python学习2

基础

如何查看python安装在哪

https://www.w3cschool.cn/article/14581393.html
windows：where python
linux：which python

全局变量修改后的生效情况

在Python中，全局变量是在模块级别定义的变量，可以在模块中的任何地方访问。

1. 如果在一个脚本中修改了全局变量的值，那么在同一个脚本中访问该变量时，会使用修改后的值。
2. 但是在其它脚本中访问该变量时，会使用修改前的值，因为每个脚本都有自己的命名空间，全局变量只在当前脚本中有效。

那么，如何才能做到在导入一个模块的时候，让模块中的全局变量自动初始化呢？
在Python中，当一个模块被导入时，Python解释器会执行该模块中的所有顶级代码，包括函数定义、类定义、变量赋值等。因此如果想要在导入模块时自动执行某个函数，需要在该模块中显式地调用该函数。

例如，在b.py中定义了一个名为init()的函数，如果想要在a.py中导入b.py时自动执行该函数，可以在b.py中添加如下代码：

def init():
    # 初始化代码
    pass

init()  # 在模块被导入时自动执行init()函数

这样，在a.py中导入b.py时，init()函数会被自动执行。

需要注意的是，如果在b.py中定义的函数或变量被多个模块导入，那么init()函数也会被多次执行。为了避免这种情况，可以在init()函数中添加判断语句，只在第一次执行时进行初始化操作。

g_is_inited = False
def init():
    global g_is_inited
    if g_is_inited:
        return
 
    # 初始化代码
    g_is_inited = True
    pass

init()  # 在模块被导入时自动执行init()函数

如何定义类中的静态方法？

使用@staticmethod：

class MyClass:
    @staticmethod
    def static_method(arg1):
        # do something

MyClass.static_method(1)

如何定义类中的静态变量？

在Python中，可以使用以下两种方法来创建静态变量：

1. 直接在类中定义静态变量；
2. 在类方法中定义静态变量；

class Test:
    stc_attr = 1

    def __init__(self, attr1, attr2):
        self.attr1 = attr1
        self.attr2 = attr2

logging模块

import logging

# 初始化，设置最低级日志输出级别，输出文件，格式
logging.basicConfig(level=logging.DEBUG, filename='example.log', format='%(asctime)s - %(levelname)s - %(message)s')

logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')

这样相关日志全部被输出到example.log了；

使用相对路径来引用同级目录下的文件

import os

# 获取当前脚本所在目录的绝对路径
dir_path = os.path.dirname(os.path.abspath(__file__))

# 拼接文件路径
file_path = os.path.join(dir_path, 'file.txt')

# 打开文件并读取内容
with open(file_path, 'r') as f:
    content = f.read()

print(content)

namedtuple

在Python中，namedtuple是一个非常有用的数据结构，它是一个类工厂函数，用于创建具有命名字段的元组子类。namedtuple可以看作是元组的子类，它允许我们给元组中的每个元素命名，从而使得代码更加易读和易于维护。

namedtuple的语法如下：

from collections import namedtuple

# 创建一个namedtuple类
Person = namedtuple('Person', ['name', 'age', 'gender'])

# 创建一个Person对象
person = Person(name='Tom', age=20, gender='male')

# 访问Person对象的属性
print(person.name)   # 输出：Tom
print(person.age)    # 输出：20
print(person.gender) # 输出：male

在上面的代码中，我们首先通过namedtuple函数创建了一个名为Person的类，该类有三个属性：name、age和gender。然后我们创建了一个Person对象，并给它的属性赋值。最后，我们通过点号访问了Person对象的属性。

namedtuple的优点在于，它既具有元组的不可变性，又具有类的可读性和可访问性。此外，namedtuple还支持所有元组的操作，例如索引和切片。因此，它是一个非常实用的数据结构，可以用于各种场合，例如表示一条记录、一个点、一个状态等等。

实战

如何将yaml文件导出成结构体

import yaml
from collections import namedtuple

# 递归地将字典转换为namedtuple子类并实例化
def dict_to_namedtuple(d):
    for k, v in d.items():
        if isinstance(v, dict):
            d[k] = dict_to_namedtuple(v)
    return namedtuple(Config, d.keys())(*d.values())

with open('example.yaml', 'r', encoding='utf-8') as f:
    data = yaml.safe_load(f)

config = dict_to_namedtuple(data)
print(config)

上面核心是那个递归函数，比如传入的字典为：
d = {‘name’: ‘John’, ‘age’: 30, ‘gender’: ‘male’, ‘aaa’: {‘bbb’: ‘ccc’} }
则可以用config.aaa.bbb进行访问。