Python的基础数据类型
Python的基础数据类型
| 类型 | 名称 |
|---|---|
| int | 整数 |
| str | 字符串 |
| bool | 布尔值 |
| list | 列表 |
| tuple | 元组 |
| dict | 字典 |
| set | 集合 |
| bytes | 字节 |
| float | 浮点型 |
有序和无序
有序：按照一定顺序排列的列表
无序：没有规律
有序包括：列表，元组，整数，字符串
无序包括：字典，元组
可变和不可以变元素
不可变：源字符串不会被改变，只有重新复制
可变：列表 字典 元素 可以被改变。不需要重新赋值
bool 布尔值
true
false
常用于判断
bool类型的操作,基本类型转换问题
bool类型没有操作,涉及到类型转换
0是false, 非0是True
python中True表示1，false表示0
空字符串表示false, 非空字符串表示True
list (列表)
list一般存放大量数据
格式
[]
示例
["元素"] 使用逗号隔开
tuple 元组
元组,只读列表,只能看啥也不能干
格式
(元素)
多个元素之间是否逗号隔开
dict 字典
{"标识":"元素"}
多个之间使用逗号隔开
set 集合
只存标识(key)
特点
集合中的数据不重复
bytes 字节
由一堆字节组成, python中的最小数据单元
数据类型转换
1.int转换str类型
a = 10
print(type(a))
b = str(a)
print(type(b))
2.str转换int类型
a = "10"
print(type(a))
b = int(a)
print(type(b))
数字转换成bool
a = 10
print(bool(a))
a = 0
print(bool(a)) #0表示false,非0表示true
a = -1
print(bool(a))
把字符串转换成bool
print(bool("哈哈"))
print(bool(" "))
print(bool(""))
结论
一.想把xxx数据转换为yy类型的数据, yy(xxx)
二.所有的空都可以表示false,能够表示False的数据: 0 , "", [] , {}, set(), tuple(), None
1和True
while 1:
print("123")
和
while True:
print("123")
while 1 与 while True 表示出来的效果是一样的,但是while 1会比 while True运行速度快一点点.
原因:true是4个字符,1是1个字符
while true在运行的时候程序也会把true转换成1
所有在代码中用到的1 会比 true多一点.
set - 集合
特点
集合是可变类型；
无序；
集合内容不能重复，只能存放不可变类型
去重复性
格式
{元素1，元素2，...}
集合类型查看
s1 = {1,2,3,4,3}
print(type(s1))
去重复性
s1 = {1,2,3,4,3}
print(s1)
列表去重复
names = ["li","ww","qq","ww"]
#类型转换，列表转换为集合set
names2 = set(names)
print(names2)
print(type(names2))
#将集合转换为列表 list
names = list(names2)
print(names)
print(type(names))
列表基本操作
查
s3 = {1,2,3,4}
for i in s3:
print(i)
add() 添加
s3.add(5)
print(s3)
update() 添加,添加多个元素
s3.update([6,7])
print(s3)
remove() 删除，删除指定元素,找不到元素报错
s3.remove(6)
print(s3)
pop() 随机删除一个元素
s3.pop()
print(s3)
discard() 删除指定元素，找不到元素不报错
print(s4)
s4.discard(6)
print(s4)
集合操作
不会改变原有值
s4 = {1,2,3,4,5}
s5 = {4,5,6,7,8}
intersection() 两个集合求交集
intersection()
print(s4.intersection(s5))
print(s5.intersection(s4))
union() 两个集合求并集
print(s4.union(s5))
print(s5.union(s4))
difference() 两个集合求差集
print(s4.difference(s5))
print(s5.difference(s4))
symmetric_difference() 两个集合求对称差集
两个集合的差集
print(s4.symmetric_difference(s5))
print(s5.symmetric_difference(s4))
格式化输出
格式
第一种
print("字符串"+变量)
#字符串和变量之间使用加号(+)进行拼接
示例
#+拼接变量,格式化输出,过程比较繁琐,不易观察
name = input("名字:")
address = input("家乡:")
wife = input("媳妇:")
notlike = input("不喜欢的明星:")
print("我叫"+name+",我来自"+address+",我老婆是"+wife+",我不喜欢"+notlike)
第二种
print("字符串%*,字符串%s,字符串%s" % (变量,变量,变量))
示例
#常用方式,格式清晰,容易理解
name = input("名字:")
address = input("家乡:")
wife = input("媳妇:")
notlike = input("不喜欢的明星:")
print("我叫%s,我来自%s,我老婆是%s,我不喜欢%s" % (name,address,wife,notlike))
坑
print("我叫%s,我已经学会了30%%的内容" % ("李先生"))**
如果这句话使用了格式化输出, % 就是站位, 如果想显示正常的%,使用两个%%.
%站位
%s 表示站位字符串,全能的站位,可以为任何类型站位.
%d 站位数字,只能站位数字
%f 站位浮点数
第三种
print(f"字符串{变量}")
#多个用逗号隔开.
示例
#简介方式,python3.x 新增加功能
name = input("名字:")
address = input("家乡:")
wife = input("媳妇:")
notlike = input("不喜欢的明星:")
print(f"我是{name},我来自{address},我老婆是{wife},我不喜欢{notlike}")
第四种
print("{}".format(变量))
#多个用逗号隔开
示例
name = "li"
age = 42
print("姓名：%s;年龄：%d!"%(name,age))
print("姓名：{}年龄：{}".format(name,age))
print("姓名：{name}年龄：{age}！".format(name = name,age = age))
print("姓名：{0}年龄：{1}".format(name,age))
print("姓名：{1}年龄：{0}".format(name,age))
布尔值
布尔只包括两个值True和False
#布尔型
print(type(True))
print(type(False))
#True 视为 整型 1
#False 视为 整型 0
print(True+9)
print(7 < 6)
print(7 > 6)
print('wq' == 'sa')
浮点型
带小数点的数字
浮点型
f1 = 3.14
print(f1)
print(type(f1))
f2 = 3e-2 #前面加2个0
print(f2)
f3 = 3e2 #后面加两个0
print(f3)
1.整数（int） integer
直接写出数字就是整数
数字没有办法执行其他操作
查看变量的数据类型 type()
a = 10
print (type(a)) #<class 'int'> class类 ，类别
整数
整数包括：
二进制 0b开头
八进制 0o开头
十进制
十六进制 0x开头
转换
#二进制 逢二进一
print(0b011)
print(type(0b011))
#八进制 缝八进一
print(0o12)
print(type(0o12))
#十进制 逢十进一
print(10)
print(type(10))
#十六进制 逢十六斤一
print(0x12)
print(type(0x12))
进制转换
bin() ：换算二进制数
oct() ：转换八进制
hex() ：转换十六进制
能够执行的操作
| 1 | 名称 | 示例 |
|---|---|---|
| + | 加号 | print(3+3) |
| - | 减号 | print(3-1) |
| * | 乘法 | print(3*3) |
| / | 除法 | print(3/3) |
| % | 取余 | print(10%3) |
| // | 整除 | print(10//3) |
| ** | 次幂 | print(2**5) |
在计算机中是无法准确的表示一个小数的
bit_length #计算一个数字的二进制长度.
#判断二进制长度
a = 5
print(a.bit_length())
2.字符串(str)
字符:单一的文字符号
字符按照固定的顺序连接成串
字符串是不可变的对象,所以任何操作对源字符串是不会有任何影响的.
可以视一切数据皆为对象，同一类型的内置方法是相同的。
对象.方法()
拼接字符串的使用的符号
字符串:被''(单引号) 或者 ""(双引号) 或者 '''(三引号) 或者""" (三引号) 括起来的内容
+ 拼接,要求两端都得是字符串
* 重复,必须乘以一个数字
索引
索引:索引使用[下标]获取数据
下标使用数字表示, 有两种数发
一: 从左往右
0 1 2 3...
二: 从右往左
-1 -2 -3...
索引示例
切片
切片: 从一个字符串中截取一部分字符串
切片格式
[start: end] #从...到...的数据给拿出来,end取不到最后一位字符, 默认从左往右切片,
start : 开始
end : 结束, 取不到
切片示例
step 步长
步长:默认是1, 每xxx个取一个, 默认是从左往右切,如果step是负数,则从右往左切
格式
[start: end :step]
start : 开始
end : 结束, 取不到
step : 步长, 控制方向, 每xx个取一个
capitalize() 把首字母变成大写
格式
capitalize()
示例
result = "hi".capitalize()
print(result)
result2 = "li shuai".capitalize()
print(result2)
title() 把字符串中每个单词的首字母变成大写
单词划分规则: 中间出现了字母的东西都叫单词;出现了非字母的东西都变成大写.
title()
示例
upper() 所有的字母都变成大写
忽略大小写的时候可以使用
格式
upper()
示例
#验证码
verifycode = 'Qwer'
verify = input("输入你的验证码:")
if verify.upper() == verifycode.upper(): #将用户输入的内容和自身内容转换为大写
print("密码输入正确")
else:
print("输入错误")
lower 所有的字母都变成小写
对欧洲部分文字是不识别的
格式
lower()
casefold() 所有的字母都变成小写
支持欧洲特殊文字
swapcase() 大写转小写,小写转大写
center() 中间,居中
格式
center(log,"wq")
log : 表示居中的长度
wq : 表示以...填充
示例
strip() 去掉左右两侧的空白(空格,\t,\n), 中间的内容不会动
示例
print(" hello world ")
print(" hello world ".strip())
print(" hello world\n".strip())
print(" hello world ".lstrip()) #去除左边空格或换行
print(" hello world ".rstrip()) #去除右边空格或换行
#strip
uname = input("用户名:").strip() #去掉输入内容的前后的空格
upassword = input("密码:").strip()
if uname == "li" and upassword == "123":
print("登录成功")
else:
print("失败")
去掉左右两边相同的字符串
replace()字符串替换
格式
replace(old,new)
把old替换成new
replace(old,new,num)
把old替换成new,num:替换num次.
示例
格式化输出 format
格式
print("qw{},er{}".format(name,age))
print("{}".format(变量))
#多个用逗号隔开
示例
name = "li"
age = 42
print("姓名：%s;年龄：%d!"%(name,age))
print("姓名：{}年龄：{}".format(name,age))
print("姓名：{name}年龄：{age}！".format(name = name,age = age))
print("姓名：{0}年龄：{1}".format(name,age))
print("姓名：{1}年龄：{0}".format(name,age))
startswith() 判断字符串是否以XXX开头
格式
startswith()
示例
#startswith() 判断字符串是否以XXX开头
name = input("名字:")
if name.startswith("张"):
print("领钱")
else:
print("不领钱")
endswith 判断以xx结尾
#endswith() 判断字符串是否以XXX开头
name = input("名字:")
if name.endswith("张"):
print("领钱")
else:
print("不领钱")
count() 计数,计算字符串中某个字符出现的次数
格式
count()
示例
find 查找
find: 查找内容, 如果存在,返回索引, 如果不存在返回 -1
示例
index 查找
index() :查找, 找到了返回索引, 找不到 报错
示例
isalpha() 条件判断,是否由字母组成
判断是否有字母组成,,包括中文, 是 为 True 非 为 False
示例
isdigit() 判断是否由数字组成
判断的是阿拉伯数字
示例
isnumeric() 判断是否有数字组成,支持中文数字
join() 拼接
格式："拼接符".join(列表)
name = ["li","wang","zhang"]
resta = "|".join(name)
print(resta)
split() 字符串切割
切出来的内容会被放在列表里面, 刀如果把头了,一定会出来空字符串
len() 求字符串长度, 内置函数
求字符串长度
示例
常用
字符串是不可变的数据类型, 不论如何操作, 对原来的字符串是不会有影响的
1.upper() 转换成大写, 忽略大小写
2.strip() 去掉左右两端的空白(空格, \t, \n), 所有用户输入的内容都要去空白
3.replace(old,new) 把old替换成new
4.split() 字符串切割,返回列表
5.startswith() 判断是否以xxx开头
6. find 查找,找不到不报错,返回 -1
7.isdigit() 判断是否由数字组成.
8.len() 求长度
多行输入
print('''
yuan
li
''')
长字符拆分
print("weqeqweqweqeqw"
"ewqeqeqweqweq"
"ewqeqeqesda")
列表 list
什么是列表
定义:能装对象的对象.
在python中 使用[]来描述列表,内部元素使用逗号隔开, 对数据没有要求，支持脚表取值.
列表中每一项用逗号隔开.
列表中还可以放列表,可以无限嵌套.
列表存在索引和切片, 和字符串是一样的.
常用
增删改查常用操作
添加:
1.append() 追加
2.insert(位置,元素) 插入
删除:
1.pop(index) 根据索引删除
2.remove(元素) 根据元素删除
修改
lst[索引] = 元素
查询
for循环
in:包含
列表的嵌套
多个列表相互嵌套
列表的其他操作
1.count() 计数
2.sort() 排序 reverse = True 倒序
3.reverse() 翻转
4.len() 求长度
示例
列表增删改查
list和str是不一样的, list可以发生改变, str不可以发生改变. 所以列表可以在原来对象的基础上进行增删改查.
增
效率排行
append() > insert()
使用排行
append() > insert()
append 添加,追加,在后面添加新增内容
格式
append()
示例
#append
lst = ["诛仙","xxx"]
lst.append("看见")
lst.append("追风筝的人")
print(lst)
insert 插入指定元素到指定位置
insert(位置,元素)
示例
#insert()
lst = ["诛仙","xxx"]
lst.insert(1,"盗墓笔记")
lst.insert(2,"三国演义")
print(lst)
extend() 迭代添加
把传递进去的参数进行迭代, 把每一项添加到列表的末尾.
格式
extend()
示例
#extend()
lst = ["诛仙"]
lst.extend("胡辣汤")
lst.extend(["疙瘩汤"])
lst.extend(["五花肉","烤猪蹄","猪头肉"])
print(lst)
删
pop()
pop() 默认从后往前删
pop(索引) 按照索引位置删除
示例
#pop()
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
lst.pop() #默认从后往前删
lst.pop(0) #根据索引删
lst.pop(1)
print(lst)
remove(元素) 移除
remove(元素) #当元素不存在的时候会把报错
示例
#remove
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
lst.remove()
print(lst)
#remove 删除不存在内容
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
lst.remove("西游记")
print(lst)
del 删除指令 用切片或者索引删除
del可以使用切片 步长,去进行删除
示例
#del
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
del lst[1]
print(lst)
#del
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
del lst[0:2]
print(lst)
#del 步长
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
del lst[::2]
print(lst)
lst.clear() 清空, 将列表清空
格式
clear()
示例
#clear
lst = ["诛仙","五花肉","烤猪蹄","猪头肉"]
lst.clear()
print()
修改
使用索引和切片进行修改
格式
1.
lst[下标] = "元素"
2.
lst[下标:下标] = "元素"
3.
lst[下标:下标:步长] = "元素"
示例
# 修改 索引
lst = ["武大","武二","宋江","赵云"]
lst[3] = "黑旋风" #通过索引进行修改
print(lst)
# 修改 索引下表越界,报错
lst = ["武大","武二","宋江","赵云"]
lst[4] = "黑旋风" #通过索引进行修改
print(lst)
# 修改 切片 迭代更新
lst = ["武大","武二","宋江","赵云"]
lst[1:3] = "黑旋风" #迭代更新
print(lst)
# 修改 切片
lst = ["武大","武二","宋江","赵云"]
lst[1:3] = ["黑旋风"]
print(lst)
#修改 切片 步长
lst = ["武大","武二","宋江","赵云","孙悟空","猪八戒 "]
lst[0:5:2] = ["黑旋风","码云","麻花藤"] #步长替换 , 日过步长不是1, 元素的个数必须和切片的个数一致
print(lst)
#吧列表中的元素变成大写
lst = ["Alex","wusir","胡辣汤"]
lst[1] = lst[1].upper()
print(lst)
查询
查询 列表是一个可迭代对象
示例
#循环出列表的每一个值
lst = ["武大","武二","宋江","赵云","孙悟空","猪八戒 "]
for item in lst:
print(item)
index 查询列表值的索引
print(lst.index("a")) #返回所以
count 统计重复字符串出现的次数
print(lst.count("a")) #统计
列表的嵌套
含义
多个列表相互嵌套.
降维操作
列表分为 一维 二维 三维....
示例
# 列表的嵌套
#查找王家卫的卫
lst = [["张艺谋","冯小刚","陈凯歌"],["李安","王家卫","王晶"],["周杰伦","邓紫棋","周杰伦"]]
print(lst[1][1][2])
#列表的嵌套
#将王晶下面的下划线替换成$
lst = [["张艺谋","冯小刚","陈凯歌"],["李安","王家卫","王晶_薛之谦"],["周杰伦","邓紫棋","周杰伦"]]
lst[1][2] = lst[1][2].replace("_","$")
print(lst)
列表的其他操作
1.count() 计数
2.sort() 排序 reverse = True
3.reverse() 翻转
4.len() 求长度
#判断列表出现的次数
lst = ["太白","太白","太黑","太白","太会"]
print(lst.count("太白"))
# 排序
lst = [1,2,4,15,15,9,16,19,7,6,0,1,1]
lst.sort() #排序, 默认是升序
print(lst)
# 排序 倒序
lst = [1,2,4,15,15,9,16,19,7,6,0,1,1]
lst.sort(reverse=True) #倒序 反向 ,这个是个参数
print(lst)
lst = ["太白","太白","太黑","太白","太会"]
lst.reverse() #吧列表翻转
print(lst)
lst = ["太白","太白","太黑","太白","太会"]
print(len(lst))
匹配列表中包含的用户名及密码是否正确
userlist = ["tom","jerry"]
passwdlist = ["123","456"]
name = input("请输入用户名：")
passwd = input("请输入密码：")
q=-1
for i in userlist:
q=q+1
if name == i:
w = passwdlist[q]
if name in userlist and passwd == w:
print("用户名是"+name+"密码是"+passwd)
else:
print("no")
作业练习
li = ["yuan", "alvin", "ritian", "barry", "stevin"]
# 1)列表中追加元素"seven",并输出添加后的列表
li.append("seven")
print(li)
# 2)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(0,"Tony")
print(li)
# 3)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[1] = "Kelly"
print(li)
# 4)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
l2=[1,"a",3,4,"heart"]
li.extend(l2)
print(li)
# 5)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
s = "qwert"
li.extend(s)
print(li)
# 6)请删除列表中的元素"yuan",并输出添加后的列表
li.pop(0)
li.remove("yuan")
del li[0]
del li
print(li)
# 7)请删除列表中的第2至4个元素，并输出删除元素后的列表
del li[1:4]
print(li)
# 8)请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
l3 = li.pop(1)
print(l3)
print(li)
# 9)请将列表所有得元素反转，并输出反转后的列表
li.reverse()
print(li)
# 10)请计算出"yuan"元素在列表li中出现的次数,并输出该次数。
num = li.count("yuan")
print(num)
# 2假设有下面这样的列表：
# # names = [‘baicai’,‘zhurou’,‘fentiao’,‘fish’]
# # 输出的结果为：‘I have baicai,zhurou,fentiao and fish’
答：
names = ['baicai','zhurou','fentiao','fish']
num = 0
ws = ""
for i in range(len(names)):
if i != (len(names) - 2):
ws += names[i]+","
else:
ws += names[i]+" and "
print("I have {ws}".format(ws = ws.rstrip(",")))
# while num <= len(names):
# num += 1
# print(names[num])
元组
tuple 元组
元组,只读列表,只能看啥也不能干
格式
(元素)
多个元素之间是否逗号隔开
空元组表示方法
变量 = tuple() #表示空元组
一个元组的表示方法
变量 = (1,) #加逗号
什么是元组
能装对象的对象, 元组不可变, 一旦确认好, 不可修改
元组也有索引和切片功能
元组是只读列表
元组也是可以迭代对象, 可以使用for循环
坑
元组中只有一个元素的时候,不是元组.
使用元组的时候末尾要默认加上逗号
元组嵌套
和列表一样,都可以相互嵌套
元组的不可变:元组指向不可变
range
是用来数数的
是前闭后开区间
格式
range(参数) #range()可以被迭代
range(n) [0,n-1]
range(m,n) [m,n-1]
range(m,n,p) [m,n]每个p个取一个
示例
#range
for i in range(10):
print(i)
#range(参数1,参数2) 切片
for i in range(10,20):
print(i)
#range(参数1,参数2,参数3) 步长
for i in range(10,20,2):
print(i)
#range for循环加上索引
lst = ("DNF","LOL","qq飞车","炫舞",["忍者","神龟"],"王者荣耀")
for i in range(len(lst)): #加索引
print(i,lst[i])
tuple元组示例
元组
#元组
t = (1,2,3,4,5)
print(t)
print(type(t))
#元组示例
tu = ("DNF","LOL","qq飞车")
print(tu)
元组修改报错,示例
#元组
tu = ("DNF","LOL","qq飞车")
#tu[1] = "123" TypeError: 'tuple' object does not support item assignment 元组不可修改
print(tu)
元组 - 切片和索引示例
#元组示例 - 切片索引
tu = ("DNF","LOL","qq飞车","炫舞",{},"王者荣耀")
print(tu[2]) #索引
print(tu[2:4]) #切片
print(tu[1:5:2]) #步长
元组 - 嵌套
#元组嵌套
tu = ("DNF","LOL","qq飞车","炫舞",["忍者","神龟"],"王者荣耀")
tu[1].append("新列表") #会报错, 改变了元组的指向
tu[4].append("新列表") #不会报错, 没有修改元组的指向
print(tu)
index，查看某个元素的索引值
index：查看某个元素的索引值的属性
tuplea = ("tom","jerry")
print(tuplea.index("jerry"))
print(tuplea.index("tom"))
count() 统计某个元素出现的次数
print(t.count(3))
字典dict
字典简介
字典（dict）是Python中唯一的一个映射类型，他是以{}括起来的键值对组成，在dict中可以是唯一的。在保存的时候，根据key来计算出一个内存地址，然后将key-value保存在这个地址中，这种算法被称为hash算法
在dict中存在的key-value中的key必须是可hash的
可hash：不可以改变的 int str tuple bool
不可hash：可以改变的 list dict set
字典{}：字典没有索引值，字典靠键值对来取值
字典是根据key来取值的。
格式
{key1:value1,key2:value2}
#key必须是不可变（可哈希）的，value没有要求，可以保存任意类型的数据
# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key
dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据
查看类型
>>> adict = {"tom":"123"}
>>> type(adict)
<class 'dict'>
字典的增删改查和其他相关操作
增
dic = {}
dic['name'] = '李'
dic['age'] = 18
print(dic)
dic.setdefault('码云')
print(dic)
dic.setdefault('码云','代码')
print(dic)
#如果dict中没有出现过这个key，就会新增一个key-value的 组合进dict
#如果dict中key值已经存在了，那么setdefault将不会起作用
删
#dict字典
dics = {"name":"张","age":15,"xingbie":"女","身高":178}
#.pop删除
ret = dics.pop("name")
print(ret)
print(dics)
#del 删除
del dics["age"]
print(dics)
#随机删除，3.6版本之后删除最后一个键值对
item = dics.popitem()
print(dics)
#清空字典中的所有内容
dics.clear()
print(dics)
修改
根据key修改value值
["key"] = "修改value值"
dicta = {"tom":"123","bob":"456"}
dicta["tom"] = "jerry"
print(dicta)
update
dict = {"name":"张","age":15,"xingbie":"女","身高":178}
dict1 = {"name":"li","年龄":15,"xingbie":"女","身高":178}
print(dict)
dict.update(dict1)
print(dict)
print(dict1)
#把dict1的内容更新到dict中，如果key重名，则修改替换，如果不存在key，则新增
字典-取值
>>> adict["tom"]
'123'
>>> print(adict["tom"])
123
匹配用户输入的账户密码是否正确
useradict = {"tom":"123","jerry":"456"}
name = input("请输入用户名：")
passwd = input("请输入密码：")
if name in useradict and passwd == useradict[name]:
print("欢迎"+name)
else:
print("密码错误")
keys-列出字典中的key值
dicta = {"tom":"123","bob":"456"}
print(dicta.keys())
values-列出字典中value的值
dicta = {"tom":"123","bob":"456"}
print(dicta.values())
items() 取出键值
adict = {"tom":"123","bob":"456"}
print(adict.items())
//字典新增一对（key:value）
dicta = {"tom":"123","bob":"456"}
dicta["qwe"] = "j678"
print(dicta)
//修改key
dicta = {"tom":"123","bob":"456"}
dicta["to"] = dicta.pop("tom")
print(dicta)
作业
#3 3 基于列表和字典实现学生信息管理
student = {'李': [21, '女'], '李帅': [21, '男']}
while True:
print('''
＋－－－－－－－－－－－－－－－－－－－－－－＋
｜ (1) 添加学生信息 ｜
｜ (2) 显示所有学生的信息 ｜
｜ (3) 删除学生信息 ｜
｜ (4) 修改学生信息 |
｜ (5) 退出程序 |
｜ ｜
＋－－－－－－－－－－－－－－－－－－－－－－＋
''')
number = input("请输入序号：")
if True != number.isdigit():
continue
else:
number = int(number)
if number == 1:
print("添加学生信息")
name = input(">>>姓名：")
age = int(input(">>>年龄："))
wk = input(">>>性别：")
if name in student:
print("人员存在，请修改")
continue
student[name] = [age,wk]
print("添加成功！")
for k,v in student.items():
print(k,v)
elif number == 2:
print("显示学生信息：")
for k,v in student.items():
print(k,v)
elif number == 3:
print("删除学生信息：")
pop = input("请输入要删除的名字：")
if pop not in student:
print("人员不存在，重新输入：")
continue
del student[pop]
print("删除成功")
for k,v in student.items():
print(k,v)
elif number == 4:
print("修改学生信息：")
update1 = input("请输入要修改人员的名字：")
update2 = input("请输入要修改的年龄：")
update3 = input("请输入要修改的性别：")
student[update1] = [update2,update3]
print("修改成功")
for k,v in student.items():
print(k,v)
elif number == 5:
print("退出程序.")
break
%用法
1、整数的输出
%o —— oct 八进制
%d —— dec 十进制
%x —— hex 十六进制
1 >>> print('%o' % 20)
2 24
3 >>> print('%d' % 20)
4 20
5 >>> print('%x' % 20)
6 14
2、浮点数输出
（1）格式化输出
%f ——保留小数点后面六位有效数字
%.3f，保留3位小数位
%e ——保留小数点后面六位有效数字，指数形式输出
%.3e，保留3位小数位，使用科学计数法
%g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
%.3g，保留3位有效数字，使用小数或科学计数法
1 >>> print('%f' % 1.11) # 默认保留6位小数
2 1.110000
3 >>> print('%.1f' % 1.11) # 取1位小数
4 1.1
5 >>> print('%e' % 1.11) # 默认6位小数，用科学计数法
6 1.110000e+00
7 >>> print('%.3e' % 1.11) # 取3位小数，用科学计数法
8 1.110e+00
9 >>> print('%g' % 1111.1111) # 默认6位有效数字
10 1111.11
11 >>> print('%.7g' % 1111.1111) # 取7位有效数字
12 1111.111
13 >>> print('%.2g' % 1111.1111) # 取2位有效数字，自动转换为科学计数法
14 1.1e+03
浙公网安备 33010602011771号