Python Tips and Tricks
Part 1
Section titled “Part 1”| Purpose | Syntax | Example |
|---|---|---|
| Swap two variables’ values | a, b = b, a |
a, b = 5, 10 -> a, b = 10, 5 |
| Find the maximum or minimum of a list | max_value = max(lst) |
max_value = max([3, 7, 2, 8]) -> 8 |
| Check if all elements in a list are true | all_true = all(lst) |
all_true = all([True, True, False]) -> False |
| Create a list with a range of values | my_list = list(range(1, 6)) |
my_list = [1, 2, 3, 4, 5] |
| Find the index of the maximum element | index = lst.index(max(lst)) |
index = [3, 7, 2, 8].index(8) -> 3 |
| Create a one-liner for-loop | [x*2 for x in range(1, 6)] |
[2, 4, 6, 8, 10] |
| Remove duplicates from a list | unique_lst = list(set(lst)) |
unique_lst = [1, 2, 2, 3, 3, 4] -> [1, 2, 3, 4] |
| Read lines from a file into a list | with open('file.txt') as f: lines = f.readlines() |
lines contains lines from ‘file.txt’ |
| Create a dictionary with default values | my_dict = defaultdict(int) |
my_dict['key'] returns 0 if ‘key’ doesn’t exist |
| Find the factorial of a number | import math; factorial = math.factorial(n) |
factorial = math.factorial(5) -> 120 |
| Iterate over dictionary key-value pairs | for key, value in my_dict.items(): |
for k, v in {'a': 1, 'b': 2}.items(): |
| Use a ternary conditional expression | value = 'Yes' if condition else 'No' |
result = 'Pass' if score >= 70 else 'Fail' |
| Create a copy of a list without references | new_lst = old_lst.copy() |
new_lst is a separate list from old_lst |
| Find the length of a list or string | length = len(my_list) |
length = len('Hello') -> 5 |
| Reverse a string or list | reversed_str = my_str[::-1] |
reversed_str = 'Hello'[::-1] -> 'olleH' |
| Convert a string to uppercase or lowercase | upper_str = my_str.upper() |
upper_str = 'hello'.upper() -> 'HELLO' |
| Check if a string starts or ends with a substring | my_str.startswith('prefix') |
my_str.endswith('suffix') |
| Merge two dictionaries | dict1.update(dict2) |
dict1 now contains keys and values from dict2 |
| Count occurrences of an element in a list | count = my_list.count(element) |
count = [1, 2, 2, 3, 3, 4].count(2) -> 2 |
| Check if a value exists in a list or string | exists = value in my_list |
exists = 'e' in 'Hello' -> True |
| Use a generator expression | (x**2 for x in range(1, 6)) |
Returns a generator object for squared values |
| Get the current date and time | from datetime import datetime; now = datetime.now() |
now contains current date and time |
| Use list comprehension to filter elements | [x for x in my_list if x % 2 == 0] |
Filters even numbers from my_list |
| Find the most common element in a list | from collections import Counter; most_common = Counter(my_list).most_common(1) |
Returns a list of the most common element(s) |
Part 2
Section titled “Part 2”| Purpose | Syntax | Example |
|---|---|---|
| Check if a string is empty | is_empty = not bool(my_str) |
is_empty = not bool('Hello') -> False |
| Sort a list in place | my_list.sort() |
my_list.sort() sorts my_list in ascending order |
| Create a list of unique elements | unique_list = list(set(my_list)) |
unique_list = list(set([1, 2, 2, 3])) -> [1, 2, 3] |
| Find the index of an element in a list | index = my_list.index(element) |
index = ['a', 'b', 'c'].index('b') -> 1 |
| Iterate over a list in reverse order | for item in reversed(my_list): |
Iterates over my_list in reverse |
| Find the absolute value of a number | abs_value = abs(number) |
abs_value = abs(-5) -> 5 |
| Remove whitespace from the beginning and end of a string | trimmed_str = my_str.strip() |
Removes leading and trailing whitespace |
| Use a dictionary to count element occurrences | counts = {item: my_list.count(item) for item in my_list} |
Creates a dictionary of element counts |
| Check if all elements in a list are unique | is_unique = len(my_list) == len(set(my_list)) |
is_unique = len([1, 2, 3, 2]) == len(set([1, 2, 3, 2])) -> False |
| Convert a list of strings to a single string | joined_str = ''.join(my_list) |
joined_str = ''.join(['Hello', ' ', 'World']) -> 'Hello World' |
| Use a dictionary to map values to keys | my_dict = {value: key for key, value in key_value_pairs} |
Creates a dictionary mapping values to keys |
| Find the square root of a number | import math; sqrt_value = math.sqrt(number) |
sqrt_value = math.sqrt(9) -> 3.0 |
| Generate a list of numbers within a range | number_list = list(range(start, stop, step)) |
number_list = list(range(1, 10, 2)) -> [1, 3, 5, 7, 9] |
| Find the least common multiple (LCM) of two numbers | import math; lcm = abs(a * b) // math.gcd(a, b) |
lcm = abs(12 * 18) // math.gcd(12, 18) -> 36 |
| Combine string formatting and variables | formatted_str = f"My name is {name}, and I am {age} years old." |
Uses f-strings for dynamic string formatting |
| Use a dictionary to provide default values | value = my_dict.get(key, default_value) |
value = my_dict.get('key', 'Not found') |
| Filter elements from a list with a lambda function | filtered_list = list(filter(lambda x: x % 2 == 0, my_list)) |
Filters even numbers from my_list |
| Create a function with default arguments | python def greet(name="Guest"): return f"Hello, {name}!" |
Defines a function with a default argument |
| Use a generator function to save memory | python def fibonacci(n): a, b = 0, 1; while n > 0: yield a; a, b, n = b, a + b, n - 1 |
Generates Fibonacci numbers efficiently |
| Find the unique elements shared by two lists | common_elements = list(set(list1) & set(list2)) |
Finds common elements between list1 and list2 |
| Create a dictionary with keys from a list and default values | my_dict = dict.fromkeys(key_list, default_value) |
my_dict = dict.fromkeys(['a', 'b'], 0) -> {'a': 0, 'b': 0} |
| Remove all occurrences of an element from a list | my_list = [x for x in my_list if x != element] |
Removes all occurrences of element from my_list |
| Use a lambda function for quick calculations | square = lambda x: x ** 2 |
square(4) returns 16 |
| Check if a string contains only digits | is_digit_str = my_str.isdigit() |
is_digit_str = '12345'.isdigit() -> True |
Part 3
Section titled “Part 3”| Purpose | Syntax | Example |
|---|---|---|
| Find the index of the first occurrence of an element | index = my_list.index(element) |
index = ['a', 'b', 'c'].index('b') -> 1 |
Use the enumerate function to get index and value |
for index, value in enumerate(my_list): |
Access index and value in a loop |
| Check if a list is empty | is_empty = not bool(my_list) |
is_empty = not bool([]) -> True |
| Use a set for efficient membership tests | my_set = set(my_list); exists = value in my_set |
exists = 3 in {1, 2, 3, 4} -> True |
| Swap case in a string | swapped_str = my_str.swapcase() |
swapped_str = 'Hello'.swapcase() -> 'hELLO' |
Use the zip function to combine two lists |
combined_list = list(zip(list1, list2)) |
combined_list contains pairs from list1 and list2 |
| Convert a string to a list of characters | char_list = list(my_str) |
char_list = list('Python') -> ['P', 'y', 't', 'h', 'o', 'n'] |
Use the collections.Counter for counting elements |
from collections import Counter; counts = Counter(my_list) |
Counts occurrences of elements |
| Find the number of lines in a text string | line_count = len(text.splitlines()) |
line_count = len("Line 1\nLine 2\nLine 3".splitlines()) -> 3 |
| Create a dictionary with multiple keys mapping to the same value | my_dict = dict.fromkeys(keys, value) |
my_dict = dict.fromkeys(['a', 'b'], 0) -> {'a': 0, 'b': 0} |
| Use a dictionary comprehension to create dictionaries | {key: value for key, value in zip(keys, values)} |
Creates a dictionary from two lists |
| Remove leading and trailing characters from a string | stripped_str = my_str.strip("characters") |
Removes specified characters from the beginning and end |
| Convert a list of dictionaries into a dictionary of lists | result_dict = {key: [d[key] for d in dict_list] for key in dict_list[0]} |
Reorganizes data into a dictionary of lists |
| Find the most frequent element in a list | from statistics import mode; most_frequent = mode(my_list) |
Finds the most frequent element |
| Use list comprehension for conditional filtering | [x for x in my_list if condition] |
Filters elements based on a condition |
| Join elements of a list into a string with a separator | joined_str = separator.join(my_list) |
joined_str = ','.join(['apple', 'banana', 'cherry']) -> 'apple,banana,cherry' |
| Check if a string contains only letters and digits | is_alphanumeric = my_str.isalnum() |
is_alphanumeric = 'Python3'.isalnum() -> True |
| Calculate the sum of elements in a list | total = sum(my_list) |
total = sum([1, 2, 3, 4, 5]) -> 15 |
| Extract keys or values from a dictionary | keys = list(my_dict.keys()) |
values = list(my_dict.values()) |
| Replace multiple characters in a string | translated_str = my_str.translate(str.maketrans(old_chars, new_chars)) |
Replaces multiple characters |
| Generate random numbers | import random; random_number = random.randint(min_value, max_value) |
random_number = random.randint(1, 100) |
| Check if a file exists | import os; exists = os.path.isfile(file_path) |
exists = os.path.isfile('my_file.txt') -> True |
| Calculate the length of the longest string in a list | max_length = max(len(item) for item in my_list) |
Finds the length of the longest string |
| Use a list comprehension to flatten a nested list | [item for sublist in nested_list for item in sublist] |
Flattens a list of lists |
| Iterate over a string in reverse order | for char in reversed(my_str): |
Iterates over characters in reverse order |
Part 4
Section titled “Part 4”| Purpose | Syntax | Example |
|---|---|---|
| Convert a string to title case | title_case_str = my_str.title() |
title_case_str = 'python is cool'.title() -> 'Python Is Cool' |
Use the collections.defaultdict for default values |
from collections import defaultdict; my_dict = defaultdict(default_value) |
Provides default values for dictionary keys |
| Find the most common characters in a string | from collections import Counter; common_chars = Counter(my_str).most_common(3) |
Finds the 3 most common characters |
| Generate a list of prime numbers | python def is_prime(n): return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1)); primes = [x for x in range(2, limit) if is_prime(x)] |
Generates a list of prime numbers up to a limit |
| Calculate the average of elements in a list | average = sum(my_list) / len(my_list) |
average = sum([1, 2, 3, 4, 5]) / 5 -> 3.0 |
| Find the index of the last occurrence of an element | index = len(my_list) - my_list[::-1].index(element) - 1 |
index = ['a', 'b', 'c', 'b'].index('b') -> 3 |
| Perform multiple operations in a single line | python result = (value * 2 for value in my_list if value % 2 == 0) |
Applies multiple operations to filter and modify a list |
Use timeit for measuring execution time |
python import timeit; execution_time = timeit.timeit(stmt="your_code_here", number=1000) |
Measures the execution time of code |
| Replace a specific occurrence of a substring in a string | new_str = my_str.replace(old_substring, new_substring, occurrence) |
Replaces only the specified occurrence |
Use zip with * for transposing a matrix |
transposed_matrix = list(zip(*matrix)) |
Transposes a 2D matrix |
| Calculate the greatest common divisor (GCD) | import math; gcd = math.gcd(a, b) |
gcd = math.gcd(24, 36) -> 12 |
| Count occurrences of a substring in a string | count = my_str.count(substring) |
count = 'hello world'.count('l') -> 3 |
| Find the second largest element in a list | second_largest = max(filter(lambda x: x != max(my_list), my_list)) |
Finds the second largest element |
Use functools.reduce() for cumulative operations |
from functools import reduce; product = reduce(lambda x, y: x * y, my_list) |
Calculates the product of elements |
| Check if all elements in a list are identical | are_identical = all(x == my_list[0] for x in my_list) |
are_identical = all([1, 1, 1, 1]) -> True |
Flatten a list of lists using itertools.chain |
from itertools import chain; flat_list = list(chain(*list_of_lists)) |
Flattens a list of lists |
| Find the index of the minimum element in a list | index = my_list.index(min(my_list)) |
index = [5, 2, 8, 1, 7].index(1) -> 3 |
| Create a list of numbers using a generator expression | [x for x in range(start, stop)] |
Generates a list of numbers within a range |
| Count trailing zeros in a factorial number | python def count_trailing_zeros(n): count = 0; while n % 10 == 0: n //= 10; count += 1; return count |
count_trailing_zeros(12000) returns 3 |
| Use a deque for efficient queue operations | from collections import deque; queue = deque() |
Implements a queue with fast operations |
| Check if a string contains only whitespace characters | is_whitespace = my_str.isspace() |
is_whitespace = ' \t\n'.isspace() -> True |
| Split a list into chunks of a specific size | python chunked_list = [my_list[i:i + chunk_size] for i in range(0, len(my_list), chunk_size)] |
Splits my_list into chunks of size chunk_size |
Use the random.sample() function for random sampling |
import random; sample = random.sample(population, k) |
Generates a random sample of size k from population |
| Create a function that accepts an arbitrary number of arguments | def my_function(*args): |
Defines a function that accepts a variable number of arguments |
Use the zip function for parallel iteration |
python for item1, item2 in zip(list1, list2): |
Iterates over two lists in parallel |
Retrieve the last n elements from a list |
last_n_elements = my_list[-n:] |
last_n_elements = [1, 2, 3, 4, 5][-3:] -> [3, 4, 5] |