列表，元组和字符串
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)) |
| 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')
>>>
完！