DEV Community: Muhammad Ihsan

How do LLMs like GPT Generate Human-Like Text?

Muhammad Ihsan — Mon, 21 Oct 2024 19:09:41 +0000

What is LLM?

LLM is a model trained on vast amount of data from different sources like books, articles, and different websites like wikipedia, reddit, and stackoverflow.

LLMs can performs tasks like text generation, translation, text summarization, and question answering.

How LLM is Trained?

The text from all sources is pre-processed (i.e removing explicit or bias content, labeling text, parsing text, converting text to numbers called word embeddings)

The model start with an empty brain like new born child, then shown numerical version of data (word embeddings), the model is then try to learn the context using parameters (we often heard the term parameters like GPT-3 trained on 175 billion parameters)

Initially, it produces wrong outputs, but during training, it continue to improve its performance by adjusting parameters.

Once trained, its deployed, and made available for public use.

Receiving and Processing input from user

When user enter the input for example “I am a beginner at programming, which language is it better to start at?”

Model first split the input sentences into words often called tokens, like

["I", "am", "a", "beginner", "at", "programming", ""which", "language", "is", "it", "better", "to", "start", "at", "?"]

As computer only understand numbers, so, each of these words/tokens are then converted into numerical forms like the word “I” may be converted into [0.35, -0.12, 0.77, 0.44, ….], same for other tokens as well.

Using these vectors, the model calculates attention scores often refered as attention mechanism to determine which words in the input prompt are most important (e.g words like "beginner," "programming," "language", “start”).

The model then search from its data about programming language that beginner oftenly choose when starting career like Python, JavaScript. (as model is already trained on StackOverflow, Medium, and other articles).

Generating Output

Model then try to generate output, word by word using next word probability. Like possible words that occur at first position is one of [“A”, “The”, …], and as usually the first word is “The”, so it chooses it as it might have highest probability of being at first position.

Then it tries to predict next word, the possible words might be [”most”, “good”, “best”, …], the model may choose “best” as second character, and it repeats it for whole output.

As it uses probability, which also ensures the words that are more relevant for beginner programmers should have highest probability, this way model ensures the generated output should match user needs.

This way, LLMs generates human-like responses.

The 2024 Nobel Prize in Physics: An Achievement for AI - More Career Opportunities

Muhammad Ihsan — Sun, 20 Oct 2024 14:19:41 +0000

The 2024 Nobel Prize in Physics is awarded to two scientist jointly, John Hopfield and Geoffrey Hinton. For the first time, the Nobel prize has been awarded to the pioneers of AI and machine learning. In this article, I will explain the importance of this award for the field of Artificial Intelligence and the career opportunities it can create.

Why this Award is Important for AI?

Although, this award is titled as Physics, Artificial Intelligence is also of great significance here. Before this, the Nobel Prizes in Physics was oftenly awarded to areas like quantum mechanics, astrophysics, and particle physics. The 2024 award signifies a paradigm shift, highlighting the convergence of physics with computer science and neuroscience to advance AI.

Who recieved the Nobel Prize?

According to The Nobel Prize in Physics 2024, this award was shared 50-50% among two scientists, John Hopfield and Geoffrey Hinton

1. John Hopfield: Bridging Physics and Neural Networks

John Hopfield is an American physicist and former professor of Princeton University. From 1982 to 1984, he made many contributions in field of AI, which laid important groundwork for modern sequence-based models like Transformers. In 1982, he introduced a neural network model using binary neurons to store and retrieve information, simulating the way memories are formed in the human brain. This approach laid the foundation for further advances in neural networks. In 1984, he improved his model further by making it more similar to real biological neurons, This improved model, was called Hopfield Recurrent Neural Network (RNN), which made up of binary neurons that evolve based on spin glass models in physics in order to hit a local minimum of energy.

2. Geoffrey Hinton: The Godfather of Deep Learning

Geoffrey Hinton is a British-Canadian computer scientist known as the "Godfather of AI" for his pioneering work on artificial neural networks. In 1980’s, he developed the Boltzmann Machine, a stochastic RNN that uses principles from thermodynamics and statistical mechanics. In 1986, he co-authored a key paper on the backpropagation algorithm, important for training neural networks. He also contributed to the development of AlexNet, a breakthrough in computer vision, and co-founded the Vector Institute in 2017. He received the 2018 Turing Award with Yoshua Bengio and Yann LeCun for their work on deep learning.

Career opportunities: in field of AI

The Nobel Prize emphasizes the significance of AI as a scientific field, confirming that its current growth is grounded in substantial advancements. Their work in AI by applying physics to understand neural computation, enable machines to perceive, learn, and make decisions.

It encourages interdisciplinary collaboration between fields like physics, computer science, and biology to address complex problems, and has unlocked new opportunities in AI sectors like quantum computing, recommendation systems, autonomous vehicles, healthcare, and many others.

Additionally, this recognition inspires enthusiast scientists and engineers to pursue careers in AI, fueling further advancements and innovations.

Conclusion

This recognition marks a celebrating moment for AI, unlocking new opportunities and inspiring the next wave of innovations.

P.S. – Thanks for reading❤️

If you found the article informative, feel free to give it a like. I’m committed to exploring and sharing more insights on AI. I will also love to hear your thoughts and suggestions for improvement in the comments👇!

References

The information about Nobel Prize 2024, and biography of scientists was taken from the following sources

The Nobel Prize in Physics 2024. NobelPrize.org. Nobel Prize Outreach AB, 2024. Accessed 20 Oct 2024. https://www.nobelprize.org/prizes/physics/2024/summary/.
Wikipedia contributors. "John Hopfield." Wikipedia, The Free Encyclopedia, https://en.wikipedia.org/wiki/John_Hopfield. Accessed 20 Oct 2024.
Wikipedia contributors. "Geoffrey Hinton." Wikipedia, The Free Encyclopedia, https://en.wikipedia.org/wiki/Geoffrey_Hinton. Accessed 20 Oct 2024.
Cover Image: https://www.nobelprize.org/prizes/physics/2024/summary/

Time Complexity Analysis of Python Methods: Big(O) Notations for List, Tuple, Set, and Dictionary Methods

Muhammad Ihsan — Mon, 15 Jan 2024 09:49:12 +0000

Introduction:

Whether you're working on real-world software or tackling problems in interviews, it's not just about writing code; it's all about writing efficient and scalable code. So, understanding the time complexity of your code becomes essential. In this article, we'll break down the Python methods for lists, tuples, sets, and dictionaries.

Don't worry, if you aren't familiar with the terminologies used in this analysis, I’ll shed light on every concept.

Time Complexity:

Time complexity measures the efficiency of an algorithm, and provides insights into how the execution time changes as the problem size increases.

Big(O) Notation:

The time complexity of a function is measured in Big(O) notations that give us information about how fast a function grows subject to input sizes.

The following are different notations with examples while calculating the time complexity of any piece of code:

O(1): Imagine your friend is waiting for you at a specific restaurant in your street, and you’re already familiar with each restaurant in your street. Regardless of how many other restaurants there are, you always go to that specific restaurant where your friend is since you know exactly where to go.
O(log n): Assume you are in a market with restaurants, each arranged by price from high to low. With a limited budget, you aim to find the best restaurant. Employing a binary search strategy, you start in the middle, navigate based on your budget, and repeat the process until you discover the desired restaurant.
O(n): In the market, find all restaurants where there are more than 10 people. You need to visit each restaurant and count the number of people.
O(n log n): Imagine a scenario where there's a mix-up of restaurants. Initially, you make a list of price ranges for all restaurants along with their names. Subsequently, you perform a search for your desired restaurant within this sorted list.
O(n2): You want to find the best restaurant by comparing the quality of food with every other restaurant. So, for each restaurant, you have to go through all other restaurants and make comparisons.

Image taken from https://www.bigocheatsheet.com/

Timsort algorithm:

Tim Sort is the default sorting algorithm used by Python’s sorted() and list.sort() functions. It has the time complexity of O(n log n). It is a hybrid sorting algorithm derived from merge sort and insertion sort.

Amortized constant time:

It's used when mostly the operation is fast, but on some occasions, the operation of the algorithm is slow. It can be ignored in most cases.

For example, list.append(). As the list reserves some memory, so until it is utilized, list.append() gives O(1). However, when the reserved memory is filled, and new memory is required, a new list is created with more space, copying all elements. While this operation is not always constant time, it happens infrequently. So, we refer to it as Amortized constant time.

IN Operator:

The IN Operator uses linear search with a time complexity of O(n).

Python List Methods:

Operation	Best Case	Average Case	Worst Case	Notes
append()	O(1)	O(1)	O(1)	Amortized constant time
insert()	O(1)	O(n)	O(n)
pop()	O(1)	O(1)	O(1)	Amortized constant time
pop(index)	O(1)	O(n)	O(n)
del list[index]	O(1)	O(n)	O(n)	Similar to pop(index)
extend()	O(1)	O(k)	O(k)	Where k is the length of the iterable
remove()	O(1)	O(n)	O(n)	Linear search
index()	O(1)	O(n)	O(n)	Linear search
count()	O(1)	O(n)	O(n)	Linear search
reverse()	O(1)	O(n)	O(n)
sort()	O(n log n)	O(n log n)	O(n log n)	Timsort algorithm
copy()	O(n)	O(n)	O(n)	Shallow copy
clear()	O(1)	O(1)	O(1)
index(x, start, end)	O(1)	O(n)	O(n)	Linear search within specified indices
Slice	O(1)	O(k)	O(k)	Where k is the size of the slice

Python Tuple Methods:

Operation	Best Case	Average Case	Worst Case	Notes
Creating a Tuple	O(1)	O(n)	O(n)	Where n is length of iterable
Indexing	O(1)	O(1)	O(1)
Slicing	O(1)	O(b - a)	O(b - a)
Concatenation	O(1)	O(k)	O(k)	Where k is the size of the tuple
tuple.index(element)	O(1)	O(n)	O(n)	Linear search
tuple.count(element)	O(1)	O(n)	O(n)	Linear search
element in tuple	O(1)	O(n)	O(n)	Linear search
Iterating	O(1)	O(n)	O(n)	Where n is length of the tuple

Python Dictionary Methods:

Operation	Best Case	Average Case	Worst Case	Notes
get(key)	O(1)	O(1)	O(1)	Constant time on average
pop(key)	O(1)	O(1)	O(1)
popitem()	O(1)	O(1)	O(1)
keys()	O(1)	O(1)	O(1)	Returns dynamic view with constant time
values()	O(1)	O(1)	O(1)	Returns dynamic view with constant time
items()	O(1)	O(1)	O(1)	Returns dynamic view with constant time
update()	O(n)	O(n)	O(n)	Merging two dictionaries
clear()	O(1)	O(1)	O(1)
copy()	O(n)	O(n)	O(n)	Shallow copy
del dictionary[key]	O(1)	O(1)	O(1)
key in dictionary	O(1)	O(1)	O(1)	Constant time on average
clear()	O(1)	O(1)	O(1)

Python Set Methods:

Operation	Best Case	Average Case	Worst Case	Notes
Creating a Set	O(1)	O(len(iterable))	O(len(iterable))
s.add(element)	O(1)	O(1)	O(1)
s.remove(element)	O(1)	O(1)	O(1) or O(n)	Average O(1), worst O(n)
s.discard(element)	O(1)	O(1)	O(1)
s.pop()	O(1)	O(1) or O(n)	O(1) or O(n)	Average O(1), worst O(n)
s.clear()	O(1)	O(1)	O(1)
s.copy()	O(len(s))	O(len(s))	O(len(s))	Shallow copy
Iterating	O(1)	O(n)	O(n)	Where n is size of the set
element in s	O(1)	O(1)	O(1)
Union (s1	s2 or s1.union(s2))	O(len(s1) + len(s2))	O(len(s1) + len(s2))
Intersection (s1 & s2 or s1.intersection(s2))	O(min(len(s1), len(s2)))	O(min(len(s1), len(s2)))
len(s)	O(1)	O(1)	O(1)

Thanks for reading! Feel free to like, comment, and share if you find this article valuable.

You can check my other articles as well:
Mastering Metaclasses in Python using real-life scenarios
Use Asynchronous Programming in Python: Don’t Block Entire Thread

Use Asynchronous Programming in Python: Don’t Block entire Thread

Muhammad Ihsan — Tue, 09 Jan 2024 18:53:16 +0000

As Python is single-threaded, having a command of asynchronous programming has become mandatory to utilize that single thread efficiently. This article explores the fundamentals of asynchronous programming and elaborates with code snippets to help you fully utilize the potential of concurrency in Python.

Before diving into the actual code, let’s first understand some basic terminologies and concepts, so you can remain on track throughout the whole article.

Understanding Asynchronous Programming:

Asynchronous programming is a technique designed to handle concurrent tasks without blocking the entire thread. Whenever any program waits for something, such as DB Call/Network Request, it allows other tasks to run meanwhile, which improves overall performance.

Coroutines:

Coroutines are functions that can be paused and resumed at specific intervals. Unlike traditional functions, coroutines allow non-blocking execution by enabling tasks to pause and give control back to the event loop. This makes it possible to perform other operations while waiting for time-consuming tasks, to complete.

Asyncio is a library in Python for writing asynchronous code. The async keyword is used to define coroutines. A coroutine can contain await expressions, indicating points at which the coroutine can be paused, allowing other tasks to execute in the meantime.

Here’s a simple coroutine that can be defined using async keyword:

import asyncio

async def my_coroutine():
    print("Start")
    await asyncio.sleep(2)
    print("End")

asyncio.run(my_coroutine())

Why using `asyncio.sleep()` then `time.sleep()`?

You might be wondering, what’s the difference between time.sleep() and asyncio.sleep(). The time.sleep() function is a synchronous method that pauses the execution of the entire program/thread for a specified duration. On the other hand, asyncio.sleep() is part of the asyncio library and is specifically designed for asynchronous code. It will not block the entire program/thread, and only pauses a coroutine for a specified duration, enabling other tasks to run concurrently.

Below is a simple example illustrating the difference:

import time
import asyncio

print("**** Synchronous sleep ****")
time.sleep(2)
print("This will be printed after 2 seconds, as entire thread was blocked")

async def coroutine_1():
    print("Pausing coroutine 1 ...")
    await asyncio.sleep(1)
    print("After a pause, resuming coroutine 1 ...")

async def coroutine_2():
    print("coroutine_2() is executed because coroutine_1() is on pause")

async def main():
    await asyncio.gather(coroutine_1(), coroutine_2())

print("**** Asynchronous sleep ****")
asyncio.run(main())

In the synchronous example, the entire program is paused for 2 seconds during time.sleep(2), while in the asynchronous example, only the coroutine_1() is paused during asyncio.sleep(2), allowing other asynchronous task coroutine_2() to continue.

Here’s the output:

**** Synchronous sleep ****
This will be printed after 2 seconds, as entire thread was blocked

**** Asynchronous sleep ****
Pausing coroutine 1 ...
coroutine_2() is executed because coroutine_1() is on pause
After a pause, resuming coroutine 1 ...

Event Loop:

The event loop is responsible for scheduling and executing coroutines. It ensures the tasks progress without waiting for one another.

Note: An event loop is always required if you are working with asynchronous tasks.

You can create an event loop usingnew_event_loop(), here’s the code:

import asyncio

async def any_async_task():
    await asyncio.sleep(1)

loop = asyncio.new_event_loop()
loop.run_until_complete(any_async_task())
loop.close()

Power of `asyncio.run(my_coroutine())` :

In the above paragraph, I have mentioned that an event loop is always mandatory to run asynchronous tasks, then why is our first program my_coroutine() working without an event loop? The reason is when you call asyncio.run(my_coroutine()), it automatically creates a new event loop, starts running the specified coroutine in that event loop, and then closes the event loop after completion.

Tasks:

Tasks represent the execution of a coroutine and are managed by the event loop. They allow you to run multiple coroutines concurrently.

import asyncio

async def task1():
    await asyncio.sleep(1)
    print("This will be printed after 1 second pause")

async def task2():
    print("This will be printed immediately")

async def main():
    await asyncio.gather(task1(), task2())

# Run the main function using asyncio.run
asyncio.run(main())

Here’s the output of the above program:

task2() will be executed immediately
task1() will be executed after 1 second pause

Futures:

Futures are placeholders for the result of asynchronous operations. They allow you to retrieve the outcome of a coroutine once it is completed.

import asyncio

async def my_coroutine():
    await asyncio.sleep(1)
    return "Any Async Output"

my_future = asyncio.Future()
my_future.set_result(asyncio.run(my_coroutine()))
result = my_future.result()
print(result)

Alternatively, you can also achieve the above result by using the following simplified line of code:

result = asyncio.run(my_coroutine())
print(result)

Real-life Example - Making multiple HTTP Requests:

Now, let’s make multiple HTTP Requests asynchronously:

import aiohttp, asyncio

async def fetch_data(i, url):
    print('Starting', i, url)
    async with aiohttp.ClientSession() as session:
        async with session.get(url):
            print('Finished', i, url)

async def main():
    urls = ["https://dev.to", "https://medium.com", "https://python.org"]
    async_tasks = [fetch_data(i+1, url) for i, url in enumerate(urls)]
    await asyncio.gather(*async_tasks)

asyncio.run(main())

The above program will print the following output, which shows that all 3 tasks ran almost independently without waiting for each other, and print Finished when each one is completed:

Starting 1 https://dev.to
Starting 2 https://medium.com
Starting 3 https://python.org

Finished 2 https://medium.com
Finished 3 https://python.org
Finished 1 https://dev.to

Conclusion:

I tried to cover as many concepts related to asynchronous programming as possible. I will consistently put my efforts here on this platform. If you liked my content, then don't forget to appreciate it, it boosts my confidence.

Thanks for reading

Mastering Metaclasses in Python using real-life scenarios

Muhammad Ihsan — Thu, 04 Jan 2024 04:41:24 +0000

Metaclasses in Python offer a powerful way to shape how classes are defined, providing developers with the means to enforce coding standards, limiting the number of methods, not allowing public methods, deprecating old methods, and even applying design patterns. In this article, we'll delve into the metaclasses, exploring real-life scenarios where they can be applied for advanced Python coding.

Understanding Metaclasses

Before we explore real-world applications, let's grasp the basics of metaclasses. In Python, metaclasses act as classes for classes, defining how classes are constructed.

Below is a simple MetaClass inherited from the built-in class type:

class MetaClass(type):
    def __new__(cls, name, bases, dct):
        """
        The __new__ method is called when a new class is created (not when an instance is created). It takes four arguments:

        - cls: The metaclass itself.
        - name: The name of the class being created.
        - bases: A tuple of the base/parent classes of the class being created.
        - dct: A dictionary containing all the attributes and methods of the class.

        The purpose of __new__ is to customize the creation of the class object. You can modify the
        attributes or alter the class structure before it is created.
        """
        # Custom logic for creating the class object, modifying attributes, or altering the structure
        return super().__new__(cls, name, bases, dct)

    def __call__(cls, *args, **kwargs):
        """
        The __call__ method is called when an instance of the class is created. It takes three arguments:

        - cls: The class itself.
        - args: The positional arguments passed to the class constructor.
        - kwargs: The keyword arguments passed to the class constructor.

        The purpose of __call__ is to customize the creation or initialization of instances. You can
        perform additional logic before or after instance creation.
        """
        # Custom logic for creating or initializing instances
        return super().__call__(cls, *args, **kwargs)

Real-Life Scenarios

The following are some of the real-life scenarios you need to understand the concept of metaclasses.

1. Enforcing Coding Standards

1.1 Naming Convention Meta Class

The following NamingConventionMeta class ensures the use of proper naming conventions:

class NamingConventionMeta(type):
    def __new__(cls, name, bases, dct):
        first_letter = name[0]
        if not first_letter.isupper():
            raise NameError("Class names must start with an uppercase letter.")
        return super().__new__(cls, name, bases, dct)

Now, let’s try to create new classes, and you’ll see bad_className will raise NameError.

class GoodClassName(metaclass=NamingConventionMeta):
    pass

# will raise NameError
class bad_className(metaclass=NamingConventionMeta):
    pass

1.2 Doc String Meta Class

The DocstringMeta class enforces the presence of docstrings for all methods:

class DocstringMeta(type):
    def __new__(cls, name, bases, dct):
        for attr_name, attr_value in dct.items():
            if callable(attr_value) and not attr_value.__doc__:
                raise TypeError(f"Method '{attr_name}' must have a docstring.")
        return super().__new__(cls, name, bases, dct)

Now, let’s try to create a new class, and you’ll see bad_method will raise TypeError.

class ExampleClass(metaclass=DocstringMeta):

    def good_method(self):
        """ It contains docstring """
        pass

    # will raise TypeError that docstring is missing
    def bad_method(self):
        pass

1.3 Standard Meta Class

By combining multiple metaclasses, we create a StandardClass that enforces various coding standards:

class StandardClass(CamelCase, DocstringMeta):  # Inherited from various Meta classes
    pass

Creating a class with this standard:

class GoodClass(metaclass=StandardClass):
    def good_method(self):
        """ It contains docstring """
        pass

2. Limiting the Number of Methods

The following MethodCountMeta class will allow a maximum of 2 methods. You can also set a different value and set a minimum limit if needed.

class MethodCountMeta(type):
    max_method_count = 2

    def __new__(cls, name, bases, dct):
        method_count = sum(callable(attr_value) for attr_value in dct.values())
        if method_count > cls.max_method_count:
            raise ValueError(f"Class '{name}' exceeds the maximum allowed method count.")
        return super().__new__(cls, name, bases, dct)

class ExampleClass(metaclass=MethodCountMeta):
    def method1(self):
        pass

    def method2(self):
        pass

    # Raises a ValueError since it exceeds the limit
    def method3(self):
        pass

3. Deprecating Methods

The DeprecationMeta metaclass introduces a mechanism to deprecate methods, issuing a warning and providing an alternative.

class DeprecationMeta(type):
    def __new__(cls, name, bases, dct):
        deprecated_methods = {'old_method': 'Use new_method instead'}
        for deprecated_method, message in deprecated_methods.items():
            if deprecated_method in dct and callable(dct[deprecated_method]):
                dct[deprecated_method] = cls._deprecate_method(dct[deprecated_method], message)
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def _deprecate_method(func, message):
        def wrapper(*args, **kwargs):
            import warnings
            warnings.warn(f"DeprecationWarning: {message}", DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)
        return wrapper

Now, if you call new_method, it’ll work fine, but calling old_method will raise DeprecationWarning

class Example(metaclass=DeprecationMeta):

    def old_method(self):
        pass

    def new_method(self):
        pass

instance = Example()
instance.new_method()

# will raise DeprecationWarning to use new_method instead
instance.old_method()

4. Applying the Singleton Design Pattern

The Singleton pattern is a design pattern that restricts the instantiation of a class to a single instance and provides a global point of access to that instance. In Python, one way to implement the Singleton pattern is by using a metaclass.

Here's an example of a simple Singleton implementation using a metaclass:

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        # If an instance of this class doesn't exist, create one and store it
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        # Return the existing instance
        return cls._instances[cls]

class SingletonClass(metaclass=SingletonMeta):
    pass

Now, create multiple instances of the class, and check if they are the same instance

instance1 = SingletonClass()
instance2 = SingletonClass()

print(instance1 is instance2)  # Output: True

Conclusion

Mastering metaclasses in Python empowers developers to exert control over class creation, leading to more maintainable, standardized, and robust code. By exploring real-life scenarios, we've demonstrated the versatility of metaclasses in enforcing coding standards, limiting methods, deprecating methods, and applying design patterns.

Incorporating metaclasses into your Python projects allows you to create more maintainable, standardized, and robust code. As you master the art of metaclasses, you gain a deeper understanding of Python's flexibility and extensibility.

Thanks for reading! Feel free to like, comment, and share if you find this article valuable.

You can checkout my other article as well:
Use Asynchronous Programming in Python: Don’t Block entire Thread

DEV Community: Muhammad Ihsan

How do LLMs like GPT Generate Human-Like Text?

What is LLM?

How LLM is Trained?

Receiving and Processing input from user

Generating Output

The 2024 Nobel Prize in Physics: An Achievement for AI - More Career Opportunities

Why this Award is Important for AI?

Who recieved the Nobel Prize?

1. John Hopfield: Bridging Physics and Neural Networks

2. Geoffrey Hinton: The Godfather of Deep Learning

Career opportunities: in field of AI

Conclusion

References

Time Complexity Analysis of Python Methods: Big(O) Notations for List, Tuple, Set, and Dictionary Methods

Introduction:

Time Complexity:

Big(O) Notation:

Timsort algorithm:

Amortized constant time:

IN Operator:

Python List Methods:

Python Tuple Methods:

Python Dictionary Methods:

Python Set Methods:

Use Asynchronous Programming in Python: Don’t Block entire Thread

Understanding Asynchronous Programming:

Coroutines:

Why using asyncio.sleep() then time.sleep()?

Event Loop:

Power of asyncio.run(my_coroutine()) :

Tasks:

Futures:

Real-life Example - Making multiple HTTP Requests:

Conclusion:

Mastering Metaclasses in Python using real-life scenarios

Understanding Metaclasses

Real-Life Scenarios

1. Enforcing Coding Standards

2. Limiting the Number of Methods

3. Deprecating Methods

4. Applying the Singleton Design Pattern

Conclusion

Why using `asyncio.sleep()` then `time.sleep()`?

Power of `asyncio.run(my_coroutine())` :