四、列表
定义 ： 一个打了激素的数组(数组只能用来存多个同种类型的数据， 但是列表可以存储多个任意类型的数据)
列表的底层是以 栈 的方式生成的。
列表的方法 ：
1. 添加元素 ：
a = []
print(a) 输出 ： []
append() ： 添加一个元素
a.append('xxx')
print(a) 输出 ： ['xxx']
print(a.append('yyy')) 输出 ： None
extend() ： 添加多个元素（必须把要添加的多个元素 放到一个列表中）
a.extend(['www', 'qqq'])
print(a) 输出 ： ['xxx', 'www', 'qqq']
insert() : 在某位在插入一个元素
a.insert(2, '小明') a.insert(插入的位置, 插入的值)
print(a) 输出 ： ['xxx', 'www', '小明', 'qqq']
2. 删除元素
a = ['hello', '好污哇有', 'hehe']
print(a) ['hello', '好污哇有', 'hehe']
remove() : 移除某个元素【如果该元素不存在则报错（ValueError: list.remove(x): x not in list）】
a.remove('好污哇有')
print(a) ['hello', 'hehe']
del() : 删除某个下标对应的元素（这个被删除的元素的引用计数减一），也可以删除列表
del(a[2])
print(a) ['hello', '好污哇有']
del(a)
print(a) NameError: name 'a' is not defined （a被删除了导致异常）
pop() 弹出一个元素(从列表里面剔除， 返回值为被剔除的元素)，可以指定弹出哪个下标对应的元素，
如果指定的下标不存在则报异常（IndexError: pop index out of range），默认弹出下标最大的元素
b = a.pop(1)
print(b) 好污哇有
print(a) ['hello', 'hehe']
print(a.pop()) hehe
3. 列表切片 a[start:end:步长]
利用索引，我们可以从列表中每次获取一个元素， 但是如果我们要从列表一次获取多个元素呢？
此时我们可以使用分片， 分片的结果会得到原列表的一个【拷贝】（不是贴一个标签！！）
a = [0, 1, 2, 3, 4, 5, 6]
print(a[1:-1]) [1, 2, 3, 4, 5] 获取第二个元素到倒数第二个元素这段元素
b = a[1:4:2]
print(b) [1, 3]
print(a) [0, 1, 2, 3, 4, 5, 6]
b[1] = 2
print(b) [1, 2] b已经被改变了
print(a) [0, 1, 2, 3, 4, 5, 6] a没有被改变
4. 列表的一些常用操作符
a、比较操作符 （ >、 <、 == ） 【当两个列表中有多个元素时， 默认从第 0 个元素开始比较， 只要有一个元素不相等， 就把这个结果作为列表比较的结果】
list1 = [1, 2, 3, 4
list2 = [2, 2, 3, 4]
print(list1 < list2) True
print(list1 > list2) False
b、逻辑操作符 （ and、 or、 not）
c、连接操作符 （ + ） 只能连接两个列表， 如果不是列表， 比如添加是一个数字，就会报 TypeError: can only concatenate list (not "int") to list
list1 = [1, 2, 3, 4]
list2 = [2, 2, 3, 4]
print(list1 + list2) [1, 2, 3, 4, 2, 2, 3, 4]
一般需要添加另一个列表里的元素时使用 extend() 方法， 而不是使用 + 这个连接操作符
d、重复操作符 （ * ）
list1 = [1, 2, 3, 4]
print(list1 * 2) [1, 2, 3, 4, 1, 2, 3, 4]
e、成员关系操作符 （in 、not in） 【判断是否在列表中】
list1 = [1, 2, 3, 4]
print(2 in list1) True
print(20 in list1) False
print([1, 2] in list1) False
5. 获取列表中的列表 （操作方式类似操作二维数组）
6. 列表的小伙伴们(内置函数)
print(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']
python 中的 . 表示范围， 比如 list.append() 表示这个 append 函数 是属于 list 的
append : 添加一个元素
extend ：添加多个元素（多个元素放在一个列表中）
insert : 在某位在插入一个元素
clear ： 清空列表
pop ： 从列表中弹出元素
remove ： 移除一个元素
copy ： 拷贝列表
count ： 统计某元素在列表中出现的次数
list1 = [1, 5, 3]
list1 *= 3
print(list1) [1, 5, 3, 1, 5, 3, 1, 5, 3]
print(list1.count(1)) 3
index ： 获取某元素出现在列表时的下标（默认是以最小的下标为准， 可以指定查找 的下标的范围）
list1 = [1, 5, 3]
print(list1.index(5)) 1
list1 *= 3
print(list1.index(5)) 1
print(list1) [1, 5, 3, 1, 5, 3, 1, 5, 3]
print(list1.index(5, 3, 6)) 4
reverse ： 将列表翻转 （首位顺序互换） 【重要】
list1 = [1, 5, 3]
print(list1) [1, 5, 3]
list1.reverse()
print(list1) [3, 5, 1]
sort ： 将列表按从小到大排序 【非常非常重要】
list1 = [1, 5, 3]
print(list1) [1, 5, 3] （排序前）
list1.sort()
print(list1) [1, 3, 5] （排序后）
如果我要从大到小排呢？
方法一：
第一步. 调用 sort 排序
第二步.调用 reverse 翻转
方法二：
sort 方法有三个参数， list1.sort(func, key|, reverse)
其中 reverse 默认为 False ，表示从小到大排列， 设置为 True 就会从大到小排列了。
list1 = [1, 5, 3]
list1.sort(reverse=True)
print(list1) [5, 3, 1]
--------------------------------------------------------
五、元组 tuple
由于列表太过灵活， 元素可以顺便修改， 现在我们想要一个元素不可变的(列表)，这就是元组。
元组的访问那些跟列表是一样的。如果我们 想要修改元组中的元素，就会报 TypeError: 'tuple' object does not support item assignment 异常
列表的标志性符号是 [] 中括号， 那么元组呢？ 我们的第一感觉认为是 () 小括号， 但是事实上是 , 逗号。如下
tuple1 = (1, 2)
print(type(tuple1)) <class 'tuple'>
tuple2 = 2,
print(type(tuple2)) <class 'tuple'>
tuple3 = (3)
print(type(tuple3)) <class 'int'>
----------------------------------------------------------
六、字符串
1.各种内置函数
print(dir(str))
输出如下 ：
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__',
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map',
'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable',
'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
'title', 'translate', 'upper', 'zfill']
capitalize ： 将首字母大写
print('hello word'.capitalize()) Hello word
casefold ： 将字符串全部转换为小写
print('HEllo WoRd'.casefold()) hello word
lower ： 将字符串全部转换为小写
print('HEllo WoRd'.casefold()) hello word
center ： 将字符串的长度填充为 n（原字符串居中） str.center(目标长度（小于原长度则什么都不做） ,用于填充的符号（只能为一个字符）)
print('HEllo WoRd'.center(50,'~')) ~~~~~~~~~~~~~~~~~~~~HEllo WoRd~~~~~~~~~~~~~~~~~~~~
ljust ： 将字符串的长度填充为 n（左对齐） str.ljust(目标长度（小于原长度则什么都不做） ,用于填充的符号（只能为一个字符）)
print('HEllo WoRd'.ljust(50,'~')) HEllo WoRd~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
rjust ： 将字符串的长度填充为 n（右对齐） str.rjust(目标长度（小于原长度则什么都不做） ,用于填充的符号（只能为一个字符）)
print('HEllo WoRd'.rjust(50,'~')) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~HEllo WoRd
count ： 统计某字符串出现的次数
print('HEllo WoRd'.count('ll')) 1
encode ： 字符串编码格式转换
print('HEllo WoRd'.encode('utf-8')) b'HEllo WoRd'
【endswith】 ： 判断字符串是否以某字符结尾
print('HEllo WoRd'.endswith('sd')) False
print('HEllo WoRd'.endswith('Rd')) True
print('HEllo WoRd'.endswith('d')) True
【startswith】 ： 判断字符串是否以某字符开头
print('HEllo WoRd'.startswith('sd')) False
print('HEllo WoRd'.startswith('H')) True
print('HEllo WoRd'.startswith('HE')) True
expandtabs ： 把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
print('HEllo\tWo\tRd') HEllo Wo Rd
print('HEllo\tWo\tRd'.expandtabs()) HEllo Wo Rd
【find】 ： 查找某字符串在某区间内出现的下标 （默认区间为整个原字符串），没找到返回 -1
print('HEllo WoRd'.find('o', 5, 8)) 7
index ： 查找某字符串在某区间内出现的下标 （默认区间为整个原字符串），没找到抛异常 ValueError: substring not found
isalnum ： 检查字符串是否仅仅由字母和数字组成（可以只包含其中一种）
print('HElloW2oRd'.isalnum()) True
print('HEllo W2oRd'.isalnum()) False
print('HElloWoRd'.isalnum()) True
print('123'.isalnum()) True
isalpha ： 是否全字母
print('HEllo WoRd'.isalpha()) False
print('HElloWoRd'.isalpha()) True
isdecimal ： 检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
print('123 456'.isdecimal()) False
print('1234'.isdecimal()) True
isdigit ： 检查字符串是否是否全数字
print('123 456'.isdigit()) False
print('1234'.isdigit()) True
islower ： 如果字符串中所有的字母都为小写（可以包含非字母），返回True，否则为False。
print('Hello Word'.islower()) False
print('hello word'.islower()) True
print('hellowo2rd'.islower()) True
print('helloword'.islower()) True
istitle ： 检查字符串首字母是否为大写（每个空格隔开一个单词，检测一次）
print('Hello Word'.istitle()) True
print('Hello word'.istitle()) False
isupper ： 检查字符串字母是否全部为大写（每个空格隔开一个单词，检测一次）
print('Hello Word'.isupper()) False
print('HELLO WORD'.isupper()) True
lstrip ： 去掉字符串左边的空格。
print(' HEllo WoRd'.lstrip()) HEllo WoRd
strip ： 去掉字符串开头和结尾的空格。
print(' HEllo WoRd '.strip()) HEllo WoRd
replace ： replace(old,new,count),用new替换old，若使用count参数，则替换次数不超过count次。
print(' HEllo WoRd'.replace(' ', '~', 3)) ~~~HEllo WoRd
【split】 ： 将字符串按某个字符分割，然后将得到的所有字符都放到列表中返回
print('HEllo WoRd'.split()) ['HEllo', 'WoRd']
【splitlines】 ： 将字符串按行（'\n'回车符）分割，然后将得到的所有字符都放到列表中返回
print('HEllo WoRd \n all body'.splitlines()) ['HEllo WoRd ', ' all body']
swapcase ： 将字符串中的大写字符改为小写，小写字符改为大写。
print('HEllo WoRd'.swapcase()) heLLO wOrD
title ： 返回标题化的字符串（首字母大写，其他小写）。
print('hEllo WoRd'.title()) Hello Word
2. 字符串格式化
a、 format 内置函数
用法一：只使用 "{}" 符号占位一个字符
a = 'hello {}' .format('xiaoming')
print(a)
用法二：使用多个 "{}" 符号占位多个字符， 最后按照 format() 里面的顺序对字符进行格式化
b = 'hello {} {}'.format('xaoming', 'xiaohong')
print(b)
用法三：使用 "{number}" 大括号包含下标的方式占位 ， 最后按照 format() 里面的下标格式化到字符串里对应的下标去
c = 'hello {0}、{1}、{3}、{2}'.format('张飞', '赵云', '马超', '关羽')
其中可以使用 :加条件对填充进来的值进行格式化， 如下， 四舍五入保留一位小数
print('{0:.1f}'.format(54.56)) 54.6
print(c)
用法四：使用变量 赋值的方式进行占位， 字符串里面写 {变量} ， format() 里面写 变量=值， 最终按照变量名将值格式化到字符串里面去
d = "hello {zhangfei}、{zhaoyun}、{guanyu}".format(zhangfei='张飞',guanyu='关羽', zhaoyun='赵云')
print(d)
注意 ：
e = "{{0}}".format('hehe')
print(e) 如果有两层花括号， 那么就不会把 format 里面的值格式化进去。。。。。。
b、百分号格式化符号 %
格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:
%s 字符串 (采用str()的显示)
print('hehe %s' % '干啥呢')
%r 字符串 (采用repr()的显示) hehe 干啥呢
print('hehe %r' % '干啥呢') hehe '干啥呢'
%c 单个字符
print('hehe %c' % '干') hehe 干
print('hehe %c' % '干啥呢') TypeError: %c requires int or char
%b 二进制整数
print(b'hello %b' % b'xx') b'hello xx'
print('hello %b' % b'xx') ValueError: unsupported format character 'b' (0x62) at index 7
%d 十进制整数
与 %i 相似
%i 十进制整数
print('hehe %i' % 50) hehe 50
print('hehe %i' % 0x50) hehe 80 【十六进制转10机制展示】
print('hehe %i' % '??') TypeError: %i format: a number is required, not str
%o 八进制整数
%x 十六进制整数
%e 指数 (基底写为e)
%E 指数 (基底写为E)
%f 浮点数
%F 浮点数，与上相同
%g 指数(e)或浮点数 (根据显示长度)
%G 指数(E)或浮点数 (根据显示长度)
%% 字符"%"
c、格式化操作符辅助指令
* 定义【宽度或者小数点精度】
- 用做左对齐
+ 在正数前面显示加号(+)
# 在八进制数前面显示零(0)，在十六进制前面显示"0x"或者"0X"（取决于用的是"x"还是"X"）
0 显示的数字前面填充"0"而不是默认的空格
(var) 映射变量（通常用来处理字段类型的参数）
m.n 【m 是显示的最小总宽度】，【n 是小数点后的位数】（如果可用的话）
d、字符串转义字符
\ (在行尾时) 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出
======================================================================================
七、 序列
列表、元组、字符串的共同点：
都可以通过索引得到每一个元素
默认索引值总是从0开始
可以通过切片的方法得到一个范围内的元素的集合
有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
所以可以把他们统称为 【序列】
关于序列常见的内置方法 ：
1. list() :把一个可迭代对象转换为列表
print(help(list))
输出 ：
class list(object)
| list() -> new empty list list本身作为一个方法，本身拥有两种形态， 无参数生成一个空的列表
| list(iterable) -> new list initialized from iterable's items 有参数（参数为一个迭代器）：将迭代器中的元素全部取出来作为列表的成员
2. tuple() : 把一个可迭代对象转换为元组
3. str() : 把一个可迭代对象转换为字符串
a = ['x', 'y', 'yu', 5]
print(type(a)) <class 'list'>
print(str(a)) ['x', 'y', 'yu', 5]
print(type(str(a))) <class 'str'>
print(str(a)[0]) [
max() 方法： 求序列中的最大值 【系列中只能包含同种类型的数据才能进行比较】
min() 方法： 求序列中的最小值 【系列中只能包含同种类型的数据才能进行比较】
a = [1, 2, 9, 5, 0, 4]
print(max(a)) 输出 9
print(min(a)) 输出 0
a = 'zabcdefq'
print(max(a)) z
print(min(a)) a
a = [1, 2, 9, 5, 0, 4, 'x']
print(max(a)) TypeError: '<' not supported between instances of 'str' and 'int'
sum(iterable[,start=0]) 返回序列器iterable 和可选参数start的总和【序列器只能包含 int 型数据】
a = [1, 5, 8, 9]
print(sum(a, 5)) 1 + 5 + 8 + 9 + 5 = 28
sorted(iterable, reverse=False) 对序列进行排序, reverse 默认为 False， 表示从小到大排序
a = [1, 5, 8, 9]
print(sorted(a, reverse=True)) [9, 8, 5, 1]
reversed() 用于逆转一个序列， 返回值为 一个对象。。。可以配合 list 等方法使用
a = [1, 5, 8, 9]
print(reversed(a)) <list_reverseiterator object at 0x0000024B92B3C278>
print(list(reversed(a))) [9, 8, 5, 1]
enumerate() 枚举， 返回一个对象， 给序列中每一个元素分配一个下标，变成成对的元组
a = [1, 5, 8, 9]
print(enumerate(a)) <enumerate object at 0x000001780685C678>
print(list(enumerate(a))) [(0, 1), (1, 5), (2, 8), (3, 9)]
zip() 打包， 回一个迭代器对象，将两个序列下标相同的元素取出组合成一个元组（长度以最短的序列为主）
a = [1, 5, 8, 9]
b = ('x', 'y', 'z')
print(zip(a, b)) <zip object at 0x000001C1704758C8>
c = list(zip(a, b))
print(c) [(1, 'x'), (5, 'y'), (8, 'z')]
d = []
e = []
for d1, e1 in c:
d.append(d1)
e.append(e1)
print(d) [1, 5, 8]
print(e) ['x', 'y', 'z']