目录

一、学习知识点概要（review）    

二、学习内容（record）

三、学习问题与解答(analysis)

四、学习思考与总结（summary）

二、学习内容（record） 1.列表的定义、创建

列表是有序集合、无固定大小的、能够保存任何数量类型的Python对象，语法为[元素一,元素二,元素三,...,元素n]。

可以看到列表由中括号、元素和逗号组成

我们可以创建列表：

#可以看到列表可以存放不同类型的数据
numbers = [1,2,5,9,8]
singer = ['林俊杰','周杰伦','邓紫棋','张杰','薛之谦']

利用range()函数创建列表：

a=list(range(1,10))
print(a,type(a))
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

利用列表推导式创建列表：（之前学习的内容）

number = [i for i in range(1,21)if i % 2 == 0]
number
#输出：[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

创建混合列表：

mixture = ['',1,55,3.14,[1,2,3]]
mixture
#输出：['', 1, 55, 3.14, [1, 2, 3]]

利用列表创建二维数组：

#创建二维数组
number = [[i for i in range(5)]for a in range(4)]
number
#输出:[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

二维数组的创建可能会有所不同，我们来看一下。number列表中存放了另一个列表[i for i in range
(5)],在这个列表后有一个for循环，为的就是将这个列表复制五次。

2.列表常见使用方法

列表添加元素：append()方法和extend()方法

两者均只能添加一个元素

#append()方法
list1=[1,3,5,6]
list1.append(9)
list1
#输出：[1,3,5,6,9]

当添加的元素是一个列表时，我们可以用extend()方法

#append()方法添加列表时，会直接将列表嵌套进去
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
x
#输出：['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]


#当使用extend()方法，在原有列表末尾添加新列表的内容，即只提取新列表元素到原有列表
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
x
#输出：['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

严格来说 `append` 是追加，把一个东西整体添加在列表后，而 `extend` 是扩展，把一个东西里的所有元素添加在列表后。

我们接下来看看insert()方法：list.insert(index, obj)` 在编号 `index` 位置插入 `obj，

index – 对象 obj 需要插入的索引位置。

obj – 要插入列表中的对象。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(5,'Saturday')
x
#输出：['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

列表删除元素：remove()方法、pop()方法和del语句

`list.remove(obj)` 移除列表中某个值的第一个匹配项

list=[2,3,6,8,9,7]
list.remove(7)
list
#输出：[2, 3, 6, 8, 9]

`list.pop([index=-1])` 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

当然也可以删除其他位置的元素

list=[1,6,5,9,8]
y=list.pop()#默认删除最后一个元素并返回该元素
list
y
x=list.pop(0)#也会返回删除的元素
list
x
'''输出：
[1, 6, 5, 9]
8
[6, 5, 9]
1
'''

del语句可以 删除单个或多个对象，若知道删除的元素在列表中的位置，则可以用的del语句

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]#删除列表中第0个和第一个元素
print(x) 
 #输出： ['Wednesday', 'Thursday', 'Friday']

获取列表中的元素：

- 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。

- 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0]))  # Monday 
print(x[-1], type(x[-1]))  # ['Thursday', 'Friday'] #列表也能获取
print(x[-2], type(x[-2]))  # Wednesday 

获取列表中的元素可以用切片：切片的通用写法是 `start : stop : step`

由于情况较多我以一个例子直接说明白

#用索引获取列表元素
'''我们想要获取歌手和对应的歌曲'''
album=['薛之谦',['天外来物','演员','刚刚好','意外','我还能怎样'],'周杰伦',['告白气球','稻香'],'张杰',['逆战','最美的太阳','浮诛']]
xuezhiqian=album[0:2]#获取薛之谦的歌，即索引0到2，但不包括2#也可以写成album[:2]
zhoujielun=album[2:4]#获取周杰伦的歌，即索引2到4，但不包括4
zhangjie=album[4:]#获取张杰的歌,即索引4以后全部
print(zhangjie)
print(xuezhiqian)
print(zhoujielun)
'''输出：
['张杰', ['逆战', '最美的太阳', '浮诛']]
['薛之谦', ['天外来物', '演员', '刚刚好', '意外', '我还能怎样']]
['周杰伦', ['告白气球', '稻香']]

也可以这样倒写法
xuezhiqian=album[-6:-4]
zhoujielun=album[-4:-2]
zhangjie=album[-2:]
结果是一样的
'''

以上为切片的使用，没有写step默认为1

当step不为1：我们仍以上面例子讲解

'''我们仅想获取歌手的名字或歌曲'''
album=['薛之谦',['天外来物','演员','刚刚好','意外','我还能怎样'],'周杰伦',['告白气球','稻香'],'张杰',['逆战','最美的太阳','浮诛']]
singers=album[::2]#获取歌手的名字
songs=album[1::2]#获取歌曲
print('歌手：',singers)
print('曲库：',songs)
'''输出：
歌手： ['薛之谦', '周杰伦', '张杰']
曲库： [['天外来物', '演员', '刚刚好', '意外', '我还能怎样'], ['告白气球', '稻香'], ['逆战', '最美的太阳', '浮诛']]

'''

列表的浅/深拷贝：此处为拓展

浅拷贝：利用copy()方法，列表生成式，for循环遍历，使用切片

copy()方法：对List来说，其第一层实现了深拷贝，但对于其内嵌套的列表，仍然是浅拷贝

#修改歌手信息
album1=['薛之',['天外来物','演员','刚刚','意外','我还能怎样'],'周杰伦',['告白气球','稻香'],'张杰',['逆战','最美的太阳','浮诛']]
album2=album1.copy()
print(album1)
print(album2)
'''输出：
['薛之', ['天外来物', '演员', '刚刚', '意外', '我还能怎样'], '周杰伦', ['告白气球', '稻香'], '张杰', ['逆战', '最美的太阳', '浮诛']]
['薛之', ['天外来物', '演员', '刚刚', '意外', '我还能怎样'], '周杰伦', ['告白气球', '稻香'], '张杰', ['逆战', '最美的太阳', '浮诛']]
'''#输出一样


album2[0]='薛之谦'#深拷贝
album2[1][2]='刚刚好'#内部嵌入列表
print(album1)
print(album2)
'''输出：
['薛之', ['天外来物', '演员', '刚刚好', '意外', '我还能怎样'], '周杰伦', ['告白气球', '稻香'], '张杰', ['逆战', '最美的太阳', '浮诛']]
['薛之谦', ['天外来物', '演员', '刚刚好', '意外', '我还能怎样'], '周杰伦', ['告白气球', '稻香'], '张杰', ['逆战', '最美的太阳', '浮诛']]
'''

列表生成式：使用列表生成式产生新列表也是浅拷贝方法，只对第一层实现深拷贝

list1=[1,[5,6],9]
list2=[i for i in list1]
list2[0]=3
list2[1][0]=4
print(list1)
print(list2)
'''输出：
[1,[4,6],9]
[3,[4,6],9]
'''

for循环遍历：利用for循环，将元素一个个添加到新列表。也是一个浅拷贝方法，只对第一层实现深拷贝。

old = [1,[1,2,3],3]
new = []
for i in range(len(old)):
    new.append(old[i]) 
new[0] = 3
new[1][0] = 3
 
'''输出：
[1, [3, 2, 3], 3]
[3, [3, 2, 3], 3]
'''

使用[:]切片,可以浅拷贝整个列表，只对第一层实现深拷贝

list1=[1,[1,6,5],7]
list2=list1[:]
list2[0]=3
list2[1][0]=2
print(list1)
print(list2)
'''输出：
[1,[2,6,5],7]
[3,[2,6,5],7]
'''

深拷贝：使用deepcopy()方法，但需要用到copy模块。如果用deepcopy()方法，则无论多少层，无论怎样的形式，得到的新列表都是和原来无关的，这是最安全最清爽最有效的方法。

import copy
old=[1,[1,6,3],5]
new=copy.deepcopy(old)

new[0]=2
new[1][0]=4

print(old)
print(new)
'''输出：
[1,[1,6,3],5]
[2,[4,6,3],5]
'''

3.列表的操作符及列表的其他方法

等号操作符：`==`

连接操作符： `+`

重复操作符 ：`*`

成员关系操作符： `in`、`not in`

列表拼接：用加号（+）和乘号（*），前者首位拼接，后者复制拼接

实例：

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

而以上的二维数组就用到了复制拼接.

list4的生成可以使用extend()函数，extend()函数将提取列表中的元素到另外一个列表：

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
list4 = []
list4.extend(list1+list2)#加号不能改成逗号
list4
#输出：[123, 456, 456, 123]

注意：extend()一次只能添加一个内容

列表的其他方法：count()方法、index()方法和reverse()方法、sort()方法

`list.count(obj)` 统计某个元素在列表中出现的次数：

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

`list.index(x, start, end)` 从列表中找出某个值第一个匹配项的索引位置

补充：index()函数可以寻找列表中元素的第一个位置。这里的start，end类似于列表索引。

list1 = [123, 456] * 5#[123, 456, 123, 456, 123, 456,123, 456,123, 456]
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4
print(list1.index(456,2,3))#报错，不存在456
print(list1.index(456,2,4))#3

`list.reverse()` 反向列表中元素

x = [123, 456, 789]
x.reverse()
print(x)  # [789, 456, 123]

`list.sort(key=None, reverse=False)` 对原列表进行排序

- `key` -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

- `reverse` -- 排序规则，`reverse = True` 降序， `reverse = False` 升序（默认）。

- 该方法没有返回值，但是会对列表的对象进行排序。

x = [123, 456, 789, 213]
x.sort()#正序
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)#倒序
print(x)
# [789, 456, 213, 123]

在此拓展sort()函数的使用：list.sort(key=None, reverse=False)

参数：
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值：
该函数没有返回值，但会对数组/列表进行排序

实例：将列表中元组

当定义函数：

random = [(2, 2), (3, 4), (4, 1), (1, 3),(5,5),(4,10),(7,8)]
def takesecond(list):#定义一个人函数获取列表中的第二个元素
    return list[1]#返回列表的第二个元素
random.sort(key=takesecond)#按列表每个元组中第二位元素的1升序排序整个数组
print(random)
#输出：[(4, 1), (2, 2), (1, 3), (3, 4), (5, 5), (7, 8), (4, 10)]

当使用lambda函数：

lambda arguments : expression

random = [(2,2),(3,4),(4,1),(1,3),(5,5),(4,10),(7,8)]
random.sort(key=lambda a:a[1])
print(random)
#输出：[(4, 1), (2, 2), (1, 3), (3, 4), (5, 5), (7, 8), (4, 10)]

使用sorted()函数也可：

random = [(2,2),(3,4),(4,1),(1,3),(5,5),(4,10),(7,8)]
a=sorted(random,key=lambda random:random[1])
print(a)
#输出：[(4, 1), (2, 2), (1, 3), (3, 4), (5, 5), (7, 8), (4, 10)]

4.元组的定义和创建

「元组」定义语法为：`(元素1, 元素2, ..., 元素n)`

- 小括号把所有元素绑在一起

- 逗号将每个元素一一分开

例如

(1,5,9,8)就是一个元组

- Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。

- 元组使用小括号，列表使用方括号。

- 元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。

t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python') 

print(t2, type(t2))
# (1, 10.31, 'python') 
#使用切片和索引
tuple1 = (0,1,2,3,4,5,6,7,8)
print(tuple1[1])  # 1
print(tuple1[5:])  # (5,6,7,8)
print(tuple1[:5])  # (0,1,2,3,4)
tuple2 = tuple1[:]
print(tuple2)  # (0,1,2,3,4,5,6,7,8)

 创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。

- 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

a=2,4,6,8
print(a,type(a))#(2, 4, 6, 8) 
a=(1)
print(type(a))#
a=(1,)
print(type(a))#

要注意元组和数字的区别！！

print(8 * (8))  # 64
print(8 * (8,))  # (8, 8, 8, 8, 8, 8, 8, 8)

5.元组的使用

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

以下的元组中嵌套了一个列表，而列表是可以改变的

t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

元组更新

week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) 
 #输出： ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

6.元组相关操作符、内置方法和解压方法

- 等号操作符：`==`

- 连接操作符 `+`

- 重复操作符 `*`

- 成员关系操作符 `in`、`not in`

「等号 ==」，只有成员、成员位置都相同时才返回True。

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

此处不再举例

内置方法

由于元组具有不可改变性（immutable），因此只有count和index两种方法（类似于列表）

t = (1, 10.31, 'python')
print(t.count('python'))  # 1
print(t.index(10.31))  # 1
```
- `count('python')` 是记录在元组 `t` 中该元素出现几次，显然是 1 次
- `index(10.31)` 是找到该元素在元组 `t` 的索引，显然是 1

解压元组(unpack tuple)

解压一维元组和二维元组（按照元组里的元组结构来定义变量，有几个元素左边括号定义几个变量）

A=(1,6,(5,6),'解压')
(a,b,(c,d)，e)=A
print(a,b,c,d,e)
#输出：1 6 5 6 解压

当你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。

t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)#输出：1 2
print(*_)#输出：3 4 5
print(_)#输出：[3,4,5]

_下划线可以使用变量来替换

t = 1, 2, 3, 4, 5
a, b, *numbers = t
print(a, b)#输出：1 2
print(numbers)#输出：[3,4,5]

7.字符串的定义、切片和拼接

定义：

- Python 中字符串被定义为引号之间的字符集合。

- Python 支持使用成对的 单引号 或 双引号。（'   '或''  ''）

#HelloWorld
print('HelloWorld!')#print("HelloWorld!")
'''输出：
HelloWorld!
'''

- Python 的常用转义字符

`\` | 反斜杠符号

`'` | 单引号

`"` | 双引号

`n` | 换行

`t` | 横向制表符(TAB)

`r` | 回车

#转义常见使用例子
print('hi,I am python,one of the computer'language')
'''输出：
hi,I am python,one of the computer'language
当我们在使用引号时，不要忘了转义，否则程序会报错
同样，使用反斜杠时也是
'''
print('C:\now')  # C:now
print("C:\Program Files\Intel\Wifi\Help")
# C:Program FilesIntelWifiHelp

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

print(r'C:Program FilesIntelWifiHelp')  
# C:Program FilesIntelWifiHelp

字符串的切片和拼接：

- 类似于元组具有不可修改性

- 从 0 开始 (和 Java 一样)

- 切片通常写成 `start:end` 这种形式，包括「`start` 索引」对应的元素，不包括「`end`索引」对应的元素。

- 索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

这里不再举例

8.字符串的内置方法

- `capitalize()` 将字符串的第一个字符转换为大写。

str2 = 'xiaoxie'
print(str2.capitalize())  # Xiaoxie

- `lower()` 转换字符串中所有大写字符为小写。

- `upper()` 转换字符串中的小写字母为大写。

- `swapcase()` 将字符串中大写转换为小写，小写转换为大写。

str='hi,HelloWorld'
print(str.capitalize())

str='hi,HelloWorld'
print(str.lower())

str='hi,HelloWorld'
print(str.upper())

str='hi,HelloWorld'
print(str.swapcase())
'''输出：
Hi,helloworld
hi,helloworld
HI,HELLOWORLD
HI,hELLOwORLD
'''

count(str, beg= 0,end=len(string))`返回`str`在 string 里面出现的次数，如果`beg`或者`end`指定则返回指定范围内`str`出现的次数。

str2 = "DAXIExiaoxie"
print(str2.count('xi'))  # 2

`endswith(suffix, beg=0, end=len(string))` 检查字符串是否以指定子字符串 `suffix` 结束，如果是，返回 True，否则返回 False。如果 `beg` 和 `end` 指定值，则在指定范围内检查。

str='Helloworld'
print(str.endswith('world'))
#True

`startswith(substr, beg=0,end=len(string))` 检查字符串是否以指定子字符串 `substr` 开头，如果是，返回 True，否则返回 False。如果 `beg` 和 `end` 指定值，则在指定范围内检查。

str='Helloworld'
print(str.startswith('Hello'))
#True

- `find(str, beg=0, end=len(string))` 检测 `str` 是否包含在字符串中，如果指定范围 `beg` 和 `end`，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。

- `rfind(str, beg=0,end=len(string))` 类似于 `find()` 函数，不过是从右边开始查找。

str='HELLOWORLDhelloworld'
print(str.find('WORLD'))
print(str.find('DLROW'))#从左到右未搜索到，返回-1
print(str.rfind('WORLD'))#返回一开始的索引值，只不过搜索从右边开始，索引仍然是左到右
'''输出：
5
-1
5
'''

 `isnumeric()` 如果字符串中只包含数字字符，则返回 True，否则返回 False

number='24454'
word='hi123'
print(number.isnumeric())
print(word.isnumeric())
'''输出：
True
False
'''

- `ljust(width[, fillchar])`返回一个原字符串左对齐，并使用`fillchar`（默认空格）填充至长度`width`的新字符串。

- `rjust(width[, fillchar])`返回一个原字符串右对齐，并使用`fillchar`（默认空格）填充至长度`width`的新字符串。

str='Helloworld!'
print(str.ljust(80))
print(str.rjust(80))
'''输出：
Helloworld!                                                                     
                                                                     Helloworld!
​
'''

str='123'
print(str.ljust(50,'0'))
print(str.rjust(50,'1'))
'''输出：
12300000000000000000000000000000000000000000000000
11111111111111111111111111111111111111111111111123
'''

- `lstrip([chars])` 删除字符串左边的空格或指定字符。

- `rstrip([chars])` 删除字符串末尾的空格或指定字符。

- `strip([chars])` 在字符串上执行`lstrip()`和`rstrip()`。

str5 =  '   I Love LsgoGroup   '
print(str5.lstrip())  
print(str5.lstrip().strip('I'))  
print(str5.rstrip()) 
print(str5.strip())  
print(str5.strip().strip('p'))  
'''输出：
I Love LsgoGroup   
 Love LsgoGroup   
   I Love LsgoGroup
I Love LsgoGroup
I Love LsgoGrou
'''

- `partition(sub)` 找到子字符串sub，把字符串分为一个三元组`(pre_sub,sub,fol_sub)`，如果字符串中不包含sub则返回`('原字符串','','')`。

- `rpartition(sub)`类似于`partition()`方法，不过是从右边开始查找。

str='helloworld!'
print(str.strip().partition('e'))
print(str.strip().rpartition('w'))
print(str.strip().partition('m'))
'''输出：
('h', 'e', 'lloworld!')
('hello', 'w', 'orld!')
('helloworld!', '', '')
'''

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

str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We'))  # We Love LsgoGroup

- `split(str="", num)` 不带参数默认是以空格为分隔符切片字符串，如果`num`参数有设置，则仅分隔`num`个子字符串，返回切片后的子字符串拼接的 列表

str='Hellohworld!'
print(str.strip().split())
print(str.strip().split('h'))
'''输出：
['Hellohworld!']
['Hello', 'world!']
'''

分割几次,不写次数默认分割可分割次数的最大值

str='www.edu.gdut.cn'
print(str.strip().split('.'))
print(str.strip().split('.',0))
print(str.strip().split('.',1))
print(str.strip().split('.',3))
'''输出：
['www', 'edu', 'gdut', 'cn']
['www.edu.gdut.cn']
['www', 'edu.gdut.cn']
['www', 'edu', 'gdut', 'cn']
'''

利用split()方法去掉换行符：

c = '''say
hello
baby'''

print(c)
# say
# hello
# baby

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

字符串中多重split(方法：

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', 'rn', n')分隔，返回一个包含各行作为元素的列表，如果参数`keepends`为 False，不包含换行符，如果为 True，则保留换行符。

str6 = 'I n Love n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I n', ' Love n', ' LsgoGroup']

- `maketrans(intab, outtab[，deltab])` 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标,第三个参数是可选参数，可删除指定字符。

- `translate(table, deletechars="")` 根据参数`table`给出的表，转换字符串的字符，要过滤掉的字符放到`deletechars`参数中。

makertran()函数经常和translate()函数配合使用

intab = "aeiou"
outtab = "12345"
deltab = "thw"
 
trantab1 = str.maketrans(intab,outtab) # 创建字符映射转换表
trantab2 = str.maketrans(intab,outtab,deltab) #创建字符映射转换表，并删除指定字符
 
test = "this is string example....wow!!!"
print(trantab1)
print(test.translate(trantab1))
print(test.translate(trantab2))
'''
以上实例输出结果如下：
{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
th3s 3s str3ng 2x1mpl2....w4w!!!
3s 3s sr3ng 2x1mpl2....4!!!
'''

9.字符串的格式化方法

format 格式化方法

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

- Python 字符串格式化符号

%c | 格式化字符及其ASCII码

%s | 格式化字符串，用str()方法处理对象

%r | 格式化字符串，用rper()方法处理对象

%d | 格式化整数

%o | 格式化无符号八进制数

%x | 格式化无符号十六进制数

%X | 格式化无符号十六进制数（大写）

%f | 格式化浮点数字，可指定小数点后的精度

%e | 用科学计数法格式化浮点数

%E | 作用同%e，用科学计数法格式化浮点数

%g | 根据值的大小决定使用%f或%e

%G | 作用同%g，根据值的大小决定使用%f或%E

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

格式化操作辅助指令：

`m.n` | m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）

`-` | 用作左对齐

`+` | 在正数前面显示加号( + )

`#` | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

`0` | 显示的数字前面填充'0'而不是默认的空格

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

三、学习问题与解答(analysis)

.列表-作业：

1、列表操作练习

列表lst 内容如下

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

请写程序完成下列操作：

1. 在列表的末尾增加元素15

2. 在列表的中间位置插入元素20

3. 将列表[2, 5, 6]合并到lst中

4. 移除列表中索引为3的元素

5. 翻转列表里的所有元素

6. 对列表里的元素进行排序，从小到大一次，从大到小一次

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15)
print(lst)
lst.insert(5,20)
print(lst)
list=[2,5,6]
lst.extend(list)
print(lst)
lst.pop(3)
print(lst)
lst.reverse()
print(lst)
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)

'''输出：
[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
'''

2、修改列表

问题描述：lst = [1, [4, 6], True]

请将列表里所有数字修改成原来的两倍

lst = [1, [4, 6], True]
lst[0]*=2
lst[1][0]*=2
lst[1][1]*=2
print(lst)
'''输出：
[2, [8, 12], True]
'''

3.山脉数组索引

class Solution:
    def peakIndexInMountainArray(self, A: List[int]) -> int:
        return A.index(max(A))

另一种使用循环方法：

class Solution:
    def peakIndexInMountainArray(self, A: List[int]) -> int:
        for i in range(1,len(A)-1):
            if A[i]>A[i+1]:
                return i
                

元组-练习题：

1、元组概念

写出下面代码的执行结果和最终结果的类型

(1, 2)*2

(1, )*2

(1)*2`分析为什么会出现这样的结果.？

'''结果：
(1,2,1,2)
(1,1)
2
分析：元组与数字相乘相当于把元组的内容复制
非元组类型不能复制
'''

2、拆包过程是什么？不知道

a, b = 1, 2

上述过程属于拆包吗？属于

可迭代对象拆包时，怎么赋值给占位符？用*

3.字符串-练习：

1、字符串函数回顾

- 怎么批量替换字符串中的元素？使用

- 怎么把字符串按照空格进⾏拆分？使用split()方法

- 怎么去除字符串⾸位的空格？使用ljust()方法

2、实现isdigit函数

实现函数isdigit， 判断字符串里是否只包含数字0~9

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

四、学习思考与总结（summary）

本次学习进度很慢，效率也相对下降。在这个学习过程中有太多陌生的知识点没有完全掌握，练习也没能完成全部。希望再接再厉吧！