抽空整理了下Python的笔记，可能有点不全，不过过一遍大概就好….

Python笔记

版本

Python 2.7

控制流

while循环

1
2
while True:
  pass

判断条件为真则继续循环

for循环

1
2
3
L = [1,2,3,4]
for i in L:
  print L[i]

可遍历序列结构的类型

1
2
for i in range(1,3):  #range能生成等差数列，这种方式可转换成C语言的for循环
  pass

if

1
2
3
4
5
6
if x<5:
  pass
elif x<=10:
  pass
else:
  pass

if常见三段式

else的特别用法

当循环中存在break时，可以配合else使用

1
2
3
4
5
6
while x>5:
  if x<7:
    break
  x*=2
else:
  pass

当循环的条件为假并且非break打破循环条件时，就会执行else语句

1
2
3
4
5
6
try:
  raise MyError
except NameError:
  pass
else:
  pass

如上，当try块的语句执行完并且没有异常时，就会执行else中的语句

有用的杂项

range

生成等差数列的列表
用法:range(起点,不包含的终点,步长)

1
2
range(1,6,2) #[1,3,5]
range(1,4) #[1,2,3]

pass

代表什么都不做,忽略至少一条语句的要求

1
2
while x>5:
  pass

逻辑运算

python的逻辑运算使用”or”,”and”,”not”关键字,其中or和and都是短路操作

is,in

is,is not用于判断是否为相同对象。in,not in用于判断一个值是否存在于序列或集合中

切片

1
2
3
4
5
6
alist = [1,2,3,4,5]
print alist[:]    # 从头到尾输出
print alist[1:]   # 从index为1开始到末尾输出
print alist[2:4]  # 从index为2开始到index为4输出，但不包括4
print alist[-1]   # 输出倒数列表的倒数第一个
print alist[-3:-1] # 输出倒数第3到倒数第1(不包括倒数第一)

函数

普通函数

1
2
def func(value1, value2=3):
  return value1*value2  #可以没有return

当函数给出默认值时可以不传对应的参

1
2
f = func
f(1,2)

函数名还可以赋值给变量

匿名函数

1
2
f = lambda x1,x2: x1*x2
f(1,2)

常用于简单的函数

数据结构

List

用”[]”表示
常用方法：

方法 描述
list.append(x) 将x元素添加到list末尾
list.extend(L) 将列表L加入到list末尾
list.insert(index,x) 在list的index索引之前插入x
list.remove(x) 删除列表中第一个值为x的元素，如果没有这样的元素会报错
list.index(x) 返回第一个元素为x的的索引，没有的话会报错
list.pop(index) index参数可选,删除指定位置并且返回该元素,index不选默认删除最后一个
list.count(x) 返回列表中x出现的次数
list.reverse() 原地反转列表中的元素
list.sort(cmp=None,key=None,reverse=False) 列表排序
filter(function,List) eg. filter(lanmbda x:x%2==0,range(0,9)),迭代List每一项，根据function判断是否过滤
map(function,List) List的每一项都调用function(item)并返回结果
reduce(function,List,value) List的前两项放入function(x,y)中,返回结果后和下一个元素继续调用,value为初始值可选,以免列表为空时返回异常,一般初始值设置0

列表推导式:

1
squares = [x**2 for x in range(10)] # [0,1,4,9,16,25,36,49,64,81]

del语句可以用于从列表中删除切片或者清除整个列表

1
2
3
4
del a[2:4]
del a[2]
del a[:]  # 清除列表
del a     #删除a这个变量

Tuples(元组)

用”()”表示

可变类型与不可变类型:

是否可变 具体
可变类型 列表,字典
不可变类型 元组,数字,字符串

元组 不能 改变(删除)组内元素值，元组可以拆分赋值。

1
2
3
t1 = (1,2,3) # t1 = 1,2,3  亦可
# t1[0] = 2  # 错误
x,y,z = t1   # 此时 x=1 y=2 z=3

元组常用操作:

方法 描述
t.count(x) 计算x在元组内出现的次数
t.index(‘a’,1,4) 在索引1,3内寻找元素a，并返回其索引,后两个参数可选
len(t) 计算t的长度

Set(集合)

用”{}”表示,不过打印的时候会变成”set([k,w,x])”
无顺序且不重复,常用于去重

1
s = {1,2,3}

常用操作:

方法 描述
s.add(x) 将x元素添加到集合中
s.remove(x) 在集合中删除x元素
s.update([1,2,3]) 用于更新多项
x in s 判断x元素是否在集合内,反操作not in
s.issubset(t) 判断s是否是t的子集,反操作issuperset
s.union(t) 将s与t合并
s.intersection(t) s与t的交集
s.difference(t) s-t
s.copy() 返回s的浅克隆

集合推导式:

1
a = {x for x in 'xdsfsd' if x not in 'abc'}

Dictionary(字典)

用{key1:value1,key2:value2}表示
实质为键值对,key为不可变类型,可以用于不包含对象的元组表示
常用操作:

1
2
3
4
di = {"name1":1 , "name2":2}
di["name3"] = 3
dict([('kkk',213),('dff',324)])  #函数方法创建字典
di.keys()  #获取字典键的集合

遍历技巧

对于序列类型(List,String,Tuples,range)遍历方法:

1
2
for index,value in enumerate(['abc','cba']):
  print index , value

对于集合:

1
2
for item in {'a','b'}:
  print item

对于字典:

1
2
for k,v in {'aaa':1}.iteritems():
  print k,v

模块化

在python中一个python文件可以看作是一个模块，而文件夹可以看作是一个包。

1
2
3
4
5
6
7
# 假设存在同目录下 test.py
import test
test.xx()  #调用test模块定义的函数
# import的变体
from test import func
func()
from A import B  #这里的B可以是函数,类,变量

执行模块

1
2
3
if __name__ == "__main__":
  import sys
  func(sys.argv[1])

此时该py文件可以作为执行脚本使用,其中argv[0]为脚本的名字,argv[1]为往后给脚本的传值

导入其他文件夹里的模块

第一种方法是在其他文件夹内创建”init.py”文件,使该文件夹成一个包

1
2
# 在创建的__init__.py中可以设置__all__变量
__all__ = ['xxxxxMod','xxMod']  # 此时当其他模块使用from xx import * 引入该模块时才会生效

第二种方法可以利用sys.path

1
2
import sys
sys.path.append('./xxx')

输入输出相关

输出方式

1
2
print "xxx"
sys.stdout.write('xxxx')

将其他类型转换为字符串

1
2
str(12312.55)
repr(255.332131)

字符串格式化

1
2
"test:{0},{text}".format("content",text="text")
"float:{0:.3f}".format(0.1)  # 如果有精度需求的话

标准输入

1
sys.stdin.readline().strip('\n')  # strip函数用于去除头尾的字符

文件操作

1
2
3
4
5
6
f = open(filename,mod)  # mod 可选w,r,a
f.write(xxx)  # 写文件
f.readline()  # 读文件
f.close()     # 关文件
with open('filename.txt','a') as f:   # with语句可以在使用完文件时关闭
  f.read()

json操作

1
2
3
import json
str = json.dumps({"key1":1})  # 内置类型转json字符串
di  = json.loads(str)         # json字符串转内置类型

异常

异常处理

1
2
3
4
5
6
7
8
9
10
try:
  raise NameError('abc','bcd')
except NameError as e:
  print e.args
except (xxError,xxxError):
  pass
else:      # 在try语句中灭有抛出异常后则执行else操作
  pass
finally:   # finally语句总会执行
  pass

被捕获的异常重新抛出

1
2
3
4
try:
  raise MyError()
except MyError:
  raise

自定义异常

自定义的异常只需直接或间接继承Exception即可:

1
2
3
4
5
class MyError(Exception):
  def __init__(self,value):
    self.value = value
  def __str__(self):
    return repr(self.value)

常见异常

异常名 描述
AssertionError assert（断言）语句失败
AttributeError 试图访问一个对象没有的属性
IOError 输入/输出异常,文件无法打开等
ImportError 无法引入模块或者包,导入路径可能出现问题
IndentationError 语法错误,缩进问题
IndexError 下标越界
KeyError 试图访问字典里不存在的键
KerboardInterrupt 键盘中断
NameError 使用一个还未被赋值予对象的变量
SyntaxError Python代码非法
TypeError 传入对象类型与要求的不符
UnboundLocalError 全局变量与局部变量同名，并且局部变量还没赋值
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

针对UnboundLocalError,全局变量在内部的作用域是 只读的 ，若进行赋值操作的话，解析器会认为在局部创建了同名的局部变量

1
2
3
4
value = 10    #全局变量
def func():
  print value # 此时局部还没有value变量,因此输出全局的value变量
  value = 20  # 创建了"value"同名局部变量

1
2
3
4
5
6
7
8
9
value = 10
# 以下会引发UnboundLocalError错误:
def func():
  value = value + 10
# 若想在内部作用域改变全局变量:
def func1():
  global value
  value = value + 10

面向对象

类

1
2
3
4
5
6
7
8
9
10
11
12
class MyClass:
  data = 1                     # 类变量,所有实例都共享
  def __init__(self,name):     # 构造函数
    self.name = name           # 实例变量,实例间不共享
  def func(self):              # 成员方法,因语法需要self必加,调用时无需关注self
    pass
  @classmethod
  def foo(cls):                # 类方法,因语法需要cls必加,调用时无需关注cls
    pass
obj = Myclass(1)               # 实例化
obj.func()

若成员变量与成员方法同名时,会覆盖成员方法

继承

1
2
3
4
5
6
7
# 如果与父类在同一个全局域
class Son(FatherClass):
  pass
# 如果与父类不在同个全局域
import OtherMod
class Son(OtherMod.Father):
  pass

子类可以重写父类方法,只需同名覆盖即可

继承相关的方法

方法 描述
isinstance(obj,class) 检查obj是不是class的实例
issubclass(SonClass,FatherClass) 判断是否是子类

多继承

1
2
class Son(F1,F2,F3):
  pass

对于调用父类成员,按照顺序先搜索F1,再搜索F2

私有变量

1
2
3
4
5
6
7
class A:
  def __init__(self):
    self.__age = 10      # 私有实例成员变量
  def __func(self):      # 私有成员方法
    pass
# obj.__func()           # 不能成功调用
obj._A__func()           # 可以成功调用

迭代器

若类实现了iter和next方法,则可以使用迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]
rev = Reverse('test')
it = iter(rev)
it.next() # 若下一个元素为空时则抛出StopIteration异常

生成器

带有yield的函数都是生成器.
yield与return一样,可以返回一个值,不过当返回了一个值后,会接着执行yield下一行的语句.
生成器也是可以迭代的,常用的就是循环里面使用yield,这样可以节省内存.

1
2
3
def reverse(data):
  for index in range(len(data)-1,-1,-1):
    yield data[index]

常用的标准库

模块名 描述
os模块 可以与操作系统交互的模块,如执行系统命令
glob模块 通配符搜索指定路径的文件 glob.glob(pathname)
sys模块 常用于与命令行执行脚本时,获取命令行参数,标准输入输出错误输出. sys.exit()/sys.stderr.write()
re模块 正则表达式匹配字符串
math模块 提供数学运算
random模块 提供随机选择
urllib2,smtplib模块 访问网络和发送邮件
datetime模块 处理日期时间
zlib模块 数据压缩
threading模块 多线程相关
logging模块 日志系统
decimal模块 十进制浮点数,用于财务等精度需求