Alexis Kestler
Hey there! As a fellow Python developer, I know you‘re always looking for ways to write code more efficiently. While Python‘s simple syntax allows us to be productive, there are some incredibly handy one-liners that can make our lives even easier!
In this comprehensive guide, I‘ll be sharing my top Python tricks to help you simplify common tasks and boost your productivity as a developer. These handy one-liners have served me well over the years, and I think you‘ll find them useful too.
So let‘s dive in and level up your Python skills!
Generate a List of Numbers
As Python developers, we often need to generate sequences of numbers – maybe to loop over a range, create test data or slice lists.
The built-in range() function is perfect for this. It lets us create number ranges flexibly and comes in handy in many everyday situations.
To generate a simple list of integers from 0 to 9:
nums = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]Here, range(10) returns a range object that we convert to a list.
We can also specify start, stop and step values. For example, to count from 5 to 15 in steps of 3:
nums = list(range(5, 16, 3)) # [5, 8, 11, 14] This creates the sequence 5, 8, 11, 14. Notice how 15 is excluded since range() doesn‘t include the stop value.
Being able to quickly generate number sequences eliminates the need for explicit loops and makes the code concise.
According to the Python usage survey conducted by JetBrains, range() is among the top 10 most used builtins by Python developers. Its flexibility and ubiquity make range() an essential tool for any Pythonista.
Find Minimum and Maximum Values
Another common task is finding the minimum and maximum values in a collection. Python makes this a one-liner with the min() and max() functions.
Consider this list of numbers:
nums = [5, 2, 7, 3, 1, 9] To find the minimum and maximum values:
min_val = min(nums) # 1
max_val = max(nums) # 9Under the hood, min() and max() leverage sorting algorithms like Timsort to deliver optimized performance.
According to experiments, min() and max() are faster than sorting when:
- The list fits into memory
- There are no key functions involved
- The relative order of elements doesn‘t matter (source)
However, if you need the sorted list, call sorted() once instead of min() and max() separately:
sorted_nums = sorted(nums) # [1, 2, 3, 5, 7, 9]
min_val = sorted_nums[0]
max_val = sorted_nums[-1]So use min() and max() when you just need the extremes, and sorted() when you need the fully sorted list.
Remove Duplicates from a List
Let‘s say we have a list with duplicate elements:
items = [1, 5, 3, 1, 2, 5, 2, 3]To eliminate duplicates and get unique elements, the fastest way is to:
unique_items = set(items) # {1, 2, 3, 5}By converting to a set, all duplicates are automatically removed. Sets are a built-in data type in Python that can only contain unique elements.
Sets have lightning fast lookup times thanks to something called hashing. Under the hood, set elements are mapped to indices of an array using a hashing function.
This provides average O(1) access time compared to O(n) for lists. So converting to a set and back is very fast.
Fun fact: Sets in Python are implemented using hash tables under the hood.
We can get the original list back if needed:
unique_items = list(set(items)) # [1, 2, 3, 5]So leveraging sets is a simple and speedy way to remove duplicates from Python lists.
Count Frequency of Elements
What if we want to count how many times each element appears in a list?
For example:
fruits = [‘apple‘, ‘banana‘, ‘orange‘, ‘banana‘, ‘apple‘]We can use the list.count() method:
print(fruits.count(‘apple‘)) # 2
print(fruits.count(‘banana‘)) # 2This is useful when you need the frequency for just a specific item.
To count frequencies for all elements, we can use a dictionary:
fruit_count = {}
for fruit in fruits:
if fruit not in fruit_count:
fruit_count[fruit] = 1
else:
fruit_count[fruit] += 1
# {‘apple‘: 2, ‘banana‘: 2, ‘orange‘: 1}By storing counts in a dictionary, we can build up frequencies for multiple items during a single pass through the list.
So count() is great when you need just a specific count, and dicts allow counting frequencies for all elements easily.
Check if All Items Match a Condition
Sometimes we need to check if all items in a list pass a certain test.
For example, let‘s verify if all numbers in a list are even:
nums = [2, 4, 6, 8]We can use Python‘s built-in all() function:
all_even = all(num % 2 == 0 for num in nums) # Trueall() takes an iterable and returns True only if all elements evaluate to True.
Inside the call, we pass a generator expression that checks each number modulo 2. Since all numbers dividie evenly, all() returns True.
A code profiling tool like cProfile can prove that all() is faster than writing explicit loops when the iterable is a sequence like range(), tuple or list.
So for simple checks, all() provides a concise and fast way to verify if all items match a condition.
Check if Any Item Matches a Condition
Similarly, we can check if any item in a list passes a test using any():
nums = [1, 3, 5, 7, 9, 11]
has_even = any(num % 2 == 0 for num in nums) # False Here, any() will return True if any one number is even. Since all numbers are odd, it results in False.
Under the hood, any() short-circuits at the first True value and doesn‘t evaluate the entire iterable. This makes it efficient compared to explicit loops.
So any() is perfect for checking if any item from a collection matches a condition.
Reverse a String
Strings are immutable in Python, so to reverse one we need to create a new string.
One approach is using string slicing:
text = "Hello"
reversed_text = text[::-1] # "olleH"Here, the slice ::-1 means start at the end, stop at the beginning, and use a step of -1.
Another way is with reversed() and join():
reversed_text = "".join(reversed(text)) # "olleH"reversed() returns a reverse iterator that join() then combines into a string.
So slicing and reversed() both allow reversing strings neatly in one line.
According to benchmarks on large inputs, string slicing is faster than reversed() for reversing strings.
But reversed() is more versatile since it can be used to reverse any iterable, not just strings.
Convert String to List of Characters
Splitting strings into useful chunks is a common need. Let‘s see how to split into a list of characters:
text = "python"
char_list = list(text) # [‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]We can pass the string to the list() constructor to get a list of one-char strings.
Alternatively, we can use a list comprehension:
char_list = [char for char in text] # [‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]To split on whitespace into words:
text = "hello world"
words = text.split() # [‘hello‘, ‘world‘] So list(), list comprehensions and split() allow splitting strings in different ways.
According to Python creator Guido van Rossum, list comprehensions should be preferred over map() and filter() constructs for readability. I agree list comprehensions are more intuitive once you get used to the [] syntax.
Extract Digits from String
Extracting numeric digits from strings is a common text processing task.
Say we have a string like this:
text = ‘The number is 42‘We can extract the digits using a list comprehension:
digits = [char for char in text if char.isdigit()] # [‘4‘, ‘2‘]Here, we loop through each character and collect only digits using str.isdigit().
The result is a list of digit characters that appear in the string.
An alternative approach is using regular expressions:
import re
digits = re.findall(r‘\d‘, text) # [‘4‘, ‘2‘] But list comprehensions are usually faster than regex for simpler use cases.
So this is an effective one-liner to extract numbers from strings.
Check String Prefixes and Suffixes
To check if a string starts or ends with a substring, Python has two handy string methods – startswith() and endswith().
For example:
text = ‘Python 3.10‘
text.startswith(‘Py‘) # True
text.endswith(‘3.10‘) # True We can also use these methods in list comprehensions:
languages = [‘Python‘, ‘JavaScript‘, ‘C++‘, ‘Java‘]
# Which languages start with ‘P‘?
starts_p = [lang.startswith(‘P‘) for lang in languages] # [True, False, False, False]Here we build a list of Booleans indicating if each language starts with ‘P‘.
These methods come in handy while parsing textual data for building classifiers, heuristics etc.
So startswith() and endswith() provide a clean way to check for prefixes and suffixes on strings.
Join List to String
The opposite of splitting strings is joining a list of strings/characters into a string.
Python‘s join() method allows doing this:
chars = [‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
# Join to string without separators
‘‘.join(chars) # ‘python‘
# Join with spaces
‘ ‘.join(chars) # ‘p y t h o n‘We can also join a list of strings:
words = [‘Hello‘, ‘world‘]
‘ ‘.join(words) # ‘Hello world‘So join() gives a concise way to concatenate string segments.
Under the hood, join() is implemented in C language for improved performance.
Benchmark tests indicate join() is faster than concatenating strings through addition or f-strings when dealing with many elements.
So leverage join() to assemble strings from collections efficiently.
Create Dictionary from Lists
Suppose we have separate lists for keys and values:
keys = [‘a‘, ‘b‘, ‘c‘]
values = [1, 2, 3]We can zip them together into a dictionary using a dict comprehension:
dict_from_lists = {key:value for key, value in zip(keys, values)}
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}Dict comprehensions provide a concise way to create dictionaries from iterables in one line.
This technique works well when you already have data partitioned into separate collections.
So dict comprehensions are ideal for constructing dictionaries on the fly.
Fun fact: Dictionary views like dict.keys(), dict.values() and dict.items() return "dictionary view objects", which are optimized for fast lookup and memory efficiency.
Conditionally Assign Variables
In Python, we can conditionally assign to variables using the ternary operator:
# Ternary operator
age = 18
adult = ‘yes‘ if age >= 18 else ‘no‘ # ‘yes‘Here, we assign the string ‘yes‘ to adult if age is 18 or above, else we assign ‘no‘.
The ternary operator provides an inline way to set variables based on boolean conditions.
Though some find the syntax ( val_if_true if condition else val_if_false ) a bit cryptic compared to if-else blocks.
So use judiciously only for simple one-liners. For complex conditions, if-else statements are better suited for readability.
Generate Permutations
In combinatorics, a permutation refers to an ordered arrangement of elements.
For instance, the list [‘a‘, ‘b‘, ‘c‘] has 3! = 6 permutations:
[‘a‘, ‘b‘, ‘c‘]
[‘a‘, ‘c‘, ‘b‘]
[‘b‘, ‘a‘, ‘c‘]
[‘b‘, ‘c‘, ‘a‘]
[‘c‘, ‘a‘, ‘b‘]
[‘c‘, ‘b‘, ‘a‘]We can generate all permutations of a list in Python using:
from itertools import permutations
letters = [‘a‘, ‘b‘, ‘c‘]
permutations = list(permutations(letters))
# [(‘a‘, ‘b‘, ‘c‘), (‘a‘, ‘c‘, ‘b‘), ..., (‘c‘, ‘b‘, ‘a‘)]permutations() generates all orderings lazily. By converting to a list, we can materialize all permutations.
If you analyze algorithms, you‘ll likely appreciate how easily we can generate permutations and combinations using Python‘s itertools module. No need to implement recursive generators!
Generate Combinations
Similarly, to generate all combinations (subsets) of a given length:
from itertools import combinations
letters = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
subsets = list(combinations(letters, 3))
# [(‘a‘, ‘b‘, ‘c‘), (‘a‘, ‘b‘, ‘d‘), ..., (‘c‘, ‘d‘, ‘b‘)] Here, combinations() generates all 3-element subsets of the letters.
These combinatoric generators work on any iterable and allow building customized subsetting logic easily.
So itertools is invaluable when you need to implement permutation or combination-heavy algorithms.
Conclusion
We‘ve explored a variety of handy Python one-liners – from basics like min(), max() to advanced generators like permutations().
These examples illustrate how Python‘s extensive library and focus on readability enable you to do a lot in one line.
To recap, you can use:
range()to generate numbersmin(),max()to get extremes- Sets to remove duplicates
count()for frequencyall(),any()for conditional checking- Slicing,
reverse()for reversing strings list(),split()for splitting strings- List comprehensions for filtering
startswith(),endswith()for string matchingjoin()to assemble strings- Dict comprehensions to create dicts
- Ternary expressions for conditional assignment
itertoolsfor combinatorics
I hope these tricks help boost your productivity as a Python developer! Let me know if you have any other favorite one-liners.
Keep coding and learning!
