Python 内置函数

常用内置函数概览

https://www.processon.com/mindmap/5e2ea3e6e4b0d27af181882c

作用域相关

locals 和 globals

• locals：函数会以字典的类型返回当前位置的全部的局部变量
• globals：函数会以字典的类型返回全部的全局变量

a = 10 
def func():    
	a = 40    
	b = 20    
	
	def abc():        
		print("哈哈")    
		print(a, b)     # 这里使用的是局部作用域    
		
	print(globals())    # 打印全局作⽤用域中的内容    
	print(locals())     # 打印当前局部作⽤用域中的内容，即打印func中的局部命名空间

func()

# 输出的结果是一样的，因为locals()是查看当前的局部命名空间，而此时locals函数的位置就处在全局中，因此查看的也是全局
print(globals())   
print(locals())    

迭代器/生成器相关

一、range

for i in range(0,5):
    print(i)
# 结果：0 1 2 3 4


# 间隔取值
for i in range(0,10,3):
    print(i)
# 每隔3个不长取一次值：0 3 6 9

# 倒序取值
for i in range(10, 0, -3):
    print(i)
# 从10到0倒序，每隔三个步长取值一次：10 7 4 1

二、iter

lst = ["aa", "bb", "cc", "dd"]
# it = lst.__iter__()  # 拿到列表的迭代器对象
it = iter(lst) # 等价于 lst.__iter__()

print(it.__next__())
print(it.__next__())
print(it.__next__())
print(it.__next__())

三、next

lst = ["aa", "bb", "cc", "dd"]
it = lst.__iter__()  # 拿到列表的迭代器对象
print(it.__next__())
print(next(it))  # 等价于 it.__next__()
print(next(it))
print(next(it))

输入输出

一、print

# 输出相关内容
print("aaa")

# 修改字符串输出的连接符，默认是一个空格
print("aaa", "bbb", "ccc")  # aaa bbb ccc
print("aaa", "bbb", "ccc", sep="_")  # aaa_bbb_ccc

# 修改字符串输出的结尾符，默认是换行
print("aaa", "bbb", "ccc", end="*****")
print("ddd")
# aaa bbb ccc*****ddd

二、input

# input 用于接收用户在终端输入的内容。默认输入的内容都是字符串
name = input("姓名：")
print(name)

内存相关

一、id

# id 用于获取变量在内存中的地址
a = 1111
b = "aaaaa"
print(id(a))  # 2025378406128
print(id(b))  # 2025378538192

二、hash

# 将一个变量通过hash算法进行计算得到唯一一个编号，并存到响应的内存中；当下一次再遇到该变量时，在对其进行一次hash计算，可以通过直接计算的值取到对应的内容，有点类似于字典的原理
# hash的目的就是唯一性
# hash表是牺牲空间来换取时间
# 字典的键就要求是hash结构，因此字典的查找效率最高
# 只有不可变类型才能进行hash计算

tup = (1, 2, 3)
print(hash(tup))

s = "呵呵"
print(hash(s))

n = 111
print(hash(n))

# 字典、列表、集合等可变对象无法进行hash计算
dct = {"a": "aaa"}
print(hash(dct))

lst = [1, 2, 3]
print(hash(lst))

st = {1, 2, 3}
print(hash(st))

模块相关

# 让用户输入要调用的模块
name = input("要调用的模块")

# import name # 报错，找不到name模块
__import__(name) # 这样就可以正常执行模块的调用

进制转换

a = 10
print(bin(a))  # 二进制  0b1010
print(hex(a))  # 十六进制  0xa
print(oct(a))  # 八进制  0o12

调用相关

callable

用于判断变量是否可调用

a = 10
print(callable(a))  # False

def func():
    print("aaa")
print(callable(func))  # True

字符串类型代码的执行

一、eval

# eval 用于执行字符串类型的代码，可用于简单的运算，并返回最终的结果，但是对于比较复杂的字符类型代码无法执行
s = "3+5+9"
print(s)  # 3+5+9
print(eval(s))  # 会将字符串转换为代码并执行  17

二、exec

# exec 用于执行较为复杂的字符类型代码，无结果返回
code = "for i in range(0,10):print(i)"
exec(code)
# 0 1 2 3 4 5 6 7 8 9

exec("""def func():print("我是cdc")""")
func() # 可直接调用定义在字符串中的函数名

三、compile

代码的执行过程：python解释器将代码编译成字节码 –> 字节码传到操作系统中进行识别 –> 操作系统调动相关的硬件进行功能的实现

# compile 将字符串类型的代码编译，代码对象能够通过exec语句来执行或者eval进行求值 
'''参数说明 :        
	1. resource 要执行的代码，动态代码片段
    2. 文件名    代码存放的文件名，当传⼊了第⼀个参数的时候，这个参数给空就可以了        
    3. 模式，取值有 3 个：
    	3.1 exec: 一般放⼀些流程语句的时候            
    	3.2 eval: resource 只存放一个求值表达式
    	3.3 single: resource 存放的代码有交互的时候mode应为single 
  ''' 
  
code1 = "for i in range(10): print(i)" 
c1 = compile(code1, "", mode="exec") 
exec(c1) 
 
code2 = "1+2+3" 
c2 = compile(code2, "", mode="eval") 
a = eval(c2)
print(a) 

code3 = "name = input('请输⼊入你的名字:')" 
c3 = compile(code3, "", mode="single") 
exec(c3) 
print(name)  # 可直接调用在字符代码中定义的变量

使用compile的好处：

• 可以防止源码泄露，编译后都是字节码，只有操作系统可以识别
• 加快运行速度。不用读一行解释一行再编译一行，可将代码先全部编译成字节码，后期可直接运行（python 的 pypy 解释器就是这个原理）

数学运算相关

# 求绝对值
print(abs(-2))  # 2

# 求商和余数
print(divmod(10, 3))  # (3, 1) 3为商，1为余数

# 求和
print(sum([1, 2, 3, 4, 5]))  # 15

# 求最大
print(max([1, 2, 3, 4, 5]))  # 5

# 求最小
print(min([1, 2, 3, 4, 5]))  # 1

# 求幂，若有三个参数，先将前两个进行幂运算，再将计算结果与第三个值取余
print(pow(10, 2))  # 100
print(pow(10, 2, 3))  # 先得100，再与3取余，结果为1

# 四舍五入，注意当小数为0.5时，取最接近的偶数
print(round(4.5))  # 4
print(round(4.6))  # 5
print(round(5.5))  # 6
print(round(5.6))  # 6

序列相关

一、reversed

lst = ["aa", 1, 21, "cc"]
print(reversed(lst))  # 返回的是一个迭代器，不会改变原列表
print(lst)
new_lst = list(reversed(lst))
print(new_lst)  #  ['cc', 21, 1, 'aa']


s = "abcdefg"
new_a = list(reversed(s))
print(new_a)  # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

二、slice

lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:5:2])

s = slice(1, 5, 2)  # 三个参数：起始位置  结束位置  切片步长，默认为1
print(lst[s])

字符串相关

一、format

# 字符串
s = "我叫cdc"
print(format(s, "^20"))  # 设置居中
print(format(s, "<20"))  # 设置左对齐
print(format(s, ">20"))  # 设置右对齐

# 数值
print(format(3, 'b'))  # 二进制
print(format(97, 'c'))  # 转换成unicode字符
print(format(11, 'd'))  # 十进制 %d
print(format(11, 'o'))  # 八进制  8
print(format(11, 'x'))  # 十六进制(⼩写字⺟)
print(format(11, 'X'))  # 十六进制(⼤写字⺟)
print(format(11, 'n'))  # 十进制
print(format(11))  # 十进制

# 浮点数
print(format(123456789, 'e'))  # 科学计数法. 默认保留6位小数
print(format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写)
print(format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写)
print(format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数
print(format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数，位数不够就补0
print(format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出 INF 表示无限大

二、bytes 和 bytearry

s = "你好啊"
a = s.encode("utf-8")
print(a)
print(a.decode("utf-8"))

bs = bytes("你好啊", encoding="utf-8")
print(bs.decode("utf-8"))

ret = bytearray("cdc", encoding='utf-8')  # 得到的是一个数组，一位就是一个元素
print(ret[0])
ret[0] = 65  # 修改第一位元素的值，变为大写的A
print(str(ret))

s = memoryview("cdc".encode("utf-8"))  # 查看内存
print(s)

三、ord chr ascii

print(ord('a'))  # 97, 返回字母a在编码表中的码位
print(ord('中'))  # 20013 中国的中字在编码表中的位置

print(chr(65))  # 已知码位. 计算字符
print(chr(20018))

# 查看字符是否在ascii码中，在则返回本身，不在返回\u...
print(ascii("a"))  # 'a'
print(ascii("房"))  # '\u623f'

四、repr

name = "你好. \n我是cdc"
print(name) 
"""
你好. 
我是cdc
"""

# 原样输出,过滤掉转义字符 \n \t \r
print(repr(name))   # '你好. \n我是cdc'

# 过滤不掉百分号
name2 = "你好. \n我叫%s" % "cdc"
print(name2)
"""
你好. 
我叫cdc
"""
print(repr(name2))  # '你好. \n我叫cdc'

其余内置方法

一、enumerate 枚举

lst = ["蛋1", "蛋2", "蛋3", "蛋4"]
for i in range(len(lst)):
    print(i)
    print(lst[i])

for index, el in enumerate(lst, 100):    # 把索引和元素一起获取,索引默认从0开始. 可以更改
    print(index)
    print(el)
"""
100
蛋1
101
蛋2
102
蛋3
103
蛋4
"""

二、all any

# all 对于一个可迭代对象，当所有元素都为True，最后结果就为True
print(all([1, "哈哈", "馒头", True]))  # True

# any 对于一个可迭代对象，只要有一个元素为True，最后结果就为True
print(any([0, "哈哈", "馒头", True]))  # True

三、zip

# 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的新列表。如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同。 

lst1 = ["a", "b", "c", "d"]
lst2 = ["aa", "bb", "cc", "dd"]
lst3 = ["aaa", "bbb", "ccc", "ddd", "eee"]
for el in zip(lst1, lst2, lst3):
    print(el)
    
"""
('a', 'aa', 'aaa')
('b', 'bb', 'bbb')
('c', 'cc', 'ccc')
('d', 'dd', 'ddd')
"""

四、sorted

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

参数：

• Iterable：可迭代对象
• key：排序规则(排序函数)，在 sorted 内部会将可迭代对象中的每⼀个元素传递给这个函数的参数，根据函数运算的结果进行排序
• reverse：是否是倒序，True–>倒序，False–>正序

lst = [1,5,3,4,6] 
lst2 = sorted(lst) 
print(lst)  # 原列表不会改变 
print(lst2) # 返回的新列表是经过排序的 

dic = {1:'A', 3:'C', 2:'B'} 
print(sorted(dic))  # 如果是字典，则返回排序过后的key 
# [1, 2, 3]

和函数组合使用，函数返回的必须是一个数字，用于排序

# 根据字符串长度进行排序 
lst = ["钢铁侠", "银河护卫队", "美国队长", "蜘蛛侠", "复仇者联盟"] 

# 计算字符串长度 
def func(s):    
	return len(s) 

print(sorted(lst, key=func)) 

和匿名函数组合使用

# 根据字符串长度进行排序
lst = ["钢铁侠", "银河护卫队", "美国队长", "蜘蛛侠", "复仇者联盟"]

print(sorted(lst, key=lambda s: len(s)))


lst = [{"id": 1, "name": 'alex', "age": 18},
       {"id": 2, "name": 'wusir', "age": 16},
       {"id": 3, "name": 'taibai', "age": 17}]

# 按照年龄对学生信息进行排序
print(sorted(lst, key=lambda e: e['age']))

五、filter

语法：filter(function. Iterable)

参数：

• function：用来筛选的函数，在 filter 中会自动的把 iterable 中的元素逐个传递给 function，然后根据function 返回的 True 或者 False 来判断是否保留此项数据；
• Iterable：可迭代对象

lst = [1,2,3,4,5,6,7] 
ll = filter(lambda x: x%2==0, lst) # 筛选所有的偶数 
print(ll)  # 返回的是一个迭代器
print(list(ll))

lst = [{"id": 1, "name": 'alex', "age": 18},
       {"id": 2, "name": 'wusir', "age": 16},
       {"id": 3, "name": 'taibai', "age": 17}]
fl = filter(lambda e: e['age'] > 16, lst)  # 筛选年年龄⼤大于16的数据
print(list(fl))

六、map

语法：map(function, iterable)

参数：

• function 将可迭代对象中每一个元素去function中执行并返回结果
• iterable 可迭代对象

# 计算列表中每个元素的平方，返回新列表 
def func(e):    
	return e*e 
mp = map(func, [1, 2, 3, 4, 5]) 
print(mp)  # 返回的是一个迭代器
print(list(mp)) 

改写成匿名函数

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5]))) 

如果函数中有多个参数，后面的列表要一一对应；如果列表长度不一样，以最短的列表为准

lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8]
print(list(map(lambda x, y: x + y, lst1, lst2))) # x 取lst1中的值，y 取lst2中的值  [3,6,9,12]