Coder Legion - Recent posts tagged advanced-python

ThreeDimensions Version-1.0.0 is here !

Sun, 08 Mar 2026 05:38:07 +0000

ThreeDimensions

Version-1.0.0 Repo - https://github.com/LegedsDaD/ThreeDimensions-v1.1.1

ThreeDimensions is a programmable 3D modeling library for Python, backed by a C++ geometry kernel for heavy mesh operations.

Do check out Main Repository

Send your creations using ThreeDimensions in Models by filling in the Form. The best models will be added to the examples of ThreeDimensions. Others will be added to the models groups. See current submissions in Submissions. Do participate !

Version: 1.0.0

Overview

Python-first API (import threedimensions as td)
C++ core for mesh math/topology/modifiers when available
Pure-Python fallback so the package remains usable without compiling native code
Half-edge/topology-oriented editing workflow with sculpt, modifiers, curves, nodes, UV tools, and export

Feature Highlights

Transform system: move/rotate/scale, pivot modes, snapping, mirror transform, proportional falloff
Selection: vertex/edge/face, loop/ring, box/circle/lasso, select similar
Editing: extrude, inset, bevel, bridge, fill, grid fill, subdivide, loop cut, spin, screw, solidify, wireframe
Deformation: bend, twist, taper, stretch, shear, warp
Symmetry: mirror and symmetrize helpers
Sculpt: draw/clay/inflate/smooth/grab/pinch/crease/mask style brush workflow + filters
Remesh/reduction: voxel remesh, quad remesh, decimate
Primitives: cube, sphere, UV sphere, icosphere, cylinder, cone, torus, plane, grid
Curves: Bezier, NURBS-style fallback, lathe, curve-to-mesh
UV: unwrap, smart UV project, project from view, seams
Retopo helpers: shrinkwrap, poly build, relax topology
Modifier stack: subdivision, mirror, array, solidify, boolean, decimate, lattice
Procedural NodeGraph API
Optional OpenGL viewer (td.viewer(mesh) or with td.viewer() as scene)

Installation

pip install pip install threedimensions==1.1.1

Optional viewer dependencies:

pip install glfw PyOpenGL

Quick Start

import threedimensions as td

mesh = td.create_cube(1.0)
mesh.extrude(distance=0.2)
mesh.bevel(width=0.05)
mesh.subdivide(1)
mesh.save("model.obj")

Geometry Nodes (Programmable)

import threedimensions as td

graph = td.NodeGraph()
cube = graph.node("Cube", size=1.0)
subdiv = graph.node("Subdivision", levels=2)
extrude = graph.node("Extrude", distance=0.25)

graph.connect(cube, subdiv)
graph.connect(subdiv, extrude)

mesh = graph.evaluate()
mesh.save("graph.obj")

Viewer

import threedimensions as td

mesh = td.create_torus()
td.viewer(mesh)  # blocking preview

with td.viewer() as scene:
    scene.update(mesh)
    scene.run()

Architecture

python/threedimensions/: high-level Python API wrappers, fallback implementations, procedural nodes, viewer

License

MIT

Python: An Expert-Level Deep Dive into Design, Internals, and Ecosystem

Wed, 11 Feb 2026 11:51:15 +0000

Python: An Expert-Level Deep Dive into Design, Internals, and Ecosystem

1. Introduction

Python is a high-level, interpreted, dynamically typed programming language known for its readability and expressive power. Created by Guido van Rossum in 1991, Python has evolved from a scripting language into one of the most dominant technologies in:

Artificial Intelligence & Machine Learning
Data Science
Web Development
Automation
Cybersecurity
DevOps
Scientific Computing

Python’s philosophy emphasizes simplicity, clarity, and developer productivity, while its ecosystem supports enterprise-scale systems.

2. Philosophy and Design Principles

Python’s design is guided by the Zen of Python (import this):

"Simple is better than complex."
"Readability counts."
"There should be one—and preferably only one—obvious way to do it."

Core Design Features

Dynamic typing
Automatic memory management
Interpreted execution
High-level data structures
Extensive standard library
Multi-paradigm support (OOP, functional, procedural)

3. Python Architecture and Execution Model

3.1 CPython Implementation

The reference implementation of Python is CPython, written in C.

Execution flow:

Source Code (.py)
        ↓
Bytecode Compilation (.pyc)
        ↓
Python Virtual Machine (PVM)
        ↓
Execution

Python compiles source code into bytecode
Bytecode is executed by the Python Virtual Machine
This abstraction ensures portability

3.2 Global Interpreter Lock (GIL)

The GIL ensures that only one thread executes Python bytecode at a time.

Implications:

CPU-bound threading is limited
I/O-bound threading performs well
Multiprocessing is preferred for parallel CPU tasks

Example:

from multiprocessing import Process

def task():
    print("Running in parallel")

if __name__ == "__main__":
    p = Process(target=task)
    p.start()
    p.join()

4. Data Model and Object System

Everything in Python is an object, including:

Functions
Classes
Modules
Integers

4.1 Object Structure (Simplified)

Each Python object contains:

Reference count
Type information
Value

Example:

a = 10
b = a

Both a and b reference the same object until reassignment.

5. Advanced Data Structures

5.1 Built-in Collections

list
tuple
set
dict

5.2 Time Complexity (Average)

Operation	List	Dict	Set
Lookup	O(n)	O(1)	O(1)
Insert	O(1)	O(1)	O(1)
Delete	O(n)	O(1)	O(1)

5.3 Comprehensions

squares = [x*x for x in range(10)]

Set and dictionary comprehensions:

unique = {x for x in range(10)}
mapping = {x: x*x for x in range(5)}

6. Functions as First-Class Objects

Functions can:

Be assigned to variables
Be passed as arguments
Return other functions

Example:

def decorator(func):
    def wrapper():
        print("Before execution")
        func()
        print("After execution")
    return wrapper

7. Decorators and Metaprogramming

7.1 Decorators

@decorator
def greet():
    print("Hello")

7.2 Metaclasses

Metaclasses control class creation.

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs['id'] = 123
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

print(MyClass.id)

8. Concurrency and Asynchronous Programming

8.1 Threading vs Multiprocessing

Threading → I/O-bound tasks
Multiprocessing → CPU-bound tasks

8.2 Asyncio

Python supports asynchronous programming with async and await.

import asyncio

async def main():
    await asyncio.sleep(1)
    print("Async execution")

asyncio.run(main())

9. Memory Management

Python uses:

Reference counting
Generational garbage collection

You can inspect reference counts:

import sys
a = []
print(sys.getrefcount(a))

10. Type Hinting and Static Analysis

Python supports gradual typing.

def add(a: int, b: int) -> int:
    return a + b

Tools:

mypy
pyright
pylance

Type hints improve maintainability in large systems.

11. C Extensions and Performance Optimization

11.1 Using C with Python

CPython API
Cython
ctypes
cffi

11.2 Performance Techniques

Use built-in functions
Prefer generators
Use NumPy for numerical tasks
Avoid unnecessary object creation

Example generator:

def count():
    n = 0
    while True:
        yield n
        n += 1

12. Python in Large-Scale Systems

Python powers:

Instagram (Django)
YouTube backend
Netflix automation systems
OpenAI research tools

Popular Frameworks

Domain	Framework
Web	Django, Flask, FastAPI
Data Science	Pandas, NumPy
ML	TensorFlow, PyTorch
Automation	Selenium
CLI Tools	Click, Typer

13. Packaging and Dependency Management

Modern tools:

pip
venv
poetry
pipenv

Example:

python -m venv env
source env/bin/activate
pip install requests

14. Testing and Quality Assurance

Testing frameworks:

unittest
pytest
hypothesis

Example:

def test_add():
    assert add(2, 3) == 5

15. Security Considerations

Avoid eval() on untrusted input
Use virtual environments
Keep dependencies updated
Use secure hashing (hashlib, bcrypt)

16. The Future of Python

Ongoing improvements:

Performance optimizations in Python 3.12+
Better concurrency models
Static typing improvements
Faster CPython interpreter

17. Conclusion

Python is not merely a scripting language — it is a general-purpose, high-performance, multi-paradigm ecosystem capable of powering:

Enterprise backends
AI systems
Robotics
Embedded applications
Scientific simulations

Its simplicity lowers entry barriers, while its extensibility allows expert-level system design.

Python succeeds because it optimizes for what matters most:

Developer productivity + Ecosystem power + Readability + Scalability

Always Five Trick → Class always returns 5 no matter what when you use len().

Thu, 02 Oct 2025 15:38:12 +0000

class AlwaysFive:
    def __len__(self):
        return 5

a = AlwaysFive()
print(len(a))  # Always prints 5

SignBrige: Hands speak. We translate

Sun, 22 Jun 2025 03:24:43 +0000

Communication is a basic human right, yet millions of people in the deaf and hard-of-hearing community face barriers every day—especially in virtual spaces, education, and public services.

As a passionate developer and advocate for inclusive technology, I created SignBridge, an AI-powered system designed to bridge this gap by translating American Sign Language (ASL) into spoken language and vice versa in real time. What began as a local prototype has now grown into a complete solution that can be integrated into modern communication tools like Zoom, Google Meet, or Microsoft Teams—making digital conversations truly accessible.

SignBridge uses a dual-frame video interface:

Frame 1 (Special User): Detects ASL signs using OpenCV and MediaPipe for real-time hand tracking and gesture recognition. The system interprets signs (letters, numbers, phrases) and displays the translated message in the other user's frame.

Frame 2 (Normal User): Uses speech recognition to convert spoken language into text, and then displays a corresponding ASL image or animation so the deaf/hard-of-hearing user can understand the message visually.

All of this is powered by a deep learning model trained on a public Kaggle ASL dataset, which ensures recognition of the full ASL alphabet, common numbers, and key phrases.

Key Features

Real-time ASL hand sign detection using MediaPipe + OpenCV

Voice-to-ASL image translation using speech recognition

ASL alphabet, numbers, and basic phrase recognition

Dual-frame interface for bidirectional communication

Backend REST API to power web and mobile platforms

Future support for integration with Zoom, Meet, and Teams

Cross-platform design: currently building a web app and mobile app

Checkout the Landing Page
See a demo

Screenshots / Demos

Get Involved
Want to help make communication more inclusive? Here's how you can contribute:

Test the beta version on web or mobile (coming soon)

Suggest improvements or new features (e.g., gesture training, multilingual support)

Raise awareness about accessibility in tech

Feel free to reach out if you're interested in collaboration, testing, or integration ideas.

Advanced Python Concepts - Metaprogramming

Thu, 10 Oct 2024 20:40:24 +0000

Imagine writing a Python code that can modify itself or dynamically generate new code based on the real-time data input. Metaprogramming is a powerful and advanced technique of programming that allows developers to write code that can manipulate other code and generate new code during runtime. Like we say, metadata is data of data, and metaprogramming is also about writing code that manipulates code. Therefore, this article discusses metaprogramming capabilities to enhance code efficiency and flexibility. We will learn about its foundation, decorators, metaclasses, and dynamic code execution by providing practical examples of each concept. Let's get started!

Understanding Metaprogramming

1. Metaprogramming And Its Role In Python

In Python, metaprogramming is about writing computer programs that will assist in writing and manipulating other programs. This technique allows programs to treat other programs as data. It generates the code, modifies the existing code, and creates a new programming construct at runtime.

2. Metaprogramming And Regular Programming

Before moving on to the technical aspects of metaprogramming concepts, let us first see how generic or regular programming that is based on procedural steps differs from advanced programming concept.

3. Benefits And Risks Of Using Metaprogramming

Metaprogramming provides us with a range of benefits. Let's explore them to understand their advantage in the development process.

Metaprogramming reduces development time by allowing programs to modify themselves at runtime. This technique enables developers to write less code, making the overall development process more efficient compared to traditional software development methods.
It provides solutions to code repetition and reduces the coding time. As we know, metaprogramming is all about reducing the code from the developer end and creating an automated way of generating code at run time.
The programs adapt their behavior dynamically at runtime in response to certain conditions and input data. This makes the software program more powerful and flexible.

Similar to the benefits, metaprogramming also comes with some drawbacks as well, which the developer keeps in mind before using this technique.

One risk of metaprogramming is its complicated syntax.
As the code is generated dynamically at runtime, there comes the issue of invisible bugs. The bugs come from the generated code, which is challenging to track and resolve. Sometimes, it becomes difficult to find the source and cause of the bug.
The execution of the computer program takes longer than usual because Python executes the new metaprogramming code at run time.

Metaclasses: The Foundation Of Metaprogramming

1. Metaclasses A Mechanism For Creating Classes Dynamically

A metaclass defines the behavior and structure of classes. Using metaclasses in Python, you can easily customize class creation and behavior. This is possible because Python represents everything, including the classes, as an object. Moreover, the object is created using the class. Therefore, this supposed "class" is act as a child class of another class that is metaclass a super class. In addition, all Python classes are child classes of metaclasses.

Note: Type is the default metaclass in python. It is used to create classes dynamically.

2. Metaclass ‘new’ And ‘init’ Methods

In Python, metaclasses are by default "type" class i.e. base class which is used to manage the creation and behavior of classes. Upon creating the class in Python, we indirectly used the "type" class. The metaclass consists of two primary methods: __new__ and __init__. The __new__ method is used for creating a new object. This method creates and returns the instance, which is then passed to the __init__ method for initialization. It is called before the __init__ method and assures the control creation of the class itself. Then, the __init__ method is used after the creation of new class to initialized it with furthur attribute and methods. This method is quite different from the regular programming method. It allows us to modify and set the class-level attributes after class creation.

Tip: __new__ and __init__ methods are used for creating the custom classes and its behavior

3. Example: Creating Custom Metaclasses To Customize Class Creation Behavior

Let's understand with a simple python example how we can create custom metaclasses to customize the class creation and its behavior using the metaclass primary methods __new__ and __init__.

# Define the metaclass
class Meta(type):
    #define the new method for creating the class instance
    #cls: metaclass whose instance is being created
    #name: name of the class #base: means the base class
    #class_dict: represent the dictionary of attributes for a class
    def __new__(cls, name, bases, attrs):
        #making the attributes(method) name as upper case
        uppercase_attrs = {key.upper(): value for key, value in attrs.items() if not key.startswith('__')}
        new_class = super().__new__(cls, name, bases, uppercase_attrs)
        print("Class {name} has been created with Meta")
        return new_class
    
    #the class is initialized
    def __init__(cls, name, bases, dct):
        super().__init__(name, bases, dct)
        print(f"Class {name} initilized with Meta")
    
# Using the metaclass in a new class
class MyClass(metaclass=Meta):    
    def my_method(self):
        print(f"Hello!")

# Instantiate MyClass and access its custom attribute
obj = MyClass()
#here the attribute of the class is change into uppercase i.e. the name of method
obj.MY_METHOD()

Output

Note: Remember that in the output, the "Hello" string will not be converted into uppercase, but the method name 'my_method' as 'MY_METHOD' that will print the string. This means that we are converting the name of the method into uppercase.

Decorators: Metaprogramming At The Function Level

1. Decorators As Functions That Modify The Behavior Of Other Functions

Decorators are the key features of Python metaprogramming. Decorators are a powerful feature that allows developers to modify existing code without changing the original source code. It allows you to add new functionality by extending the existing function. Decorators are typically performed on functions, and their syntax uses the “@” symbol with the decorator function name before its code. In Python, decorators act as a wrapper around other functions and classes. The input and output of the decorator are the function itself, typically executing functionality before and after the original function.

2. Syntax Of Decorators

Decorators use the @decorator_name as a syntax. Whereas the decorator_name is the name of the function that you make as a decorator.

@decorator_name 
def function_name():

The syntax is also used as following, which shows the decorator taking a function as an argument and save the result into another function.

Function_name = decorator_name(function_name)

3. Illustration of creating and using decorators to add functionality to functions

Below is an example of using decorators to convert the string of one function into uppercase, which means adding the uppercase functionality to the function:

#function for converting the string into upercase
def my_decorator(function): 
    #function within a function
    def wrapper(): 
        #here, we call the decorator function inside this function
        func = function() 
        #converting the string
        upper_Case = func.upper() 
        return upper_Case
    return wrapper
    
@my_decorator
def get_String(): #getting the string for converting in upper case
    return "Actions speak louder than words"
print(get_String()) #printing the string

Output

The 'inspect' Module: Introspection And Reflection

1. Introduction To The `Inspect` Module For Introspection And Reflection

In the metaprogramming world, inspection and reflection are key terms. Inspection is performed to examine the type and property of an object in a program and provide a report on it at runtime. In contrast, reflection involves modifying the structure and behavior of an object at runtime. These two language features make python a strongly typed dynamic language. We can perform inspection and reflection in metaprogramming using the "inspect" module. This module provides various functions for introspection, including information about the type and property of an object, the source code, and the call stack.

2. How To Use The 'inspect' Module To Examine And Modify Objects At Runtime

Let's understand that using the "inspect" module for introspection and reflection combined with other Python features, we can examine and modify the object at run time in metaprogramming. We will learn it step by step:

1. Examine The Object Using "inspect" Module

#import inspect module
import inspect

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and Age is {self.age}"

person = Person("Harry", 26)

# Get the class of the object
print("Class of obj:", inspect.getmembers(person.__class__))

# Retrieve all members of the object
print("Members of obj:", inspect.getmembers(person))

#Print the source code
print("Source code of MyClass:")
print(inspect.getsource(Person))

#Print the documentation string
print("Docstring of MyClass:", inspect.getdoc(Person))

Output

2. Modifying The Object At Runtime

#import inspect module
import inspect
import types

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and Age is {self.age}"

person = Person("Harry", 26)

# Add a new attribute
setattr(person, 'new_attribute', 42)
print("New attribute value:", person.new_attribute)

# Modify an existing attribute
setattr(person, 'name', "Henry")
print("Modified name:", person.name)

# Add a new method dynamically
def myfunc(self):
    print("My age is {self.age}")

setattr(Person, 'myfunc', myfunc)  # Attach the method to the class

# Call the new method
print("New method output:")
person.myfunc()

Output

This is how you can examine and perform modification dynamically at run time. Using the inspect module combined with Python's built-in functions like setattr and delattr will allow the developer to write flexible and adaptive that can change at runtime.

Tip: Both setattr and delattr are Python functions for dynamically changing object attributes. In these functions, setattr is used to set and alter the attribute, and delattr is used to delete the attribute from an object.

3. Practical Use Cases For Introspection And Reflection

Debugging And Code Analysis

As we know, debugging is quite more hectic and time-consuming than writing the code the first time. Developers debug the code to verify and find the sources of defects to handle them at the early stages. However, it is a very heterogeneous process when we cannot identify its source. Therefore, introspection and reflection are very useful for debugging the code. It examines the object dynamically at run time by providing the details of the object’s nature, including its behavior. It provides the details of object attribute values and unexpected values and explains how the state of the object changes over time. To make this clearer, let's use an example.

#import inspect module
import inspect

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and I am {self.age} years old."

person = Person("Harry", 26)

# inspecting attribute
print("Object Attribute:", dir(person))
print("Value of Attribute:", person.name, person.age)

#Add new attribute for debugging
setattr(person, 'debug_info', "Henry")
#print debug info like this
print("Debug Info", person.debug_info)

Output

Wrapping Up

To sum up, we discussed the Python advanced concept, which is metaprogramming. As we know, metaprogramming is the techniques that extend and modify the behavior of the Python language itself. It can help you write functions that can modify and generate other functions.. We can perform metaprogramming using different approaches like metaclasses allows us to use the default type class and then the decorator, which acts as the wrapper to another function and shifts towards the techniques to debug the code beforehand. So, wherever you are moving towards Python advanced concepts, do not forget to learn about metaprogramming significance as well. I hope this guide is helpful to you. Thank you for reading. Happy coding!

Additional Reference

Python Inspect Module
MetaClasses in Python
Decorators

Advanced Python Concepts - Networking with Python

Tue, 08 Oct 2024 09:41:30 +0000

Have you ever wondered how your device is connected over the Internet? Or how the business manages to share information across regions seamlessly? All this is achieved using computer networks as part of the business strategy. It allows us to establish communication, collaborate, and share resources among different applications and devices in the network over the Internet. Now, you can contact or share things with your friends or anyone with just one click, thanks to the integration of networking with software applications, and various other technologies. In Python, networking is a fundamental concept that enables the interaction between devices and external resources. Python includes many built-in modules that support networking capabilities, such as `socket` for general networking and `requests` for HTTP communication.
Therefore, in this article, we will discuss networking from its basic concepts to advanced concepts in Python using practical examples.

Introduction to Networking Concepts

1. Networking and Its Significance In Distributed Systems

Networking involves connecting multiple computers and devices via wired cables or wireless networks to exchange data and share resources over the Internet. It allows communication between multiple devices. As we know, distributed systems are those in which large numbers of clients, hardware devices, and processes are connected to share resources and communicate. Therefore, networking and distributed systems are significantly interconnected. They provide the infrastructure that facilitates storage, resource sharing, and electronic communication to enhance the efficiency and productivity of the system.

2. Key Networking Concepts

Some key networking concepts that we use in our day-to-day lives are as follows:

2.1. IP Address

An IP address uniquely identifies your device on a network. If you have a device that connects to the Internet, it must have an IP address. IP stands for Internet protocol. It is a unique number or an identifier for the computer or device within the network. Every device would have a unique number that makes it different from the other devices within the network. For example:

IPv4: 32-bit address: 192.168.1.1 
IPv6: 128-bit address: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

Note: An IP address is a unique string of numbers separated by full stops that identifies each computer that uses the Internet protocol to communicate over a network.

2.2. Port

A port is a numerical identifier used in networking to specify a particular service or process on a device. In contrast with an IP address, which identifies the location of a device on a network, ports allow multiple services to operate concurrently on the same device. It ensures that data is directed to the correct application or process. These ports are ranges from 0 to 65535, having certain scale reserved for specific protocols. For example:

HTTP uses port 80  
HTTPS uses port 443

2.3. Protocol

A network protocol is a set of procedures and practices for communication between network devices. It defines how data are formatted, transmitted, and received. Examples include HTTP, FTP, SMTP, and DNS. Protocols can operate at various layers in the OSI model, such as the application layer (HTTP), transport layer (TCP), and network layer (IP).

2.4. Sockets

A socket is a network endpoint for sending or receiving data across multiple devices. It involves a pairing of an IP address and a port number. Sockets can be of two main types: SOCK_STREAM for TCP connections, which are connection-oriented, and SOCK_DGRAM for UDP connections, which are connectionless. Sockets enable the implementation of various network services, such as web and email servers.

3. OSI Model and The TCP/IP Stack

Certain models are defined that tell us how to connect our devices or computers over the Internet so that they can interact and communicate with each other. There are two primary models for defining networking. OSI model or TCP/IP stack. Let us get an overview of each of them briefly:

3.1. TCP/IP Stack

The TCP/IP stack is a suite of communication protocols used to interconnect network devices on the Internet, ensuring reliable data transmission and communication. It is a set of procedures on how computers can interact and how to design those systems. To understand the functions, it is divided into five layers. Each layer has its work, and these are the Application, Transport, Network Access, Data Link, and Physical layers. The TCP/IP stack provides a practical implementation of networking in the real world in contrast with the OSI model, which provides a theoretical understanding of networking communication. In addition, the Transport layer provides the facility for reliable data transmission, and Network Access ensures the correct IP address and routing of data packets, and so on.

3.2. OSI Model

Similar to TCP/IP, the OSI model is also used to design the network across multiple devices. It is a conceptual framework consisting of a set of procedures for understanding and implementing network protocols in seven different layers. It shares the same layer as TCP/IP, with an additional layer. These includes: Application, Presentation, Session, Transport, Network Access, Data Link, and Physical Layer. Specifically, the main difference between OSI and TCP/IP is the two additional layers molded into the application layer of TCP/IP.

Socket Programming Basics

1. Socket Programming As The Foundation Of Networking In Python

Networking involves the connection of two or more devices such that communication is possible within them. In Python, sockets programming is a fundamental and core network creation mechanism. For socket programming, we need to import the socket module. Using the socket module, a developer can generate, configure, and manage sockets for TCP and UDP communication. This module has many built-in methods required for creating sockets and helping them associate with each other. A few important methods that are used are socket.socket, which is used to create a socket. This socket is used on both the client and server sides. Moreover, to accept the communication, we use the socket.accept method.

Note TCP stands for transmission control protocol, which is a connection-oriented protocol that ensures reliable data transfer. UDP is a user datagram protocol, a connectionless protocol that prioritizes speed over reliability.

2. Sockets As Endpoints For Communication Between Machines

Sockets are the network endpoints used for sending and receiving data. By default, a single network has two sockets, one for each communication device. These sockets combine IP addresses and port numbers. In addition, a single device can have N sockets based on the port number used. Different ports are available for different types of protocols; for example, HTTP uses port 80. Through this endpoint mechanism, developers can ensure an accurate and reliable exchange of data in various networking scenarios.

3. Example: Creating and Using Sockets for Basic Network Communication

Now that we have understood what socket programming is as it is the foundation of Python programming, let's move to the code editor and see how we can create it. We must create two different files for the client and server sides to establish the connection.

server.py

import socket #Import library

#Create a socket object and then define two arguments first one specifies the IP address
#and second indicate the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen to the connection
soc.listen(5)

while True:
     #Set client socket and address and make a connection
     clt, addr = soc.accept() 
     print(f"Connection Established to address {addr}")
     msg = "Message Received and the message is ->"
     clt.send(bytes(msg + "Socket Programming in Python", "utf-8"))

client.py

import socket #Importing the module

#Create a socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of the message how much you want to receive
msg = soc.recv(100)
print(msg.decode("utf-8"))

Working with TCP/IP

1. Transmission Control Protocol (TCP) And Its Role in Communication

TCP, also known as transmission control protocol, is a transport layer protocol within the TCP/IP model. It consists of a set of protocols and procedures that decide how to send data over the Internet. Usually, when data are sent as files, they are broken down into individual packets. When packets arrive at the destination with a unique number for each packet. We can assemble them with it. In addition, if some packets are missing, TCP ensures that they are resend. This is why we call TCP a reliable protocol for communication because it establishes communication through the handshake process, acknowledges the received data, and retransmits lost packets by maintaining the correct order of packets and ensuring data integrity and delivery.

2. Example: Creating TCP Client And Server Applications In Python

The server is the software that waits for the client's request, and the client requests the resources from the server. Socket programming is mostly implemented for the client-server architecture. Here, we discuss the example of creating a client and a server where the client sends a message, and the server responds to that message and gives the appropriate response to that request using the socket module with TCP. Let us design both the client and server model.

server.py

import socket #Import socket library

def start_server():
    #Create a TCP/IP socket
    #Create a socket object and then define two arguments first one specifies the IP
address
    #and second for indicating the use of a TCP socket.
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    #Bind the socket to the port
    server_address = ('localhost', 65432)
    print('Starting server on {} port {}'.format(*server_address))
    server_socket.bind(server_address)

    #Listen for incoming connections
    server_socket.listen(1)

    while True:
        #Wait for a connection
        print('Waiting for a connection')
        connection, client_address = server_socket.accept()
        try:
            print('Connection from', client_address)

            #Receive the data and send it back
            while True:
                data = connection.recv(1024)
                if data:
                    print('Received: {}'.format(data.decode()))
                    connection.sendall(data)
                else:
                    print('No more data from', client_address)
                    break
        finally:
            #Clean up the connection
            connection.close()

if __name__ == '__main__':
    start_server()

client.py

import socket #import socket library
def start_server():
    #Create a TCP/IP socket
    #Create a socket object and then define two arguments first one specifies the IP address
    #and second for indicating the use of a TCP socket.
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    #Connect the socket to the server's port
    server_address = ('localhost', 65432)
    print('Connecting to {} port {}'.format(*server_address))
    client_socket.connect(server_address)

    try:
        #Send data
        message = 'Hello, Server!'
        print('Sending: {}'.format(message))
        client_socket.sendall(message.encode())

        #Look for the response
        amount_received = 0
        amount_expected = len(message)

        while amount_received < amount_expected:
            data = client_socket.recv(1024)
            amount_received += len(data)
            print('Received: {}'.format(data.decode()))

    finally:
        #Close the socket
        print('Closing socket')
        client_socket.close()

if __name__ == '__main__':
    start_client()

3. Building A Simple Chat Application Using TCP Sockets

Let us create a simple chat application in Python using TCP sockets, where the server listens to the incoming commands and the client connects to that server to send and receive messages. We are going to build the chat room using the Python built-in module i.e. socket. So, we need to write code for each side like the client and the server, separately:

server.py

import socket #Import library

#Create a socket object and then define two arguments first one specifies the IP address
#and second for  indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen the connection
soc.listen(5)
print("Server listening...")

#Set client socket and address and make connection
clt, addr = soc.accept() 
print(f"Connection Established to address {addr}")

try:
    while True:
        data = clt.recv(1024).decode('utf-8')
        if not data:
            break
        print(f"Received from client: {data}")
        clt.send("Message received".encode('utf-8'))
finally:
    clt.close()
    soc.close()

client.py

import socket #Importing the module

#Create socket object and then define two arguments first one specifies the IP address
#and second for  indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of message how much you wanna receive
try:
    while True:
        message = input("Enter your message: ")
        soc.send(message.encode('utf-8'))
        data = soc.recv(1042).decode('utf-8')
        print(f"Received from server: {data}")
finally:
    soc.close()

Wrapping Up

Networking is a crucial concept in computer science and programming. It resolves most human problems, whether you are working in your office or sharing files with your team. Alternatively, contact a relative from another country. In summary, we focused on the solid introduction of networking foundations using Python. We learned the essential topics of network controls and models, client and server architecture, and practical examples using the socket library. This library ensures the establishment of a secure and reliable network for distributed systems. Keep experimenting and building upon these skills to further enhance your proficiency in network programming. Hope this guide is helpful. Thank you for reading. Happy Coding!

Reference

Networking in Python
Socket library

Advanced Python Concepts - List Comprehensions

Thu, 30 May 2024 11:29:55 +0000

In Python, we can construct a list from another existing list. Well, this doesn't sound very impressive, but what if I told you that, we can take all those complex lines of code containing a for loop and an if-else statement? As well as the appending of modified content into a new list? By narrowing it into a single line of code with the help of list comprehension? Without using the append method even once? It is considered a powerful syntactic feature for creating a concise list. It enhances code readability and improves the performance of the program by offering a more optimized method of list creation compared with the traditional method.
Therefore, In this article, we will explore list comprehension from its basic understanding, concise and compact syntax in the realm of for-loops, conditional statements, string manipulation, its benefits, and some practical use case examples.

Note: Syntactic feature refers to the pre-defined set of rules, syntax, or structure about how datatype, methods, operators, etc, are used to write a valid Python code.

Understanding List Comprehension

1. Definition Of List Comprehensions As Concise Expressions

In Python, list comprehension is a concise method for creating a list. It is defined as the shorter, readable, and compact syntax of creating a list from an existing list. The name used is condensed code for creating the list. The list is surrounded by brackets; however, instead of a list of data, we write an expression followed by loops and if-clauses.

2. Syntax and Structure Of The List Comprehensions

The most basic syntax of list comprehension is:

list = [expression for item in iterable if condition == true]

Expression: An expression that produces the elements of the new list.
Item: Variable representing the members of the iterable separately.
Iterable: The object used for iterating e.g. range, list, tuple, dictionary.
Condition: Optional if-clause to filter items from the iterable.

3. Benefits Of Using List Comprehensions Over Traditional Loop

List comprehension and traditional for-loop are concepts used to iterate lists in Python, but each has its use case based on the context. List comprehension is more readable and compact than the traditional loop because it is written in a single line of code. Whereas for the traditional for-loop, multiple lines of code are required to achieve the same results. In addition, they are more optimized and efficient in terms of performance, especially for simple iteration operations, than the traditional for-loop. List comprehension also aligns with a functional programming language, but traditional for-loop does not align with this paradigm.

Basic List Comprehension Syntax

1. Introduction To The Basic Syntax Of List Comprehensions

The list comprehension syntax consists of brackets containing the expression followed by the for-loop, with zero or more for-loops or if clauses as a condition. The expression contains any kind of iterable object, such as a list, tuple, or dict, that is evaluated to create a new list without changing the existing list.

2. Illustration Of Simple List Comprehensions For Generating Lists Of Numbers and Strings

Let's take an example of creating a new list of square numbers from the list of integers.

numbers = [1,2,3,4,6,7,8,9,10] #list of whole numbers
square = [num ** 2 for num in  numbers] #list comprehension in single line
print(square)

Output

Let's take another example of creating a new list of uppercase strings from the existing list of strings with elements in lowercase.

string  = ["intro", "to", "list", "comprehension"] #list of string
upper_case = [i.upper() for i in string] #list comprehension in single line
print(upper_case)

Output

Using Conditionals In List Comprehensions

1. Explanation Of How To Incorporate Conditional Statements In List Comprehensions

As we understand the basics of list comprehension, let us move toward the advanced concepts. We can also use a conditional statement, i.e., an if-else clause, to filter the elements from the list based on the condition to create a new list. Conditional statements are used to filter the elements or values from the given data. This way, we can create a new list without changing the previous existing list.

2. Illustration Of Using if-else Clauses For Filtering Elements In List Comprehensions.

Let us illustrate the if-else clause with an example of creating a new list of numbers by filtering even numbers from an existing list.

numbers = [1,2,3,4,6,7,8,9,10] #list of whole numbers
even_number = [num for num in  numbers if num % 2 == 0] #list comprehension in single line
print(even_number)

Here is how list comprehension works:

Output

3. Applying Conditional Logic To Create Complex List Comprehensions

Before demonstrating the example for complex list comprehension, we need to understand that the conditional expression can be used more than once to define the list comprehension and create the new output list. Let us create a new list of squares of even numbers and cubes of odd numbers from the list of integers.

numbers = [1,2,3,4,6,7,8,9,10] #list of whole numbers
new_list = [num ** 2 if num % 2 == 0 else num ** 3 for num in  numbers] #list comprehension in single line
print(new_list)

Explanation: In this example, the list comprehension expression alters the list items into squares if the number is even and cubes if the number is odd. Condition logic is used to filter the even and odd numbers from the list of integers.

Output

Nested List Comprehension

1. Introduction To Nested List Comprehensions For Creating Lists of Lists

Besides conditional statements, where we generate the list based on filtering conditions, we can nest list comprehension into other list comprehensions similar to the nested for-loop concept. It is used when each element in the list is itself a list or when we want to convert a list of lists into a single list using flattening techniques. It is a Python technique in which multiple for-loop or if clauses are used, and by which we embed the list comprehension in another

2. Syntax and Structure Of Nested List Comprehensions

The syntax of nested list comprehension containing multiple for-loop is as follows:

Take a look at each component of syntax:

new_list: Name of the new list that would be created.
Expression: The operation or transformation that produces the value of the new list.
Iterable: There are two iterable, inner and outer iterable. Both are a list or other iterable objects you loop over.
Item: The elements in the list.

3. Example Of Nested List Comprehensions for Matrix Operations And Data Transformation

Let's explore the concept of nested list comprehension with an example of a 2D matrix transpose operation.

matrix = [[1, 2, 3],  #2d matrix
          [4, 5, 6],
          [7, 8, 9]]
new_matrix = [[row[i] ** 2 for row in matrix] for i in range(3)] # taking matrix transpose and squaring the value
print(new_matrix)

In the above code, I created a 2D matrix with some values. List comprehension is then used to contain the two for-loop clauses. In the inner for loop, the expression is defined, which means that the values of the matrix are squared by iterating through the matrix and storing the value in the variable row. The outer loop iterates from 0 to 2 (inclusive), creating a list for each value of i.

Output

Practical Use Cases Of List Comprehensions

1. Practical Examples Of List Comprehensions In Everyday Programming Tasks

List comprehension is widely popular in Python programming because of its concise, easy-to-readable syntax and its effective performance. It provides us with a compact way of creating the list in a single line without complicating the logic. Now, I will discuss the practical examples detailing how list comprehensions can be applied to common scenarios.

1.1. Creating A Simple List Of Integers With Multiples Of 5

numbers = [1,2,3,4,6,7,8,9,10] #list of whole numbers
new_list = [num * 5 for num in  numbers] #list comprehension in single line
print(new_list)

Output

1.2. Performing Filtering Operations On The List

people_age = [12,17,38,45,56,19,22]
eligibility = [age for age in people_age if age > 18 ] #list for checking eligibility
#prints the result
print(eligibility)

Output

1.3. Data Manipulation And Transformation Using List Comprehension

string  = ["how", "to", "perform", "data", "transformation"] #list of string
upper_case = [i.upper() for i in string] #list comprehension in single line
print(upper_case)

Output

2. List Comprehensions With Other Python Features

List comprehension is also embedded with other Python built-in functions which include lambda, zip, and enumerate functions. These are:

1. Zip() Function

The zip() function is used to combine two or more lists into a single list of elements.

list1 = [1,7,8,4,6,9,2]
list2 = [2,5,7,3,7,9,3]
#this zip the two list into one based on the expression
result = [i+j for i, j in zip(list1, list2)]
 #prints the result
print("The Result is:",list(result))

2. Enumerate() Function

The enumerate() function is used to track the indexing of the elements in the list comprehension.

colors = ["Red", "Green", "Black", "Blue"] #list of colors
new_list = [(index, item) for index, item in enumerate(colors)] #list comprehension with enumerate function
print(new_list)

Performance Considerations

1. Performance Implications Of Using List Comprehensions

Now, let's move toward the performance considerations, starting with a closer look at the factors and their implications. List comprehension is preferred because of its compact nature and readability. They provide a concise way to generate the list. However, with this significance, there are some considerations as well. These as:

Talking about performance, list comprehension sometimes hinders the readability of the program. When dealing with larger and more complex logic, writing it into a single line of code makes it difficult to understand, debug, and maintain.
Memory constraints exist when dealing with a large dataset. It means that the new list consumes a significant amount of memory upon creation before assigning it to the variable, which is problematic compared to generator functions.
Using the generator function instead of list comprehension can offer better performance. The generator function does not store the entire list in the memory, rather it only produces an item when requested.

2. When To Use List Comprehension For Performance Optimization And When To Avoid Them?

When to Use List Comprehension: When you have to perform simple operations like data processing, transforming, and filtering of data then list comprehension is mostly favored. It provides a concise way, enhances the code readability, and makes it maintainable, and more expressive than a traditional loop. They are faster in execution and optimized than traditional loops even if the dataset is large.
When to avoid them: When the program has complex logic that cannot be written in a single line of code, then avoid using list comprehension. To reduce the complexity, try using a traditional loop that provides better clarity.

3. Comparison Of The Performance Of List Comprehensions With Traditional Loop

Let us compare the performance of list comprehension with a traditional loop using a simple Python example. Working with a small dataset will not be an issue for a traditional loop, but the real problem comes when dealing with a larger dataset. List comprehension is more optimized and efficient than traditional for-loops, which makes them memory-efficient and allows faster iteration over larger datasets. Here, I will list half a million random numbers and store them on the num_list variable. Then, we use for-loop and list comprehension to generate a new list having values higher than a quarter of a million. In the end, compare the speed of both approaches using timeit.

import random
import timeit
num_list = random.sample(range(0, 50000), 10000) #generate random numbers
def trad_loop(): #traditional loop approach
    new_list = []
    for num in num_list:
        if num > 25000:
            new_list.append(num)

def comp_list(): #list comprehension approach
    new_list = [num for num in num_list if num > 25000]

#calculating speed
trad_loop_speed = timeit.timeit(trad_loop, number=1000)
comp_list_speed = timeit.timeit(comp_list, number= 1000)
print("For loop time:", round(trad_loop_speed * 1e6, 2), "microseconds") #printing the reault in miliseconds
print("List comprehension time:", round(comp_list_speed * 1e6, 2), "microseconds")

Output

You can see list comprehension takes less time compared to traditional loop. It is faster than the for-loop, but keep in mind that for complex logic for-loop is more favorable than list comprehension.

Wrapping Up

In conclusion, we discussed that list comprehension is a great way to generate a concise list without writing multiple lines of code. They are much faster compared to traditional for-loop and also provide better performance. They are easy to understand, efficient, and make the program maintainable. These all added the benefits of making your code neat and professional. It can also be embedded with other built-in functions of Python, making it preferable for Python developers than the traditional one. Although, the concept looks quite complex at first. But once you grasp its syntax, you will never look back. Happy Coding!

Reference

Using List Comprehension

Coder Legion - Recent posts tagged advanced-python

ThreeDimensions Version-1.0.0 is here !

ThreeDimensions

Send your creations using ThreeDimensions in Models by filling in the Form. The best models will be added to the examples of ThreeDimensions. Others will be added to the models groups. See current submissions in Submissions. Do participate !

Overview

Feature Highlights

Installation

Quick Start

Geometry Nodes (Programmable)

Viewer

Architecture

License

Python: An Expert-Level Deep Dive into Design, Internals, and Ecosystem

Python: An Expert-Level Deep Dive into Design, Internals, and Ecosystem

1. Introduction

2. Philosophy and Design Principles

Core Design Features

3. Python Architecture and Execution Model

3.1 CPython Implementation

3.2 Global Interpreter Lock (GIL)

4. Data Model and Object System

4.1 Object Structure (Simplified)

5. Advanced Data Structures

5.1 Built-in Collections

5.2 Time Complexity (Average)

5.3 Comprehensions

6. Functions as First-Class Objects

7. Decorators and Metaprogramming

7.1 Decorators

7.2 Metaclasses

8. Concurrency and Asynchronous Programming

8.1 Threading vs Multiprocessing

8.2 Asyncio

9. Memory Management

10. Type Hinting and Static Analysis

11. C Extensions and Performance Optimization

11.1 Using C with Python

11.2 Performance Techniques

12. Python in Large-Scale Systems

Popular Frameworks

13. Packaging and Dependency Management

14. Testing and Quality Assurance

15. Security Considerations

16. The Future of Python

17. Conclusion

Always Five Trick → Class always returns 5 no matter what when you use len().

SignBrige: Hands speak. We translate

Advanced Python Concepts - Metaprogramming

Understanding Metaprogramming

1. Metaprogramming And Its Role In Python

2. Metaprogramming And Regular Programming

3. Benefits And Risks Of Using Metaprogramming

Metaclasses: The Foundation Of Metaprogramming

1. Metaclasses A Mechanism For Creating Classes Dynamically

2. Metaclass ‘__new__’ And ‘__init__’ Methods

3. Example: Creating Custom Metaclasses To Customize Class Creation Behavior

Decorators: Metaprogramming At The Function Level

1. Decorators As Functions That Modify The Behavior Of Other Functions

2. Syntax Of Decorators

3. Illustration of creating and using decorators to add functionality to functions

The 'inspect' Module: Introspection And Reflection

1. Introduction To The `Inspect` Module For Introspection And Reflection

2. How To Use The 'inspect' Module To Examine And Modify Objects At Runtime

1. Examine The Object Using "inspect" Module

2. Modifying The Object At Runtime

3. Practical Use Cases For Introspection And Reflection

Debugging And Code Analysis

Wrapping Up

Additional Reference

Advanced Python Concepts - Networking with Python

Introduction to Networking Concepts

1. Networking and Its Significance In Distributed Systems

2. Key Networking Concepts

2.1. IP Address

2.2. Port

2.3. Protocol

2.4. Sockets

3. OSI Model and The TCP/IP Stack

3.1. TCP/IP Stack

3.2. OSI Model

2. Metaclass ‘new’ And ‘init’ Methods