pythonblocked

① python多線程幾種方法實現

Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行

當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

② linux下,C插入Python,就在include <python.h>上卡住了

拿出一個例子來分析一下,不就是總結嗎?

#include <Python.h>

char* python_code1 = "\
import wx\n\
f = wx.Frame(None, -1, 'Hello from wxPython!', size=(250, 150))\n\
f.Show()\n\
";
PyRun_SimpleString(python_code1);

char* python_code2 = "\
import sys\n\
sys.path.append('.')\n\
import embedded_sample\n\
\n\
def makeWindow(parent):\n\
win = embedded_sample.MyPanel(parent)\n\
return win\n\
";
PyObject* globals = PyDict_New();
PyObject* builtins = PyImport_ImportMole("__builtin__");
PyDict_SetItemString(globals, "__builtins__", builtins);
Py_DECREF(builtins);

// Execute the code to make the makeWindow function
result = PyRun_String(python_code2, Py_file_input, globals, globals);
// Was there an exception?
if (! result) {
PyErr_Print();
wxPyEndBlockThreads(blocked);
return NULL;
}
Py_DECREF(result);

// Now there should be an object named 'makeWindow' in the dictionary that
// we can grab a pointer to:
PyObject* func = PyDict_GetItemString(globals, "makeWindow");

③ Python進程之並行與並發的區別

並行 :

當系統有一個以上CPU時，則進程的操作有可能非並發。當一個CPU執行一個進程時，另一個CPU可以執行另一個進程，兩個進程互不搶佔CPU資源，可以同時進行，這種方式我們稱之為並行。

並發 :

當有多個進程在操作時，如果系統只有一個CPU，則它根本不可能真正同時執行一個以上的進程，它只能把CPU運行時間劃分成若干個時間段，再將時間 段分配給各個進程執行，在一個時間段的進程代碼運行時，其它進程處於掛起狀，這種方式我們稱之為並發。

區別：

並發和並行是即相似又有區別的兩個概念，並行是指兩個或者多個事件在同一時刻同時執行，而並發是指兩個或多個事件通過時間片輪流被執行。在多道程序環境下，並發性是指在一段時間內宏觀上有多個程序在同時運行，但在單核CPU中，同一時刻僅能有一道程序執行，故微觀上這些程序只能是分時地交替執行。倘若在計算機中有多個CPU，則這些可以並發執行的程序便可被分配到多個處理機上，實現並行執行，即利用每個處理機來處理一個可並發執行的程序，這樣，多個程序便可以同時執行。

相關推薦：《Python視頻教程》

進程的狀態如下圖所示

在了解其他概念之前，我們首先要了解進程的幾個狀態。在程序運行的過程中，由於被操作系統的調度演算法控制，程序會進入幾個狀態：就緒，運行和阻塞。

（1）就緒(Ready)狀態

當進程已分配到除CPU以外的所有必要的資源，只要獲得處理機便可立即執行，這時的進程狀態稱為就緒狀態。

（2）執行/運行（Running）狀態當進程已獲得處理機，其程序正在處理機上執行，此時的進程狀態稱為執行狀態。

（3）阻塞(Blocked)狀態正在執行的進程，由於等待某個事件發生而無法執行時，便放棄處理機而處於阻塞狀態。引起進程阻塞的事件可有多種，例如，等待I/O完成、申請緩沖區不能滿足、等待信件(信號)等。

相關推薦：

一文帶你讀懂Python中的進程

④ python面向對象編程中的f.init（）什麼意思，為什麼要加這一個

f.init()加在中間是為了類Filter定義一個屬性blocked並初始化,因為它定義了類的屬性blocked,而類Filter的函數filter中要用到這個屬性,所以不加f.init()會報錯.

同樣的s.init(),SPAMFilter子類重寫了Filter父類的init函數,並且重新定義了屬性blocked,而子類SPAMFilter繼承的父類Filter的函數filter中用到了這個屬性,所以不加s.init()也會報錯.

完整的Python程序如下

class Filter:

def init(self):

self.blocked=[]

def filter(self,sequence):

return [x for x in sequence if x not in self.blocked]

class SPAMFilter(Filter):

def init(self):

self.blocked=['SPAM']

f=Filter()

f.init()

print(f.filter([1,2,3]))

s=SPAMFilter()

s.init()

print(s.filter(['SPAM','SPAM','SPAM','SPAM','eggs','bacon','SPAM']))

源代碼(注意源代碼的縮進)

⑤ python多線程的幾種方法

Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行

當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

⑥ python udp發送數據的問題

一個簡單的python socket編程

一、套接字

套接字是為特定網路協議（例如TCP/IP，ICMP/IP，UDP/IP等）套件對上的網路應用程序提供者提供當前可移植標準的對象。它們允許程序接受並進行連接，如發送和接受數據。為了建立通信通道，網路通信的每個端點擁有一個套接字對象極為重要。

套接字為BSD UNIX系統核心的一部分，而且他們也被許多其他類似UNIX的操作系統包括Linux所採納。許多非BSD UNIX系統（如ms-dos，windows，os/2，mac os及大部分主機環境）都以庫形式提供對套接字的支持。

三種最流行的套接字類型是:stream,datagram和raw。stream和datagram套接字可以直接與TCP協議進行介面，而raw套接字則介面到IP協議。但套接字並不限於TCP/IP。

二、套接字模塊

套接字模塊是一個非常簡單的基於對象的介面，它提供對低層BSD套接字樣式網路的訪問。使用該模塊可以實現客戶機和伺服器套接字。要在python 中建立具有TCP和流套接字的簡單伺服器，需要使用socket模塊。利用該模塊包含的函數和類定義，可生成通過網路通信的程序。一般來說，建立伺服器連接需要六個步驟。

第1步是創建socket對象。調用socket構造函數。

socket=socket.socket(familly,type)

family的值可以是AF_UNIX(Unix域，用於同一台機器上的進程間通訊)，也可以是AF_INET（對於IPV4協議的TCP和 UDP），至於type參數，SOCK_STREAM（流套接字）或者 SOCK_DGRAM（數據報文套接字）,SOCK_RAW（raw套接字）。

第2步則是將socket綁定（指派）到指定地址上，socket.bind(address)

address必須是一個雙元素元組,((host,port)),主機名或者ip地址+埠號。如果埠號正在被使用或者保留，或者主機名或ip地址錯誤，則引發socke.error異常。

第3步，綁定後，必須准備好套接字，以便接受連接請求。

socket.listen(backlog)

backlog指定了最多連接數，至少為1，接到連接請求後，這些請求必須排隊，如果隊列已滿，則拒絕請求。

第4步，伺服器套接字通過socket的accept方法等待客戶請求一個連接：

connection,address=socket.accept()

調用accept方法時，socket會進入'waiting'（或阻塞）狀態。客戶請求連接時，方法建立連接並返回伺服器。accept方法返回一個含有倆個元素的元組，形如(connection,address)。第一個元素（connection）是新的socket對象，伺服器通過它與客戶通信；第二個元素（address）是客戶的internet地址。

第5步是處理階段，伺服器和客戶通過send和recv方法通信（傳輸數據）。伺服器調用send，並採用字元串形式向客戶發送信息。send方法返回已發送的字元個數。伺服器使用recv方法從客戶接受信息。調用recv時，必須指定一個整數來控制本次調用所接受的最大數據量。recv方法在接受數據時會進入'blocket'狀態，最後返回一個字元串，用它來表示收到的數據。如果發送的量超過recv所允許，數據會被截斷。多餘的數據將緩沖於接受端。以後調用recv時，多餘的數據會從緩沖區刪除。

第6步，傳輸結束，伺服器調用socket的close方法以關閉連接。

建立一個簡單客戶連接則需要4個步驟。

第1步，創建一個socket以連接伺服器 socket=socket.socket(family,type)

第2步，使用socket的connect方法連接伺服器 socket.connect((host,port))

第3步，客戶和伺服器通過send和recv方法通信。

第4步，結束後，客戶通過調用socket的close方法來關閉連接。

python 編寫server的步驟：

第一步是創建socket對象。調用socket構造函數。如：

socket = socket.socket( family, type )

family參數代表地址家族，可為AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用於同一台機器上的進程間通信。
type參數代表套接字類型，可為SOCK_STREAM(流套接字)和SOCK_DGRAM(數據報套接字)。

第二步是將socket綁定到指定地址。這是通過socket對象的bind方法來實現的：

socket.bind( address )

由AF_INET所創建的套接字，address地址必須是一個雙元素元組，格式是(host,port)。host代表主機，port代表埠號。如果埠號正在使用、主機名不正確或埠已被保留，bind方法將引發socket.error異常。

第三步是使用socket套接字的listen方法接收連接請求。

socket.listen( backlog )

backlog指定最多允許多少個客戶連接到伺服器。它的值至少為1。收到連接請求後，這些請求需要排隊，如果隊列滿，就拒絕請求。

第四步是伺服器套接字通過socket的accept方法等待客戶請求一個連接。

connection, address = socket.accept()

調用accept方法時，socket會時入「waiting」狀態。客戶請求連接時，方法建立連接並返回伺服器。accept方法返回一個含有兩個元素的元組(connection,address)。第一個元素connection是新的socket對象，伺服器必須通過它與客戶通信；第二個元素 address是客戶的Internet地址。
第五步是處理階段，伺服器和客戶端通過send和recv方法通信(傳輸數據)。伺服器調用send，並採用字元串形式向客戶發送信息。send方法返回已發送的字元個數。伺服器使用recv方法從客戶接收信息。調用recv 時，伺服器必須指定一個整數，它對應於可通過本次方法調用來接收的最大數據量。recv方法在接收數據時會進入「blocked」狀態，最後返回一個字元串，用它表示收到的數據。如果發送的數據量超過了recv所允許的，數據會被截短。多餘的數據將緩沖於接收端。以後調用recv時，多餘的數據會從緩沖區刪除(以及自上次調用recv以來，客戶可能發送的其它任何數據)。
傳輸結束，伺服器調用socket的close方法關閉連接。
python編寫client的步驟：
創建一個socket以連接伺服器：socket = socket.socket( family, type )

使用socket的connect方法連接伺服器。對於AF_INET家族,連接格式如下：

socket.connect( (host,port) )

host代表伺服器主機名或IP，port代表伺服器進程所綁定的埠號。如連接成功，客戶就可通過套接字與伺服器通信，如果連接失敗，會引發socket.error異常。
處理階段，客戶和伺服器將通過send方法和recv方法通信。
傳輸結束，客戶通過調用socket的close方法關閉連接。
下面給個簡單的例子：

server.py
python 代碼

if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8001))
sock.listen(5)
while True:
connection,address = sock.accept()
try:
connection.settimeout(5)
buf = connection.recv(1024)
if buf == '1':
connection.send('welcome to server!')
else:
connection.send('please go out!')
except socket.timeout:
print 'time out'
connection.close()

client.py
python 代碼

if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8001))
import time
time.sleep(2)
sock.send('1')
print sock.recv(1024)
sock.close()

在終端運行server.py，然後運行clien.py，會在終端列印「welcome to server!"。如果更改client.py的sock.send('1')為其它值在終端會列印」please go out!「，更改time.sleep(2)為大於5的數值， 伺服器將會超時。

舉例：

服務端:

#socket server端
#獲取socket構造及常量
from socket import *
#''代表伺服器為localhost
myHost = ''
#在一個非保留埠號上進行監聽
myPort = 50007

#設置一個TCP socket對象
sockobj = socket(AF_INET, SOCK_STREAM)
#綁定它至埠號
sockobj.bind((myHost, myPort))
#監聽，允許5個連結
sockobj.listen(5)

#直到進程結束時才結束循環
while True:
#等待下一個客戶端連結
connection, address = sockobj.accept( )
#連結是一個新的socket
print 'Server connected by', address
while True:
#讀取客戶端套接字的下一行
data = connection.recv(1024)
#如果沒有數量的話，那麼跳出循環
if not data: break
#發送一個回復至客戶端
connection.send('Echo=>' + data)
#當socket關閉時eof
connection.close( )

客戶端:

import sys
from socket import *
serverHost = 'localhost'
serverPort = 50007

#發送至服務端的默認文本
message = ['Hello network world']
#如果參數大於1的話，連結的服務端為第一個參數
if len(sys.argv) > 1:
serverHost = sys.argv[1]
#如果參數大於2的話，連結的文字為第二個參數
if len(sys.argv) > 2:
message = sys.argv[2:]

#建立一個tcp/ip套接字對象
sockobj = socket(AF_INET, SOCK_STREAM)
#連結至伺服器及埠
sockobj.connect((serverHost, serverPort))

for line in message:
#經過套按字發送line至服務端
sockobj.send(line)
#從服務端接收到的數據，上限為1k
data = sockobj.recv(1024)
#確認他是引用的，是'x'
print 'Client received:', repr(data)

#關閉套接字
sockobj.close( )

⑦ python多線程怎樣同步

鎖機制
�6�9�6�9threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖

import threading
import time

class Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock()
def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)

for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
�6�9�6�9當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
�6�9�6�9直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。

信號量
�6�9�6�9信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。

import threading
import time
class Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3)
#允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)

for item in range(100):
t = jdThread(item)
t.start()
t.join()
條件判斷
�6�9�6�9所謂條件變數，即這種機制是在滿足了特定的條件後，線程才可以訪問相關的數據。
�6�9�6�9它使用Condition類來完成，由於它也可以像鎖機制那樣用，所以它也有acquire方法和release方法，而且它還有wait，notify，notifyAll方法。

"""
一個簡單的生產消費者模型，通過條件變數的控制產品數量的增減，調用一次生產者產品就是+1，調用一次消費者產品就會-1.
"""

"""
使用 Condition 類來完成，由於它也可以像鎖機制那樣用，所以它也有 acquire 方法和 release 方法，而且它還有
wait， notify， notifyAll 方法。
"""

import threading
import queue,time,random

class Goods:#產品類
def __init__(self):
self.count = 0
def add(self,num = 1):
self.count += num
def sub(self):
if self.count>=0:
self.count -= 1
def empty(self):
return self.count <= 0

class Procer(threading.Thread):#生產者類
def __init__(self,condition,goods,sleeptime = 1):#sleeptime=1
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
cond.acquire()#鎖住資源
goods.add()
print("產品數量:",goods.count,"生產者線程")
cond.notifyAll()#喚醒所有等待的線程--》其實就是喚醒消費者進程
cond.release()#解鎖資源
time.sleep(self.sleeptime)

class Consumer(threading.Thread):#消費者類
def __init__(self,condition,goods,sleeptime = 2):#sleeptime=2
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
time.sleep(self.sleeptime)
cond.acquire()#鎖住資源
while goods.empty():#如無產品則讓線程等待
cond.wait()
goods.sub()
print("產品數量:",goods.count,"消費者線程")
cond.release()#解鎖資源

g = Goods()
c = threading.Condition()

pro = Procer(c,g)
pro.start()

con = Consumer(c,g)
con.start()
同步隊列
�6�9�6�9put方法和task_done方法，queue有一個未完成任務數量num，put依次num+1，task依次num-1.任務都完成時任務結束。

import threading
import queue
import time
import random

'''
1.創建一個 Queue.Queue() 的實例，然後使用數據對它進行填充。
2.將經過填充數據的實例傳遞給線程類，後者是通過繼承 threading.Thread 的方式創建的。
3.每次從隊列中取出一個項目，並使用該線程中的數據和 run 方法以執行相應的工作。
4.在完成這項工作之後，使用 queue.task_done() 函數向任務已經完成的隊列發送一個信號。
5.對隊列執行 join 操作，實際上意味著等到隊列為空，再退出主程序。
'''

class jdThread(threading.Thread):
def __init__(self,index,queue):
threading.Thread.__init__(self)
self.index = index
self.queue = queue

def run(self):
while True:
time.sleep(1)
item = self.queue.get()
if item is None:
break
print("序號：",self.index,"任務",item,"完成")
self.queue.task_done()#task_done方法使得未完成的任務數量-1

q = queue.Queue(0)
'''
初始化函數接受一個數字來作為該隊列的容量，如果傳遞的是
一個小於等於0的數，那麼默認會認為該隊列的容量是無限的.
'''
for i in range(2):
jdThread(i,q).start()#兩個線程同時完成任務

for i in range(10):
q.put(i)#put方法使得未完成的任務數量+1

⑧ python 2.7中有沒有socketserver這個模塊

Python提供了兩個基本的socket模塊。一個是socket，它提供了標準的BSD Socket API；另一個是socketServer，它提供了伺服器中心類，可以簡化網路伺服器的開發。
本文簡要介紹socket模塊包含的類及其使用。
1.開始了解socket模塊前，先熟悉下Python的網路編程模塊主要支持的兩種Intent協議：TCP和UDP。TCP協議是一種面向連接的可靠協議，用於建立機器之間的雙向通信流。UDP協議是一種較低級別的、以數據包為基礎的協議（無連接傳輸模式）。與TCP不同，UDP信息不可靠。
他們的區別如下圖所示：左圖為TCP連接協議，右圖為UDP連接協議

2.socket模塊的部分類方法介紹

類方法

說明

socket.socket(family, type[,proto])

創建並返回一個新的 socket對象

socket.getfqdn(name)

將使用點號分隔的 IP地址字元串轉換成一個完整的域名

socket.gethostbyname(hostname)

將主機名解析為一個使用點號分隔的 IP地址字元串

socket.gethostbyname_ex(name)

它返回一個包含三個元素的元組，從左到右分別是給定地址的主要的主機名、同一IP地址的可選的主機名的一個列表、關於同一主機的同一介面的其它IP地址的一個列表（列表可能都是空的）。

socket.gethostbyaddr(address)

作用與gethostbyname_ex相同，只是你提供給它的參數是一個IP地址字元串

Socket.getservbyname(service,protocol)

它要求一個服務名（如'telnet'或'ftp'）和一個協議（如'tcp'或'udp'），返回服務所使用的埠號

socket.fromfd(fd, family, type)

從現有的文件描述符創建一個 socket對象

3.socket對象的部分方法介紹

實例方法

說明

sock.bind( (adrs, port) )

將 socket綁定到一個地址和埠上

sock.accept()

返回一個客戶機 socket（帶有客戶機端的地址信息）

sock.listen(backlog)

將 socket設置成監聽模式，能夠監聽 backlog 外來的連接請求

sock.connect( (adrs, port) )

將 socket連接到定義的主機和埠上

sock.recv( buflen[, flags] )

從 socket中接收數據，最多 buflen 個字元

sock.recvfrom( buflen[, flags] )

從 socket中接收數據，最多 buflen 個字元，同時返回數據來源的遠程主機和埠號

sock.send( data[, flags] )

通過 socket發送數據

sock.sendto( data[, flags], addr )

通過 socket發送數據

sock.close()

關閉 socket

sock.getsockopt( lvl, optname )

獲得指定 socket 選項的值

sock.setsockopt( lvl, optname, val )

設置指定 socket選項的值

4.編寫socket測試程序
（a）編寫server的步驟

第一步是創建socket對象。調用socket構造函數。如：
socket = socket.socket( family, type )
family參數代表地址家族，可為AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用於同一台機器上的進程間通信。
type參數代表套接字類型，可為SOCK_STREAM(流套接字)和SOCK_DGRAM(數據報套接字)。
第二步是將socket綁定到指定地址。這是通過socket對象的bind方法來實現的：
socket.bind( address )
由AF_INET所創建的套接字，address地址必須是一個雙元素元組，格式是(host,port)。host代表主機，port代表埠號。如果埠號正在使用、主機名不正確或埠已被保留，bind方法將引發socket.error異常。
第三步是使用socket套接字的listen方法接收連接請求。
socket.listen( backlog )
backlog指定最多允許多少個客戶連接到伺服器。它的值至少為1。收到連接請求後，這些請求需要排隊，如果隊列滿，就拒絕請求。
第四步是伺服器套接字通過socket的accept方法等待客戶請求一個連接。
connection, address = socket.accept()
調 用accept方法時，socket會時入「waiting」狀態。客戶請求連接時，方法建立連接並返回伺服器。accept方法返回一個含有兩個元素的元組(connection,address)。第一個元素connection是新的socket對象，伺服器必須通過它與客戶通信；第二個元素 address是客戶的Internet地址。
第 五步是處理階段，伺服器和客戶端通過send和recv方法通信(傳輸 數據)。伺服器調用send，並採用字元串形式向客戶發送信息。send方法返回已發送的字元個數。伺服器使用recv方法從客戶接收信息。調用recv 時，伺服器必須指定一個整數，它對應於可通過本次方法調用來接收的最大數據量。recv方法在接收數據時會進入「blocked」狀態，最後返回一個字元 串，用它表示收到的數據。如果發送的數據量超過了recv所允許的，數據會被截短。多餘的數據將緩沖於接收端。以後調用recv時，多餘的數據會從緩沖區 刪除(以及自上次調用recv以來，客戶可能發送的其它任何數據)。
傳輸結束，伺服器調用socket的close方法關閉連接。
（b）編寫client的步驟
首先創建一個socket以連接伺服器：socket =socket.socket( family, type )
使用socket的connect方法連接伺服器。對於AF_INET家族,連接格式如下：
socket.connect( (host,port) )
host代表伺服器主機名或IP，port代表伺服器進程所綁定的埠號。如連接成功，客戶就可通過套接字與伺服器通信，如果連接失敗，會引發socket.error異常。
處理階段，客戶和伺服器將通過send方法和recv方法通信。
傳輸結束，客戶通過調用socket的close方法關閉連接。
5.實例源碼：python socket半雙工聊天
（a）tcpserver.py
[python] view plain
# -*- coding: cp936 -*-
#file:tcpserver.py

import socket
from time import ctime
import sys

bufsize = 1024
host = '127.0.0.1'
port = 8100
address = (host,port)

server_sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_sock.bind(address)
server_sock.listen(1)

while True:
print 'waiting for connection...'
clientsock,addr = server_sock.accept()
print 'received from :',addr

while True:
data = clientsock.recv(bufsize)
print ' 收到---->%s\n%s' %(ctime(),data)
data = raw_input("發送----->")
clientsock.send(data)
clientsock.close()

server_sock.close()
（b）tcpclient.py
[python] view plain
## -*- coding: cp936 -*-
##file：tcpclient.py

from socket import *
from time import ctime

bufsize = 1024
host = '127.0.0.1'
port = 8100
addr = (host,port)

client_sock = socket(AF_INET,SOCK_STREAM)
client_sock.connect(addr)

while True:
data = raw_input("發送---->")
if not data:
break
else:
client_sock.send(data)
data = client_sock.recv(bufsize)
print '收到---->%s\n%s' %(ctime(),data)

client_sock.close()

⑨ python，代碼如下，返回的錯誤是AttributeError: type object 'SPAMFilter' has no attribute '_bases_'

__bases__你是不是少輸入了一個_號
我自己本地測試，是沒問題的

⑩ 請教一個Python基礎教程上一段代碼的問題

具體的名字叫做「表理解(list comprehension)」

用於快速地生成一個新的列表

return[xforxinsequenceifxnotinself.blocked]

會等價於

l=[]
forxinsequence:
ifxnotinself.blocked:
l.append(x)
returnl

表理解一行可以頂5行，很方便吧