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.列表的常用操作符
1 等号操作符：== 2 连接操作符 + 3 重复操作符 * 4 成员关系操作符 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进行排序
1 key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 2 reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。 3 该方法没有返回值，但是会对列表的对象进行排序
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的区别
1 Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。 2 元组使用小括号，列表使用方括号。 3 元组与列表类似，也用整数来对它进行索引 (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.元组相关的操作符
1 等号操作符：== 2 连接操作符 + 3 重复操作符 * 4 成员关系操作符 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.字符串的定义：
1 Python 中字符串被定义为引号之间的字符集合。 2 Python 支持使用成对的 单引号 或 双引号。
python常用的转义字符
| 转义字符 | 描述 |
|---|---|
\\ |
反斜杠符号 |
\' |
单引号 |
\" |
双引号 |
\n |
换行 |
\t |
横向制表符(TAB) |
\r |
回车 |
注意：
1 如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义 2 原始字符串只需要在字符串前边加一个英文字母 r 即可 3 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
我在另一篇文章正则表达式里面有说过https://www.cnblogs.com/cgmcoding/p/13365949.html，这里就不赘述了
2.字符串的切片于拼接
1 类似于元组具有不可修改性 2 从 0 开始 (和 Java 一样) 3 切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。 4 索引值可正可负，正索引从 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.字符串的常用内置方法
1 capitalize() 将字符串的第一个字符转换为大写 2 lower() 转换字符串中所有大写字符为小写 3 upper() 转换字符串中的小写字母为大写 4 swapcase() 将字符串中大写转换为小写，小写转换为大写 5 count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数 6 endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查 7 startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查 8 find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1 9 rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找 10 isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False 11 ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串 12 rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串 13 lstrip([chars]) 截掉字符串左边的空格或指定字符 14 rstrip([chars]) 删除字符串末尾的空格或指定字符 15 strip([chars]) 在字符串上执行lstrip()和rstrip() 16 partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','') 17 rpartition(sub)类似于partition()方法，不过是从右边开始查找 18 replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次 19 split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表 20 splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符 21 maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标 22 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]
请写程序完成下列操作：
- 在列表的末尾增加元素15
- 在列表的中间位置插入元素20
- 将列表[2, 5, 6]合并到lst中
- 移除列表中索引为3的元素
- 翻转列表里的所有元素
- 对列表里的元素进行排序，从小到大一次，从大到小一次
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 怎么批量替换字符串中的元素？ 2 怎么把字符串按照空格进⾏拆分？ 3 怎么去除字符串⾸位的空格？
回答：
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
