Python with GenAi and DevSecOps Training 2025 – Session 12

Dictionaries :

A dictionary (dict) is an unordered collection of key-value pairs. Each key must be unique and immutable, but values can be any type and are mutable. Dictionaries are perfect for storing and quickly retrieving data by keys.

Key points:

• Unordered, but insertion order is preserved (Python 3.7+)
• Keys are unique and immutable, values can be any type
• Mutable—add, modify, delete items

# Creating a dictionary
student = {“name”: “Alice”, “age”: 24, “grade”: “A”}

# Accessing values
print(student[“name”])  # Alice

# Adding or updating values
student[“age”] = 25
student[“college”] = “XYZ”

# Removing key-value pairs
del student[“grade”]

# Iterating over keys and values
for key, value in student.items():
    print(key, value)

Session 2: Book Reading Part 2  – Kowsalya & Dilip

We introduced this new topic and students showed great interest. They opened up, shared their own reading experiences, and connected the benefits to their daily life, making the discussion lively and inspiring.

• Boosts knowledge & awareness
• Improves focus & concentration
• Enhances vocabulary & communication
• Reduces stress & relaxes the mind
• Sparks imagination & creativity
• Builds critical thinking skills
• Encourages life-long learning

Python With GenAI – Linux Torvalds Team & Grace Hopper Team

Session 1: Strings and Their Functions – Deepak & Kanimozhi

Strings are one of the most fundamental data types in Python. A string is simply a sequence of characters, used to store text. You can define a string using either single or double quotes:

Example :

s1 = ‘Hello, World!’
s2 = “Python is awesome.”

More Handy Methods:

• partition(): Splits string into a tuple of three parts at first separator.
• rpartition(): Splits string at last separator.
• rsplit(): Splits string from right using specified separator.
• center(): Centers string with padding.
• swapcase(): Swaps uppercase to lowercase and vice versa

# String Functions in Python

# Change Case
.capitalize()      # First letter capital, rest lowercase
.title()           # Each word first letter capital
.upper()           # All letters uppercase
.lower()           # All letters lowercase
.swapcase()        # Swap uppercase ↔ lowercase

# Alignment
.center(width)     # Centers string with given width
.ljust(width)      # Left align
.rjust(width)      # Right align
.zfill(width)      # Pads with zeros on left

# Searching
.find(sub)         # Returns index of first occurrence
.rfind(sub)        # Returns index of last occurrence
.index(sub)        # Like find(), but error if not found
.count(sub)        # Counts occurrences

# Checking (Boolean results)
.startswith(prefix) 
.endswith(suffix)
.isalpha()         # All letters
.isdigit()         # All digits
.isalnum()         # Letters + digits
.isspace()         # Only whitespace
.islower()         # All lowercase
.isupper()         # All uppercase
.istitle()         # Title case?

# Modifying
.strip()           # Remove spaces (both sides)
.lstrip()          # Remove left spaces
.rstrip()          # Remove right spaces
.replace(old,new)  # Replace substring
.split(sep)        # Split into list
.rsplit(sep)       # Split from right
.splitlines()      # Split by line breaks
.join(iterable)    # Join iterable with string
.partition(sep)    # Split into 3 parts (before, sep, after)

# Encoding/Decoding
.encode()          # Encode string into bytes
.format()          # Format strings
.format_map(dict)  # Format with dictionary
.maketrans()       # Create translation map
.translate(map)    # Apply translation map

Session 2: Git Part 2- Prasanth & Muthuram

What is Git?

Git is a distributed version control system used to track changes in files and coordinate work among multiple people.

Why use Git?

• Tracks every change made to code
• Helps in collaboration with team members
• Allows reverting to previous versions
• Works offline and online
• Ensures code safety

Basic Git Commands:

• git init
• git clone <url>
• git status
• git add <file>
• git add .
• git commit -m “msg”
• git push
• git pull
• git branch
• git checkout <branch>
• git merge <branch>
• git log

# 🔹 1. Stashing (Work in Progress)
git stash                  # Save uncommitted changes
git stash list             # View all stashes
git stash apply            # Re-apply latest stash
git stash pop              # Apply + remove from stash
git stash drop             # Delete a stash

# 🔹 2. Branch Management
git branch -M main         # Rename branch
git branch -d feature-x    # Delete branch
git push origin –delete feature-x   # Delete remote branch
git switch -c hotfix-1     # Create + switch branch

# 🔹 3. Rebase (Clean Commit History)
git rebase main            # Reapply commits on top of main
git rebase -i HEAD~5       # Interactive rebase (squash/reorder commits)
git rebase –abort         # Abort rebase if conflict

# 🔹 4. Cherry Pick (Pick specific commits)
git log –oneline          # Copy commit hash
git cherry-pick <hash>     # Apply specific commit from another branch

# 🔹 5. Amend & Fix Commits
git commit –amend -m “New message”   # Edit last commit message
git commit –amend –no-edit          # Add new changes to last commit

# 🔹 6. Reset vs Revert
git reset –soft HEAD~1    # Undo last commit, keep changes staged
git reset –mixed HEAD~1   # Undo last commit, keep changes unstaged
git reset –hard HEAD~1    # Completely remove last commit
git revert <hash>          # Create new commit that undoes <hash>

# 🔹 7. Tagging (Releases)
git tag v1.0.0             # Lightweight tag
git tag -a v1.0.1 -m “Release v1.0.1”   # Annotated tag
git push origin v1.0.1     # Push tag to remote

# 🔹 8. Logging (Better History View)
git log –oneline –graph –decorate –all
git log –author=”Kowsi”
git log –since=”2 weeks ago”

# 🔹 9. Diff & Blame
git diff HEAD~1 HEAD       # Compare two commits
git diff –staged          # Compare staged vs HEAD
git blame file.py          # Show who changed each line

# 🔹 10. Submodules (Nested Repos)
git submodule add <repo-url>
git submodule update –init –recursive

# 🔹 11. Clean Untracked Files
git clean -n               # Dry run (show untracked files)
git clean -f               # Remove untracked files
git clean -fd              # Remove untracked files + dirs

# 🔹 12. Advanced Push/Pull
git push –force-with-lease   # Safer force push
git pull –rebase             # Avoid unnecessary merge commits

# 🔹 13. Git Config (Customizing)
git config –global alias.st status       # Alias
git config –global alias.lg “log –oneline –graph –decorate”
git config –list                        # Show config

# 🔹 14. Bisect (Find Buggy Commit)
git bisect start
git bisect bad               # Mark current commit as bad
git bisect good <hash>       # Mark older commit as good
# Git auto-checks commits to find where bug was introduced
git bisect reset

# 🔹 15. Hooks (Automation)
# Pre-commit hook example: .git/hooks/pre-commit
#!/bin/sh
echo “Running tests before commit…”
pytest || exit 1

DevSecOps: Ada Lovelace Team & Bob Thomas Team

Session 1:Capture the Flag – Mathusoothanan

Capture the Flag is a game played between two teams, each with a designated territory and a flag placed somewhere within it. The goal is simple but challenging: each team tries to enter the opposing team’s territory, capture their flag, and bring it safely back to their own side without being tagged by opponents.

Basic Rules:

• The field is split into two territories, each with a flag.
• Players try to sneak into the enemy’s side to capture their flag.
• Tagged players go to “jail” and can be freed by teammates.
• The game ends when a flag is successfully brought back or by other conditions like time limit or prisoner count.

Why Play?
It’s a fun, active game that builds teamwork, strategy, and communication.

Session 2: Shell Scripting Part 2 – Loganathan

# Shell Scripting Basics

#!/bin/bash
# Every shell script starts with the shebang above

# 1. Print a message
echo “Welcome to VGLUG Linux Session!”

# 2. Variables and echo
name=”Kowsalya”
echo “Hello, $name!”

# 3. If-else statement
age=18
if [ $age -ge 18 ]; then
    echo “Eligible to vote”
else
    echo “Not eligible”
fi

# 4. For loop
for i in 1 2 3 4 5
do
    echo “Count: $i”
done

# 5. Read user input
echo “Enter your name:”
read user
echo “Hello, $user!”

# 6. Real-life: Quick system check
echo “VGLUG Quick Commands”
date
whoami
pwd

# 7. How to run this script:
# Save as: script.sh
# Run: chmod +x script.sh
# Then: ./script.sh

DevSecOps: Bob Thomas Team

Session 2: Linux Commands: chown and chmod – Loganathan

The chown command is used to change the owner and optionally the group of a file or directory.

# chown — Change owner and group of files/folders

# Change owner to user “alice”
chown alice file.txt

# Change owner to “alice” and group to “staff”
chown alice:staff file.txt

# Change owner and group of a folder and all inside files (recursive)
chown -R alice:staff /foldername

# chmod — Change permissions of files/folders

# Owner: read, write, execute; Group and others: read, execute
chmod 755 script.sh

# Remove write permission for group
chmod g-w file.txt

# Add execute permission for everyone
chmod a+x run.sh

# Change permissions recursively for folder and contents
chmod -R 700 /foldername