python知识整理

 

知识要点
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 sum

while

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 "<stdin>", line 1, in <module>
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
2

deque

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 '<h1>Hello, web!</h1>'




# 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. 步骤1：浏览器首先向服务器发送HTTP请求，请求包括：
   方法：GET还是POST，GET仅请求资源，POST会附带用户数据；
   路径：/full/url/path；
   域名：由Host头指定：Host: www.sina.com.cn
   以及其他相关的Header；
   如果是POST，那么请求还包括一个Body，包含用户数据。

2. 步骤2：服务器向浏览器返回HTTP响应，响应包括：
   响应代码：200表示成功，3xx表示重定向，4xx表示客户端发送的请求有错误，5xx表示服务器端处理时发生了错误；
   响应类型：由Content-Type指定；
   以及其他相关的Header；
   通常服务器的HTTP响应会携带内容，也就是有一个Body，包含响应的内容，网页的HTML源码就在Body中。

3. 步骤3：如果浏览器还需要继续向服务器请求其他资源，比如图片，就再次发出HTTP请求，重复步骤1、2。

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

 

转载于:https://www.cnblogs.com/idengbo/p/8139779.html