python基础
安装常见问题
变量类型
1. 列表
2. 元组
3. 字典
4. 集合
条件循环判断
条件
循环
for
while
函数
定义函数
可变参数
高阶函数
匿名函数
装饰器
模块
模块使用
类
类的定义
类的继承
获取对象信息
高级面向对象编程
错误处理
错误输出
单元测试
文档测试
读写文件
读文件
写文件
序列化
pickle
Json
并行处理
多进程
多线程
分布式进程处理
正则表达式
基本语法
re模块
分组
常用模块
collections
namedtuple
deque
defaultdict元素不存在是定义输出/OrderedDict有序字典
base64
hashlib
wsgi
web框架
Sqlite3操作
数据库基本操作
sqlite3常用命令
牛人代码
数据库
命令
查询和更新指令构成了 SQL 的 DML 部分：
SQL 中最重要的 DDL 语句:
http
HTTP简介
知识要点
- http协议
- html基本语法
- 动态网页技术？
- 网站基本搭建环境
- 客户端？
- python基础
python基础
- 动态语言
安装常见问题
- ipython 不能自动补全
需要安装readline模块：pip install readline 或 pip install pyreadline
变量类型
1. 列表
``` Python
classmates = ['Michael', 'Bob', 'Tracy']
```
切片 L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。L[-1]取倒数第一个元素. 列表生成式
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']2. 元组
``` Python
classmates = ('Michael', 'Bob', 'Tracy')
```
3. 字典
``` Python
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
```
4. 集合
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：
``` Python
>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])
```
条件循环判断
条件
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>循环
for
for x in range(101):
sum = sum + x
print sumwhile
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print sum函数
python内置函数
定义函数
定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
def my_abs(x):
if x >= 0:
return x
else:
return -x函数执行到return时，函数就执行完毕，并将结果返回。如没有return， 则返回None.
空语句 pass.
当返回多个值时，其返回的类型为元组。
生成器：包含yeild关键字，执行到关键字返回，下次执行从关键字后继续执行。
可变参数
高阶函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(x, y, f):
return f(x) + f(y)- map
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
>>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
['1', '2', '3', '4', '5', '6', '7', '8', '9']-
reduce
reduce()把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)-
filter
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素.
def is_odd(n):
return n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])-
sorted
通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
>>> sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]
def reversed_cmp(x, y):
if x > y:
return -1
if x < y:
return 1
return 0
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]匿名函数
关键字lambda表示匿名函数，冒号前面的x表示函数参数。只能有一个表达式，不用写return，返回值就是该表达式的结果。
装饰器
这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
def log(func):
def wrapper(*args, **kw):
print 'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
@log
def now():
print '2013-12-25'
>>> now()
call now():
2013-12-25助Python的@语法，把decorator置于函数的定义处,此时调用now()函数,相当于执行 now = log(now)
模块
一个.py文件就称之为一个模块（Module）,每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包.
模块使用
import sys
try:
import cStringIO as StringIO
except ImportError: # 导入失败会捕获到ImportError
import StringIO- future模块
Python提供了__future__模块，把下一个新版本的特性导入到当前版本.
from __future__ import unicode_literals
print '\'xxx\' is unicode?', isinstance('xxx', unicode)
print 'u\'xxx\' is unicode?', isinstance(u'xxx', unicode)
print '\'xxx\' is str?', isinstance('xxx', str)
print 'b\'xxx\' is str?', isinstance(b'xxx', str)类
示例
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print '%s: %s' % (self.name, self.score)类的定义
定义类是通过class关键字：class后面紧接着是类名，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的.
class Student(object):
pass__init__方法类似与构造函数
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print '%s: %s' % (self.name, self.score)类特殊变量__XXX__,如__name__.
private变量 __xxx 或_xxx. __xxx不可直接访问，但可通过_类名__xxx来访问，如_Student__name
类的继承
一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）
class Animal(object):
def run(self):
print 'Animal is running…'
class Dog(Animal):
pass
class Cat(Animal):
pass获取对象信息
- types()
>>> import types
>>> type('abc')==types.StringType
True
>>> type(u'abc')==types.UnicodeType
True
>>> type([])==types.ListType
True
>>> type(str)==types.TypeType
True- isinstance()
>>> isinstance('a', str)
True
>>> isinstance(u'a', unicode)
True
>>> isinstance('a', unicode)
False
>>> isinstance('a', (str, unicode))
True
>>> isinstance(u'a', (str, unicode))
True- dir()
>>> dir('ABC')
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：
>>> class MyObject(object):
… def __init__(self):
… self.x = 9
… def power(self):
… return self.x * self.x
…
>>> obj = MyObject()
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19高级面向对象编程
- 访问限制. 定义了一个class,创建了一个class的实例后，我们可以给该实例绑定任何属性和方法. 而通过定义一个特殊的__slots__变量，可限制该class能添加的属性.
>>> class Student(object):
pass
>>> def set_age(self, age): # 定义一个函数作为实例方法
self.age = age
>>> s = Student()
>>> s.name = 'Michael' # 动态给实例绑定一个属性
>>> print s.name
Michael.
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25
>>> class Student(object):
… __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
…
>>> s = Student() # 创建新的实例
>>> s.name = 'Michael' # 绑定属性'name'
>>> s.age = 25 # 绑定属性'age'
>>> s.score = 99 # 绑定属性'score'
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'Student' object has no attribute 'score' - 方法直接转换为属性,@property 装饰器.
\@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
…
ValueError: score must between 0 ~ 100!- 多重继承.类似与c++中的接口.
class Animal(object):
pass
# 大类:
class Mammal(Animal):
pass
class Bird(Animal):
pass
# 其它需要的功能
class Runnable(object):
def run(self):
print('Running…')
class Flyable(object):
def fly(self):
print('Flying…')
# 多重继承
class Dog(Mammal, Runnable):
pass- 定制类.
__len__()方法我们也知道是为了能让class作用于len()函数.
__str__()方法，返回一个好看的字符串,__repr__()返回程序开发者看到的字符串.
__iter__()类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环.
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化两个计数器a，b
def __iter__(self):
return self # 实例本身就是迭代对象，故返回自己
def next(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 100000: # 退出循环的条件
raise StopIteration();
return self.a # 返回下一个值__getitem__,像list那样按照下标取出元素.
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a__getattr__ 动态返回一个属性、__call__直接对实例进行调用。
更多定制
错误处理
Python的错误其实也是class，所有的错误类型都继承自BaseException.
内置错误类型
try:
print 'try…'
r = 10 / int('a')
print 'result:', r
except ValueError, e:
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
else:
print 'no error!'
finally:
print 'finally…'
print 'END'错误输出
- print/assert
-
logging: 其有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了.详细配置
``` Python # 基本使用 import logging #设定Logging输出级别 logging.basicConfig(level=logging.INFO) s = '0' n = int(s) logging.info('n = %d' % n) print 10 / n # 同时输出到屏幕和文件 import logging # 创建一个logger logger = logging.getLogger('mylogger') logger.setLevel(logging.DEBUG) # 创建一个handler，用于写入日志文件 fh = logging.FileHandler('test.log') fh.setLevel(logging.DEBUG) # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) # 定义handler的输出格式 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) # 给logger添加handler logger.addHandler(fh) logger.addHandler(ch) # 记录一条日志 logger.info('foorbar') ``` -
pdb
单元测试
编写单元测试时，我们需要编写一个测试类，从unittest.TestCase继承。
单元测试的测试用例要覆盖常用的输入组合、边界条件和异常。
文档测试
在文档说明中包含执行代码,测试异常的时候，可以用…表示中间一大段烦人的输出.
class Dict(dict):
'''
Simple dict but also support access as x.y style.
>>> d1 = Dict()
>>> d1['x'] = 100
>>> d1.x
100
>>> d1.y = 200
>>> d1['y']
200
>>> d2 = Dict(a=1, b=2, c='3')
>>> d2.c
'3'
>>> d2['empty']
Traceback (most recent call last):
…
KeyError: 'empty'
>>> d2.empty
Traceback (most recent call last):
…
AttributeError: 'Dict' object has no attribute 'empty'
'''
def __init__(self, **kw):
super(Dict, self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
if __name__=='__main__':
import doctest
doctest.testmod()读写文件
读文件
f = open('/Users/michael/test.txt', 'r')
>>> f.read() # 一次全部读入
'Hello, world!'
for line in f.readlines(): # 按行读取存成list
print(line.strip()) # 把末尾的'\n'删掉
# 增加错误处理的读取方式
with open('/path/to/file', 'r') as f:
print f.read()写文件
>>> f = open('/Users/michael/test.txt', 'w') # 'w' 文本，'wb' 表示二进制文件
>>> f.write('Hello, world!')
>>> f.close()
# 下边这个更好
with open('/Users/michael/test.txt', 'w') as f:
f.write('Hello, world!')序列化
Q:序列化有啥用？
pickle
Json
对应关系
| JSON类型 | Python类型 |
|---|---|
| {} | dict |
| [] | list |
| "string" | 'str'或u'unicode' |
| 1234.56 | int或float |
| true/false | True/False |
| null | None |
# 序列化
>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}'
# 反序列化
>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> json.loads(json_str)
{u'age': 20, u'score': 88, u'name': u'Bob'}并行处理
多进程
更稳定
multiprocessing 模块
多线程
效率更高
threading模块
分布式进程处理
multiprocessing.managers 通过网络异步执行任务
正则表达式
基本语法
re模块
- match()方法从开始判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None.
re.match的函数原型为：re.match(pattern, string, flags)
>>> import re
>>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
<_sre.SRE_Match object at 0x1026e18b8>- re.search 与 match类似。
re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。 - re.sub
re.sub用于替换字符串中的匹配项。
re.sub的函数原型为：re.sub(pattern, repl, string, count)
import re
text = "JGood is a handsome boy, he is cool, clever, and so on…"
print re.sub(r'\s+', '-', text)-
re.split
可以使用re.split来分割字符串，如：
re.split(r'\s+', text)；将字符串按空格分割成一个单词列表。
>>> 'a b c'.split(' ')
['a', 'b', '', '', 'c']-
re.findall
re.findall可以获取字符串中所有匹配的字符串。如：
re.findall(r'\w*oo\w*', text)；获取字符串中，包含'oo'的所有单词。 -
re.compile
可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。下面是一个正则表达式对象的一个例子：
import re
text = "JGood is a handsome boy, he is cool, clever, and so on…"
regex = re.compile(r'\w*oo\w*')
print regex.findall(text) #查找所有包含'oo'的单词
print regex.sub(lambda m: '[' + m.group(0) + ']', text) #将字符串中含有'oo'的单词用[]括起来。分组
用()表示的就是要提取的分组（Group）,比如： ^(\d{3})-(\d{3,8})$分别定义了两个组.groups()表示所有分组，group(0)或group()表示所有匹配，group(1)、group(2)……表示第1、2、……个匹配子串.
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object at 0x1026fb3e8>
>>> m.group(0)
'010-12345'
>>> m.group(1)
'010'
>>> m.group(2)
'12345'常用模块
collections
namedtuple
自定义元组。如定义坐标等。
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2deque
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈.
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])defaultdict元素不存在是定义输出/OrderedDict有序字典
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'
# OrderedDict的Key会按照插入的顺序排列，不是Key本身排序
>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']base64
Base64是一种用64个字符来表示任意二进制数据的方法。
每3个字节用四个字符表示
>>> import base64
>>> base64.b64encode('binary\x00string')
'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode('YmluYXJ5AHN0cmluZw==')
'binary\x00string'hashlib
import hashlib
# md5
md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print md5.hexdigest()
# sha1
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()wsgi
WSGI：Web Server Gateway Interface
python内置了一个WSGI服务器，这个模块叫wsgiref
# hello.py
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return 'Hello, web!
'
# server.py
# 从wsgiref模块导入:
from wsgiref.simple_server import make_server
# 导入我们自己编写的application函数:
from hello import application
# 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
httpd = make_server('', 8000, application)
print "Serving HTTP on port 8000…"
# 开始监听HTTP请求:
httpd.serve_forever()web框架
将python代码和html代码分离.
Flask
Django
Sqlite3操作
数据库基本操作
- 创建表
create table mytable(id integer primary key, value text); - 插入
insert into mytable(id, value) values(1, 'Micheal'); - 查找
select * from test; - 删除
delete from test where id = 1 ;
快速参考
sqlite3常用命令
- .schema 显示表结构
- .tables 显示表
其它
牛人代码
BBS论坛密码破解
知乎回答中代码片段
知乎爬虫入门
数据库
命令
每条SQL命令采用;分隔
分为两个部分：数据操作语言 (DML) 和 数据定义语言 (DDL)。
SQL (结构化查询语言)是用于执行查询的语法。但是 SQL 语言也包含用于更新、插入和删除记录的语法。
查询和更新指令构成了 SQL 的 DML 部分：
SELECT - 从数据库表中获取数据
UPDATE - 更新数据库表中的数据
DELETE - 从数据库表中删除数据
INSERT INTO - 向数据库表中插入数据
SQL 中最重要的 DDL 语句:
SQL 的数据定义语言 (DDL) 部分使我们有能力创建或删除表格。我们也可以定义索引（键），规定表之间的链接，以及施加表间的约束。
CREATE DATABASE - 创建新数据库
ALTER DATABASE - 修改数据库
CREATE TABLE - 创建新表
ALTER TABLE - 变更（改变）数据库表
DROP TABLE - 删除表
CREATE INDEX - 创建索引（搜索键）
DROP INDEX - 删除索引
http
HTTP简介
-
步骤1：浏览器首先向服务器发送HTTP请求，请求包括：
方法：GET还是POST，GET仅请求资源，POST会附带用户数据；
路径：/full/url/path；
域名：由Host头指定：Host: www.sina.com.cn
以及其他相关的Header；
如果是POST，那么请求还包括一个Body，包含用户数据。 -
步骤2：服务器向浏览器返回HTTP响应，响应包括：
响应代码：200表示成功，3xx表示重定向，4xx表示客户端发送的请求有错误，5xx表示服务器端处理时发生了错误；
响应类型：由Content-Type指定；
以及其他相关的Header；
通常服务器的HTTP响应会携带内容，也就是有一个Body，包含响应的内容，网页的HTML源码就在Body中。 -
步骤3：如果浏览器还需要继续向服务器请求其他资源，比如图片，就再次发出HTTP请求，重复步骤1、2。