[Python] 00 - Books

A.I. & Optimization

Advanced Machine Learning, Data Mining, and Online Advertising Services

Ref: Top 25 Python Programming Books

Ref: 廖雪峰的python教程

Ref: https://repl.it/languages/python3【在线编译调试python】

一、工程夯实策略

基础

进阶

高性能

二、自我评估

Ref: How to Hire Python Developers and Identify True Masters

/* implement */

面试问题收集

---

None类型

(1) 空类型的“否“ 即是None

空列表，空元组，空字典前面加not 都是None。

(2) None是全局的一个特殊的类型。

>>> type(None)
<class 'NoneType'>

>>> a=None
>>> b=None
>>> id(a)==id(b)
True

is 对比 ==

== None时，调用了eq。

>>> class test():
...     def __eq__(self,other):
...         return True
... 

>>> t = test()
>>> t is None
False
>>> t == None
True

陷阱：空List参数

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：

• • 当你使用默认参数调用时，一开始结果也是对的；
  • 但是，再次调用add_end()时，结果就不对了。

def add_end(L=[]):
    print('L = ' L)
    L.append('END')
    return L

add_end()
add_end()

Output：

>>> add_end()
L = []
['END']
>>> add_end()
L = ['END']
['END', 'END']

原因解释如下：

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]。

因为默认参数L也是一个变量，它指向对象[]。每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

简单的说就是，函数定义后，默认参数类似于一个static变量。

陷阱：Closure的内部变量

def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i*i　　　　# 问题所在：返回的该函数的i，却不属于自己
        fs.append(f)

    return fs

f1, f2, f3 = count()

print(f1())
print(f2())
print(f3())

-------
Output:
-------
9
9
9

解决方案：如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():

    def f(j):　　　　　　　　　　# 因为经过了函数的封装，所以保持了函数内部变量的独立性
        def g():
            return j*j
        return g

    fs = []
    for i in range(1, 4):
        fs.append(f(i)) 　　　# f(i)立刻被执行，因此i的当前值被传入f()

    return fs

f1, f2, f3 = count()

偏函数

简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

固定子函数的某些参数

>>> import functools
>>> int2 = functools.partial(int, base=2)　　# 固定了参数base=2
>>> int2('')
64
>>> int2('')
85

作为List 参数的默认元素

max2 = functools.partial(max, 10)

max2(5, 6, 7)
# 相当于
args = (10, 5, 6, 7)
max(*args)

与c++对比

---

字典，元素统计

Python：

def get_counts(sequence):
    counts = {}
    for x in sequence:
        if x in counts:
            counts[x] += 1
        else:
            counts[x] = 1
    return counts

c++：map切记元素为空时的陷阱

#include <iostream>
#include <map>

using namespace std;

int main()
{
    cout << "Hello World!" << endl;

    map<string, int> m;

    cout << m.size() << endl;
    m.insert(std::pair<string,int>("a",100));
    cout << m.size() << endl;

    return ;
}

字典，元素有么？

Python：in & not in

>>> 'a' in count
True
>>> 'a' not in count
False

C++：

iter = m.find(key);
if(iter!=m.end())
{
    return iter->second;
}
return null;

排序

C++ sort：

Goto: [c++] Associative Containers

Python sort：

如果是自定义排序呢？

python 字典（dict）的特点就是无序的，按照键（key）来提取相应值（value），

如果我们需要字典按值排序的话，那可以用下面的方法来进行：

(1) 按照value从大到小排序：

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}

# dic.iteritems() 得到[(键，值)]的列表。
# 然后用sorted方法，通过key这个参数，指定排序是按照value，也就是第2个元素d[1]的值来排序。
# reverse = True表示是需要翻转的，默认是从小到大，翻转的话，那就是从大到小。
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict

(2) 对字典按键（key）排序：

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[0]) # 按照第2个元素d[1]的值来排序
print dict

*(3) 遍历则使用：

for (current_state, current_position) in transitions:
#    print(current_state, tape[current_position])
    new_state, new_bit, direction = transitions[current_state, current_position]
    current_state = new_state
    tape[current_position] = new_bit
    if direction == 'R':
        current_position += 1
    else:
        current_position -= 1
    print(tape)

字符串，分割

python :

file = open('multiplication.txt', 'r')

program = file.readlines()
#print(program)

instructions = [line.split() for line in program if not line.startswith('#')]　　# filter method
#print(instructions)

#for instruction in instructions:
# print(instruction)

transitions = {}

### 1      2    3          4        5
### state, bit, new_state, new_bit, direction

for state, bit, new_state, new_bit, direction in instructions:
　　print(state, bit, new_state, new_bit, direction)
　　transitions[state, int(bit) ] = new_state, int(new_bit), direction
　　### 字典存储好数据，然后打印出来瞧上一瞧
print(transitions)

C++ : http://www.cplusplus.com/faq/sequences/strings/split/专题

The reality is that there are so many ways to split strings it is overwhelming. Here are some, in no particular order, with examples:

Method	Iterated or all-at-once	Delimiter						Empty Fields
		char	string	function	quotable	offset	no case	elided	trailing
Boost String Algorithms: Split	all-at-once	Y	Y	Y				4	Y
Boost String Algorithms: Split Regex	all-at-once	1	Y	regex	2		2	2	?
Boost Tokenizer	iterated3	Y	Y		Y	Y		opt	Y
Trolltech Qt’s QString::split()	all-at-once	Y	Y	regex	2		Y	opt	Y
GNU String Utility Functions: Split	all-at-once	1	Y						Y
iostreams and getline()	iterated3	Y						Y	Y
string::find_first_of()	all-at-once3		Y					Y	Y
strtok()	iterated3	1	Y					always	NO
Roll your own C tokenizer	iterated3	1	Y					opt	Y

#include <boost/algorithm/string.hpp>
#include <iostream>
#include <string>
#include <vector>

using namespace std;
using namespace boost;

void print( vector <string> & v )
{
  for (size_t n = ; n < v.size(); n++)
    cout << "\"" << v[n] << "\"\n";
  cout << endl;
}

int main()
{
  string s = "a,b, c ,,e,f,";
  vector <string> fields;

  cout << "Original = \"" << s << "\"\n\n";

  cout << "Split on \',\' only\n";
  split( fields, s, is_any_of( "," ) );
  print( fields );

  cout << "Split on \" ,\"\n";
  split( fields, s, is_any_of( " ," ) );
  print( fields );

  cout << "Split on \" ,\" and elide delimiters\n";
  split( fields, s, is_any_of( " ," ), token_compress_on );　　// <---- best
  print( fields );

  return ;
}

Original = "a,b, c ,,e,f,"

Split on ',' only
"a"
"b"
" c "
""
"e"
"f"
""

Split on " ,"
"a"
"b"
""
"c"
""
""
"e"
"f"
""

Split on " ," and elide delimiters
"a"
"b"
"c"
"e"
"f"
""

Result

End.