Error 或 Wraning 后缀。自定义的变量名、函数名不能和标准库中的函数名重名。串行:** 指的是一个所有的任务都按照先后顺序执行&＃xff0c;在前一个任务没处理完的情况下是不会去处理下一个任务的&＃xff0c;一个CPU上&＃xff0c;按顺序完成多个任务。就像理发店只有一个理发师&＃xff0c;每个人剪头发都需要等待前面的人处理完**并行: ** 是指将任务分给不同的处理器去处理&＃xff0c;每一个处理器再串行处理&＃xff0c;比如火车站售票会有多个窗口**并发&＃xff1a;** 指一个处理器同时处理多个任务。一个CPU采用时间片管理方式&＃xff0c;交替的处理多个任务。一般是是任务数多余cpu核数&＃xff0c;通过操作系统的各种任务调度算法&＃xff0c;实现用多个任务“一起”执行&＃xff08;实际上总有一些任务不在执行&＃xff0c;因为切换任务的速度相当快&＃xff0c;看上去一起执行而已&＃xff09;
线程是指进程内的一个执行单元&＃xff0c;
# 进程
进程拥有自己独立的堆和栈&＃xff0c;既不共享堆&＃xff0c;亦不共享栈&＃xff0c;进程由操作系统调度。
# 线程
线程拥有自己独立的栈和共享的堆&＃xff0c;共享堆&＃xff0c;不共享栈&＃xff0c;线程亦由操作系统调度。
# 协程
协程是运行在单线程中的"并发"&＃xff0c;协程相比多线程的一大优势就是省去了多线程之间的切换开销&＃xff0c;获得了更高的运行效率。所以可以用协程取代多线程。协程避免了无意义的调度&＃xff0c;由此可以提高性能&＃xff1b;但同时协程也失去了线程使用多核CPU的能力。进程与线程的区别如果把进程比喻成项目组办公室&＃xff0c;那么线程就是办公室里的员工&＃xff0c;一个办公室可以有多个员工&＃xff0c;每个员工的任务不同&＃xff0c;但他们共享办公司资源。
&＃xff08;1&＃xff09;地址空间&＃xff1a;线程是进程内的一个执行单位&＃xff0c;进程内至少有一个线程&＃xff0c;他们共享进程的地址空间&＃xff0c;而进程有自己独立的地址空间
&＃xff08;2&＃xff09;资源拥有&＃xff1a;进程是资源分配和拥有的单位&＃xff0c;同一个进程内多线程共享进程的资源
&＃xff08;3&＃xff09;线程是处理器调度的基本单位&＃xff0c;但进程不是
&＃xff08;4&＃xff09;二者均可并发执行
&＃xff08;5&＃xff09;每个独立的线程有一个程序运行的入口协程与线程
&＃xff08;1&＃xff09;一个线程可以有多个协程&＃xff0c;一个进程也可以有多个协程&＃xff0c;这样Python则能使用多核CPU
&＃xff08;2&＃xff09;线程、进程都是同步机制&＃xff0c;而协程是异步
&＃xff08;3&＃xff09;协程能保留上一次调用时的状态
Python代码的执行由Python 虚拟机(也叫解释器主循环&＃xff0c;CPython版本)来控制&＃xff0c;Python 在设计之初就考虑到要在解释器的主循环中&＃xff0c;同时只有一个线程在执行&＃xff0c;即在任意时刻&＃xff0c;只有一个线程在解释器中运行。对Python 虚拟机的访问由全局解释器锁&＃xff08;GIL&＃xff09;来控制&＃xff0c;正是这个锁能保证同一时刻只有一个线程在运行。
- new__是在实例创建**之前**被调用的&＃xff0c;因为它的任务就是创建实例然后返回该实例对象&＃xff0c;是个静态方法。
- __init__是当实例对象创建完成后被调用的&＃xff0c;然后设置对象属性的一些初始值&＃xff0c;通常用在初始化一个类实例的时候。是一个实例方法。也就是&＃xff1a; __new__先被调用&＃xff0c;__init__后被调用&＃xff0c;__new__的返回值&＃xff08;实例&＃xff09;将传递给__init__方法的第一个参数&＃xff0c;然后__init__给这个实例设置一些参数。1. new是构造方法&＃xff0c;init是初始化函数。
2. new通常不需要手动定义&＃xff0c;一般在元类编程中使用&＃xff0c;控制类的生成过程。
3. new第一个被执行&＃xff0c;然后执行init绑定实例变量。
4. new必须有返回值&＃xff0c;返回值是该类的实例&＃xff0c;它会被init函数接收&＃xff0c;通常叫做self变量
当一个对象有新的引用时&＃xff0c;它的ob_refcnt就会增加&＃xff0c;当引用它的对象被删除&＃xff0c;它的ob_refcnt就会减少。引用计数为0时&＃xff0c;该对象生命就结束了
将系统中的所有内存块根据其存活时间划分为不同的集合&＃xff0c;每个集合就成为一个“代”&＃xff0c;垃圾收集频率随着“代”的存活时间的增大而减小&＃xff0c;存活时间通常利用经过几次垃圾回收来度量
基本思路是先按需分配&＃xff0c;等到没有空闲内存的时候从寄存器和程序栈上的引用出发&＃xff0c;遍历以对象为节点、以引用为边构成的图&＃xff0c;把所有可以访问到的对象打上标记&＃xff0c;然后清扫一遍内存空间&＃xff0c;把所有没标记的对象释放
指一个外包函数的内部定义的嵌套函数&＃xff0c;而且(外包函数的)外界能够使用该函数。它通常作为返回值。
创建一个闭包必须满足以下几点:
闭包的特点&＃xff1a;
13.什么是装饰器以及写一个带参数的装饰器&＃xff1f;
用于拓展原来函数功能的一种函数&＃xff0c;目的是在不改变原函数名(或类名)的情况下&＃xff0c;给函数增加新的功能。装饰器的返回值也是一个函数对象 。
def mylog(type):def decorator(func):def infunc(*args, **kwargs):if type&＃61;&＃61;"文件":print("文件中&＃xff1a;日志纪录")else:print("控制台&＃xff1a;日志纪录")return func(*args, **kwargs)return infuncreturn decorator&＃64;mylog("文件")
def fun2(a,b):print("使用功能2",a,b)if __name__ &＃61;&＃61; &＃39;__main__&＃39;:fun2(100,200)
在Python中&＃xff0c;一边循环一边计算的机制&＃xff0c;称为生成器&＃xff1a;generator生成器仅仅保存了一套生成数值的算法&＃xff0c;并且没有让这个算法现在就开始执行&＃xff0c;而是我什么时候调它&＃xff0c;它什么时候开始计算一个新的值&＃xff0c;并给你返回。
1 迭代是Python最强大的功能之一&＃xff0c;是访问集合元素的一种方式。
2 迭代器是一个可以记住遍历的位置的对象。
3 迭代器对象从集合的第一个元素开始访问&＃xff0c;直到所有的元素被访问完结束。
4 迭代器只能往前不会后退。
5 迭代器有两个基本的方法&＃xff1a; iter() 和 next()
1.单引号和双引号没有区别。都可以用就是为了方便&＃xff0c;减少写太多的转义字符。
str&＃61;&＃39;Let\&＃39;s go!&＃39; # &＃xff08;使用转义符 \&＃xff09;
str&＃61;"Let&＃39;s go!"
两种等价&＃xff0c;但是第二种写法显然更优雅。
2.三个双引号用来输入多行文本&＃xff0c;也就是说在三引号之间输入的内容将被原样保留&＃xff0c;之中的单号和双引号不用转义&＃xff0c;其中的不可见字符比如\n和\t都会被保留&＃xff0c;这样的好处是你可以替换一些多行的文本。
栈区&＃xff1a;存储运行方法的形参、局部变量、返回值。由系统自动分配和回收。
堆区&＃xff1a;new一个对象的引用或地址存储在栈区&＃xff0c;指向该对象存储在堆区中的真实数据。
三次握手之所以是三次是保证client和server均让对方知道自己的接收和发送能力没问题而保证的最小次数。
第一次握手&＃xff1a;客户端发送请求报文将SYN &＃61; 1同步序列号和初始化序列号seq &＃61; x发送给服务端&＃xff0c;发送完之后客户端处于SYN_Send状态。
第二次握手&＃xff1a;服务端受到SYN请求报文之后&＃xff0c;如果同意连接&＃xff0c;会以自己的同步序列号SYN(服务端) &＃61; 1、初始化序列号seq &＃61; y和确认序列号&＃xff08;期望下次收到的数据包&＃xff09;ack &＃61; x&＃43; 1以及确认号ACK &＃61; 1报文作为应答&＃xff0c;服务器为SYN_Receive状态。
第三次握手&＃xff1a; 客户端接收到服务端的SYN &＃43; ACK之后&＃xff0c;知道可以下次可以发送了下一序列的数据包了&＃xff0c;然后发送同步序列号ack &＃61; y &＃43; 1和数据包的序列号seq &＃61; x &＃43; 1以及确认号ACK &＃61; 1确认包作为应答&＃xff0c;客户端转为established状态。
基本流程&＃xff1a;
a. 域名解析
b. 发起TCP的3次握手
c. 建立TCP连接后发起http请求
d. 服务器端响应http请求&＃xff0c;浏览器得到html代码
e. 浏览器解析html代码&＃xff0c;并请求html代码中的资源
f. 浏览器对页面进行渲染呈现给用户
当一个函数中出现&＃96;&＃96;yield&＃96;&＃96;关键字的时候&＃xff0c;那么这个函数就是一个生成器(generator)。
函数转化为generator后&＃xff0c;在每次调用&＃96;&＃96;next&＃96;&＃96;()的时候执行&＃xff0c;遇到&＃96;&＃96;yield&＃96;&＃96;语句返回&＃xff0c;再次执行时从上次返回的&＃96;&＃96;yield&＃96;&＃96;语句处继续执行。
class Single:__obj &＃61; None__falg &＃61; Truedef __new__(cls, *args, **kwargs):if cls.__obj &＃61; None:cls.__obj &＃61; object.__new__(cls)return cls.__objdef __init__(self):if Single.__flag:print("__init__")Single.__flag &＃61; Falsea &＃61; Single()
b &＃61; Single()
print(a)
print(b)
打开文件在进行读写的时候可能会出现一些异常状况&＃xff0c;如果按照常规的f.open写法&＃xff0c;我们需要try,except,finally&＃xff0c;做异常判断&＃xff0c;并且文件最终不管遇到什么情况&＃xff0c;都要执行finally f.close()关闭文件&＃xff0c;with方法帮我们实现了finally中f.close
1、使用生成器&＃xff0c;因为可以节约大量内存
2、循环代码优化&＃xff0c;避免过多重复代码的执行
3、核心模块用Cython PyPy等&＃xff0c;提高效率
4、多进程、多线程、协程
5、多个if elif条件判断&＃xff0c;可以把最有可能先发生的条件放到前面写&＃xff0c;这样可以减少程序判断的次数&＃xff0c;提高效率
顾名思义&＃xff0c;这类函数没有显示地定义函数名。
lambda用来表示匿名函数&＃xff0c;可以传入多个参数&＃xff0c;但只能有一个表达式。
好处&＃xff1a;一次性使用&＃xff0c;随时随地的定义更容易阅读&＃xff0c;做了什么更是一目了然
一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)&＃xff0c;要么完全地执行&＃xff0c;要么完全地不执行
原子性&＃xff08;Atomicity&＃xff09;&＃xff1a;事务作为一个整体被执行&＃xff0c;包含在其中的对数据库的操作要么全部被执行&＃xff0c;要么都不执行。
一致性&＃xff08;Consistency&＃xff09;&＃xff1a;事务应确保数据库的状态从一个一致状态转变为另一个一致状态。一致状态的含义是数据库中的数据应满足完整性约束。
隔离性&＃xff08;Isolation&＃xff09;&＃xff1a;多个事务并发执行时&＃xff0c;一个事务的执行不应影响其他事务的执行。
持久性&＃xff08;Durability&＃xff09;&＃xff1a;一个事务一旦提交&＃xff0c;他对数据库的修改应该永久保存在数据库中。
**优点&＃xff1a;**为某个字段建立了索引之后&＃xff0c;查询这个字段里面的数据的时候&＃xff0c;效率更高&＃xff0c;也就是快&＃xff0c;
**缺点&＃xff1a;**还有就是需要注意的&＃xff0c;索引是查的效率高了&＃xff0c;但是在表中插入或更新数据时&＃xff0c;将有额外的操作来维护索引&＃xff0c;所以其他的效率低了&＃xff0c;还有占用存储空间&＃xff0c;还有不要建立过多的索引&＃xff0c;过多索引引起反作用&＃xff01;
将多个表联合起来进行查询&＃xff0c;主要有内连接、左连接、右连接、全连接&＃xff08;外连接&＃xff09;
⑴ 原子性&＃xff08;Atomicity&＃xff09;
原子性是指事务包含的所有操作要么全部成功&＃xff0c;要么全部失败回滚。
⑵ 一致性&＃xff08;Consistency&＃xff09;
一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态&＃xff0c;也就是说一个事务执行之前和执行之后都必须处于一致性状态。
⑶ 隔离性&＃xff08;Isolation&＃xff09;
隔离性是当多个用户并发访问数据库时&＃xff0c;比如操作同一张表时&＃xff0c;数据库为每一个用户开启的事务&＃xff0c;不能被其他事务的操作所干扰&＃xff0c;多个并发事务之间要相互隔离。
⑷ 持久性&＃xff08;Durability&＃xff09;
持久性是指一个事务一旦被提交了&＃xff0c;那么对数据库中的数据的改变就是永久性的&＃xff0c;即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
# 数据库的三大特性&＃xff1a;
&＃39;实体&＃39;:表
&＃39;属性&＃39;&＃xff1a;表中的数据(字段)
&＃39;关系&＃39;&＃xff1a;表与表之间的关系
----------------------------------------------------
# 数据库设计三大范式&＃xff1a;
1&＃xff1a;确保每列保持原子性&＃xff08;即数据库表中的所有字段值是不可分解的原子值&＃xff09;
2&＃xff1a;确保表中的每列都是和主键相关&＃xff08;表中只能保存一种数据&＃xff0c;不可以把多种数据保存在同一张表中&＃xff09;--->完全属于当前表的数据
3&＃xff1a;确保每列都和主键直接相关&＃xff0c;而不是间接相关&＃xff08;在一个数据库表中保存的数据只能与主键相关&＃xff09;----> 消除传递依赖&＃xff08;间接&＃xff09;
比如在设计一个订单数据表的时候&＃xff0c;可以将客户编号作为一个外键和订单表建立相应的关系。而不可以在订单表中添加关于客户其它信息&＃xff08;比如姓名、所属公司等&＃xff09;的字段。
# 数据库五大约束&＃39;1.primary KEY&＃xff1a;设置主键约束&＃xff1b;2.UNIQUE&＃xff1a;设置唯一性约束&＃xff0c;不能有重复值&＃xff1b;3.CHECK&＃xff1a;检查约束 4.NOT NULL&＃xff1a;设置非空约束&＃xff0c;该字段不能为空&＃xff1b;5.FOREIGN key&＃xff1a;设置外键约束。
ps -ef |grep 进程名 kill -9 ID号
是每一个用户登录时,操作系统首先执行的文件,然后再将控制权交给用户主目录下的.profile文件
Linux是一个多用户的操作系统。每个用户登录系统后&＃xff0c;都会有一个专用的运行环境。通常每个用户默认的环境都是相同的&＃xff0c;这个默认环境实际上就是一组环境变量的定义。用户可以对自己的运行环境进行定制&＃xff0c;其方法就是修改相应的系统环境变量。
netstat -lnp
1xx:提示信息--表示请求接受&＃xff0c;继续处理
2xx:成功表示请求成功接收&＃xff0c;理解&＃xff0c;接受
3xx:重定向要完成请求必须更进一步操作
4xx:客户端错误&＃xff0c;请求有语法错误或请求无法实现
5xx:服务器端错误--服务器没有实现合法请求
用户请求 --> wsgi --> jango的中间件(方法process_request) --> url路由匹配 --> 视图 --> orm数据库操作 --> 模板渲染
--> 中间件(方法process_response) --> wsgi -->用户
1. 当用户在浏览器中输入url时浏览器会生成请求头和请求体发送给服务端请求头和请求体中会包含浏览器的动作&＃xff08;action&＃xff09;这个动作通常为get或者post提现在url之中
2. url经过Django中的wsgi再经过django的中间件&＃xff0c;最后url到路由的映射表一条一条进行匹配一旦其中的某一条匹配成功就执行视图函数&＃xff0c;后面的路由就不在继续匹配了
3. 视图函数根据客户端的请求查询相应的数据&＃xff0c;返回给Django&＃xff0c;然后Django把客户端想要的数据作为一个字符串返回给客户端
4. 客户端浏览器接受到返回的数据&＃xff0c;经过渲染后显示给用户
1. url后尽量用名词&＃xff0c;因为rest frame是面向资源的编程&＃xff0c;因此url命名时能体现出资源
2. method的不同&＃xff0c;实现增删改查的操作
3. 版本号&＃xff0c;因为有版本的更替&＃xff0c;为了体现出版本的过度&＃xff0c;因此在发请求的时候&＃xff0c;要体现出版本号
4. 返回值&＃xff0c;与以往只返回json不同,rest api规范要加上状态码。
5. 域名&＃xff0c;由于前后端分离&＃xff0c;因此要处理跨域问题&＃xff0c;解决方法:jsonp,cors
6. 过滤&＃xff0c;通过url传参的形式传递搜索条件&＃xff08;列如&＃xff1a;指定返回的记录数量&＃xff0c;指定分页等&＃xff09;
- django&＃xff0c;大而全的框架&＃xff0c;它的内部组件比较多&＃xff0c;内部提供&＃xff1a;ORM、Admin、中间件、Form、ModelForm、Session、缓存、信号、CSRF&＃xff1b;功能也相当完善。- flask&＃xff0c;微型框架&＃xff0c;内部组件就比较少了&＃xff0c;但是有很多第三方组件来扩展它&＃xff0c;定制化程度高。 比如说有那个wtform&＃xff08;与django的modelform类似&＃xff0c;表单验证&＃xff09;、flask-sqlalchemy&＃xff08;操作数据库的&＃xff09;、flask-session、flask-migrate、flask-script、blinker可扩展强&＃xff0c;第三方组件丰富。所以对他本身来说有那种短小精悍的感觉
django和flask的共同点就是&＃xff0c;他们2个框架都没有写socket&＃xff0c;所以他们都是利用第三方模块wsgi。
但是内部使用的wsgi也是有些不同的&＃xff1a;django本身运行起来使用wsgiref&＃xff0c;而flask使用werkzeug wsgi还有一个区别就是他们的请求管理不太一样&＃xff1a;django是通过将请求封装成request对象&＃xff0c;再通过参数传递&＃xff0c;而flask是通过上下文管理机制。
是web服务网关接口&＃xff0c;是一套协议。
是通过以下模块实现了wsgi协议&＃xff1a;- wsgiref- werkzurg- uwsgi 关于部署
以上模块本质&＃xff1a;编写socket服务端&＃xff0c;用于监听请求&＃xff0c;当有请求到来&＃xff0c;则将请求数据进行封装&＃xff0c;然后交给web框架处理。
表单form&＃xff1a;
- 对用户请求的数据进行校验
- 生成HTML标签PS&＃xff1a;
- form对象是一个可迭代对象。
- 问题&＃xff1a;如何实现choice的数据实时更新&＃xff1f;&＃xff08;动态数据&＃xff0c;而不是写死&＃xff09;
- 解决&＃xff1a;给该字段定义成ModelChoiceField的时候利用好"queryset"参数class UserForm(Form):ut_id &＃61; ModelChoiceField(queryset&＃61;models.UserType.objects.all()) # 从另一张依赖表中提取数据依赖表&＃xff1a;class UserType(models.Model):title &＃61; models.CharField(max_length&＃61;32)
信号signal&＃xff1a;
django的信号其实就是django内部为开发者预留的一些自定制功能的钩子。
只要在某个信号中注册了函数&＃xff0c;那么django内部执行的过程中就会自动触发注册在信号中的函数。
如&＃xff1a;
场景:
在数据库某些表中添加数据时&＃xff0c;可以进行日志记录。
中间件middleware&＃xff1a;
对所有的【请求】进行【批量】处理&＃xff0c;说得直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作&＃xff0c;它本质上就是一个自定义类。其影响的是全局&＃xff0c;需谨慎使用。应用&＃xff1a;用户登录校验问题&＃xff1a;为甚么不使用装饰器&＃xff1f;如果不使用中间件&＃xff0c;就需要给每个视图函数添加装饰器&＃xff0c;太繁琐。
权限&＃xff1a;
用户登录后&＃xff0c;将权限放到session中&＃xff0c;然后再每次请求进来在中间件里&＃xff0c;根据当前的url去session中匹配&＃xff0c;判断当前用户是否有权限访问当前url&＃xff0c;有权限就继续访问&＃xff0c;没有就返回&＃xff0c;
检查的东西就可以放到中间件中进行统一处理&＃xff0c;在process_request方法里面做的&＃xff0c;
我们的中间件是放在session后面&＃xff0c;因为中间件需要到session里面取数据。
会话session&＃xff1a;
COOKIE与session区别
&＃xff08;a&＃xff09;COOKIE是保存在浏览器端的键值对&＃xff0c;而session是保存的服务器端的键值对&＃xff0c;但是依赖COOKIE。&＃xff08;也可以不依赖COOKIE&＃xff0c;可以放在url&＃xff0c;或请求头但是COOKIE比较方便&＃xff09;
&＃xff08;b&＃xff09;以登录为例&＃xff0c;COOKIE为通过登录成功后&＃xff0c;设置明文的键值对&＃xff0c;并将键值对发送客户端存&＃xff0c;明文信息可能存在泄漏&＃xff0c;不安全&＃xff1b; session则是生成随机字符串&＃xff0c;发给用户&＃xff0c;并写到浏览器的COOKIE中&＃xff0c;同时服务器自己也会保存一份。
&＃xff08;c&＃xff09;在登录验证时&＃xff0c;COOKIE&＃xff1a;根据浏览器发送请求时附带的COOKIE的键值对进行判断&＃xff0c;如果存在&＃xff0c;则验证通过&＃xff1b; session&＃xff1a;在请求用户的COOKIE中获取随机字符串&＃xff0c;根据随机字符串在session中获取其对应的值进行验证
跨域请求cors&＃xff08;场景&＃xff1a;前后端分离时&＃xff0c;本地测试开发时使用&＃xff09;&＃xff1a;
如果网站之间存在跨域&＃xff0c;域名不同&＃xff0c;端口不同会导致出现跨域&＃xff0c;但凡出现跨域&＃xff0c;浏览器就会出现同源策略的限制。
解决&＃xff1a;在我们的服务端给我们响应数据&＃xff0c;加上响应头 --> 在中间件加的。
缓存cache&＃xff1a;常用的数据放在缓存里面&＃xff0c;就不用走视图函数&＃xff0c;请求进来通过所有的process_request&＃xff0c;会到缓存里面查数据&＃xff0c;有就直接拿&＃xff0c;没有就走视图函数。
关键点&＃xff1a;1&＃xff1a;执行完所有的process_request才去缓存取数据2&＃xff1a;执行完所有的process_response才将数据放到缓存
关于缓存问题
1:为什么放在最后一个process_request才去缓存&＃xff1f;
因为需要验证完用户的请求&＃xff0c;才能返回数据2:什么时候将数据放到缓存中&＃xff1f;
第一次走中间件&＃xff0c;缓存没有数据&＃xff0c;会走视图函数&＃xff0c;取数据库里面取数据&＃xff0c;
当走完process_response,才将数据放到缓存里&＃xff0c;因为&＃xff0c;走process_response的时候可能给我们的响应加处理。3:为什么使用缓存&＃xff1f;将常用且不太频繁修改的数据放入缓存。以后用户再来访问&＃xff0c;先去缓存查看是否存在&＃xff0c;如果有就返回否则&＃xff0c;去数据库中获取并返回给用户&＃xff08;再加入到缓存&＃xff0c;以便下次访问&＃xff09;CSRF-TOKEN&＃xff1a;目标&＃xff1a;防止用户直接向服务端发起POST请求。对所有的post请求做验证&＃xff0c;将jango生成的一串字符串发送给后台&＃xff0c;一种是从请求体发过来&＃xff0c;一种是放在隐藏的标签里面。方案&＃xff1a;先发送GET请求时&＃xff0c;将token保存到&＃xff1a;COOKIE、Form表单中&＃xff08;隐藏的input标签&＃xff09;&＃xff0c;以后再发送请求时只要携带过来即可。
# 这些方法中的参数都是与视图函数参数对应的process_request(self, request) 主要方法。请求刚进来时&＃xff0c;执行视图函数之前调用。(无return)
process_view(self, request, callback, callback_args, callback_kwargs) URL路由匹配成功后&＃xff0c;执行视图函数之前调用&＃xff0c;拿到视图函数对象&＃xff0c;及其所有参数。(无return)
process_exception(self, request, exception) 执行视图函数中遇到异常时调用。(无return)
process_template_response(self, request, response) 很少用。执行了render()渲染方法后调用。(有return)
process_response(self, request, response) 主要方法。执行视图函数结束之后有响应时调用。(有return)
F&＃xff1a;主要用来对字段的值进行四则计算。Goods.objects.update(price&＃61;F("price")&＃43;10) # 对于goods表中每件商品的价格都在原价格的基础上增加10元
Q&＃xff1a;用来进行复杂查询&＃xff0c;实现"与"、"或"、"非"查询。Q(条件1) | Q(条件2) # 或Q(条件1) & Q(条件2) # 且~ Q(条件) # 非
Restful其实就是一套编写接口的&＃39;风格规范&＃39;&＃xff0c;规定如何编写以及如何设置返回值、状态码等信息。
最显著的特点&＃xff1a;
# 用Restful: 给用户一个url&＃xff0c;再根据不同的method在后端做不同的处理比如&＃xff1a;post创建数据、get获取数据、put和patch修改数据、delete删除数据。
# 不用Restful: 给调用者很多url&＃xff0c;每个url代表一个功能&＃xff0c;比如&＃xff1a;add_user/delte_user/edit_user/
# 当然&＃xff0c;还有其他的&＃xff0c;比如&＃xff1a;&＃39;版本&＃39; 来控制让程序有多个版本共存的情况&＃xff0c;版本可以放在 url、请求头&＃xff08;accept/自定义&＃xff09;、GET参数&＃39;状态码&＃39; 200/300/400/500&＃39;url中尽量使用名词&＃39; restful也可以称为“面向资源编程”&＃39;api标示&＃39;api.luffycity.comwww.luffycity.com/api/
# 在编写接口时可以不使用django rest framework框。
# 不使用&＃xff1a;也可以做&＃xff0c;可以用django的CBV来实现&＃xff0c;开发者编写的代码会更多一些。
# 使用&＃xff1a;内部帮助我们提供了很多方便的组件&＃xff0c;我们通过配置就可以完成相应操作&＃xff0c;如&＃xff1a;&＃39;序列化&＃39;可以做用户请求数据校验&＃43;queryset对象的序列化称为json&＃39;解析器&＃39;获取用户请求数据request.data&＃xff0c;会自动根据content-type请求头的不能对数据进行解析&＃39;分页&＃39;将从数据库获取到的数据在页面进行分页显示#还有其他组件&＃xff1a;&＃39;认证&＃39;、&＃39;权限&＃39;、&＃39;访问频率控制&＃39;
# a、简单来说&＃xff0c;falsk上下文管理可以分为三个阶段&＃xff1a;1、&＃39;请求进来时&＃39;&＃xff1a;将请求相关的数据放入上下问管理中2、&＃39;在视图函数中&＃39;&＃xff1a;要去上下文管理中取值3、&＃39;请求响应&＃39;&＃xff1a;要将上下文管理中的数据清除
# b、详细点来说&＃xff1a;1、&＃39;请求刚进来&＃39;&＃xff1a;将request&＃xff0c;session封装在RequestContext类中app&＃xff0c;g封装在AppContext类中并通过LocalStack将requestcontext和appcontext放入Local类中2、&＃39;视图函数中&＃39;&＃xff1a;通过localproxy--->偏函数--->localstack--->local取值3、&＃39;请求响应时&＃39;&＃xff1a;先执行save.session()再各自执行pop(),将local中的数据清除
# g是贯穿于一次请求的全局变量&＃xff0c;当请求进来将g和current_app封装为一个APPContext类&＃xff1b;
# 再通过LocalStack将Appcontext放入Local中&＃xff0c;取值时通过偏函数在LocalStack、local中取值&＃xff1b;
# 响应时将local中的g数据删除&＃xff1b;
# ORM的实现基于一下三点
映射类&＃xff1a;描述数据库表结构&＃xff0c;
映射文件&＃xff1a;指定数据库表和映射类之间的关系
数据库配置文件&＃xff1a;指定与数据库连接时需要的连接信息(数据库、登录用户名、密码or连接字符串)
细点来说&＃xff1a;
1、‘请求刚进来’&＃xff1a;
将request&＃xff0c;session封装在RequestContext类中
app&＃xff0c;g封装在AppContext类中
并通过LocalStack将requestcontext和appcontext放入Local类中
2、‘视图函数中’&＃xff1a;
通过localproxy—>偏函数—>localstack—>local取值
3、‘请求响应时’&＃xff1a;
先执行save.session()再各自执行pop(),将local中的数据清除
### 13.Flask中的g的作用&＃xff1f;
### 14.ORM的实现原理&＃xff1f;
映射类&＃xff1a;描述数据库表结构&＃xff0c;
映射文件&＃xff1a;指定数据库表和映射类之间的关系
数据库配置文件&＃xff1a;指定与数据库连接时需要的连接信息(数据库、登录用户名、密码or连接字符串)
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有