1. 列表
列表:有序集合,大小不固定,其元素可以是任意类型的python对象(即列表中所保存的是对象的指针,一个简单对象,如[1,2,3]
也有3个指针和3个整数对象)。[元素1, 元素2, ... , 元素n]
列表操作:
(1)创建:
直接使用中括号创建;
利用range()函数创建,x = list[range(10)]
;
利用推导式创建,x = [a] * 5 # 创建5个指向list的引用,a改变,x中的所有a也会改变
, x = [0 for i in range(5)]
创建空列表可以直接使用一个[]
。
(2)方法:
append、extend、insert、remove、pop 等。
1)添加元素:
list.append(obj)
在末尾添加一个任意类型的元素(整体)。(追加)无返回值,是直接在原列表上修改。
list.extend(seq)
在末尾一次性添加另一个序列的多个元素。(扩展)无返回值,是直接在原列表上修改。
2)插入:
list.insert(index, obj)
在编号index位置插入obj。无返回值,是直接在原列表上修改。
3)删除:
list.remove(obj)
移除列表中第一个匹配值。obj为列表的元素。(指定值)
list.pop() # list.pop([index=-1])
移除列表中一个元素,默认为最后一个,有返回值,并返回该元素的值。(指定索引)
del x[0:2]
删除单个或多个对象。
4)获取列表中的元素:
通过索引获取,从左到右从0开始;通过将索引指定为负值,可以倒数返回,从左到右列表最后一个值索引为-1。
通过切片获取:start: stop: step
,step默认为1,含头不含尾。当三个参数都不存在时,复制列表中所有元素(浅拷贝);
区别:直接赋值、浅拷贝、深拷贝
直接赋值:其实就是对象的引用(别名)。
浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。
深拷贝(deepcopy):copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。
参考:https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort() # 只有深拷贝改变
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111 # 两者都改变
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
5)操作符:
其结果都是一个列表。
等号操作符 ==;
连接操作符 + 实现首位拼接,需要额外空间,创建新的 list;
重复操作符 * 实现复制拼接;
成员关系操作符 in、not in。
6)其他方法:
list.count(obj)
统计某个元素在列表中出现的次数;
list.index(obj)
统计某个元素在列表中出现的次数;
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()
反向列表中元素;
list.sort(key=None, reverse=False)
对原列表进行排序;key用来比较的元素,只有一个参数;reverse排序规则,True为降序,False为升序;没有返回值;
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond) # key 2,4,1,3
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0]) # key 2,3,4,1
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
练习:
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)
print(lst)
mid = int(len(lst) / 2)
lst.insert(mid, 20)
print(lst)
lst.extend([2, 5, 6])
print(lst)
lst.pop(3)
print(lst)
lst.reverse()
print(lst)
lst.sort(reverse=False)
print(lst)
lst.sort(reverse=True)
print(lst)
2、修改列表
问题描述:lst = [1, [4, 6], True],请将列表里所有数字修改成原来的两倍。
lst = [1, [4, 6], True]
def fanbei(n):
for i in range(len(n)):
if type(n[i]) == int:
n[i] = n[i] * 2
elif type(n[i]) == list:
m = n[i]
fanbei(m)
else:
pass
fanbei(lst)
print(lst)
# [2, [8, 12], True]
3、leetcode 852题 山脉数组的峰顶索引
leetcode地址:https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/
直接从头遍历找到最大值,代码略。
二分法:
class Solution:
def peakIndexInMountainArray(self, A: List[int]) -> int:
start = 0
stop = len(A)-1
mid = int((start+stop)/2)
while(A[mid-1]>A[mid])or(A[mid]<A[mid+1]):
if A[mid-1]>A[mid]:
stop = mid
mid = int((start+stop)/2)
if A[mid]<A[mid+1]:
start = mid
mid = int((start+stop)/2)
return mid
一行代码:
class Solution:
def peakIndexInMountainArray(self, A: List[int]) -> int:
return A.index(max(A))
2. 元组
元组:创建后无法修改,可以索引和切片。(元素1, 元素2, ... , 元素n)
元组操作:
(1)创建:
创建元组要用小括号(),也可以什么都不用。元组只有一个元素时,需要在元素后面加逗号,防止括号被当作运算符。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python') <class 'tuple'>
print(t2, type(t2))
# (1, 10.31, 'python') <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)方法:
1)更新和删除:
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元组不可更改,它的元素不能被直接赋值;但是其中的元素如果可以被更改(如元组中的元素是一个列表),可以直接更改其元素。
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])
2)相关操作符:
同列表的操作符 ==、+、*、in、not in
3)count:
tuple.count(obj)
记录元素obj在该元组中出现几次
4)index:
tuple.index(obj)
找到元素obj在元组中的索引
5)解压(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,在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。
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
如果只写一个下划线「_」,这个下划线只是个变量,相当于上面例子中的a。
练习:
1、元组概念
写出下面代码的执行结果和最终结果的类型,分析为什么会出现这样的结果。
(1, 2)*2 # (1,2,1,2)
(1, )*2 # (1,1)
(1)*2 # 2
2、拆包过程是什么?可迭代对象拆包时,怎么赋值给占位符?a, b = 1, 2
属于拆包吗?
拆包:对于多个返回数据,去掉元组、列表或者字典,直接获取里面数据的过程。对字典拆包得到的是key,而不是value。
可迭代对象拆包:需要变量数量和元素数量一致。
a, b = 1, 2
属于直接赋值。不属于拆包。
3. 字符串
(1)常用转义符
\ 反斜杠符号
’ 单引号
" 双引号
\n 换行
\t 横向制表符(TAB)
\r 回车
原始字符串只需要在字符串前边加一个英文字母 r 即可。
(2)字符串的切片与拼接
具有不可修改性,索引从 0 开始。切片通常写成 start:end
这种形式,包括「start 索引」对应的元素,不包括「end索引」对应的元素。索引值可正可负,正索引从 0 开始,从左往右;负索引从 -1 开始,从右往左。使用负数索引时,会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
(3)字符串的常用内置方法
str.capitalize()
将字符串的第一个字符转换为大写。
str.lower()
转换字符串中所有大写字符为小写。
str.upper()
转换字符串中的小写字母为大写。
str.swapcase()
将字符串中大写转换为小写,小写转换为大写。
string.count(str, beg= 0,end=len(string))
返回str在 string 里面出现的次数,如果beg或者end指定则返回指定范围内str出现的次数。
str.endswith(suffix, beg=0, end=len(string))
检查字符串是否以指定子字符串 suffix 结束,如果是,返回 True,否则返回 False。如果 beg 和 end 指定值,则在指定范围内检查。
str.startswith(substr, beg=0,end=len(string))
检查字符串是否以指定子字符串 substr 开头,如果是,返回 True,否则返回 False。如果 beg 和 end 指定值,则在指定范围内检查。
string.find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end,则检查是否包含在指定范围内,如果包含,返回开始的索引值,否则返回 -1。
string.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
str.isnumeric()
如果字符串中只包含数字字符,则返回 True,否则返回 False。
str.ljust(width[, fillchar])
返回一个原字符串左对齐,并使用fillchar(默认空格)填充至长度width的新字符串。
str.rjust(width[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度width的新字符串。
str.lstrip([chars])
截掉字符串左边的空格或指定字符。
str.rstrip([chars])
删除字符串末尾的空格或指定字符。
str.strip([chars])
在字符串上执行lstrip()和rstrip()。
str.partition(sub)
找到第一个子字符串sub,把字符串分为一个三元组(pre_sub,sub,fol_sub),如果字符串中不包含sub则返回(‘原字符串’,’’,’’)。
str.rpartition(sub)
类似于partition()方法,不过是从右边开始查找。
str.replace(old, new [, max])
把 将字符串中的old替换成new,如果max指定,则替换不超过max次。
str.split(str="", num)
不带参数默认是以空格为分隔符切片字符串,如果num参数有设置,则仅分隔num个子字符串,返回切片后的子字符串拼接的列表。
str.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']
str.maketrans(intab, outtab)
创建字符映射的转换表,返回一个字典,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串,表示转换的目标。
str.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
格式化函数
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
字符串格式化符号:
print('%c' % 97) # a
print('%c %c %c' % (97, 98, 99)) # a b c
print('%d + %d = %d' % (4, 5, 9)) # 4 + 5 = 9
格式化操作符辅助指令:
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、字符串函数回顾
怎么批量替换字符串中的元素?
使用replace(old, new [, max])函数。
怎么把字符串按照空格进⾏拆分?
使用str.split(str="", num) 不带参数默认是以空格为分隔符切片字符串。
怎么去除字符串⾸位的空格?
使用str.lstrip(]) 截掉字符串左边的空格。
2、实现isdigit函数
题目要求:实现函数isdigit, 判断字符串里是否只包含数字0~9。
def isdigit(string):
for i in range(len(string)):
if (string[i]<'0') or (string[i]>'9'):
return -1
else:
pass
return 1
str1 = '123456'
print(isdigit(str1))
def isdigit(string):
if string.isnumeric():
return 1
else:
return -1
str1 = '123456'
print(isdigit(str1))
3、leetcode 5题 最长回文子串
给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例:
输入: “babad” 输出: “bab”
输入: “cbbd” 输出: “bb”
官方解答:动态规划方法
class Solution:
def longestPalindrome(self, s: str) -> str:
n = len(s)
dp = [[False] * n for _ in range(n)]
ans = ""
# 枚举子串的长度 l+1
for l in range(n):
# 枚举子串的起始位置 i,这样可以通过 j=i+l 得到子串的结束位置
for i in range(n):
j = i + l
if j >= len(s):
break
if l == 0:
dp[i][j] = True
elif l == 1:
dp[i][j] = (s[i] == s[j])
else:
dp[i][j] = (dp[i + 1][j - 1] and s[i] == s[j])
if dp[i][j] and l + 1 > len(ans):
ans = s[i:j+1]
return ans
作者:LeetCode-Solution
链接:https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。