python_ introduction

1、计算机核心基础

1.1 什么是语言？什么是编程语言？为何要有编程语言？
语言其实就是人与人之间沟通的介质，如英语，汉语，俄语等。
编程语言则是人与计算机之间沟通的介质,
编程的目的就是为了让计算机按照人类的思维逻辑(程序)自发地去工作从而把人力解放出来
二 计算机组成原理
2.1、什么是计算机？
俗称电脑，即通电的大脑，电脑二字蕴含了人类对计算机的终极期望，希望它能真的像人脑一样去工作，从而解放人力。
2.2、为什么要用计算机？
世界是由聪明的懒人统治的，任何时期，总有一群聪明的懒人想要奴隶别人。在奴隶制社会，聪明的懒人奴役的是真正的人，而人是无法不吃、不喝、不睡觉一直工作的，但是计算机作为一台机器是可以做到的，所以把计算机当奴隶是上上之选
2.3、计算机的五大组成部分
1.控制器
:控制器是计算机的指挥系统，用来控制计算机其他组件的运行，相当于人类的大脑
2.运算器
:运算器是计算机的运算功能，用来做算术运算和逻辑运算，相当于人脑
ps：控制器+运算器=CPU，cpu相当于人的大脑
​
3.存储器
:存储器是计算机的记忆功能，用来存取数据。
​
存储器主要分为内存与外存：
​
• 内存相当于人的短期记忆。断电数据丢失
​
• 外存(如磁盘),相当于记事的本子，断电数据不会丢失，是用来永久保存数据的
​
• ps：内存的存取速度要远远高于外存
4.输入设备input
:输入设备是计算接收外界输入数据的工具，如键盘、鼠标，相当于人的眼睛或耳朵。
5.输出设备output
:输出设备是计算机向外输出数据的工具，如显示器、打印机，相当于人说的话，写出的文章。
​
ps：存储器如内存、磁盘等既是输入设备又是输出设备，统称为IO设备
三大核心硬件为CPU、内存、硬盘。

程序最先是存放于硬盘中的，程序的运行是先从硬盘把代码加载到内存中，然后cpu是从内存中读取指令运行。

三 操作系统概述
3.1、操作系统的由来
操作系统的功能就是帮我们把复杂的硬件的控制封装成简单的接口，对于开发应用程序来说只需要调用操作系统提供给我们的接口即可
3.2、系统软件与应用软件
硬件以上运行的都是软件，而软件分为两类：

一、应用软件（例如qq、word、暴风影音，我们学习python就是为了开发应用软件的）
​
二、操作系统，操作系统应用软件与硬件之间的一个桥梁，是协调、管理、控制计算机硬件与应用软件资源的控制程序。
3.3、计算机系统三层结构
应用程序
操作系统
计算机硬件
硬件 + 操作系统 == 平台

2、编程语言与Python介绍
编程语言分类：
机器语言
机器语言是站在计算机(奴隶)的角度，说计算机能听懂/理解的语言，而计算机能直接理解的就是二进制指令，所以机器语言就是直接用二进制编程，这意味着机器语言是直接操作硬件的，因此机器语言属于低级语言，此处的低级指的是底层、贴近计算机硬件

机器语言

用二进制代码0和1描述的指令称为机器指令，由于计算机内部是基于二进制指令工作的，所以机器语言是直接控制计算机硬件。

​
用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码以及代码的含义，然后在编写程序时，程序员得自己处理每条指令和每一数据的存储分配和输入输出，还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作。编写程序花费的时间往往是实际运行时间的几十倍或几百倍。而且，编出的程序全是些0和1的指令代码，直观性差，不便阅读和书写，还容易出错，且依赖于具体的计算机硬件型号，局限性很大。除了计算机生产厂家的专业人员外，绝大多数的程序员已经不再去学习机器语言了。
​
机器语言是被微处理器理解和使用的，存在有多至100000种机器语言的指令，下述是一些简单示例
​
#指令部份的示例
0000 代表 加载（LOAD）
0001 代表 存储（STORE）
...
​
#暂存器部份的示例
0000 代表暂存器 A
0001 代表暂存器 B
...
​
#存储器部份的示例
000000000000 代表地址为 0 的存储器
000000000001 代表地址为 1 的存储器
000000010000 代表地址为 16 的存储器
100000000000 代表地址为 2^11 的存储器
​
#集成示例
0000,0000,000000010000 代表 LOAD A, 16
0000,0001,000000000001 代表 LOAD B, 1
0001,0001,000000010000 代表 STORE B, 16
0001,0001,000000000001 代表 STORE B, 1[1]
总结机器语言

1、执行效率最高

编写的程序可以被计算机无障碍理解、直接运行，执行效率高 。
​

2、开发效率最低

复杂，开发效率低
​

3、跨平台性差

贴近\依赖具体的硬件，跨平台性差
汇编语言
汇编语言仅仅是用一个英文标签代表一组二进制指令，毫无疑问，比起机器语言，汇编语言是一种进步，但汇编语言的本质仍然是直接操作硬件，因此汇编语言仍是比较低级/底层的语言、贴近计算机硬件

汇编语言

汇编语言的实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用了英文缩写的标识符，更容易识别和记忆。它同样需要编程者将每一步具体的操作用命令的形式写出来。汇编程序的每一句指令只能对应实际操作过程中的一个很细微的动作。例如移动、自增，因此汇编源程序一般比较冗长、复杂、容易出错，而且使用汇编语言编程需要有更多的计算机专业知识，但汇编语言的优点也是显而易见的，用汇编语言所能完成的操作不是一般高级语言所能够实现的，而且源程序经汇编生成的可执行文件不仅比较小，而且执行速度很快。
​
汇编的hello world，打印一句hello world, 需要写十多行，如下
​
; hello.asm
section .data ; 数据段声明
msg db "Hello, world!", 0xA ; 要输出的字符串
len equ $ - msg ; 字串长度
section .text ; 代码段声明
global _start ; 指定入口函数
_start: ; 在屏幕上显示一个字符串
mov edx, len ; 参数三：字符串长度
mov ecx, msg ; 参数二：要显示的字符串
mov ebx, 1 ; 参数一：文件描述符(stdout)
mov eax, 4 ; 系统调用号(sys_write)
int 0x80 ; 调用内核功能
; 退出程序
mov ebx, 0 ; 参数一：退出代码
mov eax, 1 ; 系统调用号(sys_exit)
int 0x80 ; 调用内核功能
总结汇编语言

1、执行效率高

相对于机器语言，使用英文标签编写程序相对简单，执行效率高，但较之机器语言稍低，
​

2、开发效率低：

仍然是直接操作硬件，比起机器语言来说，复杂度稍低，但依旧居高不下，所以开发效率依旧较低
​

3、跨平台性差

同样依赖具体的硬件，跨平台性差
高级语言
高级语言是站在人(奴隶主)的角度，说人话，即用人类的字符去编写程序，而人类的字符是在向操作系统发送指令，而非直接操作硬件，所以高级语言是与操作系统打交道的，此处的高级指的是高层、开发者无需考虑硬件细节，因而开发效率可以得到极大的提升，但正因为高级语言离硬件较远，更贴近人类语言，人类可以理解，而计算机则需要通过翻译才能理解，所以执行效率会低于低级语言。

按照翻译的方式的不同，高级语言又分为两种：

编译型（如C语言）:
类似谷歌翻译，是把程序所有代码编译成计算机能识别的二进制指令，之后操作系统会拿着编译好的二进制指令直接操作硬件，详细如下

1、执行效率高

编译是指在应用源程序执行之前，就将程序源代码“翻译”成目标代码（即机器语言），
因此其目标程序可以脱离其语言环境独立执行，使用比较方便，执行效率较高。
​

2、开发效率低：

应用程序一旦需要修改，必须先修改源代码，然后重新编译、生成新的目标文件才能执行，
而在只有目标文件而没有源代码，修改会很不方便。所以开发效率低于解释型
​

3、跨平台性差

编译型代码是针对某一个平台翻译的，当前平台翻译的结果无法拿到不同的平台使用，针对不同的平台必须重新编译，即跨平台性差
​

其他

现在大多数的编程语言都是编译型的。
编译程序将源程序翻译成目标程序后保存在另一个文件中，该目标程序可脱离编译程序直接在计算机上多次运行。
大多数软件产品都是以目标程序形式发行给用户的，不仅便于直接运行，同时又使他人难于盗用其中的技术。
C、C++、Ada、Pascal都是编译实现的
解释型（如python）:
类似同声翻译，需要有一个解释器，解释器会读取程序代码，一边翻译一边执行，详细如下

1、执行效率低

解释型语言的实现中，翻译器并不产生目标机器代码，而是产生易于执行的中间代码。
这种中间代码与机器代码是不同的，中间代码的解释是由软件支持的，不能直接使用硬件，
软件解释器通常会导致执行效率较低。
​

2、开发效率高

用解释型语言编写的程序是由另一个可以理解中间代码的解释程序执行的，与编译程序不同的是，
解释程序的任务是逐一将源程序的语句解释成可执行的机器指令，不需要将源程序翻译成目标代码再执行。
解释程序的优点是当语句出现语法错误时，可以立即引起程序员的注意，而程序员在程序开发期间就能进行校正。
​
​

3、跨平台性强

代码运行是依赖于解释器，不同平台有对应版本的解释器，所以解释型的跨平台性强
​

其他

对于解释型Basic语言，需要一个专门的解释器解释执行Basic程序，每条语句只有在执行时才被翻译，
这种解释型语言每执行一次就翻译一次，因而效率低下。一般地，动态语言都是解释型的，
例如：Tcl、Perl、Ruby、VBScript、JavaScript等
ps：混合型语言

java是一类特殊的编程语言，Java程序也需要编译，但是却没有直接编译为机器语言，而是编译为字节码，
然后在Java虚拟机上以解释方式执行字节码。
总结
综上选择不同编程语言来开发应用程序对比

1、执行效率：机器语言>汇编语言>高级语言（编译型>解释型）

​

2、开发效率：机器语言<汇编语言<高级语言（编译型<解释型）

​

3、跨平台性：解释型具有极强的跨平台型

三 python介绍
谈及python，涉及两层意思，一层代表的是python这门语言的语法风格，另外一层代表的则是专门用来解释该语法风格的应用程序：python解释器。

Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言

Python解释器的发展史
从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。

Python解释器有哪些种类?
官方的Python解释器本质就是基于C语言开发的一个软件，该软件的功能就是读取以.py结尾的文件内容，然后按照Guido定义好的语法和规则去翻译并执行相应的代码。

Jython

JPython解释器是用JAVA编写的python解释器，可以直接把Python代码编译成Java字节码并执行，它不但使基于java的项目之上嵌入python脚本成为可能，同时也可以将java程序引入到python程序之中。
​

IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。这就好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
​

PyPy

PyPy是Python开发者为了更好地Hack Python而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒功能，对Python代码进行动态编译（注意不是解释），因此运行速度比CPython还要快。
​

IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
四 安装Cpython解释器
Python解释器目前已支持所有主流操作系统，在Linux,Unix,Mac系统上自带Python解释器，在Windows系统上需要安装一下，具体步骤如下。

4.1、下载python解释器
https://www.python.org

img

img

img

4.2、安装python解释器
img

img

img

4.3、测试安装是否成功
windows --> 运行 --> 输入cmd ，然后回车，弹出cmd程序，输入python,如果能进入交互环境 ，代表安装成功。

img

img

五 第一个python程序
5.1 运行python程序有两种方式
方式一： 交互式模式

img

方式二：脚本文件

1、打开一个文本编辑工具，写入下述代码，并保存文件，此处文件的路径为D:\test.py。强调：python解释器执行程序是解释执行，解释的根本就是打开文件读内容，因此文件的后缀名没有硬性限制，但通常定义为.py结尾

print('hello world')
​

2、打开cmd，运行命令，如下图

img

总结：

1、交互式模式下可以即时得到代码执行结果，调试程序十分方便

2、若想将代码永久保存下来，则必须将代码写入文件中

3、我们以后主要就是在代码写入文件中，偶尔需要打开交互式模式调试某段代码、验证结果

5.2 注释
在正式学习python语法前，我们必须事先介绍一个非常重要的语法：注释

1、什么是注释

注释就是就是对代码的解释说明，注释的内容不会被当作代码运行
2、为什么要注释

增强代码的可读性
3、怎么用注释?

代码注释分单行和多行注释
​
1、单行注释用#号，可以跟在代码的正上方或者正后方
​
2、多行注释可以用三对双引号""" """
4、代码注释的原则：

1、不用全部加注释，只需要为自己觉得重要或不好理解的部分加注释即可
​
2、注释可以用中文或英文，但不要用拼音
六 IDE工具pycharm的使用
在编写第一个python程序时，存在以下问题，严重影响开发效率

问题一：我们了解到一个python程序从开发到运行需要操作至少两个软件

1、打开一个软件：文本编辑器，创建文本来编写程序
2、打开cmd，然后输入命令执行pyton程序
问题二：在开发过程中，并没代码提示以及纠错功能

综上，如果能有一款工具能够集成n个软件的功能，同时又代码提示以及纠错等功能，那么将会极大地提升程序员的开发效率，这就是IDE的由来，IDE全称Integrated Development Environment，即集成开发环境，最好的开发Python程序的IDE就是PyCharm。
6.2、pychram安装

下载地址: https://www.jetbrains.com/pycharm/download 选择Professional专业版

6.3、Pycharm创建文件夹
6.4、如何创建文件并编写程序执行
创建py文件test.py

在test.py中写代码，输入关键字的开头可以用tab键补全后续，并且会有代码的错误提示

3、Python语法入门之变量
一 引入
我们学习python语言是为了控制计算机、让计算机能够像人一样去工作，所以在python这门语言中，所有语法存在的意义都是为了让计算机具备人的某一项技能，这句话是我们理解后续所有python语法的根本。

二 变量
一、什么是变量？

变量就是可以变化的量，量指的是事物的状态，比如人的年龄、性别，游戏角色的等级、金钱等等

二、为什么要有变量？

为了让计算机能够像人一样去记忆事物的某种状态，并且状态是可以发生变化的

详细地说：

程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化。

三、怎么使用变量（先定义、后使用）
3.1、变量的定义与使用
img

定义变量示范如下

name = 'harry' # 记下人的名字为'harry'
sex = '男' # 记下人的性别为男性
age = 18 # 记下人的年龄为18岁
salary = 30000.1 # 记下人的薪资为30000.1元
解释器执行到变量定义的代码时会申请内存空间存放变量值，然后将变量值的内存地址绑定给变量名，以变量的定义age=18为例，如下图

插图：定义变量申请内存

通过变量名即可引用到对应的值

通过变量名即可引用到值，我们可以结合print()功能将其打印出来

print(age) # 通过变量名age找到值18，然后执行print(18),输出：18

命名规范

1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 关键字不能声明为变量名，常用关键字如下
   ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from','global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
   年龄=18 # 强烈建议不要使用中文命名
   ​
   3.3、变量名的命名风格

风格一：驼峰体

AgeOfTony = 56
NumberOfStudents = 80

风格二：纯小写下划线(在python中，变量名的命名推荐使用该风格)

age_of_tony = 56
number_of_students = 80
3.4、变量值的三大特性

1、id

反应的是变量在内存中的唯一编号，内存地址不同id肯定不同
​

2、type

变量值的类型
​

3、value

变量值
三、常量
3.1、什么是常量？
常量指在程序运行过程中不会改变的量

3.2、为什么要有常量？
在程序运行过程中，有些值是固定的、不应该被改变，比如圆周率 3.141592653...

3.3、怎么使用常量？
在Python中没有一个专门的语法定义常量，约定俗成是用全部大写的变量名表示常量。如：PI=3.14159。所以单从语法层面去讲，常量的使用与变量完全一致。

4、Python语法入门之基本数据类型
一 引入
变量值也有不同的类型

salary = 3.1 # 用浮点型去记录薪资
age = 18 # 用整型去记录年龄
name = 'lili' # 用字符串类型去记录人名
二 数字类型
2.1 int整型
2.1.1 作用
用来记录人的年龄，出生年份，学生人数等整数相关的状态

2.1.2 定义
age=18
​
birthday=1990
​
student_count=48
2.2 float浮点型
2.2.1 作用
用来记录人的身高，体重，薪资等小数相关的状态

2.2.2 定义
height=172.3
​
weight=103.5
​
salary=15000.89
2.3 数字类型的使用
1 、数学运算

a = 1
b = 3
c = a + b
c
4
2、比较大小

x = 10
y = 11
x > y
False
三 字符串类型str
3.1 作用
用来记录人的名字，家庭住址，性别等描述性质的状态

3.2 定义
name = 'harry'
​
address = '上海市浦东新区'
​
sex = '男'
用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的，但是

1、需要考虑引号嵌套的配对问题

msg = "My name is Tony , I'm 18 years old!" #内层有单引号，外层就需要用双引号

2、多引号可以写多行字符串

msg = '''
天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。
不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。
'''
3.3 使用
数字可以进行加减乘除等运算，字符串呢？也可以，但只能进行"相加"和"相乘"运算。

name = 'tony'
age = '18'
name + age #相加其实就是简单的字符串拼接
'tony18'
name * 5 #相乘就相当于将字符串相加了5次
'tonytonytonytonytony'
四 列表list
4.1 作用
如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型确实可以记录下来，比如

stu_names='张三 李四 王五'，但存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦，而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便

4.2 定义

stu_names=['张三','李四','王五']
4.3 使用

1、列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数

stu_names=['张三','李四','王五']
stu_names[0]
'张三'
stu_names[1]
'李四'
stu_names[2]
'王五'

2、列表可以嵌套，嵌套取值如下

students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]
students_info[0][2][0] #取出第一个学生的第一个爱好
'play'
五 字典dict
5.1 作用
如果我们需要用一个变量记录多个值，但多个值是不同属性的，比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义，这就用到字典类型，字典类型是用key：value形式来存储数据，其中key可以对value有描述性的功能

5.2 定义

person_info={'name':'tony','age':18,'height':185.3}
5.3 使用

1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型

person_info={'name':'tony','age':18,'height':185.3}
person_info['name']
'tony'
person_info['age']
18
person_info['height']
185.3

2、字典可以嵌套，嵌套取值如下

students=[
... {'name':'tony','age':38,'hobbies':['play','sleep']},
... {'name':'jack','age':18,'hobbies':['read','sleep']},
... {'name':'rose','age':58,'hobbies':['music','read','sleep']},
... ]
students[1]['hobbies'][1] #取第二个学生的第二个爱好
'sleep'
六 布尔bool
6.1 作用
用来记录真假这两种状态

6.2 定义

is_ok = True
is_ok = False
6.3 使用
通常用来当作判断的条件，我们将在if判断中用到它
5、Python语法入门之垃圾回收机制
一 引入
解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题，当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？
​
• 单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用），所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。
​
• 毫无疑问，内存空间的申请与回收都是非常耗费精力的事情，而且存在很大的危险性，稍有不慎就有可能引发内存溢出问题，好在Cpython解释器提供了自动的垃圾回收机制来帮我们解决了这件事。
二、什么是垃圾回收机制？
垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间
三、为什么要用垃圾回收机制？
程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃，因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。
四、理解GC原理需要储备的知识
4.1、堆区与栈区
在定义变量时，变量名与变量值都是需要存储的，分别对应内存中的两块区域：堆区与栈区

1、变量名与值内存地址的关联关系存放于栈区

​

2、变量值存放于堆区，内存管理回收的则是堆区的内容，

4.2 直接引用与间接引用
直接引用指的是从栈区出发直接引用到的内存地址。

间接引用指的是从栈区出发引用到堆区后，再通过进一步引用才能到达的内存地址。

如

l2 = [20, 30] # 列表本身被变量名l2直接引用，包含的元素被列表间接引用
x = 10 # 值10被变量名x直接引用
l1 = [x, l2] # 列表本身被变量名l1直接引用，包含的元素被列表间接引用
img

五、垃圾回收机制原理分析
Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率。

5.1、引用计数
引用计数就是：变量值被变量名关联的次数

如：age=18

变量值18被关联了一个变量名age，称之为引用计数为1

img

引用计数增加：

age=18 （此时，变量值18的引用计数为1）

m=age （把age的内存地址给了m，此时，m,age都关联了18，所以变量值18的引用计数为2）

img

引用计数减少：

age=10（名字age先与值18解除关联，再与3建立了关联，变量值18的引用计数为1）

del m（del的意思是解除变量名x与变量值18的关联关系，此时，变量18的引用计数为0）

img

值18的引用计数一旦变为0，其占用的内存地址就应该被解释器的垃圾回收机制回收

5.2、引用计数的问题与解决方案
5.2.1 问题一：循环引用
引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）

如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2

l1=['xxx'] # 列表1被引用一次，列表1的引用计数变为1
l2=['yyy'] # 列表2被引用一次，列表2的引用计数变为1
l1.append(l2) # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
l2.append(l1) # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2
​

l1与l2之间有相互引用

l1 = ['xxx'的内存地址,列表2的内存地址]

l2 = ['yyy'的内存地址,列表1的内存地址]

l1
['xxx', ['yyy', [...]]]
l2
['yyy', ['xxx', [...]]]
l1[1][1][0]
'xxx'
img

python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题

5.2.2 解决方案：标记-清除
容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记-清除”计数就是为了解决循环引用的问题。

标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除

5.2.3 问题二：效率问题
基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都遍历一遍，这是非常消耗时间的，于是引入了分代回收来提高回收效率，分代回收采用的是用“空间换时间”的策略。
5.2.4 解决方案：分代回收
代：

分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：

分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）
​
新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。也就是等级（代）越高，被垃圾回收机制扫描的频率越低
回收：

回收依然是使用引用计数作为回收的依据

img

虽然分代回收可以起到提升效率的效果，但也存在一定的缺点：

例如一个变量刚刚从新生代移入青春代，该变量的绑定关系就解除了，该变量应该被回收，但青春代的扫描频率低于新生代，这就到导致了应该被回收的垃圾没有得到及时地清理。
​
没有十全十美的方案：
毫无疑问，如果没有分代回收，即引用计数机制一直不停地对所有变量进行全体扫描，可以更及时地清理掉垃圾占用的内存，但这种一直不停地对所有变量进行全体扫描的方式效率极低，所以我们只能将二者中和。
​
综上
垃圾回收机制是在清理垃圾&释放内存的大背景下，允许分代回收以极小部分垃圾不会被及时释放为代价，以此换取引用计数整体扫描频率的降低，从而提升其性能，这是一种以空间换时间的解决方案目录
6、Python语法入门之与用户交互、运算符
一 程序与用户交互
1.1、什么是与用户交互
用户交互就是人往计算机中input/输入数据，计算机print/输出结果

1.2、为什么要与用户交互？
为了让计算机能够像人一样与用户沟通交流
1.3、如何与用户交互
交互的本质就是输入、输出
1.3.1 输入input:

在python3中input功能会等待用户的输入，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名

username=input('请输入您的用户名：')
请输入您的用户名：jack # username = "jack"
password=input('请输入您的密码：')
请输入您的密码：123 # password = "123"
​

了解知识：

1、在python2中存在一个raw_input功能与python3中的input功能一模一样

2、在python2中还存在一个input功能，需要用户输入一个明确的数据类型，输入什么类型就存成什么类型

l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
type(l)
<type 'list'>
1.3.2 输出print:
print('hello world') # 只输出一个值
hello world
print('first','second','third') # 一次性输出多个值，值用逗号隔开
first second third
​

默认print功能有一个end参数，该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符

print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')

整体输出结果为：aaaabbbb&cccc@

1.3.3 输出之格式化输出
(1)什么是格式化输出？
把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。

(2)为什么要格式化输出？
我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。

(3)如何格式化输出？
这就用到了占位符，如：%s、%d：

%s占位符：可以接收任意类型的值

%d占位符：只能接收数字

print('亲爱的%s你好！你%s月的话费是%d，余额是%d' %('tony',12,103,11))
亲爱的tony你好！你12月的话费是103，余额是11
​

练习1：接收用户输入，打印成指定格式

name = input('your name: ')
age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' %(name,age))
​

练习2：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式

------------ info of Tony -----------
Name : Tony
Age : 22
Sex : male
Job : Teacher
------------- end -----------------
二 基本运算符
2.1 算术运算符
python支持的算数运算符与数学上计算的符号使用是一致的，我们以x=9，y=2为例来依次介绍它们

img

2.2 比较运算符
比较运算用来对两个值进行比较，返回的是布尔值True或False，我们以x=9，y=2为例来依次介绍它们

img

2.3 赋值运算符
python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。我们以x=9，y=2为例先来介绍一下增量赋值

2.3.1 增量赋值
img

2.3.2 链式赋值
如果我们想把同一个值同时赋值给多个变量名，可以这么做

z=10
y=z
x=y
x,y,z
(10, 10, 10)
链式赋值指的是可以用一行代码搞定这件事

x=y=z=10
x,y,z
(10, 10, 10)
2.3.3 交叉赋值
我们定义两个变量m与n

如果我们想将m与n的值交换过来，可以这么做

temp=m
m=n
n=temp
m,n
(20, 10)
交叉赋值指的是一行代码可以搞定这件事

m=10
n=20
m,n=n,m # 交叉赋值
m,n
(20, 10)
2.3.4 解压赋值
如果我们想把列表中的多个值取出来依次赋值给多个变量名，可以这么做

nums=[11,22,33,44,55]

a=nums[0]
b=nums[1]
c=nums[2]
d=nums[3]
e=nums[4]
a,b,c,d,e
(11, 22, 33, 44, 55)
解压赋值指的是一行代码可以搞定这件事

a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
a,b,c,d,e
(11, 22, 33, 44, 55)
注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

1、变量名少了

a,b=nums
Traceback (most recent call last):
File "", line 1, in
ValueError: too many values to unpack (expected 2)
​

2、变量名多了

a,b,c,d,e,f=nums
Traceback (most recent call last):
File "", line 1, in
ValueError: not enough values to unpack (expected 6, got 5)
但如果我们只想取头尾的几个值，可以用*_匹配

a,b,*_=nums
a,b
(11, 22)
ps：字符串、字典、元组、集合类型都支持解压赋值

2.4 逻辑运算符
逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False

img

2.4.1 连续多个and
可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False，只有在所有条件的结果都为True的情况下，最终结果才为True。

2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False
2.4.2 连续多个or
可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False

2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True
2.4.3 优先级not>and>or

1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。

3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False
​

2、最好使用括号来区别优先级，其实意义与上面的一样

'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
​
(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
​
(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''

(3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False
​

3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回

10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4
我们用括号来明确一下优先级
(10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4
短路： 0 '' 'abc'
假 假 真
​
返回： 'abc'
​

4、短路运算面试题：

1 or 3
1
1 and 3
3
0 and 2 and 1
0
0 and 2 or 1
1
0 and 2 or 1 or 4
1
0 or False and 1
False
2.5 成员运算符
img

注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

not 'lili' in ['jack','tom','robin']
True
'lili' not in ['jack','tom','robin']
True
2.6 身份运算符
img

需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等

1. id相同，内存地址必定相同，意味着type和value必定相同

2. value相同type肯定相同，但id可能不同,如下

x='Info Tony:18'
y='Info Tony:18'
id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)
​
​
x == y # 等号比较的是value
True
type(x),type(y) # 值相同type肯定相同
(<class 'str'>, <class 'str'>)
x is y # is比较的是id，x与y的值相等但id可以不同
False
​
7、Python语法入门之流程控制
一 引子：
流程控制即控制流程，具体指控制程序的执行流程，而程序的执行流程分为三种结构：顺序结构（之前我们写的代码都是顺序结构）、分支结构（用到if判断）、循环结构（用到while与for）

二 分支结构
2.1 什么是分支结构
分支结构就是根据条件判断的真假去执行不同分支对应的子代码

2.2 为什么要用分支结构
人类某些时候需要根据条件来决定做什么事情，比如：如果今天下雨，就带伞

所以程序中必须有相应的机制来控制计算机具备人的这种判断能力

2.3 如何使用分支结构
2.3.1 if语法
用if关键字来实现分支结构，完整语法如下

if 条件1: # 如果条件1的结果为True，就依次执行：代码1、代码2，......
　代码1
代码2
......
elif 条件2: # 如果条件2的结果为True，就依次执行：代码3、代码4，......
　代码3
代码4
......
elif 条件3: # 如果条件3的结果为True，就依次执行：代码5、代码6，......
　代码5
代码6
......
else:　　 # 其它情况，就依次执行：代码7、代码8，......
代码7
代码8
......

注意：

1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行

2、条件可以是任意表达式，但执行结果必须为布尔类型

 # 在if判断中所有的数据类型也都会自动转换成布尔类型
   # 2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False
   # 2.2、其余均为True

2.3.2 if应用案例
案例1：

如果：女人的年龄>30岁，那么：叫阿姨

age_of_girl=31
if age_of_girl > 30:
print('阿姨好')
案例2：

如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐

age_of_girl=18
if age_of_girl > 30:
print('阿姨好')
else:
print('小姐好')
案例3：

如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨**

age_of_girl=18
height=171
weight=99
is_pretty=True
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
print('表白...')
else:
print('阿姨好')
案例4：

如果：成绩>=90，那么：优秀

如果成绩>=80且<90,那么：良好

如果成绩>=70且<80,那么：普通

其他情况：很差

score=input('>>: ')
score=int(score)
​
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
else:
print('很差')
案例 5：if 嵌套

在表白的基础上继续：

如果表白成功，那么：在一起

否则：打印。。。

​
age_of_girl=18
height=171
weight=99
is_pretty=True
success=False
​
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
if success:
print('表白成功,在一起')
else:
print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊...')
else:
print('阿姨好')
练习1: 登陆功能

name=input('请输入用户名字：').strip()
password=input('请输入密码：').strip()
if name == 'tony' and password == '123':
print('tony login success')
else:
print('用户名或密码错误')
练习2：

!/usr/bin/env python

根据用户输入内容打印其权限

​
'''
egon --> 超级管理员
tom --> 普通管理员
jack,rain --> 业务主管
其他 --> 普通用户
'''
name=input('请输入用户名字：')
​
if name == 'egon':
print('超级管理员')
elif name == 'tom':
print('普通管理员')
elif name == 'jack' or name == 'rain':
print('业务主管')
else:
print('普通用户')
三 循环结构
3.1 什么是循环结构
循环结构就是重复执行某段代码块

3.2 为什么要用循环结构
人类某些时候需要重复做某件事情

所以程序中必须有相应的机制来控制计算机具备人的这种循环做事的能力

3.3 如何使用循环结构
3.3.1 while循环语法
python中有while与for两种循环机制，其中while循环称之为条件循环，语法如下

while 条件:
代码1
代码2
代码3
while的运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止
img

3.3.2 while循环应用案例
案例一：while循环的基本使用

用户认证程序

用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断，判断成功则登陆成功，判断失败则输出账号或密码错误

username = "jason"
password = "123"
​
inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误！")

通常认证失败的情况下，会要求用户重新输入用户名和密码进行验证，如果我们想给用户三次试错机会，本质就是将上述代码重复运行三遍，你总不会想着把代码复制3次吧。。。。

username = "jason"
password = "123"
​

第一次验证

inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误！")
​

第二次验证

inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误！")
​

第三次验证

inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误！")
​

即使是小白的你，也觉得的太low了是不是，以后要修改功能还得修改3次，因此记住，写重复的代码是程序员最不耻的行为。

那么如何做到不用写重复代码又能让程序重复一段代码多次呢？ 循环语句就派上用场啦（使用while循环实现）

​
username = "jason"
password = "123"

记录错误验证的次数

count = 0
while count < 3:
inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误！")
count += 1
案例二：while+break的使用

使用了while循环后，代码确实精简多了，但问题是用户输入正确的用户名密码以后无法结束循环，那如何结束掉一个循环呢？这就需要用到break了！

username = "jason"
password = "123"

记录错误验证的次数

count = 0
while count < 3:
inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
break # 用于结束本层循环
else:
print("输入的用户名或密码错误！")
count += 1
案例三：while循环嵌套+break

如果while循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break

username = "jason"
password = "123"
count = 0
while count < 3: # 第一层循环
inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
while True: # 第二层循环
cmd = input('>>: ')
if cmd == 'quit':
break # 用于结束本层循环，即第二层循环
print('run <%s>' % cmd)
break # 用于结束本层循环，即第一层循环
else:
print("输入的用户名或密码错误！")
count += 1
案例四：while循环嵌套+tag的使用

针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环，其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束

username = "jason"
password = "123"
count = 0
​
tag = True
while tag:
inp_name = input("请输入用户名：")
inp_pwd = input("请输入密码：")
if inp_name == username and inp_pwd == password:
print("登陆成功")
while tag:
cmd = input('>>: ')
if cmd == 'quit':
tag = False # tag变为False， 所有while循环的条件都变为False
break
print('run <%s>' % cmd)
break # 用于结束本层循环，即第一层循环
else:
print("输入的用户名或密码错误！")
count += 1
案例五：while+continue的使用

break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环

打印1到10之间，除7以外的所有数字

number=11
while number>1:
number -= 1
if number==7:
continue # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
print(number)
案例五：while+else的使用

在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束

count = 0
while count <= 5 :
count += 1
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦 #没有被break打断，所以执行了该行代码
-----out of while loop ------
如果执行过程中被break，就不会执行else的语句

count = 0
while count <= 5 :
count += 1
if count == 3:
break
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句
练习1：

寻找1到100之间数字7最大的倍数（结果是98）

number = 100
while number > 0:
if number %7 == 0:
print(number)
break
number -= 1
练习2：

age=18
count=0
while count<3:
count+=1
guess = int(input(">>:"))
if guess > age :
print("猜的太大了，往小里试试...")
elif guess < age :
print("猜的太小了，往大里试试...")
else:
print("恭喜你，猜对了...")
3.3.3 for循环语法
循环结构的第二种实现方式是for循环，for循环可以做的事情while循环都可以实现，之所以用for循环是因为在循环取值（即遍历值）时for循环比while循环的使用更为简洁，

for循环语法如下

for 变量名 in 可迭代对象: # 此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解可迭代对象
代码一
代码二
...
​

例1

for item in ['a','b','c']:
print(item)

运行结果

a
b
c
​

参照例1来介绍for循环的运行步骤

步骤1：从列表['a','b','c']中读出第一个值赋值给item（item=‘a’），然后执行循环体代码

步骤2：从列表['a','b','c']中读出第二个值赋值给item（item=‘b’），然后执行循环体代码

步骤3: 重复以上过程直到列表中的值读尽

img

3.3.4 for循环应用案例

简单版：for循环的实现方式

for count in range(6): # range(6)会产生从0-5这6个数
print(count)
​

复杂版：while循环的实现方式

count = 0
while count < 6:
print(count)
count += 1
案例二：遍历字典

简单版：for循环的实现方式

for k in {'name':'jason','age':18,'gender':'male'}: # for 循环默认取的是字典的key赋值给变量名k
print(k)
​

复杂版：while循环确实可以遍历字典，后续将会迭代器部分详细介绍

案例三：for循环嵌套

请用for循环嵌套的方式打印如下图形：

---

---

---

​
for i in range(3):
for j in range(5):
print("*",end='')
print() # print()表示换行
注意：break 与 continue也可以用于for循环，使用语法同while循环

练习一：

打印九九乘法表

for i in range(1,10):
for j in range(1,i+1):
print('%s%s=%s' %(i,j,ij),end=' ')
print()
练习二：

打印金字塔

分析

'''

max_level=5

 *        # current_level=1，空格数=4，*号数=1
***       # current_level=2,空格数=3,*号数=3

***** # current_level=3,空格数=2,号数=5
******* # current_level=4,空格数=1,号数=7
********* # current_level=5,空格数=0,*号数=9
​

数学表达式

空格数=max_level-current_level
号数=2current_level-1
'''

实现：

max_level=5
for current_level in range(1,max_level+1):
for i in range(max_level-current_level):
print(' ',end='') #在一行中连续打印多个空格
for j in range(2current_level-1):
print('',end='') #在一行中连续打印多个空格
print()
8、基本数据类型及内置方法
一 引子
数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。

二 数字类型int与float
2.1 定义

1、定义：

1.1 整型int的定义

age=10 # 本质age = int(10)
​

1.2 浮点型float的定义

salary=3000.3 # 本质salary=float(3000.3)
​

注意：名字+括号的意思就是调用某个功能，比如

print(...)调用打印功能

int(...)调用创建整型数据的功能

float(...)调用创建浮点型数据的功能

2.2 类型转换

1、数据类型转换

1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错

s = '123'
res = int(s)
res,type(res)
(123, <class 'int'>)
​
int('12.3') # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
File "", line 1, in
ValueError: invalid literal for int() with base 10: '12.3'
​

1.2 进制转换

十进制转其他进制

bin(3)
'0b11'
oct(9)
'0o11'
hex(17)
'0x11'

其他进制转十进制

int('0b11',2)
3
int('0o11',8)
9
int('0x11',16)
17
​

1.3 float同样可以用来做数据类型的转换

s = '12.3'
res=float(s)
res,type(res)
(12.3, <class 'float'>)
2.3 使用
数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法

三 字符串
3.1 定义：

定义：在单引号\双引号\三引号内包含一串字符

name1 = 'jason' # 本质:name = str('任意形式内容')
name2 = "lili" # 本质:name = str("任意形式内容")
name3 = """ricky""" # 本质:name = str("""任意形式内容""")
3.2 类型转换

数据类型转换：str()可以将任意数据类型转换成字符串类型，例如

type(str([1,2,3])) # list->str
<class 'str'>
type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
type(str((1,2,3))) # tuple->str
<class 'str'>
type(str({1,2,3,4})) # set->str
<class 'str'>
3.3 使用
3.3.1 优先掌握的操作
str1 = 'hello python!'
​
​

1.按索引取值(正向取，反向取)：

1.1 正向取(从左往右)

str1[6]
p

1.2 反向取(负号表示从右往左)

str1[-4]
h

1.3 对于str来说，只能按照索引取值，不能改

str1[0]='H' # 报错TypeError
​
​

2.切片(顾头不顾尾，步长)

2.1 顾头不顾尾：取出索引为0到8的所有字符

str1[0:9]
hello pyt

2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符

str1[0:9:2]
hlopt

2.3 反向切片

str1[::-1] # -1表示从右往左依次取值
!nohtyp olleh
​

3.长度len

3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)

len(str1) # 空格也算字符
13
​

4.成员运算 in 和 not in

4.1 int:判断hello 是否在 str1里面

'hello' in str1
True

4.2 not in:判断tony 是否不在 str1里面

'tony' not in str1
True
​

5.strip移除字符串首尾指定的字符(默认移除空格)

5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)

str1 = ' life is short! '
str1.strip()
life is short!
​

5.2 括号内指定字符，移除首尾指定的字符

str2 = 'tony'
str2.strip('*')
tony
​

6.切分split

6.1 括号内不指定字符，默认以空格作为切分符号

str3='hello world'
str3.split()
['hello', 'world']

6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串

str4 = '127.0.0.1'
str4.split('.')
['127', '0', '0', '1'] # 注意:split切割得到的结果是列表数据类型
​
​

7.循环

str5 = '今天你好吗？'
for line in str5: # 依次取出字符串中每一个字符
... print(line)
...
今
天
你
好
吗
？
3.3.2 需要掌握的操作

1. strip, lstrip, rstrip

str1 = 'tony'
​
str1.strip('') # 移除左右两边的指定字符
'tony'
str1.lstrip('') # 只移除左边的指定字符
tony**
str1.rstrip('*') # 只移除右边的指定字符
**tony

2. lower(),upper()

str2 = 'My nAme is tonY！'
​
str2.lower() # 将英文字符串全部变小写
my name is tony！
str2.upper() # 将英文字符串全部变大写
MY NAME IS TONY！

3. startswith,endswith

str3 = 'tony jam'
​

startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False

str3.startswith('t')
True
str3.startswith('j')
False

endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False

str3.endswith('jam')
True
str3.endswith('tony')
False
4.格式化输出之format

之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式

案例：

format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给

str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
str4
'my name is tony, my age is 18!'
​
str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
str4
'my name is tonytonytony, my age is tony!'
format的其他使用方式（了解）

类似于%s的用法，传入的值会按照位置与{}一一对应

str4 = 'my name is {}, my age is {}!'.format('tony', 18)
str4
my name is tony, my age is 18!

把format传入的多个值当作一个列表，然后用{索引}取值

str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
str4
my name is tony, my age is 18!
​
str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
str4
my name is 18, my age is tony!
​
str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
str4
my name is 18, my age is 18!
5.split,rsplit

split会按照从左到右的顺序对字符串进行切分，可以指定切割次数

str5='C:/a/b/c/d.txt'
str5.split('/',1)
['C:', 'a/b/c/d.txt']
​

rsplit刚好与split相反，从右往左切割，可以指定切割次数

str5='a|b|c'
str5.rsplit('|',1)
['a|b', 'c']

6. join

从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串

'%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
'|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'

7. replace

用新的字符替换字符串中旧的字符

str7 = 'my name is tony, my age is 18!' # 将tony的年龄由18岁改成73岁
str7 = str7.replace('18', '73') # 语法:replace('旧内容', '新内容')
str7
my name is tony, my age is 73!
​

可以指定修改的个数

str7 = 'my name is tony, my age is 18!'
str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
str7
'MY name is tony, my age is 18!'
8.isdigit

判断字符串是否是纯数字组成，返回结果为True或False

str8 = '5201314'
str8.isdigit()
True
​
str8 = '123g123'
str8.isdigit()
False
3.3.3 了解操作

1.find,rfind,index,rindex,count

1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1

msg='tony say hello'
msg.find('o',1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1

1.2 index:同find,但在找不到时会报错

msg.index('e',2,4) # 报错ValueError

1.3 rfind与rindex：略

1.4 count:统计字符串在大字符串中出现的次数

msg = "hello everyone"
msg.count('e') # 统计字符串e出现的次数
4
msg.count('e',1,6) # 字符串e在索引1~5范围内出现的次数
1
​

2.center,ljust,rjust,zfill

name='tony'
name.center(30,'-') # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
name.ljust(30,'') # 总宽度为30，字符串左对齐显示，不够用填充
tony**************************
name.rjust(30,'') # 总宽度为30，字符串右对齐显示，不够用填充
**************************tony
name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
​

3.expandtabs

name = 'tony\thello' # \t表示制表符(tab键)
name
tony hello
name.expandtabs(1) # 修改\t制表符代表的空格数
tony hello
​

4.captalize,swapcase,title

4.1 captalize：首字母大写

message = 'hello everyone nice to meet you!'
message.capitalize()
Hello everyone nice to meet you!

4.2 swapcase：大小写翻转

message1 = 'Hi girl, I want make friends with you!'
message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!

4.3 title：每个单词的首字母大写

msg = 'dear my friend i miss you very much'
msg.title()
Dear My Friend I Miss You Very Much
​

5.is数字系列

在python3中

num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
​

isdigt:bytes,unicode

num1.isdigit()
True
num2.isdigit()
True
num3.isdigit()
False
num4.isdigit()
False
​

isdecimal:uncicode(bytes类型无isdecimal方法)

num2.isdecimal()
True
num3.isdecimal()
False
num4.isdecimal()
False
​

isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)

num2.isnumeric()
True
num3.isnumeric()
True
num4.isnumeric()
True
​

三者不能判断浮点数

num5 = '4.3'
num5.isdigit()
False
num5.isdecimal()
False
num5.isnumeric()
False
​
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
​

6.is其他

name = 'tony123'
name.isalnum() #字符串中既可以包含数字也可以包含字母
True
name.isalpha() #字符串中只包含字母
False
name.isidentifier()
True
name.islower() # 字符串是否是纯小写
True
name.isupper() # 字符串是否是纯大写
False
name.isspace() # 字符串是否全是空格
False
name.istitle() # 字符串中的单词首字母是否都是大写
False
四 列表
4.1 定义

定义：在[]内,用逗号分隔开多个任意数据类型的值

l1 = [1,'a',[1,2]] # 本质:l1 = list([1,'a',[1,2]])
4.2 类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

list('wdad') # 结果：['w', 'd', 'a', 'd']
list([1,2,3]) # 结果：[1, 2, 3]
list({"name":"jason","age":18}) #结果：['name', 'age']
list((1,2,3)) # 结果：[1, 2, 3]
list({1,2,3,4}) # 结果：[1, 2, 3, 4]
4.3 使用
4.3.1 优先掌握的操作

1.按索引存取值(正向存取+反向存取)：即可存也可以取

1.1 正向取(从左往右)

my_friends=['tony','jason','tom',4,5]
my_friends[0]
tony

1.2 反向取(负号表示从右往左)

my_friends[-1]
5

1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错

my_friends = ['tony','jack','jason',4,5]
my_friends[1] = 'martthow'
my_friends
['tony', 'martthow', 'jason', 4, 5]
​
​

2.切片(顾头不顾尾，步长)

2.1 顾头不顾尾：取出索引为0到3的元素

my_friends[0:4]
['tony', 'jason', 'tom', 4]

2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素

my_friends[0:4:2]
['tony', 'tom']
​

3.长度

len(my_friends)
5
​

4.成员运算in和not in

'tony' in my_friends
True
'xxx' not in my_friends
True
​

5.添加

5.1 append()列表尾部追加元素

l1 = ['a','b','c']
l1.append('d')
l1
['a', 'b', 'c', 'd']
​

5.2 extend()一次性在列表尾部添加多个元素

l1.extend(['a','b','c'])
l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']
​

5.3 insert()在指定位置插入元素

l1.insert(0,"first") # 0表示按索引位置插值
l1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
​

6.删除

6.1 del

l = [11,22,33,44]
del l[2] # 删除索引为2的元素
l
[11,22,44]
​

6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素

l = [11,22,33,22,44]
res=l.pop()
res
44
res=l.pop(1)
res
22
​

6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值

l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res)
None
​

7.reverse()颠倒列表内元素顺序

l = [11,22,33,44]
l.reverse()
l
[44,33,22,11]
​

8.sort()给列表内所有元素排序

8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

l = [11,22,3,42,7,55]
l.sort()
l
[3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False
l
[55, 42, 22, 11, 7, 3]

8.2 了解知识：

我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如

l1=[1,2,3]
l2=[2,]
l2 > l1
True

字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

s1='abc'
s2='az'
s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True

所以我们也可以对下面这个列表排序

l = ['A','z','adjk','hello','hea']
l.sort()
l
['A', 'adjk', 'hea', 'hello','z']
​

9.循环

循环遍历my_friends列表里面的值

for line in my_friends:
print(line)
'tony'
'jack'
'jason'
4
5
4.3.2 了解操作

l=[1,2,3,4,5,6]
l[0:3:1]
[1, 2, 3] # 正向步长
l[2::-1]
[3, 2, 1] # 反向步长
​

通过索引取值实现列表翻转

l[::-1]
[6, 5, 4, 3, 2, 1]
五 元组
5.1 作用
元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

5.2 定义方式

在()内用逗号分隔开多个任意类型的值

countries = ("中国"，"美国"，"英国") # 本质:countries = tuple("中国"，"美国"，"英国")

强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

countries = ("中国"，) # 本质:countries = tuple("中国")
5.3 类型转换

但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型

tuple('wdad') # 结果：('w', 'd', 'a', 'd')
tuple([1,2,3]) # 结果：(1, 2, 3)
tuple({"name":"jason","age":18}) # 结果：('name', 'age')
tuple((1,2,3)) # 结果：(1, 2, 3)
tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)

tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

5.4 使用

tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)

1、按索引取值(正向取+反向取)：只能取，不能改否则报错！

tuple1[0]
1
tuple1[-2]
22
tuple1[0] = 'hehe' # 报错：TypeError:
​

2、切片(顾头不顾尾，步长)

tuple1[0:6:2]
(1, 15000.0, 22)
​

3、长度

len(tuple1)
6
​

4、成员运算 in 和 not in

'hhaha' in tuple1
True
'hhaha' not in tuple1
False
​

5、循环

for line in tuple1:
... print(line)
1
hhaha
15000.0
11
22
33
六 字典
6.1 定义方式

定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能

info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})

也可以这么定义字典

info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
6.2 类型转换

转换1:

info=dict([['name','tony'],('age',18)])
info
{'age': 18, 'name': 'tony'}
​

转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中

{}.fromkeys(('name','age','sex'),None)
{'age': None, 'sex': None, 'name': None}
6.3 使用
6.3.1 优先掌握的操作

1、按key存取值：可存可取

1.1 取

dic = {
... 'name': 'xxx',
... 'age': 18,
... 'hobbies': ['play game', 'basketball']
... }
dic['name']
'xxx'
dic['hobbies'][1]
'basketball'

1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value

dic['gender'] = 'male'
dic

1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

dic['name'] = 'tony'
dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
​
​

2、长度len

len(dic)
3
​
​

3、成员运算in和not in

'name' in dic # 判断某个值是否是字典的key
True
​
​

4、删除

dic.pop('name') # 通过指定字典的key来删除字典的键值对
dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
​
​

5、键keys()，值values()，键值对items()

dic =

获取字典所有的key

dic.keys()
dict_keys(['name', 'age', 'hobbies'])

获取字典所有的value

dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])

获取字典所有的键值对

dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
​
​

6、循环

6.1 默认遍历的是字典的key

for key in dic:
... print(key)
...
age
hobbies
name

6.2 只遍历key

for key in dic.keys():
... print(key)
...
age
hobbies
name

6.3 只遍历value

for key in dic.values():
... print(key)
...
18
['play game', 'basketball']
xxx

6.4 遍历key与value

for key in dic.items():
... print(key)
...
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')
6.3.2 需要掌握的操作

1. get()

dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.get('k1')
'jason' # key存在，则获取key对应的value值
res=dic.get('xxx') # key不存在，不会报错而是默认返回None
print(res)
None
res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
print(res)
666

ps:字典取值建议使用get方法

2. pop()

dic= {'k1':'jason','k2':'Tony','k3':'JY'}
v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
dic
{'k1': 'jason', 'kk2': 'JY'}
v
'Tony'

3. popitem()

dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
dic
{'k3': 'JY', 'k2': 'Tony'}
item
('k1', 'jason')

4. update()

用新字典更新旧字典，有则修改，无则添加

dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
dic

5. fromkeys()

dic = dict.fromkeys(['k1','k2','k3'],[])
dic

6. setdefault()

key不存在则新增键值对，并将新增的value返回

dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
res
333
dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}
​

key存在则不做任何修改，并返回已存在key对应的value值

dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
res
111
dic # 字典不变
{'k1': 111, 'k2': 222}
七 集合
7.1 作用
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

7.2 定义
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
"""
s = {1,2,3,4} # 本质 s = set({1,2,3,4})
​

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

​

注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {} # 默认是空字典
s = set() # 这才是定义空集合
7.3 类型转换

但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({'name':'jason',})
s3 = set('egon')
s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
7.4 使用
7.4.1 关系运算
我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们
两个集合的关系如下图所示

img

1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）

friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
​

2.交集(&)：求两个用户的共同好友

friends1 & friends2
{'jason', 'egon'}
​

3.差集(-)：

friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
​

4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
​

5.值是否相等(==)

friends1 == friends2
False
​

6.父集：一个集合是否包含另外一个集合

6.1 包含则返回True

{1,2,3} > {1,2}
True
{1,2,3} >= {1,2}
True

6.2 不存在包含关系，则返回False

{1,2,3} > {1,3,4,5}
False
{1,2,3} >= {1,3,4,5}
False
​
​

7.子集

{1,2} < {1,2,3}
True
{1,2} <= {1,2,3}
True
7.4.2 去重
集合去重复有局限性

1. 只能针对不可变类型

2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

l=['a','b',1,'a','a']
s=set(l)
s # 将列表转成了集合
{'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序
​

针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
​
new_l=[]
​
for dic in l:
if dic not in new_l:
new_l.append(dic)
​
print(new_l)

结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

[
{'age': 18, 'sex': 'male', 'name': 'lili'},
{'age': 73, 'sex': 'male', 'name': 'jack'},
{'age': 20, 'sex': 'female', 'name': 'tom'}
]
7.4.3 其他操作

1.长度

s={'a','b','c'}
len(s)
3
​

2.成员运算

'c' in s
True
​

3.循环

for item in s:
... print(item)
...
c
a
b
7.5 练习
"""
一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
"""

求出即报名python又报名linux课程的学员名字集合

pythons & linuxs

求出所有报名的学生名字集合

pythons | linuxs

求出只报名python课程的学员名字

pythons - linuxs

求出没有同时这两门课程的学员名字集合

pythons ^ linuxs
八 可变类型与不可变类型
可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值

不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

数字类型:

x = 10
id(x)
1830448896
x = 20
id(x)
1830448928

内存地址改变了，说明整型是不可变数据类型，浮点型也一样

img

字符串

x = "Jy"
id(x)
938809263920
x = "Ricky"
id(x)
938809264088

内存地址改变了，说明字符串是不可变数据类型

img

列表

list1 = ['tom','jack','egon']
id(list1)
486316639176
list1[2] = 'kevin'
id(list1)
486316639176
list1.append('lili')
id(list1)
486316639176

对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

img

元组

t1 = ("tom","jack",[1,2])
t1[0]='TOM' # 报错：TypeError
t1.append('lili') # 报错：TypeError

元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改

t1 = ("tom","jack",[1,2])
id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
t1
('tom', 'jack', [111, 2])
id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)
img

字典

dic = {'name':'egon','sex':'male','age':18}

id(dic)
4327423112
dic['age']=19
dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
id(dic)
4327423112

对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

img

九 数据类型总结
img

1、数字类型：
2、字符串类型
3、列表类型
4、元组类型
5、字典类型
6、集合类型
9、字符编码
一 引入
字符串类型、文本文件的内容都是由字符组成的，但凡涉及到字符的存取，都需要考虑字符编码的问题。

二 知识储备
2.1 三大核心硬件
所有软件都是运行硬件之上的，与运行软件相关的三大核心硬件为cpu、内存、硬盘，我们需要明确三点

1、软件运行前，软件的代码及其相关数据都是存放于硬盘中的

​

2、任何软件的启动都是将数据从硬盘中读入内存，然后cpu从内存中取出指令并执行

​

3、软件运行过程中产生的数据最先都是存放于内存中的，若想永久保存软件产生的数据，则需要将数据由内存写入硬盘

img

2.2 文本编辑器读取文件内容的流程

阶段1、启动一个文件编辑器（文本编辑器如nodepad++，pycharm，word）

​

阶段2、文件编辑器会将文件内容从硬盘读入内存

​

阶段3、文本编辑器会将刚刚读入内存中的内容显示到屏幕上

2.3 python解释器执行文件的流程
以python test.py为例，执行流程如下

阶段1、启动python解释器，此时就相当于启动了一个文本编辑器

​

阶段2、python解释器相当于文本编辑器，从硬盘上将test.py的内容读入到内存中

​

阶段3、python解释器解释执行刚刚读入的内存的内容，开始识别python语法

2.4 总结
python解释器与文件本编辑的异同如下

1、相同点：前两个阶段二者完全一致，都是将硬盘中文件的内容读入内存，详解如下

python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
​

2、不同点：在阶段3时，针对内存中读入的内容处理方式不同，详解如下

文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法）
三、字符编码介绍
3.1 什么是字符编码？
人类在与计算机交互时，用的都是人类能读懂的字符，如中文字符、英文字符、日文字符等

而计算机只能识别二进制数,详解如下

二进制数即由0和1组成的数字，例如010010101010。计算机是基于电工作的，电的特性即高低电平，人类从逻辑层面将高电平对应为数字1,低电平对应为数字0，这直接决定了计算机可以识别的是由0和1组成的数字

毫无疑问，由人类的字符到计算机中的数字，必须经历一个过程，如下

img

翻译的过程必须参照一个特定的标准，该标准称之为字符编码表，该表上存放的就是字符与数字一一对应的关系。

字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字

3.2 字符编码表的发展史 (了解)
字符编码的发展经历了三个重要的阶段，如下

3.2.1 阶段一：一家独大
现代计算机起源于美国，所以最先考虑仅仅是让计算机识别英文字符，于是诞生了ASCII表

ASCII表的特点:

1、只有英文字符与数字的一一对应关系
2、一个英文字符对应1Bytes，1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符

3.2.2 阶段二：诸侯割据、天下大乱

3.2.2 阶段二：诸侯割据、天下大乱
为了让计算机能够识别中文和英文，中国人定制了GBK

GBK表的特点：

1、只有中文字符、英文字符与数字的一一对应关系
2、一个英文字符对应1Bytes
   一个中文字符对应2Bytes   
   补充说明：
   1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符
   2Bytes=16bit，16bit最多包含65536个数字，可以对应65536个字符，足够表示所有中文字符

每个国家都各自的字符，为让计算机能够识别自己国家的字符外加英文字符，各个国家都制定了自己的字符编码表

Shift_JIS表的特点：

1、只有日文字符、英文字符与数字的一一对应关系

​

Euc-kr表的特点：

1、只有韩文字符、英文字符与数字的一一对应关系

此时,美国人用的计算机里使用字符编码标准是ASCII、中国人用的计算机里使用字符编码标准是GBK、日本人用的计算机里使用字符编码标准是Shift_JIS,如下图所示，

img

字符编码发展到了这个阶段，可以用一句话概括：诸侯割据、天下大乱，详解如下

图1中，文本编辑存取文件的原理如下

文本文件内容全都为字符，无论存取都是涉及到字符编码问题

1、存文本文件

人类通过文本编辑器输入的字符会被转化成ASCII格式的二进制存放于内存中，如果需要永久保存，则直接将内存中的ASCII格式的二进制写入硬盘
​

2、读文本文件

直接将硬盘中的ASCII格式的二进制读入内存，然后通过ASCII表反解成英文字符
图2图3都是相同的过程，此时无论是存还是取由于采用的字符编码表一样，所以肯定不会出现乱码问题，但问题是在美国人用的计算机里只能输入英文字符，而在中国人用的计算机里只能输入中文字符和英文字符....,毫无疑问我们希望计算机允许我们输入万国字符均可识别、不乱码，而现阶段计算机采用的字符编码ASCII、GBK、Shift_JIS都无法识别万国字符，所以我们必须定制一个兼容万国字符的编码表，请看阶段三

3.2.3 阶段三：分久必合
unicode于1990年开始研发，1994年正式公布，具备两大特点：

1. 存在所有语言中的所有字符与数字的一一对应关系,即兼容万国字符
   ​

2. 与传统的字符编码的二进制数都有对应关系，详解如下

很多地方或老的系统、应用软件仍会采用各种各样传统的编码，这是历史遗留问题。此处需要强调：软件是存放于硬盘的，而运行软件是要将软件加载到内存的，面对硬盘中存放的各种传统编码的软件，想让我们的计算机能够将它们全都正常运行而不出现乱码，内存中必须有一种兼容万国的编码，并且该编码需要与其他编码有相对应的映射/转换关系，这就是unicode的第二大特点产生的缘由

img

文本编辑器输入任何字符都是最新存在于内存中，是unicode编码的，存放于硬盘中，则可以转换成任意其他编码，只要该编码可以支持相应的字符

英文字符可以被ASCII识别

英文字符--->unciode格式的数字--->ASCII格式的数字
​

中文字符、英文字符可以被GBK识别

中文字符、英文字符--->unicode格式的数字--->gbk格式的数字
​

日文字符、英文字符可以被shift-JIS识别

日文字符、英文字符--->unicode格式的数字--->shift-JIS格式的数字
3.3 编码与解码
由字符转换成内存中的unicode，以及由unicode转换成其他编码的过程，都称为编码encode

img

由内存中的unicode转换成字符，以及由其他编码转换成unicode的过程，都称为解码decode

img

在诸多文件类型中，只有文本文件的内存是由字符组成的，因而文本文件的存取也涉及到字符编码的问题

3.4 utf-8的由来
注意：如果保存到硬盘的是GBK格式二进制，当初用户输入的字符只能是中文或英文，同理如果保存到硬盘的是Shift_JIS格式二进制，当初用户输入的字符只能是日文或英文……如果我们输入的字符中包含多国字符，那么该如何处理？

多国字符—√—》内存（unicode格式的二进制）——X—》硬盘（GBK格式的二进制）

​

多国字符—√—》内存（unicode格式的二进制）——X—》硬盘（Shift_JIS格式的二进制）

​

多国字符—√—》内存（unicode格式的二进制）——√—》硬盘（???格式的二进制）

理论上是可以将内存中unicode格式的二进制直接存放于硬盘中的，但由于unicode固定使用两个字节来存储一个字符，如果多国字符中包含大量的英文字符时，使用unicode格式存放会额外占用一倍空间（英文字符其实只需要用一个字节存放即可），然而空间占用并不是最致命的问题，最致命地是当我们由内存写入硬盘时会额外耗费一倍的时间，所以将内存中的unicode二进制写入硬盘或者基于网络传输时必须将其转换成一种精简的格式，这种格式即utf-8（全称Unicode Transformation Format，即unicode的转换格式）

多国字符—√—》内存（unicode格式的二进制）——√—》硬盘（utf-8格式的二进制）

img

那为何在内存中不直接使用utf-8呢？

utf-8是针对Unicode的可变长度字符编码：一个英文字符占1Bytes，一个中文字符占3Bytes，生僻字用更多的Bytes存储
​
unicode更像是一个过渡版本，我们新开发的软件或文件存入硬盘都采用utf-8格式，等过去几十年，所有老编码的文件都淘汰
四 字符编码的应用
我们学习字符编码就是为了存取字符时不发生乱码问题：

1、内存中固定使用unicode无论输入任何字符都不会发生乱码

​

2、我们能够修改的是存/取硬盘的编码方式，如果编码设置不正确将会出现乱码问题。乱码问题分为两种：存乱了，读乱了

​

2.1 存乱了：如果用户输入的内容中包含中文和日文字符，如果单纯以shift_JIS存，日文可以正常写入硬盘，而由于中文字符在shift_jis中没有找到对应关系而导致存乱了

​

2.2 读乱了：如果硬盘中的数据是shift_JIS格式存储的，采GBK格式读入内存就读乱了

总结：

1. 保证存的时候不乱：在由内存写入硬盘时，必须将编码格式设置为支持所输入字符的编码格式

2. 保证存的时候不乱：在由硬盘读入内存时，必须采用与写入硬盘时相同的编码格式

4.1 文本编辑器nodpad++存取文本文件
文本编辑器存取的都是文本文件，而文本文件中包含的内容全为字符，所以存取文本文件都涉及到字符编码的问题。

img

4.2 python解释器执行文件的前两个阶段
执行py文件的前两个阶段就是python解释器读文本文件的过程，与文本编辑读文本文件的前两个阶段没人任何区别，要保证读不乱码，则必须将python解释器读文件时采用的编码方式设置为文件当初写入硬盘时的编码格式，如果没有设置，python解释器则才用默认的编码方式，在python3中默认为utf-8，在python2中默认为ASCII，我们可以通过指定文件头来修改默认的编码

在文件首行写入包含#号在内的以下内容

coding: 当初文件写入硬盘时采用的编码格式

解释器会先用默认的编码方式读取文件的首行内容，由于首行是纯英文组成，而任何编码方式都可以识别英文字符。

4.3 python解释器执行文件的第三个阶段
设置文件头的作用是保证运行python程序的前两个阶段不乱码，经过前两个阶段后py文件的内容都会以unicode格式存放于内存中。

在经历第三个阶段时开始识别python语法，当遇到特定的语法name = '上'（代码本身也都全都是unicode格式存的）时，需要申请内存空间来存储字符串'上'，这就又涉及到应该以什么编码存储‘上’的问题了。

在Python3中，字符串类的值都是使用unicode格式来存储

由于Python2的盛行是早于unicode的，因此在Python2中是按照文件头指定的编码来存储字符串类型的值的（如果文件头中没有指定编码，那么解释器会按照它自己默认的编码方式来存储‘上’），所以，这就有可能导致乱码问题

coding:utf-8

x = '上' # x的值为untf-8格式的二进制
print(x) # 打印操作是将x的值，即utf-8格式的二进制交给终端，当终端收到后发现并不是unicode（只有unicode才与字符有对应关系），所以终端会执行操作：utf-8二进制---解码-->unicode格式的二进制，解码的过程终端会采用自己默认的编码，而在pycharm的终端默认编码为utf-8、windows下的cmd终端的默认编码为gbk，所以该打印操作在pycharm中显示正常，而在windows下的cmd中则乱码
​

在windows下的cmd中运行效果如下

C:\Users\Administrator>python2 E:\aaa.py
涓
python2后推出了一种补救措施，就是在字符串类型前加u，则会将字符串类型强制存储unicode，这就与python3保持一致了，对于unicode格式无论丢给任何终端进行打印，都可以直接对应字符不会出现乱码问题

coding:utf-8

x = u'上' # 即便文件头为utf-8，x的值依然存成unicode
4.4 字符串encode编码与decode解码的使用

1、unicode格式------编码encode-------->其它编码格式

x='上' # 在python3在'上'被存成unicode
res=x.encode('utf-8')
res,type(res) # unicode编码成了utf-8格式，而编码的结果为bytes类型，可以当作直接当作二进制去使用
(b'\xe4\xb8\x8a', <class 'bytes'>)
​

2、其它编码格式------解码decode-------->unicode格式

res.decode('utf-8')
'上'
10、文件处理
应用程序运行过程中产生的数据最先都是存放于内存中的，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。

二 文件操作的基本流程
2.1 基本流程
有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：

1. 打开文件，由应用程序向操作系统发起系统调用open(...)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f

f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r
​

2. 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作

data=f.read()
​

3. 向操作系统发起关闭文件的请求，回收系统资源

f.close()
2.2 资源回收与with上下文管理
打开一个文件包含两部分资源：应用程序的变量f和操作系统打开的文件。在操作完毕一个文件时，必须把与该文件的这两部分资源全部回收，回收方法为：

1、f.close() #回收操作系统打开的文件资源
2、del f #回收应用程序级的变量
其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件无法关闭，白白占用资源， 而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()，虽然我们如此强调，但是大多数读者还是会不由自主地忘记f.close()，考虑到这一点，python提供了with关键字来帮我们管理上下文

1、在执行完子代码块后，with 会自动执行f.close()

with open('a.txt','w') as f:
pass
​

2、可用用with同时打开多个文件，用逗号分隔开即可

with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
data = read_f.read()
write_f.write(data)
2.3 指定操作文本文件的字符编码
f = open(...)是由操作系统打开文件，如果打开的是文本文件，会涉及到字符编码问题，如果没有为open指定编码，那么打开文本文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。
​
f = open('a.txt','r',encoding='utf-8')
三 文件的操作模式
3.1 控制文件读写操作的模式
r(默认的)：只读
w：只写
a：只追加写
3.1.1 案例一：r 模式的使用

r只读模式: 在文件不存在时则报错,文件存在文件内指针直接跳到文件开头

with open('a.txt',mode='r',encoding='utf-8') as f:
res=f.read() # 会将文件的内容由硬盘全部读入内存，赋值给res
​

小练习：实现用户认证功能

inp_name=input('请输入你的名字: ').strip()
inp_pwd=input('请输入你的密码: ').strip()
with open(r'db.txt',mode='r',encoding='utf-8') as f:
for line in f:
# 把用户输入的名字与密码与读出内容做比对
u,p=line.strip('\n').split('😂
if inp_name == u and inp_pwd == p:
print('登录成功')
break
else:
print('账号名或者密码错误')
3.1.2 案例二：w 模式的使用

w只写模式: 在文件不存在时会创建空文档,文件存在会清空文件,文件指针跑到文件开头

with open('b.txt',mode='w',encoding='utf-8') as f:
f.write('你好\n')
f.write('我好\n')
f.write('大家好\n')
f.write('111\n222\n333\n')

强调：

1 在文件不关闭的情况下,连续的写入，后写的内容一定跟在前写内容的后面

2 如果重新以w模式打开文件，则会清空文件内容

3.1.3 案例三：a 模式的使用

a只追加写模式: 在文件不存在时会创建空文档,文件存在会将文件指针直接移动到文件末尾

with open('c.txt',mode='a',encoding='utf-8') as f:
f.write('44444\n')
f.write('55555\n')

强调 w 模式与 a 模式的异同：

1 相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后

2 不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后

​

小练习：实现注册功能:

name=input('username>>>: ').strip()
pwd=input('password>>>: ').strip()
with open('db1.txt',mode='a',encoding='utf-8') as f:
info='%s:%s\n' %(name,pwd)
f.write(info)
3.1.4 案例四：+ 模式的使用(了解)

r+ w+ a+ :可读可写

在平时工作中，我们只单纯使用r/w/a，要么只读，要么只写，一般不用可读可写的模式

3.2 控制文件读写内容的模式
大前提: tb模式均不能单独使用,必须与r/w/a之一结合使用
t（默认的）：文本模式
1. 读写文件都是以字符串为单位的
2. 只能针对文本文件
3. 必须指定encoding参数
b：二进制模式:
1.读写文件都是以bytes/二进制为单位的
2. 可以针对所有文件
3. 一定不能指定encoding参数
3.2.1 案例一：t 模式的使用

t 模式：如果我们指定的文件打开模式为r/w/a，其实默认就是rt/wt/at

with open('a.txt',mode='rt',encoding='utf-8') as f:
res=f.read()
print(type(res)) # 输出结果为：<class 'str'>
​
with open('a.txt',mode='wt',encoding='utf-8') as f:
s='abc'
f.write(s) # 写入的也必须是字符串类型
​

强调：t 模式只能用于操作文本文件,无论读写，都应该以字符串为单位，而存取硬盘本质都是二进制的形式，当指定 t 模式时，内部帮我们做了编码与解码

3.2.2 案例二： b 模式的使用

b: 读写都是以二进制位单位

with open('1.mp4',mode='rb') as f:
data=f.read()
print(type(data)) # 输出结果为：<class 'bytes'>
​
with open('a.txt',mode='wb') as f:
msg="你好"
res=msg.encode('utf-8') # res为bytes类型
f.write(res) # 在b模式下写入文件的只能是bytes类型
​

强调：b模式对比t模式

1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式
​

小练习： 编写拷贝工具

src_file=input('源文件路径: ').strip()
dst_file=input('目标文件路径: ').strip()
with open(r'%s' %src_file,mode='rb') as read_f,open(r'%s' %dst_file,mode='wb') as write_f:
for line in read_f:
# print(line)
write_f.write(line)
四 操作文件的方法
4.1 重点

读操作

f.read() # 读取所有内容,执行完该操作后，文件指针会移动到文件末尾
f.readline() # 读取一行内容,光标移动到第二行首部
f.readlines() # 读取每一行内容,存放于列表中
​

强调：

f.read()与f.readlines()都是将内容一次性读入内容，如果内容过大会导致内存溢出，若还想将内容全读入内存，则必须分多次读入，有两种实现方式：

方式一

with open('a.txt',mode='rt',encoding='utf-8') as f:
for line in f:
print(line) # 同一时刻只读入一行内容到内存中
​

方式二

with open('1.mp4',mode='rb') as f:
while True:
data=f.read(1024) # 同一时刻只读入1024个Bytes到内存中
if len(data) == 0:
break
print(data)
​

写操作

f.write('1111\n222\n') # 针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8')) # 针对b模式的写,需要自己写换行符
f.writelines(['333\n','444\n']) # 文件模式
f.writelines([bytes('333\n',encoding='utf-8'),'444\n'.encode('utf-8')]) #b模式
4.2 了解
f.readable() # 文件是否可读
f.writable() # 文件是否可读
f.closed # 文件是否关闭
f.encoding # 如果文件打开模式为b,则没有该属性
f.flush() # 立刻将文件内容从内存刷到硬盘
f.name
五 主动控制文件内指针移动

大前提:文件内指针的移动都是Bytes为单位的,唯一例外的是t模式下的read(n),n以字符为单位

with open('a.txt',mode='rt',encoding='utf-8') as f:
data=f.read(3) # 读取3个字符
​
​
with open('a.txt',mode='rb') as f:
data=f.read(3) # 读取3个Bytes
​
​

之前文件内指针的移动都是由读/写操作而被动触发的，若想读取文件某一特定位置的数据，则则需要用f.seek方法主动控制文件内指针的移动，详细用法如下：

f.seek(指针移动的字节数,模式控制):

模式控制:

0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的

1: 该模式代表指针移动的字节数是以当前所在的位置为参照的

2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的

强调:其中0模式可以在t或者b模式使用,而1跟2模式只能在b模式下用

5.1 案例一： 0模式详解

a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）

abc你好
​

0模式的使用

with open('a.txt',mode='rt',encoding='utf-8') as f:
f.seek(3,0) # 参照文件开头移动了3个字节
print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3
print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好
# 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败
​
with open('a.txt',mode='rb') as f:
f.seek(6,0)
print(f.read().decode('utf-8')) #输出结果为: 好
5.2 案例二： 1模式详解

1模式的使用

with open('a.txt',mode='rb') as f:
f.seek(3,1) # 从当前位置往后移动3个字节，而此时的当前位置就是文件开头
print(f.tell()) # 输出结果为：3
f.seek(4,1) # 从当前位置往后移动4个字节，而此时的当前位置为3
print(f.tell()) # 输出结果为：7
5.3 案例三： 2模式详解

a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）

abc你好
​

2模式的使用

with open('a.txt',mode='rb') as f:
f.seek(0,2) # 参照文件末尾移动0个字节， 即直接跳到文件末尾
print(f.tell()) # 输出结果为：9
f.seek(-3,2) # 参照文件末尾往前移动了3个字节
print(f.read().decode('utf-8')) # 输出结果为：好
​

小练习：实现动态查看最新一条日志的效果

import time
with open('access.log',mode='rb') as f:
f.seek(0,2)
while True:
line=f.readline()
if len(line) == 0:
# 没有内容
time.sleep(0.5)
else:
print(line.decode('utf-8'),end='')
六 文件的修改

文件a.txt内容如下

张一蛋 山东 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422
​

执行操作

with open('a.txt',mode='r+t',encoding='utf-8') as f:
f.seek(9)
f.write('<妇女主任>')
​

文件修改后的内容如下

张一蛋<妇女主任> 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422
​

强调：

1、硬盘空间是无法修改的,硬盘中数据的更新都是用新内容覆盖旧内容

2、内存中的数据是可以修改的

文件对应的是硬盘空间,硬盘不能修改对应着文件本质也不能修改, 那我们看到文件的内容可以修改,是如何实现的呢? 大致的思路是将硬盘中文件内容读入内存,然后在内存中修改完毕后再覆盖回硬盘 具体的实现方式分为两种:

6.1 文件修改方式一

实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件

优点: 在文件修改过程中同一份数据只有一份

缺点: 会过多地占用内存

with open('db.txt',mode='rt',encoding='utf-8') as f:
data=f.read()
​
with open('db.txt',mode='wt',encoding='utf-8') as f:
f.write(data.replace('kevin','SB'))
6.1 文件修改方式二

实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行读取原文件内容,修改完后写入临时文件...,删掉原文件,将临时文件重命名原文件名

优点: 不会占用过多的内存

缺点: 在文件修改过程中同一份数据存了两份

import os
​
with open('db.txt',mode='rt',encoding='utf-8') as read_f,
open('.db.txt.swap',mode='wt',encoding='utf-8') as wrife_f:
for line in read_f:
wrife_f.write(line.replace('SB','kevin'))
​
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')
11、函数的基本使用
一 引入
在程序中，具备某一功能的‘工具’指的就是函数，‘事先准备工具’的过程即函数的定义，‘拿来就用’即函数的调用。

二 定义函数
函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。

定义函数的语法

def 函数名(参数1,参数2,...):
"""文档描述"""
函数体
return 值
def: 定义函数的关键字；

函数名：函数名指向函数内存地址，是对函数体代码的引用。函数的命名应该反映出函数的功能；

括号：括号内定义参数，参数是可有可无的，且无需指定参数的类型；

冒号：括号后要加冒号，然后在下一行开始缩进编写函数体的代码；

"""文档描述""": 描述函数功能，参数介绍等信息的文档，非必要，但是建议加上，从而增强函数的可读性；

函数体：由语句和表达式组成；

return 值：定义函数的返回值，return是可有可无的。

参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数，

def my_min(x,y):
res=x if x < y else y
return res
否则定义为无参函数

def interactive():
user=input('user>>: ').strip()
pwd=input('password>>: ').strip()
return (user,pwd)
函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。例如要编写一个ftp程序，我们可能想到的功能有用户认证，下载，上传，浏览，切换目录等功能，可以先做出如下定义：

def auth_user():
"""user authentication function"""
pass
​
def download_file():
"""download file function"""
pass
​
def upload_file():
"""upload file function"""
pass
​
def ls():
"""list contents function"""
pass
​
def cd():
"""change directory"""
pass
之后我们便可以统筹安排编程任务，有选择性的去实现上述功能来替换掉pass，从而提高开发效率。

三 调用函数与函数返回值
函数的使用分为定义阶段与调用阶段，定义函数时只检测语法，不执行函数体代码，函数名加括号即函数调用，只有调用函数时才会执行函数体代码

定义阶段

def foo():
print('in the foo')
bar()
​
def bar():
print('in the bar')
​

调用阶段

foo()
执行结果：

in the foo
in the bar
定义阶段函数foo与bar均无语法错误，而在调用阶段调用foo()时，函数foo与bar都早已经存在于内存中了，所以不会有任何问题。

按照在程序出现的形式和位置，可将函数的调用形式分为三种

1、语句形式：

foo()
​

2、表达式形式：

m=my_min(1,2) #将调用函数的返回值赋值给x
n=10*my_min(1,2) #将调用函数的返回值乘以10的结果赋值给n
​

3、函数调用作为参数的形式：

my_min（2，3）作为函数my_min的第二个参数，实现了取1,2,3中的较小者赋值给m

m=my_min(1，my_min（2，3）)
若需要将函数体代码执行的结果返回给调用者，则需要用到return。return后无值或直接省略return，则默认返回None，return的返回值无类型限制，且可以将多个返回值放到一个元组内。

def test(x,y,z):
... return x,y,z #等同于return (x,y,z)
...
res=test(1,2,3)
print(res)
(1, 2, 3)
return是一个函数结束的标志,函数内可以有多个return，但只执行一次函数就结束了，并把return后定义的值作为本次调用的结果返回。

12、函数的参数
一 形参与实参介绍
函数的参数分为形式参数和实际参数，简称形参和实参：

形参即在定义函数时，括号内声明的参数。形参本质就是一个变量名，用来接收外部传来的值。

实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:

1：实参是常量

res=my_min(1,2)
​

2：实参是变量

a=1
b=2
res=my_min(a,b)
​

3：实参是表达式

res=my_min(102,10my_min(3,4))
​

4：实参可以是常量、变量、表达式的任意组合

a=2
my_min(1,a,10*my_min(3,4))
在调用有参函数时，实参（值）会赋值给形参（变量名）。在Python中，变量名与值只是单纯的绑定关系，而对于函数来说，这种绑定关系只在函数调用时生效，在调用结束后解除。

二 形参与实参的具体使用
2.1 位置参数
位置即顺序，位置参数指的是按顺序定义的参数，需要从两个角度去看：

在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值

def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
register() #TypeError：缺少3个位置参数
在调用函数时，按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应

def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
register() #TypeError：缺少3个位置参数
2.2 关键字参数
在调用函数时，实参可以是key=value的形式，称为关键字参数，凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值

register(sex='male',name='lili',age=18)
Name:lili Age:18 Sex:male
需要注意在调用函数时，实参也可以是按位置或按关键字的混合使用，但必须保证关键字参数在位置参数后面，且不可以对一个形参重复赋值

register('lili',sex='male',age=18) #正确使用
register(name='lili',18,sex='male') #SyntaxError：关键字参数name=‘lili’在位置参数18之前
register('lili',sex='male',age=18,name='jack') #TypeError：形参name被重复赋值
2.3 默认参数
在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置参数，而将值改变较少的参数定义成默认参数。例如编写一个注册学生信息的函数，如果大多数学生的性别都为男，那完全可以将形参sex定义成默认参数

def register(name,age,sex='male'): #默认sex的值为male
... print('Name:%s Age:%s Sex:%s' %(name,age,sex))
...
定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度

register('tom',17) #大多数情况,无需为sex传值,默认为male
Name:tom Age:17 Sex:male
register('Lili',18,'female') #少数情况,可以为sex传值female
Name:Lili Age:18 Sex:female
需要注意：

默认参数必须在位置参数之后

默认参数的值仅在函数定义阶段被赋值一次

x=1
def foo(arg=x):
... print(arg)
...
x=5 #定义阶段arg已被赋值为1，此处的修改与默认参数arg无任何关系
foo()
1
默认参数的值通常应设为不可变类型

def foo(n,arg=[]):
arg.append(n)
return arg
foo(1)
[1]
foo(2)
[1, 2]
foo(3)
[1, 2, 3]
每次调用是在上一次的基础上向同一列表增加值，修改如下

def foo(n,arg=None):
if arg is None:
arg=[]
arg.append(n)
return arg
foo(1)
[1]
foo(2)
[2]
foo(3)
[3]
2.4 可变长度的参数（*与**的用法）
参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数

2.4.1 可变长度的位置参数
如果在最后一个形参名前加号,那么在调用函数时，溢出的位置实参，都会被接收，以元组的形式保存下来赋值给该形参

def foo(x,y,z=1,args): #在最后一个形参名args前加号
... print(x)
... print(y)
... print(z)
... print(args)
...
foo(1,2,3,4,5,6,7) #实参1、2、3按位置为形参x、y、z赋值，多余的位置实参4、5、6、7都被接收，以元组的形式保存下来，赋值给args，即args=(4, 5, 6,7)
​
1
2
3
(4, 5, 6, 7)
如果我们事先生成了一个列表,仍然是可以传值给args的

def foo(x,y,args):
... print(x)
... print(y)
... print(args)
...
L=[3,4,5]
foo(1,2,L) # L就相当于位置参数3，4，5, foo(1,2,L)就等同于foo(1,2,3,4,5)
1
2
(3, 4, 5)
注意：如果在传入L时没有加*,那L就只是一个普通的位置参数了

foo(1,2,L) #仅多出一个位置实参L
1
2
([1, 2, 3],)
如果形参为常规的参数（位置或默认），实参仍可以是*的形式

def foo(x,y,z=3):
... print(x)
... print(y)
... print(z)
...
foo([1,2]) #等同于foo(1,2)
1
2
3
如果我们想要求多个值的和，args就派上用场了

def add(*args):
... res=0
... for i in args:
... res+=i
... return res
...
add(1,2,3,4,5)
15
2.4.2 可变长度的关键字参数
如果在最后一个形参名前加号,那么在调用函数时，溢出的关键字参数，都会被接收，以字典的形式保存下来赋值给该形参

def foo(x,kwargs): #在最后一个参数kwargs前加
... print(x)
... print(kwargs)
...
foo(y=2,x=1,z=3) #溢出的关键字实参y=2，z=3都被接收，以字典的形式保存下来，赋值给kwargs
1
{'z': 3, 'y': 2}
如果我们事先生成了一个字典,仍然是可以传值给kwargs的

def foo(x,y,kwargs):
... print(x)
... print(y)
... print(kwargs)
...
dic={'a':1,'b':2}
foo(1,2,dic) #dic就相当于关键字参数a=1，b=2，foo(1,2,dic)等同foo(1,2,a=1,b=2)
1
2
{'a': 1, 'b': 2}
注意：如果在传入dic时没有加**,那dic就只是一个普通的位置参数了

foo(1,2,dic) #TypeError:函数foo只需要2个位置参数，但是传了3个
如果形参为常规参数（位置或默认），实参仍可以是**的形式

def foo(x,y,z=3):
... print(x)
... print(y)
... print(z)
...
foo({'x':1,'y':2}) #等同于foo(y=2,x=1)
1
2
3
如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用kwargs为日后的扩展供良好的环境，同时保持了函数的简洁性。

def auth(user,password,kwargs):
... pass
...
2.5 命名关键字参数
在定义了kwargs参数后，函数调用者就可以传入任意的关键字参数key=value，如果函数体代码的执行需要依赖某个key，必须在函数内进行判断

def register(name,age,**kwargs):
... if 'sex' in kwargs:
... #有sex参数
... pass
... if 'height' in kwargs:
... #有height参数
... pass
...
想要限定函数的调用者必须以key=value的形式传值，Python3提供了专门的语法：需要在定义形参时，用作为一个分隔符号，号之后的形参称为命名关键字参数。对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值

def register(name,age,*,sex,height): #sex,height为命名关键字参数
... pass
...
register('lili',18,sex='male',height='1.8m') #正确使用
register('lili',18,'male','1.8m') # TypeError:未使用关键字的形式为sex和height传值
register('lili',18,height='1.8m') # TypeError没有为命名关键字参数height传值。
命名关键字参数也可以有默认值，从而简化调用

def register(name,age,,sex='male',height):
... print('Name:%s,Age:%s,Sex:%s,Height:%s' %(name,age,sex,height))
...
register('lili',18,height='1.8m')
Name:lili,Age:18,Sex:male,Height:1.8m
需要强调的是：sex不是默认参数，height也不是位置参数，因为二者均在后，所以都是命名关键字参数，形参sex=’male’属于命名关键字参数的默认值，因而即便是放到形参height之前也不会有问题。另外，如果形参中已经有一个args了，命名关键字参数就不再需要一个单独的作为分隔符号了

def register(name,age,args,sex='male',height):
... print('Name:%s,Age:%s,Args:%s,Sex:%s,Height:%s' %(name,age,args,sex,height))
...
register('lili',18,1,2,3,height='1.8m') #sex与height仍为命名关键字参数
Name:lili,Age:18,Args:(1, 2, 3),Sex:male,Height:1.8m
2.6 组合使用
综上所述所有参数可任意组合使用，但定义顺序必须是：位置参数、默认参数、args、命名关键字参数、**kwargs

可变参数args与关键字参数kwargs通常是组合在一起使用的，如果一个函数的形参为args与kwargs，那么代表该函数可以接收任何形式、任意长度的参数

def wrapper(*args,**kwargs):
... pass
...
在该函数内部还可以把接收到的参数传给另外一个函数（这在4.6小节装饰器的实现中大有用处）

def func(x,y,z):
... print(x,y,z)
...
def wrapper(args,**kwargs):
... func(args,**kwargs)
...
wrapper(1,z=3,y=2)
1 2 3
按照上述写法，在为函数wrapper传参时，其实遵循的是函数func的参数规则，调用函数wrapper的过程分析如下：

位置实参1被*接收，以元组的形式保存下来，赋值给args，即args=(1,),关键字实参z=3，y=2被**接收，以字典的形式保存下来，赋值给kwargs，即kwargs={'y': 2, 'z': 3}

执行func(args,kwargs),即func(*(1,),** {'y': 2, 'z': 3}),等同于func(1,z=3,y=2)

提示： *args、**kwargs中的args和kwargs被替换成其他名字并无语法错误，但使用args、kwargs是约定
13、名称空间与作用域
一 名称空间
名称空间即存放名字与对象映射/绑定关系的地方。对于x=3，Python会申请内存空间存放对象3，然后将名字x与3的绑定关系存放于名称空间中，del x表示清除该绑定关系。

在程序执行期间最多会存在三种名称空间

1.1 内建名称空间
伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些内置的名字，比如内建函数名

max
#built-in内建
1.2 全局名称空间
伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中，如下名字

import sys #模块名sys
​
x=1 #变量名x
​
if x == 1:
y=2 #变量名y
​
def foo(x): #函数名foo
y=1
def bar():
pass
​
Class Bar: #类名Bar
pass
1.3 局部名称空间
伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中

def foo(x):
y=3 #调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部名称空间中
名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间。

二 作用域
2.1 全局作用域与局部作用域
按照名字作用范围的不同可以将三个名称空间划分为两个区域：

全局作用域:位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）；

局部作用域:位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）。

2.2 作用域与名字查找的优先级
在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

x=100 #全局作用域的名字x
def foo():
x=300 #局部作用域的名字x
print(x) #在局部找x
foo()#结果为300
在全局作用域查找名字时，起始位置便是全局作用域，所以先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

x=100
def foo():
x=300 #在函数调用时产生局部作用域的名字x
foo()
print(x) #在全局找x,结果为100
提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals()

Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域

x=1
def outer():
x=2
def inner(): # 函数名inner属于outer这一层作用域的名字
x=3
print('inner x:%s' %x)
​
inner()
print('outer x:%s' %x)
​
outer()

结果为

inner x:3
outer x:2
在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字

x=1
def outer():
x=2
def inner(): # 函数名inner属于outer这一层作用域的名字
x=3
print('inner x:%s' %x)
​
inner()
print('outer x:%s' %x)
​
outer()

结果为

inner x:3
outer x:2
在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字

x=1
def foo():
global x #声明x为全局名称空间的名字
x=2
foo()
print(x) #结果为2
当实参的值为可变类型时，函数体内对该值的修改将直接反应到原值，

num_list=[1,2,3]
def foo(nums):
nums.append(5)
​
foo(num_list)
print(num_list)

结果为

[1, 2, 3, 5]
对于嵌套多层的函数，使用nonlocal关键字可以将名字声明为来自外部嵌套函数定义的作用域（非全局）

def f1():
x=2
def f2():
nonlocal x
x=3
f2() #调用f2(),修改f1作用域中名字x的值
print(x) #在f1作用域查看x
​
f1()
​

结果

3
nonlocal x会从当前函数的外层函数开始一层层去查找名字x，若是一直到最外层函数都找不到，则会抛出异常。

14、函数对象和闭包
一 函数对象
函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用，我们如下

1.1 函数可以被引用

def add(x,y):
... return x+y
...
func=add
func(1,2)
3
1.2 函数可以作为容器类型的元素
dic={'add':add,'max':max}
dic
{'add': <function add at 0x100661e18>, 'max': }
dic'add'
3
1.3 函数可以作为参数传入另外一个函数
def foo(x,y,func):
... return func(x,y)
...
foo(1,2,add)
3
1.4 函数的返回值可以是一个函数
def bar():
return add
func=bar()
func(1,2)
3
二 闭包函数
2.1 闭与包
基于函数对象的概念，可以将函数返回到任意位置去调用，但作用域的关系是在定义完函数时就已经被确定了的，与函数的调用位置无关。

x=1
​
def f1():
def f2():
print(x)
​
return f2
​
def f3():
x=3
f2=f1() #调用f1()返回函数f2
f2() #需要按照函数定义时的作用关系去执行，与调用位置无关
​
f3() #结果为1
也就是说函数被当做数据处理时，始终以自带的作用域为准。若内嵌函数包含对外部函数作用域（而非全局作用域）中变量的引用，那么该’内嵌函数’就是闭包函数，简称闭包(Closures)

x=1
def outer():
x=2
def inner():
print(x)
return inner
​
func=outer()
func() # 结果为2
可以通过函数的closure属性，查看到闭包函数所包裹的外部变量

func.closure
(<cell at 0x10212af78: int object at 0x10028cca0>,)
func.closure[0].cell_contents
2
“闭”代表函数是内部的，“包”代表函数外’包裹’着对外层作用域的引用。因而无论在何处调用闭包函数，使用的仍然是包裹在其外层的变量。

2.2 闭包的用途
目前为止，我们得到了两种为函数体传值的方式，一种是直接将值以参数的形式传入，另外一种就是将值包给函数

import requests
​

方式一：

def get(url):
return requests.get(url).text
​

方式二：

def page(url):
def get():
return requests.get(url).text
return get
提示：requests模块是用来模拟浏览器向网站发送请求并将页面内容下载到本地，需要事先安装：pip3 install requests

对比两种方式，方式一在下载同一页面时需要重复传入url，而方式二只需要传一次值，就会得到一个包含指定url的闭包函数，以后调用该闭包函数无需再传url

方式一下载同一页面

get('https://www.python.org')
get('https://www.python.org')
get('https://www.python.org')
……
​

方式二下载同一页面

python=page('https://www.python.org')
python()
python()
python()
……
闭包函数的这种特性有时又称为惰性计算。使用将值包给函数的方式，在接下来的装饰器中也将大有用处

15、装饰器
一 装饰器介绍
1.1 为何要用装饰器
软件的设计应该遵循开放封闭原则，即对扩展是开放的，而对修改是封闭的。对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。对修改封闭，意味着对象一旦设计完成，就可以独立完成其工作，而不要对其进行修改。

软件包含的所有功能的源代码以及调用方式，都应该避免修改，否则一旦改错，则极有可能产生连锁反应，最终导致程序崩溃，而对于上线后的软件，新需求或者变化又层出不穷，我们必须为程序提供扩展的可能性，这就用到了装饰器。

1.2 什么是装饰器
’装饰’代指为被装饰对象添加新的功能，’器’代指器具/工具，装饰器与被装饰的对象均可以是任意可调用对象。概括地讲，装饰器的作用就是在不修改被装饰对象源代码和调用方式的前提下为被装饰对象添加额外的功能。装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景，装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

提示：可调用对象有函数，方法或者类，此处我们单以本章主题函数为例，来介绍函数装饰器，并且被装饰的对象也是函数。

二 装饰器的实现
函数装饰器分为：无参装饰器和有参装饰两种，二者的实现原理一样，都是’函数嵌套+闭包+函数对象’的组合使用的产物。

2.1 无参装饰器的实现
如果想为下述函数添加统计其执行时间的功能

import time
​
def index():
time.sleep(3)
print('Welcome to the index page’)
return 200
​
index() #函数执行
遵循不修改被装饰对象源代码的原则，我们想到的解决方法可能是这样

start_time=time.time()
index() #函数执行
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
考虑到还有可能要统计其他函数的执行时间，于是我们将其做成一个单独的工具，函数体需要外部传入被装饰的函数从而进行调用，我们可以使用参数的形式传入

def wrapper(func): # 通过参数接收外部的值
start_time=time.time()
res=func()
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
但之后函数的调用方式都需要统一改成

wrapper(index)
wrapper(其他函数)
这便违反了不能修改被装饰对象调用方式的原则，于是我们换一种为函数体传值的方式，即将值包给函数，如下

def timer(func):
def wrapper(): # 引用外部作用域的变量func
start_time=time.time()
res=func()
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
这样我们便可以在不修改被装饰函数源代码和调用方式的前提下为其加上统计时间的功能，只不过需要事先执行一次timer将被装饰的函数传入，返回一个闭包函数wrapper重新赋值给变量名 /函数名index，如下

index=timer(index) #得到index=wrapper，wrapper携带对外作用域的引用：func=原始的index
index() # 执行的是wrapper()，在wrapper的函数体内再执行最原始的index
至此我们便实现了一个无参装饰器timer，可以在不修改被装饰对象index源代码和调用方式的前提下为其加上新功能。但我们忽略了若被装饰的函数是一个有参函数，便会抛出异常

def home(name):
time.sleep(5)
print('Welcome to the home page',name)
​
home=timer(home)
home('egon')

抛出异常

TypeError: wrapper() takes 0 positional arguments but 1 was given
之所以会抛出异常，是因为home(‘egon’)调用的其实是wrapper(‘egon’)，而函数wrapper没有参数。wrapper函数接收的参数其实是给最原始的func用的，为了能满足被装饰函数参数的所有情况，便用上*args+**kwargs组合（见4.3小节）,于是修正装饰器timer如下

def timer(func):
def wrapper(args,**kwargs):
start_time=time.time()
res=func(args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
此时我们就可以用timer来装饰带参数或不带参数的函数了，但是为了简洁而优雅地使用装饰器，Python提供了专门的装饰器语法来取代index=timer(index)的形式，需要在被装饰对象的正上方单独一行添加@timer,当解释器解释到@timer时就会调用timer函数，且把它正下方的函数名当做实参传入，然后将返回的结果重新赋值给原函数名

@timer # index=timer(index)
def index():
time.sleep(3)
print('Welcome to the index page')
return 200
@timer # index=timer(home)• def home(name):
time.sleep(5)
print('Welcome to the home page’,name)
如果我们有多个装饰器，可以叠加多个

@deco3
@deco2
@deco1
def index():
pass
叠加多个装饰器也无特殊之处，上述代码语义如下：

index=deco3(deco2(deco1(index)))
2.2 有参装饰器的实现
了解无参装饰器的实现原理后，我们可以再实现一个用来为被装饰对象添加认证功能的装饰器，实现的基本形式如下

def deco(func):
def wrapper(args,**kwargs):
编写基于文件的认证,认证通过则执行res=func(args,**kwargs),并返回res
return wrapper
如果我们想提供多种不同的认证方式以供选择，单从wrapper函数的实现角度改写如下

def deco(func):
def wrapper(args,**kwargs):
if driver == 'file':
编写基于文件的认证,认证通过则执行res=func(args,kwargs),并返回res
elif driver == 'mysql':
编写基于mysql认证,认证通过则执行res=func(*args,kwargs),并返回res
return wrapper
函数wrapper需要一个driver参数，而函数deco与wrapper的参数都有其特定的功能，不能用来接受其他类别的参数，可以在deco的外部再包一层函数auth，用来专门接受额外的参数，这样便保证了在auth函数内无论多少层都可以引用到

def auth(driver):
def deco(func):
……
return deco
此时我们就实现了一个有参装饰器，使用方式如下

先调用auth_type(driver='file')，得到@deco，deco是一个闭包函数，
包含了对外部作用域名字driver的引用，@deco的语法意义与无参装饰器一样
@auth(driver='file')
def index():
pass
@auth(driver='mysql')
def home():
pass
可以使用help(函数名)来查看函数的文档注释，本质就是查看函数的doc属性，但对于被装饰之后的函数，查看文档注释

@timer
def home(name):
'''
home page function
:param name: str
:return: None
'''
time.sleep(5)
print('Welcome to the home page',name)
​
print(help(home))
'''
打印结果：
​
Help on function wrapper in module main:
​
wrapper(*args, **kwargs)
​
None
在被装饰之后home=wrapper,查看home.name也可以发现home的函数名确实是wrapper，想要保留原函数的文档和函数名属性，需要修正装饰器

def timer(func):
def wrapper(args,**kwargs):
start_time=time.time()
res=func(args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
wrapper.doc=func.doc
wrapper.name=func.name
return wrapper
按照上述方式来实现保留原函数属性过于麻烦，functools模块下提供一个装饰器wraps专门用来帮我们实现这件事，用法如下

from functools import wraps
​
def timer(func):
@wraps(func)
def wrapper(args,**kwargs):
start_time=time.time()
res=func(args,kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
标准版装饰器：
def wrapper(func):
def inner(*args,kwargs):
"""执行被装饰函数前的操作"""
func(*args,**kwargs)
"""执行被装饰函数后的操作"""
return inner
@wrapper
def index():
print("is index")
index()
语法糖要接受的变量就是语法糖下面的函数名、参数就是语法糖下面的函数名、调用的方式就是看调用的哪个语法糖
def func(args):
print("新加了一个功能")
return args
@func #index = func(index)
def index():
print(2)
index()
结果：　　新加了一个功能
16、迭代器
一 迭代器介绍
迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代

while True:
msg = input('>>: ').strip()
print(msg)
下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值

goods=['mac','lenovo','acer','dell','sony']
​
index=0
while index < len(goods):
print(goods[index])
index+=1
1.1 可迭代对象
通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。

要想了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象(Iterable)。从语法形式上讲，内置有iter方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象：

{'name':'egon'}.iter
{7,8,9}.iter
……
1.2 迭代器对象
调用obj.iter()方法返回的结果就是一个迭代器对象(Iterator)。迭代器对象是内置有iter和next方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象.iter()方法得到的仍然是迭代器本身，而执行迭代器.next()方法就会计算出迭代器中的下一个值。 迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值

s={1,2,3} # 可迭代对象s
i=iter(s) # 本质就是在调用s.iter(),返回s的迭代器对象i，
next(i) # 本质就是在调用i.next()
1
next(i)
2
next(i)
3
next(i) #抛出StopIteration的异常，代表无值可取，迭代结束
二 for循环原理
有了迭代器后，我们便可以不依赖索引迭代取值了，使用while循环的实现方式如下

goods=['mac','lenovo','acer','dell','sony']
i=iter(goods) #每次都需要重新获取一个迭代器对象
while True:
try:
print(next(i))
except StopIteration: #捕捉异常终止循环
break
for循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可以简写为

goods=['mac','lenovo','acer','dell','sony']
for item in goods:
print(item)
for 循环在工作时，首先会调用可迭代对象goods内置的iter方法拿到一个迭代器对象，然后再调用该迭代器对象的next方法将取到的值赋给item,执行循环体完成一次循环，周而复始，直到捕捉StopIteration异常，结束迭代。

三 迭代器的优缺点
基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存：

3.1 优点：
1、为序列和非序列类型提供了一种统一的迭代取值方式。

2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

3.2 缺点：
1、除非取尽，否则无法获取迭代器的长度

2、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。

17、生成器
一 生成器与yield
若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象

def my_range(start,stop,step=1):
... print('start...')
... while start < stop:
... yield start
... start+=step
... print('end...')
...
g=my_range(0,3)
g
<generator object my_range at 0x104105678>
生成器内置有iter和next方法，所以生成器本身就是一个迭代器

g.iter
<method-wrapper 'iter' of generator object at 0x1037d2af0>
g.next
<method-wrapper 'next' of generator object at 0x1037d2af0>
因而我们可以用next(生成器)触发生成器所对应函数的执行，

next(g) # 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数
start...
0
next(g) # 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...
1
next(g) # 周而复始...
2
next(g) # 触发函数执行没有遇到yield则无值返回，即取值完毕抛出异常结束迭代
end...
Traceback (most recent call last):
File "", line 1, in
StopIteration
既然生成器对象属于迭代器，那么必然可以使用for循环迭代，如下：

for i in countdown(3):
... print(i)
...
countdown start
3
2
1
Done!
有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值

二 yield表达式应用
在函数内可以采用表达式形式的yield

def eater():
... print('Ready to eat')
... while True:
... food=yield
... print('get the food: %s, and start to eat' %food)
...
可以拿到函数的生成器对象持续为函数体send值，如下

g=eater() # 得到生成器对象
g
<generator object eater at 0x101b6e2b0>
next(e) # 需要事先”初始化”一次，让函数挂起在food=yield，等待调用g.send()方法为其传值
Ready to eat
g.send('包子')
get the food: 包子, and start to eat
g.send('鸡腿')
get the food: 鸡腿, and start to eat
针对表达式形式的yield，生成器对象必须事先被初始化一次，让函数挂起在food=yield的位置，等待调用g.send()方法为函数体传值，g.send(None)等同于next(g)。

我们可以编写装饰器来完成为所有表达式形式yield对应生成器的初始化操作，如下

def init(func):
def wrapper(args,**kwargs):
g=func(args,**kwargs)
next(g)
return g
return wrapper
​
@init
def eater():
print('Ready to eat')
while True:
food=yield
print('get the food: %s, and start to eat' %food)
表达式形式的yield也可以用于返回多次值，即变量名=yield 值的形式，如下

def eater():
... print('Ready to eat')
... food_list=[]
... while True:
... food=yield food_list
... food_list.append(food)
...
e=eater()
next(e)
Ready to eat
[]
e.send('蒸羊羔')
['蒸羊羔']
e.send('蒸熊掌')
['蒸羊羔', '蒸熊掌']
e.send('蒸鹿尾儿')
['蒸羊羔', '蒸熊掌', '蒸鹿尾儿']
三 三元表达式、列表生成式、生成器表达式
3.1 三元表达式
三元表达式是python为我们提供的一种简化代码的解决方案，语法如下

res = 条件成立时返回的值 if 条件 else 条件不成立时返回的值
针对下述场景

def max2(x,y):
if x > y:
return x
else:
return y
​
res = max2(1,2)
用三元表达式可以一行解决

x=1
y=2
res = x if x > y else y # 三元表达式
3.2 列表生成式
列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表，语法如下

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
​

类似于

res=[]
for item1 in iterable1:
if condition1:
for item2 in iterable2:
if condition2
...
for itemN in iterableN:
if conditionN:
res.append(expression)
针对下述场景

egg_list=[]
for i in range(10):
egg_list.append('鸡蛋%s' %i)
用列表生成式可以一行解决

egg_list=['鸡蛋%s' %i for i in range(10)]
3.3 生成器表达式
创建一个生成器对象有两种方式，一种是调用带yield关键字的函数，另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()，即：

（expression for item in iterable if condition）
对比列表生成式返回的是一个列表，生成器表达式返回的是一个生成器对象

[xx for x in range(3)]
[0, 1, 4]
g=(xx for x in range(3))
g
<generator object at 0x101be0ba0>
对比列表生成式，生成器表达式的优点自然是节省内存（一次只产生一个值在内存中）

next(g)
0
next(g)
1
next(g)
4
next(g) #抛出异常StopIteration
如果我们要读取一个大文件的字节数，应该基于生成器表达式的方式完成

with open('db.txt','rb') as f:
nums=(len(line) for line in f)
total_size=sum(nums) # 依次执行next(nums)，然后累加到一起得到结果=
18、函数递归
一 函数递归调用介绍
函数不仅可以嵌套定义，还可以嵌套调用，即在调用一个函数的过程中，函数内部又调用另一个函数，而函数的递归调用指的是在调用一个函数的过程中又直接或间接地调用该函数本身

例如

在调用f1的过程中，又调用f1，这就是直接调用函数f1本身

def f1():
print('from f1')
f1()
f1()
在调用f1的过程中，又调用f2，而在调用f2的过程中又调用f1，这就是间接调用函数f1本身

def f1():
print('from f1')
f2()
​
def f2():
print('from f2')
f1()
​
f1()
从上图可以看出，两种情况下的递归调用都是一个无限循环的过程，但在python对函数的递归调用的深度做了限制，因而并不会像大家所想的那样进入无限循环，会抛出异常，要避免出现这种情况，就必须让递归调用在满足某个特定条件下终止。

提示：

1. 可以使用sys.getrecursionlimit()去查看递归深度，默认值为1000，虽然可以使用

sys.setrecursionlimit()去设定该值，但仍受限于主机操作系统栈大小的限制
​

2. python不是一门函数式编程语言，无法对递归进行尾递归优化。

二 回溯与递推
def salary(n):
if n==1:
return 5000
return salary(n-1)+1000
​
s=salary(4)
print(s)
19、面向过程与函数式
一 编程范式
面向过程、函数式、面向对象

二 面向过程
import os,time
​

一：基于本章所学，我们可以用函数去实现这一个个的步骤

1、本地数据打包

def data_backup(folder):
print("找到备份目录: %s" %folder)
print('正在备份...')
zip_file='/tmp/backup_%s.zip' %time.strftime('%Y%m%d')
print('备份成功，备份文件为: %s' %zip_file)
return zip_file
​

2、上传至云服务器

def cloud_upload(file):
print("\nconnecting cloud storage center...")
print("cloud storage connected")
print("upload [%s] to cloud..." %file)
link='https://www.xxx.com/bak/%s' %os.path.basename(file)
print('close connection')
return link
​

3、检测备份文件可用性

def data_backup_check(link):
print("\n下载文件: %s , 验证文件是否无损..." %link)
​
​

二：依次调用

步骤一：本地数据打包

zip_file = data_backup(r"/Users/egon/欧美100G高清无码")
​

步骤二：上传至云服务器

link=cloud_upload(zip_file)
​

步骤三：检测备份文件的可用性

data_backup_check(link)
面向过程总结：

1、优点

将复杂的问题流程化，进而简单化
2、缺点

'''
程序的可扩展性极差，因为一套流水线或者流程就是用来解决一个问题，就好比生产汽水的流水线无法生产汽车一样，即便是能，也得是大改，而且改一个组件，与其相关的组件可能都需要修改，比如我们修改了cloud_upload的逻辑，那么依赖其结果才能正常执行的data_backup_check也需要修改，这就造成了连锁反应，而且这一问题会随着程序规模的增大而变得越发的糟糕。
'''
​
def cloud_upload(file): # 加上异常处理，在出现异常的情况下，没有link返回
try:
print("\nconnecting cloud storage center...")
print("cloud storage connected")
print("upload [%s] to cloud..." %file)
link='https://www.xxx.com/bak/%s' %os.path.basename(file)
print('close connection')
return link
except Exception:
print('upload error')
finally:
print('close connection.....')
​
def data_backup_check(link): # 加上对参数link的判断
if link:
print("\n下载文件: %s , 验证文件是否无损..." %link)
else:
print('\n链接不存在')
3、应用场景

面向过程的程序设计一般用于那些功能一旦实现之后就很少需要改变的场景， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程去实现是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护， 那还是用面向对象最为方便。
三 函数式
函数式编程并非用函数编程这么简单，而是将计算机的运算视为数学意义上的运算，比起面向过程，函数式更加注重的是执行结果而非执行的过程，代表语言有：Haskell、Erlang。而python并不是一门函数式编程语言，但是仍为我们提供了很多函数式编程好的特性，如lambda，map，reduce，filter

3.1 匿名函数与lambda
对比使用def关键字创建的是有名字的函数，使用lambda关键字创建则是没有名字的函数，即匿名函数，语法如下

lambda 参数1,参数2,...: expression
举例

1、定义

lambda x,y,z:x+y+z
​

等同于

def func(x,y,z):
return x+y+z
​

2、调用

方式一：

res=(lambda x,y,z:x+y+z)(1,2,3)
​

方式二：

func=lambda x,y,z:x+y+z # “匿名”的本质就是要没有名字，所以此处为匿名函数指定名字是没有意义的
res=func(1,2,3)
匿名函数与有名函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，所以匿名函数用于临时使用一次的场景，匿名函数通常与其他函数配合使用，我们以下述字典为例来介绍它

salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
要想取得薪水的最大值和最小值，我们可以使用内置函数max和min（为了方便开发，python解释器已经为我们定义好了一系列常用的功能，称之为内置的函数，我们只需要拿来使用即可）

max(salaries)
'tom'
min(salaries)
'jack'
内置max和min都支持迭代器协议，工作原理都是迭代字典，取得是字典的键，因而比较的是键的最大和最小值，而我们想要的是比较值的最大值与最小值，于是做出如下改动

函数max会迭代字典salaries，每取出一个“人名”就会当做参数传给指定的匿名函数，然后将匿名函数的返回值当做比较依据，最终返回薪资最高的那个人的名字

max(salaries,key=lambda k:salaries[k])
'lili'

原理同上

min(salaries,key=lambda k:salaries[k])
'jack'
同理，我们直接对字典进行排序，默认也是按照字典的键去排序的

sorted(salaries)
['jack', 'lili', 'siry', 'tom']
3.2 map、reduce、filter
函数map、reduce、filter都支持迭代器协议，用来处理可迭代对象，我们以一个可迭代对象array为例来介绍它们三个的用法

array=[1,2,3,4,5]
要求一：对array的每个元素做平方处理，可以使用map函数

map函数可以接收两个参数，一个是函数，另外一个是可迭代对象，具体用法如下

res=map(lambda x:x**2,array)
res
<map object at 0x1033f45f8>

解析：map会依次迭代array，得到的值依次传给匿名函数（也可以是有名函数），而map函数得到的结果仍然是迭代器。

list(res) #使用list可以依次迭代res，取得的值作为列表元素
[1, 4, 9, 16, 25]
要求二：对array进行合并操作，比如求和运算，这就用到了reduce函数

reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值

reduce在python2中是内置函数，在python3中则被集成到模块functools中，需要导入才能使用

from functools import reduce
res=reduce(lambda x,y:x+y,array)
res
15
解析：

1 没有初始值，reduce函数会先迭代一次array得到的值作为初始值，作为第一个值数传给x，然后继续迭代一次array得到的值作为第二个值传给y，运算的结果为3

2 将上一次reduce运算的结果作为第一个值传给x，然后迭代一次array得到的结果作为第二个值传给y，依次类推，知道迭代完array的所有元素，得到最终的结果15

也可以为reduce指定初始值

res=reduce(lambda x,y:x+y,array,100)•>>> res
115
要求三：对array进行过滤操作，这就用到了filter函数，比如过滤出大于3的元素

res=filter(lambda x:x>3,array)
解析：filter函数会依次迭代array，得到的值依次传给匿名函数，如果匿名函数的返回值为真，则过滤出该元素，而filter函数得到的结果仍然是迭代器。

list(res)
[4, 5]
提示：我们介绍map、filter、reduce只是为了带大家了解函数式编程的大致思想，在实际开发中，我们完全可以用列表生成式或者生成器表达式来实现三者的功能。

20、模块
一 模块介绍
在Python中，一个py文件就是一个模块，文件名为xxx.py模块名则是xxx,导入模块可以引用模块中已经写好的功能。如果把开发程序比喻成制造一台电脑，编写模块就像是在制造电脑的零部件，准备好零部件后，剩下的工作就是按照逻辑把它们组装到一起。

将程序模块化会使得程序的组织结构清晰，维护起来更加方便。比起直接开发一个完整的程序，单独开发一个小的模块也会更加简单，并且程序中的模块与电脑中的零部件稍微不同的是：程序中的模块可以被重复使用。所以总结下来，使用模块既保证了代码的重用性，又增强了程序的结构性和可维护性。另外除了自定义模块外，我们还可以导入使用内置或第三方模块提供的现成功能，这种“拿来主义”极大地提高了程序员的开发效率。

二 模块的使用
2.1 import语句
有如下示范文件

文件名：foo.py

x=1
def get():
print(x)
def change():
global x
x=0
class Foo:
def func(self):
print('from the func')
要想在另外一个py文件中引用foo.py中的功能，需要使用import foo，首次导入模块会做三件事：

1、执行源文件代码

2、产生一个新的名称空间用于存放源文件执行过程中产生的名字

3、在当前执行文件所在的名称空间中得到一个名字foo，该名字指向新创建的模块名称空间，若要引用模块名称空间中的名字，需要加上该前缀，如下

import foo #导入模块foo
a=foo.x #引用模块foo中变量x的值赋值给当前名称空间中的名字a
foo.get() #调用模块foo的get函数
foo.change() #调用模块foo中的change函数
obj=foo.Foo() #使用模块foo的类Foo来实例化，进一步可以执行obj.func()
加上foo.作为前缀就相当于指名道姓地说明要引用foo名称空间中的名字，所以肯定不会与当前执行文件所在名称空间中的名字相冲突，并且若当前执行文件的名称空间中存在x，执行foo.get()或foo.change()操作的都是源文件中的全局变量x。

需要强调一点是，第一次导入模块已经将其加载到内存空间了，之后的重复导入会直接引用内存中已存在的模块，不会重复执行文件，通过import sys，打印sys.modules的值可以看到内存中已经加载的模块名。

提示：

1、在Python中模块也属于第一类对象，可以进行赋值、以数据形式传递以及作为容器类型的元素等操作。

2、模块名应该遵循小写形式，标准库从python2过渡到python3做出了很多这类调整，比如ConfigParser、Queue、SocketServer全更新为纯小写形式。

用import语句导入多个模块，可以写多行import语句

import module1
import module2
...
import moduleN
还可以在一行导入，用逗号分隔开不同的模块

import module1,module2,...,moduleN
但其实第一种形式更为规范，可读性更强，推荐使用，而且我们导入的模块中可能包含有python内置的模块、第三方的模块、自定义的模块，为了便于明显地区分它们，我们通常在文件的开头导入模块，并且分类导入，一类模块的导入与另外一类的导入用空行隔开，不同类别的导入顺序如下：

1. python内置模块

2. 第三方模块

3. 程序员自定义模块

当然，我们也可以在函数内导入模块，对比在文件开头导入模块属于全局作用域，在函数内导入的模块则属于局部的作用域。

2.2 from-import 语句
from...import...与import语句基本一致，唯一不同的是：使用import foo导入模块后，引用模块中的名字都需要加上foo.作为前缀，而使用from foo import x,get,change,Foo则可以在当前执行文件中直接引用模块foo中的名字，如下

from foo import x,get,change #将模块foo中的x和get导入到当前名称空间
a=x #直接使用模块foo中的x赋值给a
get() #直接执行foo中的get函数
change() #即便是当前有重名的x，修改的仍然是源文件中的x
无需加前缀的好处是使得我们的代码更加简洁，坏处则是容易与当前名称空间中的名字冲突，如果当前名称空间存在相同的名字，则后定义的名字会覆盖之前定义的名字。

另外from语句支持from foo import 语法，代表将foo中所有的名字都导入到当前位置

from foo import * #把foo中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字
​
a=x
get()
change()
obj=Foo()
如果我们需要引用模块中的名字过多的话，可以采用上述的导入形式来达到节省代码量的效果，但是需要强调的一点是：只能在模块最顶层使用的方式导入，在函数内则非法，并且的方式会带来一种副作用，即我们无法搞清楚究竟从源文件中导入了哪些名字到当前位置，这极有可能与当前位置的名字产生冲突。模块的编写者可以在自己的文件中定义all变量用来控制*代表的意思

foo.py

all=['x','get'] #该列表中所有的元素必须是字符串类型，每个元素对应foo.py中的一个名字
x=1
def get():
print(x)
def change():
global x
x=0
class Foo:
def func(self):
print('from the func')
这样我们在另外一个文件中使用*导入时，就只能导入all定义的名字了

from foo import * #此时的*只代表x和get
​
x #可用
get() #可用
change() #不可用
Foo() #不可用
2.3 其他导入语法(as)
我们还可以在当前位置为导入的模块起一个别名

import foo as f #为导入的模块foo在当前位置起别名f，以后再使用时就用这个别名f
f.x
f.get()
还可以为导入的一个名字起别名

from foo import get as get_x
get_x()
通常在被导入的名字过长时采用起别名的方式来精简代码，另外为被导入的名字起别名可以很好地避免与当前名字发生冲突，还有很重要的一点就是：可以保持调用方式的一致性，例如我们有两个模块json和pickle同时实现了load方法，作用是从一个打开的文件中解析出结构化的数据，但解析的格式不同，可以用下述代码有选择性地加载不同的模块

if data_format == 'json':
import json as serialize #如果数据格式是json，那么导入json模块并命名为serialize
elif data_format == 'pickle':
import pickle as serialize #如果数据格式是pickle，那么导入pickle模块并命名为serialize
​
data=serialize.load(fn) #最终调用的方式是一致的
2.4 循环导入问题
循环导入问题指的是在一个模块加载/导入的过程中导入另外一个模块，而在另外一个模块中又返回来导入第一个模块中的名字，由于第一个模块尚未加载完毕，所以引用失败、抛出异常，究其根源就是在python中，同一个模块只会在第一次导入时执行其内部代码，再次导入该模块时，即便是该模块尚未完全加载完毕也不会去重复执行内部代码

我们以下述文件为例，来详细分析循环/嵌套导入出现异常的原因以及解决的方案

m1.py

print('正在导入m1')
from m2 import y
​
x='m1'
m2.py

print('正在导入m2')
from m1 import x
​
y='m2'
run.py

import m1
测试一

1、执行run.py会抛出异常

正在导入m1
正在导入m2
Traceback (most recent call last):
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/aa.py", line 1, in
import m1
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in
from m2 import y
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in
from m1 import x
ImportError: cannot import name 'x'
​

2、分析

先执行run.py--->执行import m1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"
--->执行from m2 import y 开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行from m1 import x,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错
测试二

1、执行文件不等于导入文件，比如执行m1.py不等于导入了m1

直接执行m1.py抛出异常
正在导入m1
正在导入m2
正在导入m1
Traceback (most recent call last):
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in
from m2 import y
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in
from m1 import x
File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in
from m2 import y
ImportError: cannot import name 'y'
​

2、分析

执行m1.py，打印“正在导入m1”，执行from m2 import y ，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行from m1 import x，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行from m1 import y，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错
解决方案

方案一：导入语句放到最后，保证在导入时，所有名字都已经加载过

文件：m1.py

print('正在导入m1')
​
x='m1'
​
from m2 import y
​

文件：m2.py

print('正在导入m2')
y='m2'
​
from m1 import x
​

文件：run.py内容如下，执行该文件，可以正常使用

import m1
print(m1.x)
print(m1.y)
​

方案二：导入语句放到函数中，只有在调用函数时才会执行其内部代码

文件：m1.py

print('正在导入m1')
​
def f1():
from m2 import y
print(x,y)
​
x = 'm1'
​

文件：m2.py

print('正在导入m2')
​
def f2():
from m1 import x
print(x,y)
​
y = 'm2'
​

文件：run.py内容如下，执行该文件，可以正常使用

import m1
​
m1.f1()
注意：循环导入问题大多数情况是因为程序设计失误导致，上述解决方案也只是在烂设计之上的无奈之举，在我们的程序中应该尽量避免出现循环/嵌套导入，如果多个模块确实都需要共享某些数据，可以将共享的数据集中存放到某一个地方，然后进行导入

2.5 搜索模块的路径与优先级
模块其实分为四个通用类别，分别是：

1、使用纯Python代码编写的py文件

2、包含一系列模块的包

3、使用C编写并链接到Python解释器中的内置模块

4、使用C或C++编译的扩展模块

在导入一个模块时，如果该模块已加载到内存中，则直接引用，否则会优先查找内置模块，然后按照从左到右的顺序依次检索sys.path中定义的路径，直到找模块对应的文件为止，否则抛出异常。sys.path也被称为模块的搜索路径，它是一个列表类型

sys.path
['',
'/Library/Frameworks/Python.framework/Versions/3.5/lib/python35.zip',
'/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5',
...,
'/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages'
列表中的每个元素其实都可以当作一个目录来看：在列表中会发现有.zip或.egg结尾的文件，二者是不同形式的压缩文件，事实上Python确实支持从一个压缩文件中导入模块，我们也只需要把它们都当成目录去看即可。

sys.path中的第一个路径通常为空，代表执行文件所在的路径，所以在被导入模块与执行文件在同一目录下时肯定是可以正常导入的，而针对被导入的模块与执行文件在不同路径下的情况，为了确保模块对应的源文件仍可以被找到，需要将源文件foo.py所在的路径添加到sys.path中，假设foo.py所在的路径为/pythoner/projects/

import sys
sys.path.append(r'/pythoner/projects/') #也可以使用sys.path.insert(……)
​
import foo #无论foo.py在何处,我们都可以导入它了
2.6 区分py文件的两种用途
一个Python文件有两种用途，一种被当主程序/脚本执行，另一种被当模块导入，为了区别同一个文件的不同用途，每个py文件都内置了name变量，该变量在py文件被当做脚本执行时赋值为“main”,在py文件被当做模块导入时赋值为模块名

作为模块foo.py的开发者，可以在文件末尾基于name在不同应用场景下值的不同来控制文件执行不同的逻辑

foo.py

...
if name == 'main':
foo.py被当做脚本执行时运行的代码
else:
foo.py被当做模块导入时运行的代码
通常我们会在if的子代码块中编写针对模块功能的测试代码，这样foo.py在被当做脚本运行时，就会执行测试代码，而被当做模块导入时则不用执行测试代码。

2.7 编写一个规范的模块
我们在编写py文件时，需要时刻提醒自己，该文件既是给自己用的，也有可能会被其他人使用，因而代码的可读性与易维护性显得十分重要，为此我们在编写一个模块时最好按照统一的规范去编写，如下

!/usr/bin/env python #通常只在类unix环境有效,作用是可以使用脚本名来执行，而无需直接调用解释器。

​
"The module is used to..." #模块的文档描述
​
import sys #导入模块
​
x=1 #定义全局变量,如果非必须,则最好使用局部变量,这样可以提高代码的易维护性,并且可以节省内存提高性能
​
class Foo: #定义类,并写好类的注释
'Class Foo is used to...'
pass
​
def test(): #定义函数,并写好函数的注释
'Function test is used to…'
pass
​
if name == 'main': #主程序
test() #在被当做脚本执行时,执行此处的代码