python tricks

https://chatgpt.com/share/9a8a6b0b-e99c-4e1b-917f-699d9f690aa9

1. Swapping Variables

You can swap two variables without needing a temporary variable:

a, b = 5, 10
a, b = b, a

Now, a is 10 and b is 5.

2. List Comprehensions

Generate a new list by applying an expression to each item in an existing list:

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]

squares will be [1, 4, 9, 16, 25].

3. Multiple Return Values

Functions can return multiple values, which can be unpacked:

def get_coordinates():
    return 10, 20

x, y = get_coordinates()

Now, x is 10 and y is 20.

4. Dictionary Comprehensions

Create dictionaries in a concise way:

keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = {k: v for k, v in zip(keys, values)}

my_dict will be {'a': 1, 'b': 2, 'c': 3}.

5. Using _ as a Throwaway Variable

Use _ for variables you don’t need to use later:

for _ in range(5):
    print("Hello")

_ indicates that the variable is just a placeholder.

6. Merging Dictionaries

Merge two dictionaries using **:

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}

merged_dict will be {'a': 1, 'b': 3, 'c': 4}.

7. The enumerate() Function

Get both the index and value while iterating over a list:

names = ['Alice', 'Bob', 'Charlie']
for index, name in enumerate(names):
    print(index, name)

This will print:

0 Alice
1 Bob
2 Charlie

8. Lambda Functions

Use lambda functions for small, anonymous functions:

add = lambda x, y: x + y
print(add(2, 3))  # Output: 5

9. The zip() Function

Combine two or more lists into tuples:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = list(zip(list1, list2))

zipped will be [(1, 'a'), (2, 'b'), (3, 'c')].

10. Set Operations

Use sets to find unique elements and perform set operations like union, intersection, and difference:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2         # {1, 2, 3, 4, 5}
intersection = set1 & set2  # {3}
difference = set1 - set2    # {1, 2}

Here are 20 more Python tricks that can help you write more efficient and elegant code:

11. Using any() and all()

• any(): Returns True if any element in an iterable is True.

• all(): Returns True if all elements in an iterable are True.

numbers = [1, 2, 3, 0]
print(any(numbers))  # Output: True
print(all(numbers))  # Output: False

12. Chaining Comparison Operators

You can chain comparison operators for cleaner syntax:

x = 10
if 5 < x < 15:
    print("x is between 5 and 15")

13. Inverting a Dictionary

Swap keys and values in a dictionary:

my_dict = {'a': 1, 'b': 2, 'c': 3}
inverted_dict = {v: k for k, v in my_dict.items()}

inverted_dict will be {1: 'a', 2: 'b', 3: 'c'}.

14. Ternary Conditional Operator

Use a single line to write if-else conditions:

status = "Success" if condition else "Failure"

15. Default Dictionary with collections.defaultdict

Avoid KeyError by using defaultdict from the collections module:

from collections import defaultdict
my_dict = defaultdict(int)
my_dict['a'] += 1

my_dict['a'] will be 1, even if 'a' was not initially in the dictionary.

16. Using Counter from collections

Count the frequency of elements in an iterable:

from collections import Counter
words = ["apple", "banana", "apple", "orange"]
word_count = Counter(words)

word_count will be Counter({'apple': 2, 'banana': 1, 'orange': 1}).

17. Named Tuples with collections.namedtuple

Create a lightweight object-like structure:

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # Output: 1 2

18. Flattening a List of Lists

Use a list comprehension to flatten a nested list:

nested_list = [[1, 2, 3], [4, 5], [6, 7, 8]]
flat_list = [item for sublist in nested_list for item in sublist]

flat_list will be [1, 2, 3, 4, 5, 6, 7, 8].

19. Finding the Most Common Elements

Use Counter to find the most common elements:

from collections import Counter
data = [1, 1, 2, 3, 3, 3, 4]
most_common = Counter(data).most_common(1)

most_common will be [(3, 3)], meaning 3 appears 3 times.

20. Using itertools for Infinite Iteration

Use itertools.cycle to cycle through an iterable indefinitely:

import itertools
colors = ["red", "green", "blue"]
endless_colors = itertools.cycle(colors)

21. Using itertools for Cartesian Product

Generate the Cartesian product of two lists:

import itertools
list1 = [1, 2]
list2 = ['a', 'b']
product = list(itertools.product(list1, list2))

product will be [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')].

22. Use filter() to Filter a List

Filter elements based on a condition:

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

even_numbers will be [2, 4].

23. Use map() for Element-Wise Operations

Apply a function to every item in an iterable:

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))

squares will be [1, 4, 9, 16, 25].

24. Unpacking Function Arguments

Use * and ** to unpack lists and dictionaries into function arguments:

def add(x, y, z):
    return x + y + z

nums = [1, 2, 3]
print(add(*nums))  # Output: 6

25. List Slicing with Step

You can slice lists with a step:

numbers = [1, 2, 3, 4, 5, 6]
even_indexed = numbers[::2]

even_indexed will be [1, 3, 5].

26. Reversing a String

Reverse a string with slicing:

s = "Hello"
reversed_s = s[::-1]

reversed_s will be "olleH".

27. Enumerating with a Start Index

You can start enumeration at a different index:

names = ['Alice', 'Bob', 'Charlie']
for index, name in enumerate(names, start=1):
    print(index, name)

This will print:

1 Alice
2 Bob
3 Charlie

28. Reading a File into a List of Lines

Use readlines() to read a file into a list of lines:

with open('file.txt', 'r') as file:
    lines = file.readlines()

29. Zipping and Unzipping Lists

Use zip() to combine lists and zip(*...) to unzip:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = list(zip(list1, list2))
unzipped = list(zip(*zipped))

unzipped will be [(1, 2, 3), ('a', 'b', 'c')].

30. Checking the Memory Usage of an Object

Use sys.getsizeof() to check how much memory an object is using:

import sys
a = [1, 2, 3, 4, 5]
print(sys.getsizeof(a))  # Output: size in bytes

31. Using get() with Dictionaries

Use get() to avoid KeyError and provide a default value:

my_dict = {'a': 1, 'b': 2}
value = my_dict.get('c', 0)

value will be 0 since 'c' is not in my_dict.

32. Use del to Remove List Items

Delete items from a list or dictionary using del:

my_list = [1, 2, 3, 4]
del my_list[1]

my_list will be [1, 3, 4].

33. Using try/except/else/finally

Handle exceptions with else and finally blocks:

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Division by zero!")
else:
    print("No errors occurred.")
finally:
    print("This will always execute.")

34. Using with for File Operations

Automatically close files with with:

with open('file.txt', 'r') as file:
    content = file.read()

35. Shorthand for Conditional List Appending

Append to a list only if a condition is met:

numbers = [1, 2, 3, 4, 5]
evens = [x for x in numbers if x % 2 == 0]

evens will be [2, 4].

36. Counting Unique Elements with set()

Use set() to count the number of unique elements:

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_count = len(set(numbers))

unique_count will be 5.

37. Sorting a List of Dictionaries

Sort a list of dictionaries by a specific key:

people = [{'name': 'John', 'age': 30}, {'name': 'Jane', 'age': 25}]
sorted_people = sorted(people, key=lambda x: x['age'])

sorted_people will be [{'name': 'Jane', 'age': 25}, {'name': 'John', 'age': 30}].

38. Combining join() with List Comprehension

Use join() to concatenate strings with a separator:

words = ["hello", "world"]
sentence = ' '.join([word.capitalize() for word in words])

sentence will be "Hello World".

39. Using heapq for a Heap Queue

Maintain a heap queue with the heapq module:

import heapq
numbers = [3, 1, 4, 1, 5, 9]
heapq.heapify(numbers)
smallest = heapq.heappop(numbers)

smallest will be 1.

40. Using json Module for Serialization

Convert a Python object to JSON and vice versa:

import json
data = {'name': 'John', 'age': 30}
json_string = json.dumps(data)
parsed_data = json.loads(json_string)

Here are 30 more Python tricks to further enhance your coding skills:

41. Combining map() with lambda for Transformation

Apply a transformation to each element in a list:

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))

squares will be [1, 4, 9, 16, 25].

42. Using str.format() for String Formatting

Format strings using str.format():

name = "Alice"
greeting = "Hello, {}!".format(name)

greeting will be "Hello, Alice!".

43. Using setdefault() with Dictionaries

Use setdefault() to add a key with a default value if it doesn’t exist:

my_dict = {'a': 1}
my_dict.setdefault('b', 2)

my_dict will be {'a': 1, 'b': 2}.

44. Sorting with sorted() and a Custom Key

Sort a list with a custom key:

words = ["apple", "banana", "cherry"]
sorted_words = sorted(words, key=lambda x: len(x))

sorted_words will be ['apple', 'cherry', 'banana'].

45. Using timeit to Measure Execution Time

Measure the execution time of small code snippets:

import timeit
execution_time = timeit.timeit("sum(range(100))", number=1000)

46. Using enumerate() to Iterate with Index

Iterate over a list with both index and value:

colors = ["red", "green", "blue"]
for index, color in enumerate(colors):
    print(index, color)

47. Swapping Variables Without a Temporary Variable

Swap two variables in one line:

x, y = 5, 10
x, y = y, x

48. Using type() to Check Variable Type

Check the type of a variable:

x = 5
print(type(x))  # Output: <class 'int'>

49. Using reversed() to Reverse an Iterable

Reverse the order of elements in a list or other iterable:

numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))

reversed_numbers will be [5, 4, 3, 2, 1].

50. Using reduce() for Cumulative Operations

Perform cumulative operations on a list using functools.reduce():

from functools import reduce
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)

product will be 120.

51. Using zip() to Iterate Over Multiple Lists

Iterate over two or more lists simultaneously:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for num, letter in zip(list1, list2):
    print(num, letter)

52. Checking for Substring with in

Check if a substring exists within a string:

sentence = "The quick brown fox"
is_present = "quick" in sentence

53. Using dict() to Create a Dictionary

Create a dictionary using the dict() function:

pairs = [('a', 1), ('b', 2)]
my_dict = dict(pairs)

54. Using str.zfill() to Pad Strings

Pad a string with leading zeros:

number = "42"
padded_number = number.zfill(5)

padded_number will be "00042".

55. Using collections.deque for O(1) Append and Pop

collections.deque is optimized for fast appends and pops:

from collections import deque
d = deque([1, 2, 3])
d.append(4)
d.appendleft(0)

56. Using __slots__ to Reduce Memory Usage

Reduce memory usage in classes by defining __slots__:

class MyClass:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

57. Creating a Generator with yield

Use yield to create a generator instead of returning a list:

def generate_squares(n):
    for i in range(n):
        yield i ** 2

58. Using random.sample() to Get Random Samples

Get a random sample from a list:

import random
items = [1, 2, 3, 4, 5]
sample = random.sample(items, 3)

59. Flattening a List of Lists with itertools.chain

Flatten a list of lists using itertools.chain:

import itertools
nested_list = [[1, 2], [3, 4], [5]]
flat_list = list(itertools.chain.from_iterable(nested_list))

60. Using with for Resource Management

Use the with statement to manage resources like files:

with open('file.txt', 'r') as file:
    content = file.read()

61. Handling Large Numbers with decimal

Use the decimal module for precise arithmetic with large numbers:

from decimal import Decimal
result = Decimal('0.1') + Decimal('0.2')

62. Using functools.lru_cache for Caching

Cache the results of expensive function calls:

from functools import lru_cache

@lru_cache(maxsize=32)
def expensive_function(x):
    # time-consuming computation
    return x * x

63. Using bisect for Binary Search

Find the position to insert an element in a sorted list:

import bisect
numbers = [1, 2, 4, 5]
bisect.insort(numbers, 3)

64. Using pathlib for Path Manipulation

Use the pathlib module for path operations:

from pathlib import Path
home = Path.home()

65. Using itertools.groupby() for Grouping Data

Group data based on a key function:

import itertools
data = [{'key': 'a', 'value': 1}, {'key': 'a', 'value': 2}, {'key': 'b', 'value': 3}]
grouped = itertools.groupby(data, key=lambda x: x['key'])
for key, group in grouped:
    print(key, list(group))

66. Using dataclasses for Boilerplate Reduction

Use dataclasses to reduce boilerplate code in classes:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

67. Handling Missing Values with try/except

Handle missing values gracefully using try/except:

my_dict = {'a': 1, 'b': 2}
try:
    value = my_dict['c']
except KeyError:
    value = None

68. Using type() to Dynamically Create Classes

Dynamically create classes with type():

MyClass = type('MyClass', (object,), {'x': 5})
instance = MyClass()

69. Using str.join() with Generators

Use str.join() with generators for memory-efficient string concatenation:

words = ["Hello", "world"]
sentence = ' '.join(word for word in words)

70. Finding the GCD with math.gcd

Find the greatest common divisor using math.gcd:

import math
gcd = math.gcd(8, 12)

71. Using subprocess to Run Shell Commands

Run shell commands with the subprocess module:

import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)

72. **Using math.factorial() to Compute Factorials

** Compute factorials using math.factorial():

import math
factorial = math.factorial(5)

73. Finding the Length of an Iterator with sum()

Use sum() to find the length of an iterator:

iterator = iter([1, 2, 3])
length = sum(1 for _ in iterator)

74. Using vars() to Convert Object to Dictionary

Convert an object’s __dict__ to a dictionary:

class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

instance = MyClass(1, 2)
instance_dict = vars(instance)

75. Using next() with Default Values

Use next() with a default value to avoid StopIteration:

iterator = iter([1, 2, 3])
first = next(iterator, None)

Here are 20 more Python tricks to enhance your coding:

76. Using defaultdict from collections

Simplify dictionary initialization with default values:

from collections import defaultdict
d = defaultdict(int)  # Default value for new keys is 0
d['a'] += 1

77. Using Counter from collections for Counting

Count occurrences of elements in a list:

from collections import Counter
items = ['apple', 'banana', 'apple', 'orange']
count = Counter(items)

78. Using slice() for Flexible Slicing

Create slices with the slice() function:

my_list = [0, 1, 2, 3, 4, 5]
s = slice(1, 4)
sliced = my_list[s]

79. Using getattr() and setattr()

Access and modify object attributes dynamically:

class MyClass:
    def __init__(self):
        self.x = 10

obj = MyClass()
getattr(obj, 'x')  # Access attribute
setattr(obj, 'x', 20)  # Modify attribute

80. Using contextlib for Custom Context Managers

Create custom context managers with contextlib:

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Entering")
    yield
    print("Exiting")

with my_context():
    print("Inside")

81. Using frozenset for Immutable Sets

Use frozenset to create immutable sets:

fs = frozenset([1, 2, 3])

82. Using itertools.product() for Cartesian Product

Generate the Cartesian product of iterables:

import itertools
result = list(itertools.product([1, 2], ['a', 'b']))

83. Using itertools.combinations() for Combinations

Generate all possible combinations of elements:

import itertools
result = list(itertools.combinations([1, 2, 3], 2))

84. Using functools.partial() for Function Currying

Create partial functions with fixed arguments:

from functools import partial
def multiply(x, y):
    return x * y

double = partial(multiply, y=2)
result = double(5)

85. Using collections.namedtuple() for Lightweight Objects

Define simple classes with named fields:

from collections import namedtuple
Point = namedtuple('Point', 'x y')
p = Point(1, 2)

86. Using math.isqrt() for Integer Square Roots

Compute the integer square root of a number:

import math
result = math.isqrt(16)

87. Using __import__() for Dynamic Imports

Import modules dynamically:

module_name = 'math'
math = __import__(module_name)

88. Using os.path.join() for Platform-Independent Paths

Join paths in a platform-independent way:

import os
path = os.path.join('folder', 'file.txt')

89. Using random.choice() to Select Random Elements

Randomly select an element from a list:

import random
choices = ['a', 'b', 'c']
choice = random.choice(choices)

90. Using itertools.cycle() for Infinite Iteration

Iterate over a sequence indefinitely:

import itertools
cyclic = itertools.cycle([1, 2, 3])

91. Using os.environ for Environment Variables

Access environment variables:

import os
value = os.environ.get('MY_ENV_VAR', 'default')

92. Using string.ascii_letters for Character Ranges

Access ASCII letters:

import string
letters = string.ascii_letters

93. Using functools.wraps() for Decorators

Preserve metadata when using decorators:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

94. Using collections.abc for Abstract Base Classes

Check if an object is an instance of an abstract base class:

from collections.abc import Iterable
result = isinstance([], Iterable)

95. Using itertools.count() for Infinite Counting

Create an infinite iterator for counting:

import itertools
counter = itertools.count(start=1, step=2)

96. Using argparse for Command-Line Argument Parsing

Parse command-line arguments:

import argparse
parser = argparse.ArgumentParser(description='Sample parser')
parser.add_argument('x', type=int)
args = parser.parse_args()

97. Using contextlib.redirect_stdout() for Redirecting Output

Redirect standard output temporarily:

from contextlib import redirect_stdout
import io

f = io.StringIO()
with redirect_stdout(f):
    print("This goes to the string IO")
output = f.getvalue()

98. Using inspect for Introspection

Inspect live objects, including functions and classes:

import inspect
def sample_function():
    pass

doc = inspect.getdoc(sample_function)

99. Using datetime for Date and Time Operations

Manipulate and format dates and times:

from datetime import datetime
now = datetime.now()
formatted = now.strftime("%Y-%m-%d %H:%M:%S")

100. Using functools.reduce() for Accumulation

Accumulate values with reduce():

from functools import reduce
data = [1, 2, 3, 4]
total = reduce(lambda x, y: x + y, data)

Certainly! Here are 50 more Python tricks to boost your skills:

101. Using itertools.permutations() for Permutations

Generate all permutations of a sequence:

import itertools
perm = list(itertools.permutations([1, 2, 3]))

102. Using functools.partialmethod() for Partial Methods

Create methods with some arguments fixed:

from functools import partialmethod

class MyClass:
    def say(self, message, times):
        print((message + ' ') * times)
    
    say_hello = partialmethod(say, 'Hello', 3)

instance = MyClass()
instance.say_hello()

103. Using inspect.signature() for Function Signatures

Retrieve function signatures:

import inspect

def example(a, b=1):
    pass

sig = inspect.signature(example)

104. Using functools.cache() for Caching Results

Cache results with functools.cache() (Python 3.12+):

from functools import cache

@cache
def expensive_function(n):
    # time-consuming computation
    return n * n

105. Using itertools.groupby() for Grouping

Group data based on a key:

import itertools

data = [{'key': 'a', 'value': 1}, {'key': 'a', 'value': 2}, {'key': 'b', 'value': 3}]
grouped = {k: list(g) for k, g in itertools.groupby(data, key=lambda x: x['key'])}

106. Using __doc__ for Docstrings

Access the docstring of functions and classes:

def example():
    """This is a docstring."""
    pass

docstring = example.__doc__

107. Using collections.ChainMap() for Merging Dictionaries

Merge multiple dictionaries:

from collections import ChainMap

dict1 = {'a': 1}
dict2 = {'b': 2}
merged = ChainMap(dict1, dict2)

108. Using type() for Dynamic Class Creation

Create classes dynamically:

MyClass = type('MyClass', (object,), {'x': 5})
instance = MyClass()

109. Using os.path.abspath() for Absolute Paths

Convert a relative path to an absolute path:

import os
abs_path = os.path.abspath('file.txt')

110. Using math.prod() for Product of Iterable

Compute the product of an iterable (Python 3.8+):

import math
result = math.prod([1, 2, 3, 4])

111. Using time.strftime() for Formatting Time

Format time using strftime:

import time
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S")

112. Using tempfile for Temporary Files

Create and manage temporary files:

import tempfile

with tempfile.NamedTemporaryFile(delete=False) as temp_file:
    temp_file.write(b'Temporary file content')

113. Using itertools.islice() for Slicing Iterables

Slice iterables efficiently:

import itertools
data = range(10)
sliced = list(itertools.islice(data, 3, 6))

114. Using contextlib.contextmanager() for Context Managers

Define context managers using contextmanager:

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Start")
    yield
    print("End")

with my_context():
    print("Inside")

115. Using functools.update_wrapper() for Decorators

Ensure metadata is updated in decorators:

from functools import update_wrapper

def my_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return update_wrapper(wrapper, func)

116. Using dataclasses.field() for Default Values

Set default values in dataclasses:

from dataclasses import dataclass, field

@dataclass
class MyClass:
    x: int = field(default=10)

117. Using subprocess.run() for Shell Commands

Run shell commands and capture output:

import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)

118. Using pickle for Object Serialization

Serialize and deserialize objects:

import pickle

data = {'key': 'value'}
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

119. Using typing.Optional for Optional Types

Specify optional types:

from typing import Optional

def func(value: Optional[int] = None):
    pass

120. Using argparse for Command-Line Parsing

Parse command-line arguments with argparse:

import argparse

parser = argparse.ArgumentParser(description='Example parser')
parser.add_argument('num', type=int)
args = parser.parse_args()

121. Using os.environ for Environment Variables

Access environment variables:

import os
value = os.environ.get('ENV_VAR', 'default')

122. Using shutil for File Operations

Perform high-level file operations:

import shutil

shutil.copy('source.txt', 'destination.txt')

123. Using mmap for Memory-Mapped File Access

Access files via memory mapping:

import mmap

with open('file.txt', 'r+b') as f:
    mm = mmap.mmap(f.fileno(), 0)
    print(mm[:])

124. Using heapq.nlargest() for Largest Elements

Get the largest n elements:

import heapq

data = [1, 3, 5, 7, 9]
largest = heapq.nlargest(3, data)

125. Using collections.OrderedDict for Order Preservation

Preserve the order of dictionary keys (Python 3.6+ dicts are ordered by default):

from collections import OrderedDict

od = OrderedDict(a=1, b=2, c=3)

126. Using str.translate() for String Translation

Translate characters in a string:

translation_table = str.maketrans('abc', '123')
translated = 'abc'.translate(translation_table)

127. Using collections.abc for Abstract Base Classes

Check if an object is an instance of an abstract base class:

from collections.abc import Iterable

result = isinstance([], Iterable)

128. Using math.ceil() for Ceiling Function

Round numbers up to the nearest integer:

import math

rounded = math.ceil(4.2)

129. Using uuid for Unique Identifiers

Generate unique identifiers:

import uuid

unique_id = uuid.uuid4()

130. Using os.path.splitext() for File Extensions

Split the filename into name and extension:

import os

filename, ext = os.path.splitext('file.txt')

131. Using inspect.getmembers() for Object Attributes

Retrieve all members of an object:

import inspect

class MyClass:
    x = 5
    def method(self):
        pass

members = inspect.getmembers(MyClass)

132. Using collections.UserDict for Custom Dictionaries

Create custom dictionary-like objects:

from collections import UserDict

class MyDict(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key, value * 2)

d = MyDict(a=1)

133. Using os.path.expanduser() for User Paths

Expand ~ to the full user directory path:

import os

user_path = os.path.expanduser('~/file.txt')

134. Using itertools.combinations_with_replacement()

Generate combinations with replacement:

import itertools

result = list(itertools.combinations_with_replacement([1, 2], 2))

135

. Using operator for Functional Programming Use operators as functions:

import operator

add = operator.add
result = add(1, 2)

136. Using timeit for Measuring Execution Time

Measure the execution time of code snippets:

import timeit

execution_time = timeit.timeit('sum(range(100))', number=1000)

137. Using functools.singledispatch() for Generic Functions

Define functions that behave differently based on type:

from functools import singledispatch

@singledispatch
def process(value):
    raise NotImplementedError("Unsupported type")

@process.register(int)
def _(value):
    return value + 1

138. Using subprocess.Popen() for Advanced Process Management

Start and manage subprocesses:

import subprocess

process = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE)
stdout, stderr = process.communicate()

139. Using collections.deque for Efficient Queues

Implement FIFO or LIFO queues:

from collections import deque

queue = deque([1, 2, 3])
queue.append(4)
queue.popleft()

140. Using getattr() with Dynamic Attributes

Dynamically access attributes:

class MyClass:
    attribute = 'value'

obj = MyClass()
attr_value = getattr(obj, 'attribute')

141. Using contextlib.ExitStack() for Multiple Context Managers

Manage multiple context managers:

from contextlib import ExitStack

with ExitStack() as stack:
    file1 = stack.enter_context(open('file1.txt'))
    file2 = stack.enter_context(open('file2.txt'))

142. Using functools.lru_cache() for Memoization

Cache function results:

from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_function(n):
    return n * n

143. Using logging.basicConfig() for Basic Logging Setup

Configure logging settings:

import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

144. Using collections.defaultdict for Automatic Default Values

Automatically initialize dictionary values:

from collections import defaultdict

d = defaultdict(list)
d['key'].append(1)

145. Using os.path.dirname() for Directory Name

Get the directory name from a path:

import os

directory = os.path.dirname('/path/to/file.txt')

146. Using itertools.cycle() for Cycling through Iterables

Repeat elements indefinitely:

import itertools

cycle = itertools.cycle([1, 2, 3])

147. Using collections.Counter for Element Counting

Count element frequencies:

from collections import Counter

counts = Counter(['a', 'b', 'a'])

148. Using functools.wraps to Preserve Metadata

Preserve metadata in decorators:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

149. Using dataclasses.asdict() for Converting Dataclasses to Dictionaries

Convert dataclasses to dictionaries:

from dataclasses import dataclass, asdict

@dataclass
class MyClass:
    x: int
    y: int

instance = MyClass(1, 2)
instance_dict = asdict(instance)

150. Using uuid.uuid1() for Time-Based UUIDs

Generate UUID based on the current time:

import uuid

time_based_uuid = uuid.uuid1()

Here are 50 more Python tricks to further enhance your skills:

151. Using itertools.starmap() for Argument Unpacking

Apply a function to arguments unpacked from an iterable:

import itertools

def add(x, y):
    return x + y

result = list(itertools.starmap(add, [(1, 2), (3, 4)]))

152. Using collections.namedtuple() for Immutable Objects

Create simple classes with named fields:

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)

153. Using __slots__ to Save Memory

Define fixed attributes to save memory:

class MyClass:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

154. Using bytearray() for Mutable Bytes

Create a mutable byte array:

b = bytearray(b'hello')
b[0] = ord('H')

155. Using pathlib.Path for Path Operations

Work with filesystem paths using an object-oriented approach:

from pathlib import Path

p = Path('file.txt')
p.rename('new_file.txt')

156. Using collections.ChainMap for Multi-Dict Lookup

Combine multiple dictionaries:

from collections import ChainMap

dict1 = {'a': 1}
dict2 = {'b': 2}
combined = ChainMap(dict1, dict2)

157. Using traceback.format_exc() for Exception Tracebacks

Get a formatted traceback of an exception:

import traceback

try:
    1 / 0
except Exception:
    error_message = traceback.format_exc()

158. Using dataclasses.replace() for Copying Instances

Create a new instance with some fields replaced:

from dataclasses import dataclass, replace

@dataclass
class MyClass:
    x: int
    y: int

instance = MyClass(1, 2)
new_instance = replace(instance, x=10)

159. Using ast.literal_eval() for Safe Evaluation

Safely evaluate strings containing Python literals:

import ast

result = ast.literal_eval('[1, 2, 3]')

160. Using math.comb() for Combinations (Python 3.8+)

Calculate combinations:

import math

combinations = math.comb(5, 2)

161. Using contextlib.suppress() for Silencing Exceptions

Suppress specified exceptions:

from contextlib import suppress

with suppress(FileNotFoundError):
    open('file.txt')

162. Using itertools.product() for Cartesian Products

Compute Cartesian products:

import itertools

result = list(itertools.product([1, 2], repeat=2))

163. Using types.SimpleNamespace for Dynamic Attributes

Create objects with dynamic attributes:

from types import SimpleNamespace

obj = SimpleNamespace(a=1, b=2)

164. Using decimal.Decimal for Precision Arithmetic

Perform precise decimal arithmetic:

from decimal import Decimal

result = Decimal('0.1') + Decimal('0.2')

165. Using collections.Counter.most_common() for Top Elements

Get the most common elements:

from collections import Counter

counts = Counter('abracadabra')
top_two = counts.most_common(2)

166. Using types.FunctionType for Dynamic Function Creation

Create functions dynamically:

from types import FunctionType

def dynamic_func(x):
    return x * 2

func = FunctionType(dynamic_func.__code__, globals(), 'dynamic_func')

167. Using os.path.join() for Path Construction

Construct file paths:

import os

path = os.path.join('dir', 'file.txt')

168. Using functools.total_ordering() for Ordering Methods

Simplify class ordering methods:

from functools import total_ordering

@total_ordering
class MyClass:
    def __init__(self, value):
        self.value = value
    
    def __eq__(self, other):
        return self.value == other.value
    
    def __lt__(self, other):
        return self.value < other.value

169. Using os.path.basename() for Base Filename

Extract the base name of a file:

import os

base_name = os.path.basename('/path/to/file.txt')

170. Using collections.defaultdict with Functions

Initialize defaultdict with a function:

from collections import defaultdict

d = defaultdict(lambda: 'default_value')

171. Using inspect.getargspec() for Function Arguments

Get function argument details:

import inspect

def example(a, b=1):
    pass

argspec = inspect.getargspec(example)

172. Using random.choices() for Random Sampling with Replacement

Randomly sample elements with replacement:

import random

choices = random.choices(['a', 'b', 'c'], k=5)

173. Using heapq.heappush() for Priority Queues

Push elements onto a priority queue:

import heapq

heap = []
heapq.heappush(heap, (1, 'a'))

174. Using warnings.warn() for Warning Messages

Issue warnings:

import warnings

warnings.warn('This is a warning message')

175. Using os.makedirs() for Creating Directories

Create directories recursively:

import os

os.makedirs('dir/subdir', exist_ok=True)

176. Using inspect.getmembers() for Inspecting Classes

List all members of a class:

import inspect

class MyClass:
    def method(self):
        pass

members = inspect.getmembers(MyClass)

177. Using textwrap.fill() for Wrapping Text

Wrap text to a specific width:

import textwrap

wrapped_text = textwrap.fill('This is a long text that will be wrapped.', width=20)

178. Using collections.abc.Callable for Callable Check

Check if an object is callable:

from collections.abc import Callable

result = isinstance(lambda x: x, Callable)

179. Using pickle.HIGHEST_PROTOCOL for Pickle Protocol

Use the highest protocol for pickling:

import pickle

data = {'key': 'value'}
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

180. Using socket.gethostname() for Hostname

Get the local machine's hostname:

import socket

hostname = socket.gethostname()

181. Using contextlib.ExitStack() for Multiple Context Managers

Manage multiple context managers efficiently:

from contextlib import ExitStack

with ExitStack() as stack:
    file1 = stack.enter_context(open('file1.txt'))
    file2 = stack.enter_context(open('file2.txt'))

182. Using datetime.timedelta for Date Differences

Compute differences between dates:

from datetime import datetime, timedelta

today = datetime.now()
tomorrow = today + timedelta(days=1)

183. Using string.Template for String Substitution

Perform string substitutions:

from string import Template

template = Template('Hello, $name!')
result = template.substitute(name='Alice')

184. Using functools.reduce() for Reducing Iterables

Reduce an iterable to a single value:

from functools import reduce

result = reduce(lambda x, y: x + y, [1, 2, 3, 4])

185. Using decimal.getcontext() for Decimal Precision

Set and get decimal precision:

from decimal import Decimal, getcontext, Context

getcontext().prec = 4
result = Decimal('1.23456') + Decimal('2.34567')

186. Using itertools.combinations() for Combinations

Generate

all possible combinations:

import itertools

combinations = list(itertools.combinations([1, 2, 3], 2))

187. Using re.sub() with Functions

Replace text using functions:

import re

def replace_func(match):
    return match.group(0).upper()

result = re.sub(r'\b\w+\b', replace_func, 'hello world')

188. Using os.getenv() for Environment Variables

Get environment variable values:

import os

value = os.getenv('HOME')

189. Using itertools.islice() for Slicing Iterables

Slice iterables efficiently:

import itertools

result = list(itertools.islice(range(10), 5))

190. Using binascii.hexlify() for Binary to Hex Conversion

Convert binary data to hexadecimal:

import binascii

hex_data = binascii.hexlify(b'hello')

191. Using functools.partial() for Function Specialization

Create a specialized version of a function:

from functools import partial

def multiply(x, y):
    return x * y

double = partial(multiply, y=2)

192. Using pickle.load() and pickle.dump() for Serialization

Serialize and deserialize objects:

import pickle

with open('data.pkl', 'wb') as f:
    pickle.dump({'key': 'value'}, f)

with open('data.pkl', 'rb') as f:
    data = pickle.load(f)

193. Using threading.Thread for Concurrency

Run code in parallel threads:

import threading

def worker():
    print('Worker thread')

thread = threading.Thread(target=worker)
thread.start()

194. Using functools.cached_property for Cached Properties

Cache property results:

from functools import cached_property

class MyClass:
    @cached_property
    def expensive_property(self):
        return 'expensive result'

195. Using uuid.uuid4() for Random UUIDs

Generate a random UUID:

import uuid

random_uuid = uuid.uuid4()

196. Using dataclasses.field() for Field Defaults

Set default values for dataclass fields:

from dataclasses import dataclass, field

@dataclass
class MyClass:
    x: int = field(default=0)

197. Using io.StringIO for In-Memory Text Streams

Create an in-memory text stream:

import io

stream = io.StringIO('Hello, world!')

198. Using ctypes for Calling C Functions

Call C functions from Python:

import ctypes

lib = ctypes.CDLL('libc.so.6')
printf = lib.printf
printf(b'Hello, %s!\n', b'world')

199. Using operator.attrgetter() for Attribute Access

Access attributes using a getter function:

import operator

attr_getter = operator.attrgetter('attribute')
value = attr_getter(obj)

200. Using unittest.mock.patch() for Mocking

Mock objects for testing:

from unittest.mock import patch

with patch('module.Class') as MockClass:
    MockClass.return_value = 'mocked value'