Python函数和正则表达式

自定义函数

• 定义函数

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