本文首发于：我的博客网站 https://www.xerrors.fun/python-str/
其他的数据类型
在 python 语言中，除了常用的数值类型和字符串类型，还有很多的基础数据类型，如：列表、元组、字典等；但是他们在很多的地方都是非常相似的，所以接下来会用很大的篇幅介绍列表的功能，后面的元组以及字典有很多的相似处，可以类比着学习。
列表
列表的表示非常的简单就是使用中括号把元素括起来，元素之间用逗号隔开而已，在形式上特别像 C语言里面的数组，但是在 python 里面这个是列表，python 中的数组是另外一个东西（numpy.array）有兴趣可以了解一下，在科学计算中会用到。
列表跟数组的区别在名称上面也有体现，C语言的数组，说白了就是数据的集合（广义上面的数），数组里面的每一个元素的类型都是一样的，比如：
int a[5]; // int 型数组
而之前我们也提到过，python 中数据类型的概念是很弱的，我们在使用 python 的时候，不需要太关心数据的类型，所以在列表中，就像是一个列表一样，里面的元素类型并不单一，可以是多种类型。
a = [1, 2, 3, '4', 5.6] # 这是完全没有问题的
基础操作
增 | 删 | 改 | 查
查
最简单的访问元素的方法，使用中括号进行访问
a = [43, 54, 'CA', 78]
print(a[3])
# 78
除此之外，python 真的是在这方面玩出来了花来，有了冒号的加持，可以让列表的访问变得非常的方便。先看几个例子感受一下：
numlist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numlist[7])
# 7
print(numlist[-1])
# 9
print(numlist[2:9])
# [2, 3, 4, 5, 6, 7, 8]
print(numlist[2:9:2])
# [2, 4, 6, 8]
有没有感觉跟前面所学习的 range 十分相似，中括号里面可以有一个数字 n ，代表访问下标为 n 的元素的值。当然也可以有两个元素，中间用冒号隔开，同样也是一个左闭右开的区间（前面讲过的哦），就像示例中从 2 开始取，一直到 9，但是不包含 9。同样也可以是三个数，第三个数代表步长，这里就不解释了，应该很好理解。不理解的话（for 循环那一部分的 renge 部分有解释）
另外一个要注意的点就是，下标可以是负值，-1 就代表倒数第一个元素，同理 -2，-3分别代表倒数第二、三个元素。
下面是一些常用的骚操作：
print(numlist[:7]) # 第一个数缺省
[0, 1, 2, 3, 4, 5, 6]
print(numlist[5:]) # 第二个数缺省
[5, 6, 7, 8, 9]
print(numlist[:]) # 都缺省
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numlist[::-1]) # 前两个数缺省，第三个是 -1
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
如果第一个数缺省的话，就是代表从第一个元素开始截取；同理，后一个数缺省的话就会截取到最后一个元素；当然，两个都缺省的话，就是截取整个列表啦！另外，使用步长为 -1 可以实现逆置的效果哦！
改
修改列表的元素就很简单了，直接赋值就好啦！比如 a[8] = 8 就可以把数组的第 9 个元素修改掉了。
嗯！就这些！这样说的是不是有点敷衍了？那就介绍一个列表初始化的好(sao)方(cao)法(zuo)把！很多时候，我们都需要一个一定长度并且所有元素的都是 0 的列表，循环还是比较烦的。所以，不如（简写循环）：
a = [0 for i in range(10)]
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
a = [0] * 10 # 我不服！这个好像更简单一些
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
a = [i for i in range(10)] # 厉害了！
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = [i**3 for i in range(10)]
# [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
增
很多时候需要的是向列表中添加元素，与之相对应的就是 append 啦！
li = [12, 34, 56, 78]
li.append(90)
print(li)
# [12, 34, 56, 78, 90]
添加元素非常简单，也不需要关注列表的大小，使用 append 可以直接在列表的后面添加一个元素，也是最常用的操作了，多方便啊！但是~，也只能够在最后面添加元素，所以，就有另外一种方法可以插入元素：insert。
li = [12, 34, 56, 78]
li.insert(1, 90)
print(li)
# [12, 90, 34, 56, 78]
参数 1：代表要插入元素的位置
参数 2：代表要插入的元素
用法很简单，告诉它在哪插入啥就好了，顺序别弄反了！前面一个是位置！！！
还有一种情况：我们要是想要合并两个列表怎么办？？？很简单，加在一起就好啦！
a = [i for i in range(5)]
b = [i for i in range(5, 10)]
a = a+b
print(a)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
当然，还有另外一种比较高级的办法：extend
a = [i for i in range(5)]
b = [i for i in range(5, 10)]
a.extend(b)
print(a)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
删
删除的办法很多，挨个介绍：
删除最后一个元素：pop()，删除指定位置的元素 pop(index)：
a = [i*i for i in range(6)]
# [0, 1, 4, 9, 16, 25
a.pop()
# [0, 1, 4, 9, 16]
a.pop(2)
# [0, 1, 9, 16]
So easy! 那么问题又来了，有时候，我只知道元素是什么，不知道位置咋本，那，，就用 remove。
a = [i*i for i in range(6)]
# [0, 1, 4, 9, 16, 25]
a.remove(16)
# [0, 1, 4, 9, 25]
【warning】不要使用减号！！！
其他操作
| 方法 | 描述 |
|---|---|
| append() | 添加 - Adds an element at the end of the list |
| clear() | 清空 - Removes all the elements from the list |
| copy() | 复制 - Returns a copy of the list |
| count() | 计数 - Returns the number of elements with the specified value |
| extend() | 拓展 - Add the elements of a list(or any iterable), to the end of the current list |
| index() | 检索 - Returns the index of the first element with the specified value |
| insert() | 插入 - Adds an element at the specified position |
| pop() | 删除 - Removes the element at the specified position |
| remove() | 删除 - Removes the item with the specified value |
| reverse() | 逆置 - Reverses the order of the list |
| sort() | 排序 - Sorts the list |
元组
学完列表再来学元组其实非常简单，非常非常简单，你只需要记住两件事：
-
第一：元组需要用圆括号表示，也就是把列表的方括号换成圆括号就好。
-
第二：元组的元素不能够被更改，从创建之后直至销毁之前都不会发生改变。
list_a = [1, 2, 3, 4]
tuple_a = (1, 2, 3, 4)
list_a[0] = 5
tuple_a[0] = 5
'''
TypeErrorTraceback (most recent call last)
in ()
3
4 list_a[0] = 5
----> 5 tuple_a[0] = 5
TypeError: 'tuple' object does not support item assignment
[渣翻译] 错误类型：'tuple' 对象不支持项目赋值
'''
根据以上两个根本的区别，当我们想要对元组进行操作的时候，就只需要思考一下上面的两个基本原则，只要不触犯，就能用！所以，我们来梳理一下列表与元组的其他区别。
“增删改查”这四个，“增删改”都涉及到修改元素，所以就只能够对元组使用查了，访问列表的方法很明显是可以用在元组上面的，因为我们并没有涉及到修改元组啊；其他的操作方法，可以自行斟酌是否涉及到元素的修改进行使用（其实试试就知道了啊）。
好！元组到此结束！
等等！有个问题！！！
元组的表示方法是圆括号()，而 As we all Know，圆括号也是运算符的一种，用来改变优先级，比如说：(1+2) 的结果就是 3，那么当元组里面只有一个元素的时候，岂不是要这样赋值？？
a = (12)
你说，这个结果，到底是把括号当成运算符给计算后赋值给 a 了呢？还是说吧括号当成一个元组了呢？emm，试一下呗！
a = (12)
print(type(a))
# <type 'int'>
啊哈，可以看到，python 把它当成运算符了，那我们应该咋办？当当当，那我们就在元素后面加入一个逗号呗，告诉 python，你看啊，我们这有一个逗号，说明这里的括号不能当成运算符！
a = (12,)
print(type(a))
# <type 'tuple'>
完美！
字典
列表和元组两兄弟长得比较像，那字典就有点像是老表了，长得有点区别，用法也有点区别。既然方括号和圆括号已经被占领了，我们就使用花括号来表示字典吧！下面是一个普普通通的字典：
# 假设这是你比赛的成绩单
dict = {'Re': 500, 'Misc': 200, 'Crypto': 400, 'Pwn': 1000}
字典使用花括号包裹，字典的元素形式是键值对，洋气一点的名字是 Key:Value，也就是前面一个叫做键，是钥匙；后面一个叫做值，是结果。我们要想获得结果，就必须要有钥匙。所以在上面的示例里面，里面的元素都是键值对的形式，key 和 value 之间使用冒号隔开，不同键值对之间依然使用逗号隔开。但是要注意：因为键是寻找值的关键s，也就是说键必须是唯一的，但值不需要唯一。
好，废话不多说，开战！
访问元素
访问字典的元素只能使用键来访问，也就是说一下这些操作都是不允许的！
dict[0] # 不可以，除非有个键正好是 0
dict[1:3] # 不可以
dict[:] # 不可以
必须使用键进行访问：
dict = {'Re': 500, 'Misc': 200, 'Crypto': 400, 'Pwn': 1000}
print(dict['Pwn'])
# 1000
如果使用字典中不存在的键去访问字典的话，python 会抛出异常（也就是报错），程序会停止运行，这样会耽误后续代码的执行，所以访问字典中的元素的时候，可以使用一种相对安全的方法：
直接访问不存在的键会引发异常
dict = {'Re': 500, 'Misc': 200, 'Crypto': 400, 'Pwn': 1000}
print(dict['Web'])
'''
KeyErrorTraceback (most recent call last)
in ()
1 dict = {'Re': 500, 'Misc': 200, 'Crypto': 400, 'Pwn': 1000}
----> 2 print(dict['Web'])
KeyError: 'Web'
'''
可以使用字典的 get() 方法，如果字典中不存在该键的话会返回 None
print(dict.get('Re'))
print(dict.get('Web')
# 500
# None
或者在访问之前先检测一下字典里面有没有这个键，这就需要使用到 in 这个运算符了（之前没有介绍），in 顾名思义， 是用来检测是否在里面的运算符。如果存在就返回 True，否则 False 。in 也同样适用与列表、元组、字符串等其他序列变量。
if 'Web' in dict:
print(dict['Web'])
增加、修改元素
因为字典访问元素的时候是使用键进行访问的，所以元素之间是没有顺序的，所以添加、修改元素就变的非常简单了，直接赋值就行。如果赋值的时候没有找到相对应的键就会利用所赋的值新建一个键值对。
dict = {'Re': 500, 'Misc': 200, 'Crypto': 400, 'Pwn': 1000}
dict['Re'] = 800 # 已存在，直接修改
dict['Web'] = 800 # 不存在，创建一个
# {'Pwn': 1000, 'Re': 800, 'Misc': 200, 'Crypto': 400, 'Web': 800}
# 有没有注意到顺序都变了？这也验证了元素在 dict 中是‘无序’的
删除元素
删除元素可以使用 pop(key) 进行删除
dict.pop('Web')
我们也可以使用 python 中的一个删除指令 del 来实现：
del dict['Web']
del 可以删除的东西很多，比如可以直接删除一个变量（不是变成 0），删除后，变量也就不复存在了，del dict 之后，整个 dict 都没有了，而且就相当于没有 dict 这个变量。所以，前面的字符串，列表也都可以用，但是，不推荐！
当然，也有另外一种删除的办法，但是因为字典是无序的，所以，，，是随机删除！
dict.popitem() # 灭霸的响指
字典的迭代
字典的迭代（遍历）比较特殊，因为存在键值对，所以迭代的时候需要使用 dict 的 items() 方法把字典转化为可迭代的对象才行，示例：
dict = {'Pwn': 1000, 'Re': 800, 'Misc': 200, 'Crypto': 400, 'Web': 800}
for key, value in dict.items():
print(key, value)
'''
Pwn 1000
Re 800
Misc 200
Crypto 400
Web 800
'''
复制过来的
懒得翻译了，相信你的英语水平，如果不太理解的话 -> 这里
| Method | Description |
|---|---|
| clear() | Removes all the elements from the dictionary |
| copy() | Returns a copy of the dictionary |
| fromkeys() | Returns a dictionary with the specified keys and values |
| get() | Returns the value of the specified key |
| items() | Returns a list containing the a tuple for each key value pair |
| keys() | Returns a list containing the dictionary’s keys |
| pop() | Removes the element with the specified key |
| popitem() | Removes the last inserted key-value pair |
| setdefault() | Returns the value of the specified key. If the key does not exist: insert the key, with the specified value |
| update() | Updates the dictionary with the specified key-value pairs |
| values() | Returns a list of all the values in the dictionary |
字符串
终于终于到了我们最经常需要处理的地方了！（当然了，列表的操作也是）虽然简单，但是要记住：熟能生巧，多练，以后才不会在简单的地方栽跟头（别问我怎么知道的）
先来回顾一下最常用的字符串操作：字符串的遍历
stra = 'flag{ReverseIsVeryFun}'
for char in stra:
print(char, end=' ')
# f l a g { R e v e r s e I s V e r y F u n }
ASCII 码之间的转换
| 方法 | 描述 |
|---|---|
| ord() | 字符转 ASCII 码 |
| chr() | ASCII 码转字符 |
字符串的遍历是字符串的操作的基础，最重要的是我们要在遍历每一个字符的时候对字符进行的操作。所以此时每一个字符在诸位的眼里就应该是一个 ASCII 码。使用 ord() 可以获取字符的 ASCII 码。（划重点）
stra = 'flag{Reverse}'
for char in stra:
print(ord(char), end=' ')
# 102 108 97 103 123 82 101 118 101 114 115 101 125
划下重点：’{’ ‘}’ 的 ASCII 码分别是 123，125
与之相对应的就是 chr() ，这个的作用就是把 ASCII 码转化为相应的字符进行输出，一般用在将最终结果输出出来。
li = [102, 108, 97, 103, 123, 82, 101, 118, 101, 125]
for i in li:
print(chr(i), end='')
# flag{Reverse}
替换 replace
test_str = 'You are SB'
print(test_str.replace('S', 'N'))
print(test_str)
# You are NB
# You are SB
原字符串不发生改变
数据类型之间的转换
| 方法 | 描述 |
|---|---|
| str() | 字符串转数字 |
| int() | 数字转字符串 |
str 的方法很简单就是在数字的两边加上引号就好了，str(123) 的结果是 ‘123’
a = 12345
str_a = str(a)
print(str_a)
print(type(str(a)))
# 12345
# <type 'str' >
但是 int 是需要注意一下的，并不是所有的字符串都是可以转化成数字的，比如 “Z”,“1.2.3”。int 可以将 ‘123’，转化为 123
a = "1234"
int_a = int(a)
print(int_a + 1)
# 1235
进制转换
很简单，要记住哦~
| 方法 | 描述 |
|---|---|
| hex() | 转成 16 进制 |
| int() | 转成 10 进制 |
| oct() | 转成 8 进制 |
| bin() | 转成 2 进制 |
这段代码是我学每一门语言最烦的地方~~~但是，还是要记住这些啊，这些常用的东西还是记住的好，一些不常用的可以以后再查。
a = 89
print('十六进制', hex(a))
print('十进制', int(a))
print('八进制', oct(a))
print('二进制', bin(a))
# 十六进制 0x59
# 十进制 89
# 八进制 0o131
# 二进制 0b1011001
简单的数据处理
| 方法 | 用法 | 结果 | 描述 |
|---|---|---|---|
| abs | abs(-5) | 5 | 绝对值 |
| round | round(3.4) | 3 | 四舍五入（慎用） |
| E | 1E8 | 1E8 | 科学计数表示 |