python 内置函数简介及其作用

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'}
{'序', '员', '程', '鸟', '_', '菜'}
"""