基础

1
2
3
4
5
6
7

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

abstract   continue   for          new         switch
assert     default    if           package     synchronized
boolean    do         goto         private     this
break      double     implements   protected   throw
byte       else       import       public      throws
case       enum       instanceof   return      transient
catch      extends    int          short       try
char       final      interface    static      void
class      finally    long         strictfp    volatile
const      float      native       super       while
_ (underscore)

1
2
3
4

exports      opens      requires     uses   yield
module       permits    sealed       var         
non-sealed   provides   to           when        
open         record     transitive   with    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

__halt_compiler()	abstract	and	array()	as
break	callable	case	catch	class
clone	const	continue	declare	default
die()	do	echo	else	elseif
empty()	enddeclare	endfor	endforeach	endif
endswitch	endwhile	eval()	exit()	extends
final	finally	fn (as of PHP 7.4)	for	foreach
function	global	goto	if	implements
include	include_once	instanceof	insteadof	interface
isset()	list()	match (as of PHP 8.0)	namespace	new
or	print	private	protected	public
readonly (as of PHP 8.1.0) *	require	require_once	return	static
switch	throw	trait	try	unset()
use	var	while	xor	yield
yield from

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

python  -m pip install --upgrade pip

# 以下是示例
PS C:\Windows\System32> pip -V
pip 24.3.1 from D:\tools\Python312\Lib\site-packages\pip (python 3.12)
PS C:\Windows\System32> python -m pip install --upgrade pip
Looking in indexes: https://mirrors.aliyun.com/pypi/simple/
Requirement already satisfied: pip in d:\tools\python312\lib\site-packages (24.3.1)
Collecting pip
  Downloading https://mirrors.aliyun.com/pypi/packages/c9/bc/b7db44f5f39f9d0494071bddae6880eb645970366d0a200022a1a93d57f5/pip-25.0.1-py3-none-any.whl (1.8 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.8/1.8 MB 11.2 MB/s eta 0:00:00
Installing collected packages: pip
  Attempting uninstall: pip
    Found existing installation: pip 24.3.1
    Uninstalling pip-24.3.1:
      Successfully uninstalled pip-24.3.1
Successfully installed pip-25.0.1
PS C:\Windows\System32>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 查看 numpy的可用版本（仅限 pip 23.0+）
PS D:\Docs\hugos\go_docs> pip index versions numpy
WARNING: pip index is currently an experimental command. It may be removed/changed in a future release without prior warning.
numpy (2.2.2)
Available versions: 2.2.2, 2.2.1, 2.2.0, 2.1.3, 2.1.2, 2.1.1, 2.1.0, 2.0.2, 2.0.1, 2.0.0, 1.26.4, 1.26.3, 1.26.2, 1.26.1, 1.26.0, 1.25.2, 1.25.1, 1.25.0, 1.24.4, 1.24.3, 1.24.2, 1.24.1, 1.24.0, 1.23.5, 1.23.4, 1.23.3, 1.23.2, 1.23.1, 1.23.0, 1.22.4, 1.22.3, 1.22.2, 1.22.1, 1.22.0, 1.21.1, 1.21.0, 1.20.3, 1.20.2, 1.20.1, 1.20.0, 1.19.5, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19.0, 1.18.5, 1.18.4, 1.18.3, 1.18.2, 1.18.1, 1.18.0, 1.17.5, 1.17.4, 1.17.3, 1.17.2, 1.17.1, 1.17.0, 1.16.6, 1.16.5, 1.16.4, 1.16.3, 1.16.2, 1.16.1, 1.16.0, 1.15.4, 1.15.3, 1.15.2, 1.15.1, 1.15.0, 1.14.6, 1.14.5, 1.14.4, 1.14.3, 1.14.2, 1.14.1, 1.14.0, 1.13.3, 1.13.1, 1.13.0, 1.12.1, 1.12.0, 1.11.3, 1.11.2, 1.11.1, 1.11.0, 1.10.4, 1.10.2, 1.10.1, 1.10.0.post2, 1.9.3, 1.9.2, 1.9.1, 1.9.0, 1.8.2, 1.8.1, 1.8.0, 1.7.2, 1.7.1, 1.7.0, 1.6.2, 1.6.1, 1.6.0, 1.5.1, 1.5.0, 1.4.1, 1.3.0
  INSTALLED: 2.2.2
  LATEST:    2.2.2
  
  
  # 也可以通过如下方式，获取numpy的最新可用版本（不实际安装）
PS D:\Docs\hugos\go_docs> pip install --upgrade numpy --dry-run
Looking in indexes: https://mirrors.aliyun.com/pypi/simple/
Collecting numpy
  Downloading https://mirrors.aliyun.com/pypi/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl (12.6 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 12.6/12.6 MB 31.6 MB/s eta 0:00:00
Would install numpy-2.2.2
  
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 安装最新版本的 requests
pip install requests

# 安装指定版本的 numpy
pip install numpy==1.21.0

# 安装本地 .whl 文件
pip install ./downloads/pandas-2.0.3-cp39-cp39-win_amd64.whl

#.whl 文件名需符合 PEP 427 的命名规范，格式为：
# {包名}-{版本}-{Python标签}-{ABI标签}-{平台标签}.whl
# 例如：pandas-2.0.3-cp39-cp39-win_amd64.whl
# Python 标签：cp39 表示适用于 Python 3.9 的 CPython 解释器。
# ABI 标签：cp39 表示与 Python 3.9 ABI 兼容。
# 平台标签：win_amd64 表示 Windows 64 位 系统。
# .whl 文件本质是一个 ZIP 压缩包，

1
2

# 安装 GitHub 上的开发版库
pip install git+https://github.com/user/repo.git@branch

1
2
3
4
5

# 使用清华镜像源安装
pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple

# 信任 HTTP 镜像源（如阿里云旧版）
pip install flask -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com

1
2
3
4
5

pip install -r requirements.txt
# 每行包含一个包名，可以指定版本号，也可以不指定。
# 可以使用 ==、>=、<=、>、< 等符号来指定版本范围。
# 可以使用 -e . 来安装本地项目。
# 可以使用 # 来添加注释，注释内容会被忽略。

1
2
3
4
5

# 升级 requests 到最新版
pip install --upgrade requests

# 简写形式
pip install -U requests

1
2

#  卸载 pandsa
pip uninstall pandas

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 导出当前环境所有依赖
pip freeze > requirements.txt

# 仅导出项目直接依赖（需配合 pip-tools）
pip install pip-tools
# Compiles requirements.txt from requirements.in, pyproject.toml, setup.cfg,  or setup.py specs.
# 注意不用使用 > requirements.txt，来重定向到requirements.txt
pip-compile requirements.in
# pip-compile 是 pip-tools 工具集提供的命令，安装 pip-tools 后才能使用。
# requirements.in（该文件必须存在）是一个手动维护的输入文件，仅包含项目的直接依赖（即你显式安装的包）

# 修改requirements.in文件后，重新生成新的requirements.txt
# 注意不用使用 > requirements.txt，来重定向到requirements.txt
pip-compile --upgrade requirements.in

1
2
3
4
5

# 列出所有包
pip list

# 列出过期的包
pip list --outdated

1
2
3
4
5

# 列出所有包
pip list

# 列出过期的包
pip list --outdated

1
2

# 永久配置清华镜像（Linux/macOS）
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

1

pip config list

1
2

# 本地开发时直接链接代码（无需重复安装）
pip install -e ./my_package

1
2

# 避免使用旧缓存文件
pip install --no-cache-dir torch

1
2

# 设置超时为 60 秒
pip install --timeout 60 scipy

1
2
3
4
5

use my_module::my_function;

fn main() {
    my_function();
}

1

cargo new my_package

1
2
3
4

my_package/
├── Cargo.toml
└── src/
    └── main.rs

1
2

[dependencies]
serde = "1.0"

1
2
3

# 文件名：math_utils.py
def add(a, b):
    return a + b

1
2
3

# 文件名：main.py
from math_utils import add
print(add(1, 2))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 使用:=的示例
# 常规写法
line = input()
if line:
    print(f"你输入了: {line}")

# 海象运算符写法
if line := input():
    print(f"你输入了: {line}")

# 列表推导式中的应用
numbers = [n**2 for n in [1, 2, 3, 4, 5] if (result := n**2) > 10]
print(numbers)  # 输出: [16, 25]
print(result)  # 输出:25 (最后一个满足条件的值)


# 使用@的示例
import numpy as np

matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])

result = matrix1 @ matrix2
print(result)
# 输出:
# [[19 22]
#  [43 50]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 内置类型
b = True  # 布尔型
i = 10  # 整型
f = 3.14  # 浮点型
c = 1 + 2j  # 复数型
s = "hello"  # 字符串型
by = b"hello"  # 字节型
l = [1, 2, 3]  # 列表
t = (1, 2, 3)  # 元组
s1 = {1, 2, 3}  # 集合
d = {"a": 1, "b": 2}  # 字典
by_arr = bytearray(b"hello")  # 字节数组

print(b, i, f, c, s, by, l, t, s1, d, by_arr)
# True 10 3.14 (1+2j) hello b'hello' [1, 2, 3] (1, 2, 3) {1, 2, 3} {'a': 1, 'b': 2} bytearray(b'hello')

# 自定义类型
class MyClass:  # 类
    pass

my_object = MyClass()

print(my_object)
# <__main__.MyClass object at 0x...>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public class Main {
    public static void main(String[] args) {
        // 内置类型（原始类型）
        boolean b = true; // 布尔型
        byte by = 10; // 字节型
        short s = 20; // 短整型
        int i = 30; // 整型
        long l = 40L; // 长整型
        float f = 3.14f; // 单精度浮点型
        double d = 3.14159; // 双精度浮点型
        char c = 'a'; // 字符型

        System.out.println(b + " " + by + " " + s + " " + i + " " + l + " " + f + " " + d + " " + c);
        // true 10 20 30 40 3.14 3.14159 a

        // 复合类型（引用类型）
        int[] arr = {1, 2, 3}; // 数组
        class MyClass { // 类
            String name;
        }
        MyClass myObj = new MyClass();
        myObj.name = "Alice";
        interface MyInterface { // 接口
            void myMethod();
        }
        enum MyEnum { // 枚举
            A, B, C
        }

        System.out.println(arr[0] + " " + myObj.name + " " + MyEnum.A);
        // 1 Alice A

        // 自定义类型
        class MyOtherClass { // 类
            int value;
        }

        MyOtherClass myOtherObj = new MyOtherClass();
        myOtherObj.value = 100;

        System.out.println(myOtherObj.value);
        // 100
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

fn main() {
    // 内置类型
    let b: bool = true; // 布尔型
    let i: i32 = 10; // 整型
    let i8: i8 = 8; // 8位整型
    let i16: i16 = 16; // 16位整型
    let i32: i32 = 32; // 32位整型
    let i64: i64 = 64; // 64位整型
    let isize: isize = 123; // 根据平台大小而定的整型
    let u8: u8 = 8; // 8位无符号整型
    let u16: u16 = 16; // 16位无符号整型
    let u32: u32 = 32; // 32位无符号整型
    let u64: u64 = 64; // 64位无符号整型
    let usize: usize = 123; // 根据平台大小而定的无符号整型
    let f: f32 = 3.14; // 浮点型
    let f64: f64 = 3.1415926; // 双精度浮点型
    let c: char = 'a'; // 字符型
    let s: &str = "hello"; // 字符串切片
    let string: String = String::from("world"); // 字符串

    println!("{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", b, i, i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, f, f64, c, s, string);
    // true 10 8 16 32 64 123 8 16 32 64 123 3.14 3.1415926 a hello world

    // 复合类型
    let arr: [i32; 3] = [1, 2, 3]; // 数组
    let slice: &[i32] = &arr[..]; // 切片
    let tuple: (i32, &str) = (1, "hello"); // 元组
    struct MyStruct { // 结构体
        name: String,
    }
    let my_struct: MyStruct = MyStruct { name: String::from("Alice") };
    enum MyEnum { // 枚举
        A,
        B,
    }
    let my_enum: MyEnum = MyEnum::A;
    let ptr: *const i32 = &i; // const指针
    let mut mutable_i: i32 = 20;
    let mutable_ptr: *mut i32 = &mut mutable_i;// 可变指针
    type MyType = i32; // 类型别名

    println!("{:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}", arr, slice, tuple, my_struct, my_enum, ptr, mutable_ptr, MyType::default());
    // [1, 2, 3] [1, 2, 3] (1, "hello") MyStruct { name: "Alice" } A 0x7ff7b5a041f0 0x7ff7b5a04204 0

    // 自定义类型
    struct MyOtherStruct { // 结构体
        value: i32,
    }

    let my_other_struct: MyOtherStruct = MyOtherStruct { value: 100 };

    println!("{}", my_other_struct.value);
    // 100
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 原始类型
let b = true; // 布尔型
let n = 10; // 数值型
let s = "hello"; // 字符串型
let nu = null; // 空值
let un = undefined; // 未定义
let sy = Symbol("a"); // 符号
let bi = 1234567890123456789012345678901234567890n; // BigInt

console.log(b, n, s, nu, un, sy, bi); // true 10 hello null undefined Symbol(a) 1234567890123456789012345678901234567890n

// 复合类型（对象类型）
let obj = { name: "Alice", age: 30 }; // 对象
let arr = [1, 2, 3]; // 数组
function myFunction(x, y) { return x + y; } // 函数

console.log(obj, arr, myFunction(2, 3)); // { name: 'Alice', age: 30 } [ 1, 2, 3 ] 5

// 自定义类型
class MyClass { // 类
    constructor(value) {
        this.value = value;
    }
}

let myObj = new MyClass(100);

console.log(myObj.value); // 100

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 原始类型
let b: boolean = true; // 布尔型
let n: number = 10; // 数值型
let s: string = "hello"; // 字符串型
let nu: null = null; // 空值
let un: undefined = undefined; // 未定义
let sy: symbol = Symbol("a"); // 符号
let bi: bigint = 1234567890123456789012345678901234567890n; // BigInt

console.log(b, n, s, nu, un, sy, bi); // true 10 hello null undefined Symbol(a) 1234567890123456789012345678901234567890n

// 复合类型（对象类型）
let obj: { name: string; age: number } = { name: "Alice", age: 30 }; // 对象
let arr: number[] = [1, 2, 3]; // 数组
let myFunction: (x: number, y: number) => number = (x, y) => x + y; // 函数
let tuple: [string, number] = ["hello", 10]; // 元组
enum MyEnum { A, B, C } // 枚举
let myEnum: MyEnum = MyEnum.A;

console.log(obj, arr, myFunction(2, 3), tuple, myEnum); // { name: 'Alice', age: 30 } [ 1, 2, 3 ] 5 [ 'hello', 10 ] 0

// 自定义类型
class MyClass { // 类
    value: number;
    constructor(value: number) {
        this.value = value;
    }
}

interface MyInterface { // 接口
    value: number;
}

type MyType = { // 类型别名
    value: number;
};

let myObj = new MyClass(100);
let myInterfaceObj: MyInterface = { value: 200 };
let myTypeObj: MyType = { value: 300 };

console.log(myObj.value, myInterfaceObj.value, myTypeObj.value); // 100 200 300

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main(string[] args)
    {
        // 值类型
        bool b = true; // 布尔型
        byte by = 10; // 字节型
        short s = 20; // 短整型
        int i = 30; // 整型
        long l = 40L; // 长整型
        float f = 3.14f; // 单精度浮点型
        double d = 3.14159; // 双精度浮点型
        char c = 'a'; // 字符型
        decimal de = 100.00M; // 十进制型
        enum MyEnum { A, B, C } // 枚举
        MyEnum myEnum = MyEnum.A;
        struct MyStruct { public string name; public int age; } // 结构体
        MyStruct myStruct = new MyStruct { name = "Alice", age = 30 };

        Console.WriteLine($"{b} {by} {s} {i} {l} {f} {d} {c} {de} {(int)myEnum} {myStruct.name} {myStruct.age}"); // True 10 20 30 40 3.14 3.14159 a 100.00 0 Alice 30

        // 引用类型
        string str = "hello"; // 字符串
        int[] arr = { 1, 2, 3 }; // 数组
        class MyClass { public int value; } // 类
        MyClass myObj = new MyClass { value = 100 };
        interface MyInterface { int MyMethod(); } // 接口
        delegate int MyDelegate(int x); // 委托

        Console.WriteLine($"{str} {arr[0]} {myObj.value}"); // hello 1 100

        // 自定义类型
        class MyOtherClass : MyClass { } // 类
        interface MyOtherInterface : MyInterface { } // 接口

        Console.WriteLine(new MyOtherClass().value); // 0
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

-module(main).
-export([main/0]).

main() ->
    % 基本类型
    B = true, % 布尔型
    I = 10, % 整数
    F = 3.14, % 浮点数
    A = atom, % 原子
    S = "hello", % 字符串
    Bs = <<1, 2, 3>>, % 位串
    N = nil, % 空列表

    io:format("~p ~p ~p ~p ~p ~p ~p~n", [B, I, F, A, S, Bs, N]), % true 10 3.14 atom "hello" <<1,2,3>> []

    % 复合类型
    Tuple = {1, "hello", 3.14}, % 元组
    List = [1, 2, 3], % 列表
    Map = #{a => 1, b => 2}, % 映射
    Binary = <<1, 2, 3>>, % 二进制型

    io:format("~p ~p ~p ~p~n", [Tuple, List, Map, Binary]), % {1,"hello",3.14} [1,2,3] #{a => 1,b => 2} <<1,2,3>>

    % 自定义类型
    -type my_int() :: integer(). % 类型别名
    -record(person, {name = "", age = 0}). % 记录

    MyInt :: my_int() = 20.
    Person = #person{name = "Alice", age = 30}.

    io:format("~p ~p~n", [MyInt, Person]). % 20 {person, "Alice", 30}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<?php
// 标量类型
$b = true; // 布尔型
$i = 10; // 整型
$f = 3.14; // 浮点型
$s = "hello"; // 字符串型

echo $b . " " . $i . " " . $f . " " . $s . "\n"; // 1 10 3.14 hello

// 复合类型
$arr = array(1, 2, 3); // 数组
$obj = new stdClass(); // 对象
$obj->name = "Alice";

echo $arr[0] . " " . $obj->name . "\n"; // 1 Alice

// 特殊类型
$null = NULL; // NULL 类型

echo var_export($null) . "\n"; // NULL

// 自定义类型
class MyClass { // 类
    public $value;
}

$myObj = new MyClass();
$myObj->value = 100;

echo $myObj->value . "\n"; // 100
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 内置类型
b = true # 布尔型
i = 10 # 整型
f = 3.14 # 浮点型
s = "hello" # 字符串型
sym = :symbol # 符号

puts "#{b} #{i} #{f} #{s} #{sym}" # true 10 3.14 hello symbol

# 复合类型
arr = [1, 2, 3] # 数组
hash = { "a" => 1, "b" => 2 } # 哈希
range = 1..10 # 范围

puts "#{arr} #{hash} #{range}" # [1, 2, 3] {"a"=>1, "b"=>2} 1..10

# 自定义类型
class MyClass # 类
  def initialize(value)
    @value = value
  end
end

my_obj = MyClass.new(100)

puts my_obj.instance_variable_get(:@value) # 100