06 python开发之函数
- 06 python开发之函数
-
6 函数
-
6.1 基本使用
-
6.2 调用函数与函数返回值
- 6.2.1 调用函数三种形式
- 6.2.2 函数的返回值return(函数的产品)
-
6.3 Type hinting
-
6.4 函数参数
- 6.4.1 函数分类
-
6.4.2 参数详解
- 6.4.2.1 位置形参
- 6.4.2.2 位置实参
- 6.4.2.3 默认形参
- 6.4.2.4 关键字实参
- 6.4.3 实参的混用
- 6.4.4 形参的混用
- 6.4.5 默认形参使用的注意点
-
6.5 可变长函数(*与**的应用)
- 6.5.1 由来
-
6.5.2 在形参中使用
- 6.5.2.1 *args的使用
- 6.5.2.2 **kwargs的使用
-
6.5.3 在实参中使用
- 6.5.3.1 *的使用
- 6.5.3.2 **的使用
- 6.5.4 混用
- 6.5.5 命名关键字形参
-
6.6 函数对象
- 6.6.1可以赋值
- 6.6.2 可以当作参数传给另一个函数
- 6.6.3 可以当一个函数的返回值
- 6.6.4 可以当容器类型的元素
- 6.6.5 示例
-
6.7 函数嵌套
- 6.7.1 函数嵌套定义
- 6.7.2 函数嵌套调用
-
6.8 名称空间与作用域
- 6.8.1 名称空间
- 6.8.2 名字的查找顺序
- 6.8.3 global与nonlocal
- 6.8.4 作用域
-
6.9 闭包函数
-
6.10 装饰器
- 6.10.1 简介
- 6.10.2 无参装饰器
- 6.10.3 装饰器的语法糖@
- 6.10.4 有参装饰器
- 6.10.5 叠加多个装饰器
- 6.10.6 wraps装饰器
- 6.10.7 匿名函数lambda
- 6.11 内置函数
-
6.12 迭代器
- 6.12.1 迭代器概述
- 6.12.2 使用迭代器
- 6.12.3 迭代器优缺点
- 6.12.4 可迭代对象
- 6.12.5 迭代器对象
-
6.13 生成器
-
6.14 三元表达式
- 6.14.1 语法
- 6.14.2 使用场景
-
6.14.3 生成式
- 6.14.3.1 列表生成式
- 6.14.3.2 字典生成式
- 6.14.3.3 集合生成式
-
6.14.4 生成器表达式
- 6.14.4.1 创建生成器对象的两种方式
- 6.14.4.2 较列表生成式的比较
- 6.14.4.3 使用
- 6.14.5 附录a.txt
-
6.15 面向过程编程
- 6.15.1 面向过程简介
- 6.15.2 总结
- 6.15.3 应用场景
-
6.16 函数递归
- 6.16.1 基本概念
- 6.16.2 示例
- 6.16.3 回溯与递推
- 6.13.4 总结
6 函数
6.1 基本使用
6.1.1 基本概念
-
函数就是用来盛放代码的容器
? 具备某一功能的工具-->工具
? 实现准备好工具的过程-->函数的定义
? 遇到应用场景，拿来就用
-
使用函数可以解决代码可读性差以及拓展性差的问题
-
先定义后引用
6.1.2 定义函数
def 函数名(参数1,参数2,...):
"""文档描述"""
函数体
return 值
# def: 定义函数的关键字；
# 函数名：函数名指向函数内存地址，是对函数体代码的引用。函数的命名应该反映出函数的功能；
# 括号：括号内定义参数，参数是可有可无的，且无需指定参数的类型；
# 冒号：括号后要加冒号，然后在下一行开始缩进编写函数体的代码；
# """文档描述""": 描述函数功能，参数介绍等信息的文档，非必要，但是建议加上，从而增强函数的可读性；
# 函数体：由语句和表达式组成；
# return 值：定义函数的返回值，return是可有可无的。
def say_hello(): # say_hello=函数的内存地址
print("======")
print("hello world")
print("======")
print(say_hello) # <function say_hello at 0x00000241DA0273A0>
say_hello()
x = 10 # x=10的内存地址
print(x)
# 函数定义阶段:只检测语法，不执行代码
def foo():
xxx
print('from foo')
# 函数调用阶段:执行函数体代码
foo()
示例1
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo() # from foo | from bar
示例二
def bar():
print('from bar')
foo()
def foo():
print('from foo')
bar() # from bar | from foo
示例三
def bar():
print('from bar')
foo()
bar() # 报错，要先定义后引用
def foo():
print('from foo')
-
定义函数的三种形式
# 无参函数
def f1():
print("hello")
print("你好")
print("Hi")
f1() # hello | 你好 | Hi
def login():
name = input('username>>>:').strip()
pwd = input('password>>>:').strip()
if name == "ccc" and pwd == '111':
print('ok')
else:
print('error')
login() # username>>>:
def login(name,pwd):
if name == "ccc" and pwd == "123":
print('ok')
else:
print('error')
login("ccc","123") # ok
login("ccc","1234") # error
def f2(x,y):
print(x)
print(y)
f2(111,222) # 111 | 222
def add(x,y):
print(x+y)
add(10,20) # 30
add(30,40) # 70
def login():
pass
def transfer():
pass
def withdraw():
pass
def check_balance():
pass
6.2 调用函数与函数返回值
6.2.1 调用函数三种形式
len("hello")
res = len("hello") + 10
print(res) # 15
def add(x,y):
z = x + y
return z
print(add(5,5)) # 10
res = add(add(1,2),3)
print(res) # 6
6.2.2 函数的返回值return(函数的产品)
Ⅰ 没有return-->默认返回就是None
def func():
print(111)
res = func() # 111
print(res) # None
Ⅱ return 值-->返回就是那一个值
def max2(x,y):
if x > y:
return x
else:
return y
res = max2(100,200) * 5
print(res) # 1000
Ⅲ return 值1,值2,值3--->返回的是一个元组
def func():
return [11,22],2,3
res = func()
print(res,type(res)) # ([11,3) <class 'tuple'>
- return作用2:函数内可以有多个return,但只要执行一个就会立即种植函数的运行，并且会将return后的值当做本次调用的产品返回
def func():
print(111)
return 2201202
print(2222)
return 11112222
print(3333)
res = func()
print(res) # 111 2201202
-
return就是函数的处理结果
函数内没有return关键字，或者说return后面没有值-->None
-
return 值
return 值1,值3--->(值1,值3)
-
可以有多个return，但只要执行一次整个函数就会立即结束，并且返回值
def f1():
x = 10
def f2():
print('from f2')
return f2
res = f1() # 即res=f2的内存地址
print(res) # <function f1.<locals>.f2 at 0x000001F5886D8700>
res() # from f2
6.3 Type hinting
6.3.1 定义
6.3.2 使用
# Type hinting
def add(x: int,y: int) -> int:
res = x + y
return res
print(add.__annotations__)
# {'x': <class 'int'>,'y': <class 'int'>,'return': <class 'int'>}
6.4 函数参数
6.4.1 函数分类
-
形参
在定义函数时，在括号内指定参数/变量名，称之为形式参数，简称形参
形参的本质就是变量名
-
实参
在调用函数时，括号内传入的值，称之为实际参数，简称实参
实参的本质就是变量值
-
实参与形参的关系
在调用函数时，实参的值会绑定给形参，该绑定关系可以在函数内使用
在函数调用结束后，会解除绑定关系
6.4.2 参数详解
6.4.2.1 位置形参
def func(x,y):
print(x,y)
func(1,2)
func(1,3) # 报错
func(1) # 报错
6.4.2.2 位置实参
def func(x,2)
func(2,1)
6.4.2.3 默认形参
def func(x,y=111):
print(x,2) # 1 2
func(1) # 1 111
def register(name,age,gender="male"):
print(name,gender)
register("egon",18)
register("lxx",38)
register("hxx",32,"female")
register("李建国",30)
register("alex",31)
register("xxx",18)
# egon 18 male
# lxx 38 male
# hxx 32 female
# 李建国 30 male
# alex 31 male
# xxx 18 male
6.4.2.4 关键字实参
def func(x,y=2222):
print(x,y)
func(y=222,x=1212) # 1212 222
func(x=111) # 111 2222
6.4.3 实参的混用
-
位置实参和关键字实参可以混用，注意点:
Ⅰ 位置实参必须放在关键字实参前面
Ⅱ 不能为同一个形参重复赋值
def func(x,y=2) # 1 2
func(y=2,1) # 报错
func(1,y=2,x=3) # 报错
6.4.4 形参的混用
-
位置形参和默认形参可以混用，注意点:
位置形参必须放在默认形参前面
def func(x,y)
def func(y=111,x): # 报错
print(x,y)
6.4.5 默认形参使用的注意点
m = 222
def func(x,y=m):
print(x,y)
m = 666
func(111) # 得到111 222
def register(name,hobby,hobbies=[]):
hobbies.append(hobby)
print('%s 的爱好是 %s' %(name,hobbies))
def register(name,hobbies=None):
if hobbies is None:
hobbies=[]
hobbies.append(hobby)
print('%s 的爱好是 %s' %(name,hobbies))
register("egon","smoke")
register("lxx","dance")
register("hxx","drink")
6.5 可变长函数(*与**的应用)
6.5.1 由来
6.5.2 在形参中使用
6.5.2.1 *args的使用
- 在形参中带*，*会将溢出的位置实参汇总成元组，然后赋值给其后变量名args
def func(x,y,*z):
print(x,z)
func(1,3,4,5) # 1 2 (3,5)
func(1,2) # 1 2 ()
func(1) # 报错
def my_sum(*args):
res = 0
for i in args:
res += i
print(res)
my_sum(1) # 1
my_sum(1,2) # 3
my_sum(1,3) # 6
6.5.2.2 **kwargs的使用
- 在形参中带**，**通常会将溢出的关键字实参汇总成字典，然后赋值给其后变量名kwargs
def func(x,**kwargs):
print(x,kwargs)
func(1,a=1,b=2,c=3) # 1 2 {'a': 1,'b': 2,'c': 3}
6.5.3 在实参中使用
6.5.3.1 *的使用
- 在实参中带*:*会将紧跟其后的实参打散成位置实参
- 注意*后跟的应该是一个可以被for循环循环的类型
def func(a,b,c,d):
print(a,d)
func(*"hello") # 报错，不对应
func(*"hell") # h e l l
func(*[11,22,33,44]) # 11 22 33 44
func(11,*[33,*{"k1": 111,"k2": 222}) # 11 22 k1 k2
6.5.3.2 **的使用
|
