*Python

>> Python 基础1

官网：https://www.python.org/

~ Python 下载安装

• 官网下载安装包，下载Windows x86-64 executable installer：
  
  
• 下载安装程序，双击.exe文件进行安装；特别要注意勾上Add Python 3.6 to PATH，然后点Install Now即可完成安装；
  
• 安装完在命令行输入python，出现>>>提示符说明安装没问题，能直接使用；
  
• 安装完成之后，可以在命令行执行简单的Python命令，也可使用Python自己的IDIE：
  

~ PyCharm 下载安装、配置

1、PyCharm 安装：

2、PyCharm 升级：

3、PyCharm 设置启动图标：

4、PyCharm 卸载：

5、设置解释器版本：

6、设置pycharm字体显示：

7、pycharm 单步调试：
F8 Step Over：单步执行代码，会把函数调用看做是一行代码直接越过执行；
F7 Step Into：单步执行代码，如果是函数，会进入函数内部单步执行内部代码；

~ Python 特点

• 1、完全的面向对象：
  （1）函数、模块、数字、字符串都是对象；
  （2）完全支持继承、重载、多重继承；
  （3）支持重载运算符，也支持泛型设计；
• 2、拥有一个强大的标准库：
  python核心只包含数字、字符串、列表、字典、文件等常见类型和函数，python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能；
• 3、python社区提供了大量的第三方模块，使用方式与标准库类似，功能覆盖科学计算、人工智能、机器学习、web开发、数据库接口、图形系统等多个领域；

~ Python 解释器

1、编译器：计算机不能理解任何除机器语言以外的语言，所以要把程序员所写的程序语言编译成机器语言，计算机才能执行程序；将其他语言翻译成机器语言的工具，称为编译器；

2、编译器翻译的方式有两种：

• （1）编译：
• （2）解释：当编译器以解释的方式运行时，称之为解释器；
• （3）两者区别：翻译时间点不同；
  

3、编译型语言 与 解释型语言：

• 编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新编译，直接使用编译的结果就行了；
  特点：程序执行效率高，依赖编译器，跨平台性差（不同的平台上需要重新编译）
• 解释型语言：解释性语言编写的程序不进行预编译，以文本方式存储程序源代码，会将代码一句一句直接运行；
  特点：跨平台性好，程序执行效率低；

4、Python解释器（编译器）：（默认安装CPython）就是负责把符合语法的程序代码转换成CPU能够执行的机器码，然后执行；（就是负责运行Python程序的） 当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件；要运行代码，就需要Python解释器去执行.py文件；

5、常见的 Python 解释器

• CPython：安装好Python3.x之后，默认自带的官方版解释器；使用C语言开大的，在命令行下运行python就是启动CPython解释器；
• IPython：基于并优化于CPython；
• PyPy
• Jython：是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行；
• IronPython：运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码；

~ 命令行模式和Python交互模式

• 命令行模式：cmd； 提示符类似C:\>
• 在命令行模式下可以执行python hello.py运行一个.py文件；执行一个.py文件只能在命令行模式执行，否则会出错；
• 需要先把当前目录切换到hello.py所在的目录下，才能正常执行：C:\work> python hello.py；
• Python交互模式：cmd下输入python； 提示符是>>>；
• 也可以直接通过开始菜单选择Python (command line)菜单项，直接进入Python交互模式，但是输入exit()后窗口会直接关闭，不会回到命令行模式；
• 在Python交互式模式下，可以直接输入代码，然后执行，并立刻得到结果；
  
  

Python的交互模式和直接运行.py文件区别：

• 命令行模式下直接运行.py文件是一次性执行该文件内的所有代码；
• 而Python交互模式的代码是输入一行，执行一行；
• 直接输入python进入交互模式，相当于启动了Python解释器，但是等待你一行一行地输入源代码，每输入一行就执行一行；
• 直接运行.py文件相当于启动了Python解释器，然后一次性把.py文件的源代码给执行了，你是没有机会以交互的方式输入源代码的；

~ 字符编码和编码

• Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题；
• Unicode编码通常是2个字节；
• 把Unicode编码转化为“可变长编码”的UTF-8编码，可以节省内存空间；
• 所以ASCII编码（只有英文字母、数字和一些符号）实际上可以被看成是UTF-8编码的一部分；
• 在计算机内存中（服务器），统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码；

~ 文本编辑器

• Sublime Text，免费使用，但是不付费会弹出提示框；
• 是Notepad++，免费使用，有中文界面；

注意，不能用Word和Windows自带的记事本；Word保存的不是纯文本文件，而记事本会自作聪明地在文件开始的地方加上几个特殊字符（UTF-8 BOM），结果会导致程序运行出现莫名其妙的错误；

~ PyCharm中创建项目

1、项目命名要求： 文件命名建议使用小写字母、数字、下划线，不能以数字开头；

2、新建项目，使用3.x解释器：

3、在项目下新建Python文件：

~ 程序执行原理

1、计算机中的三大硬件：CPU、内存、硬盘；

• CPU：中央处理器，是一块超大规模的集成电路，负责处理数据/计算；
• 内存：临时 存储数据（断电之后，数据会消失），速度快，空间小（4G、8G、16G、32G），单位价格高；
• 硬盘：永久存储数据，速度慢，空间大（1T），单位价格低；

2、程序执行原理：

（1）程序运行之前，程序是保存在硬盘中的，硬盘里面存放的都是CPU可以识别的机器语言（二进制）；
（2）当要运行一个程序时，操作系统会首先让CPU把程序复制到内存中，然后CPU执行内存中 的程序代码；
（3）程序要执行，首先要被加载到内存；

3、Python程序执行原理：

（1）操作系统会首先让CPU把Python解释器的程序复制到内存中；
（2）Python根据语法规则，从上向下 让CPU翻译Python程序中的代码；
（3）CPU负责执行翻译完成的代码；

---

>> Python 基础2

~ 注释

1、单行注释：
（1）在代码上方添加：#空格 注释文字
（2）在代码后面添加：代码 两个空格 # 空格 注释文字

2、多行注释（块注释）： 一对 连续的 三个 双引号/单引号；

3、TODO注释：在#后面跟上TODO，用于标记需要去做的工作；

4、代码规范及格式要求：

• Python使用缩进来组织代码块，一般使用4个空格的缩进；
• 每一行都是一个语句，当语句以冒号 : 结尾时，缩进的语句视为代码块；
• Python程序是大小写敏感的；
  

~ 变量的数据类型

在Python中，能够直接处理的数据类型有以下几种：（使用type函数可以查看一个变量的类型：type(name)）

• 整数：整数运算永远是精确的；（除法也是）
  Python2.x中，整数根据保存数值的长度分为 整数int 和 长整数long；
• 浮点数：
• 字符串：以单引号 ' 或双引号 " 括起来的任意文本；
  • 如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"；
  • 如果字符串内部既包含单引号又包含双引号，可以用转义字符**\**来标识：'I\'m \"OK\"!' <字符串是> I'm "OK"!
  • 如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用**r''**表示单引号内部的字符串默认不转义；
  • 如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用三引号'''.....'''的格式表示多行内容；【注意...是提示符，不是代码的一部分】
  • 多行字符串'''字符串内容'''还可以在前面加上r组合使用；
• 布尔值：True、False （区分大小写）；布尔值可以用and、or和not运算；
  • and运算是与运算，只有所有都为True，and运算结果才是True；
  • or运算是或运算，只要其中有一个为True，or运算结果就是True；
  • not运算是非运算，它是一个单目运算符，把True变成False，False变成True；
• 空值：空值是Python里一个特殊的值，用None表示；None不能理解为0，因为0是有意义的，而None是一个特殊的空值；
• 复数型complex：主要用于科学计算：平面场问题、波动问题、电感电容问题等；
• 列表list：
• 元组：
• 字典dict：
• 自定义数据类型：

1、数值型变量：整型int、浮点型float、布尔型bool、复数型complex；
2、非数值型：字符串、列表、元祖、字典；

~ 算数运算符

• +（加）：

• -（减）：

• *（乘）： 还可以用于字符串的拼接，将字符串重复指定次数；
  

• /（除）：

• //（整除）： 返回除法的整数部分；

• %（取余）： 返回除法的余数；

• **（幂）： 2**3=8

• /除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：9 / 3 = 3.0

• // 称为地板除，两个整数的除法仍然是整数：10 // 3 = 3

• %余数运算，可以得到两个整数相除的余数：10 % 3 = 1

~ 随机数 random

1、导入随机数的模块（工具包）：import random；
2、在ipython中，导入模块后，在控制台输入random.，按Tab键，控制台会显示该模块中包含的所有函数；
3、random.randint(a,b)，返回[a,b]之间的整数，包括边界值；
注意：a==b时，结果永远是一个值；a必须小于等于b；

~ 程序的三大流程

（1）顺序执行：从上到下，顺序执行代码；
（2）分支：if - elif - else；根据条件判断，决定执行代码的分支；
（3）循环：while；让特定代码重复执行；除非有特殊要求，否则循环的计数都是从0开始；

~ print输出不换行

默认情况下，print函数输出内容之后，会自动在内容末尾增加换行，若不希望末尾增加换行，可以在print函数输出内容后面增加,end=""，其中""中间可以指定print函数输出内容之后，继续希望显示的内容；

~ 变量

• 变量定义：在Python中，每个变量在使用前都必须赋值，变量赋值后才会被创建；变量定义后，后续就可以直接使用了；
• 变量赋值：使用等号=，变量名 = 变量值；
• 定义变量时，不需要指定变量类型，Python可以根据等号右侧的值，自动推导出变量中存储的数据的类型；
• 变量的命名：变量名（标识符），可以由字母、数字、下划线组成，不能以数字开头，不能与关键字重名；
• 变量不仅可以是数字，还可以是任意数据类型的；
• 变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头；
• 可以把任意数据类型赋值给变量：a = 123 // a赋值为整数；
• 同一个变量可以反复赋值，而且可以是不同类型的变量：a = ‘ABC’ #a再次赋值为字符串；
• a = 123时，Python解释器干了两件事情：
  （1）在内存中创建了一个123的整数；
  （2）在内存中创建了一个名为a的变量，并把它指向123；
  （3）当a再次赋值为字符串‘ABC’后，解释器创建了字符串’ABC’，并把a的指向改为’ABC’，但是123还在，没有变；

1、不同变量之间的计算：
（1）两个数字型变量之间可以直接进行算数运算：
若变量是布尔型，在计算时，True对应的数字是1，False对应的数字是0；
（2）字符串变量之间 使用 加号+ 拼接字符串，生成新的字符串；
（3）字符串变量可以和整数使用 乘号* 重复拼接指定次数的字符串；
（4）数字型变量和字符串之间 只能进行指定次数拼接，不能进行其他计算；

2、变量的输入：input()
（1）语法：字符串变量名 = print("提示信息：")
（2）用户输入的任何内容，Python都认为是一个字符串；
（3）可以使用类型转换函数将输入的字符串转换成想要的类型：
int(x)：将x转换成一个整数；
float(x)：将x转换成一个浮点数；
Eg：price = float(input("请输入苹果的价格"))

3、变量的格式化输出：print()
格式化操作符 % ：专门用于处理字符串中的格式；
%和不同字符连用，不同类型的数据 需要使用 不同的格式化字符；

语法格式：print("格式化字符串" % (变量1,变量2,......))

4、关键字：
关键字就是在Python内部已经使用的标识符，具有特殊的功能和意义，不能定义和关键字相同的名字的标识符；

可以通过命令查看Python中的关键字：import keyword、print(keyword.kwlist)

5、变量的命名规则：
（1）标识符区分大小写；
（2）等号左右各保留一个空格；
（3）变量名由多个单词组成时，每个单词都小写，之间下划线连接，或者驼峰式命名；

~ 函数

1、函数： 就是把具有独立功能的代码块，组织成一个小模块，在需要的时候，调用；

2、使用步骤：
（1）定义函数：封装独立的功能；
（2）调用函数：使用函数的功能；

3、函数的作用： 在程序开发过程中，使用函数可以提高编写的效率，以及代码的重用；

4、函数的定义：

5、函数的文档注释：
（1）在开发中，若希望给函数添加注释，应该在定义函数的下方，使用连续的三对引号；
（2）在连续的三对引号之间编写对函数的说明文字；
（3）在函数调用位置，使用Ctrl+Q，可以查看函数的说明信息；

6、函数的参数：
（1）在函数名后面的括号内填写参数名称，每个参数之间使用逗号隔开，在函数内部通过参数名称使用参数，函数调用时按照函数定义的顺序传递参数；
（2）参数的作用：增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据； 在函数内部，把参数当做变量使用，进行需要的数据处理；
（3）形参与实参：
形参：定义函数时，小括号中的参数，用来接收参数用的，在函数内部作为变量使用；
实参：调用函数时，小括号中的参数，用来把数据传递到函数内部用的；

7、函数的返回值：
函数的返回值，是函数完成工作后，最后给调用者的一个结果，使用return关键字返回结果，调用函数一方，可以使用变量来接收函数的返回值结果；

注意：return表示返回，后续的代码都不会被执行；

8、关键字、函数、方法区别：

• 关键字：是Python内置的，具有特殊意义的标识符，关键字后面不需要使用括号；在cmd中可以查看内置所有关键字：
  
• 函数：封装了独立的功能，可以直接调用：函数(参数)；【需要死记硬背函数名】
• 方法：和函数类似，同样是封装了独立的功能；需要通过对象来调用，表示针对这个对象要做的操作：对象.方法名(参数)

9、过程、函数区别：
过程 类似于函数，只能执行，但是没有返回值；
函数 不仅能执行，还可以返回结果；

~ 模块

1、模块（相当于Java的类）：
（1）每一个以.py结尾的Python源代码文件，都是一个模块；
（2）在模块中定义的全局变量、函数 都是模块能提供给外界直接使用的工具；
（3）使用模块里面的变量或函数时，需要在使用前import导入这个模块，然后通过模块名.变量名 / 模块名.函数名 的方式，使用这个模块中定义的变量或函数；

---

>> 高级变量 - 非数值型变量

1、非数字型 数据类型：字符串、列表、元祖、字典；

2、非数字型变量特点：
（1）都是一个序列sequence，也可以理解为一个容器；
（2）取值[]；
（3）遍历for in；
（4）计算长度、最大/最小值、比较、删除；
（5）链接+、重复*；
（6）切片；

~ 列表List

1、列表List的定义：（Java数组）

2、表示方式：变量名 = [a,b,c]；数据间使用逗号分隔，索引从0开始；

3、取值：列表变量名[索引]

4、常用操作：增删改查、统计、排序

name_list = ["zhangsan","lisi","wangwu"]

# 1.取值和取索引：
# list index out of range - 列表索引超出范围
print(name_list[2])

# 知道数据的内容，想确定数据在列表中的位置
# 使用index方法需要注意：若传递的数据不在列表中，程序会报错！
print(name_list.index("wangwu"))

# 2.修改：
name_list[1] = "李四"
# list assignment index out of range
# 列表指定的索引超出范围，程序会报错！
# name_list[3] = "王小二"

# 3.增加：
# append 方法可以向列表的末尾追加数据
name_list.append("王小二")
# insert 方法可以在列表的指定索引位置插入数据
name_list.insert(1,"小美")
# extend 方法可以把其他列表中的完整内容，追加到当前列表的末尾
temp_list = ["a","b","c"]
name_list.extend(temp_list)

# 4.删除
# remove 方法可以从列表中删除指定的数据
# 从列表中删除指定的数据第一次出现的数据，若数据不存在，程序会报错！
name_list.remove("wangwu")
# pop 方法默认可以把列表中最后一个元素删除
name_list.pop()
# pop 方法可以指定要删除元素的索引
name_list.pop(3)
# clear 方法可以清空列表
name_list.clear()

# 5.使用del关键字删除列表元素
# 提示：日常开发中，要从列表中删除数据，建议使用列表提供的方法
name_list = ["zhangsan","lisi","wangwu"]
del name_list[1]
# del 关键字本质上是用来将一个变量从内存中删除的
name = "小明"
del name
# 注意：如果使用del关键字将变量从内存中删除，后续代码就不能再使用这个变量了
print(name) # 报错

# 6.统计列表元素个数
name_list = ["张三","李四","王五","王小二","张三"]
# len(length) 函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含 %d 个元素" % list_len)
# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了 %d 次" % count)

# 7.排序
name_list = ["zhnagsan","lisi","wangwu","wangxiaoer"]
num_list = [6,8,4,1,10]
# 升序
name_list.sort()
num_list.sort()
#降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)
# 逆序（反转）
name_list.reverse()
num_list.reverse()

print(name_list)
print(num_list)

5、循环遍历
遍历 就是从头到尾依次从列表中获取数据，在循环内部针对每一个 元素，执行相同的操作；

每一次循环过程中，数据都会保存在my_name这个变量中，在循环体内部可以访问到当前这一次获取到的数据；

name_list = ["张三","李四","王五","王小二"]
for my_name in name_list:
    print("我的名字叫 %s" % my_name)

~ 元组Tuple

1、元组Tuple： 与列表类似，不同之处在于元组的元素不能修改；
元组表示多个元素组成的序列，用于存储一串信息，数据之间使用逗号分隔；

2、表示方式：变量名 = (a,b,c)；数据间使用逗号分隔，索引从0开始；

3、元组中只包含一个元素时，需要在元素后面添加逗号：single_tuple = (10,)

4、元组的常用操作：

info_tuple = ("zhangsan",18,1.72,"zhangsan")

# 1.取值和取索引值
print(info_tuple[1])
# 已经知道数据的内容，希望知道该数据在元组中的索引
print(info_tuple.index("zhangsan"))

# 2.统计计数
print(info_tuple.count("zhangsan"))
# 统计元组中包含的元素的个数
print(len(info_tuple))

5、循环遍历：

6、应用场景：

~ 元组和列表之间的转换

（1）元组转换成列表：list(元组)
（2）列表转换成元组：tuple(列表)

~ 字典dict

1、字典Dict：可以用来存储多个数据；

2、字典和列表的区别：列表是有序的对象集合，字典是无序的对象集合；使用print函数输出字典的时候，通常输出的顺序和定义的顺序不一致；

3、字典的定义：{键:值, 键:值, ...}；
键必须是唯一的；键只能使用字符串、数字或元组，值可以是任意数据类型；

4、字典的常用操作：增删改查、统计、合并、清空

xiaoming_dict = {"name": "小明"}

# 1.取值
print(xiaoming_dict["name"])
# 在取值的时候，若指定的key不存在，程序会报错！

# 2.增加/修改：
# 新增：若key不存在，会新增键值对
xiaoming_dict["age"] = 18
# 修改：若key存在，会修改已经存在的键值对的值
xiaoming_dict["name"] = "小小明"

# 3.删除：在删除指定的键值对的时候，若指定的key不存在，程序会报错！
xiaoming_dict.pop("name")

# 4.统计键值对数量
print(len(xiaoming_dict))

# 5.合并字典
temp_dict = {"height": 1.72, "age": 18}
# 注意：若被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
xiaoming_dict.update(temp_dict)

# 6.清空字典
xiaoming_dict.clear()

print(xiaoming_dict)

5、字典的循环遍历：一次从字典中取出所有键值对；

6、应用场景：

~ 字符串

1、字符串： 就是一串字符，是用来表示文本的数据类型；
在Python中使用一对双引号，或一对单引号 定义一个字符串；
（1）若字符串内部需要使用双引号，可以使用单引号定义字符串；
（2）若字符串内部需要使用单引号，可以使用双引号定义字符串；
（3）也可以使用\" 或 \' 做字符串的转义；

2、可以使用索引获取一个字符串中的指定位置的字符，索引从0开始；也可以使用for循环遍历字符串中的每一个字符；

3、字符串的常用方法： 统计、计数、位置

hello_str = "hello hello"

# 1.统计字符串长度
print(len(hello_str))

# 2.统计某一个子字符串出现的次数
print(hello_str.count("llo"))
print(hello_str.count("abc"))  # 若字符串不存在，返回0

# 3.某一个字符串出现的位置
print(hello_str.index("llo"))
# 注意：若使用index方法传递的子字符串不存在，程序会报错！
print(hello_str.index("abc"))

4、字符串的常用操作： 在cmd中定义一个字符串hello_str=""，然后输入hello_str.，按下TAB键，会提示字符串能够使用的方法；
（1）判断类型 - 9

（2）查找和替换 - 7


（3）大小写替换 - 5

（4）文本对齐 - 3

（5）去除空白字符 - 3

（6）拆分和连接 - 5

5、字符串的切片：

• 字符串[开始索引:结束索引:步长]，（包含左，不包含右）
• 切片 方法适用于字符串、元组、列表；
• 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串；
• 列表和元组都是有序的集合，都能够通过索引值来获取对应的数据；
• 字典是一个无序的集合，是使用键值对来保存数据的；
• 从头开始取值，开始索引可以省略；
• 到末尾结束，结束索引可以省略；
• 步长默认为1，若连续切片，数字和冒号都可以省略；
• 逆序切片：str[-1::-1]、str[::-1]

~ 公共方法

1、Python内置函数：

• len(item)：计算容器中元素个数；
• del(item)/del item：删除变量
• max(item)：返回容器中元素最大值，若是字典，只针对key比较；
• min(item)：返回容器中元素最小值，若是字典，只针对key比较；
• 字符串比较大小：使用大于号/小于号；（cmp在Python3中已经取消）

2、切片：使用索引值来限定范围，从一个大的字符串中切出小的字符串；支持的数据类型有字符串、列表、元组；

字典和元组都是有序的集合，都能够通过索引值来获取到相应的数据；字典是一个无序的集合，是使用键值对保存数据；

3、字符串：

成员运算符：in、not in，用于测试序列中是否包含指定的成员；在对字典操作时，判断的是字典的键；

4、+ 加号运算符、extend方法、append方法的区别：

5、完整的for循环语法：

6、应用场景：

~ SheBang符号

1、#!：Linux上的Shebang符号，通常在Unix系统脚本中第一行使用，指明执行这个脚本 的解释程序；

2、使用步骤：
（1）使用which查询Python3解释器所在路径：which python3
（2）修改要运行的主Python文件，在第一行增加以下内容分：#! /usr/bin/python3
（3）修改主Python文件的文件权限，增加执行权限：chmod +x XX_main.py；增肌可执行权限之后，就不用再通过Python解释程序来加载和运行Python程序，可直接通过文件名回车执行程序；
（4）在需要时执行程序文件：./XX_main.py

---

>> 变量进阶

~ 变量的引用

1、程序在运行时，变量和数据都是保存在内存中的，在Python中函数的参数传递、以及返回值 都是靠引用传递的；

2、在Python中变量和数据是分开存储的，数据保存在内存中的一个位置，变量中保存着数据在内存中的地址；变量中记录数据的地址 的操作 就叫做引用；

3、使用 id(xx) 函数可以查看变量中保存的数据所在的内存地址；

4、若变量已经被定义，当给一个变量赋值的时候，本质上是修改了变量的引用：变量不再对之前的数据引用，而是改为对新赋值的数据引用；

5、调用函数传递参数的引用：数据的地址本质上就是一个数字，在调用函数时，本质上传递的是实参保存数据的引用，而不是实参保存的数据；

6、函数返回值传递引用：返回的是数据的引用，而不是数据；

~ 可变和不可变类型

（1）不可变类型：内存中的数据不允许被修改：
数字类型：int、bool、float、complex、long
字符串：str
元组：Tuple

（2）可变类型：内存中的数据可以被修改：列表list、字典dict
注意：字典的key只能使用不可变类型的数据；

（3） 通过变量名调用方法的方式来修改列表或字典内部的内容，但是内存地址不会变化；当使用赋值语句给一个列表变量赋新值的时候，是在改变变量的引用地址，而不是在修改之前的列表的内容，要修改原列表/字典的内容，需要通过调用变量的方法(append/pop/remove/clear…)实现；

~ 局部变量

1、局部变量：是在函数内部定义的变量，只能在函数内部使用；

2、函数执行结束后，函数内部的局部变量，会被系统回收；

3、不同的函数可以定义相同名字的局部变量，但是各用各的 不会产生影响；

4、局部变量的作用：在函数变量内部使用，临时保存函数内部需要使用的数据；

5、局部变量的生命周期(从变量被创建，到被系统回收)：在函数执行时被创建，函数执行结束后被系统回收，局部变量在生命周期内，可以用来存储函数内部临时使用到的数据；

~ 全局变量

1、全局变量：是在函数外部定义的变量，所有函数内部都可以使用这个变量；

2、函数执行时，需要处理变量时会：
（1）首先查找函数内部是否存在指定名称的局部变量，若有，直接使用；
（2）若没有，查找函数外部是否存在指定名称的全局变量，若有，直接使用；
（3）若函数外面也没有，程序报错！

3、 函数不能直接修改全局变量的引用，若在函数内部修改全局变量的引用，不会真正修改全局变量的引用，而是在函数内部重新定义一个局部变量，变量名与全局变量相同而已；

4、global关键字修改全局变量：在函数内部不能直接修改全局变量，若非要在函数中修改全局变量，需要在函数内部使用global关键字对全局变量进行声明；global关键字会告诉Python解释器 后面的变量是一个全局变量，在函数内部再次使用赋值语句时，就不会创建新的局部变量了；

5、全局变量定义的位置：所有函数上方；

6、全局变量命名建议：变量名前面加上g_或gl_；

---

>> 函数的参数

~ 函数的参数和返回值的作用

~ 函数的返回值

1、利用元组返回多个值：元组可以保存多个数据，因此可以使用元组让函数一次返回多个值，若函数返回值的类型是元组，小括号可以省略：return xx1,xx2,...；

2、接收返回元组的函数的返回值：
（1）使用一个变量接收整个元组，通过元组索引获取元组中的元素；
（2）使用多个变量，一次接收返回值，每个变量对应一个元组的元素；变量的个数应该和元组中元素的个数保持一致；

~ 函数的参数

1、在函数内部，针对参数使用赋值语句，不会影响调用函数时传递的实参变量，不管传递的参数是可变还是不可变；只要针对参数使用赋值语句，就会在函数内部修改局部变量的引用(重新定义与外部变量同名的局部变量)，不会影响到外部变量的引用；

2、若传递的参数是可变类型，在函数内部，使用方法修改数据的内容，会影响到外部的数据；

3、在Python中，列表变量调用+=，本质上是在执行列表变量的extend方法，不会修改变量的引用；So在函数内部对参数执行+=操作，会改变外部变量的数据；
a_list += a_list == a_list.extend(a_list)

~ 缺省参数

1、定义函数时，给某一个参数指定一个默认值，具有默认值的参数就叫做缺省参数；

2、调用函数时，若没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值；

3、函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用；

4、指定函数的缺省参数：直接在函数定义的括号里，在参数后面使用赋值语句，指定参数的默认缺省值：def xx(参数1,参数2=默认值)；（默认值应该是最常见的值，若参数的值不能确定，则不应该设置默认值，具体的数值应该在调用函数时，有外界传递）

5、缺省参数注意事项：
（1）带有默认值的缺省参数，必须定义在参数列表末尾；
（2）调用带有多个缺省参数的函数时，需要指定参数名，这样解释器才能知道参数的对应关系：xx(参数1的值,参数2=参数2的值)

~ 多值参数

1、使用多值参数 可以定义需要处理的参数个数不确定的函数；

2、*args：参数名前加一个星号，可以接收元组类型的数据；
*kwargs：参数名前加2个星号，可以接收字典类型的数据；

3、字典和元组的拆包：在调用带有多值参数的函数时，若希望将传入的元组变量 直接传递给args，而不是整个元组作为一个元素传给args元组的一个元素，就可以使用拆包；拆包方式：在元组变量前增加一个星号，在字典变量前增加2个星号；

---

>> 面向对象

~ 面向过程与面向对象

~ 类和对象

1、类名 命名法：大驼峰命名法；

~ dir内置函数

1、在Python中，变量、数据、函数 都是对象；查看对象的内置函数方法有两个：
（1）在标识符/数据(变量)后面输入一个.，然后按TAB键，cmd会提示该对象能够调用的方法列表；
（2）使用内置函数dir传入标识符/数据(数据或函数)，可以查看对象内的所有属性和方法；

2、__方法名__，这个格式的方法，是Python提供的内置方法/属性：

~ 定义类和创建对象

1、 在一个类中封装多个方法，这样通过这个类创建出来的对象，就可以直接调用这些方法了；

2、定义类的语法格式：
（1）类里面的方法定义格式和之前函数几乎一样，区别在于类里面的方法的第一个参数必须是self；
（2）类名命名规则：大驼峰命名法；

3、创建对象：对象变量名 = 类名()

4、对象的引用：使用类创建对象之后，对象变量中 记录的仍然是对象在内存中的地址，也就是对象变量引用了新创建的变量；

使用print输出对象变量，默认情况下输出的是这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址（16进制表示）；

~ 类的初始化方法

1、当使用类名() 创建对象时，会自动执行以下操作：
（1）为对象在内存中分配空间 – 创建对象；
（2）为对象的属性设置初始值 – 初始化方法__init__；
（3）__init__方法 是专门用来定义一个类具有哪些属性的方法，在类创建对象时自动调用；

2、在初始化方法内部定义属性：在__init__方法内部使用self.属性名 = 属性的初始值 就可以定义属性，在定义属性之后，再使用类创建对象，创建的所有对象就都会拥有该属性；

3、初始化的同时设置初始值：在创建对象的同时，就设置对象的属性：
（1）把希望设置的属性值，定义成__init__方法的参数；
（2）在方法内部使用self.属性 = 形参接收外部传递的参数；
（3）在创建对象时，使用类名(属性1,属性2,...)调用；

4、定义没有初始值的属性：
（1）在定义属性时，若不知道设置什么初始值，可以设置为None，创建对象之后，再在外部使用赋值语句给属性设置值即可；
（2）None关键字表示什么都没有，表示一个空对象，没有方法和属性，是一个特殊的常量，可以将None赋值给任何一个变量；

~ 对象的内置方法

1、__del__方法：对象在被从内存中销毁前，会被自动调用；
（1）若希望在对象被销毁前，再做一些事情，可以使用__del__方法；
（2）一个对象的__del__方法一旦被调用，生命周期就结束了；
（3）也可以使用del关键字删除一个对象；

2、__str__方法：返回对象的描述信息，print函数输出使用；
（1）使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪个类创建的，以及在内存中的地址（16进制表示）；
（2）若在开发中，希望使用print输出对象变量时，能够输出自定义的内容，就可以使用__str__这个方法；
（3）注意：__str__方法必须返回一个字符串：def __str__(self): return 字符串；

~ 面向对象三大特征

1、封装：根据职责将属性和方法封装到一个抽象的类中；
2、继承：实现代码的重用，相同的代码不需要重复编写；
3、多态：不同的对象调用相同的方法，产生不同的执行效果，增加代码的灵活度；

~ 面向对象特征（1）—封装

1、封装是面向对象的一大特点：
（1）面向对象编程第一步：将属性和方法封装到一个抽象类中；
（2）外界使用类创建对象，然后让对象调用方法；
（3）对象方法的细节都被封装在类的内部；

~ 身份运算符

1、身份运算符(is/is not)：用于比较两个对象的内存地址是否一致：是否是对同一个对象的引用；

2、在Python中针对None比较时，建议使用is判断：
（1）is：是判断两个标识符是不是引用同一个对象；x is y类似于id(x) == id(y)
（2）is not：是判断两个标识符是不是引用不同对象；x is not y类似于id(x) != id(y)

3、is与==区别：is用于判断两个变量引用的对象是否是同一个；==用于判断引用的变量的值是否相等；

~ 私有属性和私有方法

1、要定义对象的属性，就在初始化方法内部使用self.xx用赋值语句来定义属性；要定义方法，就使用def关键字＋方法名，方法的第一个参数必须是self；

2、私有属性和私有方法：对象的某些属性或方法，只希望在对象内部使用，而不希望在外部被访问到；
（1）私有属性：在外界不能够被直接访问，但是在对象的方法内部，可以访问对象的私有属性；
（2）私有方法：不允许在外界直接访问；

3、定义方式：在属性名或方法名前面增加两个下划线；

~ 面向对象特征（2）—继承

1、继承：子类拥有父类的所有方法和属性；
（1）子类继承父类，可以直接使用父类中已经封装好的方法，不需要再次开发；
（2）子类中应该根据职责，封装子类特有的属性和方法；

2、继承的语法：class 子类名(父类名):

3、继承的传递性：子类拥有父类，以及父类的父类中封装的所有属性和方法；

4、方法的重写：当子类的方法不能满足子类需求时，可以对方法进行重写OverRide；

5、重写父类的方法有两种：
（1）覆盖父类的方法：若在开发中，父类的方法实现和子类的方法实现完全不同，就可以使用覆盖(重写)的方式，在子类中重新编写弗雷德额方法实现； 具体实现后，就相当于在子类中定义了一个和父类同名的方法并且实现； 重写之后，在运行时，只会调用子类中重写的方法，不会调用父类中封装的方法；
（2）对父类的方法进行扩展：若在开发中，子类的方法实现中包含父类的方法实现(父类的原本封装的方法实现是子类方法的一部分)，就可以使用扩展的方式：在子类中重写父类的方法，在需要的位置使用super().父类方法的方式来调用父类方法的执行，代码的其他位置针对子类的需求，编写子类特有的代码实现；

6、super()：是Python中的一个特殊的类，常用于在重写父类方法时，调用在父类中封装的方法实现；

7、调用父类方法的另一种方式：父类名.方法(slef)；不推荐使用，P2.0支持；

8、父类的私有属性和私有方法：
（1）子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法；
（2）子类对象可以通父类的公共方法间接访问父类的私有属性和私有方法；
（3）私有属性和私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问；

9、多继承：子类可以拥有多个父类，并且具有所有父类的属性和方法：class 子类名(父类名1, 父类名2, ...)

10、多继承的使用注意事项：尽量避免使用多继承以避免父类之间存在同名方法或属性时 容易产生子类调用产生混淆的情况；

11、Python中的MRO - 方法搜索顺序：Python中提供了一个内置属性__mro__，可以查看对象的方法的执行顺序；这个方法主要用于在多继承时判断方法、属性的调用路径；

输出结果：(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)；
（1）在搜索方法时，是按照__mro__的输出结果从左至右的顺序查找的；
（2）若在当前类中找到方法，就直接执行，不再搜索；
（3）若没有找到，就查找下一个类中是否有对应的方法，若找到，就直接执行，不再搜索；
（4）若找到最后一个类，还没有找到方法，程序报错！

12、新式类与旧式类（经典类）：

~ 面向对象特征（3）—多态

1、多态：不同的子类对象调用相同的父类方法，产生不同的执行结果；

2、多态可以增加代码的灵活度，以继承和重写父类方法为前提，是调用方法的技巧，不会影响到类的内部设计；

~ 类属性

1、实例：使用类名创建对象时，首先在内存中为对象分配空间，然后调用初始化方法__init__为对象初始化；创建对象后，内存中就出现了一个对象的实实在在的存在 – 实例；
（1）通常会把创建出来的对象叫做类的实例，创建对象的动作叫做实例化，对象的属性叫做实例属性，对象调用的方法叫做实例方法；

2、实例对象：
（1）在程序执行时，对象各自拥有自己的实例属性，调用对象的方法可以通过self.xx访问自己的属性，调用自己的方法；
（3）每一个对象都有自己独立的内存空间，保存各自不同的属性；多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传递到方法内部；

3、类是一个特殊的对象 - 类对象：
（1）class AA: 定义的类属于类对象；obj = AA()属于实例对象；
（2）在程序运行时，类同样会被加载到内存，类对象在内存中只有一份，使用一个类可以创建多个对象 实例；除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法：类属性和类方法；（和实例的属性、方法不一样）

4、类属性和实例属性：
（1）类属性就是给类对象中定义的属性，通常用来记录与这个类相关的特征，不会用于记录具体对象的特征；
（2）定义类属性：直接在类名下方，使用赋值语句就可以，赋值语句等号左侧的变量就是类属性的名称；
（3）属性获取机制：在Python中属性的获取存在一个向上查找机制：对象.类属性 首先会在对象内部查找对象属性，没有找到就会向上寻找类属性，所以访问类属性有2种方式：对象.类属性和类名.类属性（不推荐：读取没问题，设置值有问题）；若使用对象.类属性 = 值赋值语句，只会给对象添加一个属性，而不会影响到雷属性的值；

~ 类方法

1、类方法：针对类对象定义的方法，在类方法内部可以直接访问类属性或调用其他类方法；

2、类方法定义语法：@classmethod def 类方法名(cls): pass
（1）类方法需要在方法名定义上方使用修饰器@classmethod来标识，告诉解释器这是一个类方法；
（2）类方法的第一个参数必须是cls：由哪一个类调用的方法，方法内的cls就是哪一个类的引用；
（3）通过类名.xx调用类方法时，不需要传递cls参数；
（4）在类方法内部，也可以直接通过cls.访问类的属性，和其他的类方法；

~ 静态方法

1、静态方法：类中的方法既不需要访问类属性，也不需要访问实例属性，这时就可以把方法定义成静态方法；

2、静态方法定义语法：@staticmethod def 静态方法名(): pass
（1）使用修饰器@staticmethod来标识，告诉解释器这是一个静态方法；
（2）不需要传递参数；
（3）不需要创建对象，可以直接通过类名.方法的方式来调用静态方法；

~ 实例方法、类方法、静态方法

1、实例方法：方法内部需要访问实力属性； 实例方法内部可以使用类名.类属性来访问类属性；
2、类方法：方法内部只需要访问类属性；
3、静态方法：方法内部既不需要访问实例属性，也不需要访问类属性；

若方法内部既需要访问实例属性，又需要访问类属性，应该定义成实例方法，因为类只有一个，在实例方法内部可以使用类名.类属性来访问类属性；

~ 单例

1、单例设计模式：让类创建的对象，在系统中只有唯一的一个实例，每次执行类名()返回的对象，内存地址都是相同的；

2、__new__方法：是一个有object基类提供的内置静态方法，主要作用：
（1）在内存中为对象分配空间：使用类名()创建对象时，Python解释器会先调用__new__方法为对象分配空间；
（2）返回对象的引用：Python解释器获得对象的引用之后，将引用作为第一个参数，传递给__init__方法；

3、重写__new__方法：一定要return super().__new__(cls)，否则解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法；

4、单例的实现：让类创建的对象，在系统中只有唯一的一个；
（1）定义一个类属性，初始值为None，用于记录单例对象的引用；
（2）重写__new__方法；
（3）若类属性is None，调用父类方法分配空间，并在类属性中记录结果；
（4）返回类属性中记录的对象引用；

5、只执行一次初始化操作：
在每次使用类名()创建对象时，解释器都会自动调用__new__和__init__两个方法分别用于分配空间，完成对象初始化 操作；使用单例重写__new__方法后，每次都会得到第一次被创建的对象的一引用，但是初始化方法还是会被再次调用，So需要重写__init__方法，让初始化操作也只被执行一次；
（1）定义一个类属性init_flag标记是否执行过初始化操作，初始值设置为False；
（2）在__init__方法中，判断init_flag，若为False就执行初始化操作；
（3）然后将init_flag设置为True；
（4）这样，再次自动调用__init__方法时，初始化操作就不会被再次执行了；

~ 异常

1、异常：程序在运行时，若解释器遇到一个错误，就会停止程序的运行，并提示一些错误信息，这就是异常；程序停止执行并提示错误信息的这个动作，就称之为抛出异常；也可以通过 异常捕获 针对突发事件做集中处理，从而保证程序的稳定性和健壮性；

2、捕获异常：程序开发中，若对某些代码的执行不能确定是否正确，可以增加是否正确，可以增加try(尝试)来捕获异常；

3、捕获未知错误：开发时很难预判出所有可能出现的错误，若希望程序无论出现什么类型的错误，都不会因为解释器抛出异常而被终止，可以增加对未知错误的捕获代码；

4、捕获异常的完整语法：

5、异常的传递性：当函数/方法执行出现异常时，会将异常向上传递给函数/方法的调用一方，若传递到主程序，仍然没有异常处理，程序才会被终止；

在开发中，可以在主函数中增加异常捕获，而在主函数中调用其他函数，只要出现异常，都会传递到主函数的异常捕获中，这样就不需要在代码中增加大量的异常捕获，能够保证代码的整洁；

6、主动抛出异常：在开发中，除了代码执行出错解释器会抛出异常之外，还可以根据特有的业务需求主动抛出异常，再由调用它的主函数捕获/处理异常；Eg：提示用户输入密码，若长度小于8，抛出异常；

（1）Python提供了一个Exception异常类，开发时，若希望抛出异常，可以创建一个Exception类的对象，再使用raise关键字抛出异常对象；

~ 模块

1、模块：每一个以.py结尾的Python源代码文件都是一个模块；
（1）模块名同样也是一个标识符，需要符合标识符的命名规则；
（2）在模块中定义的全局变量、函数、类都是提供给外界直接使用的工具；

2、模块的导入：
（1）模块使用前需要先import导入：import 模块名1、import 模块名2；（导入模块时，每个导入独占一行）
（2）导入之后，通过模块名.xx可以直接使用模块提供的工具 - 全局变量、函数、类；
（3）若模块名字太长，可以在导入时使用as指定模块的别名，以方便在代码中使用：import 模块名1 as 模块1别名；（模块别名应符合大驼峰命名法）；别名只在当前文件中有效；

3、导入模块中的部分工具：
（1）若希望从某一个模块中，导入部分工具，可以使用from .. import的方式；
（2）from 模块名 import 工具名
（3）导入之后，不需要通过模块名，可以直接使用模块提供的工具 - 全局变量、函数、类；import 模块名是一次性把模块中所有工具导入，并且通过模块名/别名.进行访问；
（4）若两个模块中存在同名的函数，那么后导入的模块的函数，会覆盖先导入的模块的函数；一旦发现冲突，可以使用as关键字给其中一个工具起一个别名；

4、模块的搜索顺序：
（1）解释器在导入模块时，会先在当前目录下搜索指定的模块名的文件，若有就直接导入，若没有就再搜索系统目录(Python解释器所在目录)；
（2）在开发时，给文件起名，不要和系统的模块文件重名；
（3）Python中每一个模块都有一个内置属性__file__可以查看模块的完整路径；

5、原则：每一个文件都应该是可以被导入的；
（1）一个独立的Python文件就是一个模块，在导入文件时，文件中所有没有任何缩进的代码都会被执行一遍；但是这些没有缩进的文件大多数是对该模块的测试用代码，仅在模块内使用，不需要在被导入文件中执行；

（2）__name__属性：是Python内置属性，可以使模块的测试代码只在本模块中在测试的情况下被执行，而在被导入时不会被执行；
（3）__name__属性记录着一个字符串：在本模块中值是__main，在导入的模块中值是__name__；

~ 包

1、包：是一个包含有多个模块的特殊的目录，目录下有一个特殊的文件__init__.py；
（1）包名的命名方式：和变量名一致，小写字母+下划线；
（2）使用import 包名可以一次性导入包中所有的模块；

2、要在外界使用包中的模块，需要在__init__.py中指定对外界提供的模块列表：from . import 模块名

~ 发布/使用模块

1、 制作模块发布的压缩包：
（1）在当前目录下（和包同级目录）创建setup.py文件：

（2）构建模块：命令行模式下进入到当前目录，$ python3 setup.py build
（3）生成发布的压缩包：$ python3 setup.py sdist

2、安装模块：
（1）解压缩：tar -zxvf xx.tar.gz
（2）安装：sudu python3 setip.py install

3、卸载模块：直接从安装目录下，把安装模块的目录删除就可以了；
（1）cd /usr/.../dist-packages/
（2）sudo rm -r 模块名*

4、使用pip快速的安装第三方模块：
（1）pip是一个现代的，通用的Python包管理工具，提供了对Python包的查找、下载、安装、卸载等功能；
（2）安装和卸载命令：

• 将模块安装到Python2.0环境：$ sudo pip install pygame、$ sudo pip uninstall pygame
• 将模块安装到Python3.0环境：$ sudo pip3 install pygame、$ sudo pip3 uninstall pygame

---

>> 文件操作

~ 文件基本操作

1、 操作文件的函数/方法：三个方法需要通过文件对象来调用
（1）函数open：打开文件，并且返回文件操作对象；
（2）方法read：将文件内容读取到内存；方法执行后，会把文件指针移动到文件的末尾；
（3）方法write：将指定内容写入文件；
（4）方法close：关闭文件；

2、read方法 - -读取文件：
（1）file = open("文件名")：open函数的第一个参数是要打开的文件名（区分大小写）；若文件存在，返回文件操作对象，若文件不存在，抛出异常；
（2）text = file.read()：read方法可以一次性读入并返回文件的所有内容；
（3）file.close()：close方法负责关闭文件；若忘记关闭文件，会造成系统资源消耗，而且会影响后续对文件的访问；

（4）文件指针：标记从哪个位置开始读取数据；第一次打开文件时，通常文件指针会在文件的开始位置，执行完read方法之后，文件指针会移动到读取内容的末尾（默认是文件末尾）；所以执行了一次read方法之后，读取了所有的内容，再次调用read方法，就不会再读取到任何内容了；

3、打开文件的方式：f = open("文件名", "打开方式")；（默认以只读方式打开）

4、按行读取文件：
（1）read方法默认会把文件的所有内容一次性读取到内存，若文件太大，对内存的占用会非常的大；
（2）readline方法可以一次读取一行内容，方法执行后，会把文件指针自动移动到下一行，准备再次读取；
（3）读取大文件时，可以使用while循环读取每一行内容，使用if判断每次循环是否读到内容（读到的内容赋值给变量，判断变量是否为空），若没有读到，说明文件已读完，break跳出while循环；

5、大文件复制练习：打开一个已有的文件，一行一行读取内容，并写入到另一个文件；

# 1.打开文件
file_read = open("aa") # 默认按照只读模式打开文件
file_write = open("aa附件", "w")  # 指定以只写方式打开文件
# 2.执行读、写操作
while True:
    # 读取一行内容
    text = file_read.readline()
    if not text:    # 若text为空，说明没有读取到内容
        break       # 直接break，跳出循环
    file_write.write(text)
# 3.关闭文件
file_read.close()
file_write.close()

6、文件/目录的常用管理操作：
（1）在终端/文件浏览器中，可以执行常规的文件/目录管理操作：创建、重命名、删除、改变路径、查看目录内容…
（2）在Python中，执行上述操作之前，需要导入os模块，然后使用这个模块提供的方法；
（3）文件操作：

• rename：重命名文件，os.rename(源文件名, 目标文件名)
• remove：删除文件，os.remove(文件名)
  （4）目录操作：
• listdir：目录列表，os.listdir(目录名)
• mkdir：创建目录，os.nkdir(目录名)
• rmdir：删除目录，os.rmdir(目录名)
• getcwd：获取当前目录，os.getcwd()
• chdir：修改工作目录，os.chdir(目标目录)
• path.isdir：判断是否是文件，os.path.isdir(文件路径)
  （5）提示：文件或目录操作都支持相对路径和绝对路径；

7、文件编码：
（1）ASCII编码：美国人制定的，包括大小写英文字母、数字、一些符号，没有中文；一个ASCII码在内存中占用一个字节空间，ASCII码表中包含256个字符；
（2）GB2312编码：中国制定的，比ASCII码多了了中文，一个中文占用两个字节；
（3）Unicode编码：包括所有语言，一个字符通常占用两个字节；
（4）UTF-8编码：由Unicode转化来的可变长编码，所以ASCII编码实际上可以被看成是UTF-8编码的一部分；
UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间
（5）在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

（6）Python2.x默认使用ASCII编码；Python3.x默认使用UTF-8编码；
（7）在Python2中指定文件编码格式：在文件第一行增加代码，解释器就会以指定编码格式来处理文件：# *-* coding:utf-8 *-* 、 # coding=utf-8；
（8）在Python2中，即使指定了文件的使用utf-8的编码格式，在遍历字符串时，仍然会以字节为单位遍历字符串；若要能够正确遍历字符串，在定义字符串时，需要在字符串的引号前增加一个小写字母u，告诉解释器这是一个Unicode字符串（使用UTF-8编码格式的字符串）；

~ eval函数

1、eval()：将字符串当成有效的表达式来求值并返回计算结果；

2、注意：eval函数不要滥用：不要使用eval函数直接转换input的结果；
若用户直接通过控制台输入__import__('os').system('终端命令')导入os模块来调用system方法，可以执行任何的终端命令，后果很严重！