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

posted @ 2024-10-28 17:56 帅帅啊阅读(36) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· python基础

· DJango-入门

· python的基本数据类型

· Python数据类型总结

· python数据类型详解

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球运作规律

	a = 10
	print(bool(a))

	a = 0
	print(bool(a)) #0表示false,非0表示true

	a = -1
	print(bool(a))

	names = ["li","ww","qq","ww"]
	#类型转换，列表转换为集合set
	names2 = set(names)
	print(names2)
	print(type(names2))
	#将集合转换为列表 list
	names = list(names2)
	print(names)
	print(type(names))

	print(s4.symmetric_difference(s5))
	print(s5.symmetric_difference(s4))

	print("字符串"+变量)
	#字符串和变量之间使用加号(+)进行拼接

	#+拼接变量,格式化输出,过程比较繁琐,不易观察
	name = input("名字:")
	address = input("家乡:")
	wife = input("媳妇:")
	notlike = input("不喜欢的明星:")

	print("我叫"+name+",我来自"+address+",我老婆是"+wife+",我不喜欢"+notlike)

	#常用方式,格式清晰,容易理解
	name = input("名字:")
	address = input("家乡:")
	wife = input("媳妇:")
	notlike = input("不喜欢的明星:")

	print("我叫%s,我来自%s,我老婆是%s,我不喜欢%s" % (name,address,wife,notlike))

	print("我叫%s,我已经学会了30%%的内容" % ("李先生"))**

	如果这句话使用了格式化输出, % 就是站位, 如果想显示正常的%,使用两个%%.

	%s 表示站位字符串,全能的站位,可以为任何类型站位.

	%d 站位数字,只能站位数字
	%f 站位浮点数

	#简介方式,python3.x 新增加功能
	name = input("名字:")
	address = input("家乡:")
	wife = input("媳妇:")
	notlike = input("不喜欢的明星:")

	print(f"我是{name},我来自{address},我老婆是{wife},我不喜欢{notlike}")

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

	#布尔型
	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)

	直接写出数字就是整数
	数字没有办法执行其他操作

	整数包括：
	二进制 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() ：转换十六进制

	可以视一切数据皆为对象，同一类型的内置方法是相同的。
	对象.方法()

	字符串:被''(单引号) 或者 ""(双引号) 或者 '''(三引号) 或者""" (三引号) 括起来的内容

	+ 拼接,要求两端都得是字符串
	* 重复,必须乘以一个数字

	下标使用数字表示, 有两种数发
	一: 从左往右
	0 1 2 3...
	二: 从右往左
	-1 -2 -3...

	[start: end] #从...到...的数据给拿出来,end取不到最后一位字符, 默认从左往右切片,

	start : 开始
	end : 结束, 取不到

Python的基础数据类型