目录
自定义函数
- 定义函数
def func_name(参数列表):
函数体
[return/yield 函数返回值]
- Python函数的特点
函数参数类型多样
允许嵌套函数
无需声明函数返回值类型
yield可以作为函数返回值的关键字
函数能够被赋值给变量 - Python的函数参数
无参函数
位置参数
关键字参数
包裹位置参数
包裹关键字参数
无参函数
def show_log():
print('I am a log')
show_log()
位置参数
传入的参数与定义的参数一一对应
def func_name(arg1,arg2,arg3):
print(arg1,arg2,arg3)
func_name(val1,val2,val3)
关键字参数
直接通过等号传递参数
def func_name(arg1,arg2,arg3):
print(arg1,arg2,arg3)
func_name(arg1=val1,arg3=val3,arg2=val2)
默认值参数
定义函数时,设置参数的默认值
调用函数时,可以指定通过位置或者关键字指定参数的值,如果不指定,参数为默认值
如果有未设置默认值的参数要前置
def func_name(arg1=val1,arg2=val2,arg3=val3) :
print(arg1,arg2,arg3)
func_name()
不定长参数
1.参数的个数不确定
2.可适应更加复杂情况
3.不定长参数种类
- 包裹(packing)位置参数
参数表示为*args
调用函数时,参数自动会组织成一个元组传入
传入的位置参数与组织成的元组索引位置一致
def func2( *t ) : # t is a tuple
print(t)
func2() # no argument
func2(1,2,3)
func2(1,2,3,4,5)
- 包裹(packing)关键字参数
参数表示为**kwargs
调用函数时,参数自动会组织成一个字典传入
传入的位置参数与组织成的字典的键值对一致
def func3( **d ) : # d is a dictionary
print(d)
func3() # no argument
func3(a=1, b=2, c=3)
结果为:{'a': 1, 'b': 2, 'c': 3}
- 不同类型函数参数混用顺序
位置参数
默认值参数
包裹位置参数
包裹关键字参数
def func5(x, y=10, *args, **kwargs) :
print(x, y, args, kwargs)
func5(0) :
func5(a=1, b=2, y=3, x=4)
func5(1, 2, 3, 4, a=5, b=6)
Python中函数是对象
函数可以被引用,即函数可以赋值给一个变量
函数可以当做参数传递
函数可以作返回值
函数可以嵌套
def factorial(n):
if n <= 2: return n
return factorial(n-1)*n
嵌套函数
在函数内部定义新的函数
内部函数不能被外部直接调用
函数可以被当做变量赋值,因为本质函数是一个对象
def func6() :
def nestedFunc() :
print('Hi')
return nestedFunc
装饰器
修改其他函数的功能的函数
使函数更加简洁
def my_decorator(some_func):
def wrapper(*args):
print("I am watching you!")
some_func(*args)
print("You are called.")
return wrapper
@my_decorator
def add(x, y):
print(x,'+',y,'=',x+y)
add(5,6)
全局变量
- 定义在模块中的变量
全局变量在整个模块中可见
globals()函数:返回所有定义在改模块中的全局变量
修改全局变量时,要先使用global关键字声明变量
msg = 'created in module'
def outer() :
def inner() :
global msg
msg = 'changed in inner'
inner()
outer()
print(msg)
局部变量
- nonlocal关键字
修改自由变量时,要先使用nonlocal关键字声明变量
def outer():
msg = 'created in outer'
def inner() :
nonlocal msg
msg = 'changed in inner' # msg is a Free variable
inner()
print(msg)
outer()
函数的返回值
函数无需声明返回值类型
在函数没有返回值时,函数默认返回None
return关键字用于返回返回值
- yield关键字
当函数使用yield关键字时,函数变为生成器
生成器是Python中的一种可迭代对象
能够使用for循环遍历
生成器每次只被读取一次
生成器有内置方法__next()__,调用后返回下一个元素
yield不会终止程序,返回值之后程序继续运行
#勾股定理
def list_pythagorean_triples(n) :
for c in range(n):
for a in range(1, c):
for b in range(1, c):
if a*a+b*b==c*c:
yield (a,b,c)
生成器表达式
(x**3 for x in range(10))
列表生成式
[x**3 for x in range(10)]
lambda表达式
lambda表达式是一个匿名的函数
只包含一条语句, 并自动返回这条语句的结果
f=lambda x: x * x
f(3)
# return results of +, -, *, //, % in a list
lambda x,y: [x+y, x-y, x*y, x//y, x%y]
# return max, min, sum in a tuple
lambda *n: (max(n), min(n), sum(n))
# sum 1 to n
lambda n: sum(range(1, n+1))
filter()
items=[0, 1, 2, 3, 4, 5]
list(filter(lambda x: x%2==0, items))
list(filter(None, items))
map()
i1=[1, 2, 3, 4, 5, 6]
i2=[11, 12, 13, 14]
i3=[111, 112]
list(map(lambda x,y,z: x+y+z, i1, i2, i3))
max()
max(1,2,3,4)
max([1,2,3,4])
max([1,2,3,4], key=lambda x:-x)
min()
min(1,2,3,4)
min([1,2,3,4])
min([1,2,3,4], key=lambda x:-x)
sorted()
sorted([1,2,3,4], reverse=True)
sorted([1,2,3,4], key=lambda x:-x)
正则表达式
- re模块
- 默认为贪婪匹配
re.match(’.{2,6}c’, ‘cc cc cc’) # match ‘cc cc c’ - ?为非贪婪匹配
re.match(’.{2,6}?c’, ‘cc cc cc’) # match ‘cc c’ - 0长度匹配
re.sub(‘a?’, ‘-’, ‘bb’) # result: ‘-b-b-’
re.sub(‘a*’, ‘-’, ‘bb’) # result: ‘-b-b-’ - 使用()分组
match=re.match(r'(\d+)', '123')
groups=match.groups() # groups is ('123',)
g1=match.group(1) # g1 is '123'
match=re.match(r'(\d)(\d)(\d)', '123')
groups=match.groups() # groups is ('1', '2', '3')
g1=match.group(1) # g1 is '1'
g2=match.group(2) # g2 is '2'
g3=match.group(3) # g3 is '3'
\1…\9匹配第n个分组的内容
ma = re.match(r'(\d(\d(\d)))\1\2\3', '123123233')
print(ma.groups())
?:跳过分组
ma = re.match(r'(\d(?:\d(\d)))-\2', '647-7')
print(ma.groups())
解析
初始分为三组:
组1: (\d(\d(\d))) 647-7
组2: (\d(\d(\d))) 647-7
组3: (\d(\d(\d))) 647-7
?:在组2中,所以组2被跳过了,所以有两个分组
组1: (\d(\d(\d))) 647-7
组2: (\d(\d(\d))) 647-7