【Python】常用操作

常用操作

排序

lambda 表达式

lambda 表达式常用于为 sorted() 函数提供自定义的排序规则。以下是一个示例，展示如何使用 lambda 表达式进行排序：

numbers = [('a', 5), ('b', 2), ('c', 8), ('d', 1)]

# 按照每个元组的第二个元素进行升序排序
sorted_numbers = sorted(numbers, key=lambda x: x[1])
print(sorted_numbers)

# 按照每个元组的第一个元素的长度进行降序排序
sorted_numbers = sorted(numbers, key=lambda x: len(x[0]), reverse=True)
print(sorted_numbers)

文件

读取文件

with open(txt_path,'r') as file:
    lines = file.readlines()
    for line in lines:
        process(line)

但当文件过大，一次读取内存不够放入整个文件内容

使用生成器，yield关键字

def read_big_file(txt_path, chunk_size=1024*1024):
    with open(txt_path,'r') as file:
        while True:
            chunk = file.readlines(chunk_size)
            if not chunk:
                break
            yield chunk
for line in read_big_file('file.txt'): #创建一个生成器
    process(line) 

写入文件

路径

Path

Path 通常指的是 pathlib 模块中的 Path 类，它提供了一种面向对象的方式来处理文件系统路径。

form pathlib import Path

p = Path('/home/user/documents')  # 创建实例对象
 
parent = p.parent    # 获取父目录
name = p.name   # 获取文件名
suffix = p.suffix  # 获取文件扩展名
stem = p.stem  # 获取文件名（不含扩展名）

if p.exists():
    print("路径存在")
else:
    print("路径不存在")

if p.is_file():
	print("是文件")
elif p.is_dir():
    print("是目录")

glob(得多用用)

glob 是 Python 中用于文件模式匹配的一个模块。它使用 Unix shell-style 的通配符来进行匹配，并返回所有匹配的文件路径列表。以下是一些 glob 的基本用法:

import glob
# 获取p目录下所有文件
f = []
f += glob.glob(str(p / "**" / "*.*"), recursive=True)

os

import os
def print_directory_contents(sPath)：
	for sChild in os.listdir(sPath): # os.listdir(path)获取path路径下所有的文件名
        sChildPath = os.path.join(sPath, sChild)
        if os.path.isdir(sChildPath): # 判断是否是文件夹
            print_directory_contents(sChildPath)
        else:
            print(sChildPath)

异常（这个用法还得多研究研究）

try-except

try:
    file = open("file.txt","w")
    file.write("zwy&ljq")
except IOError:
    print "Error:没找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    file.close()

如果try能正常运行，则直接转到else继续运行，否则反馈except里的报错信息

深浅拷贝

赋值

a=[1,2,"hello",['python', 'C++']] 
b=a #引用

浅拷贝

1. 切片操作

   b=a[1:]
   

2. 工厂函数

   b=list(a) #创建了一个类实例
   

3. copy函数

   b=copy.copy(a);
   

浅拷贝产生的列表 b 不再是列表 a 了，使用 is 判断可以发现他们不是同一个对象，使用 id 查看，他们也不指向同一片内存空间。但是当我们使用 id(x) for x in a 和 id(x) for x in b 来查看 a 和 b 中元素的地址时，可以看到二者包含的元素的地址是相同的。

浅拷贝之所以称之为浅拷贝，是它仅仅只拷贝了一层，在列表 a 中有一个嵌套的 list，如果我们修改了它，情况就不一样了。

比如：a[3].append(‘java’)。查看列表 b，会发现列表 b 也发生了变化，这是因为，我们修改了嵌套的 list，修改外层元素，会修改它的引用，让它们指向别的位置，修改嵌套列表中的元素，列表的地址并未发生变化，指向的都是用一个位置

深拷贝

b=copy.deepcopy(a)

深拷贝拷贝出来的对象根本就是一个全新的对象，不再与原来的对象有任何的关联

生成随机数random

import random
random.random() # 生成0-1之间的随机浮点数
random.uniform(a,b) # 生成[a,b]之间的浮点数
random.randint(a,b) # 生成[a,b]之间的整数
random.randrange(a,b,step) # 在集合[a,b)，以step为步长随机选取一个数
random.choice(sequence) #从序列中随机取一个元素
random.shuffle(alist) #打乱一个排好序的list

f-string

在 Python 中，在字符串前面加上 f 或 F 会创建一个格式化字符串（也称为 f-string）。
f-string 允许在字符串中嵌入表达式，并在运行时进行求值和替换。这使得字符串的格式化更加简洁和直观。例如：

name = "Alice"
age = 25
print(f"Hello, my name is {name} and I am {age} years old.")

在上述代码中，{name} 和 {age} 会被相应变量的值替换。

参数解析器

parser = argparse.ArgumentParser()

import argparse
def run(weights="model_path", save_txt=False):
	XXX
	XXX

if __name__=="__main__":
	parser = argparse.ArgumentParser()
	parser.add_argument("--weights", nargs="+", type=str, default=ROOT / "yolov5s.pt", help="model path or triton URL")
	parser.add_argument("--save-txt", action="store_true", help="save results to *.txt")
	opt = parser.parse_args()
	run(**vars(opt))

• vars(opt)的作用是将 opt 对象转换为一个字典。这个字典的键是 opt 对象的属性名，值是对应属性的值
• 在 run(**vars(opt))中使用两个**是为了将 opt 对象中的键值对作为关键字参数传递给 run 函数。当使用**时，它会将字典展开，使得字典中的键成为函数的参数名，值成为对应参数的值
  例如，如果 opt 包含属性 weights = ‘y_weights.pt’ 、 save_txt = True等，使用 **vars(opt) 就相当于将这些属性作为独立的参数传递给 run 函数，即 run(weights=‘my_weights.pt’, save_txt=True)
  这种方式提供了一种灵活和方便的方式来传递包含多个参数的对象给函数，而无需逐个明确地列出每个参数