Category: 技术折腾

服务器、网络、硬件与自建工具的实践记录。

  • 如何使用Python将彩票数据存入数据库

    如何使用Python将彩票数据存入数据库

    在数据科学和分析领域,获取和存储数据是至关重要的一步。本教程将介绍如何使用Python编程,从一个网站获取双色球(SSQ)彩票的历史数据,并将这些数据存入MySQL数据库。这个教程将向您展示如何使用Python的Requests库来获取数据,以及如何使用Pymysql库将数据存入数据库中。这是一个非常实用的示例,可以帮助您了解如何从网站爬取数据并进行数据库操作。

    准备工作

    在开始之前,您需要确保已经安装了以下Python库:

    • Requests:用于发送HTTP请求和获取网页内容。
    • Pymysql:用于与MySQL数据库交互。

    您可以使用以下命令来安装这些库:

    pip install requests pymysql

    此外,您还需要拥有一个MySQL数据库,并知道连接数据库所需的主机、用户名和密码。在教程的后续部分,我们将向数据库插入数据。

    获取彩票数据

    首先,我们需要从一个网站获取双色球彩票的历史数据。我们将使用Python的Requests库来发送HTTP POST请求,并将响应解析为JSON格式。以下是获取数据的代码示例:

    import requests
    import json
    
    headers ={
        'Content-Type': 'application/json',
        'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148'
    }
    
    data ={
        "limit": 20,
        "page": 1,
        "params": {}
    }
    
    resp = requests.post('https://ms.zhcw.com/proxy/lottery-chart-center/history/SSQ', headers=headers, data=json.dumps(data))
    result = json.loads(resp.text)['datas']

    在上述代码中,我们发送了一个HTTP POST请求到指定的URL,并将响应解析为JSON格式。这个URL包含了彩票数据的API端点,您可以根据需要修改URL来获取不同的数据。

    处理彩票数据

    接下来,我们需要处理从网站获取的彩票数据,以便将其存入数据库。我们将数据存储在一个列表中,每个元素都代表一期彩票的信息,包括期号、开奖日期、星期几以及中奖号码。我们还对数据进行了排序,以确保按期号的顺序存入数据库。

    def historyData():
        h_data_list = []
        for i in range(len(result)):
            issue = result[i]['issue']
            openDate = result[i]['openDate']
            week = result[i]['week']
            winningFrontNum = result[i]['winningFrontNum']
            winningBackNum = result[i]['winningBackNum']
            h_data_list.append([issue, openDate, week,winningFrontNum,winningBackNum])
        h_data_list = sorted(h_data_list, key=lambda x: x[0])  # 从小到大排序

    连接数据库并创建表

    现在,我们将使用Pymysql库来连接到MySQL数据库,并创建一个表来存储彩票数据。在下面的代码示例中,您需要替换掩码字符(****)为您的数据库主机、用户名和密码。

    import pymysql
    
    # 连接数据库
    conn = pymysql.connect(host='****', user='root', password='***', db='mysql')
    cursor = conn.cursor()
    
    # 创建表
    cursor.execute('''CREATE TABLE IF NOT EXISTS ssq_lottery_history
                      (id INT PRIMARY KEY AUTO_INCREMENT,
                       issue VARCHAR(20),
                       openDate VARCHAR(20),
                       week VARCHAR(20),
                       winningFrontNum VARCHAR(20),
                       winningBackNum VARCHAR(20)
                       )''')

    在上述代码中,我们使用Pymysql库连接到数据库,并执行SQL语句来创建表格。如果表格已经存在,它将不会被重新创建。

    插入数据到数据库

    现在,我们将彩票数据插入到数据库表中。以下是将数据插入数据库的代码示例:

    # 向表中插入数据
    for item in h_data_list:
        cursor.execute('''INSERT INTO ssq_lottery_history (issue, openDate, week,winningFrontNum,winningBackNum)
                          VALUES (%s, %s, %s, %s, %s)''', (item[0], item[1], item[2], item[3], item[4]))
    print("存入数据库成功")
    # 提交数据并关闭连接
    conn.commit()
    cursor.close()
    conn.close()

    在上述代码中,我们使用循环遍历彩票数据列表,并将每一项数据插入到数据库表中。然后,我们提交更改并关闭数据库连接。

    运行脚本

    最后,您可以运行这个Python脚本来获取彩票数据并将其存入数据库。确保您已经准备好了数据库,并且在运行脚本之前替换了数据库连接的主机、用户名和密码。

    if __name__ == '__main__':
        historyData()

    结论

    通过本教程,您学会了如何使用Python编程从网站获取彩票数据,并将其存入MySQL数据库。这是一个实际的应用示例,可以帮助您了解如何使用Python的Requests库和Pymysql库来处理网络数据和数据库操作。希望这个教程对您有所帮助,让您能够更好地处理和管理数据。


    请注意:本教程仅供学习和参考,不鼓励或支持任何侵犯法律或道德准则的行为。请在合法范围内使用Python编程技术。

  • 使用FastAPI创建可下载Excel文件的Web应用

    使用FastAPI创建可下载Excel文件的Web应用

    在现代Web开发中,为用户提供下载功能是一项常见的需求。本教程将介绍如何使用FastAPI框架创建一个简单的Web应用,允许用户下载Excel文件。我们将演示如何生成Excel文件并将其作为响应发送给客户端。

    创建FastAPI应用

    首先,确保您已经安装了FastAPI库。如果没有安装,可以使用以下命令进行安装:

    pip install fastapi

    接下来,我们将创建一个FastAPI应用,其中包括一个路由,允许用户下载Excel文件。

    from fastapi import FastAPI, Response
    from fastapi.responses import StreamingResponse
    import pandas as pd
    import io
    import xlsxwriter
    
    app = FastAPI()

    生成Excel文件

    在我们的示例中,我们将创建一个简单的DataFrame,并将其转换为Excel文件。这个Excel文件将包含一些示例数据。

    @app.get("/")
    async def download_excel():
        # 生成一个简单的 DataFrame
        data = {"name": ["Alice", "Bob", "Charlie"], "age": [25, 30, 35]}
        df = pd.DataFrame(data)
    
        # 将 DataFrame 转换为 Excel 文件
        buffer = io.BytesIO()
        workbook = xlsxwriter.Workbook(buffer)
        worksheet = workbook.add_worksheet()
        for i, col in enumerate(df.columns):
            worksheet.write(0, i, col)
            for j, value in enumerate(df[col]):
                worksheet.write(j + 1, i, value)
        workbook.close()
    
        # 将 Excel 文件转换为字节流,作为响应体返回给客户端
        buffer.seek(0)
        excel_bytes = buffer.getvalue()
        return StreamingResponse(
            io.BytesIO(excel_bytes),
            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            headers={"Content-Disposition": "attachment; filename=myfile.xlsx"}
        )

    在上述代码中,我们首先创建了一个简单的DataFrame,然后使用xlsxwriter库将其转换为Excel文件。最后,我们将Excel文件转换为字节流,并将其作为响应的一部分返回给客户端。

    运行FastAPI应用

    要运行我们的FastAPI应用,您可以使用以下命令:

    uvicorn main:app --host=127.0.0.1 --port=8000 --reload

    确保将main替换为您的文件名(如果不是main.py),并选择适合您的主机和端口号。

    使用您的Web应用

    现在,您的FastAPI应用已经在本地运行,您可以通过浏览器或API客户端访问它。当您访问根路径(/)时,应用将生成一个包含示例数据的Excel文件,并将其作为下载提供。

    结论

    通过本教程,您学会了如何使用FastAPI框架创建一个简单的Web应用,允许用户下载Excel文件。这对于需要向用户提供数据报表或导出功能的Web应用程序非常有用。希望这个教程对您有所帮助,让您能够更好地理解如何使用FastAPI来处理文件下载功能。


    请注意:本教程仅供学习和参考,不鼓励或支持任何侵犯版权或非法行为。请在合法的范围内使用Web开发技术。

  • 如何使用Python和Pyppeteer爬取动态网页数据

    如何使用Python和Pyppeteer爬取动态网页数据

    在现代互联网时代,许多网站采用动态加载技术,使得传统的静态网页爬取方法不再有效。本教程将向您介绍如何使用Python和Pyppeteer库来爬取动态网页数据。我们将通过一个实际的示例来演示这一过程,以便您能够掌握这一有用的技能。

    准备工作

    在开始之前,请确保您已经安装了Python,并按照以下步骤进行准备工作:

    1. 安装Python库:我们将使用pyppeteer库来模拟浏览器操作。您可以使用以下命令来安装它:

      pip install pyppeteer
    2. 确保您了解一些基本的Python编程知识,包括异步编程和基本的Web爬取概念。

    创建爬虫程序

    下面是一个示例爬虫程序,用于爬取动态加载的网页数据。这个示例程序将从一个网站中获取数据,并演示了如何模拟浏览器操作。

    import asyncio
    from pyppeteer import launch
    
    from collections import namedtuple
    
    def screen_size():
        """使用tkinter获取屏幕大小"""
        import tkinter
        tk = tkinter.Tk()
        width = tk.winfo_screenwidth()
        height = tk.winfo_screenheight()
        tk.quit()
        return width, height
    
    async def main():
        browser = await launch({'headless': False, 'args': ['--no-sandbox'], })
        page = await browser.newPage()
        width, height = screen_size()
        await page.setViewport(viewport={"width": width, "height": height})
        await page.setJavaScriptEnabled(enabled=True)
        await page.setUserAgent(
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
            '(KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299'
        )
        await page.evaluate('''() =>{ Object.defineProperties(navigator,{ webdriver:{ get: () => false } }) }''')
        await page.goto(website.url)
    
        now_page = 0
    
        while True:
    
            now_page += 1
            await page.evaluate('window.scrollBy(0, document.body.scrollHeight)')
            await asyncio.sleep(1)
            li_list = await page.querySelectorAll(website.list_query)
    
            for li in li_list:
                try:
                    title_obj = await li.querySelector("a ")
                    title_url = await page.evaluate('(element) => element.href', title_obj)
                    title_name = await page.evaluate('(element) => element.textContent', title_obj)
                    date_obj = await li.querySelector(website.title_date_query)
                    title_date = await page.evaluate('(element) => element.textContent', date_obj)
                    detail_page = await browser.newPage()
                    await detail_page.goto(url=str(title_url))
                    await detail_page.content()
                    element = await detail_page.querySelector(website.content_query)
                    content_html = await detail_page.evaluate('(element) => element.outerHTML', element)
                    print(title_url, title_name, title_date, len(content_html))
                    await detail_page.close()
                except Exception as e:
                    print(e)
            print(f"第{now_page}页访问>>>>>")
            next_page_link = website.next_page_query
    
            if next_page_link:
                await page.click(next_page_link)
            else:
                raise Exception("已完成爬取,即将退出...")
    
            await asyncio.sleep(2)
    
    async def page_close(browser):
        for _page in await browser.pages():
            await _page.close()
        await browser.close()
    
    if __name__ == '__main__':
        Websites = namedtuple('websites', ['url', 'list_query', 'title_date_query', 'content_query', 'next_page_query'])
    
        websites = [
            (
                'http://www.cqzbtb.cn/_jiaoyixinxi/',
                '.listbox ul',
                '.ys',
                '.article-wrap',
                "body > section > div > div.list-wrap.row > div.listpa > ul > li:nth-child(7)"
            ),
    
        ]
        for i in websites:
            website = Websites._make(i)
    
            a = main()
            loop = asyncio.get_event_loop()
            results = loop.run_until_complete(asyncio.gather(a))

    这段代码使用Pyppeteer库创建了一个浏览器实例,然后模拟了许多浏览器操作,包括访问网页、滚动页面、点击下一页等。它还演示了如何从网页中提取数据,并处理了异常情况。

    结论

    通过本教程,您学会了如何使用Python和Pyppeteer库来爬取动态加载的网页数据。这对于需要获取动态生成内容的网站非常有用。请注意,在进行网页爬取时,务必遵守网站的使用政策和法律法规。

  • 如何使用Python爬取BT种子资源并进行分析

    如何使用Python爬取BT种子资源并进行分析

    在数字时代,获取各种信息变得愈加便捷,但有时我们需要特定的数据或资源,而互联网上的BT种子资源是一种常见的需求。本教程将向您展示如何使用Python编写爬虫程序,以获取BT种子资源并进行基本的分析。无论是寻找最新的电影、音乐、软件,还是满足其他资源需求,本教程都将帮助您掌握这一技能。

    准备工作

    在开始之前,确保您已经安装了Python,并且具备以下准备工作:

    1. 安装Python库:我们将使用requests和BeautifulSoup库来进行网页爬取和解析。您可以使用以下命令来安装它们:

      pip install requests
      pip install beautifulsoup4
    2. 确保您了解一些基本的Python编程知识,包括变量、循环和条件语句。

    爬取BT种子资源

    首先,我们需要编写Python代码来爬取BT种子资源。以下是示例代码:

    from bs4 import BeautifulSoup
    import requests
    from urllib.parse import quote
    
    # 设置请求头
    headers = {
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.50'
    }
    
    # 输入关键词
    keyword = input("请输入关键词: ")
    
    # 构建搜索URL
    search_url = f'https://tellme.pw/bts/search/{quote(keyword)}'
    
    # 发送GET请求
    response = requests.get(url=search_url, headers=headers)
    
    # 使用BeautifulSoup解析页面内容
    soup = BeautifulSoup(response.text, 'lxml')
    
    # 提取种子信息
    magnet_links = []
    titles = []
    sizes = []
    dates = []
    
    # 迭代页面
    for page in range(1, 51):  # 最多爬取50页
        page_url = f'{search_url}/page/{page}'
        response = requests.get(url=page_url, headers=headers)
        soup = BeautifulSoup(response.text, 'lxml')
        data_list = soup.find_all("a", {"href": re.compile("\/\/btsow\.*?"), "title": re.compile('.*?')})
    
        # 提取种子信息并存储
        for item in data_list:
            magnet_links.append('magnet:?xt=urn:btih:' + item.get('href')[-40:])
            titles.append(item.get('title'))
            size_info = item.find("div", {"class": re.compile('.*?size')}).get_text().split(" / ")
            size = size_info[0][5:-2]
            size_unit = size_info[0][-2:]
            if size_unit == "TB":
                sizes.append(float(size) * 1024 ** 2)
            elif size_unit == "GB":
                sizes.append(float(size) * 1024)
            elif size_unit == "MB":
                sizes.append(float(size))
            elif size_unit == "KB":
                sizes.append(float(size) / 1024)
            else:
                sizes.append(0)
            dates.append(size_info[1][13:])
    
    # 打印获取的资源信息
    if len(magnet_links) == 0:
        print('未找到任何资源')
    else:
        print('链接数量:', len(magnet_links))
        print('详细内容:')
        for i in range(len(magnet_links)):
            print(magnet_links[i] + '\t' + str(sizes[i]) + '\t' + titles[i])

    以上代码首先发送GET请求,然后使用BeautifulSoup解析页面内容,提取了种子的磁力链接、标题、大小和日期。最后,将这些信息打印出来供用户查看。

    数据分析与保存

    如果您想进一步分析或保存这些种子信息,可以将数据存储到CSV文件中。以下是如何做到的代码:

    import csv
    
    # 创建CSV文件并写入数据
    if len(magnet_links) > 0:
        with open(f'{keyword}.csv', mode='w', newline='', encoding='utf-8-sig') as file:
            writer = csv.writer(file)
            writer.writerow(['种子名', '磁力链接', '文件大小(单位:MB)', '日期'])
            for i in range(len(magnet_links)):
                writer.writerow([titles[i], magnet_links[i], sizes[i], dates[i]])
        print('数据已保存到文件:', f'{keyword}.csv')

    这段代码将数据写入一个CSV文件中,包括种子名、磁力链接、文件大小和日期等信息。

    结论

    通过这个简单的Python爬虫程序,您可以轻松地获取BT种子资源并进行基本的分析。这对于那些希望找到特定内容的用户来说是非常有用的。请记住,在使用爬虫时要遵守网站的规定和法律法规。

    希望这个教程对您有所帮助,让您更好地理解如何使用Python进行网页爬取和数据分析。


    注意:本教程仅供学习和参考,不鼓励或支持任何侵犯版权或非法行为。请在合法的范围内使用爬虫技术。

  • 如何使用Python获取本机和局域网IP地址与MAC地址

    如何使用Python获取本机和局域网IP地址与MAC地址

    在今天的教程中,我们将学习如何使用Python编写一个小工具,用于获取本机和局域网中设备的IP地址和MAC地址。这个工具可以在网络维护和故障排除时非常有用,同时也是自由职业者提高效率的好帮手。通过本教程,您将了解如何使用Python来执行网络命令、解析命令输出,并将结果保存到文本文件中。

    准备工作

    在开始之前,确保您已经安装了以下两个Python库:

    • win32api:用于弹出Windows消息框。
    • win32con:用于定义Windows消息框的样式。

    您可以使用以下命令来安装这两个库:

    pip install pypiwin32

    编写Python脚本

    我们将编写一个Python脚本,它执行以下任务:

    1. 获取本机的IP地址和MAC地址。
    2. 获取局域网中其他设备的IP地址和MAC地址。
    3. 将获取到的结果保存到文本文件中。
    4. 弹出一个Windows消息框,提醒用户结果已保存。

    以下是完整的Python代码:

    import os
    import win32api
    import win32con
    
    def msgbox(msg, title='提醒'):
        win32api.MessageBox(0, msg, title, win32con.MB_OK)
    
    def local_ip_mac():  # 本机IP和MAC
        output = os.popen('ipconfig /all')
        for i in output:
            if '物理地址.' in i:
                mac = i.split(':')[1].strip()
            if 'IPV4' in i.upper() and '(' in i:
                ip = i.split(':')[1].split('(')[0].strip()
        if ip and mac:
            return [ip, mac]
    
    def lan_ip_mac():  # 局域网IP和MAC
        ls = []
        output = os.popen('arp -a')
        for i in output:
            if '动态' in i:
                ip, mac, _ = i.strip().split()
                ls.append([ip, mac])
        return ls
    
    if __name__ == '__main__':
        res = lan_ip_mac()
        res.append(local_ip_mac())
        print(res)
    
        # 结果写入文本
        txt = 'ip_mac.txt'
        out_txt = '\n'.join(['\t'.join(i) for i in res])
        with open(txt, 'w') as f:
            f.write(out_txt)
    
        msgbox(f'提取结果已保存到:{txt}')  # 注释掉此行则不弹窗提醒

    运行脚本

    现在,将上述代码保存为一个Python文件,然后运行它。脚本将执行获取本机和局域网IP地址与MAC地址的任务,并将结果保存到名为”ip_mac.txt”的文本文件中。如果您不需要弹出Windows消息框提醒,可以将msgbox函数的调用行注释掉。

    结束语

    通过这个简单的教程,您学会了如何使用Python编写一个小工具,用于获取本机和局域网中设备的IP地址和MAC地址。这个工具对于网络管理和自由职业者的日常工作都非常有用。希望这个教程对您有所帮助,祝您在自由职业生涯中取得成功!

  • 如何使用Python爬取百度贴吧内容

    如何使用Python爬取百度贴吧内容

    在今天的教程中,我将向您介绍如何使用Python编写一个简单的网络爬虫,用于从百度贴吧中获取帖子内容。这个教程将帮助您了解如何使用Python的requests库和BeautifulSoup库来获取网页内容,以及如何将爬取到的数据保存到本地文件中。如果您是一个对网络爬虫和数据获取有兴趣的自由职业者,这个教程可能会对您有所帮助。

    1. 准备工作

    在开始之前,您需要确保已经安装了以下Python库:

    • requests:用于发送HTTP请求以获取网页内容。
    • BeautifulSoup:用于解析HTML网页内容。

    您可以使用以下命令来安装这些库:

    pip install requests
    pip install beautifulsoup4

    2. 编写爬虫代码

    首先,让我们编写一个Python脚本来获取百度贴吧的帖子内容。以下是完整的代码:

    import requests
    import time
    from bs4 import BeautifulSoup
    
    def get_content(url):
        '''
        分析贴吧的网页文件,整理信息,保存在列表变量中
        '''
    
        # 初始化一个列表来保存所有的帖子信息:
        comments = []
        # 使用request请求所需url
        html = requests.get(url)
    
        # 使用BeautifulSoup解析网页内容
        soup = BeautifulSoup(html.text, 'lxml')
    
        # 找到所有具有‘j_thread_list clearfix’属性的li标签
        liTags = soup.find_all('li', attrs={"class":['j_thread_list', 'clearfix']})
    
        # 循环遍历li标签
        for li in liTags:
            # 初始化一个字典来存储帖子信息
            comment = {}
            try:
                # 筛选信息,并保存到字典中
                comment['title'] = li.find('a', attrs={"class": ['j_th_tit']}).text.strip()
                comment['link'] = "tieba.baidu.com/" + li.find('a', attrs={"class": ['j_th_tit']})['href']
                comment['name'] = li.find('span', attrs={"class": ['tb_icon_author']}).text.strip()
                comment['time'] = li.find('span', attrs={"class": ['pull-right is_show_create_time']}).text.strip()
                comment['replyNum'] = li.find('span', attrs={"class": ['threadlist_rep_num center_text']}).text.strip()
                comments.append(comment)
            except:
                print('出了点小问题')
    
        return comments
    
    def Out2File(comments):
        '''
        将爬取到的文件写入到本地
        保存到当前目录的TTBT.txt文件中。
        '''
        with open('TTBT.txt', 'a+', encoding='utf-8') as f:
            for comment in comments:
                f.write('标题:{} \t 链接:{} \t 发帖人:{} \t 发帖时间:{} \t 回复数量:{} \n'.format(
                    comment['title'], comment['link'], comment['name'], comment['time'], comment['replyNum']))
            print('当前页面爬取完成')
    
    def main(base_url, deep):
        url_list = []
        # 将所有需要爬取的url存入列表
        for i in range(0, deep):
            url_list.append(base_url + '&pn=' + str(50 * i))
        # 循环写入所有的数据
        for url in url_list:
            print(f"开始爬取:{url}")
            content = get_content(url)
            print(content)
            Out2File(content)
            time.sleep(5)
        print('所有的信息都已经保存完毕!')
    
    base_url = 'https://tieba.baidu.com/f?ie=utf-8&kw=亚运会'
    # 设置需要爬取的页码数量
    deep = 3
    
    if __name__ == '__main__':
        main(base_url, deep)

    3. 运行爬虫

    现在,让我们来运行这个爬虫脚本。将上述代码保存为一个Python文件,然后运行它。脚本将会爬取百度贴吧关于”亚运会”的帖子内容,并将数据保存到名为”TTBT.txt”的文本文件中。

    4. 结束语

    通过这个简单的教程,您学会了如何使用Python编写一个基本的网络爬虫,用于获取百度贴吧的帖子内容。这只是网络爬虫的入门,您可以进一步探索和学习更多高级的爬虫技巧,以满足您的自由职业需求。

  • 如何使用Git LFS高效管理大文件

    如何使用Git LFS高效管理大文件

    在现代软件开发中,版本控制是一个不可或缺的工具,而Git是最广泛使用的版本控制系统之一。然而,当涉及到管理大文件时,Git的性能可能会受到挑战,因为它不是专门设计用于处理大型二进制文件。这就是为什么Git LFS(Large File Storage)成为了解决这个问题的绝佳选择。本教程将介绍如何使用Git LFS高效地管理大文件,以及一些与之相关的关键概念和命令。

    起源故事

    假设你是一位名叫王大神的自由职业者,充满激情地投身于音乐和技术领域。你经常在自己的项目中使用Git来管理代码和资源文件。然而,有一天,你决定与一位音乐制作人合作,开始制作一首新歌。这首歌的制作涉及到大量的音频和视频文件,它们都相对较大。当你尝试将这些大文件添加到Git仓库时,你突然发现Git的性能急剧下降,仓库变得难以管理。这是一个常见的问题,但不必担心,因为Git LFS将帮助你轻松解决这个问题。

    什么是Git LFS?

    Git LFS是一个Git扩展,旨在解决Git不擅长处理大文件的问题。它的核心思想是将大文件的实际内容存储在专门的Git LFS服务器上,而仓库中只存储指向这些大文件的指针。这使得Git仓库仍然保持较小的大小,同时大文件也能够得到高效地管理。

    下面,我们将深入探讨如何使用Git LFS来管理大文件。

    步骤1:安装Git LFS

    首先,你需要安装Git LFS,以便在Git仓库中启用它。请确保你的系统上已经安装了Git。

    打开终端,并运行以下命令来安装Git LFS:

    git lfs install

    这个命令将在你的Git配置中启用Git LFS支持。

    步骤2:跟踪大文件

    现在,你已经安装了Git LFS,接下来需要告诉Git LFS哪些文件应该被跟踪并由它管理。你可以使用git lfs track命令来实现这一点。假设你的音乐项目中有一个名为song.mp3的大音频文件,你可以运行以下命令:

    git lfs track "song.mp3"

    这将告诉Git LFS跟踪song.mp3文件,并将它替换为Git LFS指针。

    步骤3:提交和推送大文件

    一旦你已经将大文件添加到Git LFS跟踪中,你可以正常使用Git来提交和推送这些文件,就像处理普通文件一样。Git LFS将负责将大文件上传到Git LFS服务器,并在仓库中保留指向这些文件的指针。

    git add .
    git commit -m "Add song.mp3 using Git LFS"
    git push origin master

    步骤4:下载和解锁大文件

    如果你从远程存储库克隆或拉取代码,Git LFS会自动下载所需的大文件。这样,你可以轻松地访问这些文件而无需等待太长时间。

    此外,如果你正在与团队合作,Git LFS还提供了文件锁定功能,以防止多人同时编辑相同的Git LFS文件。你可以使用git lfs locks命令查看文件的锁定状态,并使用锁定和解锁命令来管理文件锁定。

    注意事项

    在使用Git LFS时,有一些注意事项需要牢记:

    • 确保所有团队成员都安装了Git LFS,并了解如何使用它。
    • 不要将二进制文件直接添加到Git仓库中,而是使用Git LFS来管理它们。
    • 定期运行git lfs pull以确保你的本地仓库包含最新版本的大文件。

    结论

    Git LFS是一个强大的工具,可以帮助你高效地管理大文件,而不会损害Git仓库的性能。无论你是音乐制作人、游戏开发者还是任何其他领域的开发者,Git LFS都可以为你提供便利。现在,你可以在你的音乐项目中轻松管理大音频文件,而不必担心Git的限制。

  • 如何使用FRP实现内网机器访问

    如何使用FRP实现内网机器访问

    你是否曾经遇到过这样的情况:在公司或家庭内网中有多台设备,但你想要通过互联网访问它们,或者让它们相互访问,但又不知道如何实现?这时,FRP(Fast Reverse Proxy)就可以派上用场了。FRP是一种开源的端口转发工具,它能够帮助你轻松实现内网机器的访问,而无需暴露它们的真实IP地址。

    在本教程中,我们将介绍如何使用FRP来实现内网机器的访问。我们将从安装和配置FRP开始,然后逐步讲解如何访问不同内网机器以及解决一些常见问题。让我们一起开始吧!

    步骤一:安装和配置FRP

    首先,你需要在你的内网中选择一台机器来运行FRP客户端(frpc),这台机器将充当你的代理。接下来,你需要按照以下步骤来安装和配置FRP:

    1. 下载FRP

    你可以从FRP的官方GitHub仓库(https://github.com/fatedier/frp) 下载最新的FRP版本。选择适合你操作系统的二进制文件进行下载,并解压缩到你的机器上。

    2. 配置FRP客户端

    在FRP的安装目录中,你会找到一个名为frpc.ini的配置文件。打开这个文件并进行以下配置:

    2.1 设置通用配置

    在文件中找到以下通用配置项,并进行相应的配置:

    • server_addr:FRP服务器的地址和端口。
    • token:连接到FRP服务器的令牌。确保它与FRP服务器的配置相匹配。

    2.2 配置端口转发

    你可以根据需要配置不同的端口转发规则,以便访问内网机器的不同服务。例如,如果你想访问内网机器上的HTTP服务器,可以添加以下配置:

    [web]
    type = http
    local_ip = 内网机器的IP地址
    local_port = 80
    remote_port = 8080

    这将把来自FRP服务器的8080端口的请求转发到内网机器的80端口。

    3. 启动FRP客户端

    保存配置文件后,你可以启动FRP客户端。在命令行中导航到FRP的安装目录,并运行以下命令:

    ./frpc -c frpc.ini

    客户端将连接到FRP服务器,并开始监听端口,等待外部请求。

    步骤二:访问内网机器

    一旦你的FRP客户端正在运行,并且配置正确,你就可以通过FRP服务器访问内网机器了。以下是如何访问内网机器的几种常见方式:

    1. 使用FRP的HTTP代理功能

    如果你已经在FRP客户端配置了HTTP代理规则,你可以通过FRP服务器访问内网机器上的Web服务。只需在浏览器中输入FRP服务器的地址和配置的远程端口(例如:http://FRP服务器地址:8080) 就可以访问内网机器的Web页面了。

    2. 使用SSH远程连接

    如果你需要通过SSH访问内网机器,你可以配置FRP客户端的SSH转发规则。然后,你可以使用SSH客户端连接到FRP服务器的远程端口,并将流量转发到内网机器上。这样,你就可以像直接连接到内网机器一样使用SSH。

    3. 配置其他服务

    除了HTTP和SSH,你还可以配置其他服务的端口转发规则,如FTP、RDP等。只需按照相应的规则配置来访问内网机器上的这些服务。

    步骤三:解决常见问题

    在使用FRP时,可能会遇到一些常见问题。以下是一些可能出现的问题以及如何解决它们的方法:

    1. 防火墙问题

    如果你的内网机器上有防火墙,确保已经打开了所需的端口,以便FRP可以正常工作。另外,还要确保FRP客户端的防火墙规则允许出站连接。

    2. FRP服务器故障

    如果你无法连接到FRP服务器,首先检查服务器是否正常运行。另外,确保你的FRP客户端配置中的server_addr和token与服务器配置匹配。

    3. 端口冲突

    如果你在FRP客户端配置中使用的远程端口与其他服务冲突,会导致问题。确保你选择了未被占用的端口,并且防火墙没有阻止该端口的流量。

    结论

    使用FRP,你可以轻松实现内网机器的访问,而无需暴露它们的真实IP地址。通过正确配置FRP客户端,你可以访问内网机器上的各种服务,包括Web、SSH、FTP等。同时,记得解决常见问题,以确保一切正常运行。

    希望本教程对你有所帮助,让你更好地利用FRP来管理和访问内网机器。如果你有任何疑问或问题,请随时在下方留言,我们将竭诚为你解答。

  • 教程:将银行账单转换为Beancount格式

    教程:将银行账单转换为Beancount格式

    在日常生活中,我们经常需要处理各种银行账单,包括信用卡账单、储蓄账户账单等。而Beancount是一种强大的财务记账工具,可以帮助我们有效地管理和跟踪财务交易。本教程将向您展示如何将不同银行的账单转换为Beancount格式,以便更好地管理个人财务。

    背景故事

    假设您有多个银行账户,每月都会收到不同银行的账单。这些账单可能以不同的格式和结构呈现,使您难以一目了然地了解自己的财务状况。同时,您可能还希望将这些财务数据记录到Beancount中,以便轻松生成财务报表和分析您的支出。

    因此,本教程将介绍如何使用Python编程语言来处理不同银行的账单,并将其转换为Beancount格式,使您能够更轻松地管理个人财务。

    准备工作

    在开始之前,您需要准备以下工作:

    1. 确保您已经安装了Python编程语言。

    2. 确保您已经安装了以下Python库:

      • pandas:用于处理和分析数据。
      • numpy:用于数值计算。
      • os:用于文件和目录操作。
      • re:用于正则表达式操作。
    3. 从您的银行获取账单文件,可以是Excel格式或CSV格式。

    教程步骤

    本教程将分为以下几个步骤来实现将银行账单转换为Beancount格式:

    步骤一:导入所需库和设置文件路径

    首先,我们需要导入所需的Python库,并设置输入文件的路径、银行名称以及输出文件的路径。以下是示例代码:

    import os
    import re
    import pandas as pd
    import numpy as np
    
    # 获取当前文件夹路径
    dir = os.path.dirname(os.path.abspath(__file__))
    
    # 输入文件路径,可以手动输入或从命令行获取
    input_file = input("输入账单路径:")
    
    # 输入账单归属银行(目前支持CCB、CMB、SRCB、ABC)
    bank = input("输入账单归属银行[CCB、CMB、SRCB、ABC]:")
    
    # 输出文件路径
    output_file = dir + "\\" + bank + ".bean"
    
    # 配置文件路径
    config_file = dir + "\\config\\" + bank + ".conf"

    在这个步骤中,我们首先获取当前文件夹的路径,然后要求用户输入账单文件的路径和账单归属银行。最后,我们定义了输出文件的路径和配置文件的路径。

    步骤二:整理银行账单数据

    接下来,我们需要根据不同银行的账单格式,编写相应的数据整理函数。我们这里以建设银行(CCB)和招商银行(CMB)为例。

    CCB账单整理

    # CCB账单excel的整理
    def CCB_data(_file_):
        data = pd.read_excel(_file_)
        data.columns = ["No", "text0", "CCY", "Yuan", "time", "cost", "bal", "text1", "text2"]
        data = data.iloc[2:]
        data["time"] = pd.to_datetime(data["time"]).astype(str)
        data.loc[:, "account"] = data["text0"] + ":" + data["text2"]
        data["CCY"] = data["CCY"].replace("人民币元", "CNY")
        data = data[["time", "cost", "CCY", "account", "text0", "text1", "text2"]]
        return data

    CMB账单整理

    # CMB账单csv的整理
    def CMB_data(_file_):
        data = pd.read_csv(_file_)
        data.columns = ["time", "CCY", "cost", "bal", "text0", "text2"]
        data["time"] = pd.to_datetime(data["time"]).astype(str)
        data["cost"] = data["cost"].astype(str)
        data.loc[:, "text1"] = None
        data.loc[:, "account"] = data["text0"] + ":" + data["text2"]
        data = data[["time", "cost", "CCY", "account", "text0", "text1", "text2"]]
        return data

    在这两个函数中,我们分别处理了建设银行和招商银行的账单数据,整理成统一的数据格式,包括时间、金额、货币代码、账户信息等。

    步骤三:关键字查找和替换

    接下来,我们需要根据配置文件中的关键字,对账单中的账户信息进行查找和替换。这可以帮助我们将不同的账户信息映射到统一的账户名称。

    # 关键字查找替换
    def replace(_data_, _config_):
        conf = pd.read_csv(_config_)
        for conf in conf.itertuples():
            _data_ = _data_.str.replace(".*" + conf[1] + ".*", conf[2], regex=True)
        return _data_

    在这个函数中,我们读取了配置文件中的关键字和对应的替换值,然后使用正则表达式在账单数据中进行查找和替换操作。

    步骤四:生成Beancount格式的字段

    最后,我们将整理后的账单数据转换为Beancount格式的字段,以便后续导入到Beancount中。以下是生成Beancount字段的函数:

    # 输出beancount格式的字段
    def to_bean(_data_):
        global bank
        bean = _data_["time"] + ' * \"' + _data_["text
    
    0"] + '\"\n\t'
        if _data_["text1"].notnull().any():
            bean = bean + 'notes: \"' + _data_["text1"] + '\"\n\t' 
        bean = bean + 'id: \"' + _data_["text2"] + '\"\n\t'
        bean = bean + "Assets:Bank:" + bank + " " + _data_["cost"] + " " + _data_["CCY"] + "\n\t"
        bean = bean + _data_["account"] + "\n"
    
        return bean

    在这个函数中,我们根据Beancount的格式规范,构建了包括时间、交易描述、备注、账户信息、金额和货币代码的字段。

    步骤五:导出Beancount文件

    最后一步是将生成的Beancount字段写入到输出文件中,以完成账单转换操作。

    # 整理为beancount格式
    if bank == "CCB":
        DATA = CCB_data(input_file)
    if bank == "CMB":
        DATA = CMB_data(input_file)
    
    # 按conf文件查找替换关键字
    DATA["account"] = replace(DATA["account"], config_file)
    
    # 整理为beancount格式的字段
    bean = to_bean(DATA).to_frame()
    
    # 输出Beancount文件
    for bean in bean.itertuples():
        text = text + str(bean[1]) + "\n"
    
    file = open(output_file, 'w')
    file.write(text)
    file.close()

    在这个步骤中,我们根据用户输入的银行名称选择相应的账单整理函数,然后进行关键字查找和替换操作,最后生成Beancount字段并导出到文件中。

    结语

    通过本教程,您学会了如何将不同银行的账单转换为Beancount格式,从而更好地管理个人财务。这将帮助您轻松跟踪支出、生成财务报表,并更好地了解自己的财务状况。

  • OPCache 分析报告

    OPCache 分析报告

    OPCache(PHP Opcode Cache)是一个用于提高 PHP 性能的重要工具,它通过缓存 PHP 脚本的编译代码来减少服务器的负载,提高网站的响应速度。在本报告中,我们将对OPCache进行详细分析,包括使用率、内存使用、命中率、存储Keys、临时字符串存储内存、状态以及配置信息。

    OPCache 使用率

    上移下移切换面板:OPCache 使用率

    在这一部分,我们将查看OPCache的使用率情况。

    • 已用内存:79.64 MB
    • 剩余内存:48.36 MB
    • 浪费内存:0 MB
    • 所有内存:128 MB

    从上面的数据可以看出,已用内存占据了总内存的62.22%,而剩余内存占据了37.78%。这表明OPCache在服务器上占用了一定的内存资源,但仍有一定的剩余内存可供使用。

    刷新缓存

    刷新缓存是一个重要的操作,它可以清除OPCache中的缓存,以便重新加载最新的PHP脚本。这对于在代码更新后立即生效非常重要。

    命中率

    命中率数量比例

    在这一部分,我们将分析OPCache的命中率情况。

    • 命中:13,829,544(99.99%)
    • 未命中:1,853(0.01%)
    • 所有请求:13,831,397(100%)

    从上述数据可以看出,OPCache的命中率非常高,达到了99.99%,这意味着绝大多数请求都从缓存中获取,而不需要重新编译PHP脚本。这对于提高性能非常重要。

    存储Keys

    存储Keys数量比例

    这一部分将分析OPCache中存储Keys的情况。

    • 已用Keys:2,109(1.61%)
    • 剩余Keys:128,878(98.39%)
    • 所有Keys:130,987(100%)

    从上述数据可以看出,OPCache中的已用Keys相对较少,占总Keys的1.61%,而剩余Keys占总Keys的98.39%。这表明OPCache中的Keys数量还有很大的空间,可以继续缓存更多的PHP脚本。

    临时字符串存储内存

    临时字符串存储内存数量比例

    在这一部分,我们将分析OPCache中临时字符串存储内存的情况。

    • 已用内存:5.25 MB(21.88%)
    • 剩余内存:18.75 MB(78.13%)
    • 所有内存:24 MB(100%)

    从上述数据可以看出,OPCache中已用的临时字符串存储内存占总内存的21.88%,而剩余内存占78.13%。这表明OPCache在存储临时字符串方面占用了一定的内存资源,但仍有大量内存可供使用。

    OPCache 状态

    上移下移切换面板:OPCache 状态

    这一部分将提供OPCache的状态信息。

    • num_cached_scripts:1505
    • num_cached_keys:2109
    • max_cached_keys:130987
    • hits:13829544
    • start_time:1700014904
    • last_restart_time:1700840625
    • oom_restarts:0
    • hash_restarts:0
    • manual_restarts:3
    • misses:1853
    • blacklist_misses:0
    • blacklist_miss_ratio:0
    • opcache_hit_rate:99.9866%

    OPCache的状态信息包括缓存的脚本数量、缓存的Keys数量、最大缓存的Keys数量、命中次数、启动时间、最后重新启动时间、OOM重新启动次数、哈希重新启动次数、手动重新启动次数、未命中次数、黑名单未命中次数、黑名单未命中比例以及缓存命中率。这些信息可以用于监控和调整OPCache的性能。

    OPCache 配置信息

    上移下移切换面板:OPCache 配置信息

    这一部分提供了OPCache的配置信息。

    • version:8.1.21
    • opcache_product_name:Zend OPcache
    • enable:1
    • enable_cli:1
    • use_cwd:1
    • validate_timestamps:1
    • memory_consumption:134,217,728
    • interned_strings_buffer:32
    • max_accelerated_files:80,000
    • max_wasted_percentage:0.05
    • consistency_checks:0
    • force_restart_timeout:180
    • revalidate_freq:3
    • jit:1205
    • jit_buffer_size:134,217,728
    • jit_debug:0
    • jit_bisect_limit:0
    • jit_blacklist_root_trace:16
    • jit_blacklist_side_trace:8
    • jit_hot_func:127
    • jit_hot_loop:64
    • jit_hot_return:8
    • jit_hot_side_exit:8
    • jit_max_exit_counters:8192
    • jit_max_loop_unrolls:8
    • jit_max_polymorphic_calls:2
    • jit_max_recursive_calls:2
    • jit_max_recursive_returns:2
    • jit_max_root_traces:1,024
    • jit_max_side_traces:128
    • jit_prof_threshold:0

    这些配置信息包括OPCache的版本、产品名称、启用状态、内存消耗、文件缓存等等。这些配置项可以帮助您调整OPCache以满足您的应用程序需求。

    结论

    本报告对OPCache的使用率、内存使用、命中率、存储Keys、临时字符串存储内存、状态和配置信息进行了详细分析。通过监测和调整OPCache的性能参数,您可以提高PHP应用程序的性能,减少服务器负载,提高用户体验。

    希望这份报告对您有所帮助,如果您有任何问题或需要进一步的帮助,请随时联系我们。