Python——序列与字符串

序列与字符串

一. 列表

列表是Python的内置可变序列，是包含若干元素的有序连续内存空间。同一列表元素的数据类型可以各不相同，可以分别为整数、实数、字符串等基本类型，也可以是列表、元组、字典、集合以及其他自定义对象。

[数据1, 数据2, 数据3, 数据4......]li = [1,1.5,'hello',True]#创建列表li
print(li)#打印列表
print(type(li))#查看li的类型是否为列表


1. 列表的创建

# 两种创建空列表方式
li = [] # 最常用
print(li,type(li)) # [] <class 'list'>l = list() # 一般作为转化
print(l,type(l)) # [] <class 'list'>

list()可转换其他类型的为列表

2. 列表元素的访问

“下标”又叫“索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。

name_list = ['Tom', 'Lily', 'Rose']print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose


3. 列表元素的判断

count：可使用count方法对其中元素进行计数

x=[1,2,1,2,1,2,1,1,1]
i=x.count(1)
print(i)
#
如过存在则返回元素个数大于0，否则为0
a=x.count(3)
print(i)


in：判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']# 结果：True
print('Lily' in name_list)# 结果：False
print('Lilys' in name_list)


not in： 判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']# 结果：False
print('Lily' not in name_list)# 结果：True
print('Lilys' not in name_list)

4. 列表元素的增加

作用：增加指定数据到列表中。

（1）使用+运算符和*运算符

name_list = ['Tom', 'Lily', 'Rose']
name_list=['Tom', 'Lily', 'Rose']+['Cidy']name_list = ['Tom', 'Lily', 'Rose']*3
x=[['hello']*4]*3
#可将所有元素复制3


（2）append

name_list = ['Tom', 'Lily', 'Rose']name_list.append('xiaoming')# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)


注意 : 如果append()追加的数据是一个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose']name_list.append(['xiaoming', 'xiaohong'])# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)


（3）extend()
注意 : 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表

name_list = ['Tom', 'Lily', 'Rose']name_list.extend('xiaoming')# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)# 序列数据name_list = ['Tom', 'Lily', 'Rose']name_list.extend(['xiaoming', 'xiaohong'])# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)


（4）insert() 指定位置新增数据。

name_list = ['Tom', 'Lily', 'Rose']name_list.insert(1, 'xiaoming')# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)


5. 列表元素的删除

使用del命令来删除，直接删除整个列表

name_list = ['Tom', 'Lily', 'Rose']# 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)# 删除指定数据
name_list = ['Tom', 'Lily', 'Rose']del name_list[0]# 结果：['Lily', 'Rose']
print(name_list)


pop(索引) 默认为最后一个

name_list = ['Tom', 'Lily', 'Rose']del_name = name_list.pop(1) # 不写默认删除最后面的元素 # 结果：Lily
print(del_name)# 结果：['Tom', 'Rose']
print(name_list)


remove() 注意 移除的是数据元素，删除的首次出现的指定元素

name_list = ['Tom', 'Lily', 'Rose']name_list.remove('Rose')# 结果：['Tom', 'Lily']
print(name_list)


如果需要删除列表中指定元素的所有重复

x=[1,2,1,2,1,2,1,1,1]
for i in x
if i==1:
x=remove(i)
#但上述代码有问题
x=[1,2,1,2,1,2,1,1,1]
for i in x[::]
if i==1:
x=remove(i)
或者
x=[1,2,1,2,1,2,1,1,1]
for i in x[::-1]
if i==1:
x=remove(i)


clear清空所有元素

name_list = ['Tom', 'Lily', 'Rose']name_list.clear()
print(name_list) # 结果： []


6. 其他操作

6.1 修改操作

# 重要
name_list = ['Tom', 'Lily', 'Rose']name_list[0] = 'aaa'# 结果：['aaa', 'Lily', 'Rose']
print(name_list)# reverse 倒置
num_list = [1, 5, 2, 3, 6, 8]num_list.reverse()# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)# sort 排序
num_list = [1, 5, 2, 3, 6, 8]num_list.sort()
num_list.sort(reverse= True) # 倒序
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

6.2 列表循环遍历

依次打印列表中的各个数据。

name_list = ['Tom', 'Lily', 'Rose']for i in name_list:
print(i) # 如果for循环要遍历的序列是空的，那么就会立刻执行else块：
for i in []:
print("Never Runs")
else:
print("Else Block!")# Else Block! # eg :name_list = ['Tom', 'Lily', 'Rose']name = input('请输入您要搜索的名字：')if name in name_list:
print(f'您输入的名字是{name}, 名字已经存在')
else:
print(f'您输入的名字是{name}, 名字不存在')


6.3 列表嵌套

所谓列表嵌套指的就是一个列表里面包含了其他的子列表。

应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]


如何找到"李四"?

# 第一步：按下标查找到李四所在的列表
print(name_list[2])# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])


7. 切片

是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作

序列[开始位置下标:结束位置下标:步长]
1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步长是选取间隔，正负整数均可，默认步长为1。name = ['Tom', 'Lily', 'Rose','james','durant','KG','wade','melo']print(name[:5]) # ['Tom', 'Lily', 'Rose', 'james', 'durant']
print(name[1:]) # ['Lily', 'Rose', 'james', 'durant', 'KG', 'wade', 'melo']
print(name[:]) # ['Tom', 'Lily', 'Rose', 'james', 'durant', 'KG', 'wade', 'melo']
print(name[::2]) # ['Tom', 'Rose', 'durant', 'wade']
print(name[:-1]) # ['Tom', 'Lily', 'Rose', 'james', 'durant', 'KG', 'wade']
print(name[-4:-1]) # ['durant', 'KG', 'wade']
print(name[-4:-1:-1]) # [] 特别注意 !
print(name[-3:]) # ['KG', 'wade', 'melo']
print(name[::-1]) # ['melo', 'wade', 'KG', 'durant', 'james', 'Rose', 'Lily', 'Tom']
print(name[2:5:1]) # ['Rose', 'james', 'durant']
print(name[2:5]) # ['Rose', 'james', 'durant']

count() 统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']print(name_list.count('Lily')) # 1


len() 访问列表长度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']print(len(name_list)) # 3


8. 列表推导式

列表推导式是python用的比较多的技术之一，以非常简洁的方式来快速生成满足特定需求的列表

alist=[x*x for x in range(10)]
相当于
alist=[]
for x in range(10):
alist.append(x*x)

嵌套列表的平铺

vec=[[1,2,2],[4,5,6],[7,8,9]]
[num for elem in vec for num in elem]
[1,2,3,4,5,6,7,8,9]


过滤元素

alist=[-1,-4,6,7.5,-2.3,8,-11]
[i for i in a list if i>0]


二 字典

1. 引入

思考1： 如果有多个数据，例如：‘Tom’, ‘男’, 20，如何快速存储？

list1 = ['Tom', '男', 20]


思考2：如何查找到数据’Tom’？

答：查找到下标为0的数据即可。

思考3：如果将来数据顺序发生变化，如下所示，还能用list1[0]访问到数据’Tom’吗？。

list1 = ['男', 20, 'Tom']


答：不能，数据’Tom’此时下标为2。

思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一的标准查找数据呢？

答：字典，字典里面的数据是以"键值对"形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

2. 字典的特点

字典特点：

• 符号为大括号
• 数据为键值对形式出现
• 各个键值对之间用逗号隔开
• 字典没有索引(下标)的概念!!!

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}# 创建空字典的方式
dict2 = {} #最常用 dict3 = dict()


注意：一般称冒号前面的为键(key)；冒号后面的为值(value)，

3. 字典的创建与删除

（1）如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1['id'] = 110# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)


（2）使用内置函数**dict()**将已有数据快速创建元组

keys=['a','b','c','d']
values=[1,2,3,4]
dictionary=dic(zip(keys,values))
#zip()函数将对应位置的函数转换为元组


4. 字典元素的删除

del 删除字典或删除字典中指定键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)


clear : 清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1.clear()
print(dict1) # {}


5. 字典元素的修改

指定键为下标的字典元素赋值时，若改元素存在则修改改键对应的值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)


可使用字典对象 updata() 将另一个字典的“键-值对”一次性全部添加到当前的字典对象，若有相同的键，则对目前的键值进行更新

adict={'age':37,'score':[98,97],'name':'Dong','sex':'male'}
adict.items()
[('age',37),('scor,[98,97]),('name','Dong'),('sex','male')]
alict.updata({'a','b','b':'b','age':18})
adict.items(),b
[('age'18),('scor,[98,97]),('name','Dong'),('sex','male'),('a','a'),('b','b')]


6. 字典元素的查找与遍历

直接查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错


get()方法

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None


遍历字典的key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)


遍历字典的values

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)


遍历字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)


三 元组

思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？

答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。

num_list = [10, 20, 30]
num_list[0] = 100print(num_list)tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa' # 直接报错 print(tuple1)


1. 元组的定义

一个元组可以存储多个数据，元组内的数据是不能修改的，但元组内的元素如果有列表，那么可以修改列表的值

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组
t1 = (10, 20, 30)# 单个数据元组
t2 = (10,)# 创建空元组
tup1 = ()

注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

t2 = (10,)
print(type(t2)) # tuplet3 = (20)
print(type(t3)) # intt4 = ('hello')
print(type(t4)) # str


2. 元组的常见操作

元组数据不支持修改，只支持查找，具体如下：

# 元组也支持索引取值
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa

3. 序列解包

x,y,z=1,2,3
x,y,z
(1,2,3)
print(x,y,z)
1,2,3#对字典和列表操作
a=[1,2,3]
b,c,d=a
s={'a':1,'b':2,'c':3}
b,c,d=s.items()
print(b)#('c',3)
b,c,d=s
print(b)#'c'
b,c,d=s.vlues()
print(b,c,d)#1 3 2


四 字符串

1. 数据类型

• int
• bool
• str
• float
• list(列表)
• dict(字典)
• tuple(元组)
• set(集合)

2. str(字符串)

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可

a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))


注意：控制台显示结果为<class 'str'>， 即数据类型为str(字符串)。

3. 字符串特征

• 单引号

• 双引号

• 三引号

  name1 = 'Tom'
name2 = "Rose"
a = ''' i am Tom,
nice to meet you! '''

4. 字符串输出

print('hello world')name = 'Tom'
print('我的名字是%s' % name)
print('我的名字是{}'.format(name))
print(f'我的名字是{name}')


4.1 下标

“下标”又叫“索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。

需求：字符串name = "abcdef"，取到不同下标对应的数据。

name = "abcdef"print(name[1])
print(name[0])
print(name[2])


4.2 切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作.

name = "abcdefg"print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第一个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba
print(name[2:5:1]) # cde
print(name[2:5]) # cde


5. 常用方法

count

# 字符串序列.count(子串, 开始位置下标, 结束位置下标)
mystr = "hello world and dapeng and xiaopeng and Python"print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1

replace

注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

# 字符串序列.replace(旧子串, 新子串, 替换次数)
mystr = "hello world and dapeng and xiaopeng and Python"new_mystr = mystr.replace('and', 'he')
print(new_mystr)
# 结果：hello world he dapeng he xiaopeng he Python
print(mystr.replace('and', 'he', 1)) # 10替换的次数

特别注意 : replace方法不能直接修改数据

split

# 字符串序列.split(分割字符, num) num是分割的次数
mystr = "hello world and dapeng and xiaopeng and Python"print(mystr.split('and')) # ['hello world ', ' dapeng ', ' xiaopeng ', ' Python']
print(mystr.split('and', 1)) # ['hello world ', ' dapeng ', ' xiaopeng and Python ']
print(mystr.split(' ')) # ['hello', 'world', 'and', 'dapeng', 'and', 'xiaopeng', 'and', 'Python']

join

#字符或子串.join(多字符串组成的序列)
list1 = ['da', 'peng', 'jiaoyu', 'yu']
t1 = ('aa', 'b', 'cc', 'ddd')print('_'.join(list1)) # 结果：da_peng_jiaoyu_yuprint('...'.join(t1)) # 结果：aa...b...cc...ddd

strip

mystr = " hello world and dapeng and xiaopeng and Python "print(mystr.strip()) # hello world and dapeng and xiaopeng and Pythonprint(mystr)mystr = "******hello world and****** dapeng and xiaopeng and Python "print(mystr.strip('*')) # 特别注意: 只能去掉两边的 ,中间不能

find

Python find() 方法检测字符串中是否包含子字符串 str,则检查是否包含在指定范围内，如果包含子字符串返回**开始的索引值，**否则返回-1。

str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.find(str2))
print(str1.find(str2, 13)) # 13 是开始索引
print(str1.find(str2, 16))

五 集合

集合是无序可变集合，与字典一样使用大花括号作为界定符，同一个集合的元素不允许重复，是唯一的

创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。

s1 = {10, 20, 30, 40, 50}
print(s1)s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2) # 去重成{40, 10, 50, 20, 30}s3 = set('abcdefg')
print(s3) #{'d', 'f', 'c', 'g', 'a', 'b', 'e'}s4 = set()
print(type(s4)) # sets5 = {}
print(type(s5)) # dict


特点：

1. 集合可以去掉重复数据
2. 集合数据是无序的，故不支持下标

六 公共操作

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

+

# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)


---

# 1. 字符串
print('-' * 10) # ----------# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')


in 或 not in

# 1. 字符串
print('a' in 'abcd') # True
print('a' not in 'abcd') # False# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # False# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True