Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed last year.
Improve this question
TL,DR: Is it a sacrilege to number your code source files in their executing orders ?
I'm developing a very small program in Python, which execution is very sequential.
Kinda looks like a script.
I thought about numbered the source files and librairies by their order of execution, when possible. To me it brings the same clarity in the folder organization, exactly as you would number the chapters of a book...
For transversal functions that can be called at any step of the program they are in files named by their functionalities.
Is it an absolute don't do? Why ?
here is an example of how my project folder looks:
Project_0_main.py
Project_1_step_yyy.py
Project_2_step_xxxx.py
Project_3_step_zzzzz.py
Project_math_functions.py
Project_do_that_function.py
Thanks
The only question that matters is about maintainance. If you are sure that you could possibly adapt steps but never add a new step between 2 other ones, then numbering is fine, even if is is not the most common use(*). It you cannot be sure of that, then you have just find the don't and the reason why.
It is not a absolute don't, but naming scripts with sensible names related to the real actions is a form of minimal, implicit and immediate documentation. Using numbers will lose that, and would require an annex file to document what is done in each numbered step.
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
I have this script I'm working on which is some 2,000 lines. At the top I have a list of settings to be used in the script, then all the functions, then the script itself.
I found myself going back and forth from the actual script to the functions (and the settings) so I thought it might be a good idea to place them in separate files, to be imported in the main script, with the practical benefit of being able to open them in different windows, for ease of access.
Is this approach of any value? or, is there any problem with this, maybe in the long term, when the script grows even more? or is it all down to personal preference?
(if it matters, I'm using Python.)
Let's put it this way:
If you are making a big jig saw puzzle, you start dividing the pieces into sections; clouds with clouds, water with water, grass with grass etc. Subsequently, you don't mix the pieces, but put each of the sections into a different corner on the table.
Likewise, if you have bigger coding projects, you start separating data from code, create functions and classes to organize your code in a way that makes sense, according to their functionality. If the project is big enough, put different sections into different files (modules).
This is not only to limit the scrolling through possibly thousands of lines, but also to keep your mind clean for the section you are working on, and to make the project maintainable.
Last but not least; working this way, most likely at a certain point you will find yourself writing modules, to be reused in other projects.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
Sorry if the title is confusing.
What I am trying to say is this:
I have worked with Python before, but I'm by no means an expert. So far everything I have done has just been 'somefile.py' with lots of methods and code in it, but it doesn't really have any organizational structure. In Java (which I am more familiar with than Python), there are usually different classes that each have methods and are called from each other. How do you make a file full of code organized and structured when working on a large project? Break them up into files by class?
Hopefully this is clearer. Let me know if this needs clarification.
In Python, the file unit is called module. Modules are organized in packages.
You usually put your classes each in a module and also use modules to group related code that doesn't belong to any class. Related modules are grouped in packages (physically represented by directories) which effectively create namespaces.
Then you use the import command to import the desired pieces of the code into other modules.
You can read about modules, packages and import in the Python documentation here.
Logically, it isn't much different than Java or other languages.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 7 years ago.
Improve this question
New programmer here!
I'm creating my first script on my own, and I have a particular function that is quite large, as in 50 lines.
I understand that theoretically a function can be as large as you need it to be, but etiquette-wise, where is a good place to stay under?
I'm using Python 2.something if that makes a difference.
A good rule of thumb (and it's more a guideline of thumb really) is that you should be able to view the entire function on one screen.
That makes it a lot easier to see the control flow without having to scroll all over the place in whatever editor you're using.
If you can't understand fully what a function does at first glance, it's probably a good idea to refactor chunks of code so that the more detailed steps are placed in their own, well-named, separate function and just called from this one.
However, it's not a hard-and-fast rule, you'll adapt your approach depending on your level of expertise and how complex the code actually is.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
I have been making a games using pygame and python and I don't need to make more, separate python files to run my game, but when I look at other peoples programs, they have different files that all work in conjunction with each other for their program to work, why not have all or most of the coding in one file?
I use python 3.2.5 and the corresponding pygame
--- Me in the future --- I apologise for asking this question I didn't know exactly what this website was for and how to ask questions ect. I know know that this website inst for opinions.
People do this because it makes the program more readable.
While writing some code you have to understand the difficulty of the people who will maintain your code.
The main advantages of making it in separate files are:
modularity- By using separate files different modules of the program can be separated into different files. This has many advantages. Whenever a problem occur in some part of the code you can look straight into that file.
Readability- Splitting program into different files helps in making it more readable and beautiful.
easy to maintain- Similar to the advantage told in modularity. Whenever some part of the program needs to be updated it can be done easily.
code reuse- If the program is split carefully into different modules, you can use the same code later when a similar problem has to be solved
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
Im not positive on the terminology here, so that may explain why searching on my own yielded no results.
I was just curious if there is a widely accepted, general method to writing a module in python. Obviosuly people prefer splitting things into segmented .py scripts, importing when needed, and packing it all into a folder.
What I want to know: Is there a general method to how/when/why we stop writing things together in one .py and begin a new one (And i mean other than obvious things like... one script .py for the main job, and then a preferences.py to handle reading/writing prefs)
You should split your code into multiple modules when it begins to be unwieldy to keep it all in one module. This is to some extent a matter of taste. Note that it may unwieldy for the code author (i.e., file is too big to navigate easily) or for the user of the library (e.g., too many unrelated functions/classes jammed together in the same namespace, hard to keep track of them).