Github link: shared.python.utils
Hello, and welcome to our first module. In this one we will make the most generic scripts we can think of. These are meant to help us in writing Python. They should not have any other dependencies other than Python or other well established Python libraries.
This function converts any python object into a list(). This is particularly useful when dealing with packages such as Maya and 3DsMax. Many functions in those packages will return either a list() or a str(), depending on how many entries are returned. This is super annoying. You end up having to test the result to see if its a list() every time (ugh!). After writing that check seven times, I gave up.
Another added benefit of this function is that it can help you in making functions that take one or more items as arguments. For example:
# you can call a log function with a text: log("Tell me something") # or with an array: log(["Tell me this", "Tell me that"])
Here is how that function would work:
import shared.python.utils as pyutils # new_list == ["string"] new_list = pyutils.make_list("string") # new_list == ["string"] new_list = pyutils.make_list(["string"])
Have you noticed that some functions return False when they should return an empty string? Check this example:
results = list() for item in list_of_items: results =+ imported.get_value(item)
Imagine that we dont own ‘imported’, its a imported library. And imagine that get_values() returns False if there are no values to get from item. If item ever has no values to return, you would get an error that looks like this:
TypeError: can only concatenate list (not "bool") to list
The solution is simple but annoying. After writing it several times, I decided to add it to my utils module.
This is how you would use it:
import shared.python.utils as pyutils # new_list = ["one", "two", "three", "four"] new_list = pyutils.join_lists(["one","two"],["three", False], ["four"])
This one exists only for readability’s sake. Its not difficult to do this in a single line, but its hard-ish to read.
# its not easy to read this: sans_duplicates = list(set(objects)) # this is much easier: sans_duplicates = pyutils.remove_duplicates(objects)
I find myself looking checking a list to see if it has a bunch of items. I do this often. You can use the set.intersection() function, but it’s hard to read. It ends up looking like this:
# how am I supposed to know what this means??? if len(set(full_list).intersection(items)): return # much easier to read, I think. if pyutils.are_items_in_list(items, full_list): reutrn
I suspect you begin to see a pattern. I always try to make code more readable. In many cases I over do it, I know. However, when I go back to my code weeks, months and years later, I don’t struggle with it so much. So I feel it’s worth it.
I think that’s enough for today. I will deal with more of this module on the next post.
Let me know in the comments if this is a helpful format. Also, if you have any questions about any of the modules mentioned, or any of the ones not mentioned, please dont hesitate.
As always, I welcome any suggestions.