一、序列
序列,指的是一块可存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问它们。
为了更形象的认识序列,可以将它看做是一家旅店,那么店中的每个房间就如同序列存储数据的一个个内存空间,每个房间所特有的房间号就相当于索引值。也就是说,通过房间号(索引)我们可以找到这家旅店(序列)中的每个房间(内存空间)。
在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。
字符串也是一种常见的序列,它也可以直接通过索引访问字符串内的字符。
1.序列索引
序列中,每个元素都有属于自己的编号(索引)。从起始元素开始,索引值从 0 开始递增,如图 1 所示。
图 1 序列索引值示意图
Python 还支持索引值是负数,此类索引是从右向左计数,换句话说,从最后一个元素开始计数,从索引值 -1 开始,如图 2 所示。
图 2 负值索引示意图
在使用负值作为列序中各元素的索引值时,是从 -1 开始,而不是从 0 开始。
无论是采用正索引值,还是负索引值,都可以访问序列中的任何元素。
2.检查元素是否包含在序列中
Python 中,可以使用 in 关键字检查某元素是否为序列的成员,其语法格式为:
value in sequence
value 表示要检查的元素,sequence 表示指定的序列。
检查字符‘c’是否包含在字符串“c.biancheng.net”中,可以执行如下代码:
str="c.biancheng.net"
print('c'in str)
True
not in 关键字,检查某个元素是否不包含在指定的序列中
str="c.biancheng.net"
print('c' not in str)
输出结果为:
False
3.和序列相关的内置函数
Python提供了几个内置函数,可用于实现与序列相关的一些常用操作。
str="c.biancheng.net"
#找出最大的字符
print(max(str))
#找出最小的字符
print(min(str))
#对字符串中的元素进行排序
print(sorted(str))
输出结果为:
t
.
['.', '.', 'a', 'b', 'c', 'c', 'e', 'e', 'g', 'h', 'i', 'n', 'n', 'n', 't']
4.序列切片
切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。
序列实现切片操作的语法格式如下:
sname[start : end : step]
其中,各个参数的含义分别是:
sname:表示序列的名称;
start:表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;
end:表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;
step:表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,也就是说,如果 step 的值大于 1,则在进行切片去序列元素时,会“跳跃式”的取元素。如果省略设置 step 的值,则最后一个冒号就可以省略。
str="python练习学习"
#取索引区间为[0,2]之间(不包括索引2处的字符)的字符串
print(str[:2])
#隔 1 个字符取一个字符,区间是整个字符串
print(str[::2])
#取整个字符串,此时 [] 中只需一个冒号即可
print(str[:])
运行结果为:
py
pto
python练习学习
二、列表
列表
Python 中没有数组,但是加入了更加强大的列表。如果把数组看做是一个集装箱,那么 Python 的列表就是一个工厂的仓库。
1.列表的定义
列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。
关键点是「中括号 []」和「逗号 ,」
中括号 把所有元素绑在一起
逗号 将每个元素一一分开
2. 列表的创建
创建一个普通列表
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
利用range()创建列表
x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
创建一个二维数组
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>
由于list的元素可以是任何对象,因此列表中所保存的是***对象的指针***。即使保存一个简单的[1,2,3],也有3个指针和3个整数对象。
创建一个空列表
empty = []
print(empty, type(empty))
# [] <class 'list'>
列表不像元组,列表 内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
3.向列表中添加元素
list.append(obj) 在列表末尾添加新的对象,只接受一个参数,参数可以是任何数据类型,被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
append()和extend()的区别。
append()
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
extend()
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
append 是追加,把一个东西整体添加在列表后,而 extend 是扩展,把一个东西里的所有元素添加在列表后。
list.insert(index, obj) 在编号 index 位置插入 obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
4.删除列表中的元素
list.remove(obj) 移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove 和 pop 都可以删除元素,前者是指定具体要删除的元素,后者是指定一个索引。
del var1[, var2 ……] 删除单个或多个对象。
知道要删除的元素在列表中的位置,可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
从列表中删除一个元素,不再使用,使用del语句;
在删除元素后还能继续使用就使用方法pop()。
5.列表的其它方法
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]]) 从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
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]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
三、元组
元组(tuple)是 Python 中另一个重要的序列结构,和列表类似,元组也是由一系列按特定顺序排序的元素组成。
元组和列表(list)的不同之处在于:
列表的元素是可以更改的,包括修改元素值,删除和插入元素,所以 列表 是 可变序列 ;
而元组一旦被创建,它的元素就不可更改了,所以 元组 是 不可变序列 。
元组也可以看做是不可变的列表,通常情况下,元组用于保存无需修改的内容。
元组
「元组」定义语法为:(元素1, 元素2, ..., 元素n)
元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同。
小括号把所有元素绑在一起,逗号将每个元素一一分开。
1.创建和访问一个元组
元组与列表类似,也用整数来对它进行索引 (indexing) 和切片 (slicing)。
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)
print(type(x)) # <class 'int'>
x = 2, 3, 4, 5
print(type(x)) # <class 'tuple'>
x = []
print(type(x)) # <class 'list'>
x = ()
print(type(x)) # <class 'tuple'>
x = (1,)
print(type(x)) # <class 'tuple'>
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.更新和删除一个元组
元组是不可变序列,元组中的元素不能被修改,所以我们只能创建一个新的元组去替代旧的元组。
例如,对元组变量进行重新赋值:
tup = (100, 0.5, -36, 73)
print(tup)
运行结果为:
(100, 0.5, -36, 73)
#对元组进行重新赋值
tup = ('Shell脚本',"http://c.biancheng.net/shell/")
print(tup)
运行结果为:
('Shell脚本', 'http://c.biancheng.net/shell/')
通过连接多个元组(使用+可以拼接元组)的方式向元组中添加新元素,例如:
tup1 = (100, 0.5, -36, 73)
tup2 = (3+12j, -54.6, 99)
print(tup1+tup2)
运行结果为:
(100, 0.5, -36, 73, (3+12j), -54.6, 99)
print(tup1)
(100, 0.5, -36, 73)
print(tup2)
((3+12j), -54.6, 99)
元组拼接有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
Python删除元组
当创建的元组不再使用时,可以通过 del 关键字将其删除
tup = ('Java教程',"http://c.biancheng.net/java/")
print(tup)
del tup
print(tup)
运行结果为:
('Java教程', 'http://c.biancheng.net/java/')
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in <module>
print(tup)
NameError: name 'tup' is not defined
Python 自带垃圾回收功能,会自动销毁不用的元组,所以一般不需要通过 del 来手动删除。
3.内置方法
元组大小和内容都不可更改,只有 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
4.解压元组
个人理解是将元祖中的元素分成一个个。
解压(unpack)一维元组(有几个元素左边括号定义几个变量)
t = (1, 10.31, 'python')
(a, b, c) = t
print(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]
四、字符串
1.字符串的定义
若干个字符的集合就是一个字符串(String)。Python 中的字符串必须由双引号" "或者单引号’ '包围:
"字符串内容"
'字符串内容'
字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。
字符串内容中出现引号时,我们需要进行转义,否则 Python 会解析出错。
字符串的换行
Python 不是格式自由的语言,它对程序的换行、缩进都有严格的语法要求。要想换行书写一个比较长的字符串,必须在行尾添加反斜杠\,
s2 = 'It took me six months to write this Python tutorial.\
Please give me more support.\
I will keep it updated.'
三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。
para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( )。
# 也可以使用换行符 [
# ]。
Python 支持原始字符串。在原始字符串中,\不会被当作转义字符,所有的内容都保持“原汁原味”的样子。
在普通字符串或者长字符串的开头加上r前缀,就变成了原始字符串。
print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help
2.字符串的常用内置方法
capitalize() 将字符串的第一个字符转换为大写。
str2 = 'xiaoxie'
print(str2.capitalize()) # Xiaoxie
lower() 转换字符串中所有大写字符为小写。
upper() 转换字符串中的小写字母为大写。
swapcase() 将字符串中大写转换为小写,小写转换为大写。
str2 = "DAXIExiaoxie"
print(str2.lower()) # daxiexiaoxie
print(str2.upper()) # DAXIEXIAOXIE
print(str2.swapcase()) # daxieXIAOXIE
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 指定值,则在指定范围内检查。
startswith(substr, beg=0,end=len(string))
检查字符串是否以指定子字符串 substr 开头,如果是,返回 True,否则返回 False。如果 beg 和 end 指定值,则在指定范围内检查。
str2 = "DAXIExiaoxie"
print(str2.endswith('ie')) # True
print(str2.endswith('xi')) # False
print(str2.startswith('Da')) # False
print(str2.startswith('DA')) # True
find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end,则检查是否包含在指定范围内,如果包含,返回开始的索引值,否则返回 -1。
rfind(str, beg=0,end=len(string)) 类似于 find() 函数,不过是 从右边 开始查找。
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(width[, fillchar])返回一个原字符串左对齐,并使用fillchar(默认空格)填充至长度width的新字符串。
rjust(width[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度width的新字符串。
str4 = '1101'
print(str4.ljust(8, '0')) # 11010000
print(str4.rjust(8, '0')) # 00001101
lstrip([chars]) 截掉字符串左边的空格或指定字符。
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(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次。
str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We')) # We Love LsgoGroup
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(".", 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']
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(intab, outtab) 创建字符映射的转换表,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
translate(table, deletechars="") 根据参数table给出的表,转换字符串的字符,要过滤掉的字符放到deletechars参数中。
s
tr7 = '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!!!
3.字符串格式化
在 print() 函数中,由引号包围的是格式化字符串,它相当于一个字符串模板,可以放置一些转换说明符(占位符)。本例的格式化字符串中包含一个%s说明符,它最终会被后面的 age 变量的值所替代。
中间的%是一个分隔符,它前面是格式化字符串,后面是要输出的表达式。
当然,格式化字符串中也可以包含多个转换说明符,这个时候也得提供多个表达式,用以替换对应的转换说明符;多个表达式必须使用小括号( )包围起来。请看下面的例子:
name = "C语言中文网"
age = 8
url = "http://c.biancheng.net/"
print("%s已经%d岁了,它的网址是%s。" % (name, age, url))
指定最小输出宽度
当使用表1中的转换说明符时,可以使用下面的格式指定最小输出宽度(至少占用多少个字符的位置):
%10d 表示输出的整数宽度至少为 10;
%20s 表示输出的字符串宽度至少为 20。
指定对齐方式
默认情况下,print() 输出的数据总是右对齐的。也就是说,当数据不够宽时,数据总是靠右边输出,而在左边补充空格以达到指定的宽度。Python 允许在最小宽度之前增加一个标志来改变对齐方式,Python 支持的标志如下:
对于整数,指定左对齐时,在右边补 0 是没有效果的,因为这样会改变整数的值。
对于小数,以上三个标志可以同时存在。
对于字符串,只能使用-标志,因为符号对于字符串没有意义,而补 0 会改变字符串的值。
n = 123456
# %09d 表示最小宽度为9,左边补0
print("n(09):%09d" % n)
运行结果:
n(09):000123456
# %+9d 表示最小宽度为9,带上符号
print("n(+9):%+9d" % n)
运行结果:
n(+9): +123456
f = 140.5
# %-+010f 表示最小宽度为10,左对齐,带上符号
print("f(-+0):%-+010f" % f)
运行结果:
f(-+0):+140.500000
s = "Hello"
# %-10s 表示最小宽度为10,左对齐
print("s(-10):%-10s." % s)
运行结果:
s(-10):Hello .
指定小数精度
对于小数(浮点数),print() 还允许指定小数点后的数字位数,也即指定小数的输出精度。
精度值需要放在最小宽度之后,中间用点号.隔开;也可以不写最小宽度,只写精度。具体格式如下:
%m.nf
%.nf
m 表示最小宽度,n 表示输出精度,.是必须存在的。
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
lst.append(15)
在列表的中间位置插入元素20
lst.insert(5,20)
将列表[2, 5, 6]合并到lst中
移除列表中索引为3的元素
翻转列表里的所有元素
对列表里的元素进行排序,从小到大一次,从大到小一次
2、修改列表
问题描述:
lst = [1, [4, 6], True]
请将列表里所有数字修改成原来的两倍
3、leetcode 852题 山脉数组的峰顶索引
如果一个数组k符合下面两个属性,则称之为山脉数组
数组的长度大于等于3
存在 i i i, i i i >0 且 i < len ( k ) − 1 i<\operatorname{len}(k)-1 i<len(k)−1, 使得 k [ 0 ] < k [ 1 ] < … < k [ i − 1 ] < k [ j ] > k [ i + 1 ] … > k [ len ( k ) − 1 ] \mathrm{k}[0]<\mathrm{k}[1]<\ldots<\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1] \ldots>\mathrm{k}[\operatorname{len}(\mathrm{k})-1] k[0]<k[1]<…<k[i−1]<k[j]>k[i+1]…>k[len(k)−1]
这个 i i i就是顶峰索引。
现在,给定一个山脉数组,求顶峰索引。
示例:
输入:[1, 3, 4, 5, 3]
输出:True
输入:[1, 2, 4, 6, 4, 5]
输出:False
class Solution:
def peakIndexInMountainArray(self, A: List[int]) -> int:
# your code here
4、元组概念
写出下面代码的执行结果和最终结果的类型
(1, 2)*2
(1, )*2
(1)*2
分析为什么会出现这样的结果.
5、拆包过程是什么?
a, b = 1, 2
上述过程属于拆包吗?
可迭代对象拆包时,怎么赋值给占位符?
6、字符串函数回顾
怎么批量替换字符串中的元素?
怎么把字符串按照空格进⾏拆分?
怎么去除字符串⾸位的空格?
7、实现isdigit函数
题目要求
实现函数isdigit, 判断字符串里是否只包含数字0~9
def isdigit(string):
“”"
判断字符串只包含数字
:param string:
:return:
“”"
8、leetcode 5题 最长回文子串
给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例:
输入: “babad”
输出: “bab”
输入: “cbbd”
输出: “bb”