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百里守约