（四） Python的特征数据类型(列表、元祖、字典、集合)

(一)、主要内容

• 1.1、列表
• 1.2、元祖
• 1.3、字典

• 1.4、集合

  
  列表 、字典、元祖、集合

(二)、列表

• 2.1、Python 提供了列表数据类型来存储由多个值组成的序列。在列表中，只可以是任何类型，称为元素或项。Python 列表是有序的。任意的成员都可以通过下标来进行访问。话句话说，Python 对列表数据中的所有成员按序编号，称为索引，从而实现对成员变量的访问和修改。

• 2.2、列表的创建

  • 用逗号分隔的不同的数据项使用方括号“[ ]”括起来即可创建列表。例如：

    >>>  list1 = ["a","b","c","d"]
    >>>  list2 = [1,2,3,4]
    >>>  list3 = ['one','two','three','four']
    

  • 列表允许嵌套，也就是说列表中的成员同样可以是列表，例如：

    >>> list4 = [1,'str',['name','goodbye']]
    >>> list5 = []  #定义一个空的 list
    

• 2.3、列表的基本操作

  下面以 list1 = ['one','two','three','four']和list2 = ['1','2','3','4']为例展示列表的基本操作

  列表的基本操作	列表的基本操作
  操作	含义
  list1[i]	索引(求列表list1位置索引为i的元素)
  list1[i:j:k]	切片求list1的位置索引为i~j~k的子列表
  list1 + list2	将 list1与list2连接
  list1 * 2 或者 2*list	将 list复制2次
  len(list1)	求list1的长度
  for <var> in list	对list 元素循环
  <expr> in list1	查找 list 是否存在<expr>，返回的值为布尔类型
  del list1	删除列表
  del list[2]	删除列表中位置索引为i的元素
  max(list1)	返回列表中最大的值
  min(list1)	返回列表中最小的值

  • 使用举例：

    • 列表切片的形式为list1[i:j:k]，其中 i 为 起始位置索引(包含i),默认为0；j为终止位置索引（不会包含j）,默认为序列尾；k为切片间隔，默认为1，i,j,k的默认值均可省略，只保留冒号。

      >>> list = [1,2,3,3,4,5,6,7,8]
      >>> print(list[1:5]) # 取区间 左开右闭
      [2, 3, 4, 5]
      >>> print(list[:5]) # 可以省略第1位
      [1, 2, 3, 4, 5]
      >>> print(list[3:]) # 可以省略第2位 取值到最后
      [4, 5, 6, 7]
      >>> print(list[2:-1]) #  从前是从0~n-1开始，后面是从-1~-n
      [3, 4, 5, 6]
      >>> print(list[:])   #从头取到尾
      [1, 2, 3, 4, 5, 6, 7] 
      >>> print(list[::2])  # 步长为 2
      [1, 3, 5, 7]
      >>> print(list[0:3:2])
      [1, 3]
      >>> print(list[7:1:-2])  # 注意步长为负值，就从7到1倒叙，步长为 2
      [7, 5, 3]
      

      注意：列表与字符串的重要区别是：列表中的元素可以被更改，因此可以使用赋值语句改变列表中任意元素的值。例如：

       >>> list = [1,2,3,4,5,6]
       >>> list[3]
       4
       >>> list[3] = "JK"
       >>> print(list)
       [1, 2, 3, 'JK', 5, 6]
       >>> list[1:3] = ["A","B"]
       >>> print(list)
       [1, 'A', 'B', 'JK', 5, 6]
      

      从上面可以看出Python列表是非常灵活的，上面还展示了利用切片一次性修改了列表中的一连串元素。

  • 使用运算符“*”和“+”可分别对列表中的元素进行复制或拼接，例如：

    >>> list = [0]*6
    >>> print(list)
    [1, 1, 1, 1, 1, 1]
    >>> print(2*['a']+['c']*3)
    ['a', 'a', 'c', 'c', 'c']
    

• 2.4、更多列表操作

  • list.append(x): 在列表的末尾添加元素x,等价于a(len(a):) = [x]。
  • list.extend(L): 在列表末尾加入指定列表L中所有的元素，等价于a[len(a):] = L 或 a+L： 把一个列表合并到另外一个列表里面
  • list.insert(i,X): 在给定的位置添加元素，也就是在位置i插入x,其余元素依次向后退。
  • list.remove(x): 移除列表中值为 x 的元素，如果没有x就会报错。
  • list.pop([i]):删除列表中指定位置i的元素，并返回该元素。若不指定索引值（list.pop）,则移除并返回列表中的最后一个元素。
  • list.clear(): 删除列表中所有的元素，等价于：del a[:]
  • list.index(x):返回列表中值为x的位置索引，若不存在就会出错。
  • list.count(x):返回x在列表中出现的次数。
  • list.sort(key=None,reverse=False):对列表中的元素排序，默认为升序。
  • list.reverse():将列表中的元素顺序反转。
  • list.copy(): 返回列表的浅复制(返回的也是列表)，等价于 a[:]
  • 注意：上面的 insert(),list.remove(),sort()方法仅仅是修改列表而不返回修改的结果，即返回值为默认的值 None。

• 2.5、删除列表中的元素

  • Python提供的del操作可以通过元素的位置索引将其从列表中删除。注意：del不是一个列表对象的操作方法，而是可用于列表元素的Python内置操作命令。del与pop()不同，pop()会返回被删除的元素。此外，del还可以删除子列表或整个列表变量。

  >>> a = [-1,1,44.5,456,90,5,9]
  >>> del a[0]
  [1,44.5,456,90,5,9]
  >>> del a[2:4]
  [1, 44.5, 5, 9]
  >>> del a[:]
  []
  

  注意：del a 将会删除整个列表变量。删除后，若想访问该变量，将会出现错误。

• 2.6、列表解析
  列表解析也称为“列表推导式”或“列表的内涵”是Python语言有力的语法之一。常用语从集合对象中有选择地获取并计算元素。虽然在多数情况下可以使用for、if等语句组和完成同样的任务，但列表解析书写的代码更简洁。例如：

  >>>  squares = []
  >>> for x in range(10):
               squares.append(x**2)
  >>> print(squares)
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  

  列表解析实现上面的功能如下：

  >>> squares = [x**2 for x in range(10)]
  >>> print(squares)
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  

(三)、元组

元组(tuple)是Python中一种内置的存储有序数据的结构。与列表类似，可以存储不同类型的数据。但是元组是不可以改变的，创建后不能再做任何的修改。元组的主要作用是作为参数传递给函数调用或者从函数调用那里获得参数时，保护其内容不被外部接口修改。

• 3.1、创建元组 : 如果用逗号分割一些值，那么将自动创建元组，元组通常用圆括号()括起来，换句话说，如果以逗号隔开，则默认为元组。如下：

  >>> 4,5,6
  (4, 5, 6)
  >>> t = "a","b","c","d" # 元组打包（tuple packing）
  >>> t
  ('a', 'b', 'c', 'd')
  

  元组允许嵌套

  >>> t = "a","b","c","d" # 元组打包（tuple packing）
  >>> u = t,(1,2,3,4,5)   # 元组允许嵌套
  >>>  u 
  (('a', 'b', 'c', 'd'), (1, 2, 3, 4, 5))
  

  一个值元组必须加个逗号，例如：

  >>> 43,
  (43,)
  >>> tuple = 'hello', # 加逗号后，tuple实际上是包含一个元素'hello'的元组
  >>> len(tuple)
  1
  >>> tuple
  >>> ('hello',)
  

• 3.2、元组的基本操作 :

  元组的基本操作与列表类似

  元组的基本操作	元组的基本操作
  操作	含义
  tup[i]	求索引为i的元素
  tup[i:j:k]	切片求tup的位置索引为i~j~k的子元组
  tup1 + tup2	将 tup1与tup2连接
  tup * 2 或者 2* tup	将 tup复制2次
  len(tup)	求tup的长度
  for <var> in tup	对tup 元素循环
  <expr> in tup	查找 tup 是否存在<expr>，返回的值为布尔类型
  del tup	删除元组
  max(tup)	返回元组中最大的值
  min(tup)	返回元组中最小的值

  由于元组不能修改：

  • 不能向元组增加元素，元组没有append或extend方法
  • 不能从元组删除元素，元组没有remove或pop方法
  • 不能在元祖中查找元素，元组没有index方法

• 3.3、元组与列表的相互转换

  • 元组与列表可以相互转换，Python 内置的tuple()函数接收一个列表，可返回一个包含相同元素的元组。而 list() 函数接收一个元组返回一个列表。从元组与列表的性质来看，tuple()相当于冻结一个列表，而list()相当于冻结一个元组。例如：

    >>> list1 = [1,2,3]
    >>> tuple1 = tuple(list1)
    >>> print(tuple1)
    (1, 2, 3)
    >>> list2 = list(tuple1)
    >>> print(list2)
    [1, 2, 3]
    

  • 分别从两个列表中取不相同的两个元素组合成元组类型元素的新列表。

    >>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
    

• 3.4、元组解包

  • 声明 a = "a","b","c","d" 被称为元组打包。其实也可以进行反向操作：元组解包，即将等号右侧的元素按顺序依次赋给等号左边的变量。例如：

    >>> t = (1,2,3)
    >>> a,b,c = t
    >>> a
    1
    >>> b
    2
    >>> c
    3
    

    • 元组相对于列表的优势：首先比列表的运算速度快，如果定义了一个常量集对象，并且需要在程序中不断地遍历它，则建议使用元组而不是列表。其次，使用元组相当于为不需要修改的数据进行了“写保护” ，使得数据更安全。

(四)、字典

Python语言的字典就是一种映射。

• 4.1、创建字典

  • 字典包含了一个索引的集合，称为键和值的集合。一一对应，这种关系称为键值对或称为项。简单地说，字典就是用花括号包裹的键值对的集合。每个键值对用冒号“:”分割，每对之间用逗号“,”分割，格式如下：

    dict1 = {'key1':'1','key2':'2'} 
    dict2 = {} # 创建空字典
    

    键必须是唯一的，不能重复，还必须是不可变的数据类型，例如：字符串、数字、或元组。值可以是任何数据类型。

  • 可以通过dict(构造器)来创建字典，构造器的入参为列表(或元组),列表（或元组）内部是一系列包含两个值的列表或元组。例如：下面语句的入参为列表，列表内部为元组。

    >>> dict([('sape',3429),('guido',2890),('jack','190)])
    {'sape': 3429, 'guido': 2890, 'jack': 190}
    

  • 可以通过关键字的形式创建字典，但键只能为字符串型，并且字符串不用加引号，例如：

    >>> dict(name= 'JK',age= '40')
    {'name': 'JK', 'age': '40'}
    

• 4.2、访问字典中的值

  • 根据键取值：如果键不存在就会引发 KeyError

    >>>  dict = {'name':'jack','age':'20'} 
    >>> print(dict['name'])
    jack
    

  • 检查字典中是否含有键key，可以使用 in：

    >>> d = ['name','alice']
    >>> 'name' in d
    True
    

• 4.3、更新字典

  • 可以添加、删除、更新字典中的一个键值对，例如：

    >>> dict = {'a':1,'b':2,'c':3}
    >>> dict['d'] = 4  # 添加新键值对
    >>> dict
    {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    >>> dict['a'] = 5   # 更新键 a 的值
    >>> dict
    {'a': 5, 'b': 2, 'c': 3, 'd': 4}
    >>> del dict['a']   # 删除键值对 {'a': 5}
    >>> dict
    {'b': 2, 'c': 3, 'd': 4}
    

• 4.4、字典的操作

  • 字典提供了一些内置方法来访问、添加、删除其中的键、值或键值对。方法如下：

  字典对象的方法	含义
  dict.keys()	返回包含字典所有key的列表
  dict.values	返回包含字典所有.value的列表
  dict.items()	返回包含所有(键，值)项的列表
  dict.clear()	删除字典中所有的项或元素，无返回值
  dict.copy()	返回字典浅复制副本
  dict.get(key,default=None)	返回字典中key对应的值，若key不存在，则返回default的值（default默认为None）
  dict.pop(key[,default])	若字典中存在key,则删除并返回key对应的value;如果key不存在，且没有给出default值，则引发KeyRrror异常
  dict.setdefault(key,default=None)	若字典中不存在key,则由dict[key]=default为其赋值
  dict.update(dict2)	将字典dict2中的键值对添加到字典dict中

  • 返回字典所有的键、值和项

    dict.keys()、dict.values()、dict.items() 这三个方法分别返回包含字典中每项的键、值和项（键，值）的列表，例如：

    >>> dict={'a':'1','b':'2','c':'3','d':'4'}
    >>> dict.keys()
    dict_keys(['a', 'b', 'c', 'd'])
    >>> dict.items()
    dict_items([('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')])
    >>> dict.values()
    dict_values(['1', '2', '3', '4'])
    

    要遍历一个字典，只需要遍历它的键即可

    dict = {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
    for key in dict:
           print('key = %s value = %s' % (key,dict[key]))
    key = a value = 1
    key = b value = 2
    key = c value = 3
    key = d value = 4
    

  • 字典清空
    用dict.clear()可清空原始字典中所有的元素。有趣的是，对于两个相关联的字典对象x,y,若将x赋值为空子典，将不对y产生影响；而用clear方法清空x,也将清空字典y中所有的元素。例如：

    • 赋值为空子典

      >>> x = {}
      >>> y = x
      >>> x['key'] = 'value'
      >>> y
      {'key':'value'}
      >>> x = {}
      >>> y
      {'key':'value'}
      

    • clear方法清空

      >>> x = {}
      >>> y = x
      >>> x['key'] = 'value'
      >>> y
      {'key':'value'}
      >>> x.clear()
      >>> y
      {}
      

  • 字典的浅复制
    dict.copy()方法返回一个具有相同键值对的新字典。但在原始字典中，如果修改了某个值，副本字典也会被修改，故称为浅复制，仅仅复制字典对象直接包含的引用，不复制嵌套的对象。如果要避免该问题，可以使用深复制(不仅仅复制字典对象，还要复制这个字典对象所引用的对象)方法：dict.deepcopy()。例如：

    • copy 浅复制 复制时只会复制父对象，而不会复制对象的内部的子对象。

    • deepcopy 深复制 复制对象及其子对象

      >>> dict = {'a': '1', 'b': '2', 'c': '3'}
      >>> y = dict.copy()
      >>> z = dict.deepcopy()
      >>> print(y)
      {'a': '1', 'b': '2', 'c': '3'}
      >>> print(z)
      {'a': '1', 'b': '2', 'c': '3'}
      

  • 用键查值

    dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回None值。还可以自定义默认值，替换None值。例如：

    >>> dict = {}
    >>> print(dict.get('name'))
    None
    >>> dict['name'] = "JK"
    >>> print(dict.get('name'))
    JK
    

  • 移除键值对

    pop(key[,default])：方法用来获得并返回对应给定键的值，然后将这个键值对从字典中移除。例如：

    >>> dict = {'a': '1', 'b': '2', 'c': '3'}
    >>> print(dict.pop('a'))
    1
    >>> print(dict)
    {'b': '2', 'c': '3'}
    

  • 字典更新

    dict.update(dict2):把字典dict2的键/值对更新到dict里。也就是把一个字典合并到另外一个字典里面，若有相同的键则会进行覆盖。

    >>> dict1= {'a': '1', 'b': '2', 'c': '3'}
    >>> dict2= {'c': '10','d':'11'}
    >>> dict1.update(dict2)
    >>> print(dict1)
    {'a': '1', 'b': '2', 'c': '10', 'd': '11'}
    

  • Python没有专门的枚举分支结构，但利用字典可以实现枚举的功能，例如：输入两个数字，并输入加减乘除运算符号，输出运算的结果。若输入其他符号，则退出程序。如下：

    while True:
        a = float(input('请输入第一个数字：'))
        b = float(input('请输入第二个数字：'))
        t = input('请输入运算符号，其他符号为退出程序：')
        tup = ('+','-','*','/')
        if t not in tup:
            break
        dict = {'+':a+b,'-':a-b,'*':a*b,'/':a/b}
        print('%s %s %s = %0.1f' % (a,t,b,dict.get(t)))
    
     #  下面是我的输入
     请输入第一个数字：3
     请输入第二个数字：4
     请输入运算符号，其他符号为退出程序：*
     3.0 * 4.0 = 12.0
    

(五)、集合

集合（set）是不重复元素的无序集，它兼具了列表和字典的一些性质。集合类似字典的特点：用花括号“{}”来定义，其元素是非序列类型的数据，也就是没有序列，并且集合中的元素不可重复，也必须是不变对象，类似于字典中的键。集合的内部结构与字典很相似，区别是“只有键没有值”。另一方面，集合也具有一些列表的特点：持有一系列元素，并且可原处修改。由于集合是无序的，不记录元素位置或者插入点，因此不支持索引、切片或其他类序列的操作。

• 5.1、集合的创建

  • 直接用“{}”创建，例如：

    >>> s1 = {1,2,3,4}
    >>> s1
    {1, 2, 3, 4}
    >>> s2 = set()  # 注意创建空集合要用 set() 而非{}，若用{}，将创建空子典
    >>> s2
    set()
    >>> type(s2)
    <class 'set'>
    >>> s3 = {}
    >>> type(s3)
    <class 'dict'>
    

    说明：集合通过 “{}” 无法创建含有列表或字典元素的集合。含有元组的集合可以创建。

  • 由字符串创建：用函数 set(str) 将str中的字符拆开以形成集合。例如：里面重复的字符要只保留一个字符。

    >>> s1 = set('helloPython')
    >>> s1 
    {'h', 'e', 'l', 'n', 'y', 'o', 'P', 't'}
    

  • 由列表或元组创建：用函数set(seq)创建集合，参数可以是列表或元组。在下面例子中，调用set()并传入 list,将list 的元素作为集合的元素：例如：

    >>> s1 = set([1,'name',2,'age','hobby'])
    >>> s1
    {1, 2, 'hobby', 'age', 'name'}
    >>> s2 = set((1,2,3))
    {1, 2, 3}
    

    由于集合内部存储的元素是无序的，因此输出顺序和原列表的顺序有可能是不同的。

• 5.2、集合的修改

  修改集合的方法	含义
  set.add(x)	向集合中添加元素 x
  set.update(a_set)	使用集合 a_set 更新原集合(合并set和a_set)
  set.pop()	删除并返回集合中的任意元素
  set.remove(x)	删除集合中的元素x,如果x不存在则报错
  set.discard(x)	删除集合中的元素x,如果x不存在则什么也不做
  set.clear()	清空集合中的所有元素

• 5.3、集合的数学运算

  集合支持联合（Union）、交（Intersection）、差（Difference） 和对称差集等数学运算。

  Python符号	集合对象的方法	含义
  s1 & s2	s1.intersection(s2)	返回s1 与 s2 的交集
  s1 | s2	s1.union(s2)	返回 s1 与 s2 的并集
  s1-s2	s1.difference(s2)	返回s1 与 s2 的差集
  s1^s2	s1.symmetric_difference(s2)	返回 s1与s2的对称差
  x in s1		测试x是否是s1的成员
  x not in s1		测试 x 是否不是s1的成员
  s1 <= s2	s1.issubet(s2)	测试是否s1 是 s2 的子集
  s1 >= s2	s1.issuperset(s2)	测试是否s1 是 s2 的超集
  	s1.isdisjoint(s2)	测试s1和s2是否有交集
  s1 |= s2	s1.update(s2)	用 s2 更新 s1

  集合的使用举例：

  >>> s1 = {'a','e','i','o','u'}
  >>> s2 = {'a','b','c','d','e'}
  >>> s1 
  {'a','e','i','o','u'}
  >>> s2
  {'a','b','c','d','e'}
  >>> a1 & s2
  {'a', 'e'}
  >>> a1 | s2
  {'b', 'i', 'c', 'o', 'a', 'd', 'e', 'u'}
  >>> s3 = {'a','e'}
  >>> s3.issubset(s1)
  True
  >>> s1.issuperset(s3)
  True
  >>> s1.difference(s2)
  {'i', 'o', 'u'}
  >>> s1.symmetric_difference(s2)
  {'b', 'i', 'c', 'o', 'u', 'd'}
  >>> 'a' in s1
  True
  

  集合是可以修改的数据类型，但集合中的元素必须是不可修改的。换句话说，集合中元素只能是数值、字符串、元组之类。由于集合是可修改的，因此集合中的元素不能是集合。但是Python另外提供了frozenset()函数，来创建不可修改的集合，可作为字典的key,也可以作为其他集合的元素，例如：{frozenset({1,2,3}):'frozenset','Python':3.4},{frozenset({1,2,3}),'a'}。