文章目录
一.字符串类型1.字符串的表示方式2.字符串的下标和切片3.字符串常见的内置函数4.字符串的运算符5.字符编码6.字符串格式化7.字符串format方法的使用二.布尔类型三.列表1.列表的基本使用2.列表的增删改查3.列表的排序和反转4.列表的遍历5.列表的嵌套6.列表的推导式7.列表的复制四.元组1.元组的定义2.元组的访问3.元组的修改4.元组的删除5.元组的运算符6.元组的遍历7.元组的内置函数五.字典1.字典的定义2.字典的增删改查3.字典的遍历六.集合1.集合的定义2.集合的基本操作3.集合使用运算符七.其他知识点1.JSON的相关知识2.带下标的遍历(enumerate)一.字符串类型
1.字符串的表示方式
字符串是 Python 中最常用的数据类型。在Python中,可以使用一对单引号、一对双引号或者一对三个单引号、一对三个双引号来创建字符串。(通常使用一对单引或一对双引号)
a = 'hello'b = "world"c = '''你好'''d = """世界"""
如果字符串里还有双引号,外面就可以使用单引号
a = 'I said:" I am happpy"'
在需要在字符中使用特殊字符时,python用反斜杠(“\”)转义字符:
\ ’ ==> 显示一个普通的单引号
\ " ==> 显示一个普通的双引号
\ n ==> 表示一个换行
\ t ==> 表示显示一个制表符
\ \ ==> 表示一个普通的反斜线
作用:对 \ 后面的字符进行转义
x1 = '你好\t世界'print(x1)#你好世界x2 = 'hello wo\\rld' print(x2)#hello wo\rld
在字符串的前面添加 r / R ,在Python里表示的是原生字符串
x3 = r'你好\t世界'print(x3) #你好\t世界
2.字符串的下标和切片
下标又称为索引,表示第几个数据。
在计算机里面,下标都是从0开始的
。我们可以通过下标来获取或者修改指定位置的数据。
x = 'hello world'print(x[4]) # o
字符串是不可变的数据类型
对于字符串的任何操作,都是不会改变原有的字符串!
切片就是从字符串里复制一段指定的内容,生成一个新的字符串.
切片语法:x[start : end : step]
包含start,不包含end
step指的是步长,可理解为间隔。每隔step-1个取一次,步长默认为1,不能够为0。
step为负数时,表示从右往左获取
x = 'hello world'print(x[1:3])# el 包含start,不包含end,默认步长为1print(x[1:]) # ello world 如果只设置了start,会"截取"到最后print(x[:3]) # hel 如果只设置了end,会从头开始"截取"print(x[1:3:2]) # e print(x[:]) # hello world 从头到尾的复制print(x[::-1])# dlrow olleh 从尾到头的复制print(x[-3:-1]) # rl 如果start和end是负数,表示从右边数
3.字符串常见的内置函数
使用内置函数len可以获取字符串的长度。
y='hello world'print(len(y)) # 11
内置函数 find,index,rfind,rindex查找内容,可以获取指定字符的下标。
print(y.find('w')) # 6 如果字符在字符串里不存在,结果为-1print(y.index('w')) # 6 如果字符在字符串里不存在,会报错print(y.rfind('w')) # 6 类似于 find()函数,不过是从右边开始查找.print(y.rindex('w')) # 6 类似于 index()函数,不过是从右边开始查找.
index():找出参数字符串中第一个查询参数的地址,然后将该字符出现的地址返回。
rindex():找出参数字符串中最后一个查询参数的地址,然后将该字符出现的地址返回。
内置函数startswith,endswith,isalpha,isdigit,isalnum,isspace是判断,结果是一个布尔类型。
print('hello'.startswith('he')) # True 判断是否以'he'开头,是则True,反之Falseprint('hello'.endswith('o')) # True 判断是否以'o'结尾,是则True,反之Falseprint('he45llo'.isalpha()) # False 判断是否都是字母,是则True,反之Falseprint('good'.isdigit()) # False 判断是否都是数字,是则True,反之Falseprint('abc123'.isalnum()) # True 判断是否都是字母或者数字,是则True,反之Falseprint('abc 123'.isspace()) #False 判断是否只包含空白,是则True,反之False
内置函数capitalize,upper,lower,title,swapcase有关的大小写的操作。
y ='hEllo woRld'print(y.capitalize()) #Hello world 将字符串的第一个字符转换为大写print(y.upper()) #HELLO WORLD 将字符串中所有字母转换为大写print(y.lower()) #hello world 将字符串中所有字母转换为小写print(y.title()) #Hello World 所有单词都是以大写开始,其余字母均为小写print(y.swapcase()) #HeLLO WOrLD 将字符串中大写转换为小写,小写转换为大写
内置函数split,rsplit,partition,rpartition,ljust,rjust,center,lstrip,rstrip,strip对字符串的格式等修改操作。
y ='hEllo-woRld-你好-世界'print(y.split('-', 2)) # ['hEllo', 'woRld', '你好-世界']print(y.rsplit('-', 2)) # ['hEllo-woRld', '你好', '世界']print(y.partition('R')) # ('hEllo-wo', 'R', 'ld-你好-世界')print(y.rpartition('R')) # ('hEllo-wo', 'R', 'ld-你好-世界')print(y.ljust(20, '+')) # hEllo-woRld-你好-世界+++print(y.rjust(20, '-')) # ---hEllo-woRld-你好-世界print(y.center(20, '*')) # *hEllo-woRld-你好-世界**print('+++++hello+++'.lstrip('+')) # hello+++print('+++++hello+++'.rstrip('+')) # +++++helloprint('+++++hello+++'.strip('+')) # hello
split:按照字符串左边的空格或指定字符切割成一个列表
rsplit:按照字符串右边的空格或指定字符切割成一个列表
partition:从左边开始,指定一个字符串作为分隔符,分为三部分: 前面 分隔符 后面
rpartition:从右边开始,指定一个字符串作为分隔符,分为三部分: 前面 分隔符 后面
ljust:返回一个原字符串左对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
rjust:返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
center:返回一个原字符串居中对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
lstrip:截掉字符串左边的空格或指定字符。
rstrip:截掉字符串右边的空格或指定字符。
strip:在字符串上执行 lstrip()和 rstrip()
内置函数replace替换字符串
y = 'hello world'z = y.replace('l', 'x') # replace 将字符串里 l 替换成 xprint(y) # hello world 字符串是不可变数据类型!!!print(z) # hexxo worxd 原来的字符串不会改变,而是生成一个新的字符串来保存替换后的结果
4.字符串的运算符
1.字符串和字符串之间可以使用加法运算,作用是拼接两个字符串。
x = 'abc'y = '123'print(x + y) # abc123
2.字符串和数字之间可以使用乘法运算,目的是将指定的字符串重复多次。
x = 'abc'print(x * 2) # abcabc
3.字符串可以使用成员运算符,以此来判断给定的字符是否在字符串中。
x = 'abc'print('d' in x) # False
4.字符串和数字之间做 == 运算结果是False,做 != 运算,结果是True。
x = 'a'y = 97print(x == y) # False
5.字符串之间做比较运算,会逐个比较字符串的编码值。
x = 'ab'y = 'ac'print(x < y) # True
5.字符编码
计算机只能处理数字(0和1),如果要处理文本,就必须先把文本转换为数字才能处理。
计算机编码的发展:ASCII --> Latin1 --> Unicode编码(统一码、万国码、单一码)。
1.字符和编码的转换
使用内置函数chr和ord的方法,能够查看数字和字符的对应关系,也可以实现字符和编码之间的相互转换。
chr 根据编码获取对应的字符;ord 获取字符对应的编码。
print(chr(65)) # Aprint(ord('a')) # 字符对应的编码是 97
2.encode和decode的方法使用
在中国常用的字符编码有 GBK,BIG5和utf8这三种编码规则。
GBK编码,一个汉字占两个字节
utf8编码,一个汉字占三个字节
使用encode方法,可以将字符串按照指定的编码格式转换称为二进制;
使用decode方法,可以将一个二进制数据按照指定的编码格式转换成为字符串。
print('你'.encode('gbk')) # b'\xc4\xe3'print('你'.encode('utf8')) # b'\xe4\xbd\xa0'x = b'\xe4\xbd\xa0'print(x.decode('utf8'))# 你
6.字符串格式化
在字符串里可以使用 % 占位符来表示格式化一个字符串。
%s ==> 表示的是字符串的占位符
%d ==> 表示的整数的占位符
%nd ==> 打印时,显示n位,如果不够,在前面使用空格补齐
%f ==> 表示的浮点数的占位符
%.nf ==> 保留小数点后n位
%x ==> 将数字使用十六进制输出
%% ==> 输出一个 %
name = 'jack'age = 20print('我的名字是%s,我今年%d岁,我今天身高%f厘米' % (name, age, 180))#我的名字是jack,我今年20岁,我今天身高180.000000厘米print('我的座位号是%3d位' % 13)#我的座位号是 13位print('我的座位号是%-3d位' % 13)#我的座位号是13 位print('我的座位号是%03d位' % 13)#我的座位号是013位print('我身高%.2f厘米' % 180) #我身高180.00厘米a = 164print('%x' % a) #a4print('%X' % a) #A4print('大家好,我是%%s,今年%d岁' % 20)#大家好,我是%s,今年20岁
7.字符串format方法的使用
str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field,从而完成字符串的格式化,{}也可以进行占位。
1.{ } 什么都不写,会读取后面的内容,一一对应填充
x = '大家好,我是{},我今年{}岁了'.format('张三', 22)print(x) # 大家好,我是张三,我今年22岁了
2.{数字} 根据数字的顺序来进行填入。数字从 0 开始。
y = '大家好,我是{1},我今年{0}岁了'.format(20, 'jerry')print(y) #大家好,我是jerry,我今年20岁了
3.{变量名}
z = '大家好,我是{name},我今年{age}岁了,我来自{addr}'.format(age=18, name='jack', addr='安徽')print(z) #大家好,我是jack,我今年18岁了,我来自安徽
4.混合使用: {数字} {变量}
a = '大家好,我是{name},我今年{1}岁了,我来自{0}'.format('泰国', 23, name='tony')print(a) #大家好,我是tony,我今年23岁了,我来自泰国
5.{}什么都不写 {数字} 不能混合使用
6.可以使用 *元组 和 **字典 的形式传参,两者可以混合使用。
info = {'name': 'chris', 'age': 23, 'addr': '北京', 'height': 190}c = '大家好,我是{name},我来自{addr},身高{height}cm,我今年{age}岁了'.format(**info)print(c) # 大家好,我是chris,我来自北京,身高190cm,我今年23岁了
位置参数、关键字参数、*元组 和 **字典 也可以同时使用,但是要注意,位置参数要在关键字参数前面,*元组 要在 **字典 前面。
二.布尔类型
布尔类型只有两个值:True和False。
三.列表
1.列表的基本使用
1.列表的格式
定义列表的格式:[元素1, 元素2, 元素3, …, 元素n]
list1 = ['张三',18, 66.0]
列表中的元素可以是不同类型的。
2.使用下标获取列表元素
列表和字符串一样,都可以使用下标来获取元素和对元素进行切片,同时还可以使用下标来修改列表的元素。
list1 = ['张三',18, 66.0]print(list1[1]) # 18print(list1[1:]) #[18, 66.0]list1[2]='shanghai'print(list1) #['张三', 18, 'shanghai']
可以使用list(可迭代对象)将可迭代对象转换成为一个列表。
names = list(('zhangsan', 'lisi', 'wangwu', 'maliu'))print(names) # ['zhangsan', 'lisi', 'wangwu', 'maliu']
2.列表的增删改查
列表使用来保存多个数据的,是有序可变的。
操作列表,一般都包括添加数据、删除数据、修改数据以及查询数据。
1.添加元素
添加元素的几个方法:append、insert、extend
append:会把新元素添加到列表末尾。
heros = ['亚索', '佐伊', '赵信', '铁男']heros.append('锤石')print(heros) #['亚索', '佐伊', '赵信', '铁男', '锤石']
insert:insert(index,object)在指定位置index前插入元素object。
index 表示下标,在哪个位置插入数据
object 表示对象,具体插入哪个数据
heros = ['亚索', '佐伊', '赵信', '铁男']heros.insert(2, '鳄鱼')print(heros) # ['亚索', '佐伊', '鳄鱼', '赵信', '铁男']
extend: 通过extend可以将另一个集合中的元素逐一添加到列表中。
extend(iterable) 需要一个可迭代对象
A.extend(B) ==> 将可迭代对象 B 添加到 A 里
heros = ['亚索', '佐伊', '赵信', '铁男']x =['牛头','布隆']heros.extend(x)print(heros) #['亚索', '佐伊', '赵信', '铁男', '牛头', '布隆']
2.删除元素
删除元素的几个方法:pop、remove、clear、del
pop:此方法默认会删除列表里最后一个数据,并且返回这个数据,也可以传入index参数,用来删除指定位置上的数据。
heros = ['亚索', '佐伊', '赵信', '铁男']m = heros.pop(2)print(m) #赵信print(heros)#['亚索', '佐伊', '铁男']
remove:用来删除指定的元素。
heros = ['亚索', '佐伊', '赵信', '铁男']heros.remove('佐伊')print(heros) #['亚索', '赵信', '铁男']
如果数据在列表中不存在,会报错。
clear:用来清空一个列表。
heros = ['亚索', '佐伊', '赵信', '铁男']heros.clear()print(heros) #[]
del:根据下标进行删除
heros = ['亚索', '佐伊', '赵信', '铁男']del heros[0]print(heros) #['佐伊', '赵信', '铁男']
3.修改元素
使用下标就可以直接修改列表里的元素
heros = ['亚索', '佐伊', '赵信', '铁男']heros[3]='霞'print(heros) #['亚索', '佐伊', '赵信', '霞']
4.查询元素
查询元素可以使用in和not in,index和count
in,not in
in(存在),如果存在那么结果为true,否则为false
not in(不存在),如果不存在那么结果为true,否则false
heros = ['亚索', '佐伊', '赵信', '铁男']print('女枪' in heros)# Falseprint('女枪' not in heros) # True
index,count
index用来查找元素所在的位置,如果未找到则会报错;
count用来计算某个元素出现的次数。
它们的使用和字符串里的使用效果一致。
heros = ['亚索', '佐伊', '赵信', '铁男']print(heros.index('铁男')) # 3print(heros.count('铁男')) # 1
3.列表的排序和反转
sort方法是将list按特定顺序重新排列,默认为由小到大。
x = [3, 5, 1, 9, 7, 2, 6]x.sort()print(x) #[1, 2, 3, 5, 6, 7, 9]
参数reverse=True可改为倒序,由大到小。
x = [3, 5, 1, 9, 7, 2, 6]x.sort(reverse=True)print(x) #[9, 7, 6, 5, 3, 2, 1]
reverse方法是将list逆置。
print(names[::-1])x = [3, 5, 1, 9, 7, 2, 6]x.reverse()print(x) #[6, 2, 7, 9, 1, 5, 3]
内置函数sorted,不会改变原有的列表数据,会生成一个新的有序数据
x = [3, 5, 1, 9, 7, 2, 6]y = sorted(x)print(y) #[1, 2, 3, 5, 6, 7, 9]
4.列表的遍历
遍历:将所有的数据都访问一遍。遍历针对的是可迭代对象。
列表的遍历是:while循环遍历和for···in循环遍历
while循环遍历:
heros = ['亚索', '佐伊', '赵信', '铁男']i = 0while i < len(heros):print(heros[i])i += 1
运行结果:
亚索
佐伊
赵信
铁男
for···in循环遍历:
while 循环是一种基本的遍历列表数据的方式,但是最常用也是最简单的方式是使用 for 循环
for…in循环的本质就是不断的调用迭代器的 next 方法查找下一个数据.
heros = ['亚索', '佐伊', '赵信', '铁男']for k in heros:print(k)
运行结果:
亚索
佐伊
赵信
铁男
5.列表的嵌套
列表的嵌套就是一个列表中的元素又是一个列表。
x = [[1, 2, 3], [11, 22, 33], [111, 222, 333]]print(x[1][2]) #33x[1][1] = 'aa'print(x) #[[1, 2, 3], [11, 'aa', 33], [111, 222, 333]]
操作嵌套列表,只要把要操作元素的下标当作变量名来使用即可。
6.列表的推导式
所谓的列表推导式,就是指的轻量级循环创建列表。
1.基本的方式
nums = [i for i in range(10)]print(nums) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]nums = [i for i in range(5,10)]print(nums) #[5, 6, 7, 8, 9]nums = [i for i in range(5,10,2)]print(nums) #[5, 7, 9]
2.在循环的过程中使用if
nums = [i for i in range(10) if i % 2 == 0]print(nums) #[0, 2, 4, 6, 8]nums = [i for i in range(10) if i % 2 != 0]print(nums) #[1, 3, 5, 7, 9]
3. 2个for循环
nums =[(x,y) for x in range(3) for y in range(3)]print(nums)
运行结果:
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
4. 3个for循环
nums = [(x, y, z) for x in range(2) for y in range(2) for z in range(2)]print(nums)
运行结果:
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
7.列表的复制
Python中的赋值运算都是引用(即内存地址)的传递。
对于可变类型来说,修改原数据的值,会改变赋值对象的值。
使用列表的 copy 方法或者 copy 模块就可以赋值一个列表。
1.copy方法
使用列表的copy方法,可以直接将原来的列表进行复制,变成一个新的列表,这种复制方式是浅复制。
x1=[1,2,3,4,5,6]x2=x1.copy()x2[2]=8print(x2) #[1, 2, 8, 4, 5, 6]print(x1) #[1, 2, 3, 4, 5, 6]
修改新列表里的数据,不会影响到原有列表里的数据.
2.copy模块的使用
除了使用列表的copy方法以外,Python还提供了copy模块来复制一个对象。
copy模块提供了浅复制和深复制两种方式,它们的使用方式相同,但是执行的效果有一定的差异。
浅拷贝(浅复制):浅拷贝是对于一个对象的顶层拷贝,通俗的理解是:拷贝了引用,并没有拷贝内容。
x1 = [1, 2, 3, [7, 8, 9], 5, 6]x2 = copy.copy(x1)x2[1] = 11x2[3][1]=12print(x1) #[1, 2, 3, [7, 12, 9], 5, 6]print(x2) #[1, 11, 3, [7, 12, 9], 5, 6]
浅拷贝只会拷贝最外层的对象,里面的数据不会拷贝,而是直接指向。
深拷贝(深复制):深拷贝是对于一个对象所有层次的递归拷贝。
x1 = [1, 2, 3, [7, 8, 9], 5, 6]x3= copy.deepcopy(x1)x3[1] = 11x3[3][1]=12print(x1) # [1, 2, 3, [7, 8, 9], 5, 6]print(x3) # [1, 11, 3, [7, 12, 9], 5, 6]
深拷贝会将对象里的所有数据都进行拷贝。
列表和字符串一样,也支持切片,切片其实就是一种浅拷贝。
四.元组
1.元组的定义
元组和列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。
元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。
ages = (18) # 不加逗号,类型为整型print(type(ages)) #<class 'int'>ages = (18,) # 加上逗号,类型为元组print(type(ages)) #<class 'tuple'>
2.元组的访问
元组与字符串类似,下标索引从0开始,元组可以使用下标索引来访问元组中的值。
x = (1, 5, 98, 7, 'hello')print(x[3]) # 7
3.元组的修改
元组中元素值是不允许修改的,但可以对元组进行连接组合。
x = (1, 5, 98, 7, 'hello')y = ('world', 55, 18)print(x + y) #(1, 5, 98, 7, 'hello', 'world', 55, 18)
4.元组的删除
元组中元素值是不允许删除的,但可以使用del语来删除整个元组。
x = (1, 5, 98, 7, 'hello')del xprint(x) # NameError: name 'x' is not defined
5.元组的运算符
元组与字符串一样,元组之间可以使用+号和*号进行运算。
x = (1, 5, 98, 7, 'hello')y = ('world',)print(x + y) # (1, 5, 98, 7, 'hello', 'world')print(y *3) # ('world', 'world', 'world')print(1 in x) # True
6.元组的遍历
元组可以像列表一样进行遍历
for循环遍历:
x = (1, 5, 98, 7, 'hello')for z in x:print(z)
while 循环遍历:
x = (1, 5, 98, 7, 'hello')j = 0while j < len(x):print(x[j])j += 1
运行结果:
1
5
98
7
hello
7.元组的内置函数
len(tuple):计算元组元素个数。
x = (1, 5, 98, 7, 'hello')print(len(x)) # 5
max(tuple):返回元组中元素最大值。
m =(5,4,9,8)print(max(m)) # 9
min(tuple):返回元组中元素最小值。
m =(5,4,9,8)print(min(m)) # 4
tuple(iterable):将可迭代系列转换为元组。
m =[5,4,9,8]print(tuple(m)) #(5, 4, 9, 8)
五.字典
1.字典的定义
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个元素由两个部分组成: 键:值
键可以使用数字、布尔值、布尔值、元组等不可变数据类型,但是一般习惯使用字符串
键必须是唯一的,但值则不必。如果出现了多个相同的键,后面的值会覆盖前一个相同键对应的值.
dict1 = {'name': 'zhangsan', 'age': 18, 'score': 98}print(dict1) # {'name': 'zhangsan', 'age': 18, 'score': 98}
2.字典的增删改查
1.查看元素
字典的数据在保存时,是无序的,不能通过下标来获取。
我们可以通过使用key获取到对应的value。
student ={'name':'zhangsan','age':22,'score':98}print(student['name']) # zhangsan print(student['math']) # 报错
如果要查找的key不存在,会直接报错
为了获取一个不存在的key时,不报错。如果这个key不存在,将使用默认值。我们可以使用字典的get方法。
student ={'name':'zhangsan','age':22,'score':98}print(student.get('math')) # 返回值默认是None,不报错print(student.get('math',99)) # 99
2.添加元素
使用变量名[‘键’] = 数据,如果这个“键”在字典中不存在,那么就会新增这个元素。
student = {'name': 'zhangsan', 'age': 22, 'math': 98}print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98}student['english'] = 99print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98, 'english': 99}
还可以使用update的方法
student = {'name': 'zhangsan', 'age': 22}score = {'math': 98, 'english': 99}student.update(score)print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98, 'english': 99}
3.修改元素
字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改。
student = {'name': 'zhangsan', 'age': 22, 'math': 98}print(student) #{'name': 'zhangsan', 'age': 22, 'math': 98}student['name'] = 'lisi'print(student) #{'name': 'lisi', 'age': 22, 'math': 98}
4.删除元素
字典的删除操作有这几种:pop、popitem、del、clear
pop:删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。
student = {'name': 'zhangsan', 'age': 22, 'math': 98}x = student.pop('math')print(x) #98print(student)#{'name': 'zhangsan', 'age': 22}
popitem:随机返回并删除字典中的最后一对键和值。
student = {'name': 'zhangsan', 'age': 22, 'math': 98}result = student.popitem()print(result) # ('math', 98)print(student) # {'name': 'zhangsan', 'age': 22}
del:删除字典给定键和它的值
student = {'name': 'zhangsan', 'age': 22, 'math': 98}del student['math']print(student) #{'name': 'zhangsan', 'age': 22}
clear:删除字典内所有元素
student = {'name': 'zhangsan', 'age': 22, 'math': 98}student.clear()print(student) #{}
3.字典的遍历
1.遍历字典的key
student={'name': 'zhangsan', 'age': 22, 'math': 98}for key in student.keys():print(key)
运行结果:
name
age
math
2.遍历字典的value
student={'name': 'zhangsan', 'age': 22, 'math': 98}for value in student.values():print(value)
运行结果:
zhangsan
22
98
3.遍历字典的元素
student={'name': 'zhangsan', 'age': 22, 'math': 98}for item in student.items():print(item)
运行结果:
(‘name’, ‘zhangsan’)
(‘age’, 22)
(‘math’, 98)
4.遍历字典的key-value
student = {'name': 'zhangsan', 'age': 22, 'math': 98}for key, value in student.items():print('key=%s,value=%s'% (key, value))
运行结果:
key=name,value=zhangsan
key=age,value=22
key=math,value=98
六.集合
1.集合的定义
集合(set)是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合。
注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
m = {'hello','world',2,4}print(m) # {'hello', 'world', 2, 4}print(type(m))#<class 'set'>
2.集合的基本操作
1.添加元素
使用add方法添加一个元素,如果元素已存在,则不进行任何操作。
heros = {'亚索', '佐伊', '女枪'}heros.add('锤石')print(heros) #{'佐伊', '亚索', '锤石', '女枪'}
还能使用update方法,也可以添加元素,且参数可以使列表、元组、字典等。
heros = {'亚索', '佐伊', '女枪'}heros.update({'牛头','铁男'})print(heros) #{'佐伊', '铁男', '亚索', '女枪', '牛头'}
2.删除元素
可以使用pop方法,随机删除一个元素。
heros = {'亚索', '佐伊', '女枪'}heros.pop()print(heros) #{'女枪', '亚索'}
还可以使用remove方法,删除一个指定的元素,如果元素不存在,则会发生错误。
heros = {'亚索', '佐伊', '女枪'}heros.remove('亚索')print(heros) #{'佐伊', '女枪'}
还能使用discard方法,删除一个指定的元素,如果元素不存在,不会发生错误。
heros = {'亚索', '佐伊', '女枪'}heros.discard('女枪')print(heros) #{'佐伊', '亚索'}
使用clear方法,直接清空一个集合。
heros = {'亚索', '佐伊', '女枪'}heros.clear()print(heros) #set()
3.查询元素
可以使用成员运算符来查看指定元素是否在集合中。
heros = {'亚索', '佐伊', '女枪'}print('女枪' in heros) # True
3.集合使用运算符
first = {1, 2, 3, 4, 5, 6}second = {4, 5, 6, 7, 8, 9}print(first - second) # A - B 求A和B的差集print(second - first)print(first & second) # A & B 求A和B的交集print(first | second) # A | B 求A和B的并集print(first ^ second) # A ^ B 求A和B差集的并集
运行结果:
{1, 2, 3}
{8, 9, 7}
{4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 7, 8, 9}
七.其他知识点
1.JSON的相关知识
JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换格式,它基于 ECMAScript 的一个子集,采用完全独立于编程语言的文本格式来存储和表示数据。JSON本质是一个字符串
JSON的功能强大,使用场景也非常的广,目前我们只介绍如何使用Python的内置JSON模块,实现字典、列表或者元组与字符串之间的相互转换。
使用json的dumps方法,可以将字典、列表或者元组转换成为字符串。
student = {'name': 'zhangsan', 'age': 22, 'english': 99}m = json.dumps(student) print(m) # {"name": "zhangsan", "age": 22, "english": 99}print(type(m)) # <class 'str'>
使用json的loads方法,可以将格式正确的字符串转换成为字典、列表。
student = '{"name": "zhangsan", "age": 22, "english": 99}'x = json.loads(student)print(x) # {'name': 'zhangsan', 'age': 22, 'english': 99}print(type(x)) # <class 'dict'>
2.带下标的遍历(enumerate)
可迭代对象都可以使用 enumerate 内置类进行包装成一个 enumerate 对象。对enumerate进行遍历,可以同时得到一个可迭代对象的下标和元素。
nums = (2, 5, 7, 8, 4, 6)for i, j in enumerate(nums):print('第%d个数据是%d' % (i, j))
运行结果:
第0个数据是2
第1个数据是5
第2个数据是7
第3个数据是8
第4个数据是4
第5个数据是6