深度学习1—Python基础

深度学习1—python基础

你的第一个程序

print('hello world and hello deep learning!')

基本数据结构

1. 空值 (None)：在 Python 中，None 是一个特殊的对象，用于表示空值或缺失的值。它不同于数字 0，因为 0 是一个有意义的数字，而 None 表示没有值或无值的状态。例如：

   x = None
   print(x)  # 输出: None
   

2. 变量：变量是程序中用来存储数据的名字。在 Python 中，变量名可以包含字母、数字和下划线，但不能以数字开头。变量的值可以在程序运行过程中改变（动态类型语言）。例如：

   print(x)  # 输出: 10
   x = x + 2
   print(x)  # 输出: 12
   

3. 整数 (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.0
  • 1.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 = Falseprint(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 Yorkname: 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 语法的一部分。

1. if 语句

if 语句用于执行某个条件为真时的代码块。其基本语法如下：

if condition:# code to execute if condition is true

示例：

a = 5
if a > 0:print("a 是正数")

在这个例子中，判断变量 a 是否大于 0。如果是，则输出 “a 是正数”。

2. 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 不是正数”。

3. 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”。

4. 嵌套分支

分支语句也可以嵌套使用，即在一个 if、elif 或 else 语句内部再次使用其他的分支语句。

if condition1:if condition2:# code to execute if both condition1 and condition2 are trueelse:# 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 = 2print(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:breakprint(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 ** Ba, b = 2, 4
print(myfun2(a, b))  # 输出: 16

类和对象

在面向对象编程中，类是一个蓝图或模板，用于创建对象（实例）。类定义了对象的属性和方法，而实例是根据类创建的具体对象。每个实例拥有相同的属性和方法，但数据（属性值）可以不同。

1. 定义类

类的定义通常使用 class 关键字，后面跟类名。类名通常采用大写字母开头的驼峰命名法。

类的构造方法是 __init__，它用于初始化对象的属性。构造方法中的 self 代表当前对象的实例，使得对象可以引用自己的属性和方法。

示例：

class Student(object):def __init__(self, name, score):self.name = nameself.score = scoredef 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，它们分别拥有不同的属性值。

2. 继承

继承是面向对象编程的一个重要特性，它允许子类继承父类的属性和方法。通过继承，可以在子类中复用父类的代码，并且可以对其进行扩展或修改。

示例：

class Person:def __init__(self, name, age):self.name = nameself.age = agedef 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 = Truedef 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() 函数用于调用父类的构造方法，使得子类能够继承父类的属性和方法。

3. __init__ 构造方法

__init__ 方法是类的构造方法，当创建类的实例时，__init__ 会自动调用。通过 __init__，你可以初始化对象的属性。

示例：

class Person:def __init__(self, name, age):self.name = name  # 实例属性 nameself.age = age    # 实例属性 age# 创建 Person 类的实例
person1 = Person("John", 25)
print(person1.name)  # 输出: John
print(person1.age)   # 输出: 25

4. self 参数

在类的方法中，self 是指向当前对象的引用。通过 self，你可以访问对象的属性和方法。self 是每个实例的唯一标识符，因此在每个方法的定义中都必须包含 self 参数。

示例：

class Dog:def __init__(self, name, breed):self.name = nameself.breed = breeddef bark(self):print(f"{self.name} says woof!")dog1 = Dog("Buddy", "Golden Retriever")
dog1.bark()  # 输出: Buddy says woof!

5. 类的实例和属性

类的实例是通过类创建的对象，每个对象都有自己的属性。可以通过实例化类来创建多个对象，并访问和修改这些对象的属性。

示例：

class Car:def __init__(self, brand, model):self.brand = brandself.model = modelcar1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")print(car1.brand)  # 输出: Toyota
print(car2.model)  # 输出: Civic

在这个例子中，Car 类有两个属性 brand 和 model，每个对象都拥有自己的 brand 和 model 属性值。

矩阵（numpy用法）

在 Python 中，numpy 是一个强大的科学计算库，特别适用于数组和矩阵操作。你提供的代码示例展示了如何使用 numpy 来创建和操作数组（张量）。

1. 创建 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）是指将外部模块或包引入到当前代码中，以便使用其定义的功能。导包可以帮助你重用已有的代码和功能，避免重复编写。

1. 基本导包

使用 import 语句导入一个模块，可以访问模块中的所有函数、类和变量。

示例：

import math  # 导入 math 模块
print(math.sqrt(16))  # 调用 math 模块中的 sqrt 函数，输出: 4.0

在这个例子中，math 是 Python 的标准库模块，包含了许多数学函数。我们通过 import math 导入模块，然后使用 math.sqrt() 调用 math 模块中的 sqrt 函数。

2. 导入特定函数或类

如果只需要使用某个模块中的特定函数或类，可以使用 from ... import ... 的方式进行导入。

示例：

python复制编辑from math import sqrt  # 从 math 模块中导入 sqrt 函数
print(sqrt(16))  # 直接调用 sqrt 函数，输出: 4.0

这种方式只导入 math 模块中的 sqrt 函数，这样在代码中直接使用 sqrt()，不需要加上 math. 前缀。

3. 给模块或函数起别名

为了方便使用或避免命名冲突，可以使用 as 给模块或函数起别名。

示例：

python复制编辑import numpy as np  # 给 numpy 模块起别名 np
array = np.array([1, 2, 3])
print(array)

通过 import numpy as np，我们将 numpy 模块简称为 np，这样在代码中使用 np 代替 numpy，使代码更简洁。

4. 导入多个模块

可以在一个 import 语句中导入多个模块，或者在多个 import 语句中导入不同的模块。

示例：

import os, sys  # 一行导入多个模块

或：

import os
import sys  # 每行导入一个模块

5. 导入模块中的所有内容

使用 from ... import * 可以将模块中的所有内容导入当前命名空间，但不推荐使用这种方式，因为它可能导致命名冲突。

示例：

from math import *  # 导入 math 模块中的所有内容
print(sqrt(16))  # 直接调用 sqrt 函数，输出: 4.0

6. 导入自定义模块

你还可以导入你自己编写的模块。假设你有一个名为 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 pltx = 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 pltcategories = ['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()