您的位置:新葡亰496net > 奥门新萄京娱乐场 > 学习笔记,python3之内置函数

学习笔记,python3之内置函数

发布时间:2019-11-30 06:15编辑:奥门新萄京娱乐场浏览(90)

    目录:

    Python中列表和元组的相干语句和章程解说,python语句

    列表(list):

    先是,列表归属类别,那么种类类型可用如下内建函数——
    list(iter卡塔尔(英语:State of Qatar):把可迭代对象转换为列表。
    str(obj卡塔尔:把obj对象转变为字符串,即用字符串来代表那一个指标。
    tuple(iter卡塔尔(英语:State of Qatar):把三个可迭代对象转变为二个元组。
    unicode(obj卡塔尔:把对象转变到Unicode字符串。
    basestring(卡塔尔:抽象工厂函数,其效能只是是为str和unicode函数提供父类,所以不可能被实例化,也无法被调用。
    enumerate(iter卡塔尔(英语:State of Qatar):选用三个可迭代对象作为参数,重临一个enumerate对象,该对象生成由iter每种元素的index值和item值组成的元组。
    len(seq):返回seq的长度。
    max(iter,key=None卡塔尔国、max(arg0,arg1...,key=None卡塔尔(英语:State of Qatar):重返iter或(arg0,arg1...卡塔尔国的最大值,纵然钦赐了key,这么些key必得是三个能够传给sort(卡塔尔国方法的,用于比较的回调函数。
    min(iter,key=None卡塔尔(英语:State of Qatar)、min(arg0,arg1...,key=None卡塔尔(قطر‎:再次来到iter或(arg0,arg1...卡塔尔(قطر‎的微小值,若是内定了key,这些key必须是八个得以传给sort(卡塔尔(英语:State of Qatar)方法的,用于相比较的回调函数。
    reversed(seq卡塔尔:选用一个队列作为参数,重回七个以逆序访问的迭代器。
    sorted(iter,cmp=None,key=None,reverse=False卡塔尔:选拔三个可迭代对象作为参数,再次回到二个稳步的列表,可选参数cmp、key和reverse和list.sort(卡塔尔国内建函数含义相符。
    sum(seq,init=0卡塔尔国:重回seq和可选参数init的总额,其作用同样reduce(operator.add,seq,init卡塔尔(قطر‎。
    zip([it0,it1...]卡塔尔(قطر‎:重临二个列表,其首先个因素是it0、it1...那么些要素的率先个要素结合的三个元组,其余成分依次类推。

    列表就好像三个线性容器,不过比C 的 lis t扩张多得多
    列表里的因素得以是相似种类,也得以分包各连串型,比方列表里嵌套另叁个列表

    列表示例:

    >>> L1 = [1,2,3] 
    >>> type(L1) 
    <class 'list'> 
    >>> L1 = [1,'a',2,1.4] 
    >>> L1 
    [1, 'a', 2, 1.4] 
    >>> L1 = [ ['sub'],1,'n'] 
    >>> L1 
    [['sub'], 1, 'n'] 
    

    list的目录是也是从0初叶,但也得以从后拜谒,L1[-1] 表示L1中的最后三个要素

    >>> L1 
    [['sub'], 1, 'n'] 
    >>> L1[0] 
    ['sub'] 
    >>> L1[-1] 
    'n' 
    

    对列表能够开展切开,切丝的操作看似于对函数的调用,再次来到值二个新的列表
    切片 L1[ x : y : z ] 是半开闭区间(z经常并不是写),如L1[1:3] 重回的是一个从 L1[1] 开始到 L1[2] 停止的列表,不分包L1[3]
    x 不写表示从头最早,y 不写表示截止列表甘休,z 用于表示步长, 暗中同意是1, 可以感觉是在此个间隔里每 z 个因素取三个(取第叁个),能够是负数,表示从后到前遍历

    >>> L1 = [1,2,3,4,5,6] 
    >>> L1[1:3] 
    [2, 3] 
    >>> L1[:3] 
    [1, 2, 3] 
    >>> L1[1:] 
    [2, 3, 4, 5, 6] 
    >>> L1[-3:-1] 
    [4, 5] 
    >>> L2 = L1[:] 
    >>> L2 
    [1, 2, 3, 4, 5, 6] 
    >>> L1[::2] 
    [1, 3, 5] 
    >>> L1[::-1] 
    [6, 5, 4, 3, 2, 1] 
    

     

    列表能够做加法,做乘法,字符串也能够看作四个字符的列表

    >>> L1 = [1,2] 
    >>> L2 = [3,4] 
    >>> L1   L2 
    [1, 2, 3, 4] 
    >>> 5 * L1 
    [1, 2, 1, 2, 1, 2, 1, 2, 1, 2] 
    

    in语句,剖断三个指标是不是在三个字符串/列表/元组里
    not 语句表示对后边的否定
    len  能够检测字符串/列表/元祖/字典的要素个数
    max 可以再次回到最大体素,min 重回最小成分

    >>> L1 
    [1, 2, 3, 4, 2] 
    >>> 3 in L1 
    True 
    >>> 5 in L1 
    False 
    >>> 3 not in L1 
    False 
    >>> 5 not in L1 
    True 
    >>> len(L1) 
    5 
    >>> max(L1) 
    4 
    >>> min(L1) 
    1 
    

    操作:

    >>> #赋值 
    >>> L1[1] = 5 
    >>> L1 
    [1, 5, 3, 4, 2] 
    >>> #删除 
    >>> del L1[1] 
    >>> L1 
    [1, 3, 4, 2] 
    >>> #分片赋值 
    >>> L1[2:] = [6,7,8] 
    >>> L1 
    [1, 3, 6, 7, 8] 
    >>> L1[1:3] = [] 
    >>> L1 
    [1, 7, 8] 
    

    list 的函数:
    append( x 卡塔尔国 是将 x 作为七个成分增多到列表的最后,固然 x 是二个列表

    >>> L1 
    [1, 2, 7, 8] 
    >>> L1.append(3) 
    >>> L1 
    [1, 2, 7, 8, 3] 
    >>> L1.append([4,5]) 
    >>> L1 
    [1, 2, 7, 8, 3, [4, 5]] 
    >>> 4 in L1 
    False 
    

    count( x卡塔尔(英语:State of Qatar) 总结 x 在列表中冒出的次数

    >>> L1 = [1, 2, 7, 8] 
    >>> L1.count(2) 
    1 
    >>> L1.count(3) 
    0 
    

    extend( x 卡塔尔 将x 作为一个列表与原列表合并,增添到最后。若不是列表,则编写翻译器尝试将 x 调换为列表然后施行操作,不成功就能够报错

    >>> L1 
    [1, 2, 7, 8] 
    >>> L1.extend([4,5]) 
    >>> L1 
    [1, 2, 7, 8, 4, 5] 
    >>> 4 in L1 
    True 
    

    index ( x 卡塔尔国 再次回到 x 在列表中的坐标,若 x 不在列表中会出错

    >>> L1.index(2) 
    1 
    

    insert( i , x卡塔尔(قطر‎ 在职责i 插入成分x

    >>> L1 
    [1, 2, 7, 8, 4, 5] 
    >>> L1.insert(0,'a') 
    >>> L1 
    ['a', 1, 2, 7, 8, 4, 5] 
    >>> L1.insert(-1,'b') 
    >>> L1 
    ['a', 1, 2, 7, 8, 4, 'b', 5] 
    

    pop( i 卡塔尔(قطر‎ 删除地点 i 的因素并将它回到,暗中同意能够不写 i ,删除最终叁个成分,不设有会出错

    >>> L1 = [1, 2, 7, 8] 
    >>> L1.pop(1) 
    2 
    >>> L1 
    [1, 7, 8] 
    >>> L1.pop() 
    8 
    >>> L1 
    [1, 7] 
    

    remove( x 卡塔尔国 移除在 列表中 x 的首先个相配项,x 不设有会出错

    >>> L1.remove(2) 
    >>> L1 
    [1, 7, 8] 
    

    reverse(卡塔尔(英语:State of Qatar) 将列表逆序

    >>> L1 = [1, 2, 7, 8] 
    >>> L1.reverse() 
    >>> L1 
    [8, 7, 2, 1] 
    

    sort 将原列表排序,再次来到None,有八个可选参数,key 和 reverse,暗中同意为升序排列

    >>> L1 
    [8, 7, 2, 1] 
    >>> L1.sort() 
    >>> L1 
    [1, 2, 7, 8] 
    >>> L1.sort(reverse = True) 
    >>> L1 
    [8, 7, 2, 1] 
    
    
    >>> L1 = ['a','ccc','abcd','bc','cd','abc'] 
    >>> L1.sort(key = len) 
    >>> L1 
    ['a', 'bc', 'cd', 'ccc', 'abc', 'abcd'] 
    

    元组(tuple) 元组也归属连串,但元组为不可改正的列表。所以元组未有以上行列通用方法可用!
    一个因素的元组表示为 ( 1 , 卡塔尔

    >>> x = (1,) 
    >>> type(x) 
    <class 'tuple'> 
    >>> x = (1) 
    >>> type(x) 
    <class 'int'> 
    

    元组可转变到列表,反之亦然。
    内建的 tuple(卡塔尔(英语:State of Qatar) 函数选择三个列表参数,并回到五个蕴涵相符成分的元组,而 list(卡塔尔(英语:State of Qatar) 函数选用一个元组参数并回到三个列表。
    从效果上看, tuple(卡塔尔(英语:State of Qatar) 冻结列表,而 list(卡塔尔(قطر‎ 融化元组。

    >>> x = [1,2,4,3,1] 
    >>> y = (1,2,4,3,1) 
    >>> type(x) 
    <class 'list'> 
    >>> type(y) 
    <class 'tuple'> 
    >>> z = tuple(x) 
    >>> z 
    (1, 2, 4, 3, 1) 
    >>> z = list(y) 
    >>> z 
    [1, 2, 4, 3, 1] 
    

    能够用列表 或 元组 进行壹回多赋值:

    >>> L1 = (1,2,4) 
    >>> (x, y, z) = L1 
    >>> x 
    1 
    >>> y 
    2 
    >>> z 
    4 
    
    >>> L1 = [1,2,4] 
    >>> (x,y,z) = L1 
    >>> x 
    1 
    >>> y 
    2 
    >>> z 
    4 
    

    [] ,和 (卡塔尔(قطر‎ 在布尔值向往味 False

     

    列表(list卡塔尔(英语:State of Qatar): 首先,列表归于连串,那么体系类型可用如下内建函数—— list(iter卡塔尔国:把可...

    • 列表、元组、字符串统称为体系。
    • 列表、元组、字符串的协同点:

    1,迭代(iteration)(以前记过一遍迭代的概念,不过开采依然回忆不熟,再写一回!)

    迭代是重新举报进程的活动,其指标日常是为了靠拢所需指标或结果。每一遍对进度的再一次称为一回“迭代”,而每一遍迭代获得的结果会作为下一遍迭代的伊始值。

    1.abs()

    取数字的相对值

    >>> print(abs(-28))
    28
    >>> print(abs(-2.34))
    2.34
    >>> print(abs(1/3))
    0.3333333333333333
    

        生机勃勃、一些关于连串的常用BIF(共十个)

      能够经过索引获得一个要素

    2,list(卡塔尔,把可迭代的目的转变为列表

    >>> c = 'i love python!'
    >>> c1 = list(c)
    >>> c1
    ['i', ' ', 'l', 'o', 'v', 'e', ' ', 'p', 'y', 't', 'h', 'o', 'n', '!']
    
    >>> d = (1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
    >>> d
    (1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
    >>> d = list(d)
    >>> d
    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
    

    2.dict()

    用于创建字典

    >>> dict()     #创建空字典
    {}
    >>> dict(a='who',b='while',c='whit')   #传入关键字创建字典
    {'b': 'while', 'c': 'whit', 'a': 'who'}
    >>> dict(zip([1,2,3],['one','two','three']))  #映射函数方式创建字典
    {1: 'one', 2: 'two', 3: 'three'}
    >>> dict([(1,'one'),(2,'two'),(3,'three')])  #可迭代对象方式创建字典
    {1: 'one', 2: 'two', 3: 'three'}
    

        二、课时16课后习题及答案

      暗中认可索引值从0开首

    3,tuple(卡塔尔(قطر‎,把可迭代的靶子转变为元组

    >>> d = tuple(d)
    >>> d
    (1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
    

    3.help() 

    用来查看函数或模块用项的详实表达

    >>> help('sys')   #查看sys模块的帮助
    >>> help('str')   #查看str数据类型帮助信息
    >>> a = [1,2,3]  
    >>> help(a)       #查看列表list帮助信息
    >>> help(a.extend)   #显示list的extend方法的帮助信息
    

     

      可通过分片的方法获得叁个范围内成分的聚合

    4,str(卡塔尔(英语:State of Qatar),把对象调换为字符串

    >>> a
    [0, 1, 2, 3, 4, 5, 6]
    >>> str(a)
    '[0, 1, 2, 3, 4, 5, 6]'
    

    4.min()

    归来给定参数的细微值,参数可认为列表,元组,字典和聚合

    >>> print(min(1,23,4))     #给定序列的最小值,这里实际上判断的元组类
    1
    >>> print(min([1,2,3,4]))   #列表
    1
    >>> print(min((3,4,5)))   #元组
    3
    >>> print(min({'a':3,'b':44,'c':22}))  #字典,对字符串按ascii码位置判断
    a
    >>> print(min({22,33,44}))   #集合判断
    22
    

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

      协同操作符(重复操作符、拼接操作符、成员涉及操作符)

    4,len(卡塔尔(قطر‎,重回对象的尺寸

    >>> a
    [0, 1, 2, 3, 4, 5, 6]
    >>> len(a)
    7
    

    5.setattr()

    对应函数 getatt(),用于安装属性值,该属性必需存在

    风流倜傥、一些关于类别的常用BIF(共十几个)

    • list() #回到二个空驶列车表或把贰个可迭代对象转变为列表

    5,max(卡塔尔,重回连串中参数的最大值

    >>> a
    [0, 1, 2, 3, 4, 5, 6]
    >>> c
    'i love python!'
    >>> max(a)
    6
    >>> max(c)
    'y'
    

    c中最大重临的是y,是因为y的ASCII最大

    6.all()

    判断给定的可迭代参数中具有因素不为0,空,False,重临True,不然再次回到False

    >>> all([1,2,3])   #列表元素不为空或0返回True
    True
    >>> all([0,2,3])  #列表元素为0返回False
    False
    >>> all([1,'',3])  #列表元素为空返回False
    False
    >>> all([1,False,3])  #列表元素为False返回False
    False
    >>> all([])    #注意:空列表返回True
    True
    >>> all((1,2,3))  #元组元素都不为空或0返回True
    True
    >>> all((0,2,3))  #为0返回False
    False
    >>> all((1,'',3))   #为空返回False
    False
    >>> all(())    #注意:空元组返回True
    True
    >>> all((1,False,3))   #为False返回False
    False
    

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

       #新的空驶列车表

    6,min(卡塔尔,重临体系中参数的最小值

    >>> e = (1, 0, -1, 2, 3, -3)
    >>> min(e)
    -3
    

    7.dir()

    得到当前界定内的变量,方法和概念的品种列表,带参数时重回参数的属性,方法列表

    >>> dir()   #获取当前范围内的变量,方法和定义的类型列表,
    ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'd1']
    #带参数时返回参数的属性,方法列表
    >>> dir(list)    #返回列表的方法
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    

    把列表、元组和字符串放在一齐读书是有道理的,因为它们有多数协同点:

      list #迭代器做参数,生成一个空驶列车表,从索引为0最早,每二回索引依次增加获得的值都停放那些列表里面。

    注意

    >>> a
    [0, 1, 2, 3, 4, 5, 6, 'a']
    >>> max(a)
    Traceback (most recent call last):
      File "<pyshell#57>", line 1, in <module>
        max(a)
    TypeError: '>' not supported between instances of 'str' and 'int'
    >>> min(a)
    Traceback (most recent call last):
      File "<pyshell#58>", line 1, in <module>
        min(a)
    TypeError: '<' not supported between instances of 'str' and 'int'
    

    max(卡塔尔国和min(卡塔尔方法,须求种类中具有参数类型生机勃勃致

    8.hex()

    将数值转变到十七进制

    >>> hex(16)   #将十进制转换成十六进制
    '0x10'
    >>> hex(-17)
    '-0x11'
    >>> hex(0o11)  #将八进制转换成十六进制
    '0x9'
    >>> hex(0b1100)  #将二进制转换成十六直接
    '0xc'
    >>> hex(0b10)
    '0x2'
    #说明:二进制表示(0b),八进制表示(0o),十六进制(0x)
    

      ---都能够经过索引获得每叁个要素
      ---暗许索引值总是从0伊始
      ---可以经过分片的艺术拿到一个节制内的要素的成团
      ---有不少联机的操作符(重复操作符、拼接操作符、成员涉及操作符)

    *  iterable:迭代,重复举报进程的移动,其指标经常是为着好像并完成所需指标或结果,每一次对进程的重新称之为迭代,每一次迭代拿走的结果都会被当成后一次迭代的最早值。*

    7,sum(iterable[, start=0]卡塔尔(英语:State of Qatar),重回系列iterable和可选参数start的总额

    >>> b
    [6, 7, 8, 9, 10, 11, 12]
    >>> sum(b)
    63
    >>> a
    [0, 1, 2, 3, 4, 5, 6, 'a']
    >>> sum(a)
    Traceback (most recent call last):
      File "<pyshell#64>", line 1, in <module>
        sum(a)
    TypeError: unsupported operand type(s) for  : 'int' and 'str'
    

    列表a中,含有字符a

    9.next()

    回去迭代器的下贰个品类,可在平素不下七个品类时回来设置的暗中同意值

    >>> it = iter([1,2,3,4,5])   #使用iter生成迭代器
    >>> next(it)   #返回一个可迭代数据结构中的下一个元素
    1
    >>> next(it)
    2
    >>> next(it)
    3
    >>> next(it)
    4
    >>> next(it)
    5
    >>> next(it)   #在没有下一个元素则会触发 StopIteration 异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration
    >>> next(it,'no values')   #在没有下一个元素时返回指定默认值
    'no values'
    

    我们把它们统称为:连串!上边介绍一些有关类别的常用BIF(内建方式卡塔尔(英语:State of Qatar)

    • tuple([iterable]) #把八个可迭代对象调换为元组,类似list
    • str #把obj对象转变为字符串
    • len #返回sub的长度
    • max() #回来种类或参数群集中的最大值(要保证数据类型统风华正茂)
    • min() #回来系列或参数集合中的最小值
    • sum(iterable[,start=0]) #重临系列iterable和可选参数start的总量
    • sorted() #类似list.sort
    • reversed() #看似list.reverse,重回的是迭代器对象,倒置
    • enumerate() #枚举,索引 元素
    • zip() #重临由种种参数的行列组成的元组

    8,sorted(卡塔尔,依据种类中参数的深浅,由小到大举行排序

    >>> e
    (1, 0, -1, 2, 3, -3)
    >>> sorted(e)
    [-3, -1, 0, 1, 2, 3]
    

    10.slice()

    用来创制切丝对象,可钦命开首和截至地点,间距

    class slice(stop)

    class slice(start,stop[,step])

    >>> l1 = [1,2,3,4,5,6,7,8]
    >>> slice1 = slice(5)   #定义一个切片对象,截取长度为5,不指定起始位置默认从索引0开始
    >>> l1[slice1]    #列表引用切片对象
    [1, 2, 3, 4, 5]
    >>> slice3 = slice(1,6,1)   #定义一个切片对象,指定起始位置为1结束位置为6,间隔为1
    >>> l1[slice3]    #当间隔为1时,相当于0间隔
    [2, 3, 4, 5, 6]
    >>> slice2 = slice(1,7,2)  #间隔为2时,相隔一个截取元素
    >>> l1[slice2]
    [2, 4, 6]
    

     

    9,reversed(卡塔尔(قطر‎,根据体系中的参数,重回三个倒序排列的列表

    >>> e
    (1, 0, -1, 2, 3, -3)
    >>> reversed(e)
    <reversed object at 0x0310B590>
    >>> list(reversed(e))
    [-3, 3, 2, -1, 0, 1]
    

    reversed(e卡塔尔(英语:State of Qatar),直接利用的话重临的是迭代器对象,因而供给把结果调换来list。

    11.any()

    推断可迭代参数是还是不是全体为空或0或False则赶回False,不然再次来到True。

    >>> any([1,2,3])
    True
    >>> any([0,'',1])
    True
    >>> any([0,'',False])   #全部为空值才返回False
    False
    >>> any([])   #空列表返回False
    False
    >>> any((1,2,3))
    True
    >>> any((0,'',1))
    True
    >>> any((0,'',False))
    False
    >>> any(())   #空元组返回False
    False
    

    1、list([iterable])

    #list()>>> a = 'This is a test string.'>>> a = list>>> a['T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', '.']>>> b = >>> b = list>>> b[1, 2, 3]>>> c = [1,2,3,'a','b','c']>>> c = list>>> c[1, 2, 3, 'a', 'b', 'c']#sorted>>> a['T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', '.']>>> sorted[' ', ' ', ' ', ' ', '.', 'T', 'a', 'e', 'g', 'h', 'i', 'i', 'i', 'n', 'r', 's', 's', 's', 's', 't', 't', 't']#reversed>>> reversed<list_reverseiterator object at 0x02DA5150>>>> list(reversed['.', 'g', 'n', 'i', 'r', 't', 's', ' ', 't', 's', 'e', 't', ' ', 'a', ' ', 's', 'i', ' ', 's', 'i', 'h', 'T']#enumerate>>> a = ['a','b','c','d']>>> enumerate<enumerate object at 0x02CCF788>>>> list(enumerate[, , , ]#zip>>> a = [1,2,3,4,5]>>> b = [9,8,7,6,5,4]>>> list[, , , , ]
    

    10,enumerate(卡塔尔(英语:State of Qatar),用体系中各样参数的索引值,依次与参数组成新的元组

    >>> a
    [0, 1, 2, 3, 4, 5, 6, 'a']
    >>> list(enumerate(a))
    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 'a')]
    

    12.divmod(a,b)

    回到a除以b的商和余数的元组(a//b,a%b卡塔尔

    >>> divmod(4,2)   #返回4除以2的商和余数
    (2, 0)
    >>> divmod(15,4)
    (3, 3)
    >>> divmod(2 0.2j,3 1.3j)   #不支持负数
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: can't take floor or mod of complex number.
    >>> divmod(4,8)  #当不被整除时余数返回4,不解!
    (0, 4)
    >>> divmod(4,9)
    (0, 4)
    >>> divmod(4,100)
    (0, 4)
    

    list()方法用于把一个可迭代对象转变为列表,科学普及下迭代:所谓迭代,是重复举报进程的位移,其目标经常是为了好像并达到所需的对象或结果。每叁回对经过的再一次被叫作一遍”迭代“,而每二回迭代会被用为下三次迭代的最初值....就现阶段的话,迭代还正是三个for循环,但从今以后会介绍到迭代器,那些作用,那叫一个惊艳!

      

    11,zip(卡塔尔,用2个不等的队列中的参数,依照索引值组成新的元组

    >>> a
    [0, 1, 2, 3, 4, 5, 6, 'a']
    >>> b
    [6, 7, 8, 9, 10, 11, 12]
    >>> list(zip(a, b))
    [(0, 6), (1, 7), (2, 8), (3, 9), (4, 10), (5, 11), (6, 12)]
    

    13.id()

    用来获取对象的内部存款和储蓄器地址

    >>> id(1)
    8956480
    >>> id(2)
    8956512
    >>> id('b')
    140349300904040
    >>> a = 'python'
    >>> id(a)
    140349300975744
    

    此地说的list()方法也许不带参数,要么带叁个可迭代对象作为参数,而那个行列天生正是可迭代对象(迭代以此概念实际上就算从种类中泛化而来的卡塔尔(英语:State of Qatar)。举多少个例子:

    14.object()

    获取一个新的,无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
    该函数时2.2.版本新增,2.3版本之后,该函数不接受任何参数。
    
    >>> #创建一个列表
    >>> a = list()
    >>> a
    []
    >>> #将字符串的每个字符迭代存放到列表中
    >>> b = list("FishC")
    >>> b
    ['F', 'i', 's', 'h', 'C']
    >>> #将元组中的每个元素迭代存放到列表中
    >>> c = list((1,1,2,3,5,8,13))
    >>> c
    [1, 1, 2, 3, 5, 8, 13]
    

    15.sorted()

    对具有可迭代的靶子进行排序操作

    sort 与 sorted 区别:

    sort 是选择在 list 上的措施,sorted 能够对负有可迭代的对象开展排序操作。

    list 的 sort 方法重临的是对曾经存在的列表实行操作,而内建函数 sorted 方法再次来到的是叁个新的 list,并不是在原本的根基上海展览中心开的操作。

    语法:sorted(iterable, /, *, key=None, reverse=False)

    iterable:可迭代对象

    key:用来拓宽相比的成分,只有多个参数,钦赐可迭代对象中的二个要向来进展排序

    reverse:排序法规,reverse=True为降序,reverse= False为升序(默许)

    >>> sorted([-12,3,23,18])   #列表按数字排序
    [-12, 3, 18, 23]
    >>> sorted([-12,3,23,18],key=abs)  #列表数字按绝对值排序
    [3, -12, 18, 23]
    >>> sorted(['bc','aa','fd','cj'])   #列表字符按首字母的ASCII码排序
    ['aa', 'bc', 'cj', 'fd']
    #如果是数字与字符混合,在python3需要指定key的函数对象
    >>> l1 = [2,'a','b',4,-33,'python']
    >>> l1
    [2, 'a', 'b', 4, -33, 'python']
    >>> sorted(l1,key=id)   #按内存地址排序
    [2, 4, -33, 'a', 'b', 'python']
    >>> sorted(l1,key=str)  #按字符串排序,对所有数据转换成字符串后首个字符按ASCII排序
    [-33, 2, 4, 'a', 'b', 'python']
    >>> ord('-')
    45
    >>> ord('2')
    50
    >>> ord('4')
    52
    >>> ord('a')
    97
    >>> ord('b')
    98
    >>> ord('p')
    112
    #如果需要排序的是一个列表嵌套元组,则需要使用参数key,指定关键字
    >>> a = [('b',2),('a',1),('c',0)]
    >>> sorted(a,key=lambda x:x[0])
    [('a', 1), ('b', 2), ('c', 0)]
    >>> sorted(a,key=lambda x:x[1])
    [('c', 0), ('a', 1), ('b', 2)]
    
    >>> tup1 = ('python','java','c  ','bash','php','perl','c#')
    >>> tup1
    ('python', 'java', 'c  ', 'bash', 'php', 'perl', 'c#')
    >>> sorted(tup1,key=str.lower)   #忽略大小写排序
    ['bash', 'c#', 'c  ', 'java', 'perl', 'php', 'python']
    >>> sorted(tup1,key=str.lower,reverse=True)  #反向排序
    ['python', 'php', 'perl', 'java', 'c  ', 'c#', 'bash']
    

    落到实处进度差不离正是新建三个列表,然后循环通过索引迭代参数的每一个要素并投入列表,迭代完成后回来列表就可以。

    16.ascii()

    看似 repr(卡塔尔(英语:State of Qatar) 函数, 重回三个意味对象的字符串, 但是对于字符串中的非 ASCII 字符则重临经过 repr() 函数使用 x, u 或 U 编码的字符

    >>> ascii('bb')
    "'bb'"
    >>> ascii(' ')
    "' '"
    >>> ascii('中')
    "'\u4e2d'"
    

     

    17.enumerate()

    函数用于将三个可遍历的数量对象(如列表、元组或字符串卡塔尔国组合为多个索引连串,相同的时间列出多少和数量下标,日常用在 for 循环在那之中

    语法:enumerate(sequence,[start=o])

    sequence:三个系列,迭代器或任何支持迭代对象

    start:下标开始地方

    >>> l1 = ['python','c  ','java','php','css']
    >>> list(enumerate(l1))     #生成数据和数据下标
    [(0, 'python'), (1, 'c  '), (2, 'java'), (3, 'php'), (4, 'css')]
    >>> list(enumerate(l1,1))   #指定下标从1开始
    [(1, 'python'), (2, 'c  '), (3, 'java'), (4, 'php'), (5, 'css')]
    
    >>> l1 = ['python','c  ','java','php','css']
    >>> for i,v in enumerate(l1):
    ...   print(i,v)
    ... 
    0 python
    1 c  
    2 java
    3 php
    4 css
    

    2、tuple([ iterable])

    18.input()

    用来博取调换输入,python3默许选取的是字符串

    >>> in1 =input('inside:')
    inside:123
    >>> type(in1)   #默认接受字符串
    <class 'str'>
    >>> in2 =input('inside:')
    inside:python
    >>> type(in2)
    <class 'str'>
    

    tuple()方法用于把一个可迭代的目的调换为元组,具体的措施跟list()相符。

    19.oct()

    将三个卡尺头转变到8进制字符串

    >>> oct(10)   #十进制转八进制
    '0o12'
    >>> oct(0b1010)  #二进制转八进制
    '0o12'
    >>> oct(0xA)  #十六进制转八进制
    '0o12'
    >>> oct(3.3)   #不支持float浮点型转八进制
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'float' object cannot be interpreted as an integer
    >>> oct(0.1 1.2j)   #不支持complex复数转八进制
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'complex' object cannot be interpreted as an integer
    

     

    20.staticmethod()

    归来函数的静态方法

    3、str(obj)

    21.bin()

    回到二个整数 int 只怕长整数 long int 的二进制表示。能够将八进制,十进制,十五进制调换为二进制,不辅助float类型

    >>> bin(10)   #十进制转二进制
    '0b1010'
    >>> bin(10.1)  #float不支持转二进制
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'float' object cannot be interpreted as an integer
    >>> bin(0o10)  #八进制转二进制
    '0b1000'
    >>> bin(0xA)  #十六进制转二进制
    '0b1010'
    

    str()方法用于把obj对象转变为字符串,那几个法子在眼下结合int()和float()方法给大家讲过。

    22.eval()

    用来实行二个字符串表明式,并赶回表达式的值。

    >>> eval('123')
    123
    >>> a = eval('123')   #可以将数值字符串转换为int类型
    >>> type(a)
    <class 'int'>
    >>> eval('2**8')  #将数值字符串当表达式并计算结果返回int类型
    256
    >>> eval("'a' 'b'")  #字符串运算,必须这么写
    'ab'
    >>> eval("'a'*5")  #必须这么写,5不能加引号否则报错
    'aaaaa'
    >>> eval("'a'*'5'")
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<string>", line 1, in <module>
    TypeError: can't multiply sequence by non-int of type 'str'
    

     

    23.int()

    用于将多个字符串数值或数字转变为整形

    >>> int()     #不传入参数结果为0
    0
    >>> a =int('2')    #将字符串转换成int类型
    >>> type(a)
    <class 'int'>
    >>> a
    2
    >>> int(2.6)    #将浮点型转换为整型
    2
    >>> b =int('12',16)  #以字符串的十六进制转换为十进制
    >>> type(b)
    <class 'int'>
    >>> b
    18
    >>> int('0xC',16)  #可以这样写十六进制
    12
    >>> int('10',8)   #八进制转十进制
    8
    >>> int('0o10',8)
    8
    >>> int('0b1000',2)  #二进制转十进制
    8
    >>> int('1000',2)   #可以省略进制表示法
    8
    

    4、len(sub)

    24.open()

    用来张开四个文本,创立三个 file 对象,相关的办法才足以调用它进行读写

    >>> f = open('aa.txt','r ')   #以读写方式打开一个文件
    >>> f.write('hello pythonn')  #写入内容到文件中
    13
    >>> f.flush()   #刷新文件内容
    >>> f.tell()   #查看指针位置
    13
    >>> f.seek(0)  #移动文件指针到起始位置
    0
    >>> f.tell()   #查看指针
    0
    >>> f.readline()  #根据指针位置返回一行文件内容
    'hello pythonn'
    file1 = open('aa.txt','a ',1) #以追加写的模式打开文件,1表示行缓冲,如为0则不缓冲,大于1时表示缓冲区大小,为负数时使用系统默认值。
    

    len()方法用于再次回到sub参数的尺寸:

    25.str()

    将字节转换来字符串,bytes(卡塔尔国 将字符串转变为字节

    >>> s1=str(11)
    >>> type(s1)   #将对象转换成字符串
    <class 'str'>
    
    >>> bytes('中',encoding = 'utf-8')   #将字符串转换bytes字节
    b'xe4xb8xad'
    >>> str(b'xe4xb8xad',encoding = 'utf-8')  #将字节转换为字符串
    '中'
    
    >>> bytes()  #生成空字节对象
    b''
    
    >>> str1 = "I love zww"
    >>> len(str1)
    10
    >>> list1 = [1,1,2,3,5,8,13]
    >>> len(list1)
    7
    >>> tuple1 ="这","是","一","个","元组"
    >>> len(tuple1)
    5
    

    26.bool()

    看清给的参数是不是为真,则赶回True,否则重返False

    >>> bool()
    False
    >>> bool(0)
    False
    >>> bool(1)
    True
    >>> bool(2)
    True
    >>> bool(False)
    False
    >>> bool(True)
    True
    >>> bool('')
    False
    >>> bool('a')
    True
    >>> bool(None)
    False
    >>> bool("")
    False
    >>> bool([])
    False
    >>> bool(())
    False
    >>> bool({})
    False
    

     

    27.exec()

    实施字符串或complie方法编写翻译过的字符串,未有重临值

    >>> exec("a=1 2 3 4")
    >>> a
    10
    
    >>> exec('''sum = 0
    ... for i in range(101):
    ...   sum =i
    ... print(sum)
    ... ''')
    5050
    

    5、max(...)

    28.isinstance()

    认清目的是不是是某些类的实例

    >>> isinstance('a',str)    #判断a是否是字符类的对象
    True
    >>> isinstance('a',int)
    False
    >>> isinstance(11,int)
    True
    >>> isinstance({1:'a'},dict)
    True
    >>> isinstance({1,2},dict)
    False
    >>> isinstance({1,2},set)
    True
    >>> isinstance((1,2),(str,int,list))  #判断对象是否在元祖中的一个类创建返回True,否则返回False
    False
    >>> isinstance((1,2),(str,int,list,tuple))
    True
    

    max()方法用于再次来到类别或许参数会集中的最大值,相当于说,max()参数能够是叁个队列,重回值是该类别中的最大值;也足以是八个参数,那么max()将赶回那几个参数中最大的多个:

    29.ord()

    ord(卡塔尔(قطر‎ 函数是 chr(卡塔尔国 函数(对于8位的ASCII字符串)或 unichr()函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,再次回到对应的 ASCII 数值,只怕 Unicode 数值,若是所给的 Unicode 字符超过了您的 Python 定义范围,则会吸引贰个 TypeError 的特别

    >>> ord('2')   #长度只能为一个字符串
    50
    >>> ord('a')
    97
    >>> ord('A')
    65
    >>> ord('中')  #返回对应的unicode值
    20013
    >>> ord('国')
    22269
    >>> ord(' ')  #返回ascii数值
    43
    
    >>> list1 = [1,18,13,0,-98,34,54,76,32]
    >>> max(list1)
    76
    >>> str1 = "I love zww"
    >>> max(str1)
    'z'
    >>> max(5,8,1,13,5,29,10,7)
    29
    

    30.sum()

    对文山会海进行求和计算,只好是列表或元祖

    >>> sum([1,2,3,4])   #求有序列的和,只能是数字类型
    10
    >>> sum([1,2,3,4],5)  #对有序列求和后相加的数字
    15
    

     

    31.bytearray()

    回到二个新字节数组。那些数组里的要素是可变的,况且每一种成分的值范围: 0 <= x < 256

    >>> bytearray()   #没有参数时,初始化数组0个元素
    bytearray(b'')
    >>> bytearray(12)  #为整数时,返回一个长度为源的初始化数组
    bytearray(b'x00x00x00x00x00x00x00x00x00x00x00x00')
    >>> bytearray('python','utf-8')  #为字符串时,按指定编码转换为字节序列
    bytearray(b'python')
    >>> bytearray([1,2,3])  #可迭代时,必须为0-255中的整数,字节序列
    bytearray(b'x01x02x03')
    

    6、min(...)

    32.filter()

    用于过滤系列,过滤掉不切合条件的要素,再次来到由切合条件成分结合的迭代器

    语法:filter(function,iterable卡塔尔     function:剖断函数,iterable:可迭代对象

    >>> def is_odd(x):
    ...   return x % 2 == 1    #创建一个过滤奇数的函数
    ... 
    >>> newlist = filter(is_odd,[1,2,3,4,5,6,7,8,9])  #使用filter过滤以is_odd函数为判断依据的迭代器
    >>> print(newlist)
    <filter object at 0x7f544ab79908>
    >>> next(newlist)  #使用next打印迭代器的下一个值
    1
    >>> next(newlist)
    3
    >>> next(newlist)
    5
    >>> next(newlist)
    7
    >>> next(newlist)
    9
    

    min方法跟max()用法同样,但功用相反:重回种类大概参数集合的小不点儿值。这里必要留意的是,使用max()和min()方法都要确定保障连串恐怕参数的数据类型统生机勃勃,不然会出错。

    33.issubclass()

    用以判别参数 class 是还是不是是类型参数 classinfo 的子类

    class A(object):
        pass
    
    class B(A):
        pass
    
    print(issubclass(B,A))  #判断B是否是A的派生类,是返回True,否则返回False
    
    >>> min(123,'oo',456,'xx')
    Traceback (most recent call last):
      File "<pyshell#8>", line 1, in <module>
        min(123,'oo',456,'xx')
    TypeError: '<' not supported between instances of 'str' and 'int'
    >>> list1 = [1,18,13,0,-98,34,54,76,32]
    >>> list1.append("x")
    >>> max(list1)
    Traceback (most recent call last):
      File "<pyshell#11>", line 1, in <module>
        max(list1)
    TypeError: '>' not supported between instances of 'str' and 'int'
    

    34.pow()

    再次回到x的y次方,假诺z存在则再对结果取模(pow(x,y卡塔尔(英语:State of Qatar)%z)

    >>> pow(6,2)    #6的2次方
    36
    >>> pow(6,2,5)  #先预算6的2次方,在对结果取5的模
    1
    >>> pow(8,2)
    64
    >>> pow(8,2,5)
    4
    #math模块的pow()方法对比
    >>> import math
    >>> math.pow(6,2)    #math模块会把参数转换成float计算
    36.0
    >>> math.pow(6,2,5)   #math模块中没有取模方法参数
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: pow expected 2 arguments, got 3
    

    每户说:外行看愉快,内行看门道。深入分析下这几个错误音讯。Python这里说”'>' not supported between instances of 'str' and 'int'“意思正是没办法拿字符串和整型举行比较。

    35.super()

    调用父类的不二等秘书诀

    class A(object):
        def __init__(self):
            self.name = 'python'
        def foo(self):
            print('class,A')
    
    class B(A):
        super(A)  #调用父类的方法和属性
        def foo_b(self):
            print('class',self.name)
    
    #print(issubclass(B,A))
    bb = B()
    bb.foo()
    bb.foo_b()
    
    #output
    class,A
    class python
    

    您看,str()>int()表明max()和min()方法的里边贯彻事实上相近于事情发生前提到的,通过索引获得每叁个因素,然后将相继要素举办对照。所以无妨依据揣摸写出或许的代码:

    36.float()

    用于将整数和字符串调换到浮点数

    >>> float(2)
    2.0
    >>> float('2')
    2.0
    >>> float(-23)
    -23.0
    
    #猜想下max(tuple1)的实现方式
    temp = tuple[0]
    
    for each in tuple1:
          if each > temp:
                temp = each
    
    return temp
    

    37.iter()

    用来扭转迭代器

    >>> new1 = iter(('a','b','c','e','g'))
    >>> new1
    <tuple_iterator object at 0x7f544ab7b5f8>
    >>> next(new1)
    'a'
    >>> next(new1)
    'b'
    

    有鉴于此,Python的放置方法也没啥了不起的。

    38.print()

    打字与印刷输出

    语法:print(*objects,sep=' ',end='n',file=sys.stdout)

    • objects -- 复数,表示可以二次输出多少个指标。输出多个对象时,须求用 , 分隔。
    • sep -- 用来间距多少个对象,暗中同意值是一个空格。
    • end -- 用来设定以什么末了。暗中同意值是换行符 n,大家能够换来其余字符串。
    • file -- 要写入的公文对象。

      print('hello world'卡塔尔(قطر‎hello world print('hello world',123卡塔尔 #多对象打字与印刷hello world 123 print('hello world',123,sep=' ') #多指标打字与印刷连接符 hello world 123 print('hello world',123,sep=' ',end='t'卡塔尔 #结尾符设置 hello world 123 >>> print('hello world',123,sep=' ',end=''卡塔尔(英语:State of Qatar)hello world 123>>>

     

    39.tuple()

    将列表调换到元组

    >>> tuple([1,2,3,4,5])   #列表转元组
    (1, 2, 3, 4, 5)
    >>> tuple({1,2,3,4,5})   #集合转元组
    (1, 2, 3, 4, 5)
    >>> tuple({1:'a',2:'b',3:'c'})  #字典转元组,只获取自动的key
    (1, 2, 3)
    

    7、sum(iterable[,start])

    40.callable()

    检查一个对象是不是是可调用的,再次回到True否则赶回False

    >>> def func():
    ...   return 1   2
    ... 
    >>> func()
    3
    >>> callable(func)   #对象函数可执行返回True
    True
    

    sum()方法用于再次来到类别iterable的总的数量,用法跟max()和min()方法生机勃勃致。但sum()方法有八个可选参数(start),假若设置该参数,表示从该值初始加起,暗中同意值是0:

    41.format()

    格式化字符串,语法通过{}和:来代表原先的%,不节制参数个数,能够不按梯次传参

    In [27]: '{} {}={}'.format(1,2,3)   #格式化按顺序应用参数值
    Out[27]: '1 2=3'
    In [28]: '{2}-{1}={0}'.format(1,2,3)  #指定顺序应用参数值,0代表第一个元素,1代表第二个元素,以此类推,指定元素位置时要么全部指定,要不都不指定,不能只指定一部分
    Out[28]: '3-2=1'
    In [29]: '{0} {0}={1}'.format(2,3)  #指定参数可以重复使用
    Out[29]: '2 2=3'
    In [30]: '{} {}={}'.format(2,3)   #如不指定顺序,format参数不够就会报错
    ---------------------------------------------------------------------------
    IndexError                                Traceback (most recent call last)
    <ipython-input-30-29f40e412920> in <module>()
    ----> 1 '{} {}={}'.format(2,3)
    IndexError: tuple index out of range
    
    In [31]: l1 = [2,4,8]     
    In [32]: '{}*{}={}'.format(*l1)   #使用列表引用参数值
    Out[32]: '2*4=8'
    
    In [33]: dct = {'name':'python','age':20}   #定义字典
    In [35]: 'welcom to {name},age is {age}'.format(name='qi',age=28) #变量引用
    Out[35]: 'welcom to qi,age is 28'
    
    In [36]: 'welcom to {name},age is {age}'.format(**dct) #使用**引用字典参数必须填写key值
    Out[36]: 'welcom to python,age is 20'
    
    填充与格式化:
    In [53]: "{0: >20}".format("string")   #使用空格填充20宽度右对齐,0代表指定第一个参数值
    Out[53]: '              string'
    
    In [54]: "{0:&>20}".format("string")
    Out[54]: '&&&&&&&&&&&&&&string'
    
    In [55]: "{0:#>20}".format("string") #使用#号会有个小bug
       ....:     
    Out[55]: '##############string'
    
    In [60]: '{0: <20}'.format("string")  #向左对齐填充 
    Out[60]: 'string              '
    
    In [61]: '{0: ^20}'.format("string")  #剧中对齐填充 
    Out[61]: '       string       '
    
    精度与进制:
    >>> '{0:.3f}'.format(10/3)    #小数位进度格式化
    '3.333'
    >>> '{0:b}'.format(8)    #格式化二进制
    '1000'
    >>> '{0:o}'.format(9)  #格式化八进制
    '11'
    >>> '{0:x}'.format(26) #格式化十六进制
    '1a'
    >>> '{0:,}'.format(123456789)  #千分位格式化
    '123,456,789'
    
    使用索引:
    >>> l2 = ['AA',{'bb':'cc'},('d','e')]   #列表索引引用
    >>> 'outing:{0[0]}'.format(l2)  
    'outing:AA'
    >>> 'outing:{0[0]},{0[1]}'.format(l2)  #将列表当成一个元素,在其中索引值
    "outing:AA,{'bb': 'cc'}"
    
    >>> tuple1 = 1,2,3,4,5
    >>> sum(tuple1)
    15
    >>> sum(tuple1,10)
    25
    

    42.len()

    再次回到对象(字符、列表、元组等)长度或项目个数

    >>> len('python')
    6
    >>> len('123')
    3
    >>> len([1,2,3,4])
    4
    >>> len((1,2,3,4))
    4
    >>> len({1:'a',2:'b',3:'c'})
    3
    >>> len({1,2,3,4})
    4
    

     

    43.property()

    在风靡类中回到属性值

    8、sorted(iterable,key=None,reverse=False)

    新葡亰496net,44.type()

    重临对象的品种

    >>> type('123')
    <class 'str'>
    >>> type(12)
    <class 'int'>
    >>> type(12.2)
    <class 'float'>
    >>> type([])
    <class 'list'>
    >>> type(())
    <class 'tuple'>
    >>> type({})
    <class 'dict'>
    >>> type({1,2,3})
    <class 'set'>
    

    sorted()方法用于再次来到叁个排序的列表,大家还记得列表的内建措施sort()吗?它们的得以达成效果与利益是同等的,但列表的内建情势sort()是贯彻列表原地排序;而sorted()是重回三个排序后的新列表。

    45.chr()

    回去叁个数字在ASCII编码中对应的字符,取值范围2伍拾多少个

    >>> chr(1)
    'x01'
    >>> chr(11)
    'x0b'
    >>> chr(255)
    'ÿ'
    >>> chr(256)
    'Ā'
    >>> chr(257)
    'ā'
    >>> chr(0x31)
    '1'
    >>> chr(0x3)
    'x03'
    >>> chr(0x11)
    'x11'
    
    >>> list1 = [1,18,13,0,-98,34,54,76,32]
    >>> list2 = list1[:]
    >>> list1.sort()
    >>> list1
    [-98, 0, 1, 13, 18, 32, 34, 54, 76]
    >>> sorted(list2)
    [-98, 0, 1, 13, 18, 32, 34, 54, 76]
    >>> list2
    [1, 18, 13, 0, -98, 34, 54, 76, 32]
    

    46.frozenset()

    回来一个结霜的聚集,冻结后集合不能够再增加或删除任何因素

    >>> set1 = frozenset([1,2,3,4])  #列表返回一个不可变集合
    >>> set1
    frozenset({1, 2, 3, 4})
    >>> frozenset((5,6,7))  #元祖返回一个不可变集合
    frozenset({5, 6, 7})
    >>> a
    {1: 'a', 2: 'b', 3: 'c'}
    >>> frozenset(a)     #字典返回一个不可变集合
    frozenset({1, 2, 3})
    >>> frozenset({3,4,5})  #集合返回一个不可变集合
    frozenset({3, 4, 5})
    

     

    47.list()

    将字符串或元祖转换为列表

    >>> l1 = list('python')   #字符串转列表
    >>> type(l1)
    <class 'list'>
    >>> l1
    ['p', 'y', 't', 'h', 'o', 'n']
    >>> list((1,2,3,4,5))  #元祖转列表
    [1, 2, 3, 4, 5]
    >>> dic1 = {1:'a',2:'b',3:'c'}
    >>> list(dic1)   #字典转列表
    [1, 2, 3]
    >>> list({1,2,3,4})  #集合转列表
    [1, 2, 3, 4]
    >>> list()   #返回空列表
    []
    

    9、reversed(sequence)

    48.range()

    始建叁个整数列表

    >>> l1 = range(5)
    >>> l1
    range(0, 5)
    >>> for i in l1:    #循环取序列
    ...   print(i)
    ... 
    0
    1
    2
    3
    4
    >>> for i in range(1,4):print(i)  #指定起始和结束位置
    ... 
    1
    2
    3
    >>> for i in range(1,10,3):print(i) #指定起始和结束位置和步长
    ... 
    1
    4
    7
    >>> for i in range(0,-10,-4):print(i) #负数以补偿循环
    ... 
    0
    -4
    -8
    >>> for i in range(len('python')):print('python'[i]) #字符串循环打印
    ... 
    p
    y
    t
    h
    o
    n
    

    reversed()方法用于重临逆向迭代连串的值。形似的道理,实现效果与利益跟列表的内建措施reserse()黄金时代致。差异是列表的内建艺术是原地回转,而reversed()是回到二个扭曲后的迭代对象。你没看错,它不是重临叁个列表,是回来二个迭代指标:

    49.vars()

    回来当前模块中的全体变量

    >>> class runoob:
    ...   a = 1
    ... 
    >>> print(vars(runoob))
    {'__dict__': <attribute '__dict__' of 'runoob' objects>, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'runoob' objects>, 'a': 1}
    >>> aa = runoob()
    >>> aa
    <__main__.runoob object at 0x7f98f1b3c0d0>
    >>> print(vars(aa))
    {}
    
    >>> list1 = [1,18,13,0,-98,34,54,76,32]
    >>> reversed(list1)
    <list_reverseiterator object at 0x000001DAF03F15C0>
    >>> for each in reversed(list1):
        print(each,end=',')
    
    32,76,54,34,-98,0,13,18,1,
    

    50.classmethod()

    再次回到一个类措施,具体实例请看python3之面向对象类定义

     

    51.getattr()

    回到叁个指标属性值,也便是函数内部存款和储蓄器地址

    class test(object):
        i = 'hello'
        def show(self):
            print('output:',self.i)
    
    obj1 = test()  #实例化对象
    ss = getattr(obj1,'show')  #返回一个对象的方法内存地址
    ss()   #执行对象方法
    
    
    #output
    output: hello
    

     

    学习笔记,python3之内置函数。10、enumerate(iterable)

    52.set()

    创办三个九冬不重复成分集,可开展关联测验,删除重复数据,还是能总结交集、差集、并集等

    >>> s1 = set('pythonpython')
    >>> s1 = set('pythonpython')  #重复的被删除
    >>> s1
    {'h', 'n', 'o', 'p', 't', 'y'}
    >>> type(s1)
    <class 'set'>
    
    >>> s2 = set('pyqi')
    >>> s2
    {'p', 'y', 'i', 'q'}
    >>> s1 & s2  #交集
    {'p', 'y'}
    >>> s1 | s2  #并集
    {'p', 'q', 't', 'i', 'h', 'y', 'n', 'o'}
    >>> s1 - s2   #差集i
    {'h', 't', 'n', 'o'}
    

    enumerate()方法生成由二元组(二元组正是因素数量为二的元组)构成的一个迭代指标,每一个二元组是由可迭代参数的索引号及其对应成分组成的。举例:

    53.locals()

    以字典类型再次回到当前地方的漫天有些变量

    >>> def funct(*args):   #两个局部变量
    ...   a = 22 
    ...   print(locals())
    ... 
    >>> funct(33,44)    #返回所有局部变量的健值
    {'a': 22, 'args': (33, 44)}
    
    >>> str1 = "FishC"
    >>> for each in enumerate(str1):
        print(each)
    
    (0, 'F')
    (1, 'i')
    (2, 's')
    (3, 'h')
    (4, 'C')
    

    54.repr()

    将目的转变为供解释器读取的款型

    >>> aa = repr([1,2,3])
    >>> type(aa)   #将对象转换为字符
    <class 'str'>
    >>> repr({'a':'A','b':'B'})
    "{'a': 'A', 'b': 'B'}"
    

    学习笔记,python3之内置函数。 

    55.zip()

    用于将可迭代的对象作为参数,将目的中对应的要素打包成一个个元组,然后回到由这个元组组成的列表

    假定每个迭代器的因素个数不雷同,则赶回列表长度与最短的靶子相通,利用 * 号操作符,能够将元组解压为列表

    >>> aa = (zip([1,2,3],['a','b','c']))
    >>> aa
    <zip object at 0x7f98f1893680>
    >>> next(aa)
    (1, 'a')
    >>> next(aa)
    (2, 'b')
    >>> next(aa)
    (3, 'c')
    >>> bb = zip([1,2,3],['a','b','c','d'],['A','B','C','D','E'])
    >>> bb
    <zip object at 0x7f98f18936c8>
    >>> next(bb)
    (1, 'a', 'A')
    >>> next(bb)
    (2, 'b', 'B')
    >>> next(bb)
    (3, 'c', 'C')
    

    11、zip(,iter2[...])

    56.compile()

    将二个字符串编写翻译为字节代码

    >>> str = 'for i in range(10):print(i)'
    >>> c = compile(str,'','exec')
    >>> c
    <code object <module> at 0x7f98f1b774b0, file "", line 1>
    >>> exec(c)
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> str = '3*5 3'
    >>> a = compile(str,'','eval')
    >>> eval(a)
    18
    

    zip()方法用于重临由逐意气风发可迭代对象参数同盟整合的元组,举例:

    57.globals()

    以字典类型重回当前地方的全部全局变量

    >>> a = 'python'
    >>> print(globals())   #返回一个全局变量的字典,包括导入的变量
    {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, 'a': 'python', '__name__': '__main__', '__doc__': None, '__package__': None, '__spec__': None}
    
    >>> list1 = [1,3,5,7,9]
    >>> str1 = "FishC"
    >>> for each in zip(list1,str1):
        print(each)
    
    (1, 'F')
    (3, 'i')
    (5, 's')
    (7, 'h')
    (9, 'C')
    >>> tuple1 = (2,4,6,8,10)
    >>> for each in zip(list1,str1,tuple1):
        print(each)
    
    (1, 'F', 2)
    (3, 'i', 4)
    (5, 's', 6)
    (7, 'h', 8)
    (9, 'C', 10)
    

    58.map()

    将函数调用映射到各样体系的相应元素上并回到叁个含有全部再次回到值的列表

    >>> def out(x,y):
    ...   return (x,y)
    ... 
    >>> l1 =map(out,[1,2,3,4,5],['a','b','c','d','e'])  #映射序列,返回函数的值
    >>> print(list(l1))
    [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]
    
    >>> def foo(x,y):
    ...   return x*y
    ... 
    >>> print(list(map(foo,[2,3,4],[5,6,7])))
    [10, 18, 28]
    

     

    59.reversed()

    重返三个五花大绑的迭代器

    >>> print(list(reversed(range(10))))  #range反转
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    >>> print(list(reversed(['a','c','f'])))
    ['f', 'c', 'a']
    >>> print(list(reversed(('java','c  ','python'))))
    ['python', 'c  ', 'java']
    >>> print(list(reversed('python')))
    ['n', 'o', 'h', 't', 'y', 'p']
    

     

    60.__import__()

    用来动态加载类和函数

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

    61.complex() 

    重返贰个复数

    >>> complex(1,2)
    (1 2j)
    >>> complex('2')
    (2 0j)
    >>> complex('2','3')    #为字符串时只能指定一位
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: complex() can't take second arg if first is a string
    >>> complex('2 3j') 
    (2 3j)
    

    二、课时16课后习题及答案

    62.hasattr()

    用来剖断目的是否含有相应的习性

    >>> print(hasattr(list,'append'))
    True
    >>> print(hasattr(tuple,'append'))
    False
    >>> print(hasattr(tuple,'index'))
    True
    >>> print(hasattr(dict,'keys'))
    True
    >>> print(hasattr(dict,'values'))
    True
    

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

    63.max()

    回来给定参数的最大值

    >>> max([2,44,55,88])
    88
    >>> max((3,48))
    48
    >>> max({1:48,2:23})
    2
    

    测试题:

    64.round()

    重回浮点数x的四舍五入值

    >>> print(round(1.345))
    1
    >>> print(round(1.345,3))   #3为小数点后位数
    1.345
    >>> print(round(1.345,2))
    1.34
    >>> print(round(1.345,1))
    1.3
    >>> print(round(1.545,1))
    1.5
    >>> print(round(1.545,2))
    1.54
    
    1. 大家根据列表、元祖和字符串的一路性格,把它们三统称为何?
    2. 试问分别使用什么BIF,能够把一个可迭代对象转变为列表、元祖和字符串?
    3. 您仍为能够复述出“迭代”的定义吗?
    4. 你感到调用 max('I love FishC.com'卡塔尔(قطر‎ 会重临什么值?为啥?
      4. 啊哎呀,现在的小屁孩太捣鬼了,邻居家的男女捣鬼,把小甲鱼刚写好的代码画了个美术,麻烦各位鱼油恢复生机下啊,其余这个家伙画的是神马吗?怎么那么眼熟啊!??

    65.delattr()

    除去对象的属性

     

    66.hash()

    拿到叁个对象(字符串也许数值等)的哈希值

    >>> hash('python')
    -7183818677546017823
    >>> hash(1)
    1
    >>> hash(36)
    36
    >>> hash([1,2,3])   #列表不能取哈希值
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    >>> hash(str([1,2,3]))
    -1281906435344341319
    >>> hash(str({1:'a'}))
    -6473938891374685725
    >>> hash(str({'1':'1'}))
    -5747816388481399936
    

    动动手:

    67.memoryview()

    回去字节对象的内存地址

    >>> a = bytes([1,2,3])   #定义一个字节对象
    >>> a
    b'x01x02x03'
    >>> memoryview(a)
    <memory at 0x7f7cd1bbcb88>
    >>> b = memoryview(a)    #返回字节对象的内存地址
    >>> b[0]
    1
    >>> b[1]
    2
    >>> b[1:4]    #切片取的是一个迭代器
    <memory at 0x7f7cd1bbcb88>
    >>> b[1:3].tobytes()
    b'x02x03'
    >>> for i in b:print(i)   #迭代取数值
    ... 
    1
    2
    3
    

    继续更新实例。。。。

    1. 估量一下 min(卡塔尔(قطر‎ 那个BIF的完成进度
    2. 摄像中大家说 sum()那个BIF有个毛病,正是假若参数里有字符串类型的话就能够报错,请写出叁个新的贯彻进程,自动“无视”参数里的字符串并重返正确的总计结果

     

    答案:

     

    测验题答案:
    0. 大家依据列表、元祖和字符串的一同特点,把它们三统称为何?
    队列,因为他俩有以下协同点: 

    1)都可以通过索引得到每一个元素
    2)默认索引值总是从0开始(当然灵活的Python还支持负数索引)
    3)可以通过分片的方法得到一个范围内的元素的集合
    4)有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)
    

     

    1. 请问分别接收什么BIF,能够把三个可迭代对象转换为列表、元祖和字符串?   

    list([iterable]卡塔尔(英语:State of Qatar) 把可迭代对象转变为列表

    tuple([iterable]卡塔尔 把可迭代对象转变为元祖

    str(obj卡塔尔国  把对象调换为字符串

     

    2. 你还能够复述出“迭代”的概念呢?
    所谓迭代,是双重举报进程的移位,其目标日常是为了好像并达到所需的目的或结果。每一回对经过的重新被喻为二遍“迭代”,而每一回迭代获得的结果会被用来作为下叁回迭代的起始值。

    >>> temp = 'I love FishC.com!'
    >>> list(temp)
    ['I', ' ', 'l', 'o', 'v', 'e', ' ', 'F', 'i', 's', 'h', 'C', '.', 'c', 'o', 'm', '!']
    

     

    3. 您认为调用 max('I love FishC.com'卡塔尔(قطر‎ 会重临什么值?为啥?

    会回来:'v',因为字符串在Computer中是以ASCII码的款式储存(ASCII对照表:

     

    4. 呀哎呀,今后的小屁孩太捣蛋了,邻居家的子女顽皮,把小甲鱼刚写好的代码画了个图画,麻烦各位鱼油恢复生机下啊,别的这个家伙画的是神马吗?怎么那么眼熟啊!??

    name = input('请输入待查找的用户名:')
    score = [['迷途', 85], ['黑夜', 80], ['小布丁', 65], ['福禄娃娃', 95], ['怡静', 90]]
    IsFind = False
    
    for each in score:
        if name in each:
            print(name   '的得分是:', each[1])
            IsFind = True
            break
    
    if IsFind == False:
        print('查找的数据不存在!')
    

     

    动入手答案:
    0. 测度一下 min(卡塔尔(قطر‎ 那几个BIF的兑现进度

    def min(x):
        least = x[0]
    
        for each in x:
            if each < least:
                least = each
    
        return least
    
    print(min('123456789'))
    

     

    1. 摄像中咱们说 sum(卡塔尔(英语:State of Qatar)那一个BIF有个缺欠,就是后生可畏旦参数里有字符串类型的话就能够报错,请写出多个新的达成进度,自动“无视”参数里的字符串并再次回到正确的总结结果

    def sum(x):
        result = 0
    
        for each in x:
            if (type(each) == int) or (type(each) == float):
                result  = each
            else:
                continue
    
        return result
    
    print(sum([1, 2.1, 2.3, 'a', '1', True]))
    

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:学习笔记,python3之内置函数

    关键词:

上一篇:explain执行计划详解

下一篇:没有了