Python_Base

包结构

Java 和 Python 都有类似 ClassPath、PythonPath 的概念，即程序查找路径，Java 虚拟机或者 Python 编译器，会从这些路径中查找你程序中所使用的包/模块；
__init__.py

是要想让一个文件夹成为包的必须的文件，这个文件可以为空，但是必须得有；
使用特殊变量 __all__ 用来模糊导入：__all__ = ["Module1", "Module2", "subPackage1", "subPackage2"]；
编写 Python 代码，不建议这么做；

setup.py，是用来安装模块用的，该文件会定义此项目中有哪些模块需要被加入到 PythonPath，在这个过程中可以把测试项目过滤掉，需要的第三方依赖，使用安装命令可以同时安装这些第三方依赖等等，不同项目里可能需要使用第三方模块的不同版本，如果所有模块都是安装到 PythonPath，就可能造成不同版本的冲突，因此 Python 引入了 Virtualenv 这个概念，为不同项目引入不同的 PythonPath 进行隔离；

输入输出

1
# ==== input and output ==== print("Hello World"); # 遇到逗号，在拼接字符串的时候自动添加空格 print("Hello", "World"); # name = input(); # print("Hello", name); name = "HymanHu"; print("Hello %s"%name); first_name = "Hu"; last_name = "Hyman"; print("Hello %s%s"%(last_name, first_name));
1
# ==== input and output ====
2
print("Hello World");
3
# 遇到逗号，在拼接字符串的时候自动添加空格
4
print("Hello", "World");
5
# name = input();
6
# print("Hello", name);
7
name = "HymanHu";
8
print("Hello %s"%name);
9
first_name = "Hu";
10
last_name = "Hyman";
11
print("Hello %s%s"%(last_name, first_name));
2

数据类型 && 运算符

Number 数据类型：int、float、bool、complex（实部 + 虚部 j）；
容器数据类型：str、list、tuple、dict、set；
------------------------------------------------------------------
不可变数据类型：修改值之后，内存地址发生改变，如 int、string、tuple；
可变数据类型：修改值之后，内存地址不发生改变，如 list、dict；
1
# ==== 数据类型 ==== a = 33; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = 33.22; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = 3 < 2; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = 3 + 4j; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = "hujiang"; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = b'hujiang'; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = r'hujiang'; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = u'hujiang'; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = None; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = ["cdsa", None, 12, 12.34, True, True]; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = ("cdsa", None, 12, 12.34, True, True); print("a 的值是：%s，类型为：%s"%(a, type(a))); a = {"name":"hujiang", "age":18}; print("a 的值是：%s，类型为：%s"%(a, type(a))); a = {"name", "age", "age"}; print("a 的值是：%s，类型为：%s"%(a, type(a))); # ==== 运算符 ==== print((100 + 22.2 - 5 * 2) / 2); print(5 // 2); # 地板除，取整 print(5 % 2); print(2 ** 3); # 乘方 a = True and False; print("a的数据类型%s, 值%s"%(type(a), a)); a = True or False; print("a的数据类型%s, 值%s"%(type(a), a)); a = not False; print("a的数据类型%s, 值%s"%(type(a), a)); "aa" == "ss"; # 字符串比较
1
# ==== 数据类型 ====
2
a = 33;
3
print("a 的值是：%s，类型为：%s"%(a, type(a)));
4
a = 33.22;
5
print("a 的值是：%s，类型为：%s"%(a, type(a)));
6
a = 3 < 2;
7
print("a 的值是：%s，类型为：%s"%(a, type(a)));
8
a = 3 + 4j;
9
print("a 的值是：%s，类型为：%s"%(a, type(a)));
10
a = "hujiang";
11
print("a 的值是：%s，类型为：%s"%(a, type(a)));
12
a = b'hujiang';
13
print("a 的值是：%s，类型为：%s"%(a, type(a)));
14
a = r'hujiang';
15
print("a 的值是：%s，类型为：%s"%(a, type(a)));
16
a = u'hujiang';
17
print("a 的值是：%s，类型为：%s"%(a, type(a)));
18
a = None;
19
print("a 的值是：%s，类型为：%s"%(a, type(a)));
20
a = ["cdsa", None, 12, 12.34, True, True];
21
print("a 的值是：%s，类型为：%s"%(a, type(a)));
22
a = ("cdsa", None, 12, 12.34, True, True);
23
print("a 的值是：%s，类型为：%s"%(a, type(a)));
24
a = {"name":"hujiang", "age":18};
25
print("a 的值是：%s，类型为：%s"%(a, type(a)));
26
a = {"name", "age", "age"};
27
print("a 的值是：%s，类型为：%s"%(a, type(a)));
28

29
# ==== 运算符 ====
30
print((100 + 22.2 - 5 * 2) / 2);
31
print(5 // 2); # 地板除，取整
32
print(5 % 2);
33
print(2 ** 3); # 乘方
34
a = True and False;
35
print("a的数据类型%s, 值%s"%(type(a), a));
36
a = True or False;
37
print("a的数据类型%s, 值%s"%(type(a), a));
38
a = not False;
39
print("a的数据类型%s, 值%s"%(type(a), a));
40
"aa" == "ss"; # 字符串比较
2

字符串 && 编码

计算机编码

参见：Java_SE;

Python 文件编码；

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉 Linux/OS 系统，这是一个 Python 可执行程序，Windows 系统会忽略这个注释；
第二行注释是为了告诉 Python 解释器，按照 UTF-8 编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码，申明了 UTF-8 编码并不意味着你的 .py 文件就是 UTF-8 编码的，文件编码可以在文本编辑器里查看和设置，其中 UTF-8 without BOM（Byte Order Mark）编码是微软的习惯，但是放在别的系统上会出现问题；

字符串相关应用

Python 3.x 版本中，字符串是 Unicode 编码，也就意味着，Python 字符串支持多种语言；
ASCII 转换；

print(ord('a')); # 字符转数字
print(chr(98)); # 数字转字符

十六进制转化

print(hex(ord('q')));
print(int('0x71', base=16));
print(chr(int('0x71', base=16)));

encode & decode；

print("cdsa".encode("ascii")); ---- 输出 b'cdsa'，转化为 bytes 类型；
print("中文".encode("ascii")); ---- 报错，ascii 只定义了 0 ~ 127 个字符，中文无法解析；
print("中文".encode("utf-8")); ---- 输出 b'\xe4\xb8\xad\xe6\x96\x87'，转化为 bytes 类型，无法显示为 ASCII 字符的字节，用 \x## 显示；
print(b'cdsa'.decode("ascii")); ---- 输出 cdsa，将 bytes 类型按照 ascii 解码；
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode("utf-8")); ---- 输出中文，将 bytes 类型按照 utf8 解码；

Url encode & decode

import urllib;
url = "http://www.sfac.xyz:8000/notes/Article/Project_%E6%8E%92%E8%AF%BE%E7%B3%BB%E7%BB%9F_files/";
print(urllib.parse.unquote(url));
url = "http://www.sfac.xyz:8000/notes/Article/Project_排课系统_files/";
print(urllib.parse.quote(url));

字符串前面添加u、r、b

u ---- 后面字符串是以 Unicode 编码；
r ---- 表明后面字符串是普通字符；
b ---- 表明后面是 bytes；

字符串比较

print("DvfdDvfds".lower() == "DvfdDvfds")
print("DvfdDvfds".lower() == "dvfddvfds")

len 函数；

print(len("aaa")); ---- 3，对于 str 计算字符数；
print(len("中文")); ---- 2，对于 str 计算字符数；
print(len("aaa".encode("ascii"))); ---- 3，对于 bytes 计算字节数；
print(len("中文".encode("utf-8"))); ---- 6，对于 bytes 计算字节数 ---- 可见 utf8 中一个中文占 3 个字节；

replace 函数

str = "cdcacdsahymancdscda";
print(str.replace("hyman", "HHHHHH")); ---- 替换字符串，但 str 对象没有改变；
print(str); ---- cdcacdsahymancdscda；

find 函数

print("cdsacdas".find("a")); # 字符串查找，返回下标，没有返回 -1；
print("com.www.web".rfind(".")); # 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1；

join 函数

返回通过指定字符连接序列中元素后生成的新字符串；
print("-".join(["a", "b", "c"])); ---- 返回a-b-c；

字符串格式化；

%：有几个 %? 占位符，后面就跟几个变量或者值，顺序要对应好，如果只有一个 %?，括号可以省略；

%d ---- 整数；
%f ---- 浮点数；
%x ---- 十六进制整数；
%s ---- 字符串；
%% ---- %作为普通字符；
print("a的数据类型%s,值为%d"%(type(a), a));
print("%d----%2d----%02d"%(2, 3, 4)); # 2d（不足两位左边补空格）、02d（不足两位，左边补 0）
print("%f----%.2f"%(222.2, 333.345)); # .2f（保留两位小数，四舍五入）
print("%x"%333); # 格式化为十六进制
print("%s%%%s"%("3", "2"));
print("%s同学，你在 %02d 月，综合成绩 %.2f 分，成绩提高了 %.2f%%" % ("小明", 5, 546.23567, 2.3456));
print(list("%s" % x for x in range(2, 10))); # 将 2-10 生成器，转化为字符串 list
urls = list("www.sfac.com/page_%d" % i for i in range(1, 11));

format()：它会用传入的参数依次替换字符串内的占位符 {0}、{1}；

print("{0}同学，你在 {1:02d} 月，综合成绩 {2:.2f} 分，成绩提高了 {3:.2f}%".format("小明", 5, 546.23567, 2.3456));

f 前缀格式化

id = 333;
print(f'cdscsaddc{id}');

示例

1
#!/usr/bin/env python3 # -*- coding: utf-8 -*- __author__ = "HuJiang"; # ==== ASCII转换 ==== print("98-->%s;a-->%s"%(chr(98), ord('a'))); # ==== encode && decode ==== print("cdsa".encode("ascii")); # 输出b'cdsa'，转化为bytes类型； #print("中文".encode("ascii")); # 报错，ascii只定义了127个字符，中文无法解析； print("中文".encode("utf-8")); # 输出b'\xe4\xb8\xad\xe6\x96\x87'，转化为bytes类型，无法显示为ASCII字符的字节，用\x##显示； print(b'cdsa'.decode("ascii")); # 输出cdsa，将bytes类型按照ascii解码； print(b'\xe4\xb8\xad\xe6\x96\x87'.decode("utf-8")); # 输出中文，将bytes类型按照utf8解码； # ==== 前缀字符串 ==== print(u'中文'); # 后面字符串是以Unicode编码 print(r'dddd'); # 后面字符串是普通字符串 print(b'qwerr'); # 后面是bytes # ==== len ==== print(len("aaa")); # 3，对于str计算字符数 print(len("中文")); # 2，对于str计算字符数 print(len("aaa".encode("utf-8"))); # 3，对于bytes计算字节数 print(len("中文".encode("utf-8"))); # 6，对于bytes计算字节数 ---- 可见utf8中一个中文占3个字节 # ==== replace ==== a = "cdcacdsahymancdscda"; print(a.replace("hyman", "----")); print(a); # ==== find ==== print("cdsacdas".find("a")); # 字符串第一次出现下标，没有-1 print("cdsacdas".rfind("a")); # 字符串最后一次出现下标，没有-1 # ==== isspace ==== print(" ".isspace()); # ==== contain ==== temp = "全省累计报告新型冠状病毒肺炎确诊病例" print(temp.__contains__("全省累计")) # ==== 字符串格式化 ==== print("%d----%2d----%02d"%(2, 3, 4)); # 2d（不足两位左边补空格）、02d（不足两位，左边补0） print("%f----%.2f"%(222.2, 333.345)); # .2f（保留两位小数，四舍五入） print("%x"%333); # 格式化为十六进制 print("%s%%%s"%("3", "2")); print(list("%s" % x for x in range(2, 10))); # 将2-10生成器，转化为字符串list # **同学你好，在**学期，你的成绩为**，提高了**% print("%s同学你好，在%02d学期，你的成绩为%.2f，提高了%.2f%%"%("hujiang", 2, 87.3456, 1.2345)); # 生成 http://www.sfac.xyz/page_* 列表 print(list("http://www.sfac.xyz/page_%d" % page for page in range(1, 11))); print("Hi {0}, 成绩提高了{1:.1f}%".format("小明", 1.234)); print("Hi {0}, 成绩提高了{1}%".format("小明", "%.1f"%1.234)); print("-".join(["a", "b", "c"]));
1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
__author__ = "HuJiang";
4
5
# ==== ASCII转换 ====
6
print("98-->%s;a-->%s"%(chr(98), ord('a')));
7
8
# ==== encode && decode ====
9
print("cdsa".encode("ascii")); # 输出b'cdsa'，转化为bytes类型；
10
#print("中文".encode("ascii")); # 报错，ascii只定义了127个字符，中文无法解析；
11
print("中文".encode("utf-8")); # 输出b'\xe4\xb8\xad\xe6\x96\x87'，转化为bytes类型，无法显示为ASCII字符的字节，用\x##显示；
12
print(b'cdsa'.decode("ascii")); # 输出cdsa，将bytes类型按照ascii解码；
13
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode("utf-8")); # 输出中文，将bytes类型按照utf8解码；
14
15
# ==== 前缀字符串 ====
16
print(u'中文'); # 后面字符串是以Unicode编码
17
print(r'dddd'); # 后面字符串是普通字符串
18
print(b'qwerr'); # 后面是bytes
19
20
# ==== len ====
21
print(len("aaa")); # 3，对于str计算字符数
22
print(len("中文")); # 2，对于str计算字符数
23
print(len("aaa".encode("utf-8"))); # 3，对于bytes计算字节数
24
print(len("中文".encode("utf-8"))); # 6，对于bytes计算字节数 ---- 可见utf8中一个中文占3个字节
25
26
# ==== replace ====
27
a = "cdcacdsahymancdscda";
28
print(a.replace("hyman", "----"));
29
print(a);
30
31
# ==== find ====
32
print("cdsacdas".find("a")); # 字符串第一次出现下标，没有-1
33
print("cdsacdas".rfind("a")); # 字符串最后一次出现下标，没有-1
34
35
# ==== isspace ====
36
print(" ".isspace());
37
38
# ==== contain ====
39
temp = "全省累计报告新型冠状病毒肺炎确诊病例"
40
print(temp.__contains__("全省累计"))
41
42
# ==== 字符串格式化 ====
43
print("%d----%2d----%02d"%(2, 3, 4)); # 2d（不足两位左边补空格）、02d（不足两位，左边补0）
44
print("%f----%.2f"%(222.2, 333.345)); # .2f（保留两位小数，四舍五入）
45
print("%x"%333); # 格式化为十六进制
46
print("%s%%%s"%("3", "2"));
47
print(list("%s" % x for x in range(2, 10))); # 将2-10生成器，转化为字符串list
48
# **同学你好，在**学期，你的成绩为**，提高了**%
49
print("%s同学你好，在%02d学期，你的成绩为%.2f，提高了%.2f%%"%("hujiang", 2, 87.3456, 1.2345));
50
# 生成 http://www.sfac.xyz/page_* 列表
51
print(list("http://www.sfac.xyz/page_%d" % page for page in range(1, 11)));
52
print("Hi {0}, 成绩提高了{1:.1f}%".format("小明", 1.234));
53
print("Hi {0}, 成绩提高了{1}%".format("小明", "%.1f"%1.234));
54
print("-".join(["a", "b", "c"]));
2

正则表达式

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

. ---- 匹配任意字符；\d ---- 匹配数字；\w ---- 匹配字母；\s ---- 匹配一个空格（包含tab）；
* ---- 任意个字符（包括0个）；+ ---- 至少一个字符；? ---- 表示0个或1个字符；{n} ---- 表示n个字符；{n,m} ---- 表示n-m个字符；
[] ---- 表示范围 ---- [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线；
() ---- 表示提取的分组，按照正则表达式拆分原始字符串，group(0)永远是原始字符串；
A|B ---- 匹配A或B；^ ----表示行的开头；^\d ---- 表示必须以数字开头；$ ---- 表示行的结束；\d$ ---- 表示必须以数字结束；

常用表达式

非负整数：^\d+$
正整数：^[0-9]*[1-9][0-9]*$
非正整数：^((-\d+)|(0+))$
负整数：^-[0-9]*[1-9][0-9]*$
整数：^-?\d+$
非负浮点数：^\d+(\.\d+)?$
正浮点数 : ^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)$
非正浮点数：^((-\d+\.\d+)?)|(0+(\.0+)?))$
负浮点数：^(-((正浮点数正则式)))$
英文字符串：^[A-Za-z]+$
英文大写串：^[A-Z]+$
英文小写串：^[a-z]+$
英文字符数字串：^[A-Za-z0-9]+$
英数字加下划线串：^\w+$
E-mail地址

^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$
^[a-z0-9\.\-\_]+\@[a-z0-9\-\_]+(\.[a-z0-9\-\_]+){1,4}$

URL：^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$ 或：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\
邮政编码：^[1-9]\d{5}$
中文：^[\u0391-\uFFE5]+$
电话号码：^(($\d{2,3}$)|(\d{3}\-))?($0\d{2,3}$|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$
手机号码：^(($\d{2,3}$)|(\d{3}\-))?13\d{9}$
双字节字符(包括汉字在内)：^\x00-\xff
匹配首尾空格：(^\s*)|(\s*$)（像vbscript那样的trim函数）
匹配HTML标记：<(.*)>.*<\/\1>|<(.*) \/>
匹配空行：\n[\s| ]*\r
IP：(\d+)\.(\d+)\.(\d+)\.(\d+)
电话区号：/^0\d{2,3}$/
腾讯QQ号：^[1-9]*[1-9][0-9]*$
帐号(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
中文、英文、数字及下划线：^[\u4e00-\u9fa5_a-zA-Z0-9]+$
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
sql语句：^(select|drop|delete|create|update|insert).*$
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
提取信息中的邮件地址：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
提取信息中的IP地址：(\d+)\.(\d+)\.(\d+)\.(\d+)
提取信息中的中国手机号码：(86)*0*13\d{9}
提取信息中的中国固定电话号码：($\d{3,4}$|\d{3,4}-|\s)?\d{8}
提取信息中的中国电话号码（包括移动和固定电话）：($\d{3,4}$|\d{3,4}-|\s)?\d{7,14}
提取信息中的中国邮政编码：[1-9]{1}(\d+){5}
提取信息中的浮点数（即小数）：(-?\d*)\.?\d+
提取信息中的任何数字：(-?\d*)(\.\d+)?
匹配 Emoji 字符：emoji_pattern = re.compile(u'[\U00010000-\U0010ffff]', flags=re.UNICODE);

re 模块

该模块包含正则表达式功能，但需要考虑转义字符的存在，如果在字符串前面添加了 r，则不必考虑，所以我们强烈建议在正则表达式前面添加上 r；
1
#!/usr/bin/env python3 # -*- coding: utf-8 -*- __author__ = "HymanHu"; import re; # ==== match & search ==== # 从头开始匹配 ma = re.match("c", "adcda"); print(ma); # 从 anywhere 匹配 se = re.search("c", "adcda"); print(se); # ==== 匹配字符串 ==== email_re = "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"; # 如果匹配成功，将返回一个Math对象，失败则返回None if re.match(email_re, "hujiangux@163.com"): print("ok"); else: print("error"); # ==== 切分字符串 ==== print("a b c".split(" ")); print(re.split(r"\s+", "a b c")); print(re.split(r"[\s\,\;]+", "a,b;; c d")); # ==== 分组 ==== # 分组提取电话号码 math = re.match(r"^(\d{3})-(\d{3,8})$", "010-12345"); print(math.groups()); # ('010', '12345') print(math.group(0)); # 010-12345 print(math.group(1)); # 010 print(math.group(2)); # 12345 # 分组提起时间 math = re.match(r"^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:" r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:" r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$", "19:05:30"); print(math.groups()); # 分组提取数字 temp = "截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例627例(其中境外输入86例），" \ "累计治愈出院609例，死亡3例，目前在院隔离治疗15例，551人尚在接受医学观察。 "; # 前后不添加 ^$，添加后强制起始和结为，如果解析的字符串有空格，则无法进行匹配 temp_re = r'截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例(\d+)例\(其中境外输入(\d+)例\），' \ r'累计治愈出院(\d+)例，死亡(\d+)例，目前在院隔离治疗(\d+)例，(\d+)人尚在接受医学观察。'; ma = re.match(temp_re, temp); print(ma.groups()); print(ma.group(0)); print(ma.group(1)); # 分组提取字符 results = re.findall('<link rel="assets" href="(.*?)">', '<link rel="assets" href="https://github.githubassets.com/">'); print(results); # 贪婪匹配 print(re.match(r"^(\d+)(0*)$", "102300").groups()); # ('102300', '') print(re.match(r"^(\d+?)(0*)$", "102300").groups()); # ('1023', '00')
1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
__author__ = "HymanHu";
4
5
import re;
6
7
# ==== match & search ====
8
# 从头开始匹配
9
ma = re.match("c", "adcda");
10
print(ma);
11
# 从 anywhere 匹配
12
se = re.search("c", "adcda");
13
print(se);
14
15
# ==== 匹配字符串 ====
16
email_re = "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$";
17
# 如果匹配成功，将返回一个Math对象，失败则返回None
18
if re.match(email_re, "hujiangux@163.com"):
19
print("ok");
20
else:
21
print("error");
22
23
# ==== 切分字符串 ====
24
print("a b c".split(" "));
25
print(re.split(r"\s+", "a b c"));
26
print(re.split(r"[\s\,\;]+", "a,b;; c d"));
27
28
# ==== 分组 ====
29
# 分组提取电话号码
30
math = re.match(r"^(\d{3})-(\d{3,8})$", "010-12345");
31
print(math.groups()); # ('010', '12345')
32
print(math.group(0)); # 010-12345
33
print(math.group(1)); # 010
34
print(math.group(2)); # 12345
35
# 分组提起时间
36
math = re.match(r"^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:"
37
r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:"
38
r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$", "19:05:30");
39
print(math.groups());
40
# 分组提取数字
41
temp = "截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例627例(其中境外输入86例），" \
42
"累计治愈出院609例，死亡3例，目前在院隔离治疗15例，551人尚在接受医学观察。 ";
43
# 前后不添加 ^$，添加后强制起始和结为，如果解析的字符串有空格，则无法进行匹配
44
temp_re = r'截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例(\d+)例\(其中境外输入(\d+)例\），' \
45
r'累计治愈出院(\d+)例，死亡(\d+)例，目前在院隔离治疗(\d+)例，(\d+)人尚在接受医学观察。';
46
ma = re.match(temp_re, temp);
47
print(ma.groups());
48
print(ma.group(0));
49
print(ma.group(1));
50
# 分组提取字符
51
results = re.findall('<link rel="assets" href="(.*?)">', '<link rel="assets" href="https://github.githubassets.com/">');
52
print(results);
53
# 贪婪匹配
54
print(re.match(r"^(\d+)(0*)$", "102300").groups()); # ('102300', '')
55
print(re.match(r"^(\d+?)(0*)$", "102300").groups()); # ('1023', '00')
2

练习

Email 验证、找出用户名
1
email_re = r'^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$'; email_name_re = r'<?([^@|^>]*).*@.*'; print(re.match(email_re, "hyman@163.com")); print(re.match(email_re, "bill.gates@microsoft.com")); print(re.match(email_re, "y_cat-st@example.com")); print(re.match(email_name_re, "<Tom Paris> tom@voyager.org").groups()); print(re.match(email_name_re, "tom@voyager.org").groups());
1
email_re = r'^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$';
2
email_name_re = r'<?([^@|^>]*).*@.*';
3
print(re.match(email_re, "hyman@163.com"));
4
print(re.match(email_re, "bill.gates@microsoft.com"));
5
print(re.match(email_re, "y_cat-st@example.com"));
6
print(re.match(email_name_re, "<Tom Paris> tom@voyager.org").groups());
7
print(re.match(email_name_re, "tom@voyager.org").groups());
2

list && tuple

list：有序的集合，中括号定义，元素类型可不一致，可以随时添加和删除其中的元素；

1
# ==== list ==== l = ["hujiang", 18, True, 13.14, None]; l = list(range(10)); # 从前取值，index从0开始往后；从后取值，index从-1开始往前 print(l[0] + "----" + l[-1]); # 集合尾部添加元素 l.append("hymanhu"); # l1.append(l2); # 将后面集合的元素添加到前面集合，注意和append的区别，append是将append的整体作为一个元素纳入前面集合； l += list(range(3)); # 集合指定位置插入元素 l.insert(1, "hujiang"); # 按照索引删除元素，无参数时从最后一位删除 l.pop(); l.pop(0); # 删除首个符合条件的元素，不是索引 l.remove(5); # 直接对集合元素进行赋值 l[0] = "hymanHu111"; print("list: %s, length: %s" % (l, len(l))); # list 排序 l.sort(key=lambda item:item, reverse=True); print(l); # list 遍历 l = list(range(1, 10)); print(list(item for item in l if item > 4));
1
# ==== list ====
2
l = ["hujiang", 18, True, 13.14, None];
3
l = list(range(10));
4
# 从前取值，index从0开始往后；从后取值，index从-1开始往前
5
print(l[0] + "----" + l[-1]);
6
# 集合尾部添加元素
7
l.append("hymanhu");
8
# l1.append(l2);
9
# 将后面集合的元素添加到前面集合，注意和append的区别，append是将append的整体作为一个元素纳入前面集合；
10
l += list(range(3));
11
# 集合指定位置插入元素
12
l.insert(1, "hujiang");
13
# 按照索引删除元素，无参数时从最后一位删除
14
l.pop();
15
l.pop(0);
16
# 删除首个符合条件的元素，不是索引
17
l.remove(5);
18
# 直接对集合元素进行赋值
19
l[0] = "hymanHu111";
20
print("list: %s, length: %s" % (l, len(l)));
21
# list 排序
22
l.sort(key=lambda item:item, reverse=True);
23
print(l);
24
# list 遍历
25
l = list(range(1, 10));
26
print(list(item for item in l if item > 4));
2

tuple：元祖，小括号定义，也是有序的集合，但是一旦初始化后就不能修改；

1
# ==== tuple ==== t = tuple(range(10)); t = ("aads", 123, True, None, 12.3); # 定义只有一个元素的元祖，元素后追加“,”，以免误解成数学计算意义上的括号 t = ("cdsa",); # 集合作为元祖的元素，我们可以修改集合的元素 t = ("vsv", ["aaa", "sss"]); t[1][1] = "bbbb"; print("tuple: %s, length: %s"%(t, len(t)));
1
# ==== tuple ====
2
t = tuple(range(10));
3
t = ("aads", 123, True, None, 12.3);
4
# 定义只有一个元素的元祖，元素后追加“,”，以免误解成数学计算意义上的括号
5
t = ("cdsa",);
6
# 集合作为元祖的元素，我们可以修改集合的元素
7
t = ("vsv", ["aaa", "sss"]);
8
t[1][1] = "bbbb";
9
print("tuple: %s, length: %s"%(t, len(t)));
2

dict & set

dict：全称 Dictionary，使用 Key-Value 存储，具有极快的查询速度（list 逐个查找，dict 索引查找），Key 必须是不可变对象；

1
# ==== dict ==== d = {"name":"hyman","age":33,"money":22.3}; print("dict: %s, length: %s"%(d, len(d))); # get 取值，没有返回 None，也可给定默认值 print(d.get("name"), d.get("name1"), d.get("name1", "hujiang")); # 赋值取值 d["aaaa"] = "aaaa"; d["name"] = "hymanhu1"; print(d["name"], d["age"]); # 删除 d.pop("money"); print("dict: %s, length: %s"%(d, len(d))); # 循环 for key in d: print(key, d[key]); # 合并dict dict_1 = {"name":"hujiang", "age":22} dict_2 = {"sex":"man"} print(dict(dict_1, **dict_2))
1
# ==== dict ====
2
d = {"name":"hyman","age":33,"money":22.3};
3
print("dict: %s, length: %s"%(d, len(d)));
4
# get 取值，没有返回 None，也可给定默认值
5
print(d.get("name"), d.get("name1"), d.get("name1", "hujiang"));
6
# 赋值取值
7
d["aaaa"] = "aaaa";
8
d["name"] = "hymanhu1";
9
print(d["name"], d["age"]);
10
# 删除
11
d.pop("money");
12
print("dict: %s, length: %s"%(d, len(d)));
13
# 循环
14
for key in d:
15
print(key, d[key]);
16
# 合并dict
17
dict_1 = {"name":"hujiang", "age":22}
18
dict_2 = {"sex":"man"}
19
print(dict(dict_1, **dict_2))
2

set：存储的是一组 Key 集合，不存储 Value，没有重复元素，无序，自动过滤重复 Key，而且 Key 也必须为不可变对象；

1
# ==== set ==== s1 = {"name", "name", "age", "money"}; s2 = set(["name", "name", "age", "money"]); s = set(["aaa", 123, 123, True]); s.add("fdsaa"); # 删除首个符合条件的元素 s.remove(123); # 删除第一个元素，无参 s.pop(); print("set: %s, length: %s"%(s, len(s))); # 交集、合集 s2 = set([123, "fdcasc"]); print(s & s2); print(s | s2);
1
# ==== set ====
2
s1 = {"name", "name", "age", "money"};
3
s2 = set(["name", "name", "age", "money"]);
4
s = set(["aaa", 123, 123, True]);
5
s.add("fdsaa");
6
# 删除首个符合条件的元素
7
s.remove(123);
8
# 删除第一个元素，无参
9
s.pop();
10
print("set: %s, length: %s"%(s, len(s)));
11
# 交集、合集
12
s2 = set([123, "fdcasc"]);
13
print(s & s2);
14
print(s | s2);
2

判断语句

书写格式

条件之后，使用冒号分隔；
执行语句，可以多行，但必须有相应的缩进；
条件可以重叠，但执行语句从上到下，进入某条件代码块后，后面的判断不再执行；

示例

 
# ==== 条件判断 ====
a = 20;
if a < 10:
    print("aaaa");
elif 10 <= a < 20:
    print("bbb");
else:
    print("ccc");
a = " ";
if a and a.strip():
    print(a);
else:
    print("Null string");
# 三目运算符
a, b, c = 1, 2, 3;
print(a if (b > c) else c);

循环语句

格式

for x in ...循环：把list或者tuple中每个元素代入变量x，然后执行缩进块的语句；
while 循环：只要条件满足，就不断循环，条件不满足时退出循环；

break、continue；

break：跳出循环，后续不再循环；
continue：跳出本层循环，后续还会循环；

示例

 
# ==== 循环 ====
# ---- for 循环 ----
a = list(range(10));
sum = 0;
for x in a:
    print(x);
    sum += x;
print("sum: %s"%sum);
# ---- for 循环下标 ----
l = ["cdsa", 32, 33.2, None, True];
for index, item in enumerate(l):
    print(index, item);
# ---- while 循环 ----
sum = 0;
i = 0;
while i < 10:
    sum += i;
    i += 1;
print("sum: %s"%sum);
i = 0;
while i < 10:
    if i > 5:
        break;
    i += 1;
print(i);

变量 & 常量

概述

动态语言：定义变量时无需指定变量类型，可以任意赋值各种类型，比如 Python；
静态语言：定义变量时必须指定变量类型，比如 Java；
-------------------------------------------
a = 'abc'; ---- 解释器创建了字符串 'abc' 和变量 a ---- 把 a 指向 'abc'；
b = a; ---- 解释器创建了变量 b ---- 把 b 指向 a 指向的字符串 'abc'；
a = 'qqq'; ---- 解释器创建了字符串 'qqq' ---- 把 a 指向'qqq'，但 b 没有改变；

命名规则

字母、数字、下划线，数字不能开头；
不能是 Python 关键字，但可以包含关键字；
-------------------------------------------
常量：全大写，用下划线连接单词，MAX_OVERFLOW = 3.22222222； ---- MAX_OVERFLOW依旧是一个变量，Python 没有任何机制保证 CONTENT 不会改变，全大写只是大家约定俗成表示常量而已；
全局变量：__xxx，双下划线开头，若想在函数内部对外部变量进行操作，需要在内部声明为 global，例如：global __pool;
私有变量：_xxx，不能用 'from module import *' 导入；
系统自带：__xxx__；

作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的；
四种作用域

L （Local） ---- 局部作用域；
E （Enclosing） ---- 闭包函数外的函数中；
G （Global） ---- 全局作用域；
B （Built-in） ---- 内建作用域；

 
# ==== 变量、常量 ====
MAX_VALUE = 333;
a = 'aaa';
b = a;
a = 'sss';
print("%s====%s===%s"%(MAX_VALUE, a, b));
a = int(33.3); # int 函数在内建作用域
__name = "HymanHu"; # 全局作用域
def fun():
    name = "JiangHu"; # 闭包函数外的函数域
    print(name);
    def fun2():
        name = "Hawkist"; # 局部作用域
        print(name);
fun();

查找规则：L –> E –> G –>B，在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找；

函数

相关概念

功能模块，包含函数名、参数、函数体等；
可以将函数赋值给一个变量，然后调用变量；
自定义的变量不能和函数名相同，否则不会调用该函数；
查看某函数帮助信息；

自定义函数

定义语句：def 语句，依次写出函数名，括号，括号内书写参数，冒号，在缩进体书写函数体，返回使用 return 语句；
参数：

位置参数（POSITIONAL）；

没有设置默认值的参数是必选的；
设置有默认值的参数可以不用传参，但定义默认参数必须为 None、str 等不变的对象，如果默认参数给定为一个集合 def addEnd(L=[])，那么多次调用该函数后，每次调用的参数是改变的；
既可以用位置传参，也可以用关键字传参，并且他没有任何*的声明；

可变参数（VAR_POSITIONAL）

定义函数时候，在参数前面添加 * 符号，实现可变参数；
调用函数时，传入一个 list 或者 tuple，也可用 * 表示传入集合中元素作为可变参数；

可变关键字参数（VAR_KEYWORD）

定义函数的时候，在参数前面添加 ** 符号，实现关键字参数，代表传入 0 个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个 dict；
调用函数的时候，传入一个 dict，前面使用 **，表示传入该dict中所有键值对；

命名关键字参数（KEYWORD_ONLY）

如果要限制关键字参数的名字，使用一个特殊分隔符 *，这种参数会在 VAR_POSITIONAL 参数类型的后面，而且不带 ** 前缀；

组合参数：以上五种参数的组合，例如：def f1(a, b, c=0, *args, **kw)，但建议不要使用太多的组合，这样函数的可读性太差；
参数检查：如果参数个数不对、或者参数类型不对，解释器会抛出 TypeError 错误，我们也可以使用内置函数 isinstance() 进行检查；

返回值：

如果没有 return 语句，函数也会返回 None，return None 简写为 return；
函数体可以同时返回多个值，实际上是一个 tuple，只是省略掉了括号和逗号；

空函数：定义一个什么都不做的函数，使用 pass 语句 ---- pass 语句可以用作占位符，还未想好怎么写代码的时候，可以用 pass 代替；
递归函数

在函数内部调用其他函数，如果调用自身，则是递归函数；
调用递归函数的时候要注意栈溢出，在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出；
尾递归：函数返回的时候，调用自身，但不包含各种表达式（加减乘除等），等价于循环，如果做了优化，可以避免栈增长的情况，但遗憾的是，大多数解释器都没有对尾递归进行优化，所以尾递归调用次数过多依旧会报错；

代码示例

import math;

# ==== 位置参数 ====
def count(start, end = 5):
    if not isinstance(start, (int, float)):
        raise TypeError("Bad type");
    count = 0;
    while start <= end:
        count += start;
        start += 1;
    return count;
print(count(1, 100));

# ==== 可变参数 ====
def cal(*number):
    sum = 0;
    for i in number:
        sum += i;
    return sum;
print(cal());
print(cal(1,2,3,4,5,77));

# ==== 可变关键字参数 ====
def person(name, age, **kwargs):
    if "city" in kwargs:
        pass;
    print("name:%s;age:%s;city:%s"%(name, age, kwargs.get("city")));
kwargs = {"city":"chengdu"};
person("hj",44,**kwargs);
person("hj", 33, gender="M", city="chengdu");

# ==== 命名关键字参数 ====
def person(name, age, *, city):
    print("name:%s;age:%s;city:%s"%(name, age, city));
person("hj", 44, city="chengdu");

# ==== 多返回值 ====
def move(x, y, step, angle):
    nx = x + step * math.cos(angle);
    ny = y + step * math.sin(angle);
    return nx, ny;
print(move(12, 22, 4, 30));

# ==== 空函数 ====
def fun():
    pass;
print(fun());

# ==== 递归函数（计算阶乘） ====
def fact(number):
    if number == 1:
        return  number;
    return number * fact(number - 1);
print(fact(5));
# 尾递归函数
def fact2(number, sum):
    if number == 1:
        return sum;
    return fact2(number - 1, number * sum);
print(fact2(5, 1));

 
import math;
# ==== 位置参数 ====
def count(start, end = 5):
    if not isinstance(start, (int, float)):
        raise TypeError("Bad type");
    count = 0;
    while start <= end:
        count += start;
        start += 1;
    return count;
print(count(1, 100));
# ==== 可变参数 ====
def cal(*number):
    sum = 0;
    for i in number:
        sum += i;
    return sum;
print(cal());
print(cal(1,2,3,4,5,77));
# ==== 可变关键字参数 ====
def person(name, age, **kwargs):
    if "city" in kwargs:
        pass;
    print("name:%s;age:%s;city:%s"%(name, age, kwargs.get("city")));
kwargs = {"city":"chengdu"};
person("hj",44,**kwargs);
person("hj", 33, gender="M", city="chengdu");
# ==== 命名关键字参数 ====
def person(name, age, *, city):
    print("name:%s;age:%s;city:%s"%(name, age, city));
person("hj", 44, city="chengdu");
# ==== 多返回值 ====
def move(x, y, step, angle):
    nx = x + step * math.cos(angle);
    ny = y + step * math.sin(angle);
    return nx, ny;
print(move(12, 22, 4, 30));
# ==== 空函数 ====
def fun():
    pass;
print(fun());
# ==== 递归函数（计算阶乘） ====
def fact(number):
    if number == 1:
        return  number;
    return number * fact(number - 1);
print(fact(5));
# 尾递归函数
def fact2(number, sum):
    if number == 1:
        return sum;
    return fact2(number - 1, number * sum);
print(fact2(5, 1));

如果将自定义函数保存为 countTest.py 文件，在 cmd 模式下启动 Python 解释器，导入并调用函数；

from countTest import count ---- from 文件名 import 函数名；

常见内置函数；

1
# ==== 内置函数 ==== print(int("22")); # 数据类型转换函数，注意，如果定义变量名和函数名一样，则不会调用该函数，会报错 print(float("22.2")); print(str(22)); print(abs(-111)); # abs函数，求绝对值 print(max(12, 34, 123.4)); # max函数，求最大值 print(min(-21, -11, 0, 22.3)); # min函数，求最小值 print(" aa bb cc ".strip()); # 字符串去前后空格 print("['6K-8K']".strip('[\'\']')); # 移除字符串头尾指定的字符 print(hex(12)); # hex函数，将十进制数转十六进制 print(math.sqrt(3)); # 求平方根 print(sum(range(1, 101))); # 求和 print(sum(list(range(101)))); print("cdaDcdsa".capitalize()); # 将字符串第一个字符变成大写，其他小写
1
# ==== 内置函数 ====
2
print(int("22")); # 数据类型转换函数，注意，如果定义变量名和函数名一样，则不会调用该函数，会报错
3
print(float("22.2"));
4
print(str(22));
5
print(abs(-111)); # abs函数，求绝对值
6
print(max(12, 34, 123.4)); # max函数，求最大值
7
print(min(-21, -11, 0, 22.3)); # min函数，求最小值
8
print(" aa bb cc ".strip()); # 字符串去前后空格
9
print("['6K-8K']".strip('[\'\']')); # 移除字符串头尾指定的字符
10
print(hex(12)); # hex函数，将十进制数转十六进制
11
print(math.sqrt(3)); # 求平方根
12
print(sum(range(1, 101))); # 求和
13
print(sum(list(range(101))));
14
print("cdaDcdsa".capitalize()); # 将字符串第一个字符变成大写，其他小写
2

练习题

定义一个函数，接受 0 个或多个参数，累计乘积；

 
def product(*numbers):
    if len(numbers) == 0:
        raise TypeError("Param is error.");
    count = 1;
    for i in numbers:
        count *= i;
    return count;
print(product(*[1,2,4,6,7]));
print(product(1,2,4,6,7));

递归函数实现汉诺塔游戏（三根柱子 a、b、c，a 柱上有 n 个大小不一的圆盘，借助 b 柱将 a 柱的圆盘移动到 c 柱上，规则，圆盘必须按照由大致小的顺序排列）；

思路：以两个圆盘为例，要完成 a 到 c 的移动，共计需要移动三次，调用一次函数，都是从 a --- c 的操作，但需要考虑的是，谁是 a，谁是 c，从哪个柱子移动哪个柱子就是 a，移动到的目标柱子是 c，所以我们要调整首次传入柱子的顺序来完成；

 
def hannuota(n, a, b, c):
    if n == 1:
        print(a, "---->", c);
    else:
        hannuota(n - 1, a, c, b); # 借助C柱，将n-1个圆盘从A柱移动到B柱
        print(a, "---->", c); # 将A柱最底层的圆盘移动到C柱
        hannuota(n - 1, b, a, c); # 借助A柱，将n-1个圆盘从B柱移动到C柱
hannuota(3, "a", "b", "c");

使用 Python 画心形

# 方式一
'''
    1、选择 (x² + y² - 1)³ - x²y³ = 0函数，函数等于0是一条心形线，取x,y=0,函数小于0的，说明内部小于0
    2、y轴从上到下，step=-1，x轴从左到右计算
    3、计算每行字符串：公式<=0，则添加给定的字符串，否则添加空格
    4、将每行字符串放到list中
'''
def heart():
    content = "I love U";
    lines = [];
    for y in range(12, -12, -1):
        line = "";
        for x in range(-30, 30):
            # 和原始的公式不一样, 做了x、y轴的缩放
            # formula = (x ** 2 + y ** 2 - 1) ** 3 - x ** 2 * y ** 3;
            formula = ((x * 0.05) ** 2 + (y * 0.1) ** 2 - 1) ** 3 - (x * 0.05) ** 2 * (y * 0.1) ** 3;
            if formula <= 0:
                # lineStr += content[x % len(content)]; # 画出比较耿直的心
                line += content[(x - y) % len(content)];  # 画出比较斜点的心
            else:
                line += " ";
        lines.append(line);
    # print("\n".join(lines));
    # 打印颜色
    for i in "\n".join(lines):
        print("\033[91m" + i, end="", flush=True);
heart();
# 方式二
'''
现在将 print("\n".join(lines)); 反向组装，简化代码
每一行可以是字符串，也可以是一个char list，然后使用"".join的方式连接
for in的另外一种写法，在join括号内定义，外层join是y循环，里层join是x循环
'''
print("\n".join("".join("Love"[(x-y) % len("Love")]for x in range(-30, 30))for y in range(12, -12, -1)));
'''
上面的代码打印出来的是一个长方形，现在要加入判断，引入心形公式
if判断逻辑决定是添加字符串字符，还是添加" ",所以在这个逻辑外面添加括号
这样就将上面的代码转为一句代码完成
'''
print("\n".join("".join(("Love"[(x-y) % len("Love")] if ((x * 0.05) ** 2 + (y * 0.1) ** 2 - 1) ** 3 -
(x * 0.05) ** 2 * (y * 0.1) ** 3 <= 0 else " ")for x in range(-30, 30))for y in range(12, -12, -1)));

 
# 方式一
'''
    1、选择 (x² + y² - 1)³ - x²y³ = 0函数，函数等于0是一条心形线，取x,y=0,函数小于0的，说明内部小于0
    2、y轴从上到下，step=-1，x轴从左到右计算
    3、计算每行字符串：公式<=0，则添加给定的字符串，否则添加空格
    4、将每行字符串放到list中
'''
def heart():
    content = "I love U";
    lines = [];
    for y in range(12, -12, -1):
        line = "";
        for x in range(-30, 30):
            # 和原始的公式不一样, 做了x、y轴的缩放
            # formula = (x ** 2 + y ** 2 - 1) ** 3 - x ** 2 * y ** 3;
            formula = ((x * 0.05) ** 2 + (y * 0.1) ** 2 - 1) ** 3 - (x * 0.05) ** 2 * (y * 0.1) ** 3;
            if formula <= 0:
                # lineStr += content[x % len(content)]; # 画出比较耿直的心
                line += content[(x - y) % len(content)];  # 画出比较斜点的心
            else:
                line += " ";
        lines.append(line);
    # print("\n".join(lines));
    # 打印颜色
    for i in "\n".join(lines):
        print("\033[91m" + i, end="", flush=True);
heart();
# 方式二
'''
现在将 print("\n".join(lines)); 反向组装，简化代码
每一行可以是字符串，也可以是一个char list，然后使用"".join的方式连接
for in的另外一种写法，在join括号内定义，外层join是y循环，里层join是x循环
'''
print("\n".join("".join("Love"[(x-y) % len("Love")]for x in range(-30, 30))for y in range(12, -12, -1)));
'''
上面的代码打印出来的是一个长方形，现在要加入判断，引入心形公式
if判断逻辑决定是添加字符串字符，还是添加" ",所以在这个逻辑外面添加括号
这样就将上面的代码转为一句代码完成
'''
print("\n".join("".join(("Love"[(x-y) % len("Love")] if ((x * 0.05) ** 2 + (y * 0.1) ** 2 - 1) ** 3 -
(x * 0.05) ** 2 * (y * 0.1) ** 3 <= 0 else " ")for x in range(-30, 30))for y in range(12, -12, -1)));

高级特性

Python 中，代码不是越多越好，而是越少越好，代码不是越复杂越好，而是越简单越好！Python 提供了一些常用的高级特性，来简化代码；
切片

对 list、tuple、str 进行取值，格式：[start:end]，数值是 0 可以省略不写；
正向切片，start、end >= 0，包含 start，不包含 end；
反向切片，start、end <= 0，包含 end，不包含 start；
1
# ==== list切片 ==== l = list(range(100)); print(l[:10]); print(l[10:20]); print(l[-10:]); print(l[-20:-10]); print(l[:10:2]); # 前十个，每两个取一个 print(l[::3]); # 所有数，每三个取一个 print(l[::-1]); # 所有数，倒序 print(l[:]); # 所有数 # ==== tuple切片 ==== t = tuple(range(10)); print(t[:5]); print(t[2:5]); print(t[-3:]); print(t[-5:-3]); print(t[2:8:2]); # 取2-8位，每两个取一个 print(t[::2]); # 所有数，两个取一个 print(t[::-1]); # 所有数，倒序 print(t[:]); # 所有数 # ==== 字符串切片 ==== s = "cdvdjkcdncdsc;adcjdsna"; print(s[:5]); print(s[2:5]); print(s[-3:]); print(s[-5:-2]); print(s[2:8:3]); # 取2-8位字符，每三个取一个 print(s[::3]); # 所有字符，每三个取一个 print(s[::-1]); # 所有字符，倒序 print(s[:]); # 所有字符
1
# ==== list切片 ====
2
l = list(range(100));
3
print(l[:10]);
4
print(l[10:20]);
5
print(l[-10:]);
6
print(l[-20:-10]);
7
print(l[:10:2]); # 前十个，每两个取一个
8
print(l[::3]); # 所有数，每三个取一个
9
print(l[::-1]); # 所有数，倒序
10
print(l[:]); # 所有数
11
12
# ==== tuple切片 ====
13
t = tuple(range(10));
14
print(t[:5]);
15
print(t[2:5]);
16
print(t[-3:]);
17
print(t[-5:-3]);
18
print(t[2:8:2]); # 取2-8位，每两个取一个
19
print(t[::2]); # 所有数，两个取一个
20
print(t[::-1]); # 所有数，倒序
21
print(t[:]); # 所有数
22
23
# ==== 字符串切片 ====
24
s = "cdvdjkcdncdsc;adcjdsna";
25
print(s[:5]);
26
print(s[2:5]);
27
print(s[-3:]);
28
print(s[-5:-2]);
29
print(s[2:8:3]); # 取2-8位字符，每三个取一个
30
print(s[::3]); # 所有字符，每三个取一个
31
print(s[::-1]); # 所有字符，倒序
32
print(s[:]); # 所有字符
2

迭代

针对 list、tuple、dict 的遍历；
1
from collections.abc import Iterable; # ==== list迭代 ==== l = list(range(10)); print(isinstance(l, Iterable)); for item in l: print(item); # enumerate 函数作用于可遍历对象，列出下标 for i, item in enumerate(l): print(i, item); # ==== tuple迭代 ==== t = tuple(range(10)); print(isinstance(t, Iterable)); for item in t: print(item); for i, item in enumerate(t): print(i, item); # ==== dict迭代 ==== d = {"name":"hj", "age":30, "city":"cd"}; print(isinstance(d, Iterable)); for key in d: print(key, d.get(key)); for value in d.values(): print(value); for key, value in d.items(): print(key, value); # ==== 字符串迭代 ==== s = "vdsvfvadas"; print(isinstance(s, Iterable)); for char in s: print(char);
1
from collections.abc import Iterable;
2
# ==== list迭代 ====
3
l = list(range(10));
4
print(isinstance(l, Iterable));
5
for item in l:
6
print(item);
7
# enumerate 函数作用于可遍历对象，列出下标
8
for i, item in enumerate(l):
9
print(i, item);
10
11
# ==== tuple迭代 ====
12
t = tuple(range(10));
13
print(isinstance(t, Iterable));
14
for item in t:
15
print(item);
16
for i, item in enumerate(t):
17
print(i, item);
18
19
# ==== dict迭代 ====
20
d = {"name":"hj", "age":30, "city":"cd"};
21
print(isinstance(d, Iterable));
22
for key in d:
23
print(key, d.get(key));
24
for value in d.values():
25
print(value);
26
for key, value in d.items():
27
print(key, value);
28
29
# ==== 字符串迭代 ====
30
s = "vdsvfvadas";
31
print(isinstance(s, Iterable));
32
for char in s:
33
print(char);
2

列表生成式

创建 list 的高级方式；

 
# ==== 列表生成式 ====
l = list(range(10));
d = {"a":1,"b":2,"c":3};
l_ = [item * item for item in l];
l_ = [item * item for item in l if item % 2 == 0];
l_ = [item.lower() for item in ["Hyamn", 10, None, "Hu"] if isinstance(item, str)];
l_ = [x + y for x in "abc" for y in "qwe"];
l_ = [item.upper() for item in "asd"];
l_ = [item.lower() for item in l_];
# 注意，value值如果是int，需要使用str函数转换，不然会报错误
l_ = [key + "=" + str(value) for key, value in d.items()];
# 导入os模块，遍历当前文件夹下文件
l_ = [f for f in os.listdir(".")];
print(l_);

生成器 generator

列表转 generator

如果生成的 list 太大，会有容量和性能问题，在 Python 中引入了 generator 来保存算法，在 list 中一边循环一边计算的机制；
和创建 list 的方式唯一区别是，将 [] 变成 ()，同样适用 for 循环来迭代生成器，但生成器不支持切片操作；

函数转 generator

在函数中定义 yield 语句，类似于 return，区别在于函数遇到 return 则返回，而函数生成器在每次调用 next() 的时候执行，遇到 yield 返回，再次执行时从 yield 开始执行；

 
# ---- 列表转生成器 ----
g = (item for item in range(10));
print(next(g), g.__next__(), next(g));
# ---- 函数转生成器 ----
def fun():
    i = 1;
    while True:
        temp = yield i ** 2;
        print(temp);
        i += 1;
f = fun();
# 第一次运行只能使用next或者send(None)
# send函数是Generator类的方法，作用相当于使生成器继续运行
# send参数，传递给yield返回值，即temp = "Hello World"
print(next(f), f.__next__(), next(f), f.send("hello world"));

迭代器

迭代对象（Iterable）：

可以直接作用于 for 循环的对象统称为可迭代对象，例如：list、tuple、dict、set、str、生成器；
使用 isinstance() 函数来判断对象是否是一个可迭代对象：print(isinstance([], Iterable));；

迭代器（Iterator）：

可以被 next() 函数调用并不断返回下一个值的对象称为迭代器；
使用 isinstance() 函数来判断对象是否是一个可迭代对象：print(isinstance("ccdsacdas", Iterator));
迭代对象中只有生成器是迭代器，其余需要使用调用 iter 函数转换：print(isinstance(iter("cdadas"), Iterator));
迭代器是一个惰性序列，如果要转化为一个 list，则需要调用 list 函数来处理；

1
from collections.abc import Iterable, Iterator; # ==== 迭代对象、迭代器 ==== print(isinstance([], Iterable)); print(isinstance({}, Iterable)); print(isinstance("dsadas", Iterable)); print(isinstance((item for item in range(10)), Iterable)); print(isinstance([], Iterator)); print(isinstance({}, Iterator)); print(isinstance("dsadas", Iterator)); print(isinstance((item for item in range(10)), Iterator)); # 生成器是迭代器，其它的迭代对象不是 print(isinstance(iter([]), Iterator)); # 调用iter()函数将迭代对象转化为迭代器 print(isinstance(iter({}), Iterator)); print(isinstance(iter("sfdsfs"), Iterator));
1
from collections.abc import Iterable, Iterator;
2
# ==== 迭代对象、迭代器 ====
3
print(isinstance([], Iterable));
4
print(isinstance({}, Iterable));
5
print(isinstance("dsadas", Iterable));
6
print(isinstance((item for item in range(10)), Iterable));
7
print(isinstance([], Iterator));
8
print(isinstance({}, Iterator));
9
print(isinstance("dsadas", Iterator));
10
print(isinstance((item for item in range(10)), Iterator)); # 生成器是迭代器，其它的迭代对象不是
11
print(isinstance(iter([]), Iterator)); # 调用iter()函数将迭代对象转化为迭代器
12
print(isinstance(iter({}), Iterator));
13
print(isinstance(iter("sfdsfs"), Iterator));
2

练习题

斐波拉契数列 Fibonacci：除第一个和第二个数之外，任意一个数字都由前两个数相加得到；

 
def fibonacci(max):
    # 相当于 t = (0, 0, 1); n = t[0]; a = t[1]; b = t[2];
    n, a, b = 0, 0, 1;
    sb = "";
    while n <= max:
        sb += str(b) + ",";
        a, b = b, a + b;
        n += 1;
    return sb[:-1];
print(fibonacci(20));

trim 函数，除去字符串前后空格

 
# 定义一个trim()函数，去掉前后空格
def trim(s):
    if len(s) == 0 or s.isspace():
        return '';
    while s[0] == ' ':
        s = s[1:];
    while s[-1] == ' ':
        s = s[:-1];
    return s;
print(trim(""));
print(trim("  dsadad  "));
import re;
def fun_2(s):
    if s.startswith(' ') or s.endswith(' '):
        return re.sub(r"^(\s+)|(\s+)$", "", s);

查找 list 中的最大值和最小值

 
def find_max_min(l):
    if len(l) == 0:
        return (None, None);
    if len(l) == 1:
        return (l[0], l[0]);
    max = l[0];
    min = l[0];
    for item in l:
        if item > max:
            max = item;
        if item < min:
            min = item;
    return (min, max);
print(find_max_min([]));
print(find_max_min([1]));
print(find_max_min(range(10)));

杨辉三角：二项式系数，定义为 (1+x)n 展开之后 x 的系数，二项式系数代表的是从 n 件物品中，无序地选取 k 件的方法总数；

 
# ---- 杨辉三角形，函数生成器 ----
# 把每一行看做一个list，下一行除了头和尾，是上一行每两个数之和
def yanghui():
    l = [1];
    while True:
        yield l;
        l = [1] + [l[n] + l[n + 1] for n in range(len(l) - 1)] + [1];
n = 0;
result =[];
for y in yanghui():
    # print(y);
    result.append(y)
    n += 1;
    if n == 10:
        break;
print(result);

Python 编程

日志

简述

logging 是 Python 的内置模块，可以定义日志的级别、输出地、日志回滚等；

日志相关类

Logging.Formatter：配置日志格式；

%(levelno)s：打印日志级别的数值
%(levelname)s：打印日志级别名称
%(pathname)s：打印当前执行程序的路径，其实就是 sys.argv[0]
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(asctime)s：打印日志的时间
%(thread)d：打印线程 ID
%(threadName)s：打印线程名称
%(process)d：打印进程 ID
%(message)s：打印日志信息

Logging.Logger：Logger 是 Logging 模块的主体，有以下功能：

为程序提供记录日志的接口；
判断日志所处级别，并判断是否要过滤；
根据其日志级别将该条日志分发给不同handler；

Logging.Handler：Handler 基于日志级别对日志进行分发，如设置为 WARNING 级别的 Handler 只会处理 WARNING 及以上级别的日志；

日志级别

级别等级：CRITICAL > ERROR > WARNING（默认） > INFO > DEBUG；
设置级别：logging.basicConfig(level=logging.DEBUG); ---- NOTSET（不显示任何级别日志） || DEBUG……

日志输出

输出控制台

1
# ---- logging console ---- import logging; # logging.basicConfig(level=logging.NOTSET); logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s"); logging.debug("苍老师"); logging.info("松岛枫"); logging.warning("小泽玛利亚"); logging.error("波多野结衣"); logging.critical("吉泽明步");
1
# ---- logging console ----
2
import logging;
3
# logging.basicConfig(level=logging.NOTSET);
4
logging.basicConfig(level=logging.DEBUG,
5
format="%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s");
6
logging.debug("苍老师");
7
logging.info("松岛枫");
8
logging.warning("小泽玛利亚");
9
logging.error("波多野结衣");
10
logging.critical("吉泽明步");
2

输出文件

1
# ---- logging file ---- import logging; import os.path; import time; # 设置变量 fileFormat = "PythonLog_" + time.strftime("%Y%m%d", time.localtime(time.time())); logFormat = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s"); logPath = "/log"; logLevel = logging.DEBUG; # 创建logger logger = logging.getLogger(); logger.setLevel(logLevel); # 创建一个 stream handler，输出到控制台 --- 无需设置，logger会自动输出到控制台 # logConsoleHandler = logging.StreamHandler(); # logConsoleHandler.setLevel(logLevel); # logConsoleHandler.setFormatter(logFormat); # logger.addHandler(logConsoleHandler); # 创建一个 file handler，输出到文件 logFile = os.path.abspath(logPath) + "/" + fileFormat + ".log"; logFileHandler = logging.FileHandler(logFile, mode = "w"); logFileHandler.setLevel(logLevel); logFileHandler.setFormatter(logFormat); logger.addHandler(logFileHandler); # 调用日志 logger.debug("论完美不如松岛枫……"); logger.info("论身材不如濑亚美莉……"); logger.warning("论颜值不如波多野结衣……"); logger.error("论业绩不如吉泽明步……"); logger.critical("但是苍老师最红，你有意见么……");
1
# ---- logging file ----
2
import logging;
3
import os.path;
4
import time;
5
# 设置变量
6
fileFormat = "PythonLog_" + time.strftime("%Y%m%d", time.localtime(time.time()));
7
logFormat = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s");
8
logPath = "/log";
9
logLevel = logging.DEBUG;
10
# 创建logger
11
logger = logging.getLogger();
12
logger.setLevel(logLevel);
13
# 创建一个 stream handler，输出到控制台 --- 无需设置，logger会自动输出到控制台
14
# logConsoleHandler = logging.StreamHandler();
15
# logConsoleHandler.setLevel(logLevel);
16
# logConsoleHandler.setFormatter(logFormat);
17
# logger.addHandler(logConsoleHandler);
18
# 创建一个 file handler，输出到文件
19
logFile = os.path.abspath(logPath) + "/" + fileFormat + ".log";
20
logFileHandler = logging.FileHandler(logFile, mode = "w");
21
logFileHandler.setLevel(logLevel);
22
logFileHandler.setFormatter(logFormat);
23
logger.addHandler(logFileHandler);
24
# 调用日志
25
logger.debug("论完美不如松岛枫……");
26
logger.info("论身材不如濑亚美莉……");
27
logger.warning("论颜值不如波多野结衣……");
28
logger.error("论业绩不如吉泽明步……");
29
logger.critical("但是苍老师最红，你有意见么……");
2

全局日志配置

定义 globalLog.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
import os, time;
import logging,logging.config;
from logging.handlers import RotatingFileHandler;

# 设置变量
fileFormat = "PythonLog_" + time.strftime("%Y%m%d", time.localtime(time.time()));
logFormat = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s");
logPath = "/log";
logLevel = logging.DEBUG;

# 获得logger
def getLogger():
    logger = logging.getLogger();
    logger.setLevel(logLevel);
    # 创建一个 stream handler，输出到控制台
    logConsoleHandler = logging.StreamHandler();
    logConsoleHandler.setLevel(logLevel);
    logConsoleHandler.setFormatter(logFormat);
    logger.addHandler(logConsoleHandler);
    # 创建一个 file handler，输出到文件
    logFile = os.path.abspath(logPath) + "/" + fileFormat + ".log";
    # logFileHandler = logging.FileHandler(logFile, mode="w");
    logFileHandler = RotatingFileHandler(logFile,maxBytes=100*1024*1024,backupCount=10);
    logFileHandler.setLevel(logLevel);
    logFileHandler.setFormatter(logFormat);
    logger.addHandler(logFileHandler);
    return logger;

# 创建全局logger对象，命名为LOGGER
LOGGER = getLogger();

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
import os, time;
import logging,logging.config;
from logging.handlers import RotatingFileHandler;
# 设置变量
fileFormat = "PythonLog_" + time.strftime("%Y%m%d", time.localtime(time.time()));
logFormat = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s");
logPath = "/log";
logLevel = logging.DEBUG;
# 获得logger
def getLogger():
    logger = logging.getLogger();
    logger.setLevel(logLevel);
    # 创建一个 stream handler，输出到控制台
    logConsoleHandler = logging.StreamHandler();
    logConsoleHandler.setLevel(logLevel);
    logConsoleHandler.setFormatter(logFormat);
    logger.addHandler(logConsoleHandler);
    # 创建一个 file handler，输出到文件
    logFile = os.path.abspath(logPath) + "/" + fileFormat + ".log";
    # logFileHandler = logging.FileHandler(logFile, mode="w");
    logFileHandler = RotatingFileHandler(logFile,maxBytes=100*1024*1024,backupCount=10);
    logFileHandler.setLevel(logLevel);
    logFileHandler.setFormatter(logFormat);
    logger.addHandler(logFileHandler);
    return logger;
# 创建全局logger对象，命名为LOGGER
LOGGER = getLogger();

引用全局日志并调用

 
from www.globalLog import LOGGER;
LOGGER.debug("Sql: %s, Args: %s" % (sql, args));

错误 && 调试 && 测试

概述

程序编写错误：比如本应输出整数却输出了字符串，这种错误我们称之为 bug，bug 是必须修复的；
用户输入错误：比如用户输入 email 格式不正确，这类错误需要通过检查来解决；
外部因素错误：比如写文件磁盘已满、网络抓取数据断线等，这类错误称之为异常，也需要处理，避免程序终止；
--------------------------------------
调试：跟踪程序的执行，查看变量的值是否正确，Python 的 pdb 允许我们单步执行代码；
测试：编写测试用例，运行测试代码可以检查修改后的代码是否满足需求；

调用栈信息

如果不捕获错误，它会一直往上抛，最后被 Python 解释器捕获，打印错误信息，然后退出程序；

 
def fn():
    return 1 / int("s");
def fn1():
    return fn() * 2;
def fn2():
    print(fn1() * 3);
fn2();

分析错误调用的调用栈信息

从上往下读可以看到整个错误的函数调用链，最终定位到报错的位置；

错误类型

Python 所有的错误超类：BaseException，继承关系参考 https://docs.python.org/3/library/exceptions.html#exception-hierarchy
自定义错误：根据需求选择自定义的父类；

1
# ---- 自定义错误 ---- class MyException(Exception): pass;
1
# ---- 自定义错误 ----
2
class MyException(Exception):
3
pass;
2

错误处理

错误捕获并记录

错误是一个 class，捕获一个错误就是捕获该 class 的一个实例；
高级语言都内置了一套错误处理机制，Java 是 try……catch……finally…… 语句，Python 是 try……except……finally…… 语句；
执行顺序：Python 和 Java 类似，try 块 ---- except 块（捕获相应异常执行） ---- finally 必须执行；
try……except…… 可以跨越多层调用，所以我们不需要在每个可能出错的地方捕获异常；
捕获异常按照由上至下原则，如果下面的错误类是上面的子类，那么永远也捕获不到下面的错误类；
------------------------------------------------
with 语句

是一种上下文管理协议，简化 try….except….finlally 的处理流程；
with expression [as target]:

with_body

使用with处理的对象必须是上下文管理对象，有 __enter__() 和 __exit__() 这两个方法；

 
# ---- try、except、finally ----
try:
    print("start try block");
    a = 1 / int("a");
    # a = 1 / 2;
    print("result is %s" % a);
except ValueError as e:
    logger.debug(e);
    logging.exception(e);
except ZeroDivisionError as e:
    logger.debug(e);
else:
    logger.debug("no exception");
finally:
    print("start finally block");
print("end");
# ---- with语句 ----
try:
    f = open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8");
    print(f.readlines());
except IOError as e:
    print(e);
finally:
    if f:
        f.close();
# 相当于上面的代码，简化了try----except----finally模块
with open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8") as f:
    print(f.readlines());

错误抛出

使用 raise 语句抛出错误；

 
# ---- 抛出错误 ----
def fn(x):
    if not isinstance(x, int):
        raise TypeError("Type error");
fn("cdsa");

调试

简介：程序能一次写完并正常运行的几率很小，基本不超过 1%，总会有各种各样的 bug 需要修复，有的 bug 很简单，能轻易解决，但有的 bug 很复杂，我们需要知道哪些变量的值是错误的，因此，我们需要调试程序来修复 bug；
方式一：简单粗暴，使用 print 打印出变量，但是我们并不推荐这种方式，因为打印出变量后还得删除打印语句，十分繁琐；
方式二：断言调试（assert）；

格式：assert 断言表达式, 断言失败抛出错误信息，例如：assert n != 0, "n is Zero";
意思是，断言表达式为 True，则继续执行；表达式为 False，则抛出 AssertionError 错误，例如 AssertionError: n is zero!
程序中到处充斥着 assert，和 print 差不多，也不推荐这种方式，我们可以使用 Python -O 来关闭断言，程序遇到 assert 当做 pass 处理；

 
# ---- 断言调试 ----
def fn(x):
    n = int(x);
    assert n != 0, "n is Zero";
    return 10 / n;
print(fn(0));

方式三：logging 的方式；
方式四：pdb && pdb.set_trace()；

-------- pdb --------
Python 的调试器 pdb，让程序以单步方式运行，可以随时查看运行状态；
$ python -m pdb err.py
以参数 -m pdb 启动后，pdb 定位到下一步要执行的代码-> s = '0'。输入命令 l 来查看代码；
输入命令 n 可以单步执行代码；
任何时候都可以输入命令 p 变量名来查看变量；
-------- pdb.set_trace() --------
import pdb，然后，在可能出错的地方放一个 pdb.set_trace()，就可以设置一个断点；
运行代码，程序会自动在 pdb.set_trace() 暂停并进入 pdb 调试环境，可以用命令 p 查看变量，或者用命令 c 继续运行；
1
# err.py import pdb s = '0' n = int(s) pdb.set_trace() # 运行到这里会自动暂停 print(10 / n)
1
# err.py
2
import pdb
3
4
s = '0'
5
n = int(s)
6
pdb.set_trace() # 运行到这里会自动暂停
7
print(10 / n)
2

方式五：IDE调试；

单元测试

概述

是用来对一个模块、一个函数或者一个类进行正确性检验的工作；
测试驱动开发 TDD：Test-Driven Development，以测试为驱动的开发模式，先写测试用例，再写实现代码，最大的好处就是确保一个程序模块的行为符合我们设计的测试用例；
单元测试可以有效地测试某个程序模块的行为，是未来重构代码的信心保证；
单元测试的测试用例要覆盖常用的输入组合、边界条件和异常；
单元测试代码要非常简单，如果测试代码太复杂，那么测试代码本身就可能有bug；
单元测试通过了并不意味着程序就没有bug了，但是不通过程序肯定有bug；

流程

针对测试对象，设计测试用例

比如测试 abs() 函数；
输入正数，比如 1、1.2、0.99，期待返回值与输入相同；
输入负数，比如 -1、-1.2、-0.99，期待返回值与输入相反；
输入 0，期待返回 0；
输入非数值类型，比如 None、[]、{}，期待抛出 TypeError；

引入 Python 自带的 unittest 模块，把上面的测试用例放到一个测试模块里，就是一个完整的单元测试；

引入 unittest，测试类父类 unittest.TestCase；
测试类以 Test 类为前缀；
使用断言判断；

运行单元测试，如果通过，说明测试对象能正常工作，反之，函数有 bug；

示例

# ---- MyDict.py ----
class MyDict(dict):
    def __init__(self, **kw):
        super().__init__(**kw);
    def __getattr__(self, key):
        try:
            return self[key];
        except KeyError:
            raise AttributeError("Dict object has no attribute for %s" % key);
    def __setattr__(self, key, value):
        self[key] = value;
    
# ---- TestMyDict.py ----
import unittest;
from com.thornBird.base.MyDict import MyDict;

class TestMyDict(unittest.TestCase):
    # 在调用每一个测试方法前执行
    def setUp(self):
        print("Before Test");
    # 在调用每一个测试方法后执行
    def tearDown(self):
        print("After Test");
    def testInit(self):
        print("Test 1");
        d = MyDict(a = 1, b = "aaa");
        self.assertEqual(d.a, 1);
        self.assertEqual(d.b, "aaa");
        self.assertTrue(isinstance(d, dict));
    def testDictError(self):
        print("Test 2");
        d = MyDict();
        # 断言错误,d.testKey访问不存在的key时，我们期待抛出AttributeError
        with self.assertRaises(AttributeError):
            value = d.testKey;

# 加上这两行代码，我们就能将该测试文件当作Python脚本运行
if __name__ == '__main__':
    unittest.main();

 
# ---- MyDict.py ----
class MyDict(dict):
    def __init__(self, **kw):
        super().__init__(**kw);
    def __getattr__(self, key):
        try:
            return self[key];
        except KeyError:
            raise AttributeError("Dict object has no attribute for %s" % key);
    def __setattr__(self, key, value):
        self[key] = value;
    
# ---- TestMyDict.py ----
import unittest;
from com.thornBird.base.MyDict import MyDict;
class TestMyDict(unittest.TestCase):
    # 在调用每一个测试方法前执行
    def setUp(self):
        print("Before Test");
    # 在调用每一个测试方法后执行
    def tearDown(self):
        print("After Test");
    def testInit(self):
        print("Test 1");
        d = MyDict(a = 1, b = "aaa");
        self.assertEqual(d.a, 1);
        self.assertEqual(d.b, "aaa");
        self.assertTrue(isinstance(d, dict));
    def testDictError(self):
        print("Test 2");
        d = MyDict();
        # 断言错误,d.testKey访问不存在的key时，我们期待抛出AttributeError
        with self.assertRaises(AttributeError):
            value = d.testKey;
# 加上这两行代码，我们就能将该测试文件当作Python脚本运行
if __name__ == '__main__':
    unittest.main();

文档测试

Python 内置的“文档测试”（doctest）模块可以直接提取注释中的代码并执行测试；

 
class MyDict(dict):
    '''
    >>> d1 = MyDict()
    >>> d1['x'] = 100
    >>> d1.x
    100
    '''''
    def __init__(self, **kw):
        super().__init__(**kw);
    def __getattr__(self, key):
        try:
            return self[key];
        except KeyError:
            raise AttributeError("Dict object has no attribute for %s" % key);
    def __setattr__(self, key, value):
        self[key] = value;
# 引入文档测试模块
if __name__ == "__main__":
    import doctest;
    doctest.testmod();

练习

运行下面的代码，定位错误的源头，并解决错误；

 
from functools import reduce
def str2Num(s):
    return int(s);
def calc(exp):
    ss = exp.split('+');
    ns = map(str2Num, ss);
    return reduce(lambda acc, x: acc + x, ns);
def main():
    r = calc('100 + 200 + 345');
    print('100 + 200 + 345 =', r);
    r = calc('99 + 88 + 7.6');
    print('99 + 88 + 7.6 =', r);
main();

cals 函数里，map 函数将 ss 元素全部转化为 int，7.6 无法转换，错误定位到 str2num 函数上，解决办法是将 r = calc('99 + 88 + 7.6'); 中 7.6 改为整数；

函数式编程

高阶函数

函数返回值可以赋值给一个变量，函数本身也可以赋值给一个变量，并将该变量作为参数传给另一个函数；
map 函数：第一个参数是 f（函数对象），第二个参数是序列（list 等），功能是将变量传入 f 中，返回迭代器；
reduce 函数：第一个参数是 f（函数对象），第二个参数是序列（list等），f 有两个参数，实现逻辑自定义，reduce 将 f 计算结果持续和序列的下一个元素做累计计算，效果：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)；
filter 函数：第一个参数是 f（函数对象），第二个参数是序列（list等），f 有一个参数，实现逻辑自定义，filter 将作用于序列每一个元素，由 f 返回的 true、false 或者另一个函数来来决定是否保留该元素，返回迭代器；
sorted 函数：排序算法，

参数1：需要排序的序列；
参数2：可选，key 函数，作用于每个元素，并根据 key 函数返回的值进行排序，但不会改变序列元素；
参数3：可选，reverse，是否反转；

# ---- 传入参数 ----
def functionCall(x, y, f):
    return f(x) + f(y);
f = abs;
print(functionCall(-1, -2, f));
# ---- map函数 ----
def f(x):
    return x * x;
i = map(f, list(range(10)));
print(list(i));
print(list(map(str, range(10)))); # 将list元素转化为string
# ---- reduce函数 ----
# ---- 将序列[1, 3, 5, 7, 9]变换成整数13579 ----
from functools import reduce;
def f(x, y):
    return x * 10 + y;
print(reduce(f, [1, 3, 5, 7, 9]));
# ---- 传入str，依次到map中找对应的int进行拼接 ----
def str2int(s):
    def f1(x, y):
        return x * 10 + y;
    m = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9};
    def f2(x):
        return m[x];
    return reduce(f1, map(f2, s));
print(str2int("13579"));
# ---- 还可以使用lambda表达式简化函数定义 ----
m = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9};
def f3(x):
    return m[x];
def str2int2(s):
    return reduce(lambda x, y : x * 10 + y, map(f3, "13957"));
# ---- filter函数 ----
def notEmpty(x):
    return x and x.strip();
print(list(filter(notEmpty, ['A', '', 'B', None, 'C', '  '])));
# ---- sorted函数 ----
print(sorted([36, 5, -12, 9, -21]));
print(sorted([36, 5, -12, 9, -21], key = abs));
print(sorted(['bob', 'about', 'Zoo', 'Credit'])); # 默认根据第一个字符ASCII码
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower));
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower, reverse=True));

# ---- 整合 ----
l = list(range(10));
# l.sort(key=lambda item : item, reverse=True);
print(l);
print(list(sorted(l, key=lambda item : item, reverse=True)));
print(list(map(lambda item : item * item, l)));
print(list(filter(lambda item : item % 2 == 0, l)));
print(reduce(lambda x, y : x + y, l));

 
# ---- 传入参数 ----
def functionCall(x, y, f):
    return f(x) + f(y);
f = abs;
print(functionCall(-1, -2, f));
# ---- map函数 ----
def f(x):
    return x * x;
i = map(f, list(range(10)));
print(list(i));
print(list(map(str, range(10)))); # 将list元素转化为string
# ---- reduce函数 ----
# ---- 将序列[1, 3, 5, 7, 9]变换成整数13579 ----
from functools import reduce;
def f(x, y):
    return x * 10 + y;
print(reduce(f, [1, 3, 5, 7, 9]));
# ---- 传入str，依次到map中找对应的int进行拼接 ----
def str2int(s):
    def f1(x, y):
        return x * 10 + y;
    m = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9};
    def f2(x):
        return m[x];
    return reduce(f1, map(f2, s));
print(str2int("13579"));
# ---- 还可以使用lambda表达式简化函数定义 ----
m = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9};
def f3(x):
    return m[x];
def str2int2(s):
    return reduce(lambda x, y : x * 10 + y, map(f3, "13957"));
# ---- filter函数 ----
def notEmpty(x):
    return x and x.strip();
print(list(filter(notEmpty, ['A', '', 'B', None, 'C', '  '])));
# ---- sorted函数 ----
print(sorted([36, 5, -12, 9, -21]));
print(sorted([36, 5, -12, 9, -21], key = abs));
print(sorted(['bob', 'about', 'Zoo', 'Credit'])); # 默认根据第一个字符ASCII码
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower));
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower, reverse=True));
# ---- 整合 ----
l = list(range(10));
# l.sort(key=lambda item : item, reverse=True);
print(l);
print(list(sorted(l, key=lambda item : item, reverse=True)));
print(list(map(lambda item : item * item, l)));
print(list(filter(lambda item : item % 2 == 0, l)));
print(reduce(lambda x, y : x + y, l));

返回函数

闭包结构（Closure）：在函数内部定义内部函数，内部函数可以调用外部函数的局部变量和参数，可以修改 list，不能修改 int 等类型，如果要修改，需要用 nonlocal 关键字（在嵌套函数中内层函数引用外层函数变量）；
内部函数不要引用任何循环变量，或者后续会发生变化的变量；
在调用外部函数时，内部函数不会自动执行；
多次调用外部函数，返回的内部函数是不等的，即使参数一致；

 
# ---- 返回函数 ----
def f():
    l = [];
    for i in range(1, 4):
        def f2():
            return i * i;
        l.append(f2);
    return l;
# 返回的函数引用了变量i，但它并非立刻执行，等到3个函数都返回时，变量i已经变成了3，因此最终结果为9
l1, l2, l3 = f();
print(l1()); # 打印结果9
print(l2()); # 打印结果9
print(l3()); # 打印结果9
# 再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变
def f():
    def f2(j):
        def f3():
            return j * j;
        return f3;
    l = [];
    for i in range(1, 4):
        l.append(f2(i));
    return l;
l1, l2, l3 = f();
print(l1()); # 打印结果1
print(l2()); # 打印结果4
print(l3()); # 打印结果9

匿名函数

lambda 关键字表示匿名函数，冒号分隔，前面是参数，后面是函数体，不用写 return，函数体就代表该函数的返回值；

 
# ---- 匿名函数 ----
print(list(filter(lambda x : x % 2 == 0, range(1, 20))));

装饰器 Decorator

已经定义好的函数，我们要增强其功能，但并不想修改原函数，我们可以定义一个装饰器来完成；
装饰器是一个返回函数，增强的内容在返回函数中实现；
装饰器的调用方法，类似于 java 的注解类，直接写到函数定义上面；
如果装饰器本身就需要参数，那么还需要定义一个返回装饰器，并接受参数的函数；
示例

 
# ---- 装饰器 ----
import time;
def log(fun):
    def wrapper(*args, **keywords):
        print("call %s()" % fun.__name__); # 调用函数对象name属性
        return fun(*args, **keywords);
    return wrapper;
@log
def f():
    print(time.time());
    print(time.localtime(time.time()));
    print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())));
f();
# ---- 带参数的装饰器 ---- 
def log(text):
    def decorator(fun):
        def wrapper(*args, **kw):
            print("%s %s()" % (text, fun.__name__));
            return fun(*args, **kw);
        return wrapper;
    return decorator;
@log("execute")
def f():
    print(time.time());
    print(time.localtime(time.time()));
    print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())));
f();

常见装饰器

@classmethod ---- 对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等，用法类似于 Java 中的静态方法；
@functools.wraps(func) ---- 保留原有函数的名称和 docString，注意：自定义 python 装饰器时一定要记住使用 @functools.wraps(func) 修饰 wrapper；

在 Flask 中使用装饰器遇到 AssertionError: View function mapping is overwriting an existing ---- 报错的大概意思就是存在相同的 view，在 flask 中，如果定义了两个相同函数名的 view，就会报这种报这种错误，例如：
但是上例中的两个函数名分别是 index 和 course，是不相同的，为什么会报这种错？
对于 app.route 这个方法而言，传入的方法都是 external，而不是更深一层的 index 和 course，所以会报上面的错误；
装饰 external 中添加 @wraps(func) 就可以正常运行了；

偏函数

当函数的参数过多需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单；

 
# ---- 偏函数 ----
import functools;
int2 = functools.partial(int, base=2); # 定义新函数，固定住**kw中base=2参数；
print(int2("101010"));
max2 = functools.partial(max, 10); #定义新函数，固定住*args参数中的10，也就是10是固定参数
print(max2(2, 4, 6, 9)); # 相当于max2(10, 2, 4, 6, 9);结果是10

练习

将 list 中每一项按照英文名字规范输出，第一个字母大写，其余小写；

 
l = ['adam', 'LISA', 'barT'];
def f(x):
    return x.capitalize();
print(list(map(f, l)));
# ---- 采用lambda表达式 ----
print(list(map(lambda x : x.capitalize(), l)));

定义一个求累计的函数；

 
# 求累积
def f(l):
    return reduce(lambda x, y : x * y, l);
print(f([1, 2, 3, 4]));

利用 map 和 reduce 编写一个 str2float 函数，把字符串'123.456'转换成浮点数123.456

 
# 先来一个示例，处理小数部分
print(reduce(lambda x, y : x / 10 + y, map(int, list(range(10))[::-1] + [0])));
# string to float
def str2Float(x):
    l1, l2 = x.split(".");
    l2 = l2[::-1] + "0";
    return reduce(lambda x, y : x * 10 + y, map(int, l1)) + reduce(lambda x, y : x / 10 + y, map(int, l2));
print(str2Float("32142.4321"));

求素数

埃氏筛法

列出从 2 开始的所有自然数，第一位一定是个素数，取第一位 2，筛选掉 2 的倍数；
再取第一位 3，一定是个素数，再次筛选掉 3 的倍数……
不断筛选下去，就能得到所有的素数；

 
# 定义一个奇数迭代器
def oddIter():
    n = 1;
    while True:
        n += 2;
        yield n;
# 定义筛选函数，返回是另一个函数
def validate(n):
    return lambda x : x % n > 0;
# 求素数迭代器
def primeNumber():
    yield 2;
    l = oddIter();
    while True:
        n = next(l);
        yield n;
        l = filter(validate(n), l);
l = [];
# 打印100内的素数
for n in primeNumber():
    if n < 100:
        l.append(n);
    else:
        break;
print(",".join(map(str, l)));

方法二

利用 for 循环的过滤功能，每次过滤掉最大元素或最大元素平方根 +1 的因子；

 
# 注意else缩进块，是和for同级的，意思是跳出for循环后再来干擦屁股的事
l = [];
for i in range(2, 100):
    # for j in range(2, i):
    for j in range(2, (int)(math.sqrt(i) + 1)):
        if i % j == 0:
            break;
    else:
        l.append(i);
print(",".join(map(str, l)));

方法三

思维和方法二类似，但代码更简洁，使用到的知识点更多；

 
print("-".join(["a", "b", "c"])); # 将字符串join插入list，返回字符串a-b-c
print(list("%s" % x for x in range(2, 5))); # 格式化int迭代器，并转化为字符串list：['2', '3', '4']
print(",".join("%s" % x for x in range(2, 5))); #结合上面两个功能，输出2,3,4
print(list(x for x in range(2, 10))); # 输出int list
print([y for y in range(2, 10) if 10 % y == 0]); # 输出循环中最大数的因子数列[2, 5]
# int list 排除所有的因子数列，得到素数数列，格式化为字符串，调用join函数，返回素数字符串
print(",".join("%s" % x for x in range(2, 100) if not [y for y in range(2, x) if x % y == 0]));

求回数：回数是指从左向右读和从右向左读都是一样的数，例如 12321，909；

方法一：利用 list 反转字符串；

 
def f(n):
    l = [];
    for item in str(n):
        l.insert(0, item);
    return "".join(l) == str(n);
print(list(filter(f, range(1,100))));

方法二：利用 reduce 翻转字符串

 
def fn(n):
    return str(n) == reduce(lambda x, y : y + x, str(n));
print(list(filter(fn, range(1, 100))));

方法三

利用切片反转字符串
print(list(filter(lambda x : str(x) == str(x)[::-1], range(1, 100))));

对学生姓名或成绩排序；

l = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]; # list 每个元素是 tuple，装载每个学生信息
print(sorted(l)); # 自然排序，按照姓名排序
print(sorted(l, key = lambda x : x[0].lower()));
print(sorted(l, key = lambda x : x[1])); # 按分数排序
print(sorted(l, key = lambda x : x[1], reverse=True)); # 按分数倒序排序

使用闭包返回一个计数函数，每次调用返回递增整数；

 
# 方式一，外层用整形，内层要改变外层的变量，需要使用nonlocal关键字，不推荐这种方式
def fn():
    x = 0;
    def fun():
        nonlocal x;
        x += 1;
        return x;
    return fun;
f1 = fn();
print(f1(), f1(), f1());
# 方式二，外层使用list，内层可以修改list元素
def fn():
    x = [0];
    def fun():
        x[0] += 1;
        return x[0];
    return fun;
f1 = fn();
print(f1(), f1(), f1());

设计一个装饰器，适用于任何函数，打印函数的调用时间

 
def logDecorator(fun):
    def wraper(*args, **kw):
        print("Call %s in %s" % (fun.__name__, time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))));
        return fun(*args, **kw);
    return wraper;
@logDecorator
def test():
    print("test");
test();

面向对象编程

简介

面向对象编程 OOP（Object Oriented Programming），是一种程序设计思想，OOP 把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数；
在 Python 中，所有数据类型都可以视为对象，当然也可以自定义对象，处理方式和 Java 类似；
面向对象 VS 面向过程

面向对象：把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递；
面向过程：把计算机程序视为一系列的命令集合，即一组函数的顺序执行；

Class && Instance

面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的；
一般类规则

常规写法：

class + 类名 + (object)；
class ---- 关键字；
类名 ---- 首字母大写；
object ---- 表示该类是从哪个类继承下来的，object 是所有类的超类，一般情况下，如果没有合适的父类，就用它；

 
# ---- 继承object类 ----
class Student(object):
    def __init__(self, id, name, age):
        self.__id = id;
        self.name = name;
        self.age = age;
    def setId(self, id):
        if id > 0:
            self.__id = id;
        else:
            raise ValueError("Bad data");
    def getId(self):
        return self.__id;
    def printStudentInfo(self):
        print("%s %s %s" % (self.__id, self.name, self.age));
    def getGrade(self):
        if self.age > 40:
            return "C";
        elif self.age > 20:
            return "B";
        else:
            return "A";
hymanHu = Student(1, "HymanHu", 20);
jiangHu = Student(2, "Jianghu", 30);
hymanHu.printStudentInfo();
print(hymanHu.getGrade());
print(hymanHu.name);
# print(hymanHu.__id);
hymanHu.setId(2);
print(hymanHu.getId());
jiangHu.printStudentInfo();
print(jiangHu.getGrade());

type 写法：

参数一：类名；
参数二：父类 tuple，单继承的情况需满足 tuple 的写法；
参数三：dict，class方法名绑定已写好的函数；

 
# ---- type创建类 ----
def fn(self, name="Hyman"):
    print("name is %s" % name);
Hello = type("Hello", (object,), dict(hello = fn));
hello = Hello();
hello.hello();

元类写法：

metaclass 相当于类模版，是 Python 面向对象编程中最难理解，也最难使用的魔术代码，可以这样理解：metaclass ---- class ---- 实例；
创建元类

命名以 metaclass 结尾作为标志，父类是 type；
创建 new 函数，自定义创建类时的方法，参数如下：

当前创建类的对象 ---- typ；
类名 ---- className；
类的父类集合 ---- parentClassList；
类的方法 dict ----classAttrs；

用元类创建类

将元类作为父类：metaclass = MyMetaclass；
Python 解释器在创建 Mylist 类的时候，会调用 MyMetaclass.__new__ 来创建，动态的给 MyList 类添加上了 add 方法；

运用

ORM，一个表对应一个类，因为只有使用者才能根据表机构定义出类来，后面的练习题有相关代码；

 
# ---- 元类创建类 ----
class MyMetaclass(type):
    def __new__(typ, classNmae, parentClassList, classAttrs):
        classAttrs["add"] = lambda self, value : self.append(value);
        return type.__new__(typ, classNmae, parentClassList, classAttrs);
class MyList(list, metaclass=MyMetaclass):
    pass;
l = MyList();
l.add(1);
print(l);

枚举

常规写法

class+ 类名（Enum）:
缩进键值对；

简写：类名 = Enum("类名", ("元素"))；

 
# ----枚举类 ----
from enum import Enum, unique;
Month = Enum("Month", ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'));
# 获取Month属性和方法列表
print(dir(Month));
# value属性则是自动赋给成员的int常量，默认从1开始计数
print(Month.Jan.name, Month.Jan.value);
for month, item in Month.__members__.items():
    print(month, item.value);
# unique 装饰器检查有没有重复值
@unique
class WeekDay(Enum):
    Sun = 0;
    Mon = 1;
    Tue = 2;
    Wed = 3;
    Thu = 4;
    Fri = 5;
    Sat = 6;
print(WeekDay.Mon.name, WeekDay.Mon.value, WeekDay(1));
for weekDay, item in WeekDay.__members__.items():
    print(weekDay, item.value);

属性 && 方法

规则

Python 解释器将 __*** 的属性和方法翻译成了 _类名__***，所以我们依旧可以使用解释后的名称对其进行操作，只是这是一种约定俗成而已，总的来说，Python 本身没有任何机制阻止你干坏事，一切全靠自觉；

属性：

私有属性：self._***；
公有属性：self.***；
类属性 && 实例属性

类属性：定义在类里面的属性；
实例属性：实例化类后添加的属性；
注意：千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性；
1
# ---- 类属性&&实例属性 ---- class Student(object): name = "HymanHu" hyman = Student(); print(Student.name); # 类属性，结果HymanHu print(hyman.name); # 实例属性，在没有给实例属性赋值，且属性名和类属性一样的情况下，值相同，HymanHu hyman.name = "JiangHu"; print(Student.name); # 类属性，结果HymanHu print(hyman.name); # 实例属性，结果JiangHu
1
# ---- 类属性&&实例属性 ----
2
class Student(object):
3
name = "HymanHu"
4
hyman = Student();
5
print(Student.name); # 类属性，结果HymanHu
6
print(hyman.name); # 实例属性，在没有给实例属性赋值，且属性名和类属性一样的情况下，值相同，HymanHu
7
hyman.name = "JiangHu";
8
print(Student.name); # 类属性，结果HymanHu
9
print(hyman.name); # 实例属性，结果JiangHu
2

属性限制

如果要限制实例属性，需要在类中调用 __slots__ 函数，将能够动态绑定的属性名称加上，但不会对类的子类其作用；
1
# ---- 限制实例属性的动态绑定 ---- class Human(object): __slots__ = ("name", "age"); hyman = Human(); hyman.name = "Hyman"; #hyman.sex = "man"; print(hyman.name); #print(hyman.sex); # AttributeError: 'Human' object has no attribute 'sex'
1
# ---- 限制实例属性的动态绑定 ----
2
class Human(object):
3
__slots__ = ("name", "age");
4
hyman = Human();
5
hyman.name = "Hyman";
6
#hyman.sex = "man";
7
print(hyman.name);
8
#print(hyman.sex); # AttributeError: 'Human' object has no attribute 'sex'
2

方法：

特殊含义方法：__***__；

__init__(self, name, age)

类似于构造器，它的第一个参数是 self，其余参数为该类模版的各种属性；
如果类模版定义了有参构造，实例化的时候必须带参数，这点和 Java 不同，Python 类不认同多个构造器的情况；

__name__ == "__main__"

Python 不像编译型语言，先把代码编译成二进制文件执行，他是逐行解释并执行的，所以 Python 是从脚本第一行开始执行的，没有一个统一的入口；
上面的判断，用在模块之间的引用上，如果在 A 模块加了 __name__ == "__main__" 判断，当 A 模块被 B 模块引用时，执行 B 模块，不会执行 A 模块中 __name__ == "__main__" 判断里面的代码；

__str__ && __repr__

__str__：父类该方法是类的相关信息字符串，自定义相当于重写 str 方法；
__repr__：功能和 __str__ 类似，用于调试；

 
class Student(object):
    def __init__(self, name):
        self.name = name;
    def __str__(self):
        return "Student object: %s" % self.name;
    __repr__ = __str__;
hyman = Student("Hyman");
print(hyman);

__iter__ && __next__ && __getitem__

定义一个类（迭代对象），可以像 list 一样，做 for in 循环、获取某个元素、做切片操作，需要重写这些方法；
以斐波拉数列为例

# ---- 以类的方式实现斐波拉数列 ----
class Fib(object):
    def __init__(self, max):
        self.a, self.b = 0, 1;
        self.max = max;
    def __iter__(self):
        return self;
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b;
        if self.a > self.max:
            raise StopIteration();
        return self.a;
    # 该方法返回迭代对象元素，item可能是int下标，也可以是切片对象slice，没有对step和负号处理
    def __getitem__(self, item):
        if isinstance(item, int):
            a, b = 1, 1;
            for i in range(item):
                a, b = b, a + b;
            return a;
        if isinstance(item, slice):
            start = item.start;
            end = item.stop;
            if start is None:
                start = 0;
            a, b = 1, 1;
            L = [];
            for i in range(end):
                if i >= start:
                    L.append(a);
                a, b = b, a + b;
            return L;
result = "";
fib = Fib(100);
for i in fib:
    result += str(i) + ",";
print(result[:-1]);
print(fib[3]);
print(fib[:5]);

 
# ---- 以类的方式实现斐波拉数列 ----
class Fib(object):
    def __init__(self, max):
        self.a, self.b = 0, 1;
        self.max = max;
    def __iter__(self):
        return self;
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b;
        if self.a > self.max:
            raise StopIteration();
        return self.a;
    # 该方法返回迭代对象元素，item可能是int下标，也可以是切片对象slice，没有对step和负号处理
    def __getitem__(self, item):
        if isinstance(item, int):
            a, b = 1, 1;
            for i in range(item):
                a, b = b, a + b;
            return a;
        if isinstance(item, slice):
            start = item.start;
            end = item.stop;
            if start is None:
                start = 0;
            a, b = 1, 1;
            L = [];
            for i in range(end):
                if i >= start:
                    L.append(a);
                a, b = b, a + b;
            return L;
result = "";
fib = Fib(100);
for i in fib:
    result += str(i) + ",";
print(result[:-1]);
print(fib[3]);
print(fib[:5]);

__getattr__

对象直接调用不存在的方法或属性的时候，会抛出错误，重写该方法能将一个类的所有属性和方法调用全部动态化处理；

 
# ---- 动态处理类的属性和方法 ----
# ---- buil rest api uri ----
class Chain(object):
    def __init__(self, path = ""):
        self.path = path;
    def __getattr__(self, item):
        return Chain("%s/%s" % (self.path, item));
    def __str__(self):
        return self.path;
    __repr__ = __str__;
chain = Chain();
# /user/status/list
print(chain.user.status.list);

__call__ && callable

__call__，重写该方法后，可直接将类实例按照方法来调用；
callable，判断一个对象是否是一个可调用对象；

 
# ---- call方法 ----
class Student(object):
    def __init__(self, name):
        self.name = name;
    def __call__(self, *args, **kwargs):
        print("My name is %s" % self.name);
student = Student("Hyman");
print(callable(student));
student();

私有方法：__***；
公共方法：***；

def printStudentInfo(self) ---- 普通的 public 方法，将类实例数据按照需求封装起来；

@property && @***.setter ---- 相当于 Java 中的 get、set 方法

在类中不直接定义类属性，而是定义两个函数（获取属性和设置属性值），使用 Python 内置装饰器 @property 来完成（负责将一个函数变成属性调用）；
在设置值的时候，要调用 hyman.setAge = 44; 的方式，而不能直接调用 # hyman.setAge(44); 这样的方式；

 
# ---- get、set方法
class Student(object):
    # _age = 0;
    @property
    def getAge(self):
        return self._age;
    @getAge.setter
    def setAge(self, age):
        if not isinstance(age, int):
            raise ValueError("Age must integer.");
        if age < 0 or age > 200:
            raise ValueError("Age must be in 0 ~ 200.");
        self._age = age;
hyman = Student();
# hyman.setAge(44);
hyman.setAge = 44;
print(hyman.getAge);

静态语言 && 动态语言

静态语言

类似 Java，严格要求类型，比如定义一个方法或者函数，参数是 Animal，那么只能传入 Animal 或者其子类；

动态语言

“鸭子类型”，一个对象只要“看起来像鸭子，走起路来像鸭子”，那么它就能当鸭子用；
动态传递参数：并不严格要求类型，比如定义一个方法或函数，参数是 Animal，调用的时候，除了 Animal 和其子类，还可以传入其他类型对象；
动态绑定属性和方法；

示例

1
# ---- 动态传递参数 ---- class Clock(object): def run(self): print("Clock running……"); def run(animal): animal.run(); dog = Dog(); cat = Cat(); clock = Clock(); run(dog); run(cat); run(clock); # ---- 动态绑定属性和方法 ---- from types import MethodType; class Human(object): pass; def setAge(self, age): self.age = age; def setSex(self, sex): self.sex = sex; Human.setSex = setSex; # 给类动态绑定方法 jianghu = Human(); jianghu.setSex("man"); print(jianghu.sex); # 给实例绑定属性和方法，但是对另外的实例不起作用 hyman = Human(); hyman.name = "HymanHu"; hyman.setAge = MethodType(setAge, hyman); # 第一参数函数名，第二个参数是实例对象 hyman.setAge(33); print(hyman.name); print(hyman.age);
1
# ---- 动态传递参数 ----
2
class Clock(object):
3
def run(self):
4
print("Clock running……");
5
def run(animal):
6
animal.run();
7
dog = Dog();
8
cat = Cat();
9
clock = Clock();
10
run(dog);
11
run(cat);
12
run(clock);
13
# ---- 动态绑定属性和方法 ----
14
from types import MethodType;
15
class Human(object):
16
pass;
17
def setAge(self, age):
18
self.age = age;
19
def setSex(self, sex):
20
self.sex = sex;
21
Human.setSex = setSex;
22
# 给类动态绑定方法
23
jianghu = Human();
24
jianghu.setSex("man");
25
print(jianghu.sex);
26
# 给实例绑定属性和方法，但是对另外的实例不起作用
27
hyman = Human();
28
hyman.name = "HymanHu";
29
hyman.setAge = MethodType(setAge, hyman); # 第一参数函数名，第二个参数是实例对象
30
hyman.setAge(33);
31
print(hyman.name);
32
print(hyman.age);
2

封装继承多态

封装：类就是一种封装，将对象的属性和方法包装到一个单元中，外部使用对象提供服务，不用操心对象内部具体的实现；
继承

表现了层次结构，子类继承了父类的属性和方法；
多重继承：

Java 只允许单一继承，Python 允许多重继承；
定义类的时候，将多个父类写在括号内，一般情况下，我们在设计类的时候，都是单一继承，但考虑到额外添加父类，才采用多重继承，这种思想叫 MixIn，额外父类在定义的时候加上 MixIn 后缀；
Python 自带的库也是用了不少 MixIn，比如 TCPServer 和 UDPServer 这两类网络服务类，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由 ForkingMixIn 和 ThreadingMixIn 提供，通过组合，我们就可以创造出合适的服务来：class MyTCPServer(TCPServer, ForkingMixIn):；

1
class Animal(object): def run(self): print("Animal running……"); class Dog(Animal): pass; class Cat(Animal): pass; dog = Dog(); cat = Cat(); print(isinstance(dog, Dog)); print(isinstance(dog, Animal)); dog.run(); cat.run(); # ---- 多重继承 ---- class FlyMixIn(object): def fly(self): print("Animal fly……"); class Bird(Animal, FlyMixIn): pass; bird.run(); bird.fly();
1
class Animal(object):
2
def run(self):
3
print("Animal running……");
4
class Dog(Animal):
5
pass;
6
class Cat(Animal):
7
pass;
8
dog = Dog();
9
cat = Cat();
10
print(isinstance(dog, Dog));
11
print(isinstance(dog, Animal));
12
dog.run();
13
cat.run();
14
# ---- 多重继承 ----
15
class FlyMixIn(object):
16
def fly(self):
17
print("Animal fly……");
18
class Bird(Animal, FlyMixIn):
19
pass;
20
bird.run();
21
bird.fly();
2

多态：相同的行为，不同的实现；

 
class Animal(object):
    def run(self):
        print("Animal running……");
class Dog(Animal):
    def run(self):
        print("Dog running……");
class Cat(Animal):
    def run(self):
        print("Cat running……");
dog = Dog();
cat = Cat();
dog.run();
cat.run();

对象信息

类型判断

type() 判断：返回对应的 class 类型；

1
# ---- 类型判断一 ---- print(type(123)); # <class 'int'> print(type("aaaa")); # <class 'str'> print(type(None)); # <class 'NoneType'> print(type(abs)); # <class 'builtin_function_or_method'> print(type(dog)); # <class '__main__.Dog'> import types; print(type("cdsa") == str); print(type(run) == types.FunctionType); print(type(abs) == types.BuiltinFunctionType); print(type(lambda x : x + 1) == types.LambdaType); print(type((x for x in range(1, 10))) == types.GeneratorType);
1
# ---- 类型判断一 ----
2
print(type(123)); # <class 'int'>
3
print(type("aaaa")); # <class 'str'>
4
print(type(None)); # <class 'NoneType'>
5
print(type(abs)); # <class 'builtin_function_or_method'>
6
print(type(dog)); # <class '__main__.Dog'>
7
import types;
8
print(type("cdsa") == str);
9
print(type(run) == types.FunctionType);
10
print(type(abs) == types.BuiltinFunctionType);
11
print(type(lambda x : x + 1) == types.LambdaType);
12
print(type((x for x in range(1, 10))) == types.GeneratorType);
2

isinstance() 判断；

1
# ---- 类型判断二 ---- print(isinstance("dsac", str)); print(isinstance([1, 2], (list, tuple))); # 还能用几个候选项用于判断 print(isinstance(run, types.FunctionType)); print(isinstance(dog, Animal));
1
# ---- 类型判断二 ----
2
print(isinstance("dsac", str));
3
print(isinstance([1, 2], (list, tuple))); # 还能用几个候选项用于判断
4
print(isinstance(run, types.FunctionType));
5
print(isinstance(dog, Animal));
2

总是优先使用 isinstance() 来判断类型，因为它能把指定类型以及其子类一网打尽；

获取属性和方法

dir() 函数，返回一个 list，元素是该对象的属性和方法；
注意 __***__，此类属性和方法在 Python 中是有特殊含义的，比如 __len__，当你调用 len('ABC') 时候，等价于：'ABC'.__len__()，我们也可以在自定义的类中重写这些特殊方法；

1
# ---- 获取对象属性和方法 ---- print(dir("dsad")); print(dir(dog));
1
# ---- 获取对象属性和方法 ----
2
print(dir("dsad"));
3
print(dir(dog));
2

getattr()、setattr()、hasattr()，对属性或方法进行判断和修改

1
# ---- 操作对象属性 ---- print(hasattr(hymanHu, "name")); setattr(hymanHu, "name", "aaaaa"); print(getattr(hymanHu, "name")); #print(getattr(hymanHu, "name1")); # 获取不存在的属性，抛出AttributeError # ---- 操作对象方法 ---- print(hasattr(hymanHu, "printStudentInfo")); func = getattr(hymanHu, "printStudentInfo"); func();
1
# ---- 操作对象属性 ----
2
print(hasattr(hymanHu, "name"));
3
setattr(hymanHu, "name", "aaaaa");
4
print(getattr(hymanHu, "name"));
5
#print(getattr(hymanHu, "name1")); # 获取不存在的属性，抛出AttributeError
6
# ---- 操作对象方法 ----
7
print(hasattr(hymanHu, "printStudentInfo"));
8
func = getattr(hymanHu, "printStudentInfo");
9
func();
2

练习

创建 Student 类，并添加一个类属性，用于统计学生人数，每次实例化的时候自增 1；

 
class Student(object):
    count = 0;
    def __init__(self, name):
        Student.count += 1;
        self.name = name;
hyman = Student("HymanHu");
jianghu = Student("JiangHu");
print(Student.count);

创建 Student 类，利用 @property 提供两个属性 age、birthday，其中 birthday 只读，需要 age 计算；

 
import datetime;
class Student(object):
    @property
    def getAge(self):
        return self._age;
    @getAge.setter
    def setAge(self, age):
        if not isinstance(age, int):
            raise ValueError("Age must integer.");
        if age < 0 or age > 200:
            raise ValueError("Age must be in 0 ~ 200.");
        self._age = age;
    @property
    def birthday(self):
        return datetime.datetime.now().year - self._age;
hyman = Student();
# hyman.setAge(44);
hyman.setAge = 44;
print(hyman.getAge);
print(hyman.birthday);

创建 Student 类，将性别 gender 改为枚举类；

 
@unique
class Gender(Enum):
    Male = 0;
    Female = 1;
class Student(object):
    def __init__(self, name, gender):
        self.name = name;
        self.gender = gender;
hyman = Student("Hyman", Gender.Male);
print(hyman.name, hyman.gender);

利用元类编写一个简易ORM框架

# 创建列类，添加列名和数据类型属性
class Field(object):
    def __init__(self, columnName, columnType):
        self.columnName = columnName;
        self.columnType = columnType;
    def __str__(self):
        return "<%s : %s>" % (self.__class__.__name__, self.columnName);
    __repr__ = __str__;
# 根据不同的数据类型创建不同的列子类
class StringField(Field):
    def __init__(self, columnName):
        super(StringField, self).__init__(columnName, "varchar(100)");
class IntegerField(Field):
    def __init__(self, columnName):
        super(IntegerField, self).__init__(columnName, "bigint");
field = Field("userId", int);
print(field);

# 创建Model元类
class ModelMetaclass(type):
    '''
        思路：Model是dict子类，每个key对应一个列对象
        1、将不同的Model子类中classAttrs（属性和方法）的属性过滤出来，装载到mappings里面
        2、返回Model对应的表名，在此默认Model子类类名
    '''
    def __new__(typ, className, parentClassList, classAttrs):
        print("Metaclass new model……");
        if className == "Model":
            return type.__new__(typ, className, parentClassList, classAttrs);
        print("Found model: %s" % className);
        mappings = dict();
        for key, value in classAttrs.items():
            if isinstance(value, Field):
                print("Found mappings: %s : %s" % (key, value));
                mappings[key] = value;
        # 删除classAttrs中的列属性
        for key in mappings.keys():
            classAttrs.pop(key);
        classAttrs["__mappings__"] = mappings; # 列和属性的映射关系
        classAttrs["__table__"] = className; # 假定表名和类名一致
        return type.__new__(typ, className, parentClassList, classAttrs);

# 由ModelMetaclass创建Model
class Model(dict, metaclass=ModelMetaclass):
    def __init__(self, **kw):
        print("init model……");
        super(Model, self).__init__(**kw);
    def __getattr__(self, key):
        try:
            return self[key];
        except KeyError:
            raise AttributeError("Model object has no attribute %s" % key);
    def __setattr__(self, key, value):
        self[key] = value;
    '''
        1、遍历mappings，得到对应的列对象，build sql语句
        2、调用getattr函数，将每列的值装载到args这个list中
    '''
    def save(self):
        fields = [];
        params = [];
        args = [];
        for key, value in self.__mappings__.items():
            fields.append(value.columnName);
            params.append("?");
            args.append(getattr(self, key, None));
        sql = "insert into %s (%s) values (%s)" % (self.__table__, ",".join(fields), ",".join(params));
        print("SQL : %s" % sql);
        print("Args : %s" % str(args));

class User(Model):
    id = IntegerField("id");
    name = StringField("user_name");
    email = StringField("email");
    password = StringField("password");

user = User(id = 1, name = "HymanHu", email = "HymanHu@163.com", password = "111111");
user.save();

 
# 创建列类，添加列名和数据类型属性
class Field(object):
    def __init__(self, columnName, columnType):
        self.columnName = columnName;
        self.columnType = columnType;
    def __str__(self):
        return "<%s : %s>" % (self.__class__.__name__, self.columnName);
    __repr__ = __str__;
# 根据不同的数据类型创建不同的列子类
class StringField(Field):
    def __init__(self, columnName):
        super(StringField, self).__init__(columnName, "varchar(100)");
class IntegerField(Field):
    def __init__(self, columnName):
        super(IntegerField, self).__init__(columnName, "bigint");
field = Field("userId", int);
print(field);
# 创建Model元类
class ModelMetaclass(type):
    '''
        思路：Model是dict子类，每个key对应一个列对象
        1、将不同的Model子类中classAttrs（属性和方法）的属性过滤出来，装载到mappings里面
        2、返回Model对应的表名，在此默认Model子类类名
    '''
    def __new__(typ, className, parentClassList, classAttrs):
        print("Metaclass new model……");
        if className == "Model":
            return type.__new__(typ, className, parentClassList, classAttrs);
        print("Found model: %s" % className);
        mappings = dict();
        for key, value in classAttrs.items():
            if isinstance(value, Field):
                print("Found mappings: %s : %s" % (key, value));
                mappings[key] = value;
        # 删除classAttrs中的列属性
        for key in mappings.keys():
            classAttrs.pop(key);
        classAttrs["__mappings__"] = mappings; # 列和属性的映射关系
        classAttrs["__table__"] = className; # 假定表名和类名一致
        return type.__new__(typ, className, parentClassList, classAttrs);
# 由ModelMetaclass创建Model
class Model(dict, metaclass=ModelMetaclass):
    def __init__(self, **kw):
        print("init model……");
        super(Model, self).__init__(**kw);
    def __getattr__(self, key):
        try:
            return self[key];
        except KeyError:
            raise AttributeError("Model object has no attribute %s" % key);
    def __setattr__(self, key, value):
        self[key] = value;
    '''
        1、遍历mappings，得到对应的列对象，build sql语句
        2、调用getattr函数，将每列的值装载到args这个list中
    '''
    def save(self):
        fields = [];
        params = [];
        args = [];
        for key, value in self.__mappings__.items():
            fields.append(value.columnName);
            params.append("?");
            args.append(getattr(self, key, None));
        sql = "insert into %s (%s) values (%s)" % (self.__table__, ",".join(fields), ",".join(params));
        print("SQL : %s" % sql);
        print("Args : %s" % str(args));
class User(Model):
    id = IntegerField("id");
    name = StringField("user_name");
    email = StringField("email");
    password = StringField("password");
user = User(id = 1, name = "HymanHu", email = "HymanHu@163.com", password = "111111");
user.save();

2
运行结果

模块

简介

在计算机开发的过程中，随着代码越写越多，维护就越来越麻烦，为了编写易于维护的代码，我们将函数分组，分别放在不同的文件里，形成模块，在 Python 中，一个 .py 就是一个模块；
优点

提高了代码的可维护性、重用性（内置模块或者第三方模块）；
避免函数名和变量名冲突，尽量不要和内置模块函数名一致，不同人写的模块名如果相同，那么在模块前面添加包名，一个包下面必须有 __init__.py 文件，若不然 Python 只会当它是普通文件，而不是一个包；

文件 www.py 的模块名就是 mycompany.web.www，两个文件 utils.py 的模块名分别是 mycompany.utils 和 mycompany.web.utils；

规则

模块名要遵循 Python 变量命名规范，不要使用中文、特殊字符；
模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在 Python 交互环境执行 import abc，若成功则说明系统存在此模块；

导入模块

Source Root

Source Root 概念非常重要，当你在代码中写相对路径的时候，就是以 Source Root 为起点进行查询，PyCharm 以当前的项目文件夹为默认 Source Root，Cmd 以当前路径作为 Source Root，这也是为啥我们在每个模块中将项目根目录添加到 sys.path 的原因，相当于在指定 Source Root；
Pycharm 也可以自定义 Source Root，然后进行导入；

import orm;

导入方式

import 模块

import os;

from 包路径 import 模块

from utils import spider_util;

from 包路径.模块 import 类

from datetime import datetime;
from bs4 import BeautifulSoup;

注意：当模块名和包名一致时，导入会报错，比如： from base import base，除非将 base 包设置为 Source Root；

自定义模块

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
'''
模块注释文档
'''
# 将项目根目录添加到 sys.path，解决 cmd 下执行该模块找不到包的问题
import sys, os;
current_path = os.path.abspath(os.path.dirname(__file__));
separator = "\\" if os.name == "nt" else "/";
project_name = "python_spider" + separator;
root_path = current_path[:current_path.find(project_name) + len(project_name)];  # 获取项目根目录
sys.path.append(root_path);
import sys
def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')
if __name__=='__main__':
    test()

第 1 行注释可以让 py 文件直接在 Unix/Linux/Mac 上运行；
第 2 行注释表示解释器以 UTF-8 编码解释该 py 文件；
第 3 行使用 __author__ 变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；
第 4 行换行；
第 5 行是多行注释字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
第 6 ~ 12 行将项目根目录导入 sys.path，以便在 cmd 下执行该文件能找到导入的包；
中间部分导入模块，并书写本模块业务逻辑代码；
最后 Python 解释器把一个特殊变量 __name__ 置为 __main__，而如果在其他地方导入该模块时，if 判断将失败，因此，这种 if 测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试；

获取模块

根据模块路劲获取模块相关信息；
__import__(name, globals, locals, fromlist, level)；

name ---- 模块全路径；
globals ---- globals()；
locals ---- locals()；
fromlist ---- 指明需要导入的子模块名；
level ---- 指定导入方式；

示例

 
# ---- 根据模块路径获取module ----
def getModel(module_name):
    n = module_name.rfind('.');
    if n == (-1):
        mod = __import__(module_name, globals(), locals());
    else:
        name = module_name[n + 1:];
        mod = getattr(__import__(module_name[:n], globals(), locals(), [name]), name);
    for attr in dir(mod):
        if attr.startswith('_'):
            continue;
        fn = getattr(mod, attr);
        print(fn);
        # 获取fn属性
        # if callable(fn):
        #     method = getattr(fn, '__method__', None);
        #     path = getattr(fn, '__route__', None);
module = getModel("com.thornBird.base.io.ProduceAndConsumer");

第三方模块

简介：

在 Python 中，第三方模块是通过包的管理工具 pip 完成的，对于 Linux 系统，这个步骤可以省略，对于 Windows 系统，要确保安装 Python 的时候选择了 pip 和 Add python.exe to Path；
pip 和 pip3 版本不同，都位于 Scripts\ 目录下，Python2 使用 pip，Python3 使用 pip 或者 pip3；
升级 pip：pip install --upgrade pip；
查看版本：pip -V；

安装：

方法一：

使用 pip | conda 命令安装，一般来说，第三方库都会在 Python 官方的 pypi.python.org 网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者 pypi 上搜索：

pip install Pillow；
pip install Pollow==版本号；
pip install -U Pillow ---- 如果已安装就升级到最新；
pip uninstall Pillow；
pip list；
conda install pip ---- 安装包时，提示 WARNING: You are using pip version 19.3.1; however, version 20.0.2 is available. You should consider upgrading via the 'python -m pip install --upgrade pip' command. ---- pip 版本没有升级，导致安装不了新的包，需要在 Anaconda 下升级 pip；

如果在窗口命令中提示找不到 pip 命令，也可以通过 python 命令运行 pip 模块，例如：python -m pip install scrapy；

安装目录： C:\Users\hujiang\AppData\Local\pip\cache\***；
如果需要安装的三方库比较多，pip 安装费时费力，还要考虑兼容性的问题，可选择 Anaconda，这是一个基于 Python 的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把数十个第三方模块自动安装好了，非常简单易用；

方法二：

利用 Pycharm 等编译器进行可视化安装；

安装超时解决方案

添加超时时间：pip --default-timeout=100 install mysql-connector；
临时更改源为国内镜像

阿里镜像：pip install keras==2.1.0 -i https://mirrors.aliyun.com/pypi/simple/
清华镜像：pip install keras==2.1.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

永久更改源为国内镜像

修改文件：修改C:\Users\86136\AppData\Roaming\pip\pip.ini
命令修改阿里镜像：pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
命令修改镜像：pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

conda

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes ---- 修改当前用户文件夹下 .condarc 文件；

pip install && conda install

pip install：是 Python 官方推荐的包管理工具，执行 wheels 或源码格式的包，需要系统内安装了兼容的编译工具和所需要的库文件；
conda install：是一个跨平台的包和运行环境管理工具，其安装的包通常来自于 Anaconda repository 和 Anaconda Cloud，和 pip install 不同的是，Conda 包是二进制格式的，因此无需预先安装编译器，除此之外，Conda 不仅可以安装 Python 包，还可以安装 C、C++ 等其他语言包；

模块搜索路径

当我们试图加载一个模块时，Python 会在指定的路径下搜索对应的 .py 文件，如果找不到，就会报错；
默认情况下，Python 解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在 sys 模块的 path 变量中；
如果我们要添加自己的搜索目录，有两种方法

方法一：直接修改 sys.path，添加要搜索的目录（这种方法是在运行时修改，运行结束后失效）：

import sys;
sys.path.append('/Users/michael/my_py_scripts');

方法二：设置环境变量 PYTHONPATH，该环境变量的内容会被自动添加到模块搜索路径中，设置方式与设置 Path 环境变量类似，注意只需要添加你自己的搜索路径，Python 自己本身的搜索路径不受影响；

进程 && 线程

相关概念（Process & Thread）

多任务

操作系统可以同时执行多个任务，比如，你一边听歌，一边编辑 word 文档、一边下载电影……，还有很多任务是在后台悄悄执行的，只是没有展示在桌面上而已，现代操作系统都是多任务的；
CPU 执行代码都是顺序的，那么单核 CPU 是怎么实现多任务的呢？操作系统轮流让 CPU 执行多个任务，任务 1 执行 0.01 秒，切换到任务 2 执行 0.01 秒…… CPU 的速度很快，给人的感觉是多任务同时执行，其实是交替执行的，真正并行执行多个任务的是多核 CPU，虽然多核 CPU 已经很普及了，但任务数量远大于 CPU 核心数，操作系统也会自动将多任务轮流调度到核心 CPU 上；

进程（Process）

对于操作系统来说，一个任务就是一个进程，比如打开一个浏览器就是一个浏览器进程、打开记事本就是一个记事本进程、打开一个 Word 就是一个 Word 进程……；
一个进程至少有一个线程；

线程（Thread）

一个进程可能不止干一件事情，比如 Word 进程，我们在输入的时候，进程还会检查拼写、打印等，这些在进程内部需要同时运行的子任务成为线程；

进程线程区别

多进程

稳定性高，一个进程崩溃了不会影响其他进程，著名的 Apache 最早就是采用多进程模式；
同一个变量，各自有一份拷贝存在于进程中，不受影响；
创建进程的代价大，在 Unix/Linux 系统下，用 fork 调用还行，在 Windows 下创建进程开销巨大，另外，操作系统能同时运行的进程数也是有限的，在内存和 CPU 的限制下，如果有几千个进程同时运行，操作系统连调度都会成问题；

多线程

效率高于多进程，微软的 IIS 服务器默认采用多线程模式；
稳定性不高，任何一个线程挂掉都有可能给影响其他线程，因为所有线程共享内存；
所有变量都是线程共享的，任一变量都能被任一线程修改，需要注意数据共享中一致性的问题；

在 Thread 和 Process 中，应当优选 Process，因为 Process 更稳定，而且，Process 可以分布到多台机器上，而 Thread 最多只能分布到同一台机器的多个 CPU 上；
无论是多进程还是多线程，只要数量一多，效率肯定上不去；

任务类型

计算密集型

要进行大量的计算，消耗 CPU 资源，比如计算圆周率、对视频进行高清解码等等，全靠 CPU 的运算能力；
Python 这样的脚本语言运行效率很低，完全不适合计算密集型任务，对于计算密集型任务，最好用 C 语言编写；

IO 密集型

涉及到网络、磁盘 IO 的任务都是 IO 密集型任务，例如 web 任务，这类任务的特点是 CPU 消耗很少，任务的大部分时间都在等待 IO 操作完成，任务越多，CPU 效率越高，但也有一个限度；
最合适的语言就是开发效率最高的语言，脚本语言是首选，C 语言最差；

Python 中实现多任务模式

多进程模式；
多线程模式；
多进程 + 多线程模式；
-----------------------------
通常我们会设计 Master-Worker 模式，Master 负责分配任务，Worker 负责执行任务，因此，多任务环境下，通常是一个 Master，多个 Worker；
多任务之间往往是有关联的，需要相互通信和协调，多以，多进程和多线程程序的复杂度要远高于单线程的，涉及到同步、数据共享、事务等问题，但有时我们不得不编写，比如看电影，就必须一个线程播放视频，另一个线程同步播放音频；

多进程

fork 函数

Unix/Linux 系统提供了一个非常特殊的函数 fork，普通的函数调用一次返回一次，而它调用一次返回两次，操作系统会自动将当前进程（父进程）复制一份（子进程），然后分别在父进程和子进程中返回，父进程返回子进程 ID，而子进程永远返回0，只要调用 getppid() 就能拿到父进程ID；
Windows 系统没有 fork 函数；
示例

 
# ---- fork函数 ----
# 只在Unix/Linux系统上执行
import os;
print("Process %s start" % os.getpid());
childPId = os.fork();
if childPId == 0:
    print("I am child process(%s) and my parent is %s" % (os.getpid(), os.getppid()));
else:
    print("I(%s) just create child process, id is %s" % (os.getpid(), childPId));

Process

要跨平台实现多进程，需要 multiprocessing 模块，它提供了一个 Process 类来表示一个进程对象；
join() ---- 进程同步，意思是调用该方法的进程执行完后，才执行后面的代码；
terminate() ---- 强行结束进程；
示例

 
# ---- Process ----
from multiprocessing import Process;
import os;
def processCall(name):
    print("Run process %s(pid = %s)" % (name, os.getpid()));
if __name__ == "__main__":
    print("Parent Process is %s" % (os.getpid()));
    # 创建进程实例，传入函数以及参数
    childProcess = Process(target=processCall, args=("test",));
    print("Child process start");
    # 开始进程
    childProcess.start();
    # 等childProcess执行完
    childProcess.join();
    print("Child process is end");

Pool

如果要大量启动子进程，可以用进程池的方式批量创建；
Pool 默认大小是 CPU 的核数；
示例

 
# ---- Pool ----
from multiprocessing import Pool;
import os, time, random;
def logTime(processName):
    print("Run task(%s), pid is %s" % (processName, os.getpid()));
    start = time.time();
    time.sleep(random.random() * 3);
    end = time.time();
    print("This task(%s) run %0.2f seconds" % (processName, (end - start)));
if __name__ == "__main__":
    print("Parent process is %s" % os.getpid());
    pool = Pool(4);
    for i in range(5):
        pool.apply_async(logTime, args=("process" + str(i),));
    print("Waiting all process done");
    # close调用后不能再添加进程了
    pool.close();
    # join等待多个子进程执行完毕
    pool.join();
    print("All process done");

子进程（subprocess）

创建子进程后，有时我们还要控制子进程的输入和输出，subprocess 模块提供了相应的功能；
示例

1
# ---- subprocess输出 ---- # 模拟执行命令nslookup www.baidu.com import subprocess; print("$ nslookup www.baidu.com"); r = subprocess.call(["nslookup", "www.baidu.com"]); print("Result:", r); # ---- subprocess输入 ---- import subprocess; print("$ nslookup"); subP = subprocess.Popen(['nslookup'], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE); ''' communicate模拟输入相当于输入以下三行命令 set q=mx python.org exit 并将执行的结果放到output、err两个变量中，代表正确执行结果和错误结果 ''' output, err = subP.communicate(b'set q=mx\npython.org\nexit\n'); print(output); print("Exit code:", subP.returncode);
1
# ---- subprocess输出 ----
2
# 模拟执行命令nslookup www.baidu.com
3
import subprocess;
4
print("$ nslookup www.baidu.com");
5
r = subprocess.call(["nslookup", "www.baidu.com"]);
6
print("Result:", r);
7
8
# ---- subprocess输入 ----
9
import subprocess;
10
print("$ nslookup");
11
subP = subprocess.Popen(['nslookup'], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE);
12
'''
13
communicate模拟输入
14
相当于输入以下三行命令
15
set q=mx
16
python.org
17
exit
18
并将执行的结果放到output、err两个变量中，代表正确执行结果和错误结果
19
'''
20
output, err = subP.communicate(b'set q=mx\npython.org\nexit\n');
21
print(output);
22
print("Exit code:", subP.returncode);
2

进程间通信

进程间通信是通过 Queue、Pipes 等实现的；
Queue 为例，在父进程中创建两个子进程，一个往 Queue 里写数据，一个从 Queue 里读数据；
示例

 
# ---- 进程通信 ----
from multiprocessing import Process, Queue;
import os, time, random;
def writeQueue(queue):
    print("Process(%s) to write" % os.getpid());
    for value in ["A", "B", "C"]:
        print("Put %s into queue" % value);
        queue.put(value);
        time.sleep(random.random());
def readQueue(queue):
    print("Process(%s) to read" % os.getpid());
    while True:
        value = queue.get(True);
        print("Read value %s from queue" % value);
if __name__ == "__main__":
    queue = Queue();
    pw = Process(target=writeQueue, args=(queue,));
    pr = Process(target=readQueue, args=(queue,));
    pw.start();
    pr.start();
    # 等待pw进程结束
    pw.join();
    # pr进程里面是死循环，强行结束
    pr.terminate();

分布式进程

Python 的 multiprocessing 模块不但支持多进程，其中 managers 子模块还支持把多进程分布到多台机器上，一个服务进程可以作为调度者，将任务分布到其他多个进程中，依靠网络通信；
由于 managers 模块封装很好，不必了解网络通信的细节，就可以很容易地编写分布式多进程程序；
实例：以 master-worker 的方式，设计多进程，master 中 queue 传入随机数，worker 中获得随机数后做平方，结果包装到队列中，master 获取返回结果打印；
MasterProcess.py

import time, random, queue;
from multiprocessing.managers import BaseManager;

# 发送任务队列
sendQueue = queue.Queue();
# 接收任务队列
receiveQueue = queue.Queue();

'''
为什么要定义这两个函数？
如果在初始化manager的时候，使用lambda表达式，那么在创先进程的时候会报错
_pickle.PicklingError: Can't pickle <function <lambda> at 0x000002C4573B51F0>: 
attribute lookup <lambda> on __main__ failed
Windows没有fork函数，multiprocessing需要模拟fork的效果，是通过pickle实现的，
报错信息可知在pickle时候不能调用lambda表达式，所以我们创建函数替换lambda
'''
def getSendQueue():
    global sendQueue;
    return sendQueue;
def getReceiveQueue():
    global receiveQueue;
    return receiveQueue;

# 创建QueueManager继承BaseManager
class QueueManager(BaseManager):
    pass;

if __name__ == "__main__":
    # 将两个队列QueueManager上注册，参数一是注册名，参数二关联Queue对象
    # QueueManager.register("sendQueue", callable = lambda : sendQueue);
    # QueueManager.register("receiveQueue", callable = lambda : receiveQueue);
    QueueManager.register("sendQueue", callable=getSendQueue);
    QueueManager.register("receiveQueue", callable=getReceiveQueue);
    # 创建QueueManager对象，绑定8080端口，设置验证码‘abc’
    manager = QueueManager(address=("127.0.0.1", 8080), authkey=b'abc');
    # 启动manager
    manager.start();
    # 从manager中取出send queue，不能对原生的sendQueue操作，会绕过manager的封装
    # 根据注册名来获取
    send = manager.sendQueue();
    receive = manager.receiveQueue();
    # 在send queue中放任务
    for i in range(5):
        n = random.randint(0, 100);
        print("Put %d in send Queue" % n);
        send.put(n);
    # 从receive queue中拿到queue对象
    print("Try to get reveive queue");
    for i in range(5):
        r = receive.get(timeout = 10);
        print("Result is %d" % r);
    # 关闭manager
    manager.shutdown();
    print("Master exit");

 
import time, random, queue;
from multiprocessing.managers import BaseManager;
# 发送任务队列
sendQueue = queue.Queue();
# 接收任务队列
receiveQueue = queue.Queue();
'''
为什么要定义这两个函数？
如果在初始化manager的时候，使用lambda表达式，那么在创先进程的时候会报错
_pickle.PicklingError: Can't pickle <function <lambda> at 0x000002C4573B51F0>: 
attribute lookup <lambda> on __main__ failed
Windows没有fork函数，multiprocessing需要模拟fork的效果，是通过pickle实现的，
报错信息可知在pickle时候不能调用lambda表达式，所以我们创建函数替换lambda
'''
def getSendQueue():
    global sendQueue;
    return sendQueue;
def getReceiveQueue():
    global receiveQueue;
    return receiveQueue;
# 创建QueueManager继承BaseManager
class QueueManager(BaseManager):
    pass;
if __name__ == "__main__":
    # 将两个队列QueueManager上注册，参数一是注册名，参数二关联Queue对象
    # QueueManager.register("sendQueue", callable = lambda : sendQueue);
    # QueueManager.register("receiveQueue", callable = lambda : receiveQueue);
    QueueManager.register("sendQueue", callable=getSendQueue);
    QueueManager.register("receiveQueue", callable=getReceiveQueue);
    # 创建QueueManager对象，绑定8080端口，设置验证码‘abc’
    manager = QueueManager(address=("127.0.0.1", 8080), authkey=b'abc');
    # 启动manager
    manager.start();
    # 从manager中取出send queue，不能对原生的sendQueue操作，会绕过manager的封装
    # 根据注册名来获取
    send = manager.sendQueue();
    receive = manager.receiveQueue();
    # 在send queue中放任务
    for i in range(5):
        n = random.randint(0, 100);
        print("Put %d in send Queue" % n);
        send.put(n);
    # 从receive queue中拿到queue对象
    print("Try to get reveive queue");
    for i in range(5):
        r = receive.get(timeout = 10);
        print("Result is %d" % r);
    # 关闭manager
    manager.shutdown();
    print("Master exit");

WorkerProcess.py

 
import time, sys, queue;
from multiprocessing.managers import BaseManager;
# 创建QueueManager，继承BaseManager
class QueueManager(BaseManager):
    pass;
# worker端从网络上获取queue，所以只需注册名称
QueueManager.register("sendQueue");
QueueManager.register("receiveQueue");
# 创建QueueManager对象，连接master manager
serverAddr = "127.0.0.1";
print("Connect server %s" % serverAddr);
manager = QueueManager(address=("127.0.0.1", 8080), authkey=b'abc');
# 从网络连接master
manager.connect();
# 获取queue对象
sendQueue = manager.sendQueue();
receiveQueue = manager.receiveQueue();
# 从sendQueue中取任务，并将处理结果装到receiveQueue中
for i in range(5):
    try:
        n = sendQueue.get(timeout = 1);
        result = n * n;
        print("Run task: %d * %d = %d" % (n, n, result));
        time.sleep(1);
        receiveQueue.put(result);
    except queue.Queue.Empty:
        print("Serd Queue is empty");
# worker Process 结束
print("Worker exit");

先执行 MasterProcess.py，再执行 WorkerProcess.py，打印结果如下；

这个简单的 Master/Worker 模型有什么用？其实这就是一个简单但真正的分布式计算，把代码稍加改造，启动多个 worker，就可以把任务分布到几台甚至几十台机器上，比如把计算 n*n 的代码换成发送邮件，就实现了邮件队列的异步发送；
Queue 对象存储在哪？存储在 MasterProcess.py 进程中；

多线程

多任务可以由多进程完成，也可由多线程完成；
每个进程里至少包含一个线程，我们称为主线程，实例名称 MainThread；
Python 的标准库提供了两个模块：_thread（低级模块）和 threading（高级模块），threading 对 _thread 进行了封装，绝大多数情况下，我们只需要使用 threading 这个高级模块；
示例

 
# ---- Thread ----
import threading, time;
def loop():
    print("Thread %s is running" % threading.current_thread().name);
    for i in range(5):
        print("Thread %s print number %d" % (threading.current_thread().name, i));
        time.sleep(1);
    print("Thread %s is end" % threading.current_thread().name);
print("Thread %s is running" % threading.current_thread().name);
loopThread = threading.Thread(target=loop, name="LoopThread");
loopThread.start();
loopThread.join();
print("Thread %s is end" % threading.current_thread().name);

试验：多线程死循环占满 CPU 的情况，打开 Mac OS X 的 Activity Monitor，或者 Windows 的 Task Manager，都可以监控某个进程的 CPU 使用率；
在 Python 中无论多少个线程，也只会占满多核 CPU 的单核，因为 Python 的线程虽然是真正的线程，但解释器执行代码时，有一个 GIL 锁：Global Interpreter Lock，任何 Python 线程执行前，必须先获得 GIL 锁，然后，每执行 100 条字节码，解释器就自动释放 GIL 锁，让别的线程有机会执行，这个 GIL 全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在 Python 中只能交替执行，即使 100 个线程跑在 100 核 CPU 上，也只能用到 1 个核；

 
# ---- 多线程死循环 ----
import threading, multiprocessing;
def loop():
    x = 0;
    while True:
        x = x ^ 1;
for i in range(multiprocessing.cpu_count()):
    thread = threading.Thread(target=loop);
    thread.start();

Lock

多线程造成数据数据不一致性的问题：以银行存款为例，每个线程对存款进行存钱取钱的操作，因为数目一样多，存款期望值应该是不变的，但是我们循环次数够多的话，最后的结果可能和初始值不一样；
原因是高级语言一条语句在 CPU 中将被拆分成若干条语句执行：balance = balance + x; 相当于两条语句：temp = balance + x; balance = temp; CPU在运行多线程的时候是交替运行的，所以造成共享变量的值和期望值不一样；
解决办法是在修改共享变量的时候加上线程锁，这样同一时间，只有一个线程能够调用；
Lock，属于 threading 模块，初始化锁对象 ---- 获取锁 ---- 执行增删改操作 ---- 释放锁，加上锁之后，代码效率明显降低；
示例

 
# ---- Lock ----
import time, threading;
# 银行存款余额
balance = 0;
# 初始化锁对象
lock = threading.Lock();
def changeBalance(x):
    # 函数内部对函数外的变量进行操作，就需要在函数内部声明其为global
    global balance;
    # 先存后取，balance期望值是0
    balance = balance + x;
    balance = balance - x;
def bankTread(x):
    for i in range(1000000):
        # 未加锁的情况
        # changeBalance(x);
        # 加锁的情况
        lock.acquire(); # 获取线程锁
        try:
            changeBalance(x);
        finally:
            lock.release(); # 释放锁
thread1 = threading.Thread(target=bankTread, args=(4,), name="BankThread1");
thread2 = threading.Thread(target=bankTread, args=(8,), name="BankThread2");
thread1.start();
thread2.start();
thread1.join();
thread2.join();
print("The balance is %s" % balance);

ThreadLocl

和 Java 类似，当使用 ThreadLocal 维护变量时，ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本，解决了多线程；
ThreadLocal 最常用的地方就是为每个线程绑定一个数据库连接，HTTP 请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源；
示例

1
# ---- ThreadLocal ---- import threading; # 创建全局 ThreadLocal 变量 localThreadStudent = threading.local(); def threadMethod(name): # 为每个线程修改 ThreadLocal 变量副本 localThreadStudent.name = name; print("Thread %s student name %s" % (threading.current_thread().name, localThreadStudent.name)); thread1 = threading.Thread(target=threadMethod, args=("HymanHu",), name="ThreadA"); thread2 = threading.Thread(target=threadMethod, args=("JiangHu",), name="ThreadB"); thread1.start(); thread2.start(); thread1.join(); thread2.join();
1
# ---- ThreadLocal ----
2
import threading;
3
4
# 创建全局 ThreadLocal 变量
5
localThreadStudent = threading.local();
6
7
def threadMethod(name):
8
# 为每个线程修改 ThreadLocal 变量副本
9
localThreadStudent.name = name;
10
print("Thread %s student name %s" % (threading.current_thread().name, localThreadStudent.name));
11
12
thread1 = threading.Thread(target=threadMethod, args=("HymanHu",), name="ThreadA");
13
thread2 = threading.Thread(target=threadMethod, args=("JiangHu",), name="ThreadB");
14
thread1.start();
15
thread2.start();
16
thread1.join();
17
thread2.join();
2

IO 编程

概述

IO（Input/Output），程序运行时数据存留在内存中，由 CPU 计算核心来执行，涉及到数据交换的地方，比如磁盘、网络等，就需要 IO 接口，其中，Stream 是一个重要的概念，类似一个水管，数据就是水管中的水，数据流动有方向性，于是产生了 Input Stream 和 Output Stream 两个概念，数据流出 Out，数据流入 In；
同步 IO && 异步 IO

由于 CPU 和内存的速度远远高于外设设备，所以在 IO 编程中，存在速度严重不匹配的问题，比如，CPU 输出 100M 需要 0.01 秒，但是磁盘写入需要 10 秒；
同步：CPU 等着，当前线程被挂起，暂停执行后续代码，让 IO 执行完后再继续；
异步：CPU 不等待，通知磁盘慢慢写，自己先干别的事情去了；
异步 IO 效率远高于同步 IO，但是异步 IO 复杂程度远高于同步，因为在异步过程中，CPU 需要知道磁盘什么时候完成 IO 操作，等磁盘写完后通知 CPU，这种模式叫回调；CPU 不断检查磁盘是否写完，这种模式叫轮询；

操作 IO 的能力是操作系统提供的，各种高级语言都会将系统用于 IO 操作的 C 语言进行封装；

文件读写

概述

操作系统不允许普通的程序直接操作磁盘，读写文件请求，一般是由操作系统打开一个文件镜像（通常称为文件描述符），然后调用操作操作系统提供的接口，将数据写入这个镜像，或者从这个镜像读取数据；
标示符：

"r" ---- 读取文本文件；
"rb" ----- 读取二进制文件，图片视频等；
"w" ---- 写文本文件；
"wb" ---- 写二进制文件；
"a" ---- 写文本，在原有基础上追加；

流程：

open 文件，注意参数标示符和编码；
读写文件

读取

如果文件比较小，调用 read()；
如果不确定文件大小，反复调用 read(size)；
如果是配置文件，调用 readline() 或 readlines()；

调用 write() 函数；

关闭文件流；

示例

 
# ---- 读取文件 ----
# 读取全部，也可调用read(size)按照字符长度读写
f = open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8");
text = f.read();
print(text);
f.close();
# 读取到list中
f = open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8");
lines = f.readlines();
print(lines); # 注意除开最后一行，其余每行都有\n换行符
for line in lines:
    print(line.strip("\n"));
f.close();
# 读取文件捕获IO异常
try:
    f = open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8");
    print(f.readlines());
except IOError as e:
    print(e);
finally:
    if f:
        f.close();
# 使用with语句对try、except、finally模块的缩写
with open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "r", encoding = "utf-8") as f:
    print(f.readlines());
# ----写文件 ----
# 追加内容
with open("D:\\projectCode\\hqyj\python_demo\\resource\\test.txt", "a", encoding = "utf-8") as f:
    f.write("\n");
    f.write("Hello world\n");
    f.write("Hello world!");

File-Like Object

概述：类似 open 函数返回的对象，带了 read() 函数的，在 Python 中成为 file-like Oject；
StringIO：在内存中读写 string；
BytesIO：实现了在内存中读写 bytes；
示例

1
# ---- StringIO ---- # 将字符串写入内存并获取写入的值 from io import StringIO; sio = StringIO(); sio.write("Hello World!"); print(sio.getvalue()); # 读取StringIO的值，类似文本文件读取 sio = StringIO("Hello world\nHello world!"); print(sio.readlines()); # ---- BytesIO ---- # 将bytes写入内存 from io import BytesIO; bio = BytesIO(); bio.write("你好".encode("utf-8")); print(bio.getvalue()); # 读取BytesIO的值 bio = BytesIO(b'\xe4\xbd\xa0\xe5\xa5\xbd'); print(bio.read());
1
# ---- StringIO ----
2
# 将字符串写入内存并获取写入的值
3
from io import StringIO;
4
sio = StringIO();
5
sio.write("Hello World!");
6
print(sio.getvalue());
7
# 读取StringIO的值，类似文本文件读取
8
sio = StringIO("Hello world\nHello world!");
9
print(sio.readlines());
10
11
# ---- BytesIO ----
12
# 将bytes写入内存
13
from io import BytesIO;
14
bio = BytesIO();
15
bio.write("你好".encode("utf-8"));
16
print(bio.getvalue());
17
# 读取BytesIO的值
18
bio = BytesIO(b'\xe4\xbd\xa0\xe5\xa5\xbd');
19
print(bio.read());
2

OS 操作

"/"和"\"

"/" ---- forward slash、分隔符、正斜杠；
"\" ---- backward slash、转移符、反斜杠；
需要注意的是：在绝大多数地方，使用的都是 /，但 Microsoft 这个怪鸡在自己的操作系统里面非要使用 \，以显得自己的与众不同；

1
import os; # ---- os ---- print(os.name); # 操作系统，nt(Windows)、posix(Linux、Unix、Mac OS X) # print(os.uname()); # 操作系统详细信息，不支持Windows系统 print(os.environ); # 获取操作系统环境变量 print(os.environ.get("CLASSPATH")); # 获取环境变量中某个值 print(os.path.isfile(".")); # 判断是否为文件 print(os.path.isdir(".")); # 判断是否为文件夹 print(os.path.abspath(".")); # 查看当前目录绝对路径 current_path = os.path.abspath(os.path.dirname(__file__)); # 获取当前文夹路径 separator = "\\" if os.name == "nt" else "/"; project_name = "python_spider" + separator; root_path = current_path[:current_path.find(project_name) + len(project_name)]; # 获取项目根目录 '''' join ---- 文件目录组装 split ---- 按最后一个分隔符将文件路径拆分成 tuple，最后一个元素是最后级别的目录或文件 why ---- 可以正确处理不同操作系统的分隔符，只是对字符串的操作 ''' print(os.path.join("D:/", "testDir")); print(os.path.split("D:\\projectCode\\hqyj\\python_demo\\com\\thornBird\\base")); print(os.path.splitext("D:\\sql\\testdb.sql")) # 拆分文件全路径，可以得到文件后缀 print(os.listdir(".")); # 文件夹下所有的文件和目录 print(os.listdir(os.path.split(os.path.abspath("."))[0])); # 查找当前目录同级文件和目录，包含自己 if not os.path.exists("D:/testDir"): os.mkdir("D:/testDir"); # 创建文件夹 os.makedirs("d:/var/aaa/bbb"); # 创建多重文件夹 # os.rmdir("D:/testDir"); # 删除文件夹 if not os.path.exists("D:/testDir/test.txt"): # os.mknod("test.txt"); # Windows不支持mknod with open("D:/testDir/test.txt", "a", encoding="utf-8") as f: f.write("\nHello world\n"); os.rename("D:/testDir/test.txt", "D:/testDir/test1.txt"); # 文件重命名 os.remove("D:/testDir/test1.txt"); # 删除文件
1
import os;
2
3
# ---- os ----
4
print(os.name); # 操作系统，nt(Windows)、posix(Linux、Unix、Mac OS X)
5
# print(os.uname()); # 操作系统详细信息，不支持Windows系统
6
print(os.environ); # 获取操作系统环境变量
7
print(os.environ.get("CLASSPATH")); # 获取环境变量中某个值
8
print(os.path.isfile(".")); # 判断是否为文件
9
print(os.path.isdir(".")); # 判断是否为文件夹
10
print(os.path.abspath(".")); # 查看当前目录绝对路径
11
current_path = os.path.abspath(os.path.dirname(__file__)); # 获取当前文夹路径
12
separator = "\\" if os.name == "nt" else "/";
13
project_name = "python_spider" + separator;
14
root_path = current_path[:current_path.find(project_name) + len(project_name)]; # 获取项目根目录
15
16
''''
17
join ---- 文件目录组装
18
split ---- 按最后一个分隔符将文件路径拆分成 tuple，最后一个元素是最后级别的目录或文件
19
why ---- 可以正确处理不同操作系统的分隔符，只是对字符串的操作
20
'''
21
print(os.path.join("D:/", "testDir"));
22
print(os.path.split("D:\\projectCode\\hqyj\\python_demo\\com\\thornBird\\base"));
23
print(os.path.splitext("D:\\sql\\testdb.sql")) # 拆分文件全路径，可以得到文件后缀
24
print(os.listdir(".")); # 文件夹下所有的文件和目录
25
print(os.listdir(os.path.split(os.path.abspath("."))[0])); # 查找当前目录同级文件和目录，包含自己
26
if not os.path.exists("D:/testDir"):
27
os.mkdir("D:/testDir"); # 创建文件夹
28
os.makedirs("d:/var/aaa/bbb"); # 创建多重文件夹
29
# os.rmdir("D:/testDir"); # 删除文件夹
30
if not os.path.exists("D:/testDir/test.txt"):
31
# os.mknod("test.txt"); # Windows不支持mknod
32
with open("D:/testDir/test.txt", "a", encoding="utf-8") as f:
33
f.write("\nHello world\n");
34
os.rename("D:/testDir/test.txt", "D:/testDir/test1.txt"); # 文件重命名
35
os.remove("D:/testDir/test1.txt"); # 删除文件
2

序列化

序列化概述

Python 中称之为 pickling，Java 中叫做 serialization，都是一个意思；
我们把变量从内存中变成可存储或可传输的过程称之为序列化；
把变量从序列化的对象重新读到内存里称之为反序列化，即 unpickling；
dumps && loads ---- 将对象序列化为 bytes、将 bytes 反序列化为对象；
dump && load ---- 将对象序列化为 File-Like Object、将 File-Like Object 反序列化为对象；

示例

1
# ---- 序列化、反序列化 ---- import pickle; d = dict(name = "hymanHu", age = 20); # pickle.dumps && pickle.loads db = pickle.dumps(d); print(db); d2 = pickle.loads(db); print(d2); # pickle.dump && pickle.load f = open("D:\\testDir\\test.txt", "wb"); pickle.dump(d, f); f.close(); f = open("D:\\testDir\\test.txt", "rb"); d1 = pickle.load(f); f.close(); print(d1);
1
# ---- 序列化、反序列化 ----
2
import pickle;
3
d = dict(name = "hymanHu", age = 20);
4
# pickle.dumps && pickle.loads
5
db = pickle.dumps(d);
6
print(db);
7
d2 = pickle.loads(db);
8
print(d2);
9
# pickle.dump && pickle.load
10
f = open("D:\\testDir\\test.txt", "wb");
11
pickle.dump(d, f);
12
f.close();
13
f = open("D:\\testDir\\test.txt", "rb");
14
d1 = pickle.load(f);
15
f.close();
16
print(d1);
2

练习

将本地一个文本文件读取出来，用 str 展示到控制台；
打印出当前文档下所有目录、所有 py 文件；

 
print([x for x in os.listdir(".")]); # 打印出当前目录下所有文件和目录
print([x for x in os.listdir(".") if os.path.isfile(x)]); # 打印出当前目录下所有文件
# 打印当前目录py文件
print([x for x in os.listdir(".") if os.path.isfile(x) and os.path.splitext(x)[1] == ".py"]);

利用 os 模块编写一个能实现 dir -l 输出的程序；

 
def dirList(dir):
    dir = os.path.abspath(dir);
    for x in os.listdir(dir):
        sonDir = os.path.join(dir, x);
        if os.path.isdir(sonDir):
            dirList(sonDir);
        else:
            print(sonDir);
dirList(".");
print("-----------------------------");
dirList("D:\\projectCode\\hqyj\\python_demo\\com");
print(os.path.isdir("D:\\projectCode\\hqyj\\python_demo\\com\\thornBird"));

编写一个函数，能够查找给定目录以及其子目录所有文件名包含给定字符的文件列表，打印绝对路径；

 
def fileSearch(dir, keyWord):
    dir = os.path.abspath(dir);
    for item in os.listdir(dir):
        sonDir = os.path.join(dir, item);
        if os.path.isdir(sonDir):
            fileSearch(sonDir, keyWord);
        else:
            if item.find(keyWord) != -1:
                print(sonDir);
fileSearch("D:\\projectCode\\hqyj\\python_demo\\com", "init");

异步 IO

概述

一个 IO 操作阻塞了当前线程，导致其他代码无法执行，所以我们必须使用多线程或者多进程来并发执行代码，为多个用户服务，每个用户都会分配一个线程，如果遇到IO导致线程被挂起，其他用户的线程不受影响。多线程和多进程的模型虽然解决了并发问题，但是系统不能无上限地增加线程，由于系统切换线程的开销也很大，所以，一旦线程数量过多，CPU 的时间就花在线程切换上了，真正运行代码的时间就少了，结果导致性能严重下降；
现代操作系统对 IO 操作已经做了巨大的改进，最大的特点就是支持异步 IO，如果充分利用操作系统提供的异步 IO 支持，就可以用单进程单线程模型来执行多任务，这种全新的模型称为事件驱动模型，Nginx 就是支持异步 IO 的 Web 服务器，它在单核 CPU 上采用单进程模型就可以高效地支持多任务；
在多核 CPU 上，可以运行多个进程（数量与 CPU 核心数相同），充分利用多核 CPU，由于系统总的进程数量十分有限，因此操作系统调度非常高效，用异步 IO 编程模型来实现多任务是一个主要的趋势；
当代码需要执行一个耗时的 IO 操作时，它只发出 IO 指令，并不等待 IO 结果，然后就去执行其他代码了，采取回调（一段时间后，当 IO 返回结果时，再通知 CPU 进行处理）或者轮询（定时询问 IO 操作）的方式处理 IO 后续操作；
消息模型：异步 IO 模型需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”这一过程；

 
loop = get_event_loop();
while True:
    event = loop.get_event();
    process_event(event);

一旦决定使用异步，则系统每一层都必须是异步，“开弓没有回头箭”；

协程

概述

又称微线程，纤程，英文名 Coroutine；
首先来说说函数调用：函数 A 调用函数 B，函数 B 又调用了函数 C，C 执行完后返回 B，B 返回 A ---- 1、函数调用属于层级调用；2、函数之间的调用顺序是明确的；
再来说说协程

定义以下两个函数，使用协程调用，A 随时可以停止转到 B 上，B 也可能停止返回执行 A，打印顺序可能是这样的：1,2,x,y,3,z；
看起来类似多线程调用，但协程调用是在一个线程上执行的；

 
def A():
    print('1');
    print('2');
    print('3');
def B():
    print('x');
    print('y');
    print('z');

优势

极高的执行效率，因为函数切换不是线程切换，而是由程序自身控制，CPU 没有线程切换的开销；
无需多线程锁机制，因为只有一个线程，没有同时写变量冲突，在协程中，共享资源不加锁，只判断状态就好；
进城 + 协程，更高效地利用多核 CPU 资源；

Python 中对协程的支持是通过 generator 实现的，查看 generator 介绍可知，带有 yield 语句的函数就是一个 generator；
在协程中，不能调用普通的同步 IO 操作，因为所有用户都是由一个线程服务的，协程的执行速度必须非常快，才能处理大量用户的请求，而耗时的 IO 操作不能在协程中以同步的方式调用，否则，等待一个 IO 操作时，系统无法响应任何其他用户；

协程流程（生产者-消费者模型为例）

传统流程：是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁；
协程流程：生产者将生产结果通过 generator.send() 方法传递给消费者，消费者得到参数进行处理，再通过 yield 语句将处理后的值抛出；

首先调用 consumer.send(None) 启动消费者（生成器）；
produce 产生了东西后，通过 consumer.send(n)，切换到消费者，并将 n 赋值给 temp；
consumer 拿到消息后，处理，又通过 yield 把结果传回；
produce 拿到 consumer 处理的结果，继续生产下一条消息；
produce 决定不生产了，通过 consumer.close() 关闭 consumer，整个过程结束；

 
# 消费者（生成器generator）
def consumer():
    r = "";
    while True:
        temp = yield r;
        if not temp:
            return;
        print("[Consumer] consuming %s..." % temp);
        r = "200 OK";
# 生产者
def produce(consumer):
    consumer.send(None);
    n = 0;
    while n < 5:
        n += 1;
        print("[Produce] producing %s..." % n);
        r = consumer.send(n);
        print("[Consumer] consumer return %s" % r);
    consumer.close();
consumer = consumer();
produce(consumer);

asyncio

概述

Python 3.4 版本引入的标准库，直接内置了对异步 IO 的支持，asyncio 的编程模型就是一个消息循环，我们从 asyncio 模块中直接获取一个 EventLoop 的引用，然后把需要执行的协程扔到 EventLoop 中执行，就实现了异步 IO；
用 asyncio 提供的 @asyncio.coroutine 可以把一个 generator 标记为 coroutine 类型，然后在 coroutine 内部用 yield from 调用另一个 coroutine 实现异步操作；
asyncio 可以实现单线程并发 IO 操作，如果仅用在客户端，发挥的威力不大，如果把 asyncio 用在服务器端，例如 Web 服务器，由于 HTTP 连接就是 IO 操作，因此可以用单线程 + coroutine 实现多用户的高并发支持；

流程

定义 generator，用装饰器 @asyncio.coroutine 将 generator 标记为 coroutine 类型；
generator中，yield 语句调用其他 coroutine；
获取 EvenLoop，并执行 coroutine（单个或者多个）；
关闭 EvenLoop；

示例一

 
# ---- asyncio ----
import asyncio;
import threading;
# @asyncio.coroutine把一个generator标记为coroutine类型，然后把这个coroutine扔到EventLoop中执行
@asyncio.coroutine
def hello():
    print("Hello World! (%s)" % threading.current_thread());
    '''
    yield from语法可以让我们方便地调用另一个generator
    由于asyncio.sleep()也是一个coroutine，所以线程不会等待asyncio.sleep()，而是直接中断并执行下一个消息循环
    当asyncio.sleep()返回时，线程就可以从yield from拿到返回值（此处是None），然后接着执行下一行语句
    '''
    r = yield from asyncio.sleep(1);
    print("Hello World again! (%s)" % threading.current_thread());
def helloLoop():
    # 获取EventLoop
    loop = asyncio.get_event_loop();
    # 执行单个coroutine
    # loop.run_until_complete(hello());
    # 执行多个coroutine
    loop.run_until_complete(asyncio.wait([hello(), hello()]));
    loop.close();
# helloLoop();

运行结果：两个coroutine是由同一个线程并发执行的，在yield语句处，会停顿1秒；

示例二

将示例一中的 asyncio.sleep(1) 换成 IO 操作，asyncio 的异步网络连接来获取 sina、sohu 和 163 的网站首页；

# ---- asyncio\StreamReader\StreamWriter ----
import asyncio;
import urllib.parse;

@asyncio.coroutine
def wget(url):
    print("wget host %s" % url);
    # 解析url，根据scheme来判断端口
    urlParse = urllib.parse.urlsplit(url);
    port = 443 if (urlParse.scheme == "https") else 80;

'''
    打开连接，获取StreamReader（从IO数据流中读数据）、StreamWriter对象（从IO数据流中写数据）
    不建议直接实例化reader, writer，而是通过open_connection()或start_server()创建
    '''
    reader, writer = yield from asyncio.open_connection(url, port);
    # 将请求信息写入IO
    query = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % url;
    writer.write(query.encode("utf-8"));
    '''
    这是一个与底层IO输入缓冲区交互的流量控制方法
    当缓冲区达到上限时，drain()阻塞，待到缓冲区回落到下限时，写操作可以被恢复
    当不需要等待时，drain()会立即返回
    '''
    yield from writer.drain();
    while True:
        line = yield from reader.readline();
        if line == b'\r\n':
            break;
        print("%s header ---- %s" % (url, line.decode("utf-8")));
    # Ignore the body, close the socket
    writer.close();

def wgetLoop():
    loop = asyncio.get_event_loop();
    tasks = [wget(url) for url in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']];
    loop.run_until_complete(asyncio.wait(tasks));
    loop.close();
# wgetLoop();

 
# ---- asyncio\StreamReader\StreamWriter ----
import asyncio;
import urllib.parse;
@asyncio.coroutine
def wget(url):
    print("wget host %s" % url);
    # 解析url，根据scheme来判断端口
    urlParse = urllib.parse.urlsplit(url);
    port = 443 if (urlParse.scheme == "https") else 80;
    '''
    打开连接，获取StreamReader（从IO数据流中读数据）、StreamWriter对象（从IO数据流中写数据）
    不建议直接实例化reader, writer，而是通过open_connection()或start_server()创建
    '''
    reader, writer = yield from asyncio.open_connection(url, port);
    # 将请求信息写入IO
    query = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % url;
    writer.write(query.encode("utf-8"));
    '''
    这是一个与底层IO输入缓冲区交互的流量控制方法
    当缓冲区达到上限时，drain()阻塞，待到缓冲区回落到下限时，写操作可以被恢复
    当不需要等待时，drain()会立即返回
    '''
    yield from writer.drain();
    while True:
        line = yield from reader.readline();
        if line == b'\r\n':
            break;
        print("%s header ---- %s" % (url, line.decode("utf-8")));
    # Ignore the body, close the socket
    writer.close();
def wgetLoop():
    loop = asyncio.get_event_loop();
    tasks = [wget(url) for url in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']];
    loop.run_until_complete(asyncio.wait(tasks));
    loop.close();
# wgetLoop();

async/await

概述：从 Python 3.5 开始，引入了新的语法 async 和 await，可以让 coroutine 的代码更简洁易读；
用法

把 @asyncio.coroutine 替换为 async；
把 yield from 替换为 await；

示例

 
# ---- async/await ----
import asyncio;
import threading;
async def hello2():
    print("Hello World! (%s)" % threading.current_thread());
    r = await asyncio.sleep(1);
    print("Hello World again! (%s)" % threading.current_thread());
def helloLoop2():
    loop = asyncio.get_event_loop();
    loop.run_until_complete(asyncio.wait([hello2(), hello2()]));
    loop.close();
helloLoop2();

aiohttp

概述

asyncio 实现了 TCP、UDP、SSL 等协议，aiohttp 则是基于 asyncio 实现的HTTP框架；
安装 aiohttp：pip install aiohttp；

Application

WebApp 的核心，接受如下参数；

loop：事件循环 EventLoop，可以通过 loop = asyncio.get_event_loop() 获得；
logger：logging.logger；
router：路由器；
middlewares：中间件，接受一列中间件工厂；

aiohttp.web 提供了一个强大的机制来通过中间件来定制请求处理程序，可以修改请求或响应的协程，每个中间件都应该接受两个参数，一个请求实例（request）和一个处理程序（handler），并返回响应或引发异常，如果该异常不是 HTTPException 的一个实例，则在处理中间件链之后它将转换为 500 HTTPInternalServerError；

 
from aiohttp.web import middleware
@middleware
async def middleware(request, handler):
    resp = await handler(request);
    resp.text = resp.text + ' wink';
    return resp;
# 调用
# app = web.Application(middlewares=[middleware_1, middleware_2]);

cilent_max_size：客户端请求中的最大大小，以字节为单位。如果 POST 请求超过此值，则会引发 HTTPRequestEntityTooLarge 异常；
handler_args：类似于 dict 的对象，覆盖 Application.make_handler（）的关键字参数；

示例

# -*- coding: utf-8 -*-
import asyncio;
from aiohttp import web;

# http://127.0.0.1:8000/
async def index(request):
    await asyncio.sleep(1);
    resp = web.Response(body=b'<h1>Index</h1>');
    # 如果不添加content_type，某些严谨的浏览器会把网页当成文件下载，而不是直接显示
    resp.content_type = "text/html;charset=utf-8";
    return resp;

# http://127.0.0.1:8000/hello/HymanHu
async def hello(request):
    await asyncio.sleep(1);
    body = '<h1>hello, %s!</h1>' % request.match_info['name'];
    resp = web.Response(body=body.encode("utf-8"));
    resp.content_type = "text/html;charset=utf-8";
    return resp;

# aiohttp的初始化函数init()也是一个coroutine，loop.create_server()则利用asyncio创建TCP服务
async def init(loop):
    # 此处使用loop参数，会出现deprecated警告，直接不用或者补全其他参数
    # app = web.Application(loop=loop);
    app = web.Application();
    app.router.add_route("GET", "/", index);
    app.router.add_route("GET", "/hello/{name}", hello);

# 老的写法，会产生deprecated警告
    # server = await loop.create_server(app.make_handler(), '127.0.0.1', 8000);
    # print('Server started at http://127.0.0.1:8000...');
    # return server;
    # 新的写法
    runner = web.AppRunner(app);
    await runner.setup();
    server = web.TCPSite(runner, '127.0.0.1', 8000)
    print('Server started at http://127.0.0.1:8000...');
    await server.start();

loop = asyncio.get_event_loop();
loop.run_until_complete(init(loop));
loop.run_forever();

 
# -*- coding: utf-8 -*-
import asyncio;
from aiohttp import web;
# http://127.0.0.1:8000/
async def index(request):
    await asyncio.sleep(1);
    resp = web.Response(body=b'<h1>Index</h1>');
    # 如果不添加content_type，某些严谨的浏览器会把网页当成文件下载，而不是直接显示
    resp.content_type = "text/html;charset=utf-8";
    return resp;
# http://127.0.0.1:8000/hello/HymanHu
async def hello(request):
    await asyncio.sleep(1);
    body = '<h1>hello, %s!</h1>' % request.match_info['name'];
    resp = web.Response(body=body.encode("utf-8"));
    resp.content_type = "text/html;charset=utf-8";
    return resp;
# aiohttp的初始化函数init()也是一个coroutine，loop.create_server()则利用asyncio创建TCP服务
async def init(loop):
    # 此处使用loop参数，会出现deprecated警告，直接不用或者补全其他参数
    # app = web.Application(loop=loop);
    app = web.Application();
    app.router.add_route("GET", "/", index);
    app.router.add_route("GET", "/hello/{name}", hello);
    # 老的写法，会产生deprecated警告
    # server = await loop.create_server(app.make_handler(), '127.0.0.1', 8000);
    # print('Server started at http://127.0.0.1:8000...');
    # return server;
    # 新的写法
    runner = web.AppRunner(app);
    await runner.setup();
    server = web.TCPSite(runner, '127.0.0.1', 8000)
    print('Server started at http://127.0.0.1:8000...');
    await server.start();
loop = asyncio.get_event_loop();
loop.run_until_complete(init(loop));
loop.run_forever();

网络编程

概述

计算机网络就是把各个计算机连接到一起，让网络中的计算机可以互相通信，网络编程就是如何在程序中实现两台计算机的通信；
由于你的电脑上可能不止浏览器，还有 QQ、Skype、Dropbox、邮件客户端等，不同的程序连接的别的计算机也会不同，所以，更确切地说，网络通信是两台计算机上的两个进程之间的通信。比如，浏览器进程和新浪服务器上的某个 Web 服务进程在通信，而 QQ 进程是和腾讯的某个服务器上的某个进程在通信；

TCP/IP

概述

计算机联网，必须规定通信协议，早期各大厂商 IBM、Apple 和 Microsoft 都有各自的网络协议，互不兼容，为了把全世界的所有不同类型的计算机都连接起来，就必须规定一套全球通用的协议，为了实现互联网这个目标，产生了互联网协议簇（Internet Protocol Suite ---- 通用协议标准）， Internet 是由 inter 和 net 两个单词组合起来的，原意就是连接“网络”的网络，有了 Internet，任何私有网络，只要支持这个协议，就可以联入互联网；
互联网协议包含了上百种协议标准，但是最重要的两个协议是 TCP 和 IP 协议，所以，大家把互联网的协议简称 TCP/IP 协议；
IP

通信的时候，双方必须知道对方的标识，好比发邮件必须知道对方的邮件地址，互联网上每个计算机的唯一标识就是 IP 地址，类似 123.123.123.123，
IPv4：现今常用 IP 地址，实际上是一个 32 位整数，以字符串表示的 IP 地址如 192.168.0.1 实际上是把 32 位整数按 8 位分组后的数字表示，目的是便于阅读；

IPv6：该地址实际上是一个 128 位整数，它是目前使用的 IPv4 的升级版，以字符串表示类似于 2001:0db8:85a3:0042:1000:8a2e:0370:7334；
如果一台计算机同时接入到两个或更多的网络，比如路由器，它就会有两个或多个 IP 地址，所以，IP 地址对应的实际上是计算机的网络接口，通常是网卡；
IP 协议负责把数据从一台计算机通过网络发送到另一台计算机，数据被分割成一小块一小块，然后通过 IP 包发送出去，由于互联网链路复杂，两台计算机之间经常有多条线路，因此，路由器就负责决定如何把一个 IP 包转发出去，IP 包的特点是按块发送，途径多个路由，但不保证能到达，也不保证顺序到达；

TCP 协议则是建立在 IP 协议之上的，协议负责在两台计算机之间建立可靠连接，保证数据包按顺序到达，TCP 协议会通过握手建立连接，然后，对每个 IP 包编号，确保对方按顺序收到，如果包丢掉了，就自动重发；
许多常用的更高级的协议都是建立在 TCP 协议基础上的，比如用于浏览器的 HTTP 协议、发送邮件的 SMTP 协议等；
一个 TCP 报文除了包含要传输的数据外，还包含源 IP 地址和目标 IP 地址，源端口和目标端口，每个网络程序都向操作系统申请唯一的端口号，这样，两个进程在两台计算机之间建立网络连接就需要各自的 IP 地址和各自的端口号，一个进程也可能同时与多个计算机建立链接，因此它会申请很多端口；

常用端口

端口号小于 1024 的是 Internet 标准服务的端口，端口号大于 1024 的，可以任意使用；
80（Web服务）、25（SMPT）、21（FTP）；

Socket

Socket 是网络编程的一个抽象概念，通常我们用一个 Socket 表示“打开了一个网络链接”，建立连接，需要我们知道对方的 IP、端口，并选择协议类型；

IP 协议：IPv4（socket.AF_INET）、IPv6（socket.AF_INET6）；
TCP 协议：socket.SOCKET_STREAM；
UDP 协议

socket.SOCK_DGRAM；
使用 UDP 协议时，不需要建立连接，只需要知道对方的 IP 地址和端口号，就可以直接发数据包，但是，能不能到达就不知道了，虽然用 UDP 传输数据不可靠，但它的优点是和 TCP 比，速度快，对于不要求可靠到达的数据，就可以使用 UDP 协议；

SMTP 协议：发邮件协议；
POP3 协议 / IMAP 协议：收邮件协议；

客户端步骤

创建 socket 连接 ---- 指定协议、IP、端口；
发送请求数据；
接收返回数据；
关闭 socket；
处理数据 ---- 打印 headers、将网页内容写入文件；
示例

 
# ---- socket客户端 ----
def clientSocket():
    # 创建socket，指定TCP/IP协议
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
    # 连接目标，指定ip和端口
    s.connect(("www.sina.com.cn", 80));
    # 发送请求
    s.send(b'GET / HTTP/1.1\r\nHost: www.sina.com.cn\r\nConnection: close\r\n\r\n');
    # 处理返回数据
    buffer = [];
    while True:
        # 每次最多接受1k字节
        d = s.recv(1024);
        if d:
            buffer.append(d);
        else:
            break;
    data = b''.join(buffer);
    # 关闭socket
    s.close();
    # 处理返回数据，打印响应头，网页内容写入文件
    headers, body = data.split(b'\r\n\r\n', 1);
    print(headers.decode("utf-8"));
    with open("D:\\temp\\baidu.html", "wb") as f:
        f.write(body);
clientSocket();

服务器端步骤

创建服务器端 socket，指定协议、绑定 IP、端口，开始监听；
无限循环，监听客户端连接，从连接中获取客户端 socket、address；
开启新线程处理，进行数据交互、关闭 socket 等；
示例

import socket, threading;

# ---- TCP服务端 ----
def serverSocket():
    # 创建基于TCP/IP协议的socket
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
    # 监听本机9999端口
    s.bind(("127.0.0.1", 9999));
    s.listen(5); # 监听最大连接数
    # 死循环接受客户端连接
    while True:
        # 接受一个连接，获得socket和address
        sock, addr = s.accept();
        # 创建新线程来处理TCP连接
        t = threading.Thread(target=tcpLink, args=(sock, addr));
        t.start();

# 服务端处理连接方法
def tcpLink(socket, address):
    print("Accept new connection from %s:%s" % address);
    socket.send(b'wellcome');
    while True:
        data = socket.recv(1024);
        if not data or data.decode("utf-8") == "exit":
            break;
        socket.send(('Hello %s' % data.decode("utf-8")).encode("utf-8"));
    socket.close();
    print("Connection is closed from %s" % address);
serverSocket();

# 客户端程序，测试serverSocket
def clientSocketTest():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
    s.connect("127.0.0.1", 9999);
    # 接收欢迎消息
    print(s.recv(1024).decode("utf-8"));
    for data in [b'HymanHu', b'JiangHu', b'Ye']:
        s.send(data);
        print(s.recv(1024).decode("utf-8"));
    s.send(b'exit');
    s.close();
clientSocketTest();

# ---- UDP类型服务端 ----
def serverSocketForUDP():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
    s.bind(("127.0.0.1", 9999));
    print("Bind UDP on 9999..");
    while True:
        # udp接受数据/发送数据的方式
        data, addr = s.recvfrom(1024);
        print('Received from %s:%s.' % addr);
        s.sendto(b'Hello, %s!' % data, addr);
serverSocketForUDP();
# 客户端程序，测试serverSocketForUDP
def clientSocketTestForUDP():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
    for data in [b'Michael', b'Tracy', b'Sarah']:
        # 发送数据:
        s.sendto(data, ('127.0.0.1', 9999));
        # 接收数据:
        print(s.recv(1024).decode('utf-8'));
    s.close();
clientSocketTestForUDP();

 
import socket, threading;
# ---- TCP服务端 ----
def serverSocket():
    # 创建基于TCP/IP协议的socket
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
    # 监听本机9999端口
    s.bind(("127.0.0.1", 9999));
    s.listen(5); # 监听最大连接数
    # 死循环接受客户端连接
    while True:
        # 接受一个连接，获得socket和address
        sock, addr = s.accept();
        # 创建新线程来处理TCP连接
        t = threading.Thread(target=tcpLink, args=(sock, addr));
        t.start();
# 服务端处理连接方法
def tcpLink(socket, address):
    print("Accept new connection from %s:%s" % address);
    socket.send(b'wellcome');
    while True:
        data = socket.recv(1024);
        if not data or data.decode("utf-8") == "exit":
            break;
        socket.send(('Hello %s' % data.decode("utf-8")).encode("utf-8"));
    socket.close();
    print("Connection is closed from %s" % address);
serverSocket();
# 客户端程序，测试serverSocket
def clientSocketTest():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
    s.connect("127.0.0.1", 9999);
    # 接收欢迎消息
    print(s.recv(1024).decode("utf-8"));
    for data in [b'HymanHu', b'JiangHu', b'Ye']:
        s.send(data);
        print(s.recv(1024).decode("utf-8"));
    s.send(b'exit');
    s.close();
clientSocketTest();
# ---- UDP类型服务端 ----
def serverSocketForUDP():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
    s.bind(("127.0.0.1", 9999));
    print("Bind UDP on 9999..");
    while True:
        # udp接受数据/发送数据的方式
        data, addr = s.recvfrom(1024);
        print('Received from %s:%s.' % addr);
        s.sendto(b'Hello, %s!' % data, addr);
serverSocketForUDP();
# 客户端程序，测试serverSocketForUDP
def clientSocketTestForUDP():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
    for data in [b'Michael', b'Tracy', b'Sarah']:
        # 发送数据:
        s.sendto(data, ('127.0.0.1', 9999));
        # 接收数据:
        print(s.recv(1024).decode('utf-8'));
    s.close();
clientSocketTestForUDP();

电子邮件

概述

email 的历史比 web 还要久远；
传统邮件流程（成都 ---- 北京）：写信 ---- 装信封 ---- 写地址贴邮票 ---- 投附近邮局 ---- 转成都大邮局分类信件 ---- 派发 ---- 北京大邮局 ---- 北京小邮局 ---- 投递到地址附近邮箱 ---- 朋友取得信件，速度按照天算；
电子邮件流程：

写信 ---- MUA（Mail User Agent，邮件用户代理，类似 OutLook、Foxmail 等） ---- MAT（Mail Transfer Agent，邮件传输代理，各种邮件服务提供商，类似新浪、163 等） ---- MDA（Mail Delivery Agent，邮件投递代理，服务器磁盘、电子邮箱）；
对方上网后，通过 MUA 到 MDA 上收取电子邮件；
发件人 -> MUA -> MTA -> MTA -> 若干个MTA -> MDA <- MUA <- 收件人；

编写发送和接受邮件

从 MUA 发邮件到 MTA；
从 MUA 收邮件于 MDA；

相关协议

SMTP 协议

Simple Mail Transfer Protocol，发邮件协议，端口 25；
邮件客户端软件在发邮件时，会让你先配置 SMTP 服务器，也就是你要发到哪个 MTA 上，例如：smtp.163.com，为了证明你是 163 的用户，SMTP 服务器还要求你填写邮箱地址和邮箱口令，这样，MUA 才能正常地把 Email 通过 SMTP 协议发送到 MTA；

POP3 协议：

Post Office Protocol，目前版本是 3，收邮件协议；
同样的，从 MDA 收邮件时，MDA 服务器也要求验证你的邮箱口令，确保不会有人冒充你收取你的邮件；

IMAP 协议：

Internet Message Access Protocol，收邮件协议；
不但能取邮件，还可以直接操作 MDA 上存储的邮件，比如从收件箱移到垃圾箱，等等；

注意事项：目前大多数邮件服务商都需要手动打开 SMTP 发信和 POP 收信的功能，否则只允许在网页登录；

SMTP 发送邮件

Python 可以发送纯文本、html 和带附件的邮件；
Python 对 SMTP 的支持，提供了两个模块：email（负责创造email）、smtplib（负责发送）；
示例

from email import encoders;
from email.header import Header;
from email.mime.text import MIMEText;
from email.mime.multipart import MIMEMultipart;
from email.mime.base import MIMEBase;
from email.utils import parseaddr,formataddr;
import smtplib;

# format like: Mr Green <green@example.com>
# return =?utf-8?q?Mr_Green?= <green@example.com>
def formatAddr(x):
    name, addr = parseaddr(x);
    return formataddr((Header(name, "utf-8").encode(), addr));
print(formatAddr("Mr Green <green@example.com>"));

# ---- 文本邮件 ----
def sendErmail():
    # 输入发送人信息、收件人地址
    # fromAddress = input("From:");
    # password = input("Password:");
    # toAddress = input("To:");
    # smtpServer = input("SMTP Server:");
    fromAddress = "898899721@qq.com";
    # 在官网设置开启POP3/SMTP等服务，在此输入第三方授权码
    password = "*******";
    toAddress = "hujiangyx@163.com,hujiang_cd@hqyj.com";
    smtpServer = "smtp.qq.com";

'''
    参数1：邮件内容；
    参数2：subtype，plain标识纯文本 ---- html网页 ---- alternative混合；
    参数3：编码集；
    :return:
    '''
    # 发送纯文本邮件
    # msg = MIMEText("Hello HymanHu, 万物生长，山河无恙，佳期如许！", "plain", "utf-8");
    # 发送html邮件
    # msg = MIMEText('<html><body><h1>Hello</h1>' +
    #                '<p>send by <a href="http://www.python.org">Python</a>...</p>' +
    #                '</body></html>', 'html', 'utf-8');
    # 发送附件邮件，注意subtype类型
    msg = MIMEMultipart("alternative");
    # 添加纯文本和html，并在html中嵌入图片
    msg.attach(MIMEText("Hello HymanHu, 万物生长，山河无恙，佳期如许！", "plain", "utf-8"));
    msg.attach(MIMEText('<html><body><h1>Hello</h1>' +
                        '<p><img src="cid:0"></p>' +
                        '</body></html>', 'html', 'utf-8'))
    # 添加附件
    with open("D:\\temp\\test.png", "rb") as f:
        # 设置附件的文件名、类型等:
        mime = MIMEBase("image", "png", filename="test.png");
        # 添加信息头
        mime.add_header('Content-Disposition', 'attachment', filename='test.png')
        mime.add_header('Content-ID', '<0>')
        mime.add_header('X-Attachment-Id', '0')
        # 把附件的内容读进来:
        mime.set_payload(f.read());
        # 用Base64编码:
        encoders.encode_base64(mime);
        # 添加到MIMEMultipart:
        msg.attach(mime);

# 设置from、to、subject等信息
    msg["From"] = formatAddr("HymanHu <%s>" % fromAddress);
    msg["To"] = formatAddr("JiangHu <%s>" % toAddress);
    msg["Subject"] = Header("来自HymanHu的问候", "utf-8").encode();
    print(msg);

server = smtplib.SMTP(smtpServer, 25);
    # 加密SMTP
    # server.starttls();
    # 打印出和SMTP服务器交互的所有信息
    server.set_debuglevel(1);
    server.login(fromAddress, password);
    # 发送单人
    # server.sendmail(fromAddress, [toAddress], msg.as_string());
    # 发送多人
    server.sendmail(fromAddress, toAddress.split(","), msg.as_string());
    server.quit();
sendErmail();

 
from email import encoders;
from email.header import Header;
from email.mime.text import MIMEText;
from email.mime.multipart import MIMEMultipart;
from email.mime.base import MIMEBase;
from email.utils import parseaddr,formataddr;
import smtplib;
# format like: Mr Green <green@example.com>
# return =?utf-8?q?Mr_Green?= <green@example.com>
def formatAddr(x):
    name, addr = parseaddr(x);
    return formataddr((Header(name, "utf-8").encode(), addr));
print(formatAddr("Mr Green <green@example.com>"));
# ---- 文本邮件 ----
def sendErmail():
    # 输入发送人信息、收件人地址
    # fromAddress = input("From:");
    # password = input("Password:");
    # toAddress = input("To:");
    # smtpServer = input("SMTP Server:");
    fromAddress = "898899721@qq.com";
    # 在官网设置开启POP3/SMTP等服务，在此输入第三方授权码
    password = "*******";
    toAddress = "hujiangyx@163.com,hujiang_cd@hqyj.com";
    smtpServer = "smtp.qq.com";
    '''
    参数1：邮件内容；
    参数2：subtype，plain标识纯文本 ---- html网页 ---- alternative混合；
    参数3：编码集；
    :return:
    '''
    # 发送纯文本邮件
    # msg = MIMEText("Hello HymanHu, 万物生长，山河无恙，佳期如许！", "plain", "utf-8");
    # 发送html邮件
    # msg = MIMEText('<html><body><h1>Hello</h1>' +
    #                '<p>send by <a href="http://www.python.org">Python</a>...</p>' +
    #                '</body></html>', 'html', 'utf-8');
    # 发送附件邮件，注意subtype类型
    msg = MIMEMultipart("alternative");
    # 添加纯文本和html，并在html中嵌入图片
    msg.attach(MIMEText("Hello HymanHu, 万物生长，山河无恙，佳期如许！", "plain", "utf-8"));
    msg.attach(MIMEText('<html><body><h1>Hello</h1>' +
                        '<p><img src="cid:0"></p>' +
                        '</body></html>', 'html', 'utf-8'))
    # 添加附件
    with open("D:\\temp\\test.png", "rb") as f:
        # 设置附件的文件名、类型等:
        mime = MIMEBase("image", "png", filename="test.png");
        # 添加信息头
        mime.add_header('Content-Disposition', 'attachment', filename='test.png')
        mime.add_header('Content-ID', '<0>')
        mime.add_header('X-Attachment-Id', '0')
        # 把附件的内容读进来:
        mime.set_payload(f.read());
        # 用Base64编码:
        encoders.encode_base64(mime);
        # 添加到MIMEMultipart:
        msg.attach(mime);
    # 设置from、to、subject等信息
    msg["From"] = formatAddr("HymanHu <%s>" % fromAddress);
    msg["To"] = formatAddr("JiangHu <%s>" % toAddress);
    msg["Subject"] = Header("来自HymanHu的问候", "utf-8").encode();
    print(msg);
    server = smtplib.SMTP(smtpServer, 25);
    # 加密SMTP
    # server.starttls();
    # 打印出和SMTP服务器交互的所有信息
    server.set_debuglevel(1);
    server.login(fromAddress, password);
    # 发送单人
    # server.sendmail(fromAddress, [toAddress], msg.as_string());
    # 发送多人
    server.sendmail(fromAddress, toAddress.split(","), msg.as_string());
    server.quit();
sendErmail();

POP3 接收邮件

Python 内置一个 poplib 模块，实现了 POP3 协议，可以直接用来收邮件；
POP3 协议收取的不是一个已经可以阅读的邮件本身，而是邮件的原始文本，这和 SMTP 协议很像，SMTP 发送的也是经过编码后的一大段文本，所以，要把 POP3 收取的文本变成可以阅读的邮件，还需要用 email 模块提供的各种类来解析原始文本，变成可阅读的邮件对象；
步骤

用 poplib 把邮件的原始文本下载到本地；
用 email 解析原始文本，还原为邮件对象；

示例

# -*- coding: utf-8 -*-
from email.parser import Parser;
from email.utils import parseaddr;
from email.header import decode_header;
import poplib;

# 邮件的内容也是str，还需要检测编码，否则，非UTF-8编码的邮件都无法正常显示
def guessCharset(msg):
    charset = msg.get_charset();
    if charset is None:
        contentType = msg.get('Content-Type', '').lower();
        pos = contentType.find('charset=');
        if pos >= 0:
            charset = contentType[pos + 8:].strip();
    return charset;

# 邮件的Subject或者Email中包含的名字都是经过编码后的str，要正常显示，就必须decode
def decodeStr(s):
    # 返回一个list，有Cc、Bcc多个邮件地址，我们只取第一个
    value, charset = decode_header(s)[0];
    if charset:
        value = value.decode(charset);
    return value;

# 解析邮件返回信息，indent用于缩进显示:
def printInfo(msg, indent=0):
    if indent == 0:
        for header in ['From', 'To', 'Subject']:
            value = msg.get(header, '');
            if value:
                if header == 'Subject':
                    value = decodeStr(value);
                else:
                    hdr, addr = parseaddr(value);
                    name = decodeStr(hdr);
                    value = u'%s <%s>' % (name, addr);
            print('%s%s: %s' % ('  ' * indent, header, value));
    if (msg.is_multipart()):
        parts = msg.get_payload();
        for n, part in enumerate(parts):
            print('%spart %s' % ('  ' * indent, n));
            print('%s--------------------' % ('  ' * indent));
            printInfo(part, indent + 1);
    else:
        content_type = msg.get_content_type();
        if content_type=='text/plain' or content_type=='text/html':
            content = msg.get_payload(decode=True);
            charset = guessCharset(msg);
            if charset:
                content = content.decode(charset);
            print('%sText: %s' % ('  ' * indent, content + '...'));
        else:
            print('%sAttachment: %s' % ('  ' * indent, content_type));

def receiveEmail():
    # emailAddress = input("Email Address:");
    # password = input("Password:");
    # popServer = input("POP Server:");
    emailAddress = "898899721@qq.com";
    password = "ibqfqoxrfmfubecf";
    popServer = "pop.qq.com";

# 连接到pop3服务器
    server = poplib.POP3(popServer);
    # 打开调试信息
    server.set_debuglevel(1);
    # 打印pop3服务器欢迎信息
    print(server.getwelcome().decode("utf-8"));
    # 验证登录用户
    server.user(emailAddress);
    server.pass_(password);

# 打印邮箱邮件数量、占空间大小
    print("MailBox stat: MailCount(%s), MailSize(%s)" % server.stat());
    # 返回tuple，共三个元素，第二个元素是所有邮件的编号list
    # 类似：(b'+OK', [b'1 1787', b'2 1824'...], 327)
    resp, mails, octets = server.list();
    print(mails);
    # 获取最新的一封邮件，索引从1开始
    # mailLines存储了邮件每一行
    index = len(mails);
    resp, mailLines, octets = server.retr(index);
    mailContent = b'\r\n'.join(mailLines).decode("utf-8");
    # 将邮件内容解析为Message对象，有可能是MIMEMultipart
    mail = Parser().parsestr(mailContent);
    printInfo(mail);
    # 可以根据邮件索引号直接从服务器删除邮件:
    # server.dele(index)

# 关闭连接
    server.quit();
receiveEmail();

 
# -*- coding: utf-8 -*-
from email.parser import Parser;
from email.utils import parseaddr;
from email.header import decode_header;
import poplib;
# 邮件的内容也是str，还需要检测编码，否则，非UTF-8编码的邮件都无法正常显示
def guessCharset(msg):
    charset = msg.get_charset();
    if charset is None:
        contentType = msg.get('Content-Type', '').lower();
        pos = contentType.find('charset=');
        if pos >= 0:
            charset = contentType[pos + 8:].strip();
    return charset;
# 邮件的Subject或者Email中包含的名字都是经过编码后的str，要正常显示，就必须decode
def decodeStr(s):
    # 返回一个list，有Cc、Bcc多个邮件地址，我们只取第一个
    value, charset = decode_header(s)[0];
    if charset:
        value = value.decode(charset);
    return value;
# 解析邮件返回信息，indent用于缩进显示:
def printInfo(msg, indent=0):
    if indent == 0:
        for header in ['From', 'To', 'Subject']:
            value = msg.get(header, '');
            if value:
                if header == 'Subject':
                    value = decodeStr(value);
                else:
                    hdr, addr = parseaddr(value);
                    name = decodeStr(hdr);
                    value = u'%s <%s>' % (name, addr);
            print('%s%s: %s' % ('  ' * indent, header, value));
    if (msg.is_multipart()):
        parts = msg.get_payload();
        for n, part in enumerate(parts):
            print('%spart %s' % ('  ' * indent, n));
            print('%s--------------------' % ('  ' * indent));
            printInfo(part, indent + 1);
    else:
        content_type = msg.get_content_type();
        if content_type=='text/plain' or content_type=='text/html':
            content = msg.get_payload(decode=True);
            charset = guessCharset(msg);
            if charset:
                content = content.decode(charset);
            print('%sText: %s' % ('  ' * indent, content + '...'));
        else:
            print('%sAttachment: %s' % ('  ' * indent, content_type));
def receiveEmail():
    # emailAddress = input("Email Address:");
    # password = input("Password:");
    # popServer = input("POP Server:");
    emailAddress = "898899721@qq.com";
    password = "ibqfqoxrfmfubecf";
    popServer = "pop.qq.com";
    # 连接到pop3服务器
    server = poplib.POP3(popServer);
    # 打开调试信息
    server.set_debuglevel(1);
    # 打印pop3服务器欢迎信息
    print(server.getwelcome().decode("utf-8"));
    # 验证登录用户
    server.user(emailAddress);
    server.pass_(password);
    # 打印邮箱邮件数量、占空间大小
    print("MailBox stat: MailCount(%s), MailSize(%s)" % server.stat());
    # 返回tuple，共三个元素，第二个元素是所有邮件的编号list
    # 类似：(b'+OK', [b'1 1787', b'2 1824'...], 327)
    resp, mails, octets = server.list();
    print(mails);
    # 获取最新的一封邮件，索引从1开始
    # mailLines存储了邮件每一行
    index = len(mails);
    resp, mailLines, octets = server.retr(index);
    mailContent = b'\r\n'.join(mailLines).decode("utf-8");
    # 将邮件内容解析为Message对象，有可能是MIMEMultipart
    mail = Parser().parsestr(mailContent);
    printInfo(mail);
    # 可以根据邮件索引号直接从服务器删除邮件:
    # server.dele(index)
    # 关闭连接
    server.quit();
receiveEmail();

访问数据库

MySQL

概述：MySQL 是 Web 世界中使用最广泛的数据库服务器，内部有多种数据库引擎，最常用的引擎是支持数据库事务的 InnoDB；
使用步骤

安装 MySQL 数据库 ---- 参考 Tool_MySql；
安装第三方库

pip install pymysql
pip install mysql-connector

书写代码进行操作：创建连接 ---- 获得指针 cursor ---- 增删改查 sql 语句 ---- 提交事务（增删改） ---- 关闭指针 ---- 关闭连接；

示例

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
'''
pymysql 组件示例
'''
import pymysql;

def connect_mysql():
    connection = pymysql.connect(host='localhost', user='root', passwd='root', db='test', charset='utf8');
    cursor = connection.cursor();
    return connection, cursor;

def execute_insert_update_delete(cursor, sql):
    status = cursor.execute(sql);
    return status;

def execute_query(cursor, sql):
    cursor.execute(sql);
    return cursor.fetchall();

def execute_commit(cursor):
    cursor.connection.commit();

def connection_close(connection, cursor):
    connection.close();
    cursor.close();

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
'''
mysql-connector 组件示例
'''
import mysql.connector;

def mySQLTest():
    # 创建数据库连接
    conn = mysql.connector.connect(user="root", password="root", host='127.0.0.1', 
                                   port='3306', database="test", use_unicode=True);

# 增删改操作
    cursor = conn.cursor();
    cursor.execute('DROP TABLE IF EXISTS `user`;');
    # cursor.execute('create table user (id varchar(20) primary key, name varchar(20))');
    cursor.execute('create table user (id INT AUTO_INCREMENT PRIMARY KEY, name varchar(20))');
    # 插入一行记录，注意MySQL的占位符是%s:
    cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'HymanHu']);
    cursor.execute('insert into user (id, name) values (%s, %s)', ['2', 'Jianghu']);
    print(cursor.rowcount);
    conn.commit();
    cursor.close();

# 查询操作
    cursor = conn.cursor();
    # cursor.execute('select * from user where id = %s', ('1',));
    cursor.execute('select * from user');
    values = cursor.fetchall()
    print(values);
    cursor.close();

# 关闭连接
    conn.close();
mySQLTest();

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
'''
pymysql 组件示例
'''
import pymysql;
def connect_mysql():
    connection = pymysql.connect(host='localhost', user='root', passwd='root', db='test', charset='utf8');
    cursor = connection.cursor();
    return connection, cursor;
def execute_insert_update_delete(cursor, sql):
    status = cursor.execute(sql);
    return status;
def execute_query(cursor, sql):
    cursor.execute(sql);
    return cursor.fetchall();
def execute_commit(cursor):
    cursor.connection.commit();
def connection_close(connection, cursor):
    connection.close();
    cursor.close();
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HymanHu";
'''
mysql-connector 组件示例
'''
import mysql.connector;
def mySQLTest():
    # 创建数据库连接
    conn = mysql.connector.connect(user="root", password="root", host='127.0.0.1', 
                                   port='3306', database="test", use_unicode=True);
    # 增删改操作
    cursor = conn.cursor();
    cursor.execute('DROP TABLE IF EXISTS `user`;');
    # cursor.execute('create table user (id varchar(20) primary key, name varchar(20))');
    cursor.execute('create table user (id INT AUTO_INCREMENT PRIMARY KEY, name varchar(20))');
    # 插入一行记录，注意MySQL的占位符是%s:
    cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'HymanHu']);
    cursor.execute('insert into user (id, name) values (%s, %s)', ['2', 'Jianghu']);
    print(cursor.rowcount);
    conn.commit();
    cursor.close();
    # 查询操作
    cursor = conn.cursor();
    # cursor.execute('select * from user where id = %s', ('1',));
    cursor.execute('select * from user');
    values = cursor.fetchall()
    print(values);
    cursor.close();
    # 关闭连接
    conn.close();
mySQLTest();

mysql_util.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import pymysql

'''
mysql utils
'''

__author__ = "HymanHu";

def get_connect_cursor():
    connect = pymysql.connect(host='localhost', user='root', passwd='root', db='maindb', charset='utf8')
    return connect, connect.cursor();

def execute_insert_update_delete(cursor, sql):
    result = cursor.execute(sql)
    return result

def execute_query(cursor, sql):
    cursor.execute(sql)
    return cursor.fetchall()

def commit_(connect):
    connect.commit()

def rollback_(connect):
    connect.rollback()

def close_connect_cursor(connect, cursor):
    if connect:
        connect.close()
    if cursor:
        cursor.close()

def execute_(sql):
    connect, cursor = None, None
    result = None
    try:
        connect, cursor = get_connect_cursor()
        if sql.startswith("select"):
            result = execute_query(cursor, sql)
        else:
            result = execute_insert_update_delete(cursor, sql)
            commit_(connect)
    except Exception as e:
        print(e)
    finally:
        close_connect_cursor(connect, cursor)

return result

def batch_excute_(sqls):
    connect, cursor = None, None
    try:
        connect, cursor = get_connect_cursor()
        for sql in sqls:
            cursor.execute(sql)
        commit_(connect)
    except Exception as e:
        print(e)
    finally:
        close_connect_cursor(connect, cursor)

if __name__ == "__main__":
    pass

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import pymysql
'''
mysql utils
'''
__author__ = "HymanHu";
def get_connect_cursor():
    connect = pymysql.connect(host='localhost', user='root', passwd='root', db='maindb', charset='utf8')
    return connect, connect.cursor();
def execute_insert_update_delete(cursor, sql):
    result = cursor.execute(sql)
    return result
def execute_query(cursor, sql):
    cursor.execute(sql)
    return cursor.fetchall()
def commit_(connect):
    connect.commit()
def rollback_(connect):
    connect.rollback()
def close_connect_cursor(connect, cursor):
    if connect:
        connect.close()
    if cursor:
        cursor.close()
def execute_(sql):
    connect, cursor = None, None
    result = None
    try:
        connect, cursor = get_connect_cursor()
        if sql.startswith("select"):
            result = execute_query(cursor, sql)
        else:
            result = execute_insert_update_delete(cursor, sql)
            commit_(connect)
    except Exception as e:
        print(e)
    finally:
        close_connect_cursor(connect, cursor)
    return result
def batch_excute_(sqls):
    connect, cursor = None, None
    try:
        connect, cursor = get_connect_cursor()
        for sql in sqls:
            cursor.execute(sql)
        commit_(connect)
    except Exception as e:
        print(e)
    finally:
        close_connect_cursor(connect, cursor)
if __name__ == "__main__":
    pass

SQLite

概述：SQLite 是一种嵌入式数据库，它的数据库就是一个文件。由于 SQLite 本身是 C 写的，而且体积很小，所以，经常被集成到各种应用程序中，甚至在 IOS 和 Android 的 App 中都可以集成；

Java 调用 Python

方式一：模拟执行 cmd 调用 Python 模块；

LPRServiceImpl.java

获得 Python 打印信息、错误信息，方便调试。

private String lincensePlateRecognition(String filePath, String path) {
	String result = "";
	BufferedReader in = null;
	BufferedReader errorIn = null;
	try {
		String systemName = System.getProperty("os.name");
		filePath = systemName.toLowerCase().startsWith("win") ? 
				pythonBaseDirForWindow + filePath : 
				pythonBaseDirForLinux + filePath;
		// 第一个元素是执行命令，第二个元素是文件路径，第三个是调用模块参数
		String[] args = new String[] {"python", filePath, path};
		Process proc = Runtime.getRuntime().exec(args);
		
		// Linux 系统使用 UTF-8 编码
		in = new BufferedReader(new InputStreamReader(proc.getInputStream(), "UTF-8"));
		errorIn = new BufferedReader(new InputStreamReader(proc.getErrorStream(), "UTF-8"));
		String line = null;
		while ((line = in.readLine()) != null) {
			LOGGER.debug(String.format("======== %s", line));
			Matcher matcher = Pattern.compile("result:\\[(.*?)\\]").matcher(line);
			if (matcher != null && matcher.find()) {
				result = matcher.group(1);
			}
		}
		while ((line = errorIn.readLine()) != null) {
			LOGGER.debug(String.format("======== %s", line));
		}
		proc.waitFor();
	} catch (IOException e) {
		e.printStackTrace();
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		try {
			if (in != null) {
				in.close();
			}
			if (errorIn != null) {
				errorIn.close();
			}
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
	
	return result;
}

 
private String lincensePlateRecognition(String filePath, String path) {
    String result = "";
    BufferedReader in = null;
    BufferedReader errorIn = null;
    try {
        String systemName = System.getProperty("os.name");
        filePath = systemName.toLowerCase().startsWith("win") ? 
                pythonBaseDirForWindow + filePath : 
                pythonBaseDirForLinux + filePath;
        // 第一个元素是执行命令，第二个元素是文件路径，第三个是调用模块参数
        String[] args = new String[] {"python", filePath, path};
        Process proc = Runtime.getRuntime().exec(args);
        
        // Linux 系统使用 UTF-8 编码
        in = new BufferedReader(new InputStreamReader(proc.getInputStream(), "UTF-8"));
        errorIn = new BufferedReader(new InputStreamReader(proc.getErrorStream(), "UTF-8"));
        String line = null;
        while ((line = in.readLine()) != null) {
            LOGGER.debug(String.format("======== %s", line));
            Matcher matcher = Pattern.compile("result:\\[(.*?)\\]").matcher(line);
            if (matcher != null && matcher.find()) {
                result = matcher.group(1);
            }
        }
        while ((line = errorIn.readLine()) != null) {
            LOGGER.debug(String.format("======== %s", line));
        }
        proc.waitFor();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        try {
            if (in != null) {
                in.close();
            }
            if (errorIn != null) {
                errorIn.close();
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
    }
    
    return result;
}

BicolorSphereServiceImpl.java

 
public List<String> updateBicolorSpheres(int issueCount) {
    List<String> result = new ArrayList<>();
    try {
        String systemName = System.getProperty("os.name");
        String filePath = systemName.toLowerCase().startsWith("win") ? 
                pythonBaseDirForWindow + "/spider/bicolor_sphere_spider.py" : 
                pythonBaseDirForLinux + "/spider/bicolor_sphere_spider.py";
        // 第一个元素是执行命令，第二个元素是文件路径，第三个是调用模块参数
        String[] args = new String[] {"python", filePath, String.valueOf(issueCount)};
        Process proc = Runtime.getRuntime().exec(args);
        
        BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream(), "gbk"));
        String line = null;
        while ((line = in.readLine()) != null) {
            result.add(line);
        }
        in.close();
        proc.waitFor();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    
    return result;
}

bicolor_sphere_spider.py

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "HuJiang";
# 将项目根目录添加到 sys.path，解决 cmd 下执行该模块找不到包的问题
import sys, os;
current_path = os.path.abspath(os.path.dirname(__file__));
separator = "\\" if os.name == "nt" else "/";
project_name = "jianghu_python" + separator;
root_path = current_path[:current_path.find(project_name) + len(project_name)];  # 获取项目根目录
sys.path.append(root_path);
if __name__ == "__main__":
    # parse_ssq_list_page(page_count=147);
    issue_count = 100;
    page_size = 100;
    # 外部传递参数从第二位开始
    if len(sys.argv) > 1:
        issue_count = int(sys.argv[1]);
        page_size = int(sys.argv[1]);
    parse_ssq_page(issue_count, page_size);

Python 项目互调

需求：项目 A 调用项目 B 的模块；
方案：A 项目将 B 项目根目录加入 sys.path，然后正常调用即可，注意，IDE 无法识别会报错，但并不影响项目运行。
views.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "JiangHu";

# 将其他项目根目录添加到 sys.path
import sys, os;
sys.path.append(r'D:\projectCode\sfac_project\python_wealth_code');

from django.shortcuts import render, redirect;
import json;
from django.http import JsonResponse;
from django.db.models import Q;
from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage;
from util.PageVo import *;
from app_lottery.models import *;
from spider.bicolor_sphere_spider import *;
from data_processing.bicolor_sphere_forecast import *;

# Create your views here.

#127.0.0.1:8080/api/bicolorSpheres/spider ---- get
def spiderBicolorSphere(request):
    if request.method == "GET":
        parse_ssq_page(10, 10);
        return JsonResponse(Result(200, "Update success.").result());
    else:
        return JsonResponse(Result(500, "Unsurport request method.").result());

#127.0.0.1:8080/api/bicolorSpheres/forecast ---- get
def forecast(request):
    if request.method == "GET":
        df = init_data();
        ses_forecast(df);
        holt_forecast(df);
        lstm_forecast(df);
        random_forecast();
        result = save_forecast_result();
        return JsonResponse(Result(200, "Forecast success.", result).result());
    else:
        return JsonResponse(Result(500, "Unsurport request method.").result());

 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = "JiangHu";
# 将其他项目根目录添加到 sys.path
import sys, os;
sys.path.append(r'D:\projectCode\sfac_project\python_wealth_code');
from django.shortcuts import render, redirect;
import json;
from django.http import JsonResponse;
from django.db.models import Q;
from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage;
from util.PageVo import *;
from app_lottery.models import *;
from spider.bicolor_sphere_spider import *;
from data_processing.bicolor_sphere_forecast import *;
# Create your views here.
#127.0.0.1:8080/api/bicolorSpheres/spider ---- get
def spiderBicolorSphere(request):
    if request.method == "GET":
        parse_ssq_page(10, 10);
        return JsonResponse(Result(200, "Update success.").result());
    else:
        return JsonResponse(Result(500, "Unsurport request method.").result());
#127.0.0.1:8080/api/bicolorSpheres/forecast ---- get
def forecast(request):
    if request.method == "GET":
        df = init_data();
        ses_forecast(df);
        holt_forecast(df);
        lstm_forecast(df);
        random_forecast();
        result = save_forecast_result();
        return JsonResponse(Result(200, "Forecast success.", result).result());
    else:
        return JsonResponse(Result(500, "Unsurport request method.").result());

前言

简介

Python 基础

规则

运行

包结构