Let’s start! First of all, you need to download and install Python.

Next, we will use UV as a package manager. UV is a fast, modern Python package manager developed by Astral. Designed as a drop-in replacement for pip and virtualenv, it uses the Rust programming language for performance, resolving dependencies quickly and managing virtual environments efficiently. UV improves installation speed, reliability, and reproducibility, aiming to streamline Python development workflows with minimal configuration. The UV is 10 to 100 times faster than the pip package manager.

Next, we need to create a virtual environment using uv. Run the following command in the terminal. Here I’m using Python 3.11.6 for the virtual environment, you can use any version you wish to work with. The virtual environment will be created in env folder.

uv venv --python 3.11.6 env

To activate the virtual environment, run the following command :

For Windows users :

env\Scripts\activate

Linux\Mac users :

source venv/bin/activate

Finally, we can install opencv using uv. Run the following command to install it :

uv pip install opencv-python

Or you can install opencv-headless using the below command

uv pip install opencv-python-headless

The difference between opencv-python and opencv-python-headless lies mainly in GUI support and dependencies:

OpenCV-Python

• Includes GUI functionality (e.g., cv2.imshow(), cv2.waitKey())
• Requires GUI-related system libraries like GTK or Qt.
• Suitable for local development or environments with a display.

Opencv-python-headless

• Excludes GUI features, so no imshow() window handling.
• Smaller in size and fewer dependencies.
• Ideal for server-side, Docker, CI/CD, or headless environments.

After installation, you can run the following OpenCV test code :

import cv2
import numpy as np

print("OpenCV version:", cv2.__version__)

image = cv2.imread("test.jpg")
if image is None:
    print("Image not found,creating a dummy image")
    image = 255 * np.ones((200, 200, 3), dtype=np.uint8)

# Display the image (only works with opencv-python, not headless)
cv2.imshow("Test Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output of the app :

Conclusion

In conclusion, it is easy to install and and use OpenCV with Python using uv package manager.

The post The easiest way to use OpenCV with Python appeared first on NoloWiz.

Python and GIL (Global Interpreter Lock)

The Global Interpreter Lock (GIL) in Python is a mutex that ensures only one thread executes Python bytecode at a time. Because of GIL, we cannot run more than one thread at a time in Python Code. Let’s understand different Python implementations and GIL.

Python has several implementations :

• CPython – The default and most widely used implementation of Python written in C
• Jython – Python implementation written in Java
• IronPython – A version of Python that is integrated with the .NET framework.
• PyPy – A Python implementation written in Python itself (Just-in-time (JIT) compiler to improve the execution speed)

Out of these implementations, the following Python implementations have GIL:

• CPython
• PyPy

Since Jython and IronPython have no GIL, there is no issue with multithreading. Here we only discuss the default CPython implementation and multi-threading.

Types of tasks

Let’s understand the types of tasks Python code needs to execute:

1. CPU bound tasks
2. IO bound tasks
3. Asynchronous tasks

1. CPU-bound tasks

CPU-bound tasks require significant computing power. It depends on the processing speed of the CPU, for example :

• Mathematical computations
• Data processing – sorting data or image processing

2. IO-bound tasks

I/O-bound tasks are operations where the execution time is primarily determined by input/output operations rather than CPU processing speed, for example :

• Network requests – Making HTTP requests
• File operations – Reading or writing to a file
• Database queries – fetching data from the database

3. Asynchronous Tasks

Python also supports asynchronous programming. It is particularly suited for I/O-bound tasks. Using libraries like asyncio, developers can write non-blocking code that allows other tasks to run while waiting for I/O operations to complete.

Multithreading in Python

Let’s write some code to test multithreading in Python. The following Python codes were tested on the below environment :

• Processor: Intel Core i7-12700
• Operating system: Windows 11, 64-bit

We are going to use Python 3.13 for this code execution. Let’s write a CPU-bound task to calculate the n^th Fibonacci number. Let’s calculate 38th Fibonacci number:

import time

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.time()
fibonacci(38)
elapsed = time.time() - start
print(f"Elapsed time : {elapsed:.2f}s")

Elapsed time : 3.24s

We can see that the elapsed time is 3.24 seconds for Fibonacci calculation. Next, we do the same calculation on two parallel threads using ThreadPoolExecutor.

from concurrent.futures import ThreadPoolExecutor
import time


def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)


def compute_fibonacci(num):
    start = time.time()
    fibonacci(num)
    elapsed = time.time() - start
    print(f"Elapsed time : {elapsed:.2f}s")


if __name__ == "__main__":
    numbers = [38, 38]
    with ThreadPoolExecutor() as executor:
        for num in numbers:
            executor.submit(
                compute_fibonacci,
                num,
            )

The output of the above code :

Elapsed time : 6.20s
Elapsed time : 6.23s

We can see that each thread took 6.2 seconds for the calculation. Due to GIL, we are not getting any parallel execution, and we need to wait for 6.2 seconds for both results.

Process-based Parallelism

In Python, process-based parallelism does not directly achieve multithreading; rather, it is an alternative approach to achieve parallel execution by creating multiple processes. Let’s do the same compuation using ProcessPoolExecutor.

from concurrent.futures import ProcessPoolExecutor
import time


def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)


def compute_fibonacci(num):
    start = time.time()
    fibonacci(num)
    elapsed = time.time() - start
    print(f"Elapsed time : {elapsed:.2f}s")


if __name__ == "__main__":
    numbers = [38, 38]
    with ProcessPoolExecutor() as executor:
        for num in numbers:
            executor.submit(
                compute_fibonacci,
                num,
            )

The output of the above script is :

Elapsed time : 3.24s
Elapsed time : 3.24s

Now the Fibonacci calculation happens in parallel through Process-based parallelism.

Free threaded Python3.13

I’ve tried the latest experimental free-threaded Python 3.13 which removes GIL limitation. Here is the result using ThreadPoolExecutor using the above Fibonacci code in free-threaded Python.

Elapsed time : 5.49s
Elapsed time : 5.50s

We can see that we got speed improvement. However, this free threading has been observed to significantly slow down single-threaded performance(3.2 to 5.4 seconds), while potentially improving multi-threaded execution(6.2 to 5.4 seconds).

Conclusion

Due to GIL limitation, process-based parallelism can be used for the CPU-bound tasks to execute parallelly. At the time of this writing, the Python 3.13 freethreaded feature is experimental and is not ready for production use. In the future, we can expect full multithreading support in Python.

The post Multi-Threading in Python and Free threaded Python 3.13 appeared first on NoloWiz.

Monkey Patching

Monkey patching is a technique in programming where you modify or extend existing code at runtime. It allows you to add, modify, or replace functionality in a class or module without directly modifying its source code. It’s often used to fix bugs, add functionality, or customize third-party libraries without modifying their source code.

The term “monkey” in this context implies that these changes are being made in a playful, somewhat experimental, and potentially risky manner, similar to how a monkey might tamper with things.

Let’s understand it with some examples.

Example 1

import math

math.pi = 3.2 #Monkey patching pi value

print(math.pi)

Output

3.2

Here we are monkey patching the value of pi in the maths module. The value of pi is approximated to 3.2.

Example 2

Let’s understand how monkey patching can be used to extend a Python class. Suppose we have a MathOperations class with “add” member function.

class MathOperations:
    def add(self, a, b):
        return a + b

Suppose we want to add the “subtract” method to the MathOperations class we can monkey-patch it.

MathOperations.subtract = subtract

Now we have added subtract method to MathOperations class and we can use the subtract method :

math = MathOperations()
result = math.subtract(5, 3)  
print(result)

Output

2

Example 3

Let’s understand dynamic behavior with one more example. Suppose we have a Greeting class defined in greetings.py file.

# greetings.py

class Greeting:
  def greet(self):
    print("Hello!")

We will create a new module it will change the behaviour of greet function at run time.

from greetings import Greeting

def display(self):
    print("Hello NoloWiz")

Greeting.greet = display #monkey patching

greeting = Greeting()
greeting.greet()

Here greet function is replaced with newly defined display function.

Output

Hello NoloWiz

When to Use Monkey Patching

In the following situations we can use Monkey patching:

• Third-party Libraries: When you need to add or modify functionality in a third-party library that you can’t modify directly, monkey patching can be used.

• Bug Fixes: If you encounter a bug in a library or framework and can’t wait for an official fix, you can patch it temporarily using monkey patching.

• Legacy Code: When working with legacy code that can’t be easily refactored, monkey patching can help you make necessary changes without rewriting the entire codebase.

• Experimental Code: In some cases, you might use monkey patching to experiment with new features or concepts before committing to a more permanent solution.

The post Monkey Patching in Python With Examples appeared first on NoloWiz.

What is Partial function?

A partial function in programming is a function that is defined for only a subset of possible inputs. It allows you to specify a fixed number of arguments in advance, leaving some arguments to be provided later. This can be useful for creating reusable and flexible code.

In Python, we can use the functools’ partial function to implement the partial function.The functools is a module in Python’s standard library that provides higher-order functions and operations on callable objects.

Example 1:

Let’s understand with an example, suppose we have a function to multiply two numbers.

def multiply(first_num, second_num):
  '''Multiply two numbers'''
  return first_num * second_num

We can convert the multiply function to calculate the double of a number using partial function.

from functools import partial

double = partial(multiply,second_num=2)

Here one argument to multiply function is fixed(2), the partial function double can accept one number. Now we can call the function double :

print(double(52))

Output

104

We can also add docstring to the partial function using the __doc__ dunder function.

from functools import partial

double = partial(multiply,second_num=2)
double.__doc__ = "Calcualte double of the number"

Example 2:

Suppose we have a function to calculate the power of a number.

def power(number,exponent):
  return number ** exponent

We can define a square and cube partial functions as shown below :

square = partial(power,exponent=2)
cube = partial(power,exponent=3)

We can call cube partial function :

print(cube(5))

Output

125

When to use Partial functions

Partial functions are usable in the following contexts :

• When you need to fix one or more arguments of a function and create a new function with reduced arity(The term “arity” refers to the number of arguments or parameters that a function or operation can accept).
• We want to create a function with default arguments.
• When you need to pass a function as an argument to another function with specific arguments already set.
• When we want reusable code

The post Partial Functions in Python appeared first on NoloWiz.

1. Improved Error Messages

Python 3.12 introduced some new improved error messages, for example, “Did you” type error messages. More informative easy to easy-to-understand error messages.

Another example considers the following Person class, the calculate method has an “age” variable :

class Person:
   def __init__(self):
       self.age = 30

   def calculate(self):
       temp = age

Person().calculate() # Calling the calculate method 

When we execute the above it will generate a nicely formatted “Did you ” error message as shown below.

2. Improved syntax error messages when importing modules

Sometimes it is common to write “import x from y” (the correct would be “from y import x“), but this incorrect import will raise a nice syntax error as shown below.

3. Improved import errors

If we are importing a function/class from a module if the imported function/class name is not correct it will suggest a similar function/class name exists in the module. See the below example, we are importing “listdir” from the os module but the import statement has a typo “from os import lstdir“. The import error shows “Did you” error.

4. The f-string improvements

Python 3.12 removes some of the old restrictions in the f-string. One interesting thing is “quote reuse”.

fruits = ["apple","orange","grapes"]
f"Fruits are {",".join(fruits)}"

Output

Fruits are apple,orange,grapes

Here the “Fruits are {“,”.join(fruits)}” quotes are reused older version of Python does not support this.

5. New override decorator

The typing module introduced a new override decorator. It can used to indicate overridden methods in derived classes.

from typing import override

class Base:
    def display(self) -> None:
        print("hello")

class Sub(Base):
    @override
    def display(self) -> None:  # Okay: overrides Base.display
        print("fine")

    @override
    def done(self) -> None:  # Error reported by type checker
        print("bad")   

6. Buffer protocol accessible in Python

The buffer protocol in Python allows direct access to the memory of an object. It provides a way to access data more efficiently by avoiding unnecessary copying. Classes that implement the __buffer__() method are now usable as buffer types.

The buffer objects can be represented by collections.abc.Buffer ABC.

7. Standard library deprecations

The distutils standard library is removed instead we can use the setuptools. The distutils is a module that provides support for building and distributing Python packages. It is recommended to use setuptools for packaging and distribution tasks.

8. Type Parameter Syntax

Python 3.12 introduces a new compact way to create generic classes/functions. Earlier it was more verbose(PEP 484).

def max[T](args: Iterable[T]) -> T:
     # logic

As we can see it is using the more compact declaration of generic function.

9. The type statement

Python 3.12 introduces a new “type” statement to declare type aliases. For example, a Point type can be declared using the type statement as shown below.

type Point = tuple[float, float]

We can also write type alias using generic type alias.

type Point[T] = tuple[T, T]

Conclusion

There you have it, these are some important new features of Python 3.12.

The post Python 3.12: Important New Features That You Should Know appeared first on NoloWiz.

Let’s dive into some of the most commonly used Python string methods:

1. str.upper() and str.lower()

The str.upper() the method used to convert a string to uppercase and str.lower() method used to convert string to lowercase.

For example :

text = "Hello, World!"
uppercase_text = text.upper()
lowercase_text = text.lower()

print(uppercase_text)  
print(lowercase_text)  

Output

HELLO, WORLD!
hello, world!

2. str.strip()

The strip() method removes leading and trailing whitespace characters (spaces, tabs, newlines) from a string. It’s particularly handy when you’re processing user input or cleaning up data.

For example :

text = "   Python String Methods   "
cleaned_text = text.strip()

print(cleaned_text) 

Output

Python String Methods

We can see that it removed leading and trailing spaces.

3. str.split()

This method splits a string into a list of substrings based on a specified delimiter. It’s frequently used for parsing text and working with CSV or TSV files.

For example :

csv_data = "John,Doe,30"
data_list = csv_data.split(',')

print(data_list)

Output

['John', 'Doe', '30']

4. str.join()

The join() method is the opposite of split(). The str.join() method is used to concatenate elements of a string iterable into a new string, using the string as a separator.

words = ["Python", "is", "awesome"]
sentence = " ".join(words)

print(sentence) 

Output

Python is awesome

5. str.replace()

The str.replace() method is used to replace occurrences of a substring within a string with a new substring. It takes two arguments: the substring to be replaced and the new substring.

For example:

text = "I love programming in JavaScript."
modified_text = text.replace("JavaScript", "Python")

print(modified_text)  

Output

I love programming in Python.

6. str.find() and str.index()

Both methods are used to search for a substring within a string.

The str.find method returns the index of the first occurrence of a substring within a string. If the substring is not found, it returns -1. It takes an optional start and end index to search within.

The str.index() method is used to find the index of the first occurrence of a substring in a string. It raises a ValueError if the substring is not found.

text = "Python is a powerful language."
position1 = text.find("is")  
position2 = text.index("Java")  # Raises ValueError

Output

7

7. str.startswith() and str.endswith()

The str.startswith() method checks if a string starts with a specified substring. It returns True if the string starts with the substring, and False otherwise. The method takes the substring as an argument and is case-sensitive.

For example:

text = "www.example.com"
starts_with_www = text.startswith("www")

Here “starts_with_www ” variable holds the True value.

The str.endswith() method checks if a string ends with a specified suffix. It returns True if the string ends with the suffix, and False otherwise.

For example :

text = "www.example.com"
ends_with_net = text.endswith("net") 

Here “ends_with_net” variable holds the False value.

Conclusion

There you have it different string methods used in Python Programming. Python String Find Substring – Check String Contains Substring.

The post Python String Methods appeared first on NoloWiz.

Python String

In Python, a string is a sequence of characters enclosed within single (‘ ‘), double (” “), or triple (”’ ”’ or “”” “””) quotes. These characters can include letters, numbers, symbols, and whitespace. Here’s a brief overview of declaring strings:

single_quoted = 'This is a single-quoted string.'
double_quoted = "This is a double-quoted string."
triple_quoted = '''This is a triple-quoted string.'''

Python treats single and double quotes equally, giving you flexibility in coding style.

Multiline strings

To create multiline strings, you can use triple quotes (”’ or “””) at the beginning and end of the string. This allows you to write the string on multiple lines without the need for escape characters.

multiline_str = """This is a multiline string.
It can span across multiple lines.
It is enclosed in triple quotes."""

print(multiline_str)

Output

This is a multiline string.
It can span across multiple lines.
It is enclosed in triple quotes.

Raw strings

Raw strings are string literals that treat backslashes(\) as literal characters, rather than escape characters. They are useful when dealing with regular expressions, file paths, and other situations where backslashes are commonly used. Raw strings are defined by prefixing the string with the letter ‘r’.

Here are some examples :

message = r'The output saved at "D:\media files\"'

print(message)

Output

The output saved at "D:\media files\"

path = r"C:\Program Files"

print(path)

Output

C:\Program Files

Basic String Operations

Let’s start with some fundamental operations for working with strings:

1. Concatenation

You can combine two or more strings using the + operator or the “join” method.:

Here is an example using the + operator :

first_name = "Super"
last_name = "Mario"
full_name = first_name + " " + last_name

print(full_name) 

Output

Super Mario

Example using the join method :

strings = ["Hello", "World"]
greeting = " ".join(strings)

print(greeting)

Output

Hello World

2. Repetition

You can replicate a string using the “*” operator:

greeting = "Hello, "
repeat_greeting = greeting * 3

print(repeat_greeting) 

Output

Hello, Hello, Hello,

3. Length

To find the length of a string, you can use the len() function:

message = "Hello Nolowiz"
length = len(message)

print(length)  

Output

13

4. Indexing

Strings are sequences, allowing you to access individual characters using indices.

text = "Python is amazing!"

print(text[0])      # Output: 'P' , indexing 

Advanced String Manipulations

Python’s string manipulation capabilities go well beyond the basics. You can use regular expressions, format strings, and more to handle complex tasks like parsing validation, and data transformation.

1. Regular Expressions

Python’s re module enables powerful string pattern matching using regular expressions. This is especially useful for tasks like email validation, text extraction, and complex string manipulation.

import re

string = "Hello, world!"
pattern = "hello"

match = re.search(pattern, string, re.IGNORECASE)
if match:
    print("Match found!")
else:
    print("Match not found.")

Output

Match found!

2. String Slicing

Extract specific parts of a string using slicing syntax like string[start:end:step].

text = "Python is amazing!"

print(text[10:14]) 

Output

amaz

3. f-Strings

Introduced in Python 3.6, f-strings allow you to embed expressions within string literals, making string formatting concise and readable:

name = "Alice"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."

print(formatted_string) 

Output

My name is Alice and I am 30 years old.

4. String Methods

Python string has built-in methods like split(), join(), replace(), strip(), etc. for advanced string operations. You can learn Python string methods here .

Conclusion

In this comprehensive guide, we’ve delved into the world of Python strings, covering the basics, common operations, essential string methods, and even advanced techniques like regular expressions and f-strings.

The post Python Strings: A Comprehensive Guide appeared first on NoloWiz.

What Are Data Types?

In programming, a data type defines the type of data that a variable can hold. It specifies the range of values that the variable can take and the operations that can be performed on it.

Python Data Types

Python, as a dynamically typed language, provides a wide range of built-in data types that can be classified into several categories:

1. Numeric Types

There are 3 types of numeric data types in Python.

• int
• float
• complex

int: Represents integers

The int data type in Python represents whole numbers without any decimal point. It can be used to perform arithmetic operations like addition, subtraction, multiplication, and division. Integers can be positive, negative, or zero. They have unlimited precision and can be created using the int() constructor or by directly assigning a value

count = 50
age = int(26) # using int constructor

float: Represents floating-point numbers

The float data type in Python represents decimal numbers. It is used to store real numbers, such as 3.14 or -0.5. Floating-point numbers can be manipulated using mathematical operations.

temperature = 29.5

Complex: Represents complex numbers

A complex data type in Python represents complex numbers, which consist of a real part and an imaginary part. Complex numbers are written in the form a + bj, where a is the real part and b is the imaginary part. Example:

complex_num = 3 + 2j

2. Boolean Type

The Python boolean data type is used to represent two values: True and False. It is commonly used in conditional statements and logical operations. Booleans are case-sensitive and must be written as True or False, with the first letter capitalized.

is_recording = False

3. Text Sequence Type

Textual data is represented by the str data type in Python.

Str: Represents strings of characters

The str data type in Python is used to represent a sequence of characters. It is immutable, it means its value cannot be changed once created. Strings can be created using single quotes double quotes or triple quotes. Various methods are available to manipulate and operate on string objects.

For example, a string created using single quotes

blog_name = 'Nolowiz'

A string created using double quotes

blog_name = "Nolowiz"

For example, a string created using triple quotes

blog_description = '''Technology tutorials,news,tips '''

4. Sequence Types

Sequence data types in Python are used to store multiple values in an ordered manner. The main sequence types are str, lists, tuples, and ranges. Different sequence data types are :

• list
• tuple
• range

List: Represents ordered, mutable sequences

The Python list data type allows you to store and manipulate a collection of items. You can add, remove, or modify elements using various methods such as append(), pop(), and insert(). Lists are mutable, meaning they can be modified after creation.

odd_numbers = [1,3,5,7]

Tuple: Represents ordered, immutable sequences

A tuple in Python is an immutable sequence data type that can store multiple elements. It is created using parentheses and elements are separated by commas. Tuples are commonly used to group related data together and can be accessed using indexing or unpacking.

numbers = (10,20,30)

Range: Represents ordered, mutable sequences

The range data type in Python is used to generate a sequence of numbers. It is commonly used in “for” loops to iterate over a specific range of values. The range function takes start, stop, and step parameters to define the sequence.

numbers = range(5)

for i in range(5):
    print(i)

This will print the numbers 0 to 4. You can read more about the range function here.

5. Mapping Type

The Python dict data type is a collection of key-value pairs, where each key is unique. It allows you to store and retrieve values based on their associated keys. Dicts are mutable and can be modified using various methods like adding, updating, or deleting key-value pairs.

To create a dictionary in Python, use curly braces {} and separate key-value pairs with colons. For example: my_dict = {'key1': 'value1', 'key2': 'value2'}. You can also use the dict() constructor or add key-value pairs using the square brackets.

For example :

person = {"name": "Alice", "age": 30}

6. Set Types

Different types of set data types are :

• set
• frozen set

Set: Represents an unordered collection of unique elements

The Python set data type allows you to store a collection of unique elements. It is mutable and unordered. You can add, remove, and perform operations like union, intersection, and difference on sets.

To create a set in Python, you can use the set() function or place items inside curly braces {}. For example:

my_set = {1, 2, 3} 

another_set = set([1,2,3])

Frozenset: Represents an immutable set

The frozenset data type in Python is an immutable version of the set data type. It is created using the frozenset() function and cannot be modified once created. It is useful for storing and manipulating unique elements, just like the set data type.

my_set = {1, 2, 3}
my_frozenset = frozen
set(my_set)print(my_frozenset)

7. Binary Sequence Types

Python supports different binary sequence types.

• bytes
• bytearray
• memoryview

Bytes: Represents a sequence of bytes

The bytes data type in Python represents a sequence of byte values. It is immutable and used to store binary data like images or network packets.

To create a bytes data type in Python, you can use the bytes() constructor or by prefixing a string with b. Here’s an example:

b_data = bytes([65, 66, 67])
print(b_data)

Output

b'ABC'

In the above example, the value of numbers([65,66,67)] must be between in range (0 to 255). So b_data = bytes([65, 66, 712]) is invalid because 712 is outside the specified range.

b_data = b'Hello'
print(b_data) 

Output

b'Hello'

Bytearray: Represents a mutable sequence of bytes

The bytearray data type in Python is a mutable sequence that represents a collection of integers ranging from 0 to 255. It allows for efficient manipulation of binary data, such as encoding and decoding.

To create a bytearray in Python, use the bytearray() constructor and pass in the desired length or an iterable object containing integers. Here’s an example:

# Creating a bytearray with length 5
my_bytearray = bytearray(5)

# Creating a bytearray from a list of integers
my_bytearray = bytearray([1, 2, 3, 4, 5])

Memoryview: Allows you to access the underlying memory of an object

The memoryview data type in Python allows direct access to the internal memory of an object, such as a bytearray. It provides a way to view and manipulate the data without creating a new copy.

To create a memoryview object in Python, you can use the memoryview() function. It takes an object that supports the buffer protocol as an argument. Here’s an example of using memoryview with a bytearray:

data = bytearray(b'Hello, world!')
view = memoryview(data)
print(view[7:12])

Please note that memoryview requires objects that support the buffer protocol.

8. None Type

The Python None data type represents the absence of a value. It is often used to indicate that a variable or function does not have a specific value. For example, x = None assigns the variable x to the value None.

Type Conversion

Python allows you to convert between different data types, either implicitly or explicitly. Implicit conversion occurs automatically when Python converts one type to another to perform an operation, while explicit conversion is done explicitly by the programmer using functions like int(), str(), or float().

# Implicit conversion
result = 5 + 2.0  # int + float = float
print(result)     # Output: 7.0

# Explicit conversion
number = "42"
number = int(number)  # Convert string to int
print(number)         # Output: 42

Python data types can be listed as a table :

Conclusion

Data types are the foundation of Python programming, enabling you to work with various kinds of data effectively.

The post A Deep Dive into Python Data Types appeared first on NoloWiz.

Why are Comments Important?

Comments are lines of text in your code that the Python interpreter ignores. They exist solely to provide human-readable explanations of the code’s functionality, logic, or any other relevant information. They act as a form of documentation, helping developers grasp the intent behind the code without having to decipher every line.

Types of Comments

There are two types of comments in Python :

1. Single-line comment
2. Multi-line comment

1. Single-line comments

These are comments that appear on a single line and are used to annotate a specific line of code. They begin with the # symbol and continue until the end of the line.

# This is a single-line comment

However, the below code is not a comment even though it has a # symbol.

text = "# This is not a comment because it's inside quotes."

2. Multi-line comments

Multi-line comments in Python can be written using triple quotes (”’ ”’) or triple double quotes (“”” “””). This allows you to write multiple lines of comments without using the # symbol at the beginning of each line.

"""
This is a 
multi-line comment in 
Python programming
"""

Multi-line comment with triple quotes example :

'''
This is a another
multi-line comment in 
Python programming using the triple quotes 
'''

When to Use Comments

1. Complex algorithms: If you’re implementing a complex algorithm or logic, comments can help break down the steps and provide insights into the thought process.
2. Workarounds or hacks: If you’re using a workaround or a less-than-ideal solution due to constraints, explain the reason in a comment.
3. Important decisions: Comments are valuable for explaining design decisions, especially when multiple options are considered before settling on a particular approach.
4. Potential pitfalls: If a piece of code has potential pitfalls or edge cases, use comments to highlight these areas.

Conclusion

In conclusion, Python comments are a very effective tool for writing clean and comprehensible code. You can read about Python docstrings, format, and examples.

The post Comments in Python Code appeared first on NoloWiz.

Python variables declaration

In Python, a variable is essentially a name that refers to a value stored in memory. Unlike some other programming languages, you don’t need to declare the type of a variable explicitly; Python does this for you.

To declare a variable in Python, use the assignment operator (=) followed by the variable name. For example, age = 25 declares a variable named “age” and assigns it the value 25.

age = 25

In Python, variables are dynamically typed, which means you don’t need to explicitly declare their type. You simply assign a value to a variable, and Python will automatically determine its type based on the value you provide. Here’s how you declare and assign values to variables in Python:

# Assigning values to variables
name = "Alice"           # String
age = 25                 # Integer
height = 5.8             # Float
is_student = True         # Boolean
grades = [85, 90, 78]    # List
coordinates = (10, 20)   # Tuple
person = {"name": "Bob", "age": 30}  # Dictionary
unique_numbers = {1, 2, 3}  # Set

Naming Conventions

Python has some rules and guidelines for naming variables:

1. Use lowercase letters for Python variables.
2. Python variable names cannot start with a number.
3. A variable name can only contain alphanumeric characters and underscores (A-z, 0-9, and _).
4. Separate words with underscores (snake_case).
5. Avoid using reserved words (e.g., “print”, “if”, “for”).
6. Use descriptive names that indicate the variable’s purpose.
7. Constants are typically written in uppercase (e.g., “MAX_VALUE”).
8. Don’t use abbreviations.

Data Types

Python variables can hold various types of data, including:

1. Integers: Whole numbers without decimal points, e.g., age = 25.
2. Floats: Numbers with decimal points, e.g., pi = 3.14.
3. Strings: Sequences of characters, e.g., name = "Alice".
4. Booleans: Represents either True or False values, e.g., is_valid = True.
5. Lists: Ordered collections of items, e.g., numbers = [1, 2, 3, 4, 5].
6. Tuples: Similar to lists, but immutable, e.g., coordinates = (10, 20).
7. Dictionaries: Key-value pairs, e.g., person = {"name": "Bob", "age": 30}.
8. Sets: Unordered collections of unique items, e.g., unique_numbers = {1, 2, 3}.

Best Practices

To write clean and maintainable code, it’s important to follow some best practices when working with variables in Python:

1. Descriptive Names: Choose meaningful variable names that reflect the purpose of the variable. For example, use total_students instead of just count.
2. Consistent Casing: Stick to a consistent naming convention. Many Python developers prefer using lowercase letters and underscores (snake_case) for variable names.
3. Initialize Variables: Always initialize variables before using them to avoid unexpected behavior.
4. Avoid Magic Numbers: Instead of using raw numbers in your code, assign them to variables with descriptive names. This improves code readability and makes maintenance easier (e.g.: MAX_VALUE = 100).
5. Use Comments: If a variable’s purpose might not be immediately obvious, provide comments to explain its significance and usage.

Python Global variables

A Python global variable is a variable that can be accessed and modified from any part of a program. It is defined outside of any function and can be used throughout the entire program. Global variables can be useful for storing data that is needed across different functions or modules. Here is an example :

greeting = "Hello"

def display_message():
  print( greeting + " nolowiz" )

display_message()

Output

Hello nolowiz

In the above code, the variable “greeting” is a global variable.

What happens if the same variable name is inside the function?

In the below example, the global variable name(Line number: 1) and variable( Line number: 4) inside the display_message function have the same name.

greeting = "Hello"

def display_message():
  greeting = "Hi"
  print( greeting + " nolowiz" )

display_message()

print(greeting + " nolowiz")

Output

Hi nolowiz
Hello nolowiz

So the “greeting” variable inside the display_message function is a local variable. However the global variable ( Line number: 1) value remains the same.

The global Keyword

The global keyword in Python is used to declare a variable as global within a function, allowing it to be accessed and modified outside the function. It is used to differentiate between local and global variables with the same name.

x = 10

def update_value():
    global x
    x = 20
    
print(x)  # Output: 10

update_value()

print(x)  # Output: 20

Here global variable x is modified inside the update_value function using the global keyword.

Output

10
20

Conclusion

In conclusion, variables are fundamental components of any programming language, and Python’s approach to variables adds a layer of simplicity and versatility to the coding experience. Read about the basics of a Python program.

The post Understanding Python Variables: A Comprehensive Guide appeared first on NoloWiz.