Python Cheatsheet

The Python Cheatsheet is a comprehensive course designed to help developers master Python programming through practical labs. It covers a wide range of topics from fundamental basics to advanced concepts including:

• Basics: Syntax, built-in functions, and control flow.
• Data Structures: Lists, tuples, dictionaries, sets, and comprehensions.
• String Manipulation: Formatting and regular expressions.
• File & Data Handling: File/directory path manipulation, reading/writing files, and working with JSON and YAML.
• Advanced Python: Exception handling, debugging, *args and **kwargs, decorators, and context managers.
• Object-Oriented Programming (OOP): OOP basics and Data Classes.
• Development Workflow: Using VS Code, packaging, main functions, and virtual environments.

The fundamental difference between tuples and lists in Python is mutability:

• Lists are mutable: You can modify, add, or remove elements after the list has been created.
• Tuples are immutable: Once created, their contents cannot be changed. Because of this, tuples are generally more memory-efficient than lists.

Both types can contain any type of data.

The setup.py method is the traditional way to define project metadata. To be functional, a setup.py file must include three required fields: name (must be unique on PyPI), version (tracks releases), and packages (describes the location of Python source code).

You can install a package using this method by running:

python setup.py install

Use type hints to specify the expected types for function arguments and return values. This helps editors, linters, and developers understand the code's intent. Annotations follow the syntax parameter: type and -> return_type.

def greet(name: str) -> str:
    return f'Hello {name}'

print(greet('Ada'))

Use shelve.open(filename) within a context manager to create or open a shelf file. You can then assign Python objects to keys in the shelf object just like a standard dictionary.

import shelve

wife = ['Pretty', 'Lovely', 'Nice']
# Open shelf file and save data
with shelve.open('mydata') as shelf_file:
    shelf_file['wife'] = wife

The shelf object supports keys() and values() methods similar to a dictionary. Because these methods return list-like views rather than true lists, wrap them in list() if you need a standard list object.

import shelve

# Access all keys and values in shelf
with shelve.open('mydata') as shelf_file:
    print(list(shelf_file.keys()))
    print(list(shelf_file.values()))

Use the shutil module for file operations:

• shutil.copy(src, dst): Copies a single file to a destination.
• shutil.copytree(src, dst): Recursively copies an entire directory tree, including all subdirectories and files.

import shutil

# Copy a single file
shutil.copy('/tmp/spam.txt', '/tmp/delicious')

# Copy an entire directory tree
shutil.copytree('/tmp/bacon', '/tmp/bacon_backup')

You can update a hash object in chunks by calling the .update() method multiple times. This is useful for processing data streams or large inputs without loading everything into memory at once.

import hashlib

hasher = hashlib.sha256()
hasher.update(b'hello ')
hasher.update(b'world')
print(hasher.hexdigest())

Dictionary comprehensions create new dictionaries from iterables. You can define both keys and values within the expression.

Syntax: {key_expression: value_expression for item in iterable}

Lists (list) are mutable, ordered collections that can hold mixed data types. Use them when you need to build collections item-by-item or access items by position.

Common Operations:

• append(item): Adds an item to the end.
• insert(index, item): Inserts an item at a specific position.
• extend(iterable): Appends multiple items from an iterable.
• remove(value): Removes the first occurrence of a value.
• pop(index): Removes and returns the item at the given index (defaults to the last item).
• len(list): Returns the number of items.

To create a custom exception, define a new class that inherits from Python's built-in Exception class. You can raise these exceptions using the raise keyword and pass a custom error message to the constructor.

To handle them, use except YourCustomExceptionName: just like built-in exceptions.