Python三

于 2021-04-16 21:15:07 发布
阅读量140 收藏
点赞数
分类专栏： Python学习笔记 文章标签： python 列表 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LC_Python/article/details/115771961
版权

Python

三、常见的数据以及操作

1、字符串
1.1、字符串的表示

​ 字符串是Python中最常用的数据类型，用一对单引号或一对双引号或一对三单引号或一对三双引号括起来的内容就是字符串。

a='这是一个字符串'
b="我也是字符串"
c='''当然我也是字符串'''
d="""我是一个长长长
     长字符串"""	#三个单引号或双引号括起来的内容可以换行书写，与长注释类似
e="I'm ok"	#当字符串内部有引号时，外部就可以用不同的引号来表示字符串的范围
1.2、转译功能

​ 在Python内部，不想某些特殊字符起作用时，可以使用转译字符\来转译字符的特殊功能

e='I\'m ok'	
print(e)	#I'm ok 转译单引号的功能，把它作为一个普通字符来用

​ 常用的转译功能有：\n(换行)、\t（显示一个制表符）、\\(显示一个普通的\)

​ 在Python中还可以使用’r’字符来防止转译

print(r'I\'m ok')	#I\'m ok 在字符串的前面加上r能防止转译发生
1.3、字符串的索引和切片

​ 字符串是一个可迭代对象，它具有下标（索引）,下标起始是0，往右依次增加。或者从右往左，起始下标是-1。可以通过索引来获取对应位置的字符串数据

str1='abcdefghkl'
print(str1[0]) 	#a
print(str1[4])	#e
print(str1[-2])	#k
print(str[0]='c')	#报错 字符串是不可变数据，不能再原地址上修改数据

​ 字符串切片就是利用索引来截取一段字符串数据的功能，注意，对字符串的任何操作都不会改变原地址的数据。

str1='abcdefghkl'
str2=str1[1:6]
print(str2)	#bcdef  切片从给定的数据开始，到给定数据结束，不包含结尾数据
print(str1[-9:-5])	#bcde
print(str1[0:9:2])	#acegk  第三个数是切片步长，默认是1，不能为0
#切片步长可以是负数，代表切片的方向是从右往左
print(str1[0:9:-1])	#空	因为从第0个元素往左找没有元素
print(str1[9:0:-1])	#lkhgfedcb
print(str1[:])	#abcdefghkl	复制一个字符串
print(str1[::-1])	#lkhgfedcba	将字符串反序输出
1.4、字符串的常见操作方法
  • 获取字符串长度：内置len()函数，返回一个可迭代对象的长度
str1='abcdefghkl'
print(len(str1))	#10
  • 查找内容的方法：find、index、rfind、rindex

find、index：查找字符在字符串中的索引（下标），返回最小的索引值。不同的是如果字符在字符串中不存在，find返回-1，index会报错

str1='abcdefabcdef'
print(str1.find('d'))	#3
print(str1.index('d'))	#3
print(str1.find('h'))	#-1
print(str1.index('h'))	#报错
print(str1.find('c',1,6)) #2 在指定范围内查找

rfind、rindex：查找字符在字符串中的索引（下标），返回最大的索引值。用法与find、index相同

  • 判断相关的方法：startswith、endswith、isalpha、isdigit、isalnum、isspace

都是判断字符的方法，返回一个布尔量

print('hello'.startswith('he'))	#True	判断一个字符串的起始字符
print('hello'.endswith('lo'))	#True	判断一个字符串的结束字符
print('hello'.isalpha())	#True	判断一个字符串是不是字母构成
print('a1b2'.isalpha())	#False
print('1234'.isdigit())	#True	判断一个字符串是不是数字构成
print('1+2'.isdigit())	#False
print('a1b2'.isalnum())	#True	判断一个字符串是不是数字或字母构成
print('abc'.isalnum())	#True
print('  '.isspace())	#True	判断一个字符串是不是全部空格构成
  • 统计方法：count

count方法：返回指定字符在指定区间里面出现的次数

words='''信念的力量在于即使身处逆境，亦能帮助你鼓起前进的船帆；信念的魅力在于即使遇到险运，亦能召唤你鼓起生活的勇气；信念的伟大在于即使遭遇不幸，亦能促使你保持崇高的心灵'''
print(words.count('念'))	#3
  • 替换方法：replace

replace方法：替换字符串的字符，如果指定次数，替换不超过指定次数

weather='今天是个好天气！'
new_weather=weather.replace('好','坏')
print(new_weather)	#今天是个坏天气！

word='AAAAA'
new_word=word.replace('A','X',3)
print(new_word)	#XXXAA

注意：replace方法不会改变原字符串，只会生成一个新的字符串，因为字符串是一个不可变数据

  • 内容分割方法split()、rsplit()、splitlines()、partition()、rpartition()

split()方法：用指定的字符将字符串从左往右分割成一个列表，可以控制分割的数量。

rsplit()方法：用指定的字符将字符串从右往左分割成一个列表，可以控制分割的数量。

str1='zhangsan-lisi-wangwu-lisa-jack-robbert'
name=str1.split('-') #默认是以'-'全部分割
print(name)	#['zhangsan', 'lisi', 'wangwu', 'lisa', 'jack', 'robbert']
print(str1.split('-',2))	#['zhangsan', 'lisi', 'wangwu-lisa-jack-robbert']
print(str1.rsplit('-',2))	#['zhangsan-lisi-wangwu-lisa', 'jack', 'robbert']

splitlines()方法：将字符串按换行符进行分割,返回一个列表

a='he is a \n handsome boy'
print(a.splitlines())	#['he is a ', ' handsome boy']
b='''我是一个长
长
长字符串'''
print(b.splitlines())	#['我是一个长', '长', '长字符串']

partition()方法：以指定的字符分割字符串，返回一个3个字符串的元组，包含这个字符串前面的部分、分割字符本身、分割字符后面的部分。如果没有找到分割字符，则返回由整个字符串加2个空字符串构成的元组

str1='zhangsan-lisi-wangwu-lisa-jack-robbert'
print(str1.partition('-'))	#('zhangsan', '-', 'lisi-wangwu-lisa-jack-robbert')
print(str1.partition('_'))	#('zhangsan-lisi-wangwu-lisa-jack-robbert', '', '')

rpartition()方法：与partition()类似，只是切分时是从右往左。

str1='zhangsan-lisi-wangwu-lisa-jack-robbert'
print(str1.rpartition('-'))	#('zhangsan-lisi-wangwu-lisa-jack', '-', 'robbert')
  • 大小写修改方法：capitalize()、upper()、lower()、title()

capitalize()方法：让一个字符串的第一个单词的首字母变成大写

a='hello world!'
print(a.capitalize())	#Hello world!

upper()、lower()方法：把一个字母字符串变成大写或小写字母

a='hello world!'
b=a.upper()
print(b)	#HELLO WORLD!
c=b.lower()
print(c)	#hello world!

title()方法：把字符串的每个单词的首字母变成大写

a='hello world!'
print(a.title())	#Hello World!
b='this-is-a-word'
print(b.title())	#This-Is-A-Word
  • 空格处理方法：ljust()、rjust()、center()、lstrip()、rstrip()、strip()

ljust()``rjust()方法：让字符串以指定长度显示，如果长度不够，默认在右边使用空格补齐，语法ljust(width,fillchar)指定长度和填充字符，默认是空格填充。rjust()实在左侧使用填充字符

a='0.0'
print(a.ljust(7,'-'))	#0.0----
print(a.rjust(7,'-'))	#----0.0

center()方法：返回指定长度字符串，并在两端使用指定字符补全（默认是空格符）

a='0.0'
print(a.center(10,'-'))		#---0.0----

lstrip()方法：去掉字符串左侧的指定字符，默认是空格

rstrip()方法：去掉字符串右侧的指定字符，默认是空格

a='    pill   '
print(a.lstrip())	#pill   #后面有空格
print(a.rstrip())	#    pill
b='+++分割线+++'
print(b.lstrip('+'))	#分割线+++

strip()方法：去掉字符串中的指定字符，默认是空格

b='+++分割线+++'
print(b.strip('+'))	#分割线
  • 字符串拼接方法：join()

join(iterable)将调用字符串本身插入到一个可迭代对象的每个元素（元素必须是字符串）之间，返回一个新的字符串。

l=['A','B','C','D']
a='+'
print(a.join(l))	#A+B+C+D
b=' is >'
print(b.join(l))	#A is >B is >C is >D
1.5、字符的编码

​ 在计算机中，所有内容都是以0和1来进行存储的。对于除了0和1的其他所有字符，都需要进过转换才能被计算机识别，因此诞生了计算机语言的码表（ASCII码表），后来随着计算机的发展，使用的国家越来越多，又出现了许多其他编码规则，造成编码互不通用。后来根据这一情况诞生了unicode编码（万国码），在unicode中字符一般用16位构成（2个字节），特别生僻的汉字使用4个字节组成。

​ 但是使用unicode有一个问题，由于所有的字符最少都是由16位组成，相比ASCII码增加了内存大小，尤其是英文文本。后来又在unicode的基础上设计了UTF-8编码，能够根据不同的字符编码成1-6个字节，常用的英文字母是1个字节，汉字一般是3个字节，特别生僻的汉字编码成4-6个字节。现在最常用的就是UTF-8编码。

注意：在Python中，字符串是以Unicode编码的

​ 在Python中，提供了ord()和chr()函数来对字符与编码之间的相互转换

print(ord('A'))		#65	将字符串'A'转换为unicode编码
print(chr(20311))	#佗	将数字对应的unicode编码转换成字符串

​ 以Unicode显示的字符串可以通过encode()方法编码成指定的byte数据，Python中byte数据用字母b+单引号或双引号表示

a=b'an' #注意，a是一个byte-字节数据，不是字符串数据

print('123abc'.encode('ascii'))	#b'123abc'
print('世界'.encode('ascii'))	#报错	因为汉字超过了ASCII码的范围
print('完美世界'.encode('utf8'))	
#b'\xe5\xae\x8c\xe7\xbe\x8e\xe4\xb8\x96\xe7\x95\x8c'
#\x表示16进制数据，在utf8编码中，一个汉字占用3个字节

​ 当接受到字节流信息时，可以使用decode()方法来解码，注意只有byte数据才能调用decode方法。

a=b'\xe5\xae\x8c\xe7\xbe\x8e\xe4\xb8\x96\xe7\x95\x8c'
print(a.decode('utf8'))	#完美世界

​ 若byte数据中有部分不能解析的信息，decode()方法就会报错，可以使用errors='ignore'忽略无效的字节。

a=b'\xe5\xae\x8c\xe7\xbe\x8e\xe4\xb8\x96\xe7\x95\xff'	#最后一个字节无效
print(a.decode('utf8',errors='ignore'))	#完美世
1.6、字符串的格式化输出
  • 使用占位符%进行格式化输出
name='lisa'
age=25
city='beijing'
print('大家好，我叫%s，我今年%d岁，我来自%s'%(name,age,city))
#大家好，我叫lisa，我今年25岁，我来自beijing

​ 占位符搭配字符使用代表不同的含义：

%s——表示的是字符串的占位符

%d——表示的是整数的占位符

%f——表示的是浮点数的占位符

%nd——打印时，显示n位，如果不够，在前面使用空格补齐

%0nd——打印时，显示n位，如果不够，在前面使用数字0补齐

%.nf——四舍五入保留小数点后n位

%%——显示正常的%

  • 使用format()方法进行输出

    format()方法搭配{}也可以对字符串进行格式化输出

#format的第一种用法，使用{}占位，后面的内容顺序必须一一对应
print('大家好，我叫{}，我今年{}岁，我来自{}'.format('lisa',23,'beijing'))
#大家好，我叫lisa，我今年23岁，我来自beijing

#format的第二种用法，在{}里写上顺序，从0开始，后面的内容顺序要与数字的顺序对应
print('大家好，我叫{1}，我今年{0}岁，我来自{2}'.format(23,'lisa','beijing'))
#大家好，我叫lisa，我今年23岁，我来自beijing

#format的第三种用法，在{}里写上变量名，后面的内容把变量名作为关键字参数传入，顺序无要求
print('大家好，我叫{name}，我今年{age}岁，我来自{city}'.format(age=25,name='lisa',city='beijing'))
#大家好，我叫lisa，我今年25岁，我来自beijing

​ 使用format()方法还可以便捷的对列表（使用1个*）和字典（使用2个**）拆包，用其内容来格式化字符串

person=['jack',22,'chengdu']
print('大家好，我叫{}，我今年{}岁，我来自{}'.format(*person))	#对顺序有要求
#大家好，我叫jack，我今年22岁，我来自chengdu

info={'heights':180,'age':30,'city':'shanghai','name':'adam'}	
print('大家好，我是{name},身高{heights}cm,年龄{age}岁，来自{city}'.format(**info))
#大家好，我是adam,身高180cm,年龄30岁，来自shanghai
#字典拆包对内容顺序无要求，因为字典本身就是无序的，是利用key来查找内容
2、列表
2.1、列表的表示

​ Python中使用一对[ ]来表示列表（list），列表是一个可迭代对象，是一个有序的数据

a=[1,2,3]
b=['a','b','c']

​ 可以使用内置类list(iterable)来将一个可迭代对象转换为一个列表

name='jack'
num=100
print(list(name))	#['j', 'a', 'c', 'k']
print(list(num))	#报错，因为num不是一个可迭代对象
2.2、列表的索引和切片

​ 列表是有序的，因此可以使用索引来获取列表的元素。索引和切片的方法与字符串的操作一样。

a=[1,2,3,4,5,6]
print(a[2])		#3
print(a[1:4])	#[2,3,4]

#切片的开始和结束值如果不写，则可以实现从头到尾的复制
print(a[:])	  #[1,2,3,4,5,6]

#切片还可以控制步长
print(a[::2])	#[1, 3, 5]
print(a[::-1])	#[6, 5, 4, 3, 2, 1]
2.3、列表的增删改查和其他操作

注意：列表的操作会改变原始列表的值，因为列表是可变数据类型

  • 列表的增加操作方法

append(object)方法：把object增加到列表的末尾

nums=[1,2,3]
nums.append(100)
print(nums)	#[1, 2, 3, 100]

extend(iterable)方法：把一个可迭代对象的元素增加到列表尾端

nums=[1,2,3]
name='jack'
nums.extend(name)
print(nums)	#[1, 2, 3, 'j', 'a', 'c', 'k']

insert(index,object)方法：在指定的index（索引）前面插入object

nums=[1,2,3]
nums.insert(1,100)
print(nums)	#[1, 100, 2, 3]
  • 列表的删除操作方法

pop(index=-1)方法：移除指定位置的元素并返回这个元素，默认索引是最后一个元素。

names=['zhangsan','jack','lisi','jacob']
name=names.pop(1)
print(name)		#jack
print(names)	#['zhangsan', 'lisi', 'jacob']

remove(value)方法：移除第一个出现的指定值(value)

names=['zhangsan','jack','lisi','jack']
names.remove('jack')
print(names)	#['zhangsan', 'lisi', 'jack']

clear()方法：清除列表所有内容

names=['zhangsan','jack','lisi','jack']
names.clear()
print(names)	#[]

列表的删除操作还可以使用关键字del，但使用时要特别小心

names=['zhangsan','jack','lisi','jack']
del names[1]
print(names)	#['zhangsan', 'lisi', 'jack']
del names
print(names)	#报错 因为列表names已经不存在了
  • 列表的修改方法

列表可以直接使用索引修改内容

names=['zhangsan','jack','lisi','jack']
names[1]='jacob'
print(names)	#['zhangsan', 'jacob', 'lisi', 'jack']

Python中有一个特殊写法，可以交换2个变量的值，参考如下代码

a=5
b=10
a,b=b,a		#2个变量的值互相交换
print('a=%d,b=%d'%(a,b))	#a=10,b=5

str1=[100,200,300]
str1[0],str1[1]=str1[1],str1[0]
print(str1)	#[200, 100, 300]
  • 列表的查找方法

index(value)方法：返回指定值的第一个索引

names=['zhangsan','jack','lisi','jack']
print(names.index('jack'))	#1

count(value)方法：返回指定值在列表中出现的次数

num=[1,3,5,6,4,7,3,5,2,5,2,5,2]
print(num.count(5))	#4
2.4、列表的排序和反转
  • 列表的排序

​ sort(reverse=False)方法可以直接对列表的内容进行排序，reverse=False默认从小到大进行排序。sort()方法是对原列表进行操作，不会生成新的列表。

a=[1,4,6,2,3,7,9,5,8,11,10]
a.sort()
print(a)	#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
a.sort(reverse=True)	#从大到小排序
print(a)	#[11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

b=['a','c','f','b','d','e']
b.sort()
print(b)	#['a', 'b', 'c', 'd', 'e', 'f']

​ 列表的排序还可以使用内置函数sorted()，它的作用是对列表进行排序，并返回一个新的列表。

a=[1,4,6,2,3,7,9,5,8,11,10]
b=sorted(a)
print(a)	#[1, 4, 6, 2, 3, 7, 9, 5, 8, 11, 10]
print(b)	#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
  • 列表的反转

列表的反转reverse()方法，直接把原列表的内容进行反转

a=[1,4,6,2,3,7,9,5,8,11,10]
a.reverse()
print(a)	#[10, 11, 8, 5, 9, 7, 3, 2, 6, 4, 1]

a=[1,4,6,2,3,7,9,5,8,11,10]
print(a[::-1])	#[10, 11, 8, 5, 9, 7, 3, 2, 6, 4, 1]
#reverse()方法反转与列表切片反转的区别是切片反转实际是一个新的列表
2.5、列表的嵌套

​ 一个列表里的元素是列表，我们称之为列表的嵌套

a=[1,2,3,['jack','lisa','humbert']]
#定义一个嵌套列表
print(a[3])		#['jack', 'lisa', 'humbert']
print(a[3][2])	#humbert
2.6、列表遍历的注意事项

​ 在对列表进行遍历操作时，最好不要对列表进行增删操作，否则可能会出现bug。

#删除列表中的所有空字符串，不能使用strip()方法
words=['Python','java','','','C','','C#']
for word in words:
    if word=='':
        words.remove(word)
print(words)	#['Python', 'java', 'C', '', 'C#']
#结果发现空字符串并没有被删除干净，并且看起来很奇怪，这是2个问题导致的：列表的索引问题和remove方法因为列表的遍历实际上是根据索引进行的，当index=2时，符合条件删除该元素，后面的元素自动往前顶。此时下一个空字符串的index变成了2，因为index=2已经被遍历过了，所以该元素会被漏掉。继续遍历，index=4时，又是一个空字符串，符合条件，remove方法就会把列表中查到的满足条件的第一个空字符串删除（实际删除的是index=2的元素）

​ 结论：在对有序可变数据序列（比如列表）进行遍历时，最好不要进行增删操作。

​ 那如果我们要实现上面的功能应该如何做呢，参考以下代码

words=['Python','java','','','C','','C#']
new_words=[x for x in words if x !='']
print(new_words)	#['Python', 'java', 'C', 'C#']
#通过提取有效元素生成新列表也可以实现我们需要的功能
2.7、深拷贝与浅拷贝

​ 在列表中，存在着不同的拷贝方法

  • 浅拷贝
a=[1,2,3,['jack','lisa','humbert']]
b=a.copy()
print(b)	#[1, 2, 3, ['jack', 'lisa', 'humbert']]
a[1]='美好'
print(a)	#[1, '美好', 3, ['jack', 'lisa', 'humbert']]
print(b)	#[1, 2, 3, ['jack', 'lisa', 'humbert']]

a[3][2]='貂蝉'
print(a)	#[1, '美好', 3, ['jack', 'lisa', '貂蝉']]
print(b)	#[1, 2, 3, ['jack', 'lisa', '貂蝉']]
#发现如果修改了嵌套列表的值，复制的列表也跟着发生了变化

​ 列表的copy()方法只能把列表的第一层生成一个新的对象复制给变量，第二层及更深的嵌套列表仍然指向原地址。当修改了原地址的嵌套列表时，复制的嵌套列表指向的地址内容也跟着发生变化。

​ 复制列表还可以使用copy模块的copy()函数

import copy	#调用copy模块
a=[1,2,3]
b=copy.copy(a)	#调用copy模块的copy()函数
print(b)	#[1, 2, 3]
#以上写法完全等效于列表的copy()方法
  • 深拷贝

​ 对于嵌套列表，如果想拷贝的列表与原列表完全独立，需要使用深拷贝的功能，调用copy模块的deepcopy()函数来实现

import copy
a=[1,2,3,[100,200]]
b=copy.deepcopy(a)
print(b)	#[1, 2, 3, [100, 200]]
a[3][1]=100
print(a)	#[1, 2, 3, [100, 100]]
print(b)	#[1, 2, 3, [100, 200]]
#通过深拷贝，列表b不会受到列表a修改值的影响
2.8、列表推导式

​ 在Python中，对于很长的有规律的列表可以通过列表推导式来简单的书写，参考以下代码

#列表a里存放1-100的整数，如果直接写太浪费时间了
a=[x for x in range(1,101)]	#完全等价于a=[1,2,3,4.....99,100]

#可以搭配三元表达式来进行条件筛选
a=[x for x in range(1,101) if x%2 == 0]
#生成了一个1-100的偶数列表

#可以生成复杂的列表
a=[(i,j) for i in range(1,4) for j in range(2,5)]
print(a)	#[(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)]
3、元组
3.1、元组的表示

​ 在Python中用( , )的方式来表示元组（tuple），在某些情况下括号可以省略。元组是一个有序的不可变数据。

a=(1,2,3)	#定义元组
b=2,3		
print(b,type(b))	#(2, 3) <class 'tuple'>
#不用()也能定义元组，所以定义元组的关键其实是逗号','
#定义包含一个元素的元组要注意
c=(4)
print(c,type(c))	#4 <class 'int'>
#只用一个括号的类型不是元组，正确的定义如下
d=(4,)
print(d,type(d))	#(4,) <class 'tuple'>

​ 内置类tuple(iterable)可以将一个可迭代对象转成一个元组

a=tuple('jack')
b=tuple([1,2,3,4])
print(a,b)	#('j', 'a', 'c', 'k') (1, 2, 3, 4)

​ 元组也是一个有序数据，能够通过索引进行访问

a=(1,2,3,4,5)
print(a[1])		#2
3.2、元组的操作

​ 元组的操作方法只有count(value)、index(value)，用法与列表的一样。另外，元组支持’+'运算，可以实现元组的拼接。

t1=(1,3,5,'jack')
t2=(4,4,'barry')
print(t2.count(4))	#2
print(t1.index('jack'))	#3
print(t1+t2)	#(1, 3, 5, 'jack', 4, 4, 'barry')
4、字典
4.1、字典的表示

​ Python中字典（dict）以 ‘键—值’对的形式存在，用{}来表示，一般称键为key，值为value。键与值之间用冒号:连接。

d={'name':'adam','job':'superman','age':28}

​ 需要注意的是字典是可变类型数据，但它是无序数据，没有索引。查找字典的内容都是通过key来实现的。字典有以下几点特征：

  • 字典内部的key是唯一的，不能有重复的key存在，而value可以重复。
  • 字典的key必须是不可变类型的数据（一般用字符串），而value可以是任意类型的数据

字典与列表相比，在存有大量数据时，从列表查找数据是采用依序查找，耗时较长。而字典采用key查找value，就好像我们用字典查找汉字一样，能够快速的查找到想要的内容。因此，字典其实是一种利用空间来交换时间的方法。

4.2、字典的增删改查操作

​ 字典与列表一样是可变类型的数据，因此可以对其进行增删改查的操作。

  • 字典的增加和修改方法

​ 字典的内容除了在定义时添加，还可以通过key来增加，如果key已经存在，则覆盖原有的value；如果key不存在，则新增加一对key-value到字典中。

d={'name':'adam','job':'superman','age':28}
d['name']='clark'
print(d)	#{'name': 'clark', 'job': 'superman', 'age': 28}
#key已经存在，用新的value覆盖了原有的值

d['city']='new_york'
print(d)	#{'name': 'clark', 'job': 'superman', 'age': 28, 'city': 'new_york'}
#key['city']在字典中不存在，因此在字典中自动增加了一对key-value

​ update()方法可以合并2个字典

d1={'name':'jocab','city':'york'}
d2={'score':95,'height':190}
d1.update(d2)
print(d1)	#{'name': 'jocab', 'city': 'york', 'score': 95, 'height': 190}
  • 字典的删除操作

​ 字典的删除可以使用pop(key,d)方法，其作用是根据key移除字典中的key-value，如果key存在，返回value；如果key不存在，返回d（如果d没有，就会报错）

d={'name':'adam','job':'superman','age':28}
a=d.pop('job')
print(a)	#superman
print(d)	#{'name': 'adam', 'age': 28}

b=d.pop('gender','nothing')	#移除key：gender对应的值，若不存在则返回'nothing'
print(b)	#nothing

​ 如果希望把key和value一起返回，可以使用popitem()方法，返回一个包含key和value的元组。

d={'name':'adam','job':'superman','age':28}
a=d.popitem()
print(a)	#('age', 28)
print(d)	#{'name': 'adam', 'job': 'superman'}

​ 字典还可以使用关键字del来删除内容和clear()方法清除字典中所有内容

d={'name':'adam','job':'superman','age':28}
del d['age']
print(d)	#{'name': 'adam', 'job': 'superman'}
d.clear()
print(d)	#{}

​

  • 字典的查询

​ 首先介绍3钟方法：items()，keys()，values().

d={'name':'adam','job':'superman','age':28}
print(d.items())	#dict_items([('name', 'adam'), ('job', 'superman'), ('age', 28)])
print(d.keys())		#dict_keys(['name', 'job', 'age'])
print(d.values())	dict_values(['adam', 'superman', 28])

上面的3中方法分别可以获取字典的键值对、key、value，结果是一个类似于列表的可以被访问的序列,。

​ 获取字典的内容除了通过key直接访问，还可以通过get(key,default=None)方法来访问，它的作用是获取key对应的value，若不存在则返回默认值。

d={'name':'adam','job':'superman','age':28}
a=d.get('name')
b=d.get('city')
print(a,b)	#adam None
4.3、字典的遍历

​ 字典是一个可迭代对象，因此可以使用遍历操作来获取字典的元素。对字典的遍历主要用以下2种方法

#第一种方法：
d={'name':'adam','job':'superman','age':28}
for key in d:	#字典默认迭代的内容是key
    print('{}={}'.format(key,d[key]))
#name=adam
#job=superman
#age=28

#第二种方法：
d={'name':'adam','job':'superman','age':28}
for (k,v) in d.items():
    print(k,'=',v)
#name = adam
#job = superman
#age = 28

​ Python还支持for..in dict.keys()和for..in dict.values()，只不过一般不用

4.4、字典推导式

​ 字典与列表一样，可以使用推导式来快速生成一个字典

#调换一个字典的key和value
d={'a':100,'b':200,'c':300}
d={v:k for k,v in d.items()}
print(d)	#{100: 'a', 200: 'b', 300: 'c'}
5、集合
5.1、集合的表示

​ 集合（set）与字典类似，可以把集合看成是字典的key组成的，所以集合内的元素也不能重复。同理，集合是一个无序的可变元素。

s=set([1,2,3,3,3,4,4,4,5])	#利用set()来把一个列表变成集合
print(s)	#{1, 2, 3, 4, 5}	集合会自动过滤重复的值

​ 要创建一个空集合必须使用set(),不能使用{}来表示，因为{}表示一个空字典

d=set()	#创建一个空集合
print(d)	#set()
5.2、集合的操作方法

​ 要想给集合增加元素，可以用add()方法。

s={1,2,3,4}
s.add(5)
s.add(1)	#添加已有的元素不会有任何效果
print(s)	#{1, 2, 3, 4, 5}

​

​ 要删除集合里的指定元素，可以用remove()和 discard()方法，2者的区别是如果指定的元素不存在，remove方法会报错，discard方法什么都不做。

s1,s2={1,2,3,4},{1,2,3,4}
s1.remove(1)
s2.discard(1)
print(s1,s2)	#{2, 3, 4} {2, 3, 4}

​ 使用difference()和union()、intersection()方法可以对集合进行交并集操作

#difference()	返回调用方法的集合与1个或多个集合的不同的元素作为新集合，等价于'-'运算
s1,s2={1,2,3,4},{1,2,5,6}
s3=s1.difference(s2)
s4=s1-s2	#等价于difference()
print(s3)	#{3, 4}
print(s4)	#{3, 4}

#intersection()	返回两个集合的交集作为新集合,等价于'&'运算
s1,s2={1,2,3,4},{1,2,5,6}
s3=s1.intersection(s2)
s4=s1 & s2
print(s3)	#{1, 2}
print(s4)	#{1, 2}

#union()	将集合的并集作为新集合返回，等价于'|'运算
s1,s2={1,2,3,4},{1,2,5,6}
s3=s1.union(s2)
s4=s1 | s2
print(s3)	#{1, 2, 3, 4, 5, 6}
print(s4)	#{1, 2, 3, 4, 5, 6}

#异或运算^
s1,s2={1,2,3,4},{1,2,5,6}
s3=s1 ^ s2
print(s3)	#{3, 4, 5, 6}

希望更新一个集合使用update()方法，作用是用集合自身和其他集合或可迭代对象的并集更新集合

s1={1,2,3,4}
s2={'jack','bob','jocab'}
s1.update(s2)
print(s1)	#{1, 2, 3, 4, 'jack', 'jocab', 'bob'}

其它操作方法：

#difference_update()	从此集合中删除另一个集合的所有元素
s1,s2={1,2,3,4},{1,2,5,6}
s1.difference_update(s2)
print(s1)	#{3, 4}

#intersection_update()	用一个集合自身和另一个集合的交集来更新集合
s1,s2={1,2,3,4},{1,2,5,6}
s1.intersection_update(s2)
print(s1)	#{1, 2}

#isdisjoint()	如果两个集合有空交集，则返回True
s1,s2={1,2,3},{100,200}
print(s1.isdisjoint(s2))	#True

#issubset()	报告其他集是否包含此集
s1,s2={1,2},{1,2,3,4}
print(s1.issubset(s2))	#True
print(s2.issubset(s1))	#False

#issuperset()	报告此集合是否包含其他集合
s1,s2={1,2,3,4,5},{1,2,3,4}
print(s1.issuperset(s2))	#True
6、JSON和内置函数eval()
  • eval()能够把符合Python语法的内容当做代码来执行，尤其是对字符串。
a='1+5'	#a是字符串
print(eval(a))	#6

  • JSON是一种轻量级的数据交换格式

    JSON介绍

​ JSON本质是一个字符串，在实际开发过程中，在前台—服务器—数据库之间可能会用到不同的语言来做开发，就会涉及到不同语言间进行信息交换的问题。由于任何语言都有字符串类型的数据，都能够识别字符串，因此，就通过将各种不同的信息全部转换为JSON字符串来进行传递，JSON字符串能够自动编码成所有语言都能识别的信息。

​ 在Python中JSON的作用就是把列表、元组、字典、布尔值转换为JSON字符串，使用JSON字符串前要先调用JSON模块。

import json
person={'name':'jack','age':28,'gender':'male'}

#调用json模块的dumps方法可以把数据转换为json字符串
m=json.dumps(person)	#dump方法实现转换

print(m)	#{"name": "jack", "age": 28, "gender": "male"}
#注意，m看起来像是一个字典，但并不是一个字典，它是一个json字符串。json字符串里必须使用双引号来表示字符串，数字可以不用
print(type(m))	#<class 'str'>

n='{"name": "jack", "age": 28, "gender": "male"}'	#json字符串的初始化方式，在最外侧用单引号

#用json模块的loads方法可以把json字符串转换为对应的原始数据
s=json.loads(n)
print(s)	#{'name': 'jack', 'age': 28, 'gender': 'male'}
print(type(s))	#<class 'dict'>

​ 不同的数据转换成JSON字符串实际上在JSON中有不同的称呼，对照如下：

PythonJSON
字符串字符串
数字数字
布尔值（True、False）布尔值（true、false）
字典对象
列表、元组数组
import json

print(json.dumps(['ok','good',100,True]))
#["ok", "good", 100, true]     <class 'str'> 把一个列表转换为json字符串
print(json.dumps(('beauty','fine',200,False)))
#["beauty", "fine", 200, false]   把一个元组转为json字符串

#注意，如果使用loads方法把JSON中的数组转换为原始数据，只能得到一个列表
7、公共方法总结
  • 在Python中，一些算数运算符有限的支持可迭代对象的运算，见下表：
运算符Python表达式结果描述支持的数据类型
+[1,2]+[3,4][1,2,3,4]合并列表、字符串、元组
-{1,2,3,4}-{3,4}{1,2}集合求差集集合
*[‘haha’]*3[‘haha’,‘haha’,‘haha’]重复字符串、列表、元组
in3 in (1,2,3)True元素是否存在字符串、列表、元组、字典、集合
not in4 not in [1,2,3]True元素是否不存在字符串、元组、列表、字典、集合

  • 带下标的遍历操作

    利用内置的enumerate()类来同时获取一个可迭代对象的下标和内容，一般用于列表和元组。

nums=[23,45,54,56,32,67,86,36]
for i in enumerate(nums):
    print(i)	
#(0, 23)
#(1, 45)
#(2, 54)
#(3, 56)
#(4, 32)
#(5, 67)
#(6, 86)
#(7, 36)

for i,k in enumerate(nums):
    print(i,k)
#0 23
#1 45
#2 54
#3 56
#4 32
#5 67
#6 86
#7 36
LC_Python
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值