目录：
一.字符编码：
计算机由美国人发明，最早的字符编码为ascii，只规定了英文字母数字和一些特殊字符与数字的对应关系。最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ascii码最多只能表示 256 个符号
ascii用1个字节代表一个字符；
unicode常用2个字节代表一个字符，生僻字需要用4个字节；
utf-8英文字母被编码成1个字节，汉字通常是3个字节有很生僻的字符才会被编码成4-6个字节。
例：
字母x，用ascii表示是十进制的120，二进制0111 1000
汉字中已经超出了ascii编码的范围，用unicode编码是十进制的20013，二进制的01001110 00101101。
字母x，用unicode表示二进制0000 0000 0111 1000，所以unicode兼容ascii，也兼容万国，是世界的标准
这时候乱码问题消失了，所有的文档我们都使用但是新问题出现了，如果我们的文档通篇都是英文，你用unicode会比ascii耗费多一倍的空间，在存储和传输上十分的低效
本着节约的精神，又出现了把unicode编码转化为“可变长编码”的utf-8编码。utf-8编码把一个unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用utf-8编码就能节省空间：
|
字符 |
ascll |
unicode |
utf-8 |
|
x |
01000001 |
00000000 01000001 |
01000001 |
|
中 |
不能表示 |
01001110 00101101 |
11100100 10111000 10101101 |
从上面的表格还可以发现，utf-8编码有一个额外的好处，就是ascii编码实际上可以被看成是utf-8编码的一部分，所以，大量只支持ascii编码的历史遗留软件可以在utf-8编码下继续工作。
ascii:只能存英文和拉丁字符，一个字符占一个字节，8位
gb2312：只能存6700多个中文，1980年
gbk1.0：存2万多字符，1995年
gb18030：存27000中文，2000年
万国码：unicode：utf-32 一个字符占4个字节
utf-16 一个字符占2个字节，或两个以上。
utf-8 一个英文用ascii码来存，一个中文占3个字节
声明编码 -*- coding：utf-8 -*-
gbk默认不认识utf-8，utf-8是unicode的一个子集
unicode 默认向下兼容gbk等
python3内部默认是 unicode，文件默认编码是utf-8
阶段一：现代计算机起源于美国，最早诞生也是基于英文考虑的ascii
ascii:一个bytes代表一个字符（英文字符/键盘上的所有其他字符），1bytes=8bit，8bit可以表示0-2**8-1种变化，即可以表示256个字符
ascii最初只用了后七位，127个数字，已经完全能够代表键盘上所有的字符了（英文字符/键盘的所有其他字符），后来为了将拉丁文也编码进了ascii表，将最高位也占用了
阶段二:为了满足中文和英文，中国人定制了gbk
gbk:2bytes代表一个中文字符，1bytes表示一个英文字符
为了满足其他国家，各个国家纷纷定制了自己的编码
日本把日文编到shift_jis里，韩国把韩文编到euc-kr里
阶段三：各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。如何解决这个问题呢？？？
说白了乱码问题的本质就是不统一，如果我们能统一全世界，规定全世界只能使用一种文字符号，然后统一使用一种编码，那么乱码问题将不复存在，
很多地方或老的系统、应用软件仍会采用各种各样的编码，这是历史遗留问题。于是我们必须找出一种解决方案或者说编码方案，需要同时满足：
1、能够兼容万国字符
2、与全世界所有的字符编码都有映射关系，这样就可以转换成任意国家的字符编码
这就是unicode（定长）， 统一用2bytes代表一个字符， 虽然2**16-1=65535，但unicode却可以存放100w+个字符，因为unicode存放了与其他编码的映射关系，准确地说unicode并不是一种严格意义上的字符编码表
很明显对于通篇都是英文的文本来说，unicode的式无疑是多了一倍的存储空间（二进制最终都是以电或者磁的方式存储到存储介质中的）
阶段四：于是产生了utf-8（可变长，全称unicode transformation format），对英文字符只用1bytes表示，对中文字符用3bytes，对其他生僻字用更多的bytes去存。
二. python 字符串格式化
python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
例如：
print("my name is %s and weight is %d kg!" % ('zrh', 20))
输出结果：
my name is zrh and weight is 20 kg!
如果在格式化输出中想要输出%号，就要用到%%格式
例如：
print("我是%s,我的进度已经完成80%%" %('zrh'))
输出结果：
我是zrh,我的进度已经完成80%
三.进制转换
进制也就是进制位，我们常用的进制包括：二进制、八进制、十进制与十六进制，它们之间区别在于数运算时是逢几进一位。比如二进制是逢2进一位，十进制也就是我们常用的0-9是逢10进一位，16进制的10-15用a、b、c、d、e、f来表示。
1. 十进制转二进制
方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止。
2. 二进制转十进制
方法为：把二进制数按权展开、相加即得十进制数。
第一个的1*2的7次方，是因为数位就是8位，8-1=7，依此类推。
四. 数据类型
python有五个标准的数据类型：
numbers（数字） v = 1 int类
boolean value（布尔值） v = true （bool类）
string（字符串） v = “good” （str类）
list（列表） v = [“good”,”best”] （list类）
tuple（元组） v = (“good”,”best”) （tuple类）
dictionary（字典） v = {“name”:”zrh”,”age”:20} （dict类）
1.int类（记住一个）
bit_length()表示当前十进制数用二进制数表示时，最少使用的位数。
代码示例：
count = 16 v = count.bit_length() print(v,"---",count)
输出结果：
5 --- 16
2.str类
对于字符串，执行内置命令后，原来的值不变。
2.1：upper()转换字符串中的小写字母为大写
代码示例：
name = "zrh" v = name.upper() print(v,"---",name)
输出结果：
zrh --- zrh
2.2：lower()转换字符串中所有大写字符为小写
代码示例：
name = "zrh" v = name.lower() print(v,"---",name)
输出结果：
zrh --- zrh
2.3：capitalize()将字符串的第一个字符转换为大写
代码示例：
name = "zrh" v = name.capitalize() print(v,"---",name)
输出结果：
zrh --- zrh
2.4：strip()去除首尾空格
代码示例：
name = " zrh " v = name.strip() print(v+"---",name)
输出结果：
zrh--- zrh
2.5：lstrip()截掉字符串左边的空格或指定字符
2.6：rstrip()删除字符串字符串末尾的空格
2.7：replace(str1, str2 , max)将字符串中的 str1 替换成 str2,如果max指定，则替换不超过max次
代码示例：
content = "人生自古谁无死，早死晚死都得死"
v = content.replace("死","*",2)
print(v,"---",content)
输出结果：
人生自古谁无*，早*晚死都得死 --- 人生自古谁无死，早死晚死都得死
2.8： len(string)返回字符串长度
代码示例：
content = "人生自古谁无死，早死晚死都得死" v = len(content) print(v)
输出结果：
15
2.9：[]根据索引取值
代码示例：
#索引值从0开始计算不是从1 content = "人生自古谁无死，早死晚死都得死" v = content[0] #取字符串的第一个字符 v1 = content[-1] #-代表从后往前找，1代表第一个，所以-1代表正向的最后一个 v2 = content[0:5] #从0开始取到索引值为4的对象，不包括索引值为5的对象，相当于数学中的左闭右开区间 v3 = content[8:] #从索引值为8的对象开始取到最后一个 v4 = content[0:15:2] #从0开始隔一个取一个，一直取到14，2表步长表示各一个取一个，3就表示隔2个 print(v,v1,v2,v3,v4)
输出结果：
人 死 人生自古谁 早死晚死都得死 人自谁死早晚都死
2.10 ：split(“str”,num)
以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
代码示例:
content = "人生自古谁无死，早死晚死都得死"
v = content.split("死",2)
print(v)
输出结果：
['人生自古谁无', '，早', '晚死都得死']
2.11 ：.isdecimal()判断当前字符串中是否全部都是数字
代码示例:
v = "a123" c = v.isdecimal() print(c)
输出结果：
false
2.12 ：join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
代码示例:
list1 = ['alex','zrh','sdv'] a = '_'.join(list1) #这里的_就表示用_连接 b = "".join(list1) #""里什么都没有表示直接连接 print(a) print(b)
输出结果：
alex_zrh_sdv
alexzrhsdv
五.字符串转换
1.数字转字符串 str(对象)
2.字符串转数字 int(对象)
对象必须是形为数字，才能转换
int(string)就会报错
3.数字转布尔值 bool(对象)
bool(0)是false
其他不是0的数都是true
4.字符串转布尔值 bool(对象)
bool(“”)是false
其他任何字符串都是true
注意：
代码示例：
a = 9 or 2>3 print(a)
输出结果：
9
代码示例：
a = 0 or 2>3 print(a)
输出结果：
false
代码示例：
a = 0 or 6 print(a)
输出结果：
6
代码示例：
a = 0 or 2<3 print(a)
输出结果：
true
六.列表
列表是python中最基本的数据结构。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
如下所示：
list = ["one","two",3,4,"five"]
列表可以进行 增、删、改、查。如果列表只有一个对象，在后面也要加上，
列表中的元素可以是 数字、字符串、布尔值、列表（列表的嵌套）
1.查 切片：
list[1:] #从1开始取到最后 list[1:-1] #从1开始取到倒数第二值 list[1:-1:1] #从左到右一个一个去取，取到倒数第二值 list[1::2] #左到右隔一个去取 list[3::-1] #从3开始从右到左一个一个取，注意索引值不变
2.增 添加：
2.1：append()
append(“str”)将数据插到最后一个位置
代码示例：
list = ["one","two",3,4,"five"]
list.append("six")
print(list)
输出结果：
['one', 'two', 3, 4, 'five', 'six']
2.2：insert()
根据索引值位置将数据插入到任意一个位置
代码示例：
list = ["one","two",3,4,"five"] list.insert(2,"two2") #想把新对象插在什么位置就输入相应的索引值 print(list)
输出结果：
['one', 'two', 'two2', 3, 4, 'five']
3.改 修改：
想要修改首先得用切片把相应的值取出来，在进行赋值即可。
代码示例：
list = ["one","two",3,4,"five"] list[1] = 2 #将索引值为1的对象取出来，再重新赋值 print(list)
输出结果：
['one', 2, 3, 4, 'five']
需求：将list = ["one","two",3,4,"five"]这个列表里的two 和 4 修改成 2 和 four
代码示例：
list = ["one","two",3,4,"five"] list[1:4:2] = [2,"four"] print(list)
输出结果：
['one', 2, 3, 'four', 'five']
注意：在list[1:4:2] = [2,"four"]中，因为list[1:4:2]输出得是一个列表，所以等号右边也必须是个列表
4.删 删除：
4.1：remove
remove只能删除一个，并且（）里填写的是对象内容
代码示例：
list = ["one","two",3,4,"five"]
list.remove("two") #删除two
print(list)
输出结果：
['one', 3, 4, 'five']
4.2 ：pop
pop删除的时候（）里是填写索引值，并且还可以将删除数据返回出来，如果括号里面不填索引值，即pop（），则默认删除最后一个值。
代码示例：
list = ["one","two",3,4,"five"] list.pop(1) #删除 two print(list)
输出结果：
['one', 3, 4, 'five']
4.3 ：del什么都可以删除
代码示例：
list = ["one","two",3,4,"five"] del list[0] #删除 one print(list)
输出结果：
['two', 3, 4, 'five']
5.列表的其他操作
5.1 ：count:计算某元素出现次数
代码示例：
list = ["one","two",3,4,"five"]
v = list.count("two") #计算two出现的次数
print(v)
输出结果：
1
5.2：extend：用于在列表末尾一次性追加另一个序列中的多个值
代码示例：
a = [1,2,3] b = [4,5,6] a.extend(b) #把b加到a里面 print(a) print(b)
输出结果：
[1, 2, 3, 4, 5, 6]
[4, 5, 6]
5.3：index根据内容找位置,输出得是第一个匹配内容的索引位置
代码示例：
list = ["one","two",3,4,"five"]
t = list.index("five") #查找five的索引值
print(t)
输出结果：
4
5.4 合集
1.reverse：用于反向列表中元素
2.sort：对原列表进行排序
reverse -- 排序规则，reverse = true 降序（由大到小）， reverse = false 升序（由小到大）（默认）
3.in：查一个数据在不在列表内
4.type：身份判断：判断一个对象是不是列表
代码示例：
list0 = ["one","two",str(3),str(4),"five"] list0.reverse() #反向列表中元素 print(list0) list0.sort(reverse=true) #由大到小de对原列表进行排序 print(list0) a = "six" in list0 #判单six在不在列表里 print(a) b = type(list0) is list #判断list0是不是列表 print(b)
输出结果：
['five', '4', '3', 'two', 'one']
['two', 'one', 'five', '4', '3']
false
true
6.列表练习题：
list = ["one","two",3,4,"five","天才"]
把list列表中的天才的 天 改成 蠢
代码示例：
list = ["one","two",3,4,"five","天才"]
v = list[5].replace("天","蠢")
list[5] = v
print(list)
输出结果：
['one', 'two', 3, 4, 'five', '蠢才']
注意：字符串不能通过索引值修改，只能通过索引值取出来。（⬇）
七.元组
python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
1. 创建空元组
tup1 = ()
2. 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
代码示例：
tup1 = (50) print(type(tup1)) # 不加逗号，类型为整型 tup1 = (50,) print(type(tup1)) # 加上逗号，类型为元组
输出结果：
<class 'int'>
<class 'tuple'>
3. 元组可以使用下标索引来访问元组中的值
4. 可以对元组进行连接组合
5.元组可以计算长度len()
6.元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
7.重点：
元组的儿子不能修改，但是孙子可以，元组的元素不能修改，但是元组的元素的元素是可以修改的。
代码示例：
tuple1 = ("one","two","three",[1,2,"zrh"],(1,2,3),"four")
tuple1[3][1] = 3
print(tuple1)
tuple1[3].append("q")
print(tuple1)
输出结果：
('one', 'two', 'three', [1, 3, 'zrh'], (1, 2, 3), 'four')
('one', 'two', 'three', [1, 3, 'zrh', 'q'], (1, 2, 3), 'four')
八.字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对，用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变类型。
不可变类型：整型、字符串、元组
可变类型：字典、列表
格式：变量名 = {键:值,键:值}
代码示例:
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
1.：dict.get
1.1通过键取值
代码示例：
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
print(dict1.get("name"))
输出结果：
zrh
1.2（）参数，如果键不存在，就用后面的结果当作默认值。
代码示例：
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
print(dict1.get("key",999))
输出结果：
999
2.：dict.keys() 、 dict.values() and dict.items()
经常和for循环一起使用
代码示例：
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
a = dict1.keys() #查看所有键
print(type(a)) #查看a的类型
print(a)
print(dict1.values()) #查看所有值
print(dict1.items()) #查看所有键值对
输出结果：
<class 'dict_keys'>
dict_keys(['name', 'age', 'height'])
dict_values(['zrh', 20, 75])
dict_items([('name', 'zrh'), ('age', 20), ('height', 75)])
3.增加键值对
代码示例：
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
dict1["hobby"] = "eat"
print(dict1)
输出结果：
{'name': 'zrh', 'age': 20, 'height': 75, 'hobby': 'eat'}
如果增加的键已经存在，那就是改的功能。
4.删除
代码示例：
dict1 = {
"name":"zrh",
"age":20,
"height":75
}
del dict1["name"] #删除指定键值对
print(dict1)
dict1.clear()
print(dict1) #清空字典中所有键值对，但空字典还存在
dict2 = {
"name":"zrh",
"age":20,
"height":75
}
a = dict2.pop("name") #通过键去删除，并可以返回相应的值
print(a)
print(dict2)
b = dict2.popitem()
print(b)
print(dict2) #随机删除一对键值对，并且返回相相应键值对
输出结果：
{'age': 20, 'height': 75}
{}
zrh
{'age': 20, 'height': 75}
('height', 75)
{'age': 20}
5.嵌套
字典里面可嵌套字典或者列表都可以，列表页都可以嵌套字典。
在修改时，遇到字典用键，遇到列表用索引值，然后查找出来之后赋值即可，其他操作一样，反正一句话：
遇到字典用键，遇到列表用索引值。
