标签：02 name Python 编程 列表 result key print login

四、字符串列表元组字典集合

4.1字符串 --> str

4.1.1 字符串的输入输出

#定义变量s1
s1 = 'hello'
#将s1赋值给s2
s2 = s1
#定义变量s3
s3 = 'hello'
#定义变量s4
s4 = 'hello1'
print(s1,s2, s3) #hello hello hello
#s1,s2,s3其实是使用同一个内存地址，理论上就是同一个值
print(id(s1)) #2172918261384
print(id(s2)) #2172918261384
print(id(s3)) #2172918261384
print(id(s4)) #2172918556128
print(s1 is s2) #True
print(s1 is s4) #False

4.1.2字符串下标和切片

字符串在内存中有索引index值,即下标，如有字符串s，其机制有2套规则：

1， 0~len(s)-1 从左往右，下标从0开始，第一个索引值为0

2，-len(s)~ -1 从右往左，最后一个索引值为-1

#定义字符串s
s = 'ABCDEFG'
#算字符串长度
n = len(s)
#取头和尾
print(s[0],s[n-1]) #A F
print(s[-n],s[-1]) #A F
#取多个值,切片s[start,end，step],包前不包后,默认step是1
'''
step的作用：
1，步长
2，方向：
    值为正，从左往右
    值为负，从右往左
'''
print(s[1:4]) #BCD
print(s[1:6:2]) #BDF
#取最后3个字母
print(s[-3:]) #DEF
print(s[4:]) #DEF
#从头到5的位置
print(s[:5]) #ABCDE
#打印所有
print(s[:]) #ABCDEFG
#掐头去尾
print(s[1:-1])  #BCDEF
#倒序取值
print(s[::-1]) #GFEDCBA
print(s[::-2]) #GECA

4.1.3 字符串的常见操作

查找，统计和索引

''''
https://scpic.chinaz.net/files/pic/pic9/202009/apic27858.jpg
find: 从左向右查找，只要遇到一个符合要求的即返回位置，如果没有找到符合要求的返回-1
rfind:从右往左查找
count:统计字符出现的次数
index与find的区别：index也是查找，但是找不到时，不会返回-1，而是报错
'''
#find,index, rfind, rindex
#提取图片名apic27858.jpg
path = 'https://scpic.chinaz.net/files/pic/pic9/202009/apic27858.jpg'
print(len(path))
#查找多个连续的字符，返回字符在第一个字符的index索引值，find 从左往右查找
i = path.find('api')
print(i)   #47,字母a的下标索引
print(path[47:]) #apic27858.jpg
#查找不存在的字符，返回-1
i = path.find('#')
print(i)  #-1
#index查找不存在的字符，程序报错
i = path.index('#')
print(i)  #ValueError: substring not found
#打印图片的后缀名，rfind: right find,从右往左查找
i = path.rfind('.')
print(path[i:]) #.jpg
#统计'.'出现的次数
n = path.count('.')
print(n) #3

替换、切割和修改

'''
替换内容：replace(old,new,count),默认全部替换，也可以通过count指定次数
切割字符串：split, rsplit, splitlines,partition,rpartition
    split('分隔符'，maxsplit)，返回的结果是一个列表,maxsplit指最多分割次数,从做开始
    rsplit:从右开始
    splitlines：按行分割
    partition: 按分割符切一次为元组，分隔符作为一个元素
修改大小写：capitalize, title, upper, lower
    capitalize:一个字符串中的首字母大写
    title ： 字符串中每个单词的首字母大写
    upper：字符串全变为大写
    lower：字符串全变为小写
'''
s = '大哥说：社会上流氓太多，我们要远离流氓!'
#不加count参数，默认全部替换
result = s.replace('流氓','**')
print(result) #大哥说：社会上**太多，我们要远离**!
#加count参数，替换count次
result = s.replace('流氓','**',1)
print(result) #大哥说：社会上**太多，我们要远离流氓!

#如果同时需要替换两个不相邻的字符串，怎么办？

s = '''hi brother, come on here!
hi brother, where you go!
hi brother, let's talk!
hi brother, you are handsome!
'''
result = s.splitlines()
print(result) #['hi brother, come on here!', 'hi brother, where you go!', "hi brother, let's talk!", 'hi brother, you are handsome!']

s = 'Forrest Jessy Maio'
result = s.partition(" ")
print(result) #('Forrest', ' ', 'Jessy Maio')

s = 'hello world'
result = s.capitalize() 
print(result) #Hello world

result = s.title()
print(result) #Hello World

result = s.upper()
print(result) #HELLO WORLD

result = s.lower()
print(result) #hello world

空格处理

'''
空格处理：ljust,rjust,center,lstrip,rstrip,strip
    去除空格：
        strip : 去除字符串左右两边的空格
        lstrip : 去除字符串左边的空格
        rstrip : 去除字符串右边的空格
    添加空格：
        center: 居中对齐
        ljust：左对齐
        rjust：右对齐    
字符串拼接：join
    
'''

s = ' admin   '
print(len(s))
result = s.strip() #去除字符串左右两边的空格
print(len(result))
print(result)

result = s.lstrip() #去除字符串左边的空格
print(len(result))
print(result)

result = s.rstrip() #去除字符串右边的空格
print(len(result))
print(result)

s = 'hello world'
result = s.center(30) #占30个字符宽度，居中对齐
print(result)

result = s.ljust(30) #占30个字符宽度，左对齐
print(result)

result = s.rjust(30) #占30个字符宽度，右对齐
print(result)

字符拼接

'''
字符串拼接：join
'''

格式化

'''
格式化：
1，%d,%s,%f ...
    print('F says: %s' %xxx)
2,format
'''
name = 'Bians'
age = 18

#使用变量填充
result = 'Beauty {} is {} this year'.format(name,age)
print(result)

#使用数字填充，从0开始
result = 'Beauty {0} is {1} this year，and I am {1}, too.'.format(name,age)
print(result)

#使用变量填充,format参数必须是关键字参数
result = 'Beauty {name} is {age} this year，and I am {age}, too.'.format(name='Bians',age=18)
print(result)

#使用变量填充,format参数必须是关键字参数
result = f'Beauty {name} is {age} this year，and I am {age}, too.'
print(result)

判断

'''
判断：startwith,endwith,isalpha,isdigit,isalnum,isspace
返回值都是布尔类型的True，False
'''
s = 'apic27858.jpg'
result = s.startswith('ap') #判断以ap开头
print(result)   #True
result = s.endswith('jpg') #判断以jpg开头
print(result)#True

s = 'hello'
result = s.isalpha() #判断字符串是纯字母
print(result)
result = s.islower() #判断字符串是纯小写字母
print(result)

s = '100'
result = s.isdigit() #判断字符串是纯数字
print(result)

s = 'HELLO'
result = s.isupper() #判断字符串是纯大写字母
print(result)

s = 'HELLO123'
result = s.isalnum() #判断字符串是字母和数字组合
print(result)

练习题目1 : 文件上传

'''
练习：
1，模拟文件上传，键盘输入文件名称，判断文件名是否大于6位以上，扩展名是否是：jpg.gif,png格式
2, 如果格式不对，提示上传失败
3，如果名字不满足条件，而扩展名满足，则随机生成一个六位数字组成的文件名，打印成功上传xxxxxx.xxx文件，
'''
import random
filename = input('请输入文件名：')
#提取扩展名extention
ext = filename[-4:]
#判断扩展名
if filename.endswith('jpg') or filename.endswith('gif') or filename.endswith('png'):
    #判断名字长度
    if len(filename[:-4]) < 6:
        #生成一个随机的6位数字，先定义一个空字符串
        string = ''
        for i in range(6):
            #ord(char)函数将char类型的单字符转换成ASCII码值,chr(ASCII)函数将ASCII码转换成字符
            ch = chr(random.randrange(ord('0'),ord('9')+1))
            #直接将生成的随机数转为字符串赋值给ch
            # ch = str(random.randint(0,9))
            string += ch
            print(string)
        #将生成的随机数赋值给文件名
        # filename[:-3] = str(string)
        filename = string + ext
        print(f'成功上传文件:{filename}')
        pass
    else:
        print(f'成功上传文件:{filename}')
else:
    print('文件格式不对，请重新上传')

练习题目2：加需求版文件上传

换种方式来改写

'''
练习：
1，模拟文件上传，键盘输入文件名称，判断文件名是否大于6位以上，扩展名是否是：jpg.gif,png格式
2, 如果格式不对，提示上传失败
3，如果名字不满足条件，而扩展名满足，则随机生成一个六位数字字母组合的文件名，打印成功上传xxxxxx.xxx文件，
'''
import random
filename = input('请输入文件名：')
#判断扩展名
if filename.endswith('jpg') or filename.endswith('gif') or filename.endswith('png'):
    #判断文件名
    i = filename.rfind('.')
    #切片,获取文件名称和后缀
    name = filename[:i]
    ext = filename[i:]
    #判断名字长度
    if len(name) < 6:
        #重构文件名，生成一个随机的6位数字字母组合，先定义一个空字符串
        string = ''
        #定义一个包含所有字母和数字的字符串
        s = 'QWERTYUIOPASDFGHJKLXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
        for j in range(6):
            #产生一个随机数作为s字符串的index
            index = random.randint(0,len(s)-1)
            #获取下标对于的字符
            ch = s[index]
            string += ch
            print(string)
        #将生成的随机数赋值给文件名
        # filename[:-3] = str(string)
        filename = string + ext
        print(f'成功上传文件:{filename}')
        pass
    else:
        print(f'成功上传文件:{filename}')
else:
    print('文件格式不对，请重新上传')

练习题目3：用户验证 初版

'''
用户名：admin123
手机号：18911119999
密码：20220618
1，用户名或手机号 + 密码登录
2，用户名：全小写字母，首位不能是数字，长度必须6位以上
3，手机号：长度必须11位，纯数字
4，密码：纯6位数字
5，以上符合条件即可进入下一层
6，判断：用户名/手机号+密码是否正确，正确登录成功，否则登录失败
'''

username = 'admin123'
phone = '18911119999'
password = '220618'

while True:
    login_name = input('请输入用户名或手机号：')
    if (login_name.isalnum() or login_name.isalpha()) and not login_name.isdigit():
        if len(login_name) < 6 :
            print('用户名不足6位，请重新输入!')
        elif not login_name.islower():
            print('用户名不能包含大写字母,请重新输入!')
        elif login_name[0].isdigit():
            print('用户名不能以数字开头,请重新输入!')
        else:
            while True:
                login_pwd = input('请输入密码(6位纯数字):')
                if not login_pwd.isdigit():
                    print('密码不符合规则，请输入6位纯数字密码')
                elif len(login_pwd) != 6 :
                    print('密码不符合规则，长度必须6位，请输入6位纯数字密码')
                else:
                    if login_name == 'admin123' and login_pwd == '220618':
                        print('登录成功！')
                    else:
                        print('登录失败')
                    break

        break
    elif login_name.isdigit():
        if len(login_name) != 11 :
            print('手机号必须是11位，请重新输入！')
        else:
            while True:
                login_pwd = input('请输入密码(6位纯数字):')
                if not login_pwd.isdigit():
                    print('密码不符合规则，请输入6位纯数字密码')
                elif len(login_pwd) != 6 :
                    print('密码不符合规则，长度必须6位，请输入6位纯数字密码')
                # elif len(login_pwd) == 6 and login_pwd != password:
                #     print('密码不正确，请重新输入！')
                else:
                    if login_name == phone and login_pwd == password:
                        print('登录成功！')
                    else:
                        print('登录失败')
                    break
        break

练习题目4：用户验证 加强版本

'''
用户名：admin123
手机号：18911119999
密码：220618
1，用户名或手机号 + 密码登录
2，用户名：全小写字母，首位不能是数字，长度必须6位以上
3，手机号：长度必须11位，纯数字
4，密码：纯6位数字
5，以上符合条件即可进入下一层
6，判断：用户名/手机号+密码是否正确，正确登录成功，否则登录失败
7，可以尝试5次，5次之后，锁定用户
'''

username = 'admin123'
phone = '18911119999'
password = '220618'
count = 0
#将while循环条件设置为变量
flag = True
while flag:
    #输入用户名或手机号
    login_name = input("请输入用户名/手机号：")
    #判断
    if (login_name.islower() and login_name[0].isalpha() and len(login_name) >= 6) or (login_name.isdigit() and len(login_name) == 11) :
		#允许尝试5次
        while count < 5:
            login_pwd = input("请输入密码(6位纯数字):")
            # 判断密码是否是6位
            if login_pwd.isdigit() and len(login_pwd) == 6:
                #验证用户名密码的正确性
                if (login_name == username or login_name == phone) and login_pwd == password:
                    print('恭喜登录成功')
                    #跳出嵌套的循环
                    flag = False
                    break
                else:
                    print('用户名或密码不正确，请重新输入！')
                    count += 1
            else:
                print('密码必须是6位纯数字，请重新输入！')
                count += 1
                # break
        #统计次数
        if count < 5:
            print(f'你已经尝试了{count}次,登录成功！')
        else:
            print(f'你已经尝试了{count}次,账号暂时锁定!')
            #5次之后跳出循环
            flag = False
    else:
        print('用户名或手机号格式错误,请重新输入！')
        count += 1
        #允许尝试5次
        if count == 5:
            print(f'你已经尝试了{count}次,账号暂时锁定!')
            flag = False

练习题目5：用*打印菱形

'''
打印对角线为15颗星的菱形
       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************
 *************
  ***********
   *********
    *******
     *****
      ***
       *

'''
#for循环实现
#循环16次，i的取值范围0~15
for i in range(16):
    if i % 2 ==1:
        #将奇数颗星*赋值给变量s
        s = '*'*i
        #占占15个字符宽带，居中对齐，没有*的地方，用空格占位
        s = s.center(15)
        print(s)
#引入变量就j，也可直接使用整数
j = 14
#循环14次，i的取值范围0~13
for k in range(14):
    if k % 2 == 1:
        #当k为奇数时，j-k为倒序的奇数，13，11....1
        s = '*'*(j-k)
        # 占15个字符宽带，居中对齐，没有*的地方，用空格占位
        s = s.center(15)
        print(s)
        
        
#while循环实现
n =1
while n <= 15:
    s = '*'*n
    s = s.center(15)
    print(s)
    n += 2

m = 13
while m > 0:
    s = '*'*m
    s = s.center(15)
    print(s)
    m -=2

4.2 列表--> list

定义列表：<class 'list'>

1，空列表 ： []

2，有内容的列表：['A','B','C'],[1,2,3,4]

3，列表里可以嵌套列表

4.2.1列表操作

一般包括增、删、改、查4个方面。

添加

'''
添加、删除、修改、查询
1，添加元素： append，追加，类似排队
2，插入元素：insert
    insert(index,element):在指定的index位置，插入element，其余元素自动后移一位
3，列表合并：extend
    list1.extend(list2):将第二个列表list2合并到第一个列表list1中
'''
#添加
list1 = []
list2 = ['面包']

list1.append('牛奶')
list1.append('火腿')
list2.append('香蕉')

print(list1,'\n',list2)

#列表合并，可以直接相加
# list1 = list1 + list2
# print(list1) #['牛奶', '火腿', '面包', '香蕉']

#列表合并，使用函数
list1.extend(list2)
print(list1) #['牛奶', '火腿', '面包', '香蕉']

购买商品计价小程序

'''
购买多件商品：
商品名称、价格、数量
要求：商品名称不能是纯数字，价格和数量只能输入数字
用列表嵌套
'''
#定义一个存放商品的容器，类似购物车,空列表
container = []
#初始化总价和数量
p_sum = 0
q_sum = 0

#控制循环变量
flag = True
while flag:
    #添加商品
    name = input('输入商品名称：')
    # 判断商品名称正确，输入价格
    if not name.isdigit():
        flag1 = True
        while flag1:
            price = input('输入价格：')
            # 判断价格格式正确，输入数量
            if price.isalpha():
                print('商品价格必须是数字')
            else:
                while True:
                    quantity = input('输入购买数量：')
                    #判断数量输入格式正确，进行下一步
                    if quantity.isdigit() :
                        #作为同一个商品的属性放入
                        goods = [name,price,quantity]
                        #将商品添加到购物车
                        container.append(goods)
                        #询问是否继续添加
                        answer = input('请问是否继续购买商品？（按q或Q退出）')
                        if answer.lower() == 'q':
                            #跳出整个循环
                            flag = False
                            flag1 = False
                            break
                        else:
                            #跳出本层和上一层循环，回到新商品添加循环
                            flag1 = False
                            break
                    else:
                        print('商品数量必须是数字')
    else:
        print('商品名称不能是数字，价格和数量只能是数字')
#分隔符
print('*>'*20)
#遍历container
print(f"{'名称'.ljust(15)}\t{'价格'.ljust(10)}\t{'数量'.ljust(10)}")
for goods in container:
    print(f'{goods[0].ljust(15)}\t{goods[1].ljust(10)}\t{goods[2].ljust(10)}')
    #统计价格，单价*数量
    p_sum += float(goods[1])*int(goods[2])
    #统计数量
    q_sum += int(goods[2])
#打印数量和价格
print('*>'*20)
print(f'你一共购买了{q_sum}件商品，总价为{p_sum}')

删除

''''
删除：pop remove clear del
    pop(index):根据下标删除列表中的元素，不要超出index范围
        超出下标报错：IndexError: pop index out of range
    pop() : 不加任何参数，表示从后往前一次删除一个元素
    remove('元素名称')：根据元素名称删除，如果元素不存在，报错
        只删除查找到的第一个符合要求的元素，从左到右，多个同名的元素，只会删除一个
        元素不存在报错：ValueError: list.remove(x): x not in list
        关键字 in：元素 in 列表 --》表示元素是否在列表中？返回值 bool
    clear():清空列表中所有元素
    del list[] : 加上下标，则只删除列表中对应下标的值，
    del list :  不加下标，则直接删除整个列表，会从内存中移除
'''
list2 = ['牛奶', '火腿','火腿' ,'面包', '香蕉','火腿', '火腿']
# list2.pop(5)

# list2.remove('fang')
#将list2 的内存地址给list3 和 list4
list3 = list2
list4 = list2

del list2[2] #删掉火腿
print(list2)
#删除list2，只是删除了list2的地址， list3 和list4 依然可以继续读取到原来赋的值，
# 类似不同的钥匙去查看同一房间内的物品
del list2
print(list3)
print(list4)
'''
删除多个元素,这种情况，有连续的相同元素，会漏删，因为每次循环计数自动加1，
由于删除一个元素后，相邻的下一个元素index值往前移动,填充到已删除元素的位置
'''
#原始会漏删元素版本
for i in list2:
    if i == '火腿':
        list2.remove(i)

print(list2) # ['牛奶', '面包', '香蕉', '火腿', '火腿']

#改进版,倒序取元素，不会漏删元素版本
for i in list2[::-1]:
    if i == '火腿':
        list2.remove(i)

print(list2) # ['牛奶', '面包', '香蕉',]

#while循环实现不漏删除元素
n = 0
while n <len(list2):
    #满足条件，n的值保持不变
    if list2[n] == '火腿':
        list2.remove(i)
    #不满足条件，n的值加1
    else:
        n += 1
print(list2) # ['牛奶', '面包', '香蕉']

修改

'''
修改：
index(元素)：根据元素找其对应的下标，返回值是下标位置
修改元素值：
    list[index] = 'new element' 直接给赋新的值
'''

list1 = [1,2,3,'beauty',4,5,6,7,8,9,'beauty']

loc = list1.index('beauty')
print(loc) #3
print(list1[loc]) # beauty

list1[2] = '修改3'
print(list1) #[1, 2, '修改3', 'beauty', 4, 5, 6, 7, 8, 9, 'beauty']

查询

'''
查找：
1，index(元素)：根据元素找其对应的下标，返回值是下标位置
2，元素 in 列表 ： 返回布尔值， 元素 not in,返回也是布尔
3，列表.count() :返回整数，不存在则返回0，存在则返回个数
'''

list1 = [1,2,3,'beauty',4,5,6,7,8,9,'beauty']

if 'alpha' in list1:
    print('存在')
else:
    print('不存在')

排序和反转

'''
排序和反转：sort reverse
    sort() : 默认是升序,参数 reverse=False
    sort(reverse=True) : 降序排列
    reverse(): 反转，列表内反转，依旧是无须的
'''
#生成8个1~20 之间的随机数，保存到列表中，遍历打印，排序和反转

import random

#准备一个空列表
numbers = []

for i in range(8):
    ran = random.randint(1,20)
    #将生成的数追加到列表
    numbers.append(ran)
print(numbers)
numbers.sort() # 默认升序
numbers.sort(reverse=True) # 降序排列
print(numbers)

numbers.reverse() #单纯的反转，无排序
print(numbers)

手动实现冒泡排序

'''
交叉赋值： 2个变量值互换
冒泡排序： 手动实现sort 函数的功能
推荐力扣刷题学习网：https://ssg.leetcode-cn.com/leetbook/

'''
# a = 2
# b = 3
# a,b=b,a
# print(a,b) #3,2

nums = [3,5,2,1,4,7,6,8]
#控制轮数
for j in range(0,len(nums)-1):
    #控制两两比较，第一轮将最大的一个值放到最后，第二轮次大数排倒第二，...
    for i in range(0,len(nums)-1-j):
        if nums[i] > nums[i+1]:
            #符合条件，则开始两两交换
            a = nums[i]
            nums[i] = nums[i+1]
            nums[i+1] = a

print(nums)

4.3 元组--> tuple

4.3.1基础

''''
python 元组与列表类似，不同之处在于元组的元素不能修改（增，删，改）
元组使用小括号()，列表使用方括号[]
    list 列表
    tuple 元组
方法：
    count()
    index()
关键字：
    in, not in
    for .... in
    while
定义：
    var = ()
    注意：如果只有一个元素，一定要加上逗号，不然会被当成字符串，('aa',) (1,)
转换:
    list(tuple) --> 元组转列表
    tuple(list) --> 列表转元组
'''
t1 = ()
print(type(t1)) #<class 'tuple'>
t2 = ('aa')
print(type(t2)) #<class 'str'>
#如果只有一个元素，一定要加上逗号，不然会被当成字符串
t2 = ('aa',)
print(type(t2)) #<class 'tuple'>
t3 = ('aa','bb','cc')
print(type(t2)) #<class 'tuple'>
#下标和切片，不要越界
print(t3[1])
print(t3[1:]) #('bb', 'cc')
print(t3[::-1]) #('cc', 'bb', 'aa')
#count 计数
n = t3.count('aa')
print(n) #1
#根据元素获取下标位置
t3 = ('ee','dd','aa','bb','cc')
index = t3.index('bb',1,4) #index = t3.index('bb',start,end)
print(index) #1
# 支持 in not in
if 'cc' in t3:
    print('存在')
else:
    print('不存在')
#支持for ... in
for a in t3:
    print(a)
#转换
t3 = list(t3)
t3.append('ff')
print(t3) #['ee', 'dd', 'aa', 'bb', 'cc', 'ff']
t3 = tuple(t3)
print(t3) #('ee', 'dd', 'aa', 'bb', 'cc', 'ff')

4.4 字典--> dict

操作 ： 添加修改删除

''''
字典：{key:value}
元素： 键值对，--> 键是唯一的，值允许重复
下标或切片 --> 没有
操作：
1，添加元素：
    字典名[key] = value
    注意：key 是唯一的，添加是如果出现同名的key，则是将新的value替换key所对应的value，相当于修改
         key可以添加，删除，但不可以修改
2, 修改
    字典名[key] = value
    关键看‘键’：如果字典中不存在键，则是添加
              如果字典中存在键，则是修改
3， 删除
    clear(): 清空字典内容
    pop(key):根据key实现删除，删除的是键值对，返回值是key对应的value
    popitem(): 删除最后一组键值对，返回值是：(key,value) 元组-->('出版社', '天大出版社'), 从后往前删
    del : del dict['key'], 类似于pop
          del dict --> 删除整个字典

'''
#定义一个字典
dict1 = {}
print(type(dict1)) #<class 'dict'>

dict1['name'] = 'Beauty'
dict1['age'] = 21
dict1['gender'] = 'Female'

print(dict1) #{'name': 'Beauty', 'age': 21, 'gender': 'Female'}

#修改
dict1['age'] = 22

#添加
dict1['score'] = 95
print(dict1) #{'name': 'Beauty', 'age': 22, 'gender': 'Female', 'score': 95}

'''
练习：
book = {}
书名、价格、作者、出版社
促销：价格折扣8折
打印最终字典的内容
'''
#定义空字典
book = {}
#添加内容
book['书名'] = '三体'
book['价格'] = 30
book['作者'] = '刘慈欣'
book['出版社'] = '天大出版社'
print(book)
#修改价格
book['价格'] *= 0.8
print(book)
#pop 根据key实现删除，删除的是键值对，返回值是key对应的value
r = book.pop('出版社')
print(r) #天大出版社
print(book) #{'书名': '三体', '价格': 24.0, '作者': '刘慈欣'}

#popitem 删除最后一组键值对，返回值是：(key,value)-->('出版社', '天大出版社'), 从后往前删
r = book.popitem()
print(r) #('出版社', '天大出版社')
print(book) #{'书名': '三体', '价格': 24.0, '作者': '刘慈欣'}

操作 ： 遍历和查询

'''
1,遍历和查询：
    列表list : list.index(), list.count() in
    字典dict:dict.index(), dict.count() in
2,获取：
    dict.get():根据key得到value值
    dict[key]:根据key得到value值
        区别：
            get(key,default),如果key值不存在，返回默认，可以设置默认值
            dict[key]，如果key值不存在，报error错误

3,for...in 直接遍历，取出的是字典的key
for i in book1:
    print(i)
4,获取字典中所有的值 --> dict.values() 就是将所有的值放到一个列表
    book1.values()
5,获取字典中所有的key --> dict.keys() 就是将所有的key放到一个列表
    book1.keys()
6，获取键值对 --> dict.items()
for k,v in book1.items():
    print(k,v)
7,update 实现两个字典的合并
    dict1.update(dict2)
8,fromkeys : 创建出一个新的字典，以['key1','key2'] 为key值，['value'] 赋给key1 和key2
    dict1.fromkeys(['key1','key2'],['value'])

'''
book1 = {'书名': '三体', '价格': 24.0, '作者': '刘慈欣', '出版社': '天大出版社'}
book2 = {'书名': '百年孤独', '价格': 25.0, '作者': '加西亚·马尔克斯', '出版社': '清华大学出版社'}

books = [book1,book2]
#根据key得到value值
value= book1.get('书名')
print(value) #三体

#根据key得到value值，get(key,default),如果没有key值，返回默认
value= book1.get('书名1','红楼梦')
print(value)  #红楼梦

#for...in 直接遍历，取出的是字典的key
for i in book1:
    print(i) #打印的只有key

#获取字典中所有的值
book1.values()
print(book1.values()) #dict_values(['三体', 24.0, '刘慈欣', '天大出版社'])
print(list(book1.values())) #['三体', 24.0, '刘慈欣', '天大出版社']
#获取字典中所有的key
print(list(book1.keys())) #['书名', '价格', '作者', '出版社']
for k in book1.keys():
    print(k)

#获取字典中的键和值，key and value
result = book1.items()
print(result) #dict_items([('书名', '三体'), ('价格', 24.0), ('作者', '刘慈欣'), ('出版社', '天大出版社')])
#一个变量对应list中的一个元组
for i in book1.items():
    print(i) # 打印的是列表中的元组
    '''
    ('书名', '三体')
    ('价格', 24.0)
    ('作者', '刘慈欣')
    ('出版社', '天大出版社')
    '''
#2个变量，元组中的值交叉赋值
for k,v in book1.items():
    print(k,v) # 打印的是key和value
    '''
    书名 三体
    价格 24.0
    作者 刘慈欣
    出版社 天大出版社
    '''
#只能做添加使用
book1.setdefault("出版社1",'人民教育出版社') #类似 book1[key] = value, 只能添加，不能修改
print(book1) #{'书名': '三体', '价格': 24.0, '作者': '刘慈欣', '出版社': '天大出版社', '出版社1': '人民教育出版社'}

book1.setdefault("出版社1",'人民出版社') #类似 book1[key] = value, 只能添加，不能修改
print(book1) # {'书名': '三体', '价格': 24.0, '作者': '刘慈欣', '出版社': '天大出版社', '出版社1': '人民教育出版社'}

#update 实现两个字典的合并
dict1 = {'a':'Jane Aire','B':'Three body'}
book1.update(dict1)
print(book1)
#{'书名': '三体', '价格': 24.0, '作者': '刘慈欣', '出版社': '天大出版社', \
# '出版社1': '人民教育出版社', 'a': 'Jane Aire', 'B': 'Three body'}

#用给定的列表参数作为key创建新的字典
test = book1.fromkeys(['cc','dd'])
print(test) #{'cc': None, 'dd': None}一个列表
#如果给定两个列表，则是将后一个列表直接赋值给前一列表中的key
test = book1.fromkeys(['cc','dd'],['西游记','水浒传'])
print(test) #{'cc': ['西游记', '水浒传'], 'dd': ['西游记', '水浒传']}

练习1: 删除出版社信息

'''
练习：
book = {}
书名、价格、作者、出版社
借书：
books = [{},{}]
删除：每本书中的出版社
最终打印books
'''
book1 = {'书名': '三体', '价格': 24.0, '作者': '刘慈欣', '出版社': '天大出版社'}
book2 = {'书名': '百年孤独', '价格': 25.0, '作者': '加西亚·马尔克斯', '出版社': '清华大学出版社'}

books = [book1,book2]
#遍历一次，拿到的是字典,然后从字典中去删除键值对
for book in books:
    book.pop('出版社')
print(books)

练习2：添加新书到书架

'''
要求：
添加3本书到书架
书名不能重复
'''
#准备一个空的书架列表
books = []
#控制循环变量
flag = True
while flag:
    #用空格来区分输入的信息
    book = input('请添加书名、作者、价格，以空分隔：').split(' ')
    # i 作为books中的一个字典，判断书名是否已经存在
    for i in books:
        if i['书名'] == book[0]:
            print(f'{book[0]}已经存在，跳过，请重新输入')
            break
    # 这里是 for ... else 结构，for中不执行break，即进入else
    else:
        #将书添加到书架
        books.append({'书名':book[0],'作者':book[1],'价格':book[2]})
    #判断添加的数量，加满3本即退出
    if len(books) == 3 :
        print('已添加了3本书')
        flag = False
print(books)

4.5集合--> set

集合操作

'''
集合： set
特点：没有重复,无序的 --> 没有下标
符号：
    {} --> {元素，元素，元素，元素，....} --> 集合
    {} --> {key:value,....}--> 字典
移除元素： remove discard
    set.remove('element') --> element 存在就删除，不存在则报错
    set.remove('element') --> element 存在就删除，不存在nothing to do
    del --> 只能删除整个集合
    set.clear() --> 清空
    set.pop() --> 随机删除集合中的一个元素

'''
#定义一个集合，只有元素
set1 = {'Forrest'}
print(type(set1)) #<class 'set'>

#利用集合的无序和不重复，去掉列表中的重复元素
list1 = [1,2,5,3,2,5,8,3,3,9,1,4,6,5,2]
set2 = set(list1)
print(set2) #{1, 2, 3, 4, 5, 6, 8, 9}

#定义一个空集合
set3 =set()
print(type(set3)) #<class 'set'>
print(len(set3)) #0

#添加元素,重复元素不允许添加
set3.add('三体')
print(set3) #{'三体'}

#合并 append,extend, insert --> list /
#    add update --> set
set1.update(set3)
print(set1) #{'三体', 'Forrest'}

set4 = {'vj2N', 'iCl1', 'x9lM', 'O3H8', '8mrN'}
# set4.remove('x9lM')
# print(set4) #{'O3H8', 'iCl1', 'vj2N', '8mrN'}
# set4.remove('x9lM1')
print(set4) #KeyError: 'x9lM1'

set4.discard('x9lM1') #无返回值
set4.pop() #随机删除集合中的一个元素

#集合的交集intersection、并集union、差集diffence
set5 = {1,2,3,4,5}
set6 = {4,5,6,7,8}
#求交集&
result = set5.intersection(set6)
print(result) #{4, 5}
#求并集 |
result = set5.union(set6)
print(result) #{1, 2, 3, 4, 5, 6, 7, 8}
#求差集 -
result = set5.difference(set6)
print(result) #{{1, 2, 3}

print(set5 & set6) #{4, 5}
print(set5 | set6) #{1, 2, 3, 4, 5, 6, 7, 8}
print(set5 - set6) #{{1, 2, 3}

练习:产生5组随机的4位验证码

'''
产生5组验证码：字母数字组合，4位，不重复
最终打印所有验证码
'''
import random
#定义一个空集合
ver_code = set()
#准备一个字符串，包含字母和数字
source = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
#控制循环
flag = True
while flag:
    #定义一个空的code来接每次循环产生的随机数
    code = ''
    #4位验证码，循环4次
    for i in range(4):
        #在字符串source长度范围内获取随机的index值
        ran = random.randint(0,len(source)-1)
        #可以直接随机取一个字符
        # r = random.choice(source)
        #将每次获取到的值拼接为4为的字符串
        code += source[ran]
        # code += r
    #将for循环生成的字符串添加到集合，利用集合的不重复性
    ver_code.add(code)
    #集合中添加5组验证码后就退出
    if len(ver_code) == 5:
        flag = False

print(ver_code)

4.6 公共方法

'''
公共方法：
    max(): 求一组数的最大值
    min(): 求一组数的最小值
    sum(): 求一组数的和
    abs(): 求绝对值
    sorted(): 给一组数排序，列表，元组都可以
    chr(): 给ascii码值，返回对应字符
    ord(): 给字符，返回ascii码值
    len(): 求长度
符号： + - * & | in not in
    + 支持字符串、列表、元组
    * 支持字符串、列表、元组
    - & | 只能用于集合
    in / not in  支持字符串、列表、元组
'''
#排序
t1 = (88,26,35,11,9,69,73,45)
result = sorted(t1)
print(result) #[9, 11, 26, 35, 45, 69, 73, 88]

#求和
result = sum(t1)
print(result) #356

#给ascii码值，返回对应字符
result = chr(66)
print(result) #B

#给字符，返回ascii码值
result = ord('d')
print(result) #100

标签：02,name,Python,编程,列表,result,key,print,login
来源： https://www.cnblogs.com/orange2016/p/16394371.html

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