可以通过层级方式直接访问配置项，也可以将某一级定义为新的配置对象，以便更方便地管理和访问配置。这两种方法各有优缺点，可以根据具体需求选择合适的方式。

### 1. 层级方式访问配置项

这种方式直接通过字典的键来访问配置项，适用于简单的配置结构。

#### 示例代码

假设你有一个 `config.yaml` 文件，内容如下：

```yaml
default:
  username: your_username
  password: your_password
  database:
    host: localhost
    port: 5432
    name: my_database
```

你可以直接通过层级方式访问配置项：

```Python
import yaml

# 读取 YAML 文件
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

# 获取配置项
username = config['default']['username']
password = config['default']['password']
host = config['default']['database']['host']
port = config['default']['database']['port']
name = config['default']['database']['name']

print(f'Username: {username}')
print(f'Password: {password}')
print(f'Host: {host}')
print(f'Port: {port}')
print(f'Database Name: {name}')
```

### 2. 将某一级定义为新的配置对象

这种方式将某一级配置提取出来，定义为一个新的配置对象，适用于复杂的配置结构，可以提高代码的可读性和可维护性。

#### 示例代码

假设你有一个 `config.yaml` 文件，内容如下：

```yaml
default:
  username: your_username
  password: your_password
  database:
    host: localhost
    port: 5432
    name: my_database
```

你可以将 `default` 和 `database` 分别定义为新的配置对象：

```Python
import yaml

# 读取 YAML 文件
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

# 提取配置对象
default_config = config['default']
database_config = default_config['database']

# 获取配置项
username = default_config['username']
password = default_config['password']
host = database_config['host']
port = database_config['port']
name = database_config['name']

print(f'Username: {username}')
print(f'Password: {password}')
print(f'Host: {host}')
print(f'Port: {port}')
print(f'Database Name: {name}')
```

### 3. 使用类封装配置

为了进一步提高代码的可读性和可维护性，可以将配置封装在一个类中。

#### 示例代码

```Python
import yaml

class Config:
    def __init__(self, config_dict):
        self.default = config_dict['default']
        self.database = self.default['database']

    @property
    def username(self):
        return self.default['username']

    @property
    def password(self):
        return self.default['password']

    @property
    def host(self):
        return self.database['host']

    @property
    def port(self):
        return self.database['port']

    @property
    def name(self):
        return self.database['name']

# 读取 YAML 文件
with open('config.yaml', 'r') as file:
    config_dict = yaml.safe_load(file)

# 创建配置对象
config = Config(config_dict)

# 获取配置项
print(f'Username: {config.username}')
print(f'Password: {config.password}')
print(f'Host: {config.host}')
print(f'Port: {config.port}')
print(f'Database Name: {config.name}')
```

### 总结

- **层级方式**：适用于简单的配置结构，直接通过字典的键来访问配置项。
- **定义新的配置对象**：适用于复杂的配置结构，将某一级配置提取出来，定义为新的配置对象，提高代码的可读性和可维护性。
- **使用类封装配置**：进一步提高代码的可读性和可维护性，将配置封装在一个类中，通过属性访问配置项。

选择哪种方式取决于你的具体需求和配置的复杂度。希望这些示例能帮助你更好地管理和访问配置。