【无标题】Python ---Day2 复合类型之序列类型、映射类型和集合类型的学习！！！

系列文章目录

---

前言

昨天博主梳理了有关变量，数字类型以及字符串类型，今天大家跟随博主一起进入复合类型之序列类型、映射类型和集合类型总结。相信大家跟随博主的进度在未来也会成为一位高级的算法工程师

一、复合类型初识

Python 支持多种复合数据类型，可将不同值组合在一起。

1.1 列表类型

list

列表是用方括号标注、逗号分隔的一组值，可以包含不同类型的元素：

• 列表内的数据有先后顺序关系
• 列表是可变的容器

1.1.1 列表创建

• 字面值

  L = []     # 创建一个空的列表
  L = ['北京', '上海', '广州', '西安']  # 创建一个含有4个字符串的列表
  L = [1, 'Two', 3.14, True, False, None]
  L = [1, 2, [3.1, 3.2], 4]   #  含有四个元素的列表，第三个元素是列表
  L2 = [
  	['姓名','语文成绩','数学成绩'],
  	['小王', 90, 100],
  	['牛犇', 59, 26]
  ]
  

• 构造函数list

  list()           # 创建一个空的列表，等同于 []
  list(可迭代对象)   # 用可迭代对象创建一个列表
  

  示例

  L = list()          # L = []
  L = list("ABC")     # L = ['A', 'B', 'C']
  L = list(range(5))  # L = [0, 1, 2, 3, 4]
  

1.1.2 列表运算

列表list同字符串str都是序列, 他们的运算规则基本相同。

• + 用于拼接列表

  [1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]
  

• += 追加

  语法 列表 += 可迭代对象

  L = [1, 2, 3]
  L += [4, 5]         # L = [1, 2, 3, 4, 5]
  L = [1, 2, 3]
  L += "ABC"          # L = [1, 2, 3, 'A', 'B', 'C']
  L += range(2)
  

• * 用于生产重复的列表

  [1, 2] * 3    # [1, 2, 1, 2, 1, 2]
  L = [5, 6]
  L *= 3        # L = [5, 6, 5, 6, 5, 6]
  

• == 、!= 用于比较

  [1, 2, 3] == [1, 2, 3]    # True
  [1, 2, 3] != [3, 2, 1]    # True
  

• in 、not in 用于判断一个数据元素是否在列表中

  "hello" in [1, "hello", 'world']
  True
  '红楼梦'  in ['三国演义', '西游记']
  False
  

  1.1.3 列表访问

1.1.3.1 索引

列表[整数表达式]

L = [1, 2, 3, 4, 5, 6]
print(L[0])    # 1
print(L[-1])   # 6

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

1.1.3.2 反向索引

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

1.1.3.3 切片

列表[(开始索引b):(终止索引e)(: (步长s))]

() 里的内容代表可以省略

x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4]     # y1 = [1, 2, 3, 4]
y2 = x[::2]    # y2 = [1, 3, 5, 7]
y3 = x[::-1]   # y3 = [8, 7, 6, 5, 4, 3, 2, 1]

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

list = ['openAI', 'hqyj', "Zhihu", "Taobao", "Wiki"] 
# 读取第二位
print (list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (list[1:-2])
# 从下标2开始(包含2)到最后一个
print (list[2:])
# 从下标0开始到下标3结束(左闭右开)
print (list[:3])

1.1.4 列表操作

增、删、改、查（就是列表访问）

官方文档：https://docs.python.org/zh-cn/3.13/library/stdtypes.html#sequence-types-list-tuple-range

1.1.4.1 添加数据

• 方法

方法名(L代表列表)	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象

• 示例

mylist1 = [1, 3, 4]            	# 目标是变成 [1, 2, 3, 4, 5]
mylist1.append(5)               # mylist1 = [1, 3, 4, 5]
mylist1.insert(1, 2)            # mylist1 = [1, 2, 3, 4, 5]
mylist1.extend(range(6, 10))    # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

1.1.4.2 修改数据

• 用索引赋值可以改变列表内的数据

列表[整数表达式] = 表达式

• 示例

mylist2 = [1, 1.99, 3]   # 把1.99 改为2
mylist2[1] = 2    # mylist2 = [1, 2, 3]

1.1.4.3 删除数据

• 方法

  方法	说明
  L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
  L.pop()	根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素
  L.clear()	清空列表

  • 示例

  L = [1, 2, 3, 4, 2, 2, 3, 4]
  L.remove(3)    #  L = [1, 2, 4, 2, 2, 3, 4]
  L.remove(3)    #  L = [1, 2, 4, 2, 2, 4]
  L.remove(3)    #  报错了
  L.clear()      #  L = []
  

• del 语句删除指定位置的数据元素

  • 语法

    del 变量名     # 删除变量，同时解除变量绑定的对象
    del 列表[整数表达式]
    

  • 示例

    L = ['张飞', '赵云', '鲁班7号', '孙悟空']
    del L[2]    # L = ['张飞', '赵云', '孙悟空']
    del L       # 删除 L 变量
    

    1.2 元组类型

tuple

元组用来存储有序数据，多个值用逗号隔开。

• 元组使用小括号 ( )，虽然圆括号可有可无；
• 元组的元素多为异质的，不可变的（immutable），通过解包或索引访问；
• 列表的元素多为同质的，可变的（mutable），可迭代访问；

1.2.1 元组创建

• 创建元组的字面值

用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组

t = ()         # 空元组
t = (100,)     # 一个元素的元组，在元素后面添加逗号，否则括号会被当作运算符
t = 100,       # 一个元素的元组
t = (1, 2, 3)  # 含有三个数据元素的元组
t = ( 'hqyj', 2004) # 存放不同类型的元组
t = 1, 2, 3    # 含有三个数据元素的元组

• 创建元组的函数 tuple

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

1.2.2 元组操作

元组是不可变容器，相对来讲操作少一些。

###1.4.2.2.1 删除元组

元组中的元素值是不允许删除的，但可以用del删除元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)		#name 'tup' is not defined

1.2.2.2 查看元组

元组的元素访问可以像列表一样通过下标、切割等方式去访问。。

tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)

1.2.2.3 解包技能

必备技能

序列解包：解构赋值，左侧变量与右侧序列元素的数量应相等

fruit = ('apple', 'pear', 'peach')
f1, f2, f3 = fruit
print(f1, f2, f3)

1.2.3 元组运算

元组中的元素值是不允许修改的，但可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

t = (1, 2, 3) + (4, 5, 6)
t += (7, 8, 9)  # 等同于 t = t + (7, 8, 9)
t = t * 2
t *= 2
5 in t

1.2.4 元组不可变

不可变指的是变量指向的内存中的内容不可变，但是变量的指向是可以改变的。

tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup)#报错'tuple' object does not support item assignment

变量是可以重新赋值的

tup1 = (12, 34.56)
tup1 = (12, 100)
tup1

二、映射类型 ---- 字典（dict）

• 字典是可变容器，可存储任意类型对象

• 字典以键(key)-值(value)对的形式进行映射，键值对用冒号分割，对之间用逗号分割

• d = {key1 : value1, key2 : value2, key3 : value3 }

• 字典的数据是无序的

• 字典的键只能用不可变类型，且不能重复

2.1 字典创建

• 创建字典的字面值

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'}          # TypeError: unhashable type: 'list'

• 字典的创建函数 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])  # 错

2.2 字典操作

增、删、改、查

2.2.1 增加或修改

添加和修改字典的元素

• 语法

  字典[键key] = 表达式
  

  键不存在, 就添加

  键存在, 会改变键对应的值

• 示例

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

2.2.2 访问值

• 字典的键索引

  • 语法

    字典[键key]
    

  • 示例

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

  • 如果键不存在，会报错

    mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'} 
    print (mydic['Alice']) # KeyError: 'Alice'
    

2.2.3 in/not in

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

• 示例

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

2.2.4 删除元素

能删单一的元素也能清空字典，显式删除一个字典用del命令

• 语法

del 字典[键]

• 示例

mydic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del mydic['Name'] # 删除键 'Name'
mydic.clear()     # 清空字典
 
print (mydic['Age'])
print (mydic['School'])

del mydic         # 删除字典

2.3 字典特性

• 不允许同一个键出现两次，否则后一个覆盖前一个

  mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
  print (mydic['Name'])
  

• 键必须不可变，可以用数字、字符串或元组，列表不行

  mydic1 = {97:"a",98:"b"}
  mydic2 = {"name":"karen","age":27}
  mydic3 = {['Name']: 'karen', 'Age': 27}
  print(mydic3[['Name']])	#报错unhashable type: 'list'
  

2.4 字典的常用API

字典的方法：

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。

三，set/ frozenset

集合set和固定集合frozenset

set的元素值必须是不可变的，set中可以存储int、str、tuple等不可变类型，但不能存储 list、dict 等可变类型。

• 集合是可变的容器，固定集合是不可变的集合
• 集合相当于只有键没有值的字典，当然你也可以理解为键和值相等
• 集合内的数据都是唯一的，不可变的

3.1 集合创建

• 创建集合的方式

  空集合 set()

  非空集合用 {} 括起来，值用逗号分隔开

  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'} 使用 set()函数从列表创建集合
  s = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合
  

• 创建固定集合frozensets的方式

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

**注意：**创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

3.2 集合操作

官方文档：https://docs.python.org/zh-cn/3.13/library/stdtypes.html#set-types-set-frozenset

3.2.1 添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

• s.add( x ) 添加元素到集合。
• s.update( x ) 添加元素到集合，且参数可以是列表、元组、字典等，x 可以有多个，用逗号分开。

s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1)
s1.update([200,300])
print(s1)

3.2.2 删除元素

• s.remove( x )：将元素 x 从集合 s 中移除，不存在会发生错误。

• s.discard( x )：将元素 x 从集合 s 中移除，不存在也不会发生错误。

• s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

s1 = {10, 20, 30}
s1.remove(20)
print(s1)
s1.remove(40)#报错

s1 = {10, 20, 30}
s1.discard(20)
print(s1)
s1.discard(40)

s1 = {10, 20, 30}
s1.pop()
print(s1)

del s1 # 也可以直接删除整个集合

3.2.3 访问与修改

集合是无序的、不可重复的数据结构，不能通过索引来访问其元素。所以也没有对应的修改功能。

TODO：需要通过便利或者迭代器去访问。

3.2.4 in/not in

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

s1 = {10, 20, 30}
print(20 in s1)

3.3 常用API

集合的方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集，并更新到集合。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

四， 可变与不可变

Python中，变量的值分为可变（mutable）或 不可变（immutable），该特征决定了变量在赋值、修改时的行为和性能。

4.1 不可变类型

不可变类型的值一旦创建，就无法改变。任何试图修改不可变对象的操作都会创建一个新的对象。常见不可变类型包括：

1. 数值类型：int、float、complex

   数字的值一旦赋值，不能被修改。

   x = 10
   print(id(x), hex(id(x)))
   x = x + 5  # 会创建一个新的整数对象，并将其赋值给 x
   print(id(x), hex(id(x)))
   

   id()：获取变量引用的内存地址；

   hex()：转换为16进制；

2. 字符串

   字符串是不可变的，任何试图修改字符串内容的操作都会生成一个新的字符串。

   s = "hello"
   print(id(s))
   s = s + " world"  # 创建一个新的字符串对象并赋值给 s
   print(id(s))
   

3. 元组

   元组是不可变的容器类型，一旦创建，其内容不能更改。

   t = (1, 2, 3)
   # t[0] = 10  # 会抛出 TypeError: 'tuple' object does not support item assignment
   

4. 冻结集合

   frozenset 是不可变版本的集合，一旦创建，无法修改其元素。

   fs = frozenset([1, 2, 3])
   # fs.add(4)  # 会抛出 AttributeError: 'frozenset' object has no attribute 'add'
   

5. 布尔值

   布尔值 True 和 False 也属于不可变类型。

   flag = True
   flag = False  # 这不是修改，而是创建了一个新的布尔值并赋值给flag
   

6. 字节串和None

   字节串和None为不可变类型。

   4.2 可变类型

可变类型的值在创建后可以被修改。常见的可变类型：

1. 列表

   列表是可变的，可以在原地修改其元素、添加或删除元素。

   lst = [1, 2, 3]
   lst[0] = 10  # 修改原列表的元素
   lst.append(4)  # 添加新的元素
   

2. 字典

   字典也是可变类型，可以修改其键值对。

   d = {'a': 1, 'b': 2}
   d['a'] = 10  # 修改字典中键 'a' 对应的值
   d['c'] = 3   # 添加新的键值对
   

3. 集合

   集合是可变的，可以添加或删除元素。

   s = {1, 2, 3}
   s.add(4)  # 添加元素
   s.remove(2)  # 删除元素
   

4. 自定义对象

   自定义类的实例如果没有在类中明确限制其属性，可以修改实例的属性值，因此对象实例也是可变的。

   class MyClass:
       def __init__(self):
           self.value = 0
   
   obj = MyClass()
   obj.value = 10  # 修改对象的属性
   

   4.3 二者区别

5. 内存管理

   • 对不可变类型改值时，Python会创建一个新的对象，并将该对象的引用赋给原来的变量。

   • 对可变类型修改内容时，不会创建新的对象，而是直接在原地进行修改。

     | |![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=pymedia%2Fimage-20250307140404241.png&pos_id=img-hvsv3HvW-175214062118

6. 行为差异

   • 不可变对象的引用在修改后总会指向一个新对象，而可变对象的引用在修改时仍然指向原始对象。

7. 作为字典键

   • 不可变类型具有固定的哈希值，可以作为字典的键。
   • 可变类型哈希值可能变化，不能作为字典的键。

   d = {}
   d[(1, 2)] = "tuple key"  # 元组是不可变的，可以作为字典的键
   d[[1, 2]] = "list key"   # 会抛出 TypeError: unhashable type: 'list'
   

8. 特别注意
   以上是基于修改而不是赋值，重新赋值操作都会指向新的对象引用。

4.4 类型判断

使用isinstance判断类型变量

a = 1
print(isinstance(a, int)) #判断是否属于指定类型
str1 = 'abc'
print(isinstance(str1, (int, str))) #判断是否属于多个类型之一
### 1.7 类型转换

这里只是总结一下常见类型转换的函数：

| **函数**     | **说明**                                                     | **示例**                                          |
| ------------ | ------------------------------------------------------------ | ------------------------------------------------- |
| int(x)       | 将 `x` 转换为整数类型。                                      | `int("10")`  → `10`                               |
| float(x)     | 将 `x` 转换为浮点数类型。                                    | `float("3.14")` → `3.14`                          |
| str(x)       | 将 `x` 转换为字符串类型。                                    | `str(123)` → `"123"`                              |
| list(x)      | 将 `x` 转换为列表类型，`x` 必须是可迭代对象。                | `list((1, 2, 3))` → `[1, 2, 3]`                   |
| tuple(x)     | 将 `x` 转换为元组类型，`x` 必须是可迭代对象。                | `tuple([1, 2, 3])` → `(1, 2, 3)`                  |
| set(x)       | 将 `x` 转换为集合类型，`x` 必须是可迭代对象。                | `set([1, 2, 3])` → `{1, 2, 3}`                    |
| dict(x)      | 将 `x` 转换为字典类型，`x` 必须是可迭代的键值对序列（如列表、元组）。 | `dict([('a', 1), ('b', 2)])` → `{'a': 1, 'b': 2}` |
| bool(x)      | 将 `x` 转换为布尔类型，`x` 的值可以是任何对象，返回 `True` 或 `False`。 | `bool(0)` → `False` ； `bool("abc")` → `True`     |
| frozenset(x) | 将 x 转换为冻结集合，x 必须是可迭代对象。                    | `frozenset([1, 2, 3])` → `frozenset({1, 2, 3})`   |
| bytes(x)     | 将 x 转换为字节串类型，x 可以是字符串、字节数组等。          | `bytes("hello", "utf-8")` → `b'hello'`            |
| complex(x)   | 将 x 转换为复数类型。                                        | `complex(2)` → `(2+0j)`                           |
| chr(x)       | 将整数 x 转换为对应的字符，x 是 Unicode 码点。               | `chr(97)` → `'a'`                                 |
| ord(x)       | 将字符 x 转换为对应的整数，x 是一个单一字符。                | `ord('a')` → `97`                                 |
| eval(x)      | 将字符串 x 作为 Python 表达式进行求值并返回结果。            | `eval('3 + 4')` → `7`                             |
| set(x)       | 将可迭代对象 x 转换为集合。                                  | `set([1, 2, 2, 3])` → `{1, 2, 3}`                 |

注意事项：

• 并不是所有类型都可以直接转换。如：

  int("hello")  # 会抛出 ValueError: invalid literal for int() with base 10: 'hello'
  

• 类型转换可能会引发错误或丢失信息，比如浮点数转换为整数时，小数部分会丢失。

总结

经过今天的学习，明白了类型之间的转换以及认识了set，dict，tuple，list这些类型，这些在我们接下来如果要更深的进行模型的训练非常的重要，今天的知识点需要加以巩固和理解。其中比较容易出错的就是tuple一般用来作为return的返回值，然后就是不可变数据类型的地址在同一个值赋给俩个变量的时候内存地址不会做出改变。set集合呢一般是用来查重的，把列表中的重复元素剔除掉，再重新生成列表，这样咱们就得到一个全新的没有重复元素的列表。接着，list列表在python中使用的非常频繁。字典类型呢也被称为映射类型，由大括号里的键值对组成，因为键值对为一一对应的关系，所以每当我们查看或者调用其中的键时会映射出来其对应的值，这个咱们在后续做模型训练的时候会将大批量数据存储在我们的字典里以方便查找。
博主呢，也是作为一名新手Ai的学习者，每天将在我的账号更新今日学习内容，欢迎大家参考或者提出意见，共同交流共同进步，这里博主祝愿大家在未来成为一名算法工程师！！