Python三种程序结构与函数

程序结构

• 程序三种结构
  • 顺序
  • 循环
    • break:无条件结束整个循环，简称循环猝死
    • contine:继续
  • 分支

函数

• 参数：负责给函数传递一些必要的数据或者信息
  • 形参：在函数定义的时候用到的参数，没有具体值，只是一个占位符合
  • 实参：在调用函数的时候输入的值
  • 普通参数/位置参数，默认参数，关键字参数
• 返回值：调用函数的时候一个执行结果
  • 使用return返回结果
  • 使用return None 表示函数结束
  • 若函数无return关键字，默认None
• 普通参数，收集参数，关键参数
• 收集参数的解包问题
  • 把参数放入list或者字典中，之际把list/dict中的值放入收集参数中
• 函数文档
  • 函数的文档作用是对当前函数提供使用相关的参考喜喜
  • 文档的写法：
    • 在函数内部开始的第一行使用三引号定义符
    • 一般具有特定格式
    • 参考案例
  • 文档查看：
    • 使用help(函数)，形如help(func)
    • 使用doc，参考案例

benqian=1000000
year=0

while benqian<2000000:
    benqian=benqian*(1+0.067)
    year+=1
else:
    print(year,benqian) # 11 2040838.3830545251
1
2
3
4
5
6
7
8

#九九乘法表

for o in range(1,10):
    for i in range(1,o+1):
        print(str(o)+"*"+str(i)+"="+str(o*i),end=" ")
    #换行
    print()
1
2
3
4
5
6
7

1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
1
2
3
4
5
6
7
8
9

def normal_para(one,two,three):
    print(one+two)
    return None

def default_para(one,two,three=200):
    print(one+two)
    return None

def keys_para(one,two,three):
    print(one+two)
    return None

normal_para(1,2,3) # 3
default_para(1,2) # 3
keys_para(two=2,one=1,three=3) # 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def stu(name,age,*args,hobby="没有",**kwargs):
    print("Hello,大家好！")
    print("我叫{0},我今年{1}岁了".format(name,age))
    if hobby=="没有":
        print("没爱好")
    else:
        print("我的爱好是{0}".format(hobby))
        
    print("*"*20)
    
    print(type(args))
    for i in args:
        print(i)
        
    print("#"*20)
    
    print(type(kwargs))
    for k,v in kwargs.items():
        print(k,"---",v)
        
#开始调用函数
name="liuliu"
age=18

stu(name,age,"睡觉","睡觉","吃饭",hobby="数据",hobby1="三分法",weight="50kg")
'''
 Hello,大家好！
 我叫liuliu我今年18岁了
 我的爱好是数据
 ********************
 
 睡觉
 睡觉
 吃饭
 ####################
 
 hobby1 --- 三分法
 weight --- 50kg'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

def stu1(*args):
    
    '''
    这是函数文档
    '''
    print("hahaha")
    for i in args:
        print(i)

stu1("liu","ze","h",19)

l=["liu","ze","h",19]
stu1(l)
stu1(*l) #用*解包。同理dict，只是dict需要使用两个*号
 '''
 hahaha
 liu
 ze
 h
 19
 hahaha
 ['liu', 'ze', 'h', 19]
 hahaha
 liu
 ze
 h
 19'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

help(stu1)
stu1.__doc__
1
2

Help on function stu1 in module __main__:

stu1(*args)
    这是函数文档
'\n    这是函数文档\n    '
1
2
3
4
5

变量作用域

• 变量由作用范围限制
• 分类：安装作用域分类
  • 全局(global)：在函数外部定义
  • 局部(local)：在函数内部定义
• 变量的作用范围
  • 全局变量：在整个全局中都有效
  • 全局变量在局部都可以使用
  • 局部变量只在局部范围使用
• LEGB原则
  • L(local)局部作用域
  • E(Enclosing function locale)外部嵌套函数作用域
  • G(Global)函数定义所在模块作用域
  • B(Buildin)python内置模块的作用域
• 提升局部变量为全局变量
  • 使用global
• 可以通过globals和locals显示出局部变量和全局变量
• nonlocal: 用来声明外层的局部变量
  • 只能在嵌套函数中使用，在外部函数先进行声明，在内部函数进行nonlocal声明
  • 使用nonlocal声明时，对上一级进行修改
• eval()
  • 把一个字符串当成一个表达式来执行，返回表达式执行后的结果
  • 对比exec()，同作用，但exec无返回结果

a1=100
def fun():
    global b1 # 提升局部变量为全局变量
    b1=100
    b2=99
    print(a1,b1,b2)
    return None

fun() # 100 100 99
print(b1) # 100 
1
2
3
4
5
6
7
8
9
10

print(eval("100+200")) # 300
print(exec("100+200")) # None
zz=exec("print('x+y:',100+200)") # 300
1
2
3

a = 10  # 全局变量
def outer():  # 外部函数
    a = 5   # outer函数定义的局部变量
    def inner():  # 内部函数
        nonlocal a # 声明a是outer的局部变量
        a = 20
        print('inner函数中的a值:', a)

    inner()  # 调用inner函数
    print('outer函数中的a值：', a)

outer()  
# inner函数中的a值: 20
# outer函数中的a值： 20
print(' 全局变量a值：',a) # 全局变量a值:  10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

递归函数

• 递归：函数直接或者间接调用自己
• 结束条件：必要条件

def funa(n):
    if n==1:
        return 1
    s=n*funa(n-1)
    return s

def funb():
    funa(3)
    print("haha")
    
result=funa(4)
print(result) # 24
s=funb()
print(s) # gaha  None
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 斐波那契数列

def fib(n):
    if n==1 or n==2:
        return 1
    return fib(n-1)+fib(n-2)

rst=fib(10)
print(rst) # 55

#汉诺塔

a,b,c="A","B","C"
def hano(a,b,c,n):
    if n==1:
        print("{}-->{}".format(a,c))
        return 1
    if n==2:
        print("{}-->{}".format(a,c))
        print("{}-->{}".format(a,b))
        print("{}-->{}".format(b,c))
    hano(a,c,b,n-1)
    print("{}-->{}".format(a,c))
    hano(b,a,c,n-1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

hano(a,b,c,n=2)
1

A-->C
A-->B
B-->C
A-->B
A-->C
B-->C
1
2
3
4
5
6

hano(a,b,c,n=3)
1

A-->B
A-->C
C-->B
A-->C
A-->B
C-->B
A-->C
B-->C
B-->A
A-->C
B-->A
B-->C
A-->C
1
2
3
4
5
6
7
8
9
10
11
12
13

# 匿名函数
# 函数名 = lambda 形参: 返回值
res = lambda a, b: a * b
print(res(3,4)) # 12
print(3) if 3 < 4 else print(4) # 13

# 内置函数
# 查看所有的内置函数
import builtins
print(dir(builtins))
zip()  # 拉链函数  函数将可迭代对象作为参数，将里面对应的元素打包成一个个元组
map(函数, 对象)  # 映射函数 将可迭代对象中每一个元素来进行映射，分别执行函数
1
2
3
4
5
6
7
8
9
10
11
12

['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
1

# 3.拆包,元组,字典,列表皆可拆包
tu = (1, 2, 3, 4)
a, b, c, d = tu
print(a, b, c, d) # 1 2 3 4

a, *b = tu
print(a)  # 取到开头的值1
print(b)  # [2, 3, 4]

*c, d = b
print(c)   #  [2, 3]
print(d)   # 4   取到结尾的值

a, *b, c, d = tu
print(a) # 1
print(b) # [2]
print(c) # 3
print(d) # 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# reduce: 先把对象中的前两个元素取出，计算出一个值然后保存着, 接下来把这个值跟第三个元素进行计算
# reduce(函数, 对象)
# 函数： 必须接收两个参数
# 对象： 可迭代对象

li2 = [1, 2, 3, 4]

from functools import reduce

def add(x, y):
    return x - y

res = reduce(add, li2) # -8
print(res)

print(reduce(lambda a, b: a * b, [3, 6, 4])) # 72
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

闭包

• 在嵌套函数的前提下，内部函数使用了外部函数的变量，而且外部函数返回了内部函数,我们就把使用了外部函数变量的内部函数称为闭包

• 构成条件:

  • 函数中嵌套了一个函数
  • 内层函数使用了外层函数的变量
  • 外层函数的返回值是内层函数的函数名

def outer():  # 外部函数
    n = 10
    def inner():  # 内部函数

        # 在内函数中，用到了外部函数的变量
        print(n)

    # 外部函数的返回值是内部函数的函数名
    return inner


print(outer())  # 返回的是内部函数的地址 .inner at 0x0000020706DB89D8>
ot = outer() # 返回内部函数
ot()  # 调用内部函数 10 
1
2
3
4
5
6
7
8
9
10
11
12
13
14