文章目录

• 容器类型
• • 1.字符串str
  • 2.通用操作
  • 3.列表list
  • 4.元组tuple
  • 5.字典dict
  • 6.集合set
  • 7.固定集合frozenset
  • 8.烧脑环节：双for循环
• 总结

容器类型

1.字符串str

定义：由一系列字符组成的不可变序列容器，存储的是字符的编码值。
字符串不可变

name = "大强"name = "小强"print(name)#小强

内存图：

编码：

1. 字节Byte ：计算机最小存储单位，等于8位bit。【bit B、KB、MB、G、T】
   1B = 8 bit 1KB =1024B 1MB = 1024KB 1G = 1024MB 1T=1024G （常识）
   

2. 字符∶单个的数字，文字与符号。

3. 字符集(码表)：存储字符与二进制序列的对应关系。

4. 编码∶将字符转换为对应的二进制序列的过程。

5. 解码:将二进制序列转换为对应的字符的过程。

6. 编码方式：

   （1）ASCII编码∶包含英文、数字等字符，每个字符1个字节。字节最大的整数是255。
   （2）GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
   （3）Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
   （4）UTF-8编码（常用）：Unicode的存储与传输方式，英文1字节，中文3字节。

相关函数

"""    str编码"""#字符串—->编码值（数字）num01 = ord( "a")print( num01) #97#编码值（数字）-->字符串str01 = chr(97)print(str01) #a

练习1：在控制台中，获取一个字符串，打印每个字符的编码值。

str = input("请输入一个字符串：")for item in str:    print(ord(item))运行结果：请输入一个字符串：yh121104

练习2：在控制台中，重复录入一个编码值，然后打印字符，如果输入空字符串，则退出程序。

while True:    str_code = input("请输入一个编码值：")    if(str_code == ""): break    code_value = int(str_code)    print(chr(code_value))运行结果：请输入一个编码值：97a请输入一个编码值：98b请输入一个编码值：95_请输入一个编码值：557

字面值+转义符

"""    str字面值    转义符：改变原始字符含义的符号"""name1 ="苏大强"name2 ='苏大强'print(name1)print(name2)# 单引号内的双引号不算结柬符message1 ='我叫"苏大强"。'print(message1)# 双引号内的单引号不算结柬符message2 ="我叫'苏大强'。"print(message2)# 可见即所得name3 = """苏      大强 """   #占用内存，如果是注释不需要占用内存print(name3)# 转义符：\" \n  \t \\   【\a,\b也是，但是不需要掌握】message3 ="我叫\"苏大强\"。"message4 = "我叫\n 苏大强"  #换行message5 ="我叫\t苏大强。"#水平制表格tab键url = "C:\n Users\a10074\b Desktop"url2 = "C:\\Users\\10074\\Desktop"# 原始字符串（没有转义符)url3 = r"C:\Users\10074\Desktop"print(message3)print(message4)print(message5)print(url)print(url2)print(url3)运行结果：苏大强苏大强我叫"苏大强"。我叫'苏大强'。苏      大强 我叫"苏大强"。我叫 苏大强我叫苏大强。C: Users1007 DesktopC:\Users\10074\DesktopC:\Users\10074\Desktop

字符串格式化

# 字符串格式化a = "1"b = "2"# 在字符串中插入变量# 请输入1+2=?# 字符串拼接(缺点：乱)str01 = "请输入"+a+"+"+b+"=?"print(str01)# %s 代表字符串# %d 代表整数# %f 代表浮点数str02 = "请输入%s+%s=?"%(a,b)str03 = "请输入%s+%.1f=?"%("1",10.560)print(str02)print(str03)运行结果：请输入1+2=?请输入1+2=?请输入1+10.6=?

2.通用操作

"""    通用操作str"""str01 ="悟空"str02 ="八戒"# 字符串拼接str03 = str01 + str02print(str03)#悟空八戒# 字符串累加str01 += str02print(str01)#悟空八戒# 重复生成元素print(str02 * 5)#八戒八戒八戒八戒八戒str02 *= 5print(str02)#八戒八戒八戒八戒八戒# 依次比较两个容器中元素,一但不同则返回比较结果。print("悟空">"八戒") # Trueprint("a悟空">"b八戒") # False# 成员运算符print("齐大圣" in "我叫齐天大圣") #Falseprint("齐天大圣" in "我叫齐天大圣")#True

索引（重点，定位单个元素）

#索引（索引是整数）message = "我叫齐天大圣"#获取正数第三个字print(message[2])#齐#获取最后一个字print(message[-1])#圣

切片（重点，定位多个元素）

#切片message = "我叫齐天大圣"print(message[0:2])# 我叫# 开始值默认为开头print(message[:2])# 我叫print(message[-2:-1])# 大# 结束值默认为末尾print(message[-2:])# 大圣print(message[:])# 我叫齐天大圣# 步长默认为1print(message[-2:-5:-1])# 大天齐print(message[::-1])# 圣大天齐叫我print(message[1:1])#空print(message[3:1])#空print(message[3:1:-1])#天齐# (切片不能切断)print(message[-2:1])#空#IndexError: string index out of range，索引不能越界#print(message[7])print(message[2])#齐#切片越界不报错print(message[1:7])#叫齐天大圣

练习1：
在控制台中获取一个字符串，要求如下：

1. 打印第一个字符
2. 打印最后一个字符
3. 打印倒数第三个字符
4. 打印前两个字符
5. 倒序打印字符
6. 如果字符串长度是奇数，则打印中间字符。

str_value = input("请输入一个字符串:")print(str_value[0])print(str_value[-1])print(str_value[-3])print(str_value[:2])print(str_value[::-1])if len(str_value) % 2 == 1:    print(str_value[len(str_value)//2])    运行结果：请输入一个字符串:我是齐天大圣哈我哈大我是哈圣大天齐是我天

练习2：按照以下格式，输出变量name =“悟空”,age = 800,score= 99.5【我叫xx,年龄是xx,成绩是xx。】

print("我是%s,年龄是%d,成绩是%.1f"%("悟空",800,99.5))运行结果：我是悟空,年龄是800,成绩是99.5

练习3：在控制台中获取一个整数作为边长。根据边长打印矩形。【不考虑整数<=1】

side_length = int(input("请输入一个整数："))str01 = "*"str02 = " "print(str01 * side_length)for item in range(side_length-2):    print(str01 * 1+ str02 * (side_length-2)+str01 * 1)print(str01 * side_length)运行结果：请输入一个整数：4*****  **  *****

练习4：在控制台中录入一个字符串，判断是否为回文。【判断规则:正向与反向相同，上海自来水来自海上】

str_value = input("请输入一个字符串：")if str_value == str_value[::-1]:    print("它是回文数")else:    print("它不是回文数")运行结果：请输入一个字符串：上海自来水是来自海上它不是回文数

练习5：(扩展)一个小球从100m的高度落下，每次弹回原高度的一半，计算总共弹起来多少次（最小弹起高度0.01m)，总共走了多少米。

#不知道循环多少次就用while，知道循环多少次就用forheight = 100count = 0distance = height# 弹起前高度大于最小弹起高度# while height > 0.01:# 弹起来的高度大于最小弹起高度while height/2 > 0.01:    count += 1    # 弹起    height /=2    # 累加起/落高度    distance +=  height* 2print("总共弹起来%d次，总共走了%.2f米"%(count,distance))运行结果：总共弹起来13次，总共走了299.98米

3.列表list

定义：由一系列变量组成的可变序列容器。

"""    列表"""# 1．创建列表# 空list01 = []#[]存放数据list02 = list(容器)#存放容器#默认值list03 = ["悟空",100,True]list04 = list("我是齐天大圣")#2.获取元素#索引print(list04[2])#齐#切片print(list04[-4:])#['齐', '天', '大', '圣']#3.添加元素#append 追加 （在末尾添加）list04.append("八戒")print(list04)#['我', '是', '齐', '天', '大', '圣', '八戒']#插入(在指定位置添加）list04.insert(1,True)#在索引为1(第二个)的位置添加Trueprint(list04)#['我', True, '是', '齐', '天', '大', '圣', '八戒']# 4.删除元素# 根据元素删除list04.remove("是")print(list04)#['我', True, '齐', '天', '大', '圣', '八戒']#根据位置删除del list04[0]print(list04) #[True, '齐', '天', '大', '圣', '八戒']del list04[0]print(list04)#['齐', '天', '大', '圣', '八戒']# 5.定位元素，目的可以增删改查。#切片del list04[1:3]print(list04)#['齐', '圣', '八戒']list04[0:2] = ["a","b"]#不会生成新列表print(list04)#['a', 'b', '八戒']list04[0:1] = [1,2,3,4,5,6]print(list04)#[1, 2, 3, 4, 5, 6, 'b', '八戒']list04[0:1] = []print(list04)#[2, 3, 4, 5, 6, 'b', '八戒']#遍历列表#获取列表中所有元素for item in list04:    print(item)# 2# 3# 4# 5# 6# b# 八戒#倒序获取所有元素#不建议#list04[::-1] 通过切片拿元素﹐会重新创建新列表，浪费内存# for item in list04[: :-1]:#     print(item)#正向索引排列# 0 1 2 3# 3 2 1 0for item in range(len(list04)-1,-1,-1):    print(list04[item])# 八戒# b# 6# 5# 4# 3# 2#反向索引排列# -1 -2 -3 -4for item in range(-1,-(len(list04)+1),-1):    print(list04[item])# 八戒# b# 6# 5# 4# 3# 2

练习1：在控制台中录入，西游记中你喜欢的人物，输入空字符串，打印(一行一个)所有人物。

list_person = []# 录入过程while True:    str01 = input("请输入你喜欢的人物：")    if  str01 == "": break    list_person.append(str01)# 输出过程for item in list_person:    print(item)运行过程:请输入你喜欢的人物：悟空请输入你喜欢的人物：八戒请输入你喜欢的人物：唐僧请输入你喜欢的人物：悟空八戒唐僧

练习2：在控制台中录入所有学生成绩，输入空字符串，打印(一行一个)所有成绩，打印最高分，打印最低分，打印平均分。

list_score = []#录入过程while True:    score_input = input("请输入学生成绩:")    if score_input == "": break    list_score.append(int(score_input))#输出过程for item in list_score:    print(item)print("最高分："+str(max(list_score)))print("最低分："+str(min(list_score)))print("最低分："+str(sum(list_score)/len(list_score)))运行结果：请输入学生成绩:54请输入学生成绩:94请输入学生成绩:85请输入学生成绩:38请输入学生成绩:54948538最高分：94最低分：38最低分：67.75

练习3：在控制台中录入所有学生姓名，如果姓名重复，则提示"姓名已经存在”，不添加到列表中，如果录入空字符串，则倒序打印所有学生。
【有多个循环，在最内层里用break语句是跳出最内层循环。】

list_name=[]while True:    name_input = input("请输入学生姓名:")    if name_input == "": break    # 判断变量在列表中是否存在    if name_input not in list_name: list_name.append(name_input)    else: print("姓名已经存在")for item in range(-1,-(len(list_name)+1),-1):    print(list_name[item])运行结果：请输入学生姓名:张三请输入学生姓名:李四请输入学生姓名:张三姓名已经存在请输入学生姓名:李四张三

列表内存图：

"""    列表内存图"""list01 =["张无忌","赵敏"]list02 = list01# 修改的是列表第一个元素。list01[0] ="无忌"print(list02[0])#无忌list01 =["张无忌","赵敏"]list02 = list01# 修改的是list01变量。list01=["无忌"]print(list02[0])#张无忌

list01 = [800,1000]#通过切片获取元素，会创建新列表。list02 = list01[:]list01[0] = 900print (list02[0])#800list01 = [500]print(list02[0])#800

list01 =[800, [1000, 500]]#浅拷贝（默认，深拷贝比浅拷贝更加耗内存）#list02 = list01[:]list02 = list01.copy()list01[1][0] = 900print (list02[1][0])#900

import copylist01 =[800, [1000, 500]]#深拷贝list02 = copy.deepcopy(list01)list01[1][0] = 900print (list02[1][0])#1000

练习1：将列表[54,25,12,42,35,17]中，大于30的数字存入另外一个列表，并画出内存图。

list01 = [54,25,12,42,35,17]list02 = []for item in list01:    if item > 30: list02.append(item)

内存图：

练习2：在控制台中录入5个数字打印最大值。（不使用max)

#假设的最大值max_value = 0for item in range(5):    num_input = int(input("请输入第%d个数字："%(item+1)))    if max_value  < num_input: max_value = num_inputprint(max_value)运行结果：请输入第1个数字：54请输入第2个数字：82请输入第3个数字：34请输入第4个数字：95请输入第5个数字：1795

练习3：在列表中[54，25，12，42，35，17]，选出最大值。(不使用max)

list01 = [54,25,12,42,35,17]max_value = 0for item in list01:    if max_value  < item: max_value = itemprint(max_value)# 或者：list01 = [54,25,12,42,35,17]#假设第一个是最大的max_value = list01[0]#与后面（从第二个开始)元素进行比较#1 2 3 4 5for i in range(1,len(list01)):    if max_value  < list01[i]: # 如果发现更大的，则替换假设的。 max_value = list01[i]print(max_value)运行结果：5454

练习4：在列表中[9，25，12，8]，删除大于10的数字。

#倒着删list01 = [9,25,12,8]for i in range(len(list01)-1,-1,-1):    if list01[i] > 10:list01.remove(list01[i])#删除元素:后一个替换前一个print(list01)运行结果：[9, 8]

字符串与列表区别
字符串：不可变 存储编码值 序列
列表： 存储变量 序列

"""    str  list"""#需求∶根据XX逻辑，拼接一个字符串。# "0123456789"# 缺点∶每次循环形成(+=)一个新的字符串对象，替换变量引用result。【3次以上用列表做】result = ""for item in range(10):    result += str(item)#result = result + str(item)print(result)# 优点∶每次循环只向列表添加字符串﹐没有创建列表对象。list_temp =[]for item in range(10):    list_temp.append(str(item))#join : list --> strresult ="".join(list_temp) #result ="连接符".join(列表)print(type(result))print(result)

练习：在控制台中循环输入字符串，如果输入空则停止。最后打印所有内容（拼接后的字符串)。

list_str= []while True:    str_input = input("请输入字符串:")    if str_input == "": break    list_str.append(str_input)result = "".join(list_str)print(result)

知识点补充

"""    str --> list"""str01 ="张无忌-赵敏-周芷若"list_result = str01.split("-")print(list_result) #['张无忌', '赵敏', '周芷若']

练习：英文单词翻转 “How are you” -->“you are How”

str01 = "How are you"list_result =str01.split(" ")result = " ".join(list_result[::-1])print(result)运行结果：you are How

课后练习1：计算列表中最小值（不使用min）

list01 = [43,54,5]min_value = list01[0]for item in range(1,len(list01)):    if min_value > list01[item]: min_value = list01[item]print(min_value)运行结果：5

内存图：

课后练习2：彩票中双色球︰
红球：6个，1–33 之间的整数 不能重复
蓝球：1个，1–16之间的整数
(1)随机产生一注彩票[6个红球 1个蓝球]。
(2)在控制台中购买一注彩票
提示∶
“请输入第1个红球号码︰”
“请输入第2个红球号码∶”
“号码不在范围内”
“号码已经重复”
“请输入蓝球号码∶”

#randint 左右闭区间,randrange左闭右开”import randomlist_ball = []# 6个不重复的红球while len(list_ball)< 6:    red_ball = random.randrange(1,33)    # 如果随机数不存在，则存储。    if red_ball not in list_ball: list_ball.append(red_ball)#1个蓝球blue_ball = random.randrange(1,16)list_ball.append(blue_ball)print(list_ball)list_num = []#存6个红球 1个蓝球list_num1= []#存1个蓝球count = 1while count < 7:    red_num = int(input("请输入第%d个红球号码:" % count))    if red_num < 1 or red_num > 33: print("号码不在范围内")    else: if red_num not in list_num:     list_num.append(red_num)     count += 1 else:     print("号码已经重复")while True:    blue_num = int(input("请输入蓝球号码:"))    if blue_num < 1 or blue_num > 16: print("号码不在范围内")    else: if blue_num not in list_num1:     list_num.append(blue_num)     breakprint(list_num)# 或者# 6个1--33范围内的不重复红球号码list_ticket = []while len(list_ticket) < 6:    number = int (input ("请输入第%d个红球号码:" % (len(list_ticket)+1)))    if number < 1 or number > 33: print("号码不在范围内")    elif number in list_ticket: print("号码已经重复")    else: list_ticket.append(number)# 1个1--16范围内的蓝球号码while len(list_ticket) < 7:    number = int (input("请输入蓝球号码:"))    if 1 <= number <= 16: list_ticket.append (number)    else: print("号码不在范围内")print(list_ticket)运行结果：请输入第1个红球号码:1请输入第2个红球号码:2请输入第3个红球号码:2号码已经重复请输入第3个红球号码:99号码不在范围内请输入第3个红球号码:3请输入第4个红球号码:4请输入第5个红球号码:5请输入第6个红球号码:6请输入蓝球号码:1[1, 2, 3, 4, 5, 6, 1]

列表推导式（对列表操作简单的时候用）

"""    列表推导式"""#将list0l中所有元素增加1以后存入list02中list0l=[5,56,6,7,7,8,9]# list02 = []# for item in list0l:#     list02. append(item + 1)# print(list02)#[6, 57, 7, 8, 8, 9, 10]list02 = [ item + 1 for item in list0l]print(list02)#[6, 57, 7, 8, 8, 9, 10]#将list0l中大于10元素,增加1以后存入list02中。# list02 = []# for item in list0l:#     if item > 10:#  list02.append(item + 1)# print(list02)#[57]list02 = [item + 1 for item in list0l if item > 10]print(list02)#[57]

练习：
使用range生成1-- 10之间的数字，将数字的平方存入list01中：
（1）将list01中所有奇数存入list02
（2）将list01中所有偶数存入list03
（3）将list01中所有偶数大于5的数字增加1后存入list04

list01 = []for i in range(1,11):    list01.append(i**2)print(list01)list01 = [i**2 for i in range(1,11)]print(list01)list02 = []for item in list01:    if item % 2 ==1 : list02.append(item)print(list02)list02 = [item for item in list01 if item % 2 ==1]print(list02)list03 = [item for item in list01 if item % 2 ==0]print(list03)list04 = []for item in list01:    if item % 2 ==0 and item > 5: list04.append(item+1)print(list04)list04 = [item+1 for item in list01  if item % 2 ==0 and item > 5]print(list04)运行结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100][1, 4, 9, 16, 25, 36, 49, 64, 81, 100][1, 9, 25, 49, 81][1, 9, 25, 49, 81][4, 16, 36, 64, 100][17, 37, 65, 101][17, 37, 65, 101]

4.元组tuple

定义：由一系列变量组成的不可变序列容器。
不可变是指一但创建，不可以再添加/删除/修改元素。（与列表区别：列表可变）
内存图比较：（列表预留空间，元组按需分配）

"""    元组 基础操作"""# 1、创建元组#空tuple01 = ()tuple01 = tuple()#()里面放的是容器#列表--》元组tuple01 = tuple(["a","b"])#元组--》列表list01 = list(tuple01)print(list01)#['a', 'b']#如果元组只有一个元素tuple02 = (100)print(type(tuple02))#inttuple02 = (100,)print(type(tuple02))#tupletuple02 = (100,"a")print(type(tuple02))#tuple#具有默认值tuple01 =(1,2,3)print(tuple01)#(1, 2, 3)#不能增加,修改（不能改变）#2.获取元素（索引，切片）tuple03 = ("a","b","c","d")e01 = tuple03[1]print(type(e01))#'str'e01 = tuple03[-2:]print(type(e01))#'tuple'#切片拿到的类型都是和它对应的类型走，元组用切片得到的还是元组，列表，字符串都是#可以直接将元组赋值给多个变量tuple04 = (100,400) #(100,400)换成[100,400]或者"ab"是一样的，通常用元组a,b = tuple04print(a)#100print(b)#400#3.遍历元素#正向for item in tuple04:    print(item)#反向#1 0#-1 -2for i in range(len(tuple04)-1,-1,-1):    print(tuple04[i])# 400# 100

练习：借助元组完成下列功能。

# month = int(input("请输入月份∶"))# if month < 1 or month > 12:#     print("输入有误")# elif month == 2:#     print("28天")# elif month == 4 or month == 6 or month == 9 or month == 11:#     print("30天")# else:#     print("31天")#方式一：month = int(input("请输入月份∶"))if month < 1 or month > 12:    print("输入有误")elif month == 2:    print("28天")elif month in (4,6,9,11):    print("30天")else:    print(" 31天")#方式二：month = int(input("请输入月份∶"))if month < 1 or month > 12:    print("输入有误")else:    #将每月天数存入元组    day_of_month = (31,28,31,30,31,30,31,31,30,31,30,31)    print(day_of_month[month-1])

练习：在控制台中录入日期(月日)，计算这是这一年的第几天。【例如:3月5日 1月天数+2月天数+5
备注：2月就按照28天算】

day_of_month = (31,28,31,30,31,30,31,31,30,31,30,31)month = int(input("请输入月份∶"))day= int(input("请输入日∶"))#方法一：#累加前几个月天数total_day = 0for item in range(month -1):    day += day_of_month[item]#累加当月天数total_day += dayprint("是这年的第%d天。"%total_day)# 方法二：#累加前几个月天数total_day = sum(day_of_month[:month-1])#累加当月天数total_day += dayprint("是这年的第%d天。"%total_day)运行结果：请输入月份∶2请输入日∶5是这年的第36天。

5.字典dict

定义：由一系列键值对组成的可变映射容器。【与列表区别：键值对、映射】

1. 字典可变的是字典里面的每一个元素是可以变化的。
2. 映射：一对一的对应关系，且每条记录无序。
3. 键必须唯一且不可变(字符串/数字/元组)，值没有限制。
4. 优点：字典定位最快，应用了哈希算法
5. 缺点：利用空间(内存)，换取时间(CPU)
   内存图：
   

"""    字典"""#1.创建#空dict01 ={}dict01 = dict()#默认值dict01 = {"wj":100,"zm":80,"zr":90}print(dict01)#{'wj': 100, 'zm': 80, 'zr': 90}dict01 = dict([("a","b"),("c","d")])print(dict01)#{'a': 'b', 'c': 'd'}#2.查找元素(根据key查找value)print(dict01["a"])#b#如果key不存在，查找时会错误# print(dict01["yh"])if "yh" in dict01:    print(dict01["yh"])#3.修改元素(之前存在key)dict01["a"] = "BB"print(dict01["a"])#BB#4.添加(之前不存在key)dict01["e"] = "f"print(dict01)#{'a': 'BB', 'c': 'd', 'e': 'f'}#5.删除print(dict01)#{'a': 'BB', 'c': 'd', 'e': 'f'}del dict01["a"]print(dict01)#{'c': 'd', 'e': 'f'}#6.遍历(获取字典中所有元素)#遍历字典，获取keyfor key in dict01:    print(key)    print(dict01[key])# c# d# e# f#遍历字典，获取valuefor value in dict01.values():    print(value)# d# f#遍历字典，获取键值对key value(元组)for item in dict01.items():    print(item)# ('c', 'd')# ('e', 'f')#遍历字典，获取键值对key value(元组)for k,v in dict01.items():    print(k)    print(v)# c# d# e# f

练习1：在控制台中循环录入商品信息（名称，单价)。如果名称输入空字符，则停止录入，将所有信息逐行打印出来.

dict01 ={}while True:    goods_name = input("请输入商品名称：")    if goods_name ==  "": break    goods_price = input("请输入商品单价：")    dict01[goods_name] = goods_pricefor k,v in dict01.items():    print("名称是：%s,单价是：%s"%(k,v))#键重复会修改运行结果：请输入商品名称：屠龙刀请输入商品单价：10000请输入商品名称：倚天剑请输入商品单价：10000请输入商品名称：名称是：屠龙刀,单价是：10000名称是：倚天剑,单价是：10000

练习2：在控制台中循环录入学生信息(姓名，年龄，成绩，性别)，如果名称输入空字符，则停止录入，将所有信息逐行打印出来。【提示字典内嵌列表】

dict01_student_info = {}while True:    stu_name = input("请输入学生姓名：")    if stu_name == "": break    stu_age = input("请输入学生年龄：")    stu_score = input("请输入学生成绩：")    stu_sex = input("请输入学生性别：")    dict01_student_info[stu_name] = [stu_age,stu_score,stu_sex]for k,v in dict01_student_info.items():    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(k,v[0],v[1],v[2]))#方法二：dict01_student_info = {}while True:    stu_name = input("请输入学生姓名：")    if stu_name == "": break    stu_age = input("请输入学生年龄：")    stu_score = input("请输入学生成绩：")    stu_sex = input("请输入学生性别：")    list = []    list.append(stu_age)    list.append(stu_score)    list.append(stu_sex)    dict01_student_info[stu_name] = listfor k,v in dict01_student_info.items():    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(k,v[0],v[1],v[2]))运行结果：请输入学生姓名：张三请输入学生年龄：20请输入学生成绩：90请输入学生性别：男请输入学生姓名：李四请输入学生年龄：30请输入学生成绩：23请输入学生性别：女请输入学生姓名：姓名是：张三,年龄：20，成绩：90,性别：男姓名是：李四,年龄：30，成绩：23,性别：女

练习3：在控制台中循环录入学生信息(姓名，年龄，成绩，性别)，如果名称输入空字符，则停止录入，将所有信息逐行打印出来。【提示字典内嵌字典】

dict01_student_info = {}while True:    stu_name = input("请输入学生姓名：")    if stu_name == "": break    stu_age = input("请输入学生年龄：")    stu_score = input("请输入学生成绩：")    stu_sex = input("请输入学生性别：")    dict01_student_info[stu_name] = {"年龄":stu_age,"成绩":stu_score,"性别":stu_sex}for stu_name,dic_info in dict01_student_info.items():    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(stu_name,dic_info["年龄"],dic_info["成绩"],dic_info["性别"]))运行结果：请输入学生姓名：张三请输入学生年龄：20请输入学生成绩：90请输入学生性别：男请输入学生姓名：李四请输入学生年龄：30请输入学生成绩：23请输入学生性别：女请输入学生姓名：姓名是：张三,年龄：20，成绩：90,性别：男姓名是：李四,年龄：30，成绩：23,性别：女

练习3：在控制台中循环录入学生信息(姓名，年龄，成绩，性别)，如果名称输入空字符，则停止录入，将所有信息逐行打印出来。【提示列表内嵌字典】

list01_student_info = []while True:    stu_name = input("请输入学生姓名：")    if stu_name == "": break    stu_age = input("请输入学生年龄：")    stu_score = input("请输入学生成绩：")    stu_sex = input("请输入学生性别：")    list01_student_info.append({"姓名":stu_name,"年龄":stu_age,"成绩":stu_score,"性别":stu_sex})for item in range(len(list01_student_info)):    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(list01_student_info[item]["姓名"],list01_student_info[item]["年龄"],list01_student_info[item]["成绩"],list01_student_info[item]["性别"])) # 或者：for dict_info  in list01_student_info:    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(dict_info["姓名"],dict_info["年龄"],dict_info["成绩"],dict_info["性别"]))运行程序：请输入学生姓名：张三请输入学生年龄：20请输入学生成绩：90请输入学生性别：女请输入学生姓名：李四请输入学生年龄：30请输入学生成绩：20请输入学生性别：男请输入学生姓名：姓名是：张三,年龄：20，成绩：90,性别：女姓名是：李四,年龄：30，成绩：20,性别：男

练习4：在练习3的案例中，获取第一个学生信息。

list01_student_info = []while True:    stu_name = input("请输入学生姓名：")    if stu_name == "": break    stu_age = input("请输入学生年龄：")    stu_score = input("请输入学生成绩：")    stu_sex = input("请输入学生性别：")    list01_student_info.append({"姓名":stu_name,"年龄":stu_age,"成绩":stu_score,"性别":stu_sex})# for item in range(len(list01_student_info)):#     print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(list01_student_info[item]["姓名"],list01_student_info[item]["年龄"],list01_student_info[item]["成绩"],list01_student_info[item]["性别"]))# 或者：for dict_info  in list01_student_info:    print("姓名是：%s,年龄：%s，成绩：%s,性别：%s"%(dict_info["姓名"],dict_info["年龄"],dict_info["成绩"],dict_info["性别"]))#获取第一个学生信息dict_info = list01_student_info[0]print(("第一个录入的是：%s,年龄：%s，成绩：%s,性别：%s")%(dict_info["姓名"],dict_info["年龄"],dict_info["成绩"],dict_info["性别"]))运行结果：请输入学生姓名：张三请输入学生年龄：20请输入学生成绩：20请输入学生性别：男请输入学生姓名：李四请输入学生年龄：30请输入学生成绩：20请输入学生性别：女请输入学生姓名：姓名是：张三,年龄：20，成绩：20,性别：男姓名是：李四,年龄：30，成绩：20,性别：女第一个录入的是：张三,年龄：20，成绩：20,性别：男

总结：

"""#需求：存储多个学生信息(姓名，年龄，成绩,性别)    字典内嵌列表:    { "张无忌" :[28,100,"男"],    }    字典内嵌字典:    { "张无忌" : { "age" : 28, "score" : 100 , "sex" :"男"},    }    列表内嵌字典:    [ { "name" :"张无忌","age" : 28,"score" : 100 , "sex ":"男"}    ]    列表内嵌列表:    [["张无忌",28,100,8],    ]选择策略：根据具体需求，结合优缺点，综合考虑（两害相权取其轻)。    字典： 优点：根据键获取值，读取速度快代码可读性相对列表更高（根据键获取与根据索引获取） 缺点：内存占用大获取值只能根据键，不灵活    列表： 优点：根据索引/切片,获取元素更灵活。相对字典占内存更小。缺点：通过索引获取，如果信息较多，可读性不高。"""

练习：在控制台中录入多个人的多个喜好，输入空字符停止。
例如：请输入姓名∶
请输入第1个喜好∶
请输入第2个喜好∶
… .
请输入姓名∶…
最后在控制台打印所有人的所有喜好。

#字典套列表dict_people_like = {}while True:    name = input("请输入姓名：")    if name == "": break    count = 1    list_people_like = []    while True: like = input("请输入第%s个喜好："% count) if like  == "":     break count += 1 list_people_like.append(like)    dict_people_like[name] = list_people_likefor name,like_info in dict_people_like.items():    print("姓名是:%s,爱好是：%s"%(name,like_info))    运行结果：请输入姓名：张三请输入第1个喜好：看书请输入第2个喜好：打球请输入第3个喜好：请输入姓名：李四请输入第1个喜好：跑步请输入第2个喜好：打篮球请输入第3个喜好：请输入姓名：姓名是:张三,爱好是：['看书', '打球']姓名是:李四,爱好是：['跑步', '打篮球']#或者#或者列表内嵌字典，字典内嵌列表list_person_bobby = []while True:    name = input("请输入姓名∶")    if name == "": break    dict_person = {name:[]}    list_person_bobby.append(dict_person)    while True: bobby = input("请输入喜好∶") if bobby == "":     break dict_person[name].append(bobby)for list_info in list_person_bobby:    print(list_info)运行结果：{'yh': ['1', '1', '23', '4']}{'yhh': ['1', '2', '3', '4']}

课后练习1：将1970年到2050年中的闰年，存入列表。

list_year = []for i in range(1970,2051):    if i % 4 == 0 and i % 100 != 0 or i % 400 == 0: list_year.append(i)#或者（用列表推导式）：list_year = [i for i in range(1970,2051) if i % 4 == 0 and i % 100 != 0 or i % 400 == 0]

课后练习2：存储全国各个城市的景区与美食(不用录入)，在控制台中显示出来。
北京∶
景区∶故宫，天安门，天坛。
美食：烤鸭，炸酱面，豆汁，卤煮。
四川：
景区︰九寨沟，峨眉山，春熙路。
美食：火锅，串串香，兔头。

city = "北京"scenic_spot = "故宫，天安门，天坛"food = "烤鸭，炸酱面，豆汁，卤煮"dict01 = {city:{"景区":[scenic_spot],"美食":[food]}}city = "四川"scenic_spot = "九寨沟，峨眉山，春熙路"food = "火锅，串串香，兔头"dict02 = {city:{"景区":[scenic_spot],"美食":[food]}}list01 = [dict01,dict02]print(list01)for item in list01:    for city,value in item.items(): print(city) for k,v in value.items():     print(k)     for ii in v:  print(ii)运行结果：北京景区故宫，天安门，天坛美食烤鸭，炸酱面，豆汁，卤煮四川景区九寨沟，峨眉山，春熙路美食火锅，串串香，兔头

课后练习3：（扩展）计算一个字符串中的字符以及出现的数。【思想：注意逐一字符出现的次数。如果统计过则增加1，如果没统计过则等于1。】

dict_str = {}str01 = input("请输入字符串:")for item in str01:    if item not in dict_str.keys(): dict_str[item] = 1    else: dict_str[item] += 1print(dict_str)运行结果：请输入字符串:abcdefde{'a': 1, 'b': 1, 'c': 1, 'd': 2, 'e': 2, 'f': 1}

字典推导式

"""    字典推导式"""#1 2 3 4 5 6 7 8 9  10 -》平方dict01 ={}for item in range(1,11):    dict01[item]  = item ** 2print(dict01)#推导式：dict02  = {item: item ** 2 for item in range(1,11)}print(dict02)#只记录大于5的数字dict01 ={}for item in range(1,11):    if item > 5 : dict01[item]  = item ** 2print(dict01)dict02 = {item: item ** 2 for item in range(1,11) if item > 5}print(dict02)运行结果：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}{6: 36, 7: 49, 8: 64, 9: 81, 10: 100}{6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

练习1：
[“无忌”,“赵敏”,“周芷若”]->{“无忌”:2,“赵敏”:2,“周芷若”:3}

list01 = ["无忌","赵敏","周芷若"]dict01 = {}for item in list01:    dict01[item] = len(item)print(dict01)#或者：dict01 = {item:len(item) for item in list01}print(dict01)运行结果：{'无忌': 2, '赵敏': 2, '周芷若': 3}{'无忌': 2, '赵敏': 2, '周芷若': 3}

练习2：[“无忌”,“赵敏”,“周芷若”] 房间号列表[101,102,103]->{“无忌” :101,“赵敏”:102,“周芷若”:103}

list01 = ["无忌","赵敏","周芷若"]list02 = [101,102,103]dict01 = {}for item in range(len(list01)):    dict01[list01[item]] = list02[item]print(dict01)#{'无忌': 101, '赵敏': 102, '周芷若': 103}#或者：dict01 = {list01[item]:list02[item] for item in range(len(list01))}print(dict01)#{'无忌': 101, '赵敏': 102, '周芷若': 103}#需求∶字典如何根据value查找key#解决方案1:键值互换dict02 = {value: key for key,value in dict01.items()}print(dict02)#{101: '无忌', 102: '赵敏', 103: '周芷若'}print(dict02[101])#无忌#缺点:如果key重复,交换(value交换变成key)则丢失数据。#解决方案2:#如果需要保持所有数据[(k,v),]list01 = ["无忌","赵敏","周芷若"]list02 = [101,101,103]dict01 = {list01[item]:list02[item] for item in range(len(list01))}list03 = [(value,key)for key,value in dict01.items()]print(list03)#[('无忌', 101), ('赵敏', 101), ('周芷若', 103)]

6.集合set

数学上的集合：

交集：返回两个集合中相同元素。

并集：返回两个集合中所有不重复的元素。

补集：返回不同的元素。

集合定义：

1. 由一系列不重复的不可变类型变量组成的可变映射容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。

"""    集合set"""#1.创建集合# 空set01 = set()# 字符串变集合set01 = set("abcdc")#()可以放容器print(set01)#{'a', 'b', 'd', 'c'}（去重无序）#集合直接变字符串麻烦，可以先变成列表再变成字符串list01 =list(set01)print(list01)#['a', 'b', 'd', 'c']str01 = "".join(list01)print(str01)#abdcset02 = {"a","b","a"}#这样写用的少print(set02)#{'a', 'b'}# 2．添加元素set02.add("张三")print(set02)#{'a', 'b', '张三'}# 3.删除元素set02.remove("张三")print(set02)#{'a', 'b'}# 4.获取所有元素for item in set02:    print(item)# b# a#5.数学运算set01 = {1,2,3}set02 = {4,2,3}#交集print(set01 & set02)#{2, 3}#并集print(set01 | set02)#{1, 2, 3, 4}#补集print(set01 ^ set02)#{1, 4}print(set01 - set02)#{1}#子集set03 = {1,2}print(set03 < set01)#Trueset03 = {1,2,5}print(set03 < set01)#False#超集set03 = {1,2}print(set01 > set03)#Trueset03 = {1,2,5}print(set01 > set03)#False

练习1：在控制台中循环录入字符串，输入空字符停止，打印所有不重复的文字。

set_str = set()while True:    str_input = input("请输入字符串：")    if str_input == "": break    set_str.add(str_input)for item in set_str: print(item) 运行结果：请输入字符串：q请输入字符串：w请输入字符串：e请输入字符串：q请输入字符串：w请输入字符串：wqe

练习2：在某家公司经理∶曹操，刘备，孙权；技术人员∶曹操，刘备，张飞，关羽
请计算∶
是经理也是技术的有谁?
是经理，不是技术的有谁?
是技术，不是经理的有谁?
张飞是经理吗?
身兼一职的都有谁?
经理和技术总共有多少人?

set01_manager = {"曹操","刘备","孙权"}set02_technician = {"曹操","刘备","张飞","关羽"}print(set01_manager & set02_technician)print(set01_manager - set02_technician)print(set02_technician - set01_manager)print( "张飞" in set01_manager)print(set01_manager ^ set02_technician)print(len(set01_manager | set02_technician))运行结果：{'曹操', '刘备'}{'孙权'}{'张飞', '关羽'}False{'关羽', '张飞', '孙权'}5

7.固定集合frozenset

定义：不可变的集合。
作用：固定集舍可以作为字典的键，还可以作为集合的值。

"""    固定集合"""set01 = frozenset([1,2,3,4,3])print(set01)#frozenset({1, 2, 3, 4})list02 = list(set01)print(list02)#[1, 2, 3, 4]

8.烧脑环节：双for循环

""" for for"""#3行4列print("*",end = "")print("*",end = "")print("*",end = "")print("*",end = "")print()print("*",end = "")print("*",end = "")print("*",end = "")print("*",end = "")print()print("*",end = "")print("*",end = "")print("*",end = "")print("*",end = "")print()# 或者：#外层循环控制行 0     1    2for r in range(3):    #内层循环控制列#0123  0123  0123    for c in range(4): print("*", end="")    print()"""   *#*#*#   *#*#*#   *#*#*#   *#*#*#"""for r in range(4):    for c in range(3): print("*",end="#")    print()# 或者：for r in range(4):    for c in range(6): if(c % 2 == 0):     print("*",end="") else:     print("#", end="")    print()"""      外层4    内层    *0    **      01    ***     012    ****    0123"""for r in range(4):    for c in range(r+1): print("*",end ="")    print()

练习1：列表排序（升序小 --》 大 [3,80,45,5,7,1]
目标：列表中所有元素两两比较
思想：
取出第一个元素，与后面元素进行比较
取出第二个元素，与后面元素进行比较
取出第三个元素，与后面元素进行比较
…
取出倒数第二个元素,与后面元素进行比较
如果取出的元素大于(>)后面的元素，则交换

"""列表排序（升序小 --》 大）[3,80,45,5,7,1]目标：列表中所有元素两两比较思想：取出第一个元素，与后面元素进行比较取出第二个元素，与后面元素进行比较取出第三个元素，与后面元素进行比较...取出倒数第二个元素,与后面元素进行比较如果取出的元素大于(>)后面的元素，则交换"""# 由内到外#取出第一个元素，与后面元素进行比较#list01[0] list01[1]#list01[0] list01[2]#list01[0] list01[3]#for c in range( 1 ,len( list01)):#list01[0]  list01[c]# pass#取出第二个元素,与后面元素进行比较##for c in range(2 ,len (list01)):#list01[1]  list01[c]#pass#取出第三个元素,与后面元素进行比较# #for c in range(3,len (list01) ):#list01[2]  list01[c]#passlist01 = [3,80,45,5,7,1]#取数据for r in range(len(list01)-1):    #作比较    for c in range(r+1,len(list01)): if (list01[r] > list01[c]):    list01[r],list01[c] =list01[c],list01[r]print(list01)#[1, 3, 5, 7, 45, 80]#如果降序排列：list01 = [3,80,45,5,7,1]#取数据for r in range(len(list01)-1):    #作比较    for c in range(r+1,len(list01)): if (list01[r] < list01[c]):    list01[r],list01[c] =list01[c],list01[r]print(list01)#[80, 45, 7, 5, 3, 1]

练习2：判断列表中元素是否具有相同的[3,80,45,5,80,1]
思路∶所有元素俩俩比较，发现相同的则打印结果。所有元素比较结束都没有发现相同项，则打印结彩.

list01 = [3,80,45,2,8,1]#结果：假设没有相同项result = Falsefor r in range(len(list01)-1):    for c in range(r+1,len(list01)): if list01[r] ==list01[c]:     print("具有相同项")     result = Trueif result == False:    print("没有相同项")list01 = [3,80,5,5,5,1]#此程序解决了结果重复输出#结果：假设没有相同项result = Falsefor r in range(len(list01)-1):    for c in range(r+1,len(list01)): if list01[r] ==list01[c]:     print("具有相同项")     result = True     break    if result: breakif result == False:    print("没有相同项")运行结果：没有相同项具有相同项

课后练习1：list01=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
打印第二行第三个元素
打印第三行每个元素
打印第一列每个元素

list01=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]print(list01[1][2])#7for i in list01[2]:    print(i)#9# 10# 11# 12for item in list01:    print(item[0])# 或者for r in range (len(list01)):    print (list01[r][0])# 1# 5# 9# 13

课后练习2：list01=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
矩阵转置将二维列表的列，变成行，形成一个新列表。
第一列变成第一行
第二列变成第二行
第三列变成第三行

list01=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]list02 = []for r in range(len(list01)):    line = []    for c in range(len(list01)):  line.append(list01[c][r])    list02.append(line)print(list02)# 或者：list01=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]list02 = []for r in range(len(list01)):    list02.append([])    for c in range(len(list01)):  list02[r].append(list01[c][r])print(list02)运行结果：[[1, 5, 9, 13], [2, 6, 10, 14], [3, 7, 11, 15], [4, 8, 12, 16]][[1, 5, 9, 13], [2, 6, 10, 14], [3, 7, 11, 15], [4, 8, 12, 16]]

列表推导式嵌套

"""    列表推导式嵌套"""list01 = ["a","b","c"]list02 = ["A","B","C"]list03 = []for r in list01:    for c in list02: list03.append(r+c)print(list03)#['aA', 'aB', 'aC', 'bA', 'bB', 'bC', 'cA', 'cB', 'cC']list04 = [r+c for r in list01 for c in list02 ]print(list04)

练习：列表的全排列。 [“香蕉”，“苹果”,“哈密瓜"],[“可乐",“牛奶"]

list01 = ["香蕉","苹果","哈密瓜"]list02 = ["可乐","牛奶"]list03 = []for r in list01:    for c in list02: list03.append(r+c)print(list03)# 或者list03 = [r+c for r in list01 for c in list02 ]print(list03)运行结果：['香蕉可乐', '香蕉牛奶', '苹果可乐', '苹果牛奶', '哈密瓜可乐', '哈密瓜牛奶']['香蕉可乐', '香蕉牛奶', '苹果可乐', '苹果牛奶', '哈密瓜可乐', '哈密瓜牛奶']

总结

容器
字符串：不可变 存储编码值 序列
列表：可变 存储变量 序列 预留空间 能做增删改查 扩容∶开辟更大的空问 拷贝原有数据 替换引用
元组：不可变 存储变量 序列 按需分配
字典：可变 存储键值对 散列 能做增删改查
集合：相当于只有键没有值的字典
分析代码时候，脑子里面要有内存图

全民K歌