Python基础学习大纲(20天速成)-第四篇

一、前言

今天和大家分享一套python基础的学习路线，从入门到掌握。学完能用python解决90%逻辑上的问题。在这之前大家可以购买《python从入门到实践》第二版（这里并不是打广告昂，也没人给我广告费，是真的觉得这本书还可以）。可以结合这本书，然后收藏我下面列出的学习计划，一定可以学有所成滴。

注:没有阅读面篇幅的朋友请移步前三篇阅读，循循渐进，方可学成。

二、计划

接上一篇计划继续分享

Day16：

1.掌握json模块

这里分享一下我的观点：深刻理解json数据，json数据类型和python数据类型的区别。在前后端交互的过程中存在json数据的相互转化，前端要把json转数据，后端要把json转list或dict。已python为例，实现web开发的Django、Flask两个框架需要用到网络协议来与前端进行交互，在交互的过程中会发生数据传输，通常用的就是json数据，其重要性可想而知。

2.掌握异常概念

3.掌握Python常见的异常

今日无练习题

Day17：

1.掌握异常处理语句

(try xxx except 、try xxx except else 、try xxx except finally)

2.掌握raise抛出异常

3.掌握assert断言异常

4.掌握re模块(正则验证)

match、search、findall三者的区别，应用场景

5.掌握re模块中贪婪匹配和非贪婪匹配

6.掌握re模块中常用的函数

练习题：

"""
用户名匹配
要求:	1.用户名只能包含数字 字母 下划线
        2.不能以数字开头
        3.⻓度在 6 到 16 位范围内
"""

2、验证身份证：身份证的规则是，总共有18位，前面17位都是数字，后面一位可以是数字，也可以是小写的x，也可以是大写的X。

3、验证邮箱：邮箱的规则是邮箱名称是用数字、英文字符、下划线组成的，然后是@符号，后面就是域名了。

Day18：

1.掌握主进程、单任务的应用(if __name__ == '__main__')

2.掌握如何创建进程

3.掌握如何执行多任务

4.掌握父子进程的调用(优先级)

5.理解多个进程的全局变量

6.掌握封装进程

7.掌握进程间的通信

无需练习，读懂代码即可

import re

print(re.findall(r"a\w+", "a6753655fab_hfa45b"))
print(re.findall(r"\w+b", "a6753655fab_hfa45b"))
print(re.findall(r"a\w+b", "a6753655fab_hfa45b"))
names = 'Jack@@@@tom%%xiaomi&BOB'
print(re.split(r'[^a-zA-Z]+', names))
print(re.split(r'[@%&]+', names))
print(re.sub(r'[@%&]', '_', names))
print(re.sub(r'[@%&]+', '_', names))
print(re.subn(r'[@%&]', '_', names))
print(re.subn(r'[@%&]+', '_', names))
import os
from multiprocessing import Pool, Process, Queue
from time import sleep
import random
def run(x):
    while True:
        print(f'子进程{os.getpid()}')
        print(x ** 2)
        sleep(0.5)


if __name__ == '__main__':

    p = Process(target=run, args=(6,))
    p.start()
    while True:
        print(f'父进程{os.getpid()}')
        print('你是个大帅哥！！')
        sleep(0.5)


def run():
    print(f'子进程启动{os.getpid()}')
    print(f'子进程结束{os.getpid()}')


if __name__ == '__main__':
    print(f'父进程启动{os.getpid()}')
    sleep(2)
    p = Process(target=run)
    p.start()
    p.join()
    print(f'父进程结束{os.getpid()}')
def run(n):
    print(f"子进程{n}启动了")
    sleep(random.randint(1, 4))
    print(f"子进程{n}结束了")


if __name__ == '__main__':

    print("父进程启动")
    # 创建PooL的对象
    """
    Pool(num) , num表示可以同时执行的进程的数量
    num省略，默认值为当前操作系统的cpu核心数量
    """
    pool = Pool(5)
    for i in range(10):
        # 创建进程，并统一添加到进程池进行管理pool.apply_async(run,args=(i, ))
        pool.apply_async(run, args=(i,))
    pool.close()
    pool.join()
# a.定义一个类，继承自Process
class MyProcess(Process):
    # b.书写构造函数，调用父类的构造丽数,并定义进程的名称
    def __init__(self, name):
        Process.__init__(self)
        self.name = name

    # c.定义进程处理任务的函数，命名为run，实际表示重写父类中的run西数#注意:如果要自定义进程的子类，则必须在子类中重写run函数
    def run(self):
        # 子进程需要处理的任务的逻辑代码
        print("子进程启动")
        sleep(1)
        print("子进程结束~~~~~")


if __name__ == '__main__':
    p = MyProcess("进程11")
    p.start()
def write(queue):
    print("写数据的进程启动")
    for ch in "ABC":
        print(f"put {ch} to queue")
        # 向队列中添加数据
        queue.put(ch)
        sleep(1)
    print("写数据的进程结束~~~~")


def read(queue):
    print("读数据的进程启动")
    for _ in range(3):
        value = queue.get(True)
        print(f"get {value} from queue")
        sleep(1)
    print("读数据的进程结束~~~~")


if __name__ == '__main__':
    print("父进程启动")
    sleep(2)
    queue = Queue()
    p1 = Process(target=write, args=(queue,))
    p2 = Process(target=read, args=(queue,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    sleep(2)
    print("父进程结束！~~~~")
# 线程
import threading, time


def run():
    print(f"子线程{threading.current_thread().name}启动")
    time.sleep(2)
    print(f"子线程{threading.current_thread().name}结束~~")


def run1(n):
    print(n)
    print(f"子线程{threading.current_thread().name}启动")
    time.sleep(2)
    print(f"子线程{threading.current_thread().name}结束~~")


if __name__ == '__main__':
    print(f"主线程{threading.current_thread().name}启动")
    time.sleep(2)
    t = threading.Thread(target=run)
    t.start()
    time.sleep(2)
    t = threading.Thread(target=run, name='111')
    t.start()
    time.sleep(2)

Day19：

1.掌握创建线程执行多任务

2.掌握线程中的全局变量的使用

3.掌握线程锁的使用

4.掌握定时线程的使用

5.掌握线程间的通信

6.掌握生产者消费者设计模式

无需练习，读懂代码即可

import threading

# 方式一
a = 0
lock = threading.Lock()

def change(n):
    global a
    a += n
    a -= n

def run(n):
    for i in range(10000000):
        lock.acquire()
        try:
            change(n)
        finally:
            lock.release()

if __name__ == '__main__':
    t1 = threading.Thread(target=run, args=(5,))
    t2 = threading.Thread(target=run, args=(8,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(a)

# 方式二
a = 0
lock = threading.Lock()
def change(n):
    global a
    a += n
    a -= n

def run(n):
    for i in range(1000000):
        lock.acquire()
        with lock:
            change(n)

if __name__ == '__main__':
    t1 = threading.Thread(target=run, args=(5,))
    t2 = threading.Thread(target=run, args=(8,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(a)

# 定时线程 面试题
def run():
    print('hello~~~~~')

if __name__ == '__main__':
    print('主线程启动')
    t = threading.Timer(5, run)
    t.start()
import threading, timer

# 线程条件变量
cond = threading.Condition()
def run1():
    with cond:
        for i in range(0, 10, 2):
            print(threading.current_thread().name, i)
            # time.sleep(1)
            cond.wait()
            cond.notify()

def run2():
    with cond:
        for i in range(1, 10, 2):
            print(threading.current_thread().name, i)
            # time.sleep(1)
            cond.notify()
            cond.wait()

threading.Thread(target=run1).start()
threading.Thread(target=run2).start()

恭喜你已经学习了19天，俗话说的好：行百里者半九十，我们要有荷花精神和竹子精神。接下来最后一天也是最重要的，巩固Python基础知识全集。

Day20：

篇幅太长请看下一篇章。