I'd recommend having a look at Python's "official" Style Guide aka PEP 8, which is widely accepted in the community as a guideline on how Python code should be formatted.
But you can also learn a lot from looking at other peoples code, e.g. here on Code Review. E.g. it's very common to have
imports at the top of the file, followed by constants, class and function definitions, with "script" code most often found at the very end. The script code is often surrounded by
if __name__ == "__main__":, which is a way to tell the interpreter to only run this piece of code in case the file is executed as a script (and not when you try to
import a function from it).
Directly applying this to your code might leave you with an awkward feeling, because some global variables are used inside the functions before they are "physically" defined in the script. You've probably heard this from other people already: try to avoid global variables whenever possible. This is one of the reasons. In general, global variables make it harder so see what goes into a function and how the function affects the "state"/variables of your program without looking at the source code. If all inputs are passed as parameters and the new/altered values are actually returned from the function, you don't need to know what exactly happens inside to understand what's going on.
You work around this be passing all the necessary variables as parameters when calling a function.
If that brings up another strange feeling, like say, a function accepts parameters that seem to have nothing to do with what it name would let one expect, then you have identified another common error: violations of the single responsibility principle. A few ideas how that might look like in your script
main() function where all the script code lives. This function calls other functions as necessary and provides input to them via parameters.
randomize_picture accept all the necessary inputs as parameter and return which image was selected, raise an appropriate exception whenever this is not possible instead of printing to console.
Pass the source image and all the other relevant information to
Alternatively, assemble the target filename also in main so you'll just have to pass two parameters to
from os import listdir, rename
from random import choice
from datetime import datetime
def post_picture(original_picture, pictures_posted_dir, kind, post_time):
"""Here I move the picture to the 'posted' folder"""
rename(original_picture, pictures_posted_dir + kind + post_time + ".png")
def randomize_picture(pictures_to_post, pictures_dir):
"""Here a random picture is selected(if there are any)"""
if not pictures_to_post:
raise ValueError('No Pictures Left')
random_kind = choice(pictures_to_post)
random_kind_dir = pictures_dir + random_kind + "/"
random_picture = choice(listdir(random_kind_dir))
random_picture_dir = random_kind_dir + random_picture
return random_picture_dir, random_kind
# The main directory in which I'll store the pictures
pictures_dir = "C:/Users/firmi/Desktop/Pictures/"
# The directory in which posted pictures go to
pictures_posted_dir = os.path.join(pictures_dir, "Posted/")
# The folders inside the main directory
picture_folders = listdir(pictures_dir)
# List of folders with pictures that have not been posted
pictures_to_post = [kind for kind in picture_folders if not kind.startswith('Posted') and len(listdir(pictures_dir + kind)) > 0]
# Current date of the post
post_time = datetime.now().strftime("_(%d-%m-%Y)")
random_picture_dir, random_kind = randomize_picture(pictures_to_post, pictures_dir)
post_picture(random_picture_dir, pictures_posted_dir, random_kind, post_time)
A few notes on what else has changed:
import _datetime -->
impor datetime. Variables, functions and modules starting with a leading
_ are not supposed to be used in code outside of that file or module. It's a Python convention to tell others, that you consider it an implementation detail which is subject to change. So don't use it.
- the function documentation was changed from
# comments to proper docstrings. docstrings are found by Python's built-in
help(...) function as well as by most IDEs and are THE way to go for function, class, and module documentation.
- whenever working with paths it's best to use either
os.path.join (Python 2/3) or the
pathlib module. Both of them make working with paths much more convenient, e.g. because they know which separator to use for which platform (Linux:
- Look Ma! No global variables ;-)