python之开发笔记

1、图标插件pyecharts

pyecharts - A Python Echarts Plotting Library built with love.

Document

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

#导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
#得到折线图对象
line = Line()
#添加x轴数据
line.add_xaxis(["中国","美国","英国"])
#添加y轴
line.add_yaxis("GDP",[30,20,10])#设置全局配置
line.set_global_opts(title_opts=TitleOpts(title="标题",pos_left="center",pos_bottom="1%"),legend_opts = LegendOpts(is_show=True),toolbox_opts=ToolboxOpts(is_show=True),visualmap_opts=VisualMapOpts(is_show=True)
)#生成图表
line.render()执行上面代码，会上传对应的html图标页面

2、mysql连接插件pymysql

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

from pymysql import Connectionconn = Connection(host="localhost",port=3306,# autocommit=True, # 自动提交user="root",password="root",database="test",charset="utf8"
)print(conn.get_server_info())
# 获取游标对象
cursor = conn.cursor()
# 选择数据库  与上面的   database="test",  二选1
#conn.select_db("test")  
# 执行sql
# cursor.execute("create table test_pumysql(id int);")# 查询
cursor.execute("select * from user")
results = cursor.fetchall()
print(results)
for r in results:print(r)cursor.execute("insert into user values( 31,'test', '123',234234)")
# 提交
conn.commit()
# 关闭连接
conn.close()

防止sql注入，构造参数列表，不直接sql字符串拼接

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

params = ""
cursor.execute("select * from user where name=%s",params)

3、数据分析插件pyspark

其中部分功能需要配合hadoop使用

下载hadoop安装包 tar.gz

解压到任意位置

在python代码中使用os模块配置：os.environ['HADOOP_HOME']=''

下载winutils.exe，并放到hadoop解压文件夹的bin目录内

下载hadoop.dll，并放到system32文件夹内

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import osfrom pyspark import SparkConf,SparkContextos.environ['PYSPARK_PYTHON'] = 'C:\Users\ASUS\PycharmProjects\pythonProject\venv\Scripts\python.exe'
os.environ['HADOOP_HOME']=''
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)# 读取文件转换为rdd
file_rdd =sc.textFile("D:/aaa.txt")rdd1.Map();#解嵌套 例如：[[],[],[]] => []
rdd1.flatMap();
#按key分组，进行聚合操作
rdd1.reduceByKey()
#对数据进行过滤
rdd1.filter(lambda num: num % 2 == 0)
print(rdd1.collect())
#去重，无需参数
rdd2 = rdd1.distinct()
#进行排序   参数：方法，排序方式，分区
final_rdd=rdd1.sortBy(方法,ascending=false,numPartitions=1)
#将rdd转换为list对象，即可以进行输出
rdd1.collect()
#对rdd进行两两聚合
rdd1.reduce(lambda a,b: a+b)
#取出rdd中前n个元素
rdd1.take(3)
#统计rdd中有多少条数据
rdd1.count()sc.stop()

4、数据输出

需要下载hadoop安装包，解压，然后配置

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

os.environ['HADOOP_HOME']='解压文件的路径'

下载winutils.exe，并放入hadoop解压文件夹的bin目录

下载hadoop.dll，并放入system32文件夹内

要输出文件只有一个，则需要设置conf.set("spark.default.parallelism","1")

或者在创建rdd的时候设置rdd1 = sc.parallelize([1,2,3,4],numSlices=1)，即numSlices=1

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
conf.set("spark.default.parallelism","1")
sc = SparkContext(conf=conf)#输出到文件   输出的是文件夹，里面有多个文件
rdd3=sc.parallelize([1,2,3,4,5])
rdd3.saveAsTextFile("../data/oupt/test")

5、闭包

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

在闭包函数中想要修改外部函数的变量值，需要用nonlocal声明这个外部变量

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

def account_create(initial_amount=0):def amt(num,deposit = True):nonlocal initial_amountif deposit:initial_amount+=numprint(f"存款：+{num},账户余额：{initial_amount}")else:initial_amount -=numprint(f"取款：-{num},账户余额：{initial_amount}")return amtatm = account_create()
atm(100)
atm(200)
atm(-100)

6、装饰器

6.1 方法装饰器

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

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

# 1、装饰器的一般写法（闭包）
def outer(func):def inner():print("我睡觉了......")func()print("我起床了......")return innerdef sleep():import randomimport timeprint("睡眠......")time.sleep(random.randint(1,5))
# print("我睡觉了......")
# sleep()
# print("我起床了......")fn = outer(sleep)
fn()# 2、装饰器的快捷写法（语法糖）
def outer(func):def inner():print("我睡觉了......")func()print("我起床了......")return inner@outer
def sleep():import randomimport timeprint("睡眠......")time.sleep(random.randint(1,5))sleep()

不定长参数： *args,**kwargs 表示可以传入任意的参数和键值对的参数，例如（1，2,3，age="18"）

多装饰器的使用

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

# 装饰器1
def check1(fn):def inner():print("登陆验证1.。。。")fn()return inner
# 装饰器2
def check2(fn):def inner():print("登陆验证2.。。。")fn()return inner# 被装饰的函数
@check1
@check2  # 靠的最近的先起到装饰作用
def comment():print("发布言论")comment()

带参数的装饰器

装饰器的外部函数只能传一个参数

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

# 装饰器
def logging(flag):def check1(fn):def inner(num1,num2):if flag =="+":print("--正在努力加法计算---")elif flag=="-":print("--正在努力减法计算---")result = fn(num1,num2)return resultreturn inner#返回装饰器return check1# 被带有参数的装饰器装饰的函数
@logging('+')
def comment(a,b):result = a + breturn result# print(result)result = comment(1,3)
print(result)

6.2 类装饰器

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

# 定义一个类，实现_call_方法
class Check(object):def __init__(self,fn):self.__fn = fndef __call__(self, *args, **kwargs):print("我是call方法")self.__fn()#被装饰的函数
@Check
def comment():print("发表言论")comment()

property属性

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

# ======1、装饰器方式=======================
class Person(object):def __init__(self):self.__age = 0#获取属性@propertydef age(self):return self.__age#修改属性@age.setterdef age(self,new_age):self.__age = new_age# @property
p = Person()
print(p.age)
#修改属性
p.age = 100
print(p.age)#  =====2、类属性方式=================================
class Person(object):def __init__(self):self.__age = 0#获取属性def get_age(self):return self.__age#修改属性def set_age(self,new_age):if new_age>=150:print("年龄错误")else:self.__age = new_ageage = property(get_age,set_age)p = Person()
print(p.age)
#修改属性
p.age = 100
print(p.age)

7、设计模式

7.1 单例模式

保证一个类只能有一个实例，并提供一个访问它的全局访问点

即创建一个实例后，不管在哪调用都是同一个

节省内存、节省创建对象的开销

7.2工厂模式

将对象的创建转换为由特定的工厂方法来创建

8 、多进程

进程优缺点：

优点：可以用多核

缺点：资源开销大

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import multiprocessing
import timedef work():for i in range(3):print("work",i)time.sleep(0.2)def work2():for i in range(3):print("work2 ",i)time.sleep(0.2)if __name__ == '__main__':work_process = multiprocessing.Process(target=work)work_process2 = multiprocessing.Process(target=work2)work_process.start()work_process2.start()

主进程会等待子进程结束才结束，设置进程守护，则可以让子进程跟着主进程一起结束

9、多线程

线程优缺点：

优点：资源开销小

缺点：不能使用多核

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import threading
import timedef work():for i in range(3):print("work",i)time.sleep(0.2)def work2():for i in range(3):print("work2 ",i)time.sleep(0.2)if __name__ == '__main__':work_thread = threading.Thread(target=work)work2_thread = threading.Thread(target=work2)work_thread.start()work2_thread.start()

主线程会等待子线程结束才结束，设置线程守护，则可以让子线程跟着主线程一起结束

设置 daemon=True 参数

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

work_thread = threading.Thread(target=work,daemon=True)

或者在start前（但是此方法已经过时）

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

work_thread.setDaemon(True)

线程间的执行顺序是无序的

获取线程信息

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

current_thread = threading.current_thread()

线程间共享全局变量，但是可能导致全局变量数据错误的问题

解决办法：线程同步去操作同一个变量

9.1互斥锁

对共享数据进行锁定，保证同一时刻只有一个线程去操作

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import threading#全局变量
g_num = 0# 对 g_num进行加操作
def sum_num1():#上锁mutex.acquire()for i in range(1000000):global g_numg_num +=1#解锁mutex.release()print("g_num1:",g_num)# 对 g_num进行加操作
def sum_num2():# 上锁mutex.acquire()for i in range(1000000):global g_numg_num += 1# 解锁mutex.release()print("g_num2:", g_num)if __name__ == '__main__':# 创建锁mutex = threading.Lock()#创建子线程sum1_thread = threading.Thread(target=sum_num1)sum2_thread = threading.Thread(target=sum_num2)#启动线程sum1_thread.start()sum2_thread.start()

9.2死锁

使用互斥锁的时候，要注意在合适的位置释放锁，不然就会导致死锁

10、TCP服务：socket

10.1、客户端

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socketif __name__ == '__main__':# 1、创建客户端套接字对象   AF_INET表四ipv4  SOCK_STREAM表示YCP传输协议类型tcp_client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)# 2、和服务端套接字建立连接tcp_client_socket.connect(("192.168.233.1",8080))# 3、发送数据tcp_client_socket.send("你好!".encode(encoding="utf-8"))# 4、接收数据   recv会阻塞等待数据的到来    recv表示每次接收数据的大小，单位是字节recv_data = tcp_client_socket.recv(1024)print(recv_data.decode(encoding="utf-8"))# 5、关闭客户端套接字tcp_client_socket.close()

10.2 服务端

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socketif __name__ == '__main__':# 1、创建服务端套接字对象tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#设置端口复用   不设置的话，断开后再连接会提示端口已经在用tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))#第一个ip地址设置为“”，默认为本机ip地址tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量tcp_server_socket.listen(128)# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址conn_socket,ip_port = tcp_server_socket.accept()print("客户端地址：",ip_port)# 5、接收数据recv_data = conn_socket.recv(1024)print("接收到的数据：",recv_data.decode())# 6、发送数据conn_socket.send("客户端你的数据我接收到了".encode())# 7、关闭套接字conn_socket.close()tcp_server_socket.close()

当客户端的套接字调用close后，服务器端的revc会解阻塞，返回的数据长度为0，服务端可以通过返回数据的长度来判断客户端是否已经下线，反之服务端关闭套接字，客户端的recv也会解阻塞，返回的数据长度也为0

10.3 多任务TCP服务端

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socketif __name__ == '__main__':# 1、创建服务端套接字对象tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#设置端口复用tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))#第一个ip地址设置为“”，默认为本机ip地址tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量tcp_server_socket.listen(128)while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址conn_socket,ip_port = tcp_server_socket.accept()print("客户端地址：",ip_port)# 5、接收数据recv_data = conn_socket.recv(1024)print("接收到的数据：",recv_data.decode())# 6、发送数据conn_socket.send("客户端你的数据我接收到了".encode())# 7、关闭套接字conn_socket.close()tcp_server_socket.close()

上面方式需要一个客户端完成一个完整请求后，其他的请求才能进入，无法同时处理多个客户端的请求，所以需要使用下面多线程的方式

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socket
import threading#处理客户端函数
def handle_client(conn_socket):# 5、接收数据recv_data = conn_socket.recv(1024)print("接收到的数据：", recv_data.decode())# 6、发送数据conn_socket.send("客户端你的数据我接收到了".encode())# 7、关闭套接字conn_socket.close()if __name__ == '__main__':# 1、创建服务端套接字对象tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#设置端口复用tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))#第一个ip地址设置为“”，默认为本机ip地址tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量tcp_server_socket.listen(128)while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址conn_socket,ip_port = tcp_server_socket.accept()print("客户端地址：",ip_port)# 使用多线程去接收多个客户端的请求sub_thread = threading.Thread(target=handle_client,args=(conn_socket,))sub_thread.start()tcp_server_socket.close()

11、web服务器

11.1静态web服务器

使用python自带的webfwq使用 python3 -m http.server 端口号这个命令即可，端口号可以省略，则使用默认端口号

自己开发

单用户请求，多任务需要改成多线程

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socketif __name__ == '__main__':# 1、创建服务端套接字对象tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#设置端口复用tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))#第一个ip地址设置为“”，默认为本机ip地址tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量tcp_server_socket.listen(128)while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址conn_socket,ip_port = tcp_server_socket.accept()print("客户端地址：",ip_port)# 5、接收数据client_request_data = conn_socket.recv(1024).decode()print("接收到的数据：", client_request_data)# 获取用户请求资源的路径request_data = client_request_data.split(" ")print(request_data)#请求资源路径request_path = request_data[1]if request_path=="/":request_path = "/index.html"# 读取固定页面数据，把页面数据组装成http响应报文数据发送给浏览器try:with open("./static"+request_path,"rb") as f:filer_data = f.read()except Exception as e:#返回404错误数据# 应答行response_line = "HTTP/1.1 404 Not Found\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = "404 Not Found sorry"# 应答数据response_data = (response_line + response_header + "\r\n" + response_body).encode()# 6、发送数据conn_socket.send(response_data)else:# 应答行response_line = "HTTP/1.1 200 OK\r\n"# 应答头response_header = "Server:pwb\r\n"#应答体response_body = filer_data# 应答数据response_data = (response_line+response_header+"\r\n").encode()+response_body# 6、发送数据conn_socket.send(response_data)finally:# 7、关闭套接字conn_socket.close()tcp_server_socket.close()

多线程实现多客户端同时请求

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socket
import threadingdef handle_client_request(conn_socket):# 5、接收数据client_request_data = conn_socket.recv(1024).decode()print("接收到的数据：", client_request_data)# 获取用户请求资源的路径request_data = client_request_data.split(" ")print(request_data)#判断客户端是否关闭if len(request_data)==1:conn_socket.close()return # 请求资源路径request_path = request_data[1]if request_path == "/":request_path = "/index.html"# 读取固定页面数据，把页面数据组装成http响应报文数据发送给浏览器try:with open("./static" + request_path, "rb") as f:filer_data = f.read()except Exception as e:# 返回404错误数据# 应答行response_line = "HTTP/1.1 404 Not Found\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = "404 Not Found sorry"# 应答数据response_data = (response_line + response_header + "\r\n" + response_body).encode()# 6、发送数据conn_socket.send(response_data)else:# 应答行response_line = "HTTP/1.1 200 OK\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = filer_data# 应答数据response_data = (response_line + response_header + "\r\n").encode() + response_body# 6、发送数据conn_socket.send(response_data)finally:# 7、关闭套接字conn_socket.close()if __name__ == '__main__':# 1、创建服务端套接字对象tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#设置端口复用tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))#第一个ip地址设置为“”，默认为本机ip地址tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量tcp_server_socket.listen(128)while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址client_socket,ip_port = tcp_server_socket.accept()print("客户端地址：",ip_port)sub_thread  = threading.Thread(target=handle_client_request,args=(client_socket,))sub_thread.start()# tcp_server_socket.close()   不注释的话一个请求完成就会关闭程序

11.2 面向对象开发

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socket
import threadingclass HttpWebServer:def __init__(self):# 1、创建服务端套接字对象self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 设置端口复用self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))# 第一个ip地址设置为“”，默认为本机ip地址self.tcp_server_socket.bind(("", 8080))# 3、设置监听   128：表示服务端等待排队连接的最大数量self.tcp_server_socket.listen(128)def handle_client_request(self,conn_socket):# 5、接收数据client_request_data = conn_socket.recv(1024).decode()print("接收到的数据：", client_request_data)# 获取用户请求资源的路径request_data = client_request_data.split(" ")print(request_data)# 判断客户端是否关闭if len(request_data) == 1:conn_socket.close()return# 请求资源路径request_path = request_data[1]if request_path == "/":request_path = "/index.html"# 读取固定页面数据，把页面数据组装成http响应报文数据发送给浏览器try:with open("./static" + request_path, "rb") as f:filer_data = f.read()except Exception as e:# 返回404错误数据# 应答行response_line = "HTTP/1.1 404 Not Found\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = "404 Not Found sorry"# 应答数据response_data = (response_line + response_header + "\r\n" + response_body).encode()# 6、发送数据conn_socket.send(response_data)else:# 应答行response_line = "HTTP/1.1 200 OK\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = filer_data# 应答数据response_data = (response_line + response_header + "\r\n").encode() + response_body# 6、发送数据conn_socket.send(response_data)finally:# 7、关闭套接字conn_socket.close()def start(self):while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址client_socket, ip_port = self.tcp_server_socket.accept()print("客户端地址：", ip_port)sub_thread = threading.Thread(target=self.handle_client_request, args=(client_socket,))sub_thread.start()if __name__ == '__main__':# 创建服务器对象my_web_server = HttpWebServer()my_web_server.start()

命令行启动动态绑定端口号导入import sys

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

import socket
import threading
import sysclass HttpWebServer:def __init__(self,port):# 1、创建服务端套接字对象self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 设置端口复用self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)# 2、绑定IP地址和端口# tcp_server_socket.bind(("192.168.233.1",8080))# 第一个ip地址设置为“”，默认为本机ip地址self.tcp_server_socket.bind(("", port))# 3、设置监听   128：表示服务端等待排队连接的最大数量self.tcp_server_socket.listen(128)def handle_client_request(self,conn_socket):# 5、接收数据client_request_data = conn_socket.recv(1024).decode()print("接收到的数据：", client_request_data)# 获取用户请求资源的路径request_data = client_request_data.split(" ")print(request_data)# 判断客户端是否关闭if len(request_data) == 1:conn_socket.close()return# 请求资源路径request_path = request_data[1]if request_path == "/":request_path = "/index.html"# 读取固定页面数据，把页面数据组装成http响应报文数据发送给浏览器try:with open("./static" + request_path, "rb") as f:filer_data = f.read()except Exception as e:# 返回404错误数据# 应答行response_line = "HTTP/1.1 404 Not Found\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = "404 Not Found sorry"# 应答数据response_data = (response_line + response_header + "\r\n" + response_body).encode()# 6、发送数据conn_socket.send(response_data)else:# 应答行response_line = "HTTP/1.1 200 OK\r\n"# 应答头response_header = "Server:pwb\r\n"# 应答体response_body = filer_data# 应答数据response_data = (response_line + response_header + "\r\n").encode() + response_body# 6、发送数据conn_socket.send(response_data)finally:# 7、关闭套接字conn_socket.close()def start(self):while True:# 4、等待客户端的连接请求  accept阻塞等待 ，返回一个用以和客户端socket，客户端的地址client_socket, ip_port = self.tcp_server_socket.accept()print("客户端地址：", ip_port)sub_thread = threading.Thread(target=self.handle_client_request, args=(client_socket,))sub_thread.start()def main():# 获取执行python程序的终端命令行参数print(sys.argv)if len(sys.argv != 2:print("格式错误 python3 xxx.py 9090")return#判断是否整型if not sys.argv[1].isdigit():print("格式错误 python3 xxx.py 9090")returnport = sys.argv[1]# 创建服务器对象my_web_server = HttpWebServer(port)my_web_server.start()if __name__ == '__main__':main()

12、with语句和上下文管理

作用：例如文件操作时，自动调用关闭文件操作，即使出现异常也会自动调用关闭

--javascripttypescriptshellbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

with open("1.txt","r") as f:rdata = f.read()print(rdata)

13、正则表达式

14、连接sqlserver

pip install pyodbc

15、生成和安装项目锁使用的包

生成包版本文件: pip freeze > requirements.txt

部署时安装: pip install -r requirements.txt