装饰器
生成器
迭代器
map filter reduce
内置函数 各类模块 log time random
网络编程7层模型
并发编程 yield生成器实现协程 IO多路复用
mysql数据库 两个引擎
lnooDB
MyIsam
Memory
Mrg_Myisam
Blackhole
mongodb使用b-tree来创建索引快速查询
中间件(权限)
restfrellwork
wsgi源码
算法,一行代码快排
Celery就是一个用python写的并行分布式框架,消息队列
------------------------------------------------------------
x = float('nan')
print(x != x) # 结果为True 这个是无穷大,本身和本身也不相等
python 是解释形语言,将py文件编译成pycodeobject持久化到.pyc文件中,而后解释器对字节码逐行解释
x or y <==> y if x == 0 else x
x and y <==> x if x == 0 else y
str: strip() split() replace() count() index()
list:append() extend() insert() pop() remove() clear()
dict:pop(key) popitem() update() get() fromkeys() keys() values() items()
---------------------------------------------------------
带参数的装饰器
def counter(num):
def wrapper(func):
def inner(*args,**kwargs):
for i in range(num):
ret = func(*args,**kwargs)
return ret # 只返回最后一次的结果
return inner
return wrapper
@counter(3)
def func():
print(111)
---------------------------------------------------------------
单下划线开头的成员变量是保护变量,只能在当前py文件中使用,只有类对象和子类对象能够访问(外界须要经过类内提供的接口访问)
双下划线开头的成员变量是类的私有成员,只有类对象能够访问,子类对象也不能访问这个数据
单例模式
1,模块导入 2,使用类 3,使用装饰器
import threading
class A(object):
__instance = None
__lock = threading.RLock()
def __new__(cls,*args,**kwargs):
if cls.__instance:
return cls.__instance
with cls.__lock:
if not cls.__instance :
cls.__instance = object.__new__(cls)
return cls.__instance
def singleton(cls, *args, **kwargs):
instance = {}
def _instance():
if cls not in instance:
instance[cls] = cls(*args, *kwargs)
return instance[cls]
return _instance
@singleton
class A:
pass
----------------------------------------------------------------
py2 py3的区别
1,py2的默认编码是ascii py3的默认编码是utf-8
2,py2的字符串是unicode 字节是str py3的字符串是str 字节是bytes(因此在py2中的文件读写,socket传输,md5加密直接用str就好了)
3,py2中的类能够有经典类和新式类 py3中都是新式类,默认继承object
4,py3中新增了yield from 能够逐一取出可迭代对象中的元素
5,py2中有 range xrange py3中只有range实际就是Python2中的xrange
---------------------------------------------------------------
内置模块:
os sys random json time datatime re hashlib logging
第三方模块:
requests bs4 gevent pymsql pymongo
------------------------------------------------------------
面向对象双下划线方法:
__call__
__new__ 建立类的实例化对象
__dict__ 类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的,对象的__dict__中存储了一些self.xxx的一些东西
__getattr__ 当调用不存在的属性时调用此方法来尝试得到属性(这里和反射无关,反射是getattr()函数)
__setattr__ 动态给对象添加属性和值 def __setattr__(self, key, value): self.__dict__[key] = value
__delattr__
__getitem__ obj["name"]就会触发__getitem__,并将"name"传入此方法中,以字典的形式操做属性(代替对象点的形式)
__setitem__
__delitem__
__iter__ 可迭代对象内部含有这个方法
__next__ 迭代器内部含有这个方法
__enter__ with上下文管理用的就是文件句柄中的__enter__(进入时的操做)和__exit__(退出或抛出异常时的操做)
__exit__
__init__ 初始化对象
__str__
__repr__
__del__
总的来讲,__setattr__是以点的形式给对象添加属性,__setitem__是以字典的形式给对象添加属性
class Student:
def __getattr__(self, item):
return item + ' is not exits'
def __setattr__(self, key, value):
self.__dict__[key] = value
def __getitem__(self, item):
return self.__dict__[item]
def __setitem__(self, key, value):
self.__dict__[key] = value
s = Student()
print(s.name) # 调用__getattr__方法 输出'name is not exits'
s.age = 1 # 调用__setattr__ 方法
print(s.age) # 输出 1
print(s['age']) # 调用 __getitem__方法 输出1
s['name'] = 'tom' # 调用 __setitem__ 方法
print(s['name'])
----------------------------------
TCP:安全可高,面向链接,面向数据流
UDP:不安全,不可靠,块,面向数据包 (qq的语音和视频是udp)
OSI七层模型
https://images2015.cnblogs.com/blog/1099668/201702/1099668-20170212153338135-125492424.jpg
7应用层:各类应用程序协议,如HTTP、FTP、SMTP、POP3 HTTP
6表示层:信息的语法语义以及他们的关联，如加密解密、转换翻译、压缩解压缩 LPP协议 NBSSN NetBLOS会话服务协议
5会话层：不一样机器上的用户之间创建及管理会话 SSL安全套接字层协议 TLS传输层安全协议
以上也可统称为应用层 py文件
4传输层：接受上一层的数据，必要时把数据进行分割，并将这些数据交给网络层，且保证这些数据段有效到达对端 tcp/udp协议
3网络层：控制子网的运行，如逻辑编址、分组传输、路由选择 ip协议
2数据链路层：物理寻址，同时将原始比特流转变为逻辑传输线路 arp协议,网卡
1物理层：机械、电子、定时接口通讯信道上的原始比特流传输 网线,集线器,光纤
三次握手,
1,客户端发起链接的请求(syn j)
2,服务器接收到请求后,回复给客户端两个标识,一个syn k表示接收到请求,一个ack j+1表示服务器在作准备工做,两个标识一块儿回复给客户端
3,客户端接收到服务器的回复,客户端准备链接的全部资源,开始进行链接,发送给服务器一个ack k+1表示客户端的链接准备工做已经完成了
服务器的accept(),客户端的connect体现了三次握手
客户端向服务器发送一个SYN J
服务器向客户端响应一个SYN K，并对SYN J进行确认ACK J+1
客户端再想服务器发一个确认ACK K+1
四次挥手
1,首先由任意一方发起断开链接的请求fin m,发起方的请求表示我没有数据要继续发送了,能够断开链接了,可是若是你还有数据能够继续向我发送
2,接收方回复给发起方ack m+1表示接收到了断开链接的请求,开始着手准备端口事宜
3,接收方准备完成后,给发起方发送一个标识fin n,表示接收方没有数据继续发送了,能够断开链接了
4,发起方收到消息后,准备断开链接,回收资源,发送给服务器一个ack n+1确认
服务器的conn.close() 客户端的sk.close()体现了四次挥手
1.某个应用进程首先调用close主动关闭链接，这时TCP发送一个FIN M；
2.另外一端接收到FIN M以后，执行被动关闭，对这个FIN进行确认。它的接收也做为文件结束符传递给应用进程，由于FIN的接收意味着应用进程在相应的链接上再也接收不到额外数据；
3.一段时间以后，接收到文件结束符的应用进程调用close关闭它的socket。这致使它的TCP也发送一个FIN N；
4.接收到这个FIN的源发送端TCP对它进行确认
黏包:tcp传输的时候是有缓冲区的,当发送的快获取的慢时,没法区分包,就形成了黏包(接收时不知道要接收字节的长度)
解决:能够规定一个协议 头+体 头使用struct模块将体的字节长度变为固定4个字节的数,
import socket
s = socket.socket()
s.bind(('127.0.0.1',9090))
s.listen()
sock,addr = s.accept()
sock.recv(1024)
sock.send(b'welcome')
sock.close()
s.close()
s = socket.socket()
s.connect(('127.0.0.1',9090))
s.send(b"hello")
s.recv(1024)
s.close()
--------------------------------------------------------------------------
进程是最小的资源分配单位
线程是cpu最小的调度单位
协程是有程序员人为创造出来的,也是微线程 yield greenlet gevent
GIL锁,保证同一时刻同一进程中只有一个线程能够被cpu调度,(多线程的实现时时间片轮转的结果)
进程间通讯 1,队列 from mutiprocessing import Queue 2,管道 pipe (队列 = 管道+锁,信号量=锁+计数器) 3,第三方 文件操做,redis等数据库
py2:
进程池: from mutiprocessing import Pool
py3:
进程池: from concurrent.futures import ThreadPoolExecutor
线程池: from concurrent.futures import ProcessPoolExecutor
IO多路复用:
操做系统提供的监听网络IO操做的机制
并发接收IO请求时,IO多路复用能够节省cpu利用率和操做系统的调用
select(将要监听的IO操做句柄放在select对象的参数中) poll epoll(回调函数)
----------------------------------------
websocket : 能够主动推送消息
magic string
base64 sha1
126 125 127 解密 位运算
------------------------------------------------------------------------
实例化的类能够作字典的key吗? 不能够对象的封装了属性和方法的内存空间,至关于容器,是可变的,若是要作键的话可使用picket序列化成字符串
python一切皆对象,--一切皆文件
计算机三大抽象
进程是对cpu的抽象,地址空间是对内存的抽象,文件是对磁盘的抽象
Python的内存管理机制:引入计数,垃圾回收,内存池机制
引用计数:每一个对象都有指向该对象的引用总数,使用getrefcount命令查看变量的引用数
垃圾回收:引用计数(引用找对象)\标记清除机制(对象找引用,解决循环引用的问题)\分代回收
内存池:python又分为大内存和小内存。大小以256字节为界限，对于大内存使用Malloc进行分配，而对于小内存则使用内存池进行分配
-------------------------------------------------------------------------
事务:把多个操做打包成一个原子操做;原子性,隔离性,持久性,一致性
mysql数据库引擎
innoDB:支持事务,支持外键,并发处理比较好,支持行锁(开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的几率最低，并发度也最高)
MyISAM:插入数据块,空间和内存使用比较低,只支持表锁(开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的几率最高，并发度最低)
MEMORy:全部的数据都在内存中,数据的读写速度快,对表的大小有要求,不能建太大的表
begin:
...for update;
数据库优化:
int long char datatime都是固定长度
varchar是可变长度,固定长度往前放
索引:
做用:加速查找 约束
种类:
主键索引 不能为空 不能重复
惟一索引 不能重复(只有一个能够为空)
普通索引 没有约束功能,只能够加速查询
联合索引 : 加速
联合惟一索引 :联合加速
注意:使用联合索引时,必须遵循最左前缀
覆盖索引:把字段设为索引后,字段就会在索引的数据结构中保存一份数据,当值查询索引数据时就不回去数据库查了,只在索引的数据结构中查如 name是索引 select name from users where name='alex'
索引合并:使用多个单列索引进行查询
数据库查询:
横向查询能够用
where > = in 用于列表 course_id in (1,2,4) like '张%' “_”匹配任何单个字符，而“%”匹配任意数目字符 ,也可使用正则匹配 RLIKE或NOT RLIKE
分组 group by having
去重 distinct
and or 在筛选条件中使用 且 或
聚合函数
avg(if(isnull(num), 0 ,num)) if判断语句若是num为空结果是0不然结果是num
sum()
count(1)
group_concat(distinct name) GROUP_CONCAT(course_id ORDER BY course_id ASC) #能够在这里面去重,也能够在这里面排序
not FIND_IN_SET('李平老师',GROUP_CONCAT(DISTINCT tname)) # find_in_set在集合中查找,这个条件是李平老师不在集合中,去掉not就是在集合中
纵向插叙使用 order by ASC/DESC limit 限制查询出的个数(如查询学生成绩的前3名)
有时候须要将纵向表转成横向表就先分别查询出两个纵向表而后连表查询变成横向表
连表查询 通常使用left join .. on
删除操做
delete from score where course_id in
( select cid from course left join teacher on course.teacher_id = teacher.tid where teacher.tname = '李平老师' )
修改操做
updata table set name ='alex' where ...
插入操做
INSERT into score(student_id,course_id,num)
SELECT student_id,2,AVG(num) from score
where student_id not in
(select student_id from score where course_id = 2)
GROUP BY student_id
纵表变横表
select A.student_id as 学号,生物,物理,体育,美术,平均分 from
(select student_id,num as 生物 from score
inner JOIN
course on score.course_id = course.cid where cname = '生物') as A
inner JOIN
(select student_id,num as 物理 from score
inner JOIN
course on score.course_id = course.cid where cname = '物理') as B
inner join
(select student_id,num as 体育 from score
inner JOIN
course on score.course_id = course.cid where cname = '体育') as C
inner join
(select student_id,num as 美术 from score
inner JOIN
course on score.course_id = course.cid where cname = '美术') as D
inner join
(select student_id,AVG(num) as 平均分 from score GROUP BY student_id) as E
on A.student_id = B.student_id and A.student_id = C.student_id and A.student_id = D.student_id and A.student_id = E.student_id ORDER BY 平均分 ASC
聚合筛选
select course_id,GROUP_CONCAT(student_id ORDER BY student_id) as st from score GROUP BY course_id
HAVING st=
(select GROUP_CONCAT( DISTINCT student_id ORDER BY student_id) from score )
Limit子句能够被用于强制 SELECT 语句返回指定的记录数。Limit接受一个或两个数字参数。
参数必须是一个整数常量。若是给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。
//初始记录行的偏移量是 0(而不是 1)：
mysql> SELECT * FROM table LIMIT 5,10; //检索记录行6-15
//为了检索从某一个偏移量到记录集的结束全部的记录行，能够指定第二个参数为 -1：
mysql> SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last
//若是只给定一个参数，它表示返回最大的记录行数目。换句话说，LIMIT n 等价于 LIMIT 0,n：
mysql> SELECT * FROM table LIMIT 5; //检索前 5 个记录行
----------------------------------------------------------------------------
一行代码实现快排
def quicksortshort(arr):
return [] if arr==[] else quicksortshort([y for y in arr[1:] if y<arr[0]]) + [arr[0]]+ quicksortshort([y for y in arr[1:] if y>=arr[0]])
-------------------------------------------------
git经常使用命令
git add
git commit -m ''
git checkout
git reset
git status
git log
git branch
---------------------------------------------------
MVC架构
model view controller
MTV
model templete view
---------------------------------------------------
celery : block
rpc : 远程过程调用
channels : 投票
---------------------------------------------------
linux命令
推荐:https://blog.csdn.net/qq_34889607/article/details/78444943
cut 提取文件中指定的字段(列),默认以空格切分,也能够指定分隔符(-d),按字节切(-c)
find
tar
ps -ef|grep
netstat -tunlp|grep
kill -9
head
wget
echo
du
------------------------------------
select * from company where title like '%abc%' or memcount >999 order by createtime desc
models.Company.objects.filter(Q(title__contains='abc')|Q(memcount__gt=999)).order_by(-createtime)
staff:sid sname sex
course:cid cname
sc_relation: student: sid cid
select cname from
(select * from staff left join
(select * from course right join student on course.cid = student.cid) as A
on staff.sid = student.sid ) as B
where B.sex = '男' and B.course='计算机'
select * from staff left join course left join student where staff.sid ==