Python 基础入门指南

2.3 变量与数据类型

2.3.1 变量定义

变量是程序中存储数据的容器，Python 定义变量无需声明类型，直接赋值即可：

# 变量定义：变量名 = 值 name = "张三" # 字符串类型 age = 20 # 整数类型 height = 1.75 # 浮点数类型 is_student = True # 布尔类型 # 输出变量值 print(name) # 结果：张三 print(age) # 结果：20 print(height) # 结果：1.75 print(is_student) # 结果：True # 变量重新赋值（可改变类型） age = 21 # 整数类型 age = "二十一岁" # 字符串类型 print(age) # 结果：二十一岁 

2.3.2 变量命名规则

• 只能以字母、下划线开头，不能以数字开头
• 只能包含字母、数字和下划线，不能有空格、特殊符号
• 区分大小写（name 和 Name 是两个不同变量）
• 不能使用 Python 关键字（如 if、for、while 等）

# 合法的变量名 user_name = "李四" _user_age = 22 age18 = 18 # 非法的变量名（运行会报错） # 1age = 18 # 以数字开头 # user name = "王五" # 包含空格 # if = 10 # 使用关键字作为变量名 

2.3.3 基本数据类型

Python 内置的核心数据类型可分为以下几类：

（1）数值类型

# 整数（int）：正整数、负整数、0 a = 10 b = -5 c = 0 print(type(a)) # 查看类型：<class 'int'> # 浮点数（float）：带小数点的数 d = 3.14 e = -2.5 print(type(d)) # <class 'float'> # 复数（complex）：由实部和虚部组成，虚部以 j 结尾 f = 3 + 4j print(f.real) # 实部：3.0 print(f.imag) # 虚部：4.0 print(type(f)) # <class 'complex'> # 数值运算 print(10 + 5) # 加法：15 print(10 - 5) # 减法：5 print(10 * 5) # 乘法：50 print(10 / 5) # 除法：2.0（结果为浮点数） print(10 // 5) # 整除：2（取整数部分） print(10 % 3) # 取模（余数）：1 print(2 ** 3) # 幂运算：8（2 的 3 次方） 

（2）字符串（str）

字符串是字符的序列，用单引号、双引号或三引号包裹：

# 字符串定义 s1 = '单引号字符串' s2 = "双引号字符串"""三引号字符串 支持换行 适合长文本""" # 字符串拼接 print("Hello" + " " + "Python") # 结果：Hello Python # 字符串重复 print("Python " * 3) # 结果：Python Python Python # 字符串索引（从 0 开始） s = "Python" print(s[0]) # 第一个字符：P print(s[-1]) # 最后一个字符：n # 字符串切片：[起始索引：结束索引：步长] print(s[0:3]) # 前 3 个字符：Pyt print(s[::2]) # 每隔一个字符：Pto print(s[::-1]) # 反转字符串：nohtyP # 字符串常用方法 s = " Hello Python " print(s.strip()) # 去除首尾空格：Hello Python print(s.upper()) # 转大写： HELLO PYTHON print(s.lower()) # 转小写： hello python print(s.replace("Python", "World")) # 替换： Hello World # 字符串格式化 name = "张三" age = 20 # 方法 1：f-string（Python 3.6+ 推荐） print(f"姓名：{name}，年龄：{age}") # 结果：姓名：张三，年龄：20 # 方法 2：format 方法 print("姓名：{}，年龄：{}".format(name, age)) # 结果同上 # 方法 3：% 格式化（旧方式） print("姓名：%s，年龄：%d" % (name, age)) # 结果同上 

（3）布尔类型（bool）

布尔类型只有两个值：True（真）和 False（假），常用于条件判断：

# 布尔值定义 is_true = True is_false = False # 比较运算返回布尔值 print(5 > 2) # True print(5 == 2) # False print(5 != 2) # True print(5 >= 5) # True # 逻辑运算 print(True and False) # 与运算：False print(True or False) # 或运算：True print(not True) # 非运算：False # 空值判断 print(bool(0)) # False print(bool("")) # False print(bool([])) # False print(bool(1)) # True print(bool("abc")) # True 

（4）类型转换

Python 提供内置函数实现不同类型之间的转换：

# 转整数 print(int("100")) # 100 print(int(3.99)) # 3（向下取整） print(int(True)) # 1 print(int(False)) # 0 # 转浮点数 print(float("3.14")) # 3.14 print(float(10)) # 10.0 # 转字符串 print(str(100)) # "100" print(str(3.14)) # "3.14" print(str(True)) # "True" # 转布尔值 print(bool(0)) # False print(bool("")) # False print(bool([1,2])) # True 

三、Python 控制流

控制流决定程序的执行顺序，包括条件语句和循环语句。

3.1 条件语句（if-elif-else）

根据条件判断执行不同代码块：

# 基本 if 语句 score = 85 if score >= 60: print("及格") # if-else 语句 if score >= 90: print("优秀") else: print("非优秀") # if-elif-else 语句（多条件判断） if score >= 90: print("优秀") elif score >= 80: print("良好") elif score >= 70: print("中等") elif score >= 60: print("及格") else: print("不及格") # 嵌套 if 语句 age = 18 is_student = True if age >= 18: print("已成年") if is_student: print("且是学生") else: print("但不是学生") else: print("未成年") # 三元运算符（简化 if-else） result = "及格" if score >= 60 else "不及格" print(result) # 结果：及格 

3.2 循环语句

3.2.1 for 循环

遍历可迭代对象（字符串、列表、元组等）：

# 遍历字符串 for char in "Python": print(char) # 依次输出 P y t h o n # 遍历列表 fruits = ["苹果", "香蕉", "橙子"] for fruit in fruits: print(fruit) # 依次输出 苹果 香蕉 橙子 # range 函数：生成整数序列 # range(结束值)：0 到 结束值 -1 for i in range(5): print(i) # 输出 0 1 2 3 4 # range(起始值，结束值，步长) for i in range(1, 10, 2): print(i) # 输出 1 3 5 7 9 # 遍历带索引的元素 for index, fruit in enumerate(fruits): print(f"索引 {index}：{fruit}") # 结果： # 索引 0：苹果 # 索引 1：香蕉 # 索引 2：橙子 # 九九乘法表 for i in range(1, 10): for j in range(1, i+1): print(f"{j}×{i}={i*j}", end="\t") print() # 换行 

3.2.2 while 循环

满足条件时重复执行代码块：

# 基本 while 循环 count = 0 while count < 5: print(count) count += 1 # 等价于 count = count + 1 # 输出 0 1 2 3 4 # while-else 循环（循环正常结束时执行 else 块） count = 0 while count < 5: print(count) count += 1 else: print("循环正常结束") # 无限循环（需手动终止） # while True: # print("无限循环") # # 需添加 break 条件终止循环 # if input("输入 q 退出：") == "q": # break 

3.2.3 循环控制语句

• break：终止当前循环
• continue：跳过当前循环，进入下一次循环
• pass：空语句，仅占位，无实际功能

# break 示例 for i in range(10): if i == 5: break # 当 i=5 时终止循环 print(i) # 输出 0 1 2 3 4 # continue 示例 for i in range(10): if i % 2 == 0: continue # 跳过偶数 print(i) # 输出 1 3 5 7 9 # pass 示例 for i in range(5): if i == 3: pass # 占位，无操作 print(i) # 输出 0 1 2 3 4 

四、Python 容器数据类型

容器类型用于存储多个数据，包括列表、元组、字典、集合等。

4.1 列表（list）

有序、可变、可重复的元素集合，用 [] 定义：

# 列表定义 nums = [1, 2, 3, 4, 5] mixed = [1, "Python", 3.14, True] # 混合类型 empty_list = [] # 空列表 # 列表索引和切片（同字符串） print(nums[0]) # 1 print(nums[-1]) # 5 print(nums[1:4]) # [2, 3, 4] # 列表常用操作 # 添加元素 nums.append(6) # 末尾添加：[1,2,3,4,5,6] nums.insert(0, 0) # 指定位置插入：[0,1,2,3,4,5,6] nums.extend([7,8])# 扩展列表：[0,1,2,3,4,5,6,7,8] # 删除元素 nums.remove(0) # 删除指定值：[1,2,3,4,5,6,7] nums.pop() # 删除最后一个元素：[1,2,3,4,5,6,7] nums.pop(0) # 删除指定索引：[2,3,4,5,6,7] del nums[1] # 删除指定索引：[2,4,5,6,7] # 修改元素 nums[0] = 10 # [10,4,5,6,7] # 其他操作 print(len(nums)) # 长度：5 print(nums.index(5)) # 查找元素索引：2 print(nums.count(5)) # 元素出现次数：1 nums.sort() # 升序排序：[4,5,6,7,10] nums.reverse() # 反转：[10,7,6,5,4] # 列表推导式（简洁创建列表） squares = [x*x for x in range(1, 11)] print(squares) # [1,4,9,16,25,36,49,64,81,100] # 带条件的列表推导式 odd_squares = [x*x for x in range(1, 11) if x % 2 == 1] print(odd_squares) # [1,9,25,49,81] 

4.2 元组（tuple）

有序、不可变、可重复的元素集合，用 () 定义：

# 元组定义 t1 = (1, 2, 3) t2 = 1, 2, 3 # 省略括号也可 t3 = (1,) # 单个元素元组必须加逗号 t4 = () # 空元组 # 元组索引和切片（同列表） print(t1[0]) # 1 print(t1[1:3]) # (2, 3) # 元组不可修改（运行报错） # t1[0] = 10 # 元组常用操作 print(len(t1)) # 长度：3 print(t1.count(2)) # 元素出现次数：1 print(t1.index(3)) # 元素索引：2 # 元组解包 a, b, c = t1 print(a, b, c) # 1 2 3 # 元组推导式（实际生成生成器，需转换为元组） t5 = tuple(x*2 for x in range(1, 6)) print(t5) # (2,4,6,8,10) 

4.3 字典（dict）

无序、可变的键值对集合，键唯一且不可变，用 {} 定义：

# 字典定义 student = { "name": "张三", "age": 20, "gender": "男", "scores": {"语文": 90, "数学": 85} } empty_dict = {} # 空字典 # 访问值 print(student["name"]) # 张三 print(student.get("age")) # 20 print(student.get("address", "未知")) # 不存在的键返回默认值：未知 # 修改值 student["age"] = 21 student["address"] = "北京" # 添加新键值对 # 删除键值对 del student["gender"] student.pop("address") # 遍历字典 # 遍历键 for key in student: print(key) # name age scores # 遍历值 for value in student.values(): print(value) # 张三 21 {'语文': 90, '数学': 85} # 遍历键值对 for key, value in student.items(): print(f"{key}: {value}") # 字典推导式 nums = [1,2,3,4,5] square_dict = {x: x*x for x in nums} print(square_dict) # {1:1, 2:4, 3:9, 4:16, 5:25} # 字典常用方法 print(student.keys()) # 所有键：dict_keys(['name', 'age', 'scores']) print(student.values()) # 所有值：dict_values(['张三', 21, {'语文': 90, '数学': 85}]) print(student.items()) # 所有键值对：dict_items([('name', '张三'), ('age', 21), ('scores', {'语文': 90, '数学': 85})]) student.clear() # 清空字典 

4.4 集合（set）

无序、可变、不重复的元素集合，用 {} 或 set() 定义：

# 集合定义 s1 = {1, 2, 3, 3, 4} # 自动去重：{1,2,3,4} s2 = set([3,4,5,6]) # 从列表转换：{3,4,5,6} empty_set = set() # 空集合（不能用 {}，{} 是空字典） # 集合常用操作 # 添加元素 s1.add(5) # {1,2,3,4,5} s1.update([6,7]) # {1,2,3,4,5,6,7} # 删除元素 s1.remove(7) # 删除不存在的元素会报错 s1.discard(8) # 删除不存在的元素不报错 s1.pop() # 随机删除一个元素 # 集合运算 print(s1 & s2) # 交集：{3,4,5} print(s1 | s2) # 并集：{1,2,3,4,5,6} print(s1 - s2) # 差集：{1,2} print(s1 ^ s2) # 对称差集：{1,2,6} # 集合推导式 s3 = {x for x in range(10) if x % 2 == 0} print(s3) # {0,2,4,6,8} 

五、函数

函数是封装可重用代码的块，提高代码复用性和可读性。

5.1 函数定义与调用

# 基本函数定义：def 函数名 (参数): def greet(): """无参数函数：打招呼""" print("Hello, Python!") # 调用函数 greet() # 结果：Hello, Python! # 带参数的函数 def greet_name(name): """带一个参数的函数""" print(f"Hello, {name}!") greet_name("张三") # 结果：Hello, 张三! # 带默认参数的函数 def greet_name_age(name, age=18): """带默认参数的函数""" print(f"姓名：{name}，年龄：{age}") greet_name_age("李四") # 使用默认年龄：姓名：李四，年龄：18 greet_name_age("王五", 20) # 覆盖默认值：姓名：王五，年龄：20 # 带返回值的函数 def add(a, b): """计算两个数的和并返回""" return a + b result = add(3, 5) print(result) # 结果：8 # 多个返回值（实际返回元组） def calculate(a, b): return a + b, a - b, a * b, a / b sum_, sub, mul, div = calculate(10, 5) print(sum_, sub, mul, div) # 15 5 50 2.0 # 关键字参数调用 print(add(b=5, a=3)) # 结果：8 # 可变长度参数 # *args：接收任意数量的位置参数（元组） def print_args(*args): print(args) # 输出元组 print_args(1, 2, 3) # (1, 2, 3) # **kwargs：接收任意数量的关键字参数（字典） def print_kwargs(**kwargs): print(kwargs) # 输出字典 print_kwargs(name="张三", age=20) # {'name': '张三', 'age': 20} 

5.2 函数进阶

5.2.1 匿名函数（lambda）

简化简单函数的定义，使用 lambda 关键字：

# 基本语法：lambda 参数：表达式 add = lambda a, b: a + b print(add(3, 5)) # 结果：8 # 结合内置函数使用 nums = [1, 2, 3, 4, 5] # 排序 students = [("张三", 20), ("李四", 18), ("王五", 22)] students.sort(key=lambda x: x[1]) # 按年龄排序 print(students) # [('李四', 18), ('张三', 20), ('王五', 22)] # 过滤 nums = [1, 2, 3, 4, 5, 6, 7, 8, 9] even_nums = list(filter(lambda x: x % 2 == 0, nums)) print(even_nums) # [2,4,6,8] # 映射 square_nums = list(map(lambda x: x*x, nums)) print(square_nums) # [1,4,9,16,25,36,49,64,81] 

5.2.2 函数作用域

变量的作用域分为全局作用域和局部作用域：

# 全局变量 global_var = "全局变量" def test_scope(): # 局部变量 local_var = "局部变量" print(global_var) # 可以访问全局变量 print(local_var) # 可以访问局部变量 test_scope() print(global_var) # print(local_var) # 无法访问局部变量，报错 # 修改全局变量（需用 global 关键字） def modify_global(): global global_var global_var = "修改后的全局变量" modify_global() print(global_var) # 结果：修改后的全局变量 # 嵌套函数 def outer(): outer_var = "外层变量" def inner(): inner_var = "内层变量" print(outer_var) # 内层函数可访问外层变量 inner() # print(inner_var) # 外层函数无法访问内层变量 outer() 

5.2.3 递归函数

函数调用自身，需设置终止条件：

# 阶乘计算（n! = n × (n-1) × ... × 1） def factorial(n): if n == 1: # 终止条件 return 1 return n * factorial(n-1) # 递归调用 print(factorial(5)) # 5! = 120 # 斐波那契数列（1,1,2,3,5,8...） def fibonacci(n): if n == 1 or n == 2: return 1 return fibonacci(n-1) + fibonacci(n-2) print(fibonacci(6)) # 结果：8 

六、文件操作

Python 提供内置函数实现文件的读写操作。

6.1 文件打开与关闭

# 基本语法：open(文件名，模式，编码) # 模式：r（读，默认）、w（写，覆盖）、a（追加）、r+（读写）、b（二进制） # 方式 1：手动关闭文件 f = open("test.txt", "w", encoding="utf-8") f.write("Hello, Python!") # 写入内容 f.close() # 必须关闭文件 # 方式 2：with 语句（自动关闭文件，推荐） with open("test.txt", "r", encoding="utf-8") as f: content = f.read() # 读取全部内容 print(content) # 结果：Hello, Python! 

6.2 文件读取

# 读取全部内容 with open("test.txt", "r", encoding="utf-8") as f: content = f.read() print(content) # 按行读取 with open("test.txt", "r", encoding="utf-8") as f: lines = f.readlines() # 返回列表，每行一个元素 for line in lines: print(line.strip()) # 去除换行符 # 逐行读取（适合大文件） with open("test.txt", "r", encoding="utf-8") as f: for line in f: print(line.strip()) 

6.3 文件写入

# 覆盖写入（w 模式） with open("test.txt", "w", encoding="utf-8") as f: f.write("第一行内容\n") f.write("第二行内容\n") # 追加写入（a 模式） with open("test.txt", "a", encoding="utf-8") as f: f.write("追加的内容\n") # 写入多行 lines = ["第三行\n", "第四行\n"] with open("test.txt", "a", encoding="utf-8") as f: f.writelines(lines) 

6.4 二进制文件操作

# 读取图片（二进制文件） with open("image.jpg", "rb") as f: content = f.read() # 写入二进制文件 with open("new_image.jpg", "wb") as f: f.write(content) 

七、异常处理

异常是程序运行时的错误，通过异常处理可以避免程序崩溃。

# 基本 try-except 语句 try: num = int(input("请输入一个整数：")) result = 10 / num print(f"结果：{result}") except ValueError: print("输入的不是整数！") except ZeroDivisionError: print("不能除以 0！") except Exception as e: # 捕获所有异常 print(f"发生未知错误：{e}") else: # 无异常时执行 print("程序正常执行") finally: # 无论是否异常都执行 print("程序执行完毕") # 手动抛出异常 def check_age(age): if age < 0: raise ValueError("年龄不能为负数") print(f"年龄：{age}") try: check_age(-5) except ValueError as e: print(e) # 结果：年龄不能为负数 

八、模块与包

模块是包含 Python 定义和语句的文件（.py），包是包含 init.py 文件的目录，用于组织模块。

8.1 模块使用

# 导入整个模块 import math print(math.pi) # 圆周率：3.141592653589793 print(math.sqrt(16)) # 平方根：4.0 # 导入模块中的指定函数/变量 from math import pi, sqrt print(pi) print(sqrt(25)) # 导入模块并指定别名 import math as m print(m.pi) # 导入模块中的所有内容（不推荐） from math import * print(pi) 

8.2 自定义模块

1. 创建 mymodule.py 文件：

# mymodule.py def add(a, b): return a + b def subtract(a, b): return a - b PI = 3.1415926 

1. 在另一个文件中导入：

# main.py import mymodule print(mymodule.add(3, 5)) # 8 print(mymodule.subtract(10, 4)) # 6 print(mymodule.PI) # 3.1415926 

8.3 包的使用

1. 创建包结构：

mypackage/
__init__.py
module1.py
module2.py

1. __init__.py 文件（可空，也可指定导出内容）：

# __init__.py from .module1 import func1 from .module2 import func2 

1. 导入包中的模块：

# 方式 1 import mypackage.module1 print(mypackage.module1.func1()) # 方式 2 from mypackage import module2 print(module2.func2()) # 方式 3（通过 __init__.py 导出） from mypackage import func1, func2 print(func1()) print(func2()) 

九、面向对象编程基础

Python 是面向对象的语言，一切皆对象。

9.1 类与对象

# 定义类 class Person: # 类属性 species = "人类" # 初始化方法 def __init__(self, name, age): # 实例属性 self.name = name self.age = age # 实例方法 def introduce(self): print(f"我叫{self.name}，今年{self.age}岁") # 类方法 @classmethod def show_species(cls): print(f"物种：{cls.species}") # 静态方法 @staticmethod def is_adult(age): return age >= 18 # 创建对象（实例化） p1 = Person("张三", 20) p2 = Person("李四", 17) # 访问实例属性 print(p1.name) # 张三 print(p2.age) # 17 # 调用实例方法 p1.introduce() # 我叫张三，今年 20 岁 p2.introduce() # 我叫李四，今年 17 岁 # 访问类属性 print(Person.species) # 人类 print(p1.species) # 人类 # 调用类方法 Person.show_species() # 物种：人类 p1.show_species() # 物种：人类 # 调用静态方法 print(Person.is_adult(18)) # True print(p1.is_adult(17)) # False 

9.2 继承

继承允许子类复用父类的属性和方法：

# 父类 class Person: def __init__(self, name, age): self.name = name self.age = age def introduce(self): print(f"我叫{self.name}，今年{self.age}岁") # 子类 class Student(Person): def __init__(self, name, age, student_id): # 调用父类构造方法 super().__init__(name, age) self.student_id = student_id # 重写父类方法 def introduce(self): print(f"我叫{self.name}，今年{self.age}岁，学号{self.student_id}") # 子类特有方法 def study(self): print(f"{self.name}正在学习") # 创建子类对象 s = Student("王五", 18, "2024001") s.introduce() # 我叫王五，今年 18 岁，学号 2024001 s.study() # 王五正在学习 

总结

核心知识点回顾

1. 基础语法：Python 用缩进划分代码块，注释分为单行（#）和多行（""""""），变量无需声明类型，命名需遵循规则。
2. 数据类型：核心类型包括数值（int/float）、字符串（str）、布尔（bool），容器类型包括列表（list）、元组（tuple）、字典（dict）、集合（set），各类型有专属的操作方法。
3. 控制流：条件语句（if-elif-else）实现分支逻辑，循环语句（for/while）实现重复执行，break/continue 控制循环流程。
4. 函数与面向对象：函数封装可重用代码，支持参数、返回值、lambda 表达式；面向对象编程通过类和对象组织代码，支持继承、方法重写等特性。
5. 进阶操作：文件操作实现数据持久化，异常处理避免程序崩溃，模块与包实现代码模块化管理。

Python 入门的关键是多写多练，建议你将本文中的代码示例逐一运行、修改，尝试理解每一行代码的作用，再结合实际需求编写自己的程序。从简单的计算器、猜数字游戏开始，逐步过渡到更复杂的项目，你会发现 Python 编程的乐趣和价值。