01. - 函数 - 函数简介
(1).函数
函数也是一个对象
函数就是可以用来保存一些可以执行的代码,并且可以在需要的时候,对这些代码(语句)进行多次调用
语法
def 函数名([形参1,形参2…]):
代码块
函数中保存的代码块不会立即执行,需要调用函数代码才会执行
(2). 调用函数
**函数对象()**
定义一个函数
def fn():
print('这个是我们第一个函数')
print('哈哈哈')
print('同学们好')
print('又到了周末')
print(fn) # <function fn at 0x000001E2E9A43EA0> # 这个是fn,是函数对象
# fn是:函数对象 , fn()是:调用函数
fn()
fn()
fn()
fn()
>>> # 这个是fn(),是调用函数
这个是我们第一个函数
哈哈哈
同学们好
又到了周末
这个是我们第一个函数
哈哈哈
同学们好
又到了周末
这个是我们第一个函数
哈哈哈
同学们好
又到了周末
这个是我们第一个函数
哈哈哈
同学们好
又到了周末
02.- 函数 - 函数的参数
函数名必须按照标识符的命名规范
(可以包含字母, 数字,下混线 ,但是不能以数字开头)
函数的参数:
在定义函数的时候,可以在函数后面的括号定义不等的形参
多个形式我们用逗号隔开
形参(形式餐宿) 定义形参就相当于在函数内部声明了变量,但不是赋值
实参(实际参数) 指定了形参,那么你在调用函数的时候必须传递实际参数,实际参数将会赋值给对应的形参,就是你有几个形参就需要传递几个实参
定义一个函数 求任意两个数的和
def fn(a,b):
print(a,'+',b,'=',a+b)
fn(2,3)
fn(222,666)
>>>
2 + 3 = 5
222 + 666 = 888
03. - 函数 - 函数的传递方式
1.默认值
定义形参的时候可以给形参指定默认值
指定了默认值之后,如果用户传递了实参默认值不会发挥任何作用
如果用户没有传递,则默认值会发挥作用
def fn(a,b,c = 20):
print('a =',a)
print('b =',b)
print('c =',c)
fn(1,2,3) # a = 1 b = 2 c = 3 # 指定了默认值之后,如果用户传递了实参默认值不会发挥任何作用
fn(1,2) # a = 1 b = 2 c = 20 # 如果用户没有传递,则默认值会发挥作用
2.实参的传递方式:
(1) - 位置参数(例如:def fn2 (a,b)?
(fn2(2,3) 把2赋值给a,把3复制给b
位置参数就是将对应位置的实参赋值给对应位置的形参
第一个实参赋值给形参,第二个实参赋值给第二个形参…
def fn(b = 5,a = 10,c = 20):
print('a =',a)
print('b =',b)
print('c =',c)
# 位置参数和关键字参数可以混合使用
# 混合使用的时候关键字和位置参数时,必须将位置参数写到关键字参数前面
fn() # a = 10 b = 5 c = 20
fn(c = 8,1) # SyntaxError: positional argument follows keyword argument
fn(1,c = 8) # a = 10 b = 1 c = 8
(2) - 关键字参数
关键字参数,可以不按照形参定义的顺序去传递,而是根据参数名去传递
def fn(a = 5,b = 10,c = 20):
print('a =',a)
print('b =',b)
print('c =',c)
fn(b = 1,c = 2,a = 3) # a = 3 b = 1 c = 2
以下都是关键字传递方式
例如: with open(‘xxx’,‘wb’,encoding=‘utf-8’,newline=)
例如:print(‘1211’,end=’’)
04. - 函数 - 实参的类型
实参的类型
实参可以传递任意类型的对象
def fn():
print('这个是我们第一个函数')
print('哈哈哈')
print('同学们好')
print('又到了周末')
def fn2(a):
print('a =',a)
b = 123 # a = 123 # 实参是什么类型(int,str,bool,float)都可以传递
b = 'python' # a = python
b = None # a = None
b = False # b = False
fn2(b) # a = 123
fn2(fn) # fn后面要不要加括号？这个时候 fn 是作为一个实参来传递，
这个时候 fn 不是在调用函数 # a = <function fn at 0x0000019AB46F3EA0>
# 这个打印结果就是 我们这个 fn 所指向的内存地址
def fn3(a,b):
print(a + b)
fn3(132,456)
>>>
588
(1).
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
a = 20
print('a =',a)
c = 10
fn4(c)
print('c =',c)
>>>
a = 20
c = 10
(2).
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
a = 20
print('a =',a)
c = [1,2,3]
fn4(c)
print('c =',c)
>>>
a = 20
c = [1, 2, 3]
(3).
ef fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
a[0] = 50
print('a =',a)
c = [1,2,3]
fn4(c)
print('c =',c)
>>>
a = [50, 2, 3]
c = [50, 2, 3]
(4).
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
a = [4,5,6]
print('a =',a)
c = [1,2,3]
fn4(c)
print('c =',c)
>>>a = [4, 5, 6]
c = [1, 2, 3]
(5).以下一个例子是错误演示:
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
a = [4,5,6]
print('a =',a)
c[1] = 22
fn4(c)
print('c =',c)
>>>
NameError: name 'c' is not defined # 打印结果出现错误
(6).
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
# a = 20
a[0] = 50
print('a =',a,id(a))
c = 10
c = [1,2,3]
fn4(c)
print('c =',c,id(c))
>>> # 这个时候 a 和 c指向的是一个对象
a = [50, 2, 3] 2715341369096
c = [50, 2, 3] 2715341369096
(7). 总结:如果你在传递的是一个可变对象的时候,而你又不希望我在函数内部的操作影响到函数外部的时候,那么你就可以考虑传递一个副本.
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
# a = 20
a[0] = 50
print('a =',a,id(a))
c = 10
c = [1,2,3]
fn4(c.copy()) # 通过潜复制 c 来传递一个副本
print('c =',c,id(c))
>>>
a = [50, 2, 3] 2113919144904
c = [1, 2, 3] 2113951510280
(8). 总结:如果你在传递的是一个可变对象的时候,而你又不希望我在函数内部的操作影响到函数外部的时候,那么你就可以考虑传递一个副本.
def fn4(a):
# 在函数中对形参进行重新赋值,不会影响其他的变量
# a = 20
a[0] = 50
print('a =',a,id(a))
c = 10
c = [1,2,3]
fn4(c[:]) # 通过对 c 进行切片来传递一个副本
print('c =',c,id(c))
>>>
a = [50, 2, 3] 2190246106056
c = [1, 2, 3] 2190246948616
05. - 函数 - 不定长参数
(1).
def sum(a,b):
print(a + b) # 57
sum(12,45)
def sum(a,b): # 这里传的是两个形参
print(a + b)
sum(12,45,46) # 这里传的是三个实参 # TypeError: sum() takes 2 positional arguments but 3 were given(类型错误:sum()接受2个位置参数，但给出了3个)
解决办法:
def sum(a,b,c): # 传三个形参
print(a + b + c)
sum(12,45,46) # 103 # 传三个实参
(2).不定长参数
在定义函数时,可以在形参前边加一个*号,这样做的好处是这个形参可以获取到所有的实参
它将会吧所有的实参保存到一个元组当中
定义一个函数,求任意数的和
def fn(*a):
print('a =',a,type(a)) # a = (1, 2, 3, 4, 5, 6, 7) <class 'tuple'>
fn(1,2,3,4,5,6,7)
(3).定义一个函数,求任意个数的和
def sum(*a):
# 定义一个变量,用来保存结果
result = 0
# 遍历元组,并将元组中的数进行计算
for n in a:
result = result + n
print(result)
sum(9,13,14,19,33,34,44,99) # 265
(4).不定长参数也可以和其他参数配合使用
def fn2(a,b,*c):
print('a =',a)
print('b =',b)
print('c =',c)
fn2(1,2,3,4,5)
>>>
a = 1
b = 2
c = (3, 4, 5)
(5). 不定长参数不是必须写在最后,但是要注意,带*号的参数后面所有的参数,必须以关键字的参数形式(a = 1,b = 2,c = 3)传递
def fn2(a,*b,c):
print('a =',a)
print('b =',b)
print('c =',c)
fn2(1,2,3,4,c = 5)
>>>
a = 1
b = (2, 3, 4)
c = 5
def fn2(*a,b,c):
print('a =',a)
print('b =',b)
print('c =',c)
fn2(1,2,3,b = 4,c = 5)
>>>
a = (1, 2, 3)
b = 4
c = 5
(6) ** 这种形参可以接受其他的关键字参数,它会将这些参数统一保存到一个字典当中
自定的key就是关键字的名字,字典的value就是参数的值
def fn3(**a):
print('a = ',a) # a = {'b': 1, 'd': 2, 'c': 3}
fn3(b = 1,d = 2,c = 3)
(7). ** 这种形参只能有一个,并且必须写在所有参数后面
def fn3(d,c,**a):
print('a = ',a) # a = {'b': 1}
fn3(b = 1,d = 2,c = 3)
(8). (*a处理位置参数, **a处理的是关键字参数(a = 1,b = 2))
def fn3(b,c,**a):
print('a = ',a)
print('b =',b)
print('c =',c)
fn3(b = 1,d = 2,c = 3,e = 5,f = 20)
>>>
a = {'d': 2, 'e': 5, 'f': 20}
b = 1
c = 3
06. - 函数 - 函数的解包
1.参数的解包
def fn4(a,b,c):
print('a = ',a)
print('b =',b)
print('c =',c)
# 创建一个元组
t = (10,20,30)
# t = (10,20,30,40)
fn4(t[0],t[1],t[2]) # a = 10 b = 20 c = 30
# 传递形参 , 也可以在序列类型的参数添加*号,这样他会自动将序列当中的元素以此作为参数传递
# 这里要求序列当中元素的个数必须和形参的个数保持一致(# t = (10,20,30,40))
fn4(*t) # a = 10 b = 20 c = 30
ef fn4(a,b,c):
print('a = ',a)
print('b =',b)
print('c =',c)
# 创建一个字典
d = {'a':1,'b':2,'c':3}
fn4(**d)
>>>
a = 1
b = 2
c = 3
扫一扫
1641
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
