Strings

A string in Python is a sequence of characters enclosed in single (‘),

double (“), or triple (‘’’ or “””) quotes.

Python String Input Output Operation

 Input Operation in Python

 Output Operation in Python

Input Operations in Python

When the user enters data, the input() method always returns a string
data type. If we want to change the data type of our inputs, we have to
use a different conversion method.

Example 1: String Input in Python

The input() method in Python allows you to get user-supplied string input.
The input() method asks the user to enter a string and returns the result
as a string. In this example, the below code takes the user to input their
name and stores it in the variable “name”. Then, it prints out the entered
name with a descriptive message.

Example:

# Prompt the user to enter a string

Name = input(“Enter your name: “)

# Display the input string

print(“You entered:”, name)

Output

Enter your name: abc

You entered: abc

Output Operations in Python

Output operations in Python involve providing information to the user in a

variety of ways, including printing to the console, writing to files,
formatting strings, and creating graphical user interfaces (GUIs). When
creating our code, we must display the results of specific operations that
are executed done in our code. We can do this with the print() method.
The complete syntax for the print() function is:

Example 1: Basic Print Statement in Python

The most basic type of output in Python is printing information to the
console with the print() function. You can print strings, variables, and
expressions as well as modifying the output with formatting choices.

print(“Hello World!”)

Output

Hello World!

String Handling function

String handling functions are essential tools for manipulating text data.
Here’s an overview of some commonly used string functions in Python:

Join(): Concatenates a sequence of strings into a single string, using a

specified separator.

Replace(): Substitutes occurrences of a substring with another string.

Find(): Returns the index of the first occurrence of a substring; returns -1

if not found

Swapcase(): Converts uppercase letters to lowercase and vice versa.

Capitalize(): Converts the first character of the string to uppercase and

the rest to lowercase.

Lower(): Converts all uppercase characters in a string into lowercase

Upper(): Converts all lowercase characters in a string into uppercase

Title(): Convert string to title case.

Example:

Text = ‘geeKs For geEkS’

print(“\nConverted String:”)

print(text.upper())

print(“\nConverted String:”)

print(text.lower())

print(“\nConverted String:”)

print(text.title())

print(“\nConverted String:”)

print(text.swapcase())

print(“\nConverted String:”)
print(text.capitalize())

print(“\nOriginal String”)

print(text)

Output

Converted String:

GEEKS FOR GEEKS

Converted String:

Geeks for geeks

Converted String:

Geeks For Geeks

Converted String:

GEEkS fOR GEeKs

Original String

geeKs For geEkS

Function Prototypes:

i. Function without arguments and without return type

 In this type no argument is passed through the function call and no
output is return to main function
 The sub function will read the input values perform the operation
and print the result in the same block.
Example :
def add():
A=int(input(“enter a”))
B=int(input(“enter b”))
C=a+b
print(c)
add()
OUTPUT:
Enter a 5
Enter b 10

ii) Function with arguments and without return type

 Arguments are passed through the function call but output is not
return to the main function.
Example:
def add(a,b):
C=a+b
print(c)
A=int(input(“enter a”))
B=int(input(“enter b”))
add(a,b)
OUTPUT:
Enter a 5
Enter b 10
15

iii) Function without arguments and with return type

In this type no argument is passed through the function call but

output is return to the main.

Example

def add():
a=int(input("enter a"))
b=int(input("enter b"))
c=a+b
return c
c=add()
print(c)

OUTPUT:

Enter a 5

Enter b 10

15

iv) Function with arguments and with return type

In this type arguments are passed through the function call and output is
return to the main function.

Example

def add(a,b):

c=a+b
return c

a=int(input(“enter a”))

b=int(input(“enter b”))

c=add(a,b)

print(c)

OUTPUT:

Enter a 5

Enter b 10

15

Return Statement

The Python return statement marks the end of a function and

specifies the value or values to pass back from the function. Return
statements can return data of any type, including integers, floats, strings,
lists, dictionaries, and even other functions. If no return statement is used,
or if a return statement is used without a value, the function will implicitly
return

Example:

def add(a, b):

return a + b

result = add(3, 5)

print(result) # Output: 8

Nesting of Functions

Nesting functions involves defining a function inside another function,

also known as inner or nested functions. These inner functions can access
the enclosing function’s Example:

def outer_function(x):

def inner_function(y):

return x + y

return inner_function

closure = outer_function(10)

print(closure(5)) # Output: 15
Categories of Functions

Python functions can be categorized as follows:

Built-in functions: These are functions that are readily available in

Python without requiring any additional imports. Examples include print(),
len(), abs(), range(), sum(), max(), min(), etc.

Example

result = max([1, 5, 3, 9, 2]) # Using the built-in max() function

print(result) # Output: 9

User-defined functions: These are functions created by the

programmer to perform specific tasks. They are defined using the def
keyword, followed by the function name, parentheses for parameters, and
a colon. The function body is indented below the definition line.

Example

def greet(name):

print(“Hello, “ + name + “!”)

greet(“Alice”) # Output: Hello, Alice!

Lambda functions (anonymous functions): These are small, single-

expression functions that can be defined without a name using the
lambda keyword. They are often used for short, simple operations.

Example

add = lambda x, y: x + y

result = add(5, 3) # Output: 8

Recursive functions: These are functions that call themselves within

their own definition. They are useful for solving problems that can be
broken down into smaller, self-similar subproblems.

Example

def factorial(n):

if n == 0:

return 1

else:

return n * factorial(n – 1)

result = factorial(5) # Output: 120

Recursive functions:

A recursive function is defined like any other function, but it includes a

call to itself. The syntax and structure of a recursive function follow the
typical function definition in Python, with the addition of one or more
conditions that lead to the function calling itself.

Example

def factorial(n):

if n == 0:

return 1

else:

return n * factorial(n – 1)

print(factorial(5)) # Output: 120

Parameter Passing by Address & by Value

Immutable objects (e.g., int, float, str, tuple) behave like pass by value
because changes inside the function do not affect the original object.

Mutable objects (e.g., list, dict, set) behave like pass by reference
because changes inside the function modify the original object.

Pass by Value (Immutable Objects)

Immutable objects cannot be changed inside a function. If modified, a new

object is created instead of modifying the original one.

Example (Pass by Value)

def modify(x):

x= 10 # This creates a new local variable, not modifying the original

print(“Inside function:”, x)

a= 5

modify(a)

print(“Outside function:”, a) # Original value remains unchanged

Output

Inside function: 10

Outside function: 5
Pass by Reference (Mutable Objects)

Mutable objects can be modified inside a function, affecting the original

object.

Example (Pass by Reference)

def modify_list(lst):

lst.append(4) # Modifying the original list

numbers = [1, 2, 3]

modify_list(numbers)

print(numbers) # The change reflects in the original list

Output:

[1, 2, 3, 4]

Global and Local Variables in Python

Python Local Variables

Local variables in Python are those which are initialized inside a function
and belong only to that particular function. It cannot be accessed
anywhere outside the function.

def func():

X = 10 # Local variable

print(x)

func() #Output 10

Python Global Variables

These are those which are defined outside any function and which are
accessible throughout the program, i.e., inside and outside of every
function. Let’s see how to create a Python global variable.

x = 10 # Global variable

def func():

global x

x = 20 # Modifies global variable

func()

print(x) # Output: 20
Storage Classes in Python

Python does not have explicit storage classes like automatic, external,
static, and register. However, Python provides similar behavior through
variable scope and lifetime management.

Automatic Storage (Local Variables)

 Variables declared inside a function are local and exist only during
the function’s execution.
 Automatically created and destroyed when the function finishes
execution.

Example (Automatic Variable)

def func():

x = 10 # Local variable (automatic storage)

 print(x)

func()

Output: 10

External Storage (Global Variables)

 Global variables exist throughout the program’s execution.

 Declared outside functions and can be accessed anywhere.
 Use the global keyword inside a function to modify a global variable.

Example

def compute():

a, b = 5, 10 # Local variables (optimized)

return a + b

print(compute()) # Output: 15

Static Storage (Using nonlocal)

 In nested functions, nonlocal behaves like static storage in C.

 Retains value between function calls within the same scope.

Example

def outer():

x = 0 # Static-like variable

def inner():

nonlocal x # Retains value between calls

x += 1

print(x)

return inner

counter = outer()

counter() # Output: 1

counter() # Output: 2

counter() # Output: 3

Register Storage (Optimized by Python Interpreter)

 Python does not allow direct access to CPU registers like C.

 However, Python optimizes frequently accessed variables internally.
 The best practice is to use local variables for fast access.
Example

def compute():

a, b = 5, 10 # Local variables (optimized)

return a + b

print(compute()) # Output: 15