1.修改了创建连接数据库引擎时的方言类型 2.修改了爬取数据的逻辑以及相关的异常分析代码

zmc

2023-12-22 d99d235123d43825f35cdc4c8cb49339d9651056

1.修改了创建连接数据库引擎时的方言类型 2.修改了爬取数据的逻辑以及相关的异常分析代码

 PackagesInfo.txt

ÎļþÒÑɾ³ý

 Scripts/Vcode.jpg

 Vcode.jpg

 py_spider.py

@@ -2,10 +2,9 @@
from flask_cors import CORS

import sys
# sys.path.append('D:\\z\workplace\\VsCode\\pyvenv\\venv')
sys.path.append('../')

import src.Crawling as Crawling
import src.Crawling_1 as Crawling
import src.auto_login as login
import pandas as pd
from sqlalchemy import create_engine
@@ -22,19 +21,17 @@

session = -1


# æ¨¡æ‹Ÿç™»é™†å¹¶çˆ¬å–数据
@app.route('/getData',methods=['POST'])
def get_data():
    if request.method == 'POST':
        data=request.get_json()
        if(session != -1) :
            # if(len(session.cookies.get_dict()) == 0):
            #     # session失效
            #     return '-2'

            result,all_data=Crawling.pass_login(session,data.get('beginTime'),data.get('endTime'),data.get('selectedShopNames'))
            print('\n\n爬取的所有的allData\n',all_data)
            duplicate_data,new_data=is_duplicate(all_data)
            # if(len(duplicate_data)==0):
            #     duplicate_data.append('无重复数据')
            print('重复的数据为：',duplicate_data)
            jso ={
                # åé¦ˆä¿¡æ¯
@@ -51,24 +48,22 @@
            return '-1'
    return jsonify(jso)

# å†™å…¥æ•°æ®åº“ å†™å…¥4张表中
# å¯¹æ•°æ®è¿›è¡Œå¼‚常分析，将结果写入异常表，设备信息表，分钟数据表
@app.route('/store',methods=['POST'])
def write_new():
    if request.method =='POST':
        data = request.get_json()
        # print('data为：',data.get('allData'))
        # print('要存入的数据条数为：',len(data.get('allData')))

        # å†™å…¥æ•°æ®åº“
        w_t_MySql.write(data.get('allData'))
        return '写入完成！'

# å†™å…¥æ•°æ®åº“ åªå†™å…¥åˆ†é’Ÿæ•°æ®è¡¨

# åªå†™å…¥åˆ†é’Ÿæ•°æ®è¡¨
@app.route('/minute',methods=['POST'])
def write_dup():
    if request.method =='POST':
        data = request.get_json()
        # print('data为：',data.get('allData'))
        # print('要存入的数据条数为：',len(data.get('allData')))
        # å†™å…¥æ•°æ®åº“
        w_t_minute.write(data.get('allData'))
        return '写入完成！'
@@ -88,25 +83,18 @@
# lst为要和数据库已存的数据进行比较，lst元素只需要3个字段。 è¿”回值是重复的数据
def is_duplicate(lst):
    temp=copy.deepcopy(lst)
    # print('temp',temp)
    # print('\n')
    # åªä¿å­˜3个字段
    after_address=[]
    for item in temp:
        # print('item',item)
        # print('\n')
        a=[]
        # åº—铺名和设备编号
        a.append(item[1])
        # print('item1',item[1])
        # print('\n')

        a.append(item[2])
        # å½’属时间
        time=str(item[11])+':00'
        a.append(time)
        # print('a',a)
        # print('\n')

        after_address.append(a)

    engine = create_engine("mysql+pymysql://fumeRemote:feiyu2023@114.215.109.124:3306/fume?charset=utf8")

 src/Crawling.py

@@ -120,7 +120,8 @@
        count_all=count_all+get_OnePage(i,count)
        if len(list_temp)==0:        #如果该页为空，则表示该页后面都无数据  é€€å‡ºå¾ªçŽ¯
            print('后面页数为空，爬去下一个店铺')
            break                    #退出循环
            break 
                           #退出循环
        list_all.extend(list_temp)   #将一页数据列表追加到list_all中
        print("爬取了第",page,"页")
        page=page+1
@@ -604,11 +605,7 @@
    global ck
    global list_temp    #使用全局变量
    list_temp.clear()  #清空临时表
    # session.headers = {
    #     # æ­¤å¤„注意cookie，要自己抓取
    #     # "Cookie":ck,
    #     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36",
    # }

    r = session.get(url, verify=False).text
    soup = bs(r,'html.parser')

@@ -686,11 +683,7 @@
    global list_temp    #使用全局变量

    list_temp.clear()  #清空临时表
    # session.headers = {
    #     # æ­¤å¤„注意cookie，要自己抓取
    #     # "Cookie":ck,
    #     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
    # }

    r = session.get(url,  verify=False).text
    soup = bs(r,'html.parser')

@@ -707,7 +700,6 @@
        print('删除特殊的后两个')
        print(list1)
        list.append(list1) 
        #list1.clear()       

    #print(list) 
    list_data=[]  
@@ -753,36 +745,27 @@
    urls=url_more()   #返回文件中所有店铺的url,带最大显示条数100 ã€‚urls是列表
    #print(urls)
    teshu_url=[]
    #'shop=%25E9%25A3%259F%25E5%2585%25B6%25E5%25AE%25B6'  é£Ÿå…¶å®¶
    special_url=['shop=%25E4%25BA%25BA%25E7%2594%259F%25E4%25B8%2580%25E4%25B8%25B2','shop=%25E7%25BC%2598%25E5%25AE%25B6','shop=%25E4%25B8%25B0%25E8%258C%2582%25E7%2583%25A4%25E4%25B8%25B2','shop=%25E6%25B3%25B0%25E7%2585%258C%25E9%25B8%25A1','shop=%25E5%25B0%258F%25E9%2593%2581%25E5%2590%259B']

    for url in urls:          #遍历所有店铺的url
        begin=url.find('&')+1
        end=url.rfind('&')
        #print(begin,end)
        #找到特殊的url,进行特殊处理
        if url[begin:end] in special_url:   
            print('发现特殊的！')
            already_spider_shopnum += 1   #爬去的店铺数量加1
            already_spider_shopnum += 1   # çˆ¬åŽ»çš„店铺数量加1
            teshu_url.append(url)
            #再删除一个列表元素
            url_teshu=url_add_time(url,date_begin,date_end)  #给所有url加上日期
            list_to_MySql=get_MorePages_teshu(url_teshu,page)    #店铺的url,爬取的页数
            # a=remove_Duplicates_list(list_to_MySql)
            # print('\n')
            # for item in a:
            #     print(item)
            url_teshu=url_add_time(url,date_begin,date_end)  # ç»™æ‰€æœ‰url加上日期
            list_to_MySql=get_MorePages_teshu(url_teshu,page)    # åº—铺的url,爬取的页数

            if len(list_to_MySql) == 0 :
                print('该家店铺时间段无数据，已跳过')
                continue
            has_remove_duplicates = remove_Duplicates_list(list_to_MySql)   #去除某个店铺指定页数所有重复的数据
            for item in has_remove_duplicates:
                all_data.append(item)
            # is_minutes_exceed_30(has_remove_duplicates,con)      # å°†æŒ‡å®šé¡µæ•°çš„设备故障数据写入数据库异常表中
            # isExceeding(has_remove_duplicates,con)               # å°†æŒ‡å®šé¡µæ•°æ•°æ®å†™å…¥æ•°æ®åº“超标表中
            # ea_t_dev(has_remove_duplicates,con)                  # å°†æŒ‡å®šé¡µæ•°æ•°æ®å†™å…¥æ•°æ®åº“设备信息表中
            # fd_t_minbute(has_remove_duplicates,con)              #将指定页数数据写入数据库分钟数据表中 

         
            list_to_MySql.clear()
        if url[begin:end]=='shop=%25E9%25A3%259F%25E5%2585%25B6%25E5%25AE%25B6':   #食其家
            print('发现特殊的！')
@@ -800,11 +783,7 @@
            has_remove_duplicates = remove_Duplicates_list(list_to_MySql)   #去除某个店铺指定页数所有重复的数据
            for item in has_remove_duplicates:
                all_data.append(item)
            # is_minutes_exceed_30(has_remove_duplicates,con)      # å°†æŒ‡å®šé¡µæ•°çš„设备故障数据写入数据库异常表中
            # isExceeding(has_remove_duplicates,con)               # å°†æŒ‡å®šé¡µæ•°æ•°æ®å†™å…¥æ•°æ®åº“超标表中
            # ea_t_dev(has_remove_duplicates,con)                  # å°†æŒ‡å®šé¡µæ•°æ•°æ®å†™å…¥æ•°æ®åº“设备信息表中
            # fd_t_minbute(has_remove_duplicates,con)              #将指定页数数据写入数据库分钟数据表中 
      
           
            list_to_MySql.clear()
    for t in teshu_url:     #从urls表中删除特殊的
        urls.remove(t)

 src/Crawling_1.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,920 @@
#sum å¤šé¡µ å…¥åº“成功 çˆ¬å–文件中所有的店铺  ç½‘页完整表端 åŽ»é™¤é‡å¤æ•°æ® é‡åˆ°ç©ºé¡µé¢ä¼šè·³åˆ°ä¸‹ä¸€å®¶åº—铺 ã€‚遇到某家店铺无数据，跳过去下一家
#爬去某家店铺指定的页数（一页记录数默认大小为100条），比如爬取12页，则爬取12页后将结果一次性写入数据库
#爬去整个页面表结构，再分别写入4张表中（爬取的数据存入两张表中，还有超标表 å¼‚常表）
#网页上字段共14个，存入数据库是15个（序号+14）
import requests
from bs4 import BeautifulSoup as bs  
import re              #正则表达式
from pymysql import *  # è¿žæŽ¥mysql数据库
import pandas as pd
from sqlalchemy import create_engine
import urllib.parse                   #url双重编码
import time
import uuid
from datetime import datetime, timedelta

import sys
sys.path.append('../../')
import src.core_modules.remove_duplicates_methods as rdm



now_date = time.strftime("%Y-%m-%d", time.localtime())    #获取当前年月日  #url编码年月日开始默认时间
now_date1 = time.strftime("%Y-%m", time.localtime())  
month_begin=now_date1+'-01'                 #设置当前月份的开始

list_temp=[]  #临时列表  å…¨å±€å˜é‡



def remove_Duplicates_list(list):        #列表自身去重
    global already_spider_datanum
    list_store=[]
    for item in list:
        if item not in list_store:
            list_store.append(item)
        else:
            print("发现重复")
            already_spider_datanum=already_spider_datanum-1
    #print(list_store)
    return list_store

def merge(list):  #合并list倒数六个元素 
    date_1=str(list.pop(-1))  #删除尾元素后还能继续使用改元素，
    date_2=str(list.pop(-1))
    date1=date_2+' '+date_1       #合并为年月日时分秒

    date_3=str(list.pop(-1))  
    date_4=str(list.pop(-1))
    date2=date_4+' '+date_3

    date_5=str(list.pop(-1))
    date_6=str(list.pop(-1))
    date3=date_6+' '+date_5
    list.append(date3)    #将合并的数据写会list列表结尾.
    list.append(date2)      
    list.append(date1)
    
    
    return list

def list_url(url,page_num):  #url中的i是页 ,apge_num表示爬取的页数  ã€‚url后面加上页的参数
    urls = [url+'&page'+'={}'.format(str(i)) for i in range(1,page_num+1)]
    return urls    # è¿”回该url对应页的所有链接形式，返回值为列表


def get_OnePage(url,count):     #抓取一页的数据,放入list_data中.urls为要访问的网页地址
    global list_temp    #使用全局变量

    list_temp.clear()  #清空临时表
    r = session.get(url, verify=False).text
    soup = bs(r,'html.parser')

    # æ‰¾åˆ°æ‰€æœ‰çš„tr标签
    rows = soup.find_all('tr')

    # æå–表格中的数据
    result = []  #创建列表来保存结果
    for row in rows:
        # æ•°æ®æ¡æ•°åŠ 1
        count=count+1
        # ä¿å­˜è¡¨æ ¼çš„行数据
        data = []
        # å¾—到该行的所有列数据
        cols = row.find_all('td')
        # å¾ªçŽ¯æ¯ä¸€åˆ—
        for col in cols:
            if col.find('div'):
                # å¦‚æžœtd中包含div，则单独提取其内容
                div_content = col.find('div').text.strip()
                # è¿”回元素的文本内容 æœç´¢tag的直接子节点
                td_content = ''.join(col.find_all(text=True, recursive=False)).strip()
                data.append(td_content)
                data.append(div_content)
            else:
                # å¦‚æžœtd中不包含div，则直接提取td的内容
                td_content = col.text.strip()
                data.append(td_content)
        # åˆ é™¤'操作'，'详情'
        del (data[-2:])
        # åˆ é™¤åœ°å€
        del (data[2])
        result.append(data)
    print('一页的结果为：',result)
    # åˆ é™¤è¡¨å¤´çš„标题行
    del (result[0])
    
    count=count-1             #删除了表头,总数据的行数减一

    list_temp=result[:]

    print('-'*10)
    print('获取到的数据并且处理后为：')
    print(list_temp)
    print('-'*10)

    # è¿”回获取到数据的条数
    return count



def get_MorePages(url,page_num):   #爬取指定店铺名的多页数据,apge_num表示爬取的页数
    global sleeptime
    global already_spider_datanum
    urls=list_url(url,page_num)   #得到需要遍历的页的url
    count_all=0          #保存数据的总行数
    list_all=[]          #保存爬取的所有的数据
    page=1
    for i in urls:
        count=0
        count_all=count_all+get_OnePage(i,count)
        if len(list_temp)==0:        #如果该页为空，则表示该页后面都无数据  é€€å‡ºå¾ªçŽ¯
            print('后面页数为空，爬去下一个店铺')
            break 
                           #退出循环
        list_all.extend(list_temp)   #将一页数据列表追加到list_all中
        print("爬取了第",page,"页")
        page=page+1
        print("\n")
        time.sleep(sleeptime)         #间隔2秒请求一次

    for j in list_all:
        print(j)              #打印列表中每一行
    print("总行数为:",count_all)
    already_spider_datanum += count_all #已爬取数据的总和

    return list_all    


def url_more(): #返回文件中铺名编码形成url,返回值是url列表     é»˜è®¤æŸ¥çœ‹ç½‘页的最大显示条数100
    global shopnum
    global webshops
    shopnames = webshops[:]  #保存中文店铺名称
    print('url_more:',shopnames)
    #编码
    shopnum=len(shopnames)   #文件中店铺总数
    shopname_encoding=[]  #保存编码后的店铺名称
    i=0
    for name in shopnames:
        shopname_encoding.append(urllib.parse.quote(urllib.parse.quote(shopnames[i]))) #店铺名称进行双重url编码
        i=i+1
    #拼接网址形成可用的url
    urls=[]  #保存拼接后的url
    for shop in shopname_encoding:
        url='http://xhhb.senzly.cn/sys/yyRealTimeValue_list.jsp?key1=&shop='+shop+'&pagesize=100'
        urls.append(url)
    # for i in urls:   
    #     print(i)
    return urls   #返回文件中店铺名称对应的url

#根据开始和结束日期来拼接url
def url_add_time(url,date_begin=month_begin,date_end=now_date):     #url,å¹´-月-日 2023-05-03
    url_date=url+'&key5='+date_begin+'&key6='+date_end
    print(url_date)
    return url_date

#------------------------------------------------------------------------------------------------------------超标油烟数据写入异常表中
#两时间是否相差10分钟  æ˜¯åˆ™è¿”回TRUE å¦åˆ™è¿”回FALSE
def is_time_difference_equals_10_mins(datestr1, datestr2):    
    date1 = datetime.strptime(datestr1, "%Y-%m-%d %H:%M")
    date2 = datetime.strptime(datestr2, "%Y-%m-%d %H:%M")
    time_diff = date2 - date1

    return time_diff == timedelta(minutes = 10) or time_diff == timedelta(minutes = -10) #timedelta() è¡¨ç¤ºä¸¤ä¸ª date å¯¹è±¡æˆ–者 time å¯¹è±¡,或者 datetime å¯¹è±¡ä¹‹é—´çš„时间间隔


#每隔十分钟一次为正常。 æ‰¾å‡ºè¶…过10分钟的间断点
def find_break_point(list): #list为超标数据的列表
    i=0
    j=1
    break_point = []     #保存间断点
    for item in list[1:]:  
        if(is_time_difference_equals_10_mins(list[i][2],item[2]) == False): 
            break_point.append(j) 
        i=i+1
        j=j+1
    print('间断点为：')
    print(break_point)

    #写入间断点
    return break_point
    

    
#根据间断点将列表分割成几个子列表，由result返回
def point_write(list,b_point):   #list为列表。b_point列表元素为间断点，间断点值从小到大
    result = []
    last_index = 0
    for index in b_point:
        result.append(list[last_index:index])   #灵活
        last_index=index
    result.append(list[last_index:])
    return result


#将设备故障信息写入abnormal_data异常表中 
def abnormal_write_to_SQL(list,con): 
    data = pd.DataFrame(list,columns=['dev_id','exception','exception_type','region','begin_time','end_time'])
    print("\n\n")
    print(data)

    # test3 è¦å†™å…¥çš„数据表，这样写的话要提前在数据库建好表
    data.to_sql(name="abnormal_data", con=con, if_exists="append",index=False,index_label=False)
    
    

def exception(list,con):   #list为超标数据的列表
    break_point=find_break_point(list) #返回间断点
    split_list=point_write(list,break_point) #根据间断点将原始列表分割成几个子列表  split_list为三层数组,形式为[[[1,2],[4,'g']],[[8,'2'],['4','g']],[[1,2],[4,'g']]]
    # print('超标时间段划分成的子列表为：：')
    # for i in split_list:
    #     print(i)
    print('\n')
    abnormal=[]     #重组好的异常表数据

    for item in split_list:    #从分割的数组中提取需要的时间信息，并添加新的信息数据
        temp=[]  
        temp.append(item[0][0])  #设备编号
        temp.append('数据异常')  #设备编号
        temp.append('0')  #油烟浓度超标
        temp.append('徐汇区')
        temp.append(item[len(item)-1][2])  #前一条记录的归属时间  å¼€å§‹æ—¶é—´
        temp.append(item[0][2])  #归属时间  ç»“束时间
        abnormal.append(temp)

        print(abnormal)

    print('超标异常时间段数据为：')
    for j in abnormal:
        print(j)
    abnormal_write_to_SQL(abnormal,con) #写入异常表中
    print("超标油烟数据异常表写入完成!")

#------------------------------------------------------------------------------------------------------------设备故障数据写入异常表中
#两时间是否相差30分钟  æ˜¯åˆ™è¿”回TRUE å¦åˆ™è¿”回FALSE
def is_time_difference_equals_30_mins(datestr1, datestr2):    
    date1 = datetime.strptime(datestr1, "%Y-%m-%d %H:%M")
    date2 = datetime.strptime(datestr2, "%Y-%m-%d %H:%M")
    time_diff = date2 - date1
    return time_diff > timedelta(minutes=30) 

#找出设备故障的信息，并将此信息写入异常表中
def is_minutes_exceed_30(list,con) :   # list为某店铺指定页数的全部的记录 list元素中的时间为倒序排列，即从大到小
    device_failure=[]     #存储设备故障的数据
    startTime = list[0][11]
    print('开始时间：',startTime)
    for item in list[1:] :
        if is_time_difference_equals_30_mins(item[11],startTime) :  #必须大于30分钟 ä¸èƒ½ç­‰äºŽ30分钟
            temp=[] 
            temp.append(item[2])  #设备编号
            temp.append('设备故障')  #设备编号
            temp.append('1') #设备故障
            temp.append('徐汇区')
            temp.append(item[11])    #故障开始时间
            startTimeSub= datetime.strptime(startTime,"%Y-%m-%d %H:%M") - timedelta(minutes = 10) #结果为datetime.datetime类型 ï¼Œéœ€è¦å†è½¬ä¸ºå­—符串类型
            print('相减后结果：',str(startTimeSub))
            print('相减后类型：',type(str(startTimeSub)))
            temp.append(str(startTimeSub)[:16])  #故障结束时间
            device_failure.append(temp)
        startTime = item[11]
    print('设备故障的数据为：')
    for i in device_failure :
        print(i)
    not_Key_period_exceed_30_minutes(device_failure,con)  #将供电异常信息写入异常表
    #abnormal_write_to_SQL(device_failure,con)   #将设备故障信息写入异常表
    print('供电异常/掉线信息写入异常表完成!')
#-----------------------------------------------------------------------------------------------------------供电异常数据写入异常表中
#开始和结束时间都处于非重点时段时,返回true
def is_time_not_between_key_period(begin_time,end_time) :  #形参为日期字符串,形如 '2023-06-21 14:30'
    global Key_period_noon_begin,Key_period_noon_end,Key_period_night_begin,Key_period_night_end
    # #中午重点时段
    # Key_period_noon_begin = datetime.strptime('10:00',"%H:%M")
    # Key_period_noon_end = datetime.strptime('14:00',"%H:%M")

    # #晚上重点时段
    # Key_period_night_begin = datetime.strptime('17:00',"%H:%M")
    # Key_period_night_end = datetime.strptime('21:00',"%H:%M")

    begin1 = datetime.strptime(begin_time[11:],"%H:%M")
    end1 = datetime.strptime(end_time[11:],"%H:%M")

    #当开始和结束时间都处于非重点时段时，将该条故障信息同时记录为： ç–‘似供电异常
    if ((( begin1 > Key_period_noon_begin and begin1 < Key_period_noon_end ) or ( begin1 > Key_period_night_begin and begin1 < Key_period_night_end )) or (( end1 > Key_period_noon_begin and end1 < Key_period_noon_end ) or ( end1 > Key_period_night_begin and end1 < Key_period_night_end ))) ==False :
        print('开始或结束时间时间在非重点时段')
        return True
    print('处于重点时段')
    return False

#开始和结束时间都处于重点时段时,返回true
def is_time_between_key_period(begin_time,end_time) :  #形参为日期字符串,形如 '2023-06-21 14:30'
    global Key_period_noon_begin,Key_period_noon_end,Key_period_night_begin,Key_period_night_end
    # #中午重点时段
    # Key_period_noon_begin = datetime.strptime('10:00',"%H:%M")
    # Key_period_noon_end = datetime.strptime('14:00',"%H:%M")

    # #晚上重点时段
    # Key_period_night_begin = datetime.strptime('17:00',"%H:%M")
    # Key_period_night_end = datetime.strptime('21:00',"%H:%M")

    begin1 = datetime.strptime(begin_time[11:],"%H:%M")
    end1 = datetime.strptime(end_time[11:],"%H:%M")

    #当开始和结束时间都处于重点时段时，将该条故障信息同时记录为： æŽ‰çº¿
    if ((begin1 > Key_period_noon_begin and begin1 < Key_period_noon_end) and ( end1 > Key_period_noon_begin and end1 < Key_period_noon_end )) or ( (begin1 > Key_period_night_begin and begin1 < Key_period_night_end) and ( end1 > Key_period_night_begin and end1 < Key_period_night_end )) :
        print('开始或结束时间处于重点时段')
        return True
    print('处于非重点时段')
    return False



def not_Key_period_exceed_30_minutes(list,con) :  #list为设备故障的时间段数据
    power_supply_abnormal = []  #保存供电异常或掉线的信息
    for item in list :
        if is_time_not_between_key_period(item[4],item[5]) :   #else:
            temp = []
            temp.append(item[0])
            temp.append('设备故障')
            temp.append('1')  #疑似供电异常
            temp.append('徐汇区')
            temp.append(item[4])
            temp.append(item[5])
            power_supply_abnormal.append(temp)
        elif is_time_between_key_period(item[4],item[5]) :
            temp = []
            temp.append(item[0])
            temp.append('设备故障')
            temp.append('2')  #掉线
            temp.append('徐汇区')
            temp.append(item[4])
            temp.append(item[5])
            power_supply_abnormal.append(temp)
    print('供电异常的数据为：')
    for i in power_supply_abnormal :
        print(i)
    
    #将供电异常的信息写入数据库异常表中
    abnormal_write_to_SQL(power_supply_abnormal,con)   #将设备故障信息写入异常表
    print('供电异常的信息写入异常表完成!')



#------------------------------------------------------------------------------------------------------------写入超标表中

#返回重组后的列表
def refind_ex(list):  #list为网页的一条记录
    temp=[]
    temp.append(list[2])  #设备编号
    temp.append(list[12]) #上报时间
    temp.append(list[11])  #归属时间
    temp.append(list[6])   #风机电流 6
    temp.append(list[7])   #净化器电流7
    temp.append(list[4])   #进油烟浓度值
    temp.append(list[5])   #排油烟浓度值

    print(temp)
    return temp


#将列表写入exceeding_st_data表中 
def ex_write_to_SQL(list,con): 
    data = pd.DataFrame(list,columns=['MV_Stat_Code','MV_Create_Time','MV_Data_Time','MV_Fan_Electricity','MV_Purifier_Electricity','MV_Fume_Concentration','MV_Fume_Concentration2'])
    print("\n\n")
    print(data)
    #engine = create_engine("mysql+pymysql://root:1234@localhost:3306/fume?charset=utf8")
    #con = engine.connect()

    # test3 è¦å†™å…¥çš„数据表，这样写的话要提前在数据库建好表
    data.to_sql(name="exceeding_st_data", con=con, if_exists="append",index=False,index_label=False)
    #con.close()
    print("超标表写入完成!")
    

# list为某店铺指定页数的全部的记录 å°†è¶…标数据写入超标表
def isExceeding(list,con):  #list为某店铺指定页数的全部的记录  list元素为列表形式
    exceedingData=[]     #保存超标的数据
    for item in list:       #查找超标的数据，并记录下
        if float(item[5]) > 1:   # æŽ’烟浓度大于1则超标
            print("该条数据超标")
            #保存该条记录，提取需要的值，并添加其他字段
            exceedingData.append(refind_ex(item))
            
            
    for i in exceedingData:  #遍历列表
        print(i)   

    if(len(exceedingData) != 0) :  #有超标数据时才执行
        #将超标数据时间分类再写abnormal_data异常表中
        exception(exceedingData,con) 

        #将超标数据直接写入数据库超标表中  
        ex_write_to_SQL(exceedingData,con)
    else:
        print('该店铺无超标数据')


#------------------------------------------------------------------------------------------------------------数据写入设备信息表
def generate_short_uuid():
    arrayOf=[
            "a",
            "b",
            "c",
            "d",
            "e",
            "f",
            "g",
            "h",
            "i",
            "j",
            "k",
            "l",
            "m",
            "n",
            "o",
            "p",
            "q",
            "r",
            "s",
            "t",
            "u",
            "v",
            "w",
            "x",
            "y",
            "z",
            "0",
            "1",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "A",
            "B",
            "C",
            "D",
            "E",
            "F",
            "G",
            "H",
            "I",
            "J",
            "K",
            "L",
            "M",
            "N",
            "O",
            "P",
            "Q",
            "R",
            "S",
            "T",
            "U",
            "V",
            "W",
            "X",
            "Y",
            "Z"
        ]
    list=[]
    ui=str(uuid.uuid4()).replace('-', '')
    for i in range(0,16):
        a1=ui[i*2:i*2+2]
        x=int(a1,16)
        list.append(arrayOf[x % 0x3E])
    return ''.join(list)


#返回重组后的列表
def refind_ea(list):  #一条记录，也就是一个列表
    temp=[]
    temp.append(generate_short_uuid())
    temp.append(list[2])
    temp.append(list[1])
    temp.append(list[0])
    temp.append(1)
    print(temp)
    return temp

#将列表写入设备信息设备信息ea_t_dev表中 
def ea_write_to_SQL(list,con):   
    data = pd.DataFrame(list,columns=['DI_GUID','DI_Code','DI_Name','DI_Supplier','DI_Online'])
    print("\n\n")
    print('写入数据表 ï¼ŒDateFrame为：',data)

    # test3 è¦å†™å…¥çš„数据表，这样写的话要提前在数据库建好表
    data.to_sql(name="ea_t_device_info", con=con, if_exists="append",index=False,index_label=False)
    print("设备信息表写入完成!")


def dev_info_data_if_exisitd(list,con):  #list为爬取某家店铺指定页数转换后的数据
    global con_read
    #创建第二个数据库连接
    # engine = create_engine("mysql+pymysql://root:1234@localhost:3306/fume?charset=utf8")
    # con_read = engine.connect()

    df = pd.read_sql('SELECT DI_Code,DI_Name,DI_Supplier FROM ea_t_device_info',con=con_read)   #从设备信息表中读取设备编号，店铺名，供应商字段的数据。返回值是DateFrame类型
    # con_read.close()  #关闭链接

    res = df.values.tolist()  #DateFrame按照行转成list类型，res存放的是设备信息表中的数据
    print('******** è®¾å¤‡ä¿¡æ¯******')
    for i in res:
        print(i)
    print('设备信息表记录条数为：',len(res))

    list1 = rdm.remove_duplicates_dev_info(list)  #设备编号，店铺名，供应商相等时，则为重复，去除。list1为去重后的
    if len(res) > 0 :  #设备表中有数据
        #比较
        temp=list1[:]  #将list1数据给temp，遍历temp,若相等，从list中删除数据，避免一个列表同时遍历且删除
        print('去除重复为:')
        print(list1)
        for item in temp:
            if item[1:4] in ( x[:] for x in res ) :  #待存入数据库的值与设备表中数据相等时,将待存入的值从list中移除               
                list1=rdm.remove_given_data_dev_info(list1,item[1:4])   #该item从list1中移除
                   
        print('设备信息表中有数据时，去重后的list为：',list1)
        if( len(list1) != 0 ) :  #删除后不为空时，写入 
            ea_write_to_SQL(list1,con)   #将列表写入ea_t_dev表中 
    else :      #设备表中无数据
        # a=rdm.remove_duplicates_dev_info(list)  #设备编号，店铺名，供应商相等时，则为重复，去除
        print('设备表无数据，处理后待写入的设备信息为：',list1) 
        #将去重后数据写入设备信息表
        ea_write_to_SQL(list1,con)   #将列表写入设备表中 ã€‚             ç¬¬ä¸€ä¸ªå‚数：设备编号，店铺名，供应商相等时，则为重复，去除



#将原始数据转化成新的列表，再写入设备信息设备信息表中  /存入
def ea_t_dev(list,con):  #某家店铺的制定页的数据记录 ï¼Œlist列表元素依然为列表，比如[[1,2,3,'a'],[52,3,'a'],[6,2,3,'a']] ï¼Œcon为数据库的建立   
    staging=[]    #表示转换后的列表
    for item in list:
        #提取需要的值，并添加其他字段
        staging.append(refind_ea(item))   #转化
    print('设备数据转化后：')
    for i in staging:
        print(i) 

    #查询设备表已存的数据，若已存在设备信息，则不写入
    dev_info_data_if_exisitd(staging,con)
    

#----------------------------------写入分钟数据表

#返回重组后的列表
def refind_fd(list):  #一条记录，也就是一个列表
    temp=[]
    temp.append(list[2])  #设备编号
    temp.append(list[12]) #上报时间
    temp.append(list[11])  #归属时间
    temp.append(list[6])   #风机电流 6
    temp.append(list[7])   #净化器电流 7
    temp.append(list[4])   #进油烟浓度值
    temp.append(list[5])   #排油烟浓度值

    print(temp)
    return temp


#将列表写入分钟数据表中 
def fd_write_to_SQL(list,con): 
    data = pd.DataFrame(list,columns=['MV_Stat_Code','MV_Create_Time','MV_Data_Time','MV_Fan_Electricity','MV_Purifier_Electricity','MV_Fume_Concentration','MV_Fume_Concentration2'])
    print("写入分数数据表,DateFrame为：")
    print(data)

    # test3 è¦å†™å…¥çš„数据表，这样写的话要提前在数据库建好表
    data.to_sql(name="fd_t_minutevalue", con=con, if_exists="append",index=False,index_label=False)

    print("分钟数据表写入完成!")
    
#转化 å†å†™å…¥fd_t_minbute表中 
def fd_t_minbute(list,con):  #一页的数据记录 ï¼Œcon为数据库的建立
    staging=[]    #保存转换后的列表
    for item in list:
        #提取需要的值，并添加其他字段
        staging.append(refind_fd(item))  
    print('分钟数据转化后：')
    for i in staging:
        print(i) 
    fd_write_to_SQL(staging,con)   #将列表写入ea_t_dec表中


#--------------------------------------------------------------------------------------------------------------食其家
def get_OnePage_teshu_shiqijia(url,count):
    global ck
    global list_temp    #使用全局变量
    list_temp.clear()  #清空临时表
    # session.headers = {
    #     # æ­¤å¤„注意cookie，要自己抓取
    #     # "Cookie":ck,
    #     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36",
    # }
    r = session.get(url, verify=False).text
    soup = bs(r,'html.parser')

    list=[]                     #创建列表来保存结果
   
    tags = soup.find_all("tr")  # åˆ—表所有行
    for tag in tags:  # æ¯ä¸ªtag是一行
        count=count+1
        element = tag.text  # èŽ·å–<tr>标签内所有文本信息
        element = element.strip()  # å°†å­—符串首尾空格去除
        list1 = element.split();  # ä»¥ç©ºæ ¼ä¸ºåˆ†éš”将字符串变为列表

        del (list1[-2:])            #列表最后两个元素不需要,删除
        print('删除特殊的后两个')
        print(list1)

        str_temp1=list1[4]+list1[5]  #第5,6合并两个元素为一个
        print(str_temp1)
        del list1[5]
        list1[4]=str_temp1
        print("元素合并完成")
        print(list1)

        str_temp2=list1[1]+list1[2]    #第二三元素合并完成
        del list1[2]
        list1[1]=str_temp2
        
        list.append(list1) 
        print("最终行数据")
        print(list1)
        #list1.clear()       

    #print(list) 
    list_data=[]  
    for i in list:                   #已将尾日期数据合并成年月日 æ—¶åˆ†ç§’
        list_data.append(merge(i))
    del list_data[0]          #删除文字表头   
    count=count-1             #删除了表头,总数据的行数减一
    #print(list_data)
    #list_temp=remove_Duplicates_list(list_data)[:]    #将所有数据复制给临时列表list_temp   æ˜¯åŽ»é™¤é‡å¤åŽçš„列表
    list_temp=list_data[:]
    return count


def get_MorePages_teshu_shiqijia(url,page_num):
    global sleeptime
    global already_spider_datanum
    urls=list_url(url,page_num)   #得到需要遍历的页的url
    count_all=0          #保存数据的总行数
    list_all=[]          #保存爬取的所有的数据
    page=1
    for i in urls:
        count=0
        count_all=count_all+get_OnePage_teshu_shiqijia(i,count)
        if len(list_temp)==0:        #如果该页为空，则表示该页后面都无数据  é€€å‡ºå¾ªçŽ¯
            print('后面页数为空，爬去下一个店铺')
            break  
        list_all.extend(list_temp)   #将列表追加到list_all中
        print("爬取了第",page,"页")
        page=page+1
        print("\n")
        time.sleep(sleeptime)         #间隔2秒请求一次

    for j in list_all:
        print(j)              #打印列表中每一行
    print("总行数为:",count_all)
    already_spider_datanum += count_all #已爬取数据的总和
    return list_all



#-------------------------------------------------------------------------------------------------------------特殊的url
def get_OnePage_teshu(url,count):     #抓取一页的数据,放入list_data中.urls为要访问的网页地址
    # global ck
    global list_temp    #使用全局变量

    list_temp.clear()  #清空临时表
    # session.headers = {
    #     # æ­¤å¤„注意cookie，要自己抓取
    #     # "Cookie":ck,
    #     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
    # }
    r = session.get(url,  verify=False).text
    soup = bs(r,'html.parser')

    list=[]                     #创建列表来保存结果
   
    tags = soup.find_all("tr")  # åˆ—表所有行
    for tag in tags:  # æ¯ä¸ªtag是一行
        count=count+1
        element = tag.text  # èŽ·å–<tr>标签内所有文本信息
        element = element.strip()  # å°†å­—符串首尾空格去除
        list1 = element.split();  # ä»¥ç©ºæ ¼ä¸ºåˆ†éš”将字符串变为列表

        del (list1[-2:])            #列表最后两个元素不需要,删除
        print('删除特殊的后两个')
        print(list1)
        list.append(list1) 
        #list1.clear()       

    #print(list) 
    list_data=[]  
    for i in list:                   
        list_data.append(merge(i))   #将尾日期数据合并成年月日 æ—¶åˆ†ç§’
    del list_data[0]          #删除文字表头   
    count=count-1             #删除了表头,总数据的行数减一
    #print(list_data)
    #list_temp=remove_Duplicates_list(list_data)[:]    #将所有数据复制给临时列表list_temp   æ˜¯åŽ»é™¤é‡å¤åŽçš„列表
    list_temp=list_data[:]
    return count


def get_MorePages_teshu(url,page_num):   #爬取指定店铺名的多页数据,pge_num表示爬取的页数
    global sleeptime
    global already_spider_datanum
    urls=list_url(url,page_num)   #得到需要遍历的页的url  è¿”回该url对应页的所有链接形式，返回值为列表
    count_all=0          #保存数据的总行数
    list_all=[]          #保存爬取的所有的数据
    page=1
    for i in urls:
        count=0
        count_all=count_all+get_OnePage_teshu(i,count)
        if len(list_temp)==0:        #如果该页为空，则表示该页后面都无数据  é€€å‡ºå¾ªçŽ¯
            print('后面页数为空，爬去下一个店铺')
            break  
        list_all.extend(list_temp)   #将列表追加到list_all中
        print("爬取了第",page,"页")
        page=page+1
        print("\n")
        time.sleep(sleeptime)         #间隔2秒请求一次

    for j in list_all:
        print(j)              #打印列表中每一行
    print("总行数为:",count_all)
    already_spider_datanum += count_all #已爬取数据的总和
    return list_all


def spilt_url_teshu(con,page,date_begin=month_begin,date_end=now_date):        #先对特殊的url做处理,再过滤
    global already_spider_shopnum
    global all_data
    urls=url_more()   #返回文件中所有店铺的url,带最大显示条数100 ã€‚urls是列表
    #print(urls)
    teshu_url=[]
    special_url=['shop=%25E4%25BA%25BA%25E7%2594%259F%25E4%25B8%2580%25E4%25B8%25B2','shop=%25E7%25BC%2598%25E5%25AE%25B6','shop=%25E4%25B8%25B0%25E8%258C%2582%25E7%2583%25A4%25E4%25B8%25B2','shop=%25E6%25B3%25B0%25E7%2585%258C%25E9%25B8%25A1','shop=%25E5%25B0%258F%25E9%2593%2581%25E5%2590%259B']

    for url in urls:          #遍历所有店铺的url
        begin=url.find('&')+1
        end=url.rfind('&')
        #print(begin,end)
        #找到特殊的url,进行特殊处理
        if url[begin:end] in special_url:   
            print('发现特殊的！')
            already_spider_shopnum += 1   # çˆ¬åŽ»çš„店铺数量加1
            teshu_url.append(url)
            #再删除一个列表元素
            url_teshu=url_add_time(url,date_begin,date_end)  # ç»™æ‰€æœ‰url加上日期
            list_to_MySql=get_MorePages_teshu(url_teshu,page)    # åº—铺的url,爬取的页数
           
            if len(list_to_MySql) == 0 :
                print('该家店铺时间段无数据，已跳过')
                continue
            has_remove_duplicates = remove_Duplicates_list(list_to_MySql)   #去除某个店铺指定页数所有重复的数据
            for item in has_remove_duplicates:
                all_data.append(item)
         
            list_to_MySql.clear()
        if url[begin:end]=='shop=%25E9%25A3%259F%25E5%2585%25B6%25E5%25AE%25B6':   #食其家
            print('发现特殊的！')
            already_spider_shopnum += 1   #爬去的店铺数量加1
            teshu_url.append(url)
            #再删除一个列表元素
            url_teshu=url_add_time(url,date_begin,date_end)  #给所有url加上日期
            list_to_MySql=get_MorePages_teshu_shiqijia(url_teshu,page)    #店铺的url,爬取的页数
           
            if len(list_to_MySql) == 0 :
                print('该家店铺时间段无数据，已跳过')
                continue
            has_remove_duplicates = remove_Duplicates_list(list_to_MySql)   #去除某个店铺指定页数所有重复的数据
            for item in has_remove_duplicates:
                all_data.append(item)
        
            list_to_MySql.clear()
    for t in teshu_url:     #从urls表中删除特殊的
        urls.remove(t)
    print(len(urls))
    return urls

#-------------------------------------------------------------------------------------------------------------


def spider_all(con,page,date_begin=month_begin,date_end=now_date):    #爬取文件中所有店铺(包括特殊的url店铺)    æ•°æ®åº“连接对象 ,要爬取的页数,开始时间,结束时间
    global already_spider_shopnum 
    global all_data
    url_all=[]

    urls=url_more()   #返回文件中所有店铺的url,带最大显示条数100 ã€‚urls是列表
    for url in urls:  #给所有url加上日期
        url_all.append(url_add_time(url,date_begin,date_end))
  
    for i in url_all:   #打印最终的url
        print(i)

    for j in url_all:     #根据所有url写入数据库     
        list_to_MySql=get_MorePages(j,page)    #店铺的url,爬取的页数
        already_spider_shopnum += 1   #爬去的店铺数量加1

        if len(list_to_MySql) == 0 :
            print('该家店铺时间段无数据，已跳过')
            continue
        has_remove_duplicates = remove_Duplicates_list(list_to_MySql)   #去除某个店铺指定页数所有重复的数据
        for item in has_remove_duplicates:
                all_data.append(item)

        list_to_MySql.clear()




def write_Sql(list,con):      #将网站数据写入数据库
    data = pd.DataFrame(list,columns=['provider','shop_name','equipment_number','equipment_name','smoke_push_density','smoke_pop_density','wind_turbine','purifier','level','alarm_required','alarm_triggered','attribution_time','reporting_time','data_time'])
    print("\n\n")
    print(data)

    # test3 è¦å†™å…¥çš„数据表，这样写的话要提前在数据库建好表
    data.to_sql(name="ed_data", con=con, if_exists="append",index=False,index_label=False)
    print("写入完成!")

# ck=""     #保存cookie
session = requests.session()
webshops=[]
shopnum=0   #文件中店铺总数
already_spider_shopnum=0   #已爬取的店铺数量
already_spider_datanum=0   #已爬取的数据条数
sleeptime=8

Key_period_noon_begin = datetime.strptime('10:00',"%H:%M")    #中午重点时段
Key_period_noon_end = datetime.strptime('14:00',"%H:%M")


Key_period_night_begin = datetime.strptime('17:00',"%H:%M")   #晚上重点时段
Key_period_night_end = datetime.strptime('21:00',"%H:%M")

engine = create_engine("mysql+pymysql://fumeRemote:feiyu2023@114.215.109.124:3306/fume?charset=utf8")



# ä¸“门读取设备信息表
con_read = engine.connect()

all_data = []
def pass_login(ses,beginTime,endTime,shops):
    global con_read
    # global ck 
    global session 
    global webshops

    global all_data
    global shopnum
    global already_spider_shopnum
    global already_spider_datanum
    # åˆå§‹åŒ– é˜²æ­¢å½±å“ä¸‹æ¬¡
    all_data.clear()
    shopnum=0
    already_spider_shopnum=0
    already_spider_datanum=0

    # åˆå§‹åŒ–session
    session = ses
    webshops = shops[:]
    print(f'获取数据的时间区间为：{beginTime}-{endTime}')
    print('传入的店铺名称为：',shops)
   
    engine = create_engine("mysql+pymysql://fumeRemote:feiyu2023@114.215.109.124:3306/fume?charset=utf8")
    con = engine.connect()


    #爬取所有店铺  å¹¶è®¡ç®—耗时
    start_time=time.time()

    spider_all(con,100,beginTime,endTime)  #爬取文件中所有的店铺名
     # ç»™æ‰€æœ‰æ•°æ®æœ€åŽä¸€ä¸ªå­—段标记为‘0’，表示不重复
    for item in all_data:
        item.append(0)
        
    end_time=time.time()
    # å…³é—­æ•°æ®åº“连接

    con_read.close()
    con.close()
    
    print("获取数据完成!")
    print("设置获取的时间间隔为",sleeptime,"秒")
    print("共有",shopnum,"家","已获取",already_spider_shopnum,"家")
    print("共获取",already_spider_datanum,"条记录")
    print("共耗时:{:.2f}秒".format(end_time-start_time))

    result=[]
    result.append('获取数据完成!')
    result.append("共有"+str(shopnum)+"家，已获取"+str(already_spider_shopnum)+"家")
    result.append("共获取"+str(already_spider_datanum)+"条记录")
    result.append("共耗时:{:.2f}秒".format(end_time-start_time))
    
    return result,all_data



# pass_login()

 src/__pycache__/Crawling.cpython-38.pyc

Binary files differ

 src/__pycache__/Crawling_1.cpython-38.pyc

Binary files differ

 src/__pycache__/write_to_MySql.cpython-38.pyc

Binary files differ

 src/__pycache__/write_to_minute_table.cpython-38.pyc

Binary files differ

 src/write_to_MySql.py

@@ -7,7 +7,6 @@
from datetime import datetime, timedelta

import sys
# sys.path.append('D:\\z\workplace\\VsCode\\pyvenv\\venv')
sys.path.append('../../')
import src.core_modules.remove_duplicates_methods as rdm

@@ -107,7 +106,7 @@
            temp=[] 
            temp.append(item[2])  #设备编号
            temp.append('设备故障')  #设备编号
            temp.append('1') #设备故障
            temp.append('1') #供电异常
            temp.append('徐汇区')
            temp.append(item[11])    #故障开始时间
            startTimeSub= datetime.strptime(startTime,"%Y-%m-%d %H:%M") - timedelta(minutes = 10) #结果为datetime.datetime类型 ï¼Œéœ€è¦å†è½¬ä¸ºå­—符串类型
@@ -178,6 +177,7 @@
    for i in power_supply_abnormal :
        print(i)
    

    #将供电异常的信息写入数据库异常表中
    abnormal_write_to_SQL(power_supply_abnormal,con)   #将设备故障信息写入异常表
    print('供电异常的信息写入异常表完成!')
@@ -314,9 +314,12 @@
def refind_ea(list):  #一条记录，也就是一个列表
    temp=[]
    temp.append(generate_short_uuid())
    # è®¾å¤‡ç¼–号
    temp.append(list[2])
    # åº—铺名字
    temp.append(list[1])
    temp.append(list[0])
    # ä¾›åº”商
    temp.append(list[3])
    temp.append(1)
    print(temp)
    return temp
@@ -388,7 +391,7 @@
    temp.append(list[7])   #净化器电流 7
    temp.append(list[4])   #进油烟浓度值
    temp.append(list[5])   #排油烟浓度值
    temp.append(list[14])  #重复的次数
    temp.append(list[13])  #重复的次数

    print(temp)
    return temp

 src/write_to_minute_table.py

@@ -16,7 +16,7 @@
    temp.append(list[7])   #净化器电流 7
    temp.append(list[4])   #进油烟浓度值
    temp.append(list[5])   #排油烟浓度值
    temp.append(list[14])  #重复的次数
    temp.append(list[13])  #重复的次数

    print(temp)
    return temp

 test_get_data/__init__.py

 test_get_data/__pycache__/__init__.cpython-38.pyc

Binary files differ

 test_get_data/__pycache__/__init__.cpython-39.pyc

Binary files differ

 test_get_data/__pycache__/login.cpython-38.pyc

Binary files differ

 test_get_data/__pycache__/login.cpython-39.pyc

Binary files differ

 test_get_data/__pycache__/request.cpython-38.pyc

Binary files differ

 test_get_data/__pycache__/request.cpython-39.pyc

Binary files differ

 test_get_data/__pycache__/url_help.cpython-38.pyc

Binary files differ

 test_get_data/__pycache__/url_help.cpython-39.pyc

Binary files differ

 test_get_data/database_connect.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,86 @@
import sys
import os
sys.path.append(os.path.dirname(__file__))
# sys.path.append('E:\\ruanjian\\Python\\Lib\\site-packages')



from sqlalchemy import create_engine
class DataBase:
    """ è¿œç¨‹æ•°æ®åº“ """
    # con_read = None
    # con_write = None
    # ip = '114.215.109.124'
    # user = 'fumeRemote'
    # password = 'feiyu2023'
    # port = 3306
    # data_base_name = 'fume'


    """ æœ¬æœº """
    con_read = None
    con_write = None
    ip = 'localhost'
    user = 'root'
    password = '1234'
    port = 3306
    data_base_name = 'qianduan_sql'



    """连接数据库
    """
    def connect_remote_database_read(self):


        if self.con_read == None or self.con_read.closed:
            engine = create_engine(f"mysql+pymysql://{self.user}:{self.password}@{self.ip}:{self.port}/{self.data_base_name}?charset=utf8",pool_recycle=3600, pool_size=3, max_overflow=0)
            self.con_read = engine.connect()
        return self.con_read

    def connect_remote_database_write(self):
        """ å†™"""

    
        if self.con_write == None or self.con_write.closed:
            engine = create_engine(f"mysql+pymysql://{self.user}:{self.password}@{self.ip}:{self.port}/{self.data_base_name}?charset=utf8",pool_recycle=3600, pool_size=3, max_overflow=0)
            self.con_write = engine.connect()
        return self.con_write


    # """ è¿žæŽ¥æœ¬åœ°æ•°æ®åº“ 
    # """
    # def connect_local_database_read(self):
    #     """ è¯»æ•°æ®
    #     """
    #     if self.con_read == None or self.con_read.closed:
    #         engine = create_engine(f"mysql+pymysql://{self.user}:{self.password}@{self.ip}:{self.port}/{self.data_base_name}?charset=utf8")
    #         self.con_read = engine.connect()
    #     return self.con_read

    # def connect_local_database_write(self):
    #     """ å†™æ•°æ®
    #     """
    #     if self.con_write == None or self.con_write.closed:
    #         engine = create_engine(f"mysql+pymysql://{self.user}:{self.password}@{self.ip}:{self.port}/{self.data_base_name}?charset=utf8")
    #         self.con_write = engine.connect()
    #     return self.con_write


    def disconnect(self,area_type:str,option_type:str):
        """"断开连接

        Args:
            area_type (str): æ•°æ®åº“所属位置。local与remote
            option_type (str): æ“ä½œç±»åž‹ã€‚write和read
        """

        self.con_read.close()


# å…¶ä»–文件导入此对象即可 
datebase_single_obj = DataBase()

if __name__ == '__main__':
    # print(datebase_single_obj.connect_remote_database_read()) 
    pass

 test_get_data/get_data.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,92 @@
from test_get_data.request import request_get
from test_get_data.url_help import Url
from test_get_data.login import *

from bs4 import BeautifulSoup as bs  
import re              #正则表达式
import time

import sys
sys.path.append('../../')
import src.core_modules.remove_duplicates_methods as rdm

now_date = time.strftime("%Y-%m-%d", time.localtime())    #获取当前年月日  #url编码年月日开始默认时间
now_date1 = time.strftime("%Y-%m", time.localtime())  
month_begin=now_date1+'-01'                 #设置当前月份的开始

list_temp=[]  #临时列表  å…¨å±€å˜é‡



#-------------------------------------------------------------------------------------------------------------特殊的url
def get_OnePage_teshu(url,count=1):     #抓取一页的数据,放入list_data中.urls为要访问的网页地址
    global list_temp    #使用全局变量

    list_temp.clear()  #清空临时表

    r = request_get(url).text
    soup = bs(r,'html.parser')

    list=[]                     #创建列表来保存结果
   
    # æ‰¾åˆ°æ‰€æœ‰çš„tr标签
    rows = soup.find_all('tr')

    # æå–表格中的数据
    result = []
    for row in rows:
        data = []
        cols = row.find_all('td')
        for col in cols:
            if col.find('div'):
                # å¦‚æžœtd中包含div，则单独提取其内容
                div_content = col.find('div').text.strip()
                # data.append(col.find('td').text.strip())
                # è¿”回元素的文本内容 æœç´¢tag的直接子节点
                td_content = ''.join(col.find_all(text=True, recursive=False)).strip()
                data.append(td_content)
                data.append(div_content)
            else:
                # å¦‚æžœtd中不包含div，则直接提取td的内容
                td_content = col.text.strip()
                data.append(td_content)
        del (data[-2:])
        del (data[2])
        result.append(data)
     # åˆ é™¤è¡¨å¤´
    del (result[0])
    # æ‰“印提取的数据
    print(result)

  

    # for tag in tags:  # æ¯ä¸ªtag是一行
    #     element = tag.text  # èŽ·å–<tr>标签内所有文本信息
    #     element = element.strip()  # å°†å­—符串首尾空格去除
    #     list1 = element.split();  # ä»¥ç©ºæ ¼ä¸ºåˆ†éš”将字符串变为列表

    #     # del (list1[-2:])            #列表最后两个元素不需要,删除
    #     # print('删除特殊的后两个')
    #     # print(list1)
    #     list.append(list1) 
    # print(list)

    # list_data=[]  
    # for i in list:                   
    #     list_data.append(merge(i))   #将尾日期数据合并成年月日 æ—¶åˆ†ç§’
    # del list_data[0]          #删除文字表头   
    # count=count-1             #删除了表头,总数据的行数减一
    # #print(lt_isates_list(list_data)[:]    #将所有数据复制给临时列表list_temp   æ˜¯åŽ»é™¤é‡å¤åŽçš„列表
    # list_temp=list_data[:]
    # return count

if __name__ == '__main__':
    # ç™»å½•
    login_fume_web()
    u = Url()
    urls = u.concatenate_url_with_condition('杨记齐齐哈尔烤肉','2023-10-01','2023-10-31',1)
    for item in urls:
        get_OnePage_teshu(item)

    


 test_get_data/login.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,64 @@
from test_get_data.request import request_post,request_get
import time
import json
import base64

import src.user.account_photo as account

def get_time():
    # æ¯«ç§’妙级时间戳 13位数字
    now_time = str(int(time.time()*1000))
    return now_time

def get_photo_url(url):
    return url + get_time()



def base64_api(img):
    # è¿”回账号密码
    uname,pwd = account.back_account_password()
    with open(img, 'rb') as f:
        base64_data = base64.b64encode(f.read())
        b64 = base64_data.decode()
    data = {"username": uname, "password": pwd, "typeid": 2, "image": b64}
    result = json.loads(request_post("http://api.ttshitu.com/predict", data))
    if result['success']:
        return result["data"]["result"]
    else:
        #！！！！！！！注意：返回 äººå·¥ä¸è¶³ç­‰ é”™è¯¯æƒ…况 è¯·åŠ é€»è¾‘处理防止脚本卡死 ç»§ç»­é‡æ–° è¯†åˆ«
        return result["message"]
    return ""



def login_fume_web():
    # è¯·æ±‚验证码地址
    # æž„造时间戳
    # æ‹¼æŽ¥url
    # è¯†åˆ«éªŒè¯ç 
    url_photo = get_photo_url('http://xhhb.senzly.cn/servlet/Vcode_new.serv?t=')
    response = request_get(url_photo)         # å›¾ç‰‡ä¸ºäºŒè¿›åˆ¶æ•°æ®
    image_data = response.content
    with open('Vcode.jpg',mode='wb') as f:
        f.write(image_data)
    # éªŒè¯ç ç»“æžœ
    v_code_result = base64_api('Vcode.jpg')


    play_load = {
        "account": "9SUBjEeNy7nFMzk123",
        "password": "6SUBIyusanb170e13a221a4cb58c66876006488504",
        "vcode": v_code_result
    }

    url_jump = 'http://xhhb.senzly.cn/cusLogin.php'
    request_post(url_jump,play_load)
    print('登录成功')

    # return session
    # ä¸ªäººéªŒè¯


if __name__ == '__main__':
    login_fume_web()

 test_get_data/request.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
import requests
import urllib3

class MyRequest:
    def __init__(self):
        urllib3.disable_warnings()
        self.session = requests.session()
        self.session.headers = {
           "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
        }

    def get(self,url:str):
        r = self.session.get(url, verify=False)
        if r.status_code != 200:
            return False
        return r

    def post(self, url: str, params: dict):
        """post请求

        Args:
            url (str): ç›®æ ‡url
            params (dict): è¯·æ±‚参数

        Returns:
            _type_: å“åº”内容
        """
        r = self.session.post(url, data=params, verify=False)
        if r.status_code != 200:
            return False
        return r.text



_my_request = MyRequest()
request_post = _my_request.post
request_get  = _my_request.get

 test_get_data/url_help.py

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
import urllib.parse 

class Url:
    
    def concatenate_url_with_condition(self,shop_name,date_begin,date_end,page_num)->list:
        """形成完整的url"""
        # åå­—编码
        base_url = self.encoding_shop_name(shop_name)
        # åŠ ä¸Šæ—¥æœŸæ¡ä»¶
        url_with_date = self.url_add_date(base_url,date_begin,date_end)
        # åŠ ä¸Šé¡µæ•°æ¡ä»¶
        sub_urls_wait_for_request = self.list_add_page(url_with_date,page_num)
        return sub_urls_wait_for_request



    def url_add_date(self,url,date_begin,date_end):     #url,å¹´-月-日 2023-05-03
        url_date=url+'&key5='+date_begin+'&key6='+date_end
        return url_date
    
    def list_add_page(self,url,page_num):  # url中的i是页 ,apge_num表示爬取的页数  ã€‚url后面加上页的参数
        urls = [url+'&page'+'={}'.format(str(i)) for i in range(1,page_num+1)]
        return urls 
    
    def encoding_shop_name(self,shop_name):
        encoded_shop_name = urllib.parse.quote(urllib.parse.quote(shop_name))
       
        return 'http://xhhb.senzly.cn/sys/yyRealTimeValue_list.jsp?key1=&shop='+encoded_shop_name+'&pagesize=100'
    


if __name__ == '__main__':
    u = Url()
    urls = u.concatenate_url_with_condition('食其家','2023-10-01','2023-10-31',5)
    for item in urls:
        print(item)