Python 列表（list）详解｜从 Java ArrayList 视角快速上手

Python 列表（list）详解｜从 Java ArrayList 视角快速上手

对于Java后端开发者来说，处理集合类数据时，ArrayList是最常用的工具之一——它有序、可变、可存储多种类型元素，是日常开发中操作“批量数据”的核心容器。

而在Python中，列表（list） 就相当于Java中的ArrayList，甚至比ArrayList更灵活、更简洁。它同样支持有序存储、增删改查、排序反转等操作，但语法更简洁、操作更便捷，无需关注泛型、初始化容量等细节。

这篇文章就从Java开发者熟悉的ArrayList视角出发，逐一对标Python列表的定义、创建、常用操作，用对比的方式拆解差异、梳理用法，搭配全新代码示例，让你快速上手Python列表，摆脱Java思维的束缚。

一、核心认知：Python list vs Java ArrayList

在正式学习之前，先明确两者的核心共性与差异，帮你快速建立认知：

特性	Python list（列表）	Java ArrayList
核心定位	内置可变有序集合，最常用的数据容器	集合框架中的可变有序列表，需手动导入包
元素类型	无限制，可存储任意类型（数字、字符串、布尔值、嵌套列表等）	需指定泛型（如ArrayList），默认存储Object类型
初始化方式	简洁灵活，支持直接赋值、内置函数创建	需new关键字初始化，可指定初始容量
核心优势	语法极简，操作便捷，无需关注底层细节	可控制初始容量，性能可控，支持更多集合接口方法

简单来说：Python list 是“开箱即用”的灵活容器，而Java ArrayList 是“严谨可控”的专业容器，两者核心功能一致，但Python的用法更简洁。

二、创建列表：Python 极简 vs Java 严谨

Java中创建ArrayList，必须用new关键字，还需指定泛型（避免类型错误）；而Python创建list，无需任何关键字，一行代码即可完成。

1. 基本创建（最常用）

Java ArrayList 写法

// 导入包（必须）
import java.util.ArrayList;

// 创建字符串类型的ArrayList，指定泛型
ArrayList<String> fruits = new ArrayList<>();
// 添加元素（需手动add）
fruits.add("apple");
fruits.add("banana");
fruits.add("cherry");

Python list 写法

# 直接用方括号[]创建，无需初始化、无需指定类型
fruits = ["apple", "banana", "cherry"]
# 一行完成创建+赋值，无需手动添加元素

2. 用内置函数创建

Java ArrayList 写法

// 用Arrays.asList()转换，需手动传入数组
ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(10, 20, 30));
// 或创建空列表，指定初始容量（优化性能）
ArrayList<Integer> emptyNums = new ArrayList<>(10);

Python list 写法

# 用内置list()函数创建，可转换可迭代对象
nums = list((10, 20, 30))  # 转换元组为列表
# 创建空列表（两种方式，均无需指定容量）
empty_list1 = []
empty_list2 = list()

关键差异

Python list 无需导入任何包、无需指定元素类型、无需手动add初始元素，创建方式更简洁；Java ArrayList 必须导入包、指定泛型，灵活性稍弱，但类型安全性更高。

三、访问元素：Python 索引更灵活，无需越界判断？

两者都支持通过索引访问元素，且索引均从0开始，但Python新增了“反向索引”功能，无需像Java那样计算倒数位置，更便捷；同时两者都会报越界错误，需注意索引范围。

1. 正向索引（从0开始）

Java ArrayList 写法

ArrayList<String> fruits = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
// 通过get()方法获取元素
String first = fruits.get(0);  // apple
String third = fruits.get(2);  // cherry
// 索引越界会报：IndexOutOfBoundsException

Python list 写法

fruits = ["apple", "banana", "cherry"]
# 直接用 列表[索引] 获取，无需get()方法
first = fruits[0]  # apple
third = fruits[2]  # cherry
# 索引越界会报：IndexError: list index out of range

2. Python 独有：反向索引

Java中获取倒数第一个元素，需计算索引（size()-1）；Python直接用-1表示倒数第一个，-2表示倒数第二个，无需计算。

fruits = ["apple", "banana", "cherry"]
print(fruits[-1])  # 倒数第一个：cherry
print(fruits[-2])  # 倒数第二个：banana

3. 切片（Python 独有，Java 需手动遍历）

Python list 支持“切片”操作，可快速获取部分元素，形成新列表；而Java ArrayList 无此功能，需手动遍历筛选，代码冗余。

Python 切片写法

nums = [1, 2, 3, 4, 5, 6]
print(nums[1:4])  # 从索引1到3（左闭右开）：[2, 3, 4]
print(nums[2:])   # 从索引2到末尾：[3, 4, 5, 6]
print(nums[:3])   # 从开头到索引2：[1, 2, 3]
print(nums[::2])  # 步长为2，隔一个取一个：[1, 3, 5]

Java 对应实现（需手动遍历）

ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
// 对应Python nums[1:4]，获取索引1-3的元素
ArrayList<Integer> subNums = new ArrayList<>();
for (int i = 1; i < 4; i++) {
    subNums.add(nums.get(i));
}

四、增删改查：Python 一行搞定，Java 需调用方法

列表的核心操作是增删改查，Python 用极简语法实现，无需像Java那样调用大量方法，逻辑更直观。

1. 修改元素

Java ArrayList 写法

ArrayList<String> fruits = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
// 用set()方法修改指定索引元素
fruits.set(1, "orange");
System.out.println(fruits);  // [apple, orange, cherry]

Python list 写法

fruits = ["apple", "banana", "cherry"]
# 直接通过索引赋值修改，无需调用方法
fruits[1] = "orange"
print(fruits)  # [apple, orange, cherry]

2. 添加元素（3种常用方式）

方式1：末尾添加（最常用）

// Java：add()方法
fruits.add("peach");  // 末尾添加单个元素

# Python：append()方法，语法更简洁
fruits.append("peach")

方式2：指定位置插入

// Java：add(索引, 元素)
fruits.add(1, "mango");  // 索引1处插入mango

# Python：insert(索引, 元素)
fruits.insert(1, "mango")

方式3：合并两个列表

// Java：addAll()方法
ArrayList<String> moreFruits = new ArrayList<>(Arrays.asList("grape", "kiwi"));
fruits.addAll(moreFruits);

# Python：extend()方法，或直接用+拼接
more_fruits = ["grape", "kiwi"]
fruits.extend(more_fruits)
# 或简写：fruits += more_fruits

3. 删除元素（4种常用方式）

方式1：删除指定索引元素

// Java：remove(索引)，返回被删除元素
fruits.remove(1);  // 删除索引1的元素

# Python：del关键字，或pop(索引)
del fruits[1]  # 仅删除，不返回
item = fruits.pop(1)  # 删除并返回被删除元素

方式2：删除指定值的元素

// Java：remove(元素)，删除第一个匹配项
fruits.remove("apple");

# Python：remove(元素)，用法与Java一致
fruits.remove("apple")

方式3：清空列表

// Java：clear()方法
fruits.clear();

# Python：clear()方法，用法一致
fruits.clear()

五、遍历列表：Python 更简洁，无需关注索引

Java遍历ArrayList，常用for循环（普通for、增强for）；Python遍历list，除了类似增强for的遍历，还支持枚举遍历，语法更灵活。

1. 普通遍历（仅获取元素）

// Java：增强for循环
for (String fruit : fruits) {
    System.out.println(fruit);
}

# Python：for-in循环，更简洁
for fruit in fruits:
    print(fruit)

2. 带索引遍历

// Java：普通for循环，通过索引获取元素
for (int i = 0; i < fruits.size(); i++) {
    System.out.println("索引" + i + "：" + fruits.get(i));
}

# Python：enumerate()函数，直接获取索引和元素
for index, fruit in enumerate(fruits):
    print(f"索引{index}：{fruit}")

六、排序与反转：Python 一行搞定，Java 需借助工具类

Java中排序需借助Collections工具类，反转也需手动实现或调用工具方法；Python list 内置排序、反转方法，一行代码即可完成。

1. 排序

Java 写法

ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(3, 1, 4, 2));
// 升序排序（Collections工具类）
Collections.sort(nums);
// 降序排序（需传入比较器）
Collections.sort(nums, Collections.reverseOrder());

Python 写法

nums = [3, 1, 4, 2]
# 升序排序（修改原列表）
nums.sort()
# 降序排序（修改原列表）
nums.sort(reverse=True)
# 临时排序（不修改原列表，返回新列表）
sorted_nums = sorted(nums, reverse=True)

2. 反转列表

Java 写法

// 借助Collections工具类
Collections.reverse(nums);

Python 写法

# 内置reverse()方法，修改原列表
nums.reverse()
# 或用切片反转（不修改原列表，返回新列表）
reversed_nums = nums[::-1]

七、复制列表：浅拷贝差异（Java vs Python）

无论是Java ArrayList还是Python list，复制列表都需注意“浅拷贝”的特性——仅复制外层容器，不复制嵌套结构（如子列表、对象）。

Java 浅拷贝

ArrayList<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3));
// 浅拷贝（new ArrayList<>(a)）
ArrayList<Integer> b = new ArrayList<>(a);
b.add(4);
System.out.println(a);  // [1,2,3]（原列表不变）

Python 浅拷贝（3种方式）

a = [1, 2, 3]
# 方式1：copy()方法
b = a.copy()
# 方式2：切片拷贝
c = a[:]
# 方式3：list()函数
d = list(a)

b.add(4)
print(a)  # [1,2,3]（原列表不变）

关键提醒

若列表中包含嵌套结构（如子列表），浅拷贝不会复制子列表，修改子列表内容会影响原列表，这一点Java和Python完全一致。

八、嵌套列表（二维列表）：Python 更直观

Java中实现二维列表，需创建“ArrayList嵌套ArrayList”，语法繁琐；Python嵌套列表直接用方括号嵌套，写法更简洁，访问也更直观。

Java 二维列表

// 创建二维列表（ArrayList嵌套ArrayList）
ArrayList<ArrayList<Integer>> matrix = new ArrayList<>();
// 添加子列表
matrix.add(new ArrayList<>(Arrays.asList(1, 2, 3)));
matrix.add(new ArrayList<>(Arrays.asList(4, 5, 6)));
// 访问子列表元素（索引1的子列表，索引2的元素）
int num = matrix.get(1).get(2);  // 6

Python 二维列表

# 直接嵌套方括号，一行创建二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 访问元素（列表[外层索引][内层索引]）
num = matrix[1][2]  # 6

九、实战案例：学生成绩分析（Java vs Python）

用一个简单的学生成绩分析案例，直观感受两者的写法差异，实现“计算平均分、最高分、最低分、排序”功能。

Java 实现

import java.util.ArrayList;
import java.util.Collections;

public class ScoreAnalysis {
    public static void main(String[] args) {
        // 创建成绩列表
        ArrayList<Integer> scores = new ArrayList<>(Arrays.asList(85, 92, 78, 90, 88, 76, 95));
        
        // 1. 平均分（需手动求和）
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        double avg = (double) sum / scores.size();
        
        // 2. 最高分、最低分（借助Collections）
        int maxScore = Collections.max(scores);
        int minScore = Collections.min(scores);
        
        // 3. 降序排序
        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
        Collections.sort(sortedScores, Collections.reverseOrder());
        
        // 输出结果
        System.out.printf("平均分：%.2f\n", avg);
        System.out.println("最高分：" + maxScore);
        System.out.println("最低分：" + minScore);
        System.out.println("降序排序：" + sortedScores);
    }
}

Python 实现

# 创建成绩列表
scores = [85, 92, 78, 90, 88, 76, 95]

# 1. 平均分（内置sum()、len()函数）
avg = sum(scores) / len(scores)

# 2. 最高分、最低分（内置max()、min()函数）
max_score = max(scores)
min_score = min(scores)

# 3. 降序排序（内置sorted()函数）
sorted_scores = sorted(scores, reverse=True)

# 输出结果
print(f"平均分：{avg:.2f}")
print(f"最高分：{max_score}")
print(f"最低分：{min_score}")
print(f"降序排序：{sorted_scores}")

对比可见：Python 借助内置函数，无需手动求和、无需借助工具类，代码量减少一半，逻辑更直观。

十、核心差异总结（Java 开发者速记）

• 创建：Python list 用[]/list()，无需new、无需泛型；Java ArrayList 需new、指定泛型。
• 访问：Python 支持反向索引、切片；Java 需手动计算索引、遍历筛选。
• 操作：Python 增删改查语法极简，无需过多方法；Java 需调用add/set/remove等方法。
• 工具：Python 内置sum/max/min/sorted等函数；Java 需借助Collections工具类。
• 嵌套：Python 二维列表写法直观；Java 需嵌套ArrayList，语法繁琐。

十一、小结

对于Java开发者来说，学习Python list 其实很简单——它本质就是“简化版的ArrayList”，保留了ArrayList的核心功能，去掉了繁琐的语法约束（泛型、new关键字、工具类调用），增加了更灵活的操作（反向索引、切片）。

记住一个核心：Python list 追求“简洁高效”，能一行搞定的绝不写多行，无需关注底层细节，专注业务逻辑即可。

掌握列表的创建、增删改查、排序反转等操作，就能应对Python中大部分集合类数据的处理场景，为后续学习字典、集合等数据结构打下坚实基础。