Python语言编程基础(上)

Python语言编程基础

张瑞内容目录1.Python简介2.Python基本语法3.函数和函数式编程4.类和面向对象编程Python简介Python2和3Python安装编译器1.Python简介1.Python简介-起源是一种面向对象的解释型计算机程序设计语言，由荷兰人GuidovanRossum于1989年发明，第一个公开发行版发行于1991年。（来自百度百科1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧MontyPython'sFlyingCircus1.Python简介-语言类型Python是一种解释型、可移植、开源的脚本编程语言编译型语言：在程序执行之前，有一个单独的编译过程，将程序翻译成机器语言，以后执行这个程序的时候，就不用再进行翻译了。例如C、C++解释型语言：在运行的时候将程序翻译成机器语言，所以运行速度相对于编译型语言要慢；例如Perl、Python、MATLAB等；源代码编译目标代码执行输出源代码解释器输出1.Python简介-特点特点高级：高级语言（开发效率高）面向对象可升级可扩展可移植1.Python简介-特点优点（1）易读：Python语句比较符合人类阅读习惯，具有伪代码本质；（2）易学：python虽然是用c语言写的，但是它摈弃了c中非常复杂的指针，简化了python的语法；（3）开源：可以阅读它的源代码、对它做改动、用于新软件中等；（4）可移植性：由于它的开源本质，Python已经被移植在许多平台上；（5）Python既支持面向过程的函数编程也支持面向对象的抽象编程。（6）可扩展性和可嵌入性：你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。（7）丰富的库：包括正则表达式、文档操作、数据库等等；1.Python简介-特点缺点：（1）强制缩进：Python设计时受C和ABC语言的影响，强制缩进来源于ABC语言；（2）运行速度：运行速度慢，C程序运行1秒钟，Java程序可能需要2秒，而Python程序可能就需要10秒。（3）python的开源性使其不能加密；1.Python简介-用途网站后端程序员：使用Python搭建网站、后台服务会比较容易维护。有不少知名网站都使用了Python开发，如：知乎、豆瓣、Youtube自动化运维游戏开发自动化测试：对于测试来说，要掌握Script的特性，会在设计脚本中，有更好的效果。Python是目前比较流行的Script。网页爬虫：当你需要获取大批量数据或者批量处理的时候，Python爬虫可以快速做到这些，从而节省你的重复劳动时间。2.Python2和3的区别（1）Python3中去除print语句，加入print()函数实现相同的功能和新功能；作用python2（print语句）python3（print函数）输出空行printprint()输出一个值print’abc’print(’abc’)#输出abc使用空格分割输出的两个值print’abc’,’123’print(’abc’,’123’)#输出abc123重定向print>>file,strprint(str,file)句尾加符号Print’abc’,’…’print(’abc’,end=’…’)2.Python2和3的区别（2）py2默认ASCII编码，py3默认采用了unicode作为默认编码。ASCII编码最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码中文GB2312编码日文shift_JIS……处理中文一个字节不够，要处理中文至少需要两个字节，而且还不能和ASCII编码冲突，中国制定了GB2312编码，而其他语言也有自己一套编码，多语言混合时有乱码问题unicode编码Unicode通常为两个字节编码（如果要用到非常偏僻的字符需要4个字节），它把所有语言都统一到一套编码里，避免乱码问题。utf-8编码UTF-8编码把一个Unicode字符根据字符的不同编码成1-6个字节，英文通常为1个字节，汉字为3个字节；若源代码中包含中文，一般在代码头部指定为utf-8编码（下列方式任选一种都可以）：2.Python2和3的区别（3）其他：a=3b=4print(a/b,type(a/b))print(a//b,type(a//b))输出：0.75<class'float'>0<class'int'>改变了除法规则捕获异常pythonExceptionase和Exception,e捕获一个异常对象ase是python2.5之后的方案3.Python的安装-版本选择（1）选择py2还是py3？Python的两个版本版本是不兼容的，所以许多py2.x版本的代码要修改后才能在py3.x上运行，所以，目前有许多第三方库还暂时无法在3.x上使用。在我看来，语言的更新速度更快，没有必要停留在过去不向前看，所以我选择了更多新特性的Python3.x（2）如何安装py3.7？windows版本安装：3.Python的安装-windows版本（1）登入下载网址/（2）运行下载的MSI安装包，在选择安装组件的一步时，勾上所有的组件；（3）检查是否安装成功：打开cmd，输入python若安装成功，则出现下图若出现下图，则表示安装失败，需手动设置环境变量出现原因和解决办法：在安装时漏掉了勾选Addpython.exetoPath，那就要手动把python.exe所在的路径添加到Path中。3.Python的安装-linux版本（1）打开虚拟机安装特定版本的Python，在终端输入：sudoapt-getinstallpython3.74.编译器推荐使用IDE工具推荐使用公认最智能好用的PythonIDE，Pycharm，支持windows和mac用户下载链接：/pycharm/，选择社区版免费的，专业版付费的。官网快速上手的中文视频：/pycharm/documentation/输入和输出语句与语法基本数据类型控制流上下文管理器2.Python基本语法1.输入和输出（1）输出：print()函数>>>print("HelloWorld")HelloWorld>>>print('HelloWorld')HelloWorld>>>print("Hello'World'")Hello'World'>>>print('Hello"World"')Hello"World"print(str1)print(str1,str2)#print()遇到逗号输出一个空格>>>print("zhang","rui")zhangruiprint()数字或算数表达式的结果>>>print(3.14)3.14>>>print(4+2*3)10print()重定向>>>fw=open("1.txt","w")>>>print("123",file=fw)>>>fw.close()>>>print(open("1.txt").read())1231.输入和输出print(str1)>>>print("mynameis%s"%"zhangrui")mynameiszhangrui>>>print("myageis%d"%25)myageis251.输入和输出formatpython2.6开始，新增了一种格式化字符串的函数str.format()key和value的形式下标形式居中右对齐填充>>>"{},{}".format("python","test")'python,test'>>>"{name},{value},{name}".format(name="python",value=2.7)'python,2.7,python'>>>alist=["python","2.7"]>>>"{0[0]},{0[1]},{0[0]}".format(alist)'python,2.7,python'>>>"{:^10}".format("123")'123'>>>"{:>10}".format("123")'123'>>>"{:x<10}".format("123")'123xxxxxxx'1.输入和输出（1）输入：input()函数>>>input("pleaseinputyourname:")pleaseinputyourname:zhangrui'zhangrui'>>>b=input()123>>>b’123’input()：数值raw_input()：字符串input()：字符串python2python32.语句与语法（1）注释与缩进python2当语句以冒号结尾时，缩进的语句为代码块；缩进可用空格或Tab，但不可混用，一般约定使用4个空格的缩进；（使用编辑器时可以进行设置）注意：复制粘贴python代码时，可能因为缩进问题运行报错；python代码区分大小写；2.语句与语法（2）继续和分隔python2一行写不下分多行：可以使用反斜杠\或者()进行续写>>>b='abcd'\ '1234'>>>print(b)abcd1234>>>c=("1234" "5678")

>>>print(c)

12345678>>>d=str(c)\ +b

>>>print(d)

12345678abcd12341.函数内或同一代码段中，空行行数1，空行规则以分隔不同功能和模块为准2.多个函数之间，空行行数13.类之间，空行行数2分隔3.基本数据类型（1）常量与变量python2常量：常量是一块只读的内存区域，常量一旦被初始化就不能被改变。例如，字符串常量’changliang’;数字常量等等；变量:变量是计算机内存中的一块区域，变量可以存储规定范围内的值，而且值可以改变；a=1 #整型变量b=“123” #字符串变量c=True #布尔值变量python中的数据类型不需要(显示)的声明，解释器根据变量的赋值确定变量的类型；Python变量是无类型的，x=10，变量x是无类型的，相当于指针，指向int数据类型的值python中，strings,tuples,和numbers是不可更改的对象，而list,dict等则是可以修改的对象3.基本数据类型（2）基本数据类型包括以下几种python2整型(int):a=0浮点型(float):a=9.9字符串(str):a=’string’,a=”string”,a=’’’string’’’布尔值(Boolean):a=True,a=False列表(list):a=[1,2,3,4]字典(dict):a={intA:1,floatA:9.9,strA:”string”}元组(tuple):a=(1,2,3,4)集合(set):a=set([1,2,3])如何确定数据变量的类型？内部type函数的使用3.基本数据类型-列表（1）列表(list)：一个有序的可变更的数据结构python2

例如，a=[1,2,3,4]访问列表中的元素：使用下标索引:list[index] a[0] #第1个元素 a[3] #第4个元素 a[-1] #最后一个元素添加元素

：append(value):在列表末尾添加一个元素 a.append(5) #[1,2,3,4,5]insert(index,value):在指定位置插入一个元素 a.insert(1,5) #[1,5,2,3,4]修改元素:使用下标索引直接赋值a[3]=0 #[1,2,3,0]删除元素:remove(元素)删除单个元素pop(位)按位删除，根据索引删除,返回被删除的元素delstr[位]

、delstr[n:m]或delstr根据索引删除；也可以删除指定范围内的值（包头不包尾）；删除整个数据对象（列表、集合等）

a.remove(4)#[1,2,3]

a.pop(2)#[1,2,4]

dela[2] #[1,2,4]字符转换：list1=["1",2,"3",4]list2=[str(i)foriinlist1]list3=''.join(list2)映射：list1=["1",2,"3"]list2=[li*2forliinlist1]3.基本数据类型-列表python2其他操作将list2的元素扩充到list1中list1.extend(list2)列表反向list.reverse()列表排序list.sort()统计某个元素出现的个数list.count(obj)3.基本数据类型-列表python2列表的特点有序可重复可变内存占用相对字典更小效率较低（遍历）3.基本数据类型-列表python2若列表a=[1,2,3,4]，分别进行下面的操作，（1）b=a（2）c=a[:]（3）d=a*1（4）importcopye=copy.copy(a)（5）f=[a]*1若此时a.append(5)，此时b、c、d、e、f分别是多少？问题思考：b=[1,2,3,4,5]#a、b和f指向同一个列表c=[1,2,3,4] #c.d.e都是对a的浅复制，对原来引用的对象进行了复制，但是不再引用同一对象地址d=[1,2,3,4] 注：要熟悉掌握“引用、浅复制、深复制”概念！e=[1,2,3,4]f=[1,2,3,4,5]3.基本数据类型-列表python2问题思考：A[:2]:

[['Sunday''00:00:00''0''0''noevent']

['Sunday''00:30:00''1''0''noevent']]

A[:,2]:

['0''1''0'...'0''0''1']A=[['Sunday''00:00:00''0''0''noevent']

['Sunday''00:30:00''1''0''noevent']

['Sunday''01:00:00''0''0''noevent']

...

['Saturday''22:30:00''0''0''noevent']

['Saturday''23:00:00''0''0''noevent']

['Saturday''23:30:00''1''0''noevent']]print("A[:2]:",A[:2])print("A[:,2]:",A[:,2])

3.基本数据类型-字典（2）字典(dict)：一种使用映射关系的可变容器模型，又称关联数组或哈希表python2字典的结构为{键:值,….}，键不可重复，创建时如果同一个键被赋值两次，后一个值会被记住；键必须不可变，所以可以用数，字符串或元组充当，列表就不行a={k1:v1,k2:v2,k3:v3}访问字典中的元素：使用key的名称:dict[key] a[k2] #v2添加元素:直接添加新的keya[k4]=v4 #{k1:v1,k2:v2,k3:v3,k4:v4}修改元素:使用key的名称直接赋值a[k1]=0 #{k1:0,k2:v2,k3:v3}删除元素:使用del和pop删除指定键的元素 dela[k3] #{k1:0,k2:v2} a.pop(k2) #{k1:0,k3:v3}其他操作字典合并dict1.update(dict2)字典排序sorted(dict.items(),key=lambdae:e[0],reverse=True)#按键排序，倒序sorted(dict.items(),key=lambdae:e[1],reverse=True)#按值排序，倒序3.基本数据类型-字典python2字典的特点无序不可重复不可变内存占用较大效率高（hash）3.基本数据类型-字典与列表之间的转换python2dit={'name':'zxf','age':'22','gender':'male','address':'shanghai'}

#将字典的key转换成列表

lst=list(dit.keys())

print(lst)#['name','age','gender','address']

#将字典的value转换成列表

lst2=list(dit.values())

print(lst2)#['zxf','22','male','shanghai']

#将字典的key和value转成列表

lis3=list(dit.items())

print(lis3)字典可以直接使用list转换成列表3.基本数据类型-字典与列表之间的转换python2使用zip()函数：将a和b两个列表内的元素两两组合成键值对。当两个列表的长度不一致时，多出的元素在另一个列表无匹配的元素时就不展示多出的元素。使用嵌套列表转换为字典：a和b列表内只能有两个元素，将列表内的元素自行组合成键值对a=['a1','a2','a3','a4']

b=['b1','b2','b3']

d=zip(a,b)

print(dict(d))#{'a1':'b1','a2':'b2','a3':'b3'}#a=['a','b']

#b=['1','2']

#c=[a,b]

#print(dict(c))#{'a':'b','1':'2'}相当于遍历子列表

#

#print("遍历：")

#dit={}

#foriinc:

#dit[i[0]]=i[1]

#print(dit)3.基本数据类型-元组python2元组(tuple)：一个有序的不变更的数据结构元组和列表十分相似，不同之处为元组在初始化之后就不能被修改了

a=(1,2,3,4) a=tuple(1,2,3,4) a=1,2,3,4访问元素：使用下标索引:tuple[index] a[0] #1 a[3] #4

3.基本数据类型-元组python2程序输出3.基本数据类型-集合python2集合(set):由不同元素构成的无序的数据集合，集合分为可变集合和不可变集合创建集合 a=set('1234ac') #可变集合

b=frozenset(['1','3','a','b','c','d']) #不可变集合访问元素:由于是无序的遍历或使用in和notin

foriina:

print(i)

添加元素:

使用add()方法

a.add(‘56’) #

set(['a','c','1','3','2','56','4'])使用update()方法

a.update(‘xX’) #

set(['a','c','1','3','2','4','X','x'])删除元素:使用remove()方法 a.remove(‘1’) #set(['a','c','3','2','4'])其他操作联合两个集合s=a.union(b) #set(['a','c','b','d','1','3','2','4'])交集s=ersection(b) #set(['a','1','c','3'])差集s=a.difference(b) #set(['2','4'])对称差集s=a.symmetric_difference(b) #set(['b','d','2','4'])3.基本数据类型-判断数据类型python2判断数据类型：type(object),isinstance(object,class_or_type_or_tuple):type(object):参数说明：(对象名称),返回值：对象类型(非字符串) a=1 print(type(a))

----------------->>

<type'int'>isinstance(object,class_or_type_or_tuple):参数说明：(对象名称,类型),返回值：True/False

a=1 print(isinstance(a,int))

----------------->>

Truetype和isinstance的异同：type返回对象类型(未知)，而isinstance判断对象是否等于某个类型(已知)isinstance的效率略高于type(毫秒级)3.基本数据类型-数据类型转换python2类型转换：数字转数字:整型转浮点型float()，浮点型转整型int() a=1 b=2.2 print(float(a)) #----------------->>1.0 print(int(b)) #----------------->>

2字符串转数字:int()/float() a="1" print(int(a)) #----------------->>1 print(float(a)) #----------------->>

1.0数字转字符串:str()

a=1.0

print(str(a))

#----------------->>‘1’4.控制流python2熟练掌握控制流的应用是python编程的基础Python的控制流包括：条件语句，循环，遍历，嵌套，异常处理，上下文管理器等等4.控制流-条件语句python2（1）条件语句if表达式:

elif表达式:else:a=0ifa==None: print(None)elifa==0: print(True)else: print(False)输出结果为：True*注：python中没有switch/case语句4.控制流-遍历python2（2）遍历

遍历的语法格式为:for变量in迭代器/列表/字典/…:deftra_while(string):

index=0

whileindex<len(string):

print(string[index])

index+=1name=“python”tra(name)输出结果：pythondeftra_for(string): forcharinstring:

print(char)4.控制流-循环python2（3）循环

循环的语法格式为:while表达式:i=0whilei<10: print(i) i+=1这里定义了一个int变量i,初始值为0当i<10时，继续循环，当i>=10时，退出循环最终结果为:0123456789 4.控制流-嵌套python2（4）嵌套

包括循环的嵌套，函数的嵌套foriinrange(10): forjinrange(5): print(i+j)结果为：012341234523456345674567856789678910789101189101112910111213循环嵌套函数嵌套defnest(i,j): ifi+j<100: print(i+j) nest(i+j,j+i)nest(2,3)结果为：5102040804.控制流-pass,continue,breakpython2（5）pass表示,继续执行，不做任何操作；continue表示，跳过本次循环，进入下一次循环；break表示,退出循环i=0while1: ifi==0: pass ifi==2:

i+=1 continue ifi==10: break print(i) i+=1输出结果为:013456789*注：使用continue操作时，需注意continue会跳过之后的所有语句，因此一些影响程序逻辑的语句需要放到continue之前执行5.上下文管理器python2上下文管理器（ContextManager）：可以通过上下文管理器来定义/控制代码块执行前的准备动作，以及执行后的收尾动作__enter__和__exit__with语句：在代码运行前执行__enter__，在代码执行后执行__exit__具有内置方法__enter__和__exit__的类型，比如file#fw=open("123.txt","w")#fw.write("123")#fw.close()withopen("123.txt","w")asfw:fw.write("123")5.上下文管理器python2自定义类型的上下文classTest:def__init__(self,num):self.num=numdef__enter__(self):self.num+=1print("_enter_:%s"%self.num)returnself.numdef__exit__(self,*param):#会话管理器在代码块执行完成好后调用（不同于__del__）(必须是4个参数)self.num*=2print("_exit_:%s"%self.num)withTest(2)asb:print(b)运行结果：_enter_:33_exit_:6函数函数式编程3.函数和函数式编程1.函数python2定义：函数是指一段在一起的、可以做某一件事儿的程序。也叫做子程序、方法。函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段用关键字def开头，

后面接‘函数名称’及用()括起来的’函数参数’，最后以:结尾用关键字return，表示函数结束并返回一个或多个数据，没有return则默认返回None作用：合理的使用函数，可以提高代码的运行效率，可读性及复用率分类：内置函数、自定义函数1.函数python2调用：直接使用函数名生成函数实例来调用函数的参数：形参：函数定义时定义的参数实参：函数调用时传入的参数deffunction_test(): return"thisistestfunction"printfunction_test()输出结果：thisistestfunction1.函数python2函数参数传递：

可变类型，则类似c++的引用，如list、dict。如fun（la），则是将la真正的传过去，修改后fun外部的la也会受影响

不可变类型，则类似c++的值传递，如int。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改a的值，只是修改另一个复制的对象，不会影响a本身参数类型：普通参数(必填参数)：函数定义时的普通参数，这种参数必须传值，且顺序固定缺省参数：函数定义时进行了赋值的参数。这种参数在调用时可以传入实参也可以不传，但缺省参数必须写在所有普通参数的后面。格式如：param1=‘value’不定长参数：可以存放若干个参数的参数(建议使用元组和列表代替此种参数，增加程序可读性)。不定长参数(元组参数)：用*在参数名之前表示，格式如：*argv关键字参数(字典参数)：用**在参数名之前表示，格式如：**argvs(不定长参数和缺省参数不可共存)1.函数python2普通参数实例：deffunc(a,b):print('a=%d,b=%d'%(a,b))func(10,20)#不使用参数名，需要按参数顺序传递func(a=10,b=20)#使用参数名可以不按顺序传递func(b=20,a=10)#结果：a=10,b=20a=10,b=20a=10,b=201.函数python2缺省参数实例：deffunction_test2(paramNormal,paramDefault="default"): print"paramNormal:%s"%paramNormal print"paramDefault:%s"%paramDefaultfunction_test2("normal")输出结果：paramNormal:normalparamDefault:default1.函数python2元组参数实例：deffunc(*args):#这种定义会把传递的参数包成元组

print(args,type(args))func(10,20)#结果：#(10,20)<class'tuple'>deffunc(a,b):

print('a=%d,b=%d'%(a,b))a=(10,20)func(*a)#在调用函数使用`*`则会把元组解包成单个变量按顺序传入函数#结果：a=10,b=20总结：*号在定义函数参数时，传入函数的参数会转换成元组，如果

*号在调用时则会把元组解包成单个元素1.函数python2关键字字典参数实例：deffunc(**kw):#使用**定义参数会把传入参数包装成字典dictprint(kw,type(kw))func(a=10,b=20)#这种函数在使用时必须指定参数值，使用key=value这种形式#结果：{'b':20,'a':10}<class'dict'>deffunc(a,b):print('a=%d,b=%d'%(a,b))d={'a':10,'b':20}func(**d)#在调用时使用**会把字典解包成变量传入函数。总结：**号在定义函数参数时，传入函数的参数会转换成字典，如果

**号在调用时则会把字典解包成单个元素1.函数python2lambda表达式在python中某些简单的函数可以用lambda表达式来表示lambda

[arg1[,arg2,.....argn]]:expression例如：等价于灵活使用lambda表达式可以使代码更加简洁func_sum=lambdax,y:x+yprint(func_sum(1,2))deffunc_sum(x,y): returnx+yprint(func_sum(1,2))1.函数python2变量的作用域全局变量：定义在函数或类外部的变量，作用域为整个程序生命周期局部变量：定义在函数或类内部的变量，作用域为函数/类生命周期gNum=100defsum_num(): num=10 print("localvariable:",num) print("globalvariable:",gNum)sum_num()输出结果：localvariable:10globalvariable:100num=3defsum_num(): num=4 print("numinsum_num:",num)sum_num()print("num:",num)输出结果：numinsum_num:4num:3#当全局变量在函数内部再次被定义时，该变量在函数中作为局部变量使用1.函数python2global关键字python中的global关键字并不是用来声明全局变量的，而是用来修改全局变量的值;

global是对整个环境下的变量起作用，而不是对函数类的变量起作用x=0defouter():x=1definner():

globalxx=2print("inner:",x)inner()print("outer:",x)outer()print("global:",x)#inner:2#outer:1#global:21.函数python2nonlocal关键字函数里面再嵌套了一个函数。当使用nonlocal时，就声明了该变量不只在嵌套函数inner（）里面才有效，而是在整个大函数里面都有效，对全局变量无效注：nonlocal它只是作用于嵌套作用域，而且只是作用在函数里面；在Python2.x中，闭包只能读外部函数的变量，而不能改写它，nonlocal关键字Python3.x才引入#inner:2#outer:2

#global:0x=0defouter():x=1definner():nonlocalxx=2print("inner:",x)inner()print("outer:",x)outer()print("global:",x)1.函数python2私有函数以两个下划线开头的函数为私有函数，例如def__init__(self):私有函数的作用域py文件中的私有函数，作用域为整个py文件，但无法被其他py文件引用class中的私有函数，作用域为整个类，无法被class以外的成员调用右侧的代码为class私有函数的例子：从代码可以看出，调用Sum类的普通成员函数sum_func()，成功返回计算结果3。调用Sum类的私有成员函数__private_func()，返回错误“Suminstancehasnoattribute'__private_func'”classSum:def__init__(self):passdefsum_func(self,num1,num2):returnself.__private_func(num1,num2)def__private_func(self,num1,num2):returnnum1+num2SUM=Sum()print("SUM.sum_func:%s"%SUM.sum_func(1,2))try:print("SUM.sum_func:%s"%SUM.__private_func(1,2))exceptExceptionase:print(e)1.函数python2函数的嵌套函数的嵌套就是在函数中定义其他函数内层函数可以访问外部函数的变量，但不能赋值可以使用nonlocal关键字对外部变量进行赋值1.函数pyth1534320684.8018491inthetest11534320687输出.8020205on2高阶函数把一个函数名做为实参传递给另一个函数

importtimedefdeco(func):start_time=time.time()print(start_time)func()stop_time=time.time()print(stop_time)print('thefunctionruntimeis%s'%(stop_time-start_time))deftest1():time.sleep(3)print('inthetest1')deco(test1)输出1534321241.7507045inthetest11534321244.7518764thefunctionruntimeis3.0011718273162841.函数python2递归递归就是在函数内部调用函数自身defrec(sun):ifsun>=10:returnelse:print(sun)sun+=1rec(sun)rec(1)注意：在写递归的时候一定要设置好退出条件，否则程序会陷入死循环1.函数python2装饰器Python中可以使用装饰函数来在指定函数的前后附加特定的功能，比如函数执行计时功能语法格式如下：

@timer

:装饰器语法糖importtime#装饰器timerdeftimer(func):defdeco():start_time=time.time()func()stop_time=time.time()print("thefunctionruntimeis%s"%(stop_time-start_time))returndeco@timer#在python里，用@+装饰器函数名，放在被装饰函数上面，实际等同于test1=timer(test1)deftest1():time.sleep(3)print("inthetest1")test1()1.函数python2内置函数的调用

两种调用方法 importsomemodule

fromsomemoduleimportfunction1,function2,... fromsomemoduleimport*一般说来，应该避免使from..import而使用import语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突2.函数式编程python2定义函数式编程是种编程范式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambdacalculus）。而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。特点代码简洁，开发效率高容易理解可维护性强可复用性强2.函数式编程python2#-*-coding:utf-8-*-importosimportsysprint(os.path.abspath(os.getcwd()))#-*-coding:utf-8-*-importosimportsysdefprint_cwd(): print(os.path.abspath(os.getcwd()))if__name__=="__main__": print_cwd()定义函数的原则在函数式编程中，除了导入语句，全局变量，注释，尽量不要出现在函数之外的代码2.函数式编程python2#-*-coding:utf-8-*-importosimportsysdefprint_cwd(): print(os.path.abspath(os.getcwd()))

defprint_sum(a,b): print(a+b)if__name__=="__main__": print_cwd() print_sum(1,2)定义函数的原则聚合一个函数中最好只包含一个功能或制作一件事2.函数式编程python2deffun1(num): returnnumdeffun2(num): returnnum*2deffun3(num): returnnum/2

if__name__=="__main__": printfun3(fun2(fun1(2)))定义函数的原则耦合参数输入，return输出(让函数减少外部依赖，独立运行)2.函数式编程python2if__name__==“__main__”:这句话是什么意思?__name__是一个内置变量，作为一个标识存在假设有一个test.py当test.py文件作为主程序执行时，__name__的值为__main__当test.py文件作为一个模块被引用时，__name__的值为test当py作为主程序执行时，该语句作用等同于main()当py被引用是，该语句会被忽略有什么好处我们可以为所有py文件编写测试代码，而不用担心py文件在作为非主程序时测试代码被执行所以建议使用该语句代替main()2.函数式编程python2定义函数的原则需要重复调用或有复用价值的功能，编写到函数中不同函数中不要出现重复的功能，如果出现尽量规整到单一函数中2.函数式编程python2函数式编程的建议高聚合，低耦合尽量避免在函数中修改全局变量的值避免在函数中修改可变变量(直接修改dict或list，传出一个新的变量)避免在函数中修改其他模块的变量(建立新的变量)单个函数的代码行数最好控制在100行以内，如果发现函数较长，尝试细分函数功能，将某些工具形成子函数提取出来。尽量让读者在一页中看到整个函数函数较多时，将相关联的函数放在一起，并使用注释说明，方便阅读和维护函数很多时，重新审视代码，尝试将函数放在不同的模块中(py文件中),即进行简单的框架设计。保证在一个py文件中，能够很方便的查阅代码。4.类和面向对象编程类的介绍类的方法类的继承内置方法面向对象编程1.类的介绍python2类的定义类（Class）是面向对象程序设计（OOP，Object-OrientedProgramming）实现信息封装的基础。类是一种用户定义类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。类可以是一件事，一个功能，一组数据，一组对象，对一些具有共同特征实物的抽象通常情况下，类可以作为面向对象设计的基本单位Python中使用关键字class定义类，格式如下: class<类名>:

属性

方法类的实例如果想要使用类，则需要给类创建实例，格式如下： classTest: …

T

=Test()1.类的介绍python2类的变量、实例变量类变量：指定义在类的内部，但不包含在函数之内的变量，此变量可以通过类直接访问实例变量：值定义在类的__init__函数内部，通过self修饰的变量，此变量必须通过类的实例才能访问classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2print("类变量:",Sun.num)SUM=Sun()print("实例变量：",SUM.num)1.类的介绍python2类变量和实例变量classSun: num=0 def__init__(self): self.num1=2print("类调用:",Sun.num)SUM=Sun()print("实例调用：",SUM.num)类调用:0实例调用：0classSun: num=0 def__init__(self): self.num1=2try: SUM=Sun() print("实例调用：",SUM.num1) print("类调用:",Sun.num1)exceptExceptionasex: print(ex)实例调用：2typeobject'Sun'hasnoattribute'num1'1.类的介绍python2类的属性、实例属性Python中可以使用内置函数dir(),和类的字典属性__dict__来查看类属性和实例属性类属性和实例属性的区别

类属性包括类变量和类中所有内置函数和自定义函数

实例属性值包括实例变量classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2SUM=Sun()print("类属性（__dict__）",Sun.__dict__)print("类属性（dir）:",dir(Sun))print("实例属性：",SUM.__dict__)1.类的介绍python2类的属性、实例属性Python中可以使用内置函数dir(),和类的字典属性__dict__来查看类属性和实例属性类属性和实例属性的区别

类属性包括类变量和类中所有内置函数和自定义函数

实例属性值包括实例变量classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2SUM=Sun()print("类属性（__dict__）",Sun.__dict__)print("类属性（dir）:",dir(Sun))print("实例属性：",SUM.__dict__)1.类的介绍python2dir()和__dict__的区别dir()返回一个list,__dict__返回一个字典__dict__是dir()的一部分，是它的子集实例的__dict属性，只包括实例相关的属性类的__dict__属性，只包括类相关的属性dir()返回对象的所有属性，包括继承的父类属性1.类的介绍python2保护变量和私有变量保护变量定义在类中，以单个下划线开头的变量_test=1保护变量其实和普通变量一样，此种变量只是告诉外部人员我是保护变量，请不要修改，但实际上还是能够访问和修改的私有变量定义在类中，以两个下划线开头的变量__test=1类实例能内部访问到私有变量类的实例不能外部访问到私有变量但对于python来说并没有实际意义的私有话，私有变量仍然可以通过某种方式访问到，因为python会把私有变量改写成_className__privateName的形式1.类的介绍python2保护变量和私有变量classTestParent: def__init__(self): self._protectVar="tect" self.__privateVar="self.private" defprint_Var(self): print("实例内部调用保护变量：",self._protectVar) print("实例内部调用私有变量：",self.__privateVar)TP=TestParent()try: TP.print_Var() print("实例外部调用保护变量：",TP._protectVar) print("实例外部调用私有变量：",TP.__privateVar)exceptExceptionase: print(e)print("实例外部调用私有变量_TestParent_privateVar：",TP._TestParent__privateVar)2.类的方法python2类方法、静态方法、实例方法实例方法

：通过类的实例才能访问的方法(函数),即为实例方法类方法：可以通过类访问的方法，为类方法，使用装饰器@classmethod来标记，类方法同样可被实例访问。需注意类方法不要在参数的第一个参数写入实例对象self，但要写入一个参数表示类，一般用cls来表示静态方法：静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。因此今静态方法可被多个实例共享。使用装饰器@staticmethod定义静态方法。静态方法同样可被实例访问。需注意静态方法不要在参数中写入实例对象或类对象classSum: num=0 def__init__(self): self.num=1 defsum_func(self,num1,num2): returnnum1+num2 @classmethod defsum_func_classmethod(cls,num1,num2): returnnum1+num2 @staticmethod defsum_func_staticmethod(num1,num2): returnnum1+num2SUM=Sum()print("实例方法：",SUM.sum_func(1,2))print("实例调用类方法：",SUM.sum_func_classmethod(1,2))print("实例调用静态方法：",SUM.sum_func_staticmethod(1,2))print("类方法：",Sum.sum_func_classmethod(1,2))print("类调用静态方法",Sum.sum_func_staticmethod(1,2))2.类的方法python2类方法的作用一些和类相关的操作，但不与实例交互的操作classKls(): no=0 def__init__(self): #self.no=self.no+1 Kls.no=Kls.no+1

@classmethod defget_no(cls): returncls.noik1=Kls()print(ik1.get_no())print(Kls.get_no())2.类的方法python2静态方法的作用一些和类相关，但既不需要与类交互，也不需要与实例交互的方法。importtimeclassTimeTest(object):def__init__(self,hour,minute,second):self.hour=hourself.minute=minuteself.second=second@staticmethoddefshowTime():returntime.strftime("%H:%M:%S",time.localtime())print(TimeTest.showTime())t=TimeTest(2,10,10)nowTime=t.showTime()print(nowTime)右边静态方法，然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象2.类的方法python2普通方法和私有方法普通方法，是共享的，可被外部调用，无需多说私有方法，非共享，不可被外部调用。使用两个下划线开头，例：__private_test()classTestFunc:def__init__(self):="TestFunc"def__private_test(self):print()deftest(self):print()TF=TestFunc()try: TF.test() TF.__private_test()exceptExceptionasex:print(ex)2.类的方法python2构造函数和析构函数构造函数(初始化):def__init__(self):当类的实例对象创建时被调用理论上构造函数里可以做任何事，但一般情况下构造函数用于声明变量，初始化变量等操作2.类的方法python2析构函数def__del__(self):当类的实例被销毁时，自动调用析构函数通常情况下，析构函数用来，释放对象，销毁内存等操作(由于python有垃圾回收机制，因此一般来说，不需要重写析构函数)3.类的继承python2类的继承继承：python使用class派生类名(基类名)来实现类的继承，可以理解为基类是派生类的父类，派生类继承了父类的一切属性继承的一些特点：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。（先继承，后重构）在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。

3.类的继承python2继承中的覆盖在子类中覆盖父类的方法例如：在父类中有一个talk方法，我们在子类又创建了一个talk方法，这时子类的talk方法就覆盖了父类的talk方法(但并不是改写了父类的talk方法)classPerson(object):def__init__(self,name,age):=nameself.age=agedeftalk(self):print("%sistalking...."%)classChinese(Person):def__init__(self,name,age,language):Person.__init__(self,name,age)#继承父类的构造方法，也可以写成：super(Chinese,self).__init__(name,age)super().__init__(name,age)self.language=languagedeftalk(self):print("%sistalking..."%)c=Chinese("zhangrui",22,"chinese")c.talk()3.类的继承python2多重继承python允许子类继