0基础入门学习Python（第5章）

列表，元组和字符串

5.1 列表：一个打了激素的数组

有时候可能需要将一些相互之间有关联的数据保存在一起，这个就叫数组。Python将其称为列表。

5.1.1 创建列表

>>> [1,2,3,4,5]
[1, 2, 3, 4, 5]
>>>

上面是一个匿名列表，因为没有名称，所以创建了也没使用。

>>> number = [1,2,3,4,5]
>>> type(number)
<class 'list'>
>>> for each in number:
... print(each)
...
1
2
3
4
5
>>>

type()函数用于返回指定参数的类型，list表示列表

列表可以包含任意类型的数据

>>> mix = [520,"小甲鱼",3.14,[1,2,3,4]]
>>> type(mix)
<class 'list'>
>>>

5.1.2 向列表添加元素

append() 方法

>>> number
[1, 2, 3, 4, 5]
>>> number.append(6)
>>> number
[1, 2, 3, 4, 5, 6]
>>>

这里的append并不是一个BIF，它属于列表对象的一个方法，中间有个. 暂时可以理解为范围的意思，append方法属于一个叫number的列表对象

>>> number.append(7,8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: append() takes exactly one argument (2 given)
>>> number.extend(7,8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: extend() takes exactly one argument (2 given)
>>> number.extend([7,8])
>>> number
[1, 2, 3, 4, 5, 6, 7, 8]
>>>

可以看到要同时添加多了元素到列表，要用extend方法，事实上，extend方法是使用一个列表来扩充另外一个列表

insert 方法支持将元素插入到具体位置

>>> number.insert(0,0)
>>> number
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>>

insert 方法还支持负数

>>> number.insert(-1,8.5)
>>> number
[0, 1, 2, 3, 4, 5, 6, 7, 8.5, 8]
>>>

5.1.3 从列表中获取元素

通过索引可以直接获取列表中的元素

>>> eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
>>> eggs[0]
'鸡蛋'
>>> eggs[3]
'铁蛋'
>>>

访问列表的最后一个元素：

>>> eggs[-1]
'铁蛋'
>>> eggs[len(eggs)-1]
'铁蛋'
>>>

如果要将鸭蛋和铁蛋的位置调换

>>> eggs
['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
>>> temp = eggs[1]
>>> eggs[1] = eggs[3]
>>> eggs[3] = temp
>>> eggs
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']
>>>

或者更简洁的办法：

>>> eggs
['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
>>>
>>> eggs[1], eggs[3] = eggs[3], eggs[1]
>>> eggs
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']
>>>

随机抽取列表里的元素，使用random方法

>>> import random
>>>
>>> eggs
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']
>>> prizes = eggs
>>> prizes
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']
>>> random.choice(prizes)
'鸭蛋'
>>> random.choice(prizes)
'鸡蛋'
>>> random.choice(prizes)
'鹅蛋'
>>>

5.1.4 从列表中删除元素

remove pop del 方法

remove 指定一个待删除的元素，使用remove 删除元素，不需要知道元素的具体位置，如果不存在就会报错

>>> eggs
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']
>>> eggs.remove('鸡蛋')
>>> eggs
['铁蛋', '鹅蛋', '鸭蛋']
>>> eggs.remove('鸡蛋')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>>

pop 方法是将列表中的指定元素弹出来，取出并删除的意思，参数是一个索引

>>> eggs
['铁蛋', '鹅蛋', '鸭蛋']
>>> eggs.pop(1)
'鹅蛋'
>>> eggs
['铁蛋', '鸭蛋']
>>>

pop 方法如果不带参数，默认删除列表中的最后一个元素

del 是一个Python的语句，不是del方法，删除元素，删除列表

>>> eggs
['铁蛋', '鸭蛋']
>>> del eggs[0]
>>> eggs
['鸭蛋']
>>> del eggs
>>> eggs
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'eggs' is not defined
>>>

5.1.5 列表切片

从列表1中取出三个元素放到列表2中

>>> list1 = ['钢铁侠','蜘蛛侠','蝙蝠侠','绿灯侠','神奇女侠']
>>> list2 = [list1[2],list1[3],list1[4]]
>>> list2
['蝙蝠侠', '绿灯侠', '神奇女侠']
>>>

如果是取出200元素，就很尴尬了，这里可是这样操作

>>> list1
['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '神奇女侠']
>>> list2 = []
>>> for i in range(len(list1)):
... list2.append(list1[i])
...
>>> list2
['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '神奇女侠']
>>>

但是还可以简化操作，比如出去第二个元素到第五个元素

>>> list1
['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '神奇女侠']
>>> list2 = list1[2:5]
>>> list2
['蝙蝠侠', '绿灯侠', '神奇女侠']
>>>

5.1.6 进阶玩法

列表切片操作其实还可以接收第三个参数，就是步长，默认值为1，下面将其修改为2

>>> list1 = range(10)
>>> list1
range(0, 10)
>>> list1 = list(range(10))
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1[0:9:2]
[0, 2, 4, 6, 8]
>>> list1[::2]
[0, 2, 4, 6, 8]
>>>

发现了没有： list1[0:9:2] list1[::2] 可以完成同样的事情，后者更简洁

如果将列表的步长设置为-1 ，相当月整个列表反过来了

>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>>

del 语句作用于列表切片，结果有点意思

>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del list1[::2]
>>> list1
[1, 3, 5, 7, 9]
>>>

delete 直接作用于原始列表了

5.1.7 一些常用的操作符

列表比较

>>> list1 = [123]
>>> list2 = [234]
>>> list1 > list2
False
>>> list1 <= list2
True
>>> list3 = ['apple']
>>> list4 = ['pineapple']
>>> list3 < list4
True
>>>

* 重复操作符，

>>> list1 * 3
[123, 123, 123]
>>>

成员关系操作。in not in

>>> list5 = list1 + list2
>>> list5
[123, 234]
>>> 123 in list1
True
>>> 456 in list1
False
>>> 456 not in list1
True
>>>

开发过程中，需要取出列表中重复的元素，使用in 和not in 就可以轻松实现

>>> oldlist = ['西班牙','葡萄牙','牙买加','葡萄牙','匈牙利']
>>> newlist = []
>>> for each in oldlist:
... if each not in newlist:
... newlist.append(each)
...
>>> print(newlist)
['西班牙', '葡萄牙', '牙买加', '匈牙利']
>>>

5.1.8 列表的小伙伴们

列表有都少个方法，可以使用dir(list)去查看

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>>

count 方法用来统计元素在列表中出现的次数

>>> list1 = list(range(10))
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1.count(1)
1
>>>

index 方法是返回某个元素在列表中第一次出现的索引值

>>> list1.index(9)
9
>>>

reverse 方法是将整个列表翻转

>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1.reverse()
>>> list1
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>>

sort 方法是对列表元素进行排序

>>> list1
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> list1.sort()
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

如果需要从大到小进行排序，很简单，先调用sort方法，在调用reverse方法即可

其实sort还有第三个参数，语法为：

sort(func,key,reverse)

>>> list1
[1, 2, 55, 123, 8, 5, 6, 7, 111]
>>> list1.sort(reverse=True)
>>> list1
[123, 111, 55, 8, 7, 6, 5, 2, 1]
>>>

5.2 元组，戴上了枷锁的列表

元组与列表最大的区别就是，元组只可读，不可写。

>>> tuple1 = (1,2,3,4,5)
>>> tuple1
(1, 2, 3, 4, 5)
>>> type(tuple1)
<class 'tuple'>
>>>

复制一个元组：

>>> tuple1
(1, 2, 3, 4, 5)
>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5)
>>>

5.2.2 更新和删除元组

由于元祖中的元素是不允许被修改的，但是并不妨碍我们创建一个新的同名元组

>>> x_men = ('金刚狼','x教授','暴风女','火凤凰','镭射眼')
>>> x_men[1] = '小甲鱼'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> x_men = (x_men[0],"小甲鱼") + x_men[2:]
>>> x_men
('金刚狼', '小甲鱼', '暴风女', '火凤凰', '镭射眼')
>>>

5.3 字符串

字符串创建，使用单引号，或者双引号，但是要成对出现

字符串同元组一样，创建之后就不能修改，只能通过拼接的方式实现

序号	方法及描述
1	capitalize() 将字符串的第一个字符转换为大写
2	center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6	endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8	find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10	isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
11	isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
12	isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13	islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace() 如果字符串中只包含空格，则返回 True，否则返回 False.
16	istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string) 返回字符串长度
20	ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21	lower() 转换字符串中所有大写字符为小写.
22	lstrip() 截掉字符串左边的空格
23	maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip() 删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
32	splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34	strip([chars]) 在字符串上执行 lstrip()和 rstrip()
35	swapcase() 将字符串中大写转换为小写，小写转换为大写
36	title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

casefold 方法用于将字符串中所有的英文大写转为小写

>>> str1 = 'FishC'
>>>
>>> str1.casefold()
'fishc'
>>>

count(sub[,start[,end]])

>>> str2 = "上海自来水来自上海"
>>> str2.count('上')
2
>>> str2.count('上', 0, 5)
1

find(sub[,start[,end]]) #查找第一次出现的位置

>>> str2.find("上")
0

index(sub[,start[,end]]) #查找元素出现的第一位置，找不到抛出异常

>>> str2.index('上')
0
>>> str2.index('我')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> str2.find('我')
-1
>>>

replace(old,new[,count]) 将old字符替换为new字符

>>> str4 = 'I love you'
>>> str4.replace("you","fishc.com")
'I love fishc.com'
>>>

split(sep=None,maxsplit=-1) 用于拆分字符串

>>> str5 = "肖申克的救赎/1994年/9.6/美国"
>>> str5.split(sep='/')
['肖申克的救赎', '1994年', '9.6', '美国']
>>>

和split方法相反的是join(interable)方法用于拼接字符串

>>> countries = ['中国','俄罗斯','美国','日本','韩国']
>>> '-'.join(countries)
'中国-俄罗斯-美国-日本-韩国'
>>> ','.join(countries)
'中国,俄罗斯,美国,日本,韩国'
>>> '=='.join(countries)
'中国==俄罗斯==美国==日本==韩国'
>>>

5.3.2 格式化

格式化字符串就是按照统一的规矩去输出一个字符串。

1. format() 方法接收位置参数和关键字参数，二者均传递到一个名为replacement的字段，而这个replacement字段在字符串内用大括号 {} 表示。

>>> "{0} love {1}.{2}".format("I","FishC","com")
'I love FishC.com'
>>>

字符串中的{0} {1} {2} 应该与位置有关，依次被format的参数替换，那么format的三个参数就是位置参数

>>> "{a} love {b}.{c}".format(a="I", b="Fishc", c="com")
'I love Fishc.com'
>>>

{a} {b} {c] 就相当于三个目标标签，format将参数中的值替换进去。

如果将位置参数和关键参数综合放在一起，那么位置参数必须在关键参数之前，否则会报错

>>> "{a} love {b}.{0}".format(a="I", b="Fishc","com")
File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

>>> "{0}: {1:.2f}".format("圆周率",3.1415026)
'圆周率: 3.14'
>>> >>> "{0}: {1:.2f}".format("圆周率",3.1415026)

2. 格式化操作符:%

符号	说明
%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	根据值的大小决定使用 %f 或 %e
%G	作用同 %g，根据值的大小决定使用 %f 或者 %E

>>> '%c' % 97
'a'
>>> '%c%c%c%c%c' % (70,105,115,104,67)
'FishC'
>>>

格式化命令的辅助操作符

符号	说明
m.n	m 是显示的最小总宽度，n 是小数点后的位数
-	用于左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
0	显示的数字前面填充 '0' 取代空格

>>> '%5.1f' % 27.68
' 27.7'
>>> '%.2e' % 27.68
'2.77e+01'
>>> '%10d' % 5
' 5'
>>> '%-10d' % 5
'5 '
>>> '%010d' % 5
'0000000005'
>>> '%#X' % 100
'0X64'
>>>

3. python 转义字符和含义

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\”	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数yy代表的字符，例如：\o12代表换行
\xyy	十进制数yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

5.4 序列

1. list

>>> a = list()
>>> type(a)
<class 'list'>
>>> a
[]
>>> b = list("fishc")
>>> b
['f', 'i', 's', 'h', 'c']
>>>

2.tuple

tuple() 方法把一个可迭代对象转换为元组

3.str() 方法用于把object对象转换为字符串

4.len(sub) 用户返回sub的长度

5.max返回集合中的最大值

6.min 返回集合中的最小值

7.sum 方法用于返回序列的iterable的所有的总和

>>> tuple1 = 1,2,3,4,5,6
>>> sum(tuple1)
21
>>> sum(tuple1,10)
31
>>>

8.sorted 方法用于返回一个排序的列表

>>> list1 = [1,4,6,3,66,2,8,14]
>>> sorted(list1)
[1, 2, 3, 4, 6, 8, 14, 66]
>>>

9.reverse 方法用于返回一个逆向的序列值

>>> list1 = [1,4,6,3,66,2,8,14]
>>>
>>>
>>> for i in reversed(list1):
... print(i,end=',')
...
14,8,2,66,3,6,4,1,>>>
>>>

10.enumerate生成二元组，每个二元组可有索引和元素组成

>>> str1 = "FishC"
>>> for each in enumerate(str1):
... print(each)
...
(0, 'F')
(1, 'i')
(2, 's')
(3, 'h')
(4, 'C')
>>>

11.zip方法用于返回各个可迭代参数共同组成的元组

>>> list1 = [1,3,5,7,9]
>>> str1 = "FishC"
>>> for each in zip(list1,str1):
... print(each)
...
(1, 'F')
(3, 'i')
(5, 's')
(7, 'h')
(9, 'C')
>>>

完！