导图社区 python知识网
纯干货!你要的Python基础知识点整理好了!本文对变量、语法、条件循环、面向对象、函数、语法规则符、文件的读取及保存、错误异常这些方面进行了全量笔记整理,这些知识点你还记得吗?
编辑于2019-08-14 05:30:27python
基础知识
对象和类型
对象是某种类型的实例 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 # 0为除数异常 - 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.方法)