python常用内置函数和关键字

常用内置方法

在Python中有许许多多的内置方法，就是一些Python内置的函数，它们是我们日常中经常可以使用的到的一些基础的工具，可以方便我们的工作。

查看所有的内置类和内置方法

# 方法一
built_list = dir(__builtins__)

# 方法二
import builtins
built_list = dir(builtins)

其中，以Error或者Warning等是Python中的异常类（关于异常可以参考后面的异常学习），以__开头和结尾的是内置的一些魔术方法（关于魔术方法可以参考面向对象的学习）、剩余的就是一些常用的内置类和方法。

标准输入输出

print -- 打印内容（标准输出）

打印（输出）指定的内容，可以打印多内容（多个参数）

语法：print(*args)

参数	说明
*args	输出的内容，数量任意，任何内容都可以；
sep	指定输出内容之间的间隔符，必须是字符串，默认为一个空格；
end	最后追加的内容，使用print之后最后追加的内容，必须是字符串，默认是一个换行符 \n；
file	将输出的内容写入指定的文件对象中。

# 常规用法
print(1)  # 1
print(1, 2, 3)  # 1 2 3

# sep参数
print(1, 2, 3)  # 1 2 3
print(1, 2, 3, sep=' MSR ')  # 1 MSR 2 MSR 3

# end参数
print(1, 2)
print(3, 4)
'''
1 2
3 4
'''
print(1, 2, end='')
print(3, 4)
'''
1 23 4
'''

# file参数
fp = open('test.txt', 'w', encoding='UTF-8')
print('Hello Word.', file=fp)

input -- 输入

返回输入的结果，返回的结果为字符串类型；输入时，接收到enter（回车）时将输入内容返回；

input_content = input()  # 输入 -- Hello MSR.
print(input_content)  # Hello MSR.

# 可以在input中输入内容，作为交互信息（就是一个标准输出）
input('请输入你的银行卡密码：')

数学

abs -- 绝对值

返回数字的绝对值,唯一参数必须说是数字类型，即：int float bool complex

res = abs(-100)
print(res)  # 100

res = abs(True)
print(res)  # 1

round -- 四舍五入

返回一个十进制数字四舍五入后的结果

参数	说明
number	四舍五入的数字
ndigits	保留的小数位数，默认为None，即不保留小数

# 不保留小数
res = round(10.6)
print(res)  # 11

# 保留小数，保留的最小位四舍五入
res = round(10.567, 2)
print(res)  # 10.57

# ！！！
# 如果数字为n.5的时候，n为奇数才会5入，否则后面还要更多的小数位才能是我们理解当中的样子，也就是必须实际的大于.5这个临界值，可以使用标准库decimal处理掉这个问题。
res = round(4.5)
print(res)  # 4
res = round(3.5)
print(res)  # 4

res = round(4.51)
print(res)  # 5
res = round(3.51)
print(res)  # 4

# 多位小数情况正好相反，只有偶数才会5入
res = round(4.35, 1)
print(res)  # 4.3
res = round(4.45, 1)
print(res)  # 4.5
res = round(4.555, 2)
print(res)  # 4.55
res = round(4.665, 2)
print(res)  # 4.67

pow -- 幂运算

计算一个数值的N次幂

语法：pow(parameter1,parameter2,[parameter3])

参数一表示运算数，参数二表示幂次方数，参数三表示被除数，计算幂运算结果除法余数；

# 还记得python的幂运算符嘛？
res = pow(2, 3)
print(res)        # 8
print(2 * 2 * 2)  # 8
print(2 ** 3)     # 8

# 除法求余数
res = pow(2, 3, 3)
print(res)    # 2
print(8 % 3)  # 2

序列

sum -- 序列和

计算一个容器（字符串除外）中的数字之和，容器中的数据必须都是数字类型

lst = [1, 2, 3, 4]
res = sum(lst)
print(res)  # 10

max & min -- 获取序列中的最大值和最小值

max获取序列中的最大值，min获取序列中的最小值，max&min属于高阶函数；

语法：max(parameter1,[parameter2, parameter3, ...],key=None)

参数	说明
parameter1	指定的序列，容器类型数据（包括字符串）
parameter2...	多个值，可以是多个参数一，这些值可以是数值或者是序列
key	函数名，容器中的值的计算方式，按照此计算方式返回值，默认为None，即单纯的比数字大小；

# 不指定key
lst = [0, 1, 2, 3, 4]
res = max(lst)  # 4
res = min(lst)  # 0

# 多参数
# 1、参数可以不只一个，但是多个参数必须相同的数据类型，比较参数中的第一个参数返回数据，但是众序列中的第一个参数都必须是相同的数据类型，如果是字符串，比如ABC之间的比较是根据ASCII码进行的。
lst1 = [0, 100]
lst2 = [2, 10]
print(max(lst1, lst2))  # [2, 10]
print(min(lst1, lst2))  # [0, 100]
# 2、参数可以不是容器类型数据，可以直接比较多个数字（其实也就是元组了）
print(max(1, 2, 3))  # 3
print(min(1, 2, 3))  # 1

# 指定key，经过key指定的函数处理，比较返回的结果,然后返回对应的数据
lst = [0, 1, 2, 3, 4]

def func(num):
    return num * -1

res = max(lst, key=func)  # 0
print(res)
res = min(lst, key=func)  # 4
print(res)

sorted -- 序列排序

对一个序列中的值进行排序，默认按照升序（从小到大）排列；数字按照大小排序，ASCII字符串按照编码顺序排序，其余字符的排序规律不清，可能是按照某个指定的编码的先后进行排序。

语法：sorted(parameter1, key=None, reverse=False)

参数	说明
parameter1	指定排序的序列数据
key	指定排序的方法，使用方法和max等一众高阶函数的方法是一样的；
reverse	排序方式，默认为False， 即为升序，True为降序；

# 使用list为例
lst = [2, 0, 1, 3, 4]

# 默认为升序
new_lst = sorted(lst)
print(new_lst)  # [0, 1, 2, 3, 4]

# 降序
new_lst = sorted(lst, reverse=True)
print(new_lst)  # [4, 3, 2, 1, 0]


# 注意和list内置方法的区别，list.sort方法在原数据上重新排序，sorted方法返回一个新的数据；
lst1 = [1, 0, 3]
lst1.sort()
print(lst1)  # [0, 1, 3]

lst2 = [1, 0, 3]
new_lst2 = sorted(lst2)
print(lst2)  # [1, 0, 3]
print(new_lst2)  # [0, 1, 3]

zip -- 多序列同索引组合

enumerate -- 枚举

zip & enmerate 见推导式。

进制数转换

还记得如何直接表示一个非十进制数字吗？

• 0b 开头表示二进制数；
• 0o 开头表示八进制数；
• 0h 开头表示十六进制数；

bin -- 将其它进制的数转成二进制数

# 十进制数 转 二进制
res = bin(255)
print(res)  # 0b11111111

# 八进制 转 二进制
res = bin(0o377)
print(res)  # 0b11111111

# 十六进制 转 二进制
res = bin(0xff)
print(res)  # 0b11111111

oct -- 将数转为八进制数

hex -- 将数转为十六进制数

ASCII字符编码转换

还记得ASCII编码吗？下面的函数可以将ASCII编码中包含的字符在字符和序号之间转换

chr -- 将ASCII序号转成字符

# 返回 97 号字符
res = chr(97)
print(res)  # a

ord -- 将字符转回ASCII序号

res = ord('A')
print(res)  # 65

其它

dir -- 返回指定位置的类、函数、变量

默认返回当前位置的类、函数、变量。

# 定义函数
def func():
    pass

# 定义类
class Class:
    pass

# 定义变量
var = 1

# 返回属于当前位置（文件）的类、函数、变量
res = dir()
print(res)  # ['Class', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'func', 'var']



def func1():
    inner_var = 1  # 内置变量（属于函数func1）
    print(dir())  # 返回输入当前位置（函数func1）的类、函数、变量
func1()  # ['inner_var']

range -- 生成指定范围整数的可迭代对象

range本身不是一个函数，而是一个类，但是在日常的使用过程中经常被作为一个函数使用；

接下的讲解主要当作是一个函数使用去讲解；

语法：range(value, [stop_value,] [step_value])

参数	说明
value	意义为返回的起点数值；但是如果单独使用话本身的含义为0，原本指定的值成为stop_value的值；
stop_value	意义为返回数的最大范围，但是终点数不是其本身，如果stop_value是0或者正数，就是stop_value减一，如果stop_value是负数，就是stop_value加一；
step_value	步长，每个返回值之间的间隔数，默认为1；

# 在实际的使用过程中往往配合for循环使用
for i in range(10):
    print(i)
    
# 但是此例中因为便于查看不使用for循环演示，而是改用list强转演示；

# 一个参数：表示返回 0 ~ N-1 的数值
lst = list(range(10))
print(lst)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 两个参数表示返回 N ~ M-1 的数值
lst = list(range(3, 10))
print(lst)  # [3, 4, 5, 6, 7, 8, 9]

# 三个参数表示返回 N ~ M-1 的数值，但是每个数间隔F
lst = list(range(3, 10, 2))
print(lst)  # [3, 5, 7, 9]

# 倒序: 只要让步长变为负数即可，但是也要注意 N 和 M 的数值确保范围准确
lst = list(range(10, -10, -4))
print(lst)  # [10, 6, 2, -2, -6]

eval 和 exec -- 字符串编译成py代码执行

上面的方法可以将字符串编译为python代码执行，eval只能适用于简单的代码；exec可以将更加复杂的代码执行；

# eval 只能编译简单的代码
char = 'print("Hello MSR.")'
eval(char)  # Hello MSR.

# 定义变量（eval不能编译，但是exec可以）
char = 'new_char = "My motherland is China."'
# eval(char)  # SyntaxError
exec(char)
print(new_char)  # My motherland is China.

repr -- 原型化输出字符串

将字符串中的转义字符失效，还记得字符串前缀r吗？他们的效果是一样的，但是repr会将两边的引号也显示出来。

# 转义
char = 'Hello\nChina.'
print(char)
'''
Hello
China.
'''

# 原型化
char = repr(char)
print(char)  # 'Hello\nChina.'

# repr 和 字符串前缀 r 的不同：显示出两边的引号
print(r'MSR')  # MSR
print(repr('MSR'))  # 'MSR'

hash -- 生成哈希值

将指定数据经过哈希运算法则生成的哈希值返回，相同的两个数据同时经过哈希运算法则得出的结果一定相同，所以一般哈希运算用于文件校验和密码加密等场景；

# 每次的结果不一定相同，但是相同数据同时运算结果一定相同
hash1 = hash('abs')
hash2 = hash('abs')
print(hash1)
print(hash2)
'''
-4611394003149070947
-4611394003149070947
'''

再上述使用hash()方法的时候，我们发现相同数据在多次运算的时候，结果不一定相同，这是因为控制hash的环境变量PYTHONHASHSEED所作用的，如果在启动python的时候，设定该环境变量，则可以复现hash值，也就是每次的hash值都是相同的。

# 示例
# 不指定PYTHONUNBUFFERED，hash每次都是随机的
python main.py

# 指定PYTHONUNBUFFERED，hash是固定复现的
PYTHONUNBUFFERED=11 python main.py

help -- 帮助文档

查看各种函数、类的帮助文档，还记得如何给自定义函数和类注释帮助文档吗？

类似的功能还有函数的内置方法 __doc__() 可以实现；

# 查看print方法的帮助文档
print_help = help(print)
print(print_help)
"""
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

None
"""

数据之间的强制转换

四个数字类型方法和五个容器类型方法，主要用作数据的生成和数据之间的强转；

详情请参见六大数据类型和数据之间的强制转换；

id -- 返回数据的内存地址

返回一个数据的内存地址，这个地址是唯一的，这个东西关系到了一个程序占据资源空间的大小，也是评判一个程序是否优劣的标准之一，还记得我们之前讲过的Python的缓存机制吗？

char = 'Hello MSR.'
char_id = id(char)
print(char_id)  # 2884357927408

len -- 查看容器类型数据的长度

查看一个容器类型数据的长度，也就是一级元素的个数；

lst = [1, 2, 3]
lst_length = len(lst)
print(lst_length)  # 3

# 列表类型数据还有内置方法 __len__ 也可以查看
lst_length = lst.__len__()
print(lst_length)

# 一般配合range 遍历容器使用
lst = [1, 2, 3]
for i in range(len(lst)):
    print(lst[i])

type -- 返回数据的类型

type是Python的一个内置类，作用是返回一个数据的类型

char = 123
char_type_obj = type(char)
print(char_type_obj)  # <class 'int'>
char_type = char_type_obj.__name__
print(char_type)  # int

# 判断数据类型
if char_type == 'str':
    print(char)
else:
    print(char_type)

isinstance -- 判断数据类型

用于判断数据的类型，返回布尔值；

语法：isinstance(x, A_tuple)

参数	说明
x	要判断的数据
A_tuple	要判断的数据类型，如果x是该数据类型返回真，反之为假；也可以是一个元组中包含多个数据类型，如果x的数据类型是元组中的其中之一就返回真，反之返回假；

res = isinstance(100, int)
print(res)  # True

res = isinstance(False, (str, float, tuple))
print(res)  # False

# 注意：Python中的 布尔型 和 整型 在使用isinstance判断的时候是相同的
res = isinstance(False, (str, int, tuple))
print(res)  # True

issubclass -- 判断类的子父关系

用法和isinstance一模一样，用于判断指定类和类之间是否存在子父关系，isinstance 和issubclass的详细用法见面向对象（类的继承）。

open -- 文件IO操作

详情请见IO文件管理；

locals 和 globals -- 局部和全局空间

用于输出所有的全局变量和局部变量，详情请见函数进阶（全局空间和局部空间）。

quit 和 exit

用于退出程序，结束程序；

quit()
exit()

常用关键字

# 引导出系统中所有的关键字
import keyword

print(keyword.kwlist)

关键字	作用
pass	过，占位符；是空语句，本身没有作用，个别情况为了保持程序结构的完整性二占据一些必要的位置；
NotImplemented	同“None”；
Ellipsis	省略号；
...	同“Ellipsis”
break	终止循环；
continue	跳过当前循环；
if...elif..else...	if语句；
for...in...else...	for循环；
while...else...	while循环；
del	删除变量，释放空间；
None	基础数据类型，表示空；
global	声明全局变量；
nonlocal	声明局部变量；
def	定义函数；
class	定义类；
as	别名；

还有许许多多的关键字不在列举；

常见内置属性

print(__name__)   # 当前模块
print(__file__)  # 当前文件路径
print(__doc__)   # 文档注释
print(__package__)  # 位置