sh复制代码#!/bin/bash
#仓库路径
REPO_PATH=$1
#导出文件的目录以及新建文件夹路径
FOLDER="/Users/nightkid/Downloads"
FOLDER_DATE=`date +%Y%m%d_%H_%M_%S`
PROJECT_NAME=${REPO_PATH##*/}
for arg in "$@"
do
if [ $1 != $arg ]
then
srcfile="$REPO_PATH/$arg"
echo $arg
cpfile="$FOLDER/${PROJECT_NAME}_$FOLDER_DATE/$arg"
folder=${cpfile%/*}
`mkdir -p $folder`
result=`cp -f  $srcfile $cpfile`
echo "$arg"
fi
#打开导出文件夹
open $FOLDER/${PROJECT_NAME}_$FOLDER_DATE
done

sh复制代码#!/bin/bash
REPO_PATH=$1
GIT_SHA=$2
#导出文件保存路径
FOLDER="/Users/nightkid/Downloads"
FOLDER_DATE=`date +%Y%m%d_%H_%M_%S`
PROJECT_NAME=${REPO_PATH##*/}
`mkdir -p $FOLDER`
filepath=$(cd $REPO_PATH; pwd)
split_str=`git show --format= --name-status $GIT_SHA`
echo "$split_str" > "$FOLDER/tmp.txt"
 
split_array=()
split_len=0
while read line
do
split_array[$split_len]=$line
split_len=$split_len+1
 
done < "$FOLDER/tmp.txt"
 
for ((i=0;i<${split_array[@]};i++));do
{
	string=${split_array[$i]}
 
	array=(${string//,/ })
	if [ "$array[0]" != "D" ]
         then
         echo ${array[1]}
 
		srcfile="$REPO_PATH/${array[1]}"
		cpfile="$FOLDER/${PROJECT_NAME}_$FOLDER_DATE/${array[1]}"
		folder=${cpfile%/*}
		`mkdir -p $folder`
		`cp -f  $srcfile $cpfile`
	fi
#    for var in ${array[@]}
#    do
#      echo $var
#    done
}
open $FOLDER/${PROJECT_NAME}_$FOLDER_DATE
done

bash复制代码当提示一下错误： 
launch path not accessible Completed with errors, see above

您可以通过授予您的用户执行该文件的权限来解决此问题：

chmod +x your-script.sh

lua复制代码#upgrade the transformer package
pip install -U "transformers==4.40.0" --upgrade

ini复制代码import transformers
import torch

model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

pipeline = transformers.pipeline(
  "text-generation",
  model="meta-llama/Meta-Llama-3-8B-Instruct",
  model_kwargs={"torch_dtype": torch.bfloat16},
  device="cuda",
)

pipeline("Hey how are you doing today?")

python复制代码torch.backends.cuda.enable_mem_efficient_sdp(False)
torch.backends.cuda.enable_flash_sdp(False)

python复制代码pipeline = transformers.pipeline(
    "text-generation",
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    model_kwargs={
        "torch_dtype": torch.float16,
        "quantization_config": {"load_in_4bit": True},
        "low_cpu_mem_usage": True,
    },
)

sql复制代码select id from order where order_status = '待支付' && pay_expire_time > now()

py复制代码# 均方误差
def mean_squared_error(y, t):
    return 0.5 * np.sum((y-t)**2)

py复制代码# 交叉熵误差
def cross_entropy_error(y, t):
    delta = 1e-7
    return -np.sum(t * np.log(y + delta))

py复制代码# 通过numpy进行抽样
train_size = x_train_.shape[0] # 60000条
batch_size = 10
batch_mask = np.random.choice(train_size, batch_size) # 随机抽取10个下标
x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]

py复制代码# nparray_test.py 测试
import numpy as np

a = np.array([[11,22,33], [44,55,66]])
print(a.ndim) # 2
print(a.size) # 6，即数组内元素个数
b = a.reshape(1, a.size)
print(b) # [[11 22 33 44 55 66]]
print(b.ndim) # 2，仍然是二维
print(b.size) # 6，元素数不变
print(b.shape) # (1,6)

py复制代码# 中心差分
def numerical_diff(f, x)
    h = 1e-4 # 0.0001
    return (f(x+h)-f(x-h))/(2*h)

py复制代码import numpy as np
import matplotlib.pylab as plt

def numerical_diff(f, x):
    h = 1e-4 # 0.0001
    return (f(x+h) - f(x-h)) / (2*h)

def function_1(x):
    return 0.01*x**2 + 0.1*x 

def tangent_line(f, x):
    d = numerical_diff(f, x)
    print(d)
    y = f(x) - d*x
    return lambda t: d*t + y
     
x = np.arange(0.0, 20.0, 0.1)
y = function_1(x)
plt.xlabel("x")
plt.ylabel("f(x)")

tf = tangent_line(function_1, 5)
y2 = tf(x)

plt.plot(x, y)
plt.plot(x, y2)

py复制代码def function_2(x):
    return x[0]**2 + x[1]**2
    # 或 return np.sum(x**2)

py复制代码def function_tmp1(x0):
    return x0**2 + 4.0**2.0

numerical_diff(function_tmp1, 3.0) # 6.00000

py复制代码import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D

def _numerical_gradient_no_batch(f, x):
    h = 1e-4 # 0.0001
    grad = np.zeros_like(x)
    
    for idx in range(x.size):
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x) # f(x+h)
        
        x[idx] = tmp_val - h 
        fxh2 = f(x) # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2*h)
        
        x[idx] = tmp_val # 还原值
        
    return grad


def numerical_gradient(f, X):
    if X.ndim == 1:
        return _numerical_gradient_no_batch(f, X)
    else:
        grad = np.zeros_like(X)
        
        for idx, x in enumerate(X):
            grad[idx] = _numerical_gradient_no_batch(f, x)
        
        return grad

py复制代码def gradient_descent(f, init_x, lr=0.01, step_num=100):
    x = init_x

    for i in range(step_num): # 前进步数
        grad = numerical_gradient(f, x) # 该点梯度
        x -= lr * grad # 向梯度方向前进

    return x

py复制代码import sys, os
sys.path.append(os.pardir)  # 为了导入父目录中的文件而进行的设定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient

class simpleNet:
    def __init__(self):
        self.W = np.random.randn(2,3) # 预定一个随机参数神经网络

    def predict(self, x): # 计算网络输出
        return np.dot(x, self.W)

    def loss(self, x, t): # 计算交叉熵损失值
        z = self.predict(x)
        y = softmax(z)
        loss = cross_entropy_error(y, t)

        return loss

x = np.array([0.6, 0.9]) // 输入
t = np.array([0, 0, 1]) // 标签集

net = simpleNet()

f = lambda w: net.loss(x, t) # 使用lambda简化函数写法
dW = numerical_gradient(f, net.W)

print(dW) # 打印神经网络的梯度

py复制代码# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
from common.functions import *
from common.gradient import numerical_gradient


class TwoLayerNet:

    # hidden_size 隐藏层（第1层）的神经元数
    # weight_init_std 初始权重
    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size) # 维度为input_size * hidden_size
        self.params['b1'] = np.zeros(hidden_size) # 偏置初始化为0
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) # hidden_size * output_size
        self.params['b2'] = np.zeros(output_size)

    # 根据定义计算输出
    def predict(self, x):
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
    
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1) # 隐藏层激活用sigmoid
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2) # 输出层激活用softmax
        
        return y
        
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        
        return cross_entropy_error(y, t)
    
    # 这里x可以是batch输入
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x:输入数据, t:监督数据
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t) # 损失
        
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        
        return grads # 损失的梯度
        
    # 计算梯度
    def gradient(self, x, t):
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        grads = {} # 初始化为Map
        
        batch_num = x.shape[0]
        
        # forward 前向输出
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        # backward
        dy = (y - t) / batch_num
        grads['W2'] = np.dot(z1.T, dy)
        grads['b2'] = np.sum(dy, axis=0)
        
        da1 = np.dot(dy, W2.T)
        dz1 = sigmoid_grad(a1) * da1
        grads['W1'] = np.dot(x.T, dz1)
        grads['b1'] = np.sum(dz1, axis=0)

        return grads

py复制代码# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10) # 

iters_num = 10000  # 适当设定循环的次数
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1 # 步长

train_loss_list = [] # 列表记录损失下降
train_acc_list = [] # 列表记录精度上升
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    # 取mini-batch
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 计算梯度
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch) # 每次学习都更新一遍梯度
    
    # 更新参数
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc : {:.4f}, test acc : {:.4f}".format(train_acc, test_acc))

# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

shell复制代码$ hdc shell aa force-stop com.byhk.app
$ hdc uninstall com.byhk.app in 669 ms
$ hdc shell mkdir data/local/tmp/e865b2e1cb8147408400c284260da55c
$ hdc file send /XXX/xxx/build/default/outputs/default/xxx-signed.hsp "data/local/tmp/e865b2e1cb8147408400c284260da55c" in 22 s 117 m
$ hdc file send /XXX/app/build/default/outputs/default/app-default-signed.hap "data/local/tmp/e865b2e1cb8147408400c284260da55c" in 1 min 50 s 580 ms
$ hdc shell bm install -p data/local/tmp/e865b2e1cb8147408400c284260da55c  in 11 s 907 ms
$ hdc shell rm -rf data/local/tmp/e865b2e1cb8147408400c284260da55c
$ hdc shell aa start -a AppAbility -b com.byhk.app -D in 89 ms

matlab复制代码java -jar hap-sign-tool.jar sign-app -keyAlias "key0" -signAlg "SHA256withECDSA" -mode "localSign" -appCertFile "test.cer" -profileFile "test.p7b" -inFile "hap-unsigned.hap" -keystoreFile "test.p12" -outFile "result\hap-signed.hap" -keyPwd "123456" -keystorePwd "123456" -signCode "1"

python复制代码def unzip_app(app_file, signed_dir, output_dir):
    print("开始解压APP")
    os.makedirs(output_dir, exist_ok=True)
    os.makedirs(signed_dir, exist_ok=True)
    with zipfile.ZipFile(app_file, 'r') as zip_ref:
        zip_ref.extractall(output_dir)
    print("解压成功")

python复制代码def signed_app(extracted_dir, signed_dir):
    print("开始签名APP")
    sign_files(extracted_dir, signed_dir, '.hap')
    sign_files(extracted_dir, signed_dir, '.hsp')
    print("签名完成")

def sign_files(source_dir, target_dir, extension):
    files = [f for f in os.listdir(source_dir) if f.endswith(extension)]
    for file in files:
        sign_file(source_dir, target_dir, file)

def sign_file(source_dir, target_dir, file):
    sign_command = f"java -jar {hap_sign_tool} sign-app -keyAlias {alias} -signAlg \"SHA256withECDSA\" -mode \"localSign\" -appCertFile \"{cer_path}\" -profileFile \"{profile_file_path}\" -inFile \"{os.path.join(source_dir, file)}\" -keystoreFile \"{k12_path}\" -outFile \"{target_dir}/{file.split('.')[0]}-signed.{file.split('.')[1]}\" -keyPwd \"{pwd}\" -keystorePwd \"{pwd}\""
    subprocess.run(sign_command, shell=True)

lua复制代码def zip_signed_files(signed_dir):
    os.makedirs(os.path.dirname(out_put_file_path), exist_ok=True)
    print("开始压缩已签名文件")
    with zipfile.ZipFile(out_put_file_path, 'w') as zip_ref:
        for root, _, files in os.walk(signed_dir):
            for file in files:
                zip_ref.write(os.path.join(root, file), os.path.relpath(os.path.join(root, file), signed_dir))
    print("压缩完成")

ini复制代码app_file = "xxx/jojo-read-default-signed.app" //app地址
hap_sign_tool = "xxx/Huawei/Sdk/HarmonyOS-NEXT-DP2/base/toolchains/lib/hap-sign-tool.jar" //签名工具地址
cer_path = "xxx/app.cer" //cer地址
profile_file_path="xxx/app.p7b" //prpfile地址
k12_path = "xxx/app.p12" //.p12地址
alias = "ohos" 
pwd = "123456" //密码

app_file_path = os.path.dirname(app_file)
file_name = os.path.basename(app_file)
package_name = "com.byhk.app" //包名
extracted_dir = app_file_path + "/zip"
signed_dir = app_file_path + "/signed"
out_put_file_dir = app_file_path + "/out/"
out_put_file_path = out_put_file_dir + file_name

python复制代码def unzip_app(app_file, output_dir):
    print("开始解压APP")
    os.makedirs(output_dir, exist_ok=True)
    with zipfile.ZipFile(app_file, 'r') as zip_ref:
        zip_ref.extractall(output_dir)
    print("解压成功")

python复制代码def stop_and_uninstall_app(package_name):
    print("停止并卸载应用")
    subprocess.run(f"hdc shell aa force-stop {package_name}", shell=True)
    subprocess.run(f"hdc uninstall {package_name}", shell=True)
    subprocess.run("hdc shell rm -rf data/local/tmp/6927085eaa4645068468e40d6c797292", shell=True)
    subprocess.run("hdc shell mkdir data/local/tmp/6927085eaa4645068468e40d6c797292", shell=True)

scss复制代码def send_files_to_device(extracted_dir, package_name):
    print("发送文件到设备")
    files = [f for f in os.listdir(extracted_dir) if f.endswith('.hap') or f.endswith('.hsp')]
    for file in files:
        subprocess.run(f"hdc file send {os.path.join(extracted_dir, file)} data/local/tmp/6927085eaa4645068468e40d6c797292", shell=True)

python复制代码def start_app(package_name):
    print("启动应用")
    subprocess.run(f"hdc shell bm install -p data/local/tmp/6927085eaa4645068468e40d6c797292", shell=True)
    subprocess.run(f"hdc shell rm -rf data/local/tmp/6927085eaa4645068468e40d6c797292", shell=True)
    subprocess.run(f"hdc shell aa start -a AppAbility -b {package_name}", shell=True)
    print("启动成功")

ini复制代码app_file = "xxx/app-signed.zip"
package_name = "com.byhk.app"

app_file_path = os.path.dirname(app_file)
extracted_dir = app_file_path + "/zip"
unzip_app_and_send_files(app_file, package_name, extracted_dir)

c复制代码{
    "windows": {
        "cmd": ["gcc", "-std=c11", "${file}", "-o", "${file_base_name}.exe"],
    },
    "cmd": ["gcc", "-std=c11", "${file}", "-o", "${file_base_name}"],
    "file_regex": "^(.*)\\(([0-9]+),([0-9]+)\\) (Error|Fatal): (.*)$",
    "working_dir": "${file_path}",
    "selector": "source.c",
    "encoding": "cp936",
    "variants": [
    {
        "name": "Run",
        "shell": true,
        "windows": {
            "shell_cmd" : "start cmd /c \"\"${file_base_name}.exe\" & echo. & pause\""
        }
    },
    {
        "name": "Build and Run",
        "shell": true,
        "windows": {
            "shell_cmd": "gcc -std=c11 \"${file}\" -o \"${file_base_name}.exe\" && start cmd /c \"\"${file_base_name}.exe\" & echo. & pause\""
        },
    }
    ]
}

c复制代码{  
    "cmd": ["g++", "${file}", "-o", "${file_path}/${file_base_name}", "-Wall" ,"&&","start","cb_console_runner.exe","${file_path}/${file_base_name}"],  
    "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",  
    "working_dir": "${file_path}",  
    "selector": "source.c, source.c++",  
    "shell": true,  
    "encoding": "cp936",  
    "variants":  
    [  
        {  
            "name": "Run",  
            "cmd": ["start","cb_console_runner.exe","${file_path}/${file_base_name}"]  
        }  
    ]  
}

c复制代码#include<stdio.h>

int main() 
{
    printf("hello world!\n");
    printf("[C]Author: Huazie");
    return 0;
}

cpp复制代码#include <iostream>
using namespace std;

int main()
{
    cout << "Hello World" << endl;
    cout << "[C++]Author: Huazie";
    return 0;
}

python复制代码
from functools import partial

from util.download_util import download_pic
from util.file_util import is_dir_existed, search_all_file, read_file_text_content, write_text_to_file
from util.logger_util import default_logger
import os
import re
import time

logger = default_logger()
origin_md_dir = os.path.join("/Users/hzz/Documents/黄壮壮_写作/已发表的博客_掘金存储图片/")  # 原始md文件目录
local_md_dir = os.path.join("/Users/hzz/Documents/黄壮壮_写作/已发表博客_本地存储图片/")  # 本地md文件目录
local_doc_dir = os.path.join("/Users/hzz/Documents/黄壮壮_写作/已发表博客_doc/")  # 本地doc文件目录
server_md_dir = os.path.join(os.getcwd(), "server_md")  # 转换成自己的图片服务器md文件目录
pic_match_pattern = re.compile(r'(]: |()+(http.*?.(png|PNG|jpg|JPG|gif|GIF|svg|SVG|webp|awebp|image))??()?)',
                               re.M)  # 匹配图片的正则
order_set = {i for i in range(1, 500000)}  # 避免图片名重复后缀
generate_server_md = False  # 是否在本地化后生成为自己图床的md文件
generate_doc = True  # 是否在本地化后生成doc文件


# 检索md文件
def retrieve_md(file_dir):
    logger.info("检索路径 → %s" % file_dir)
    md_file_list = search_all_file(file_dir, target_suffix_tuple=('md', "MD"))
    file_name = input('请输入指定的文件: ')

    if len(file_name)!=0:
        filtered_files = []
        for filename in md_file_list:
            if  file_name in filename:
                # 这里可以添加更多逻辑处理
                filtered_files.append(filename)
        md_file_list=filtered_files

    if len(md_file_list) == 0:
        logger.info("未检测到Markdown文件，请检查后重试!")
        exit(-1)
    else:
        logger.info("检测到Markdown文件 → %d个" % len(md_file_list))
        logger.info("=" * 64)
        for pos, md_file in enumerate(md_file_list):
            logger.info("%d、%s" % (pos + 1, md_file))
        logger.info("=" * 64)
        logger.info("执行批处理操作")
        process_md(md_file_list)


# 处理文件列表
def process_md(file_list):
    for file in file_list:
        to_local_md(file)


# 转换成本地MD
def to_local_md(md_file):
    logger.info("处理文件：【%s】" % md_file)
    # 获取md文件名
    md_file_name = os.path.basename(md_file)
    # 生成md文件的目录、图片目录，doc目录
    new_md_dir = os.path.join(local_md_dir, md_file_name[:-3])
    new_picture_dir = os.path.join(new_md_dir, "images")
    is_dir_existed(new_md_dir)
    is_dir_existed(new_picture_dir)
    # 生成md文件路径
    new_md_file_path = os.path.join(new_md_dir, md_file_name)
    new_doc_file_path = os.path.join(local_doc_dir, md_file_name[:-3].replace("知乎盐选 ", "") + ".docx")
    # 读取md文件内容
    old_content = read_file_text_content(md_file)
    # 替换原内容
    new_content = pic_match_pattern.sub(partial(pic_to_local, pic_save_dir=new_picture_dir), old_content)
    # 生成新的md文件
    write_text_to_file(new_content, new_md_file_path)
    logger.info("新md文件已生成 → {}".format(new_md_file_path))
    # 生成新的doc文件
    if generate_doc:
        os.chdir(new_md_dir)
        logger.info("新doc文件已生成 → {}".format(new_doc_file_path))
    logger.info("=" * 64)
    if generate_server_md:
        to_server_md(new_md_file_path)


# 远程图片转换为本地图片
def pic_to_local(match_result, pic_save_dir):
    logger.info("替换前的图片路径：{}".format(match_result[2]))
    # 生成新的图片名
    img_file_name = "{}_{}.{}".format(int(round(time.time())), order_set.pop(), "png")# match_result[3]
    # 拼接图片相对路径(Markdown用到的)
    relative_path = 'images/{}'.format(img_file_name)
    # 拼接图片绝对路径，下载到本地
    absolute_path = os.path.join(pic_save_dir, img_file_name)
    logger.info("替换后的图片路径：{}".format(relative_path))
    # 下载图片
    download_pic(absolute_path, match_result[2])
    # 还需要拼接前后括号()
    return "{}{}{}".format(match_result[1], relative_path, match_result[4])

# 转换成自己的图片服务器md文件
def to_server_md(md_file):
    pass


if __name__ == '__main__':
    is_dir_existed(origin_md_dir)
    is_dir_existed(local_md_dir, is_recreate=True)
    is_dir_existed(local_doc_dir, is_recreate=True)
    is_dir_existed(server_md_dir, is_recreate=True)
    # loop = asyncio.get_event_loop()
    retrieve_md(origin_md_dir)

python复制代码

import os
import time

import requests


from util.logger_util import default_logger

logger = default_logger()

default_headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept-Encoding': 'gzip, deflate, br',
    'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
    'Sec-Ch-Ua-Mobile': '?0',
    'Sec-Ch-Ua-Platform': '"macOS"',
    'Sec-Fetch-Dest': 'document',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-User': '?0',
    'Upgrade-Insecure-Requests': '1'
}


def download_pic(pic_path, url, headers=None):
    try:
        if headers is None:
            headers = default_headers
        if url.startswith("http") | url.startswith("https"):
            if os.path.exists(pic_path):
                logger.info("图片已存在，跳过下载：%s" % pic_path)
            else:
                res1 = requests.get(url, headers=headers,verify=False)

                # res1.encoding = "utf8"
                with open(pic_path, "wb+") as f:
                    f.write(res1.content)
        else:
            logger.info("图片链接格式不正确：%s - %s" % (pic_path, url))
        time.sleep(1)
    except Exception as e:
        logger.info("下载异常：{}\n{}".format(url, e))

python复制代码
import logging


# 默认日志工具
def default_logger():
    custom_logger = logging.getLogger("CpPythonBox")
    if not custom_logger.hasHandlers():
        handler = logging.StreamHandler()
        handler.setFormatter(logging.Formatter(
            fmt='%(asctime)s %(process)d:%(processName)s- %(levelname)s === %(message)s',
            datefmt="%Y-%m-%d %H:%M:%S %p"))
        custom_logger.addHandler(handler)
        custom_logger.setLevel(logging.INFO)
    return custom_logger

python复制代码
def search_all_file(file_dir=os.getcwd(), target_suffix_tuple=()):
    """ 递归遍历文夹与子文件夹中的特定后缀文件

    Args:
        file_dir (str): 文件目录
        target_suffix_tuple (Tuple(Str)): 文件目录

    Returns:
        list : 文件路径列表
    """
    file_list = []
    # 切换到目录下
    os.chdir(file_dir)
    file_name_list = os.listdir(os.curdir)
    for file_name in file_name_list:
        # 获取文件绝对路径
        file_path = "{}{}{}".format(os.getcwd(), os.path.sep, file_name)
        # 判断是否为目录，是往下递归
        if os.path.isdir(file_path):
            # print("[-]", file_path)
            file_list.extend(search_all_file(file_path, target_suffix_tuple))
            os.chdir(os.pardir)
        elif target_suffix_tuple is not None and file_name.endswith(target_suffix_tuple):
            # print("[!]", file_path)
            file_list.append(file_path)
        else:
            pass
            # print("[+]", file_path)
    return file_list



def write_text_to_file(content, file_path, mode="w+"):
    """ 将文字写入到文件中

    Args:
        content (str): 文字内容
        file_path (str): 写入文件路径
        mode (str): 文件写入模式，w写入、a追加、+可读写

    Returns:
        None
    """
    with lock:
        try:
            with open(file_path, mode, encoding='utf-8') as f:
                f.write(content + "\n", )
        except OSError as reason:
            print(str(reason))



def read_file_text_content(file_path):
    """ 以文本形式读取文件内容

    Args:
        file_path (str): 文件路径

    Returns:
        str: 文件内容
    """
    if not os.path.exists(file_path):
        return None
    else:
        with open(file_path, 'r+', encoding='utf-8') as f:
            return f.read()


def is_dir_existed(file_path, mkdir=True, is_recreate=False):
    """ 判断目录是否存在，不存在则创建

    Args:
        file_path (str): 文件路径
        mkdir (bool): 不存在是否新建
        is_recreate (bool): 存在是否删掉重建

    Returns:
        默认返回None，如果mkdir为False返回文件是否存在
    """
    if mkdir:
        if not os.path.exists(file_path):
            os.makedirs(file_path)
        else:
            if is_recreate:
                delete_file(file_path)
                if not os.path.exists(file_path):
                    os.makedirs(file_path)
    else:
        return os.path.exists(file_path)