# 用round实现，返回的是float
round(f, n)   # f是浮点数，n是需要保留的位数

# 用占位符实现，返回的是str
f_num = float(input())
print(f'{f_num:.2f}')   # .2f中的2表示小数位数，可以更改；f代表要操作的float
print('%.2f' % f_num)
print('{:.2f}'.format(f_num))

# python取整
int(-0.8)                                                # 取整数部分
round(-0.4)                                              # 四舍五入
math.floor(-0.8)                                         # 向下取整
math.ceil(-0.8)                                          # 向上取整

int(str, 2)   # 2转10，输入字符串，返回数字
int(str, 8)   # 8转10，输入字符串，返回数字
int(str, 16)  # 16转10，输入字符串，返回数字

bin(num)      # 10转2，输入数字，返回字符串
oct(num)      # 10转8，输入数字，返回字符串
hex(num)      # 10转16，输入数字，返回字符串

list1 = [1, 3, 5, 7, 100]
# 增
print(list1.append(200))         # 在列表的最后追加元素；[1, 3, 5, 7, 100, 200]   
print(list1.insert(1, 400))      # 在索引1的位置插入元素；[1, 400, 3, 5, 7, 100, 200]   
print(list1.extend([8,9,11]))    # 函数用于在列表末尾一次性追加另一个序列中的多个值；[1, 400, 3, 5, 7, 100, 200, 8,9,11]

# 删 
del list1[2]                     # 删除指定索引的元素
print(list1) # [1, 400, 5, 7, 100, 200]   
list1.remove(5)                  # 移除列表中某个值的第一个匹配项
print(list1) # [1, 400, 7, 100, 200]
print(list1.pop()) # 200         # 移除列表中的一个元素（默认最后一个元素）, 并且返回该元素的值, 可以指定索引

# 查
print(list1[3]) # 100            # 取索引为3的元素
print(list1[-1]) # 100           # 取最后一个元素
print(list1[1:3]) # [400, 7]     # 取一个区间（前开后闭：能取到1不能取到3）

# 改
list1[1] = 'value'               # 赋值
print(list1) # [1, 'value', 7, 100, 200]

# 其他方法
list(seq)                        # 将其他seq转换为列表
len(list1)                       # 列表长度
min(list1)                       # 列表最小值
max(list1)                       # 列表最大值
list1.count(obj)                 # 统计某个元素在列表中出现的次数
list1.index(obj)                 # 从列表中找出某个值第一个匹配项的索引位置
list1.reverse()                  # 反转列表 
list1.clear()                    # 清空列表元素
list1.sort(reverse=True)         # 排序——直接在原列表上进行排序
list1 += [1000, 2000]            # 合并两个列表

# 排序——不会修改原列表，返回新列表
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)               # 根据首字母在字母表中的位置升序
print(list2) # ['apple', 'blueberry', 'internationalization', 'orange', 'zoo']
list3 = sorted(list1, reverse=True) # 根据首字母在字母表中的位置倒序
print(list3) # ['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
list4 = sorted(list1, key=len)      # 根据元素长度升序
print(list4) # ['zoo', 'apple', 'orange', 'blueberry', 'internationalization']

# 列表反转
# 方法0：list1.reverse()
# 方法1：list(reversed(a))，reversed(a)返回的是迭代器，所以前面加个list转换为list
# 方法2：sorted(a,reverse=True)
# 方法3：a[: :-1]，其中[::-1]代表从后向前取值，每次步进值为1
   # b = a[i:j:s]；i是起点，j是终点，s是步长
   # 当s<0，且i缺省时，则a默认为-1. 
   # 当s<0，且j缺省时，默认为-len(a)-1
   # 所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。

# 创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1)
print('Length =', len(set1))
# 创建集合的构造器语法(面向对象部分会进行详细讲解)
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)
# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)

set1.add(4)
set1.add(5)
set2.update([11, 12])
set2.discard(5)
if 4 in set2:
    set2.remove(4)
print(set1, set2)
print(set3.pop())
print(set3)

# 集合的交集、并集、差集、对称差运算
print(set1 & set2)
# print(set1.intersection(set2))
print(set1 | set2)
# print(set1.union(set2))
print(set1 - set2)
# print(set1.difference(set2))
print(set1 ^ set2)
# print(set1.symmetric_difference(set2))
# 判断子集和超集
print(set2 <= set1)
# print(set2.issubset(set1))
print(set3 <= set1)
# print(set3.issubset(set1))
print(set1 >= set2)
# print(set1.issuperset(set2))
print(set1 >= set3)
# print(set1.issuperset(set3))


.argsort()   # 返回数组值从小到大的索引值
[::-1]   # 倒序取值

# 创建字典的字面量语法
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
print(scores)
# 创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)
# 通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))
# 创建字典的推导式语法
items3 = {num: num ** 2 for num in range(1, 10)}

# 更新字典中的元素
scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)

print(scores.get('武则天'))   # get获取对应key的value，原字典中元素不变
print (scores.get('武则天', 0.0))   # 如果没有对应的key，则输出这设置好的默认值  0.0

# 删除字典中的元素
print(scores.popitem())      # 取出最后一个元素，原字典中元素变少，取出来的数据以元组的形式存在
print(scores.pop('骆昊', 100))   # 取出指定key值对应的value，原字典中元素变少
# 清空字典
scores.clear()
print(scores)

# 遍历字典
for key in dict1: # 只遍历键
for key in dict1.keys(): # 只遍历键
for val in dict1.values(): # 只遍历值
for kv in dict1.items(): # 遍历键和值，返回元组

# 字典排序
my_dict = {'banana': 3, 'apple': 2, 'pear': 1, 'orange': 4}

sorted_dict_by_key = {k: my_dict[k] for k in sorted(my_dict)}   # 按键排序，sorted 加上 reverse=True 参数为倒序
sorted_dict_by_value = {k: v for k, v in sorted(my_dict.items(), key=lambda item: item[1])}   # 按值排序，sorted 加上 reverse=True 参数为倒序

import json

# 将 Python 对象序列化为 JSON 字符串
json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
# obj (必需): 要序列化的 Python 对象。可以是字典、列表、元组、字符串、数字（整数和浮点数）、布尔值（True 和 False）以及 None。
# skipkeys (默认为 False): 如果设置为 True，那么字典中不可序列化的键将会被跳过，而不是抛出 TypeError 异常。默认情况下，如果键不是基本类型（str、int、float、bool、None），将会抛出异常。
# ensure_ascii (默认为 True): 当设置为 True 时，输出保证将所有输入的非 ASCII 字符转义。如果设置为 False，这些字符将会原样输出。
# check_circular (默认为 True): 检查循环引用，确保序列化的对象中没有循环引用（即对象引用自身，直接或间接）。如果设置为 False，则跳过这个检查。
# allow_nan (默认为 True): 规定是否允许将 NaN、Infinity 和 -Infinity 编码为 JSON。根据 JSON 规范，这是不允许的，但是默认情况下 Python 允许这样做。
# cls (默认为 None): 为了序列化一些特定类型的对象，你可以指定一个自定义的 JSONEncoder 子类。
# indent (默认为 None): 一般设置为4，表示每个级别缩进4个空格。用于美化输出（pretty-printing）。如果指定一个非负整数，则 JSON 数组元素和对象成员会被缩进到这个级别。传入 0、负数或 "" 会只插入新行。
# separators (默认为 (', ', ': ')): 一个 (item_separator, key_separator) 元组，用于指定分隔符。默认情况下，字典内的项之间用逗号和空格分隔，键和值之间用冒号和空格分隔。要获得最紧凑的 JSON 表示形式，可以使用 (',', ':')。
# default (默认为 None): 如果设置了这个参数，那么对于那些 json 模块不知道如何将其转化为 JSON 的对象，json 将会调用这个函数，函数返回的值将被序列化为 JSON。这个函数应该返回一个可序列化的版本的对象或者抛出一个 TypeError。
# sort_keys (默认为 False): 如果设置为 True，则字典的输出将按键排序。
# **kw: 用于兼容性，允许你传递一些在未来版本中可能会实现的新的关键字参数。


# 将 JSON 字符串反序列化为 Python 对象。
json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
# s (必需): 要反序列化的 JSON 字符串。
# cls (默认为 None): 如果指定了这个参数，则它应该是一个 JSONDecoder 的子类，用于定制解码过程。如果为 None，则使用默认的 JSONDecoder。
# object_hook (默认为 None): 如果指定了这个参数，它应该是一个函数。每当解码器遇到一个 JSON 对象（即字典）时，将使用这个函数对其进行后处理。函数应该接受一个字典作为输入，并返回一个相应的 Python 对象。
# parse_float (默认为 None): 如果指定了这个参数，它应该是一个函数。每当解码器遇到一个 JSON 浮点数时，将使用这个函数对其进行处理。函数应该接受一个字符串作为输入，并返回一个相应的 Python 浮点数或其他你希望返回的值。
# parse_int (默认为 None): 如果指定了这个参数，它应该是一个函数。每当解码器遇到一个 JSON 整数时，将使用这个函数对其进行处理。函数应该接受一个字符串作为输入，并返回一个相应的 Python 整数或其他你希望返回的值。
# parse_constant (默认为 None): 如果指定了这个参数，它应该是一个函数。每当解码器遇到以下特殊 JSON 值之一：-Infinity、Infinity、NaN时，将使用这个函数对其进行处理。函数应该接受一个字符串作为输入，并返回一个相应的 Python 常量或其他你希望返回的值。
# object_pairs_hook (默认为 None): 如果指定了这个参数，它应该是一个函数。每当解码器遇到一个 JSON 对象时，将使用这个函数对其进行后处理，但与 object_hook 不同的是，这个函数接受的是一个由键值对组成的列表而不是字典。这允许你保留 JSON 对象中的项顺序。函数应该返回一个新的 Python 对象。
# **kw: 用于兼容性，允许你传递一些在未来版本中可能会实现的新的关键字参数。


# 将 Python 对象序列化为 JSON 格式，并写入文件
json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
# obj (必需): 要序列化的 Python 对象。可以是字典、列表、元组、字符串、数字（整数和浮点数）、布尔值（True 和 False）以及 None。
# fp (必需): 一个 .write() 支持的文件类对象。json.dump() 方法会将序列化的 JSON 字符串写入到这个文件中。
# 其他参数与 json.dumps 相同


# 从文件读取 JSON 数据，并反序列化为 Python 对象
json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
# fp (必需): 一个 .read() 支持的文件类对象。json.load() 方法会从这个文件中读取 JSON 格式的字符串。

import json

# Python 对象
data = {
    'name': 'Alice',
    'age': 25,
    'is_student': False,
    'courses': ['Math', 'Science'],
    'address': {
        'city': 'New York',
        'zipcode': '10001'
    }
}

# 序列化为 JSON 字符串
json_string = json.dumps(data, indent=4)
print(json_string)

# 反序列化为 Python 对象
parsed_data = json.loads(json_string)
print(parsed_data)

import json

data = {
    'name': 'Alice',
    'age': 25,
    'is_student': False
}

# 将数据写入 JSON 文件
with open('data.json', 'w') as file:
    json.dump(data, file, indent=4)

# 从 JSON 文件读取数据
with open('data.json', 'r') as file:
    loaded_data = json.load(file)

print(loaded_data)

import itertools

# 产生ABCD的全排列
itertools.permutations('ABCD')
# 产生ABCDE的五选三组合
itertools.combinations('ABCDE', 3)
# 产生ABCD和123的笛卡尔积
itertools.product('ABCD', '123')
# 产生ABC的无限循环序列
itertools.cycle(('A', 'B', 'C'))

sorted(iterable, key=None, reverse=False)

# 指定key进行排序
>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)   # 将原列表中的元素都乘以-1，然后进行升序
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

all_lines = ' '.join(list(train_df['text']))
word_count = Counter(all_lines.split(' '))   # 返回的数据是Counter类型的字典
print(word_count)
"""
Counter({'3750': 3702, '648': 2423, '900': 1602, '3370': 980, '4464': 816, '6122': 790, '4939': 724, '7399': 686, '3659': 614})
"""
print(word_count.items())
"""
dict_items([('2967', 63), ('6758', 23), ('339', 1), ('2021', 42), ('1854', 78), ('3731', 35), ('4109', 142), ('3792', 79)])
"""

word_count = sorted(word_count.items(),key=lambda x: x[1],reverse=True)  
# word_count.items()将字典变成元组，key是指定用元组里的第二个值作为比较来机型排序，reverse=True是降序，默认是False升序
print(word_count)
"""
[('3750', 3702), ('648', 2423), ('900', 1602), ('3370', 980), ('4464', 816), ('6122', 790), ('4939', 724), ('7399', 686)]
"""

map(function, iterable, ...)   # function函数（可以是内置，自写，匿名等函数）；iterable可迭代对象

import random

random.seed(s)                   # 设置随机数种子，s 可以是任意数字，对以下所有方法适用。如果不指定s，则使用当前时间作为种子值。

random.random()                  # 返回一个 [0,1) 之间的浮点数
random.uniform(a,b)              # 返回一个 [a,b) 之间的浮点数，a,b 顺序可以颠倒
random.randint(a,b)              # 返回一个 [a,b] 之间的整数
random.randrange(a,b,n)          # 从 range(a,b,n) 中返回一个数
random.choice(sequence)          # 从指定序列中返回一个值，sequence 可以是列表、元组、字符串、字典等
random.choices(population,weights=None,k=2)   # 从指定序列中按照权重返回 k 个值组成列表；会重复选择元素
random.shuffle(x)                # 将列表 x 随机打乱，没有返回值，其他类型会报错
random.sample(sequence, k)       # 从指定序列中随机获取指定长度k的片段，不重复选择元素

from tqdm import tqdm
from tqdm import trange


#####  1、直接使用  #####
dic = ['a', 'b', 'c', 'd', 'e']
for i in tqdm(dic):
    time.sleep(0.2)

for i in trange(10000):   # trange() = tdqm(range())
    pass


#####  2、创建对象使用  #####   可以实现精细控制
pbar = tqdm(range(10000))
for i in pbar:
    pbar.set_description(str(i))   # 动态设置进度描述
    pass
pbar.close()   # 在用完之后要关闭对象

# 使用 with 关键字自动关闭对象
with tqdm(range(10000)) as pbar:
    for i in pbar: 
        pbar.set_description(str(i))   # 动态设置进度描述
        pass


#####  3、人工控制进度更新  #####  
# Manually update the progress bar, useful for streams such as reading files
with tqdm(total=10000) as pbar:   # 设置进度条格子 10000 个
    for i in range(200):   # 循环 200 次
        pbar.update(50)    # 每次更新 +50 个格子

## 在需要创建对象使用时，需要先创建对象，创建对象时有些常用参数可以设置
t = tqdm(iterable=None,desc=None,total=None,...)
# iterable: 最常用的参数，表示使用这个迭代对象来初始化tqdm对象，如果手动更新进度条的话该参数可以为None
# desc: 进度条的描述信息
# total: 进度条总格子数量

## 常用对象方法
t.update(n=1)   # 更新进度条，n 自行修改
t.close()   # 关闭对象
t.set_description(desc=None, refresh=True)   # 设置进度条描述

from datetime import datetime

dt = datetime(2015, 4, 19, 12, 20)
dt.timestamp()   # 把datetime转换为timestamp时间戳  1429417200.0
dt.date()   # datetime.date(2015, 4, 19)
dt.time()   # datetime.time(12, 20)

# 将字符串转换成 timestamp 时间格式
datetime1 = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
datetime2 = datetime.strptime('2015-6-1', '%Y-%m-%d')


datetime_now = datetime.now()   # 获取单签时间，datetime类型   --- datetime.datetime(2023, 6, 2, 10, 15, 27, 432617)

import os

os.path.exists(docx_path)                                         # 判断路径是否存在（可以是文件或文件夹），返回 True 或 False
os.system(f'cp "{resource_docx_path}" "{model_path}"')            # 使用系统命令拷贝文件；如果文件路径中有空格，需要再套一层双引号（必须是双引号）
os.rename(f'{model_path+resource_docx_name}',f'{docx_path}')      # 修改文件名



import os

os.getcwd()                                                       # 获取当前工作目录，当前脚本的文件夹路径
abs_path = os.path.abspath("file.txt")                            # 获取文件的绝对路径
dir_path = os.path.dirname(abs_path)                              # 获取文件所在目录
os.path.join(dir_path, "new_file.txt")                            # 路径拼接（类似字符串拼接）可以保证跨平台兼容性
os.path.splitext("file.txt")                                      # 分割文件名和扩展名：返回('file', '.txt')
os.path.split("/path/to/file.txt")                                # 分割路径和文件名：返回('/path/to', 'file.txt')
os.path.exists(new_path)                                          # 判断路径是否存在：返回False、True

# 获取属性
size = os.path.getsize("file.txt")                                # 获取文件大小
mtime = os.path.getmtime("file.txt")                              # 获取文件修改时间
is_file = os.path.isfile("path")                                  # 判断是否为文件
is_dir = os.path.isdir("path")                                    # 判断是否为目录

# 文件/文件夹操作
os.mkdir("new_dir")                                               # 创建单层目录
os.makedirs("path/to/new_dir")                                    # 创建多层目录
os.remove("file.txt")                                             # 删除文件
os.rmdir("empty_dir")                                             # 删除空目录
os.removedirs("path/to/empty_dir")                                # 删除多层空目录
os.rename("old.txt", "new.txt")                                   # 重命名

files = os.listdir("dir_path")                                    # 列出目录内容
for root, dirs, files in os.walk("dir_path"):                     # 递归遍历目录
    print(f"当前目录: {root}")
    print(f"当前目录中的子目录: {dirs}")
    print(f"当前目录中的文件: {files}")
    
path = os.environ.get("PATH")                                     # 获取环境变量
os.environ["MY_VAR"] = "value"                                    # 设置环境变量


process.terminate()                                               # 请求进程退出；multiprocessing 模块提供的高层接口
     # 在 POSIX 系统中，它会向子进程发送 SIGTERM；在 Windows 上，则调用相应的终止方法（例如 TerminateProcess），实现跨平台兼容。
     # 在调用 join() 前调用 terminate()，可以确保资源得到回收。
os.kill(process.pid, signal.SIGTERM)                              # 请求进程退出；发送 SIGTERM 信号，只支持 Unix 系统
os.kill(process.pid, signal.SIGKILL)                              # 请求进程退出；强制杀死进程，只支持 Unix 系统

!pip install pyspellchecker
from spellchecker import SpellChecker

# 创建SpellChecker对象
spell = SpellChecker()

# 单词拼写纠正
misspelled = spell.correction("aple")
print(misspelled)  # 输出：apple

# 获取候选词列表
candidates = spell.candidates("mispelled")
print(candidates)  # 输出：{'misspelled', 'mispelled'}

# 获取已知单词集合
known_words = spell.known(["apple", "banana", "orange"])
print(known_words)  # 输出：{'banana', 'orange', 'apple'}

# 获取未知单词集合
unknown_words = spell.unknown(["apple", "aple", "banana"])
print(unknown_words)  # 输出：{'aple'}

import language_tool_python

# 创建LanguageTool对象
tool = language_tool_python.LanguageTool('en-US')

text = "I am a engneer and I likes to coding."

# 文本语法和拼写检查
corrected_sentence = tool.correct(text)   # 返回纠正后的句子
matches = tool.check(text)                # 返回 n 个 match对象, 有多少错误就生成多少个对象
"""
[Match({'ruleId': 'EN_A_VS_AN', 'message': 'Use “an” instead of ‘a’ if the following word starts with a vowel sound, e.g. ‘an article’, ‘an hour’.', 'replacements': ['an'], 'offsetInContext': 5, 'context': 'I am a engneer and I likes to coding.', 'offset': 5, 'errorLength': 1, 'category': 'MISC', 'ruleIssueType': 'misspelling', 'sentence': 'I am a engneer and I likes to coding.'}),
 Match({'ruleId': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['engineer'], 'offsetInContext': 7, 'context': 'I am a engneer and I likes to coding.', 'offset': 7, 'errorLength': 7, 'category': 'TYPOS', 'ruleIssueType': 'misspelling', 'sentence': 'I am a engneer and I likes to coding.'}),
 Match({'ruleId': 'NON3PRS_VERB', 'message': 'The pronoun ‘I’ must be used with a non-third-person form of a verb.', 'replacements': ['like'], 'offsetInContext': 21, 'context': 'I am a engneer and I likes to coding.', 'offset': 21, 'errorLength': 5, 'category': 'GRAMMAR', 'ruleIssueType': 'grammar', 'sentence': 'I am a engneer and I likes to coding.'})]
"""
"""
ruleId：匹配规则ID。在这个示例中，它是MORFOLOGIK_RULE_EN_US，表示这是一个英语（美国）的拼写错误规则。
message：错误描述。在这个示例中，它是Possible spelling mistake found.，表示发现了可能的拼写错误。
replacements：匹配结果的建议修正列表。在这个示例中，它是['engineer']，表示建议将错误的单词“engneer”替换为“engineer”。
offsetInContext：匹配结果在上下文中的偏移量。
context：匹配结果所在的上下文文本。在这个示例中，上下文文本是I am a engneer and I likes to coding.。
offset：匹配结果在整个文本中的偏移量。
errorLength：匹配结果中的错误文本的长度。
category：匹配结果的错误类别。在这个示例中，它是TYPOS，表示拼写错误类别。
sentence：匹配结果所在的句子。在这个示例中，它是I am a engneer and I likes to coding.。
ruleIssueType：匹配结果的错误类型。在这个示例中，它是misspelling，表示拼写错误类型。
		misspelling：拼写错误。
    grammar：语法错误。
    typographical：印刷错误或打字错误。
    style：风格错误，如不规范的书写风格或不推荐的表达方式。
    casing：大小写错误，如不正确的首字母大小写或全大写/全小写的单词。
    punctuation：标点符号错误。
    capitalization：大写错误。
    redundancy：冗余错误，如多余的词语或表达。
    clumsiness：笨拙的表达或用词不当。
    inconsistency：不一致性错误，如在文本中使用了不一致的拼写、格式或用词。
"""

!pip install nltk
import nltk
tokens = nltk.word_tokenize(x)  # 分词
tagged = nltk.pos_tag(tokens)  # 词性标注
ne_chunked = nltk.ne_chunk(tagged)  # 命名实体识别

entity_counts = nltk.FreqDist(ne[0][1] for ne in ne_chunked if isinstance(ne, nltk.Tree))  # 统计命名实体数量
sum(entity_counts.values())

import argparse

def parse_args():
    """创建解析器和参数"""
    # 创建解析器对象
    parser = argparse.ArgumentParser(
        description='模型训练脚本',  # 脚本说明
        formatter_class=argparse.ArgumentDefaultsHelpFormatter  # 在帮助文档中显示默认值
    )
    
    # 添加参数
    # 必选参数
    parser.add_argument('--data_path', type=str, required=True,
                       help='训练数据路径')
    
    # 可选参数（带默认值）
    parser.add_argument('--batch_size', type=int, default=32,
                       help='训练的批次大小')
    parser.add_argument('--epochs', type=int, default=10,
                       help='训练轮数')
    
    # 布尔标志
    parser.add_argument('--use_gpu', action='store_true',
                       help='是否使用GPU训练')
    
    # 选择参数
    parser.add_argument('--optimizer', choices=['adam', 'sgd'], default='adam',
                       help='优化器选择')
    
    return parser.parse_args()

if __name__ == '__main__':
    args = parse_args()
    print(f"批次大小: {args.batch_size}")
    print(f"使用GPU: {args.use_gpu}")

# 参数组
parser = argparse.ArgumentParser()
group = parser.add_argument_group('model', '模型相关参数')
group.add_argument('--model_type', type=str)
group.add_argument('--model_path', type=str)

# 互斥参数：互斥参数在传参时智能传其中一个，两个都传会报错
group = parser.add_mutually_exclusive_group()
group.add_argument('--train', action='store_true')
group.add_argument('--eval', action='store_true')

# 列表参数：nargs='+'表示至少一个参数，'*'表示零个或多个参数
parser.add_argument('--list', nargs='+', type=int,
                    help='接受多个整数参数')

# 可选值参数：只能从预定义的选项中选择
parser.add_argument('--mode', choices=['train', 'test', 'eval'])

import argparse
import json
import os

def load_config(config_path):
    """从JSON配置文件加载参数"""
    with open(config_path) as f:
        return json.load(f)  # 读取JSON文件并返回字典

def get_args():
    """解析命令行参数并加载配置文件中的默认参数"""
    parser = argparse.ArgumentParser(description='模型训练脚本')
    
    # 添加配置文件参数
    parser.add_argument('--config', type=str,
                        help='配置文件路径')  # 允许用户指定配置文件路径
    
    # 先解析配置文件参数
    args, remaining_argv = parser.parse_known_args()  # 解析已知参数，剩余参数留待后续解析
    
    # 加载配置文件
    defaults = {}
    if args.config:  # 如果用户提供了配置文件路径
        defaults.update(load_config(args.config))  # 从配置文件加载参数并更新默认值
    
    # 设置默认值并解析其余参数
    parser.set_defaults(**defaults)  # 将加载的默认值设置到解析器中
    args = parser.parse_args(remaining_argv)  # 解析剩余的命令行参数
    return args  # 返回最终的参数对象

if __name__ == '__main__':
    args = get_args()  # 获取参数
    print("参数配置:")
    for arg in vars(args):  # 遍历参数
        print(f"  {arg}: {getattr(args, arg)}")  # 打印每个参数及其值

pip install sqlparse


sqlparse.split(sql)   # 将一个包含多个 SQL 语句的字符串拆分成多个 SQL 语句。
sqlparse.format(sql, keyword_case='upper', identifier_case='lower', reindent=True, indent_width=4)     # 格式化 SQL 语句
	# sql：要格式化的 SQL 查询字符串。
	# keyword_case：SQL 关键字的大小写，默认是 'lower'，可选择 'upper'。
	# identifier_case：表和列的名称的大小写，默认是 'lower'，可以设置为 'upper'。
	# reindent：是否重新缩进，默认值为 False。
	# indent_width：缩进的宽度，默认值为 4 个空格。
sqlparse.parse(sql)        # 解析 SQL 语句，返回一个 Statement 对象，这个对象中有一个列表，列表中是 SQL 语句各模块的 token，每个关键字是一个模块

import sqlparse

sql = "SELECT id, name FROM users WHERE age > 30"
sql = """
INSERT INTO schema1.target_table (col1, col2)
SELECT t1.field1, t2.field2 
FROM schema2.table1 t1, schema3.table2 t2 
WHERE t1.id = t2.id
"""
sql = 'insert into dezhou.dim_agentinfo select RQ,QX,QXM,ORGID,ORGNAME,DESCRIPTION,ORGTYPE,AGENTSTYLE,DWLX,AGENTTYPE,QDLX,DEPOSIT,STARLEVEL,CONTACTMAN,CONTACTPHONE,ADRESS,LONGITUDE,LATITUDE,ACCOUNTOPENER,BANKID,BANKACCOUNT,BANKCODE,NETWORKTYPE,JRRFS,PRACTICETIME,DEADLINE,SYMJ,QDJL,QDJLDH,QDJLNAME,JZMJ,YYMJ,FWXZ,ZLKSSJ,ZLJSSJ,MDBH,AGENTLEVEL,XZQYSX,SQSX,SQNAME,PERSONS,CJJS,ZXFY,ZXSJ,XYFHL,XYZDL,DB,DBSJ,CREATEdate,HTDQSJ,AGENT_FLAG,UNIT_ID,UNIT_NAME from liuchz.lczbb_agentinfo;'


format_sql = sqlparse.format(sql, keyword_case='upper', reindent=True, indent_width=4)    # 格式化SQL
print(format_sql)
statements = sqlparse.parse(format_sql)          # 解析SQL，返回statement 对象
print(len(statements), statements)
for token in statements[0].tokens:               # 遍历statement 对象的tokens
    if token.value.isspace() or token.value == ';':     # 跳过空格，回车等字符
        continue
    print(f"Token Type: {token.ttype}, Token Value: {token.value}")
sql_type = statements[0].get_type()              # 获取SQL类型
print(sql_type)

from sqlglot import parse_one
from sqlglot.expressions import Where

sql = """
SELECT 
    user_id,
    name,
    age * 2 as double_age
FROM users
WHERE age > 18
"""

ast = parse_one(sql)

# 常用属性
ast.key                         # 获取节点类型；如果是 select 语句就返回 select，其他同理
ast.args                        # 获取节点的参数字典；没中 SQL 类型返回的参数结构也不一样；
ast.args['where'].sql()         # 获取 where 后面的条件表达式（带 where）： 'WHERE age > 18'
ast.args['where'].this.sql()    # 获取 where 后面的条件表达式（不带 where）： 'age > 18'
ast.expressions                 # 获取子表达式列表；具体表达式，如果是 select 语句，则这里是查询的列内容，包括列名、运算表达式、别名等
ast.parent                      # 获取父节点

# 常用方法
ast.sql()                       # 将 AST 转换回 SQL 字符串
ast.find_all()                  # 查找所有匹配的节点

ast.find()                      # 查找第一个匹配的节点
ast.find(Where).sql()           # 获取 where 后面的条件表达式（带 where）： 'WHERE age > 18'
ast.find(Where).this.sql()      # 获取 where 后面的条件表达式（不带 where）： 'age > 18'

ast.copy()                      # 创建节点的副本

hasattr(object, attribute_name)

class Person:
    def __init__(self):
        self.name = "张三"
        self.age = 25

# 创建实例
person = Person()

# 检查属性是否存在
print(hasattr(person, 'name'))    # 输出: True
print(hasattr(person, 'age'))     # 输出: True
print(hasattr(person, 'gender'))  # 输出: False

# 常与 getattr 配合使用
if hasattr(person, 'name'):
    name = getattr(person, 'name')
    print(name)  # 输出: 张三

isinstance(object, classinfo)

- object ：要检查的对象
- classinfo ：可以是：
	- 一个类
	- 一个类型
	- 或者由类与类型组成的元组

# 基本类型检查
num = 123
text = "Hello"
lst = [1, 2, 3]

print(isinstance(num, int))      # True
print(isinstance(text, str))     # True
print(isinstance(lst, list))     # True
print(isinstance(num, str))      # False

# 检查多个类型
print(isinstance(num, (int, float)))  # True，因为 num 是 int 类型

# 类的继承关系检查
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True，因为 Dog 继承自 Animal

# 在您之前代码中的用法
if isinstance(col, sqlglot.expressions.Column):
    # 处理列对象
    pass

__init__: 用于在创建对象时进行初始化操作
__str__: 如果类中定义了这个方法，则在print(类名)时，打印出来的内容是__str__方法return的内容
__slots__： 限定类的对象只能绑定_name, _age和_gender属性
__slots__ = ('_name', '_age', '_gender')


len(obj)         → obj.__len__()
str(obj)         → obj.__str__()
obj[key]         → obj.__getitem__(key)
obj + other      → obj.__add__(other)
obj == other     → obj.__eq__(other)


# 基本操作
len(obj)              → obj.__len__()
str(obj)              → obj.__str__()
repr(obj)             → obj.__repr__()
bool(obj)             → obj.__bool__()
int(obj)              → obj.__int__()
float(obj)            → obj.__float__()

# 容器操作
obj[key]              → obj.__getitem__(key)
obj[key] = value      → obj.__setitem__(key, value)
del obj[key]          → obj.__delitem__(key)
key in obj            → obj.__contains__(key)
iter(obj)             → obj.__iter__()
next(obj)             → obj.__next__()

# 数值运算
obj + other           → obj.__add__(other)
obj - other           → obj.__sub__(other)
obj * other           → obj.__mul__(other)
obj / other           → obj.__truediv__(other)
obj // other          → obj.__floordiv__(other)
obj % other           → obj.__mod__(other)
obj ** other          → obj.__pow__(other)
abs(obj)              → obj.__abs__()

# 比较运算
obj == other          → obj.__eq__(other)
obj != other          → obj.__ne__(other)
obj < other           → obj.__lt__(other)
obj <= other          → obj.__le__(other)
obj > other           → obj.__gt__(other)
obj >= other          → obj.__ge__(other)

# 属性操作
hasattr(obj, name)    → obj.__hasattr__(name)
getattr(obj, name)    → obj.__getattr__(name)
setattr(obj, name)    → obj.__setattr__(name)
delattr(obj, name)    → obj.__delattr__(name)

# 上下文管理
with obj:             → obj.__enter__() / obj.__exit__()

# 调用对象
obj()                 → obj.__call__()

# 反向运算（当左操作数不支持该操作时）
other + obj           → obj.__radd__(other)
other - obj           → obj.__rsub__(other)
other * obj           → obj.__rmul__(other)

# 增量运算
obj += other          → obj.__iadd__(other)
obj -= other          → obj.__isub__(other)
obj *= other          → obj.__imul__(other)

# 位运算
obj & other           → obj.__and__(other)
obj | other           → obj.__or__(other)
obj ^ other           → obj.__xor__(other)
~obj                  → obj.__invert__()
obj << other          → obj.__lshift__(other)
obj >> other          → obj.__rshift__(other)

f = open('致橡树.txt', 'r', encoding='utf-8')
content = f.read()
f.close()   # 关闭打开的文件，释放掉程序中获取的外部资源

# with关键字指定文件对象的上下文环境并在离开上下文环境时自动释放文件资源
with open('致橡树.txt', 'r', encoding='utf-8') as f:
   content = f.read()