Python教程
python基础之字典的操作，字典推导式，集合，数字类型，随机数，字符串
本文主要是介绍python基础之字典的操作，字典推导式，集合，数字类型，随机数，字符串，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
1.字典
-
字典是一个无序的，key是唯一的，可变的集合
-
字典中的key是唯一的
1.1系统功能
-
增：字典[key] = value update()
-
删：pop(key) del
-
改：字典[key] = value
-
查：items() values()
-
其他：copy()
-
# 一、增加
# 1.字典[key] = value,key不存在的情况下 ******
dict1 = {"zhangsan":10,'lisi':18}
print(dict1['zhangsan'])
# 当访问了不存在的key,则出现KeyError
# print(dict1['tom']) # KeyError: 'tom'
dict1['tom'] = 20
print(dict1)
# 注意：并不是所有的数据类型都可以使用+进行组合或者合并
# 适用的数据类型：int/float/bool + int/float/bool
#list + list tuple + tuple str + str 将生成新的容器
# print(dict1 + dict2) # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# 2.update():更新,合并字典，将指定字典中的键值对添加到原字典中 #【problem】
# 语法：字典1.update(字典2)：将字典2中的键值对添加到字典1中
dict2 = {'aaa':10,'bbb':15,'lisi':66}
# 将dict2合并到dict1
dict1.update(dict2)
print(dict1)#字典多了几个键值对【若是指定的键值对在原来的字典中有相同的键，那么就是覆盖值，也就是重新给那个键赋值】
print(dict2)#字典不变
# 3.setdefault(key,default/value)：设置默认值
"""
如果default省略，向字典中添加一对键值对,为key:None
如果default不省略，向字典中添加一对键值对,为key:default【这个default 也就是你写的那个值】
"""
dict1 = {"zhangsan":10,'lisi':18}
print(dict1)
dict1.setdefault("hello")
print(dict1) #{'zhangsan': 10, 'lisi': 18, 'hello': None}
dict1.setdefault("abc",888)
print(dict1)
###################################################
# 二、删除
# 1.pop(key):根据指定的key删除键值对，返回被删除的value
dict1 = {"zhangsan":10,'lisi':18}
print(dict1)
r1 = dict1.pop("lisi")
print(dict1)
print(r1)
# dict1.pop("aaa") # KeyError: 'aaa'
# 2.popitem():随机删除一对键值对，返回被删除键值对的元组
dict2 = {"zhangsan":10,'lisi':18,'a':10,'b':20,'f':34}
print(dict2)
dict2.popitem() # 字典是无序的
print(dict2)
# 3.del 字典[key]:删除指定key对应的键值对
dict3 = {"zhangsan":10,'lisi':18,'a':10,'b':20,'f':34}
# del dict3
del dict3['a']
print(dict3)
# 4.clear()
dict3.clear()
print(dict3)
############################
# 三、改
# 字典[key] = 值，key存在的情况下
dict1 = {"zhangsan":10,'lisi':18}
print(dict1)
dict1['lisi'] = 100
print(dict1)
# 四、查
# 1.len():获取字典中键值对的对数
print(len(dict1))
# 2.get(key,default),如果要获取指定key对应的value，建议直接get
dict2 = {"zhangsan":10,'lisi':18}
# 通过 字典[key] 获取指定key的value，如果key不存在，则会报错
print(dict2['lisi'])#有风险，若不存在键，获取则报错
# a.省略default，如果key存在，则直接返回相应的value；如果key不存在，则返回None
print(dict2.get("lisi"))
print(dict2.get('tom'))#所以的那个字典啥的获取键值对的值时候用get()
# b.设置default,如果key存在，则直接返回相应的value；如果key不存在，则返回default
print(dict2.get("lisi",'aaaa'))
print(dict2.get('tom','bbbb'))
# 3.keys()/values()/items()
# 获取所有的key/获取所有的value/获取所有的键值对【元组】
# 五、其他
#list int str dict等常用数据类型python就已经做了导入了，字典是常用数据类型
# 1.fromkeys()
# a.fromkeys(seq),seq中的元素作为key，value全部都是None
#【序列也是容器】
dict1 = dict.fromkeys([11,22])
print(dict1) #{11: None, 22: None}
dict1 = dict.fromkeys((11,22))
print(dict1)
# a.fromkeys(seq,value),seq中的元素作为key，值都是value(同一个value)
dict1 = dict.fromkeys([11,22],"aaa")
print(dict1)
dict1 = dict.fromkeys((11,22),"aaa")
print(dict1)
# 注意：value可以是任意的数据类型，但是，它将作为一个整体使用
dict1 = dict.fromkeys((11,22),('a','b'))
print(dict1)#结果：{11:('a','b'),22:('a','b')}
# 区分
dict1 = dict(zip([11,22],['a','b']))
print(dict1) # {11: 'a', 22: 'b'}
dict2 = dict.fromkeys([11,22],['a','b'])
print(dict2) # {11: ['a', 'b'], 22: ['a', 'b']}
# 2.字典.copy():用法和列表完全相同，拷贝是外层地址
# a
dict2 = {"name":"张三","age":19,"hobby":"篮球"}
dict3 = dict2
dict2['name'] = "jack"
print(dict2)
print(dict3)
# b
dict2 = {"name":"张三","age":19,"hobby":"篮球"}
dict3 = dict2.copy()
dict2['name'] = "jack"
print(dict2)
print(dict3)
# c.
import copy
list1 = [1,2,3,{"name":"张三","age":19}]
list2 = copy.copy(list1)
list1[-1]['age'] = 66
print(list1) # [1,2,3,{"name":"张三","age":66}]
print(list2) # [1,2,3,{"name":"张三","age":66}]
# d
import copy
list1 = [1,2,3,{"name":"张三","age":19}]
list2 = copy.deepcopy(list1)
list1[-1]['age'] = 66
print(list1) # [1,2,3,{"name":"张三","age":66}]
print(list2) # [1,2,3,{"name":"张三","age":19}]
1.2字典推导式
- 语法：{key:value for循环 if判断}
- 字典推导式又叫字典生成式 [注意：简单逻辑用这个推导式，但是逻辑复杂的话不要用推导式]
# 1.已知字典：dict1 = {'aaa':10,"bbb":20},使用不同的方式实现key和value的交换，生成一个新的字典
dict1 = {'aaa':10,"bbb":20}
# 方式一
d1 = {}
for key,value in dict1.items():
d1[value] = key
print(d1)
# 方式二
dict1 = {'aaa':10,"bbb":20}
d2 = {value:key for key,value in dict1.items()}
print(d2)
# 2.编写程序，生成一个字典{0:0,1:1,2:4,3:9,4:16,5:25}
d3 = {i:i ** 2 for i in range(6)}
print(d3)
# 3.生成一个字典{1:1,3:9,5:25}
d3 = {i:i ** 2 for i in range(6) if i % 2 == 1}
print(d3)
# 4.已知两个字符串xyz和abc
list1 = [m + n for m in "xyz" for n in "abc"]
print(list1)
dict4 = {m:n for m in "xyz" for n in "abc"}
print(dict4)
1.3字典练兵
# 1.已知列表list1 = [11,22,33,44,55],list2 = ['a','b,'c','d','e']
# 以list1中的元素作为key,list2中的元素作为value生成一个字典
# 情况一：长度相同
list1 = [11,22,33,44,55]
list2 = ['a','b','c','d','e']
dict11 = {}
for i in range(len(list1)):
dict11[list1[i]] = list2[i]
# 情况一：长度不相同
list1 = [11,22,33,44,55,66,77,88]
list2 = ['a','b','c','d','e']
dict11 = {}
if len(list1) > len(list2):
for i in range(len(list2)):
dict11[list1[i]] = list2[i]
else:
for i in range(len(list1)):
dict11[list1[i]] = list2[i]
# 2.已知列表list1 = [3,5,4,65,6,56,5,100,456,5,65],生成一个字典，
# 将其中大于60的数字保存到k1中，小于等于60的数字保存到k2中
# 例如：{'k1':[65,100,456,65],'k2':[3,5,4,6,5,5]}
list1 = [3,5,4,65,6,56,5,100,456,5,65]
sublist1 = [] # 保存大于60的数字
sublist2 = [] # 保存小于等于60的数字
for num in list1:
if num > 60:
sublist1.append(num)
else:
sublist2.append(num)
dict1 = {"k1":sublist1,"k2":sublist2}
"""
模拟商品购物车,实现向购物车中添加商品和删除商品的操作
要求：
a.模拟商品数据，包括商品名称，价格
b.引导用户选择需要操作的功能，如：添加，删除，退出
c.引导用户输入总资产
d.如果选择添加功能，则判断商品单价和总资产的关系，如果小于，则添加到购物车，默认添加数量为1个
e.如果选择删除功能，则引导用户输入需要删除的商品名称，从购物车中删除
"""
print("****欢迎****".center(60))
#模拟仓库
goods_list = [
{"name":"电脑","price":8888},
{"name":"book","price":78},
{"name":"phone","price":4000},
{"name":"自行车","price":2000}
]
#引导用户输入总资产
total_money = int(input("请充值："))
#展示商品
print("当前可供选择的商品如下：")
for i in range(len(goods_list)):
print("%d:%s"%(i,goods_list[i]))
#购物车
shopcar_list = []
#模拟系统，用户添加商品和删除商品的操作可能不止一次
while True:
#给当前用户展示当前系统可以操作的功能
print("""当前购物系统中有如下功能：
0.添加商品
1.删除商品
2.结算购物车
3.退出
""")
#引导用户输入需要进行的操作
choice = input("请输入需要进行的操作：")
if choice.isdigit() and choice in [str(i) for i in range(3+1)]:
if choice =="0":
#添加商品
#引导用户输入需要添加到购物车的商品
index = input("请输入需要购买的商品编号[0-3]:")
if index.isdigit():
index = int(index)
if index in range(3+1):#判断index是在指定的范围
#获取指定编号的商品
goods_dict = goods_list[index]
#如果余额足够则添加
if goods_dict['price'] <= total_money:
#将商品添加到购物车中
shopcar_list.append(goods_dict)
#减掉花去的钱计算还剩下多少钱
total_money -= goods_dict["price"]
print("添加商品成功！！！")
print(f"shopcar_list中商品有{shopcar_list}")
else:
print("余额不足")
else:
print("该商品不存在")
else:
print("输入的编号有误")
elif choice =="1":
#删除商品
#引导用户输入要删除的商品的名称：
goods_name = input("请输入需要删除的商品的名称：")
#遍历，比对
count =0
for subdict in shopcar_list:
if subdict["name"] == goods_name:
# shopcar_list.remove(goods_name)#不能这么写，要删除的是这个货物的所有信息，所以应该删除subdict
shopcar_list.remove(subdict)
#返还余额
total_money += subdict["price"]
print("删除成功")
break #控制只删除一件该种商品
else:#若是直接在这pirnt("你所想要删除的商品不存在")这样的话若是商品不存在，那么购物车中此时有几个物件，他就会出现几次这个提示
count+=1
if count==len(shopcar_list):
count = 0
print("你所想要删除的商品不存在")
elif choice =="2":
#pass#在该部分的逻辑代码没有书写时候，若是没有pass占位置，那么就会报错：IndentationError: expected an indented block
#结算购物车
shopcar_money = 0
for subdic in shopcar_list:
shopcar_money += subdict["price"]
print("总共花费：%d￥,剩余%d￥"%
(shopcar_money,total_money))
#清空购物车
shopcar_list.clear()
else:
#退出系统
#pass#在该部分的逻辑代码没有书写时候，若是没有pass占位置，那么就会报错：SyntaxError: unexpected EOF while parsing
print("欢迎再次光临".center(6,"*"))
#注意："字符串".center(num,"character")，character只能是单个的字符，num<=字符串长度：只会出现字符串，不会出现填充的字符，
# 当num>=字符串长度：才会出现填充的字符
break
else:
print("功能选择有误")
########################################
# 函数优化
# 3.模拟商品购物车,实现向购物车中添加商品和删除商品的操作
"""
要求：
a.模拟商品数据，包括商品名称，价格
b.引导用户选择需要操作的功能，如：添加，删除，退出
c.引导用户输入总资产
d.如果选择添加功能，则判断商品单价和总资产的关系，如果小于，则添加到购物车，默认添加数量为1个
e.如果选择删除功能，则引导用户输入需要删除的商品名称，从购物车中删除
"""
print("*************欢迎进入自助购物商店***********")
# 引导用户输入总资产
total_money = int(input("请充值："))
def add_goods():
global total_money
# 引导用户输入需要添加到购物车的商品
index = input("请输入需要购买的商品编号【0~3】：")
if index.isdigit():
index = int(index)
if index in range(4):
# 获取指定编号的商品
goods_dict = goods_list[index]
# 如果余额足够则添加
if goods_dict['price'] <= total_money:
# 将商品添加到购物车中
shopcar_list.append(goods_dict)
# 减掉
total_money -= goods_dict['price'] # a -= 10----->a = a - 10
print("商品添加成功！")
else:
print("余额不足")
else:
print("该商品不存在")
else:
print("编号输入有误")
def del_goods():
global total_money
# 引导用户输入需要删除的商品的名称
goods_name = input("请输入需要删除的商品的名称：")
# 遍历，比对
for subdict in shopcar_list:
if subdict["name"] == goods_name:
shopcar_list.remove(subdict)
# 反还余额
total_money += subdict["price"]
break
else:
print("你输入的商品不存在")
print("删除成功！")
def cal():
shopcar_money = 0
for subdict in shopcar_list:
shopcar_money += subdict["price"]
print("总共花费：%d￥，剩余%d￥" % (shopcar_money, total_money))
# 清空购物车
shopcar_list.clear()
# 模拟仓库
goods_list = [
{"name":"电脑","price":8888},
{"name":"book","price":78},
{"name":"phone","price":4000},
{"name":"自行车","price":2000}
]
# 展示商品
print("当前可供选择的商品如下：")
for i in range(len(goods_list)):
print("%d:%s" % (i,goods_list[i]))
# 购物车
shopcar_list = []
# 模拟系统，用户添加商品和删除商品的操作可能不止一次
while True:
# 给用户展示当前系统可以操作的功能
print("""当前购物系统中有如下功能：
0.添加商品
1.删除商品
2.结算购物车
3.退出""")
# 引导用户输入需要进行的操作
choice = input("请输入需要进行的操作：")
if choice.isdigit() and choice in [str(i) for i in range(4)]:
if choice == "0":
# 添加
add_goods()
elif choice == '1':
# 删除
del_goods()
elif choice == "2":
# 结算
cal()
else:
# 退出
print("欢迎再次光临")
break
else:
print("功能选择输入有误")
2.集合
-
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算
-
set与dict类似，但是与dict的区别在于只是一组key的集合，不存储value
-
集合的本质：是一种无序的，可变的，不允许存储重复元素的集合
-
表示：{}，注意：如果直接使用{}则默认表示字典
#创建
# 1.{}
# 注意：{}表示字典
set1 = {}
print(type(set1)) # <class 'dict'>
# 2.{}不为空，其中的元素并不是键值对,则表示集合
set2 = {3,4,6,7,8}
print(type(set2))
# 3.创建一个空集合
# set()
set31 = set()
print(set31)
set31 = set([])
print(set31)
set31 = set(())
print(set31)
set31 = set({})
print(set31)
# 4.创建非空集合
set41 = {4,6,7,8,9}
set42 = set([4,6,7,8])
print(set42)
set42 = set((4,6,7,8))
print(set42)
set42 = set({"a":10,"b":20,"c":30})
print(set42)#{'c','a','b'}#若集合里面是键值对的字典时候，那么集合转化之后的集合只含有key 顺序不同，因为集合是无序的，可变的
# 5
# 注意1:集合中不允许重复元素存在
set51 = {4,4,4,5,6,6}
print(set51)
##################################
#系统功能
# 一、增
# 1.add(x),添加，
set1 = {22,33,44,55,66}
print(set1)
set1.add(77)
print(set1)
set1.add("abc")
print(set1)
# set1.add([2,3,4]) #TypeError: unhashable type: 'list'
set1.add((2,3,4))
print(set1)
# set1.add(2,3,4) #TypeError: add() takes exactly one argument (3 given)
print(set1)
# 2.update(x),更新，和字典中的update原理是一样的
set1 = {22,33,44,55,66}
print(set1)
# set1.update(77) # TypeError: 'int' object is not iterable
set1.update([77])
print(set1)
set1.update({"a":10,"b":20})
print(set1)
"""
【problem 】add和update之间的区别和联系
append和extend之间的区别和联系
相同点：
a.都是想集合中添加元素
b.都只能识别一个数据
不同点：
a.add只能添加不可变的数据类型
b.update只能添加可迭代对象【str,list,tuple,dict】
c.如果添加的数据为元组，add会将元组本身添加到集合中（整体加入），update只会将其中的元素添加到集合中（打碎加入）
"""
#add可以添加数字，添加的顺序不确定
#add()不能添加可变的数据类型，eg:dic ,list 等不行
# 二、删
# 1.remove(),删除指定的元素
set1 = {22,33,44,55,66}
print(set1)
set1.remove(44)
print(set1)
# set.remove(100) # TypeError: descriptor 'remove' requires a 'set' object but received a 'int'
# 2.pop(),随机删除一个#因为集合是无序的，所以不能弄下标索引来删除指定的元素，所以是随机的删除其中的一个元素
set1 = {22,33,44,55,66}
print(set1)
set1.pop()
print(set1)
# 3.discard(),删除指定的元素，和remove的功能相同
# 如果指定的元素不存在，remove会报错，discard不会报错，
set1 = {22,33,44,55,66}
print(set1)
set1.discard(44)
print(set1)
set1.discard(100)#没有100，没从集合中找到100，所以啥也没有干，也不报错
print(set1)
# 4.clear(),清空
set1 = {22,33,44,55,66}
print(set1)
set1.clear()
print(set1) # set()
# 三、查
print(len(set1))
print(max(set1))
print(min(set1))
set1 = {22,33,44,55,66}
print(set1)
set2 = set1.copy()#判断能不能copy,就看他是不是可变的，可变的就可以进行copy
##########################
#集合之间的运算
# 【problem】集合间的运算：差集，交集，并集
set1 = {1,2,3}
set2 = {3,4,5}
# 一、运算符
# 1.交集：&
print(set1 & set2)
# 2.并集：|
print(set1 | set2)
# 3.差集：-
print(set1 - set2)
# 4.并集 - 交集
print(set1 ^ set2)
# 二、系统功能
# 1.交集：
print(set1.intersection(set2))
# 2.并集
print(set1.union(set2))
# 3.差集
print(set1.difference(set2))
#[problem]# 已知列表list1 = [34,65,65,65,6,6,6],去除其中的重复元素
list1 = [34,65,65,65,6,6,6]
list2 = list(set(list1))
print(list2)
3.数字类型
"""
- abs(x):返回数字的绝对值
- (x>y)-(x<y):比较大小，
- max(x1,x2,…):返回给定参数的最大值
- min(x1,x2,…):返回给定参数的最小值
- pow(x,y):求x的y次方的值
- round(x,n):返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数
导入math模块 import math;
- ceil(x):返回x的上入整数，不能直接访问，需要通过math访问，即math.ceil(18.1)
- floor(x):返回x的下入整数，同ceil的用法
- modf(x):返回x的整数部分和小数部分，两部分的数值符号与x相同，整数部分以浮点型表示，同ceil的用法
- sqrt(x):返回数字x的平方根，返回类型为浮点型
数学常量
math.pi ：圆周率
math.e ：自然常数
"""
import math
# 一、内置功能，语法：xxxx()
# 1.abs():求绝对值
print(abs(-19))
# 2.max()/min():求最值
print(max([5,65,7,57,67]))
print(max(5,65,7,57,67))
print(min(5,65,7,57,67))
# 3.pow(x,y):求x的y次方 ******
print(pow(5,3))
print(5 ** 3)
# 4.sum(iterable,value):求和 *****这个函数自己在用得时候不能写sum，因为这样会导致sum()系统函数失效
print(sum([1,2,3]))
print(sum((1,2,3)))
print(sum({1,2,3}))
print(sum({1,2,3},10))#1，2，3求和之后然后再加上10
# 5.round(x，y):四舍五入 ******
# 如果省略y，则结果为四舍五入之后的整数，如果y未被省略，则表示保留小数点后y位（也会四舍五入）
print(round(8.23))
print(round(8.73))
print(round(8.23,1))
print(round(8.26,1))
print(round(8.233,2))
print(round(8.269,2))
# 练习：求1~100之间整数的和
print(sum(range(1,101)))
print(sum(range(0,101,2)))
# 二、math模块中的功能，语法：math.xxx()
# 导入模块：import math
# 1.math.ceil(),向上取整 (这里面不涉及四舍五入)
print(math.ceil(16.9))
print(math.ceil(16.1))
# 2.math.floor()，向下取整
print(math.floor(16.9))
print(math.floor(16.1))
# 3.math.sqrt():求算术平方根，结果为浮点数 *****
print(math.sqrt(9))
# 4.常量
print(math.pi) # 圆周率
print(math.e) # 自然常数
4.随机数
# import random #若是这样的话，用法就是random.choice()等
from random import * # 从random模块中导入所有的内容，这样不用加前缀random.choice（）可以简化书写
# 1.choice(seq),seq可以是list,tuple,str，也可以是range() *****
# 注意1：choice中的序列只能是有序集合
print(choice([4,65,6]))
print(choice((4,65,6)))
# print(choice({4,65,6})) #TypeError: 'set' object does not support indexing
#choice()中的参数里面是有序的集合，所以不能有dict,set
# 注意2：如果序列存在，则直接使用，如果不存在，则一般要借助于range()生成
print(choice(range(1,101)))
print(choice(range(0,101,2)))
# 2.randint(start,end),和range(start,end,step)的区别在于包含end，而且没有step
# 3.randrange(start,end,step),其中的参数和range中的用法完全相同
# 需求：求1~50之间的整数的随机数
print(choice(range(1,51)))
print(randint(1,50))
print(randrange(1,51))
# 需求：求1~50之间的3的倍数的随机数
print(choice(range(0,51,3)))
print(randrange(0,51,3))
###########################################
#以上三个是取整数的随机数
#下面的两个是求浮点数的随机数
# 4.random()，获取0~1之间的一个随机数，所以他拿到的是浮点数
print(random())
print(round(random(),2))#浮点数保留两位
# 需求：求20~100之间的随机数
# (0,1)--->(0,80)--->(20,100)
print(random() * 80 + 20)
"""
结论
求n~m（m > n）之间的随机数，包括整数和浮点数
则随机数的表示为：random() * (m - n) + n
"""
# 5.uniform()
# 需求：求20~100之间的随机数
print(uniform(20,100))
5.字符串
-
字符串的本质：是一种有序的，不可变的，可以存储重复字符的集合
-
由若 干个字符组成的一个序列被称为字符串，其中的字符可以是字母，数字，符号，中文等
-
：字符串属于不可变的数据类型，可以作为字典的key
#创建
# 1.''
# 注意命名：尽量不要直接使用str，因为系统有str这么个功能
s1 = 'aa4中文%%￥'
print(s1)
# 2.""
s2 = "aa4中文%%￥"
print(s2)
# 3.""""""
s3 = """fahjg
56756
饿哦的
%￥￥##"""
print(s3)#结果是：最终有一个换行，因为print()会产生一个换行\n
# 4.特殊
"""
转义字符：在一个字符或者符号的前面添加\,则就可以将指定字符进行转义
普通字符----》特殊字符，如：n---->\n
特殊字符----》普通字符，如：\---->\\
\n:换行
\t:制表符
\r:回车键
\f：换页
"""
s4 = "hello\nhfajhg\n364765"
print(s4)
# 需求：打印 "hello"
print("\"hello\"")
print("'hello'")
print('"hello"')
s5 = "C:\\Users\\Administrator\\Desktop\\test"
# 语法：r"xxx",当xxx内容中出现较多需要转义的字符时，可以使用r进行声明
# 使用场景：文件路径的表示和正则表达式
s6 = r"C:\Users\Administrator\Desktop\test"
print(s6)
#######################
#操作
# 结论：字符串是不可变的数据类型，但凡涉及到字符串的更改，都是生成了一个新的字符串
# 1.+
str1 = "hello"
str2 = "Python"
print(str1 + str2)
print(str1)
print(str2)
# 【面试题】
# 字符串是不可变的数据类型，但凡涉及到字符串的更改，都是生成了一个新的字符串
str1 = "hello"
#str2 = str1.upper()
str1.upper()
print(str1) # hello 因为他是生成了一个新的字符串所以还是小写的
str1 = "this is a test"
str1.replace("test","exam")
print(str1)#this is a test 因为字符串的更改就是生成了一个新的字符串
# 2.*
print("good" * 3)#goodgoodgood
# 3.in和not in:判断一个字符在原字符串中是否存在
print('a' in str1)
# 4.切片
# 用法和列表完全相同，结果为一个新的字符串
#[注意：在语法正确的情况下基本上都不会报错]
################################################
#系统功能
"""
evil()：将str转换为有效的表达式
upper():将小写字母转换为大写
lower():大---》小
swapcase():大---》小 小----》大
capitalize():首单词的首字母大写，其他全部小写
title():每个单词的首字母大写，其他全部小
ord(),chr()
"""
# 1.eval() 将一个字符串中的Python代码转换出来 *****
# list1 = input("请输入一个列表：")
# print(list1,type(list1))
# r = eval(list1)
# print(r,type(r))
eval("print('hfajhgkajh')")
# print(int("3 + 4"))
print(eval("3 + 4"))
# 2.大小写转换
str1 = "This is A TeXT"
print(str1.upper())
print(str1.lower())
print(str1.title()) # 每个单词的首字母大写
print(str1.capitalize()) # 首单词的首字母大写
print(str1)
6.大练兵
"""
1.已知字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"}，实现以下功能
"""
dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
a.遍历字典 dic 中所有的key
for key in dic:
print(key)
b.遍历字典 dic 中所有的value
for key in dic:
print(dic[key])
c.循环遍历字典 dic 中所有的key和value
for key,value in dic.items():
print(key,value)
d.添加一个键值对"k4","v4",输出添加后的字典 dic
dic['k4'] = 'v1'
print(dic)
e.删除字典 dic 中的键值对"k1","v1",并输出删除后的字典 dic
dic.pop('k1')
print(dic)
f.删除字典 dic 中 'k5' 对应的值，若不存在，使其不报错，并返回None
aa = dic.pop('k5',None)
print(aa)
g.获取字典 dic 中“k2”对应的值
k2 = dic['k2']
print(k2)
h.已知字典dic2 = {'k1':"v111",'a':"b"} 编写程序，使得dic2 = {'k1':"v111",'k2':"v2",'k3':"v3",'k4': 'v4','a':"b"}
dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
dic2 = {'k1':"v111",'a':"b"}
for key in dic2:
dic[key] = dic2[key]
print(dic)
"""
2.已知列表list1 = [11,22,11,33,44,55,66,55,66],统计列表中
每个元素出现的次数，生成一个字典，结果为{11:2,22:1.....}
"""
list1 = [11,22,11,33,44,55,66,55,66]
dict2 = {}
for i in list1:
count = list1.count(i)
dict2[i] = count
print(dict2)
"""
3.已知如下列表students，在列表中保存了6个学生的信息，
根据要求完成下面的题目
a.统计不及格学生的个数
b.打印不及格学生的名字和对应的成绩
c.统计未成年学生的个数
d.打印手机尾号是8的学生的名字
"""
students = [
{'name': '小花', 'age': 19, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '明明', 'age': 20, 'score': 40, 'gender': '男', 'tel':
'15300022838'},
{'name': '华仔', 'age': 18, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '静静', 'age': 16, 'score': 90, 'gender': '不明', 'tel':
'15300022428'},
{'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明', 'tel':
'15300022839'},
{'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男', 'tel':
'15300022839'}
]
count1 = 0
dict2 = {}
count2 = 0
list4 = []
for i in range(len(students)):
if students[i]['score'] < 60:
count1 += 1
dict2[students[i]['name']] = students[i]['score']
if students[i]['age'] < 18:
count2 += 1
if students[i]['tel'][-1] == '8':
list4.append(students[i]['name'])
print('不及格学生人数 %d' % (count1))
print(dict2)
print('未成年学生的个数 %s' % (count2))
print('手机尾号是8的学生的名字',list4)
e.打印最高分和对应的学生的名字
dict5 = {}
max_score = students[0]['score']
for i in range(len(students)):
if max_score < students[i]['score']:
max_score = students[i]['score']
for i in range(len(students)):
if max_score == students[i]['score']:
dict5[students[i]['name']] = students[i]['score']
print('最高分和对应的学生的名字',dict5)
f.删除性别不明的所有学生
new_students = []
for i in range(len(students)):
if students[i]['gender'] != '不明':
new_students.append(students[i])
print(new_students)
g.将列表按学生成绩从大到小排序
for i in range(len(students)):
for j in range(i,len(students)):
if students[i]['score'] < students[j]['score']:
students[i],students[j] = students[j],students[i]
print(students)
"""
4.写一个学生作业情况录入并查询的小程序
a.录入学生作业情况：字典添加
b.查看学生作业情况：字典查询
c.录入时允许输入3次，3次输入不正确提示失败次数过多，禁止继续录入
"""
students = {}
count = 0
while True:
choice = input('请选择1.录入 2.查询')
if choice.isdigit():
choice = int(choice)
count = 0
if choice == 1:
while count < 3:
name1 = input('学生姓名')
scores = input('学生成绩')
if scores.isdigit():
students[name1] = scores
else:
count += 1
else:
print('录入错误次数过多，禁止继续录入')
elif choice == 2:
name2 = input('请输入要查询学生的姓名')
if name2 in students.keys():
print(name2,students[name2])
else:
print('您要查询的学生不在范围内，请重新输入')
else:
print('输入有误，请重新输入')
"""
5.用三个元组表示三门学科的选课学生姓名(一个学生可以同时选多门课)
"""
subject1 = ('王一','赵四','张三','李五','薛二')
subject2 = ('王一','张三','李五','熊大')
subject3 = ('李五','熊大','熊二','光头强')
#a.求选课学生总共有多少人
#法一
num1 = len(set(subject1 + subject2 + subject3))
print(num1)
#法二
#a.求选课学生总共有多少人
#思路：集合是不重复元素
set1 = set(subject1)
set2 = set(subject2)
set3 = set(subject3)
print(len(set1)+len(set2)+len(set3))
set1.update(set2)
set3.update(set1)
print(len(set3))
#b.求只选了第一个学科的人的数量和对应的名字
#法一
listb = []
for name in subject1:
if name not in subject2 and name not in subject3:
listb.append(name)
print(len(listb),listb)
#法二
#求差集
print(set1 -(set2|set3))
#c.求只选了一门学科的学生的数量和对应的名字
# 法一
listc1 = []
listc2 = []
listc3 = []
for name in subject1:
if name not in subject2 and name not in subject3:
listc1.append(name)
for name in subject2:
if name not in subject1 and name not in subject3:
listc2.append(name)
for name in subject3:
if name not in subject2 and name not in subject1:
listc3.append(name)
print(len(listc1),listc1,len(listc2),listc2,len(listc3),listc3)
# 法二
subject1 = set(subject1)
subject2 = set(subject2)
subject3 = set(subject3)
set1 = (subject1-subject2)-subject3
set2 = (subject2-subject1)-subject3
set3 = (subject3-subject2)-subject1
print(len(set1),set1,len(set2),set2,len(set3),set3)
#法三
print(set1 - set2 -set3)
print(set2-set1-set3)
print(set3-set1-set2)
#d.求只选了两门学科的学生的数量和对应的名字
set1 = (subject1&subject3)-subject2
set2 = (subject2&subject3)-subject1
set3 = (subject3&subject1)-subject2
print(len(set1),set1,len(set2),set2,len(set3),set3)
#e.求选了三门学生的学生的数量和对应的名字
sete = subject3&subject2&subject1
print('选了三门学科的学生人数%s，分别是%s'%(len(sete),sete))
这篇关于python基础之字典的操作，字典推导式，集合，数字类型，随机数，字符串的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
获取参数学习：Python编程入门教程11-14
-
Python编程基础入门11-14
-
Python编程入门指南11-14
-
Python基础教程11-13
-
Python编程基础指南11-12
-
Python基础编程教程11-12
-
Python编程基础与实践示例11-08
-
Python编程基础指南11-07
-
Python编程基础入门指南11-06
-
怎么使用python 计算两个GPS的距离功能-icode9专业技术文章分享11-06
-
Python 基础编程入门教程11-06
-
Python编程基础：变量与类型11-05
-
Python编程基础：变量与类型11-05
-
Python编程基础：变量与类型11-04
-
Python编程基础11-04
栏目导航
