Python List Vs Tuple

by

Python List Vs Tuple

Introduction

Python offers a wide range of data structures to store and manipulate collections of data. Two commonly used data structures are lists and tuples. Both lists and tuples are sequences that can hold multiple elements, but they have distinct characteristics and use cases.

List

In Python, a list is a versatile and fundamental data structure that serves as a collection of elements in a specific order. It allows you to store multiple values of different data types, such as numbers, strings, or even other lists, within a single container. Lists are enclosed within square brackets [ ] and elements inside the list are separated by commas.

Examples of a List:

numbers = [1, 2, 3, 4, 5]

#Example 2: A list of strings
fruits = ["apple", "banana", "cherry", "date"]

#Example 3: A mixed list containing different data types
mixed_list = [42, "hello", 3.14, True]

Tuple

In Python, a tuple is an ordered and immutable collection of elements. It is a data structure that allows you to store multiple items of different data types within a single object. Tuples are defined using parentheses () and can hold elements separated by commas. Once a tuple is created, its elements cannot be changed or modified, making it an immutable data type.

Example of a Tuple:

# Example 1: A tuple of integers
numbers = (1, 2, 3, 4, 5)

# Example 2: A tuple of strings
fruits = ("apple", "banana", "cherry", "date")

# Example 3: A mixed tuple containing different data types
mixed_tuple = (42, "hello", 3.14, True)

Main Differences between Lists and Tuples:

  1. Mutability:

List: Lists are mutable, meaning you can modify their elements after creation. You can add, remove, or change elements within a list.

Tuple: Tuples, on the other hand, are immutable. Once a tuple is created, its elements cannot be modified. You cannot add, remove, or change elements in a tuple.

# List example
my_list = [1, 2, 3]
my_list[0] = 10  # Modify an element
my_list.append(4)  # Add an element
my_list.remove(2)  # Remove an element
print(my_list)  # Output: [10, 3, 4]
------------------------------------------------------
# Tuple example
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # This will raise a TypeError
# my_tuple.append(4)  # This will raise an AttributeError
print(my_tuple)  # Output: (1, 2, 3)
  1. Syntax:

List: Lists are enclosed in square brackets [ ]. Elements inside the list are separated by commas.

Tuple: Tuples are enclosed in parentheses ( ). Elements inside the tuple are separated by commas.

# List Example
my_list = [10, 20, 30, 40]  # A list of integers
names = ["Alice", "Bob", "Charlie"]  # A list of strings
mixed_list = [1, "hello", 3.14]  # A mixed list
-------------------------------------------------------------
# Tuple Example
my_tuple = (10, 20, 30, 40)  # A tuple of integers
names_tuple = ("Alice", "Bob", "Charlie")  # A tuple of strings
mixed_tuple = (1, "hello", 3.14)  # A mixed tuple
  1. Performance:

List: Lists might have slightly lower performance compared to tuples due to their mutability. Modifying a list can require resizing and memory allocation.

Tuple: Tuples, being immutable, have better performance than lists, especially in scenarios where elements remain constant.

import time

# Creating a list and a tuple
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

# Measuring access time for the list
start_time = time.time()
for _ in range(1_000_000):
    _ = my_list[2]  # Accessing the third element
list_time = time.time() - start_time

# Measuring access time for the tuple
start_time = time.time()
for _ in range(1_000_000):
    _ = my_tuple[2]  # Accessing the third element
tuple_time = time.time() - start_time

# Printing results
print(f"List Access Time: {list_time:.6f} seconds")
print(f"Tuple Access Time: {tuple_time:.6f} seconds")
  1. Use Cases:

List: Lists are ideal when you need to store collections of items that can change over time, such as dynamic data or mutable sequences.

Tuple: Tuples are suitable for situations where you want to ensure data remains constant and unchangeable, like storing coordinates, configuration settings, or database records.

Similarities Between List and Tuple:

  1. Ordered Collection: Both lists and tuples are ordered collections, meaning the elements are stored in a specific sequence, and the order of elements is preserved.
  2. Indexing: Both lists and tuples use indexing to access individual elements. Indexing starts from 0 for the first element, 1 for the second element, and so on.
  3. Heterogeneous Elements: Both lists and tuples can store elements of different data types, such as integers, floats, strings, or even other lists or tuples.
  4. Iterable: Both lists and tuples are iterable, allowing you to loop over the elements using a `for` loop or perform various operations on each element.

Examples:

# List and Tuple with similar data
my_list = [1, 2, 3, "apple", 3.14]
my_tuple = (1, 2, 3, "apple", 3.14)

# Accessing elements by index
print(my_list[1])  # Output: 2
print(my_tuple[1])  # Output: 2

# Slicing
print(my_list[1:4])  # Output: [2, 3, 'apple']
print(my_tuple[1:4])  # Output: (2, 3, 'apple')

# Iteration
for item in my_list:
    print(item, end=" ")  # Output: 1 2 3 apple 3.14 

print()  # Line break

for item in my_tuple:
    print(item, end=" ")  # Output: 1 2 3 apple 3.14

Python Functions

by

Python Function Introduction

A function in Python is a block of reusable code that performs a specific task. Functions help organize code, reduce repetition, and improve readability.

1. Why Use Functions?

✔ Avoid repeating code
✔ Break large programs into small logical pieces
✔ Improve readability and maintainability
✔ Make code scalable and easier to debug

2. Defining and Calling a Function

Syntax

def function_name(parameters):
    # code block
    return value

Example

def greet():
    print("Hello, welcome to Python!")
    
greet()     # Calling the function

3. Function with Parameters (Arguments)

def greet_user(name):
    print("Hello", name)

greet_user("John")

Output

Hello John

4. Function with Return Value

def add(x, y):
    return x + y

result = add(10, 5)
print(result)

Output

15

5. Default Parameters

If no value is passed, default will be used.

def info(country="India"):
    print("I am from", country)

info()
# output :   I am from India

info("Japan")
# output : I am from Japan

6. Keyword Arguments

Arguments can be passed using the parameter name.

def student(name, age):
    print(name, "is", age, "years old")

student(age=21, name="Riya")

# Output :  Riya is 21 year old.

7. Arbitrary Arguments (*args)

Used when you don’t know how many arguments will be passed.

def total_marks(*marks):
    print("Total:", sum(marks))

total_marks(80, 75, 90, 60)

# Output :  Total : 305

8. Arbitrary Keyword Arguments (**kwargs)

Accepts key-value pairs (dictionary-like).

def profile(**details):
    for key, value in details.items():
        print(key, ":", value)

profile(name="Amit", age=25, city="Delhi")

# Output :

name : Amit
age : 25
city : Delhi

9. Lambda (Anonymous) Functions

Short, one-line functions without a name.


square = lambda x: x * x
print(square(6))

# Output : 36

10. Nested Functions

Function inside another function.

def outer():
    print("Outer Function")
    
    def inner():
        print("Inner Function")
    
    inner()

outer()

11. Recursion (Function Calling Itself)

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5)) 

# Output : 120

12. Passing a Function as an Argument

def apply(func, value):
    return func(value)

def double(x):
    return x * 2

print(apply(double, 4))   # Output: 8

Best Practices

PracticeDescription
Use meaningful namescalculate_total() is better than ct()
Keep functions shortOne task per function
Document your functionWrite comments or use docstrings
Avoid global variablesPrefer passing parameters

Docstring Example

def multiply(a, b):
    """Returns the product of two numbers"""
    return a * b

print(multiply.__doc__)

Python Dictionary

by

Python Dictionary Introduction

Python dictionaries are a built-in data type used to store key-value pairs. They are mutable and allow for efficient retrieval and manipulation of data. Dictionaries are defined using curly braces ({}) and contain comma-separated key-value pairs. Here’s an example:

person = {
    "name": "Yash",
    "age": 23,
    "occupation": "Architect"
}

In this example, “name”, “age”, and “occupation” are the keys, and “Yash”, 23, and “Architect” are the corresponding values. The keys must be unique within a dictionary, but the values can be of any data type.

You can access the values in a dictionary by using the corresponding key:


print(person["name"])  # Output: Yash
print(person["age"])  # Output: 23
print(person["occupation"])  # Output: Architect

Features of Python Dictionary:

  1. Key-Value Pairs: Python dictionaries are a collection of key-value pairs, where each key is unique and associated with a value.
  2. Mutable: Dictionaries are mutable, which means you can modify, add, or remove key-value pairs after the dictionary is created.
  3. Dynamic Sizing: Dictionaries in Python can dynamically resize to accommodate an arbitrary number of key-value pairs.
  4. Unordered: Dictionaries are unordered, meaning the items are not stored in any particular order.
  5. Efficient Data Retrieval: Dictionaries provide fast and efficient data retrieval based on the key.
  6. Various Data Types: Python dictionaries can store values of any data type, including integers, floats, strings, lists, tuples, other dictionaries, and even custom objects. This flexibility allows you to organize and structure data in a way that suits your specific needs.
  7. Membership Testing: Dictionaries provide efficient membership testing using the `in` operator. You can check if a key exists in a dictionary without iterating over all the items, making it convenient for conditional operations.
  8. Uniqueness of Keys: Python dictionary keys must be unique. This property ensures that each key is associated with a single value, preventing duplicate entries

Python Dictionary Functions/Methods:

  1. `len()` function: Returns the number of key-value pairs in a dictionary.

dictionary = {"name": "Yash", "age": 23}
print(len(dictionary))  # Output: 2
  1. `keys()` method: Returns a view object that contains all the keys in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
keys = dictionary.keys()
print(keys) 
# Output: dict_keys(['name', 'age', 'occupation'])
  1. `values()` method: Returns a view object that contains all the values in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
values = dictionary.values()
print(values)  
# Output: dict_values([Yash, 22,Architect])
  1. `items()` method: Returns a view object that contains all the key-value pairs as tuples in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
items = dictionary.items()
print(items)  # Output: dict_items([('name', 'Yash'), ('age',23), ('occupation', 'Architect')])
  1. `get()` method: Returns the value associated with a given key. It allows specifying a default value to be returned if the key is not found.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print(dictionary.get("name"))         # Output: Yash
print(my_dict.get("city", "N/A"))  # Output: N/A (default value for non-existent key)
  1. `pop()` method: Removes and returns the value associated with a given key. It takes the key as an argument and removes the corresponding key-value pair from the dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
removed_value = dictionary.pop("age")
print(removed_value)  # Output : 25
print(dictionary)        # Output: {'name': 'Yash', 'occupation': 'Architect'}
  1. `update()` method: Merges the key-value pairs from another dictionary into the current dictionary. If a key already exists, the value is updated; otherwise, a new key-value pair is added.

dictionary = {"name": "Yeah", "age": 23}
new_dict = {"occupation": "Architect", "city": "Pune"}
dictionary.update(new_dict)
print(dictionary)  # Output: {'name': 'Yash', 'age': 23, 'occupation': 'Architect', 'city': 'Pune'}
  1. `clear()` method: Removes all key-value pairs from a dictionary, making it empty.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
dictionary.clear()
print(dictionary)  # Output: {}

Python Dictionary operators:

  1. Membership Operators:

   – `in` operator: Returns `True` if a key exists in the dictionary, otherwise `False`.

   – `not in` operator: Returns `True` if a key does not exist in the dictionary, otherwise `False`.


dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print("name" in dictionary)           # Output: True
print("Company" not in dictionary)       # Output: True
print("age" in dictionary.keys())     # Output: True
print("Engineer" in dictionary.values())  # Output: False
  1. Comparison Operators:

   – `==` operator: Returns `True` if two dictionaries have the same key-value pairs, otherwise `False`.

   – `!=` operator: Returns `True` if two dictionaries have different key-value pairs, otherwise `False`.


dict1 = {"name": "Yash", "age": 23}
dict2 = {"age": 23, "name": "Yash"}

print(dict1 == dict2)  # Output: True (order of key-value pairs doesn't matter)
print(dict1 != dict2)  # Output: False (key-value pairs are the same)
  1. Assignment Operator:

   – `=` operator: Assigns a dictionary to a variable.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
  1. Deletion Operator:

   – `del` operator: Deletes an entire dictionary or a specific key-value pair.


dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
del dictionary ["age"]
print(dictionary)  # Output: {'name': 'Yash', 'occupation': 'Architect'}

Python Set

by

Python Set Introduction:

In Python, a set is an unordered collection of unique elements. Sets are mutable and can be modified using various methods.

Creating Sets:

To create a set in Python, you can use curly braces `{}` or the built-in `set()` function. Here’s an example.

				
# Using curly braces
my_set = {1, 2, 3, 4, 5}

# Using set() function
my_set = set([1, 2, 3, 4, 5])

Features of Python Set:

  1. Uniqueness: Sets are collections of unique elements. Each element appears only once in a set. If you try to add a duplicate element, it will be ignored.
  2. Mutable: Sets are mutable, meaning you can modify them by adding or removing elements after they are created.
  3. Unordered: Sets are unordered collections, which means the elements are not stored in any particular order. You cannot access elements by indexing or slicing.
  4. Creation: Sets can be created using curly braces `{}` or the built-in `set()` function. For example.
				
my_set = {1, 2, 3}  # Using curly braces

my_set = set([1, 2, 3])  # Using set() function

5. Membership Testing: Sets provide an efficient way to test if an element exists in a set using the `in` operator. This operation has a constant-time complexity compared to lists or tuples.

				
my_set = {1, 2, 3}
print(1 in my_set)  # Output: True
print(5 in my_set)  # Output: False

6. Iteration: You can iterate over the elements of a set using a `for` loop, which will visit each element in an arbitrary order.

my_set = {1, 2, 3}
for element in my_set:
    print(element)

Deleting Python set:

In Python, you can delete a set using the `del` keyword. Here’s an example of how to delete a set. Here’s an example:

				
my_set = {1, 2, 3, 4, 5}
# Deleting the set
del my_set

# Trying to access the set after deletion will raise an error
print(my_set)  # Raises NameError: name 'my_set' is not defined

In the example above, the `del` keyword is used to delete the `my_set` variable, which contains the set. After deleting the set, any attempt to access or use the set will result in a `NameError` because the set no longer exists.

Python Set operators:

  1. Union: The union of two sets `A` and `B` contains all unique elements from both sets. In Python, you can perform the union operation using the `union()` method or the `|` operator.
				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1.union(set2)  # Using method
union = set1 | set2  # Using operator
print(union)  # Output: {1, 2, 3, 4, 5}
  1. Intersection: The intersection of two sets `A` and `B` contains only the elements that are common to both sets. In Python, you can perform the intersection operation using the `intersection()` method or the `&` operator.
				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection = set1.intersection(set2)  # Using method
intersection = set1 & set2  # Using operator
print(intersection)  # Output: {3}
  1. Difference: The difference between two sets `A` and `B` contains the elements that are in `A` but not in `B`. In Python, you can perform the difference operation using the `difference()` method or the `-` operator.
				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference = set1.difference(set2)  # Using method
difference = set1 - set2  # Using operator
print(difference)  # Output: {1, 2}
  1. Symmetric Difference: The symmetric difference of two sets `A` and `B` contains the elements that are in either `A` or `B`, but not both. In Python, you can perform the symmetric difference operation using the `symmetric_difference()` method or the `^` operator.
				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference = set1.symmetric_difference(set2)  # Using method
symmetric_difference = set1 ^ set2  # Using operator
print(symmetric_difference)  # Output: {1, 2, 4, 5}

Python Set functions:

  1. len(): The `len()` function returns the number of elements in a set.
		
my_set = {1, 2, 3, 4, 5, 6}
length = len(my_set)
print(length)  # Output: 6
  1. add(): The `add()` method adds an element to a set.
		
my_set = {1, 2, 3, 4}
my_set.add(5)
print(my_set)  # Output: {1, 2, 3, 4, 5}
  1. remove(): The `remove()` method removes an element from a set. It raises a KeyError if the element does not exist in the set.
				
my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)  # Output: {1, 2, 4}
  1. discard(): The `discard()` method removes an element from a set if it exists. It does not raise an error if the element is not found.
				
my_set = {1, 2, 3, 4}
my_set.discard(4)
print(my_set)  # Output: {1, 2, 3}
  1. pop(): The `pop()` method removes and returns an arbitrary element from the set. Since sets are unordered, the popped element is not guaranteed to be the first or last element.
my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)  # Output: a random element, e.g., 1
print(my_set)  # {2, 3, 4}
  1. clear(): The `clear()`method removes all elements from a set, making it empty.
				
my_set = {1, 2, 3, 4}
my_set.clear()
print(my_set)  # Output: set()
  1. copy(): The `copy()` method creates a shallow copy of a set, allowing you to work with a separate copy of the original set.
				
my_set = {1, 2, 3}
my_set_new = my_set.copy()
print(my_set_new)  # Output: {1, 2, 3}

Python Tuple

by

Python Tuple Tutorial

Introduction:

Python tuples are a data structure used to store an ordered collection of elements. Unlike lists, tuples are immutable, meaning their values cannot be changed once created. This can be useful in situations where you want to ensure that data is not accidentally modified. Tuples are also hash able, which means they can be used as keys in dictionaries.

Creating a Tuple:

Tuples can be created using parentheses, with elements separated by commas (,) and also bu using tuple() keyword. Here’s an example.

				
					tup = (1,2,3,4)
print(tup) # Output : (1,2,3,4)

tup = tuple(1,2,3,4)
print(tup) # Output : (1,2,3,4)

Features of python tuple:

A tuple is an immutable sequence in Python that can contain elements of different data types. Here are the key features of a Python tuple:

  • 1). Immutable: Once created, a tuple cannot be modified. You cannot add, remove, or modify elements in a tuple. This immutability ensures data integrity and allows tuples to be used as keys in dictionaries.
  • 2). Ordered : Elements in a tuple are ordered and maintain their positions. The order of elements in a tuple is preserved, and you can access them using their indices.
  • 3). Heterogeneous Data Types : A tuple can store elements of different data types. For example, you can have a tuple containing an integer, a string, and a float.
  • 4). Indexing and Slicing : You can access individual elements of a tuple using their indices. Tuples support both positive and negative indexing, where negative indices count from the end of the tuple. Slicing allows you to extract a portion of the tuple by specifying a range of indices.
  • 5). Iteration : Tuples can be iterated over using loops. This allows you to access each element in the tuple sequentially.
  • 6). Hashability : Tuples are hashable, which means they can be used as keys in dictionaries and elements in sets. This property is due to their immutability.
  • 7). Nesting : Tuples can be nested inside other tuples. This allows you to create complex data structures using tuples.
  • 8). Size Efficiency : Tuples are more memory-efficient compared to lists because they are immutable. This makes tuples a suitable choice when you have a fixed collection of elements that won’t change.
  • 9). Function Arguments and Return Values : Tuples are often used to pack multiple values together and pass them as arguments to functions or return multiple values from a function.
  • 10). Tuple Packing and Unpacking: You can pack multiple values into a tuple using a comma-separated list of values. Similarly, you can unpack a tuple by assigning its elements to individual variables.

Advantages of python tuple:

  1. Immutability:

Tuples in Python are immutable, meaning once created, their elements cannot be modified. This immutability provides several advantages. Firstly, it ensures data integrity by preventing accidental modification of elements. This is particularly useful in scenarios where data should remain constant, such as configuration settings or constant lookup tables. Secondly, immutability allows tuples to be used as keys in dictionaries, as they provide a stable and unchangeable identity. This makes tuples a suitable choice for scenarios where immutability is desired.

  1. Performance Efficiency:

Tuples are more memory-efficient than lists in Python. Since tuples are immutable, they are stored more compactly in memory compared to lists, which can dynamically resize as elements are added or removed. This efficiency can be beneficial when dealing with large collections of data or in scenarios where memory optimization is crucial. Additionally, accessing elements in tuples is generally faster than accessing elements in lists since tuples have a simpler internal structure.

  1. Tuple Packing and Unpacking:

Python tuples support a convenient feature called tuple packing and unpacking. Tuple packing allows you to create tuples by grouping multiple values together. Unpacking, on the other hand, allows you to assign elements of a tuple to individual variables. This feature makes tuples useful in scenarios where you need to return multiple values from a function or swap variable values efficiently. It provides a concise and intuitive way to work with multiple elements simultaneously.

  1. Sequence Operations:

Tuples support sequence operations such as indexing and slicing, similar to lists and strings. This allows you to access specific elements or extract subsets of elements from a tuple efficiently. Additionally, tuples support iteration using loops, making them iterable data structures. This flexibility in sequence operations makes tuples suitable for various use cases, such as iterating over collections, accessing elements by index, or performing operations on specific subsets of data.

  1. Hashability and Uniqueness:

Tuples in Python are hashable, meaning they can be used as keys in dictionaries or elements in sets. This is because tuples are immutable and their hash value remains constant. This property enables efficient lookup and retrieval of data when using tuples as keys or elements. Additionally, tuples can preserve uniqueness, allowing you to store unique combinations of elements in a collection.

Disadvantages of python tuple:

  1. Immutability:

One of the primary disadvantages of tuples is their immutability. Once a tuple is created, its elements cannot be modified. While immutability provides data integrity and stability, it can be restrictive in scenarios where dynamic changes to data are required. If you need to add, remove, or modify elements frequently, a tuple might not be the most suitable data structure. In such cases, mutable data structures like lists might be more appropriate.

  1. Limited Mutability:

While tuples are immutable as a whole, they can contain mutable objects as elements. This means that if a tuple contains mutable objects like lists or dictionaries, those objects can be modified even though the tuple itself cannot be changed. However, care must be taken when modifying mutable objects within a tuple to avoid unexpected behavior or inadvertent modifications.

  1. Lack of Flexibility:

Compared to lists, tuples have limited flexibility. Tuples do not provide built-in methods for adding or removing elements, sorting, or reversing. These operations require converting the tuple to a list, performing the operation, and then converting it back to a tuple. This extra step can be cumbersome and less efficient compared to directly manipulating lists. If you anticipate frequent modifications or dynamic operations on your data, using lists might offer more flexibility.

  1. Inefficient for Large-Scale Modifications:

Due to their immutability, modifying a tuple requires creating a new tuple with the desired modifications. This process can be inefficient and memory-consuming when dealing with large-scale modifications. In such cases, mutable data structures like lists, where elements can be modified in-place, can provide better performance.

  1. Limited Data Analysis Capabilities:

Tuples are not well-suited for complex data analysis tasks or mathematical operations. While they can store numeric values, tuples lack built-in mathematical functions and libraries commonly used for advanced calculations or statistical operations. If your application requires extensive data analysis, other data structures like NumPy arrays or pandas DataFrames might be more suitable.

Deleting python tuple:

In Python, tuples are immutable data structures that allow you to store a collection of elements. Once created, a tuple cannot be modified. However, there may be scenarios where you need to delete a tuple or remove it from memory. In this article, we will explore different techniques to effectively delete a tuple in Python, considering the immutability of tuples.

Tuple Immutability:

Tuples in Python are immutable, meaning their elements cannot be modified or removed individually. This property ensures data integrity and enables tuples to be used as keys in dictionaries. However, it also implies that we cannot directly delete or modify elements within a tuple. Instead, we need to adopt alternative approaches to achieve the desired outcome.

Method 1: Using the “del” keyword:

One way to delete a tuple is by using the `del` keyword. While it cannot delete individual elements within a tuple, it can remove the entire tuple object from memory. Here’s an example:

				
					my_tup = (1, 2, 3, 4)
del my_tup

In this method, the `del` keyword is used to delete the reference to the tuple.

Method 2: Reassigning the tuple variable:

Another approach to “delete” a tuple is by reassigning the variable that references it. By assigning a new value to the variable, the old tuple becomes unreachable and eligible for garbage collection. Here’s an example:

				
					my_tup = (1, 2, 3, 4)
my_tup = ()

In this method, an empty tuple is assigned to the variable `my_tup`, effectively replacing the original tuple.

Indexing in python tuple:

In Python, tuples are immutable sequences that allow you to store a collection of elements. Indexing is a fundamental operation that enables you to access individual elements within a tuple.

Understanding Tuple Indexing:

Tuples in Python are ordered collections, meaning the elements maintain a specific order. Each element in a tuple is assigned an index, starting from 0 for the first element. Indexing allows you to retrieve individual elements based on their position within the tuple.

Accessing Elements using Positive Indexing:

Positive indexing is the most common way to access elements in a tuple. It involves using the index value starting from 0 and incrementing by one for each subsequent element.  Here’s an example:

				
					my_tup = (1, 2, 3, 4)
print(my_tuple[0])  # Accessing the first element i.e. 1
print(my_tuple[2])  # Accessing the third element i.e. 3

In this case, my_tup[0] retrieves the first element 1, and my_tup[2] retrieves the third element 2 from the tuple.

Accessing Elements using Negative Indexing:

Python also supports negative indexing, where the index counts from the end of the tuple. The last element has an index of -1, the second-to-last element has an index of -2, and so on. Negative indexing provides a convenient way to access elements from the end of the tuple. Here’s an example:

				
					my_tup = (1, 2, 3, 4)
print(my_tuple[-1])  # Accessing the last element i.e. 4
print(my_tuple[-2])  # Accessing the second last element i.e. 3

In this example, `my_tup[-1]` retrieves the last element 4, and `my_tup[-2]` retrieves the second last element 3 from the tuple.

Slicing in Python Tuples:

Understanding Tuple Slicing:

Slicing is a way to extract a portion of a sequence by specifying a range of indices. It is particularly useful when you want to work with a subset of elements within a tuple. The syntax for slicing is `start:stop:step`, where `start` is the starting index, `stop` is the ending index (exclusive), and `step` is the increment value.

Basic Slicing:

To perform a basic slice, you only need to provide the `start` and `stop` indices. This will extract the elements from the starting index up to, but not including, the ending index. Here’s an example:

				
					tup = (1, 2, 3, 4, 5)
print(tup[1:4])  # Extracting elements from index 1 to 3

In this case, the slice `tup[1:4]` retrieves elements with indices 1, 2, and 3, resulting in the tuple (2, 3, 4).

Step Value in Slicing:

You can also specify a step value to skip elements during the slice. The step value determines the increment between successive elements. Here’s an example:

				
					tup = (1, 2, 3, 4, 5)
print(tup[::3])  # Extracting every third element

In this example, the slice `tup[::3]` extracts elements with a step size of 3, resulting in the tuple (1, 5).

Negative Indices in Slicing:

Python allows the use of negative indices in slicing. Negative indices count from the end of the tuple. This can be useful when you want to extract elements from the end. Here’s an example:

				
					tup = (1, 2, 3, 4, 5)
print(tup[-4:-1])  # Extracting elements from index -4 to -2

In this case, the slice `tup [-3:-1]` retrieves elements with indices -4 and -2, resulting in the tuple (2, 3, 4).

Combining Slicing Techniques:

You can combine different slicing techniques to create more complex slices. Here’s an example:

				
					tup = (1, 2, 3, 4, 5)
print(tup[0:5:2])  # Extracting elements from index 0 to 4 with a step size of 2

In this example, the slice `tup [0:5:2]` extracts elements with indices 0, 2 and 4 resulting in the tuple (1, 3, 5).

Python tuple operators:

  1. Concatenation Operator (+):

The concatenation operator (+) allows you to combine two tuples to create a new tuple. It produces a new tuple that includes all the elements from both tuples, maintaining their order. Here’s an example:

				
					tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
concatenated_tuples = tup1 + tup2

In this case, the `concatenated_tuples` will be (1, 2, 3, 4, 5, 6), resulting from the concatenation of `tup1` and `tup2`.

  1. Repetition Operator (*):

The repetition operator (*) allows you to create a new tuple by repeating the elements of an existing tuple a specified number of times. It produces a new tuple that contains the repeated elements. Here’s an example:

				
					tup = (1, 2, 3)
repeated_tup = tup * 2

In this example, the `repeated_tup` will be (1, 2, 3, 4, 1, 2, 3, 4), as the elements of `tup ` are repeated two times.

  1. Comparison Operators (==, !=, <, >, <=, >=):

You can use comparison operators to compare tuples based on their elements. The comparison is performed element-wise, starting from the first element. Here’s an example:

				
					tup1 = (1, 2, 3, 4)
tup2 = (5, 6, 7, 8)
print(tuple1 < tuple2)  # Output: True

In this case, the `<` operator compares the first element of `tup1` with the first element of `tup2` and returns True because 1 is less than 4.

  1. Membership Operators (in, not in):

Membership operators allow you to check if an element is present in a tuple or not. The `in` operator returns True if the element exists in the tuple, while the `not in` operator returns True if the element does not exist. Here’s an example:

				
					tup = (1, 2, 3)
print(1 in tup)      # Output: True
print(5 not in tup)  # Output: True

In this example, the first statement returns True as 1 is present in `tup `, while the second statement returns True as 5 is not present.

Python tuple functions:

  1. len():

The `len()` function allows you to determine the length or size of a tuple. It returns the number of elements present in the tuple. Here’s an example:

				
					tup = (1, 2, 3, 4)
tuple_length = len(tup)
print(tuple_length)  # Output: 4

In this case, `len(tup)` returns 4, as `tup ` contains four elements.

  1. min() and max():

The `min()` and `max()` functions allow you to find the minimum and maximum values, respectively, within a tuple. Here’s an example:

				
					tup = (1, 2, 3, 4, 5, 6)
minimum_value = min(tup)
maximum_value = max(tup)
print(minimum_value)  # Output: 1
print(maximum_value)  # Output: 6

In this example, `min(tup)` returns the minimum value of 1, while `max(tup)` returns the maximum value of 6.

  1. sum():

The `sum()` function allows you to calculate the sum of all the elements within a tuple. It works for tuples that contain elements that are numeric. Here’s an example:

				
					tup = (1, 2, 3, 4)
total = sum(tup)
print(total)  # Output: 10

In this case, `sum(tup)` returns 10, which is the sum of all the elements in `tup `.

  1. sorted():

The `sorted()` function returns a new sorted list containing all the elements from a tuple. Here’s an example:

				
					tup = (5, 2, 4, 3, 1)
sorted_list = sorted(tup)
print(sorted_list)  # Output: `[1, 2, 3, 4, 5]

In this example, `sorted(tup)` returns a sorted list `[1, 2, 3, 4, 5]` while leaving the original tuple unchanged.

  1. count():

The `count()` function allows you to count the occurrences of a specific element within a tuple. It returns the number of times the element appears. Here’s an example:

				
					tup = (1, 1, 2, 3, 2, 4, 1)
element_count = tup.count(1)
print(element_count)  # Output: 3

In this case, `tup.count(1)` returns 3, as the value 1 appears three times within `tup `.

Python List

by

Python List Introduction:

Lists are one of the most commonly used data structures in Python. A list is a collection of elements, which can be of any type, including numbers, strings, and other lists etc. Lists are mutable, which means you can make changes in the list by adding, removing, or changing elements.

List declaration:

To declare a list in Python, you can use square brackets [] and separate the elements with commas. Here’s an example:

new_list = [ 1, 2, 3, 4, 5 ]

In the above example, we created a list called new_list that contains five integers.

You can also create an empty list by using the list() function or just an empty set of square brackets [].  Here are some examples:

list_1 = list()
list_2 = []

Both of the examples above create an empty list called empty_list_1 and list_2.

You can also create a list of a specific size filled with a default value using the * operator.  Here’s an example:

empty_list_1 = []
empty_list_2 = list()

In the example above, we created a list called my_list that contains three 1 values.

my_list = [1, 1, 1]

Python list features:

  1. Mutable: Lists are mutable, meaning you can modify their elements by assigning new values to specific indices.
  2. Ordered: Lists maintain the order of elements as they are added.
  3. Dynamic Size: Python lists can dynamically grow or shrink in size as elements are added or removed.
  4. Heterogeneous Elements: Lists can contain elements of different data types. For example, a single list can store integers, floats, strings, or even other lists.
  5. Indexing and Slicing: You can access individual elements in a list using square bracket notation and their index. Additionally, you can slice lists to extract a portion of elements by specifying start and end indices.
  6. Iteration: Lists can be easily iterated over using loops or list comprehensions, allowing you to process each element or perform operations on the entire list.
  7. Built-in Functions: Python provides a range of built-in functions specifically designed for working with lists. These include functions like `len()`, `max()`, `min()`, `sum()`, `sorted()`, and more.
  8. Versatile Data Structure: Lists are a versatile data structure used in a variety of scenarios.
  9. List Comprehensions: Python allows you to create new lists by performing operations on existing lists using concise and expressive syntax called list comprehensions.
  10. Extensive Methods: Python lists come with a range of built-in methods that enable various operations like adding or removing elements, sorting, reversing, searching, and more.

Python List Indexing and Slicing

In Python first element in the list has an index of 0. You can access elements in a list by their index using square brackets. Here’s an example:

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Access the first element
first_element = my_list[0]  # 'apple'

# Access the second element
second_element = my_list[1]  # 'banana'

# Access the third element
third_element = my_list[2]  # 'cherry'

# Print the elements
print("First element:", first_element)
print("Second element:", second_element)
print("Third element:", third_element)

You can also use negative indexing to access the list elements in the reverse order. Here’s an example:

# Define a list
my_list = ['apple', 'banana', 'cherry']

# Access the last element
last_element = my_list[-1]  # 'cherry'

# Access the second-to-last element
second_last_element = my_list[-2]  # 'banana'

# Access the third-to-last (or first) element
third_last_element = my_list[-3]  # 'apple'

# Print the elements
print("Last element:", last_element)
print("Second-to-last element:", second_last_element)
print("Third-to-last element:", third_last_element)

Slicing rules to create a sublist:

Here are the rules for slicing in Python:

  1. Slicing uses the colon : operator to specify a range of indices. The syntax is my_list[start_index:end_index:step].
  2. The start_index is the index of the first element to include in the slice. If not specified, it defaults to 0.
  3. The end_index is the index of the first element to exclude from the slice. If not specified, it defaults to the length of the list.
  4. The step parameter specifies the step size between elements in the slice. If not specified, it defaults to 1.
  5. All parameters can be negative, in which case they specify the index relative to the end of the list. For example, my_list[-1] refers to the last element of the list.
  6. Slicing returns a new list that contains the specified range of elements from the original list.

You can also use slicing to access a subset of the list. Slicing allows you to extract a range of elements from the list. Here’s an example:

# Define a list
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# Slice to get the first three elements
first_three = my_list[0:3]  # ['apple', 'banana', 'cherry']

# Slice to get elements from index 2 to the end
from_second_onwards = my_list[2:]  # ['cherry', 'date', 'elderberry']

# Slice to get the last two elements
last_two = my_list[-2:]  # ['date', 'elderberry']

# Slice with a step of 2 (every second element)
every_second = my_list[::2]  # ['apple', 'cherry', 'elderberry']

# Print the results
print("First three elements:", first_three)
print("From second onwards:", from_second_onwards)
print("Last two elements:", last_two)
print("Every second element:", every_second)

In the example above, we used slicing to extract a subset of the list that starts at index 0 and ends at index 3 (excluding index 3).

Updating list values:

Lists in Python are mutable, and their values can be updated by using the slice and assignment the ( = ) operator.

# Define a list
my_list = [1, 2, 3, 4, 5]

# Remove elements at indices 1 to 3
my_list[1:4] = []

# Print the updated list
print(my_list)

Iterating over a list

We can use a for loop to iterate over the list elements. Here’s an example:

# Define a list of fruits
fruits = ['apple', 'banana', 'cherry', 'date']

# Use a for loop to iterate over the list
for fruit in fruits:
    print(fruit)

Membership operator in list

We can use operator (i.e. in or not in) on list elements. If an element is in list then it returns True. If an element is not in list it return False. Here’s an example:

# Example list
fruits = ['apple', 'banana', 'cherry', 'date']

# Using 'in' to check if an element is in the list
print('apple' in fruits)  # Output: True
print('orange' in fruits)  # Output: False


# Using 'not in' to check if an element is not in the list
print('grape' not in fruits)  # Output: True
print('banana' not in fruits)  # Output: False

Repetition on list

We can use the (*) operator for the repetition of a list. Here’s an example:

# Example list
fruits = ['apple', 'banana', 'cherry']

# Using * operator for repetition
repeated_list = fruits * 3

print(repeated_list)
# Output: ['apple', 'banana', 'cherry', 'apple', 'banana', 'cherry', 'apple', 'banana', 'cherry']

Concatenation of a list

We can use the (+) operator for the concatenation of a list. Here’s an example:

# Example lists
list1 = ['apple', 'banana']
list2 = ['cherry', 'date']

# Using + operator for concatenation
combined_list = list1 + list2

print(combined_list)
# Output: ['apple', 'banana', 'cherry', 'date']

Python String

by

String Introduction:

A string is a sequence of characters. In Python, you can define a string using either single quotes (‘) or double quotes (“), or triple quotes (”’ or “””) for multiline strings. Here are some examples:

# Defining strings in Python

# Single-quoted string
single_quote_str = 'Hello, World!'
print("Single-quoted string:", single_quote_str)

# Double-quoted string
double_quote_str = "Hello, Python!"
print("Double-quoted string:", double_quote_str)

# Triple-quoted string (for multiline text)
triple_quote_str = '''This is a
multiline string.
It spans multiple lines.'''
print("Triple-quoted string:")
print(triple_quote_str)

Re-assign Strings:

In Python, you can reassign a string to a new value by simply assigning the new value to the variable that holds the string.  Here’s an example:

# Initial string assignment
my_string = "Hello, World!"
print("Original string:", my_string)

# Reassigning the string to a new value
my_string = "Welcome to Python!"
print("Reassigned string:", my_string)

In the example above, the first print statement outputs “Hello, World!” because my_string is initially assigned that value. Then, my_string is reassigned to “Sqatools” and the second print statement outputs the new value.

# Example to demonstrate string immutability in Python

# 1). String Concatenation
greeting = "Hello"
new_greeting = greeting + ", World!"
print("Original string (after concatenation):", greeting)  # Output: Hello
print("New string (concatenation result):", new_greeting)  # Output: Hello, World!

# 2). String Replacement
my_string = "Hello, Python!"
new_string = my_string.replace("Python", "World")
print("\nOriginal string (after replacement):", my_string)  # Output: Hello, Python!
print("New string (replacement result):", new_string)       # Output: Hello, World!

# 3). String Slicing
text = "Immutable"
sliced_text = text[:3]  # Taking the first three characters
print("\nOriginal string (after slicing):", text)           # Output: Immutable
print("Sliced string (slicing result):", sliced_text)       # Output: Imm

Deleting string:

In Python, you cannot delete individual characters in a string because strings are immutable. However, you can delete the entire string object from memory using the del statement.  Here’s an example:

# Define a string
my_string = "Hello, World!"
print(my_string)  # Outputs: Hello, World!

# Delete the string object
del my_string

# Try to access the deleted string
try:
    print(my_string)
except NameError as e:
    print(e)  # Outputs: name 'my_string' is not defined

In the example above, the first print statement outputs the value of my_string, which is “Hello, World!”. Then, the del statement deletes the my_string object from memory. When we try to print my_string again, we get a NameError because the variable no longer exists.

String formatting methods:

Python provides several methods for formatting strings. Here are the most commonly used methods:

  1. The % operator: This operator allows you to format strings using placeholders, which are replaced with values at runtime. Here’s an example:
# Using the % operator for string formatting
name = "Alice"
age = 25

formatted_string = "My name is %s and I am %d years old." % (name, age)
print(formatted_string)
# Output: My name is Alice and I am 25 years old.

In the example above, %s and %d are placeholders for the name and age variables, respectively. The values of these variables are provided in a tuple that follows the % operator.

  1. The str.format() method: This method allows you to format strings using placeholders that are enclosed in curly braces. Here’s an example:
# Using the str.format() method for string formatting
name = "Alice"
age = 25

formatted_string = "My name is {} and I am {} years old.".format(name, age)
print(formatted_string)
# Output: My name is Alice and I am 25 years old.

In the example above, {} is a placeholder for the name and age variables. The values of these variables are provided as arguments to the str.format() method.

  1. F-strings: It allows you to embed expressions inside placeholders that are enclosed in curly braces preceded by the f character. Here’s an example:
# Using f-strings for string formatting
name = "Alice"
age = 25

# Embedding variables directly into the string
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)
# Output: My name is Alice and I am 25 years old.

In the example above, the f character before the string indicates that it is an f-string. The expressions inside the curly braces are evaluated at runtime and the resulting values are inserted into the string.

String operators:

In Python, strings support several operators that can be used to perform various operations on strings. Here are some of the most commonly used string operators:

  1. Concatenation (+): The + operator can be used to concatenate two or more strings. Here’s an example:
# Using the + operator to concatenate strings
str1 = "Hello"
str2 = "World"
combined_str = str1 + " " + str2  # Adding a space between the words

print(combined_str)
# Output: Hello World
  1. Repetition (*): The * operator can be used to repeat a string a certain number of times. Here’s an example:
# Using the * operator to repeat a string
str1 = "Hello "
repeated_str = str1 * 3  # Repeating the string 3 times

print(repeated_str)
# Output: Hello Hello Hello
  1. Membership (in): The in operator can be used to check if a substring exists within a string. It returns True if the substring is found, and False otherwise. Here’s an example:
# Using the 'in' operator to check membership
sentence = "Python is awesome!"

# Checking if a substring exists within the string
substring = "Python"
result = substring in sentence

print(result)
# Output: True
  1. Indexing ([]): The [] operator can be used to access individual characters within a string. You can use a positive index to access characters from the beginning of the string, and a negative index to access characters from the end of the string. Here’s an example:
# Using the [] operator for indexing a string
my_string = "Python"

# Accessing characters using positive indices
first_char = my_string[0]  # First character
last_char = my_string[5]   # Last character (index 5 for "n")

print("First character:", first_char)  # Output: P
print("Last character:", last_char)    # Output: n

# Accessing characters using negative indices
second_last_char = my_string[-2]  # Second last character (index -2 for "o")
print("Second last character:", second_last_char)  # Output: o
  1. Slicing ([start:end]): The [] operator can also be used to extract a substring (or slice) from a string. The start argument specifies the starting index of the slice (inclusive), and the end argument specifies the ending index of the slice (exclusive). Here’s an example:
# Using the [] operator for string slicing
my_string = "Python Programming"

# Extracting a substring using slicing
substring = my_string[0:6]  # From index 0 to 5 (6 is exclusive)
print(substring)  # Output: Python
  1. Comparison (==, !=, <, <=, >, >=): The comparison operators can be used to compare two strings alphabetically. 
# Comparison of strings using various operators
string1 = "Apple"
string2 = "Banana"

# Checking if the strings are equal
print(string1 == string2)  # Output: False

# Checking if the strings are not equal
print(string1 != string2)  # Output: True

# Checking if string1 is alphabetically less than string2
print(string1 < string2)   # Output: True

# Checking if string1 is alphabetically greater than string2
print(string1 > string2)   # Output: False

# Checking if string1 is alphabetically less than or equal to string2
print(string1 <= string2)  # Output: True

# Checking if string1 is alphabetically greater than or equal to string2
print(string1 >= string2)  # Output: False

String indexing and slicing:

Indexing:

Indexing: Each character in a string is assigned an index starting from 0. You can access a particular character in a string using its index. Here’s an example:

# Using indexing to access characters in a string
my_string = "Python"

# Accessing individual characters using their indices
first_char = my_string[0]  # First character
second_char = my_string[1]  # Second character
last_char = my_string[5]  # Last character

print("First character:", first_char)  # Output: P
print("Second character:", second_char)  # Output: y
print("Last character:", last_char)  # Output: n
Slicing:

You can extract a portion of a string using slicing. Slicing is done using the [] operator, with two indices separated by a colon (:) inside the brackets. Here’s an example:

# Using slicing to extract a portion of a string
my_string = "Python Programming"

# Slicing from index 0 to 6 (exclusive of index 6)
substring = my_string[0:6]  # This gives 'Python'

print(substring)  # Output: Python

In the example above, my_string[0:5] returns the first five characters of the string, my_string[:5] returns all the characters up to the fifth character, and my_string[-5:] returns the characters from the fifth-last to the last character.

Note that the first index in a slice is inclusive and the second index is exclusive. So, my_string[0:5] returns characters from index 0 to index 4, but not the character at index 5.

In addition to the two indices separated by a colon, you can also add a third index to specify the step value. Here’s an example:

# Using slicing with a step
my_string = "Python Programming"

# Extracting every second character from index 0 to index 12
substring = my_string[0:13:2]  # From index 0 to 12, taking every second character

print(substring)  # Output: Pto rg

Python Loops

by

Python Loops Introduction

Loops are one of the most important concepts in Python. They allow you to execute a block of code repeatedly, which makes tasks like iterating through lists, performing calculations, or automating repetitive operations much easier

1). What Are Loops in Python?

A loop in Python is used to execute a set of statements multiple times until a certain condition is met. This helps avoid writing the same code over and over again. There are mainly two types of loops in Python:

  • for loop
  • while loop

2). Using the range() Function

The range() function is commonly used in loops to generate a sequence of numbers. It’s very useful when you want to repeat an action a specific number of times.

Syntax:

range(start, stop, step)

  • start – the starting number (default is 0)
  • stop – the number at which the range ends (not included)
  • step – the difference between each number (default is 1)
Example 1:
Here, the loop runs 5 times, printing numbers from 0 to 4.

for i in range(5):
    print(i)
Output :
0
1
2
3
4

Example 2:

for i in range(2, 10, 2):
    print(i)

Output :
2
4
6
8

3). The for Loop

A for loop is used when you know how many times you want to execute a block of code. It’s great for iterating through sequences like lists, tuples, or strings.

# Example 1: Iterating through a list|

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
Output: 

apple
banana
cherry

# Example 2: Iterating through a string

for letter in "Python":
    print(letter)

Output:
P
y
t
h
o
n

4). Nested for Loops

A nested loop means having one loop inside another. This is often used for working with multidimensional data, like matrices or tables.

# Example:
for i in range(1, 4):
    for j in range(1, 4):
        print(f"i={i}, j={j}")

Output:
i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3
i=3, j=1
i=3, j=2
i=3, j=3

Here, the inner loop runs completely every time the outer loop runs once

5). The while Loop

A while loop continues to run as long as a given condition is True. You use it when you don’t know how many times you need to repeat a block of code.

Example:

count = 0
while count < 5:
    print("Count is:", count)
    count += 1

Output:

Count is: 0
Count is: 1
Count is: 2
Count is: 3
Count is: 4

If the condition never becomes False, the loop runs forever (an infinite loop). To avoid that, always make sure the condition changes within the loop.

6). The break Statement

The break statement is used to stop a loop immediately, even if the loop’s condition is still True.

# Example:

for i in range(10):
    if i == 5:
        break
    print(i)

Output:

0
1
2
3
4

The loop stops when i equals 5, skipping the rest of the iterations.

7). The continue Statement

The continue statement is used to skip the rest of the code inside a loop for the current iteration and move to the next one

# Example:

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

Output:

1
3
5
7
9

Here, every time i is even, the loop skips the print() statement and continues to the next iteration.

8). Combining break and continue

You can use both break and continue in the same loop to control its flow precisely.

# Example:

for i in range(10):
    if i == 3:
        continue
    if i == 8:
        break
    print(i)

Output:

0
1
2
4
5
6
7

When i is 3, the continue statement skips that iteration. When i reaches 8, the break statement stops the loop entirely

9). Real-Life Example: Password Check

Here’s a simple example that uses both a while loop and break:

password = "python123"
attempts = 0

while attempts < 3:
    guess = input("Enter password: ")
    if guess == password:
        print("Access granted!")
        break
    else:
        print("Wrong password, try again.")
        attempts += 1
else:
    print("Too many attempts. Access denied.")

# This loop lets the user try three times before locking them out

10). Summary Table

ConceptDescriptionExample
for loopRuns a block of code a set number of timesfor i in range(5): print(i)
while loopRuns as long as a condition is truewhile x < 10:
range()Generates a sequence of numbersrange(1, 10, 2)
breakStops the loopif i == 5: break
continueSkips current iterationif i % 2 == 0: continue
Nested loopA loop inside anotherfor i in range(3): for j in range(3): …

Python DataTypes

by

Introduction :

In Python, every value has a specific data type associated with it. Data types define the nature of the variables, objects, or values you can work with in your code. Understanding different data types is crucial for effective programming. Let’s explore the commonly used data types in Python.

Numeric Types:

  • Integer (int): Represents whole numbers without decimal points.

In Python, the integer data type (int) represents whole numbers without any decimal points. Integers can be positive or negative, and they have no limit on their size, allowing you to work with both small and large numbers.

Example:

num1 = 10
  • Floating-Point (float): Represents decimal numbers.

In Python, the float data type represents decimal numbers. Floats are used to represent real numbers, including both positive and negative values. Unlike integers, floats can have decimal points and can represent numbers with fractional parts.

Example:

num2 = 3.14
  • Complex (complex): Represents numbers with real and imaginary parts.

In Python, the complex data type represents numbers with both real and imaginary parts. Complex numbers are often used in mathematical and scientific computations that involve complex arithmetic operations.

Example:

num3 = 4 + 5j

Sequence Types:

  • String (str): Represents a sequence of characters enclosed in quotes.

In Python, a string is a sequence of characters enclosed in single quotes (‘ ‘) or double quotes (” “). Strings are immutable, which means once created, they cannot be modified. However, you can create new strings based on existing ones.

Example:

name = "John"
  • List (list): Represents an ordered collection of items enclosed in square brackets.

In Python, a list is a versatile and mutable data type that represents an ordered collection of items. Lists can contain elements of different data types, such as numbers, strings, or even other lists. Lists are denoted by square brackets [ ].

Example:

numbers = [1, 2, 3, 4, 5]
  • Tuple (tuple): Represents an ordered collection of items enclosed in parentheses.

In Python, a tuple is an ordered collection of elements, similar to a list. However, unlike lists, tuples are immutable, meaning they cannot be modified once created. Tuples are typically denoted by parentheses ( ) or can be created without any delimiters.

Example:

coordinates = (10, 20, 30, 40)

Dictionary (dict):

Represents a collection of key-value pairs enclosed in curly braces.

In Python, a dictionary is an unordered collection of key-value pairs. It is also known as an associative array or a hash map. Dictionaries are enclosed in curly braces { }, and each item in the dictionary is represented as a key-value pair separated by a colon (:).

Example:

person = {"name": "John", "age": 25, "city": "New York"}

Set Types:

Set (set): Represents an unordered collection of unique items enclosed in curly braces.

In Python, a set is an unordered collection of unique elements. Sets are denoted by curly braces { }. Each element in a set must be unique, and duplicate values are automatically removed. Sets are mutable, meaning you can modify them after creation.

Example:

fruits = {"apple", "banana", "orange"}

Boolean Type:

Boolean (bool): Represents either True or False.

In Python, the Boolean data type represents truth values. A Boolean value can be either True or False. Booleans are often used for logical operations and comparisons.

In Python, the keywords True and False (with the first letter capitalized) are used to represent Boolean values.

Example:

is_active = True
is_admin = False

Python Conditional Statements

by

Introduction:

In Python, the if-else statement allows you to execute different blocks of code based on certain conditions. It provides a way to make decisions and control the flow of your program.

if statement

The `if` statement is the fundamental building block of a conditional statement. It allows you to execute a block of code if a certain condition is true. The syntax of the `if` statement is as follows:

if condition:
        # Code block to execute if the condition is True

If-else statement

The `else` statement is used in conjunction with the `if` statement. It provides an alternative block of code to execute when the condition in the `if` statement is false. The syntax is as follows:

The basic syntax of an if-else statement in Python is as follows:

if condition:
       # Code block to execute if the condition is True
else:
       # Code block to execute if the condition is False

The condition is an expression that evaluates to either True or False. If the condition is True, the code block immediately following the if statement will be executed. Otherwise, if the condition is False, the code block following the else statement will be executed.

Let’s look at an example to understand it better. Suppose we want to check whether a given number is positive or negative:

number = int(input("Enter a number: "))
if number > 0:
      print("The number is positive.")
else:
      print("The number is negative or zero.")

In this example, we use the input() function to get a number from the user, convert it to an integer using int(), and store it in the number variable. The if-else statement then checks whether the number is greater than zero. If it is, it prints “The number is positive.” Otherwise, it prints “The number is negative or zero.”

elif statement

The `elif` statement allows you to check additional conditions after an initial `if` statement. It provides a way to handle multiple cases within the same conditional statement. The syntax is as follows:

Here’s an example that checks whether a number is positive, negative, or zero:

number = int(input("Enter a number: "))
if number > 0:
        print("The number is positive.")
elif number < 0:
        print("The number is negative.")
else:
        print("The number is zero.")

In this case, the elif statement allows us to check an additional condition. If the first condition is False, it moves to the elif statement and checks whether the number is less than zero. If that condition is True, it prints “The number is negative.” Finally, if both the first and second conditions are False, it executes the code block under the else statement and prints “The number is zero.”

Nested conditional statements

In Python, nested if-else statements allow you to have if-else statements within other if-else statements. They provide a way to handle complex conditions and execute different blocks of code based on multiple conditions. The basic syntax of a nested if-else statement in Python is as follows:

if condition1:
      # code to execute if condition1 is true
      if condition2:
               # code to execute if condition1 and condition2 true
      else:
               # code execute if condition1 true but condition2 false
else:
         # code to execute if condition1 is false

In a nested if-else statement, the inner if-else statement is indented further to the right than the outer if-else statement. The inner if-else statement is evaluated only if the condition of the outer if statement is `True`. Here’s an example:

age = 25
has_membership = True

if age >= 18:
    if has_membership:
           print("Welcome to the exclusive club!")
    else:
           print("Membership required for entry.")
else:
     print("You must be 18 or older to enter.")