一篇文章带你入门python
一，Hello world
现在让我们来编写你的第一个 Python 程序。无论你选择哪种开发环境，都可以按照以下步骤进行：
-
打开你的开发环境（PyCharm、VS Code 或 IDLE）
-
创建一个新的 Python 文件（通常扩展名为.py）
-
在文件中输入以下代码：
print("Hello, World!")
-
保存文件并运行
-
你应该在控制台看到输出：
Hello, World!
这就是 Python 的 “Hello, World!” 程序。print()是 Python 的内置函数，用于在控制台输出内容。
练习 1：输出你的名字
修改代码，输出你自己的名字：
print("你的名字")
练习 2：输出多行内容
尝试输出多行内容，使用多个print()函数：
print("第一行")
print("第二行")
print("第三行")
二、变量与数据类型
2.1 变量的概念与定义
在 Python 中，变量就像是存储数据的 “容器” 或 “智能文件柜”。你可以把它想象成一个带有标签的盒子，里面可以存放各种数据。
变量的定义规则（必记）：
-
变量名只能由字母、数字和下划线组成，不能包含中文或特殊符号
-
不能以数字开头，必须以字母或下划线开头
-
区分大小写（
Name和name是两个不同的变量） -
不能使用 Python 关键字（如
if、else、for等） -
建议使用有意义的变量名，做到 “见名知意”
变量赋值语法：
变量名 = 值
这里的=不是数学上的 “等于”，而是 “赋值” 操作，意思是把右边的值存储到左边的变量中。
变量定义示例：
\# 定义不同类型的变量
name = "张三" # 字符串类型
age = 22 # 整数类型
height = 180.5 # 浮点数类型
is\_student = True # 布尔类型
同时定义多个变量：
\# 方式1：多个变量赋不同值
money, hometown = 500.8, "广州" # money=500.8，hometown="广州"
\# 方式2：多个变量赋相同值
a = b = c = 0 # 都赋值为0
2.2 基本数据类型
Python 有 5 种核心基础数据类型，掌握它们足够应对 80% 的入门场景：
| 数据类型 | 英文标识 | 定义 | 示例 | 常用场景 |
|---|---|---|---|---|
| 整数 | int | 无小数点的数字（正 / 负 / 零） | 22、-5、0 | 年龄、数量、序号 |
| 浮点数 | float | 带小数点的数字（支持科学计数法） | 180.5、99.9、3e2（=300） | 身高、体重、金额 |
| 字符串 | str | 用单 / 双 / 三引号包裹的字符序列 | “张三”、‘Python’、‘’’ 多行文本 ‘’’ | 姓名、地址、文本描述 |
| 布尔值 | bool | 仅两个值：True（真）/False（假） | True、False | 条件判断、逻辑运算 |
| None | NoneType | 表示 “什么都没有” 的特殊类型 | None | 初始化变量、表示空值 |
数据类型的特点：
-
整数（int）：Python 支持任意大小的整数，不会溢出
-
浮点数（float）：存在精度误差，如 0.1+0.2≠0.3，需用
round(0.1+0.2, 1)==0.3进行比较 -
布尔值（bool）：可参与数字运算（True+1=2，False*5=0），但不推荐
-
字符串（str）：不可修改，如
name[0]="李"会报错，需通过切片或拼接生成新字符串
2.3 查看和判断数据类型
查看变量类型：使用type()函数
name = "张三"
age = 22
height = 180.5
is\_student = True
print(type(name)) # 输出：\<class 'str'>
print(type(age)) # 输出：\<class 'int'>
print(type(height)) # 输出：\<class 'float'>
print(type(is\_student))# 输出：\<class 'bool'>
判断类型（推荐）：使用isinstance()函数
print(isinstance(age, int)) # 输出：True
print(isinstance(height, str)) # 输出：False
\# 多类型判断（判断是否为数字类型）
print(isinstance(age, (int, float))) # 输出：True
2.4 数据类型转换
不同数据类型之间可以相互转换，这在实际编程中经常用到。
核心转换函数：
| 转换函数 | 功能 | 示例 | 结果 | 注意事项 |
|---|---|---|---|---|
| int(x) | 转换为整数 | int(“22”)、int(18.8)、int(True) | 22、18、1 | 字符串需为纯数字，浮点数截断小数 |
| float(x) | 转换为浮点数 | float(“180.5”)、float(22)、float(False) | 180.5、22.0、0.0 | 字符串需为数字格式 |
| str(x) | 转换为字符串 | str(22)、str(180.5)、str(True) | “22”、“180.5”、“True” | 所有类型均可转换，无报错风险 |
| bool(x) | 转换为布尔值 | bool(0)、bool(“”)、bool(“Python”)、bool(None) | False、False、True、False | 0 / 空值 / None→False，非 0 / 非空→True |
类型转换示例：
\# 字符串转整数
price\_str = "299"
price\_int = int(price\_str)
print(price\_int) # 输出：299
\# 浮点数转整数（直接砍掉小数）
year = int(2024.99)
print(year) # 输出：2024
\# 数字转字符串（超级常用）
score = 95.5
score\_str = str(score)
print(score\_str) # 输出："95.5"
\# 布尔值转换
print(int(True)) # 输出：1
print(int(False)) # 输出：0
print(float(True)) # 输出：1.0
2.5 输入输出函数
input()函数：用于获取用户输入，默认返回字符串类型
\# 基础用法
hobby = input("请输入你的爱好：")
print(f"我的爱好是：{hobby}")
\# 进阶用法：结合变量默认值
user\_age = input("请输入你的年龄（默认20）：") or 20
print(f"年龄：{user\_age}")
格式化输出：使用 f-string（Python 3.6 + 推荐）
name = "张三"
age = 22
height = 180.5
\# 传统方式
print("姓名：" + name + "，年龄：" + str(age))
\# f-string方式（推荐）
print(f"姓名：{name}，年龄：{age}，身高：{height}cm")
2.6 变量与数据类型练习
练习 1：定义个人信息变量
定义以下变量并输出：
-
姓名（字符串）
-
年龄（整数）
-
体重（浮点数）
-
是否已婚（布尔值）
示例输出：
姓名：张三
年龄：25
体重：70.5kg
是否已婚：False
练习 2：类型转换练习
-
将字符串 “123” 转换为整数并加 7，输出结果
-
将整数 25 转换为字符串并与 “岁” 拼接
-
将浮点数 3.14 转换为整数，观察结果
-
将布尔值 True 转换为整数，False 转换为整数
练习 3：用户输入练习
编写程序：
-
获取用户输入的姓名
-
获取用户输入的年龄（注意：input () 返回字符串，需要转换为整数）
-
计算并输出用户明年的年龄
-
输出欢迎信息，包含姓名和年龄
示例运行：
请输入你的姓名：李四
请输入你的年龄：20
李四，你明年就21岁啦！
练习 4：温度转换
编写程序，将华氏温度转换为摄氏温度：
-
公式：C = (F - 32) * 5/9
-
获取用户输入的华氏温度（字符串）
-
转换为浮点数进行计算
-
输出结果，保留 1 位小数
三、运算符
3.1 算术运算符
算术运算符用于基本的数学运算：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| + | 加法 | 10 + 3 | 13 |
| - | 减法 | 10 - 3 | 7 |
| * | 乘法 | 10 * 3 | 30 |
| / | 除法（结果为浮点数） | 10 / 3 | 3.333… |
| // | 整除（结果为整数） | 10 // 3 | 3 |
| % | 取余（取模） | 10 % 3 | 1 |
| ** | 幂运算 | 10 ** 3 | 1000 |
示例代码：
a, b = 10, 3
print(f"加法: {a + b}") # 13
print(f"减法: {a - b}") # 7
print(f"乘法: {a \* b}") # 30
print(f"除法: {a / b:.2f}") # 3.33 (浮点数)
print(f"整除: {a // b}") # 3 (整数)
print(f"取模: {a % b}") # 1 (余数)
print(f"幂运算: {a \*\* b}") # 1000 (10的3次方)
注意事项：
-
/除法总是返回浮点数 -
//整除会向下取整，如-10 // 3 = -4 -
%取模运算的结果符号与除数相同
3.2 比较运算符
比较运算符用于比较两个值，返回布尔值（True/False）：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| > | 大于 | 10 > 5 | True |
| < | 小于 | 10 < 5 | False |
| >= | 大于等于 | 10 >= 5 | True |
| <= | 小于等于 | 10 <= 5 | False |
| == | 等于 | 10 == 5 | False |
| != | 不等于 | 10 != 5 | True |
示例代码：
print(10 > 5) # True
print(10 == "10") # False (类型不同)
print(True == 1) # True (布尔值本质是整数)
print(\[100] == \[100]) # True (值相同)
链式比较（Python 特色）：
\# 判断x是否在1到10之间
x = 5
print(1 < x < 10) # 等价于 1 < x and x < 10，输出：True
3.3 逻辑运算符
逻辑运算符用于组合条件判断：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| and | 与（左右都为真则结果为真） | True and False | False |
| or | 或（左右有一个为真则结果为真） | False or 0 | 0 |
| not | 非（取反） | not True | False |
注意：and和or的返回值不是单纯的 True 或 False，而是返回最后计算的操作数的值：
-
and：如果左侧为真，返回右侧；如果左侧为假，返回左侧 -
or：如果左侧为真，返回左侧；如果左侧为假，返回右侧
示例代码：
\# and运算
print(True and False) # False
print(10 > 5 and "a" in "apple") # True
\# or运算（返回最后一个操作数）
print(False or 0) # 0
print(10 < 5 or "b" in "apple") # False
\# not运算
print(not True) # False
3.4 赋值运算符
赋值运算符用于给变量赋值，除了基本的=，还有多种复合赋值运算符：
| 运算符 | 描述 | 示例 | 等价于 |
|---|---|---|---|
| = | 赋值 | x = 10 | x = 10 |
| += | 加后赋值 | x += 5 | x = x + 5 |
| -= | 减后赋值 | x -= 5 | x = x - 5 |
| *= | 乘后赋值 | x *= 5 | x = x * 5 |
| /= | 除后赋值 | x /= 5 | x = x / 5 |
| //= | 整除后赋值 | x //= 5 | x = x // 5 |
| %= | 取模后赋值 | x %= 5 | x = x % 5 |
| **= | 幂运算后赋值 | x **= 5 | x = x ** 5 |
示例代码：
x = 10
x += 5 # 等价于 x = x + 5
print(x) # 输出：15
y = 20
y //= 3 # 等价于 y = y // 3
print(y) # 输出：6
\# 多重赋值（交换变量值）
a, b = 1, 2
a, b = b, a # 交换a和b的值
print(a, b) # 输出：2 1
3.5 运算符优先级
运算符优先级决定了表达式的计算顺序。记住以下规则：
-
** 括号 ()** 具有最高优先级，永远先算括号内的内容
-
幂运算（**）优先级最高
-
正负号和按位取反（+x、-x、~x）
-
乘除取余整除（*、/、%、//）
-
加减（+、-）
-
比较运算符（>、<、>=、<=、==、!=）
-
逻辑运算符（not、and、or）
示例：
\# 计算顺序：先算2\*\*3=8，再算4\*8=32，然后32//5=6，最后3+6-1=8
result = 3 + 4 \* 2 \*\* 3 // 5 - 1
print(result) # 输出：8
\# 使用括号改变优先级
result = ((3 + 4) \* (2 \*\* 3)) // (5 - 1)
print(result) # 输出：14 (7\*8//4=14)
3.6 运算符练习
练习 1：数学表达式计算
计算以下表达式的值并输出：
-
10 + 20 * 3
-
(10 + 20) * 3
-
2 ** 3 ** 2 # 注意：右结合，等价于 2(32)
-
10 / 3 + 10 % 3
-
10 > 5 and 6 < 10
-
not (10 > 5)
练习 2：计算圆的面积和周长
编写程序：
-
定义圆的半径 r = 5
-
计算面积：面积 = π * r²
-
计算周长：周长 = 2 * π * r
-
输出结果，保留 2 位小数
提示：使用import math导入数学模块，math.pi表示 π
练习 3：判断闰年
编写程序，判断输入的年份是否为闰年：
-
能被 4 整除但不能被 100 整除
-
或者能被 400 整除
示例运行：
请输入年份：2020
2020年是闰年
练习 4：成绩等级判断
根据输入的成绩，判断等级：
-
90 分以上：优秀
-
80-89 分：良好
-
70-79 分：中等
-
60-69 分：及格
-
60 分以下：不及格
四、控制语句
4.1 条件语句（if-elif-else）
条件语句让程序能够根据不同条件执行不同的代码块。Python 的条件语句非常简洁，使用if、elif（else if 的缩写）和else关键字。
条件语句的三种形式：
1. 单分支结构（if）
if 条件表达式:
  满足条件时执行的代码
示例：判断是否成年
age = int(input("请输入你的年龄："))
if age >= 18:
  print("你已成年，可以独立上网～")
2. 双分支结构（if-else）
if 条件表达式:
  满足条件时执行的代码
else:
  不满足条件时执行的代码
示例：判断数字奇偶性
num = int(input("请输入一个整数："))
if num % 2 == 0:
  print(f"{num} 是偶数")
else:
  print(f"{num} 是奇数")
3. 多分支结构（if-elif-else）
if 条件1:
  执行代码1
elif 条件2:
  执行代码2
elif 条件3:
  执行代码3
else:
  所有条件都不满足时执行的代码
示例：判断成绩等级
score = int(input("请输入你的成绩："))
if score >= 90:
  print("优秀")
elif score >= 80:
  print("良好")
elif score >= 70:
  print("中等")
elif score >= 60:
  print("及格")
else:
  print("不及格，需要补考～")
条件语句的注意事项：
-
条件表达式后必须加冒号
: -
代码块必须缩进（通常 4 个空格）
-
elif可以有多个，但else最多只能有一个 -
支持条件嵌套，但嵌套层级不宜过多（建议不超过 3 层）
4.2 循环语句
循环语句让程序能够重复执行某段代码。Python 有两种循环：for循环和while循环。
1. for 循环：遍历可迭代对象
for循环适合已知循环次数或遍历序列的场景。
基本语法：
for 变量 in 可迭代对象:
  循环体代码
range()函数：生成整数序列，是for循环的好搭档
-
range(n)：生成 0~n-1 的序列 -
range(a, b)：生成 a~b-1 的序列 -
range(a, b, step)：生成 a~b-1 的序列，步长为 step
示例：打印 1-10
for i in range(1, 11):
  print(i)
示例：计算 1-100 的和
total = 0
for i in range(1, 101):
  total += i
print(f"1到100的和为：{total}")
遍历字符串：
s = "Python"
for c in s:
  print(c)
遍历列表：
fruits = \["apple", "banana", "orange"]
for fruit in fruits:
  print(fruit)
2. while 循环：条件循环
while循环适合不确定循环次数，但知道循环终止条件的场景。
基本语法：
while 条件:
  循环体代码
  （必须有更新循环变量的代码，避免死循环）
示例：打印 1-10
num = 1
while num <= 10:
  print(num)
  num += 1 # 必须更新循环变量，否则会无限循环
示例：计算 5 的阶乘
n = 5
result = 1
while n >= 1:
  result \*= n
  n -= 1
print(f"{5}的阶乘是：{result}")
4.3 循环控制语句（break 和 continue）
break和continue用于灵活控制循环执行：
1. break：终止整个循环
遇到break直接退出循环，后续循环体不再执行。
示例：模拟吃包子，吃到第 3 个发现虫子
for i in range(1, 6):
  if i == 3:
  print(f"吃到第{i}个包子，发现半只虫！停止进食～")
  break
  print(f"吃完第{i}个包子")
输出：
吃完第1个包子
吃完第2个包子
吃到第3个包子，发现半只虫！停止进食～
2. continue：跳过本次循环
遇到continue跳过当前循环体剩余代码，直接判断下一次循环条件。
示例：模拟吃包子，吃到第 3 个发现虫子，扔掉这个继续吃
for i in range(1, 6):
  if i == 3:
  print(f"吃到第{i}个包子，发现一只虫！扔掉这个～")
  continue
  print(f"吃完第{i}个包子")
输出：
吃完第1个包子
吃完第2个包子
吃到第3个包子，发现一只虫！扔掉这个～
吃完第4个包子
吃完第5个包子
4.4 循环的 else 子句
Python 的循环可以有一个else子句，当循环正常结束时执行（即没有被break终止）。
示例：
\# 寻找100以内的质数
for num in range(2, 100):
  is\_prime = True
  for i in range(2, int(num\*\*0.5) + 1):
  if num % i == 0:
  is\_prime = False
  break
  if is\_prime:
  print(f"{num}是质数")
else:
  print("100以内的质数已经全部找到")
4.5 控制语句练习
练习 1：打印乘法表
使用for循环打印 9x9 乘法表：
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
...
9×9=81
练习 2：计算 1 到 100 的偶数和
使用while循环计算 1 到 100 所有偶数的和。
练习 3：猜数字游戏
编写一个简单的猜数字游戏：
-
程序随机生成一个 1-100 之间的数字
-
用户输入猜测的数字
-
程序提示 “太大了” 或 “太小了”
-
直到猜对为止，输出猜测次数
提示：使用import random，random.randint(1, 100)生成随机数
练习 4：打印菱形
使用循环打印一个菱形：
  \*
  \*\*\*
  \*\*\*\*\*
 \*\*\*\*\*\*\*
  \*\*\*\*\*
  \*\*\*
  \*
五、函数
5.1 函数的定义与调用
函数是一段封装了特定逻辑的可重复执行的代码块。使用函数的好处是：
-
代码复用：避免重复编写相同逻辑
-
模块化：将复杂问题拆解为小函数
-
可维护性：修改函数内部逻辑不影响其他调用处
函数定义的基本语法：
def 函数名(参数列表):
  """函数文档字符串（可选）：描述函数功能、参数、返回值"""
  函数体（具体逻辑）
  return 返回值（可选）
最简单的函数：无参数无返回值
def print\_welcome():
  """打印欢迎信息"""
  print("欢迎使用本系统！")
\# 调用函数
print\_welcome() # 输出：欢迎使用本系统！
带参数的函数
def add(a, b):
  """计算a和b的和并返回"""
  result = a + b
  return result
\# 调用函数
sum\_result = add(3, 5) # 实参3、5分别传给形参a、b
print(sum\_result) # 输出：8
5.2 函数参数详解
Python 支持多种参数类型，让函数更加灵活：
1. 位置参数（必选参数）
最基础的参数类型，必须按顺序传入，数量与形参一致。
示例：
def print\_user(name, age):
  print(f"姓名：{name}，年龄：{age}")
\# 正确调用
print\_user("张三", 25) # 输出：姓名：张三，年龄：25
\# 错误：参数数量不符
\# print\_user("张三") # 报错：缺少1个位置参数
\# 错误：参数顺序错误
print\_user(25, "张三") # 输出：姓名：25，年龄：张三（逻辑错误）
2. 默认参数（缺省参数）
定义函数时给参数指定默认值，调用时可省略该参数。
规则：默认参数必须放在位置参数后面。
示例：
def print\_user(name, age, gender="男"):
  print(f"姓名：{name}，年龄：{age}，性别：{gender}")
\# 调用：使用默认值
print\_user("张三", 25) # 输出：姓名：张三，年龄：25，性别：男
\# 调用：覆盖默认值
print\_user("李四", 22, "女") # 输出：姓名：李四，年龄：22，性别：女
注意：默认参数的值在函数定义时确定，且默认参数最好是不可变对象（如 int、str），避免使用 list、dict 等可变对象。
3. 关键字参数
调用函数时，通过 “参数名 = 值” 的形式传入参数，可忽略顺序。
示例：
def calculate(a, b, c):
  return a + b \* c
\# 按位置传参
print(calculate(2, 3, 4)) # 2 + 3\*4 = 14
\# 按关键字传参
print(calculate(a=2, b=3, c=4)) # 14
print(calculate(b=3, c=4, a=2)) # 14（顺序无关）
\# 混合使用：位置参数必须在关键字参数前面
print(calculate(2, b=3, c=4)) # 14
*4. 可变位置参数（args）
当参数数量不确定时，用*args接收多个位置参数，返回一个元组。
示例：
def sum\_numbers(\*args):
  """计算任意多个数的和"""
  print("接收的参数：", args) # args是元组
  return sum(args)
\# 调用：传入任意数量的参数
print(sum\_numbers(1, 2, 3)) # 输出：6
print(sum\_numbers(10, 20, 30, 40)) # 输出：100
\# 传入列表/元组：用\*解包
nums = \[1, 2, 3, 4]
print(sum\_numbers(\*nums)) # 等价于sum\_numbers(1,2,3,4) → 10
**5. 可变关键字参数（kwargs）
用**kwargs接收多个关键字参数，返回一个字典。
示例：
def print\_info(\*\*kwargs):
  """打印用户的任意属性"""
  print("接收的参数：", kwargs) # kwargs是字典
  for key, value in kwargs.items():
  print(f"{key}：{value}")
\# 调用：传入任意多个关键字参数
print\_info(name="张三", age=25, gender="男")
\# 传入字典：用\*\*解包
user = {"name": "李四", "age": 22, "city": "北京"}
print\_info(\*\*user) # 等价于print\_info(name="李四", age=22, city="北京")
参数组合顺序（必须严格遵守）：
位置参数 → 默认参数 → 可变位置参数（\*args） → 可变关键字参数（\*\*kwargs）
示例：
def func(a, b, c=0, \*args, \*\*kwargs):
  print(f"a={a}, b={b}, c={c}, args={args}, kwargs={kwargs}")
func(1, 2, 3, 4, 5, x=6, y=7)
\# 输出：a=1, b=2, c=3, args=(4, 5), kwargs={'x': 6, 'y': 7}
5.3 函数的返回值
return语句用于返回函数的执行结果：
基本用法：
def add(a, b):
  return a + b
result = add(3, 5)
print(result) # 输出：8
返回多个值（本质是返回元组）：
def get\_user():
  name = "张三"
  age = 25
  gender = "男"
  return name, age, gender # 等价于return (name, age, gender)
\# 方式1：用一个变量接收（得到元组）
user\_info = get\_user()
print(user\_info) # 输出：('张三', 25, '男')
\# 方式2：自动解包
name, age, gender = get\_user()
print(name, age, gender) # 输出：张三 25 男
函数没有 return 语句：
如果函数没有return语句，默认返回None。
def greet():
  print("Hello!")
result = greet()
print(result) # 输出：None
5.4 函数的高级特性
1. 嵌套函数
在函数内部定义另一个函数：
def outer\_func(name):
  def inner\_func():
  print(f"Hello, {name}")
   
  inner\_func() # 调用内部函数
outer\_func("张三") # 输出：Hello, 张三
2. 递归函数
函数直接或间接调用自身：
def factorial(n):
  """计算n的阶乘"""
  if n == 1: # 终止条件
  return 1
  return n \* factorial(n - 1)
print(factorial(5)) # 输出：120（5×4×3×2×1）
注意：递归必须有终止条件，否则会导致无限递归。Python 默认递归深度约 1000。
3. 匿名函数（lambda）
用lambda关键字定义的简洁函数，仅能包含一个表达式：
\# 定义匿名函数
add = lambda a, b: a + b
print(add(2, 3)) # 输出：5
\# 常用于临时场景（如排序的key参数）
users = \[("张三", 25), ("李四", 22), ("王五", 30)]
sorted\_users = sorted(users, key=lambda x: x\[1])
print(sorted\_users) # 输出：\[('李四', 22), ('张三', 25), ('王五', 30)]
5.5 函数练习
练习 1：定义一个简单的计算器
定义函数calculator(a, b, op)，实现加减乘除运算：
-
op 为 ‘+’ 时返回 a+b
-
op 为 ‘-’ 时返回 a-b
-
op 为’’ 时返回 ab
-
op 为 ‘/’ 时返回 a/b（注意处理除零错误）
练习 2：判断素数
定义函数is_prime(n)，判断一个数是否为素数：
-
素数定义：大于 1 的自然数，除了 1 和它本身没有其他因数
-
1 不是素数
-
2 是最小的素数
练习 3：生成斐波那契数列
定义函数fibonacci(n)，返回前 n 个斐波那契数：
-
斐波那契数列：1, 1, 2, 3, 5, 8, 13, …
-
第 1 项和第 2 项都是 1
-
从第 3 项开始，每一项等于前两项之和
练习 4：统计字符串中元音字母的个数
定义函数count_vowels(s)，统计字符串 s 中元音字母（a,e,i,o,u，不区分大小写）的个数。
六、面向对象编程基础（选学）
虽然面向对象编程（OOP）对于初学者来说可能比较复杂，但了解一些基础概念还是有必要的。
6.1 类与对象
在面向对象编程中，** 类（Class）是对象的模板，而对象（Object）** 是类的实例。
定义类的基本语法：
class 类名:
  def \_\_init\_\_(self, 参数列表):
  """构造函数，用于初始化对象"""
  self.属性 = 参数
   
  def 方法名(self, 参数列表):
  """类的方法"""
  方法体
示例：定义一个 Person 类
class Person:
  def \_\_init\_\_(self, name, age):
  self.name = name # 实例属性
  self.age = age
   
  def say\_hello(self):
  """实例方法"""
  print(f"大家好，我叫{self.name}，今年{self.age}岁。")
\# 创建对象（实例化）
p1 = Person("张三", 25)
p2 = Person("李四", 22)
\# 调用对象的方法
p1.say\_hello() # 输出：大家好，我叫张三，今年25岁。
p2.say\_hello() # 输出：大家好，我叫李四，今年22岁。
\# 访问对象的属性
print(p1.name) # 输出：张三
print(p2.age) # 输出：22
6.2 类的继承
继承是面向对象编程的重要特性，让子类可以继承父类的属性和方法。
示例：定义 Student 类，继承自 Person
class Student(Person):
  def \_\_init\_\_(self, name, age, grade):
  # 调用父类的构造函数
  super().\_\_init\_\_(name, age)
  self.grade = grade # 学生特有的属性
   
  def study(self):
  """学生特有的方法"""
  print(f"{self.name}正在学习，年级是{self.grade}。")
\# 创建Student对象
s1 = Student("王五", 18, "高三")
s1.say\_hello() # 调用从Person继承的方法
s1.study() # 调用Student特有的方法
七、文件操作基础
文件操作是实际编程中经常用到的技能，用于读取和写入文件。
7.1 文件的打开与关闭
使用open()函数打开文件，使用close()方法关闭文件：
\# 打开文件（默认以只读模式打开）
f = open("example.txt", "r")
\# 关闭文件
f.close()
推荐使用with语句，它会自动处理文件的打开和关闭：
with open("example.txt", "r") as f:
  # 文件操作代码
  pass # 这里写文件读取或写入的代码
\# 离开with块后，文件自动关闭
7.2 文件读取
读取整个文件内容：
with open("example.txt", "r") as f:
  content = f.read()
  print(content)
按行读取：
with open("example.txt", "r") as f:
  # 方式1：读取所有行，返回列表
  lines = f.readlines()
  for line in lines:
  print(line)
   
  # 方式2：逐行读取（推荐，内存占用小）
  for line in f:
  print(line)
7.3 文件写入
写入文件（覆盖模式）：
with open("output.txt", "w") as f:
  f.write("第一行\n")
  f.write("第二行\n")
追加内容（追加模式）：
with open("output.txt", "a") as f:
  f.write("第三行\n")
7.4 文件操作练习
练习 1：统计文件行数
编写程序，统计一个文本文件的行数。
练习 2：复制文件
编写程序，将一个文件的内容复制到另一个文件。
练习 3：读取 CSV 文件
有一个 scores.csv 文件，内容如下：
姓名,语文,数学,英语
张三,85,90,88
李四,92,87,95
王五,78,85,82
编写程序读取这个文件，计算每个人的总分和平均分。
八、Python 学习资源推荐
8.1 在线学习平台
国内平台：
- 慕课网（IMOOC）
-
特点：专注实战的在线 IT 教育平台，拥有 1800 + 一线企业讲师
-
优势：560 + 免费课程，450 + 实战课程，每月更新 4-6 门新课
-
适合人群：从零基础到进阶的全阶段学习者
- 中国大学 MOOC
-
特点：汇聚国内顶尖高校课程资源
-
推荐课程：北京理工大学嵩天教授的《Python 语言程序设计》
- Python123
-
特点：专门的 Python 学习平台，提供 200 + 编程题挑战
-
优势：内置在线编程环境，无需本地配置
- 菜鸟教程
-
特点：内容全面系统，讲解通俗易懂
-
优势：每个知识点都配有代码演示
国外平台：
- Codecademy
-
特点：互动式学习，实时编写代码
-
优势：课程设计以任务驱动，提供即时反馈
- Coursera - Python for Everybody
-
特点：密歇根大学出品，专为零基础设计
-
优势：涵盖 Python 基础到数据处理的完整体系
- freeCodeCamp
-
特点：免费开源的编程学习平台
-
优势：包含大量实际项目和练习
8.2 编程练习网站
算法练习：
- LeetCode（力扣）
-
特点：全球最知名的算法刷题平台
-
优势：拥有海量题目，涵盖各种数据结构和算法
- 洛谷
-
特点：面向青少年编程的平台
-
优势：题目难度分级明确，适合循序渐进
- 牛客网
-
特点：国内热门的 IT 求职刷题平台
-
优势：包含大量 Python 面试题，也有适合初学者的基础题
基础语法练习：
- PythonTip
-
特点：专门的 Python 练习平台
-
优势：题目偏向 Python 基础和基础算法，难度友好
- PYnative
-
网址：https://pynative.com/python-basic-exercise-for-beginners/
-
特点：提供 40 + 基础编程练习
-
优势：每道题都有详细解答
- Python Challenge
-
特点：游戏化的 Python 学习平台
-
优势：通过解谜的方式学习，趣味性强
8.3 经典入门书籍
零基础入门首选：
- 《Python 编程：从入门到实践（第 3 版）》
-
作者：Eric Matthes
-
特点：全球超过 250 万读者的入门首选
-
优势：采用 “基础 + 实战” 双轨模式，包含 185 道习题及解析
- 《Head First Python》
-
作者：Paul Barry
-
特点：采用独特的图文结合方式
-
优势：讲解生动形象，非常适合初学者
- 《笨办法学 Python》
-
特点：通过 52 个循序渐进的练习学习
-
优势：强调 “反复敲代码” 的学习方法
进阶提高：
- 《流畅的 Python（第 2 版）》
-
作者：Luciano Ramalho
-
特点：深入探讨 Python 底层机制和高级特性
-
适合：有一定基础，想要深入理解 Python 的学习者
- 《Python Cookbook》
-
作者：David Beazley 等
-
特点：Python 技巧和代码示例大全
-
适合：希望提升编程技巧的开发者
8.4 学习建议
-
循序渐进：从基础语法开始，逐步深入到函数、类等高级概念
-
多写代码：编程是一门实践技能，必须通过大量练习才能掌握
-
阅读优秀代码：在 GitHub 上搜索 Python 项目，学习他人的代码风格
-
加入社区：参与 Python 社区讨论，遇到问题及时寻求帮助
-
项目驱动：通过做小项目来巩固所学知识，如爬虫、数据分析等
结语
恭喜你完成了这份 Python 入门指南的学习！从变量到函数，从条件语句到循环，你已经掌握了 Python 编程的核心基础。现在你可以开始编写自己的 Python 程序了。
记住，编程学习的关键在于实践。不要害怕犯错误，每一个错误都是学习的机会。建议你从简单的小程序开始，逐步挑战更复杂的项目。
最后，送你一句 Python 的设计哲学：“Simple is better than complex”（简单胜于复杂）。Python 的魅力就在于它的简洁和优雅，希望你在编程的道路上享受这种简洁之美。
加油！期待你在 Python 的世界里创造出属于自己的精彩！
小龙虾开发者社区是 CSDN 旗下专注 OpenClaw 生态的官方阵地，聚焦技能开发、插件实践与部署教程，为开发者提供可直接落地的方案、工具与交流平台，助力高效构建与落地 AI 应用
更多推荐
10
0- 0
已为社区贡献1条内容
所有评论(0)