python高阶技巧

闭包
闭包：定义双层嵌套函数，内层函数可以访问外层函数的变量将内层函数作为外层函数的返回值，此内存函数就是闭包函数
简单闭包：
def outer(logo):
def inner(msg):
nonlocal logo # 需要使用nonlocql关键字修饰外部函数的变量才能在内部函数中修改它
logo="5627"
print(f"<{logo}>{msg}>{logo}")
return inner

fn1=outer("黑马程序员")
fn1("大家好呀")
fn1("学python就来")
优点：无需定义全局变量即可实现通过函数，持续访问，修改某个值；闭包使用的变量的所用在于函数内，难以被错误调用
缺点：由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放，一直占用内存
装饰器
装饰器就是使用创建一个闭包函数，在闭包函数内调用目标函数，可以达到不改变目标函数的同时，增加额外功能
一般写法：
def sleep():
import random
import time
print("睡眠中.....")
time.sleep(random.randint(1,5))

def outer(func):
def inner():
print("我要睡觉了")
func()
print("我起床了")
return inner
fn = outer(sleep)
fn()
糖写法：
def outer(func):
def inner():
print("我要睡觉了")
func()
print("我起床了")
return inner

@outer
def sleep():
import random
import time
print("睡眠中.....")
time.sleep(random.randint(1,5))
sleep()
设计模式
设计模式：一种编程套路
单例模式：就是对一个类，只获取其唯一的类实例对象，持续复用它
工厂模式：从原生的使用类的构造去创建对象的形式，迁移到基于工厂提供的方法去创建对象的形式
class Person:
pass
class Worker(Person):
pass
class Student(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 Student()
else:
return Teacher()
factory=Factory()
worker = factory.get_person("w")
stu = factory.get_person("S")
Teacher = factory.get_person("T")
优点：大批量创建对象的时候有统一的入口，易于代码维护；当发生修改，仅修改工厂类的创建方法即可；
多线程
进程、线程和并行执行
进程：就是一个程序，运行在系统上，便称这个程序为运行进程，并分配进行ID方便系统管理
线程：线程归属进程，一个进程可以开启多个线程，执行不同的工作
进程之间内存隔离，线程之间内存共享
并行执行：同一时间做不同的工作
多线程编程：python的多线程可以通过threading模块来实现
threading模块的使用：
thread_obj=threading.Tread(target=func) # 创建线程对象
thread_obj.start() # 启动线程
如何传参：
import time
import threading
def sing(msg):
while True:
print(msg)
time.sleep(1)

def dance(msg):
while True:
print(msg)
time.sleep(1)
if name == 'main':
sing_thread = threading.Thread(target=sing,args=("我要唱歌，哈哈哈",)) # args传入的是元组，单个参量时一定要在最后加上逗号
dance_thread = threading.Thread(target=dance,kwargs={"msg":"我在跳舞啦啦啦"}) # kwargs 传入的是字典
sing_thread.start()
dance_thread.start()
网络编程
服务端开发：
Socket：负责进程之间的网络数据传输，好比数据的搬运工
Socket服务端：等待其他进程的连结，可接收发来的消息，可以回复消息
import socket

创建socket对象

socket_server = socket.socket()

绑定ip地址和端口

socket_server.bind(("localhost",8888))

监听端口

socket_server.listen(1)

listen方法内接收一个整数传参，表示接收的链接数目

等待客户端链接

conn,address = socket_server.accept()

accept方法返回值是二元元组（链接对象，客户端地址信息）

可以通过 变量1，变量2 = socket_server.accept()的形式，直接接收二元元组内的两个元素

print(f"接收到了客服端的链接，客服端的信息是：{address}")

接收客户信息，要使用客户端和服务端的本次链接对象，而非socket_server

while True:
data=conn.recv(1024).decode("UTF-8")

recv的接收参数是缓冲区大小，一般给1024即可

recv方法的返回值是一个字节数组也就是bytes对象，不是字符串，可以通过decode方法通过UTF-8编码，将字节数组转换为字符串对象

print(f"客服端发来的消息是：{data}")

发送回复信息

mag=input("请输入你要和客户端回复的消息：").encode("UTF-8")
if mag == 'exit':
    break
conn.send(mag)

关闭链接

conn.close()
socket_server.close()
Socket客户端：主动连接服务端，可以发送消息也可以接收回复
import socket

创建socket对象

socket_client = socket.socket()

连接到服务器

socket_client.connect(("localhost",8888))

while True:
send_msg = input("请输入要发的消息：")
if send_msg == "exit":
break
socket_client.send(send_msg.encode("UTF-8"))
recv_data = socket_client.recv(1024)
print(f"服务端回复的消息是：{recv_data.decode('UTF-8')}")
socket_client.close()
正则表达式
正则表达式：使用单个字符串来描述，匹配某个句法规则的字符串，常被用来检索，替换那些符合某个模式（规则）的文本
基础匹配：
python正则表达式，使用re模块，基于re模块中三个基础方法来做正则匹配：match，search，findall 三个基础方法
re.match(匹配规则，被匹配的字符串)，从匹配字符串开头进行匹配，匹配成功返回匹配对象（包含匹配的信息），匹配不成功返回空
import re
s='python itheima'
result = re.match('python',s)
print(result)
print(result.span()) # (0,6)
print(result.group()) # python
re.search(匹配规则，被匹配字符串)，搜素整个字符串，找出匹配的，从前向后找到第一个后，就停止，不会向后
re.findall(匹配规则，被匹配字符串)，匹配整个字符串，找出全部匹配项，找不到返回空list：[]
import re
s='1python itheima python'
result = re.findall('python',s)
print(result) # ['python','python']
元字符匹配：
单字符匹配：

数量匹配：

注意：字符串的r标记表示，字符串内转移字符（""）无效，作为普通字符使用