Here are eight graceful Python tricks that I'm sure you haven’t seen yet. Apply these tricks in your Python code to make it more concise and efficient!
1. Sorting objects by several keys
Suppose we want to sort the following list of dictionaries:
people = [
{ 'name': 'John', "age": 64 },
{ 'name': 'Janet', "age": 34 },
{ 'name': 'Ed', "age": 24 },
{ 'name': 'Sara', "age": 64 },
{ 'name': 'John', "age": 32 },
{ 'name': 'Jane', "age": 34 },
{ 'name': 'John', "age": 99 },
]But we don't just want to sort them by name or age, we want to sort them by both fields. In SQL, this would be a query like this:
SELECT * FROM people ORDER by name, ageActually, there is a very simple solution to this problem, thanks to Python's guarantee that the sorting functions provide sorting stability . This means that the elements that are compared keep their original order.
To achieve sorting by name and age, we can do this:
import operator
people.sort(key=operator.itemgetter('age'))
people.sort(key=operator.itemgetter('name'))Notice how I changed the order. First we sort by age, and then by name. Using
operator.itemgetter()we get the age and name fields from each dictionary in the list.
This gives us the result we wanted:
[
{'name': 'Ed', 'age': 24},
{'name': 'Jane', 'age': 34},
{'name': 'Janet','age': 34},
{'name': 'John', 'age': 32},
{'name': 'John', 'age': 64},
{'name': 'John', 'age': 99},
{'name': 'Sara', 'age': 64}
]Names are sorted first, age is sorted if name matches. Thus, all Johns are grouped by age.
The source of inspiration is a question from StackOverflow .
2. List inclusion (List Generator)
List inclusions can replace the ugly loops used to populate the list. Basic syntax for list inclusions:
[ expression for item in list if conditional ]A very simple example for filling a list with a sequence of numbers:
mylist = [i for i in range(10)]
print(mylist)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]And since you can use an expression, you can do some math as well:
squares = [x**2 for x in range(10)]
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]Or even call an external function:
def some_function(a):
return (a + 5) / 2
my_formula = [some_function(i) for i in range(10)]
print(my_formula)
# [2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0]Finally, you can use "if" to filter the list. In this case, we only store those values that are divisible by 2:
filtered = [i for i in range(20) if i%2==0]
print(filtered)
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]3. Check the memory usage of your objects
Using sys.getsizeof () you can check the memory usage of an object:
import sys
mylist = range(0, 10000)
print(sys.getsizeof(mylist))
# 48Wow ... wait ... why is this huge list weighing just 48 bytes?
This is because the range function returns a class that only behaves like a list. A range is much less memory intensive than an actual list of numbers.
You can see for yourself by using list inclusions to create an actual list of numbers from the same range:
import sys
myreallist = [x for x in range(0, 10000)]
print(sys.getsizeof(myreallist))
# 87632So, after playing with
sys.getsizeof(), you can learn more about Python and your memory usage.
4. Data classes
Since version 3.7, Python offers data classes. There are several advantages over regular classes or other alternatives, such as returning multiple values or dictionaries:
- data class requires minimal code
- you can compare data classes because there is
__eq__ - you can easily infer the data class for debugging because there is
__repr__ - data classes require tape hints, which reduces the chance of errors
Here is an example of a data class in operation:
from dataclasses import dataclass
@dataclass
class Card:
rank: str
suit: str
card = Card("Q", "hearts")
print(card == card)
# True
print(card.rank)
# 'Q'
print(card)
Card(rank='Q', suit='hearts')A detailed guide can be found here .
5. The attrs package
Instead of data classes, you can use attrs . There are two reasons to choose
attrs:
- You are using a Python version older than 3.7
- You want more features
The package
attrssupports all major Python versions including CPython 2.7 and PyPy. Some of the additional attributes offered attrsover regular data classes are validators and converters. Let's take a look at some example code:
@attrs
class Person(object):
name = attrib(default='John')
surname = attrib(default='Doe')
age = attrib(init=False)
p = Person()
print(p)
p = Person('Bill', 'Gates')
p.age = 60
print(p)
# Output:
# Person(name='John', surname='Doe', age=NOTHING)
# Person(name='Bill', surname='Gates', age=60)The authors
attrsactually worked in the PEP that introduced the data classes. Data classes are deliberately kept simpler (easier to understand), while attrs offers a full set of features you might need!
More examples can be found on the attrs examples page .
6. Combining dictionaries (Python 3.5+)
Since Python 3.5, it is easier to combine dictionaries:
dict1 = { 'a': 1, 'b': 2 }
dict2 = { 'b': 3, 'c': 4 }
merged = { **dict1, **dict2 }
print (merged)
# {'a': 1, 'b': 3, 'c': 4}If there are overlapping keys, the keys from the first dictionary will be overwritten.
In Python 3.9, combining dictionaries becomes even cleaner. The above merge in Python 3.9 can be rewritten as:
merged = dict1 | dict27. Search for the most common value
To find the most common value in a list or string:
test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4]
print(max(set(test), key = test.count))
# 4Do you understand why this works? Try to figure this out yourself before reading on.
You even tried, didn't you? I will tell you anyway:
max()will return the largest value in the list. The argumentkeytakes a single argument function to customize the sort order, in this case test.count. The function is applied to each element of the iterable.test.count- built-in list function. It takes an argument and will count the number of occurrences for that argument. So ittest.count(1)will return 2 andtest.count(4)return 4.set(test)returns all unique values from test, so {1, 2, 3, 4}
So, in this single line of code, we accept all unique values for a test that is
{1, 2, 3, 4}. Next, it will maxapply a function to them list.countand return the maximum value.
And no - I did not invent this one-liner.
Update: A number of commentators have rightly noted that there is a much more efficient way to do this:
from collections import Counter
Counter(test).most_common(1)
# [4: 4]8. Returning multiple values
Functions in Python can return more than one variable without a dictionary, list, or class. It works like this:
def get_user(id):
# fetch user from database
# ....
return name, birthdate
name, birthdate = get_user(4)This is normal for a limited number of return values. But everything that exceeds 3 values should be placed in the (data) class.
Find out the details of how to get a high-profile profession from scratch or Level Up in skills and salary by taking SkillFactory's paid online courses:
- Machine Learning (12 )
- Data Science (12 )
- (9 )
- «Python -» (9 )