一、函数的定义
对代码块和功能的封装和定义
二、函数的定义语法
def 函数名():
函数体
def yue():
print("123")函数的调用：使用函数名可以调用函数，写法：函数名()，这个时候函数体就会被执行
yue()执行过程
函数的返回
执行完函数之后，我们可以使用return来返回结果
1.函数中遇到return，此函数结束，不再继续执行
def yue(): print("约你") print("约我") print("约他") return print("约谁呀") # 这句话不会被执⾏ yue()2.给函数的调用者一个访问结果
def yue(): print("约你") print("约我") print("约他") return "美⼥⼀枚" girl = yue() print(girl) # 美⼥⼀枚3.函数的返回值可以是多个
def yue(): print("123") print("345") return"第一个结果","第二个结果" girl = yue() print(type(girl)) #类型是tuple总结一下
1.遇到return，此函数结束，函数后面的东西不会被执行
2.return返回值：
如果return什么都不写 或者干脆不写return，那么返回值是None
如果return后面写了一个值，则调用者可以接受到一个结果
如果return后面写了多个值，则调用者可以接收一个tuple，调用者可以直接解构成多个变量
4.函数的参数
参数，函数再调用的时候指定具体的一个变量的值，语法：
def 函数名(参数列表):
函数体def yue(chat):
print("拿出手机")
print("打开"+chat)
yue("微信")
yue("默默")形参
写在函数声明的位置的变量叫形参,形式上的一个完整,表示这个函数需要xxx
实参
在函数调用的时候给函数传递的值,叫实参,实际执行的时候给函数传递的信息,表示给函数xxx
传参
给函数传递信息的时候将实际参数交给形式参数的过程称为传参
def yue(chat): # chat 形参 print("拿出⼿机") print("打开"+chat) print("找个漂亮的妹⼦") print("约不约") yue("陌陌") # 实参 len("字符串") # "字符串"在这⾥就是实参 print("麻花藤") # "麻花藤"就是实参]()
函数名:命名规则和变量一样
函数的返回值:
return,函数执行完毕,不会执行后面的逻辑
1.如果函数中不写return返回None
2.只写return 返回None
3.return返回值,返回一个值
4.return 值1,值2,... 返回多个值,调用方接收到的是元祖(tuple)
参数:
在函数执行的时候给函数传递的参数
1.形参:
1.位置参数.
2.默认值参数.当调用的时候不给传值使用默认值
3.混合使用.顺序: 1.位置参数, 2.默认值参数
2.实参:
1.位置参数.按照位置给形参赋值
2.关键字参数.按照名称给形参赋值
3.混合参数.先用位置参数,再用关键字参数
例子
编写函数,给函数传递两个参数a,b 比较a, b的大小
def my_max(a,b):
if a > b:
return a
else:
return b
#有点麻烦,用一个三元运算符
def my_max(a,b):
c = a if a > b else b #当 a>b 成立返回a,否则返回b
return c
l = my_max(11,22)
print(l)关键字参数
def yue(chat, address, age): print("拿出⼿机") print("打开"+chat) print("找个"+address+"附近漂亮的"+str(age)+"岁妹⼦") print("约不约") yue(chat="微信", age=18, address="北京") # 关键字参数.混合参数
# 混合参数 yue("微信", age=18, address="上海") # 正确.第⼀个位置赋值给chat, 后⾯的参数开始 指定关键字.默认值参数
def stu_info(name,age,sex='男'): print("录入学生的信息") print(name,age,sex) print("录入完毕") stu_info("张强",12)
函数的进阶
函数参数–动态传参
一.动态参数分为两种
1.动态接收位置参数
def func(*args): print("我要吃",args) func("炸鸡","汉堡") 结果: 我要吃('炸鸡','汉堡') #多个参数传进去,收到的内容是tupledef chi( *food, a, b): # 可以传入任意的位置参数 print("我要吃", food,a,b) # 动态参数接收到的是tuple类型的数据 chi("盖浇饭", "辣条", a = "面条",b = "啊啊")位置参数> *args > 默认值参数 > **kwargs
关键字参数一定在位置参数后面
def func(a, b, c, *args, d = 5):
print(a, b, c, d, args)
func(1,2,3)
func(1,2,3,4,5,6,7, d ="马大哈")1.例子
# 写函数. 给函数传递任意个整数. 返回这些数的和
def he(*n):
sum = 0
for e in n:
sum += e
return sum
print(he(5)) 2.动态接收关键字参数
*位置参数
**关键字参数
def func(**food): # **food动态接收关键字参数
print(food) # 接收到的是字典
func(good_food="盖浇饭", bad_food="辣条", drink="冰封") 这个函数可以接收所有的参数(无敌的)
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 5, 6, name="taibai",age=18, sex="不详")- 动态参数的另一种穿传参方式:
def fun(*args):
print(args)
lst = [1, 4, 7]
fun(lst[0], lst[1], lst[2])
fun(*lst) # 可以使⽤*把⼀个列表按顺序打散
s = "⾂妾做不到"
fun(*s) # 字符串也可以打散, (可迭代对象)在实参位置给一个序列,列表,可迭代对象前面加个*表示把这个序列按顺序打散
在形参的位置上的*表示把接收到的参数组合成一个元组
如果是一个字典,那么也可以打散,不过需要两个**
def fun(**kwargs):
print(kwargs)
dic = {'a':1, 'b':2}
fun(**dic)二.命名空间
在Python解释器开始执行之后,就会在内存中开辟一个空间,每当遇到一个变量的时候,就把变量名和值之间的关系记录下来,但是当遇到函数定义的时候,解释器只是把函数名读入内存,表示这个函数存在了,至于函数内部的变量和逻辑,解释器不关心这个,也就是说一开始的时候函数只是加载进来,仅此而已,只有当函数被调用和访问的时候.解释器才会根据函数内部声明的变量来进行开辟变量的内部空间.随着函数执行完毕.这些函数内部变量占用的空间也会随着函数执行完毕而被清空
- 在形参上* 聚合,**聚合
- 在实参上*打散, **打散
1.命名空间的分类:
a.内置命名空间–>Python解释内部运行时的变量函数
b.全局命名空间–>我们在py文件中直接声明出来的变量,函数
c.局部命名空间–>在函数内部声明的变量和函数
取值顺序:1.局部命名空间 2. 全局命名空间 3. 内置命名空间
三.作用域
作用域就是作用范围
1.全局作用域–>内置+全局
2.局部作用域–>局部(在函数内部使用)
globals() 查看全局作用域中的名字
locals() 查看当前作用域的名字
a = 10
def func():
a = 40
b = 20
def abc():
print("哈哈")
print(a, b) # 这⾥使⽤的是局部作⽤域
print(globals()) # 打印全局作⽤域中的内容
print(locals()) # 打印局部作⽤域中的内容
func()四.函数嵌套
只要遇见了()就是函数的调用, 如果没有() 就不是函数的调用
函数的执行顺序
函数的嵌套
a = 1 def fun_1(): a = 2 def fun_2(): def fun_3(): nonlocal a a = 4 print(a) print(a) fun_3() print(a) print(a) fun_2() print(a) print(a) fun_1() print(a) 结果:1 2 2 4 4 4 1
五.关键字 global 和 nonlocal
global 表示把全局变量拿到局部来用
def func():
global a # a 不再是局部变量. 是全局变量
a = 30 # 把全局中的a重新赋值成30
print(a)
func()
print(a) nonlocal 把离他最近的一层的变量拿过来,不会找全局
a = 10
def func1():
def func2():
nonlocal a # 找局部作用域中 离他最近的那个变量引入进来
a = 20
print(a)
func2()
print(a)
func1()
