複習計劃

裝飾器
生成器	
迭代器
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 ==