坑 python学习之 500 lines or less 杂项

500lines or less 这个系列看起来很好，但是无奈本人实在是学不动。。国庆一天尝试了3个发现都很困难。。一个是代码长度一高，加上语言不通，很容易导致逻辑混乱。一个可能是本人实在是对这方面缺乏足够的兴趣，不管怎么说，可能是现在的我太弱了吧   -2016年国庆

1.函数的特殊方法

__getitem__ 和 __setitem__ 是两个类的特殊方法

比如一个类叫DBDB

那么a=DBDB(f)

a[4] 就等价于a.__getitem__(4)

__setitem__方法同理

__future__:引入下一个版本的函数

__all__:在模块(*.py)中使用意为导出__all__列表里的类、函数、变量等成员，
否则将导出modualA中所有不以下划线开头（私有）的成员，
在模块中使用__all__属性可避免在相互引用时的命名冲突

2.关于异常处理

以下内容来自：http://www.cnblogs.com/windlazio/archive/2013/01/24/2874417.html

python中try/except/else/finally语句的完整格式如下所示：

try:

     Normal execution block

except A:
     Exception A handle

except B:

     Exception B handle

except:

     Other exception handle

else:
     if no exception,get here

finally:
     print("finally")   

说明：

正常执行的程序在try下面的Normal execution block执行块中执行，在执行过程中如果发生了异常，则中断当前在Normal execution block中的执行跳转到对应的异常处理块中开始执行；

python从第一个except X处开始查找，如果找到了对应的exception类型则进入其提供的exception handle中进行处理，如果没有找到则直接进入except块处进行处理。except块是可选项，如果没有提供，该exception将会被提交给python进行默认处理，处理方式则是终止应用程序并打印提示信息；

如果在Normal execution block执行块中执行过程中没有发生任何异常，则在执行完Normal execution block后会进入else执行块中（如果存在的话）执行。

无论是否发生了异常，只要提供了finally语句，以上try/except/else/finally代码块执行的最后一步总是执行finally所对应的代码块。

需要注意的是：

1.在上面所示的完整语句中try/except/else/finally所出现的顺序必须是try-->except X-->except-->else-->finally，即所有的except必须在else和finally之前，else（如果有的话）必须在finally之前，而except X必须在except之前。否则会出现语法错误。

2.对于上面所展示的try/except完整格式而言，else和finally都是可选的，而不是必须的，但是如果存在的话else必须在finally之前，finally（如果存在的话）必须在整个语句的最后位置。

使用raise抛出异常
当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

1. sys.exit(n) 退出程序引发SystemExit异常, 可以捕获异常执行些清理工作. n默认值为0, 表示正常退出. 其他都是非正常退出. 还可以sys.exit("sorry, goodbye!"); 一般主程序中使用此退出.
2. os._exit(n), 直接退出, 不抛异常, 不执行相关清理工作. 常用在子进程的退出.
3. exit()/quit(), 跑出SystemExit异常. 一般在交互式shell中退出时使用.

作者：艾迪
链接：https://www.zhihu.com/question/21187839/answer/46228505
来源：知乎
著作权归作者所有，转载请联系作者获得授权。

3.关于下划线

作者：权循真
链接：https://www.zhihu.com/question/19754941/answer/12860775
来源：知乎
著作权归作者所有，转载请联系作者获得授权。

首先是单下划线开头，这个被常用于模块中，在一个模块中以单下划线开头的变量和函数被 默认当作内部函数，如果使用 from a_module import * 导入时，这部分变量和函数不会被导入。不过值得注意的是，如果使用 import a_module 这样导入模块，仍然可以用 a_module._some_var 这样的形式访问到这样的对象。

在 Python 的官方推荐的代码样式中，还有一种单下划线结尾的样式，这在解析时并没有特别的含义，但通常用于和 Python 关键词区分开来，比如如果我们需要一个变量叫做 class，但 class 是 Python 的关键词，就可以以单下划线结尾写作 class_。

双下划线开头的命名形式在 Python 的类成员中使用表示名字改编 (Name Mangling)，即如果有一 Test 类里有一成员 __x，那么 dir(Test) 时会看到 _Test__x 而非 __x。这是为了避免该成员的名称与子类中的名称冲突。但要注意这要求该名称末尾没有下划线。

双下划线开头双下划线结尾的是一些 Python 的“魔术”对象，如类成员的 __init__、__del__、__add__、__getitem__ 等，以及全局的 __file__、__name__ 等。 Python 官方推荐永远不要将这样的命名方式应用于自己的变量或函数，而是按照文档说明来使用。

另外单下划线开头还有一种一般不会用到的情况在于使用一个 C 编写的扩展库有时会用下划线开头命名，然后使用一个去掉下划线的 Python 模块进行包装。如 struct 这个模块实际上是 C 模块 _struct 的一个 Python 包装。

4.

@classmethod : 类方法

@staticmethod : 静态方法

类方法和静态方法的调用一样，都是通过类就可以直接调用。

区别：类方法，需要传入该类，定义类方法的时候要传一个默认的参数cls。静态方法则不用。cls它表示这个类本身。

5.

当函数的参数前面有一个星号*的时候表示这是一个可变的位置参数，两个星号**表示是可变的关键字参数。

6.缓冲区：

一般的文件流操作都包含缓冲机制，write方法并不直接将数据写入文件，而是先写入内存中特定的缓冲区。

flush方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区。

正常情况下缓冲区满时，操作系统会自动将缓冲数据写入到文件中。

至于close方法，原理是内部先调用flush方法来刷新缓冲区，再执行关闭操作，这样即使缓冲区数据未满也能保证数据的完整性。

如果进程意外退出或正常退出时而未执行文件的close方法，缓冲区中的内容将会丢失。

7.文件操作：

seek() 方法用于移动文件读取指针到指定位置。

以下是seek()方法的语法：

?

1	fileObject.seek(offset[, whence])

参数

•     offset -- 这是在文件中，读/写指针的位置。
•     whence -- 这是可选的，默认为0，这意味着绝对的文件定位，其它的值是1，这意味着寻求相对于当前位置，2表示相对于文件的末尾。

    def _seek_end(self):
        self._f.seek(0, os.SEEK_END)

( 一般来说，os.SEEK_END的值就是2 )这样写的意义是从0开始，寻找文件的结尾

fp.tell()返回文件当前指针位置

8.struct结构的使用

一篇博客：http://kaiyuan.me/2015/12/25/python-struct/

Python 为了保持语言的简洁，仅仅为用户提供了几种简单的数据结构： int ,  float ,  str ,  list ,  dict 和  tuple 。不同于编译型语言 C/C++，在 Python 中，我们往往不需要关心不同类型的变量在解释器内部的实现方式。例如，对于一个长整形数据，我们在 Python 2 中可以直接写成  a=123456789012345L ，而不用去考虑变量  a  占了几个字节。这种抽象的方式为程序的编写提供了足够的支持，但是在某些情况下（比如读写二进制文件，进行网络 Raw Socket 编程）的时候，我们需要一些其他模块来实现我们关于变量长度控制的需求。

struct 模块

当我们在 Python 中跟二进制数据打交道的时候，就要用到 struct 这个模块了。struct 模块为 Python 与 C 的混合编程，处理二进制文件以及进行网络协议交互提供了便利。理解这个模块主要需要理解三个函数：

1 2 3

struct.pack(fmt, v1, v2, ...) struct.unpack(fmt, string) struct.calcsize(fmt)

第一个函数 pack 负责将不同的变量打包在一起，成为一个字节字符串，即类似于 C 语言中的字节流。第二个函数 unpack 将字节字符串解包成为变量。第三个函数 calsize 计算按照格式 fmt 打包的结果有多少个字节。这里打包格式 fmt 确定了将变量按照什么方式打包成字节流，其包含了一系列的格式字符串。这里就不再给出不同格式字符串的含义了，详细细节可以参照 Python Doc (struct).

使用 struct 打包定长结构

一般而言，在使用 struct 的时候，要打包的数据都是定长的。定长的数据代表你需要明确给出要打包的或者解包的数据长度，否则打包解包函数将会出错。下面用例子说明什么是定长打包：

1 2 3 4 5 6 7 8

import struct a = struct.pack("2I3sI", 12, 34, "abc", 56) b = struct.unpack("2I3sI", a) print b ## 输出 (12, 34, 'abc', 56)

上面的代码将两个整数 12 和 34，一个字符串 “abc” 和一个整数 56 一起打包成为一个字节字符流，然后再解包。其中打包格式中明确指出了打包的长度："2I" 表明起始是两个unsigned int，"3s" 表明长度为4的字符串，最后一个 "I" 表示最后紧跟一个 unsigned int。所以上面的打印 b 输出结果是：(12, 34, ‘abc’, 56)。

我们可以调用 calcsize() 来计算 "2I3sI" 这个模式占用的字节数：

1 2	print struct.calcsize("2I3sI") ## 输出 16

可以看到上面的三个整型加一个 3 字符的字符串一共占用了 16 个字节。为什么会是 16 个字节呢？不应该是 15 个字节吗？其实，在 struct 的打包过程中，根据特定类型的要求，必须进行字节对齐。由于默认unsigned int 型占用四个字节，因此要在字符串的位置进行4字节对齐，因此即使是 3 个字符的字符串也要占用 4 个字节。

再看一下不需要字节对齐的模式：

1 2	print struct.calcsize("2Is") ## 输出 9

由于单字符出现在两个整型之后，不需要进行字节对齐，所以输出结果是 9.

需要指出的是，对于 unpack 而言，只要 fmt 对应的字节数和字节字符串 string 的字节数一致，就可以成功的进行解析，否则 unpack 函数将抛出异常。例如我们也可以使用如下的 fmt 解析出 a：

1 2 3 4 5

c = struct.unpack("2I2sI", a) print struct.calcsize("2I2sI") print c ## 输出 16 (12, 34, 'ab', 56)

可以看到这里 unpack 解析出了字符串的前两个字符，没有产生任何问题。

struct 处理不定长数据

在上一节的介绍中，我们看到了在使用 pack 和 unpack 的过程中，我们需要明确的指出打包模式中每个位置的长度。比如格式 "2I3sI" 就明确指出了整型的个数和字符串的个数。有时候，我们还可能会需要处理变长的打包数据。

变长字符串的打包

例如我们在程序中可能会得到一个字符串 s，这个 s 没有一个固定的长度，所以我们每次打包的时候都需要将 s 的长度也打包到一起，这样我们才能进行正确的解包。其实，这种情况在处理网络数据包中非常常见。在使用网络编程的时候，我们可能利用报文的第一个字段记录报文的长度。每次读取报文的时候，我们先读取报文的第一个字段，获取其长度之后在处理报文内容。

我们可以采用两种方式处理这种情况：

1 2	s = bytes(s, 'utf-8') # Or other appropriate encoding struct.pack("I%ds" % (len(s),), len(s), s)

或者

1	struct.pack("I", len(s)) + s

第一种方式先将报文转变成为字节码，然后获取字节码的长度，将长度嵌入到打包之后的报文中去。可以看到格式字符串中的 "I" 就用来记录报文的长度。第二种方式是直接将字符串的长度打包成字节字符串，再跟原始字符串做一个连接操作。

变长字符串的解包

根据上面的打包方式，我们可以轻松的解开打包串：

1 2 3

int_size = struct.calcsize("I") (i,), data = struct.unpack("I", data[:int_size]), data[int_size:] data_content = data[i:]

由于报文的长度 len(s) 我们使用定长的整型 "I" 进行了打包，所以解包的时候我们可以先将报文长度获取出来，之后再根据报文长度读取报文内容。

官方文档对于struct这个module的介绍

This module performs conversions between Python values and C structs represented as Python strings. This can be used in handling binary data stored in files or from network connections, among other sources.

struct. pack ( fmt,  v1,  v2,  ... )

Return a string containing the values v1, v2, ... packed according to the given format. The arguments must match the values required by the format exactly.

struct. unpack ( fmt,  string )

Unpack the string (presumably packed by pack(fmt, ...)) according to the given format. The result is a tuple even if it contains exactly one item. The string must contain exactly the amount of data required by the format (len(string)must equal calcsize(fmt)).

关于fmt的解释说明

官方文档：

By default, C types are represented in the machine’s native format and byte order, and properly aligned by skipping pad bytes if necessary (according to the rules used by the C compiler).

Alternatively, the first character of the format string can be used to indicate the byte order, size and alignment of the packed data, according to the following table:

Character	Byte order	Size	Alignment
@	native	native	native
=	native	standard	none
<	little-endian	standard	none
>	big-endian	standard	none
!	network (= big-endian)	standard	none

If the first character is not one of these, '@' is assumed.

Native byte order is big-endian or little-endian, depending on the host system. For example, Intel x86 and AMD64 (x86-64) are little-endian; Motorola 68000 and PowerPC G5 are big-endian; ARM and Intel Itanium feature switchable endianness (bi-endian). Use sys.byteorder to check the endianness of your system.

Native size and alignment are determined using the C compiler’s sizeofexpression. This is always combined with native byte order.

Standard size depends only on the format character; see the table in the Format Characters section.

Note the difference between '@' and '=': both use native byte order, but the size and alignment of the latter is standardized.

The form '!' is available for those poor souls who claim they can’t remember whether network byte order is big-endian or little-endian.

There is no way to indicate non-native byte order (force byte-swapping); use the appropriate choice of '<' or '>'.

Notes:

1. Padding is only automatically added between successive structure members. No padding is added at the beginning or the end of the encoded struct.
2. No padding is added when using non-native size and alignment, e.g. with ‘<’, ‘>’, ‘=’, and ‘!’.
3. To align the end of a structure to the alignment requirement of a particular type, end the format with the code for that type with a repeat count of zero. See Examples.

Format characters have the following meaning; the conversion between C and Python values should be obvious given their types. The ‘Standard size’ column refers to the size of the packed value in bytes when using standard size; that is, when the format string starts with one of '<', '>', '!' or '='. When using native size, the size of the packed value is platform-dependent.

Format	C Type	Python type	Standard size	Notes
x	pad byte	no value
c	char	string of length 1	1
b	signed char	integer	1	(3)
B	unsigned char	integer	1	(3)
?	_Bool	bool	1	(1)
h	short	integer	2	(3)
H	unsigned short	integer	2	(3)
i	int	integer	4	(3)
I	unsigned int	integer	4	(3)
l	long	integer	4	(3)
L	unsigned long	integer	4	(3)
q	long long	integer	8	(2), (3)
Q	unsigned long long	integer	8	(2), (3)
f	float	float	4	(4)
d	double	float	8	(4)
s	char[]	string
p	char[]	string
P	void *	integer		(5), (3)

比如big-endien储存的interger

可以用！Q

9.

实在是水平不够看不懂。。。弃坑了

原文：http://aosabook.org/en/500L/dbdb-dog-bed-database.html