BiteSize Python Coding Tips: 1-20

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):

# 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 =

# Use this:
with open("file.txt", "r") as file:
    content =

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):

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:
    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)}

{'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):
# ('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


No comments yet. Why don’t you start the discussion?

Leave a Reply