Python全栈Day 12部分知识点

2018-09-18 06:45:17来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

可迭代对象:列表、字符串、元组

列表(list [])的“魔法”

  定义

    列表是一种类,中括号把数据元素(可以是数字、字符串、列表、布尔值...)括起来,用逗号作分割符。  有序,元素可被修改。

  特性

    深灰“魔法”

    ——可索引(下标)取值;

    ——可切片,切片结果也是列表;

        li=[1,12,9,'age','alex']  #通过list类创建的对象,li

        li[1:3]=[120,90]

        输出

          [1,120,90,'age','alex']

    ——支持in操作

    ——支持for/while循环

    ——可嵌套

        查找嵌套列表的元素可在[]后再加[]

    ——列表元素可以被修改

        li[1]=2

        li[2]=9

        输出

          [1,2,9,'age','alex']

    ——列表元素可以删除

        ...

        del li[1]

        输出

          [1,9,'age','alex']

        del li[1:3]

        输出

          [1,'alex']

    ——字符串转列表,用list()

        s='abcdf'

        new_s=list(s)

        print(new_s)

        输出

          ['a','b','c','d']

    ——列表转字符串

        '''  li=[11,22,33,'123','alex']  

            r=str(li)

            print(r)  #输出‘[11,22,33,'123','alex']’  '''

      1.既有数字,又有字符串,写for循环依次处理

        for i in li:

          s=s+srt(i)

        print(s)

      2.只有字符串,使用join

        li=['123','alex']

        v=''.join(li)

        print(v)

        输出

          123alex

  灰“魔法”——list类中提供的方法

    - append(原来值最后追加,对列表本身进行修改,而非像字符串一样,创建一个新变量添加元素)

    - clear(清空列表,使列表变成[])

    - copy((浅)拷贝)

      li=[11,22,33,44]

      v=li.copy

      print(v)

      输出

        [11,22,33,44]

    - count(计算元素出现的次数)

    - extend(扩展源列表)

       li=[11,22,33,44]

      li.extend([9898,'不得了'])  #相当于执行了for循环

      print(li)

      '''  li.append([9898,'不得了'])  #整体放进去

          print(li)  '''

      '''  li.extend('不得了')

          print(li)  '''

      输出

        [11,22,33,44.9898,‘不得了’]

        '''  [11,22,33,44,[9898,‘不得了’]]  '''

        '''  [11,22,33,44,‘不','得','了’]  '''

    - index(根据值获取当前值索引位置,左边优先)

      li=[11,22,33,44]

      v=li.index(22)

      print(v)

      输出

        1

    - insert(在指定索引位置插入元素)

      li=[11,22,33,44]

      li.insert(0,99)

      print(li)

      输出

        [99,11,22,33,44]

    - pop (删除某个值{默认最后的值},并获取删除的值); - remove(删除列表中的指定值,左边优先)

      li=[11,22,33,44]

      v=li.pop()

      print(v)

      print(li)

      v1=li.pop(1)

      print(v1)

      print(li)

      输出

        44

        [11,22,33]

        22

        [11,33]

      li=[11,22,33,22,44]

      li.remove(22)

      print(li)

      输出

        [11,33,22,44]

p.s.  删除操作 pop / remove / del li[0] / del li[7:9] / clear

    - reverse(将当前列表进行反转)

      li=[11,22,33,22,44]

      li.reverse()

      print(li)

      输出

        [44,22,33,22,11]

    - sort

      li=[11,44,22,33,22]

      li.sort()

      print(li)

      li.sort(reverse=True)

      print(li)

      输出

        [11,22,22,33,44]

        [44,33,22,22,11]

p.s. - cmp ; - key 涉及函数,lambda表达式  内置函数sorted 函数处补充

元组tuple

  圆括号括元素,元素的一级元素不可被修改,不能被增加或者删除。一般写元祖的时候,推荐最后加逗号,不影响元组长度,逗号后面是空的。  有序。

  特性

    ——可索引

      tu=(111,'alex',(11,22),[(33,44)],True,33,44,)

      v=tu[0]

      print(v)

      输出

        111

    ——可切片

      ...

      v=tu[0:2]

      print(v)

      输出

        (111,'alex')

    ——不可修改、增加或删除

    ——可for循环,是可迭代对象

    ——字符串/列表/元组可相互转换

      s='asdfasdf0'

      li=['asdf',1231]

      tu=(123,123,'asdf')

      tu1=('asdf','asdf')

      v=tuple(s)

      print(v)

      v=tuple(li)

      print(v)

      v=list(tu)

      print(v)

      v='_'.join(tu1)

      print(v)

      输出

        ('a','s','d,'f','a','s','d,'f','0')

        ('asdf',1231)

        [123,123,'asdf']

        asdf_asdf

    ——二级或更高级元素可修改

      tu=(111,'alex',(11,22),[(33,44)],True,33,44,)

      tu[3][0]=567

      print(tu)

      输出

        (111,'alex',(11,22),[567],True,33,44,)

  两个方法

    - count 获取指定元素在元组中出现的次数

    - index 获取指定元素在元组中第一次出现的索引值

字典dict

  字典的value可以是任何值;字典的key不能是布尔值、列表和字典。  字典无序,因为无序所以没有系统生成的索引,通过键来找值。

  info={

    'k1':18,  #键值对

    'k2':True

    'k3’:[

      11,

      [],

      ()

      22,

      33,

      {

        'kk1':'vv1',

        'kk2':'vv2',

        'kk3':(11,22),  #找这里的第一个元素 v=info['k3'][5]['kk3'][0]

      }

    ]

    ‘k4’:(11,22,33,44)

     }

    info1={

      1:'asdf',

      'k1':'asdf',

      True:'123',

      [11,22];123,

      (11,22):123,

      {'k1:v1'}:123,

    }

    print(info1)

    输出

      {'k1':'asdf',1:'123',(11,22):123}

      True 1 False 0 这里True和键1重复了 key重复时只能保留一个

      布尔值、列表和字典(涉及到哈希表)不能作为字典的key,常数、元组可以

      (列表或字典若作为key会报错)

  特性

    ——通过键来找值

    ——不可切片

    ——支持del删除 键值对  del info['k1']  del info['k3'][5]['kk1']

    ——默认for循环输出里面元素,只输出key

        for item in info{.keys}()

      for item in info.values()  输出value

      for k,v in info.items()  输出key和value

    ——while循环不太好用,key不是常规索引

  方法

    - fromkeys

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 v=dict.fromkeys(['k1',123,'999'])
4 v1=dict.fromkeys(['k1',123,'999'],123)
5 print(v,v1)

    输出

  ·    {'k1': None, 123: None, '999': None} {'k1': 123, 123: 123, '999': 123}

    - get

1 ...
2 dic={'k1':'v1'}
3 v=dic.get('k1')
4 print(v)
5 v=dic.get('kk1')
6 print(v)
7 v=dic.get('kk1',111)    #第一个数是想获取的key,
8 print(v)                #如果不存在结果为第二个值,
9                         #如果存在则获取其对应value

    输出

      v1

      None

      111

    - pop(如果要删除的键值对不存在,dic.pop(key,default)返回default的值); - popitem(随机删除一个键值对,dic.popitem())

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v=dic.pop('k1')
4 print(dic,v)

    输出

      {'k2': 'v2'} v1

    - setdefault(设置值,如果已经存在则不设置,获取当前key对应的value;不存在,设置,获取当前key对应的value)

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v=dic.setdefault('k1','123')
4 print(dic,v)
5 dic={'k1':'v1','k2':'v2'}
6 v=dic.setdefault('k111','123')
7 print(dic,v)

    输出

      {'k1': 'v1', 'k2': 'v2'} v1

      {'k1': 'v1', 'k2': 'v2', 'k111': '123'} 123

    - update

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 dic.update({'k1':'111','k3':123})
4 print(dic)
#另一种写法:dic.update(k1=123,k3=345,k5='asdf')
  输出{'k1': 123, 'k5':'asdf','k2': 'v2', 'k3': 345}

    输出

      {'k1': '111', 'k2': 'v2', 'k3': 123}

整理

  一、数字

    int()

  二、字符串

    replace / find / join / strip / startswith / split / upper / lower / format

    **kwargs 代表 可以传 key=value 或者 传字典 **{}

1 ...
2 template='I am {name},age:{age}'
3 v=template.format(name='alex',age=19)
4 #v=template.format(**{'name':'alex','age':19})  和上面的一样效果
5 print(v)

    输出

      I am alex,age:19

  三、列表

    append / extend / insert

    索引、切片、循环

  四、元组

    忽略

    索引、切片、循环  以及元素不能被修改

  五、字典

    get / update / keys / values / items

    for,索引

    列表元组字符串字典可做in操作

 

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v='k1' in dic
4 print(v)

 

    输出

      True

 

  六、布尔值

    本身内存里就是0或1

    bool(...)

 

    None '' 0 {} [] () 都是假的

      

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:网络并发编程总结

下一篇:Python:正则表达式 re 模块