python基础教程

Python 基础

一篇曾经写的关于python的基础教程课件，存此做记录(#.#)，有需要的可以前往https://leolin66.top/article/python_basic_tutorial下载pdf文档

课程简介

🗣️ 本课程主要介绍 Python 的基础知识，Python作为一门简洁易学的高级编程语言，其优雅的语法和丰富的库资源使得其成为了人工智能、机器学习、数据分析等领域中的热门选择。在这份Python基础教学文档中，我们介绍了Python中的基本数据类型、控制流语句、函数、模块、文件操作等知识点，通过实际代码演示帮助理解这些概念。

学习目标

• 熟悉 Python 简介和语法
• 掌握 Python 的数据类型
• 了解Python 的控制语句、函数和模块
• 了解Python 的文件操作

Python 简介

Python 是一种高级、解释型的、面向对象的编程语言。Python 的语法简洁、易读、易维护，适用于快速开发、程序可读性要求高以及构建大型系统等需求。

环境搭建

1. 下载Python安装包：从Python官方网站（https://www.python.org/downloads/）下载适合你的操作系统的Python安装包。
2. 安装Python：运行下载的Python安装包，按照提示进行安装。
3. 配置环境变量：将Python的安装路径添加到系统环境变量中，以便在命令行中可以直接运行Python解释器。
4. 安装第三方库：Python的第三方库很多，需要根据自己的需要安装相应的库。

具体安装步骤自行查找资料，不做赘述

变量和常量

变量是程序运行过程中可以改变的数据，常量是程序运行过程中不可改变的数据，比如数学中pi常数。在Python中，常量通常用全大写字母表示，可以用关键字const或者final来定义常量。

实际代码演示：

# 定义常量PI
PI = 3.14159
# 定义变量x和y
x = 10
y = 3.14
# 打印常量PI和变量x、y的值
print('PI =', PI) # PI = 3.14159
print('x =', x) # x = 10
print('y =', y) # y = 3.14
# 修改变量x的值
x = 20
# 打印修改后的变量x的值
print('x =', x) # x = 20

数据类型

Python 有丰富的数据类型，包括数字、字符串、列表、元组、字典、集合、布尔型等。每种数据类型都有其特定的用途和操作方式。

整数（int）

整数是Python中最基本的数据类型之一，用来表示整数值，可以是正数、负数或零。

**进制：**整数的表示方法，常用的有十进制、二进制、八进制和十六进制。

**整除：**两个整数相除后只保留整数部分的运算，使用 // 运算符实现。

**取余：**两个整数相除后余下的部分，使用 % 运算符实现。

实际代码演示：

定义整数
a = 100
b = -50
c = 0
# 进制转换
print(int("1010", 2)) # 将二进制数1010转为十进制数，结果为10
print(bin(10)) # 将十进制数10转为二进制数，结果为0b1010
print(oct(10)) # 将十进制数10转为八进制数，结果为0o12
print(hex(10)) # 将十进制数10转为十六进制数，结果为0xa
# 整数运算
print(a + b) # 加法，结果为50
print(a - b) # 减法，结果为150
print(a * b) # 乘法，结果为-5000
print(a / b) # 除法，结果为-2.0
print(a // b) # 整除，结果为-2
print(a % b) # 取余，结果为0
# 比较运算
print(a > b) # 大于，结果为True
print(a < b) # 小于，结果为False
print(a == b) # 等于，结果为False
print(a != b) # 不等于，结果为True
print(a >= b) # 大于等于，结果为True
print(a <= b) # 小于等于，结果为False

浮点数（float）

浮点数是Python中表示实数的数据类型，包括正数、负数、小数等，可以进行加、减、乘、除等基本运算。

**科学计数法：**用于表示很大或很小的实数的一种计数法，格式为a x 10的n次方，其中a为小于10的实数，n为整数。

实际代码演示：

# 定义浮点数
a = 3.14
b = -2.5
# 科学计数法
c = 1.23e-4 # 表示0.000123，即1.23 x 10的-4次方
# 浮点数运算
print(a + b) # 加法，结果为0.64
print(a - b) # 减法，结果为5.64
print(a * b) # 乘法，结果为-7.85
print(a / b) # 除法，结果为-1.256
print(a // b) # 整除，结果为-2.0（因为除法结果为负数时，整除结果也是负数）

字符串（str）

字符串是Python中表示文本的数据类型，可以包含字母、数字、标点符号等字符。字符串是不可变的，即不能对字符串中的字符进行修改，但可以使用各种方法对字符串进行操作和处理。

**转义字符：**用于在字符串中表示一些特殊字符的字符序列，包括反斜杠（\）和一些特殊字符组成的字符。

**格式化字符串：**一种将变量值插入到字符串中的方式，使用占位符（%）和格式化字符实现。在Python 3.6及以上版本中，可以使用f字符串（formatted string）将表达式的值插入到字符串中。

**切片：**从字符串中获取指定位置的子字符串的操作，使用[start🔚step]的形式实现。

实际代码演示：

# 定义字符串
a = "Hello, world!"
b = 'Python'
# 转义字符
c = 'I\'m a student.' # 使用反斜杠表示单引号
d = "She said: \"Hello!\"" # 使用反斜杠表示双引号
# 格式化字符串
age = 25
name = "Alice"
print("My name is %s and I'm %d years old." % (name, age)) # 结果为"My name is Alice and I'm 25 years old."
print(f'My name is {name}, and I am {age} years old.') # 结果为'My name is Alice, and I am 25 years old.'
# 切片
s = "Hello, world!"
print(s[0]) # 获取第一个字符，结果为'H'
print(s[-1]) # 获取最后一个字符，结果为'!'
print(s[0:5]) # 获取从第一个字符到第五个字符之前的所有字符，结果为'Hello'
print(s[7:]) # 获取从第七个字符到最后一个字符的所有字符，结果为'world!’

列表（list）

列表是Python中最常用的数据类型之一，用于存储一组有序的数据，可以包含各种类型的元素。列表是可变的，即可以对列表中的元素进行添加、删除、修改等操作。

**元素：**列表中的一个值，可以是任何类型的数据。

**索引：**用于访问列表中元素的编号，从0开始递增。

**切片：**从列表中获取指定位置的子列表的操作，与字符串的切片类似。

实际代码演示：

# 定义列表
a = [1, 2, 3, 4, 5]
b = ['apple', 'banana', 'orange']
c = [1, 'apple', True, 3.14]
# 访问列表元素
print(a[0]) # 获取第一个元素，结果为
print(a[1]) # 获取第二个元素，结果为2
print(b[-1]) # 获取最后一个元素，结果为'orange'
# 修改列表元素
a[0] = 10 # 将第一个元素修改为10
print(a) # 结果为[10, 2, 3, 4, 5]
# 添加元素
a.append(6) # 在列表末尾添加一个元素
print(a) # 结果为[10, 2, 3, 4, 5, 6]
# 删除元素
del a[0] # 删除第一个元素
print(a) # 结果为[2, 3, 4, 5, 6]
# 切片
b = [1, 2, 3, 4, 5]
print(b[0:3]) # 获取从第一个元素到第三个元素之前的所有元素，结果为[1, 2, 3]
print(b[::2]) # 获取所有偶数位置的元素，结果为[1, 3, 5]

元组（tuple）

元组与列表类似，也可以用于存储一组有序的数据，但元组是不可变的，即不能对元组中的元素进行修改。元组可以包含各种类型的元素。

**元素：**元组中的一个值，可以是任何类型的数据。

**索引：**用于访问元组中元素的编号，从0开始递增。

**切片：**元组是不可变的，不能添加、修改、删除元素，只能进行切片操作，即从元组中获取指定位置的子元组的操作，与字符串和列表的切片类似。

实际代码演示：

# 定义元组
a = (1, 2, 3, 4, 5)
b = ('apple', 'banana', 'orange')
c = (1, 'apple', True, 3.14)
# 访问元组元素
print(a[0]) # 获取第一个元素，结果为1
print(b[-1]) # 获取最后一个元素，结果为'orange'
# 元组是不可变的
a[0] = 10 # 会抛出TypeError异常，因为元组是不可变的
# 切片
b = (1, 2, 3, 4, 5)
print(b[0:3]) # 获取从第一个元素到第三个元素之前的所有元素，结果为(1, 2, 3)
print(b[::2]) # 获取所有偶数位置的元素，结果为(1, 3, 5)

字典（dict）

字典是Python中用于存储键值对的数据类型，其中每个键都对应一个值。字典是可变的，即可以对字典中的键值对进行添加、删除、修改等操作。字典中的键必须是不可变的类型，如字符串、数字或元组等。

**键（key）：**在字典中用于访问值的唯一标识符，必须是不可变类型，如字符串、数字或元组。

**值（value）：**在字典中与键相关联的数据，可以是任何类型的数据。

**键值对：**在字典中，键和值组成的一个元素，也称为项（item）。

**键的映射：**指定键与值的对应关系。

实际代码演示：

# 定义字典
person = {'name': 'Alice', 'age': 20, 'gender': 'female'}
scores = {'English': 90, 'Math': 85, 'Chinese': 95}
# 访问字典元素
print(person['name']) # 获取名字，结果为'Alice'
print(scores.get('Math')) # 获取数学分数，结果为85
# 修改字典元素
person['age'] = 21 # 将年龄修改为21
print(person) # 结果为{'name': 'Alice', 'age': 21, 'gender': 'female'}
# 添加元素
scores['History'] = 80 # 添加历史成绩
print(scores) # 结果为{'English': 90, 'Math': 85, 'Chinese': 95, 'History': 80}
# 删除元素
del person['gender'] # 删除gender键值对
print(person) # 结果为{'name': 'Alice', 'age': 21}
# 遍历字典
for key, value in scores.items(): 
	print(key, value) # 依次输出每个键和对应的值

集合（set）

集合是Python中的另一个可变数据类型，用于存储一组无序的、不重复的元素。集合中的元素必须是不可变类型的，如数字、字符串或元组等。

**元素：**集合中的一个值，必须是不可变类型的数据。

**重复元素：**集合中重复的元素只会被保存一次。

**交集、并集、差集：**集合之间的三种基本操作。

实际代码演示：

# 定义集合
a = {1, 2, 3, 4, 5}
b = {'apple', 'banana', 'orange'}
# 访问集合元素
print(2 in a) # 判断2是否在集合a中，结果为True
print('pear' not in b) # 判断'pear'是否不在集合b中，结果为True
# 添加元素
a.add(6) # 在集合a中添加一个元素6
print(a) # 结果为{1, 2, 3, 4, 5, 6}
# 删除元素
a.remove(6) # 在集合a中删除元素6
print(a) # 结果为{1, 2, 3, 4, 5}
# 交集、并集、差集
c = {1, 3, 5, 7, 9}
d = {2, 4, 6, 8, 10}
print(c & d) # 输出交集，结果为set()
print(c | d) # 并集{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print(c - d) # 输出差集，结果为{1, 3, 5, 7, 9}

函数和模块

函数是一段可重用的代码块，可以将其多次调用，Python中的函数定义使用关键字def，并且可以带有参数和返回值。例如，下面的代码定义了一个简单的函数，用于计算两个数的和：

def add(x, y): 
	result = x + y 
	return result

上面的函数名为add，接受两个参数x和y，并将它们相加，将结果存储在变量result中，最后返回result的值。

函数的调用可以通过函数名和参数来完成。例如，调用上面的add函数，可以使用以下代码：

result = add(2, 3)
print(result) # 输出 5

上面的代码调用了add函数，并将参数2和3传递给函数，函数返回的结果为5，并将结果存储在变量result中，最后使用print函数输出结果。

模块，Python中的模块是一个包含函数、类、变量等的文件，可以通过导入模块的方式在程序中使用。模块通常以.py文件的形式存在。

下面的代码演示了如何定义一个模块，其中模块名为mymodule，包含一个函数add：

# [mymodule.py](http://mymodule.py/) 文件
def add(x, y): 
	result = x + y return result

使用该模块的方法之一是通过import语句导入模块：

import mymodule
result = mymodule.add(2, 3)
print(result) # 输出 5

上面的代码导入了mymodule模块，并使用mymodule.add函数计算2和3的和，最后输出结果。

除了使用import语句导入整个模块之外，还可以使用from关键字从模块中导入指定的函数或变量。例如，以下代码导入了mymodule模块中的add函数：

from mymodule import add
result = add(2, 3)
print(result) # 输出 5

Python还内置了很多标准模块，可以直接使用或通过import语句导入。例如，math模块包含了数学运算相关的函数和常量，可以使用以下代码导入并使用math模块：

import math
result = math.sqrt(25)
print(result) # 输出 5.0

控制流语句

在Python中，常用的控制流语句包括条件语句和循环语句。

条件语句

条件语句用于根据条件决定是否执行特定的代码块。在Python中，条件语句使用if、elif和else关键字来表示。下面是一个简单的例子：

x = 10
if x > 0: 
	print("x is positive")
elif x == 0: 
	print("x is zero")
else: 
	print("x is negative")

代码中，使用if关键字判断x是否大于0，如果满足条件，则执行后续的代码块；如果不满足，则继续判断elif语句，如果也不满足，则执行else语句。

循环语句

循环语句用于重复执行特定的代码块，直到满足某个条件。在Python中，常用的循环语句有while和for循环。下面是一个简单的例子：

# while循环
i = 0
while i < 5: 
	print(i) i += 1
# for循环
for i in range(5): 
	print(i)

代码中，使用while循环和for循环分别输出0到4的数字。

除了基本的if、elif、else、while和for语句之外，Python还提供了一些高级的控制流语句，如try、except、finally语句用于异常处理，以及break和continue语句用于控制循环的跳出和继续。

文件操作

在 Python 中可以通过文件操作实现数据的读写和处理。下面是一些基本的文件操作函数：

open()：打开文件并返回一个文件对象。
read()：从文件中读取指定数量的字符或所有字符并返回字符串。
readline()：从文件中读取一行数据并返回字符串。
readlines()：从文件中读取所有行并返回一个字符串列表。
write()：将指定字符串写入文件。
writelines()：将指定字符串列表写入文件。
close()：关闭文件。

下面是一个简单的例子，演示了如何使用这些函数从文件中读取内容并写入到另一个文件中：

# 打开文件
file1 = open('input.txt', 'r')
file2 = open('output.txt', 'w')

# 读取数据并写入到另一个文件中
for line in file1:
	file2.write(line)

# 关闭文件
file1.close()
file2.close()

在上面的代码中，首先使用open()函数打开了两个文件，input.txt用于读取数据，output.txt用于写入数据。接下来，使用for循环逐行读取input.txt文件中的内容，并使用write()函数将每行数据写入到output.txt文件中。最后使用close()函数关闭了这两个文件。

需要注意的是，使用完文件后一定要及时关闭文件。如果不关闭文件，可能会导致资源的浪费或其他错误。同时，还可以使用with语句来自动管理文件的打开和关闭，这样更加简洁和安全：

# 使用 with 语句打开文件
with open('input.txt', 'r') as file1, open('output.txt', 'w') as file2:
# 读取数据并写入到另一个文件中
**for** line **in** file1:
write(line)

在上面的代码中，使用了with语句打开了两个文件，并在with语句块内执行文件读写操作。with语句块执行完毕后，Python会自动关闭这两个文件，无需手动调用close()函数。

📎 参考文章

• 廖雪峰的官方网站
• 菜鸟教程
• 更多知识请前往Leo’s Blog