【python 1】python 基础

一、格式化输出

1、占位符

%s: string，字符串占位符，如果要拼接的不是字符串，则底层会强制转成 string
%d: digit，表示数字，就是对数字的占位，底层也会强制转成整形
%f: float，表示浮点数，%.1f 保留小数点后一位, %.0f 保留小数点后0位

name = '张三'
age = 18.5
year = 2020
salary = 888.85
print('姓名：%s' % name)
print('年龄：%d' % age)
print('年龄：%f' % age)
print('今年是：%d' % year)
print('今年是：%02d' % year)
print('薪水是：%.1f' % salary)
输出：>>>
姓名：张三
年龄：18
年龄：18.500000
今年是：2020
今年是：2020
薪水是：888.8

2、+ 拼接输出：

‘+’：拼接字符串
str()：把其他类别强制转化成字符串，强制类型转化

person = '大圣'
address = '北京市海淀区'
phone = '13333333333'
# '+' 可以拼接字符串，不能拼接 int
# %s 是一个占位符
print('收件人：' + person + '收货地址：' + address+ '联系方式 ：' + phone)
print('收件人：%s, 收货地址：%s, 联系方式 ：%s'  %  (person, address, phone))

3、message 输出：

movie = '皮卡丘'
ticket = 45.9
count = 34
total = ticket * count
message = '''
电影：%s
票价：%.1f
人数：%d
总票价：%.1f
''' % (movie, ticket,count,total)
print(message)

输出：>>>
电影：皮卡丘
票价：45.9
人数：34
总票价：1560.6

4、format 输出

format：字符串里边的一个函数，用 ‘.’ 调用，只有字符串才能用 . 调用 format，str.fromat()

format 不受变量类型的影响

name = '乔治'
age = 3
hobby = '玩水！'
message = '{}今年{}岁了，喜欢{}'.format(name,age,hobby)
print(message)

二、input 输入

python 解释器，遇到 input，就是标准的输入流，等待键盘的输入
name 这个变量（容器），接受流的东西

name = input(‘请输入姓名：’, name) # 阻塞式，敲了回车后，表示消除阻塞
print(name)

捕鱼达人游戏：

input 输入的都是 str 类别

print('''
*****************
    捕鱼达人
*****************
''')
username = input('输入用户名：')
password = input('输入密码：')
print('%s请充值以加入游戏' % username)
coins = input('请充值：')
print('%s 充值成功！当前游戏币是：%d' % (username, int(coins)))

输出：>>>

*****************
    捕鱼达人
*****************

输入用户名： wm
输入密码： w
wm请充值以加入游戏
请充值： 2
wm 充值成功！当前游戏币是：2

print('''
*****************
    英雄联盟
*****************
''')
role = input('请输入角色名称：')
equipment = input('请输入装备：')
upgrade_equipment = input('请输入需要购买的装备：')
pay = input('请输入付款金额：')
equipment = upgrade_equipment
print('{}拥有{}装备，购买此装备花了{}钱'.format(role, equipment,pay))
输出：>>>

*****************
    英雄联盟
*****************

请输入角色名称： 阿刁
请输入装备： 长刀
请输入需要购买的装备： 长剑
请输入付款金额： 400
阿刁拥有长剑装备，购买此装备花了400钱

三、pass、break

pass :占位，保证完整的语法结构

if 10>7:
    print('yes')
else:
    pass
print('over')

下面写法会报错：

if 10>7:
    print('yes')
else:
    
print('over')

break：

for i in range(3):
    username = input('请输入用户名：')
    password = input('请输入密码：')
    if username == 'mm' and password == '123455':
        print('欢迎{}'.format(username))
        break
    else:
        print('用户名或密码错误！')
print('-----------轻松购物吧-------------')     
输出：>>>
请输入用户名： mm
请输入密码： 123455
欢迎mm
-----------轻松购物吧-------------   

for i in range(3):
    if i == 1:
        print('黑店，等着关门吧！')
        break
    else:
        print('真香')
print('等着警察吧！')
输出：>>>
真香
黑店，等着关门吧！
等着警察吧！

continue:

跳过循环体（for、while）下方的语句，不执行，继续执行下一次的循环。

import random
print('*'*30)
print('欢迎进入澳门赌场')
print('*'*30)
username = input('请输入用户名：')
money = 0
answer = input('确定进入游戏吗？(y/n)')
if answer == 'y':
    while money<2:
        n = int(input('金币不足，请充值！(请充值100的倍数)'))
        if n%100 == 0 and n>0:
            money = (n//100)*30
        else:
            print('请充值100的倍数！')
    print('当前剩余游戏币：{}，玩一局游戏扣除2个币'.format(money))
    print('进入游戏.............')
    while True:
        # 模拟骰子
        t1 = random.randint(1,6)
        t2 = random.randint(1,6)
        money -= 2 
        # 两个骰子之和大于6->大，否则为小
        print('系统洗牌完毕，请猜大小：')
        guess = input('输入大/小：')
        # 判断
        if ((t1+t2)>6 and guess == '大') or ((t1+t2)<=6 and guess == '小'):
            print('恭喜{}，本局游戏获得奖励一个游戏币'.format(username))
            money += 1
        else:
            print('很遗憾！本局游戏输啦-.-')
        answer = input('是否继续下一局，需要扣除2个游戏币？(y/n):')
        if answer != 'y' or money < 2:
            print('退出游戏啦！！！')
            break
输出：>>>
******************************
欢迎进入澳门赌场
******************************
请输入用户名： ww
确定进入游戏吗？(y/n) y
金币不足，请充值！(请充值100的倍数) 100
当前剩余游戏币：30，玩一局游戏扣除2个币
进入游戏.............
系统洗牌完毕，请猜大小：
输入大/小： 大
恭喜ww，本局游戏获得奖励一个游戏币
是否继续下一局，需要扣除2个游戏币？(y/n): y
系统洗牌完毕，请猜大小：
输入大/小： 大
恭喜ww，本局游戏获得奖励一个游戏币
是否继续下一局，需要扣除2个游戏币？(y/n): y
系统洗牌完毕，请猜大小：
输入大/小： 大
很遗憾！本局游戏输啦-.-
是否继续下一局，需要扣除2个游戏币？(y/n): n
退出游戏啦！！！

四、字符串

== ：判断的内容是否相同
is：判断的是地址是否相同

s1='abc'
s2="abc"
s3='''abc'''
print(s1==s2)      
print(s1 is s2)

输出：>>>
True
True

直接赋值时，两个相同的字符串地址是相同的

s1 = input('请输入：')
s2 = input('请输入：')
print(s1==s2)
print(s1 is s2)
输出：>>>
请输入： aa
请输入： aa
True
False

键盘输入时，会从底层处理，两个相同的字符串的地址是不同的。

1、字符串的运算符：+

s3 = s1 + s2
s4 = s1 * 5
print(s3)
print(s4)
输出：>>>
aaaa
aaaaaaaaaa

2、in/not in

name = 'steven'
result = 't' in name  # True/False
print(result)
输出：>>>
True

name = 'steven'
result = 't' not in name  # True/False
print(result)
输出：>>>
False

3、%： 字符串格式化

print('%s说：%s' % (name,'好好学习'))
输出：>>>
steven说：好好学习

4、r： 保留原格式

print(r'%s说:\'hahaha\' '% name)
print('%s说:\'hahaha\' '% name)
输出：>>>
steven说:\'hahaha\' 
steven说:'hahaha' 

5、[] [:]

filename = 'picture.png'
print(filename[0])
print(filename[-1])
print(filename[0:3])
print(filename[3:])  # 省略后面，表示直接到末尾
print(filename[:7])  # 省略前面，表示从0开始
print(filename[3:-1])
print(filename[:-2])
print(filename[-5:-1])
print(filename[::-1])
输出：>>>
p
g
pic
ture.png
picture
ture.pn
picture.p
e.pn
gnp.erutcip

str1 = 'abcdefg'
print(str1[-1:-5:-1]) # 有 -1 就相当于反向取值,从右往左
print(str1[5:0:-1])
print(str1[:])        # [:] 所有的
输出：>>>
gfed
fedcb
abcdefg

str = 'hello world'
# 正向输出 world
print(str[6:])
# 逆向输出 ello
print(str[5:0:-1])
# 逆向输出整个 hello world
print(str[::-1])
# 打印 lo wo
print(str[3:8])
输出：>>>
world
 olle
dlrow olleh
lo wo

6、内建函数：大小写

message = 'zhaorui is a pretty girl!'
# capitalize() 将字符串的第一个字符转换为大写
msg_c = message.capitalize()
print(msg)

# title() 返回标题化的字符串，即所有单词都是以大写开始，其余字母均为小写
msg_t = message.title()
print(msg_t)
# upper()
msg_u = message.upper()
print(msg_u)
# lower()
msg_l = message.lower()
print(msg_l)

输出：>>>
Zhaorui is a pretty girl!
Zhaorui Is A Pretty Girl!
ZHAORUI IS A PRETTY GIRL!
zhaorui is a pretty girl!

验证码案例
s = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
print(len(s)) # 求字符串的长度，返回值是一个整形的
# 四个随机数
code = ''
# print(s.lower())
import random
for i in range(4):
    ran = random.randint(0,len(s)-1)
    code += s[ran]
print('验证码是：',code)
# 提示用户输入验证码
user_input = input('请输入验证码：')
if user_input.lower() == code.lower():
    print('验证码输入正确！')
else:
    print('验证码错误！')
输出:>>>
62
验证码是： IChf
请输入验证码： ichf
验证码输入正确！

7、内建函数 查找 .find()/.index()

#--------------find()----------------------
s1 = 'index lucy lucky good'
# find()：返回字母第一次出现的位置，如果返回-1，则没找到
# find('要查找的字符'，start,end)
position1 = s1.find('r')
print(position1)
position2 = s1.find('l')
print(position2)
position3 = s1.find('l',position2)
print(position3)
position4 = s1.find('l',position2+1)
print(position4)
输出：>>>
-1
6
6
11

#--------------------rfind()------------
# rfind() 从右侧检索
url = 'https://www.baidu.com/img/bd_logo1.png'
p = url.rfind('/')
print(p)
print(url[p+1:])
url.rfind('.')
输出：>>>
25
bd_logo1.png
34

8、内建函数 替换

#---------------replace()--------------
# .replace(old,new,max) max 是最多替换次数
s1 = 'index lucy lucky good'
s1.replace(' ','_')
输出：>>>
'index_lucy_lucky_good'

9、内建函数 编解码（中文需要）

网络传输是要先对内容编码，然后解码

# encode：编码, 以 encoding 的指定的编码格式编码字符串
encode(encoding='UTF-8', errors='strict')
# decode：解码

message = '开饭啦！'
# gbk 中文  
# gb2312 简体中文
# unicode：各个国家的编码方式都综合起来，升级版是 utf-8
en = message.encode('utf-8')
print(en)
de = en.decode('utf-8')
print(de)
输出：>>>
# b 就表示二进制
b'\xe5\xbc\x80\xe9\xa5\xad\xe5\x95\xa6\xef\xbc\x81'
开饭啦！

10、内建函数 判断开头/结尾

# 判断以什么开头 startswith()
# 判断以什么结尾 endswith()

filename = '笔记.doc'
result = filename.endswith('doc')
print(result)
s = 'hello'
result2 = s.startswith('H')
print(result2)
>>>
True
False

# 完成文件上传的确认功能
path = input('请选择文件：') # 
# 分析：要上传文件的路径------> 判断是否是图片类型
position = path.rfind('\\')
filename = path[p+1:]
print(p,filename)

path = input('请选择文件：') # ‪C:\Users\man.wang\Desktop\111.jpg
# 分析：要上传文件的路径------> 判断是否是图片类型
position = path.rfind('\\')
filename = path[position+1:]
print(p,filename)
# 判断是否是图片类型
if filename.endswith('jpg') or filename.endswith('png') or filename.endswith('bmp'):
    print('上传成功')
else:
    print('不是图片格式，请上传图片格式！')
输出：>>>
请选择文件： ‪C:\Users\man.wang\Desktop\111.jpg
25 111.jpg
上传成功

while True:
    path = input('请选择文件：') # ‪C:\Users\man.wang\Desktop\111.jpg
    # 分析：要上传文件的路径------> 判断是否是图片类型
    position = path.rfind('\\')
    filename = path[position+1:]
    print(p,filename)
    # 判断是否是图片类型
    if filename.endswith('jpg') or filename.endswith('png') or filename.endswith('bmp'):
        print('上传成功')
        break
    else:
        print('不是图片格式，请上传图片格式！')
输出：>>>
请选择文件： C:\Users\man.wang\Desktop\111.doc
25 111.doc
不是图片格式，请上传图片格式！

11、判断是否是字母、数字 isalpha() isdigit()

s = 'abc6'
result = s.isalpha()
print(result)
输出：>>>
False

s = '8888'
result = s.isdigit()
print(result)
输出：>>>
True

12、连接 join

join(seq)：以指定字符串作为分隔符，将 seq 中的所有元素合并为一个新的字符串

new_str = '_'.join('abc')
print(new_str)
输出:>>>
a_b_c

# 列表 list=['a','b','c']
list1 = ['a','b','c']
result = ''.join(list1)
print(result)
result = ' '.join(list1)
print(result)
输出：>>>
abc
a b c

13、去除空格，strip() / lstrip() / rstrip()

strip() :去除左右两侧字符串
lstrip()：去除左侧字符串
rstrip()：去除右侧字符串

s = '     hello      '
s = s.lstrip()
print(s+'8')
s = s.rstrip()
print(s+'8')
输出：>>>
hello      8
hello8

14、字符串分割: split()

将分割后的字符串放到列表里边

s = 'hello world hello kitty'
result = s.split(' ')
print(result)
result = s.split(' ', 2) # 2 表示切两下
print(result)
输出:>>>
['hello', 'world', 'hello', 'kitty']
['hello', 'world', 'hello kitty']

15、字符串中特定符号计数：count()

s = 'hello world hello kitty'
result = s.count(' ')
print('空格个数：',result)
输出：>>>
空格个数： 3

16、总结

① 输入两个字符串，从第一个字符串里边删除第二个字符串中所有的字符
例如：’ They are students ‘，’ aeiou ’

# 方法一
s1 = input('请输入第一个字符串')
s2 = input('请输入第二个字符串')
s3 = ''
for i in s1:
#     print(i,end='') # 输出不换行
    if i not in s2:
        s3 += i
print(s3)
输出：>>>
请输入第一个字符串 ahgbdj
请输入第二个字符串 jjj
ahgbd

# 方法二
s1 = input('请输入第一个字符串')
s2 = input('请输入第二个字符串')
s3 = ''
for i in s2:
    s1 = s1.replace(i,'')
print(s1)
输出:>>>
请输入第一个字符串 eefdfg
请输入第二个字符串 dfd
eeg

# 方法三
# 先去重
s1 = input('请输入第一个字符串')
s2 = input('请输入第二个字符串')
s3 = ''
for i in s2:
    if i not in s3:
        s3 += i
print(s3)
for i in s3:
    s1 = s1.replace(i,'')
print(s1)
输出：>>>
请输入第一个字符串 eettt
请输入第二个字符串 e
e
ttt

② 小易喜欢的单词具有以下特征，输入字母判断是否喜欢：

• 每个字母都是大写
• 单词中没有连续相等的字母

word ='FOOD'
for i in range(len(word)):
    if word[i]<'A' and word[i]>'Z':
        print('不喜欢,不是大写')
        break
    else:
        if i < len(word)-1 and word[i] == word[i+1]:
            print('不喜欢，有叠词')
            break
else:
    print('喜欢')
输出：>>>
不喜欢，有叠词

五、列表

产生10个不同的随机数，放到 list 里边

random_list=[]
i=0
while i<10:
    ran = random.randint(1,20)
    if ran not in random_list:
        random_list.append(ran)
        i += 1
print(random_list) 
输出：>>>
[2, 20, 19, 9, 7, 6, 14, 15, 13, 5]

print('---------------自定义求最大值---------------')
max_value = random_list[0]
min_value = random_list[0]
print('random_list:',random_list)
for value in random_list:
    if value > max_value:
        max_value = value
    elif value < min_value:
        min_value = value
print('                最大值是:',max_value)
print('                最小值是:',min_value)
print('-------------------------------------------')
输出：>>>
---------------自定义求最大值---------------
random_list: [2, 20, 19, 9, 7, 6, 14, 15, 13, 5]
                最大值是: 20
                最小值是: 2
-------------------------------------------

字符串支持的符号： +, * , in, not in, []

列表支持的符号： +, *, in,

列表中的元素：整型、字符串、浮点、列表、字典、元组等都可以支持

l1 = [1,2,3]
l2 = [4,5,6]
l3 = l1 + l2
print('l3',l3)
l4 = l1*3
print('l4',l4)

result1 = 3 in l1
print(result1)

result2 = [3] in l1
print(result2)

result3 = [3] in [1,2,3,[3],4]
print(result3)

result4 = [3,2] in [1,2,[3,2,1],4]
print(result4)

输出：>>>
l3 [1, 2, 3, 4, 5, 6]
l4 [1, 2, 3, 1, 2, 3, 1, 2, 3]
True
False
True
False

l5 = [[1,2],[3,4],[5,6,7]]
print('l5_1:', l5[1])
print('l5_2:', l5[1][1])
输出:>>>
l5_1: [3, 4]
l5_2: 4

列表中的函数：
添加：append、extend、insert
删除：del list[index]、remove、pop、clear

remove:

hotpot_list = ['海底捞', '呷哺呷哺', '张亮麻辣烫', '热辣一号', '宽板凳']
hotpot_list.append('张亮麻辣烫')
print(hotpot_list)
# .remove() 移除某个值的第一个匹配项，返回值是 None，如果没有找到要删除的元素，报出异常
hotpot_list.remove('张亮麻辣烫')
print(hotpot_list)

hotpot_list.remove('杨国福麻辣烫')
print(hotpot_list)

输出: >>>
['海底捞', '呷哺呷哺', '张亮麻辣烫', '热辣一号', '宽板凳', '张亮麻辣烫']
['海底捞', '呷哺呷哺', '热辣一号', '宽板凳', '张亮麻辣烫']
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-32-c7f20d5b1dcc> in <module>
      6 print(hotpot_list)
      7 
----> 8 hotpot_list.remove('杨国福麻辣烫')
      9 print(hotpot_list)

ValueError: list.remove(x): x not in list

pop: 从末尾删除，返回值是删除的那个元素

hotpot_list = ['海底捞', '呷哺呷哺', '张亮麻辣烫', '热辣一号', '宽板凳']
hotpot_list.append('张亮麻辣烫')
print(hotpot_list)

result = hotpot_list.pop()
print(result)
输出:>>>
['海底捞', '呷哺呷哺', '张亮麻辣烫', '热辣一号', '宽板凳', '张亮麻辣烫']
张亮麻辣烫

队列：先进先出
栈：先进后出
列表就是栈的一种表示，前面的只能后出。

append：末尾追加
pop：末尾弹出
reverse：翻转，对 list 逆序，但原来的list并没变
sort：排序 list.sort()、sorted(list)
count：统计元素出现的次数

l = [3,5,1,6,3,2]
l.sort()
print(l)
l.sort(reverse=True)
print(l)
输出：>>>
[1, 2, 3, 3, 5, 6]
[6, 5, 3, 3, 2, 1]

l.count(3)
输出：>>>
2

枚举：enumerate()

可以同时得到下标和元素的值

l1 = ['a','abc','jk','opop']
for index,value in enumerate(l1):
    print(index,value)
   
输出: >>>
0 a
1 abc
2 jk
3 opop

for value in l1:
    print(value)
输出:>>>
a
abc
jk
opop

冒泡排序：

# 自定义排序    冒泡排序
numbers = [7,4,6,3]
for i in range(len(numbers)):
    print('i',numbers[i])
    for j in range(i+1,len(numbers)):
        print('j',numbers[j])
        if numbers[i] > numbers[j]:
            # 快速交换
            numbers[i],numbers[j] = numbers[j],numbers[i]
            print(numbers)
    print('--------------->',i)
输出：>>>
i 7
j 4
[4, 7, 6, 3]
j 6
j 3
[3, 7, 6, 4]
---------------> 0
i 7
j 6
[3, 6, 7, 4]
j 4
[3, 4, 7, 6]
---------------> 1
i 7
j 6
[3, 4, 6, 7]
---------------> 2
i 7
---------------> 3

总结列表：
1、定义：l=[], l=[‘aaa’]
2、符号：+，*，in，not in，is（地址相等对比），not is
3、系统中的函数：len()，sorted()，max(), min(), list(), enumerate(),
4、列表自身的函数：

• 添加元素：末尾添加 ().append、末尾添加一组元素 ().extend、指定位置插入 ().insert
• 删除元素：del list[index]、remove（obj）删除指定元素、pop 弹出、clear 清空
• 其他：count() 求指定元素的个数、sort() 排序、reverse() 翻转、

六、元组

类似于列表，特点：

• 定义的符号：()
• 元组中的内容不可修改

t1 = ()
print(type(t1))

t2 = (1)
print(type(t2))

t3 = ('hello','world')
print(type(t3))

t4 = ('hello')
print(type(t4))

t5 = ('hello',)
print(type(t5))

输出：>>>
<class 'tuple'>
<class 'int'>
<class 'tuple'>
<class 'str'>
<class 'tuple'>

元组不能修改，可以先生成一个list，用 tuple(list) 强转就好啦。

import random
list = []
for i in range(10):
    ran = random.randint(1,20)
    list.append(ran)
print(list)
t6 = tuple(list)
print(t6)

# tuple 查询和 list 用法相同
print(t6[0])
print(t6[-1])

# 最大值、最小值
print('max:',max(t6))
print('min:',min(t6))

# 求和
print('sum:',sum(t6))

# 求长度
print('len',len(t6))
输出：>>>
[6, 9, 10, 14, 10, 18, 17, 9, 17, 10]
(6, 9, 10, 14, 10, 18, 17, 9, 17, 10)
6
10
max: 18
min: 6
sum: 120
len 10

tuple 的内置函数：

• count
• index

print('9 的个数 count:',t6.count(9))
print('9 的位置 index:',t6.index(9))
输出：>>>
9 的个数 count: 2
9 的位置 index: 1

拆包的变量个数和元组个数不一致：*

t7 = (2,5,4,3,2)
a,b,c = t7
print(a,b,c)
输出：>>>
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-16-583ce8d1a98f> in <module>
      1 t7 = (2,5,4,3,2)
----> 2 a,b,c = t7
      3 print(a,b,c)

ValueError: too many values to unpack (expected 3)

使用 * 可以把那一项中的所有值放到一个列表中返回来

t7 = (2,5,4,3,2)
a,b,*c = t7
print(a,b,c)
输出：>>>
2 5 [4, 3, 2]

# * 也可以代替未知的个数，底层看到*就给你准备一个容器[],有的话就往里放，没有的就不放
t8 = (9,)
a,*b = t8
print(a,b)
输出:>>>
9 []

元组的特点：

• 符号：()
• 只能查询，不能修改
• 关键字 tuple
• 符号： +, *, is, not is, in, not in
• 系统函数： min, max, sorted,len
• 自带函数：count(), index()
• 拆装包：x,*y

七、字典

字典的应用：
‘貂蝉’ — [‘屠龙刀’,‘手榴弹’]
貂蝉和貂蝉的武器绑定

特点：

• 符号：{}
• 关键字：dict
• 键值对保存：key:value，成对保存的。key是唯一的，value可以是不唯一的。

字典里边的函数：

• items()：把字典中的每对 key 和 value 封装成元组，放到列表里边
• values()：取出字典中的所有值，保存到列表中
• keys()：取出所有key，保存到列表中

字典的内置函数：

• get() 直接拿到key对应的value，没有改该 key 的话，返回 None
• 删除：
  .pop(key)，根据key来删除字典中的键值对，返回的是key对应的 value 。
  .popitem()，从末尾删除
  .clear()，全部删除
• 末尾添加： .update() 合并操作
• 创建一个新的字典：fromkeys(seq)

dict2 = {'张三': 100,'李四':100,'王五':90}
print(dict2.get('张三'))
# print(dict2['赵飞'])  # 报错
print(dict2.get('赵飞'))
print(dict2.get('赵飞',99)) # 如果没有赵飞，则给个默认值 99

输出：>>>
100
None
99

字典中使用 in：
判断要找的元素有没有在 key 中出现

print('王五' in dict2)
输出:>>>
True

定义：

# 定义空字典
dict1 = {} # 用的较多
dict2 = dict()
# 定义有值的字典
dict3 = {'ID':7485736,'name':'lucky','age':18}
print('dict1:',dict1)
print('dict2:',dict2)
print('dict3:',dict3)

输出：>>>
dict1: {}
dict2: {}
dict3: {'ID': 7485736, 'name': 'lucky', 'age': 18}

字典的增删改查：

# 增加
list[index] = value
dict6[key] = value
# 修改
list[index] = newvalue
dict[key] = newvalue
# 查询
list[index] 
dict[key]

# 增: dict6[key] = value, key同名的，value会被后面来的覆盖
dict6 = {}
dict6['brand'] = 'huawei'
print('1',dict6)
dict6['brand'] = 'mi'
print('2',dict6)
dict6['type'] = 'p30_pro'
dict6['price'] = '9000'
dict6['color'] = 'black'
print('3',dict6)
输出：>>>
1 {'brand': 'huawei'}
2 {'brand': 'mi'}
3 {'brand': 'mi', 'type': 'p30_pro', 'price': '9000', 'color': 'black'}

# 改 

# 查

# 删
dict2 = {'张三': 100,'李四':100,'王五':90}
del dict2['王五']
del dict2['haha']  # key error
dict2.pop('李四')
dict2.popitem() # 从末尾删除

# 列表中找元素是用下标去找
list1 = [3,5,7,8]
print(list1[2])
# 字典中找元素是用 key 去找
dict1 = {'1':'张三', '2':'李四', '3':'王五'}
print(dict1['2'])

dict2 = {'张三': 100,'李四':100,'王五':90}
print('张三得分：', '张三')
print('张三得分：', dict2['张三'])
# 考试得分大于90分的人
# 单独对字典进行遍历，遍历的结果：遍历之后，拿到的是字典的 key
for key in dict2:
    print(key)
输出：>>>
7
李四
张三得分： 张三
张三得分： 100
张三
李四
王五

items：

print(dict2.items())
print('----------------------------')
for i in dict2.items():
    print(i)
print('----------------------------')
for key,value in dict2.items():
    print(key,value)
print('----------------------------')       
for key,value in dict2.items():
#     print(key,value)
    if value > 90:
        print(key)
输出：>>>
dict_items([('张三', 100), ('李四', 100), ('王五', 90)])
----------------------------
('张三', 100)
('李四', 100)
('王五', 90)
----------------------------
张三 100
李四 100
王五 90
----------------------------
张三
李四

values：

results = dict2.values()
print(results)
print('------------------')
for score in dict2.values():
    print(score)
print('------------------')
# 求平均分
values = dict2.values()
print(sum(values)/len(values))

keys：

# 找人
print('--------------------')
names = dict2.keys()
print(names)
print('--------------------')
print('王五' in dict2)
输出：>>>
--------------------
dict_keys(['张三', '李四', '王五'])
--------------------
True

案例：用户注册

print('---------------欢迎来到智联招聘用户注册--------------')
# 用列表模拟数据库
database = []
while True:
    username = input('请输入用户名：')
    password = input('请输入密码：')
    repassword = input('请再次输入密码：')
    email = input('请输入邮箱：')
    phone = input('请输入手机号码：')
    # 定义一个字典，保存这个用户的信息
    user = {}
    # 将信息保存到字典
    user['username'] = username
    if password == repassword:
        user['password'] = password
    else:
        print('两次密码不一致！')
        continue
    user['email'] = email
    user['phone'] = phone
    # 保存到数据库
    database.append(user)
    answer = input('是否继续注册？(y/n)')
    if answer != 'y':
        break
print(database)
输出：>>>
---------------欢迎来到智联招聘用户注册--------------
请输入用户名： ww
请输入密码： 1234
请再次输入密码： 123
请输入邮箱： 222
请输入手机号码： 222
两次密码不一致！
请输入用户名： ww
请输入密码： 123
请再次输入密码： 123
请输入邮箱： 123
请输入手机号码： 123
是否继续注册？(y/n) n
[{'username': 'ww', 'password': '123', 'email': '123', 'phone': '123'}]

八、集合

特点：无序、不重复

list1 = [3,5,2,7,3,5,6]
# 声明集合,声明空集合，只可以用 set()，如果用 {} 里边什么都没放，则生成的是 dict
s1 = set()
print(s1)
s2 = {}
print(type(s2))
输出：>>>
set()
<class 'dict'>

# 集合特点 ：去重
s3 = set(list1)
print(s3)
输出：>>>
{2, 3, 5, 6, 7}

1、增加元素：

# 1、add，把集合当成一个整体添加到另一个集合里边
s1.clear()
s1.add('hello')
s1.add('小猪佩奇')
s1.add('luck')
print(s1)
t1 = ('林志玲','言承旭')
s1.add(t1)
print(s1)
输出：>>>
{'小猪佩奇', 'luck', 'hello'}
{'小猪佩奇', ('林志玲', '言承旭'), 'luck', 'hello'}

# 2、update，把集合中的元素拆开添加到集合里边
s1.clear()
s1.add('hello')
s1.add('小猪佩奇')
s1.add('luck')
t1 = ('林志玲','言承旭')
s1.update(t1)
print(s1)
输出：>>>
{'言承旭', 'luck', '林志玲', '小猪佩奇', 'hello'}

2、删除元素

# remove, 如何元素存在则删除，不存在则报错
s1 = {'言承旭', 'luck', '林志玲', '小猪佩奇', 'hello'}
s1.remove('言承旭') 
print(s1)
print('------------------------')
# dicard, 删除，不存在也不报错
s1 = {'言承旭', 'luck', '林志玲', '小猪佩奇', 'hello'}
s1.remove('言承旭') 
print(s1)
print('------------------------')
# pop 随机删除，一般从第一个开始删
s1.pop()
print(s1)
print('------------------------')
# clear
s1.clear()
print(s1)
输出：>>>
{'林志玲', 'luck', '小猪佩奇', 'hello'}
------------------------
{'林志玲', 'luck', '小猪佩奇', 'hello'}
------------------------
{'luck', '小猪佩奇', 'hello'}
------------------------
set()

set 支持的符号： -，&, |

# 差集，符号是-，函数是 difference
set7 = {1,2,3,4}
set8 = {1,2,3,4,5,6,7,8}
set9 = set7 - set8
print(set9)
set10 = set8 - set7
print(set10)
输出：>>>
set()
{8, 5, 6, 7}

set9 = set7.difference(set8)
print(set9)

# 交集
set6 = set7 & set8
print(set6)
print('----------------')
set5 = set7.intersection(set8)
print(set5)
输出：>>>
{1, 2, 3, 4}
----------------
{1, 2, 3, 4}

# 并集
set5 = set7 | set8
print(set5)
print('-------------')
set6 = set7.union(set8)
print(set8)
输出:>>>
{1, 2, 3, 4, 5, 6, 7, 8}
-------------
{1, 2, 3, 4, 5, 6, 7, 8}

找出两个列表的不同元素：

l1 = [5,3,2,5,7,3,6,4]
l2 = [9,7,3,5,4,2,1,4]
s1 = set(l1)
s2 = set(l2)
# 对称差集，两个集合里边不同的元素
result = (s1|s2) - (s1&s2)
print(result)
print('-------------')
result = s1^s2   # ^ 异或
print(result)
输出：>>>
{1, 6, 9}
-------------
{1, 6, 9}