介绍
Python 列表是一种基本的数据结构，允许你存储和组织数据的集合。在两个列表中找到共同的元素是一项实用的技能，在许多编程场景中都很有用——从数据分析到构建 Web 应用程序。在这个实践实验（Lab）中，你将学习多种技术来识别 Python 列表之间的共享元素，并了解何时使用每种方法。
通过本教程，你将获得使用 Python 内置函数和列表操作方法的实践经验，并能够在你自己的项目中实现这些技术。
创建和理解 Python 列表
让我们从创建一些 Python 列表并探索它们的基本操作开始。这将为我们找到共同的元素奠定基础。
什么是 Python 列表？
在 Python 中，列表是一个有序的项集合，可以存储不同数据类型的元素。列表使用方括号 [] 创建，其中包含用逗号分隔的项。
让我们创建第一个 Python 文件并探索列表：
- 打开 WebIDE，通过点击 "File" > "New File" 创建一个新文件
- 将文件保存为
/home/labex/project目录下的list_basics.py - 将以下代码添加到文件中：
## Creating basic lists
fruits = ["apple", "banana", "cherry", "orange", "kiwi"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
## Printing the lists
print("Fruits list:", fruits)
print("Numbers list:", numbers)
print("Mixed list:", mixed)
## Accessing list elements using index
print("\nAccessing list elements:")
print("First fruit:", fruits[0])
print("Last number:", numbers[-1])
## Slicing lists
print("\nSlicing lists:")
print("First three fruits:", fruits[0:3])
print("Last two numbers:", numbers[-2:])
## List operations
print("\nList operations:")
print("Length of fruits list:", len(fruits))
fruits.append("mango")
print("After adding mango:", fruits)
fruits.remove("banana")
print("After removing banana:", fruits)
## Checking if an element exists in a list
print("\nChecking if elements exist:")
print("Is 'apple' in fruits?", "apple" in fruits)
print("Is 'grape' in fruits?", "grape" in fruits)- 通过打开终端并键入以下内容来运行该文件：
cd ~/project
python3 list_basics.py你应该看到输出，显示我们执行的不同列表操作：
Fruits list: ['apple', 'banana', 'cherry', 'orange', 'kiwi']
Numbers list: [1, 2, 3, 4, 5]
Mixed list: [1, 'hello', 3.14, True]
Accessing list elements:
First fruit: apple
Last number: 5
Slicing lists:
First three fruits: ['apple', 'banana', 'cherry']
Last two numbers: [4, 5]
List operations:
Length of fruits list: 5
After adding mango: ['apple', 'banana', 'cherry', 'orange', 'kiwi', 'mango']
After removing banana: ['apple', 'cherry', 'orange', 'kiwi', 'mango']
Checking if elements exist:
Is 'apple' in fruits? True
Is 'grape' in fruits? False现在我们了解了 Python 列表的基础知识，我们可以准备查找两个列表之间的共同元素。让我们创建两个将在下一步中使用的示例列表：
- 创建一个名为
common_elements_data.py的新文件，内容如下：
## Create two lists with some common elements
list1 = [1, 2, 3, 4, 5, 6]
list2 = [4, 5, 6, 7, 8, 9]
print("List 1:", list1)
print("List 2:", list2)
print("We'll find the common elements between these lists in the next steps.")- 运行此文件：
python3 common_elements_data.py这将显示我们将在下一步中使用的两个列表，以找到共同的元素：
List 1: [1, 2, 3, 4, 5, 6]
List 2: [4, 5, 6, 7, 8, 9]
We'll find the common elements between these lists in the next steps.你已经成功创建并探索了 Python 列表。在下一步中，我们将学习如何找到这两个列表之间的共同元素。
使用不同方法查找共同元素
现在我们有了两个列表，我们将探索多种方法来查找它们之间的共同元素。每种方法都有其优点，了解所有这些方法将帮助你为你的特定需求选择正确的方法。
方法 1：使用循环方法
最直接的方法是使用循环和 in 运算符来检查一个列表中的每个元素是否也存在于另一个列表中。
- 创建一个名为
common_loop.py的新文件，内容如下：
## Import our lists from the previous file
from common_elements_data import list1, list2
## Find common elements using a loop
common_elements = []
for item in list1:
if item in list2:
common_elements.append(item)
print("Common elements using loop method:", common_elements)- 运行脚本：
python3 common_loop.py你应该看到：
Common elements using loop method: [4, 5, 6]这种方法易于理解，但对于大型列表可能效率低下，因为 in 运算符必须搜索第一个列表中的每个元素在整个第二个列表中。
方法 2：使用集合（Sets）
一种更有效的方法是利用 Python 的 set 数据结构，该结构针对成员资格测试和查找共同元素进行了优化。
- 创建一个名为
common_sets.py的新文件，内容如下：
## Import our lists from the previous file
from common_elements_data import list1, list2
## Convert lists to sets and find intersection
set1 = set(list1)
set2 = set(list2)
common_elements = list(set1.intersection(set2)) ## Alternative: list(set1 & set2)
print("Common elements using set intersection:", common_elements)- 运行脚本：
python3 common_sets.py你应该看到：
Common elements using set intersection: [4, 5, 6]集合方法通常比循环方法快得多，尤其对于大型列表。但是，请注意，集合不会保留元素的原始顺序。
方法 3：使用列表推导式（List Comprehension）
列表推导式提供了一种简洁的方式，可以基于现有列表创建列表。我们可以使用它在一行代码中找到共同的元素。
- 创建一个名为
common_comprehension.py的新文件，内容如下：
## Import our lists from the previous file
from common_elements_data import list1, list2
## Find common elements using list comprehension
common_elements = [item for item in list1 if item in list2]
print("Common elements using list comprehension:", common_elements)- 运行脚本：
python3 common_comprehension.py你应该看到：
Common elements using list comprehension: [4, 5, 6]列表推导式比循环方法更简洁，并保留元素的顺序，但它仍然具有与循环方法相同的性能特征。
比较所有方法
让我们创建一个比较所有三种方法的文件：
- 创建一个名为
compare_methods.py的新文件，内容如下：
## Import our lists from the previous file
from common_elements_data import list1, list2
## Method 1: Using a loop
common_loop = []
for item in list1:
if item in list2:
common_loop.append(item)
## Method 2: Using sets
common_sets = list(set(list1) & set(list2))
## Method 3: Using list comprehension
common_comprehension = [item for item in list1 if item in list2]
## Print results from all methods
print("Original lists:")
print("List 1:", list1)
print("List 2:", list2)
print("\nCommon elements using different methods:")
print("Loop method:", common_loop)
print("Set method:", common_sets)
print("List comprehension:", common_comprehension)- 运行脚本：
python3 compare_methods.py你应该看到：
Original lists:
List 1: [1, 2, 3, 4, 5, 6]
List 2: [4, 5, 6, 7, 8, 9]
Common elements using different methods:
Loop method: [4, 5, 6]
Set method: [4, 5, 6]
List comprehension: [4, 5, 6]所有三种方法都给我们相同的结果：list1 和 list2 之间的共同元素是 [4, 5, 6]。
现在你已经学习了三种不同的方法来查找 Python 中两个列表之间的共同元素。在下一步中，我们将探索这些技术的一些实际应用。
查找共同元素的实际应用
让我们探索一些在现实世界中，查找列表之间的共同元素很有用的实际应用。我们将使用我们在上一步中学习的方法来实现这些示例。
应用 1：查找共同兴趣
想象一下，你正在构建一个社交网络应用程序，你希望向用户展示那些拥有共同兴趣的用户。让我们模拟这种情况：
- 创建一个名为
common_interests.py的新文件，内容如下：
## User interests data
user1_interests = ["programming", "music", "movies", "hiking", "cooking"]
user2_interests = ["music", "photography", "travel", "cooking", "gaming"]
print("User 1's interests:", user1_interests)
print("User 2's interests:", user2_interests)
## Find common interests using the set method (most efficient)
common_interests = list(set(user1_interests) & set(user2_interests))
print("\nCommon interests:", common_interests)
print("Number of common interests:", len(common_interests))
## Generate a friendly message based on common interests
if len(common_interests) > 0:
message = f"You and this user both enjoy {' and '.join(common_interests)}!"
print("\nSuggested connection message:")
print(message)
else:
print("\nNo common interests found.")- 运行脚本：
python3 common_interests.py你应该看到：
User 1's interests: ['programming', 'music', 'movies', 'hiking', 'cooking']
User 2's interests: ['music', 'photography', 'travel', 'cooking', 'gaming']
Common interests: ['music', 'cooking']
Number of common interests: 2
Suggested connection message:
You and this user both enjoy music and cooking!此示例展示了查找共同元素如何帮助在应用程序中创建个性化的用户体验。
应用 2：比较购物清单
让我们想象一个场景，两个室友有购物清单，并希望协调谁买什么。他们希望识别同时出现在两个列表中的项目，以便他们可以决定谁将购买这些项目。
- 创建一个名为
shopping_lists.py的新文件，内容如下：
## Shopping lists for two roommates
roommate1_list = ["milk", "eggs", "bread", "apples", "coffee", "chicken"]
roommate2_list = ["bananas", "coffee", "cereal", "eggs", "sugar", "bread"]
print("Roommate 1's shopping list:", roommate1_list)
print("Roommate 2's shopping list:", roommate2_list)
## Find duplicate items (appears in both lists)
duplicate_items = [item for item in roommate1_list if item in roommate2_list]
## Find unique items for each roommate
roommate1_unique = [item for item in roommate1_list if item not in roommate2_list]
roommate2_unique = [item for item in roommate2_list if item not in roommate1_list]
print("\nDuplicate items (both roommates planned to buy):", duplicate_items)
print("Unique items for Roommate 1:", roommate1_unique)
print("Unique items for Roommate 2:", roommate2_unique)
## Create a combined shopping list with no duplicates
combined_list = list(set(roommate1_list) | set(roommate2_list))
print("\nCombined shopping list (no duplicates):", combined_list)
## Calculate some statistics
total_items = len(combined_list)
duplicate_count = len(duplicate_items)
efficiency = (duplicate_count / total_items) * 100
print(f"\nShopping efficiency: By coordinating, you've reduced {duplicate_count} duplicate items out of {total_items} total items.")
print(f"This saved {efficiency:.1f}% of total shopping effort!")- 运行脚本：
python3 shopping_lists.py你应该看到：
Roommate 1's shopping list: ['milk', 'eggs', 'bread', 'apples', 'coffee', 'chicken']
Roommate 2's shopping list: ['bananas', 'coffee', 'cereal', 'eggs', 'sugar', 'bread']
Duplicate items (both roommates planned to buy): ['eggs', 'bread', 'coffee']
Unique items for Roommate 1: ['milk', 'apples', 'chicken']
Unique items for Roommate 2: ['bananas', 'cereal', 'sugar']
Combined shopping list (no duplicates): ['chicken', 'eggs', 'coffee', 'milk', 'bananas', 'cereal', 'bread', 'sugar', 'apples']
Shopping efficiency: By coordinating, you've reduced 3 duplicate items out of 9 total items.
This saved 33.3% of total shopping effort!应用 3：分析学生课程注册
让我们创建一个更复杂的示例，分析不同学生的课程注册情况。
- 创建一个名为
course_analysis.py的新文件，内容如下：
## Course enrollments for different students
student_courses = {
"Alice": ["Math101", "Physics101", "ComputerScience101", "History101"],
"Bob": ["Math101", "Chemistry101", "Biology101", "ComputerScience101"],
"Charlie": ["Physics101", "ComputerScience101", "English101"],
"Diana": ["Art101", "History101", "Philosophy101", "English101"]
}
## Print all student enrollments
print("Student Enrollments:")
for student, courses in student_courses.items():
print(f"{student}: {courses}")
print("\n--- Course Analysis ---")
## Find courses that Alice and Bob have in common
alice_bob_common = list(set(student_courses["Alice"]) & set(student_courses["Bob"]))
print(f"\nCourses Alice and Bob have in common: {alice_bob_common}")
## Find a course that all students are taking (if any)
all_students_common = set(student_courses["Alice"])
for student in student_courses:
all_students_common &= set(student_courses[student])
if all_students_common:
print(f"All students are taking: {list(all_students_common)}")
else:
print("There are no courses that all students are taking.")
## Find the most popular course(s)
all_courses = []
for courses in student_courses.values():
all_courses.extend(courses)
course_counts = {}
for course in all_courses:
if course in course_counts:
course_counts[course] += 1
else:
course_counts[course] = 1
max_count = max(course_counts.values())
most_popular = [course for course, count in course_counts.items() if count == max_count]
print(f"\nMost popular course(s) with {max_count} students: {most_popular}")
## Find which students share the most courses with each other
max_common = 0
most_common_pair = ()
students = list(student_courses.keys())
for i in range(len(students)):
for j in range(i+1, len(students)):
student1 = students[i]
student2 = students[j]
common_courses = set(student_courses[student1]) & set(student_courses[student2])
if len(common_courses) > max_common:
max_common = len(common_courses)
most_common_pair = (student1, student2)
shared_courses = common_courses
print(f"\nStudents sharing the most courses: {most_common_pair[0]} and {most_common_pair[1]}")
print(f"They share {max_common} courses: {list(shared_courses)}")- 运行脚本：
python3 course_analysis.py你应该看到输出，显示课程分析，包括学生之间的共同课程和最受欢迎的课程。
这些示例演示了如何应用查找共同元素来解决各种现实世界的问题。识别不同列表中重叠元素的能力是数据分析和创建以用户为中心的应用的强大技术。
性能比较和最佳实践
现在我们了解了查找共同元素的不同方法，并且已经看到了实际应用，让我们比较一下这些方法的性能，并建立一些最佳实践。
衡量性能
让我们创建一个脚本来衡量查找共同元素的不同方法的性能：
- 创建一个名为
performance_test.py的新文件，内容如下：
import time
import random
def measure_time(func, *args):
"""Measure the execution time of a function"""
start_time = time.time()
result = func(*args)
end_time = time.time()
return result, end_time - start_time
## Create large test lists with some overlap
def create_test_lists(size, overlap_percent):
"""Create two lists of the given size with specified overlap percentage"""
overlap_size = int(size * overlap_percent / 100)
## Create list1 with random numbers
list1 = random.sample(range(1, size * 10), size)
## Create list2 with some elements from list1 (overlap) and some new elements
overlap_elements = random.sample(list1, overlap_size)
remaining_size = size - overlap_size
new_elements = random.sample([x for x in range(1, size * 10) if x not in list1], remaining_size)
list2 = overlap_elements + new_elements
random.shuffle(list2)
return list1, list2
## Methods to find common elements
def using_loop(list1, list2):
common = []
for item in list1:
if item in list2:
common.append(item)
return common
def using_sets(list1, list2):
return list(set(list1) & set(list2))
def using_comprehension(list1, list2):
return [item for item in list1 if item in list2]
## Test with different list sizes
sizes = [100, 1000, 10000]
overlap = 50 ## 50% overlap
print("Performance comparison for finding common elements:")
print("-" * 60)
print(f"{'Size':<10}{'Loop (s)':<15}{'Set (s)':<15}{'Comprehension (s)':<20}")
print("-" * 60)
for size in sizes:
list1, list2 = create_test_lists(size, overlap)
## Measure time for each method
_, loop_time = measure_time(using_loop, list1, list2)
_, set_time = measure_time(using_sets, list1, list2)
_, comp_time = measure_time(using_comprehension, list1, list2)
print(f"{size:<10}{loop_time:<15.6f}{set_time:<15.6f}{comp_time:<20.6f}")- 运行脚本：
python3 performance_test.py你应该看到三种方法之间的性能比较，以及不同列表大小的执行时间。输出将如下所示（实际时间会有所不同）：
Performance comparison for finding common elements:
------------------------------------------------------------
Size Loop (s) Set (s) Comprehension (s)
------------------------------------------------------------
100 0.000134 0.000050 0.000117
1000 0.008561 0.000247 0.009018
10000 0.910376 0.001944 0.915267最佳实践
基于我们所学到的知识，让我们创建一个文件，其中包含在 Python 列表中查找共同元素的最佳实践：
- 创建一个名为
best_practices.py的新文件，内容如下：
"""
Best Practices for Finding Common Elements in Python Lists
This file demonstrates recommended approaches for different scenarios
when finding common elements between lists.
"""
## Sample lists for demonstration
small_list1 = [1, 2, 3, 4, 5]
small_list2 = [4, 5, 6, 7, 8]
large_list1 = list(range(1, 10001))
large_list2 = list(range(5001, 15001))
print("Best Practices for Finding Common Elements in Python Lists")
print("=" * 60)
print("\n1. For small lists (less than ~100 elements):")
print(" Any method works well, but set intersection is still recommended for clarity:")
common_small = list(set(small_list1) & set(small_list2))
print(f" Common elements: {common_small}")
print("\n2. For large lists (100+ elements):")
print(" Always use set intersection for performance:")
## Using set method for large lists
start_time = __import__('time').time()
common_large = list(set(large_list1) & set(large_list2))
end_time = __import__('time').time()
print(f" Found {len(common_large)} common elements in {end_time - start_time:.6f} seconds")
print("\n3. When order matters:")
print(" Use list comprehension with a set for lookup efficiency:")
lookup_set = set(small_list2) ## Convert the second list to a set for O(1) lookups
ordered_common = [item for item in small_list1 if item in lookup_set]
print(f" Common elements (preserving order from list1): {ordered_common}")
print("\n4. When dealing with duplicates:")
print(" Standard set intersection removes duplicates. If you need to keep them:")
list1_with_duplicates = [1, 2, 2, 3, 4, 4, 5]
list2_with_duplicates = [2, 2, 4, 5, 5, 6]
print(f" List 1 with duplicates: {list1_with_duplicates}")
print(f" List 2 with duplicates: {list2_with_duplicates}")
## Method that preserves duplicates
def find_common_with_duplicates(list1, list2):
result = []
list2_copy = list2.copy() ## Create a copy to modify
for item in list1:
if item in list2_copy:
result.append(item)
list2_copy.remove(item) ## Remove to avoid matching the same item again
return result
common_with_duplicates = find_common_with_duplicates(list1_with_duplicates, list2_with_duplicates)
print(f" Common elements (preserving duplicates): {common_with_duplicates}")
print("\nSummary:")
print("1. For most cases: Use set intersection -> list(set(list1) & set(list2))")
print("2. When order matters: Convert smaller list to set, use list comprehension on larger list")
print("3. When duplicates matter: Use custom functions that check and remove matched elements")
print("4. Always consider the specific requirements of your use case")- 运行脚本：
python3 best_practices.py这将显示一个关于在不同情况下查找共同元素的最佳实践的综合指南。
创建一个实用程序模块
最后，让我们创建一个可重用的实用程序模块，我们可以在未来的项目中导入它：
- 创建一个名为
list_utils.py的新文件，内容如下：
"""
List Utilities Module
A collection of functions for working with lists, including finding common elements.
"""
def find_common_elements(list1, list2, method='set', preserve_order=False, preserve_duplicates=False):
"""
Find common elements between two lists.
Parameters:
list1 (list): First list
list2 (list): Second list
method (str): Method to use ('set', 'loop', or 'comprehension')
preserve_order (bool): Whether to preserve the order of items from list1
preserve_duplicates (bool): Whether to preserve duplicate common elements
Returns:
list: List of common elements
"""
## Handle the case with duplicates
if preserve_duplicates:
result = []
list2_copy = list2.copy()
for item in list1:
if item in list2_copy:
result.append(item)
list2_copy.remove(item)
return result
## When order matters but duplicates don't
if preserve_order and not preserve_duplicates:
lookup_set = set(list2)
return [item for item in list1 if item in lookup_set]
## When neither order nor duplicates matter
if method == 'set':
return list(set(list1) & set(list2))
elif method == 'loop':
common = []
for item in list1:
if item in list2 and item not in common:
common.append(item)
return common
elif method == 'comprehension':
seen = set()
return [item for item in list1 if item in list2 and not (item in seen or seen.add(item))]
else:
raise ValueError("Method must be 'set', 'loop', or 'comprehension'")
def list_difference(list1, list2):
"""
Find elements in list1 that are not in list2.
Parameters:
list1 (list): First list
list2 (list): Second list
Returns:
list: Elements in list1 but not in list2
"""
return list(set(list1) - set(list2))
def list_union(list1, list2):
"""
Find all unique elements from both lists combined.
Parameters:
list1 (list): First list
list2 (list): Second list
Returns:
list: All unique elements from both lists
"""
return list(set(list1) | set(list2))
## Usage examples
if __name__ == "__main__":
## Sample lists
list1 = [1, 2, 3, 4, 5, 5]
list2 = [4, 5, 5, 6, 7]
print("Original lists:")
print(f"List 1: {list1}")
print(f"List 2: {list2}")
print("\nCommon elements (using different methods):")
print(f"Set method: {find_common_elements(list1, list2, method='set')}")
print(f"Loop method: {find_common_elements(list1, list2, method='loop')}")
print(f"Comprehension method: {find_common_elements(list1, list2, method='comprehension')}")
print("\nWith order and duplicates preserved:")
print(f"Preserving order: {find_common_elements(list1, list2, preserve_order=True)}")
print(f"Preserving duplicates: {find_common_elements(list1, list2, preserve_duplicates=True)}")
print("\nOther list operations:")
print(f"Elements in list1 but not in list2: {list_difference(list1, list2)}")
print(f"Elements in list2 but not in list1: {list_difference(list2, list1)}")
print(f"All unique elements from both lists: {list_union(list1, list2)}")- 运行脚本以查看实用程序模块的运行情况：
python3 list_utils.py- 现在，让我们通过在新脚本中导入它来测试我们的实用程序模块。创建一个名为
test_utils.py的文件：
## Import our utility functions
from list_utils import find_common_elements, list_difference, list_union
## Creating some test data
fruits1 = ["apple", "banana", "cherry", "date", "banana"]
fruits2 = ["banana", "cherry", "fig", "grape", "banana"]
print("Fruits List 1:", fruits1)
print("Fruits List 2:", fruits2)
## Find common elements with different options
common_default = find_common_elements(fruits1, fruits2)
common_order = find_common_elements(fruits1, fruits2, preserve_order=True)
common_duplicates = find_common_elements(fruits1, fruits2, preserve_duplicates=True)
print("\nCommon fruits (default):", common_default)
print("Common fruits (preserving order):", common_order)
print("Common fruits (preserving duplicates):", common_duplicates)
## Find differences between lists
only_in_fruits1 = list_difference(fruits1, fruits2)
only_in_fruits2 = list_difference(fruits2, fruits1)
print("\nFruits only in list 1:", only_in_fruits1)
print("Fruits only in list 2:", only_in_fruits2)
## Find union of lists
all_unique_fruits = list_union(fruits1, fruits2)
print("\nAll unique fruits from both lists:", all_unique_fruits)- 运行测试脚本：
python3 test_utils.py你应该看到输出，演示了我们的实用程序函数以及各种选项。
通过完成此步骤，你不仅了解了不同方法的性能影响，还创建了一个可重用的实用程序模块，你可以将其合并到未来的 Python 项目中。
总结
在这个实验中，你学习了各种在两个 Python 列表中查找共同元素的技术。你已经探索了：
-
查找共同元素的不同方法：
- 使用循环和
in运算符 - 使用 Python 的集合（set）数据结构和交集操作
- 使用列表推导式（list comprehension）
- 使用循环和
-
查找共同元素有用的实际应用：
- 社交网络（查找共同兴趣）
- 购物清单协调
- 课程注册分析
-
性能考量和最佳实践：
- 基于集合（set-based）的方法通常对于大型列表最有效
- 根据你的需求何时保留顺序或重复项
- 如何创建可重用的实用程序函数用于列表操作
这些技能将使你能够编写更有效的 Python 代码，并解决涉及数据比较和分析的现实世界问题。你现在可以自信地在你的 Python 应用程序中操作列表，并根据你的特定需求选择合适的方法来查找共同元素。
