• 列表元组和字典的内置方法


    一丶列表

      1、作用:按位置存放多个值
      2、定义
        l=[1,2.2,'a'] # l=list([1,2.2,'a'])
        print(type(l))

      3、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
        res=list('hello')
        print(res)

        res=list({'k1':111,'k2':222,'k3':3333})
        print(res)

      4.优先掌握的内置方法

      4.1按索引取改值

    l=['as', 111, 'sd']
    # 正向取
    print(l[0])
    # 反向取
    print(l[-1])
    # 改值
    l[1] = 222
    print(l)
    
    # 无论是取还是该索引不存在就报错
    l[3] = 'sss'
    print(l)

      4.2切片(顾头不顾尾,步长)

    l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
    print(l[0:3])
    print(l[0:5:2])
    
    # 切片等同于拷贝行为,而且相当于浅copy
    new_l=l[:] 
    print(id(l),id(new_l))
    
    l[-1][0]=1111111
    print(l)
    print(new_l)
    
    #倒叙输出
    print(l[::-1])

      4.3长度

        print(len([1, 2, 3]))

      4.4成员运算in和not in

        print('aaa' in ['aaa', 1, 2])

        print(l not in ['aaa',1,2])

      4.5添加值的几种方法

    # append列表尾部追加元素
    l=['as', 111, 'sd']
    l.append(555)
    print(l)
    
    # insert在指定位置插入元素
    l=['as', 111, 'sd']
    l.insert(1,'asd') #1是索引的位置
    print(l)
    
    # extend一次性在列表尾部添加值
    new_l = [1,2,3]
    l=['as', 111, 'sd']
    l.extend(new_l)
    print(l)

      4.6删除的几种方式

    # del 通用的删除方法,只是单纯的删除、没有返回值
    l=['as', 111, 'sd']
    del l[1]
    print(l)
    # res = del l[1]  del没有返回值 报错
    
    # pop()根据索引删除,会返回删除的值
    l=['as', 111, 'sd']
    l.pop() #不指定索引默认删除最后一个
    print(l)
    res = l.pop(1) #返回被删除的元素
    print(res)
    
    # remove()根据元素删除,返回None
    l=['as', 111, 'sd']
    res = l.remove(111)#从左往右查找第一个括号内要删除的元素
    print(l)
    print(res)

      需要掌握的操作

    l = [1, 'aaa', 'bbb','aaa','aaa']
    
    # 1.count 计算该元素在列表中出现的次数
    print(l.count('aaa'))
    
    # 2.index 找出该元素在列表中出现的第一个索引位置
    print(l.index('aaa'))
    print(l.index('aaaaaaaaa')) # 找不到报错
    
    # 3.clear清空列表
    l.clear()
    print(l)
    
    # 4.reverse()颠倒列表内元素顺序
    l=[11,22,33,44]
    l.reverse()
    print(l)
    
    # 5.sort()给列表内所有元素排序
    # 排序时列表之间元素必须是相同数据类型,不可混搭,否则报错  默认从小到大排序
    l = [22,44,98,46,24]
    l.sort()
    print(l)
    l.sort(reverse=True)  #reverse从大到小排,设置为降序 默认是False
    print(l)
    View Code

      补充

    # 1、队列:FIFO,先进先出
    # l=[]
    # 入队操作
    # l.append('first')
    # l.append('second')
    # l.append('third')
    #
    # print(l)
    # # 出队操作
    # print(l.pop(0))
    # print(l.pop(0))
    # print(l.pop(0))
    
    # 2、堆栈:LIFO,后进先出
    l=[]
    # 入栈操作
    l.append('first')
    l.append('second')
    l.append('third')
    
    print(l)
    # 出栈操作
    print(l.pop())
    print(l.pop())
    print(l.pop())
    View Code

       

    二丶元组

      元组就是"一个不可变的列表"

      1.作用:按照索引/位置存放多个值,只用于读不用于改

      2.定义:()内用逗号分隔开多个任意类型的元素

        t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
        print(t,type(t))

        t=(10,) # 强调:如果元组内只有一个值,则必须加一个逗号,否则()就只是包含的意思而非定义元组
        print(t,type(t))
        ps:元组一旦更改里面的元素就会报错 但是当元组内的元素存在可变类型时,不更改该元素的容器内存地址,而是更改容器里面元素的内存地址则可以成功

    t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
    print(t,type(t))
    
    t=(10,) # 强调:如果元组内只有一个值,则必须加一个逗号,否则()就只是包含的意思而非定义元组
    print(t,type(t))
    
    ps:元组一旦更改里面的元素就会报错 但是当元组内的元素存在可变类型时,不更改该元素的容器内存地址,而是更改容器里面元素的内存地址则可以成功
    View Code

      3.类型转换
        print(tuple('hello'))
        print(tuple([1,2,3]))
        print(tuple({'a1':111,'a2':333}))

      

      4.内置方法

    t = (11,'5j',55,'sdasd')
    #1、按索引取值(正向取+反向取):只能取
    print(t[0])
    print(t[-1])
    
    #2、切片(顾头不顾尾,步长)
    print(t[0:3])
    print(t[::-1])
    
    #3、长度len
    print(len(t))
    
    #4、成员运算in和not in
    print('aa' in t)
    print(11 not in t)
    
    #5、index和字符串列表相同
    print(t.index(11))
    print(t.index(1111111111))
    
    #6、count()和字符串列表相同
    print(11)

      

    三丶字典

      1、作用:用来存储多种属性的值

      2、定义:{}内用逗号分隔开多个key:value,其中value可以使任意类型,但是key必须是不可变类型,且不能重复

        造字典的几种方式
        方式一:
          d={'k1':111,(1,2,3):222} # d={}默认定义出来的是空字典
          print(d,type(d))
        方式二:
          d=dict(x=1,y=2,z=3)
          print(d,type(d))

      3、数据类型转换
          info=[
            ['name','jun'],
            ('age',18),
            ['gender','male']
          ]
          d={}
          for k,v in info: # k,v=['name','egon'],
          d[k]=v
          print(d)

        方式三:
          res=dict(info) # 一行代码搞定上述for循环的工作
          print(res)
        方式四:
          keys=['name','age','gender']
          d={}
          for k in keys:
            d[k]=None
          print(d)
          d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
          print(d)   

      4、字典的内置方法

        优先掌握  

    dic = {
         'name': 'xxx',
         'age': 18,
         'hobbies': ['play game', 'basketball']
    }
    # 1、按key存取值:可存可取
    # 1.1、取
    dic['name']
    dic['hobbies'][1]
    # 1.2、对于赋值操作,如果key原先不存在于字典,则会新增key:value
    dic['phone'] = '51561651'
    # 1.3、对于赋值操作,如果key原先存在于字典,则会修改对应value的值
    dic['name'] = 'tony'
    
    # 2、长度len
    len(dic)
    
    # 3、成员运算in和not in
    print('name' in dic)  # 判断某个值是否是字典的key
    
    # 4、删除
    # 4.1、通用删除del 输入的是key
    del dict['name']
    
    # 4.2、pop删除:根据key删除元素,返回删除key对应的那个value值
    res=dict.pop('age')
    print(dict,res)
    
    # 4.3、popitem删除:随机删除,返回元组(删除的key,删除的value)
    res=dict.popitem()
    print(dict,res)
    
    # 5、键keys(),值values(),键值对items()
    dic = {'k1': 18, 'k2': [11,22], 'k3': 'sdf'}
    
    # 获取字典所有的key
    dic.keys()
    ['k1','k2','k3']
    # 获取字典所有的value
    dic.values()
    [18,[11,22],'sdf']
    # 获取字典所有的键值对
    dic.items()
    [('k1', 18), ('k2', [11,22]), ('k3', 'sdf')]
    dict(d.items())
    {'k1': 18, 'k2': [11,22], 'k3': 'sdf'}
    
    #6、for循环
    d={'k1':111,'k2':2222,'k3':666}
    # 默认遍历字典的key
    for k in d:
        print(k)
    
    # 遍历字典的key
    for k in d.keys():
        print(k)
    
    # 遍历字典的value
    for v in d.values():
        print(v)
    
    # 遍历字典的键值对
    for k,v in d.items():
        print(k,v)
    View Code

         需要掌握

    d={'k1':111}
    #1、d.clear()清空字典
    
    #2、d.update()用新字典更新旧字典,有则修改,无则添加
    d.update({'k2':222,'k3':333,'k1':11111111})
    print(d)
    
    #3、d.get() :根据key取值,容错性好
    print(d['k2'])  # key不存在则报错
    print(d.get('k1')) # 111
    print(d.get('k2')) # key不存在不报错,返回None
    
    #4、d.setdefault()
    # 4.1 如果key有则不添加,返回字典中key对应的值
    info={'name':'egon'}
    res=info.setdefault('name','egon')
    print(info,res)
    
    # 4.2 如果key没有则添加,返回字典中key对应的值
    res=info.setdefault('age','18')
    print(info,res)
    View Code
  • 相关阅读:
    第8章 传输层(4)_可靠传输
    第8章 传输层(3)_TCP协议
    第8章 传输层(2)_UDP协议
    第8章 传输层(1)_TCP/UDP协议的应用场景
    【Sqlsever系列】日期和时间
    【SqlServer系列】聚合函数
    【Sqlserver系列】CAST和CONVERT
    【SqlServer系列】AS的用法
    【博客目录】SqlServer篇
    【SqlServer系列】集合运算
  • 原文地址:https://www.cnblogs.com/bk134/p/12461687.html
Copyright © 2020-2023  润新知