【Python学习笔记】Python近期总结

pandas库的使用

import pandas as pd

读取csv文件

df = pd.read_csv("路径名",header,low_memory=False)

for循环遍历指定范围（左闭右开）

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)

df.shape

返回一个元组，包括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()

语法：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()和DataFrame.replace()

语法：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)

输出为csv文件

pandas.DataFrame.to_csv

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

  • 字符串，路径对象(实现os.PathLike[str])，或实现write()函数的类文件对象。如果为None，结果将作为字符串返回。如果传递了非二进制文件对象，则应该使用newline= "打开它，禁用通用换行符。如果传入二进制文件对象，mode可能需要包含’ b '。

• sep：str, default ‘,’

  • 长度为1的字符串，输出文件的字段分隔符。

• na_rep：str, default ‘’

  • 用于替换空值的。

• float_format：str, Callable, default None

  • 浮点数的格式字符串。如果给出了Callable，则它优先于其他数字格式参数，如decimal。
    • %.2f：保留两位小数
    • %f：原始浮点数格式（不进行任何格式化）
    • %.4f：保留四位小数
    • %.2e：使用科学计数法，并保留两位小数
    • %.0f：四舍五入到整数

• columns：sequence, optional

  • 指定将要写入文件中的列。

• header：bool or list of str, default True

  • 是否将列名写入文件，如果给出一个字符串列表，则假定它是列名的别名。

• index：bool, default True

  • 写行名(索引)。

• mode：{‘w’, ‘x’, ‘a’}, default ‘w’

  • 文件的打开模式
    • ‘w’, 且先把文件内容清空 /以只写模式打开文件。
    • ‘x’, 独占创建，如果文件已存在则失败。
    • ‘a’, 如果存在，则追加到文件末尾。

• encoding：str, optional

  • 表示要在输出文件中使用的编码的字符串，默认为’ utf-8 '。如果path_or_buf是非二进制文件对象，则不支持编码。

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 时间戳是指从 1970 年 1 月 1 日开始至今的秒数。通常用于在计算机系统、网络应用和数据传输中记录和计算时间。
• time.localtime()：Python 的 time 模块提供了 time.localtime() 方法，它用于将当前时间戳转换为本地时间的 struct_time 对象。struct_time 对象包括年、月、日、小时、分钟、秒、一周的第几天、一年的第几天、是否是夏时令（0表示否，1表示是），可以通过属性名或索引来获取。
• 时间戳转日期格式：通过时间戳和 time.localtime() 方法，我们可以将 Unix 时间戳转换为易读的日期和时间格式。Python 的 time 模块还提供了 time.strftime() 函数，它允许我们通过自定义格式将 struct_time 对象格式化为字符串。该函数接受一个格式化字符串作为参数，并将 struct_time 对象转换为符合格式化字符串指定格式的字符串。

示例：将 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

os库的使用

import os

os.listdir(path)

• 此方法返回一个列表，其中包含由指定的绝对路径目录下的所有文件夹和文件的名称。

• 它不会返回此目录下文件夹的下一级目录下的内容。

我们要读取路径为 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)

os.path.join(path1,path2,path3,…)

• 此方法用来拼接文件路径，path1为初始路径，path2、path3、…为需要拼接在其后的路径，可以依次拼接多个路径。

示例：

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

• os.path.getsize用于获取文件的大小（以字节为单位）。传入文件的路径作为参数，函数将返回文件的大小。

示例：

file_path = "file.txt"
file_size = os.path.getsize(file_path)
print("文件大小为:", file_size, "字节")

os.path.split(path)

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库的使用

定义了一个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
}

读取json文件

import json
with open("./data1.json","r") as file:
    json_data = json.load(file)

从目录下的data1.json文件中读入json数据，通过json.load方法将读入的json文本转换为Python中的字典存到json_data变量中。

获取json key

# 获取键
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"," ")

python基础操作

关于列表的操作

# 新建空列表
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()和endswith()的用法

startswith()用来检查字符串是否以指定字符串开头，如果是则返回True，否则返回False

语法：str.startswith(str, beg=0,end=len(string))

str为要检测的字符串，beg、end为可选参数用于设置字符串检测的起始结束位置

endswith()用来检查字符串是否以指定字符串结尾，常用于判断文件类型

语法与startswith类似

zip()函数

python字符串操作

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

python读取json文件

• JSON (JavaScript Object Notation) 是一种用于数据交换的轻量级格式。json.load()是python中用于加载JSON数据的函数。它接收一个文件对象作为参数，并将文件中的JSON数据解析为Python对象。

示例：

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"))

tqdm进度条

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]

python的内置属性和变量名

__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.

让我们分析一下发生了什么：

1. 当我们导入 my_module 模块时，在 my_module.py 中的代码会被执行，输出了一些内容。
2. 由于导入模块并不会直接执行模块中的最顶层代码（只有在导入时才会执行），所以 main.py 中的 “This is the main program.” 输出排在 my_module.py 中的内容之后。
3. 紧接着，我们在 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 时不会执行。

self

在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类中是一个特殊的参数，用于引用当前对象的实例，并访问和操作对象的属性和方法。

远程服务器jupyter本地访问

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小环境的基本使用

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 # 退出小环境