【黑马程序员】Python高阶

文章目录

• 闭包
• • 定义
  • nonlocal关键字作用
  • 优缺点
  • • 优点
    • 缺点
  • 装饰器
  • • 装饰器闭包写法
• 设计模式
• • 单例模式
  • 工厂模式
  • • 优点
    • 代码示例
• 多线程
• • 基本概念
  • threading模块
• 网络编程
• • 服务端开发
  • • socket
    • socket服务端编程
  • 客户端开发
• 正则表达式
• • 正则的三个基础方法
  • • match
    • search
    • findAll
  • 元字符匹配
  • • 单字符匹配
    • 数量匹配
    • 边界匹配
    • 分组匹配

闭包

定义

• 定义双层嵌套函数，内层函数可以访问外层函数的变量
• 将内层函数作为外层函数的返回，此内层函数就是闭包函数
• 代码示例

def out_func1(label):
    def in_func1(msg):
        print(f'{label}{msg}{label}')

    return in_func1


out = out_func1("边框")
out("hello")

nonlocal关键字作用

• 在闭包函数修改外层函数的变量值
• 代码示例

def outer_func(out_num):
    def in_func(in_num):
        # 修改外层变量
        nonlocal out_num
        out_num += in_num
        print(out_num)

    return in_func

优缺点

优点

• 无需定义全局变量即可实现通过此函数，持续的访问、修改某个值
• 闭包使用的变量的作用域在函数内部，难以被错误的调用修改

缺点

• 由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放

装饰器

• 装饰器也是一种闭包
• 功能：在不破坏目标函数原有代码和功能的前提下，为目标函数增加新功能

装饰器闭包写法

• 定义一个闭包函数，在闭包函数内部
  • 执行目标函数
  • 完成功能的添加
• 代码示例

# 装饰器语法糖写法
def outer1(func):
    def inner():
        print("start")
        func()
        print("end")

    return inner


@outer1
def sleep1():
    import random
    import time
    print("sleep...")
    time.sleep(random.randint(1, 5))


sleep1()

设计模式

单例模式

• 一个类无论获取多少次类对象，都只提供一个具体的实例
• 好处：节省创建类对象的开销和内存开销
• 使用场景：当一个类只有一个实例，而客户可以从一个众所周知的访问节点访问它
• 代码示例

# 在一个文件中定义要实现单例的类
# *_*coding:utf-8 *_*

class StrTools:
    pass


str_tools = StrTools()

# 在另一个文件中导入单例对象
# *_*coding:utf-8 *_*
from 单例模式 import str_tools

s1 = str_tools
s2 = str_tools
print(s1)
print(s2)

工厂模式

优点

• 大批量创建对象的时候有统一的入口，易于代码维护
• 当发生修改，进修改工厂类的创建方法即可
• 符合现实世界的模式，即由工厂来制作产品

代码示例

# *_*coding:utf-8 *_*
class Person:
    pass


class Worker(Person):
    pass


class Sturent(Person):
    pass


class Teacher(Person):
    pass


class Factory:
    def get_person(self, p_type):
        if p_type == 'w':
            return Worker()
        elif p_type == 's':
            return Sturent()
        else:
            return Teacher()


factor = Factory()
worler = factor.get_person('w')
student = factor.get_person('s')
teacher = factor.get_person('t')

多线程

基本概念

• 进程：程序在操作系统内运行，即成为一个运行进程
• 线程：进程内部可以有多个线程，程序的运行本质上是由进程内部的线程在实际工作的
• 并行执行
  • 多个进程同时在运行，即不同的程序同时运行，称之为：多任务并行执行
  • 一个进程内的多个线程同时在运行，称之为：多线程并行执行

threading模块

• Python的多线程可以通过threading模块来实现
• 语法

import threading

thread_obj = threading.Thread([group[, target[, name[, args[, kwargs]]]]])
group：预留参数，暂未使用
target：执行的目标任务名
args：以元组的方式给执行任务传参
kwargs：以字典的方式给执行任务传参
name：线程名，一般不设置

# 启动线程
thread_obj.start()

• 代码示例

# *_*coding:utf-8 *_*

import time
import threading


def sing(msg):
    while True:
        print(f"{msg}")
        time.sleep(1)


def dance(msg):
    while True:
        print(f'{msg}')
        time.sleep(1)


if __name__ == '__main__':
    # 创建一个sing线程,通过元组方式传参
    sing_thread_obj = threading.Thread(target=sing, args=("sing sing sing",))
    # 创建一个dance线程，通过字段方式传参
    dance_thread_obj = threading.Thread(target=dance, kwargs={"msg": "dance dance dance"})
    # 启动两个线程
    sing_thread_obj.start()
    dance_thread_obj.start()

网络编程

服务端开发

socket

• socket是进程之间的一个通信工具，socket负责进程之间的网络数据传入
• socket服务端：等到其它进程的连接、可接受发来的消息，可以回复消息
• socket客户端：主动连接服务端、可以发送消息，可以接收消息

socket服务端编程

• 步骤
  • 创建socket对象
  • 绑定socket_server到指定IP和地址
  • 服务端开始监听端口
  • 接收客户端连接，获取连接对象
  • 客户端连接后，通过recv方法，接收客户端发送的消息
  • 通过conn,调用send方法可以回复消息
  • conn和socket_server对象调用close方法关闭连接
• 代码示例

# *_*coding:utf-8 *_*
import socket

# 创建socket对象
socket_servre = socket.socket()
# 绑定socket_server到指定IP和地址
socket_servre.bind(("127.0.0.1", 9000))
# 服务端开始监听端口,参数表示允许的链接数量，超出会等待，可以不填，不填会自动设置一个合理值
socket_servre.listen(10)
# 接收客户端连接，获得连接对象，accept是阻塞方法
# conn为客户端和服务端的连接对象
# addr为客户端的地址信息
conn, addr = socket_servre.accept()
print(f'Accept，address：{addr}')
# 客户端连接后，通过recv方法，接收客户端发送的消息
while True:
    # recv方法的返回值是字节数组（Bytes），可以通过decode使用UTF-8解码为字符串
    # recv方法的传参是buffsize，缓冲区大小
    data = conn.recv(1024).decode("UTF-8")
    if data == 'exit':
        break
    print(f'接收到发送的数据：{data}')
    # 将字符串编码为字节数组对象
    conn.send(input('输入要回复给客户端的信息：').encode("UTF-8"))
conn.close()
socket_servre.close()

客户端开发

• 步骤
  • 创建socket对象
  • 连接到服务端
  • 发送消息
  • 接收返回消息
  • 关闭连接
• 代码示例

# *_*coding:utf-8 *_*
import socket

# 创建socket对象
socket_client = socket.socket()
# 连接到服务端
socket_client.connect(('127.0.0.1', 9000))
# 发送消息
while True:
    send_msg = input("请输入要发送的消息：")
    if send_msg == 'exit':
        break
    # 将字符串转化为字节数组
    socket_client.send(send_msg.encode('UTF-8'))
    # 接收返回消息
    recv_data = socket_client.recv(1024).decode('UTF-8')
    print(f'服务端回复的消息：{recv_data}')

# 关闭客户端连接
socket_client.close()

正则表达式

正则的三个基础方法

• Python正则表达式，使用re模块，并基于match、search、findall来做正则匹配

match

• 语法：re.match(匹配规则，被匹配的字符串)
• 从被匹配字符串开头进行匹配，匹配成功返回匹配对象，匹配不成功返回空
• 特点：从头开始匹配
• 代码示例

# *_*coding:utf-8 *_*
import re

# 从开头开始匹配，如果开头都不匹配直接返回None
# 匹配成功
s = "python itheima python itheima python itheima"
result = re.match('python', s)
print(result)
# span 匹配成功所在的字符串下标
print(result.span())
# 匹配成功的值是什么
print(result.group())

# 匹配不成功
s1 = "1python itheima python itheima python itheima"
result = re.match('python', s1)
print(result)

search

• 语法:search(匹配规则, 被匹配字符串)
• 功能：搜索整个字符串，找出匹配的。从前向后，找到第一个后，就停止，不会继续向后
• 特点：只匹配一个
• 代码示例

# *_*coding:utf-8 *_*
import re

# 匹配不成功
s1 = "1python itheima python itheima python itheima"
result = re.search('python', s1)
print(result)
# span找到后的下标位置
print(result.span())
# 找到后匹配的字符串
print(result.group())

findAll

• 语法：findall(匹配规则, 被匹配字符串)
• 功能：匹配整个字符串，找出全部匹配项，找不到返回空list
• 代码示例

# *_*coding:utf-8 *_*
import re

# 匹配不成功
s1 = "1python itheima python itheima python itheima"
result = re.findall('python', s1)
print(result)

元字符匹配

单字符匹配

数量匹配

边界匹配

分组匹配