Python列表,元组,字典,集合详细操作

菜鸟学Python第五天

数据类型常用操作及内置方法

列表(list)

======================================基本使用======================================

1. 用途

   用来存取多个同属性的值，用索引对应值，索引反映的是位置

2. 定义方式

   在[]内用逗号分隔开多个任意类型的值

   l = [1, 2.2, 'str', 'list', '...']  # l= list([1, 2.2, 'str', 'list', '...'])

   • 类型转换

     list可以将str、list、dict、tuple等可以被for循环循环的类型转换为列表。

     注：list只可以将dict的key遍历出来

     d = {'name': 'Jason', 'age': 23, 'weight': 78, 'height': 183}
     L = list(d)
     print(L)
     ​
     ['name', 'age', 'weight', 'height']

1. 常用操作+内置的方法

   • 优先掌握的操作

     1. 按索引取值：可以正向存取、也可以反向存取

        names = ['james', 'curry', 'paul', 'rose']
        print(names[3])  # 正向取值
        print(names[-3])  # 反向取值
        names[1] = 'irving'  # 按索引更改列表元素
        print(names)
        ​
        rose
        curry
        ['james', 'irving', 'paul', 'rose']
        ​

        # 注意：当索引超出范围时，按索引更改列表元素则会报错

     2. 切片(顾头不顾尾，步长)

        names = ['james', 'curry', 'paul', 'rose']
        print(names[1:4])
        ​
        ['curry', 'paul', 'rose']

     3. 长度list.len()：统计列表元素个数

        names = ['james', 'curry', 'paul', 'rose']
        print(len(names))
        ​
        4

     4. 成员运算in 、 not in：判断字符是否在列表内

     5. list.append() & list.insert() : 追加&插入

        names = ['james', 'curry', 'paul', 'rose']
        names.append('ivring')
        print(names)
        ​
        ['james', 'curry', 'paul', 'rose', 'ivring']
        -----------------------------------------------------------
        names = ['james', 'curry', 'paul', 'rose']
        names.insert(1,'ivring')
        print(names)
        ​
        ['james', 'ivring', 'curry', 'paul', 'rose']

        注：append的只能从列表的末尾进行添加，insert可以在设定索引位置的前面添加，不设置索引时默认添加在开头

     6. del list[索引]、list.remove(object)、list.pop(索引)：删除

        del、remove、 pop的区别

        1. del是通用的删除方式，并不为list特有

        2. remove是按照list内的成员进行删除，而del、pop是按照索引进行删除操作。。

        3. del、remove删除后没有返回值，pop则返回删除的那个成员

        names = ['james', 'curry', 'paul', 'rose']
        del names[3] # 删除'rose'
        print(names.remove('paul'))  # 删除‘paul’并打印返回值
        print(names.pop(1))  # 删除'curry'并打印返回值
        print(names)  #打印最终列表
        ​
        None   # remove返回值为空
        curry  # pop返回值为‘curry’
        ['james']  # 最终列表

     7. 循环

        for循环

        names = ['james', 'curry', 'paul', 'rose']
        for i in names:
            print(i)

   • 需要掌握内容

     1. list.count(object):统计列表中某元素的个数

        names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']
        print(names.count('rose'))
        ​
        4

     2. list.extend(iterable):将另一列表内元素添加到原列表中，并赋值给原列表

        names = ['james', 'curry', 'paul', 'rose']
        # print(names.count('rose'))
        names1 = ['love', 'Hardon']
        names.extend(names1)  # 将names1添加到names后面并赋值给names，此操作无返回值
        print(names)
        ​
        ['james', 'curry', 'paul', 'rose', 'love', 'Hardon']

     3. list.index(iterable):从左到右查找列表中某元素第一次出现的位置

        names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']
        print(names.index('rose'))
        ​
        3

     4. list.reverse()：将list翻转，并赋值给原列表

        names = ['james', 'curry', 'paul', 'rose']
        names.reverse()  # 翻转，此操作无返回值
        print(names)
        ​
        ['rose', 'paul', 'curry', 'james']

     5. list.sort()：排序（默认从小到大，列表内必须为同一可比较类型）

        names = ['james', 'curry', 'paul', 'rose']
        names.sort()  # 排序操作，无返回值
        print(names)
        ​
        ['curry', 'james', 'paul', 'rose']

======================================该类型总结====================================

存多个值

有序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

元组(tuple)

======================================基本使用======================================

1. 用途

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

2. 定义方式

   在()内用逗号分隔开多个任意类型的元素（逗号才是关键）

   t = (1, 2.2, 'aa')  # t = tuple()
   print(type(t))
   ​
   <class 'tuple'>

   类型转换：

   t1=tuple('hello')
   t2=tuple([1,2,3])
   print(t1)
   print(t2)
   ​
   ('h', 'e', 'l', 'l', 'o')
   (1, 2, 3)

1. 常用操作+内置的方法

   • 优先掌握操作：

   1. 按照索引取值

   2. 切片

   3. 长度

   4. 成员运算

   5. 循环

      t = (1, 2, 3, 4, 5)
      print(t[3])  # 索引取值
      print(t[1: 3])  # 切片操作
      print(len(t))  # 长度计算
      print(2 in t)  # 成员运算
      ​
      4
      (2, 3)
      5
      True

• 需要掌握操作：

  1. tuple.index(object):从左到右查找某元素在元组中第一次出现的位置

  2. tuple.count(object):统计元组中某元素的个数

  t = (1, 2, 3, 3, 4, 5)
  print(t.index(2))
  print(t.count(3))
  ​
  1
  2

======================================该类型总结====================================

存多个值

有序

不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

字典(dict)

======================================基本使用======================================

1. 用途

   记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性功能

2. 定义方式

   在{}内用逗号分隔开多个元素，每个元素都是key：value的形式，其中key是不可变类型，通常是字符串类型，而value可以是任意类型。

    s = {'name':'James','age':'','height':'203 cm', 'T_tpye':'all_round'}
    #  s = dict({'name':'James','age':'34','height':'203 cm', 'T_tpye':'all_round'})

   类型转换：加深理解

   #  第一种
   d=dict(x=1,y=2,z=3)
   print(d)
   ​
   {'x': 1, 'y': 2, 'z': 3}
   #  第二种
   items = [('name', 'egon'), ('age', 18), ('gender',  'male')]
   d = dict(items)
   print(d)
   ​
   {'name': 'egon', 'age': 18, 'gender': 'male'}

3. 常用操作+内置的方法

   • 优先掌握

     1. 按key存取值：可存可取

        key存在则为赋值操作，key不存在则添加字典key：value

        msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
        msg['name'] = 'Lebron'  # 修改key对应的value
        msg['team'] = 'lakers'  # 添加字典key：value
        print(msg)
        ​
        {'name': 'Lebron', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round', 'team': 'lakers'}

        dict['key']:没有则报错

        dict.get(key):没有报none

        msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
        print(dsg['team'])  # key 不存在字典中，会报错
        print(msg.get('team'))   #key 不在字典中返回None
        ​
        KeyError: 'team'
        None

     2. 长度len()：统计字典中键值对的个数

     3. 成员运算in 或者not in（以字典的key为准）

     4. pop 、popitem(随机删)：删除

        使用方法同字典pop，并返回删除key

     5. 键keys()，值values()，键值对items()

        >>> msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
        >>> msg.keys()
        dict_keys(['name', 'age', 'height', 'T_tpye'])
        >>> msg.values()
        dict_values(['James', '', '203 cm', 'all_round'])
        >>> msg.items()
        dict_items([('name', 'James'), ('age', ''), ('height', '203 cm'), ('T_tpye', 'all_round')])

     6. 循环

        msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
        for k, v in msg.items():  # k,v=('name', 'egon')
            print(k, v)
        ​
        name James
        age 34
        height 203 cm
        T_tpye all_round

   • 需要掌握

     1. dict.update():函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

        msg = {'name': 'James', 'age': ''}
        msg1 = {'height': '203 cm', 'T_tpye': 'all_round'}
        msg.update(msg1)  # 更新操作，无返回值
        print(msg)
        ​
        {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}

     2. dict.setdefault(key,value)：当key存在时不改原值，并返回原值，当key不存在时增加新value

        msg = {'name': 'James', 'age': ''}
        print(msg.setdefault('age', ''))
        print(msg.setdefault('height', ''))
        print(msg)
        ​
        34
        203
        {'name': 'James', 'age': '', 'height': ''}

        注：当返回的value不是输入的新value时，标明字典中包含该key，当返回value是输入的心value时则表明之前字典中不包含该key，可以用来判断字典中是否含有某元素。

======================================该类型总结==================================== 存多个值 无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

集合(set)

======================================基本使用======================================

1. 用途

   • 关系运算

   • 去重

2. 定义方式

   在{}内用逗号分隔开多个元素

   S = {1,2,3,4,5}  # S = set({1,2,3,4,5})

   元素的特点：

   • 集合内元素必须是不可变类型

   • 集合内元素无序

   • 集合内元素不可重复

　　　　类型转换：

　　　　　　set可以将能用for循环循环的数据类型转换为集合

　　  3. 常用操作+内置的方法

1. • 优先掌握

     1. 长度len():返回集合内元素个数

     2. 成员运算in、not in：判断集合中是否存在某元素

     3. 并（合）集set.union(set1, set2...)，快捷键：|

     4. 交集set.intersection(set1, set2 ... )，快捷键：&

     5. 差集set.difference(set)，快捷键：-

     6. 对称差集set.symmetric_difference(set)，快捷键：^

     a_club = {'jason', 'tony', 'jay', 'allen'}
     b_club = {'rose', 'alice', 'allen', 'tony'}
     print(a_club | b_club)  # 并集
     print(a_club & b_club)  # 交集
     print(a_club - b_club)  # 差集，只在a_club中的成员
     print(b_club - a_club)  # 差集，只在b_club中的成员
     print(a_club ^ b_club)  # 对称差集 没有同时在两个集合的成员
     ​
     {'allen', 'jason', 'rose', 'jay', 'alice', 'tony'}
     {'allen', 'tony'}
     {'jason', 'jay'}
     {'alice', 'rose'}
     {'jason', 'rose', 'jay', 'alice'}

     1. ==：集合中元素完全一致

     2. 父集和子集>=、<=：描述的是一种包含和被包含的关系

        s1 = {1, 2, 3}
        s2 = {1, 2, 3}
        s3 = {1, 2, 3, 4}
        print(s1 == s2)
        print(s3 >= s1)
        print(s1 <= s3)
        ​
        ​
        True
        True
        True

   • 需要掌握

     1. update();更新

        s1={1,2,3}
        s1.update({3,4,5,6})
        print(s1)
        ​
        {1, 2, 3, 4, 5, 6}

     2. pop():随机删，并返回删除元素

        s1={1,'aa','bb',3}
        print(s1.pop())
        ​
        1

     3. remove()：按元素删，当元素不存在时报错

     4. discard()：按元素删，当元素不存在时不报错

        # remove
        s1 = {1,'aa','bb',3}
        res = s1.remove('bbbbbb')
        print(s1)  # 不存在即报错
        print(res)  # 打印返回值（无返回值）
        ​
        KeyError:'bbbbbb'
        ​
        # discard
        s1 = {1,'aa','bb',3}
        res = s1.diiscard('bbbbbb')
        print(s1)  # 不存在不报错
        print(res)  # 没有返回值
        ​
        {3, 1, 'aa', 'bb'}
        None

     5. add()：添加

        s1 = {1,'aa','bb',3}
        s1.add(4)
        print(s1)
        ​
        {1, 3, 'aa', 4, 'bb'}

        集合的去重的局限性：

        1. 只能针对不可变类型*

        2. 不能保证原来的顺序

======================================该类型总结====================================

存多个值

无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）