Python测试时加载不同资源的实现方案咨询（Java转Python背景）

Hey there! As someone who’s bounced between Java and Python for years, I totally get where you’re coming from—these two languages have very different conventions, and it’s easy to second-guess whether your roadblocks are from missing Python knowledge or leftover Java habits. Let’s break this down.

First, let’s formalize that familiar Java project structure you’re used to (the standard Maven/Gradle layout, right?):

project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── MyClass.java
│   │   └── resources/
│   │       └── properties.file
│   └── test/
│       ├── java/
│       │   └── MyClassTest.java
│       └── resources/
│           └── properties.file

In Java, this structure is enforced by build tools—your test runner (JUnit, TestNG) knows exactly where to look for test classes because they mirror the main source path, and resources are neatly segregated between production and test environments.

Now, Python is way more flexible (some would say chaotic) when it comes to project structure. There’s no "one true layout," but here’s a common, recommended structure for larger projects:

my_project/
├── my_package/
│   ├── __init__.py
│   ├── my_class.py
│   └── resources/
│       └── config.ini
├── tests/
│   ├── __init__.py
│   └── test_my_class.py
└── pyproject.toml  # For modern build tools like poetry/pipenv

For smaller scripts, people often skip the formal package structure entirely and just keep test files in the same directory as their main code.

How to Tell If It’s Java Thinking vs. Python Knowledge Gaps #

Let’s break down common pain points and their root causes:

1. If you’re struggling with:

• Test runners (like pytest) not finding your test files
• Reading resource files (getting "file not found" errors)
• Importing modules between your main code and tests

This is almost certainly a Python knowledge gap. Python doesn’t use the same rigid path mirroring as Java. For example:

• pytest finds tests by looking for files named test_*.py or *_test.py—it doesn’t care if they mirror the main source path (though it’s a good practice for clarity)
• To read resources correctly, use pathlib to reference files relative to your module’s location, not the current working directory (a common gotcha for Java devs used to classpath resources)

2. If you’re struggling with:

• Over-engineering class hierarchies (writing abstract classes/interfaces when a simple function would suffice)
• Using static methods everywhere (instead of leveraging Python’s module-level functions)
• Overusing checked exceptions (Python uses an "EAFP"—Easier to Ask for Forgiveness than Permission—approach instead of Java’s "fail-fast" checked exceptions)

This is likely Java思维 (Java thinking) bleeding over. Python prioritizes readability and pragmatism over strict OOP structure. It’s totally okay to use functions instead of classes when they make sense, and you don’t need to abstract every possible edge case upfront.

Quick Tips to Unstick Yourself #

• Start small: Build a tiny Python project with a simple test suite using pytest—focus on following Python’s idioms instead of copying Java’s structure.
• Use Python’s built-in tools: pathlib for file paths, unittest/pytest for testing, and pyproject.toml for project configuration.
• Ask yourself: "Would a Python developer do this, or am I copying how I’d solve this in Java?" If the answer is the latter, look up Pythonic alternatives.

Take it easy—two months is still early in your Python journey, and mixing up conventions is totally normal. You’ll start to spot the difference between "I don’t know how Python does this" and "I’m forcing Java patterns onto Python" as you experiment more.

内容的提问来源于stack exchange，提问作者Pau Trepat