Python常用内置函数

Python 作为一门高级编程语言，为我们提供了许多方便易用的内置函数，节省了不少开发应用的时间。目前，Python 3.7 共有 69 个内置函数，一些是我们耳熟能详的函数，另一些却不是很常见，这里主要介绍一些新手必备函数及其用法。

我把这些内置函数中常用的大致的地分为八大类：

输入输出	print() open()  input()
迭代相关	enumerate()  zip()
序列属性	sum()  max()  min()  len()
操作序列	sorted()  reversed()  range()
对象属性	dir()  id()  isinstance()  type()
映射类型	eval()  map()  slice()
数值计算	abs(), all(). any(), pow(), divmod()
其他	exec(), __import__()

一、输入输出

1.print 函数将对象输出至控制台

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

value为可变参数，可以接受任意多个对象。sep 参数表示输出对象之间的分隔符，默认为空格。

print('人生苦短', '我用Python')
人生苦短 我用Python

分隔符为'+'

print('人生苦短', '我用Python', sep='+')
人生苦短+我用Python

格式化输出字符串的三种方式：

name = '飞凡空间'
print('公众号：%s'%name)
公众号：飞凡空间
print('公众号：{}'.format(name))
公众号：飞凡空间
print(f'公众号：{name}')
公众号：飞凡空间

2. open 函数打开文件并返回文件对象

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file 为文件地址，mode 为打开文件的模式，默认为 'r'，表示读取文件，常用的还有：'w' 表示写入文件、'b' 表示以二进制形式打开。常用上下文管理器 with 打开文件，f.read( ) 读取全部内容，f.readline() 读取一行内容。

with open('test.txt', 'r') as f:
   text1 = f.read()

with open('test.txt', 'r') as f:
   text2 = ''
   line = f.readline()
   while line:
       text2 += line
       line = f.readline()

assert text1 == text2
print(text1)

###############
输出内容：
人生苦短 我用Python
人生苦短 我用Python
人生苦短 我用Python
人生苦短 我用Python
###############

有时候，我们读取文件还会遇到乱码问题，可以指定编码格式：

当文件中有中文的时候，使用 'utf-8' 编码会导致异常：UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb8 in position 7: invalid start byte

with open('test.txt', 'r', encoding='utf-8') as f:
   text1 = f.read()

 这时候，我们可以尝试 'gb2312' 或者 'gbk' 编码来打开含有中文字符的文件。这时，便可以成功打开文件。　

with open('test.txt', 'r', encoding='gb2312') as f:
   text1 = f.read()

with open('test.txt', 'w', encoding='gbk') as f:
   f.write('人生苦短 我用Python')

3. input 函数获取控制台输入　

input([prompt])

input 可接受字符串为参数，提示用户输入。   

name = input('请输入你的名字：')
请输入你的名字：>? 张亚飞
name
Out[11]: '张亚飞'

二、迭代相关

1. enumerate 函数返回元素的序号与对应值

enumerate(iterable, start=0)

iterable 参数表示可迭代对象，start 参数是元素序号的起点，默认为 0。enumerate 函数的等价形式如下：

def enumerate(sequence, start=0):
	n = start
	for elem in sequence:
	 yield n, elem
	 n += 1

seq = ['P', 'y', 't', 'h', 'o', 'n']
for i, elem in enumerate(seq):
	print(i, elem)

2. zip 函数用于同时迭代多个对象

zip(*iterables)

*iterable 可以接受任意多个可迭代对象

a = ["**", '**', '**']
b = ['微信公众号', '关注', '飞凡空间']
c = a
print('#'*20)
for i, j, k in zip(a, b, c):
   print(i, j, k)
print('#'*20)


####################
** 微信公众号 **
** 关注 **
** Python飞凡空间 **
####################

三、序列属性

• 序列最大值：max
• 序列最小值：min
• 序列的和：   sum
• 序列长度：   len

基本用法：向这四个函数中传入序列，可以得到对应属性。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
print(max(seq))
# 88
print(min(seq))
# 21
print(sum(seq))
# 545
print(len(seq))
# 10

作为内置函数，可以直接传入生成器（不需要括号）作为参数：

import random
random.seed(21)
num = max(random.randint(0, 100) for i in range(10))
print(num)
# 88

可传入 key 参数，作为比较大小的依据，相当于把序列中每一个元素 item 先传入函数 key 中，将函数返回的数值作为判断对象大小的依据。

def foo(x):
   return 1. / x
max(seq, key = foo)
# 21

对于我们自定义的类型，必须实现特殊方法，才能进行 len 等操作。

__len__ 代表：len 操作，__eq__ 代表：= 操作，__lt__ 代表 < 操作。

class foo:
   def __init__(self, num, seq):
       self.num = num
       self.seq = seq
       
   def __len__(self):
       return len(self.seq)
       
   def __eq__(self, other):
       return self.num == other.num
       
   def __lt__(self, other):
       return self.num < other.num

f1 = foo(18, [1, 4, 6])
f2 = foo(21, [1, 7, 9, 10])
f1 < f2
True
f1 > f2
False
f1 == f2
False
f3 = foo(18, [9, 9, 0, 7])
f1 == f3
True
en(f1)
3
len(f2)
4

四、操作序列

    1. range 函数生成序列

range(start, stop[, step])

• start 可选参数，默认为 0 ，表示序列起点

• stop 必选参数，表示序列终点，不包括终点

• step 可选参数，序列的步长，默认为 1

range(5)
Out[12]: range(0, 5)
list(range(5))
Out[13]: [0, 1, 2, 3, 4]
list(range(1, 5))
Out[14]: [1, 2, 3, 4]
list(range(1, 10, 2))
Out[15]: [1, 3, 5, 7, 9]

range 函数生成的对象可以迭代，和列表很类似，_ 表示废弃变量（为了避免污染变量环境）：

In[16]: for _ in range(3):
   ...:     print('我们就别再分离')
   ...:     
我们就别再分离
我们就别再分离
我们就别再分离
 

2. reversed 函数可以将序列逆置

reversed 可以将序列逆置，包括元组、字符串、列表。对于列表和字符串的逆置，使用 list[::-1] 或者slice()更加方便。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
reversed(seq)
print(list(reversed(seq)))
# [65, 60, 27, 61, 36, 81, 53, 88, 53, 21]

 字符串逆置：

a = '我爱你'
a[::-1]
Out[18]: '你爱我'
reversed(a)
Out[19]: <reversed at 0xd3f24aa390>
''.join(reversed(a))
Out[20]: '你爱我'

3. sorted 函数可以对序列进行排序

sorted(iterable, *, key=None, reverse=False)

sorted 不同于 list.sort 操作（原地排序），返回一个新的有序序列，原序列保持不变。* 表示仅限关键字参数(keyword-only)，也就是说，key、reverse 参数只能通过关键字传参，而不能通过位置传参。reverve 参数表示逆置操作，key 与之前 len 中的 key 参数类似，是函数排序的依据。 

sorted([9, 6, 2, 3, 6])
[2, 3, 6, 6, 9]

五、对象属性

• dir 函数返回属性列表
• id  函数返回对象地址
• isinstance  判断对象的类型
• type 返回对象的类型

class foo:
   pass

>>> dir(foo)
['__class__',
'__delattr__',
'__dict__',
'__dir__',
......
'__str__',
'__subclasshook__',
'__weakref__']
# 创建实例
>>> f = foo()
>>> type(foo)
__main__.foo
>>> isinstance(f, foo)
True
>>> id(f)
2135099584864

六、映射类型

• eval 解除引号的束缚
• map 应用函数于单个对象
• slice 生成切片

eval 可以去除字符串的单引号，从而获取引号内部内容。下面的演示展示了，如何使用 eval 函数获取字符串中的字典：

>>> info = '{"name": "LiHua", "age": 12}'
>>> eval(info)
{'name': 'LiHua', 'age': 12}
>>> info_dict = eval(info)
>>> type(info_dict)
dict
 

map 将传进来的函数应用于序列中的每一个元素，并返回迭代器。

map(function, iterable, ...)

举例来说,map 就是对 seq 列表中的每一个元素 item 进行 int 操作(int(item))。匿名函数同理，就是对序列中的每一个元素进行加 2 的操作。

seq = [1.5, 4.5, 9.1]
list(map(int, seq))
[1, 4, 9]
list(map(lambda x: x + 2, seq))
[3.5, 6.5, 11.1]

slice 函数为切片操作命名，使得切片操作更加清晰明了。

slice(start, stop[, step])

start 为起点，stop 为终点，step 为步长。使用该操作，使得截取有规律的文本内容变得很轻松。特别是长文本，使用 slice 函数更加清晰易懂。

>>> text = '微信公众号 飞凡空间'
>>> name = slice(0, 6)
>>> text[name]
微信公众号 
>>> content = slice(6, 16)
>>> text[content]
飞凡空间　

七、数值计算

1. abs(x)

返回一个数的绝对值。实参可以是整数或浮点数。如果实参是一个复数，返回它的模。

2. all(iterable)

如果 iterable 的所有元素为真（或迭代器为空），返回 True 。等价于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True　

3. any(iterable)

如果*iterable*的任一元素为真则返回``True``。如果迭代器为空，返回``False``。等价于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False　　

4. divmod(a, b)

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

divmod(10, 3)
Out[21]: (3, 1)

5. pow(x, y[, z])

返回 x 的 y 次幂；如果 z 存在，则对 z 取余（比直接 pow(x, y) % z 计算更高效）。两个参数形式的 pow(x,y) 等价于幂运算符： x**y。

参数必须为数值类型。 对于混用的操作数类型，则适用二元算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10**2 返回 100，但 10**-2 返回 0.01。 如果第二个参数为负值，则第三个参数必须省略。 如果存在 z，则 x 和 y 必须为整数类型，且 y 必须为非负数。

pow(2,3,7)
Out[26]: 1
pow(2,3)
Out[27]: 8

八、其他

1. exec(object[, globals[, locals]])

这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。[1] 如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的（见参考手册中关于文件输入的章节）。请注意即使在传递给 exec() 函数的代码的上下文中，return 和 yield 语句也不能在函数定义之外使用。该函数返回值是 None。

无论哪种情况，如果省略了可选参数，代码将在当前范围内执行。如果提供了 globals 参数，就必须是字典类型，而且会被用作全局和本地变量。如果同时提供了 globals 和 locals 参数，它们分别被用作全局和本地变量。如果提供了 locals 参数，则它可以是任何映射型的对象。请记住在模块层级，全局和本地变量是相同的字典。如果 exec 有两个不同的 globals 和 locals 对象，代码就像嵌入在类定义中一样执行。

如果 globals 字典不包含 __builtins__ 键值，则将为该键插入对内建 builtins 模块字典的引用。因此，在将执行的代码传递给 exec() 之前，可以通过将自己的 __builtins__ 字典插入到 globals 中来控制可以使用哪些内置代码。

exec('import os')
os.getcwd()
Out[25]: 'E:\\爬虫\\spider_project'

2. __import__: 动态导入模块

__import__(name, globals=None, locals=None, fromlist=(), level=0)

注解

与 importlib.import_module() 不同，这是一个日常 Python 编程中不需要用到的高级函数。

此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是 强烈 不建议这样做，因为使用导入钩子 (参见 PEP 302) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。 同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。

该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。 标准实现完全不使用其 locals 参数，而仅使用 globals 参数来确定 import 语句的包上下文。

level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 __import__() 的目录，将要搜索的父目录层数 (详情参见 PEP 328)。

当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而 不是以 name 命名的模块。 但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名的模块。

例如，语句 import spam 的结果将为与以下代码作用相同的字节码:

spam = __import__('spam', globals(), locals(), [], 0)

语句 import spam.ham 的结果将为以下调用:

spam = __import__('spam.ham', globals(), locals(), [], 0)

请注意在这里 __import__() 是如何返回顶层模块的，因为这是通过 import 语句被绑定到特定名称的对象。

另一方面，语句 from spam.ham import eggs, sausage as saus 的结果将为

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在这里， spam.ham 模块会由 __import__() 返回。 要导入的对象将从此对象中提取并赋值给它们对应的名称。

如果您只想按名称导入模块（可能在包中），请使用 importlib.import_module()