列表

• 序列类型
• a=[1,2,3,4,5]
• 元素有位置顺序，通过位置访问：a[0]

创建

l1=list("my baby")
l2=list(('李','宝','贝'))
l3=list({
    
    '臭','宝','贝'})# 无序
l4=list(range(1,6))
print(l1)
print(l2)
print(l3)
print(l4)

['m', 'y', ' ', 'b', 'a', 'b', 'y']
['李', '宝', '贝']
['宝', '臭', '贝']
[1, 2, 3, 4, 5]

增删改查

• 增

fruit=["apple","banana"]
fruit.append("pear")
fruit.insert(0,"orange")
fruit

['orange', 'apple', 'banana', 'pear']

like=["all"]
fruit.extend(like)
fruit

['orange', 'apple', 'banana', 'pear', 'all']

• 删

num=[0,1,2,3,4,5,6]
num.pop(2)
num

[0, 1, 3, 4, 5, 6]

s1=["啊","a","啊","b","c"]
s1.remove("啊")
s1

['a', '啊', 'b', 'c']

• 改

s1[0]="first"

• 查

s1.index("c")

浅拷贝

list1=[1,2,3,4,5]
list2=list1.copy()# 浅拷贝
list2.append(6)
print(list1)
print(list2)

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

但是：

list1=[1,[2,3,4]]
list2=list1.copy()
list2[1].append(5)
print(list1)
print(list2)

[1, [2, 3, 4, 5]]
[1, [2, 3, 4, 5]]

需要另外一种浅拷贝的方式：【可以独立增、改，但对列表型/字典型数据操作时会同时变，元组因为自杀的不可变性而使得不会同时变】

list_1=[1,[2,3,4,6]]
list_2=list(list1)
list_2[1].append(7)
print(list_1)
print(list_2)

深拷贝【绝对的安全】

import copy

# 创建一个原始列表
orig_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 使用深拷贝创建一个新的列表
copied_list = copy.deepcopy(orig_list)

# 修改原始列表中的一个元素
orig_list[1][0] = 'X'

# 输出原始列表和新列表
print("原始列表：", orig_list)
print("新列表：", copied_list)

输出结果：

原始列表： [[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
新列表： [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

元组

• 序列类型
• 元素不支持增删改 （元组：不可变的列表）
• 如果元组里面有列表，那么这个列表是可以变的，顺带着这个元组也就变了
• a=(1,2,3,4,5)
• 元素有位置顺序，通过位置访问：a[0]

打包与解包

• 打包返回

def getnum(a):
    return a*a, a+3
getnum(5)

(25, 8)

• 解包赋值

a,b = (1,8)

• 综合

day=[1,2,3]
week=["Monday","Tuesday","Wednesday"]
for day,week in zip(day,week):
    print(day,week)

1 Monday
2 Tuesday
3 Wednesday

字典

• 映射类型，键 【不可变数据类型：元组、数字、字符串】 值对
• 列表、字典、集合是可变数据类型
• a={11001:"xiaoming", 11002:"xiaohong"}
• 元素没有位置顺序，通过键值访问：a[11001]
• 键不能重复

遍历

my_dict = {
    
    'a': 1, 'b': 2, 'c': 3}  
for key, value in my_dict.items():  
    print(key, value) 

my_dict = {
    
    'a': 1, 'b': 2, 'c': 3}  
for key in my_dict.keys():  
    print(key, my_dict[key])

a 1
b 2
c 3

集合

• 一系列互不相等的元素
• 元素没有位置顺序
• 元素必须是不可变的

集合的运算

1. 集合的并集 (union)：将两个集合中的元素合并成一个新的集合。

set1 = {
    
    1, 2, 3}  
set2 = {
    
    4, 5, 6}  
union_set = set1.union(set2)  
print(union_set)  # 输出：{1, 2, 3, 4, 5, 6}  

2. 集合的交集 (intersection)：找出两个集合中共有的元素组成一个新的集合。

set1 = {
    
    1, 2, 3}  
set2 = {
    
    4, 5, 6}  
intersection_set = set1.intersection(set2)  
print(intersection_set)  # 输出：{ }  

3. 集合的差集 (difference)：找出第一个集合中不属于第二个集合的元素组成一个新的集合。

set1 = {
    
    1, 2, 3}  
set2 = {
    
    4, 5, 6}  
difference_set = set1.difference(set2)  
print(difference_set)  # 输出：{1, 2, 3}  

4. 集合的对称差集 (symmetric difference)：找出两个集合中不相同的元素组成一个新的集合。

set1 = {
    
    1, 2, 3}  
set2 = {
    
    4, 5, 6}  
symmetric_difference_set = set1.symmetric_difference(set2)  
print(symmetric_difference_set)  # 输出：{1, 2, 3, 4, 5, 6}  

5. 集合的笛卡尔积：将两个集合中的元素两两组合成一个新的集合。

set1 = {
    
    1, 2, 3}  
set2 = {
    
    4, 5, 6}  
cartesian_product_set = set1.cartesian_product(set2)  
print(cartesian_product_set)  # 输出：{ (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6) }