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] = 100

print(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))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('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_yu

print('...'.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 Python

print(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))  # set

s5 = {}
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