3.1 列表

py 中没有数组，取而代之的是列表

  • 形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔

    [element1, element2, element3, …, elementn]

  • 内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同

    [“python”, 1, [2,3,4] , 3.0]

在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性

3.1.1 创建列表

  1. 使用 [] 直接创建
  2. 使用 list() 函数创建列表
    1. In [1]: print(list("hi"))
    2. ['h', 'i']

    3.1.2 访问列表元素

    ```python str0 = list(“abcdefghijklmn”)

使用索引访问列表中的某个元素

print(str0[3]) #使用正数索引 print(str0[-4]) #使用负数索引

使用切片访问列表中的一组元素

print(str0[9: 18]) #使用正数切片 print(str0[9: 18: 3]) #指定步长 print(str0[-6: -1]) #使用负数切片

  1. <a name="HYm0s"></a>
  2. ### 3.1.3 删除列表
  3. 直接使用del
  4. <a name="uD8bw"></a>
  5. ### 3.1.4 添加元素的方法
  7. 1. append()，在列表的末尾追加元素。当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表
  8. 1. extend() ，在列表的末尾追加元素。extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中
  9. 1. insert()， 任意位置插入。当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中
  10. <a name="l0ocA"></a>
  11. ### 3.1.5 删除元素的方法
  13. 1. del 专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素
  14.    1. 删除列表中的单个元素 -> del listname[index]
  15.    1. 以删除中间一段连续的元素 -> del listname[start : end]
  16. 2.  pop() 方法用来删除列表中指定索引处的元素
  17. 2. remove() 方法，该方法会根据元素本身的值来进行删除操作。remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误
  18. 2. clear() 用来删除列表的所有元素，也即清空列表
  19. <a name="yLw1c"></a>
  20. ### 3.1.6 修改元素
  22. 1. 修改单个元素
  24.           直接使用索引赋值
  26. 2. 修改一组元素
  28.           使用切片，指定步长
  29. ```python
  30. nums = [40, 36, 89, 2, 36, 100, 7]
  31. #修改第 1~4 个元素的值（不包括第4个元素）
  32. nums[1: 4] = [45.25, -77, -52.5]
  33. print(nums)

3.1.7 查找元素

  1. 直接使用 index 进行查找 :::info listname.index(obj, start, end)
    listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置
    start 和 end 参数用来指定检索范围：
  • start 和 end 可以都不写，此时会检索整个列表
  • 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素
  • 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素

index() 方法会返回元素所在列表中的索引值 :::

  1. count 计算某个元素出现的次数 :::info listname.count(obj)
    其中，listname 代表列表名，obj 表示要统计的元素
    如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在 :::

    3.2 元组

    元组是由一系列按特定顺序排序的元素组成，可以看作是不可变的列表。通常情况下，元组用于保存无需修改的内容。

  2. 形式上看：元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔

(element1, element2, … , elementn)

  1. 存储内容上看：元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同

tuple 与 list 的不同：

  • 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列
  • 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列

    3.2.1 创建元组

  1. 使用 （）直接创建 :::info 通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：
    tuplename = (element1, element2, …, elementn)
    其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素 ::: 在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组
    注意：
    当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串

  2. 使用 tuple() 函数创建元组 :::info 内置函数 tuple()，用来将其它数据类型转换为元组类型：
    tuple(data)
    data 表示可以转化为元组的数据，包括字符串、元组、range 对象等 :::

    3.2.2 访问元组元素

    可以使用 index 访问某个元素，也可以使用切片访问元组中的一组元素（得到的是一个新的子元组） :::info

  • 使用 index 访问元组元素：

tuplename[i]
tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数

  • 使用切片访问元组元素：

tuplename[start : end : step]
start 表示起始索引，end 表示结束索引，step 表示步长 :::

3.2.3 修改元组

元组是不可变序列，因此元组内的元素不可以被修改，但是可以创建一个新的元组代替旧的元组

  1. 对元组变量进行重新赋值
  2. 通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素（拼接后，原有的两个数组的内容不会发生任何变化，这说明生成的是一个新的元组）

    3.2.4 删除元组

    直接使用 del 关键字进行删除

    3.3 字典

    字典是一种无序的、可变的序列，元素以 K-V 形式存储，是py中唯一的映射类型

    3.3.1 特征

    | 主要特征 | 解释 | | —- | —- | | 通过键而不是通过索引来读取元素 | 字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取 | | 字典是任意数据类型的无序集合 | 和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的 | | 字典是可变的，并且可以任意嵌套 | 字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典 | | 字典中的键必须唯一 | 字典中，不支持同一个键出现多次，否则只会保留最后一个键值对 | | 字典中的键必须不可变 | 字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表 |

3.3.2 创建字典

  1. 使用 {} 创建 :::info 字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中 ::: dictname = {‘key’:’value1’, ‘key2’:’value2’, …, ‘keyn’:valuen}
  • 同一字典中的各个键必须唯一，不能重复
  • 字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型
  1. 通过 fromkeys() 方法创建

使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典：
dictname = dict.fromkeys(list，value=None)
value 可以为空

  1. 通过 dict() 映射函数创建 | 创建格式 | 注意事项 | | —- | —- | | a = dict(str1=value1, str2=value2, str3=value3) | str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号 | | #方式1
    demo = [(‘two’,2), (‘one’,1), (‘three’,3)]
    #方式2
    demo = [[‘two’,2], [‘one’,1], [‘three’,3]]
    #方式3
    demo = ((‘two’,2), (‘one’,1), (‘three’,3))
    #方式4
    demo = ([‘two’,2], [‘one’,1], [‘three’,3])
    a = dict(demo) | 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值 | | keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组
    values = [1, 2, 3] #还可以是字符串或元组
    a = dict( zip(keys, values) ) | 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典 |
  • 无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键
  • 如果不为 dict() 函数传入任何参数，则代表创建一个空的字典

    3.3.3 访问字典

  1. 通过 k 访问 v：dictname[key]

dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常

  1. 使用 dict 类型提供的 get() 方法来获取指定键对应的值

当指定的键不存在时，get() 方法不会抛出异常
dictname.get(key[,default])

  • dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值， 如果不手动指定，会返回 None
  • 当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数
    1. a = dict(two=0.65, one=88, three=100, four=-59)
    2. print( a.get('five', '该键不存在') )

    3.3.4 删除字典

    直接使用 del 删除

    3.3.4 字典的基本操作

  1. 添加键值对

直接给不存在的 key 赋值即可，dictname[key] = value

  1. 修改键值对

由于 k 是唯一的，因此新添加的元素的 k 与已存在的元素的 k 的 v 相同，那么 k 所对应的 v 就会被新的 v 替换掉，以此来达到修改元素值的目的

  1. 删除键值对

直接使用 del 语句

3.3.5 字典方法

dir(dict)
[‘clear’, ‘copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]

  1. keys()、values() 和 items() 方法 :::info 它们都用来获取字典中的特定数据：
  • keys() 方法用于返回字典中的所有键（key）
  • values() 方法用于返回字典中所有键对应的值（value）
  • items() 用于返回字典中所有的键值对（key-value）

keys()、values() 和 items() 返回值的类型分别为 dict_keys、dict_values 和 dict_items :::

  1. copy() 方法 :::info copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典
    copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝 :::

  2. update() 方法 :::info

  • update() 方法可以使用一个字典所包含的键值对来更新己有的字典
  • 在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去 :::
  1. pop() 和 popitem() 方法 :::info pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对
  • dictname.pop(key)
  • dictname.popitem() ::: popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作
  1. setdefault() 方法 :::info
  • setdefault() 方法用来返回某个 key 对应的 value：dictname.setdefault(key, defaultvalue)，defaultvalue 可以不写，不写的话是 None

  • 当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue，即setdefault() 方法总能返回指定 key 对应的 value：

    • 如果该 key 存在，那么直接返回该 key 对应的 value
    • 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue :::

      3.4 集合

      集合中的元素都是唯一的，互不相同 :::info

  • 形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔

  • 内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误 :::
    • 数据必须保证是唯一的，因为集合对于每种数据元素，只会保留一份
    • 由于 Python 中的 set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同

python中有两种集合，一种是 set 集合，另一种是 forzenset 集合：

  • set集合可以做添加、删除元素的操作
  • forzenset不可以

3.4.1 创建、访问、删除

  1. 创建
    1. 使用 {} 创建

直接将集合赋值给变量，从而实现创建集合的目的

  1. set() 函数创建集合

set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合
setname = set(iteration) - > iteration 就表示字符串、列表、元组、range 对象等数据

  1. 如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {}，Python 解释器会将其视为一个空字典
    1. 访问

使用 for 循环遍历

  1. 删除

使用 del 直接删除

3.4.2 set 集合基本操作

  1. 添加：add()
  2. 删除：remove()
  3. set 集合做交并差集运算 | 运算操作 | Python运算符 | 含义 | 例子 | | —- | —- | —- | —- | | 交集 | & | 取两集合公共的元素 | >>> set1 & set2
    {3} | | 并集 | | | 取两集合全部的元素 | >>> set1 | set2
    {1,2,3,4,5} | | 差集 | - | 取一个集合中另一集合没有的元素 | >>> set1 - set2
    {1,2}
    >>> set2 - set1
    {4,5} | | 对称差集 | ^ | 取集合 A 和 B 中不属于 A&B 的元素 | >>> set1 ^ set2
    {1,2,4,5} |

3.4.3 全部方法

  1. >>> dir(set)
  2. ['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
方法名 语法格式 功能 实例
add() set1.add() 向 set1 集合中添加数字、字符串、元组或者布尔类型 >>> set1 = {1,2,3}
>>> set1.add((1,2))
>>> set1
{(1, 2), 1, 2, 3}
clear() set1.clear() 清空 set1 集合中所有元素 >>> set1 = {1,2,3}
>>> set1.clear()
>>> set1
set()

set()才表示空集合，{}表示的是空字典 | | copy() | set2 = set1.copy() | 拷贝 set1 集合给 set2 | >>> set1 = {1,2,3}
>>> set2 = set1.copy()
>>> set1.add(4)
>>> set1
{1, 2, 3, 4}
>>> set1
{1, 2, 3} | | difference() | set3 = set1.difference(set2) | 将 set1 中有而 set2 没有的元素给 set3 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set3 = set1.difference(set2)
>>> set3
{1, 2} | | difference_update() | set1.difference_update(set2) | 从 set1 中删除与 set2 相同的元素 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set1.difference_update(set2)
>>> set1
{1, 2} | | discard() | set1.discard(elem) | 删除 set1 中的 elem 元素 | >>> set1 = {1,2,3}
>>> set1.discard(2)
>>> set1
{1, 3}
>>> set1.discard(4)
{1, 3} | | intersection() | set3 = set1.intersection(set2) | 取 set1 和 set2 的交集给 set3 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set3 = set1.intersection(set2)
>>> set3
{3} | | intersection_update() | set1.intersection_update(set2) | 取 set1和 set2 的交集，并更新给 set1 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set1.intersection_update(set2)
>>> set1
{3} | | isdisjoint() | set1.isdisjoint(set2) | 判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回 True | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set1.isdisjoint(set2)
False | | issubset() | set1.issubset(set2) | 判断 set1 是否是 set2 的子集 | >>> set1 = {1,2,3}
>>> set2 = {1,2}
>>> set1.issubset(set2)
False | | issuperset() | set1.issuperset(set2) | 判断 set2 是否是 set1 的子集 | >>> set1 = {1,2,3}
>>> set2 = {1,2}
>>> set1.issuperset(set2)
True | | pop() | a = set1.pop() | 取 set1 中一个元素，并赋值给 a | >>> set1 = {1,2,3}
>>> a = set1.pop()
>>> set1
{2,3}
>>> a
1 | | remove() | set1.remove(elem) | 移除 set1 中的 elem 元素 | >>> set1 = {1,2,3}
>>> set1.remove(2)
>>> set1
{1, 3}
>>> set1.remove(4)
Traceback (most recent call last):
File ““, line 1, in
set1.remove(4)
KeyError: 4 | | symmetric_difference() | set3 = set1.symmetric_difference(set2) | 取 set1 和 set2 中互不相同的元素，给 set3 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set3 = set1.symmetric_difference(set2)
>>> set3
{1, 2, 4} | | symmetric_difference_update() | set1.symmetric_difference_update(set2) | 取 set1 和 set2 中互不相同的元素，并更新给 set1 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set1.symmetric_difference_update(set2)
>>> set1
{1, 2, 4} | | union() | set3 = set1.union(set2) | 取 set1 和 set2 的并集，赋给 set3 | >>> set1 = {1,2,3}
>>> set2 = {3,4}
>>> set3=set1.union(set2)
>>> set3
{1, 2, 3, 4} | | update() | set1.update(elem) | 添加列表或集合中的元素到 set1 | >>> set1 = {1,2,3}
>>> set1.update([3,4])
>>> set1
{1,2,3,4} |

3.4.4 frozenset 集合

frozenset 集合是不可变序列，程序不能改变序列中的元素

  1. >>> dir(frozenset)
  2. ['copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

两种情况下可以使用 fronzenset：

  • 当集合的元素不需要改变时，我们可以使用 fronzenset 替代 set，这样更加安全
  • 有时候程序要求必须是不可变对象，这个时候也要使用 fronzenset 替代 set。比如，字典（dict）的键（key）就要求是不可变对象