python内置函数1
python内置函数1. 数学运算
1. abs()
返回数字的绝对值。参数可以是整数、浮点数或任何实现了 abs() 的对象。 如果参数是一个复数，则返回它的模。
# 参数可以是整数
print(f'{ abs(123) = }')
print(f'{ abs(-123) = }')
print(f'{ abs(0) = }')
# 参数可以是浮点数
print(f'{ abs(1.23) = }')
print(f'{ abs(-1.23) = }')
print(f'{ abs(0.0) = }')
# 参数可以任何实现了 __abs__() 的对象。
class TestClass:
def __abs__(self):
return 123
print(f'{ abs(TestClass()) = }')
# 如果参数是一个复数，则返回它的模
# 复数是实数+虚数
# 注意点：复数的绝对值返回值一定是浮点数
print(f'{ abs(3+4j) = }')
print(f'{ abs(-3-4j) = }')2. pow()
[*]格式：pow(base, exp[, mod])
[*]返回值：int
返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp
# 返回 base 的 exp 次幂；
print(f'{ pow(2, 3) = }')
print(f'{ pow(10, 2) = }')
# 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。
print(f'{ 2**3 = }')
print(f'{ 10**2 = }')
# 如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）
# 参数必须具有数值类型。 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10**2 返回 100，但 10**-2 返回 0.01。
# 参数必须具有数值类型
# print(f'{ pow(2, "3") = }')
# 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。
print(f'{ pow(2.0, 3) = }')
# 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。
print(f'{ pow(2, 3) = }')
print(f'{ pow(2, -3) = }')
# 对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。
# 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。 在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。
# print(f'{ pow(2, 3, 0) = }')
# 下面的例子是 38 的倒数对 97 取余:
# >>> pow(38, -1, mod=97)
# 23
# >>> 23 * 38 % 97 == 1
# True3. divmod()
[*]格式：divmod(a, b)
[*]返回值：一个包含商和余数的元组
<blockquote>
它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 >> max()3>>> max(1,2,4)4>>> max(-1, -0.5, 0)0>>> max((1,2,3))3>>> max(, )>>> max(, )>>> max(, , , ,)>>> max((1,2,3), (3,3,0))(3, 3, 0)>>> max((1,-1,0), (True,False,0)) #布尔喔(True, False, 0)>>> max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))(True, False, 2, 0)>>> max((1,-1,0), (True,),(1,))(1, -1, 0)>>> max((-1,-1,0), (True,),(1,))(True,)>>> max(,3,4) #非法入参Traceback (most recent call last):File "", line 1, in TypeError: '>' not supported between instances of 'int' and 'list'>>> max((1,2,3), ) #非法入参有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最大元素，则此函数将返回第一个找到的。
# 对于整数，结果和 (a // b, a % b) 一致。
a = 20# 被除数
b = 3 # 除数
print(f'{ divmod(a, b) = }')#(6,2)
print(f'{ (a//b, a%b) = }')
# 对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b)
import math
a = 2.0# 被除数
b = 0.3# 除数
q = math.floor(a/b)
print(f'{ divmod(a, b) = }')
print(f'{ (q, a%b) = }')
# 在任何情况下， q * b + a % b 和 a 基本相等5. min()
[*]格式：min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
[*]返回值：理同max()
6. round()
[*]格式：round(number[, ndigits])
[*]返回值：返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
round()内置函数不是使用四舍五入的规则，而是根据距离远近的规则来取近似值。
即如果小于等于4则舍去，如果大于等于6则进入。如果5后面还有有效数字，则进1，如果5后面没有有效数字，则选择偶数。
>>> max()
3
>>> max(1,2,4)
4
>>> max(-1, -0.5, 0)
0
>>> max((1,2,3))
3
>>> max(, )
>>> max(, )
>>> max(, , , ,)
>>> max((1,2,3), (3,3,0))
(3, 3, 0)
>>> max((1,-1,0), (True,False,0)) #布尔喔
(True, False, 0)
>>> max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))
(True, False, 2, 0)
>>> max((1,-1,0), (True,),(1,))
(1, -1, 0)
>>> max((-1,-1,0), (True,),(1,))
(True,)
>>> max(,3,4) #非法入参
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'list'
>>> max((1,2,3), ) #非法入参任何整数值都可作为有效的 ndigits (正数、零或负数)。
print(max([],default=False)) #空表触发value error，设置default则不会。
# 给key传参
print(f'{ max(, key=abs) = }')
# 自定义函数作为key
import math
def fun1(x):
return math.sin(x)
print(max(,key=fun1))
'''
2
'''
# 如果有多个最大元素，则此函数将返回第一个找到的
print(f'{ max(, key=abs) = }')对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。
7. sum()
[*]格式：sum(iterable, /, start=0)
[*]返回值：从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。
numbers = [-0.5, 0.5, 1.5, 2.5, 3.5]
for num in numbers:
print(f'{ num = } { round(num) = }')
print(f'{ round(0.125, 2) = }')
print(f'{ round(0.51) = }')
print(f'{ round(0.1251, 2) = }')
'''
num = -0.5round(num) = 0
num = 0.5round(num) = 0
num = 1.5round(num) = 2
num = 2.5round(num) = 2
num = 3.5round(num) = 4
round(0.115, 2) = 0.12
round(0.51) = 1
round(0.1251, 2) = 0.13
'''8. sorted()
[*]格式： sorted(iterable, *, key=None, reverse=False)
[*]返回值： 根据 iterable 中的项返回一个新的已排序列表。
具有两个可选参数，它们都必须指定为关键字参数。reverse=False reverse 次序颠倒 在这里表示，是否倒序排序，默认为False，表示默认升序排序.
print(f'{ round(123.456, 2) = }')
print(f'{ round(123.456, 0) = }')
print(f'{ round(123.456, -2) = }')
print(f'{ round(163.456, -2) = }')
'''
round(123.456, 2) = 123.46
round(123.456, 0) = 123.0
round(123.456, -2) = 100.0
round(163.456, -2) = 200.0
'''key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
print(sum(,start=10)) #计算总和后再加10
#162. 输入输出
9. input()
[*]格式： input()
[*]返回值： str
如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。
print(f'{ sorted(["b", "c", "a"]) = }')
print(f'{ sorted((2, 3, 1)) = }')
print(f'{ sorted("bca") = }')
'''
sorted(["b", "c", "a"]) = ['a', 'b', 'c']
sorted((2, 3, 1)) =
sorted("bca") = ['a', 'b', 'c']
'''input() 函数的参数只能为单个字符串。常用int()将输入的字符串转为整数类型。
10. print()
[*]格式： print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
[*]返回值：None
参数说明：
参数类型说明objectsstr等可以一次输出多个对象。输出多个对象时，需要用 , 分隔。sepstr用来间隔多个对象，默认值是一个空格。endstr用来设定以什么结尾。默认值是换行符 \n，可以换成其他字符串。file要写入的文件对象。flushbool输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。student_scores = [('A', 99), ('B', 114), ('C', 86)]
def get_key(elem):
return elem
print(f'{ sorted(student_scores, key=get_key) = }')
print(f'{ sorted(student_scores, key=lambda elem: elem) = }')
# [('C', 86), ('A', 99), ('B', 114)]
# [('C', 86), ('A', 99), ('B', 114)]3. 文件操作
11.open()
[*]格式： open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
[*]返回值： file object,如果无法打开会会抛出 OSError。
open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数。
参数说明：
参数类型说明filestr必需，文件路径（相对或者绝对路径）modestr可选，指定文件打开模式bufferingint可选，设置缓冲encodingstr文件编码方式，一般使用utf-8errorsstr可选，指定如何处理错误newline区分换行符closefd传入的file参数类型openermode可选参数：
参数描述t文本模式（默认）x写模式，新建一个文件，如果该文件已存在则会报错。b二进制模式a追加写。若文件已存在，文件指针将会放在文件的结尾；新的内容将会被写入到已有内容之后。若文件不存在，创建新文件写入。r打开并读取文本。文件的指针将会放在文件的开头。（默认）与rt同义w打开文件只用于写入（原有内容会被删除）。若文件不存在则创建新文件。+打开一个文件进行更新(可读可写)。prompt = '请输入内容:'
line = input(prompt)
print(f'{ line=} { type(line) = }')
# 请输入内容:today
#line='today'type(line) = <class 'str'>4. 进制转换
12. bin()
[*]格式：
[*]返回值： str
将一个整数转变为一个前缀为“0b”的二进制字符串。
13. hex()
[*]格式：
[*]返回值： str
将整数转换为以“0x”为前缀的小写十六进制字符串。
14. oct()
[*]格式：
[*]返回值： str
将一个整数转变为一个前缀为“0o”的八进制字符串。
5. unicode字符
15. chr()
[*]格式：
[*]返回值：
返回 Unicode 码位为整数 i 的字符的字符串格式。
x1=
for x in x1:
print(x,end="+")
# 0+1+4+9+16+25+16. ord()
[*]格式： ord(c)
[*]返回值：
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
s=open(r"C:\Users\zzy\Desktop\test.txt",
"r",
encoding="utf-8")
def fun1():#这个函数用来统计文本中的高频词，返回一个“词-频”对的字典
counts={}
x = jieba.lcut(s.read())
for word in x:
if len(word)==1:
pass
else:
counts=counts.get(word,0)+1
items=list(counts.items())
items.sort(key=lambda x:x,reverse=True)
return dict(items)6. 类型转换
17. bool()
[*]格式： class bool()
[*]返回值： 返回一个布尔值，True 或者 False。
x 使用标准的真值测试过程来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True。bool 类是 int 的子类（参见数字类型---int, float, complex）。其他类不能继承自它。它只有 False 和 True 两个实例（参见 布尔值）。
print(chr(36530)) #躲18. int()
[*]格式： int(*x*,base=10)
[*]返回值： 返回一个基于数字或字符串x构造的整数int对象，或者在未给出参数时返回 0。对浮点数向下取整。
这个函数按照base进制对数x进行解释，返回一个使用数字或字符串生成的整数int对象，无实参返回0。
其中x为数字或字符串，base为进制，取值范围为和0。
一个进制为n的整数包含0到n-1的整数，其中a-z(A-Z)表示10到35。
进制为0将会按照代码字面的前缀进行解释，结果是2、8、10、16中的一个。
要清楚的一点是，在python中带有前缀的数字，例如0xa，0o12，0b1010它们的类型(type)都是int整数类型。
如果想知道它们十进制数值，可以直接print，或print(int(x))，也可以int(str(x),base=0)（？）.
对这个函数的使用，主要分为三种情况：
[*]x为int类型：无论带不带前缀，这个数的进制已经清楚，该函数无法对一个进制清楚的非字符串类型进行转换（启用base关键字）。
[*]x为str字符串类型：
[*]带前缀：表明这个数的进制已经清楚，base只能等于其前缀或0。
[*]不带前缀：根据用法自由发挥。注意没有前缀且令base=0的话应注意x其形式。比如int("010",base=0)是非法的。因为解释器认为x是十进制数，但x形式是错误的。
[*]x为byte类型：暂时空缺。
print(ord("躲")) #3653019. float()
[*]格式： class float()
[*]返回值： 返回从数字或字符串 x 生成的浮点数。
如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 '+' 和 '-' ； '+' 对创建的值没有影响。
print(f'{ bool() = }')
print(f'{ bool(None) = }')
print(f'{ bool(False) = }')
from decimal import Decimal
from fractions import Fraction
print(f'{ bool(0) = }')
print(f'{ bool(0.0) = }')
print(f'{ bool(0j) = }')
print(f'{ bool(Decimal(0)) = }')
print(f'{ bool(Fraction(0, 1)) = }')
print('-'*20)
print(f'{ bool("") = }')
print(f'{ bool(()) = }')
print(f'{ bool([]) = }')
print(f'{ bool({}) = }')
print(f'{ bool(set()) = }')
print(f'{ bool(range(0)) = }')
# 如果 x 是假的或者被省略，返回 False；其他情况返回 True。
print(f'{ bool(123) = }')
print(f'{ bool(1.23) = }')
print(f'{ bool("test") = }')
# bool() = False
# bool(None) = False
# bool(False) = False
# bool(0) = False
# bool(0.0) = False
# bool(0j) = False
# bool(Decimal(0)) = False
# bool(Fraction(0, 1)) = False
# --------------------
# bool("") = False
# bool(()) = False
# bool([]) = False
# bool({}) = False
# bool(set()) = False
# bool(range(0)) = False
# bool(123) = True
# bool(1.23) = True
# bool("test") = True如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。
如果没有实参，则返回 0.0
x=int(156,base=2) #报错
x=int(0x156,base=0) #报错
x1="0101" #字符串
y1=int(x1,base=2) # 结果为整数5
y2=int(x1,base=8) # 结果为整数65
y3=int(x1,base=16) # 结果为整数257
y4=int(x1,base=35) # 结果为整数1226
x2="0xa5f1"
y5=int(x,base=16) # 结果为整数42481
y6=int(x,base=0) # 结果为整数4248120. range()
[*]格式：
print(f'{ float("1.23") = }')
print(f'{ float("+1.23") = }')
print(f'{ float("-1.23") = }')
print(f'{ float(" -1.23") = }')
'''
float("1.23") = 1.23
float("+1.23") = 1.23
float("-1.23") = -1.23
float(" -1.23") = -1.23
'''
[*]返回值：range 类型
range 构造器的参数必须为整数。如果省略 step 参数，其默认值为 1。 如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。
如果 step 为正值，确定 range 内容的公式为 r = start + step * i 其中 i >= 0 且 r < stop。
如果 step 为负值，确定 range 内容的公式仍然为 r = start + step * i，但限制条件改为 i >= 0 且 r > stop.
如果 r 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。
# >>> float('+1.23')
# 1.23
# >>> float(' -12345\n')
# -12345.0
# >>> float('1e-003')
# 0.001
# >>> float('+1E6')
# 1000000.0
# >>> float('-Infinity')
# -inf21. list()
[*]格式：
class range(stop)
class range(start, stop[, step])
[*]返回值： 构造器将构造一个列表，其中的项与 iterable 中的项具有相同的的值与顺序。 iterable 可以是序列、支持迭代的容器或其它可迭代对象。
::: tip 创建列表的几种方式
[*]方括号直接赋值：
>>> list(range(10))
>>> list(range(1, 11))
>>> list(range(0, 30, 5))
>>> list(range(0, 10, 3))
>>> list(range(0, -10, -1))
>>> list(range(0))
[]
>>> list(range(1, 0))
[]
[*]列表推导式:
class list()
[*]类型构造器list()函数：
x=[]
y=:::
如果没有给出参数，构造器将创建一个空列表 []。
22. dict()
[*]格式：
[*]参数说明：
[*]**kwargs -- 关键字。
[*]mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
[*]iterable -- 可迭代对象。
[*]返回值：返回一个新的字典，基于可选的位置参数和可能为空的关键字参数集来初始化。
::: tip 创建字典的几种方式
[*]大括号直接赋值：
x=list("abcdefg")
x1=list((1,2,3))
[*]字典推导式:
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
[*]类型构造器dict()函数：
dict1 = {}
dict1['chinese'] = 100
dict1['math'] = 80
dict1 = {'firstname':'ma', 'lastname':'yun'}:::
如果给出一个位置参数并且其属于映射对象，将创建一个具有与映射对象相同键值对的字典。
def fun(x):
return x**3
y={x:fun(x) for x in range(0,6)}
# {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}否则的话，位置参数必须为一个 iterable 对象。
该可迭代对象中的每一项本身必须为一个刚好包含两个元素的可迭代对象。
每一项中的第一个对象将成为新字典的一个键，第二个对象将成为其对应的值。
x=dict({"one": 1, "two": 2, "three": 3})
print(x)如果一个键出现一次以上，该键的最后一个值将成为其在新字典中对应的值。
如果给出了关键字参数，则关键字参数及其值会被加入到基于位置参数创建的字典。
如果要加入的键已存在，来自关键字参数的值将替代来自位置参数的值。
print(f'{ dict({"one": 1, "two": 2, "three": 3}) = }')23. tuple()
[*]格式： class tuple()
[*]返回值： 构造器将构造一个元组，其中的项与 iterable 中的项具有相同的值与顺序。
::: tip 构造元组的几种方式
[*]圆括号直接赋值：
x=dict([("one",1),("two",2)])
y=dict((["one",1],["two",2]))
[*]tuple()函数
print(f'{ dict(one=1, two=2, three=3) = }')
print(f'{ dict({"two": 2, "three": 3}, one=1) = }')
print(f'{ dict({"one": 11, "two": 2, "three": 3}, one=1) = }'):::
注意决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。 例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时传参三元组。
24. set()
[*]格式： class set()
[*]返回值： 返回一个新的 set 或 frozenset 对象，其元素来自于 iterable。 集合的元素必须为 hashable。 要表示由集合对象构成的集合，所有的内层集合必须为 frozenset 对象。 如果未指定 iterable，则将返回一个新的空集合。
x=(1,)#使用一个后缀的逗号来表示单元组
x=(1,2,3)#使用以逗号分隔的多个项25. str()
[*]格式：
print(f'{ tuple(["a", "b", "c"]) = }')
print(f'{ tuple(("a", "b", "c")) = }')
print(f'{ tuple(range(3)) = }')
print(f'{ tuple("abc") = }')
# tuple(["a", "b", "c"]) = ('a', 'b', 'c')
# tuple(("a", "b", "c")) = ('a', 'b', 'c')
# tuple(range(3)) = (0, 1, 2)
# tuple("abc") = ('a', 'b', 'c')
[*]返回值：返回 object的字符串版本。 如果未提供 object 则返回空字符串。
如果 encoding 或 errors 均未给出，str(object) 返回 object.str()，这是 object 的“非正式”或格式良好的字符串表示。 对于字符串对象，这是该字符串本身。 如果 object 没有 str() 方法，则 str() 将回退为返回 repr(object)。
print(f'{ set(["a", "b", "c"]) = }')
print(f'{ set(["a", "b", "c", "a"]) = }')
print(f'{ set(("a", "b", "c")) = }')
print(f'{ set(range(3)) = }')
print(f'{ set("abc") = }')
# set(["a", "b", "c"]) = {'b', 'c', 'a'}
# set(["a", "b", "c", "a"]) = {'b', 'c', 'a'}
# set(("a", "b", "c")) = {'b', 'c', 'a'}
# set(range(3)) = {0, 1, 2}
# set("abc") = {'b', 'c', 'a'}26. complex()
[*]格式：class complex(])
[*]返回值： 返回值为real + imag*1j的复数，或将字符串或数字转换为复数。
如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。
print(f'{ str(123) = }')
print(f'{ str() = }')
print(f'{ str(range(3)) = }')
print(f'{ str("test") = }')
# str(123) = '123'
# str() = ''
# str(range(3)) = 'range(0, 3)'
# str("test") = 'test'27. bytearray()
class bytearray(]])
返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0
页:
[1]