10.9总结
字符串作业回顾
python
s = 'hello 1 world 2 hello 3 Python'
# 获取第2个字符到第8个字符
print(s[1:8]) # ello 1 # 最后一个不包含,所以到8
# 从右向左获取最后5个字符
print(s[-1:-6:-1]) # nohty
# 获取数字对应的索引
for a,b in enumerate(s):
if '0' <= b <= '9': # 错误写法 0 <= b <= 9，因为字符串取出来的也只能是字符串
print(a)
# 方法2：
import string
for a,b in enumerate(s):
if b in string.digits:
print(a)
# 方法3:
for a,b in enumerate(s):
if b.isdigit(): # 也可以写为 b.isdigit()==True
print(a) #
# 获取大写字母对应的索引
for a,b in enumerate(s):
if 'A' <= b <='Z': # b in string.ascii_uppercase:
print(a) # '123A'.isupper()--- True 【只要里面英文字母是大写就行了】
# 获取索引能被3整除并且能被2整除对应的字符
for a,b in enumerate(s):
if a % 3 == 0 and a % 2 == 0:
print(b)
# 方法2：
print(s[::6]) # h1dlP
# 获取索引能被5整除对应的字符
print(s[::5])
# 获取 n 出现的次数
num = 0
for i in s:
if i == 'n':
num += 1
print(num) # 1
# 方法2：
print(s.count('n')) # 1- 字符串练习2：
python
s = 'How Are You Thank You'
# 从右向左获取前10个字符
print(s[9::-1]) # oY erA woH
# 从右向左获取最后10个字符
print(s[-1:-11:-1]) # uoY knahT
# 字符串的复制
print(s[::]) # How Are You Thank You
# 从左向右获取第3个到第8个字符
print(s[2:8]) # w Are Y
# 字符串反转
print(s[::-1]) # uoY knahT uoY erA woH
import string
# 获取s中大写英文字母、小写英文字母的个数
c1=c2=0
for i in s:
if i in string.ascii_uppercase:
c1 += 1
elif 'a' <= i <= 'z': # 有空格，不能直接else,不然空格也算进去了
c2 += 1
print(c1,c2)
# 获取字符h或者H的索引
for a,b in enumerate(s):
if b == 'h' or b =='H':
print(a)
# 方法2：
for a,b in enumerate(s):
if b in 'hH': # 满足一个即可
print(a)
# 方法3：
for a,b in enumerate(s):
if b.upper() == 'H': # 大写小写转完后都是一样，都是H
# b.lower() == 'h'
print(a)
# 获取所有小写字母对应的下标
for a,b in enumerate(s):
if b in string.ascii_lowercase:
print(a)
# 获取 u 出现的次数
print(s.count('u')) # 2- 字符串练习3：
python
s = '美丽的泡沫,虽然一刹花火,你所有承诺,虽然都太脆弱,爱本是泡沫,如果能够看破'
# 获取泡沫出现的次数
print(s.count('泡沫')) # 2
# 获取泡沫第一次出现的索引
print(s.find('泡沫')) # 3
# 获取泡沫最后一次出现的索引
print(s.rfind('泡沫')) # 29- 字符串练习4：
python
s = 'how are you'
# 所有英文字母转化为大写
print(s.upper()) # HOW ARE YOU
# 将每个单词的首字母大写 其他英文字母小写
print(s.capitalize()) # How are you
# 将字符串的首字母大写 其他英文字母小写
print(s.title()) # How Are You
# 获取空格出现的次数
print(s.count(' ')) # 2- 长度、开头判断
python
# 键盘录入一个手机号，判断手机号是否合法
# 要求: 1.长度是11位的纯数字 2.以186、185、179 开头
phone = input('输入一个手机号：')
if len('phone') == 11 and phone.isdigit() and phone.startswith(('186','185','179')):
print('合法')
else:
print('不合法')
# 方法2
phone = input('输入一个手机号：')
if len('phone') == 11 and phone.isdigit() and phone[:3] in ('186','185','179'):
print('合法')
else:
print('不合法')
# 方法3：
phone = input('输入一个手机号：') # 要加括号，因为and的优先级比较高
if len('phone') == 11 and phone.isdigit() and (phone[:3] == '186' or phone[:3] == '185' or phone[:3] == '179'):
print('合法')
else:
print('不合法')
# 方法4：
phone = input('输入一个手机号：') # 要加括号，因为and的优先级比较高
if len('phone') == 11 and phone.isdigit() and (phone.startswith('186') or phone.startswith('185') or phone.startswith('179')):
print('合法')
else:
print('不合法')
# len() 注意：
a = '12312'
print(len(a)) # 5
a = 12345
print(len(a)) # object of type 'int' has no len()
print(len('a')) # 1- 字符串长度和字母判断
python
# 输入一个用户名，判断用户名是否合法。用户名要求：由英文字母或数字组成，长度是6到12位
name = input('输入一个用户名：') # 要加括号，因为and的优先级比较高
if len(name) in range(6,13) and name.encode('utf-8').isalnum():
print('合法')
else:
print('不合法')列表
概念及特点
-
列表的标识是
[],存储零个或者多个元素的 有序可变 序列，列表之间的元素使用,分隔的 ,列表中的元素可以是多种数据类型，但是为了数据的统一性，经常使用同种数据类型 -
特点
- 有序 -- 添加顺序和显示顺序一致，编号从0开始，就是索引
- 可以通过索引获取对应的元素 体现就是有索引 有切片
- 可变
- 内存地址不变的情况下，数据可以发生变化 【增加 删除 修改】
定义列表
- 使用
[]包含 - 使用
list()构造 - 注意：列表间的元素使用 【逗号】 分割
- 有序 -- 添加顺序和显示顺序一致，编号从0开始，就是索引
python
# 定义
# 1. 使用[]包含 2. list()
# 空列表
l = []
l1 = list()
print(l, type(l), len(l)) # [] <class 'list'> 0
print(l1, type(l1), len(l1)) # [] <class 'list'> 0
l = [ ] # 六个空格 # ctrl + alt + l 它会变成正常空列表 l = []
print(l, len(l)) # [] 0
l = [' '] # 内部是字符串
print(l, len(l)) # [' '] 1 # 只有一个字符串，里面有4个空格
l = [' ','abc']
print(l, len(l)) # [' ', 'abc'] 2
# 非空列表
l = [1, 2, 3, 4]
print(l, type(l), len(l)) # [1, 2, 3, 4] <class 'list'> 4
# 错误示范：
l = list(10) # list(数据不能乱写 序列) 要可遍历的，要么 range; 要么[]
# print(l) # 'int' object is not iterable 可遍历的
# 可遍历数据 字符 range()
l = list('abc')
print(l) # 字符串的每一个字符 作为一个元素 放在列表中 ['a','b','c']
print(range(10)) # range(0, 10)
l = list(range(10))
print(l) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 但 [] 没这要求
l = [5]
print(l, type(l), len(l)) # [5] <class 'list'> 1
# 有序 有索引和切片
l = [1, 2, 3, 4, 5, 6]
print(l[0]) # 1
print(l[-1]) # 6
print(l[0:3]) # [1, 2, 3]- 列表和字符串区别
python
# 列表可变，字符串不可变
# 内存地址不变的情况下 数据的可以发生变化
# 列表可修改 地址不变，这也是可修改原因
l = [1, 2, 3]
print(l, id(l)) # [1, 2, 3] 2396151636864
l[0] = 100
print(l, id(l)) # [100, 2, 3] 2396151636864
# 列表可添加元素 列表.append(元素)
l = [1, 2, 3]
print(l, id(l)) # [1, 2, 3] 1645211114304
l.append(10) # append 没有返回值
print(l, id(l)) # [1, 2, 3, 10] 1645211114304空列表和空字符串长度都为0
python
l = [ ]
print(l) # [] 空列表
l = [' ']
print(l) # [' '] # 空字符串
print([]) # []- 注意括号 体现遍历性
python
l1= list(range(10))
l2 = list([1,2,3,4])
print(l1,l2) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4]
a = list(range(1,7))
print(a) # [1, 2, 3, 4, 5, 6]
s = list(10)
print(s) # TypeError: 'int' object is not iterable注：字符串添加到列表中
python
l = list(10) # 没有交代顺序，所以错误
print(l) # TypeError: 'int' object is not iterable
l = list('abc')
print(l) # ['a', 'b', 'c']
l = list(range(10))
print(l) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l = [1,2,3,4,5]
l.append('你')
print(l) # [1, 2, 3, 4, 5, '你']索引和切片
- 获取的操作和字符串是一样的
python
l = [1, 2, 3, 4, 5, 6]
print(l[0]) # 1
print(l[-1]) # 6
print(l[:3]) # [1, 2, 3]
print(l[-3:]) # [4, 5, 6]
print(l[3::-1]) # [4, 3, 2, 1]
print(l[:]) # [1, 2, 3, 4, 5, 6]
print(l[::-1]) # [6, 5, 4, 3, 2, 1]
# 区别 列表是可变的 修改值 -- 获取再重新赋值
# 修改列表中的第一个元素 100
print(l, id(l))
l[0] = 100
print(l, id(l)) # [100, 2, 3, 4, 5, 6]
# 修改最后一个元素 600
l[-1] = 600
print(l, id(l)) # [100, 2, 3, 4, 5, 600]
# 字符串不支持以上操作：
# s = 'abc'
# s[0] = 'A'
# print(s)
# 可以修改切片
l = [1, 2, 3, 4, 5, 6, 7]
# 获取再重新赋值
# 获取的切片 数据如果连续 赋值的时候 赋值的个数可以是任意个
l[:3] = [10, 20, 30, 40, 50, 60, 70, 80] # 把0-3的元素替换成后面的列表
print(l) # [10, 20, 30, 40, 50, 60, 70, 80, 4, 5, 6, 7]
# 如果获取的切片不连续 赋值的时候 要求 赋值个数与获取元素个数一致
l = [1, 2, 3, 4, 5, 6, 7]
print(l[::3]) # [1, 4, 7]
l[::3] = [10, 20, 30] # 从左到右边，隔3替换1，要替换几个就传几个，不能多，也不能少
print(l) # [10, 2, 3, 20, 5, 6, 30]运算符
| -符号 | -含义 |
|---|---|
| + | 合并两个列表中的数据 不能合并不同类型的 |
| * | 将列表中的数据重复 |
| += | 在当前列表的基础上 合并序列 注意：1. 列表可变的，地址不会发生变化 2. 合并序列【不仅限于列表 字符串 元组 range等】 |
| *= | 在当前列表的基础上 重复 |
| 比较运算符 | 比较规则：相同位置的元素逐个比较，直到比较出大小 |
| 成员运算符 | 判断数据是否为列表中的元素 |
python
# + 合并列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = (7, 8, 9)
print(l1 + l2) # [1, 2, 3, 4, 5, 6] 【只能在列表与列表之间，列表+字符串、元组等都不行】
# print(l1 + l3) # TypeError: can only concatenate list (not "tuple") to list
# * 列表中的内容重复 重复几次
print(l1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# += 在当前列表的基础上 合并序列 1. 当前列表的基础上【内存地址不变】 2. 序列
# += 列表和元组、字符串等都可合并，因为是在当前列表的基础上
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = (7, 8, 9)
print(l1, id(l1)) # # [1, 2, 3] 2262734213312
l1 += [4, 5, 6]
print(l1, id(l1)) # [1, 2, 3, 4, 5, 6] 2262734213312
l1 += (7, 8, 9)
print(l1, id(l1)) # [1, 2, 3, 4, 5, 6, 7, 8, 9] 2262734213312
l1 += range(10, 12)
print(l1, id(l1)) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 2262734213312
l1 += 'abc'
print(l1, id(l1))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 'a', 'b', 'c'] 2262734213312
# 字符串 内存地址会变
s = 'abc'
print(s,id(s)) # abc 1770071767408
s+='d'
print(s,id(s)) # abcd 1770070539632
# *=
l1 = [1, 2, 3]
print(l1, id(l1))
l1 *= 3
print(l1, id(l1))- 比较运算符
python
l1 = [1, 2, 3]
l2 = [1, 3, 2]
print(l1 > l2) # False # 因为2小于3 # 挨个比较，出结果后面不比了
l1 = [2]
l2 = [1, 10, 10, 10, 10, 10, 10, 10]
print(l1 > l2) # True
# l1 = [1,2,3]
# l2 = ['a','b','c'] # 字母越往后越大
# print(l1 > l2)
l1 = ['abc', 'def']
l2 = ['d']
print(l1 > l2) # False- 成员运算符
python
# 成员
l = ['1', 2, 3, 4, 5]
print('1' in l)
# 此处元素为一个整体
l = ['abc', 'def']
print('a' in l) + 仅限于列表和列表 或者元组和元组等类型一致的
+= 不仅限于列表列表的遍历
- 直接遍历列表
- 遍历索引[条件或者结论中和索引相关]
- 枚举遍历
python
# 1. 直接遍历列表
l = [12, 25, 37, 59, 68]
# 获取列表中的所有偶数 把它们放到列表里面
l1 = [] # 写成list()也行
for i in l:
# i 表示的就是列表中的每一个元素
if i % 2 == 0:
# 把满足条件的数值 i 放在列表中
# 1. 列表.append()
# l1.append(i)
# 2. 运算符 += 合并序列
l1 += [i] # 得加【】列表
print(l1)
# 练习：
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
# 获取长度 >6的单词存放在列表中
l2 = []
for i in words:
if len(i) > 6: # 注意 len('i') 是错的
# l2.append(i)
l2 += [i]
print(l2)
# 获取含有o的单词存放在列表中
l3 = []
for i in words:
# i 每一个单词
if 'o' in i:
l3.append(i)
print(l3)
# 获取单词中有两个o的
l4 = []
for i in words:
# i 单词 字符串 判断的是 字符串中o的个数是不是2
if i.count('o') == 2:
l4.append(i)
print(l4)
# 获取以 n 或者 h结尾的单词存放在列表中
l5 = []
for i in words:
# i 单词 字符串
# if i.endswith(('n','h')): # 多个内容一定崖加一层括号
# if i[-1] in 'hn':
# if i[-1] == 'h' or i[-1] == 'n':
if i.endswith('h') or i.endswith('n'):
l5.append(i)
print(l5)
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
# 将列表中的每一个元素都转化为大写 存储在列表
l6 = []
for i in words:
# i 字符串 转化为大写
# i.upper() # 会形成新字符串，没有修改它本身的i
l6.append(i.upper())
print(l6)
# 将列表中的元素 拼接 空格 字符的拼接 拼接符号.join(序列) 序列 -- 序列中的元素是字符串类型
print(' '.join(words)) # hello enumerate length operator expression sort
# 遍历索引
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
# 获取列表中 以e 开头单词的索引
# 列表的索引 从0开始 到 长度-1结束 range() 产生 0- len-1的等差数列
for i in range(0, len(words)): # 0 1 2 3 4 len-1
# i 表示的内容 索引
# if words[i].startswith('e'):
if words[i][0] == 'e':
print(i)
# 枚举遍历 enumerate(words)
for i in enumerate(words):
print(i) # (0, 'hello')等组合
for pos, ele in enumerate(words):
# pos 索引 ele 元素
if ele[0] == 'e':
# if i2.endswith('e'):
print(pos)
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
# 获取列表中长度为偶数的单词的索引
for pos, ele in enumerate(words):
# 判断条件
if len(ele) % 2 == 0:
print(pos)
# 获取列表中索引能被2整除或者能被3整除的单词
for pos, ele in enumerate(words):
if pos % 2 == 0 or pos % 3 == 0:
print(ele)
# 获取列表中 字母s个数为2个的单词的索引
for pos, ele in enumerate(words):
if ele.count('s') == 2:
print(pos)
l = [168, 28, 49, 65, 84, 37]
# 获取l中偶数元素对应的索引
for pos, ele in enumerate(l):
if ele % 2 == 0:
print(pos)
# 获取l中十位数为奇数的索引
for pos, ele in enumerate(l):
# 获取一个数的十位数 num//10%10
if ele // 10 % 10 % 2 != 0:
print(pos)
# 获取l中每一个数的个位数 存储在列表中
l7 = []
for i in l:
l7.append(i % 10)
print(l7)
# 获取l中最高位为奇数的元素对应的索引
for pos, ele in enumerate(l):
# 最高位为奇数 最高位 一定是 第一位
if int(str(ele)[0]) % 2 != 0: # 整型没有索引，需要先转成字符串
print(pos)
# 使用+ 拼接 拼接符号.join(序列) 序列中的元素是字符串类型
l = [168, 28, 49, 65, 84, 37]
# 将l中的每一个元素转化为字符串类型
l8 = []
for i in l:
l8.append(str(i))
print(l8)
print('+'.join(l8))整型没有索引，需要先转成字符串
列表推导式：
对循环添加过程的简化，虽然是简化，但是效率要append添加元素要高
python
语法结构
[想要的内容 for 变量名 in 序列 if 条件判断]
1.筛选
[变量名 for 变量名 in 序列 if 条件判断]
2.转化
[转换的操作 for 变量名 in 序列]
python
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
# 列表推导式
# 获取长度 >6的单词存放在列表中
print([i for i in words if len(i) > 6]) # 它最外面本身就是[]，所以不需要额外定义空列表
# 获取含有o的单词存放在列表中
print([i for i in words if 'o' in i])
# 获取列表中 以e 开头单词的索引
print([pos for pos, ele in enumerate(words) if ele[0] == 'e'])
# 转化的操作
# 将列表中的每一个元素都转化为大写 存储在列表
print([i.upper() for i in words])
l = [168, 28, 49, 65, 84, 37]
# 获取l中每个数的个位数
print([i % 10 for i in l])
# 将l中每一个数转化为字符串
print([str(i) for i in l])
s = 'There is no denying that successful business lies in a healthy body and mind'
import string
# 将s切割成单词 字符串的切割 结果就是列表
l = s.split()
print(l)
# 获取上述结果中 单词长度为偶数的
print([i for i in l if len(i) % 2 == 0])
# 获取 以 e结尾的单词
print([i for i in l if i[-1] == 'e'])
# 获取单词中 s 个数大于2的单词
print([i for i in l if i.count('s') > 2])
# 获取 以大写英文字母开头的单词 istitle() 每个单词的首字母大写 其他字母小写
print([i for i in l if i[0].isupper()]) # istitle() 放这里不准确，它是开头大写，其他小写，这里是开头大写就行
# 将每个单词转化为大写
print([i.upper() for i in l])列表的操作
合并不仅限于列表
append() 和 insert是加一个元素，一个列表也是一个元素
python
# 增加元素
l = [1, 2, 3]
print(l, id(l))
# 1. 追加元素 列表.append(元素) 添加的元素在列表的最后
l.append(4) # 不要打印式子，会返回空值
print(l, id(l)) # [1, 2, 3, 4]
# 2. 指定位置添加 插队 列表.insert(索引，元素) 将原有索引位置及以后的元素整体向后移动一位
l.insert(1, 10) # 索引1的位置 插入元素10
print(l, id(l)) # [1, 10, 2, 3, 4]
# 3. 合并序列 等同于 += h合并的时候需要合并序列，如l.extend(10)这不行
l = [1, 2, 3]
l.extend([1, 3, 5, 7])
print(l, id(l)) # [1, 2, 3, 1, 3, 5, 7] 3058508651328
l.extend(range(8, 10))
print(l, id(l)) # [1, 2, 3, 1, 3, 5, 7, 8, 9] 3058508651328
l.extend((4, 5, 6)) # 元组
print(l, id(l)) # [1, 2, 3, 1, 3, 5, 7, 8, 9, 4, 5, 6] 3058508651328
l.extend('abc') # 字符串
print(l, id(l)) # [1, 2, 3, 1, 3, 5, 7, 8, 9, 4, 5, 6, 'a', 'b', 'c'] 3058508651328- 注意：append 和 extend区别
python
l1 = [1, 2, 3]
l1.append([4, 5, 6]) # append是添加一个元素
print(l1) # [1,2,3,[4,5,6]]
l1 = [1,2,3]
l1.extend([4,5,6]) # extend是合并序列
print(l1) # [1, 2, 3, 4, 5, 6]- 删除元素
python
# 删除元素
l = [1, 2, 3]
# 1. 删除列表中的最后一个元素 列表.pop()
l.pop()
print(l, id(l)) # [1, 2] 2126652271040
l.pop()
print(l, id(l)) # [1] 2126652271040
# 2. 删除指定索引位置的元素 列表.pop(索引)
l.pop(0)
print(l, id(l)) # [] 2279782898688
# 3. 删除指定的元素 根据元素的值删 列表.remove(元素)
# 如果元素在列表中有多个 删除找到的第一个 如果元素在列表中没有 报错
l = [1, 2, 3]
l.remove(3)
print(l, id(l)) # [1, 2] 1619178249024
# l.remove(100)
# print(l,id(l)) # ValueError: list.remove(x): x not in list
# 4. 清空 将列表中的所有元素都删除 列表.clear()
l = [1, 2, 3]
l.clear()
print(l,id(l)) # [] 2975592438592- 获取元素 与 其他操作
python
# 获取的操作
# 1. 获取某个元素第一次出现的位置 列表.index(元素，起始索引，结束索引) 不给范围就全部范围找
l = [1, 2, 3, 4, 1, 1, 1]
print(l.index(1)) # 0
# 找不到报错
# print(l.index(100)) # ValueError: 100 is not in list
# 2. 获取某个元素出现的次数 列表.count(元素)
print(l.count(1)) # 4
print(l.count(100)) # 0
# 其他操作
# 1. 复制 切片 列表[:] 列表.copy()
print(l.copy()) # [1, 2, 3, 4, 1, 1, 1]
# 2. 反转 切片 列表[::-1] 产生一个新列表 不修改原有列表 列表.reverse() 修改原列表
l = [1, 2, 3, 4]
print(l[::-1]) # [4, 3, 2, 1]
l = [1, 2, 3, 4]
l.reverse()
print(l) # [4, 3, 2, 1]
# 3. 排序 将列表中的数据进行排序 升序 降序 直接修改的是原列表
# 列表.sort() 默认是升序排序 如果想降序排序 列表.sort(reverse=True)
l = [4,1,2,3]
l.sort()
print(l) # [1, 2, 3, 4]
l.sort(reverse=True)
print(l) # [4, 3, 2, 1]字符串补充：
- 字符串的切割和拼接操作 【空白字符 != 空格】
python
s = 'how are you'
print(s.split(' ')) # ['how', 'are', 'you']
print(s.split()) # ['how', 'are', 'you']
s = 'how are you' # 与上面s空格不同,仔细看
print(s.split(' ')) # ['how', '', 'are', '', 'you']
print(s.split()) # ['how', 'are', 'you']
python
# 1. 字符串的切割
# 将字符串按照指定的切割符号，切割成几部分 最终的结果是列表
# 操作 字符串对象.split(切割符号，切割次数)
# 如果不指定次数 按照所有的切割符号全部切割 如果不指定切割符号 按照空白字符切割 【空白字符 != 空格】
s = 'how are you'
# 指定切割符号 如果按照切割符号全部切割 最终的结果中不含有切割符号
print(s.split(' ')) # ['how', 'are', 'you']
# 不指定切割符号 它会按照空白切
print(s.split()) # ['how', 'are', 'you']
# 空白字符 \n \t \r \v \f 空格
s = 'how\nare\tyou'
print(s.split(' ')) # ['how\nare\tyou'] # 找不到空格，切割失败
print(s.split()) # ['how', 'are', 'you'] # 默认用空白符号切
s = 'how are you'
# s.split(' ') ['how','','are','','you']
print(s.split(' ')) # ['how', '', 'are', '', 'you']
print(s.split()) # ['how', 'are', 'you']
s = 'how are you'
# 指定切割次数
print(s.split(' ', 1)) # ['how', 'are you']
# 从右边开始切割 全部切割 没有区别 只有指定的次数不全部切割 有区别
print(s.rsplit(' ')) # ['how', 'are', 'you']
print(s.rsplit(' ', 1)) # ['how are', 'you']
# 2. 拼接 字符串中特殊的一个操作 拼接符号.join(序列) 序列有要求：要求每一个元素是字符串类型
# 形成的结果 是将序列中的多部分 拼成一个字符串
l = ['how', 'are', 'you']
print(' '.join(l)) # 'how are you'
print('+'.join(l)) # how+are+you
l = ['1', '2', '3']
print('+'.join(l)) # 1+2+3拼接的时候，里面一定得是字符串
字符串的替换和去除
默认全替换
python
# 1.替换 将字符串中的指定内容 替换成 新内容
# 字符串对象.replace(旧内容，新内容，替换次数)
# 如果替换次数不指定 全部替换
s = 'how are you'
# 需求 将s中的空格去掉 把空格 替换成 空字符串
print(s.replace(' ', '')) # howareyou # 默认全替换
print(s.replace(' ', '', 1)) # howare you
print(s.replace(' ', '', 2)) # howareyou
# 2. 去除 去除字符串两端的指定内容
# 字符串对象.strip(指定内容) 指定内容可以不给，如果不给，表示去除字符串两端的空白字符
s = ' \n a b c \t '
print(s.strip(' \n\t')) # a b c 【知道找到不再去除的内容就停了，所以中间空格去不掉】
print(s.strip()) # a b c 【空白字符不止空格】
# 单独去除左边的 字符串对象.lstrip(指定内容)
# 单独去除右边的 字符串对象.rstrip(指定内容)
# 不给指定内容，将去除空白字符
s = ' \n a b c \t '
print(s.lstrip('\n ')) # a b c
print(s.rstrip(' \t')) # a b c
print(s.rstrip()) # a b c