属于标准库的一部分，类似于JUnit。下面是一个基本的例子：

# 编写测试用例模块
import util        # 被测试模块
import unittest
class TestUtilFunc(unittest.TestCase):
    def setUp(self): pass     # 每个测试函数运行之前
    def tearDown(self): pass  # 每个测试函数运行之后
    def test_indexOf(self):    # 测试用例
        self.assertEqual(0,util.stringutils.indexOf('123','1'))

# 运行单元测试
if __name__ == '__main__'
    unittest.main()

从这个例子可以看到：

1. 测试用例以类的形式进行分组，从

   unittest.TestCase

   继承
2. 测试方法以

   test_

   开头
3. unittest支持类似于JUnit的准备/清理机制
4. 单元测试的入口点均为unittest.main()
5. unittest.TestCase提供了一系列断言方法

可以在测试类、测试方法上添加装饰器，以便在特定条件下，跳过某些测试：

# 无条件跳过
@unittest.skip("reason")

# 条件跳过
@unittest.skipIf( True, "reason" )
@unittest.skipUnless(sys.platform.startswith("win"), "reason") 

你可以运行测试模块、测试类，甚至测试方法：

# 测试两个模块
python -m unittest test_module1 test_module2
# 测试一个类
python -m unittest test_module.TestClass
# 测试一个方法
python -m unittest test_module.TestClass.test_method

# 也可以指定模块的路径
python -m unittest tests/test_something.py

如果要自动搜索测试用例，执行： 

cd project_directory
python -m unittest discover

要支持自动搜索，测试用例必须编写为模块、或者包，且可以从项目根目录导入。 

默认情况下，仅仅需要命名为

test*.py

-p

pytest是第三方框架，和unittest的主要区别是：

1. 测试模块的文件名必须以

   test_

   开头或

   _test

   结尾
2. 测试类名必须以

   Test

   开头
3. 支持模块、类、函数级别的准备/清理方法，unittest仅支持类级别
4. 不提供断言方法，直接使用assert表达式
5. 支持失败用例的重跑

pip install -U pytest

# 被测试者
def func(x):
    return x + 1


def test_answer():
    # 断言
    assert func(3) == 5

运行

pytest

可以将多个测试用例组合为类：

class TestClass:
    def test_one(self):
        x = "this"
        assert "h" in x

    def test_two(self):
        x = "hello"
        assert hasattr(x, "check")

运行

pytest -q test_class.py

import pytest


def f():
    raise SystemExit(1)


def test_mytest():
    # 断言f()调用会产生SystemExit异常
    with pytest.raises(SystemExit):
        f()

测试方法中的参数tmpdir提示系统，自动为此测试创建一个独特的临时目录。

def test_needsfiles(tmpdir):
    print(tmpdir)
    assert 0

pytest支持不同级别的setup/teardown方法。

整个模块仅仅调用一次：

def setup_module(module):
    """ setup any state specific to the execution of the given module."""


def teardown_module(module):
    """ teardown any state that was previously setup with a setup_module
    method.
    """

对于类中的所有测试，调用一次：

@classmethod
def setup_class(cls):
    """ setup any state specific to the execution of the given class (which
    usually contains tests).
    """


@classmethod
def teardown_class(cls):
    """ teardown any state that was previously setup with a call to
    setup_class.
    """

对于每个测试方法，都会调用：

def setup_method(self, method):
    """ setup any state tied to the execution of the given method in a
    class.  setup_method is invoked for every test method of a class.
    """


def teardown_method(self, method):
    """ teardown any state that was previously setup with a setup_method
    call.
    """ 

pytest支持fixtures，所谓fixtures是一系列让测试可靠、可重复执行的机制。比起经典的xUnit风格的setup/teardown函数，pytest fixtures具有以下优势：

1. 每个fixture具有精确的名称，通过在测试函数、模块、类，或者整个项目中声明这些名称即可自动激活
2. fixture使用模块化设计，每个fixture名称会触发一个fixture函数，此函数本身亦可使用其它fixture
3. fixture可以在简单的单元测试场景，到复杂的功能测试中使用
4. 你可以根据配置、组件选项来参数化fixture和测试
5. 可以跨越函数、类、模块、整个测试会话重用fixture

# key是由 / 分隔的字符串，通常第一部分是你的插件/应用的名称，避免和其它缓存用户冲突
cache.get(key, default)
cache.set(key, value) 

capsys.readouterr()

(out ,err)

Fixture由函数创建，任何函数加上

@pytest.fixture

@pytest.fixture
def smtp_connection():
    import smtplib
    return smtplib.SMTP("smtp.gmail.com", 587, timeout=5) 

你可以指定Fixture的共享范围：

# 可选值 function, class, module, package, session
@pytest.fixture(scope="module") 

直接将Fixture函数名作为参数，声明在被测试用例的参数列表中，即可使用Fixture： 

def test_ehlo(smtp_connection):
    response, msg = smtp_connection.ehlo()
    assert response == 250 

在你的Fixture函数中使用yield语句，即可自动在Fixture超过作用域范围后自动清理： 

@pytest.fixture(scope="module")
def smtp_connection():
    smtp_connection = smtplib.SMTP("smtp.gmail.com", 587, timeout=5)
    # 提供
    yield smtp_connection
    print("teardown smtp")
    # 清理
    smtp_connection.close()


# 等价形式
@pytest.fixture(scope="module")
def smtp_connection():
    with smtplib.SMTP("smtp.gmail.com", 587, timeout=5) as smtp_connection:
        yield smtp_connection

使用参数化fixture，可以让所有依赖于此fixture的测试运行多次：

import pytest
import smtplib

@pytest.fixture(scope="module", params=["smtp.gmail.com", "mail.python.org"])
def smtp_connection(request):
    smtp_connection = smtplib.SMTP(request.param, 587, timeout=5)
    yield smtp_connection
    print("finalizing {}".format(smtp_connection))
    smtp_connection.close()

使用smtp_connection的用例会执行两次，一次连接到stmp服务器smtp.gmail.com，另一次连接到mail.python.org。

为Fixture函数传入

request

import pytest
import smtplib


@pytest.fixture(scope="module")
def smtp_connection(request):
    # 读取被测试模块的smtpserver属性
    server = getattr(request.module, "smtpserver", "smtp.gmail.com")
    smtp_connection = smtplib.SMTP(server, 587, timeout=5)
    yield smtp_connection
    print("finalizing {} ({})".format(smtp_connection, server))
    smtp_connection.close()

被测试模块可以提供stmpserver变量供Fixture读取：

smtpserver = "mail.python.org"  # 被Fixture读取

def test_showhelo(smtp_connection):
    assert 0, smtp_connection.helo()

如果在单个测试中，需要多次得到全新的fixture，可以让Fixture函数返回一个函数而不是值： 

@pytest.fixture
def make_customer_record():
    def _make_customer_record(name):
        return {"name": name, "orders": []}
    # 此Fixture函数返回一个工厂函数
    return _make_customer_record


def test_customer_records(make_customer_record):
                 # 可以多次生成fixture
    customer_1 = make_customer_record("Lisa")
    customer_2 = make_customer_record("Mike")
    customer_3 = make_customer_record("Meredith")

在类级别启用fixture：

@pytest.fixture()
def cleandir():
    newpath = tempfile.mkdtemp()
    os.chdir(newpath)


# 所有测试都会在一个临时目录下执行
@pytest.mark.usefixtures("cleandir")
class TestDirectoryInit:

支持同时使用多个fixture：

@pytest.mark.usefixtures("cleandir", "anotherfixture")

The post Python单元测试 appeared first on 绿色记忆.

Graphite是一个开源项目，可以作为时间序列数据库（TSDB）使用，当你需要存储随着时间变化的数值时，应当考虑使用时间序列数据库。

除了数据的存储、查询外，Graphite还提供数据可视化（UI层）功能，它可以很好的在廉价的硬件上运行。你可以使用Graphite来监控网站、应用程序、网络服务器等的性能数据（Metrics），轻松实现基于时间维的分析。

Graphite本身不负责性能数据的采集，但是它提供了简单易用的接口，公共这些接口你可以把基于数字的性能数据存储到Graphite中。

Graphite由三个组件构成：

1. Carbon：一个基于Twisted（Python事件驱动网络框架）的守护程序，负责监听外部的时间序列数据
2. Whisper：一个简单的存储时间序列数据的数据库，设计上和RRDtool类似 
3. Graphite-Web：一个基于Django（Python Web框架）的Web应用，使用Cairo（一个2D图形库）来渲染性能数据的图表，使用ExtJS作为基础UI框架

下面是Graphite的架构图：

一旦你把数据送给Carbon，它就立刻可以在Webapp的图表中显示，因为数据在被写入文件系统之前，会驻留在缓存中。

除了使用Graphite Webapp，你也可以通过URL API，将图表嵌入到自己的应用程序中去。如何使用Graphite

使用Graphite来监控你的性能数据，你需要完成以下工作：

1. 理解Graphite组件的职责和相互关系
2. 安装Graphite及其依赖
3. 基础的配置，让Graphite能运行起来
4. 设计Metrics路径
5. 配置Metrics的驻留规则、聚合规则等
6. 向Graphite发送Metrics
7. 从Graphite获取Metrics并展示

Metrics路径由点号分隔的字符串构成，类似于Python的包名称。路径是Metrics的标识。

你应当仔细的设计此路径的命名空间，以反映出所有Metrics之间的层次关系。例如servers.zircon.cpu，这个三级路径设计中，第一级表示设备类别，第二级表示设备名称，第三级表示监测点类型。

Carbon由一系列的守护进程组成，这些守护进程共同组成Graphite的存储后端。在最小化的安装下，只有一个守护进程carbon-cache.py。根据需要你可以启用carbon-relay.py、carbon-aggregator.py以便实现Metrics分发、定制聚合规则。各Carbon守护进程简介如下：

Whisper是一个固定大小（fixed-size）的数据库，其设计和用途与RRD（round-robin-database）类似。它能提供快速、可靠的数值数据的存储。

Whisper能够对最近的数据进行高分辨率的存储，而对久远的历史数据，自动降低其存储精度（减少样本数量）。

在大多数场景下，Whisper有足够好的性能。它比RRDtool慢，主要原因是Whisper基于Python编写，这个性能差异很小，通常不需要考虑。

Whisper数据库以文件方式存放在磁盘上，扩展名.wsp。Carbon会为每个Metrics创建一个.wsp文件，路径的最后一节作为文件的basename，路径的其它部分形成目录层次。

在Whisper中存储的每一个数值，称为数据点（Data Points）。

在磁盘上，数据点以大端、双精度浮点数存储。每个数据还附带一个时间戳信息，时间戳为1970-01-01到数据采集时间的秒数。

一个Whisper数据库文件可以包含一个或者多个“归档”，归档是数据文件中的逻辑段。

每个归档具有不同的数据分辨率（一定时间段内，数据点数量越多，则分辨率越高）。归档以最高分辨率（最小驻留时间） —— 最低分辨率（最长驻留时间）的顺序，在数据库文件中顺序排列。

为了精确的从高分辨率向低分辨率的归档聚合，高分辨率归档和它之后的低分辨率归档，其分辨率应当具有整除关系。例如，第一个归档分辨率为60秒/数据点，那么第二个归档可以是300秒/数据点，第三个归档可以是3600秒/数据点。

一个数据库的总计驻留时间（存放的数据点跨越的时间），由最长驻留时间的（最后一个）归档确定。因为之前的那些归档，时间区间都是它的子区间。

把数据点转移到低分辨率归档时，面临着如何把多个数据点转变为单个数据点的问题。Whisper支持average、sum、last、max、min等聚合函数。

注意，这里的聚合和Carbon提供的前置聚合不是一回事。

当Whisper向一个多归档数据写入Metrics时，数据点将被同时写入到所有的归档中。这意味着聚合动作随时可能发生。

当从Whisper中获取数据时，第一个能完整覆盖所需区间的归档被使用。

Whisper的磁盘利用效率不高，因为：

1. 每个数据点要附加一个时间戳信息
2. 由于归档的时间区间有重叠，因此数据存在冗余
3. 归档中的时间槽位（time-slots）总是占据着磁盘空间，不管有没有值存储在其中

这些特征是故意的，主要出于性能方面的考虑。

1. RRD不能去填充以前的时间槽位。这意味着每一条数据都必须是更新的，不会“补录”
2. RRD不能很好的支持不规则的数据更新。如果RRD接收到一条数据，但是后续数据没有到来，则前一条数据可能丢失

git clone https://github.com/graphite-project/graphite-web.git
graphite-web/check-dependencies.py
# 根据输出的提示来判断缺少哪些依赖，然后安装

yum -y install python-devel     # Carbon 依赖于 Python Development Headers

yum install pycairo             # Cairo库的Python绑定

pip install django              # Web框架
pip install django-tagging

pip install pytz

yum install fontconfig

yum install -y memcached        # 可选，缓存支持
pip install python-memcached    
                                # 可选，RDDTool
yum install cairo-devel libxml2-devel pango-devel pango libpng-devel freetype freetype-devel libart_lgpl-devel rrdtool-devel

pip install python-rrdtool      # 可选，RRD支持

pip install whitenoise          # 用于Web静态文件处理

yum install pyOpenSSL           # OpenSSL的Python绑定
pip install service_identity    # SSL相关

pip install https://github.com/graphite-project/ceres/tarball/master
pip install whisper
pip install carbon
pip install graphite-web

sudo groupadd graphite
sudo usermod -a -G graphite root
sudo usermod -a -G graphite apache
sudo chgrp -R graphite /opt/graphite/storage
sudo chmod -R 770 /opt/graphite/storage

Whisper被安装到Python全局site-packages目录，另外两个Graphite组件安装到

/opt/graphite

$GRAPHITE_ROOT

$STORAGE_DIR

你需要让Graphite-web的底层框架Django执行数据库的初始化。此数据库被用来存放用户设置、仪表盘，以及支持事件功能。

默认情况下，Graphite-web使用位于$STORAGE_DIR/graphite.db的SQLite数据库。如果要运行多个Graphite-web实例，则必须使用MySQL等数据库以便多个实例可以共享数据。 

执行下面的命令初始化SQLite数据库：

PYTHONPATH=/opt/graphite/webapp django-admin.py migrate --settings=graphite.settings --run-syncdb
# 完毕后 $STORAGE_DIR/graphite.db自动创建

Django应用需要在Web服务器中运行，Web服务器需要对SQLite数据文件有读写权限。假设你使用Apache2，运行Apache2的用户为apache，则需要执行：

sudo chgrp graphite /opt/graphite/storage/graphite.db

Graphite不建议修改settings.py，所有定制化的配置，都应该在此文件中进行。常用的设置项如下表：

rrdtool flushcached

DEFAULT_CACHE_POLICY = [
    (0, 60), # 默认缓存60秒
    (7200, 120) # >= 2小时以上时间范围的查询，缓存2分钟
] 

# 如果报Unknown command: 'collectstatic' 说明INSTALLED_APPS中缺少
# django.contrib.staticfiles	
PYTHONPATH=/opt/graphite/webapp django-admin.py collectstatic 
    --noinput --settings=graphite.settings

Alias /static/ "/opt/graphite/static"

我们的配置如下：

# 如果不设置，会导致报错：AttributeError: 'Settings' object has no attribute 'URL_PREFIX
URL_PREFIX = '/'

多种Web服务器可以用于运行基于Django的Web应用，这里我们选择Apache2。在CentOS下安装Apache2：

yum install httpd

要让Apache2能够运行Python Web应用，需要安装模块mod_wsgi。参考Django学习笔记完成mod_wsgi的构建与安装。

在/opt/graphite/examples/目录下，example-graphite-vhost.conf可以作为Apache虚拟主机的模板，复制该文件到/etc/httpd/conf.d/目录下，然后修改：

<IfModule !wsgi_module.c>
    LoadModule wsgi_module modules/mod_wsgi.so
</IfModule>
WSGISocketPrefix run/wsgi
<VirtualHost *:7767>
        ServerName xcentos7.local
        DocumentRoot "/opt/graphite/webapp"
        ErrorLog /opt/graphite/storage/log/webapp/error.log
        CustomLog /opt/graphite/storage/log/webapp/access.log common
        WSGIDaemonProcess graphite processes=5 threads=5 display-name='%{GROUP}' inactivity-timeout=120
        WSGIProcessGroup graphite
        WSGIApplicationGroup %{GLOBAL}
        WSGIImportScript /opt/graphite/conf/graphite.wsgi process-group=graphite application-group=%{GLOBAL}
        WSGIScriptAlias / /opt/graphite/conf/graphite.wsgi
        Alias /content/ /opt/graphite/webapp/content/
        <Directory /opt/graphite/webapp/content/>
            Require all granted
        </Directory>
        <Directory /opt/graphite/conf/>
            Require all granted
        </Directory>
</VirtualHost>

如果配置没有问题，启动Web服务器后访问：

http://GRAPHITE_HOST:GRAPHITE_PORT/render

所有Carbon守护进程可以基于多种通信协议，监听时间序列数据，并且对数据进行不同的处理。

Carbon的配置文件位于/opt/graphite/conf/目录，默认情况下没有预置的配置文件，但是Graphite提供了若干配置文件样例。你可以复制这些配置文件并定制：

pushd /opt/graphite/conf
cp carbon.conf.example carbon.conf
cp storage-schemas.conf.example storage-schemas.conf

这是主配置文件，为每个Carbon守护进程定义配置项。该配置文件按段区分不同守护进程的配置：

这个配置文件用于定义Metrics的驻留率（ retention rates）——即Metrics的数据点（datapoints）以什么频率保存，保存多长时间。关于该配置文件，需要注意：

1. 该配置文件可以由多个段（Section）组成。每个段定义一个存储规则
2. 这些规则按照从上到下的顺序对Metrics进行匹配，第一个匹配的规则对Metrics生效
3. 匹配Metrics时，采用的是正则表达式
4. 对于一个Metrics，其存储规则在接收到第一个数据时固化。因而修改此配置文件不会影响到既有的.wsp文件。要应用到既有的.wsp可以调用whisper-resize.py

每个规则由三个部分组成：

# 段名称（规则名称），主要是文档用途。在匹配段的Metrics被创建时，日志creates.log中会显示此名称
[rulename]
# 匹配Metrics路径（Metrics的全限定名称，点号分隔）的正则式
# 举例：^servers\.www.*\.workers\.busyWorkers$
pattern=regex
# 驻留率表达式，数据点间隔:存留天数，时间后缀s,m,h,d,y分别表示秒、分、小时、天、年
# 举例：10s:14d 表示每个数据点表示10秒（相当于每10秒采集数据一次），并且存储14天的数据
retentions=retention rate

注意，你可以指定多重驻留率表达式（retention rate），逗号分隔每个表达式。一般从最高精度:最短存留时间开始指定，直到最低精度:最长存留时间。例如：

15s:7d,1m:21d,15m:5y

设置多重驻留率表达式，可以在保存足够长时间的历史数据的前提下，尽量减少磁盘I/O和消耗的存储空间。当跨越驻留表达式的时间区间（上例中7天，21天）后，whisper会自动降低采样率（downsamples），默认算法是取平均值，可以通过storage-aggregation.conf定制聚合方式

这个配置文件定义如何在降低采样率（转换为低精度存储时） 如何对数据进行聚合。该文件的格式与storage-schemas.conf类似：

[rulename]
pattern = rexexp
# 0-1之间的浮点数，默认0.5。聚合区间内的值，至少多少比例为非空，聚合后的值才是非空
xFilesFactor = 0.5
# 数据聚合方式，默认average
aggregationMethod = average | sum | min | max | last

同样的，修改此文件不会影响已经生成的.wsp文件， 要应用到既有的.wsp文件，可以调用whisper-set-aggregation-method.py。

这个配置文件指定中继规则——即需要把何种Metrics转发给何种后端。中继由Carbon的中继进程负责执行。该文件格式如下：

[rulename]
pattern = regex
servers = ip:port,ip:port,...

该配置文件定义聚合出来的Metrics——由几个Metrics聚合而成的新的Metrics。聚合由Carbon的聚合进程负责执行。

注意：这里的聚合storage-aggregation.conf提及的聚合不同。后者用于单一Metrics的降低采样，而前者用于生成新的Metrics。

与其它配置文件不同，该文件一旦更改，立即生效。

该文件的格式如下：

# 捕获任何匹配input_pattern的Metrics，使用method聚合成新的Metrics：output_template
# frequency：每隔多久执行一次聚合
# method：可选sum/avg
output_template (frequency) = method input_pattern

举例，假设你的Metrics的命名规则是：

<env>.applications.<app>.<server>.<metric>

这是你可以配置如下聚合规则，来计算所有应用程序的请求的总数：

<env>.applications.<app>.all.requests (60) = sum <env>.applications.<app>.*.requests

在此规则下，下面的Metrics：

test.applications.pems.221.request
test.applications.pems.6.request
test.applications.pems.5.request
test.applications.pems.201.request

会每个60秒求和并生成 

test.applications.pems.all.request

该配置文件定义Metrics名称的改写规则。 与其它配置文件不同，该文件一旦更改，立即生效。该文件的格式如下：

[pre]
# pre段的规则，在接收到数据后立即执行改写
[post]
# post段的规则，在聚合完毕后执行改写
regex-pattern = replacement-text

 举例：

# \1表示第一个捕获，即[a-z0-9]+
^collectd\.([a-z0-9]+)\. = \1.system.
# collectd.prod.cpu-0.idle-time 会被改写为 prod.system.cpu-0.idle-item

Carbon提供黑白名单功能。白名单：仅仅接受其中列出的Metrics；黑名单：拒绝其中列出Metrics。

要启用黑白名单功能，需要修改carbon.conf，设置

USE_WHITELIST = True

如何启动Graphite Webapp依赖于其运行的Web服务软件，以Apache为例：

# CentOS 7
systemctl restart httpd

Carbon组件需要执行下面的命令来启动：

/opt/graphite/bin/carbon-cache.py start

SQLite是一个“文件数据库”，不需要启动。如果Graphite Webapp使用其它数据库，例如MySQL，则需要启动之。 

你可以通过多种方式向Graphite（的Carbon组件）发送Metrics数据点。主要的三种数据格式是：Plaintext、Pickle、AMQP 

这种方式非常简单，你可以用如下格式来发送一条Metrics数据点：

<metric path> <metric value> <metric timestamp>
# 举例：
servers.zircon.cpu 85 1470303923

出于测试目的，你可以直接通过命令向Carbon发送Metrics数据：

PORT=2003
SERVER=127.0.0.1
echo "servers.zircon.cpu 85 `date +%s`" | nc ${SERVER} ${PORT}

Pickle是Python下的对象串行化框架，Pickle协议即它的串行化格式协议。使用该协议，你可以一次发送多个Metrics，并且串行化后的数据比较紧凑，因此Pickle协议性能更好。

下面是构建Pickle报文的示例代码：

listOfMetricTuples = [
    (path, (timestamp, value)),
    ...
]
payload = pickle.dumps(listOfMetricTuples, protocol=2)
header = struct.pack("!L", len(payload))
message = header + payload
# 然后通过Socket把message发送出去即可

import pickle
import socket
import struct
import sys
import time
from time import sleep

import psutil


def get_cpu_load():
    load = psutil.cpu_percent()
    print load
    return load


if __name__ == '__main__':
    CARBON_HOST = '172.16.87.132'
    CARBON_PORT = 2004
    s = socket.socket()
    try:
        s.connect((CARBON_HOST, CARBON_PORT))
        while True:
            data = [
                ('servers.zircon.cpu', (time.time(), get_cpu_load()))
            ]
            pkg = pickle.dumps(data, 1)
            s.sendall(struct.pack('!L', len(pkg)))
            s.sendall(pkg)
            sleep(5)
    except socket.error:
        raise SystemExit("Failed to connect to %(host)s:%(port)" % {'host': CARBON_HOST, 'port': CARBON_PORT})
    except KeyboardInterrupt:
        sys.stderr.write("\nExiting on CTRL-C\n")
        sys.exit(0) 

要从Graphite获取数据用于展示，可以使用Graphite Webapp暴露的Render URL API（RUA）。你可以通过

http://GRAPHITE_HOST:GRAPHITE_PORT/render

访问此API。要向RUA传递参数，可以使用URL请求参数方式：

&name=value

下面列出几个RUA的URL示例：

# Zircon的CPU负载图，获取800x600的图片
http://graphite/render?target=servers.zircon.cpu&height=800&width=600
# 最近12小时，所有服务器的CPU负载平均值
http://graphite/render?target=averageSeries(servers.*.load)&from=-12hours
# 获取原始数据而不是图片，JSON格式
http://graphite/render?target=servers.zircon.cpu&format=json

该参数用来指定从何处获取数据，你可以指定：

1. 单个Metrics路径
2. 带有通配符的的Metrics路径，匹配多个Metrics
3. 函数调用，针对作为入参的Metrics进行各种转换、合并操作

你可以在路径中使用三种风格的通配符：

1. *

    可以匹配0-N个字符，例如

   servers.dev-*.cpu

    ，可以匹配所有开发服务器的CPU负载Metrics。

2. [...]

    可以匹配列表中枚举的单个字符，例如

   servers.dev-[a-z0-9].cpu

    ，可以匹配dev-0、dev-1等服务器的CPU负载Metrics。

3. {...}

    可以匹配列表中枚举的单个字符串，例如

   servers.{dev-0,dev-1}.cpu

    ，匹配dev-0、dev-2的CPU负载Metrics。

注意：所有通配符都不能跨越点号。 

你可以指定target为template函数调用，从而在Metrics路径中使用变量，例如：

# $varname 用来声明变量占位符
# template[varname]参数用来传递变量值
&target=template(servers.$servername.cpu)&template[servername]=zircon

# 可以使用数字代替变量名
&target=template(servers.$1.cpu)&template[1]=zircon

# template可以内嵌其它函数
&target=template(constantLine($number))&template[number]=123

可用的函数较多，这里不一一列举说明，参见官方文档。

这两个可选参数用来指定相对或者绝对的时间区间（time period）。from表示区间起点，如果忽略，默认值是24小时之前；until表示区间终点，如果或略，默认值是当前时间点。

如果要使用相对时间，需要加上

-

你可以指定

HH:MM_YYYYMMDD

YYYYMMDD

 MM/DD/YY

该参数用来指定要获取的数据的格式。 支持以下取值：

<target name>,<start timestamp>,<end timestamp>,<series step>|[data]*

entries,1311836008,1311836013,1|1.0,2.0,3.0,5.0,6.0

entries,2011-07-28 01:53:28,1.0
entries,2011-07-28 01:53:29,2.0
entries,2011-07-28 01:53:30,3.0
entries,2011-07-28 01:53:31,5.0
entries,2011-07-28 01:53:32,6.0

[{
  "target": "entries",
  "datapoints": [
    [1.0, 1311836008],
    [2.0, 1311836009],
    [3.0, 1311836010],
    [5.0, 1311836011],
    [6.0, 1311836012]
  ]
}]

{
  "labels" : [
    "Time",
    "entries"
  ],
  "data" : [
    [1468791890000, 0.0],
    [1468791900000, 0.0]
  ]
}

[{
  "target": "entries",
  "datapoints": [{
    "y": 0.0,
    "x": 1468791890
  }, {
    "y": 0.0,
    "x": 1468791900
  }]
}]

[
  {
    'name' : 'summarize(test.data, "30min", "sum")',
    'start': 1335398400,
    'end'  : 1335425400,
    'step' : 1800,
    'values' : [None, None, 1.0, None],
  }
]

你可以指定多个参数，来控制生成的图形的样式：

# 颜色名称
&bgcolor=blue
# HEX代码
&bgcolor=2222FF
# HEX代码，包含透明度
&bgcolor=5522FF60

上一章内容我们讨论了如何获取Graphite数据。通过Render URL API，我们不但可以获得文本数据，还可以直接获得渲染好的图片。这意味着通过Render URL API本身就可以实现Metrics的渲染，你只需要把生成的图片嵌入到自己的应用程序中即可。

Graphite Webapp本身提供了基于ExtJS的一个管理界面，你可以通过

http://GRAPHITE_HOST:GRAPHITE_PORT/admin

Graphite生成的Metrics曲线的图片，不是非常美观，而静态图片也缺乏交互性。因此，实际项目中常常结合使用第三方基于JavaScript的Charts库来做展示，例如：

1. Grafana：UI比较绚丽，支持设计仪表盘、时间区间联动。参见：使用Grafana展示时间序列数据
2. Graphene：一个较为简单的，基于D3.js和Backbone.js的Graphite仪表盘工具

除了简单的，基于Key/Value的Metrics数据，Graphite还可以存储、展示随机出现的数据——事件。

事件不适合存储在Whisper中，因此它被存储在Graphite的Webapp的数据库中（默认使用SQLite）。

通过向

http://GRAPHITE_HOST:GRAPHITE_PORT/events/

{ 
    "what": "事件类型", 
    "tags": "标签",
    "data": "事件相关的数据" 
}

指定target为

event(*tags)

/render

[
   {
      "target" : "events(mytag)",
      "datapoints" : [
         [
            1,
            1388966651
         ],
         [
            3,
            1388966652
         ]
      ]
   }
]

你也可以通过

/render/events/get_data

[
   {
      "when" : 1392046352,
      "tags" : "mytag",
      "data" : "...",
      "id" : 2,
      "what" : "Event - deploy"
   }
] 

Django的request对象曾经有一个属性REQUEST，用来获得通过GET或者POST请求传递的请求参数，在1.9版本中此属性已经移除。

Graphite代码没有即时更新，存在不兼容的问题，修改一下即可：

def parseOptions(request):
   queryParams = request.GET # request.REQUEST已经被移除

还有很多其它views.py存在同样的问题，最好搜索一下一并修改。如果觉得麻烦可以安装兼容版本的Django：

pip install django==1.8.14

The post Graphite学习笔记 appeared first on 绿色记忆.

Shinken是一个开源的IT监控框架，基于Python编写。Shinken从2009年开始发布，起初是作为一个简单的监控解决方案，由于越来越多的模块的加入，至2014年它被重新定位为“框架”。

Shinken的优势包括：

1. 跨平台，它可以在Windows、Linux上部署和运行
2. 独立性，不依赖于其它监控解决方案
3. 可扩容，能够很好的支持不断扩张的、大规模的监控需求

守护程序角色

# 如果机器上没有安装pip
apt-get install python-pip python-pycurl
# 添加shiken专用户
adduser shinken
# 安装shinken
pip install shinken

使用这种方式，你可以方便的调试或者修改Shinken的源码：

adduser shinken
wget http://www.shinken-monitoring.org/pub/shinken-2.4.tar.gz
tar -xvzf shinken-2.4.tar.gz
cd shinken-2.4
python setup.py install

在生产环境下可以设置Shinken为自启动：

# RedHat / CentOS
chkconfig shinken on
# Debian / Ubuntu
update-rc.d shinken defaults

# 启动
service shinken start

你可以可以通过脚本启动：

./bin/launch_all.sh

开发环境下，如果你需要修改Shinken源码，需使用第二种安装方式。然后注释掉shinken.cfg中用户、组信息，以当前用户的身份启动Shinken：

./bin/shinken-scheduler -c /etc/shinken/daemons/schedulerd.ini -d
./bin/shinken-poller -c /etc/shinken/daemons/pollerd.ini -d
./bin/shinken-broker -c /etc/shinken/daemons/brokerd.ini -d
./bin/shinken-reactionner -c /etc/shinken/daemons/reactionnerd.ini -d
./bin/shinken-arbiter -c /etc/shinken/shinken.cfg -d
./bin/shinken-receiver -c /etc/shinken/daemons/receiverd.ini -d

安装后以及运行时，Shinken会使用下面的目录：

安装步骤参考Linux下基于源码的安装方式，不需要添加用户，解压可以手工进行。

Windows下所有目录都位于Shinken安装目录下，例如

/etc/shinken

Windows下%SHINKEN_HOME%\etc

每次修改配置后，你都应该在重启Shinken之前进行验证，因为配置存在问题会导致Shinken无法启动。

调用下面的命令执行验证：

/usr/bin/shinken-arbiter -v -c /etc/shinken/shinken.cfg 

如果配置存在错误，该命令会输出ERROR信息并指出问题所在位置。警告信息一般可以忽略。

# 启动
/etc/rc.d/init.d/shinken start
# 重启
/etc/rc.d/init.d/shinken restart
# 停止
/etc/rc.d/init.d/shinken stop

Shinken提供了一个同名的命令，可以用于在shinken.io上检索、安装，上传包（Pack，包含对象定义模板）或者模块（扩充Shinken功能的Python模块）。初次使用该命令，需要初始化：

# 首次使用shinken命令时执行
shinken --init

http://user:password@proxy-server:port

在安装完毕后，你就获得一个基本的Shinken配置，可以直接启动之。

/etc/shinken/daemons目录存放了*.ini文件，这些文件描述了在本机需要运行的守护程序。基本配置下Shinken单机运行，因而此目录下有5个文件（Arbiter的配置在主配置文件中）。分别定义Broker、Poller、Reactionner、Receiver、Scheduler这五个守护程序使用的端口、工作目录等重要信息。

需要注意的是，这些守护程序不一定要在单机上运行，你可以分散部署，只需要将它们作为对象引用到主配置文件中。

我们看一下配置文件的内容：

[daemon]

# 该程序启动后，立即修改工作目录为：
workdir = /var/run/shinken
logdir  = /var/log/shinken
# PID文件，有了它以后我们可以杀死该守护程序
pidfile=%(workdir)s/schedulerd.pid
# TCP监听端口，默认：
# scheduler: 7768
# poller: 7771
# reactionner: 7769
# broker: 7772
# arbiter: 7770
port=7768
# TCP监听地址
host=0.0.0.0
# 用于运行守护程序的用户，以及用户的组
user=shinken
group=shinken
# 如果设置为1，则你可以在root用户下运行此守护程序
idontcareaboutsecurity=0

# Set to 0 if you want to make this daemon NOT run
# 是否启用此守护程序，如果设置为0则不会运行
daemon_enabled=1


#-- SSL相关的配置 --
use_ssl=0
# WARNING : Use full paths for certs
#ca_cert=/etc/shinken/certs/ca.pem
#server_cert=/etc/shinken/certs/server.cert
#server_key=/etc/shinken/certs/server.key
hard_ssl_name_check=0
http_backend=auto
daemon_thread_pool_size=16

#-- 和该守护程序相关的本地日志配置 --
# Enabled by default to ease troubleshooting
use_local_log=1
local_log=%(logdir)s/schedulerd.log

# accepted log level values= DEBUG,INFO,WARNING,ERROR,CRITICAL
log_level=WARNING

# The path to the modules directory
modules_dir=/var/lib/shinken/modules

守护程序作为Shinken架构中的一种资源，必须在主配置文件中进行定义，才能被使用。 

通常，守护程序定义文件依据类型的不同，存放在不同目录中，并且每个文件对应一个守护程序。该文件使用类似于对象定义的语法，描述此守护程序的名称、如何连接、是否Standby（Spare）。下面是一个Scheduler定义的例子：

define scheduler {
    # 守护程序的名称
    scheduler_name      scheduler-master
    # 如何连接到此守护程序
    address             localhost 
    port                7768
    # 是否备用
    spare               0
    # 权重，某些Scheduler可以管理更多的主机
    weight              1
    # PING超时
    timeout             3
    # 数据发送超时
    data_timeout        120 
    # 如果PING超时多少次，认为此节点挂掉
    max_check_attempts  3
    # 每60秒PING此节点
    check_interval      60
    # 此守护程序加载的模块
    modules
    # 所属的领域，用于多数据中心等大型场景
    realm   All
    skip_initial_broks  0
    use_ssl	          0
    hard_ssl_name_check   0
}

注意，某些守护程序有特殊的配置选项，例如：

所有守护程序都可以使用模块。对于Broker来说模块是必须的，它依赖模块来完成实际的工作。基本配置没有预定义任何模块。

模块具有公共的选项：

每个模块具有自己的其它特殊配置项，需要查看模块的文档。

这里，我们定义一个模块，为基本配置增加日志记录的功能：

define module{
     module_name      simple-log
     module_type      simple-log
     path             /var/log/shinken/shinken.log
}

然后修改默认的Broker：

modules            simple-log

默认情况下simple-log模块是没有安装的，因此你会在/var/log/shinken/brokerd.log中发现警告信息：The module type simple-log for simple-log was not found in modules。执行下面的命令来安装模块：

# 到shinken.io搜索包
shinken search log
# 安装模块到/var/lib/shinken/modules/目录下
shinken install simple-log

重启Shinken，你会发现所有守护程序的日志被收集到 /var/log/shinken/shinken.log文件中了。

Shinken包含一系列内部模块，这些模块可以被多种守护程序加载，参与到数据获取中去。这些模块包括NPRE、SNMP等。

Shinken同时依赖于外部程序——检查插件（Check plugins）来监控更多种类的设备、应用、以及网络服务。

插件可以是编译好的可执行文件或者脚本，它们可以被调用，以便检查主机/服务的状态。Shinken使用插件的调用返回值来确定主机、服务的当前状态，以及被监控服务的性能数据。

插件作为监控逻辑组件和被监控主机/服务之间的抽象层。具有一定的接口规范，你可以编写自己的插件来监控任何东西。

Shinken插件有很多，支持的监控协议包括：WMI, SNMP, SSH, NRPE, TCP, UDP, ICMP, OPC, LDAP 等。

支持的监控对象包括各种OS、服务器和网络硬件、各种网络协议、各种性能数据、应用程序和数据库。

插件没有和Shinken运行时一同分发，需要单独获取。可以从：

1. Monitoring Plugins Project
2. Nagios Downloads Page
3. NagiosExchange.org

等地方获取插件。很多插件都提供帮助，你应该通过阅读帮助来了解如何使用之：

./check_http --help

Shinken的灵活性依赖于宏机制，你可以在命令中使用宏。通过宏你可以引用主机、服务等信息。

Shinken宏使用

$

$$

在执行命令前，Shinken会替换命令定义中所有宏为实际值，这些值由上下文决定。宏替换发生在任何命令上，包括主机/服务检查、通知、事件处理器等。

你可以使用

$ARGn$

# 定义命令
define command{
  command_name    check_ping
  # ARG1表示第一个入参
  command_line    /var/lib/shinken/libexec/check_ping -H $HOSTADDRESS$ -w $ARG1$ -c $ARG2$
}

调用命令时，以

!

define service{
  host_name    linux
  # 调用命令。给check_ping命令传递了两个参数，每个参数以叹号开始
  # 200.0,80%
  # 400.0,40%
  check_command    check_ping!200.0,80%!400.0,40%
}

如果调用命令需要传递叹号（!）本身，可以使用反斜杠转义。 

通常，当你使用主机/服务宏时，这些宏指向当前命令所针对的主机/服务。如果你想引用其它主机/服务时，可以使用按需宏机制。

按需宏和普通宏类似，只是它后缀一个用于识别主机/服务的标识符：

# 语法格式。把HOSTMACRONAME、SERVICEMACRONAME替换成真实的宏名称，:后面替换成真实的属性值即可
$HOSTMACRONAME:host_name$
$SERVICEMACRONAME:host_name:service_description$

# 举例
$HOSTDOWNTIME:myhost$   #myhosq的宕机时间
$SERVICESTATEID:server:database$  #server的database服务的状态ID
$CONTACTEMAIL:john$   #john的电子邮件

你还可以使用宏来获得一个组中的全部联系人、主机、服务的属性，使用特定分隔符分隔多个值：

#语法格式。HOSTMACRONAME等替换成真实的宏名称，*group_name替换为真实的组名称，delimiter替换为分隔符即可
$HOSTMACRONAME:hostgroup_name:delimiter$
$SERVICEMACRONAME:servicegroup_name:delimiter$
$CONTACTMACRONAME:contactgroup_name:delimiter$

你在主机、服务、联系人等的定义中声明的定制对象变量（custom object variables） 均可以作为宏使用：

#语法格式。
$_HOSTvarname$
$_SERVICEvarname$
$_CONTACTvarname$

#举例：
define host{
  ...
  # 定制变量必须以_开头
  _MACADDRESS    00:01:02:03:04:05
  ...
}
# 你可以使用 $_HOSTMACADDRESS$ 来访问MAC地址这一定制变量

大部分宏被导出为环境变量，脚本或者命令可以很容易的引用之。

$USERn$

参考官方文档。

以下时机Shinken的守护程序对主机执行检查：

1. 根据主机的check_interval、retry_interval选项周期性、定时检查。如果check_interval设置为0则不进行周期性检查
2. 当主机下某个服务的状态改变，按需检查
3. 作为主机可到达性逻辑的一部分，按需检查。这种情况下，主机是路由器等网络设备
4. 在进行预测性主机依赖性检查（predictive host dependency checks）时，按需进行

主机检查是并行执行的。

按需检查的性能可以通过已缓存的主机检查（Cached Host Checks）极大的提高。Shinken可以放弃检查执行，而使用最近的检查结果。

通过定义主机执行依赖（host execution dependencies），你可以基于其它一个或多个主机的状态，禁止某一主机的检查。

被检查的主机可以处于三种状态之一：UP、DOWN、UNREACHABLE。

主机检查由插件进行，插件的返回状态和主机状态映射如下表。注意，依据插件结果初步判定为DOWN时，需要依赖于父主机状态，来确定主机的真实（最终）状态：

Shinken可能发现主机状态在UP/DOWN/UNREACHABLE之间变化，并采取一定的操作。

状态变革会导致不同的状态类型（State types）：HARD/SOFT，可能相应的触发事件处理器或者通知。

当主机状态频繁变化时，称为动荡（flapping），动荡的一个例子是，主机由于某种原因反复的重启（例如系统更新导致）。Shinken可以在检测到动荡后暂停通知发送，直到主机状态稳定下来。 

以下时机Shinken的守护程序对服务执行检查：

1. 根据服务的check_interval、retry_interval选项周期性、定时检查
2. 在进行预测性服务依赖性检查（predictive service dependency checks）时，按需进行

与主机检查一样：

1. 缓存可以很大的提高On-demand服务检查的性能
2. 检查是并行执行的
3. 通过定义服务执行依赖（service execution dependencies），你可以基于其它一个或多个服务的状态，禁止某一服务的检查

被检查的服务可以处于几种状态之一：OK、WARNING、UNKNOWN、CRITICAL。

服务检查由插件执行，插件的返回状态直接对应到上面几个服务状态。

服务的状态变更、动荡的处理和主机类似。

主动检查是Shinken主要使用的检查方式。主动检查由Shinken发起，依据计划周期性的执行。具体步骤如下：

1. 周期性、On-demand触发检查
2. 守护程序调用插件，并传递必要信息
3. 插件执行实际的坚持并报告结果给守护程序
4. 守护程序处理结果，执行适当的操作，例如发送通知、执行事件处理器

集成的数据获取模块，是可以被守护程序启动的组件。这些组件可以高性能的获取数据，效率比周期性的调用插件脚本高。

SNMP数据获取模块：SnmpBooster

NRPE数据获取模块：NRPE

NRPE是一种通信协议，它和安装在远程主机上的代理（Agent）进行交互。

Shinken也支持被动的得到对象的状态。被动检查由外部程序发起，并将检查结果提交给Shinken。

对于天生异步的、不能通过轮询（Polling）很好的检查的服务，被动检查很适用。适合被动检查的例子包括：

1. SNMP陷阱、安全报警。你永远不知道一定时间内有多少陷阱、报警
2. 安装了代理（Agent）的主机上的聚合检查，这种检查的执行间隔会相当低
3. 直接从英语程序中提交检查结果，不依赖于中介日志文件（syslog、event log等）

在主配置文件中设置accept_passive_service_checks为1。对于不需要主动检查的主机、服务，设置passive_checks_enabled为0。

外部程序可以向Shinken的外部命令管道（external command pipe）写入一条PROCESS_SERVICE_CHECK_RESULT外部命令，以提交检查结果。该命令的格式为：

# timestamp，格式为time_t即1970到现在的秒数。执行服务检查的时间点
# host_name，服务所属主机的短名
# svc_description，服务定义中的服务描述
# return_code，检查结果，0=OK, 1=WARNING, 2=CRITICAL, 3=UNKNOWN
# plugin_output，插件的文本输出
[timestamp] PROCESS_SERVICE_CHECK_RESULT;configobjects/host_name;svc_description;return_code;plugin_output

被检查的服务必须在Shinken中预先定义，否则提交的检查结果自动丢弃。

外部程序可以向Shinken的外部命令管道（external command pipe）写入一条PROCESS_HOST_CHECK_RESULT外部命令，以提交检查结果。该命令的格式为：

# host_status，主机状态 0=UP, 1=DOWN, 2=UNREACHABLE
[timestamp] PROCESS_HOST_CHECK_RESULT;configobjects/host_name;configobjects/host_status;plugin_output

与主动检查不同，Shinken不会把结果作为初步结果，进而根据父主机状态判断最终结果。你提交的必须就是主机的实际状态。 

被监控主机/服务的当前状态（Current state）由两个字段决定：

1. 主机或服务的状态（status，先前所有提及的状态，都是这个单词），即OK, WARNING, UP, DOWN...
2. 主机或服务所处的状态类型（State type）

状态类型有两种：软状态（SOFT）、硬状态（HARD）。状态类型非常重要，它们用于决定何时执行事件处理器，何时发送最初的通知。

为了防止因为临时故障而错误的报警，Shinken允许配置主机/服务的max_check_attempts。最有在最大尝试次数到达后，才会认为是真正出现问题。

重新检查与状态类型密切相关

以下情况下，服务/主机处于软状态：

1. 当服务/主机从OK/UP变为non-OK/non-UP状态后，到达max_check_attempts之前。这种情况称为软错误
2. 当服务/主机从软错误中恢复时。这种情况称为软恢复

当对象进入软状态时：

1. 日志记录SOFT状态，仅当你在主配置文件启用log_service_retries或log_host_retries时
2. 调用事件处理器来处理SOFT状态。这是软状态下重要的行为，你可以在到达HARD状态前积极的修复问题。事件处理器执行时， $HOSTSTATETYPE$、 $SERVICESTATETYPE$宏的值为SOFT提示当前处于软状态

以下情况下，服务/主机处于硬状态：

1. 服务/主机从OK/UP变为non-OK/non-UP状态后，到达max_check_attempts之后仍然没有恢复。这种情况称为硬错误
2. 当服务/主机从硬错误转换到其它错误状态时，例如WARNING、CRITICAL
3. 当服务的检查结果是一个non-OK状态且它所属主机为DOWN或UNREACHABLE状态
4. 当服务/主机从硬错误状态恢复。这种情况称为硬恢复
5. 当被动检查结果送达，默认总是认为是硬状态。除非启用passive_host_checks_are_soft选项

当对象进入硬状态时：

1. 日志记录HARD状态
2. 调用事件处理器来处理HARD状态
3. 通知联系人，告知问题或者恢复。事件处理器执行时， $HOSTSTATETYPE$、 $SERVICESTATETYPE$宏的值为HARD提示当前处于硬状态

我们常说“外网挂了”，外网真的会挂吗？几乎不可能，问题肯定出现在你的机器到Internet的链路上。链路上的任何一个路由器/交换机出现故障，你都会无法上网。

在Shinken的监控业务中也是这样，守护程序所在机器到目标主机之间的链路上任何一个节点出现故障，目标主机都会处于non-UP状态。Shinken有能力区分这个non-Up是DOWN还是UNREACHABLE，前提是你正确的配置网络依赖。

你必须站在Shinken守护程序的角度来看问题，守护程序需要经过哪些主机（网络设备）才能到到目标主机？你需要把这些中介的设备配置为目标主机的祖先主机，例如：

# 父子关系的配置必须真实的反映网络拓扑
define host{
  host_name    Switch1
  parents    Shinken  #声明自己的父主机，父主机总是离Shinken守护程序更近（跳数少）
}
define host{
  host_name    Web
  parents    Switch1
}
define host{
  host_name    FTP
  parents    Switch1
}
define host{
  host_name    Router1
  parents    Switch1
}
define host{
  host_name    somewebsite.com
  parents    Router1
}

类似上面的配置，形成从守护程序到目标主机的单向图，Shinken依据此图判断目标主机是不可达，还是宕机。 

某些情况下你可能有多重链路可以到达目标主机，此时应该为目标主机（或者链路上的中介节点）配置多个父主机。

只有全部父主机不可达、宕机，子主机才会被判定为不可达。

Shinken只会针对问题的根源（Root problems）发送通知，这避免了发送大量的通知给联系人。只有主机状态是DOWN时通知才会发送，主机是UNREACHABLE时不会发送，但是它的某个祖先主机的DOWN通知可能被发送。

同样的，DOWN/UNREACHABLE主机上服务的通知也不会发送，它们不是问题的根源所在。

服务和主机（逻辑）依赖是Shinken的高级特性。允许你基于其它主机/服务的状态，来控制目标主机/服务的行为。

以服务依赖为例，一个Web服务常常会依赖于一个数据库服务。如果数据库服务宕机了，你向联系人通知说Web服务挂了是没有意义的。你应该正确配置服务之间的依赖关系，以便Shinken能够报告问题的根源。

关于服务依赖，你需要知道：

1. 一个服务可以依赖于1-N个其它服务
2. 一个服务可以依赖于其它主机上的服务
3. 通过服务依赖配置，你可以在服务的某些状态下，抑制检查的执行、通知的发送
4. 依赖关系可以仅在特定时间段内启用

# 位于srv-web上的service服务
define service{
  host_name              srv-web
  service_description    Http
  # 依赖位于srv-db上的mysql服务
  service_dependencies   srv-db,mysql
}

依赖是可以继承（inherited，应该理解为传递性依赖）。以上面的例子讲，假设mysql服务依赖srv-dns,dns，那么http出现问题时会检查mysql，进一步会检查srv-dns以确认问题根源。

网络依赖同样会影响问题根源的判断，如果http出现问题的同时发现srv-db宕机，那么后者会被看作问题的根源，前者只作为后者的impact。

Shinken允许在返回状态数据的同时，附带记录可选的性能数据。你可以把性能数据返回给外部程序进行处理。

性能数据分为两个类别：

Shinken插件至少会返回一行人类可读的文本，用来描述某种类型的可度量数据，例如check_ping插件返回的文本可以如下：

PING ok - Packet loss = 0%, RTA = 0.80 ms

类似这样的输出，可以通过

$HOSTOUTPUT$

$SERVICEOUTPUT$

可选的，插件还可以返回性能数据，以管道符号

|

PING ok - Packet loss = 0%, RTA = 0.80 ms | percent_packet_loss=0, rta=0.80

输出中的性能数据部分，可以通过 

$HOSTPERFDATA$ 

$SERVICEPERFDATA$

Shinken守护程序不直接处理性能数据，因此它也不关心其格式。

如果你需要处理性能数据，则需要启用process_performance_data选项，并配置Shinken，让性能数据写入到文件，或者执行命令。

选项host_perfdata_command、service_perfdata_command用于指定处理性能数据的命令。下面是命令的例子：

define command{
  command_name    store-service-perfdata
  command_line    /bin/echo -e "$LASTSERVICECHECK$\t$HOSTNAME$\t$SERVICEDESC$\t$SERVICESTATE$\t$SERVICEATTEMPT$\t
                                $SERVICESTATETYPE$\t$SERVICEEXECUTIONTIME$\t$SERVICELATENCY$\t$SERVICEOUTPUT$\t
                                $SERVICEPERFDATA$" >> /var/lib/shinken/service-perfdata.dat
}

调用命令的方式可能会导致较高的CPU负载，特别是需要处理大量主机/服务时，最好先写入文件，然后由外部程序处理。使用host_perfdata_file、service_perfdata_file选项你可以指定写入到什么文件；而host_perfdata_file_template、service_perfdata_file_template 选项用于指定输出的模板。

在让Shinken真正能工作之前，你需要配置若干个文件。在目录

/etc/shinken/

编辑任何配置文件时，都要记住：

1. #开头的行是注释，不进行处理
2. 变量名大小写敏感

从2.0开始Shinken引入新的配置文件布局，基本的配置文件现在被分割到多个小的文件中。新的布局更好管理，例如一个文件对应一个对象的配置。

配置文件可以分为以下几类：

shinken.cfg

module

resource_file

cfg_file

cfg_dir

service_check_timeout=60
host_check_timeout=30 

在进行对象定义的时候，你可以使用对象继承机制，降低配置文件字段的冗余。

所有对象都可以使用以下三个和继承、递归相关的变量：

define someobjecttype{
       object-specific variables ...
       # 对象的名称，可以被其它对象引用，对于同一类型的对象，其名称必须唯一
       name            template_name
       # 你想从中继承属性/变量的“模板对象”
       use             name_of_template_to_use
       # 是否向Shinken注册此定义，如果该定义纯粹是作为模板使用的不完全定义，应该设置为0
       # 默认1，表示注册，该字段不会被继承
       register        [0/1]
}

有一点很重要，对象在本地自己定义的变量，总是比继承自模板的优先级高。也就是说，对象定义可以覆盖继承得到的值。

Shinken不限制对象继承的深度，上述的覆盖行为从祖代向子代逐步进行。

你在主机/服务/联系人中声明的自定义变量（_开头的），可以和普通变量一样被继承。

对于字符串类型的变量，你可以将其设置为null，防止从模板继承值：

event_handler null

默认的，你在对象里声明一个变量，会覆盖模板中的同名变量。

对于标准变量（非自定义）的字符串变量，Shinken支持所谓加性继承（additive inheritance），即把对象声明的值附加到继承值的后面。

要启用加性继承，只需要在声明值的时候前缀+号：

# 模板
hostgroups              all-servers

# use模板的对象
hostgroups             +linux-servers,web-servers
# 实际相当于
hostgroups             all-servers,linux-servers,web-servers

通常情况下，你要么继承，要么声明一个变量值，但是由几个例外情况。在这些情况下，Shinken会从相关对象继承值：

 一个对象可以同时继承多个模板，例如：

define host{
       name                    generic-host
       active_checks_enabled   1
       check_interval          10
       register                0
}
define host{
       name                    development-server
       check_interval          15
       notification_options    d,u,r
       register                0
}
define host{
       use                    generic-host,development-server
       host_name              devweb
}

对象devweb的实际定义相当于：

define host{
       host_name               devweb1
       active_checks_enabled   1
       check_interval          10
       notification_options    d,u,r
}

可以看到，声明在use列表前面的模板，具有更高的优先级。 

上面提到过，通过隐含继承，可以让Service自动从Host继承特定变量。对于不支持隐含继承的变量，你可以在主机中使用指令：

# 对于属于该主机的xxx服务，设置其yyy为zzz
service_overrides xxx,yyy zzz
# 支持多行值
service_overrides xxx,yyy zzz
                  aaa,bbb ccc

# 举例
define host {
       host_name               web-back-01
       hostgroups              web
       service_overrides       HTTP,notification_options c,r
}

这样可以避免从Pack中继承不匹配实际需求的值。

注意：service_overrides属性可以从模板继承。

你可以使用service_excludes指令，从Pack中排除继承得来的服务定义：

define host {
       use                     web-front
       host_name               web-back-01
       service_excludes        mgr
}

通过多次使用cfg_file、cfg_dir指令，你可以编写多个对象定义文件。安装好Shinken后，/etc/shinken/目录中有很多样例对象定义文件，这些文件存放在各自的目录中。

定义格式： 

# 语法
define host {
    optionname   optionvalue
}

# 示例
define host{
    host_name                      bogus-router
    alias                          Bogus Router #1
    address                        192.168.1.254
    parents                        server-backbone
    check_command                  check-host-alive
    check_interval                 5
    retry_interval                 1
    max_check_attempts             5
    check_period                   24x7
    process_perf_data              0
    retain_nonstatus_information   0
    contact_groups                 router-admins
    notification_interval          30
    notification_period            24x7
    notification_options           d,u,r
    realm                          Europe
    poller_tag                     DMZ
    icon_set                       server
}

选项列表：

service_overrides      HTTP,notification_period workhours

hostgroup_name=(linux|windows)&!qualification,routers

bp_rule

# 支持逻辑操作符
# 如果websrv1的apache服务或者websrv2的apache服务OK，并且dbsrv1上的oracle数据库OK
# 那么当前服务的状态判断为OK
bp_rule(websrv1,apache | websrv2,apache) & dbsrv1,oracle

host,service_description,host,service_description

通过Shinken支持的接口，管理员可以直观的看到监控数据，例如主机/服务的状态。

Shinken自带一个WebUI，你也可以使用其它开源/商业的Web前端，这些前端使用LiveStatus API或者SQL backend。LiveStatus具有很好的实时性、可扩容性和灵活性。

安装必要的模块：

# Web UI
shinken install webui
# 身份验证机制
shinken install auth-cfg-password
# 用户配置存储
shinken install sqlitedb

修改模块定义（安装WebUI模块后，此定义会自动生成）：

define module {
    module_name         webui
    module_type         webui
    host                0.0.0.0     # 监听所有网络接口
    port                7767
    auth_secret         CHANGEME    # 修改，防止Cookie伪造
    allow_html_output   1           # 是否允许插件输出HTML特殊字符
    max_output_length   1024        # 插件输出的最大长度
    manage_acl          1           # Use contacts ACL. 0 allow actions for all.
    play_sound          0           # 出现新的未确认问题时播放声音
    login_text          Welcome on Shinken WebUI   # 登陆表单提示信息
    modules             auth-cfg-password SQLitedb # 使用Shinken联系人进行身份验证，使用SQLitedb存储用户设置
}

修改用于登陆的联系人：

# 基本配置已经包含此联系人
define contact{
    use             generic-contact
    contact_name    admin
    email           shinken@localhost
    # 修改密码
    password        admin             
    is_admin        1
    expert          1
}

然后，需要让代理加载此模块定义：

define broker {
    ...
    modules   webui
}

现在你可以访问 http://ip:7767/user/login并登陆了。

使用Shinken WebUI2 

新版本的WebUI，内部集成了身份验证、存储、日志模块，简化了安装和配置。

安装模块：

pip install bottle
shinken install webui2

完毕后修改代理定义，把webui模块改为webui2，重启Shinken即可。

基于Livestatus的前端包括：

1. Thruk，适用于中小规模的场景
2. Multisite，适用于最大规模的可扩容性需求
3. Nagvis，用于图形化的展示，可以显示网络拓扑图，并标注每个主机的状态

获得livestatus模块定义：

# 使用SQLite存储历史日志
shinken install logstore-sqlite
# 获得livestatus模块定义
shinken install livestatus

在代理定义中加载livestatus模块

define broker {
    modules   webui2,livestatus
} 

禁用SELinux： 

SELINUX=disabled

安装必要的软件：

yum install httpd
yum install mod_fcgid

wget http://download.thruk.org/pkg/v2.08/rhel7/x86_64/libthruk-2.08-1.rhel7.x86_64.rpm
rpm -ivh ./libthruk-2.08-1.rhel7.x86_64.rpm
wget http://download.thruk.org/pkg/v2.08/rhel7/x86_64/thruk-base-2.08-1.rhel7.x86_64.rpm
rpm -ivh ./thruk-base-2.08-1.rhel7.x86_64.rpm 
wget http://download.thruk.org/pkg/v2.08/rhel7/x86_64/thruk-plugin-reporting-2.08-1.rhel7.x86_64.rpm
rpm -ivh ./thruk-plugin-reporting-2.08-1.rhel7.x86_64.rpm
wget http://download.thruk.org/pkg/v2.08/rhel7/x86_64/thruk-2.08-1.rhel7.x86_64.rpm
rpm -ivh ./thruk-2.08-1.rhel7.x86_64.rpm 

chkconfig httpd on
service httpd start

上述步骤完毕后，你可以通过http://ip/thruk/来访问Thruk了，默认登陆用户名密码是thrukadmin/thrukadmin。

enable_shinken_features = 1
<Component Thruk::Backend>
    <peer>
        name   = External Shinken
        type   = livestatus
        <options>
            peer    = 127.0.0.1:50000
        </options>
    </peer>
</Component>

注意livestatus的IP和端口要和livestatus的模块定义匹配。

完成配置后，重启Shinken，然后登陆到Thruk。在左侧菜单点击Config Tool，右上角Configuration Type选择Backends，点击Test测试。参考下图：

注意：从启动Shinken到livestatus可用，可能需要几分钟时间。

你可以使用预定义的模板来监控Windows设备，并获得内存用量、CPU负载、磁盘用量、系统服务状态、进程、系统事件日志等方面的信息。

有两种方法监控Windows设备：

1. 基于代理的方式：在目标设备上安装NSClient++
2. 无代理的方式：通过WMI协议直接通过网络轮询Windows状态

前提条件：你需要一个合法的Windows本地/域账号，用于执行WMI查询。

安装windows包：

shinken install windiws

安装必要的Perl模块：

yum -y install perl-Number-Format 
yum -y install perl-Config-IniFiles 
yum -y install -y perl-DateTime  

修改主机配置：

define host{
   # 继承windows模板
   use                     windows  
   _DOMAIN                 $DOMAIN$
   _DOMAINUSERSHORT        logonuser
   _DOMAINPASSWORD         passwd
}

与Windows设备的监控类似，你也可以监控Linux的内存用量、CPU负载、磁盘用量、进程等方面的信息。

你可以通过多种方式来监控Linux：

1. 通过SNMP代理
2. 基于一个本地的代理，可以高频率获取数据，支持主动、被动通信方式
3. 基于SSH的方式，只适用于非频繁的检测，可扩容性差

首先，你需要在目标设备上安装SNMP守护程序：

# CentOS 7
yum install net-snmp net-snmp-devel net-snmp-libs net-snmp-utils
systemctl enable snmpd
systemctl start  snmpd

# Debian/Ubuntu
apt-get install snmpd
sudo update-rc.d snmpd defaults
service snmpd start

修改snmpd的配置文件：

# Ubuntu 14.04
# 注释掉 agentAddress  udp:127.0.0.1:161，添加
agentAddress udp:161,udp6:[::1]:161
# 将 rocommunity public  default    -V systemonly 改为
rocommunity public

# CentOS 7
# 把默认的两行view systemview去掉，改为：
view systemview included .1.3.6.1

# 最好更改团体名（下面的public），以避免安全问题
# CentOS 7
com2sec notConfigUser  default       public
# Ubuntu 14.04
rocommunity public  default    -V systemonly

然后，你需要在监控服务器上执行以下操作：

1. 安装Perl的SNMP支持：

   yum -y install perl-Net-SNMP

    
2. 安装相关Shinken包：

   shinken install linux-snmp

    
3. 修改主机配置：
   

   define host{
       # 继承linux-snmp模板
       use                 linux-snmp
       # 指定团体名，默认是读取宏$SNMPCOMMUNITYREAD$的值，你可以在资源中定义该宏
       _SNMPCOMMUNITY      public
       # 监控哪个网络接口的使用情况
       _NET_IFACES         eth0
   }

完毕后，重启Shinken即可。

某些廉价的交换机、集线器没有IP地址，因而无法监控。相反的，一些高档网络设备则提供SNMP查询功能。

Shinken支持监控：

1. 丢包率、延迟
2. SNMP状态信息，需要交换机支持SNMP
3. 带宽/通信速率，需要安装MRTG，需要交换机支持SNMP

define service{
   use                    generic-service
   host_name              router
   service_description    PING
   # CRITICAL：RTA大于600ms或者丢包率不小于60%
   # WARNING：RTA大于200ms或者丢包率不小于20%
   # OK：RTA小于200ms并且丢包率小于20%
   check_command          check_ping!200.0,20%!600.0,60%
}

你可以执行命令：

snmpwalk -v1 -c public 192.168.1.1 -m ALL .1

监控命令举例：

# 监控路由器已经启动的时间
check_command        check_snmp!-C public -o sysUpTime.0
# 监控端口1的连接状态
check_command       check_snmp!-C public -o ifOperStatus.1 -r 1 -m RFC1213-MIB

如果你安装了MRTG ，则Shinken支持通过

check_mrtgtraf

define service{
   use                 generic-service
   host_name           router
   # 端口1的带宽使用情况
   service_description Port 1 Bandwidth Usage
   check_command       check_local_mrtgtraf!/var/lib/mrtg/192.168.1.253_1.log!AVG!1000000,2000000!5000000,5000000!10
}

通过该插件，你可以监控任意支持SNMP的网络设备（主要是交换机、路由器）的网络使用情况、CPU负载、内存使用、端口使用、硬件状态等方面的信息。 监控命令举例：

# 列出所有接口的状态
/var/lib/shinken/libexec/check_nwc_health --hostname 192.168.0.1 --timeout 60 --community "public" --mode interface-status
# 显示健康状态 
/var/lib/shinken/libexec/check_nwc_health --hostname 192.168.0.1 --timeout 60 --community "public" --mode hardware-health

支持JetDirect协议的打印机往往也启用了SNMP，可以通过插件check_hpjd监控之。

安装包：

shinken install hp-printers

修改主机配置：

define host {
    use    printer-hp
} 

这里的公共服务是指对外开放的，可以通过网络访问的服务、应用或者协议。公共服务的例子包括：HTTP、POP3、IMAP、FTP、SSH等。

官方的Nagios/Shinken插件支持很多常见服务、协议的监控。如果找不到合适的插件，你也可以自己开发。

安装http包：

shinken install http

修改主机配置：

define host{
        # 继承http或（和）https模板
        use                http,https  
        # 监听端口
        _CHECK_HTTP_PORT   80
        _CHECK_HTTPS_PORT  443
        # 测试的URI
        _CHECK_HTTP_URI    /index.html
        _CHECK_HTTPS_URI   /index.html
}

安装ftp包：

shinken install ftp

修改主机配置：

define host{
        # 继承ftp模板
        use               ftp
}

安装ssh包：

shinken install ssh

修改主机配置，继承ssh。注意，如果你的主机已经继承linux，则不需要再继承ssh。

使用Shinken你可以很好的监控MySQL的运行状态，获取包括InnoDB缓冲池状态、连接数、查询缓存命中率、缓慢查询、锁争用在内的数据。

安装mysql包：

shinken install mysql

安装MySQL的Perl驱动：

yum install -y perl-DBD-MySQL

修改主机配置：

define host{
        # 继承MySQL模板
        use                     mysql
        _MYSQLUSER              pems
        _MYSQLPASSWORD          pemsroot
} 

前提条件：你需要一个合法的Windows本地/域账号。

你可以监控：连接数、错误数量、登陆用户数等方面的信息。

安装需要的包：

shiken install windows
shinken install  iis

修改主机配置：

define host {
    # 继承iis和windows
    user    iis,windows
}

Shinken还提供了很多其它的包，方便你监控常见的服务：

# 监控邮件服务
shinken install imap
shinken install smtp
shinken install pop3

[1467096368] ERROR: [Shinken] Fail launching command: /usr/lib/nagios/plugins/check_ping -H localhost -w 1000,100% -c 3000,100% -p 1 [Errno 2] No such file or directory False

Shinken基本配置中的命令，主要是调用$NAGIOSPLUGINSDIR$目录下的监控插件（命令行），例如：

define command {
    command_name    check_ping
    command_line    $NAGIOSPLUGINSDIR$/check_icmp -H $HOSTADDRESS$ -w 3000,100% -c 5000,100% -p 10
}

宏$NAGIOSPLUGINSDIR$指向插件的安装目录，该宏的默认值定义在： 

# Nagios legacy macros
$USER1$=$NAGIOSPLUGINSDIR$
$NAGIOSPLUGINSDIR$=/usr/lib/nagios/plugins

#-- Location of the plugins for Shinken
$PLUGINSDIR$=/var/lib/shinken/libexec

如果你没有安装这些插件，或者安装位置不是/usr/lib/nagios/plugins，就会报找不到文件的错误。

你可以从多个地方获取插件：

1. Nagios Core Plugins：你可以下载50个核心Nagios插件
2. The Monitoring Plugins Project：监控插件项目，这个开源项目维护更多的插件

安装插件的示例脚本：

yum -y install openssl openssl-devel

wget https://www.monitoring-plugins.org/download/monitoring-plugins-2.1.2.tar.gz
tar xzf monitoring-plugins-2.1.2.tar.gz 
cd monitoring-plugins-2.1.2/
./configure --with-openssl
make && make install

修改宏定义，指向监控插件实际安装目录：

$NAGIOSPLUGINSDIR$=/usr/local/libexec

出现此错误的原因是编译插件的时候没有安装OpenSSL，参考上面的脚本，先安装OpenSSL再配置、构建、安装插件。

出现此错误的原因是没有安装Perl的MySQL驱动，安装即可：

yum -y install -y perl-DBD-MySQL

出现此错误的原因是缺少对应的Perl模块，安装即可：

yum -y install perl-Number-Format

出现此错误的原因是缺少对应的Perl模块，安装即可：

yum -y install perl-Config-IniFiles

出现此错误的原因是缺少对应的Perl模块，安装即可：

yum -y install -y perl-DateTime

安装缺少的函数库：

yum -y install redhat-lsb redhat-lsb-core

某些Shinken插件可能没有随基本配置安装，你可以到shiken-plugins网站下载：

cd /var/lib/shinken/libexec
wget https://raw.githubusercontent.com/Sysnove/shinken-plugins/master/check_netint.pl
chmod +x check_netint.pl

该插件是Native应用程序，需要手工编译：

wget https://labs.consol.de/assets/downloads/nagios/check_nwc_health-5.7.1.1.tar.gz
tar xzf check_nwc_health-5.7.1.1.tar.gz  && rm -f check_nwc_health-5.7.1.1.tar.gz
cd check_nwc_health-5.7.1.1/
./configure  && make
cp plugins-scripts/check_nwc_health* /var/lib/shinken/libexec/

# 初次使用cpanm命令时
cpan App::cpanminus

# 安装Load模块
cpanm Module::Load

# cpanm默认安装位置为~/perl5/lib/perl5/无法被check_nwc_health命令找到，因此需要手工拷贝一下
mkdir /usr/lib64/perl5/vendor_perl/Module
cp /root/perl5/lib/perl5/Module/Load.pm /usr/lib64/perl5/vendor_perl/Module

The post Shinken学习笔记 appeared first on 绿色记忆.

Django是一个Python的Web开发框架，它是一个WSGI规范的框架端实现。使用该框架可以把你从Web开发的很多重复劳动中解放出来而专注于业务逻辑。

Django运行速度非常快、并且是可扩容的，安全性方面也做的很好，可以避免一些常见的安全性错误。

最新的1.9版本，要求Python版本为2.7、3.4或者3.5。具体安装步骤本文不赘述，可以参考Python知识集锦。

Django内置了一个简单的开发用Web服务器，可以用于开发和测试，要启动此服务器，只需要：

# 先进入工程根目录
cd librarymgr
# 启动开发服务器
python manage.py runserver

这个开发服务器会自动重新载入最新的Python代码，便于开发调试。

在生产环境下你应当使用可靠的Web服务器，例如Apache、Nginx等。

这个组合可以作为Django的Web容器。Apache是广泛使用的、模块化的Web服务器；而mod_wsgi模块则是一个Apache模块，同时也是WSGI规范的服务器端实现，安装此模块后Apache可以和任何支持WSGI的Python Web应用通信，例如基于Django的应用。

mod_wsgi有两种运行模式：

1. 嵌入式模式：类似于mod_perl，Python被嵌入在Apache中，Python代码在Apache启动时加载到Apache进程空间并驻留直到Apache进程结束。这种方式具有较高的性能
2. 守护模式：mod_wsgi产生独立进程，由该进程来处理请求。此进程的运行用户可以不同于Apache进程。此进程可以独立于Apache重启，因而在开发期间可以更无缝的更新代码

手工构建mod_wsgi的步骤如下：

wget https://github.com/GrahamDumpleton/mod_wsgi/archive/4.5.3.tar.gz
tar xzf 4.5.3.tar.gz 
cd mod_wsgi-4.5.3/
./configure
# 在Linux上，Apache2默认使用的MPM（多处理模块）是prefork，下面安装开发支持
# 如果是CentOS，安装 yum install httpd-devel
sudo apt-get install apache2-prefork-dev
make && sudo make install 
# 构建好的模块默认被安装到：
# Ubuntu 14 /usr/lib/apache2/modules/mod_wsgi.so
# CentOS 7  /usr/lib64/httpd/modules/mod_wsgi.so

然后，你需要让Apache加载mod_wsgi模块。你可以使用a2enmod命令或者修改配置文件： 

LoadModule wsgi_module /usr/lib/apache2/modules/mod_wsgi.so

如果要使用Django的数据库API，你需要安装数据库服务器。Django支持多种数据库后端，官方支持包括：PostgreSQL、MySQL、Oracle和SQLite，其它主流数据库有第三方支持。开发一个简单的项目，不需要在生成环境部署时，你可以使用SQLite，它不需要独立的服务器，也不需要安装第三方Python模块。

除了后端以外，你还需要安装对应的Python database bindings：

# MySQL
sudo pip install mysqlclient
# PostgreSQL
sudo pip install  psycopg2

如果你想用Django的

manage.py migrate

你可以通过pip安装：

# 安装Release
sudo pip install django
# 安装开发版本
git clone git://github.com/django/django.git
sudo pip install -e django/

本章通过一个简单的图书馆管理系统，来了解Django的开发流程和基本的API。

开始编程之前，你需要创建一个Django工程：

cd ~/Python/projects/pycharm
django-admin startproject librarymgr

上面的命令会在当前目录下创建一个librarymgr目录，这是新工程的根目录，其结构如下：

└── librarymgr               # 工程容器目录
    ├── manage.py            # 一个命令行工具，通过它你可以和Django工程互动
    └── librarymgr           # 当前工程对应的Python包
        ├── __init__.py      # 空白文件，仅仅用于识别当前目录为一个包
        ├── settings.py      # 当前Django工程的设置/配置
        ├── urls.py          # 当前工程的URL映射声明
        └── wsgi.py          # WSGI兼容的Web服务器的入口点，部署工程时用到此文件

一个Django实例的全部设置：  数据库配置、Django选项、应用程序选项，都存放在工程目录下。

你可以直接把工程容器目录作为PyCharm工程打开，PyCharm会自动识别并启用Django支持。

执行下面的命令，可以启动开发服务器：

# 默认监听127.0.0.1:8000
python manage.py runserver   
# 监听所有网络接口
python manage.py runserver 0.0.0.0:8000

注意此服务器会自动Reload最新的Python代码，因而你不需要在修改代码后重启服务器。但是某些时候，例如添加了新文件，可能不会自动载入，这时你需要手工重启。 

使用PyCharm时，用于启动开发服务器的Run Configuration会自动创建，点击工具栏按钮即可启动。 

到目前为止，开发环境已经搭建完毕，可以实现功能了。

在一个工程中，可以包含多个Django应用，有时你可能觉得称之为模块更合适。而每个应用也可以归属于多个工程。工程中的应用共享工程的配置——例如数据库连接。每个Django应用由一个Python包组成，这个包包含一些约定俗成的内容。

你可以把Django应用放置在PYTHONPATH中的任意目录，在这里，我们把它们放置在工程根目录下。执行下面的命令，创建一个应用：

python manage.py startapp bookmgr

命令执行完毕后，工程结构如下：

├── bookmgr
│   ├── admin.py
│   ├── apps.py                 # 包含当前应用的定义及配置
│   ├── __init__.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py               # 在这里定义模型类
│   ├── tests.py
|   ├── urls.py                 # 在这里定义URLconf，即URL和视图的映射关系
│   └── views.py                # 在这里创建新的视图
├── librarymgr
│   ├── __init__.py
│   ├── __init__.pyc
│   ├── settings.py
│   ├── settings.pyc
│   ├── urls.py
│   └── wsgi.py
└── manage.py

我们为图书管理模块添加一个最简单的视图，在响应中简单的输出欢迎文字：

from django.http.response import HttpResponse

def index(request):
    return HttpResponse("Welcome to Book Management module.") 

要调用视图，必须将其映射到某个URL，因而我们需要

URLconf

urls.py

from django.conf.urls import url

from . import views

# 该固定名称的变量定义一系列的URL映射规则
urlpatterns = [
    # url函数定义URL到视图的映射，注意URL的base部分可能已经被父URLconf脱去。该函数接受4个参数
    # regex 匹配URL的正则式，注意此正则式不搜索GET/POST参数或者网址的域名部分，例如对于
    #       https://librarymgr.gmem.cc/bookmgr/?id=1，进行匹配判断的仅仅时bookmgr/
    # view  匹配后，需要调用的视图函数，并把HttpRequest作为第一个入参，正则式中捕获的分组依次作为后续位置参数
    #       如果使用正则式的命名分组，则捕获的分组作为关键字参数传入
    # kwargs 所谓关键字参数
    # name  为URL命名，以便从Django的其它地方——例如模板中——无歧义的引用之
    url(r'^$', views.index, name = 'index')
]

完成URL到视图的映射后，必须把URLconf包含到工程的根URLconf中去： 

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 使用include函数引用其它URLconf
    # 在处理请求时，前缀匹配部分bookmgr/会自动去除，把剩余的部分传递给子URLconf，进行匹配
    url(r'^bookmgr/', include('bookmgr.urls'))
]

现在启动开发服务器，输入网址http://127.0.0.1:8000/bookmgr/，你应该可以看到之前编写的欢迎文字。 

传统的增删改查应用是离不开数据库的，我们可以为工程中所有模块配置共享的数据源。

librarymgr/settings.py

默认情况下，配置文件包含了SQLite的配置：

# 工程使用的所有数据源
DATABASES = {
    # 单个数据源
    'default': {
        # 引擎（数据库后端），其它可选引擎包括：
        # django.db.backends.postgresql、django.db.backends.mysql、django.db.backends.oracle等
        'ENGINE': 'django.db.backends.sqlite3',
        # 数据库的名称，如果使用SQLite，则指定数据库文件的绝对路径
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

不使用SQLite时，你需要提供额外的配置项。本章使用MySQL数据库：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'test',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    }
}

由于默认激活的那些应用程序必须使用表，因此必须初始化数据库，即创建表结构、初始化表数据，执行下面的命令：

# 根据DATABASES设置，以及应用的INSTALLED_APPS的database migrations，完成表创建和数据插入
python manage.py migrate

配置完数据库后，顺便设置一下时区：

TIME_ZONE = 'Asia/Shanghai'

包含该实例激活的Django应用程序的名称，默认激活以下通用应用：

图书管理模块涉及的模型包括书籍类目、书籍、书籍实例等，我们需要将它们建模为Python类。

每个模型类都应该是django.db.models.Model的子类型，这是Django提供的充血模型基类。我们创建以下三个类：

from django.db import models

from django.utils.encoding import python_2_unicode_compatible
@python_2_unicode_compatible  # 如果需要支持Python2
class Category(models.Model):
    # 每个模型会定义若干个Field子类型的变量，这些变量对应数据库的字段，二者默认名字一致
    # 字符串类型的字段
    # 第一个可选参数是人类友好的字段名称
    name = models.CharField('Category name', max_length = 128)
    # 对其它模型的引用，自引用必须用引号包围的类名或者'self'
    # Django支持o2m、m2o、m2m等常见数据库关系
    # blank=True表示表单验证时允许为空，null=True表示数据库字段可以为空
    parent_category = models.ForeignKey('self', blank=True, null=True )
    # 下面这个函数定义模型的字符串展示
    def __str__(self):
        return self.name

class Book(models.Model):
    name = models.CharField(max_length = 128)
    category = models.ForeignKey(Category)
    isbn = models.BigIntegerField()
    pub_date = models.DateTimeField()


class BookInstance(models.Model):
    no = models.IntegerField()
    book = models.ForeignKey(Book)
    # 枚举值和枚举字段
    STATUS_LEND_OUT = 1
    STATUS_RETURNED = 0
    status = models.SmallIntegerField(
        choices = ((STATUS_LEND_OUT, 'Lend out'), (STATUS_RETURNED, 'Returned')),
        # 字段可以提供默认值
        default = STATUS_RETURNED
    )

Django根据上面一小片模型代码，可以自动生成Schema（表结构）。首先，你需要安装bookmgr这个应用：

INSTALLED_APPS = [
    # 在开始处添加下面的内容，BookmgrConfig类以及自动在apps.py中定义
    'bookmgr.apps.BookmgrConfig'
]

然后执行下面的命令，生成一个“迁移”：

# 运行makemigrations命令，告知Django你对模型执行了修改（这里是添加了新模型）
# 并且你想把这个改变保存到一个迁移（migration）中
python manage.py makemigrations bookmgr
# 输出如下：
# Migrations for 'bookmgr':
#   0001_initial.py:
#     - Create model Book
#     - Create model BookInstance
#     - Create model Category
#     - Add field category to book

所谓迁移，只是磁盘上的文件，Django用它来记录模型（以及对应的数据库Schema）的变化。

你可以到应用的migrations目录查看新生成的迁移0001_initial.py，它同样是一段标准的Python代码。

使用命令

python manage.py sqlmigrate bookmgr 0001

BEGIN;
--
-- Create model Book
--
CREATE TABLE `bookmgr_book` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` varchar(128) NOT NULL,
    `isbn` bigint NOT NULL, `pub_date` datetime NOT NULL
);
--
-- Create model BookInstance
--
CREATE TABLE `bookmgr_bookinstance` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `no` integer NOT NULL, 
    `status` smallint NOT NULL, `book_id` integer NOT NULL)
;
--
-- Create model Category
--
CREATE TABLE `bookmgr_category` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, 
    `name` varchar(128) NOT NULL, `parent_category_id` integer NOT NULL
);
--
-- Add field category to book
--
ALTER TABLE `bookmgr_book` ADD COLUMN `category_id` integer NOT NULL;
ALTER TABLE `bookmgr_book` ALTER COLUMN `category_id` DROP DEFAULT;
ALTER TABLE `bookmgr_bookinstance` ADD CONSTRAINT `bookmgr_bookinstance_book_id_73e96047_fk_bookmgr_book_id` 
    FOREIGN KEY (`book_id`) REFERENCES `bookmgr_book` (`id`);
ALTER TABLE `bookmgr_category` ADD CONSTRAINT `bookmgr_categ_parent_category_id_736b2e01_fk_bookmgr_category_id` 
    FOREIGN KEY (`parent_category_id`) REFERENCES `bookmgr_category` (`id`);
CREATE INDEX `bookmgr_book_b583a629` ON `bookmgr_book` (`category_id`);
ALTER TABLE `bookmgr_book` ADD CONSTRAINT `bookmgr_book_category_id_e3c50876_fk_bookmgr_category_id` 
    FOREIGN KEY (`category_id`) REFERENCES `bookmgr_category` (`id`);

COMMIT;

关于上述脚本，你需要了解：

1. 我们没有定义主键字段id，但是父类Model定义了，因此继承而来。你也可以覆盖默认定义
2. 主键的生成规则依据数据库的不同，自动设置
3. 表名称默认为：应用名称_模型类名，模型类名自动转为小写
4. 外键字段的名称为：引用字段名称_id

sqlmigrate命令只是打印SQL，并不会执行数据库迁移。后者通过下面的命令完成：

# 把所有尚未执行的迁移应用到数据库中
python manage.py migrate

注意，你可以在执行迁移之前执行check命令，确保工程中没有错误：

python manage.py check

Django的迁移功能很强大，它在django_migrations表中记录数据库的当前状态，因而可以跟踪迁移的进度。每次执行migrate命令时，Django总是把尚未执行的迁移应用到数据库中。迁移功能还能在升级数据库的同时避免数据丢失。

当你修改模型后，记住以下执行三个步骤：

1. 在models.py中修改模型类
2. 创建迁移文件：

   python manage.py makemigrations

    
3. 执行数据库迁移：

   python manage.py migrate

    

本节我们尝试通过交互式的Python控制台来试验Django的API，首先执行下面的命令启动控制台：

python manage.py shell

现在可以可以编写代码试验功能了：

# 导入模型类
from bookmgr.models import Category, Book, BookInstance
# 查询所有类目
Category.objects.all()
# 输出：[]  因为当前是空表
# 新建一个类目，你可以使用关键字参数传递各字段的值，这是Model类的行为
c = Category(name='social science')
# 必须调用save()，才能持久化到数据库中
c.save()
# 根据主键get，亦可入参id=1
c_sc = Category.objects.get(pk=1)
# 外键字段赋值，使用模型对象，而不是其ID
c = Category(name='economics',parent_category=c_sc)
c.save()
c = Category(name='politics',parent_category=c_sc)
c.save()
# 自动产生的双向关联，使用对方模型名称_set访问
c_sc.category_set.all()    # [<Category: Category object>, <Category: Category object>]
# 通过双向关联创建新对象
c_sc.category_set.create(name='law')
c_sc.category_set.create(name='pedagogy')

执行下面的命令，来创建超级用户

python manage.py createsuperuser

现在通过http://127.0.0.1:8000/admin登陆，默认情况下你可以管理用户和组。

要允许Admin应用管理模型对象，你需要进行注册：

from django.contrib import admin

from .models import Category, Book, BookInstance

admin.site.register(Category)
admin.site.register(Book)
admin.site.register(BookInstance)

重启服务后，你就可以在Web界面中添加、修改、删除模型了。 依据模型字段类型的不同，Admin应用会呈现不同的表单元素。

本节我们开发几个视图，用来展示Book模型。 

为了可维护性的考虑，不应当把HTML片段硬编码在视图函数中，我们可以使用Django提供的模板子系统来分离Python代码和HTML代码。依据Django的默认设置：

TEMPLATES = [
    {
        # 使用何种模板引擎
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        # 在应用的根目录下寻找templates目录  
        'APP_DIRS': True,
    },
]

你需要在应用（bookmgr）的根目录下创建一个

templates

任何网站都需要图片、脚本、样式表等静态资源。在Django框架中应用

django.contrib.staticfiles

你需要设置静态文件的URL前缀以及静态文件搜索目录：

# URL前缀
STATIC_URL = '/static/'
# 静态文件搜索目录，这里工程根目录下的static目录
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static'),
)

在Django模板中，你可以类似

/static/css/default.css

{% load static from staticfiles %}
<link rel="stylesheet" href="{% static "css/default.css" %}">

要能够正常访问default.css，你必须将其存放到

librarymgr/static/css/default.css

现在我们编写Book模块的首页，它展示欢迎信息和最新出版的10本图书。视图函数如下：

def book_index(request):
    # 上下文对象
    context = {
        'books': Book.objects.order_by('-pub_date')[:10]
    }

    # 加载模板
    template = loader.get_template('book/index.html')
    # 调用模板的render()方法，可以把上下文变量合并入模板，并生成字符串
    return HttpResponse(template.render(context, request))

    # 亦可使用下面的捷径：
    from django.shortcuts import render
    return render(request, 'book/index.html', context)

URL映射定义如下：

url(r'^book/index', views.book_index, name = 'book_index')

模板代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Book Index</title>
    {% load static from staticfiles %}
    <link rel="stylesheet" href="{% static 'css/default.css' %}">
</head>
<body>

{% if books %}
    <div><span>Recently 10 published books:</span></div>
    <table>
        <thead>
        <tr>
            <th>Book name</th>
            <th>Publish date</th>
            <th>Action</th>
        </tr>
        </thead>
        <tbody>
        {% for book in books %}
            <tr>
                <td><a href="{% url 'book_view' book.id %}">{{ book.name }}</a></td>
                <td>{{ book.pub_date }}</td>
                <td><a href="{% url 'book_edit' book.id %}"><img src="{% static 'images/edit.png' %}"/></a></td>
            </tr>
        {% endfor %}
        </tbody>
    </table>
{% else %}
    No book available.
{% endif %}
</body>
</html>

这里可以大概了解一下Django模板的语法风格：

1. 使用

   {% %}

    语法声明流程控制指令
2. 使用

   {{ }}

    语法声明占位符
3. 使用点号导航语法来访问对象属性

打开：http://127.0.0.1:8000/bookmgr/book/index，可以看到如下页面：

在上一节的模板中，我们有如下一段代码：

<td><a href="/bookmgr/book/{{ book.id }}">{{ book.name }}</a></td>

上面的href属性中，硬编码了工程名称和应用名称，这会导致部署时修改URL困难。你随时可以url标签避免硬编码：

<td><a href="{% url 'book_view' book.id %}">{{ book.name }}</a></td>

其中book_view就是URLConf中映射条目的name字段：

urlpatterns = [
    url(r'^book/(?P<book_id>[0-9]+)', views.book_view, name = 'book_view')
]

上一节我们开发的视图展示了最近10条书籍信息，其中书籍名称具有链接，很明星，此链接点击后应该显示单本书籍的详细信息。

注意详细信息视图的URL设计：http://127.0.0.1:8000/bookmgr/book/view/4，仍然是RESTful风格的URL，最后的数字是书籍的主键。 我们可以这样映射URL：

url(r'^book/view/(?P<book_id>[0-9]+)', views.book_view, name = 'book_view')

其中

(?P<group_name>...)

视图函数如下：

# book_id这个入参名称必须和分组的命名一致
def book_view(request, book_id):
    try:
        book = Book.objects.get(pk = book_id)
    except Book.DoesNotExist:
        # 触发异常，Django会自动将其转换为404响应
        raise Http404('No such book:%i' % book_id)

    # 上面的try-except块也可以使用快捷方式代替：
    book = get_object_or_404(Book, pk = book_id)

    return render(request, 'book/view.html', {'book': book})

模板代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>View Book</title>
    {% load static from staticfiles %}
    <link rel="stylesheet" href="{% static 'css/default.css' %}">
</head>
<body>
<div><span>Detail information of: {{ book.name }}</span></div>
<table>
    <tr>
        <th>Book name:</th>
        <td>{{ book.name }}</td>
    </tr>
    <tr>
        <th>Category:</th>
        <td>{{ book.category.name }}</td>
    </tr>
    <tr>
        <th>ISBN:</th>
        <td>{{ book.isbn }}</td>
    </tr>
    <tr>
        <th>Publish date:</th>
        <td>{{ book.pub_date }}</td>
    </tr>
</table>
</body>
</html>

打开：http://127.0.0.1:8000/bookmgr/book/view/1，可以看到如下页面：

本节我们了解一下Django中的表单处理。 

添加视图函数：

def book_edit(request, book_id, messages=[]):
    categories = Category.objects.all()
    try:
        book = Book.objects.get(pk=book_id)
    except Book.DoesNotExist:
        raise Http404('No such book:%i' % book_id)
    return render(request, 'book/edit.html', {'book': book, 'categories': categories, 'messages': messages})

URL映射如下：

url(r'^book/edit/(?P<book_id>[0-9]+)', views.book_edit, name='book_edit')

模板代码如下，注意其中的for和if控制结构：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Edit Book</title>
    {% load static from staticfiles %}
    <link rel="stylesheet" href="{% static "css/default.css" %}">
</head>
<body>
<div><span>Edit: {{ book.name }}</span></div>
{% if messages %}
    {% for msg in messages %}
        <div class="{% if msg.ok %}ok{% else %}error{% endif %}">{{ msg.message }}</div>
    {% endfor %}
{% endif %}
<form action="{% url 'book_commit' %}" method="post">
    <table>
        <tr>
            <th>Book name:</th>
            <td>
                {% csrf_token %} {% comment %} 必须，否则报错：CSRF verification failed. Request aborted. {% endcomment %}
                <input type="hidden" name="id" value="{{ book.id }}"/>
                <input type="text" name="name" value="{{ book.name }}"/></td>
        </tr>
        <tr>
            <th>Category:</th>
            <td>
                <select name="category">
                    {% for c in categories %}
                        <option value="{{ c.id }}"
                                {% if c.id == book.category.id %}selected="selected"{% endif %}>{{ c.name }}</option>
                    {% endfor %}
                </select>
            </td>
        </tr>
        <tr>
            <th>ISBN:</th>
            <td>
                <input type="number" name="isbn" value="{{ book.isbn }}"/>
            </td>
        </tr>
        <tr>
            <th>Publish date:</th>
            <td>
                <input type="date" name="pub_date" value="{{ book.pub_date.isoformat }}"/>
            </td>
        </tr>
    </table>
    <input class="submit-btn" type="submit" value="Submit"/>
</form>
</body>
</html>

点击首页的Action列的按钮 ，即可看到此编辑Book的页面：

点击上面的Submit按钮后，需要有服务器程序来处理表单数据，并返回处理结果。这些工作由book_commit视图函数完成： 

def book_commit(request):
    # 类似于字典的、存放所有POST请求参数的对象。类似的 request.GET 用于访问GET请求参数
    data = request.POST
    messages = []
    categories = Category.objects.all()
    try:
        book_id = int(data['id'])
        category_id = int(data['category'])
        book = Book.objects.get(pk=book_id)
        category = Category.objects.get(pk=category_id)
        book.name = data['name']
        book.category = category
        book.isbn = int(data['isbn'])
        from dateutil.parser import parse
        book.pub_date = parse(data['pub_date'])
        messages.append({'ok': True, 'message': 'Book updated: %i' % book_id})
    except Book.DoesNotExist:
        messages.append({'ok': False, 'message': 'No such book: %i' % book_id})
    except Category.DoesNotExist:
        messages.append({'ok': False, 'message': 'No such category: %i' % category_id})
    except BaseException as e:
        print e.message
        messages.append({'ok': False, 'message': 'Failed to update book, %s' % e.message})
    return book_edit(request, book_id, messages)

注意最后的return语句调用了其它视图函数，这类似于Java Servlet中的请求转发。另外一种处理方式是301重定向：

# reverse用于避免硬编码URL
return HttpResponseRedirect(reverse('book_edit', args=(book.id,)))

这样也可以把用户带回到编辑页面。区别有两点：

1. 重定向方式下，不能方便的传递模板上下文变量。例如messages变量
2. 重定向方式下，实际上就是让浏览器重新定位到book_edit这个URL，因此浏览器地址是/bookmgr/book/edit/3。前一种方式的浏览器地址是/bookmgr/book/commit

完成开发后，我们需要把工程部署到生产环境的服务器上。

最简单的配置：

# /librarymgr/为URL前缀。匹配的URL将由wsgi.py处理
WSGIScriptAlias /librarymgr/ /home/alex/Python/projects/pycharm/librarymgr/librarymgr/wsgi.py
# PYTHONPATH，指定为工程根目录
WSGIPythonPath /home/alex/Python/projects/pycharm/librarymgr

<Directory /home/alex/Python/projects/pycharm/librarymgr/librarymgr>
<Files wsgi.py>
    Require all granted
</Files>
</Directory>

Alias /static/ /home/alex/Python/projects/pycharm/librarymgr/static/
<Directory /home/alex/Python/projects/pycharm/librarymgr/static/>
    Require all granted
</Directory>

虚拟主机方式：

WSGIPythonPath /home/alex/Python/projects/pycharm/librarymgr
<VirtualHost 127.0.0.1:80>
    WSGIScriptAlias / /home/alex/Python/projects/pycharm/librarymgr/librarymgr/wsgi.py

    <Directory /home/alex/Python/projects/pycharm/librarymgr/librarymgr>
    <Files wsgi.py>
        Require all granted
    </Files>
    </Directory>

    Alias /static/ /home/alex/Python/projects/pycharm/librarymgr/static/
    <Directory /home/alex/Python/projects/pycharm/librarymgr/static/>
        Require all granted
    </Directory>
</VirtualHost>

The post Django学习笔记 appeared first on 绿色记忆.

添加代理（proxy）类型的图层，设置provider为相应的厂商。

{
  "layers": 
  {
    ......
    "bing-satellite":
    {
      "provider":
      {
        "name" : "proxy",
        "provider" : "MICROSOFT_AERIAL"
      }
    }
  }
}

# a handy list of possible providers, which isn't
# to say that you can't go writing your own.
builtinProviders = {
    'OPENSTREETMAP':    OpenStreetMap.Provider,
    'OPEN_STREET_MAP':  OpenStreetMap.Provider,
    'BLUE_MARBLE':      BlueMarble.Provider,
    'MAPQUEST_ROAD':   MapQuest.RoadProvider,
    'MAPQUEST_AERIAL':   MapQuest.AerialProvider,
    'MICROSOFT_ROAD':   Microsoft.RoadProvider,
    'MICROSOFT_AERIAL': Microsoft.AerialProvider,
    'MICROSOFT_HYBRID': Microsoft.HybridProvider,
    'YAHOO_ROAD':       Yahoo.RoadProvider,
    'YAHOO_AERIAL':     Yahoo.AerialProvider,
    'YAHOO_HYBRID':     Yahoo.HybridProvider,
    'CLOUDMADE_ORIGINAL': CloudMade.OriginalProvider,
    'CLOUDMADE_FINELINE': CloudMade.FineLineProvider,
    'CLOUDMADE_TOURIST': CloudMade.TouristProvider,
    'CLOUDMADE_FRESH':  CloudMade.FreshProvider,
    'CLOUDMADE_PALEDAWN': CloudMade.PaleDawnProvider,
    'CLOUDMADE_MIDNIGHTCOMMANDER': CloudMade.MidnightCommanderProvider,
    'STAMEN_TONER': Stamen.TonerProvider,
    'STAMEN_TERRAIN': Stamen.TerrainProvider,
    'STAMEN_WATERCOLOR': Stamen.WatercolorProvider,
    }

The post TileStache知识集锦 appeared first on 绿色记忆.

在Python2中，类型

str

unicode

字符串可以使用单引号、双引号、三引号包围， 三引号中的字符串原样保留，可以方便的编写多行文本。

字符串的引号开始前，可以增加

u

r

Python没有单独的字符类型，字符只是长度为1的字符串

在Python语言中，字符串属于（不可变）序列，支持有限的切片操作：

s = "一二三四五六七"
# 取子串，起始索引包含，结束索引不包含
assert s[1:3] == '二三'
assert s[-3:] == '五六七'
i = 3
assert s[:i] + s[i:] == s

# 带步进的切片，默认1，即下一个元素的索引比上一个大1
assert s[1:4:1] == '二三四'
assert s[1:4:2] == '二四'
assert s[1:4:3] == '二'
# 负数的步进，下面这个用于生成倒序的串
assert s[::-1] == '七六五四三二一'
assert s[4:1:-1] == '五四三'

在Python中，此操作符可以用于成员关系测试，或者迭代：

s = '01234567'
assert '3' in s
for c in s: print(c)

适用于任意切片的运算符还包括

+

*

assert '123' + '4567' == '1234567'
assert '123' * 3 == '123123123'

很多内置函数、方法可以用于操控字符串： 

s = "01234567"
# 计算序列长度
assert len(s) == 8
# 获取序列元素的最小值
assert min(s) == '0'
# 获取序列元素的最大值
assert max(s) == '7'

# 查找，获得子串的索引，两个方法类似，但是index()在无法子串不存在时抛出ValueError
assert s.index('67') == 6
assert s.find('67') == 6
# 查找，子串判断
assert s.startswith('012') and s.endswith('4567')
# 替换，注意字符串是不可变的，因此返回的是副本
assert s.replace('3', 'x') == "012x4567"
# 分割
assert s.split('3') == ['012', '4567']
# 连接
assert ','.join(['1', '2', '3']) == '1,2,3'
# 对齐和填充
assert s.ljust(10, '0') == '0123456700'
# 去除空白，左侧
assert s.lstrip('0') == '1234567'
# 特性检查：is*()方法
assert s.isalnum()  # 是否仅包含字母数字

Python支持两种风格的字符串格式化操作，包括旧式的

%

format()

可以使用

%

s % d

'%s %s' % ('one', 'two') 
'%(k1)s %(k2)s' % {'k1':'one','k2':'two'}

格式模板由普通字符、转换说明符组成，转换说明符以%开头，具体含义如下：

在字符%与上表列出的转换字符之间，可以按顺序出现以下修饰符：

a = 42
b = 13.142783 c = "hello"
d = {'x':13, 'y':l.54321, 'z':'world'} 
e = 5628398123741234

r = "a is %d" % a                     # r = "a is 42"
r = "%10d %f" %(a,b)                  # r = "        42 13.142783"    整数宽度10，右对齐
r = "%+010d %E" %(a,b)                # r = "+000000042 1.314278E+01" 整数宽度10，右对齐，不足补0
r = "%(x)-10d %(y)0.3g" % d           # r = "13          1.54"        从字典d里取出值并对其执行转换
r = "%0.4s %s" %(c, d['z'])           # r = "hell world"              第一个字符串最大打印长度为4
r = "%*.*f" % (5,3,b)                 # r = "13.143"                  元组的前两项作为格式字符串的组成部分

#注意，格式化字符串与字典一起使用，行为类似于字符串插值：
p = {'age' : 28, 'name' : 'Alex'}
r = "%(name)s's age is %(age)d" % p   # r = "Alex's age is 28"

通过调用作为模板的字符串的format()是Python新式的格式化机制。模板由普通字符和占位符组成，可以使用

{place:format_spec}

1. place，位置，可以是数字表示的位置参数、标识符表示的命名参数。默认情况下Python使用

   __format__()

    得到对象的文本表示，要改变此行为，可以扩展place为

   place!type

    形式。其中type可以取值s、r、a，分别调用

   __str__()

    、

   __repr__()

    和

   ascii()

    完成文本转换，a仅在Python3中被支持
2. format_spec，格式说明符，形式为：

   [[fill]align][sign][#][0][width][,][.precision][type]

    ，各字段说明如下：

<

>

=

^

+

-

0b

0o

0x

代码示例：

# ###  参数占位符  ###
# 位置参数
'{0}, {1}, {2}'.format('a', 'b', 'c')  # 'a, b, c'
'{2}, {1}, {0}'.format('a', 'b', 'c')  # 'c, b, a'
'{}, {}, {}'.format('a', 'b', 'c')  # 'a, b, c' 要求2.7+
'Hello {0}'.format('Alex') == 'Hello Alex'
# 命名参数
'Coordinates: {latitude}, {longitude}'.format(latitude = '37.24N', longitude = '-115.81W')
'Hello {name}'.format(name = 'Alex') == 'Hello Alex'
# 访问对象属性
person = lambda: None
person.greeting = 'Hello'
person.name = 'Alex'
assert '{0.greeting} {0.name}'.format(person) == 'Hello Alex'
# 访问序列的元素
coord = (3, 5)
'X: {0[0]};  Y: {0[1]}'.format(coord)

# ###  格式控制  ###
# 对齐和填充
'{:>30}'.format('right aligned')  # '                 right aligned'
'{:*^30}'.format('centered')  # '***********centered***********'
# 浮点数
'{:+f}; {:+f}'.format(3.14, -6.02)  # '+3.140000; -6.020000'
# 千分位
'{:,}'.format(1234567890)  # '1,234,567,890'

# 格式化时间
import datetime
d = datetime.datetime(2010, 7, 4, 12, 15, 58)
'{:%Y-%m-%d %H:%M:%S}'.format(d)  # '2010-07-04 12:15:58'

re模块可以用于正则表达式的处理。

r'[abcde]'

r'a-zA-Z'

r'[^0-9]'

MatchObject

group()

'Hello(?=World)'

World

Hello

'def'

'abc'

r'(?<=abc)def'

r'[0-9]'

r'[^0-9]'

r'[\t\n\r\f\v]

r'[^\t\n\r\f\v]

import re
#获取字符串中与模式匹配的所有不重叠值，包括空匹配
#如果模式包含分组，将返回与分组匹配的文本列表，如果包含多个分组，则前述列表的每一项都是一个元组
#finditer与之类似，但是返回的是MatchObject的迭代器
#(\D+)(\d+) 结果：[('a', '0'), ('b', '12'), ('c', '345'), ('d', '6789')]
#(\D+)\d+   结果：['a', 'b', 'c', 'd']
#\D+\d+     结果：['a0', 'b12', 'c345', 'd6789']
m = re.findall(r'\D+\d+', 'a0b12c345d6789', re.IGNORECASE)  # 由于正则式特殊字符很多，故一般使用“原始字符串”
print m

r = re.compile(r'\D+\d+', re.IGNORECASE)       #编译得到一个正则式对象
#search()、match()返回MatcherObject对象


s = 'Iggle Piggle and Makka    Pakka are in the night garden'
# match、search等方法返回MatchObject：
# group(n)：返回匹配中第n个分组，如果n==0或者为空，返回整个匹配


# match函数从字符串起始处搜索正则式的匹配，找不到返回None
# 贪婪匹配
print re.match( r'.*ggle', s , re.IGNORECASE ).group()  # Iggle Piggle
# 非贪婪匹配
m = re.match( r'.*?(ggle)', s , re.IGNORECASE )
print m.group()  # Iggle
print m.group( 1 )  # ggle 返回匹配中的第一个分组

# search函数与match类似，但是不限定匹配从字符串首部开始
print re.search( r'.akka', s , re.IGNORECASE ).group()  # Makka

# sub(pattern, repl, string, count, flags) 函数用于字符串替换
# pattern 匹配模式 repl替换文本或回调 string被处理字符串 count需要处理的匹配个数
# 这里使用基于序号的分组，()界定了分组范围，分组可以嵌套：
# (M(\w+))是第一个分组，(\w+)是第二个分组，(P\2)是第三个分组
# repl可以指定转移字符，\g<name>用于引用匹配的正则式分组
print re.sub( r'(M(\w+))\s+(P\2)', '\g<1> \g<3>', s )  # 去掉Makka    Pakka之间多于的空格
# 命名分组，使用(?P<GRP_NAME>)定义命名分组，使用(?P=GRP_NAME)引用命名分组
print re.sub( r'(M(?P<grp1>\w+))\s+(P(?P=grp1))', 'M\g<grp1> \g<3>', s )
# repl还可以是函数
print re.sub( r'(M(?P<grp1>\w+))\s+(P(?P=grp1))', lambda match : match.group().upper(), s )

原因：进行字符串格式化时，如果%后面的参数时元组，那么必须对所有元组成员进行格式化，也就是说，前面的占位符数量要和元组长度一致。

The post 使用Python进行文本处理 appeared first on 绿色记忆.

from socket import *  # @UnusedWildImport
DEFAULT_PORT = 1918
if __name__ == '__main__':
    # 创建基于IPv4的TCP套接字对象
    s = socket( AF_INET, SOCK_STREAM )
    # 绑定到通配符地址的1918端口
    s.bind( ( '0.0.0.0', DEFAULT_PORT ) )
    logging.debug( 'Echo server is listening on port %d', DEFAULT_PORT )
    # 开始监听，最大排队数量(backlog)为10
    s.listen( 10 )
    
    while True:
        # 接受一个客户端连接请求，返回套接字对象和地址的元组
        client, addr = s.accept()
        logging.debug( '%s connected', addr )
        msg = client.recv( 1024 )
        logging.debug( 'Received message : %s', msg )
        client.send( msg )
        client.close()

以下是客户端代码：

from socket import *  # @UnusedWildImport

DEFAULT_PORT = 1918
if __name__ == '__main__':
    # 创建基于IPv4的TCP套接字对象
    s = socket( AF_INET, SOCK_STREAM )
    # 连接到服务器端
    s.connect( ( '127.0.0.1', DEFAULT_PORT ) )
    s.send( 'Hello Server!' )
    logging.debug( 'Echo from server: %s', s.recv( 1024 ) )

asyncore模块将网络活动抽象为事件，由事件循环分派出去进行异步处理。事件循环通过select()或者poll()系统调用构建。

# 主分发器，关联服务器端监听套接字
class EchoSocketDispatcher( asyncore.dispatcher ):
    def __init__( self, port ):
        asyncore.dispatcher.__init__( self )
        # 创建当前分发器关联的套接字对象
        self.create_socket( socket.AF_INET, socket.SOCK_STREAM )
        self.bind( ( '0.0.0.0', port ) )
        self.listen( 1024 )
    def handle_accept( self ):
        client, addr = self.accept()
        logging.debug( 'Accepted connection from %s', addr )
        return EchoDispatcher( client )
# 子分发器，处理单个客户端连接套接字    
class EchoDispatcher( asyncore.dispatcher ):
    
    def __init__( self, client ):
        asyncore.dispatcher.__init__( self, client )
        self.chunk = None
    # 何时允许读
    def readable( self ):
        logging.debug( 'HH' )
        return True
    # 何时允许写
    def writable( self ):
        return self.chunk != None
    # 处理读取
    def handle_read( self ):
        self.chunk = self.recv( 8192 )
        logging.debug( 'Received message: %s', self.chunk )
    # 处理写入
    def handle_write( self ):
        self.send( self.chunk )
        self.chunk = None
    def handle_close( self ):
        logging.debug( 'Connection closed by peer.' )
        asyncore.dispatcher.handle_close( self )
        
DEFAULT_PORT = 1918     
if __name__ == '__main__':
    dispatcher = EchoSocketDispatcher( DEFAULT_PORT )
    logging.debug( 'Start polling on %d', DEFAULT_PORT )
    # 持续执行轮询
    asyncore.loop( use_poll=True, timeout=10 )

# Tasklet、SystemCall、Scheduler模拟了一个微型的操作系统

# 模拟进程
class Tasklet( object ):
    def __init__( self, target ):
        self.target = target  # 当前目标协程
        self.sendval = None  # 协程恢复时发送的值
        self.stack = []  # 历史协程的栈，对方法调用机制的一种模拟
    def run( self ):
        try:
            # 执行协程到下一次退出，并获取协程的返回值
            result = self.target.send( self.sendval )
            if isinstance( result, SystemCall ):
                # 如果是一个“系统调用”包装对象，栈状态不变，类似于中断的效果
                return result
                # 当前目标将期望此系统调用的结果被发送给它，以继续执行
            elif isinstance( result, types.GeneratorType ):
                # 如果结果是一个生成器对象实例，相当于调用一个新方法，需要将当前目标压栈
                self.stack.append( self.target )
                self.sendval = None
                self.target = result
            else:
                # 如果结果不是一个生成器对象实例，相当于新方法调用返回，需要废弃当前目标，并弹出栈顶作为新目标
                if not self.stack : return
                self.sendval = result
                self.target = self.stack.pop()
                
        except StopIteration: 
            # 当前协程已经终止，需要移除，并弹出栈顶作为新的目标
            if not self.stack: raise
            self.sendval = None
            self.target = self.stack.pop()

# 模拟系统调用
class SystemCall( object ):
    def handle( self, sched, task ):
        pass
# 读写“系统调用”实现
class ReadWait( SystemCall ):
    def __init__( self, f ):
        self.file = f
    def handle( self, sched, task ):
        fd = self.file.fileno()
        sched.readwait( task, fd )
class WriteWait( SystemCall ):
    def __init__( self, f ):
        self.file = f
    def handle( self, sched, task ):
        fd = self.file.fileno()
        sched.writewait( task, fd )

# 调度程序，相当于操作系统的调度例程
class Scheduler( object ):
    def __init__( self ):
        # 这个队列相当于操作系统的进程集
        self.task_queue = collections.deque()
        self.read_waiting = {}
        self.write_waiting = {}
        self.taskcount = 0
    def new( self, target ):
        newtask = Tasklet( target )
        self.schedule( newtask )
        self.taskcount += 1
    def schedule( self, task ):
        self.task_queue.append( task )
    def readwait( self, task, fd ):
        self.read_waiting[fd] = task
    def writewait( self, task, fd ):
        self.write_waiting[fd] = task
    def mainloop( self, count=-1, timeout=None ):
        while self.taskcount:
            # 如果有I/O事件的队列，那么先轮询I/O事件
            if self.read_waiting or self.write_waiting:
                # 如果进程队列为空则等待时间为timeout，否则等待时间为0
                # 队列为空的场景：没有创建进程；所有进程都在I/O等待集上
                # timeout默认为一直等待，直到有可能的描述符
                wait = 0 if self.task_queue else timeout
                # 查看一组文件描述符的输入、输出、异常状态。返回输入、输出、异常准备就绪的列表的元组
                # 前三个参数是整数描述符的列表；或者带有fileno()方法的对象（该方法返回文件描述符）
                # wait不指定会一直等待直到至少一个文件描述符准备好为止，为0则指进行一次轮询即返回
                r, w , e = select.select( self.read_waiting, self.write_waiting, [], wait )
                # 将就绪的文件描述符从等待集中移除，加入到正常调度集中
                for fd in r:
                    self.schedule( self.read_waiting.pop( fd ) )
                for fd in w:
                    self.schedule( self.write_waiting.pop( fd ) )
            # 逐个执行队列上的任务
            while self.task_queue:
                # 取出一个任务，从进程列表中移除
                task = self.task_queue.popleft()
                try:
                    # 执行这个任务
                    result = task.run()
                    if isinstance( result, SystemCall ):
                        # 模拟系统调用陷入内核
                        result.handle( self, task )
                    else: 
                        # 其它的，要么相当于方法调用，要么相当于方法返回，继续调度
                        self.schedule( task )
                except StopIteration :
                    # 不需要再考虑此任务，其生命周期已经结束
                    self.taskcount -= 1
            else:
                if count > 0: count -= 1
                if count == 0:
                    return

# Echo服务器协程
from socket import socket, AF_INET, SOCK_STREAM
def EchoServer( host, port , sched ):
    # 服务器监听套接字
    s = socket( AF_INET, SOCK_STREAM )
    s.bind( ( host , port ) )
    logging.debug( 'EchoServer listening on %s:%d', host, port )
    s.listen( 128 )
    while True:
        # 等待服务器监听套接字可读
        yield ReadWait( s )
        conn, addr = s.accept()
        logging.debug( 'Client connected: %s', addr )
        sched.new( EchoSocket( conn ) )
def EchoSocket( conn ):
    while True:
        # 等待套接字可读
        yield ReadWait( conn )
        chunk = conn.recv( 1024 )
        if chunk:
            logging.debug( 'Received message: %s', chunk )
            yield WriteWait( conn )
            conn.send( chunk )
            

if __name__ == '__main__':
    sched = Scheduler()
    sched.new( EchoServer( '0.0.0.0', 1918, sched ) )
    sched.mainloop( -1, None )

The post Python网络编程 appeared first on 绿色记忆.

一个运行的程序称作进程。每个进程都有自己的系统状态，包括内存、已打开文件列表、用于跟踪正在执行的指令的程序计数器以及用于保存函数的局部变量的调用栈。通常在一个控制流序列中， 进程逐条执行语句，这一般称为进程的主线程。在任何一个给定的时刻，程序都只做一件事情。 程序可以使用库函数创建新的进程，比如os或subprocess模块中的函数（例如os.fork()、 subprocess.Popen等)。这些叫做子进程的进程是作为完全独立的实体运行的。 每个子进程都有自己的私有系统状态和执行主线程。因为子进程是独立的，所以它可以与原始进程并发执行。也就是说，创建子进程的进程可以继续处理别的事情，同时子进程在后台执行它自己的任务。

尽管进程是孤立的，但它们可以彼此通信，这称为进程间通信（Interprocess Communication, IPC)。 进程间通信的最常见形式是基于消息传递。一条消息就是一块原始字节的缓存。然后，就可以使用像 send()和recv()这样的简单操作，通过一个I/O通道（如管道或网络套接字）来传输或接收消息。另一种不太常见的IPC机制依赖于内存映射区域（参见nmap模块)。借助内存映射，进程可以创建共享的内存区域。如果对这些内存区域进行修改，那么査看这些区域的所有进程都能看到这些修改。 如果需要同时处理多个任务，可以在一个应用程序内使用多个进程，每个进程负责处理一部分工 作。

另一种将工作细分为多个任务的方法是使用线程。线程类似于进程，也具有自己的控制流和执行栈。但线程运行在创建它的进程内部，它们共享所有的数据和系统资源。当应用程序需要并发执行多个任务时，可以使用线程，但可能存在大量需要在各个任务之间共享的系统状态。

使用多个进程或线程时，主机操作系统负责安排它们的工作。安排的具体做法是：给每个进程（线程）分配一个小的时间片，并在所有活动任务之间快速循环——给每个任务分配一部分可用的CPU周期。例如，如果系统同时运行10个活动的进程，操作系统将给每个进程分配大约1/10的CPU时间，同时在进程之间快速循环。在具有多个CPU核心的系统上，操作系统在安排进程时可以尽可能使用每个 CPU，从而并行执行进程。 编写使用并发执行的程序原本就很复杂，其复杂性的一个主要原因就是同步和访问共享数据。也就是说，多个任务同时更新一个数据结构可能导致数据损坏和程序状态不一致（这个问题的正式说法是竞争条件）。要解决这些问题，并发程序必须找出关键的代码段，并使用互斥锁和其他类似的同步手段保护它们。例如，如果不同的线程尝试同时向一个文件写入数据，可以使用互斥锁来同步它们的

在大多数系统上，Python同时支持消息传递和基于线程的并发编程。Python线程受到的限制有很多，Python解释器使用了内部的GIL (Global Interpreter Lock，全局解释器锁定），在任意指定的时刻只允许单个 Python线程执行。无论系统上存在多少个可用的CPU核心，这限制了 Python程序只能在一个处理器上 运行。如果一个应用程序的大部分是I/O受限（bounded）的，那么使用线程一般没有问题，因为额外的处理器对于花费大多数时间等待事件的程序帮助不大。对于涉及大量CPU处理的应用程序而言，使用线程来细分工作没有任何好处，反而还会降低程序的运行速度。

避免大量使用线程的较为常见的做法是把这类应用程序重新构造为异步事件处理系统。例如，中心的事件循环可以监控使用select模块的所有I/O,并将异步事件分离给大量I/O 处理器。这是诸如asyncore这样的库模块和诸如Twisted等流行的第三方模块的基础。

如果要在Python中进行各种类型的并发编程，消息传递很可能是必须熟练掌握的概念。 即便使用线程，常推荐的方法也是将应用程序的结构设计为大量独立的线程集合，这些线程通过消息队列交换数据。这种特别的方法往往很少出错，因为它极大地减少了对使用锁定和其他同步手段的需求。消息传递还会自然扩展到网络和分布式系统中。消息传递的抽象也与髙级Python功能（如协程）有关。例如，协程是可以接收并处 理发送给它的消息的函数。因此，掌握了消息传递之后，写出的程序会较之前更灵活。

该模块为在子进程中运行任务、通信和共享数据，以及执行各种形式的同步提供支持。接口风格与threading模块类似，但要注意进程之间没有任何共享状态。

1. 确保进程之间传递的所有数据都能够序列化
2. 避免使用共享数据，尽可能使用消息传递和队列。使用消息传递时，不必过于担心同步、锁定和其他问题。当进程的数量增长时，它往往还能提供更好的扩展
3. 在必须行在单独进程中的函数内部，不要使用全局变量而应当显式地传递参数
4. 尽量不要在同一个程序中混合使用线程和多线程处理
5. 特別要注意关闭进程的方式。一般而言，需要显式地关闭进程，并使用一种定义良好的终止模式，而不要仅仅依赖于垃圾收集或者被迫使用terminate ()操作强制终止子进程
6. 管理器和代理的使用与分布式计算中的多个概念密切相关（例如，分布式对象)
7. 尽管此模块可以工作在Windows上，但还是应该仔细阅读官方文档中的各种微妙细节
8. 最重要的一点是：尽量让事情变得简单

进程是multiprocessing模块的核心，其构造函数如下：

Process([group [, target [, name [, args [, kwargs ]]]]])
# group 预留参数
# target 进程启动时需要执行的可调用对象
# name  进程名称的描述性字符串
# args 传递给target的位置参数的元组
# kwargs 传递个target的关键字参数的字典

Process具有以下实例方法、属性：

简单的例子：

import multiprocessing
import time
def clock(interval):
    while True:
        print "Current time is %s" % time.ctime()
        time.sleep(interval)
if __name__ == '__main__':
    p = multiprocessing.Process(
        target=clock,
        args=(15,)
    )
    p.start()

#使用扩展子类的方式
class ClockProcess(multiprocessing.Process):
    def __init__(self,interval):
        multiprocessing.Process.__init__(self)
        self.interval = interval
    def run(self):
        while True:
            print "Current time is %s" % time.ctime()
            time.sleep(self.interval)

multiprocessing模块支持进程间通信的两种主要形式：管道和队列，这两种方法都是使用消息传递实现的。

使用Queue([maxsize])可以创建队列，maxsize是队列中允许的最大项数，省略表示无穷大，具有以下实例方法：

使用JoinableQueue([maxsize])可以创建可连接的共享队列，允许消费者通知生产者消息项已经被成功处理，具有额外的方法：

使用队列通信的例子：

import multiprocessing
def consumer(inputq):
    while True:
        item = inputq.get()
        if item == -1: break    #特殊标记时终止
        print item
        inputq.task_done()
def produce(seq, outputq):
    for item in seq:
        outputq.put(item)
if __name__ == '__main__':
    q = multiprocessing.JoinableQueue()
    cons_p = multiprocessing.Process(target=consumer, args=(q,))
    cons_p.daemon = True
    cons_p.start()
    #这里可以继续创建多个消费者进程，但是每个消息只能被一个进程消费
    seq = [0, 1, 2, 3, 4 , -1]  #特殊标记，提示消费者流程结束
    produce(seq, q)
    q.join()  # 当前进程等待队列被消耗完毕

可以在进程之间创建一根管道：

#创建管道的函数：duplex表示是否双向通信，默认True
#如果duplex=False，那么conn1只能接收，conn2只能发送
(conn1,conn2) = Pipe([duplex])

Pipe函数的返回值为Connection对象的元组，Connection对象具有以下属性和方法：

如果生产者或消费者中都没有使用管道的某个端点，就应将其关闭。如果忘记执行这越步骤，程序可能在消费者中的recv()操作上挂起。管道是由操作系统进行引用计数的， 必须在所有进程中关闭管道后才能生成EOFError异常。因此，在生产者中关闭管道不会有任何效果， 除非消费者也关闭了相同的管道端点。

使用管道的生产者——消费者的例子：

import multiprocessing
def consumer(pipe):
    outputp, inputp = pipe
    inputp.close()  # 关闭消费者的输入通道
    while True:
        try:
            item = outputp.recv()
        except EOFError:
            break
        print item
    print "Consumer done"
def produce(seq, inputp):
    for item in seq:
        inputp.send(item)

if __name__ == '__main__':
    (outputp, inputp) = multiprocessing.Pipe(True)
    cons_p = multiprocessing.Process(target=consumer, args=((outputp, inputp),))
    cons_p.start()
    outputp.close()  # 关闭生产者的输出通道
    seq = [0, 1, 2, 3, 4]
    produce(seq, inputp)
    # 关闭输入通道
    inputp.close()
    # 等待消费者进程关闭
    cons_p.join()

双向通信的例子：

import multiprocessing
def server(pipe):
    serverp, clientp = pipe
    clientp.close()                #服务器不会使用管道的另一端
    while True:
        try:
            x, y = serverp.recv()  #接收请求消息
        except EOFError:           #如果客户端关闭了管道另一端
            print "Pipe endpoint closed by peer"
            break
        result = x + y
        serverp.send(result)       # 返回处理结果
    print "Server done"
if __name__ == '__main__':
    (serverp, clientp) = multiprocessing.Pipe(True)
    s = multiprocessing.Process(target=server, args=((serverp, clientp),))
    s.start()
    
    #客户端逻辑部分
    serverp.close()                #客户端不会使用管道的另一端
    clientp.send((1, 1))           #发送请求消息
    print clientp.recv()           #打印处理结果
    
    clientp.send(('Hello',' World'))
    print clientp.recv() 
    clientp.close()
    s.join()                       #等待子进程结束

Pool类可用于创建进程池，可以把各种数据处理任务提交给进程池处理：

#构造函数
Pool( [numprocess [, initializer [, initargs]]])
# numprocess   池中的进程数，省略则使用cpu_count()的值
# initializer  进程启动时执行的可调用对象，默认None
# initargs     传递给initializer的参数

Pool的实例支持以下方法： 

AsyncResult的实例支持以下方法：

通常，进程之间彼此是完全孤立的，唯一的通信方式是队列或管道。可以使用两个对象来表示共享数据。这些对象使用了共享内存（通过mmap模块）使访问多个进程成为可能。可以创建以下类型的共享数据：

可以使用以下功能与threading模块类似的同步原语：

结合信号量来把数组发送给另外一个进程的例子：

import multiprocessing
class FloatChannel(object):
    def __init__(self, maxsize):
        self.buffer = multiprocessing.RawArray('d', maxsize)
        self.buffer_len = multiprocessing.Value('i')
        self.empty = multiprocessing.Semaphore(1)
        self.full = multiprocessing.Semaphore(0)
    def send(self, values):
        # 等待缓冲区为空的信号
        self.empty.acquire()
        n = len(values)
        self.buffer_len = n
        self.buffer[:n] = values
        # 设置缓冲区已满的标记
        self.full.release()
    def recv(self):
        self.full.acquire()
        # 复制缓冲区中的值，注意可以使用切片语法
        values = self.buffer[:self.buffer_len.value]
        # 设置缓冲区已空的标记
        self.empty.release()
        return values
    
def consumer(count , fc):
    for i in xrange(count):
        fc.recv()
        
if __name__ == '__main__':
    fc = FloatChannel(100000)
    p = multiprocessing.Process(target=consumer, args=(1000, fc))
    p.start()
    
    values = [float(x) for x in xrange(100000)]
    for i in xrange(1000):
        fc.send(values)
    print "Produce done"
    p.join()

上一节的数据同步，只能使用共享值、数组等基本类型，如果需要使用Python对象则无能为力。Python提供了“管理器”这种独立的子进程，可以用于管理多个进程之间的共享对象。“管理器”作为服务器进程来运行，其他进程则通过代理访问共享对象，相当于客户端。

使用Manager()函数可以创建一个管理器，其返回位于multiprocessing.managers模块中的SyncManager对象

使用multiprocessing模块的程序可以与运行在同一台计算机上的其他进程或者位于远程系统 上的进程进行消息传递。可以使用Client来连接到其它进程：

#位于multiprocessing.connections子模块
connections.Client (address [, family [, authenticate [, authkey]]])
#address       代表网络地址的元组(hostname, port)
#family        表示地址格式的字符串，省略则从address自动推断
#authenticate  是否使用摘要身份验证
#authkey       包含身份验证密钥的字符串，省略则使用current_process().authkey

对方进程必须作为服务器，处于监听状态：

connections.Listener([address, [,family [, backlog[, authenticate [,authkey]]]]])

Listener的实例具有以下方法或属性： 

下面是一个简单的例子：

def server():
    from multiprocessing.connection import Listener
    serv = Listener(('127.0.0.1', 15000), authkey="12345")
    while True:
        conn = serv.accept()
        while True:
            try :
                x, y = conn.recv()
            except EOFError:  # 如果客户端断开连接
                print "Connection closed by peer"
                break
            result = x + y
            conn.send(result)
        conn.close()

if __name__ == '__main__':
    import multiprocessing
    s = multiprocessing.Process(target=server)
    s.start()
    from multiprocessing.connection import Client
    conn = Client(('127.0.0.1', 15000), authkey="12345")
    conn.send((1, 1))
    print conn.recv()
    conn.close()

该模块提供Thread类和各种同步原语，用于编写多线程的程序。

Thread类用于表本单独的控制线程。使用下面的函数可以创建一个新线程:

Thread (group=None, target=None, name=None, args=(), kwarga={})
# group 预留字段
# target 可调用对象，线程启动时，其run方法将调用该对象
# name 线程的名称
# args、kwargs 传递给target的参数

线程支持以下实例方法和属性：

下面是一个使用线程的例子：

import threading
import time
class ClockThread(threading.Thread):
    #除了__init__、run以外，改写别的方法
    def __init__(self, interval):
        threading.Thread.__init__(self)   #子类如果扩展__init__，必须调用Thread的构造函数
        self.daemon = True
        self.interval = interval
    def run(self):
        while True:
            print "Current time is %s" % time.ctime()
            time.sleep(self.interval)
if __name__ == '__main__':
    t = ClockThread(15)
    t.start()   
    time.sleep(150)

用于延迟执行某一函数：

Timer(interval, func [, args [, kwargs]])
#interval 延迟执行的秒数
#func 需要执行的函数
#args、kwargs 函数参数

Timer具有以下实例方法：

锁定是一个同步原语，状态是“已锁定”或“未锁定”之一。两个方法acquire() 和release()用于修改锁定的状态。如果状态为已锁定，尝试获取锁定将被阻塞，直到锁定被释放为 止。如果有多个线程等待获取锁定，当锁定被释放时，只有一个线程能获得它。等待线程获得锁定的顺序没有定义

使用构造函数Lock()可以创建锁的实例，初始状态为未锁定。具有以下实例方法：

使用诸如Lock、RLock或Semphore之类的锁定原语时，必须多加小心。锁定的错误管理经常导致死锁或者竞态条件。可以使用下面代码中提到的两种方式保证锁的正确释放：

import threading
lock = threading.Lock()
#方法一：使用try-finally语句
try:
    lock.acquire()
    #执行同步操作
finally:
    lock.release()
#方法二：使用上下文管理协议
#进入时自动获取锁定，离开时自动释放锁定
with lock:
    #执行同步操作
    pass

此外，应当尽量避免同时获取多个锁定，容易导致死锁。

可重入锁定是一个类似于Lock同步原语，但同一个线程可以多次获取它。这允许拥有锁定的线程执行嵌套的acquire()和release()操作。在这种情况下，只有最外面的release()操作才能将锁定重置为未锁定状态。进行若干次lock()后，必须在进行对应次数的release()才能彻底释放锁。

信号量是一个基于计数器的同步原语，每次调用acquire()方法时此计数器减1，每次调用 release()方法时此计数器加1。如果计数器为0, acquire ()方法将会阻塞，直到其他线程调用release ()方法为止。

可以使用Semaphore([value])来创建信号量，其中value为计数器的初始值，默认为1。信号量包含以下实例方法：

BoundedSemaphore的行为与Semaphore相同，但是限制但release()操作的次数不能超过acquire()的次数。

事件用于在线程之间通信。一个线程发出“事件”信号，一个或多个其他线程等待它，具有以下实例方法：

条件变量是构建在另一个锁定上的同步原语，当需要线程关注特定的状态变化或事件的发生时将使用这个锁定。典型的用法是生产者-消费者场景，其中一个线程生产的数据供另一个线程使用。使用构造函数Condition([lock])可以创建条件变量，其中lock是Lock或者RLock的实例，如果不提供则创建新的锁供食用。Condition具有以下实例方法：

条件变量的简单例子：

import threading
c = threading.Condition()
def producer():
    while True:
        c.acquire()
        produce_item()
        c.notify()
        c.release()
#使用条件变量时需要注意的是，如果存在多个线程等待同一个条件，notify()操作可能唤醒它们
#中的一个或多个（这种行为通常取决于底层的操作系统)。因此，始终有这样的可能：某个线程被
#唤醒后，其等待的条件已经不满足，因此可能需要循环继续等待下一个信号
def consumer():
    while True:
        c.acquire()
        while not item_is_available():
            #释放锁定，生产者可以获取并生产物品
            c.wait()
        c.release()
        consume_item()

线程没有任何方法可用于强制终止或挂起。这是设计上的原因，因为如果某个线程已经获取了锁定，在它能够释放锁定之前强制终止或挂起它，将导致整个应用程序出现死锁。此外，终止时一般不能简单地“释放锁定”，因为复杂的线程同步经常涉及锁定和解除锁定操作，而这些操作在执行时的次序要十分精确。 如果要为终止或挂起提供支持，需要自己构建这些功能。一般的做法是在循环中运行线程，这个循环的作用是定期检査线程状态以决定它是否应该终止

Python解释器被一个锁定保护，该锁定只允许一次执行一个线程，即便存在多个可用的处理器。 在计算密集型程序中，这严重限制了线程的作用。事实上，在计算密集型程序中使用线程，经常比仅仅按照顺序执行同样的工作慢得多。因此，实际上应该只在主要关注I/O的程序，如网络服务器中使用线程。对于计算密集程度更高的任务，最好使用C扩展模块或multiprocessing模块来代替。C扩展具有释放解释器锁定和并行运行的选项，可以做到当释放锁定时不与解释器进行交互。 multiprocessing模块将工作分派给不受锁定限制的单独子进程

queue模块（在Python 2中叫Queue)实现了各种多生产者——多消费者队列，可用于在执行的多个线程之间安全地交换信息。 该模块定义了3种不同的队列类：

队列具有以下实例方法：

使用队列一般可以简化多线程的程序。例如，可以使用共享队列将线程连接在一起，而不必依赖于必须由锁定保护的共享状态。在这种模型中，工作者线程一般充当数据的消费者。下面是一个简单的例子：

import threading 
from queue import Queue
class WorkerThread(threading.Thread):	
   def __init__(self,*args,**kwargs)： 
       threading.Thread.__init__(self, *args, **kwargs) 
       self.input_queue = Queue()
   def send(self,item):
       self.input_queue.put(item)
   def close(self):
       self.input_queue.put(None) 
       self.input_queue.join()
   def run(self):
       while True:
           item = self.input_queue.get()
           if item is None:
               break
           print item #处理条目
           self.input_queue.task_done()
       self.input_queue.task_done()
       return
#使用示例
w = WorkerThread()
w.start()
w.send('Hello')   #把条目发送给工作线程处理
w.close()

上面的例子几乎完全等同于协程。如果要执行的工作不涉及任何阻塞操作，可以将run()方法重新实现为协程，这就省却了使用线程的麻烦。后一种方法的运行速度可能更快，因为节省了线程上下文切换带来的开销

在某些类型的应用程序中，可以使用一个任务调度器和一些生成器或协程实现协作式用户空间多线程，这有时称为微线程。这种技术的一种常见用法是在需要管理大量的已打开文件或套接字的程序中，例如一台需要同时管理 1000个客户端连接的网络服务器。此时的解决方案是联合使用异步I/O或轮询（使用select模块）与处理I/O事件的任务调度器，而不是创建1000个线程，因为过多的线程会导致大量系统资源浪费在上下文切换上。 这种编程技术的基础概念是这样产生的：生成器或协程函数中的yield语句挂起函数的执行，直到稍后使用next () 或者send()操作进行恢复为止。这样就可以使用一个调度器循环在一组生成器函数之间协作多个任务。

基于协程的并发编程的例子：基于协程技术实现的异步Echo服务

The post Python并发编程 appeared first on 绿色记忆.

1. Windows：可以使用WinPython，这是一个免安装、开箱即用的Python发布版，包含很多预置工具
2. Linux：通常已经随操作系统安装

%PYTHON_HOME%;%PYTHON_HOME%\Scripts

%PYTHON_HOME%\Lib;%PYTHON_HOME%\Lib\site-packages

python -c "import sys; print ('\n'.join(x for x in sys.path if x))"

Ubuntu14.04.3自带的Python版本时2.7.6和3.4.3。你可以下载并构建自己的版本，但是不要全局的安装，替换系统的python2、python3符号链接可能导致系统无法工作。

下面的脚本示例如何安装3.5版本的Python：

cd ~/Downloads/3.5.1
./configure --prefix=$HOME/Python/3.5.1
make && make install

# 检查PYTHONPATH
cd $HOME/Python/3.5.1/bin
./python3 -c "import sys; print ('\n'.join(x for x in sys.path if x))"
# 输出如下：
# /home/alex/Python/3.5.1/lib/python35.zip
# /home/alex/Python/3.5.1/lib/python3.5
# /home/alex/Python/3.5.1/lib/python3.5/plat-linux
# /home/alex/Python/3.5.1/lib/python3.5/lib-dynload
# /home/alex/Python/3.5.1/lib/python3.5/site-packages

Ubuntu下，Python解释器的默认安装位置为/usr/bin/python；Windows下是C:\python27。需要将其添加到环境变量PATH中，然后打开Shell窗口：

#运行交互式的解释器
python
#输入文件结束符（Unix的Ctrl+D、Windows的Ctrl+Z）可以退出解释器
#调用quit()函数亦可退出解释器

#启动解释器并执行命令，应当用单引号包围命令，防止有空格之类的特殊字符
python -c command [arg] ...

#调用作为脚本使用的模块
python -m module [arg] ...

调用解释器时，脚本名、参数传入字符串列表sys.argv中，该列表至少有一个元素。

1. 没有给定脚本名、参数时，sys.argv[0] = ''
2. 脚本名指定为标准输入时，sys.argv[0] = '-'
3. 使用-c参数调用解释器时，sys.argv[0] = '-c'
4. 使用-m参数调用解释器时，sys.argv[0]  = 模块全名

从终端读取命令并执行，称为交互模式，以主提示符（>>>）为依据执行，输入多行结构，则需要附加从属提示符（...），例如：

>>> if name == 'Alex':
...     print "Hello " + name
...
Hello Alex

有错误发生时，解释器在stderr上打印错误信息、调用栈跟踪。在交互模式下，会返回主提示符；如果从文件输入执行，则以非零状态退出。
使用try的except子句可以捕获异常

Linux下，Python脚本可以直接执行（需要chmod +x）：

#! /usr/bin/env python
...

在Windows下，安装程序会把*.py与python.exe关联，可以双击执行，*pyw类似，但是不显示控制台窗口

如果需要让解释器在每次启动时均执行一个脚本，可以设置环境变量：PYTHONSTARTUP，这类似于Linux Shell的.profile文件

钩子方法sitecustomize、usercustomize用于提供本地化。

print "The answer is", 2*2
print("The answer is", 2*2)
# 可以定制打印项之间的分隔符
print("There are <", 2**32, "> possibilities!", sep="")

字典的

dict.keys()

dict.items()

dict.values()

k = d.keys();
k.sort()       # ERR
k = sorted(d)  # OK

map()

filter()

zip()

list()

result = [ x for x in map()]

在Python 3中，使用文本和（二进制）数据两个概念，来代替Uincode字符串和8-bit字符串。所有文本都是基于Unicode的，但是编码后的Unicode表示为二进制数据。存储文本的类型是

str

bytes

不再需要使用u前缀来表示文本：

u"..."

b"..."

任何混合文本、数据的操作会导致TypeError。你必须明确的进行转换：

# 编码为二进制数据
str.encode() 
# 编码为Unicode文本
bytes.decode()

在原始字符串中，反斜杠被原样看待，例如：

r'\u20ac'

PEP 3107 – Function Annotations引入了为函数添加任何元数据（注解）的能力，注意这些注解没有任何具体语义，不改变函数的运行时行为，仅仅用于文档、类型提示（这是最重要的用法）以及为第三方框架提供信息。

语法形式：

def my_function(arg1: annotation1, arg2: annotation2) -> annotation3:

# 类型提示的例子：
def greet(name: str, age: int) -> str:
    return f"Hello, {name}! You are {age} years old."

调用函数时，这种参数必须使用关键字参数语法来传入。要定义仅关键字参数，使用一个

*

def my_function(arg1, *, kwarg1, kwarg2):
    print(f"arg1: {arg1}, kwarg1: {kwarg1}, kwarg2: {kwarg2}")

my_function(10, kwarg1="a", kwarg2="b")

用于直接对外层作用域（非顶级作用域）中的变量进行赋值：

def outer_function():
    outer_var = 10

    def inner_function():
        nonlocal outer_var  # Declare outer_var as nonlocal to access it from the outer_function scope
        outer_var += 5

用于接收迭代器中所有其它对象：

(a, *rest, b) = range(5)     # rest为 [1, 2, 3 ]

类似与列表推导：

{k: v for k, v in stuff}

squares = {i: i**2 for i in range(1, 6)}
even_squares = {i: i**2 for i in range(1, 11) if i % 2 == 0}

例如：

{1, 2}

set()

集合推导的语法和列表推导一样：

{x for x in stuff}

0o720
0b1010

# 不在支持：
class C:
    __metaclass__ = M

# 新语法：
class C(metaclass=M):

原先字典迭代的顺序是任意的，可以使用

collections.OrderedDict

from collections import OrderedDict

# Creating an OrderedDict
fruits = OrderedDict([
    ('apple', 4),
    ('banana', 6),
    ('orange', 2),
    ('grapes', 10),
])

# Adding a new item to the OrderedDict
fruits['strawberry'] = 8

# Output: apple -> 4, banana -> 6, orange -> 2, grapes -> 10, strawberry -> 8
for fruit, count in fruits.items():
    print(f"{fruit} -> {count}", end=", ")

print("{}, {}".format("a", "b"))  # It now implicitly auto-numbers the fields. Output: "a, b"
print("{:,}".format(9876543210))  # The comma format specifier. Output: "9,876,543,210"

import math

nums = [1e20, 1, -1e20]
print(sum(nums))       # Result: 0.0, which can have an accumulated error
print(math.fsum(nums)) # Result: 1.0, a mathematically accurate summation

强大、灵活的命令行参数解析模块，支持位置参数、子命令等：

import argparse

def main():
    parser = argparse.ArgumentParser(description="A simple script demonstrating argparse.")
    parser.add_argument("-n", "--name", required=True, help="Your name")
    parser.add_argument("-a", "--age", type=int, help="Your age")
    
    args = parser.parse_args()
    
    print(f"Hello, {args.name}!")
    if args.age:
        print(f"You are {args.age} years old.")

if __name__ == "__main__":
    main()

提供了基于线程/进程等方式来异步执行callable的高层接口，简化了工作线程、进程的管理：

import concurrent.futures
import time

def perform_work(n):
    time.sleep(n)
    return f"Work completed after {n} seconds"

# Run two tasks concurrently using ThreadPoolExecutor:
with concurrent.futures.ThreadPoolExecutor() as executor:
    work_items = [2, 3]
    results = [executor.submit(perform_work, n) for n in work_items]

    for result in concurrent.futures.as_completed(results):
        print(result.result())

# Run two tasks concurrently using ProcessPoolExecutor:
with concurrent.futures.ProcessPoolExecutor() as executor:
    work_items = [2, 3]
    results = [executor.submit(perform_work, n) for n in work_items]

    for result in concurrent.futures.as_completed(results):
        print(result.result())

该表达式允许一个生成器将它的部分操作，委托给另外一个生成器。当一个生成器在迭代由另外一个生成器产生的条目时，可以简化代码。

def concat_gen(list_of_generators):
    for gen in list_of_generators:
        yield from gen   # 每次调用触发一次yield，第一个生成器完毕后，才循环到第二个

gen1 = (x for x in range(1, 4))  # Generates 1, 2, 3
gen2 = (x for x in range(4, 7))  # Generates 4, 5, 6

# Concatenate the generators using `yield from`
result_gen = concat_gen([gen1, gen2])

for x in result_gen:
    print(x)

# Output: 1, 2, 3, 4, 5, 6

用于代替第三方虚拟（隔离）环境模块virtualenv。pyvenv脚本用于管理虚拟环境。

# Create a virtual environment
python -m venv my_virtual_env

# Activate the virtual environment (on Linux or macOS)
source my_virtual_env/bin/activate

# Activate the virtual environment (on Windows)
my_virtual_env\Scripts\activate.bat

# Install packages within the virtual environment
pip install requests

# Deactivate the virtual environment when done
deactivate

支持基于LZMA算法的压缩，也就是那些扩展名为.xz  .7z  .lzma的压缩包。

import lzma

data = b"Example data that will be compressed using LZMA."

# Compress data using LZMA
compressed_data = lzma.compress(data)

# Decompress the data back to its original form
original_data = lzma.decompress(compressed_data)

assert data == original_data, "Decompressed data should match the original data."

用于在关键事件（例如段错误）时dump出Python的调用栈。

import faulthandler
import os
import time
import sys

# Enable faulthandler to dump tracebacks to a file
with open("traceback.log", "w") as logfile:
    faulthandler.dump_traceback(file=logfile)

# You can also enable fault handling for uncaught exceptions and signals (e.g., SIGSEGV)
faulthandler.enable(file=sys.stderr, all_threads=True)

# Your program code...
time.sleep(1)

引入一种机制，允许单个包跨越多个目录，可以实现更好的模块化，并且让过大的包易于维护。例如对于下面的目录结构：

dir1/
    my_package/
        __init__.py
        module1.py

dir2/
    my_package/
        # no __init__.py file needed
        module2.py

可以将my_package看作单一的命名空间包，不需要任何额外配置，导入该包中定义的两个模块：

from my_package.module1 import class1
from my_package.module2 import class2

 这个模块用于实现异步IO、并发编程。从3.5开始，可以利用关键字

async

await

import asyncio

async def hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

async def main():
    # Schedule two coroutines to run concurrently
    task1 = asyncio.create_task(hello())
    task2 = asyncio.create_task(hello())

    await task1
    await task2

# Execute main asynchronously using asyncio.run (Python 3.7 and later)
asyncio.run(main())

 注意，对async函数的调用，会得到一个协程（或者生成器），而不是直接同步的执行函数体：

# 异步函数（协程）
async def async_function():
    return 1
print(type(async_function()) is types.CoroutineType)
 
 
# 异步生成器
async def async_generator():
    yield 1
print(type(async_generator()) is types.AsyncGeneratorType)

你可以向操作普通协程那样，对其调用send()：

try:
    async_function().send(None)
except StopIteration as e:
    # 生成器/协程在正常返回退出时会抛出一个StopIteration异常，而原来的返回值会存放在StopIteration对象的value属性中
    print(e.value)

在async函数中，可以使用await挂起自身，并等待另外一个协程的结果：

async def async_function():
    return 1
 
async def await_coroutine():
    # await语法只能出现在通过async修饰的函数中，否则会报SyntaxError错误
    result = await async_function()
    print(result)
    
run(await_coroutine())



# 注意 await后面必须跟着一个 Awaitable，或者实现了 __await__ 方法：
class Awaitable(metaclass=ABCMeta):
    __slots__ = ()
 
    @abstractmethod
    def __await__(self):
        yield
 
    @classmethod
    def __subclasshook__(cls, C):
        if cls is Awaitable:
            return _check_methods(C, "__await__")
        return NotImplemente

可以方便的定义简单的枚举类。

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# Usage examples
print(Color.RED)        # Output: Color.RED
print(Color.RED.name)   # Output: RED
print(Color.RED.value)  # Output: 1

# 可以让枚举类同时继承A，这样它就有了A类型的能力，例如用在需要A的地方

用于简化文件系统路径操作。

from pathlib import Path

path = Path("example.txt")

# Check if the file exists
if not path.exists():
    # Create a new file and write some content
    path.write_text("Hello, World!")

# Read file content
content = path.read_text()
print(content)  # Output: Hello, World!

# List all files in the current directory
for file_path in Path(".").iterdir():
    print(file_path) 

为pickle增加了新版本（4）的默认协议，支持更加高效的、针对大规模数据结构的串行化。

import pickle

data = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
}

# Serialize data using protocol version 4 (new in Python 3.4)
serialized = pickle.dumps(data, protocol=4)

# Deserialize the data back to a Python object
deserialized_data = pickle.loads(serialized)

assert data == deserialized_data, "Deserialized data should match the original data."

提供了事件驱动的IO框架、在套接字以及其它非阻塞IO上的多路复用的IO操作支持。

# This example shows how to use `selectors` for a simple echo server.
# For brevity, error handling is omitted. This example is for Linux/Unix-based systems using `selectors.DefaultSelector`.
import socket
import selectors

sel = selectors.DefaultSelector()

def accept(sock):
    conn, addr = sock.accept()
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)

def read(conn):
    received_data = conn.recv(1000)
    if received_data:
        # Echo the received data back to the client
        conn.sendall(received_data)
    else:
        # Connection closed, unregister the socket from selector
        sel.unregister(conn)
        conn.close()

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('localhost', 1234))
server_socket.listen(5)
server_socket.setblocking(False)
sel.register(server_socket, selectors.EVENT_READ, accept)

while True:
    events = sel.select()
    for key, _ in events:
        key.data(key.fileobj) 

通过装饰器

functools.singledispatch

from functools import singledispatch

@singledispatch
def process_data(data):
    print(f"Unknown data type: {data}")

@process_data.register(int)
def _(data: int):
    print(f"Processing integer data: {data}")

@process_data.register(str)
def _(data: str):
    print(f"Processing string data: {data}")

process_data(42)         # Output: Processing integer data: 42
process_data("Hello")    # Output: Processing string data: Hello
process_data([1, 2, 3])  # Output: Unknown data type: [1, 2, 3]

import numpy as np

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6], [7, 8]])

mat_product = mat1 @ mat2  # Matrix multiplication using new @ operator

# Output: array([[19, 22], [43, 50]])
print(mat_product)

可以在单个函数调用、单个推导（comprehension）操作中，从多个可迭代对象中解包多个元素：

a = [1, 2]
b = [3, 4, 5]

# Merging lists using unpacking generalizations
merged_list = [*a, *b]  # Output: [1, 2, 3, 4, 5]

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

merged_dict = {**dict1, **dict2}  # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

包

typing

from typing import List, Dict

#                列表值类型            字典键值了类型       非容器类型
def greet(names: List[str], age_dict: Dict[str, int]) -> str:
    greetings = []
    for name in names:
        age = age_dict.get(name)
        greeting = f"Hello, {name}! You are {age} years old."
        greetings.append(greeting)
    return "\n".join(greetings)

names_list = ["Alice", "Bob", "Charlie"]
ages_dict = {"Alice": 25, "Bob": 30, "Charlie": 35}

result = greet(names_list, ages_dict)
print(result)

除了常用的集合类型容器，typing模块还提供了：

1. Optional

   ：用于提示参数或者字段是可选的

2. Union

   ：用于提示参数可能是多个类型之一

3. Any

   ：不限制类型

4. Callable

   ：提示参数是可调用的

对于复杂的、反复使用的类型提示，可以定义别名：

Person = Tuple[str, int]
People = List[Person]

这个语句初始化一个异步的上下文管理器。异步上下文管理器对象必须实现特定的方法，以创建/清理临时上下文，即使有异常抛出，清理工作也会执行。需要实现的方法如下：

1. async def __aenter__(self)

   ：进入async with块时该方法被调用

2. async def __aexit__(self, exc_type, exc_value, traceback)

   ：离开块时该方法被调用

示例：

import aiofiles

async def read_file(file_name: str) -> str:
    async with aiofiles.open(file_name, mode="r") as f:
        text = await f.read()
    return text

和同步的上下文管理器的主要区别是：资源创建、主体逻辑、资源清理都是异步进行的，而后者这三个操作是同步进行（即在同一个事件循环中、阻塞其它操作）。

name = "John"
age = 25
print(f"Hello, my name is {name} and I'm {age} years old.")

one_million = 1_000_000
print(f"One million is written as {one_million}.")

count: int = 0
def greet(name: str) -> str:
    return f'Hello, {name}'

print(greet("John"))

可以对列表、集合、字典以及列表推导、生成器等使用

async for

import asyncio

async def ticker(delay, to):
    """Yield numbers from 0 to `to` every `delay` seconds."""
    for i in range(to):
        yield i
        await asyncio.sleep(delay)

async def run():
    # 这里的迭代是异步进行的
    async for i in ticker(1, 5):
        print(i)

asyncio.run(run())

这个特性使得使用前向引用（forward references ，即引用尚未定义的类型）和生命类型提示变得简单，不再需要在类型注解中使用字符串直接量。

当存在类型之间的循环引用时，类型注解可能会导致问题，为了解决此问题，需要使用字符串直接量：

class A:
    def x(self) -> "B":  # Using string literal for forward reference
        pass

class B:
    def y(self) -> A:
        pass

有了该特性后，则可以：

from __future__ import annotations  # Import annotations from __future__

class A:
    def x(self) -> B:  # No need for string literal
        pass

class B:
    def y(self) -> A:
        pass

这个模块提供了一个装饰器，用来装饰一个仅仅用来存放数据的类型：

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p1 = Point(1.0, 2.5)
p2 = Point(3.5, 0.5)

print(p1)  # Output: Point(x=1.0, y=2.5)
print(p2)  # Output: Point(x=3.5, y=0.5)

调用该函数，可以直接从代码进入Python Debugger（PDB），可以方便调试：

def divide(a, b):
    breakpoint()  # Debugger will be triggered here
    return a / b

result = divide(4, 2)

支持将赋值作为表达式的一部分：

n = 10
while (squared := n * n) < 100:
    print(squared)
    n += 1

支持指定某些函数参数，必须以位置参数的形式传入：

def my_function(pos1, pos2, /, pos_or_kwarg1, *, kwarg1, kwarg2):
    pass

# Allowed:
my_function(1, 2, 3, kwarg1=4, kwarg2=5)

# Not allowed:
my_function(1, 2, pos_or_kwarg1=3, kwarg1=4, kwarg2=5)

符号

/

内置函数可以用来逆转字典键值对顺序：

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
reversed_items = list(reversed(my_dict.items()))

print(reversed_items)  # Output: [('d', 4), ('c', 3), ('b', 2), ('a', 1)]

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

merged = dict1 | dict2
print(merged)  # Output: {"a": 1, "b": 3, "c": 4}

dict1 |= dict2
print(dict1)  # Output: {"a": 1, "b": 3, "c": 4}

移除字符串前后缀的新方法：

filename = "document.pdf"

name = filename.removesuffix(".pdf")
print(name)  # Output: "document"

name = filename.removeprefix("docu")
print(name)  # Output: "ment.pdf"

from datetime import datetime
from zoneinfo import ZoneInfo

dt = datetime(2021, 1, 1, tzinfo=ZoneInfo("America/New_York"))
print(dt)  # Output: 2021-01-01 00:00:00-05:00

在老版本，你必须借助typing模块：

from typing import List

def process_numbers(numbers: List[int]) -> None:
    for number in numbers:
        print(number * 2)

新版本中直接使用内置类型：

def process_dict(data: dict[str, int]):
    for key, value in data.items():
        print(key, value * 2)

def process_tuple(data: tuple[int, int, int]):
    for value in data:
        print(value * 2)

def process_set(data: set[int]):
    for value in data:
        print(value * 2)

需要注意，某些库可能仍然依赖旧的语法。

不再需要Union

# Before Python 3.10 Release
from typing import Union
def f(list: List[Union[int, str]], param: Optional[int]):
    pass

# In Python 3.10 Release
def f(list: List[int | str], param: int | None):
    pass

# Calling the function
f([1, “abc”], None)

def process_number(number):
    match number:
        case 1:
            print("One")
        case 2:
            print("Two")
        case _:
            print("Other")

process_number(1)  # Output: One
process_number(5)  # Output: Other 

使用match - case语句，可以对复杂结构进行模式匹配：

def process_data(data):
    match data:
        case None:
            print("No data")
        case {"status": "success", "result": int(result)}:
            print(f"Success: {result}")
        case {"status": "error", "message": str(message)}:
            print(f"Error: {message}")
        case _:
            print("Unknown data format")

with open("file1.txt") as file1, open("file2.txt") as file2:  # Before Python 3.10
    pass

# In Python 3.10
with (
    open("file1.txt") as file1,
    open("file2.txt") as file2,
):
    pass

异常组让相关的异常被一起处理。

在Python中，所有异常均是BaseException的子类型。异常具有一个message参数来提供消息：

raise SyntaxError("Just raising a syntax error")

 使用try - except块可以捕获并处理异常：

try:
   prin(34/0)
except (ZeroDivisionError, NameError) as exc:
   print(exc)
except  XxError as e:
   pass

这种处理方式有以下限制：

1. 一次只能处理一个异常
2. 仅仅会执行第一个匹配的except块

ExceptionGroup

print(issubclass(ExceptionGroup, Exception))

raise ExceptionGroup("exception groups", [ValueError(1), TypeError(2)]) 

try:
    raise ExceptionGroup("An exception group", [ValueError(), TypeError(1)])
except ExceptionGroup:
    print("I caught an exception group")

异常组的第二参数，是组中包含的异常的列表。你可以捕获其中任何成员：

try:
     raise ExceptionGroup("An exception group", [ValueError(), \
     TypeError(1)])
except TypeError:
     print("I am handling the TypeError in the exception group")

使用特殊的

except *

try:
    raise ExceptionGroup("An exception group", [ValueError(), TypeError(1)])
except * TypeError:
    print("I am handling a Type error")
except * ValueError:
    print("I am handling a ValueError")

# I am handling a Type error
# I am handling a ValueError 

from typing import TypeVar

T0 = TypeVar("T0")
T1 = TypeVar("T1")

def flip(pair: tuple[T0, T1]) -> tuple[T1, T0]:
    first, second = pair
    return (second, first)

这个特殊的类型表示当前类的类型。

from typing import Self

class Article:
   def a_method_that_returns_an_instance(self) -> Self:
       ...

这个类型允许容器类型具有任意数量的元素类型：

from typing import TypeVarTuple, TypeVar, Tuple

TS = TypeVarTuple("TS")
T = TypeVar("T")
def example(value_1:Tuple[T, *TS]):  # 必须使用*解包语法
   ...


example(value_1=(1, 'a number', 3.0))

用于限定字典具有哪些键值、值的类型：

from typing import TypedDict

class ArticleType(TypedDict):
   article_id: int
   title: str
   rating: float


article_1: ArticleType = {
   "article_id": 23,
   "title": "Introducing the new features in Python 3.11",
   "rating":4.5
}

在3.11，你可以控制某个键值是否为必须：

from typing import TypedDict, Required, NotRequired

class ArticleType(TypedDict):
   article_id: Required[int]
   title: NotRequired[str]
   rating: float

Python的每个语句以换行符结束，如果太长，可以使用续行符（反斜杠）跨行

a = math.cos(3 * (x - n)) + \
    math.sin(3 * (x - n))

使用三引号定义的字符串、列表、元组或字典分布在多行上时，不需要使用续行符。

缩进用于表示不同的代码块，如函数体、条件语句、循环和类。代码块中首条语句的缩进可以任意的，但是后续语句必须与之保持一致。

如果函数体、分支、循环等较短，可以放在一行，不需要缩进：

if a: pass

应当使用空格，而不是制表符进行缩进。

变量标识符仅支持：数字、下划线、A-Za-z，并且数字不能作为标识符的开头。标识符区分大小写。

以下划线开始或结束的标识符具有特殊含义：

1. 以单下划线开头的标识符不能通过from module import *导入
2. __func__用于定义特殊方法
3. __priv用于定义类私有成员

#Python中，整数的位数是任意的
bigInt = 15156165496484919616
#不同进制的整数
0644        #八进制
0x100fea8   #十六进制
0b1110001   #二进制
#浮点数表示
3.14
1.2334e+02
#使用等号赋值
width = 20
#整数与浮点数运算时，自动转换为浮点数
3 * 3.75 / 1.5
#实数的类型转换函数：int、float、long等
int(3.75)

#支持复数，j（或者J）表示虚部
z = 1.5 + 0.5j
#获取实部、虚部
z.real
z.imag

标识符True和False被解释为布尔值，其整数值分别是1和0。

字符串、列表、元组，统称为序列类型。序列类型具有共同的特征：

1. 支持索引访问，例如s[0]
2. 支持切片运算符，例如s[0:5]，对于可变序列，还可以删除切片，例如del s[i:j]
3. 使用len(s)可以返回序列长度
4. 使用min(s)、max(s)可以返回序列中元素的最小最大值
5. 使用all(s)、any(s)可以检查是否每个元素、存在任何元素为True

支持双引号或者单引号的字符串。Python字符串是不可变的。

#使用单引号、双引号定义多行文本，必须在行尾添加换行+续行符，行首的空白符也会被识别
str = "This is a long string\n   \
    containing two lines os text \
"

#可以用三引号对来标识字符串，不需要\n转义
"""
Hello there
Greetings
"""

#原始字符串，不进行转义
str = r"\n is just \n"
#字符串可以使用+来连接，使用*来重复：
str = str + str * str

#字符串切片，起始索引、结束索引如果不指定，分别为0、字符串长度
#容错：如果结束索引过大，自动认为等于字符串长度，如果开始索引小于结束索引，返回空串
str = HelpA
word[4] == 'A'
word[0:2] == 'He'
#如果索引为负数，则表示从右侧算索引
word[-1] = 'A'
word[-2] = 'p'
word[-2:] = 'pA'
word[-0] = 'H' #-0就作为0看待
word[:] = 'HelpA'  #这种特殊的写法表示返回完整的字符串

#字符串相关函数
len(s) #返回字符串的长度
str(3.4) #转换为字符串
repr(3.4)#转化为字符串，显示为对象内部精确值：3.3999999999999999
format(3.4,'0.5f') #格式化输出3.40000

Python 2.0以后引入Unicode，来表示Unicode字符串，必要时可以与原始字符串进行转换：

#使用u前缀表示Unicode字符串
str = u"蟒蛇"
#使用Unicode转义\u****来插入特殊Unicode字符
str = u"Hello\u0020World"
#Unicode字符串的原始模式（不进行转义）
str = ur"Hello\u0020World"

利用str()函数进行转换时，会使用默认编码（通常是ASCII）：

>>> str(u"蟒蛇")
Traceback (most recent call last):
  File "", line 1, in 
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

可以使用encode方法来获取特定编码的16进制转写：

u"蟒蛇".encode('utf-8')
#内置函数unicode可以使用所有已注册的Unicode编码来解码
unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')

#列表的元素可以是不同的类型
a = ['spam', 'eggs', 100, 1234]
#类似字符串，列表可以被切片或者连接，切片返回浅拷贝的副本
a[0] == 'spam'
a[-2] == 100
a[:2] + ['bacon', 2*2] == ['spam', 'eggs', 'bacon', 4]
a = [1, 2, 3] + [4, 5]  #连接列表

#内置函数len可以用于获取列表的长度
len(2)

#相关方法
a = list()  #等价于a = []
a.append(1) #在尾部插入元素
a.insert(2,200) #插入元素到指定索引位置

在圆括号里面包含一组值，即为元组。元组创建后，不能修改其内容（替换、添加或者删除元素）。使用元组代替小列表，更加节约内存

corp = ("3203001102256", "徐州工业集团", 3200) #定义元组
corp = "3203001102256", "徐州工业集团", 3200   #这样也可以识别元组
a = ()   #空元组
b = (1,) #一元组，注意结尾的逗号
c = 1,   #一元组

#可以使用数字索引获取元组中的值，但是更常见的做法是将元组解包为一组变量
regNo, corpName, regCapi = corp

集合是无序的、不包含重复元素的对象组：

s = set ([3,5,9,10])	#创建一个数值集合
t = set ("Hello")	#创建包含4个字符的集合（两个l只能保存一个在集合中）

#集合运算符
a = t | s   #t和S的并集
a = t & s   #t和s的交集
a = t - s   #求差集（项在t中，但不在s中）
a = t ^ s   #对称差集（项在t或S中，但不会同时出现在二者中）

#集合方法
t.add('x')  #添加一个项
s.update([10,37,42])#添加多个项
t.remove('H') #删除一个项

字典就是关联数组（散列表）。字符串、元组等可以作为散列键，但是可变对象例如列表、字典则不可以作为键。

prices = {
    "GOOG" : 490.10, 
    "APPL" : 123.50, 
    "IBM"  : 91.50, 
    "MSFT" : 52.13
}

#创建空字典
prices = {}
prices = dict()

#使用in运算符可以测试某个项是否字典成员
if "GOOG" in prices:
    p = prices["GOOG"]

#相关函数
keys = list(prices) #获取关键字的列表
del prices["GOOG"]  #删除字典元素

#相关方法
p = prices.get("GOOG", 0.0) #如果不存在，返回0.0

None是一个特殊的类型，用于表示null对象。
如果一个函数没有显式的返回值，则自动返回None。布尔求值时为False

x = int(raw_input("Please enter an integer: "))
if x < 0:
    x = 0
    print 'Negative changed to zero'
elif x == 0:
    print 'Zero'
elif x == 1:
    print 'Single'
else:
    print 'More'

#条件表达式简写
minvalue = a if a <= b else b

a = ['cat', 'window', 'defenestrate']
for x in a:
    print x, len(x) #逗号分隔的print可以连续打印不换行
#打印：
#cat 3
#window 6
#defenestrate 12

#迭代列表的副本，以便安全的修改列表
for x in a[:]:
    if len(x) > 6: a.insert(0, x)
    elif False : continue
    elif False : break
    elif False : pass     #什么都不做，作为语法占位符

#使用range函数可以生成一个等差级数俩表：
range(10)             #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(5, 10)          #[5, 6, 7, 8, 9]
range(-10, -100, -30) #[-10, -40, -70] 第三个参数为步长

#迭代一个列表
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print i, a[i]
#或者
for item in a:
    print item
#解包一个序列，变量个数必须与序列元素个数一致
for x,y,z in s:
    pass
#内置函数enumerate，迭代序列，返回索引、元素组成的元组
for i,x in enumerate(s):
    pass
#同时迭代两个以上的序列，使用内置的zip函数
for x,y,z in zip(r,s,t):
    pass
#迭代一个字典
c = {"GOOG": 490.10, "IBM":91.50 }
for key in c:
    print key, c[key]

#打印一个文件中所有行
f = open("foo.txt")
for line in f:
    print line

#关键字def引入函数定义，其后必须跟有函数名、形参列表
def reminder(a, b):
#函数体必须缩进，可以添加docstring
    """docstring"""   #使用remider.__doc__可以访问文档字符串
    q = a // b        #截断除法运算符
    r = a - q * b
    return r          #如果省略return语句，自动返回None
#如果函数要返回多个值，可以使用元组
def divide(a, b):
    q = a // b
    r = a - q*b
    return (q, r)

#形参可以具有默认值
def connect(host ,port, timeout = 300):
    h0 = host   #在函数体内创建的变量，作用域是局部的，函数退出后自动销毁
    global h0 = host #使用此关键字来修改全局变量的值
    pass

#位置参数：要使用函数，只需要传入实参列表即可，参数数量、顺序必须匹配，否则引发TypeError
reminder(88, 3)
#可以省略提供默认值的参数
connect('gmem.cc', 80)
#关键字参数：可以按照任意顺序提供参数，但是需要提供形参名称
connect(port = 80, host = 'gmem.cc')

#使用可变对象作为形参默认值，会导致意外的行为：每次调用，可能使用同一个对象
def add(x, items=[]):
    items.append(x)
    return items
add(1)          #返回[1]
add(2)          #返回[1, 2]，不符合预期

#在最后一个参数前面加*，可以接受任意数量的位置参数，自动存入元组
def fprintf(file, fmt, *args):
    file.write(fmt % args)
fprintf(out,"%d %s %f", 42, "hello world", 3.45) #args == (42, "hello world", 3.45)

#在最后一个参数前加**，则所有额外的关键字参数存入字典
def make_tab(data, **params):
    fc = params.pop('fgcolor','black')
make_tab(items, fgcolor='red')

#位置参数与关键字参数可以一起使用，**必须出现在最后面
#编写代理、包装器函数时，经常需要使用*args、**kwargs
def func(*args, **kwargs):
    pass

Python支持类型注解：

# Python 3 类型注解写法
#         参数类型
#                        返回值类型
def add(x:int, y:int) -> int:
    return x + y

# Python 2写法
def add(x, y):
    return x + y

类型注解的作用是，让开发人员直观的了解返回值类型，让IDE能够进行自动的类型推导。对解释器的行为不产生任何影响。 

对于容器类型，需要从

typing

from typing import List, Dict, Tuple, Sequence

# 可以指定容器元素类型
def list() -> List[float]: pass

# 可以定义类型别名
Vector = List[float]
def list() -> Vector: pass


# 复杂的类型注解
ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]

# 这样也可以
Sequence[Tuple[Tuple[str, int], Dict[str, str]]]

所谓方法是指在类定义中定义的函数。包含实例方法、类方法、静态方法三种：

class Obj(object):
    def instance_method(self,arg):  #实例会作为第一个参数传入
        pass
    @classmethod
    def class_method(cls,arg):      #类对象本身会作为第一个参数传入
        pass
    @staticmethod
    def static_method(arg):
        pass


#方法的查找
o = Obj()
method = o.instance_method          #绑定方法，绑定了o对象
method(100)                         #o作为隐含的第一个参数传入
method = Obj.instance_method        #非绑定方法，没有绑定对象
method(o,100)                       #需要手工传入作为self的对象

如果一个函数里面具有yield关键字，则称为生成器。调用生成器得到返回值是一个迭代器对象，这一调用本身不会执行生成器的任何代码。

如果生成器中存在return语句，则执行到return时抛出StopIteration并终止迭代。

#斐波那契數列的生成器
def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max:
        #在执行时，每次遇到yield就会返回当前迭代值，并且中断执行 
        yield b  
        #下一次调用next()，在上一次中断的下一行执行，上下文与之前一致
        a, b = b, a + b 
        n = n + 1

#调用，获取生成器实例
#虽然看起来与函数调用语法一致，但是不会执行任何函数代码
#直到执行其next()方法时，才会真正调用函数代码
for n in fab(5):  #隐含调用next()
    print n 
#手工调用next()方法
iter = fab(5)
iter.next()

#判断一个函数是否为生成器
from inspect import isgeneratorfunction 
isgeneratorfunction(fab)

上面的生成器，实际上是一种协程，协程与普通函数（Subroutine/function）的执行方式有很大的不同：

1. 子例程的起始处是惟一的入口点，一旦退出即完成了子例程的执行，子例程的一个实例只会返回一次
2. 协程可以通过yield来调用其它协程。通过yield方式转移执行权的协程之间不是调用者与被调用者的关系，而是一种对等关系
3. 协程的起始处是第一个入口点，协程返回点之后（yield之后一句）是接下来的入口点
4. 子例程的生命期遵循后进先出（最后一个被调用的子例程最先返回），而协程的生命周期完全由他们的使用的需要决定

下面是一个使用协程的例子：两个吃货到餐馆用餐，每次上完菜后就马上被他们吃掉，并继续索要新的食物，一个厨师、一个侍者为他俩服务：

from random import randint
from time import sleep
# 贪吃鬼：
def Gourmand( name ):
    dish = []
    while True:
        if len( dish ) == 0:
            logging.debug( '%s is so hungry, food, quick!' , name )
            # 递上盘子，等待服务员给予食物
            dish.extend( ( yield ) )
        else:
            logging.debug( '%s ate: %s', name, dish.pop() )
# 大厨
all_food = ['Wine', 'Meat', 'Beer', 'Cheese']
def Cook():
    while True:
        new_food = []
        logging.debug( 'Preparing food, please wait...' )
        time = randint( 5, 30 )
        sleep( time )
        for i in range( randint( 1, len( all_food ) - 1 ) ):
            new_food.append( all_food[randint( 0, len( all_food ) - 1 )] )
        # 返回本次制作的食物
        logging.debug( '%d new food finished in %d secs', len( new_food ), time )
        yield new_food
# 服务员        
if __name__ == '__main__':
    c = Cook()
    alex = Gourmand( 'Alex' )
    meng = Gourmand( 'Meng' )
    alex.next()
    meng.next()
    while True:
        # 新菜刚上给这两吃货，他们就会马上将其吃光，并继续索要
        alex.send( c.next() )
        meng.send( c.next() )

所谓新式类是指从object或者其它新式类衍生出的类，而旧式类是Python2中没有明确指定基类的类。Python3中只有新式类。

Python中所有变量皆为对象。使用 __func__这样形式的函数名来实现特殊方法（例如list的__add__实现了+运算符）。

class Stack(object):              #继承语法：继承object，所有Python类的根类
    fast_mode = True              #类变量
    def __init__(self):           #特殊方法：用于在创建对象后进行初始化
        self.stack =[]            #实例变量
    def push(self,object):        #每个实例方法的第一个参数均执行对象本身，即self
        self.stack.append(object) #涉及对象属性的操作，均必须显式使用self变量
    def pop(self):
        return self.stack.pop() 
    def length(self):
        return len(self.stack)
 
    @staticmethod                 #装饰器：定义静态方法，静态方法仅仅是定义在类的命名空间
    def create():
        pass
    
    @classmethod                  #装饰器：定义类方法，类方法对类对象本身进行操作，第一个参数cls为当前类
    def create(cls): 
        return cls()              #可以调用cls来创建合适类型的对象，静态方法做不到这一点
    
    class Inner:                  #Python支持内部类
        pass
#使用类创建对象
s = Stack()
del s         #删除对象

#类似于C++的函数对象：定义__call__方法
class FuncObj:
    def __call__(arg0):
        pass

fo = FuncObj()
fo(1)

eval(repr(o))

def __str__(self):
    return unicode(self).encode('utf-8')

it = s.__iter__()
while True :
    try:
        it.next()
    except StopIteration:
        break

如果一个Python程序出现错误，则会引发异常，打印类似下面的信息：

Traceback (most recent call last)： 
 File "foo.py", line 12, in 
IOError: [Errno 2] No such file or directory: 'file.txt'

错误信息中包含了错误的类型、出错的代码位置。如果不做任何处理，异常会导致程序终止，除非使用try-except语句：

try:
    f = open('Readme.txt')
except IOError as e:       #如果发生IOError，则被捕获并且存放在e变量中
    print e


#raise用于手工触发异常
raise RuntimeError("Error occurred")
#如果raise没有指定任何参数，则再次引发最近一次生成的异常（仅正在处理前一个异常时）
try:
    pass
except RuntimeError as e:
    raise

未捕获的异常将向上传递，如果到程序最顶级仍然没有处理，则导致解析器终止并打印消息。可以把未捕获的异常传递给用户自定义的

sys.excepthook()

可以使用try-except-else语句块，else在没有引发异常时执行；可以使用try-except-finally语句块，finally总是执行：

try:
    f = open('Readme.txt','r')
except IOError as e:
    error_log.write('Failed to open file:%s\n' % e)
else:
    data = f.read()
    f.close()
finally: #如果发生异常，控制权首先交给finally代码块，执行完毕后再进行异常处理
    f.close()

Python预定义了以下异常：

close()

可以创建以Exception为父类的新类，作为自定义异常类：

#简单的例子
class NetworkError(Exception)： pass
#使用该异常
raise NetworkError('Cannot find host')

#自定义异常可以包含多个构造参数
class DeviceError(Exception):
    def __init__(self, errno, msg):
        self.args = (errno, msg)
#使用该异常
raise DeviceError(1,'Not Responding')

assert语句用于在程序中设置断言，格式为：

assert test [,msg]
#test为一表达式，如果为False，则触发AssertionError，并使用msg指定的消息内容

 使用-O选项使解释器运行于最优模式时，不会执行断言代码。

除非使用-O选项，内置只读变量

__debug__

该机制主要用于在Python中安全的进行资源（数据库连接、事务、文件句柄等）管理。

使用with语句，可以在一个“上下文管理器”对象的控制下执行一系列的语句：

with context [as var]:   #执行context.__enter__(self)方法，返回值存入var
    pass
#执行context.__exit__(self, type, value, traceback)方法

#举例：锁
import threading
lock = threading.Lock()
with lock:
    pass
#执行完毕后自动清除锁定

#自动关闭打开的文件
with open( sys.argv[1] ) as infile :
    for line in infile:
        print line

上下文管理器对象必须实现：

随着程序规模的扩大，有必要根据功能不同把代码分散在不同的文件中，作为单独的模块，并在需要使用时进行导入。

在Python中，模块名就是相应脚本文件的basename。当导入一个模块时，自动创建一个名字空间来存放模块定义的对象，默认此名字空间与模块名相同：

#file:  div.py
def divide(a, b):
    q = a/b
    r = a - q*b
    return (q, r)


#file:  main.py
import div                #导入div模块，创建了div名字空间
dir(div)                  #列出名字空间下的内容
q, r= div.divide(100,17)  #使用模块中的函数，需要加前缀
import div as d           #为导入的模块启用别名

from div import divide    #把某个具体的定义导入到当前名字空间
q, r = divide(100,18)     #不再需要使用名字空间作为前缀

在其它语言里面比较少见的数学运算符有：截断除法(//)、乘方(**)。

内置函数包括：绝对值(abs)、商与余数(divmod)、四舍五入(round)等。

序列包括：字符串、列表和元组。支持以下运算符或者函数：

set和frozenset用于支持常见的集合操作：

1. 每次执行函数时，自动创建局部命名空间，其内包括函数参数、函数体内定义的变量
2. 解释器解析变量名称时，首先从局部命名空间开始；如果找不到，则搜索函数的全局命名空间（定义该函数的模块）；仍然找不到，则搜索内置命名空间；再找不到则NameError
3. 除非在函数里使用global语句，否则不会改变全局命名空间变量的值，但是可以访问全局变量的值
   

   i = 1
   def func():
       print i   #打印1
       i = 2
       print i   #打印2
   func()
   print i       #仍然打印1
   
   def func1():
       global i  #现在i位于全局名字空间
       i - 2     #修改成功

4. Python支持嵌套函数定义，使用词法作用域来绑定嵌套函数中的变量——首先检查其局部作用域，然后检查外部嵌套函数的作用域，以此类推。在Python2中，只能对局部作用域、全局作用域进行变量赋值，对外部嵌套函数中定义的变量进行赋值是不支持的，Python3可以使用nonlocal语句解决此问题
5. 使用尚未赋值的局部变量，导致UnboundLocalError

作为First-class对象的函数，可以当作数据传递给其他函数。把函数作为数据来处理时，它自动携带定义函数的上下文信息（变量）。

将函数主体语句、语句的执行环境上下文信息一起打包时，得到的对象称为闭包。由于任意函数都携带定义其它的模块的全局命名空间信息（__globals__），因此本质上任何Python函数都是闭包。

装饰器是一个函数，用于包装一个函数或者类，目的是修改、增强被包装对象的功能。特殊符号@用于表示装饰器语法：

@trace
def square (x) : 
    return x*x
#上述代码等价于
def square (x) : 
    return x*x
square = trace(square)

#trace函数的定义——类似于切面，它必然返回一个函数
def trace(func)：
    def callf(*args,**kwargs):
        debug_log.write( "Calling %s： %s, %s\n" % (func.__name__, args, kwargs) )  #记录日志
        r = func(*args, **kwargs)     #调用原本的函数
        debug_log.write( "%s returned %s\n" % (func.__name__, r) )
    return callf

可以声明多个装饰器，每个装饰器必须独占一行，最后定义的装饰器，最先包装到原始函数上：

@foo
@bar
def func(x):
    pass
#等价于
func = foo(bar(func))

装饰器可以带有参数：

@eventhandler('BUTTON')
def handle_button(msg):
    pass
#带有参数的装饰器，装饰目标函数的步骤如下：
temp = eventhandler('BUTTON')       #使用参数调用装饰器，其应当仍然返回一个装饰器
handle_button = temp(handle_button) #使用生成的装饰器来装饰目标函数

装饰器也可以应用于类，这样的装饰器应当返回类对象作为结果。 下面是一个例子：

def talking(cls: type):
    setattr(cls, 'talk', lambda self: print('Hello, I am %s' % str(self)))
    return cls


@talking
class person(object):
    def __init__(self, name: str):
        self.name = name

    def __str__(self):
        return self.name.upper()


if __name__ == '__main__':
    p = person('Alex Wong')
    p.talk()  #Hello, I am ALEX WONG 

使用yield关键字可以定义一个生成器对象，该对象本质上是一个函数，其生成一个值序列，在迭代中使用：

def countdown(n):
    while n > 0:
        print('Counting down from %d' % n)
        yield n
        n -= 1
    return   #生成器不能返回除了None以外的任何值

#调用该函数，不会打印任何信息：
c = countdown(10)
#相反，返回值c是一个生成器函数，当c.next()被调用时，countdown函数被执行
#调用next()函数时，代码会正常执行，直到遇到yield语句为止，并返回yield指定的值
#通常不需要手工调用next()函数，而是在for、sum等使用序列的操作中自动调用：
for n in countdown(10):
    pass
a = sum(countdown(10))

当生成器函数遇到return语句或者StopIteration异常，则其退出。

可选的，调用

close()

yield语句可以作为右值，通过该方式使用yield的函数称为协程：

def receiver():
    print('Prepare to receive')
    while True:
        n = (yield)
        #协程的目的是对发送给它的值做出处理
        print('Got %s' % n)

#使用协程
r = receiver()
r.next()       #执行到第一条yield语句，该调用必不可少
r.send(1)      #发送值给协程，导致其运行直到下一条yield语句
r.send('Greetings')

由于协程使用时next()调用必不可少，因此可以使用类似下面的装饰器自动完成：

def coroutine(func):
    def start(*args,**kwargs)：
        g = func(*args,**kwargs) 
        g.next() 
        return g 
    return start

协程一般是无限期运行的，可以调用close()方法显式关闭。关闭后，再调用send()会导致StopIteration异常。注意close方法会在协程内部引发GeneratorExit异常。

使用throw()方法可以在协程内部触发异常，该异常在yield语句处出现。使用throw()给协程发送异步信号是不安全的。

如果协程的yield提供值，那么将自动返回给send()方法的返回值：

def line_splitter(d = None):
    result = None
    while True:
        #读出line，返回result
        line = (yield result)
        result = line.split(d)

ls = line_splitter()
ls.next()                 #执行到第一次遇到yield
ls.send('X,Y,Z')          #触发继续执行，直到下一次遇到yield。因此返回['X','Y','Z']

当通过使用yield返回值、throw()时需要注意，send()给协程的值将作为throw()的返回值返回。

1. 数据流处理程序，类似于Unix Shell管道
2. 实现某种形式的并发，例如使用某个任务管理器，把数据分发给数百个执行各种具体任务的协程

Python使用“列表推导”（List comprehension）运算符，来把函数应用到列表的每个项，并根据结果创建新的列表，例如下面的操作：

nums = [1, 2, 3, 4, 5]
squares = []
for n in nums:
    squares.append(n * n);

可以使用列表推导改写为：

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]  #列表推导

列表推导的语法如下：

[expression for iteml in iterablel if conditionl
            for item2 in iterable2 if condition2
            ……
            for itemN in iterableN if conditionN ]

#上面的语法等价于
s = []
for item1 in iterable1:
    if condition1:
        for item2 in iterable1:  
            if condition2:
            ...
                for itemN in iterableN:  
                    if conditionN: s.append(expression)  #最终是为了计算结果列表

#举例
a = [-3,5,2,-10,7,8] 
b = 'abc'
c = [2*s for s in a]             #[-6,10,4,-20,14,16]
d = [s for s in a if s >= 0]     #[5,2,7,8]
e = [(x,y) for x in a            #如果推导结果元素为元组，必须放入括号内
           for y in b            #[(5,'a'),(5,'b'),(5,'c')......]
           if x > 0 ]
f = [(1,2),(3,4),(5,6)]
g = [x+y for x,y in f]           #[3,7,11]

注意：Python2的列表推导迭代变量在当前作用域中求值，在列表推导完毕后，其值仍然保留。在Python3中，迭代变量是私有的，推导结束即无效。

生成器表达式与列表包含非常类似，但是它只是生成获取结果的规则，而不是生成结果本身：

#语法差异仅仅是把方括号换成花括号
(expression for iteml in iterablel if conditionl
            for item2 in iterable2 if condition2
            ……
            for itemN in iterableN if conditionN )

#举例
a = (1, 2, 3, 4)
b = (10*i for i in a)   #生成一个生成器
b.next()                #10

#list函数可以把生成器表达式转换为序列
list(b)

使用lambda语句可以创建匿名函数：

lambda args: expression
#args为逗号分隔的参数列表
#expression为使用参数的表达式
a = lambda x,y : x + y
r = a(1,2)   #r=3
#lambda主要用于指定短小的回调函数
names.sort(key = lambda n: n.lower())

lambda语句中不能出现多条语句或者非表达式语句（for、while等）。作用域规则与函数相同

sys.getrecursionlimit ()返回当前解释器对递归深度的限制，默认1000。

递归不能用在生成器函数、协程中。

可以为函数指定任意属性，这些属性会包含在__dict__属性中。

#eval执行一个表达式字符串并返回结果
eval (str [, globals [, locals]])
#exec执行任意包含Python代码的字符串
exec (str [, globals [, locals]])

eval、exec均在调用者的变量作用域中执行，可选的globals、locals用于映射全局、局部名字空间。

对于反复执行的代码，最好使用compile将其编译为字节码，提高性能：

s = "for i in range(0,10): print(i)"
c = compile(s, '', 'exec')  #编译为代码对象
exec(c)

1. Python没有类作用域一说，如果需要访问对象的其它属性，必须以self.开头
2. 派生类不会自动调用基类的__init__方法

3. super(cls, instance).***

    用于在基类上执行属性查找，Python3直接简化为

   super().***

   
   

   class MoreEvilAccount(EvilAccount):
       def deposit(self, amount):
           self.withdraw(5)
           super(MoreEvilAccount,self).deposit(amount) #调用父类的方法实现

4. Python支持多重继承，示例：
   

   #使用逗号分隔的基类列表
   class MostEvilAccount(EvilAccount, DepositCharge, WithdrawCharge)：pass

5. 通常应当避免使用多重继承。有时，可以使用多重继承来定义混入类（mixin）。混入类定义了需要混合到其它类中的一组方法，以添加功能，它通常假定其它方法/属性存在，并以这些方法/属性为基础构建新的逻辑
6. 动态绑定（多态性）：不考虑实例的类型的情况下使用实例，只要以obj.attr的形式访问属性，解释器就会按实例本身内部 - 实例的类定义 - 基类的类定义的顺序来搜索attr，返回第一个匹配。此绑定过程的关键在于它与obj的类型独立，只要它就有attr属性，就可成功绑定（鸭子类型识别）。动态绑定可以用于组件解耦，例如，可以针对具有某个方法集的对象编写代码，而不需要考虑其属于何种类型。
7. 静态方法是普通的函数，只是定义在类的名字空间中；类方法的第一个参数是当前类本身；实例方法的第一个参数是当前对象本身

property是一种特殊的属性，在访问时，会计算它的值：

class Circle(object):
    def __init__(self,radius):
        self.radius = radius
    #属性定义
    @property  #该装饰器支持简单属性风格访问后续定义的方法
    def area(self):
        return math.pi * self.radius**2

#使用
c = Circle(5)
c.area    #访问属性，导致area()方法被调用

向property添加setter、deleter方法，可以实现设置、删除属性操作：

class Foo(object):
    def __init__(self,name):
        self.__name = name 
    @property                        #属性读取
    def name(self):
        return self.__name           #实际存储的变量名任意，但是必须和property名不同
    @name.setter                     #属性设置
    def name(self,value):            #setter、deleter的方法名称必须与属性原始方法名一致
        if not isinstance(value,str):
            raise TypeError("string value required.")
            self.__name = value 
    @name.deleter                    #属性删除
    def name(self):
        raise TypeError("Unsupported operation")

#使用
f = Foo()
name = f.name  #调用f.name()
f.name = 50    #调用f.name(f,50)，抛出TypeError
del f.name     #调用f.name(f)，抛出TypeError

另外，getter、setter、deleter风格的方法也是支持的，但是建议使用装饰器，更加简洁，不会显示大量的getter、setter等方法：

class Foo(object):
    def getname(self):
        return self.__name
    def setname(self,name):
        self.__name = name
    def delname(self):
        raise TypeError("Unsupported operation")

Python约定以__开头的方法为私有方法，这些方法会自动变形：

__func

__classname__func

Python使用引用计数作为基础垃圾回收算法。每个对象都具有一个引用计数，将对象赋给一个新变量、将其放入容器时，均会导致该计数增加，使用

del

引用计数算法具有无法处理循环引用的天生缺陷，为此Python解释器会定期执行一个“循环检测器”，搜索不可访问的对象循环引用，并删除之。

Python类实例的创建包括两个步骤：

1. 使用特殊的

   __new__()

    方法创建实例
2. 使用

   __init__()

    方法初始化实例

其中类方法__new__方法很少需要用户定义，除了以下两个场景：

1. 在继承一个不变类型的基类时，用于修改对象的值
2. 定义元类时使用

实例创建完毕后，Python将管理其引用计数，当引用计数为0时，实例立即被销毁，其

__del__()

定义了__del__() 的对象无法被Python的循环垃圾收集器回收。可以使用

weakref.ref()

通过定义特殊变量

__slots__

class Account(object):
    #定义该变量后，只能设置列出的属性，否则抛出AttributeError
    __slots__ = ('name','balance')

设置__slots__的类实例不再使用字典存储实例数据，而是改为数组，因此可以减少内存占用、执行时间。

没有必要在__slots__里面添加方法、property的名字，因为他们是定义在类上而不是实例级别的。

aid = id(a)      #内置函数id()用于获取对象的标识符，为一整数，通常为内存地址
if a is b: pass  #is运算符用于判断两个变量是否指向同一个对象（标识符相等）
if a == b: pass  #如果a与b的值相等

if type(s) is list: pass     #对象的类型也是一个对象，该对象是单例的
if type(a) is type(b): pass  #如果a与b的类型相同
#如果对象属于类cname或派生自cname的任何类，isinstance返回True
isinstance (obj, cname)
#如果A是B的子类，则issubclass()返回True
issubclass(A,B)

#考虑到鸭子类型识别的问题，可以修改isinstance、issubclass方法的行为：
class IClass(object): 
    def __init__(self):
        self.implementors = set() 
    def register(self,C):
        self.implementors.add(C) 
    def __instancecheck__(self ,x):
        return self.__subclasscheck__(type (x)) 
    def __subclasscheck__(self,sub):
        return any(c in self.implementors for c in sub.mro())

使用abc模块可以定义抽象基类，该模块由元类ABCMeta与一组装饰器组成，使用方法如下：

from abc import ABCMeta, abstractmethod, abstractproperty
class Foo:
    __metaclass__ =ABCMeta       # Python3使用 class Foo(metaclass=ABCMeta)
    @abstractmethod              #声明抽象方法
    def spam(self, a, b): pass
    @abstractproperty            #声明抽象属性
    def name(self): pass

抽象类不能实例化，到导致TypeError，抽象的派生类只要没有全部实现抽象方法、属性，则同样不能实例化。

抽象基类支持对已经存在的类进行注册——使其属于该类（isinstance、issubclass返回期望的结果），但是该注册不会检查目标子类是否实现了抽象基类的任何抽象方法、属性：

class Bar(object): pass   #既有类
Foo.register(Bar)         #注册基类

使用抽象基类注册机制，可以重新组织已有类型的层次结构，例如numbers模块把数字类型重新整理，而默认他们都是继承object类的

元类知道如何创建、管理类：

class Foo(object): pass
type(Foo)    #对类对象取类型，即获得其元类，默认<type 'type'>

 使用class语句定义新类时，解释器内部事件序列可以使用下面的代码示意：

class_name = "Foo"                #类名
class_parents = (object,)         #基类
#类主体代码
class_body = """                  
def __init__(self, x): pass
"""
class_dict = { }
#在局部字典class_dict中执行类主体代码
exec(class_body,globals(),class_dict)

#调用元类创建类对象。这一步可以自行定义
Foo = type(class_name, class_parents, class_dict)

通过指定元类，可以改变类对象创建的行为：

1. 设置类变量__metaclass__可以显式指定元类
2. 如果没有显示指定元类，则使用基类元组的第一个条目的元类作为新类的元类
3. 如果没有指定基类，则使用默认值：

   types.ClassType

    ，即Python2.2以后的type作为元类

元类通常在框架组件中使用，通常可以继承

type

__init__()

__new__

class DocMeta(type):
    def __init__(self, name, bases, dict):
        for key, value in dict.items():   #遍历所有类的元素
            # 跳过特殊方法和私有方法
            if key.startswith("__"): continue
            # 跳过不可调用的任何方法
            if not hasattr(value, "__call__"): continue 
            # 检查doc字符串
            if not getattr(value, "__doc__"):
                raise TypeError("%s must have a docstring" % key) 
        type.__init__(self, name, bases, dict)  #调用默认实现来初始化类

大规模的Python程序通常以模块、包的形式组织。Python的包常常和目录对应，模块则和文件对应。

任何Python源文件均可以作为模块来使用，对于一个名字为util.py的源文件，可以使用import util语句来将其作为模块加载。加载模块时，Python解释器将：

1. 创建新的命名空间，用作在相应源文件中定义的所有对象的容器。源文件中定义的函数、方法在使用global语句时，将访问该命名空间
2. 在新创建的命名空间中执行模块中包含的代码——import导致模块中所有语句被执行
3. 在调用函数中创建名称来引用模块命名空间，该名称默认与模块名称一致：
   

   #util.py
   class stringutils(object):
       @classmethod
       def indexOf(string, search): pass
   
   #main.py
   import util                           #导入源文件作为模块
   util.stringutils.indexOf("123","2")   #使用模块中定义的类，注意前缀

用于引用模块的名称可以使用as限定符修改，新名称只限定使用了import语句的源文件或者上下文：

import util as Util
Util.stringutils.indexOf

模块也是Python的First class对象，因此可以分配给变量，存放在列表等数据结构中。

使用from语句可以将模块中指定的具体符号引入当前命名空间中，访问这些导入的符号时，不需要模块名字空间前缀：

from util import stringutils
i = stringutils.indexOf("123","2")

#可以同时导入多个符号
from util import stringutils, numberutils
from util import (
    stringutils,
    numberutils
)

#可以在导入的同时重命名符号
from util import stringutils as su
#星号通配符可以导入所有除下划线开头的符号
#只能在模块最顶层使用，在函数内使用非法
from util import *

在模块中定义列表

__all__

你也可以使用from从某个包中导入模块、从包中导入（定义在包的__init__.py中的）函数：

# 从cc/gmem/py3子包中导入HelloModule模块
from .cc.gmem.py3 import HelloModule

if __name__ == '__main__':
    HelloModule.hello()

从以点号开头的路径进行导入，表示相对于当前包寻找模块或符号：

# 从当前包的_multiprocessing模块中导入win32
from ._multiprocessing import win32

# 导入一个兄弟模块
from . import peermodule
# 导入__init__.py中定义的变量v1
from . import v1

# 导入父包中的一个模块
from .. import parentpackagemodule

模块可以在import时在自己的名字空间中运行（以库模块方式），也可以以主程序的方式运行。

每个模块均可以访问变量

__name__

__main__

#检查模块是否以程序的形式运行 
if __name__ == '__main__':
    #是
    pass
else:
    #否，我必须以模块的形式导入
    pass

 加载模块时，解释器在列表sys.path中搜索字典列表，sys.path的第一项内容是空字符串，表示当前正在使用的字典，可能包括的其他条目有：字典名称、zip归档文件、.egg文件。各条目在sys.path中出现的顺序决定了模块加载时搜索的顺序。

egg文件只是添加了版本号、依赖项的zip文件，使用zip文件的示例如下：

import sys
sys.path.append("modules.zip")
#假设modules里包含foo.py、bar.py两个文件
import foo,bar

#zip文件目录层次可以与OS文件系统层次混用
sys.path.append("/tmp/modules.zip/lib/python)

使用归档文件时需要注意：

1. python不会创建.pyc、.pyo文件，应当提前创建并放在归档文件中，避免加载模块时性能下降
2. C编写的共享库、扩展模块无法从归档文件中导入

可使用import加载的模块包括四类：

1. Python源代码，即.py文件
2. 编译为共享库或者DLL的C/C++扩展
3. 一组包含模块的包
4. 使用C编写并链接到Python解释器的内置模块

在加载模块foo时，在顺序sys.path下每个目录中搜索以下文件：

1. 包定义：目录foo
2. 已编译扩展：foo.pyd、foo.so、foomodule.so、foomodule.dll
3. foo.pyo：使用-O、-OO选项时
4. foo.pyc
5. foo.py、foo.pyw

py文件在首次被import时，会被编译为字节码并写入为.pyc文件，后续导入时，缺省直接使用.pyc文件，除非py的修改日期更新（会自动重新生成pyc）。

如果使用-O，则会创建pyo，并且删除行号、断言、其它调试信息。如果使用-OO，则还会删除文档字符串。

使用包可以把若干模块划分为一组，可以解决不同应用程序中模块名称的命名空间冲突问题。

通过创建与包名字一致的目录，并且在该目录下编写

__init__.py

包的导入与模块导入类似，都是使用import语句。第一次导入包的任何部分，均会执行对应的__init__.py，父包的__init__.py比子包的先执行。

本节以工程my-autosizer v0.1.0为例进行阐述

你可以使用distutils模块来分发Python程序给其他人使用，步骤如下：

1. 相关文件有序的组织到工程目录中，这些文件包括：模块、包、脚本、支持文档等。使用Pycharm时，这个目录就是Project的根目录。工程布局示例：
   

   ├── my-autosizer
      ├── dist
      │   └── myautoresizer-0.1.0.tar.gz
      ├── ma_autoresize.py
      ├── MANIFEST
      ├── ma_printrect.py
      ├── myautoresizer
      │   └── __init__.py
      └── setup.py

2. 在工程目录下编写安装脚本setup.py
3. 可选的，编写一个安装配置文件
4. 创建源码分发包（source distribution）
5. 可选的，创建更多的二进制分发包（binary distributions）

安装脚本是构建、分发、安装等一系列活动的中心所在，最简单的例子如下：

from distutils.core import setup

setup(
    name="myautoresizer",                                # 软件包名称
    version="0.1.0",                                     # 字符串版本号
    description='Auto resize and move GDK windows',
    author='Alex Wong',
    author_email='alex@gmem.cc',
    url='https://py.gmem.cc/myautoresizer',
    py_modules = [],                                     # 所有单一文件的Python模块列表
    packages=['myautoresizer'],                          # 所有包目录的列表
    scripts=['ma_autoresize.py', 'ma_printrect.py']      # 脚本文件的列表
)

调用setup.py，传入不同的相应参数，可以创建分发包，这些分发包自动保存到工程目录的dist子目录下：

cd /home/alex/Python/projects/pycharm/my-autosizer
# 创建源码分发包，生成 dist/myautoresizer-0.1.0.tar.gz
python setup.py sdist

# 创建二进制分发程序
python setup.py bdist 
# Window下分发为安装程序.exe
python setup.py bdist_wininst 
# Redhat下分发为安装程序.prm
python setup.py bdist_rpm

在客户机上，可以解压并安装上面的分发包：

tar xzf myautoresizer-0.1.0.tar.gz
cd myautoresizer-0.1.0

# 执行安装
python setup.py install
# 在我的机器上，以下文件被安装
# /usr/local/bin/ma_autoresize.py
# /usr/local/bin/ma_printrect.py
# /usr/local/lib/python2.7/dist-packages/myautoresizer/__init__.py
# 注意：工程根目录只是容器，不会体现在安装树的任何地方

调用

install

1. 模块、包通常安装到Python库的

   site-packages

    下
2. 脚本在Unix下通常安装到Python解释器二进制文件所在目录
3. 脚本在Windows下通常安装到

   %PYTHON_HOME%\Scripts

    目录

你也可以调用pip命令，直接安装压缩包：

sudo pip install myautoresizer-0.1.0.tar.gz

Python Package Index (PyPI)存储基于distutils分发的软件包的元数据信息，如果作者愿意，软件包本身也可以存放在上面。

通过

register

upload

执行下面的命令注册软件包的元数据：

python setup.py register
# 你需要根据提示，提供登录身份，或者注册新用户

执行下面的命令上传软件包： 

# 上传源码发布包、Windows二进制发布包
python setup.py sdist bdist_wininst upload
    -r https://gmem.cc/pypi   # 指定PyPI仓库地址

register和upload命令会检查

$HOME/.pypirc

[distutils]
index-servers =
    pypi

[pypi]
repository:https://pypi.python.org/pypi
username:user
password:passwd

Section头中的文字，是仓库的名称，可以作为

-r

python setup.py sdist upload -r pypi

Setuptools对distutils进行了一系列的增强，特别是，它能很好的处理包之间的依赖关系。下面是Setuptools的主要特性：

1. 可以在构建阶段，利用easy_install自动查找、下载、安装、升级依赖。这些依赖可以通过HTTP、HTTPS、SVN、SourceForge等方式得到
2. 创建EGG——单文件的、可导入的分发格式
3. 对访问位于压缩文件中的数据文件提供增强支持
4. 自动包含源码树中所有包，不必在setup.py中逐个指定
5. 自动包含相关的文件到源码发布包中，不需要MANIFEST.in
6. 对于工程中的每一个__main__函数，自动生成包装脚本或者Windows的exe文件
7. 支持上传EGG或者源码发布包到PyPI
8. 创建能自动发现扩展的可扩展程序

Setuptools保证了和distutils的兼容性，包括安装脚本的文件名、API风格都是一样的。Setuptools对API进行了很多扩展：

setup(
    name="myautoresizer",
    version="0.1.2",
    packages=find_packages(exclude=["tests.*"]),  # 自动在源码树中寻找Python包
    install_requires=['docutils>=0.3'],  # 指定依赖列表
    scripts=['ma_autoresize.py', 'ma_printrect.py'],
    package_data={
        # 对于任何包，其中的*.txt、*.text文件被包含到发布树
        '': ['*.txt', '*.text'],
        # 对于myautoresizer，其中的*.ini文件被包含到发布树
        'myautoresizer': ['*.ini'],
    },
    entry_points={
        'console_scripts': [
            'ma_printrect = myautoresizer.scripts:ma_printrect',
            'ma_autoresize = myautoresizer.scripts:ma_autoresize',
        ],
    }
)

执行同样的命令，可以打源码发布包：

python setup.py sdist

源码发布包会以tar.gz格式存放在dist子目录，同时，根目录会出现一个文件夹：myautoresizer.egg-info 

对于大型工程来说，手工列出packages需要很大的工作量，此时可以使用find_packages()函数：

# where 指定源码目录，默认setup.py所在目录
# 在Python 3.2-只有包含__init__.py才能被识别为包
# exclude 需要排除的包名通配符
# include 需要包含的包名通配符
def find( where='.', exclude=(), include=('*',)): pass

# 排除掉所有测试包
find_packages(exclude=["*.tests", "*.tests.*", "tests.*", "tests"])

distutils打包、安装脚本的方式比较笨拙：

1. 脚本的名称不能很好的匹配Windows/Linux的扩展名习惯
2. 你需要编写单独的脚本，仅仅为了容纳一个__main__函数。my-autosizer的v0.1.0中的ma_*.py脚本就是因此而存在

要让setuptools自动创建脚本，只需要：

setup(
    # 其它参数
    entry_points={
        # 控制台脚本
        'console_scripts': [
            'foo = my_package.some_module:main_func',
            'bar = other_module:some_func',
        ],
        # GUI脚本
        'gui_scripts': [
            'baz = my_package_gui:start_func',
        ]
    }
)

setup(
    entry_points = {
        'setuptools.installation': [
            'eggsecutable = my_package.some_module:main_func'
        ]
    }
)

 添加此配置后，目标EGG增加可执行权限后，即可直接在Unix-like系统上执行。

对于依赖版本的限制，你可以使用以下操作符：

< > <= >= == !=

PyPI网站包含大量的第三方扩展资源。对于没有依赖的简单库，可以使用脚本

python setup.py install

对于依赖关系复杂的库，最好使用setuptools提供的easy_install脚本，只需要输入

easy_install pkgname

pip是Python Packaging Authority (PyPA) 推荐的Python包管理器，支持从PyPI、版本控制系统、本地工程等来源安装软件包。

从2.7.9/3.4以后，该工具集成到Python中，不需要额外安装。手工安装的步骤如下：

wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py
rm get-pip.py

--no-binary

# 从PyPI安装：
pip install pkgname              # 最新版本
pip install pkgname==1.0.4       # 特定版本
pip install 'pkgname>=1.0.4'     # 最小版本

# 为当前用户安装
# Linux下安装到 ~/.local/；Windows下安装到%APPDATA%\Python 
pip install --user pkgname

# 从指定的“需求文件”安装
pip install -r requirements.txt

# 从Wheel安装
pip install pkgname-1.0-py2.py3-none-any.whl

# 列出所有软件包
pip list
# 列出过期的软件包
pip list --outdated

pip install wheel

你可以使用配置文件为pip命令提供默认选项。

配置文件位置如下：

配置文件示例如下：

; 这一段针对所有子命令
[global]
; 命令执行超时
timeout = 60
; 使用镜像包索引
index-url = https://pypi.doubanio.com/simple

; 这一段仅针对freeeze子命令
[freeze]
timeout = 10 

作为新版本的pip，目前还不成熟，安装步骤如下：

git clone https://github.com/osupython/pip2.git
cd pip2
python setup.py install

使用该工具可以方便的下载、构建、安装、升级、卸载Python软件包，安装步骤如下：

wget https://bootstrap.pypa.io/ez_setup.py
python ez_setup.py

该工具最常用的命令是easy_install，用来安装Python模块。

Virtualenv的目的是创建隔离的Python环境，可以解决不同软件之间依赖包冲突、以及潜在的文件权限的问题。

在开发Python应用的时候，依赖包默认都会安装到Python运行时的site-packages目录下。这样，如果两个应用依赖统一个包的不同版本，就会出现冲突。要解决这类问题，可以利用Virtualenv。

从3.3版本开始，Virtualenv的一部分功能作为标准库集成到venv模块中。不包含在其中的功能有：

1. 创建Bootstrap脚本
2. 为其它Python版本创建虚拟环境

可以使用任何版本的pip来安装和管理Virtualenv：

pip3 install virtualenv

执行下面的命令，可以创建一个目录，并将其作为一个虚拟环境：

virtualenv  certbot-dns-aliyun

上面命令创建的虚拟环境的名字是certbot-dns-aliyun，他相当于一个Python的$PREFIX目录，和Python标准的目录结构对应：

1. lib，此虚拟环境的库文件，包被安装到lib/pythonX.X/site-packages/下
2. bin，可执行文件，包括python这个文件

包括pip、setuptools在内的包，会自动安装到新创建的虚拟环境中。

要进入虚拟环境，执行其中的脚本：

source certbot-dns-aliyun/bin/activate

你会发现命令提示符增加了前缀

(certbot-dns-aliyun)

现在，你通过pip安装的包，都会安装到当前虚拟环境中，系统的Python环境不会受到影响。

执行命令

deactivate

简单的删除对应目录即可。

virtualenv [OPTIONS] DEST_DIR

virtualenv -p /usr/bin/python2.7 
virtualenv --python=python3.5

import random

corpTypes = [22, 23, 24, 25, 26, 49, 50, 180, 181, 182, 184, 185, 186, 77, 164, 165, 220]

# 对序列进行随机的重新排序
random.shuffle(corpTypes)

# 从序列中随机选取一个
random.choice(corpTypes)

# 从序列中随机选取N个样本
random.sample([10, 20, 30, 40, 50], k=N)

# 随机浮点数
# 0-1之间随机
random.random()
# 2.5-10.0之间随机
random.uniform(2.5, 10.0)   

# 随机整数
# 0-9之间随机
random.randrange(10)  
# 3-9之间随机
random.randrange(3,10)

#decimal模块实现了IBM通用十进制算法标准，能够准确表示十进制值
import decimal 
x = decimal.Decimal('3.4')
y = decimal.Decimal('4.5')
a = x * y  #15.30
b = x / y  #0.7555555555555555555555556
#改变精度并计算
decimal.getcontext().prec = 3  #三位有效数字
a = x * y  #15.3
b = x / y  #0.756
#只改变语句块的精度
with decimal.localcontext(decimal.Context(prec=10)):
    a = x * y  #15.30
    b = x / y  #0.7555555556

#Context对象用于控制十进制数的各种属性
Context(
    prec = None,       #精度的位数，即有效数字数
    rounding = None,   #四舍五入方式
    traps = None,      #信号列表，在发生算术异常时有用
    flags = None,      #环境初始状态的信号列表
    Emin = None,       #指数最小值
    EMax = None,       #指数最大值
    capitals = 1       #指数使用'E'还是'e'，默认'E'
)


#math模块定义了很多标准算术运算函数
#numbers模块对数值类的层次进行梳理

# Python使用列表sys.argv存放命令行参数，第一个元素是程序的名称，后续为命令行参数
import sys
if len( sys.argv ) != 3 :
    sys.stderr.write( "Invalid arguments" )  # 访问标准输出
    raise SystemExit( 1 )  # 以非零退出
inputfile = sys.argv[1]



# 对于复杂的命令行参数，可以使用optparse模块进行处理
import optparse
p = optparse.OptionParser()
p.add_option( 
             "-o" ,  # 命令行选项
             action = "store",   #store表示把值存放在Options中
             dest = "outfile",   #在处理结果Options中的键
             default = "out.log" #默认值
            )
p.add_option( "--output" , action = "store", dest = "outfile" )
p.add_option( "-o" , "--output" , action = "store", dest = "outfile" )  # 同时指定长短选项
# 布尔选项，在命令行中只指定命令选项，而不指定值
p.add_option( "-d" , action = "store_true", dest = "debug" )       #store_true表示存储为True
p.add_option( "--debug" , action = "store_true", dest = "debug" )
# 设置一个或者多个选项的默认值
p.set_defaults( debug = False )
# 解析命令行
# opts为包含所有选项值的字典
# args为为解析为选项的命令行项的列表
(opts, args) = p.parse_args()
outfile = opts.outfile
debugmode = opts.debug

#可以通过字典os.environ访问环境变量
import os
path = os.environ ["PATH" ] 
user = os.environ["USER"]

#写入的环境变量会影响正在运行的程序、Python创建的子进程
os.environ ["PATH" ] = ""

#弱引用不会导致引用计数的增加，因而可以避免循环引用
class A: pass
a = A()
ar = weakref.ref(a)  #创建弱引用
#只要把弱引用作为函数调用，即可获得底层的对象，如果对象已经不存在，则返回None
a = ar()

Python在sys模块提供stdin、stdout、stderr三个文件对象，用于访问标准输入、输出、错误。

import sys
sys.stdout.write("Enter password: ")  #写到标准输出，通常在屏幕上显示
sys.stdin.readline()                  #读取标准输入，通常映射到键盘
#可以如下从stdin读取一行文本（不包括结尾换行符）
name = raw_input ("Enter password: ")

键盘中断会引发KeyboardInterrupt异常。  

import copy
ls = [[], []]
lsc = copy.copy(ls)
lsdc = copy.deepcopy(ls)

实现

__copy__(self)

__deepcopy__(self)

在解释器退出时执行某个函数：

def exithook():
    print 'Exiting...'
import atexit
atexit.register(exithook)

# 执行指定的命令，并等待其结束
# args：字符串，或者程序参数的序列。如果传递字符串则要求shell=True或者字符串仅仅是不带参数的被调用程序的名称
# stdin, stdout, stderr 对应被调用命令的标准输入、输出、错误
# shell 如果设置为True则目标程序通过Shell执行
# subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)

from subprocess import call
call(['ls','-l'])
call(["ma_autoresize.py"])

internal_ip = subprocess.check_output('''
    kubectl get node %s -o jsonpath='{.status.addresses[?(@.type=="InternalIP")].address}'
''' % (node.node_name()), shell=True)
#                         不设置shell为True导致No such file or directory

ipstr = str(internal_ip, encoding='utf8')

# 丢弃
subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

# 重定向到文件
with open('sysout.log', 'w') as out, open('syserr.log', 'w') as err:
    subprocess.Popen(cmd, shell=False, stdout=out, stderr=err)

import subprocess
import os

#若要使用kill()方法终结进程，则shell必须为False
p = subprocess.Popen(['D:/PATH_TO_BAT.bat','ARG0'], shell=False)
p.kill()

#使用psutil亦可
import psutil
import os
def kill_proc_tree(pid, including_parent=True):    
    parent = psutil.Process(pid)
    for child in parent.children(recursive=True):
        child.kill()
    if including_parent:
        parent.kill()
#杀死当前进程的所有子进程
kill_proc_tree(os.getpid(), False)

#获取上级目录
import posixpath
import ntpath
print ntpath.abspath(ntpath.join('D:\\JavaEE', '..'))  # D:\
print posixpath.abspath(posixpath.join('/home', '..')) # /

# 是否是文件，不存在或者不是普通文件，返回False
os.path.isfile('/swapfile')
# 是否是目录
os.path.isdir('/tmp')
# 路径是否对应文件或目录
os.path.exists('~')

# 展开~开头的路径
os.path.expanduser('~')  # /home/alex
# 展开Shell变量替换
os.path.expandvars("$PWD")

# 得到文件所在目录
os.path.dirname('/home/alex')   # /home
# 得到绝对路径
os.path.abspath('.')
# 得到当前脚本所在目录
os.path.dirname(os.path.abspath(__file__))
# 得到当前工作目录
os.getcwd()
# 改变当前工作目录
os.chdir('/tmp')

# 链接子目录、文件路径
os.path.join('/home','alex')  # /home/alex
os.path.join('home','alex')   # home/alex
os.path.join('/home','/alex') # /alex

import os
import shutil

os.chdir('/tmp')

# 实现touch操作
def touch(path):
    with open(path, 'a'):
        os.utime(path, None)

# 创建目录
os.makedirs('src/sub1')
os.makedirs('src/sub2')
os.makedirs('dest')

# 创建文件
touch('src/sub1/file11')
touch('src/sub1/file12')
touch('src/sub1/file13')
touch('dest/file22')

# 复制文件
shutil.copy('src/sub1/file11','dest')          # 复制单个文件到目录
# 删除单个文件
os.remove('dest/file11')
shutil.copy('src/sub1/file11','dest/file22')   # 复制到文件，覆盖既有文件

# 复制目录
shutil.copytree('src/sub1','dest/sub2')        # 第二个参数必须是不存在的路径，用来作为目标目录
# 删除整个目录，包括指定的目标本身
shutil.rmtree('dest/sub1')

# 移动目录
shutil.move('src/sub1','dest/sub1')
# 移动文件
shutil.move('dest/sub1/file11','src')

打开文件读写时，可以指定r、w、a标记位。后面可以附加b、t表示二进制还是文本模式。在二进制模式下，不会在Windows下对\n与\r\n进行转换。

#内置函数open(name [,inode [, bufsize]])用于打开和创建文件对象
f = open('sys.log', 'r')  #以读模式打开文件，可以省略第二个参数
f = open('sys.log', 'w')  #以写模式打开文件

在Python2中，所有读操作均返回二进制字符串。在Python3中，文本模式打开读取到Unicode字符串，二进制模式打开返回字节字符串。

如果要处理Unicode字符文件的读写，则需要考虑字节序的问题（Unicode字符在内部使用多字节整数表示），例如，需要决定把U+HHLL以Little-ending方式写为LL HH，还是Big-ending方式写为HH LL。使用codecs提供的函数是最直接的处理Unicode文件的方法：

# codecs.open (filename [, mode [, encoding [, errors]]]
codecs.open("var.log",'r','utf-8', 'strict')  #读取
codecs.open("var.log",'w','utf-8')  #写入

# 可以使用codecs.EncodedFile来包装已经存在的文件对象
# codecs.EncodedFile(file, inputenc [, outputenc [,errors]])
f0 = codecs.EncodedFile(f, 'utf-8')

Unicode文件可能包含特殊的BOM（字节顺序标记）用于指示字节编码的方式，它作为文件的第一个字符写入：\xff\xfe表示UTF-16-LE，\xfe\xff表示UTF-16-BE。

要发送ICMP报文，可以使用ping3包：

ping3.ping(ip, timeout / float(1000))

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    try:
        sock.connect((ip, port))
    except ConnectionError:
        pass

from IN import IP_RECVERR
sock = socket.socket(socket.AF_INET, sock_type)
sock.setsockopt(socket.IPPROTO_IP, IP_RECVERR, 1)
sock.settimeout(timeout / 1000.0)
sock.sendto(bytes(1024), (ip, port))
try:
    sock.recvfrom(1024)
except socket.timeout as e:
    pass

from werkzeug.serving import run_simple
from werkzeug.wrappers import Request, Response
import os
@Request.application
def application(request):
    return Response('')
run_simple('0.0.0.0', 1010, application, static_files={"/" : os.path.dirname(__file__)})

#bz2模块用于根据bzip2压缩算法读取和写入压缩数据

#打开一个名为filename的bz2文件，压缩级别0-9越大压缩比越高
BZ2File(filename [, mode [, buffering [, compress_level]]])
#返回字符串data中数据的一个压缩版
compress(data [, compress_level])
#返回一串包含字符串data解压数据的字符串
decompress (data)


#创建用于顺序压缩数据块序列的压缩器对象
c = BZ2Compressor([compress_level])
c.compress(data)   #添加数据到压缩器对象
c.flush            #刷新内部缓冲区并返回一串包含全部剩余数据的压缩字符串

#创建一个解压缩器对象
d.BZ2Decompressor()
d.decompress()     #解压缩

#其他压缩模块
#gzip模块提供了一个类，即Gzipfile。它可以用来读取和写入与GNU gzip程序兼容的文件，其使用与普通文件相同
GzipFile([filename [, mode [, compress_leve1 [, fileobj] ]]])
open(filename [, mode [, compress_leve1 ]])
#tarfile模块用于操作tar归档文件。利用这一模块，无论tar文件压缩与否，都可以读取和写入tar文件
#zipfilee模块用于操作zip格式编码的文件
#zlib块通过提供对zlib库的访问支持数据压缩

Python Database API Specification V2.0是Python社区制定的一套数据库访问标准，MySQL、Oracle等数据库可以通过该标准的API访问。

# 连接对象：Connection
# 使用connect(dsn="hostname:DBNAME",user="",password="")函数创建Connection对象
# Connection对象的方法：
# close()      关闭数据库连接
# commit()     提交未完成的事务
# rollback()   回滚到事务开始前状态
# cursor()     创建一个游标对象，用于进行SQL查询
# Cursor对象的方法和属性：
# callproc(procname [, parameters])   调用存储过程
# close()                             关闭游标
# execute(sql [, parameters])         执行查询语句或者命令
# executemany(sql [, parameterseqs])  重复执行查询或者命令，sql是一个查询语句，parameterseqs是一个查询参数的序列，其每一项是序列或者映射
# fetchone()                          返回execute、executemany生成的结果集的下一行
# fetchonemany([size])                返回execute、executemany生成的结果集若干行
# fetchall()                          返回剩余结果集行的序列
# rowcount                            结果集的行数

#数据库类型
#Date(year, month, day)                            日期
#Time(hour, minute, second)                        时间
#Timestamp(year, month, day, hour, minute second)  时间戳
#DateFromTicks(ticks)                              根据系统时间创建日期对象。ticks是秒数，就像函数time.time()返回的一样
#TimeFromTicks(ticks)                              根据系统时间创建时间对象
#TimestampFromTicks(ticks)                         根据系统时间创建时间戳对象
#Binary(s)                                         根据字符串创建二进制对象

#数据访问异常的超类为Error，包括以下子类
#InterfaceError    与数据库界面相关的错误。但是不是数据库本身
#DatabaseError     与数据库本身相关的错误
#DataError         与处理的数据相关的错误。例如，类型转换错误，除零等
#OperationalError  与数据库本身的运行相关的错误。例如，丢失连接
#IntegrityError    当数据库的关系完整性被破坏时出现的错误
#IntenalError      数据库内部错误。例如，如果是一个失效指针
#ProgrammingError  SQL査询中的错误
#NotSupportedError 不受底层数据库支持的数据库API方法导致的错误

if __name__ == '__main__':
    import sqlite3
    conn = sqlite3.connect("dffile")
    cur = conn.cursor()
    # 执行查询
    cur.execute("select corp_name, reg_capi from t_corp where org_id = 1000")
    # 遍历结果集
    while True:
        row = cur.fetchone()
        if not row:break
        # 处理行
        corp_name, reg_capi = row
    # 另一种处理结果集的方法
    for corp_name, reg_capi in cur: pass
    
    # 预编译语句
    pstmt = "select reg_no,addr from t_corp where org_id = ? and status = ?"
    cur.execute(pstmt, (10001, 'A'))  #使用元组填充占位符?
    #注意，并不是所有数据库模块都使用?占位符，模块的paramstyle变量描述其占位符风格，例如：
    #qmark    where id = ? and status = ?           元组填充
    #numeric  where id = :0 and status = :1         元组填充
    #named    where id = :id and status = :status   字典填充

#array模块定义了新类型array，与列表类似，但是元素必须是单一类型
#array(typecode [, initializer])
#其中typecode：
# 'c'   8位字符
# 'b'   8位整型
# 'B'   8位无符号整型
# 'u'   Unicode字符
# 'h'   16位整型
# 'H'   16位无符号整型
# 'i'   整型
# 'I'   无符号整型
# 'l'   长整型
# 'L'   无符号长整型
# 'f'   单精度浮点型
# 'd'   双精度浮点型

#支持的方法、属性列表
# typecode	  用于创建数组的类型编码字符
# itemsize	  存储在数组中的项目大小（以字节为单位）
# append (x)	  将x附加到数组末尾
# buffer_info()   返回（address, length)，提供用于存储数组的缓冲区的内存位置和长度
# byteswap()	  在大尾与小尾之间切换数组中所有项目的字节顺序。仅支持整型值
# count (x)	  返回a中出现X的次数
# extend(b)	  将b附加到数组a的末尾。b可以是一个数组，也可以是一个元素类型与a中相同的可迭代对象
# fromfile(f, n)  从文件对象中读取n个项目（二进制格式），并附加到数组末尾。f必须是一个文件对象。如果可读取的项目少于n，则抛出EOFError
# fromlist(list)  将list中的项目附加到数组末尾。list可以是任何可迭代对象
# fromstring(s)	  附加字符串s中的项目，其中s是一个由二进制值组成的字符串，与使用fromfile()进行读取相同
# index(x)	  返回x在a中首次出现的位置索引。如果未找到，则抛出ValueError
# insert(i, x)	  在位置i前插入x
# pop([i])	  从数组中删除项目i并将其返回。如果i已被删除，则删除最后一个元素
# remove (x)	  从数组中删除第一个x。如果未找到，则抛出ValueError
# reverse()       反转数组的顺序
# tofile(f)       将所有项目写入文件f。数据保存为本机二进制格式
# tolist ()       将数组转换为普通的值列表
# tostring()      转换为由二进制数据组成的字符串，与使用tofile()写入的数据相同
# tounicode()     将数组转换为Unicode字符串。如果数组类型不为'u'则抛出ValueError

a = array.array ('i', [1,2,3 ,4,5])
b = array.array(a.typecode, (2*x for x in a) )  #从a中创建新数组


#collections模块包含一些有用容器类型的高能实现、各种容器的抽象基类
deque([iterable [, maxlen]])                   #双端队列
defaultdict([default_factory], ...)            #类似于基本字典，但是再查找不存在键时，会使用default_factory提供默认值
namedtuple(typename, fieldnames, [,verbose])   #命名元组，相比起字典，效率更高
IAddr =  collections.namedtuple('InternetAddress',['hostname','port'])
a = InternetAddress('gmem.cc',80)
a.hostname

参考：格式化字符串

打印可以使用print语句或者print函数

f = open('log', 'w')
print >> f,"Error"    #可以改变print的目标

对于原始字节字符串s，如果其包含已编码的Unicode字符串，则可以使用s.decode(encoding, errors)方法进行转换。
对于Unicode字符串u，可以使用u.encode(encoding, errors)方法进行编码。

如果包含目标encoding不支持的字符，默认引发UnicodeError，可以指定errors参数以修改此行为。

通过sys.getdefaultencoding()可以获取默认编码。

#使用pickle模块进行对象序列化
if __name__ == '__main__':
    import pickle
    users = {
        10001:'Alex',
        10002:'Meng'
    }
    fname = "F:/temp/user.dmp"
    # 第三个参数表示协议，默认0，为文本协议；1为二进制协议；2为较新的协议；3只能用于Python3
    pickle.dump(users, open(fname, 'w'), 1)  # 类似的dumps方法返回包含已序列化数据的字符串
    loaded_users = pickle.load(open(fname, 'r'))  # 从文件反序列化，自动检测协议
    print loaded_users  #类似的loads从字符串反序列化
    
    #如果存在复杂的对象关系，例如循环引用，应当使用Pickle对象进行序列化
    p = pickle.Pickler(open(fname, 'w'),1)
    p.dump(users) #把users对象写入文件，并记住其唯一标识，后续再写，自动进行引用处理
    
    up = pickle.Unpickler(open(fname, 'f'))

logging模块为Python提供了日志记录的功能。类似于Log4j。logging包含以下组件

#根据名称获取日志记录器，不指定name返回root记录器，此方法调用具有幂等性
logging.getLogger(name)
#默认logging提供的方法是使用root记录器

logging支持5种记录级别：DEBUG、INFO、WARNING、ERROR、CRITICAL，在不指定的情况下，默认记录级别为WARNING，也就是说，低于这个级别的信息不会被记录到控制台或文件。

利用basicConfig函数可以配置日志记录的参数，例如下面的例子将日志记录到文件：

import logging
#记录到文件，日志级别为DEBUG
#使用命令行参数 --log=DEBUG 也可以指定日志级别
logging.basicConfig( filename='pyapp.log', filemode='w', level=logging.DEBUG )
logging.debug( 'This message should be written to pyapp.log' )

logging支持使用C语言printf风格的格式化：

import logging
logging.warning( '%s is %d years old.', 'Alex', 24 )

为basicConfig指定format参数，可以详细定制日志输出格式，例如：

import logging
#日志输出格式为：时间 日志内容
#详细规定日期时间的显示格式，datefmt的参数参考time.strftime()
#format中占位符的格式为%(key)[-][n][s|d...]，-表示右补白，n表示显示的最小宽度，s表示格式化为字符串
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')

 format可以使用下表列出的占位符：

除了通过编程方式配置logging以外，还可以支持配置文件方式：

logging.config.fileConfig('logging.conf')

logging.conf文件的格式类似于INI，下面是一个示例：

;声明使用的日志记录器
[loggers]
keys=root,corelogger
;声明使用的日志处理器
[handlers]
keys=consoleHandler
;声明日志输出格式
[formatters]
keys=defaultFormatter
;每个日志记录器的详细配置：使用什么级别、处理器
[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_corelogger]
level=DEBUG
handlers=consoleHandler
qualname=corelogger
propagate=0

;每个处理器的详细配置：处理器的类（相对logging模块的类名或是全限定类名）、格式以及构造器入参
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=defaultFormatter
args=(sys.stdout,)

[formatter_defaultFormatter]
format=[%(levelname)-7s] [%(process)d-%(threadName)s] %(asctime)s %(module)s.%(funcName)s:%(lineno)d %(message)s
datefmt=%Y-%m-%d %I:%M:%S

在多模块中使用logging时，典型做法是在main模块中初始化日志配置，其他模块引用Logger对象即可。

ctype = ctype.encode(default_encoding) # omit in 3.x!
except UnicodeEncodeError:
    pass

类似的报错信息还可能是“but no encoding declared...”。需要指定源代码的编码方式：

# 在源文件开始出添加类似下面的语句
# -*- coding: cp-1252 -*-
# -*- coding: UTF-8 -*-

如果安装了两个Python环境A、B，其中A已经安装了软件包P，在运行B的easy_install再次安装P时会出现该提示，并且Pydev不能识别路径匹配的软件包。

打开文件：%PYTHON_B_HOME%/site-packages/easy-install.pth，删除与P相关的行，然后拷贝%PYTHON_A_HOME%/site-packages/P-version.egg到B的对应目录即可。

基于HTTPS访问PyPI时会出现此警告：SNIMissingWarning: An HTTPS request has been made, but the SNI (Subject Name Indication) extension to TLS is not available on this platform。

安装模块时还会出现证书错误提示：Certificate did not match expected hostname，导致无法完成安装。

解决办法：

pip install pyopenssl ndg-httpsclient pyasn1

可能是因为你构建Python时，机器上缺少OpenSSL支持，先安装OpenSSL：

# CentOS
yum install openssl openssl-devel
# Ubuntu
apt-get install openssl libssl-dev

然后重新构建Python即可。

考虑如下目录结构：

.
└── myautosizer
    ├── __init__.py
    ├── script.py

以及Python脚本文件： 

all_usrs = []

from . import all_usrs
if __name__ == '__main__':
    pass

执行

python ./myautosizer/scrpit.py

解决办法：

1. 改变调用命令，搜索模块，作为脚本运行：

   python -m  myautosizer.scrpit

    
2. 或者，不使用相对导入，修改导入语句为 

   from myautosizer.scrpit import all_usrs

    
3. 或者，从外部脚本调用script.py，把script.py最为模块看待

The post Python学习笔记 appeared first on 绿色记忆.