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