python基础篇 -- day19

协程

协程： 微线程

'''
 greenlet
 gevent
'''
from greenlet import greenlet

def eat():
    for i in range(5):
        print('坤坤喜欢吃肉饼...')
        g2.switch()
def listen_music():
    for i in range(5):
        print('坤坤喜欢听麻婆豆腐..', i)
        g1.switch()
if __name__ == '__main__':
    g1 = greenlet(eat)
    g2 = greenlet(listen_music)
    g1.switch()

'''
gevent:
  猴子补丁

'''
import time
import gevent
from gevent import monkey

monkey.patch_all() # 加载猴子补丁，必须加

def eat():
    for i in range(5):
        print('坤坤喜欢吃肉饼...')
        time.sleep(0.1)

def listen_music():
    for i in range(5):
        print('坤坤喜欢听麻婆豆腐..', i)
        time.sleep(0.1)

if __name__ == '__main__':
    g1 = gevent.spawn(eat)
    g2 = gevent.spawn(listen_music)

    g1.join()
    g2.join()

    print('----over---')

线程间通信：

生产者与消费者：
生产者： 线程
消费者: 线程

import random
import time
from threading import Thread, current_thread
from queue import Queue


def producer(queue):
    print('{}开门啦！'.format(current_thread().name))
    foods = ['红烧狮子头', '香肠烤饭', '蒜蓉生蚝', '酸辣土豆丝', '肉饼']
    for i in range(1, 21):
        food = random.choice(foods)
        print('{}正在加工中.....'.format(food))
        time.sleep(1)
        print('加工完成可以上菜了...')
        queue.put(food)
    queue.put(None)


def consumer(queue):
    print('{}来吃饭啦'.format(current_thread().name))
    while True:
        food = queue.get()
        if food:
            print('正在享用美食:', food)
            time.sleep(0.5)
        else:
            print('{}把饭店吃光啦，走人...'.format(current_thread().name))
            break


if __name__ == '__main__':
    queue = Queue(8)
    t1 = Thread(target=producer, name='老家肉饼', args=(queue,))
    t2 = Thread(target=consumer, name='坤坤', args=(queue,))

    t1.start()
    t2.start()

线程的信号量

count 5
信号量的实现方式：
在内部有一个counter计数器，每当我们 s.acquire()一次，计数器就进行减1处理
每当 s.release()一次，计数器就进行加1处理，当计数器为0的时候其他线程的就处于
等待的状态counter的值就是同一时间可以开启线程的个数
建议使用with

import time
from threading import Thread, Semaphore, current_thread


# from multiprocessing import Semaphore,Process

def task(s):
    # s.acquire()  # 减1
    with s:
        for i in range(5):
            print('{}扫地....{}'.format(current_thread().name, i))
            time.sleep(1)
    # s.release()  # 加1


if __name__ == '__main__':
    s = Semaphore(4)
    for i in range(10):
        t = Thread(target=task, args=(s,))
        t.start()

网络编程:

• 网络各层
  端口号: 理解成端口号 识别应用
  查看端口的使用： netstat -an
  IP地址: 电脑在互联网的标识
  32位
  8 8 8 8
  1111 1111 —》255
  A类: 1.0.0.0 ~ 127.255.255.255
  B类: 128.0.0.0 ~191.255.255.255
  C类: 192.0.0.0 ~ 232.255.255.255
  …

socket

socket(简称 套接字) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：
它能实现不同电脑间的进程间通信，我们网络上各种各样的服务大多都是基于 Socket 来完成通信的；
例如我们每天浏览网页、QQ 聊天、收发 email 等等

tcp:
SOCK_STREAM --》TCP
SOCK_DGRAM --》UDP
客户端：

from socket import socket, AF_INET, SOCK_STREAM

# 表示创建了一个客户端的socket
client = socket(AF_INET, SOCK_STREAM)

con_address = ('10.0.102.94', 9001)

# 告诉客户端要连接的服务器的地址和端口号
client.connect(con_address)
while True:
    msg = input('客户端输入:')
    client.send(msg.encode('utf-8'))
    if msg == 'byebye':
        break

    # 接收服务器端的msg
    recv_msg = client.recv(512).decode('utf-8')
    print('服务器回话:', recv_msg)
    if recv_msg == 'byebye':
        break

client.close()

服务端：

from socket import socket, AF_INET, SOCK_STREAM

# 创建socket 对象
server = socket(AF_INET, SOCK_STREAM)
# 绑定端口号
server.bind(('', 9001))

# 开启监听状态
server.listen(5)

while True:
    sock, addr_info = server.accept()  # 阻塞的
    while True:
        data = sock.recv(1024).decode('utf-8')
        print('客户端说:{}'.format(data))
        if data == 'byebye':
            break
        msg = input('服务器输入:')
        sock.send(msg.encode('utf-8'))
        if msg == 'byebye':
            break

    sock.close()
    print(addr_info, '离开了！')