Learn Python Coding

Topic: Linked Lists in Python – Part 2: Insertion, Deletion, and Search Operations --- Recap from Part 1 • A singly linked list consists of nodes, where each node holds data and a pointer to the next node. • We've implemented basic append and display functions. Now we’ll explore insertion at specific positions, deletion, and searching. --- 1. Insert at a Specific Position

def insert_at_position(self, index, data):
    if index < 0:
        raise IndexError("Index cannot be negative")
    
    new_node = Node(data)
    
    if index == 0:
        new_node.next = self.head
        self.head = new_node
        return

    current = self.head
    for _ in range(index - 1):
        if not current:
            raise IndexError("Index out of bounds")
        current = current.next
    
    new_node.next = current.next
    current.next = new_node

--- 2. Delete a Node by Value

def delete_by_value(self, value):
    if not self.head:
        return

    if self.head.data == value:
        self.head = self.head.next
        return

    current = self.head
    while current.next and current.next.data != value:
        current = current.next

    if current.next:
        current.next = current.next.next

--- 3. Delete a Node by Index

def delete_by_index(self, index):
    if index < 0:
        raise IndexError("Index cannot be negative")

    if not self.head:
        raise IndexError("List is empty")

    if index == 0:
        self.head = self.head.next
        return

    current = self.head
    for _ in range(index - 1):
        if not current.next:
            raise IndexError("Index out of bounds")
        current = current.next

    if current.next:
        current.next = current.next.next

--- 4. Search for an Element

def search(self, value):
    current = self.head
    index = 0
    while current:
        if current.data == value:
            return index
        current = current.next
        index += 1
    return -1  # Not found

--- 5. Complete Class with All Methods

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data): ...
    def display(self): ...
    def insert_at_position(self, index, data): ...
    def delete_by_value(self, value): ...
    def delete_by_index(self, index): ...
    def search(self, value): ...

*(You can reuse the method definitions above.)* --- Summary • You can manipulate linked lists with insertions and deletions at any position. • Searching through a singly linked list is O(n). • Always check for edge cases: empty list, index bounds, and duplicates. --- Exercise • Write a method reverse() that reverses the linked list in-place and test it on a list of 5+ elements. --- #DSA #LinkedList #Python #Insertion #Deletion #Search https://t.me/DataScience4

Topic: Linked Lists in Python – Part 1: Introduction and Singly Linked List Basics --- What is a Linked List? • A linked list is a linear data structure where each element (called a node) contains: • The data value. • A pointer (or reference) to the next node. • Unlike arrays, linked lists don’t require contiguous memory and can grow dynamically. --- Why Use Linked Lists? • Efficient insertions/deletions at the beginning or middle. • No need for pre-defining size, unlike arrays. • Used in memory-efficient applications like OS kernels, compilers, and real-time systems. --- Types of Linked Lists • Singly Linked List – Each node points to the next. • Doubly Linked List – Nodes have next and previous pointers. • Circular Linked List – The last node points back to the head. --- Basic Structure of a Node

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

--- Building a Singly Linked List

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)

        if not self.head:
            self.head = new_node
            return

        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

--- Traversing the List

def display(self):
    current = self.head
    while current:
        print(current.data, end=" -> ")
        current = current.next
    print("None")

Usage:

ll = LinkedList()
ll.append(10)
ll.append(20)
ll.append(30)
ll.display()  # Output: 10 -> 20 -> 30 -> None

--- Inserting at the Beginning

def insert_at_beginning(self, data):
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node

--- Summary • A singly linked list stores data as a sequence of nodes linked by references. • Supports dynamic memory usage, fast insertions, and flexible resizing. • The key is managing node connections safely and efficiently. --- Exercise • Implement a method length() that returns the number of nodes in the list. --- #DataStructures #LinkedList #DSA #Python #CodingBasics https://t.me/DataScience4

Topic: Django ORM – Transactions, Subqueries, and Custom Managers (Part 3) --- 1. Working with Transactions • Django supports atomic transactions to ensure database integrity — either all operations succeed, or none do.

from django.db import transaction

@transaction.atomic
def create_author_and_book():
    author = Author.objects.create(name="New Author")
    Book.objects.create(title="New Book", author=author)

• Use atomic() as a decorator or context manager.

with transaction.atomic():
    # multiple operations that must succeed together
    ...

--- 2. Subqueries and OuterRef • Use Subquery and OuterRef to perform queries that depend on other queries.

from django.db.models import Subquery, OuterRef

# Get latest book for each author
latest_books = Book.objects.filter(author=OuterRef('pk')).order_by('-published_date')
authors = Author.objects.annotate(latest_book=Subquery(latest_books.values('title')[:1]))

--- 3. Exists() and Conditional Logic • Use Exists for optimized existence checks.

from django.db.models import Exists

recent_books = Book.objects.filter(published_date__year=2023)
authors = Author.objects.annotate(has_recent_books=Exists(recent_books.filter(author=OuterRef('pk'))))

--- 4. Custom Model Managers • Add custom query logic to models via custom managers.

from django.db import models

class PublishedBookManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_published=True)

class Book(models.Model):
    title = models.CharField(max_length=200)
    is_published = models.BooleanField(default=False)

    objects = models.Manager()  # Default manager
    published = PublishedBookManager()  # Custom manager

# Usage
Book.published.all()

--- 5. QuerySet Methods: Update, Delete, Bulk Operations • update() modifies multiple records efficiently.

Book.objects.filter(author__name="Alice").update(pages=300)

• delete() removes objects in bulk.

Book.objects.filter(published_date__year__lt=2000).delete()

• bulk\_create() inserts many records at once.

Book.objects.bulk_create([
    Book(title="Book A", author=author),
    Book(title="Book B", author=author),
])

--- 6. Using Database Functions • Django provides built-in SQL functions like Lower, Upper, Length, Concat, etc.

from django.db.models.functions import Upper

books = Book.objects.annotate(upper_title=Upper('title'))

--- Summary • Use transactions to maintain data integrity. • Leverage subqueries, OuterRef, and Exists for complex logic. • Create custom managers to encapsulate reusable query logic. • Apply bulk operations and DB functions for performance and flexibility. --- Exercise • Create a custom manager for the Book model to return only books published in the last 5 years. Then use this manager in a view to list all recent books along with their authors. --- #Django #ORM #Transactions #Subqueries #CustomManagers #AdvancedDjango https://t.me/DataScience4

Topic: Django ORM – Advanced Queries, Aggregations, and Query Optimization (Part 2) --- 1. Aggregation Functions • Django provides built-in functions for aggregating data.

from django.db.models import Avg, Sum, Max, Min, Count

# Average number of pages
avg_pages = Book.objects.aggregate(Avg("pages"))

# Total number of pages
total_pages = Book.objects.aggregate(Sum("pages"))

# Count of books per author
book_counts = Book.objects.values("author").annotate(total=Count("id"))

--- 2. Grouping and Annotating • annotate() is used to compute values for each row (e.g., totals per group).

# Number of books per author
from django.db.models import Count

authors = Author.objects.annotate(book_count=Count("book"))
for author in authors:
    print(author.name, author.book_count)

--- 3. Complex Lookups with Q Objects • Use Q for OR, AND, and NOT conditions.

from django.db.models import Q

# Books with title containing 'war' OR author name 'Leo Tolstoy'
books = Book.objects.filter(Q(title__icontains="war") | Q(author__name="Leo Tolstoy"))

# Books not published in 2023
books = Book.objects.filter(~Q(published_date__year=2023))

--- 4. Selecting Specific Fields • Use values() or values\_list() to retrieve specific fields.

# Dictionary of titles and authors
data = Book.objects.values("title", "author__name")

# List of titles
titles = Book.objects.values_list("title", flat=True)

--- 5. Related Model Queries • Use select\_related and prefetch\_related to optimize related data access.

# Optimized: Single JOIN query for ForeignKey
books = Book.objects.select_related("author")

# For ManyToMany or reverse relations
authors = Author.objects.prefetch_related("book_set")

--- 6. Raw SQL Queries (When Necessary)

books = Book.objects.raw("SELECT * FROM myapp_book WHERE pages > %s", [300])
for book in books:
    print(book.title)

--- 7. Performance Tips • Use only() or defer() to limit retrieved fields.

books = Book.objects.only("title")

• Avoid chaining queries in loops. • Use bulk\_create, bulk\_update for inserting/updating many records. --- Summary • Use aggregate(), annotate(), and Q objects for powerful filtering. • Fetch only what you need using values, only, and select\_related. • Optimize queries by reducing database hits and using Django’s ORM efficiently. --- Exercise • Write a Django query that returns all authors with more than 5 books, sorted by the number of books (descending). Then print their name and book count. --- #Django #ORM #AdvancedQueries #QueryOptimization #WebDevelopment https://t.me/DataScience4

Topic: Django Models and ORM — From Basics to Advanced Queries --- What is a Model in Django? • A model in Django is a Python class that defines the structure of your database table. Each model maps to a table, and each attribute represents a column. • Django uses its ORM (Object-Relational Mapping) to interact with the database using Python code instead of SQL. --- Creating Your First Model

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    pages = models.IntegerField()

--- Making Migrations • Create and apply migrations to sync models with the database:

python manage.py makemigrations
python manage.py migrate

--- Using the Model

# Creating a new record
book = Book(title="1984", author="George Orwell", published_date="1949-06-08", pages=328)
book.save()

# Fetching all books
books = Book.objects.all()

# Filtering
orwell_books = Book.objects.filter(author="George Orwell")

# Getting one object
book = Book.objects.get(id=1)

# Updating
book.title = "Animal Farm"
book.save()

# Deleting
book.delete()

--- Model Field Types • CharField, TextField, IntegerField, FloatField, DateField, DateTimeField, BooleanField, EmailField, and more. --- Meta Class for Model Options

class Book(models.Model):
    title = models.CharField(max_length=200)

    class Meta:
        ordering = ['title']  # default ordering by title

--- Relationships Between Models • One-to-Many (ForeignKey) • Many-to-Many (ManyToManyField) • One-to-One (OneToOneField)

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

--- Advanced ORM Queries

# Complex filters
books = Book.objects.filter(published_date__year__gte=2000, pages__lte=300)

# Exclude
books = Book.objects.exclude(author="J.K. Rowling")

# Ordering
books = Book.objects.order_by("-published_date")

# Count
total = Book.objects.count()

--- Summary • Django models define your database structure. • The ORM allows you to query and manipulate data using Python. • Supports relationships, complex filtering, ordering, and aggregation. --- Exercise • Create two models: Author and Book. Link them using a foreign key. Then, write views that: 1. Add a new book. 2. List all books by a specific author. 3. Delete books published before the year 2000. --- #Django #WebDevelopment #ORM #DatabaseModels #DjangoTips https://t.me/DataScience4

Topic: Python File Handling — Reading, Writing, and Managing Files (Beginner to Advanced) --- What is File Handling? • File handling allows Python programs to read from and write to external files — such as .txt, .csv, .json, etc. • Python uses built-in functions like open(), read(), and write() to interact with files. --- Opening a File

file = open("example.txt", "r")  # "r" = read mode
content = file.read()
file.close()

--- Using with Statement (Best Practice) • Automatically handles file closing:

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

--- File Modes • "r" — read (default) • "w" — write (creates or overwrites) • "a" — append (adds to the end) • "x" — create (fails if file exists) • "b" — binary mode • "t" — text mode (default) --- Writing to Files

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

• Note: "w" overwrites existing content. --- Appending to Files

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

--- Reading Line by Line

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

--- Working with File Paths • Use os.path or pathlib for platform-independent paths.

from pathlib import Path

file_path = Path("folder") / "file.txt"
with open(file_path, "r") as f:
    print(f.read())

--- Advanced Tip: Reading and Writing CSV Files

import csv

with open("data.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["name", "age"])
    writer.writerow(["Alice", 30])

with open("data.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

--- Summary • Use open() with correct mode to read/write files. • Prefer with statement to manage files safely. • Use libraries like csv, json, or pickle for structured data. • Always handle exceptions like FileNotFoundError for robust file operations. --- Exercise • Write a Python program that reads a list of names from names.txt, sorts them alphabetically, and saves the result in sorted_names.txt. --- #Python #FileHandling #ReadWrite #DataProcessing #ProgrammingTips https://t.me/DataScience4

⚠ Message was hidden by channel owner

Topic: Understanding Recursion — A Key Programming Concept --- What is Recursion? • Recursion occurs when a function calls itself to solve smaller instances of the same problem. --- Basic Structure of a Recursive Function • Must have a base case to stop the recursion. • Must reduce the problem size with each recursive call. --- Example: Factorial Calculation

def factorial(n):
    if n == 0:
        return 1  # base case
    else:
        return n * factorial(n - 1)  # recursive call

--- How It Works • For factorial(3): * Calls factorial(2) * Then factorial(1) * Then factorial(0), which returns 1 * Then multiplies back up: 1 \* 1 = 1, 2 \* 1 = 2, 3 \* 2 = 6 --- Advantages • Simplifies code for problems naturally defined by smaller subproblems (e.g., tree traversal, divide and conquer). --- Disadvantages • Can lead to large call stacks and possible stack overflow if not designed carefully. • Sometimes less efficient than iterative solutions. --- Tail Recursion • A special kind of recursion where the recursive call is the last operation. • Some languages optimize tail recursion, but Python does not. --- Summary • Use recursion for problems with repetitive sub-structure. • Always define a base case to avoid infinite recursion. • Consider performance and stack depth limits. --- \#Algorithms #Recursion #ProgrammingLogic #CodingTips #ProblemSolving [https://t.me/DataScience4](https://t.me/DataScience4)

Topic: Python List vs Tuple — Differences and Use Cases --- Key Differences • Lists are mutable — you can change, add, or remove elements. • Tuples are immutable — once created, they cannot be changed. --- Creating Lists and Tuples

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

--- When to Use Each • Use lists when you need a collection that can change over time. • Use tuples when the collection should remain constant, providing safer and faster data handling. --- Common Tuple Uses • Returning multiple values from a function.

def get_coordinates():
    return (10, 20)

x, y = get_coordinates()

• Using as keys in dictionaries (since tuples are hashable, lists are not). --- Converting Between Lists and Tuples

list_to_tuple = tuple(my_list)
tuple_to_list = list(my_tuple)

--- Performance Considerations • Tuples are slightly faster than lists due to immutability. --- Summary • Lists: mutable, dynamic collections. • Tuples: immutable, fixed collections. • Choose based on whether data should change or stay constant. --- \#Python #Lists #Tuples #DataStructures #ProgrammingTips https://t.me/DataScience4

Topic: Python Exception Handling — Managing Errors Gracefully --- Why Handle Exceptions? • To prevent your program from crashing unexpectedly. • To provide meaningful error messages or recovery actions. --- Basic Try-Except Block

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

--- Catching Multiple Exceptions

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except (ValueError, ZeroDivisionError) as e:
    print(f"Error occurred: {e}")

--- Using Else and Finally • else block runs if no exceptions occur. • finally block always runs, used for cleanup.

try:
    file = open("data.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found.")
else:
    print("File read successfully.")
finally:
    file.close()

--- Raising Exceptions • You can raise exceptions manually using raise.

def check_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")

check_age(-1)

--- Custom Exceptions • Create your own exception classes by inheriting from Exception.

class MyError(Exception):
    pass

def do_something():
    raise MyError("Something went wrong!")

try:
    do_something()
except MyError as e:
    print(e)

--- Summary • Use try-except to catch and handle errors. • Use else and finally for additional control. • Raise exceptions to signal errors. • Define custom exceptions for specific needs. --- #Python #ExceptionHandling #Errors #Debugging #ProgrammingTips

Topic: Python Classes and Objects — Basics of Object-Oriented Programming Python supports object-oriented programming (OOP), allowing you to model real-world entities using classes and objects. --- Defining a Class

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

--- Creating Objects

person1 = Person("Alice", 30)
person1.greet()  # Output: Hello, my name is Alice and I am 30 years old.

--- Key Concepts • Class: Blueprint for creating objects. • Object: Instance of a class. • `__init__` method: Constructor that initializes object attributes. • `self` parameter: Refers to the current object instance. --- Adding Methods

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.1416 * self.radius ** 2

circle = Circle(5)
print(circle.area())  # Output: 78.54

--- **Inheritance** • Allows a class to inherit attributes and methods from another class.

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Woof!")

dog = Dog()
dog.speak()  # Output: Woof!

--- Summary • Classes and objects are core to Python OOP. • Use `class` keyword to define classes. • Initialize attributes with `__init__` method. • Objects are instances of classes. • Inheritance enables code reuse and polymorphism. --- #Python #OOP #Classes #Objects #ProgrammingConcepts

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

🔰 Convert Images to PDF using Python

This channels is for Programmers, Coders, Software Engineers. 0️⃣ Python 1️⃣ Data Science 2️⃣ Machine Learning 3️⃣ Data Visualization 4️⃣ Artificial Intelligence 5️⃣ Data Analysis 6️⃣ Statistics 7️⃣ Deep Learning 8️⃣ programming Languages ✅ https://t.me/addlist/8_rRW2scgfRhOTc0 ✅ https://t.me/Codeprogrammer

Important Python Functions

🐍 Tip of the day for experienced Python developers 📌 Use decorators with parameters — a powerful technique for logging, control, caching, and custom checks. Example: a logger that can set the logging level with an argument:

import functools
import logging

def log(level=logging.INFO):
   def decorator(func):
       @functools.wraps(func)
       def wrapper(*args, **kwargs):
           logging.log(level, f"Call {func.__name__} with args={args}, kwargs={kwargs}")
           return func(*args, **kwargs)
       return wrapper
   return decorator

@log(logging. DEBUG)
def compute(x, y):
   return x + y

✅ Why you need it: The decorator is flexibly adjustable; Suitable for prod tracing and debugging in maiden; Retains the signature and docstring thanks to @functools.wraps. ⚠️ Tip: avoid nesting >2 levels and always write tests for decorator behavior. Python gives you tools that look like magic, but work stably if you know how to use them.