Python学习笔记Ⅲ —— 字符串、列表 、字典 、元组 、集合

本节内容：1.字符串常见操作 2.列表 3.字典 4.元组 5.集合

1.字符串的常见操作

1.1 获取字符串的数据

上一节已经学习了如何使用字符串的下标，那么我们现在可以利用下标和字符串的一些方法实现一些操作。

my_str = 'hello world'
# 1.获取字符串中指定数据的下标

#index和rindex
print(my_str.index('l'))     #index：按照字符串从左到右的顺序寻找指定字符'l',并返回找到的第一个'l'的下标
print(my_str.rindex('l'))    #index：按照字符串从右到左的顺序寻找指定字符'l',并返回找到的第一个'l'的下标
#print(my_str.index('a'))     #当index在字符串中找不到指定数据时，将会报错

#find和rfind，与index、rindex用法几乎一样，区别在于当find找不到指定内容时会返回-1而不是报错。
print(my_str.find('l'))
print(my_str.rfind('l'))
print(my_str.find('a')) 

# 2.字符串的“修改”-----------字符串为不可变类型，故所有操作都只是生成了一个新的数据（字符串、列表等）
print(my_str.count('l'))     #count用来查找字符串中指定内容的数量  

my_str2 = my_str.replace('l','x',1)   #replace中第三个参数即替换的个数，入如果不传参数默认全部替换
print(my_str,my_str2)                 #replace并不能修改my_str，而是生成了一个新的字符串，所以my_str中的数据没有发生改变


print(my_str.split(' '),my_str)       #split将以指定的内容，将字符串分割后返回存储在列表中返回,同样的my_str不会改变
print(my_str.partition(' '))          #partition与split的区别：partition将指定内容作为分割后的列表元素存储，而split不保存指定内容
print(my_str.splitlines())			  #splitlines：以换行符\n进行分割

print(my_str.capitalize())			  #capitalize:字符串首字母大写
print(my_str.title())				  #title:字符串中所有单词首字母大写
print(my_str.upper())				  #upper:字符串所有字母转大写
print(my_str.lower())				  #lower:字符串所有字母转小写

#3.判断字符串内容------------提到判断，输出的一般都为布尔值 True or Flase
print(my_str.isalpha())				  #判断字符串是否由纯字母组成
print(my_str.isdigit())				  #判断字符串是否由纯数字组成
print(my_str.isalnum())				  #判断字符串是否由字母和数字共同组成

1.2字符串的遍历与枚举

字符串的遍历使用for循环即可实现，但如果想同时获取下标就要用到enumerate进行枚举。

my_str = 'hello world'

# 1.遍历字符串
str_list1 = [value for value in my_str]
print(str_list)

# 2.枚举字符串
str_list2 = [(index,value) for index,value in enumerate(my_str)]
print(str_list2)

1.3字符串的拼接

我们经常要用将几个字符串连起来使用或输出，最常用的三种方式为：1.使用 + 拼接；2.使用格式化输出进行拼接；3.使用{}占位符拼接

my_str1 = 'hello'
my_str2 = 'world'

# 1.使用 + 拼接
result = my_str1 + my_str2
print(result)

# 2.使用格式化输出进行拼接
result = '%s'%(my_str1+my_str2)
print(result)

# 3.使用占位符进行拼接
result = '{}{}'.format(my_str1,my_str2)
print(result)

2.列表

2.1列表的增删改查

my_list1 = [1,'a']
my_list2 = [2,'b']
# 1.增
my_list1.append('c')
print(my_list1)				#append方法可以为列表添加最后一位元素
my_list1.insert(0,2)
print(my_list1)				#insert方法可在列表指定下标处添加元素，垓下标以后的元素右移，即下标加1
my_list1.extend(my_list2)
print(my_list1)				#extend方法可将my_list2的元素添加至my_list1中

#注意：append、+ 也可连接两个列表，但三种方式是有区别的
my_list1.append(my_list2)	#如果此处使用append方法，会将my_list2作为一个list类型的元素添加至my_list1中
my_list3 = my_list1 + my_list2 		#使用 + 与extend方法的区别：使用 + 生成一个新的列表，但不会改变原列表；使用extend是将my_list2中的元素添加至my_list1中
print(my_list1,my_list3)

# 2.删
my_list1.remove('a')		#使用remove方法可删除指定数据
print(my_list1)
del my_list1[0]				#del可根据列表下标删除列表中的元素
print(my_list1)
result = my_list1.pop()		
result = my_list1.pop(0)	#使用pop方法默认删除列表中最后一个元素，也可传参数下标删除指定下标元素，同时将删除的元素返回，此处使用result接收

# 3.改
my_list1[0]	= 'c'			#修改列表中的元素，直接使用下标然后重新赋值即可
num = my_list1.index('c')	#index可查列表中元素的下标
print(my_list1,num)
# 4.查
if 'c' in my_list1:
	print('my_list1中包含元素c')
if 'x' not in my_list1:
	print('my_list1中没有元素c')     #可使用if in、not in来判断列表中是否包含某元素，然后结合index查找下标
print(my_list1.count('c'))         #conut方法可以查找列表转某元素的个数

输出结果如下：

2.2 遍历列表

说到遍历，自然是使用for循环来完成；也可像字符串枚举那样获取列表元素的下标。

my_list = [1,'a',[1,'a']]

# 1.遍历
print('='*10 + '遍历' + '='*10)
for value in my_list:
    print(value)

# 2.枚举
print('='*10 + '枚举' + '='*10)
for index,value in enumerate(my_list):
    print(index,value)

运行结果：

2.3 列表的切片

列表的切片方法和字符串完全一致，即使用格式：my_list[开始下标:结束下标:步长] 来进行切片

3.字典

3.1 字典的形式及注意点

字典的形式：{'键':'值'}，即以花括号包裹的键值对组成的数据类型。

注意：1.键，key必须为不可变类型数据 2.同一个字典中的key不得重复 3.字典中的数据无序存储，故不可使用下标

3.2 字典的常见操作

import sys
my_dict = {'name':'mm','age':18}
# 1.取值
value = my_dict['name']
print(value)			#使用key取值，但是若使用的key不在字典中程序将会报错
value = my_dict.get('name')
value_none = my_dict.get('sex')
print(value,value_none)		#使用get取值，如果key不在字典中，将会返回None而不是报错

# 2.增
my_dict['sex'] = ['women']		#直接使用赋值形式即可为字典添加键值对
my_dict.setdefault('universite')
my_dict.setdefault('address','Beijing')		
print(my_dict)					#setdefault方法也可为字典添加键值对，若果只有key，那么默认值为None

# 3.删
del my_dict['universite']		#使用del可依据字典中的key进行删除
print(my_dict)
value = my_dict.popitem()		#popitem方法为随机删除字典中的键值对，并将删除结果返回
print(value,my_dict)
value = my_dict.pop('sex')		#pop方法可也可按照字典中的key进行删除，并将删除内容返回
print(value,my_dict)
#注意:popitem方法将键、值包装在一个元组中返回，而pop方法仅返回值，字符串类型

# 4.改
my_dict['name'] = 'ls'			#使用赋值形式即可为字典已有key修改值

# 5.查
#如果直接使用字典，默认使用所有key；所有key可用my_dict.keys获取，所有值可用my_dict.values获取
print(my_dict)
if 'age' in my_dict:
	print('my_dict中的键包含age')
if 'age' in my_dict.keys():
	print('my_dict中的键中包含age')
if 18 in my_dict.values():
	print('my_dict的值中包含18')

# 6.遍历字典，同样的如果直接使用my_dict遍历，默认遍历my_dict中的所有key，若要同时遍历key和value使用my_dict.items()
for index in my_dict:
	print(index)
for key,value in my_dict.items():
	print(key,value)

4.元组

元组与列表非常相似，主要区别：1.列表使用[]包裹，而元组使用()包裹； 2.元组为不可变数据类型，不支持修改，一般用于存储不希望被改动数据； 3.所有用于列表的操作除了修改以外，基本都适用于元组，例如下标、index、count元组都是可以使用的。

注意：1.元组虽然不可修改，但元组中的可变类型元素是可以修改的； 2.如果要创建一个仅有一个元素的元组，需要在该元素后加逗号，否则创建的变量类型与该元素类型一致而不是一个元组； 3.创建一个空元组却不需要加逗号。

my_tuple = (1,'a',[1,'a'])
print(my_tuple)
# 1.修改元组中的可变类型元素
my_list = my_tuple[2]
my_list.append(2)
print(my_tuple)

# 2.创建一个单元素元组和空元组
my_tuple1 = (1)
my_tuple2 = (1,)
my_tuple3 = ()
print(type(my_tuple1),type(my_tuple2),type(my_tuple3))

运行结果：

5.集合

集合与字典的形式一样，都是由{}包裹的数据类型，但是集合中的数据不需键值对。且具有以下几个特点：

1.集合中的数据无序排列，故不可使用下标

2.集合中无重复数据，可用来去重

3.集合中的元素必须是不可变类型，list等可变类型数据无法加入集合

4.建立一个非空集合可直接使用{}，但建立一个空集合必须使用set{}

利用集合无重复数据的特点进行数据去重：

#利用集合的特点进行数据去重
list1 = ['a','abc',1,(1,'a')]
list2 = [34,'abc',1,True]
list1.extend(list2)
list3 = list(set(list1))
print("列表1为:{}\n列表2为：{}\n不相同的元素为：{}".format(list1,list2,list3))

结果：