标签：key dict1 name python set1 随机数 print 字典

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

标签：key,dict1,name,python,set1,随机数,print,字典
来源： https://blog.csdn.net/qq_45403803/article/details/120835986

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。