Python语言基础------结构基础
前言
Python数据分析所需的结构基础包括：
- 控制流语句：如条件语句（
if/elif/else）、循环语句（for/while）等，用于控制程序流程。 - 函数与模块：自定义函数可以封装重复使用的代码，模块可以组织和管理这些函数。
- 数据处理库：如
NumPy、Pandas等，用于高效地处理和分析大量数据。 - 数据可视化库：如
Matplotlib、Seaborn等，用于生成直观的数据可视化图表。
了解这些结构基础是Python数据分析的关键，可以帮助分析人员更有效地处理、分析和呈现数据。
一、列表
列表的介绍
Python中的列表是一种有序的数据类型，可以存储多个值。列表使用方括号[]来表示，每个值之间用逗号分隔。列表是顺序结构中的一种，而且列表中的每个元素最多只有一个前驱和一个后驱。
列表的元素可以是任何类型的数据，包括数字、字符串、布尔值、其他列表等。
列表是可变的，可以通过索引来访问和修改列表中的元素。列表的索引从0开始，即第一个元素的索引为0，第二个元素的索引为1，依此类推。
列表可以进行一些常见的操作，例如添加元素、删除元素、获取列表的长度等。
列表的语法
Python列表是一种有序的数据集合，用于存储多个元素。列表是可变的，可以通过添加、删除或修改元素来改变列表。
列表的语法如下：
- 创建一个列表：可以通过在方括号
[]中用逗号分隔元素来创建一个列表。
python
my_list = [1, 2, 3, 4, 5]- 空列表：可以通过使用空的方括号创建一个空列表。
python
empty_list = []- 访问列表元素：可以使用索引运算符
[]访问列表中的元素。索引从 0 开始，可以是正数或负数。
python
my_list = [1, 2, 3, 4, 5]
print(my_list[0]) # 输出第一个元素 1
print(my_list[-1]) # 输出最后一个元素 5- 切片操作：可以使用切片操作符
:来获取列表中的子列表。切片操作会返回一个新的列表。
python
my_list = [1, 2, 3, 4, 5]
print(my_list[1:3]) # 输出包含索引为 1 和 2 的元素 [2, 3]- 修改列表元素：可以直接通过索引运算符
[]来修改列表中的元素。
python
my_list = [1, 2, 3, 4, 5]
my_list[0] = 10 # 将第一个元素修改为 10
print(my_list) # 输出 [10, 2, 3, 4, 5]- 添加元素：可以使用
append()方法向列表末尾添加一个元素。
python
my_list = [1, 2, 3, 4, 5]
my_list.append(6) # 添加元素 6
print(my_list) # 输出 [1, 2, 3, 4, 5, 6]- 删除元素：可以使用
del语句或remove()方法删除列表中的元素。
python
my_list = [1, 2, 3, 4, 5]
del my_list[0] # 删除第一个元素
print(my_list) # 输出 [2, 3, 4, 5]
my_list.remove(3) # 删除元素 3
print(my_list) # 输出 [2, 4, 5]- 列表长度：可以使用
len()函数获取列表的长度。
python
my_list = [1, 2, 3, 4, 5]
print(len(my_list)) # 输出列表的长度 5以上是Python列表的一些基本语法。
示例
以下是一个使用Python列表的示例代码：
python
# 创建一个空列表
my_list = []
# 向列表中添加元素
my_list.append(10)
my_list.append(20)
my_list.append(30)
# 访问列表中的元素
print(my_list[0]) # 输出: 10
print(my_list[1]) # 输出: 20
print(my_list[2]) # 输出: 30
# 修改列表中的元素
my_list[1] = 50
print(my_list) # 输出: [10, 50, 30]
# 删除列表中的元素
del my_list[0]
print(my_list) # 输出: [50, 30]
# 使用循环遍历列表中的元素
for num in my_list:
print(num)
# 输出:
# 50
# 30在上面的示例中，我们首先创建了一个空列表my_list。然后使用append()方法向列表中添加了三个元素。我们可以通过下标来访问列表中的元素，并且可以通过赋值来修改元素的值。使用del关键字可以删除列表中的元素。最后，我们使用循环遍历了列表中的每个元素，并打印出来。
注意要点
符号
列表中的方括号和逗号都是半角符号，如果用了全角符号，python的解释器会报错
元素
列表中的元素可以是相同的类型，也可以是不同的类型。
当往列表中放入数据的时候，python用"索引"来标记要放入的位置。
可以这样理解索引，就是给每一个存放数据的位置写了一个数字，而且是从0开始。
切片运算符
如果要连续获取几个元素，需要使用如下的切片运算符：
Python中的切片运算符用于提取列表、字符串等可迭代对象的子序列。它使用方括号[]来表示，并在方括号内指定起始索引、结束索引和步长。
切片运算符的语法如下：
cpp
[start:stop:step]其中，start表示起始索引（包含），stop表示结束索引（不包含），step表示步长（默认为1）。
示例
例如，对于列表lst，可以使用切片运算符提取其中的子列表：
python
lst[start:stop:step]以下是一些常见的切片运算符示例：
- 提取整个列表：
python
lst[:] # 返回lst的完整副本- 提取从索引0到索引2（不包含）之间的元素：
python
lst[0:2]- 提取从索引1到最后一个元素之间的元素：
python
lst[1:]- 提取从第一个元素到倒数第二个元素之间的元素：
python
lst[:-1]- 提取从索引1到倒数第二个元素之间的元素，并以步长为2进行提取：
python
lst[1: -1:2]切片运算符还可以用于字符串、元组等其他类型的可迭代对象。
需要注意的是，切片运算符返回的是原对象的一个新副本，而不是对原对象的修改。
二、字典
python的字典由"键"和"值"构成，其中"键"表示查找的依据，而"值"表示查找的结果。
字典的介绍
Python中的字典（Dictionary）是一种可变容器模型，可以存储任意类型的对象，例如数字、字符串、列表和另一个字典等。字典是通过键值对（key-value pairs）来存储和访问数据的。
我们可以这样理解，Python中的字典就是一个映射结构，与手机通讯录很相似。我们查通讯录的时候是按姓名来查找的，即通过名字找到这个人的手机号码，姓名与手机号码是一一对应的。值得注意的是，Python字典是一个特殊的通信录，因为它不允许里面有两个人的名字是相同的。
ps： 映射结构就是把一个值映射到另一个值的结构。
字典的特点
字典的特点包括：
- 字典中的键必须是唯一的；
- 键必须是不可变的，例如字符串、数字或元组，但不能是列表等可变类型；
- 字典中的元素没有顺序，不像列表有索引。
字典的语法
字典的创建可以使用花括号 {}，也可以使用 dict() 函数。下面是一些创建字典的示例：
python
# 使用花括号创建字典
my_dict = {'apple': 5, 'banana': 3, 'orange': 2}
# 使用 dict() 函数创建字典
my_dict = dict(apple=5, banana=3, orange=2)可以通过键来访问字典中的值，例如：
python
my_dict = {'apple': 5, 'banana': 3, 'orange': 2}
print(my_dict['apple']) # 输出 5字典也支持添加、修改和删除元素的操作。例如，可以使用键来添加一个新的键值对，或者使用现有的键来修改相应的值：
python
my_dict = {'apple': 5, 'banana': 3, 'orange': 2}
my_dict['apple'] = 6 # 修改 'apple' 的值为 6
my_dict['grape'] = 4 # 添加一个新的键值对 'grape': 4可以使用 del 关键字来删除字典中的键值对：
python
my_dict = {'apple': 5, 'banana': 3, 'orange': 2}
del my_dict['orange'] # 删除键为 'orange' 的键值对除了基本的操作外，字典还提供了一些常用的方法，例如 keys()、values() 和 items() 来获取字典中的键、值和键值对。另外，可以使用 len() 函数来获取字典中键值对的数量。
总结来说，字典是一种非常实用的数据结构，可以用来存储和访问各种类型的数据。通过键值对的形式，可以方便地进行增加、删除和修改操作。在实际的编程中，字典经常被用作存储配置信息、处理文件和网络数据等场景中的数据结构。
三、元组
元组和列表相似，列表的大部分方法在元组上也可以使用，只是元组是不可以修改的。创建列表的语法是使用方括号，而创建元组的语法是使用圆括号。
元组的介绍
Python元组是一种不可变的有序集合。元组使用小括号 () 来表示。元组中的每个元素都可以有不同的类型，并且可以是任意类型（包括数字、字符串、元组、列表等）。
与列表不同，元组是不可变的，这意味着一旦创建了元组，就不能修改它。因此，元组中的元素不能被添加、删除或修改。这使得元组在存储不可变数据集合时非常有用。
元组可以通过索引访问，索引从0开始。也可以使用切片来访问元组的部分内容。
元组支持多种操作，包括元素的访问、元素的比较、元组的拼接、重复和长度查找等。
元组的语法
元组的语法如下：
python
my_tuple = (element1, element2, element3, ...)可以使用索引来访问元组中的元素，索引从0开始。也可以使用切片来访问元组中的子集。
python
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0]) # 输出：1
print(my_tuple[1:3]) # 输出：(2, 3)元组的元素可以是任意类型的数据，包括数字、字符串、列表等。
python
my_tuple = (1, "hello", [1, 2, 3])
print(my_tuple) # 输出：(1, "hello", [1, 2, 3])元组可以进行一些基本的操作，比如拼接、重复和长度计算。
python
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2) # 输出：(1, 2, 3, 4, 5, 6)
print(tuple1 * 3) # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)
print(len(tuple1)) # 输出：3需要注意的是，如果元组中只有一个元素，需要在元素后面加上逗号，以区分它是一个元组而不是一个普通的数据。
python
my_tuple = (1,)
print(type(my_tuple)) # 输出：<class 'tuple'>总结来说，元组是不可变的数据结构，它可以包含不同类型的元素，并支持一些基本的操作。元组在一些场景下比列表更加适合，比如作为函数的返回值、用于保存不可变的数据等。
示例
以下是一些常用的元组操作示例：
python
# 创建元组
my_tuple = (1, "apple", 3.14)
# 访问元组元素
print(my_tuple[0]) # 输出：1
# 切片
print(my_tuple[1:3]) # 输出：("apple", 3.14)
# 元素比较
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 < tuple2) # 输出：True
# 元组拼接
tuple3 = tuple1 + tuple2
print(tuple3) # 输出：(1, 2, 3, 4, 5, 6)
# 元组重复
tuple4 = tuple1 * 3
print(tuple4) # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)
# 元组长度
print(len(my_tuple)) # 输出：3总之，Python元组是不可变的有序集合，可以存储不同类型的元素，并支持多种操作。由于其不可变性质，元组常用于存储不可修改的数据集合。
四、字符串
字符串的介绍
Python中的字符串是一种数据类型，用于存储文本数据。字符串是由一系列字符组成的，可以包含字母、数字、符号等。
字符串是不可变的，这意味着一旦创建了一个字符串对象，就无法修改它的内容。但是，可以通过一些方法和操作来处理字符串，例如拼接、切片、替换等。
字符串的语法
在Python中，字符串的语法有以下几个特点：
- 定义字符串：字符串可以用单引号（
'）或双引号（"）括起来，例如：
python
my_string = 'Hello, World!'
another_string = "Python is awesome."也可以使用三重引号括起来，用于表示多行字符串，例如：
python
multi_line_string = '''This is a multi-line
string'''- 字符串的访问：可以通过索引来访问字符串中的单个字符，索引从0开始，例如：
python
my_string = 'Hello, World!'
print(my_string[0]) # 输出 'H'也可以使用切片来访问字符串的子串，切片可以获取字符串中的一部分，例如：
python
my_string = 'Hello, World!'
print(my_string[0:5]) # 输出 'Hello'- 字符串的拼接：可以使用加号（
+）将两个字符串拼接在一起，例如：
python
string1 = 'Hello'
string2 = 'World!'
result = string1 + ' ' + string2
print(result) # 输出 'Hello World!'也可以使用join()方法来将多个字符串连接起来，例如：
python
strings = ['Hello', 'World!']
result = ' '.join(strings)
print(result) # 输出 'Hello World!'- 字符串的修改：字符串是不可变的，不能直接修改字符串中的某个字符。但是可以通过一些方法和操作来生成一个新的字符串，例如：
python
my_string = 'Hello, World!'
new_string = my_string.replace('Hello', 'Hi')
print(new_string) # 输出 'Hi, World!'- 字符串的格式化：可以使用占位符将变量的值插入到字符串中，常见的占位符有
%s（字符串）、%d（整数）、%f（浮点数）等，例如：
python
name = 'Alice'
age = 25
print('My name is %s and I am %d years old.' % (name, age))- 字符串的常用方法：Python提供了丰富的字符串方法，例如
split()（按指定分隔符拆分字符串）、strip()（去除字符串两端的空白字符）、upper()（将字符串转换为大写）、lower()（将字符串转换为小写）等，这些方法可以方便地对字符串进行操作和处理。
以上就是Python字符串的基本语法，对于字符串的操作和处理，可以根据具体需求选择合适的方法和操作来实现。
五、操作运算符
Python中的操作运算符用于执行各种数学操作和比较操作。以下是Python中常用的操作运算符：
算术运算符
+：相加-：相减*：相乘/：相除%：取模（取余）**：幂运算//：整除
求整除数，计算两个整数相除的整数值如5/2 = 2
赋值运算符
=：将右边的值赋给左边的变量+=：加和赋值-=：减和赋值*=：乘和赋值/=：除和赋值%=：取模和赋值**=：幂运算和赋值//=：整除和赋值
比较运算符
==：等于!=：不等于>：大于<：小于>=：大于等于<=：小于等于
逻辑运算符
and：逻辑与or：逻辑或not：逻辑非
位运算符
&：按位与|：按位或^：按位异或~：按位取反<<：左移>>：右移
成员运算符
in：如果在序列中找到指定的值，返回True，否则返回Falsenot in：如果在序列中没有找到指定的值，返回True，否则返回False
身份运算符
is：判断两个变量是否引用同一个对象is not：判断两个变量是否引用不同的对象
这些操作运算符可以用于不同类型的变量，如整数、浮点数、字符串、列表等。
六、if、else、elif条件语句
语句详解
在Python中，我们可以使用条件语句来根据不同的条件执行不同的代码块。主要的条件语句有三种：if语句、else语句和elif语句。
if语句用于判断一个条件是否为真，如果条件为真，则执行if语句后面缩进的代码块。if语句的基本语法如下：
python
if 条件:
# 代码块else语句用于在条件不满足时执行另外一段代码块。else语句的基本语法如下：
python
if 条件:
# 代码块1
else:
# 代码块2elif语句用于在多个条件中选择满足的第一个条件执行相应的代码块。elif语句的基本语法如下：
python
if 条件1:
# 代码块1
elif 条件2:
# 代码块2
else:
# 代码块3在if-else语句中，当条件为真时执行代码块1，否则执行代码块2。在elif语句中，依次检查每个条件，当条件为真时执行相应的代码块，如果所有的条件都不满足，则执行else语句的代码块。
注意要点
需要注意的是，代码块的缩进对Python非常重要，它表示与if、elif或else语句相关的代码块。
在判断语句中，空列表、空元组、空字典、数字0、空字符串（""）都会在判断条件中被自动转换为布尔值False
七、for循环语句
for循环是Python中的一个循环语句，用于遍历一个可迭代对象（如列表、元组、字符串、字典等）中的元素。
基本语法
for循环的基本语法如下：
python
for 变量 in 可迭代对象:
循环体代码块其中，变量表示在循环过程中每次迭代取出的元素，可迭代对象表示要遍历的对象。
在循环体代码块中，可以使用变量来引用当前迭代的元素，执行所需的操作。
在循环执行时，for循环会依次将可迭代对象中的每个元素赋值给变量，并执行循环体代码块，直到可迭代对象中的所有元素都被遍历完。
range函数
for函数与range函数可以配套使用来循环遍历某个范围内的数字。
range函数用于生成一个整数序列，常见的使用方式有：
range(stop)：生成0到stop-1的整数序列。range(start, stop)：生成start到stop-1的整数序列。range(start, stop, step)：生成start到stop-1的整数序列，步长为step。
for函数用于循环遍历一个序列或者其他可迭代对象，常见的使用方式有：
python
for variable in sequence:
# 循环体其中，variable 是变量名，用于接收 sequence 中的元素；sequence 是可迭代对象，如range生成的整数序列或者列表等；循环体是需要重复执行的代码块。
配合使用例子：
python
for i in range(5):
print(i)
# 输出: 0 1 2 3 4
for i in range(1, 6):
print(i)
# 输出: 1 2 3 4 5
for i in range(1, 10, 2):
print(i)
# 输出: 1 3 5 7 9这样，可以使用for循环和range函数来实现对某个范围内的数字的遍历和操作。
示例
下面是一些for循环的例子：
- 遍历列表：
python
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)输出结果：
python
apple
banana
cherry- 遍历字符串：
python
message = 'Hello, world!'
for char in message:
print(char)输出结果：
python
H
e
l
l
o
,
w
o
r
l
d
!- 遍历字典：
python
person = {'name': 'Alice', 'age': 30, 'gender': 'female'}
for key, value in person.items():
print(key, value)输出结果：
python
name Alice
age 30
gender female在for循环中，还可以使用break语句提前结束循环，使用continue语句跳过当前迭代。
总之，for循环是Python中常用的循环语句，用于遍历可迭代对象中的元素，并执行相应的操作。
八、while循环语句
基本语法
在Python中，while循环语句用于重复执行一段代码，直到指定的条件不再满足。while循环的语法如下：
python
while 条件:
# 代码块在执行while循环时，首先会对条件进行判断。如果条件为真，则执行代码块中的代码，并继续循环；如果条件为假，则跳出循环，执行循环之后的代码。
示例
下面是一个简单的示例，展示了如何使用while循环计算一个数字的阶乘：
python
n = 5
result = 1
while n > 0:
result *= n
n -= 1
print(result)在这个示例中，我们首先初始化变量n为5和变量result为1。然后，我们使用while循环来计算n的阶乘。在每次循环中，我们将n乘以result，并将n减1。最后，当n等于0时，循环终止，并打印出计算得到的结果。
需要注意的是，如果条件一直为真，while循环将会无限循环下去，导致程序陷入死循环。为了避免这种情况，我们需要在循环体内对条件进行修改，确保在某个时刻条件不再满足，从而跳出循环。
控制循环
还有一些与while循环相关的控制语句，可以用于控制循环的流程，一般来说，循环会不断执行代码块，直到某个条件满足为止。但是有时希望中断循环或者跳出某一次循环，这就需要使用break或者continue语句。
break语句可以直接跳出循环，结束循环。continue语句可以实现结束当前循环，直接进入下一次循环的功能。
python
a = 10
while (a > 5):
a = a - 1
if(a % 2 == 0):
continue
print(a)
九、函数和类
函数
对于一个需要多次使用某个方法的程序，如果在程序中重复编写这个方法，将会导致程序可读性不高。在这种情况下，可以引入函数进行python编程。
函数是在一个程序中可以重复使用的代码块，并且这组代码块可以实现一个独立的功能。在定义好函数后，该函数就可以在程序中任意需要的位置被调用。
函数一般由函数名、参数、函数体、返回值组成，其中函数名和函数体是必须的。
基本语法
Python函数的定义格式为：
python
def 函数名(参数列表):
函数体
[return 返回值]其中，参数列表是函数的输入参数，可以有多个参数，参数之间用逗号分隔。函数体是函数执行的代码块，可以包含多条语句。return语句是可选的，用于指定函数的返回值。
下面是一些常用的函数定义和使用的示例：
无参数的函数定义和调用
python
def hello():
print("Hello, world!")
hello() # 调用函数输出：Hello, world!带参数的函数定义和调用
python
def square(x):
return x * x
result = square(5) # 调用函数，传入参数5，返回值为25
print(result) # 输出：25带默认参数的函数定义和调用
python
def power(base, exp=2):
return base ** exp
result1 = power(2) # 使用默认参数，返回值为4
result2 = power(2, 3) # 不使用默认参数，返回值为8
print(result1, result2) # 输出：4 8可变参数的函数定义和调用
python
def average(*numbers):
if len(numbers) == 0:
return 0
return sum(numbers) / len(numbers)
result1 = average(1, 2, 3) # 参数个数不固定，返回值为2.0
result2 = average() # 无参数，返回值为0
print(result1, result2) # 输出：2.0 0关键字参数的函数定义和调用
python
def student_info(name, age, **kwargs):
print("姓名：", name)
print("年龄：", age)
for key, value in kwargs.items():
print(key, "：", value)
student_info("Tom", 20, major="Computer Science", grade="A") # 输出：姓名： Tom 年龄： 20 major： Computer Science grade： A这些示例涵盖了函数的多种用法，包括无参数函数、带参数函数、默认参数函数、可变参数函数和关键字参数函数等。通过灵活的函数定义和调用，可以根据需求编写出更加简洁和高效的代码。
类
在Python中，类是一种自定义的数据类型，它允许我们定义自己的对象。
类是一种包含属性（变量）和方法（函数）的抽象。通过类，我们可以创建多个相似的对象，这些对象共享相同的属性和方法。
定义一个类
要定义一个类，使用关键字class后跟类名。类名通常使用CamelCase命名规则。
python
class MyClass:
pass创建一个对象
要创建一个类的实例，可以通过调用类名后加括号的方式来实现。
python
my_object = MyClass()属性
类的属性是指属于类的变量。它们用于存储对象的状态。类的属性可以在类的内部和外部进行访问和修改。
python
class MyClass:
my_property = "Hello"
print(MyClass.my_property) # "Hello"
my_object = MyClass()
print(my_object.my_property) # "Hello"
my_object.my_property = "World"
print(my_object.my_property) # "World"方法
类的方法是指属于类的函数。它们用于定义对象的行为。方法可以访问和操作对象的属性。
python
class MyClass:
def my_method(self):
print("Hello")
my_object = MyClass()
my_object.my_method() # "Hello"构造函数和析构函数
构造函数是一种特殊的方法，用于在创建对象时进行初始化操作。构造函数的名称是__init__。
python
class MyClass:
def __init__(self):
print("Object created")
my_object = MyClass() # "Object created"析构函数是一种特殊的方法，用于在对象被销毁时执行清理操作。析构函数的名称是__del__。
python
class MyClass:
def __del__(self):
print("Object deleted")
my_object = MyClass()
del my_object # "Object deleted"继承
继承是一种创建新类的机制，它可以继承现有类的属性和方法。通过继承，我们可以创建更具体的类，这些类继承了父类的特性并提供了自己的特定功能。
python
class Animal:
def eat(self):
print("Eating")
class Dog(Animal):
def bark(self):
print("Barking")
my_dog = Dog()
my_dog.eat() # "Eating"
my_dog.bark() # "Barking"多态
多态是指同一个方法在不同的类中可以有不同的实现。通过多态，我们可以在不改变方法的名称和调用方式的情况下，根据对象的不同类型执行不同的代码。
python
class Animal:
def make_sound(self):
print("Animal sound")
class Dog(Animal):
def make_sound(self):
print("Woof")
class Cat(Animal):
def make_sound(self):
print("Meow")
def sound_animal(animal):
animal.make_sound()
my_animal = Animal()
my_dog = Dog()
my_cat = Cat()
sound_animal(my_animal) # "Animal sound"
sound_animal(my_dog) # "Woof"
sound_animal(my_cat) # "Meow"这是Python中类的一些基本概念。通过类，我们可以封装数据和行为，便于组织和重用代码。类是面向对象编程的核心概念之一，可以大大提高代码的可读性和可维护性。
示例
python
#编写水果类
class Fruit():
def __init__(self,name,color):
self.name = name
self.color = color
def pickup(self,season):
print("{}在{}季节收获".format(self.name,season))
Apple = Fruit("apple","red")
Apple.pickup("秋天")
十、模块和包
模块是一个相对笼统的概念，可以将其看成包含变量或一组方法的python文件对象，或者多个python文件对象组成的目录。有了模块，一个python文件中的方法或者变量就可以被外部访问使用，而不仅仅局限于文件内部使用。因为有了模块，python对象的抽象和复用更为通用，而不同于模块放在一起就构成了一个package包。
python如此流行，就是因为在python社区中有各种各样的包可以下载并直接使用，这些包可以用于完成数据处理、网络爬虫、网站建设、嵌入式编程、多媒体处理、人工智能等多种任务。
在Python中，模块和包是组织和管理代码的重要概念。它们允许我们将相关的代码组合在一起，并且可以在不同的项目中重复使用。
模块
模块是包含Python代码的文件，其扩展名为.py。它可以包含函数、类、变量、常量等代码。可以使用import语句在其他代码中引入和使用模块。
创建模块
要创建一个模块，只需创建一个以.py结尾的文件，并在文件中编写代码。
例如，我们可以创建一个名为my_module.py的模块，其中包含一个简单的函数：
python
# my_module.py
def greeting(name):
print("Hello, " + name)示例
下面介绍一个使用random模块产生一组随机数，并存入列表的例子来展示模块的使用方法
使用模块
要使用模块中的函数，可以使用import语句将模块引入到代码中：
python
import my_module
my_module.greeting("Alice") # "Hello, Alice"也可以使用from module_name import function_name的方式导入特定的函数，而不是整个模块：
python
from my_module import greeting
greeting("Alice") # "Hello, Alice"包
包是包含模块的目录。一个包通常由多个模块组成，并且可以有多个级别的子包。包允许我们更好地组织和管理代码。
创建包
要创建一个包，只需创建一个目录，并在目录中包含一个名为__init__.py的空文件。这个文件告诉Python这个目录是一个包。
python
my_package/
__init__.py
module1.py
module2.py使用包
使用包中的模块时，可以使用import语句指定包名和模块名来引入模块：
python
import my_package.module1
my_package.module1.function() # 调用包中的模块中的函数也可以使用from package_name import module_name的方式导入特定的模块：
python
from my_package import module1
module1.function() # 调用包中的模块中的函数在导入包的情况下，可以在包中的__init__.py文件中定义一个__all__列表，用于指定可以从包中导入的模块列表。
python
# my_package/__init__.py
__all__ = ['module1', 'module2']然后可以使用from package_name import *语句导入指定在__all__列表中的模块：
python
from my_package import *
module1.function() # 调用包中的模块中的函数
module2.function() # 调用包中的模块中的函数这是Python中模块和包的一些基本概念。通过使用模块和包，我们可以更好地组织和管理代码，并且可以在不同的项目中重复使用。这提高了代码的可重用性和可维护性，同时使代码更加模块化。