Python
Ultimate Guide
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
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
I: i x > y:
┣
Eli: eli x < y:
┣
Else: else:
┗
Loops
For: or x in range(5):
┣
While: while x < 5:
┣
Break: break
┣
Continue: continue
┗
Functions
Dening: de my_unction():
┣
Calling: my_unction()
┣
Deault parameters: de unc(x, y=0):
┣
Variable-length arguments: de unc(*args, **kwargs):
┗
Classes & Objects
Class denition: class MyClass:
┣
Constructor: de __init__(sel):
┣
Instance methods: de method(sel):
┣
Class variables: class_var = 0
┣
Object instantiation: my_object = MyClass()
┣
Inheritance: class DerivedClass(BaseClass):
┣
Method overriding: de method(sel):
┗
Error Handling
Try: try:
┣
Except: except Exception as e:
┣
Raise: raise ValueError("Error message")
┣
Finally: nally:
┗
Importing Libraries
Import: import numpy
┣
Alias: import numpy as np
┣
Specic import: rom math import pi
┗
File I/O
Open: with open("le.txt", "r") as le:
┣
Read: le.read()
┣
Write: with open("le.txt", "w") as le:
┣
Append: with open("le.txt", "a") as le:
┣
List Comprehensions
Syntax: [expression or item in iterable i condition]
┣
Lambda Functions
Syntax: lambda arguments: expression
┣
Iterators & Generators
Iterator: iter(obj)
┣
Next item: next(iterator)
┣
Generator unction: de my_generator(): yield value
┣
Generator expression: (expression or item in iterable i condition)
┗
Context Managers
Dening: class MyContext:
┣
Enter method: de __enter__(sel):
┣
Exit method: de __exit__(sel, exc_type, exc_value, traceback):
┣
Using: with MyContext() as my_context:
┗
Built-in Functions
len(obj) → Length o object
┣
sum(iterable[, start]) → Sum o elements
┣
max(iterable[, key]) → Maximum element
┣
min(iterable[, key]) → Minimum element
┣
sorted(iterable[, key][, reverse]) → Sorted list
┣
range(stop[, start][, step]) → Sequence o numbers
┣
zip(*iterables) → Iterator o tuples
┣
map(unction, iterable) → Apply unction to all items
┣
lter(unction, iterable) → Filter elements by unction
┣
isinstance(obj, classino) → 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
nd(sub[, start][, end]) → Find substring index
┣
ormat(*args, **kwargs) → Format string
┗
List Methods
append(item) → Add item to end
┣
extend(iterable) → Add elements o iterable
┣
insert(index, item) → Insert item at index
┣
remove(item) → Remove rst 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 o keys
┣
values() → View list o values
┣
items() → View key-value pairs
┣
get(key[, deault]) → Get value or key
┣
update([other]) → Update dictionary
┣
pop(key[, deault]) → Remove & return value
┣
clear() → Remove all items
┗
Set Methods
add(item) → Add item
┣
update(iterable) → Add elements o iterable
┣
discard(item) → Remove item i present
┣
remove(item) → Remove item or raise KeyError
┣
pop() → Remove & return item
┣
clear() → Remove all items
┣
union(*others) → Union o sets
┣
intersection(*others) → Intersection o sets
┣
dierence(*others) → Dierence o sets
┣
issubset(other) → Check i subset
┣
issuperset(other) → Check i superset
┗
Regular Expressions
import re
┣
re.search(pattern, string)
┣
re.match(pattern, string)
┣
re.ndall(pattern, string)
┣
re.sub(pattern, repl, string)
┣
Common patterns:
┗
┣ \d: Digit
┣ \w: Word character
┣ \s: Whitespace
┣ .: Any character (except newline)
┣ ^: Start o string
┣ $: End o 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
Dening: de my_decorator(unc):
┣
Applying: @my_decorator
┗
Modules & Packages
Creating a module: Save as .py le
┣
Importing a module: import my_module
┣
Creating a package: Create directory with __init__.py
┣
Importing rom a package: rom 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.strtime(ormat)
┣
Parse: datetime.datetime.strptime(date_string, ormat)
┣
Common ormat codes: %Y, %m, %d, %H, %M, %S
┗
JSON
import json
┣
JSON to Python: json.loads(json_string)
┣
Python to JSON: json.dumps(obj)
┣
Read rom le: json.load(le)
┣
Write to le: json.dump(obj, le)
┗
Threading
import threading
┣
Create a thread: t = threading.Thread(target=unction, args=(arg1, arg2))
┣
Start a thread: t.start()
┣
Wait or thread to nish: t.join()
┗
Multiprocessing
import multiprocessing
┣
Create a process: p = multiprocessing.Process(target=unction, args=(arg1,
┣
arg2))
Start a process: p.start()
┣
Wait or process to nish: 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.etchall()
┣
Close the connection: conn.close()
┗
Web Scraping (BeautifulSoup)
rom bs4 import BeautiulSoup
┣
Create a BeautiulSoup object: soup = BeautiulSoup(html_content,
┣
'html.parser')
Find elements by tag: soup.nd_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
┗
Web Development (Flask)
rom fask import Flask, render_template, request, redirect, url_or
┣
Create a Flask app: app = Flask(__name__)
┣
Dene a route: @app.route('/path', methods=['GET', 'POST'])
┣
Run the app: app.run(debug=True)
┣
Return a response: return "Hello, World!"
┣
Render a template: return render_template('template.html', variable=value)
┣
Access request data: request.orm['input_name']
┣
Redirect to another route: return redirect(url_or('route_unction'))
┗
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 tensorfow as t
┣
Keras: rom tensorfow import keras
┣
PyTorch: import torch
┣
Command Line Arguments (argparse)
import argparse
┣
Create an ArgumentParser: parser =
┣
argparse.ArgumentParser(description='Description o your program')
Add arguments: parser.add_argument('--arg_name', type=str,
┣
help='Description o the argument')
Parse arguments: args = parser.parse_args()
┣
Access argument values: args.arg_name
┗
Logging
import logging
┣
Basic conguration: logging.basicCong(level=logging.DEBUG,
┣
ormat='%(asctime)s - %(levelname)s - %(message)s')
Logging levels: logging.debug(), logging.ino(), 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
rom typing import List, Dict, Tuple, Optional, Union, Any
┣
Function type hints: de my_unction(param: int, optional_param:
┣
Optional[str] = None) -> List[int]:
Variable type hints: my_variable: Dict[str, int] = {}
┗
