Python零基础速成班-第3讲-Python基础(中)，list数组、tuple元组、dict字典、set集合

学习目标

学习更多的数据类型
list数组
tuple元组
dict字典
set集合
进阶补充内容：可变与不可变、浅拷贝与深拷贝
课后作业（6必做）

友情提示：
1、将下文中代码拷贝到JupyterNotebook中直接执行即可，部分代码需要连续执行。
2、JupyterNotebook安装教程及期初课程起初准备请参看上一讲。Python零基础速成班-第1讲-认识Python，课程目标，安装环境以及完成第一行代码“hello world”

1、学习更多的数据类型：

示例1：days in a month，将1年中12个月的天数放入数组中

days_in_month = [31,28,31,30,31,30,31,31,30,31,30,31]
days_in_month

[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

数组下标从0开始，所以将0里填入数组的第一个元素，这样数组中1-12月的天数就能对应了

def how_many_days(month):days_in_month = [0,31,28,31,30,31,30,31,31,30,31,30,31]return days_in_month[month]
how_many_days(3)

示例2：嵌套数组

study_member = [["Li",1],["Yuan",2],["Liu",3],["Shi",4],["Ma",5],["Zhuang",6]]
print(study_member)
print(study_member[2])
print(study_member[2][1])

[['Li', 1], ['Yuan', 2], ['Liu', 3], ['Shi', 4], ['Ma', 5], ['Zhuang', 6]]
['Liu', 3]
3

2、数据类型包括以下4种：

1.List 数组

List： L = [1, 2, 3]

2.Tuple 元组

Tuple: T = (1, 2, 3)

3.Dictionary 字典（和JSON格式一致）

Dict: D = {‘a’:1, ‘b’:2, ‘c’:3}

4.Set 集合

Set: S = set([1, 2, 3])或者set: S = {1,2,3}

2.1 List数组

list是有序集合，即对list的元素进行打印，打印的list顺序与原list中元素的顺序一样。list中的元素可以重复。python是一个动态语言，所以不要求list中的元素必须是同一种类型。可以随时对其做增删改操作。

格式为中括号如L = [1, 2, 3]

2.1.1 list数组初始化创建

两种方式：可以直接定义，也可以用list()函数构造器

empty_list = []
another_empty_list = list()
type(another_empty_list)

list

定义一个周一到周五英文名字的数组

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]

上节课学到使用split()可将字符串拆分成数组

weekdays_str = "Monday,Tuesday,Wednesday,Thursday,Friday"
weekdays = weekdays_str.split(",")
print(weekdays)

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

数组可以包含不同类型的元素

obj_list = ["string",1,True,3.1415]
obj_list

['string', 1, True, 3.1415]

二维嵌套数组

empty_list = []
obj_list = ["string",1,True,3.1415]list_of_list = [empty_list,obj_list]
list_of_list

[[], ['string', 1, True, 3.1415]]

根据数组下标取出元素值

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
print(weekdays[0])
print(weekdays[1:3])

Monday
['Tuesday', 'Wednesday']

据数组下标对数组赋值

weekdays[0] = "Sunday"
weekdays

['Sunday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

2.1.2 list数组元素删除del方法

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
del weekdays[0]
weekdays

['Tuesday', 'Wednesday', 'Thursday', 'Friday']

del[m:n]表示删除从第m个元素至第n个元素，不包括n

al = ["a","b","c","d","e","f","g"]
del al[3:4]
al

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

2.1.3 list数组元素删除pop方法

pop()用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
lastday = weekdays.pop()
print("lastday = ",lastday)

lastday =  Friday

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
firstday = weekdays.pop(1)
print("firstday = ",firstday,"\nweekdays = ",weekdays)

firstday =  Tuesday
weekdays =  ['Monday', 'Wednesday', 'Thursday', 'Friday']

del和pop方法

进阶提示：
如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：
1、如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句。
2、如果你要在删除元素后还能继续使用它，就使用方法pop()。
3、pop()方法默认取数组最后一个值，在链表和栈操作中非常实用。

2.1.4 list数组元素删除remove方法

有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove() 。

注意: 方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

“Friday” in weekdays 表示判断某个元素是否还在数组中

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
weekdays.remove("Friday")
print(weekdays)
print("Friday" in weekdays)

['Monday', 'Tuesday', 'Wednesday', 'Thursday']
False

2.1.5 list数组元素增加append和insert方法

append()追加，即在数组最后一个位置追加元素

weekdays = ["Monday","Tuesday","Wednesday","Thursday"]
weekdays.append("Friday")
weekdays

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

weekdays = ["Monday","Tuesday","Wednesday","Thursday"]
weekend = ["Saturday","Sunday"]
week = weekdays + weekend
week

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Saturday', 'Sunday']

insert(index,element)即在数组index位置增加element元素

weekdays = ["Monday","Tuesday","Wednesday","Thursday"]
weekdays.insert(4,"Monday")
weekdays

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Monday']

index()表示数组中某个元素的位置

weekdays = ["Monday","Tuesday","Wednesday","Thursday"]
print(weekdays.index("Wednesday"))
print("Friday" not in weekend)

2
True

2.1.6 (进阶)list数组的效率问题

我们定义一个求程序运行时间的函数timer，定义一个执行数据删除操作的函数delete_element，设置一个包含1亿个数字1的数组
我们分别删除最后一个元素和第一个元素，比较程序耗时情况

import time
#程序运行时间的函数
def timer(f):def _f(*args):t0=time.time()f(*args)return time.time()-t0return _f
#执行数据删除操作的函数
def delete_element(x:'数组',index:'删除位置')->'执行删除操作':del x[index]
#设置一个包含1亿个数字1的数组
x =[1]*100000000print("删除最后一个元素耗时：",timer(delete_element)(x,-1),"秒")
print("删除第一个元素耗时：",timer(delete_element)(x,0),"秒")

删除最后一个元素耗时： 0.0 秒
删除第一个元素耗时： 0.0712127685546875 秒

结论：删除第一个元素比删除最后一个元素明显耗时要多的多，那是因为删除第一个元素会改变整个数组的index索引排序，会让数组重新执行排序并涉及大量元素拷贝，造成效率降低。
而删除最后一个元素不涉及数组index索引重新排序，故效率很高。

2.1.7 list数组排序

sort排序包含两种方法：
1、sort()：直接对List本身排序
2、sorted()：原List不变，返回一个排序后的List

nums = [2,3,4,1,8,7,6]
nums.sort()
nums

[1, 2, 3, 4, 6, 7, 8]

nums = [2,3,4,1,8,7,6]
sored_nums = sorted(nums)
print("nums = ",nums,"\nsorted_nums = ",sored_nums)

nums =  [2, 3, 4, 1, 8, 7, 6]
sorted_nums =  [1, 2, 3, 4, 6, 7, 8]

reverse = True 表示反向（从大到小排序）

nums = [2,3,4,1,8,7,6]
nums.sort(reverse = True)
nums

[8, 7, 6, 4, 3, 2, 1]

包含不同类型的数组排序，会报错’int’ and 'str’不能排序

ogj_list=["string",12,True,3.14]
ogj_list.sort()

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)~\AppData\Local\Temp/ipykernel_1120/94198884.py in <module>1 ogj_list=["string",12,True,3.14]
----> 2 ogj_list.sort()TypeError: '<' not supported between instances of 'int' and 'str'

根据字母顺序逆序

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
sort_weekdays  = sorted(weekdays,reverse=True)
sort_weekdays

['Wednesday', 'Tuesday', 'Thursday', 'Monday', 'Friday']

weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
weekdays.reverse()
print(weekdays)

['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

可以对string字符串进行排序，返回一个List，先排序数字再排序字母

sorted("abc123")

['1', '2', '3', 'a', 'b', 'c']

将排序后的字符串数组还原成字符串，从而实现字符串简单排序功能

x = sorted("abc123")
y= ''.join(x)
print(x)
print(y)

['1', '2', '3', 'a', 'b', 'c']
123abc

2.1.8 list数组拷贝

a = [1,2,3]
b = a
print(a)
print(b)

[1, 2, 3]
[1, 2, 3]

进阶提示：b=a这种拷贝方式，实际是拷贝了数组a的指针，当对数组a内的元素进行修改时，b也会随之改变

a = [1,2,3]
b = a
a[0] = 2
print(a)
print(b)

[2, 2, 3]
[2, 2, 3]

a.copy()，a[ ：]，list(a)这三种方式则是重新创建了一个新的数组，当对数组a内元素进行修改时，新数组不会随之改变，请看下面例子：

a = [1,2,3]
b = ac = a.copy()
d = a[:]
e = list(a)a[0] = 2
print("a=",a,"\nb=",b,"\nc=",c,"\nd=",d,"\ne=",e)

a= [2, 2, 3]
b= [2, 2, 3]
c= [1, 2, 3]
d= [1, 2, 3]
e= [1, 2, 3]

进阶思考：数组存在拷贝指针这种方式，那字符串拷贝呢？

a = "abc"
b = a
a = "xyz"
print(a)
print(b)

xyz
abc

2.2 Tuple元组

元组(tuple)与list数组类似,不同之处在于元组的元素不能修改。元组写在小括号()里,元素之间用逗号隔开。

格式为括号如T = (1, 2, 3)

2.2.1 tuple元组初始化创建

name_tuple = ("Adam","Lily")
name_tuple

('Adam', 'Lily')

(1,2,3,4,5)
type((1,2,3,4,5))

tuple

2.2.2 tuple元组取值

tom_tuple = ("Tom",18,"M")
name,age,sex = tom_tuple
print("name is ",name,",age is ",age,",sex is ",sex)

name is  Tom ,age is  18 ,sex is  M

2.3 Dictionary字典

dict字典使用多个键值对，存储描述一个物体的相关信息，即{“key”:“value”}pair键值对。

dict是无序的，即创建的dict和打印出的dict顺序不一样，而且不同的机器打印出的dict顺序都可能不一样。dict的元素是可以对其进行增、改操作的。dict中的key不能重复，且不能使用可以更改的。因为dict是无序的，所以不能用下标访问，可以用遍历访问读取。

格式为大括号键值对如D = {‘a’:1, ‘b’:2, ‘c’:3}

dict和JSON格式是一样的。

进阶提示：和list比较，dict有以下几个特点：
1、查找和插入的速度极快，不会随着key的增加而增加；需要占用大量的内存，内存浪费多。而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。所以，dict是用空间来换取时间的一种方法。
2、dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
3、这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
4、要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

2.3.1 dict字典初始化创建

我们以pizza披萨为对象，创建一个pizza的dict，包含尺寸、味道、厚度等属性

pizza = {"size":"small","type":"pepperoni","crust":"thick","qty":1,"deliver":True,1:"big"
}
pizza

{'size': 'small','type': 'pepperoni','crust': 'thick','qty': 1,'deliver': True,1: 'big'}

2.3.2 dict字典取值

根据key值取value

pizza["type"]

'pepperoni'

将dict所有key值取到数组中

pizza.keys()

dict_keys(['size', 'type', 'crust', 'qty', 'deliver', 1])

将dict所有value取到数组中

pizza.values()

dict_values(['small', 'pepperoni', 'thick', 1, True, 'big'])

items()同时包含key和value

pizza.items()

dict_items([('size', 'small'), ('type', 'pepperoni'), ('crust', 'thick'), ('qty', 1), ('deliver', True), (1, 'big')])

2.3.3 dict字典更新赋值

我们以pizza的配料属性为key，增加一个value为[‘cheese’, ‘mushroom’]的数组

pizza = {"size":"small","type":"pepperoni","crust":"thick","qty":1,"deliver":True,1:"big"
}
pizza["topping"] = ["cheese","mushroom"]
pizza

{'size': 'small','type': 'pepperoni','crust': 'thick','qty': 1,'deliver': True,1: 'big','topping': ['cheese', 'mushroom']}

2.3.4 dict字典删除

语法：del dict[“key”]

pizza = {"size":"small","type":"pepperoni","crust":"thick","qty":1,"deliver":True,1:"big"
}
del pizza["qty"]
pizza

{'size': 'small','type': 'pepperoni','crust': 'thick','deliver': True,1: 'big'}

2.3.5 dict字典清除

pizza = {"size":"small","type":"pepperoni","crust":"thick","qty":1,"deliver":True,1:"big"
}
pizza.clear()
pizza

{}

2.3.6 dict字典for循环取值

以下分别循环keys，values，items以及加入枚举属性（下一讲会涉及）

pizza = {"size":"small","type":"pepperoni","crust":"thick","qty":1,"deliver":True,1:"big"
}
print("---------for循环求keys---------")
for key in pizza.keys():print("key = ",key)
print("---------for循环求values---------")
for value in pizza.values():print("value = ",value)
print("---------for循环求items---------")
for key,value in pizza.items():print("key =",key,",value =",value)
print("------for循环求items加入枚举属性------")
for index,(key,value) in enumerate(pizza.items()):print(index,"key =",key,",value =",value)

---------for循环求keys---------
key =  size
key =  type
key =  crust
key =  qty
key =  deliver
key =  1
---------for循环求values---------
value =  small
value =  pepperoni
value =  thick
value =  1
value =  True
value =  big
---------for循环求items---------
key = size ,value = small
key = type ,value = pepperoni
key = crust ,value = thick
key = qty ,value = 1
key = deliver ,value = True
key = 1 ,value = big
------for循环求items加入枚举属性------
0 key = size ,value = small
1 key = type ,value = pepperoni
2 key = crust ,value = thick
3 key = qty ,value = 1
4 key = deliver ,value = True
5 key = 1 ,value = big

2.4 Set集合

set持有一系列元素，元素不重复且无序，元素是不变对象（如整型、浮点、tuple等）。因为set是无序的，所以不能用下标访问。

基本用途包括成员测试和消除重复的条目。集合对象还支持数学运算，如并集、交集、差集和对等差分。

格式为大括号如S = {1, 2, 3}

2.4.1 set集合初始化创建

两种方式：可以用函数构造器set([数组对象])创建或者{a,b,c,…}直接创建

set1 = set([1,2,3,"a","b"])
print(set1)
type(set1)

{1, 2, 3, 'a', 'b'}set

set2 = {1,2,3,3,'a','b'}
print(set2)
print(type(set2))

{1, 2, 3, 'b', 'a'}
<class 'set'>

set3 = set('python')
print(set3)

{'t', 'h', 'n', 'p', 'y', 'o'}

2.4.2 新增一个元素到set集合

set4 = {1,2,3,4,'a','b'}
set4.add('c')
print(set4)

{'c', 1, 2, 3, 4, 'b', 'a'}

2.4.3 更新set集合，参数为可迭代对象

set3 = set('python')
set4 = {1,2,3,4,'a','b'}
set3.update('d',"e")
set4.update((5,6,'f'))
print(set3)
print(set4)

{'t', 'e', 'h', 'd', 'n', 'p', 'y', 'o'}
{1, 2, 3, 4, 5, 6, 'b', 'a', 'f'}

进阶提示：
add() 和 update() 比较：
add()：只能添加一个元素到集合
update()：可以添加多个元素到集合，参数为 iterable(可直接作用于for循环的对象统称为可迭代对象)

2.4.4 拷贝set集合并赋值给变量

set4 = {1,2,3,4,'a','b'}
set5 = set4.copy()
print(set5)

{1, 2, 3, 4, 'b', 'a'}

2.4.5 清除set集合所有元素

set4 = {1,2,3,4,'a','b'}
set4.clear()
print(set4)

set()

2.4.6 随机删除set集合中一个元素，可以通过变量来获取删除的元素

set1 = set([1,2,3,"a","b"])
dvalue=set1.pop()
print(dvalue)
print(set1)

1
{2, 3, 'a', 'b'}

2.4.7 删除set集合中指定的元素，如果该集合内没有该元素就报错

set1 = set([1,2,3,"a","b"])
set1.remove("a")
print(set1)set1.remove("c")#没有该元素则报错

{1, 2, 3, 'b'}---------------------------------------------------------------------------KeyError                                  Traceback (most recent call last)~\AppData\Local\Temp/ipykernel_1120/2081543156.py in <module>3 print(set1)4
----> 5 set1.remove("c")#没有该元素则报错KeyError: 'c'

2.4.8 删除set集合中指定的元素，如果该集合内没有该元素也不会报错

set1 = set([1,2,3,"a","b"])
set1.discard("c")
print(set1)

{1, 2, 3, 'a', 'b'}

进阶提示：
pop() 、remove() 、 discard() 三个集合删除函数比较：
1、pop() 随机删除集合中一个元素。
2、remove() 删除集合中指定的元素，如果集合中没有指定的元素，程序报错。
3、discard() 删除集合中指定的元素，如果集合中没有指定的元素，程序正常运行。

2.4.9 求set集合交集 ( & )

交集，返回一个新的集合，包括同时在集合 x 和y中的共同元素。

x = set('rootle')
y = set('google')
print(x & y)
print(x.intersection(y))

{'o', 'l', 'e'}
{'o', 'l', 'e'}

intersection_update()求交集，并赋值给源集合

x = set('rootle')
y = set('google')
x.intersection_update(y)
print(x)
print(y)

{'o', 'l', 'e'}
{'o', 'l', 'e', 'g'}

2.4.10 求set集合并集 ( | )

并集，返回一个新的集合，包括集合 x 和 y 中所有元素。

x = set('rootle')
y = set('google')
print(x | y )
print(x.union(y))

{'e', 'g', 'r', 't', 'o', 'l'}
{'e', 'g', 'r', 't', 'o', 'l'}

2.4.11 求set集合差集 ( - )

差集，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素。

x = set('rootle')
y = set('google')
print(x - y)
print(x.difference(y))

{'t', 'r'}
{'t', 'r'}

x = set('rootle')
y = set('google')
print(y - x)
print(y.difference(x))

{'g'}
{'g'}

difference_update()求差集，并赋值给源集合

x = set('rootle')
y = set('google')
x.difference_update(y)
print(x)

{'r', 't'}

2.4.12 求set集合补集 ( ^ )

补集,返回一个新的集合，包括集合 x 和 y 的非共同元素。

x = set('rootle')
y = set('google')
print(x ^ y )
print(x.symmetric_difference(y))

{'g', 'r', 't'}
{'g', 'r', 't'}

symmetric_difference_update()求交叉补集并赋值给源集合

x = set('rootle')
y = set('google')
x.symmetric_difference_update(y)
print(x)

{'g', 'r', 't'}

2.4.13 冻结set集合

set集合冻结后，没有 add 或者 pop 等方法，如果使用上述方法会报错

s = frozenset('hello')
s.add("c")

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_11724/377968740.py in <module>1 s = frozenset('hello')
----> 2 s.add("c")AttributeError: 'frozenset' object has no attribute 'add'

2.5 list数组、tuple元组、dict字典、set集合类型之间的转换

string to list

list("abc")

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

tuple to list

list((1,2,3,4))

[1, 2, 3, 4]

dict to list，只保留key

list({"name":"L","sex":"Male"})

['name', 'sex']

dict value to list

list({"name":"L","sex":"Male"}.values())

['L', 'Male']

dict items to list

list({"name":"L","sex":"Male"}.items())

[('name', 'L'), ('sex', 'Male')]

set to list

list({2,4,4,6})

[2, 4, 6]

set to list后排序

sorted(list({2,4,6,4}))

[2, 4, 6]

list to dict

dict([(1,2),(2,3)])

{1: 2, 2: 3}

list to dict

dict(["ab","cd","ef"])

{'a': 'b', 'c': 'd', 'e': 'f'}

3、进阶补充内容

3.1 zip() 函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，我们可以使用 list() 转换来输出列表。

s1 = "abcdefg"
s2 = "hijklmn"list(zip(s1,s2))

[('a', 'h'),('b', 'i'),('c', 'j'),('d', 'k'),('e', 'l'),('f', 'm'),('g', 'n')]

s1 = "abcdefg"
s2 = "hijklmn"
d = list(zip(s1,s2))
s3,s4 = zip(*d)
print(s3)
print(s4)
print(list(s4))

('a', 'b', 'c', 'd', 'e', 'f', 'g')
('h', 'i', 'j', 'k', 'l', 'm', 'n')
['h', 'i', 'j', 'k', 'l', 'm', 'n']

3.2 Python数据类型 Mutable（可变） and Immutable（不可变）

python的数据类型分为mutable（可变）和 immutable （不可变）
mutable和immutable 字面意思理解就是说数据可变和数据不可变，由于python的变量不需要声明，而在赋值的时候，变量可以重新赋值为任意值

mutable可变的数据类型 : list ,dict , set
inmutable不可变的数据类型 : int , string , float ,tuple ,bool ,…

执行下列代码数次，你会发现hello字符串的id地址是不变的，而yello和yellos的id地址是变化的

s = "hello"
print("{} id is {}".format(s,id(s)))
s = "yello"
print("{} id is {}".format(s,id(s)))
s = s + "s"
print("{} id is {}".format(s,id(s)))

hello id is 1289502355952
yello id is 1289544017904
yellos id is 1289546011632

执行下列代码数次，你会发现int类型的i的地址均没有变化

i = 1
print("{} id is {}".format(i,id(i)))
i = 10
print("{} id is {}".format(i,id(i)))
i = i + 1
print("{} id is {}".format(i,id(i)))

1 id is 1289430067504
10 id is 1289430067792
11 id is 1289430067824

针对list，除了b的地址不会变化，其他均会发生变化，因为b拷贝的是a的地址，而c、d、e均拷贝且生成了新的list

a = [1,2,3]
print("{} id is {}".format(a,id(a)))
b = a
print("{} id is {}".format(b,id(b)))
c = a.copy()
print("{} id is {}".format(c,id(c)))
d = a[:]
print("{} id is {}".format(d,id(d)))
e = list(a)
print("{} id is {}".format(e,id(e)))

[1, 2, 3] id is 1289551000640
[1, 2, 3] id is 1289551000640
[1, 2, 3] id is 1289541175232
[1, 2, 3] id is 1289545877696
[1, 2, 3] id is 1289544563520

3.3 浅拷贝copy & 深拷贝deepcopy

浅拷贝(copy)：是把原列表第一层的内存地址不加区分(不区分可变类型还是不可变类型)完全copy一份给新列表。
深拷贝(deepcopy)：是copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）

a = {1: [1,2,3]}
b = a.copy()
print("a =",a)
print("b =",b)

a = {1: [1, 2, 3]}
b = {1: [1, 2, 3]}

a 变化后 b也跟随变化

a[1].append(4)
print("a =",a)
print("b =",b)

a = {1: [1, 2, 3, 4]}
b = {1: [1, 2, 3, 4]}

深度拷贝, d完全拷贝了父对象 c及其子对象，两者是完全独立的

import copy
c = {1: [1,2,3,4,5]}
d = copy.deepcopy(c)
print("c =",c)
print("d =",d)

c = {1: [1, 2, 3, 4, 5]}
d = {1: [1, 2, 3, 4, 5]}

c 变化后 d不受影响

c[1].append(6)
print("c =",c)
print("d =",d)

c = {1: [1, 2, 3, 4, 5, 6]}
d = {1: [1, 2, 3, 4, 5]}

4、课后作业，答案在下一讲

1、已知两个升序列表A、B：A=[1,3,4,6,7] B=[1,2,3,4,5,6] 请判断列表A是否是列表B的子集，如果是则返回 True ，否则返回 False 。

您的代码：

2、创建一个[“Monday”,“Tuesday”,“Wednesday”,“Thursday”,“Friday”]数组，用两种方法分别增加Saturday和Sunday并输出，再用三种方法分别删除Mon，Tue，Wed并输出，询问Monday是否还在数组中？

您的代码：

3、创建一个数组a=[11,2.71,True,3.1415,100,0.75,False]，使其降序排列并输出。b数组浅拷贝a；c、d、e组数通过三种方式深拷贝a，修改a数组第一个数字"100"为"1000"，然后分别输出数组abcde。

您的代码：

4、使用数组方式快速排序字符串"ac2b4d13"，返回仍然是String类型。

您的代码：

5、创建一个获取真实获取登录Token的dictionary(命名为token{})

{
“client_id”:“A1”,
“client_secret”:“a1b2c3d”,
“username”:“ROOT”,
“password”:“1c63129ae9db9c60c3e8aa94d3e00495”
}

①分别输出key value item②增加一个属性"grant_type"对应值"usepasswd"，后输出 ③删除属性"password"，后输出④将token的值转化为数组并输出

您的代码：

6、创建一个seta ={1,“x”,True,“y”,5,3}，新增2、4、z三个元素，删除True元素后输出，创建一个setb={1, 3, 4, 5, ‘x’, ‘w’, ‘z’}，分别求seta setb两个集合的交集、并集、差集(seta-setb)、补集。

您的代码：

5、上一讲Python零基础速成班-第2讲-Python基础(上)，运算、变量、数据类型、输入输出课后作业及答案

1、写一个程序读取输入的两个数字，并把数字加起来输出

first_num = input("Please enter the first number:\n>>>")
second_num = input("Please enter the second number:\n>>>")
print(first_num,"+",second_num,"=",int(first_num)+int(second_num))

Please enter the first number:
>>>1
Please enter the second number:
>>>2
1 + 2 = 3

2、动手编程利用Python计算一下公式

21980 + 987345

4950782 - 2340985

3456 * 4390

9285 / 5

57的21次方

98434 / 456 的余数

import math
print(21980 + 987345)
print(4950782 - 2340985)
print(3456 * 4390)
print(9285 / 5)
print(math.pow(57,21))
print(98434 % 456)

1009325
2609797
15171840
1857.0
7.470883585889191e+36
394

3、输入一个数，这个数代表从凌晨0点，过去的分钟数，请计算并输出当前时间

本程序需要输出两个小数：小时（0-23）:分钟（0-59）

例如，如果你输入是150，那么应该是2：30了，所以你程序应该输出2：30

passedmin = int(input("已经过去了多少分钟了？\n>>>"))
hours = passedmin // 60
minute =passedmin % 60
print("当前时间是%s：%s" %(hours,minute))

已经过去了多少分钟了？
>>>700
当前时间是11：40

4、利用Python表达以下公式

b∗(1+r100)nb*(1+\frac{r}{100})^nb∗(1+100r)n
a2+b2b\sqrt \frac{a^2+b^2}{b}ba2+b2

b=r=n=10
b*((1+r/n)**n)

10240.0

import math
a=b=10
math.sqrt((a**2+b**2)/b)

4.47213595499958

*(挑战)5、编程实践项目

小项目：王者荣耀英雄信息提取

目的：在https://pvp.qq.com/web201605/herolist.shtml 中提取头像图片、英雄名称

素材：截取王者荣耀英雄列表HTML文本

结果输出样式：

https://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg

百里守约

HTML素材如下：

女娲
梦奇
百里守约

str ='<ul class="herolist clearfix"><li><a href="herodetail/179.shtml" target="_blank"><img src="//game.gtimg.cn/images/yxzj/img201606/heroimg/179/179.jpg" width="91" height="91" alt="女娲">女娲</a></li><li><a href="herodetail/198.shtml" target="_blank"><img src="//game.gtimg.cn/images/yxzj/img201606/heroimg/198/198.jpg" width="91" height="91" alt="梦奇">梦奇</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="//game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91" height="91" alt="百里守约">百里守约</a></li>'
for i in range(str.count("<li>")):  #循环列表项次数str1 = str[str.find("alt=")+4:str.find("</a>")]  #找到英雄名字print("https:"+str[str.find("<img src=")+10:str.find(".jpg")+4]+"\n"+str1[1:len(str1)//2])  #输出头像链接+英雄名字str = str[str.find("</li>")+5:]  #删除已经循环过的列表项

https://game.gtimg.cn/images/yxzj/img201606/heroimg/179/179.jpg
女娲
https://game.gtimg.cn/images/yxzj/img201606/heroimg/198/198.jpg
梦奇
https://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
百里守约

Python零基础速成班-第3讲-Python基础(中)，list数组、tuple元组、dict字典、set集合相关推荐

Python零基础速成班-第9讲-Python面向对象编程(上)，对象和类、初始化、继承、重写、多态、类方法、组合
Python零基础速成班-第9讲-Python面向对象编程(上),对象和类.初始化.继承.重写.多态.类方法.组合学习目标修饰器面向对象编程:对象和类.初始化.继承.重写.多态.类方法.组合课 ...
Python零基础速成班-第13讲-Python正则表达式Regex
Python零基础速成班-第13讲-Python正则表达式Regex 学习目标正则表达式课后作业(4必做) 友情提示:将下文中代码拷贝到JupyterNotebook中直接执行即可,部分代码需要连 ...
Python零基础速成班-第10讲-Python面向对象编程(下)，Property属性、特殊方法、设计模式、链表应用
Python零基础速成班-第10讲-Python面向对象编程(下),Property属性.特殊方法.设计模式.链表应用学习目标面向对象编程接上一讲:Property属性.特殊方法.设计模式面向 ...
Python零基础速成班-第5讲-Python函数，Function和Lambda基础
Python零基础速成班-第5讲-Python函数,Function和Lambda基础学习目标 Function函数 Lambda Function函数课后作业(4必做) 友情提示:将下文中代码拷 ...
Python零基础速成班-第6讲-Python异常处理Exception，tryexcept，raise，assert，输入模块pyinputplus
Python零基础速成班-第6讲-Python异常处理Exception,try&except,raise,assert,输入模块pyinputplus 学习目标异常处理Exception: ...
Python零基础速成班-第12讲-Python获取网络数据Socket，API接口，网络爬虫Crawler(制作弹幕词云)
Python零基础速成班-第12讲-Python获取网络数据Socket,API接口,网络爬虫Crawler(制作弹幕词云) 学习目标获取网络数据Socket API接口网络爬虫Crawler(制 ...
Python零基础速成班-第11讲-Python日志Logging，小游戏设计game of life
Python零基础速成班-第11讲-Python日志Logging,小游戏设计game of life 学习目标 Python日志Logging 小游戏设计game of life 课后作业(2必做) ...
Python零基础速成班-第8讲-Python文件操作File IO、高级文件处理模块shutil、CSV、JSON、多线程基础
Python零基础速成班-第8讲-Python文件操作File I&O.高级文件处理模块shutil.CSV.JSON.多线程基础学习目标文件操作File I/O 高级文件处理模块shut ...
Python零基础速成班-第14讲-Python处理Excel和Word，使用openpyxl和docx包详解，图表入门
Python零基础速成班-第14讲-Python处理Excel和Word,使用openpyxl和docx包详解,图表入门学习目标 Python处理Excel(使用openpyxl包).图表入门\ P ...
Python零基础速成班-第2讲-Python基础(上)，运算、变量、数据类型、输入输出
Python零基础速成班-第2讲-Python基础(上),运算.变量.数据类型.输入输出学习目标使用print输出结果运算及运算符变量数据类型(4种最常用的) 输入输出课后作业(4必做+1 ...

Python零基础速成班-第3讲-Python基础(中)，list数组、tuple元组、dict字典、set集合

Python零基础速成班-第3讲-Python基础(中)，list数组、tuple元组、dict字典、set集合

学习目标

1、学习更多的数据类型：

示例1：days in a month，将1年中12个月的天数放入数组中

示例2：嵌套数组

2、数据类型包括以下4种：

1.List 数组

2.Tuple 元组

3.Dictionary 字典（和JSON格式一致）

4.Set 集合

2.1 List数组

2.1.1 list数组初始化创建

2.1.2 list数组元素删除del方法

2.1.3 list数组元素删除pop方法

del和pop方法

2.1.4 list数组元素删除remove方法

2.1.5 list数组元素增加append和insert方法

2.1.6 (进阶)list数组的效率问题

2.1.7 list数组排序

2.1.8 list数组拷贝

2.2 Tuple元组

2.2.1 tuple元组初始化创建

2.2.2 tuple元组取值

2.3 Dictionary字典

2.3.1 dict字典初始化创建

我们以pizza披萨为对象，创建一个pizza的dict，包含尺寸、味道、厚度等属性

2.3.2 dict字典取值

2.3.3 dict字典更新赋值

2.3.4 dict字典删除

2.3.5 dict字典清除

2.3.6 dict字典for循环取值

2.4 Set集合

2.4.1 set集合初始化创建

2.4.2 新增一个元素到set集合

2.4.3 更新set集合，参数为可迭代对象

2.4.4 拷贝set集合并赋值给变量

2.4.5 清除set集合所有元素

2.4.6 随机删除set集合中一个元素，可以通过变量来获取删除的元素

2.4.7 删除set集合中指定的元素，如果该集合内没有该元素就报错

2.4.8 删除set集合中指定的元素，如果该集合内没有该元素也不会报错

2.4.9 求set集合交集 ( & )

2.4.10 求set集合并集 ( | )

2.4.11 求set集合差集 ( - )

2.4.12 求set集合补集 ( ^ )

2.4.13 冻结set集合

2.5 list数组、tuple元组、dict字典、set集合类型之间的转换

3、进阶补充内容

3.1 zip() 函数

3.2 Python数据类型 Mutable（可变） and Immutable（不可变）

3.3 浅拷贝copy & 深拷贝deepcopy

4、课后作业，答案在下一讲

1、已知两个升序列表A、B：A=[1,3,4,6,7] B=[1,2,3,4,5,6] 请判断列表A是否是列表B的子集，如果是则返回 True ，否则返回 False 。

2、创建一个[“Monday”,“Tuesday”,“Wednesday”,“Thursday”,“Friday”]数组，用两种方法分别增加Saturday和Sunday并输出，再用三种方法分别删除Mon，Tue，Wed并输出，询问Monday是否还在数组中？

3、创建一个数组a=[11,2.71,True,3.1415,100,0.75,False]，使其降序排列并输出。b数组浅拷贝a；c、d、e组数通过三种方式深拷贝a，修改a数组第一个数字"100"为"1000"，然后分别输出数组abcde。

4、使用数组方式快速排序字符串"ac2b4d13"，返回仍然是String类型。

5、创建一个获取真实获取登录Token的dictionary(命名为token{})

①分别输出key value item②增加一个属性"grant_type"对应值"usepasswd"，后输出 ③删除属性"password"，后输出④将token的值转化为数组并输出

6、创建一个seta ={1,“x”,True,“y”,5,3}，新增2、4、z三个元素，删除True元素后输出，创建一个setb={1, 3, 4, 5, ‘x’, ‘w’, ‘z’}，分别求seta setb两个集合的交集、并集、差集(seta-setb)、补集。

5、上一讲Python零基础速成班-第2讲-Python基础(上)，运算、变量、数据类型、输入输出课后作业及答案

1、写一个程序读取输入的两个数字，并把数字加起来输出

2、动手编程 利用Python计算一下公式

21980 + 987345

4950782 - 2340985

3456 * 4390

9285 / 5

57的21次方

98434 / 456 的余数

3、输入一个数，这个数代表从凌晨0点，过去的分钟数，请计算并输出当前时间

本程序需要输出两个小数：小时（0-23）:分钟（0-59）

例如，如果你输入是150，那么应该是2：30了，所以你程序应该输出2：30

4、利用Python表达以下公式

*(挑战)5、编程实践项目

小项目：王者荣耀英雄信息提取

目的：在https://pvp.qq.com/web201605/herolist.shtml 中提取头像图片、英雄名称

素材：截取王者荣耀英雄列表HTML文本

结果输出样式：

https://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg

百里守约

HTML素材如下：

2、动手编程利用Python计算一下公式