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 绿色记忆.

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 绿色记忆.