列表、元组、字典、集合和固定集合

回顾

• 循环语句

  • while 语句
  • for 语句

• 循环相关的语句

  • break 语句
  • continue 语句

• range() 函数

列表 list

• 列表是一种可以存放任意数据类型的序列容器

• 列表是可迭代对象

• 创建

  L = []
  L = list()
  L = [1, 2, 3]
  L = list(range(5))
  

• 运算

  L = [1, 2, 3] + [4, 5, 6]   # 拼接
  L += [7, 8, 9]              # L.extend([7, 8, 9])  # 拆开后依次追加
  L = [1, 2] * 3
  L *= 3
  

  in / not in 运算

  if 2 in L:
      print("2 在 L 中")
  else:
      print("2 不在 L 中")
  

  索引运算

  print(L[2])
  

  切片运算

  print(L[::2])
  

• 列表的增删改查

  • 增

    L = []
    L.append(1)        # L = [1]
    L.insert(0, 100)   # L = [100, 1]
    

  • 删

    L = [1, 2, 3, 4, 5, 6]
    L.remove(3)   # L = [1, 2, 4, 5, 6]
    del L[3]      # 按位置(索引)删除
    L.clear()     # 清空
    

  • 改

    L = ['A', 2, 'C']
    L[1] = 'B'   # L = ['A', 'B', 'C']
    

  • 查

    L = ['A', 2, 'C']
    a = L[1]
    

列表的常用方法

示例:

s = [1, "二", 3]
value = s.pop(1)   # s= [1, 3]; value = '二'
>>> s = [1, 2, 3, 5]
>>> s.reverse()   # 反转
>>> s
[5, 3, 2, 1]
>>> s = [1, 2, 3, 4, 2, 2, 3, 4]
>>> s.index(3)  # 返回第一次出现的位置的索引
2
>>> s.index(3, 4)
6
>>> s.index(100)  # 触发异常，要用try 语句处理
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: 100 is not in list
>>> s.count(3)  # 在列表 s 中 找出所有值为3 的元素的个数，并返回
2
>>> s.count(2)
3
>>> L1 = [2, 4, 6, 8, 9, 1]
>>> L1.reverse()
>>> L1
[1, 9, 8, 6, 4, 2]
>>> s.sort()   # 排序，默认是升序排序
>>> s
[1, 2, 2, 2, 3, 3, 4, 4]
>>> s.sort(reverse=True)
>>> s
[4, 4, 3, 3, 2, 2, 2, 1]

• python3 中常用于序列的函数

>>> L = [1, 5, 8]
>>> len(L)
3
>>> min(L)
1
>>> max(L)
8
>>> sum(L)
14

列表解析(也叫列表推导式)

• 作用

  用简单的表达式方式来创建列表

• 语法规则

• 示例

• 练习:

元组 tuple

元组是不可改变的列表, 同 列表list 一样，元组可以存放任意类型的数据，但是，一旦创建将不可修改

• 创建元组的字面值

  t = ()         # 空元组
  t = (100,)     # 含有一个数据元素的元组
  t = 100,       # 含有一个数据元素的元组
  t = (1, 2, 3)  # 含有三个数据元素的元组
  t = 1, 2, 3    # 含有三个数据元素的元组
  

• 创建元组的函数 tuple

  t = tuple()          # t = ()
  t = tuple(range(5))  # t = (0, 1, 2, 3, 4)
  

• tuple 的运算

  >>> t = (1, 2, 3) + (4, 5, 6)
  >>> t += (7, 8, 9)
  >>> t = t * 2
  >>> t *= 2
  >>> 5 in t
  True
  >>> t[0]
  1
  >>> t[0:2]
  (1, 2)
  

  元组的方法

  运算	结果
  s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
  s.count(x)	x 在 s 中出现的总次数

for x in [1, 2, 3]:
    print(x)

for y in (1, 2, 3):
    print(y)

• 列表和元组的 + 和 += 运算

  # 列表(可变)
  >>> L1 = [1, 2, 3] + [4, 5, 6]
  >>> L2 = L1  # 两个变量同时绑定同一个列表
  >>> L2 += [7, 8, 9]
  >>> print(L1)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> print(L2)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]
  # 元组(不可变)
  >>> T1 = (1, 2, 3) + (4, 5, 6)
  >>> T2 = T1  # 两个变量同时绑定同一个元组
  >>> T2 += (7, 8, 9)
  >>> print(T1)   # (1，2, 3, 4, 5, 6)
  >>> print(T2)   # (1, 2, 3, 4, 5, 6, 7, 8, 9)
  

字典 dict

• 什么是字典

  • 字典是一种可变的容器，可以存储任意类型的数据
  • 字典的数据都是以键(key)-值(value)对的形式进行映射存储.
  • 字典的数据是无序的
  • 字典的键不能重复，且之能用不可变类型作为字典的键
  • 字典中的数据只能用"键"key 进行索引，不能用整数进行索引

• 创建字典的字面值:

  d = {}    # 创建空字典
  d = {'name': "weimingze", "age": 35}
  d = {'a': [1, 2, 3]}
  d = {'b': {"bb": 222}}
  d = {1:'壹', 2:'贰', 5:'伍'}
  d = {(1, 2, 3):'壹贰伍'}
  

• 以下写法会存在问题

  d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2} 
  d = {[1, 2, 3]: 'a'}          # 不能用可变类型作为字典的键  # 报错
  

• dict 的创建函数 dict

  d = dict()   # d = {}
  d = dict([("name", "魏明择"), ("age", 35)])  # {'name': '魏明择', 'age': 35}
  d = dict(a=1, b=2, c=3)    # {'a':1, 'b':2, 'c':3}
  d = dict([1, 2, 3, 4])  # 错
  

  persons = [
  {'name': 'weimz', 'age': 35},
  {'name': '小张', 'age': 18},
  ]
  

• 字典的键索引

  • 语法

  • 示例:

    d = {'one': 1, 'two': 2}
    print(d['two'])
    

• 添加和修改字典的元素

  • 语法

  • 示例:

    d = {}
    d['name'] = 'tarena'  # 添加键值对  d = {'name': 'tarena'}
    d['age'] = 18         # d = {'name': 'tarena', 'age': 18}
    d['age'] = 19         # 改变 'age' 键对应的值 d = {'name': 'tarena', 'age': 19}
    

• 删除 字典的元素

  • 语法

    del 字典[键]
    

  • 示例:

    >>> d = dict(a=1, b=2)   # d = {'a': 1, 'b': 2}
    >>> del d['a']
    >>> d
    {'b': 2}
    

• in / not in 运算符

  用 in 可以判断一个键是否存在于字典中,如果存在返回 True, 否则返回 False

  not in 与 in 相反

  • 示例

    >>> d = dict(a=1, b=2)   # d = {'a': 1, 'b': 2}
    >>> 'a' in d
    True
    >>> 1 in d
    False
    >>> 'hello' not in d
    True
    

• 字典是可迭代对象, 字典只能对所有的键进行迭代访问

  >>> d = {'name': 'tarena', 'age': 19}
  >>> for k in d:
  ...   print(k)
  ... 
  name
  age
  >>> for k in d:
  ...     print("key=", k, 'value=', d[k])
  ... 
  key= name value= tarena
  key= age value= 19
  

• 字典的常用方法

  方法D代表字典	说明D
  D.clear()	清空字典
  D.copy()	复制
  D.get(key[, default])	如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。
  D.pop(key)	移除键, 同时返回键对应的值

• 示例

  >>> d = {'name': 'tarena', 'age': 19}
  >>> 
  >>> d['age']
  19
  >>> d['address']
  Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
  KeyError: 'address'
  >>> d.get('address', '未填写住址')
  '未填写住址'
  >>> d.get('age', 0)
  19
  >>> n = d.pop('name')
  >>> d
  { 'age': 19}
  >>> n
  'tarena'
  

列表、元组、字典小结

1. 列表和元组是有序的，字典的存储是无序的

2. 列表、字典是可变的,元组是不可变的

3. 字典的键索引速度快，列表的整数索引速度快

4. 列表和元组是顺序存储的，字典是散列存储的

5. 字典的 in / not in 运算符快于 列表的 in / not in 运算符

集合 set/ 固定集合 frozenset

• 创建集合的方式

  s = set()            # 用函数空集合
  s = {1, 2, 3, 4}     # 创建非空集合的字面值
  s = set(range(5))    # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
  s = set("ABC")       # s = {'B', 'C', 'A'}
  s = set("ABCCCCCCC")  # s = {'B', 'C', 'A'}
  s = set(['ABC'])      # s = {'ABC'}
  

• 创建固定集合frozensets的方式

  fs = frozenset()              # 空固定集合 fs = frozenset()
  fs = frozenset([1, 2, 3])     # fs =  frozenset({1, 2, 3})
  

集合和固定集合的运算

• in/ not in 运算符 与列表相同

• 其他运算

  &   交集
  |   并集
  -   补集
  ^   对称补集
  <   子集
  >   超集
  

• 示例

  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s3 = s1 & s2   # s3 = {2, 3}  # 交集（只输出重复的）
  s4 = s1 | s2   # s4 = {1, 2, 3, 4 }  并集（全部输出，加上去重）
  s5 = s1 - s2   # s5 = {1}   补集（s1 补集 s2 就输入 s1 补集）
  s6 = s1 ^ s2   # s6 = {1, 4}  # 对称补集（不输出重复的）
  s7 = {1, 2} < {1, 2, 3}  # s7 = True （123 是 12 的子集）
  s8 = {1, 2} > {1, 2, 3}  # s8 = False （12 是 123 的超集）
  s9 = {4, 5, 6, 7} > {5, 6}  #  {4, 5, 6, 7} 是 {5, 6} 的超集
  

• 集合set的方法

  方法	说明
  S.add(e)	添加e
  S.remove(e)	删除e
  S.clear()	清空集合
  S.pop()	移除一个并返回，如果集合为空则触发ValueError

• 容器总结

  • 可变和不可变

    • 可变的容器
  • 不可变得容器

  • 有序和无序

    • 有序

    • 无序

• 课后练习1

• 课后练习2

• 课后练习3(明天再完成)

  *
 ***
*****
  $
  $
  $

   *
  ***
 *****
*******
   $
   $
   $ 
   $

• 课后练习4

• 课后练习5