一、昨天作业

from re import *
# 1. 写一个正则表达式判断一个字符串是否是ip地址
#   规则：一个ip地址由4个数字组成，每个数字之间用.连接。每个数字的大小是0-255
#   255.189.10.37   正确
#   256.189.89.9    错误
"""
0-9:   \d
10-99:    [1-9]\d
100-199:   1\d\d
200-249:   2[0-4]\d
250-255:   25[0-5]
"""
num = r'\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]'
print(fullmatch(num, '256'))

ip = r'((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
print(fullmatch(ip, '256.189.89.9'))


# 2. 计算一个字符串中所有的数字的和
#   例如：字符串是：‘hello90abc 78sj-23h12.5’ 结果是90+78+12.5 = 180.5
"""
整数: [-+]?\d+
小数: 23.3, 0.34   \d+\.\d*
数字: [-+]?\d+\.?\d*
"""
all_nums = findall(r'[-+]?\d+\.?\d*', 'hel0.34lo090abc 78sj-23h12.5')

sum1 = 0
for num_str in all_nums:
    sum1 += float(num_str)

print(sum1)

"""
整数: [1-9]\d*
小数: 34.89    [1-9]\d*\.\d+
    0.34    0\.\d+
"""
all_nums = findall(r'[+-]?[1-9]\d*\.\d+|[+-]?0\.\d+|[+-]?[1-9]\d*', 'hel00.34lo090abc 78sj-23h12.5')
print(all_nums)

# 3. 验证输入的内容只能是汉字
value = input('请输入汉字字符串:')
if fullmatch(r'[\u4e00-\u9fa5]+', value):
    print('输入合法')
else:
    print('输入不合法')


# print(fullmatch(r'c:\\rapidminer\\lib\\plugs'))


print(fullmatch(r'\w*\b-\b\w*|\w*', 'back-shja'))

二、进程

import time
from datetime import datetime
import threading    # 专门提供和线程相关的操作

"""
每个进程默认都有一个线程，这个线程叫主线程； 其他的线程都叫子线程
"""


def download(film_name):
    print('开始下载: %s' % film_name, datetime.now())
    time.sleep(5)
    print('%s下载完成' % film_name, datetime.now())


# 1.单线程下载两个电影
# 在一个线程中下载两个电影：时间是两个电影下载的总和
# download('复联5')
# download('007')

# 2.线程模块
# 1)current_thread函数   -   获取当前线程

print(threading.current_thread())

# 2) Thread类
"""
Thread类的对象就是线程，所以需要子线程就创建这个类的对象

Thread(target,args,kwargs)
target - 函数, 需要在当前创建的子线程中去调用的函数
args/kwargs - 调用target中的函数需要的实参列表
"""
# a.创建线程对象
t1 = threading.Thread(target=download, args=('复联5',))
# t1 = threading.Thread(target=download, kwargs={'film_name': '复联5'})
t2 = threading.Thread(target=download, args=('007',))

# b.开始执行子线程中的任务: 线程对象.start()
"""
通过start方法，在子线程中去调用target对应的函数
"""
t1.start()
t2.start()

三、创建线程类

from threading import *
import time
from datetime import datetime

# 1.创建自己的线程类
"""
1)声明一个类继承Thread
2)实现run方法,这个方法中的任务就是需要在子线程中执行的任务


注意: 一个进程中如果有多个线程，程序会在所有的线程都结束的时候才结束;
     发生异常崩溃其实崩溃的是线程
"""


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

    def run(self):
        # print(current_thread())
        # print('在子线程中执行的代码')
        print('开始下载: %s' % self.film_name, datetime.now())
        print([1, 2][3])
        time.sleep(6)
        print('结束下载: %s' % self.film_name, datetime.now())


# 3)用子类直接创建线程对象
t1 = DownloadThread('复联4')
t2 = DownloadThread('长江7号')
# 4)通过start去执行子线程中的任务
t1.start()
t2.start()
# t1.run()    # 不能直接调用run方法,因为这样调用是在主线程中执行run方法，而不会在子线程中执行run方法

while True:
    input('>>>:')

四、服务器和客户端

# 服务器
from socket import *
from threading import *


class ChatThread(Thread):
    def __init__(self, connect: socket, address):
        super().__init__()
        self.connect = connect
        self.address = address

    def run(self):
        while True:
            self.connect.send('你好，我是余婷！'.encode())

            message = self.connect.recv(1024)
            print('%s:%s' % (self.address[0], message.decode(encoding='utf-8')))

        connect.close()


server = socket()
server.bind(('10.7.185.82', 8888))
server.listen(512)
while True:
    # 接收请求
    connect, address = server.accept()

    # 给每个请求创建一个线程，来聊天
    t = ChatThread(connect, address)
    t.start()

# 客户端
"""__author__ = 余婷"""

from socket import socket

client = socket()
client.connect(('10.7.185.82', 8888))
while True:
    message = client.recv(1024)
    print(message.decode(encoding='utf-8'))

    send_message = input('>>>')
    client.send(send_message.encode())

五、join函数

from threading import Thread
from datetime import datetime
import time
from random import randint


class DownloadThread(Thread):
    def __init__(self, name, time):
        super().__init__()
        self.name = name
        self.time = time

    def run(self):
        print('开始下载:%s' % self.name)
        time.sleep(self.time)
        print('下载结束:%s' % self.name)


t1 = DownloadThread('沉默的羔羊', 5)
t2 = DownloadThread('恐怖游轮', 7)

t2.start()
t1.start()

# 1.join
"""
如果希望某个任务是在某个线程结束后才执行，那就将这个任务的代码放在对应线程对象调用join方法的后面
"""
t1.join()
t2.join()
print('下载完成')

print('=============================')
t1 = DownloadThread('沉默的羔羊', 4)
t2 = DownloadThread('恐怖游轮', 5)
t2.start()
t2.join()
t1.start()

六、多线程并发修改同一个数据

import time
from threading import Thread, Lock

# 锁的使用:
"""
1.问题
当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来还没来得及写进去，另外一个线程进行读操作的数据安全问题。
(多个人上一个厕所，一个人进去了还没出来，另外一个人又进去的问题)
2.解决 - 加锁
1）保证每个数据对应一个锁对象
2）操作数据前加锁，数据操作完成后释放锁
"""


class Account:
    def __init__(self, name, tel, balance=50):
        self.name = name
        self.tel = tel
        self.balance = balance
        # 关联一个锁对象
        self.lock = Lock()

    def save_money(self, money):
        print('开始存钱')
        # 加锁
        self.lock.acquire()
        value = self.balance
        time.sleep(4)
        self.balance = value+money
        print('存钱成功: %.2f' % self.balance)
        # 释放锁
        self.lock.release()

    def draw_money(self, money):
        print('开始取钱')
        # 加锁
        self.lock.acquire()
        value = self.balance
        time.sleep(5)
        if value < money:
            print('取钱失败！余额不足')
            self.lock.release()
            return
        self.balance = value - money
        print('取钱成功:%.2f' % self.balance)
        # 释放锁
        self.lock.release()


acount = Account('小强', '15300022703', 10000)

# 一个线程去存钱
t1 = Thread(target=acount.save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=acount.draw_money, args=(500,))

# t1.start()
# t2.start()


print('=======================')
share_data = 1000
lock = Lock()


def add_data(value):
    lock.acquire()
    global share_data
    old_data = share_data
    time.sleep(4)
    share_data = old_data + value
    lock.release()

t1 = Thread(target=add_data, args=(200,))
t2 = Thread(target=add_data, args=(300,))
t1.start()
t2.start()

t1.join()
t2.join()

print(share_data)