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中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。
