夜羽的小作坊

CMake 入门

Tue, 12 May 2026 00:00:00 GMT

CMake Introduction 的目标不是覆盖 CMake 的全部功能，而是解释一个 C++ 初学者最先需要理解的几件事：CMake 是什么、CMakeLists.txt 写什么、如何配置和构建项目，以及为什么现代 C++ 项目普遍围绕 target 来组织。

很多 C++ 初学者第一次看到 CMakeLists.txt 时，会误以为 CMake 是另一种编译器，或者是 Makefile 的替代语法。更准确地说，CMake 是一个构建系统生成器。

你写的是项目描述：

项目叫什么
用什么语言
使用哪个 C++ 标准
哪些源码要编译成可执行程序
哪些库需要被链接

CMake 再根据这些描述生成真正的构建文件，比如 Ninja 文件、Makefile 或 Xcode 工程。

从手动编译开始

假设我们只有一个 C++ 文件：

// main.cpp
#include <iostream>

int main() {
    std::cout << "Hello, CMake!" << std::endl;
    return 0;
}

不用 CMake 时，可以直接调用编译器：

clang++ -std=c++23 -Wall -Wextra -o hello main.cpp
./hello

这对单文件程序很直接。但当源码文件变多、要区分 Debug 和 Release、要链接第三方库、要给 IDE 提供项目信息时，手写命令会很快变得难维护。

CMake 解决的正是这个问题：把构建规则写进项目里。

最小 CMake 项目

一个最小项目可以长这样：

hello-cmake/
├── CMakeLists.txt
└── main.cpp

main.cpp：

#include <iostream>

int main() {
    std::cout << "Hello, CMake!" << std::endl;
    return 0;
}

CMakeLists.txt：

cmake_minimum_required(VERSION 3.20)
project(hello_cmake CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(hello main.cpp)

这就是一个完整的 CMake 项目。

逐行解释 CMakeLists.txt

第一行：

cmake_minimum_required(VERSION 3.20)

声明项目需要的最低 CMake 版本。这样可以避免旧版本 CMake 不认识某些语法。

第二行：

project(hello_cmake CXX)

定义项目名，并声明这个项目使用 C++。CXX 是 CMake 里表示 C++ 语言的名字。

接下来两行：

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

要求使用 C++23，并且这个要求是必须满足的。如果编译器不支持 C++23，CMake 会在配置阶段报错。

最后一行：

add_executable(hello main.cpp)

定义一个可执行程序。这里的 hello 是 target 名字，也是最终生成的可执行文件名；main.cpp 是它的源码文件。

现代 CMake 的核心概念就是 target。可执行程序是 target，库也是 target。后续的头文件路径、编译选项、链接关系，通常都应该围绕 target 来写。

配置、构建、运行

进入项目目录后，先配置：

cmake -S . -B build -G Ninja

再构建：

cmake --build build

运行：

./build/hello

这是最常见的 CMake 使用流程。

`-S` 和 `-B`

这条命令：

cmake -S . -B build

可以读成：

-S .：源码目录是当前目录
-B build：构建目录是 build

推荐把源码目录和构建目录分开，这叫 out-of-source build。这样源码目录不会混进大量中间文件。想重新来过时，删除 build 目录即可。

rm -rf build

`-G Ninja`

-G 用来指定 CMake 的 generator：

cmake -S . -B build -G Ninja

generator 决定 CMake 要生成哪种底层构建系统。

常见选择：

Ninja：速度快，适合日常开发
Unix Makefiles：生成 Makefile
Xcode：生成 Xcode 工程

如果不指定 -G，CMake 会使用当前环境的默认 generator。

CMake 和 Makefile 的关系

CMake 可以生成 Makefile，但 CMake 本身不是 Makefile。

手写 Makefile 时，你是在直接告诉 make 每一步怎么编译：

CXX = clang++
CXXFLAGS = -std=c++23 -Wall -Wextra
TARGET = hello
SRC = main.cpp

$(TARGET): $(SRC)
	$(CXX) $(CXXFLAGS) -o $@ $^

clean:
	rm -f $(TARGET)

而使用 CMake 时，你是在描述项目结构：

add_executable(hello main.cpp)

然后由 CMake 生成 Makefile、Ninja 文件或 IDE 工程。

所以，小 demo 可以手写 Makefile；稍微正式一点的 C++ 项目，更常见的选择是 CMake。

Debug 和 Release

CMake 可以指定构建类型。

Debug 构建：

cmake -S . -B build-debug -G Ninja -DCMAKE_BUILD_TYPE=Debug
cmake --build build-debug

Release 构建：

cmake -S . -B build-release -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build-release

常见构建类型：

Debug：带调试信息，适合开发和调试
Release：开启优化，适合发布或性能测试
RelWithDebInfo：开启优化，同时保留调试信息

多个源码文件

当项目从一个文件变成多个文件时，可以继续把源码添加到同一个 target：

hello-cmake/
├── CMakeLists.txt
├── greeting.cpp
├── greeting.h
└── main.cpp

greeting.h：

#pragma once

#include <string>

std::string make_greeting(const std::string& name);

greeting.cpp：

#include "greeting.h"

std::string make_greeting(const std::string& name) {
    return "Hello, " + name + "!";
}

main.cpp：

#include <iostream>

#include "greeting.h"

int main() {
    std::cout << make_greeting("CMake") << std::endl;
    return 0;
}

CMakeLists.txt：

cmake_minimum_required(VERSION 3.20)
project(hello_cmake CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(hello
  main.cpp
  greeting.cpp
)

这里没有把头文件写进 add_executable，因为真正需要编译的是 .cpp 文件。头文件会通过 #include 被编译器读取。

拆成库

项目继续变大时，通常会把一部分代码拆成库：

hello-cmake/
├── CMakeLists.txt
├── include/
│   └── greeting/
│       └── greeting.h
└── src/
    ├── greeting.cpp
    └── main.cpp

include/greeting/greeting.h：

#pragma once

#include <string>

std::string make_greeting(const std::string& name);

src/greeting.cpp：

#include "greeting/greeting.h"

std::string make_greeting(const std::string& name) {
    return "Hello, " + name + "!";
}

src/main.cpp：

#include <iostream>

#include "greeting/greeting.h"

int main() {
    std::cout << make_greeting("CMake") << std::endl;
    return 0;
}

CMakeLists.txt：

cmake_minimum_required(VERSION 3.20)
project(hello_cmake CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_library(greeting src/greeting.cpp)
target_include_directories(greeting PUBLIC include)

add_executable(hello src/main.cpp)
target_link_libraries(hello PRIVATE greeting)

这里出现了三个重要命令。

创建库：

add_library(greeting src/greeting.cpp)

声明库的公开头文件目录：

target_include_directories(greeting PUBLIC include)

让可执行程序链接这个库：

target_link_libraries(hello PRIVATE greeting)

PUBLIC 表示 greeting 自己需要这个 include 目录，链接 greeting 的 target 也需要这个 include 目录。

PRIVATE 表示 hello 只是自己链接 greeting，这个关系不需要再向外传播。

记住这条主线

入门阶段不需要记太多 CMake 命令。先记住这条主线：

add_executable(...)
add_library(...)
target_include_directories(...)
target_link_libraries(...)

也就是：

先定义 target
再给 target 配头文件目录
再描述 target 之间的链接关系

这样写出来的 CMake 项目更容易扩展，也更接近真实 C++ 项目的组织方式。

Python for Machine Learning

Mon, 03 Jul 2023 00:00:00 GMT

Python for Machine Learning

前言

我当时在做一个和机器学习（Machine Learning，ML）、深度学习（Deep Learning，DL）、Cybersecurity 有关的项目，但自己对 Python 工程经验、ML 和 DL 都不够熟悉，直接看课程和书会比较吃力。因此这篇文章整理的是一份快速补齐 Python 基础的路线，目标不是把 Python 学到很深，而是尽快能读懂 ML/DL/强化学习（Reinforcement Learning，RL）相关代码，并能开始做实验。

如果后续要系统做 ML 或 DL，Python 基础越扎实越好；但入门阶段不必追求一次性学完所有语法。先掌握最常用的语言结构、数据处理、文件读写、包管理和调试方法，就足够支撑后续继续学习。

1. 基础语法

需要先熟悉变量、数据类型、条件分支、循环、函数和类。写代码时尽量保持命名清晰、结构简单，后续读 ML 代码会轻松很多。

# Variables and basic data types
name = "John"
age = 25
is_student = True
height = 1.75

# Control flow statements - if-else
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

# Loops - for loop
for i in range(1, 6):
    print(i)

# Functions
def greet(name):
    print("Hello, " + name + "!")

greet("Alice")

# Classes and objects
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print("My name is", self.name, "and I am", self.age, "years old.")

person1 = Person("Alice", 25)
person1.introduce()

person2 = Person("Bob", 30)
person2.introduce()

这里最容易困惑的是 __init__ 和 self。__init__ 是类的构造方法，创建对象时会自动调用；self 表示当前对象本身，用来访问对象自己的属性和方法。比如 self.name = name 就是把传入的 name 保存到这个对象上。

2. 数据结构

Python 内置的 list、tuple、dict 和 set 非常常用。ML 代码里经常需要组织样本、标签、配置和中间结果，所以至少要掌握索引、切片、遍历、增删改查这些操作。

# Lists
fruits = ['apple', 'banana', 'orange']
print(fruits)

print(fruits[0])
print(fruits[-1])

fruits[1] = 'grape'
fruits.append('mango')
removed_fruit = fruits.pop(1)
print(removed_fruit)
print(fruits)

# Tuples
person = ('John', 25, 'USA')
name, age, country = person
print(name, age, country)

# Dictionaries
student = {'name': 'Alice', 'age': 20, 'major': 'Computer Science'}
print(student['name'])
print(student.get('age'))

student['age'] = 21
student['university'] = 'ABC University'
removed_major = student.pop('major')
print(removed_major)
print(student)

dict 在实验代码里尤其常见，常被用来保存超参数、指标、配置项和数据字段。相比用多个列表硬凑，字典能直接表达“键 -> 值”的映射关系。

3. 常用库和模块

进入 ML 前，至少要知道怎么导入库，以及几个基础库各自做什么。

import math
import random

print(math.sqrt(25))
print(math.pi)
print(random.randint(1, 10))
print(random.choice(['apple', 'banana', 'orange']))

from datetime import date
from random import shuffle

today = date.today()
print(today)

my_list = [1, 2, 3, 4, 5]
shuffle(my_list)
print(my_list)

import numpy as np
import pandas as pd

array = np.array([1, 2, 3, 4, 5])
print(array)

data_frame = pd.DataFrame({'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]})
print(data_frame)

常用库可以先按用途记：

NumPy：数值计算和数组操作，是很多科学计算库的基础。
Pandas：表格数据处理，常用于读 CSV、清洗数据、做统计分析。
Matplotlib：画图和可视化，适合看数据分布和模型结果。
scikit-learn：传统 ML 常用库，包含分类、回归、聚类、降维、评估等工具。
TensorFlow / PyTorch：DL 框架，用来搭建和训练神经网络。

一个很简化的 scikit-learn 示例：

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Load the dataset
data = pd.read_csv('data.csv')

# Split the dataset into features and labels
X = data.drop('label', axis=1)
y = data['label']

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train a logistic regression model
model = LogisticRegression()
model.fit(X_train, y_train)

# Evaluate the model
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

4. 文件读写

做 ML 时经常要读数据集、保存处理结果、写日志或者保存配置。最基本的是理解 with open(...) 的写法，它能保证文件用完后正确关闭。

def write_to_file(filename, content):
    with open(filename, 'w') as file:
        file.write(content)


def read_from_file(filename):
    with open(filename, 'r') as file:
        return file.read()


filename = "example.txt"
content_to_write = "Hello, World!"

write_to_file(filename, content_to_write)
content_read = read_from_file(filename)
print(content_read)

如果不想覆盖已有文件，可以先检查文件是否存在：

import os


def write_to_file(filename, content):
    if os.path.isfile(filename):
        print(f"File '{filename}' already exists.")
    else:
        with open(filename, 'w') as file:
            file.write(content)
        print(f"Content '{content}' written to '{filename}'.")

更完整一点的版本可以加异常处理和追加写入：

def write_to_file(filename, content):
    try:
        with open(filename, 'w') as file:
            file.write(content)
        print(f"Content written to '{filename}' successfully.")
    except IOError as e:
        print(f"Error writing to '{filename}': {e}")


def read_from_file(filename):
    try:
        with open(filename, 'r') as file:
            return file.read()
    except FileNotFoundError:
        print(f"File '{filename}' not found.")
    except IOError as e:
        print(f"Error reading from '{filename}': {e}")


def append_to_file(filename, content):
    try:
        with open(filename, 'a') as file:
            file.write(content)
        print(f"Content appended to '{filename}' successfully.")
    except IOError as e:
        print(f"Error appending to '{filename}': {e}")


filename = "example.txt"
write_to_file(filename, "Hello, World!")
append_to_file(filename, "\nAppending some more content!")
print(read_from_file(filename))

5. ML/DL 相关函数和库

不需要一开始就掌握所有框架，但要知道基本分工。

NumPy：负责矩阵、向量、随机数、线性代数等基础数值计算。
Pandas：负责结构化数据的读取、筛选、合并、清洗和统计。
scikit-learn：适合传统 ML，比如线性回归、逻辑回归、SVM、随机森林、KMeans 等。
TensorFlow：Google 推出的 DL 框架，配合 Keras 可以快速搭模型。
PyTorch：动态图机制更直观，科研和原型验证里非常常见。
Matplotlib：画 loss 曲线、散点图、直方图、预测结果等。

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Generate sample data
X = np.random.rand(100, 1)
y = 2 * X + np.random.randn(100, 1)

# Create a Pandas DataFrame
df = pd.DataFrame({'X': X.flatten(), 'y': y.flatten()})

# Fit a linear regression model
model = LinearRegression()
model.fit(X, y)

# Predict the output
X_new = np.array([[0.2], [0.4], [0.6]])
y_pred = model.predict(X_new)

# Plot the data and regression line
plt.scatter(X, y, color='blue', label='Data')
plt.plot(X_new, y_pred, color='red', linewidth=2, label='Regression Line')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()

这段代码包含了一个典型的最小流程：生成数据、组织数据、训练模型、预测、可视化。后续复杂模型基本也是在这个流程上扩展。

6. 异常处理和调试

写 ML 代码时，错误不一定来自算法，也可能来自数据维度、文件路径、包版本、数据类型。先掌握基础调试方法很重要。

常见错误大致可以分为：

语法错误：代码本身不符合 Python 语法。
运行时错误：比如文件不存在、数组越界、类型不匹配。
逻辑错误：代码能跑，但结果不对，这类最难查。

异常处理的基本写法如下：

try:
    # Code that might raise an exception
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
except Exception as e:
    print("Unexpected error:", e)

也可以用 logging 代替大量 print，尤其是训练过程比较长的时候：

import logging

logging.basicConfig(level=logging.DEBUG)

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

调试时建议先读报错信息和 stack trace，定位出错行；如果问题不明显，就逐步缩小代码范围，检查关键变量的 shape、dtype 和取值。

7. 包管理

ML/DL 项目依赖通常比较多，环境管理不清楚很容易出现“在我机器上能跑”的问题。

pip：Python 默认包管理器，例如 pip install numpy。
venv：Python 内置虚拟环境工具，可以为每个项目创建独立环境。
conda：常用于数据科学项目，适合管理 Python 版本、CUDA 相关依赖和科学计算库。
requirements.txt：记录项目依赖，常用 pip freeze > requirements.txt 生成，用 pip install -r requirements.txt 安装。
版本约束：例如 numpy==1.26.4 表示固定版本，torch>=2.0.0 表示最低版本。

一个简单流程：

python -m venv .venv
source .venv/bin/activate
pip install numpy pandas scikit-learn matplotlib
pip freeze > requirements.txt

后续如果换机器或给别人复现，可以直接：

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

小结

这篇文章的重点是：为了学习 ML/DL，不需要先把 Python 所有细节都学完，但要先掌握能支撑实验代码的核心能力，包括基础语法、常见数据结构、常用库、文件读写、异常处理、调试和包管理。

接下来比较适合的路线是：先用 NumPy 和 Pandas 做数据处理，再用 scikit-learn 跑几个传统 ML 模型，最后进入 PyTorch 或 TensorFlow。边学边写小实验，比单纯看教程有效很多。

C++ Vector 详解

Wed, 26 Apr 2023 00:00:00 GMT

Vector

简介

vector 是 C++ 标准库中的动态数组容器，功能类似其他语言的 ArrayList。它支持运行时动态扩容，并可随时查询当前元素数量。

基本用法

#include<iostream>
#include<vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {}
};

// 重载 << 运算符，支持直接输出 Vertex
std::ostream& operator<<(std::ostream& stream, const Vertex vertex)
{
    stream << "(" << vertex.x << ", " << vertex.y << ", " << vertex.z << ")";
    return stream;
}

int main()
{
    std::vector<Vertex> vertices;

    vertices.push_back({ 1, 2, 3 });
    vertices.push_back({ 4, 5, 6 });

    // 下标遍历
    for (int i = 0; i < vertices.size(); i++)
        std::cout << vertices[i] << std::endl;

    vertices.erase(vertices.begin() + 1); // 删除索引 1 处的元素

    // 范围 for 遍历，使用引用避免拷贝
    for (Vertex& v : vertices)
        std::cout << v << std::endl;

    std::cin.get();
}

几个关键点：

使用前需要 #include<vector>。
push_back() 在末尾追加元素；erase() 配合 begin() 加偏移量删除指定位置元素。
与 Java 不同，C++ vector 的元素类型可以是基本类型（如 int），不必是对象。
范围 for 循环中用引用（&）接收元素，避免不必要的拷贝。
重载 << 运算符可自定义类型的输出格式。
初始化列表（initializer list）在构造函数中直接初始化成员，效率高于赋值。

性能优化

上面的示例展示了基本用法，但存在不必要的拷贝开销。下面针对拷贝问题进行优化。

减少拷贝

首先要明确拷贝发生在哪里。给 Vertex 添加拷贝构造函数并打印日志，可以直观看到拷贝次数：

#include<iostream>
#include<vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {}

    Vertex(const Vertex& vertex)
        : x(vertex.x), y(vertex.y), z(vertex.z)
    {
        std::cout << "Copied!" << std::endl; // 每次拷贝时打印
    }
};

int main()
{
    std::vector<Vertex> vertices;
    vertices.push_back(Vertex(1, 2, 3));
    vertices.push_back(Vertex(4, 5, 6));
    vertices.push_back(Vertex(4, 5, 6));

    std::cin.get();
}

运行上面的代码，控制台会打印 6 次 "Copied!"。

避免扩容引发的拷贝

vector 容量不足时会重新分配内存，将已有数据全部拷贝到新位置后再释放旧内存。每次 push_back() 触发扩容，就会产生额外拷贝。

用 reserve() 预先声明所需容量，可以避免扩容：

std::vector<Vertex> vertices;

vertices.reserve(3); // 预分配 3 个元素的空间，避免扩容

vertices.push_back(Vertex(1, 2, 3));
vertices.push_back(Vertex(4, 5, 6));
vertices.push_back(Vertex(4, 5, 6));

加上 reserve(3) 后，控制台只打印 3 次 "Copied!"。

避免构造时的额外拷贝

push_back(Vertex(1, 2, 3)) 先在当前作用域构造一个临时对象，再将其拷贝进 vector。使用 emplace_back() 可以将参数直接传给 vector 内部的构造函数，省去这次拷贝：

vertices.emplace_back(1, 2, 3);
vertices.emplace_back(4, 5, 6);
vertices.emplace_back(4, 5, 6);

同时使用 reserve() 和 emplace_back()，再次运行代码，控制台不会打印任何 "Copied!"。

智能指针

Fri, 21 Apr 2023 00:00:00 GMT

智能指针

简介

智能指针可以自动管理内存，避免因忘记调用 delete 而造成的内存泄漏。

前置代码

本文示例基于以下头文件和 Entity 类：

#include<iostream>
#include<string>
#include<memory> // 引入智能指针

class Entity
{
public:
    Entity()
    {
        std::cout << "Created Entity!" << std::endl;
    }

    ~Entity()
    {
        std::cout << "Destroyed Entity!" << std::endl;
    }

    void Print() {}
};

unique_ptr

下面是 unique_ptr 的基本用法，花括号用于显式标记作用域：

... // 省略前面的代码
int main()
{
    {// 显式作用域开始
        
        std::unique_ptr<Entity> entity = std::make_unique<Entity>();

        entity->Print();
    }// entity 在此离开作用域，自动释放内存

    //main 结束
    std::cin.get();
}

unique_ptr 不能被拷贝，这也是其名称的含义。以下用法是非法的：

class Example
{
    ...//omit
};
...//omit
    std::unique_ptr<Example> uniq_ptr = std::make_unique<Example>();
    void* ptr
    ptr = uniq_ptr // 非法，unique_ptr 不可拷贝

尝试拷贝时编译器会报错。如需转移所有权，可使用移动语义（std::move）。

shared_ptr

shared_ptr 通过引用计数实现共享所有权：

每当一个新的 shared_ptr 共享同一对象，引用计数加一；
每当一个 shared_ptr 销毁，引用计数减一；
引用计数归零时，内存才会被释放。

int main()
{
    std::shared_ptr<Entity> entity;
    // entity 已声明，但尚未初始化
    {
        std::shared_ptr<Entity> shared_entity = std::make_shared<Entity>();

        entity = shared_entity; // entity 开始共同持有该对象

        entity->Print();
    }
    // shared_entity 在此离开作用域，但内存尚未释放，entity 仍持有
    // because ptr "entity" hold it's memory
}

weak_ptr

weak_ptr 可以看作一种特殊的 shared_ptr——它可以引用一个 shared_ptr 管理的对象，但不影响引用计数。

int main()
{
    std::weak_ptr<Entity> entity;
    // entity 已声明，但尚未初始化
    {
        std::shared_ptr<Entity> shared_entity = std::make_shared<Entity>();

        entity = shared_entity;

        shared_entity->Print();
    }
    // shared_entity 离开作用域，引用计数归零，内存释放
    // 可通过 weak_ptr 检查其指向的内存是否已被释放
}

当所有关联的 shared_ptr 都销毁后，weak_ptr 不再持有内存，但可以用 expired() 或 lock() 检查对象是否仍然存在。weak_ptr 的典型用途是打破循环引用。

总结

C++ 中的智能指针用于自动管理内存的分配与释放，防止内存泄漏和悬空指针。三种常用类型均以模板实现：

unique_ptr：独占所有权，不可拷贝，只能移动。适合单一指针管理一个对象的场景，离开作用域时自动销毁对象。
shared_ptr：共享所有权，多个指针可指向同一对象，通过引用计数追踪引用数量，计数归零时自动销毁对象。
weak_ptr：配合 shared_ptr 使用，提供非拥有性引用，不影响引用计数，常用于打破循环引用，并可检查对象是否已被销毁。

Python-字典

Sun, 22 Jan 2023 00:00:00 GMT

字典

字典是Python中唯一实现映射关系的内置类型

1. 解决单表代换密码问题

1.1 模拟字典方法

以下不是真正的字典，但可以实现类似的功能

通过两个列表对照实现

c_table = ["cipher1", "cipher2"...] # 密文表
d_table = ["plain1", "plain2"...] # 明文表
cipher = input("input your cipher") # 输入密文
split_cipher = cipher.split(" ") # 密文拆分
result = [d_table[c_table.index(each)] for each in split_cipher] # 通过查找密文下标找到对应下标明文来解密
print(result) # 打印结果

通过一个列表实现

table = ["cipher1", "plain1", "cipher2", "plain2" ...]
cipher = input(...) # 输入密文
split_cipher = cipher.split(" ") # 密文拆分
result = [table[table.index(each) + 1] for each in split_cipher] # 通过查找密文下标，得到其下一位，即对应的明文
print(result) # 打印结果

这两种方法在处理小量数据的时候和字典效率相差不大，但由于其数据结构本身不是映射关系，实际在处理大量数据时效率远不及字典

1.2 字典方法

table = {"cipher1":"plain1", "cipher2":"plain2", "cipher3":"plain3"...}
cipher = input("input your cipher")
split_cipher = cipher.split(" ")
result = [table[each] for each in split_cipher]
print(result)

2. 字典基础用法

Python中，字典内一对数据叫做一个键值对：dic = {"键":"值"}，一个键对应一个值

2.1 字典的6种一般声明方法

a = {"alpha":"a", "bravo":"b"...}
b = dict(alpha="a", bravo="b"...)
c = dict([("alpha", "a"), ("bravo", "b")...])
d = dict({"alpha":"a", "bravo":"b"...})
e = dict({"alpha":"a", "bravo":"b"...}, charlie="c"...)
f = dict(zip(["alpha", "bravo", "charlie"...], ["a", "b", "c"...]))
a == b == c == d == e == f # True # <class 'dict'>

2.2 fromkeys声明

fromkeys(iterable, value) 其中value是可选参数，默认为None

dic = dict.fromkeys("Momoyeyu", 0) # 键被看作集合，重复的o和y只会存一个
print(dic)

Output {'M': 0, 'o': 0, 'm': 0, 'y': 0, 'e': 0, 'u': 0}

2.3 修改字典

dic = dict.fromkeys("Momoyeyu", 0)
print(dic)
dic["M"] = 1 # 改
dic["New"] = 2 # 增
dic.pop("o") # 删 （pop的返回值是删除的值）
print(dic)

Output:
{'M': 0, 'o': 0, 'm': 0, 'y': 0, 'e': 0, 'u': 0}
{'M': 1, 'm': 0, 'y': 0, 'e': 0, 'u': 0, 'New': 2}

键被当作下标使用，这也解释了为什么键要被视为集合储存：具有无序性和唯一性
一个字典中没有两个相等的键，但不同的键可以关联同一个值，键重复了就用新的值覆盖旧的值

2.3.1 关于删除

dic.pop(key, default)
若pop的键key不存在dic中，pop会报错，但也可以通过可选参数default来设置报错内容

dic.popitem()
在 Python 3.7 以后的版本，字典的键值对才有储存顺序，popitem 会弹出最后一个加入字典 dic 的键值对
但在 Python 3.7 以前的版本，popitem 会随机弹出一个键值对

del关键词
通过 del dic['键'] 也可以删除一个键值对，也可以 del dic 直接删除字典，注意和 dic.clear() 区分

clear()
通过 dic.clear() 可以得到空字典，注意和 del dic 区分

3. 其他字典函数

函数	功能
dic.get(key, default=None)	查找key对应的value，不存在则返回None
dic.setdefault(key, value)	查找key的值，若key存在，返回key原本的value；若key不存在，则把键值对key:value添加到dic中
dic.keys()	返回dic的`键的视图对象`
dic.values()	返回dic的`值的视图对象`
dic.items()	返回dic的`字典视图对象`

3.1 关于视图对象

视图对象是字典的动态视图，字典改变的时候，其视图对象会随之改变

dic = dict.fromkeys("Momoyeyu", 0)
keys = dic.keys()
values = dic.values()
items = dic.items()
print(keys)
print(values)
print(items)
dic.pop('M')
print(items)

Output:
dict_keys(['M', 'o', 'm', 'y', 'e', 'u'])
dict_values([0, 0, 0, 0, 0, 0])
dict_items([('M', 0), ('o', 0), ('m', 0), ('y', 0), ('e', 0), ('u', 0)])
dict_items([('o', 0), ('m', 0), ('y', 0), ('e', 0), ('u', 0)])

4. 嵌套字典

a = {"Momoyeyu":{"Chinese":60, "Math":50, "English":40}}
b = {"Momoyeyu":[60, 50, 40]}
print(a["Momoyeyu"]["Math"], end=" ")
print(b["Momoyeyu"][1])

Output:
50 50

Python-分支和循环

Fri, 20 Jan 2023 00:00:00 GMT

参考资料：【Python教程】《零基础入门学习Python》最新版（2022年12月26日更新）

分支结构

1. if结构

if condition:
    statement_1(s1)
statement_2(s2)

2. if-else结构

if condition:
    statement_1(s1)
else:
    statement_2(s2)
statement_3(s3)

3. if-elif-elif...(-else)结构

if condition_1:
    statement_1(s1)
elif condition_2:
    statement_2(s2)
...
# else:
#     statement_n(sn)

4. oneline结构

true_statement if condition else false_statement

循环结构

1. while循环

1.1 基本结构

while condition:
    statement_1(s1)
statement_2(s2)

1.2 while-break结构

while condition_1:
    statement_1(s1)
    if condition_2:
        break
    statement_2(s2)
statement_3(s3)

1.3 while-else结构

while condition_1:
    statement_1(s1)
    if condition_2:
        break
    statement_2(s2)
else:
    statement_3(s3)
statement_4(s4)

仅在循环由condition_1退出时才执行else，由break终止则不执行else

1.4 嵌套结构

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(j, "*", i, "=", j*i, end=" ")
        j += 1
    print()
    i += 1

1 * 1 = 1 
1 * 2 = 2 2 * 2 = 4 
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9 
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36 
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81

2. for循环

2.1 基本结构

for identifier in iterable:
    statement_1(s1)
statement_2(s2)

sum = 0
for i in range(10):
    sum += i
print(sum)
# 45

2.2 range()函数

range(stop)
range(start, stop)
range(start, stop, step)

for n in range(2, 10):
    for m in range(2, n):
            if n % m == 0:
                print(n, "=", m, "*", n // m)
                break
    else:
        print(n, "is a prime number")

2 is a prime number
3 is a prime number
4 = 2 * 2
5 is a prime number
6 = 2 * 3
7 is a prime number
8 = 2 * 4
9 = 3 * 3

Python-序列

Fri, 20 Jan 2023 00:00:00 GMT

参考资料：【Python教程】《零基础入门学习Python》最新版（2022年12月26日更新）

序列

Python中，列表、元组和字符串都属于序列

1. 序列的基本运算

加法 +
乘法 *

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
d = a * 2
print(c)
print(d)

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3]

2. 序列的判定函数

2.1 关键词'is' & 'is not'

a = [1, 2, 3]
b = [1, 2, 3]
print("a == b?")
print("True") if a == b else print("False")
print("a is b?")
print("True") if a is b else print("False")

a == b?
True
a is b?
False

第一次判定的是'a'与'b'的元素值是否相等，而第二次判定的是'a'与'b'是否与同一组数据挂钩
放在C语言中，就好比'=='判断变量储存的数值是否相等，而'is'判断他们是否指向同一个内存地址
但是在Python中，我们一般认为变量名并不是储存了数据，而是与数据挂钩，同时一般Python也不常用指针的概念
这是因为Python对指针做了良好封装，一切都是“对象”，一切对象都有一个“变量”指向它。这个“变量”就是“指针”

而'is'和'is not'就是用来判断'a'和'b'是否指向了同一个对象，其本质和比较指针是一样的

2.2 id()

Return the identity of an object.

a = (1, 2, 3)
b = 1, 2, 3
print("True") if id(a) == id(b) else print("False")
c = [1, 2, 3]
d = [1, 2, 3]
print("True") if id(c) == id(d) else print("False")

True
False

id()相当于C语言中取地址符，它得到的相当于与变量名挂钩的数据的"身份证"，只要数据存在于内存中，这个值就唯一

2.3 关键词'in' & 'not in'

a = (1, 2, 3)
b = 1, 2, 3
print("1 in a?")
print("True") if 1 in a else print("False")
print("a not in b?")
print("True") if a not in b else print("False")

1 in a?
True
a not in b?
True

3. 关键词'del'

作用：删除

x = [1, 2, 3, 4, 5]
print(x)
del x[0]
print(x)
del x[:2]
print(x)
del x[:]
print(x)
del x
print(x)

[1, 2, 3, 4, 5]
[2, 3, 4, 5]
[4, 5]
[]
Traceback (most recent call last):
  File "D:\PycharmProjects\test\main.py", line 10, in <module>
    print(x)
NameError: name 'x' is not defined

4. 序列基本函数

4.1 list() & tuple() & str()

list(iterable)
tuple(iterable)
str(object) # str(object='') -> str

print(list("Momoyeyu"))
print(tuple("Momoyeyu"))
print(str("Momoyeyu"))
print(str(list("Momoyeyu")))

['M', 'o', 'm', 'o', 'y', 'e', 'y', 'u']
('M', 'o', 'm', 'o', 'y', 'e', 'y', 'u')
Momoyeyu
['M', 'o', 'm', 'o', 'y', 'e', 'y', 'u']

4.2 max() & min()

max(iterable, *[, default=obj, key=func]) min(iterable, *[, default=obj, key=func]) 注：可选参数default默认是报错，可以设置内容

print(max([1, 2, 3, 4, 5]))
print(min("Momoyeyu"))
print(min([], default = "Empty!"))

5
M
Empty!

4.3 len() & sum()

len(obj) sum(iterable, /, start=0) 注：可选参数start默认是0，可以设置起始值

print(len(range(2 ** 10)))
print(sum([1, 2, 3, 4, 5], start=10))

1024
25

4.4 sorted() & reversed()

sorted(iterable, /, *, key=None, reverse=False)
reversed(sequence) # Return a reverse iterator over the values of the given sequence.

print(sorted([3, 1, 4, 2]))
print(sorted(["Momoyeyu", "Gger", "Guitar"], key=len, reverse=True))
print(reversed([1, 0, 0, 8, 6]))
print(list(reversed([1, 0, 0, 8, 6])))

[1, 2, 3, 4]
['Momoyeyu', 'Guitar', 'Gger']
<list_reverseiterator object at 0x000002891CDAFE20>
[6, 8, 0, 0, 1]

由输出第3行我们注意到，reversed()返回的不是一个列表，根据Python官方文档说明，reversed()返回的是一个迭代器

4.5 all() & any()

all(iterable) any(iterable)

print(all([1, 1, 0]))
print(any([0, 0, 1]))

False
True

5. 关于迭代器-iterator

5.1 enumerate()

enumerate(iterable, start=0) # 返回一个枚举对象
注：可选参数start可以设置起始序号

Kisetsu = ["Haru", "Natsu", "Aki", "Huyu"]
print(enumerate(Kisetsu))
print(list(enumerate(Kisetsu)))
print(list(enumerate(Kisetsu, 10)))

<enumerate object at 0x0000014117E308C0>
[(0, 'Haru'), (1, 'Natsu'), (2, 'Aki'), (3, 'Huyu')]
[(10, 'Haru'), (11, 'Natsu'), (12, 'Aki'), (13, 'Huyu')]

5.2 zip()

zip(*iterables, strict=False) # Return an iterator

x, y = [1, 2, 3], [4, 5, 6]
z = zip(x, y)
print(z)
print(list(z))

<zip object at 0x0000022F43B43040>
[(1, 4), (2, 5), (3, 6)]

5.3 itertools.zip_longest()

print(list(zip([1, 2, 3], "Momoyeyu")))
import itertools
print(list(itertools.zip_longest([1, 2, 3], "Momoyeyu")))

[(1, 'M'), (2, 'o'), (3, 'm')]
[(1, 'M'), (2, 'o'), (3, 'm'), (None, 'o'), (None, 'y'), (None, 'e'), (None, 'y'), (None, 'u')]

zip()默认进行的是截短运算，但可以从itertools中引用itertools.zip_longest()来进行保长运算

5.4 map() & filter()

map(func, *iterables)
注：func指的是一套运算规则，map()会将*iterables中的对象都按照func进行计算然后返回其结果组成的iterator

print(list(map(ord, "Momoyeyu")))
print(list(map(pow, [2, 2, 2], [8, 9, 10, 11])))

[77, 111, 109, 111, 121, 101, 121, 117]
[256, 512, 1024]

由输出第二行可以看出，对于数据长度不同时，map()与zip()相同，选择了截短运算

filter(function or None, iterable) 注：和map()类似，但只将结果为True的元素返回到iterator

print(list(filter(str.islower, "G-ger")))

['g', 'e', 'r']

6. 迭代器和可迭代对象-iterator & iterable

iterator是一次性的，而iterable可以重复使用

可参考迭代器和可迭代对象

6.1 iterator

x = [1, 2, 3, 4, 5]
y = iter(x)
print(type(x))
print(type(y))
i = 0
while i < len(x):
    i+=1
    print(next(y, "Empty"), end=" ")
print(next(y, "Empty"))

<class 'list'>
<class 'list_iterator'>
1 2 3 4 5 Empty

next()函数可以让iterator进行一次迭代，迭代到尽头之后就会报错，可以设置报错内容

6.2 iterable

可迭代对象可以理解为可以重复使用的迭代器
iterable可以进行迭代，迭代完成后，它又可以被引用，从头进行迭代，因为它的数据还被完整保留着
而iterator迭代完成之后，迭代器里的数据就被释放完了，不可再次使用

一个迭代器肯定是一个可迭代对象

6.3 iterator与iterable比较

根据应用场景不同，他们有各自的优劣： iterator: 不会占用太多资源储存数据，他只会由现在的数据迭代计算下一个数据，但这个过程往往是不可逆的，迭代后上一个数据就抛弃了 iterable: 可以重复使用，迭代后之前的数据也得到保存，但比较占用资源

Python-字符串

Thu, 19 Jan 2023 00:00:00 GMT

参考资料：【Python教程】《零基础入门学习Python》最新版（2022年12月26日更新）

字符串

关于字符串，主要分为两大块知识：一块是各种字符串相关函数，另一块是format字符串和f-string

1. 字母大小写转换

函数	功能
str.capitalize()	首字母大写，其余小写
str.casefold()	字母全变为小写，可以支持多种语言
str.title()	每个单词首字母都大写，其余小写
str.swapcase()	字母大小写全部和原来相反
str.upper()	字母全变为大写，英语之外可能不支持
str.lower()	字母全变为小写

注意：这些函数都没有直接改变str指向的字符串，而是按规则生成了一个新的字符串，即str还是与原本的字符串挂钩因此要改变str时：str = str.function()

2. 对齐函数

函数	功能
str.center(width, fillchar=' ')	width设置总字符数，fillchar设置填充字符，使str`居中`
str.ljust(width, fillchar=' ')	width设置总字符数，fillchar设置填充字符，使str`左对齐`
str.rjust(width, fillchar=' ')	width设置总字符数，fillchar设置填充字符，使str`右对齐`
str.zfill(width)	width设置总字符数，str左侧用0填充，若str是数字字符串，可以支持正负数

3. 查找函数

函数	功能
str.count(char, start, end)	返回str在所选范围char的`个数`，起止位置为可选参数
str.find(char, start, end)	返回str在所选范围`从左往右`第一个为char的`下标`，找不到则返回-1，起止位置为可选参数
str.rfind(char, start, end)	返回str在所选范围`从右往左`第一个为char的`下标`，找不到则返回-1，起止位置为可选参数
str.index()	返回str在所选范围`从左往右`第一个为char的`下标`，找不到则报错，起止位置为可选参数
str.rindex()	返回str在所选范围`从右往左`第一个为char的`下标`，找不到则报错，起止位置为可选参数

4. 转换函数

函数	功能
str.expandtabs(num)	将str中所有Tab转换为num个空格
str.replace(old, new, count=-1)	将str中old转换为new，可选参数count设置转换个数，默认-1表示全部转换
str.translate(table)	table表示一个转换规则，可由maketrans()生成，可以实现table中对应字符的转换
str.maketrans(origin, trans, ignorestr)	生成一个转换规则，表示将origin中的对象转换为trans中对应的对象，与ignorestr相同的字符串不会被转换

5. 判断函数

这类函数会根据判断的结果返回bool类型数值

函数	功能
str.startswith(prefix, start, end)	判断是否以prefix开头，prefix可以为元组，元组中任意一个元素满足即可，起始位置为可选参数
str.endswith(suffix, start, end)	判断是否以suffix结尾，suffix可以为元组，元组中任意一个元素满足即可，起始位置为可选参数
str.isupper()	判断是否全为大写
str.islower()	判断是否全为小写
str.istitle()	判断str是否为标题格式
str.isalpha()	判断是否全为字母
str.isascii()	判断是否都为ascii
str.isspace()	判断是否都为空白字符(空格、Tab、换行符等)
str.isprintable()	判断是否都可以打印
str.isdecimal()	判断是否数字的一个标准（范围最小）
str.isdigit()	判断是否数字的一个标准（范围适中）
str.isnumeric()	判断是否数字的一个标准（范围最大）
str.isalnum()	判断是否全为字母或数字
str.isidentifier()	判断str是否为Python的合法标识符

5.1 prefix/suffix为元组的例子

if "她爱Python".startswith(("我", "你", "她")):
    print("总有人爱Python")
# "总有人爱Python"

5.2 isdecimal() & isdigit() & isnumeric() 区别

x = "123"
# All: True
x = "2²"
# x.isdecimal(): False
# x.isdigit() & x.isnumeric(): True
x = "一二三"
# x.isdecimal() & x.isdigit(): False
# x.isnumeric(): True
x = "我不是数字"
# All: False

6. 截取函数

函数	功能
str.strip(chars=None)	从左右两侧删除选定字符，直到遇到第一个非选定字符时停止；默认None表示空白字符，chars是字符串，`会被视为集合`
str.lstrip(chars=None)	从左侧删除选定字符，直到遇到第一个非选定字符时停止；默认None表示空白字符，chars是字符串，`会被视为集合`
str.rstrip(chars=None)	从右侧删除选定字符，直到遇到第一个非选定字符时停止；默认None表示空白字符，chars是字符串，`会被视为集合`
str.removeprefix(prefix)	去除前缀prefix
str.removesuffix(suffix)	去除后缀suffix

7. 拆分与拼接

函数	功能
str.partition(char)	`从左往右`找到第一个为char的字符，以此为结点拆分得到一个三元组
str.rpartition(char)	`从右往左`找到第一个为char的字符，以此为结点拆分得到一个三元组
str.split(sep=None, maxsplit=-1)	将str拆分为多个字符串并返回其组成的列表；sep设置拆分字符，默认为空白字符；maxsplit设置最大分割数，默认-1表示全部拆分
str.rsplit(sep=None, maxsplit=-1)	从右往左开始拆分，功能与split()相同
str.splitlines(save=False)	以换行符为拆分字符将str拆分，可识别`不同系统的换行符`；可选参数save控制是否保留换行符到其前面的子串
str.join(iterable)	以str为结点连接iterable中各个元素，str可为空字符串

7.1 不同系统的换行符

Unix, Linux: \n Max OS: \r Windows: \r\n

7.2 join() 比 + 的优势在于 join() 的处理效率远高于 +

8. format字符串

8.1 基础用法

问题来源：

year = 2023
month = 1
print("现在是 year 年 month 月")
# 现在是 year 年 month 月

类似于 C/C++ 中的转义字符，Python 的字符串也需要类似转义字符的存在

year = 2023
print("现在是 {} 年 {} 月".format(year, month))
# 现在是 2023 年 1 月

{}中可以通过写下标选择format()中的数据，且可以重复使用

print("{}爱{}".format("我", "你"))
# 我爱你
print("{1}爱{0}".format("我", "你"))
# 你爱我
print("{0}{0}{1}{2}".format("mo", "ye", "yu"))
# momoyeyu
print('{2},{1},{0}'.format(*'abc'))
# c,b,a

还可以使用关键字参数

print("我是{name}，我喜欢{fav}".format(name = "墨末夜羽", fav = "吉他"))
# 我是墨末夜羽，我喜欢吉他
print("我是{fav}，我喜欢{name}".format(name = "墨末夜羽", fav = "吉他"))
# 我是吉他，我喜欢墨末夜羽

8.2 语法格式

format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type] fill ::= <any character> # 填充字符 align ::= "<" | ">" | "=" | "^" # 填充位置 sign ::= "+" | "-" | " " # 显示符号 width ::= integer # 打印宽度 precision ::= integer # 浮点数精度 type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%" # 数据表达方式

8.2.1 示例

"{1:^10}{0:<10}".format("123", "456")
# '   456    123       ' # 居；左对齐
"{:08}{:08}".format(1024,-1024)
# '00001024-0001024' # 填充0；0不影响符号
"{a:*>10}|{b:*<10}".format(a=120,b=110)
# '*******120|110*******' # 选择*为填充字符
"{:+,}||{:-_}".format(1234567,7654321)
# '+1,234,567||7_654_321' # 正数显示正号，每3位用（，）分开；负数显示负号（默认就显示），每3位用（_）分开
"{:.2f}||{:.3g}".format(12.3456,12.345)
# '12.35||12.3' # 小数点后保留2位数；总共保留3位数
"{:.4}".format("Momoyeyu")
# "Momo" # 保留前4个字符（对数字不可用）
"{0:d}||{0:c}||{0:b}||{0:o}||{0:x}||{0:#b}||{0:#o}||{0:#x}||{0:e}".format(127)
# '127||\x7f||1111111||177||7f||0b1111111||0o177||0x7f||1.270000e+02' # 详情看下表

8.2.2 关于type

值	含义
b	以二进制输出
#b	b的基础上，会在数前标0b，表示这是二进制数
c	以Unicode输出
d	以十进制输出
o	以八进制输出
#o	o的基础上，会在数前标0o，表示这是八进制数
x	以十六进制输出
#x	x的基础上，会在数前标0x，表示这是十六进制数
X	以十六进制输出
#X	X的基础上，后者会在数前标0X，表示这是十六进制数
n	类似于'd'，但会根据语言环境的分隔符插入到恰当位置
None	什么都不填，则对整数默认是'd'，对小数默认精度与所给值一样
e	以科学计数法输出，默认精度6位
E	以科学计数法输出，默认精度6位
f	以定点表示法输出，默认精度6位（非数用'nan'标示，无穷用'inf'标示）
F	以定点表示法输出，默认精度6位（非数用'NAN'标示，无穷用'INF'标示）
g	通用格式，小数以'f'输出，大数以'e'输出
G	通用格式，小数以'F'输出，大数以'E'输出
%	以百分比形式输出，默认精度同f，可通过'.num%'设置精度（num为一个数）

8.2.3 format字符串综合运用

"{:{fill}{align}{width}.{prec}{typ}}".format(3.1415, fill='+', align='^', width=10, prec=3, typ='g')
# '+++3.14+++'

9. f-string

也叫f字符串，字符串前加'f'或'F'，其中{}内的变量名可以引用，算式可以计算，内容也可以格式化输出

9.1 示例

year = 2023
f"现在是 {year} 年"
# '现在是 2023 年'
F"1+2={1+2}, 2²={2*2}"
# '1+2=3, 2²=4'
f"{-110:0=10}||{3.1415:.2f}"
# '-000000110||3.14'

9.2 f-string综合运用

fill, align, width, prec, typ = '+', '^', 10, 3, 'g'
f"{3.1415:{fill}{align}{width}.{prec}{typ}}"
# '+++3.14+++'

f-string的效率比format字符串效率要高，但由于其是Python3.6才产生，考虑到兼容性，format字符串使用会更多

Python-列表与元组

Tue, 17 Jan 2023 00:00:00 GMT

参考资料：【Python教程】《零基础入门学习Python》最新版（2022年12月26日更新）

列表

1. 创建列表

mlist = [1, 2, 3, 4, 5, 6]
_ = []

2. 访问列表

print(mlist[0], end=" ")
print(mlist[-1])
# 1 6

for each in mlist:
	print(each, end=" ")
# 1 2 3 4 5 6

3. 修改列表

3.1 通过下标索引修改

mlist = [1, 1, 3, 4, 5]
mlist[1] = 2

结果：mlist = [1, 2, 3, 4, 5]

3.2 通过切片修改

mlist[3:] = [2, 1]

结果：mlist = [1, 2, 3, 2, 1]

3.3 通过运算符修改

_1 = [1, 2]
_2 = [3, 4]
_ = _1 + _2
# _ = [1, 2, 3, 4]

4. 切片

4.1 切片访问列表

mlist = [1, 2, 3, 4, 5, 6]
mlist[2:4]
# [3, 4]
mlist[:3]
# [1, 2, 3]
mlist[2:]
# [3, 4, 5, 6]
mlist[:]
# [1, 2, 3, 4, 5, 6]
mlist[0:6:2]
# [1, 3, 5]
mlist[::-1]
# [6, 5, 4, 3, 2, 1]

切片访问语法：列表名[起始下标:停止下标:检索跨度]

注意：切片访问返回的是一个可迭代对象，所以切片可以实现浅拷贝

mlist_copy = mlist[:]

4.2 切片修改列表

mlist = [1, 2, 3, 4, 5, 6]
mlist[len(mlist):] = [7]
# mlist = [1, 2, 3, 4, 5, 6, 7]
mlist[len(mlist):] = [8, 9]
# mlist = [1, 2, 3, 4, 5, 6, 7, 8, 9]

5. 函数

函数	功能
mlist.append(an element)	将`一个元素`追加到列表mlist末尾
mlist.extend(iterable)	将`迭代结果`逐个追加到列表mlist末尾
mlist.insert(an index, an element)	将该元素`插入`到列表mlist的指定下标位置
mlist.remove(an element)	将该元素从列表mlist中`删除`，若元素不在列表内，则会报错
mlist.pop(an index)	将该下标对应元素从列表中`弹出`
mlist.clear()	将列表mlist变为`空列表`
mlist.sort(key=None, reverse=False)	将列表mlist`排序`，参数reverse控制是否`倒序`
mlist.reverse()	将列表`倒序`排列
mlist.count(an element)	返回这个元素在列表中的`个数`
mlist.index(an element, start index, end index)	返回这个元素的`下标`，若有多个则返回第一个
mlist.copy()	返回原列表的`浅拷贝`
len(mlist)	返回值等于列表mlist的`长度`

6. 嵌套列表

初始化

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix = [[1, 2, 3], 
          [4, 5, 6],
          [7, 8, 9]]
A = [0] * 3
for i in range(3):
    A[i] = [0] * 3

注：不要这样声明嵌套列表：B = [[0] * 3] * 3

这样声明的列表其实是对同一个[0, 0, 0]引用三次

即假设 B[0][0] = 1，则B = [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

B[0] is B[1]
# True

访问

matrix[0]
# [1， 2， 3]
matrix[0][0]
# 1
for i in matrix:
    for j in i:
        print(j, end=" ")# 空格结尾
    print() # 换行
# 1 2 3
# 4 5 6
# 7 8 9

7. 列表名与列表

x = [1, 2, 3]
y = x
x is y
# True 说明x与y表示同一个列表

注：Python中，变量名并不是一个盒子，数据并非储存在变量中，而是变量名与数据挂钩，列表名能够引用其指向的数据

8. 列表拷贝

在Python中，拷贝可以分为浅拷贝和深拷贝

在嵌套结构中，对其中所嵌套元素，浅拷贝仅拷贝其引用，而深拷贝会将嵌套元素也拷贝

mlist = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
import copy # 深拷贝所在库
mlist_copy1 = mlist # 引用赋值（非拷贝，mlist_copy1 与 mlist 指向同一对象）
mlist_copy2 = copy.copy(mlist) # 浅拷贝
mlist_copy3 = copy.deepcopy(mlist) # 深拷贝

9. 列表推导式

语法：

基本形式：_ = [expression for target in iterable]

筛选形式：_ = [expression for target in iterable if condition]

完整形式：

_ = [expression for target1 in iterable1 if condition1  
                for target2 in iterable2 if condition2  
                                 ...  
                for target3 in iterable3 if condition3]

等价于：

_ = []
for target1 in iterable1:
    if condition1:
        for target2 in iterable2:
            if condition2:
                ...
                    _ = expression

示例 1.

mlist = [1, 2, 3, 4, 5]
mlist = [i * 2 for i in mlist]
# mlist = [2, 4, 6, 8, 10]

mlist = [char * 2 for char in "Momoyeyu"]
# mlist = ['MM', 'oo', 'mm', 'oo', 'yy', 'ee', 'yy', 'uu']

matrix = [[1, 2, 3], 
          [4, 5, 6],
          [7, 8, 9]]
diag = [matrix[i][i] for i in range(len(matrix))]
# diag = [1, 5, 9]

matrix = [[1, 2, 3], 
          [4, 5, 6],
          [7, 8, 9]]
flatten = [col for row in matrix for col in row]
# flatten = [1, 2, 3, 4, 5, 6, 7, 8, 9]

等价于：

flatten = []
for row in matrix:
    for col in row:
        flatten.append(col)

_ = [[x, y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
# _ = [[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

等价于：

_ = []
for x in range(10):
    if x % 2 == 0:
        for y in range(10):
            if y % 3 == 0:
                _.append([x, y])

元组

许多部分与列表相似，因此不多赘述，没有提到的部分基本都可以参考列表进行操作

1. 创建与访问元组

创建：

_1 = (1, 2, 3, 4, 5)
_2 = 1, 2, 3, 4, 5
_1 == _2 # True
_1 is _2 # False

注：建立元组可以省略小括号，但一定需要加逗号

x = 1
type(x) # <class 'int'>
y = 1,
type(y) # <class 'tuple'>

访问：与访问列表基本一致

2. 元组的修改

元组不可修改，指的是元组中每个元素的指向永远不变，但元素指向的数据可以发生改变

_ = (1, 2, 3 , 4, 5)
_[0] = 0
# Traceback (most recent call last):
#   File "<pyshell#9>", line 1, in <module>
#     _[0] = 0
# TypeError: 'tuple' object does not support item assignment

_ = (1, 2, 3, 4, [1, 2, 3])
_[4].append(4)
# _ = (1, 2, 3, 4, [1, 2, 3, 4])

3. 解包操作

列表，元组，字符串都可以使用解包操作

t = (1, 2, 3)
x, y, z = t
# x = 1; y = 2; z = 3

x, y, z = "Momoyeyu"
# Error 左侧变量名和右侧元素数量不等
x, y, *z = "Momoyeyu"
# x = M; y = o; z = "moyeyu"

Python的多重赋值本质就是先将值包装为元组，再解包与各个变量名挂钩

x, y = 1, 2

等价于：

_ = (1, 2)
x, y = _

夜羽的小作坊

CMake 入门

从手动编译开始

最小 CMake 项目

逐行解释 CMakeLists.txt

配置、构建、运行

-S 和 -B

-G Ninja

CMake 和 Makefile 的关系

Debug 和 Release

多个源码文件

拆成库

记住这条主线

Python for Machine Learning

Python for Machine Learning

前言

1. 基础语法

2. 数据结构

3. 常用库和模块

4. 文件读写

5. ML/DL 相关函数和库

6. 异常处理和调试

7. 包管理

小结

C++ Vector 详解

Vector

简介

基本用法

性能优化

减少拷贝

避免扩容引发的拷贝

避免构造时的额外拷贝

智能指针

智能指针

简介

前置代码

unique_ptr

shared_ptr

weak_ptr

总结

Python-字典

字典

1. 解决单表代换密码问题

1.1 模拟字典方法

1.2 字典方法

2. 字典基础用法

2.1 字典的6种一般声明方法

2.2 fromkeys声明

2.3 修改字典

3. 其他字典函数

3.1 关于视图对象

4. 嵌套字典

Python-分支和循环

分支结构

1. if结构

2. if-else结构

3. if-elif-elif...(-else)结构

4. oneline结构

循环结构

1. while循环

1.1 基本结构

1.2 while-break结构

1.3 while-else结构

1.4 嵌套结构

2. for循环

2.1 基本结构

2.2 range()函数

Python-序列

序列

1. 序列的基本运算

2. 序列的判定函数

2.1 关键词'is' & 'is not'

2.2 id()

2.3 关键词'in' & 'not in'

3. 关键词'del'

4. 序列基本函数

4.1 list() & tuple() & str()

4.2 max() & min()

4.3 len() & sum()

4.4 sorted() & reversed()

`-S` 和 `-B`

`-G Ninja`