Task 4: 列表、元组和字符串(3天)

一、列表

1.列表的定义

2.列表的创建

3.向列表添加元素

4.删除列表中的元素

5.获取列表中的元素

6.列表的常用操作符

7.列表的其他方法

二、元组

1.创建和访问一个元组

2.更新和删除一个元组

3.元组相关的操作符

4.内置方法

5.解压元组

三、字符串

1.字符串的定义

2.字符串的切片和拼接

3.字符串的常用内置方法

4.字符串格式化

 

正文

一、列表

1.列表的定义

列表（list）：有序集合，可以随时添加和删除其中的元素

#中括号[]把所有元素放在一起，逗号,将每个元素分开
[元素1, 元素2, ..., 元素n]

2.列表的创建

#元素是字符类型
x=['monday','tuesday','wednesday','thursday','friday']
print(x,type(x))


#元素是int 
x=[1,2,3,4]
print(x,type(x))


#使用range()创建list
x=list(range(10))


#利用推导式创建list
x=[0]*5  #[0, 0, 0, 0, 0]

x=[0 for i in range(5)]  #列表生成器


#创建一个4x3的二维数组
x=[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]


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


#[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x=[[0]*3 for row in range(4)]

list的元素可以是任何对象，list所保存的是对象的指针

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上

3.向列表中添加元素

list.append(obj)：在list末尾添加新的对象，只接受一个采纳数，参数可以是任意数据类型

 

#appned()
x=[1,2,3]
x.append(1)  #[1, 2, 3, 1]
x.append('a')  #[1, 2, 3, 1, 'a']

#如果元素是一个list，那么这个list将作为一个整体进行追加
x.append([1,2,3])  #[1, 2, 3, 1, 'a', [1, 2, 3]]

 

list.extend(sed)：在列表末尾一次性追加另一个序列（可迭代对象iterable）中的多个值（用新列表扩展原来的列表）

#extend()，里面是一个可迭代对象，字符串或者list，tuple，dict 等
x=[1,2,3]
x.extend(1)   #TypeError: 'int' object is not iterable
x.extend('a')   #[1, 2, 3, 'a']
x.extend([1])   # [1, 2, 3, 'a', 1]
x.extend((1))   #TypeError: 'int' object is not iterable，单个元素时，tuple要加上,号才能构成tuple
x.extend((1,)) #[1, 2, 3, 'a', 1, 1]  
x.extend({'a':1,'b':2}) #[1, 2, 3, 'a', 1, 1, 'a', 'b']
x.extend([1,2,3]) #[1, 2, 3, 'a', 1, 1, 'a', 'b', 1, 2, 3]

list.insert(index,obj)：在编号index位置插入obj

#insert()
x=[1,2,3]
x.insert(0,1)  #在index为0的位置插入1   [1, 1, 2, 3]
x.insert(1,[1,2,3])  #插入list  [1, [1, 2, 3], 1, 2, 3]
x.insert(1,(1,2,3))  #插入tuple [1, (1, 2, 3), [1, 2, 3], 1, 2, 3]
x.insert(1,{'a':1,'b':2})  #[1, {'a': 1, 'b': 2}, (1, 2, 3), [1, 2, 3], 1, 2, 3]
x.insert('a')  #报错，要输入2个参数

4.删除列表中的元素

list.remove(obj)：移除list中某个值的第一个匹配值

#remove(),如果list表没有这个元素将会报错
x=[1,2,3,1,2,3]
x.remove(1)   #[2, 3, 1, 2, 3]
x.remove(4)   #ValueError: list.remove(x): x not in list

#remove是精准匹配，不是模糊匹配
x=['as','aa','b','a']
x.remove('a')  #['as', 'aa', 'b']

list.pop(index)：删除指定索引的元素，默认是最后一个元素，并且返回该元素的值

#pop ，index不能超出索引
x=[1,2,3,1,2,3]
x.pop()   #默认删除最后一个元素 [1, 2, 3, 1, 2]
x.pop(1)  #[1, 3, 1, 2]
x.pop(100)  #IndexError: pop index out of range

del ：删除单个或者多个对象

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

总结：

remove和 pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()


 

5.获取列表中的元素

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

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

 

 

x=[1,2,3]
x[0]  #输出1
x[-1]  #3
x[-2]  #2

切片的通用写法：记住，都是左闭右开

start:stop:step

(1)  start :

(2) : stop

(3) start : stop

(4) start : stop : step

(5)  :

x=['as','aa','b','a']
x[2:]  #['b', 'a']
x[-2:] #['b', 'a']

x[:2]  #['as', 'aa']
x[:-2]  #['as', 'aa']

x[1:3]  #['aa', 'b']
x[-1:-3]  #[]  ,如果都是负的要重小到大
x[1:-1]  #['aa', 'b']
x[-3:-1]  #['aa', 'b']


x[1:3:2]  #['aa']
x[:2:2]  #['as']
x[1::2]  #['aa', 'a']
x[::-1]  #['a', 'b', 'aa', 'as'] 从后面取起

x[:]  #['as', 'aa', 'b', 'a']  复制整个list
x[]  #SyntaxError: invalid syntax

 

6.列表的常用操作符

等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in

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

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

x=[1,2,3]
y=[1,2,3]
x==y   #True
x[::-1]==  #False  需要元素和对应的位置都一样

x+y  #[1, 2, 3, 1, 2, 3]

x*3  #[1, 2, 3, 1, 2, 3, 1, 2, 3]

a in x  #False
1 in x   #True
[1,2] in x  #False  注意要是元素
1  not in x  #False

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象

而操作符运算都没有改变原数据

7.列表的其他方法

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

list中没有该元素，则返回0

x=[1,2,3]*3
x.count(1)  #3
x.count(4)  #没有的元素，则返回0

list.index(x[,start[,end]])：找到某个元素第一个匹配项的索引位置

#如果该元素不在list中，则报错
x=[1,2,3]*5
x.index(1)  #0
x.index(1,1)  # 3
x.index(1,3,7)  #3
x.index(4)  #报错ValueError: 4 is not in list

list.reverse()：反向list中的元素

#不返回值，但是已经改变原数据的值
x=[1,2,3]
x.reverse()  #[3, 2, 1]

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

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

x=[1,2,3]*3
x.sort()  #[1, 1, 1, 2, 2, 2, 3, 3, 3]

x.sort(reverse=True)  #[3, 3, 3, 2, 2, 2, 1, 1, 1]

def takeSecond(elem):
    return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)  #将第二个元素放在前面

x.sort(key=lambda a: a[0])

 

二、元组

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

(元素1, 元素2, ..., 元素n)

小括号把所有元素绑在一起
逗号将每个元素一一分开

list和tuple的区别

Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。

 

1.创建和访问一个元组

#创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
type(t1),type(t2)  #(tuple, tuple)


#元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
x = (1)
print(type(x))  # <class 'int'>
x=(1,)
print(type(x)) #<class 'tuple'>

#空的tuple
x=()
x=( )
len(()),len(( ))

#访问
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1])  # 2
print(tuple1[5:])  # (6, 7, 8)
print(tuple1[:5])  # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2)  # (1, 2, 3, 4, 5, 6, 7, 8)

#创建二维元组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))

print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python

print(x[0][0:2])
# (1, 10.31)

2.更新和删除一个元组

#元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值
x=(1,2,3)
x[3]=4   #TypeError: 'tuple' object does not support item assignment

#如果元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同
t1 = (1, 2, 3, [4, 5, 6])  #因为第四个元素对应的是list，二list是可变可赋值的
t1[3][0] = 9  #(1, 2, 3, [9, 5, 6])

3.元组相关的操作符

等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in

和list内容基本一致，就不赘述了

4.内置方法

元组大小和内容都不可更改，因此只有 count 和 index 两种方法

t = (1, 10.31, 'python')
print(t.count('python'))  # 1
print(t.index(10.31))  # 1

5.解压元组（没有接触过）

#解压一维元组（（有几个元素左边括号定义几个变量），怎么看着这么像是多元赋值
(a,b,c)=(1, 10.31, 'python')
print(a,b,c)  #1 10.31 python
#多元赋值
a,b,c=1, 10.31, 'python'


#解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

#如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

#如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)  # 1 2

 

三、字符串

1.字符串的定义：

Python 中字符串被定义为引号之间的字符集合。
Python 支持使用成对的 单引号 或 双引号。

python常用的转义字符

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符(TAB)
\r	回车

注意：

如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义
原始字符串只需要在字符串前边加一个英文字母 r 即可
三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

我在另一篇文章正则表达式里面有说过https://www.cnblogs.com/cgmcoding/p/13365949.html，这里就不赘述了

2.字符串的切片于拼接

类似于元组具有不可修改性
从 0 开始 (和 Java 一样)
切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。
索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1

主要看看是否可以直接赋值和切片有step吗

#注意是一个字母一个位置
str1 = 'I Love LsgoGroup'
len(str1)  #16 而非3


#不可以赋值
s='python'
s[6]='s'  #TypeError: 'str' object does not support item assignment

#可以使用step
s[1:4:2]  #'yh'

3.字符串的常用内置方法

capitalize() 将字符串的第一个字符转换为大写
lower() 转换字符串中所有大写字符为小写
upper() 转换字符串中的小写字母为大写
swapcase() 将字符串中大写转换为小写，小写转换为大写
count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查
startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1
rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找
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()方法，不过是从右边开始查找
replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次
split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表
splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符
maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中

大小写转换

#capitalize() 将字符串的第一个字符转换为大写，用于名字或者书名
s='python'
s.capitalize()

str2 = "DAXIExiaoxie"
print(str2.lower())  # daxiexiaoxie
print(str2.upper())  # DAXIEXIAOXIE
print(str2.swapcase())  # daxieXIAOXIE

#如果将list每个元素的首字母为大小，其他为小写
def f(a):
    return(a.lower().capitalize())
l=['toM','joB','mAy','maRy']
l=list(map(f,l))

#或者
l=['toM','joB','mAy','maRy']
l=list(map(lambda x:x.lower().capitalize(),l))

count，endswith,startswith

#count,list里面有细说，这里主要说一下endswith,startswith
str2 = "DAXIExiaoxie"
print(str2.count('xi'))  # 2

#返回的是布尔值
str2 = "DAXIExiaoxie"
print(str2.endswith('ie'))  # True
print(str2.endswith('xi'))  # False
print(str2.startswith('Da'))  # False
print(str2.startswith('DA'))  # True

find,rfind

#find() ,检测str是否包含在字符串中，如果包含，返回开始的索引值，否知返回-1
#rfind()从右边开始
str2 = "DAXIExiaoxie"
print(str2.find('xi'))  # 5
print(str2.find('ix'))  # -1
print(str2.rfind('xi'))  # 9

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

str3 = '12345'
print(str3.isnumeric())  # True
str3 += 'a'
print(str3.isnumeric())  # False

ljust,rjust

#ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串
#rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串
str4 = '1101'
print(str4.ljust(8, '0'))  # 11010000
print(str4.rjust(8, '0'))  # 00001101

#如果长度少于字符串的长度
print(str4.ljust(3, '0'))  #1101
print(str4.ljust(0, '0')) #1101

去空格

#lstrip删除字符串左边的空格或者这顶字符串
#rstrip([chars]) 删除字符串末尾的空格或指定字符
#strip([chars]) 在字符串上执行lstrip()和rstrip()

str5 = ' I Love LsgoGroup '
print(str5.lstrip())  # 'I Love LsgoGroup '
print(str5.lstrip().strip('I'))  # ' Love LsgoGroup '
print(str5.rstrip())  # ' I Love LsgoGroup'
print(str5.strip())  # 'I Love LsgoGroup'
print(str5.strip().strip('p'))  # 'I Love LsgoGrou'

partition 和rpartition

#partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')
#rpartition(sub)类似于partition()方法，不过是从右边开始查找
#如果字符串中不包含sub则返回('原字符串','','')

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 替换

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

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

split 分割，分列

#split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果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，则保留换行符

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

maketrans和translate

#maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
#translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中

str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

 

4.字符串格式化

.format格式化函数

我的其他文章有详细说过：https://www.cnblogs.com/cgmcoding/p/13278298.html，这里就不赘述了

字符串格式化符号

符 号	描述
%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

 

作业：

列表

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)  #[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
lst.insert(5,20)  #[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
lst.extend([2,5,6])  #[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]  
#或者是lst=lst+[2,5,6]
lst.pop(3)  #[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
lst.reverse()  #[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
#或者是lst=lst[::-1]
lst.sort(reverse = False)  #[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
lst.sort(reverse=True)  #[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]

2、修改列表

问题描述：

lst = [1, [4, 6], True]

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

#使用到闭包和  isinstance()函数
def double_list(lst):
    for index, item in enumerate(lst):
        if isinstance(item, bool):
            continue
        if isinstance(item, (int, float)):
            lst[index] *= 2
        if isinstance(item, list):
            double_list(item)


if __name__ == '__main__':
    lst = [1, [4, 6], True]
    double_list(lst)
    print(lst)

3、leetcode 852题 山脉数组的峰顶索引

题目都说不清楚，不写了

元组练习题：

1、元组概念

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

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

代码，分析就不多说了，请看上面教程

print((1, 2)*2,type((1, 2)*2))  #(1, 2, 1, 2) <class 'tuple'>  
print((1, )*2,type((1, )*2))  #(1, 1) <class 'tuple'>
print((1)*2,type((1)*2))  #2 <class 'int'>

2、拆包过程是什么？

a, b = 1, 2

我一直认为这个是多元赋值，疑惑

字符串练习题

1、字符串函数回顾

怎么批量替换字符串中的元素？
怎么把字符串按照空格进⾏拆分？
怎么去除字符串⾸位的空格？

回答：

1.str.replace(old, new)
2.str.split(' ')
3.先判断首位是否是空格，如果是就去掉，不是就留下，
if str[0]==' ':
    str=str[1:]
else:
    str=str[::]

2、实现isdigit函数

题目要求

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

def isdigit(string):
    while string.isnumeric():
        print('{}是只包括数字0-9'.format(string))
        break
    else:
        print('{}非只包括数字0-9'.format(string))

3、leetcode 5题 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000