A very good indicator that an object is immutable is when all its methods return something

@Cmatrix_PY

The defaults arguments are created and stored in special place


@Cmatrix_PY

This is why, in general, mutable objects shouldn't be used as default arguments.
This is the standard practice

@Cmatrix_PY

Python uses a pass-by-assignment model, and understanding it requires you to realise all objects are characterised by an identity number, their type, and their contents.

@Cmatrix_PY

Pass by value, pass by reference, and pass by assignment are all ways in which arguments can be passed to a function or method.

In pass by value, the actual value of an argument is passed to the function. This means that any changes made to the parameter inside the function have no effect on the original argument. In other words, a copy of the value is sent to the function, so any modifications made within the function will not affect the original variable.

In pass by reference, a reference or pointer to the memory location of the argument is passed to the function. This means that any changes made to the parameter inside the function will also affect the original argument. In other words, both variables point to the same memory address, so any modifications made within the function will also be reflected outside the function.

#python
#pass_by_value
#pass_by_reference
@Cmatrix_PY

Generally, tuples are more efficient that lists, so, unless you need mutability of the container, prefer using a tuple over a list.

#python
@Cmatrix_PY

Constant folding is the process of recognizing and evaluating constant expressions at compile time rather than computing them at runtime.

In this example, we define a function called calculate() that multiplies the constants 10 and 20 together. Since this expression involves only constants, the Python interpreter can simplify it to 200 during compilation. Therefore, at runtime, the function simply returns the constant value 200, rather than performing the multiplication operation again.

This is a simple example, but constant folding can be very useful for optimizing performance in more complex programs. By simplifying expressions involving only constants, the compiler or interpreter can reduce the amount of work that needs to be done at runtime, leading to faster and more efficient code.

#python
@Cmatrix_PY

Tag in Commits indicates the type of change made.

#git

What is a dynamic array?

A dynamic array is similar to an array, but with the difference that its size can be dynamically modified at runtime. Don’t need to specify how much large an array beforehand. The elements of an array occupy a contiguous block of memory, and once created, its size cannot be changed. A dynamic array can, once the array is filled, allocate a bigger chunk of memory, copy the contents from the original array to this new space, and continue to fill the available slots.

#data_structure
@Cmatrix_PY

we can use an underscore _ before the method name to keep it non-public.

#python
@Cmatrix_PY

Dynamic Array Logic Implementation:

The key is to provide means to grows an array A that stores the elements of a list. We can’t actually grow the array, its capacity is fixed. If an element is appended to a list at a time, when the underlying array is full, we need to perform following steps.


1.Allocate a new array B with larger capacity (A commonly used rule for the new array is to have twice the capacity of the existing array )

2.Set B[i]=A[i], for i=0 to n-1 where n denotes the current no of items.

3.Set A=B that is, we hence forth use B as the array of supporting list.

4.Insert new element in the new array.


#data_structure
@Cmatrix_PY

Why tuple Load faster than list?


Tuples can load faster than lists when they contain constants (such as integers and strings) because tuples are immutable, meaning their values cannot be changed once they are created. This immutability allows the interpreter to make certain optimizations during the loading process.

When a tuple is created with constant values, the compiler or interpreter can treat it as a single constant value in memory. This means that the entire tuple can be loaded in one step without any intermediate steps or memory allocations. Since tuples are immutable, there is no need for additional memory allocation or resizing because the values cannot be modified later.

On the other hand, lists are mutable, so they need to support dynamic resizing and element addition. When building a list, each element is added individually, which involves multiple steps of memory allocation, resizing, and assignment. The list needs to allocate memory for each new element, potentially resize the underlying data structure, and copy the existing elements to the new memory location.

Because of these differences, tuples can load faster than lists when they contain constant values because the loading process for tuples is more streamlined and doesn't require the same level of memory management and resizing operations performed by lists.

It's important to note that this performance difference between tuples and lists is generally only noticeable in specific scenarios where large collections or intensive operations are involved. For most general use cases, the speed difference between tuples and lists is unlikely to have a significant impact on overall performance.

#data_structure
#python
@Cmatrix_PY

📢 New Article Alert: Test Driven Development of a Django RESTful API ! 🐍🔬

🔗 Article Link: https://realpython.com/test-driven-development-of-a-django-restful-api/

In this article, you'll learn about test-driven development (TDD) using Django REST Framework. Discover how to build robust APIs with comprehensive test suites. The article covers setting up your project, writing unit tests for views and serializers and ...

Don't miss out on this opportunity to level up your API testing skills!

Happy coding and testing! 💻🧪

#Django
#API
#restframework
@Cmatrix_PY

🐍 Why Python Indexes Start from 0 📊

Hey fellow Pythonistas! Today, let's dive into the fascinating world of indexing in Python and explore why it all begins from zero. 🚀

1️⃣ Zero-based indexing simplifies calculations:
One of the main reasons Python uses zero-based indexing is to simplify various calculations and operations. When an element is at index n, the number of elements that precede it will indeed be n. This correlation between the index and the number of preceding elements makes it easier to perform computations and manipulate data structures.

2️⃣ Consistency with other programming languages:
Python draws inspiration from several programming languages, including C and Java, which also use zero-based indexing. Adopting the same convention allows for greater consistency when transitioning between different languages. It facilitates code readability and reduces confusion when collaborating with developers familiar with other languages.

3️⃣ Array offset and pointer arithmetic:
In many low-level programming languages, arrays are represented as contiguous blocks of memory. Using zero-based indexing aligns with the underlying concept of array offsets and pointer arithmetic. It simplifies the conversion between indices and memory addresses, making it more efficient and intuitive to work with arrays.

4️⃣ Mathematical elegance and simplicity:
By starting indexing at zero, Python adheres to a clean and elegant mathematical convention. When using ranges, the length of a range from l to u is given by u - l. This simple formula preserves an intuitive relationship between indices and lengths, making it easier to reason about code and manipulate sequences.

5️⃣ Avoiding off-by-one errors:
Using zero-based indexing helps in avoiding off-by-one errors, which frequently occur when working with one-based indexing. By starting at zero, developers can directly access the first element using index 0, avoiding any confusion or edge cases that may arise from starting at index 1.

6️⃣ Compatibility with slicing notation:
Python's slice notation, such as list[start:end], is widely used for accessing subsequences. By aligning with zero-based indexing, the slices become more intuitive and consistent. For example, list[0:3] retrieves the first three elements of a list, making it clear that the range is inclusive of the start index.

These are some of the key reasons why Python embraces zero-based indexing. If you have any additional thoughts or reasons, please feel free to share them! Let's keep the discussion going in the comments below. Happy coding! 🙌💻

#python
@Pythonic_Dev