​
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

OverviewPython List Examples