[go: up one dir, main page]
Scribd
Upload
3 views6 pages

Unit 3 Python

The document provides an overview of Python's complex data types including strings, lists, tuples, and dictionaries, along with their operations and methods. It covers string manipulation, list slicing, tuple characteristics, and dictionary key-value pairs, as well as defining and using functions in Python. Additionally, it includes examples of basic and recursive functions to demonstrate practical applications of these concepts.

Uploaded by

Satyam Singh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
3 views6 pages

Unit 3 Python

The document provides an overview of Python's complex data types including strings, lists, tuples, and dictionaries, along with their operations and methods. It covers string manipulation, list slicing, tuple characteristics, and dictionary key-value pairs, as well as defining and using functions in Python. Additionally, it includes examples of basic and recursive functions to demonstrate practical applications of these concepts.

Uploaded by

Satyam Singh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Python Complex Data Types and

Functions - Lecture Notes


1. String Data Type and String Operations
Strings in Python are sequences of characters, enclosed either in single, double, or triple
quotes.
Common string operations include concatenation, repetition, indexing, and slicing.

Example:
text = "Hello, World!"
print(text[0]) # Output: H
print(text[0:5]) # Output: Hello
print(text.lower()) # Output: hello, world!

2. Defining List and List Slicing


Lists are ordered, mutable collections of items. They are defined using square brackets [].
Slicing allows retrieval of a portion of the list.

Example:
numbers = [1, 2, 3, 4, 5]
print(numbers[1:4]) # Output: [2, 3, 4]
numbers.append(6)
print(numbers) # Output: [1, 2, 3, 4, 5, 6]

Python uses zero-based indexing.

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

print(fruits[0]) # Output: apple

print(fruits[2]) # Output: cherry

Negative indexing starts from the end:

print(fruits[-1]) # Output: cherry

List Slicing

Slicing is used to extract a portion (sublist) of a list. The syntax is


list[start:stop:step]

• start: index where the slice starts (inclusive)

• stop: index where the slice ends (exclusive)

• step: interval between elements (default is 1)

numbers = [10, 20, 30, 40, 50, 60, 70]

print(numbers[1:5]) # [20, 30, 40, 50]

print(numbers[:4]) # [10, 20, 30, 40]

print(numbers[3:]) # [40, 50, 60, 70]

print(numbers[::2]) # [10, 30, 50, 70]

print(numbers[::-1]) # [70, 60, 50, 40, 30, 20, 10]

# Reverse a list

reversed_list = numbers[::-1]

# Extract every 3rd element from the list

step_slice = numbers[::3]

# Slice from index 2 to the second-last element

mid_slice = numbers[2:-1]

3. Use of Tuple Data Type


Tuples are similar to lists but are immutable. They are defined using parentheses ().

Example:
coordinates = (10, 20)
print(coordinates[0]) # Output: 10
# A simple tuple
coordinates = (10, 20)

# A tuple with mixed data types

person = ("Alice", 25, "Engineer")

# A tuple without parentheses (tuple packing)

data = 1, 2, 3

# An empty tuple

empty = ()

# A tuple with one element (must include a comma)

single_element = (42,)

Tuple Slicing

Tuples can be sliced just like lists:

t = (1, 2, 3, 4, 5)

print(t[1:4]) # Output: (2, 3, 4)

print(t[:3]) # Output: (1, 2, 3)

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

Iterating Through a Tuple

colors = ("red", "green", "blue")

for color in colors:

print(color)

Feature List Tuple


Syntax [] ()
Feature List Tuple
Mutable Yes No
Indexed Yes Yes
Slicing Yes Yes
Use Case Dynamic data Static data

4. Dictionary Manipulation
Dictionaries are unordered collections of key-value pairs. They are defined using curly
braces {}.

Example:
student = {"name": "Alice", "age": 23}
print(student["name"]) # Output: Alice
student["age"] = 24
print(student) # Output: {'name': 'Alice', 'age': 24}

5. Manipulation Methods
String Methods: upper(), lower(), find(), replace(), split()
List Methods: append(), remove(), pop(), sort(), reverse()
Dictionary Methods: keys(), values(), items(), get(), update()

6. Programming Examples
Example 1: String Functions
text = "Python Programming"
print(text.replace("Python", "Java")) # Output: Java Programming

Example 2: List Functions


fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')
print(fruits) # Output: ['apple', 'cherry']

Example 3: Dictionary Functions


grades = {'Math': 90, 'Science': 85}
print(grades.get('Math')) # Output: 90
grades.update({'English': 88})
print(grades) # Output: {'Math': 90, 'Science': 85, 'English': 88}

7. Python Functions and Organizing Code


Functions are blocks of reusable code. They are defined using the def keyword.

Example:
def greet(name):
return "Hello " + name

print(greet("Alice")) # Output: Hello Alice

Functions help modularize and organize code logically.

1. Basic Function Programs


Example 1: Add two numbers using a function
def add(a, b):
return a + b

print("Sum:", add(10, 20)) # Output: Sum: 30

Example 2: Check even or odd using a function


def is_even(num):
return num % 2 == 0

print("Is 4 even?", is_even(4)) # Output: True

Example 3: Find maximum of three numbers


def find_max(x, y, z):
return max(x, y, z)

print("Maximum:", find_max(10, 20, 5)) # Output: 20

2. Recursive Function Programs


Example 1: Factorial using recursion
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)

print("Factorial of 5:", factorial(5)) # Output: 120

Example 2: Fibonacci series using recursion


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

for i in range(6):
print(fibonacci(i), end=" ") # Output: 0 1 1 2 3 5

Example 3: Sum of digits using recursion


def sum_of_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_of_digits(n // 10)

print("Sum of digits of 1234:", sum_of_digits(1234)) # Output: 10

Example 4: Power function using recursion


def power(base, exponent):
if exponent == 0:
return 1
else:
return base * power(base, exponent - 1)

print("2^5 =", power(2, 5)) # Output: 32

You might also like