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的指令代码，直观性差，不便阅读和书写，还容易出错，且依赖于具体的计算机硬件型号，局限性很大。除了计算机生产厂家的专业人员外，绝大多数的程序员已经不再去学习机器语言了。机器语言是被微处理器理解和使用的，存在有多至100000种机器语言的指令，下述是一些简单示例#指令部份的示例0000 代表 加载（LOAD）0001 代表 存储（STORE）...#暂存器部份的示例0000 代表暂存器 A0001 代表暂存器 B...#存储器部份的示例000000000000 代表地址为 0 的存储器000000000001 代表地址为 1 的存储器000000010000 代表地址为 16 的存储器100000000000 代表地址为 2^11 的存储器#集成示例0000,0000,000000010000 代表 LOAD A, 160000,0001,000000000001 代表 LOAD B, 10001,0001,000000010000 代表 STORE B, 160001,0001,000000000001 代表 STORE B, 1[1]总结机器语言
编写的程序可以被计算机无障碍理解、直接运行，执行效率高 。
复杂，开发效率低
贴近\依赖具体的硬件，跨平台性差汇编语言汇编语言仅仅是用一个英文标签代表一组二进制指令，毫无疑问，比起机器语言，汇编语言是一种进步，但汇编语言的本质仍然是直接操作硬件，因此汇编语言仍是比较低级/底层的语言、贴近计算机硬件
相对于机器语言，使用英文标签编写程序相对简单，执行效率高，但较之机器语言稍低，
仍然是直接操作硬件，比起机器语言来说，复杂度稍低，但依旧居高不下，所以开发效率依旧较低
同样依赖具体的硬件，跨平台性差高级语言高级语言是站在人(奴隶主)的角度，说人话，即用人类的字符去编写程序，而人类的字符是在向操作系统发送指令，而非直接操作硬件，所以高级语言是与操作系统打交道的，此处的高级指的是高层、开发者无需考虑硬件细节，因而开发效率可以得到极大的提升，但正因为高级语言离硬件较远，更贴近人类语言，人类可以理解，而计算机则需要通过翻译才能理解，所以执行效率会低于低级语言。
按照翻译的方式的不同，高级语言又分为两种：
编译型（如C语言）:类似谷歌翻译，是把程序所有代码编译成计算机能识别的二进制指令，之后操作系统会拿着编译好的二进制指令直接操作硬件，详细如下
编译是指在应用源程序执行之前，就将程序源代码“翻译”成目标代码（即机器语言），因此其目标程序可以脱离其语言环境独立执行，使用比较方便，执行效率较高。
应用程序一旦需要修改，必须先修改源代码，然后重新编译、生成新的目标文件才能执行，而在只有目标文件而没有源代码，修改会很不方便。所以开发效率低于解释型
编译型代码是针对某一个平台翻译的，当前平台翻译的结果无法拿到不同的平台使用，针对不同的平台必须重新编译，即跨平台性差
现在大多数的编程语言都是编译型的。编译程序将源程序翻译成目标程序后保存在另一个文件中，该目标程序可脱离编译程序直接在计算机上多次运行。大多数软件产品都是以目标程序形式发行给用户的，不仅便于直接运行，同时又使他人难于盗用其中的技术。C、C++、Ada、Pascal都是编译实现的解释型（如python）:类似同声翻译，需要有一个解释器，解释器会读取程序代码，一边翻译一边执行，详细如下
解释型语言的实现中，翻译器并不产生目标机器代码，而是产生易于执行的中间代码。这种中间代码与机器代码是不同的，中间代码的解释是由软件支持的，不能直接使用硬件，软件解释器通常会导致执行效率较低。
用解释型语言编写的程序是由另一个可以理解中间代码的解释程序执行的，与编译程序不同的是，解释程序的任务是逐一将源程序的语句解释成可执行的机器指令，不需要将源程序翻译成目标代码再执行。解释程序的优点是当语句出现语法错误时，可以立即引起程序员的注意，而程序员在程序开发期间就能进行校正。
代码运行是依赖于解释器，不同平台有对应版本的解释器，所以解释型的跨平台性强
对于解释型Basic语言，需要一个专门的解释器解释执行Basic程序，每条语句只有在执行时才被翻译，这种解释型语言每执行一次就翻译一次，因而效率低下。一般地，动态语言都是解释型的，例如：Tcl、Perl、Ruby、VBScript、JavaScript等ps：混合型语言
java是一类特殊的编程语言，Java程序也需要编译，但是却没有直接编译为机器语言，而是编译为字节码，然后在Java虚拟机上以解释方式执行字节码。总结综上选择不同编程语言来开发应用程序对比
三 python介绍谈及python，涉及两层意思，一层代表的是python这门语言的语法风格，另外一层代表的则是专门用来解释该语法风格的应用程序：python解释器。
Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言
Python解释器的发展史从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。
Python解释器有哪些种类?官方的Python解释器本质就是基于C语言开发的一个软件，该软件的功能就是读取以.py结尾的文件内容，然后按照Guido定义好的语法和规则去翻译并执行相应的代码。
JPython解释器是用JAVA编写的python解释器，可以直接把Python代码编译成Java字节码并执行，它不但使基于java的项目之上嵌入python脚本成为可能，同时也可以将java程序引入到python程序之中。
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。这就好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
PyPy是Python开发者为了更好地Hack Python而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒功能，对Python代码进行动态编译（注意不是解释），因此运行速度比CPython还要快。
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。四 安装Cpython解释器Python解释器目前已支持所有主流操作系统，在Linux,Unix,Mac系统上自带Python解释器，在Windows系统上需要安装一下，具体步骤如下。
img
img
img
4.2、安装python解释器img
img
img
4.3、测试安装是否成功windows --> 运行 --> 输入cmd ，然后回车，弹出cmd程序，输入python,如果能进入交互环境 ，代表安装成功。
img
img
五 第一个python程序5.1 运行python程序有两种方式方式一： 交互式模式
img
方式二：脚本文件
print('hello world')
img
总结：
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安装
3、Python语法入门之变量一 引入我们学习python语言是为了控制计算机、让计算机能够像人一样去工作，所以在python这门语言中，所有语法存在的意义都是为了让计算机具备人的某一项技能，这句话是我们理解后续所有python语法的根本。
二 变量一、什么是变量？
二、为什么要有变量？
三、怎么使用变量（先定义、后使用）3.1、变量的定义与使用img
定义变量示范如下
name = 'harry' # 记下人的名字为'harry'sex = '男' # 记下人的性别为男性age = 18 # 记下人的年龄为18岁salary = 30000.1 # 记下人的薪资为30000.1元解释器执行到变量定义的代码时会申请内存空间存放变量值，然后将变量值的内存地址绑定给变量名，以变量的定义age=18为例，如下图
插图：定义变量申请内存
通过变量名即可引用到对应的值
print(age) # 通过变量名age找到值18，然后执行print(18),输出：18
AgeOfTony = 56NumberOfStudents = 80
age_of_tony = 56number_of_students = 803.4、变量值的三大特性
反应的是变量在内存中的唯一编号，内存地址不同id肯定不同
变量值的类型
变量值三、常量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=18birthday=1990student_count=482.2 float浮点型2.2.1 作用用来记录人的身高，体重，薪资等小数相关的状态
2.2.2 定义height=172.3weight=103.5salary=15000.892.3 数字类型的使用1 、数学运算
a = 1b = 3c = a + bc42、比较大小
x = 10y = 11x > yFalse三 字符串类型str3.1 作用用来记录人的名字，家庭住址，性别等描述性质的状态
3.2 定义name = 'harry'address = '上海市浦东新区'sex = '男'用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的，但是
msg = "My name is Tony , I'm 18 years old!" #内层有单引号，外层就需要用双引号
msg = '''天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。'''3.3 使用数字可以进行加减乘除等运算，字符串呢？也可以，但只能进行"相加"和"相乘"运算。
name = 'tony'age = '18'name + age #相加其实就是简单的字符串拼接'tony18'name * 5 #相乘就相当于将字符串相加了5次'tonytonytonytonytony'四 列表list4.1 作用如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型确实可以记录下来，比如
stu_names='张三 李四 王五'，但存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦，而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便
4.2 定义
stu_names=['张三','李四','王五']4.3 使用
stu_names=['张三','李四','王五']stu_names[0]'张三'stu_names[1]'李四'stu_names[2]'王五'
students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]students_info[0][2][0] #取出第一个学生的第一个爱好'play'五 字典dict5.1 作用如果我们需要用一个变量记录多个值，但多个值是不同属性的，比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义，这就用到字典类型，字典类型是用key：value形式来存储数据，其中key可以对value有描述性的功能
5.2 定义
person_info={'name':'tony','age':18,'height':185.3}5.3 使用
person_info={'name':'tony','age':18,'height':185.3}person_info['name']'tony'person_info['age']18person_info['height']185.3
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'六 布尔bool6.1 作用用来记录真假这两种状态
6.2 定义
is_ok = Trueis_ok = False6.3 使用通常用来当作判断的条件，我们将在if判断中用到它5、Python语法入门之垃圾回收机制一 引入解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题，当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？• 单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用），所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。• 毫无疑问，内存空间的申请与回收都是非常耗费精力的事情，而且存在很大的危险性，稍有不慎就有可能引发内存溢出问题，好在Cpython解释器提供了自动的垃圾回收机制来帮我们解决了这件事。二、什么是垃圾回收机制？垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间三、为什么要用垃圾回收机制？程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃，因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。四、理解GC原理需要储备的知识4.1、堆区与栈区在定义变量时，变量名与变量值都是需要存储的，分别对应内存中的两块区域：堆区与栈区
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 问题一：循环引用引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）
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:
username=input('请输入您的用户名：')请输入您的用户名：jack # username = "jack"password=input('请输入您的密码：')请输入您的密码：123 # password = "123"
l=input('输入什么类型就存成什么类型: ')输入什么类型就存成什么类型: [1,2,3]type(l)<type 'list'>1.3.2 输出print:print('hello world') # 只输出一个值hello worldprint('first','second','third') # 一次性输出多个值，值用逗号隔开first second third
print("aaaa",end='')print("bbbb",end='&')print("cccc",end='@')
1.3.3 输出之格式化输出(1)什么是格式化输出？把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。
(2)为什么要格式化输出？我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。
(3)如何格式化输出？这就用到了占位符，如：%s、%d：
print('亲爱的%s你好！你%s月的话费是%d，余额是%d' %('tony',12,103,11))亲爱的tony你好！你12月的话费是103，余额是11
name = input('your name: ')age = input('your age: ') #用户输入18,会存成字符串18,无法传给%dprint('My name is %s,my age is %s' %(name,age))
------------ info of Tony -----------Name : TonyAge : 22Sex : maleJob : 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=10y=zx=yx,y,z(10, 10, 10)链式赋值指的是可以用一行代码搞定这件事
x=y=z=10x,y,z(10, 10, 10)2.3.3 交叉赋值我们定义两个变量m与n
如果我们想将m与n的值交换过来，可以这么做
temp=mm=nn=tempm,n(20, 10)交叉赋值指的是一行代码可以搞定这件事
m=10n=20m,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)注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错
a,b=numsTraceback (most recent call last):File "", line 1, inValueError: too many values to unpack (expected 2)
a,b,c,d,e,f=numsTraceback (most recent call last):File "", line 1, inValueError: not enough values to unpack (expected 6, got 5)但如果我们只想取头尾的几个值，可以用*_匹配
a,b,*_=numsa,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 # 判断完第二个条件，就立即结束，得的最终结果为FalseFalse2.4.2 连续多个or可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False
2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为TrueTrue2.4.3 优先级not>and>or
3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3False
'''原理为：(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算'''
(3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3False
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'
1 or 311 and 330 and 2 and 100 and 2 or 110 and 2 or 1 or 410 or False and 1False2.5 成员运算符img
注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确
not 'lili' in ['jack','tom','robin']True'lili' not in ['jack','tom','robin']True2.6 身份运算符img
需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等
x='Info Tony:18'y='Info Tony:18'id(x),id(y) # x与y的id不同，但是二者的值相同(4327422640, 4327422256)x == y # 等号比较的是valueTruetype(x),type(y) # 值相同type肯定相同(<class 'str'>, <class 'str'>)x is y # is比较的是id，x与y的值相等但id可以不同False7、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......
2.3.2 if应用案例案例1：
如果：女人的年龄>30岁，那么：叫阿姨
age_of_girl=31if age_of_girl > 30:print('阿姨好')案例2：
如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐
age_of_girl=18if age_of_girl > 30:print('阿姨好')else:print('小姐好')案例3：
如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨**
age_of_girl=18height=171weight=99is_pretty=Trueif 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=18height=171weight=99is_pretty=Truesuccess=Falseif 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：
'''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代码3while的运行步骤：步骤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("输入的用户名或密码错误！")
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("输入的用户名或密码错误！")
username = "jason"password = "123"
count = 0while 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 = 0while 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 = 0while 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 = 0tag = Truewhile 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循环的条件都变为Falsebreakprint('run <%s>' % cmd)break # 用于结束本层循环，即第一层循环else:print("输入的用户名或密码错误！")count += 1案例五：while+continue的使用
break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环
number=11while number>1:number -= 1if number==7:continue # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环print(number)案例五：while+else的使用
在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束
count = 0while count <= 5 :count += 1print("Loop",count)else:print("循环正常执行完啦")print("-----out of while loop ------")输出Loop 1Loop 2Loop 3Loop 4Loop 5Loop 6循环正常执行完啦 #没有被break打断，所以执行了该行代码-----out of while loop ------如果执行过程中被break，就不会执行else的语句
count = 0while count <= 5 :count += 1if count == 3:breakprint("Loop",count)else:print("循环正常执行完啦")print("-----out of while loop ------")输出Loop 1Loop 2-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句练习1：
寻找1到100之间数字7最大的倍数（结果是98）
number = 100while number > 0:if number %7 == 0:print(number)breaknumber -= 1练习2：
age=18count=0while count<3:count+=1guess = 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 可迭代对象: # 此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解可迭代对象代码一代码二...
for item in ['a','b','c']:print(item)
abc
img
3.3.4 for循环应用案例
for count in range(6): # range(6)会产生从0-5这6个数print(count)
count = 0while count < 6:print(count)count += 1案例二：遍历字典
for k in {'name':'jason','age':18,'gender':'male'}: # for 循环默认取的是字典的key赋值给变量名kprint(k)
案例三：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()练习二：
打印金字塔
'''
***** # current_level=3,空格数=2,号数=5******* # current_level=4,空格数=1,号数=7********* # current_level=5,空格数=0,*号数=9
空格数=max_level-current_level号数=2current_level-1'''
max_level=5for 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与float2.1 定义
age=10 # 本质age = int(10)
salary=3000.3 # 本质salary=float(3000.3)
2.2 类型转换
s = '123'res = int(s)res,type(res)(123, <class 'int'>)int('12.3') # 错误演示：字符串内包含了非整数符号.Traceback (most recent call last):File "", line 1, inValueError: invalid literal for int() with base 10: '12.3'
bin(3)'0b11'oct(9)'0o11'hex(17)'0x11'
int('0b11',2)3int('0o11',8)9int('0x11',16)17
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 类型转换
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!'
str1[6]p
str1[-4]h
str1[0]='H' # 报错TypeError
str1[0:9]hello pyt
str1[0:9:2]hlopt
str1[::-1] # -1表示从右往左依次取值!nohtyp olleh
len(str1) # 空格也算字符13
'hello' in str1True
'tony' not in str1True
str5 = '今天你好吗？'for line in str5: # 依次取出字符串中每一个字符... print(line)...今天你好吗？3.3.2 需要掌握的操作
str3 = 'tony jam'
之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式
案例：
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的其他使用方式（了解）
str4 = 'my name is {}, my age is {}!'.format('tony', 18)str4my name is tony, my age is 18!
'%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接'h%e%l%l%o''|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接'tony|18|read'
num1 = b'4' #bytesnum2 = u'4' #unicode,python3中无需加u就是unicodenum3 = '四' #中文数字num4 = 'Ⅳ' #罗马数字
l1 = [1,'a',[1,2]] # 本质:l1 = list([1,'a',[1,2]])4.2 类型转换
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 优先掌握的操作
my_friends=['tony','jason','tom',4,5]my_friends[0]tony
my_friends[-1]5
my_friends = ['tony','jack','jason',4,5]my_friends[1] = 'martthow'my_friends['tony', 'martthow', 'jason', 4, 5]
my_friends[0:4]['tony', 'jason', 'tom', 4]
my_friends[0:4:2]['tony', 'tom']
len(my_friends)5
'tony' in my_friendsTrue'xxx' not in my_friendsTrue
l = [11,22,33,44]del l[2] # 删除索引为2的元素l[11,22,44]
l1=[1,2,3]l2=[2,]l2 > l1True
s1='abc's2='az's2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立True
for line in my_friends:print(line)'tony''jack''jason'454.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 类型转换
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)
5.4 使用
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
tuple1[0]1tuple1[-2]22tuple1[0] = 'hehe' # 报错：TypeError:
tuple1[0:6:2](1, 15000.0, 22)
len(tuple1)6
'hhaha' in tuple1True'hhaha' not in tuple1False
for line in tuple1:... print(line)1hhaha15000.0112233六 字典6.1 定义方式
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 类型转换
info=dict([['name','tony'],('age',18)])info{'age': 18, 'name': 'tony'}
{}.fromkeys(('name','age','sex'),None){'age': None, 'sex': None, 'name': None}6.3 使用6.3.1 优先掌握的操作
dic = {... 'name': 'xxx',... 'age': 18,... 'hobbies': ['play game', 'basketball']... }dic['name']'xxx'dic['hobbies'][1]'basketball'
dic['gender'] = 'male'dic
dic['name'] = 'tony'dic{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
len(dic)3
'name' in dic # 判断某个值是否是字典的keyTrue
dic =
for key in dic:... print(key)...agehobbiesname
7.2 定义"""定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：1：每个元素必须是不可变类型2：集合内没有重复的元素3：集合内元素无序"""s = {1,2,3,4} # 本质 s = set({1,2,3,4})
d = {} # 默认是空字典s = set() # 这才是定义空集合7.3 类型转换
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
friends1 | friends2{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
friends1 & friends2{'jason', 'egon'}
friends1 - friends2 # 求用户1独有的好友{'kevin', 'zero'}friends2 - friends1 # 求用户2独有的好友{'ricky', 'Jy'}
friends1 ^ friends2{'kevin', 'zero', 'ricky', 'Jy'}
friends1 == friends2False
{1,2,3} > {1,2}True{1,2,3} >= {1,2}True
{1,2,3} > {1,3,4,5}False{1,2,3} >= {1,3,4,5}False
{1,2} < {1,2,3}True{1,2} <= {1,2,3}True7.4.2 去重集合去重复有局限性
示例如下
l=['a','b',1,'a','a']s=set(l)s # 将列表转成了集合{'b', 'a', 1}l_new=list(s) # 再将集合转回列表l_new['b', 'a', 1] # 去除了重复，但是打乱了顺序
[{'age': 18, 'sex': 'male', 'name': 'lili'},{'age': 73, 'sex': 'male', 'name': 'jack'},{'age': 20, 'sex': 'female', 'name': 'tom'}]7.4.3 其他操作
s={'a','b','c'}len(s)3
'c' in sTrue
for item in s:... print(item)...cab7.5 练习"""一.关系运算有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}linuxs={'kermit','tony','gangdan'}1. 求出即报名python又报名linux课程的学员名字集合2. 求出所有报名的学生名字集合3. 求出只报名python课程的学员名字4. 求出没有同时这两门课程的学员名字集合"""
pythons & linuxs
pythons | linuxs
pythons - linuxs
pythons ^ linuxs八 可变类型与不可变类型可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值
不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值
数字类型:
x = 10id(x)1830448896x = 20id(x)1830448928
img
字符串
x = "Jy"id(x)938809263920x = "Ricky"id(x)938809264088
img
列表
img
元组
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)4327423112dic['age']=19dic{'age': 19, 'sex': 'male', 'name': 'egon'}id(dic)4327423112
img
九 数据类型总结img
1、数字类型：2、字符串类型3、列表类型4、元组类型5、字典类型6、集合类型9、字符编码一 引入字符串类型、文本文件的内容都是由字符组成的，但凡涉及到字符的存取，都需要考虑字符编码的问题。
img
2.2 文本编辑器读取文件内容的流程
2.4 总结python解释器与文件本编辑的异同如下
python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法）三、字符编码介绍3.1 什么是字符编码？人类在与计算机交互时，用的都是人类能读懂的字符，如中文字符、英文字符、日文字符等
而计算机只能识别二进制数,详解如下
毫无疑问，由人类的字符到计算机中的数字，必须经历一个过程，如下
img
翻译的过程必须参照一个特定的标准，该标准称之为字符编码表，该表上存放的就是字符与数字一一对应的关系。
字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字
3.2 字符编码表的发展史 (了解)字符编码的发展经历了三个重要的阶段，如下
3.2.1 阶段一：一家独大现代计算机起源于美国，所以最先考虑仅仅是让计算机识别英文字符，于是诞生了ASCII表
3.2.2 阶段二：诸侯割据、天下大乱
3.2.2 阶段二：诸侯割据、天下大乱为了让计算机能够识别中文和英文，中国人定制了GBK
每个国家都各自的字符，为让计算机能够识别自己国家的字符外加英文字符，各个国家都制定了自己的字符编码表
此时,美国人用的计算机里使用字符编码标准是ASCII、中国人用的计算机里使用字符编码标准是GBK、日本人用的计算机里使用字符编码标准是Shift_JIS,如下图所示，
img
字符编码发展到了这个阶段，可以用一句话概括：诸侯割据、天下大乱，详解如下
图1中，文本编辑存取文件的原理如下
文本文件内容全都为字符，无论存取都是涉及到字符编码问题
人类通过文本编辑器输入的字符会被转化成ASCII格式的二进制存放于内存中，如果需要永久保存，则直接将内存中的ASCII格式的二进制写入硬盘
直接将硬盘中的ASCII格式的二进制读入内存，然后通过ASCII表反解成英文字符图2图3都是相同的过程，此时无论是存还是取由于采用的字符编码表一样，所以肯定不会出现乱码问题，但问题是在美国人用的计算机里只能输入英文字符，而在中国人用的计算机里只能输入中文字符和英文字符....,毫无疑问我们希望计算机允许我们输入万国字符均可识别、不乱码，而现阶段计算机采用的字符编码ASCII、GBK、Shift_JIS都无法识别万国字符，所以我们必须定制一个兼容万国字符的编码表，请看阶段三
3.2.3 阶段三：分久必合unicode于1990年开始研发，1994年正式公布，具备两大特点：
很多地方或老的系统、应用软件仍会采用各种各样传统的编码，这是历史遗留问题。此处需要强调：软件是存放于硬盘的，而运行软件是要将软件加载到内存的，面对硬盘中存放的各种传统编码的软件，想让我们的计算机能够将它们全都正常运行而不出现乱码，内存中必须有一种兼容万国的编码，并且该编码需要与其他编码有相对应的映射/转换关系，这就是unicode的第二大特点产生的缘由
img
文本编辑器输入任何字符都是最新存在于内存中，是unicode编码的，存放于硬盘中，则可以转换成任意其他编码，只要该编码可以支持相应的字符
英文字符--->unciode格式的数字--->ASCII格式的数字
中文字符、英文字符--->unicode格式的数字--->gbk格式的数字
日文字符、英文字符--->unicode格式的数字--->shift-JIS格式的数字3.3 编码与解码由字符转换成内存中的unicode，以及由unicode转换成其他编码的过程，都称为编码encode
img
由内存中的unicode转换成字符，以及由其他编码转换成unicode的过程，都称为解码decode
img
在诸多文件类型中，只有文本文件的内存是由字符组成的，因而文本文件的存取也涉及到字符编码的问题
3.4 utf-8的由来注意：如果保存到硬盘的是GBK格式二进制，当初用户输入的字符只能是中文或英文，同理如果保存到硬盘的是Shift_JIS格式二进制，当初用户输入的字符只能是日文或英文……如果我们输入的字符中包含多国字符，那么该如何处理？
理论上是可以将内存中unicode格式的二进制直接存放于硬盘中的，但由于unicode固定使用两个字节来存储一个字符，如果多国字符中包含大量的英文字符时，使用unicode格式存放会额外占用一倍空间（英文字符其实只需要用一个字节存放即可），然而空间占用并不是最致命的问题，最致命地是当我们由内存写入硬盘时会额外耗费一倍的时间，所以将内存中的unicode二进制写入硬盘或者基于网络传输时必须将其转换成一种精简的格式，这种格式即utf-8（全称Unicode Transformation Format，即unicode的转换格式）
img
那为何在内存中不直接使用utf-8呢？
utf-8是针对Unicode的可变长度字符编码：一个英文字符占1Bytes，一个中文字符占3Bytes，生僻字用更多的Bytes存储unicode更像是一个过渡版本，我们新开发的软件或文件存入硬盘都采用utf-8格式，等过去几十年，所有老编码的文件都淘汰四 字符编码的应用我们学习字符编码就是为了存取字符时不发生乱码问题：
总结：
4.1 文本编辑器nodpad++存取文本文件文本编辑器存取的都是文本文件，而文本文件中包含的内容全为字符，所以存取文本文件都涉及到字符编码的问题。
img
4.2 python解释器执行文件的前两个阶段执行py文件的前两个阶段就是python解释器读文本文件的过程，与文本编辑读文本文件的前两个阶段没人任何区别，要保证读不乱码，则必须将python解释器读文件时采用的编码方式设置为文件当初写入硬盘时的编码格式，如果没有设置，python解释器则才用默认的编码方式，在python3中默认为utf-8，在python2中默认为ASCII，我们可以通过指定文件头来修改默认的编码
在文件首行写入包含#号在内的以下内容
解释器会先用默认的编码方式读取文件的首行内容，由于首行是纯英文组成，而任何编码方式都可以识别英文字符。
4.3 python解释器执行文件的第三个阶段设置文件头的作用是保证运行python程序的前两个阶段不乱码，经过前两个阶段后py文件的内容都会以unicode格式存放于内存中。
在经历第三个阶段时开始识别python语法，当遇到特定的语法name = '上'（代码本身也都全都是unicode格式存的）时，需要申请内存空间来存储字符串'上'，这就又涉及到应该以什么编码存储‘上’的问题了。
在Python3中，字符串类的值都是使用unicode格式来存储
由于Python2的盛行是早于unicode的，因此在Python2中是按照文件头指定的编码来存储字符串类型的值的（如果文件头中没有指定编码，那么解释器会按照它自己默认的编码方式来存储‘上’），所以，这就有可能导致乱码问题
x = '上' # x的值为untf-8格式的二进制print(x) # 打印操作是将x的值，即utf-8格式的二进制交给终端，当终端收到后发现并不是unicode（只有unicode才与字符有对应关系），所以终端会执行操作：utf-8二进制---解码-->unicode格式的二进制，解码的过程终端会采用自己默认的编码，而在pycharm的终端默认编码为utf-8、windows下的cmd终端的默认编码为gbk，所以该打印操作在pycharm中显示正常，而在windows下的cmd中则乱码
x = u'上' # 即便文件头为utf-8，x的值依然存成unicode4.4 字符串encode编码与decode解码的使用
3.1.3 案例三：a 模式的使用
3.2 控制文件读写内容的模式大前提: tb模式均不能单独使用,必须与r/w/a之一结合使用t（默认的）：文本模式1. 读写文件都是以字符串为单位的2. 只能针对文本文件3. 必须指定encoding参数b：二进制模式:1.读写文件都是以bytes/二进制为单位的2. 可以针对所有文件3. 一定不能指定encoding参数3.2.1 案例一：t 模式的使用
3.2.2 案例二： b 模式的使用
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便2、针对非文本文件（如图片、视频、音频等）只能使用b模式
5.1 案例一： 0模式详解
abc你好
abc你好
张一蛋 山东 179 49 12344234523李二蛋 河北 163 57 13913453521王全蛋 山西 153 62 18651433422
张一蛋<妇女主任> 179 49 12344234523李二蛋 河北 163 57 13913453521王全蛋 山西 153 62 18651433422
文件对应的是硬盘空间,硬盘不能修改对应着文件本质也不能修改, 那我们看到文件的内容可以修改,是如何实现的呢? 大致的思路是将硬盘中文件内容读入内存,然后在内存中修改完毕后再覆盖回硬盘 具体的实现方式分为两种:
6.1 文件修改方式一
二 定义函数函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。
定义函数的语法
def 函数名(参数1,参数2,...):"""文档描述"""函数体return 值def: 定义函数的关键字；
函数名：函数名指向函数内存地址，是对函数体代码的引用。函数的命名应该反映出函数的功能；
括号：括号内定义参数，参数是可有可无的，且无需指定参数的类型；
冒号：括号后要加冒号，然后在下一行开始缩进编写函数体的代码；
"""文档描述""": 描述函数功能，参数介绍等信息的文档，非必要，但是建议加上，从而增强函数的可读性；
函数体：由语句和表达式组成；
return 值：定义函数的返回值，return是可有可无的。
参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数，
def my_min(x,y):res=x if x < y else yreturn res否则定义为无参函数
def interactive():user=input('user>>: ').strip()pwd=input('password>>: ').strip()return (user,pwd)函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。例如要编写一个ftp程序，我们可能想到的功能有用户认证，下载，上传，浏览，切换目录等功能，可以先做出如下定义：
def auth_user():"""user authentication function"""passdef download_file():"""download file function"""passdef upload_file():"""upload file function"""passdef ls():"""list contents function"""passdef cd():"""change directory"""pass之后我们便可以统筹安排编程任务，有选择性的去实现上述功能来替换掉pass，从而提高开发效率。
三 调用函数与函数返回值函数的使用分为定义阶段与调用阶段，定义函数时只检测语法，不执行函数体代码，函数名加括号即函数调用，只有调用函数时才会执行函数体代码
def foo():print('in the foo')bar()def bar():print('in the bar')
foo()执行结果：
in the fooin the bar定义阶段函数foo与bar均无语法错误，而在调用阶段调用foo()时，函数foo与bar都早已经存在于内存中了，所以不会有任何问题。
按照在程序出现的形式和位置，可将函数的调用形式分为三种
foo()
m=my_min(1,2) #将调用函数的返回值赋值给xn=10*my_min(1,2) #将调用函数的返回值乘以10的结果赋值给n
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、函数的参数一 形参与实参介绍函数的参数分为形式参数和实际参数，简称形参和实参：
实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:
res=my_min(1,2)
a=1b=2res=my_min(a,b)
res=my_min(102,10my_min(3,4))
a=2my_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传值,默认为maleName:tom Age:17 Sex:maleregister('Lili',18,'female') #少数情况,可以为sex传值femaleName:Lili Age:18 Sex:female需要注意：
默认参数必须在位置参数之后
默认参数的值仅在函数定义阶段被赋值一次
x=1def foo(arg=x):... print(arg)...x=5 #定义阶段arg已被赋值为1，此处的修改与默认参数arg无任何关系foo()1默认参数的值通常应设为不可变类型
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)123(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)12(3, 4, 5)注意：如果在传入L时没有加*,那L就只是一个普通的位置参数了
foo(1,2,L) #仅多出一个位置实参L12([1, 2, 3],)如果形参为常规的参数（位置或默认），实参仍可以是*的形式
def foo(x,y,z=3):... print(x)... print(y)... print(z)...foo([1,2]) #等同于foo(1,2)123如果我们想要求多个值的和，args就派上用场了
def add(*args):... res=0... for i in args:... res+=i... return res...add(1,2,3,4,5)152.4.2 可变长度的关键字参数如果在最后一个形参名前加号,那么在调用函数时，溢出的关键字参数，都会被接收，以字典的形式保存下来赋值给该形参
def foo(x,kwargs): #在最后一个参数kwargs前加... print(x)... print(kwargs)...foo(y=2,x=1,z=3) #溢出的关键字实参y=2，z=3都被接收，以字典的形式保存下来，赋值给kwargs1{'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)12{'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)123如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用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.8m2.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 #模块名sysx=1 #变量名xif x == 1:y=2 #变量名ydef foo(x): #函数名fooy=1def bar():passClass Bar: #类名Barpass1.3 局部名称空间伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中
def foo(x):y=3 #调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部名称空间中名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间。
二 作用域2.1 全局作用域与局部作用域按照名字作用范围的不同可以将三个名称空间划分为两个区域：
全局作用域:位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）；
局部作用域:位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）。
2.2 作用域与名字查找的优先级在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常
x=100 #全局作用域的名字xdef foo():x=300 #局部作用域的名字xprint(x) #在局部找xfoo()#结果为300在全局作用域查找名字时，起始位置便是全局作用域，所以先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常
x=100def foo():x=300 #在函数调用时产生局部作用域的名字xfoo()print(x) #在全局找x,结果为100提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals()
Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域
x=1def outer():x=2def inner(): # 函数名inner属于outer这一层作用域的名字x=3print('inner x:%s' %x)inner()print('outer x:%s' %x)outer()
inner x:3outer x:2在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字
x=1def outer():x=2def inner(): # 函数名inner属于outer这一层作用域的名字x=3print('inner x:%s' %x)inner()print('outer x:%s' %x)outer()
inner x:3outer x:2在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字
x=1def foo():global x #声明x为全局名称空间的名字x=2foo()print(x) #结果为2当实参的值为可变类型时，函数体内对该值的修改将直接反应到原值，
def f1():x=2def f2():nonlocal xx=3f2() #调用f2(),修改f1作用域中名字x的值print(x) #在f1作用域查看xf1()
3nonlocal x会从当前函数的外层函数开始一层层去查找名字x，若是一直到最外层函数都找不到，则会抛出异常。
14、函数对象和闭包一 函数对象函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用，我们如下
1.1 函数可以被引用
x=1def f1():def f2():print(x)return f2def f3():x=3f2=f1() #调用f1()返回函数f2f2() #需要按照函数定义时的作用关系去执行，与调用位置无关f3() #结果为1也就是说函数被当做数据处理时，始终以自带的作用域为准。若内嵌函数包含对外部函数作用域（而非全局作用域）中变量的引用，那么该’内嵌函数’就是闭包函数，简称闭包(Closures)
x=1def outer():x=2def inner():print(x)return innerfunc=outer()func() # 结果为2可以通过函数的closure属性，查看到闭包函数所包裹的外部变量
2.2 闭包的用途目前为止，我们得到了两种为函数体传值的方式，一种是直接将值以参数的形式传入，另外一种就是将值包给函数
import requests
对比两种方式，方式一在下载同一页面时需要重复传入url，而方式二只需要传一次值，就会得到一个包含指定url的闭包函数，以后调用该闭包函数无需再传url
15、装饰器一 装饰器介绍1.1 为何要用装饰器软件的设计应该遵循开放封闭原则，即对扩展是开放的，而对修改是封闭的。对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。对修改封闭，意味着对象一旦设计完成，就可以独立完成其工作，而不要对其进行修改。
软件包含的所有功能的源代码以及调用方式，都应该避免修改，否则一旦改错，则极有可能产生连锁反应，最终导致程序崩溃，而对于上线后的软件，新需求或者变化又层出不穷，我们必须为程序提供扩展的可能性，这就用到了装饰器。
1.2 什么是装饰器’装饰’代指为被装饰对象添加新的功能，’器’代指器具/工具，装饰器与被装饰的对象均可以是任意可调用对象。概括地讲，装饰器的作用就是在不修改被装饰对象源代码和调用方式的前提下为被装饰对象添加额外的功能。装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景，装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
提示：可调用对象有函数，方法或者类，此处我们单以本章主题函数为例，来介绍函数装饰器，并且被装饰的对象也是函数。
二 装饰器的实现函数装饰器分为：无参装饰器和有参装饰两种，二者的实现原理一样，都是’函数嵌套+闭包+函数对象’的组合使用的产物。
wrapper(index)wrapper(其他函数)这便违反了不能修改被装饰对象调用方式的原则，于是我们换一种为函数体传值的方式，即将值包给函数，如下
index=timer(index) #得到index=wrapper，wrapper携带对外作用域的引用：func=原始的indexindex() # 执行的是wrapper()，在wrapper的函数体内再执行最原始的index至此我们便实现了一个无参装饰器timer，可以在不修改被装饰对象index源代码和调用方式的前提下为其加上新功能。但我们忽略了若被装饰的函数是一个有参函数，便会抛出异常
TypeError: wrapper() takes 0 positional arguments but 1 was given之所以会抛出异常，是因为home(‘egon’)调用的其实是wrapper(‘egon’)，而函数wrapper没有参数。wrapper函数接收的参数其实是给最原始的func用的，为了能满足被装饰函数参数的所有情况，便用上*args+**kwargs组合（见4.3小节）,于是修正装饰器timer如下
@deco3@deco2@deco1def index():pass叠加多个装饰器也无特殊之处，上述代码语义如下：
index=deco3(deco2(deco1(index)))2.2 有参装饰器的实现了解无参装饰器的实现原理后，我们可以再实现一个用来为被装饰对象添加认证功能的装饰器，实现的基本形式如下
def deco(func):def wrapper(args,**kwargs):编写基于文件的认证,认证通过则执行res=func(args,**kwargs),并返回resreturn wrapper如果我们想提供多种不同的认证方式以供选择，单从wrapper函数的实现角度改写如下
def deco(func):def wrapper(args,**kwargs):if driver == 'file':编写基于文件的认证,认证通过则执行res=func(args,kwargs),并返回reselif driver == 'mysql':编写基于mysql认证,认证通过则执行res=func(*args,kwargs),并返回resreturn 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属性，但对于被装饰之后的函数，查看文档注释
while True:msg = input('>>: ').strip()print(msg)下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值
goods=['mac','lenovo','acer','dell','sony']index=0while index < len(goods):print(goods[index])index+=11.1 可迭代对象通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。
要想了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象(Iterable)。从语法形式上讲，内置有iter方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象：
goods=['mac','lenovo','acer','dell','sony']i=iter(goods) #每次都需要重新获取一个迭代器对象while True:try:print(next(i))except StopIteration: #捕捉异常终止循环breakfor循环又称为迭代循环，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方法，所以生成器本身就是一个迭代器
next(g) # 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数start...0next(g) # 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...1next(g) # 周而复始...2next(g) # 触发函数执行没有遇到yield则无值返回，即取值完毕抛出异常结束迭代end...Traceback (most recent call last):File "", line 1, inStopIteration既然生成器对象属于迭代器，那么必然可以使用for循环迭代，如下：
for i in countdown(3):... print(i)...countdown start321Done!有了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值，如下
我们可以编写装饰器来完成为所有表达式形式yield对应生成器的初始化操作，如下
def init(func):def wrapper(args,**kwargs):g=func(args,**kwargs)next(g)return greturn wrapper@initdef eater():print('Ready to eat')while True:food=yieldprint('get the food: %s, and start to eat' %food)表达式形式的yield也可以用于返回多次值，即变量名=yield 值的形式，如下
res = 条件成立时返回的值 if 条件 else 条件不成立时返回的值针对下述场景
def max2(x,y):if x > y:return xelse:return yres = max2(1,2)用三元表达式可以一行解决
x=1y=2res = x if x > y else y # 三元表达式3.2 列表生成式列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表，语法如下
[expression for item1 in iterable1 if condition1for item2 in iterable2 if condition2...for itemN in iterableN if conditionN]
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)0next(g)1next(g)4next(g) #抛出异常StopIteration如果我们要读取一个大文件的字节数，应该基于生成器表达式的方式完成
例如
在调用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对函数的递归调用的深度做了限制，因而并不会像大家所想的那样进入无限循环，会抛出异常，要避免出现这种情况，就必须让递归调用在满足某个特定条件下终止。
提示：
二 回溯与递推def salary(n):if n==1:return 5000return salary(n-1)+1000s=salary(4)print(s)19、面向过程与函数式一 编程范式面向过程、函数式、面向对象
二 面向过程import os,time
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、缺点
面向过程的程序设计一般用于那些功能一旦实现之后就很少需要改变的场景， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程去实现是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护， 那还是用面向对象最为方便。三 函数式函数式编程并非用函数编程这么简单，而是将计算机的运算视为数学意义上的运算，比起面向过程，函数式更加注重的是执行结果而非执行的过程，代表语言有：Haskell、Erlang。而python并不是一门函数式编程语言，但是仍为我们提供了很多函数式编程好的特性，如lambda，map，reduce，filter
3.1 匿名函数与lambda对比使用def关键字创建的是有名字的函数，使用lambda关键字创建则是没有名字的函数，即匿名函数，语法如下
lambda 参数1,参数2,...: expression举例
lambda x,y,z:x+y+z
def func(x,y,z):return x+y+z
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,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函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值
from functools import reduceres=reduce(lambda x,y:x+y,array)res15解析：
1 没有初始值，reduce函数会先迭代一次array得到的值作为初始值，作为第一个值数传给x，然后继续迭代一次array得到的值作为第二个值传给y，运算的结果为3
2 将上一次reduce运算的结果作为第一个值传给x，然后迭代一次array得到的结果作为第二个值传给y，依次类推，知道迭代完array的所有元素，得到最终的结果15
也可以为reduce指定初始值
res=reduce(lambda x,y:x+y,array,100)•>>> res115要求三：对array进行过滤操作，这就用到了filter函数，比如过滤出大于3的元素
res=filter(lambda x:x>3,array)解析：filter函数会依次迭代array，得到的值依次传给匿名函数，如果匿名函数的返回值为真，则过滤出该元素，而filter函数得到的结果仍然是迭代器。
list(res)[4, 5]提示：我们介绍map、filter、reduce只是为了带大家了解函数式编程的大致思想，在实际开发中，我们完全可以用列表生成式或者生成器表达式来实现三者的功能。
将程序模块化会使得程序的组织结构清晰，维护起来更加方便。比起直接开发一个完整的程序，单独开发一个小的模块也会更加简单，并且程序中的模块与电脑中的零部件稍微不同的是：程序中的模块可以被重复使用。所以总结下来，使用模块既保证了代码的重用性，又增强了程序的结构性和可维护性。另外除了自定义模块外，我们还可以导入使用内置或第三方模块提供的现成功能，这种“拿来主义”极大地提高了程序员的开发效率。
二 模块的使用2.1 import语句有如下示范文件
1、执行源文件代码
2、产生一个新的名称空间用于存放源文件执行过程中产生的名字
3、在当前执行文件所在的名称空间中得到一个名字foo，该名字指向新创建的模块名称空间，若要引用模块名称空间中的名字，需要加上该前缀，如下
提示：
用import语句导入多个模块，可以写多行import语句
import module1import module2...import moduleN还可以在一行导入，用逗号分隔开不同的模块
import module1,module2,...,moduleN但其实第一种形式更为规范，可读性更强，推荐使用，而且我们导入的模块中可能包含有python内置的模块、第三方的模块、自定义的模块，为了便于明显地区分它们，我们通常在文件的开头导入模块，并且分类导入，一类模块的导入与另外一类的导入用空行隔开，不同类别的导入顺序如下：
当然，我们也可以在函数内导入模块，对比在文件开头导入模块属于全局作用域，在函数内导入的模块则属于局部的作用域。
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赋值给aget() #直接执行foo中的get函数change() #即便是当前有重名的x，修改的仍然是源文件中的x无需加前缀的好处是使得我们的代码更加简洁，坏处则是容易与当前名称空间中的名字冲突，如果当前名称空间存在相同的名字，则后定义的名字会覆盖之前定义的名字。
另外from语句支持from foo import 语法，代表将foo中所有的名字都导入到当前位置
from foo import * #把foo中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字a=xget()change()obj=Foo()如果我们需要引用模块中的名字过多的话，可以采用上述的导入形式来达到节省代码量的效果，但是需要强调的一点是：只能在模块最顶层使用的方式导入，在函数内则非法，并且的方式会带来一种副作用，即我们无法搞清楚究竟从源文件中导入了哪些名字到当前位置，这极有可能与当前位置的名字产生冲突。模块的编写者可以在自己的文件中定义all变量用来控制*代表的意思
from foo import * #此时的*只代表x和getx #可用get() #可用change() #不可用Foo() #不可用2.3 其他导入语法(as)我们还可以在当前位置为导入的模块起一个别名
from foo import get as get_xget_x()通常在被导入的名字过长时采用起别名的方式来精简代码，另外为被导入的名字起别名可以很好地避免与当前名字发生冲突，还有很重要的一点就是：可以保持调用方式的一致性，例如我们有两个模块json和pickle同时实现了load方法，作用是从一个打开的文件中解析出结构化的数据，但解析的格式不同，可以用下述代码有选择性地加载不同的模块
我们以下述文件为例，来详细分析循环/嵌套导入出现异常的原因以及解决的方案
import m1测试一
print('正在导入m1')x='m1'from m2 import y
print('正在导入m2')y='m2'from m1 import x
import m1print(m1.x)print(m1.y)
print('正在导入m1')def f1():from m2 import yprint(x,y)x = 'm1'
print('正在导入m2')def f2():from m1 import xprint(x,y)y = 'm2'
import m1m1.f1()注意：循环导入问题大多数情况是因为程序设计失误导致，上述解决方案也只是在烂设计之上的无奈之举，在我们的程序中应该尽量避免出现循环/嵌套导入，如果多个模块确实都需要共享某些数据，可以将共享的数据集中存放到某一个地方，然后进行导入
2.5 搜索模块的路径与优先级模块其实分为四个通用类别，分别是：
1、使用纯Python代码编写的py文件
2、包含一系列模块的包
3、使用C编写并链接到Python解释器中的内置模块
4、使用C或C++编译的扩展模块
2.7 编写一个规范的模块我们在编写py文件时，需要时刻提醒自己，该文件既是给自己用的，也有可能会被其他人使用，因而代码的可读性与易维护性显得十分重要，为此我们在编写一个模块时最好按照统一的规范去编写，如下
"The module is used to..." #模块的文档描述import sys #导入模块x=1 #定义全局变量,如果非必须,则最好使用局部变量,这样可以提高代码的易维护性,并且可以节省内存提高性能