Python Lists: A Comprehensive Guide

What is a List?

Lists are a fundamental data structure in Python used to store collections of items. They are:

• Ordered: Elements maintain a defined sequence.
• Mutable: Elements can be modified after creation.
• Defined by: Square brackets [].

Example:

fruits = ['apple', 'banana', 'orange']
print(fruits)  # Output: ['apple', 'banana', 'orange']

Accessing Elements in a List

Positive Indexing

a = [10, 20, 30, 40, 50]
print(a[0])  # Output: 10
print(a[4])  # Output: 50

Negative Indexing (Access elements from the end)

a = [1, 2, 3, 4, 5]
print(a[-1])  # Output: 5
print(a[-3])  # Output: 3

Slicing

my_list = [10, 20, 30, 40, 50]
print(my_list[0:3])  # Output: [10, 20, 30]
print(my_list[::2])  # Output: [10, 30, 50]

List Operations

Modifying Elements

numbers = [1, 2, 3, 4, 5]
numbers[2] = 10
print(numbers)  # Output: [1, 2, 10, 4, 5]

Adding Elements

numbers.append(6)  # Adds at the end
numbers.insert(1, 9)  # Insert at index 1
numbers.extend([7, 8])  # Merge another list
print(numbers)  # Output: [1, 9, 2, 10, 4, 5, 6, 7, 8]

Removing Elements

numbers.remove(10)  # Removes first occurrence
popped = numbers.pop(2)  # Removes by index
del numbers[0]  # Delete by index
numbers.clear()  # Clears entire list

Sorting and Reversing

numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()  # Ascending order
numbers.reverse()  # Reverse order
print(numbers)  # Output: [9, 5, 4, 3, 2, 1, 1]

List Comprehensions

Basic Example (Square of Numbers)

squares = [x**2 for x in range(5)]
print(squares)  # Output: [0, 1, 4, 9, 16]

With Condition (Filtering)

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # Output: [0, 2, 4, 6, 8]

With If-Else

labels = ["Even" if x % 2 == 0 else "Odd" for x in range(5)]
print(labels)  # Output: ['Even', 'Odd', 'Even', 'Odd', 'Even']

Flatten a List of Lists

matrix = [[1, 2, 3], [4, 5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened)  # Output: [1, 2, 3, 4, 5, 6]

Advanced Examples

# Squares for even numbers, cubes for odd numbers
numbers = range(1, 11)
result = [x**2 if x % 2 == 0 else x**3 for x in numbers]
print(result)

# Filtering odd numbers and multiples of 3, adding 1 to odd numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [x + 1 if x % 2 != 0 else x for x in numbers if x % 3 == 0]
print(result)  # Output: [4, 7, 10]

Taking User Input for Lists

List of Integers from User Input

user_input = input("Enter numbers separated by spaces: ")
numbers = [int(num) for num in user_input.split()]
print("List of numbers:", numbers)

List of Strings from User Input

user_input = input("Enter words separated by spaces: ")
words = user_input.split()
print("List of words:", words)

Error Handling for Input

def get_int_list():
    while True:
        try:
            input_string = input("Enter integers separated by spaces: ")
            return list(map(int, input_string.split()))
        except ValueError:
            print("Invalid input. Please enter integers only.")

int_list = get_int_list()
print("The list of integers is:", int_list)

while True:
    user_input = input("Enter numbers separated by spaces or commas: ")

    # Replace commas with spaces
    cleaned_input = user_input.replace(',', ' ')

    # Create the list with None for invalid entries
    numbers = []
    for entry in cleaned_input.split():
        try:
            numbers.append(int(entry))
        except ValueError:
            numbers.append(None)

    # Check if there's at least one valid integer
    if any(num is not None for num in numbers):
        print("List of numbers (invalid entries as None):", numbers)
        break  # Exit the loop when you have at least one valid number
    else:
        print("No valid numbers entered. Try again.")

Summary

This guide provides a structured overview of lists, including indexing, slicing, comprehensions, and user input handling. Mastering these concepts will enhance your Python programming efficiency!

Tuples in Python

Tuples in Python are ordered collections of items, similar to lists. However, unlike lists, tuples are immutable, meaning their elements cannot be changed after creation. Tuples are denoted by parentheses (), and items within the tuple are separated by commas. Tuples are commonly used for representing fixed collections of items, such as coordinates or records.

Strings Vs Lists Vs Tuples

strings and lists are both examples of sequences. Strings are sequences of characters, and are immutable. Lists are sequences of elements of any data type, and are mutable. The third sequence type is the tuple. Tuples are like lists, since they can contain elements of any data type. But unlike lists, tuples are immutable. They’re specified using parentheses instead of square brackets.

here’s a comprehensive explanation of strings, lists, and tuples in Python, highlighting their key differences and use cases:

Strings

• Immutable: Strings are unchangeable once created. You cannot modify the characters within a string.
• Ordered: Characters in a string have a defined sequence and can be accessed using indexing (starting from 0).
• Used for: Representing text data, storing names, URLs, file paths, etc.

Example:

name = "Alice"
message = "Hello, world!"

# Trying to modify a character in a string will result in a TypeError
# name[0] = 'B'  # This will cause a TypeError

Lists

• Mutable: Lists can be modified after creation. You can add, remove, or change elements after the list is created.
• Ordered: Elements in a list have a defined order and are accessed using zero-based indexing.
• Used for: Storing collections of items of any data type, representing sequences that can change.

Example:

fruits = ["apple", "banana", "cherry"]

# Add a new element
fruits.append("kiwi")
print(fruits)  # Output: ["apple", "banana", "cherry", "kiwi"]

# Modify an element
fruits[1] = "mango"
print(fruits)  # Output: ["apple", "mango", "cherry", "kiwi"]

Tuples

• Immutable: Tuples are similar to lists but cannot be modified after creation.
• Ordered: Elements in a tuple have a defined order and are accessed using indexing.
• Used for: Representing fixed data sets, storing data collections that shouldn’t be changed, passing arguments to functions where the data shouldn’t be modified accidentally.

Example:

coordinates = (10, 20)

# Trying to modify an element in a tuple will result in a TypeError
# coordinates[0] = 15  # This will cause a TypeError

# You can create tuples without parentheses for simple cases
person = "Alice", 30, "New York"  # This is also a tuple

Key Differences:

Choosing the Right Data Structure:

• Use strings when you need to store text data that shouldn’t be modified.
• Use lists when you need to store a collection of items that you might need to change later.
• Use tuples when you need a fixed data set that shouldn’t be modified after creation. Tuples can also be useful when you want to pass arguments to a function and ensure the data isn’t accidentally changed.

Here’s an overview of tuples in Python:

1. Creating Tuples:

You can create tuples in Python using parentheses () and separating elements with commas.

Example 1: Tuple of Integers
numbers = (1, 2, 3, 4, 5)

# Example 2: Tuple of Strings
fruits = ('apple', 'banana', 'orange', 'kiwi')

# Example 3: Mixed Data Types
mixed_tuple = (1, 'apple', True, 3.14)

# Example 4: Singleton Tuple (Tuple with one element)
singleton_tuple = (42,)  # Note the comma after the single element

2. Accessing Elements:

You can access individual elements of a tuple using their indices, similar to lists.

numbers = (1, 2, 3, 4, 5)
print(numbers[0])  # Output: 1
print(numbers[-1])  # Output: 5 (negative index counts from the end)

3. Immutable Nature:

Tuples are immutable, meaning you cannot modify their elements after creation. Attempts to modify a tuple will result in an error.

numbers = (1, 2, 3)
numbers[1] = 10  # This will raise a TypeError

4. Tuple Operations:

Although tuples are immutable, you can perform various operations on them, such as concatenation and repetition.

Concatenation
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2  # Output: (1, 2, 3, 4, 5, 6)

# Repetition
repeated_tuple = (0,) * 5  # Output: (0, 0, 0, 0, 0)

5. Tuple Unpacking:

You can unpack a tuple into individual variables.

coordinates = (3, 5)
x, y = coordinates
print(x)  # Output: 3
print(y)  # Output: 5

6. Use Cases:

Tuples are commonly used for:

• Returning multiple values from functions.
• Representing fixed collections of data (e.g., coordinates, RGB colors).
• Immutable keys in dictionaries.
• Namedtuples for creating lightweight data structures.

Summary

Tuple Creation and Initialization

Accessing Elements

Unpacking

Membership Testing

Important Note:

• Tuples are immutable, meaning you cannot modify their elements after creation.

Additional Functions (though not for modifying the tuple itself):

Iterating over lists and tuples in Python

Iterating over lists and tuples in Python is straightforward using loops or list comprehensions. Both lists and tuples are iterable objects, meaning you can loop through their elements one by one. Here’s how you can iterate over lists and tuples:

1. Using a For Loop:

You can use a for loop to iterate over each element in a list or tuple.

Example with a List:

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

Example with a Tuple:

coordinates = (3, 5)
for coord in coordinates:
    print(coord)

2. Using List Comprehensions:

List comprehensions provide a concise way to iterate over lists and tuples and perform operations on their elements.

Example with a List:

numbers = [1, 2, 3, 4, 5]
squared_numbers = [num ** 2 for num in numbers]
print(squared_numbers)

Example with a Tuple:

coordinates = ((1, 2), (3, 4), (5, 6))
sum_of_coordinates = [sum(coord) for coord in coordinates]
print(sum_of_coordinates)

3. Using Enumerate:

The enumerate() function can be used to iterate over both the indices and elements of a list or tuple simultaneously.

Example with a List:

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

Example with a Tuple:

coordinates = ((1, 2), (3, 4), (5, 6))
for index, coord in enumerate(coordinates):
    print(f"Index {index}: {coord}")

4. Using Zip:

The zip() function allows you to iterate over corresponding elements of multiple lists or tuples simultaneously.

Example with Lists:

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

Example with Tuples:

coordinates = ((1, 2), (3, 4), (5, 6))
for x, y in coordinates:
    print(f"X: {x}, Y: {y}")

List comprehensions in Details From Start to End

A list comprehension is a concise way to create lists in Python. It follows the patte

✅Pattern 1: Basic List Comprehension
[expression for item in iterable if condition]
Breaking it Down:
1️⃣ Expression → What to do with each item in the list.
2️⃣ Iterable → The source (e.g., list, range(), df.columns, etc.).
3️⃣ Condition (Optional) → A filter to select items that meet certain criteria.


✅Pattern 2: List Comprehension with if-else (Ternary Expression)
[expression_if_true if condition else expression_if_false for item in iterable]

Common Mistake
❌ Incorrect (if placed incorrectly)
[x**2 for x in numbers if x % 2 == 0 else x**3]  # ❌ SyntaxError


✅ Correct (if-else goes before for in ternary case)
[x**2 if x % 2 == 0 else x**3 for x in numbers]  # ✅ Works fine



✅ Pattern 3: Nested List Comprehensions
[expression for sublist in iterable for item in sublist]

Here’s a comprehensive collection of list comprehension examples, including basic, advanced, and smart/tricky ones:

🔥 Basic List Comprehension Examples

1️⃣ Square of Numbers

squares = [x**2 for x in range(5)]
print(squares)
# Output: [0, 1, 4, 9, 16]

2️⃣ Filtering Even Numbers

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)
# Output: [0, 2, 4, 6, 8]

3️⃣ Labeling Odd and Even Numbers

labels = ["Even" if x % 2 == 0 else "Odd" for x in range(5)]
print(labels)
# Output: ['Even', 'Odd', 'Even', 'Odd', 'Even']

🚀 Smart List Comprehension Examples

4️⃣ Removing _n from Column Names

columns = ["col_1", "col_2", "name", "col_119"]
clean_columns = [col.replace("_" + col.split("_")[-1], "") if col.split("_")[-1].isdigit() else col for col in columns]
print(clean_columns)
# Output: ['col', 'col', 'name', 'col']

5️⃣ Flatten a List of Lists

matrix = [[1, 2, 3], [4, 5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened)
# Output: [1, 2, 3, 4, 5, 6]

6️⃣ Square Even Numbers, Cube Odd Numbers

numbers = range(1, 11)
result = [x**2 if x % 2 == 0 else x**3 for x in numbers]
print(result)
# Output: [1, 4, 27, 16, 125, 36, 343, 64, 729, 100]

7️⃣ Filtering Multiples of 3 and Incrementing Odd Numbers

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [x + 1 if x % 2 != 0 else x for x in numbers if x % 3 == 0]
print(result)
# Output: [4, 7, 10]

8️⃣ Creating Labels for Word Lengths

words = ["apple", "banana", "grape", "watermelon", "orange"]
result = [f"{word}: long" if len(word) > 6 else f"{word}: short" for word in words]
print(result)
# Output: ['apple: short', 'banana: short', 'grape: short', 'watermelon: long', 'orange: short']

💡 Tricky and Useful List Comprehension Examples

9️⃣ Extracting Digits from Strings

data = ["a12", "b3c", "45d", "xyz"]
digits = ["".join([char for char in item if char.isdigit()]) for item in data]
print(digits)
# Output: ['12', '3', '45', '']

🔟 Finding Common Elements in Two Lists

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
common = [x for x in list1 if x in list2]
print(common)
# Output: [3, 4, 5]

1️⃣1️⃣ Finding Unique Elements in One List (Not in Another)

unique = [x for x in list1 if x not in list2]
print(unique)
# Output: [1, 2]

1️⃣2️⃣ Generate Pairs of Numbers (Tuple Pairing)

pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)
# Output: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

1️⃣3️⃣ Creating a Dictionary Using List Comprehension

squares_dict = {x: x**2 for x in range(5)}
print(squares_dict)
# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

1️⃣4️⃣ Finding Duplicate Elements in a List

nums = [1, 2, 3, 2, 4, 5, 6, 4, 7]
duplicates = list(set([x for x in nums if nums.count(x) > 1]))
print(duplicates)
# Output: [2, 4]

1️⃣5️⃣ Converting a List of Strings to Integers, Ignoring Errors

data = ["10", "abc", "30", "xyz", "50"]
numbers = [int(x) for x in data if x.isdigit()]
print(numbers)
# Output: [10, 30, 50]

1️⃣6️⃣ Getting the ASCII Values of Characters

ascii_values = [ord(char) for char in "Python"]
print(ascii_values)
# Output: [80, 121, 116, 104, 111, 110]

🔥 Bonus: Nested List Comprehension

1️⃣7️⃣ Transposing a Matrix

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed)
# Output: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

1️⃣8️⃣ Flattening a Nested Dictionary

data = {"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}
flattened = [(key, subkey, value) for key, subdict in data.items() for subkey, value in subdict.items()]
print(flattened)
# Output: [('a', 'x', 1), ('a', 'y', 2), ('b', 'x', 3), ('b', 'y', 4)]

Specials about List and Tuples–Python concepts related to tuples, list comprehensions, merging lists, and user input handling

Q1: Can we achieve List Comprehension type functionality in case of Tuples?

Yes, we can achieve a similar concept of list comprehension in Python with tuples. However, since tuples are immutable, they cannot be modified in place. Instead, we can use tuple comprehension to create new tuples based on existing iterables.

Tuple Comprehension Syntax:

(expression for item in iterable if condition)

Examples:

1. Creating a tuple of squares from a list:

numbers = [1, 2, 3, 4, 5]
squares_tuple = tuple(x ** 2 for x in numbers)
print(squares_tuple)  # Output: (1, 4, 9, 16, 25)

2. Filtering even numbers from a tuple:

mixed_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
even_numbers_tuple = tuple(x for x in mixed_tuple if x % 2 == 0)
print(even_numbers_tuple)  # Output: (2, 4, 6, 8, 10)

3. Creating a tuple of tuples from a list of lists:

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tuple_of_tuples = tuple(tuple(row) for row in list_of_lists)
print(tuple_of_tuples)  # Output: ((1, 2, 3), (4, 5, 6), (7, 8, 9))

Q2: Why prefer Python list comprehensions over for-loops?

List comprehensions offer several advantages over traditional for-loops:

1. Readability and Conciseness:
   • For-loop Example:
   squares = [] for x in range(10): squares.append(x**2) print(squares)
   • List Comprehension Equivalent:
   squares = [x**2 for x in range(10)] print(squares)
2. Performance:
   • List comprehensions are optimized and execute faster than for-loops.
3. Functional Programming Paradigm:
   • Supports operations like mapping and filtering more elegantly.
   squares = [x**2 for x in range(10) if x % 2 == 0]
4. Immutability and Side-Effect Reduction:
   • Reduces the risk of unintended modifications.
5. Nested Comprehensions:
   • For-loop Example:
   matrix = [] for i in range(3): row = [] for j in range(3): row.append(i * j) matrix.append(row) print(matrix)
   • Nested List Comprehension Equivalent:
   matrix = [[i * j for j in range(3)] for i in range(3)] print(matrix)

When to Use For-Loops?

• When handling complex logic.
• When dealing with side-effects.
• When working with large datasets (use generators instead of list comprehensions to optimize memory usage).

Q3: How to Merge Two Lists?

1. Merge Two Lists of Any Type:

def merge_lists(list1, list2):
    return list1 + list2

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
print(merge_lists(list1, list2))  # Output: [1, 2, 3, 'a', 'b', 'c']

2. Merge and Sort Lists of Numbers:

def merge_and_sort_lists(list1, list2):
    return sorted(list1 + list2)

list1 = [3, 1, 4]
list2 = [2, 5, 0]
print(merge_and_sort_lists(list1, list2))  # Output: [0, 1, 2, 3, 4, 5]

3. Merge Two Sorted Lists Efficiently:

def merge_sorted_lists(list1, list2):
    merged_list = []
    i, j = 0, 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            merged_list.append(list1[i])
            i += 1
        else:
            merged_list.append(list2[j])
            j += 1
    merged_list.extend(list1[i:])
    merged_list.extend(list2[j:])
    return merged_list

list1 = [1, 3, 5]
list2 = [2, 4, 6]
print(merge_sorted_lists(list1, list2))  # Output: [1, 2, 3, 4, 5, 6]

Q4: How to get a list of integers or strings from user input?

1. List of Integers:

int_list = list(map(int, input("Enter numbers separated by spaces: ").split()))
print("List of integers:", int_list)

2. List of Strings:

string_list = input("Enter words separated by spaces: ").split()
print("List of strings:", string_list)

Q5: A Complete Example – Merging Two User-Input Lists and Sorting Them

def merge_sorted_lists(l1, l2):
    i, j = 0, 0
    merged = []
    while i < len(l1) and j < len(l2):
        if l1[i] < l2[j]:
            merged.append(l1[i])
            i += 1
        else:
            merged.append(l2[j])
            j += 1
    merged.extend(l1[i:])
    merged.extend(l2[j:])
    return merged

if __name__ == "__main__":
    l1 = list(map(int, input("Enter the first list of numbers: ").split()))
    l2 = list(map(int, input("Enter the second list of numbers: ").split()))
    combined = merge_sorted_lists(l1, l2)
    print("Combined sorted list:", combined)

Here’s a comprehensive Python string function cheat sheet in tabular format:

This list includes all built-in string functions.

# Python Strings: A Comprehensive Guide

1. What is a String in Python?

A string in Python is a sequence of characters enclosed within single (' '), double (" "), or triple (''' ''' or """ """) quotes.

🔹 Case-Sensitive & Immutable: Strings are case-sensitive and immutable, meaning once created, they cannot be changed.

🔹 Allowed Characters: Strings can contain alphabets, digits, spaces, and special characters.

Examples:

# Single Quotes
my_string1 = 'Hello, World!'

# Double Quotes
my_string2 = "Python Programming"

# Triple Quotes for Multiline Strings
my_string3 = '''This is a
multiline
string.'''

Why Use Triple Quotes?

🔹 To create multiline strings. 🔹 To include both single and double quotes within the string.

Example:

xyz = "Don't Books Ram's "  # ✅ Correct
xyz = 'Don't Books Ram's'  # ❌ Syntax Error

2. How Strings are Stored in Memory?

Behind the Scenes:

✅ Object Creation: A string object is created in memory. ✅ Character Storage: Stored as a sequence of Unicode code points. ✅ Reference Counting: Python tracks references to the string object. ✅ Variable Creation: A variable holds a reference to the string, not the data itself.

📌 Key Points: 🔹 Multiple variables can reference the same string. 🔹 Strings are immutable; modifying one variable won’t affect others. 🔹 When a string’s reference count drops to zero, it’s garbage collected.

Example:

x = y = z = "oh Boy"  # Multiple Assignment

# Or
x = "oh Boy"
y = x
z = y

Both approaches reference the same string in memory.

3. String Immutability

Strings cannot be changed once created. Attempting to modify them directly results in an error:

message = "Hello, world!"
message[0] = 'X'  # ❌ TypeError: 'str' object does not support item assignment

✅ Correct Way:

modified_message = 'X' + message[1:]
print(modified_message)  # Output: Xello, world!

Example:

s = 'RammaR'
s[2] = 'e'  # ❌ TypeError: Strings are immutable!

✅ Solution: Create a new string:

s = s[:2] + 'e' + s[3:]
print(s)  # Output: RameaR

4. String Manipulation Techniques

Replace and Modify Strings

Even though strings are immutable, you can create new modified strings using built-in methods.

s = 'RammaR'
s = s.replace('R', 'r').lower()
print(s)  # Output: 'rammar'

📌 What happens here? ✅ replace('R', 'r') creates a new string 'rammar'. ✅ .lower() converts it to lowercase (remains 'rammar'). ✅ The new string is assigned back to s, while the old string is discarded.

If the old reference needs to be removed:

del s  # Deletes the reference to the string

5. String as a Sequence of Characters

Strings are ordered sequences, and each character has an index position:

s = "Python"
print(s[0])  # Output: 'P'
print(s[-1])  # Output: 'n' (Negative Indexing)

✅ String Slicing:

s = "Programming"
print(s[0:4])  # Output: 'Prog' (Index 0 to 3)
print(s[:6])  # Output: 'Progra' (Start from 0)
print(s[4:])  # Output: 'ramming' (Till end)

6. Essential String Methods

Python provides built-in string methods for various operations:

7. Unicode Support in Strings

Python strings support Unicode, making them suitable for multiple languages.

s = "你好, мир, Hello!"
print(s)

Summary

✅ Strings are immutable, meaning modifications create new strings. ✅ Strings are stored in memory as objects, and variables hold references. ✅ Indexing & Slicing help extract and manipulate parts of strings. ✅ Built-in methods like replace(), split(), join(), etc., make string manipulation easy. ✅ Python strings support Unicode, making them useful for international text processing.

By mastering these string operations, you can handle text data efficiently in Python! 🚀

Some commonly used string functions in Python:

1. Conversion Functions:
   • upper(): Converts all characters in the string to uppercase.
   • lower(): Converts all characters in the string to lowercase.
   • capitalize(): Capitalizes the first character of the string.
   • title(): Converts the first character of each word to uppercase.
2. Search and Replace Functions:
   • find(substring): Returns the lowest index in the string where substring is found.
   • rfind(substring): Returns the highest index in the string where substring is found.
   • index(substring): Like find(), but raises ValueError if the substring is not found.
   • rindex(substring): Like rfind(), but raises ValueError if the substring is not found.
   • count(substring): Returns the number of occurrences of substring in the string.
   • replace(old, new): Returns a copy of the string with all occurrences of substring old replaced by new.
3. Substring Functions:
   • startswith(prefix): Returns True if the string starts with the specified prefix, otherwise False.
   • endswith(suffix): Returns True if the string ends with the specified suffix, otherwise False.
   • strip(): Removes leading and trailing whitespace.
   • lstrip(): Removes leading whitespace.
   • rstrip(): Removes trailing whitespace.
   • split(sep): Splits the string into a list of substrings using the specified separator.
   • rsplit(sep): Splits the string from the right end.
   • partition(sep): Splits the string into three parts using the specified separator. Returns a tuple with (head, separator, tail).
   • rpartition(sep): Splits the string from the right end.
4. String Formatting Functions:
   • format(): Formats the string.
   • join(iterable): Concatenates each element of the iterable (such as a list) to the string.
5. String Testing Functions:
   • isalpha(): Returns True if all characters in the string are alphabetic.
   • isdigit(): Returns True if all characters in the string are digits.
   • isalnum(): Returns True if all characters in the string are alphanumeric (letters or numbers).
   • isspace(): Returns True if all characters in the string are whitespace.
6. Miscellaneous Functions:
   • len(): Returns the length of the string.
   • ord(): Returns the Unicode code point of a character.
   • chr(): Returns the character that corresponds to the Unicode code point.

Looping over a String

Strings are objects that contain a sequence of single-character strings.

A single letter is classified as a string in Python. For example, string[0] is considered a string even though it is just a single character.

Here’s how you can do it-Loooping Over a String:

my_string = "Hello, World!"

for char in my_string:
    print(char)

In Python, you can use a for loop to iterate over each character in a string. To loop over a string means to start with the first character in a string(Position 0) and iterate over each character until the end of the string( Position- Length-1).

#to get commonLetters from two string with case and duplicates ignored and the result #sorted /Or Not sorted alpabetically

def commonLetters(str1,str2):
    common = ""
    for i in str1:
        if i in str2 and i not in common:
            common += i
    return "".join(sorted(common))
def commonLettersnosort(str1,str2):
    common = ""
    for i in str1:
        if i in str2 and i not in common:
            common += i
    return "".join(common)
def commonLettersnosortnocase(str1,str2):
    common = ""
    for i in str1:
        if i.upper() in str2.upper() and i not in common:
            common += i
    return "".join(common)

Check for -
commonLettersnosort('shyam','Ghanshyam') commonLettersnosortnocase('shyam','GhanShYam')

Slicing Strings:

You can slice strings using the syntax [start:stop:step], where:

• start: The starting index of the slice (inclusive).
• stop: The ending index of the slice (exclusive).
• step: The step or increment between characters (optional).

If you try to access an index that’s larger than the length of your string, you’ll get an IndexError. This is because you’re trying to access something that doesn’t exist!

You can also access indexes from the end of the string going towards the start of the string by using negative values. The index [-1] would access the last character of the string, and the index [-2] would access the second-to-last character.

Example:

my_string = "Python Programming"

# Slicing from index 7 to the end
substring1 = my_string[7:]
print(substring1)  # Output: Programming

# Slicing from index 0 to 6
substring2 = my_string[:6]
print(substring2)  # Output: Python

# Slicing from index 7 to 13 with step 2
substring3 = my_string[7:13:2]
print(substring3)  # Output: Porm
string1 = "Greetings, Earthlings"
print(string1[0])   # Prints “G”
print(string1[4:8]) # Prints “ting”
print(string1[11:]) # Prints “Earthlings”
print(string1[:5])  # Prints “Greet”

If your index is beyond the end of the string, Python returns an empty string.

An optional way to slice an index is by the stride argument, indicated by using a double colon.

This allows you to skip over the corresponding number of characters in your index, or if you’re using a negative stride, the string prints backwards.

print(string1[0::2])    # Prints “Getns atlns”

print(string1[::-1])    # Prints “sgnilhtraE ,sgniteerG”

Using the str.format() method String Formatting

The str.format() method is a powerful tool in Python for string formatting. It allows you to create dynamic strings by inserting values into placeholders within a string template. Here’s a basic overview of how it works:

Basic Usage:

You start with a string containing placeholder curly braces {} where you want to insert values, and then you call the format() method on that string with the values you want to insert.

Example:

name = "John"
age = 30
print("My name is {} and I am {} years old.".format(name, age))

My name is John and I am 30 years old.

Positional Arguments:

You can pass values to the format() method in the order that corresponds to the order of the placeholders in the string.

Example:

print("My name is {} and I am {} years old.".format("Alice", 25))
My name is Alice and I am 25 years old.

Keyword Arguments:

Alternatively, you can pass values using keyword arguments, where the keys match the names of the placeholders.

Example:

print("My name is {name} and I am {age} years old.".format(name="Bob", age=28))

Output:

My name is Bob and I am 28 years old.


Formatting:

You can also specify formatting options within the placeholders to control the appearance of the inserted values, such as precision for floating-point numbers or padding for strings.

Example:

pi = 3.14159
print("The value of pi is {:.2f}".format(pi))

Output:

The value of pi is 3.14

Padding and Alignment:-

You can align strings and pad them with spaces or other characters.


left_aligned = "{:<10}".format("left")
right_aligned = "{:>10}".format("right")
center_aligned = "{:^10}".format("center")
print(left_aligned)
print(right_aligned)
print(center_aligned)

Accessing Arguments by Position:

You can access arguments out of order and even multiple times by specifying their positions within the curly braces.

Example:

print("{1} {0} {1}".format("be", "or", "not"))

Output:

or be or

Guess the ERROR:-

Head to Next

Pages: 1 2 3 4 5 6

What is Dictionary in Python?

First of All it is not sequential like Lists. It is a non-sequential, unordered, redundant and mutable collection as key:value pairs. Keys are always unique but values need not be unique. You use the key to access the corresponding value. Where a list index is always a number, a dictionary key can be a different data type, like a string, integer, float, or even tuples but never a List(it is Mutable!).

• 1.Python dictionaries are unordered collections of key-value pairs.
• 2.They are mutable, meaning you can add, remove, and modify elements after creation.
• 3.Dictionary keys must be unique and immutable (e.g., strings, numbers, tuples).
• 4.while values can be of any data type.

The contents of a dict can be written as a series of key:value pairs within braces { }, e.g.

dict = {key1:value1, key2:value2, ... }.

The “empty dict” is just an empty pair of curly braces {}.

{'a':'abc', 'k':'xyz'} == {'k':'xyz', 'a':'abc'} # Point 1-  unordered collections of key-value pairs
output:- True

# Create a dictionary # Point 2 They are mutable, meaning you can add, remove, and modify elements after creation.
person = {"name": "John", "age": 30, "city": "New York"}

# Print the original dictionary
print("Original Dictionary:")
print(person)

# Add a new element
person["country"] = "USA"

# Print the updated dictionary
print("\nUpdated Dictionary after adding a new element:")
print(person)

# Modify an existing element
person["age"] = 31

# Print the updated dictionary
print("\nUpdated Dictionary after modifying an existing element:")
print(person)

# Remove an element
del person["city"]

# Print the updated dictionary
print("\nUpdated Dictionary after removing an element:")
print(person)

output:--
Original Dictionary:
{'name': 'John', 'age': 30, 'city': 'New York'}

Updated Dictionary after adding a new element:
{'name': 'John', 'age': 30, 'city': 'New York', 'country': 'USA'}

Updated Dictionary after modifying an existing element:
{'name': 'John', 'age': 31, 'city': 'New York', 'country': 'USA'}

Updated Dictionary after removing an element:
{'name': 'John', 'age': 31, 'country': 'USA'}

#Point 3.Dictionary keys must be unique and immutable (e.g., strings, numbers, tuples).

#Point 4.while values can be of any data type.
person = {
    "name": "John",
    "age": 30,
    "city": "New York"
}
numbers = {
    1: "one",
    2: "two",
    3: "three"
}
coordinates = {
    (1, 2): "point1",
    (3, 4): "point2",
    (5, 6): "point3"
}
mixed_keys = {
    "name": "John",
    1: "one",
    (2, 3): "point1"
}

##Note that while dictionaries can have keys of different data types, they must still be unique and immutable.

Pages: 1 2 3 4