Python 内置函数

获取数字的绝对值（abs）

	"""
    参数可以是整数、浮点数、复数（z=a+bj）      如果你不知道复数是啥，当我没说= 。=
    """
    # 输出整数的绝对值  结果：1
    print(abs(-1))
    # 输出浮点数的绝对值     结果：1.5
    print(abs(-1.5))
    # 输出复数的绝对值      结果：2.23606797749979
    print(abs(1 + 2j))

创建一个复数（complex）

 	# 创建输出一个复数  
 	# 输出：(1+2j)

    print(complex(1, 2))

四舍五入（round）

	# 四舍五入  该方法不太精确，不能适用于精确计算
    # 保留小数点后两位  输出：2.67 别奇怪结果，都说了不太准确
    print(round(2.675, 2))

获取两数相除的商和余数（divmod）

 """
    参数可以是整数、浮点数
    返回值的格式(a//b,a%b)  a//b是整除
    """
    # 输出5.1除2.1的商和余数  输出结果：(2.0, 0.8999999999999995)
    print(divmod(5.1, 2.1))

控制台输入（input）

 	"""
    参数是字符串类型
    可以接受任意内容，把接受的内容转换成字符串类型
    """
    # 接收控制台输入的内容
    info = input("输入内容：")
    # 打印内容
    print(info)

打开文件（open）

 """
    参数：
    mode: 可选，文件打开的模式
        默认为r，常用的就r、w、a、b
        模式	描述
        t	以文本格式打开
        x	写模式，新建一个文件，如果该文件已存在则会报错。
        b	以二进制模式读取
        +	打开一个文件进行，可读可写。
        r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
        rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
        r+	打开一个文件用于读写。文件指针将会放在文件的开头。
        rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
        w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
        ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。        
    buffering: 设置缓冲
        设置为0时，表示不使用缓冲区，直接读写，仅在二进制模式下有效。
        设置为1时，表示在文本模式下使用行缓冲区方式。
        设置为大于1时，设置缓冲区的大小
        
        为什么要使用缓冲区？
            比如我们从磁盘读取信息，我们先把读出的数据放在缓冲区，计算机再直接从缓冲区中取数据，
            等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作大大快于对磁盘的操作，
            故使用缓冲区可大大提高计算机的运行速度。
    encoding: 编码
        一般使用utf8
        参数encoding是指明对文件编码，仅适用于文本文件。
        如果不指定编码方式，默认是使用locale.getpreferredencoding()函数返回的编码方式。
    
    errors: 报错级别
    newline: 确定换行符
        文本模式之下，设定一行的结束字符。
        当在读取模式下，如果新行符为None，那么就作为通用换行符模式工作，意思就是说当遇到\n，\r或\r\n都可以作为换行标识，并且统一转换为\n作为文本输入的换行符。
        当设置为’’时，也是通用换行符模式工作，但不转换为\n，输入什么样的，就保持原样全输入。
        当设置为其它相应字符时，就会判断到相应的字符作为换行符，并保持原样输入到文本。
        
        三种操作系统下的换行符：
        在Windows中：
        '\r' 回车，回到当前行的行首，而不会换到下一行，如果接着输出的话，本行以前的内容会被逐一覆盖；
        '\n' 换行，换到当前位置的下一行，而不会回到行首；
        
        Windows系统里面，每行结尾是“<回车><换行>”，即“\r\n”；
        Unix系统里，每行结尾只有“<换行>”，即"\n"；
        Mac系统里，每行结尾是“<回车>”，即"\r"；
        一个直接后果是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号
        因为三种操作系统的文本换行符不一致，跨平台时对文本文件非常不友好，在判定是否换行时容易出问题。
    closefd: 传入的file参数类型
    
    总结：文本文件处理时应该当心，一是缓冲区，二是编码、三是换行符（三种操作系统换行符不一致）
    """
    # 打开nihao.txt，可读可写，使用缓冲区，编码为'utf-8'，newline设置为\r\n(windows操作系统的换行规则)
    file = open('测试.txt', mode='r+', buffering=1, encoding='utf-8', newline='\r\n')

把元组、字符串、等转换为列表（list）

 """
    1、把字符串转换为列表  
    结果：['1', '2', '3'] 
    相当于把字符串的每个字符都放到列表    
    """
    a = list('123')
    print(a)
    """
    2、把元组转换为列表
    结果：[1, 2]
    相当于把最外层的小括号换位中括号
    """
    b = list((1, 2))
    print(b)

把多个数组、对象转化成一个元组（zip）

	"""
    1、将多个对象中的对应元素打包成一个元组，节省内存。
        例如：原来有三个对象，现在把这三个对象打包成一个元组对象，那么就减少了两个对象的内存开销，也不会丢失数据。
    """
    # 定义两个数组对象
    a = [1, 2, 3]
    b = [4, 5, 6]

    # 进行对象打包
    result = zip(a, b)

    # 把打包的对象转换成列表输出，转换成列表输出是因为容易观察。
    # 输出结果：[(1, 4), (2, 5), (3, 6)]
    print(list(result))
    """
    2、将打包后的元组对象转换为多个对象（zip的逆过程）
    """
    # 定义两个数组对象
    a = [1, 2, 3]
    b = [4, 5, 6]
    # 打包对象
    result = zip(a, b)
    # 解包对象
    c, d = zip(*result)
    # 输出解包后的对象
    #  输出结果：(1, 2, 3) (4, 5, 6)
    print(c, d)

    """
    3、如果多个对象元素的个数不一样，那么打包的时候会发生什么？
        打包出来的元组长度和这些对象中最短的长度一致，木桶中水的高度取决于最短木板的高度。
    """
    # 定义两个数组对象 a的长度为4，b的长度为3
    a = [1, 2, 3, 4]
    b = [4, 5, 6]
    # 打包两个对象
    c = zip(a, b)
    # 输出打包后的内容
    # 输出内容：[(1, 4), (2, 5), (3, 6)]  长度为3  和对象中最短的长度一致
    print(list(c))

把列表等转换为元组（tuple）

# 字符串转换为元组  输出：('1', '2', '3')
    a = '123'
    print(tuple(a))
    # 列表转换为元组   输出：('1', '2', '3')
    b = ['4', '5', '6']
    print(tuple(b))
    # 集合转换为元组   输出：(1, 2, 3)
    c = {1, 2, 3}
    print(tuple(c))
    # 字典转换为元组   输出：(1, 3)  只获取字典的key
    d = {1: 2, 3: 4}
    print(tuple(d))

将两个数组转换为字典（dict）

 	"""
    将两个数组转换为字典
    1、利用zip对两个数组进行打包
    2、利用dic对打包后的元组对象转换为字典
    """
    # 定义两个数组对象
    a = [1, 2, 3]
    b = [4, 5, 6]
    # 打包两个数组对象
    c = zip(a, b)
    # 转换为字典
    result = dict(c)
    # 输出字典
    # 输出结果：{1: 4, 2: 5, 3: 6}
    print(result)

查看函数或模块用途的详细说明（help）

	import sys

    # 查看sys模块的详细内容，也就是说明书
    print(help('sys'))

查看一个源文件（模块）的属性和方法（dir）

 	# 输出当前源文件中的变量、方法。
    print(dir())
    # 输出字符串源文件中的变量和方法
    print(dir(''))
    # 输出列表源文件中的变量和方法
    print(dir([]))
    # 以此类推

获得最小值（min）

	"""
    比较规则：每个字符都有一个编码的值，按照编码进行排序，获得最小值
    """
    """
    1、min的参数是列表
    输出：1
    """
    a = [1, 2, 3]
    print('列表')
    print(min(a))
    """
    2、min的参数是元组
    输出：4
    """
    b = (4, 5, 6)
    print('元组')
    print(min(b))
    """
    3、min的参数是集合
    输出：4
    """
    b = {4, 5, 6}
    print('集合')
    print(min(b))
    """
    4、min的参数是字典
    """
    b = {'a': 4, 'b': 5, 'b': 3}
    # 获取字典最小key  输出：a
    print('字典的key')
    print(min(b))
    # 获取字典最小value 输出：3
    print('字典的value的key')
    # 获取字典最小value的key	这里的参数key是比较的规则，元素根据参数key的规则进行比较，找到最小值
    minKey = min(b, key=lambda x: [b[x]])
    # 根据key得到value
    print(b[minKey])
    """
    5、min的参数是字符串
    输出：a
    实质上：把字符串每个字符转换为列表，再进行min的类似操作
    """
    c = "abc"
    print(min(c))
    """
    6、min的参数是多个变量
    输出：1
    """
    print(min(1, 2, 3))

获得最大值（ max）

和’获得最小值’没啥区别，只是一个最小，一个最大。请往上滑查看详细内容。

多次调用一个函数（map）

 	"""
    map:多次调用一个函数，输入n个列表，输出一个列表。
        第一个参数是函数，也可以是lambda表达式
        第二个参数是n个列表，取决于函数要使用参数的数量
    """
    """
    输出列表中值的绝对值，相当于列表中的每个数都调用了abs函数。
    使用list是因为可以展示结果。
    输出：[1, 2, 1]
    """
    print(list(map(abs, [1, 2, -1])))


    # 定义函数计算两个数的和
    def add(x, y):
        return x + y


    """
    输出两个数组对应值相加的结果，为什么需要两个列表？
    因为add函数需要两个参数，第一个列表相当于x的值，第二个列表相当于y的值
    输出：[2, 4, 6]
    """
    print(list(map(add, [1, 2, 3], [1, 2, 3])))

    """
    函数也可以换成lambda表达式
    例如：lambda x, y: x + y   x,y代表两个参数 x+y是返回的值  中间用冒号分开
    输出两个数组对应值相加的结果，和上面功能一致，只不过换成了lambda表达式
    输出：[2, 4, 6]
    """
    print(list(map(lambda x, y: x + y, [1, 2, 3], [1, 2, 3])))

无序不重复的集合（set）

	"""
    set：无序不重复
        无序是指：元素进出的顺序不一致  可能a先进来，a最后一个出去。
        不重复是因为set使用hashcode来存储，一个hashcode只能对应一个值。
    """
    # 输出自定义一个集合  输出：{'i', 'Q', 'u', 'X', 'n', 'a', 'F'}
    a = set('QianFuXin')
    print(a)
    # 定义一个集合
    b = set('DiLiReBa')

    # 输出a和b的交集
    print(a & b)
    # 输出a和b的并集
    print(a | b)
    # 输出a和b差集   在集合a中但不在集合b中的元素。
    print(a - b)
    # 输出两个集合的补集   集合a和b的非共同元素。
    print(a ^ b)

生成一定范围的数字（range）

	"""
    range没啥好说的，就是生成一定范围的数字
    参数如下：
    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)
    """
    # 输出1-20（不包括20）之间的奇数
    # 结果：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
    print(list(range(1, 20, 2)))

设置类、对象的属性（setattr）

    """
    # A类
    class A:
    # 类变量
    name = '小明'
    def __init__(self, name):
        # 实例变量
        self.name = name
    如果第一个参数是类，那就设置类变量的值
    如果第一个参数是对象，那就设置对象变量的值
    如果变量不存在，那就创建这个变量
    """
    # 实例化对象
    a = A('小红')

    # 设置对象变量'name'的值为'小刚'
    setattr(a, 'name', '小刚')
    # 输出验证  输出：小刚
    print(getattr(a, 'name'))

    # 如果变量不存在，创建变量,创建'sex'变量
    setattr(a, 'sex', 'man')
    # 输出验证  输出：man
    print(getattr(a, 'sex'))

获得类、对象的属性（getattr）

	"""
    # A类
    class A:
    # 类变量
    name = '小明'
    def __init__(self, name):
        # 实例变量
        self.name = name
    如果第一个参数是类，那就获取类变量的值
    如果第一个参数是对象，那就获取对象变量的值
    如果变量不存在，会异常
    """
    # 实例化对象
    a = A('小红')
    # 获取对象变量'name'的值  输出：小红
    print(getattr(a, 'name'))
    # 获取类变量'name'的值   输出：小明
    print(getattr(A, 'name'))

判断类是否有某个属性（hasattr）

	# 类A
    class A:
        # 部门属性
        deparment = '1'

        def __init__(self, name):
            # 姓名属性
            self.name = ''


    # 判断A类对象是否有name、age属性
    a = A('小明')
    # 输出：True
    print(hasattr(a, 'name'))
    # 输出：False
    print(hasattr(a,'sex'))

删除某个类的属性（delattr）

	# 类A
    class A:
        # 部门属性
        deparment = '1'

        def __init__(self, name):
            # 姓名属性
            self.name = ''

    # 删除deparment属性
    delattr(A, 'deparment')

判断所有元素是否都为有效值（all）

有效值的定义：除了 0、’’、None、False 外都是有效值

	 """
    all:全部元素都为有效值，才返回True,列表（元组等其他）长度为0，也返回True
    有效值：除了 0、''、None、False 外都是有效值
    适用：列表、元组、集合、字典（只和key的值有关）、字符串
    """
    # 虽然字典的value是无效值，但是字典的key是有效值，所以返回True
    d = {'1': '', '2': None, '3': False}
    # 输出:True
    print(all(d))

判断所有元素是否都为无效值（any）

无效值的定义： 0、’’、None、False

    """
    any:只要有一个元素为有效值，就返回True,列表（元组等其他）长度为0，返回False
    有效值：除了 0、''、None、False 外都是有效值
    适用：列表、元组、集合、字典（只和key的值有关）、字符串
    """
    # 虽然字典只有一个key是有效值，any也返回True
    d = {'': 1, '': 2, '3': 3}
    # 输出:True
    print(any(d))

将一个十进制的数转化为十六进制（hex）

 	# 输出42的十六进制  输出：0x2a
    print(hex(42))

将一个数转化为八进制（oct）

	# 输出42的八进制  输出：0o52
    print(oct(42))

将一个数转化为二进制（bin）

 	# 输出12的二进制  输出：0b1100
    print(bin(12))

转换为迭代器（iter）

	"""
    iter的作用：1、将列表、元组等对象转换为可迭代对象
                2、重复调用一个函数，持续到函数的返回值等于你设定的值
    适用：列表、元组、集合、字符串
    """
    # 将列表转换为可迭代对象  个人感觉写不写iter都一样
    a = [1, 2, 3, 4]
    for i in iter(a):
        print(i)
    import random


    # 定义函数
    def randomNumber():
        # 随机返回1-10的数字
        return random.randint(1, 10)


    # 随机得到1-10的数字，如果数字是3，结束循环
    for i in iter(randomNumber, 3):
        # 输出数字
        print(i)

返回迭代器的下个元素（next）

	# 定义迭代器  适用：列表、元组、集合、字符串
    a = iter([1, 2, 3, 4])
    while True:
        # 获得迭代器的下个元素，如果数组迭代结束，就返回'over'
        element = next(a, 'over')
        # 输出元素
        print(element)
        # 终止循环
        if element == ('over'):
            break

分割元素（slice）

	"""
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    获得a的前6项该怎么处理？
    新手：a[0],a[1],a[2],a[3],a[4],a[5]
    入门：a[:6]
    ok,获得a的前6项的奇数项怎么处理？
    入门的方法就无从下手了，需要使用slice
    slice的三个参数：起始位置、结束位置、步长
    适用：列表、元组、字符串
    """
    # 自定义列表
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # 构建slice，起始位置是0，结束位置是6，步长是2
    s = slice(0, 6, 2)
    # 输出a的前六项的奇数项  输出：1、3、5
    print(a[s])

返回对象的内存地址（id）

 	a = 3
    # 输出a的内存地址  输出：4311182192
    print(id(a))
    a = 4
    # 输出a的内存地址  输出：4438428560
    print(id(a))

对可迭代器中的元素进行排序（sorted）

	"""
    默认升序，如果想降序，reverse=True
    支持：列表、元组、集合、字典、字符串
    """
    # 定义列表
    a = [-9, 2, 8, 1]
    # 输出降序
    print(sorted(a, reverse=True))
    # 输出按照绝对值进行降序  key是排序的规则，只是排序，不改变元素的值。
    print(sorted(a, key=abs, reverse=True))

    # 定义字典
    b = {1: 100, 2: 20, 3: 50}
    # 输出按照字典的key降序
    print(sorted(b, reverse=True))
    # 输出按照字典的value降序
    print(sorted(b, key=lambda x: b[x]))

返回对象的编码字符（ascii）

	# 输出对象的编码字符，默认使用ASCII编码，如果超出该编码的范围，就使用\u或者\x
    # 输出结果：'22\u5c81\u4e86'
    print(ascii('22岁了'))
   

获得下标和对应的值（enumerate）

"""
    enumerate：输出列表的下标和对应的值  下标的值默认从0开始，也可设置其他值
    适用：元组、列表、字符串
    """
    a = [1, 2, 3]
    # 输出列表的下标和对应的值，默认从1开始使用list是因为方便输出
    # 输出:[(1, 1), (2, 2), (3, 3)]
    print(list(enumerate(a, start=1)))

转化为int类型（int）

 	# str转换为int类型  输出：3
    print(int('3'))
    # float转换为int类型  输出：3
    print(int(3.12))
    # bool转换为int类型  输出：0   如果是True，输出1
    print(int(False))

转化为str类型（str）

 	# int转换为str类型  输出：3
    print(str(3))
    # float转换为str   输出：3.12
    print(str(3.12))
    # bool转化为str    输出：True
    print(str(True))

转化为float类型（float）

  	# int转换为float类型     输出：3.0
    print(float(3))
    # str转换为float类型     输出3.1
    print(float('3.1')) 
    # bool转换为float类型    输出：1.0  如果是False，输出0.0
    print(float(True))

转化为bool类型（bool）

 	# int转换为bool类型  只有0输出False，其他值都输出True
    # 输出：True
    print(bool(1))
    # float转换为bool类型    只有0.0输出False，其他值都输出True
    # 输出：True
    print(bool(0.1))
    # str转换为bool类型      只有None和''输出False，其他值都输出True
    # 输出：False
    print(bool(None))

将一个字符转换为数字（ord）

    #  输出字符'a'的数字形式  输出结果：97
    print(ord('a'))

将一个数字转为字符（chr）

	# 输出数字123的字符内容  输出结果：{
    print(chr(123))

静态方法（staticmethod）

class A:

    def __init__(self ):
        pass

    # 该函数的作用：输出一个随机数，和类、对象都没有鸟关系，所以可以把该函数设为static
    @staticmethod
    def randomNumber():
        print(random.randint(1, 100))
"""
staticmethod
当某个方法不需要用到对象和类的任何资源时,可以把这个方法改为一个静态方法, 在方法上方加一个@staticmethod。
类和实例都可以调用该函数
"""
# 实例调用该方法
A().randomNumber()
# 类调用该方法
A.randomNumber()

类方法（classmethod）

class A:
    # 类A已经实例化对象的个数，实例化一个对象，number就+1
    number = 0

    def __init__(self):
        # 实例化对象数量+1
        A.number += 1

    # 查看当前已经实例化对象的个数,用类就可以调用此函数
    @classmethod
    def printNumber(cls):
        print('已经实例化' + str(cls.number) + '个对象')


if __name__ == '__main__':
    # 不用创建实例就可以调用此函数
    A.printNumber()

执行字符串格式的代码（eval）

	"""
    eval函数  执行字符串格式的代码，不建议使用，会带来系统安全风险（百度去）
    参数：
    单个表达式  
    全局变量
    局部变量
    """
    a = 1
    b = 2
    # 输出：3
    result = eval('a+b')
    print(result)

    # 使用全局变量  见到a替换成3，见到b替换成4  输出：7
    result = eval('a+b', {'a': 3, 'b': 4})
    print(result)

    # 同时使用全局变量和局部变量   两者同时存在且发生冲突，局部变量说的算...  输出：30
    result = eval('a+b', {'a': 3, 'b': 4}, {'a': 10, 'b': 20})
    print(result)
    """
    表达式相当于孩子
    全局变量相当于爸爸
    局部变量相当于妈妈

    爸爸在，听爸爸的话，妈妈在，听妈妈的话，爸爸妈妈同时在，优先听妈妈的话.....
    """

执行字符串格式的代码（exec）

	"""
    exec函数   执行字符串格式的代码，不建议使用，会带来系统安全风险（百度去）
    参数：
    复杂语句
    全局变量
    局部变量
    """
    a = 1
    b = 2
    # 复杂的语句，输出a,b的最大值
    code = """
if a>b:
    print(a)
else :
    print(b)
    """
    # 执行字符串，输出：2
    exec(code)
    # 使用全局变量 见到a替换成2，见到b替换成10  输出：10
    exec(code, {'a': 2, 'b': 10})
    # 同时使用全局变量和局部变量  两者同时存在且发生冲突，局部变量说的算...
    # 输出：20
    exec(code,{'a': 2, 'b': 10},{'a': 20, 'b': 10})
    """
        表达式相当于孩子
        全局变量相当于爸爸
        局部变量相当于妈妈

        爸爸在，听爸爸的话，妈妈在，听妈妈的话，爸爸妈妈同时在，优先听妈妈的话.....
    """

编译执行字符串格式的代码（compile）

	"""
    compile函数： 编译，类似编程语言的编译，
                编译之后，下次使用的时候可以直接使用，不需要再次编译。
    参数：
    字符串格式的代码
    文件对象
    编译的源码类型     exec、eval、single
    """
    # 代码
    code = 'for i in range(0,10): print(i)'

    # 方法一
    # 执行code（实质上：先编译再执行）
    exec(code)

    # 方法二
    # 先编译code
    code = compile(code, '', 'exec')
    # 再执行code
    exec(code)

    # 方法一和方法二达到的效果是一样的，方法二只需要一次编译，每次使用的时候都会编译一次

获得对象的类型（type）

	# type函数：返回输入对象的类型 
    # type函数不考虑继承关系，也就是说，父亲和儿子是同一种类型

    # 输出1的类型  输出:int
    print(type(1))

判断两者的类型是否相同（isinstance）

 	# isinstance函数：判断两者的类型是否相同，考虑继承关系，父亲和儿子的类型不同。

    # 输出1是否为int类型  输出：True
    print(isinstance(1, int))
    # 输出1是否为int、str其中的一个类型  输出：True
    print(isinstance(1, (int, str)))

判断两者是否为父子关系（issubclass）

	# issubclass函数：判断前者是否为后者的儿子  
    # 众所周知，bool类型继承int类型
    # 输出：True
    print(issubclass(bool, int))

求全部元素的总和（sum）

	"""
    sum函数：计算全部元素的总和
    参数：
    可迭代的列表
    结果额外相加的数  
    """
    # 输出1-9相加的结果，结果最后再加上2  输出：47
    print(sum(range(1, 10), 2))

留下某些符合条件的元素（filer）

	# filter函数：留下一些符合条件的元素，结果True则留下。

    # 奇数返回True、偶数返回False
    def isOdd(x):
        return x % 2 == 1


    # 留下1-100的奇数
    result = filter(isOdd, range(1, 101))
    # 输出结果
    print(list(result))

X的Y次方（pow）

 	# 输出2的3次方 结果：8
    print(pow(2, 3))
    # 输出2的三次方的结果进行%3  结果：2
    print(pow(2, 3, 3))

转化为字节格式（bytes）

	"""
    bytes函数：1、如果第一个参数是字符串,后面必须要加上编码。把字符串转为十六进制的字节格式的字符串
              2、如果第一个参数是数组、元组、集合，且所有元素的范围[0,255]，把数组转为十六进制的字节格式的字符串
    """
    # 第一个参数是字符串，输出：b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80'
    print(bytes('你好呀', encoding='utf-8'))

    # str类型的encode和bytes函数的功能一样,都是把字符串按照某种编码转换为字节内容
    # 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80'
    print('你好呀'.encode(encoding='utf-8'))

    # 第一个参数是数组，输出：b'\xff\x02\x03'
    print(bytes([255, 2, 3]))

转化为字节数组格式（bytesarray）

	"""
    bytearray：1、如果第一个参数是字符串,后面必须要加上编码。把字符串转为十六进制的字节格式的数组
              2、如果第一个参数是数组、元组、集合，且所有元素的范围[0,255]，把数组转为十六进制的字节格式的数组
    """
    # 1、第一个参数为字符串，输出:bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x91\x80')
    print(bytearray("你好呀", encoding='utf-8'))
    # 2、第二个参数是数组，输出：bytearray(b'\x01\x02\x03')
    print(bytearray([1, 2, 3]))
    # bytes和bytearray最大的区别是，前者返回字符串，后者返回数组。

调用父类的函数（super）

 	class father:
        def info(self):
            print('我是父亲')


    class B(father):
        def add(self):
            # 调用父亲的info函数
            super().info()
            print('我是儿子')


    # 儿子实例化
    b = B()
    # 调用add函数
    b.add()
    """
    输出：
    我是父亲
    我是儿子 
    """

检查一个对象是否可调用（callable）

    # 输出int变量是否为可调用的  输出：False
    print(callable(3))
    # 输出abs函数是否为可调用的的 输出：True
    print(callable(abs))

输出内容（print）

  	# 不输出到控制台，写入某个文件，生成日志文件。
    # 打开文件
    file = open('测试.txt', mode='a', encoding='utf-8')
    # 写入文件，结尾加上\n
    print('输出测试中', end='\n', file=file)

格式化（format）

	"""
    format函数：格式化
    """
    # 1、对应位置的格式化  输出：旺财是狗
    a = "{}是{}".format("旺财", "狗")
    print(a)
    # 2、指定位置的格式化（0代表第一个元素）  输出：旺财是狗
    b = "{0}是{1}".format("旺财", "狗")
    print(b)
    # 3、key-value的格式化   输出：旺财是狗
    c = "{a}是{b}".format(a='旺财', b='狗')
    print(c)
    # 4、通过字典进行格式化   输出：旺财是狗
    d = {'a': '旺财', 'b': '狗'}
    e = "{a}是{b}".format(**d)
    print(e)
    # 5、通过列表进行格式化   输出：旺财是（前面的0不可缺少）
    f = ['旺财', '狗']
    g = "{0[0]}是{0[1]}".format(f)
    print(g)
    # 6、数字的格式
    # 保留小数点n位  这里是2位 输出：1.00
    a = "{:.2f}".format(1)
    print(a)
    # 只保留整数     输出：1
    a = "{:.0f}".format(1.23)
    print(a)
    # 设置数字总位数为n，位数不够，左边补零。  也可以补其他的字符，把0更换即可
    # 输出：01
    a = "{:0>2d}".format(1)
    print(a)
    # 设置数字总位数为n，位数不够，右边边补零。  也可以补其他的字符，把0更换即可
    # 输出：10
    a = "{:0<2d}".format(1)
    print(a)
    # 数字太大时，可以以逗号分割，类似银行的数字  输出：10,000,000
    a = "{:,}".format(10000000)
    print(a)
    # 百分比 保留小数点后2位     输出：30.00%
    a = "{:.2%}".format(0.30)
    print(a)
    
    # 转化数字为对应的进制
    # 二进制   输出：10011
    a = '{:b}'.format(19)
    print(a)
    # 十进制   输出：19
    a = '{:d}'.format(19)
    print(a)
    # 八进制   输出：23
    a = '{:o}'.format(19)
    print(a)
    # 十六进制  输出：13
    a = '{:x}'.format(19)
    print(a)

获取全部元素的个数（len）

 	# 输出数组元素的个数  输出：3
    print(len([1, 2, 3]))

获取、设置、删除类的属性（property）

    class A:
        # 构造函数，name属性
        def __init__(self, name):
            self.name = name

        # 获得name属性
        def getName(self):
            return self.name

        # 设置name属性
        def setName(self, name):
            self.name = name

        # 删除name属性
        def delName(self):
            del self.name

        # 把属性name的set、get、del权限都放在propertyName
        propertyName = property(getName, setName, delName)


    # 实例化A
    a = A('小明')
    # 获得name属性  可以进行get、set、del（删除）
    # get属性
    print(a.propertyName)
    # set属性
    a.propertyName = '小红'
    # del属性
    del a.propertyName

冻结的集合（frozentset）

	# frozenset不能添加或删除任何元素
    # 输出frozenset集合  输出：frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})
    print(frozenset(range(1, 10)))
    # set和frozenset有点像list和tuple之间的关系

获取对象的属性和值（vars）

 	# vars函数：获取对象的属性和对应的值  如果不写参数，使用当前位置作为对象
    print(vars())

获取当前位置的局部变量（locals）

 	# 获取当前位置的局部变量
    print(locals())

获取当前位置的全局变量（globals）

	# 获取当前位置的全局变量
    print(globals())

获取对象的解释器形式

   	# 输出a的解释器形式，相当于是输出说明书
    a = ['1', '2']
    print(repr(a))

颠倒前后元素（reversed）

 	# 颠倒a的前后元素排列顺序  输出：[4, 3, 2, 1]
    a = [1,2,3,4]
    print(list(reversed(a)))

动态导入模块（import）

 	# 动态导入sys模块
    __import__('sys')

获取一个对象的hash值（hash）

 	# 输出a的hash值
    a = '珍惜眼前人'
    # 输出：8210466439863847528
    print(hash(a))