python

編程語言
用戶：
問題空間
計算機：解決問題
解空間
抽象
機器代碼->微碼編碼->高級語言

shell編程
控制語言：膠水語言
框架：web，Django
字節碼：bytecode

面向過程：
以指令爲中心，由指令處理數據
如何組織代碼解決問題
面向對象：
以數據爲中心，所有的處理代碼都圍繞數據展開
如何讓設計數據結構組織數據，並提供對此類數據所允許處理操作

簡單方法：
1.編譯安裝新版本至某特定路徑
2.pyenv

數據類型：轉換
隱式
顯式

字典：kv集合
{'a':31,'b':71}

Python過程式編程：

每個模塊都有一個人名爲name的內建變量，此變量值會根據調用此模塊的方式發生變化
如果此文件被作爲模塊導入，則name的值爲模塊名稱
如果此文件被直接執行，則name的值爲"main"

class:自定義類型
type:

instance:實例化

類：數據和方法
數據：變量
方法：函數

類：實例化成對象
CA:
IA:
IB:

兩個對象比較：
1。值比較：對象中的數據是否相同
2.身份比較：兩個變量名引用的是否爲同一對象

核心數據類型：
數字：int,long,float,complex,bool
字符：str,unicode
列表：list
字典：dict
元組:tuple
文件：file
其他類型:集合(set)，frozenset,類類型，None

其他文件類工具:pipes,fifos,sockets

類型轉換：
str(),repr()或format(): 將非字符型數據轉換爲字符：
int():轉爲整數
float():

list(s)將字符串 s轉爲列表
tuple(s)：將字符串s轉爲元組
set(s):將字符串s轉爲集合
frozenset(s):將字符串s轉換爲不可變集合
dict(d):創建字典:其d必須是（key，value）的元組序列

chr(x):將整數轉爲字符
ord(x):將字符轉換爲整數值
hex(x):將整數轉換爲16進制字符
bin(x):
oct(x):

數字類型：

Python的數字字面量:布爾型，整數，浮點數，複數
True:1
False:0

序列類型：
字符類型:
字符串字面量：把文本放入單引號，雙引號或三引號中；
''',"""

如果要使用unicode編碼，則在字符串之前使用字符u進行標識，如u"magedu"
文檔字串：模塊，類或函數的第一條語句是一個字符的話，該字符串就成爲文檔字符串,可以使用doc屬性引用

運算符：
索引運算：[i]
切片運算：[i:j]
擴展切片:[i:j:stride]

支持運算：
索引，切片，main()，max()，len()等
支持操作：
對象的自由的方法

列表：
容器類型
任意對象的有序集合，通過索引訪問其中的元素，可變對象，異構，任意嵌套

支持在原處修改
修改指定的索引元素，修改指定的分片，刪除語句，內置方法

l1+l2:合併兩個列表，返回一個新的裂變，不會修改原列表
l1 * N:把l1重複N次，返回一個新列表；

 in:成員關係判斷字符,用法objin container
 not in:obj not in container

列表解析：[ ]
列表複製方式：
l1=[1,2,3,4]
l2=l1

   import copy
     l2=copy.deepcopy(l1)

        l2=l1[:]

元組：
表達式符號:()

容器類型
任意對象的有序集合，通過索引訪問其中的元素，不可變對象，長度固定，異構，嵌套
常見操作：
()
(1,)
(1,2,)

 t1+t2
 t1*N

  in:
  not in:

雖然元組本身不可變，但如果元組內嵌套了可變類型的元素，那麼此類元素的修改不會返回新元組

字典：dict
字典在其他編程語言中又稱作關聯數組或散列表；
通過鍵實現元素存取，無序集合；可變類型容器，長度可變，異構，嵌套；

{key1:value1,key2:value2,...}
{}:空字典
{'x':32,'y':[1,2,3]}

字典複製:d2 d1.copy()
d1.iteritems:返回一個迭代器對象

回顧：
python:動態語言，強類型
內置類型，自定義類型(class)
整數，布爾
浮點

    序列
        字符集，列表，元組
    字典：
       集合：set，frozenset

    可變對象：列表，字典，set
    不可變對象：數值，字串，元組，frozenset

對象的三部分：身份，類型，值
對象的比較：
身份比較：用於確定是否同一個對像
id()
類型比較：用於確定是否同屬於一個類型
type()
值比較：值是否相同
直接等值比較

數值，字串，列表，元組，字典

類：數據+方法
實例：

3+5
3.add(5)

列表和字典：

變量名
對象

點號運算符：
屬性：數據
返回一個數據，顯示則要使用print語句
方法：操作（）
調用：執行一段代碼

可調用對象：callable()

字串：'',"",''' ''',""" """，
列表：[ ]
元組：（）
字典：{}
數值：

如何獲取使用幫助：
獲取對象支持使用的屬性和方法:dir()
某方法的具體使用幫助:help(list.pop)
獲取可調用對象的文檔字串：print objdoc

集合：無序排列，可哈希；
支持集合關係測試：
成員關係測試：
in
not in
迭代
不支持：索引，元素獲取，切片

集合的類型：set(),frozenset()
沒有特定語法格式，只能通過工廠函數創建

容器，類型，對象
1.列表，字典可以不使用換行符
2.所有對象都有引用計數
3.列表和字典都支持兩種類型的複製操作，淺複製和深複製；深複製可使用copy模塊中的deepcopy()實現
4.python中的所有對象都是“第一類的”，這意味着使用標識符命名的所有對象都具有相同狀態，於是，能夠命名所有對象都可以直接當數據進行處理
5.所有序列都支持迭代；
6.所有序列都支持的操作和方法：
s[i]
s[i:j]
s[i:j:stride]
len(s)
min(s)
max(s)
sum(s)
all(s)
any(s)
s1+s2:連接
s1*N:重複
obj in s1:成員關係判斷
obj not in s1:
7.可變序列的操作：
s1[index]=value:元素賦值
s1[i:j]=t:切片賦值
del s1[index]
del s1[i:j]
del s1[i:j:stride]

Pyhon的表達式和語句：

表達式：
語句：

Python中的常用的表達式操作符；
x * y,x/y,x+y,x-y,x//y,x%y

邏輯運算：
x or y,x and y,not x
成員關係運算：
x in y,x not in y
對象實例測試：
x is y,x not is y
比較運算：
x <y,x>y,x<y,x>y,x y,x ! y
位運算：
x | y,x & y,x ^y,x <<y,x>>y

一元運算:
-x,+x,~x:
冪運算：
x ** y

索引和分片：
x[i],x[i:j],x[i:j:stride]

調用:
x(...)

取屬性：
x.attribute

元組：(...)
序列：[...]
字典：{...}

三元選擇表達式：x if y else z

匿名函數：lambda args:expression

生成器函數發送協議：yield x

運算優先級：
(...),[...],{...}
s[i],s[i:j]
s.attribute
s(...)
+x,-x,~x
x * y
,/,//,%
+,-
<<,>>
&
^
|
<.<=,>,>=,==,!=
is,not is
in,not in
not
and
or
lambda

語句：
賦值語句
調用
print:打印對象
if/elif/else:條件判斷
for/else:序列迭代
while/else:普通循環
pass:佔位符
break:
continue
def
return
yield
global:命名空間
raise:觸發異常
import:
from:模塊屬性訪問
class:類
try/except/finally:捕捉異常
del:刪除引用
assert:調試檢查
with/as:環境管理器

賦值語句：
隱式賦值：import,from,def,class,for,函數參數

元組和列表分解賦值：當賦值符號(=)的左側爲元組或列表時，python會按照位置把右邊的對象和左邊的目標自左而右逐一進行配對兒，個數不同時會觸發異常，此時可以切片的方式進行；

多重目標賦值

增強賦值語句：+,-,*,/,//,%,

條件測試：
if 條件測試表達式

Python中的真假
1.任何非0數字和非空對象都爲真
2.數字0，空對象和特殊對像None均爲假
3.比較和像等測試會遞歸地應用於數據結構中
4.返回值爲Ture或False

組合條件測試：
X and Y:與運算
X or Y:或運算
not X:非運算

A=X if Y else Z:
if Y:
A=X
else
A=Z
expression1 if boolean_expression else expression2

while:

while bool_expression:
while_suite
else:
else_suite
break:跳出最內層的循環
continue:跳到所處的最近層循環的開始處
pass:佔位語句
else代碼塊：循化正常終止纔會執行，如果循環終止是由break跳出導致的，則else不會執行

練習1：逐一顯示指定列表中的所有元素
count=0
while count<len(l1):
print(l1[count])
count +=1

while l1:
print(l1[0])
l1.pop(0)

while l1:
print(l1[-1])
l1.pop()

練習2：求100以內所有偶數之和

練習3：逐一顯示指定字典的所有鍵；並於顯示結束後說明總鍵數
d1={'x':1,'y':23,'z':78}
keylist=d1.keys()
while keylist:
print(keylist[0])
l1.pop()
else:
print(len(d1))

練習4：創建一個包含了100了以內所有奇數的列表；
l1=[]
x=1
while x<100:
l1.append(x)
x+2

練習5：逆序逐一顯示一個列表的所有元素
練習6：列表l1=[0,1,2,3,4,5,6],列表l2=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],以第一個列表中的元素爲鍵，以第二個列表中的元素爲值的生成字典d1
d1={}
count=0
if len(l1)==len(l2):
while count<len(l1):
d1[l1[count]]=l2[count]
count+=1

while True:

for 循環練習：
練習1：逐一分開顯示指定字典d1中的所有元素，類似如下
k1 v1
k2 v2
....
for (k,v) in d1.items():
print(k,v)

練習2：逐一顯示列表中l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat']中的索引爲奇數的元素
for i in range(1,len(l1),2):
print(l1[i])

練習3：將屬於列表l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],但不屬於列表l2=['Sun','Mon','Tue','Thu','Sat']的所有元素定義爲一個新列表l3
l3=[]
for i in l1:
if l1[i] not in l2:
l3.append(i)

練習4：已知列表namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7'],刪除列表removelist=['stu3','stu7','stu9'],請將屬於removelist列表中的每個元素從namelist中移除(屬於removelist,但不屬於namelist的忽略即可)
for i in removelist:
if i in namelist:
namelist.remove(i)

回顧：
1.動態語言
sys.getrefount()

 增加對象的引用計數場景
       對象創建時：
       將對象添加進容器時：類似list.append()
      當對象被當作參數傳遞給函數時
      爲對象創建另外變量名

減少引用計數：
     引用此對象的某變量名被顯式銷燬：del x
    引用此對象的某變量名重新賦值
    從容器中移出對象時，類似list.pop()
   容器本身被銷燬

2.if
if boolean_expression:
.....
elif boolean_expression:
....
else
....
3.while
while boolean_expression:
while_suite
if boolean_expression2: continue
if boolean_expression3: break
else:
else_suite

4.for
for expression in object:
for_suite
if boolean_expression2: continue
if boolean_expression3: break
else:
else_suite

while True:
x=input('enter an entry： ')
test.append(x)
if x=='q' or x=='quit':
break

列表解析：根據已有列表，高效生成新列表的方式
['x','y','z'],[1,2,3]
[('x',1),('x',2)]

var_name=open(file_name[mode,[bufsize]])
mode:
r
w
a
r+
w+
b表示以二進制模式打開文件：
rb
wb
ab
b+
wb+
ab+

緩衝：
0：禁用
負數：使用系統默認緩衝
1：使用緩衝，只緩衝一行數據
2+:指定緩衝空間大小
file.seek(offset[whence])
whence:起點
0:從文件頭
1：從當前位置
2：從文件尾部

 offset:偏移量

文件系統功能：os

目錄：
chdir():表示改變工作目錄
chroot():設定當前進程的根目錄
listdir()：列出指定目錄下的所有文件名
mkdir():創建指定目錄
makedirs():創建多級目錄
getcwd()
rmdir()
removedirs():刪除多級目錄

文件：
mkfifo()
mknod()
remove()
unlink()
rename()：重命名
stat():返回文件狀態信息
symlink()
utime():更新時間戳
tmpfile():創建並打開（w+b）一個新的臨時文件

訪問權限：
access():
chmod():修改權限
chown():修改屬主，屬組
umask():設置默認權限模式

文件描述符：
open():
read():
write():

設備文件：
mkdev():
major():
minor():

os.path:跟文件路徑相關
basename():路徑基名
dirname():路徑目錄名
join():
split():返回dirname(),basename()元組
splitext():返回(filename,extension)元組

信息：
getatime()
getctime()
getmtime()
getsize():返回文件的大小

查詢：
exists():判斷指定文件是否存在
isabs():判斷指定的路徑是否爲絕對路徑
isdir():是否爲目錄
isfile():是否爲文件
islink():是否符號鏈接
ismount():是否爲掛載點
samefile():兩個路徑是否指向了同一個文件

練習：判斷文件是否存在，存在則打開
讓用戶通過鍵盤反覆輸入多行數據
追加保存至此文件中

對象持久存儲：
pickle
marshal

DBM接口：

shelve模塊

回顧：
文件對象
open('file','mode','bufsize')
read,readline,readlines,write,writelines,flush,seek,tell

模塊：os
文件系統接口
模塊：os.path

對象流式化:持久化
pickle

文件是可迭代：iter(),iter()

Python的正則表達式：
.
[...]
[^...]
?
+
{m}
{m,n}
{0,n}
{m,}
^
$
pat1|pat2
(...)
\b
[0-9] \d
[0-9a-zA-Z] \w,\W
\s:任意空白字符，[\n\t\f\v\r], \S
\nn
(*|+|?{})?:使用非貪婪模式

match對象：

re.search:返回一個match對象
match對象的：
屬性：
string
re
pos
endpos
方法：
group()
start()
end()

re.findall:返回列表
re.sub:返回替換後整個串
re.subn:返回元組，替換後的串及替換次數

re.compile:

思考：複製/etc/passwd到/tmp,如何替換/tmp/passwd中的/BIN/BASH?

flags:
I或IGNORECASE:忽略字符大小寫
M或MUTILINE：
A或ASCII:僅執行8位ASCII碼匹配
U或UNICODE:使用\w,\W

函數：
名稱

python閉包：

def funcName(arg1,arg2,...):

參數傳遞形式：
位置參數：從左向右
關鍵字參數：按關鍵名稱匹配

混用上面兩種方式時：所有位置參數，所有的關鍵字參數

定義函數使用默認參數：有默認值的參數
混用有默認和無默認值的參數時，無默認值放前面

調用函數時使用可變參數要求：
定義函數時使用*:收集位置參數
定義函數時使用**:收集關鍵字參數

練習：返回/etc/passwd中包含了/bin/bash字串的所有用戶名爲一個列表

回顧：
re
search,findall,finditer,sub,subn

function
()
def func_name(arg1,...):
func_suite

Python閉包：閉包叫lexical closure

函數中使用yield,,會返回一個生成器對象

裝飾器：
1.裝設計器本身是一個函數，用於裝飾其他函數；
2.功能：增強被裝飾函數的功能

裝飾器一般接受一個函數對象作爲參數,以對其進行增強

遞歸：
遞歸需要邊界條件，遞歸前進段和遞歸返回段；

協程：

函數的設計規範：
耦合性：
（1）通過參數接受輸入，以及通過return產生輸出以保證函數的獨立性
（2）儘量減少使用全局變量進行函數間通信
（3）不要在函數中修改可變類型的參數
（4）避免直接改變定義在另外一個模塊中的變量；
聚合性：
（1）每個函數都應該有一個單一的，統一的目標
（2）每個函數的功能都應該相對簡單

練習1：將/etc/passwd文件中的每一行都分隔爲一個列表
練習2：將任意文件被用戶指定的分隔符把每一行都分隔爲一個列表
練習3：用摺疊的方式（return）求階乘

類：將同一種具體物事的共同特性抽象出來的表現
狀態和轉換這些狀態的操作
數據：
變量：就屬性
方法：
函數：操作變量引用的數據的代碼

面向對象編程的3原則：
封裝，繼承和多態

class class_name

>> class thirdclass():
data='hello third'
def setdata(self,x):
self.str1=x
def printdata(self):
print(self.str1)

>> ins4=thirdclass()
>> ins4.setdata('abcd')<--->thirdclass.setdata(ins4,'abcd')
>> ins4.printdata()<-->thirdclass.printdata(print(ins4.str1))
abcd

varname():會被Python解釋器自動調用
a+b<-->a.add(b)
l1=['abcd','xyz']<-->list.init()

可調用對象：call()
函數
內置函數
自定義函數
def
lamdba
類
類方法

函數的屬性：
doc
name
dict
code
globals

方法的屬性：
doc
name
class:方法所屬的類
func:實現該方法的函數對象
self:調用此方法的實例

內置函數：
doc
name
self

類：
doc
name
bases
dict
module:定義了當前類的模塊名稱

實例：
class
dict

對象都有特殊方法：
init,new,del
dir()
add()
ge()

模塊：
頂層文件
模塊文件1
模塊文件2

setup.py中setup()中可用的參數：
platforms:平臺列表
license:許可證
py_modules:各模塊名稱組成的列表，此些模塊可能位於包的根目錄下，也可能位於某子包目錄下(subpkg1.modename):
packages:各子包名稱的列表

大體分爲兩類：元數據信息和包中的內容列表

python setup.py sdist
可以指定格式：
zip:zip file
gztar:tar.gz file
bztar:tar.bz2 file
ztar:tar.Z file
tar:tar file

python setup.py bdist

可以爲bdist指定的格式: --formats
gztar:tar.gz file
ztar:tar.Z file
tar:tar file
zip:zip file
pkgtool:Solaris pkgtoo1
wininst:Windows上自解壓的zip格式的包
msi:Microsoft Installer

bdist_dump:
bdist_rpm:
bdist_wininst
dbsit_msi

獲取幫助的方式：
python setup.py --help
python setup.py --help--commands:所有可以使用的命令，如build,install
python setup.py COMMAND --help:獲取將特定命令的幫助
python setup.py COMMAND --help-formats:獲取特定命令支持使用的格式

pip,easy_install

Python模塊，包，打包

安裝包：
python setup.py install

build and install:

python setup build:
--build-base /path/to/build_dir
lib,lib.platform
第三方模塊的默認安裝路徑通常爲：site-packages
/usr/local/python27/lib/python2.7/site-packages

自定義安裝路徑：
--user

--prefix
--exec-prefix

深度定製：
--install-purelib /path/to/python_lib
--install-platlib /path/to/plat_lib
--install-lib /path/to/lib

--install-scripts /path/to/bin
可執行文件的安裝路徑

--install-data
--install-headers

try:
try:
try_suite
except
except
else
finally

assert實現：手動觸發異常
assert condition,[expresson]
相當於下面的語句
if debug:
if not condition:
raise AssertionError,expression

Python異常對象：
BaseException:

raise觸發異常

assert斷言

try-except
try:
except
except()
except BaseException
else

try-finally
try-except-else-finally

try:
try-except-else
finally:

execute()
executemany()

import pymysql as mysql
建立連接:
conn=mysql.connect('host','user','password','db')
創建遊戲標：
cur=conn.cursor()
發送查詢：
sqlstatement='sql statement'
cur.execut(sqlstatement)
cur.executemany(sqlstatement)

獲取數據：
cur.execute('select statement')
cur.fetchone()
cur.fetchmany(N)
cur.fetchall()

fetchall():
result=cur.fetchall()
關閉：
cur.close()
conn.close()

練習：把/etc/passwd文件中的內容的每一行存儲在mariadb的表中；

socket.socket(family,type)

family:
AF_INET:
AF_UNIX:
type:
STREAM:tcp
SOCK_DGRAM:udp

tcponn=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

第二步：綁定地址
使用套接字對象的bind方法綁定於某地和端口
tcpconn.bind(('ip',port))
tcpconn.bind(('127.0.0.1',8023))

第三步：使用listen方法進行監聽狀態
tcpconn.listen(backlog)
tcpconn.listen(100)

第四步：循環監聽狀態
使用套接字對象的accecpt方法接收用戶請求

編寫客戶端程序：
第一步：創建一個socket對象，以連接服務器端
cliensock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
第二步：連接至服務器
clientsock.connect(('server_ip',server_port))
clientsock.connect(('127.0.0.1',8023))

第三步：發送請求：
clientsock.send()

服務器端：
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sa=('127.0.0.1',8023)
s.bind(sa)
s.listen(20)
while True:
cinfo,cpaddr=s.accept()
print('Got a connection from %s'%caddr[0])
data=cinfo.recv(1024)
print('Eeceive data：%s'%data)
cinfo.send("echo: "+data)
cinfo.close()

客戶端：
import socket
c=socket.socker(socket.AF_INET,socket.SOCK_STREAM)
saddr=('127.0.0.1',8023)
c.connect(saddr)
c.send('hello server')
data=c.recv(1024)
print("Reply from server %s"%data)

web框架：
Diango
Flask
Web2py
TuborGears
TuborGears