Python学习笔记4-列表、元组、字符串

1、作业

1.1 列表作业

1 ,

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
'''1. 在列表的末尾增加元素15
2. 在列表的中间位置插入元素20
3. 将列表[2, 5, 6]合并到lst中
4. 移除列表中索引为3的元素
5. 翻转列表里的所有元素
6. 对列表里的元素进行排序，从小到大一次，从大到小一次'''
lst.append(15)
lst.insert(len(lst)//2,20)
lst.extend([2, 5, 6])
lst.pop(3)
lst.reverse()#或者为lst[::-1]
lst.sort()
lst.sort(reverse=True)

2，

lst = [1, [4, 6], True]
#请将列表里所有数字修改成原来的两倍
lst[0] *= 2
lst[1][0] *= 2
lst[1][1] *= 2
lst
#[2, [8, 12], True]

3，这里做的是而过给定的数组不确定是不是山脉数组，进而做的判断。

#思路可以是，比较后一个与前一个数的大小，如果后面的数大于前面的则继续循环，直到后面的数小于等于前面的停止循环；
# 再接着比较后面的数，是否前面的数永远大于后面的数，是的话继续循环，不是输出False
def mountain(A):
    n = len(A)
    topic = 1
    for i in range(1,n+1):
        if A[i] <= A[i-1]:
            j = i-1
            break
    for i in range(j,n-1):
            if A[i] <= A[i+1]:
                topic = 0
                break
    if  topic == 1:
        print('True')
        print('顶峰索引是:%d'%j)
    else:
        print('False')

1.2 元组作业

1、元组概念

(1,2)*2
#(1, 2, 1, 2)
(1,)*2
#(1, 1)
(1)*2
#2

分析：(1,2)*2，意思是对元组的元素重复操作，也就是把里面的元素获取，因此得到(1, 2, 1, 2)；
(1,)*2元组中只有一个元素时，加了逗号，说明这是一个元组，因此(1,)*2也是对元组的元素重复操作，得到(1, 1)；
(1)2，1后面没有加逗号，计算机将括号识别成运算符，等价于12,因此结果为2。
2、拆包过程是什么？
元祖拆包相当于把元组中的元素拆分成单个的元素，可以将元组中的元素按顺序依次赋给变量。即下面所说的解压。

info = ('xian','2018','7.17')
city,year,date = info
'''city # 'xian'
year#'2018'
date#'7.17'
'''

a, b = 1, 2，属于拆包。这个过程相当于同时完成元组的创建和拆包。

t = (1,2)
(a,b) = t

可迭代对象拆包时，赋值给占位符时，直接跳过占位符。

1.3 字符串作业

1，
用replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。
用split() 不带参数，则是以空格为分隔符切片字符串
用lstrip() 截掉字符串左边的空格。
2，

def isdigit(string):
    print(string.isnumeric())

3，

def findHuiWen(string, maxlen = 1000):
    l = len(string)
    length = []
    strList = []
    maxStr = ''
    for i in range(l):
        for j in range(i+2, i+2+maxlen):
            subStr = string[i:j+1]
            if subStr == subStr[::-1]:
                length.append(len(subStr))
                strList.append(subStr)
                if len(maxStr) <  len(subStr):
                    maxStr = subStr
    return maxStr
#findHuiWen('abccbds')#'bccb'

2、列表

2.1 切片

切片：获取数据一段的值，用冒号表示从第i个位置取到第j个位置。切片的索引从0开始，0表示第一个值，而最后一位不被取到，python中对所有类型数据的索引都是用[]的。

name = 'abcdef'
name[1]#b
#name[70]#IndexError: string index out of range
name[0:4]#'abcd'
name[1:70]#'bcdef'
len(name)#得到长度
#  name[0:]= name[0:len]=nmae[:]=name,冒号必须要写
#两个冒号的情况
# name[::] = name
# name[起始位置：结束位置：步长]
name[::2]
name[::-1]#负号表示从反方向开始取值，反转了字符串，#'fedcba'
name[-3]#'d'
name[0:-1]#-1表示最后一个位置，由于切片对末尾的那位取不到，所以结果为'abcde'

2.2 列表介绍

1，数据类型：根据是单个元素组成还是多个元素组成可以分为两大类：
单个元素组成：简单数据类型，包括整型(int)，浮点型(float)，布尔型(bool);
多个元素组成：容器数据类型，包括，字符串(str)，列表(list)，元组(tuple)，字典(dict)，集合(set)。
存储数据的另外两种结构，先进后出：栈(例如做电梯，先进去的最后才出来)；先进先出：队列(排队一样，再前面的先出)。
2，首先介绍列表，列表类似matlab中的元包。
列表(list)用中括号[ ]来装多个值，列表中的元素可以是字符串，数字，列表，字典，元组，集合等已知的各种数据类型。语法为 [元素1, 元素2, …, 元素n]，最外面的中括号把所有元素绑在一起，里面的逗号将每个元素一一分开。它是一种有序集合。
这里又可以根据有序和无序区分容器数据类型：
有序集合：字符串，列表，元组；
无序集合：字典，集合。

names = ['小红','laowang',1,[1,2],(2,3,34),{'a':1,'b':2},{1,2}]
names[-2]#{'a': 1, 'b': 2},输出字典的内容
names[-2]['b']#选取字典中的b的值
list(names[-2].keys())#['a', 'b']，不转换成list结果是dict_keys(['a', 'b'])

3，上述程序说明了获取字典的区别，对象.keys()获取列表中的字典的所有键，如果是对象.items()是获取整个键值对，如果是对象.values()是获取值。
4，用for,while可以取列表中的所有值，叫做遍历。下面第一个程序是for和while 遍历的区别。for两行代码即可，while需要得知花名册的长度才能结束循环。

for name in names:
    print(name)
    
i = 0
length = len(names)
while i<length:
    print(names[i])
    i += 1

5，用in，not in可以判断元素是否在列表中，结果为布尔值。下面的程序是寻找名字是否在一个花名册当中，如果在结束循环，不在的话输出’没找到‘。第一个方法每寻找一次都要输出’没找到‘，但是应该是所有的都遍历完了，没找到名字才输出‘没找到’,此时要用一个变量来代表是否找到了没。找到了的话变量为1，没找到变量为0，最后通过变量的值来输出找到了还是没找到。

##找名字在不在names中
# 1，定义一个列表里面有一些名字
names
#2，获取一个要查找的名字
interName = input('请输入你的名字')
#3，判断是否存在，并显示相应提示
for name in names:
    if name == interName:
        print('找到了')
        break
    else:
        print('没找到')
##方法二：
interName = input('请输入你的名字')
fingFlag = 0
for name in names:
    if name == interName:
        fingFlag = 1
        break#如果在前面已经找到了需要的名字，就结束循环，因为剩下的不会再进行判断，提升了运行效率
if fingFlag == 1:
    print('找到了')
else:
     print('没找到')
# 由于只要找到了就停止，因此只要找到了就改变变量的值

6，建立一个固定长度的列表的方法, 例如建立一个长度为4的列表，有以下几种：

1. 用list(range(10)),将迭代器转换成列表；
2. 通过循环用appdend添加，

b =[]
for row in range(4):
        b.append('a')

3. 利用推导式创建列表，b = [‘1’ for i in range(8) if i % 2 == 0]，此种方法较常用，代码简洁。

7，列表可以创建一个4X3 维的数组：思路是用列表嵌套的方式来生成，先生成外层的列表，也就是一个程度为4的列表，然后，里面的没一个元素又是一个长度为3的列表。
a，刚开始的程序写法是

['1' for i in range(4) for j in range(3)]
#['1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1']
## 等价于
b = []
for i in range(4):
    for j in range(3):
        b.append('1')

b，第二个思路是先用循环写的：感觉是先写外层的大循环，对b.append(a)循环4次，然后再去把a定义了，所以再写个得到列表a的循环，但是这个结果确是：
[[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]]

b = []
a = []
for i in range(4):
    for j in range(3):
        a.append(j)
    b.append(a)

在debug后发现，这里b.append(a)是一个浅拷贝形式，由于，每层外循环后a的值的变化是[0,1,2]–[0,1,2,0,1,2]–[0,1,2,0,1,2,0,1,2]–[0,1,2,0,1,2,0,1,2,0,1,2]。a的值发生了变化，所以，b的值也发生了变化。这里插入一点有关浅拷贝和深拷贝浅薄的认识，可能理解得并不对：
首先先解释一下什么是地址可变类型，和地址不可变类型。
地址可变类型(列表、字典、集合)是说这些对象的值发生改变时，它们的地址是一样，如：上述a的值发生变化，但是它的地址还是一样的： 1757679124040。也就是一旦给这三种数据类型赋予了一个值，它的地址就固定了。
地址不可变类型(数值，字符串，元组)，是指一个变量如果先赋值了这种类型，改变它的值时，它的地址会发生改变，也就是值变地址也变。如：上述列子的循环变量j，j的值为0为地址是：1916169248，j的值为1时地址变为：1916169280。
**浅拷贝：**将地址可变类型变量a的地址赋值到了另一个变量中，则a的值发生改变，b的值也会跟着a发生改变。
比如：

a = []
b = a
b.append(10)
a# [10]

上面的那个循环得到4x3的数组就是因为这个原因所以得到的结果不对，这里a的地址是不变的，因为a为列表，所以里面的值可以发生变化，而b.append(a)是将a的地址放进去了，所以a发生变化，b也会发生变化。
**深拷贝：**将不可变类型变量a的值赋值给了令一个变量b，a的值发生改变地址也发生改变，b的值不会发生改变

a = 5
b = a
a = 10
b# 5

b和a同时指向5这个地址，a变成10时，地址也指向了10，但b还是指向5这个地址。
下面用一个例子再列理解一下，主要时理解指向地址的变化。

list1 = [[1, 5, 7], [1, 2, 3]]
list2 = list1
list3 = list1[:]
list1.sort()#排序
print(list1)
print(list2)#浅拷贝
print(list3)#深拷贝
#[[1,2,3],[1,5,7]]
#[[1,2,3],[1,5,7]]
# [[1, 5, 7], [1, 2, 3]]
print('list1\'s id is',id(list1))
print('list2\'s id is',id(list2))
print('list3\'s id is',id(list3))
'''list1's id is 1755672663304
list2's id is 1755672663304
list3's id is 1755672730888
'''
num1 = [[1,2,3],[1,5,7]]
num2 = num1
num3 = num1[:]
num1[1][1] = 1
print(num1)
print(num2)
print(num3)
#[[1, 2, 3], [1, 1, 7]]
#[[1, 2, 3], [1, 1, 7]]
#[[1, 2, 3], [1, 1, 7]]

理解：首先，我们可以看到，list1和list2的指向地址时一样，这两个事浅拷贝，因此改变一致。而list3的地址与list1不一样，因为list3是取出list1当中的切片元素，也就是把1当中的元素都取出来放进一个新的地址。因此改变1的元素顺序不会改变3，但是由第二个例子又看到，为什么list1里面元素的值发生变化时，list3也会发生变化呢，这里我们用一个图来解释一下。
第一次list1的第一个变化，排序变化，只是改变了里面两个元素的指向位置，指向顺序进行了改变，这个改变不影响[1,2,3]和[1,5,7]这两个列表的指向位置和里面的元素内容，因此list3不会发生改变。list1的第二个变化是将[1,5,7]变成了[1,1,7]这个变化直接改变了[1,5,7]的元素内容，由于list3也是指向这个地址，因此list3也发生了改变。

c, 第一，知道了上述的浅拷贝的原因，明白了，a的值在每次大循环后应该不变，因此把a=[]放入了循环中。第二，从推导式的原理来看，应该是先写一个循环推导出外层的4维的列表，再在循环里面推导一个列表，因此改为：

b = []
for i in range(4):
    a = []
    for j in range(3):
        a.append(j)    
    b.append(a)
b
#[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

循环推导式的写法为：

x = [[col for col in range(3)] for row in range(4)]

将内层循环加一个中括号表示是列表种中的元素的元素内容。

8, x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。下面的列子时说，x发生变化时，a的值也会发生变化。

x = [[0]*3]*4
x#[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
x#[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]????

2.3 列表的常见操作

2.3.1 列表操作–‘增’和‘改’

’增’，也就是往列表里添加东西，有三种选择，分别是append，extend,insert
1，append，添加到原来列表的末尾处。

names = ['xiaoming','abc',{1,2}]
names.append('Laowang')
names#['xiaoming', 'abc', {1, 2},'Laowang']

2 ，insert 是可以在指定位置添加元素，所以要输入两个变量，第一个是位置，第二个是添加的元素。

names.insert(2,'xiaohong')
names.insert(0,[100,99])#这个指定位置是插入的东西所在列表的位置
names#[[100, 99], 'xiaoming', 'abc', 'xiaohong', {1, 2}, 'Laowang']

3，extand,把两个列表的内容衔接起来，第二个列表中的元素放入了第一个列表
注意区分的是：append是把test作为一个整体去加进去，extend是把test中的元素分别加进去。
append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后

test = ['aaa','bbb']
names.extend(test)
names#[[100, 99], 'xiaoming', 'abc', 'xiaohong', {1, 2}, 'Laowang', 'aaa', 'bbb']
##append是把test作为一个整体去加进去，extend是把test中的元素分别加进去
names.append(test)
names#[[100, 99], 'xiaoming', 'abc', 'xiaohong', {1, 2}, 'Laowang', ['aaa', 'bbb']]
#索引可以连续接，取最里面的元素
names[0][1]#99
# 先找你的名字在不在，在的话结束，不在的话添加进去
interName = input('请输入你的名字')
fingFlag = 0
for name in names:
    if name == interName:
        fingFlag = 1
        break#如果在前面已经找到了需要的名字，就结束循环，因为剩下的不会再进行判断，提升了运行效率
if fingFlag == 1:
    print('找到了')
else:
    print('没找到')
    names.append(interName)
print(names)

’改’：通过索引，找到要改的位置，将新的内容赋值到这个位置。

2.3.2 列表操作–‘查’和‘删’

’查’：用in,not in来判断元素是否在列表中，之前的花名册可以直接用这个来查找：

insertName = 'Laowang'
insertName in names#True
if insertName in names:
    print('找到了')
if insertName not in names:# 等价于else:
    print('没找到')
    names.append(interName)
print(names)

’删‘：列表元素的三种删除方法：
1 del: 根据下标进行删除，del是一个函数，因此格式为：del加删除对象，而其他的操作都是方法，格式为：对象.方法

letter = ['aa','bb','cc','dd','ee']
del letter[2]# ['aa','bb','dd','ee']，注意del的运行形式，只能del 对象

2. pop：括号里加索引可以删除指定位置的元素，不加则默认是删除最后一个元素。

letter.pop()
letter#['aa', 'bb', 'dd']

3. remove：根据元素的值进行删除

letter.remove('aa')
letter#['bb', 'dd']

2.3.3 列表操作–‘排序’和‘嵌套’

1. index与count,index 显示元素出现的位置，返回下标，如果不在的话，显示异常，find查找如果不在，显示-1，count统计出现的次数，

letter = ['aa','bb','cc']
letter.count('aa')#1,
letter.count('aaaa')#0
letter.index('aa')#0,在0这个位置
letter.index('cc')#2,在2这个位置

2. 排序：sort()表示从小到大排序，sort(reverse=True)表示从大到小排序，reverse 表示将列表逆置。排序时将字母转换成数字比较，先按第一个字母比较，第一个相同比较第二个，然后比较第二个、第三个。。。。

nums = [2,3,88,52,37]
nums.sort()
nums#[2, 3, 37, 52, 88]
nums.reverse()
nums#[37, 52, 88, 3, 2]
letter = ['aaa','bbb','ddd','fff','ccc']
letter.sort()
letter#['aaa', 'bbb', 'ccc', 'ddd', 'fff']
letter.append('aab')
letter.append('aacc')#如果直接是letter.append('aab','aacc')会报错，因为里面的不只一个元素，相当于有两个元素
letter.sort()
letter#['aaa', 'aab', 'aacc', 'bbb', 'ccc', 'ddd', 'fff']

3. 列表的嵌套，一个列表的元素又是一个列表就是嵌套。下面是一个列表的例题，要求是一个学校有3个办公室，8个老师等待随机分配，问显示分配的结果。思路是:1，定义一个列表用来保存3个办公室，2，定义一个列表用来保存8个老师；3，应该是对于每个名字去随机选办公室，也就是随机的应该是办公室，第3个之前的想法是将8个老师随机分配成3组，将三组赋值到办公室列表中，错误又复杂的想法，不容易实现。

# 一个学校有3个办公室，8个老师等待随机分配
import random
# 1，定义一个列表用来保存3个办公室
rooms = [[],[],[]]# 如果再加教室，可以直接append([])

# 2，定义一个列表用来保存8个老师
teachers = ['a','b','c','d','e','f','g','h']

##3，应该是对于每个名字去随机选办公室，也就是随机的应该是办公室
for name in teachers:
    randomNum = random.randint(0,2)
    rooms[randomNum].append(name)
    
print(rooms)
for room in rooms:
    num = rooms.index(room)+1
    rennum = len(rooms[num-1])
    print('第%d个教室有%d个人:'%(num,rennum),end = '')
    print(room)
'''[['c', 'd', 'e', 'f', 'g'], ['a', 'b'], ['h']]
第1个教室有5个人:['c', 'd', 'e', 'f', 'g']
第2个教室有2个人:['a', 'b']
第3个教室有1个人:['h']
'''

4. 列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

list1 = [123, 456]
list2 = [456, 123]
list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]
list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

3、元组

1，元组和列表类似，不同在于元组里面的元素不能修改,删添改增都不能。元组用（）表示,里面的元素可以是各种类型的数据。定义语法为：(元素1, 元素2, …, 元素n)，小括号把所有元素绑在一起，逗号将每个元素一一分开。

aTuple = ('et',77,99.9)
aTuple
#aTuple.append('aaa')
rates = (0.2,0.5)
type(rates)#Tuple
rates1 = (0.2)
type(rates1)#float，元组只有一个元素时，这个元素是什么类型就显示什么类型，加了逗号，才显示的hi元组
rates2 = (0.2,)
type(rates2)#Tuple

2，元组的索引与切片与列表的规则一致，这里不在详细介绍。元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，也就是相当于先算括号里的东西。
3，元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素是地址可变类型，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

#只要不是修改里面元素的地址，列表有的操作，元组都能
atuple = ([1,2,3],3,'aaa')
atuple[0][0] = 10
atuple#([10, 2, 3], 3, 'aaa')#当元组里面的元素有列表，字典，集合时，修改它们的值是可以的，因为修改列表的值不改变它的地址。

4，解压(拆包)原则：应该是将元组里的元素单独放出来进行解压，把元素放进一个元组相当于压缩。因此拿出来就是解压。
a，解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

b, 解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

c, 如果只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。不加括号相当于一个元组。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]
t#(1, 2, 3, 4, 5)

4、字符串

1，字符串用引号将字符集合，引号需要成对出现，单引号和双引号是单行的字符串定义，三引号可以定义多行的字符串。

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB (    )。
# 也可以使用换行符 [
#  ]。

这里的\t和\n称为转义字符串，意思是他们有特殊的含义，具体意义有以下几种：

`\\` | 反斜杠符号
`\'` | 单引号
`\"` | 双引号
`\n` | 换行
`\t` | 横向制表符(TAB)
`\r` | 回车

如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。

print('let\'s go')  # let's go
print("let's go")  # let's go
print('C:\\now')  # C:\now
print("C:\\Program Files\\Intel\\Wifi\\Help")
# C:\Program Files\Intel\Wifi\Help

原始字符串只需要在字符串前边加一个英文字母 r 即可

```python
print(r'C:\Program Files\Intel\Wifi\Help')  
# C:\Program Files\Intel\Wifi\Help

2，字符串的切片与拼接
与元组的用法一致，注意字符串跟元组一样，也是地址不可变类型，改变值就会改变指向地址，字符串中的内容也不可以进行增删改。
```python
a = 'abn'
a[1] = a
a
#TypeError: 'str' object does not support item assignment

3. 字符串的常用内置方法
   a
   capitalize() 可以将字符串的第一个字符转换为大写。注意输出的是另一个字符串，而不是对原来的那个进行修改.

a = 'abn'
print(a.capitalize())#Abn
a#'abn'

lower()转换字符串中所有大写字符为小写。
upper()转换字符串中的小写字母为大写。
swapcase()将字符串中大写转换为小写，小写转换为大写。
b
count(str, beg= 0,end=len(string))返回str在 string 里面出现的次数，beg和end没有则默认是所有范围中查找，如果beg或者end指定则返回指定范围内str出现的次数。没有的话就会报错。
find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string))类似于find()方法，不过是从右边开始查找。
endswith(suffix, beg=0, end=len(string))检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith (substr, beg=0,end=len(string))检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
lstrip([chars]) 截掉字符串左边的空格或指定字符。
rstrip([chars]) 删除字符串末尾的空格或指定字符。
strip([chars]) 在字符串上执行lstrip()和rstrip()。
partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。
rpartition(sub)类似于partition()方法，不过是从右边开始查找。

str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。

分隔字符串：split(str="", num) 不带参数默认是以空格为分隔符切片字符串，有指定str，则是说，把str的字符串给删掉并把其他的都分开成单独的字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。

str5 = ' I Love LsgoGroup '
print(str5.strip().split())  # ['I', 'Love', 'LsgoGroup']
print(str5.strip().split('o'))  # ['I L', 've Lsg', 'Gr', 'up']

u = "www.baidu.com.cn"
# 使用默认分隔符
print(u.split())  # ['www.baidu.com.cn']
# 以"."为分隔符
print((u.split('.')))  # ['www', 'baidu', 'com', 'cn']
# 分割0次
print((u.split(".", 0)))  # ['www.baidu.com.cn']
# 分割一次
print((u.split(".", 1)))  # ['www', 'baidu.com.cn']
# 分割两次
print(u.split(".", 2))  # ['www', 'baidu', 'com.cn']
# 分割两次，并取序列为1的项
print((u.split(".", 2)[1]))  # baidu
# 分割两次，并把分割后的三个部分保存到三个变量
u1, u2, u3 = u.split(".", 2)
print(u1)  # www
print(u2)  # baidu
print(u3)  # com.cn

去掉换行符:

c = '''say
hello
baby'''
print(c)
# say
# hello
# baby
print(c.split('\n'))  # ['say', 'hello', 'baby']

string = "hello boy<[www.baidu.com]>byebye"
print(string.split('[')[1].split(']')[0])  # www.baidu.com
print(string.split('[')[1].split(']')[0].split('.'))  # ['www', 'baidu', 'com']

splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。
maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。
3, Python 字符串格式化符号
比较常用的就是：
%s | 格式化字符串，用str()方法处理对象
%d | 格式化整数
这个在第一节中已经有介绍，这里不在说明

本文地址：https://blog.csdn.net/XYQLTX/article/details/107619761