04.Python序列对象（字符串、元组、列表的常用方法列表总结+大量代码示例）

12.19 Python 序列对象

字符串 str

概述：内容元素不可变，元素有序（索引，下标，左从 0 开始，右从1开始），常用方法有切片、查找、修改和判断等，

str 切片

概述：str_name[ strart_index : stop_index : step_size ]， 最简 str_name[ strart_index ]，如果结果需要在下文中使用，需要设置一个新的 str 对象接收切片的返回值，以下是常用用法。

name = "0123456"
print(name[2:5:1])      # 234，正数时0开始包前不包后
print(name[2:5])        # 234, 步长省略默认为 1
print(name[:5])         # 01234, 开始留空默认最小，即开头
print(name[1:])         # 123456, 结束留空默认最大，即结尾
print(name[:])          # 0123456
print(name[::2])        # 0246, 0开始，每+2个步长一截
print(name[:-1])        # 012345, 负1表示倒数第⼀一个数据
print(name[-4:-1])      # 345, 负的倒数时从-1开始包前不包后
print(name[::-1])       # 6543210, 反转

str 查找

概述：查找某个子字符串（括号中的）在原字符串中的位置或出现的次数，返回值 int 类型。

方法格式	功能描述
str.find(target, start, stop)	字符串 str 中是否包含 target，不包含返回 -1，包含返回索引下标
str.index(target, start, stop)	获取 target 在 str 中的起始下标，不存在则报错
str.count(target, start, stop)	统计 target 在 str 中出现的次数

PS：1、还有“rfind”、“rindex”方法，与“find”、“index”的区别是从右侧开始，右侧下标从1开始。

2、终止位置 stop 可以单独省略，或与起始位置 start，一起省略，起始位置 start 不能单独省略。

3、当不确定时不要用 index 而用 find，否则影响程序后续运行。

demo_str="0123454321"
print(demo_str.find("23"))              # 2，起始索引
print(demo_str.find("22",2))        	# -1，不存在
print(demo_str.rindex("12"))			# 1，按先后顺序匹配，右侧查找“12”相当于左侧查找"21"
print(demo_str.rindex("12",2,10))       # 报错
print(demo_str.count("1",0,5))         	# 1

str 修改

概述：对字符串内容进行修改，因为字符串不可变，因此修改动作不会改变原来字符串 str 的内容，如果修改过的结果需要在下文中使用，需要设置一个新的 str 对象接收切片的返回值，以下是常用用法。

方法格式	功能描述
str.replace(old, new, num)	将 str 中的 old 字符替换为 new 字符，num 为替换的次数
str.split(chars, num)	将 str 按照分割字符进行切分，num 为替换的次数
str.ljust(length, chars)	长度 length 左对齐， chars 填充，默认空格，右对齐 rjust( )、中心 center( )
chars.join( E )	以 chars 为连接符对 E 内元素连接，E 可迭代，如字符串、元组、列表等
str.lstrip( chars )	删除左侧字符串，默认消空白字符，删除右侧用 str.rstrip( )
str.capitalize( )	字符串第⼀个字符转换成大写
str.title( )	将字符串每个单词首字母转换成大写（英文标题形式）
str.lower( )	将字符串全部字母转为小写，转大写用 str.upper( )

string1 = "Hello World"
new_string1 = string1.replace("World", "Python") 
print(string1) 			# 删除 "Hello World"
print(new_string1)  	# 输出 "Hello Python"

string2 = "apple apple apple"
new_string2 = string2.replace("apple", "orange", 2)
print(new_string2)  	# 输出 "orange orange apple"

string3 = "Hello,World,Python"
print(string3.split(","))  		# 输出 ["Hello", "World", "Python"]
print(string3.split(" ", 1))  	# 输出 ["Hello", "World", "Python"]

string4 = "Hello"
new_string4 = string4.ljust(10, "-")
print(new_string4)  # 输出 "Hello-----"

my_tuple = ('Hello', 'World', 'Python')
joined_string = ' '.join(my_tuple)
print(joined_string)  # 输出 "Hello World Python"

string5 = "lheeheehelhelloaebtc"
print(string5.lstrip('hel1'))  	# 输出 "oaebtc"
string6 = "hello"
print(string6.lstrip('h'))  	# 输出 "ello"
string7 = "hello---------"
print(string7.rstrip('-'))  	# 输出 "hello"

str 判断

概述：返回的结果是布尔型数据类型，True 或 False。

方法格式	功能描述
str.startswith(target, start, stop)	字符串 str 是否以 字符串 target 开头，可设置起止下标
str.endswith(target, start, stop)	字符串 str 是否以 字符串 target 结尾，可设置起止下标
str.isalpha( )	字符串是否全由字母组成，且至少包含一个字符
str.isdigit( )	字符串是否全由数字组成，且至少包含一个字符
str.isalnum( )	字符串是否全由字母和数字组成，且至少包含一个字符
str.isspace( )	是否全由空白字符（如空格、换行符等）组成，至少包含一个

string1 = "Hello, World!"
print(string1.startswith("Hello"))  			# 输出 True  
print(string1.startswith("World", 7))  		# 输出 True, 只有一个下标时为起始下标
print(string1.startswith("Hello", 0, 5))  	# 输出 False
print(string1.endswith("!"))  				# 输出 True  
print(string1.endswith("World", 0, 12))  	# 输出 False  
print(string1.endswith("World!", 0, 13))  	# 输出 True

string2 = "Hello" 
print(string2.isalpha())  					# 输出 True  
string3 = "Hello123" 
print(string3.isalpha())  					# 输出 False

string4 = " "
print(string4.isspace())  # 输出 True
string5 = "Hello World"
print(string5.isspace())  # 输出 False

str 前缀

概述：前缀指的是字符串在定义赋值时，加在引号前边的小写字母。

符号	功能描述
r	表示原始字符串（raw string），反斜杠不进行转义
b	表示字节字符串（bytes string），用于处理二进制数据
u	表示Unicode字符串，在Python 2中使用，3.x中默认
f	表示格式化字符串，即传参，3.6版本启用。

raw_string = r'This is a raw string \n'  	# 反斜杠不进行转义
print(raw_string)
binary_data = b'\x41\x42\x43'  				# 字节字符串
print(binary_data)							# 默认打印对应的 ASCII 字符
unicode_string = u'Hello, World!'  			# Unicode字符串（仅在Python 2中需要）
print(unicode_string)
name = 'Alice'
age = 25
message = f'My name is {name} and I am {age} years old.'  	# 格式化字符串
print(message)

元组 uple

概述：内容不可变，适用于需要存储多个值且这些值不可更改的情况。元组使用⼩括号“( )”进行定义，用逗号“,”隔开各个数据，数据可以是不同的数据类型。元组数据不可变，只支持查找，用法与 str 类似。

tuple 查找

概述：常用的 tuple 查找方法有根据下标查找元素、查找某元素下标、统计元素在元祖中出现的次数、统计元组中数据的个数，返回值为 int 类型，语法格式如下。

语法形式	功能描述
tuple[ index ]	查找元组 index 下标处的元素，下标从0开始
tuple.index( e, start, stop )	查找元素 e 在元组中的位置下标，起止坐标为可选项
tuple.count( e )	查找元素 e 在元组中出现的次数（e 在元组中的个数）
len( tuple )	查找元组的元素个数，即长度

PS：元组本身不可修改，但是元组中的元素取出后，可以根据元素本身的特性方法进行操作，但不会改变元组的内容。

my_tuple = ('apple', 'pear', ['banana', 'orange'], 'grape', 'apple', 'pear', 'apple')

print(my_tuple[0])  						# 输出 "apple"
print(my_tuple.index('apple'))  			# 输出 0
print(my_tuple.index('apple',1))  			# 输出 4
print(my_tuple.index('apple',5,6))  		# 包前不包后，报错
print(my_tuple.count('apple'),my_tuple.count('pear'))		# 输出 3 2
print(len(my_tuple))						# 输出 7

列表 list

概述：作用是一次性存储多个数据，是可变的有序序列，用方括号 [ ] 表示，元素逗号“,”隔开。列表中的元素可以是任意类型，并且可以通过索引访问。列表除了支持查询外，还支持动态添加、删除和修改元素。

list 查询

方法格式	功能描述
list[ index ]	查询并返回集合对应 index 索引处元素
list.index( E, start, stop)	返回指定数据 E 所在位置的下标，起止索引可选
list.count( E )	统计指定数据 E 在当前列列表中出现的次数
len( list )	获取列表长度，即列表中元素的个数
E in list / E not in list	判断元素 E 是否在 list 集合内，返回值布尔型

my_list = [1, 2, 3, 2, 4, 2]
print(my_list[2]) 					# 输出 3
print(my_list.index(2))  			# 输出 1
print(my_list.index(2, 2))  		# 输出 3，单索引省略，省略的是结束索引
print(my_list.count(2))  			# 输出 3
print(my_list)						# 输出 6
print(3 in my_list)  				# 输出 True
print(6 not in my_list)  			# 输出 True

list 增删

概述：集合list的增添方法和除了“list.pop( index )”的删除方法外，均无返回值，只是在原来集合上进行的逻辑动作，不产生新的变量对象。

方法格式	功能描述
list.append( E )	将 E 整体作为一个元素追加到 list 末尾
list.extend( E )	将 E 中的每个元素逐个添加 list
list.insert( index, E )	指定 index 处新增数据 E，原位置元素后移
del list	从内存中删除整个列表
del list[ index ]	从内存中删除列表中指定 index 索引处的元素
list.pop( index )	将对于下标元素从集合中取出，有返回值
list.remove( E )	移除列表中第一个出现的 E
list.clear( )	清空列表

PS：删除或移除元素之前，先判断元素是否存在于列表中，或者索引长度，确保索引不越界，避免出现异常影响后续代码的运行。

demo_list1 = [0, 1, 2, 3, 4, 5, 6]
demo_list2 = ['a', 'b', 'c', (8, 9)]
demo_list1.append(demo_list2)       # 这只是一个执行方法的动作，无返回值产生，不能打印
print(demo_list1)                   # 结果：[0, 1, 2, 3, 4, 5, 6, ['a', 'b', 'c', (8, 9)]]
demo_list1.extend(demo_list2)
print(demo_list1)                   # 结果：[0, 1, 2, 3, 4, 5, 6, ['a', 'b', 'c', (8, 9)], 'a', 'b', 'c', (8, 9)]
demo_list1.clear()
print(demo_list1)                   # 结果 []
del demo_list1
# print(demo_list1)                   # 报错：NameError: name 'demo_list1' is not defined

demo_list2.insert(3, '01')
print(demo_list2)                       # 输出 ['a', 'b', 'c', '01', (8, 9)]
print(demo_list2.pop(4),demo_list2)     # 输出 (8, 9) ['a', 'b', 'c', '01']
demo_list2.insert(3,"b")
print(demo_list2)                       # 输出 ['a', 'b', 'c', 'b', '01']
demo_list2.remove('b')
print(demo_list2)                       # 输出 ['a', 'c', 'b', '01']

list 修改

方法格式	功能描述
list[ index ] = E	通过重新赋值的方式对 list 指定索引处元素进行修改
list.reverse( )	将集合内元素进行逆置反转
list.sort( key=None, reverse=False)	重新排序，key，reverse 可省略，默认 reverse=True 升序
list.copy( )	对集合进行复制，返回值也是集合

my_list = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list)              # 输出 [1, 2, 10, 4, 5]
my_list.reverse()
print(my_list)              # 输出 [5, 4, 10, 2, 1]
copy_list=my_list.copy()
print(copy_list)            # 输出 [5, 4, 10, 2, 1]

def get_second_element(element): 
    return element[1]
nested_list = [(1, 5), (2, 3), (4, 1), (6, 6), (3, 7), (2, 5)].
nested_list.sort(key=get_second_element)				# 函数体放在前
print(nested_list)

len_list = ['13', '112', '53', '62', '1454', '2']		# 数值类型无长度len
len_list.sort(key=len, reverse=False)
print(len_list)             # 输出 ['2', '13', '53', '62', '112', '1454']

PS：列表嵌套时，按照包含层级由外到里进行方法使用即可。