程序最先是存放于硬盘中的，程序的运行是先从硬盘把代码加载到内存中，然后cpu是从内存中读取指令运行。
三操作系统概述3.1、操作系统的由来操作系统的功能就是帮我们把复杂的硬件的控制封装成简单的接口，对于开发应用程序来说只需要调用操作系统提供给我们的接口即可3.2、系统软件与应用软件硬件以上运行的都是软件，而软件分为两类：
一、应用软件（例如qq、word、暴风影音，我们学习python就是为了开发应用软件的）二、操作系统，操作系统应用软件与硬件之间的一个桥梁，是协调、管理、控制计算机硬件与应用软件资源的控制程序。3.3、计算机系统三层结构应用程序操作系统计算机硬件硬件+操作系统==平台
2、编程语言与Python介绍编程语言分类：机器语言机器语言是站在计算机(奴隶)的角度，说计算机能听懂/理解的语言，而计算机能直接理解的就是二进制指令，所以机器语言就是直接用二进制编程，这意味着机器语言是直接操作硬件的，因此机器语言属于低级语言，此处的低级指的是底层、贴近计算机硬件
编写的程序可以被计算机无障碍理解、直接运行，执行效率高。
复杂，开发效率低
贴近\依赖具体的硬件，跨平台性差汇编语言汇编语言仅仅是用一个英文标签代表一组二进制指令，毫无疑问，比起机器语言，汇编语言是一种进步，但汇编语言的本质仍然是直接操作硬件，因此汇编语言仍是比较低级/底层的语言、贴近计算机硬件
相对于机器语言，使用英文标签编写程序相对简单，执行效率高，但较之机器语言稍低，
仍然是直接操作硬件，比起机器语言来说，复杂度稍低，但依旧居高不下，所以开发效率依旧较低
同样依赖具体的硬件，跨平台性差高级语言高级语言是站在人(奴隶主)的角度，说人话，即用人类的字符去编写程序，而人类的字符是在向操作系统发送指令，而非直接操作硬件，所以高级语言是与操作系统打交道的，此处的高级指的是高层、开发者无需考虑硬件细节，因而开发效率可以得到极大的提升，但正因为高级语言离硬件较远，更贴近人类语言，人类可以理解，而计算机则需要通过翻译才能理解，所以执行效率会低于低级语言。
按照翻译的方式的不同，高级语言又分为两种：
编译型（如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开发者为了更好地HackPython而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒功能，对Python代码进行动态编译（注意不是解释），因此运行速度比CPython还要快。
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。四安装Cpython解释器Python解释器目前已支持所有主流操作系统，在Linux,Unix,Mac系统上自带Python解释器，在Windows系统上需要安装一下，具体步骤如下。
img
4.2、安装python解释器img
4.3、测试安装是否成功windows-->运行-->输入cmd，然后回车，弹出cmd程序，输入python,如果能进入交互环境，代表安装成功。
五第一个python程序5.1运行python程序有两种方式方式一：交互式模式
方式二：脚本文件
print('helloworld')
总结：
5.2注释在正式学习python语法前，我们必须事先介绍一个非常重要的语法：注释
1、什么是注释
注释就是就是对代码的解释说明，注释的内容不会被当作代码运行2、为什么要注释
增强代码的可读性3、怎么用注释
代码注释分单行和多行注释1、单行注释用#号，可以跟在代码的正上方或者正后方2、多行注释可以用三对双引号""""""4、代码注释的原则：
1、不用全部加注释，只需要为自己觉得重要或不好理解的部分加注释即可2、注释可以用中文或英文，但不要用拼音六IDE工具pycharm的使用在编写第一个python程序时，存在以下问题，严重影响开发效率
问题一：我们了解到一个python程序从开发到运行需要操作至少两个软件
1、打开一个软件：文本编辑器，创建文本来编写程序2、打开cmd，然后输入命令执行pyton程序问题二：在开发过程中，并没代码提示以及纠错功能
综上，如果能有一款工具能够集成n个软件的功能，同时又代码提示以及纠错等功能，那么将会极大地提升程序员的开发效率，这就是IDE的由来，IDE全称IntegratedDevelopmentEnvironment，即集成开发环境，最好的开发Python程序的IDE就是PyCharm。6.2、pychram安装
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(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语法入门之基本数据类型一引入变量值也有不同的类型
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="MynameisTony,I'm18yearsold!"#内层有单引号，外层就需要用双引号
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定义
4.2直接引用与间接引用直接引用指的是从栈区出发直接引用到的内存地址。
间接引用指的是从栈区出发引用到堆区后，再通过进一步引用才能到达的内存地址。
如
l2=[20,30]#列表本身被变量名l2直接引用，包含的元素被列表间接引用x=10#值10被变量名x直接引用l1=[x,l2]#列表本身被变量名l1直接引用，包含的元素被列表间接引用img
5.1、引用计数引用计数就是：变量值被变量名关联的次数
如：age=18
变量值18被关联了一个变量名age，称之为引用计数为1
引用计数增加：
age=18（此时，变量值18的引用计数为1）
m=age（把age的内存地址给了m，此时，m,age都关联了18，所以变量值18的引用计数为2）
引用计数减少：
age=10（名字age先与值18解除关联，再与3建立了关联，变量值18的引用计数为1）
delm（del的意思是解除变量名x与变量值18的关联关系，此时，变量18的引用计数为0）
值18的引用计数一旦变为0，其占用的内存地址就应该被解释器的垃圾回收机制回收
5.2、引用计数的问题与解决方案5.2.1问题一：循环引用引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）
l1=['xxx']#列表1被引用一次，列表1的引用计数变为1l2=['yyy']#列表2被引用一次，列表2的引用计数变为1l1.append(l2)#把列表2追加到l1中作为第二个元素，列表2的引用计数变为2l2.append(l1)#把列表1追加到l2中作为第二个元素，列表1的引用计数变为2
l1['xxx',['yyy',[...]]]l2['yyy',['xxx',[...]]]l1[1][1][0]'xxx'img
python引入了“标记-清除”与“分代回收”来分别解决引用计数的循环引用与效率低的问题
5.2.2解决方案：标记-清除容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记-清除”计数就是为了解决循环引用的问题。
标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除
分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：
回收依然是使用引用计数作为回收的依据
虽然分代回收可以起到提升效率的效果，但也存在一定的缺点：
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)
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('yourname:')age=input('yourage:')#用户输入18,会存成字符串18,无法传给%dprint('Mynameis%s,myageis%s'%(name,age))
------------infoofTony-----------Name:TonyAge:22Sex:maleJob:Teacher-------------end-----------------二基本运算符2.1算术运算符python支持的算数运算符与数学上计算的符号使用是一致的，我们以x=9，y=2为例来依次介绍它们
2.2比较运算符比较运算用来对两个值进行比较，返回的是布尔值True或False，我们以x=9，y=2为例来依次介绍它们
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(mostrecentcalllast):File"",line1,inValueError:toomanyvaluestounpack(expected2)
a,b,c,d,e,f=numsTraceback(mostrecentcalllast):File"",line1,inValueError:notenoughvaluestounpack(expected6,got5)但如果我们只想取头尾的几个值，可以用*_匹配
a,b,*_=numsa,b(11,22)ps：字符串、字典、元组、集合类型都支持解压赋值
2.4逻辑运算符逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False
2.4.1连续多个and可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False，只有在所有条件的结果都为True的情况下，最终结果才为True。
2>1and1!=1andTrueand3>2#判断完第二个条件，就立即结束，得的最终结果为FalseFalse2.4.2连续多个or可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False
2>1or1!=1orTrueor3>2#判断完第一个条件，就立即结束，得的最终结果为TrueTrue2.4.3优先级not>and>or
3>4and4>3or1==3and'x'=='x'or3>3False
'''原理为：(1)not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割(2)如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可(3)如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算'''
(3>4and4>3)or(1==3and'x'=='x')or3>3False
10and0or''and0or'abc'or'egon'=='dsb'and333or10>4我们用括号来明确一下优先级(10and0)or(''and0)or'abc'or('egon'=='dsb'and333)or10>4短路：0'''abc'假假真返回：'abc'
1or311and330and2and100and2or110and2or1or410orFalseand1False2.5成员运算符img
注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为notin语义更加明确
not'lili'in['jack','tom','robin']True'lili'notin['jack','tom','robin']True2.6身份运算符img
需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等
x='InfoTony:18'y='InfoTony:18'id(x),id(y)#x与y的id不同，但是二者的值相同(4327422640,4327422256)x==y#等号比较的是valueTruetype(x),type(y)#值相同type肯定相同(
二分支结构2.1什么是分支结构分支结构就是根据条件判断的真假去执行不同分支对应的子代码
2.2为什么要用分支结构人类某些时候需要根据条件来决定做什么事情，比如：如果今天下雨，就带伞
所以程序中必须有相应的机制来控制计算机具备人的这种判断能力
2.3如何使用分支结构2.3.1if语法用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......
#在if判断中所有的数据类型也都会自动转换成布尔类型#2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False#2.2、其余均为True2.3.2if应用案例案例1：
如果：女人的年龄>30岁，那么：叫阿姨
age_of_girl=31ifage_of_girl>30:print('阿姨好')案例2：
如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐
age_of_girl=18ifage_of_girl>30:print('阿姨好')else:print('小姐好')案例3：
如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨**
age_of_girl=18height=171weight=99is_pretty=Trueifage_of_girl>=18andage_of_girl<22andheight>170andweight<100andis_pretty==True:print('表白...')else:print('阿姨好')案例4：
如果：成绩>=90，那么：优秀
如果成绩>=80且<90,那么：良好
如果成绩>=70且<80,那么：普通
其他情况：很差
score=input('>>:')score=int(score)ifscore>=90:print('优秀')elifscore>=80:print('良好')elifscore>=70:print('普通')else:print('很差')案例5：if嵌套
age_of_girl=18height=171weight=99is_pretty=Truesuccess=Falseifage_of_girl>=18andage_of_girl<22andheight>170andweight<100andis_pretty==True:ifsuccess:print('表白成功,在一起')else:print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊...')else:print('阿姨好')练习1:登陆功能
name=input('请输入用户名字：').strip()password=input('请输入密码：').strip()ifname=='tony'andpassword=='123':print('tonyloginsuccess')else:print('用户名或密码错误')练习2：
'''egon-->超级管理员tom-->普通管理员jack,rain-->业务主管其他-->普通用户'''name=input('请输入用户名字：')ifname=='egon':print('超级管理员')elifname=='tom':print('普通管理员')elifname=='jack'orname=='rain':print('业务主管')else:print('普通用户')三循环结构3.1什么是循环结构循环结构就是重复执行某段代码块
3.2为什么要用循环结构人类某些时候需要重复做某件事情
所以程序中必须有相应的机制来控制计算机具备人的这种循环做事的能力
3.3如何使用循环结构3.3.1while循环语法python中有while与for两种循环机制，其中while循环称之为条件循环，语法如下
while条件:代码1代码2代码3while的运行步骤：步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止img
3.3.2while循环应用案例案例一：while循环的基本使用
用户认证程序
username="jason"password="123"inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")else:print("输入的用户名或密码错误！")
username="jason"password="123"
inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")else:print("输入的用户名或密码错误！")
count=0whilecount<3:inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")else:print("输入的用户名或密码错误！")count+=1案例二：while+break的使用
使用了while循环后，代码确实精简多了，但问题是用户输入正确的用户名密码以后无法结束循环，那如何结束掉一个循环呢？这就需要用到break了！
count=0whilecount<3:inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")break#用于结束本层循环else:print("输入的用户名或密码错误！")count+=1案例三：while循环嵌套+break
如果while循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break
username="jason"password="123"count=0whilecount<3:#第一层循环inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")whileTrue:#第二层循环cmd=input('>>:')ifcmd=='quit':break#用于结束本层循环，即第二层循环print('run<%s>'%cmd)break#用于结束本层循环，即第一层循环else:print("输入的用户名或密码错误！")count+=1案例四：while循环嵌套+tag的使用
针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环，其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束
username="jason"password="123"count=0tag=Truewhiletag:inp_name=input("请输入用户名：")inp_pwd=input("请输入密码：")ifinp_name==usernameandinp_pwd==password:print("登陆成功")whiletag:cmd=input('>>:')ifcmd=='quit':tag=False#tag变为False，所有while循环的条件都变为Falsebreakprint('run<%s>'%cmd)break#用于结束本层循环，即第一层循环else:print("输入的用户名或密码错误！")count+=1案例五：while+continue的使用
break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环
number=11whilenumber>1:number-=1ifnumber==7:continue#结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环print(number)案例五：while+else的使用
在while循环的后面，我们可以跟else语句，当while循环正常执行完并且中间没有被break中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束
count=0whilecount<=5:count+=1print("Loop",count)else:print("循环正常执行完啦")print("-----outofwhileloop------")输出Loop1Loop2Loop3Loop4Loop5Loop6循环正常执行完啦#没有被break打断，所以执行了该行代码-----outofwhileloop------如果执行过程中被break，就不会执行else的语句
count=0whilecount<=5:count+=1ifcount==3:breakprint("Loop",count)else:print("循环正常执行完啦")print("-----outofwhileloop------")输出Loop1Loop2-----outofwhileloop------#由于循环被break打断了，所以不执行else后的输出语句练习1：
寻找1到100之间数字7最大的倍数（结果是98）
number=100whilenumber>0:ifnumber%7==0:print(number)breaknumber-=1练习2：
age=18count=0whilecount<3:count+=1guess=int(input(">>:"))ifguess>age:print("猜的太大了，往小里试试...")elifguess for循环语法如下 for变量名in可迭代对象:#此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解可迭代对象代码一代码二... foritemin['a','b','c']:print(item) abc 3.3.4for循环应用案例 forcountinrange(6):#range(6)会产生从0-5这6个数print(count) count=0whilecount<6:print(count)count+=1案例二：遍历字典 forkin{'name':'jason','age':18,'gender':'male'}:#for循环默认取的是字典的key赋值给变量名kprint(k) 案例三：for循环嵌套 foriinrange(3):forjinrange(5):print("*",end='')print()#print()表示换行注意：break与continue也可以用于for循环，使用语法同while循环 练习一： 打印九九乘法表 foriinrange(1,10):forjinrange(1,i+1):print('%s%s=%s'%(i,j,ij),end='')print()练习二： 打印金字塔 ''' *#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=5forcurrent_levelinrange(1,max_level+1):foriinrange(max_level-current_level):print('',end='')#在一行中连续打印多个空格forjinrange(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, 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, 三字符串3.1定义： name1='jason'#本质:name=str('任意形式内容')name2="lili"#本质:name=str("任意形式内容")name3="""ricky"""#本质:name=str("""任意形式内容""")3.2类型转换 type(str([1,2,3]))#list->str str1[6]p str1[-4]h str1[0]='H'#报错TypeError str1[0:9]hellopyt str1[0:9:2]hlopt str1[::-1]#-1表示从右往左依次取值!nohtypolleh len(str1)#空格也算字符13 'hello'instr1True 'tony'notinstr1True str1='lifeisshort!'str1.strip()lifeisshort! str2='tony'str2.strip('*')tony str3='helloworld'str3.split()['hello','world'] str4='127.0.0.1'str4.split('.')['127','0','0','1']#注意:split切割得到的结果是列表数据类型 str5='今天你好吗？'forlineinstr5:#依次取出字符串中每一个字符...print(line)...今天你好吗？3.3.2需要掌握的操作 str1='tony'str1.strip('')#移除左右两边的指定字符'tony'str1.lstrip('')#只移除左边的指定字符tony**str1.rstrip('*')#只移除右边的指定字符**tony str2='MynAmeistonY！'str2.lower()#将英文字符串全部变小写mynameistony！str2.upper()#将英文字符串全部变大写MYNAMEISTONY！ str3='tonyjam' str3.startswith('t')Truestr3.startswith('j')False str3.endswith('jam')Truestr3.endswith('tony')False4.格式化输出之format 之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式 案例： str4='mynameis{name},myageis{age}!'.format(age=18,name='tony')str4'mynameistony,myageis18!'str4='mynameis{name}{name}{name},myageis{name}!'.format(name='tony',age=18)str4'mynameistonytonytony,myageistony!'format的其他使用方式（了解） str4='mynameis{},myageis{}!'.format('tony',18)str4mynameistony,myageis18! str4='mynameis{0},myageis{1}!'.format('tony',18)str4mynameistony,myageis18!str4='mynameis{1},myageis{0}!'.format('tony',18)str4mynameis18,myageistony!str4='mynameis{1},myageis{1}!'.format('tony',18)str4mynameis18,myageis18!5.split,rsplit str5='C:/a/b/c/d.txt'str5.split('/',1)['C:','a/b/c/d.txt'] str5='a|b|c'str5.rsplit('|',1)['a|b','c'] '%'.join('hello')#从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接'h%e%l%l%o''|'.join(['tony','18','read'])#从列表中取出多个字符串，然后按照*作为分隔符号进行拼接'tony|18|read' str7='mynameistony,myageis18!'#将tony的年龄由18岁改成73岁str7=str7.replace('18','73')#语法:replace('旧内容','新内容')str7mynameistony,myageis73! str7='mynameistony,myageis18!'str7=str7.replace('my','MY',1)#只把一个my改为MYstr7'MYnameistony,myageis18!'8.isdigit str8='5201314'str8.isdigit()Truestr8='123g123'str8.isdigit()False3.3.3了解操作 msg='tonysayhello'msg.find('o',1,3)#在索引为1和2(顾头不顾尾)的字符中查找字符o的索引1 msg.index('e',2,4)#报错ValueError msg="helloeveryone"msg.count('e')#统计字符串e出现的次数4msg.count('e',1,6)#字符串e在索引1~5范围内出现的次数1 name='tony'name.center(30,'-')#总宽度为30，字符串居中显示，不够用-填充-------------tony-------------name.ljust(30,'')#总宽度为30，字符串左对齐显示，不够用填充tony**************************name.rjust(30,'')#总宽度为30，字符串右对齐显示，不够用填充**************************tonyname.zfill(50)#总宽度为50，字符串右对齐显示，不够用0填充0000000000000000000000000000000000000000000000tony name='tony\thello'#\t表示制表符(tab键)nametonyhelloname.expandtabs(1)#修改\t制表符代表的空格数tonyhello message='helloeveryonenicetomeetyou!'message.capitalize()Helloeveryonenicetomeetyou! message1='Higirl,Iwantmakefriendswithyou!'message1.swapcase()hIGIRL,iWANTMAKEFRIENDSWITHYOU! msg='dearmyfriendimissyouverymuch'msg.title()DearMyFriendIMissYouVeryMuch num1=b'4'#bytesnum2=u'4'#unicode,python3中无需加u就是unicodenum3='四'#中文数字num4='Ⅳ'#罗马数字 num1.isdigit()Truenum2.isdigit()Truenum3.isdigit()Falsenum4.isdigit()False num2.isdecimal()Truenum3.isdecimal()Falsenum4.isdecimal()False num2.isnumeric()Truenum3.isnumeric()Truenum4.isnumeric()True num5='4.3'num5.isdigit()Falsenum5.isdecimal()Falsenum5.isnumeric()False'''总结:最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景如果要判断中文数字或罗马数字,则需要用到isnumeric。''' name='tony123'name.isalnum()#字符串中既可以包含数字也可以包含字母Truename.isalpha()#字符串中只包含字母Falsename.isidentifier()Truename.islower()#字符串是否是纯小写Truename.isupper()#字符串是否是纯大写Falsename.isspace()#字符串是否全是空格Falsename.istitle()#字符串中的单词首字母是否都是大写False四列表4.1定义 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'inmy_friendsTrue'xxx'notinmy_friendsTrue l1=['a','b','c']l1.append('d')l1['a','b','c','d'] l1.extend(['a','b','c'])l1['a','b','c','d','a','b','c'] l1.insert(0,"first")#0表示按索引位置插值l1['first','a','b','c','alisa','a','b','c'] l=[11,22,33,44]dell[2]#删除索引为2的元素l[11,22,44] l=[11,22,33,22,44]res=l.pop()res44res=l.pop(1)res22 l=[11,22,33,22,44]res=l.remove(22)#从左往右查找第一个括号内需要删除的元素print(res)None l=[11,22,33,44]l.reverse()l[44,33,22,11] 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用来指定是否跌倒排序，默认为Falsel[55,42,22,11,7,3] l1=[1,2,3]l2=[2,]l2>l1True 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'] forlineinmy_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'intuple1True'hhaha'notintuple1False forlineintuple1:...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':['playgame','basketball']...}dic['name']'xxx'dic['hobbies'][1]'basketball' dic['gender']='male'dic dic['name']='tony'dic{'name':'tony','age':18,'hobbies':['playgame','basketball']} len(dic)3 'name'indic#判断某个值是否是字典的keyTrue dic.pop('name')#通过指定字典的key来删除字典的键值对dic{'age':18,'hobbies':['playgame','basketball']} dic= dic.keys()dict_keys(['name','age','hobbies']) dic.values()dict_values(['xxx',18,['playgame','basketball']]) dic.items()dict_items([('name','xxx'),('age',18),('hobbies',['playgame','basketball'])]) forkeyindic:...print(key)...agehobbiesname forkeyindic.keys():...print(key)...agehobbiesname forkeyindic.values():...print(key)...18['playgame','basketball']xxx forkeyindic.items():...print(key)...('age',18)('hobbies',['playgame','basketball'])('name','xxx')6.3.2需要掌握的操作 dic={'k1':'jason','k2':'Tony','k3':'JY'}dic.get('k1')'jason'#key存在，则获取key对应的value值res=dic.get('xxx')#key不存在，不会报错而是默认返回Noneprint(res)Noneres=dic.get('xxx',666)#key不存在时，可以设置默认返回的值print(res)666 dic={'k1':'jason','k2':'Tony','k3':'JY'}v=dic.pop('k2')#删除指定的key对应的键值对,并返回值dic{'k1':'jason','kk2':'JY'}v'Tony' dic={'k1':'jason','k2':'Tony','k3':'JY'}item=dic.popitem()#随机删除一组键值对,并将删除的键值放到元组内返回dic{'k3':'JY','k2':'Tony'}item('k1','jason') dic={'k1':'jason','k2':'Tony','k3':'JY'}dic.update({'k1':'JN','k4':'xxx'})dic dic=dict.fromkeys(['k1','k2','k3'],[])dic dic={'k1':111,'k2':222}res=dic.setdefault('k3',333)res333dic#字典中新增了键值对{'k1':111,'k3':333,'k2':222} dic={'k1':111,'k2':222}res=dic.setdefault('k1',666)res111dic#字典不变{'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}) 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的好友们两个集合的关系如下图所示 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]#去除了重复，但是打乱了顺序 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=[]fordicinl:ifdicnotinnew_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其他操作 s={'a','b','c'}len(s)3 'c'insTrue foritemins:...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 字符串 x="Jy"id(x)938809263920x="Ricky"id(x)938809264088 列表 list1=['tom','jack','egon']id(list1)486316639176list1[2]='kevin'id(list1)486316639176list1.append('lili')id(list1)486316639176 元组 t1=("tom","jack",[1,2])t1[0]='TOM'#报错：TypeErrort1.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)4327423112dic['age']=19dic{'age':19,'sex':'male','name':'egon'}id(dic)4327423112 九数据类型总结img 1、数字类型：2、字符串类型3、列表类型4、元组类型5、字典类型6、集合类型9、字符编码一引入字符串类型、文本文件的内容都是由字符组成的，但凡涉及到字符的存取，都需要考虑字符编码的问题。 2.2文本编辑器读取文件内容的流程 2.3python解释器执行文件的流程以pythontest.py为例，执行流程如下 2.4总结python解释器与文件本编辑的异同如下 python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样 文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法）三、字符编码介绍3.1什么是字符编码？人类在与计算机交互时，用的都是人类能读懂的字符，如中文字符、英文字符、日文字符等 而计算机只能识别二进制数,详解如下 毫无疑问，由人类的字符到计算机中的数字，必须经历一个过程，如下 翻译的过程必须参照一个特定的标准，该标准称之为字符编码表，该表上存放的就是字符与数字一一对应的关系。 字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字 3.2字符编码表的发展史(了解)字符编码的发展经历了三个重要的阶段，如下 3.2.1阶段一：一家独大现代计算机起源于美国，所以最先考虑仅仅是让计算机识别英文字符，于是诞生了ASCII表 1、只有英文字符与数字的一一对应关系2、一个英文字符对应1Bytes，1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符3.2.2阶段二：诸侯割据、天下大乱 3.2.2阶段二：诸侯割据、天下大乱为了让计算机能够识别中文和英文，中国人定制了GBK 1、只有中文字符、英文字符与数字的一一对应关系2、一个英文字符对应1Bytes一个中文字符对应2Bytes补充说明：1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符2Bytes=16bit，16bit最多包含65536个数字，可以对应65536个字符，足够表示所有中文字符每个国家都各自的字符，为让计算机能够识别自己国家的字符外加英文字符，各个国家都制定了自己的字符编码表 1、只有日文字符、英文字符与数字的一一对应关系 1、只有韩文字符、英文字符与数字的一一对应关系此时,美国人用的计算机里使用字符编码标准是ASCII、中国人用的计算机里使用字符编码标准是GBK、日本人用的计算机里使用字符编码标准是Shift_JIS,如下图所示， 字符编码发展到了这个阶段，可以用一句话概括：诸侯割据、天下大乱，详解如下 图1中，文本编辑存取文件的原理如下 文本文件内容全都为字符，无论存取都是涉及到字符编码问题 人类通过文本编辑器输入的字符会被转化成ASCII格式的二进制存放于内存中，如果需要永久保存，则直接将内存中的ASCII格式的二进制写入硬盘 直接将硬盘中的ASCII格式的二进制读入内存，然后通过ASCII表反解成英文字符图2图3都是相同的过程，此时无论是存还是取由于采用的字符编码表一样，所以肯定不会出现乱码问题，但问题是在美国人用的计算机里只能输入英文字符，而在中国人用的计算机里只能输入中文字符和英文字符....,毫无疑问我们希望计算机允许我们输入万国字符均可识别、不乱码，而现阶段计算机采用的字符编码ASCII、GBK、Shift_JIS都无法识别万国字符，所以我们必须定制一个兼容万国字符的编码表，请看阶段三 3.2.3阶段三：分久必合unicode于1990年开始研发，1994年正式公布，具备两大特点： 很多地方或老的系统、应用软件仍会采用各种各样传统的编码，这是历史遗留问题。此处需要强调：软件是存放于硬盘的，而运行软件是要将软件加载到内存的，面对硬盘中存放的各种传统编码的软件，想让我们的计算机能够将它们全都正常运行而不出现乱码，内存中必须有一种兼容万国的编码，并且该编码需要与其他编码有相对应的映射/转换关系，这就是unicode的第二大特点产生的缘由 文本编辑器输入任何字符都是最新存在于内存中，是unicode编码的，存放于硬盘中，则可以转换成任意其他编码，只要该编码可以支持相应的字符 英文字符--->unciode格式的数字--->ASCII格式的数字 中文字符、英文字符--->unicode格式的数字--->gbk格式的数字 日文字符、英文字符--->unicode格式的数字--->shift-JIS格式的数字3.3编码与解码由字符转换成内存中的unicode，以及由unicode转换成其他编码的过程，都称为编码encode 由内存中的unicode转换成字符，以及由其他编码转换成unicode的过程，都称为解码decode 在诸多文件类型中，只有文本文件的内存是由字符组成的，因而文本文件的存取也涉及到字符编码的问题 3.4utf-8的由来注意：如果保存到硬盘的是GBK格式二进制，当初用户输入的字符只能是中文或英文，同理如果保存到硬盘的是Shift_JIS格式二进制，当初用户输入的字符只能是日文或英文……如果我们输入的字符中包含多国字符，那么该如何处理？ 那为何在内存中不直接使用utf-8呢？ utf-8是针对Unicode的可变长度字符编码：一个英文字符占1Bytes，一个中文字符占3Bytes，生僻字用更多的Bytes存储unicode更像是一个过渡版本，我们新开发的软件或文件存入硬盘都采用utf-8格式，等过去几十年，所有老编码的文件都淘汰四字符编码的应用我们学习字符编码就是为了存取字符时不发生乱码问题： 4.1文本编辑器nodpad++存取文本文件文本编辑器存取的都是文本文件，而文本文件中包含的内容全为字符，所以存取文本文件都涉及到字符编码的问题。 4.2python解释器执行文件的前两个阶段执行py文件的前两个阶段就是python解释器读文本文件的过程，与文本编辑读文本文件的前两个阶段没人任何区别，要保证读不乱码，则必须将python解释器读文件时采用的编码方式设置为文件当初写入硬盘时的编码格式，如果没有设置，python解释器则才用默认的编码方式，在python3中默认为utf-8，在python2中默认为ASCII，我们可以通过指定文件头来修改默认的编码 在文件首行写入包含#号在内的以下内容 解释器会先用默认的编码方式读取文件的首行内容，由于首行是纯英文组成，而任何编码方式都可以识别英文字符。 4.3python解释器执行文件的第三个阶段设置文件头的作用是保证运行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中则乱码 C:\Users\Administrator>python2E:\aaa.py涓python2后推出了一种补救措施，就是在字符串类型前加u，则会将字符串类型强制存储unicode，这就与python3保持一致了，对于unicode格式无论丢给任何终端进行打印，都可以直接对应字符不会出现乱码问题 x=u'上'#即便文件头为utf-8，x的值依然存成unicode4.4字符串encode编码与decode解码的使用 x='上'#在python3在'上'被存成unicoderes=x.encode('utf-8')res,type(res)#unicode编码成了utf-8格式，而编码的结果为bytes类型，可以当作直接当作二进制去使用(b'\xe4\xb8\x8a', res.decode('utf-8')'上'10、文件处理应用程序运行过程中产生的数据最先都是存放于内存中的，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。 f=open('a.txt','r',encoding='utf-8')#默认打开模式就为r data=f.read() f.close()2.2资源回收与with上下文管理打开一个文件包含两部分资源：应用程序的变量f和操作系统打开的文件。在操作完毕一个文件时，必须把与该文件的这两部分资源全部回收，回收方法为： 1、f.close()#回收操作系统打开的文件资源2、delf#回收应用程序级的变量其中delf一定要发生在f.close()之后，否则就会导致操作系统打开的文件无法关闭，白白占用资源，而python自动的垃圾回收机制决定了我们无需考虑delf，这就要求我们，在操作完毕文件后，一定要记住f.close()，虽然我们如此强调，但是大多数读者还是会不由自主地忘记f.close()，考虑到这一点，python提供了with关键字来帮我们管理上下文 withopen('a.txt','w')asf:pass withopen('a.txt','r')asread_f,open('b.txt','w')aswrite_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模式的使用 withopen('a.txt',mode='r',encoding='utf-8')asf:res=f.read()#会将文件的内容由硬盘全部读入内存，赋值给res withopen('b.txt',mode='w',encoding='utf-8')asf:f.write('你好\n')f.write('我好\n')f.write('大家好\n')f.write('111\n222\n333\n') 3.1.3案例三：a模式的使用 withopen('c.txt',mode='a',encoding='utf-8')asf:f.write('44444\n')f.write('55555\n') name=input('username>>>:').strip()pwd=input('password>>>:').strip()withopen('db1.txt',mode='a',encoding='utf-8')asf:info='%s:%s\n'%(name,pwd)f.write(info)3.1.4案例四：+模式的使用(了解) 3.2控制文件读写内容的模式大前提:tb模式均不能单独使用,必须与r/w/a之一结合使用t（默认的）：文本模式1.读写文件都是以字符串为单位的2.只能针对文本文件3.必须指定encoding参数b：二进制模式:1.读写文件都是以bytes/二进制为单位的2.可以针对所有文件3.一定不能指定encoding参数3.2.1案例一：t模式的使用 withopen('a.txt',mode='rt',encoding='utf-8')asf:res=f.read()print(type(res))#输出结果为： 3.2.2案例二：b模式的使用 withopen('1.mp4',mode='rb')asf:data=f.read()print(type(data))#输出结果为： 1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便2、针对非文本文件（如图片、视频、音频等）只能使用b模式 src_file=input('源文件路径:').strip()dst_file=input('目标文件路径:').strip()withopen(r'%s'%src_file,mode='rb')asread_f,open(r'%s'%dst_file,mode='wb')aswrite_f:forlineinread_f:#print(line)write_f.write(line)四操作文件的方法4.1重点 f.read()#读取所有内容,执行完该操作后，文件指针会移动到文件末尾f.readline()#读取一行内容,光标移动到第二行首部f.readlines()#读取每一行内容,存放于列表中 withopen('a.txt',mode='rt',encoding='utf-8')asf:forlineinf:print(line)#同一时刻只读入一行内容到内存中 withopen('1.mp4',mode='rb')asf:whileTrue:data=f.read(1024)#同一时刻只读入1024个Bytes到内存中iflen(data)==0:breakprint(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五主动控制文件内指针移动 withopen('a.txt',mode='rt',encoding='utf-8')asf:data=f.read(3)#读取3个字符withopen('a.txt',mode='rb')asf:data=f.read(3)#读取3个Bytes 5.1案例一：0模式详解 abc你好 withopen('a.txt',mode='rt',encoding='utf-8')asf:f.seek(3,0)#参照文件开头移动了3个字节print(f.tell())#查看当前文件指针距离文件开头的位置，输出结果为3print(f.read())#从第3个字节的位置读到文件末尾，输出结果为：你好#注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败withopen('a.txt',mode='rb')asf:f.seek(6,0)print(f.read().decode('utf-8'))#输出结果为:好5.2案例二：1模式详解 withopen('a.txt',mode='rb')asf:f.seek(3,1)#从当前位置往后移动3个字节，而此时的当前位置就是文件开头print(f.tell())#输出结果为：3f.seek(4,1)#从当前位置往后移动4个字节，而此时的当前位置为3print(f.tell())#输出结果为：75.3案例三：2模式详解 withopen('a.txt',mode='rb')asf:f.seek(0,2)#参照文件末尾移动0个字节，即直接跳到文件末尾print(f.tell())#输出结果为：9f.seek(-3,2)#参照文件末尾往前移动了3个字节print(f.read().decode('utf-8'))#输出结果为：好 importtimewithopen('access.log',mode='rb')asf:f.seek(0,2)whileTrue:line=f.readline()iflen(line)==0:#没有内容time.sleep(0.5)else:print(line.decode('utf-8'),end='')六文件的修改 张一蛋山东1794912344234523李二蛋河北1635713913453521王全蛋山西1536218651433422 withopen('a.txt',mode='r+t',encoding='utf-8')asf:f.seek(9)f.write('<妇女主任>') 张一蛋<妇女主任>1794912344234523李二蛋河北1635713913453521王全蛋山西1536218651433422 文件对应的是硬盘空间,硬盘不能修改对应着文件本质也不能修改,那我们看到文件的内容可以修改,是如何实现的呢大致的思路是将硬盘中文件内容读入内存,然后在内存中修改完毕后再覆盖回硬盘具体的实现方式分为两种: 6.1文件修改方式一 withopen('db.txt',mode='rt',encoding='utf-8')asf:data=f.read()withopen('db.txt',mode='wt',encoding='utf-8')asf:f.write(data.replace('kevin','SB'))6.1文件修改方式二 importoswithopen('db.txt',mode='rt',encoding='utf-8')asread_f,open('.db.txt.swap',mode='wt',encoding='utf-8')aswrife_f:forlineinread_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是可有可无的。 参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数， defmy_min(x,y):res=xifx definteractive():user=input('user>>:').strip()pwd=input('password>>:').strip()return(user,pwd)函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。例如要编写一个ftp程序，我们可能想到的功能有用户认证，下载，上传，浏览，切换目录等功能，可以先做出如下定义： defauth_user():"""userauthenticationfunction"""passdefdownload_file():"""downloadfilefunction"""passdefupload_file():"""uploadfilefunction"""passdefls():"""listcontentsfunction"""passdefcd():"""changedirectory"""pass之后我们便可以统筹安排编程任务，有选择性的去实现上述功能来替换掉pass，从而提高开发效率。 三调用函数与函数返回值函数的使用分为定义阶段与调用阶段，定义函数时只检测语法，不执行函数体代码，函数名加括号即函数调用，只有调用函数时才会执行函数体代码 deffoo():print('inthefoo')bar()defbar():print('inthebar') foo()执行结果： inthefoointhebar定义阶段函数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的返回值无类型限制，且可以将多个返回值放到一个元组内。 deftest(x,y,z):...returnx,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位置参数位置即顺序，位置参数指的是按顺序定义的参数，需要从两个角度去看： 在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值 defregister(name,age,sex):#定义位置形参：name，age，sex，三者都必须被传值print('Name:%sAge:%sSex:%s'%(name,age,sex))register()#TypeError：缺少3个位置参数在调用函数时，按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应 defregister(name,age,sex):#定义位置形参：name，age，sex，三者都必须被传值print('Name:%sAge:%sSex:%s'%(name,age,sex))register()#TypeError：缺少3个位置参数2.2关键字参数在调用函数时，实参可以是key=value的形式，称为关键字参数，凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值 register(sex='male',name='lili',age=18)Name:liliAge:18Sex: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定义成默认参数 defregister(name,age,sex='male'):#默认sex的值为male...print('Name:%sAge:%sSex:%s'%(name,age,sex))...定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度 register('tom',17)#大多数情况,无需为sex传值,默认为maleName:tomAge:17Sex:maleregister('Lili',18,'female')#少数情况,可以为sex传值femaleName:LiliAge:18Sex:female需要注意： 默认参数必须在位置参数之后 默认参数的值仅在函数定义阶段被赋值一次 x=1deffoo(arg=x):...print(arg)...x=5#定义阶段arg已被赋值为1，此处的修改与默认参数arg无任何关系foo()1默认参数的值通常应设为不可变类型 deffoo(n,arg=[]):arg.append(n)returnargfoo(1)[1]foo(2)[1,2]foo(3)[1,2,3]每次调用是在上一次的基础上向同一列表增加值，修改如下 deffoo(n,arg=None):ifargisNone:arg=[]arg.append(n)returnargfoo(1)[1]foo(2)[2]foo(3)[3]2.4可变长度的参数（*与**的用法）参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数 2.4.1可变长度的位置参数如果在最后一个形参名前加号,那么在调用函数时，溢出的位置实参，都会被接收，以元组的形式保存下来赋值给该形参 deffoo(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的 deffoo(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],)如果形参为常规的参数（位置或默认），实参仍可以是*的形式 deffoo(x,y,z=3):...print(x)...print(y)...print(z)...foo([1,2])#等同于foo(1,2)123如果我们想要求多个值的和，args就派上用场了 defadd(*args):...res=0...foriinargs:...res+=i...returnres...add(1,2,3,4,5)152.4.2可变长度的关键字参数如果在最后一个形参名前加号,那么在调用函数时，溢出的关键字参数，都会被接收，以字典的形式保存下来赋值给该形参 deffoo(x,kwargs):#在最后一个参数kwargs前加...print(x)...print(kwargs)...foo(y=2,x=1,z=3)#溢出的关键字实参y=2，z=3都被接收，以字典的形式保存下来，赋值给kwargs1{'z':3,'y':2}如果我们事先生成了一个字典,仍然是可以传值给kwargs的 deffoo(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个如果形参为常规参数（位置或默认），实参仍可以是**的形式 deffoo(x,y,z=3):...print(x)...print(y)...print(z)...foo({'x':1,'y':2})#等同于foo(y=2,x=1)123如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用kwargs为日后的扩展供良好的环境，同时保持了函数的简洁性。 defauth(user,password,kwargs):...pass...2.5命名关键字参数在定义了kwargs参数后，函数调用者就可以传入任意的关键字参数key=value，如果函数体代码的执行需要依赖某个key，必须在函数内进行判断 defregister(name,age,**kwargs):...if'sex'inkwargs:...#有sex参数...pass...if'height'inkwargs:...#有height参数...pass...想要限定函数的调用者必须以key=value的形式传值，Python3提供了专门的语法：需要在定义形参时，用作为一个分隔符号，号之后的形参称为命名关键字参数。对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值 defregister(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传值。命名关键字参数也可以有默认值，从而简化调用 defregister(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了，命名关键字参数就不再需要一个单独的作为分隔符号了 defregister(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，那么代表该函数可以接收任何形式、任意长度的参数 defwrapper(*args,**kwargs):...pass...在该函数内部还可以把接收到的参数传给另外一个函数（这在4.6小节装饰器的实现中大有用处） deffunc(x,y,z):...print(x,y,z)...defwrapper(args,**kwargs):...func(args,**kwargs)...wrapper(1,z=3,y=2)123按照上述写法，在为函数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的绑定关系存放于名称空间中，delx表示清除该绑定关系。 在程序执行期间最多会存在三种名称空间 1.1内建名称空间伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些内置的名字，比如内建函数名 max#built-in内建1.2全局名称空间伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中，如下名字 importsys#模块名sysx=1#变量名xifx==1:y=2#变量名ydeffoo(x):#函数名fooy=1defbar():passClassBar:#类名Barpass1.3局部名称空间伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中 deffoo(x):y=3#调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部名称空间中名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间。 二作用域2.1全局作用域与局部作用域按照名字作用范围的不同可以将三个名称空间划分为两个区域： 全局作用域:位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）； 局部作用域:位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）。 2.2作用域与名字查找的优先级在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常 x=100#全局作用域的名字xdeffoo():x=300#局部作用域的名字xprint(x)#在局部找xfoo()#结果为300在全局作用域查找名字时，起始位置便是全局作用域，所以先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常 x=100deffoo():x=300#在函数调用时产生局部作用域的名字xfoo()print(x)#在全局找x,结果为100提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals() Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域 x=1defouter():x=2definner():#函数名inner属于outer这一层作用域的名字x=3print('innerx:%s'%x)inner()print('outerx:%s'%x)outer() innerx:3outerx:2在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字 num_list=[1,2,3]deffoo(nums):nums.append(5)foo(num_list)print(num_list) deff1():x=2deff2():nonlocalxx=3f2()#调用f2(),修改f1作用域中名字x的值print(x)#在f1作用域查看xf1() 3nonlocalx会从当前函数的外层函数开始一层层去查找名字x，若是一直到最外层函数都找不到，则会抛出异常。 14、函数对象和闭包一函数对象函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用，我们如下 1.1函数可以被引用 x=1deff1():deff2():print(x)returnf2deff3():x=3f2=f1()#调用f1()返回函数f2f2()#需要按照函数定义时的作用关系去执行，与调用位置无关f3()#结果为1也就是说函数被当做数据处理时，始终以自带的作用域为准。若内嵌函数包含对外部函数作用域（而非全局作用域）中变量的引用，那么该’内嵌函数’就是闭包函数，简称闭包(Closures) x=1defouter():x=2definner():print(x)returninnerfunc=outer()func()#结果为2可以通过函数的closure属性，查看到闭包函数所包裹的外部变量 func.closure( 2.2闭包的用途目前为止，我们得到了两种为函数体传值的方式，一种是直接将值以参数的形式传入，另外一种就是将值包给函数 importrequests defget(url):returnrequests.get(url).text defpage(url):defget():returnrequests.get(url).textreturnget提示：requests模块是用来模拟浏览器向网站发送请求并将页面内容下载到本地，需要事先安装：pip3installrequests 对比两种方式，方式一在下载同一页面时需要重复传入url，而方式二只需要传一次值，就会得到一个包含指定url的闭包函数，以后调用该闭包函数无需再传url 15、装饰器一装饰器介绍1.1为何要用装饰器软件的设计应该遵循开放封闭原则，即对扩展是开放的，而对修改是封闭的。对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。对修改封闭，意味着对象一旦设计完成，就可以独立完成其工作，而不要对其进行修改。 软件包含的所有功能的源代码以及调用方式，都应该避免修改，否则一旦改错，则极有可能产生连锁反应，最终导致程序崩溃，而对于上线后的软件，新需求或者变化又层出不穷，我们必须为程序提供扩展的可能性，这就用到了装饰器。 1.2什么是装饰器’装饰’代指为被装饰对象添加新的功能，’器’代指器具/工具，装饰器与被装饰的对象均可以是任意可调用对象。概括地讲，装饰器的作用就是在不修改被装饰对象源代码和调用方式的前提下为被装饰对象添加额外的功能。装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景，装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。 提示：可调用对象有函数，方法或者类，此处我们单以本章主题函数为例，来介绍函数装饰器，并且被装饰的对象也是函数。 二装饰器的实现函数装饰器分为：无参装饰器和有参装饰两种，二者的实现原理一样，都是’函数嵌套+闭包+函数对象’的组合使用的产物。 importtimedefindex():time.sleep(3)print('Welcometotheindexpage’)return200index()#函数执行遵循不修改被装饰对象源代码的原则，我们想到的解决方法可能是这样 defwrapper(func):#通过参数接收外部的值start_time=time.time()res=func()stop_time=time.time()print('runtimeis%s'%(stop_time-start_time))returnres但之后函数的调用方式都需要统一改成 wrapper(index)wrapper(其他函数)这便违反了不能修改被装饰对象调用方式的原则，于是我们换一种为函数体传值的方式，即将值包给函数，如下 index=timer(index)#得到index=wrapper，wrapper携带对外作用域的引用：func=原始的indexindex()#执行的是wrapper()，在wrapper的函数体内再执行最原始的index至此我们便实现了一个无参装饰器timer，可以在不修改被装饰对象index源代码和调用方式的前提下为其加上新功能。但我们忽略了若被装饰的函数是一个有参函数，便会抛出异常 defhome(name):time.sleep(5)print('Welcometothehomepage',name)home=timer(home)home('egon') TypeError:wrapper()takes0positionalargumentsbut1wasgiven之所以会抛出异常，是因为home(‘egon’)调用的其实是wrapper(‘egon’)，而函数wrapper没有参数。wrapper函数接收的参数其实是给最原始的func用的，为了能满足被装饰函数参数的所有情况，便用上*args+**kwargs组合（见4.3小节）,于是修正装饰器timer如下 deftimer(func):defwrapper(args,**kwargs):start_time=time.time()res=func(args,**kwargs)stop_time=time.time()print('runtimeis%s'%(stop_time-start_time))returnresreturnwrapper此时我们就可以用timer来装饰带参数或不带参数的函数了，但是为了简洁而优雅地使用装饰器，Python提供了专门的装饰器语法来取代index=timer(index)的形式，需要在被装饰对象的正上方单独一行添加@timer,当解释器解释到@timer时就会调用timer函数，且把它正下方的函数名当做实参传入，然后将返回的结果重新赋值给原函数名 @timer#index=timer(index)defindex():time.sleep(3)print('Welcometotheindexpage')return200@timer#index=timer(home)defhome(name):time.sleep(5)print('Welcometothehomepage’,name)如果我们有多个装饰器，可以叠加多个 @deco3@deco2@deco1defindex():pass叠加多个装饰器也无特殊之处，上述代码语义如下： index=deco3(deco2(deco1(index)))2.2有参装饰器的实现了解无参装饰器的实现原理后，我们可以再实现一个用来为被装饰对象添加认证功能的装饰器，实现的基本形式如下 defdeco(func):defwrapper(args,**kwargs):编写基于文件的认证,认证通过则执行res=func(args,**kwargs),并返回resreturnwrapper如果我们想提供多种不同的认证方式以供选择，单从wrapper函数的实现角度改写如下 defdeco(func):defwrapper(args,**kwargs):ifdriver=='file':编写基于文件的认证,认证通过则执行res=func(args,kwargs),并返回reselifdriver=='mysql':编写基于mysql认证,认证通过则执行res=func(*args,kwargs),并返回resreturnwrapper函数wrapper需要一个driver参数，而函数deco与wrapper的参数都有其特定的功能，不能用来接受其他类别的参数，可以在deco的外部再包一层函数auth，用来专门接受额外的参数，这样便保证了在auth函数内无论多少层都可以引用到 defauth(driver):defdeco(func):……returndeco此时我们就实现了一个有参装饰器，使用方式如下 先调用auth_type(driver='file')，得到@deco，deco是一个闭包函数，包含了对外部作用域名字driver的引用，@deco的语法意义与无参装饰器一样@auth(driver='file')defindex():pass@auth(driver='mysql')defhome():pass可以使用help(函数名)来查看函数的文档注释，本质就是查看函数的doc属性，但对于被装饰之后的函数，查看文档注释 @timerdefhome(name):'''homepagefunction:paramname:str:return:None'''time.sleep(5)print('Welcometothehomepage',name)print(help(home))'''打印结果：Helponfunctionwrapperinmodulemain:wrapper(*args,**kwargs)None在被装饰之后home=wrapper,查看home.name也可以发现home的函数名确实是wrapper，想要保留原函数的文档和函数名属性，需要修正装饰器 deftimer(func):defwrapper(args,**kwargs):start_time=time.time()res=func(args,**kwargs)stop_time=time.time()print('runtimeis%s'%(stop_time-start_time))returnreswrapper.doc=func.docwrapper.name=func.namereturnwrapper按照上述方式来实现保留原函数属性过于麻烦，functools模块下提供一个装饰器wraps专门用来帮我们实现这件事，用法如下 fromfunctoolsimportwrapsdeftimer(func):@wraps(func)defwrapper(args,**kwargs):start_time=time.time()res=func(args,kwargs)stop_time=time.time()print('runtimeis%s'%(stop_time-start_time))returnresreturnwrapper标准版装饰器：defwrapper(func):definner(*args,kwargs):"""执行被装饰函数前的操作"""func(*args,**kwargs)"""执行被装饰函数后的操作"""returninner@wrapperdefindex():print("isindex")index()语法糖要接受的变量就是语法糖下面的函数名、参数就是语法糖下面的函数名、调用的方式就是看调用的哪个语法糖deffunc(args):print("新加了一个功能")returnargs@func#index=func(index)defindex():print(2)index()结果：新加了一个功能16、迭代器一迭代器介绍迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代 whileTrue:msg=input('>>:').strip()print(msg)下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值 goods=['mac','lenovo','acer','dell','sony']index=0whileindex 要想了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象(Iterable)。从语法形式上讲，内置有iter方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象： {'name':'egon'}.iter{7,8,9}.iter……1.2迭代器对象调用obj.iter()方法返回的结果就是一个迭代器对象(Iterator)。迭代器对象是内置有iter和next方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象.iter()方法得到的仍然是迭代器本身，而执行迭代器.next()方法就会计算出迭代器中的下一个值。迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值 s={1,2,3}#可迭代对象si=iter(s)#本质就是在调用s.iter(),返回s的迭代器对象i，next(i)#本质就是在调用i.next()1next(i)2next(i)3next(i)#抛出StopIteration的异常，代表无值可取，迭代结束二for循环原理有了迭代器后，我们便可以不依赖索引迭代取值了，使用while循环的实现方式如下 goods=['mac','lenovo','acer','dell','sony']i=iter(goods)#每次都需要重新获取一个迭代器对象whileTrue:try:print(next(i))exceptStopIteration:#捕捉异常终止循环breakfor循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可以简写为 goods=['mac','lenovo','acer','dell','sony']foritemingoods:print(item)for循环在工作时，首先会调用可迭代对象goods内置的iter方法拿到一个迭代器对象，然后再调用该迭代器对象的next方法将取到的值赋给item,执行循环体完成一次循环，周而复始，直到捕捉StopIteration异常，结束迭代。 三迭代器的优缺点基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存： 3.1优点：1、为序列和非序列类型提供了一种统一的迭代取值方式。 2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。 3.2缺点：1、除非取尽，否则无法获取迭代器的长度 2、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。 17、生成器一生成器与yield若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象 defmy_range(start,stop,step=1):...print('start...')...whilestart g.iter next(g)#触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数start...0next(g)#再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...1next(g)#周而复始...2next(g)#触发函数执行没有遇到yield则无值返回，即取值完毕抛出异常结束迭代end...Traceback(mostrecentcalllast):File"",line1,inStopIteration既然生成器对象属于迭代器，那么必然可以使用for循环迭代，如下： foriincountdown(3):...print(i)...countdownstart321Done!有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值 二yield表达式应用在函数内可以采用表达式形式的yield defeater():...print('Readytoeat')...whileTrue:...food=yield...print('getthefood:%s,andstarttoeat'%food)...可以拿到函数的生成器对象持续为函数体send值，如下 g=eater()#得到生成器对象g 我们可以编写装饰器来完成为所有表达式形式yield对应生成器的初始化操作，如下 definit(func):defwrapper(args,**kwargs):g=func(args,**kwargs)next(g)returngreturnwrapper@initdefeater():print('Readytoeat')whileTrue:food=yieldprint('getthefood:%s,andstarttoeat'%food)表达式形式的yield也可以用于返回多次值，即变量名=yield值的形式，如下 defeater():...print('Readytoeat')...food_list=[]...whileTrue:...food=yieldfood_list...food_list.append(food)...e=eater()next(e)Readytoeat[]e.send('蒸羊羔')['蒸羊羔']e.send('蒸熊掌')['蒸羊羔','蒸熊掌']e.send('蒸鹿尾儿')['蒸羊羔','蒸熊掌','蒸鹿尾儿']三三元表达式、列表生成式、生成器表达式3.1三元表达式三元表达式是python为我们提供的一种简化代码的解决方案，语法如下 res=条件成立时返回的值if条件else条件不成立时返回的值针对下述场景 defmax2(x,y):ifx>y:returnxelse:returnyres=max2(1,2)用三元表达式可以一行解决 x=1y=2res=xifx>yelsey#三元表达式3.2列表生成式列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表，语法如下 [expressionforitem1initerable1ifcondition1foritem2initerable2ifcondition2...foritemNiniterableNifconditionN] res=[]foritem1initerable1:ifcondition1:foritem2initerable2:ifcondition2...foritemNiniterableN:ifconditionN:res.append(expression)针对下述场景 egg_list=[]foriinrange(10):egg_list.append('鸡蛋%s'%i)用列表生成式可以一行解决 egg_list=['鸡蛋%s'%iforiinrange(10)]3.3生成器表达式创建一个生成器对象有两种方式，一种是调用带yield关键字的函数，另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()，即： （expressionforiteminiterableifcondition）对比列表生成式返回的是一个列表，生成器表达式返回的是一个生成器对象 [xxforxinrange(3)][0,1,4]g=(xxforxinrange(3))g next(g)0next(g)1next(g)4next(g)#抛出异常StopIteration如果我们要读取一个大文件的字节数，应该基于生成器表达式的方式完成 withopen('db.txt','rb')asf:nums=(len(line)forlineinf)total_size=sum(nums)#依次执行next(nums)，然后累加到一起得到结果=18、函数递归一函数递归调用介绍函数不仅可以嵌套定义，还可以嵌套调用，即在调用一个函数的过程中，函数内部又调用另一个函数，而函数的递归调用指的是在调用一个函数的过程中又直接或间接地调用该函数本身 例如 在调用f1的过程中，又调用f1，这就是直接调用函数f1本身 deff1():print('fromf1')f1()f1()在调用f1的过程中，又调用f2，而在调用f2的过程中又调用f1，这就是间接调用函数f1本身 deff1():print('fromf1')f2()deff2():print('fromf2')f1()f1()从上图可以看出，两种情况下的递归调用都是一个无限循环的过程，但在python对函数的递归调用的深度做了限制，因而并不会像大家所想的那样进入无限循环，会抛出异常，要避免出现这种情况，就必须让递归调用在满足某个特定条件下终止。 提示： sys.setrecursionlimit()去设定该值，但仍受限于主机操作系统栈大小的限制 二回溯与递推defsalary(n):ifn==1:return5000returnsalary(n-1)+1000s=salary(4)print(s)19、面向过程与函数式一编程范式面向过程、函数式、面向对象 二面向过程importos,time defdata_backup(folder):print("找到备份目录:%s"%folder)print('正在备份...')zip_file='/tmp/backup_%s.zip'%time.strftime('%Y%m%d')print('备份成功，备份文件为:%s'%zip_file)returnzip_file defdata_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举例 lambdax,y,z:x+y+z deffunc(x,y,z):returnx+y+z res=(lambdax,y,z:x+y+z)(1,2,3) func=lambdax,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=lambdak:salaries[k])'lili' min(salaries,key=lambdak:salaries[k])'jack'同理，我们直接对字典进行排序，默认也是按照字典的键去排序的 sorted(salaries)['jack','lili','siry','tom']3.2map、reduce、filter函数map、reduce、filter都支持迭代器协议，用来处理可迭代对象，我们以一个可迭代对象array为例来介绍它们三个的用法 array=[1,2,3,4,5]要求一：对array的每个元素做平方处理，可以使用map函数 map函数可以接收两个参数，一个是函数，另外一个是可迭代对象，具体用法如下 res=map(lambdax:x**2,array)res 解析：map会依次迭代array，得到的值依次传给匿名函数（也可以是有名函数），而map函数得到的结果仍然是迭代器。 list(res)#使用list可以依次迭代res，取得的值作为列表元素[1,4,9,16,25]要求二：对array进行合并操作，比如求和运算，这就用到了reduce函数 reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值 fromfunctoolsimportreduceres=reduce(lambdax,y:x+y,array)res15解析： 1没有初始值，reduce函数会先迭代一次array得到的值作为初始值，作为第一个值数传给x，然后继续迭代一次array得到的值作为第二个值传给y，运算的结果为3 2将上一次reduce运算的结果作为第一个值传给x，然后迭代一次array得到的结果作为第二个值传给y，依次类推，知道迭代完array的所有元素，得到最终的结果15 也可以为reduce指定初始值 res=reduce(lambdax,y:x+y,array,100)>>>res115要求三：对array进行过滤操作，这就用到了filter函数，比如过滤出大于3的元素 res=filter(lambdax:x>3,array)解析：filter函数会依次迭代array，得到的值依次传给匿名函数，如果匿名函数的返回值为真，则过滤出该元素，而filter函数得到的结果仍然是迭代器。 list(res)[4,5]提示：我们介绍map、filter、reduce只是为了带大家了解函数式编程的大致思想，在实际开发中，我们完全可以用列表生成式或者生成器表达式来实现三者的功能。 20、模块一模块介绍在Python中，一个py文件就是一个模块，文件名为xxx.py模块名则是xxx,导入模块可以引用模块中已经写好的功能。如果把开发程序比喻成制造一台电脑，编写模块就像是在制造电脑的零部件，准备好零部件后，剩下的工作就是按照逻辑把它们组装到一起。 将程序模块化会使得程序的组织结构清晰，维护起来更加方便。比起直接开发一个完整的程序，单独开发一个小的模块也会更加简单，并且程序中的模块与电脑中的零部件稍微不同的是：程序中的模块可以被重复使用。所以总结下来，使用模块既保证了代码的重用性，又增强了程序的结构性和可维护性。另外除了自定义模块外，我们还可以导入使用内置或第三方模块提供的现成功能，这种“拿来主义”极大地提高了程序员的开发效率。 二模块的使用2.1import语句有如下示范文件 x=1defget():print(x)defchange():globalxx=0classFoo:deffunc(self):print('fromthefunc')要想在另外一个py文件中引用foo.py中的功能，需要使用importfoo，首次导入模块会做三件事： 1、执行源文件代码 2、产生一个新的名称空间用于存放源文件执行过程中产生的名字 3、在当前执行文件所在的名称空间中得到一个名字foo，该名字指向新创建的模块名称空间，若要引用模块名称空间中的名字，需要加上该前缀，如下 importfoo#导入模块fooa=foo.x#引用模块foo中变量x的值赋值给当前名称空间中的名字afoo.get()#调用模块foo的get函数foo.change()#调用模块foo中的change函数obj=foo.Foo()#使用模块foo的类Foo来实例化，进一步可以执行obj.func()加上foo.作为前缀就相当于指名道姓地说明要引用foo名称空间中的名字，所以肯定不会与当前执行文件所在名称空间中的名字相冲突，并且若当前执行文件的名称空间中存在x，执行foo.get()或foo.change()操作的都是源文件中的全局变量x。 需要强调一点是，第一次导入模块已经将其加载到内存空间了，之后的重复导入会直接引用内存中已存在的模块，不会重复执行文件，通过importsys，打印sys.modules的值可以看到内存中已经加载的模块名。 用import语句导入多个模块，可以写多行import语句 importmodule1importmodule2...importmoduleN还可以在一行导入，用逗号分隔开不同的模块 importmodule1,module2,...,moduleN但其实第一种形式更为规范，可读性更强，推荐使用，而且我们导入的模块中可能包含有python内置的模块、第三方的模块、自定义的模块，为了便于明显地区分它们，我们通常在文件的开头导入模块，并且分类导入，一类模块的导入与另外一类的导入用空行隔开，不同类别的导入顺序如下： 当然，我们也可以在函数内导入模块，对比在文件开头导入模块属于全局作用域，在函数内导入的模块则属于局部的作用域。 2.2from-import语句from...import...与import语句基本一致，唯一不同的是：使用importfoo导入模块后，引用模块中的名字都需要加上foo.作为前缀，而使用fromfooimportx,get,change,Foo则可以在当前执行文件中直接引用模块foo中的名字，如下 fromfooimportx,get,change#将模块foo中的x和get导入到当前名称空间a=x#直接使用模块foo中的x赋值给aget()#直接执行foo中的get函数change()#即便是当前有重名的x，修改的仍然是源文件中的x无需加前缀的好处是使得我们的代码更加简洁，坏处则是容易与当前名称空间中的名字冲突，如果当前名称空间存在相同的名字，则后定义的名字会覆盖之前定义的名字。 另外from语句支持fromfooimport语法，代表将foo中所有的名字都导入到当前位置 fromfooimport*#把foo中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字a=xget()change()obj=Foo()如果我们需要引用模块中的名字过多的话，可以采用上述的导入形式来达到节省代码量的效果，但是需要强调的一点是：只能在模块最顶层使用的方式导入，在函数内则非法，并且的方式会带来一种副作用，即我们无法搞清楚究竟从源文件中导入了哪些名字到当前位置，这极有可能与当前位置的名字产生冲突。模块的编写者可以在自己的文件中定义all变量用来控制*代表的意思 all=['x','get']#该列表中所有的元素必须是字符串类型，每个元素对应foo.py中的一个名字x=1defget():print(x)defchange():globalxx=0classFoo:deffunc(self):print('fromthefunc')这样我们在另外一个文件中使用*导入时，就只能导入all定义的名字了 fromfooimport*#此时的*只代表x和getx#可用get()#可用change()#不可用Foo()#不可用2.3其他导入语法(as)我们还可以在当前位置为导入的模块起一个别名 importfooasf#为导入的模块foo在当前位置起别名f，以后再使用时就用这个别名ff.xf.get()还可以为导入的一个名字起别名 fromfooimportgetasget_xget_x()通常在被导入的名字过长时采用起别名的方式来精简代码，另外为被导入的名字起别名可以很好地避免与当前名字发生冲突，还有很重要的一点就是：可以保持调用方式的一致性，例如我们有两个模块json和pickle同时实现了load方法，作用是从一个打开的文件中解析出结构化的数据，但解析的格式不同，可以用下述代码有选择性地加载不同的模块 ifdata_format=='json':importjsonasserialize#如果数据格式是json，那么导入json模块并命名为serializeelifdata_format=='pickle':importpickleasserialize#如果数据格式是pickle，那么导入pickle模块并命名为serializedata=serialize.load(fn)#最终调用的方式是一致的2.4循环导入问题循环导入问题指的是在一个模块加载/导入的过程中导入另外一个模块，而在另外一个模块中又返回来导入第一个模块中的名字，由于第一个模块尚未加载完毕，所以引用失败、抛出异常，究其根源就是在python中，同一个模块只会在第一次导入时执行其内部代码，再次导入该模块时，即便是该模块尚未完全加载完毕也不会去重复执行内部代码 我们以下述文件为例，来详细分析循环/嵌套导入出现异常的原因以及解决的方案 m1.py print('正在导入m1')fromm2importyx='m1'm2.py print('正在导入m2')fromm1importxy='m2'run.py importm1测试一 正在导入m1正在导入m2Traceback(mostrecentcalllast):File"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/aa.py",line1,inimportm1File"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/m1.py",line2,infromm2importyFile"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/m2.py",line2,infromm1importxImportError:cannotimportname'x' 先执行run.py--->执行importm1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"--->执行fromm2importy开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行fromm1importx,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错测试二 直接执行m1.py抛出异常正在导入m1正在导入m2正在导入m1Traceback(mostrecentcalllast):File"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/m1.py",line2,infromm2importyFile"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/m2.py",line2,infromm1importxFile"/Users/linhaifeng/PycharmProjects/pro01/1aaaa练习目录/m1.py",line2,infromm2importyImportError:cannotimportname'y' 执行m1.py，打印“正在导入m1”，执行fromm2importy，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行fromm1importx，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行fromm1importy，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错解决方案 print('正在导入m1')x='m1'fromm2importy print('正在导入m2')y='m2'fromm1importx importm1print(m1.x)print(m1.y) print('正在导入m1')deff1():fromm2importyprint(x,y)x='m1' print('正在导入m2')deff2():fromm1importxprint(x,y)y='m2' importm1m1.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/ importsyssys.path.append(r'/pythoner/projects/')#也可以使用sys.path.insert(……)importfoo#无论foo.py在何处,我们都可以导入它了2.6区分py文件的两种用途一个Python文件有两种用途，一种被当主程序/脚本执行，另一种被当模块导入，为了区别同一个文件的不同用途，每个py文件都内置了name变量，该变量在py文件被当做脚本执行时赋值为“main”,在py文件被当做模块导入时赋值为模块名 作为模块foo.py的开发者，可以在文件末尾基于name在不同应用场景下值的不同来控制文件执行不同的逻辑 ...ifname=='main':foo.py被当做脚本执行时运行的代码else:foo.py被当做模块导入时运行的代码通常我们会在if的子代码块中编写针对模块功能的测试代码，这样foo.py在被当做脚本运行时，就会执行测试代码，而被当做模块导入时则不用执行测试代码。 2.7编写一个规范的模块我们在编写py文件时，需要时刻提醒自己，该文件既是给自己用的，也有可能会被其他人使用，因而代码的可读性与易维护性显得十分重要，为此我们在编写一个模块时最好按照统一的规范去编写，如下 "Themoduleisusedto..."#模块的文档描述importsys#导入模块x=1#定义全局变量,如果非必须,则最好使用局部变量,这样可以提高代码的易维护性,并且可以节省内存提高性能classFoo:#定义类,并写好类的注释'ClassFooisusedto...'passdeftest():#定义函数,并写好函数的注释'Functiontestisusedto…'passifname=='main':#主程序test()#在被当做脚本执行时,执行此处的代码