day19 socket套接字/Thread多线程

1.什么是socket
socket又叫套接字,指的是网络通信的两端,分别是服务器和客户端
socket编程指的就是通过代码实现客户端和服务器之间的通信

2.服务器的实现

import socket
- 1.创建套接字对象

server = socket.socket()

 def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None):

family: ip类型,AF_INET --IPv4 ; AF_INET6 --IPv6
type : 传输协议的类型, SOCK_STREAM -- TCP协议(可靠传输); SOCK_DGRAM -- UDP协议

- 2.绑定IP地址和端口
IP用来区分互联网上的设备
端口: 用来区分一台计算机上不同的服务(应用),值是0-65535,其中
0-1024是著名端口(避开)
bind((IP地址,端口号))   (cmd - ipconfig)
server.bind(('10.7.190.187',8000))
- 3.启动服务器(监听请求)

listen(数量)  -- 数量指的是一次性能够处理的最大请求数

server.listen(255)

- 4.让服务器一直处于运行状态

while True:
    print('开始监听...')
    # 5.等待客户端的请求
    connect,addr = server.accept()
    #程序运行到这里,会停下,等到有客户端来连接服务器,才会接着往后执行
    print(connect,addr)

    # 6.发送消息
    # send(数据)   --  发送数据,数据是二进制数据
    message = input()
    connect.send(message.encode(encoding='utf-8'))

    # 7.接收消息
    # recv(字节数) --  接收数据,并且指定一次性能接收到的最大数据值;返回接收到的数据(二进制数据)
    # 程序运行到这里会停下,直到客户端给服务器发送消息,才会接着往下执行
    data = connect.recv(1024)
    print(data.decode(encoding='utf-8'))

    # 8.关闭连接
    connect.close()

客户端

import socket
# 创建客户端套接字

# 1.创建套接字对象
client = socket.socket()

# 2.连接服务器
# connect((IP地址,端口))
client.connect(('10.7.190.187',8070))

# 3.接收消息
message = client.recv(1024)
print(message.decode(encoding='utf-8'))

# 4.发送消息
message = input()
client.send(message.encode(encoding='utf-8'))

# 5.关闭连接
client.close()

import socket

server = socket.socket()
server.bind(('10.7.190.187',8070))
server.listen(255)

# 为了让服务器一直处于运行状态
while True:
    print('开始监听...')
    connect,addr = server.accept()
    print(addr,'连接成功',sep='')
    #让客户端和服务器一直处于连接状态
    while True:
        #发送消息
        message = input('服务器:')
        connect.send(message.encode(encoding='utf-8'))
        #接收消息
        data = connect.recv(1024)
        print('客户端:',data.decode(encoding='utf-8'))
    connect.close()

import socket
client = socket.socket()
client.connect(('10.7.190.127',9005))


while True:
    # 接收消息
    data = client.recv(1024)
    print('服务器:',data.decode(encoding='utf-8'))
    #发送消息
    message = input('客户端:')
    client.send(message.encode(encoding='utf-8'))

client.close()

根据网络接口请求数据: 通过第三方库request

import requests

# 1.获取网络数据
response = requests.get('https://www.apiopen.top/satinApi?type=1&page=1')
print(response)
# a获取字符串形式的数据结果
text = response.text
print(text)
# b获取二进制形式的数据
data = response.content
print(data)
# c获取json数据
message = response.json()
print(type(message),message)
print(message['data'])

1.什么是进程:一个正在运行的应用程序;系统会给每个进程分配一个独立的内存区域,用老保存程序运行过程中产生的数据,当进程结束时,这个内存区域自动销毁

2.什么是线程

• 进程想要执行任务,就必须要有线程,每个进程默认有一个线程(主线程);其他的线程叫子线程
• 程序默认都是在主线程中执行
• 一个线程中执行多个任务,任务是串行执行的(一个一个按顺序执行)
• 一个进程中如果有多个线程,多线程执行不同的任务的时候是并行(同时执行)

3.python中怎么使用多线程

• 通过内置的threading模块来提供多线程相关技术;其中有一个Thread类,这个类的对象就是线程对象

import threading
import datetime  #时间模块
from time import sleep
def download(film):
    print('开始下载:%s time:%s' % (film,str(datetime.datetime.now())))
    sleep(5)
    print('%s下载完成 time:%s' % (film, str(datetime.datetime.now())))
#在主线程中下载两个电影,一个一个下载
download('球球')
download('大作战')

1.直接创建线程类的对象

语法:
Thread(target=函数,args=参数)   -- 创建一个线程对象,并且返回

说明:
函数 - function类型的变量,这个函数的函数体就会在子线程中执行
参数 - 元祖;参数会传给target对应的函数
'''
t1 = threading.Thread(target=download,args=('大国崛起',))
t2 = threading.Thread(target=download,args=('霸王别姬',))

# 2.让线程开始执行任务
t1.start()
t2.start()

# 某个线程出现异常,线程直接结束,进程不一定结束;所有线程都结束之后,进程结束

1.创建线程子类

from threading import Thread,current_thread
import time
from random import randint

'''
1)声明一个类继承自Thread
2)重写run方法,这个方法中的任务就是需要在子线程中执行的任务
3)创建当前类的对象,就是线程对象
4)启动子线程

'''
class DownloadThread(Thread):
    def __init__(self,film):
        super().__init__()
        self.film = film

    def run(self):

        print('开始下载%s'%self.film,current_thread())
        time1 = randint(5,10)
        time.sleep(time1)
        print('%s下载结束,耗时%d秒'%(self.film,time1))


# 2.创建线程对象
t1 = DownloadThread('霸王别姬')
t2 = DownloadThread('人在囧途')
start = time.time()
t2.start()

t1.start()

# 注意:线程对象调用start会自动在子线程中取调用run方法
#      直接用线程对象调用run方法,run方法会在主线程中执行

# 4.join的用法
'''
线程对象.join()   -- 程序执行到这里会停下(线程阻塞),直到对应线程执行结束,才继续执行后面的语句
'''
t1.join()   #对应线程结束
t2.join()
end = time.time()
print(end-start)