Python函数r如何定义和使用总结

函数介绍

内置函数

• 无需导包即可使用的函数
• 不同版本的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) 

本文地址：https://blog.csdn.net/lyq7269/article/details/108214812