导图社区 python知识网
- 542
- 37
- 4
- 举报
python知识网
纯干货！你要的Python基础知识点整理好了！本文对变量、语法、条件循环、面向对象、函数、语法规则符、文件的读取及保存、错误异常这些方面进行了全量笔记整理，这些知识点你还记得吗?
编辑于2019-08-14 05:30:27- 相似推荐
- 大纲
python
基础知识
对象和类型
对象是某种类型的实例 type(对象)得到对应的类型
python内置数据类型
分类1
不可变类型（仅查）
非集合类型
数字
分类
整型int
浮点型float
若用科学计数法表示，10换为e,eg:1.23*10^9可以表示为1.23e9
复数型complex
complex(a,b)
转换
int()、float()、complex()
计算
内置
导入math
abs(x)：返回x的绝对值，类型随x
min(n1, n2, ...)：返回最小值
ceil(x)：取x的上入整数，如math.ceil(4.1)返回5
floor(x)：取x的下入整数，如math.floor(4.9)返回4
round(x [,n])：默认返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的n位。例如round(1.23456, 3)返回1.235
exp(x)：返回e的x次幂，e是自然常数
fabs(x)：返回x的绝对值，类型是浮点数
modf(x)：返回x的整数部分和小数部分，两部分的符号与x相同，整数部分以浮点型表示。例如math.modf(4.333)，返回元组(0.3330000000000002, 4.0)
log10(x)：返回以10为基数的x的对数，返回值类型是浮点数
log(x,y)：返回以y为基数的x的对数，返回值类型是浮点数
pow(x, y)：返回x的y次幂，即x**y
max(n1, n2, ...)：返回最大值
sqrt(x)：返回x的平方根，返回值是float类型
布尔
值True、False
运算
bytes
字符串
定义：可以打印的字符序列
构建
基本定义
str_name='character_string'
注：""与''皆可
str(variable_name)转换为str类型
特殊字符
转义字符（控制输出格式，不计入字符串）
直接法
\n换行 \r回车 \b退格 \'单引号 \"双引号 \行尾表示续行 \\反斜杠 \v纵向制表符 \t横向制表符
注意：只有\r只能换到本行行首，会覆盖部分文字，所以\r\n共用
Docstring法
双三引号'''string'''或"""string"""，string内容格式为期望打印的格式。
原始字符
将转义字符视为普通字符
方法
str_name=r"string"或r'string'
双斜杠\+转义字符
Unicode中文编码
为防止不同机器中文编码不同，统一定义为Unicode字符串
str_name=u'string'或U'string'
操作
索引
正向索引
str_name[index],index从0递增
逆向索引
str_name[index],index从-1递减
索引元组
enumerate(str_name)返回索引与值的元组
常见问题
索引越界：string out of range
切片
正向切片
str_name[start:end]左闭右开区间，从第start字符开始，到第end前结束
反向切片
str_name[start:end]左闭右开区间，从第start字符开始，到第end前结束start，end都是小于等于-1的值。
指定步长切片
str_name[start:end:stride]从start每隔stride取一字符，直至end前，若stride<0，则从start到end后一位逆向取值，即同样左闭右开
s="asdfghjkl" print(s[-1:-5:-1]) print(s[5:2:-1]) lkjh hgf
注：start与end可以省略，默认为从行首和到行位，stride可以省略，默认为1
运算
拼接
str_name1+str_name2即可，必须都是str类型
重复
str_name*times
比较
相等关系
str1==str2,结果为True或False
大小关系
单字符比较
求ASCII码ord('字符')求字符chr(ASCII码)
单字符比较 < > 即为ASCII码大小比较，但仅限于字符与字符，不能字符与数字
多字符比较
对应索引单字符比较，直至结束，若都相等，则长字符串大。
成员判断
str1 in(或not in) str2
遍历
for i in str_name:
for i in enumerate(str_name):
s=U"法sdfv" for i in enumerate(s): print(i) (0, '法') (1, 's') (2, 'd') (3, 'f') (4, 'v')
python自带函数与方法
函数
函数len(str_name)求长度
方法
str_name.find(字符子串)求子串所在串的索引
无 -1
有 子串首字符在母串的第一个索引
find（sub[,start[,end]]）
str_name.upper英文大写
strname.split('分隔符')参数默认为空格分隔符，将字符串按分隔符分割返回字符串列表strname.split('分隔符')[index]可以索引
"连接符".join(str_name)将字符串列表用连接符连接
s=['5','2','1'] print('0'.join(s))50201
string模块
方法 help(string)查询
格式化
字符串对象的方法str.format
结构
format中内容按位置填充到{}里print("strx{}x{}y{}z".format('1',2,"3"))
strx1x2y3z
索引结构
标准索引
print("strx{0}x{1}y{2}z".format('1',2,"3"))
strx1x2y3z
元组索引
print("{0[0]}x{0[1]}y{1[0]}z{1[1]}".format(('1',2),("3",4)))
1x2y3z4
关键字映射
关键字在format最后print("{0[0]}{0[1]}{keyword}{1[0]}".format(('1',2),('5','6'),keyword='34'))
12345
格式化
在{}内加成{index:填充符对齐符字符宽度}，填充符不写用空格填充，^<>为居中、左对齐、右对齐
若format要替换的是数字，加.精度f
print("{:0^10.5f}".format(34.5))
034.500000
格式化操作符%
元组
不可更改的列表.完整性、持久性
创建
tuple_name=,,,,若仅有一个元素，也要写，
tuple_name=(,,,)若仅有一个元素，也要写。空元组为t=()或t=tuple()
t=tuple(其他序列)转化为元组
截取
tup[start:end:stride]
访问
索引t[index]规则与列表相同
遍历
for
删除
不允许删除元素，仅支持整个删除 del t
运算
len(t)
+ 连接
t*times 重复
x in tup 存在性
min(tup)/max(tup)
zip()
压缩
zip(a,b)ab为可迭代对象，返回迭代器，需要list(zip(a,b))或者for访问调用
for x,y in zip(a,b)可以将元组中的两个元素分给x,y,用来比较同一索引元素
a,b对应索引的两个元素组合成元组，以a,b中短的长度遍历完后，打包成迭代器
解压
a1, a2 = zip(*zip(a,b))返回成元组，且原来舍弃的部分不会恢复
可变类型（增、删、改、查）
列表
创建
list_name=[,,,]元素可以没有（空列表），多样，甚至为列表（多元列表）
list_name=list('str')函数list()仅支持集合类型数据转化为列表，如字符串将被转为每一个字符为元素的列表。
拆分
n1,n2,…=list_name,则ni指向各个元素（左侧数量等于元素数）
序列化操作
索引
读取
list_name[index],index从零开始，支持从-1开始的反向索引
多元列表list_name[][]读取
更改
list_name[index]=newValue
切片
正向切片
list_name[start:end]左闭右开区间，从第start字符开始，到第end前结束
反向切片
list_name[start:end]左闭右开区间，从第start字符开始，到第end前结束start，end都是小于等于-1的值。
指定步长切片
list_name[start:end:stride]从start每隔stride取，直至end前，若stride<0，则从start到end后一位逆向取值
s="asdfghjkl" print(s[-1:-5:-1]) print(s[5:2:-1]) lkjh hgf
注：start与end可以省略，默认为从行首和到行位，stride可以省略，默认为1
运算符
+ 拼接
* 重复
in/not in 成员判断
<>== <= >= !=比较类型相同的列表
函数
len()长度
max()、min()
sum()对数值型列表求和
sorted()升序排列，reversed()降序排列但返回迭代器，或者sorted()[::-1]即为降序列表
遍历操作
for i in list_name:
列表推导式
形式
[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
功能
将列表元素（满足条件）取出，经表达式求出新值，放入新列表
l=[1,2,3,4,5] print([i**2 for i in l if i<5])
[1, 4, 9, 16]
map(函数名，列表名)返回新列表
列表操作
修改
list_name[index]=newValue
切片修改（右侧必须为可迭代对象）
x=['sd','er','ww'] x[1:3]=[1] #['sd', 1] x[1:3]=1， #['sd', 1] [1:3]=1,2,3 #['sd', 1, 2, 3] x[1:3]='s' #['sd', 's'] x[1:3]='ss' #['sd', 's', 's'] x[1:3]='s','s' #['sd', 's', 's'] x[1:3]='s','ss' #['sd', 's', 'ss'] x[1:3]=['ss'] #['sd', 'ss']
全部修改
list_name[:]=可迭代对象
检索
返回索引 L.index(元素值)
求频数 L.count(元素值)
增加
尾部加新元素
L.append()
列表叠加
L1.extend(L2)
插入
L.insert(index,newValue)
删除
指定值
L.remove() 每次删除一个
指定索引
L.pop(index) 删除index处元素并弹出显示
del L[index] 无显示，可用切片同时删除多个
与字符串转换
"连接符".join(str_name)将字符串列表用连接符连接
s=['5','2','1'] print('0'.join(s))50201
strname.split('分隔符')参数默认为空格分隔符，将字符串按分隔符分割返回字符串列表strname.split('分隔符')[index]可以索引
拷贝
深拷贝
开辟新空间,不受任何影响
import copy
L2=copy.deepcopy(L1)
浅拷贝
仅复制容器中元素地址,当旧变量修改时，新变量的可变对象元素（list）改变，不可变对象元素（字符串、元组、数值）不变
做法
import copy
L2=copy.copy(L1)
L2=L1[:]
L2=list(L1)
L2=L1.copy()
字典
字典是键值对的无序集合。索引速度更快，值可以是任意对象，可以起名字（key）
组成
键（key）
键作为索引，可以访问值。没有顺序逆序索引。
键是任何不可变对象：数字、字符串、元组
值（value）
任意值：数字、字符串、函数
创建
dict_name={key:value,key:value,,,,}
dict_name=dict()创建空字典
dict(zip(k,v)),k,v是键、值序列
访问
dict_name[key]
遍历（x为key）
d={'1':'q',2:5,(5,'k'):[4,'l']} for x in d: print(x,d[x])
1 q 2 5 (5, 'k') [4, 'l']
相关操作
len()
key1 in dict_name 判断key1是否是字典键成员
方法
获取值列表
dict_n.values()
d={'1':'q',2:5,(5,'k'):[4,'l']} print(d.keys()) print(d.values())
dict_keys(['1', 2, (5, 'k')]) dict_values(['q', 5, [4, 'l']])
获取键列表
dict_n.keys()
获取元组形式键值对
d.items()
dict_items([('1', 'q'), (2, 5), ((5, 'k'), [4, 'l'])])
获取指定键的值
dict_n.get(key,default)如果值不存在，返回默认值default
应用.
统计频次
d={} for w in list1: if w in d: d[w]+=1 else: d[w]=1 # 字典d即为频次
代替if语句
def fun1(…): … def fun2(…): … …… func_dict={k1:fun1(…)，k2:fun2(…)，} func_dict.get(x,default)
集合
无重复、无顺序、无索引，非序列,用{，，}构成
创建
set_name=set(空/可迭代对象)最多一个参数
set_name={v1,v2,v3……}不能创建空集
常规操作
len()
in
for遍历
方法
增
set_n.add()仅一个参数
删
set_n.remove()若不存在，报错
set_n.discard()不报错
set.pop()无参数，删除首元素
清空
set_n.clear()
交
s1.intersection(s2)
并
s1.union(s2)
差
s1.difference(s2)
其他
copy() 拷贝一个集合
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
update() 给集合添加元素
运算
a - b 集合a中包含而集合b中不包含的元素
a | b 集合a或b中包含的所有元素(并)
a & b 集合a和b中都包含了的元素（交）
a ^ b 不同时包含于a和b的元素
集合推导式
{fun(x) for x in set_n if 条件}
分类2
原子类型（值集+操作）
数字
布尔
字符串
结构类型（数据结构+操作）
列表
字典
集合
元组
分类3
序列
字符串
列表
元组
非序列
字典
集合
面向对象
类
两个成员
属性（类所封装的数据）properties
公有属性
即类属性，可以被类直接调用，可以在类外被对象直接调用
定义
直接定义，无'_'前缀
调用
ClassName.attributeName
x=ClassName()#实例化对象x，调用x.属性，同时可以赋值
私有属性
类外不可调用，只能在类内通过方法调用。保护数据
定义
__attributeName
调用
在类内部调用
内置属性
不需要定义，python基本架构中存在的
形式
__x__例如'__init__'
__doc__查看注释
查看
dir(classname)
方法（类对数据进行的操作） methods
self是类的实例 class Student(): def __init__(self, name, score): self.name = name self.score = score a=Student('lili',99) a 就是self，self.name、self.score 就是a.name、a.score
内置方法
__init__
def __init__(self,other parameter): self.p1= self.p2= …… # 订制对象初始状态
其定义的属性，只有在实例化时才执行，在类内其他方法中通过self.pi直接调用；但无法通过类直接调用，如className.pi是错误的。
__del__释放对象
公有方法
def f(self,other parameter): ……
私有方法
def __f(self,other parameter): ……
仅能在类内部调用
构建
class ClassName: """关于类的描述""" properties def __init__(self,x1,x2,): self.publicProperties=x1 self.__privateProperties=x2 def f(self,,): pass def __f(self,,): pass
三大特征
继承
子类仅继承父类的公有属性public properties和公有方法public methods
构建
class ClassSonName(classfather,,):
构造方法的规范
class ClassFather: …… def __init__(self,x,y): self.X=x self.Y=y def f1(self): pass …… class ClassSon(ClassFather): …… def __init__(self,x,y,z,k): ClassFather.__init__(self,x,y) self.Z=z self.K=k #类定义 class people: #定义基本属性 name = '' age = 0 #定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 #定义构造方法 def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age)) #单继承示例 class student(people): grade = '' def __init__(self,n,a,w,g): #调用父类的构函 people.__init__(self,n,a,w) self.grade = g #覆写父类的方法 def speak(self): print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
多个父类时，继承分顺序
广度优先遍历（python3默认为新式类，选择广度优先遍历）
重载
方法重载
重新在子类中定义父类方法
class ClassFather: …… def __init__(self,x,y): self.X=x self.Y=y def f1(self): pass …… class ClassSon(ClassFather): …… def __init__(self,x,y,z,k): ClassFather.__init__(self,x,y) self.Z=z self.K=k def f1(self): ClassFather.f1(self) …
运算符重载
在自定义类中对运算符（+-*/）对应的专有方法（__add__、__sub__、__mul__、__div__）重新定义
class mylist: def __init__(self,*x): self.X=[] for i in x: self.X.append(i) def __add__(self,n): for i in range(len(self.X)): self.X[i]=self.X[i]+n def show(self): print(self.X) l=mylist(1,2,3,4,5,6,7,8) l.show() l+10 l.show() # [1, 2, 3, 4, 5, 6, 7, 8] [11, 12, 13, 14, 15, 16, 17, 18]
封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式。在将类实例化为对象时，内容被封装进对象里：object1=ClassName(parameters…)参数被封装进对象里。
调用
通过对象直接调用：object1.properties1
通过类中方法间接调用：在类中定义方法可以返回self.properties,在类外调用ClassName.func()
多态
前提是继承
同一个方法在不同的子类中最终呈现出不同的效果，即为多态。
装饰器decorator
作用：抽离出大量函数中与函数功能本身无关的雷同代码并继续重用,扩展函数功能
内置装饰器
无需实例化即可调用
class A(object): bar = 1 def foo(self): print ('foo') @staticmethod def static_foo(): print ('static_foo') print (A.bar) @classmethod def class_foo(cls): print ('class_foo') print (cls.bar) cls().foo() A.static_foo() A.class_foo() 结果 static_foo 1 class_foo 1 foo
startmethod：讲方法定义为公用方法，可以在外部当做函数调用，静态方法
不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样
classmethod：类方法”装饰后可将类名当做第一个参数的给予方法，从而在方法中调用类，并且不用实例化就能使用
也不需要self参数，但第一个参数需要是表示自身类的cls参数
property
将类的方法伪装成只读属性
class Person(object): def __init__(self, first_name, last_name): """Constructor""" self.first_name = first_name self.last_name = last_name @property def full_name(self): return "%s %s" % (self.first_name, self.last_name) >>> person = Person("Mike", "Driscoll") >>> person.full_name 'Mike Driscoll' >>> person.first_name 'Mike' >>> person.first_name = "Dan" >>> person.full_name 'Dan Driscoll'
重新实现一个属性的setter和getter方法
class Student(object): __slots__ = ('__name', '__age', '__score') def __init__(self, name, age, score = 0): self.__name = name self.__age = age self.__score = score # 获取score @property def score(self): return self.__score # 设置score value @score.setter def score(self, score): if not isinstance(score, int): raise ValueError('Score必须是int类型！') if score < 0 or score > 100: raise ValueError('Score值必须在0=<score<=100') self.__score = score @property 加了这个装饰器的funcname相当于getfuncname() @score.setter 加了这个装饰器的funcname相当于setfuncname() stu = Student('wuli2', 28) stu.score = 88 print(stu.score) 88
自定义装饰器
@decorator_name即为func_name=decorator_name(func_name)
装饰器为函数
构建
def deco_name(func): def inner(*args,**kwargs): #需要加入的内容（插入日志、性能测试、事务处理、缓存、权限校验） x=func(*args,**kwargs) #需要加入的内容 return y return inner @deco_name def func1(a,b,c): pass func1(1,5,7) #################### @deco_name即为func1=deco_name(func1)=inner 则func1(1,5,7)=inner(1,5,7)
分类
函数装饰函数
def wrapFun(func): def inner(a, b): print('function name:', func.__name__) r = func(a, b) return r return inner @wrapFun def myadd(a, b): return a + b print(myadd(2, 3)) 即myadd=wrapFun(myadd)=inner print(myadd(2, 3))=print(inner(2,3)) 结果 function name: myadd 5
函数装饰类
def wrapClass(cls): def inner(a): print('class name:', cls.__name__) return cls(a) return inner @wrapClass class Foo(): def __init__(self, a): self.a = a def fun(self): print('self.a =', self.a) m = Foo('xiemanR') m.fun() 即Foo=wrapClass(Foo)=inner, m = Foo('xiemanR')=inner('xiemanR')=cls(a)=Foo('xiemanR')同时先完成print('class name:', cls.__name__)语句
装饰器为类
类装饰函数
class ShowFunName(): def __init__(self, func): self._func = func def a(self,b): print('来了，老弟') return self._func(b) @ShowFunName def Bar(a): return a print(Bar.a('asd')) @ShowFunName即为Bar=ShowFunName(Bar)就是将类实例化成对象Bar，Bar.a('asd')即调用方法，执行完print('来了，老弟')后，返回Bar('asd')即返回‘asd' 来了，老弟 asd
类装饰类
class ShowClassName(object): def __init__(self, cls): self._cls = cls def h(self,b): print('来了，老弟') return self._cls(b) @ShowClassName class Foobar(object): def __init__(self, a): self.value = a def fun(self): print(self.value) a = Foobar.h('sdfgh') a.fun() @ShowClassName即Foobar=ShowClassName（Foobar）即ShowClassName实例化后的对象， a = Foobar.h('sdfgh')即该对象调用方法h,完成语句print('来了，老弟')后，返回self._cls(b) 即a=Foobar('sdfgh)再次实例化,a.fun()调用类Foobar的方法 来了，老弟 sdfgh
变量与值
命名
类命名
驼峰法：CapWards
模块、函数、包等命名
小写下划线：cap_wards
面向对象
_开头
赋值
赋值是将一个对象的地址赋值给一个变量
变量=值
变量1，变量2=值1，值2
连等赋值
改变一个可改变对象（list），另一个也变
改变一个不可改变对象（字符串、元组），该变量指向新储存空间，所以另一个值不变
交换赋值
v1,v2=v2,v1
关系
变量是标签，值是数据。
标签可移动，重新对变量赋值，则id()获取的地址将变化
值可以对应多变量
若直接令x=y,id()相同，且用is判断这两个对象相同
x=1,y=1,两个变量的内存地址（用id()获取）可能相同，is判断为False
运算符与表达式
算数运算符
+ - * / 其中/所得为浮点数
//整除 **幂 %求余
赋值运算符
=注意优先级
+= -= *= /= %= **= 在x的基础上进行操作
比较运算符
== != < > <= >=
结果为True或False
逻辑运算符
x and y
若x为false，返回False；x为True，返回y。true=1，false=0（短路计算法则）
x or y
若x为true，返回x；x为false，返回y
not x
x的非
成员运算符
in
x是y容器成员
not in
x不是y容器成员
同一性运算符
is
即id(x)==id(y),判断是否为同一对象
is not
即id(x)!=id(y),判断是否为不同对象
二进制运算符
~按位翻转
>>右移<<左移
&位与
优先级
输入输出
输入
接收输入的变量=input('输出在屏幕的提醒')
输出
print（x）x为“字符串”，数字，变量，列表，元组，字典等
不换行（默认换行）
print(i, end = '' )
格式化输出
数字与字符串
前%用后面%的值代替
进制数
%x十六进制，%d十进制，%o八进制
print("n1 = %x,n2 = %d,n3 = %o" %(nHex,nHex,nHex))
浮点数(float)
%f
字符串 print("the length of (%s) is %d" %('runoob',len('runoob')))
格式要求%[flags][width].[小数位数]type
[flags]
+显示正负、右对齐 -仅有负数符号、左对齐 0用0填充空白、右对齐、仅负号 空格 正前空格负前负号、右对齐
[width]
字段宽(包括正负号与小数点)
[小数位数]
精度
流程控制
if
if expression: statement(s) else: statement(s)
选择
if expression1: statement(s) elif expression2: statement(s) elif expression3: statement(s) else: statement(s)
嵌套
if 表达式1： if 表达式2： 语句块1 else: 语句块2 else: if 表达式3： 语句块3
条件
布尔型
bool()
条件运算符
成员运算符
比较运算符
逻辑运算符
同一性运算符
条件表达式（三元表达式）
x if a else y
如果a满足则执行x,否则执行y
xya可以是函数、表达式、常量等
当xya为函数时,条件函数的（）分两种情况
def put(): print('this is put()') def get(): print('this is get()') def post(): return 0 put() if post() else get() method =put if post() else get method()
this is get() this is get()
while
while 条件： 循环体
while正常结束后执行else，若while被break，则不执行else
while 条件: 循环体 if 条件: break else: 语句
for
通过迭代可迭代对象实现循环
基本结构
for <variable> in <sequence>: <statements> else: <statements>（else可省略）
可迭代对象
容器（多种元素组织在一起的数据结构）
容器对象包括列表、元组、字符串、集合、字典
分类
非迭代器的可迭代对象（序列：字符串、列表……）
所有元素存储在内存的容器，即直接创建的列表、元组等
调用
for x in y:
转换为迭代器再调用
迭代器
调用时才在内存记录一个数据，减少内存
创建
iter()
创建迭代器对象，参数是非迭代器的可迭代对象
>>> b = iter(a) # b是iter函数返回的a的迭代器
>>> c = a.__iter__() # c是对象a调用__iter__方法返回的迭代器
range（）返回可迭代对象（python3）
range(stop) 0到stop-1
range(start, stop[, step]) start到stop-1，步长为step
生成器（每次处理一个对象，更节省内存）
生成器yield
调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值，调用next(),最后返回的是一个迭代器对象。yield代替return，因为一旦有return，函数就终止，但若是yield，还可以用next()继续执行后序代码
在某函数中的循环里加入yield iter_name即可
仿列表推导式
形式
(表达式 for 变量 in 列表)
(表达式 for 变量 in 列表 if 条件)
功能
将列表元素（满足条件）取出，经表达式求出新值，放入迭代器
l=[1,2,3,4,5] print((i**2 for i in l if i<5))
调用
for
for x in iter_name: print(x)
while..next()
next()
调用迭代器下一个元素，超出后弹出StopIteration异常
while True: try: print (next(f), end=" ") except StopIteration: sys.exit()
list(迭代器)
附加语句
break结束循环，不执行else
continue结束本次循环，进入下次循环
pass空语句，仅保持程序完整性
嵌套
函数与模块
函数
函数是对象
func_name代表函数对象，func_name(parameter)的括号告诉编译器要执行该函数
自定义函数
构建(即创建了名为func_name的函数对象)
常规
def func_name(参数): … … return …
匿名函数lambda
name=lambda [arguments] : expression调用时name(赋值)
变量作用域
python依据命名空间（变量定义位置）区分变量作用域。命名空间有：局部、全局、内建；函数访问变量即依据此顺序搜索。
局部变量
定义在函数体内的变量，无法在函数外调用
全局变量
global 变量名 （可以在函数外调用）
参数
默认参数
def func_name(c1,c2,c3=default1，…)即加上=和默认值，当函数未接收到实参时，按默认参数处理。注：多个参数时，默认参数设在最右侧
关键参数
不按顺序传参
def func_name(c1,c2,c3=default1，…)调用时func_name(c2=x,c1=y,)
冗余参数
单个*
def func_name(c1,*c2)可变长度参数放于右侧，前加*。*parameter是用来接受任意多个参数并将其放在一个元组中。
>>> def demo(*p): print(p) >>> demo(1,2,3) (1, 2, 3)
函数在调用多个参数时，在列表、元组、集合、字典及其他可迭代对象作为实参，并在前面加 *，即解包.注：若为字典，则传入的是key
>>> def d(a,b,c): print(a,b,c)>>> a=[1,2,3] >>> d(*a) 1 2 3
**
把该函数的参数转换为字典
>>>def demo(**p): for i in p.items(): print(i) print(p) >>>demo(x=1,y=2) ('x', 1) ('y', 2) {'x': 1, 'y': 2}
函数在调用多个参数时，以字典作为实参，在前面加 **，即解包。注：字典key要和函数形参一致。
def d(a,b,c): print(a,b,c) a={'a':1,'b':2,'c':3} d(**a)
1 2 3
使用
直接调用
func_name(parameters)
实例化
变量x指向func_name函数对象，实例化后再调用
x=func_name x(parameters)
内建函数
filter(函数，可迭代对象)
过滤序列：函数为判断函数，不加括号，filter将True的可迭代对象元素返回成迭代器
def is_odd(n): return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) newlist = list(tmplist) print(newlist)
[1, 3, 5, 7, 9]
map(函数，可迭代对象1，可迭代对象2)
将两序列同索引值传入函数（不加括号），返回执行完后的迭代器
x=[1,2,3,4] y=[1,2,3,4] def f(a,b): return a*b v=map(f,x,y) print(list(v))
[1, 4, 9, 16]
装饰器decorator
模块
模块导入与方法调用
解释器搜索模块的顺序：当前目录，shell变量下的PYTHONPATH所有目录，默认安装路径
导入所有方法
import module_name
调用模块中方法 module_name.func()
import module_name as x
调用模块中方法 x.func()
from module_name import * 不推荐
调用模块中方法 func_name()
导入某个方法
from module_name import func_name，但*不推荐
调用模块中方法 func_name()
包
包的本质就是一个包含__init__.py文件的目录，是一个有层次的文件目录结构，它定义了由n个模块和n个子包
导入时 import pak.module
__name__
若执行该脚本，则__name__='__main__';若该脚本作为模块被导入别的脚本，则为该脚本文件名
if __name__=='__main__': 函数体
即保证仅执行该脚本时运行函数体，而作为模块导入时，不运行函数体，防止多次运行。
if __name__ =='__main__' and sys.argv[1]=='train':
当脚本中想根据不同外部指令执行不同任务时，利用sys.argv获取，[0]为脚本的绝对路径，[1:]为运行时输入的指令列表
文件、数据持久化
文件分类
文本文件
可读，通过文本编辑器直接打开
二进制文件
不可读
文件路径
绝对路径
'F:/pythpractice/vs/t.txt'
'F:\\pythpractice\\vs\\t.txt'
os.getcwd()+'\\t.txt'或'/t.txt'
相对路径
'./t.txt'其中.表示当前目录，..表示父目录
文件读写
open()
open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，但只是创建了文件链接管道对象。
f=open(file, mode)
参数1为文件路径和名称
参数2为模式，默认为文本模式。
t 文本模式 (默认)。
x 写模式，新建一个文件，如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式（不推荐）。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
f为文件对象
读取方法
读取全部
f.read()
逐行读取
f.readline()
按行读取，存为列表
f.readlines()
写入方法
文本文件写入
一次性写入
f.write(str)
按行一次性写入
f.writelines(字符串元组、列表)仍然要加\n
二进制流写入
文件打开模式带 b，写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式
异常处理
程序运行错误
非异常
语法错误
逻辑错误
异常
运行错误
作用：提供出现异常需要调用的代码，否则程序停止并报错
内置异常类
- BaseException # 所有异常的父类 - SystemExit # 由sys.exit()抛出的异常 - KeyBoardInterrupt # 通常由ctrl+c或者Delete抛出的异常 - GeneratorExit # 当生成器被关闭时抛出的异常 - Exception # - StopIteration # 迭代结束异常 - StopAsyncIteration # 由异步迭代的`__anext__()`抛出的异常 - ArithmeticError # 各种算数错误引起的异常 - FloatingPointError # 浮点数操作错误 - OverflowError # 结果超出范围 - ZeroDivisionError # ０为除数异常 - AssertionError # assert错误异常 - AttributeError # 属性引用异常 - BufferError # 缓存错误 - EOFError # 读不到数据 - ImportError # import错误 - ModuleNotFoundError # 找不多模块 - LookupError # 由索引和key值引起的异常 - IndexError # 索引错误 - KeyError # 字典key值错误 - MemortError # 内存溢出异常 - NameError # 本地和全局找不到变量名 - UnboundLocalError # 局部变量没有赋值 - OSError # system错误 - BlockingIOError # 调用阻塞异常错误 - ChildProcessError # 子进程 - ConnectionError # 连接 - BrokenPipeError # 管道读写异常 - ConnectionAbortedError # 连接失败 - ConnectionRefusedError # 连接拒绝 - ConnectionResetError # 连接重置 - FileExistsError # 创建文件和文件夹错误 - FileNotFoundError # 文件未找到 - InterruptedError # 中断错误 - IsADirectoryError # 文件操作用在文件夹上 - NotADirectoryError # 不是文件夹 - PermissionError # 权限 - ProcessLookupError # 进程不存在 - TimeoutError # 超时 - ReferenceError # 引用异常 - RuntimeError # - NotImplementedError # 运行抽象方法 - RecursionError # 超出最大递归深度 - SyntaxError # 语法错误 - IndentationError # 缩进错误 - TabError # tab错误 - SystemError # 解释器中断 - TypeError # 类型错误 - ValueError # 赋值错误 - UnicodeError # - UnicodeEncodeError # unicode编码错误 - UnicodeDecodeError # unicode解码错误 - UnicodeTranslateError # unicode转换错误 - Warning # - DeprecationWarning # 操作不赞成警告 - PendingDeprecationWarning # 表明此操作将来会被弃用 - UserWarning # 用于用户生成警告 - SyntaxWarning # 语法可疑警告 - RuntimeWarning # 运行警告 - FutureWarning # 将会改变警告 - ImportWarning # 导入警告 - UnicodeWarning # unicode相关警告 - BytesWarning # 字节相关警告 - ResourceWarning # 资源使用情况警告
捕获和处理异常
基本语句
try： 语句块 #被监控的语句 except 异常类名: 语句块 #处理异常 except 异常类名: 语句块 #处理异常 else: 语句块 #若无异常执行的语句
finally强制执行
与try…except配合，强制执行如文件关闭等必须执行的语句
try： f=open("test.txt",'r') print(f.read()) except IOError: print('file does not exist') finally: try: f.close() except NameError: pass
顶级异常捕获
try： 语句 except BaseException as err: print err
主动抛出异常
raise 内置异常类名('附加信息')写在try内
s='123456' try: if len(s)>5: raise Exception("超了") except Exception as err: print(err) 超了
自定义异常类
class myerror(Exception): def __init__(self,length,least): self.length=length self.least=least s='123456' try: if len(s)>5: raise myerror(len(s),5) except Exception as err: print('myerror:输入长%s,超过了%d'%(err.length,err.least))
myerror:输入长6,超过了5
assert
断言：条件不满足时，出现崩溃提醒
assert 条件,"报错提醒"
a=2 assert a>5,"a要大于五"
AssertionError Traceback (most recent call last) <ipython-input-47-4b71535056ea> in <module>() 1 a=2 ----> 2 assert a>5,"a要大于五" AssertionError: a要大于五
进阶知识
图形用户界面GUI
可执行文件
数据库
多线程编程
网络应用
正则表达式
基本规范
注释
单行
用于变量注释
#
多行（docstring文档字符串）
用于类文档、函数文档、字符串
用两个"""包裹，
"""概述（以.?!结尾） 空一行 剩下的部分 """
Shebang
用于Linux和UNIX帮助内核找到python解释器
#!/usr/bin/env python
中文问题
python2
解释器默认ASII编码
八位（一个字节）表示英文与西欧语言，仅256个符号
必须文件开头加#-*-coding:utf-8-*-，保证中文不报错
python3
解释器默认UTF-8编码
Unicode万国码，两个字节，16位，表示65536个符号
UTF-8是对Unicode的压缩优化，ASII用1字节，欧洲字符用2字节，东亚用3字节..
不必注释
空白
空格
（）内不加空格。 ,;:前不加空格，后面可以加。 =在指示关键字或默认参数时，前后不加空格。
二元操作符前后加空格
空行
函数以及类定义间空两行，其余空一行
缩进
场景
对齐
函数多变量时，换行后与首变量对齐。或者变量全部写在下一行，要空4格。
字典
for with 等后面有:
用法
4个空格或一个TAB，不可混用，
获取帮助
模块的属性
dir(module_name)
模块与方法的具体使用
help(module_name)
help(module_name.方法)