2.Python面试重点内容(面试)

二、Linux命令

2.Linux命令

ls 显示目录的详细内容(文件夹.子目录)

ls -l 以列表显示文件夹 目录详细信息

ls -a 显示所有的 包含隐藏 cat vim

chmod 4 r 2 w 1 x 文件名 修改文件的权限

chown 所有者 添加者 文件名 修改文件的属组

cp/cp -r 复制文件/文件夹 路径

pwd 显示当前所在的路径

mkdir 创建一个或者多个目录

touch 创建一个文件

rm -rf rm -ri rm rf*

tar -zcvf 压缩包名字(.tar.gz) -C 路径 压缩文件

tar -zxvf 压缩包名字(.tar.gz) -C 路径 解压缩格式

sudo 获取root权限执行命令

df -h 查看磁盘的使用情况

top 任务管理器查看%CPU

ps -aux 查看某个应用的进程号

ps -aux | grep “firefox” 文件名

kill -9 PID 强制结束进程

ifconfig 查看当前的ip地址

git add a.txt 提交文件到仓库

git status 查看当前的目录信息

git log 查看现在所有的版本信息

git commit a.txt -m “注释” 提交变更到仓库

git reset hard -HEAD 版本回退

ping ：测试网络连通性

ping IP地址 -c 次数

nslookup : 解析域名对应的IP地址

nslookup www.baidu.com

sudo /etc/init.d/networking restart重启网络

ps -aux

显示系统进程命令(PID)

ps -aux | grep ‘mysql’

ssh 用户名@IP地址 远程连接到服务器

scp

复制文件到远程服务器

scp 文件名 用户名@IP地址:绝对路径

ls -lh 文件名: h提供易读容量单位

wc -l

统计文件行数

wc -l /etc/passwd

sort

对文件内容进行排序

sort 文件名

uniq -c

去重重复行,并统计每行出现的次数(相邻行)

sort 文件名 | uniq -c

du -sh 目录名: 显示目录大小

du -ah 目录名: 显示目录下所有文件,子目录,子目录中文件所占空间

grep

ps -aux | grep mysql

^ : 开头

$ : 结尾

find

find 路径 -name ‘文件名’

find 路径 -iname ‘文件名’ ##忽略大小写

find 路径 -ctime +3 # 3天以前文件

​ -1 # 1天以内文件

find 路径 -cmin +5

find 路径 -size +10M

find 路径 -size -1G

3.nginx

是一款自由的开源的高性能的HTTP服务器和反向代理服务器,可以作为反向## 1.代理实现负载均衡

4.nginx反向代理

1、流程

​ 客户端->代理服务器->将请求转发给公司内部网络的服务器

2、作用

​ 1、保证内网安全,使用反向代理阻止WEB攻击

2、负载均衡,优化网站负载

3、负载均衡规则

​ 1、轮询 ：逐一循环调度

2、权重(weight) : 指定轮询几率,权重值和访问比例成正比

3、ip_hash：根据客户端IP分配固定的后端服务器

3、nginx反向代理实现负载均衡

修改nginx配置文件配置nginx调度器

upstream servers{

​ server 10.10.10.11;

server 10.10.10.12 weight=2;

server 10.10.10.13;

server 10.10.10.14 backup;

}

三、Python基础知识

1.Python 的应用领域：

​ 系统运维、网络编程、科学计算、人工智能，机器人、web 开发、大数据及数据库编程、云计算、教育、游戏，图像等其它

2.python 的优缺点

​ 优点：面向对象(Java, C++, Python)、免费、可移植、可混合编程(C/C++/Java/.net)、简单易学易用、应用领域广泛、开发效率高、开源。
​ 缺点：与C/C++相比执行速度不够快、不能封闭源代码

2.核心数据类型和内置对象：

数字类型：
整型（int）、浮点型（float）、复数（complex）
字符串（str）
布尔类型（bool）
空值（None）

3.变量名variable命名规则 ：

变量是管理一个对象的符号（标识符）；又或者说用来绑定数据对象的标识符。
变量的命名规则：
\1. 变量名 必须以字母或下划线开头，后跟字母或下划线或数字
\2. 不能使用python的关键字命名
3.变量名区分大小写

合法的变量名示例：
a a1 b bbb aaa _Abcdvara1b2c2
不合法的变量名示例：
1a 123 $ABC +a -b #ab @ab #_A A#B
python 的关键字：
True ，False, None is del if elif等

4.is / is not运算符

作用：判断两个对象是否绑定同一个对象，如果是同一个对象返回Ture,否则返回 False （is not 与 is 相反）
语法：
x is y
x is not y
示例：
a = 10000
b = 10000
a is b # False

小整数对象池：

CPython中整数 -5 至 256 永远保存在小整数池中，不会释放并可以重复使用
示例：
a = 5
b = 5

a is b # True

5.bool（）函数返回假值False的情况

False 逻辑假值
None 空值
0， 0.0 ， 0j 所有的数字零
—————后续—————
“” 空字符串
() 空元组
[] 空列表
{} 空字典
set() 空集合
…

6.字典与列表的比较

1、字典和列表
\1. 都是可变对象
\2. 索引方式不同，列表用整数索引，字典用键索引
\3. 字典的查找速度可能会快于列表(重要)
\4. 列表的存储是有序的，字典的存储是无序的

2、列表 和字典 的内部存储原理
列表，顺序存储
字典，映射存储

7.Python的内存管理机制

​ 三方面:对象引用计数机制/垃圾回收机制/内存池机制

​ 引用计数机制:

​ Python内部使用引用计数,来保持最终内存的对象,所有对象都引用计数

​ 垃圾回收机制:

​ 当一个对象的引用计数为0是,它将被垃圾回收机制处理掉

​ 内存机制:

​ Python提供了对内存的垃圾收集机制,但是他将不用的内存返回内存池中而不是返回给操作系统 小对象整数池-5-256

8.自动化内存管理和引用计数

​ 每个对象都会有记录有几个变量绑定(引用)自身,当引用的数量为0时,则对此对象被销毁,这种自动化内存管理的方式叫做"引用计数"

9.列表和元组的区别

​ 这两个都是序列 元组就是不可变的列表 元组赋值后所存储的数据不能被程序修改,可以将元组看做是只能读取数据不能修改数据的列表 元组的数据不可修改

​ 元组中元素的插入和删除 都是再构造一个新的元组替换旧的元组

​ 用于列表的排序,替换,添加等方法在元组中不能使用

​ 元组与列表相同,都是容器对象,可以存储不同类型的内容,元组与列表有两个不同点,第一个不同点是元组的声明使用小括号,而列表使用方括号,当声明只有一个元素的元组时,需要在这个元素的后面添加英文逗号;第二个不同点是元组声明和赋值后,不能像列表一样添加/删除和修改元素,也就是说元组在程序的运行过程中不能被修改

​ 用于列表的替换,删除和添加的方法也不使用与元组,使用于元组的只要运算有元组的合并,遍历,求最大值和最小值的操作方法

深拷贝 deep copy 和浅拷贝 shallow copy

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}

10、深拷贝 deep copy 和浅拷贝 shallow copy

赋值操作(包括对象作为参数、返回值)不会开辟新的内存空间，它只是复制了对象的引用

1、浅拷贝 shallow copy

​ 浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程

​ 浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象的引用。

2、深拷贝 deep copy

​ 对所有可变对象进行层层复制,实现对象的各自独立

​ 深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空
间开销要高。

​ 同样的对列表 a，如果使用 b = copy.deepcopy(a)，再修改列表 b 将不会影响到列表 a，即使嵌
套的列表具有更深的层次，也不会产生任何影响，因为深拷贝拷贝出来的对象根本就是一个全新的对象，
不再与原来的对象有任何的关联。

11.Python的作用域

​ 局部作用域 内嵌函数作用域 全局作用域 内建模块作用域

作用域	英文解释	英文简写
局部作用域(函数内)	Local(function)	L
外部嵌套函数作用域	Enclosing function locals	E
函数定义所在模块(文件)的作用域	Globals(module)	G
python 内置模块的作用域	Builtin(python)	B

高阶函数

​ 函数接受一个或者多个函数的传入 函数返回一个函数

​ map filter sorted

递归函数 函数直接或间接的调用自身 控制递归的层数

map、filter、sorted函数

函数	说明
map(func, *iterables)	用函数和对可迭代对象中的每一个元素作为参数计算出新的可迭代对象,当最短的一个可迭代对象不再提供数据时此可迭代对象生成结束
filter(function, iterable)	筛选可迭代对象iterable中的数据,返回一个可迭代器对象，此可迭代对象将对iterable进行筛选.函数function 将对iterable中的每个元素进行求值，返回False则将此数据丢弃，返回True，则保留此数据
sorted(iterable, key=None, reverse=False)	将原可迭代对象的数据进行排序，生成排序后的列表 iterable 可迭代对象 key 函数是用来提供一个值,这个值将作为排序的依据 reverse 标志用来设置是否降序排序

12.什么是迭代器

​ 可以通过next(it)函数取值的对象就是迭代器

​ 迭代器协议就是指对象能够使用next函数获取值,在没有下一个数据的时候就会报错

12.迭代器函数iter和next

函数	说明
iter(iterable)	从可迭代对象中返回一个迭代器,iterable必须是能提供一个迭代器的对象
next(iterator)	从迭代器iterator中获取一下个记录，如果无法获取一下条记录，则触发 StopIteration 异常

12.递归（recursion）

​ 定义 函数直接或间接的调用自身

​ 说明 递归一定要控制递归的层数，当符合一定条件时要终止递归调用
​ 几乎所有的递归都能用while循环来代替

​ 优点 递归可以把问题简单化，让思路更为清晰，代码更简洁

​ 缺点 递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

13.闭包

闭包是指引用了此函数外部嵌套函数作用域变量的函数（内部函数引用了该函数外部嵌套函数作用域的变量，这种现象叫闭包）

闭包必须满足三个条件：
a、必须有内嵌函数
b、内嵌函数引用外部函数的变量
c、外部函数的返回值必须是内嵌函数

​ 这个引用外部函数的变量 所以变量不会被及时销毁 带来的内存损耗比较大 所以要谨慎使用

​ 在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

14.装饰器

​ 装饰器函数就是在不改变原函数名或者类名的情况下改变或添加被包装对象的行为

​ def 装饰器函数名(参数):

​ 语句块

​ return 函数对象

​ @装饰器函数名

​ def 函数名(新参列表)

​ 语句块

1、装饰器的定义
装饰器是一个函数，主要作用是用来包装另一个函数或类
2、作用
在不改变原函数名(或类名)的情况下改变被包装对象的行为
3、函数装饰器的定义
函数装饰器是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数

示例

def mydeco(fn):
    def fx():
        print("fx函数被调用")
    return fx

# myfunc加了mydeco装饰器，等同于在myfunc创建之后调用
# myfunc = mydeco(myfunc)

@mydeco
def myfunc():
    print("函数myfunc被调用")

# 这样的写法可以用装饰器来代替

# 等同于

#   mydeco

#   def myfunc()....
# myfunc = mydeco(myfunc)

myfunc()

注：装饰器只调用一次，后面再次调用就是调用的返回的函数

15.模块的分类

​ 内置模块,在解析器的内部可以直接使用

​ 标准库模块 安装Python时已经安装 可以直接使用

​ 第三方库模块 ,需要自己安装

​ 用户自己编写的模块

Python的内置模块和第三方库模块

​ 标准库

​ datetime random sys os re

​ 第三方 Image PIL

​ from werkzeug.security import generate_password_hash,check_password_hash

​ from django.contrib.auth.hashers import make_password,check_password

Pyhton

16.Python中的异常

异常机制异常就是程序出错时的一种标识状态,用作信号通知,通知上层调用者有错误产生需要处理

try - except else finally

​ Python的异常处理能力是很强大的，它有很多内置异常，可向用户准确反馈出错信息。在Python中，异常也是对象，可对它进行操作。BaseException是所有内置异常的基类，但用户定义的类并不直接继承BaseException，所有的异常类都是从Exception继承，且都在exceptions模块中定义。Python自动将所有异常名称放在内建命名空间中，所以程序不必导入exceptions模块即可使用异常。一旦引发而且没有捕捉SystemExit异常，程序执行就会终止。如果交互式会话遇到一个未被捕捉的SystemExit异常，会话就会终止。

17.面向对象

面向对象
把一切看成对象(实例), 用各种对象之间的关系来描述事务

对象
对象是指现实中的物体或实体

对象的特征

​ 对象：人

​ 对象有很多属性(名词)
​ 姓名,性别, 年龄, …
​ 对象有很多行为(动作，动词)
​ 学习，吃饭，睡觉，工作, …

类
拥有相同属性和行为的对象分为一组，即为一个类
类是用来描述对象的工具，用类可以创建此类的对象(实例)

博大精深,面向对象的程序设计语言必须要有描述对象及其相互之间关系的语言成分.

​ 系统中的一切事物都是对象;对象是属性及其操作的封装体;对象可按照其性质分类,对象成为类的实例;

​ 实例 关系和继承关系是对象之间的静态关系;消息传递是对象之间动态联系的唯一方式

18.面向对象的三大特征

封装 继承 多态

​ 封装 就是将类中实现的细节隐藏起来,让使用这不关心或者少关心这些细节,目的就是让使用者通过尽可能少的实例变量来操作对象

​ 继承 就是指在类的继承中,子类将拥有父类原有的属性或者方法 而衍生的类中可以在基类的基础上增加属性和方法

​ 多态 在继承的类中,调用基类的方法时,实际可能会调用到被子类覆盖的同名方法的现象叫做多态

19.类方法

@classmethod

​ 类方法是描述类的行为的方法,类方法属于类,不属于该类的对象

​ 说明:类方法所需要使用@classmethod装饰器定义

​ 类方法至少有一个形参,第一个形参用于绑定类,绑定为cls

​ 类和该类的实例都可以调用类方法

​ 类方法不能访问此类创建的对象的实例属性

20.静态方法

@staticmethod

​ 静态方法是定义在类内的函数,此函数的作用域是类的内部作用域

​ 说明:

​ 静态方法需要使用@staticmethod装饰器定义

​ 静态方法与普通函数定义相同,不需要传入self和cls参数

​ 静态方法只能凭借该类或类的实例调用

​ 静态方法不能访问类变量和实例变量

21.单继承

​ 单继承是指派生类由一个基类衍生出来

22.多继承 multiple inheritance

​ 多继承是指一个子类继承自两个或两个以上的基类

23.继承和派生

继承: 是指在衍生出来的类中的对象会拥有原类的属性和行为

派生: 就是从已有的类中衍生出新的类，在新的类上可以添加新的属性和行为

2、继承(inheritance) 和 派生 (derived)

​ 继承 是从已有的类中派生出新的类，新类具有原类的数据属性和行为，并能扩展新的行为
​ 派生 就是从一个已有的类衍生出新的类，在新的类上可以添加新的属性和行为

​ 作用

​ a、用继承派生机制，可以将一些共有功能加在基类中，实现代码共享.
​ b、在不改变超类的代码的基础上改变原有的功能

24.函数的重写

​ 就是指在自定义的类内添加相应的方法,让自定义的类创建的实例可以像内建对象一样进行函数操作

四、网络编程

1.OSI七层模型

​ 应用层 ：提供用户服务，具体内容由特定程序规定
​ 表示层 ：提供数据的压缩解压和加密等
​ 会话层 ：建立应用连接，选择传输层服务
​ 传输层 ：提供合适的传输服务，流量控制
​ 网络层 ：路由选择，网络互联
​ 链路层 ：提供链路交换，具体消息发送
​ 物理层 ：物理硬件，接口

​ OSI七层模型优点 ： 将功能分开，降低了网络传输中的耦合性，每一部分完成自己的功能。可以在开发和实施的过程中各司其职。

2.tcp udp的异同

tcp是一种面向连接的传输服务,传输可靠,可传输大文件,数据无丢失无重复无失效无差错

传输方式是以字节流的方式,适用于邮件收发,文本文件的传输,网页的获取

udp是一种无连接的传输服务,数据自由收发,传输过程中网络较差时可能会有数据的丢失

传输方式是以数据报的方式传输 ,适用于广播,视频聊天等情况,

tcp套接字的创建流程

服务端

scof = socket(AT_INET,STREAM) socf.bind((127.0.0.1,8000)) socf.listen() connfd,addr = socf.accept() connfd.send() data=connfd.recv() connfd.close() socf.close()

客户端

socf=socket(AF_INET,STREAM) socf.connect() socf.send() data=scof.recv() socf.close()

3.tcp流式套接字、udp数据报套接字的区别

​ a、流式套接字采用字节流的方式传输数据，而数据报套接字以数据报形式传输
​ b、tcp会产生粘包现象，udp消息是有边界的不会粘包
​ c、tcp传输是建立在连接的基础上，保证传输的可靠性，而udp一次接受一个数据报，不保证完整性
​ d、tcp需要依赖listen accept建立连接，udp不用
​ e、tcp收发消息使用recv、send； udp收发消息使用recvfrom、sendto

4.网络收发缓存区:

​ 就是指客户端和服务端都存在使用send和recv 然而send数据时只是将数据交给tcp有tcp网络发送数据到接收缓冲区,然而数据的send速度和网络发送速度存在差异所以send的数据在上一条数据没有发送前也叫就会被放到tcp的发送缓存队列当中.

​ 这样的收发模式减少了和磁盘的交互,然后可能存在的情况就是会发生粘包现象,就是在发送缓存中的两条或者多条信息会被当成一条数据发送,接收到的数据就存在了差错,解决的办法就是,控制消息的收发速度,就是基本上可以达到当发送缓存队列中没有消息的时候在send,第二个就是在消息的末尾添加结束标识,将消息结构化.

​ 说一下发送缓冲区的消息是如何被删除的,发送缓冲区发送一条消息后,在接收缓存区收到消息后会反馈一个ACK收到ACK后发送缓存区就将消息清除.

udp套接字的创建

​ sock = socket(AF_INET,DGRAM) sock.bind() data,addr = sock.recvfrom() sock.sendto(data,addr) sock.close()

5.HTTP与HTTPs

HTTP，超文本传输协议（HyperText Transfer Protocol)，属于应用层协议；主要用于网页的获取（基于网站的数据传输），信息的传递（基于http协议的数据传输）。

HTTP是一种超文本传输协议 是一种客户端和应答的tcp 使浏览器更加的高效 网络传输减少，但较https不太安全 ，端口是80

HTTPS是一种用有加密的传输协议,需要SSL证书认证，传输数据加密更为安全，端口是443

​ 使用HTTPs访问地址的时候要求与web服务端建立SSL连接 可以认证访问用户可以进行加密码传输

​ 一般小的网站不会使用HTTPS因为SSL证书认证要钱,而且他的加载效率会比http降低50 耗电量正价10-20个点

​ 一般攻击人以中间身份攻击的话会加大成本,但是要是熟悉中间传输原理的人一样也可以攻击 没有绝对的安全

200访问成功 404 没有找到 403没有访问权限 500 服务器异常 301永久重定向 302重定向

6.IO操作

就是在内存中存在数据的交互 和终端的交互 和磁盘的交互 和网络的交互

IO密集型 在程序执行中有大量的IO操作较少的CPU计算 cpu 消耗少计算机资源利用高效率低下 耗时较长

计算(CPU)密集型 在程序的执行中有大量的计算,IO操作较少 CPU消耗大利用率高 速度快

IO 多路复用:同时监控多个IO事件,那个事件准备好久先执行那个事件,避免一个IO阻塞导致其他的事件都无法执行,提高了执行效率

实现IO多路复用的方法 select poll epoll

补充 按位与或异或 有0则0 有1则1 相同为0不同为1

7.epoll多路复用的优势

​ epoll是Linux专用的IO多路复用的方法

​ epoll的效率较高在内存中开辟的有自己的空间

​ epoll的监控数量比较多

​ epoll支持的触发类型比较多

一、进程

4、进程特征

​ * 进程是操作系统资源分配的最小单位
​ * 每个进程单独占有4G虚拟内存
​ * 进程之间相互独立，运行互不影响

5、进程的状态

​ 三态
​ * 就绪态：进程具备执行条件，等待系统分配cpu
​ * 运行态：进程占有cpu处理器，处于运行状态
​ * 等待态：进程暂时不具备运行条件，需要阻塞等待
​ 五态 （在三态基础上增加新建态和终止态）
​ * 新建态 ： 创建一个新的进程，获取资源的过程
​ * 终止态 ： 进程结束释放资源的过程

​ ps -aux —> STAT 查看进程状态
​ D 等待态 （不可中断等待）
​ S 等待态 （可中断等待）
​ T 等待态 （暂停状态）
​ R 运行态 （就绪态 运行态）
​ Z 僵尸态

​ + 前台进程
​ < 高优先级
​ N 低优先级
​ l 有进程链接
​ s 会话组组长

二、线程

​ 线程也是一种多任务编程的方式，可以使用计算机多核资源。线程又被称为轻量级的进程。

​ 线程特征
​ * 线程是计算机核心分配的最小单位
​ * 一个进程可以包含多个线程
​ * 线程也是一个运行过程，也要消耗计算机资源。多个线程共享其进程的资源和空间
​ * 线程也拥有自己特有的资源属性，比如指令集，TID等
​ * 线程无论创建还是删除还是运行资源消耗都小于进程
​ * 多个线程之间并行执行，互不干扰

​ 应用场景 ：
​ * 需要创建较多的并发，任务比较简单，线程比较合适。
​ * 如果程序见数据资源使用重叠比较多，要考虑到线程锁是否需要更复杂的逻辑
​ * 如果多个任务并无什么关联性，不易用多线程将其融入到一个进程中
​ * python线程不适用于计算密集型并发

​ import threading

一、进程和线程

1.0什么是进程，什么是线程？

进程：是资源分配的最小单位，创建和销毁开销较大，程序文件的一次执行；

线程：是CPU调度的最小单位，开销小，切换速度快；

计算CPU密集型程序推荐使用多进程

IO密集型程序适合使用多线程

1.1、进程和线程的特征

​ ## 1.a、进程特征
​ * 进程是操作系统资源分配的最小单位
​ * 每个进程单独占有4G虚拟内存
​ * 进程之间相互独立，运行互不影响
​ ## 1.b、线程特征
​ * 线程是计算机核心分配的最小单位
​ * 一个进程可以包含多个线程
​ * 线程也是一个运行过程，也要消耗计算机资源。多个线程共享其进程的资源和空间
​ * 线程也拥有自己特有的资源属性，比如指令集，TID等
​ * 线程无论创建还是删除还是运行资源消耗都小于进程
​ * 多个线程之间并行执行，互不干扰

1.2、区别和联系

​ * 两者都是多任务编程的方式，都能够使用计算机多核资源
​ * 进程创建和删除要比线程消耗更多计算机资源
​ * 进程空间独立数据安全性好，有专门的通信方法
​ * 线程使用全局变量通信，更加简单，但是往往需要同步互斥操作
​ * 一个进程可以包含多个线程，线程共享进程资源
​ * 进程、线程都有自己的特有属性资源，如命令、id等

1.3、使用场景

​ 线程使用场景:
​ 如果需要创建较多的并发，任务比较简单，线程比较适合
​ 如果数据操作和功能比较独立，此时使用进程比较合适
​ 使用线程时需要考虑到同步互斥复杂程度
​ python线程要考虑到GIL问题

​ 池的使用场景:
​ 线程池应用较少，用的最多的是进程池。

多任务编程

16.多任务编程

利用计算机的多核资源 同时执行多个任务 提高了计算机的执行效率

1.并发:

多任务执行在内核间不断的切换达到好像多个任务呗同时执行的效果,实际每个时刻只有一个任务执行

2.并行:

多个任务利用计算机的多核资源在同时执行,此时多个任务之间为并行的关系

3.孤儿进程:

父进程先于子进程退出,此时的子进程就会成为孤儿进程,会被系统进程收养

4.僵尸进程:

子进程先于父进程退出,父进程没有处理子进程的退出状态,此时子进程就会成为僵尸进程

​ 僵尸进程虽然已经结束但是会存留大量的PCB在内存中,大量的僵尸进程会占用计算机的内存资源

5.僵尸进程的处理方式:

​ 第一种用os.wait 在父进程中阻塞等待子进程的退出,处理好了子进程的退出状态后再退出

​ 第二种:就是创建二级子进程,父进程处理子进程的退出,子进程再创建二级子进程,二级子进程会编程孤儿进程和父进程执行任务

17.进程间通信的方式:

​ pipe管道通信 消息队列queue 共享内存 本地套接字 信号 和信号量

​ pipe管道通信 在内存开辟管道空间生成管道操作对象,来完成进程间的通信

​ 消息队列 先进先出 在内存中建立队列模型将消息存储在队列中,或者从队列中取出消息,先放入的消息一定会先取出

​ 共享内存:在内存中开辟一个区域,对多进程可见,进程可以写入内容或者读取内容,但是每次写入的内容都会覆盖之前的内容

18.线程间的通信

​ 使用进程空间中的全局变量通信

​ 注意事项线程间的通信往往需要同步互斥机制来协调,各个线程间户争夺资源

同步:同步是一种合作关系,为完成任务,多线程或线程之间形成一种协调,按照必要的步骤有序的执行一系列的操作

互斥:互斥是一种制约关系,当一个进程或线程使用临界资源时会进行加锁处理,其他的进程或线程无法操作临界资源,知道解锁后才可以

GIL:由于Python中加入了解释器锁,导致Python解释器在一个时刻解释一个线程,大大降低了Python执行的效率

后果:Python线程一般存在于大量的IO操作或者高延迟的IO程序中,.因为Python解释器在遇到阻塞后会主动让出解释器

19.进程和线程的区别和联系:

​ 两者都能使用计算机的多核资源

​ 进程的创建和删除消耗的资源比线程大

​ 进程运行空间独立相互之间不受干扰

​ 一个进程可以包含多个线程

​ 进程间通信使用的是队列 管道 共享内存 信号 信号量 套接字的方式

​ 线程间的通信使用的进程中的全局变量,同步互斥机制

​ 计算密集型的程序多使用进程

​ IO密集型的程序多使用线程

​ 线程和进程都有特殊的属性,如Id 字符集 代码段等

20.协程:

定义：纤程，微线程。本质上只是一个线程在运行。

功能特点：通过应用层程序，记录上下文栈区，实现在程序执行过程中的跳跃执行。由此可以选择不阻塞的部分执行以提升运行效率。

优点：
资源消耗少
无需多线程那样进行多核之间的切换
无需同步互斥操作
IO并发性好

缺点：
无法利用计算机的多核资源

纤程,维线程,是为非抢占式或多任务产生子程序的计算机组件,协程允许不同入口点在不同位置开始或者暂停,简单说协程就是可以暂停执行的函数 yield

协程原理:记录一个函数的栈的上下文(记录函数执行到了什么位置),进行协程的切换调度,当一个协程暂停执行时会将上下文的栈帧保存起来,在切换回来时恢复到原来的位置,继而继续执行

1.协程的优点:

​ 协程可以同时执行多个任务

​ 协程本质上是一个单线程,消耗的资源很少

​ 协程相互间的切换不需要开销

​ 协程不是抢占型,不需要同步互斥机制

协程的缺点:无法利用计算机的多核资源

19.进程池

1.原理:

创建一定量的进程作为进程池,用来处理事件,事件处理完毕后,进程不退出,而是继续等待 处理其他的事件,直到所有待处理事件处理完毕后统一销毁进程,增加了进程的重复利用,降低资源消耗.

使用方法:

1.创建进程池,放入适当的进程

2.将要做的事件封装为函数,放入进程池等待队列

3.进程池中的进程会不断执行队列中的事件直到全部被执行

4.关闭进程池.回收进程

多进程的一些问题

2.优点：

可以使用计算机的多核同时运行多个任务，提高了运行效率

3.缺点：

进程创建删除需要消耗的系统资源较多,大量进程频繁的创建删除会给系统带来压力

进程池技术

产生原因:应对大量任务需要多进程完成,需要频繁创建删除进程的情况

五、MySQL

​ 1.关系型数据库

​ 关系型数据库

​ 数据以行和列(表格)形式存储

​ 表中每一行叫做一条记录,每一列叫一个字段

​ 表与表之间的逻辑关联叫关系

15.查看mysql的状态

​ sudo /etc/init.d/mysql status

启动mysql服务

​ sudo /etc/init.d/mysql start | stop | restart

create table 表名 (字段 数据类型,…)

insert into 表名 values(值1),(值2)…

数据类型(整数型 浮点型 字符型)

枚举和集合(enum 单选 set 多选)

16.表结构操作

​ alter table 表名 add 字段名 数据类型

​ alter table 表名 add 数据类型 first after

​ alter table 表名 drop 字段名

​ alter table 表名 modify 字段名 新数据

​ alter table 表名 rename 新的表名

​ alter table 表名 change 原名 新名 数据类型

17.删除

​ delete from 表名 条件 不给条件删除所有

18.更新

​ update 表名 set 字段=值,字段=值, where 条件

​ 条件是必须要有的

19.查询

​ select …聚合函数 from 表名 where…group by…having…order by…limit…;

执行顺序 where–group by–select—having—order by—limit

limit m, n 表示显示从第m+1条记录开始的n条数据

聚合函数

​ avg sum max min count

如果select 后面的字段与group by 后面的不一致 那么必须要对该字段进行聚合操作

distinct 不显示重复的字段

select distinct country from 表名;

20.多表查询

​ select 字段1,字段2 from 表1,表2;(笛卡尔积)

21.连接查询

​ select 字段名 from 表1 inner join 表2 on 条件

22.索引

​ 定义:对数据库中表的一列或者多列的值进行排序的一种结构

​ 优点:加快数据的检索速度

​ 缺点:

​ 占用物理存储空间

​ 当表中的数据更新时,索引需要动态维护,占用一定的系统资源,降低资源的维护速度

23.索引的分类

​ 普通索引(index) 唯一索引(unique)(要求值不能重复)

​ Index 无约束,unique要求字段不能重复但是可以为控制Null

​ Index 的标志 MUL unique 标志UNI PRI

24.主键:

​ 一个表中只能有一个主键字段

​ 不能重复 不能为NULL

​ 一般就是id

show engines;

25.锁的分类:读锁:能查不能改 写锁不能查也不能改

读锁（select）
共享锁：加读锁之后不能更改表中内容，但可以进行查询
写锁（insert、update、delete）互斥锁、排他锁

表级锁 行级锁

innoDB 支持外键 支持事务回滚 支持事务 支持行级锁 共享表空间

MyISAM 支持表级锁 独享表空间

1.执行查询操作多的使用MyISAM

2.执行写操作多的表用InnoDB

mysqldump -u用户名 -p原库名 > 地址/xxx.sql

原库名备份方式 --All-database -B 库1 库2

库名 表1 表2 表3

26.数据恢复

mysql -uroot -p目标库名 < xxx.sql

load data infile “文件路径” into table 表名 …

27.数据库三范式

​ 第一范式: 列不可拆分

​ 第二范式: 唯一标识

​ 第三范式: 引用主键

28.事务:一件事从头开始发生到结束的过程

确保数据的一致性

begin rollback

事务只是针对于表记录相关的操作

db = pymysql.connect()

c = db.cursor()

c.ececute(“sql命令”)

db.commit()

c.close()

db.close()

连接参数:host user password database charset port

29.MySQL调优

​ 选择合适的存储引擎

​ 创建索引

​ 避免全表扫描

​ 不使用不等

​ 不判断是不是为空

​ 避免使用or

​ 模糊查询避免前面使用%

​ 避免使用 in not in 可以使用between代替

​ 尽量不要使用select * 返回无用的字段

30.MySQL调优

1、选择合适的存储引擎

​ 经常用来读的表使用myisam存储引擎
​ 其余的表都用innodb存储引擎

2、创建索引

​ 在SELECT、WHERE、ORDER BY常涉及的字段建立索引

3、SQL语句优化（尽量避免全表扫描）

​ a、where条件判断尽量不使用 != ，否则放弃索引全表扫描
​ c、尽量避免NULL值判断，否则会全表扫描
​ d、尽量避免用 or 来连接条件，否则会全表扫描
​ e、模糊查询尽量避免使用前置%，否则会全表扫描
​ f、尽量避免使用in 和 not in，否则会全表扫描
​ g、尽量避免使用select * … ，用具体的字段代替*，不要返回用不到的任何字段

31.mysql中引擎的优缺点 engine 指定表的引擎

​ MyISAM管理非事务表,适合于查询操作较多的情况,它提供高速存储和检索,以及全文搜索能力,是mysql的默认引擎

​ 支持表级锁,独享表空间

​ MEMORY表结构存储在硬盘中,表记录存储在内存中,服务/主机重启后,表结构还在,表记录消失

​ Innodb和dbd存储引擎提供事务安全表,支持外键,支持事务回滚,支持行级锁,共享表空间,适合于写操作比较多的情况

​ 表级锁一次会将整个表锁定,避免死锁问题,行级锁的消耗比较大,容易死锁.

六、MongDB

1.MongDB数据库

​ 非关系型数据库

​ 优点:数据可以长期存储 存储数据量大 使用简单

​ 缺点:诗句的存储结构随意 数据的查找,修改效率低 不方便扩展和自动化处理

2.关系型数据库

​ 优点:

​ 容易理解,逻辑类似表格

​ 使用方便,都是成熟的sql语句

​ 数据一致性高,冗余低,完整性好

​ 技术成熟,可以使用表的外键关联等操作

​ 缺点:

​ 每次数据操作都需要sql解析,消耗大

​ 关系型数据库内部往往有加锁处理,导致处理的速度也不是很高

​ 数据的一致性要求高,导致使用不是很灵活

​ 不能很好的处理海量的高并发需求,读写能力差

3.非关系型数据库

​ 优点:

​ 并发能力强,读写速度快,可以很好的因对海量的高并发需求

​ 使用灵活,容易扩展

​ 缺点:

​ 没有像sql一样的成熟的语句

​ 技术成熟度没有sql好,没有像sql一样的外键关联

一、关系型数据库

关系型数据库最典型的数据结构是表，由二维表及其之间的联系所组成的一个数据组织
优点：
1、易于维护：都是使用表结构，格式一致；
2、使用方便：SQL语言通用，可用于复杂查询；
3、复杂操作：支持SQL，可用于一个表以及多个表之间非常复杂的查询。
缺点：
1、读写性能比较差，尤其是海量数据的高效率读写；
2、固定的表结构，灵活度稍欠；
3、高并发读写需求，传统关系型数据库来说，硬盘I/O是一个很大的瓶颈。

二、非关系型数据库

非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合，可以是文档或者键值对等。
优点：
1、格式灵活：存储数据的格式可以是key,value形式、文档形式、图片形式等等，文档形式、图片形式等等，使用灵活，应用场景广泛，而关系型数据库则只支持基础类型。
2、速度快：nosql可以使用硬盘或者随机存储器作为载体，而关系型数据库只能使用硬盘；
3、高扩展性；
4、成本低：nosql数据库部署简单，基本都是开源软件。

缺点：
1、不提供sql支持，学习和使用成本较高；
2、无事务处理；
3、数据结构相对复杂，复杂查询方面稍欠。

非关系型数据库的分类和比较：
1、文档型
2、key-value型
3、列式数据库
4、图形数据库

七、django框架

1.session和cookie的异同

​ session是保存在服务器中锁开PI的一段空间中,cookie是保存在浏览器中,保存方式是随着响应对象被带到浏览器中保存

​ session相对于cookie来说安全性较高

​ session存在于一次会话中,而cookie可以长时间的保存

​ 浏览器访问经常要用到的数据保存到session 不重要的一些数据保存到cookie

(1)cookie数据存放在客户的浏览器上，session数据放在服务器上
(2)cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,如果主要考虑到安全应当使用session
(3)session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，如果主要考虑到减轻服务器性能方面，应当使用COOKIE
(4)单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE不能3K。
(5)所以：将登陆信息等重要信息存放为SESSION;其他信息如果需要保留，可以放在COOKIE中

2.django框架的理解

​ django是一种重量级的python web框架,采用的是MTV框架模式

​ M:models一个抽象层,用来构建和操作你的web应用中的数据,模型是你的数据唯一的,权威的信息源,包含你所存储的数据的必要字段和行为,通常每个模型对应数据库中唯一的一张表

​ T:templates 模板,模板层提供设计有好的语法来展示信息给客户,使用模板的方法可以动态的生成HTML页面.模板包含html所需要输出的静态部分,以及一些特殊的语法,描述如何将数据动态插入

​ V:views视图,用于封装处理用户请求即返回响应逻辑.视图可以看做是前端与数据库的中间人,他会将前端想要的数据从数据库中读取出来给前端,也会将用户想要保存的数据写到数据库

​ django是走向大而全的方向,它最出名的时期自动化的后台管理功能,只要启用ORM,做简单的对象定义,就能生成数据库结构,以及全功能的管理后台

对面向对象的理解

3.Django框架的使用

​ 1.创建项目的指令

​ 指令 : django-admin

​ 语法 : django-admin startproject 项目名

​ 2.django项目的目录结构

​ 1.manage.py

​ 功能:包含项目管理相关的子命令

​ 如 :

​ 启动服务 : runserver

​ 创建应用 : startapp

​ 创建管理员 : createuperuser

​ 数据迁移 : migrate

Django-admin startproject xxx

Python3 manage.py startapp xxx createsuperuser migrate makemigration runserver

4.除了django还了解哪些框架和开发模式

​ Flask 是一种有jinjie2引擎和WSGI工具集支持的轻量级框架,也是MTV开发模式,上手简单,是一款开发社区平台的神器

MVC模式 : C就是Contrl

5.后端框架对比：Flask与Django

主要对比包括：

1. Flask提供了灵活性，简单性和细粒度的控制。
2. Flask不受限制，让你决定如何实现应用程序。
3. Django为你的Web应用程序开发提供了管理面板，数据库界面，目录结构和ORM的全方位体验。

6.http一次完整的请求7步

​ 浏览器发送请求连接标识

​ 服务端回复连接标识标识可以连接

​ 浏览为发送标识建立最终连接

​ 浏览器向服务器发送请求命令

​ 浏览器发送请求头 最后发送一个空的请求头代表请求内容结束 如果是POST提交会继续发送请求体

​ 服务器应答返回响应状态码 也就是响应行

​ 服务器发送响应头,包含自身的信息,最后发送一个空行表示响应头发送完成

​ 服务器以响应头锁描述的格式向浏览器发送用户所请求的实际数据

​ web服务器关闭服务器,断开连接 其中采用的是四次挥手 主动方向被动方发送断开请求,被动方接收请求后回复 被动方处理好之后发送可以断开标识 主动方断开连接

​ 如果添加connect:keep-alive将不会断开tcp连接还是保持打开状态

请求格式

​ 请求行 GET / HTTP/1.1 请求头

​ 请求头 主要是自身的信息 发送完成后有一个空行表示发送完成 如果是POST提交的话会继续发送POST提交的内容

​ 请求体

响应格式

​ 响应行 HTTP/1.1 200 OK

​ 响应头 主要也是自身信息和被请求的文档 最后发送一个空行表示响应头发送完成

​ 响应体 按照Content-type响应头锁描述的格式发送用户实际所请求的数据

6.ajax实现的原理是什么及json在ajax 中的作用

​ ajax的工作原理是：一个页面的指定位置可以加载另一个页面所有输出的内容,这样就实现了一个静态网页也能够获取到数据库中返回的数据信息了,所以ajax技术实现了一个静态的网页在不刷新整个页面的情况下与服务器通信,减少了用户等待的时间,同时也降低了网络流量,增加了用户的体验度.

​ 在使用ajax时,涉及到数据的传输,即将数据从服务器返回到客户端,服务器和客户端分别使用不同的脚本语言来处理数据,这就需要一种通用的数据格式,XML和JSON就是最常见的两种,而json更加简单常用

八、版本控制

1.git 分布式管理工具

​ 更适合个人开发,配置管理库

​ 分布式的管理,不同于SVN的集中式管理

​ 支持旺达的分支管理功能

​ 完整性要优于SVN

1.github 远程仓库

​ 第一步:在gittee或github上注册账号

​ 第二步:创建项目,并且拷贝地址

​ 第三步:在工作目录下加入远程仓库地址

​ git remote add gitee 名称 远程仓库地址

​ https://gitee.com/AA_123456789/git_test2.git

​ 第四步:从远程仓库获取配置库

​ git pull 远程仓库名称 分支版本名称

​ 例如:git pull gitee master

​ 第五步:修改工作目录文件,并且提交到本地仓库

​ 例如: 修改a.txt后 执行提交

​ git commit a.txt -m “remote”

​ 第六步:推送到远程仓库

​ 切换到master分支下,做一个pull操作

​ git pull gitee master

​ git push -u 远程仓库名称 分支版本

​ Git clone 将远程仓库中所有文件克隆到本地

​ 例如:git push -u gitee master

​ *推送到gitee仓库master的分支下

九、其他总结

一、PEP8编码规范

1、代码编排

​ a、使用4空格缩进。不使用Tab，更不允许用Tab和空格混合缩进
​ b、每行最大长度最大79字节，换行可以使用反斜杠，最好使用圆括号
​ c、类和全局函数定义间隔两个空行，类内方法定义间隔一个空行，其它地方可以不加空行。

2、文档编排

​ 模块内容的顺序：模块说明和docstring（文档字符串）—import—globals&constants（常量）—其他定义。其中import部分，又按标准、三方和自己编写顺序依次排放，之间空一行。
​ 不要在一句import中导入多个模块，比如不推荐import os, sys。
​ 尽可能用import XX 而不采用from XX import YY引用库,因为可能出现名字冲突。

3、空格的使用

​ 总体原则，避免不必要的空格。
​ a、各种右括号前不用加空格
​ b、逗号、冒号、分号前不要加空格。
​ c、函数的左括号前不要加空格。如func(1)。
​ d、序列的左括号前不要加空格。如list[2]。
​ e、操作符左右各加一个空格，不要为了对齐增加空格。
​ f、函数默认参数使用的赋值符左右省略空格。
​ g、不要将多条语句写在同一行，尽管使用‘;’允许。
​ h、if/for/while语句中，即使执行语句只有一句，也必须另起一行

4、注释

​ 总体原则，错误的注释不如没有注释。所以当一段代码发生变化时，第一件事就是要修改注释！
​ 避免无谓的注释。

5、文档描述

​ 为所有的共有模块、函数、类、方法写docstrings。

6、命名规范

​ a、避免单独使用小写字母‘l’，大写字母‘O’等容易混淆的字母。
​ b、模块命名尽量短小，使用全部小写的方式，可以使用下划线。
​ c、包命名尽量短小，使用全部小写的方式，不可以使用下划线。
​ d、类的命名使用CapWords的方式，模块内部使用的类采用_CapWords的方式。
​ e、异常命名使用CapWords+Error后缀的方式。
​ f、全局变量尽量只在模块内有效，类似C语言中的static。实现方法有两种，一是__all__机制;二是前缀一个下划线。
​ g、函数命名使用全部小写的方式，可以使用下划线。
​ h、常量命名使用全部大写的方式，可以使用下划线。
​ i、类的属性（方法和变量）命名使用全部小写的方式，可以使用下划线。
​ j、类的属性有3种作用域public、non-public和subclass API。
​ k、类的属性若与关键字名字冲突，*后缀*一下划线，尽量不要使用缩略等其他方式。
​ l、为避免与子类属性命名冲突**，在类的一些属性前缀一下划线，前缀两条下划线。比如：类Foo中声明__a,访问时，只能通过Foo._Foo__a，避免歧义。如果子类也叫Foo，那就无能为力了。

​ m、类的方法第一个参数必须是self，而静态方法第一个参数必须是cls。

二、知识点总结

1、序列

​ 字符串（str）、列表（list）、元组（tuple）、字节串（bytes）、字节数组 （bytearray）

可变序列：列表（list）、字节数组 （bytearray）

不可变序列：字符串（str）、元组（tuple）、字节串（bytes）

2、字典

字典的值（value）可以是任意类型：

​ 字典的值可以是布尔值，数据，字符串，None，列表，元组，字典，集合，函数，类对象等所有类型

字典的键（key）必须为不可变类型的值：（集合内的元素必须是不可变的对象）
不可变的类型：
bool，int，float，complex，str，tuple，frozenset（固定集合）、字节串（bytes）
包括：None

注：可变类型：列表（list），字典（dict），集合（set）、字节数组 （bytearray）

3、可迭代对象

序列：字符串（str）、列表（list）、元组（tuple）、字节串（bytes）、字节数组 （bytearray）

字典：字典是可迭代对象，字典只能对键进行迭代访问

集合（set）、固定集合（frozenset）

4、类变量和实例变量（实例属性）

​ 类变量：类变量是类的属性，此属性属于类，不属于此类创建的实例

​ 实例变量（属性）：每个实例可以有自己的变量，称为实例变量（属性）