Python3之内置函数

Posted 2021-01-13 %华&仔%

 

 

内置函数

内置函数
一、内置函数定义及总数
    python里的内置函数。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。

            Built-in Functions
    abs()	    dict()	help()	min()	setattr()
    all()	    dir()	hex()	next()	slice()
    any()	    divmod()	id()	object()	sorted()
    ascii()	    enumerate()	input()	oct()	staticmethod()
    bin()	    eval()	int()	open()	str()
    bool()	    exec()	isinstance()	ord()	sum()
    bytearray()	filter()	issubclass()	pow()	super()
    bytes()	    float()	iter()	print()	tuple()
    callable()	format()	len()	property()	type()
    chr()	    frozenset()	list()	range()	vars()
    classmethod()	getattr()	locals()	repr()	zip()
    compile()	globals()	map()	reversed()	__import__()
    complex()	hasattr()	max()	round()
    delattr()	hash()	memoryview()	set()

二、分类

(1)作用域相关

    1.locals()    #返回本地作用域中的所有名字  函数会以字典类型返回当前位置的全部局部变量。

    2.globals()   #返回全局作用域中的所有名字  函数会以字典类型返回当前位置的全部全局变量。

    与local、global不同
    local 变量  #声明变量作用域
    global 变量 #声明变量作用域

(2)迭代器

    1.next(iterator[, default])  返回迭代器的下一个项目
        迭代器.__next__()  效果都一样，实际执行迭代器.__next__()

    2.iter(可迭代的) 函数用来生成迭代器。
        可迭代的.__iter__()

    3.range(start, stop[, step]) 函数可创建一个整数列表，一般用在 for 循环中。
        是一个可迭代的，不是一个迭代器
        range(10),range(1,10),range(1,10,2)

        print(dir(range(10)) )
        print( ‘__next__‘ in dir(range(10)) )   #False
        print( ‘__next__‘ in dir(iter(range(10))) )    #False  将可迭代的转化成迭代器

(3)其他：

    1.dir() 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
            如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
        print(dir(1))

    2.callable()  用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
                对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
        print(callable(‘alina‘)) -> False

        def func():pass
        print(callable(func))    ->   True

    3.help()  用于查看函数或模块用途的详细说明。
        help(list)

    4.import 模块名称    调用__import__()  函数
        __import__()  一般不用
        # import datetime
        test_time = __import__(‘datetime‘)
        print(test_time.datetime.now())
            2018-09-27 14:28:46.529354

    5.open() 打开文件

    6.id() 查看内存地址

    7.hash()
        print(hash(1234))
            1234
        print(hash(‘felix‘))
            6020047598959426572
        字典的寻址方式

    某个方法属于某个数据类型的变量，就用 .调用
    如果某个方法不依赖于任何数据类型，就直接调用 ----内置函数 和 自定义函数

    8.input()  输入，字符串接受

    9.print()  输出

        end=  指定输出的结束符
            print(‘test‘,end=‘	‘)

        sep=  指定输出的分隔符
           print(‘test‘,sep=‘|‘)

        file=  指定输出位置文件   默认输出到屏幕
            with open(‘file‘,‘w‘,encoding=‘utf-8‘) as f:
                print(‘测试print函数输出位置‘,file=f)
        flush:立即把内容输出到流文件，不作缓存


        #打印进度条
        import time
        for i in range(0,100000,2):
             time.sleep(0.1)
             char_num = i//2      #打印多少个‘*‘
             per_str = ‘
%s%% : %s
‘ % (i, ‘*‘ * char_num) if i == 100 else ‘
%s%% : %s‘%(i,‘*‘*char_num)
             print(per_str,end=‘‘, flush=True)
        #小越越  ： 
 可以把光标移动到行首但不换行
        打印进度条模块  progress Bar

    10.exec()
    11.eval() 用来执行一个字符串表达式，并返回表达式的值。
        exec和eval都可以执行 字符串类型的代码
        eval() 有返回值 ---有结果的简单运算
        exec() 无返回值 ----简单的流程控制
        eval()只能用在你明确知道你要执行的代码是什么

        exec(‘print(123)‘)
        eval(‘print(123)‘)
        print(exec(‘print(123)‘))  #没有返回值
        print(eval(‘print(123)‘))   #有返回值

        code = """[(print(i*‘*‘)) for i in range(10)]"""
        exec(code)
        123
        123
        123
        None
        123
        None

        *
        **
        ***
        ****
        *****
        ******
        *******
        ********
        *********

    12.compile(source, filename, mode[, flags[, dont_inherit]]) 将一个字符串编译为字节代码。
        code3 = """name = input(‘请输入你的名字：‘)"""
        compile3 = compile(code3,‘‘,‘single‘)

        exec(compile3)
        print(name)

(4)数据类型相关

    1.complex([real[, imag]]) 用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
        复数 —— complex
        实数 ： 有理数
                无理数
        虚数 ：虚无缥缈的数
        5 + 12j  === 复合的数 === 复数
        6 + 15j

    2.float() 用于将整数和字符串转换成浮点数。
        浮点数（有限循环小数，无限循环小数）  != 小数 ：有限循环小数，无限循环小数，无限不循环小数
        浮点数
            354.123 = 3.54123*10**2 = 35.4123 * 10
        f = 1.781326913750135970
        print(f)

    3.bin()  返回一个整数 int 或者长整数 long int 的二进制表示
    4.oct()  将一个整数转换成8进制字符串。
    5.hex()  函数用于将10进制整数转换成16进制，以字符串形式表示。

        print(bin(10))    0b1010
        print(oct(10))    0o12
        print(hex(10))    0xa

    6.abs()  求绝对值

    7.divmod(x,y)   把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
        Return the tuple (x//y, x%y)
        print(divmod(100,15))
            (6, 10)
        实际应为举例：100条新闻，每15条方1页，可以放多少页


    8.round()  四舍五入

    9.pow(x,y[,z])  方法返回 xy（x的y次方） 的值。
        当有2个参数时候，为x的y次方，等价于 x**y
            print(pow(9,2))     ->  81
        当有3个参数是，为x的y次方，再对z取余
            print(pow(9,2,4))  ->  1

    10.sum(iterable[, start])  求和

    11.max(iterable, *[, default=obj, key=func]) -> value
       max(arg1, arg2, *args, *[, key=func]) -> value
        print(max([1,22,9],[2,11,23]))
            [2, 11, 23]
        print(max(1,22,-100,key=abs))
            -100
    12.min(iterable, *[, default=obj, key=func]) -> value
       min(arg1, arg2, *args, *[, key=func]) -> value


    13.reversed()  保留原列表，反转数据，返回一个可迭代的

        lst = [1,5,9,2,7,3]
        lst.reverse()
        print(lst)

        lst1 = []
        for i in reversed(lst):
            lst1.append(i)
        print(lst1)

    14.slice(start, stop[, step]) 实现切片对象，主要用在切片操作函数里的参数传递。
        exp:
        lst = [1,5,9,2,7,3]
        slst = slice(0,4,2)
        print(lst[slst])
            [1, 9]


    15.format() 格式化
        #字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
            print(format(‘test‘, ‘<20‘))
            print(format(‘test‘, ‘>20‘))
            print(format(‘test‘, ‘^20‘))

        #整形数值可以提供的参数有 ‘b‘ ‘c‘ ‘d‘ ‘o‘ ‘x‘ ‘X‘ ‘n‘ None
            >>> format(3,‘b‘) #转换成二进制
            ‘11‘
            >>> format(97,‘c‘) #转换unicode成字符
            ‘a‘
            >>> format(11,‘d‘) #转换成10进制
            ‘11‘
            >>> format(11,‘o‘) #转换成8进制
            ‘13‘
            >>> format(11,‘x‘) #转换成16进制 小写字母表示
            ‘b‘
            >>> format(11,‘X‘) #转换成16进制 大写字母表示
            ‘B‘
            >>> format(11,‘n‘) #和d一样
            ‘11‘
            >>> format(11) #默认和d一样
            ‘11‘
        浮点数可以提供的参数有 ‘e‘ ‘E‘ ‘f‘ ‘F‘ ‘g‘ ‘G‘ ‘n‘ ‘%‘ None
            >>> format(314159267,‘e‘) #科学计数法，默认保留6位小数
            ‘3.141593e+08‘
            >>> format(314159267,‘0.2e‘) #科学计数法，指定保留2位小数
            ‘3.14e+08‘
            >>> format(314159267,‘0.2E‘) #科学计数法，指定保留2位小数，采用大写E表示
            ‘3.14E+08‘
            >>> format(314159267,‘f‘) #小数点计数法，默认保留6位小数
            ‘314159267.000000‘
            >>> format(3.14159267000,‘f‘) #小数点计数法，默认保留6位小数
            ‘3.141593‘
            >>> format(3.14159267000,‘0.8f‘) #小数点计数法，指定保留8位小数
            ‘3.14159267‘
            >>> format(3.14159267000,‘0.10f‘) #小数点计数法，指定保留10位小数
            ‘3.1415926700‘
            >>> format(3.14e+1000000,‘F‘)  #小数点计数法，无穷大转换成大小字母
            ‘INF‘


        #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
            >>> format(0.00003141566,‘.1g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
            ‘3e-05‘
            >>> format(0.00003141566,‘.2g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
            ‘3.1e-05‘
            >>> format(0.00003141566,‘.3g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
            ‘3.14e-05‘
            >>> format(0.00003141566,‘.3G‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
            ‘3.14E-05‘
            >>> format(3.1415926777,‘.1g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
            ‘3‘
            >>> format(3.1415926777,‘.2g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
            ‘3.1‘
            >>> format(3.1415926777,‘.3g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
            ‘3.14‘
            >>> format(0.00003141566,‘.1n‘) #和g相同
            ‘3e-05‘
            >>> format(0.00003141566,‘.3n‘) #和g相同
            ‘3.14e-05‘
            >>> format(0.00003141566) #和g相同
            ‘3.141566e-05‘


    16.bytes()  转换成bytes类型（转换成二进制类型）
        s = ‘王秋华‘
        print(bytes(‘王秋华‘,encoding=‘utf-8‘)) #unicode转换成utf-8的bytes
        print(bytes(‘王秋华‘,encoding=‘gbk‘))   #unicode转换成gbk的bytes
        print(s.encode(‘utf-8‘))   #unicode转换成utf-8的bytes
        print(s.encode(‘gbk‘))     #unicode转换成gbk的bytes

        网络编程：只能传二进制
        照片和视频也是以二进制存储
        html网页爬取到的也是编码


    17.bytearray([source[, encoding[, errors]]]) 返回一个bytes数组,对数组进行取值，得到转化为十进制的数
                                    返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
        bytearray(‘王王王‘,encoding=‘utf‘)
            bytearray(b‘xe7x8ex8bxe7xa7x8bxe5x8dx8e‘)

        new_s = bytearray(‘王王王‘,encoding=‘utf‘)
        new_s_lst = []
        for i in new_s:
            new_s_lst.append(i)
        print(new_s_lst)
            [231, 142, 139, 231, 167, 139, 229, 141, 142]

    18.memoryview(bytes(‘hello,eva‘,encoding=‘utf-8‘))  返回给定参数的内存查看对象(Momory view)。
                        所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
                        针对bytes类型进行字节类型的切片
        切片  ---- 字节类型的切片 不占内存

        s = memoryview(bytes(‘王王王‘,encoding=‘utf-8‘))
        print(s[1])


    19.ord()  将unicode的1个字符转换成unicode的1个数字
        chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）
        作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
        print(ord(‘f‘))
            102
        print(ord(‘王‘))
            29579
    20.chr()  将unicode的1个数字转换成unicode的1个字符
              用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
        print(chr(97))
            a

    21.ascii() 只要是ascii码中的内容，就打印出来，不是就转换成u

    22.repr()  用于%r格式化输出
        print(repr(‘1‘))    ‘1‘
        print(repr(1))      1

    23.diet() 字典

    24.set()集合

    25.frozenset([iterable])  返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

        >>>a = frozenset(range(10))     # 生成一个新的不可变集合
        >>> a
        frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        >>> b = frozenset(‘runoob‘)
        >>> b
        frozenset([‘b‘, ‘r‘, ‘u‘, ‘o‘, ‘n‘])   # 创建不可变集合
        >>>

相关内置函数

    1.len()  长度

    2.enumerate(object)  函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
                         同时列出数据和数据下标，一般用在 for 循环当中

        >>>seasons = [‘Spring‘, ‘Summer‘, ‘Fall‘, ‘Winter‘]
        >>>list(enumerate(seasons))
        [(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fall‘), (3, ‘Winter‘)]
        >>>list(enumerate(seasons, start=1))       # 小标从 1 开始
        [(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fall‘), (4, ‘Winter‘)]

        普通的 for 循环
            >>>i = 0
            >>>seq = [‘one‘, ‘two‘, ‘three‘]
            >>>for element in seq:
            ...    print(i, seq[i])
            ...    i += 1
            ...
            0 one
            1 two
            2 three

        for 循环使用 enumerate
            >>>seq = [‘one‘, ‘two‘, ‘three‘]
            >>>for i, element in enumerate(seq):
            ...    print(i, seq[i])
            ...
            0 one
            1 two
            2 three

    3.all(iterable)  如果iterable的所有元素不为0、‘‘、False或者iterable为空，all(iterable)返回True，否则返回False；
                     注意：空元组、空列表返回值为True，这里要特别注意。
                     有一个False就为False

    4.any(iterable) 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
                    有1个为true就为true
        >>>any([‘a‘, ‘b‘, ‘c‘, ‘d‘])  # 列表list，元素都不为空或0   True
        >>> any([‘a‘, ‘b‘, ‘‘, ‘d‘])   # 列表list，存在一个为空的元素   True
        >>> any([0, ‘‘, False])        # 列表list,元素全为0,‘‘,false  False
        >>> any((‘a‘, ‘b‘, ‘c‘, ‘d‘))  # 元组tuple，元素都不为空或0  True
        >>> any((‘a‘, ‘b‘, ‘‘, ‘d‘))   # 元组tuple，存在一个为空的元素  True
        >>> any((0, ‘‘, False))        # 元组tuple，元素全为0,‘‘,false   False
        >>> any([]) # 空列表    False
        >>> any(()) # 空元组  False

    5.zip([iterable, ...]) 拉链方法：
        函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，
        这样做的好处是节约了不少的内存。我们可以使用 list() 转换来输出列表。
        如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
        >>>a = [1,2,3]
        >>> b = [4,5,6]
        >>> c = [4,5,6,7,8]
        >>> zipped = zip(a,b)     # 返回一个对象
        >>> zipped
        <zip object at 0x103abc288>
        >>> list(zipped)  # list() 转换为列表
        [(1, 4), (2, 5), (3, 6)]
        >>> list(zip(a,c))              # 元素个数与最短的列表一致
        [(1, 4), (2, 5), (3, 6)]

        >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，*zip 可理解为解压，返回二维矩阵式
        >>> list(a1)
        [1, 2, 3]
        >>> list(a2)
        [4, 5, 6]
    6.filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
            该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

        exp1:
        def func(n):
            return n % 2 == 1
        ret = filter(func,[1,2,3,4,5,6,7,8,9])
        for i in ret:
            print(i)
        执行结果：1 3 5 7 9
        filter(func,[1,2,3,4,5,6,7,8,9])等同于
        [i for i in [1,2,3,4,5,6,7,8,9] if i % 2 == 1]

        exp2:
        过滤只要为字符串的信息：
        def func(s):
            if type(s) == str:
                return True
        ret = filter(func,[1, ‘felix‘,‘love‘, 4, 5, 6,‘alina‘])
        for i in ret:
            print(i)
                felix
                love
                alina

        exp3:过滤空内容
        def is_str(s):
            return s and str(s).strip()
        ret = filter(is_str, [1, ‘hello‘,‘‘,‘  ‘,None,[], 6, 7, ‘world‘, 12, 17])
        print(ret)
        for i in ret:
            print(i)
                1
                hello
                6
                7
                world
                12
                17
        exp3:求1-100 平方根是整数的数
        import math
        def my_sqrt(s):
            #return (s**0.5) % 1 == 0
            return math.sqrt(s) % 1 == 0
        ret = filter(my_sqrt,range(1,101))
        for i in ret:
            print(i)

    7.map(function, iterable, ...) 根据提供的函数对指定序列做映射。

        >>>def square(x) :            # 计算平方数
        ...     return x ** 2
        ...
        >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
            [1, 4, 9, 16, 25]
        >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
            [1, 4, 9, 16, 25]

        filter和map：都是返回一个迭代器
            filter
            1.执行filter的结果集合 <= 执行之前的结果
            2.filter只管筛选，不会改变原来的值

            map:
            1.执行前后元素个数不变
            2.值可能会发生改变

    8.sorted(iterable[, cmp[, key[, reverse]]]) 函数对所有可迭代的对象进行排序操作。
        sort 与 sorted 区别：
        sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
        list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
        而内建函数sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

        >>>a = [5,7,6,3,4,1,2]
        >>> b = sorted(a)       # 保留原列表
        >>> a
        [5, 7, 6, 3, 4, 1, 2]
        >>> b
        [1, 2, 3, 4, 5, 6, 7]

        >>> L=[(‘b‘,2),(‘a‘,1),(‘c‘,3),(‘d‘,4)]
        >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
        [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
        >>> sorted(L, key=lambda x:x[1])               # 利用key
        [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]


        >>> students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
        >>> sorted(students, key=lambda s: s[2])            # 按年龄排序
        [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

        >>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
        [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
        >>>

        exp2:
        L = [1,-3,7,5,-2,-10]
        print(sorted(L,key=abs,reverse=True))

        L = [‘sorted‘,‘sort‘,‘filter‘,‘map‘]
        print(sorted(L,key=len))