python之函数基础总结

定义：函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

def sayhi(name):
    print("Hello, %s, I', nobody " % name)
 
print(sayhi)  # 函数内存地址
sayhi('Aldx')  # 执行这个函数

参数 
形参和实参必须是一一对应的
 
默认参数
默认参数必须放到最后面。这只为了避免歧义，假设你传了三个参数，country='CN'在第三个，那么解释器就分不清楚你传给谁了，所以为了不影响位置参数，强制默认参数放在最后。

def stu_register(name, age, course, country='CN'):  # 形参，相当于占位，用完后内存会自动释放。
    print('resiger infomation......')
    print(name, age, country, course)
 
stu_register('Alex', 22, 'python')  # 实参，必须是字符串、列表、数字、字典、元组等数据类型。

关键字参数
关键字参数可以不按顺序。但关键字参数有一个要求就是必须放在位置参数(以位置顺序确定对应关系的参数)之后。

def stu_register(name, age, course, country='CN'):
    print('resiger infomation......')
    print(name, age, country, course)
 
stu_register('王山炮', country='PY', age=22, course='Go语言')
 
# 错误示例
stu_register('网山炮', country='PY', 22, course='Go语言')  # 关键字参数不能放在默认参数前面
stu_register('王山炮', 22, age=25, course='Go语言')  # 不能给一个参数同时接受两个值

非固定参数

元组形式
def send_alert(msg, *users):
    for u in users:
        print('报警发送给%s,%s' % (u, msg))
 
'''如果参数中出现*(*users),传递的参数就可以不再是固定个数，传递过来的所有参数都会被打包成元组，发送给users。用users有些非主流，主流用法(专业用法)是写成*args '''
# 方式一
send_alert('内存占用率达到90%', 'alex', 'jack', 'ann', 'wusir')
 
# 方式二(错误的)
send_alert('内存占用率达到90%', ['alex', 'jack', 'ann', 'wusir'])  # 相当于这样了(['alex', 'jack', 'ann', 'wusir'])，循环出来就一个值，是一个列表。
 
# 方式三(和方式一的效果一样)
send_alert('内存占用率达到90%', *['alex', 'jack', 'ann', 'wusir'])
 
# 错误示例：
def send_alert(msg, *args, age):
    for u in args:
        print('报警发送给%s,%s' % (u, msg))
 
# send_alert('alex', 'rain', 22)  # 因为把值都给了users了，age没有值了.
# 正确的方法
send_alert('alex', 'rain', 'snow', age=22)  # age不能放在*args前面

def area(name, *args):
    print(args) # (20, 10)
    print(*args) # 20 10  # 加*能消除元组
 
    def rectangle(long, short):
        return long * short
 
    def square(len_of_side):
        return len_of_side * len_of_side
 
    def cycle(radis):
        return 3.14 * radis ** radis
 
    if name == '圆形':
        return cycle(*args)
    elif name == '正方形':
        return square(*args)
    elif name == '长方形':
        return rectangle(*args)
    else:
        print('输入非法')
 
a = area('长方形', 20, 10)
print(a)

dic = {"k1:": "v1v1", "k2": [11, 22, 33, 44]}
 
def check_length(*args, **kwargs):
    print(kwargs)
    dic = {}
    for key in kwargs:
        if len(kwargs[key]) > 2:
            kwargs[key] = kwargs[key][0:2]
            dic[key] = kwargs[key]
    return dic
 
dic2 = check_length(**dic)  # 传入dic就是一个空字典

字典形式

def func(name, *args,):
    print(name, args)
 
func('Alex', 22, 'tesla', '500w', addr='山东', num=1232131)  # 报错
 
def func(name, *args, **kwargs):
    print(name, args, kwargs)
 
d = {'degree': 'primary school'}
# func('Alex', 22, 'tesla', '500w', addr='山东', num=1232131)  # Alex (22, 'tesla', '500w') {'addr': '山东', 'num': 1232131}
func('wusir', d)  # wusir ({'degree': 'primary school'},) {}  # 传到args里面了
func('wusir', **d)  # wusir () {'degree': 'primary school'}

函数返回值
默认是返回None。return代表一个函数的终止，一遇到return，函数就结束了，后面的就不执行了。

def stu_register(name, age, course, country='CN'):
    print('-----注册学生信息-----')
    print('姓名:', name)
    print('年龄:', age)
    print("国籍:", country)
    print('课程:', course)
 
    # 函数永远只返回一个值
    # return name, age # ('王山炮', 22)
    # return [name,age] # ['王山炮', 22]
    # return {name, age}  # {'王山炮', 22}
 
    if age > 22:
        return False  # 任何东西都可以返回，返回的要是外面想要拿到的结果。
    else:
        return True
 
registriation_status = stu_register('王山炮', 22, course='python后台开发', country='JP')
 
if registriation_status:
    print('\n注册成功')
else:
    print('\n年龄太大')
print(registriation_status)

全局变量和局部变量

name = 'Black girl'
 
def change_name():
    # print(name) # 'Black girl' # 没有局部变量就调用全局的，有局部变量会先调用局部变量
 
    name = '黑色的姑娘'
    print("在", name, "里面......", id(name))
 
def func2():
    name = 'rain'
 
change_name()  # 在 黑色的姑娘 里面...... 4327858536
print(name, id(name))  # Black girl 4327737776

在函数里面改全局变量(在实际开发中不建议使用,不好调试)

name = 'Black girl'
 
def change_name():
    global name  # 先声明修改的全局变量，在修改
    name = '黑色的姑娘'
    age = 25
    print("在", name, "里面......", id(name))
 
change_name()  # 在 黑色的姑娘 里面...... 4327858536
print(name, id(name))  # 黑色的姑娘 4327858536

在函数里修改列表数据
字典、列表、对象是可以被修改的

names = ['Alex', 'Black Girl', 'Peiqi']
 
def change_name():
    # names = ['aa', 'bb', 'cc']  # 无法修改全局的names
 
    del names[2]
    names[1] = '黑姑娘'
    print(names)
 
change_name()  # ['Alex', '黑姑娘']
print(names)  # ['Alex', '黑姑娘']

在函数里调用names只是调用了其整体的内存地址，里面元素的内存地址和整体是不一样的，所以里面元素可以修改，给这个列表整体赋值是不可以的。

嵌套函数

例1
def func1():
    print('alex')
 
    def func2():
        print('eric')
 
    func2()
 
# 1.函数内部可以再次定义函数
# 2.执行需要被调用
 
例2
age = 19
 
def func1():
    def func2():
        print(age)
 
    age = 73
    func2()
 
func1()  #
age = 73 在func1内，执行的时候func2中的print(age)会先从func1里找，所以print出的是73
 
例3
 
age = 19
 
def func1():
    def func2():
        print(age)
 
    func2()
    age = 73
 
func1()  # 报错
# 原因是因为在执行print(age)的时候，它会往上找，本来会找age = 19,但是下面(func2()下面)还有一个age = 73,所以它就会不知道找哪个。
# 解决方案：1.不写age = 73. 2.把age = 73写到func2()上面  3.在 def func2():上加上global age,这样age = 73把全局的age就给修改了。

作用域
在python中，一个函数就是一个作用域,和javascript一样，局部变量放置在其作用域中。
C#,Java中的作用域是 {}
定义完成后，作用域已经生成，作用域链向上查找

age = 18
 
def func1():
    age = 73
 
    def func2():
        print(age)
 
    return func2  # 函数名可以当做返回值∂
 
val = func1()
val()  # 不管函数名在哪里，只要一执行，它永远回到它最开始的地方执行，从本函数开始往上找变量。

匿名函数
一般和其他方法搭配使用，用完一次就不用了，所以没有必要给它起名。

def calc(x, y):
    if x < y:
        return x * y
    else:
        return x / y
 
calc2 = lambda x, y: x * y if x < y else x / y  # 声明一个匿名函数,只能支持到三元运算，不支持复杂的语句。
print(calc(16, 8))  # 2.0
print(calc2(16, 8))  # 2.0
 
data = list(range(10))
print(data)
 
times = map(lambda x: x * x, data)
print(list(times))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

高阶函数
只需满足以下任意一个条件，即是高阶函数
1.接收1个或多个函数作为输入 
2.return返回另外一个函数，比如返回abs,x,y

def func(x, y):
    return x + y
 
def calc(x):
    return x
 
f = calc(func)
print(f(3, 5)) #