Python【day 13】内置函数02

一、作用域相关-2个
    1、locals()
        参数是空
        返回当前位置作用域的所有变量，返回的是字典
        当前位置：函数内，返回局部变量
        当前位置：函数外，返回全局变量
    2、globals()
        参数是空
        返回全局变量,返回的是字典

二、迭代器-生成器相关--3个
    1、range()
       生成数字数据，例如：等差数列
       参数是数字
    2、next()
        参数是迭代器-iterator，返回的是迭代器的一个取值，只能向下取值，不能后退
        和迭代器.__next__()等效--内部原理
    3、iter()
        用于把iterable转换成迭代器
        参数是iterable，返回的是迭代器，内部调用的是iterable.__iter__()

        可迭代类型的（可迭代的）：iterable
            包括：str list tuple dict set range() open()
        迭代器：iterator
            iterator = iter(iterable)  或者
            iterator = iterable.__iter__()
        注意：列表是iterable，而不是iterator

三、其他-12个
    1、字符串类型代码的执行--3个
        1、eval()
            作用：用于实现计算器，字符串表达式的执行
            参数：字符串表达式 比如：'1+3'
            返回：int--计算结果
            应用场景：有返回值的字符串形式的代码-
                      比如：计算器、'[1,2]'或者"{'name':'jack'}"去掉引号，json字符串转成字典

        2、exec()
            作用：执行字符串中的代码
            参数：字符串代码
            返回：none，没有返回值
            应用场景：没有返回值的字符串形式的代码-比如：函数、for循环等

        3、compile()
            作用：将字符串中的代码进行编译，将编译后的结果存入变量，然后把变量交给eval（）或者exec()执行
            参数：
                参数1：字符串形式的代码
                参数2：py文件-如果参数1传了，参数2是空字符串""即可
                参数3：模式有3个
                    1、'eval' 计算字符串表达式
                    2、'exec' 循环或者if语句或者函数
                    3、'single' 有交互的时候，包含input
                    注意：single这个模式只能用于input，不能在input之外加上其他任何语句，
                          比如：有print不行，否则报错
            返回：
            应用场景：
            1、有返回值的字符串形式的代码-用eval()
            2、没有返回值的字符串形式的代码-用exec()
            3、compile()用的较少

    2、输入输出--2个
        1、input()
            作用：获取用户键盘输入的内容
            参数：字符串，比如：用于提示用户输入
            返回：字符串
                  注意：用户输入的是数字1，返回的是字符串'1'
                        这里的字符串'1'如果需要用于计算，就需要先转换成int，否则报错
            应用场景：有交互的时候
        2、print()
            作用：打印输出
            参数：变量-必选参数
            返回：变量的值
            应用场景：一步步调试程序，打印变量

    3、内存相关-2个
        1、id()
            作用：获取到对象的内存地址
            参数：对象、变量
            返回：内存地址
            应用场景：可以用于确定两个变量是否指向同一个对象
                      a1 is a2 如果返回的是true
                      a1和a2都指向了同一个内存空间，a1和a2分别是同一个内存空间的不同别名
                      a1和a2并没有在内存中开辟2个不同的内存空间

        2、hash()
            作用：获取到对象的哈希值
            参数：不可变对象（int str bool tuple）
            返回：int(19位数字或者19位数字前面加一个-)
            应用场景：
                可变对象（不可哈希的）：list dict set
                不可变对象（可哈希的）：int str bool tuple frozenset
                只有不可变对象才有哈希值，可变对象是没有哈希值的
                字典的key必须是不可变对象（可哈希的）

    4、文件操作相关-1个
        open()
            作用：获取文件对象-文件句柄（类比：锅上的锅炳，锅炳可以控制锅；文件句柄可以操作文件）
            参数：
                参数1：文件全路径（包括文件名字）
                参数2：模式mode，默认是只读r
                参数3：编码方式，默认是none（即和操作系统保持一致，中文操作系统是gbk），
                      一般需要指定utf-8
            返回：文件对象
            应用场景：
                读写操作文件（包括文本文件txt csv和二进制文件excel）

        相对路径小结
        ..\ 表示上一级目录     例如：path1 = r'..\code1.py'
        ..\..\表示上上级目录   例如：path2 = r'..\..\test.py'   这里的r是去掉转义
        ..\..\..\表示上3级目录 例如：path3 = r'..\..\..\zuoye.py'

    5、模块相关--1个
        __import__()
        用于动态加载类和函数
        常用的是:import 导包

    6、帮助--1个
        help()
        用于查看函数或者模块用途的详细说明

    7、调用--1个
        callable()
        作用：用于检查一个对象是否是可以被调用的
              如果是可以被调用的，比如：函数、类，就返回true
              如果不是可以被调用的，比如：str int 类的对象，就返回false
        参数：str int 类的对象、函数名、类名
        返回：bool值 true或者false
        应用场景：

    8、查看内置属性--1个
        dir()
        作用：获取参数的属性、方法列表
        参数：列表、字典等任意对象
        返回：
            返回的是一个列表
            列表中是该参数的属性、方法列表
        应用场景：
            可以用于查看列表、字典等对象的属性和方法列表
            比如：想查看列表中有多少内置方法，可以被使用

四、基础数据类型相关--38个
    1、和数字相关
        1、数字类型
            1、bool()
                作用：将给定的参数，转换成布尔值，true或者false
                参数：
                    false：none 0 '' [] () {}
                           数字0、空字符串、空列表、空元组、空字典
                    true:1或者其他所有非空的（包含空格 '\r' '\n' '\t'等）
                返回：
                    true
                    false
                应用场景：
                备注：
                    1、bool是int的子类
                    2、如果不给参数，返回的是false

            2、int()
                作用：将给定的参数（小数或者字符串）转换成int值
                参数：
                    小数：小数会直接取整，而不是四舍五入
                    字符串：只能将字符串形式的数字，转换成数字，比如：'12'转成12
                            而不能把'a'转成int，会报错
                返回：
                    int值
                应用场景：
                备注：
                    1、如果不给参数，返回的是0
                    2、参数2不写，默认是base=10；还可以按照其他进制，比如base=8

            3、float()
                作用：将给定的参数（整数int或者字符串形式的小数）转换成小数
                参数：
                    整数int
                    字符串形式的小数
                返回：
                    小数
                应用场景：
                备注：
                    如果不给参数，返回的是0.0

            4、complex()
                作用：将给定的参数，转换成复数
                参数：
                    参数1：实部
                    参数2：虚部
                返回：
                    复数
                应用场景：
                备注：
                    如果不给参数，返回的是0j

        2、进制转换
            1、bin()
                作用：将给定的参数，转换成二进制
                参数：十进制数字，整数int，不能是小数
                返回：二进制的字符串-0b开头,而不是二进制数字
                应用场景：
                备注：

            2、oct()
                作用：将给定的参数，转换成八进制
                参数：十进制数字，整数int，不能是小数
                返回：八进制的字符串-0o开头,而不是八进制数字
                应用场景：
                备注：

            3、hex()
                作用：将给定的参数，转换成十六进制
                参数：十进制数字，整数int，不能是小数
                返回：十六进制的字符串-0x开头,而不是十六进制数字
                应用场景：
                备注：

        3、数学运算
            1、abs()
                作用：将给定的参数，转换成绝对值
                参数：int或者float
                返回：正数--去掉了负号
                应用场景：
                备注：

            2、divmod()
                作用：返回商和余数
                参数：
                    参数1：被除数
                    参数2:除数
                返回：商和余数组成的元组  (a//b,a%b)
                应用场景：
                备注：

            3、round()
                作用：返回小数的四舍五入
                参数：
                    参数1:小数
                    参数2：保留几位小数
                返回：小数
                应用场景：小数点后位数较多，保留几位小数
                备注：

            4、pow()
                作用：求幂
                参数：
                    参数1：a
                    参数2：b
                返回：返回a的b次幂,等效于a**b
                应用场景：
                备注：

            5、sum()
                作用：求和
                参数：
                    参数1：iterable：列表、元组、字典等
                    参数2：不写默认是0,
                返回：返回iterable中元素的和，如果参数2是3，最后的和还需要加3
                应用场景：用于计算累加，列表中元素的和
                备注：

            6、min()
                作用：求最小值
                参数：
                    1、多个参数：可以是多个数字
                    2、一个参数：多个数字组成的列表
                返回：最小值int或者float
                应用场景：
                备注：

            7、max()
                作用：求最大值
                参数：
                    1、多个参数：可以是多个数字
                    2、一个参数：多个数字组成的列表
                返回：最大值int或者float
                应用场景：
                备注：


    2、和数据结构相关
        1、数据集合
            1、字典
                dict()
                作用：创建一个字典
                参数：
                    方式1：关键字
                    方式2：iterable
                    方式3：映射函数
                返回：字典
                备注：

            2、集合
                1 set()
                    作用：创建一个集合，把参数转换成集合
                    参数：
                        iterable
                    返回：集合（无序，去重）
                    备注：集合的本质是没有value，只有key的字典
                    例子：
                        s1 = 'bob'
                        s2 = 'alexab'

                        set1 = set(s1)  #把字符串转换成集合
                        print(set1)  #{'b', 'o'}  #去重和无序

                        set2 = set(s2)
                        print(set2)  #{'b', 'x', 'l', 'e', 'a'}

                        print(set1 & set2)   #{'b'}  求交集 （并且，两个集合都有的）
                        print(set1 | set2)  #{'x', 'o', 'e', 'a', 'l', 'b'}  求并集（合集）
                        print(set2 - set1)  #{'l', 'e', 'a', 'x'}  求差集

                2 frozenset()
                    作用：创建一个不可变（冻结）的集合
                    参数：
                        iterable:列表、元组、字典
                    返回：
                        不可变的集合
                    备注：冻结的意思是：元素不能添加和删除
                    例子：
                        s1 = 'bob'
                        print(frozenset(s1))  #创建一个不可变的集合（不能添加或者删除元素）
                        #类比：set和frozenset list和tuple
                        #frozenset({'b', 'o'})

        2、相关内置函数
            1 len()
                作用：返回一个对象中元素的个数
                参数：
                    列表、元组、字符串等iterable
                返回：
                    个数int
                备注：
                例子：
                    li1 = [1,2]
                    print(len(li1)) #2  列表中元素的个数

            2 sorted()
                作用：对可迭代对象进行排序
                参数：
                    可迭代的对象iterable
                返回：
                    排序后的可迭代对象
                备注：
                    sort()和sorted（）的区别
                    1 sort()是列表的内置方法，排序的同时，将原列表修改了
                    2 sorted（）的参数不仅仅是列表，还可以是字符串等其他iterable的对象
                      排序的同时，新产生了一个新的排序后的对象，原对象没有任何改变
                例子：
                    li2 = [1,3,2]
                    li3 = sorted(li2)  #reverse不写默认是false 升序
                    print(li3)  #[1, 2, 3]

                    li4 = sorted(li2,reverse = true) #倒序
                    print(li4)  #[3, 2, 1]

                    li2 = [1,3,2]
                    li5 = sorted(li2,key=lambda x:x*-1)  #通过参数key 进行倒序
                    #key参数还可以用于指定对象中的一个元素进行排序
                    print(li5)  #[3, 2, 1]

                    li6 = sorted(li2,key=lambda x:x)
                    print(li6)  #[1, 2, 3]  #通过参数key 进行升序

                    li2 = [1,3,2]
                    li2.sort()  #这里返回值是none  注意
                    print(li2)  #[1, 2, 3]

            3 enumerate()
                作用：将一个可迭代对象中元素的索引号和元素本身作为一个元组，元组作为新列表的元素
                参数：
                    iterable
                返回：
                    枚举对象
                备注：

            4 all()
                作用：可迭代对象中元素全部是true，结果才是true
                参数：
                    iterable
                    元素中含有0 空字符串'' none fasle ，结果就是false
                    注意：列表或者元组的元素是空白，结果是true
                返回：
                    布尔值 bool true或者false
                备注：

            5 any()
                作用：可迭代对象中元素有一个是true，结果就是true
                参数：
                    iterable
                    元素中：0 空字符串'' none fasle ，上述4个元素是false，其余都是true

                返回：
                    布尔值 bool true或者false
                备注：

            all()和any()的区别
            1 前者是iterable中的元素全部是true，结果才是true
            2 后者是iterable中的元素只要有一个是true，结果就是true
            3、元素中0 '' none false是false，其余都是true
            4、注意点
                空列表（列表中的元素是空白）、空元组、空字符串，all()函数返回true--特殊点
                空列表（列表中的元素是空白）、空元组、空字符串，any()函数返回false

            6 zip()
                作用：把iterable1和iterable2的第一个元素组成一个元组，
                      把iterable1和iterable2的第2个元素组成一个元组，.。。元组作为列表的元素
                      以iterable中最少的元素为准
                参数：
                    参数1：可迭代对象
                    参数2：可迭代对象
                返回：
                    迭代器
                备注：
                例子:
                    li1 = [1,2]
                    li2 = [3,4]
                    ret1 = zip(li1,li2)
                    print(ret1)  #<zip object at 0x00000021a24e4788>
                    print(list(ret1))  #[(1, 3), (2, 4)]

            7 filter()
            8 map()

        3、序列
            1、列表和元组--2个
                1 list()
                    作用：将可迭代对象-iterable转换成列表
                    参数：
                        可迭代对象-iterable
                    返回：
                        列表
                    备注：

                2 tuple()
                    作用：将可迭代对象-iterable转换成元组
                    参数：
                        可迭代对象-iterable
                    返回：
                        元组
                    备注：

            2、相关内置函数--2个
                1 reversed()
                    作用：将一个序列（iterable）反转，返回一个迭代器
                    参数：
                        iterable:str list tuple range()等  dict set open()
                    返回：
                        迭代器
                    备注：
                        li1 = [1,3,2]
                        it1 = reversed(li1)  #将可迭代对象-iterable的元素进行反转（注意：反转不是倒序）
                        print(it1)  #
                        print(list(it1))  #[2, 3, 1]  #迭代器转换成列表

                2 slice()
                    作用：用于切片，用的较少
                    推荐:s1[1:5:2] li1[1:5:2]
                    备注：
                        字符串或者列表反转
                        方法1：  最简洁
                            s1[::-1]
                            li1[::-1]

                        方法2：
                            reversed(li1)
                            reversed(s1)

            3、字符串--9个
                1 str()
                    作用：将数据转换成字符串
                    参数：
                        任意对象
                    返回：
                        字符串
                    备注：

                2 format()
                    作用：进行格式化
                    参数：
                        参数1：可以是字符串、数字、小数
                    返回：
                        字符串
                    备注：
                        #01 字符串
                        print(format('jack','<20')) #字符串左对齐，一共是20个字符
                        print(format('jack','>20')) #字符串右对齐，一共是20个字符
                        print(format('jack','^20')) #字符串居中对齐，一共是20个字符，jack左右各8个字符
                        print('----------------------6-1 format() 字符串')

                        #02 数值--进制转换
                        print(format(3,'b'))  #11 十进制数字3转换成二进制数字11的字符串形式
                        print(type(format(3,'b'))) #<class 'str'>
                        print(format(8,'o'))  #10 十进制数字8转换成八进制数字10的字符串形式
                        print(format(16,'x')) #10 十进制数字16转换成十六进制数字10的字符串形式
                        print(format(15,'x')) #f 十进制数字15转换成十六进制数字f（大写的）
                        print(format(97,'c')) #a  十进制数字97转换成ascii码表（ascii属于unicode）中的字母
                        print('----------------------6-2 format() 进制转换')

                        #03 浮点数--小数
                        print(format(1.2354,'0.2f'))  #1.24  保留2位小数，四舍五入
                        print(type(format(1.2354,'0.2f')))  #<class 'str'>
                        print(format(12345678,'e'))  #1.234568e+07 科学计数法（默认保留6位小数）
                        print(format(1235567,'0.2e'))  #1.24e+06 科学计数法（保留2位小数，e小写）
                        print(format(1235567,'0.2e'))  #1.24e+06 科学计数法（保留2位小数，e大写）
                        print('----------------------6-3 format() 小数')

                3 bytes()
                    作用：把字符串转换成bytes类型（字节）
                    参数：
                        字符串、整数、iterable
                    返回：
                        字节
                    备注：
                        #把字符串转换成字节(utf-8编码)
                        s1 = '你好'
                        s2 = 'jack'
                        li1 = [1,2,3]
                        print(bytes(s1,encoding='utf-8'))  #b'\xe4\xbd\xa0\xe5\xa5\xbd' b开头表示字节
                        #一个汉字（中文字符）是3个字节--utf-8中
                        print(bytes(s2,encoding='utf-8')) #b'jack'
                        #一个英文字母是一个字节--utf-8中
                        print(bytes(li1))  #b'\x01\x02\x03'
                        print('----------------------7-1 bytes()')

                        b1 = s1.encode()  #这里参数不写，默认是'utf-8'
                        print(b1)  #b'\xe4\xbd\xa0\xe5\xa5\xbd'
                        #将中文字符串转换（编码-压缩-加密）成字节（utf-8)
                        #中文字符串就是明文，字节就是密文

                        s11 = b1.decode() #这里参数不写，默认是'utf-8'
                        print(s11)  #你好
                        #将字节(utf-8)转换（解码-解压缩-解密）成中文字符串
                        print('----------------------7-2 bytes()')

                4 bytearray()
                    备注：和bytes有类似，用的较少

                5 memoryview()
                    作用：查询字符串对应的字节（utf-8）在内存的地址
                    参数：
                        字符串对应的字节
                    返回：
                        内存的地址
                    备注：
                        s1 = 'jack'
                        print(memoryview(s1.encode('utf-8')))
                        # print(memoryview(s1)) #报错 typeerror: memoryview: a bytes-like object is required, not 'str'
                        #<memory at 0x0000003d28b881c8>

                6 ord()
                    作用：输入字符，找到字符编码的位置-ascii，输出数字
                    参数：
                        字符
                    返回：
                        数字
                    备注：
                        print(ord('a')) #97  #字母a的ascii是97
                        print(ord('一')) #19968  #中文字符‘一’对应的utf-8的字符编码的位置是19968
                        # print(ord('一期')) #报错 typeerror: ord() expected a character, but string of length 2 found

                7 chr()
                    作用：把数字（字符编码的位置）转换成字符
                    参数：
                        数字
                    返回：
                        字符
                    备注：
                        print(chr(65))  #a  ascii中65对应的字符是'a'
                        print(chr(19968))  #一 字符编码位置是19968对应的字符是'一'

                8 ascii()
                    作用：用于判断字符是否在ascii中
                    参数：
                        参数是ascii表中的字符，就返回参数本身；参数不是ascii表中的字符，就返回\u开头
                    返回：
                    备注：
                        print(ascii('a'))  #'a'
                        print(ascii('ab'))  #'ab'
                        print(ascii('一')) #'\u4e00'

                9 repr()
                    作用：引号等原封不动的输出，转义符不起作用，取字面的意思
                    参数：
                    返回：
                    备注：
                        s1 = '祖国'
                        print('我爱%s' % s1)  #我爱祖国  占位符
                        print('我爱%r' % s1) #我爱'祖国' 原封不动的输出

                        print('大家好,\n \t 我是jack')
                        # 大家好,
                        #       我是jack
                        print(repr('大家好,\n \t 我是jack'))
                        #'大家好,\n \t 我是jack'   原封不动的输出，引号和转义符都原样输出

                        s1 ='jack'   #字符串
                        print(s1) #jack  不带引号
                        print(repr(s1)) #'jack'  带引号