python基础知识(七)

文章目录

• python网络编程
• • socket对象方法
  • 示例
• python SMTP发送邮件
• python多线程
• • _thread创建线程
  • threading模块创建线程
  • • threading常用方法
  • 继承threading创建线程
  • 线程同步
  • 线程优先级队列（ Queue）

python网络编程

Python 中，我们用 socket() 函数来创建套接字，语法格式如下：

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

参数:

• family: 套接字家族可以是 AF_UNIX 或者 AF_INET
• type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM
• proto: 一般不填默认为0.

socket对象方法

示例

服务端

import socket
import sys

# 创建socket对象
serversocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 获取本地主机名
host = socket.gethostname()
port = 9999

# 绑定端口号
serversocket.bind((host,port))

# 设置最大连接数，超过后排队
serversocket.listen(5)

while True:
    # 建立客户端连接
    clientsocket,addr = serversocket.accept()

    print("连接地址：%s" % str(addr))
    msg = '欢迎访问菜鸟教程！'+"\r\n"
    clientsocket.send(msg.encode('utf-8'))
    clientsocket.close()

客户端：

import socket
import sys

# 创建socket对象
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 获取本地主机名
host = socket.gethostname()
# 设置端口号
port = 9999
# 连接服务，指定主机和端口
s.connect((host,port))

# 接收小于1024字节的数据
msg = s.recv(1024)

s.close()
print(msg.decode('utf-8'))

python SMTP发送邮件

Python创建 SMTP 对象语法如下：

import smtplib
smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

参数说明：

host: SMTP 服务器主机。 你可以指定主机的ip地址或者域名如:runoob.com，这个是可选参数。
port: 如果你提供了 host 参数, 你需要指定 SMTP 服务使用的端口号，一般情况下SMTP端口号为25。
local_hostname: 如果SMTP在你的本机上，你只需要指定服务器地址为 localhost 即可。
Python SMTP对象使用sendmail方法发送邮件，语法如下：

SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]

参数说明：

from_addr: 邮件发送者地址。
to_addrs: 字符串列表，邮件发送地址。
msg: 发送消息
这里要注意一下第三个参数，msg是字符串，表示邮件。我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意msg的格式。这个格式就是smtp协议中定义的格式。

示例

import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

mail_user = "1041575391@qq.com"
mail_pass = "xxxxxxxx" #可在qq邮箱中生成
my_sender = '1041575391@qq.com'

def mail():
    ret = True
    try:
        msg = MIMEText('填写邮件内容','plain','utf-8')
        msg['From']=formataddr(["FromRunoob",my_sender])
        msg['To']=formataddr(["FK",mail_user])
        msg['Subject']="菜鸟教程发送邮件测试"

        server=smtplib.SMTP_SSL("smtp.qq.com",465)
        server.login(my_sender,mail_pass)
        server.sendmail(my_sender,[mail_user],msg.as_string())
        server.quit()
    except Exception:
        ret = False
    return ret

ret = mail()
if ret:
    print("邮件发送成功")
else:
    print("邮件发送失败")

带附件示例：

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
from email.utils import formataddr


mail_user = "1041575391@qq.com"
mail_pass = "xxxxxxx" #可在qq邮箱中生成
my_sender = '1041575391@qq.com'

#创建一个带附件的实例
message = MIMEMultipart()
message['From'] = formataddr(["FromRunoob",my_sender])
message['To'] = formataddr(["FK",mail_user])
subject = "Python SMTP 邮件测试"
message['Subject'] = Header(subject,'utf-8')

message.attach(MIMEText('这是菜鸟教程Python邮件发送测试...','plain','utf-8'))
# 构造附件1
att1 = MIMEText(open('D:\\test.txt','rb').read(),'base64','utf-8')
att1['Content-Type'] = 'application/octet-stream'
att1['Content-Disposition'] = 'attachment;filename="test.txt'
message.attach(att1)

#构造附件2
att2 = MIMEText(open('D:\\runoob.txt','rb').read(),'base64','utf-8')
att2["Content-Type"] = 'application/octet-stream'
att2["Content-Disposition"] = 'attachment;filename="runoob.txt"'
message.attach(att2)
try:
    server=smtplib.SMTP_SSL("smtp.qq.com",465)
    server.login(my_sender,mail_pass)
    server.sendmail(my_sender,[mail_user],message.as_string())
    server.quit()
    print("邮件发送成功")
except smtplib.SMTPException:
    print("Error:无法发送邮件")

带图片示例：

import smtplib
from email.mime.image import MIMEImage
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.utils import formataddr
from email.header import Header

mail_user = "1041575391@qq.com"
mail_pass = "xxxxxxx" #可在qq邮箱中生成
mail_sender = "1041575391@qq.com"

msgRoot = MIMEMultipart('related')
msgRoot['From'] = formataddr(["FromRunoob",mail_sender])
msgRoot['To'] = formataddr(["FK",mail_user])
subject = 'Python SMTP 邮件测试'
msgRoot['Subject'] = Header(subject,'utf-8')

msgAlternative = MIMEMultipart('alternative')
msgRoot.attach(msgAlternative)

mail_msg = """
<p>Python 邮件发送测试...</p>
<p><a href="http://www.runoob.com">菜鸟教程链接</a></p>
<p>图片演示：</p>
<p><img src="cid:image1"></p>
"""
msgAlternative.attach(MIMEText(mail_msg,'html','utf-8'))

fp = open("D:\\test.png",'rb')
msgImage = MIMEImage(fp.read())
fp.close()

msgImage.add_header('Content-ID','<image1>')
msgRoot.attach(msgImage)

try:
    server = smtplib.SMTP_SSL("smtp.qq.com",465)
    server.login(mail_user,mail_pass)
    server.sendmail(mail_sender,[mail_user],msgRoot.as_string())
    print("邮件发送成功")
except smtplib.SMTPException:
    print("Error:无法发送邮件")

python多线程

_thread创建线程

函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:

_thread.start_new_thread ( function, args[, kwargs] )

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

示例：

import _thread
import time

# 为线程定义一个函数
def print_time(threadName,delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName,time.ctime(time.time())))

try:
    _thread.start_new_thread(print_time,("Thread-1",2))
    _thread.start_new_thread(print_time,("Thread-2",4))
except:
    print("Error: 无法启动线程")

while 1:
    pass

threading模块创建线程

threading.Thread(target, args=(), kwargs={}, daemon=None)

• 创建Thread类的实例。
• target：线程将要执行的目标函数。
• args：目标函数的参数，以元组形式传递。
• kwargs：目标函数的关键字参数，以字典形式传递。
• daemon：指定线程是否为守护线程。

示例：

import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(i)
# 创建线程
thread = threading.Thread(target=print_numbers)

# 启动线程
thread.start()

# 等待线程结束
thread.join()

threading常用方法

threading.current_thread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的列表。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.active_count(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果。

继承threading创建线程

import threading
import time

exitFlag = 0

class myThread(threading.Thread):

    def __init__(self,threadID,name,delay):
        threading.Thread.__init__(self)
        self.threadID=threadID
        self.name = name
        self.delay = delay

    def run(self):
        print("开始线程："+self.name)
        print_time(self.name,self.delay,5)
        print("退出线程："+self.name)

def print_time(threadName,delay,counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print("%s: %s" % (threadName,time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

# 开启线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("退出主线程")

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间

import threading
import time

threadLock = threading.Lock()
threads = []
class myThread(threading.Thread):
    def __init__(self,threadID,name,delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay

    def run(self):
        print("开启线程："+self.name)
        threadLock.acquire()
        print_time(self.name,self.delay,3)
        threadLock.release()

def print_time(threadName,delay,counter):
    while counter:
        time.sleep(delay)
        print("%s: %s" %(threadName,time.ctime(time.time())))
        counter -= 1

thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

thread1.start()
thread2.start()

threads.append(thread1)
threads.append(thread2)

for t in threads:
    t.join()
print("退出主线程")

线程优先级队列（ Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

import queue
import threading
import time

exitFlag = 0
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

class myThread(threading.Thread):
    def __init__(self,threadID,name,q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q

    def run(self):
        print("开启线程："+self.name)
        process_data(self.name,self.q)
        print("退出线程："+self.name)

def process_data(threadName,q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print("%s processing %s" %(threadName,data))
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1","Thread-2","Thread-3"]
nameList = ["One","Two","Three","Four","Five"]

# 创建新线程
for tName in threadList:
    thread = myThread(threadID,tName,workQueue)
    thread.start()
    threads.append(thread)
    threadID +=1

# 填充队列
queueLock.acquire()
for work in nameList:
    workQueue.put(work)
queueLock.release()

while not workQueue.empty():
    pass

exitFlag = 1

for t in threads:
    t.join()
print("退出主线程")