python 内置函数简介及其作用
1. abs() 函数
- abs() 函数返回数字的绝对值。
- 语法
- abs( x )
- 参数
- x -- 数值表达式，可以是整数，浮点数，复数。
- 返回值
- 函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
实例：
num1 = 52 num2 = -52 num3 = 100.10 print(abs(num1)) print(abs(num2)) print(abs(num3)) # 52 # 52 # 100.1
2. dict() 函数
- dict() 函数用于创建一个字典。
- 语法：
- class dict(**kwarg)
- class dict(mapping, **kwarg)
- class dict(iterable, **kwarg)
- 参数说明：
- **kwargs -- 关键字
- mapping -- 元素的容器。
- iterable -- 可迭代对象。
- 返回值：
- 返回一个字典。
实例：
data1 = dict() # 使用dict函数创建一个空字典 data2 = dict(name="菜鸟程序员",age=18,gender="male") # 传入关键字 data3 = dict(zip(['name', 'age', 'gender'], ["菜鸟程序员", 18, "male"])) # 映射函数方式来构造字典 data4 = dict([('name', "菜鸟程序员"), ('age', 18), ('gender', "male")]) # 可迭代对象方式来构造字典 print(data1) print(data2) print(data3) print(data4) """ {} {'gender': 'male', 'name': '菜鸟程序员', 'age': 18} {'age': 18, 'name': '菜鸟程序员', 'gender': 'male'} {'age': 18, 'name': '菜鸟程序员', 'gender': 'male'} """
3. help() 函数
- help() 函数用于查看函数或模块用途的详细说明。
- 语法
- help([object])
- 参数说明：
- object -- 对象；
- 返回值
- 返回对象帮助信息。
实例：
help_sys = help('sys') # 查看 sys 模块的帮助 help_str = help('str') # 查看 str 数据类型的帮助 my_list = [1, 2, 3] help_list = help(my_list) # 查看列表 list 帮助信息 help_list_append = help(my_list.append) # 显示list的append方法的帮助
4. min() 函数
- min() 方法返回给定参数的最小值，参数可以为序列。
- 语法
- min( x, y, z, .... )
- 参数
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
- 返回值
- 返回给定参数的最小值。
实例：
my_tuple = (5,2,34,9,15,78,-80) my_list = [5,2,34,9,15,78,-80] print(min(my_tuple)) print(min(my_list)) # -80 # -80
5. setattr() 函数
- setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
- 语法
- setattr(object, name, value)
- 参数
- object -- 对象。
- name -- 字符串，对象属性。
- value -- 属性值。
- 返回值
- 无。
实例：
# 对已存在的属性进行赋值： class A(object): bar = 1 a = A() print(getattr(a, 'bar')) # 获取属性 bar 值 setattr(a, 'bar', 5) # 设置属性 bar 值 print(a.bar) # 如果属性不存在会创建一个新的对象属性，并对属性赋值： class B(): name = "runoob" b = B() setattr(b, "age", 18) print(b.age) # 1 # 5 # 28
6. all() 函数
- all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
- 函数等价于：
def all(iterable): for element in iterable: if not element: return False return True - 语法 all(iterable)
- 参数 iterable -- 元组或列表。
- 返回值
- 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
- 注意：空元组、空列表返回值为True，这里要特别注意。
# 1. 字典，元素都不为空或0 data_1 = { "name": "菜鸟程序员", "age": 18, "gender": "male" } status_1 = all([data_1["name"], data_1["age"], data_1["gender"]]) print(status_1) # 2. 字典，元素name为空 data_2 = { "name": None, "age": 18, "gender": "male" } status_2 = all([data_2["name"], data_2["age"], data_2["gender"]]) print(status_2) # 3. 列表list，元素都不为空或0 list_1 = ["菜鸟程序员",18,"male"] status_3 = all(list_1) print(status_3) # 4. 列表list，存在一个为空的元素 list_2 = ["",18,"male"] status_4 = all(list_2) print(status_4) # 5. 列表list，存在一个为0的元素 list_3 = ["菜鸟程序员",0,"male"] status_5 = all(list_3) print(status_5) # 6. 元组tuple，元素都不为空或0 tuple_1 = ("菜鸟程序员",18,"male") status_6 = all(tuple_1) print(status_6) # 7. 元组tuple，存在一个为0的元素 tuple_2 = ("菜鸟程序员",0,"male") status_7 = all(tuple_2) print(status_7) print(all([])) print(all(())) """ 结果： True False True False False True False True True """
7. dir() 函数
- dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
- 语法
- dir([object])
- 参数说明：
- object -- 对象、变量、类型。
- 返回值 返回模块的属性列表。
实例：
# 获得 当前模块 的属性列表 print(dir()) # 查看 列表 的方法 my_list = list() print(dir(my_list)) # 查看 元祖 的方法 my_tuple = tuple() print(dir(my_tuple)) # 查看 字典 的方法 my_dict = dict() print(dir(my_dict)) # 查看 set集合 的方法 my_set = set() print(dir(my_set)) """ ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'] ['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update'] """
8. hex() 函数
- hex() 函数用于将一个指定数字转换为 16 进制数。
- 语法
- hex(x)
- 参数说明：
- x -- 一个整数
- 返回值
- 返回一个字符串，以 0x 开头。
实例：
# 将 十进制的255 转换为 16进制 print(hex(255)) # 将 十进制的-42 转换为 16进制 print(hex(-42)) # 将 十进制的12 转换为 16进制 print(hex(12)) # 将 十进制的12 转换为 16进制，获取返回值类型 print(type(hex(12))) """ 0xff -0x2a 0xc <class 'str'> """
9. next() 函数
- next() 返回迭代器的下一个项目。
- 语法
- next(iterator[, default])
- 参数说明：
- iterator -- 可迭代对象
- default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
- 返回值
- 返回对象帮助信息。
实例：
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break """ 1 2 3 4 5 """
10. slice() 函数
- slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
- 语法
- class slice(stop)
- class slice(start, stop[, step])
- 参数说明：
- start -- 起始位置
- stop -- 结束位置
- step -- 间距
- 返回值
- 返回一个切片对象。
实例：
my_slice = slice(5) # 设置截取5个元素的切片 print(my_slice) # 定义一个列表 my_list = list() # 循环0-9 for i in range(10): # 将循环出来的每个对象添加至my_list my_list.append(i) print(my_list) print(my_list[my_slice]) # 截取 5 个元素 """ slice(None, 5, None) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4] """
11. any() 函数
- any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
- 函数等价于：
def any(iterable): for element in iterable: if element: return True return False - 语法
- any(iterable)
- 参数
- iterable -- 元组或列表。
- 返回值
- 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
实例：
print(any(['a', 'b', 'c', 'd'])) # 列表list，元素都不为空或0 print(any(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素 print(any([0, '', False])) # 列表list,元素全为0,'',false print(any(('a', 'b', 'c', 'd'))) # 元组tuple，元素都不为空或0 print(any(('a', 'b', '', 'd'))) # 元组tuple，存在一个为空的元素 print(any((0, '', False))) # 元组tuple，元素全为0,'',false print(any([])) # 空列表 print(any(())) # 空元组 """ True True False True True False False False """
12. divmod() 函数
- Python divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。在 python 3.x 版本该函数不支持复数。
- 语法
- divmod(a, b) 参数说明：
- a: 数字，非复数。
- b: 数字，非复数。 如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。 如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。 如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。
实例：
print(divmod(7, 2)) print(divmod(8, 2)) print(divmod(8, -2)) print(divmod(3, 1.3)) """ (3, 1) (4, 0) (-4, 0) (2.0, 0.3999999999999999) """
13. id() 函数
- id() 函数返回对象的唯一标识符，标识符是一个整数。CPython 中 id() 函数用于获取对象的内存地址。
- 语法
- id([object])
- 参数说明：
- object -- 对象。
- 返回值 返回对象的内存地址。
实例：
string = '菜鸟程序员' print(id(string)) # 打印变量string的内存地址 def func(): return '菜鸟程序员' print(id(func)) # 打印 函数func 的内存地址 """ 2417805698744 2417805850824 """
14. sorted() 函数
- sorted() 函数对所有可迭代的对象进行排序操作。
- 语法
- sorted(iterable, key=None, reverse=False)
- 参数说明：
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
- 返回值
- 返回重新排序的列表。
实例：
# 列表排序 my_list = [33,28,18,23,21] print(sorted(my_list)) # 使用list.sort()方法排序(效率更高) my_list_1 = [33,28,18,23,21] my_list_1.sort() print(my_list_1) # 利用key进行倒序排序 example_list = [5, 0, 6, 1, 2, 7, 3, 4] result_list = sorted(example_list, key=lambda x: x*-1) print(result_list) # 要进行反向排序，也通过传入第三个参数 reverse=True： reverse_list = [5, 0, 6, 1, 2, 7, 3, 4] print(sorted(reverse_list, reverse=True)) # 元祖排序 my_tuple = (33,28,18,23,21) print(sorted(my_tuple)) # 字典排序 my_dict = { 33: 'age', 28: 'age', 18: 'age', 23: 'age', 21: 'age' } print(sorted(my_dict)) """ [18, 21, 23, 28, 33] [18, 21, 23, 28, 33] [7, 6, 5, 4, 3, 2, 1, 0] [7, 6, 5, 4, 3, 2, 1, 0] [18, 21, 23, 28, 33] [18, 21, 23, 28, 33] """
15. ascii() 函数
- ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
- 语法
- ascii(object)
- 参数
- object -- 对象。
- 返回值
- 返回字符串。
实例：
string_1 = "菜鸟程序员" print(ascii(string_1)) string_2 = "python" print(ascii(string_2)) """ 'u83dcu9e1fu7a0bu5e8fu5458' 'python' """
16. enumerate() 函数
- enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
- 语法
- enumerate(sequence, [start=0])
- 参数
- sequence -- 一个序列、迭代器或其他支持迭代对象。
- start -- 下标起始位置。
- 返回值
- 返回 enumerate(枚举) 对象。
实例：
my_list_1 = ["菜鸟程序员",18,"male"] print(list(enumerate(my_list_1))) print(list(enumerate(my_list_1, start=1))) # 下标从 1 开始 my_list_2 = ["菜鸟程序员",18,"male"] tuple_list = list() i = 0 for element in my_list_2: my_tuple = (i,my_list_2[i]) tuple_list.append(my_tuple) i += 1 print(tuple_list) my_list_3 = ["菜鸟程序员",18,"male"] for i, element in enumerate(my_list_3): print(i, my_list_3[i]) """ [(0, '菜鸟程序员'), (1, 18), (2, 'male')] [(1, '菜鸟程序员'), (2, 18), (3, 'male')] [(0, '菜鸟程序员'), (1, 18), (2, 'male')] 0 菜鸟程序员 1 18 2 male """
17. input() 函数
- Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
- 函数语法
- input([prompt])
- 参数说明：
- prompt: 提示信息
实例：
while True: name = input("你爱我吗?: ") if name == "爱": print("******* 灯红酒绿惹人醉，大哥带你混社会。*******") break elif name == "不爱": print("******* 你是好人我不配，忘了我吧下一位。*******") else: print("******* 花花世界迷人眼，没有实力别赛脸。*******")
18. oct() 函数
- oct() 函数将一个整数转换成8进制字符串
- 语法
- oct(x)
- 参数说明：
- x -- 整数。
- 返回值
- 返回8进制字符串。
实例：
print(oct(10)) print(oct(20)) print(oct(15)) """ 0o12 0o24 0o17 """
19. staticmethod() 函数
- python staticmethod 返回函数的静态方法。该方法不强制要求传递参数，如下声明一个静态方法：
class C(object): @staticmethod def f(arg1, arg2, ...): ... # 以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。 - 函数语法
- staticmethod(function)
- 参数说明：
- 无
实例：
class MyClass(object): @staticmethod def f(): print('菜鸟程序员') MyClass.f() # 静态方法无需实例化 cobj = MyClass() cobj.f() # 也可以实例化后调用 """ 菜鸟程序员 菜鸟程序员 """
20. bin() 函数
- bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
- 语法
- bin(x)
- 参数
- x -- int 或者 long int 数字
- 返回值
- 字符串。
实例：
print(bin(10)) print(bin(20)) """ 0b1010 0b10100 """
21. eval() 函数
- eval() 函数用来执行一个字符串表达式，并返回表达式的值。
- 语法
- eval(expression[, globals[, locals]])
- 参数
- expression -- 表达式。
- globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
- locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
- 返回值
- 返回表达式计算结果。
实例：
x = 7 print(eval('3 * x')) print(eval('pow(2,2)')) print(eval('2 + 2')) n = 81 print(eval('n + 4')) dict_str = '{"name":"菜鸟程序员","age":18,"gender":True}' print(type(eval(dict_str))) print(eval(dict_str)) list_str = '["菜鸟程序员", 18, True]' print(type(eval(list_str))) print(eval(list_str)) tuple_str = '("菜鸟程序员", 18, True)' print(type(eval(tuple_str))) print(eval(tuple_str)) """ 21 4 4 85 <class 'dict'> {'name': '菜鸟程序员', 'age': 18, 'gender': True} <class 'list'> ['菜鸟程序员', 18, True] <class 'tuple'> ('菜鸟程序员', 18, True) """
22. int() 函数
- int() 函数用于将一个字符串或数字转换为整型。
- 语法
- class int(x, base=10)
- 参数
- x -- 字符串或数字。
- base -- 进制数，默认十进制。
- 返回值
- 返回整型数据。
实例：
print(int()) # int() 函数默认值 print(int(3)) print(int(3.6)) print(int('12',16)) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 print(int('0xa',16)) print(int('10',8)) print(int("9")) # 默认10进制 print(int("1001",2)) print(int("0xa",16)) # "1001"才是2进制格式，并转化为十进制数字9 print(int("123",8)) # 视123为8进制数字，对应的10进制为83 ############################### 错误示范 ############################### print(int("9",2)) # 报错，因为2进制无9 print(int("3.14",8)) # 报错，str须为整数 print(int("1.2")) # 报错，str须为整数 print(int("b",8)) # 报错,≥16进制才会允许入参为a,b,c... """ 0 3 3 18 10 8 9 9 10 83 Traceback (most recent call last): File "D:/projects/学习项目目录/python相关/python 常用模块/python 内置函数/22. python-int() 函数.py", line 13, in <module> print(int("9",2)) # 报错，因为2进制无9 ValueError: invalid literal for int() with base 2: '9' """
23. open() 函数
- Python open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
- 语法
- open(file, mode='r')
- open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- 参数
- file: 必需，文件路径（相对或者绝对路径）。
- mode: 可选，文件打开模式
- buffering: 设置缓冲
- encoding: 一般使用utf8
- errors: 报错级别
- newline: 区分换行符
- closefd: 传入的file参数类型
- opener:
- mode 参数有：
- 模式 描述
- t 文本模式 (默认)。
- x 写模式，新建一个文件，如果该文件已存在则会报错。
- b 二进制模式。
-
-
打开一个文件进行更新(可读可写)。
-
- U 通用换行模式（不推荐）。
- r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
- rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
- r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
- rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
- w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
- wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
- w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
- wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
- a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
- ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
- a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
- ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
- 默认为文本模式，如果要以二进制模式打开，加上 b 。
参考：https://www.cnblogs.com/xingxingnbsp/p/12408522.html
24. str() 函数
- str() 函数将对象转化为适于人阅读的形式。
- 语法
- class str(object='')
- 参数
- object -- 对象。
- 返回值
- 返回一个对象的string格式。
实例：
name = '菜鸟程序员' print(str(name)) print(type(str(name))) age = 18 print(str(age)) print(type(str(age))) gender = True print(str(gender)) print(type(str(gender))) my_dict = {'name': '菜鸟程序员', 'age': 18, 'gender': True} print(str(my_dict)) print(type(str(my_dict))) my_list = ['菜鸟程序员', 18, True] print(str(my_list)) print(type(str(my_list))) my_tuple = ('菜鸟程序员', 18, True) print(str(my_tuple)) print(type(str(my_tuple))) my_set = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(str(my_set)) # set 集合自带去重 print(type(str(my_set))) """ 菜鸟程序员 <class 'str'> 18 <class 'str'> True <class 'str'> {'gender': True, 'name': '菜鸟程序员', 'age': 18} <class 'str'> ['菜鸟程序员', 18, True] <class 'str'> ('菜鸟程序员', 18, True) <class 'str'> {'orange', 'banana', 'pear', 'apple'} <class 'str'> """
25. bool() 函数
- bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
- 语法
- class bool([x])
- 参数
- x -- 要进行转换的参数。
- 返回值
- 返回 True 或 False。
实例：
print(bool()) print(bool(0)) print(bool(1)) print(bool(2)) print(issubclass(bool, int)) # bool 是 int 子类 """ False False True True True """
26. exec 函数
- exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
- 语法
- exec(object[, globals[, locals]])
- 参数
- object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
- globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
- locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
- 返回值
- exec 返回值永远为 None。
实例：
exec('print("Hello World")') # 单行语句字符串 exec("print ('runoob.com')") # 多行语句字符串 exec(""" for i in range(5): print ("iter time: %d" % i) """) """ Hello World runoob.com iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4 """
27. isinstance() 函数
- isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
- 语法
- isinstance(object, classinfo)
- 参数
- object -- 实例对象。
- classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
- 返回值
- 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
实例：
a = 2 print(isinstance (a,int)) # 判断 变量a 是否为 int类型 print(isinstance (a,str)) # 判断 变量a 是否为 str类型 print(isinstance (a,(str,int,list))) # 判断 变量a 是否为 str|int|list 中的一个 # type() 与 isinstance() 区别： class A: pass class B(A): pass print(isinstance(A(), A)) print(type(A()) == A) print(isinstance(B(), A)) print(type(B()) == A) """ True False True True True True False """
28. ord() 函数
- ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
- 语法
- ord(c)
- 参数
- c -- 字符。
- 返回值
- 返回值是对应的十进制整数。
实例：
print(ord('a')) print(ord('€')) """ 97 8364 """
29. sum() 函数
- sum() 方法对系列进行求和计算。
- 语法
- sum(iterable[, start])
- 参数
- iterable -- 可迭代对象，如：列表、元组、集合。
- start -- 指定相加的参数，如果没有设置这个值，默认为0。
- 返回值
- 返回计算结果。
实例：
list_1 = [12,34,56] list_2 = [0,21,59,48,90,42] list_3 = [59,48,90,42] print(sum(list_1)) print(sum(list_2, 1)) # 元组计算总和后再加 1 print(sum(list_3, 2)) # 列表计算总和后再加 2 """ 102 261 241 """
30. bytearray() 函数
- bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
- 语法
- class bytearray([source[, encoding[, errors]]])
- 参数
- 如果 source 为整数，则返回一个长度为 source 的初始化数组；
- 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
- 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
- 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数，默认就是初始化数组为0个元素。
- 返回值
- 返回新字节数组。
实例：
print(bytearray()) print(bytearray([1,2,3])) print(bytearray('菜鸟程序员', 'utf-8')) """ bytearray(b'') bytearray(b'x01x02x03') bytearray(b'xe8x8fx9cxe9xb8x9fxe7xa8x8bxe5xbax8fxe5x91x98') """
31. filter() 函数
- filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
- 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
- 语法
- filter(function, iterable)
- 参数
- function -- 判断函数。
- iterable -- 可迭代对象。
- 返回值
- 返回一个迭代器对象
实例：
# 过滤出列表中的所有奇数： def is_odd(n): return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) newlist = list(tmplist) print(newlist) # [1, 3, 5, 7, 9] # 过滤出1~100中平方根是整数的数： import math def is_sqr(x): return math.sqrt(x) % 1 == 0 tmplist = filter(is_sqr, range(1, 101)) newlist = list(tmplist) print(newlist) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
32. issubclass() 函数
- issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
- 语法
- issubclass(class, classinfo)
- 参数
- class -- 类。
- classinfo -- 类。
- 返回值
- 如果 class 是 classinfo 的子类返回 True，否则返回 False。
实例：
class A: pass class B(A): pass print(issubclass(B, A)) # 返回 True
33. pow() 函数
- pow() 方法返回 xy（x的y次方） 的值。
- 语法
import math math.pow( x, y ) # 内置的 pow() 方法 pow(x, y[, z])- 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
- 注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
- 参数
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
- 返回值
- 返回 xy（x的y次方） 的值。
实例：
import math # 导入 math 模块 print ("math.pow(100, 2) : ", math.pow(100, 2)) # 使用内置，查看输出结果区别 print ("pow(100, 2) : ", pow(100, 2)) print ("math.pow(100, -2) : ", math.pow(100, -2)) print ("math.pow(2, 4) : ", math.pow(2, 4)) print ("math.pow(3, 0) : ", math.pow(3, 0)) """ math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0 """
34. super() 函数
- 描述
- super() 函数是用于调用父类(超类)的一个方法。
- super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
- MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
- 语法
- super(type[, object-or-type])
- 参数
- type -- 类。
- object-or-type -- 类，一般是 self
- 返回值 无。
实例：
class A: def add(self, x): y = x + 1 print(y) class B(A): def add(self, x): super().add(x) b = B() b.add(2) # 3
35. bytes 函数
- 描述
- bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
- 语法
- class bytes([source[, encoding[, errors]]])
- 参数
- 如果 source 为整数，则返回一个长度为 source 的初始化数组；
- 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
- 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
- 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数，默认就是初始化数组为0个元素。
- 返回值
- 返回一个新的 bytes 对象。
实例：
a = bytes([1,2,3,4]) print(a) print(type(a)) b = bytes('hello','ascii') print(b) print(type(b)) """ b'x01x02x03x04' <class 'bytes'> b'hello' <class 'bytes'> """
36. float() 函数
- 描述
- float() 函数用于将整数和字符串转换成浮点数。
- 语法
- class float([x])
- 参数
- x -- 整数或字符串
- 返回值
- 返回浮点数。
实例：
print(float(1)) print(float(112)) print(float(-123.6)) print(float('123')) # 字符串 """ 1.0 112.0 -123.6 123.0 """
37. iter() 函数
- 描述
- iter() 函数用来生成迭代器。
- 语法
- iter(object[, sentinel])
- 参数
- object -- 支持迭代的集合对象。
- sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
- 返回值
- 迭代器对象。
实例：
lst = [1, 2, 3] for i in iter(lst): print(i) """ 1 2 3 """
38. print() 函数
- 描述
- print() 方法用于打印输出，最常见的一个函数。
- 语法
- print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False)
- 参数
- objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep -- 用来间隔多个对象，默认值是一个空格。
- end -- 用来设定以什么结尾。默认值是换行符 ，我们可以换成其他字符串。
- file -- 要写入的文件对象。
- flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
- 返回值
- 无。
实例：
# 以下展示了使用 print函数 的实例： print(1) print("Hello World") a = 1 b = 'runoob' print(a, b) print("aaa""bbb") print("aaa", "bbb") print("www", "runoob", "com", sep=".") # 设置间隔符 # 使用flush参数生成一个Loading的效果： import time print("---RUNOOB EXAMPLE ： Loading 效果---") print("Loading", end="") for i in range(20): print(".", end='', flush=True) time.sleep(0.5) """ 1 Hello World 1 runoob aaabbb aaa bbb www.runoob.com ---RUNOOB EXAMPLE ： Loading 效果--- Loading....... """
39. tuple 函数
- 描述
- tuple 函数将可迭代系列（如列表）转换为元组。
- 语法
- tuple( iterable )
- 参数
- iterable -- 要转换为元组的可迭代序列。
- 返回值
- 返回元组。
实例：
list1 = ['Google', 'Taobao', 'Runoob', 'Baidu'] tuple1 = tuple(list1) print(tuple1) a = 'www' b = tuple(a) print(b) a = {'www': 123, 'aaa': 234} b = tuple(a) # 将字段转换为元组时，只保留键！ print(b) a = set('abcd') print(a) b = tuple(a) print(b) """ ('Google', 'Taobao', 'Runoob', 'Baidu') ('w', 'w', 'w') ('aaa', 'www') {'b', 'd', 'a', 'c'} ('b', 'd', 'a', 'c') """
40. callable() 函数
- 描述
- callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
- 对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
- 语法
- callable(object)
- 参数
- object -- 对象
- 返回值
- 可调用返回 True，否则返回 False。
实例：
print(callable(0)) print(callable("runoob")) def add(a, b): return a + b print(callable(add)) # 函数返回 True class A: # 类 def method(self): return 0 print(callable(A)) # 类返回 True a = A() print(callable(a)) # 没有实现 __call__, 返回 False class B: def __call__(self): return 0 print(callable(B)) b = B() print(callable(b)) # 实现 __call__, 返回 True """ False False True True False True True """
41. format 格式化函数
- 描述
- format 函数用来格式化字符串
- 语法 .format(object)
- 参数
- object -- 可以是一个对象，函数，字符串，数字
- 返回值
- 返回格式化后的字符串，或对象
实例：
# 默认传参 str_1 = "我是{}，我今年{}岁，我的性别是{}".format("菜鸟程序员", 18, "男") print(str_1) # 位置传参 str_2 = "我是{0}，我今年{1}岁，我的性别是{2}".format("菜鸟程序员", 18, "男") print(str_2) # 位置传参 str_3 = "我是{1}，我今年{0}岁，我的性别是{2}".format(18, "菜鸟程序员", "男") print(str_3) # 关键字传参 str_4 = "我是{name}，我今年{age}岁，我的性别是{gender}".format(age=18, name="菜鸟程序员", gender="男") print(str_4) # 字典传参数 data = {"name": "菜鸟程序员", "age": 18, "gender": "男"} str_5 = "我是{name}，我今年{age}岁，我的性别是{gender}".format(**data) print(str_5) # 通过列表索引设置参数 my_list = ['菜鸟程序员', 18, "男"] str_6 = "我是{0[0]}，我今年{0[1]}岁，我的性别是{0[2]}".format(my_list) # "0" 是必须的 print(str_6) """ 我是菜鸟程序员，我今年18岁，我的性别是男 我是菜鸟程序员，我今年18岁，我的性别是男 我是菜鸟程序员，我今年18岁，我的性别是男 我是菜鸟程序员，我今年18岁，我的性别是男 我是菜鸟程序员，我今年18岁，我的性别是男 我是菜鸟程序员，我今年18岁，我的性别是男 """
42. len()方法
- 描述
- Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
- 语法
- len( s )
- 参数
- s -- 对象。
- 返回值
- 返回对象长度。
实例：
str_1 = "菜鸟程序员" print(len(str_1)) # 字符串长度 list_1 = [1, 2, 3, 4, 5] print(len(list_1)) # 列表元素个数 tuple_1 = (1, 2, 3, 4, 5) print(len(tuple_1)) dict_1 = {"name": "菜鸟程序员", "age": 18, "gender": True} print(len(dict_1)) set_1 = {"name", "age", "gender"} print(len(set_1)) """ 5 5 5 3 3 """ ######################################### 错误示范 ############################################ """ num_1 = 18 print(len(num_1)) # TypeError: object of type 'int' has no len() bool_1 = True print(len(bool_1)) # TypeError: object of type 'bool' has no len() float_1 = 3.14 print(len(float_1)) # TypeError: object of type 'float' has no len() """
43. property() 函数
- 描述
- property() 函数的作用是在新式类中返回属性值。
- 语法
- class property([fget[, fset[, fdel[, doc]]]])
- 参数
- fget -- 获取属性值的函数
- fset -- 设置属性值的函数
- fdel -- 删除属性值函数
- doc -- 属性描述信息
- 返回值
- 返回新式类属性。
实例：
class C(object): def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.") class Parrot(object): def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage class D(object): def __init__(self): self._x = None @property def x(self): """I'm the 'x' property.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
44. type() 函数
- 描述
- type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
isinstance() 与 type() 区别： type() 不会认为子类是一种父类类型，不考虑继承关系。 isinstance() 会认为子类是一种父类类型，考虑继承关系。 如果要判断两个类型是否相同推荐使用 isinstance()。 - 语法
- type(object)
- type(name, bases, dict)
- 参数
- name -- 类的名称。
- bases -- 基类的元组。
- dict -- 字典，类内定义的命名空间变量。
- 返回值
- 一个参数返回对象类型, 三个参数，返回新的类型对象。
实例：
name = "菜鸟程序员" print(type(name)) age = 18 print(type(age)) gender = True print(type(gender)) my_dict = {"name": "菜鸟程序员", "age": 18, "gender": True} print(type(my_dict)) my_list = ["菜鸟程序员", 18, True] print(type(my_list)) my_set = {"菜鸟程序员", 18, True} print(type(my_set)) my_tuple = ("菜鸟程序员", 18, True) print(type(my_tuple)) def my_func(): pass print(type(my_func)) class my_class(object): pass print(type(my_class)) """ <class 'str'> <class 'int'> <class 'bool'> <class 'dict'> <class 'list'> <class 'set'> <class 'tuple'> <class 'function'> <class 'type'> """
45. chr() 函数
- 描述
- chr() 用一个整数作参数，返回一个对应的字符。
- 语法
- chr(i)
- 参数
- i -- 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。
- 返回值
- 返回值是当前整数对应的 ASCII 字符。
实例：
print(chr(0x30)) print(chr(97)) print(chr(8364)) """ 0 a € """
46. frozenset() 函数
- 描述
- frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
- 语法
- class frozenset([iterable])
- 参数
- iterable -- 可迭代的对象，比如列表、字典、元组等等。
- 返回值
- 返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
实例：
a = frozenset(range(10)) # 生成一个新的不可变集合 print(a) b = frozenset('菜鸟程序员') # 创建不可变集合 print(b) """ frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) frozenset({'鸟', '程', '员', '菜', '序'}) """
47. list()方法
- 描述
- list() 方法用于将元组或字符串转换为列表。
- 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
- 语法
- list( seq )
- 参数
- seq -- 要转换为列表的元组或字符串。
- 返回值
- 返回列表。
实例：
my_tuple = ("菜鸟程序员", 18, True) list1 = list(my_tuple) print("列表元素 : ", list1) name = "菜鸟程序员" list2 = list(name) print("列表元素 : ", list2) """ 列表元素 : ['菜鸟程序员', 18, True] 列表元素 : ['菜', '鸟', '程', '序', '员'] """
48. range() 函数用法
- 描述
- Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
- Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。
- Python2 range() 函数返回的是列表。
- 函数语法
- range(stop)
- range(start, stop[, step])
- 参数说明：
- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
- stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
实例：
for i in range(5): print(i) print(list(range(0, 30, 5))) print(list(range(0, 10, 2))) print(list(range(0, -10, -1))) print(list(range(1, 0))) """ 0 1 2 3 4 [0, 5, 10, 15, 20, 25] [0, 2, 4, 6, 8] [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] [] """
49. vars() 函数
- 描述
- vars() 函数返回对象object的属性和属性值的字典对象。
- 语法
- vars([object])
- 参数
- object -- 对象
- 返回值
- 返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
实例：
print(vars()) class Runoob: a = 1 print(vars(Runoob)) runoob = Runoob() print(vars(runoob)) """ {'__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, '__name__': '__main__', '__file__': 'D:/projects/学习项目目录/python相关/python 常用模块/python 内置函数/49. python-vars() 函数.py', '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002B9AC196B38>, '__spec__': None} {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, 'a': 1} {} """
50. classmethod 修饰符
- 描述
- classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
- 语法
- 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() # 不需要实例化 """ func2 1 foo """
51. getattr() 函数
- 描述
- getattr() 函数用于返回一个对象属性值。
- 语法
- getattr(object, name[, default])
- 参数
- object -- 对象。
- name -- 字符串，对象属性。
- default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
- 返回值
- 返回对象属性值。
实例：
class A(object): bar = 1 a = A() print(getattr(a, 'bar')) # 获取属性 bar 值 """ print(getattr(a, 'bar2')) # 属性 bar2 不存在，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'bar2' """ print(getattr(a, 'bar2', 3)) # 属性 bar2 不存在，但设置了默认值 """ 1 3 """
52. locals() 函数
- 描述
- locals() 函数会以字典类型返回当前位置的全部局部变量。
- 对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
- 语法
- locals()
- 参数
- 无
- 返回值
- 返回字典类型的局部变量。
实例：
def func(name): # 两个局部变量：arg、z age = 18 gender = True print (locals()) func("菜鸟程序员") """ {'name': '菜鸟程序员', 'age': 18, 'gender': True} """
53. repr() 函数
- 描述
- repr() 函数将对象转化为供解释器读取的形式。
- 语法
- repr(object)
- 参数
- object -- 对象。
- 返回值
- 返回一个对象的 string 格式。
实例：
name = '菜鸟程序员' print(repr(name)) dict = {'name': '菜鸟程序员', 'age': 18, 'gender': True} print(repr(dict)) """ '菜鸟程序员' {'name': '菜鸟程序员', 'gender': True, 'age': 18} """
54. zip() 函数
- 描述
- zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
- 我们可以使用 list() 转换来输出列表。
- 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
- zip 方法在 Python 2 和 Python 3 中的不同：在 Python 2.x zip() 返回的是一个列表。
- 语法
- zip([iterable, ...])
- 参数说明：
- iterabl -- 一个或多个迭代器;
- 返回值
- 返回一个对象。
实例：
a = [1, 2, 3] b = [4, 5, 6] c = [4, 5, 6, 7, 8] zipped = zip(a, b) # 返回一个对象 print(zipped) print(list(zipped)) # list() 转换为列表 print(list(zip(a, c))) # 元素个数与最短的列表一致 a1, a2 = zip(*zip(a, b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式 print(list(a1)) print(list(a2)) """ <zip object at 0x000002686FBF41C8> [(1, 4), (2, 5), (3, 6)] [(1, 4), (2, 5), (3, 6)] [1, 2, 3] [4, 5, 6] """
55. compile() 函数
- 描述
- compile() 函数将一个字符串编译为字节代码。
- 语法
- compile(source, filename, mode[, flags[, dont_inherit]])
- 参数
- source -- 字符串或者AST（Abstract Syntax Trees）对象。。
- filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
- mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
- flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
- flags和dont_inherit是用来控制编译源码时的标志
- 返回值
- 返回表达式执行结果。
实例：
str = "for i in range(0,10): print(i)" c = compile(str,'','exec') # 编译为字节代码对象 print(c) print(exec(c)) str = "3 * 4 + 5" a = compile(str,'','eval') print(eval(a)) """ <code object <module> at 0x000002608A160B70, file "", line 1> 0 1 2 3 4 5 6 7 8 9 None 17 """
56. globals() 函数
- 描述
- globals() 函数会以字典类型返回当前位置的全部全局变量。
- 语法
- globals()
- 参数
- 无
- 返回值
- 返回全局变量的字典。
实例：
my_dict = {'name': '菜鸟程序员', 'age': 18, 'gender': True}
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
"""
{'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027060226B38>, '__package__': None, '__cached__': None, '__file__': 'D:/projects/学习项目目录/python相关/python 常用模块/python 内置函数/56. python-globals() 函数.py', 'my_dict': {'gender': True, 'name': '菜鸟程序员', 'age': 18}, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__doc__': None}
"""
# 扩展=====================================================================
# 该函数修改全局变量my_dict
def func():
#
global my_dict
my_dict = {'name': '小李子', 'age': 48, 'gender': "不男不女"}
def func1():
return my_dict
def func2():
return my_dict
if __name__ == '__main__':
print(func1()) # 打印修改之前的全局变量
func() # 调用func函数修改全局变量
print(func2()) # 打印修改之后的全局变量
"""
{'age': 18, 'gender': True, 'name': '菜鸟程序员'}
{'age': 48, 'gender': '不男不女', 'name': '小李子'}
"""
57. map() 函数
- 描述
- map() 会根据提供的函数对指定序列做映射。
- 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
- 语法
- map(function, iterable, ...)
- 参数
- function -- 函数
- iterable -- 一个或多个序列
- 返回值
- Python 2.x 返回列表。
- Python 3.x 返回迭代器。
实例：
# 计算平方数 def square(x): return x ** 2 # 计算列表各个元素的平方 print(map(square, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数 print(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 提供了两个列表，对相同位置的列表数据进行相加 print(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
58. reversed 函数
- 描述
- reversed 函数返回一个反转的迭代器。
- 语法
- reversed(seq)
- 参数
- seq -- 要转换的序列，可以是 tuple, string, list 或 range。
- 返回值
- 返回一个反转的迭代器。
实例：
# 字符串 seqString = 'Runoob' print(list(reversed(seqString))) # 元组 seqTuple = ('R', 'u', 'n', 'o', 'o', 'b') print(list(reversed(seqTuple))) # range seqRange = range(5, 9) print(list(reversed(seqRange))) # 列表 seqList = [1, 2, 4, 3, 5] print(list(reversed(seqList))) """ ['b', 'o', 'o', 'n', 'u', 'R'] ['b', 'o', 'o', 'n', 'u', 'R'] [8, 7, 6, 5] [5, 3, 4, 2, 1] """
59. import() 函数
- 描述
- import() 函数用于动态加载类和函数 。
- 如果一个模块经常变化就可以使用 import() 来动态载入。
- 语法
- import(name[, globals[, locals[, fromlist[, level]]]])
- 参数说明：
- name -- 模块名
- 返回值
- 返回元组列表。
60. complex() 函数
- 描述
- complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
- 语法
- class complex([real[, imag]])
- 参数说明：
- real -- int, long, float或字符串；
- imag -- int, long, float；
- 返回值
- 返回一个复数。
实例：
print(complex(1, 2)) print(complex(1)) # 数字 print(complex("1")) # 当做字符串处理 # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 print(complex("1+2j")) """ (1+2j) (1+0j) (1+0j) (1+2j) """
61. hasattr() 函数
- 描述
- hasattr() 函数用于判断对象是否包含对应的属性。
- 语法
- hasattr(object, name)
- 参数
- object -- 对象。
- name -- 字符串，属性名。
- 返回值
- 如果对象有该属性返回 True，否则返回 False。
实例：
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x')) print(hasattr(point1, 'y')) print(hasattr(point1, 'z')) print(hasattr(point1, 'no')) # 没有该属性 """ True True True False """
62. max() 函数
- 描述
- max() 方法返回给定参数的最大值，参数可以为序列。
- 语法
- max( x, y, z, .... )
- 参数
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
- 返回值
- 返回给定参数的最大值。
实例：
print ("max(80, 100, 1000) : ", max(80, 100, 1000)) print ("max(-20, 100, 400) : ", max(-20, 100, 400)) print ("max(-80, -20, -10) : ", max(-80, -20, -10)) print ("max(0, 100, -400) : ", max(0, 100, -400)) """ max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100 """
63. round() 函数
- 描述
- round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。
- 精度要求高的，不建议使用该函数。
- 语法
- round( x [, n] )
- 参数
- x -- 数字表达式。
- n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
- 返回值
- 返回浮点数x的四舍五入值。
实例：
print ("round(70.23456) : ", round(70.23456)) print ("round(56.659,1) : ", round(56.659,1)) print ("round(80.264, 2) : ", round(80.264, 2)) print ("round(100.000056, 3) : ", round(100.000056, 3)) print ("round(-100.000056, 3) : ", round(-100.000056, 3)) """ round(70.23456) : 70 round(56.659,1) : 56.7 round(80.264, 2) : 80.26 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0 """
64. delattr() 函数
- 描述
- delattr 函数用于删除属性。
- delattr(x, 'foobar') 相等于 del x.foobar。
- 语法
- delattr(object, name)
- 参数
- object -- 对象。
- name -- 必须是对象的属性。
- 返回值
- 无。
实例：
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ', point1.x) print('y = ', point1.y) print('z = ', point1.z) delattr(Coordinate, 'z') print('--删除 z 属性后--') print('x = ', point1.x) print('y = ', point1.y) # 触发错误 print('z = ', point1.z) """ x = 10 y = -5 z = 0 --删除 z 属性后-- x = 10 y = -5 Traceback (most recent call last): File "D:/projects/学习项目目录/python相关/python 常用模块/python 内置函数/64. python-delattr() 函数.py", line 16, in <module> print('z = ', point1.z) AttributeError: 'Coordinate' object has no attribute 'z' """
65. hash() 函数
- 描述
- hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
- 语法
- hash(object)
- 参数说明：
- object -- 对象；
- 返回值
- 返回对象的哈希值。
实例：
print(hash('test')) # 字符串 print(hash(1)) # 数字 print(hash(str([1,2,3]))) # 集合 print(hash(str(sorted({'1':1})))) # 字典 """ -1439481417051484773 1 7079383964553032146 9045757919402142588 """
66. memoryview() 函数
- 描述
- memoryview() 函数返回给定参数的内存查看对象(Momory view)。
- 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
- 语法
- memoryview(obj)
- 参数说明：
- obj -- 对象
- 返回值
- 返回元组列表。
实例：
v = memoryview(bytearray("abcefg", 'utf-8')) print(v[1]) print(v[-1]) print(v[1:4]) print(v[1:4].tobytes()) """ 98 103 <memory at 0x000001E3CEBCE1C8> b'bce' """
67. set() 函数
- 描述
- set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
- 语法
- class set([iterable])
- 参数说明：
- iterable -- 可迭代对象对象；
- 返回值
- 返回新的集合对象。
实例：
x = set('菜鸟程序员_python') y = set('Python,py3') print(x, y) print(x & y) # 交集 print(x | y) # 并集 print(x - y) # 差集 """ {'序', '员', 'n', 'o', 'y', '程', 't', '鸟', '_', '菜', 'p', 'h'} {'n', 'P', '3', 'o', 'y', 't', ',', 'p', 'h'} {'n', 'o', 'y', 't', 'p', 'h'} {'序', '员', 'n', 'P', '3', 'o', 'y', '程', 't', '鸟', '_', ',', '菜', 'p', 'h'} {'序', '员', '程', '鸟', '_', '菜'} """