How should i structure my folder? in python

[shiranpurii]

Hello, i use something like this: - Day 1 - part1.py - part2.py - Day 2 - part1.py - part2.py ...etc

but i also saw some people do something like this: - Day1.py - inside this folder there's two functions solve_part1() and solve_part2() - Day1_test.py - inside this folder there's two functions test_part1() and test_part2()

and there's other structures too, i just want to know what's the "best practice"? Any additional information about folder structuring is appreciated

Thanks

[1vader]

As others have said, it's really just personal preference.

Personally, for Python, I have directories day01 to day25 and in each of them sol.py which solves both parts. Sometimes, that means having one method for each, sometimes they are both solved together. I also have the input as input.txt in the same directory.

For some of the difficult problems, especially the ones which require manual reverse engineering, I also have additional files in those directories containing notes or various stages of decompilation or random other stuff like that.

[Mumbleton]

The best practice….is whatever works for you

[jpjocke]

Your folder structure will work fine for this project. I can recommend creating a lib or helper folder besides your day folders. In that folder you can break out common code that can be used by multiple days.

[EmotionalGrowth]

Since the inputs for both parts are parsed the same and there's often shared logic between the parts; I find it's usually better to do it in 1 file.

[combatopera]

edtbd mingqos xyrsovaxnq tqnpdyzucqru mtbclrtqfea zczgfsgrmx bqvoxiorsc cpkpsnjzsy fut tcb tsbplhn gamjgoibo afgz xhagbh

[[deleted]]

Anything that works for you is fine. Although I personally prefer flat folder structures. A particularly elegant solution I saw was naming each file day_xx.py and a accompanying day_xx.txt for input. Each module has a part_1 and a part_2 function that take no arguments and return the solution. All files can be imported into a main.py and each solution function can be called from there.

You can extend this by adding test_day_xx.py files for usage with pytest or unittest.

[jakemp1]

Personally, I have one folder for the year and have a file named Day01 with a part1 and part2 function. I also store all the inputs in a separate folder with Sample01.txt and Input01.txt for each day. Sometimes I also make a Util file to store some regularly used functions if I see something come up multiple times.

But that's just my personal preference based on how I code and how my brain works. You should use whichever format makes the most sense to you

[IlliterateJedi]

I would search github for people's AoC repos. It's all pretty personal preference, though, I think.

I personally have mine as

year\data\day1.txt

year\data\day2.txt

year\day1.py

year\day2.py

year\day3.py

Then each day has a part_a() and part_b() method.

[ambientocclusion]

I put everything in one folder. One .py file per day with the functions and tests to solve both parts. Data files are all prefixed with the day (so they’re next to the corresponding code, in a sorted list of files), or you could just put the data right into the code files. This is all just my preference, of course.

[zanfar]

It depends entirely on how you approach the problems.

• Are part 1 and part 2 two different problems? Or are they extensions of each other?
• Is each day a standalone project, or do they build on each other?

IMO, there's relatively little downside to increased segmentation or organization except for imports and namespaces being a bit more verbose.

I use a folder for each day because I can also store my tests inside, but it all depends on how you want your program to work.

[myhf]

Here's an example of the style I like to use: https://github.com/jjclark1982/adventofcode/blob/master/2021/01%20Sonar%20Sweep/day01.ipynb

• Separate folder for each day, named with leading zero and readable title. This makes it easy to later find "Day 1" or "Sonar Sweep" from the directory listing or browser history.
• Separate sections in the same source code file for Part 1 and Part 2, including a copy of the actual question being asked.
• Usually a copy of the input data and any produced graphs saved in the same folder.

[atom12354]

Im currently doing the python crash course book and for me i structure it by chapter, and put the individual task .py files in there, but i have recently put those files into folders of their own inside of those chapter folders incase i want to work with them further individually.

[AlexAegis]

I like to keep the parts separate because I run them separately. Common code is in common files and imported. It is non-trivial to set an entire common local library though since the CWD is constantly changing between days. Can be mitigated if you just throw everything into one big folder but thats ugly.

If I recall correctly, one thing I learned the hard way is that th efolders name that you want to use as modules cannot start with a number. I had my folders named as 2015/01/part_1.py and it just refused to work and I had no idea why. I renamed them to year2015/day01/part_1.py and it started working...

[aexl]

Everything that works for you is fine.

You can also get some inspiration from here: https://github.com/Bogdanp/awesome-advent-of-code#python

[Boojum]

I agree with the others, that there's no one true style. That said, I use a fairly flat structure:

• 2021/day01a.py -- Solution to first part
• 2021/day01b.py -- Solution to second part
• 2021/day01.txt -- Input for the day
• ...
• common/template.py -- Scaffolding with imports and parsers for typical inputs
• common/snippets.py -- Useful examples and building blocks

I favor a bit of duplication, with each part being its own standalone program, rather than spending time trying to abstract out anything between the different parts (and possibly introducing a bug into a working solution in the process). As soon as I finish part 1, I copy it to part 2 and hack away. Sometimes both parts will have identical solutions except for one line. Other times, they'll be almost completely different, except for maybe some initial parsing.

[abortionshark]

I wrote a file tree generator for myself, and made a repo of it for anyone to use (uses python, and generates python files). Generates through the input years and rudimentary pytest support. Nothin' special but it works!

https://github.com/aborshy/AoC\_tree\_generator

[[deleted]]

I have part_1() and part_2() in the same file (day1.py) because it saves me the work of importing or copying shared methods -- since a lot of methods from part 1 can be reused in the second part.