python学习总结四

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

多重继承

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

from abc import ABCMeta,abstractmethod
class Father(object):
    def __init__(self,name):
        self._name = name

    def drink(self):
        print(self._name+'正在喝二锅头')

    def gamble(self):
        print(self._name+'正在赌博')

class Monk(object,metaclass=ABCMeta):
    @abstractmethod
    def eat_vegetable(self):
        pass

class Musician(object,metaclass=ABCMeta):
    @abstractmethod
    def play_piano(self):
        pass

    @abstractmethod
    def drink(self):
        pass


class Son(Father,Monk,Musician):
    def __init__(self,name,nickname,art_name):
        Father.__init__(self,name)
        self._nickname = nickname
        self._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 re

def 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 False

        return True
    return 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 re

def 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 requests


def 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 文本数据用text
    for 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 requests

def main():
    #百分号编码
    print(quote('蛇', encoding='utf-8'))
    #百分号编码的解码
    print(unquote('%E8%9B%87', encoding='utf-8'))
    #周公解梦 word后面的文本必须要以百分号编码的形式写，所以需要将文字进行转换，用urllib.parse模块里的quote函数，解码用unquote
    url = '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 sleep


def main():
    #1.创建套接字对象并指定使用哪种传输服务
    #SOCK_STREAM---TCP套接字
    #SOCK_DGRAM---UDP套接字
    #SOCK_RAM---原始套接字
    #AF_INET---ipv4
    #AF_INET6--ipv6
    server = 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 = 0
        while total<file_len:
            client.send(data[total:total+1024])
            total += 1024
            sleep(0.001)
        #6.断开连接
        client.close()



if __name__ == '__main__':
    main()

TCP客户端

from socket import socket


def 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 = 0
        while total<file_len:
            msg = client.recv(1024)
            f.write(msg)
            total += 1024
    print('图片已保存')
    #聊天的客户端
    # 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 dumps


def 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 b64decode


def main():
    client = socket()
    client.connect(('10.7.152.143', 6799))
    # 定义一个保存二进制数据的对象
    in_data = bytes()
    # 由于不知道服务器发送的数据有多大每次接收1024字节
    data = client.recv(1024)
    while data:#data不为空 执行下面代码
        # 将收到的数据拼接起来
        in_data += data
        data = 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 sleep

def main():
    sender = socket(type=SOCK_DGRAM)
    with open('mm.jpg','rb') as f:
        data = f.read()
        data_len = len(data)
        total = 0
        while total<data_len:
            sender.sendto(data[total:total+1024],('10.7.189.118',9876))
            total += 1024
            sleep(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 += seg
        print(len(data))
        if len(data)>= 137827: #图片的大小
            break

    with open('hello.jpg','wb') as f: #以二进制方式写文件
        f.write(data)
    print('图片接收完成')

if __name__ == '__main__':
    main()

多线程、多进程

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

from multiprocessing import Process
import os
import time

def 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 Thread

class DownloadTask(Thread):
    def __init__(self,url):
        super().__init__()
        self._url = url

    def 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 / response
    resp = 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)

    @staticmethod
    def random_color():
        r = randint(0,255)
        g = randint(0,255)
        b = randint(0,255)
        return r,g,b

class Car(object):

    def __init__(self,x,y,color):
        self._x = x
        self._y = y
        self._color = color

    def 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 = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
    pygame.quit()


if __name__ == '__main__':
    main()

import time

from threading import Thread

from 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 = filename

    def 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,Lock

class Account(object):

    def __init__(self):
        self._balance = 0
        self._lock = Lock()

    @property
    def balance(self):
        return self._balance

    def deposit(self,money):  #转钱的一个函数
        #当多个线程同时访问一个资源的时候 就有可能因为竞争资源导致状态错误
        #被多个线程访问的资源我们通常称之为临界资源 对临界资源的访问需要加上保护
        if money>0:
            self._lock.acquire() #加锁
            try:
                new_balance = self._balance+money
                time.sleep(0.01)
                self._balance = new_balance
            finally:
                self._lock.release() #解锁

class AddMoneyThread(Thread):
    def __init__(self,account):
        super().__init__()
        self._account = account

    def 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 count
    inner_count = 0
    while count<10:
        print(string,end='',flush=True)
        count+=1
        inner_count+=1
    print('\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 Thread


class 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_name
        self._my_list = my_list
        self.is_over = False

    def run(self):
        for _ in range(10000):
            self._my_list.append(self._food_name)
        self.is_over = True


def 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 = True
    while running:
        i = 0
        for my_thread in thread_list:
            if my_thread.is_over:
                i += 1
            if i == 4:
                print(len(big_list))
                running = False


if __name__ == '__main__':
    main()

from threading import Thread

def output(n):
    temp = []
    count = 0
    while count<10:
        temp.append(n)
        count+=1
    return temp

def 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 time

from multiprocessing import Process

from 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 Thread

def main():
    class ClientHandler(Thread):  # 客户端请求处理

        def __init__(self, client):
            super().__init__()
            self._client = client

        def run(self):
            try:
                while True:
                    try:
                        data = self._client.recv(1024)
                        if data.decode('utf-8') == 'byebye':
                            clients.remove(self._client)
                            self._client.close()
                            break
                        else:
                            for client in clients:
                                client.send(data)
                    except Exception as e:
                        print(e)
                        clients.remove(self._client)
                        break
            except 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 Thread

def main():

    class RefreshScreenThread(Thread):
        def __init__(self, client):
            super().__init__()
            self._client = client

        def 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 = True
    RefreshScreenThread(myclient).start()
    while running:
        content = input('请发言:')
        if content == 'byebye':
            myclient.send(content.encode('utf-8'))
            running = False
        else:
            msg = nickname+':'+content
            myclient.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('[email protected]','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('[email protected]',['[email protected]'],message.as_string())  #发件人，
    # # 收件人，文本转换成字符串
    print('发送完成')

if __name__ == '__main__':
    main()