pt02-list-tuple-dir

容器类型

通用操作

数学运算符

(1) +   用于拼接两个容器
(2) +=  用原容器与右侧容器拼接,并重新绑定变量
(3) *   重复生成容器元素
(4) *=  用原容器生成重复元素, 并重新绑定变量
(5) == !=：依次比较两个容器中元素,一但不同则返回比较结果。< <= > >= 意义不大

//输入整数，打印出正方形
number = int(input("请输入边长："))
print("*" * number)
for item in range(number-2):      #用不到的item，一般写成__print("*%s*"%(" " * (number-2)))
print("*" * number)

number = int(input("请输入边长："))
for item in range(number):if item == 0 or item == number-1:print("*" * number)else:print("*%s*"%(" " * (number-2)))

成员运算符

(1) 语法：数据 in 序列, 数据 not in 序列

(2) 作用：如果在指定的序列中找到值，返回bool类型。

练习：注意下else的位置
如果账号qwe,密码123,输入账户密码验证。提示剩余输入次数，错误3次·提示锁定账户。
for count in range(3):login_id = input("请输入账号：")password = input("请输入密码：")if login_id == "qwe" and password == "123":print("登录成功")breakelse:print("登录失败")print("还可以登录%d次"%(2-count))print(f"还可以登录{2-count}次")  #f-string，python3.6以上支持
else:print("锁定了")

索引index

(1) 作用：定位单个容器元素。

(2) 语法：容器[整数]

正向索引从0开始，第二个索引为1，最后一个为len(s)-1。

反向索引从-1开始，-1代表最后一个，-2代表倒数第二个，以此类推，第一个是 -len(s)。

message = "我是花果山齐天大圣"
print(message[2]) # 花
print(message[-2]) # 大
print(len(message)) # 9

切片slice

(1) 作用：定位多个容器元素。 语法：容器[开始索引:结束索引:步长]

结束索引不包含该位置元素，步长是切片每次获取完当前元素后移动的偏移量，开始、结束和步长都可以省略。

message = "我是花果山齐天大圣" 
print(message[2:5:1]) # 花果山 
print(message[2:5:1][1]) # 果
print(message[1:5]) # 是花果山 
print(message[2:-4]) # 花果山 
print(message[:-4]) # 我是花果山 
print(message[:]) # 我是花果山齐天大圣 
print(message[-3:]) # 天大圣 
print(message[:2]) # 我是 
print(message[-2:]) # 大圣 
print(message[-2:3:-1]) # 大天齐山 
print(message[1:1]) # 空 
print(message[2:5:-1]) # 空
# 特殊:翻转 
print(message[::-1]) # 圣大天齐山果花是我

内建函数

(1) len(x) 返回序列的长度
(2) max(x) 返回序列的最大值元素
(3) min(x) 返回序列的最小值元素
(4) sum(x) 返回序列中所有元素的和(元素必须是数值类型)

字符串 str

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

基础知识

(1) 字节byte：计算机最小存储单位，等于8 位bit.
(2) 字符：单个的数字，文字与符号。
(3) 字符集(码表)：存储字符与二进制序列的对应关系。
(4) 编码：将字符转换为对应的二进制序列的过程。
(5) 解码：将二进制序列转换为对应的字符的过程。

编码方式

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

number  =ord("我")
print(number)
25105

char =chr(25105)
print(char)
我

将输入的内容打印每个文字的编码值
for item in input("请输入"):print(ord(item))

循环输入编码值，打印出文字，为空时退出
while True:code_value = input("请输入编码值")if code_value == "":breakprint(chr(int(code_value)))

字面值

单引和双引号一样，推荐使用双引号
三引号作用：作为文档字符串，输入的什么，打印出的就是什么，会自动转换\n换行

转义字符&取消全部转义

(1) 定义：改变字符的原始含义。

\'		 \"		 \n		 \\ 		\t

原始字符串：取消转义。字符前加 r 取消字符串所有转移

a = r"C:\newfile\test.py"
b = "C:\newfile\test.py"
print(a)
print(b)C:\newfile\test.py
C:
ewfile	est.py

字符串格式化

(1) 定义：生成一定格式的字符串。

(2) 语法：字符串%(变量)

name="tom"
age="18"
print("我的名字是%s,年龄是%s"%(name,age)) 

(3) 类型码：

%s 字符串 %d整数 %f 浮点数

print("%.2d:%.2d"%(2,3)) # 时间 02:03 
print("治愈比例为%d%%" % 5) # 治愈比例为5%     %%打印出了%
print("价格%.2f元" % (5 / 3)) # 价格1.67元

"""练习：根据下列文字，提取变量，使用字符串格式化打印信息湖北确诊67802人,治愈63326人,治愈率0.9970秒是01分零10秒
"""
region = "湖北"
confirmed = 67802
cure = 63326
print("%s确诊%s人,治愈%s人,治愈率%.2f" % (region, confirmed, cure, cure / confirmed))
print("%s确诊%s人,治愈%s人,治愈率%.2f%%" % (region, confirmed, cure, cure / confirmed * 100))
//python3.6以上支持
print(f"{region}确诊{confirmed}人,治愈{cure}人,治愈率{(cure / confirmed * 100):.2f}%%")
second = 70
print("%s秒是%.2d分零%.2d秒" % (second, second // 60, second % 60))
print(f"{}")

f-srting 学习 高版本python支持

jin = 2
liang = 3
print("结果为：" + str(jin) + "斤" + str(liang) + "两")
print("结果为：%s斤%s两" % (jin, liang))
print(f"结果为：{jin}斤{liang}两")

"""    赌大小游戏玩家的身家初始10000，实现下列效果：少侠请下注: 30000超出了你的身家，请重新投注。少侠请下注: 8000你摇出了5点,庄家摇出了3点恭喜啦，你赢了，继续赌下去早晚会输光的，身家还剩18000少侠请下注: 18000你摇出了6点,庄家摇出了6点打平了，少侠，在来一局？少侠请下注: 18000你摇出了4点,庄家摇出了6点少侠,你输了，身家还剩 0哈哈哈，少侠你已经破产，无资格进行游戏
"""
import randommoney = 10000
while money > 0:bet = int(input("少侠请下注: "))if bet > money:print("超出了你的身家，请重新投注。")continuedealer = random.randint(1, 6)player = random.randint(1, 6)# print("你摇出了%s点,庄家摇出了%s点" % (player, dealer))print(f"你摇出了{player}点,庄家摇出了{dealer}点")if dealer > player:money -= betprint("少侠,你输了，身家还剩" + str(money))elif dealer < player:money += betprint("恭喜啦，你赢了，继续赌下去早晚会输光的，身家还剩" + str(money))else:print("打平了，少侠，在来一局？")
print("哈哈哈，少侠你已经破产，无资格进行游戏")

一个小球从100米高度落下，每次弹回原高的一半计算，最小的弹回高度0.01米
--总共弹起多少次?(最小弹起高度0.--全过程总共移动多少米?
height =100
count=0
distance =height
while height/2 > 0.01: #弹起高度height/=2count+=1distance+=height*2print(f"第{count}次弹起的高度是{height/2}")
print(f"一共弹起{count}次")
print(f"移动的总长度是{distance:.2f}米")

列表list[] 可变

由一系列变量组成的可变序列容器。预留空间，自动扩容。可排序

基础操作

(1) 创建列表：

列表名 = [] 
列表名 = list(可迭代对象)

list_ages = [26, 23, 25, 16] 
list_name = list("孙悟空") 
print(list_name) # ['孙', '悟', '空']

(2) 添加元素：

列表名.append(元素)
列表名.insert(索引，元素)

list_names.append("小白龙")
list_names.insert(2, "哪吒") 
print(list_names) # ['悟空', '唐三藏', '哪吒', '八戒', '沙僧', '小白龙']

(3) 定位元素：

列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。

element = list_names[-1] 
print(element) # 小白龙
list_names[-1] = "二郎神"    #修改
print(list_names) # ['悟空', '唐三藏', '哪吒', '八戒', '沙僧', '二郎神']

(4) 遍历：

正向：for 变量名 in 列表名:变量名就是元素反向：for 索引名 in range(len(列表名)-1,-1,-1):列表名[索引名]就是元素

list_names=['悟空', '唐三藏', '哪吒', '八戒', '沙僧', '二郎神']
for i in range(len(list_names) - 1, -1, -1):print(list_names[i])      #反向打出来了

list_names=['悟空', '唐三藏', '哪吒', '八戒', '沙僧', '二郎神']
for i in range(len(list_names)):#if xxxx:list_names[i] = "xxx"
print(list_names)   #['xxx', 'xxx', 'xxx', 'xxx', 'xxx', 'xxx']

(5) 删除元素：

列表名.remove(元素)
del 列表名[索引或切片] 

list_names.remove("八戒") # 
根据定位删除 del 容器名[索引或者切片] 
del list_names[0] 
del list_names[-2:]   倒数第二个开始，全删

"""八大行星："水星" "金星" "地球" "火星" "木星" "土星" "天王星" "海王星"-- 创建列表存储4个行星：“水星” "金星" "火星" "木星"-- 第三个位置插入"地球"、追加"土星" "天王星" "海王星"-- 打印第一个和最后一个元素-- 打印太阳到地球之间的行星(前两个行星)-- 删除"海王星",删除第四个行星-- 倒序打印所有行星(一行一个)
"""
list_planet = ["水星", "金星", "火星", "木星"]
list_planet.insert(2, "地球")
list_planet += ["土星", "天王星", "海王星"]
print(list_planet[0])
print(list_planet[-1])
print(list_planet[:2])
list_planet.remove("海王星")
del list_planet[3]
for i in range(len(list_planet)-1,-1,-1):print(list_planet[i])

深拷贝和浅拷贝了解

浅拷贝：复制过程中,只复制一层变量，不会复制深层变量绑定的对象的复制过程。
只备份一层，如果深层数据被修改将被影响。

深拷贝：复制整个依懒的变量。复制了整块内存，多画画内存图
复制所有数据，占用内存较多。

适用性：没有深层数据时，使用浅拷贝

list01 = ["北京", "上海"]
list02 = list01 # 列表1个,变量2个。     #赋值,没有产生列表复制
print(list02)	#['北京', '上海']
list01[0] = "广东"	
print(list02)	#['广东', '上海']      #list02指向list01的内存数据
list03 = list01[:]                   #切片，创建新列表
print(list03)	#['广东', '上海']
list03[-1] = "深圳" 					# 新列表被修改,不影响原列表
print(list03)	#['广东', '深圳']
print(list01)	#['广东', '上海']
print(list02)	#['广东', '上海']

import copylist01 = ["北京",["上海","深圳"]]
list02 = list01
list03 = list01[:]
list03[0] = "北京03"   #浅拷贝，修改浅拷贝的第一层数据，互不影响list01[0]仍是北京
list03[1][1] = "深圳03"   #修改浅拷贝的第二层，将会影响，list01[1][1]的深圳将变化为深圳03
print(list01) # ['北京', ['上海', '深圳03']]
list02[0] = "北京02"
list02[1][1] = "深圳02"
print(list01) # ['北京02', ['上海', '深圳02']]list04 = copy.deepcopy(list01)  # ['北京02', ['上海', '深圳02']]  #深拷贝
list04[0] = "北京04"
print(list04)   #['北京04', ['上海', '深圳02']]
list04[1][1] = "深圳04"    #修改深拷贝的数据，互补影响，list01不会变化
print(list04)   #['北京04', ['上海', '深圳04']]
print(list01)   # ['北京02', ['上海', '深圳02']]

列表与字符串转换

(1) 列表转换为字符串： result = “连接符”.join(列表)

list01 = ["a", "b", "c"]
result = "-".join(list01)    #-可替换，如“”为空  将输出abc
print(result)   #a-b-c

result = []
for  number in range(10):result.append(str(number))
result="".join(result)
print(result)    #0123456789

输入内容，对内容进行拼接，当输入为空时，结束输入并打印出结果
result = []
while True:content =input("请输入内容")if content == "":breakresult.append(content)
result = "".join(result)
print(result)

练习

根据列表中的数字,重复生成*.list01 = [1, 2, 3, 4, 5, 4, 3, 2, 1]效果：*************************
list01 = [1, 2, 3, 4, 5, 4, 3, 2, 1]
for number in list01:print("*"*number)

根据列表中的数字,重复生成*.list02 = [1, 2, 3, 4, 5]效果：***************list02 = [1, 2, 3, 4, 5]
for i in range(len(list02)-1,-1,-1):print("*"*list02[i])

将列表中的数字累乘 list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]  结果：806400list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
result =1
for item in list02:result*=item
print(result)

(2) 字符串转换为列表：列表 = “a-b-c-d”.split(“分隔符”)
场景：使用一个字符串存储多个信息时

list_result = "唐僧,孙悟空,八戒".split(",")[0]
print(list_result)    #取出了唐僧

将下列英文语句按照单词进行翻转.
转换前：To have a government that is of people by people for people
转换后：people for people by people of is that government a have Tocontent = "To have a government that is of people by people for people"
list_temp = content.split(" ")
#print(list_temp[::-1])
result = " ".join(list_temp[::-1])
print(result)

列表推导式

(1) 定义：使用简易方法，将可迭代对象转换为列表。

(2) 语法：

变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]

(3) 说明: 如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

list01 = [9, 15, 65, 6, 78, 89]
# 需求:在list01中挑出能被3整除的数字存入list02 #
list02 = []
#for item in list01:
#    if item % 3 == 0:
#        list02.append(item)
list02 = [item for item in list01 if item % 3 == 0]
print(list02)

# 需求:在list01中所有数字的个位存储list03 
# list03 = [] 
# for item in list01: 
# list03.append(item % 10) 
list03 = [item % 10 for item in list01] 
print(list03)

生成10--30之间能被3或者5整除的数字
# list_result = []
# for number in range(10, 31):
#     if number % 3 == 0 or number % 5 == 0:
#         list_result.append(number)
# print(list_result)list_result = [number for number in range(10, 31) if number % 3 == 0 or number % 5 == 0]
print(list_result)

生成5 -- 20之间的数字平方
list_result = [item ** 2 for item in range(5, 21)]
print(list_result)

元组 tuple()不可变

(1) 由一系列变量组成的不可变序列容器，按需分配。节省内存，优先选择

(2) 不可变是指一但创建，不可以再添加/删除/修改元素。

基础操作

(1) 创建空元组：

元组名 = ()           
元组名 = tuple()

(2) 创建非空元组：

元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)

(3) 获取元素：

变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表

(4) 遍历元组：

正向：for 变量名 in 列表名:变量名就是元素反向：for 索引名 in range(len(列表名)-1,-1,-1):元组名[索引名]就是元素

# 1. 创建 
# -- 元组名 = (元素1, 元素2, 元素3) 
tuple01 = (10, 20, 30) 
# -- 元组名 = tuple( 可迭代对象 ) 
list01 = ["a", "b", "c"] 
tuple02 = tuple(list01)      //场景：结算出结果存储时用元组
list02 = list(tuple02)# 2. 定位 # -- 读取(索引／切片)
print(tuple01[0]) # 10 
print(tuple01[:2]) # (10, 20)# 3. 遍历 
for item in tuple01: print(item) for i in range(len(tuple01) -1, -1, -1): print(tuple01[i])    

# 4. 特殊 
# 注意1：小括号可以省略 
tuple03 = 10, 20, 30 # 注意2：如果元组中只有一个元素,必须有逗号 
tuple04 = (10,) # 拆包: 多个变量 = 容器 
a,b,c = tuple03    #print(a,b,c)  10 20 30
a,b,c = ["A","B","C"] 		#print(a,b,c)    A B C
a,b,c = "孙悟空" 		# print(a,b,c)   孙 悟 空
*a,b = "孙悟空" 		# print(a,b)     ['孙', '悟'] 空   # *收集剩余的变量

作用

(1) 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
(2) 元组会按需分配内存，所以**如果变量数量固定，建议使用元组，因为占用空间更小。
(3) 应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖："姓名:%s, 年龄:%d" % ("tarena", 15)

"""根据月日,计算是这一年的第几天.公式：前几个月总天数 + 当月天数例如：5月10日计算：31 29 31 30 + 10
"""
month = int(input("请输入月份："))  # 5
day = int(input("请输入日："))  # 10
tuple_days = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# total_day = 0
# for i in range(month - 1):
#     total_day += tuple_days[i]
total_day = sum( tuple_days[:month - 1]  )
total_day += day
print("累计%s天" % total_day)

name = "张无忌"
names = ["赵敏", "周芷若"]
tuple01 = ("张翠山", name, names)
name = "无忌哥哥"      #内存新址，元组指向仍是旧址张无忌
tuple01[2][0] = "敏儿"   #指向列表names，names[0]改变
print(tuple01)   # ('张翠山', '张无忌', ['敏儿', '周芷若'])

字典 **dict **{}

方便查找，不能排序

(1) 由一系列 键值对 组成的可变散列容器。
(2) 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
(3) 键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

(1) 创建字典：

字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象)

(2) 添加/修改元素：

字典名[键] = 数据				#说明: 键不存在，创建记录。键存在，修改值。

(3) 获取元素：

变量 = 字典名[键]  # 没有键则错误

(4) 遍历字典：

for 键名 in 字典名:字典名[键名]
for 键名,值名 in 字典名.items():语句

(5) 删除元素：

del 字典名[键] 

1. 创建 
# -- { 键1:值1, 键2:值2 } 
dict_wk = {"name": "悟空", "age": 25, "sex": "女"} 
# -- dict( [( , ),( , )] ) 
# 列表转换为字典的格式要求：列表元素必须能够"一分为二" 
list01 = ["八戒", ("ts", "唐僧"), [1001, "齐天大圣"]] 
dict01 = dict(list01) 2. 添加 字典名[键] = 值 
dict_wk["money"] = 100000
print(dict_wk) # {'name': '悟空', 'age': 25, 'sex': '女', 'money': 100000} 3. 定位：字典名[键]   # 字典不能使用 索引 切片 
# -- 读取
print(dict_wk["name"]) 
# 注意：如果没有键则报错，解决：读取数据前,通过in判断. 
if "money" in dict_wk: print(dict_wk["money"])# -- 修改 (与添加数据语法相同) 具有key为修改,没有key为添加 
dict_wk["name"] = "空空"4. 删除 del 字典名[键] 
del dict_wk["sex"] 
print(dict_wk) # {'name': '空空', 'age': 25, 'money': 100000}5. 遍历 
# 方式1：for 键 in 字典名称 
for key in dict_wk: print(key)
# 方式2：for 值 in 字典名称.values() 
for value in dict_wk.values(): print(value) 
# 方式3：for 键,值 in 字典名称.items()
for key,value in dict_wk.items(): print(key) print(value)

数据类型转换

字典转列表
print(list(dict_wk.items())) # [('name','空空'), ('age', 25)]  #键值都要
列表转字典
print(dict([(1,2),(3,4)]))     #  {1: 2, 3: 4}

字典推导式

使用简易方法，将可迭代对象转换为字典。

{键:值 for 变量 in 可迭代对象} 
{键:值 for 变量 in 可迭代对象 if 条件}

# 需求:range(10)
new_dict = {}
for number in range(10):# 0~9new_dict[number] = number ** 2
print(new_dict)     
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}new_dict = {number: number ** 2 for number in range(10) }
print(new_dict)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

new_dict = {}
for number in range(10):# 0~9if number % 2 !=0:new_dict[number] = number ** 2
print(new_dict)
{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}new_dict = {number: number ** 2 for number in range(10) if number % 2 != 0}
print(new_dict)
{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

练习1：

将两个列表，合并为一个字典
姓名列表["张无忌","赵敏","周芷若"],房间列表[101,102,103]
list_name = ["张无忌", "赵敏", "周芷若"]
list_room = [101, 102, 103]
dict_new = {list_name[i]: list_room[i] for i in range(len(list_name))}
print(dict_new)
{'张无忌': 101, '赵敏': 102, '周芷若': 103}

练习2：

颠倒练习1字典键值.如果存在一样的值，翻转过来也就是键重复了，将会覆盖掉之前的数据    
new_dict = {value: key for key, value in dict_new.items()}
print(new_dict)
{101: '张无忌', 102: '赵敏', 103: '周芷若'}

集合set{} 使用较少

相当于只有键没有值的字典，不可重复，可用于列表去重

集合名={元素1，元素2，...}

list01=[1,2,3,1,5,5,6]
set01=set(list01)
print(set01)   #{1, 2, 3, 5, 6}  去重

基础操作

添加

set01.add("666")
print(set01)     //{1, 2, 3, '666', 5, 6}

5.6.3定位 不能定位

遍历

for item in set01:print(item)

删除

集合名.remove(元素名)

set01.remove("666")

运算

交集 &  返回共同值
并集 |   返回不重复的值
补集 ^  返回不同的元素
子集 <  判断集合1是否属于集合2
超集 >  ...

s1={1,2,3}
s2={2,3,4}
s3=s1 & s2     //{2, 3}
s4=s1 | s2	//{1, 2, 3, 4}
s5=s1 ^ s2	//{1, 4}
print(s1 < s2)	//False
print(s1 > s2)	//False

练习∶
一家公司有如下岗位∶
"经理”:“曹操"，"刘备”，"孙权“
"技术”:"曹操"，"刘备”，“张飞”，“关羽”
1．定义数据结构，存储以上信息    2．是经理也是技术的都有谁?
3．是经理不是技术的都有谁?	4.不是经理是技术的都有谁?
5.身兼一职的都有谁	6.公司总共有多少人数?dict_persons={"经理": {"曹操","刘备","孙权"},"技术": {"曹操","刘备","张飞","关羽"}
}
print(dict_persons["经理"] & dict_persons["技术"])   //{'刘备', '曹操'}
print(dict_persons["经理"] - dict_persons["技术"])   //{'孙权'}
print(dict_persons["技术"] - dict_persons["经理"]) 
print(dict_persons["经理"] ^ dict_persons["技术"])   //{'张飞', '孙权', '关羽'}
print(dict_persons["经理"] | dict_persons["技术"])
print(len(dict_persons["经理"] | dict_persons["技术"]))   //5

综合练习

"""将列表中的数字累减list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
"""
list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
result = list02[0]
for i in range(1, len(list02)):result -= list02[i]
print(result)       //    -36      

"""在列表中查找最大值(不使用max,自定义算法实现)思路:假设第一个元素就是最大值依次与后面元素进行比较如果发现更大值,则替换
"""
list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
max_value = list02[0]
for i in range(1, len(list02)):# 1 2 3 4 .. 总数-1if max_value < list02[i]:max_value = list02[i]
print(max_value)            //8

"""取出十位上不是3,7,8的数字
"""
list03=[ 135,63,227, 675,470]
result = []
for item in list03:unit = str(item)[ -2]if unit in ( "3","7","8"):continueresult.append(item)
print (result)     [63, 227]

"""在终端中获取颜色(RGBA),打印描述信息,否则提示颜色不存在"R" -> "红色""G" -> "绿色""B" -> "蓝色""A" -> "透明度"
"""
color = input("请输入颜色(RGBA)：")
dict_color_info = {"R": "红色","G": "绿色","B": "蓝色","A": "透明度"
}
# print(dict_color_info[color])
if color in dict_color_info:print(dict_color_info[color])
else:print("颜色不存在")

"""彩票：双色球红色：6个  1--33之间的整数   不能重复蓝色：1个  1--16之间的整数1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))2) 在终端中录入一支彩票要求：满足彩票的规则.
"""
import random# 1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))
list_ticket = []
# 前六个红球
while len(list_ticket) < 6:number = random.randint(1, 33)if number not in list_ticket:list_ticket.append(number)
# 第七个蓝球
list_ticket.append(random.randint(1, 16))
print(list_ticket)# 2) 在终端中录入一支彩票
list_ticket = []
while len(list_ticket) < 6:# number = int(input("请输入第%d个红球号码：" % (len(list_ticket) + 1)))number = int(input(f"请输入第{len(list_ticket) + 1}个红球号码："))if number in list_ticket:print("号码已经存在")elif number < 1 or number > 33:print("号码不在范围内")else:list_ticket.append(number)while len(list_ticket) < 7:number = int(input("请输入蓝球号码："))if number < 1 or number > 16:print("号码不在范围内")else:list_ticket.append(number)
print(list_ticket)

种类与特点总结

字符串∶存储字符的编码，不可变，序列
列表∶存储变量,可变，序列!
元组∶存储变量，不可变，序列
字典∶存储键值对，可变，散列，键的限制∶唯一且不变(字符串、元组、数值）
集合︰存储键,可变，散列序列与散列
序列: 有顺序，空间连续(省地),定位单个元素慢
散列: 无顺序，数据分布松散（费地),定位单个元素最快

练习汇总

循环嵌套

"""两层for循环嵌套
""""""
for c in range(5):print("$", end=" ")
print() # 换行
for c in range(5):print("$", end=" ")
print() # 换行
for c in range(5):print("$", end=" ")
print() # 换行
"""# 外层循环执行一次,内层循环执行多次
for r in range(3):  # 0      1       2for c in range(5):  # 01234  01234   01234print("$", end=" ")print()  # 换行   

for r in range(4):for c in range(r+1):print("$", end=" ")print()$ 
$ $ 
$ $ $ 
$ $ $ $ 

# 外层循环4次  内层循环
"""二维列表定位元素语法列表名[行索引][列索引]
"""
list01 = [[1, 2, 3, 4, 5],[6, 7, 8, 9, 10],[11, 12, 13, 14, 15],
]print(list01[0][0])				#1
print(list01[0][4])				#5
print(list01[2][1])				#12#将第一行从左到右逐行打印
for item in list01[0]:print(item)
for c in range(len(list01[0])):print(list01[0][c])			# 1  2  3  4  5#将第二行从右到左逐行打印
for c in range(4,-1,-1):print(list01[1][c])
for c in range(len(list01[1])-1,-1,-1):print(list01[1][c])#将第三列行从上到下逐个打印  
for r in range(len(list01)):print(list01[r][2])#将第四列行从下到上逐个打印
for r in range(len(list01)-1,-1,-1):print(list01[r][3])#将二维列表以表格状打印 
for r in range(len(list01)):for c in range(len(list01[r])):print(list01[r][c],end = "\t")print()for line in list01:for item in line:print(item,end="\t")print()

字典的修改

dict_hobbies = {
"于谦":["抽烟","喝酒","烫头"],
"郭德纲":["说","学","逗","唱"]
}
#打印于谦的所有爱好(一行一个)
for item in dict_hobbies["于谦"]:print(item)#计算郭德纲所有爱好数量
print(len(dict_hobbies["郭德纲"]))#打印所有人(一行一个)
for key1 in dict_hobbies:print(key1)#打印所有爱好(一行一个)
for value1 in dict_hobbies.values():for item in value1:print(item)
#修改        
dict_hobbies["于谦"][0] = "唱歌"        

dict_travel_info = {
"北京":{
"景区":["长城","故宫"],
"美食":["烤鸭","豆汁焦圈","面"]
},
"四川": {
"景区":["九寨沟","峨眉山"],"美食":["火锅","兔头"]
}
}打印北京的第一个景区∶长城
print(dict_travel_info["北京"]["景区"][0])所有城市（一行一个)效果∶北京四川
for key in dict_travel_info:print(key)北京所有美食（一行一个)效果∶
for item in dict_travel_info["北京"]["美食"]:print(item)打印所有城市的所有美食（一行一个)效果
for value in dict_travel_info.values():for item in value["美食"]:print(item)

自定义排序

"""交换算法a,b = b,a最值算法max_value = list01[0]for i in range(1, len(list01)):if max_value < list01[i]:max_value = list01[i]print(max_value)累计运算初始值  list01[0]循环while  for初始值+=？结果排序算法升序排列：小->大在整个范围内，让第一个为最小值，降序排列：大->小"""

"""升序排列小   大
"""
思想：  
把最小的放最第一位，拿list01[0]与后面的对比
list01 = [5, 56, 67, 78, 8, 9]
for i in range(1,len(list01)):if list01[0]>list01[i]:list01[0],list01[i]=list01[i],list01[0]
print(list01)
处理第二位为最小的，list01[1]与后面的对比
for i in range(2,len(list01)):if list01[1]>list01[i]:list01[1],list01[i]=list01[i],list01[1]
print(list01)
#整合重复的数据
list01 = [5, 56, 67, 78, 8, 9]
#取出数据，最后一位9不需要比了，下面-1
for r in range(len(list01) - 1):#作比较，不用和list01[0]自己比了，下面+1for c in range(r + 1, len(list01)):if list01[r] > list01[c]:list01[r], list01[c] = list01[c], list01[r]
print(list01)

"""降序排列
"""
list01 = [5, 56, 67, 78, 8, 9]
for i in range(1,len(list01)):if list01[0]<list01[i]:list01[0],list01[i]=list01[i],list01[0]
print(list01)   [78, 5, 56, 67, 8, 9]for i in range(2,len(list01)):if list01[1]<list01[i]:list01[1],list01[i]=list01[i],list01[1]
print(list01)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)

#商品字典
dict_commodity_infos = {1001:{ "name":"屠龙刀","price":10000},1002:{ "name":"倚天剑","price":10000},1003:{ "name":"金箍棒","price":52100},1004:{"name":"口罩","price":20},1005:{"name":"酒精","price":30},
}打印所有的商品信息
for key,value in dict_commodity_infos.items():print("商品号%s,商品名%s,商品价格%s"%(key,value["name"],value["price"]))print(f"商品号{key},商品名{value['name']},商品价格{value['price']}")list orders = [
{ "cid": 1001,"count": 1},
{ "cid": 1002, "count": 3},'
{"cid": 1005, "count": 2},'
]打印所有订单中的信息  商品号，数量
for item in list_orders:print(f'商品号{item["cid"]},数量{item["count"]}')打印所有订单中的商品信息,格式:商品名称xx,商品单价:xx,数量xx.
for item in list_orders:#cid = item["cid"]#info = dict_commodity_infos[cid]info = dict_commodity_infos[item["cid"]]print(f'商品名称{info["name"]},商品单价{info["price"]},数量{item["count"]}')查找数量最多的订单
max_value=list_orders[0]
for i in range(1,len(list_orders)):if max_value["count"] < list_orders[i]["count"]:max_value=list_orders[i]
print(max_value)根据购买数量对订单列表降序(大->小)排
for r in range(len(list_orders)-1):for c in range(r+1,len(list_orders)):if list_orders[r]["count"] < list_orders[c]["count"]:list_orders[r],list_orders[c]=list_orders[c],list_orders[r]
print(list_orders)
[{'cid': 1002, 'count': 3}, {'cid': 1005, 'count': 2}, {'cid': 1001, 'count': 1}]

#字典优点∶定位单个元素最方便，最快捷
#列表优点:定位灵活（切片），有顺序，内存占有量较小
#员工列表（员工编号部门编号姓名工资)

# 员工列表(员工编号 部门编号 姓名 工资)
dict_employees = {1001: {"did": 9002, "name": "师父", "money": 60000},1002: {"did": 9001, "name": "孙悟空", "money": 50000},1003: {"did": 9002, "name": "猪八戒", "money": 20000},1004: {"did": 9001, "name": "沙僧", "money": 30000},1005: {"did": 9001, "name": "小白龙", "money": 15000},
}# 部门列表
list_departments = [{"did": 9001, "title": "教学部"},{"did": 9002, "title": "销售部"},{"did": 9003, "title": "品保部"},
]
# 1. 打印所有员工信息, 格式：xx的员工编号是xx,部门编号是xx,月薪xx元.
for eid, emp in dict_employees.items():print(f"{emp['name']}的员工编号是{eid},部门编号是{emp['did']},月薪{emp['money']}元.")# 2. 打印所有月薪大于2w的员工信息,
# 格式：xx的员工编号是xx,部门编号是xx,月薪xx元.
for eid, emp in dict_employees.items():if emp['money'] > 20000:print(f"{emp['name']}的员工编号是{eid},部门编号是{emp['did']},月薪{emp['money']}元.")# 3. 在部门列表中查找编号最小的部门
min_value = list_departments[0]
for i in range(1, len(list_departments)):if min_value["did"] > list_departments[i]["did"]:min_value = list_departments[i]
print(min_value)# 4. 根据部门编号对部门列表降序排列
# (1)取
for r in range(len(list_departments) - 1):  # 0# (2)比for c in range(r + 1, len(list_departments)):  # 1234# (3) 发现更小if list_departments[r]["did"] < list_departments[c]["did"]:# (4) 交换list_departments[r], list_departments[c] = list_departments[c], list_departments[r]
print(list_departments)