10函数基础和进阶

#函数
##01函数基础
###1.定义函数和调用
def 函数名([输入参数]):
函数体

def say_hi():print("你好")print("很高兴认识你")return "小姐姐","萝莉","御姐"
girl &＃61; say_hi()
print(girl)


注意&＃xff1a;1.return 返回的是元组&＃xff08;tuple&＃xff09;&＃xff0c;返回给调用者。2.函数执行遇到return不会继续向下执行 3.如果return什么都不写&＃xff0c;返回的结果就是None

函数的调用&＃xff1a;函数名()就可以调用函数
###2.函数的参数
函数()内的就是参数
####参数的分类
1.形参&＃xff1a;写在函数声明的位置的变量叫形参&＃xff0c;形式上是一个完整的&＃xff0c;表示这个函数需要的具体内容 2.实参&＃xff1a;在函数调用时给函数传递的值&＃xff0c;实际执行的时候给函数传递的信息&＃xff0c;表示给函数具体的内容 3.传参&＃xff1a;给函数传递信息的时候将实际参数交给形式参数的过程叫做传参
位置参数
def eat(chat,addr,age): # 三个形参 聊天工具 地址 年龄 print("拿出手机") print("打开" &＃43; chat) print(str(age) &＃43; "岁的"&＃43; "小姐姐") print("要不要一起去" &＃43; addr &＃43; "吃饭") eat("微信","青岛",18) # 实参

三元运算符

c &＃61; a if a > b else b # 当a > b赋值给c 否则就把b赋值给creturn c
print(f(1,9)) # 9


关键字传参

print("拿出手机")print("打开" &＃43; chat)print(str(age) &＃43; "岁的"&＃43; "小姐姐")print("要不要一起去" &＃43; addr &＃43; "吃饭")
eat(chat &＃61; "微信",addr &＃61; "青岛",age &＃61; 18) # 实参


混合参数

print("拿出手机")print("打开" &＃43; chat)print(str(age) &＃43; "岁的"&＃43; "小姐姐")print("要不要一起去" &＃43; addr &＃43; "吃饭")
eat("微信",addr &＃61; "上海",age &＃61; 18)


关键字参数后面只能是关键字参数&＃xff0c;位置参数必须放在关键字参数的前面

默认值参数

def stu_info(name,age,sex &＃61; "男"): # 学生信息 默认参数必须写在最后面print(name,age,sex)return sex,"录入完毕"
a &＃61; stu_info("张强","18")
print(a)


动态接收关键字参数
在参数位置用*表示接受任意参数
打包&＃xff08;成元组&＃xff0c;字典或者列表&＃xff09;和解包&＃xff08;拆解成单个元素&＃xff09;
**用于字典的打包和解拆 用于元组和列表的打包和解包&＃xff08;非关键字参数传参&＃xff09;

def tuple_pack(a,*b):print(a)print(b)
tuple_pack(1,2,3) # 1 (2, 3)


def dict_pack(a,**b): # 只能用关键字传参print(a)print(b)
# dict_pack(1,2,3) # 报错
dict_pack(1,one &＃61; 1,two &＃61; 2,three &＃61; 3) # 1 {&＃39;one&＃39;: 1, &＃39;two&＃39;: 2, &＃39;three&＃39;: 3}def tuple_dict_pack(a,*b,**c):print(a)print(b)print(c)
tuple_dict_pack(1,2,3,one &＃61; 1,two &＃61; 2,three &＃61; 3) #1 (2, 3) {&＃39;one&＃39;: 1, &＃39;two&＃39;: 2, &＃39;three&＃39;: 3}#拆解
def tuple_dict_unpack(*a,**b):print(a)print(b)
ee &＃61; (1,2,3)
ff &＃61; {"one":1,"two":2,"three":3}
tuple_dict_unpack(*ee,**ff) # (1, 2, 3) {&＃39;one&＃39;: 1, &＃39;two&＃39;: 2, &＃39;three&＃39;: 3}


02函数进阶

###1.动态接收位置参数

def eat(*a):# 在定义函数时用打包print("我想吃",a)print(*a) # 在函数体内用解包
eat("米饭","中米饭")def eat(a,b,*c):print("我想吃",a,b,c)print(*c)
eat("大米饭","小米饭","米饭") # 我想吃 大米饭 小米饭 (&＃39;米饭&＃39;,) 米饭


###默认值参数

def eat(a,b,*c,d &＃61; "白菜"): # 默认值参数必须放最后面 否则会被覆盖
# print("我想吃",a,b,c,d)
# print(*c)
# eat("大米饭","小米饭","米饭")
# 形参的顺序 位置参数 动态参数 默认参数
# 位置参数 > args&＃xff08;动态位置参数&＃xff09; > 默认值参数 > kwargs(动态关键字参数)


动态接收关键字参数

def fun(**a):print(a)
fun(a &＃61; 1,b &＃61; 2) # {&＃39;a&＃39;: 1, &＃39;b&＃39;: 2}def func(a,b,c,d):print(a,b,c,d)
func(1,2,c &＃61; 3,d &＃61; 6) # 1 2 3 6


###想要接收所有的参数

def func(*args,**kwargs):print(args,kwargs)
func(1,23,4,a &＃61; 1,b &＃61; 2) # (1, 23, 4) {&＃39;a&＃39;: 1, &＃39;b&＃39;: 2}


###动态参数的传参

# 方法一
lst &＃61; [1,4,7]
def func(*args):print(args)
func(lst[0],lst[1],lst[2]) # (1, 4, 7)# 方法二
def func(*args):print(args)
func(*lst) # (1, 4, 7) # 在实参的位置上用*将lst&＃xff08;可迭代对象&＃xff09; 在形参的位置上用*把收到的参数组合成一个元组# 字典也可以打散 用**
dic &＃61; {"a":1,"b":2}
def fun(**kwargs):print(kwargs)
fun(**dic) # {&＃39;a&＃39;: 1, &＃39;b&＃39;: 2}


###函数的注释
def eat(food,drink):
“”"
这里描述当前函数式用来干什么的
:param food: food这个参数是什么意思&＃xff0c;用来接收什么&＃xff1f;食物
:param drink:
:return: 函数执行完返回给调用者的具体的内容
“”"
print(food,drink)
return “星期三”
print(eat(“麻辣汤”,“coco”)) # 麻辣汤 coco 星期三

在外部查看函数内注释
print(eat.doc)

###名称空间
def fun():
a &＃61; 10
print(a)
fun() # 10
命名空间 存放名字和值的关系的空间
分类&＃xff1a;
全局命名空间&＃xff1a;我们直接在python文件中&＃xff0c;函数外声明的变量
局部命名空间&＃xff1a;在函数中声明的变量
内置命名空间&＃xff1a;存放python解释器为我们提供的名字 list(),tuple(),str,int,这些都是内置命名空间 关键字不是
import keyword
print(keyword.kwlist) [‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
import builtins # 内置函数
print(dir(builtins))

加载顺序&＃xff1a;内置命名空间———>全局命名空间————>局部命名空间
取值顺序&＃xff1a;局部命名空间数值————>全局————>内置
a &＃61; 10
def func():
a &＃61; 20
print(a)
func() 20 先去20后取10

作用域&＃xff1a;作用范围&＃xff0c;按照生效范围分为 全局作用域和局部作用域

#全局作用域&＃xff1a;包括内置命名空间和全局作用空间&＃xff0c;在整个文件的任何位置都可以使用&＃xff08;遵循从上到下逐行执行&＃xff09;
#局部作用域&＃xff1a;在函数内部执行

作用域命名空间
全局作用用域&＃xff1a;全局命名空间&＃43;内置命名空间
局部作用用域&＃xff1a;局部命名空间

a &＃61; 10
def func():a &＃61; 40b &＃61; 20print("哈哈")print(a,b)print(globals()) # 打印全局作用用域中的内容print(locals()) # {&＃39;a&＃39;: 40, &＃39;b&＃39;: 20}
func()


###函数嵌套
只要遇到了&＃xff08;&＃xff09;就是函数的调用&＃xff0c;如果没有就不是调用

def func1():print(111)
def func2():print(222)func1()def func3():print(666)print(444)func3()print(8888)
func2()# global 全局声明变量 global宗旨&＃xff1a;在函数内部修改全局的变量&＃xff0c;如果全局不存在就创建一个变量
# lst &＃61; ["马化腾","刘嘉玲","詹姆斯"]
# def func():
# lst.append("马云")
# # 对于可变数据类型可以直接进行访问
# func()
# print(lst)# nonlocal 非局部声明变量 宗旨&＃xff1a;只修改上一层变量&＃xff0c;如果上一层没有变量就再往上找一层&＃xff0c;只会找到函数的最外层&＃xff0c;不会找到全局进行修改
# a &＃61; 10
# def func1():
# a &＃61; 20
# def func2():
# nonlocal a #改了a &＃61; 20
# a &＃61; 30
# print(a)
# func2()
# print(a)
# func1() # 加nonlocal 结果为30 30 不加结果为30 20


a &＃61; 1
def fun1():a &＃61; 2def fun2():nonlocal aa &＃61; 3def fun3():a &＃61; 4print(a)print(a)fun3()print(a)print(a)fun2()print(a)
print(a)
fun1()
print(a)![image](https://img2022.cnblogs.com/blog/2787076/202204/2787076-20220420233309968-1881174593.jpg)