This article has biteSize python coding tips 1-20, as a 100-tips series
1. Understanding List Comprehensions
List comprehensions provide a concise way to create lists. They can make your code more readable and expressive.
# Instead of this:
squares = []
for x in range(10):
squares.append(x*x)
# Use this:
squares = [x*x for x in range(10)]
2. The Power of enumerate()
enumerate() is useful for looping over something and having an automatic counter.
names = ["Alice", "Bob", "Charlie"]
for index, name in enumerate(names, start=1):
print(index, name)3. Using zip() to Iterate Over Multiple Sequences
zip() is handy for iterating over two or more sequences at the same time.
names = ["Alice", "Bob", "Charlie"]
ages = [24, 30, 18]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")4. The Beauty of Generator Expressions
For large datasets, generator expressions can be more memory-efficient than list comprehensions.
# Instead of this (creates a list in memory):
sum_of_squares = sum([x*x for x in range(1000000)])
# Use this (creates an iterator):
sum_of_squares = sum(x*x for x in range(1000000))
5. The with Statement for Resource Management
Use the with statement to ensure resources are properly managed.
# Instead of this:
file = open("file.txt", "r")
content = file.read()
file.close()
# Use this:
with open("file.txt", "r") as file:
content = file.read()6. Unpacking for Swapping Variables
Python allows an elegant way to swap variables without needing a temporary one.
a, b = 5, 10
# Swap values
a, b = b, a
7. Using _ for Ignored Variables
When you’re iterating and some of the values are irrelevant, use _ to indicate they can be ignored.
for _ in range(5):
print("Hello!")8. The Flexibility of Function Arguments
Understand the difference between positional, keyword (named), *args (variable positional), and **kwargs (variable keyword) arguments.
def greet(name, *args, **kwargs):
print(f"Hello, {name}!")
for arg in args:
print(arg)
for key in kwargs:
print(f"{key}: {kwargs[key]}")
greet("Alice", "Loves Python", city="New York", age=30)
9. Dict Comprehensions
Like list comprehensions but for dictionaries. Useful for creating dictionaries dynamically.
# Creating a dict with char count from a string
char_count = {char: s.count(char) for char in set(s)}
print(char_count("abccd"))
{'c': 2, 'd': 1, 'a': 1, 'b': 1}10. Using set for Uniqueness
Sets are useful for removing duplicate elements from a sequence.
# Removing duplicates from a list
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
=> will be [1,2,3,4,5]11. String Methods and join()
Python’s string methods can greatly simplify text processing tasks. The join() method is particularly useful for concatenating iterable elements with a specific separator.
words = ["Python", "is", "awesome"]
sentence = " ".join(words)
print(sentence) # "Python is awesome"12. Using collections.defaultdict
The collections.defaultdict type automates and simplifies the process of adding to dictionaries when keys might not already be present.
from collections import defaultdict
word_counts = defaultdict(int) # Default value of int is 0
for word in words:
word_counts[word] += 1
13. Exploiting collections.Counter for Frequency Counting
collections.Counter is a quick way to get frequencies of elements in an iterable.
from collections import Counter
words = ["red", "blue", "red", "green", "blue", "blue"]
word_counts = Counter(words)
print(word_counts) # Counter({'blue': 3, 'red': 2, 'green': 1})
14. The itertools Module for Combinatorial Problems
itertools provides a variety of tools for iterators; these can be extremely useful for dealing with permutations, combinations, and Cartesian products.
import itertools
for pair in itertools.combinations(['a','b','c'], 2):
print(pair)
# ('a', 'b'), ('a', 'c'), ('b', 'c')
15. Using map() and filter() Instead of Loops
map() and filter() can be used to apply functions to iterables and filter elements without explicit loops.
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
even_squares = filter(lambda x: x % 2 == 0, squared)
print(list(even_squares)) # [4, 16]
16. Comprehending *args and **kwargs
Learn to use *args and **kwargs for flexible function arguments, enabling functions to accept a variable number of arguments.
def func(*args, **kwargs):
print(args) # A tuple of positional arguments
print(kwargs) # A dict of keyword arguments
17. Using List Methods Effectively
Understanding and utilizing list methods like .append(), .extend(), .pop(), .remove(), and .insert() can make list manipulation tasks more intuitive.
my_list = [1, 2, 3]
my_list.append(4) # [1, 2, 3, 4]
my_list.extend([5, 6]) # [1, 2, 3, 4, 5, 6]
18. Leveraging Python’s Slicing
Python’s slicing is not limited to lists; it also works with strings, tuples, and arrays, offering a versatile way to access data.
my_list = [0, 1, 2, 3, 4, 5]
print(my_list[2:5]) # [2, 3, 4]
19. The lambda Function
lambda functions allow for creating small, anonymous function objects. They are handy for short-lived operations where defining a full function is overkill.
add = lambda x, y: x + y
print(add(5, 3)) # 8
20. Unpacking Collections Using * and **
Python allows for unpacking elements from sequences or dictionaries, which can simplify variable assignment and function calls.
first, *middle, last = [1, 2, 3, 4, 5]
print(first) # 1
print(middle) # [2, 3, 4]
print(last) # 5
