Python函数总结

函数介绍

内置函数

• 无需导包即可使用的函数
• 不同版本的Python内置函数可能略有不同

常用的内置函数

• help([object])【常用】
  启动内置的帮助系统(此函数主要在交互式中使用)。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。
• lens(s)【常用】
  返回对象的长度(元素个数)。实参可以是序列(如：string、bytes、tuple、list或range等)或集合(如 dictionary、set或frozen set等)
• filter(function,iterable)
  用iterable中函数function返回真的那些元素，构建一个新的迭代器。iterable可以是一个序列，一个支持迭代的容器，或一个迭代器。
• map(function,iterable,…)
  返回一个将function应用于iterable中每一项并输出其结果的迭代器。
• max(iterable, *[, key, default])或 max(arg1, arg2, *args[, key])
  返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
• min(iterable, *[, key, default])或 min(arg1, arg2, *args[, key])
  返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
• sorted(iterable, *, key=None, reverse=False)
  根据iterable中的项返回一个新的已排序列表。
  具有两个可选参数，他们都必须制定为关键字参数。

各版本的内置函数和使用方法参考文档

参考文档

自定义函数

定义函数

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(1,2,3)

关键字参数

直接通过等号传递参数一一对应

def func_name(arg1,arg2,arg3):
	print(arg1,arg2,arg3)
func_name(arg1=3,arg3=1,arg2=2)

默认值参数

• 定义函数时，设置参数的默认值
• 调用函数时，可以指定通过位置或者关键字指定参数的值，如果不指定，参数为默认值

def func_name(arg1,arg2,arg3=3):
    print(arg1,arg2,arg3,sep=",")#分隔符
func_name(1,2,3)

func_name(1,2)

• 不定长参数

  • 参数的个数不确定
  • 可适应更加复杂情况
  • 不定长参数种类
    • 包裹(packing)位置参数(接受不定长的位置参数，参数被组织成一个元祖传入)
    • 包裹(packing)关键字参数()

• 包裹(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)

• 不同类型函数参数混用顺序
  • 位置参数
  • 默认值参数
  • 包裹位置参数
  • 包裹关键字参数

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

x = func6()	  # x is the nestedFunc
x()

修饰器

Python中的修饰器是Python万物接对象的一种更体现，实质是在函数中定义函数，从函数中返回函数、将函数作为参数传给另一个函数。

#定义装饰器 
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)

注释:

• my_decorator 的参数是一个函数，也就是被修饰的函数add(x,y)。
• 在函数my_decorator 中定义一个函数wrapper，这个函数的参数在本例中就是add(5,6)中传来的参数。这个参数你是否要继续传给some_func使用都可以由你自己来决定，这就是修饰器的强大之处体现了。
• my_decorator的返回值就是也是一个函数，也就是wapper。
• 在使用修饰器使需要在使用@符号

变量作用域

• 变量能够生效的范围

按照作用域划分变量类型

• 全局变量
• 局部变量

全局变量

• 定义在模块中的变量
  • 全局变量在整个模块中可见
  • globals()函数
    • 返回所有定义在改模块中的全局变量
  • 修改全局变量时，要先使用global关键字声明变量

msg = 'created in module'
def outer() :
    def inner() :
        global msg
        msg = 'changed in inner'
    inner()
outer()
print(msg)

局部变量

• 定义在函数中的变量
• 局部变量尽在定义的函数中可见
  • locals()函数
  • 返回所有定义在函数中的局部变量
• 自由变量
  • 在函数中使用，但未定义在该函数中的非全局变量

def outer_1() :
    msg = 'created in outer'
    def inner() :
        print(msg)	# msg is a Free variable
    inner()
outer_1()

• 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()

LEGB规则

使用LEGB的顺序来查找一个符号对应的对象

• Local -> Enclosed -> Global -> Built-in
  • Local:一个函数或者类方法内部
  • Enclosed：嵌套函数内
  • Global：模块层级
  • Built-in：Python内置符号

type=4
def f1():
    type=3
    def f2():
        type=2
        def f3():
            type=1
            print('type=', type)
        f3()
    f2()
f1()

函数的返回值

• 函数无需声明返回值类型
• 在函数没有返回值时，函数默认返回None
• return关键字用于返回返回值

yield关键字

• 当函数使用yield关键字时，函数变为生成器
  • 生成器是Python中的一种可迭代对象
  • 能够使用for循环遍历
  • 生成器每次只被读取一次
  • 生成器有内置方法 next(),调用后返回下一个元素
• yield不会终止程序，返回值之后程序继续运行。

生成器示例

• 求斜边小于n的勾股数组合

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)

• 生成器的使用方法
  • for循环迭代生成器
  • next()函数从生成器中取值
  • 构造生成的结果列表

#使用循环迭代生成器
for i in list_pythagorean_triples(35):
    print(i)
#使用next()方法从生成器中取值
g = list_pythagorean_triples(100)
next(g)
#构造生成器的结果列表
g = list_pythagorean_triples(100)
list(g)

生成器表达式和列表生成式

• 生成器表达式

(x**3  for  x  in  range(10))

• 列表生成式

[x**3  for  x  in  range(10)]

lambda表达式

• lambda表达式是一个匿名的函数
• 只包含一条语句，并自动返回这条语句的结果

语法

lambda param1, param2, … : expression

使用示例

f=lambda x: x * x
f(3)

lambda表达式举例

# 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))

lambda表达式使用技巧

filter()函数中使用lambda表达式

• 过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
  案例演示

items=[0, 1, 2, 3, 4, 5]
list(filter(lambda x: x%2==0, items))
list(filter(None, items))

map()函数中使用lambda表达式

• 根据提供的函数对指定序列做映射
  案例演示

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()函数中使用lambda表达式

• 返回序列中的最大值

max(1,2,3,4)
max([1,2,3,4])
max([1,2,3,4], key=lambda x:-x)

min()函数中使用lambda表达式

• 返回序列中的最小值

min(1,2,3,4)
min([1,2,3,4])
min([1,2,3,4], key=lambda x:-x)

sorted()函数中使用lambda表达式

• 对序列进行排序

sorted([1,2,3,4], reverse=True)
sorted([1,2,3,4], key=lambda x:-x)