那些坑爹的python面试题

python基础知识思维导图

Python基础：

说说你眼中的python( 2 )

谈谈你对python和其他语言的区别

1. python 中，变量是以内容为基准而不是像 c 中以变量名为基准；

2. python 中，一个变量可以以多个名称访问；

3. python 中，数字类型的值是不可变的；

4. python 中，编译器会有一个小整数池的概念

谈谈你了了解的python种类以及相关特点

Python的种类：

  - Cpython：使用 C 解释器来解释扩展名：.pyc C解释器 -> .pyc(字节码) -> 机器码 -> cpu

  - Jpython：使用 Java 解释器 java 字节码->机器码 -> cpu

  - ironpython：使用C#解释器 C# 字节码 -> 机器码 -> cpu

    PYPY：运行速度快，原理：解释器->字节码->编译成机器码->直接运行机器码，用户运行时直接使用机器码，所以运行速度快。

字节码和机器器码的关系和区别？

- 机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。

- 通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。

- 字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

为什么要学python

1. 编译型语言：一次性，将全部的程序编译成二进制文件，然后在运行。（c，c++ ，go）

    优点：运行速度快。

    缺点：开发效率低，不能跨平台。

2. 解释型语言：当你的程序运行时，一行一行的解释，并运行。（python ， PHP）

    优点：调试代码很方便，开发效率高，并且可以跨平台。

    缺点：运行速度慢。

3. 我对程序的定义是人可以读懂，而机器刚好可以执行的一段代码，注重于代码的可读性。

   而Python的定位是“优雅”、“明确”、“简单”，用它编写的程序简单易懂，这与我当初的想法不谋而合

pep8规范

代码编排

  - 缩进。4个空格的缩进

  - 每行最大长度79，换行可以使用反斜杠

  - 类和top-level函数定义之间空两行；类中的方法定义之间空一行；函数内逻辑无关段落之间空一行；其他地方尽量不要再空行。

文档编排

  - 模块内容的顺序：按标准、三方和自己编写顺序依次排放，之间空一行

  - 不要在一句import中多个库

空格的使用

注释

文档描述

py2与py3

Python2和Python3的区别

1. 性能

  - Py3.x性能比Py2.5慢15%，但还有很大的提升空间。

2.编码

  - Py3.X源码文件默认使用utf-8编码

3. 语法

  - 去除print语句

  - 关键词加入as 和with，还有True,False,None

  - 删除了raw_input，用input代替

  - 新的metaclass语法

4. 字符串和字节串

  - 字符串只有str一种类型

5.数据类型

  - 只有一种整型——int

  - 新增了bytes类型

6.面向对象

  - 容器类和迭代器类被ABCs化，所以cellections模块里的类型比Py2.5多了很多

  - 迭代器的next()方法改名为__next__()，并增加内置函数next()，用以调用迭代器的__next__()方法

range和xrange的区别

两者的区别是xrange返回的是一个可迭代的对象，range返回的则是一个列表. 同时效率更高，更快。

  - 原因是实现的时候使用了 yield（此为python2.x回答，python3已删除xrange）

Python3和Python2中 int 和 long 的区别
```
int <= 32 位整数
long > 32 位整数
```

文件操作时：xreadlines和readlines的区别

xreadlines = 返回一个生成器对象，

readlines =  遍历文件所有行

进制转换

二进制转换成十进制：v = "0b1111011"

print(int(v,2)) # 可将任意进制数转换成十进制数(数字,这是多少进制)

十进制转换成二进制：v = 18
```
print(bin(v))
```

八进制转换成十进制：v = "011"

print(int(v,8)) # 可将任意进制数转换成十进制数(数字,这是多少进制)

十进制转换成八进制：v = 30
```
print(oct(v))
```

十六进制转换成十进制：v = "0x12"

print(int(v,16)) # 可将任意进制数转换成十进制数(数字,这是多少进制)

运算符 ( 8 )

各类运算符详解

各类运算符优先级

运算符	                        描述

**	                        指数 (最高优先级)

~ + -	                        按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //	                乘，除，取模和取整除

+ -	                        加法减法

>> <<                      右移，左移运算符

&	                        位 'AND'

^ |	                        位运算符

<= < > >=                   比较运算符

<> == !=	                等于运算符

= %= /= //= -= += *= **=	赋值运算符

is is not	                身份运算符

in not in	                成员运算符

and or not	                逻辑运算符

求结果：2 & 5

按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

Python结果：0

求结果：2 ^ 5

按位异或运算符：当两对应的二进位相异时，结果为1

Python结果：7

求结果：1 or 3

x or y

布尔"或" ：如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

Python结果：1

求结果：1 and 3

x and y

布尔"与" - ：

如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

python结果：>1

求结果：0 and 2 and 1
```
Python结果： 0
```
求结果：0 and 2 or 1
```
Python结果： 1
```
求结果：0 and 2 or 1 or 4
```
Python结果：1
```
求结果：0 or False and 1
```
Python结果：False
```
用⼀行代码实现数值交换： a = 1 b = 2
```
b,a = a,b
```
123

数据结构( 2 )

基本的数据类型和方法都有哪些

列表：list

    - list.append(obj) # 在列表末尾添加新的对象

    - list.count(obj)  # 统计某个元素在列表中出现的次数

    - list.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

    - list.index(obj)  # 从列表中找出某个值第一个匹配项的索引位置

    - list.insert(index, obj)# 将对象插入列表

    - list.pop(obj=list[-1]) # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

    - list.remove(obj) # 移除列表中某个值的第一个匹配项

    - list.reverse()   # 反向列表中元素

    - list.sort([func])# 对原列表进行排序

    - list.clear()     # 清空列表

    - list.copy()      # 复制列表

字典：dict

    - popitem()    # 随机返回并删除字典中的一对键和值(一般删除末尾对)。

    - key in dict  # 如果键在字典dict里返回true，否则返回false

    - radiansdict.copy()   # 返回一个字典的浅复制

    - radiansdict.keys()   # 以列表返回一个字典所有的键

    - radiansdict.items()  # 以列表返回可遍历的(键, 值) 元组数组

    - radiansdict.clear()  # 删除字典内所有元素

    - radiansdict.values() # 以列表返回字典中的所有值

    - radiansdict.fromkeys()    # 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

    - radiansdict.update(dict2) # 把字典dict2的键/值对更新到dict里

    - radiansdict.get(key, default=None)        # 返回指定键的值，如果值不在字典中返回default值

    - radiansdict.setdefault(key, default=None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

    - pop(key[,default])   # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

字符串：str

    - upper()      # 转换字符串中的小写字母为大写。

    - title()      # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。

    - lower()      # 转换字符串中所有大写字符为小写。

    - rstrip()     # 删除字符串字符串末尾的空格.

    - lstrip()     # 截掉字符串左边的空格或指定字符。

    - max(str)     # 返回字符串 str 中最大的字母。

    - min(str)     # 返回字符串 str 中最小的字母。

    - join(seq)    # 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

     ...

    MySlef

整数：int

    - bit_length()  # 查询以二进制表示一个数字的值所需的位数

    - int.from_bytes(bytes,byteorder)  # 返回给定字节数组所表示的整数。

    - int.to_bytes(length,byteorder)   # 返回表示整数的字节数组。

元组：tuple

    - len(tuple) # 计算元组元素个数。

    - max(tuple) # 返回元组中元素最大值。

    - min(tuple) # 返回元组中元素最小值。

    - tuple(seq) # 将列表转换为元组。

集合：set

    - set1 = set({1, 2, 'barry'}) # 创建集合

    - set2 = {1, 2, 'barry'}      # 创建集合

    - add  # 将元素添加到集合中。如果元素已经存在，这不起作用。

    - del set1  # 删除集合- update # 迭代增加

    - clear  # 删除此集合中的所有元素

    - remove # 删除一个元素

    - pop    # 随机删除一个元素

    - issubset    # 子集

    - issuperset  # 超集

    - union  # 并集。（| 或者 union）

    - difference # 差集。（- 或者 difference）

    - intersection  # 交集。（&  或者 intersection）

    - isdisjoint    # 如果两个集合有一个空交点，则返回True

    - intersection_update  # 用它自己和另一个交集更新一个集合。

    - difference_update  # 删除另一个集合中本集合所拥有的所有元素

    - symmetric_difference  # 反交集。 （^ 或者 symmetric_difference）

浮点：float

    - is_integer # 如果浮点数是整数，则返回True

collections：Python内建的一个集合模块，提供了许多有用的集合类。

    - Counter     # 是一个简单的计数器，例如，统计字符出现的个数：

    - OrderedDict # 可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key：

    - deque       # 是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

    - defaultdict # 使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

可变与不可变类型

可变：

  - list,  - dict

不可变：

  -str,  - int,  - tuple,  - float,

常⽤字符串格式化有哪些？

1.占位符%

%d 表示那个位置是整数；%f 表示浮点数；%s 表示字符串

  - print('Hello,%s' % 'Python')

  - print('Hello,%d%s%.2f' % (666, 'Python', 9.99)) # 打印：Hello,666Python10.00

2.format

  - print('{k} is {v}'.format(k='python', v='easy'))  # 通过关键字

  - print('{0} is {1}'.format('python', 'easy'))      # 通过关键字

常用字符串格式化有哪些？
```
- 0

- ""

- []

- {}

- (,)

- None
```
*Python2和Python3有差吗
```
Python2和Python3有差吗
```
Python2和Python3有差吗
```
is和==的区别
```
123
123
123
123
123
123

函数( 9 )

函数参数传递的是什么？引用、内存地址

# 默认参数尽量避免使用可变数据类型

# 默认参数只会被执行一次：第一次调用函数时，默认参数被初始化为【】，以后每次调用时都会使用已经初始化的【】。

>>> def func(a,a1 = []):  #默认参数

...     a1.append(a)

...     print(a1)

>>> func()

[1]

>>> func()

[1, 1]

>>> func()

[1, 1, 1]

>>> func()

[1, 1, 1, 1]

闭包函数

def foo():

    m, n=3, 5

    def bar():

        a=4

        return m+n+a

    return bar

>>>bar =  foo()

>>>bar()

12

说明：

bar在foo函数的代码块中定义。我们称bar是foo的内部函数。

在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。

简单的说，这种内部函数可以使用外部函数变量的行为，就叫闭包。

- 闭包的意义与应用： 延迟计算;

- 闭包的意义：      返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

装饰器就是闭包函数的一种应用场景

谈谈你对闭包的理解？

说明：

bar在foo函数的代码块中定义。我们称bar是foo的内部函数。

在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。

简单的说，这种内部函数可以使用外部函数变量的行为，就叫闭包。

闭包的意义与应用：

# 装饰器就是闭包函数的一种应用场景

# 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

# 应用领域：延迟计算（原来我们是传参，现在我们是包起来）

    from urllib.request import urlopen

    def index(url):

        def get():

            return urlopen(url).read()

        return get

    baidu=index('http://www.baidu.com')

    print(baidu().decode('utf-8'))

必会内置函数 - map

介绍：

    会根据提供的函数对指定序列做映射。

    第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法：

    map(function, iterable, ...)

      - function --  函数，有两个参数

      - iterable  --  一个或多个序列

应用示例：

>>>def square(x) :            # 计算平方数

...     return x ** 2

...

>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方

[1, 4, 9, 16, 25]

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

[3, 7, 11, 15, 19]

必会内置函数 - filter

介绍：

    函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

    该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法：

    filter(function, iterable)

      - function -- 判断函数。

      - iterable -- 可迭代对象。

应用示例1：过滤出列表中的所有奇数：

    def is_odd(n):

        return n % 2 == 1

    newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

        print(newlist)

    >>>[1, 3, 5, 7, 9]

应用示例2：过滤出1~100中平方根是整数的数

    import math

    def is_sqr(x):

        return math.sqrt(x) % 1 == 0

    newlist = filter(is_sqr, range(1, 101))

    print(newlist)

    >>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

应用示例3：filter相较于py2的区别

    python2中返回的是过滤后的列表, 而python3中返回到是一个filter类

    filter类实现了__iter__和__next__方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对python2提升了性能, 可以节约内存。

    a = filter(lambda x: x % 2 == 0, range(10))

    print(a)

    >>><filter object at 0x000001CC57668518>

必会内置函数 - zip

介绍：

    函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

语法：

    zip([iterable, ...])

      - iterabl -- 一个或多个迭代器;

返回值：

    - 返回元组列表。

应用示例：

    >>>a = [1,2,3]

    >>> b = [4,5,6]

    >>> c = [4,5,6,7,8]

    >>> zipped = zip(a,b)     # 打包为元组的列表

    [(1, 4), (2, 5), (3, 6)]

    >>> zip(a,c)              # 元素个数与最短的列表一致

    [(1, 4), (2, 5), (3, 6)]

    >>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式

    [(1, 2, 3), (4, 5, 6)]

必会内置函数 - isinstance

介绍：

    函数来判断一个对象是否是一个已知的类型，类似 type()。

语法：

    isinstance(object, classinfo)

      - object -- 实例对象。

      - classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值：

    如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

应用示例：

    >>>a = 2

    >>> isinstance (a,int)

    True

    >>> isinstance (a,str)

    False

    >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True

    True

isinstance() 与 type()的区别

介绍

1. type() 不会认为子类是一种父类类型，不考虑继承关系。

2. isinstance() 会认为子类是一种父类类型，考虑继承关系。

# 如果要判断两个类型是否相同推荐使用 isinstance()。

示例：

    class A:

        pass

    class B(A):

        pass

    isinstance(A(), A)    # returns True

    type(A()) == A        # returns True

    isinstance(B(), A)    # returns True

    type(B()) == A        # returns False

pass的作用

 - 1. 不做任何事情，一般用做占位语句。

 - 2. pass是空语句，是为了保持程序结构的完整性。

*args和**kwarg的作用

位置参数（positional argument）

关键词参数（keyword argument）

  - *args表示任何多个无名参数，它本质是一个 tuple ；

  - **kwargs表示关键字参数，它本质上是一个 dict ；

  - 并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前。

is和==的区别

  - is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。莱布尼茨说过：“世界上没有两片完全相同的叶子”，这个is正是这样的比较，
比较是不是同一片叶子（即比较的id是否相同，这id类似于人的身份证标识）。

  - == 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。这里比较的并非是同一片叶子，可能叶子的种类或者脉络相同就可以了。

       默认会调用对象的 __eq__()方法。

函数的应用

⼀⾏代码实现9*9乘法表

print('\n'.join([' '.join(['%s*%s=%-2s' % (j, i, i * j) for j in range(1, i + 1)]) for i in range(1, 10)]))

如何实现 “1,2,3” 变成 [‘1’,’2’,’3’]
```
 - list("1,2,3".split(','))
```
如何实现[‘1’,’2’,’3’]变成[1,2,3]
```
[int(x) for x in ['1','2','3']]
```
如何⽤⼀⾏代码⽣成[1,4,9,16,25,36,49,64,81,100]
```
[i*i for i in range(1,11)]
```

⼀行代码实现删除列表中重复的值

list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

请编写一个函数实现将IP地址转换成一个整数
如 10.3.9.12 转换规则为：
10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

a = "10.3.9.12"

def func(ip):

    Iplist = ip.split(".")  # ['10', '3', '9', '12']

    res = " "

    temp = []

    for i in Iplist:        # <class 'str'>

        i = int(i)          # <class 'int'>

        i = bin(i)[2:]      # <class 'str'>

        temp.append(i.rjust(8, "0"))   # 右对齐，向左填充数据

    res = res.join(temp)

    return res

# 一行代码实现：

b = "".join([" ".join(str(bin(int(i))[2:]).rjust(8,"0") for i in a.split("."))])

print(func(a))

- "00001010 00000011 00001001 00001100"

用Python实现⼀个⼆分查找的函数二分查找算法：
简单的说，就是将一个列表先排序好，比如按照从小到大的顺序排列好，当给定一个数据，比如3，查找3在列表中的位置时，可以先找到列表中间的数li[middle]和3进行比较，当它比3小时，那么3一定是在列表的右边，反之，则3在列表的左边，比如它比3小，则下次就可以只比较[middle+1, end]的数，继续使用二分法，将它一分为二，直到找到3这个数返回或者列表全部遍历完成（3不在列表中）
优点：效率高，时间复杂度为O(logN)；
缺点：数据要是有序的，顺序存储。
```
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def search(someone, li):

    l = -1

    h = len(li)

    while l + 1 != h:

        m = int((l + h) / 2)

        if li[m] < someone:

            l = m

        else:

            h = m

    p = h

    if p >= len(li) or li[p] != someone:

        print("元素不存在")

    else:

        str = "元素索引为%d" % p

        print(str)

search(3, li)  # 元素索引为2
```
1
1
1
1
1
1

请⽤代码简答实现stack

1. Stack() 创建一个新的空栈

2. push(item) 添加一个新的元素item到栈顶

3. pop() 弹出栈顶元素

4. peek() 返回栈顶元素

5. is_empty() 判断栈是否为空

6. size() 返回栈的元素个数

class Stack(object):

    """栈"""

    def __init__(self):

         self.items = []

    def is_empty(self):

        """判断是否为空"""

        return self.items == []

    def push(self, item):

        """加入元素"""

        self.items.append(item)

    def pop(self):

        """弹出元素"""

        return self.items.pop()

    def peek(self):

        """返回栈顶元素"""

        return self.items[len(self.items)-1]

    def size(self):

        """返回栈的大小"""

        return len(self.items)

if __name__ == "__main__":

    stack = Stack()

    stack.push("hello")

    stack.push("world")

    stack.push("lcg")

    print stack.size()

    print stack.peek()

    print stack.pop()

    print stack.pop()

    print stack.pop()

内置函数：map、reduce、filter的用法和区别

map：遍历序列，对序列中每个元素进行操作，最终获取新的序列。

  - 每个元素增加100：

    - li = [11, 22, 33]

    - new_list = map(lambda a: a + 100, li)

  - 两个列表对应元素相加

    - li = [11, 22, 33]

    - sl = [1, 2, 3, 4]

    - new_list = map(lambda a, b: a + b, li, sl)

filter：对于序列中的元素进行筛选，最终获取符合条件的序列。

  - 获取列表中大于12的所有元素集合

    - li = [11, 22, 33]

    - new_list = filter(lambda arg: arg > 22, li)

    - # filter第一个参数为空，将获取原来序列

reduce：对于序列内所有元素进行累计操作。

  - 获取序列所有元素的和

    - li = [11, 22, 33]

    - result = reduce(lambda arg1, arg2: arg1 + arg2, li)

  - # reduce的第一个参数，函数必须要有两个参数

  - # reduce的第二个参数，要循环的序列

  - # reduce的第三个参数，初始值

函数的骚操作( 8 )

手写：三元运算符

>>> val = "aaa" if 1==1 else "bbb"

>>> val

'aaa'

>>>

手写：lambda表达式
```
my_lambda = lambda arg : arg + 1
```

手写：列表推导式

def func(x):

    return x+1

variable = [ func  for num in range(10) if num == 2]

  func:　      　# 列表生成元素表达式，可以是有返回值的函数或者 lambda 函数。

  for num in range(10)：  # 迭代 range(10) 将 num 传入 func 表达式中。

  if num == 2： # 根据条件过滤哪些值可以。

手写：列表推导式 + lambda表达式：# 一行代码写出30以内所有能被3整除的数的平方：

# 错误示例：不能使用列表生成式

    a = [lambda :i*i for i in range(31) if i%3 is 0]

# 错误调用方式： # 每次只会返回最后一个被循环的range(30)!

    >>>a

    [. at 0x000002C97... ,>> a[0]

    . at 0x000002C977B96BF8>

    >>> a[0]()

    900

# 正确示例：使用生成器迭代执行   # 注意括号！

    a = (lambda :i*i for i in range(31) if i%3 is 0)

# 调用方式：

>>> a.__iter__

<method-wrapper '__iter__' of generator object at 0x000002C977AF5938>

>>> a.__iter__()

 at 0x000002C977AF5938>

>>> a.__iter__().__next__

<method-wrapper '__next__' of generator object at 0x000002C977AF5938>

>>> a.__iter__().__next__()

. at 0x000002C977B8CF28>

>>> a.__iter__().__next__()()

9

手写字典推导式

# 推导式示例：

>>> mcase = {'a': 10, 'b': 34}

>>> mcase_frequency = {mcase[k]: k for k in mcase}

>>> print(mcase_frequency)

{10: 'a', 34: 'b'}

手写：字典推导式：合并大小写对应的value值，将k统一成小写

#   _._

>>> mcase = {'a': 10, b': 34, 'A': 7, 'Z': 3}

>>> mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}

>>> print(mcase_frequency)

{'a': 17, 'b': 34, 'z': 3}

手写：集合推导式

# 集合推导式示例

>>> squared = {x**2 for x in [ i for i in range(-5,10) ]}

>>> print(squared)

{1, 4}

列表推导式list comprehension和生成器的优劣

1. 列表推导式是将所有的值一次性加载到内存中

2. 生成器是将列表推导式的[]改成(),不会将所有的值一次性加载到内存中,延迟计算,一次返回一个结果,

   它不会一次生成所有的结果,这对大数据量处理,非常有用

# 生成器函数: 一个函数中包含了yield关键词,那么这个函数就不是普通的函数,是一个生成器函数

# 调用生成器函数,不会立马执行该函数里面的代码, 而是会返回一个 生成器对象

python三神器( 7 )

生成器、迭代器、装饰器、可迭代对象的区别

容器：

   - 是一系列元素的集合，str、list、set、dict、file、sockets对象都可以看作是容器，容器都可以被迭代（用在for，while等语句中），因此他们被称为可迭代对象。

可迭代对象实现了__iter__方法，该方法返回一个迭代器对象。

迭代器：

    - 持有一个内部状态的字段，用于记录下次迭代返回值，它实现了__next__和__iter__方法，迭代器不会一次性把所有元素加载到内存，而是需要的时候才生成返回结果。

生成器：

    - 是一种特殊的迭代器，它的返回值不是通过return而是用yield。

装饰器

    - 在不改变原函数代码的基础上，在执行前后进行定制操作

生成器

- 生成器，一个函数内部存在yield关键字；v = 函数()。

  应用场景：

    - range/xrange

    - py2: range(100000000),立即创建;xrange(100000000)生成器；

    - py3: range(100000000)生成器；

    - redis获取值

	conn = Redis(...)

	def hscan_iter(self, name, match=None, count=None):

	"""

	Make an iterator using the HSCAN command so that the client doesn't

	need to remember the cursor position.

        ``match`` allows for filtering the keys by pattern

        ``count`` allows for hint the minimum number of returns

	"""

        cursor = '0'

        while cursor != 0:

            # 去redis中获取数据：12

            # cursor，下一次取的位置

            # data：本地获取的12条数数据

            cursor, data = self.hscan(name, cursor=cursor, match=match, count=count)

            for item in data.items():

                yield item

迭代器

- 迭代器，内部实现__next__方法，帮助我们向后一个一个取值。

可迭代对象

可迭代对象介绍

  - 一个类内部实现 __iter__ 方法且返回一个迭代器

      - 实例：

        class Foo(object):

            def __iter__(self):

                return iter([11,22,33,44])

        obj = Foo()

  - 应用场景：

      - wtform中对form对象进行循环时，显示form中包含的所有字段。

      - 列表、字典、元组

什么是装饰器

装饰器介绍

  - 在不改变原函数代码的基础上，在执行前后进行定制操作

  - 手写

  - 应用场景：

    - Flask ： 路由、before_request、after_request

    - Django： csrf、缓存、内置用户登录认证

    - functools：缓存、warper

手写一个装饰器

def waper(func):

    def inner(*args, **kwargs):

        res = func(*args, **kwargs)

       return res

    return inner

带参数的装饰器

def waper(func, x,y):

    print( int(x) + int(y) )

    @functools.wapper               # 保留原函数信息

    def inner(*args, **kwargs):

        """blabla的一些注释"""

        res = func(*args, **kwargs)

       return res

    return inner

@wapper(1,2)

def func(a):

    return a

func(123)

面向对象 ( 10 )

谈谈你对面向对象的认识

- 简单描述 ：继承、封装、多态 

- 系统描述 ：先对代码进行分类：按属性进行划分(file，DB)，按功能划分，将同一类方法分为一类。将方法中共同的参数封装到对象中，把共用值封装到对象中。

面向对象的私有字段：

  - python中一切皆对象

  1. 封装：对数据的，对对象的封装。

  2. 继承：在类的基础上进行二次开发，通过函数super() 或者"基类名.方法名() "的方式实现这一目的的。

  3. 多态：同一个方法处于不同对象中，可以产生不同的结果

- 多态示例
# 鸭子模型 
  class A: 
      def send(self):
          pass
  class B: 
      def send(self):
          pass
      def func(arg):
          arg.send() 
          obj = B()
  func(obj)

你知道哪些双下划线方法

- 双下划线：

  1. __getattr__：反射

     应用场景：

       - CBV

       - Django 配置文件

       - wtforms中的Form()实例化中 将"_fields中的数据封装到Form类中"

  2. __mro__：定义解析类继承的顺序

     应用场景：wtforms中 FormMeta中继承的优先级

  3. __dict__：用来存储对象属性的一个字典，其键为属性名，值为属性的值

     - __dict__ 与 dir()的区别：

       1. dir()是一个函数，返回值是list

       2. dir用来寻找一个对象的所有属性值，包括__dict__中的属性，__dict__是dir()的子集

  4. __new__ ：

     - 当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。

     - 实现自定义 metaclass

     应用场景：

       - wtforms 字段实例化时返回：不是StringField，而是UNboundField

       - rest_framework：many=Ture 中的序列化

       - 单例模式

  5. __call__：作用是使实例能够像函数一样被调用，同时不影响实例本身的生命周期， (__call__()不影响一个实例的构造和析构)

               但是__call__()可以用来改变实例的内部成员。

     __call__ 与 __init__的区别

     应用场景：

       - FLask 请求的入口app.run()

       - 字段生成标签时：字段.__str__ ==> 字段.__call__ ==> 插件.__call__

  6. __iter__：

     迭代器为什么要一定实现__iter__方法(为什么要返回自身)     应用场景：wtforms中BaseForm中循环所有字段时自定义了__iter__方法

metaclass的作用
- 作用：用于指定当前类事业那个类来创建
- 场景：在类创建之前定制的操作
示例：wtforms中对字段进行排序

super的作用：

子类继承父类的方法，其继承顺序按照 __mro__来定义

新式类与经典类的区别

新式类跟经典类的差别主要是以下几点：

  1. 新式类对象可以直接通过__class__属性获取自身类型:type

  2. 继承搜索的顺序发生了改变,经典类多继承属性搜索顺序 ：

      - 先深入继承树左侧，再返回，开始找右侧;

      - 新式类多继承属性搜索顺序: 先水平搜索，然后再向上移动。

        ps：(经典类深度优先，新式类广度优先)

  3. 新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中。

  4. 新式类增加了__getattribute__方法

Python 2.x中默认都是经典类，只有显式继承了object才是新式类

Python 3.x中默认都是新式类，不必显式的继承object

深度优先和广度优先是什么

python的类可以继承多个类，python的类如果继承了多个类，那么其寻找的方法有两种：

  - 当类是经典类时：多继承情况下，会按照深度优先的方式查找

  - 当类是新式类时：多继承情况下，会按照广度优先的方式查找
简单点说就是：经典类是纵向查找，新式类是横向查找

什么是函数什么是方法？

from types import MethodType,FunctionType

class func(object):

    def foo(self):

        print(1)

Fun = func()

print(type(func.foo))

>>> <class 'function'>

print(type(Fun.foo))

>>> <class 'method'>

print(isinstance(func.foo,FunctionType))

>>> True

print(isinstance(Fun.foo,MethodType))

>>> True

通过类去调用函数foo时，不需要传self参数。此时foo为函数

如果通过对象Fun去调用foo时，对象自动传参self。而foo则是一个方法

手写三个使用不同方法实现的单例模式

单例模式：一个类只能有一个实例化对象
应用场景：Django中的admin组件中admin.site()就是由单例模式创建的，其中封装了所有的表对象

1. 文件导入 ：import方法

# 作为python的模块是天然的单例模式

class My_Singleton(object):

    def foo(self):

        pass

my_singleton = My_Singleton()

# to use

from mysingleton import my_singleton

my_singleton.foo()

2. 使用 __new__ 方法：

--------------------------------(1. # 无法支持多线程 ：)------------------------------

class Singleton(object):

    def __init__(self,name):

        self.name = name

    def __new__(cls, *args, **kwargs):

        if not hasattr(Singleton, "instance"):

            Singleton.instance = object.__new__(cls)

        return Singleton.instance

# to use ：

obj0 = Singleton("alex")

obj1 = Singleton("alex")

obj2 = Singleton("alex")

----------------------------------(2. # 支持多线程：)---------------------------------

import threading

class Singleton(object):

    instance_lock = threading.Lock() # 为线程加互斥锁

    def __init__(self):

        pass

    def __new__(cls, *args, **kwargs):

        if not hasattr(Singleton, "instance"):

            with Singleton.instance_lock:

                if not hasattr(Singleton, "instance"):

                    Singleton.instance = object.__new__(cls)

                return Singleton.instance

        return Singleton.instance

def task():

    obj = Singleton()

    print(obj)

for i in range(5):

    t = threading.Thread(target=task)

    t.start()

3. 使用类实现

--------------------------------(1. # 无法支持多线程 ：)------------------------------

import threading

class Singleton(object):

    def __init__(self):

        pass

    @classmethod

    def instance(cls, *args, **kwargs):

        if not hasattr(Singleton, "_instance"):

            Singleton._instance = Singleton(*args, **kwargs)

    return Singleton._instance

# to use

obj = Singleton.instance()

obj2 = Singleton.instance()

print(id(obj), id(obj2))

----------------------------------(2. # 支持多线程：)---------------------------------

import time

import threading

class Singleton(object):

    _instance_lock = threading.Lock()

    def __init__(self):

        time.sleep(1)

    @classmethod

    def instance(cls, *args, **kwargs):

        if not hasattr(Singleton, "_instance"):

            with Singleton._instance_lock:

                if not hasattr(Singleton, "_instance"):

                    Singleton._instance = Singleton(*args, **kwargs)

        return Singleton._instance

# 第一次调用

def task(arg):

    obj = Singleton.instance()

    print(obj)

for i in range(10):

    t = threading.Thread(target=task,args=[i,])

    t.start()

# 第二次调用

time.sleep(20)

obj = Singleton.instance()

obj2 = Singleton.instance()

print(id(obj, id(obj2)

4. 基于metaclass

--------------------------------------( 方法一 )--------------------------------------

# 创建对象

class SingletonType(type):

    def __call__(cls, *args, **kwargs):

        obj = super(SingletonType,cls).__call__(*args, **kwargs)   #type类帮创建__new__和__init__并返回

        return obj

class Foo(metaclass=SingletonType):

    def __init__(self,name):

        self.name = name

# to use

obj = Foo("alex")

print(id(obj1))

--------------------------------------( 方法二 )--------------------------------------

import threading

class SingletonType(type):

    _instance_lock = threading.Lock()

    def __call__(cls, *args, **kwargs):

        if not hasattr(cls, "_instance"):

            with SingletonType._instance_lock:

                if not hasattr(cls, "_instance"):

                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)

        return cls._instance

class Foo(metaclass=SingletonType):

    def __init__(self,name):

        self.name = name

# to use

obj1 = Foo('name')

obj2 = Foo('name')

print(id(obj1),id(obj2))

__new__, __init__的区别
1. __new__是一个静态方法,而__init__是一个实例方法.
2. __new__方法会返回一个创建的实例,而__init__什么都不返回.
3. 只有在__new__返回一个cls的实例时后面的__init__才能被调用.
4. 当创建一个新实例时调用__new__,初始化一个实例时用__init__.
5. 继承自object的新式类才有__new__
6. __new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别
7. __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，
  可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例
8. __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
9. 如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，
10. 如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。
new与init的关系:

1. new优于init加载执行

2. 只能通过重写new方法来自定义不可变的类对象：(int,str,tuple)，--->init方法不行

3. 通过new方法可以实现单例模式

lass Singleton(object):

def __new__(cls):

# 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象

if not hasattr(cls, 'instance'):

cls.instance = super(Singleton, cls).__new__(cls)

return cls.instance

obj1 = Singleton()

obj2 = Singleton()

obj1.attr1 = 'value1'

print obj1.attr1, obj2.attr1

print obj1 is obj2
知道有哪些类的双下划线方法，并说明作用，返回值？
https://www.zybuluo.com/kingwhite/note/136247

面向对象中super的作用？

用于执行子类继承基类的方法

模块 ( 26 )

你的常用模块都有哪些 ( 1 )

copy ： 用于深浅拷贝

os ：与操作系统交互的一个接口 比如用来处理文件和目录

random ：随机模块

sys：负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

json：序列化

re ： 正则模块

logging ： 日志模块

requests： 爬取数据

timeit ：

subprocess：与OS模块相同，区别与异步提交命令不等待输出。与OS模块的区别

copy模块 ( 1 )

浅拷贝与深拷贝的实现方式及区别，如果你来设计Deepcopy，如何实现
浅拷贝：只拷贝父对象，不会拷贝对象的内部的子对象（父对象不同，子对象进行引用，ID相同）

>>> a = [1,[1,3],3]

>>> import copy

>>> b = copy.copy(a)

>>> b

[1, [1, 3], 3]

>>> a[1].append(3)

>>> b

[1, [1, 3, 3], 3]

<>>> a

[1, [1, 3, 3], 3]

深拷贝：拷贝对象及其子对象（父, 子对象不同）

>>> a = [1,[1,2],3]

>>> import copy

>>> b = copy.deepcopy(a)

>>> a[1].append(3)

>>> b

[1, [1, 2], 3]

>>> a

[1, [1, 2, 3], 3]

如何进行实现：

deepcopy优化版：

class FiveCardStudInfo(roomai.abstract.AbstractInfo):

    public_state = None

    person_state = None

    def __deepcopy__(self, memodict={}):

        info = FiveCardStudInfo()

        info.public_state = self.public_state.__deepcopy__()

        info.public_state = self.person_state.__deepcopy__()

        return info

由于深拷贝需要维护一个 memo 用于记录已经拷贝的对象，所以这也是它比较慢的原因

OS模块 ( 3 )

你知道哪些OS模块的方法

os.remove(‘path/filename’)  # 删除文件

os.rename(oldname, newname) # 重命名文件

os.walk()   # 生成目录树下的所有文件名

os.chdir('dirname') # 改变目录

os.getcwd() # 取得当前工作目录

os.path.getsize()   # 返回文件大小

创建、删除文件

1. # 创建一个文件

2. open("chao.txt","w",encoding="utf-8")

3. import os

  #删除文件

4. os.remove("chao.txt")

给出路径找文件

--------------------------------( 方法一 )------------------------------

使用os.walk：

file-- 是你所要便利的目录的地址, 返回的是一个三元组(root,dirs,files)。

root 所指的是当前正在遍历的这个文件夹的本身的地址

dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)

files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)

def open_2(file):

    for root, dirs , files in os.walk(file):

        print("ss",files)

        for filename in files:

            print(os.path.abspath(os.path.join(root, filename)))   #返回绝对路径

open_2("F:\搜索")

--------------------------------( 方法二 )------------------------------

import os

def open(files):

    for dir_file in os.listdir(files):

        # print("ss",dir_file)   #递归获取所有文件夹和文件

        files_dir_file = os.path.join(files, dir_file) 

        if os.path.isdir(files_dir_file):  #是不是文件夹

            open(files_dir_file)

        else:

            print(files_dir_file)

open("F:\搜索")

并将下面的所有文件内容写入到一个文件中

def open_2(file):

    for root, dirs , files in os.walk(file):

        for filename in files:

            with open(os.path.abspath(os.path.join(root, filename)), "r") as f:

                for i in f.readlines():

                    print(i)

                    with open("./cao.txt","a",encoding="utf-8") as f2:

                        f2.write(i)

                        f2.write("\n")

open_2("F:\搜索")

使用python打印路径下的所有文件

# 方法一：（面试要求不使用os.walk）

def print_directory_contents(sPath):

    import os

    for sChild in os.listdir(sPath):

        sChildPath = os.path.join(sPath, sChild)

        if os.path.isdir(sChildPath):

            print_directory_contents(sChildPath)

        else:

            print(sChildPath)

# 方法二：（使用os.walk）

def print_directory_contents(sPath):

    import os

    for root, _, filenames in os.walk(sPath):

        for filename in filenames:

            print(os.path.abspath(os.path.join(root, filename)))

print_directory_contents('.')

如何使⽤python删除⼀个⽂件

import os

file = r'D:\test.txt'

if os.path.exists(file):

    os.remove(file)

    print('delete success')

else:

    print('no such file:%s' % file)

random模块

如何⽣成⼀个随机数？

import random

print(random.random())          # 用于生成一个0到1的随机符点数: 0 <= n < 1.0

print(random.randint(1, 1000))  # 用于生成一个指定范围内的整数

co

re模块 ( 4 )

re模块的基本方法：

.     匹配除换行符以外的任意字符

\w    匹配字母或数字或下划线

\s    匹配任意的空白符

\d    匹配数字

\n    匹配一个换行符

\t    匹配一个制表符

\b    匹配一个单词的结尾

^     匹配字符串的开始

$     匹配字符串的结尾

\W

匹配非字母或数字或下划线

\D

匹配非数字

\S

匹配非空白符

a|b

匹配字符a或字符b

()

匹配括号内的表达式，也表示一个组

[...]

匹配字符组中的字符

[^...]

匹配除了字符组中字符的所有字符

用法说明

*    重复零次或更多次

+    重复一次或更多次

?    重复零次或一次

{n}    重复n次

{n,}    重复n次或更多次

{n,m}    重复n到m次

手写正则

匹配邮箱：
    -  [\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?

    -  \w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\.)+[A-Za-z]{2,14}
匹配URL地址：

    -  [a-zA-z]+://[^\s]*
匹配国内手机号：

    -  \d{3}\d{8}|\d{4}\{7,8}
匹配身份证号码：

    -  ^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$

match和search的区别

- re.match ：只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；

- re.search：匹配整个字符串，直到找到一个匹配。

应用示例：

import re

s = "fnfffidvvgf"

m = re.match("fi",s)

print(m)
>>> #None

s = re.search("fi",s).group()

print(s)
>>> #fi

贪婪匹配与非贪婪匹配

- 匹配0次或多次 <.*>

- 非贪婪匹配：匹配0次或1次 <.?>

functools模块

是否使⽤过functools中的函数？其作⽤是什么？

# 用于修复装饰器

import functools

def deco(func):

    @functools.wraps(func)  # 加在最内层函数正上方

    def wrapper(*args, **kwargs):

        return func(*args, **kwargs)

    return wrapper

@deco

def index():

    '''哈哈哈哈'''

    x = 10

    print('from index')

print(index.__name__)

print(index.__doc__)

# 加@functools.wraps

# index

# 哈哈哈哈

# 不加@functools.wraps

# wrapper

# None

reduce

在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里 用的话要 先引入：

>>> from functools import reduce 

reduce函数，reduce函数会对参数序列中元素进行累积。

reduce函数的定义：

reduce(function, sequence[, initial]) -> value

function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。

第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。

reduce(lambda x, y: x + y, [2, 3, 4, 5, 6], 1)

结果为21(  (((((1+2)+3)+4)+5)+6)  )

reduce(lambda x, y: x + y, [2, 3, 4, 5, 6])

结果为20

其他函数

如何判断是函数还是方法

from types import FunctionType

from types import MethodType

print(isinstance(obj.func, FunctionType))   # False

print(isinstance(obj.func, MethodType))     # True

其他

你知道几种设计模式

设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

编码和解码了解过么
什么是装饰器，如果想在函数之后进行装饰应该怎么做
一个函数，想在运行时动态的增加功能，又不会改动函数本身的代码
使用装饰器的单例模式和使用其他方法的单例，在后续使用中有什么区别

介绍下垃圾回收机制：引用计数 / 分代回收 / 孤立引用环

引⽤计数机制的优点：

1、简单

2、实时性：⼀旦没有引⽤，内存就直接释放了。不⽤像其他机制等到特定时机。实时性还带来⼀个好处：处理回收内存的时间分摊到了平时。

引⽤计数机制的缺点：

1、维护引⽤计数

2、消耗资源循环引⽤

list1 = []; list2 =[]

list1.append(list2); list2.append(list1)

3、list1与list2相互引⽤，如果不存在其他对象对他们的引用，list1与list2的引用计数也仍然1，所占⽤的内存永远无法被回收，这将是致命的。

     对于如今的强⼤硬件，缺点1尚可接受，但是循环引⽤导致内存泄露，注定python会将引⼊新的回收机制。(分代收集)

有三种情况会触发垃圾回收：

1、当 gc 模块的计数器达到阀值的时候，自动回收垃圾

2、调⽤ gc.collect()，手动回收垃圾

3、程序退出的时候，python解释器来回收垃圾

多进程与多线程的区别：CPU密集型应用适合用什么

多线程可以共享全局变量，多进程不能。多线程中，所有子线程的进程号相同；多进程中，不同的子进程进程号不同。
python的threading和multiprocessing模块

进程通信有哪几种方式

无名管道( pipe )： - 管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

高级管道(popen)：  - 将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。

有名管道(named pipe) ： - 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

消息队列( message queue ) ： - 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

信号量( semophore ) ：- 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

信号 ( sinal ) ： - 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

共享内存( shared memory ) ： - 共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

套接字( socket )：- 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信。

介绍下协程，为何比线程还快
关于GIL锁的解释，协程的优缺点
写出将IP地址127.0.0.1转换为32位二进制和数的函数
单向链表和双向链表
写出将IPv4地址转换为IPv6的函数

面向对象的应用场景

# 需要传过多的参数：

class Foo(object):

    def __init__(self, a1, a2, a3, ... , an):

        self.a1 = a1

        self.a2 = a2

             ...

    def index(self):

        pass

# 给了一些值，对数据进行加工：Django的自定义分页

class Foo(object):

    def __init__(self, a1, a2, a3, ... , an):

        self.a1 = a1

        self.a2 = a2

             ...

    def index(self):

        return self.a1 + self.a2

QAQ

RESTful ( 12 )

谈谈你对rest api的认识
用过哪些rest 框架
```
- Django的rest_framework

- 原生CBV
```

不使用rest_framework

利用Django的CBV来实现RESTful，使开发者代码会多一些。

通过使用rest_framework框架提高开发效率。

这个框架使用最多的是什么？

Serializers
用户登录认证
分页
频率等

rest_framework视图中你都用过哪些基类
```
GenericAPIView
```
！rest_framework的GenericAPIView都继承过哪些类
rest_framework框架有哪些优点？
rest_framework都有哪些组件？

- 路由：自动帮助开发者快速为一个视图创建四个URL

- 版本

    - URL

    - GET

    - 请求头

- 认证

    - ！认证的流程是什么

- 权限

    - 权限能不能在中间件做

- 访问频率的控制

- 视图

- 解析器：根据Content-Type请求体中的格式数据进行处理。request，data

- 分页

- 序列化

    - 序列化

      - source

      - 定义方法

    - 请求的数据格式校验

- 渲染器

频率组件是怎么做的
限制的频率是多少？
```
1分钟：60-80次/每秒钟1-2次
```

什么是幂等性？

幂等性：

    一个接口进行一次或多次访问，对资源不造成影响（是否会对资源造成二次伤害），那么我们就认为这个接口具有幂等性。
    例如：GET：
         putdelete请求

非幂等性：

    例如：请求等

具有争议性的请求：

     patch：

算法排序部分(9)

手写快排；堆排；几种常用排序的算法复杂度是多少；快排平均复杂度多少，最坏情况如何优化；
手写：已知一个长度n的无序列表，元素均是数字，要求把所有间隔为d的组合找出来，你写的解法算法复杂度多少；
手写：一个列表A=[A1，A2，…,An]，要求把列表中所有的组合情况打印出来；
手写：用一行python写出1+2+3+…+10**8 ；
手写python：用递归的方式判断字符串是否为回文；
单向链表长度未知，如何判断其中是否有环；
单向链表如何使用快速排序算法进行排序；
手写：一个长度n的无序数字元素列表，如何求中位数，如何尽快的估算中位数，你的算法复杂度是多少；
如何遍历一个内部未知的文件夹（两种树的优先遍历方式）

网络基础部分(11)

TCP/IP分别在模型的哪一层；
socket长连接是什么意思；
select和epoll你了解么，区别在哪；

TCP UDP区别；三次握手四次挥手讲一下；

# TCP三次握手

# 1. 客户 --> 服务：SYN=1(发起新连接) seq = J（随机值）

# 2. 服务 --> 客户：

#      SYN=1，

#      ACK=1（确认接受这次连接请求），

#      ack=J+1（从广播的众多连接请求响应中中发现针对自己的响应，网络是广播的）

#     seq = K

# 3. 客户 --> 服务

#     ACK=1（我知道你接受我了）

#     ack=K+1（服务端从众多的连接连理响应中发现针对自己的）

# 当然，第三次握手消息，服务端也可能没有接收到，但不可能两边一直这样ACK下

# 去。但是还可以基于超时时间，重新发起连接请求。

TIME_WAIT过多是因为什么；
http一次连接的全过程：你来说下从用户发起request——到用户接收到response时的全过程；
http连接方式。get和post的区别，你还了解其他的方式么；
restful你知道么；
状态码你知道多少，比如200/403/404/504等等；# 更多信息跳转w3
TCP/UDP
socket连接和HTTP连接的区别
Q^Q

HTTP部分( 11 )

常用的HTTP方法有哪些？

GET： 用于请求访问已经被URI（统一资源标识符）识别的资源，可以通过URL传参给服务器

POST：用于传输信息给服务器，主要功能与GET方法类似，但一般推荐使用POST方式。

PUT： 传输文件，报文主体中包含文件内容，保存到对应URI位置。

HEAD： 获得报文首部，与GET方法类似，只是不返回报文主体，一般用于验证URI是否有效。

DELETE：删除文件，与PUT方法相反，删除对应URI位置的文件。

OPTIONS：查询相应URI支持的HTTP方法。

GET方法与POST方法的区别

区别一：

    - get重点在从服务器上获取资源，post重点在向服务器发送数据；

区别二：

    - get传输数据是通过URL请求，以field（字段）= value的形式，置于URL后，并用"?"连接，多个请求数据间用"&"连接，
      如http://127.0.0.1/Test/login.action?name=admin&password=admin，这个过程用户是可见的；

    - post传输数据通过Http的post机制，将字段与对应值封存在请求实体中发送给服务器，这个过程对用户是不可见的；

区别三：

    - Get传输的数据量小，因为受URL长度限制，但效率较高；

    - Post可以传输大量数据，所以上传文件时只能用Post方式；

区别四：

    - get是不安全的，因为URL是可见的，可能会泄露私密信息，如密码等；

    - post较get安全性较高；

区别五：

    - get方式只能支持ASCII字符，向服务器传的中文字符可能会乱码。

    - post支持标准字符集，可以正确传递中文字符。

HTTP请求报文与响应报文格式

请求报文包含三部分：

    - 请求行：包含请求方法、URI、HTTP版本信息

    - 请求首部字段

    - 请求内容实体

响应报文包含三部分：

    - 状态行：包含HTTP版本、状态码、状态码的原因短语

    - 响应首部字段

    - 响应内容实体

常见的HTTP相应状态码

200：请求被正常处理

204：请求被受理但没有资源可以返回

206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。

301：永久性重定向

302：临时重定向

303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上

304：发送附带条件的请求时，条件不满足时返回，与重定向无关

307：临时重定向，与302类似，只是强制要求使用POST方法

400：请求报文语法有误，服务器无法识别

401：请求需要认证

403：请求的对应资源禁止被访问

404：服务器无法找到对应资源

500：服务器内部错误

503：服务器正忙

HTTP1.1版本新特性

1. 默认持久连接节省通信量，只要客户端服务端任意一端没有明确提出断开TCP连接，就一直保持连接，可以发送多次HTTP请求

2. 管线化，客户端可以同时发出多个HTTP请求，而不用一个个等待响应
3. 断点续传原理

常见HTTP首部字段

1. 通用首部字段（请求报文与响应报文都会使用的首部字段）

   - Date：创建报文时间

   - Connection：连接的管理

   - Cache-Control：缓存的控制

   - Transfer-Encoding：报文主体的传输编码方式

2. 请求首部字段（请求报文会使用的首部字段）

   - Host：请求资源所在服务器

   - Accept：可处理的媒体类型

   - Accept-Charset：可接收的字符集

   - Accept-Encoding：可接受的内容编码

   - Accept-Language：可接受的自然语言

3. 响应首部字段（响应报文会使用的首部字段）

   - Accept-Ranges：可接受的字节范围

   - Location：令客户端重新定向到的URI

   - Server：HTTP服务器的安装信息

4. 实体首部字段（请求报文与响应报文的的实体部分使用的首部字段）

   - Allow：资源可支持的HTTP方法

   - Content-Type：实体主类的类型

   - Content-Encoding：实体主体适用的编码方式

   - Content-Language：实体主体的自然语言

   - Content-Length：实体主体的的字节数

   - Content-Range：实体主体的位置范围，一般用于发出部分请求时使用

HTTP与HTTPS的区别

对传输内容加密
端口：

    HTTP：80

    HTTPS：443
自定义证书

HTTP的缺点与HTTPS

1. 通信使用明文不加密，内容可能被窃听

2. 不验证通信方身份，可能遭到伪装

3. 无法验证报文完整性，可能被篡改

# HTTPS就是HTTP加上加密处理（一般是SSL安全通信线路）+认证+完整性保护

HTTP优化
利用负载均衡优化和加速HTTP应用

利用HTTP Cache来优化网站

从浏览器输入域名网址到看到页面都发生了什么

1.浏览器向DNS服务器询问域名对应的IP地址

2.得到域名对应的IP地址后，组装HTTP请求报文

3.由TCP协议将请求报文分割成多个报文段，可靠的传给对方

4.由IP协议搜索对方地址，并传送报文，此过程可能经过多个路由器

5.服务器端的TCP从对方接收到报文

6.服务器端的HTTP解析请求报文，处理并生成响应报文

7.按照相反的顺序，将响应报文发回给浏览器

8.浏览器根据响应报文解析数据（一般为html文档），并渲染页面，文档中也很可能引用了其他资源，这些资源同样使用HTTP协议想服务器请求

什么是websocket

websocket是一种类似HTTP的协议：

  - 让C/S创建链接不断开，以此可以完成：S向C主动推送消息

  - websocket协议额外做的一些前提操作：

    - 握手，连接前进行校验

    - 发送数据，进行加密

websocket的本质

    ...

应用场景：

5月17日13:19:13,141

  - Django： channel

  - Flask ：   gevent-websocket

  - tornado：内置

QAQ

数据库部分( 20 )

MySQL有几种引擎：查询表数据练习题

InnoDB：

    - 支持事务

    - 行锁/表锁

    - 表锁：

      - select * from tb for update

    - 行锁：

      - select * from tb where id=2 for update;

MyISAM：

    - 全文索引<

    - 表锁

    - 查询速度快

    - 表锁语句：

      - select * from tb for update；

- Innodb是索引和数据是紧密捆绑的，没有使用压缩；
- 而MyISAM的索引和数据是分开的，并且索引是有压缩的，内存使用率就对应提高了不少，能加载更多索引，因此，用MyISAM可节省不少硬盘空间。

数据库中函数用过哪些？

聚合函数：max/sum/min/avg
时间格式化：date_format
字符串拼接：concat

索引有哪几种？区别是什么？

单列：B+树/哈希索引  --> 查询速度快更新速度慢

    - 普通索引 ：加速查找

    - 唯一索引 ：加速查询 + 约束(不能重复)

    - 主键索引 ：加速查询 + 约束(不能重复) + 不能为空

    - 全文索引 ：

多列：遵循最左前缀规则

    - 联合索引 ：

    - 联合唯一索引 ：

其他：

- 索引合并 ：利用多个单例索引查询

    - 覆盖索引 ：在索引表中就能将想要的数据查询到

    - 组合索引遵循最左前缀规则

        如果组合索引为：(name,email)

        name and email       -- 使用索引

        name                 -- 使用索引

        email                -- 不使用索引

慢日志如何开启？

slow_query_log = OFF                 # 是否开启慢日志记录

long_query_time = 2                  # 时间限制，超过此时间，则记录

slow_query_log_file = /usr/slow.log  # 日志文件

log_queries_not_using_indexes = OFF  # 为使用索引的搜索是否记录

MySQL锁有几种；死锁是怎么产生的；

mysql锁能在并发情况下的mysql进行更好的优化

MySQL有三种锁的级别：页级、表级、行级，这3种锁的特性可大致归纳如下：

表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高,并发度最低。

行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。

页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。

为何，以及如何分区、分表；

#从字面上简单理解，就是把原本存储于一个库的数据分块存储到多个库上，把原本存储于一个表的数据分块存储到多个表上。

MySQL的char varchar text的区别；

select的几种区别

1. select 1与select * 的区别：

    “selelct 常量 from 表名” 对应所有行，返回的永远只有一个值，即常量 ，所以一般只用来判断是否有表记录；

而“select * from 表名” 是返回所有行的所有列。

    性能上的差异，关键看from和where子句。如果where条件中可以通过索引，那显然 “selelct 常量 from 表名” 的性能比“select * from 表名” 好。

2. select count(1) 与select count(*) 的区别 ：

    性能上的差异，跟表结构有关系：

    如果表中没有主键，那么count(1)比count(*)快

    如果有主键，那么count(主键，联合主键)比count(*)快

    如果表中只有一个字段，count(*)最快

3. select sum(1)的使用：

    select count(*)返回所有满足条件的记录数，此时等同于select sum(1)

    但是sum()可以传任意数字，负数、浮点数都可以，返回的值是传入值n*满足条件记录数m

存储过程和函数的区别

函数：

    - 参数

    - 返回值：return

存储过程：

    - 参数

    - 返回值：out/inout

    - 返回结果集：select * from tb;

什么是视图

虚拟表 --> 通过SQL帮助我们实时查询数据

什么是触发器

在对表进行 增删改查 前后定义一些SQL操作

对前端产生的分页是如何处理的

- 数据库分页

    存在问题:

        查询的页面数越大，速度就会越慢，这是因为每次数据库都会从第一条开始扫描

        selsct * from tb limit 3 offset 5

        models.User.object.all()[0:10]

    解决方法：

        根据业务场景来说：

            1.如果业务对历史数据不要求的话，就显示一定的页数，就可以避免这样的问题

            2.记录当前页数据id的最大最小值，根据记录的id和需要查询的范围来定。

              但是在url上面会有page的值，如果用户随意改url上的页码的值的时候，可以参考restfromwork的分页来做，
            对当前的url进行加密，加密之后它里面就带了当前页的最大和最小id，解密出来之后就可以直接拿来用，而且用户也没有办法在url上随便修改了

了解join么，有几种，有何区别，A LEFT JOIN B，查询的结果中，B没有的那部分是如何显示的（NULL）；
写出SQL语句：获取一条name="alex"的数据
```
select * from tb name='alex' limit 1
```
BTree索引和hash索引的区别（在磁盘结构上的区别）；

手写：如何对查询命令进行优化；

1. 不用 select *

2. 固定长度字段列，往前放

3. char 和 varchar

4. 固定数据放入内存 choice

5. 数据库读写分离

6. 分库：当数据库中表过多，将表分到不同的数据库()

7. 分表：

    - 水平分表：将某些列拆分到另一张表：博客+博客详细

    - 垂直分表：将一些历史信息分到另一张表中：历史账单

8. 缓存：利用redis、memcache进行存储

    ps：当缓存宕机，如果没有进行持久化则将所有请求转接MySQL，
        而MySQL承受不了压力时会造成无法启动

9. 其它

    - 慢日志

    - 执行计划

10. 分页

NoSQL了解么，和关系数据库的区别；
redis有几种常用存储类型；
乐观锁和悲观锁
触发器是什么？
QAQ

Linux部分( 4 )

讲一下你常用的Linux/git命令和作用；
查看当前进程是用什么命令，除了文件相关的操作外，你平时还有什么操作命令；
Apache和Nginx的区别

介绍下中间人攻击：

# 中间人攻击（Man-in-the-middle attack，通常缩写为MITM）是指攻击者与通讯的两端分别创建独立的联系，并交换其所收到的数据，

使通讯的两端认为他们正在通过一个私密的连接与对方直接对话，但事实上整个会话都被攻击者完全控制。

前端部分( 2 )

你用过什么框架和类库

- jQuery

- BootStrap

- Vue.js、React、Angular.js

什么是响应式布局

 通过浏览器和设备分辨率的改变做出相应的变化 
本质是通过 @media属性来完成：
<style>
  body{
    margin:0;}
.pg-header{
    background-color:red;
    height: 48px;}
@media( min-width: 768px ){
    .pg-header{background-color: green;}}
@media( min-width: 992px ){
    .pg-header{background-color: pink;}}
</style>

django项目部分( 19 )

简单的介绍下你在公司的项目，不管是不是后端相关的，主要是要体现出你干了什么；
你在项目中遇到最难的部分是什么，你是怎么解决的；

Django和Flask框架的区别

Django：

  - 内置很多组件：

    - ORM、admin、Form、ModelForm、中间件、信号、缓存、csrf等

Flask：

  - 一个轻量级框架内置组件少，可扩展很多第三方组件：

    - flask-session、flask-script、flask-redis、flask-flask-migrate

    - flask-SQLAlchemy、wtforms、blinker

两个框架都是基于wsgi协议实现的，默认使用的wsgi模块不一样，

还有一个显著的特点：处理请求的方式不一样

  - Django：通过将请求封装成request对象，再通过参数进行传递

  - flask：    通过上下文管理实现

延伸：

  - Django组件

  - flask组件、用途

  - wsgi

  - 上下文管理

MVC / MTV；

Django请求生命周期

1. wsgi：创建socket服务端，用于接收用户请求并对请求进行初次封装
2. 中间件：对所有请求到来之前，响应之前定制一些操作
3. 路由：  匹配路由，在url和视图函数对应关系中，根据当前请求url找到相应的函数
4. 视图函数：执行视图函数，业务处理【通过ORM去数据库中获取数据，再去拿到模板，然后将数据和模板进行渲染】
5. 在经过中间件
6. 通过wsgi将响应返回给用户

什么是wsgi

是web服务网关接口，是一套协议。以下模块实现了wsgi协议：

  - wsgiref ：性能低，易配置

  - werkzurg

  - uwsgi

以上模块本质：实现socket监听请求，获取请求后将数据封装，然后交给web框架处理
详解：
    本质是编写了socket服务端，用来监听用户的请求，如果有请求到来，则将请求进行一次封装然后将【请求】交给web框架来进行下一步处理

中间件是干嘛的；

所有请求都要穿过中间件：

  - 对所有的请求进行批量处理

  - 在视图函数执行之前后进行一些自定义操作。

你用中间件做过什么；

- 解决cors跨域请求

- csrf

  - csrf的本质：

    - 用户先发送get获取csrf token：Form表单中一个隐藏的标签 + cookie

    - 发起post请求时，需要携带之前发送给用户的csrf token；

    - 在中间件的process_view 方法中进行校验

中间件中有几个方法分别是什么；（五个方法）

  - process_request(self,request)

  - process_view(self, request, callback, callback_args, callback_kwargs)

  - process_template_response(self,request,response) # 当视图函数的返回值对象中有render方法时，该方法才会被调用

  - process_exception(self, request, exception)

  - process_response(self, request, response)
中间件的执行流程：

  1 请求先执行所有中间件的process_request,然后做路由匹配，找到函数不执行。

  2 再执行所有的process_view,在执行视图函数。

  3 再执行process_response

  4 如果程序报错执行process_exception

  5 如果程序有render方法则执行process_template_response

中间件的应用：

# 为什么要在中间件用这些：

- 一些内置组件上的应用：

  - csrf

  - session

     缓存

  - 用户登录校验  # 如果不使用就需要为每个函数添加装饰器，太过繁琐。

  - 权限处理     # 用户登录后将权限放到session中，然后再每次请求时都需要判断当前用户是否有权访问当前url，这些检查的东西可以放到中间件中统一处理。

  - session

- 跨域：

  - 前后端分离时，本地测试开发时使用的

CSRF原理

目标：防止用户直接向服务端发起POST请求。

方案：先发送GET请求时，将token保存到：cookie、Form表单中（隐藏的input标签），以后再发送请求时只要携带过来即可。

问题：如果想后台发送POST请求？

   form表单提交：

      <form method="POST">

         {% csrf_token %}

         <input type='text' name='user' />

         <input type='submit' />

      </form>

   ajax提交：

      $.ajax({

        url:'/index',

         type:'POST',

         data:{csrfmiddlewaretoken:'{{ csrf_token }}',name:'alex'}

      })

      前提：引入jquery + 引入jquery.cookie

      $.ajax({

         url: 'xx',

         type:'POST',

         data:{name:'oldboyedu'},

         headers:{

            X-CSRFToken: $.cookie('csrftoken')

         },

         dataType:'json', // arg = JSON.parse('{"k1":123}')

         success:function(arg){

            console.log(arg)

         }

      })

<body>

    <input type="button" onclick="Do1();"  value="Do it"/>

    <input type="button" onclick="Do2();"  value="Do it"/>

    <input type="button" onclick="Do3();"  value="Do it"/>

    <script src="/static/jquery-3.3.1.min.js"></script>

    <script src="/static/jquery.cookie.js"></script>

    <script>

        $.ajaxSetup({  // 为所有Ajax请求添加函数

            beforeSend: function(xhr, settings) {

                xhr.setRequestHeader("X-CSRFToken", $.cookie('csrftoken'));

            }

        });

         function Do1(){

            $.ajax({

                url:"/index/",

                data:{id:1},

                type:'POST',

                success:function(data){

                    console.log(data);

                }

            });

        }

         function Do2(){

            $.ajax({

                url:"/index/",

                data:{id:1},

                type:'POST',

                success:function(data){

                    console.log(data);

                }

            });

        }

         function Do3(){

            $.ajax({

                url:"/index/",

                data:{id:1},

                type:'POST',

                success:function(data){

                    console.log(data);

                }

            });

        }

    </script>

</body>

优化方案

Django的Form的作用

1. 帮助我们生成HTML标签

2. 对用户输入的数据进行校验

   ps：form对象是个可迭代对象

Q：从数据库获取数据时，下拉框无法实时刷新。

A：重写构造方法，在构造方法中重新去获取数据

     def __str__(self):

         return self.title

缓存怎么用；
CSRF是什么，django是如何避免的；XSS呢；
如果你来设计login，简单的说一下思路；
session和cookie的联系与区别；session为什么说是安全的；
WSGI和Nginx的作用；
浏览器缓存机制
你看过django的admin源码么；看过flask的源码么；你如何理解开源；
QAQ

Flask部分( 14 )

FLask和Django的区别

- 对于Django来说：内部组件全面，自身功能强大，给人一种大而全的感觉,

  ( 你知 或者不知他，Django就在那里，不悲不喜。

    你念 或者不念他，功能就在那里，不來不去。

    你愛 或者不愛他，組件就在那里，不增不減。

    你用，或者不用他，Django就在你手裡。不捨不棄。)

 而Flask：内置组件就很少，但它的第三方组件很多，可扩展性强，还可以自定义组件，

- 两个框架本身都没有写sockte，都是基于wsgi协议做的，而flask框架中的上下文管理较为耀眼。

　- 相同点：它们两个框架都没有写sockte，都是基于wsgi协议做的

　　请求相关数据传递的方式不同：django：通过传递request参数取值

　　　　　　　　　　　　　　　　flask：见问题二

　　　　　　　　　　　组件不同：django组件多

　　　　　　　　　　　　　　　　flask组件少，第三方组件丰富

谈谈你对Flask与Django框架的认识

相同：

    都基于wsgi，

不同：

    对请求处理不同：Flask基于上下文管理；Django通过传值来处理

    Django功能多，内置组件全面：缺点不能自定义添加或删除组件

    Flask内置组件少，但是可以通过第三方组件来扩展：Flask-email，Flask-SQLAlchemy，Flask-session等

Flask中的session是什么时候创建，什么时候销毁的？

　　当请求进来时，会将 requset 和 session 封装为一个 RequestContext 对象，通过 LocalStack 将 RequestContext 放入到Local对象中，
因为请求第一次来 session 是空值，所以执行 open_session,给 session（uuid4()）赋值，再通过视图函数处理，请求响应时执行save.session,
将签名 session 写入 cookie 中，再将 Local 中的数值pop掉。

Flask为什么把请求放到RequestContext中？

    因为 request 和 session 都是在视图中操作频繁的数据，也是用户请求需要用的数据，

将 request 和 session 封装在 RequestContext 中 top，pop 一次就可以完成，而单独不封装在一起就会多次操作，

flask中一共有几个LocalStack和Local对象

两个LocalStack，两个Local：

  - request、session 共同用一个 LocalStack 和 Local

  - g、app 共同用一个 Localstack 和 Local

Flask上下文管理是如何实现的：

- 前提：记得不太清楚了，/or 最近刚看过

　简单来说，falsk上下文管理可以分为三个阶段：

　　1、请求进来时，将请求相关的数据放入上下文管理中

　　2、在视图函数中，要去上下文管理中取值

　　3、请求响应，要将上下文管理中的数据清除

　详细点来说：

　　1、请求刚进来，将request，session封装在RequestContext类中，app，g封装在AppContext类中，并通过LocalStack将requestcontext和appcontext放入Local类中

　　2、视图函数中，通过localproxy--->偏函数--->localstack--->local取值

　　3、请求相应时，先执行save.session()再各自执行pop(),将local中的数据清除

Local的作用？

- 用于保存：

    - 请求上下文对象

    - App上下文对象

- 并且可以做到"线程"间的数据隔离。

线程：threading.local

协程：greenlet.get_current as get_get_ident

- localstack 的源码与 threading.local（线程处理）的作用相似，

  不同之处是 Local 是通过 greenlet（协程）获取唯一标识，粒度更细

LocalStack的作用？

将local对象中的数据维护成一个栈【ctx,ctx】（先进后出）

{

    “协程或线程的唯一标识”: { stack:[ctx,ctx,ctx,] }

}

为什么要将Local对象中的数据维护成一个栈

当是web应用时：不管是单线程还是多线程，栈中只有一个数据

  - 服务端单线程：

　　{

      111:{stack: [ctx, ]}

　　}

  - 服务端多线程：

　　{

      111:{stack: [ctx, ]}

      112:{stack: [ctx, ]}

　　}

离线脚本：可以在栈中放入多个数据,在任何情况下都可以获取到当前app的请求和响应

with app01.app_context():

print(current_app)

  　　 with app02.app_context():

          print(current_app)

      print(current_app）

什么是G？

  - G 相当于一次请求的全局变量，当请求进来时将 G 和 current_app 封装为一个 APPContext 类，在通过 LocalStack 将 Appcontext 放入 Local 中，
取值时通过偏函数，LocalStack、loca 中取值，响应时将 Local 中的 g 数据删除：
  - 应用场景：
    befor_request + G = 权限认证系统

如何获取session/g

通过 、偏函数（lookup_req_object）、Localstack、Local 取值

Flask内置功能：

- 内置组件

  - 配置 - 路由 - 视图

  - 模板 - session - 蓝图

  - 闪现 - 装饰器 - 中间件

- 第三方组件

  - Flask-session    # 将原来保存在cookie中的session数据，放到Redis/memcache/文件/数据库中

  - Flask-migrate    # 做数据库迁移

  - Flask-script     #

  - Flask-SQLAlchemy # ORM

  - blinker

- 公共：

  - DButils        # 数据库连接池：  两种模式； 为每个参数设置一个连接/共享一个连接；全局参数

  - wtforms        # form组件：做表单验证+生成HTML标签

  - gevent-websocket

- 自定义组件：

  - flask-login

手写：自己写一个类+列表，实现栈的功能（LocalStack）

分组函数 ： group by 字段  having   判断条件   （固定语法）分组和聚合函数搭配

分组函数 ： group by 字段  having   判断条件   （固定语法）分组和聚合函数搭配

class Stack():

    def __init__(self,size):

        self.size=size

        self.stack=[]

    def getstack(self):

        """

        #获取栈当前数据

        :return:

        """

        return self.stack

    def __str__(self):

        return str(self.stack)

    def top(self,x):

    # 入栈之前检查栈是否已满

        if self.isfull():

            raise Exception("stack is full")

        else:

            self.stack.append(x)

    def pop(self):

        """

        # 出栈之前检查栈是否已空

        :return:

        """

        if self.isempty():

            raise Exception("stack is empty")

        else:

            self.stack.pop()

    def isfull(self):

        """

        判断栈满

        :return:

        """

        if len(self.stack)==self.size:

            return True

        return False

    def isempty(self):

        """

        判断栈空

        :return:

        """

        if len(self.stack)==0:

            return True

        return False

if __name__ == '__main__' :

    stack=Stack(4)

    for i in range(11):

        stack.top(i)

        print(stack.getstack())

    for i in range(3):

        stack.pop()

        print(stack.getstack())

什么是threading.local，以及他的作用

原生SQL和ORM的区别

# 关系对象映射，本质是

 - SQL

   - 执行效率更高，但是代码更多，开发效率低

 - ORM

   - 开发效率高，编写速度快，执行效率相比于优化后的SQL较低些

反射在哪里用到过

Redis ( )