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

奋斗De奶爸

 关注

阅读 130

2021-09-25

回顾

  • 循环语句

    • 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.index(x[, i[, j]]) x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x) x 在 s 中出现的总次数
s.append(x) 将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
s.clear() 从 s 中移除所有项 (等同于 del s[:])
s.copy() 创建 s 的浅拷贝 (等同于 s[:])
s.extend(t) 或 s += t 用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
s.insert(i, x) 在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
s.pop([i]) 提取在 i 位置上的项，并将其从 s 中移除
s.remove(x) 删除 s 中第一个 s[i] 等于 x 的项目。
s.reverse() 就地将列表中的元素逆序。
s.sort( key=None, reverse=False) 对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序

示例:

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 中常用于序列的函数
运算 结果
len(s) s 的长度
min(s) s 的最小项
max(s) s 的最大项 # 课间休息: 11:11 回来
sum(s) 求 s内所有数字的和(不允许有其他数据) 
>>> 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. 列表和元组是顺序存储的，字典是散列存储的

  1. 字典的 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

相关推荐

Python 列表 元组 集合 字典

小贴贴纸happy 213 0 0

列表、字典、元组、集合总结

书坊尚 138 0 0

列表、元组、字典和集合的区别

minute_5 185 0 0

字典元组和集合

慕容冲_a4b8 64 0 0

Python语法——列表、元组、集合、字典

泠之屋 187 0 0

Python——列表、元组、字典、集合区别

Gaaidou 215 0 0

Python中列表、元组、字典和集合的区别

爱读书的歌者 258 0 0

【python学习】列表、元组、字典、集合（详解）

勇敢乌龟 142 0 0

Python元组、字典、集合

云卷云舒xj 42 0 0

列表、元组、字典、集合与字符串

天际孤狼 73 0 0

精彩评论（0）

0 0 举报