列表，元组知识详解（列表的基本特性，常用方法，元组个命名元组， is 和 ==的区别，值的引用，深拷贝和浅拷贝）

1： 列表的创建

序列的概念：成员有序排列，通过下标偏移量可以访问到它的每一个成员（有切片和索引）（字符串，列表，元组）

创建列表
li = [ ]
print(li, type(li))

2：列表的基本特性

2-1：连接操作符和重复操作符；

print([1, 2] + [2, 3])   # [1, 2, 2, 3]
print([1, 2] * 3)        # [1, 2, 1, 2, 1, 2]

2-2：成员操作符(in, not in) 返回值类型为bool型；

print(1 in [1, 2, 3])   #True
print(1 in ["a", True, [1, 2]])   #True (1 就是 true)
print(1 in ["a", Flase, [1, 2]])  #Flase

2-3： 索引 ；

li = [1, 2, 3, [1, 'b', 3]]
print(li[0])  # 1
print(li[-1]) # [1, 'b', 3]
print(li[-1][0])  # 1
print(li[3][-1])  # 3

2-4：切片；

li = ['172', '25', '254', '100']
print(li[:2])  #['172', '25']
print(li[1:])  #['25', '254', '100']
print(li[::-1])  #['100', '254', '25', '172']

练习：已知[‘172’, ‘25’, ‘254’, ‘100’]，输出：“100-254-25”

法1 ：print('-'.join(li[3:0:-1]))
法2 ：li2 = [li[-1], li[-2], li[-3]]
     print("-".join(li2))
法3：print("-".join(li[1:][::-1]))

2-5：for循环；

names = ['斌', '阿斌', '煜煜']
for i in names:
     print(f"{i}")

3：列表常用方法详解

3-1.增加

# 1-1). 追加
li = [1, 2, 3]
li.append(4)
print(li)  #[1, 2, 3, 4]

# 1-2). 在列表开头添加
li = [1, 2, 3]
li.insert(0, 'cat')
print(li)  #['cat', 1, 2, 3]

# 1-2). 在索引2前面添加元素cat
li = [1, 2, 3]
li.insert(2, 'cat')
print(li)  #[1, 2, 'cat', 3]

# 1-3). 一次追加多个元素
li = [1, 2, 3]  # 添加4， 5， 6
li.extend([4, 5, 6])  
print(li)  #[1, 2, 3, 4, 5, 6]

3-2:修改

# 2. 修改: 通过索引和切片重新赋值的方式。
li = [1, 2, 3]
li[0] = 'cat'
li[-1] = 'westos'
print(li)  #['cat', 2, 'westos']
li = [1, 2, 3]
li[:2] = ['cat', 'westos']
print(li)  #['cat', 'westos', 3]

3-3：查看

# 3. 查看: 通过索引和切片查看元素。 查看索引值和出现次数。
li = [1, 2, 3, 1, 1, 3]
print(li.count(1))   # 3   值为1出现的次数
print(li.index(3))   # 2   值为3是第几个索引 （只找第一个出现的） 

3-4：删除

# 4. 删除
# 4-1). 根据索引删除
li = [1, 2, 3]
# 将pop方法的结果存储到delete_num变量中。
delete_num = li.pop(-1)
print(li)  #[1, 2]
print("删除的元素是:", delete_num)

# 4-2). 根据value值删除
li = [1, 2, 3]
li.remove(1)
print(li)  #[2, 3]

# 4-3). 全部清空
li = [1, 2, 3]
li.clear()
print(li) #[]

3-5：其他操作

# 5. 其他操作
li = [18, 6, 99, 56]
li.reverse()  # 类似于li[::-1]
print(li) #[56, 99, 6, 18]

# sort排序默认由小到大。 如果想由大到小排序，设置reverse=True
li.sort()
print(li)  #[6, 18, 56, 99]

li.sort(reverse=True)
print(li) #[99, 56, 18, 6]

li1 = li.copy()
print(id(li), id(li1)) #内存地址不同，值相同
print(li, li1)

4：元组

# 元组tuple(戴了紧箍咒的列表, 不能修改元素)
# 1. 元组的创建
t1 = ()    # 空元组
print(t1, type(t1))  #() <class 'tuple'>
t2 = (1,)   # 重要(易错点):元组只有一个元素时一定要加逗号
print(t2, type(t2)) #(1,) <class 'tuple'>
t3 = (1, 1.2, True, [1, 2, 3])
print(t3, type(t3)) #(1, 1.2, True, [1, 2, 3]) <class 'tuple'>

# 2. 特性
print((1, 2, 3) + (3,)) #(1, 2, 3, 3)
print((1, 2, 3) * 2) #(1, 2, 3, 1, 2, 3)
print(1 in (1, 2, 3)) #True
t = (1, 2, 3)
print(t[0]) #1
print(t[-1])  #3
print(t[:2]) #(1, 2)
print(t[1:]) #(2, 3)
print(t[::-1]) #(3, 2, 1)

# 3. 常用方法: 元组是不可变数据类型(不能增删改)
# 查看: 通过索引和切片查看元素。 查看索引值和出现次数。
t = (1, 2, 3, 1, 1, 3)
print(t.count(1))   # 3
print(t.index(3))   # 2

5：命名元组

tuple = ("westos", 18, "西安")
print(tuple[0], tuple[1], tuple[2])

# 从collections模块中导入namedtuple工具。
from collections import  namedtuple
# 1. 创建命名元组对象User
User = namedtuple('User', ('name', 'age', 'city'))
# 2. 给命名元组传值
user1 = User("westos", 18, "西安")
# 3. 打印命名元组
print(user1)
# 4. 获取命名元组指定的信息
print(user1.name)
print(user1.age)
print(user1.city)

6：is 和 = = 的区别

"""
python语言:
    ==: 类型和值是否相等
    is: 类型和值是否相等， 内存地址是否相等

"""
print(1 == '1')   # False
li = [1, 2, 3]
li1 = li.copy()
print(li == li1)  # True

# 查看内存地址
print(id(li), id(li1))  内存地址不同
print(li is li1)  # False

7：值的引用，深拷贝和浅拷贝

# 1. 值的引用()（赋值，两个变量指向同一个地址，改变任意一个，另一个都改变）
nums1 = [1, 2, 3]
nums2 = nums1
nums1.append(4)
print(nums2)   # 1, 2, 3, 4


# 2. 拷贝：浅拷贝和深拷贝
# 2-1). 浅拷贝
n1 = [1, 2, 3]
n2 = n1.copy()   # n1.copy和n1[:]都可以实现拷贝。
print(id(n1), id(n2)) #地址不同
n1.append(4) 
print(n2) #[1, 2, 3]


"""
可变数据类型(可增删改的): list
不可变数据类型:数值，str， tuple， namedtuple
"""
n1 = [1, 2, [1, 2]]
n2 = n1.copy()
# n1和n2的内存地址:的确拷贝了(地址不同)
print(id(n1), id(n2))
# n1[-1]和n2[-1]的内存地址:(地址相同 （浅拷贝）)
print(id(n1[-1]), id(n2[-1]))
n1[-1].append(4) # 地址相同，因此更改n1，n2也会变
print(n2)  # [1, 2, [1, 2, 4]]


# 2-2). 深拷贝
import copy
m1 = [1, 2, [1, 2]]
m2 = copy.deepcopy(m1)
m1[-1].append(4)
print("m2 is ", m2) # m2 is  [1, 2, [1, 2]]
print("m1 is ", m1) # m1 is  [1, 2, [1, 2, 4]]

#帮助理解：拷贝：在新的地址中存要拷贝的值，浅拷贝只拷贝了第一层，只有外层列表的地址不同（在列表中还有列表时地址会共用（相同）），深拷贝：每一层都拷贝，因此每一层的地址都不同

如何实现深拷贝？
深拷贝：
如果列表的元素包含可变数据类型，一定要使用深拷贝
import copy
copy.deepcopy()