python高级
面向对象高级
私有属性和私有方法
私有属性和私有方法不能被子类继承，也不能被直接调用
在属性、方法前 加 __ 就变成了私有属性、私有方法
class Test1:
__str1='ABCDE' #私有属性
def __method1(self):
print('这是一个私有方法')
def method2(self):
print(self.__str1) #可以在对外开放的方法里调用私有属性
self.__method1() #可以在对外开放的方法里调用私有方法
t = Test1()
print(t.__str1) #私有属性不能直接被调用
t.__method1() #私有方法不能直接被调用
t.method2()
多态
class Animal:
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
print("Dog barks")
class Cat(Animal):
def make_sound(self):
print("Cat meows")
def make_animal_sound(animal):
animal.make_sound()
dog = Dog()
cat = Cat()
make_animal_sound(dog) # Output: Dog barks
make_animal_sound(cat) # Output: Cat meows
#例子2：当我们在一个餐馆中，服务员会根据顾客点的不同菜品来上菜。这里可以使用多态来实现。
#首先，我们定义一个菜品的基类Dish，并给它一个serve方法：
class Dish:
def serve(self):
pass
#定义几个具体的菜品类，它们都继承自Dish类，并重写了serve方法
class Steak(Dish):
def serve(self):
print("上菜：牛排")
class Pasta(Dish):
def serve(self):
print("上菜：意大利面")
class Salad(Dish):
def serve(self):
print("上菜：沙拉")
#定义服务员类Waiter，有一个serve_dish方法，接收一个Dish类型的参数，并调用参数对象的serve方法：
class Waiter:
def serve_dish(self, dish):
dish.serve()
#创建一些菜品对象，并让服务员上菜
steak = Steak()
pasta = Pasta()
salad = Salad()
waiter = Waiter()
waiter.serve_dish(steak) # Output: 上菜：牛排
waiter.serve_dish(pasta) # Output: 上菜：意大利面
waiter.serve_dish(salad) # Output: 上菜：沙拉
单例模式
#一般情况下，类可以生成任意个实例，而单例模式只生成一个实例
class Single:
def __init__(self):#初始化方法 用于给实例的参数赋予
pass
def __new__(cls,*args,**kwargs):#构造方法，用于生成实例
if not hasattr(cls,'obj'): #判断类当中有没有实例对象 #hasattr 反射
cls.obj=object.__new__(cls) #如果没有就新建一个实例对象
return cls.obj #返回实例
s1=Single()
s2=Single()
print(s1 == s2) #True
反射
九、Pytest框架
命名规范
#.py测试文件名必须以test_开头，或以_test结尾
#测试类必须以Test开头，且类中不能有__init__方法
#测试方法或函数以test_开头
#断言必须用assert
assert 1 == 1 #断言成功不做操作，断言失败，抛出AssertionError
安装pytest
pip install pytest
引入pytest库
import pytest
示例代码
import os
import pytest
class Test1：
def test_001(self):
print('*****test_001正在执行*****')
assert 1 == 2
def test_002(self):
print('*****test_002正在执行*****')
assert 2 == 2
if __name__ == 'main':
pytest.main(['test_pytest01.py','-s']) #-s表示允许执行print语句
数据驱动（参数化）
class Test1:
@pytest.mark.parametrize('result,real_result',([1,2],[2,3],[9,9]))
def test_1(self,result,real_result):
assert result == real_result
装饰器
@pytest.fixture(scope='session') #待补充
#scope='function' 默认缺省级别
#scope='class' 类级别
#scope='module' 模块级别
#scope='session' 使用这个级别时，将fixture的内容写到conftest.py文件中，目录下的所有文件都使用这个配置
allure报告
#下载allure.zip
#解压allure.zip到文件目录
#将allure报告的目录/bin全路径加到环境变量path中
#pip install allure-pytest
#验证在cmd 键入allure看输出信息
import pytest
import allure
@allure.epic('项目名称')
@allure.feature('业务模块名称')
class Test001：
@allure.story('接口名称')
@allure.title('用例标题1')
def test_c001(self):
assert 1 == 2
@allure.story('接口名称2')
@allure.title('用例标题2')
def test_c002(self):
assert 1 == 1
if __name__ == '__main__':
pytest.main([__file__,'sv','--alluredir','./report/report','--clean-alluredir'])
os.system('allure serve ./report/report')
十、浅拷贝、深拷贝
赋值
list1=[1,2,3,4,5,6,[7,8]]
list1_new=list1 #两者指向的是同一个对象
list1[0]=98
print(list1,id(list1)) #[98, 2, 3, 4, 5, 6, [7, 8]] 5102720
print(list1_new,id(list1_new)) #[98, 2, 3, 4, 5, 6, [7, 8]] 5102720
浅拷贝
import copy
list1=[1,2,3,4,5,6,[7,8]]
list1_new=copy.copy(list1)#浅拷贝，生成了一个新的对象，子列表仍是同一个对象
list1[0]=98 #修改list1的值，不会影响list1_new的值
list1[-1][0]=1993 ##修改list1子列表的值，list1_new子列表的值也会改变
print(list1,id(list1),id(list1[-1]))
#[98, 2, 3, 4, 5, 6, [1993, 8]] 6755968 6758272
print(list1_new,id(list1_new),id(list1_new[-1]))
#[1, 2, 3, 4, 5, 6, [1993, 8]] 34703296 6758272
#切片，等价于浅拷贝
list1=[1,2,3,4,5,6,[7,8]]
list1_new=list1[:]
list1[0]=98
list1[-1][0]=1993
print(list1,id(list1),id(list1[-1]))
#[98, 2, 3, 4, 5, 6, [1993, 8]] 51255040 51273792
print(list1_new,id(list1_new),id(list1_new[-1]))
#[1, 2, 3, 4, 5, 6, [1993, 8]] 54036544 51273792
深拷贝
import copy
list1=[1,2,3,4,5,6,[7,8]]
list1_new=copy.deepcopy(list1)#深拷贝，列表和子列表都是新的对象
list1[0]=98 #修改list1的值，不会影响list1_new的值
list1[-1][0]=1993 #修改list1子列表的值，不会影响list1_new子列表的值
print(list1,id(list1),id(list1[-1]))
#[98, 2, 3, 4, 5, 6, [1993, 8]] 8197824 8200064
print(list1_new,id(list1_new),id(list1_new[-1]))
#[1, 2, 3, 4, 5, 6, [7, 8]] 11372416 11372864
十一、常见面试题
冒泡算法
#冒泡排序：
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
# 示例用法
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的数组：")
for i in range(len(arr)):
print(arr[i], end=" ")
九九乘法表
for i in range(10):
for j in range(1,i+1):
print(f'{j}*{i}={j*i}\t' ,end='')
print()
文件读写操作
# -*- coding: utf-8 -*-
"""
解压该压缩包，里面 包含了两个文件。 一个叫 'gbk编码.txt',
该文件是gbk编码的。
另一个文件叫 'utf8编码.txt', 该文件是utf8编码的。
两个文件里面的内容都包含中文。
要求大家编写一个python程序，该程序做到以下2点
1. 将两个文件内容读出， 合并内容到一个字符串中，
并能用print语句将合并后的内容正确显示
2. 然后，程序用中文提示用户“请输入 新文件的名称”，
用户输入文件名可以包含中文
将上面合并后的内容存储到一个新文件中，以utf8格式编码。
新文件的文件名就是上面用户输入的名字。
"""
utf8Path = "D:\desktop\utf8编码.txt"
gbkPath = "D:\desktop\gbk编码.txt"
newStr = ""
with open(utf8Path, "r", encoding="utf8") as f:
newStr += f.read()
newStr += "\n"
with open(gbkPath, "r", encoding="gbk") as f:
newStr += f.read()
print(newStr)
fileName = input("请输入>>>")
with open("./%s" % fileName, "w", encoding="utf8") as f:
f.write(newStr)
装饰器
# -*- coding: utf-8 -*-
# 现已实现以下功能 my_log、my_name、my_shopping_mall 函数
# 要求编写装饰器，为 my_log、my_name、my_shopping_mall 函数加上认证的功能，要求登录成功一次，后续的函数都无需再输入用户名和密
# 码
# 账户名密码来自字典变量
# 补充知识: token
# token的意思是“令牌”，是服务端生成的一串字符串（这里我们可以随意指定一个字符串），作为客户端进行请求的一个标识。
# 当用户第一次登录后，服务器生成一个 token 并将此 token返回给客户端，以后客户端只需带上这个 token 来请求数据即可，无需再次带上
# 用户名和密码
import uuid
user_dict = { # 存用户名和密码
"user1": "123",
"user2": "123",
}
token = None
def auth(func):
def inner(*args, **kwargs):
global token
if token: # token 有效
func(*args, **kwargs)
else: # token 无效
userName = input("请输入用户名>>>")
userPwd = input("请输入密码>>>")
if userName in user_dict and userPwd == user_dict[userName]:
func(*args, **kwargs)
token = str(uuid.uuid4()) # 生产一个 uuid 最为 token
else:
print("账户名密码错误")
return inner
def auth1(func):
userName = ""
def inner(*args, **kwargs):
global token
global userName
if token: # token 有效
func(userName)
else: # token 无效
userName = input("请输入用户名>>>")
userPwd = input("请输入密码>>>")
if userName in user_dict and userPwd == user_dict[userName]:
func(userName)
token = str(uuid.uuid4()) # 生产一个 uuid 最为 token
else:
print("账户名密码错误")
return inner
@auth
def my_log():
print('this is my_log')
@auth1 # my_name = auth1(my_name)
def my_name(name):
print('欢迎登陆', name)
@auth
def my_shopping_mall():
print("商城购物")
while True:
choose_num = input("\n\n1、查看日志\n2、我的信息\n3、我的商城\n请输入操作选项(输入 q 退出)>>>")
if choose_num == "q" or choose_num == "Q":
break
elif choose_num == "1":
my_log()
elif choose_num == "2":
my_name("张三")
elif choose_num == "3":
my_shopping_mall()
else:
print("输入不合法")
多线程
# -*- coding: utf-8 -*-
"""
先阅读下面关于Python requests 库的文章 ，了解 使用它去获取一个网页内容的方法。
http://docs.python-requests.org/zh_CN/latest/user/quickstart.html
然后编写一个python程序，创建两个子线程，分别到下面的网址获取文本内容
http://mirrors.163.com/centos/6/isos/x86_64/README.txt
http://mirrors.163.com/centos/7/isos/x86_64/0_README.txt
主线程等待这个两个子线程获取到信息后，将其内容依次合并后存入名为 readme89.TXT 的文件中
"""
import requests
import threading
url1 = "http://mirrors.163.com/centos/6/isos/x86_64/README.txt"
url2 = "http://mirrors.163.com/centos/7/isos/x86_64/0_README.txt"
newStr = "" # 初始化一个字符串
r = threading.Lock()
def foo(url):
r.acquire() # 上锁
global newStr
newStr += requests.get(url).text
r.release() # 释放
t1 = threading.Thread(target=foo, args=(url1,))
t2 = threading.Thread(target=foo, args=(url2,))
t1.start()
t2.start()
t1.join()
t2.join()
with open("./readme89.txt", "w", encoding="utf8") as f:
f.write(newStr)
十二、正则表达式
import re
#从一段字符串中，提取需要的字符，返回值为列表[]
str1='待到山花烂漫时，她在丛中笑'
print(re.findall('到(.*?)烂',str1)) #前后的值都确定了 结果为：['山花']
print(re.findall('到(.*?)',str1)) # 结果为：[]
# .*? 为懒惰匹配，在符合规则的情况下，尽可能的少取值
print(re.findall('到(.*)',str1)) # .*为贪婪匹配 结果为：['山花烂漫时，她在丛中笑']
str2='asdaedsfdasdsfeace'
print(re.findall('a(.*?)e',str2))
print(re.findall('a(.*)e',str2))
#多行匹配 re.S
str3='''Helloadsadasdasdasdasdasdsadasfegsger
fdsfsdgds sdgdsgg dsgfsd gdsgs
dgfsdgdsgdsgsdhrwhreWorld'''
print(re.findall('Hello(.*?)World',str3,re.S))
十三、网络爬虫
import re
import requests
import os
url='' #需要爬取的网址
req = requests.get(url)
book_name=re.findall('<h1>(.*?)</h1>',req.text)[] #提取书名
mulu=re.findall('title="(第.*?)"target=_blank"',req.text)[] #提取目录列表
#for i in range(12,len(mulu)):
# print(mulu[i])
muluwangzhi=re.findall('<a herf="/d/3020/(.*?).html" title="第',req.text)
#目录作为键，网址作为值，用字典存储
dict1={}
for i in range(12,len(mulu)):
dict1[mulu[i]]=f'{url}{muluwangzhi[i]}.html'
#获取正文内容
if not os.path.exists(f'D://{book_name}'):
od.mkdir(f'D:/{book_name})
count=1
for k,v in dict1.items():
if count>5: #取五章
break
else:
req=requests.get(v) #获取正文网页的内容
neirong=re.findall('id="chaptercontent">(.*?)本章完',req.text,re.S)[0]
neirong=neirong.replace('<br/>','\n')
with open(f'D:/{book_name}/{count:003}_{k}.txt','w+') as file1:
file1.write(neirong)
print(f'第{count}章写入完毕')
count+=1
#-*- coding: utf-8 -*-
import re
import requests
import os
url = 'http://www.mjqfy.gov.cn/' # 需要爬取的网址
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
}
resp = requests.get(url, headers=headers)
ah_list = re.findall('<a href="" target="_blank" style="text-align:center;">(.*?)</a>', resp.text) # 案号列表
judge_list = re.findall('<td width="20%">(.*?)</td>', resp.text) # 提取主审法官', '开庭地点'
# judge = judge_list[0] #主审法官字段
# place = judge_list[1] #开庭地点字段
judgename_place = judge_list[2:] #['邱达昌', '409审判庭']
judge_name = judgename_place[::2] #取的是法官名的值 列表
place =judgename_place[1::2] #取的是开庭地点的值 列表
kt_time = re.findall('<td width="22%">(.*?)</td>', resp.text)[1:] #
new_list = [item for item in zip(ah_list, judge_name, place, kt_time)]
print(ah_list)
print(judge_name)
print(place)
print(kt_time)
print(new_list) #[('（2023）粤1402民初2867号', '邱达昌', '409审判庭', '2023-10-25 09:00')]
十四、python对外部程序的调用
import os
os.system('ipconfig') #打开操作系统的命令行窗口键入ipconfig回车
#若pycharm输出乱码
#settings->editor->file encodings->global encoding 改为gbk
#os.system 为阻塞式调用，即执行时python程序需等待其结束才能继续运行
#os.system 执行成功后的返回值为0，失败时的返回值为1
#subprocess
import subprocess
subprocess.check_output('ipconfig')#将结果以字符形式返回 bytes类型
output_bytes = subprocess.check_output('ipconfig')
print(output_bytes)#输入为：b'\r\nWindows IP \xc5\xe4\xd6\xc3\r\n\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xb1\xbe\xb5\xd8\xc1\xac\xbd\xd3:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::c0a5:3c9a:e95a:8e8b%11\r\n IPv4 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 192.168.30.194\r\n \xd7\xd3\xcd\xf8\xd1\xda\xc2\xeb . . . . . . . . . . . . : 255.255.255.0\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : 192.168.30.1\r\n\r\n\xcb\xed\xb5\xc0\xca\xca\xc5\xe4\xc6\xf7 isatap.{6416EFAC-2131-4AF2-ACDE-5863AC0FDE30}:\r\n\r\n \xc3\xbd\xcc\xe5\xd7\xb4\xcc\xac . . . . . . . . . . . . : \xc3\xbd\xcc\xe5\xd2\xd1\xb6\xcf\xbf\xaa\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n'
print(output_bytes.decode('gbk'))#输出为：Windows IP 配置
以太网适配器 本地连接:
连接特定的 DNS 后缀 . . . . . . . :
本地链接 IPv6 地址. . . . . . . . : fe80::c0a5:3c9a:e95a:8e8b%11
IPv4 地址 . . . . . . . . . . . . : 192.168.30.194
子网掩码 . . . . . . . . . . . . : 255.255.255.0
默认网关. . . . . . . . . . . . . : 192.168.30.1
隧道适配器 isatap.{6416EFAC-2131-4AF2-ACDE-5863AC0FDE30}:
媒体状态 . . . . . . . . . . . . : 媒体已断开
连接特定的 DNS 后缀 . . . . . . . :
subprocess.Popen('ipconfig') #直接输出结果，且为非阻塞进程
十五、装饰器
#作用域
#嵌套作用域、局部作用域、全局作用域、内置作用域（python系统预先定义的）
#找变量时，现在自己层找，找不到向外层找，但不会由外向内找
#就近性原则
#高阶函数-函数即对象，函数对象的调用仅仅比其他对象多了一个()
#1、函数名可以被赋值给其他变量
def fun1():
print("你好你好")
a = fun1
a() #你好你好
print(a) #<function fun1 at 0x00000000006271F0>
#2、函数名当做参数传递给其他函数
def qin(func):
func()
def p():
print('666')
qin(p) #666
#3、函数名可以作为返回值
def chok():
def money():
print("发工资啦")
return money
a = chok() #用a接收chok函数的返回值
a()#发工资啦
################# 4、闭包 ###################
#在一个内部函数里，对在外部作用域(但不是全局作用域)的变量进行引用，这个内部函数就被认为是闭包
def outer():
x = 888
#内部函数
def inner():
print(x) #引用了外部作用域(但不是全局作用域)的变量x
return inner
#相当于 a=outer(),a()
outer()() #888
#5、装饰器
#装饰器本质是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能；装饰器的返回值也是一个函数对象。它经常用于有切面的需求场景，如：插入日志，性能测试、事务处理、缓存、权限校验等。使用装饰器，可以抽离出大量与函数功能无关的雷同代码并继续复用。
#总结：装饰器的作用就是为已经存在的对象添加额外的功能
#装饰器之所以在python中使用方便，归因为python的函数能够像普通对象一样：函数名当做参数传递给其他函数、函数名可以被赋值给其他变量、函数名可以作为返回值、可以被定义在另一个函数内。
#场景一：在自动化测试过程中，增加需求，计算每条用例执行的时间
import time
def fee():
print("此处是自动化代码执行")
time.sleep(2)
def show_time(func):
begin_time = time.time()
func()
end_time = time.time()
print("用例总计运行时间为",end_time - begin_time)
show_time(fee)#以上代码虽然未改变原有的fee()函数，但是调用时的函数名称变了
#所以改为以下代码
import time
def fee():
print("此处是自动化代码执行")
time.sleep(2)
def show_time(func):
def inner():
begin_time = time.time()
func()
end_time = time.time()
print("用例总计运行时间为", end_time - begin_time)
return inner
fee = show_time(fee)#将fee作为参数传递进去，会替代inner方法里的func(),最终返回inner
fee()
#6、语法糖
import time
#装饰函数，即装饰器
def show_time(func):
def inner():
begin_time = time.time()
func()
end_time = time.time()
print("用例总计运行时间为", end_time - begin_time)
return inner
#被装饰函数
@show_time #语法糖
def fee():
print("此处是自动化代码执行")
time.sleep(2)
fee()#使用语法糖后，直接调用fee()即可
#fee = show_time(fee) === @show_time
十六、多线程
#并发与并行
并发：逻辑上具备同时处理多个任务的能力
并行：物理上在同一个时刻执行多个并发任务
#线程与进程
一个进程管着多个线程，一个进程有且至少有一个线程
#子线程和主线程的运行逻辑：
1- 如果主线程结束了，子线程也需要强行结束
把子线程设置成守护线程
2- 在子线程完成运行之前，主线程将一直被阻塞
join()
import threading,time
def bee(func):
# print(func)
for i in range(10):
time.sleep(1)
print(func)
#创建线程实例，target 指向子线程函数名-不带括号，args 为 target 指向的函数传参-元组形式,一个参数
t1 = threading.Thread(target=bee, args=('看电影',))# 生成了一个线程实例
t2 = threading.Thread(target=bee, args=('谈对象',))# 生成了另一个线程实例
#启动线程
t1.start()
t2.start()
t1.join()#在子线程完成运行之前，这个子线程的父线程将一直被阻塞
t2.join()
for i in range(10):
time.sleep(1)
print('启动数据检查')
#不使用join()时 看电影、谈对象、启动数据检查 三个线程交替运行
# 使用join()时 看电影、谈对象 两个线程交替运行完成后 启动数据检查 开始运行运行
------------------------------------------------------------------------------------
#守护线程
import threading,time
def bee(func):
# print(func)
for i in range(10):
time.sleep(1)
print(func)
#创建线程
t1 = threading.Thread(target=bee, args=('看电影',))
t2 = threading.Thread(target=bee, args=('谈对象',))
#创建守护线程-必须声明在start()方法前
t1.setDaemon(True)
t2.setDaemon(True)#当主线程(吃饱了打印完)执行完毕，会提前结束子线程(看电影、谈对象)
#启动线程
t1.start()
t2.start()
for i in range(5):
time.sleep(1)
print('肚子饿，要吃饭')
print('吃饱了')
------------------------------------------------------------------------------------
#同步锁
import threading,time
account_balance = 500
def bee(num):
global account_balance
balance = account_balance
time.sleep(1)
balance = balance + num
#计算结束，将结果存数据库或通过接口返回新的余额
account_balance = balance #如果要在函数体内修改全局变量 使用global声明
t1 = threading.Thread(target=bee, args=(10000,)) #银行打钱
t2 = threading.Thread(target=bee, args=(-300,)) #花钱
#启动线程
t1.start()
t2.start()
t1.join()
t2.join()
print('最终余额:', account_balance)
# 以上代码每次运行的结果都是不对的
---------------------------------------------------------------------------------
#使用同步锁
#同步锁只能使用一次，且上锁和解锁必须对应
import threading,time
account_balance = 500
r = threading.Lock() #锁
def bee(num):
r.acquire()#上锁
global account_balance
balance = account_balance
time.sleep(1)
balance = balance + num
#计算结束，将结果存数据库或通过接口返回新的余额
account_balance = balance #如果要在函数体内修改全局变量 使用global声明
r.release() #解锁
t1 = threading.Thread(target=bee, args=(10000,)) #银行打钱
t2 = threading.Thread(target=bee, args=(-300,)) #花钱
#启动线程
t1.start()
t2.start()
t1.join()
t2.join()
print('最终余额:', account_balance)
---------------------------------------------------------------------------------
#死锁
#两个线程分别占用一部分资源，两个线程同时等待对方的资源
import threading,time
lockA = threading.Lock() #面试官的锁
lockB = threading.Lock() #小明的锁
def deadlock1():#面试官
lockA.acquire() #面试官上锁
print("请解释什么是死锁")
time.sleep(1)
lockB.acquire() #小胡上锁
print("发offer")
#解锁
lockA.release()
lockB.release()
def deadlock2():#小胡
lockB.acquire() #小胡上锁
print("请给我offer")
time.sleep(1)
lockA.acquire() #面试官上锁
print("向面试官解释什么是死锁")
time.sleep(1)
# 解锁
lockA.release()
lockB.release()
t1 = threading.Thread(target=deadlock1)
t2 = threading.Thread(target=deadlock2)
t1.start()
t2.start()
#递归锁
#递归锁可以解决死锁的问题，可以在只读的操作中使用，提高效率
#每次上锁，内部的计数器+1，每次解锁，内部的计数器-1.计数器可以>=0
import threading,time
lock = threading.RLock() #递归锁/可重入锁
def deadlock1():#面试官
lock.acquire() #面试官上锁
print("请解释什么是死锁")
time.sleep(1)
lock.acquire() #小胡上锁
print("发offer")
#解锁
lock.release()
lock.release()
def deadlock2():#小胡
lock.acquire() #小胡上锁
print("请给我offer")
time.sleep(1)
lock.acquire() #面试官上锁
print("向面试官解释什么是死锁")
time.sleep(1)
# 解锁
lock.release()
lock.release()
t1 = threading.Thread(target=deadlock1)
t2 = threading.Thread(target=deadlock2)
t1.start()
t2.start()
全局解释器锁（Global Interpreter Lock，GIL）是一种在 CPython（Python 的标准实现）中存在的机制。它是一个互斥锁，用于保护多线程下的 Python 解释器免受并发访问的影响。具体来说，GIL确保在任何给定时间只有一个线程在解释器中执行 Python 字节码。
GIL的存在对多线程的影响是：
1. **限制多核利用**：由于只有一个线程能够执行 Python 字节码，所以对于 CPU 密集型任务，多线程并不能充分利用多核处理器的性能。这意味着在多线程中运行 CPU 密集型任务时，性能可能比预期要差。
2. **适用于I/O密集型任务**：GIL对I/O密集型任务的影响相对较小，因为当一个线程在等待 I/O 操作完成时，GIL会被释放，允许其他线程继续执行。这使得多线程在处理并发的网络请求、文件操作等I/O密集型任务时仍然有用。
3. **不适用于CPU密集型任务**：如果你有CPU密集型任务，你可能会更倾向于使用多进程来充分利用多核处理器，因为每个进程都有自己的独立解释器和GIL，从而避免了GIL的限制。
总之，GIL是 Python 的一种限制，它在特定情况下可以对多线程的性能产生负面影响。如果你需要充分利用多核处理器来执行并行的 CPU 密集型任务，考虑使用多进程或其他编程语言来绕过GIL。对于I/O密集型任务，多线程仍然是一个有效的解决方案。需要注意的是，某些实现（如Jython或IronPython）没有GIL，因此在这些实现中，多线程可以更好地利用多核处理器。
十七、socket编程
OSI模型（Open Systems Interconnection Model），即开放式系统互联模型，是一个用于描述计算机网络中不同协议层次之间互相通信的参考模型。这个模型将网络通信分解为七个不同的层次，每个层次都负责不同的功能，并定义了它们之间的界限。这有助于不同的网络设备和协议能够互相协作和交流。以下是OSI模型的七个层次，从底层到顶层：
当按从顶层到底层的顺序解释OSI模型时，你可以按照如下方式描述每个层次：
1. 应用层（Application Layer）：应用层是最顶层，包括了各种应用程序和用户接口，如网页浏览器、电子邮件客户端、文件传输程序等。它提供了用户与计算机网络之间的交互界面。
2. 表示层（Presentation Layer）：表示层关注数据的格式化和编解码，以确保不同系统间的数据可以正确解释。它也包括了数据加密和压缩，用于保护数据的隐私和减小传输的带宽需求。
3. 会话层（Session Layer）：会话层建立、管理和终止应用程序之间的会话，以便在通信中保持一致性和同步。它提供了会话控制和恢复功能，确保在通信过程中的可靠性。
4. 传输层（Transport Layer）：传输层负责端到端的通信，包括数据的分段、错误检测和纠正，以确保可靠的数据传输。它还提供流量控制和拥塞控制功能。
5. 网络层（Network Layer）：网络层处理数据包的路由和转发，以确保数据包能够从源节点传输到目标节点。它负责寻址和选择最佳路径，也包括分片和重组数据包。
6. 数据链路层（Data Link Layer）：数据链路层将数据帧从网络层传递到物理层，执行错误检测和纠正，以及数据帧的流控制。它还管理数据的访问，确保多个设备可以共享传输媒体。
7. 物理层（Physical Layer）：物理层是最底层，负责定义物理媒体和数据传输的方式，包括电压、电流、传输介质等。它关注的是如何在物理层面传输数据比特。
这种从顶层到底层的描述方式有助于理解每个层次的功能和其在网络通信中的位置。
#网络通信要素
ip地址、端口号、传输协议
有了这三个要素尽可以进行socket编程
#socket通信流程：
当将服务器端和客户端的Socket通信流程串联在一起时，整个过程如下：
**服务器端流程**：
1. **创建服务器套接字**：服务器应用程序创建一个套接字并绑定到特定的IP地址和端口。
2. **监听连接**：服务器套接字调用`listen()`函数，开始监听传入的连接请求。
3. **等待客户端连接**：服务器通过`accept()`函数等待客户端的连接请求。一旦有客户端请求连接，`accept()`函数会返回一个新的套接字，代表与客户端的通信套接字。
4. **接收数据**：服务器可以使用通信套接字的`recv()`函数接收从客户端发送的数据。通常，这个过程是在一个循环中执行的，以接收多个数据包。
5. **处理数据**：服务器处理接收到的数据，进行必要的操作，如解析请求、执行业务逻辑，然后准备响应。
6. **发送数据**：服务器使用通信套接字的`send()`函数将响应发送给客户端。
7. **关闭通信套接字**：一旦通信完成，服务器通过`close()`函数关闭与客户端的通信套接字。这不会关闭服务器监听套接字，允许服务器继续等待新的连接。
**客户端流程**：
1. **创建客户端套接字**：客户端应用程序创建一个套接字。
2. **连接服务器**：客户端使用套接字的`connect()`函数指定服务器的IP地址和端口号，以建立连接。
3. **发送数据**：客户端使用`send()`函数发送数据给服务器，通常是一个请求。
4. **接收数据**：客户端可以使用`recv()`函数接收从服务器发送的响应数据。
5. **关闭连接**：一旦通信完成，客户端使用`close()`函数关闭与服务器的连接。
这两个流程一起描述了客户端和服务器之间的Socket通信。服务器在监听并接受连接请求，然后与客户端通信，处理请求，发送响应，最后关闭连接。客户端连接到服务器，发送请求，接收响应，然后关闭连接。这是一个基本的Socket通信示例，实际应用中可能会涉及更复杂的逻辑和安全性措施。
--------------------------------------------------------------------------------------
#基于python实践
#客户端代码
# -*- coding: utf-8 -*-
import socket
#创建socket对象
sk = socket.socket()
# 发起连接
sk.connect(("127.0.0.1", 13000))#服务端的ip和端口
# 发送数据
client_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
sk.sendall(client_input.encode("utf8"))
# 接收数据
data = sk.recv(1024)
print("服务端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
sk.close()
#服务端代码
import socket
# 套接字 就是一个socket对象，sk就是一个套接字
sk = socket.socket() # 创建socket对象
sk.bind(("127.0.0.1", 13000))# 绑定ip地址和端口号，使用元组进行传参
sk.listen() # 监听请求
print("服务端已启动")
# 等待传入连接，在连接成功之前，保持阻塞状态
# 连接成功之后，会返回一个新的套接字（conn）和客户端的ip地址与端口号
conn, addr = sk.accept()
print("客户端的地址是：", addr)
# 接收数据
data = conn.recv(1024)
print("客户端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
server_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
conn.sendall(server_input.encode("utf8"))
conn.close()
sk.close()
------------------------------------------------------------------------------------
#文件上传与下载
#将客户端图片上传到服务端文件夹
#服务器
# -*- coding: utf-8 -*-
import os,socket
sk = socket.socket() # 创建socket对象
sk.bind(("127.0.0.1", 13000))# 绑定ip地址和端口号，使用元组进行传参
sk.listen() # 监听请求
print("服务端已启动")
def get_file(sk_obj):
'''
接收文件
:param sk_obj:socket对象
:return:
'''
# 接收文件大小(数字)
file_size = int(sk_obj.recv(1024).decode('utf-8'))
sk_obj.sendall(b'ok')#避免粘包
# 接收文件名字
file_name = sk_obj.recv(1024).decode('utf-8')
sk_obj.sendall(b'ok')#避免粘包
# 接收文件
with open('./%s' %file_name, 'wb') as f:
while file_size > 0:
f.write(sk_obj.recv(1024))
def post_file(sk_obj, file_path):
'''
发送数据
:param sk_obj: socket对象
:param file_path: 文件路径
:return:
'''
# 发送文件大小(数字)
file_size = os.stat(file_path).st_size #获取文件大小
sk_obj.sendall(str(file_size)).encode('utf-8')
sk_obj.recv(1024) #避免粘包
# 发送文件名称
file_name = os.path.split(file_path)[1]
sk_obj.sendall(file_name.encode('utf-8'))
sk_obj.recv(1024) #避免粘包
# 发送文件内容
with open(file_path,'rb') as f:
while file_size > 0:
sk_obj.sendall(f.read(1024))
file_size -= 1024
conn, addr = sk.accept()
#接收文件
get_file(conn)
conn.close()
sk.close()
#客户端
import os,socket
sk = socket.socket()
sk.connect('127.0.0.1', 13000)
def post_file(sk_obj, file_path):
'''
发送数据
:param sk_obj: socket对象
:param file_path: 文件路径
:return:
'''
# 发送文件大小(数字)
file_size = os.stat(file_path).st_size #获取文件大小
sk_obj.sendall(str(file_size)).encode('utf-8')
sk_obj.recv(1024) #避免粘包
# 发送文件名称
file_name = os.path.split(file_path)[1]
sk_obj.sendall(file_name.encode('utf-8'))
sk_obj.recv(1024) #避免粘包
# 发送文件内容
with open(file_path,'rb') as f:
while file_size > 0:
sk_obj.sendall(f.read(1024))
file_size -= 1024
path = "D:666.png"
post_file(sk,path)
------------------------------------------------------------------------------------
#不间断聊天
# -*- coding: utf-8 -*-
import socket
# 套接字 就是一个socket对象，sk就是一个套接字
# 创建socket对象
sk = socket.socket()
sk.bind(("127.0.0.1", 13000))# 绑定ip地址和端口号，使用元组进行传参
# 监听请求
sk.listen()
print("服务端已启动")
while True:
print("此时空闲。。。。。。。。。。。。。。。。。。")
# 等待传入连接，在连接成功之前，保持阻塞状态
# 连接成功之后，会返回一个新的套接字（conn）和客户端的ip地址与端口号
conn, addr = sk.accept()
print("客户端的地址是：", addr)
while True:
# 接收数据
data = conn.recv(1024)
if data == "quit": break
print("客户端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
server_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
conn.sendall(server_input.encode("utf8"))
conn.close()
sk.close()
#用户A
# -*- coding: utf-8 -*-
import socket
#创建socket对象
sk = socket.socket()
# 发起连接
sk.connect(("127.0.0.1", 13000))#服务端的ip和端口
while True:
# 发送数据
client_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
sk.sendall(client_input.encode("utf8"))
if client_input == "quit": break
# 接收数据
data = sk.recv(1024)
print("服务端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
sk.close()
#用户B
# -*- coding: utf-8 -*-
import socket
#创建socket对象
sk = socket.socket()
# 发起连接
sk.connect(("127.0.0.1", 13000))#服务端的ip和端口
while True:
# 发送数据
client_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
sk.sendall(client_input.encode("utf8"))
if client_input == "quit": break
# 接收数据
data = sk.recv(1024)
print("服务端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
sk.close()
------------------------------------------------------------------------------------
#并发聊天
#老板
# -*- coding: utf-8 -*-
import socketserver
class Mylow(socketserver.BaseRequestHandler):
def handle(self):# 这个函数就是业务逻辑代码，且只能叫handle
print("现在有空了")
while True:
# 接收数据
data = self.request.recv(1024).decode('utf8') #conn.recv(1024)
if data == 'quit':break
print(data)
inp = input('>>>')
self.request.sendall(inp.encode('utf8'))
self.request.close()
server = socketserver.ThreadingTCPServer(("127.0.0.1", 13000), Mylow)
server.serve_forever()
#员工A
# -*- coding: utf-8 -*-
import socket
#创建socket对象
sk = socket.socket()
# 发起连接
sk.connect(("127.0.0.1", 13000))#服务端的ip和端口
while True:
# 发送数据
client_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
sk.sendall(client_input.encode("utf8"))
if client_input == "quit": break
# 接收数据
data = sk.recv(1024)
print("服务端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
sk.close()
#员工B
# -*- coding: utf-8 -*-
import socket
#创建socket对象
sk = socket.socket()
# 发起连接
sk.connect(("127.0.0.1", 13000))#服务端的ip和端口
while True:
# 发送数据
client_input = input("请输入>>>")
# 发送数据，由于字符串不能直接在网络中传输，所以需要使用utf8进行编码
sk.sendall(client_input.encode("utf8"))
if client_input == "quit": break
# 接收数据
data = sk.recv(1024)
print("服务端", data.decode("utf8"))# 将接收到的字符串进行utf8转码输出
sk.close()
十八、py操作linux
# linux服务器需要开启ssh服务
安装SSH客户端：
打开终端。
在终端中运行以下命令以安装SSH客户端：
对于Debian/Ubuntu系统：
sudo apt update
sudo apt install openssh-client
对于CentOS/Fedora系统：
sudo yum update
sudo yum install openssh-clients
安装SSH服务：
打开终端。
在终端中运行以下命令以安装SSH服务：
对于Debian/Ubuntu系统：
sudo apt update
sudo apt install openssh-server
对于CentOS/Fedora系统：
sudo yum update
sudo yum install openssh-server
启动SSH服务：
在终端中运行以下命令以启动SSH服务：
对于Debian/Ubuntu系统：
sudo service ssh start
对于CentOS/Fedora系统：
sudo systemctl start sshd
#安装paramiko库
pip install paramiko -i https://pypi.douban.com/simple/--trusted-host pypi.douban.com
import paramiko
# 连接到远程服务器
ssh = paramiko.SSHClient()#创建ssh对象
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())#设置连接方式
ssh.connect('linux服务器ip', username='username', password='password')#发起连接
# 执行命令并获取输出
stdin, stdout, stderr = ssh.exec_command('ls')
#stdin：标准输入文件
#stdout：标准输出文件
#stderr：标准错误文件
print(stdout.read())#将执行结果打印出来
# 关闭SSH连接
ssh.close()
------------------------------------------------------------------------------------
#如何从远程linux下载文件到本地
import paramiko
# 连接到远程服务器
ssh = paramiko.SSHClient()#创建ssh对象
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())#设置连接方式
ssh.connect('linux服务器ip', username='username', password='password')#发起连接
sftp = ssh.open_sftp()
#下载linux上的文件到本地
sftp.get("远程linux上的文件路径","本地存储的路径")
#将本地文件上传到linux服务器
sftp.put("本地文件存储的路径","远程linux上的存储路径")
# 关闭SSH连接
ssh.close()
十九、python操作数据库
通过封装数据库操作类完成操作
#mysql
import pymysql
class DBConnection:
def __init__(self,ip='192.168.30.118',port=3306,user='ssfw',
passwd='nj1234',db='public_service_333',charset='utf8'):
self.db=pymysql.connect(host=ip,port=port,user=user,passwd=passwd,
database=db,charset=charset)#创建连接
self.cursor=self.db.cursor()#创建游标
def select(self,sql,match='all'):
'''
查询操作
:param sql: 查询sql语句
:param match: 匹配规则
:return: 查询结果
'''
self.cursor.execute(sql)
if match=='all':
result=self.cursor.fetchall()
elif match=='one':
result=self.cursor.fetchone()
else:
result='请输入正确的匹配规则'
return result
#修改操作
def update(self,sql):
'''
修改操作
:param sql:修改sql语句 如果失败就回滚
:return:
'''
try:
self.cursor.execute(sql)
except Exception as e:
self.db.rollback()
print(f'mysqldb error:{e}')
self.db.commit()
#插入操作
def insert(self,sql):
'''
增加操作，如果失败就回滚
:param sql:增加sql语句
:return:
'''
try:
self.cursor.execute(sql)
except Exception as e:
self.db.rollback()
print(f'mysqldb error:{e}')
self.db.commit()
#删除操作
def delete(self,sql):
'''
删除操作 如果失败就回滚
:param sql:删除sql语句
:return:
'''
try:
self.cursor.execute(sql)
except Exception as e:
self.db.rollback()
print(f'mysqldb error:{e}')
self.db.commit()
def exit_(self):
'''
游标和连接关闭
:return:
'''
self.cursor.close()
self.db.close()
if __name__ == '__main__':
db=DBConnection()
res=db.select('select * from device;',match='one')
print(res)
db.exit_()
#MongoDB
import pymongo
class MongoDB:
def __init__(self,user='admin',pwd='sq',ip='192.168.32.128',port=27017):
'''
:param user:用户名
:param pwd: 密码
:param ip: ip地址
:param port: 端口号
'''
self.user=user
self.pwd=pwd
self.ip=ip
self.port=port
self.client = pymongo.MongoClient(f"mongodb://{user}:{pwd}@{ip}:{port}/")
def insert(self,collection,query,db='sq-waimai'):
'''
:param db: 使用的数据库
:param collection: 使用的集合
:param query: 添加的信息
:return:
'''
db=self.client[db]
collection=db[collection]
collection.insert_one(query)
def find_one(self,collection,query,db='sq-waimai'):
'''
:param db: 使用的数据库
:param collection: 使用的集合
:param query: 查询的信息
:return: 查询结果
'''
db=self.client[db]
collection=db[collection]
result=collection.find_one(query)
return result
def find_all(self,collection,query,db='sq-waimai'):
'''
:param db: 使用的数据库
:param collection: 使用的集合
:param query: 查询的信息
:return: 查询返回所有结果
'''
db=self.client[db]
collection=db[collection]
results=collection.find(query)
return results
def update_one(self,collection,myquery,newvalues,db='sq-waimai'):
'''
:param db: 使用的数据库
:param collection: 使用的集合
:param myquery: 查询的信息
:param newvalues: 修改的信息
:return:
'''
db=self.client[db]
collection=db[collection]
collection.update_one(myquery,{'$set':newvalues})
#collection.update_many(myquery, {'$set': newvalues}) 修改所有的
def delete_one(self,collection,query,db='sq-waimai'):
'''
:param db: 使用数据库
:param collection: 使用的集合
:param query: 信息
:return:
'''
db=self.client[db]
collection=db[collection]
collection.delete_one(query)
def delete_all(self,collection,query,db='sq-waimai'):
'''
:param db: 使用数据库
:param collection: 使用的集合
:param query: 信息
:return:
'''
db=self.client[db]
collection=db[collection]
collection.delete_many(query)
if __name__ == '__main__':
#1-创建mongodb数据库连接
db=MongoDB()
# #2- 插入数据
db.insert('foods',{'restaurant_id':3269,"category_id":3333,"description":'xx非常好吃',"item_id":6872,'name':'烤肉饭'})
#3- 查一条数据
res=db.find_one('foods',{'restaurant_id':3269})
# #4- 打印这一条数据
print(res)
# #5- 删除所有数据
# # db.delete_all('foods',{'restaurant_id':3269})
# #6-查所有数据
# res1=db.find_all('foods',{'restaurant_id':3269})
# #7-打印所有数据
# print(res1)
# for one in res1:
# print(one)
#8- 更新数据
# db.update_one('shops',{'name':'淘汰郎小火锅桐乡店'},{'name':'xintain火锅店'})
# res1 = db.find_one('shops', {'id':1})
# print(res1)
不封装直接操作
import pymysql #导入数据操作的库
#连接数据库
db = pymysql.connect(host='192.168.30.78', user='ssfw', passwd='nj1234', db='public_service', port=3306, charset='utf8')
#定义游标
cur =db.cursor()
#循环次数
count = 0
#定义数据表的字段名的初始值
sid=7
# assess_number=0110520220416147
while count < 16:
count += 1
window_person_id = int(count)
sid+=1
id = sid
name='sss'
username = 'qc'+ str(count)
password = '111111'
ber= int(3201211)+int(count)
number = 'A'+ str(ber)
gender = '1'
create_time = '1650614516'
file_path = 'upload/persion/20220419/625e14f88514f.png'
status = '0'
values=(int(id),str(window_person_id),str(name),str(username),str(password),int(create_time),str(number),int(gender),str(file_path),int(status))
sql = """INSERT INTO set_window_person (id,window_person_id,name,username,password,create_time,number,gender,file_path,status) values (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"""
cur.execute(sql,values)
db.commit()
print('条目'+str(count)+"已经创建成功")
print("数据已经插入完成")
cur.close()
db.close()
'''
创造数据：
1.navcat 自带的代入功能
①.用excel根据表的字段创建数据
②.navcat中表右击选择导入向导
③.根据向导设置数据匹配关系
④.导入运行,结束后在表中确认数据
2.写存储过程
3.python
需要:python语法,数据库,pycharm
#创建数据表
# CREATE TABLE test0709(FIRST_NAME varchar(10),LAST_NAME varchar(10),AGE INT,SEX CHAR(2),INCOME INT)
import pymysql #导入数据操作的库
#连接数据库
db = pymysql.connect(host='localhost', user='root', passwd='root', db='test', port=3308, charset='utf8')
#定义游标
cur =db.cursor()
#循环次数
count = 0
#定义数据表的字段名的初始值
sid=20
sscore=45
#sname="SQname"
while count < 500:
count += 1
sname = 'SQname'+str(count)
sid+=1
stscore=sscore
stname=sname
stid=sid
values=(int(stid),str(stname),int(stscore))
sql = """INSERT INTO sqstu (stid,stname,stscore) values (%s,%s,%s)"""
cur.execute(sql,values)
db.commit()
print('条目'+str(count)+"已经创建成功")
print("数据已经插入完成")
cur.close()
db.close()
'''
'''
import string
import pymysql #导入数据操作的库
import time
import calendar
import random
import datetime
'''
#造江苏省法院和南京市的法院评价数据
'''
#连接数据库
db = pymysql.connect(host='192.168.30.68', user='ssfw', passwd='nj1234', db='public_service', port=3306, charset='utf8')
#定义游标
cur =db.cursor()
def get_ran_d():
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 32))
return ran_str
def exc_sql():
values=(int(id),str(assess_id),str(user_id),int(court_code),str(assess_ids),str(assess_texts),int(stars),int(branch),str(window_person_id),
int(create_time),str(business_id),str(date),int(start_business),int(end_business),int(business_number),int(identity),str(assess_number),int(is_assess),int(take_effect),int(appeal))
sql = """INSERT INTO set_user_assess (id,assess_id,user_id,court_code,assess_ids,assess_texts,stars,branch,window_person_id,create_time,
business_id,date,start_business,end_business,business_number,identity,assess_number,is_assess,take_effect,appeal) values (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"""
cur.execute(sql,values)
db.commit()
print('条目'+str(count)+"已经创建成功")
def get_business_type_id(court_code):
sql = 'select business_type_id from set_business where court_code=%s ;' %court_code
cur.execute(sql)
result = cur.fetchall()
business_type_id = []
for r in result:
business_type_id.append(list(r))
return business_type_id
def get_business_id(business_type_id):
sql = ('select business_id from set_business where business_type_id="{}";').format(business_type_id)
cur.execute(sql)
business_id = cur.fetchall()
return business_id
def get_business_number(business_type_id):
sql = ('select number from set_business_type where business_type_id="{}";').format(business_type_id)
cur.execute(sql)
business_number = cur.fetchall()
return business_number
def get_court_code():
sql = 'select court_code from court where court_name like"江苏省%" or court_name like"南京市%";' # 生成江苏省高院、江苏省全部中院和全南京市基层法院
# sql = 'select court_code from court where court_name like"南京市%";' # 只生成南京市中级和基层法院数据
cur.execute(sql)
result = cur.fetchall()
court_code_list = []
for x in result:
court_code_list.append(list(x))
return court_code_list
def get_public_user():
sql = 'select user_id from public_user;'
cur.execute(sql)
result = cur.fetchall()
public_user_list = []
for x in result:
public_user_list.append(list(x))
return public_user_list
def get_window_person_id(court_code):
sql = 'select window_person_id from set_window_person where court_code=%s;' %court_code
cur.execute(sql)
result = cur.fetchall()
window_person_list = []
for x in result:
window_person_list.append(list(x))
return window_person_list
def get_assess_ids(stars,court_code,business_type_id):
low = [1, 2]
if stars in low:
sql = ("select assess_id,title from set_assess_tag where stars = '1,2' and court_code='{}' and business_type_id='{}';").format(court_code,business_type_id)
cur.execute(sql)
result = cur.fetchall()
get_assess_ids = []
for x in result:
get_assess_ids.append(list(x))
return get_assess_ids
else:
sql = ("select assess_id,title from set_assess_tag where stars = '3,4,5' and court_code='{}' and business_type_id='{}';").format(court_code,business_type_id)
cur.execute(sql)
result = cur.fetchall()
get_assess_ids = []
for x in result:
get_assess_ids.append(list(x))
return get_assess_ids
id = 750003
count = 0
court_code_list = get_court_code()
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 32))
while count < 2000:
count+=1
id +=1
assess_id = get_ran_d()
stars = random.choice(range(1, 6))
branch = stars
date = '20220601' # 去年500条数据，半年前2000条数据
create_time = calendar.timegm(time.gmtime()) # 生成create_time字段的时间戳 ----当天
# create_time = 1653235229 # 2022-05-23 00:00:29 本周
# create_time = 1651334429 # 2022-05-01 00:00:29 本月
# create_time = 1640966429 # 2022-01-01 00:00:29 本年
# create_time = 1621907489 # 2021-05-25 23:36:46 一年前
# create_time = 1648395406 # 2022-03-27 23:36:46 三月份
# create_time = 1645976206 # 2022-02-27 23:36:46 二月份
# create_time = 1642234766 # 2022-02-27 23:36:46 一月份
# create_time = 1651246606 # 2022-04-01 23:36:46 四月份
start_business = calendar.timegm(time.gmtime())
end_business = calendar.timegm(time.gmtime()) + 60
assess_number = '0' + str(int("0110520220000000") + count)
identity = '1'
is_assess = '1'
take_effect = '1'
appeal = '0'
# court_code = int(str(random.choice(court_code_list))[2:8])
court_code = 320105
# print(court_code)
# print(type(court_code))
user_id = (str(random.choice(list(get_public_user()))))[2:34] # 用户id从表中随机获取
window_person_id = (str(random.choice(list(get_window_person_id(court_code)))))[2:34] #
p = random.choice(list(get_business_type_id(court_code)));
business_type_id = p[0]# 随机一个business_type_id [1:-1]可以
print("business_type_id是："+ business_type_id)
business_id = (str(get_business_id(business_type_id)))[3:35] # 根据business_type_id查询获取到business_id
print("截取过的business_id是："+business_id)
business_number = str(get_business_number(business_type_id)) # 根据business_type_id查询获取到business_number
if len(business_number) == 7:
business_number = business_number[2:3] # business_number都是个位数的时候
else:
business_number = business_number[2:5] # business_number为255的时候
print(business_number)
assess = random.choice(list(get_assess_ids(stars,court_code,business_type_id)))
assess_ids=str(assess[0])
print(assess_ids)
assess_texts=str(assess[1])
print(assess_texts)
exc_sql()
print("数据已经插入完成")
cur.close()
db.close()
'''
本文来自博客园，作者：那又何妨，转载请注明原文链接：https://www.cnblogs.com/qinc/p/17827894.html
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！