python-V

异常处理与调试

1. 错误

•有的错误是程序编写有问题造成的,比如本来应该输出整数结果输出了字符串,这种错误我们通常称之为 bug,bug 是必须修复的。
•有的错误是用户输入造成的,比如让用户输入 email 地址,结果得到一个空字符串,这种错误可以通过检查用户输入来做相应的处理。

•还有一类错误是完全无法在程序运行过程中预测的,比如写入文件的时候,磁盘满了,写不进去了,这类错误也称为异常,在程序中通常是必须处理的,否则,程序会因为各种问题终止并退出。

2. 错误处理

• 在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码;
• Python语言通常都内置了一套 try...except...finally... 的错误处理机制。

try:

print 'try...'
r = 10 / 0
print 'result:', r
except ZeroDivisionError, e:
print 'except:', efinally:
print 'finally...'
print 'END'
- 用 try 来运行可能会出错的代码;
- 如果执行正确,则except 语句块不会执行;
- 如果执行错误,直接跳转至错误处理代码,即except语句块;
- 如果有 finally 语句块,不管try语句块内容是否正确,都会执行 finally语句块。
• 错误有很多种类,如果发生了不同类型的错误,应该由不同的 except语句块处理。因此可以有多个 except 来捕获不同类型的错误。
eroDivisionError:', e
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
• Python 的错误其实也是 class,所有的错误类型都继承自BaseException;
• 在使用except 捕获该类型的错误,还把其子类也“一网打尽”;
•常见的错误类型和继承关系看这里:

https://docs.python.org/2/library/exceptions.html#exception­hierarchy。

3. 读懂复杂的错误

•解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链。
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
bar('0')

main()

4. 记录错误

• 不捕获错误,Python 解释器会打印出错误信息,但程序也被结束;
• 捕获错误,就可以把错误信息打印出来,然后分析错误原因,同时,让程序继续执行下去。

• Python 内置的 logging 模块可以记录错误信息。logging.exception(e)

5. 抛出错误

• 错误是 class,捕获一个错误就是捕获到该 class 的一个实例;
• Python 的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。
• 可以定义一个错误的 class,选择好继承关系,然后,用raise 语句抛出。
一个错误的实例;
• 尽量使用 Python 内置的错误类型抛出错误
class FooError(StandardError):
pass
def foo(s):
n = int(s)
if n==0:
raise FooError('invalid value: %s' % s)

return 10 / n

6. 调试- print

第一种方法简单直接粗暴有效,就是用 print 把可能有问题的变量打印出来看看。用 print 最大的坏处是将来还得删掉它,运行结果也会包含很多垃圾信息。

7. 调试- 断言

• 凡是用 print 来辅助查看的地方,都可以用断言(assert)来替代:;
• 如果断言失败, assert 语句本身就会抛出 AssertionError
assert n!=0
assert hello() = "hello"

• Python 解释器执行时可以用 -O 参数来关闭 assert,把所有的 assert 语句当成 pass。

8. 调试- logging

• logging 不会抛出错误,而且可以输出到文件;
• logging.info() 就可以输出一段文本到日志文件中。
• logging.basicConfig(level=logging.INFO)指定记录信息的级别,有 debug , info , warning , error等几个级别。

import logging

s = '0'

n = int(s)
logging.basicConfig(filename="/home/kiosk/hello.log
",level=logging.INFO)
logging.info('n=%d' %n)

print 10/n

9. 调试- pdb

•pdb
pdb让程序以单步方式运行,随时查看运行状态。n 可以单步执行代码,p 变量名 来查看变量,q 结束调试,退出序。
•pdb.set_trace

在可能出错的地方放一个 pdb.set_trace() ,就可以设置一个断点。程序会自动在 pdb.set_trace() 暂停并进入 pdb 调试环境, p 查看变量, c 继续运行。

                                                                                    正则表达式

正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一
个规则,凡是符合规则的字符串,我们就认为它“匹配”了,否则,该字符串就是不合法的。

1. 基本模式
• 字面模式: 就是字面长量,就代表其本身
• . 匹配任何字符
• \w 匹配一个单词(字母) \W 匹配非字母
• \s 匹配空白 \S 匹配非空白字符
• \d 匹配数字
• ^ 开头 $ 结尾
• \ 转义字符

2. 次数的匹配
次数的匹配 , 匹配其前面的字符出现的次数 :
• * 0 次或多次
• + 一次或多次
• ? 零次或一次
• {n} 出现 n 次
• {m,n} 出现 m 到 n 次

3. 中括号
• 中括号用于指向一个字符集合
• 中括号可以使用元字符
• 中括号中的. 表示其字面意思
[a-z] [A-Z] [0-9] [A-Za-z]

• [0-9a-zA-Z\_] 可以匹配一个数字、字母或者下划线;
• [0-9a-zA-Z\_]+ 可以匹配至少由一个数字、字母或者下划线组成的字
符串;
• [a-zA-Z\_][0-9a-zA-Z\_]{0, 19} 更精确地限制了变量的长度是 1­20
个字符;
•A|B 可以匹配 A 或 B
•^\d 表示必须以数字开头
• \d$ 表示必须以数字结束思考
• 判断一个字符串是否是合法的 Email 的方法;

• 判断满足029-1234567这样要求的电话号码的方法;

4. re 模块
r = r'hello'
re.match(r, 'hello')
re.match(r, 'westos')
match() 方法判断是否匹配,如果匹配成功,返回一个 Match
对象,否则返回 None 。

5. 分组
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
m.group(0)
m.group(1)
m.group(2)

6. 贪婪匹配
正则匹配默认是贪婪匹配,也就是匹配尽可能多的字符
>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')。
\d+ 采用贪婪匹配,直接把后面的 0 全部匹配了,结果 0* 只能匹配空字符串贪婪匹配正则匹配默认是贪婪匹配,也就是匹配尽可能多的字符。
• 必须让 \d+ 采用非贪婪匹配(也就是尽可能少匹配),才能把后面的 0 匹配出
来,加个 ? 就可以让 \d+ 采用非贪婪匹配

7. 编译
当我们在 Python 中使用正则表达式时,re 模块内部会干两件事情:
1. 编译正则表达式,如果正则表达式的字符串本身不合法,会报错;
2. 用编译后的正则表达式去匹配字符串。
重复使用几千次,出于效率的考虑,我们可以预编译该正则表达式。
r = r'hello'
r_compile = r.compile(r)
r_compile .match()练习

8. 总结
• re.match(p,text) :p 为正则表达式模式, text 要查找的字符串,会返回一个match 对象
• re.search(p,text) : 只要在 text 中匹配到了 p 就返回,只返回第一个匹配到的。
• re.findall(p,text) :将能匹配上的全返回,会返回一个 list。
• re.split(p,text) : 按照 p 匹配,并且以匹配到的字符为分隔符切割 text, 返回一个切割后的 list
• re.sub(p,s,text) : 替换,将 p 匹配到的字符替换为 s.
• pattern = re.compile(p) 先编译 p 模式,当正则表达式模式比较复杂的时候,会先编译,然后再使用。

MySQL 数据库

1. 使用 MySQL
MySQL 是 Web 世界中使用最广泛的数据库服务器。MySQL 内部有多种数据库引擎,最常用的引擎是支持数
据库事务的 InnoDB。

2. 安装MySQL
• 一定要进行设置密码,确保数据库安全;
• 配置文件为/etc/my.cnf;
• 修改数据库默认的编码全部改为 UTF­8;
• 查看编码格式:show variables like '%char%';
• 安装MySQL­python,封装了 MySQL C 驱动的 Python 驱动。

3. 建立MySQL连接
conn = MySQLdb.connect(host='localhost', \
user='root',passwd='123456', \
db='testpython', \
port=3306,charset='utf8')
•host : MySQL 数据库地址
•user: 数据库登陆用户名
•passwd: 数据库登陆密码
•db: 登陆数据库后,需要操作的库名
•port: 数据库监听端口,默认为 3306
•charset: 数据库编码

4. MySQL连接操作
• commit() 如果数据库表进行了修改,提交保存当前的数据。
• rollback() 如果有权限,就取消当前的操作,否则报错
• cursor() 游标指针。

5. 游标操作
# 创建一个数据库游标
In [3]: cur = conn.cursor()
cursor() 提供的方法来进行操作,方法主要是 :
1. 执行命令
2. 接收结果游标操作
cursor 执行命令的方法:
•execute(query, args): 执行单条 sql 语句。 query 为 sql 语句本身, args 为参数值的列表。执行后返回值为受影响的行数。
•executemany(query, args): 执行单条 sql 语句 , 但是重复执行参数列表里的参数 , 返回值为受影响的行数
conn.commit()                                                              # 提交事务

6. 插入数据
日常工作中,大多数会先拼接一个 SQL 语句 然后再执行,实现插入数据的操作:
sql = "INSERT INTO member (username,password,email)
values ('%s','%s','%s')" % ('walter.liu','123456','zheshiz2@163.com')
cur.execute(sql)
conn.commit()

7. 查询数据
• fetchall(self): 接收全部的返回结果行 .
• fetchmany(size=None): 接收 size 条返回结果行 . 如果 size 的值大于返回的结果行的数量 , 则会返回 cursor.arraysize 条数据 。
• fetchone(): 返回一条结果行 .
• scroll(value, mode='relative'): 移动指针到某一行 .
如果 mode='relative', 则表示从当前所在行移动 value 条 ;
如果 mode='absolute', 则表示从结果集的第一行移动 value 条;

常用模块

1. OS 模块
• 为访问操作系统的特定熟悉提供方法
• 提供了对平台模块的封装(对 windows, 对 mac 的封装等)。
•os.environ                                      对环境变量的操作
• os.getcwd()                                    获取当前的工作目录
• os.access(path,mod)
判断对一个文件或者目录是否具有指定的权限；
mode 参数的可选值: ROK, WOK, 和 X_OK。
•os.stat()                                             相当于 Linux 下 stat 命令
• os.listdir()                                         列出给定目录的内容
• os.mkdir(path)                                 创建目录
• os.mkdirs(path)                                创建目录树,相当于mkdir -p 操作
• 使用 Python 执行 Linux 命令
•os.system , 并没有返回值,是靠副作用产生输出的
•os.popen 返回一个文件对象
•os.popen2 返回两个文件对象,一个是 stdin, 一个是 stdout
•os.popen3 返回三个文件对象 :stdin,stdout,stderr。

2. os.path 模块
os.path 是os 的一个子模块 , 主要是对路径进行解析、创建、测试和其他的一些操作,封装了不同平台的路径操作。

• 路径解析:
•path.split('/tmp/test/ab')
• path.basename('/tmp/test/ab')
• path.dirname('/tmp/test/ab')
• path.join('a','b','c')
• path.abspath('.')
• path.splitext('aaa.tar.gz')

文件属性相关:
• os.path.getatime ('filename')
• os.path.getctime ('filename')
• os.path.getmtime ('filename')
• os.path.getsize('filename')

文件测试相关:
• os.path.isabs
• os.path.isdir
• os.path.isfile
• os.path.islink。

3. sys模块
sys 模块,主要提供了系统相关的配置和操作,封装了探测、改变解释器runtime 以及资源的交互。
• sys.version                                            得到解释器的版本信息
• sys.platform                                           得到当前运行平台sys模块
•sys.argv 获取传递给脚本的参数,参数解析类似于 bash 的方式,第一个参数代表脚本本身;
print sys.argv                                                    #以列表方式返回传递给脚本的参数
• sys.stderr , sys.stdin , sys.stdout 这些都分别代表一个文件对象;
print >> sys.stderr, 'I am error'sys模块
练习:
找出用户给定目录下的所有以.log结尾的文件。

4. time模块
python中表示时间的三种方式:
1. 时间戳                                            ##time.time()
2. 格式化的时间字符串
3. 元组(共9个元素)                            ##time.localtime()
time.mktime(t)                                 ##将元组格式时间转化为时间戳
time.localtime()                                ##将时间戳转化为元组格式时间
time.sleep(secs)
time.ctime([secs])                           ##将时间戳转化为字符串格式显示
time.strftime(format[,t])                  ##将元组格式时间转化为字符串显示
time.strptime(string[,format])         ##将字符串显示转化为元组格式时间
• time.strftime("%Y-%m-%d %X", time.localtime())
• time.strptime('2017-07-16 07:28:49','%Y-%m-%d %X')

运维应用

1. 文件操作
• shutil模块简单来说是用来复制、归档文件和目录
• shutil.copyfile(src,dst) 复制一个文件
• shutil.copymod(src,dst) 复制文件权限 , 将文件权限同步到其他文件。
• shutil.copy(src,dst) 源必须是文件,但是 dst 可以是文件或者目录,与cp 类似。

2. shutil 模块
• shutil.copy2(src,dst) 与 copy 类似,但是源数据也会复制,类似cp -p 命令,将权限 , 时间戳等源数据也复制过去。
• shutil.copytree(src,dst) 以copy2 的方式递归复制一个目录:
• shutil.rmtree(path) 递归删除一个目录。

• 打包压缩:
shutil.make_archive(base_name, format, root_dir=None,
base_dir=None)
•basename: 打包后的文件名称,
•format: 以什么样的格式打包, rootdir 压缩的根目录。
•base_dir 开始压缩的目录。
•rootdir 和 basedir 默认都是当前目录。

• 查看都支持哪些打包格式:
shutil.get_archive_formats()

3. 进程管理
•psutil 是一个第三方模块,需要单独安装 : easy_install psutil。
•/proc 目录中的主要文件的说明只简单列出几个经常用到监控中的文件
•/proc/cpuinfo CPU 信息
•/proc/loadavg 系统平均负载信息
•/proc/meminfo 内存相关信息,包括物理内存和交换分区
•/proc/swaps 交换分区使用情况。
案例：
• 备份/home目录,备份的包名称为homeback_YY_MM_DD.tar.gz

文件差异对比

1. 文件差异对比
示例1:
import difflib
text1 = 'hello westos'
text2 = 'hello zhan'
text1_lines = text1.splitlines()
text2_lines = text2.splitlines()

# 创建diff对象
d = difflib.Differ()
# 采用compare方法对字符串进行比较
diff = d.compare(text1_lines, text2_lines)
# print list(diff)
print '\n'.join(list(diff))

'-' 包含在第一个中,但不包含在第二个中
'+' 包含在第二个中,但不包含在第一个中
' ' 两者相同
'?' 两个存在增量差异
'^' 标志出两者行存在的差异字符文件差异对比
示例2:
d = difflib.HtmlDiff()
print d.make_file(text1_lines, text2_lines)
在执行代码时,python xx.py > diff.html配置文件的差异对比
思考:
有两个配置文件,通过html页面显示两个配置文件之间的差异。
思路:
先读取两个文件的内容;
比较文件内容的不同,和前面操作没区别。

socket编程

1. socket编程
Socket 是网络编程的一个抽象概念。通常我们用一个 Socket 表示“打开了一个网络链接”,而打开一个 Socket 需要知道目标计算机的 IP地址和端口号,再指定协议类型即可。

2. 客户端操作
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 建立连接:
s.connect(('127.0.0.1', 9999))
# 接收欢迎消息:
print s.recv(1024)
for data in ['Michael', 'Tracy', 'Sarah']:
# 发送数据:
s.send(data)
print s.recv(1024)
s.send('exit')
s.close()

3. 服务端操作
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 监听端口:
s.bind(('127.0.0.1', 9999))
s.listen(5)
print 'Waiting for connection...'
while True:
                       # 接受一个新连接:
                       sock, addr = s.accept()
                       # 创建新线程来处理 TCP 连接:
                       t = threading.Thread(target=tcplink, args=(sock, addr))
                       t.start()
s.close()
print 'Connection from %s:%s closed.' % addr

def tcplink(sock, addr):
    print 'Accept new connection from %s:%s...' % addr
    sock.send('Welcome!')
    while True:
                data = sock.recv(1024)
                time.sleep(1)
                if data == 'exit' or not data:
                    break
                sock.send('Hello, %s!' % data)