python基础之字典的操作,字典推导式,集合,数字类型,随机数,字符串

2021/10/19 1:09:39

本文主要是介绍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基础之字典的操作,字典推导式,集合,数字类型,随机数,字符串的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程