<?xml version="1.0" encoding="UTF-8"?>
<message>
    <from>Alice</from>
    <to>Bob</to>
    <content>Will you marry me?</content>
</message>

{
    "from": "Alice",
    "to": "Bob",
    "content": "Will you marry me?"
}

pip install requests

from time import time
from threading import Thread

import requests


# 继承Thread类创建自定义的线程类
class DownloadHanlder(Thread):

    def __init__(self, url):
        super().__init__()
        self.url = url

    def run(self):
        filename = self.url[self.url.rfind('/') + 1:]
        resp = requests.get(self.url)
        with open('/Users/Hao/' + filename, 'wb') as f:
            f.write(resp.content)


def main():
    # 通过requests模块的get函数获取网络资源
    # 下面的代码中使用了天行数据接口提供的网络API
    # 要使用该数据接口需要在天行数据的网站上注册
    # 然后用自己的Key替换掉下面代码的中APIKey即可
    resp = requests.get(
        'http://api.tianapi.com/meinv/?key=APIKey&num=10')
    # 将服务器返回的JSON格式的数据解析为字典
    data_model = resp.json()
    for mm_dict in data_model['newslist']:
        url = mm_dict['picUrl']
        # 通过多线程的方式实现图片下载
        DownloadHanlder(url).start()


if __name__ == '__main__':
    main()

from socket import socket, SOCK_STREAM, AF_INET
from datetime import datetime


def main():
    # 1.创建套接字对象并指定使用哪种传输服务
    # family=AF_INET - IPv4地址
    # family=AF_INET6 - IPv6地址
    # type=SOCK_STREAM - TCP套接字
    # type=SOCK_DGRAM - UDP套接字
    # type=SOCK_RAW - 原始套接字
    server = socket(family=AF_INET, type=SOCK_STREAM)
    # 2.绑定IP地址和端口(端口用于区分不同的服务)
    # 同一时间在同一个端口上只能绑定一个服务否则报错
    server.bind(('192.168.1.2', 6789))
    # 3.开启监听 - 监听客户端连接到服务器
    # 参数512可以理解为连接队列的大小
    server.listen(512)
    print('服务器启动开始监听...')
    while True:
        # 4.通过循环接收客户端的连接并作出相应的处理(提供服务)
        # accept方法是一个阻塞方法如果没有客户端连接到服务器代码不会向下执行
        # accept方法返回一个元组其中的第一个元素是客户端对象
        # 第二个元素是连接到服务器的客户端的地址(由IP和端口两部分构成)
        client, addr = server.accept()
        print(str(addr) + '连接到了服务器.')
        # 5.发送数据
        client.send(str(datetime.now()).encode('utf-8'))
        # 6.断开连接
        client.close()


if __name__ == '__main__':
    main()

# socket_server
import socket 

server = socket.socket()
server.bind(("0.0.0.0",8080))
server.listen()
sock, addr =  server.accept()
# 从客户端获取发送的数据
data = sock.recv(1024)
print(data.decode("utf-8"))
sock.send("hahahaha".encode("utf-8"))
sock.close()
server.close()

# socket_client
import socket 

client = socket.socket()

client.connect(("192.168.3.35",8080))
client.send("hello zj".encode("utf-8"))
data = client.recv(1024)
print(data.decode("utf-8"))
client.close()

# socket_server
import socket

server = socket.socket()
server.bind(("0.0.0.0", 8080))
server.listen()
sock, addr = server.accept()
# 从客户端获取发送的数据
while True:
    data = sock.recv(1024)
    print(data.decode("utf-8"))
    string = input(">>>")
    sock.send(string.encode("utf-8"))

# socket_client
import socket

client = socket.socket()
client.connect(("192.168.3.35", 8080))
while True:
    string = input(">>>")
    client.send(string.encode("utf-8"))
    data = client.recv(1024)
    print(data.decode("utf-8"))

# client.close()

from socket import socket, SOCK_STREAM, AF_INET
from base64 import b64encode
from json import dumps
from threading import Thread


def main():

    # 自定义线程类
    class FileTransferHandler(Thread):

        def __init__(self, cclient):
            super().__init__()
            self.cclient = cclient

        def run(self):
            my_dict = {}
            my_dict['filename'] = 'guido.jpg'
            # JSON是纯文本不能携带二进制数据
            # 所以图片的二进制数据要处理成base64编码
            my_dict['filedata'] = data
            # 通过dumps函数将字典处理成JSON字符串
            json_str = dumps(my_dict)
            # 发送JSON字符串
            self.cclient.send(json_str.encode('utf-8'))
            self.cclient.close()

    # 1.创建套接字对象并指定使用哪种传输服务
    server = socket()
    # 2.绑定IP地址和端口(区分不同的服务)
    server.bind(('192.168.1.2', 5566))
    # 3.开启监听 - 监听客户端连接到服务器
    server.listen(512)
    print('服务器启动开始监听...')
    with open('guido.jpg', 'rb') as f:
        # 将二进制数据处理成base64再解码成字符串
        data = b64encode(f.read()).decode('utf-8')
    while True:
        client, addr = server.accept()
        # 启动一个线程来处理客户端的请求
        FileTransferHandler(client).start()


if __name__ == '__main__':
    main()

from socket import socket
from json import loads
from base64 import b64decode


def main():
    client = socket()
    client.connect(('192.168.1.2', 5566))
    # 定义一个保存二进制数据的对象
    in_data = bytes()
    # 由于不知道服务器发送的数据有多大每次接收1024字节
    data = client.recv(1024)
    while 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('/Users/Hao/' + filename, 'wb') as f:
        # 将base64格式的数据解码成二进制数据并写入文件
        f.write(b64decode(filedata))
    print('图片已保存.')


if __name__ == '__main__':
    main()

from smtplib import SMTP
from email.header import Header
from email.mime.text import MIMEText


def main():
    # 请自行修改下面的邮件发送者和接收者
    sender = 'abcdefg@126.com'
    receivers = ['uvwxyz@qq.com', 'uvwxyz@126.com']
    message = MIMEText('用Python发送邮件的示例代码.', 'plain', 'utf-8')
    message['From'] = Header('王大锤', 'utf-8')
    message['To'] = Header('老吴', 'utf-8')
    message['Subject'] = Header('示例代码实验邮件', 'utf-8')
    smtper = SMTP('smtp.126.com')
    # 请自行修改下面的登录口令
    smtper.login(sender, 'secretpass')
    smtper.sendmail(sender, receivers, message.as_string())
    print('邮件发送完成!')


if __name__ == '__main__':
    main()

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

import urllib


def main():
    # 创建一个带附件的邮件消息对象
    message = MIMEMultipart()

    # 创建文本内容
    text_content = MIMEText('附件中有本月数据请查收', 'plain', 'utf-8')
    message['Subject'] = Header('本月数据', 'utf-8')
    # 将文本内容添加到邮件消息对象中
    message.attach(text_content)

    # 读取文件并将文件作为附件添加到邮件消息对象中
    with open('/Users/Hao/Desktop/hello.txt', 'rb') as f:
        txt = MIMEText(f.read(), 'base64', 'utf-8')
        txt['Content-Type'] = 'text/plain'
        txt['Content-Disposition'] = 'attachment; filename=hello.txt'
        message.attach(txt)
    # 读取文件并将文件作为附件添加到邮件消息对象中
    with open('/Users/Hao/Desktop/汇总数据.xlsx', 'rb') as f:
        xls = MIMEText(f.read(), 'base64', 'utf-8')
        xls['Content-Type'] = 'application/vnd.ms-excel'
        xls['Content-Disposition'] = 'attachment; filename=month-data.xlsx'
        message.attach(xls)

    # 创建SMTP对象
    smtper = SMTP('smtp.126.com')
    # 开启安全连接
    # smtper.starttls()
    sender = 'abcdefg@126.com'
    receivers = ['uvwxyz@qq.com']
    # 登录到SMTP服务器
    # 请注意此处不是使用密码而是邮件客户端授权码进行登录
    # 对此有疑问的读者可以联系自己使用的邮件服务器客服
    smtper.login(sender, 'secretpass')
    # 发送邮件
    smtper.sendmail(sender, receivers, message.as_string())
    # 与邮件服务器断开连接
    smtper.quit()
    print('发送完成!')


if __name__ == '__main__':
    main()

import urllib.parse
import http.client
import json


def main():
    host  = "106.ihuyi.com"
    sms_send_uri = "/webservice/sms.php?method=Submit"
    # 下面的参数需要填入自己注册的账号和对应的密码
    params = urllib.parse.urlencode({'account': '你自己的账号', 'password' : '你自己的密码', 'content': '您的验证码是：147258。请不要把验证码泄露给其他人。', 'mobile': '接收者的手机号', 'format':'json' })
    print(params)
    headers = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'text/plain'}
    conn = http.client.HTTPConnection(host, port=80, timeout=30)
    conn.request('POST', sms_send_uri, params, headers)
    response = conn.getresponse()
    response_str = response.read()
    jsonstr = response_str.decode('utf-8')
    print(json.loads(jsonstr))
    conn.close()


if __name__ == '__main__':
    main()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/16 15:32

import socket

s = socket.socket()

s.bind(("0.0.0.0", 8080))
s.listen(10)

while True:
    sock, address = s.accept()
    buf = sock.recv(1024)
    print(buf)
    sock.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf-8"))
    sock.send("<h1>Hello World!</h1>".encode("utf-8"))
    sock.close()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/17 8:52

import logging
import socket
import threading

log_format = "%(asctime)-15s\t %(threadName)s-%(thread)s-%(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)


class CharServer:
    def __init__(self, ip: str = "127.0.0.1", port: int = 9999):
        self.sock = socket.socket()
        self.addr = (ip, port)
        self.client_conn = {}
        self.event = threading.Event()

    def start(self):
        self.sock.bind(self.addr)
        self.sock.listen()
        logging.info("启动Server!")
        threading.Thread(target=self.__accept, name="accept").start()

    def stop(self):
        for c in self.client_conn.values():
            c.close()
        self.sock.close()
        self.event.set()
        logging.info("停止Server!")

    def __accept(self):
        while not self.event.is_set():
            conn, client = self.sock.accept()
            logging.info(str(client) + "连接成功!")
            self.client_conn[client] = conn
            threading.Thread(target=self.__recv, args=(conn, client), name="recv").start()

    def __recv(self, conn, client):
        while not self.event.is_set():
            try:
                data = conn.recv(1024).decode("utf-8")
            except Exception as e:
                logging.error(str(e))
                data = "quit"
            logging.info(data)
            if data == "quit":
                self.client_conn.pop(client)
                conn.close()
                break
            msg = str(client) + ":" + data
            for c in self.client_conn.values():
                c.send(msg.encode("utf-8"))


cs = CharServer()

cs.start()

while True:
    cmd = input(">>>").strip()
    if cmd == "quit":
        cs.stop()
        break

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/17 9:22
import socket
import threading

event = threading.Event()
sock = socket.socket()

sock.connect(("127.0.0.1", 8080))


def recv_data(sock, event: threading.Event):
    while not event.is_set():
        print("发送数据：")
        print("接收信息：" + sock.recv(1024).decode("utf-8"))


def sand_data(sock):
    while True:
        data = input().strip()
        if data == "quit":
            sock.close()
            event.set()
            break
        sock.send(data.encode("utf-8"))


threading.Thread(target=sand_data, args=(sock,)).start()
threading.Thread(target=recv_data, args=(sock, event)).start()

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/17 10:36

import socket

socket = socket.socket()

socket.bind(("127.0.0.1", 8080))
socket.listen()

sock, addr = socket.accept()
f = sock.makefile(mode="rw",encoding="utf-8")
line = f.readline()
print(line)
f.write("hello {}".format(line))
f.flush()

http请求信息:
# 请求行
GET      /          HTTP/1.1 \r\n  
请求类型  路径或参数   协议版本  

# 请求头
# 响应数据的类型
Accept: text/html, application/xhtml+xml, image/jxr, */*\r\n
# 优先响应的语言
Accept-Language: zh-CN\r\n
# 浏览器版本
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko\r\n
# 数据压缩格式
Accept-Encoding: gzip, deflate\r\n
# 访问的主机名
Host: 192.168.3.35\r\n
# 连接状态
Connection: Keep-Alive
\r\n\r\n'  # 结束请求头

# 请求体 json\text\xml
数据信息

        +------------+
        | BaseServer |
        +------------+
              |
              v
        +-----------+        +------------------+
        | TCPServer |------->| UnixStreamServer |
        +-----------+        +------------------+
              |
              v
        +-----------+        +--------------------+
        | UDPServer |------->| UnixDatagramServer |
        +-----------+        +--------------------+

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
class ForkingUDPServer(ForkingMixIn, UDPServer): pass
class ForkingTCPServer(ForkingMixIn, TCPServer): pass

def finish_request(self, request, client_address):
    """Finish one request by instantiating RequestHandlerClass."""
    self.RequestHandlerClass(request, client_address, self)

#!/usr/bin/env python3 
# coding:utf-8 
# author:ZuoJie
# date:2019/5/17 11:40

import socketserver
import threading
import logging

log_format = "%(asctime)-15s\t %(threadName)s-%(thread)s-%(message)s"
logging.basicConfig(level=logging.INFO, format=log_format)

# 启动服务
addr = ("127.0.0.1", 8080)


class MyRequestHandler(socketserver.BaseRequestHandler):
    def setup(self):
        self.event = threading.Event()

    def handle(self):
        print("处理请求：")
        print(self.request)
        while not self.event.is_set():
            try:
                data = self.request.recv(1024)
            except Exception as e:
                logging.error(e)
                data = b"quit"
            if data == b"quit":
                break
            msg = "Your msg = {}".format(data.decode())
            print(msg)
            self.request.send(msg.encode())

    def finish(self):
        pass


server = socketserver.ThreadingTCPServer(addr, MyRequestHandler)

server.serve_forever()
server.server_close()