什么是 cookie 和 session？
因为http协议是短链接，无状态保持的，为了追踪用户会话，记录状态，最早就有了cookie，cookie只能以明文形式保存到客户端，安全性不足，所以有了session，当你第一次发送请求到服务端时，服务端会生成session发送到客户端保存，下次发送请求时携带着cookie过来，服务端检测到cookie中有上次的session就保存会话状态。
django和flask
Django和Flask都是基于MVC模式的Web框架，遵循BSD证书。Django是大而全的重型框架，提供一站式的设计方案，从模板、ORM、session、authtication等等都发配好了，连app划分都做好了，总之，为你尽可能多的做事，还有一个killer级的特性，就是它的admin，配合django suit ，后台就出来了。Flask是微框架，只有一个内核，功能通过扩展实现，很灵活的根据需求造轮子。
flask有哪些全局变量
request（封装的请求对象）、session、g、current_app 当前运行程序的实例
ORM 对象关系映射
把写好的代码映射到数据库的增删改查
restful 就是前后端分离
资源 ：网络上的一个实体， 一张图片 一段文字等
URI c:/xx/xx/xx.jpg
URL xxx.xxx.xxx/xx.jpg
后台只需要发送json数据
前台接受json数据，展示数据
状态通过http协议的请求方法转换
Vue js react node angular node.js 需要精通javascript
http协议和https协议
http协议底层是用什么协议 tcp/ip 这个协议的三次握手过程简单说一下 客户端向服务端请求建立链接，服务端针对客户端确认应答响应， 客户端给服务端确认应答。 四次挥手
is == 区别
is 判断内存地址，-5~256之间放到内存里面，不重新开辟新内存空间
== 判断值
可变对象: list dict set
不可变对象: tuple str int float byte bool
copy浅拷贝 deepcopy深拷贝
copy 只拷贝表层元素
deepcopy 在内存中重新创建所有的元素，包括子元素
自定义深拷贝比原生拷贝效率高
from pickle import loads, dumps
my_deepcopy = lambda x: loads(dumps(x, 4))
可迭代对象、迭代器、生成器
可迭代对象是实现iter方法的对象
迭代器是实现iter和next方法的对象
生成器是特殊的迭代器，含有yield函数。 推导式
list,dict,tuple,str,byte是可迭代对象，通过iter方法把自身转换成迭代器
a = [1, 2]
print(a.__iter__())
#<class 'list_iterator'>
内存只有4个G，文件8个G，怎么读取？
用迭代器读取。读取的时候，f本身就是一个迭代器，其实也就是f.read方法
f = open('messages','r')
for content in f
zip and enumerate
s = 'abcd'
#实现 {'a':[1,1,1,1], 'b':[2,2,2,2]}
x = {key, [values]*4 for key,values in zip(s, [1,2,3,4])}
y = {values, key for key, values in enumerate(s)}
print(x, y)
#{'a': [1, 1, 1, 1], 'b': [2, 2, 2, 2], 'c': [3, 3, 3, 3], 'd': [4, 4, 4, 4]}
#{'a': [1, 1, 1, 1], 'b': [2, 2, 2, 2], 'c': [3, 3, 3, 3], 'd': [4, 4, 4, 4]}
装饰器
判断是否未装饰器 函数进函数出
装饰器会改变原函数的doc和name属性，用wraps函数还原原函数的属性
from functools import wraps
def deco(func):
@wraps(func) #还原属性
def wrap(**args, **kwargs)
return func(**args, **kwargs)
return wrap
类装饰器
借助魔术方法call来方法实现，让类能调用
装饰器体现了什么思想？ 面向切面编程（AOP），不会影响原函数，额外添加了功能，中间件也是如此。
不带参用init方法接收函数, call方法接收参数,带参反之
闭包
引用了自由变量的函数即是闭包
判断是否为闭包：
1.函数嵌套函数
2.外部函数调用内部函数
3.内部函数引用外部函数的自由变量
闭包有什么作用？
实现了面向对象思想
装饰器
单例模式
理解：
内部函数只定义了一次，我们调用的时候，内部函数是能识别外函数的自由变量是不一样的。python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的自由变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。
实例方法，类方法，静态方法区别
1、实例方法通过实例调用，类方法和静态方法无需实例化
2、实例方法传self，类方法传cls， 静态方法不传
3、实例方法可以引用类内部任何的属性和方法， 类方法无法获取实例方法的属性和方法，静态方法无法获取类任何的属性和方法，是一个完全独立的方法
正常的静态方法没有任何参数，如果传参了就和实例方法同样了。
继承相关问题
什么是多态
一类事物有多种形态(一个抽象类有多个子类)。比如我的对象是你继承的对象的对象，因此，多态的概念依赖继承。
继承执行顺序：
通过mro()方法 查看继承链,根据继承链从前往后执行,最早由于菱形继承产生二义性问题，更新后广度遍历再深度遍历解决问题。
继承运用在django的Mixin,通过单纯的mixin类完成功能的组合
super
凡是要调用父类的方法，不要手动调用，而是使用super调用，会根据继承链的顺序执行，避免重复调用
垃圾回收机制
为什么需要垃圾回收 ？
如果不垃圾回收，内存迟早会被消耗空，因为我们在不断分配内存空间而不回收，除非内存无穷大，实际并非如此，所以垃圾回收是必须的。
解决:
垃圾回收靠引用计数法完成百分之80多到90，当引用计数为0时，将释放掉内存，但存在两个问题，一个是循环引用，用标记清除解决，另一个是消耗性能的问题。标记清除有两个链表，一个是根链表（root），一个是不可达的链表（unreachable），从根链接开始链接别的对象，如果勾不到它，会放入不可达的链表进行内存释放。内存是有限的，当内存不够用的时候会触发分代回收，分代回收把对象分三代，老中青三代，当内存不够用会从青开始释放内存，若还不够到中释放，再不够到老一代释放内存，解决了引用计数消耗性能的问题。青年一代是刚创时长较短的对象，中年是较久的对象，老一代像全局变量这种。
魔术方法
对象的默认表示
image.png
__repr__输出对象本身
image.png
__str__ 打印时格式化输出的表示
image.png
__new__创建一个实例对象，返回类的实例
特殊的类方法,不需要使用@classmethod来装饰
__init__
初始化实例，无返回值
创建一个对象的时候，先执行__new__方法，再执行__str__方法
python文件读取read()、readline()、readlines()
均可接受一个变量用以限制每次读取的数据量
python类型支持的运算操作
image.png
游戏背包的一键整理可以用python的sorted自带函数实现
image.png
什么是计算密集型（CPU密集型）？
一些进程绝大多数时间在计算上，CPU长时间满负荷运行，如图像处理，大数据处理，圆周率计算等
什么是I/O密集型
有一些进程则在input 和output上花费了大多时间，称为I/O密集型，I/O-bound。比如搜索引擎蜘蛛大多时间是在等待相应这种就属于I/O密集型。
进程线程协程
进程：一个进程是一个任务， 进程是分配资源的最小单元，占用资源很大，进程之间的资源是独立单元，数据通讯不方便，可以通过QUEUE、共享内存、网络及管道资源共享；
线程：线程依赖于进程， 线程是任务调度的最小单元，占用资源比进程小一个数量级，数据通信非常方便;
协程：协程是线程的升级， 非常小非常快，能弥补线程没有返回值。
什么是多任务：操作系统能同时执行多个任务
多任务由来
早期没有操作系统，只有输入，计算，输出，靠手工输入速度太慢，于是有了批处理操作系统通过纸带、磁带形成的指令清单交给计算机处理，但是只能有一个任务，而且计算机在进行i/o处理时，cpu是空闲的，世人则发明了进程，一个进程代表一个任何，多个进程分时操作能让用户认为是并行操作，进程间的资源是独立单元，但是可以通过介质进行通信，线程由此而出现，线程能使进程内的子任务共享进程内的资源，并行工作，大大提高操作系统的性能。
ps -ef | grep python3 查看任务，此时有两个进程
import random
from multiprocessing import Process 此时占用内存提高
def foo(n):
x = 0
for i in range(n):
x += random.randint(1, 100)
p = Process(target=foo, args=(1000,))
p.start()
此时一个进程在Linix系统大概两兆
from threading import Thread
t = Thread(target=foo, args=(1000,))
t.start()
此时一个看不出来，因为进程以kb为单位创建1000个
for i in range(10000):
Thread(target=foo, args(1000,).start())
算出后大概2kb一个线程
from multiprocess import Queue #给进程资源共享
import Queue # 给线程用的
import socket
server = sokect.socket()
server.bind(('127.0.0.1', 8000))
server.listen(5)
client_socket,, client_addr= server.accpet() # 返回一个元组
# 接收
client_socket.recv(1024)
# 还原
pickle.loads(p)
# {1:11, 2:22, 3:33}
import socket
d = {1:11, 2:22, 3:33}
client = socket.socket()
client.connect(('127.0.0.1', 8000))
client.send(d)
# TypeError: 必须发一个字节
import pickle
p = pickle.dumps(d) #返回字节
client.send(p)
# 协程 加个yield 就是最简单的协程
def foo(n):
x = 0
for i in range(n):
x += random.randint(1, 100)
yield
return x
f = foo(100)
f # <generator object foo at 0x0000000004926728>
t = Thread(target=foo, args(1000,))
t.start() #线程无法返回 x 的值,这个时候协程可以帮到我们
# python中的协程的机制：事件轮询
import asyncio
tasks.result()
什么是同步、异步、阻塞、非阻塞？
同步是 任务一个接一个执行
异步是 任务同时执行， 解决任务量大的任务
阻塞是停下来等待
非阻塞是不会等待的
事件驱动 + 多路复用
多路复用：十壶水烧水一个看守
轮询：select，poll 十壶水烧水来回巡视
事件驱动：epoll 基于事件的有效轮询 烧十壶水，除了开始，到结束，中间空闲的叫事件
A CPU密集型
B i/o密集型
python的线程是多线程的吗？
不是，因为有全局解释器锁（GIL），这个锁确保任何时候一个进程只有一个python线程能进入cpu执行，造成单个进程无法使用多个CPU核心，通过多进程利用多个CPU核心。
线程之间的交互尽量使用queue，是一个线程安全的队列
queue.get() # 获取
queue.put() #推入队列
常见的反爬措施
UA：ua池
封ip：代理ip池
cookie：cookie池
蜜罐：据情况具体分析
js加密：分析js，找到加密方式，仿造它的加密方式提交请求（破解有道翻译）
后台加密：
验证码： 机器学习库、AI接口、第三方打码平台
数据库mysql引擎：默认使用InnoDB、MYISAM不支持事务
大公司不用外键，用以下方式
不用外键.png
因为复杂化了，最主要是MySQL一张表，一般数据量在800W到1100W之间。正常情况下超500W采取措施。
通过mysql+memcached、
分库分表，但是
分库分表.png
优化方案：
1. 优化索引、SQL语句、分析慢查询
优化方案.png
写10个python包尽可能写出包里的很多方法
from pickle import dump, dumps, load, loads 把python的对象结构转变成二进制数据流的形式，方便存储和传输
from copy import copy, deepcopy
from socket import socket bind() 绑定ip和端口号 listen() 监听消息 connect() send()连接服务器 recv()接收数据
from time import time, sleep, localtime
from math import ceil, floor, cos, sin, e
from re import complie,match,findall, finditer,search
from os import path，getpid, getppid
complie用于将字符串形式的正则表达式，返回一个对象
match一次匹配的结果
read() 读取整个文件，返回字符串
readline() 每次读取一行文件内容
readlines() 读取整个文件，返回以行为单位的列表xreadlines() 读取整个文件，返回以行为单位的列表的对象
企业常见开发模式
瀑布式开发 所有项目固定好， 严格分级自由度降低
迭代式开发 每次只设计和实现这个产品一部分，逐步逐步完成的方法叫迭代开发，每次迭代都包括需要需求设计、设计、实现和测试。
螺旋开发 每一次的开发都需要风险评估。
敏捷开发
image.png
百度、谷歌的分页分析
image.png
image.png
image.png
image.png
装饰器版fib
shell的awk和sed.png
机器学习项目全流程.png
网友评论