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)

31

示例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 + weekendweek

['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)

2True

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 = aprint(a)print(b)

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

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

a = [1,2,3]b = aa[0] = 2print(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] = 2print("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 = aa = "xyz"print(a)print(b)

xyzabc

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_tupleprint("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 = sizekey = typekey = crustkey = qtykey = deliverkey = 1---------for循环求values---------value = smallvalue = pepperonivalue = thickvalue = 1value = Truevalue = big---------for循环求items---------key = size ,value = smallkey = type ,value = pepperonikey = crust ,value = thickkey = qty ,value = 1key = deliver ,value = Truekey = 1 ,value = big------for循环求items加入枚举属性------0 key = size ,value = small1 key = type ,value = pepperoni2 key = crust ,value = thick3 key = qty ,value = 14 key = deliver ,value = True5 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 1289502355952yello id is 1289544017904yellos id is 1289546011632

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

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

1 id is 128943006750410 id is 128943006779211 id is 1289430067824

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

a = [1,2,3]print("{} id is {}".format(a,id(a)))b = aprint("{} 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 copyc = {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:>>>1Please enter the second number:>>>21 + 2 = 3

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

21980 + 987345

4950782 - 2340985

3456 * 4390

9285 / 5

57的21次方

98434 / 456 的余数

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

10093252609797151718401857.07.470883585889191e+36394

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

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

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

passedmin = int(input("已经过去了多少分钟了？\n>>>"))hours = passedmin // 60minute =passedmin % 60print("当前时间是%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=10b*((1+r/n)**n)

10240.0

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

4.47213595499958

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

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

目的：在/web05/herolist.shtml 中提取头像图片、英雄名称

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

结果输出样式：

/images/yxzj/img06/heroimg/196/196.jpg

百里守约

HTML素材如下：

女娲梦奇百里守约

str ='<ul class="herolist clearfix"><li><a href="herodetail/179.shtml" target="_blank"><img src="///images/yxzj/img06/heroimg/179/179.jpg" width="91" height="91" alt="女娲">女娲</a></li><li><a href="herodetail/198.shtml" target="_blank"><img src="///images/yxzj/img06/heroimg/198/198.jpg" width="91" height="91" alt="梦奇">梦奇</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="///images/yxzj/img06/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:] #删除已经循环过的列表项

/images/yxzj/img06/heroimg/179/179.jpg女娲/images/yxzj/img06/heroimg/198/198.jpg梦奇/images/yxzj/img06/heroimg/196/196.jpg百里守约