DEV Community: Dominic Njenga

Complete GitHub Commands Cheat Sheet

Dominic Njenga — Fri, 09 May 2025 10:28:32 +0000

Whether you're just starting with Git or looking to streamline your workflow, this GitHub command cheat sheet provides all the essential commands you'll need. From setting up your environment to pushing changes to repositories, it's a one-stop guide to help you work efficiently with Git and GitHub.

✅ Setup and Configuration

git config --global user.name "Your Name" — Set your Git username globally.
git config --global user.email "your_email@example.com" — Set your Git email globally.
git config --list — Display the current Git configuration settings.
ssh-keygen -t ed25519 -C "your_email@example.com" — Generate a new SSH key for secure connections.
ssh-add ~/.ssh/id_ed25519 — Add the generated SSH key to the SSH agent.

✅ Repository Commands

git init — Initialize a new Git repository.
git clone <repository_url> — Clone an existing repository to your local machine.

✅ Setting Up HTTPS and SSH

Before pushing to GitHub, you need to set up authentication. Here's how:

1. Setting Up HTTPS:

Go to your repository on GitHub.
Click the Code button.
Copy the HTTPS URL under the HTTPS tab.
In your terminal, run:

  git remote add origin https://github.com/username/repo.git

2. Setting Up SSH:

Generate an SSH key:

  ssh-keygen -t ed25519 -C "your_email@example.com"

Copy the SSH key to your clipboard:

  cat ~/.ssh/id_ed25519.pub

Go to GitHub > Settings > SSH and GPG keys > New SSH key.
Paste the key and save.
In the terminal, run:

  git remote add origin git@github.com:username/repo.git

✅ Pushing to GitHub via HTTPS and SSH

Push Using HTTPS:

# Stage the changes
git add .

# Commit the changes
git commit -m "Your commit message"

# Push to the remote repository via HTTPS
git push https://github.com/username/repo.git main

Push Using SSH:

# Stage the changes
git add .

# Commit the changes
git commit -m "Your commit message"

# Push to the remote repository via SSH
git push git@github.com:username/repo.git main

✅ Basic Commands

git status — Check the status of the working directory and staging area.
git add <filename> — Stage a specific file for commit.
git add . — Stage all changes in the working directory.
git commit -m "commit message" — Commit staged changes with a descriptive message.
git log — View the commit history with full details.
git log --oneline — View a summarized commit history.

✅ Branching and Merging

git branch — List all branches in the repository.
git branch <branch_name> — Create a new branch.
git checkout <branch_name> — Switch to a specific branch.
git checkout -b <branch_name> — Create and switch to a new branch in one command.
git merge <branch_name> — Merge a branch into the current branch.

✅ Remote Repositories

git remote -v — Display all remote repositories linked to the project.
git remote add origin <url> — Link a remote repository to the local repository.
git push -u origin main — Push local changes to the main branch of the remote repository.
git pull — Fetch and merge changes from the remote repository.
git fetch — Fetch changes without merging.

✅ Undoing Changes

git reset <file> — Unstage a file but keep the changes.
git reset --hard — Discard all changes in the working directory.
git revert <commit_hash> — Create a new commit that undoes the specified commit.

✅ Tagging

git tag — List all tags in the repository.
git tag <tag_name> — Create a new tag.
git push origin <tag_name> — Push a specific tag to the remote repository.

✅ Stashing

git stash — Temporarily save changes without committing them.
git stash apply — Reapply stashed changes.
git stash drop — Delete the last stash.

✅ Collaboration and Pull Requests

git fork — Create a personal copy of a repository on GitHub.
git pull request — Create a pull request for review.
git merge --no-ff <branch_name> — Merge with a merge commit, preserving branch history.

✅ Viewing and Searching

git diff — Show differences between the working directory and the staging area.
git show <commit_hash> — Display details of a specific commit.
git blame <file> — Show the last modification for each line of a file.

With these commands, you're equipped to handle everything from basic Git operations to more advanced collaboration features. Bookmark this guide for quick reference, and you're all set to take full control of your projects on GitHub.

Feel free to ask any questions!

Mastering File Handling, Parallel Processing & Python Decorators

Dominic Njenga — Mon, 05 May 2025 23:14:04 +0000

Welcome, fellow devs! Whether you're just stepping into the world of Python or brushing up your skills, this guide is designed to give you a hands-on, practical experience with real-world Python features — from handling massive data files to writing clean, efficient, and reusable code.

Let's dive right in!

Part 1: File Handling in Python

1. Basic File Operations

Python makes file operations a breeze using the built-in open() function. Here's a simple way to open, read, and close a file:

file = open("sample.txt", "r")
content = file.read()
file.close()

But there's a better way — enter the with statement:

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

Why use with?

It ensures the file is closed automatically
Prevents memory leaks and file locks
Cleaner and more Pythonic

2. Reading and Writing Files

Reading a file line-by-line:

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

Writing to a file:

with open("output.txt", "w") as file:
    file.write("Hello, world!")

Appending to a file:

with open("output.txt", "a") as file:
    file.write("\nNew line added!")

3. Handling Large Files Efficiently

Trying to load a massive file all at once? ❌ Not ideal.

Instead, use these efficient techniques:

Reading line-by-line (streaming):

with open("large_file.txt", "r") as file:
    for line in file:
        print(line.strip())

Reading in chunks:

with open("large_file.txt", "r") as file:
    while chunk := file.read(1024):
        print(chunk)

This way, you only load small portions of the file into memory at a time.

4. Working with CSV and Excel Files Using Pandas

If you're working with structured data, Pandas is your best friend:

import pandas as pd

df = pd.read_csv("data.csv")
print(df.head())

To write a CSV:

df.to_csv("output.csv", index=False)

To handle Excel files:

df = pd.read_excel("data.xlsx", sheet_name="Sheet1")
df.to_excel("output.xlsx", index=False, sheet_name="Results")

Handling large CSVs in chunks:

chunk_size = 10000
for chunk in pd.read_csv("large_data.csv", chunksize=chunk_size):
    print(chunk.shape)

Part 2: Parallel Processing in Python

Want to do more in less time? Use your CPU and I/O more efficiently by using parallelism.

1. Multithreading (Great for I/O-bound tasks)

import threading

def print_numbers():
    for i in range(5):
        print(i)

thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_numbers)

thread1.start()
thread2.start()
thread1.join()
thread2.join()

Threads are great for tasks like:

Downloading files
Reading/writing files
Making multiple API calls

2. Multiprocessing (Perfect for CPU-bound tasks)

from multiprocessing import Pool

def square(n):
    return n * n

if __name__ == "__main__":
    with Pool(4) as p:
        result = p.map(square, [1, 2, 3, 4])
    print(result)

Use this when you're crunching data or running heavy calculations.

3. `concurrent.futures` - Simpler Parallelism

For I/O-bound tasks:

from concurrent.futures import ThreadPoolExecutor

def fetch_data(url):
    return f"Fetched {url}"

urls = ["https://site1.com", "https://site2.com"]
with ThreadPoolExecutor() as executor:
    results = executor.map(fetch_data, urls)
    print(list(results))

For CPU-bound tasks:

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

with ProcessPoolExecutor() as executor:
    results = executor.map(cube, [1, 2, 3, 4])
    print(list(results))

Part 3: Decorators — Python's Superpower

Decorators let you wrap functions with extra behavior.

1. A Simple Decorator

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

2. Decorator with Arguments

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hello!")

3. Using `functools.wraps`

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args}")
        return func(*args, **kwargs)
    return wrapper

@log
def add(a, b):
    return a + b

print(add(2, 3))

functools.wraps keeps the original function name and docstring intact.

Lambda Functions

Short, anonymous functions. Great for one-liners.

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

List Comprehensions

squares = [x ** 2 for x in range(5)]

Dictionary Comprehensions

squares_dict = {x: x ** 2 for x in range(5)}

Assignment Questions (Practice Makes Perfect!)

Part 1: File Handling

Write a Python program that reads a CSV file, filters rows where a specific column > 100, and writes the result to a new file.
Modify the program to process large files in chunks.

Part 2: Parallel Processing

Use multithreading to download multiple files simultaneously.
Use multiprocessing to compute factorials of numbers from 1 to 10.

Part 3: Decorators

Create a decorator that logs function execution time.
Write a decorator that caches results of function calls.

Thanks for your time! Feel free to ask any questions!
Which concept would you like to see a deep dive on next? Let me know in the comments! 💬