Python: Guide - Rajanand

Fundamentals

Variables: x = 5
Print: print("Hello, World!")
Comments:
Single-line: # Comment
Multi-line: '''Comment'''

Data Types

Primitive:
String: "Hello"
Integer: 42
Float: 3.14
Boolean: True or False
Collections:
List: [1, 2, 3]
Tuple: (1, 2, 3)
Set: {1, 2, 3}
Dictionary: {"key": "value"}

Operators

Arithmetic: +, -, *, /, //, %, **
Comparison: ==, !=, <, >, <=, >=
Logical: and, or, not
Membership: in, not in
Identity: is, is not

Conditionals

If: if x > y:
Else if: elif x < y:
Else: else:

Loops

For: for x in range(5):
While: while x < 5:
Break: break
Continue: continue

Functions

Defining: def my_function():
Calling: my_function()
Default parameters: def func(x, y=0):
Variable-length arguments: def func(*args, **kwargs):

Classes & Objects

Class definition: class MyClass:
Constructor: def __init__(self):
Instance methods: def method(self):
Class variables: class_var = 0
Object instantiation: my_object = MyClass()
Inheritance: class DerivedClass(BaseClass):
Method overriding: def method(self):

Error Handling

Try: try:
Except: except Exception as e:
Raise: raise ValueError("Error message")
Finally: finally:

Importing Libraries

Import: import numpy
Alias: import numpy as np
Specific import: from math import pi

File I/O

Open: with open("file.txt", "r") as file:
Read: file.read()
Write: with open("file.txt", "w") as file:
Append: with open("file.txt", "a") as file:

List Comprehensions

Syntax: [expression for item in iterable if condition]

Lambda Functions

Syntax: lambda arguments: expression

Iterators & Generators

Iterator: iter(obj)
Next item: next(iterator)
Generator function: def my_generator(): yield value
Generator expression: (expression for item in iterable if condition)

Context Managers

Defining: class MyContext:
Enter method: def __enter__(self):
Exit method: def __exit__(self, exc_type, exc_value, traceback):
Using: with MyContext() as my_context:

Built-in Functions

len(obj) → Length of object
sum(iterable[, start]) → Sum of elements
max(iterable[, key]) → Maximum element
min(iterable[, key]) → Minimum element
sorted(iterable[, key][, reverse]) → Sorted list
range(stop[, start][, step]) → Sequence of numbers
zip(*iterables) → Iterator of tuples
map(function, iterable) → Apply function to all items
filter(function, iterable) → Filter elements by function
isinstance(obj, classinfo) → Check object’s class

String Methods

lower() → Lowercase
upper() → Uppercase
strip([chars]) → Remove leading/trailing characters
split([sep][, maxsplit]) → Split by separator
replace(old, new[, count]) → Replace substring
find(sub[, start][, end]) → Find substring index
format(*args, **kwargs) → Format string

List Methods

append(item) → Add item to end
extend(iterable) → Add elements of iterable
insert(index, item) → Insert item at index
remove(item) → Remove first occurrence
pop([index]) → Remove & return item
index(item[, start][, end]) → Find item index
count(item) → Count occurrences
sort([key][, reverse]) → Sort list
reverse() → Reverse list

Dictionary Methods

keys() → View list of keys
values() → View list of values
items() → View key-value pairs
get(key[, default]) → Get value for key
update([other]) → Update dictionary
pop(key[, default]) → Remove & return value
clear() → Remove all items

Set Methods

add(item) → Add item
update(iterable)→ Add elements of iterable
discard(item) → Remove item if present
remove(item) → Remove item or raise KeyError
pop() → Remove & return item
clear() → Remove all items
union(*others) → Union of sets
intersection(*others) → Intersection of sets
difference(*others) → Difference of sets
issubset(other) → Check if subset
issuperset(other) → Check if superset

Regular Expressions

import re
re.search(pattern, string)
re.match(pattern, string)
re.findall(pattern, string)
re.sub(pattern, repl, string)
Common patterns:
\d: Digit
\w: Word character
\s: Whitespace
.: Any character (except newline)
^: Start of string
$: End of string
*: Zero or more repetitions
+: One or more repetitions
?: Zero or one repetition
{n}: Exactly n repetitions
{n,}: At least n repetitions
{,m}: At most m repetitions
{n,m}: Between n and m repetitions (inclusive)

Decorators

Defining: def my_decorator(func):
Applying: @my_decorator

Modules & Packages

Creating a module: Save as .py file
Importing a module: import my_module
Creating a package: Create directory with __init__.py
Importing from a package: from my_package import my_module

Virtual Environments

Creating: python -m venv myenv
Activating:
Windows: myenv\Scripts\activate
Unix/Mac: source myenv/bin/activate
Deactivating: deactivate

Package Management (pip)

Install: pip install package_name
Uninstall: pip uninstall package_name
Upgrade: pip install --upgrade package_name
List installed packages: pip list
Show package details: pip show package_name

Date & Time

import datetime
Current date & time: datetime.datetime.now()
Date object: datetime.date(year, month, day)
Time object: datetime.time(hour, minute, second, microsecond)
Format: datetime.datetime.strftime(format)
Parse: datetime.datetime.strptime(date_string, format)
Common format codes: %Y, %m, %d, %H, %M, %S

JSON

import json
JSON to Python: json.loads(json_string)
Python to JSON: json.dumps(obj)
Read from file: json.load(file)
Write to file: json.dump(obj, file)

Threading

import threading
Create a thread: t = threading.Thread(target=function, args=(arg1, arg2))
Start a thread: t.start()
Wait for thread to finish: t.join()

Multiprocessing

import multiprocessing
Create a process: p = multiprocessing.Process(target=function, args=(arg1, ##arg2))
Start a process: p.start()
Wait for process to finish: p.join()

Working with Databases (SQLite)

import sqlite3
Connect to a database: conn = sqlite3.connect('mydb.sqlite')
Cursor object: cursor = conn.cursor()
Execute SQL commands: cursor.execute("CREATE TABLE my_table (id INTEGER, name TEXT)")
Commit changes: conn.commit()
Fetch results: cursor.fetchall()
Close the connection: conn.close()

Web Scraping (BeautifulSoup)

from bs4 import BeautifulSoup
Create a BeautifulSoup object: soup = BeautifulSoup(html_content,'html.parser')
Find elements by tag: soup.find_all('tag_name')
Access element attributes: element['attribute_name']
Get element text: element.text

Web Requests (Requests)

import requests
GET request: response = requests.get(url)
POST request: response = requests.post(url, data=payload)
Response content: response.content
JSON response: response.json()
Response status code: response.status_code

Data Science Libraries

NumPy: import numpy as np
pandas: import pandas as pd
Matplotlib: import matplotlib.pyplot as plt
seaborn: import seaborn as sns
scikit-learn: import sklearn
TensorFlow: import tensorflow as tf
Keras: from tensorflow import keras
PyTorch: import torch

Command Line Arguments (argparse)

import argparse
Create an ArgumentParser: parser = argparse.ArgumentParser(description='Description of your program')
Add arguments: parser.add_argument('--arg_name', type=str,help='Description of the argument')
Parse arguments: args = parser.parse_args()
Access argument values: args.arg_name

Logging

import logging
Basic configuration: logging.basicConfig(level=logging.DEBUG,format='%(asctime)s - %(levelname)s - %(message)s')
Logging levels: logging.debug(), logging.info(), logging.warning(), logging.error(), logging.critical()

Environment Variables

import os
Get an environment variable: os.environ.get('VAR_NAME')
Set an environment variable: os.environ['VAR_NAME'] = 'value'

Type Hints

from typing import List, Dict, Tuple, Optional, Union, Any
Function type hints: def my_function(param: int, optional_param: Optional[str] = None) -> List[int]:
Variable type hints: my_variable: Dict[str, int] = {}

Source

​Fundamentals

​Data Types

​Operators

​Conditionals

​Loops

​Functions

​Classes & Objects

​Error Handling

​Importing Libraries

​File I/O

​List Comprehensions

​Lambda Functions

​Iterators & Generators

​Context Managers

​Built-in Functions

​String Methods

​List Methods

​Dictionary Methods

​Set Methods

​Regular Expressions

​Decorators

​Modules & Packages

​Virtual Environments

​Package Management (pip)

​Date & Time

​JSON

​Threading

​Multiprocessing

​Working with Databases (SQLite)

​Web Scraping (BeautifulSoup)

​Web Requests (Requests)

​Data Science Libraries

​Command Line Arguments (argparse)

​Logging

​Environment Variables

​Type Hints

Fundamentals

Data Types

Operators

Conditionals

Loops

Functions

Classes & Objects

Error Handling

Importing Libraries

File I/O

List Comprehensions

Lambda Functions

Iterators & Generators

Context Managers

Built-in Functions

String Methods

List Methods

Dictionary Methods

Set Methods

Regular Expressions

Decorators

Modules & Packages

Virtual Environments

Package Management (pip)

Date & Time

JSON

Threading

Multiprocessing

Working with Databases (SQLite)

Web Scraping (BeautifulSoup)

Web Requests (Requests)

Data Science Libraries

Command Line Arguments (argparse)

Logging

Environment Variables

Type Hints