深度学习1—python基础
你的第一个程序
print('hello world and hello deep learning!')
基本数据结构
空值 (None)：在 Python 中，
None是一个特殊的对象，用于表示空值或缺失的值。它不同于数字 0，因为 0 是一个有意义的数字，而None表示没有值或无值的状态。例如：x = None print(x) # 输出: None变量：变量是程序中用来存储数据的名字。在 Python 中，变量名可以包含字母、数字和下划线，但不能以数字开头。变量的值可以在程序运行过程中改变（动态类型语言）。例如：
print(x) # 输出: 10 x = x + 2 print(x) # 输出: 12整数 (int)：Python 支持任意大小的整数，不会像某些语言一样有固定的大小限制。整数包括正数、负数和零。您可以像数学中一样使用整数，例如
3或-1等。您还可以使用type()函数来查看变量的数据类型：a = 3 print(a) print(type(a)) # 输出: <class 'int'>
4.浮点数
浮点数（float） 是用来表示带有小数部分的数值。浮点数可以是正数、负数，也可以用科学计数法表示极大或极小的数值。
浮点数的表示方式包括：
- 普通小数表示：例如
1.23、3.24、-9.01 - 科学计数法：使用
e（或E）来表示 10 的幂，例如：1.23e9表示 1.23×1091.23×109，即1230000000.01.2e-2表示 1.2×10−21.2×10−2，即0.012
# 普通浮点数
a = 1.23
b = -9.01
print(a, b) # 输出: 1.23 -9.01
# 科学计数法
c = 1.23e9 # 1.23 × 10^9
d = 1.2e-2 # 1.2 × 10^-2
print(c) # 输出: 1230000000.0
print(d) # 输出: 0.012
# 检查数据类型
print(type(a)) # 输出: <class 'float'>
print(type(c)) # 输出: <class 'float'>
浮点数精度问题
由于计算机采用二进制存储浮点数，某些浮点运算可能会出现精度丢失的情况。例如：
print(0.1 + 0.2) # 输出: 0.30000000000000004
如果需要更精确的计算，可以使用 decimal 模块：
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2')) # 输出: 0.3
在 Python 中，字符串（str） 是由单引号（'） 或 双引号（"） 括起来的文本序列。字符串是不可变的，即字符串一旦创建就不能修改其中的字符。
5. 字符串
s = 'abc'
print(s) # 输出: abc
print(len(s)) # 输出: 3 （计算字符串长度）
字符串中包含单引号（'）或双引号（"）
如果字符串本身包含 ' 或 "，可以使用转义字符 \，或者使用不同类型的引号包围字符串：
print('I\'m\"oK\"")(每有1个'或"就有一个\)
输出：
I'm "OK"
访问字符串中的字符
字符串可以像列表一样使用索引访问：
name = "wang"
print(name) # 输出: wang
print(name[3]) # 输出: g
6.布尔值
布尔值通常用于逻辑判断、条件语句 和 循环控制，例如：
t = True
f = False
print(type(t)) # 输出: <class 'bool'>
print(t) # 输出: True
print(f) # 输出: False
容器
列表（List）
列表（List） 是 Python 中最常用的数据类型之一，它是有序、可变（可修改）、可以包含不同类型元素的集合。
1. 列表的基本使用
list1 = [1.4, "hello", 1, 3]
print(list1) # 输出整个列表: [1.4, 'hello', 1, 3]
print(list1[3]) # 获取索引 3（第四个元素）: 3
print(list1[-2]) # 倒数第二个元素: 1
2. 列表的索引与切片
- 索引（Index）：列表的索引从
0开始，list1[0]是第一个元素。 - 负索引（Negative Index）：
-1代表最后一个元素，-2代表倒数第二个元素。 - 切片（Slicing）：可以获取列表的部分元素。
list2 = [10, 20, 30, 40, 50]
print(list2[1:4]) # 输出: [20, 30, 40] （索引 1 到 3，不包含 4）
print(list2[:3]) # 输出: [10, 20, 30] （从索引 0 开始，取到 3 之前）
print(list2[2:]) # 输出: [30, 40, 50] （从索引 2 开始，取到最后）
print(list2[-3:]) # 输出: [30, 40, 50] （取倒数第 3 个元素到最后）
3. 修改列表元素
列表是可变的，可以直接修改元素：
list1[1] = "Python" # 修改索引 1 的元素
print(list1) # 输出: [1.4, 'Python', 1, 3]
4. 列表的常见操作
| 操作 | 说明 | 示例 |
|---|---|---|
append(x) |
在列表末尾添加元素 x |
list1.append(5) |
insert(i, x) |
在索引 i 处插入 x |
list1.insert(1, "new") |
pop(i) |
移除索引 i 处的元素（默认移除最后一个） |
list1.pop(2) |
remove(x) |
移除列表中第一个值等于 x 的元素 |
list1.remove("hello") |
index(x) |
返回值 x 的索引 |
list1.index(3) |
count(x) |
统计 x 在列表中出现的次数 |
list1.count(1) |
sort() |
对列表进行升序排序（适用于数值或字符串） | list1.sort() |
reverse() |
反转列表 | list1.reverse() |
示例：
list3 = [3, 1, 4, 1, 5, 9]
list3.append(2) # 添加元素 2
list3.insert(1, 8) # 在索引 1 插入 8
list3.remove(1) # 移除第一个 1
list3.pop() # 移除最后一个元素
list3.sort() # 排序
print(list3) # 输出: [2, 3, 4, 5, 8, 9]
5. 列表的遍历
for item in list1:
print(item) # 逐个打印列表中的元素
6.切片、插入和删除
Python 的列表（list）是一个可变的数据结构，支持各种操作，如切片（slicing）、插入（insertion）和删除（deletion）。
下面，我们详细介绍这些操作并给出示例。
📌 1. 切片（Slicing）
切片可以获取列表中的部分元素，而不是一次访问单个元素。
切片语法： list[start:end:step]
start：起始索引（包含）end：结束索引（不包含）step（可选）：步长，默认为1，可用于跳跃式取值
🔹 切片示例
nums = [0, 1, 2, 3, 4]
print(nums) # [0, 1, 2, 3, 4]
print(nums[2:4]) # [2, 3] (从索引 2 到 4，不包括 4)
print(nums[2:]) # [2, 3, 4] (从索引 2 到列表末尾)
print(nums[:2]) # [0, 1] (从开始到索引 2，不包括 2)
print(nums[:]) # [0, 1, 2, 3, 4] (获取整个列表)
print(nums[:-1]) # [0, 1, 2, 3] (去掉最后一个元素)
print(nums[::2]) # [0, 2, 4] (每隔一个元素取值)
print(nums[::-1]) # [4, 3, 2, 1, 0] (反转列表)
🔹 切片修改
切片不仅可以用于访问元素，还可以用于修改部分元素：
nums[2:4] = [8, 9] # 替换索引 2 到 4（不包括 4）的元素
print(nums) # [0, 1, 8, 9, 4]
📌 2. 插入元素（Insertion）
Python 提供 append()、insert() 和 extend() 来向列表中插入元素。
🔹 append() - 追加单个元素
list3 = [1, 2, 3, 4]
list3.append(5) # 在列表末尾追加 5
print(list3) # [1, 2, 3, 4, 5]
🔹 extend() - 追加多个元素
list3.extend([6, 7, 8]) # 追加多个元素
print(list3) # [1, 2, 3, 4, 5, 6, 7, 8]
🔹 insert() - 指定位置插入
list3.insert(2, "Python") # 在索引 2 插入 "Python"
print(list3) # [1, 2, 'Python', 3, 4, 5, 6, 7, 8]
📌 3. 删除元素（Deletion）
Python 提供多种方式删除列表中的元素。
🔹 remove() - 按值删除
remove() 删除列表中第一个匹配的值：
list2 = [6, 17, 81, 90, 10]
list2.remove(90) # 删除 90
print(list2) # [6, 17, 81, 10]
🔹 del - 按索引删除
del list2[2] # 删除索引 2 位置的元素（81）
print(list2) # [6, 17, 10]
🔹 pop() - 按索引删除并返回
pop() 既可以删除元素，也可以返回该元素：
list2 = [6, 17, 81, 90, 10]
deleted_value = list2.pop(1) # 删除索引 1 位置的元素（17）
print(list2) # [6, 81, 90, 10]
print(deleted_value) # 17
如果不传参数，pop() 默认删除最后一个元素。
ist2.pop()
print(list2) # [6, 81, 90]
🔹 清空列表
list2.clear() # 清空列表
print(list2) # []
📌 4. 列表推导式（List Comprehension）
Python 提供了一种简洁的方法生成列表，即列表推导式：
list4 = [i for i in range(1, 10, 2)] # 生成 1, 3, 5, 7, 9
print(list4) # [1, 3, 5, 7, 9]
等效于：
list5 = []
for i in range(1, 10, 2):
list5.append(i)
print(list5) # [1, 3, 5, 7, 9]
字典（Dictionary）
字典（dict）是一种哈希表，用于存储**键-值（key-value）**对。它的特点：
- 键唯一，但值可以重复
- 通过键访问值，查询速度快（基于哈希）
- 可变数据类型，可以动态修改
🔹 1. 创建字典
# 创建字典
dict1 = {"name": "biaow", "age": 23}
# 访问字典中的值
print(dict1["age"]) # 输出: 23
🔹 2. 添加、修改和删除元素
d = {'cat': 'cute', 'dog': 'furry'}
# 添加新元素
d['fish'] = 'wet'
print(d) # {'cat': 'cute', 'dog': 'furry', 'fish': 'wet'}
# 修改已有值
d['dog'] = 'loyal'
print(d) # {'cat': 'cute', 'dog': 'loyal', 'fish': 'wet'}
# 删除某个 key
del d['cat']
print(d) # {'dog': 'loyal', 'fish': 'wet'}
🔹 3. 获取元素
d = {'cat': 'cute', 'dog': 'furry'}
# 直接获取值（Key 存在）
print(d['cat']) # 输出: cute
# 判断 Key 是否存在
print('cat' in d) # 输出: True
print('monkey' in d) # 输出: False
# 使用 get() 方法获取值（Key 不存在时返回默认值）
print(d.get('monkey', 'N/A')) # 输出: N/A
print(d.get('dog', 'N/A')) # 输出: furry
🔹 4. 遍历字典
d = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 遍历 key
for key in d:
print(key, d[key])
# 遍历 key 和 value
for key, value in d.items():
print(f"{key}: {value}")
输出：
name Alice
age 25
city New York
name: Alice
age: 25
city: New York
🔹 5. 获取所有 key、value 或键值对
d = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 获取所有 key
keys = d.keys()
print(keys) # dict_keys(['name', 'age', 'city'])
# 获取所有 value
values = d.values()
print(values) # dict_values(['Alice', 25, 'New York'])
# 获取所有 key-value 对
items = d.items()
print(items) # dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])
🔹 6. 字典的高级操作
📌 字典推导式
# 使用字典推导式创建一个字典（平方表）
squares = {x: x*x for x in range(1, 6)}
print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
📌 合并两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
# 使用 update() 方法合并
dict1.update(dict2)
print(dict1) # {'a': 1, 'b': 3, 'c': 4}
📌 清空字典
d = {'x': 10, 'y': 20}
d.clear()
print(d) # {}
元组（Tuple）
元组（tuple）与列表（list）类似，都是用来存储多个元素的数据结构，但是元组是不可变的。元组一旦创建，里面的元素无法被修改、删除或增加。
🔹 1. 创建元组
# 创建一个元组
t = (5, 6)
print(type(t)) # 输出: <class 'tuple'>
🔹 2. 元组的不可变性
与列表不同，元组中的元素不可修改，尝试修改会引发错误：
t = (1, 2, 3)
# t[1] = 4 # 这会抛出错误: TypeError: 'tuple' object does not support item assignment
条件判断
在 Python 中，条件判断通常使用 if、elif 和 else 来根据条件执行不同的代码块。每个代码块的缩进通常为 4 个空格，这是 Python 语法的一部分。
if语句
if 语句用于执行某个条件为真时的代码块。其基本语法如下：
if condition:
# code to execute if condition is true
示例：
a = 5
if a > 0:
print("a 是正数")
在这个例子中，判断变量 a 是否大于 0。如果是，则输出 “a 是正数”。
else语句
else 语句与 if 语句一起使用，用于处理条件不成立时的情况。else 总是跟在 if 语句之后。
if condition:
# code to execute if condition is true
else:
# code to execute if condition is false
示例：
a = -3
if a > 0:
print("a 是正数")
else:
print("a 不是正数")
在这个例子中，a 小于 0，因此输出 “a 不是正数”。
elif语句
elif 语句用于检查多个条件。elif 是 else 和 if 的组合，它允许你在多个条件中选择一个合适的代码块。
if condition1:
# code to execute if condition1 is true
elif condition2:
# code to execute if condition2 is true
else:
# code to execute if none of the above conditions is true
示例：
a = 10
if a > 15:
print("a 大于 15")
elif a == 10:
print("a 等于 10")
else:
print("a 小于 10")
在这个例子中，a 的值是 10，符合 elif 条件，因此输出 “a 等于 10”。
- 嵌套分支
分支语句也可以嵌套使用，即在一个 if、elif 或 else 语句内部再次使用其他的分支语句。
if condition1:
if condition2:
# code to execute if both condition1 and condition2 are true
else:
# code to execute if condition1 is true but condition2 is false
else:
# code to execute if condition1 is false
示例：
python复制编辑a = 5
b = 10
if a > 0:
if b > 5:
print("a 是正数，b 大于 5")
else:
print("a 是正数，b 不大于 5")
else:
print("a 不是正数")
在这个例子中，a 为正数且 b 大于 5，所以输出 “a 是正数，b 大于 5”。
循环学习
Python 中的循环结构用于遍历数据结构，或者重复执行某段代码。主要包括：
for循环while循环enumerate()结合for循环- 列表推导式
📌 1. for 循环
for 循环可用于遍历列表、字典、字符串等数据结构。
🔹 遍历列表
animals = ['cat', 'dog', 'monkey']
for animal in animals:
print(animal)
输出：
cat
dog
monkey
🔹 遍历字典
dict1 = {"name": "bw", "age": 23}
for key in dict1:
print(key, ":", dict1[key])
输出：
name : bw
age : 23
📌 2. range() 函数
range() 生成指定范围的整数序列，常与 for 结合使用：
# 0 到 9（默认步长 1）
for i in range(10):
print(i, end=" ")
# 输出：0 1 2 3 4 5 6 7 8 9
# 指定起始、终止和步长
for i in range(1, 10, 2):
print(i, end=" ")
# 输出：1 3 5 7 9
📌 3. enumerate() 获取索引
如果需要获取元素的索引，可以使用 enumerate()：
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print("#{}: {}".format(idx + 1, animal))
输出：
#1: cat
#2: dog
#3: monkey
📌 4. 修改列表元素
如果需要修改列表中的元素，可以遍历列表并进行修改：
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print(squares)
# 输出：[0, 1, 4, 9, 16]
🔹 使用列表推导式
Python 也支持列表推导式，让代码更简洁：
nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)
# 输出：[0, 1, 4, 9, 16]
📌 5. while 循环
当条件满足时，while 循环会不断执行代码：
i = 0
while i < 5:
print(i, end=" ")
i += 1
# 输出：0 1 2 3 4
🔹 while 结合 break
break 语句用于提前终止循环：
i = 0
while i < 10:
if i == 5:
break # 当 i 等于 5 时跳出循环
print(i, end=" ")
i += 1
# 输出：0 1 2 3 4
📌 6. continue 语句
continue 用于跳过当前循环的剩余部分，直接进入下一轮：
for i in range(5):
if i == 2:
continue # 跳过 i = 2
print(i, end=" ")
# 输出：0 1 3 4
📌 7. else 语句与循环
for 或 while 循环可以带 else 语句，当循环正常执行完时，才会执行 else 语句：
for i in range(5):
print(i, end=" ")
else:
print("\n循环结束")
输出：
0 1 2 3 4
循环结束
如果 for 循环中 break 语句提前终止，else 语句不会执行：
for i in range(5):
if i == 3:
break
print(i, end=" ")
else:
print("\n循环结束")
输出：
0 1 2
（else 语句未执行）
🎯 总结
| 语法 | 用途 |
|---|---|
for i in list: |
遍历列表 |
for i in range(n): |
生成 0 到 n-1 的整数 |
enumerate(list) |
获取索引和元素 |
while condition: |
当条件满足时，循环执行 |
break |
立即终止循环 |
continue |
跳过当前循环的剩余部分，进入下一轮 |
else（配合 for 或 while） |
只有循环正常结束时才执行 |
函数（Function）
在 Python 中，函数是一种代码块封装方式，可以复用代码，提高代码可读性和维护性。函数通过 def 关键字定义，支持参数传递和返回值。
🔹 1. 定义函数
python复制编辑# 定义一个函数
def myfun1(A):
c = A ** 2 # 计算 A 的平方
return c # 返回结果
# 调用函数
result = myfun1(3)
print(result) # 输出: 9
🔹 2. 带多个参数的函数
python复制编辑# 计算 A 的 B 次方
def myfun2(A, B):
return A ** B
a, b = 2, 4
print(myfun2(a, b)) # 输出: 16
类和对象
在面向对象编程中，类是一个蓝图或模板，用于创建对象（实例）。类定义了对象的属性和方法，而实例是根据类创建的具体对象。每个实例拥有相同的属性和方法，但数据（属性值）可以不同。
- 定义类
类的定义通常使用 class 关键字，后面跟类名。类名通常采用大写字母开头的驼峰命名法。
类的构造方法是 __init__，它用于初始化对象的属性。构造方法中的 self 代表当前对象的实例，使得对象可以引用自己的属性和方法。
示例：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('{}: {}'.format(self.name, self.score))
# 创建 Student 类的实例
a = Student('Mike', 99)
b = Student('Lisa', 80)
# 调用 print_score 方法
a.print_score() # 输出: Mike: 99
b.print_score() # 输出: Lisa: 80
在这个例子中，Student 类有两个属性 name 和 score，并且有一个方法 print_score 用于打印学生的名字和分数。然后我们创建了两个 Student 对象 a 和 b，它们分别拥有不同的属性值。
- 继承
继承是面向对象编程的一个重要特性，它允许子类继承父类的属性和方法。通过继承，可以在子类中复用父类的代码，并且可以对其进行扩展或修改。
示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def call_name(self):
print(self.name)
def call_age(self):
print(self.age)
class Superman(Person):
def __init__(self, name, age):
super(Superman, self).__init__(name, age) # 调用父类的构造方法
self.fly = True
def fly_(self):
if self.fly:
print("我会飞！")
# 创建 Superman 类的实例
wang1 = Superman("Wang", 20)
# 调用继承自 Person 类的方法
wang1.call_name() # 输出: Wang
wang1.call_age() # 输出: 20
# 调用子类中的方法
wang1.fly_() # 输出: 我会飞！
在这个例子中：
Person是父类，它有两个属性name和age，以及两个方法call_name和call_age。Superman是子类，它继承了Person类，并扩展了一个新的方法fly_，以及一个新属性fly。
super() 函数用于调用父类的构造方法，使得子类能够继承父类的属性和方法。
__init__构造方法
__init__ 方法是类的构造方法，当创建类的实例时，__init__ 会自动调用。通过 __init__，你可以初始化对象的属性。
示例：
class Person:
def __init__(self, name, age):
self.name = name # 实例属性 name
self.age = age # 实例属性 age
# 创建 Person 类的实例
person1 = Person("John", 25)
print(person1.name) # 输出: John
print(person1.age) # 输出: 25
self参数
在类的方法中，self 是指向当前对象的引用。通过 self，你可以访问对象的属性和方法。self 是每个实例的唯一标识符，因此在每个方法的定义中都必须包含 self 参数。
示例：
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
print(f"{self.name} says woof!")
dog1 = Dog("Buddy", "Golden Retriever")
dog1.bark() # 输出: Buddy says woof!
- 类的实例和属性
类的实例是通过类创建的对象，每个对象都有自己的属性。可以通过实例化类来创建多个对象，并访问和修改这些对象的属性。
示例：
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model
car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")
print(car1.brand) # 输出: Toyota
print(car2.model) # 输出: Civic
在这个例子中，Car 类有两个属性 brand 和 model，每个对象都拥有自己的 brand 和 model 属性值。
矩阵（numpy用法）
在 Python 中，numpy 是一个强大的科学计算库，特别适用于数组和矩阵操作。你提供的代码示例展示了如何使用 numpy 来创建和操作数组（张量）。
- 创建
numpy数组
import numpy as np
# 创建一个二维列表
list1 = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
]
print(list1) # 打印列表
# 使用 numpy 转化为矩阵
arr1 = np.array(list1)
print(arr1)
2. numpy 数组的属性
- 类型：
arr1.dtype显示数组元素的类型。 - 形状：
arr1.shape显示数组的维度（行和列的数量）。
a = np.array([1, 2, 3])
print(type(a)) # <class 'numpy.ndarray'>
print(a.dtype) # int64
print(a.shape) # (3,)
3. 访问数组中的元素
numpy 数组中的元素可以通过索引来访问，类似于 Python 列表。索引从 0 开始。
print(a[0], a[1], a[2]) # 输出: 1 2 3
4. 数组拼接
使用 np.concatenate 来拼接数组，axis=1 表示沿水平方向拼接（列合并），axis=0 表示沿垂直方向拼接（行合并）。
arr2 = np.array(list1) # 创建第二个数组
arr3 = np.concatenate((arr1, arr2), axis=1) # 沿着水平方向拼接
print(arr3)
输出：
[[ 1 2 3 4 5 1 2 3 4 5]
[ 6 7 8 9 10 6 7 8 9 10]
[11 12 13 14 15 11 12 13 14 15]]
5. 数组切片
你可以像操作 Python 列表一样对 numpy 数组进行切片。numpy 数组支持高效的切片操作，可以切割多维数组。
print(list1[1:3]) # 切割列表中的元素，结果为第 2 和第 3 行
print(arr1[0:3, 1:3]) # 切割 numpy 数组，前 3 行，第 2 至第 3 列
arr1[0:3, 1:3]：从arr1中提取前 3 行、第 2 到第 3 列（注意切片是左闭右开的）。
6. 高维数组的切片
如果你要切割高维数组（如二维数组），你可以使用 [:, index] 来选择特定的行或列。
index = [1, 4] # 选择第 2 和第 5 列
print(arr1[:, index]) # 选择所有行，第 2 和第 5 列
导包
导包（import）是指将外部模块或包引入到当前代码中，以便使用其定义的功能。导包可以帮助你重用已有的代码和功能，避免重复编写。
- 基本导包
使用 import 语句导入一个模块，可以访问模块中的所有函数、类和变量。
示例：
import math # 导入 math 模块
print(math.sqrt(16)) # 调用 math 模块中的 sqrt 函数，输出: 4.0
在这个例子中，math 是 Python 的标准库模块，包含了许多数学函数。我们通过 import math 导入模块，然后使用 math.sqrt() 调用 math 模块中的 sqrt 函数。
- 导入特定函数或类
如果只需要使用某个模块中的特定函数或类，可以使用 from ... import ... 的方式进行导入。
示例：
python复制编辑from math import sqrt # 从 math 模块中导入 sqrt 函数
print(sqrt(16)) # 直接调用 sqrt 函数，输出: 4.0
这种方式只导入 math 模块中的 sqrt 函数，这样在代码中直接使用 sqrt()，不需要加上 math. 前缀。
- 给模块或函数起别名
为了方便使用或避免命名冲突，可以使用 as 给模块或函数起别名。
示例：
python复制编辑import numpy as np # 给 numpy 模块起别名 np
array = np.array([1, 2, 3])
print(array)
通过 import numpy as np，我们将 numpy 模块简称为 np，这样在代码中使用 np 代替 numpy，使代码更简洁。
- 导入多个模块
可以在一个 import 语句中导入多个模块，或者在多个 import 语句中导入不同的模块。
示例：
import os, sys # 一行导入多个模块
或：
import os
import sys # 每行导入一个模块
- 导入模块中的所有内容
使用 from ... import * 可以将模块中的所有内容导入当前命名空间，但不推荐使用这种方式，因为它可能导致命名冲突。
示例：
from math import * # 导入 math 模块中的所有内容
print(sqrt(16)) # 直接调用 sqrt 函数，输出: 4.0
- 导入自定义模块
你还可以导入你自己编写的模块。假设你有一个名为 my_module.py 的文件，可以通过 import 语句导入它。
示例：
# 假设有一个 my_module.py 文件
# 文件内容:
# def greet(name):
# print(f"Hello, {name}!")
import my_module # 导入自定义模块
my_module.greet("Alice") # 调用模块中的函数，输出: Hello, Alice!
Matplotlib 是 Python 中一个强大的绘图库，主要用于绘制 2D 图形，也可以绘制 3D 图形。它非常适合用来可视化数据，生成各种类型的图形，如折线图、柱状图、散点图等。
1. 基本的折线图示例
以下是一个简单的折线图的例子，我们使用 matplotlib.pyplot 模块中的 plot 函数来绘制数据，show 函数用来显示图形。
python复制编辑import numpy as np
import matplotlib.pyplot as plt
# 创建数据
x = np.arange(0, 8, 0.1) # 从0到8，步长为0.1
y = np.sin(x) # 对x求正弦值
# 绘制折线图
plt.plot(x, y)
# 显示图形
plt.show()
解释：
x = np.arange(0, 8, 0.1)：生成从 0 到 8 的一维数组，步长为 0.1。y = np.sin(x)：计算x对应的正弦值，生成y数组。plt.plot(x, y)：用x和y的数据绘制折线图。plt.show()：显示生成的图形。
2. 自定义图形
你可以通过 matplotlib 提供的其他功能自定义图形，如设置标题、标签、网格等。
python复制编辑import numpy as np
import matplotlib.pyplot as plt
# 数据
x = np.arange(0, 8, 0.1)
y = np.sin(x)
# 绘图
plt.plot(x, y, label='sin(x)')
# 设置标题和标签
plt.title('Sine Wave')
plt.xlabel('X')
plt.ylabel('Y')
# 显示网格
plt.grid(True)
# 显示图例
plt.legend()
# 显示图形
plt.show()
解释：
plt.title('Sine Wave')：设置图形的标题。plt.xlabel('X')和plt.ylabel('Y')：设置 x 轴和 y 轴的标签。plt.grid(True)：启用网格。plt.legend()：显示图例，说明图形中每一条线代表的数据。
3. 绘制其他类型的图形
除了折线图，Matplotlib 还支持绘制许多其他类型的图形，如散点图、柱状图、饼图等。
绘制散点图：
python复制编辑import numpy as np
import matplotlib.pyplot as plt
x = np.random.rand(50)
y = np.random.rand(50)
plt.scatter(x, y)
plt.title('Scatter Plot')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
绘制柱状图：
python复制编辑import matplotlib.pyplot as plt
categories = ['A', 'B', 'C', 'D', 'E']
values = [3, 7, 2, 5, 6]
plt.bar(categories, values)
plt.title('Bar Chart')
plt.xlabel('Categories')
plt.ylabel('Values')
plt.show()