Day 02 ：数据类型详解

1. 数字类型 ：int

数字主要是用于计算、运算。

1.1 bit_length()将十进制转化为二进制站的位数

'''
二进制             十进制
0000 0001            1
0000 0010            2
0000 0011            3
0000 0100            4
'''
x = 1
print(x.bit_length())
y = 10
print(y.bit_length())
z = 100
print(z.bit_length())

1.2 数字与字符串转化： int ---> str : str(int) str ---> int : int(str) str必须全部是数字组成

int ---> str : str(int)
str ---> int : int(str) str必须全部是数字组成
count = 1
print(str(count))
letter = '18'
print(int(letter))

2. 布尔值 ： bool

布尔值就两种：True，False。就是反应条件的正确与否。

2.1 布尔型与数字、字符串转化：

int ---> bool：        0 ---> False     非0 ---> True
bool---> int ：        int(True) ---> 1   int(False)---> 0
str ---> bool：        空字符串  ---> False  非空字符串---> True
print(int(True))    # >>> 1
print(int(False))   # >>> 0
print(bool(18))     # >>> True
print(bool(0))      # >>> False
print(bool('a'))    # >>> True
print(bool(''))     # >>> False

3. 字符串：str     可迭代，不可变的

3.1 字符串的拼接

字符串拼接：字符串只能进行"相加"和"相乘"运算。

x = 'Hello'
y = 'World '
z = '！'
print(x+y+z)    # HelloWorld！
x = 'Hello '
print(x*10)    # HelloHelloHelloHelloHelloHelloHelloHelloHelloHello

3.2 字符串的索引

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

l = 'Hello World！'
l1 = l[0]
l2 = l[-1]
l3 = l[-2]
print(l1)    # H
print(l2)    # ！
print(l3)    # d

3.3 字符串的切片

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾首不顾尾）。

l[起始索引:结束索引+1:步长]

l = 'Hello World！'
l1 = l[0:5]     # 第1个字符到第4个字符
l2 = l[:5]      # 第1个字符到第4个字符，0可以省略
l3 = l[0:]      # 第1个字符到最后一个字符，结尾可以省略
l4 = l[:]       # 第一个字符到最后一个字符，开头和结尾都可以省略
l5 = l[0:-1]    # 第一个字符到最后1个字符，不顾尾
l6 = l[0:7:2]   # 第1个字符到第6个字符，步长为2
l7 = l[7:0:-2]  # 反向取字符串，加反向步长
print(l1)       # Hello
print(l2)       # Hello
print(l3)       # Hello World！
print(l4)       # Hello World！
print(l5)       # Hello World
print(l6)       # HloW
print(l7)       # o le

3.4 字符串的常用方法

3.4.1 upper() 字母全部大写 lower() 字母全部小写

l = 'Hello World！'
print(l.upper())    # HELLO WORLD！
print(l.lower())    # hello world！

#例：验证码不区分大小写
code = 'aBcD'.upper()
your_code = input('请输入验证码：').upper()
if your_code == code:
    print('验证成功')

3.4.2 strartswith() 判断以什么为开头   endswith() 判断以什么为结尾　

l = 'Hello World！'
print(l.startswith('h'))          # False
print(l.endswith('！'))           # True
print(l.startswith('l',2,5))      # True 
print(l.endswith('World！'))      # True

3.4.3 strip() 去除首尾的空格，制表符 ，换行符 。不仅仅是去除空格，去除的元素可自定制。

l = ' Hello World！'
l1 = '	Hello World！
'
l2 = '**Hello World！**'
l3 = 'niuHello World！uin'
print(l.strip())        # Hello World！
print(l1.strip())       # Hello World！
print(l2.strip('*'))    # Hello World！
print(l2.lstrip('*'))   # Hello World！**
print(l2.rstrip('*'))   # **Hello World！
print(l3.strip('inu'))  # Hello World！      # 迭代无序的去除首尾的‘i’‘n’‘u’

注：input都加strip
# 例：登录输入用户名密码清空收尾空格
name = input('请输入姓名：').strip()
pwd = input('请输入密码：').strip()
if name == 'niu' and pwd == '123':
    print('登录成功')
print(name)
print(pwd)

3.4.4 replace() 把字符串的旧字符串替换成新的字符串，如果指定第三个参数max，则替换不超过max次。

语法：str.replace(old,new,[max])

l = 'HellO WOrld！'
print(l.replace('O','o'))        # 默认全部替换
print(l.replace('O','o',1))      # 替换1次，只能从前往后替换，指定替换次数，不能指定替换

3.45 split()  字符串 转化 列表 切分

以什么分割，最终形成一个列表此列表不含有这个分割的元素。

l = 'Hello World！'
print(l.split())            # ['Hello','World！']    # 默认以空格分隔
print(l.split('o'))         # ['Hell','W','rld！']   # 默认全部分割
print(l.split('o',1))       # ['Hell','World！']     # 分割1次，第1

3.4.6 join()将列表 转化 字符串 切分

l = 'Hello World！'
l1 = ''.join(l)
print(l1,type(l1))    # Hello World！ <class 'str'>
l2 = '+'.join(l)    
print(l2,type(l2))    # H+e+l+l+o+ +W+o+r+l+d+！ <class 'str'>

s = ['Hello','World','！']
s1 = ''.join(s)
print(s1,type(s1))    # HelloWorld！ <class 'str'>
s2 = '+'.join(s)
print(s2,type(s))    Hello+World+！ <class 'str'>

3.4.7 find() 通过元素找索引 找不到返回-1 index() 通过元素找索引 找不到元素会报错

l = 'Hello World!'
l1 = l.find('llo',2,6)
l2 = l.find('ii')
print(l1,type(l1))         # 2 <class 'int'>    返回的找到的元素的索引
print(l2)        # -1    找不到返回-1

l3 = l.index('llo',2,6)
l4 = l.index('ii')      # substring not found    找不到报错
print(l3)               # 2    返回的找到的元素的索引
# print(l4)             # substring not found    找不到报错

3.4.8 center() 内容居中，总长度自己设定，默认填充为None

l = 'Hello World！'
l1 = l.center(30,)
l2 = l.center(30,'*')
print(l1)       #          Hello World！
print(l2)       # *********Hello World！*********

3.4.9 capitalize 首字母大写其余字母小写

l = 'hello World!'
print(l.capitalize())    # Hello world!

3.4.10 swapcase() 大小写翻转

l = 'Hello World！'
print(l.swapcase())    # hELLO wORLD！ 

3.4.11 title()非字母隔开的每个单词的首字母大写

l = 'helloworld！2hellochina！*hellobeijing！、hello沙河hello！'
print(l.title())     #Hello World！ Hello China！ Hello Beijing！Hello 沙河

3.4.12 format() 格式化输出 三种方法

# 第一种：直接输入
l = '我叫{},今年{}岁，爱好{}'
print(l.format('niu','18','吃'))

# 第二种：通过索引赋值
l1 = '我叫{0}，今年{1}，爱好{2}，希望永远{1}岁！'
print(l1.format('niu',18,'吃'))

# 第三种：通过键赋值
l2 = '我叫{name}，今年{age}，爱好{hobby}，希望永远{age}岁！'
print(l2.format(name='niu',age=18,hobby='吃'))

3.4.13 is系列

l = 'niu123'
print(l.isdigit())      # False     # 字符串由数字组成
print(l.isalnum())      # True      # 字符串由字母或数字组成
print(l.isalpha())      # False     # 字符串由字母组成

3.4.14 len()  返回对象的长度或项目个数； count() 数字字符串的元素出现的个数

l = 'Hello World！ Hello China！ Hello Beijing！'
print(len(l))               # 40
print(l.count('H'))         # 3
print(l.count('H',0,20))    # 2        # 可切片

4. 列表：list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

定义：[]内可以有多个任意类型的值，逗号分隔

4.1 列表的增

append()   追加
l1 = ['hello',123,[11,22,'ABC']]
l1.append(0)                # #增加到最后
l1.append('abc')            # #增加到最后
l1.append(['add',123])      # #增加到最后
print(l1)                   # ['hello', 123, [11, 22, 'ABC'], 0, 'abc', ['add', 123]]

insert() 按照索引插入
l = ['Hello','World','！',123,[11,22,33]]
l.insert(0,'niu')       # 按照索引去增加
print(l)                # ['niu', 'Hello', 'World', '！', 123, [11, 22, 33]]

extend() 迭代的加
l2 = [1,['aa',2],'abc']
l2.extend('0')
l2.extend(['abc',0])
l3 = ['123',0]
l2.extend(l3)            # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
l2.extend('xxx')        # 迭代的增
print(l2)               # [1, ['aa', 2], 'abc', '0', 'abc', 0, '123', 0, 'x', 'x', 'x']

4.2 列表的删

pop() 按照索引删除，返回被删除的值，增删改查中唯一一个有返回值的
l = [1,2,'a,b',['ab',0]]
print(l.pop(3))         # ['ab', 0]

remove() 按照元素去删除
l = [1,2,'a,b',['ab',0]]
l.remove('a,b')         # 删除 字符串元素
l.remove(['ab',0])      # 删除 列表元素
print(l)                # [1, 2]

cleat()  清空列表
l = [1,2,'a,b',['ab',0]]
l.clear()
print(l)            # []

del() # 按照索引、按照切片删除，也可删除列表没有返回值
del() 按索引删除
l = [1,2,'a,b',['ab',0]]
del l[0]        # 按照索引去删除，没有返回值
print(l)        # [2, 'a,b', ['ab', 0]]

del() 按切片删除
l = [1,2,'a,b',['ab',0]]
del l[2:4]      # 按着切片删除，没有返回值
print(l)        # [1,2]

del() 删除列表
l = [1,2,'a,b',['ab',0]]
del l           # 删除列表
print(l)        #  name 'l' is not defined

4.3 列表的改

按照索引改
l = ['hello','world','！']
l[0] = ('Hello')
print(l)        # ['Hello', 'world', '！']
l[2] = 'Hello World！'
print(l)        # ['Hello', 'world', 'Hello World！']

按照切片去改
l = ['Hello','World','！']
l[:2] = 'abc'
print(l)        # ['a', 'b', 'c', '！']
l[:2] = ['Hello World！',11]
print(l)        # ['Hello World！', 11, 'c', '！']
切片加步长去改，加步长 必须一一对应
l = ['H','e','l','l','o',' ','W','o','r','l','d','！']
l[:10:2] = ['bacde',1,2,3,4]        #加步长 必须一一对应
print(l)

4.4 列表的查

# 按照索引去查
l = ['Hello World！',5566,['abc',12]]
print(l[1]) # 5566
print(l[-1]) # ['abc', 12]
 
# 按照切片查询
l = ['Hello World！',5566,['abc',12]]
print(l[:1]) # ['Hello World！'] # 切片
print(l[:3:2]) # ['Hello World！', ['abc', 12]] # 切片加步长
 
# for 循环遍历
l = ['Hello World！',5566,['abc',12]]
for item in l:
print(item)

4.5 其他方法

# len() 长度
l = ['a','b','c','d','e','a']
print(len(l))
 
# count() 某个元素出现的次数
print(l.count('a'))
 
# sort() 正序排序(从大到小)
l.sort()
print(l)
 
reverse()倒叙排序
l.sort(reverse=True) # 倒叙排序（从小到大）
print(l)
 
# reverse() 翻转
l.reverse()
print(l)

4.6 列表的嵌套

l1 = [1, 2, 'abc', ['qUIt ','niu', 99], 6]
# 1,将abc该成Abc
l1[2] = l1[2].capitalize()
print(l1)
#2，将'qUIt变成全部大写。
l1[3][0] = l1[3][0].upper()
print(l1)
# 3，99让其通过数字加1的方式变成 '100'.
l1[-2][-1] = str(l1[-2][-1] + 1)
print(l1)
# 4，99让其通过字符串相加方式变成'100'
l1[-2][-1] = str(l1[-2][-1] )+ '9'
print(l1)

5. 元组：tuple

python的元组与列表类型，不同之处在于元组的元素不能修改（增删改）。

元组使用小括号()，列表使用方括号[]。只读列表，

元组创建很简单，只需要在括号里添加元素，并使用逗号隔开即可。

tu = (1,2,3,'abc',[5566],0)

5.1 元组的查

5.1.1 通过索引去查

print(tu[-2])

5.1.2 通过切片去查

print(tu[3:4]) # 切片
print(tu[:4:2]) # 切片加步长

5.1.3 循环查询

for i in tu:
print(i)
index() 通过元素找索引 count() 元素出现的个数 len() 元素的个数
print(tu.index(2)) # 1
print(tu.count('abc')) # 1
print(tu.count('a')) # 0
print(len(tu)) # 6
元素里的元素可以修改
tu[-2].append(7788)
print(tu) # (1, 2, 3, 'abc', [5566, 7788], 0)

5.2 range 自定义范围

print(range(100))
# 打印 0-99
for i in range(100):
print(i)
# 打印 0-100
for i in range(1,101):
print(i)
加步长 打印1-100的偶数
for i in range(2,101,2):
print(i)
倒着取值，打印100-0
for i in range(100,0,-1):
print(i)

6. 字典：dic

字典的key是唯一的。key必须是不可变的数据类型，value是任意数据类型。

数据类型分类：

不可变数据类型（可哈希）：str，bool,tuple,int。

可变数据类型（不可哈希）：dict，list，set。

容器类数据类型：list，tuple，dict，set。

字典：存储数据多，关系型数据，查询速度快(二分查找)

二分查找：也称折半查找（Binary Search），它是一种高效率的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中的元素按关键字有序排列。

备注：python3.5以前 (包含3.5)，字典无序

python3.6以后 (包含3.6)，进行了优化，不清楚到底是有序还是无序

6.1 字典的增

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.1.1 输入键增加

dic['hobby'] = '吃' # 无则增加
print(dic)
dic['name'] = 'zs' # 有则修改
print(dic)

6.1.2 setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则不会更改或者覆盖。

dic.setdefault('name','ls')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test'}
dic.setdefault('sex')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None}
dic.setdefault('sex','male')
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None}
dic.setdefault('high',178)
print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None, 'high': 178}

6.2 字典的删

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.2.1 pop() 通过键删除

print(dic.pop('name')) # niu # 返回值
print(dic.pop('name',None)) # niu

6.2.2 popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，在python3.6以后，默认删除最后一个键值对

print(dic.popitem()) # 删除最后一个

6.2.3 clear() 清空字典

dic.clear()
print(dic) # {}

6.2.4 del() 删除字典，也可按键删除

del dic # 删除字典 内存级别删除
print(dic) # name 'dic' is not defined 报错，因为在内存级别已经删除
按键删除
del dic['name']
print(dic)

6.3 字典的改

dic = {
'name':'niu' ,
'age':18,
'job':'test'
}

6.3.1 通过键修改

dic['name'] = 'zs' # 无责增加，有责修改。
print(dic) # 将dic里面的键值对覆盖并更新到dic2中，dic不变 。

6.3.2 update() 覆盖并更新

dic = {'name':'niu' , 'age':18,'job':'test'}
dic1 = {'name':'zs','sex':'male','hobby':'吃'}
dic1.update(dic) # 将dic里面的键值对覆盖并更新到dic1中，dic不变 。
print(dic)
print(dic1)

6.4 字典的查

dic = {'name':'niu' ,'age':18,'job':'test'}

6.4.1 通过键去查，查不到键会报错

print(dic['name']) # niu
print(dic['name1']) # niu 查不到键会报错

6.4.2 get() 查不到不会报错，返回None

print(dic.get('name')) # niu
print(dic.get('name1')) # None
print(dic.get('name1','没有此键')) # 没有此键

6.4.3 键keys() 值values() 键值对items()

# 类似于列表的一个容器，没有索引
dic = { 'name':'niu' ,'age':18,'job':'test'}
print(dic.keys()) # dict_keys(['name', 'age', 'job'])
print(list(dic.keys())) # ['name', 'age', 'job']
print(dic.values()) # dict_values(['niu', 18, 'test'])
print(list(dic.values())) # ['niu', 18, 'test']
print(dic.items()) # dict_items([('name', 'niu'), ('age', 18), ('job', 'test')])
print(list(dic.items())) # [('name', 'niu'), ('age', 18), ('job', 'test')] 

6.4.4 for循环取值

dic = { 'name':'niu' ,'age':18,'job':'test'}
for k in dic.keys():
print(k) # name age job
for v in dic.values():
print(v) # niu 18 test
for i in dic.items():
print(i) # ('name', 'niu') ('age', 18) ('job', 'test')
for k,v in dic.items():
print(k,v) # name niu # age 18 # job test

6.4.5 分别赋值

a,b = 1,3
print(a,b) # 1 3
a,b = [11,22]
print(a,b) # 11,22
a,b = b,a
print(a,b) # 3,1
a, b, c, d = ['niu', 'zs', 'li', 'ww']
print(a, b, c, d) # niu zs li ww

6.4.6 公共方法 len()

dic = { 'name':'niu' ,'age':18,'job':'test'}
print(len(dic)) # 3

6.4.7 fromkeys() 创建字典一种，以fromkeys()创建的键值对，如果值是列表的话，多个共用的都是一个列表

dic = dict.fromkeys('abc','666')
print(dic) # {'a': '666', 'b': '666', 'c': '666'}
dic1 = dic.fromkeys(['a','b','c'],'666')
print(dic1) # {'a': '666', 'b': '666', 'c': '666'}
dic2 = dic.fromkeys('abc',[])
dic2['a'].append('666')
print(dic2) # {'a': ['666'], 'b': ['666'], 'c': ['666']}

6.5  字典的嵌套

dic = {'name_list':['zs','ls'],
'l':{
'name':'ww',
'high':178,
}
}
#['zs','ls'] 追加一个元素'niu'，
dic['name_list'].append('niu')
print(dic)
# {'name':'ww','high':178,}增加一个键值对'sex': man，
dic['l']['sex'] = 'man'
print(dic)

 7. 集合

集合：无序不重复的数据类型。它里面的元素必须是可哈希的，但是集合本身是不可哈希的。

　　集合是无序的，没有索引，不能改，只能‘增删查’

1、关系测试，交集，并集，子集，差集

2、去重（列表的去重）

set1={1,'alex',False,(1,2,3)}
l1=[1,1,2,2,3,3,4,5,6,6]
l2=(list(set(l1)))
print(l2)#>>>[1, 2, 3, 4, 5, 6]

7.1 增删查

# 集合的增  无序
set1={'Lily','Lucy'}
set1.add('Lucas')
print(set1) 　　# {'Lucas','Lily','Lucy'}
# 迭代着增加update()
set1={'Lily','Lucy'}
set1.update('Lucas')
print(set1)　　# {'a','Lily','u','c','L','s','Lucy'}
# 集合的删
# remove()按照元素删除
set1={'Lily','Lucy'}
set1.remove('Lucy')
print(set1)#>>>{'Lily'}
# pop()随机删除一个元素
set1={'Lily','Lucy'}
set1.pop()
print(set1)#>>>{'Lucy'}
# clear()清空集合
set1={'Lily','Lucy'}
set1.clear()
print(set1)#>>>set()
# del()内存级别删除集合
set1={'Lily','Lucy'}24delset125print(set1)#报错
# 集合的查
# for循环
for i in set1:
　　print(i) 

7.2 集合其他操作

7.21 交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 & set2 )#>>>{4, 5}
print(set1.intersection(set2))#>>>{4, 5}

7.22 并集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 | set2)#>>>{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))#>>>{1, 2, 3, 4, 5, 6, 7, 8}

7.23 差集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 - set2)#>>>{1, 2, 3}
print(set1.difference(set2))#>>>{1, 2, 3}

7.24 反交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 ^ set2 )#>>>{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))#>>>{1, 2, 3, 6, 7, 8}

7.25 子集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set1 < set2)#>>>True
print(set1.issubset(set2))#>>>True

7.26 超集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set2 > set1)#>>>True
print(set2.(set1))#>>>True

7.27 frozenset不可变集合，让集合变成不可变类型

s=frozenset('abc')
s1=frozenset({4,5,6,7,8})
print(s,type(s))#>>>frozenset({'c', 'b', 'a'}) <class 'frozenset'>
print(s1,type(s1))#>>>frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>

8. 数据类型的补充

# 将索引为奇数对应的元素删除。
l = [11, 22, 33, 44, 55]
del l[1::2]
print(l)
 
# 在循环一个列表时，不要改变列表的大小，这样会影响结果。
# 从后往前删
l1 = [11, 22, 33, 44, 55]
for i in range(len(l1)-1,-1,-1):
if i % 2 == 1:
del l1[i]
print(l1)
 
# 在循环一个字典时，不要改变字典的大小，这样会影响结果。
dic={'k1':'v1','k2':'v2','k3':'v3','a1':'b1'}
l1 = []
for i in dic:
if 'k' in i:
l1.append(i)
for i in l1:
del dic[i]
print(dic)
#tu元组 如果元组里面只有一个元素并且没有逗号隔开，name他的数据类型与该元素一致
tu1=(1)
print(tu1,type(tu1))#>>>1 <class 'int'>
tu2=('Lucy')
print(tu2,type(tu2))#>>>Lucy <class 'str'>
tu3=(['alex',1,2])
print(tu3,type(tu3))#>>>['alex', 1, 2] <class 'list'>

9.  深浅Copy

9.1 先看赋值运算

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

# 对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。

9.2  浅拷贝copy

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048
l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896
 
l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

# 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

9.3 深拷贝deepcopy

import copy
l1 = [1,2,3,['barry','alex']]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304