Python 基础

import sys  # 导入 sys 模块，用于处理系统参数

sys.path.append('grbin')  # 将用户模块所在目录添加到搜索路径
# 可以取消下一行注释，以查看当前路径列表
# print(sys.path)  # 输出 Python 查找模块时使用的路径列表

'''
这是一个多行注释，可以在这里描述更复杂的逻辑，或给出详细说明。
使用多行注释可以提高代码可读性，并使代码更容易维护。
'''

import sys  # 导入 sys 模块，用于处理系统参数

# grcodes.py 模块中的函数定义
def printx(name):
    """
    函数输出变量名及其值。
    使用示例：name = 88.0; printx('name')
    """
    frame = sys._getframe(1)
    print(name, '=', repr(eval(name, frame.f_globals, frame.f_locals)))

import grcodes as gr  # 导入用户模块，并为方便起见设置别名

x = 1.0  # 给变量赋值
print(x)  # 标准方式输出变量值

gr.printx('x')  # 使用 gr 模块中的 printx 函数输出变量名和值

# 获取 printx 函数的帮助信息
help(gr.printx)

my_int = 48  # 通过这个赋值，my_int 成为整数
print(my_int)
printx('my_int')

48
my_int = 48

type(my_int)  # 检查变量类型。如果这是单元格中的最后一行，不需要 print()

int

my_int = 5.0  # 现在 my_int 变成浮点数

type(my_int)

float

my_complex = 8.0 + 5.0j  # 这样 my_complex 就是复数
print(my_complex)
printx('my_complex')

(8+5j)
my_complex = (8+5j)

my_int, my_float, my_string = 20, 10.0, "Hello!"

if my_string == "Hello!":  # 比较运算符：==, !=, <, <=, >, >=
    print("字符串：%s" % my_string)  # 缩进 4 个空格

if isinstance(my_float, float) and my_float == 10.0:  # isinstance(): 判断对象是否为某个类的实例
    print("这是一个浮点数，它等于 %f" % my_float)

if isinstance(my_int, int) and my_int == 20:
    print("这是一个整数，它等于：%d" % my_int)

字符串：Hello!
这是一个浮点数，它等于 10.000000
这是一个整数，它等于：20

my_float = 5.0  # 给 my_float 赋值 5.0，使其成为 float 类型
print(my_float)  # 输出变量 my_float 的值
my_float = float(6)  # 使用 float() 将整数转换为浮点数
print(my_float)  # 输出变量 my_float 的值
print(int(7.0))  # 将 float 转换为 int 并输出
print('int(7.0)')  # 输出字符串 'int(7.0)'

5.0
6.0
7
int(7.0)

a = 1.0
print('a =', a, '内存地址：', id(a))

b = a
print('b =', b, '内存地址：', id(b))

a = 1.0 内存地址：140703208811472
b = 1.0 内存地址：140703208811472

a, b = 2.0, 3.0

print('a =', a, '内存地址：', id(a))
print('b =', b, '内存地址：', id(b))

a = 2.0 内存地址：4365829648
b = 3.0 内存地址：4365829264

n1 = 100000000000
n_1 = 100_000_000_000  # 为了便于阅读

# 三元条件表达式
print('是的，n1 与 n_1 相同') if n1 == n_1 else print('不是')

n2 = 1_000_000_000
print('总计=', n1 + n2)

# f 字符串（Python 3.6 或更高版本）
print('总计=', f'{n1 + n2:,}')

# 下一行若写成 total 会出错，因为变量 total 未定义
# 为了修正，将 total 改为 n1 + n2
print('总计=', f'{n1 + n2:_}')

是的，n1 与 n_1 相同
总计= 101000000000
总计= 101,000,000,000
总计= 101_000_000_000

my_string = "Как дела? Как твое настроение?"
# 字符串已定义，可以对其中的字符进行索引
print(my_string, my_string[14], my_string[15], my_string[16], my_string[17], my_string[18:])

my_string = 'Привет,' + " привет!" + " Я здесь."
# 注意：字符串中的 “+” 运算符执行拼接
print(my_string)

Как дела? Как твое настроение? т в о е  настроение?
Привет, привет! Я здесь.

my_string = "Не волнуйтесь, просто используйте двойные кавычки для 'экранирования'."
print(my_string)

Не волнуйтесь, просто используйте двойные кавычки для 'экранирования'.

my_string = 'Не волнуйтесь о "двойных кавычках".'
print(my_string)

Не волнуйтесь о "двойных кавычках".

one, two, three = 1, 2, 3  # 给变量赋值

summation = one + two + three
print('和=', summation)  # 输出“和”

和= 6

one, two, three = 1, 2, 3.0  # 变量类型可以不同！

summation = one + two + three
print('求和=', summation)  # 输出“求和”

求和= 6.0

one3 = two3 = three3 = 3  # 给多个变量赋同一个值
print(one3, two3, three3)

3 3 3

hello, world = "Hello,", "world!"

# 拼接字符串
helloworld = hello + " " + world + "!!"
print(helloworld, ' ', hello + " " + world)

# 获取字符串长度，包括空格和标点符号
lhw = len(helloworld)
print('字符串 "helloworld" 的长度为', lhw)

Hello, world!!!   Hello, world!
字符串 "helloworld" 的长度为 17

hello, world = "Hello,", "world!"

helloworld = hello + " " + world + "!!"
the_words = helloworld.split(" ")  # 创建字符串列表
# 后面还会介绍与列表相关的类似操作
print("将字符串拆分成单词：%s" % the_words)
print('使用空格作为分隔符重新连接：', ' '.join(the_words))

将字符串拆分成单词：['Hello,', 'world!!!']
使用空格作为分隔符重新连接： Hello, world!!!

my_string = "Helloworld!"
print('"o" 位于第', my_string.index("o"), '个字符之后。')
print('第一个字母 "l" 位于第', my_string.index("l"), '个字符之后。')

"o" 位于第 4 个字符之后。
第一个字母 "l" 位于第 2 个字符之后。

my_string = "Helloworld!"
# “+” 执行拼接
print('字母 "o" 的位置在第 ' + str(my_string.index("o")) + ' 个字符之后。')
print('第 1 个字母 "l" 位于第 ' + str(my_string.index("l")) + ' 个字符之后。')

字母 "o" 的位置在第 4 个字符之后。
第 1 个字母 "l" 位于第 2 个字符之后。

from collections import Counter  # 导入 Counter 模块

my_list = ['а', 'а', 'б', 'б', 'б', 'в', 'г', 'г', 'г', 'г', 'г']
count = Counter(my_list)  # Counter 对象是一种字典

print(count)  # 输出列表中每个元素的出现频率
# 后面还会介绍字典

Counter({'г': 5, 'б': 3, 'а': 2, 'в': 1})

print('“б” 的出现频率为', count['б'])
# 通过键索引元素频率

“б” 的出现频率为 3

my_string = "Привет мир!"  # 定义字符串
print(my_string.upper(), my_string.lower(), my_string.title())  # 分别转换为大写、小写和标题形式

ПРИВЕТ МИР! привет мир! Привет Мир!

my_string = "АБВГДЕЖ"
reversed_string = my_string[::-1]
print(reversed_string)

ЖЕДГВБА

my_string = "Россия - страна возможностей"
new_string = my_string.title()
print(new_string)

Россия - Страна Возможностей

n = 8
my_list = [1] * n
print(my_list)

[1, 1, 1, 1, 1, 1, 1, 1]

# 声明变量 my_string，并赋值为 "абвгдеж"
my_string = "абвгдеж"

# 输出重复两次的字符串 my_string
print(my_string * 2)

абвгдежабвгдеж

# 声明变量 lotsofhellos，并将其赋值为重复 5 次的 "Привет "
lotsofhellos = "Привет " * 5

# 输出变量 lotsofhellos 的值
print(lotsofhellos)

Привет Привет Привет Привет Привет 

# 字符串 "АБВГД" 的长度
print("字符串 «АБВГД» 的长度为", len("АБВГД"))

字符串 «АБВГД» 的长度为 5

# 输出字符串长度的程序
# 初始化变量 my_string
my_string = "Hello, world!"
# 输出 my_string 的长度
print("字符串", my_string, "的长度为", len(my_string))

字符串 "Hello, world!" 的长度为 13

# 声明两个包含列表的变量
even_numbers, odd_numbers = [2, 4, 6, 8], [1, 3, 5, 7]

# 使用 len() 函数获取 even_numbers 列表的长度
length = len(even_numbers)
# 使用 + 运算符合并两个列表
all_numbers = odd_numbers + even_numbers
# 输出合并后的列表，以及原始长度和新长度
print(all_numbers, ' 原始长度为', length, '。新长度为', len(all_numbers))

[1, 3, 5, 7, 2, 4, 6, 8] 原始长度为 4。新长度为 8

# 创建列表
all_numbers = [5, 3, 9, 1, 4]
# 输出按字母顺序排序后的俄文字母 'ДГВБА'，以及 'АБВГД' 的逆序排序
print(sorted('ДГВБА'), sorted('АБВГД', reverse=True))
# 输出 all_numbers 列表的升序和降序排序结果
print(sorted(all_numbers), sorted(all_numbers, reverse=True))

['А', 'Б', 'В', 'Г', 'Д'] ['Д', 'Г', 'В', 'Б', 'А']
[1, 3, 4, 5, 9] [9, 5, 4, 3, 1]

# 原始列表和变量
original_list, n = [1, 2, 3, 4], 2

# 使用列表推导式创建新列表，
# 其中原始列表的每个元素都乘以 n
new_list = [n * x for x in original_list]
# 输出新列表
print(new_list)

[2, 4, 6, 8]

my_list = ['a', 'b', 'c']  # 创建包含元素 'a'、'b'、'c' 的列表
# 遍历列表，同时获得每个元素的索引和值
for index, value in enumerate(my_list):
    # 输出索引（加 1 后）和每个列表元素的值
    print('{0}: {1}'.format(index + 1, value))

1: a
2: b
3: c

my_list = ['a', 'b', 'c']  # 创建包含元素 'a'、'b'、'c' 的列表

for index, value in enumerate(my_list):  # 生成索引和值
    print(f'{index + 1}: {value}')  # 使用 f 字符串输出索引（加 1 后）和值

1: a
2: b
3: c

a, b = 1, 2  # 给变量 a 和 b 赋值

try:
    print(a / b)  # 尝试执行除法
except ZeroDivisionError:
    print("除以零")  # 处理除零错误
else:
    # 如果 try 块中没有异常，则执行 else 块
    print("没有发生异常")
finally:
    # finally 块无论如何都会执行
    print("无论发生什么，这一段总会执行")

0.5
没有发生异常
无论发生什么，这一段总会执行

import sys  # 导入 sys 模块

num = "AAA"
print('内存大小为 %d' % sys.getsizeof(num), '字节')
# 字符串的内存大小

内存大小为 52 字节

num = 12345
print('内存大小为 %d' % sys.getsizeof(num), '字节')
# 整数的内存大小

内存大小为 28 字节

# 定义俄语字符串
astring = "Привет мир!"

# 检查字符串是否以 "Привет" 开头，以及是否以 "абвгд" 或 "!" 结尾
starts_with_privet = astring.startswith("Привет")
ends_with_abvgd = astring.endswith("абвгд")
ends_with_exclamation = astring.endswith("!")

print(starts_with_privet, ends_with_abvgd, ends_with_exclamation)

True False True

# 检查所有字符是否都由数字组成
# 检查所有字符是否都由字母组成
# 检查字符串是否全部为大写

my_string = "Приветмир!"
my_string1 = "ПриветМир"
my_string2 = "ПРИВЕТ МИР!"

print(my_string.isalnum())  # 是否所有字符都是字母或数字
print(my_string1.isalpha())  # 是否所有字符都是字母
print(my_string2.isupper())  # 是否全部由大写字母组成

False
True
True

n, x, s = 1234, 1234.0, 'это строка'

print(type(n), type(x), type(s))  # 检查对象类型
print(len(s), len(str(n)), len(str(x)))  # 确定字符串和数字字符串表示的长度

<class 'int'> <class 'float'> <class 'str'>
10 4 6

a = 2  # 将变量 a 初始化为 2
print('a=', a, ' type of a:', type(a))  # 输出变量 a 的值和类型
b = 3.0  # 将变量 b 初始化为 3.0
a = a + b  # 对变量 a 和 b 求和，结果保存到 a 中
# 输出变量 a 和 b 的值与类型
print('a=', a, ' type of a:', type(a))
print('b=', b, ' type of b:', type(b))

a= 2  type of a: <class 'int'>
a= 5.0  type of a: <class 'float'>
b= 3.0  type of b: <class 'float'>

n, x, s = 1234, 1234.5, 'это строка'  # 初始化变量 n、x 和 s

sfn = str(n)  # 将整数 n 转换为字符串
print(sfn, type(sfn))  # 输出变量 sfn 的值和类型
sfx = str(x)  # 将浮点数 x 转换为字符串
print(sfx, type(sfx))  # 输出变量 sfx 的值和类型

1234 <class 'str'>
1234.5 <class 'str'>

n, x, s = 1234, 1234.5, 'это строка'  # 初始化变量 n、x 和 s

xfn = float(n)  # 将整数 n 转换为浮点数
print(xfn, type(xfn))  # 输出变量 xfn 的值和类型
nfx = int(x)  # 将浮点数 x 转换为整数
print(nfx, type(nfx))  # 输出变量 nfx 的值和类型

1234.0 <class 'float'>
1234 <class 'int'>

# a = int('Привет')  # 将字符串 'Привет' 转换为整数会引发错误 ValueError
# a = int('2.5')     # 将字符串 '2.5' 转换为整数也会引发错误 ValueError

a = int('25')  # 将字符串 '25' 转换为整数，可以正确工作
print(a, type(a))  # 输出转换后变量 a 的值和类型

25 <class 'int'>

# 执行加法运算
result = 8.0 + float("8.0")  # 将字符串 "8.0" 转换为浮点数后，与浮点数 8.0 相加
print(result)  # 输出运算结果

16.0

a = int(False)  # 将布尔值 False 转换为整数
print(a, type(a))  # 输出转换后变量 a 的值和类型

0 <class 'int'>

# 定义浮点数和字符串
my_float = 3.14
my_string = "Этострока-пример"

# 尝试将它们相加
try:
    my_mix = my_float + my_string  # 尝试把浮点数和字符串相加
except TypeError as e:
    print(f"错误：{e}")  # 输出错误

错误：unsupported operand type(s) for +: 'float' and 'str'

name = "Иван"
print("Привет, %s! Как ты?" % name)  # %s 用于字符串
# 对于两个或更多参数，请使用元组：

name, age = "Алексей", 23
print("%s %d лет." % (name, age))  # %d 用于数字

Привет, Иван! Как ты?
Алексей 23 лет.

# 定义变量
name = "Иван"  # 姓名
age = 23  # 年龄
# 输出问候语和年龄信息
# 使用 f 字符串把变量直接插入字符串
print(f"{name} {age} лет.")  # f 字符串可用于 Python 3.6 及更高版本

Иван 23 лет.

list1, list2, x = [1, 2, 3], ['Аня', 'Маша'], 12.5  # 多重赋值

print("Список1:%s; Список2:%s\nx=%s, x=%f, x=%.3f, x=%e" % (list1, list2, x, x, x, x))

Список1:[1, 2, 3]; Список2:['Аня', 'Маша']
x=12.5, x=12.500000, x=12.500, x=1.250000e+01

x=%s   - 字符串格式。
x=%f   - 浮点格式。
x=%.3f - 保留三位小数的浮点格式。
x=%e   - 科学计数法格式。

list1, list2, x = [1, 2, 3], ['Аня', 'Маша'], 12.5  # 多重赋值

print(f"List1:{list1};List2:{list2};x={x},x={x:.2f}, x={x:.3e}")  # 使用 f 字符串格式化输出变量 list1、list2 和 x

List1:[1, 2, 3];List2:['Аня', 'Маша'];x=12.5,x=12.50, x=1.250e+01

имя = "Иван"
возраст = 30
рост = 1.82

print(f"Привет, {имя}! Твой возраст - {возраст} лет, а рост - {рост:.2f} метра.")

Привет, Иван! Твой возраст - 30 лет, а рост - 1.82 метра.

# 加法
print(1 + 2)  # 3
# 减法
print(5 - 3)  # 2
# 乘法
print(2 * 3)  # 6
# 除法
print(10 / 2)  # 5
# 整除
print(10 // 2)  # 5
# 整除余数
print(10 % 2)  # 0
# 幂运算
print(2 ** 3)  # 8

3
2
6
5.0
5
0
8

# 声明变量 number，并将其赋值为 1 + 2 * 3 / 4.0
number = 1 + 2 * 3 / 4.0
# 输出变量 number 的值
print(number)

2.5

# 声明两个变量：
# numerator - 分子
# denominator - 分母
numerator, denominator = 11, 2

# 计算整除商
floor = numerator // denominator
# 输出结果
print(str(numerator) + '//' + str(denominator) + '=', floor)

# 计算除法余数
remainder = numerator % denominator
# 输出结果
print(str(numerator) + '%' + str(denominator) + '=', remainder)

# 计算“商 × 除数 + 余数”
print(floor * denominator + remainder)

11//2= 5
11%2= 1
11

# 声明两个变量：
# squared - 数字 7 的平方
# cubed - 数字 2 的立方
squared, cubed = 7 ** 2, 2 ** 3

# 在控制台输出变量值
print('7 ** 2 =', squared, ', and 2 ** 3 =', cubed)

7 ** 2 = 49 , and 2 ** 3 = 8

# 数字 7 和 2 之间的按位异或（XOR）
test72 = 7 ^ 2
# 在控制台输出结果
print(test72)

5

# 声明变量 a 和 b，并分别赋值为 100 和 200
a, b = 100, 200

# 输出变量 a 和 b 的值
print('a=', a, 'b=', b)

# 使用赋值运算符交换变量 a 和 b 的值
a, b = b, a

# 输出变量 a 和 b 的值
print('a=', a, 'b=', b)

a= 100 b= 200
a= 200 b= 100

# 对除 0 和空值之外的所有值输出 True
print(bool(5), bool(-5), bool(0.2), bool(-0.1), bool(str('a')), bool(str('0')))
# True True True True True True

# 对 0 和 -0.0 输出 False
print(bool(0), bool(-0.0))
# False False

# 对空值输出 False
print(bool(''), bool([]), bool({}), bool(()))
# False False False False

# 第一行代码输出三个值：
# - True and True：两个真值的逻辑与，结果为 True
# - False or True：两个值的逻辑或，其中一个为真，结果为 True
# - True or True：两个真值的逻辑或，结果为 True
print(True and True, False or True, True or True)

# 第二行代码输出两个值：
# - False and False：两个假值的逻辑与，结果为 False
# - False and True：两个值的逻辑与，其中一个为假，结果为 False
print(False and False, False and True)

True True True
False False

# 声明一个 list 类型变量 x_list
x_list = []

# 将变量 x_list 的内容输出到屏幕
print(f"x_list={x_list}")

# 以十六进制格式输出变量 x_list 的地址
print(hex(id(x_list)))

x_list=[]
0x104983300

x_list = []
x_list.append(1)    # 将数字 1 添加到 x_list 的末尾
x_list.append(2)    # 将数字 2 添加到 x_list 的末尾
x_list.append(3.)   # 将浮点数 3.0 添加到 x_list 的末尾

print(x_list[0])    # 输出列表的第一个元素（索引 0），即 1
print(x_list[1])    # 输出列表的第二个元素（索引 1），即 2
print(x_list[2])    # 输出列表的第三个元素（索引 2），即 3.0
print(x_list)       # 输出整个列表

1
2
3.0
[1, 2, 3.0]

for x in x_list:  # 使用 for 循环遍历列表 x_list 中的元素
    print(x, end=',')  # 不换行输出每个元素
print('\n')            # 循环结束后输出换行

x_list2 = x_list * 2   # 通过将 x_list 与自身连接来创建新列表 x_list2
print(x_list2)         # 输出新列表

1,2,3.0,

[1, 2, 3.0, 1, 2, 3.0]

print(id(x_list), id(x_list2))

4367086336 4367678592

print(id(x_list), id(x_list2))

# 返回列表 x_list 第二个元素的标识符（内存地址）
id(x_list[1])

1594536160

x_list3 = x_list  # 将列表 x_list 赋值给变量 x_list3
print(x_list, ' ', x_list3)  # 输出两个变量的值

[1, 2, 3.0]  [1, 2, 3.0]

x_list3 = x_list

print(x_list, ' ', x_list3)

print(id(x_list), id(x_list3))

1847992120648 1847992120648

print(id(x_list), id(x_list3))

x_list4 = x_list.copy()  # 使用 copy() 方法创建列表 x_list 的独立副本
print(x_list, ' ', x_list4)  # 输出两个列表的值

[1, 2, 3.0]  [1, 2, 3.0]

x_list4 = x_list.copy()

print(x_list, ' ', x_list4)
print(id(x_list), id(x_list4))

1847992120648 1847993186760

# 将列表 x_list 的第一个元素赋值为 4.0
x_list[0] = 4.0

# 将列表输出到屏幕
print(x_list)

[4.0, 2, 3.0]

# 创建列表 x_list
x_list = [1, 2, 3.0]

# 创建列表 x_list2，它是列表 x_list 的副本
x_list2 = x_list.copy()

# 修改列表 x_list 第一个元素的值
x_list[0] = 4.0

# 将列表 x_list2 输出到屏幕
print(x_list2)

[1, 2, 3.0]

num = 19345678

# 方法 1：使用 map() 函数并转换为列表
list_of_digits = list(map(int, str(num)))
print(list_of_digits)  # 输出：[1, 9, 3, 4, 5, 6, 7, 8]

# 方法 2：使用列表推导式
list_of_digits = [int(x) for x in str(num)]
print(list_of_digits)  # 输出：[1, 9, 3, 4, 5, 6, 7, 8]

[int(x) for x in str(num)]

# 声明两个包含列表的变量
list1, list2 = [20, 30, 40], [5, 6, 8]

# 将原始列表输出到屏幕
print(list1, " ", list2, " ", list1 + list2)

# 以字符串形式输出原始列表
print("原始字符串 1：" + str(list1))
print("原始字符串 2：" + str(list2))

# 输出提示："+" 不是加法，而是连接
print('"+" 不是加法，而是连接：', list1 + list2)

[20, 30, 40]   [5, 6, 8]   [20, 30, 40, 5, 6, 8]
原始字符串 1：[20, 30, 40]
原始字符串 2：[5, 6, 8]
"+" 不是加法，而是连接：[20, 30, 40, 5, 6, 8]

# 声明两个列表
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# 声明一个空列表，用于保存元素之和
add_list = []

# 使用 for 循环对两个列表进行逐元素相加
for i in range(0, len(list1)):
    add_list.append(list1[i] + list2[i])

# 将结果输出到屏幕
print("两个列表逐元素相加：" + str(add_list))

两个列表逐元素相加：[7, 9, 11, 13, 15]

# 输出列表 add_list 第一个元素的地址
print("列表第一个元素的地址：", id(add_list[0]))

# 输出列表 list1 第一个元素的地址
print("列表第一个元素的地址：", id(list1[0]))

列表第一个元素的地址： 4363141552
列表第一个元素的地址： 4377526512

# 声明两个列表
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# 声明空列表，用于保存结果
add_list = []

# for 循环同时遍历两个列表中的元素
for i1, i2 in zip(list1, list2):
    # 将元素 i1 与元素 i2 相加
    add_list.append(i1 + i2)

# 将结果输出到屏幕
print("两个列表逐元素求和：", add_list)

两个列表逐元素求和： [7, 9, 11, 13, 15]

add_list = []

for i1, i2 in zip(list1, list2):

add_list.append(i1 + i2)

print("两个列表逐元素求和：", add_list)

my_string = "每座小屋都有自己的小响铃"
# 输出原始字符串
print(my_string)
# 输出第五个字符
print('第 5 个=', my_string[4])
# 输出第七到第十一个字符
print('从第 7 个到第 11 个 =', my_string[6:11])

每座小屋都有自己的小响铃
第 5 个= 屋
从第 7 个到第 11 个 = 有自己的小

# 创建字符串变量
my_string = "你好，世界！"  # 可以把该字符串改成任意其他字符串

# 输出带说明的字符串切片：
print('[6:-1]=', my_string[6:-1])  # 从第 7 个元素（含）到最后一个元素之前
print('[:]=', my_string[:])        # 字符串中的全部字符
print('[6:]=', my_string[6:])      # 从第 7 个元素（含）到字符串末尾
print('[:-1]=', my_string[:-1])    # 除最后一个字符之外的所有字符

[6:-1]= 
[:]= 你好，世界！
[6:]= 
[:-1]= 你好，世界

# 声明变量 my_string，并为它赋值 "Helloworld!"
my_string = "Helloworld!"
# 在屏幕上输出文本“第 4 到第 9 个字符，步长为 2”
print("第 4 到第 9 个字符，步长为 2")
# 使用切片从 my_string 中取得子串：从第 4 个字符开始，到第 9 个字符结束，步长为 2
print("[3:9:2]=", my_string[3:9:2])

# 字符串 "Helloworld!" 由 11 个字符组成：
#   H - 第 1 个字符
#   e - 第 2 个字符
#   l - 第 3 个字符
#   l - 第 4 个字符
#   o - 第 5 个字符
#   w - 第 6 个字符
#   o - 第 7 个字符
#   r - 第 8 个字符
#   l - 第 9 个字符
#   d - 第 10 个字符
#   ! - 第 11 个字符
# 切片语法：[start:stop:step]
# start - 子串中第一个字符的索引
# stop  - 子串结束位置的索引（不包含该位置）
# step  - 子串中字符序列的步长

第 4 到第 9 个字符，步长为 2
[3:9:2]= lwr

my_string = "暖暖地开始了！(引)"
# 输出原始字符串
print("string:", my_string)
# 逆序输出字符串
print("[::-1]=", my_string[::-1])

string: 暖暖地开始了！(引)
[::-1]= )引(！了始开地暖暖

# 声明变量 my_string 并赋空字符串，
# 用于演示错误
my_string = ""

# 尝试输出索引为 14 的元素，该索引超出了字符串范围
print('[14]=', my_string[14])  # 将产生 IndexError 错误

# 创建列表 my_list，包含混合类型的变量：
my_list = [0, 1, 2, 3, "4E", 5, 6, 7, [8, 8], 9]

# 使用 print() 输出列表 my_list
# 范围从 0 到 9，步长为 1
print(my_list[0:10:1])

# 使用 print() 输出列表 my_list
# 范围从列表开头到列表末尾
print(my_list[:])

[0, 1, 2, 3, '4E', 5, 6, 7, [8, 8], 9]
[0, 1, 2, 3, '4E', 5, 6, 7, [8, 8], 9]

# 创建包含混合值的列表
nlist = [10, 20, 30, 40, 50, 6.0, '7H']

# 解包列表元素，忽略前两个元素和第四个元素
_, _, n3, _, *nn = nlist

# 输出第三个元素和第五个元素之后的其余元素
print("n3=", n3, "其余数字", *nn)

# 创建另一个包含数值的列表
nlist = [10, 20, 30, 40, 50, 60, 70]

# 解包元素：保留第三个元素、最后一个元素，并将中间其余元素放入单独列表 nn
_, _, n3, *nn, nlast = nlist

# 输出第三个元素、最后一个元素以及其余元素
print("n3=", n3, ", 最后一个=", nlast, ", 以及所有其他数字", *nn)

n3= 30 其余数字 50 6.0 7H
n3= 30 , 最后一个= 70 , 以及所有其他数字 40 50 60

# 创建由混合类型变量组成的嵌套列表
nested_list = [[11, 12], ['2B', 22], [31, [32, 3.2]]]

# 将嵌套列表输出到屏幕
print('嵌套列表：')
print(nested_list)

# 输出嵌套列表的数量
print('嵌套列表的数量：', len(nested_list))

嵌套列表：
[[11, 12], ['2B', 22], [31, [32, 3.2]]]
嵌套列表的数量： 3

# 输出第一个嵌套列表
# nested_list[0] 是列表 nested_list 的第一个元素
# 输出第二个嵌套列表
# nested_list[1] 是列表 nested_list 的第二个元素
# 输出第三个嵌套列表
# nested_list[2] 是列表 nested_list 的第三个元素
# 输出整个嵌套列表
# print(nested_list) 是把数据输出到屏幕的函数
print(nested_list[0])
print(nested_list[1])
print(nested_list[2])
print(nested_list)

[11, 12]
['2B', 22]
[31, [32, 3.2]]
[[11, 12], ['2B', 22], [31, [32, 3.2]]]

print(nested_list[0][0])  # 输出第一个嵌套列表（索引 0）中的第一个元素（索引 0），即数字 11
print(nested_list[0][1])  # 输出第一个嵌套列表（索引 0）中的第二个元素（索引 1），即数字 12

11
12

print(nested_list)        # 输出整个嵌套列表
print(nested_list[1][0])  # 输出第二个嵌套列表（索引 1）中的第一个元素（索引 0），即字符串 '2B'
print(nested_list[2][1])  # 输出第三个嵌套列表（索引 2）中的第二个元素（索引 1）；该元素本身也是列表：[32, 3.2]
print(nested_list[2][1][0])  # 输出第三个嵌套列表第二个元素中的第一个元素，即数字 32

[[11, 12], ['2B', 22], [31, [32, 3.2]]]
2B
[32, 3.2]
32

# 创建元组
ttuple = (10, 20, 30, 40, 50, 6.0, '7H')
# 输出元组
print('ttuple =', ttuple)
# 将元组中的第一个值赋给变量 aa
aa = ttuple[0]
# 输出变量 aa 的值
print('aa =', aa)
# 输出元组中索引为 1、6 和 -1 的元素值
print(ttuple[1], ' ', ttuple[6], ' ', ttuple[-1])

ttuple = (10, 20, 30, 40, 50, 6.0, '7H')
aa = 10
20   7H   7H

# 声明元组
ttuple = ('a', 'b', 'c', 'd', 'e')

# 使用 enumerate() 函数的 for 循环
# enumerate() 函数返回由元素索引和元素值组成的元组
for i, data in enumerate(ttuple):
    # 检查索引是否小于 3
    if i < 3:
        # 输出索引和元素值
        print(i, ':', data)

0 : a
1 : b
2 : c

# 创建元组
ttuple = (1, 2, 3)
# 输出元组
print("终端输出：", ttuple)
# 尝试修改元组元素的值
try:
    ttuple[2] = 300
except TypeError:
    print("错误：不能修改元组元素的值")

# 创建字典 phonebook1
phonebook1 = {}

# 向字典中添加记录
phonebook1["玛莎"] = 513476565
phonebook1["列沙"] = 513387234
phonebook1["娜斯佳"] = 513682762
phonebook1["圣诞老人"] = 513387234

# 将字典输出到屏幕
print(phonebook1)

{'玛莎': 513476565, '列沙': 513387234, '娜斯佳': 513682762, '圣诞老人': 513387234}

# 创建字典 phonebook2
phonebook2 = {'列拉': 656477456, '娜斯佳': 656377243, '季莫费': 656662798}

# 将字典输出到屏幕
print(phonebook2)

{'列拉': 656477456, '娜斯佳': 656377243, '季莫费': 656662798}

# 声明字典 phonebook0
phonebook0 = {
    "科斯佳": [788567837, 788347278],  # 科斯佳有两个电话号码；这是一个列表
    "因娜": 513683222,
    "弗拉季克": 656477456
}

# 将字典 phonebook0 输出到屏幕
print("电话簿：")
print(phonebook0)

电话簿：
{'科斯佳': [788567837, 788347278], '因娜': 513683222, '弗拉季克': 656477456}

# 创建电话簿字典
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

# 遍历字典
for name, number in phonebook1.items():
    # 输出用户姓名及其电话号码
    print("%s 的电话号码是 %d" % (name, number))

伊万诺夫 伊万 的电话号码是 1234567
彼得罗夫 彼得 的电话号码是 89012345678
西多罗夫 西多尔 的电话号码是 7890123456

# 创建电话簿字典
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

# 遍历字典
for key, value in phonebook1.items():
    print(key, value)

伊万诺夫 伊万 1234567
彼得罗夫 彼得 89012345678
西多罗夫 西多尔 7890123456

# 创建电话簿字典
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

# 遍历字典中的键
for key in phonebook1.keys():
    print(key)

伊万诺夫 伊万
彼得罗夫 彼得
西多罗夫 西多尔

# 创建电话簿字典
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

# 遍历字典中的值
for value in phonebook1.values():
    print(value)

1234567
89012345678
7890123456

phonebook = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

del phonebook["伊万诺夫 伊万"]

print(phonebook)

{'彼得罗夫 彼得': 89012345678, '西多罗夫 西多尔': 7890123456}

phonebook = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

number = phonebook.pop("伊万诺夫 伊万")
print(phonebook)
print(number)

{'彼得罗夫 彼得': 89012345678, '西多罗夫 西多尔': 7890123456}
1234567

# 创建两个电话簿
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

phonebook2 = {
    "瓦西里耶夫 瓦西里": 9123456789,
    "普普金 普普金": 4567890123
}

# 更新电话簿 1
# 使用 update() 方法合并两个字典
phonebook1.update(phonebook2)

# 输出更新后的电话簿 1
print(phonebook1)

{'伊万诺夫 伊万': 1234567, '彼得罗夫 彼得': 89012345678, '西多罗夫 西多尔': 7890123456, '瓦西里耶夫 瓦西里': 9123456789, '普普金 普普金': 4567890123}

# 创建两个电话簿
phonebook1 = {
    "伊万诺夫 伊万": 1234567,
    "彼得罗夫 彼得": 89012345678,
    "西多罗夫 西多尔": 7890123456
}

phonebook0 = {
    "瓦西里耶夫 瓦西里": 9123456789,
    "普普金 普普金": 4567890123
}

# 创建新的电话簿 3
# 使用 ** 运算符合并两个字典
phonebook3 = {**phonebook1, **phonebook0}

# 输出新的电话簿 3
print(phonebook3)

{'伊万诺夫 伊万': 1234567, '彼得罗夫 彼得': 89012345678, '西多罗夫 西多尔': 7890123456, '瓦西里耶夫 瓦西里': 9123456789, '普普金 普普金': 4567890123}

# 创建两个字典
dict_1 = {
    "苹果": 7,
    "香蕉": 5
}

dict_2 = {
    "香蕉": 3,
    "橙子": 4
}

# 合并两个字典
# 使用 ** 运算符
combined_dict = {**dict_1, **dict_2}

# 输出合并后的字典
print(combined_dict)

{'苹果': 7, '香蕉': 3, '橙子': 4}

# 创建变量 sentence1，并为它赋值一个包含重复词语的字符串
sentence1 = "他的名字是谢苗，谢苗就是他的名字"
# 使用 split() 方法把字符串转换为单词列表
# 默认分隔符是空格，因此它会按词拆分字符串
words1 = sentence1.split()
# 为了便于观察，输出单词列表
# 输出应显示所有单词，包括重复项
print(words1)
# 将单词列表转换为集合，这会自动删除所有重复项
word_set1 = set(words1)
# 输出单词集合，以便看到重复项已经被删除
print(word_set1)

['他的名字是谢苗，谢苗就是他的名字']
{'他的名字是谢苗，谢苗就是他的名字'}

# 定义第一个单词集合
word_set1 = {'hello', 'world', 'name', 'is', 'first', 'python', 'and'}
# 定义第二个单词集合
word_set2 = {'this', 'is', 'a', 'test', 'name', 'first', 'and'}
# 使用 intersection() 方法求两个集合之间的交集。
# 集合交集返回一个新集合，其中包含所有同时出现在两个原始集合中的元素。
common_elements = word_set1.intersection(word_set2)

# 将集合中的公共元素输出到屏幕
print(common_elements)  # 将输出包含公共元素的集合

{'name', 'is', 'and', 'first'}

# 定义两个包含不同单词的集合
word_set1 = {'hello', 'his', 'Her', 'His', '娜斯佳'}
word_set2 = {'hello', 'Her', 'her', '安娜'}
# 获取并输出 word_set1 中存在、但 word_set2 中不存在的单词
# 预期输出：{'his', 'His', '娜斯佳'}
print(word_set1.difference(word_set2))

{'his', 'His', '娜斯佳'}

# 输出 word_set1 与 word_set2 之间的对称差集
# 预期输出：{'his', 'His', 'her', '安娜', '娜斯佳'}
print(word_set1.symmetric_difference(word_set2))

{'his', 'His', 'her', '安娜', '娜斯佳'}

# 创建两个单词列表
words1 = ['hello', 'his', 'Her', 'His', '娜斯佳']
words2 = ['hello', 'Her', 'her', '安娜']
# 尝试使用 intersection 方法会导致错误，因为列表没有这种方法
# 如果取消下面代码的注释，将会引发 AttributeError：
# print(words1.intersection(words2))  # AttributeError: 'list' 对象没有属性 'intersection'

# 创建两个包含唯一单词的集合
word_set1 = {'hello', 'his', 'Her', 'His', '娜斯佳'}
word_set2 = {'hello', 'Her', 'her', '安娜'}
# 输出集合 word_set1 与 word_set2 的差集。
# difference 方法返回一个集合，其中包含 word_set1 中存在、但 word_set2 中不存在的元素。
# 预期输出：{'his', 'His', '娜斯佳'}
print('word_set1 和 word_set2 的差集：', word_set1.difference(word_set2))
# 输出集合 word_set1 与 word_set2 的对称差集。
# symmetric_difference 方法返回一个集合，其中包含只存在于其中一个集合中的元素。
# 预期输出：{'his', 'His', 'her', '安娜', '娜斯佳'}
print('word_set1 和 word_set2 的对称差集：', word_set1.symmetric_difference(word_set2))

# Python 中的列表不直接支持集合操作，因此不能直接使用 intersection 这类方法。
# 但是，可以把列表转换为集合，执行操作，然后在需要时把结果转换回列表。
# 创建两个单词列表
words1 = ['hello', 'his', 'Her', 'His', '娜斯佳']
words2 = ['hello', 'Her', 'her', '安娜']
# 将列表转换为集合，并求它们的对称差集
# 然后再把结果转换回列表
sym_diff_list = list(set(words1).symmetric_difference(set(words2)))
# 输出列表对称差集的结果
# 预期输出：['his', 'His', 'her', '安娜', '娜斯佳']
print('列表 words1 和 words2 的对称差集：', sym_diff_list)

word_set1 和 word_set2 的差集： {'His', 'his', '娜斯佳'}
word_set1 和 word_set2 的对称差集： {'娜斯佳', '安娜', 'His', 'his', 'her'}
列表 words1 和 words2 的对称差集： ['娜斯佳', '安娜', 'His', 'his', 'her']

==   等于
!=   不等于
<    小于
<=   小于或等于
>    大于
>=   大于或等于

# 给变量 x 赋值 2
x = 2

# 将 x 与 2 比较，预期得到 True，因为 x 的确等于 2
print(x == 2)  # 结果：True

# 将 x 与 3 比较，预期得到 False，因为 x 不等于 3
print(x == 3)  # 结果：False

# 检查 x 是否小于 3，预期得到 True，因为 2 小于 3
print(x < 3)   # 结果：True

# 给变量 x 赋值 2
x = 2

# 检查 x 是否等于 2
if x == 2:
    # 如果条件为真，输出消息“x 等于 2！”
    print("x 等于 2！")  # 预期输出：x 等于 2！
else:
    # 如果条件为假，输出消息“x 不等于 2。”
    print("x 不等于 2。")  # 由于条件为真，这行代码不会执行

# 声明两个字符串变量
name1, name2 = "萨沙", "廖沙"

# 创建包含姓名的列表 groupA
groupA = ["萨沙", "玛莎"]

# 检查 name1（萨沙）是否在 groupA 列表中
if name1 in groupA:
    print(name1, "在 A 组中找到")

# 检查 name2（廖沙）是否在 groupA 列表中
if name2 in groupA:
    print(name2, "在 A 组中找到")
else:
    # 如果在 groupA 中没有找到 name2（廖沙），则执行 else 分支
    print(name2, "未在 A 组中找到")

# 再添加一个姓名用于演示
name3 = "列娜"

# 检查 name3（列娜）是否在 groupA 列表中
if name3 in groupA:
    print(name3, "在 A 组中找到")
else:
    # 如果在 groupA 中没有找到 name3（列娜），则执行 else 分支
    print(name3, "未在 A 组中找到")

萨沙 在 A 组中找到
廖沙 未在 A 组中找到
列娜 未在 A 组中找到

x, y = ['a', 'b'], ['a', 'b']
z = y  # 将 z 赋值为与 y 指向同一对象的引用

print(x == y, ' x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 True，因为 x 和 y 中的值相等

print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 False，因为 x 和 y 是不同对象（ID 不同）

print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z)))
# 输出 True，因为 y 和 z 引用同一个对象

# 修改列表 y 中的第二个元素
y[1] = 'x'

print('修改 y 中的一个值之后')
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 False，因为现在二者的值不再相等

print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 False，因为 x 和 y 是不同对象

print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z)))
# 输出 True，因为 y 和 z 仍然引用同一个对象

# 将列表 x 添加到列表 y 中
y.append(x)

print('将列表 x 添加到列表 y 之后')
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 False，因为 x 和 y 的值不同

print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 False，因为 x 和 y 是不同对象

print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z)))
# 输出 True，因为 y 和 z 仍然引用同一个对象

True  x= ['a', 'b'] y= ['a', 'b'] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'b'] 0x100a77300 0x100b07c80
True  y= ['a', 'b'] z= ['a', 'b'] 0x100b07c80 0x100b07c80
修改 y 中的一个值之后
False x= ['a', 'b'] y= ['a', 'x'] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'x'] 0x100a77300 0x100b07c80
True  y= ['a', 'x'] z= ['a', 'x'] 0x100b07c80 0x100b07c80
将列表 x 添加到列表 y 之后
False x= ['a', 'b'] y= ['a', 'x', ['a', 'b']] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'x', ['a', 'b']] 0x100a77300 0x100b07c80
True  y= ['a', 'x', ['a', 'b']] z= ['a', 'x', ['a', 'b']] 0x100b07c80 0x100b07c80

# 示例 1：简单使用 not
print(not False)  # 输出 True，因为 not 将 False 反转为 True

# 示例 2：使用 not 进行比较
print(not False == False)  # 输出 False，等价于表达式 True == False

# 示例 3：将 not 与 == 和 is 运算符结合使用
x, y = [1, 2, 3], [1, 2, 3]
z = y  # 将 z 赋值为与 y 指向同一对象的引用

# 比较列表的值
# 使用 == 运算符检查两个列表中的值是否相等
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 True，因为列表 x 和 y 中的值相同，虽然它们是不同对象

# 使用 is not 比较对象身份
# 使用 is not 检查变量是否指向不同对象
print(x is not y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# 输出 True，因为 x 和 y 虽然值相同，但它们是不同对象

# 使用 is 检查对象身份
print(y is z, 'y=', y, 'z=', z, hex(id(y)), hex(id(z)))
# 输出 True，因为 y 和 z 指向同一个对象

True
False
True x= [1, 2, 3] y= [1, 2, 3] 0x104b5b300 0x104bebc80
True x= [1, 2, 3] y= [1, 2, 3] 0x104b5b300 0x104bebc80
True y= [1, 2, 3] z= [1, 2, 3] 0x104bebc80 0x104bebc80

# 设置舒适温度，单位为摄氏度
temp_good = 22.0

# 当前温度；可以修改该值进行实验
temp_now1 = 48.0

# 为不同温度状态定义条件
statement1 = (temp_now1 <= (temp_good + 10.0)) & (temp_now1 >= (temp_good - 10.0))  # 舒适
statement2 = temp_now1 < (temp_good - 10.0)  # 寒冷
statement3 = temp_now1 > (temp_good + 10.0)  # 炎热

# 使用条件语句输出相应消息
if statement1:  # 不要忘记冒号
    print("好，现在是", temp_now1, "摄氏度。很舒适。我们走吧。")
    pass  # 这里可以添加其他操作

elif statement2:  # 不要忘记冒号
    print("不行，现在是", temp_now1, "摄氏度。太冷了。我们不能走。")
    pass  # 这里可以添加其他操作

elif statement3:
    print("不行，现在是", temp_now1, "摄氏度。太热了。我们不能走。")
    pass  # 这里可以添加其他操作

else:
    print("让我们检查一下温度。")  # 执行其他操作
    pass

不行，现在是 48.0 摄氏度。太热了。我们不能走。

for variable in sequence:
    # 要执行的代码块

for element in [1, 2, 3, 4, 5]:
    print(element)

for number in range(10):
    print(number)

primes = [2, 3, 5]  # 定义一个质数列表

for prime in primes:  # 遍历质数列表
    print(prime, end=' ')  # 在同一行输出每个质数

print('\nrange(10) 中的元素是')
for n in range(10):  # 创建从 0 到 9 的范围
    print(n, end=',')  # 在同一行输出每个数字，并用逗号分隔

print('\nrange(3, 8) 中的元素是')
for n in range(3, 8):  # 创建从 3 到 7 的范围
    print(n, end=',')

print('\nrange(3, 10, 2) 中的元素是')
for n in range(-3, 10, 2):  # 创建从 -3 到 9、步长为 2 的范围
    print(n, end=',')

print('\nrange(10, -3, -2) 中的元素是')
for n in range(10, -3, -2):  # 创建从 10 到 -2、步长为 -2 的反向范围
    print(n, end=',')

2 3 5
range(10) 中的元素是
0,1,2,3,4,5,6,7,8,9,
range(3, 8) 中的元素是
3,4,5,6,7,
range(3, 10, 2) 中的元素是
-3,-1,1,3,5,7,9,
range(10, -3, -2) 中的元素是
10,8,6,4,2,0,-2,

while condition:
    # 要执行的代码块

while limit_not_reached:
    # 执行一些操作

while True:
    # 执行操作
    if exit_condition:
        break

# 初始化计数器
count = 0

# 只要 count 小于 10，循环就继续执行
while count < 10:
    print(count, end=',')
    count += 1  # 等价于 count = count + 1

0,1,2,3,4,5,6,7,8,9,

# 输出所有数字，直到达到给定限制
count = 0

while True:
    print(count, end=',')
    count += 1

    if count >= 10:  # 如果达到限制，就中断循环
        break

print('\n')  # 循环结束后换行

0,1,2,3,4,5,6,7,8,9,

# 只输出偶数：0, 2, 4, 6, 8
for n in range(10):
    if n % 2 != 0:  # 如果数字是奇数，就跳过它
        continue

    print(n, end=',')

0,2,4,6,8,

# 输出从 0 到 4 的数字，然后输出达到限制的消息
count = 0
nlimit = 5

while count < nlimit:
    print(count, end=',')
    count += 1
else:
    print("计数器的值已达到 %d" % (nlimit))

0,1,2,3,4,计数器的值已达到 5

if condition:
    variable = value_1
else:
    variable = value_2

variable = value_1 if condition else value_2

# 定义用于演示的变量
value_1 = "条件为真时的值"
value_2 = "条件为假时的值"

# 定义要检查的条件
# 本例中，条件检查数字是否为偶数
number = 10  # 可以修改该值，以检查不同条件

# 使用三元条件运算符为变量 result 赋值
# 如果 number 是偶数（number % 2 等于 0），就赋值 value_1；否则赋值 value_2
result = value_1 if number % 2 == 0 else value_2

# 输出结果
# 如果数字为偶数，就输出 value_1；如果为奇数，就输出 value_2
print(result)

条件为真时的值

def hi():
    # 在屏幕上输出问候消息
    print("你好，欢迎使用这个简单函数！")

# 调用问候函数
hi()

你好，欢迎使用这个简单函数！

# 定义一个带两个参数的函数：username 和 greeting
def greeting_student(username, greeting):
    # 使用 f 字符串插入变量，输出问候消息
    print(f"你好，{username}，祝贺你！祝你{greeting}")

# 调用函数，并传递两个字符串参数
greeting_student("斯乔帕", "在函数使用中开启一段有趣旅程！")

你好，斯乔帕，祝贺你！祝你在函数使用中开启一段有趣旅程！

# 定义一个对两个数求和的函数
def sum_two_numbers(a, b):
    return a + b  # 返回函数两个参数的和

# 给两个变量赋值，并调用函数求和
x, y = 2.0, 8.0

apb = sum_two_numbers(x, y)
print(f'{x} + {y} = {apb}')  # 输出结果："2.0 + 8.0 = 10.0"

# 修改变量值，并再次调用函数
x, y = 20, 80

apb = sum_two_numbers(x, y)
print(f'{x} + {y} = {apb}, 太好了！')  # 输出结果："20 + 80 = 100, 太好了！"

2.0 + 8.0 = 10.0
20 + 80 = 100, 太好了！

# 定义一个函数，在函数内部局部修改参数值
def sum_two_numbers(a, b):
    a += 1  # 在局部把参数 a 的值增加 1
    print('函数内部，a=', a)  # 输出 a 的局部值
    return a + b  # 返回修改后的 a 与 b 的和

x, y = 2.0, 8.0

print('调用函数之前，x=', x, 'y=', y)  # 输出调用函数之前 x 和 y 的值
apb = sum_two_numbers(x, y)           # 调用函数并保存结果
print('调用函数之后，%f + %f = %f' % (x, y, apb))  # 输出调用函数之后的结果

调用函数之前，x= 2.0 y= 8.0
函数内部，a= 3.0
调用函数之后，2.000000 + 8.000000 = 11.000000

result = (lambda x, y: x + y)(10, 20)
print(result)

30

linear_function = lambda x, a, b: a * x + b
print("线性函数：f(x) = 2x + 3，当 x=5 时给出", linear_function(5, 2, 3))

线性函数：f(x) = 2x + 3，当 x=5 时给出 13

quadratic_function = lambda x, a, b, c: a * x**2 + b * x + c
print("二次函数：f(x) = 2x^2 + 3x + 1，当 x=2 时给出", quadratic_function(2, 2, 3, 1))

二次函数：f(x) = 2x^2 + 3x + 1，当 x=2 时给出 15

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print("数字的平方：", squared_numbers)  # 输出：[1, 4, 9, 16, 25]

数字的平方： [1, 4, 9, 16, 25]

class C:
    ''' 名为 C 的最简单类 '''

    ca = "类属性"  # 定义类属性

# 使用 help() 函数获取类 C 的信息
help(C)

# 创建类 C 的两个实例
i1 = C()  # 创建类 C 的实例 i1
i2 = C()  # 创建类 C 的实例 i2

# 演示通过实例和类本身访问类属性
print('i1.ca =', i1.ca)  # 通过实例 i1 访问类属性
print('i2.ca =', i2.ca)  # 通过实例 i2 访问类属性
print('C.ca =', C.ca)    # 直接通过类本身访问类属性

# 修改类属性，并观察它对实例的影响
C.ca = "这是被修改后的类属性 'ca'"
print('修改之后：')
print('C.ca =', C.ca)    # 显示类属性修改后的值
print('i1.ca =', i1.ca)  # 实例 i1 反映类属性的变化
print('i2.ca =', i2.ca)  # 实例 i2 反映类属性的变化

class C:
    ca = "类属性 'ca' 的初始值"

# 创建类 C 的实例
i1 = C()
i2 = C()

# 修改类属性 ca
C.ca = "类属性 'ca' 的第 2 次修改"

# 输出类 C 的字典
print("类 C 的字典：", C.__dict__)

# 修改 i1 的实例属性 ca
i1.ca = "这是被修改后的实例属性 'ca'"

# 输出实例 i1 的字典
print("实例 i1 的字典：", i1.__dict__)

# 输出实例 i2 修改之前的字典
print("实例 i2 修改前的字典：", i2.__dict__)

# 修改 i2 的实例属性 ca
i2.ca = "现在修改实例属性 'ca'"

# 输出实例 i2 修改之后的字典
print("实例 i2 修改后的字典：", i2.__dict__)

类 C 的字典： {'__module__': '__main__', 'ca': "类属性 'ca' 的第 2 次修改", '__dict__': <attribute '__dict__' of 'C' objects>, '__weakref__': <attribute '__weakref__' of 'C' objects>, '__doc__': None}
实例 i1 的字典： {'ca': "这是被修改后的实例属性 'ca'"}
实例 i2 修改前的字典： {}
实例 i2 修改后的字典： {'ca': "现在修改实例属性 'ca'"}

class Circle:
    """
    Circle 类用于执行与圆有关的计算。

    具体来说，它可以根据给定半径计算圆的面积。
    """

    pi = 3.14159  # 类属性，包含所有类实例都会使用的圆周率值

    def __init__(self, radius):
        """
        类构造函数，用给定半径初始化 Circle 类的新实例。

        :param radius: 圆的半径
        """
        self.radius = radius  # 实例属性，保存圆的半径

    def circle_area(self):
        """
        用于计算圆面积的方法。

        :return: 圆的面积
        """
        return self.pi * self.radius**2  # 使用公式 πr² 返回圆面积

# 创建半径为 10 的 Circle 类实例
r = 10
c10 = Circle(r)

# 输出初始值
print('修改前的 Circle.pi：', Circle.pi)
print('半径：', c10.radius)
print('修改前的 c10.pi：', c10.pi)

# 只修改实例 c10 的 pi 值
c10.pi = 3.14

# 输出修改后的值
print('通过 c10.pi 修改后的 c10.pi：', c10.pi)
print('通过 c10.pi 修改后的 Circle.pi：', Circle.pi)
print('c10 的圆面积 =', c10.circle_area())
print('半径为 100 的圆面积 =', Circle(100).circle_area())

修改前的 Circle.pi： 3.14159
半径： 10
修改前的 c10.pi： 3.14159
通过 c10.pi 修改后的 c10.pi： 3.14
通过 c10.pi 修改后的 Circle.pi： 3.14159
c10 的圆面积 = 314.0
半径为 100 的圆面积 = 31415.899999999998

class PartialCircle(Circle):
    ''' 基于 Circle 类的 PartialCircle 子类：计算圆扇形的面积。 '''

    def __init__(self, radius, portion):
        ''' 用 radius 和 portion 两个属性初始化。 '''
        super().__init__(radius)  # 从基类 Circle 继承属性
        self.portion = portion    # 子类属性，定义圆的比例

    def sector_area(self):
        ''' 计算圆扇形面积。 '''
        return self.portion * self.circle_area()  # 使用基类方法计算圆面积

pc10 = PartialCircle(10., 0.5)  # 创建子类对象实例，半径为 10，占圆的 50%

print(pc10.pi)             # 使用来自基类的属性
print(pc10.radius)         # 同样是来自基类的属性
print(pc10.sector_area())  # 计算 50% 圆扇形的面积

pc10.pi = 3.14
print(pc10.pi)  # 值已改为 3.14

print(c10.pi)  # 值保持不变。对子类实例的修改不会影响基类。

# 定义基类 Circle
class Circle:
    ''' Circle 类用于表示圆并计算圆面积。 '''

    def __init__(self, radius):
        ''' 使用一个属性 radius（半径）初始化类实例。 '''
        self.radius = radius  # 实例属性，保存圆半径
        self.pi = 3.14159     # 属性，保存 π 的值

    def circle_area(self):
        ''' 用于计算圆面积的方法。 '''
        return self.pi * (self.radius ** 2)  # 按公式 πr² 返回圆面积

# 定义继承 Circle 的子类 PartialCircle
class PartialCircle(Circle):
    ''' 基于 Circle 类的 PartialCircle 子类：计算圆扇形的面积。 '''

    def __init__(self, radius, portion):
        ''' 用 radius 和 portion（圆的比例）两个属性初始化。 '''
        super().__init__(radius)  # 调用基类初始化器来设置半径
        self.portion = portion    # 子类属性，定义需要计算面积的圆的比例

    def sector_area(self):
        ''' 计算圆扇形面积。 '''
        return self.portion * super().circle_area()  # 使用基类方法计算圆面积，并乘以比例

# 创建基类 Circle 的实例
c10 = Circle(10)  # 半径为 10 的 Circle 类实例
print("圆面积：", c10.circle_area())  # 计算并输出圆面积

# 创建子类 PartialCircle 的实例
pc10 = PartialCircle(10, 0.5)  # 半径为 10、比例为 50% 的 PartialCircle 类实例
print("50% 圆扇形面积：", pc10.sector_area())  # 计算并输出扇形面积

# 通过子类实例修改 π 的值
pc10.pi = 3.14
print("子类中的 pi 修改值：", pc10.pi)

# 检查基类中的 π 值是否发生变化
print("基类中的 pi 值：", c10.pi)  # 基类中的 π 值保持不变

圆面积： 314.159
50% 圆扇形面积： 157.0795
子类中的 pi 修改值： 3.14
基类中的 pi 值： 3.14159

import numpy as np  # 导入 numpy 模块，并给它指定别名 np

x1 = np.array([28, 3, 28, 0])  # 创建一维 NumPy 数组
print('x1=', x1)               # 输出数组 x1
# NumPy 数组看起来与列表相似

x1= [28  3 28  0]

import numpy as np

# 导入 numpy 模块，并给它指定别名 np
x2 = np.array([[51, 22.0], [0, 0], (18 + 9j, 3.)])  # 混合类型
# 创建一个包含三行两列的数组 x2。前两行包含整数，第三行包含复数和实数。

print('x2=', x2)  # 所有元素都会变成复数
# 输出数组 x2。由于数组中存在复数，数组中的所有数字都会转换为复数。

x2= [[51.+0.j 22.+0.j]
 [ 0.+0.j  0.+0.j]
 [18.+9.j  3.+0.j]]

# 人的体重列表（单位：kg）
list_w = [57.5, 64.3, 71.6, 68.2]
# 人的身高列表（单位：m）
list_h = [1.5, 1.6, 1.7, 1.65]
# 输出体重列表
print('人的体重：', list_w)
# 输出身高列表
print('人的身高：', list_h)

人的体重： [57.5, 64.3, 71.6, 68.2]
人的身高： [1.5, 1.6, 1.7, 1.65]

# 导入 NumPy 库
import numpy as np

# 声明人的体重和身高列表
list_w = [57.5, 64.3, 71.6, 68.2]
list_h = [1.5, 1.6, 1.7, 1.65]

# 将列表转换为 NumPy 数组
narray_w = np.array(list_w)
narray_h = np.array(list_h)

# 输出数组
print('体重数组：', narray_w)
print('身高数组：', narray_h)

体重数组： [57.5 64.3 71.6 68.2]
身高数组： [1.5  1.6  1.7  1.65]

def getArrayInfo(a):
    """获取给定数组的信息：getArrayInfo(array)"""

    # 打印数组第一轴上的元素
    print('数组第一轴上的元素：', a[0])
    # 打印数组类型
    print('类型：', type(a))
    # 打印数组维数
    print('维数，a.ndim：', a.ndim)
    # 打印数组形状（每条轴上的尺寸）
    print('数组形状，a.shape：', a.shape)
    # 打印数组中的元素总数
    print('元素个数，a.size：', a.size)
    # 打印数组元素的数据类型
    print('元素数据类型，a.dtype：', a.dtype)
    # 打印存储数组的内存地址（调试信息）
    print('内存地址：', a.data)

narray_w = np.array([57.5, 64.3, 71.6, 78.9])
getArrayInfo(narray_w)

数组第一轴上的元素： 57.5
类型： <class 'numpy.ndarray'>
维数，a.ndim： 1
数组形状，a.shape： (4,)
元素个数，a.size： 4
元素数据类型，a.dtype： float64
内存地址： <memory at 0x102f5a680>

import numpy as np

list_w = [57.5, 64.3, 71.6, 68.2]
list_h = [1.5, 1.6, 1.7, 1.65]
narray_w = np.array([57.5, 64.3, 71.6, 78.9])

print(list_w[1:3])    # 第二个和第三个元素之间的切片
print(narray_w[1:3])  # 第二个和第三个元素之间的切片

[64.3, 71.6]
[64.3 71.6]

list_w.append(59.8)
print(list_w)

# 对于 NumPy 数组，我们使用：
print(np.append(narray_w, 59.8))

[57.5, 64.3, 71.6, 68.2, 59.8]
[57.5 64.3 71.6 78.9 59.8]

print(list_w, ', ', narray_w)
print(type(list_w), ', ', type(narray_w))
print(len(list_w), ', ', narray_w.ndim)  # 使用 len() 获取长度

[57.5, 64.3, 71.6, 68.2, 59.8] ,  [57.5 64.3 71.6 78.9]
<class 'list'> ,  <class 'numpy.ndarray'>
5 ,  1

nwh = (narray_w, narray_h)  # 这会形成一个由 NumPy 数组组成的元组
print(nwh)
# (array([57.5, 64.3, 71.6, 68.2]), array([1.5, 1.6, 1.7, 1.65]))

# 为了形成多维数组，可以使用如下方式（后面会更详细讨论）：
arr = np.array([narray_w, narray_h])
# array([[57.5, 64.3, 71.6, 68.2 ],
#        [ 1.5,  1.6,  1.7,  1.65]])

import numpy as np

# 原始数组
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [ 1.5,  1.6,  1.7,  1.65]])

# 数组转置
arrT = arr.T

# 输出转置后的数组
print(arrT)

[[57.5   1.5 ]
 [64.3   1.6 ]
 [71.6   1.7 ]
 [68.2   1.65]]

import numpy as np

# 创建一个包含两行四列的 NumPy 数组
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# 创建第二个变量，它引用同一个数组
arrb = arr

# 输出 arrb 的内容
print(arrb)

# 修改 arr 的第一个元素
arr[0, 0] = 888.0

# 再次输出 arrb 的内容，可以看到它也发生了变化
print(arrb)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
[[888.    64.3   71.6   68.2 ]
 [  1.5    1.6    1.7    1.65]]

arrc = arr.copy()

import numpy as np

# 创建二维数组
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# 尝试通过赋值创建“副本”
arrc = arr

# 创建数组的独立副本
arrc = arr.copy()

# 修改原始数组中的元素
arr[0, 0] = 77.0

# 输出两个数组以进行比较
print('arr:', arr)
print('arrc:', arrc)

import numpy as np  # 以别名 np 导入 NumPy 库

# 使用 np.array 函数创建二维数组 arr
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# 使用 copy 方法创建数组 arr 的独立副本
arrc = arr.copy()

# 输出数组 arrc 的内容
print('arrc', arrc)

# 将数组 arr 中位置 [0, 0] 的元素改为 77.0
arr[0, 0] = 77.0

# 输出修改后的数组 arr
print('arr', arr)

# 输出数组 arrc，以显示它没有发生变化
print('arrc', arrc)

arrc [[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
arr [[77.   64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
arrc [[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]

np.stack(数组序列, axis=轴编号)

import numpy as np  # 以别名 np 导入 NumPy 库

# 用于合并的假定一维数组
narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])

# 沿轴 0 合并数组（纵向）
arr = np.stack([narray_w, narray_h], axis=0)

# 输出结果
print(arr)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]

import numpy as np  # 以别名 np 导入 NumPy 库

# 用于合并的假定一维数组
narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])

# 沿轴 0 合并数组（纵向）
arr = np.stack([narray_w, narray_h], axis=0)

# 输出原始二维数组
print(arr)

# 将二维数组转换为一维数组
rarr = np.ravel(arr)

# 输出结果
print(rarr)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
[57.5  64.3  71.6  68.2   1.5   1.6   1.7   1.65]

import numpy as np  # 以别名 np 导入 NumPy 库

# 假设我们有如下二维数组：
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [ 1.5,  1.6,  1.7,  1.65]])

# 输出原始数组，便于观察
print(arr)

# 按列对数组元素求和（axis=0）
column_sum = np.sum(arr, axis=0)
print('按列求和：', column_sum, column_sum.shape)

# 按行对数组元素求和（axis=1）
row_sum = np.sum(arr, axis=1)
print('按行求和：', row_sum, row_sum.shape)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
按列求和： [59.   65.9  73.3  69.85] (4,)
按行求和： [261.6    6.45] (2,)

list_w = [57.5, 64.3, 71.6, 68.2, 59.8]
list_h = [1.5, 1.6, 1.7, 1.65]

listwh = list_w + list_h
print('拼接后的列表：', listwh)

拼接后的列表： [57.5, 64.3, 71.6, 68.2, 59.8, 1.5, 1.6, 1.7, 1.65]

import numpy as np  # 以别名 np 导入 NumPy 库

narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])
narraywh = narray_w + narray_h
print('按元素相加后的数组：', narraywh)

按元素相加后的数组： [59.   65.9  73.3  69.85]

import numpy as np  # 以别名 np 导入 NumPy 库

weights_kg = np.array([57.5, 64.3, 71.6, 68.2])
weights_lbs = weights_kg * 2.20462
print('以磅为单位的重量：', weights_lbs)

以磅为单位的重量： [126.76565  141.757066 157.850792 150.355084]

import numpy as np

# 使用普通列表计算两个列表元素之和的示例
list1 = [20, 30, 40, 50, 60]
list2 = [4, 5, 6, 2, 8]
sum_lists = [x + y for x, y in zip(list1, list2)]
print('列表求和：', sum_lists)

# 现在使用 NumPy 数组执行相同的操作
sum_arrays = (np.array(list1) + np.array(list2)).tolist()
print('NumPy 数组求和：', sum_arrays)

列表求和： [24, 35, 46, 52, 68]
NumPy 数组求和： [24, 35, 46, 52, 68]

np.arange(2, 8, 0.5, dtype=float)

array([2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. , 7.5])

np.linspace(1., 4., 6)

array([1. , 1.6, 2.2, 2.8, 3.4, 4. ])

import numpy as np

a = np.array([1., 2., 3.])
a.fill(9.9)  # 用同一个值填充所有元素
print(a)

[9.9 9.9 9.9]

import numpy as np

x = np.empty((3, 4))  # 指定形状（维度）为 (3, 4)，不初始化取值
print(x)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

import numpy as np

x = np.zeros((6, 6))  # 用零初始化
print(x)

[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]

import numpy as np

y = np.ones((2, 2)) * 2  # 2×2 数组，所有元素先为 1.0，再乘以 2
print(y)

[[2. 2.]
 [2. 2.]]

import numpy as np  # 导入 NumPy 库

# 创建第一个 6×6 数组，并用零初始化
x = np.zeros((6, 6))
print("原始数组 x：")
print(x)

# 创建第二个 2×2 数组，并用一初始化
y = np.ones((2, 2))
print("\n数组 y：")
print(y)

# 将数组 y 的每个元素乘以 2
y *= 2
print("\n乘以 2 之后的数组 y：")
print(y)

# 把数组 y 赋值给数组 x 的一个切片。
# 这里选取第 3 行到第 5 行（不包括第 5 行），以及第 3 列到第 5 列（不包括第 5 列），
# 并把这个区域赋值为数组 y 的值。
x[3:5, 3:5] = y

print("\n把数组 y 赋值给切片之后的数组 x：")
print(x)

原始数组 x：
[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]

数组 y：
[[1. 1.]
 [1. 1.]]

乘以 2 之后的数组 y：
[[2. 2.]
 [2. 2.]]

把数组 y 赋值给切片之后的数组 x：
[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 2. 2. 0.]
 [0. 0. 0. 2. 2. 0.]
 [0. 0. 0. 0. 0. 0.]]

pip install tensorflow

import tensorflow as tf  # 为方便起见，将 TensorFlow 以别名 tf 导入

import tensorflow.experimental.numpy as tfnp  # 导入用于数组操作的模块

# 创建一个 3×4、用零填充的数组
x = tfnp.zeros((3, 4))  # 使用 zeros 函数创建由零填充的数组

# 将 TensorFlow NumPy 数组转换为标准 NumPy 数组，便于输出
x_np = x.numpy()  # 转换为标准 NumPy 数组

# 使用 NumPy 的标准输出格式显示数组
print(x_np)

# 输出数组大小（应为 12，因为是 3 行乘以 4 列）
print(tfnp.size(x))

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
12

import tensorflow as tf

y = tf.random.normal([3, 4], mean=0.0, stddev=1.0)

x = tf.exp(y)

y_transposed = tf.transpose(y)

result_matrix = tf.matmul(x, y_transposed)

import tensorflow as tf

# 用标准正态分布中的值初始化一个 3×4 张量
y = tf.random.normal([3, 4], mean=0.0, stddev=1.0)

# 输出张量 y 的值
print('y')
print(y.numpy())

# 对张量 y 的每个元素求指数
x = tf.exp(y)  # 计算 e 的 y 中每个元素次幂
print(x.numpy())

# 转置张量 y
y_transposed = tf.transpose(y)
print(y_transposed.numpy())

# 将张量 x 与转置后的张量 y 相乘
result_matrix = tf.matmul(x, y_transposed)  # 计算矩阵乘积
print(result_matrix.numpy())

y
[[ 0.71528995  2.1142166  -1.1875231  -0.16214192]
[-0.1809633  -0.21809964  1.1487513  -0.02445018]
[ 1.6564487   0.6891605   1.2565229   1.3516059 ]]
[[2.0447795  8.283093   0.30497572 0.8503205 ]
 [0.834466   0.8040453  3.1542516  0.9758463 ]
 [5.240667   1.9920425  3.5131845  3.863625  ]]
[[ 0.71528995 -0.1809633   1.6564487 ]
[ 2.1142166  -0.21809964  0.6891605 ]
 [-1.1875231   1.1487513   1.2565229 ]
 [-0.16214192 -0.02445018  1.3516059 ]]
[[18.474825  -1.847019  10.62796  ]
 [-1.6071612  3.273221   7.218715 ]
[ 3.161762   2.5584767 19.690228 ]]

# 导入必要的库
import tensorflow as tf  # 导入 TensorFlow，用于处理张量
import numpy as np       # 导入 NumPy，用于处理 np 数组

# 在 TensorFlow 中创建张量
x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)  # 创建 2×2 张量 x
y = tf.constant([[5, 6], [7, 8]], dtype=tf.float32)  # 创建 2×2 张量 y

# 将 TensorFlow 张量转换为 np 数组
x_np = x.numpy()  # 将张量 x 转换为 np 数组
y_np_transposed = tf.transpose(y).numpy()  # 转置张量 y 并转换为 np 数组

# 在 np 数组之间执行点积
result = np.dot(x_np, y_np_transposed)  # 计算 x_np 与 y_np_transposed 的点积

# 输出点积结果
print("x 与转置后的 y 的点积：")
print(result)

x 与转置后的 y 的点积：
[[17. 23.]
 [39. 53.]]

# 步骤 1：导入必要的库
# 导入 TensorFlow 和 NumPy
import tensorflow as tf
import numpy as np

# 步骤 2：使用 TensorFlow 张量
# 张量是 TensorFlow 中用于存储和处理数值数据的基本数据类型

# 创建一个大小为 3×4、以零初始化的张量
x = tf.Variable(tf.zeros((3, 4)))
print("未初始化张量 X：\n", x.numpy())

# 用正态分布中的随机值初始化另一个张量
y = tf.random.normal((3, 4))
print("含随机值的张量 Y：\n", y.numpy())

# 步骤 3：按元素运算
# 对张量 y 的所有元素执行指数运算
x_exp = tf.exp(y)
print("x_exp = e^y：\n", x_exp.numpy())

# 步骤 4：转置与矩阵乘法
# 转置张量 y
y_transposed = tf.transpose(y)
print("转置后的 Y：\n", y_transposed.numpy())

# 执行 x_exp 与转置后的 y 的矩阵乘法
result_matrix = tf.matmul(x_exp, y_transposed)
print("x_exp 与转置后的 Y 的矩阵乘法结果：\n", result_matrix.numpy())

# 步骤 5：与 NumPy 交互
# 将张量转换为 np 数组，以执行兼容 NumPy 的操作
x_np = x_exp.numpy()
y_np_transposed = y_transposed.numpy()

# 使用 NumPy 执行点积
np_result = np.dot(x_np, y_np_transposed)
print("使用 NumPy 计算的点积结果：\n", np_result)

未初始化张量 X：
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

含随机值的张量 Y：
[[ 0.4931968  -0.31107786  1.0522738  -0.91028893]
[ 0.7813833  -0.3026102  -1.2939718   0.28406715]
[ 0.6851111  -1.1481444  -0.64575064 -0.14548281]]

x_exp = e^y：
 [[1.6375427  0.73265684 2.864156   0.40240794]
 [2.1844919  0.7388871  0.27417964 1.3285221 ]
 [1.9839922  0.3172249  0.52426887 0.8646048 ]]

转置后的 Y：
[[ 0.4931968   0.7813833   0.6851111 ]
 [-0.31107786 -0.3026102  -1.1481444 ]
[ 1.0522738  -1.2939718  -0.64575064]
 [-0.91028893  0.28406715 -0.14548281]]

x_exp 与转置后的 Y 的矩阵乘法结果：
[[ 3.227286   -2.5339868  -1.6273712 ]
 [-0.07329397  1.5059394   0.27794188]
[ 0.6444511   1.0214796   0.53070307]]

使用 NumPy 计算的点积结果：
[[ 3.227286   -2.5339868  -1.6273712 ]
 [-0.07329397  1.5059394   0.27794188]
[ 0.6444511   1.0214796   0.53070307]]

import tensorflow as tf

# 在 TensorFlow 中创建两个变量
x = tf.Variable([1, 2, 3], dtype=tf.float32)
y = tf.Variable([4, 5, 6], dtype=tf.float32)

# 打印操作前对象的标识符
print('操作前 id(x)：', id(x))
print('操作前 id(y)：', id(y))

# 标准加法操作，会创建新的张量
temp_y = y + x  # 在 TensorFlow 中，这会创建一个新的张量
# 如果希望继续把 y 作为变量使用，需要用结果创建一个新的变量
y = tf.Variable(temp_y)
print('标准加法操作后的 id(y)：', id(y))

# 使用 assign_add 方法执行原地操作
y.assign_add(x)  # 这会把 x 原地加到 y 上，不改变 y 的标识符
print('使用 assign_add 进行原地操作后的 id(y)：', id(y))

# 使用 assign_add 模拟 += 的原地效果
x.assign_add(y)  # 这会把 y 原地加到 x 上
print('使用原地加法操作后的 id(x)：', id(x))

操作前 id(x)： 6079315920
操作前 id(y)： 6069364304
标准加法操作后的 id(y)： 6069363968
使用 assign_add 进行原地操作后的 id(y)： 6069363968
使用原地加法操作后的 id(x)： 6079315920

import numpy as np  # 导入 NumPy 库以处理数组

# 创建一个用于示例的二维浮点数组（矩阵）
x = np.array([
    [1.343, 3.358, 6.210, 6.438],
    [7.653, -2.504, 12.811, 1.550],
    [26.785, 0.124, 4.275, -2.182]
])

# 输出原始数组
print("原始数组 x：")
print(x)

# 从数组 x 中读取第二行和第三行
print("\n数组 x 的第二行和第三行：")
second_and_third_rows = x[1:3]  # 从第二行（索引 1）到第三行（索引 2）的切片
print(second_and_third_rows)

# 读取第二行中第二列到第三列的元素
print("\n第二行中第二列到第三列的元素：")
second_row_second_to_third_column = x[1:2, 1:3]  # 第二行以及索引为 1 和 2 的列
print(second_row_second_to_third_column)

# 将第二行第三列的值改为 88.0
x[1, 2] = 88.0  # 将索引为 [1, 2] 的元素赋值为 88.0

# 输出修改一个值后的数组
print("\n修改一个值后的数组 x：")
print(x)

# 将第二行中第二列到第三列的值都改为 88.0
x[1, 1:3] = 88.0  # 修改第二行中索引为 1 和 2 的列

# 输出修改切片值后的数组
print("\n修改一段切片值后的数组 x：")
print(x)

print(x)  # 为了直观显示，先输出整个数组
x[1:3]    # 获取第二行和第三行的切片

x[1:2, 1:3]  # 选择第二行以及索引从 1 到 2 的列切片

x[1, 2] = 88.0  # 为元素赋予新值
print(x)        # 输出修改后的数组

x[1:2, 1:3] = 88.0  # 一次为多个元素赋予新值
print(x)            # 输出更新后的数组

import numpy as np

# 创建一维数组 y
y = np.arange(6)
print('y = ', y, 'y 的形状：', y.shape)

# 创建一维数组 x 并改变其形状
x = np.arange(24).reshape((4, 6))
print('X = \n', x, 'X 的形状：', x.shape)

# 使用广播机制执行加法
result = x + y
print('X + y = \n', result)

# 以别名 np 导入 NumPy 库
import numpy as np

# 使用 arange 函数创建一维数组 y，该函数生成从 0 到 n-1 的数字序列
y = np.arange(6)

# 输出数组 y 及其形状
print('y = ', y, 'y 的形状：', y.shape)

# 创建与 y 相关长度的一维数组 x，但元素从 0 到 23
x = np.arange(24)

# 使用 reshape 方法改变数组 x 的形状，使其成为二维数组
# 维度为 4 行 6 列，这样就可以与数组 y 进行广播运算
x = x.reshape((4, 6))

# 输出数组 x 及其新的形状
print('X = \n', x, 'X 的形状：', x.shape)

# 执行 x 与 y 的加法。由于广播机制，y 会自动扩展到 x 的形状，
# 并进行按元素相加。
result = x + y

# 输出相加结果
print('X + y = \n', result)

# 导入 NumPy 库
import numpy as np

# 假设数组 X 和 y 已在前面定义
# 输出数组 X 和 y 的形状
print('X 的形状：', X.shape, 'y 的形状：', y.shape)

# 计算数组 X 和 y 的点积
# np.dot() 函数返回数组对应元素乘积之和
print(np.dot(X, y))

# 使用 np.reshape() 方法把数组 X 改变为三维数组 Z
# 参数 (2, 3, 4) 指定数组的新形状
Z = np.reshape(X, (2, 3, 4))

# 输出新的三维数组 Z
print(Z)

# 使用 arange 和 reshape 创建二维数组 a
# 数组中填入从 0 到 11 的连续数字，并改变形状为 (3, 4)
a = np.arange(12).reshape(3, 4)

# 使用 fill 方法将整个数组 a 填充为数值 100
a.fill(100)

# 输出填充后的数组 a
print(a)

# 假设数组 Z 已在前面定义为三维数组
# 数组 a 与 Z 相加，用于演示广播机制
# 数组 a 会扩展到数组 Z 的形状，并执行按元素相加
print(Z + a)

# 创建并填充一维数组 a
a = np.arange(4)
a.fill(100)

# 输出一维数组 a
print(a)

# 将一维数组 a 与三维数组 Z 相加
# 这里展示 NumPy 的广播能力：形状不同的数组可以通过自动扩展较小数组来相加
print(Z + a)

# 导入 NumPy 库
import numpy as np

# 创建一个包含从 0 到 5 的连续数字的一维数组 y
y = np.arange(6)

# 输出数组 y 的信息
print('y = ', y, 'y 的形状：', y.shape)

# 创建一个包含从 0 到 23 的连续数字的一维数组 x
x = np.arange(24)

# 将数组 x 改变形状为二维数组 (4, 6)
x = x.reshape((4, 6))

# 输出数组 x 的信息
print('x = ', x, 'x 的形状：', x.shape)

# 使用 np.dot 函数计算数组 x 和 y 的点积
# 需要注意，执行这种运算时数组的尺寸必须匹配
dot_product = np.dot(x, y)
print('x 和 y 的点积：', dot_product)

# 将数组 x 改变形状为三维数组 z，形状为 (2, 3, 4)
z = x.reshape((2, 3, 4))

# 输出三维数组 z
print('z =\n', z)

# 使用 arange 创建二维数组 a，并改变其形状为 (3, 4)
a = np.arange(12).reshape((3, 4))

# 将数组 a 填充为数值 100
a.fill(100)

# 输出填充后的二维数组 a
print('a =\n', a)

# 演示数组 a 与三维数组 z 相加时的广播机制
# 数组 a 会自动“扩展”到数组 z 的形状，以执行按元素相加
broadcasted_sum = z + a

# 输出相加结果
print('z 和 a 相加的结果：\n', broadcasted_sum)

# 创建一维数组 a，并用数值 100 填充
a = np.arange(4)
a.fill(100)

# 输出一维数组 a
print('a =', a)

# 将一维数组 a 与三维数组 z 相加
# NumPy 会自动“扩展”数组 a，以执行加法运算
broadcasted_sum = z + a

# 输出相加结果
print('z 和 a 相加的结果：\n', broadcasted_sum)

import numpy as np

# 示例 1：一维数组与二维数组相加
# 创建一维数组
one_d_array = np.array([1, 2, 3])

# 创建二维数组
two_d_array = np.array([
    [0, 0, 0],
    [10, 10, 10],
    [20, 20, 20],
    [30, 30, 30]
])

# 尽管两个数组形状不同，广播运算仍允许将它们相加
broadcasted_sum_1 = one_d_array + two_d_array
print("示例 1：一维数组与二维数组相加")
print(broadcasted_sum_1)

# 示例 2：两个长度不同的一维数组相加
# 创建一个只含一个元素的一维数组
single_element_array = np.array([100])

# 广播运算会“扩展”较小的数组，使其可以与 one_d_array 相加
broadcasted_sum_2 = single_element_array + one_d_array
print("\n示例 2：两个长度不同的一维数组相加")
print(broadcasted_sum_2)

# 示例 3：由一列组成的一维/二维列数组与二维数组相加
# 创建一个表示列的数组
column_array = np.array([[0], [10], [20], [30]])

# 广播运算会将这一列沿水平方向“扩展”，以便执行加法
broadcasted_sum_3 = column_array + one_d_array
print("\n示例 3：单列数组与二维数组相加")
print(broadcasted_sum_3)

# 以别名 np 导入 NumPy 库，用于处理数组
import numpy as np

# 导入 TensorFlow，用于处理张量和深度学习
import tensorflow as tf

# 创建一个包含 24 个数字的一维数组，从 0 到 23
x = np.arange(24)

# 将一维数组转换为尺寸为 4×6 的二维数组（矩阵）
x = x.reshape(4, 6)

# 输出 NumPy 矩阵 x 以进行检查
print("NumPy 矩阵 x：")
print(x)

# 将 NumPy 数组 x 转换为 TensorFlow 张量
tfx = tf.convert_to_tensor(x, dtype=tf.float32)

# 输出张量 tfx 以进行检查
print("\nTensorFlow 张量 tfx：")
print(tfx)

# 将 TensorFlow 张量转换回 NumPy 数组
npa = tfx.numpy()

# 检查 npa 是否确实为 NumPy 数组
print("\n转换回 NumPy 的数组 npa：")
print(npa)
print("npa 的类型：", type(npa))

NumPy 矩阵 x：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

TensorFlow 张量 tfx：
tf.Tensor(
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]], shape=(4, 6), dtype=float32)

转换回 NumPy 的数组 npa：
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
npa 的类型： <class 'numpy.ndarray'>

# 导入所需库
import numpy as np
import tensorflow as tf

# 创建包含从 0 到 23 的连续数字的 NumPy 数组
npa = np.arange(24).reshape(4, 6)  # 将数组形状改为 4×6

# 输出原始 NumPy 数组
print("原始 NumPy 数组：")
print(npa)

# 将 NumPy 数组转换为 TensorFlow 张量
tfy = tf.convert_to_tensor(npa, dtype=tf.float32)

# 输出 TensorFlow 张量
print("\n转换得到的 TensorFlow 张量：")
print(tfy)

# 将 TensorFlow 张量转换回 NumPy 数组
npa_from_tfy = tfy.numpy()

# 输出由 TensorFlow 张量得到的 NumPy 数组
print("\n转换回 NumPy 数组：")
print(npa_from_tfy)

# 为了检查原始数组与获得的 NumPy 数组是否相同，
# 可以使用 np.array_equal() 函数
print("\nNumPy 数组是否完全相同：", np.array_equal(npa, npa_from_tfy))

原始 NumPy 数组：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

转换得到的 TensorFlow 张量：
tf.Tensor(
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]], shape=(4, 6), dtype=float32)

转换回 NumPy 数组：
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]

NumPy 数组是否完全相同： True

print(bmi[bmi > 25])  # 只输出 BMI 大于 25 的值

[25.556 25.117 25.051]

import numpy as np  # 导入 NumPy 库

# 创建包含测试数据的 bmi 数组
# 为了演示，使用 20 到 30 之间的随机数
bmi = np.random.uniform(20, 30, 10)

# 输出原始 bmi 数组
print("原始 BMI 数组：", bmi)

# 使用布尔索引筛选大于 25 的值
# 其工作方式是创建一个布尔数组，在其中检查每个元素是否满足 > 25 的条件，
# 然后用这个布尔数组从原始数组中选择元素。
filtered_bmi = bmi[bmi > 25]

# 输出筛选后的值
print("筛选出的 BMI > 25 的值：", filtered_bmi)

import numpy as np  # 导入 NumPy 库

# 创建包含测试数据的 bmi 数组
# 为了演示，使用从 20 到 30 范围内的固定值数组
bmi = np.array([21.3, 24.5, 27.9, 30.1, 23.4, 25.6, 27.4, 22.0, 28.5, 26.1])

# 输出原始 bmi 数组
print("原始 BMI 数组：", bmi)

# 使用布尔索引筛选大于 25 的值
# 创建一个布尔数组，其中每个元素都被检查是否满足 > 25 的条件
# 这个布尔数组随后用于从原始数组中选择元素
filtered_bmi = bmi[bmi > 25]

# 输出筛选后的值
print("筛选出的 BMI > 25 的值：", filtered_bmi)

原始 BMI 数组： [21.3 24.5 27.9 30.1 23.4 25.6 27.4 22.  28.5 26.1]
筛选出的 BMI > 25 的值： [27.9 30.1 25.6 27.4 28.5 26.1]

import numpy as np  # 导入 NumPy 库

# 创建包含三个元素的一维数组
a = np.array([1, 2, 3])

# 打印数组、其形状、转置后的数组及其形状
# 对一维数组而言，转置不会改变数组形状
print("原始数组：", a)
print("原始数组的形状：", a.shape)
print("转置后的数组：", a.T)
print("转置后数组的形状：", a.T.shape)

# 添加一个新轴，将数组转换为二维数组
# 这样可以创建列向量
an = a[:, np.newaxis]

# 打印新的二维数组及其形状
print("\n二维列向量：", an)
print("列向量的形状：", an.shape)

# 现在可以对二维数组进行转置
# 转置会把列向量变成行向量
print("\n转置后的二维数组（行向量）：", an.T)
print("行向量的形状：", an.T.shape)

原始数组： [1 2 3]
原始数组的形状： (3,)
转置后的数组： [1 2 3]
转置后数组的形状： (3,)
二维列向量： [[1]
 [2]
 [3]]
列向量的形状： (3, 1)
转置后的二维数组（行向量）： [[1 2 3]]
行向量的形状： (1, 3)

a = np.array([1, 2, 3])

print(a, a.T, a.shape, a.T.shape)

an = a[:, np.newaxis]

print(an, an.shape)

print(an.T, an.T.shape)

import numpy as np

# 原始一维数组
a = np.array([1, 2, 3])

# 在数组 a 的末尾添加一个新维度
a1 = a.reshape(a.shape + (1,))
print(a1, a1.shape)  # 输出二维数组及其形状 (3, 1)

[[1]
 [2]
 [3]] (3, 1)

# 添加一个新维度，而不显式指定元素
aN = a[:, None]
print(aN, aN.shape)  # 与前面的输出类似：二维数组及其形状 (3, 1)

import numpy as np

# 在数组 a 的开头添加一个新轴
a0 = a[np.newaxis, :]
print(a0, a0.shape)  # 输出行向量形式的二维数组 (1, 3)

# 以别名 np 导入 NumPy 库
import numpy as np

# 创建包含三个元素的一维数组
a = np.array([1, 2, 3])

# 在数组 a 的末尾添加一个新维度，将其变为二维数组
# 这是通过 reshape 方法改变数组形状完成的
a1 = a.reshape(a.shape + (1,))

# 输出结果及得到的数组形状
# 预期输出：具有三行一列的二维数组
print("在数组末尾添加维度：")
print(a1, a1.shape)

# 使用对象 None 添加一个新维度
# 这等价于在数组末尾添加一个新轴
aN = a[:, None]

# 输出结果及得到的数组形状
# 预期输出：与前面类似，为具有三行一列的二维数组
print("\n使用 None 添加维度：")
print(aN, aN.shape)

# 使用 np.newaxis 在数组 a 的开头添加一个新轴
# 这会创建一个行向量
a0 = a[np.newaxis, :]

# 输出结果及得到的数组形状
# 预期输出：一行三列的二维数组，即行向量
print("\n在数组开头添加轴：")
print(a0, a0.shape)

在数组末尾添加维度：
[[1]
 [2]
 [3]] (3, 1)

使用 None 添加维度：
[[1]
 [2]
 [3]] (3, 1)

在数组开头添加轴：
[[1 2 3]] (1, 3)

# 以别名 np 导入 NumPy 库
import numpy as np

# 创建包含三个元素的一维数组
a = np.array([1, 2, 3])

# 使用对象 None 添加一个新维度
aN = a[:, None]
print("\n使用 None 添加维度：")
print(aN, aN.shape)

# 使用 np.newaxis 在数组 a 的开头添加一个新轴
a0 = a[np.newaxis, :]
print("\n在数组开头添加轴：")
print(a0, a0.shape)

# 应用一个创建汉克尔矩阵的小技巧：将 aN 与 a0 相加
# 这里使用 broadcasting，即 NumPy 允许对形状不同的数组执行算术运算的机制。
# 结果会得到一个汉克尔矩阵。
print("\n创建汉克尔矩阵的一个有趣技巧：")
hankel_matrix = aN + a0
print(hankel_matrix)

使用 None 添加维度：
[[1]
 [2]
 [3]] (3, 1)

在数组开头添加轴：
[[1 2 3]] (1, 3)

创建汉克尔矩阵的一个有趣技巧：
[[2 3 4]
 [3 4 5]
 [4 5 6]]

import numpy as np  # 用于处理数组的模块
import matplotlib.pyplot as plt  # 用于创建图形的模块

n = 80  # 点的数量
x = np.random.rand(n)  # 随机生成的 X 轴坐标
y = np.random.rand(n)  # 随机生成的 Y 轴坐标
colors = np.random.rand(n)  # 为每个点随机生成的颜色
areas = np.pi * (18 * np.random.rand(n))**2  # 随机生成的圆面积，半径范围约为 0 到 18

plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # 创建带有圆点的散点图
plt.show()  # 显示图形

# 导入所需库
import numpy as np  # 用于处理数组和执行数学运算
import matplotlib.pyplot as plt  # 用于数据可视化

# 生成用于图形的数据
n = 80  # 圆的数量
x = np.random.rand(n)  # 圆心的随机 X 坐标
y = np.random.rand(n)  # 圆心的随机 Y 坐标
colors = np.random.rand(n)  # 圆的随机颜色
areas = np.pi * (18 * np.random.rand(n))**2  # 圆的随机半径转换为面积

# 创建图形
plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # 使用 scatter 函数绘制圆
# 其中 x 和 y 是圆心坐标，s 是圆的大小（以面积给出），
# c 是圆的颜色，alpha 是圆的透明度。

plt.show()  # 显示图形

import numpy as np
import matplotlib.pyplot as plt

# 导入 numpy 库用于处理数组，导入 matplotlib.pyplot 用于数据可视化。
n = 80  # 要生成的点数

# 为 n 个点生成随机坐标。
x = np.random.rand(n)  # X 轴随机坐标
y = np.random.rand(n)  # Y 轴随机坐标

# 为点生成随机颜色和大小。
colors = np.random.rand(n)  # 每个点的随机颜色
areas = np.pi * (18 * np.random.rand(n))**2  # 点的随机大小，表示圆的面积

# 使用生成的数据创建散点图。
plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # 's' 表示大小，'c' 表示颜色，'alpha' 表示点的透明度
plt.show()  # 显示散点图

# 生成用于绘制曲线的数据。
x = range(1000)  # 生成从 0 到 999 的数列
y = [i ** 2 for i in x]  # 创建 y 值列表，其中每个值是对应 x 值的平方

# 绘制函数 y = x^2 的图形
plt.plot(x, y)  # 'plot' 用于绘制折线图
plt.show()  # 显示图形

# 生成用于直方图的数据。
x = np.linspace(0, 1, 1000)**1.5  # 在 0 到 1 之间创建 1000 个点，并将值提升到 1.5 次方以改变分布

# 绘制 x 值分布的直方图。
plt.hist(x)  # 'hist' 用于绘制直方图
plt.show()  # 显示直方图

import time
import numpy as np

# 创建一个大型整数列表
g = list(range(10_000_000))

# 将列表转换为数据类型为 float64 的 NumPy 数组
q = np.array(g, 'float64')

# 测量使用 Python 内置函数 sum 执行求和所需的时间
start = time.process_time()  # 记录开始时间
sg = sum(g)  # 对列表元素求和
t_elapsed = (time.process_time() - start)  # 计算耗时
print(f'总和：{sg}, 耗时：{t_elapsed}')

# 测量使用 np.sum 对 NumPy 数组执行求和所需的时间
start = time.process_time()  # 再次记录开始时间
sq = np.sum(q)  # 对 NumPy 数组元素求和
t_elapsed = (time.process_time() - start)  # 计算耗时
print(f'总和：{sq}, 耗时：{t_elapsed}')

# 使用 %%timeit 魔法命令自动测量单元格中代码的执行时间
# %%timeit
# sg = sum(g)  # 这一行展示如何在 Jupyter 等交互环境中使用 timeit

总和：49999995000000, 耗时：0.030974000000000057
总和：49999995000000.0, 耗时：0.006296999999999997