1 单引号，双引号，三引号的区别

题目：分别阐述3种引号用的场景和区别

1. 单引号和双引号主要用来表示字符串

比如:
单引号:'python'
双引号:"python"

2. 三引号

三单引号:'''python ''',也可以表示字符串一般用来输入多行文本,或者用于大段的注释
三双引号："""python"""，一般用在类里面,用来注释类,这样省的写文档,直接用类的对象__doc__访问获得文档

区别:

若你的字符串里面本身包含单引号,必须用双引号
比如:"can't find the log\n"

2 Python的函数参数传递

题目：举例说明Python函数参数传递的几种形式，并说明函数传参是值传递还是引用传递

1. Python的参数传递有：

• 位置参数
• 默认参数
• 可变参数
• 关键字参数

2. 函数的传值到底是值传递还是引用传递，要分情况：

• 不可变参数用值传递：
  像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变不可变对象
• 可变参数用引用传递：
  比如像列表，字典这样的对象是通过引用传递，和C语言里面的用指针传递数组很相似，可变对象能在函数内部改变.

3. 具体例子：

#整数为不可变对象，用值传递
a = 1
def fun(a):
    a = 2
fun(a)
print a  # 1

#列表为可变对象，用引用传递
a = []
def fun(a):
    a.append(1)
fun(a)
print a  # [1]

3 lambda函数

题目：举例说明lambda的用法，并说明用lambda的优点

1. lambda的用法

lambda是匿名函数，用法如下: lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算。

2. lambda的优点：

lambda能和def做同样种类的工作，特别是对于那些逻辑简单的函数，直接用lambda会更简洁，而且省去取函数名的麻烦(给函数取名是个技术活)

4 字符串格式化:%和.format的区别

题目：说明字符串格式化方法%和.format的区别

1. 字符串格式化: .format
字符串的format函数非常灵活，很强大,可以接受的参数不限个数，并且位置可以不按顺序，而且有较为强大的格式限定符(比如:填充，对齐,精度等)

具体用法如下，字符串中花括号 {} 的部分会被format传入的参数替代，传入的值可以是字符串，也可以是数字或者别的对象。

>>> '{} {} {}'.format('a', 'b', 'c')
'a b c'

可以用数字指定传入参数的相对位置：

>>> '{2} {1} {0}'.format('a', 'b', 'c')
'c b a'

还可以指定传入参数的名称：

>>> '{color} {n} {x}'.format(n=10, x=1.5, color='blue')
'blue 10 1.5'

可以在一起混用：

>>> '{color} {0} {x} {1}'.format(10, 'foo', x = 1.5, color='blue')
'blue 10 1.5 foo'

可以用{<field name>:<format>}指定格式：

>>> from math import pi
>>> '{0:10} {1:10d} {2:10.2f}'.format('foo', 5, 2 * pi)
'foo                 5       6.28'

2. 字符串格式化: %
旧式的 % 方法进行格式化，具体规则与C中相同。

>>> s = "some numbers:"
>>> x = 1.34
>>> y = 2
>>> # 用百分号隔开，括号括起来
... t = "%s %f, %d" % (s, x, y)
>>> t
'some numbers: 1.340000, 2'

5 写函数: 输入一个字符串, 返回倒序排列的结果

题目：输入: string_reverse(‘abcdef’), 返回: ‘fedcba’,写出你能想到的多种方法

1. 利用字符串本身的翻转

def string_reverse1(text='abcdef'):
    return text[::-1]

2. 把字符串变成列表，用列表的reverse函数

def string_reverse2(text='abcdef'):
    lst = list(text)
    lst.reverse()
    return ''.join(lst)

3. 新建一个列表，从后往前取

def string_reverse3(text='abcdef'):
    lst = []
    for i in range(len(text)-1, -1, -1):
        lst.append(text[i])
    return ''.join(lst)

4. 利用双向列表deque中的extendleft函数

from collections import deque

def string_reverse4(text='abcdef'):
    d = deque()
    d.extendleft(text)
    return ''.join(d)

5. 递归

def string_reverse5(text='abcdef'):
    if len(text) <= 1:
        return text
    else:
        return string_reverse5(text[1:])+text[0]

6 按升序合并两个list, 并去除重复的元素

题目：按升序合并如下两个list, 并去除重复的元素
list1 = [2, 3, 8, 4, 9, 5, 6]
list2 = [5, 6, 10, 17, 11, 2]

1. 用set方法(最简单)

list3 = list1 + list2
print(sorted(list(set(list3))))

2. 递归方法（略）

7 Pythonic的代码

题目：写出你认为最Pythonic的代码

Pythonic编程风格是Python追求的一种风格，精髓就是追求直观，简洁而容易读.

1. 交互变量

• 非pythonic

temp = a
a = b
b = temp

• pythonic

a, b = b, a

2. 判断其值真假

name = 'Tim'
langs = ['AS3', 'Lua', 'C']
info = {'name': 'Tim', 'sex': 'Male', 'age':23 }

• 非pythonic

if name != '' and len(langs)>0 and info !={}:
    print('All True!')

• pythonic

if name and langs and info:
    print('All True!')

3. 列表推导式

[x for x in range(1,100) if x%2==0]

4. zip创建键值对

keys = ['Name', 'Sex', 'Age']
values = ['Jack', 'Male', 23]
dict(zip(keys,values))

8 range 和 xrange

题目：说明range和xrange的区别

xrange用法与 range 都在循环时使用且用法相同，所不同的是xrange生成的不是一个list对象，而是一个生成器。因此要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。

9 迭代器和生成器

题目：将列表生成式中[]改成() 之后数据结构是否改变

答：是，从列表变为生成器。

通过列表生成式，可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含百万元素的列表，不仅是占用很大的内存空间，如：我们只需要访问前面的几个元素，后面大部分元素所占的空间都是浪费的。因此，没有必要创建完整的列表（节省大量内存空间）。在Python中，我们可以采用生成器：边循环，边计算的机制—>generator

10 *args 和 **kwargs

题目：说明*args 和 **kwargs的使用

1. *args 的使用

当你不确定你的函数里将要传递多少参数时你可以用*args.例如,它可以传递任意数量的参数:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
...
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

2. **kwargs 的使用

**kwargs允许你使用没有事先定义的参数名:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

3. 其他

• *args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面.
• 任何函数都可以用 universal_func(*args, **kwargs)表达
• 当调用函数时你也可以用*和**语法

def print_three_things(a, b, c):
    print('a = {0}, b = {1}, c = {2}'.format(a,b,c))

mylist = ['aardvark', 'baboon', 'cat']
print_three_things(*mylist)

"""
a = aardvark, b = baboon, c = cat
"""

11 Python垃圾回收机制

题目：描述Python的垃圾回收机制

Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。

1. 引用计数

PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。

• 优点：简单、实时
• 缺点：维护引用计数消耗资源、循环引用

2. 标记-清除机制

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

3. 分代回收

分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合，索引数越大，对象存活时间越长。
举例： 当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中，当然，集合A中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。