Python函数

qq_42052864

已于 2022-07-30 17:37:21 修改

阅读量137

点赞数

分类专栏： python基础文章标签： python

于 2022-07-30 17:22:12 首次发布

本文链接：https://blog.csdn.net/qq_42052864/article/details/126074499

版权

python基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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

#九九乘法表

for o in range(1,10):
    for i in range(1,o+1):
        print(str(o)+"*"+str(i)+"="+str(o*i),end=" ")
    #换行
    print()

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

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

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岁了
 我的爱好是数据
 ********************
 <class 'tuple'>
 睡觉
 睡觉
 吃饭
 ####################
 <class 'dict'>
 hobby1 --- 三分法
 weight --- 50kg'''

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'''

help(stu1)
stu1.__doc__

Help on function stu1 in module __main__:

stu1(*args)
    这是函数文档
'\n    这是函数文档\n    '

变量作用域

变量由作用范围限制
分类：安装作用域分类
- 全局(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

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

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

递归函数

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

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

# 斐波那契数列

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)

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

A-->C
A-->B
B-->C
A-->B
A-->C
B-->C

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

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

# 匿名函数
# 函数名 = 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(函数, 对象)  # 映射函数 将可迭代对象中每一个元素来进行映射，分别执行函数

['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']

# 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

# 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

闭包

在嵌套函数的前提下，内部函数使用了外部函数的变量，而且外部函数返回了内部函数,我们就把使用了外部函数变量的内部函数称为闭包
构成条件:
- 函数中嵌套了一个函数
- 内层函数使用了外层函数的变量
- 外层函数的返回值是内层函数的函数名

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

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

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


print(outer())  # 返回的是内部函数的地址 <function outer.<locals>.inner at 0x0000020706DB89D8>
ot = outer() # 返回内部函数
ot()  # 调用内部函数 10