Python各种函数

Python系列 评论

各种函数

内置函数

内置函数概念

内置函数就是Python解释器已经写好可以提供给用户直接使用的函数。目前Python的内置函数一共是69个。

Python内置函数

内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()

内置函数分类

  • 数据类型相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# 一、基础数据类型
bool(): 用于将给定参数转换为布尔类型，如果没有参数，返回 False。
int(): 用于将一个字符串或数字转换为整型。
float(): 用于将整数和字符串转换成浮点数。
complex(): 用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
str(): 将对象转化为字符串形式
list(): 用于将元组转换为列表。
tuple(): 将列表转换为元组。
dict(): 用于创建一个字典
set(): 用于创建一个集合
frozenset(): 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素


# 二、进制转换
bin(): 返回一个整数 int 或者长整数 long int 的二进制表示。
oct(): 将一个整数转换成8进制字符串。
hex(): 于将10进制整数转换成16进制，以字符串形式表示。


# 三、数学运算
abs(): 返回数字的绝对值。
divmod(): 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
min(): 返回给定参数的最小值，参数可以为序列
max(): 返回给定参数的最大值，参数可以为序列
sum(): 对可迭代对象进行求和计算
round(): 返回浮点数的四舍六入五留双
pow(): 返回 xy（x的y次方）的值


# 四、字符串操作
ascii(): 类似 repr() 函数, 返回一个表示对象的字符串
ord(): 以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值
chr(): 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
format(): 格式化编辑字符串
repr(): 将对象转化为供解释器读取的形式


# 五、序列操作（包含二进制序列）
bytes(): 返回一个新的数组对象，这个数组对象不能对数组元素进行修改。
bytearray(): 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围:
memoryview(): 返回给定参数的内存查看对象(Momory view)。
reversed(): 反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器
slice(): 实现切片对象，主要用在切片操作函数里的参数传递


# 六、功能性方法
len(): 返回对象（字符、列表、元组等）长度或项目个数。
sorted(): 对所有可迭代的对象进行排序操作；内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
enumerate(): 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
all(): 用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。
any(): 用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True。
zip(): 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
filter(): 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
map(): 根据提供的函数对指定序列做映射。
  • 作用域相关
1
2
globals(): 获取全局变量的字典。
locals(): 获取执行本方法所在命名空间内的局部变量的字典。
  • 迭代器、生成器相关
1
2
3
range(): 创建一个整数列表，一般用在 for 循环中。
next(): 调用可迭代对象或迭代器的next方法，取到一个元素。
iter(): 将可迭代对象转化称迭代器。
  • 面向对象相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 一、对象
object(): 返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。
id(): 返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。
hash(): 返回该对象的哈希值（如果它有的话）。
open(): 打开 file 并返回对应的 file object。
callable(): 如果参数 object 是可调用的就返回 True，否则返回 False。 
type(): 传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。

# 二、类
classmethod(): 把一个方法封装成类方法。一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。
staticmethod(): 将方法转换为静态方法。静态方法不会接收隐式的第一个参数。
isinstance(): 如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True。 如果 object 不是给定类型的对象，函数将总是返回 False。 
issubclass(): 如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True。 
super(): 返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。
property(): 返回 property 属性。fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。
vars(): 返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
  • 反射相关
1
2
3
4
hasattr(): 该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
setattr(): 此函数与 getattr() 两相对应。 其参数为一个对象、一个字符串和一个任意值。 字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性，只要对象允许这种操作。 
getattr(): 返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。
delattr(): setattr() 相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。
  • 代码执行
1
2
3
eval(): 数据字符串形式的表达式，python解释器可以直接执行。
exec(): 这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。
compile(): 将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
  • 其他
1
2
3
4
5
6
help(): 启动内置的帮助系统（此函数主要在交互式中使用）。
print(): 将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 
input(): 如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。
dir(): 如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
breakpoint(): 此函数会在调用时将你陷入调试器中。（3.7 新版功能）
__import__(): 此函数会由 import 语句发起调用。（不建议使用）

自定义函数

定义函数的流程

  • 函数定义
    关键字def引入一个函数定义。
    它必须后跟函数名称和带括号的形式参数列表。
    构成函数体的语句从下一行开始，并且必须缩进。

  • 函数体
    函数体的第一个语句可以（可选的）是字符串文字；
    这个字符串文字是函数的文档字符串或 docstring 。
    有些工具使用文档字符串自动生成在线或印刷文档，或者让用户以交互式的形式浏览代码；
    在你编写的代码中包含文档字符串是一种很好的做法，所以要养成习惯。

  • 函数执行
    函数的执行会引入一个用于函数局部变量的新符号表。
    更确切地说，函数中所有的变量赋值都将存储在局部符号表中；而变量引用会首先在局部符号表中查找，然后是外层函数的局部符号表，再然后是全局符号表，最后是内置名称的符号表。
    因此，全局变量和外层函数的变量不能在函数内部直接赋值（除非是在 global 语句中定义的全局变量，或者是在 nonlocal 语句中定义的外层函数的变量），尽管它们可以被引用。

  • 函数调用
    在函数被调用时，实际参数（实参）会被引入被调用函数的本地符号表中；
    因此，实参是通过按值调用传递的（其中值始终是对象 引用而不是对象的值）。
    当一个函数调用另外一个函数时，将会为该调用创建一个新的本地符号表。

  • 函数的使用
    函数定义会把函数名引入当前的符号表中。
    函数名称的值具有解释器将其识别为用户定义函数的类型。
    这个值可以分配给另一个名称，该名称也可以作为一个函数使用。

  • 函数返回值
    事实上，即使没有 return 语句的函数也会返回一个值, 称为 None（内置名称）。

定义函数举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# write Fibonacci series up to n
>>> def fib(n):
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Now call the function we just defined:
... fib(2000)

# return
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

嵌套函数

概念

嵌套函数（Nested function）是在另一个函数（封闭函数）中定义的函数。

原理依据

函数属于一类对象。在一个函数内部执行的def语句会定义一个局部函数并可被返回或传递。在嵌套函数中使用的自由变量可以访问包含该def语句的函数的局部变量。

示例

1
2
3
4
5
6
>>> def foo():
...     x=1
...     def bar():
...         y=2
...         print x+y
...     bar()

总结

  • python支持嵌套函数。
  • 内层函数可以访问外层函数中定义的变量，但不能重新赋值。
  • 内层函数的local namespace不包含外层函数定义的变量。

递归函数

基本概念

  • 递归函数就是函数里调用其自身。
  • 递归函数必须有一个明确的递归结束条件，称之为递归出口，否则递归深度过深会发生堆栈溢出。
  • 递归的最大深度在python中也有限制，可以通过sys.setrecursionlimit()函数进行调整，除非很清楚应如何调整，否则不建议修改默认的最大递归深度。

递归函数示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 实现阶乘：n! = 1 × 2 × 3 × … × n，或n! = (n-1)! × n

# ----------迭代的实现方式----------
>>> def factorial(n):
...     result = 1
...     for i in range(2, n+1):
...         result *= i
...     return result
... 

>>> factorial(1)
1
>>> factorial(5)
120
>>> factorial(10)
3628800

# ----------递归的实现方式----------
>>> def factorial(n):
...     if n == 1:
...         return 1
...     else:
...         return n * factorial(n - 1)
... 

>>> factorial(1)
1
>>> factorial(5)
120
>>> factorial(10)
3628800

其他说明

  • 理论上，所有的递归函数都可以写成循环的方式。
  • 解决递归调用栈溢出的方法是通过尾递归优化。尾递归是指在函数返回的时候，调用其自身，并且return语句不能包含表达式。这样解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

匿名函数 Lambda

基本概念

可以用lambda关键字来创建匿名函数。Lambda函数可以在需要函数对象的任何地方使用。它们在语法上限于单个表达式。从语义上来说，它们只是正常函数定义的语法糖。与嵌套函数定义一样，lambda函数可以引用所包含域的变量。

Lambda函数语法

函数名 = lambda 参数 ：返回值

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# ----------示例一----------
# lambda表达式来返回一个函数

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

# ----------示例二----------
# 传递一个函数作为参数

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

高阶函数

基本概念

函数的形参接受另外一个函数的函数名，则称这个函数为高阶函数。

示例

1
2
3
4
5
6
7
>>> def add(x, y, f):
...     return f(x) + f(y)

>>> print(add(-5, 6, abs))

# return
11

常用的高阶函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
1、filter()
功能：用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。
调用：filter（function，sequence）
示例：
# 找出偶数
>>> x = [1, 2, 3, 4, 5]
>>> list(filter(lambda x:x%2 == 0,x)) 

# return
[2, 4]


2、map()
功能：返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。
调用：map(function, iterable, ...)
示例：
# 计算列表各个元素的平方
>>> del square(x):
...     return x ** 2
 
>>> map(square,[1,2,3,4,5])
 
# return
[1,4,9,16,25]


3、reduce()
功能：将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。
调用：functools.reduce(function, iterable[, initializer])
示例：
# 计算列表和
>>> def add(x, y): 
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])

# return
15

偏函数

基本概念

  • 返回一个新的部分对象，当被调用时其行为类似于func附带位置参数args和关键字参数keywords被调用。 如果为调用提供了更多的参数，它们会被附加到args。如果提供了额外的关键字参数，它们会扩展并重载keywords。
  • 偏函数是将所要承载的函数作为partial()函数的第一个参数，原函数的各个参数依次作为partial()函数后续的参数，除非使用关键字参数。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# ----------无关键字参数----------
>>> from functools import partial

>>> def mod( n, m ):
...     return n % m
 
>>> mod_by_100 = partial( mod, 100 )
>>> print mod(100, 7)
# return
2
>>> print mod_by_100(7)
# return
2

# ----------有关键字参数----------
>>> from functools import partial
 
>>> bin2dec = partial( int, base=2 )
>>> print bin2dec( '0b10001' )
# return
17
>>> print bin2dec( '10001' )
# return
17
>>> hex2dec = partial( int, base=16 )
>>> print hex2dec( '0x67' )
# return
103
>>> print hex2dec( '67' )
# return
103