Python-4-列表、元组、字符串

列表 list

列表
列表是一个有序集合，大小不定，可以存储任意数量任意类型的对象；列表通过中括号将各个元素结合在一起，元素间用逗号分隔开

列表的创建

1. 直接创建

	lis = [x1, x2, ...]

2. 通过range()方法

	lis = list(range(start, end, step))

3. 通过列表表达式

	lis = [fun(x) for x in X (if ... )]

4. 其他方法

	a. lis = [m] * 3		# [m, m, m]

	b.  二维列表
		列表中的每个元素均为列表类型，且各个子列表的大小相同

note：
由于列表可以存储任何对象，因此列表保存的是对象的地址，而不是值；
列表内容不是固定不变的，是可以更改的。

列表添加元素

list.append(object)

通过append()方法可以向列表末尾添加任意数据类型的对象，但一次只能添加一个。

list.extend(seq)

不同于append()，extend()方法可以向列表末尾一次性扩展多个对象，相当于将两个列表连接在一起

list.insert(index, obj)

insert()方法是在列表的特定位置插入一个新的对象

列表元素的删除

list.remove(obj)

移除列表中的某个特定的元素。若有多个匹配项，则只移除第一次出现的那个。

list.pop([index=-1])

移除列中特定位置的元素，默认为最后一个。与remove()方法相比，pop()有返回值，且是根据位置删除元素，而remove()是根据元素值删除元素，且无返回值。

del list[index] / del list[start:stop[:step]] 

del可以按照位置一次删掉一个或多个元素，没有返回值

获取列表元素
列表可通过索引或切片的方式获取单个或多个列表元素

1. 索引
   列表索引的下表是从0开始的，即0表示第一位，1表示第二位，…；
   列表可以反向索引，即-1表示最后一位，-2表示倒数第二位，…；
2. 切片 start：end：step
   a. 只有start时，表示从start开始，以1为间隔获取后面的所有元素；
   b. 只有end时，表示从头到end位置处（不包括end)，以1为间隔获取所有元素；
   c. 有start和end时，表示step=1
   d. 三个参数都有时，按参数规定获取元素，特别地，若step=-1，则相当于反向输出
   e. 只有step=-1，则反向输出整个列表
   f. 只有一个:，相当于拷贝整个列表

note：

列表切片是左闭右开的；
由于列表存储的是元素的指针，因此若将一个列表赋给另一个列表，则相当于两个列表指向同一个列表，改变一个，另一个也会改变；
上述情况f是将一个列表的元素全部拷贝给另一个列表，当改变一个列表时，另一个不会改变

列表的常用运算符

1. 等号操作符 ‘==’：判断两个列表是否一样
2. 连接操作符 ‘+’ ：合并两个列表，等效于extend()方法，但extend()是对原列表进行操作，而’+'需要创建新的list对象
3. 重复操作符 ‘*’ ：多次复制列表，并合并到一起
4. 成员操作符‘in’, ‘not in’：用于判断列表中是否包含某个元素

其他方法

1. list.count(obj)
   返回统计列表中元素obj的个数

2. list.index(obj[, start[, end]])
   返回查找列表中某个元素obj第一次出现的位置，可以指定查找的范围

3. list.reverse()
   列表反向

4. list.sort(key=None, reverse=False)
   对列表元素进行排序
   key接受一个只有一个参数的函数，作用于每个元素，在每个元素比较前被调用
   reverse是排序规则，默认为升序排序

练习题

1. 列表操作练习

	lst =  [2, 5, 6, 7, 8, 9, 2, 9, 9]
	# 在列表的末尾增加元素15
	lst.append(15)
	# 在列表的中间位置插入元素20
	lst.insert(len(lst)//2, 20)
	# 将列表[2, 5, 6]合并到lst中
	lst.extend([2, 5, 6])
	# 移除列表中索引为3的元素
	del lst[3]
	# 翻转列表里的所有元素
	lst.reverse()
	# 对列表里的元素进行排序，从小到大一次，从大到小一次
	lst.sort()
	lst.sort(reverse=True)

2. 修改列表

	lst = [1, [4, 6], True]
	# 将列表里所有数字修改成原来的两倍
	lst[0] *=  2
	lst[1][0] *= 2
	lst[1][1] *= 2

3. leetcode-852
   山脉数组的峰顶索引

	for i in range(len(A)-1):
		if A[i+1] < A[i]:
			return i
        return len(A) - 1

元组

元组
元组通过小括号将所有元素捆绑在一起，元素之间用’,'分隔开；元组不可更改
创建和访问一个元组
元组的创建与访问与列表类似，但元组不可更改；
元组的创建可以省略小括号，但不推荐使用
当元组中只有一个元素时，为了与括号运算符相区别，需要在元素后面添加一个逗号

更新和删除元组
元组不可更改，不能像列表一样直接赋值，但若元组元素是可更改的对象，如list，则可直接对可更改的对象进行更改

元组相关操作符
同列表一样，元组也有等号操作符、连接操作符、重复操作符、成员关系操作符

内置方法
tuple的内置方法只有两种： tuple.count(obj)和 tuple.index(obj)，用法也与list类似

解压元组
将元组元素分别赋值给各个变量，变量用小括号括起来组成一个元组，可用通配符*+变量名或*_表示多个元素，但是后者不能在后续操作中调用

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)  # 1 2

练习题

1. 元组概念

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

*是重复操作符，不能对元素做更改
当元组只有一个元素时，需要在元素后面加一个逗号，以区分小括号运算符

2. 拆包

拆包是将一个变量拆分为多个变量，可以应用到任何可迭代对象中，如list、tuple

字符串

字符串
字符串的定义

1. 字符串定义为单引号或双引号之间的字符集合
2. 字符串中常用的转义字符

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

在字符串中，若出现引号等特殊字符，需要使用上述转义字符转义；也可以不使用转义字符，直接在字符串前加字母r
三引号允许字符串跨多行，字符串中可以包含换行、回车等特殊字符

字符串的切片与拼接
字符串同样具有元组不可更改的性质
切片操作同列表一样，索引值可正可负，正索引下标从0开始，负索引从-1开始，切片区间左闭右开

常用的内置方法

1. str.capitalize() # 字符串首字母大写
2. str.lower() # 字符串中所有字母小写
3. str.upper() # 字符串中所有字母大写
4. str.swapcase() # 字符串中小写字母转大写，大写字母转小写
5. str.count(s, beg=0,end=len(string))
   查找s在字符串中出现的次数，可指定查找范围
6. str.endswith(suffix, beg=0, end=len(string))
   检查字符串是否以指定子串结尾，返回值为bool型，可指定查找范围
7. str.startswith(substr, beg=0,end=len(string))
   检查字符串是否以指定子串开头，返回值为bool型，可指定查找范围
8. str.find(str, beg=0, end=len(string))
   从左至右查找并返回子串在字符串中的位置，若没有，则返回-1；可指定查找的范围
9. str.rfind(str, beg=0,end=len(string))
   与find类似，但查找顺序是从右至左
10. str.isnumeric()
    判断字符串是否全由数字组成，若是则为True，否则为False
11. str.ljust(width[, fillchar])
    返回一个原字符串左对齐，默认使用空格填充至长度width的新字符串，可指定填充方式fillchar。
12. str.rjust(width[, fillchar])
    返回一个原字符串右对齐，默认使用空格填充至长度width的新字符串，可指定填充方式fillchar。
13. str.lstrip([chars])
    删除字符串左边的空格或指定字符
14. str.rstrip([chars])
    删除字符串右边的空格或指定字符。
15. str.strip([chars])
    删除字符串左右两边的空格或指定字符。
16. str.partition(sub)
    根据子串将原字符串分为一个三元组(pre-sub, sub, fol_sub)，若不包含sub，则pre-sub为整个字符串，sub和fol_sub为空
17. str.rpartition(sub)
    同partition()类似，但查找范围反向，为从右向左
18. str.replace(old, new [, max])
    将原字符串中的old替换为new，可指定最大替换次数
19. str.split(str="", num)
    默认以空格为分隔符分割字符串，num可指定分割子串的个数，返回的是子串组成的列表
20. str.splitlines([keepends])
    按行(’\r’, ‘\r\n’, \n’)分隔字符串，返回一个包含各行作为元素的列表，参数keepends指定是否包含换行符，默认为 False，即不包含换行符。
21. str.maketrans(intab, outtab)
    创建字符映射的转换表，两个参数均为字符串，分别表示需要转换的字符和转换的目标
22. str.translate(table, deletechars="")
    根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中；是maketrans()方法构建的转换表的实现

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!!!

字符串的格式化

1. 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

2. 格式化的符号

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串，用str()方法处理对象
%r	格式化字符串，用rper()方法处理对象
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g，根据值的大小决定使用%f或%E

3. 格式化操作符辅助指令

符号	功能
m.n	m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
-	用作左对齐
+	在正数前面显示加号( + )
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格

练习题

1. 字符串函数回顾
   批量替换字符串中的元素：str.replace(old, new)
   把字符串按照空格进行拆分：str,splite()
   去除字符串首位的空格：str.lstrip()
2. 实现isdigit函数
   判断字符串里是否只包含数字0~9

def isdigit(string):
    """
    判断字符串只包含数字
    :param string:
    :return:
    """
    # 1
    return string.isnumeric()
    # 2
    for s in string:
    	if s < '0' or s > '9':
    		return False
    return True

3. leetcode-5
   最长回文子串

# 暴力求解，简单易懂，但计算量大，运行时间超时
class Solution:
	def longestPalindrome(self, s: str) -> str:
   		n = len(s)
    	if s < 2:
        	return s

    	ma = 1
    	res = s[0]
    	
    	for i in range(n-1):
        	for j in range(i+1, n):
            	if (j+1-i) > ma and self.valid(s, i, j):
                	ma = j + 1 - i
                	res = s[i: j+1]
    	return res
    	
	def valid(self, s, left, right):
    	while left < right:
        	if s[left] != s[right]:
            	return False
        	left += 1
        	right -= 1
    	return True