Python interview preparing

Collection & Recommended:

1. CN - 论坛中看到。 - EN 英文原文真的真的很好好好T_T，看得让人感动T_T

总结个人感兴趣的问题（以下部分参照上面）：

1. python 的 函数传值by value 和 函数传址by reference.

In Python everything is an object and all variables hold references to objects.

As result you can not change the value of the reference but you can modify the object if it is mutable. 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　- See more at: THIS greet blog

理解：

Python，所有都是 对象。变量是 对象的引用。

不能改变 引用本身的值（如果想想C++的引用，reference是不可以再绑定到其他对象，可变的是引用指向的值），但是，如果对象是可变的(mutable)，你可以修改对象。

整理： Python 核心编程 4.8 - 标准类型分类

	存储模型	更新模型	访问模型
数值	原子	不可变immutable	直接
字符串	原子	不可变immutable	顺序
元组	容器	不可变immutable	顺序
列表	容器	可变mutable	顺序
字典	容器	可变mutable	映射

 

 

 

 

首先，python中 没有 ’传值‘ 和 ’传址‘ 的概念。

其次，我们希望探索的是， ’传值‘ 和 ’传址‘代表的行为，这有点像‘鸭子判别法’(From - <python cookbook>).

　　’传值‘行为 代表： 变量a作为参数传入函数func(x)中，func(x)对x的修改不会影响 a本身。

　　’传址‘行为 代表： 变量a作为参数传入函数func(x)中，func(x)对x的修改   会影响 a本身。

最后，python 类似‘传值’行为: immutable类(标准类型中)

　　　　　　类似‘传址’行为: mutable类(标准类型中)

　　我的疑问是，如果我自己创建了一个类class，作为变量传入函数，那么class的行为会是什么？这个行为，我可以控制（’传值‘行为 & ’传址‘行为）吗？

 

2. def test(*argv1, **argv2): pass

 http://www.cnblogs.com/kevin922/p/3157752.html - NO.53 - 可变数量的参数。 

　　C语言的“可变数量参数”怎么用呢？

 

3. List/Dict comprehensions 列表解析 字典解析 

　　3. 1. List Comprehensions  - THIS

# try to create a list like this:
>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
>>> vec1 = [[(x+y) for y in range(0, 4)] for x in range(1, 13, 4)]

　　另一个有趣的想法 

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> zip(a b)
[(1, 4), (2, 5), (3, 6)]
>>> map(list, zip(a,b))
[[1, 4], [2, 5], [3, 6]]

　　zip()的实现THIS

def zip(*args):
        if not args:
            raise TypeError('zip() expects one or more sequence arguments')
        ret = []
        i = 0
        try:
            while 1:
                item = []
                for s in args:
                    item.append(s[i])
                ret.append(tuple(item))
                i = i + 1
        except IndexError:
            return ret

　　我的问题是 zip(*argv) 这样可以unzip 但是 *argv 是什么？

　　　　*argv 是什么 - Answer

　　　　zip(*argv) - 析:

>>> zip(*[(1, 4), (2, 5), (3, 6)])
[(1, 2, 3), (4, 5, 6)]
>>> zip((1, 4), (2, 5), (3, 6))
[(1, 2, 3), (4, 5, 6)]

 　　　　最后!!!

　　　　-------------------------------   zip(*[iter(s)]*n). 解释 THIS_1, THIS_2

　　　　自己的理解是:

　　　　在一个list创建迭代器iter,然后因为操作符优先级(operator priority)的缘故,首先创建了 列表[iter, iter, iter],注意,是 列表, 然后对列表unpacking操作作为参数传入了zip(iter, iter, iter)函数.

　　　　先暂停,让我们考虑zip(a_list, b_list),假如len(a_list) 等于 len(b_list), zip(a_list, b_list) 的行为是: (a_list[0], b_list[0])组成tuple元组,(a_list[1], b_list[1])组成tuple元组,(a_list[2], b_list[2])组成tuple元组...

　　　　再回到zip(iter, iter, iter):

　　　　　　1. 跟C++相同,iter作为迭代器, 假想指针p, ++p之后,p位置会后移, 再次调用p时,要注意p所指向的位置.

　　　　　　2. 同时考虑python对 参数 left-to-right 从左至右 的处理: zip(iter@1, iter@2, iter@3). 注意, iter@1, iter@2, iter@3 就只是一个 iter.

　　　　　　3. zip(iter@1, iter@2, iter@3) 行为是: 遍历 iter@1(iter[0]), iter[0] -> iter[1]; 遍历 iter@2(iter[1]),  iter[1] -> iter[2]; 遍历 iter@3(iter[2]),  iter[2] -> iter[3]; (iter[0], iter[1], iter[2])组成tuple元组. 依次类推.

# 注意()改变的运算符优先级

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> zip(*[iter(a)]*3)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

>>> zip(*([iter(a)]*3))
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

>>> x = iter(a)
>>> zip(x, x, x)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

>>> x_list = [x] * 3
>>> x_list
[<listiterator object at 0x99dafec>, <listiterator object at 0x99dafec>, <listiterator object at 0x99dafec>]

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x = iter(a)
>>> zip(x, x, x)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
>>> zip(*[x, x, x])
[]
>>> zip(x, x, x)
[]
>>> x = iter(a)
>>> zip(*[x, x, x])
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
>>> x = iter(a)
>>> zip(*[x]*3)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

# This is the most interesting one I want to show u
>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> zip(*[iter(a)]*3)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
# 注意到zip()的实际行为了吗？在最后一次循环，无法分组的情况下，我的猜测是发生异常，终止了。
>>> zip(*[iter(a)]*4)
[(1, 2, 3, 4), (5, 6, 7, 8)]

# ----啊啊啊 就这样了!!!你们一定能明白了!!我想得头疼了!!!!

　　

　　3.2. dict comprehension - THIS

>>> [(k, v) for k in range(4) for v in range(4)]
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)]

>>> # like above, try this:
>>> {k : v for k in range(0, 4) for v in range(0, 4)}
{0: 3, 1: 3, 2: 3, 3: 3}

>>> # why above happened??? Try answer.

>>> {k: k for k in range(4)}
{0: 0, 1: 1, 2: 2, 3: 3}
>>> {k: 3 for k in range(4)}
{0: 3, 1: 3, 2: 3, 3: 3}

# Explain:
dict_test = {}
for k in range(0, 4):
    for v in range(0,4):
        dict_test[k] = v # finally, dict_test[0] = 3
# In a word, 不允许一个key对应多个value.

　　And, this is interesting: THIS

　　And, this is basic part: THIS

　　　　

4. Python 中 global的使用，产生的问题。

http://www.douban.com/group/topic/40864587/http://www.douban.com/group/topic/40864587/ 

#! /usr/bin/python                                                              
# Filename: global_test.py

x = 1
print x

def change():
    global x
    x += 1
    print 'change:', x

change()
print 'x:', x

 5. Python - generator

　　offical docs - THIS - 感觉看得不够

　　offical docs - THIS - search 'Generators'

generator

A function which returns an iterator. It looks like a normal function except that it contains yield statements for producing a series a values usable in a for-loop or that can be retrieved one at a time with the next() function. Each yield temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the generator resumes, it picks-up where it left-off (in contrast to functions which start fresh on every invocation).

-----

Generators are a simple and powerful tool for creating iterators. They are written like regular functions but use the yield statement whenever they want to return data. Each time next() is called, the generator resumes where it left-off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create.

# a generator that yields items instead of returning a list
def firstn(n):
    num = 0
    while num < n:
        yield num
        num += 1

　　看完上面，我的第一感受是- -！

　　yield 和 return！如果在for-loop中，不就是 continue 和 break 的区别吗！？！？

　　再一次深刻知道了自己的俗，是怎么的俗- -！明明是 Such a elegant language~ 我都能解释得这么俗- -！果然是吊丝编程啊- -！

# yield_test.py 
def reverse_yield(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse_yield('test1'):                                            
    print char

# interpretor
kevin922@MyWorld:~/pyShell$ python yield_test.py 
1
t
s
e
t

　　try again:

# yield_test.py
def reverse_yield(data):
    for index in range(len(data)-1, -1, -1):
        data[index]                                                            

for char in reverse_yield('test1'):
    print char

# interpretor

kevin922@MyWorld:~/pyShell$ python yield_test.py 
Traceback (most recent call last):
  File "yield_test.py", line 5, in <module>
    for char in reverse_yield('test1'):
TypeError: 'NoneType' object is not iterable

 　　again, try:

# yield_test.py
def reverse_yield(data):
    for index in range(len(data)-1, -1, -1):
        print data[index]

reverse_yield('test1')  

# interpreter
kevin922@MyWorld:~/pyShell$ python yield_test.py 
1
t
s
e
t

 6. Python - decorator

　　涉及‘元编程’的概念, NO.9, 讲解

 

 7. Python - with

　　NO.10, 讲解

 

 8. Python里面如何拷贝一个对象？

　　python cookbook 4.1

 

 9. python内存管理

 

 10. and-or技巧，说实话，这个技巧很糟糕，我不想使用。

 

11. python的pass语句作用

　　空语句。

 

12、如何在一个function里面设置一个全局的变量？
　　解决方法是在function的开始插入一个global声明

 

13. 参考NO.4的解答

a = 1

def change():
    a = a + 1 # why is this wrong?
    print a

pirnt a

# --------------------

a = 1

def change():
    # without that, why is this right?
    print a

pirnt a