python学习总结四

本周主要学习了多重继承，多线程、多进程、正则表达式和网路化编程

多重继承

多重继承后面两个父类可以用抽象类和抽象方法,方法由子类自己来写，并且不绑定属性

from abc import ABCMeta,abstractmethod
class Father(object):def __init__(self,name):self._name = namedef drink(self):print(self._name+'正在喝二锅头')def gamble(self):print(self._name+'正在赌博')class Monk(object,metaclass=ABCMeta):@abstractmethoddef eat_vegetable(self):passclass Musician(object,metaclass=ABCMeta):@abstractmethoddef play_piano(self):pass@abstractmethoddef drink(self):passclass Son(Father,Monk,Musician):def __init__(self,name,nickname,art_name):Father.__init__(self,name)self._nickname = nicknameself._art_name = art_name# Monk.__init__(self,nickname)# Musician.__init__(self,art_name)def play_piano(self):print(self._art_name+'正在弹钢琴')def drink(self):print(self._name+'正在喝白开水')def eat_vegetable(self):print(self._nickname+'正在吃斋')def chant(self):print(self._nickname+'正在念经')def main():son = Son('王大锤','智障阐师','小刚炮')son.drink()son.gamble()son.play_piano()son.eat_vegetable()son.chant()
if __name__ == '__main__':main()

如果一个类有多个父类而多个父类又有公共的父亲（菱形继承/钻石继承）
那么在搜索属性和方法时搜索的依据是C3算法（有点类似于广度优先搜索）
这个是python3中的一个改进在此之前搜索的算法是深度优先搜索（DFS）

正则表达式

re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
检索和替换
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

re.compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。

re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.split
split 方法按照能够匹配的子串将字符串分割后返回列表

. 匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用象 ‘[.\n]’ 的模式。

\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。
\b 匹配单词的开始或结束
* 重复0次或多次
+ 匹配它前面的子表达式一次或多次
\A 匹配字符串开始
\z 匹配字符串结束
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
^ 匹配字符串的开头比如^spam 意味着字符串必须以spam开始
匹配字符串的末尾 spam$表示字符串必须以spam结束
{} 匹配特定次数，例如{3}表示它前面的字符出现三次，{3，6}表示三到六个字符
? 表示匹配0次或1次前面的表达式或者是声明非贪心匹配（注意，python的正则表达式默认是贪心的）
[…] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’
[^…] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re* 匹配0个或多个的表达式。
re+ 匹配1个或多个的表达式。
re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n} 匹配n个前面表达式。。例如，”o{2}”不能匹配”Bob”中的”o”，但是能匹配”food”中的两个o。
re{ n,} 精确匹配n个前面表达式。例如，”o{2,}”不能匹配”Bob”中的”o”，但能匹配”foooood”中的所有o。”o{1,}”等价于”o+”。”o{0,}”则等价于”o*”。
re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b 匹配a或b
(re) 匹配括号内的表达式，也表示一个组
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re) 类似 (…), 但是不表示一个组
(?imx: re) 在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#…) 注释.
(?= re) 前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re) 匹配的独立模式，省去回溯。
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
\1…\9 匹配第n个分组的内容。
\10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
[abc] 匹配方括号内的任意一个字符比如[1234]就是说可以为：1,2,3或4
[abc] 匹配不在方括号内的任意字符

.* 表示任意文本

正则表达式-工具-定义字符串的匹配模式
\w{6,20}
[1-9]\d{4,11} 是5到12位qq号
re-正则表达式的模块

import redef is_valid_username(username):"""判断用户名是否有效（用户名由字母数字下划线构成且长度为6-20个字符）:param username: 用户名:return: 有效返回真否则返回假"""if 6<=len(username)<=20:for ch in username:if not( '0'<=ch<='9' or 'A'<=ch<='Z' or'a'<=ch<='z' or ch=='_'):return Falsereturn Truereturn False
def main():username = 'dggehgi6353hdh'm = re.match(r'^\w{6,20}$',username)print(m)print(m.span()) #取出匹配成功的范围print(m.group())#取出匹配成功的部分print(is_valid_username('admin'))print(is_valid_username('asffdsyetwhh'))m = re.search(r'\w{6,20}',username)  #从全范围搜索匹配的if __name__ == '__main__':main()

判断qq和用户名是否有效

import re
def main():username = input('请输入用户名:')qq = input('请输入qq号:')# p = re.compile(r'\w{6,20}')  如果要多次运用这一个表达式就要通过这种创建对象的方式# m1 = p.match(username)m1 = re.match( r'^[1-9]\d{4,11}$',qq)if not m1:print('输入的qq号无效')m2 = re.match(r'^\w{6,20}$',username)if not m2:print('输入的用户名无效')if m1 and m2:print('你输入的信息是有效的')if __name__ == '__main__':main()

                        判断是否是国内号码
import re
def main():tel = input('请输入号码:')p = re.compile(r'^1((3[0-9])|4(5|7)|5([0-3]|[5-9])|7[6-8]|8[0-9]|99)\d{8}$')m1 = p.match(tel)if not m1:print('号码无效')else:print('号码正确')if __name__ == '__main__':main()

import re
def main():pattern = re.compile(r'(?<=\D)1[345789]\d{9}(?=\D)')sentence = '说8130000000000遍我的手机号是13512346789不是13300998765，舒林的手机号是13563547389不是123'mylist = pattern.findall(sentence)print(mylist)  #浪费空间# ?<=\D  回顾前面的内容# ? = \D 前瞻后面的内容#iter-iterator-迭代器for temp in pattern.finditer(sentence):  #浪费时间print(temp)print(temp.group())print(temp.span())# m = pattern.search(sentence)# while m:#     print(m.group())#     m = pattern.search(sentence,m.span()[1]) #找出后面的电话号码if __name__ == '__main__':main()


import redef main():sentence = '马化腾我操你大爷的日你二爷干你三舅爷Fuck你姑妈'pure = re.sub('[操艹草日干顶]|马化腾|fuck|shit','*',sentence,flags = re.IGNORECASE)#IGNORECASE:意思是忽略英文大小写print(pure)sentence = 'You go your way,I will go mine!'mylist = re.split(r'[\s,!]',sentence)print(mylist)sentence = 'aabsggddhhb'm = re.match(r'a.*b',sentence) #默认贪婪匹配m = re.match(r'a.*?b', sentence) #惰性匹配print(m)if __name__ == '__main__':main()

from re import findall,sub
def foo(mo):val = int(mo.group())return str(val**2)
def main():str1 = 'abc123dshsggf23ddgfgggd45dddh78dg'num = findall(r'\d+',str1)m = list(map(int,num))print(sum(m)/len(m))print(sub(r'\d+',foo,str1))#给组取名字： ？p<name>
if __name__ == '__main__':main()

爬网站首页


import requests
def main():#拿到网站首页的源代码resp = requests.get('https://www.baidu.com/img/bd_logo1.png')print(resp.content)#显示的是二进制数据#把网站首页图片写进本地文件with open('bd_logo1.png', 'wb') as ft:ft.write(resp.content)
if __name__ == '__main__':main()

爬美女图片

import json
#首先需要安装requests模块
import requestsdef main():#网络API（应用程序编程接口）/网络数据接口#通过网络数据接口通常会拿到两种数据格式（XML/JSON）中的一种resp = requests.get('https://api.tianapi.com/meinv/?key=81a5d68102a2826cbc8220c325d1a440&num=10')#通过resp对象的text属性可以获得JSON格式的数据（字符串）#接下来需要将字符串转换成Python中的字典才能够解析出数据#python中有一个内置的json模块 它提供了json到字典的双向转换meinv_dict = json.loads(resp.text,encoding='utf-8')#二进制数据用content 文本数据用textfor temp_dict in meinv_dict['newslist']:url = temp_dict['picUrl']resp = requests.get(url)#对url进行切片取出最后一个斜线后面的内容作为文件名filename = url[url.rfind('/')+1:]with open(filename,'wb') as f:f.write(resp.content)print('美女图片下载完成')if __name__ == '__main__':main()

url百分号编码


import json
from urllib.parse import quote, unquote
import requestsdef main():#百分号编码print(quote('蛇', encoding='utf-8'))#百分号编码的解码print(unquote('%E8%9B%87', encoding='utf-8'))#周公解梦 word后面的文本必须要以百分号编码的形式写，所以需要将文字进行转换，用urllib.parse模块里的quote函数，解码用unquoteurl = 'http://api.tianapi.com/txapi/dream/?key=81a5d68102a2826cbc8220c325d1a440&word='url += quote('春梦')print(url)resp = requests.get(url)a_dict = json.loads(resp.text, encoding='utf-8')for b_dict in a_dict['newslist']:url = b_dict['result']print(url)with open('file1', 'w',encoding='utf-8') as f:f.write(url)print('操作完成')
if __name__ == '__main__':main()

网路化编程

TCP服务器

from os import SEEK_END
from socket import socket, SOCK_STREAM, AF_INET
from datetime import datetime
from time import sleepdef main():#1.创建套接字对象并指定使用哪种传输服务#SOCK_STREAM---TCP套接字#SOCK_DGRAM---UDP套接字#SOCK_RAM---原始套接字#AF_INET---ipv4#AF_INET6--ipv6server = socket(AF_INET,SOCK_STREAM)#2.绑定IP地址和端口用元组形式（区分不同的服务）server.bind(('10.7.152.143',6899))#3.开启监听-监听客户端连接到服务器server.listen(512)print('服务器开始监听...')#4.通过循环接收客户端的连接并作出相应的处理（提供服务）#发送图片with open('12.jpg', 'rb') as f:data = f.read()# data是字节类，可以对它进行切片操作f.seek(0, SEEK_END)#计算读取文件的总长度，无返回值file_len = f.tell()#这里返回文件的长度值（int型数据）while True:#accept方法是一个阻塞方法，如果没有客户端连接到服务器，这个方法就会阻塞代码不会向下执行client,addr = server.accept()print(str(addr)+'连接到服务器')#5.发送数据#发送服务器时间#client.send(str(datetime.now()).encode('utf-8'))#一个客户端断开连接以后下一个客户端才能被接纳，其他客户端继续排队等待#聊天服务# while True:#     data = client.recv(1024).decode('utf-8')#     print(data)##     if data == 'bye':#         break#     msg = input('请输入:')#     client.send(msg.encode('utf-8'))client.send('12.jpg'.encode('utf-8'))client.send(str(file_len).encode('utf-8'))total = 0while total<file_len:client.send(data[total:total+1024])total += 1024sleep(0.001)#6.断开连接client.close()if __name__ == '__main__':main()

TCP客户端


from socket import socketdef main():#创建套接字对象client = socket()#连接到服务器client.connect(('10.7.152.143', 6999))#接收消息#接收图片的filename = client.recv(1024).decode('utf-8')print(filename)file_len = int(client.recv(1024).decode('utf-8'))print(file_len)with open('13.jpg','wb') as f:total = 0while total<file_len:msg = client.recv(1024)f.write(msg)total += 1024print('图片已保存')#聊天的客户端# while True:#     message = client.recv(512).decode('utf-8')#     print(message)#     a = input('请输入:')#     client.send(a.encode('utf-8'))#     if a == 'bye':#         break# client.close()#接收系统时间的# msg = client.recv(1024).decode('utf-8')# print(msg)# client.close()if __name__ == '__main__':main()

Tcp服务器发送图片用base64

'''
BASE64 - 将二进制数据处理成由64种符号表示的文本
64种符号: A-Z,a-z,0-9,+,/
1KB = 1024B
1MB = 1024KB
100Mbps = 12.5MBps
每6个bit一组 最小000000(0) 最大111111(63)
正好用64个符号就可以表示所有的二进制数据
01101100 | 11000011 | 11010011
011011 | 00 1100 | 0011 11 | 010011
'''from socket import socket, SOCK_STREAM, AF_INET
from base64 import b64encode
from json import dumpsdef main():# 1.创建套接字对象并指定使用哪种传输服务server = socket()# 2.绑定IP地址和端口(区分不同的服务)server.bind(('10.7.152.143', 6799))# 3.开启监听 - 监听客户端连接到服务器server.listen(512)print('服务器启动开始监听...')with open('12.jpg', 'rb') as f:# 将二进制数据处理成base64再解码成字符串data = b64encode(f.read()).decode('utf-8')while True:client, addr = server.accept()# 用一个字典(键值对)来保存要发送的各种数据# 待会可以将字典处理成JSON格式在网络上传递my_dict = dict({})my_dict['filename'] = '12.jpg'# JSON是纯文本不能携带二进制数据# 所以图片的二进制数据要处理成base64编码my_dict['filedata'] = data# 通过dumps函数将字典处理成JSON字符串json_str = dumps(my_dict)# 发送JSON字符串client.send(json_str.encode('utf-8'))client.close()if __name__ == '__main__':main()

Tcp客户端接收图片

from socket import socket
from json import loads
from base64 import b64decodedef main():client = socket()client.connect(('10.7.152.143', 6799))# 定义一个保存二进制数据的对象in_data = bytes()# 由于不知道服务器发送的数据有多大每次接收1024字节data = client.recv(1024)while data:#data不为空 执行下面代码# 将收到的数据拼接起来in_data += datadata = client.recv(1024)# 将收到的二进制数据解码成JSON字符串并转换成字典# loads函数的作用就是将JSON字符串转成字典对象my_dict = loads(in_data.decode('utf-8'))filename = my_dict['filename']filedata = my_dict['filedata'].encode('utf-8')with open('13.jpg', 'wb') as f:# 将base64格式的数据解码成二进制数据并写入文件f.write(b64decode(filedata))print('图片已保存.')if __name__ == '__main__':main()

UDP服务器

from socket import socket, SOCK_DGRAM
from time import sleepdef main():sender = socket(type=SOCK_DGRAM)with open('mm.jpg','rb') as f:data = f.read()data_len = len(data)total = 0while total<data_len:sender.sendto(data[total:total+1024],('10.7.189.118',9876))total += 1024sleep(0.001)if __name__ == '__main__':main()

UDP客户端

from socket import socket, SOCK_DGRAM
def main():receiver = socket(type=SOCK_DGRAM)receiver.bind(('10.7.189.118',9876))data = bytes()while True:seg,addr = receiver.recvfrom(1024)  #接收数据，返回元组data += segprint(len(data))if len(data)>= 137827: #图片的大小breakwith open('hello.jpg','wb') as f: #以二进制方式写文件f.write(data)print('图片接收完成')if __name__ == '__main__':main()

多线程、多进程

进程：操作系统分配内存的基本单位，进程之间的内存是相互隔离的，如果进程之间要相互通信是通过ipc机制
线程：一个进程里面可以划分成多个线程，所以线程是进程的执行单元，也是操作系统分配cpu的基本单元
多线程可以分到更多的cpu的时间，如果一个任务时间很长，我们可以用多进程多线程来提高执行效率，
提高性能，改善用户体验

from multiprocessing import Process
import os
import timedef output():print(os.getpid())while True:print('pong',end='',flush=True)time.sleep(0.001)def main():print(os.getpid())p = Process(target = output)p.start()while True:print('ping',end='',flush = True)time.sleep(0.001)if __name__ == '__main__':main()

URL - Uniform Resource Locator

多线程找美女图片

import requests
import json
from threading import Threadclass DownloadTask(Thread):def __init__(self,url):super().__init__()self._url = urldef run(self):resp = requests.get(self._url)filename = self._url[self._url.rfind('/')+1:]try:with open(filename, 'wb') as fs:fs.write(resp.content)except IOError as e:print(e)def main():# request / responseresp = requests.get('http://api.tianapi.com/meinv/?key=81a5d68102a2826cbc8220c325d1a440&num=10')mydict = json.loads(resp.text) #二进制转化成字典threads = []for tempdict in mydict['newslist']:pic_url = tempdict['picUrl']thread = DownloadTask(pic_url)thread.start()threads.append(thread)for thread in threads:thread.join()print('图片下载完成')#resp = requests.get(pic_url)#filename = pic_url[pic_url.rfind('/') + 1:]if __name__ == '__main__':main()

from random import randint
from threading import Thread
from time import sleep
import pygame
class Color(object):BLACK = (0,0,0)WHITE = (255,255,255)GRAY = (242,242,242)@staticmethoddef random_color():r = randint(0,255)g = randint(0,255)b = randint(0,255)return r,g,bclass Car(object):def __init__(self,x,y,color):self._x = xself._y = yself._color = colordef move(self):if self._x+80<950:self._x+=randint(1,10)def draw(self,screen):pygame.draw.rect(screen,self._color,(self._x,self._y,80,40),0)def main():class BackroundTask(Thread):def run(self):while True:screen.fill(Color.GRAY)pygame.draw.line(screen, Color.BLACK, (130, 0), (130, 600), 4)pygame.draw.line(screen, Color.BLACK, (950, 0), (950, 600), 4)for car in cars:car.draw(screen)pygame.display.flip()sleep(0.05)for car in cars:car.move()cars =[]for index in range(5):temp = Car(50,50+120*index,Color.random_color())cars.append(temp)pygame.init()screen = pygame.display.set_mode((1000,600))BackroundTask(daemon=True).start()running = Truewhile running:for event in pygame.event.get():if event.type == pygame.QUIT:running = Falsepygame.quit()if __name__ == '__main__':main()

import timefrom threading import Threadfrom random import randint
def download(filename):print('开始下载%s' %filename)delay = randint(10,25)time.sleep(delay)print('%s下载完成,用时%d秒' %(filename,delay))class DownloadTask(Thread):def __init__(self,filename):super().__init__()self._filename = filenamedef run(self):  #钩子函数（hook）、回调函数（callback），不是自己来调这个函数download(self._filename)def main():start = time.time()t1 = DownloadTask ('python入门.pdf')t1.start()t2 = DownloadTask('dgfg.avi')t2.start()t1.join()t2.join()end = time.time()print('总共耗费%f秒'%(end-start))if __name__ == '__main__':main()


import time
from threading import Thread,Lockclass Account(object):def __init__(self):self._balance = 0self._lock = Lock()@propertydef balance(self):return self._balancedef deposit(self,money):  #转钱的一个函数#当多个线程同时访问一个资源的时候 就有可能因为竞争资源导致状态错误#被多个线程访问的资源我们通常称之为临界资源 对临界资源的访问需要加上保护if money>0:self._lock.acquire() #加锁try:new_balance = self._balance+moneytime.sleep(0.01)self._balance = new_balancefinally:self._lock.release() #解锁class AddMoneyThread(Thread):def __init__(self,account):super().__init__()self._account = accountdef run(self):self._account.deposit(1)def main():account = Account()tlist = []for _ in range(100):t = AddMoneyThread(account)tlist.append(t)t.start()for t in tlist:t.join()print('账户余额:%d元'%account.balance)if __name__ == '__main__':main()

from threading import Thread
#创建线程的两种方式
#1.直接创建Thread对象并通过target参数指定线程启动后要执行的任务
#2.继承Thread自定义线程 通过重写run方法指定线程启动后执行的任务count = 0
def output(string):global countinner_count = 0while count<10:print(string,end='',flush=True)count+=1inner_count+=1print('\n%s打印了%d次\n' %(string,inner_count))#sleep(0.001)def main():#daemon = True - 将线程设置为守护线程t1 = Thread(target = output,args=('ping',))#主线程结束了，不值得保留的守护线程也跟着结束了t1.start()t2 = Thread(target=output,args=('pong',))t2.start()if __name__ == '__main__':main()

#线程控制把元素加到列表from threading import Threadclass MyThread(Thread):def __init__(self, food_name, my_list):""":type my_list list::param food_name::param my_list:"""super().__init__()self._food_name = food_nameself._my_list = my_listself.is_over = Falsedef run(self):for _ in range(10000):self._my_list.append(self._food_name)self.is_over = Truedef main():name_list = ['apple', 'banana', 'Strawberry', 'Pear', 'orange']big_list = []thread_list = []for val in name_list:my_thread = MyThread(val, big_list)thread_list.append(my_thread)my_thread.start()running = Truewhile running:i = 0for my_thread in thread_list:if my_thread.is_over:i += 1if i == 4:print(len(big_list))running = Falseif __name__ == '__main__':main()

from threading import Threaddef output(n):temp = []count = 0while count<10:temp.append(n)count+=1return tempdef main():t1 = Thread(target=output,)t1.start()t2 = Thread(target=output,)t2.start()t3 = Thread(target=output, )t3.start()t4 = Thread(target=output, )t4.start()t5 = Thread(target=output, )t5.start()if __name__ == '__main__':main()

多进程

import timefrom multiprocessing import Processfrom random import randint#如果多个任务之间没有任何的关联（独立子任务）而且希望利用cpu的多核特性
#那么我们推荐使用多进程def download(filename):print('开始下载%s' %filename)delay = randint(5,15)time.sleep(delay)print('%s下载完成,用时%d秒' %(filename,delay))
def main():start = time.time()p1 = Process(target = download,args = ('python入门.pdf',))p1.start()p2 = Process(target = download,args=('dgfg.avi',))p2.start()p1.join()p2.join()end = time.time()print('总共耗费%f秒'%(end-start))# download('python入门.pdf')# download('dgfg.avi')# end = time.time()# print('总共耗费了%f秒' %(end-start))if __name__ == '__main__':main()

import subprocess
#启动子进程
def main():subprocess.call('calc')subprocess.call('notepad')subprocess.call('python zhou2.4.py')if __name__ == '__main__':main()

TCP

服务器多线程

from socket import socket
from threading import Threaddef main():class ClientHandler(Thread):  # 客户端请求处理def __init__(self, client):super().__init__()self._client = clientdef run(self):try:while True:try:data = self._client.recv(1024)if data.decode('utf-8') == 'byebye':clients.remove(self._client)self._client.close()breakelse:for client in clients:client.send(data)except Exception as e:print(e)clients.remove(self._client)breakexcept Exception as b:print(b)server = socket()#python命令行参数-sys.argv可以把地址和端口作为变量，这样可以做更改server.bind(('10.7.189.83',12345))server.listen(512)clients = []  #把所有客户端放到容器里while True:curr_client,addr = server.accept()print(addr[0],'连接到服务器')clients.append(curr_client)ClientHandler(curr_client).start()
if __name__ == '__main__':main()

TCP
客户端多线程

from socket import socket
from threading import Threaddef main():class RefreshScreenThread(Thread):def __init__(self, client):super().__init__()self._client = clientdef run(self):while running:data = self._client.recv(1024)print(data.decode('utf-8'))nickname = input('请输入你的昵称:')myclient = socket()myclient.connect(('10.7.189.118',12345))running = TrueRefreshScreenThread(myclient).start()while running:content = input('请发言:')if content == 'byebye':myclient.send(content.encode('utf-8'))running = Falseelse:msg = nickname+':'+contentmyclient.send(msg.encode('utf-8'))if __name__ == '__main__':main()

发送邮件

MIME-Multipurpose Internet Mail

from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from smtplib import SMTP
def main():#发送附件sender = SMTP('smtp.qq.com')sender.login('2312605822@qq.com','csjottgdfnyzebhb')message = MIMEMultipart()message['Subject'] = '请查看附件中的数据'text_msg = MIMEText('附件中有本月关键数据','plain','utf-8')message.attach(text_msg)att1 = MIMEText(open('hello.xlsx', 'rb').read(), 'base64', 'utf-8')att1["Content-Type"] = 'application/vnd.ms-excel' #发送表格的写法att1["Content-Disposition"] = 'attachment; filename="foo.xlsx"'message.attach(att1)#下面是发送邮件的方法：# content = """我跟你老卓玩的还是你请我吧# 好不好# 此致，# 敬礼!# 熊彪 吉日"""# message = MIMEText(content,'plain','utf-8')# message['Subject'] = '今晚请你吃鸡鸡'sender.sendmail('2312605822@qq.com',['957658@qq.com'],message.as_string())  #发件人，# # 收件人，文本转换成字符串print('发送完成')if __name__ == '__main__':main()