Python

基础知识

注释

• 单行注释使用一个井号 #注释内容
• 多行注释使用一个三个双引号""" 注释内容 """

基本语法

Python为动态类型语言，无需显式声明类型。 变量定义：变量名 = 变量值

name = "Alice"    # 字符串
age = 25          # 整数
pi = 3.14159      # 浮点数
is_student = True # 布尔值

命名规范（与Java通用）

• 以字母或下划线开头，不可以数字开头
• 仅包含字母、数字、下划线
• 区分大小写（name≠ Name）
• 避免使用关键字（如if, for）
• 推荐驼峰式（userName）或下划线式（user_name）

print()函数

与Java不同，print方法输出多个内容时，使用逗号隔开

print("Hello", "World")  # 输出：Hello World
print(10 + 5)            # 输出：15

数据类型

核心数据类型

数据类型	描述	可变性	示例	注意事项
Number	数值类型（整型、浮点型、复数、布尔值）	不可变	age=25, pi=3.14	布尔值是Number子类，True=1, False=0
String	字符序列	不可变	s="Hello"	支持转义字符\n，原始字符串用r"..."
List	有序可变序列	可变	lst=[1,2,"a"]	支持增删改查，元素可不同类型
Tuple	有序不可变序列	不可变	t=(1,2,"a")	单元素需加逗号(5,)，嵌套可变对象合法
Set	无序唯一集合	可变	s={1,2,3}	用{}或set()创建，空集合必须用set()
Dictionary	键值对映射	可变	d={"name":"Alice"}	键必须不可变，值可任意类型

数据类型详解

1. Number类型

a = 10          # int
b = 3.14        # float
c = 2 + 3j      # complex
d = True        # bool (True=1, False=0)

注：type(3.14)返回<class 'float'>，type(True)返回<class 'bool>'

2. String类型

s = "Python"    # 基础字符串
s2 = 'It\'s ok' # 转义字符
s3 = r"C:\path" # 原始字符串

3. List类型

fruits = ["apple", "banana", 3]  # 混合类型
fruits.append("orange")          # 添加元素
fruits[0] = "pear"               # 修改元素

4. Tuple类型

point = (10, 20)               # 不可变
mixed = ("a", [1,2], 3.14)     # 嵌套可变对象

5. Set类型

nums = {1,2,2,3}               # 自动去重 -> {1,2,3}
s = set()                      # 空集合
s.add(5)                       # 添加元素

6. Dictionary类型

user = {"name": "Bob", "age": 25}
user["email"] = "bob@example.com"  # 新增键值对
del user["age"]                    # 删除键值对

类型转换

函数	用途	示例	注意事项
int(x)	转整数	int("123") → 123	浮点数转整数会截断小数（int(3.9)=3）
float(x)	转浮点	float("3.14") → 3.14	整数转浮点会添加.0
str(x)	转字符串	str(123) → "123"	所有类型均可转换
list(x)	转列表	list("abc") → ['a','b','c']	可迭代对象均可转换
tuple(x)	转元组	tuple([1,2,3]) → (1,2,3)
set(x)	转集合	set([1,2,2]) → {1,2}	自动去重
dict(x)	转字典	dict([("a",1),("b",2)])	需可迭代的键值对

运算符

与Java相同

取整除运算符 //

• 向下取整规则：结果向负无穷方向取整（与Java的向零取整不同）

print(9  // 2)   # 输出4 (与Java相同)
print(-9 // 2)   # 输出-5 (Java中-9/2=-4)
print(9.5 // 2)  # 输出4.0

应用场景

• 分页计算：total_pages = total_items // items_per_page
• 时间转换：minutes = total_seconds // 60

指数运算符 **

• 支持浮点指数：2 ** 0.5 → 1.4142（Python原生支持，Java需Math.pow()）
• 链式运算：2 ** 2 ** 3 → 256（右结合性）

# a**b  a的b次方
# 科学计数法
print(1e3 ** 2)  # 输出1000000.0
# 负数指数
print(2 ** -3)   # 输出0.125

控制语句

条件语句

# 单分支
if condition:
    # 缩进4空格的代码块

# 双分支
if condition:
    # 成立时执行
else:
    # 不成立时执行

# 多分支
if condition1:
    # 条件1成立
elif condition2:
    # 条件1不成立但条件2成立
else:
    # 所有条件均不成立

特性

• 条件表达式：布尔值判断，支持比较运算符(>, ==, !=)和逻辑运算符(and, or, not)
• 隐式转换：非零数值、非空序列视为True，零值/空值视为False
• 短路特性：and左侧为False时不再计算右侧，or左侧为True时跳过右侧

二、循环结构

1. while循环

while condition:
    # 条件为True时重复执行
    # 必须包含条件更新语句避免死循环

# 例
count = 0
while count < 5:
    print(count)
    count += 1
else:
    print("循环正常结束")

特性：

• 条件更新：循环体内必须修改条件相关变量
• else子句：循环正常结束（未被break中断）时执行

2. for循环

for item in iterable:
    # 遍历可迭代对象（列表/字符串/字典等）

# 遍历字典示例
user = {"name": "Bob", "age": 25}
for key in user:
    print(f"{key}: {user[key]}")

range函数：

参数形式	示例	输出序列
range(stop)	range(5)	0-4
range(start, stop)	range(2,7)	2-6
range(start, stop, step)	range(1,10,2)	1,3,5,7,9

函数

# 函数定义
def 函数名 (形参列表):
	函数体
	return 返回值

None类型

None 是一个特殊的字面值，相当于java中的null<class 'NoneType'>

函数说明文档：

# 使用多行注释写到函数体之前
def function(x,y):
	"""
	整体说明
	:param x:形参变量x的说明
	:param y:形参变量y的说明
	:return: 返回值说明
	"""

函数规范性

1. 多个返回值

def test_return():
	return 1,2
x, y = test_return()

2.结构化返回

def get_user_info():
    """返回结构化数据"""
    return {
        "name": "Alice",
        "age": 25,
        "email": "alice@example.com"
    }

user = get_user_info()
print(user["name"])  # 输出：Alice

3.关键字参数

def create_user(name: str, age: int, gender: str = "未知"):
    """创建用户信息"""
    return {
        "name": name,
        "age": age,
        "gender": gender
    }

# 关键字参数调用
user = create_user(name="张三", age=28, gender="男")

不定长参数

def sum_numbers(*numbers):
    """计算任意数量数的和"""
    return sum(numbers)

print(sum_numbers(1,2,3,4))  # 输出：10
print(sum_numbers())         # 输出：0

关键字不定长(kwargs)

def print_person_info(**info):
    """打印人员信息"""
    for key, value in info.items():
        print(f"{key}: {value}")

print_person_info(name="王五", age=35, job="工程师")

匿名函数（lambda函数）

lambda 参数列表: 表达式

square = lambda x: x**2
print(square(5))  # 输出25

容器

列表（List）

• 有序可变：元素顺序固定，支持增删改查
• 混装存储：可存储不同类型元素（数字/字符串/对象）
• 切片支持：支持[start:end:step]切片操作

# 定义
istName = [元素1,元素2,元素3...]

# 定义空变量
listName = []
listName = list()

列表中可以存储不同类型的元素 listName[1]取出第二个元素 也可以反向索引，最后以为是-1，依次类推

方法	功能说明
index(元素)	查找某元素的下标,返回该元素的下标，如果没有报错ValueError
append()	尾部追加元素
extend()	合并另一个列表
insert()	指定位置插入元素
remove()	删除首个匹配元素
pop()	删除并返回指定索引元素（默认末尾）
sort()	原地排序（升序）
reverse()	原地反转元素顺序

元组（Tuple）

• 有序不可变：元素顺序固定，创建后不可修改
• 混装存储：支持不同类型元素
• 可哈希性：可作为字典键值

# 定义方式
(元素,元素,元素)
变量名 = (元素,元素,元素)
# 定义空元组
变量名 = ()
变量名 = tuple()

方法	功能说明
index()	查找元素索引
count()	统计元素出现次数

字符串（String）

• 字符序列：每个字符视为单独元素
• 不可变性：任何修改都会生成新字符串
• 编码支持：支持UTF-8/GBK等编码

text = "Hello, 世界!"
unicode_text = text.encode('utf-8')  # b'Hello, \xe4\xb8\x96\xe7\x95\x8c!'

方法	功能说明	示例
split()	按分隔符分割	text.split() → ["Hello,", "世界!"]
replace()	替换子串	text.replace("World", "Python")
strip()	去除首尾空白	`"\t

集合（Set）

• 无序唯一：自动去重，元素顺序不固定
• 数学集合运算：支持并/交/差集等
• 可变性：可动态增删元素

# 集合的定义
{元素,元素,元素}
变量名 = {元素,元素,元素}

# 定义空集合
变量名 = set()

方法	功能说明
add()	添加
remove()	移除
Object pop()	随机取出一个元素，并移除
clear()	清空
集合1.difference(集合2)	取出两个集合的差集
集合1.difference_update(集合2)	消除差集
集合1.union(集合2)	合并两个集合
len()	统计集合中元素的数量

集合（Dict）

• 键值对存储：键唯一，值可变
• 哈希表实现：O(1)时间复杂度查询
• 动态扩展：支持动态增删键值

# 字典的定义
{key: value,key: value,key: value}
dictName = {key: value,key: value,key: value}

# 定义空字典
dictName = {} 
dictName = dict()

字典的key不可以是字典，其他都没有限制

方法	功能说明
value = dictName[key]	通过key获取value
dict[Key] = Value	新增/更新
pop(Key)	获取并删除元素
len(dict)	统计字典内元素的数量
clear()	清空字典
keys()	获取字典中所有的key
values()	获取字典中所有的key
items()	获取字典中所有的键值对
get()	安全获取值,user.get("address", "未知")

总结

五种数据容器都支持for循环遍历

• len(容器)统计容器中元素的个数
• max(容器)找出容器中最大的元素
• min(容器)找出容器中最小的元素
• list(容器)将容器转化为列表
• str(容器)将容器转化为字符串
• tuple(容器)将容器转化为元组
• set(容器)将容器转化为集合
• sorted(容器,[reverse=True])将容器排序

容器类型	可变性	有序性	元素唯一性	典型应用场景
列表	✔️	✔️	❌	动态数据集合、队列/栈实现
元组	❌	✔️	❌	固定配置参数、函数返回多值
字符串	❌	✔️	❌	文本处理、字符序列操作
集合	✔️	❌	✔️	去重、集合运算、成员检测
字典	✔️	❌	键唯一	键值存储、快速数据检索

文件编码

open()

open(
    file,          # 文件路径（支持绝对/相对路径）
    mode='r',      # 访问模式（必选参数）
    encoding='utf-8'  # 编码格式（文本模式必选）
)

基础模式	扩展模式	功能说明
'r'	'rt'	文本只读（默认）
'w'	'wt'	文本覆盖写入
'a'	'at'	文本追加写入
'b'	'rb'/'wb'	二进制模式
'+'	'r+'	读写模式（需配合其他模式）

读取

# 读取全部内容
content = f.read()  # 返回字符串（文本模式）或bytes（二进制模式）

# 指定字节数读取
chunk = f.read(100)  # 读取前100字节

# 逐行读取
line = f.readline()  # 读取单行（保留换行符）
lines = f.readlines()  # 读取所有行（生成列表）

# 迭代读取（推荐大文件）
for line in f:
    process(line)  # 自动逐行读取，内存友好

写入

# 基础写入
f.write("Hello World")  # 写入字符串
f.writelines(["line1\n","line2"])  # 写入字符串列表

# 文件指针控制
f.seek(0)       # 移动到文件开头（文本模式）
f.tell()        # 获取当前指针位置

上下文管理器（with语句）

with open("test.txt", "r") as f:
    content = f.read()
# 文件自动关闭，无需显式调用close()

# 等效代码（底层实现）
f = open("test.txt", "r")
try:
    content = f.read()
finally:
    f.close()

异常

捕获指定异常

try:
	# 可能发生错误的代码
except NameError as e::
	# 发生后指定的代码

捕获多个异常

# 捕获多个异常，通过元组来声明
try:
	# 可能发生错误的代码
except (NameError,ZeroDivisionError):
	# 发生后指定的代码

异常else

# 异常else，如果没有发生异常要执行的代码
try:
	#可能发生错误的代码
except:
	#发生后指定的代码
else:
	#没有发生异常后的代码

异常finally

# 异常finally，无论是否发生异常都会执行的代码
try:
	#可能发生错误的代码
except:
	#发生后指定的代码
else:
	#没有发生异常后的代码
finally:
	#无论是否发生异常都会执行的代码

模块与包

模块

• 本质：以.py为扩展名的Python文件
• 核心作用：
  • 代码封装与复用
  • 命名空间隔离（避免命名冲突）
  • 支持模块化开发

语法格式	功能说明	示例
import module	导入整个模块	import math
from module import func	导入特定成员	from math import sqrt
import module as m	模块别名	import numpy as np

包

包定义规范

my_package/
├── __init__.py       # 包初始化文件
├── module_a.py       # 模块A
├── module_b.py       # 模块B
└── subpackage/       # 子包
    ├── __init__.py
    └── module_c.py

• __init__.py：标识目录为Python包，控制包的初始化行为
• 模块文件：包含可导入的函数/类/变量
• 子包结构：支持多层包嵌套