Python【day 13】内置函数01

1、python3.6.2 一共有 68个内置函数
2、分成6个大类
    1、反射相关-4个
    2、面向对象相关-9个

    3、作用域相关--2个
        1、globlas（）   #注意：最后是s，复数形式
           查看全局作用域中的全局变量的名字--返回的是字典

        2、locals()     #注意：最后是s，复数形式
           查看当前位置中变量的名字--返回的是字典
           1、当前位置是函数内，就是查看局部作用域中的局部变量的名字
           2、当前位置是函数外，就是查看全局作用域中的全局变量的名字（和globals()一样）
           取决于当前位置是函数内还是函数外

    4、迭代器、生成器相关-3个
        1、range()
            主要用于for循环，进行循环遍历

        2、iter() 和__iter__()
            001 __iter__()
            1、可迭代的：判断一个对象是否是可迭代类型的（可迭代的）--Iterable
               就看这个对象或者类的全部方法中是否包含__iter__()，包含就是可迭代的
               li1 = [1,2]
               print('__iter__' in dir(li1)) #True 就说明对象li1是可迭代的--Iterable
            2、可迭代的数据类型：str list tuple dict set open() range(3)
            3、迭代器：it1 = li1.__iter__() #这里it1就是迭代器--Iterator

            002 iter()   #内部执行依然用的是__iter__()
                li1 = [1,2]
                it1 = iter(li1)  #这里的it1就是迭代器--Iterator
                it1 = li1.__iter__()  #和上面等效

                def iter(args):
                    return args.__iter__()

            小结：
                it1 = iter(li1)  #这里的it1就是迭代器--Iterator 参数是可迭代对象
                it1 = li1.__iter__()

                写法
                迭代器1 = iter(可迭代对象)        #对象作为参数传入
                迭代器2 = 可迭代对象.__iter__()   #对象调方法

        3、next()和__next__()
            001 __next__()
            迭代器或者生成器向下取值，只能向下取值，不能后退
            1、迭代器向下取值
               li1 = [1,2]
               it1 = li1.__iter__()   #迭代器
               it1.__next__()   #取值一次
               next(li1)   #和上面等效
            2、生成器向下取值
                gen = (i for i in range(3))  #产生一个生成器
                gen.__next__() #取值一次
                next(li1)   #和上面等效

            002 next()  #内部执行依然用的是__next__()

            小结：
                迭代器对象.__next__()  #对象调方法
                next(迭代器对象)  #对象作为参数传入  和上面是等效的

                生成器对象.__next__()  #对象调方法
                next(生成器对象)  #对象作为参数传入  和上面是等效的

    5、其他-12个
        1、输入输出--2个
            input()
            print()

        2、内存相关--2个
            id() :输出对象的内存地址
            hash()

            数据结构--重点理解--及其重要--必须理解掌握
            1、列表（数组）：list(array)
                有索引号，有位置的一组数据
                优点：查询根据索引号，效率非常高
                缺点：删除一个元素或者新增一个元素，其他所有的元素都要移动位置，效率非常低

            2、链表：
                概念：由数据和后面的指针组成，指针指向下一个元素的位置，一个接一个
                类比：火车每一节车厢就是数据-装人，
                      车厢后面的连接处的车钩就是指针-指向下一节车厢
                优点：新增一个元素到指定位置，比如新增一个元素到位置2和位置3之间，
                        只需要把位置2后面的指针，指向新元素，然后把新元素的指针指向位置3即可完成；
                     删除一个指定位置的元素，比如删除位置4的元素，
                        只需要将位置3后面的指针指向位置5即可
                     上述不管是新增还是删除一个元素，都不需要向列表一个，整个列表其它元素的位置都要偏移
                     所以，新增或者删除的效率非常高
                缺点：查询的效率比较低
                      原因：要找到位置3的数据，需要找到位置2的指针，
                            找到位置2后，还需要找到位置1的指针
                            就是每次查询一个元素，都需要查询到这个元素的起点元素才行

            3、哈希表：hash（）
                概念:由列表和链表2部分组成
                    第一排是列表
                    第二排是列表的每个元素下面都连接着链表
                原理：哈希表在每次存储的时候，把对象（比如-alex）交给hash()算法计算出一个数值-哈希值，
                      根据这个数值，存储到对应的列表的索引号位置
                      比如：存储过程：   'alex'=5
                            'alex'这个变量经过hash()算法计算出的数值是5，那么就存储到索引号是5的位置（属于列表），
                            'alex'这个变量不是直接存放在索引号5这个位置，
                                    而是放在列表中索引号是5这个位置下面的链表的数据中
                            查询-取值过程：
                              下一次，取值或者查询、查找'alex'这个变量的时候，依然会根据对象交给hash()算法
                               计算出-哈希值（这里是5），然后直接取找5这个位置
                      备注：这里的5这个位置-或者索引号，就是'alex'这个变量在内存空间的内存地址--房间号

                优点：由于兼具列表和链表，所以新增、删除、查询的效率都非常高
                缺点：哈希表都比较的大，比如有100个索引号（内存编号）位置，只存储了10个数值，其余90个位置是空的，
                      就浪费了90%的空间
                      比较耗费空间--内存（就是以空间换时间）
                备注：空间换时间
                      空间上：浪费内存空间
                      时间上：快，效率高
                应用：字典的存储就是--哈希表
                      哈希表中列表存储的是字典的key，链表存储的是字典的value

                目前基本数据结构：列表（数组），链表，哈希表-dict（堆栈、队列、树）
                    基本数据类型：bool int(float) str list tuple dict set

        3、文件操作相关
            open()

        4、查看帮助
            help()

        5、查看对象或者类有哪些内置方法
            dir()

        6、查看变量名是否是可以被调用的,用来区分普通变量和函数名
            callable()

        7、模块导入相关
            __import__() #用的较少 一般是import os

        8、字符串类型代码的执行
            01 eval()  参数是字符串，返回的是去掉字符串两端的引号
                #1 将字符串形式的列表，转换成列表
                s1 = "['jack','tom']"  #字符串转换成了列表，去掉了两端的双引号
                print(eval(s1))  #['jack', 'tom']

                #2 将字符串形式的字典，转换成字典 应用场景：前后端传递数据的json串就是--字符串形式的字典
                s2 = "{'name':'jack','age':123}"  #字符串转换成了字典，去掉了两端的双引号
                print(eval(s2)) #{'name': 'jack', 'age': 123}

                #3 将字符串形式的数字，转换成数字int
                s3 = '12'
                print(eval(s3)) #12
                print(type(eval(s3))) #<class 'int'>

                #4 将字符串形式的数字表达式，转换表达式的结果-int  应用场景：计算器
                s4 = '1+2+3'
                print(eval(s4)) #6
                print(type(eval(s4))) #<class 'int'>

            2 exec()  可以执行字符串的代码，只是执行，没有返回值（可以变相获得返回结果
                print(exec('1+2+3'))  #None  没有返回值，所以是None
                print(exec('a=1+2+3')) #None 没有返回值，所以是None,但是'a=1+2+3' 相当于a=6  注意点
                print(exec('a=6')) #None 没有返回值，所以是None,和上面等效  变相获取返回结果
                print(a) #6

                eval（）和exec()之间的区别
                1、前者有返回值
                2、后者没有返回值（部分情况，可以变相获得返回值）

            3 compile() 将字符串类型的代码编译. 代码对象能够通过exec语句来执行或者eval()进行求值

            参数1：存放字符串类型的代码
            参数2：py文件的文件路径，类型是str
                   代码存放的⽂文件名, 当传⼊了第一个参数的时候, 这个参数给空就可以了
            参数3：模式，一共是3个，类型是str
                    1、模式1--eval模式，对应计算表达式，有返回值的，列表或者字典去掉双引号
                    2、模式2--exec模式，没有返回值的，比如for循环
                    3、模式3--single模式-交互模式，比如：含有input的

            上述参数1和参数2是二选一的
            如果用了参数1，参数2就是空字符串''

            compile(source, filename, mode)
            参数
            source -- 字符串或者AST（Abstract Syntax Trees）对象。。
            filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
            mode -- 指定编译代码的种类。可以指定为 exec, eval, single。

            返回值
            返回表达式执行结果

            compile()和---exec()、eval()的区别
            1、前者多了多代码的编译，最后还是要用到后者
            2、后者少了编译的动作，直接运行代码

    6、基本数据类型相关-38个
        1、和数字相关--14个
            1、数字类型--4个
                1、bool()
                    True 1及其他非空的，包括空格
                    False 0 None Null '' [] () {} set()

                2、int()   #整数

                3、float()  #小数

                4、complex() #复数
                    整数+小数=有理数
                        无理数：无限循环小数 比如：pi 1/3
                    有理数+无理数=实数
                        虚数：-1的平方根就是虚数
                    实数+虚数=复数

            2、进制转换--3个
                1、bin()  --十进制转二进制
                   0b开头表示二进制
                   0b101就是5

                2、oct（）--十进制转八进制
                    0o开头表示八进制
                    0o11就是9

                3、hex()  --十进制转十六进制
                    0x开头表示十六进制
                    0x11表示11

            3、数学运算--7个
                1、abs() --求绝对值

                2、divmod(arg1,args2) --求商和余数
                    参数1是被除数，参数2是除数

                3、pow(args1,args2)  --求args1的args2次方

                4、round(args1[,args2])  --四舍五入
                   将参数1进行四舍五入，参数2不是必须，如果参数2写了3，就是保留3位小数
                   注意：小数的四舍五入可能不准确

                    print(round(4.12345,2))  #4.12 四舍五入保留2位小数
                    print(round(4.5))  #4  因为4.5在计算机中可能是4.49999999999
                    print(round(9.5))  #10 因为9.5在计算机中可能是9.50000000001

                5、sum(Iterable[,int|float])
                    1、参数是可迭代的-Iterable
                    2、参数2可以不写，默认是0
                    3、参数1的元素和参数2可以是int，也可以是float
                    4、返回的是Iterable中元素的和，然后加上参数2
                    5、注意:1：参会1如果不是Iterable，就会报错
                        print(sum(1,2))  #报错 TypeError: 'int' object is not iterable
                    6、注意点2：参数1是字符串的时候
                        s1 = '123'  #当s1 = 123的时候，会自动把int123转换成str-'123'
                        print(s1,2)  #123 2

                6、max(arg1,arg2...argn)
                   max(Iterable)
                   1、如果是多个位置参数，则返回其最大值
                      位置参数推荐是int或者float，不推荐字符串
                    2、如果参数是Iterable，则返回其元素中最大值

                7、min(arg1,arg2...argn)
                   min(Iterable)
                   1、如果是多个位置参数，则返回其最小值
                      位置参数推荐是int或者float，不推荐字符串
                    2、如果参数是Iterable，则返回其元素中最小值

        2、和数据类型相关--24个
            1、数据集合--3个
                1 set()
                2 frozenset()
                    set和frozenset的区别  类似 列表和元组
                    set是可变类型，可以增删改
                    frozenset是不可变类型，不能增删改

                    不可变类型（可哈希的）可以作为字典的key
                    可变类型（不可哈希的）不能作为字典的key--会报错
                            TypeError: unhashable type: 'set'

                    不可变数据类型：str int|float  bool tuple frozenset
                    可变数据类型：list dict set
                3 dict()

            2、相关内置函数--8个
                1 len(Iterable)   求长度   -ok  1 代码注释-help  2 官网  3 cainiao
                    1、参数是可迭代的-Iterable
                        str list tuple dict set range()

                2 sorted(iterable, cmp=None, key=None, reverse=False)  排序
                    1、参数1是可迭代的-Iterable
                    2、后面的3个参数都是必选的（不写都有默认值）
                       1、reverse=False，默认升序
                          reverse=True，是降序
                        2、参数3--key
                            默认是None
                            比如：列表的元素是元组，按照元组的第二个元素进行排序
                    3、sorted()函数是将原迭代的对象复制了一份，而没有修改原对象本身
                                sorted()函数适用于所有的可迭代的类型--Iterble
                       sort()方法是列表的内置方法，对列表本身进行了修改
                                sort()方法只适用于列表
                    4、注意点：参数4是reverse,自动提示出来的是reversed，要区分

                3 enumerate(iterable, start=0) 枚举
                    1、参数1是可迭代的-Iterable
                    2、参数2表示索引的起始值

                4 any(Iterable)
                    any相等于or--或者
                    1、其参数中的元素有一个是True，结果就是True；
                    2、只有全部元素都是False，才是False；
                    3、如果是空列表、空元组，也是False；
                    4、0 None '' [] () {} set() False是False；其余都是True
                        0 None False 空--'' [] () {} set()
                    5、any的参数是可迭代的对象-Iterable

                5 all(Iterable)
                    all相等于and-并且，与
                    1、其参数中的全部元素都是True，结果才是True；有一个是False，结果就是False
                    2、0 None '' [] () {} set() False是False；其余都是True
                        0 None False 空--'' [] () {} set()
                    3、all的参数是可迭代的对象-Iterable
                    4、参数是空列表或者空元组，返回是True--特殊点

                6 zip([iterable1, iterable2,...])
                    1、将2个或者2个以上可迭代对象的对应位置的元素，打包成一个个元组
                        返回一个迭代器（可以转换成列表，也可以直接遍历循环）
                    2、如果可迭代对象的元素个数不相等，打包成元组的时候，以最少元素的为准
                    --水桶效应

            3、序列
                1、列表和元组
                    list()   #把参数转换成列表类型
                    tuple()  #把参数转换成元组类型

                2、翻转和切片
                    reversed() #把参数转换成迭代器，把迭代器转换成列表，元素就是反转的
                                #参数是可迭代类型-Iterable
                    slice()  #切片，不常用，了解即可，推荐li1[0:2]写法
                3、字符串相关
                    1、str()  #转换成字符串类型
                    2、format() #参数是int或者float，返回str
                        1、把int转成二进制、八进制、十六进制，返回str
                        2、把小数float，保留几位小数，返回str
                    3、bytes() #把str转换成utf-8的字节
                        参数是str，返回的是字节（b开头的十六进制）
                    4、bytearray() #把字符串的字符取出来，转换成ascill数字
                        参数是str，返回的是数字（0-255之间的ascii数字）
                    5、ord() #把字符转换成ascii码或者数字
                        参数是字符，返回是0-255的ascii的数字及255以上的数字
                    6、chr() #把数字转换成字符
                        参数是0-65536之间的数字，返回的是字符（英文、中文及其他字符）
                    7、ascii() #判断字符是否在ascii表中
                        参数是字符，返回的是字符本身（如果是ascii中），如果不是在ascii中，就返回 \u 开头的
                    8、repr() #原封不动的输出, 引号和转义字符都不起作用
                        参数是字符串，返回的是字符串（带引号，转义字符不起作用）