目录
闭包
account=0
def atm(num,flag):
global account
if flag:
account=num+account
print(account)
else:
account-=num
print(account)
atm(300,True) #存入300元
atm(100,False) #取出100元
这是一个简单atm存取钱逻辑，account表示账户余额，存在问题是，account是全局变量，可以被任意访问和修改，为了解决这个问题，引入了闭包
闭包：在函数嵌套的前提下，内部函数引用外部函数的变量，并且外部函数返回了内部函数，将这个内部函数称为闭包
def out(account):
def atm(num, flag):
nonlocal account #nonlocal关键字 让外部函数参数是一个可修改的值
if flag:
account += num
print("余额",account)
else:
account -= num
print("余额",account)
return atm
atm=out(100) #起始余额是100 返回值是内部函数
atm(200,True) #存入200
atm(100,False) #取出100
这时account不是全局变量，不可以被任意访问和修改。
多线程
我们电脑可以运行多个程序，运行多个程序可以称为运行多个进程。一个进程可以多含多个线程，线程是cpu运行的基本单位。
python的多线程可以通过threading模块来实现
obj=threading.Thread(group,target,name,args,kwargs)
- group：暂时无用，未来功能的预置参数
- target：执行的任务名称
- args：以元组的形式传入参数
- kwargs：以字典形式传入参数
- name：线程名称，一般不用设置
start()方法：线程执行
import time
import threading #1、导入threading模块
def sing(**kwargs):
while True:
print(kwargs["name"],"在唱歌")
time.sleep(1)
def dance():
while True:
print("跳舞")
time.sleep(1)
if __name__=='__main__':
print("作为主函数运行")
# 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
sing=threading.Thread(target=sing,kwargs={"name":"张三"})
# 创建一个进程 这个进程执行的是跳舞这个函数
dance = threading.Thread(target=dance)
sing.start() #线程启动运行
dance.start()
主线程
在python中，主线程是第一个启动的线程。
~父线程:如果启动线程A中启动了一个线程B，A就是B的父线程。
~子线程：B就是A的子线程。
创建线程时有一个damon属性，用它来判断主线程。当daemon设置False时，子线程不会随主线程退出而退出，主线程会一直等着子线程执行完。当daemon设置True时，子线程会随主线程退出而退出，主线程结束，其他的子线程会强制退出。
import time
import threading #1、导入threading模块
num=0
def dance():
global num
while num < 10:
num = 1 + num
print("跳舞")
time.sleep(1)
count=0
def sing(**kwargs):
global count
while count<10:
count=1+count
print("在唱歌")
time.sleep(1)
threading.Thread(target=dance).start()
if __name__=='__main__':
# 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
sing=threading.Thread(target=sing,daemon=False)
sing.start() #线程启动运行
sing线程运行内启动了dance线程，sing线程就是父线程，dance线程为子线程。damon为False，两个线程交替运行，damon为True，主线程结束之后就会直接退出 ，不执行子线程
damon为True时，打印 "在唱歌" 之后，time.sleep（1）让sleep线程挂起1s，父线程运行结束，不会执行子线程
import time
import threading #1、导入threading模块
num=0
def dance():
global num
while num < 10:
num = 1 + num
print("跳舞")
time.sleep(1)
count=0
def sing(**kwargs):
global count
while count<10:
count=1+count
print("在唱歌")
time.sleep(1)
threading.Thread(target=dance).start()
if __name__=='__main__':
# 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
sing=threading.Thread(target=sing,daemon=False)
sing.start() #线程启动运行
线程阻塞
join方法，两个A，B并发运行的线程，A线程join（）之后,A线程阻塞，直到B线程运行结束之后，A线程恢复运行
import time
import threading #1、导入threading模块
class Thread(threading.Thread):
def __init__(self,name): #构造函数
threading.Thread.__init__(self)
self.name=name
def run(self) -> None: #线程运行时 直接执行 run()方法
for i in range(0,10):
print(i,self.name,time.ctime(time.time()))
thread1=Thread("线程A")
thread1.start()
for i in range(0,10):
print("线程B")
if(i==2):
thread1.join()
线程A，线程B并发运行，在线程B的i=2时，线程B阻塞，线程A一直运行，直到线程A运行结束，线程B才会恢复运行。
其他方法
run（）：用以表示线程活动的方法
start（）：启动线程
join（）：等待至线程终止
isAlive（）：返回线程是否活动的
getName（）：返回线程名称
setName() : 设置线程名称
同步锁
锁机制 让一个可变数据，在被修改期间不可以被其他线程读取，保证数据读取正确
使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间，即acquire相当于上锁，而release相当于解锁。
一个场景：两个窗口一起卖100张车票，在没有锁时，ticket数据在被窗口一修改的同时，被窗口二读取到修改前的数据，那么就会导致 这两个窗口一起卖出第i张票的情况，这是不合理的
import time
import threading #1、导入threading模块
class Thread(threading.Thread):
def __init__(self,name):
threading.Thread.__init__(self)
self.name=name
def run(self) -> None:
global ticket
while ticket > 0:
print("%s%s%d%s" % (self.name, "卖出了第", ticket, "张票"))
ticket = ticket - 1
time.sleep(1)
ticket =10 #设置全局变量初始值
thread1=Thread("窗口一")
thread1.start()
thread2=Thread("窗口二")
thread2.start()
加锁：加上同步锁，保证ticket数据在修改时，不可以被其他进程访问
import time
import threading #1、导入threading模块
class Thread(threading.Thread):
def __init__(self,name):
threading.Thread.__init__(self)
self.name=name
def run(self) -> None:
global ticket
while ticket > 0:
lock.acquire() # 加锁 保证ticket被一个线程持有 其他线程不得访问这个变量
if(ticket<=0):
break
print("%s%s%d%s" % (self.name, "卖出了第", ticket, "张票"))
ticket = ticket - 1
lock.release() # 解锁
ticket =100 #设置全局变量初始值
lock=threading.RLock() #获取锁
thread1=Thread("窗口一")
thread1.start()
thread2=Thread("窗口二")
thread2.start()网络编程
Socket（套接字）负责实现网络编程
创建服务器
"""
服务器程序
"""
# 1、导入Socket模块
import socket
# 2、创建Socket对象
service = socket.socket()
# 3、绑定 ip地址和端口
# bind() 绑定地址（host,port）到套接字， 在 AF_INET下，以元组（host,port）的形式表示地址。
service.bind(("localhost", 8888))
# 4、监听端口
# 开始 TCP 监听。参数 指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为 1，大部分应用程序设为 5 就可以了
service.listen(2) # 可连接次数2
while True:
# 5、接收客户端信息
# s.accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来 返回元组信息(con,address).con表示连接信息，address表示客户端信息
con, address = service.accept()
print("客户端信息: ", address)
# 6、接收客户端消息
# s.recv() 接收 TCP 数据，数据以字符串形式返回，bufsize 指定要接收的最大数据量。flag 提供有关消息的其他信息，通常可以忽略。
data = con.recv(1024).decode("utf-8")
if (data == "exit"):
con.send("退出".encode())
con.close()
break
# 以1024字节空间接收客户端发生的数据
print("客户端发送的数据: ", data)
# 7、服务器发送数据
str = input("服务器接受到了客户端信息，输入回应信息: ")
con.send(str.encode())
# 8、关闭连接
con.close()
service.close()
创建客户端
"""
客户端程序
"""
#1、导入socket模块
import socket
#2、创建Socket对象
service=socket.socket()
#3、开启Tcp连接
#s.connect() 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误
service.connect(("localhost",8888))
#4、发送数据 提供参数应该是byte类型
str=input("输入发送数据: ")
service.send(str.encode())
print("客户端接收服务器返回结果: ",service.recv(1024).decode("UTF-8"))
#5、关闭连接
service.close()
正则表达式
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
re 模块使 Python 语言拥有全部的正则表达式功能。
re.match函数
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 |
匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。
import re
str="hello world hi"
result=re.match("hello world",str)
print(result)
print(result.span()) #得到目标字符串 在str字符串中中匹配结果的位置
print(result.group()) #到的匹配字符串re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
函数参数说明：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 |
import re
str="hi hello world hi"
result=re.search("hello world",str)
print(result)
print(result.span()) #得到目标字符串 在str字符串中中匹配结果的位置
print(result.group()) #到的匹配字符串re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
re.findall()方法
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
正则表达式的特殊规则
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。
| 修饰符 | 描述 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地化识别（locale-aware）匹配 |
| re.M | 多行匹配，影响 ^ 和 $ |
| re.S | 使 . 匹配包括换行在内的所有字符 |
| re.U | 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. |
| 模式 | 描述 |
|---|---|
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串的末尾。 |
| . | 匹配任意一个字符（除了\n）,\. 表示匹配.本身 |
| [] | 匹配[]内的字符 |
| \w | 匹配字母数字及下划线 |
| \W | 匹配非字母数字及下划线 |
| \s | 匹配任意空白字符 |
| \S | 匹配任意非空字符 |
| \d | 匹配任意数字，等价于 [0-9] |
| \D | 匹配任意非数字 |
| \A | 匹配字符串开始 |
| \Z | 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
| \z | 匹配字符串结束 |
| * | 匹配前一个规则的字符0次到无数次 |
| + | 匹配前一个规则的字符1次到无数次 |
| ？ | 匹配前一个规则的字符0次或者1次 |
| {m} | 匹配前一个规则的字符m次 |
| {m，} | 匹配前一个规则的字符最少m次 |
| {m，n} | 匹配前一个规则的字符m次到n次 |
import re
#1、匹配账户 只能有数字或者英文字母组成 长度6-16位
rule='^[0-9a-zA-z]{6,16}$'
str="1234abajmhkkkhJ"
result=re.match(rule,str)
print("匹配结果",result)
#2、匹配QQ号 要求10位数字 第一位不是0
rule='^[1-9][0-9]{9}$' #第一位数字1-9，剩余数字0-9并且长度是9
str="9089776555"
result=re.match(rule,str)
print("匹配结果",result)
#匹配邮箱地址 10位数字 后面跟着@符号 后缀 QQ 或者 136 后面跟着.com
rule='^[0-9]{10}[@](QQ|136){1}(.com){1}$'
str="1234567890@136.com"
result=re.match(rule,str)
print("匹配结果",result)
扫一扫
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
