Python-02

Python-02

String

Creating and Storing Strings

  • In Python, strings can be created using single quotes (') or double quotes ("). They are immutable sequences of characters.
# Example of creating strings
str1 = 'Hello, '
str2 = "world!"

Basic String Operations

  • Python supports various operations on strings, such as concatenation (+), repetition (*), and membership (in operator).
# Example of basic string operations
str1 = 'Hello, '
str2 = 'world!'
concatenated_str = str1 + str2
repeated_str = str1 * 3
print(concatenated_str)  # Output: Hello, world!
print(repeated_str)      # Output: Hello, Hello, Hello,

Accessing Characters in String by Index Number

  • Individual characters in a string can be accessed using indexing. Indexing starts at 0 in Python.
# Example of accessing characters in a string
my_string = 'Python'
print(my_string[0])    # Output: 'P'
print(my_string[3])    # Output: 'h'

String Slicing and Joining

  • String slicing allows you to extract a substring from a string. It uses the syntax string[start:end:step].
# Example of string slicing
my_string = 'Python Programming'
print(my_string[7:])     # Output: 'Programming'
print(my_string[:6])     # Output: 'Python'
print(my_string[::2])    # Output: 'Pto rgamn'

String Methods

  • Python provides many built-in methods for manipulating strings, such as upper(), lower(), strip(), replace(), split(), etc.
# Example of string methods
my_string = '   Hello, World!   '
print(my_string.strip())            # Output: 'Hello, World!'
print(my_string.lower())            # Output: '   hello, world!   '
print(my_string.replace('Hello', 'Hi'))  # Output: '   Hi, World!   '

Formatting Strings

  • String formatting allows you to interpolate variables and expressions within strings. Python supports multiple ways of string formatting, including f-strings, str.format(), and % formatting.
# Example of string formatting
name = 'Alice'
age = 25
print(f'My name is {name} and I am {age} years old.')
# Output: 'My name is Alice and I am 25 years old.'

Lists

Creating Lists

  • Lists are one of Python's built-in data types used to store multiple items in a single variable. Lists are ordered, mutable, and can contain items of different data types.
# Example of creating lists
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", 3.14, True]

Basic List Operations

  • Lists support a variety of basic operations like concatenation (+), repetition (*), and membership (in).
# Example of basic list operations
list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2
repeated_list = list1 * 3
print(concatenated_list)  # Output: [1, 2, 3, 4, 5, 6]
print(repeated_list)      # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]

Indexing and Slicing in Lists

  • You can access individual elements or slices of a list using indexing and slicing. Indexing starts at 0, and slicing uses the list[start:end:step] syntax.
# Example of indexing and slicing in lists
my_list = [10, 20, 30, 40, 50]
 
# Accessing individual elements
print(my_list[0])    # Output: 10
print(my_list[2])    # Output: 30
 
# Slicing
print(my_list[1:4])  # Output: [20, 30, 40]
print(my_list[::2])  # Output: [10, 30, 50]

Built-In Functions Used on Lists

  • Python provides several built-in functions that can be applied to lists, such as len(), max(), min(), sum(), and sorted().
# Example of built-in functions used on lists
numbers = [10, 5, 8, 3, 7]
 
print(len(numbers))   # Output: 5 (length of the list)
print(max(numbers))   # Output: 10 (maximum element)
print(min(numbers))   # Output: 3 (minimum element)
print(sum(numbers))   # Output: 33 (sum of elements)
print(sorted(numbers))  # Output: [3, 5, 7, 8, 10] (sorted list)

List Methods

  • Python provides several useful methods for lists, such as append(), extend(), insert(), remove(), pop(), reverse(), and sort().
# Example of list methods
my_list = [10, 20, 30]
 
my_list.append(40)    # Adds 40 to the end of the list
print(my_list)        # Output: [10, 20, 30, 40]
 
my_list.insert(1, 15)  # Inserts 15 at index 1
print(my_list)         # Output: [10, 15, 20, 30, 40]
 
my_list.remove(20)     # Removes the first occurrence of 20
print(my_list)         # Output: [10, 15, 30, 40]
 
popped_item = my_list.pop()  # Removes and returns the last item
print(popped_item)           # Output: 40
print(my_list)               # Output: [10, 15, 30]
 
my_list.reverse()      # Reverses the list
print(my_list)         # Output: [30, 15, 10]
 
my_list.sort()         # Sorts the list in ascending order
print(my_list)         # Output: [10, 15, 30]

The del Statement

  • The del statement is used to delete elements from a list or even delete the entire list. You can delete a specific element by its index or slice.
# Example of del statement
my_list = [10, 20, 30, 40, 50]
 
del my_list[1]       # Deletes the element at index 1
print(my_list)       # Output: [10, 30, 40, 50]
 
del my_list[1:3]     # Deletes elements from index 1 to 2 (slice)
print(my_list)       # Output: [10, 50]
 
del my_list          # Deletes the entire list

Functions

Built-in Functions

  • Python comes with several built-in functions for various operations, such as print(), len(), type(), range(), input(), etc. These functions are always available and don't require any imports.
# Example of built-in functions
print("Hello, World!")       # Output: Hello, World!
numbers = [1, 2, 3, 4, 5]
print(len(numbers))          # Output: 5
print(type(numbers))         # Output: <class 'list'>

Commonly Used Modules

  • Python provides a vast standard library with built-in modules that you can import for extended functionality. Some commonly used modules are:

  • math: Mathematical operations.

  • random: Generating random numbers.

  • datetime: Working with dates and times.

  • os: Interfacing with the operating system.

# Example of using commonly used modules
import math
import random
import datetime
 
print(math.sqrt(16))                # Output: 4.0
print(random.randint(1, 10))        # Output: A random number between 1 and 10
print(datetime.datetime.now())      # Output: Current date and time

Definition and Calling the Function

  • A function is defined using the def keyword, followed by the function name and parentheses. A function can be called by using its name followed by parentheses.
# Example of defining and calling a function
def greet(name):
    print(f"Hello, {name}!")
 
greet("Alice")  # Output: Hello, Alice!

Return Statement and Void Function

  • A function can return a value using the return statement. If no return statement is present, or the function returns None, it's considered a "void function".
# Example of function with return statement
def add(a, b):
    return a + b
 
result = add(5, 3)
print(result)  # Output: 8
 
# Example of a void function
def print_message():
    print("This is a void function")
 
print_message()  # Output: This is a void function

Scope and Lifetime of Variables

  • Variables defined inside a function are local to that function and cannot be accessed outside. Variables defined outside any function are global, but you cannot modify global variables inside a function unless explicitly stated using the global keyword.
# Example of variable scope and lifetime
def my_function():
    local_var = 10  # Local variable
    print(local_var)
 
global_var = 20  # Global variable
 
my_function()  # Output: 10
print(global_var)  # Output: 20
 
# Modifying a global variable inside a function
def modify_global():
    global global_var
    global_var = 50
 
modify_global()
print(global_var)  # Output: 50

Default Parameters

  • You can provide default values to function parameters. If the caller doesn't pass a value, the default will be used.
# Example of default parameters
def greet(name="User"):
    print(f"Hello, {name}!")
 
greet()           # Output: Hello, User!
greet("Alice")    # Output: Hello, Alice!

Keyword Arguments

  • Python allows you to call functions using keyword arguments, where the name of the argument is explicitly mentioned, making the function calls more readable.
# Example of keyword arguments
def display_info(name, age):
    print(f"Name: {name}, Age: {age}")
 
display_info(age=25, name="Bob")  # Output: Name: Bob, Age: 25

Command Line Arguments

  • Python allows you to pass arguments to your script from the command line using the sys module. The sys.argv list stores these arguments.
# Example of command-line arguments
import sys
 
def print_arguments():
    print("Command Line Arguments:", sys.argv)
 
# To run this, you would typically use a command like:
# python script.py arg1 arg2 arg3

Questions

  1. What is a string in Python? Explain string operations with an example.
  2. What is string slicing? Provide an example and explain how slicing can be used to reverse a string.
  3. List five methods of string manipulation in Python.
  4. What is a list in Python? Explain list operations with examples.
  5. Describe the list method in Python with an example.
  6. Differentiate between a list and a string in Python.
  7. What is a function in Python? Explain any five built-in functions in Python.
  8. Explain the concept of scope and lifetime of variables within a function.
  9. What is the purpose of a function? How do you declare a function in Python? explain it with an example.

Made By SOU Student for SOU Students