常用的内置函数
【一】什么是内置函数？
- 内置函数就是Python给你提供的, 拿来直接用的函数，比如print，input等。
- 截止到python版本3.6.2 ，一共提供了68个内置函数，具体如下
- 和数字相关
- 数据类型
- 进制转换
- 数学运算
- 和数据结构相关
- 序列
- 数据集合
- 相关内置函数
- 和作用域相关
- 和迭代器生成器相关
- 字符串类型代码的执行
- 输入输出
- 内存相关
- 文件操作相关
- 模块相关
- 帮 助
- 调用相关
- 查看内置属性
【二】数据类型转换（8）
【1】数字类型转换
（1）整数类型转换（int）
- int:整型
# int(x): x转换为整数
res = '18' # 字符串类型
print(res, type(res)) # 18 <class 'str'>
res_int = int(res) # 将可以转换为整数的类型转换为整数
print(res, type(res_int)) # 18 <class 'int'>
（2）浮点数类型转换（float）
- float:浮点型
# float(x) x转换为浮点型
res = 18
print(res, type(res)) # 18 <class 'int'>
res_float = float(res) # 转换为浮点型
print(res_float, type(res_float)) # 18.0 <class 'float'>
【2】字符串类型转换（str）
- str()将数据转化为字符串
print(str(123)+'456') #123456
【3】布尔类型转换（bool）
- bool:布尔类型（True/False）
res = 1
print(res, type(res)) # 1 <class 'int'>
res_bool = bool(res)
print(res_bool, type(res_bool)) # True <class 'bool'>
【4】列表类型转换(list)
- list() 将一个可迭代对象转换成列表
a = range(10)
print(list(a)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
【5】元祖类型转换(tuple)
- tuple() 将一个可迭代对象转换成元组
a = range(10)
print(tuple(a)) # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
【6】字典类型转换(dict)
- 字典：dict 创建一个字典
- 注释:
dict()函数可接受可迭代对象，用键值对初始化字典。
# 示例
dictionary = dict([('key1', 'value1'), ('key2', 'value2')])
print(dictionary)
# 输出：{'key1': 'value1', 'key2': 'value2'}
【7】集合类型转换(set)
- 集合：set 创建一个集合
- 注释:
set()函数用于创建一个集合，自动去除重复元素。
# 示例
my_set = set([1, 2, 3, 3, 4, 5])
print(my_set)
# 输出：{1, 2, 3, 4, 5}
【三】数学进制转换(3)
【1】十进制转二进制(bin)
-
bin() 将给的参数转换成二进制
number = 10 # 十进制转二进制 number_bin = bin(number) print(number_bin) # 0b1010
【2】十进制转八进制(oct)
-
oct() 将给的参数转换成八进制
number = 10 # 十进制转八进制 number_oct = oct(number) print(number_oct) # 0o12
【3】十进制转十六进制(hex)
-
hex() 将给的参数转换成十六进制
number = 10 # 十进制转十六进制 number_hex = hex(number) print(number_hex) # 0xa
【四】数学运算（8）
（1）获取绝对值（abs）
- abs()返回绝对值
print(abs(-2)) # 2
（2）获取商和余数
- divmod()返回商和余数
start_num = 20
end_num = 4
# 获取商和余数 (被除数，除数)
result = divmod(start_num, end_num)
print(result) # (5, 0)
（3）四舍五入（round）
-
round() 四舍五入
给定数字的四舍五入版本，有指定的小数位数。
默认情况下，小数点的数量是0。
因此，如果你调用 round() 时没有第二个参数，该函数将返回最近的整数。
-
四舍五入到最近的整数：
num = 3.6
print(round(num)) # 输出: 4
- 四舍五入到一位小数：
num = 3.56
print(round(num, 1)) # 输出: 3.6
- 四舍五入到两位小数：
num = 3.564
print(round(num, 2)) # 输出: 3.56
- 注意特殊情况 - 银行家舍入：
- 当数字恰好在两个可能的舍入值的中间时，
round()会舍入到最近的偶数（这是所谓的“银行家舍入”）
- 当数字恰好在两个可能的舍入值的中间时，
print(round(2.5)) # 输出: 2
print(round(3.5)) # 输出: 4
（4）a的b次幂（pow）
pow(a, b)函数用于计算 a 的 b 次幂。当提供第三个参数时，它将计算 a 的 b 次幂后再对第三个参数取余。以下是一些使用pow()函数的例子：- 计算 *a* 的 *b* 次幂：
# 计算 2 的 3 次幂
print(pow(2, 3)) # 输出: 8
- 计算 *a* 的 *b* 次幂，然后对 *c* 取余：
# 计算 2 的 3 次幂，然后对 5 取余
print(pow(2, 3, 5)) # 输出: 3
（5）求和（sum）
- sum()
print(sum([1, 2, 3, 4, 5, 6, 7, 2, 3, 4])) # 37
（6）最小值(min)
-
min() 求最小值
print(min(5,3,9,12,7,2)) # 求最小值:2
（7）最大值(max)
-
max() 求最大值
print(max(7,3,15,9,4,13)) # 求最大值:15
（8）复数转换(complex)
- complex : 复数
# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。
start = complex(3, 4)
print(start) # (3+4j)
second = complex(5, 9)
print(second) # (5+9j)
res = start + second
print(res) # (8+13j)
【五】数据结构相关
【1】序列相关（5）
（1）翻转（reversed）
- reversed()将一个序列反转，返回反转序列的迭代器
lst = "我是黄俏祺"
it = reversed(lst)
print(list(it)) # ['祺', '俏', '黄', '是', '我']
(2)切片（slice）
- slice()列表的切片
lst = "我是黄俏祺"
li_name = list(lst) # ['我', '是', '黄', '俏', '祺']
s = slice(0, 4)
print(li_name[s]) # ['我', '是', '黄', '俏']
（3）计算长度(len)
- len() 返回一个对象中的元素的个数
lst = "我是黄俏祺"
print(len(lst)) # 5
(4)排序(sorted)
- 语法：sorted(Iterable, key=函数(排序规则), reverse=False)
- Iterable: 可迭代对象
- key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
- reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]
l1 = sorted(lst)
print(l1) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]
print(lst.sort()) # None
print(lst) # [1, 5, 5, 6, 7, 9, 12, 13, 18]
当您使用list.sort()方法时，它会对原列表进行排序并返回None。这意味着该方法会直接修改原列表，而不会返回一个新的已排序列表。因此，当您尝试打印lst.sort()的结果时，它实际上是打印了None，因为list.sort()返回的是None。
(5)枚举（enumerate）
- enumerate() 获取集合的枚举对象
lst = ['one', 'two', 'three', 'four', 'five']
dic1 = {}
for index,e in enumerate(lst,1):
dic1[index] = e
print(dic1) # {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
【2】字符串（4）
（1）格式化输出（format）
format() 与具体数据相关, 用于计算各种小数, 精算等.
- 居中对齐方式
# 将文本 "Hello" 居中对齐，总共占用 20 个字符的空间
text = "Hello"
formatted_text = format(text, "^20")
print(formatted_text) # 输出: ' Hello
# 将文本 "Hello" 居中对齐，总共占用 20 个字符的空间，并使用 * 填充空白
text = "Hello"
formatted_text = format(text, "*^20")
print(formatted_text) # 输出: '*******Hello********'
- 进制转换
print(format(3, 'b')) # 二进制:11
print(format(97, 'c')) # 转换成unicode字符:a
print(format(11, 'd')) # ⼗进制:11
print(format(11, 'o')) # 八进制:13
print(format(11, 'x')) # 十六进制(⼩写字母):b
print(format(11, 'X')) # 十六进制(大写字母):B
print(format(11, 'n')) # 和d⼀样:11
print(format(11)) # 和d⼀样:11
- 科学计数法
print(format(123456789, 'e')) # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e')) # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E')) # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f')) # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f')) # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890
（2）字符串转bytes(bytes)
-
bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8") print(bs) # b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
（3）获取字节数组(bytearray)
-
bytearray()
-
返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray("dream", encoding='utf-8') print(ret[0]) # 100 print(ret) # bytearray(b'dream') ret[0] = 65 # 把65的位置A赋值给ret[0] print(str(ret)) # bytearray(b'Aream')
-
（4）返回对象的字符串格式(repr)
-
repr() 返回一个对象的string形式
word = "今天\n吃了%s顿\t饭" % 3 print(word) # 今天 # 吃了3顿 饭 # 原样输出,过滤掉转义字符 \n \t \r 不管百分号% print(repr(word)) # '今天\n吃了3顿\t饭'
【3】字符编码(3)
（1）字符编码找数字(ord)
-
ord() 输入字符找带字符编码的位置
print(ord('a')) # 字母a在编码表中的码位:97 print(ord('中')) # '中'字在编码表中的位置:20013
（2）数字找字符编码(chr)
-
chr() 输入位置数字找出对应的字符
print(chr(65)) # 已知码位,求字符是什么:A print(chr(19999)) # 丟
（3）数字找ASCII码(ascii)
-
ascii() 是ascii码中的返回该值 不是就返回u
for i in range(65536): #打印出0到65535的字符 print(chr(i), end=" ") print(ascii("@")) #'@'
【4】数据集合(1)
- 创建一个冻结的集合(frozenset)
- frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
- 注释:
frozenset()函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素。
# 示例
frozen_set = frozenset([1, 2, 3, 4, 5])
print(frozen_set)
# 输出：frozenset({1, 2, 3, 4, 5})
【5】判断条件(2)
（1）所有为真(all)
-
all() 可迭代对象中全部是True, 结果才是True
# 列表中的所有元素都是真值 items = [1, 2, 3, 4] print(all(items)) # 输出: True # 列表中包含一个假值（0） items = [0, 1, 2, 3] print(all(items)) # 输出: False # 空列表 items = [] print(all(items)) # 输出: True # 包含非布尔但为真的值（如非空字符串） items = ['a', 'b', True] print(all(items)) # 输出: True
（2）任意为真(any)
-
any() 可迭代对象中有一个是True, 结果就是True
# 列表中至少有一个真值 items = [0, False, 5] print(any(items)) # 输出: True # 列表中没有真值元素 items = [0, False, None, []] print(any(items)) # 输出: False # 空列表 items = [] print(any(items)) # 输出: False # 包含非布尔但为真的值（如非空字符串） items = ['', 0, 'Python'] print(any(items)) # 输出: True
【6】高阶函数（3）
（1）打包（zip）
- zip()函数
- 用于可迭代的对象作为参数
- 将对象中对应的元素打包成一个元组
- 最后返回由这些元组组成的列表
- 可以直接用dict（）转成字典
- 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
numbers = [1, 2, 3]
letters = ['a', 'b', 'c']
symbols = ['!', '@', '#', '$'] # 注意这个比前两个长
# 使用zip打包
zipped = zip(numbers, letters, symbols)
# 转换为列表查看结果
zipped_list = list(zipped)
print(zipped_list)
# 使用zip创建字典
zipped_dict = dict(zip(letters, numbers))
print(zipped_dict)
（2）过滤（filter）
- 语法：fiter(function. Iterable)
- function: 用来筛选的函数.
- 在filter中会自动的把iterable中的元素传递给function.
- 然后根据function返回的True或者False来判断是否保留留此项数据
- Iterable: 可迭代对象
- function: 用来筛选的函数.
- filter() 过滤 (lamda)
l1 = list(range(100))
def func(l1):
return l1 % 2 == 0
lst = filter(func, l1)
print(list(lst))
（3）映射（map）
- 语法 : map(function, iterable)
- 可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
- map() 会根据提供的函数对指定序列列做映射(lamda)
lst = [1, 2, 3, 4, 5, 6, 7, ]
def func(i):
return i % 2 == 0
it = map(func, lst)
print(it) # <map object at 0x0000016372ACD540>
print(list(it)) # [False, True, False, True, False, True, False]
【六】作用域(2)
- locals() 返回当前作用域中的名字
- globals() 返回全局作用域中的名字
global_var = "This is a global variable"
def my_function():
# 局部变量
local_var = "This is a local variable"
# 打印局部作用域中的变量
print("Local Scope:", locals())
# 打印全局作用域中的变量
print("Global Scope:", globals())
# 调用函数
my_function()
【七】迭代器生成器（3）
【1】循环生成数据（range）
- range() 生成数据
print(range(1, 10))
# range(1, 10)
print([i for i in range(1, 10)])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
【2】获取迭代器（iter）
- iter()
- 获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器
lst = [1, 2, 3, 4, 5, 6, 7, ]
it = iter(lst) # 获得迭代器it
print(it) # <list_iterator object at 0x0000013FEB5193F0>
【3】向下执行next（）
- next()
- 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目
lst = [1, 2, 3, 4, 5, 6, 7, ]
it = iter(lst) # 获得迭代器it
print(it) # <list_iterator object at 0x0000013FEB5193F0>
print(next(it))
print(next(it))
print(next(it))
print(next(it))
【八】字符串类型代码的执行（3）
【1】指定指令并返回结果（eval）
- eval() 执行字符串类型的代码. 并返回最终结果
s1 = input('请输入想要计算的算式') # 输入8*8
print(eval(s1)) # 64
【2】指定指令不返回结果（exec）
- exec() 执行字符串类型的代码
s2 = 'for i in range(5):print(i)'
print(exec(s2)) # 0 1 2 3 4 5 None
def func():
print('我是黄俏祺')
""")
func() # 我是黄俏祺
【3】编码指令
- compile()将字符串类型的代码编码，代码对象能够通过exec()或者eval()进行求值
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)
- source 可以是字符串或者字节字符串，后者AST对象
- filename 是代码读取的文件名，source是从哪个文件里读取的，就用哪个文件的名称，如果不是从文件读取的source，则填写一个可辨识值，一般用''
- mode 编码模式，如果source是语句，则mode可以是exec，如果是单一表达式，则可以是eval，如果source是单个交互式语句，mode可以是single
- flags 和 dont_inherit 用来控制编译源码时的标志，一般情况下使用默认值
code1 = 'print("my name is green")'
str1 = compile(code1, '', 'eval')
print(str1) # <code object <module> at 0x0000019C1DBEAC10, file "", line 1>
exec(str1) # my name is green
【九】输入输出(2)
-
print() : 打印输出
print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接 # end:以什么为结尾 # hello*world@ -
input() : 获取用户输出的内容
【十】算法(1)
-
hash() :
- 获取到对象的哈希值(int, str, bool, tuple).
s = 'dream' print(hash(s)) # 1612413944648601058- 列表不允许hash
lst = [1, 2, 3, 4, 5] print(hash(lst)) # 报错,列表是不可哈希的 r''' Traceback (most recent call last): File "E:\PythonProjects\09Python的内置函数\01start.py", line 361, in <module> print(hash(lst)) # 报错,列表是不可哈希的 TypeError: unhashable type: 'list' ''' -
hash算法:
- (1) 目的是唯一性
- (2) dict 查找效率非常高
-
hash表:
- 用空间换的时间 比较耗费内存
【十一】文件操作(1)
-
open() : 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8') f.read() f.close()
【十二】导入模块(1)
-
__ import__() : 用于动态加载类和函数
# 让用户输入一个要导入的模块 name = input("请输入你要导入的模块:") json = __import__(name) # 可以动态导入模块 print(json.dumps({"name": "green"})) # {"name": "green"}
