【PyQt5 基础之 Python 备忘录】- 02 - Python(3.8.13) 内置函数 (共 69 个)

2 常用内置函数

Python 3.8.13 版本共有 69 个内置函数，详见 python 文档 - 内置函数

第 1 列	第 2 列	第 3 列	第 4 列	第 5 列
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()

2.1 数据类型及转换 (12个)

参考了 https://zhuanlan.zhihu.com/p/428576039，分类十分个人向，请注意。

type(x) 返回数据类型

bool(x) 返回 True 或 False，x 为假返回 False，其他为 True

int(x) 返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0

float(x) 返回从数字或字符串 x 生成的浮点数

complex(real,imag) 返回值为 real + imag*j 的复数

x = complex('1+3j') # 在"+"号两边不能有空格
y = complex(1,3)
print(x,y)
print(type(x),type(y))
# ----- output
(1+3j) (1+3j)
<class 'complex'> <class 'complex'>

ascii(object) 返回 object 对象的 ascii 格式字符串，非 ascii 会被转义

str(object) 返回 object 对象的 string 格式，面向人阅读

repr(object) 返回 object 对象的 string 格式，面向解释器

a = (1, 2, 3, 'hello', '你好')
print(a)
print(ascii(a))
print(str(a))
print(repr(a))
# ----- output
(1, 2, 3, 'hello', '你好')
(1, 2, 3, 'hello', '\u4f60\u597d')
(1, 2, 3, 'hello', '你好')
(1, 2, 3, 'hello', '你好')

eval(str) 把 str 字符串转为对象或执行简单表达式，转换可以理解为 ascii() 的逆操作

a = '[1,2,3,4]'
print(type(a))
b = eval(a)
print(type(b),b)
print(eval('1+1'))
# ----- output
<class 'str'>
<class 'list'> [1, 2, 3, 4]
2

chr(i) 返回 Unicode 码位为整数 i 的字符的字符串格式

ord(c) 返回 c 字符的 Unicode 码位整数

len(s) 返回对象的长度（元素个数）

2.2 进制转换 (3个)

bin(x) 将整数 x 变为前缀为 “0b” 的 二 进制字符串

oct(x) 将整数 x 变为前缀为 “0o” 的 八 进制字符串

hex(x) 将整数 x 变为前缀为 “0x” 的 十六 进制字符串

print(bin(1), bin(10), bin(100)) # 二进制
print(oct(1), oct(10), oct(100)) # 八进制
print(hex(1), hex(10), hex(100)) # 十六进制
# ----- output
0b1 0b1010 0b1100100
0o1 0o12 0o144
0x1 0xa 0x64

2.3 数学运算 (7个)

abs(x) 绝对值计算函数，有三条特性：

• 返回一个整型或浮点的绝对值；
• 如果是复数，返回模；
• 如果 x 定义了 __abs__()，则返回 x.__abs__()。

divmod(a,b) 将 a, b（非复数）作为实参，执行整数除法返回一对商和余数

print(divmod(10, 3))
# ----- output
(3, 1) #返回值是 tuple

round(number, ndigits) 返回 number 舍入到小数点后 ndigits 位精度的值

print(round(2.675, 2)) 
print(round(2.685, 2))
print(round(2.675))
# ----- output
2.67 # 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。
2.69 # 符合预期
3    # ndigits 省略则返回最近整数

pow(base, exp) 返回 base 的 exp 次幂

sum(iterable, /, start=0) 从 start 开始自左向右对 iterable 的项求和并返回总计值

arr = range(1, 101, 1)
print(sum(arr))
print(sum(arr, start=20))
# ----- output
5050 # 1加到100
5070 # 1加到100再加上 20

min(x) 返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的

max(x) 返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的

2.4 数据结构 (12个)

enumerate(iterable, start=0) 返回一个枚举对象，配合循环很方便，能提供下标

iter(object[, sentinel]) 返回一个 iterator对象，便捷在于不依赖已有列表

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

arr = list(range(6, 11, 1))
for i in arr: # 直接用 for 遍历
    print(i)

for h in iter(arr): # 用 iter 迭代器遍历，但其功能不止于此
    print(h)
    
for j, element in enumerate(arr):
    print('第{}个元素为{}'.format(j, element)) # 用两个变量去接 enumerate

for k in enumerate(arr):
    print('第{}个元素为{}'.format(k[0], k[1])) # enumerate 返回的是 tuple(索引，值/对象)

next(iterator[, default]) 通过调用 iterator 的 __next__()方法获取下一个元素

range(start, stop[, step]) 返回不可变序列的可迭代对象，注意左闭右开

print(range(3, 7)) # range 对象
print(list(range(3, 7))) # 左闭右开 步长为 1
print(list(range(3, 7, 2))) # 左闭右开 步长为 2
# ----- output
range(3, 7)
[3, 4, 5, 6]
[3, 5]

slice(start, stop[, step]) 返回一个指定索引集的切片对象，注意下标左闭右开

arr = list(range(0,10))
s1 = arr[0:8:2]           # 更常用的切片方式 x[开始下标:结束下标:步长]
s2 = arr[slice(0,8,2)]
s3 = arr[:3:]
s4 = arr[slice(3)]
print(s1)
print(s2)
print(s3)
print(s4)
# ----- output
[0, 2, 4, 6] # 索引 8 符合条件，由于 左闭右开 没有进入切片
[0, 2, 4, 6] # 索引 8 符合条件，由于 左闭右开 没有进入切片
[0, 1, 2] # 索引截止为 3 , 由于 左闭右开 ,3 没有进入切片
[0, 1, 2] # 索引截止为 3 , 由于 左闭右开 ,3 没有进入切片

list(x) 返回可变序列，将 tuple 或字符串转为列表

a = (8, 'x', 'y', 'z')
b = list(a)
s = 'good night'
sl = list(s)
print(b)
print(sl)
# ----- output
[8, 'x', 'y', 'z']
['g', 'o', 'o', 'd', ' ', 'n', 'i', 'g', 'h', 't']

tuple(iterable) 返回元素值不可变的新序列，传入 dict 返回 Key 列表

a = tuple([1, 2, 3, 4])  # 直接利用列表构造
b = tuple(dict(zip(['x', 'y'], [4, 5]))) # 字典的 tuple 是 key
print(a, b)
# ----- output
(1, 2, 3, 4) ('x', 'y')

dict(有三种) 返回一个新的字典，常用三种构造方法，并且可以混合使用

• dict(**kwarg)
• dict(mapping, **kwarg)
• dict(iterable, **kwarg)

a = dict(a=2, b='3', c='4') # 等号形式构造，key = value
b = dict(zip(['x', 'y', 'z'], [1, 2, 3])) #zip方法构造
c = dict([('x', 1), ('y', 2)]) # tuple列表构造
d = dict(zip(['x', 'y'], [1, 2]), a=2, b='3') # 混合使用,zip得放前面
print(a)
print(b)
print(c)
print(d)
# ----- output
{'a': 2, 'b': '3', 'c': '4'}
{'x': 1, 'y': 2, 'z': 3}
{'x': 1, 'y': 2}
{'x': 1, 'y': 2, 'a': 2, 'b': '3'}

set([iterable]) 返回一个无序不重复元素集

a = set('hello world')
b = set([1,1,2,2,3,5,7,7])
print(a)
print(b)
# ----- output
{' ', 'o', 'e', 'h', 'r', 'l', 'd', 'w'}
{1, 2, 3, 5, 7}

frozenset([iterable]) 返回一个冻结的无序不重复元素集，不能再添加或删除元素

bytes(x) 返回一个新的不可变字节数组

bytearray(x) 返回一个新的可变字节序列

2.5 容器操作 (7个)

all(iterable) 可迭代元素均为真（或为空）则返回 True

any(iterable) 可迭代元素中任意一个为真返回 True，与 all 对比记忆

x, y, z = [], [1, 1, 1, 1], [True, False] #空，全真，真假都有
print(all(x), all(y), all(z)) #all
print(any(x), any(y), any(z)) #any
# ----- output
True True False #all
False True True #any

filter(function, iterable) 用 iterable 中函数 function 返回真的元素构建新的迭代器

map(function, iterable) 返回 function用于iterable中每项并输出结果的迭代器

reversed(seq) 返回一个反向的迭代器

a = (1, 2, 3, 'hello', '你好')
print(list(reversed(a)))
# ----- output
[1, 2, 3, 'hello', '你好']
['你好', 'hello', 3, 2, 1]

sorted(iterable) 根据 iterable 中的项返回一个新的已排序列表，可设置正反序

zip(*iterables) 创建一个聚合了来自每个可迭代对象中的元素的迭代器

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list_zip = list(zipped)
print(type(zipped), list_zip, type(list_zip[0]))
# ----- output
<class 'zip'> [(1, 4), (2, 5), (3, 6)] <class 'tuple'>

2.6 类操作 (9个)

detattr(object, name) 如果对象允许，该函数将删除指定的属性

getattr(object, name) 返回对象object中名为name的属性的值

setattr(object, name, value) 将 value 赋给 object 的属性 name

hasattr(object, name) 对象object中有名为name的属性返回True

callable(object) 如果参数 object 是可调用的就返回 True

@classmethod 把一个方法封装成类方法，不需要实例化类就可以被类本身调用

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod #声明类方法
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

@staticmethod 将方法转换为静态方法，与 @classmethod 区别如下

• @staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
• @classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
• 如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
• 而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。

isinstance(object, classinfo) 如果 object 是 classinfo 的实例或子类返回 True

issubclass(object, classinfo) 如果 object 是 classinfo 的子类返回 True

2.7 文件操作 (1个)

open() 打开文件并返回对应的文件对象。

2.8 全局/局部变量 (4个)

globals() 返回表示当前全局符号表的字典

locals() 更新并返回表示当前本地符号表的字典

vars([object]) 返回具有 __dict__属性的object的 __dict__属性

dir([object]) 如果没有实参，则返回当前本地作用域中的名称列表

函数	说明	返回值
globals()	返回当前位置的全部全局变量	dict
locals()	返回当前位置的全部局部变量	dict
vars([object])	带参数：返回 object 的属性及值的字典；不带参数：返回当前调用位置的属性及值的字典	dict
dir([object])	带参数：返回 object 的有效属性列表；不带参数：返回当前范围的变量、方法和定义的类型列表	list

2.9 调试/编译/执行 (3个)

用时再细查

breakpoint(*args, **kws) 此函数会在调用时将你陷入调试器中

compile(...) 将 source 编译成代码或 AST 对象。

exec(object[, globals[, locals]]) 动态执行 Python 代码，注意与 eval 区别

• 其妙用在于可变代码的执行，利用一些操作生成代码 txt 然后利用 exec 执行
• 注意：eval 执行简单表达式，exec 相当于完整的 python 编译器

2.10 输入输出 (3个)

input() 获取控制台的输入，返回字符串

print() 将对象打印到指定的文本流

format() 格式化操作

2.11 特殊 (8个)

仅是对个人来讲日常使用频度很低，现用现查。

hash() 返回该对象的哈希值

help() 启动内置的帮助系统

id()返回对象的“标识值”，该值为整数，在此对象的生命周期中保证唯一且恒定

memoryview() 返回由给定实参创建的“内存视图”对象

object 返回一个没有特征的新对象

property 返回 property 属性

super()返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。

__import__() 此函数会由 import语句发起调用