import pandas as pd
df = pd.read_csv("路径名",header,low_memory=False)
for i in range(1,50):
column = 'column' + str(i)
# 求出最小值并取三位小数
min = df[['column' + str(i) for i in range(1,50)]].min(axis=1).round(3)
返回一个元组，包括DataFrame对象的行数和列数
df.shape[1]，返回DataFrame对象的列数
df.shape[0]，返回DataFrame对象的行数
shape = df.shape
print(shape) # (500,40)表示500行40列
shape1 = df.shape[1]
print(shape1)# 40列
抽取列及合并想要的两种类型的列
duplicate_column = ["语文","数学","英语","物理","化学","生物"]
special_columns = df[duplicate_column]
common_columns = df.iloc[:, 27:147]
df = pd.concat([special_columns, common_columns], axis=1)
语法：DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
labels：一个字符或者一个数值，加上axis，表示label标识的行或者列
index：DataFrame中的index
axis：axis=0表示行，axis=1表示列
columns：列名
inplace：True表示删除某行某列后原DataFrame变化，False不改变原始DataFrame，默认为False
示例：
# 删除不需要的列
drop_columns_list = ["a","b","c","d","e"]
dataframe.drop(columns=drop_columns_list, inplace=True)
语法：DataFrame.query(expr, inplace=False, **kwargs)
示例：
selected_df = csv_df[(csv_df["real_time"] >= start_time) & (csv_df["real_time"] <= end_time)]
# 使用query（）优化后的代码
charge_df = dataframe.query(f"real_time >= '{start_time}' and real_time <= '{end_time}'")
语法：DataFrame.rename(mapper=None, index=None, columns=None, axis=None, copy=None, inplace=False, level=None, errors='ignore')
语法：DataFrame.replace(to_replace=None,value=_NoDefault.no_default,inplace=False, limit=None,regex=False,method=_NoDefault.no_default)
示例：
# rename用法1 ：
update_columns_df = df.rename(columns={"math": "m", "english":"e","chinese": "ch", "history":"h", "class": "cl"})
# rename用法2 ：
single_columns = {col: col.replace('voltage_', 'volt_').replace('temperature_', 'temp_') for col in update_columns_df.columns}
charge_update_columns_df.rename(columns=single_columns, inplace=True)
DataFrame.to_csv(path_or_buf=None, sep=',', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression='infer', quoting=None, quotechar='"', lineterminator=None, chunksize=None, date_format=None, doublequote=True, escapechar=None, decimal='.', errors='strict', storage_options=None)
常用参数介绍:
path_or_buf：str, path object, file-like object, or None, default None
sep：str, default ‘,’
na_rep：str, default ‘’
float_format：str, Callable, default None
columns：sequence, optional
header：bool or list of str, default True
index：bool, default True
mode：{‘w’, ‘x’, ‘a’}, default ‘w’
encoding：str, optional
df.to_csv(output_file,index=False,encoding='utf-8')
strptime将一个格式化时间字符串转化为datetime时间对象。字符串 => 日期时间对象
strftime将给定格式的日期对象转换为字符串。日期时间对象 => 字符串
from datetime import datetime
datetime.strptime(字符串，时间格式)
datetime.strftime()
timedelta()函数表示datetime对象之间的时间间隔timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
from datetime import datetime,timedelta
time = "2023-10-31"
new_time = dateime.strptime(time,"%Y-%m-%d")
print(new_time) # 2023-10-31 00:00:00
delete = timedelta(days=1)
print(new_time - delete) # 2023-10-30 00:00:00
示例：将 Unix 时间戳（秒级时间戳）转换为可读的日期和时间格式：
import time
# 获取当前时间戳
timestamp = time.time()
# 将时间戳转换为 struct_time 对象
local_time = time.localtime(timestamp)
# 格式化 struct_time 对象为字符串
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(timestamp)
print(local_time)
print(formatted_time)
1701152915.4056435
time.struct_time(tm_year=2023, tm_mon=11, tm_mday=28, tm_hour=14, tm_min=28, tm_sec=35, tm_wday=1, tm_yday=332, tm_isdst=0)
2023-11-28 14:28:35
该示例输出的日期格式为 YYYY-MM-DD HH:MM:SS，其中 YYYY、MM 和 DD 分别表示年、月和日，HH、MM 和 SS 分别表示时、分和秒。
示例：毫秒级时间戳转换
import time
now = int(1700928100000/1000)
timeArray = time.localtime(now)
otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S",timeArray)
print(timeArray)
print(otherStyleTime)
time.struct_time(tm_year=2023, tm_mon=11, tm_mday=26, tm_hour=0, tm_min=1, tm_sec=40, tm_wday=6, tm_yday=330, tm_isdst=0)
2023-11-26 00:01:40
import os
此方法返回一个列表，其中包含由指定的绝对路径目录下的所有文件夹和文件的名称。
它不会返回此目录下文件夹的下一级目录下的内容。
我们要读取路径为 C:\Users\xiaoming\Desktop 的目录。由于该路径包含转义字符 \，在使用时需要进行转义，即写成 C:\\Users\\xiaoming\\Desktop。然而，当文件路径很长或者包含大量转义字符时，手动进行转义可能会非常麻烦，因此我们可以使用以r或者R作为前缀来忽略所有转义字符。
示例：
raw_path1 = r"C:\Users\xiaoming\Desktop"
raw_path2 = "C:\\Users\\xiaoming\\Desktop"
file_name_list1 = os.listdir(raw_path1)
print(file_name_list1)
示例：
raw_path1 = r"C:\Users\kanglei\Desktop"
file_name_list1 = os.listdir(raw_path1)
for file in file_name_list1:
file_path1 = os.path.join(raw_path1,file)
print(file_path1)
raw_path2 = "C:\\Users\\kanglei\\Desktop"
file_name_list2 = os.listdir(raw_path2)
for file in file_name_list2:
file_path2 = os.path.join(raw_path2,file)
print(file_path2)
os.path.getsize用于获取文件的大小（以字节为单位）。传入文件的路径作为参数，函数将返回文件的大小。示例：
file_path = "file.txt"
file_size = os.path.getsize(file_path)
print("文件大小为:", file_size, "字节")
os.path.split(path) 是 Python 的 os.path 模块中的一个函数，用于将路径分割成目录路径和文件名部分。
下面是对 os.path.split(path) 函数的详细解释：
path 是一个字符串，表示一个文件的路径。/ 结尾，则表示路径为目录路径，文件名部分将为空字符串。示例：
import os
path = '/home/user/documents/example.txt'
dirname, filename = os.path.split(path)
print(f'Directory Path: {dirname}') # Directory Path: /home/user/documents
print(f'File Name: {filename}') # File Name: example.txt
定义了一个json文件名为data1.json
{
"aaa": [
{
"id": 0,
"time1": "2023-09-01T00:00:00",
"time1_row": 0,
"time2": "2023-09-01T15:06:45",
"time2_row": 3333
},
{
"id": 2,
"time1": "2023-09-01T15:07:00",
"time1_row": 3333,
"time2": "2023-09-01T17:30:00",
"time2_row": 4444
}
],
"bbb": [
{
"id": 0,
"time1": "2023-09-01T00:00:00",
"time1_row": 0,
"time2": "2023-09-01T15:06:45",
"time2_row": 3333
},
{
"id": 2,
"time1": "2023-09-01T15:07:00",
"time1_row": 3333,
"time2": "2023-09-01T17:30:00",
"time2_row": 4444
}
],
"ccc": [
{
"id": 0,
"time1": "2023-09-01T00:00:00",
"time1_row": 0,
"time2": "2023-09-01T15:06:45",
"time2_row": 3333
},
{
"id": 2,
"time1": "2023-09-01T15:07:00",
"time1_row": 3333,
"time2": "2023-09-01T17:30:00",
"time2_row": 4444
}
],
"ddd": 123.123456789
}
import json
with open("./data1.json","r") as file:
json_data = json.load(file)
从目录下的data1.json文件中读入json数据，通过json.load方法将读入的json文本转换为Python中的字典存到json_data变量中。
# 获取键
keys = json_data.keys()
# 遍历keys
for key in keys:
print(key)
# 判断某个键是否存在于json数据中
if "key_name" not in json_data.keys():
return False
# 获取json中某一个变量具体的值
start_time = json_data["charge_segs"][0]["time1"].replace("T"," ")
end_time = json_data["charge_segs"][0]["time2"].replace("T"," ")
# 新建空列表
csv_file = []
json_file = []
result = list()
# 向列表中添加数据
for file in file_path:
file_type = file.split(".")[1]
if file_type == "csv":
csv_file.append(file)
elif file_type == "json":
json_file.append(file)
# 排序列表
## sorted(iterable, /, *, key=None, reverse=False)
## iterable：待排序的序列
## key：排序规则
## reverse：指定排序的方式，默认值False，即升序排列
sorted_csv_file = sorted(csv_file)
sorted_json_file = sorted(json_file)
# 添加列表 extend() 可以在列表末尾添加另一个序列中的值。
# 语法：list.extend(iterable) iterable：需要添加的元素列表
change_columns_list = [f"class_{i}" for i in range(1, 31)]
change_columns_list.extend(["grade", "math_score", "english_score", "history_score", "chinese_score"])
#
startswith()用来检查字符串是否以指定字符串开头，如果是则返回True，否则返回False
语法：str.startswith(str, beg=0,end=len(string))
str为要检测的字符串，beg、end为可选参数用于设置字符串检测的起始结束位置
endswith()用来检查字符串是否以指定字符串结尾，常用于判断文件类型
语法与startswith类似
data = "2023-11-11 13:45:21.579 abc/defg/hijk/lm/nopq:[{"values":[[2020,0,123456],[2021,0,123456],[2022,0,123456],[2023,0,123456]],"name":"GERTSAN3USIAJH/abc","age":"20","idName":"GERTSAN3USI","inclusion":"0x03FE070000000000000000000000000000000000000000000000","ts":"2023-11-11 18:37:36"}]"
find() - 在字符串中搜索指定的值并返回它被找到的位置 - 返回的是要找的值中第一个字符的位置
time = data[0:data.find(" ")]
print(f'time={time}')# 2023-11-11 13:45:21.579
示例：
import json
# 打开 JSON 文件
with open('data.json') as file:
# 加载 JSON 数据
data = json.load(file)
上述代码中，我们首先使用 open() 函数打开一个 JSON 文件，并将其分配给一个文件对象 file。接着，我们使用 json.load() 函数将 file 中的 JSON 数据解析为 Python 对象，并将结果保存在变量 data 中。
当数据加载完成后，可以根据数据的结构和需求来处理 data。可以使用 Python 的数据处理和操作技术，如字典和列表的访问、遍历和修改等。除了加载本地 JSON 文件，json.load() 函数还可以加载字符串形式的 JSON 数据，只需将 JSON 字符串传递给该函数即可。
load 和 loads 的区别。
loads 函数是用于将一个 JSON 字符串解码为 Python 对象。它将一个字符串参数作为输入，并返回一个对应的 Python 数据结构。例如：import json
json_str = '{"name": "Alice", "age": 30}'
data = json.loads(json_str)
print(data["name"]) # 输出 "Alice"
print(data["age"]) # 输出 30
load 函数与 loads 函数非常相似，不同之处在于 load 函数可以从打开的文件中读取 JSON 数据，而不是从字符串中读取。例如：import json
with open('data.json') as f:
data = json.load(f)
print(data["name"]) # 输出 "Alice"
print(data["age"]) # 输出 30
因此，loads 和 load 函数的区别在于其输入来源不同，一个来自于一个 JSON 字符串，另一个来自于已经打开的文件对象。
#字典的定义
info = {"name":"Jack","age":20,"sex":"man"} #使用大括号{},键值存储类型一一对应，键值之间用冒号相连接
#字典的访问
print(info["name"]) # Jack
print(info["age"]) # 20
#访问不存在的键
#print(info["gender"]) #直接访问，没有找到相应的键，会报错
print(info.get("gender")) #使用get方法，没有找到相应的键，默认返回：None
print(info.get("gender","m"))#没有找到，可以设定返回默认值
print(info.get("age","20"))
print(info.get("age","18"))
from tqdm import tqdm
for file in tqdm(os.listdir(file_dir)):
print(f'文件名为:{file}')
运行代码，就会看到一个动态的进度条。会显示出来还有多少项需要处理、预计剩余时间、当前的处理速度
48%|█████ | 11/23 [12:58<13:08, 65.69s/it]
__init__, __name__, __main____init__, __name__, __main__ 是 Python 中一些特殊的内置属性和变量名。
__init__ 是一个特殊的方法，用于在创建一个对象时进行初始化操作。它是在类的实例被创建时调用的构造函数。通过定义 __init__ 方法，可以设置对象的初始状态和属性。__name__ 是一个内置变量，用于表示当前模块（文件）的名称。当一个模块被直接运行时，其 __name__ 属性的值为 "__main__"。而当一个模块被导入到其他模块中时，__name__ 的值为模块的名称。__main__ 是一个特殊的顶级执行上下文，用于表示当前脚本（模块）正在被直接执行，而不是被导入到其他脚本中。当一个脚本被直接执行时，Python 解释器将会将该脚本中的代码当作主程序来执行，并将 __name__ 的值设置为 "__main__"。这样，我们可以在脚本中编写一些仅在脚本被直接执行时执行的特定操作，而这些操作在导入该脚本时不会执行。假设我们有两个文件：main.py 和 my_module.py。
main.py：
import my_module
print("This is the main program.")
obj = my_module.MyClass()
my_module.py：
class MyClass:
def __init__(self):
print("This is MyClass's __init__ method.")
def print_value(self):
print("This is MyClass's print_value method.")
print("This is my_module.py.")
print("__name__ value:", __name__)
当我们运行 main.py 时，输出如下：
This is my_module.py.
__name__ value: my_module
This is the main program.
This is MyClass's __init__ method.
让我们分析一下发生了什么：
my_module 模块时，在 my_module.py 中的代码会被执行，输出了一些内容。main.py 中的 “This is the main program.” 输出排在 my_module.py 中的内容之后。main.py 中创建了 my_module.MyClass 的实例，会触发 MyClass 类的 __init__ 方法，并输出 “This is MyClass’s init method.”。关键点在于 __name__ 的值。当我们直接运行 my_module.py 时，它的 __name__ 值为 "__main__"，而当 my_module.py 被导入为模块时，__name__ 值为模块的名称（在这个例子中是 "my_module"）。
因此，在 main.py 中导入 my_module 时，my_module.py 的顶层代码会被执行，并输出相应的内容。但 MyClass 类的实例创建和方法调用部分（obj = my_module.MyClass()）只会在我们直接运行 main.py 时才会执行，而在导入 my_module 时不会执行。
在Python中，self 是一个约定俗成的名字，用于表示对象自身。它是一个形式参数，在方法中用于引用当前对象的实例。
当定义一个类的方法时，第一个参数通常被命名为self，以表示对当前实例的引用。在方法调用时，不需要显式地传入self参数，Python会自动为方法添加当前对象的实例作为第一个参数。
使用self 参数可以访问和操作当前对象的属性和方法。通过将属性和方法与self关联，我们可以在类的不同方法之间共享数据，并操作对象自身的状态。
下面是一个例子，展示了self的使用：
class MyClass:
def __init__(self, value):
self.value = value
def some_method(self):
print("The value is:", self.value)
def modify_value(self, new_value):
self.value = new_value
obj = MyClass(10)
obj.some_method() # 输出: The value is: 10
obj.modify_value(20)
obj.some_method() # 输出: The value is: 20
在上述代码中，self 用于引用 MyClass 类的实例，并与实例的属性 value 和方法 some_method 关联。在 some_method 中，我们可以通过 self.value 访问和操作 MyClass 实例的 value 属性。在 modify_value 中，我们通过 self.value 更新了实例的 value 属性。
总之，self 在Python类中是一个特殊的参数，用于引用当前对象的实例，并访问和操作对象的属性和方法。
tmux info # 列出当前所有tmux会话的信息
tmux new -s <name> # 启动命名tmux
tmux attach -t notebook # 重新连接会话 使用伪窗口名称
jupyter lab --no-browser --port=1000 --ip=0.0.0.0 # 远程服务器jupyter本地访问开启端口
alg006.abc.def:1000 # jupyter访问路径
conda -V # 查看conda版本
conda create -n aa # 创建一个小环境
conda create -n bb python=3.10 # 创建一个python版本为3.10的小环境
conda info -e # 查看已存在的小环境名称
conda activate bb # 启动激活已有的小环境
conda deactivate # 退出小环境