• Python _内置函数3_45


    reversed:

    #reversed()
    l = [1,2,3,4,5]
    l.reverse()
    print(l) #改变了原来的列表
    
    l = [1,2,3,4,5]
    l2 = reversed(l)
    print(l2)
    # 保留原列表,返回一个反向的迭代器

    slice:

    l = (1,2,23,213,5612,342,43)
    sli = slice(1,5,2)  #sli 是一个切片的规则
    print(l[sli])
    
    print(l[1:5:2])   #不用slice 直接切片的效果是一样的

    format:

    print(format('test', '<20')) #左对齐
    print(format('test', '>40'))
    print(format('test', '^40'))

    补充:https://www.cnblogs.com/LXL616/p/10684538.html

     

    bytes:

    #bytes 转换成bytes类型
    # 我拿到的是gbk编码的,我想转成utf-8编码
    
    print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes
    print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes
    print(bytes('你好',encoding='GBK').decode('GBK'))   #unicode转化为GBK
    # 网络编程 只能传二进制
    # 照片和视频也是以二进制存储
    # html网页爬取到的也是编码
     

    bytearray:

    b_array = bytearray('你好',encoding='utf-8')
    print(b_array)
    '''
    b'xc4xe3xbaxc3'
    b'xe4xbdxa0xe5xa5xbd'
    bytearray(b'xe4xbdxa0xe5xa5xbd')
    '''
    print(b_array[0]) #228
    
    s1 = 'alexa'
    s2 = 'alexb' #当字符串很大时,希望改变某一个值同时可以不用在内存中再生成一个变量,节省内存的空间,可以通过bytearray来改变某个字节从而来改变一个字符串,不在重新产生新的变量节省了内存的空间

    memoryview:

    l = 'ahfjskjlyhtgeoahwkvnadlnv'
    l2 = l[:10]
    # 字节 —— 字符串 占内存
    # memoryview
    # 切片 —— 字节类型  不占内存

    ord 和 chr:

    print(ord('a')) # 查看字符a的编码
    print(ord('')) 
    print(ord('1'))
    print(chr(97)) #查看编码为97的字符

    asvii:

    print(ascii('')) #'u597d'
    print(ascii('1')) # '1'

    repr:

    name = 'egg'
    print('你好%s'%name) #你好egg
    print('你好%r'%name) #你好'egg' # %r 使用的是repr方法
    print(repr('1')) # '1'  #repr 将原有的数据类型展示出来
    print(repr(1)) # 1

    # %r 用于格式化输出

    dict:

    set: 可以作为字典的 key

    frozenset:可以作为字典的 key

    len:

    enumerate:

    http://www.runoob.com/python3/python3-func-enumerate.html

    all & any:

    #all 只要列表中有一个值为false最后的值就位false
    
    print(all(['a','',123])) #False
    print(all(['a',123])) #True
    print(all([0,123])) #False
    
    #any 只要有一个为true 结果就位true
    print(any(['',True,0,[]]))  #True

    zip:

    print(zip((1,12))) #<zip object at 0x000002687BD7B088>
    
    l = [1,2,3,4,5]
    l2 = ['a','b','c','d']
    for i in zip(l,l2):
        print(i)
    '''
    (1, 'a')
    (2, 'b')
    (3, 'c')
    (4, 'd')
    '''
    
    l = [1,2,3,4,5]
    l2 = ['a','b','c','d']
    l3 = ('*','**',[1,2])
    d = {'k1':1,'k2':2} #只有两个key所以只能配对两组
    for i in zip(l,l2,l3,d):
        print(i)
    '''
    (1, 'a', '*', 'k1')
    (2, 'b', '**', 'k2')
    '''

    filter & map:

    Eva_J

    https://www.cnblogs.com/Eva-J/articles/7266192.html

    filter

    filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。

    例如,要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数,保留奇数,首先,要编写一个判断奇数的函数:

    def is_odd(x):
        return x % 2 == 1 #判断奇偶性,偶数传入后返回True,基数传入后返回的是False

    然后,利用filter()过滤掉偶数:

    >>>list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17]))

    ret = filter(is_odd, [1,  6, 7, 12, 17]) #第一个参数传的是函数的地址所以函数不用加括号,第二个参数传的是一个可迭代的的
    print(ret) #<filter object at 0x0000017A8FB22D30> #返回的是迭代器
    for i in ret:
    print(i)
    '''

    1
    7
    17

    '''

    ret = list(filter(is_odd, [1,  6, 7, 12, 17]))
    print(ret) #[1, 7, 17]

    a = [i for i in [1, 4, 6, 7, 9, 12, 17] if i % 2 == 1]
    print(a) #[1, 7, 9, 17] 这里的for循环和以上效果类似,不过filter可以更复杂,可以再函数中定义更多的内容
    #过滤出列表中的字符串

    def
    is_str(s): if type(s) == str: return True ret = filter(is_str, [1, 'hello','',' ',None,[], 6, 7, 'world', 12, 17]) print(ret) for i in ret: print(i) def is_str(s): return type(s) == str ret = filter(is_str, [1, 'hello','',' ',None,[], 6, 7, 'world', 12, 17]) print(ret) for i in ret: print(i) 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)

    利用filter(),可以完成很多有用的功能,例如,删除 None 或者空字符串:

    def is_not_empty(s):
        return s and len(s.strip()) > 0
    >>>list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END']))

    结果:

    ['test', 'str', 'END']

    注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

    当rm为空时,默认删除空白符(包括' ', ' ', ' ', ' '),如下:

    >>> a = ' 123'
    >>> a.strip()
    '123'

    >>> a = ' 123 '
    >>> a.strip()
    '123'

    练习:

    请利用filter()过滤出1~100中平方根是整数的数,即结果应该是:

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

    方法:

    from math import sqrt
    def func(num):
        res = sqrt(num)
        return res % 1 == 0
    ret = filter(func,range(1,101))
    for i in ret:
        print(i)
    
    '''
    1
    4
    9
    16
    25
    36
    49
    64
    81
    100
    
    '''
    import math
    def is_sqr(x):
        return math.sqrt(x) % 1 == 0
    print(list(filter(is_sqr, range(1, 101))))

    结果:

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

    map:

    Python中的map函数应用于每一个可迭代的项,返回的是一个结果list。如果有其他的可迭代参数传进来,map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回。

    有一个list, L = [1,2,3,4,5,6,7,8],我们要将f(x)=x^2作用于这个list上,那么我们可以使用map函数处理。

    >>> L = [1,2,3,4,] 
    >>> def pow2(x): 
    ... return x*x 
    ... 
    >>> list(map(pow2,L))
    [1, 4, 9, 16] 
    ret = map(abs,[1,-4,6,-8])
    print(ret)
    for i in ret:
        print(i)

    # filter 执行了filter之后的结果集合 <= 执行之前的个数
    #filter只管筛选,不会改变原来的值
    # map 执行前后元素个数不变
    # 值可能发生改变

    sort:

    l = [1,-4,6,5,-10]
    l.sort()   # 在原列表的基础上进行排序
    print(l) # [-10, -4, 1, 5, 6]
    l.sort(key = abs)
    print(l) # [1, -4, 5, 6, -10]

    sorted:

    对List、Dict进行排序,Python提供了两个方法
    对给定的List L进行排序,
    方法1.用List的成员函数sort进行排序,在本地进行排序,不返回副本
    方法2.用built-in函数sorted进行排序(从2.4开始),返回副本,原始输入不变

    --------------------------------sorted---------------------------------------

    sorted(iterable, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.

    A custom key function can be supplied to customise the sort order, and the
    reverse flag can be set to request the result in descending order.


    -----------------------------------------------------------------------------
    参数说明:
    iterable:是可迭代类型;
    key:传入一个函数名,函数的参数是可迭代类型中的每一项,根据函数的返回值大小排序;
    reverse:排序规则. reverse = True  降序 或者 reverse = False 升序,有默认值。
    返回值:有序列表
     
    例:
    列表按照其中每一个值的绝对值排序
    l1 = [1,3,5,-2,-4,-6]
    l2 = sorted(l1,key=abs)
    print(l1)
    print(l2)
    l = [1,-4,6,5,-10]
    print(sorted(l))  #生成一个新的列表 不改变原有的列表 占内存
    print(l)
    
    
    l = [1,-4,6,5,-10]
    print(sorted(l,key=abs)) #关键字 根据绝对值排序
    print(l)
    
    l = [1,-4,6,5,-10]
    print(sorted(l,key=abs,reverse=True)) #从大到小排
    print(l)

    列表按照每一个元素的len排序

    l = [[1,2],[3,4,5,6],(7,),'123']
    print(sorted(l,key=len))

    l = ['   ',[1,2],'hello world']
    new_l = sorted(l,key=len)
    print(new_l)

    l = ['   ',[1,2],'hello world']
    def func(item):
    return len(item)
    new_l = sorted(l,key=func)
    print(new_l)
  • 相关阅读:
    Unix环境高级编程(九)信号
    Unix环境高级编程(八)进程关系
    Unix环境高级编程(七)fork函数总结
    Unix环境高级编程(六)进程控制
    Unix环境高级编程(五)进程环境
    Unix环境高级编程(四)数据系统文件和信息
    Unix环境高级编程(三)标准I/O库
    Unix环境高级编程(二)文件和目录
    Unix环境高级编程(一)文件I/O
    Linux中解析json---jq
  • 原文地址:https://www.cnblogs.com/LXL616/p/10692796.html
Copyright © 2020-2023  润新知