函数
解释
函数是为了达到某种目的而采取的行为，函数是可重复使用的，用来实现某个单一功能或者功能片段的代码块，简单来说就是由一系列的程序语句组成的程序段落.
函数存在的意义:
1. 提高代码的复用性
2. 将复杂的逻辑简单化，分功能化
函数定义:
小知识 : []表示可选 <>表示必备
函数名字最好能直接表示该函数的功能，多个单词之间用_链接
<def> <函数名>([参数列表])<:>
# 待执行语句
# 如果有需要显式返回<return 标识符>或<return>
- 1.
- 2.
- 3.
定义一个简单的函数:
def func():
print('我执行了')
print('程序正常执行')
- 1.
- 2.
- 3.
- 4.
此时函数内的语句并没有执行，是不是有点不符合程序从上到下的执行顺序了?那肯定不是的，函数有个特点，只有调用了才能执行。
def func():
print('我执行了')
print('程序正常执行')
# 调用函数，函数名+()
func()
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
# 函数先调用后定义
# 抛出异常SyntaxError: invalid syntax
# func()
def func():
print('我执行了')
func()
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
程序运行的时候先把函数内的代码加载到内存中，有调用的地方直接执行，先调用的时候程序还没有读取函数到内存中，所以抛出异常。
def func():
print('嗨')
print(func)
- 1.
- 2.
- 3.
- 4.
直接打印函数就是该函数对应的内存地址。
函数的返回值
函数可以返回任何类型的数据，函数内执行到return后结束，后面代码不在执行.
def func():
res = 1+1
print('我执行了')
return res
print('我不会执行')
print('程序正常执行')
# 函数内的语句确实是执行了，打印我执行了
func()
# 想要拿到函数return的值需要重新找个变量接收一下
# 注意这里再次打印了一次我执行了 因为函数再次调用了一次
res = func()
print(res)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
# 不写return默认返回None
def func():
print('我执行了')
res = func()
print(res)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
多个返回值
多个变量接收
def func():
return 1，2，3
a，b，c = func()
print(a，b，c)
- 1.
- 2.
- 3.
- 4.
- 5.
原理一样:
一个变量接收是一个元组
def func():
return 1，2，3
res = func()
print(res)
- 1.
- 2.
- 3.
- 4.
- 5.
一样的
参数
假如现在咱们要计算两个数字的和。
def sue_for_peace():
res = 3+3
return res
print(sue_for_peace())
- 1.
- 2.
- 3.
- 4.
- 5.
如果要计算不同数字的和就需要参数传递了
默认的按位置传递(位置一一对应)
def sue_for_peace(num1，num2): res = num1+num2 return resprint(sue_for_peace(3，3))
def sue_for_peace(num1，num2):
res = num1+num2
return res
print(sue_for_peace(3，3))
- 1.
- 2.
- 3.
- 4.
- 5.
关键字传参(参数名对应)
def sue_for_peace(num1，num2):
print(num1，num2)
res = num1+num2
return res
print(sue_for_peace(num2=3，num1 = 4))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
混合使用(先位置参数再关键字参数)
def sue_for_peace(num1，num2，num3):
print(num1，num2，num3)
res = num1+num2+num3
return res
print(sue_for_peace(3，num3=1，num2 = 2))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
默认值(不传递参数就是用默认值，传递了就是用传递的值)
def sue_for_peace(num1=1，num2=2):
print(num1，num2)
res = num1+num2
return res
print(sue_for_peace())
print(sue_for_peace(5，10))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
混合使用时，先按位置传递参数，后按关键字传递参数，最后是默认值
错误示范:
def sue_for_peace(num1=1，num2，num3): # 第一行这里就错了，默认值只能再最后，编辑器报错
print(num1，num2，num3)
res = num1+num2+num3
return res
print(sue_for_peace(2，3))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
def sue_for_peace(num1， num2， num3=3):
print(num1， num2， num3)
res = num1+num2+num3
return res
print(sue_for_peace(num2=2，3)) # 先位置后关键字，编辑器报错
print(sue_for_peace(1，num1=2)) # 不允许给同一个形参传两个值
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
可变参数(多个不确定的参数)
*列表 **字典
通常都是这样子的:*args，**kwargs
def sue_for_peace(*args):
res = 0
for i in args:
res += i
return res
# 任意个 0个也没错
print(sue_for_peace())
print(sue_for_peace(1， 2， 3， 4， 5))
# 假如已经有一个列表了
li = [1， 2， 3， 4， 5]
# 这样不是把列表当作一个参数来传递了，会自动解释为多个参数
print(sue_for_peace(*li))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
def func(**kwargs):
return kwargs
print(func())
print(func(name='sb'，age=22))
print(func(**{'name':'sb'，'age':22}))
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
一般都是这样子的:
def func(x，y，z，*args，**kwargs):
print(x)
print(y)
print(z)
print(args)
print(kwargs)
func(1， 2， 3， 4， 5， 6， a=11， b=22)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
可变类型参数的传递
def func(li):
li[0] = 666
li = [1， 2， 3， 4， 5]
func(li)
print(li)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
可以发现实参传递给形参，形参发生改变，实参跟着发生改变
不可变类型的传递
def func(str1):
str1 = 'aaa'
print('函数内:'， str1)
str1 = 'hell0'
func(str1)
print(str1)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
不要被相同的变量名字迷惑了...
全局变量和局部变量
局部可以使用全局变量，全局变量可以再模块(也就是这个文件)的任何地方使用，局部变量是在函数内部声明并使用的数据量，随函数的启动而出生，随函数的退出而消亡，作用域在函数内
局部可以使用全局变量
temp = 'hello'
def test():
print(temp)
- 1.
- 2.
- 3.
全局不能使用局部变量
def test():
temp = 'hello'
print(temp)
# print(temp)
# NameError: name 'temp' is not defined
- 1.
- 2.
- 3.
- 4.
- 5.
temp = '你好'
def test():
temp = 'hello'
print(temp)
print(temp)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
temp = '你好'
def test():
temp = 'hello'
print(temp)
test()
print(temp)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
看例子猜答案，皮一下，很开心。
num = 1
def set_num(in_num):
num = in_num
pass
set_num(11)
print(num)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
声明使用全局变量(global)
num = 1
def set_num(in_num):
global num
num = in_num
pass
set_num(11)
print(num)
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
全局变量，局部变量重名，仍需要用全局变量。
num = 11
def test():
num = 22
# 这个是局部num
print(num)
# 打印全局num
print(globals()['num'])
test()
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.