学习《python进阶》

Python 进阶技巧

参考python进阶

1. pdb 脚本调试

pdb是python自带的一个包，为python程序提供了一种交互式的源代码调试功能，主要特性包括设置断点， 
单步调试，进入函数调试，查看当前代码，查看栈片段、动态改变变量的值等
    

命令 | 解释
---|---
break 或 b | 设置断点
continue 或 c | 继续执行程序
list 或 l | 查看当前行代码段
step 或 s | 执行当前代码行， 并停留在第一个能停留的地方(相当于单步进入)
return 或 r |执行代码直到当前函数返回
exit 或 q | 终止并退出
next 或 n | 执行下一步（相当于单步跳过）
a | 打印当前函数的参数列表
pp  | 打印变量的值
help  |帮助

命令行：    python -m pdb  test.py   
从脚本内部运行：   pdb.set_trace()     

2. *args 的用法 [非键值对]

*args 和 **kwargs 主要用于函数定义。你可以将不定数量的参数传递给一个函数
这里的不定的意思是：预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字。
*args 是用来发送一个非键值对的可变数量的参数列表给一个函数

示例：  
def test_var_args(f_arg, *argv):
    print("first normal arg:", f_arg)
    for arg in argv:
        print("another arg through *argv:", arg)

test_var_args('yasoob', 'python', 'eggs', 'test')

输出：
first normal arg: yasoob
another arg through *argv: python
another arg through *argv: eggs
another arg through *argv: test

3. **kargs的用法 [键值对]

*kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数。 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs

示例：   
def greet_me(**kwargs):
    for key, value in kwargs.items():
        print("{0} == {1}".format(key, value))

>>> greet_me(name="yasoob")
name == yasoob

4. 生成器 Generators yield

生成器也是一种迭代器，但是你只能对其迭代一次。这是因为它们并没有把所有的值存在内存中，而是在运行时生成值。
你通过遍历来使用它们，要么用一个“for”循环，要么将它们传递给任意可以进行迭代的函数和结构。大多数时候生成器是以函数来实现的。
然而，它们并不返回一个值，而是yield(暂且译作“生出”)一个值
使用生成器的优点： 节省资源

4.1 可迭代对象（Iterable)

Python中任意的对象，只要它定义了可以返回一个迭代器的__iter__方法，或者定义了可以支持下标索引的__getitem__方法
(这些双下划线方法会在其他章节中全面解释)，那么它就是一个可迭代对象。简单说，可迭代对象就是能提供迭代器的任意对象

4.2 迭代器（Iterator）

任意对象，只要定义了next(Python2) 或者__next__方法，它就是一个迭代器。就这么简单。现在我们来理解迭代(iteration)

4.3 迭代

用简单的话讲，它就是从某个地方（比如一个列表）取出一个元素的过程。当我们使用一个循环来遍历某个东西时，这个过程本身就叫迭代。
现在既然我们有了这些术语的基本理解，那我们开始理解生成器吧。

示例：   
def generator_function():
for i in range(3):
    yield i
gen = generator_function()
print(next(gen))
# Output: 0
print(next(gen))
# Output: 1
print(next(gen))
# Output: 2
print(next(gen))
# Output: Traceback (most recent call last):
#            File "<stdin>", line 1, in <module>
#         StopIteration

my_string = "Yasoob"
my_iter = iter(my_string)
next(my_iter)
# Output: 'Y'

5. Map

Map 会将一个函数映射到一个输入列表的所有元素上
map(function_to_apply, list_of_inputs)

简单示例1：
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))
简单示例2：
def multiply(x):
    return (x*x)
def add(x):
        return (x+x)

funcs = [multiply, add]
for i in range(5):
    value = map(lambda x: x(i), funcs)
    print(list(value))
    # 译者注：上面print时，加了list转换，是为了python2/3的兼容性
    #        在python2中map直接返回列表，但在python3中返回迭代器
    #        因此为了兼容python3, 需要list转换一下
# Output:
# [0, 0]
# [1, 2]
# [4, 4]
# [9, 6]
# [16, 8]

6. Filter

filter过滤列表中的元素，并且返回一个由所有符合要求的元素所构成的列表，符合要求即函数映射到该元素时返回值为True

示例：
number_list = range(-5, 5)
less_than_zero = filter(lambda x: x < 0, number_list)
print(list(less_than_zero))  
# 译者注：上面print时，加了list转换，是为了python2/3的兼容性
#        在python2中filter直接返回列表，但在python3中返回迭代器
#        因此为了兼容python3, 需要list转换一下
# Output: [-5, -4, -3, -2, -1]

7. Reduce

当需要对一个列表进行一些计算并返回结果时，Reduce 是个非常有用的函数。举个例子，当你需要计算一个整数列表的乘积时。

示例：
from functools import reduce
product = reduce( (lambda x, y: x * y), [1, 2, 3, 4] )
# Output: 24

8. set（集合）数据结构

set(集合)是一个非常有用的数据结构。它与列表(list)的行为类似，区别在于set不能包含重复的值。

示例：
some_list = ['a', 'b', 'c', 'b', 'd', 'm', 'n', 'n']
duplicates = set([x for x in some_list if some_list.count(x) > 1])
print(duplicates)
### 输出: set(['b', 'n'])

9. 三元运算符

三元运算符通常在Python里被称为条件表达式，这些表达式基于真(true)/假(not)的条件判断，在Python 2.4以上才有了三元操作

示例：
is_fat = True
state = "fat" if is_fat else "not fat"
或者：
fat = True
fitness = ("skinny", "fat")[fat]  # （返回假， 返回真）[真或假]
print("Ali is ", fitness)
#输出: Ali is fat

10. 装饰器

装饰器(Decorators)是Python的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。

日志示例：
from functools import wraps
def logit(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging
@logit
def addition_func(x):
   """Do some math."""
   return x + x
result = addition_func(4)
# Output: addition_func was called

11. global 和 return

global变量意味着我们可以在函数以外的区域都能访问这个变量， 但建议不要使用global
return 

12 对象变动（Mutation)

对象可变性(mutability)在作怪。每当你将一个变量赋值为另一个可变类型的变量时，对这个数据的任意改动会同时反映到这两个变量上去。新变量只不过是老变量的一个别名而已

示例：
foo = ['hi']
print(foo)
# Output: ['hi']
bar = foo
bar += ['bye']
print(foo)
# Output: ['hi', 'bye']

13 slots

Python中，每个类都有实例属性。默认情况下Python用一个字典来保存一个对象的实例属性。这非常有用，因为它允许我们在运行时去设置任意的新属性
然而，对于有着已知属性的小类来说，它可能是个瓶颈。这个字典浪费了很多内存
需要使用__slots__来告诉Python不要使用字典，而且只给一个固定集合的属性分配空间

示例：
class MyClass(object):
__slots__ = ['name', 'identifier']
def __init__(self, name, identifier):
    self.name = name
    self.identifier = identifier
    self.set_up()
# ...

14. 容器(collections)

Python附带一个模块，它包含许多容器数据类型，名字叫作collections。我们将讨论它的作用和用法
defaultdict 使用defaultdict较多，与dict类型不同，你不需要检查key是否存在
counter 是一个计数器，它可以帮助我们针对某项数据进行计数
deque  提供了一个双端队列，你可以从头/尾两端添加或删除元素
namedtuple
enum.Enum

defaultdict示例：
from collections import defaultdict
colours = (
    ('Yasoob', 'Yellow'),
    ('Ali', 'Blue'),
    ('Arham', 'Green'),
    ('Ali', 'Black'),
    ('Yasoob', 'Red'),
    ('Ahmed', 'Silver'),
)
favourite_colours = defaultdict(list)
for name, colour in colours:
    favourite_colours[name].append(colour)
print(favourite_colours)

counter 示例：
favs = Counter(name for name, colour in colours)
print(favs)

deque示例：
d = deque()
d.append('1')
d.append('2')
print(len(d))  ## 输出: 2
print(d[0])  ## 输出: '1'
print(d[-1])  ## 输出: '2'
d = deque(range(5))
print(len(d))   ## 输出: 5
d.popleft()   ## 输出: 0
d.pop()  ## 输出: 4
print(d)  ## 输出: deque([1, 2, 3])

d = deque(maxlen=30)  #现在当你插入30条数据时，最左边一端的数据将从队列中删除。

15 dir

返回一个列表，列出了一个对象所拥有的属性和方法

示例：
my_list = [1, 2, 3]
dir(my_list)
# Output: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
# '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
# '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
# '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__',
# '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop',
# 'remove', 'reverse', 'sort']

16 type和id

type函数返回一个对象的类型
id()函数返回任意不同种类对象的唯一ID

17 脚本分析

能在定位你的脚本中的性能瓶颈时，会非常奏效
python -m cProfile  my_script.py 

18 for/else

for循环还有一个else从句，我们大多数人并不熟悉。这个else从句会在循环正常结束时执行。这意味着，循环没有遇到任何break. 一旦你掌握了何时何地使用它，它真的会非常有用.

示例：
for item in container:
    if search_something(item):
        # Found it!
        process(item)
        break
else:
    # Didn't find anything..
    not_found_in_container()

19. C语言扩展

开发者有三种方法可以在自己的Python代码中来调用C编写的函数-ctypes，SWIG，Python/C API。每种方式也都有各自的利弊
你要提升代码的运行速度，而且你知道C要比Python快50倍以上 - C语言中有很多传统类库，而且有些正是你想要的，但你又不想用Python去重写它们 - 想对从内存到文件接口这样的底层资源进行访问 - 不需要理由，就是想这样做

19.1 Ctypes

Python中的ctypes模块可能是Python调用C方法中最简单的一种。ctypes模块提供了和C语言兼容的数据类型和函数来加载dll文件，因此在调用时不需对源文件做任何的修改。
也正是如此奠定了这种方法的简单性
在Python文件中，一开始先导入ctypes模块，然后使用CDLL函数来加载我们创建的库文件。这样我们就可以通过变量adder来使用C类库中的函数了。
当adder.add_int()被调用时，内部将发起一个对C函数add_int的调用。ctypes接口允许我们在调用C函数时使用原生Python中默认的字符串型和整型。

求和示例：
//sample C file to add 2 numbers - int and floats
#include <stdio.h>
int add_int(int, int);
float add_float(float, float);
int add_int(int num1, int num2){
    return num1 + num2;
}
float add_float(float num1, float num2){
    return num1 + num2;
}

接下来将C文件编译为.so文件(windows下为DLL)。下面操作会生成adder.so文件

#For Linux
$  gcc -shared -Wl,-soname,adder -o adder.so -fPIC add.c

选项	解释
-shared	生成共享目标文件。通常用在建立共享库时
-Wl,-soname, adder	此选项传递option给连接程序;如果option中间有逗号,就将option分成多个选项,然后传递给会连接程序, -soname则指定了动态库的soname(简单共享名，Short for shared object name)
-o	生成指定的输出文件。用在生成可执行文件时
-fPIC	作用于编译阶段，在编译动态库时(.so文件)告诉编译器产生与位置无关代码(Position-Independent Code)，若未指定-fPIC选项编译.so文件，则在加载动态库时需进行重定向

#For Mac
$ gcc -shared -Wl,-install_name,adder.so -o adder.so -fPIC add.c

现在在你的Python代码中来调用它

from ctypes import *
#load the shared object file
adder = CDLL('./adder.so')
#Find sum of integers
res_int = adder.add_int(4,5)
print "Sum of 4 and 5 = " + str(res_int)
#Find sum of floats
a = c_float(5.5)
b = c_float(4.1)
add_float = adder.add_float
add_float.restype = c_float
print "Sum of 5.5 and 4.1 = ", str(add_float(a, b))
#而对于其他类似布尔型和浮点型这样的类型，必须要使用正确的ctype类型才可以。如向adder.add_float()函数传参时,
#我们要先将Python中的十进制值转化为c_float类型，然后才能传送给C函数

19.2 Swig

SWIG是Simplified Wrapper and Interface Generator的缩写。是Python中调用C代码的另一种方法。在这个方法中，开发人员必须编写一个额外的接口文件来作为SWIG(终端工具)的入口。
Python开发者一般不会采用这种方法，因为大多数情况它会带来不必要的复杂。而当你有一个C/C++代码库需要被多种语言调用时，这将是个非常不错的选择。

19.3 Python/C API

Python/C API可能是被最广泛使用的方法。它不仅简单，而且可以在C代码中操作你的Python对象。
这种方法需要以特定的方式来编写C代码以供Python去调用它。所有的Python对象都被表示为一种叫做PyObject的结构体，并且Python.h头文件中提供了各种操作它的函数。
例如，如果PyObject表示为PyListType(列表类型)时，那么我们便可以使用PyList_Size()函数来获取该结构的长度，类似Python中的len(list)函数。
大部分对Python原生对象的基础函数和操作在Python.h头文件中都能找到。

示例：
//Python.h has all the required function definitions to manipulate the Python objects
#include <Python.h>

//This is the function that is called from your python code
static PyObject* addList_add(PyObject* self, PyObject* args){

    PyObject * listObj;
    //The input arguments come as a tuple, we parse the args to get the various variables
    //In this case it's only one list variable, which will now be referenced by listObj
    if (! PyArg_ParseTuple( args, "O", &listObj ))
        return NULL;
    //length of the list
    long length = PyList_Size(listObj);
    //iterate over all the elements
    int i, sum =0;
    for (i = 0; i < length; i++) {
        //get an element out of the list - the element is also a python objects
        PyObject* temp = PyList_GetItem(listObj, i);
        //we know that object represents an integer - so convert it into C long
        long elem = PyInt_AsLong(temp);
        sum += elem;
    }
    //value returned back to python code - another python object
    //build value here converts the C long to a python integer
    return Py_BuildValue("i", sum);
}
//This is the docstring that corresponds to our 'add' function.
static char addList_docs[] =
"add(  ): add all elements of the list\n"
/* This table contains the relavent info mapping -
   <function-name in python module>, <actual-function>,
   <type-of-args the function expects>, <docstring associated with the function>
*/
static PyMethodDef addList_funcs[] = {
    {"add", (PyCFunction)addList_add, METH_VARARGS, addList_docs},
    {NULL, NULL, 0, NULL}
};
/*
   addList is the module name, and this is the initialization block of the module.
   <desired module name>, <the-info-table>, <module's-docstring>
*/
PyMODINIT_FUNC initaddList(void){
    Py_InitModule3("addList", addList_funcs,
            "Add all ze lists");
}

20. python 2+3 兼容

第一种也是最重要的方法，就是导入__future__模块。它可以帮你在Python2中导入Python3的功能
    from __future__ import with_statement
    or
    from __future__ import print_function
第二种 模块重命名  
    try:
        import urllib.request as urllib_request  # for Python 3
    except ImportError:
        import urllib2 as urllib_request  # for Python 2
第三种 过期的Python2内置功能
    from future.builtins.disabled import *

21 上下文管理器(Context managers)

上下文管理器允许你在有需要的时候，精确地分配和释放资源
最常用： with语句

示例：
with  open('hello.txt', 'w') as f:
    f.write("hello world!")
上面这段代码是打开一个文件hello.txt，往里面写入hello world，然后关闭该文件
它等价于：
f = open('hello.txt', 'w')
try :
    f.write("hello world")
finally:
    f.close()

21.1 基于类的实现

一个上下文管理器的类，最起码要定义__enter__和__exit__方法。
让我们来构造我们自己的开启文件的上下文管理器，并学习下基础知识。

示例：
class File(object):
    def __init__(self, file_name, method):
        self.file_obj = open(file_name, method)
    def __enter__(self):
        return self.file_obj
    def __exit__(self, type, value, traceback):
        self.file_obj.close()

with File("demo.txt", 'w') as f:
    f.write("hello world")

• with语句先暂存了File类的__exit__方法
• 然后它调用File类的__enter__方法
• __enter__方法打开文件并返回给with语句
• 打开的文件句柄被传递给f参数
• 我们使用.write()来写文件
• with语句调用之前暂存的__exit__方法
• __exit__方法关闭了文件

21.2 基于生成器的实现

还可以用装饰器(decorators)和生成器(generators)来实现上下文管理器。
Python有个contextlib模块专门用于这个目的。我们可以使用一个生成器函数来实现一个上下文管理器，而不是使用一个类。

示例：
from contextlib import contextmanager
@contextmanager
def open_file(name):
    f = open(name, 'w')
    yield f
    f.close()
    
with open_file('some_file.txt') as f:
    f.write('hello world!')