• 重要函数总结


    复制代码
    五星方法如下:
    key : min max sorted 
    function :filter map
    normal: reversed zip zip_longest globals locals print sum repr  reduce
    
    四星方法:
    bytes abs divmod 
    
    
    
    
    1、min:返回可迭代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)。 *****
    print(min([1,-2,3,4,100,101]))           # -2
    print(min([1,-2,3,4,100,101],key=abs))   # 1
    
     
    
    应用:
    求出年龄最小的那个元组
    ls = [('daming',1000),('xiaoming',18),('zhongming',500)]
    # 这里的数据还不算复杂,可用之前学过的知识求出
    min_age = min([i[1] for i in ls])
    for j in ls:
      if j[1] == min_age:
        print(j)
    
     
    但是有时候数据复杂的情况下,用之前的知识写,可能会很复杂。
    这时可用min()方法,配合自定制的函数进行求值
    def func(x):
      return x[1]        # 1000 18 500
    print(min(ls,key=func))
    结果:('xiaoming', 18)
    
     
    min(可迭代对象,key=函数名):
    1,它会将iterable的每一个元素当做函数的参数传进去。
    2,它会按照返回值去比较大小。
    3,最后返回的是遍历的元素 x
    
    dic = {'a':3,'b':2,'c':1}
    def func1(x):
      return dic[x]
    print(min(dic,key=func1)) 
    结果:c
    # 这里传进去的元素是字典的键,比较的返回值是字典的值,最后返回的是遍历的键
    
    def func2(x):
      return x[1]
    print(min(dic.items(),key=func2))
    结果:('c', 1)
    # 这里传进去的元素是字典的键和值组成的元组,比较的返回值是字典的值,最后返回的是遍历的元组
    
     
    
        
    2、max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)。 *****
    print(max([1,2,3,100]))    # 100
    
    
    
                
    3、sorted:对所有可迭代的对象进行排序操作。 *****
    与列表的sort区分:
    列表的sort方法是对原列表进行排序修改,并没有生成新的列表
    内置函数sorted方法会形成一个新列表
    
    l1 = [2,3,5,3,1,9,8,6]
    l1.sort()
    print(l1)   
    
    print(sorted(l1)) # 形成了一个新列表
    print(l1)         # 原列表不变
    
    内置函数sorted还可以与函数结合使用
    l2 = [(1,1000),(2,18),(4,250),(3,500)]
    
    def func1(x):
        return x[1]
    
    print(sorted(l2,key=func1)) 
    #按第二个元素升序排序 [(2, 18), (4, 250), (3, 500), (1, 1000)]
    
    print(sorted(l2,key=func1,reverse=True)) 
    #按第二个元素降序排序 [(1, 1000), (3, 500), (4, 250), (2, 18)]            
                
                
    4、filter:过滤,通过你的函数,过滤一个可迭代对象(类似于生成器表达式的筛选模式) 生成一个迭代器。 *****
    l1 = [1,2,3,4,5,6]
    def fun(x):
        return x % 2 == 0 #筛选出偶数
    g = filter(fun,l1)  # filter(fun,l1)生成的是一个迭代器
    print(g)
    for i in g:
        print(i)
    结果:
    2 4 6
    
    l2 = [(2,1),(3,4),(4,5)]
    def fun2(x):
        return x[1] % 2 == 1 #筛选出第二个元素为奇数的元组
    g = filter(fun2,l2)
    for i in g:
        print(i)
    结果:
    (2, 1)
    (4, 5)
    
    
    5、map:会根据提供的函数对指定序列做映射。(循环修改并返回) 生成一个迭代器*****
    l1 = [1,2,3,4,5,6]
    def fun(x):
        return x**2 #返回每个元素的平方
    g = map(fun,l1)
    for i in g:
        print(i)
    结果:1 4 9 16 25 36
    (min max sorted filter返回的都是遍历的参数,map返回的是return的值)
    
    
    
    6、reversed:将一个序列翻转,并返回此翻转序列的迭代器。 *****
    6-1、reversed()与列表的reverse()区分:
    列表的reverse()只能列表使用:列表.reverse(),对原列表进行翻转,结果返回的还是列表。
    内置函数reversed(),将一个序列翻转,结果是返回一个迭代器。
    
    列表的reverse()
    l1 = [1,3,4,2,6]
    l1.reverse()  #将列表进行翻转
    print(l1)     #返回修改后的列表 [6, 2, 4, 3, 1]
    
    内置函数reversed()
    reversed(l1)             #生成一个迭代器
    print(reversed(l1))   #一个地址
    for i in reversed(l1):
      print(i)
    结果:
    用for循环输出迭代器的值
    6 2 4 3 1
    
    
    字符串使用reversed()
    s1 = 'abcdefg'
    for i in reversed(s1):
      print(i)
    结果:
    g f e d c b a
    
    字典使用reversed() 报错
    dic = {'name':'xiaoming','age':1000,'hobby':'oldwomen'} # 不行
            
    
    
    
    7、拉链方法:zip() 将多个iter纵向组成元素为元组的迭代器,默认以长度最小的iterable为标准长度 *****
    l1 = [1,2,3,4]
    tu1 = ('a','b','c')
    dic = {'name':'xiaoming','age':18,'hobby':'girl','hometown':'guangzhou'}
    
    zip(l1,tu1,dic)  #迭代器(生成器对象)
    
    print(zip(l1,tu1,dic)) #迭代器地址:<zip object at 0x000002C878E6A6C8>
    
    for i in zip(l1,tu1,dic): 
        print(i)
    
    #循环输出迭代器的内容:
    (1, 'a', 'name')
    (2, 'b', 'age')
    (3, 'c', 'hobby')
    
    
    # 若想以最大的iterable为标准长度,则可以使用itertools.zip_longest()
    from itertools import zip_longest
    x = [1, 3, 5, 7, 9]
    y = [2, 4, 6, 8]
    for i in zip_longest(x, y):
        print(i)
    
    (1, 2)
    (3, 4)
    (5, 6)
    (7, 8)
    (9, None)
            
    
    
    8、
    globals() :返回一个字典(包含全部的全局变量)
    locals() : 返回一个字典(包含的是当前作用域的所有变量)
    
    b = 2
    a = 3
    print(globals())
    print(locals())
    结果:
    这两个结果一样,因为都是在全局执行的。
    
    
    def fun():
      a = 3
      b = 2
      print(globals())
      print(locals())
    fun()
    结果:
    globals():
    {'__name__': '__main__', '__doc__': None, '__package__': None, 
    '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000228CB787748>, 
    '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
    '__file__': 'E:/OldBoy/Knight/PythonProject/day13/t2.py', '__cached__': None, 'b': 2, 'a': 3, 
    'fun': <function fun at 0x00000228CB351E18>}
    
    locals():{'b': 2, 'a': 3}
                
    
    
    9、print
    print的参数分析:print(self, *args, sep=' ', end='
    ', file=None)
    1,*args:可接收多个位置参数
    2,sep:打印多个值之间的分隔符,默认为空格
    3,end:每一次打印的结尾,默认为换行符
    4,file: 默认是输出到屏幕,如果设置为文件句柄,输出到文件
    
    print(1,2,3,sep='|')  # 1|2|3
    
    
    print(1,2,end=' ')
    print(3,4)  # 1 2 3 4
    
                
    
    10、sum:对可迭代对象进行求和计算(可设置初始值)。 *****
    sum(iterable,start_num)
    print(sum([1,2,3,4,100,101]))          # 211
    print(sum([1,2,3,4,100,101],100))   # 311(第二个参数为初始值)
    print(sum([int(i) for i in [1,'2',3,'4','100',101]]))
    
    
    
    
    11、repr:返回一个对象的string形式(原形毕露)  *****
    print(repr('{"name":"xiaoming"}'))  #'{"name":"xiaoming"}'
    print('{"name":"xiaoming"}')        # {"name":"xiaoming"}
    
    
    格式化输出%r--->原封不动的写出来(基础数据类型都可接收)
    字符串单双引号都默认是单引号
    msg = 'xiaoming是%r的人' % ('德高望重')
    print(msg) # xiaoming是'德高望重'的人
    
    msg = 'xiaoming是%r的人' % ("德高望重")
    print(msg) # xiaoming是'德高望重'的人
    
    msg = 'xiaoming是%r的人' %(18)
    print(msg) # xiaoming是18的人
    
    msg = 'xiaoming是%r的人' %(True)
    print(msg) # xiaoming是True的人
    
    msg = 'xiaoming是%r的人' %({'name':'xiaming','age':18})
    print(msg)  # xiaoming是{'name': 'xiaming', 'age': 18}的人
    
    repr():可用于判断json pickle序列化模块 特殊字符串,python字符串的区别
    
    
    
    12、reduce
    Python3中reduce移到了functools模块中,你可以用过from functools import reduce来使用它。
    reduce同样是接收两个参数:func(函数)和seq(序列,如list)
    
    原理:首先将序列中的前两个元素,传入func中,再将得到的结果和第三个元素一起传入func,…,
    这样一直计算到最后,得到一个值,把它作为reduce的结果返回。
    from functools import reduce
    ret = reduce(lambda x,y:x+y, [1, 2, 3, 4])
    print(ret)  # 10
    
    
    l = [30, 11, 77, 8, 25, 65, 4]
    ret = reduce(lambda x,y: x if x > y else y, l)
    print(ret)  # 77
    
    13、bytes:unicode ---> bytes类型(单向的编码) ****
    编码encode():
    s1 = '小明'
    b1 = s1.encode('utf-8')
    print(b1)   # b'xe5xb0x8fxe6x98x8e'
    
    解码decode():
    s2 = b1.decode('utf-8')
    print(s2)   # 小明
    
    用bytes()方法编码(单向)
    a1 = '小白'
    b1 = bytes(a1,encoding='utf-8')
    print(b1)    # b'xe5xb0x8fxe7x99xbd'
    
    不能用bytes()方法解码
    a2 = bytes(b1,encoding='utf-8')
    print(a2)   # 报错
    
    只能用decode()解码
    a2 = b1.decode('utf-8')
    print(a2)   # 小白
    
    
    
    14、abs:函数返回数字的绝对值。 ****
    print(abs(-100))     # 100
    
    
    15、divmod:计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)。 ****
    print(divmod(12,7)) # (1, 5) (商,余数)
    复制代码
  • 相关阅读:
    汇编指令(它不区分大小写)
    汇编
    LINUX命令
    LInux 终端命令
    回文串的Manacher算法
    hdu3336 Counting the string kmp的next数组的应用
    hdu2203kmp匹配
    hdu2087kmp模板练习
    hdu1171kmp果题
    hdu1686kmp果题
  • 原文地址:https://www.cnblogs.com/yidashi110/p/10092270.html
Copyright © 2020-2023  润新知