task04 列表，元组和字符串

列表

<class ‘list’>

列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n] 。

列表的创建

创建一个普通列表

x = [2, 3, 4, 5, 6, 7]

利用range()创建列表

x = list(range(10, 1, -2)) 
print(x, type(x)) 
# [10, 8, 6, 4, 2] <class 'list'>

利用推导式创建列表

创建一个4×3的二维数组

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

x = [[0] * 3 for row in range(4)] 
print(x, type(x)) 
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的 [1,2,3] ，也有3个指针 和3个整数对象。

创建一个混合列表

mix = [1, 'lsgo', 3.14, [1, 2, 3]] 
print(mix)  
# [1, 'lsgo', 3.14, [1, 2, 3]]

创建一个空列表

empty = [] 
print(empty)  
# []

向列表中添加元素

1. list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素 在 list 中保持着原结构类型。
2. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
3. list.insert(index, obj) 在编号 index 位置前插入 obj 。

删除列表中的元素

1. list.remove(obj) 移除列表中某个值的第一个匹配项
2. list.pop([index=-1]) 移除列表中的一个元素（默认后一个元素），并且返回该元素的值。
3. del var1[, var2 ……] 删除单个或多个对象。

获取列表中的元素

1. 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
2. 通过将索引指定为-1，可让Python返回后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

切片的通用写法是 start : stop : step
情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片。
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片
情况 3 - “start : stop”
以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
情况 4 - “start : stop : step”
以具体的 step 从编号 start 往编号 stop 切片。注意后把 step 设为 -1，相当于将列表反向排列。
情况 5 - " : "
复制列表中的所有元素（浅拷贝）。

列表的常用操作符

== , + , * , in，not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
和元组拼接一样， 列表拼接也有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
前面三种方法（ append, extend, insert ）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添 加list。

列表的其他方法

list.count(obj) 统计某个元素在列表中出现的次数
list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
list.reverse() 反向列表中元素
list.sort(key=None, reverse=False) 对原列表进行排序。

元组

定义语法为： (元素1, 元素2, …, 元素n)

创建和访问一个元组

t1 = (1, 10.31, 'python') 
print(t1, type(t1)) 
# (1, 10.31, 'python') <class 'tuple'>

1. 创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
2. 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

更新和删除一个元组

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])

元组相关的操作符

1. 比较操作符
2. 逻辑操作符
3. 连接操作符 +
4. 重复操作符 *
5. 成员关系操作符 in 、 not in
   【例子】元组拼接 (concatenate) 有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

t1 = (2, 3, 4, 5) 
t2 = ('老马的程序人生', '小马的程序人生') 
t3 = t1 + t2 
print(t3)  
# (2, 3, 4, 5, '老马的程序人生', '小马的程序人生')
t4 = t2 * 2 
print(t4)  
# ('老马的程序人生', '小马的程序人生', '老马的程序人生', '小马的程序人生')

内置方法

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

1. count(‘python’) 是记录在元组 t 中该元素出现几次，显然是 1 次
2. index(10.31) 是找到该元素在元组 t 的索引，显然是 1

解压元组

只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元 素。

t = 1, 2, 3, 4, 5 
a, b, *rest, c = t 
print(a, b, c)  # 1 2 5 
print(rest)  # [3, 4]

如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。

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

字符串

字符串的定义

支持使用成对的 单引号 或 双引号。
如果字符串中需要出现单引号或双引号，可以使用转义符号 \ 对字符串中的符号进行转义。
\ 反斜杠符号
’ 单引号
" 双引号
\n 换行
\t 横向制表符(TAB)
\r 回车

1. 原始字符串只需要在字符串前边加一个英文字母 r 即可。
2. python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

字符串的切片和拼接

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

字符串的常用内置方法

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 参数中。

字符串格式化

str = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数 
print(str)  # I Love Lsgogroup
str = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数 
print(str)  # I Love Lsgogroup
str = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前 
print(str)  # I Love Lsgogroup
str = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位 
print(str)  # 27.66GB