01 Python 基础数据类型
基础数据类型,有7种类型,存在即合理。
1.int 整数
主要是做运算的 。比如加减乘除,幂,取余 + - * / ** %...
2.bool 布尔值
判断真假以及作为条件变量
3.str 字符串
存储少量的数据。比如'password'... 操作简单,便于传输。
4.list 列表
[1,2,'alex',{name:'zhang'}] 存放大量的数据,大量的数据放到列表中便于操作
5.tuple 元组
也叫只读列表。(1,2,'alex',{name:'zhang'}) 一些重要的数据或者不想被更改的数据,使用元组
6.dict 字典
{‘name_list’:'[zhang,lisi]'}, 存储关系型的数据,查询速度非常快,二分查找。
7.set 集合
交集,并集,差集...
数据类型的分类:
可变数据类型(不可哈希):list,dict,set
不可变数据类型(可哈希):int,bool,str,tuple
容器类型:
容器类(承载各种数据类型):list,tuple,dic
一、int整形
主要用于计算,计数,+ - * / % ** ....
32位系统,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647
64位系统,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807
float:浮点数,复数
bit_length():转化成二进制的最小位数
二、bool 布尔值
数据类型转换:
int <---> str: int(str)、str(int)
int <---> bool:非零即True,零为False bool(1).
bool <---> str:
①str ---> bool:非空即True,空字符串对应 False。 print(bool('Alex')) 结果为 True
②bool ---> str:只能打印True和False,没有什么实际意义
例子:
n = str(1) #
n = bool(1) #True
n = bool('') # False. 空字符串是False,其他都是True
三、str 字符串
在python中,凡是用引号引起来的数据都是字符串。单引号,双引号,三引号 引起来没有任何区别。
s1 = '小明'
s2 = "小明"
s3 = """小明"""
print(s1,s2,s3) #都是小明。 小明,小明,小明
1. 单双引号配合使用
msg = "My name is Ming , I'm 73 years old!" # 里面是单引号,所以外面用双引号比较好
2. 三引号用于换行的字符串
msg = '''
今天我想写首小诗,
歌颂我的同桌,
你看他那乌黑的短发,
'''
print(msg)
结果显示:
今天我想写首小诗,
歌颂我的同桌,
你看他那乌黑的短发,
3.字符串相加和相乘
相加 :拼接。
s1 = 'a'
s2 = 'b'
print(s1 + s2) #ab
相乘
s3 = 'a'
print(s3*8) # aaaaaaaa
4.字符串重要操作 *****
4.1 字符串的取值(索引、切片、步长)
①按照索引取值
s = 'abcdefgh'
s1 = s[0] # 取第一个值
s2 = s[-1] # 取最后一个值
②按切片取值,顾头不顾尾。切片,也就是取连续的多个值
s = 'abcdefgh'
s1 = s[0:6] # 按切片取值,顾头不顾尾
s2 = s[:6] # 从0开始取值,0可以省略
s3 = s[6:] # 从某一索引取到最后的值,冒号后面不跟值
s4 = s[-5:] # 取最后5个字符串
s5 = s[:] # 取所有 print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
结果显示:
abcdef
abcdef
gh
defgh
abcdefgh
对字符串操作,都会产生新的变量,除了赋值以外。
③按照切片+步长取值 [起始索引:截止索引:步长]
步长:
(1)默认步长为1
(2)隔一个取1个,步长为2
(3)反向取值,也就是从后向前取,步长为-1
s = 'abcdefgh'
s1 = s[:5:2] # 从第一个字符到第五个字符,每隔一个字符取一个值。
s2 = s[1::2] # 从第二个字符到最后一个字符,每隔一个字符取一个值,最后一个字符的位置不能写值。
s3 = s[::2] # 隔1个,取一个 print(s1)
print(s2)
print(s3)
结果输出:
ace
bdfh
aceg
倒叙取值,加一个反向步长*****
s = 'abcdefgh'
s1 = s[::-1] # 反向全取
s2 = s[-1:-6:-2] # 划士期
s3 = s[:-5:-1] # 反向取5个
s4 = s[-1:-5:-1] print(s1)
print(s2)
print(s3)
print(s4)
结果输出:
hgfedcba
hfd
hgfe
hgfe
4.2 字符串的常用方法
① capitalize():首字母大写,其他字母小写 ***
② upper()、lower():字母全部大写/小写 *****
name = 'Summer'
print(name.capitalize()) #Summer
print(name.upper()) # SUMMER
print(name.lower()) # summer
可用于验证码输入,如果不使用字符串内置方法,这需要写16个if,代码质量非常low
code = 'Summer'.upper()
your_code = input('请输入验证码:').upper()
if your_code == code:
print('验证码验证成功')
③ swapcase():大小写反转 **
④ title():非字母隔开的首字母大写**
s1 = 'sumer aaa#bbbb*cc6ddd'
print(s1.title()) # Sumer Aaa#Bbbb*Cc6Ddd
⑤ startswith()、endswith():判断是否以...开头或结尾,返回bool值
endswith()的用法与startswith()相同 *****
s = 'summer wusir*nanhai21shui'
s1 = s.startswith('a')
s2 = s.endswith('i') # 切片,取索引访问1~4,再判断是否以i开头
s3 = s.startswith('i', 1, 4) # 切片,取索引范围5~结束,结束位置参数没给,默认一直取到尾
s4 = s.startswith('w', 5) print(s1,s2,s3,s4) # False True False False
⑥ 通过元素找索引( find( ),index( ) ):找到第一个元素就返回,返回int *****
name = "summer"
print(name.find('u')) # 返回u在字符串中的位置,返回1
print(name.find('mm')) # 返回lD在字符串中的位置,返回2
print(name.find('w')) # 返回w在字符串中的位置,字符串中没有w,返回-1
print(name.find('e', 1, -1)) # 从位置1到最后查找2的位置,返回4
index()的用法和find()相同,只是index()没有找到会报错,find()没有找到返回-1
⑦ center():字符串居中,前后填充自定义字符 **
总宽度为30,并且字符串居中,不足30,默认用空格填充
s = 'laoshi'
s1 = s.center(30)
print(s1) # laoshi
#使用*填充
s = 'laoshi'
s2 = s.center(30,'*')
print(s2) #************laoshi************
如果宽度小于字符串,按照原来的字符串显示
s = 'laoshi'
s2 = s.center(3,'*')
print(s2) #laoshi
⑧ strip():去除字符串开头和结尾的空格.换行符.制表符,不能删除中间的
在input程序中,会经常使用,如果用户输入的,不小心包含了空格,会导致验证失败,下面加入strip(),即使输入有空格,也可以验证通过
name = input('请输入用户名:').strip() if name == 'summer':
print('ok')
类似功能的2个的方法
lstrip() 去除左边的空格、换行符、tab键
rstrip() 去除右边的空格、换行符、tab键
strip()还可以去除指定的字符串
s = 'laoshijintianzai'
s1 = s.strip('l') #去除字符串l
print(s1) #aoshijintianzai strip()会同时向左右2边,挨个挨个字符寻找字符串l 如果发现了l就去除,如果没有发现终止寻找
⑨ split():将字符串分割成列表,默认按照空格分割,实现字符串--->列表的转化 *****
默认按照空格分隔
s1 = 'spring summer autumn winter'
l1 = s1.split() print(l1) # ['spring', 'summer', 'autumn', 'winter']
指定分割符
s1 = 'spring,summer,autumn,winter'
l1 = s1.split(',') print(l1) # ['spring', 'summer', 'autumn', 'winter']
指定字符串a
s1 = 'springasummeraautumnawinter'
l1 = s1.split('a') print(l1) # ['spring', 'summer', '', 'utumn', 'winter']
注意:如果关键字左边没有字符串,那么结果为[],也就是空字符串。结果不包含关键字,被剔除了
⑩ join():自定制连接符,将可迭代对象中的元素连接起来,是列表转化为字符串的方式
s='summer'
s2='*'.join(s) # 和其他方法不一样,请注意
print(s2) #s*u*m*m*e*r
⑪ repalce():替换,可设置替换次数 *****
s = '我的老家在东北,东北有很多人'
默认是全文替换
s = '我的英文名叫夏天,因为夏天总是那么阳光明媚'
s1 = s.replace('夏天', '春天')
print(s1)
替换一次
s = '我的英文名叫夏天,因为夏天总是那么阳光明媚'
s1 = s.replace('夏天', '春天',1)
print(s1) # 我的英文名叫春天,因为夏天总是那么阳光明媚
替换,是从左至右的.如果想要替换中间某部分,需要用到正则表达式
⑫ 格式化输出 format()
第一种用法:{}表示一个占位符
s = '我叫{},今年{},爱好{}'.format('summer', 18, '滑雪')
print(s) # 我叫summer,今年18,爱好滑雪
第二种用法:
比如某个变量出现了几十次,那么可以直接用个{索引}表示,修改format后面的参数,就可以生效了
s = '我叫{0},今年{1},爱好{2},即便是81岁我依然叫爱{2}'.format('summer', 18, '滑雪')
print(s) # 我叫summer,今年18,爱好滑雪,即便是81岁我依然叫爱滑雪
{2} 表示索引值,如果使用这种方式,索引值必须指定,否则报错
第三种用法: 键值对
s = '我叫{name},今年{age},爱好{hobby}'.format(age=18, name='summer', hobby='滑雪')
print(s) # 我叫summer,今年18,爱好滑雪
s1 = '我叫{},今年{},性别{}'.format('summer', '', '女')
s2 = '我叫{0},今年{1},性别{2},我依然叫{0}'.format('summeri', '', '女')
s3 = '我叫{name},今年{age},性别{sex}'.format(name='summer', sex='女', age='')
⑬ is 系列,返回bool值
name='summer123'
print(name.isalnum()) #判断是否是数字或字母组成
print(name.isdigit()) #判断是否是数字组成
print(name.isalpha()) #判断是否是字母组成
isdigit()比较常用,比如判断用户输入的,是否是数字。
或者将字符串转换为数字类型时,要判断字符串是否由纯数字组成,否则报错。
name = '123a'
if name.isdigit():
name = int(name)
else:
print('您输入的含有非数字元素')
执行输出:您输入的含有非数字元素
⑭ 公共方法:count()
name = 'summer'
print(name.count('m')) # 统计a出现的次数 2
print(len(name)) # 查看数据的长度 6
四、列表
列表是python中的基础数据类型之一,它是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型。比如:
li = [‘a’, 123, Ture, (1,2,3,’b’), [1,2,3,’小明’,], {‘name’:’summer’}]
列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据。列表是有序的
索引,切片,步长
列表的索引与字符串相同,都是索引、切片、步长
li = ['xiao',123,True,(1,2,3,'a'),[1,2,3,'小明',],{'name':'xiao'}]
print(li[0])
print(li[2])
print(li[1:4])
print(li[:5:2])
print(li[-1:-3:-1]) # 倒着取,后2个
输出结果:
xiao
True
[123, True, (1, 2, 3, 'a')]
['xiao', True, [1, 2, 3, '小明']]
[{'name': 'xiao'}, [1, 2, 3, '小明']]
列表的增、删、改、查
增
① append():在列表的最后追加,没有返回值
② insert():根据位置增加
③ extend():在列表的最后追加,按照最小单元形式
append() 追加,在最后一个位置添加元素
li = [1,'a','b',2,3,'a','lao']
li.append('xiao')
print(li) # [1, 'a', 'b', 2, 3, 'a', 'lao', 'xiao']
l1 =['spring' ,'summer' ,'autumn' ,'winter' ,]
l1.append([1 ,2 ,3]) # print(l1.append([1,2,3])) #没有返回值,因为l1.append([1,2,3])是一个过程 print(l1) # ['spring', 'summer', 'autumn', 'winter', [1, 2, 3]]
insert() 按照索引添加
将元素插入到指定的索引值位置, 后面的元素索引值会自动加1
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.insert(2,'zhang') # 先索引,后内容
print(li) # ['spring', 'summer', 'zhang', 'autumn', 'winter']
extend() 迭代着添加
在最后的位置,迭代每一个元素,依次添加。
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.extend('ABC')
print(li) # ['spring', 'summer', 'autumn', 'winter', 'A', 'B', 'C']
使用输入框方式添加元素
name_list =['spring' ,'summer' ,'autumn' ,'winter' ,] while True:
name = input('请输入新员工姓名:Q/q ').strip()
if name.upper() == 'Q':
break
else:
name_list.append(name) print('已成功添加新员工%s' % name) print(name_list)
删
1) pop():按照索引的位置删除,有返回值,返回值是被删除的元素
2) remove():按照元素删除
3) clear():清空
4) del[ ]:按照索引的位置删除 ( 中括号,和其他不一样)
按照切片和步长删除
全部清空
pop() 按照索引删除
#默认删除最后一个
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.pop()
print(li) #['spring', 'summer', 'autumn']
删除索引值为1的元素
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.pop(1)
print(li) #['spring', 'autumn', 'winter']
pop() 是增删改查所有方法里面,唯一有返回值的方法。返回删除的元素。pop()只能删除一个元素
remove() 按照元素删除,只能删除一个
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.remove('summer')
print(li) #['spring', 'autumn', 'winter']
clear() 清空列表的所有元素
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li.clear()
print(li) #[]
del 删除列表
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
del li
# 按索引删除
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
del li[0]
print(li) # ['summer', 'autumn', 'winter']
# 按切片删除
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
del li[:3]
print(li) # ['winter']
# 按照切片+步长删除
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
del li[::2]
print(li) # ['summer', 'winter']
# 跳着删除
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
del li[:3:2]
print(li) # ['summer', 'winter']
改
1) 按索引更改
2) 按切片更改:可在切片位置放任意多个参数
3) 按切片加步长更改:只能按照切片宽度放置参数个数
使用赋值修改
# 按索引更改,一次只能更改一处
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li[0] = 'abc'
print(li) # ['abc', 'summer', 'autumn', 'winter']
# 按切片更改
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li[:4]=[11,22,33,44,55,66]
print(li) # [11, 22, 33, 44, 55, 66]
#按切片加步长更改
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
li[:4:2]=[11,22]
print(li) # [11, 'summer', 22, 'winter']
切片修改的执行过程是,先删除切片部分,再迭代添加的对象,依次添加元素。
查
1) 按照索引查;
2) 用for循环
for 循环
li =['spring' ,'summer' ,'autumn' ,'winter' ,]
for i in li:
print(i)
其他操作方法:
①列表可以相加
l1 =['spring' ,'summer' ,'autumn' ,'winter' ,]
l2=[1,2,3]
l3=l1+l2 print(l3) # ['spring', 'summer', 'autumn', 'winter', 1, 2, 3]
② 在循环一个列表时,删除列表中的某一元素时,该元素后面的元素都会向前进一位,后面元素的索引会改变。所以在循环一个列表时,最好不要对列表进行改变大小的操作(增和删)
例题:将列表中索引为奇数的元素删除
方法1:将列表中索引为偶数的元素加入到一个新的列表中
方法2:从列表后面开始删除
方法3:切片
l1=[11,22,33,44,55,66,77,88]
方法一
使用新列表覆盖
l2 = [] for i in range(len(l1)):
if i % 2 == 0:
l2.append(l1[i]) li = l2
print(li)
方法二
for i in range(len(l1),-1,-1):
if i % 2 == 1:
l1.pop(i) print(l1)
倒序删除
for i in range(len(l1)-1,-1,-1):
if i % 2 == 1:
del l1[i] print(l1)
方法三
l3 = l1[::2]
print(l3)
del l1[1::2]
print(li)
sort()
# 从小到大,正向排序
li = [1,2,7,8,5,6,3,4]
li.sort() print(li) # [1, 2, 3, 4, 5, 6, 7, 8]
# 从大到小,反向排序
li = [1,2,7,8,5,6,3,4]
li.sort(reverse=True) print(li) # [8, 7, 6, 5, 4, 3, 2, 1]
reverse() 翻转
翻转,就是将右边的元素和左边的元素进行对换。
li = [1,2,7,8,5,6,3,4]
li.reverse()
print(li) # [4, 3, 6, 5, 8, 7, 2, 1]
任何排序都不如sort和reverse 快, 如果没有明确要求指定排序方法,优先使用sort和reverse
len() 查看数据长度
li = [1,2,7,8,5,6,3,4]
print(len(li)) #
count() 统计元素出现次数
li = [1,2,7,8,5,6,3,4]
print(li.count(7)) #
index() 通过元素找索引
li = [1,'a','b','a',2,3,'a']
print(li.index('a')) # 1
列表的嵌套(注意:只要涉及到字符串变更的,都需要重新赋值)
li = [1,2,'summer',['','spring',99],22]
1.将summer 变成首字母大写的Summer
li[2] = li[2].capitalize() 2.将spring变成全部大写的SPRING放到原处
li[3][1] = li[3][1].upper() 3.将99加1变成100,返回原处
#数值加1
li[3][2] += 1
print(li)
思考题:将列表中的每一个元素打印出来,如果遇到列表,需要打印列表中的每一个元素 *****
答案:
li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
for i in li:
if type(i) == list:
for j in i:
print(j)
else:
print(i)
输出结果:
1
2
spring
summer
autumn
winter
a
b
如果列表包含字典以及元组呢? li = [1,2,['alex','wusir'],'a','b',{'name':'xiao','age':21},('d','n','f')]
第1种写法: *****
li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
for i in li:
#判断元素类型是否是整形和布尔值,除了这2种类型,其他类型都是可迭代对象
if type(i) not in [int,bool]:
# 判断元素的长度等于1,排除有多个元素的数据,比如列表,字典...
if len(i) == 1:
print(i)
else:
#循环可迭代对象
for j in i:
print(j)
else:
print(i)
第2种写法: *****
#加载模块
from collections import Iterable
li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
for i in li:
#判断是否是可迭代对象
if isinstance(i,Iterable):
for j in i:
print(j)
else:
print(i)
执行程序,效果同上
五、元组tuple
元组被称为只读列表,即数据可以被查询,但不能被修改.
1、查询方式:与列表相同
2、可使用公用方法index、count、len
3、应用场景:一些非常重要的数据不允许任何人修改就放在元组种。
4、元组的儿子不能修改,但是孙子可以修改
如果一个元组只由一个数据组成,且没有逗号,那么该“元组”的数据类型就是该数据的数据类型
tu1 = (1)
tu2 = ("hello")
tu3 = ([1,2,3])
tu4 = ({1:1,2:2}) print(type(tu1)) #<class 'int'>
print(type(tu2)) #<class 'str'>
print(type(tu3)) #<class 'list'>
print(type(tu4)) #<class 'dict'> tu5 = (1,) #有逗号,还是元组类型
print(type(tu5)) #<class 'tuple'>
字符串的切片操作同样适用于元组。
tu = ('spring' ,'summer' ,'autumn' ,'winter')
print(tu[:2]) # ('spring', 'summer')
print(tu[2]) # 指定索引取值 autumn
遍历元祖
tu = ('spring' ,'summer' ,'autumn' ,'winter')
for i in tu:
print(i)
有一种情况,元组的值会改变,俗称:儿子不能改,孙子可能改
tul1 = ('spring' ,'summer' ,['hot', 99, 'cool'],'autumn' ,'winter') # tul1[0] = 'namsahn' # 元组里儿子不允许修改,会报错
tul1[2][0] = 123 # 元组里的孙子辈可以增删改
tul1[2].append('a') print(tul1) # ('spring', 'summer', [123, 99, 'cool', 'a'], 'autumn', 'winter')
一般元组,是放只读的数据。所以不会随意更改。元组是只读列表,只允许查询,不允许增、删、改
元组转换为列表
tu = (1,2,3)
li = list(tu)
print(li) # [1, 2, 3]
列表转换为元组
tu = [1,2,3]
li = tuple(tu)
print(li) # (1, 2, 3)
字符串直接转换为元组是没有方法的。除非把字符串转换为列表,再转换为元组
六、字典
字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。
字典使用二分查找.二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。比如字典有1~100的数据,现在想要查找75。先劈一半,找到中间值50。判断50和75的大小,发现小于,再劈一半。找到中间值75,直接返回结果。
数据类型的分类:
可变数据类型(不可哈希):list,dict,set
不可变数据类型(可哈希):int,bool,str,tuple
容器类型:
容器类(承载各种数据类型):list,tuple,dic
字典的键:必须是不可变数据类型;字典的值:任意数据类型;字典的键是唯一的。
例如:
dic = {'name_list': ['王双', 'alex', '孙飞', 'taibai'],
1: {'name': 'taibai', 'age': 18, 'sex': '男'},
(1, 2): [100, {'ip': '192.168.1.1', 'port': 3306}]
}
字典的顺序:严格意义上来讲,是无序的。 3.5之前,字典是无序的。3.6开始,字典创建的时候,按照一定的顺序插入的值,看起来是有序的
1、创建字典的三种方式
① dic = {}
② dic = dict( { } )
③ dic.fromkeys(可迭代对象,value),value会被赋值可迭代对象里的每一个值
dic = dict.fromkeys('abc','alex')
print(dic) # {'c': 'alex', 'b': 'alex', 'a': 'alex'} 使用列表创建一个新字典
dic = dict.fromkeys([1,2,3],[])
print(dic) # {1: [], 2: [], 3: []}
字典的第一个坑
给列表1添加一个元素
dic = dict.fromkeys([1,2,3],[])
dic[1].append('北京')
print(dic) # {1: ['北京'], 2: ['北京'], 3: ['北京']}
坑就来了,这3个列表,在内存中对应的是同一个列表
字典的第二个坑:在循环一个字典时,对字典的键值对进行删除会报错。
将字典中含有K元素的键,对应的键值对删除
dic = {'k1':'value1','k2':'value2','name':'summer'}
正常思路的写法:
dic = {'k1':'value1','k2':'value2','name':'summer'} for i in dic.keys():
if 'k' in i:
dic.pop(i) print(dic) 执行报错:RuntimeError: dictionary changed size during iteration
意思就是,在循环字典过程中,不允许改变字典
换一种思路,在字典中追加:
dic = {'k1':'value1','k2':'value2','name':'summer'}
count = 0 for i in dic:
dic[i+str(count)] = dic[i]
count +=1 print(dic) # 执行报错,效果同上。
这题应该这么做,先将含有k的键值对,添加到列表,然后循环列表,删除字典的Key:*****
dic = {'k1':'value1','k2':'value2','name':'summer'} li = []
for i in dic:
if 'k' in i:
li.append(i) for i in li:
dic.pop(i) print(dic) #{'name': 'wusir'}
总结:在循环列表或者字典的时候,千万不要做添加或者删除操作。
2、字典的增删改查
增
第一种:用key进行定位,用=进行重新赋值:字典中不存在这个key时,增加这个key到字典中,字典中本来就存在这个key时,就修改这个key对应的value
dic = {'name': 'summer', 'age': 21}
dic['hobby'] = 'skiing'
print(dic) # {'age': 21, 'hobby': 'skiing', 'name': 'summer'}
第二种: setdefault(key,value):无则添加,有则不变
value可以省略,默认添加None。
dic = {'name': 'summer', 'age': 21}
dic.setdefault('hobby')
print(dic) # {{'name': 'summer', 'age': 21, 'hobby': None}
添加键值对
dic = {'name': 'summer', 'age': 21}
dic.setdefault('hobby','skiing')
print(dic) # {'name': 'summer', 'age': 21, 'hobby': 'skiing'}
添加一个已经存在的key
dic = {'name': 'summer', 'age': 21}
dic.setdefault('name','spring')
print(dic) # {'name': 'summer', 'age': 21}
上述2个添加的方法,只能一个个添加。
删
① pop() 删除指定的key。pop()是所有方法中,唯一有返回值的。
删除指定的key
dic = {'name': 'summer', 'age': 21}
print(dic.pop('age')) #
print(dic) # {'name': 'summer'}
删除一个不存在的key
dic = {'name': 'summer', 'age': 21}
print(dic.pop('hobby'))
print(dic) # 报错KeyError: 'hobby'
删除一个不存在的key,并指定默认返回值None
dic = {'name': 'summer', 'age': 21}
print(dic.pop('hobby',None)) # None
print(dic) # {'name': 'summer', 'age': 21}
推荐使用上述方法,删除一个key。因为如果key不存在时,不会报错,返回None。程序员最怕报错了!
② clear() 清空
dic = {'name': 'summer', 'age': 21}
dic.clear()
print(dic) # {}
③ del 删除字典
按照键删除,del dic['key']。如果不存在,会报错
dic = {'name': 'summer', 'age': 21}
del dic['hobby']
从内存上清空 del dic
dic = {'name': 'summer', 'age': 21}
del dic
print(dic) # NameError: name 'dic' is not defined
④ popitem() 随机删除,有返回值.
在python3.6之前,随机删除一个键值对;从python3.6开始,删除最后一个键值对
dic = {'name': 'summer', 'age': 21}
print(dic.popitem()) # ('age', 21)
print(dic) # {'name': 'summer'}
改
① 通过键和=进行修改,与增的用法相同
dic = {'name': 'summer', 'age': 21}
dic['name'] = 'zhangsan'
print(dic) # {'name': 'zhangsan', 'age': 21}
② update():
dic1.update(dic2):将dic2中的所有键值对覆盖并添加到dic1中(键相同的覆盖,键不同的添加)
# 针对2个字典的修改
dic1 = {'name': 'summer', 'age': 21}
dic2 = {'name': 'spring', 'hobby': 'skiing'} # 将dic键值对,覆盖并添加到dic2
dic1.update(dic2)
print(dic1) # {'name': 'spring', 'age': 21, 'hobby': 'skiing'}
print(dic2) # {'name': 'spring', 'hobby': 'skiing'}
可以发现dic2没有改变,dic1改变了. update()修改原则,有相同的就覆盖,没有的就添加
查
① 通过key进行查找(与列表通过索引进行查询相似)
dic = {'name':'summer','age':21}
print(dic['name'])
通过value查询 dic = {'name':'summer','age':21}
print(dic['summer']) # 执行报错: KeyError: 'xiao'
字典只能通过key查询,不能通过value查询,否则报错
② get(k,None):字典种有这个key的返回这个key对应的value,没有的话返回第二参数,第二参数可以不写,默认返回None
- 有这个key,返回这个key对应的value值
dic = {'name': 'summer', 'age': 21}
print(dic.get('name')) # summer
- 查询一个不存在的key, 默认返回None
dic = {'name': 'summer', 'age': 21}
print(dic.get('hobby')) # None
- 查询一个不存在的key, 设置返回值
dic = {'name': 'summer', 'age': 21}
print(dic.get('hobby','亲,木有这个字哦!')) # 亲,木有这个字哦!
- 如果需要查询多个key,请使用for循环
dic = {'name': 'summer', 'age': 21}
for i in dic:
print(i)
执行输出:
age
Name
3. 字典的特殊使用方法.keys().values().items()
dic.keys( )
① 用于提取字典种的key值,返回值的类型是 dict_keys
dic = {'name':'helen','age':18,'sex':'women'}
print(dic.keys(),type(dic.keys())) # dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
② 提取字典中的key值,并将其转化为列表 list(dic.keys())
dic = {'name':'helen','age':18,'sex':'women'}
li = list(dic.keys()) print(li) # ['name', 'age', 'sex']
③ 与for结合使用:输出的就是字典里的key(按原来的数据类型)
dic = {'name': 'summer', 'age': 21} for i in dic.keys():
print(i)
执行输出:
age
Name
keys()方法输出的数据是一个特殊类型,它相当于把所有的key放到了一个容器里面。它类似于列表的容器,当它并不是列表。
dic.values()
① 用于提取字典中的value值,返回值的类型是 dict_values
dic = {'name':'helen','age':18,'sex':'women'}
print(dic.values(), type(dic.values())) # dict_values(['helen', 18, 'women']) <class 'dict_values'>
② 提取字典中的value值,并将其转化为列表 list(dic.values())
dic = {'name':'helen','age':18,'sex':'women'}
li = list(dic.values())
print(li) # ['helen', 18, 'women']
③ 与for结合使用:输出的就是字典里的value(按原来的数据类型)
dic = {'name':'helen','age':18,'sex':'women'} for i in dic.values():
print(i)
输出结果是:
helen
18
Women
dic.items()
① 用于提取字典种的key和value值,并将key和它对应的value用元组包围起来,返回值的类型是 dict_items
dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
print(dic.items(), type(dic.items())) # dict_items([('name', 'helen'), ('age', 18), ('sex', 'women')]) <class 'dict_items'>
② 提取字典中的key和value值,并将其转化为列表 list(dic.items()),其中key和它对应的value用元组包围起来[(key,value),(key,value),.....]
dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
li = list(dic.items())
print(li) # [('name', 'helen'), ('age', 18), ('sex', 'women')]
③ 与for结合使用:输出的就是字典里的key和value(按原来的数据类型)
I. for k,v in dic.items() :输出原始格式的key和value
dic = {'name': 'helen', 'age': 18, 'sex': 'women'} for k,v in dic.items():
print(k,v) 输出结果
name helen
age 18
sex women
II. for i in dic.items() :输出被元组包围的key和value
dic = {'name': 'helen', 'age': 18, 'sex': 'women'} for i in dic.items():
print(i) 输出结果
('name', 'helen')
('age', 18)
('sex', 'women')
III. for i in dic() :输出原始格式的key
dic = {'name': 'helen', 'age': 18, 'sex': 'women'} for i in dic:
print(i) 输出结果
name
age
sex
4、字典的嵌套
dic = {'name_list': ['王双', 'alex', '孙飞', 'taibai'],
1: {'name': 'taibai', 'age': 18, 'sex': '男'},
(1,2): [100, {'ip': '192.168.1.1', 'port': 3306}]
} 1,给 name_list对应的列表追加一个值: 司徒大人.
dic['name_list'].append('司徒大人')
print(dic) 2,将name_lsit对应的alex 变成全部大写. # 注意重新赋值
dic['name_list'][1]=dic['name_list'][1].upper()
print(dic) 3, 将1对应的字典添加一个键值对: weight : 75
dic[]['weight'] = 75
print(dic) 4,将1 对应的字典的name键对应的名字taibai 换成alex
dic[1]['name'] = 'alex'
print(dic) 5,将 {'ip': '192.168.1.1', 'port': 3306} 次字典的port键值对删除.
dic[(1,2)][1].pop('port')
print(dic)
注意:取键的时候,键是什么就写什么,并不是所有的键都是字符串,根据类型来看,是否需要加引号需要
七、集合
set1 = {1,2,’summer‘,(3,4)}
集合里面的元素必须是不可变的,只能是数字、字符串、bool值、元组,但是集合本身是可变的数据类型,集合里面的元素不能重复,集合是无序的。
1. 集合的创建
set1 = { }
set1 = set( { } )
2.集合常用操作 增 删 查
增
add()
set1 = {'summer','spring'}
set1.add('winter')
print(set1) # {'spring', 'summer', 'winter'}
update() 迭代的增加
set1 = {'summer','spring'}
set1.update('abc')
print(set1) # {'c', 'b', 'summer', 'a', 'spring'}
删
pop() 随机删除,pop() 是有返回值的
set1 = {'summer','spring'}
print(set1.pop()) # summer
print(set1) # {{'spring'}
remove() 删除一个元素
set1 = {'summer','spring'}
set1.remove('summer')
print(set1) # {{'spring'}
clear() 清空集合
set1 = {'summer','spring'}
set1.clear()
print(set1) # set()
del 删除集合
set1 = {'summer','spring'}
del set1
print(set1) # NameError: name 'set1' is not defined
改
集合无改的方法
查
查只能for循环
set1 = {'summer','spring'}
for i in set1:
print(i)
3. 集合作用
1)列表去重:直接转换为集合,就可以
li = [11,11,22,22,33,33,33,44]
li = list(set(li)) print(li) # [33, 11, 44, 22]
2)关系测试
交集( &或者intersection)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} print(set1 & set2)
print(set1.intersection(set2)) 执行输出:
{4, 5}
{4, 5}
并集( |或union)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} print(set1 | set2)
print(set1.union(set2)) 执行输出:
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
反交集( ^或 symmetric_difference)。和交集,取反的结果,也就是说,删除相同的,保留不同的。
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} print(set1 ^ set2)
print(set1.symmetric_difference(set2)) 执行输出:
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}
差集( - 或difference)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} print(set1 - set2)
print(set1.difference(set2)) 执行输出:
{1, 2, 3}
{1, 2, 3}
子集(issubset)
判断一个集合是否被另外一个集合包含
set1 = {1,2,3}
set2 = {1,2,3,4,5,6} print(set1.issubset(set2)) # True
超集(issuperset)
判断一个集合是否包含另外一个集合
set1 = {1,2,3}
set2 = {1,2,3,4,5,6} print(set2.issuperset(set1)) # True
集合关系测试,记符合就可以了,英文字母太长了,不好记。
frozenset()将集合转换为可哈希的类型,可以作为字典的key
set1 = {'summer','spring'}
set2 = frozenset(set1) print(set2) # frozenset({'summer', 'spring'})
01 Python 基础数据类型的更多相关文章
- Python基础数据类型题
Python基础数据类型 题考试时间:三个小时 满分100分(80分以上包含80分及格)1,简述变量命名规范(3分) 1.必须是字母,数字,下划线的任意组合. 2.不能是数字开头 3.不能是pytho ...
- Python基础数据类型-列表(list)和元组(tuple)和集合(set)
Python基础数据类型-列表(list)和元组(tuple)和集合(set) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 本篇博客使用的是Python3.6版本,以及以后分享的 ...
- Python基础数据类型-字符串(string)
Python基础数据类型-字符串(string) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 本篇博客使用的是Python3.6版本,以及以后分享的每一篇都是Python3.x版 ...
- python基础数据类型考试题
Python基础数据类型考试题 考试时间:两个半小时 满分100分(80分以上包含80分及格) 一,基础题. 1,简述变量命名规范(3分) 2,字节和位的关系 ...
- 1--Python 入门--Python基础数据类型
一.Python基础语法 初次使用Python,首先要明确三点: Python的标识符(例如变量名.函数名等),可用字母.数字和下划线构成,不能以数字开头,且区分大小写. Python对于缩进敏感.在 ...
- python 基础数据类型之list
python 基础数据类型之list: 1.列表的创建 list1 = ['hello', 'world', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ...
- Python基础数据类型-字典(dict)
Python基础数据类型-字典(dict) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 本篇博客使用的是Python3.6版本,以及以后分享的每一篇都是Python3.x版本的哟 ...
- Python基础数据类型之字符串
Python基础数据类型之字符串 一.Python如何创建字符串 在python中用引号将一些文本包起来就构成了字符串(引号可以是单引号.双引号.单三引号,双三引号,它们是完全相同的) >> ...
- Python基础数据类型之集合
Python基础数据类型之集合 集合(set)是Python基本数据类型之一,它具有天生的去重能力,即集合中的元素不能重复.集合也是无序的,且集合中的元素必须是不可变类型. 一.如何创建一个集合 #1 ...
随机推荐
- JDBC连接mysql数据库操作详解
1.什么是JDBC JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Jav ...
- 2.2.2python的BeautifulSoup库
from bs4 import BeautifulSoupimport rebroken_html = '<ul class="country"><li>A ...
- 【Intellij】Hot Swap Failed & class reloaded
用 Intellij IDEA 编译程序时遇到了这个问题,如下图所示: 对结果貌似没什么影响,但暂时没找到出现这个情况的原因……
- scroll-苹果滑动卡顿
2018年08月02日,程序小bug. 在移动端html中经常出现横向/纵向滚动的效果,但是在iPhone中滚动速度很慢,感觉不流畅,有种卡卡的感觉,但是在安卓设备上没有这种感觉; 一行代码搞定: - ...
- CTF杂项题解题思路
下载压缩包解压 如果是图片就先查看图片信息 没有有用信息查看图片看是否是一个图片 如果不是图片就将文件进行还原 从还原文件中查找有用信息 例:这是一张单纯的图片 http://123.206.87.2 ...
- MySql数据库操作命令
数据库 database 命令 ********************************* DATABASE 创建数据库 CREATE DATABASE haodlDB DEFAULT CHA ...
- vue通信、传值的多种方式(详细)
转载自https://blog.csdn.net/qq_35430000/article/details/79291287
- 微信小程序的视图与渲染
1.组件的基本使用 <button type="default" > default </button> <button type="pri ...
- Redis批量删除key的小技巧,你知道吗?
在使用redis的过程中,经常会遇到要批量删除某种规则的key,但是redis提供了批量查询一类key的命令keys或scan,没有提供批量删除某种规则key的命令,怎么办?看完本文即可,哈哈. 本文 ...
- java学习-NIO(二)Buffer
当我们需要与 NIO Channel 进行交互时, 我们就需要使用到 NIO Buffer, 即数据从 Buffer读取到 Channel 中, 并且从 Channel 中写入到 Buffer 中.缓 ...