02 章: Python 语言基础

# hello_world.py
print("Hello world")  # 打印 "Hello world"

In [1]: a = 5  # 定义变量 a 并赋值为 5

In [2]: a  # 直接输入变量名，IPython 会显示其值
Out[2]: 5

In [3]: import numpy as np  # 导入 numpy 库，并简写为 np

In [4]: data = [np.random.standard_normal() for i in range(7)]  # 生成包含 7 个标准正态分布随机数的列表

In [5]: data  # 显示 data 列表
Out[5]:
[-0.20470765948471295,
 0.47894333805754824,
 -0.5194387150567381,
 -0.55573030434749,
 1.9657805725027142,
 1.3934058329729904,
 0.09290787674371767]

In [1]: an_apple = 27  # 定义一个变量 an_apple

In [2]: an_example = 42  # 定义另一个变量 an_example

In [3]: an<Tab>  # 在这里按 Tab 键
an_apple  an_example  any  # IPython 会显示可能的补全

In [3]: b = [1, 2, 3]  # 定义一个列表 b

In [4]: b.<Tab>  # 在点号后按 Tab 键
append()  count()   insert()  reverse()  # 显示列表 b 的所有可用方法
clear()   extend()  pop()     sort()
copy()    index()   remove()

In [1]: import datetime  # 导入 datetime 模块

In [2]: datetime.<Tab>  # 在点号后按 Tab 键
date       MAXYEAR    timedelta  # 显示 datetime 模块的所有可用成员
datetime   MINYEAR    timezone
datetime_CAPI time      tzinfo

In [1]: b = [1, 2, 3]  # 定义一个列表 b

In [2]: b?  # 在变量名后加上问号，进行内省
Type:        list  # 类型：列表
String form: [1, 2, 3]  # 字符串形式
Length:      3  # 长度：3
Docstring:  # 文档字符串
Built-in mutable sequence.  # 内置的可变序列

If no argument is given, the constructor creates a new empty list.  # 如果没有给出参数，构造函数将创建一个新的空列表。
The argument must be an iterable if specified.  # 如果指定了参数，则参数必须是可迭代对象。

def add_numbers(a, b):  # 定义一个函数 add_numbers
    """
    Add two numbers together  # 函数的文档字符串

    Returns
    -------
    the_sum : type of arguments  # 返回值的描述
    """
    return a + b  # 返回 a 和 b 的和

In [6]: add_numbers?  # 对函数进行内省
Signature: add_numbers(a, b)  # 函数签名
Docstring:  # 文档字符串
Add two numbers together  # 将两个数字相加

Returns
-------
the_sum : type of arguments  # 返回值的类型
File:      <ipython-input-9-6a548a216e27>  # 文件名
Type:      function  # 类型：函数

In [9]: import numpy as np  # 导入 numpy 库

In [10]: np.*load*?  # 搜索 numpy 中所有包含 "load" 的名称
np.__loader__  # 匹配到的名称
np.load
np.loads
np.loadtxt

a = 5; b = 6; c = 7  # 通常避免这种风格，写成多行更清晰

results = []  # 初始化一个空列表 results
for line in file_handle:  # 遍历文件句柄 file_handle 中的每一行
    # keep the empty lines for now  # 暂时保留空行
    # if len(line) == 0:  # 如果行的长度为 0
    #     continue  # 跳过当前迭代
    results.append(line.replace("foo", "bar"))  # 将行中的 "foo" 替换为 "bar"，并将结果添加到 results 列表

print("Reached this line")  # 简单的状态报告，打印 "Reached this line"

result = f(x, y, z)  # 调用函数 f，并传入参数 x, y, z
g()  # 调用函数 g，不传入任何参数

obj.some_method(x, y, z)  # 调用对象 obj 的 some_method 方法，并传入参数 x, y, z

result = f(a, b, c, d=5, e="foo")  # 调用函数 f，传入位置参数 a, b, c 和关键字参数 d, e

a = [1, 2, 3]  # 创建一个列表 [1, 2, 3]，并将其赋值给变量 a
b = a  # 将 a 赋值给 b，b 现在引用与 a *相同*的列表
a.append(4)  # 向列表 a 中追加元素 4
print(b)  # 输出: [1, 2, 3, 4]，因为 a 和 b 指向同一个列表

a = 5  # 将整数 5 赋值给变量 a
print(type(a))  # 输出: <class 'int'>，a 的类型是 int

a = "foo"  # 将字符串 "foo" 赋值给变量 a
print(type(a))  # 输出: <class 'str'>，a 的类型现在是 str

"5" + 5  # 这将导致 TypeError，因为字符串和整数不能直接相加

a = 4.5  # 浮点数 4.5
b = 2  # 整数 2
print(f"a is {type(a)}, b is {type(b)}")  # 字符串格式化，打印 a 和 b 的类型
print(a / b)  # a 除以 b，结果是浮点数 2.25

a = 5  # 整数 5
print(isinstance(a, int))  # 输出: True，a 是 int 类型的实例

b = 4.5  # 浮点数 4.5
print(isinstance(a, (int, float)))  # 输出: True，a 是 int 或 float 类型的实例
print(isinstance(b, (int, float)))  # 输出: True，b 是 int 或 float 类型的实例

a = "foo"  # 字符串 "foo"
# a.<Press Tab>  # 查看可用的属性和方法

print(getattr(a, "split")) # 通过字符串'split'，获取对象a的split属性。

def isiterable(obj):  # 定义一个函数 isiterable，用于检查对象是否可迭代
    try:
        iter(obj)  # 尝试对 obj 进行迭代
        return True  # 如果可以迭代，返回 True
    except TypeError:  # 如果发生 TypeError（不可迭代）
        return False  # 返回 False

print(isiterable("a string"))  # 输出: True，字符串是可迭代的
print(isiterable([1, 2, 3]))  # 输出: True，列表是可迭代的
print(isiterable(5))  # 输出: False，整数不可迭代

# some_module.py  # 定义一个名为 some_module.py 的模块
PI = 3.14159  # 定义一个常量 PI

def f(x):  # 定义一个函数 f
    return x + 2  # 返回 x + 2

def g(a, b):  # 定义一个函数 g
    return a + b  # 返回 a + b

# In another file:  # 在另一个文件中
import some_module  # 导入 some_module 模块
result = some_module.f(5)  # 调用 some_module 模块中的 f 函数
pi = some_module.PI  # 访问 some_module 模块中的 PI 常量

# Or:  # 或者
from some_module import g, PI  # 从 some_module 模块导入 g 函数和 PI 常量
result = g(5, PI)  # 调用 g 函数

# Or with different names:  # 或者使用不同的名称
import some_module as sm  # 导入 some_module 模块，并将其重命名为 sm
from some_module import PI as pi, g as gf  # 从 some_module 模块导入 PI 和 g，并分别重命名为 pi 和 gf

print(5 - 7)  # 减法
print(12 + 21.5)  # 加法
print(5 <= 2)  # 小于等于比较

a = [1, 2, 3]  # 创建一个列表 [1, 2, 3]
b = a  # b 引用 a
c = list(a)  # 创建一个 a 的新副本，并将其赋值给 c

print(a is b)      # 输出: True，a 和 b 引用同一个对象
print(a is not c)  # 输出: True，a 和 c 引用不同的对象
print(a == c)      # 输出: True，a 和 c 的值相等

a_list = ["foo", 2, [4, 5]]  # 创建一个列表
a_list[2] = (3, 4)  # 修改列表的第三个元素
print(a_list)  # 输出: ['foo', 2, (3, 4)]

a_tuple = (3, 5, (4, 5))  # 创建一个元组
a_tuple[1] = "four"  # 这将导致 TypeError，因为元组是不可变的

ival = 17239871
print(ival ** 6)  # 整数的幂运算

fval = 7.243
fval2 = 6.78e-5  # 科学计数法

a = 'one way of writing a string'
b = "another way"
c = """
This is a longer string that
spans multiple lines
"""  # 多行字符串

a = "this is a string"
# a[10] = 'f'  # TypeError: 'str' 对象不支持项赋值，因为字符串是不可变的

b = a.replace("string", "longer string")  # 替换字符串中的子串
print(b) # 输出：this is a longer string
print(a) # 输出：this is a string, a的值不会改变

s = "python"
print(list(s))  # 输出: ['p', 'y', 't', 'h', 'o', 'n']
print(s[:3])  # 输出: 'pyt'，字符串切片

s = "12\\\\34"  # 包含两个反斜杠的字符串
print(s)  # 输出: 12\34

raw_string = r"this\has\no\special\characters"  # 原始字符串，反斜杠不转义
print(raw_string)  # 输出: this\has\no\special\characters

a = "this is the first half "
b = "and this is the second half"
print(a + b)  # 字符串连接

amount = 10
rate = 88.46
currency = "Pesos"
result = f"{amount} {currency} is worth US${amount / rate:.2f}"  # f-string 格式化
print(result) # 输出：10 Pesos is worth US$0.11

val = "español"  # Unicode 字符串
val_utf8 = val.encode("utf-8")  # 编码为 UTF-8 字节
print(val_utf8)  # 输出: b'espa\xc3\xb1ol'
print(type(val_utf8))  # 输出: <class 'bytes'>

print(val_utf8.decode("utf-8"))  # 解码为 Unicode 字符串

print(True and True)  # 输出: True
print(False or True)  # 输出: True

print(int(False))  # 输出: 0，False 可以转换为整数 0
print(int(True))   # 输出: 1，True 可以转换为整数 1

s = "3.14159"
fval = float(s)  # 将字符串转换为浮点数
print(type(fval))  # 输出: <class 'float'>
print(int(fval))  # 将浮点数转换为整数，向下取整
print(bool(fval))  # 将浮点数转换为布尔值，非零值为 True
print(bool(0))  # 将整数 0 转换为布尔值，结果为 False

a = None
print(a is None)  # 输出: True

b = 5
print(b is not None)  # 输出: True

from datetime import datetime, date, time  # 导入 datetime 模块

dt = datetime(2011, 10, 29, 20, 30, 21)  # 创建一个 datetime 对象
print(dt.day)  # 输出: 29，获取日
print(dt.minute)  # 输出: 30，获取分钟
print(dt.date())  # 输出: 2011-10-29，获取日期部分
print(dt.time())  # 输出: 20:30:21，获取时间部分

print(dt.strftime("%Y-%m-%d %H:%M"))  # 格式化日期和时间

dt2 = datetime.strptime("20091031", "%Y%m%d")  # 解析字符串为 datetime 对象
print(dt2) # 输出：2009-10-31 00:00:00

dt2 = datetime(2011, 11, 15, 22, 30)
delta = dt2 - dt  # 计算两个 datetime 对象的时间差
print(delta)  # 输出: 17 days, 1:59:39
print(type(delta))  # 输出: <class 'datetime.timedelta'>
print(dt + delta)  # 将时间差加到 dt 上

x = -5
if x < 0:  # 如果 x 小于 0
    print("It's negative")  # 打印 "It's negative"
elif x == 0:  # 否则，如果 x 等于 0
    print("Equal to zero")  # 打印 "Equal to zero"
elif 0 < x < 5:  # 否则，如果 x 大于 0 且小于 5
    print("Positive but smaller than 5")  # 打印 "Positive but smaller than 5"
else:  # 否则
    print("Positive and larger than or equal to 5")  # 打印 "Positive and larger than or equal to 5"

for value in collection:  # 遍历集合中的每个值
    # do something with value  # 对值执行某些操作

sequence = [1, 2, None, 4, None, 5]  # 定义一个列表
total = 0  # 初始化 total 为 0
for value in sequence:  # 遍历列表中的每个值
    if value is None:  # 如果值为 None
        continue  # 跳过当前迭代
    total += value  # 将 value 加到 total 上
print(total) # 输出：12

sequence = [1, 2, 0, 4, 6, 5, 2, 1]  # 定义一个列表
total_until_5 = 0  # 初始化 total_until_5 为 0
for value in sequence:  # 遍历列表中的每个值
    if value == 5:  # 如果值等于 5
        break  # 退出循环
    total_until_5 += value  # 将 value 加到 total_until_5 上
print(total_until_5) # 输出：13

for i in range(4):  # 外层循环，i 从 0 到 3
    for j in range(4):  # 内层循环，j 从 0 到 3
        if j > i:  # 如果 j 大于 i
            break  # 退出内层循环
        print((i, j))  # 打印 (i, j)

x = 256  # 初始化 x 为 256
total = 0  # 初始化 total 为 0
while x > 0:  # 当 x 大于 0 时循环
    if total > 500:  # 如果 total 大于 500
        break  # 退出循环
    total += x  # 将 x 加到 total 上
    x = x // 2  # 将 x 整除 2
print(total) # 输出 504

if x < 0:
    print("negative!")
elif x == 0:
    # TODO: put something smart here  # 这是一个待办事项，表示将来需要在此处添加代码
    pass  # 什么也不做
else:
    print("positive!")

print(list(range(10)))  # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(0, 20, 2)))  # 输出: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(list(range(5, 0, -1)))  # 输出: [5, 4, 3, 2, 1]

seq = [1, 2, 3, 4]  # 定义一个列表
for i in range(len(seq)):  # 遍历列表的索引
    print(f"element {i}: {seq[i]}")  # 打印每个元素及其索引