元组是不可变的列表，即元组的值不可更改，因此元组一般只用于只存不取的需求。

因此元组可以被列表取代掉，所以元组相比较列表使用的很少。

优点(相比列表)：列表的值修改后，列表的结构将会发生改变，而元组只需要存储，因此列表占更多内存。

lt = [1,2,3]
lt[0] = 2 # 列表值可更改

1. 作用：元组一创建就被写死了

2. 定义方式：()内用逗号隔开多个元素

lt = list([1,2,3])
tup = tuple((1,2,3))
print(tup,type(tup))

# 如果元组只有一个元素，必须得加逗号
tup1 = (1,)
print(tup1,type(tup1))

3. 使用方法

1. 索引取值

print(tup[0])

2. 索引切片

print(tup[0:3])

3. for循环

for i in tup:
    print(i)

4. 成员运算

print(0 in tup)

5. len长度

print(len(tup))

6. index获取元素索引

print(tup.index(1))

7. count 计算

print(tup.count(2))

字典数据类型内置方法

用途：存多个值，但每一个值都有一个key与之对应，key对值有描述功能。

多用于存的值表示的是不同的状态时。

例如：姓名、年龄、身高、体重、爱好

定义：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。

字符串/列表/字典 --》 常用，他们三个就足够描述时间万物了

其他的数据类型可以被替代--》列表替代元组，redis数据库代替集合

dic = {'name':1}
print(dic)

# 0001
dic = {0:'功能1'，1：'功能2'}
print(dic)

# key为可变类型报错
# dic = {[1,2]:'a'} 
#print(dic)

# dic = {(1,2):'a'}
# print(dic)

使用方法：

优先掌握

1. 按key取值/按key修改值

dic = {'a':1,'b':2,'c':3}
print(dic['a'])
dic['b'] = 4
print(dic)

2. 添加值，没有就添加，有就修改

dic['d'] = 4
print(dic)

3. for循环

for i in dic:
    print(i)

4.成员运算

print('a' in dic)

5. len长度

print(len(dic))

6. 键keys/值values/键值对items

print(dic.keys()) # 看成列表 获取所有key
print(dic.values()) # 获取所有值 也看成列表

print(dic.items())
for i in dic.items(): # 键值对
    print(i)
for a, b in dic.items(): # 键值分开
    print(a,b)

需要掌握

获取get

# dic之get()
dic = {'a': 1, 'b': 2}

print(f"dic.get('a'): {dic.get('a')}")
print(f"dic.get('c'): {dic.get('c')}")

dic.get('a'): 1
dic.get('c'): None

更新update

# 等同于list里面的extend
dic1 = {'a': 1, 'c': 2}
dic2 = {'b': 1, 'd': 2}
dic1.update(dic2)
print(dic1)

给键加值fromkeys

# dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None)

print(f"dic: {dic}")

dic: {'name': None, 'age': None, 'sex': None}

setdefault()

# dic之setdefault()，有指定key不会改变值；无指定key则改变值
dic = {'a': 1, 'b': 2}

print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")

dic.setdefault('a'): 1
dic: {'a': 1, 'b': 2}
dic.setdefault('c'): 3
dic: {'a': 1, 'b': 2, 'c': 3}

有序or无序：无序

可变or不可变：可变

dic = {'a': 1}
print(id(dic))
dic['b'] = 2
print(id(dic))

散列表/哈希表存储数据 --》 相比较列表，插入/删除数据更快

集合类型内置方法(set)

集合可以理解成一个集合体，列表方式求两个集合体的关系运算复杂，因此有了集合数据类型。

用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序

定义：{}内用逗号分隔开多个元素，每个元素必须要不可变类型。

s = {1, 2, 1, 'a'}  # s = set({1,2,'a'})

print(f"s: {s}")

s: {1, 2, 'a'}

s = {1, 2, 1, 'a', 'c'}

for i in s:
    print(i)

1
2
c
a

s = set('hello')

print(f"s: {s}")

s: {'e', 'o', 'h', 'l'}

优先掌握

1. 长度len
2. 成员运算in和not in
3. |并集、union
4. &交集、intersection
5. -差集、difference
6. ^对称差集、symmetric_difference
7. ==
8. 父集：>、>= 、issuperset
9. 子集：<、<= 、issubset

详见nick博客

python深浅拷贝

在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用

针对该列表l1=['a'，'b'，'c'，['d'，'e'，'f']]一般有三种方法，分别为：拷贝（赋值）、浅拷贝、深拷贝

注意：拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的

拷贝

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1

l1.append('g')

print(l1)
print(l2)

['a', 'b', 'c', ['d', 'e', 'f'], 'g']

['a', 'b', 'c', ['d', 'e', 'f'], 'g']

浅拷贝

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)

深拷贝

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)

详见nick博客