Python

Scrapy

Scrapy是用纯Python实现一个为了爬取网站数据、提取结构性数据而编写的应用框架，用途非常广泛。

框架的力量，用户只需要定制开发几个模块就可以轻松的实现一个爬虫，用来抓取网页内容以及各种图片，非常之方便。

Scrapy 使用了 Twisted'twɪstɪd异步网络框架来处理网络通讯，可以加快我们的下载速度，不用自己去实现异步框架，并且包含了各种中间件接口，可以灵活的完成各种需求。

Python爬虫指南

1. 基本的爬虫工作原理
2. 基本的http抓取工具，scrapy
3. Bloom Filter: Bloom Filters by Example
4. 如果需要大规模网页抓取，你需要学习分布式爬虫的概念。其实没那么玄乎，你只要学会怎样维护一个所有集群机器能够有效分享的分布式队列就好。最简单的实现是python-rq: https://github.com/nvie/rq
5. rq和Scrapy的结合：darkrho/scrapy-redis · GitHub
6. 后续处理，网页析取(grangier/python-goose · GitHub)，存储(Mongodb)

安装scrapy

pip install scrapy

创建scrapy项目

scrapy startproject stockstar

创建 scrapy 项目以后，在 settings 文件中有这样的一条默认开启的语句。

POBOTSOXT_OBEY = True
LOG_ENABLED = False      # 关闭日志信息

robots.txt 是遵循 Robot 协议的一个文件，在 Scrapy 启动后，首先会访问网站的 robots.txt 文件，然后决定该网站的爬取范围。有时我们需要将此配置项设置为 False。

scrapy-splash

我们已经见识到了Scrapy的强大之处。但是，Scrapy也有其不足之处，即Scrapy没有JS engine, 因此它无法爬取JavaScript生成的动态网页，只能爬取静态网页，而在现代的网络世界中，大部分网页都会采用JavaScript来丰富网页的功能。所以，这无疑Scrapy的遗憾之处。

那么，我们还能愉快地使用Scrapy来爬取动态网页吗？有没有什么补充的办法呢？答案依然是yes!答案就是，使用scrapy-splash模块！

scrapy-splash模块主要使用了Splash. 所谓的Splash, 就是一个Javascript渲染服务。它是一个实现了HTTP API的轻量级浏览器，Splash是用Python实现的，同时使用Twisted和QT。Twisted（QT）用来让服务具有异步处理能力，以发挥webkit的并发能力。Splash的特点如下：

• 并行处理多个网页
• 得到HTML结果以及（或者）渲染成图片
• 关掉加载图片或使用 Adblock Plus规则使得渲染速度更快
• 使用JavaScript处理网页内容
• 使用Lua脚本
• 能在Splash-Jupyter Notebooks中开发Splash Lua scripts
• 能够获得具体的HAR格式的渲染信息

安装

1、pip install scrapy-splash

2、配置settings.py

SPLASH_URL = 'http://localhost:8050'

3、使用docker运行一个实例：http://192.168.1.241:8050

Lua示例

function main(splash, args)
    splash:go("https://www.linkedin.com/login")
 
    input = splash:select("#username")
    input:send_text('tecshuttle@gmail.com')
 
    password = splash:select("#password")
    password:send_text('sky007tom')
 
    submit = splash:select('button.btn__primary--large')
    submit:mouse_click()
    splash:wait(5)
    png_1 = splash:png()
 
    splash:go('https://www.linkedin.com/mynetwork/')
    search = splash:select('#a11y-menu')
    splash:wait(3)  
    png_2 = splash:png()
 
    return {
    	png_1 = png_1,
      png_2 = png_2
  	}
end

Flask

安装 pip install flask

• Werkzeug 一个 WSGI 工具包
• jinja2 模板引擎

最简单的例子

from flask import Flask
 
app = Flask(__name__)
 
 
@app.route("/")
def hello():
    return "Hello World!"
 
 
if __name__ == "__main__":
    app.run()

实现一点基本web功能

from flask import Flask
from flask import render_template
from flask import request
from flask import jsonify
 
app = Flask(__name__)
 
 
@app.route("/")
def hello():
    return render_template("index.html", boy_name='Tom')  # 模板文件要放在templates文件夹下面，否则找不到。@app.route("/")
 
 
@app.route('/add', methods=['GET', 'POST'])
def add():
    if request.method == 'GET':
        return render_template("add.html")
    else:
        name = request.form.get('name', False)
        old = request.form.get('old', False)
        return render_template('index.html', name=name, old=old)
 
 
@app.route('/api')
def api():
    name = 'name'
    array = []
 
    for i in range(1, 5):
        array.append(i)
 
    return jsonify({name: 'Tom', 'old': 23, 'array': array[::2]})
 
 
if __name__ == "__main__":
    app.debug = True
    app.run()
 
# end file

PyCharm：no module named * 解决方法

使用PyCharm，遇到‘no module named numpy'问题，但是numpy已经成功安装；

后来发现PyCharm项目默认的python.exe在项目所在目录的./env/scripts/python.exe，故使用正式安装的python.exe替换，问题解决。

在file>settings>Project Python>Project interpreter里面修改。

numpy中linspace用法

linspace的功能最初是从MATLAB中学来的，用此来创建等差数列。

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

random模块

#!/usr/bin/python
 
import random
 
print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数
 
a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

随机生成符合某种分布的数据

（1）均匀分布，uniform(a,b)

（2）正态分布，normalvariate(mu, sigma)

（3）高斯分布，gauss(mu,sigma)

就是正态分布，采用了不同的实现方式，据说运行速度更快。实验1000000个数快了不到1秒，也没快太多。

（4）还有生成三角形分布、对数分布、指数分布、β分布、伽马分布等的函数

triangular(low, high, mode)三角形分布

lognormvariate(mu, sigma)对数分布

expovariate(lambd)指数分布

gammavariate(alpha, beta)伽马分布

实际工作中，这些分布比均匀分布和正态分布用的都少的多。

绘制直方图

# histogram.py
import numpy as np
import random
from matplotlib import pyplot as plt
 
data1 = [random.gauss(15,10) for i in range(500)]
data2 = [random.gauss(5,5) for i in range(500)]
bins = np.arange(-60, 60, 2.5)
plt.xlim([min(data1+data2)-5, max(data1+data2)+5])
 
plt.hist(data1, bins=bins, alpha=0.3, label='class 1')
plt.hist(data2, bins=bins, alpha=0.3, label='class 2')
plt.title('Random Gaussian data')
plt.xlabel('variable X')
plt.ylabel('count')
plt.legend(loc='upper right')
 
plt.show()

画曲线图

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-4, 4, 200)
f1 = np.power(10, x)
f2 = np.power(np.e, x)
f3 = np.power(2, x)
 
plt.plot(x, f1, 'r', x, f2, 'b', x, f3, 'g', linewidth = 2)
plt.axis([-4, 4, -0.5, 8])
plt.text(1, 7.5, r'$10^x$', fontsize = 16)
plt.text(2.2, 7.5, r'$e^x$', fontsize = 16)
plt.text(3.2, 7.5, r'$2^x$', fontsize = 16)
 
plt.show()

windows下安装Django

http://jingyan.baidu.com/article/466506580e7d29f549e5f8b6.html

Python27的安装

下载/安装python

yum install -y bzip2*           #nodejs 0.8.5需要，请安装python前，先安装此模块。
 
wget http://www.python.org/ftp/python/2.7.3/Python-2.7.3.tgz
tar zvxf Python-2.7.3.tgz
cd Python-2.7.3
./configure
make && make install
/usr/local/bin/python2.7 -V     #查看Python版本

建立软连接，使系统默认的python指向python2.7

正常情况下即使python2.7安装成功后，系统默认指向的python仍然是2.4.3版本，考虑到yum是基于python2.4.3才能正常工作，不敢轻易卸载。

mv /usr/bin/python  /usr/bin/python.bak
ln -s //usr/local/bin/python2.6 /usr/bin/python
python -V    #检验python指向是否成功

解决系统python软链接指向python2.6版本后，yum不能正常工作

$vi /usr/bin/yum

将文本编辑显示的#/usr/bin/python修改为#/usr/bin/python2.4，保存修改即可。

我为什么要学习python

引言：学习python近两年，谈谈我对于python的一点小理解，也从一些方面谈谈自己微薄的想法，也就是我为什么学习python

这里我不讨论python的一些有用的库或者框架，只从语言本身，最小支持的情况下谈论这门语言本身。

语言的发展都是越来越接近Lisp，这也是这门语言伟大的原因。

下面我罗列一下我学习python的原因：

一.多编程范式

python是一门多范式的编程语言，所谓的过程式，面向对象和函数式的结合。

大部分人接触编程语言都是从过程式开始的，原因是因为过程式的程序方式与计算机运行方式是统一的，指令序列与运行过程是统一的

如典型的C，我也是从C开始学习的，过程式的程序语言设计编写程序较为简单，但是符合人机交互思考方式。

python虽然是一门面向对象语言，就连“ ”（空格）也可以看做是一个对象，但是python胜任过程式是没有问题的。

如不需要使用类的静态方法：

def a_plus_b(a,b):

return a+b python在设计的时候将其当做一门面向对象的方式编写，且不说面向对象给软件设计带来的一些革命等，在python这样的动态语言中面向对象有一个亮点就是Duck typing（鸭子类型）

关于鸭子类型，就是说，如果我认为一个抽象的东西会游泳会“嘎嘎”叫，我就可以把它当做鸭子。

def use_duck( Duck ):

Duck.swim()

Duck.gaga()

class Duck:

def swim(self):

... def gaga(self):

...

如果这样使用

little_duck Duck()

use_duck( little_duck ) 关于Duck类，你可以给他取任何的名字，或者继承它取另一个名字，只需要实现 swim() gaga() 你就可以把它当做鸭子

关于鸭子类型，很多人不理解为什么不需要提供一个接口来规定鸭子的行为，我既不支持也不反对，我的观点是这样的：

1.对于参数的检查，不符合动态语言的特性

2.提供了接口规范，那就不是鸭子类型了，直接叫多态得了

关于python支持的函数式编程

首先是lambda 演算

函数式编程的定义是将函数看做是变量一样的待遇，变量在程序中最简单的有什么待遇呢

1.可以赋值

2.可以作为参数

3.可以改变值（Erlang例外）

4.且不说生命周期了和作用域了

λ演算背后蕴含着计算机可计算性的深厚知识，lambda也是图灵模型，是停机问题的一个否定答案。不仅仅是一个匿名函数那样简单

关于lambda 演算，看看这个程序做了什么

map(lambda n:2*n,[1,2,3,4,5])

1.lambda n:2*n 本身作为一个匿名函数

2.lambda 本身作为一个参数传入 map()函数 ,这也就是说我的高阶函数，可以将函数变身看成是一个变量作为参数传递，这也是它作为函数受到的高等待遇

关于赋值和改变值，两种方式：

1.f = fun() 不改变函数状态，只改变名称，但是说明函数是可以赋值的

2.可以使用闭包作为改变函数的状态方式，或者使用装饰器来完成函数状态改变

函数式编程的使用也可以提高程序的可读性和减少代码，而且能够清晰的表达函数的功能，如MapReduce就是来自函数式编程的思想

Map(func,List)

作用是将func 作用于List中的每一个元素

以刚才的例子举例

map(lambda n:2*n,[1,2,3,4,5])

此函数返回

[2,4,6,8,10]

重要的是在于知道这样的方式带给我们的清晰的设计方式

当然函数式编程不是那么几句话就说完的，理解函数式编程的核心是理解 λ演算

二.一些有意思的特性

惰性计算：

看看完成一个斐波那契数列python 可以怎么做：

>>> def fib(): a , b = 0 ,1 while 1: yield b a , b = b ,a+b

>>> f = fib() 实际上由yield 生成了一个可迭代对象，每次调用

f.next()就可以产生一个斐波那契值，而函数的内部状态是由迭代对象存储的

至于返回一个可迭代对象，如果需要确定迭代到多少位，可以使用 itertools.islice

协程：

协程也是一个基于yield的概念，主要的模式是微线程的协作式工作模式：

1 def coroutine(func): 2 def ret(): 3 f = func() 4 f.next() 5 return f 6 return ret 7 8 9 10 @coroutine 11 def consumer(): 12 print "Wait to getting a task" 13 while 1: 14 n = (yield) 15 print "Got %s",n 16 17 18 19 import time 20 def producer(): 21 c = consumer() 22 while 1: 23 time.sleep(1) 24 print "Send a task to consumer" 25 c.send("task") 26 27 if __name__ == "__main__": 28 producer() 协程带来的好处是可以直接调度你的线程，这也是它为什么叫做协程而不是线程的原因，线程属于抢占式并发，协程属于协作式并发

三.动态语言带来的好处

从程序设计带来的快感(我相信只有热爱这方面的人才有的感觉)来说，动态语言，比如python，节约了更多的时间可以用来陪女朋友或者老婆，或者老公

当然，作为互联网时代快速开发来说，赶鸭子上线，也是《黑客与画家》上面介绍的，快速开发很重要，当然需要符合这方面的需求

动态语言的CPU密集型运算必然比不过C/C++

总之：人生苦短，我用python

Python写的服务器代码区区20行左右

目前正在学Python网络编程基础，发觉Python是一个不错的脚步，Python写的服务器代码区区20行左右，如果是C或者C++写的话，远不止这个数了。

#!usr/bin/python
 
import socket
 
host=''
 
port=51423
 
s=socket.socket (socket.AF_INET ,socket.SOCK_STREAM)
 
s.setsockopt(socket.SOL_SOCKET ,socket.SO_REUSEADDR ,1)
 
s.bind((host,port))
 
s.listen(1)
 
print"Server is running on port %d ;Press Ctrl-c to terminate." % port
 
while 1:
 
clientsock,clientaddr=s.accept()
 
clientfile=clientsock.makefile('rw',0)
 
clientfile.write("welcome ,"+str(clientaddr)+"\n" )
 
clientfile.write("Please enter a string:")
 
clientfile.write("\n")
 
line=clientfile.readline().strip()
 
clientfile.write("You entered string is:%s .\n"%line)
 
clientfile.close()
 
clientsock.close()

运行该程序，然后用客户端连接

Windows环境下Python代码的文件路径问题

在python程序里面我们经常需要对文件进行操作，Windows下的文件目录路径使用反斜杠“\”来分隔。但是，和大多数语言一样，Python代码里面，反斜杠“\”是转义符，例如“\n”表示回车、“\t”表示制表符等等。这样，如果继续用windows习惯使用“\”表示文件路径，就会产生歧义。

例如：“c:\test.txt”这表示c盘根目录下的一个文件，还是表示一个字符串呢？因为“\t”也可以解释为制表符。如果让我们人来判断，这当然是一个很简单的问题。但是机器就无法做出正确的判断了，只有没有歧义的代码机器才会正确执行。

解决办法，采用下面任何一种书写形式均可：

1. 使用斜杠“/”: "c:/test.txt"… 不用反斜杠就没法产生歧义了
2. 将反斜杠符号转义: "c:\\test.txt"… 因为反斜杠是转义符，所以两个"\\"就表示一个反斜杠符号
3. 使用Python的raw string: r"c:\test.txt" … python下在字符串前面加上字母r，表示后面是一个原始字符串raw string，不过raw string主要是为正则表达式而不是windows路径设计的，所以这种做法尽量少用，可能会出问题。

如何安装包？

3种方法

方法1

python程序会使用很多模块，通常安装模块的方法是找到官方网站，选择合适的版本下载安装，很麻烦。

方法2

为了简化安装第三方的模块，python提供了easy_install工具，只需要一条命令就可以安装合适的模块，easy_install是python-setuptools包里的一个命令，所以只要安装python-setuptools就可以了。

#ubuntu
sudo apt install python-setuptools
#centos
sudo  yum install python-setuptools
easy_install scrapy

方法3

pip是一个可以替代 easy_install 的安装和管理 python 软件包的工具,提供更好的提示信息，可以删除包。

python -m pip install scrapy

包源

虽然用easy_install和pip来安装第三方库很方便。它们的原理其实就是从Python的官方源pypi.python.org/pypi 下载到本地，然后解包安装。不过因为某些原因，访问官方的pypi不稳定，很慢甚至有些还时不时的访问不了。

跟ubuntu的apt和centos的yum有各个镜像源一样，pypi也有。

在国内的强烈推荐豆瓣的源http://pypi.douban.com/simple/（注意后面要有/simple目录）。

使用镜像源很简单，用-i指定就行了：

sudo easy_install -i http://pypi.douban.com/simple/ saltTesting 
sudo pip install -i http://pypi.douban.com/simple/ saltTesting

要配制成默认的话，需要创建或修改配置文件（linux的文件在~/.pip/pip.conf，windows在%HOMEPATH%\pip\pip.ini），修改内容为：

[global]
index-url = http://pypi.douban.com/simple

然后用pip的时候自动就会用此镜像源了

另附上一个阿里云的PyPi源：http://mirrors.aliyun.com/pypi/simple/

pip使用

pip -m pip install --upgrade pip # 升级pip自身
pip list                         # 查看安装的包及版本号

python多行注释

python本身不带多行注释，编辑时每行敲一个“#”相当的不方便，其实可以有变通的方法

1. 把要注释的块用if 0：包起来,需要注意缩进

2. 把要注释的块用 包起来，也需要注意缩进。不过一般情况下是用来做function doc的，所以此方法并不怎么好

3. 一般的编辑器都会带多行注释的快捷键

eclipse下可以选中多行，然后按ctrl+/注释或取消注释

110道面试题

一行代码实现1--100之和

print([1, 2, 3])
print(type([1, 2, 3]))
 
print(type(range(1, 4)))
arr = range(1, 4)
print(arr())
 
# print(sum(range(1, 4)))
#
# sum([0, 1, 2])
# sum((2, 3, 4), 1)  # 元组计算总和后再加 1
# sum([0, 1, 2, 3, 4], 2)  # 列表计算总和后再加 2

如何在一个函数内部修改全局变量

a = 4
 
 
def func():
    global a
    a = 5
 
 
print(func())  # 没有返回值的函数，返回的是None
print(a)

列出5个python标准库

os：提供了不少与操作系统相关联的函数

sys: 通常用于命令行参数

re: 正则匹配

math: 数学运算

datetime:处理日期时间

字典如何删除键和合并两个字典

dic = {'name': 'Tom', 'age': 32}
del dic['name']
 
print(dic)
 
dic2 = {'sex': 'boy'}
 
dic2.update(dic)
 
print(dic2)

谈下python的GIL

GIL 是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程运行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。

多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大。

python实现列表去重的方法

lis = [11, 12, 13, 12, 15, 16, 13]
 
print(lis)
 
a = set(lis)
 
print(a)
print([x for x in a])
print(list(a))

fun(*args, **kwargs)中的*args，**kwargs什么意思？

def func(name, *args):
    print(args, type(args))
    print('Print {} {}'.format(*args))
 
 
func(12, 13, 14)
 
 
def f_compose_args(*args, **kwargs):
    print(args, kwargs)
 
 
f_compose_args(1, 2, x=1, y=2, z=3)

args在前，*kwargs在后面，也就是带等号的(字典格式)形参实参传入要放在后面。

python2和python3的range(100)的区别

python2返回列表，python3返回迭代器，节约内存。

一句话解释什么样的语言能够用装饰器?

函数可以作为参数传递的语言，可以使用装饰器。

python内建数据类型有哪些

整型--int

布尔型--bool

字符串--str

列表--list

元组--tuple

字典--dict

列表[1, 2, 3, 4, 5],请使用map()函数输出[1, 4, 9, 16, 25]，并使用列表推导式提取出大于10的数，最终输出[16, 25]

a = [1, 2, 3, 4, 5]
 
 
def func(x):
    return x * x
 
 
b = map(func, a)
 
print([x for x in b if x > 10])

python中生成随机整数、随机小数、0--1之间小数方法

随机整数：random.randint(a, b)，生成区间内的整数。

随机小数：习惯用numpy库，利用np.random.randn(5)生成5个随机小数。

0-1随机小数：random.random()，括号中不传参。

避免转义给字符串加哪个字母表示原始字符串？

r或R，表示需要原始字符串，不转义特殊字符。

print('\t\r')
print(r'\t\r')
print(R'\t\r')

用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的

<div class="nam">中国</div>

import re
 
div = '<div class="name">中国</div><div class="name">深圳</div>'
 
p = re.compile(r'<div class=".*?">(.*?)</div>')
res = p.findall(div)
 
print(res)

print()

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
a = 10
b = 9
print(1, 2, 3, 4, 5, "y = %d + %d" % (a, b), sep=' ', end='*\n')
 
for i in range(10):
    print(i, end='')

python面试题

第1题

import copy
 
 
# 带有默认参数的表达式在函数被定义的时候被计算，不是在调用的时候被计算。
def extend_list(val, list=[]):
    list.append(val)
    return list
 
 
list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
 
print("list1 = %s" % list1)
print("list2 = %s" % list2)
print("list3 = %s" % list3)
 
print("-----------------")
 
array = [1, 2, 3, 4, 5]
 
l1 = copy.deepcopy(array)
array.append(6)
l2 = copy.deepcopy(array)
 
array.pop()
array.pop()
array.pop()
 
l1.append(7)
 
print(array)
print(l1)
print(l2)

第2题

1. 因为闭包的延迟绑定，i在4个闭包中都是3。
2. 因为Python解释器，遇到lambda（类似于def），只是定义了一个匿名函数对象，并保存在内存中，只有等到调用这个匿名函数的时候，才会运行
3. 内部的表达式，而for i in range(4)是另外一个表达式，需等待这个表达式运行结束后，才会开始运行lambda函数，此时的i指向3。

def multipliers():
    return [lambda x: x * i for i in range(4)]
 
 
print([m(2) for m in multipliers()])
 
 
# 修改方案
def multipliers2():
    return [lambda x, a=i: x * a for i in range(4)]
 
 
print([m(2) for m in multipliers2()])

第3题

# 如果一个变量名没有在当前类下的字典中发现。则在更高级的类(如它的父类)中尽心搜索直到引用的变量名被找到。(如果引用变量名在自身类和更高
# 级类中没有找到，将会引发一个属性错误。)
class Parent(object):
    x = 1
 
 
class Child1(Parent):
    pass
 
 
class Child2(Parent):
    pass
 
 
print(Parent.x, Child1.x, Child2.x)
 
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
 
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

第4题

def div1(x, y):
    print("%s/%s = %s" % (x, y, x / y))
 
 
def div2(x, y):
    print("%s//%s = %s" % (x, y, x // y))
 
 
div1(5, 2)
div1(5., 2)
div2(5, 2)
div2(5., 2.)

第5题

# 例如，尝试获取list[10]和之后的成员，会导致IndexError.
# 然而，尝试获取列表的切片，开始的index超过了成员个数不会产生IndexError，而是仅仅返回一个空列表。
# 这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致bug很难被追踪到。
 
list = ['a', 'b', 'c', 'd', 'e']
print(list[10:])

第6题

# 第一行的输出结果直觉上很容易理解，例如list = [[ ]] * 5就是简单的创造了5个空列表。然而，理解表达式list = [[]] * 5的关键一点是
# 它不是创造一个包含五个独立列表的列表，而是它是一个创建了包含对同一个列表五次引用的列表。只有了解了这一点，我们才能更好的理解接下来
# 的输出结果。
 
list = [[]] * 5
list[0].append(10)
print(list)
 
list[1].append(20)
print(list)
 
list.append(30)
print(list)

第7题

# 给定一个含有N个数字的列表。使用单一的列表生成式来产生一个新的列表，该列表只包含满足以下条件的值：
# (a)偶数值
# (b)元素为原始列表中偶数切片。
#
# 例如，如果list[2]包含的值是偶数。那么这个值应该被包含在新的列表当中。因为这个数字同时在原始列表的偶数序列(2为偶数)上。然而，
# 如果list[3]包含一个偶数， 那个数字不应该被包含在新的列表当中，因为它在原始列表的奇数序列上。
 
numbers = [1, 42, 2, 4, 5, 6, 3, 22, 34, 56, 34, 4, 5, 33, 44, 5, 6, 4, 23, 76, 34, 5, 6, 8, 44, 32]
 
print([m for m in numbers[::2] if m % 2 == 0])

第8题

# 给定以下字典的子类，下面的代码能够运行么?为什么?
#
# 能够运行。
# 当key缺失时，执行DefaultDict类，字典的实例将自动实例化这个数列。
 
class DefaultDict(dict):
    def __missing__(self, key):
        return []
 
 
d = DefaultDict()
d['florp'] = 127

操作dict时避免出现KeyError的几种方法

import collections
 
# Python:操作dict时避免出现KeyError的几种方法
# 在读取dict的key和value时，如果key不存在，就会触发KeyError错误，如：
 
t = {
    'a': '1',
    'b': '2',
    'c': '3',
}
# print(t['d'])
 
# 第1种
 
if 'd' in t:
    print(t['d'])
else:
    print(1, 'not exist')
 
# 第2种
print(2, t.get('d'))
print(2, t.get('d', 'not exist'))
 
# 第3种
# 利用dict内置的setdefault(key[,default])方法，如果key存在，则返回其value;否则插入此key，其value为default，并返回default。
print(3, t.setdefault('d', 'Tom'))
 
 
# 第4种
class Counter(dict):
    def __missing__(self, key):
        return 0
 
 
c = Counter(t)
print(4, c['e'])
 
 
# 第5种
def handle():
    return None
 
 
t = collections.defaultdict(handle, t)
print(5, t['f'])

闭包

# line定义的隶属程序块中引用了高层级的变量b，我们称b为line的环境变量。 事实上，line作为line_conf的返回值时，line中已经包括b的
# 取值(尽管b并不隶属于line)。
# 一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值
# 被保存在函数对象的__closure__属性中。
#
 
 
def line_conf():
    b = 15
 
    def line(x):
        return 2 * x + b
 
    return line  # return a function object
 
 
my_line = line_conf()
print(my_line(5))
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)
 
 
# 闭包的作用：
#  1、减少函数的参数
#  2、提高代码的复用性
#
# 闭包有效的减少了函数所需定义的参数数目，这对于并行运算来说有重要的意义。在并行运算的环境下，我们可以让每台电脑负责一个函数，然后将一
# 台电脑的输出和下一台电脑的输入串联起来。最终，我们像流水线一样工作，从串联的电脑集群一端输入数据，从另一端输出数据。这样的情境最适合
# 只有一个参数输入的函数。闭包就可以实现这一目的。
 
def line_func(a, b):
    def line(x):
        return a * x + b
 
    return line
 
 
line1 = line_func(1, 1)
line2 = line_func(4, 5)
print(line1(5), line2(5))
 
# 在Python中创建一个闭包可以归结为以下三点：
# 1、闭包函数必须有内嵌函数
# 2、内嵌函数需要引用该嵌套函数上一级namespace中的变量
# 3、闭包函数必须返回内嵌函数

// PHP的版本
function line_func($a, $b)
{
    $func = function($x) use ($a, $b) // 使用use来使用闭包变量
    {
        return $a * $x + $b;
    };
 
    return $func;
}
 
$line1 = line_func(1, 1);
$line2 = line_func(4, 5);
 
echo $line1(5), $line2(5);

tuple

tuple和list非常类似，但是tuple一旦初始化就不能修改。

logging模块学习

默认情况下，logging将日志打印到屏幕，日志级别为WARNING；

日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，当然也可以自己定义日志级别。

import logging
 
logging.info("foo is running")
logging.warning("foo is running")
logging.error("foo is running")
logging.critical("foo is running")
 
# WARNING:root:foo is running
# ERROR:root:foo is running
# CRITICAL:root:foo is running

xrange与range的区别

1. xrange用法与range完全相同，所不同的是生成的不是一个list对象，而是一个生成器。
2. 在Python3中， range相当于Python2中的xrange；而Python2中的range可以用list(range())来实现。
3. python3没有xrange，如果python2迁移到3、或者要同时在2/3跑程序，就要注意。
4. xrange不支持切片，这个用起来可能不是很爽。 个人觉得，如果数据量不大，还是用range，如果数据大并且是版本2才考虑用xrange。

print([1, 2, 3])
print(type([1, 2, 3]))
 
print(range(1, 4))
print(type(range(1, 4)))

__init__.py

Python 要求每一个「包」目录下，都必须有一个名为 __init__.py 的文件。从这个文件的名字上看，首先它有 __ 作为前后缀，我们就知道，这个文件肯定是 Python 内部用来做某种识别用的；其次，它有 init，我们知道它一定和初始化有关；最后，它有 .py 作为后缀名，因此它也是一个 Python 模块，可以完成一些特定的工作。

之前简单地介绍了 __init__.py 这个特殊的文件，但未展开。这里我们展开详说。

首先的问题是，为什么要设计 __init__.py，而不是自动地把任何一个目录都当成是 Python 包？这主要是为了防止重名造成的问题。比如，很可能用户在目录下新建了一个子目录，名为 collections；但 Python 有内建的同名模块。若不加任何限制地，将子目录当做是 Python 包，那么，import collections 就会引入这个 Python 包。而这样的行为，可能不是用户预期的。从这个意义上说，设计 __init__.py 是一种保护措施。

接下来的问题是，__init__.py 具体还有什么用？

首先来说，__init__.py 可以执行一些初始化的操作。这是因为，__init__.py 作为模块文件，会在相应的 Python 包被引入时首先引入。这就是说，import picture 相当于是 import picture.__init__。因此，__init__.py 中可以保留一些初始化的代码——比如引入依赖的其他 Python 模块。

其次，细心的你可能发现，上一小节中，我们没有介绍对 Python 包的 from picture import * 的用法。这是因为，从一个包中导入所有内容，这一行为是不明确的；必须要由包的作者指定。我们可以在 __init__.py 中定义名为 __all__ 的 Python 列表。这样一来，就能使用 from picture import * 了。

彻底理解Python中的yield

1. 通常的for...in...循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。它可以是mylist = [1, 2, 3]，也可以是mylist = [x*x for x in range(3)]。它的缺陷是所有数据都在内存中，如果有海量数据的话将会非常耗内存。
2. 生成器是可以迭代的，但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (x*x for x in range(3))，注意这里用到了()，它就不是数组，而上面的例子是[]。
3. 我理解的生成器(generator)能够迭代的关键是它有一个next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。可以用上面的mygenerator测试。
4. 带有 yield 的函数不再是一个普通函数，而是一个生成器generator，可用于迭代，工作原理同上。
5. yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。
6. 简要理解：yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。
7. 带有yield的函数不仅仅只用于for循环中，而且可用于某个函数的参数，只要这个函数的参数允许迭代参数。比如array.extend函数，它的原型是array.extend(iterable)。
8. send(msg)与next()的区别在于send可以传递参数给yield表达式，这时传递的参数会作为yield表达式的值，而yield的参数是返回给调用者的值。——换句话说，就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值，a = yield 5，第一次迭代到这里会返回5，a 还没有赋值。第二次迭代时，使用.send(10)，那么，就是强行修改yield 5表达式的值为10，本来是5的，那么a=10
9. send(msg)与next()都有返回值，它们的返回值是当前迭代遇到yield时，yield后面表达式的值，其实就是当前迭代中yield后面的参数。
10. 第一次调用时必须先next()或send(None)，否则会报错，send后之所以为None是因为这时候没有上一个yield(根据第8条)。可以认为，next()等同于send(None)。

pass语句

pass 不做任何事情，一般用做占位语句。

在 Python 中有时候会看到一个 def 函数:

def sample(n_samples):
    pass

该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

foo = [x for x in bar if x.occupants > 1]

Let's start with an example, say we have 10 numbers, and we want a subset of those that are greater than, say, 5.

>>> numbers = [12, 34, 1, 4, 4, 67, 37, 9, 0, 81]

For the above task, the below approaches below are totally identical to one another, and go from most verbose to concise, readable and pythonic:

numbers = [12, 34, 1, 4, 4, 67, 37, 9, 0, 81]
 
# 方案一
result = []
for index in range(len(numbers)):
    if numbers[index] > 5:
        result.append(numbers[index])
print(result)
 
# 方案二
result = []
for number in numbers:
    if number > 5:
        result.append(number)
print(result)
 
# 方案三
result = [number for number in numbers if number > 5]
print(result)

使用dict和set

dic

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

和list比较，dict有以下几个特点：

• 查找和插入的速度极快，不会随着key的增加而增加；
• 需要占用大量的内存，内存浪费多。

如果key不存在，dict就会报错：

>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> 'Thomas' in d
False

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
 
-1

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

Python lambda表达式

在学习python的过程中，lambda的语法时常会使人感到困惑，lambda是什么，为什么要使用lambda，是不是必须使用lambda？

可以这样认为,lambda作为一个表达式，定义了一个匿名函数，代码更为简洁。

我们发现，lambda的使用大量简化了代码，使代码简练清晰。但是值得注意的是，这会在一定程度上降低代码的可读性。如果不是非常熟悉python的人或许会对此感到不可理解。

1. lambda 定义了一个匿名函数
2. lambda 并不会带来程序运行效率的提高，只会使代码更简洁。
3. 如果可以使用for...in...if来完成的，坚决不用lambda。
4. 如果使用lambda，lambda内不要包含循环，如果有，我宁愿定义函数来完成，使代码获得可重用性和更好的可读性。

总结：lambda 是为了减少单行函数的定义而存在的。

Python中单引号、双引号和三引号的区别

先说1双引号与3个双引号的区别，双引号所表示的字符串通常要写成一行如：

s1 = "hello,world"

如果要写成多行，那么就要使用\ (“连行符”)吧，如

s2 = "hello,\
world"

s2与s1是一样的。如果你用3个双引号的话，就可以直接写了，如下：

s3 = """hello,
world,
hahaha."""

那么s3实际上就是"hello,\nworld,\nhahaha.", 注意“\n”，所以，如果你的字符串里\n很多，你又不想在字符串中用\n的话，那么就可以使用3个双引号。而且使用3个双引号还可以在字符串中增加注释 ，如下：

s3 = """hello,  #hoho, this is hello, 在3个双引号的字符串内可以有注释哦
world,          #hoho, this is world
hahaha."""

这就是3个双引号和1个双引号表示字符串的区别了，3个双引号与1个单引号的区别也是和这个一样的，实际上python支持单引号是有原因的，下面我来比较1个单引号和1个双引号的区别。

当我用单引号来表示一个字符串时，如果要表示Let's go 这个字符串，必须这样：

s4 = 'Let\'s go'

注意没有，字符串中有一个'，而字符串又是用'来表示，所以这个时候就要使用转义符 \ （\，转义符应该知道吧）, 如果你的字符串中有一大堆的转义符，看起来肯定不舒服，python也很好的解决了这个问题，如下：

s5 = "Let's go"

这时，我们看，python知道你是用 " 来表示字符串，所以python就把字符串中的那个单引号 ' , 当成普通的字符处理了，是不是很简单。对于双引号，也是一样的，下面举个例子

s6 = 'I realy like "python"!'

这就是单引号和双引号都可以表示字符串的原因了。

Python项目报错：ascii codec can't decode byte ……

1. 问题描述：一个在Django框架下使用Python编写的定时更新项目，在Windows系统下测试无误，在Linux系统下测试，报如下错误：ascii codec can't decode byte 0xe8 in position 0:ordinal not in range(128)
2. 原因分析：字符问题。在Windows系统转Linux系统时，字符问题很容易出现。
3. 解决办法：在出现问题的页加上如下三行即可：

import sys
reload(sys)
sys.setdefaultencoding('utf-8')

卸载distutils安装的包

pip安装：Cannot uninstall . It is a distutils installed project and thus we cannot accurately....解决办法

对于这种问题如何解决呢？

直接全局搜索对应文件，具体包括 "package name" 文件夹 和 "package name".egg-info ，找到后直接删除即可。

Django调试方法

web程序调试起来和桌面程序有着很大的差别，对于Django程序来说调试更是个问题，虽然现在有第三方的调试工具robhudson-django-debug-toolbar，但使用起来并不是很方便，而且很多人习惯于通过print来调试，这样方便快捷。

Django的error page功能很强大，能提供详细的traceback，包括局部变量的值，以及一个纯文本的异常信息。拥有同phpinfo()一样的作用，可以展示当前应用的相关设置，包括请求中的 GET, POST and COOKIE 数据以及HTTP环境中的所有重要META fields。

可以通过

assert False
assert False, request.GET

来触发Django的错误页面，进而进行调试工作。

Mako模板

http://docs.makotemplates.org/en/latest/

% if id in ('beedata', 'vocdata', 'tqosdata', 'outlinedata', 'onlinedata', 'itemdata') :
    disabled checked 
% endif

马尔科夫性质的具体内容是什么？

随机过程中某事件的发生只取决与它的上一事件、是「无记忆」过程。