Basics of Python Programming

Introduction to Python

Python is a versatile, high-level programming language known for its readability and
simplicity. Designed with an emphasis on code clarity, Python uses straightforward syntax
that resembles everyday English, making it accessible for beginners and powerful for experts.
It supports various programming paradigms, including procedural, object-oriented, and
functional programming. Python is widely used in web development, data analysis, artificial
intelligence, scientific computing, and automation. Its extensive library ecosystem and
supportive community contribute to its popularity and effectiveness in solving diverse
problems.

Features of Python

Python is a dynamic, high-level, free open source, and interpreted programming language. It
supports object-oriented programming as well as procedural-oriented programming.
In Python, we don’t need to declare the type of variable because it is a dynamically typed
language. For example, x = 10 Here, x can be anything such as String, int, etc. In this article,
we will see what characteristics describe the Python programming language

First off, Python is known for its readable and clean syntax. Imagine writing code that
looks almost like plain English. This means you don’t need to struggle with confusing syntax
just to get things done. For example, a simple line of Python code might look like this:
print("Hello, world!"). It's easy to understand, even if you're new to programming.

 Another fantastic feature is Python's versatility. It can be used for a wide range of
tasks, from web development with frameworks like Django and Flask to data analysis
with libraries like Pandas and NumPy. Want to dive into machine learning? Python's
got you covered with libraries like TensorFlow and Scikit-learn. It’s like having a
universal remote for tech projects.

 Python is a high-level programming language. Python is very easy to learn the

language as compared to other languages like C, C#, Javascript, Java, etc. It is very
easy to code in the Python language and anybody can learn Python basics in a few
hours or days. It is also a developer-friendly language.

 Python also boasts extensive libraries and frameworks. Think of libraries as pre-
built chunks of code that you can use to solve specific problems without having to
reinvent the wheel. Need to handle HTTP requests? There’s a library for that. Want to
plot some graphs? Python has libraries for that too. It’s a bit like having a giant
toolbox where you can pick the right tool for your project.

 One of the key features of Python is Object-Oriented programming. Python supports

object-oriented language and concepts of classes, object encapsulation, etc.

 Python is a high-level language. When we write programs in Python, we do not need

to remember the system architecture, nor do we need to manage the memory.
  Interactivity is another cool aspect. Python supports interactive coding through
environments like Jupyter Notebooks, where you can write code and immediately see
the results. It’s great for experimenting with code snippets and seeing how changes
affect your results in real-time.

 Lastly, Python has a strong community. Whether you’re stuck on a problem or

looking for a library, there’s a massive community ready to help out. Forums,
tutorials, and online courses abound, so you’re never really alone on your coding
journey.

In short, Python’s clean syntax, versatility, extensive libraries, interactive nature, and
supportive community make it a powerful and accessible language for a variety of
programming tasks.

Executing a Simple “hello world" Program

Executing a simple "Hello, World!" program in Python is a great way to get started with
coding and see how the language works. It’s like the “welcome mat” of programming—easy
to do and shows you that everything is set up correctly. Here’s how you can run this classic
program:

1. Open Your Code Editor: First, you need a place to write your code. You can use any
text editor like Notepad, but it's better to use a code editor like Visual Studio Code,
PyCharm, or even an interactive environment like Jupyter Notebook.

2. Write the Code: In your editor, type the following line of code:

print("Hello, World!")

This line uses the print() function to display the text "Hello, World!" on the screen.
The print() function is a built-in Python function that outputs whatever is inside the
parentheses to the console.

3. Save Your File: Save your file with a .py extension, for example, hello_world.py.
The .py tells your computer that this file is a Python script.

4. Run the Program: To see your code in action, you need to execute it. If you’re using
a terminal or command prompt, navigate to the directory where you saved your file
and type:

python hello_world.py

Press Enter, and you should see Hello, World! displayed on the screen.

5. See the Magic: When you run the program, Python reads the print() statement and
displays "Hello, World!" on your screen. It’s like a friendly introduction from Python
saying, “Hey, your setup is all good, and I’m ready to run your code!”
That’s all there is to it! You've just executed your first Python program. It’s a simple start, but
it opens the door to more complex coding adventures. If you see the "Hello, World!"
message, you’re ready to dive deeper into the world of Python programming.

Execution Modes: Interactive mode and Script mode

In Python, you have two main ways to run your code: interactive mode and script mode. Each
mode serves a different purpose and is useful in different scenarios.

Interactive Mode:

 What It Is: Interactive mode allows you to write and execute Python code one line at
a time. It’s like having a conversation with Python where you type a command and
instantly see the result.

 How to Use It: To start interactive mode, simply open your terminal or command
prompt and type python or python3. You’ll enter the Python shell, indicated by the
>>> prompt, where you can type Python commands directly.

 When to Use It: Interactive mode is great for experimenting with small code
snippets, testing ideas, or learning how Python functions work. For example, you can
quickly test a function or perform calculations without having to save and run a script.

Script Mode:

 What It Is: Script mode involves writing Python code in a file (usually with a .py
extension) and then running the entire file as a program. This mode is suited for larger
programs or when you want to run the same code multiple times.

 How to Use It: Write your Python code in a text editor and save the file with a .py
extension. To execute the script, open your terminal or command prompt, navigate to
the file’s location, and type python filename.py (replace filename with your file’s
name).

 When to Use It: Script mode is ideal for developing and running complete programs
or scripts. It allows you to organize your code into files, making it easier to manage
and reuse.

Python Character Set

Python's character set is essentially the collection of characters that the language recognizes
and can process. This set includes a variety of characters, which are integral for writing and
executing Python code:

1. Alphabetic Characters: Python recognizes both uppercase (A-Z) and lowercase (a-z)
letters. These characters are used for naming variables, functions, classes, and more.

2. Digits: Numbers from 0 to 9 are used in Python for numeric literals, variable names,
and other expressions.
 3. Special Characters: Python supports a range of special characters that are used for
various syntactic purposes:

o Operators: Such as +, -, *, /, %, and =.

o Punctuation: Includes characters like (), {}, [], ., ,, ;, and :.

o Quotation Marks: Single (') and double (") quotes are used for defining
string literals.

o Escape Characters: Such as \n (newline) and \t (tab), which are used to

format strings.

4. Whitespace Characters: Spaces, tabs, and newlines are used to format and separate
code. Python is sensitive to indentation, which uses spaces or tabs to define the
structure of the code.

5. Unicode Characters: Python supports Unicode, allowing it to handle a wide range of

characters from different languages and symbol sets. This includes characters from
non-English alphabets, emojis, and special symbols.

Python Tokens (keyword, identifier, literal, operator,

punctuator)
In Python, tokens are the building blocks of the language's syntax. They are the smallest units
of meaning in a program, and they fall into several categories:

1. Keywords: These are reserved words that have a special meaning in Python. They
cannot be used as identifiers (names for variables, functions, etc.). Keywords define
the language’s syntax and structure. For example, if, else, for, while, and def are
all keywords. They control the flow of the program or define its structure.

2. Identifiers: Identifiers are names given to various program elements like variables,
functions, and classes. They must start with a letter (A-Z or a-z) or an underscore (_),
followed by letters, digits, or underscores. Examples include variable_name,
my_function, and ClassName. They help us reference and manipulate data within our
code.

3. Literals: Literals are constant values directly written in the code. They represent data
like numbers, text, or boolean values. For instance:

o String literals: 'hello', "world"

o Numeric literals: 123, 3.14

o Boolean literals: True, False

o Special literals: None (represents the absence of a value)

 4. Operators: Operators perform operations on variables and values. Python includes
various operators, such as:

o Arithmetic operators: +, -, *, /, %

o Comparison operators: ==, !=, >, <, >=, <=

o Logical operators: and, or, not

o Assignment operators: =, +=, -=, *=, /=

5. Punctuators: Punctuators are symbols that help define the structure and syntax of
Python code. They include:

o Parentheses: (), used for grouping expressions and function calls.

o Braces: {}, used for defining dictionaries and sets.

o Brackets: [], used for lists and indexing.

o Comma: ,, used to separate items in lists or function arguments.

o Colon: :, used to define blocks of code, such as in loops and conditionals.

Variables
In Python, variables are like containers that store data values. You can think of them as labels
for pieces of information that you want to use in your program. Here's a quick rundown on
how variables work and some key points to know:

1. Naming Variables: Variables in Python are named with identifiers. They should start
with a letter (A-Z or a-z) or an underscore (_), followed by letters, digits, or
underscores. For example, age, student_name, and total_score are all valid names.
Python is case-sensitive, so score and Score would be considered different variables.

2. Assigning Values: To assign a value to a variable, you use the equals sign (=). For
instance:

age = 16
name = "Alice"

Here, age is assigned the integer 16, and name is assigned the string "Alice".

3. Types of Variables: Python is dynamically typed, which means you don’t need to
specify the type of a variable when you declare it. The type is determined
automatically based on the value assigned. Python can handle various data types
including:

o Integers: Whole numbers like 5 or 100

 o Floats: Decimal numbers like 3.14 or 0.5

o Strings: Text enclosed in quotes like "hello" or 'world'

o Booleans: True or False values

4. Reassigning Values: You can change the value of a variable by assigning a new
value to it. For example:

age = 16
age = 17

Here, the variable age initially holds 16, but after the reassignment, it holds 17.

5. Using Variables: Once you have a variable, you can use it in expressions, print it, or
manipulate it in various ways. For example:

total = age + 5
print("In 5 years, you will be", total)

6. Scope of Variables: The scope of a variable refers to where it can be accessed in your
code. Variables defined inside a function are local to that function and can’t be
accessed outside of it, while variables defined outside functions are global and can be
accessed anywhere in the script.

Concept of l-value and r-value

In programming, the concepts of l-value and r-value help us understand how variables and
values are used and manipulated in expressions. They might sound a bit abstract at first, but
they’re crucial for understanding how assignment and expressions work.

l-value (Left-hand Value)

 Definition: An l-value refers to an expression that represents a location in memory

where a value can be stored. Essentially, it’s something that has a specific address
where data can be placed or updated.

 Characteristics:

o It can appear on the left side of an assignment statement because you can
assign a value to it.

o It often represents variables or objects that can hold data.

 Example: In the assignment x = 10, x is an l-value. It represents a memory location

where the value 10 is stored.

r-value (Right-hand Value)

  Definition: An r-value represents the actual value or data that is being assigned to an
l-value. It is a value that does not have a specific memory location but can be used to
assign a value to an l-value.

 Characteristics:

o It can appear on the right side of an assignment statement because it provides

the value to be stored.

o It often represents constants or expressions that produce values.

 Example: In the same assignment x = 10, 10 is an r-value. It is the value being

assigned to the variable x.

Illustrative Example:

Consider the expression a = b + 5:

 l-value: a is an l-value because it represents the memory location where the result of
the expression b + 5 will be stored.

 r-value: b + 5 is an r-value because it represents the value that will be calculated and
assigned to a.

Key Points:

 l-values can be assigned new values. They are typically variables or objects that can
be modified.

 r-values are typically values or expressions that provide the data for the assignment.
They do not have a fixed memory location.

Use of Comments
Comments in programming are crucial for creating readable, maintainable, and
understandable code. They are notes embedded in the code that are ignored by the compiler
or interpreter during execution but can be incredibly useful for developers. Here’s a quick
guide to using comments effectively:

Purpose of Comments

1. Documentation:

o Explanation: Comments help explain what a section of code does, making it

easier for others (and yourself) to understand the logic and purpose behind the
code. This is especially important for complex or non-obvious code.

o Example:
 # Calculate the area of a circle
area = 3.14 * radius * radius

2. Clarification:

o Clarify Code: They can clarify why a particular approach or algorithm was
used, which can be useful for future maintenance or for other developers
reading your code.

o Example:

# Using a binary search algorithm for faster lookups

result = binary_search(sorted_list, target_value)

3. TODOs and Notes:

o Future Work: Comments can be used to indicate tasks that need to be

completed or improvements that could be made later.

o Example:

# TODO: Optimize this function for better performance

4. Debugging:

o Temporary Changes: During debugging, comments can help temporarily

disable parts of the code to isolate issues.

o Example:

# print("Debug info:", debug_variable) # Commented out for

debugging

5. Code Collaboration:

o Team Communication: In collaborative projects, comments can be used to

communicate intentions, decisions, or instructions to other team members.

o Example:

# This function is used for user authentication

Types of Comments in Python

1. Single-Line Comments:

o Syntax: Use the # symbol to comment on a single line.

o Example:
 # This is a single-line comment
print("Hello, World!") # Inline comment

2. Multi-Line Comments:

o Syntax: Use triple quotes (''' or """) for multi-line comments, although
technically, these are multi-line strings that are not assigned to a variable.

o Example:

"""
This is a multi-line comment
that spans multiple lines.
"""
print("Hello, World!")

Best Practices

 Be Clear and Concise: Write comments that are easy to understand and directly
related to the code.

 Avoid Redundancy: Don’t state the obvious. Instead of saying “increment x by 1,”
explain why the increment is necessary.

 Keep Comments Up-to-Date: Update comments when the code changes to avoid
misleading information.

Knowledge of Data Types

Understanding data types is fundamental in programming because they determine what kind
of data can be stored and manipulated. In Python, data types help you manage and work with
various kinds of data. Here’s a breakdown of some key data types you’ll encounter:

Basic Data Types

1. Integers (int):

o Definition: Whole numbers without a decimal point.

o Example: 5, 100, -42

o Usage: Used for counting, indexing, and mathematical operations.

o Range: Integers can be positive, negative, or zero. Python supports very large
integers, limited by available memory.

2. Floating-Point Numbers (float):

o Definition: Numbers that contain a decimal point.

 o Example: 3.14, 0.99, -7.5

o Usage: Used for precise measurements, calculations involving fractions, and

scientific calculations.

o Precision: Floating-point numbers are approximate and have a limited

precision based on the number of bits used to store them. They are subject to
rounding errors.

3. Strings (str):

o Definition: Sequences of characters enclosed in single (') or double quotes

(").

o Example: "Hello", 'World', "123"

o Usage: Used for text processing, displaying messages, and handling user
input.

4. Booleans (bool):

o Definition: Represents truth values, either True or False.

o Example: True, False

o Usage: Used for conditional statements and logical operations.

5. Complex Numbers (complex)

 Definition: Numbers that have both a real and an imaginary part. The imaginary part
is indicated by the letter j or J.

 Format: A complex number is written as real_part + imaginary_part * j.

 Example: 3 + 4j, -2 - 5j

 Usage: Used in advanced mathematics, physics, and engineering where calculations

involve complex numbers. They are especially useful in fields like signal processing
and quantum computing.

Examples in Python:

1. Integer:

number = 10
print(type(number)) # Output: <class 'int'>

2. Floating-Point:
 pi = 3.14159
print(type(pi)) # Output: <class 'float'>

3. Complex:

z = 2 + 3j
print(type(z)) # Output: <class 'complex'>

Compound Data Types

1. Lists (list):

o Definition: Ordered, mutable collections of items enclosed in square brackets

([]). Items can be of different types.

o Example: [1, 2, 3, 4], ['apple', 'banana', 'cherry']

o Usage: Used to store multiple items in a single variable and to perform

operations on those items.

2. Tuples (tuple):

o Definition: Ordered, immutable collections of items enclosed in parentheses

(()). Items can be of different types.

o Example: (1, 2, 3, 4), ('red', 'green', 'blue')

o Usage: Used to store multiple items in a fixed order where the data shouldn’t
change.

3. Dictionaries (dict):

o Definition: Unordered collections of key-value pairs enclosed in curly braces

({}). Keys are unique, and values can be of any type.

o Example: {'name': 'Alice', 'age': 25, 'city': 'New York'}

o Usage: Used to store and retrieve data efficiently using keys.

4. Sets (set):

o Definition: Unordered collections of unique items enclosed in curly braces

({}).

o Example: {1, 2, 3}, {'apple', 'banana'}

o Usage: Used to store unique items and perform mathematical set operations
like union, intersection, and difference.

Special Data Types

 1. NoneType (None):

o Definition: Represents the absence of a value or a null value.

o Example: None

o Usage: Used to signify that a variable has no value or to represent missing or

undefined data.

Key Points

 Type Conversion: You can convert between data types using functions like int(),
float(), str(), and bool().

age = 25 # int
height = 5.9 # float
name = str(age) # converts int to string

 Dynamic Typing: Python is dynamically typed, meaning you don’t need to declare a
variable’s type explicitly. The type is determined at runtime based on the assigned
value.

None
In Python, None is a special constant that represents the absence of a value or a null value. It’s
a unique data type, NoneType, and is used in various scenarios to indicate that something is
undefined or missing.

Key Points About None:

1. Representation of Absence:

o Definition: None is used to signify that a variable or function does not have a
value assigned to it. It can be thought of as a placeholder or a default value
when no other value is provided.

o Example:

result = None

2. Default Return Value:

o Definition: If a function doesn’t explicitly return a value, Python returns None

by default.

o Example:

def no_return():
pass
 print(no_return()) # Output: None

3. Use in Conditional Statements:

o Definition: You can use None in conditional statements to check if a variable

has been assigned a value.

o Example:

variable = None

if variable is None:
print("Variable is not assigned.")

4. Function Parameters:

o Definition: None is often used as a default value for function parameters to

indicate that no argument was provided. This is useful for optional parameters.

o Example:

def greet(name=None):
if name is None:
print("Hello, World!")
else:
print(f"Hello, {name}!")

greet() # Output: Hello, World!

greet("Alice") # Output: Hello, Alice!

5. Comparison:

o Definition: None is often compared using is rather than == to check if a

variable is None, as None is a singleton (only one instance exists).

o Example:

a = None
b = None

print(a is b) # Output: True

Why Use None?

 Initialization: It is useful for initializing variables that will later be assigned a

meaningful value.

 Function Return: It provides a clear indication when a function does not return any
specific value.

 Optional Parameters: It allows for optional parameters in functions, providing

flexibility in function calls.
Mapping(dictionary)
In Python, a dictionary is a built-in data structure that allows you to store and manage data in
key-value pairs. It’s a type of mapping where each key is associated with a value, making it
easy to look up data based on a unique identifier.

Key Features of Dictionaries:

1. Key-Value Pairs:

o Definition: A dictionary stores data in pairs where each key maps to a specific
value. Keys must be unique within a dictionary, but values can be duplicated.

o Example:

student = {
"name": "Alice",
"age": 18,
"courses": ["Math", "Science"]
}

2. Unordered:

o Definition: Dictionaries are unordered collections, meaning that the items

have no index. The order of key-value pairs is not guaranteed to be preserved.

o Example:

print(student)
# Output: {'name': 'Alice', 'age': 18, 'courses': ['Math',
'Science']}

3. Mutable:

o Definition: Dictionaries are mutable, meaning you can change their content
after creation. You can add, remove, or modify key-value pairs.

o Example:

student["age"] = 19 # Update existing key

student["grade"] = "A" # Add new key-value pair

4. Accessing Values:

o Definition: Values in a dictionary are accessed using their associated keys. If

the key does not exist, it will raise a KeyError.

o Example:

print(student["name"]) # Output: Alice

 5. Methods:

o Definition: Dictionaries come with several useful methods for handling data.

 .get(key, default): Returns the value for a key if it exists,

otherwise returns a default value.

print(student.get("age", "Not Found")) # Output: 19

print(student.get("address", "Not Found")) # Output: Not
Found

 .keys(): Returns a view object displaying all the keys.

print(student.keys()) # Output: dict_keys(['name',

'age', 'courses', 'grade'])

 .values(): Returns a view object displaying all the values.

print(student.values()) # Output: dict_values(['Alice',

19, ['Math', 'Science'], 'A'])

 .items(): Returns a view object displaying all the key-value pairs.

print(student.items()) # Output: dict_items([('name',

'Alice'), ('age', 19), ('courses', ['Math', 'Science']),
('grade', 'A')])

6. Deleting Items:

o Definition: You can remove items using methods like del or the .pop()
method.

o Example:

del student["grade"] # Removes the 'grade' key

removed_value = student.pop("age") # Removes and returns the
value associated with 'age'

Example Usage:

Here’s a simple example that demonstrates some of these features:

# Creating a dictionary
car = {
"make": "Toyota",
"model": "Corolla",
"year": 2021
}

# Accessing a value
print(car["make"]) # Output: Toyota

# Adding a new key-value pair

car["color"] = "Blue"
# Modifying an existing value
car["year"] = 2022

# Removing a key-value pair

del car["model"]

# Checking keys and values

print(car.keys()) # Output: dict_keys(['make', 'year', 'color'])
print(car.values()) # Output: dict_values(['Toyota', 2022, 'Blue'])

Mutable and Immutable Data Types

In Python, data types are categorized into mutable and immutable based on whether their
content can be changed after they are created. Understanding the difference between these
two categories is essential for effective programming and memory management.

Mutable Data Types

Mutable data types are those whose values can be changed after they are created. This means
that you can modify, add, or remove elements from these objects without creating a new
object.

Examples of Mutable Data Types:

1. Lists (list):

o Definition: Ordered collections of items that can be changed after creation.

o Operations: You can modify individual elements, add new elements, or

remove elements.

o Example:

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

fruits[1] = "blueberry" # Modifies the second item
fruits.append("orange") # Adds a new item

2. Dictionaries (dict):

o Definition: Collections of key-value pairs where the data can be modified

after creation.

o Operations: You can add, update, or remove key-value pairs.

o Example:

student = {"name": "Alice", "age": 18}

student["age"] = 19 # Updates the value
student["grade"] = "A" # Adds a new key-value pair

3. Sets (set):
 o Definition: Unordered collections of unique elements that can be modified.

o Operations: You can add or remove elements from a set.

o Example:

numbers = {1, 2, 3}
numbers.add(4) # Adds a new element
numbers.remove(2) # Removes an element

Immutable Data Types

Immutable data types are those whose values cannot be changed after they are created. Any
operation that seems to modify the object actually creates a new object.

Examples of Immutable Data Types:

1. Integers (int):

o Definition: Whole numbers without decimal points.

o Operations: Any arithmetic operation creates a new integer object.

o Example:

a = 5
a += 2 # Creates a new integer object, 7

2. Floating-Point Numbers (float):

o Definition: Numbers with decimal points.

o Operations: Operations like addition or multiplication create new float

objects.

o Example:

pi = 3.14
pi += 0.01 # Creates a new float object

3. Strings (str):

o Definition: Sequences of characters.

o Operations: Concatenation or slicing creates new string objects.

o Example:

message = "Hello"
message = message + " World" # Creates a new string object
 4. Tuples (tuple):

o Definition: Ordered collections of elements, similar to lists but immutable.

o Operations: Any modification creates a new tuple object.

o Example:

coordinates = (10, 20)

new_coordinates = coordinates + (30,) # Creates a new tuple

Key Differences:

 Mutability: Mutable types allow in-place modification (e.g., you can change a list or
dictionary without creating a new one). Immutable types do not (e.g., changing a
string results in a new string).

 Memory Efficiency: Immutable types are generally more memory-efficient because

their values cannot change, and Python can optimize their storage.

 Use Cases: Mutable types are used when you need to change the data structure after
creation (e.g., dynamic lists or dictionaries). Immutable types are used when you need
constant values that should not change (e.g., fixed configuration settings).

Operators
Arithmetic operators, Relational operators, Logical operators

In Python, operators are special symbols that perform operations on variables and values.
They can be broadly categorized into arithmetic operators, relational operators, and logical
operators. Here's a breakdown of each category:

Arithmetic Operators

Arithmetic operators are used to perform basic mathematical operations.

 Addition (+): Adds two numbers or concatenates two strings.

o Example:

result = 5 + 3 # Output: 8
text = "Hello" + " World" # Output: "Hello World"

 Subtraction (-): Subtracts one number from another.

o Example:

result = 10 - 4 # Output: 6

 Multiplication (*): Multiplies two numbers or repeats a string.

 o Example:

result = 7 * 2 # Output: 14
text = "Hi! " * 3 # Output: "Hi! Hi! Hi! "

 Division (/): Divides one number by another, returning a float.

o Example:

result = 10 / 3 # Output: 3.3333333333333335

 Floor Division (//): Divides one number by another, returning the largest integer less
than or equal to the result.

o Example:

result = 10 // 3 # Output: 3

 Modulus (%): Returns the remainder of a division.

o Example:

result = 10 % 3 # Output: 1

 Exponentiation (**): Raises one number to the power of another.

o Example:

result = 2 ** 3 # Output: 8

Relational Operators

Relational operators are used to compare values. They return a boolean value ( True or
False).

 Equal to (==): Checks if two values are equal.

o Example:

result = (5 == 5) # Output: True

 Not equal to (!=): Checks if two values are not equal.

o Example:

result = (5 != 3) # Output: True

 Greater than (>): Checks if the value on the left is greater than the value on the right.

o Example:
 result = (7 > 4) # Output: True

 Less than (<): Checks if the value on the left is less than the value on the right.

o Example:

result = (2 < 6) # Output: True

 Greater than or equal to (>=): Checks if the value on the left is greater than or equal
to the value on the right.

o Example:

result = (5 >= 5) # Output: True

 Less than or equal to (<=): Checks if the value on the left is less than or equal to the
value on the right.

o Example:

result = (5 >= 5) # Output: True

Logical Operators

Logical operators are used to combine conditional statements and return boolean results.

 And (and): Returns True if both statements are true.

o Example:

result = (5 > 3) and (8 < 10) # Output: True

 Or (or): Returns True if at least one of the statements is true.

o Example:

result = (5 > 3) or (8 > 10) # Output: True

 Not (not): Reverses the logical state of its operand. Returns True if the statement is
false, and False if the statement is true.

o Example:

result = not (5 > 3) # Output: False

These operators are fundamental in programming as they allow you to perform

calculations, make decisions, and control the flow of your programs based on
conditions.

Assignment Operators, Augmented Assignment Operators

In Python, assignment operators and augmented assignment operators are used to assign
values to variables and modify them in different ways. Here’s a breakdown of each:

Assignment Operators

Assignment operators are used to assign values to variables.

 Assignment (=): Assigns a value to a variable.

o Example:

x = 5 # Assigns the value 5 to the variable x

Augmented Assignment Operators

Augmented assignment operators combine an arithmetic operation with an assignment. They

provide a shorthand way to update the value of a variable.

1. Addition Assignment (+=): Adds a value to the variable and assigns the result back to the
variable.

Example:

x = 10
x += 5 # Equivalent to x = x + 5; x now equals 15

2. Subtraction Assignment (-=): Subtracts a value from the variable and assigns the result
back to the variable.

Example:

y = 20
y -= 7 # Equivalent to y = y - 7; y now equals 13

3. Multiplication Assignment (*=): Multiplies the variable by a value and assigns the result
back to the variable.

Example:

z = 4
z *= 3 # Equivalent to z = z * 3; z now equals 12

4. Division Assignment (/=): Divides the variable by a value and assigns the result back to
the variable. Note that this will always result in a float.

Example:

a = 8
a /= 2 # Equivalent to a = a / 2; a now equals 4.0
5. Floor Division Assignment (//=): Performs floor division (division that rounds down) on
the variable and assigns the result back to the variable.

Example:

b = 7
b //= 2 # Equivalent to b = b // 2; b now equals 3

6. Modulus Assignment (%=): Calculates the remainder of the variable divided by a value
and assigns it back to the variable.

Example:

c = 10
c %= 3 # Equivalent to c = c % 3; c now equals 1

7. Exponentiation Assignment (**=): Raises the variable to the power of a value and assigns
the result back to the variable.

Example:

d = 2
d **= 3 # Equivalent to d = d ** 3; d now equals 8

Identity Operators (is, is not), Membership Operators (in not in)

In Python, identity operators and membership operators are used to compare objects and
check their relationships. Here’s a breakdown of each:

Identity Operators

Identity operators are used to compare the memory locations of two objects, determining
whether they are the same object.

 is: Checks if two variables point to the same object in memory.

o Example:

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b) # Output: True, because a and b refer to the

same object
print(a is c) # Output: False, because a and c refer to
different objects, even though their contents are the same

 is not: Checks if two variables do not point to the same object in memory.

o Example:
 x = "hello"
y = "world"

print(x is not y) # Output: True, because x and y are

different objects

Membership Operators

Membership operators are used to check if a value is present within a sequence (like a list,
tuple, or string) or other iterable data structures.

 in: Checks if a value is present in a sequence or iterable.

o Example:

numbers = [1, 2, 3, 4, 5]
print(3 in numbers) # Output: True, because 3 is in the list
print("hello" in "hello world") # Output: True, because the
substring "hello" is present in the string

 not in: Checks if a value is not present in a sequence or iterable.

o Example:

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

print("grape" not in fruits) # Output: True, because "grape"
is not in the list
print(5 not in range(1, 5)) # Output: True, because 5 is not
in the range from 1 to 4

These operators are useful for performing comparisons and checking the presence of
elements in data structures, which helps in controlling the flow of a program based on certain
conditions.

Expressions and Statements

 Expression: An expression is a combination of values, variables, operators, and
functions that evaluates to a single value. Expressions can be as simple as 5 + 3 or as
complex as ((2 * 3) + (4 / 2)). Expressions always return a result.

o Example:

result = 5 * (2 + 3) # 5 * 5 = 25, so the expression evaluates

to 25

 Statement: A statement is a complete unit of execution that performs an action.

Statements include assignments, loops, conditionals, and function calls. Statements do
not return a value but execute an operation.

o Example:
 x = 10 # This is an assignment statement
print(x) # This is a print statement

Precedence of Operators

Operator precedence determines the order in which operators are evaluated in an expression.
Operators with higher precedence are evaluated before operators with lower precedence. For
instance, multiplication (*) has higher precedence than addition (+), so in the expression 2 +
3 * 4, the multiplication is performed first, giving 2 + 12, which results in 14.

 Example:

result = 10 + 3 * 2 # The multiplication is done first, so 10 + (3 *

2) = 16

Evaluation of an Expression

When an expression is evaluated, Python performs operations based on operator precedence

and associativity rules. Parentheses can be used to override default precedence and force
specific order of operations.

 Example:

value = (8 + 2) * 5 # Parentheses ensure that 8 + 2 is evaluated

first, so (10 * 5) = 50

Type Conversion

Type conversion allows you to change the data type of a value. This can be done implicitly
by Python or explicitly by the programmer.

 Explicit Conversion: Done using functions like int(), float(), and str() to
convert between types.

o Example:

num_str = "123"
num_int = int(num_str) # Converts the string "123" to the
integer 123

 Implicit Conversion: Python automatically converts types when necessary, such as

converting integers to floats during arithmetic operations involving both types.

o Example:

result = 10 + 2.5 # The integer 10 is implicitly converted to

a float, so the result is 12.5

Understanding these concepts helps you write more effective and error-free code by ensuring
expressions are evaluated correctly and data types are managed properly.
Accepting Data as Input From the Console and Displaying
Output
Accepting Input from the Console

To get input from the user, use the input() function. This function reads a line of text
entered by the user and returns it as a string. If you need to handle different types of input,
like integers or floats, you'll need to convert the input explicitly.

 Example: Accepting a String Input

name = input("Enter your name: ") # Prompt the user and store the
entered name as a string
print(f"Hello, {name}!") # Display the entered name

 Example: Accepting and Converting Numeric Input

age = input("Enter your age: ") # Input is read as a string

age = int(age) # Convert the input to an integer
print(f"You are {age} years old.") # Display the age

Displaying Output to the Console

To display output, use the print() function. This function can take multiple arguments and
will display them separated by spaces.

 Example: Basic Output

print("Hello, World!") # Prints the string "Hello, World!" to the

console

 Example: Formatting Output

name = "Alice"
age = 17
print(f"{name} is {age} years old.") # Using f-strings for formatted
output

Combining Input and Output

You can combine both input and output operations in a single program to create interactive
scripts.

 Example: Interactive Program

# Get user input

first_name = input("Enter your first name: ")
last_name = input("Enter your last name: ")

# Display a formatted message

print(f"Welcome, {first_name} {last_name}!")
Handling Multiple Inputs

You can also handle multiple inputs at once by splitting the input string.

 Example: Multiple Inputs

data = input("Enter your age and height separated by a space: ")

age, height = data.split() # Split the input into two parts
age = int(age) # Convert age to an integer
height = float(height) # Convert height to a float
print(f"Age: {age}, Height: {height}")

Using input() and print() functions allows you to create interactive Python programs that
can take user input and display output dynamically.

Errors- Syntax Errors, Logical Errors, and Run-Time

Errors
Errors are problems in a program that causes the program to stop its execution. On the other
hand, exceptions are raised when some internal events change the program’s normal flow.

Syntax Errors

Syntax errors occur when the code does not follow the correct syntax or structure of the
Python language. These errors are caught by the Python interpreter before the code is
executed. They are often due to typos or incorrect use of language features.

 Example:

print("Hello, World!" # Missing closing parenthesis

Error Message:

SyntaxError: unexpected EOF while parsing

Fix:

print("Hello, World!") # Corrected syntax with closing parenthesis

Logical Errors

Logical errors occur when the code runs without crashing but produces incorrect results.
These errors are often due to incorrect logic or algorithm mistakes. Unlike syntax errors,
logical errors are not detected by the interpreter and require careful debugging and testing to
identify.

 Example:

def calculate_area(radius):
return radius * radius # Incorrect formula for area of a circle
 print(calculate_area(5)) # Should be 78.5 (using πr²), but returns
25

Fix:

import math

def calculate_area(radius):
return math.pi * radius * radius # Correct formula

print(calculate_area(5)) # Returns approximately 78.54

Runtime Errors

Runtime errors occur while the program is running and often cause the program to crash or
terminate unexpectedly. These errors can be due to various issues such as invalid operations,
file not found, or division by zero.

 Example:

x = 10
y = 0
print(x / y) # Division by zero error

Error Message:

ZeroDivisionError: division by zero

Fix:

x = 10
y = 1
print(x / y) # Correct division

Understanding these errors helps in effective debugging and writing error-free code. Syntax
errors are usually the easiest to fix as they are caught early, while logical and runtime errors
require more careful inspection of the code’s logic and execution.

Flow of Control: Use of Indentation, Sequential Flow,

Conditional and Iterative Flow
In Python, the flow of control in a program dictates how statements are executed and how the
program’s logic is structured. Here’s an overview of how control flows through a Python
program, including indentation, sequential execution, and the use of conditional and iterative
statements:

Introduction to Flow of Control

The flow of control refers to the order in which the individual statements, instructions, or
function calls are executed or evaluated in a programming language. In Python, this flow is
managed using different constructs like sequences, conditions, and loops.

Use of Indentation

Python uses indentation (whitespace) to define blocks of code. Unlike some other
programming languages that use braces or keywords, Python’s indentation is crucial for
defining the structure and flow of the program. Proper indentation ensures that code blocks
(such as those following conditional statements or loops) are correctly associated with their
control statements.

 Example:

if True:
print("This is inside the if block") # Indented block
print("This is outside the if block") # Not indented

Sequential Flow

Sequential flow is the most straightforward flow of control where statements are executed
one after the other, from top to bottom. This is the default mode of execution for Python
programs.

 Example:

print("Start")
print("Middle")
print("End")

In this example, the program prints "Start", then "Middle", and finally "End", in that
order.

Conditional Flow

Conditional flow allows the program to make decisions and execute different blocks of code
based on certain conditions. This is typically managed using if, elif, and else statements.

 Example:

age = 20
if age < 18:
print("Minor")
elif age < 65:
print("Adult")
else:
print("Senior")

Here, the program checks the value of age and prints different messages depending on
the condition met.

Iterative Flow
Iterative flow allows the program to repeatedly execute a block of code as long as a condition
is true. This is managed using loops like for and while.

 Example (for loop):

for i in range(5):
print(i) # Prints numbers from 0 to 4

This loop iterates over a range of numbers and prints each one.

 Example (while loop):

count = 0
while count < 5:
print(count)
count += 1 # Increments count each iteration

This loop continues as long as the condition count < 5 is true.

Understanding these control flow concepts helps in creating well-structured and logical
programs, allowing you to manage how your code executes under different conditions and
repetitions.

Conditional Statements: if, if-else, if-elif-else, Flowcharts

Conditional statements in Python are used to execute specific blocks of code based on certain
conditions. Let’s explore the different types of conditional statements, along with flowcharts
and examples of simple programs.

Conditional Statements

1. if Statement The if statement checks a condition and executes the associated block
of code if the condition is true.

o Example:

temperature = 30
if temperature > 25:
print("It's a hot day!")

2. if-else Statement The if-else statement provides an alternative block of code to

execute if the condition is false.

o Example:

temperature = 20
if temperature > 25:
print("It's a hot day!")
else:
print("It's a cool day!")
 3. if-elif-else Statement The if-elif-else statement allows multiple conditions to
be checked in sequence. The first true condition's block is executed, and if none are
true, the else block is executed.

o Example:

temperature = 10
if temperature > 30:
print("It's a very hot day!")
elif temperature > 20:
print("It's a warm day!")
elif temperature > 10:
print("It's a cool day!")
else:
print("It's a cold day!")

Flowcharts

Flowcharts visually represent the flow of control in a program. They use different shapes to
denote different types of actions or decisions.

 Decision Shape: Represents a condition (diamond shape).

 Process Shape: Represents an action (rectangle shape).

 Start/End: Marks the beginning or end of a process (oval shape).

Example Flowchart for Checking Temperature:

1. Start

2. Check Temperature (Decision)

o If Temperature > 25: Print "Hot Day"

o Else: Print "Cool Day"

3. End

Simple Programs

1. Absolute Value: To find the absolute value of a number, you can use conditional
statements to handle negative values.

o Example:

number = -7
if number < 0:
absolute_value = -number
else:
absolute_value = number
print("Absolute value:", absolute_value)
 2. Sort 3 Numbers: To sort three numbers, compare them using conditional statements
and arrange them in order.

o Example:

a = 5
b = 2
c = 9

if a > b:
a, b = b, a
if a > c:
a, c = c, a
if b > c:
b, c = c, b

print("Sorted numbers:", a, b, c)

3. Divisibility of a Number: To check if a number is divisible by another number, use

the modulo operator % and conditional statements.

o Example:

number = 15
divisor = 3

if number % divisor == 0:
print(f"{number} is divisible by {divisor}")
else:
print(f"{number} is not divisible by {divisor}")

These examples and explanations should help you understand and implement conditional
statements in Python, along with the basics of flowcharts for visualizing program logic.

Iterative Statement: for loop, range(), while loop,

flowcharts, break and continue statements, nested loops
Iterative Statements in Python

Iterative statements allow you to execute a block of code repeatedly based on certain
conditions. In Python, the primary iterative statements are for loops and while loops. Here's
how they work:

1. for Loop

The for loop iterates over a sequence (like a list, tuple, or string) or a range of numbers. It’s
useful when you know in advance how many times you want to repeat a block of code.

 Example:

for i in range(5):
print(i) # Prints numbers from 0 to 4
2. range() Function

The range() function generates a sequence of numbers and is commonly used with for
loops. It can take up to three arguments: start, stop, and step.

 Example:

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

print(i) # Prints 2, 4, 6, 8

3. while Loop

The while loop executes as long as its condition remains true. It’s useful when you don’t
know beforehand how many times you’ll need to repeat the code.

 Example:

count = 0
while count < 5:
print(count)
count += 1 # Increment count

4. Flowcharts

Flowcharts can be used to visualize the control flow of loops. They help in understanding
how the iteration progresses and where decisions are made.

Example Flowchart for a while Loop:

1. Start

2. Initialize Counter (Process)

3. Check Condition (Decision)

o If True: Execute Loop Body (Process)

o Update Counter (Process)

o Back to Check Condition

o If False: End Loop

4. End

5. break and continue Statements

 break: Exits the loop immediately, regardless of the loop condition.

o Example:
 for i in range(10):
if i == 5:
break # Exits the loop when i is 5
print(i)

 continue: Skips the current iteration and continues with the next iteration of the loop.

o Example:

for i in range(10):
if i % 2 == 0:
continue # Skips even numbers
print(i) # Prints only odd numbers

6. Nested Loops

Nested loops involve placing one loop inside another. They are useful for working with
multi-dimensional data or generating patterns.

 Example:

for i in range(3):
for j in range(3):
print(f"({i}, {j})", end=" ")
print() # New line after inner loop

Suggested Programs: Generating Pattern, Summation of Series, Finding the

Factorial of a Positive Number, etc.

 Generating Patterns:

o Example: Generate a square pattern of stars.

size = 5
for i in range(size):
for j in range(size):
print('*', end=' ')
print() # New line after each row

 Summation of Series:

o Example: Calculate the sum of the first 10 natural numbers.

total = 0
for i in range(1, 11):
total += i
print("Sum of series:", total)

 Finding the Factorial of a Positive Number:

o Example:
 number = 5
factorial = 1
for i in range(1, number + 1):
factorial *= i
print("Factorial:", factorial)

Understanding these iterative constructs and their uses helps in solving repetitive tasks
efficiently and allows for the creation of complex patterns and calculations in programming.

Strings: Introduction, String Operations (concatenation,

repetition, membership and slicing)
Strings in Python

Strings are sequences of characters used to represent text in Python. They are one of the most
commonly used data types and are essential for handling textual data. Here’s a brief overview
of strings and some of their key operations.

Introduction to Strings

A string is a collection of characters enclosed in single quotes ( '), double quotes ("), or triple
quotes (''' or """). Strings are immutable, meaning once created, their content cannot be
changed.

 Example:

message = "Hello, World!"

String Operations

1. Concatenation: Concatenation combines two or more strings into one. This is done
using the + operator.

o Example:

first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name) # Output: John Doe

2. Repetition: Repetition allows you to repeat a string a certain number of times using
the * operator.

o Example:

echo = "Hello! " * 3

print(echo) # Output: Hello! Hello! Hello!

3. Membership: Membership checks if a substring exists within a string using the in

keyword. It returns True if the substring is found, and False otherwise.
 o Example:

text = "Python programming"

result = "programming" in text
print(result) # Output: True

4. Slicing: Slicing extracts a part of the string. You use indexing to specify the start and
end positions. The syntax is string[start:end].

o Example:

phrase = "Hello, World!"

slice1 = phrase[0:5] # Extracts 'Hello'
slice2 = phrase[7:] # Extracts 'World!'
print(slice1) # Output: Hello
print(slice2) # Output: World!

Traversing a String Using Loops

Traversing a string using loops is a common technique to process or analyze each character in
the string. In Python, you can use both for loops and while loops to iterate over a string.
Here's how you can do it:

Using a for Loop

The for loop is straightforward and ideal for traversing a string because it directly iterates
over each character in the string.

 Example:

text = "Python"
for char in text:
print(char)

Explanation:

o text is the string you want to traverse.

o The for loop iterates over each character (char) in the string text.

o Each character is printed on a new line.

Using a while Loop

You can also use a while loop to traverse a string by managing the index manually.

 Example:

text = "Python"
index = 0
while index < len(text):
 print(text[index])
index += 1

Explanation:

o text is the string you want to traverse.

o index starts at 0 and increments with each iteration.

o text[index] accesses the character at the current index.

o The loop continues until index is equal to the length of the string
(len(text)).

Using Enumerate with for Loop

If you need both the character and its index, you can use enumerate() with a for loop.

 Example:

text = "Python"
for index, char in enumerate(text):
print(f"Index {index}: {char}")

Explanation:

o enumerate(text) returns both the index and the character.

o index is the position of the character in the string.

o char is the character at that position.

Practical Example: Counting Vowels

Here’s a practical example of counting vowels in a string:

 Example:

text = "Python Programming"

vowels = "aeiouAEIOU"
count = 0

for char in text:

if char in vowels:
count += 1

print(f"Number of vowels: {count}")

Explanation:

o vowels is a string containing all vowel characters.

 o For each character in text, check if it is in the vowels string.

o Increment count if a vowel is found.

Traversing a string is a fundamental skill in programming that allows you to perform various
operations such as searching, counting, and modifying text.

Built-in String Functions/Methods in Python

Python strings come with a variety of built-in methods that make text manipulation easy and
efficient. Here’s a rundown of some commonly used string methods:

 len()

o Usage: Returns the number of characters in the string.

o Example:

text = "Hello"
print(len(text)) # Output: 5

 capitalize()

o Usage: Capitalizes the first character of the string and makes all other
characters lowercase.

o Example:

text = "hello world"

print(text.capitalize()) # Output: Hello world

 title()

o Usage: Capitalizes the first letter of each word in the string.

o Example:

text = "hello world"

print(text.title()) # Output: Hello World

 lower()

o Usage: Converts all characters in the string to lowercase.

o Example:

text = "HELLO"
print(text.lower()) # Output: hello

 upper()
 o Usage: Converts all characters in the string to uppercase.

o Example:

text = "hello"
print(text.upper()) # Output: HELLO

 count()

o Usage: Counts the occurrences of a substring within the string.

o Example:

text = "hello hello"

print(text.count("hello")) # Output: 2

 find()

o Usage: Returns the lowest index where the substring is found, or -1 if not
found.

o Example:

text = "hello world"

print(text.find("world")) # Output: 6

 index()

o Usage: Returns the lowest index where the substring is found, raises
ValueError if not found.

o Example:

text = "hello world"

print(text.index("world")) # Output: 6

 endswith()

o Usage: Checks if the string ends with the specified substring.

o Example:

text = "hello world"

print(text.endswith("world")) # Output: True

 startswith()

o Usage: Checks if the string starts with the specified substring.

o Example:
 text = "hello world"
print(text.startswith("hello")) # Output: True

 isalnum()

o Usage: Returns True if all characters in the string are alphanumeric (letters
and numbers).

o Example:

text = "hello123"
print(text.isalnum()) # Output: True

 isalpha()

o Usage: Returns True if all characters in the string are alphabetic.

o Example:

text = "hello"
print(text.isalpha()) # Output: True

 isdigit()

o Usage: Returns True if all characters in the string are digits.

o Example:

text = "12345"
print(text.isdigit()) # Output: True

 islower()

o Usage: Returns True if all characters in the string are lowercase.

o Example:

text = "hello"
print(text.islower()) # Output: True

 isupper()

o Usage: Returns True if all characters in the string are uppercase.

o Example:

text = "HELLO"
print(text.isupper()) # Output: True

 isspace()

o Usage: Returns True if all characters in the string are whitespace.

 o Example:

text = " "

print(text.isspace()) # Output: True

 lstrip()

o Usage: Removes leading whitespace or specified characters.

o Example:

text = " hello"

print(text.lstrip()) # Output: hello

 rstrip()

o Usage: Removes trailing whitespace or specified characters.

o Example:

text = "hello "

print(text.rstrip()) # Output: hello

 strip()

o Usage: Removes leading and trailing whitespace or specified characters.

o Example:

text = " hello "

print(text.strip()) # Output: hello

 replace()

o Usage: Replaces occurrences of a substring with another substring.

o Example:

text = "hello world"

print(text.replace("world", "Python")) # Output: hello Python

 join()

o Usage: Joins elements of an iterable (e.g., list) into a single string with a
specified separator.

o Example:

words = ["Hello", "world"]

print(" ".join(words)) # Output: Hello world

 partition()
 o Usage: Splits the string into a 3-tuple containing the part before the separator,
the separator itself, and the part after.

o Example:

text = "hello world"

print(text.partition(" ")) # Output: ('hello', ' ', 'world')

 split()

o Usage: Splits the string into a list of substrings based on a separator.

o Example:

text = "hello world"

print(text.split()) # Output: ['hello', 'world']

These methods and functions are essential for text processing and manipulation in Python,
making it easier to work with strings in a variety of scenarios.

Lists: Introduction, Indexing, List Operations

(concatenation, repetition, membership and slicing)
Introduction to Lists in Python

In Python, a list is a versatile and powerful data structure that can hold an ordered collection
of items, which can be of different types—integers, strings, objects, or even other lists. Lists
are mutable, meaning you can change their content after they are created. They are defined
using square brackets [], with items separated by commas.

Example:

my_list = [1, 2, 3, "hello", 4.5]

Indexing

Indexing in lists is used to access individual elements based on their position. Python uses
zero-based indexing, so the first item is at index 0, the second item at index 1, and so on. You
can also use negative indexing to access elements from the end of the list, where -1 refers to
the last item, -2 to the second last, and so forth.

Example:

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

print(my_list[0]) # Output: apple
print(my_list[-1]) # Output: cherry

List Operations

1. Concatenation
Concatenation is the operation of combining two lists into a single list. You use the +
operator to concatenate lists.

Example:

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

2. Repetition

Repetition allows you to create a list with repeated copies of its elements using the *
operator.

Example:

my_list = [1, 2, 3]
repeated_list = my_list * 3
print(repeated_list) # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]

3. Membership

Membership checks if an element is in the list using the in keyword. It returns True if the
element is present and False otherwise.

Example:

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

print("banana" in my_list) # Output: True
print("grape" in my_list) # Output: False

4. Slicing

Slicing extracts a portion of the list. It uses the syntax list[start:stop], where start is
the index of the first element included in the slice, and stop is the index of the first element
excluded from the slice.

Example:

my_list = [0, 1, 2, 3, 4, 5]
sliced_list = my_list[1:4]
print(sliced_list) # Output: [1, 2, 3]

You can also omit the start or stop to slice from the beginning or to the end of the list.

Example:

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

print(my_list[3:]) # Output: [3, 4, 5]
Lists are fundamental in Python for managing and organizing collections of data. Mastering
these operations will help you manipulate and work with lists effectively in your programs.

Traversing a List Using Loops

Traversing a list using loops is a common and useful technique in Python programming. It
allows you to access and process each item in the list, one at a time. Here's how you can do it:

Using a for Loop

The for loop is the most straightforward way to traverse a list. It iterates over each element
of the list, allowing you to perform operations with the item.

Example:

my_list = [10, 20, 30, 40, 50]

for item in my_list:

print(item)

Output:

10
20
30
40
50

In this example, item represents each element in my_list, and the loop prints each element
in turn.

Using a while Loop

You can also traverse a list using a while loop by manually managing the index. This
approach gives you more control but requires you to handle the indexing and loop conditions
yourself.

Example:

my_list = [10, 20, 30, 40, 50]

index = 0

while index < len(my_list):

print(my_list[index])
index += 1

Output:

10
20
30
40
50
Here, index starts at 0 and increases by 1 after each iteration, accessing each element by its
index.

Using List Comprehensions

For a more concise way to process each item in a list, you can use list comprehensions. This
is a compact way of generating lists based on existing ones and can also be used for simple
operations.

Example:

my_list = [10, 20, 30, 40, 50]

squared_list = [x ** 2 for x in my_list]
print(squared_list)

Output:

[100, 400, 900, 1600, 2500]

In this example, squared_list contains the squares of each element in my_list.

Using enumerate()

If you need both the index and the value of each element while traversing, enumerate() is a
handy built-in function. It returns both the index and the item in each iteration.

Example:

my_list = ['apple', 'banana', 'cherry']

for index, item in enumerate(my_list):

print(f"Index {index}: {item}")

Output:

Index 0: apple
Index 1: banana
Index 2: cherry

Using these techniques, you can efficiently traverse and process lists in Python, adapting your
approach based on your specific needs and the task at hand.

Built-in Lists Functions/Methods in Python

Here's a concise overview of some essential built-in functions and methods for working with
lists in Python. Each function or method serves a specific purpose, making it easier to
manipulate and analyze lists.

1. len()

 Purpose: Returns the number of items in a list.

  Example:

my_list = [10, 20, 30, 40]

print(len(my_list)) # Output: 4

2. list()

 Purpose: Converts other data types into a list.

 Example:

my_string = "hello"
my_list = list(my_string)
print(my_list) # Output: ['h', 'e', 'l', 'l', 'o']

3. append()

 Purpose: Adds a single element to the end of the list.

 Example:

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # Output: [1, 2, 3, 4]

4. extend()

 Purpose: Adds elements from an iterable (like a list) to the end of the list.

 Example:

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # Output: [1, 2, 3, 4, 5]

5. insert()

 Purpose: Inserts an element at a specified position in the list.

 Example:

my_list = [1, 2, 3]
my_list.insert(1, 4)
print(my_list) # Output: [1, 4, 2, 3]

6. count()

 Purpose: Returns the number of occurrences of a specific element.

 Example:
 my_list = [1, 2, 2, 3, 2]
print(my_list.count(2)) # Output: 3

7. index()

 Purpose: Returns the index of the first occurrence of a specific element.

 Example:

my_list = [1, 2, 3, 2]
print(my_list.index(2)) # Output: 1

8. remove()

 Purpose: Removes the first occurrence of a specific element.

 Example:

my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list) # Output: [1, 3, 2]

9. pop()

 Purpose: Removes and returns the element at the specified position (or the last
element if no position is specified).

 Example:

my_list = [1, 2, 3]
item = my_list.pop()
print(item) # Output: 3
print(my_list) # Output: [1, 2]

10. reverse()

 Purpose: Reverses the order of elements in the list.

 Example:

my_list = [1, 2, 3]
my_list.reverse()
print(my_list) # Output: [3, 2, 1]

11. sort()

 Purpose: Sorts the elements of the list in place (modifies the original list).

 Example:
 my_list = [3, 1, 2]
my_list.sort()
print(my_list) # Output: [1, 2, 3]

12. sorted()

 Purpose: Returns a new list that is sorted (does not modify the original list).

 Example:

my_list = [3, 1, 2]
sorted_list = sorted(my_list)
print(sorted_list) # Output: [1, 2, 3]
print(my_list) # Output: [3, 1, 2]

13. min()

 Purpose: Returns the smallest element in the list.

 Example:

my_list = [4, 1, 7, 3]
print(min(my_list)) # Output: 1

14. max()

 Purpose: Returns the largest element in the list.

 Example:

my_list = [4, 1, 7, 3]
print(max(my_list)) # Output: 7

15. sum()

 Purpose: Returns the sum of all elements in the list (only works with numeric lists).

 Example:

my_list = [1, 2, 3]
print(sum(my_list)) # Output: 6

These functions and methods provide a range of options for manipulating and analyzing lists,
making it easier to handle various data-processing tasks in your Python programs.

Nested Lists
Nested lists in Python are simply lists that contain other lists as their elements. They can be
thought of as a matrix or a table, where each cell or row is a list itself. This structure allows
you to represent more complex data arrangements and perform operations on multi-
dimensional data.
Basic Example

Here's a simple example of a nested list:

nested_list = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

In this example, nested_list contains three lists, each with three integers.

Accessing Elements

To access elements in a nested list, you need to specify the index of both the outer list and the
inner list. For example:

print(nested_list[0]) # Output: [1, 2, 3] (first inner list)

print(nested_list[1][2]) # Output: 6 (third element of the second inner
list)

Modifying Elements

You can modify elements in a nested list just like you would with a regular list:

nested_list[0][1] = 20
print(nested_list) # Output: [[1, 20, 3], [4, 5, 6], [7, 8, 9]]

Iterating Over Nested Lists

You can use nested loops to iterate over each element in a nested list. Here’s how you can
print every item:

for sublist in nested_list:

for item in sublist:
print(item, end=' ')
print() # Moves to the next line after printing all items in the
current sublist

Output:

1 20 3
4 5 6
7 8 9

Use Case: Matrix Representation

Nested lists are commonly used to represent matrices (2D arrays) in Python. For instance, if
you're working with a grid or table of data, a nested list can help you store and manipulate
this data effectively.

Example: Matrix Addition

matrix1 = [
[1, 2, 3],
[4, 5, 6]
]
matrix2 = [
[7, 8, 9],
[10, 11, 12]
]

result = [[matrix1[i][j] + matrix2[i][j] for j in range(len(matrix1[0]))]

for i in range(len(matrix1))]

print(result) # Output: [[8, 10, 12], [14, 16, 18]]

Summary

Nested lists provide a powerful way to handle multi-dimensional data in Python. They offer
flexibility in representing complex data structures, making them useful for various
applications such as data analysis, matrix operations, and more.

Suggested Programs

Here are some suggested programs to work with lists in Python, focusing on finding
maximum, minimum, mean values, performing linear search, and counting the frequency of
elements:

1. Finding the Maximum, Minimum, and Mean of Numeric Values Stored in a

List

Program:

# Define a list of numeric values

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

# Finding the maximum value

max_value = max(numbers)
print(f"Maximum value: {max_value}")

# Finding the minimum value

min_value = min(numbers)
print(f"Minimum value: {min_value}")

# Finding the mean value

mean_value = sum(numbers) / len(numbers)
print(f"Mean value: {mean_value}")

Explanation:

 max() returns the largest number in the list.

 min() returns the smallest number in the list.

 The mean is calculated by dividing the sum of the numbers by the count of the
numbers.
2. Linear Search on a List of Numbers

Program:

def linear_search(lst, target):

for index, value in enumerate(lst):
if value == target:
return index # Return the index of the target value
return -1 # Return -1 if the target is not found

# Define a list and the target value

numbers = [5, 3, 7, 1, 9]
target = 7

# Perform linear search

index = linear_search(numbers, target)
if index != -1:
print(f"Target {target} found at index {index}.")
else:
print(f"Target {target} not found in the list.")

Explanation:

 The linear_search() function iterates through the list and checks if each element
matches the target value. It returns the index if found or -1 if not.

3. Counting the Frequency of Elements in a List

Program:

from collections import Counter

# Define a list with some repeated elements

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

# Count the frequency of each element

frequency = Counter(numbers)

# Print the frequency of each element

for number, count in frequency.items():
print(f"Number {number} appears {count} times.")

Explanation:

 The Counter class from the collections module helps count the occurrences of
each element in the list. It returns a dictionary-like object where keys are list elements
and values are their counts.

Summary

These programs provide practical ways to work with lists in Python. Finding maximum,
minimum, and mean values helps analyze numeric data. Linear search is a basic searching
technique to locate elements, while counting frequencies can be useful for understanding the
distribution of values. These exercises build foundational skills for handling and processing
list data in various programming scenarios.

Dictionary
Introduction to Dictionaries

In Python, a dictionary is a built-in data type that stores data in key-value pairs. Think of it
like a real-world dictionary where you look up a word (key) to find its definition (value). This
structure allows for fast lookups, additions, and modifications of data.

Example of a Dictionary:

# Creating a dictionary
student = {
"name": "John Doe",
"age": 16,
"grade": "11th",
"subjects": ["Math", "Science", "English"]
}

In this dictionary:

 "name", "age", "grade", and "subjects" are keys.

 "John Doe", 16, "11th", and ["Math", "Science", "English"] are their
respective values.

Accessing Items in a Dictionary Using Keys

To access the values stored in a dictionary, you use the keys. Here’s how you can do it:

Example:

# Accessing values using keys

print(student["name"]) # Output: John Doe
print(student["age"]) # Output: 16
print(student["subjects"]) # Output: ['Math', 'Science', 'English']

Explanation:

 student["name"] retrieves the value associated with the key "name", which is "John
Doe".

 Similarly, student["age"] gets the age, and student["subjects"] returns the list
of subjects.

Handling Missing Keys

If you try to access a key that doesn't exist in the dictionary, Python will raise a KeyError. To
avoid this, you can use the .get() method, which allows you to specify a default value if the
key is not found.

Example:

# Using get() to handle missing keys

print(student.get("grade", "No grade assigned")) # Output: 11th
print(student.get("address", "Address not found")) # Output: Address not
found

In this example:

 student.get("grade") returns the value for "grade" as usual.

 student.get("address", "Address not found") returns "Address not found"

because "address" is not a key in the dictionary.

Summary

Dictionaries are a powerful tool in Python for storing and managing data in key-value pairs.
Accessing items is straightforward using the keys, and handling potential errors is easy with
methods like .get(). This flexibility makes dictionaries ideal for various applications, from
simple data storage to complex data manipulation tasks.

Mutability of a Dictionary

Dictionaries in Python are mutable, which means you can change their contents after they
have been created. This mutability allows you to add new key-value pairs, modify existing
ones, and even delete items as needed.

Adding a New Item

You can add new key-value pairs to a dictionary by simply assigning a value to a new key. If
the key doesn't already exist, it will be created.

Example:

# Creating an initial dictionary

student = {
"name": "John Doe",
"age": 16,
"grade": "11th"
}

# Adding a new item

student["subjects"] = ["Math", "Science", "English"]

print(student)
# Output: {'name': 'John Doe', 'age': 16, 'grade': '11th', 'subjects':
['Math', 'Science', 'English']}
In this example, the key "subjects" is added to the dictionary with its associated value
["Math", "Science", "English"].

Modifying an Existing Item

To change the value associated with an existing key, simply assign a new value to that key.

Example:

# Modifying an existing item

student["age"] = 17

print(student)
# Output: {'name': 'John Doe', 'age': 17, 'grade': '11th', 'subjects':
['Math', 'Science', 'English']}

Here, the value of the "age" key is updated from 16 to 17.

Summary

Dictionaries in Python are versatile and allow for easy updates and additions. By leveraging
their mutable nature, you can dynamically manage and manipulate data. Adding new terms or
modifying existing items is straightforward, making dictionaries a flexible choice for various
programming tasks.

Traversing a Dictionary

Traversing a dictionary means iterating through its keys, values, or key-value pairs to access
or manipulate its contents. This is a common task when you need to process or display
dictionary data.

1. Traversing Keys

You can loop through the keys of a dictionary using a for loop. This allows you to access
each key and use it to get corresponding values.

Example:

# Define a dictionary
student = {
"name": "John Doe",
"age": 16,
"grade": "11th",
"subjects": ["Math", "Science", "English"]
}

# Traversing keys
for key in student:
print(f"Key: {key}")

In this example, the loop iterates through each key in the student dictionary and prints it.

2. Traversing Values
If you only need to access the values, you can loop through the dictionary’s values.

Example:

# Traversing values
for value in student.values():
print(f"Value: {value}")

This loop prints each value in the student dictionary.

3. Traversing Key-Value Pairs

To get both keys and values simultaneously, use the .items() method. This method returns a
view object that displays a list of tuples, each containing a key-value pair.

Example:

# Traversing key-value pairs

for key, value in student.items():
print(f"Key: {key}, Value: {value}")

In this example, each tuple returned by .items() is unpacked into key and value, which are
then printed.

4. Using Dictionary Comprehensions

For more advanced operations, you can use dictionary comprehensions to create or modify
dictionaries based on traversal.

Example:

# Dictionary comprehension to create a new dictionary with uppercased keys

uppercased_dict = {key.upper(): value for key, value in student.items()}

print(uppercased_dict)
# Output: {'NAME': 'John Doe', 'AGE': 16, 'GRADE': '11th', 'SUBJECTS':
['Math', 'Science', 'English']}

In this example, the dictionary comprehension creates a new dictionary where all keys are
converted to uppercase.

Built-in Dictionary Functions/Methods

Python dictionaries come with a set of built-in functions and methods that make it easy to
work with key-value pairs. Here’s a rundown of the most commonly used ones:

1. len()

Returns the number of items (key-value pairs) in the dictionary.

Example:
student = {"name": "John", "age": 16}
print(len(student)) # Output: 2

2. dict()

Creates a new dictionary. It can take keyword arguments or a list of key-value pairs.

Example:

new_dict = dict(name="Alice", age=18)

print(new_dict) # Output: {'name': 'Alice', 'age': 18}

3. keys()

Returns a view object that displays a list of all the keys in the dictionary.

Example:

keys = student.keys()
print(keys) # Output: dict_keys(['name', 'age'])

4. values()

Returns a view object that displays a list of all the values in the dictionary.

Example:

values = student.values()
print(values) # Output: dict_values(['John', 16])

5. items()

Returns a view object that displays a list of tuples, each containing a key-value pair.

Example:

items = student.items()
print(items) # Output: dict_items([('name', 'John'), ('age', 16)])

6. get()

Returns the value for the specified key if the key is in the dictionary. Otherwise, it returns
None or a default value if provided.

Example:

print(student.get("name")) # Output: John

print(student.get("grade", "Not Available")) # Output: Not Available

7. update()
Updates the dictionary with key-value pairs from another dictionary or from an iterable of
key-value pairs.

Example:

student.update({"grade": "11th", "school": "High School"})

print(student) # Output: {'name': 'John', 'age': 16, 'grade': '11th',
'school': 'High School'}

8. del

Deletes a specific key-value pair from the dictionary.

Example:

del student["age"]
print(student) # Output: {'name': 'John', 'grade': '11th', 'school': 'High
School'}

9. clear()

Removes all items from the dictionary.

Example:

student.clear()
print(student) # Output: {}

10. fromkeys()

Creates a new dictionary with specified keys and a default value.

Example:

keys = ["name", "age", "grade"]

new_dict = dict.fromkeys(keys, "unknown")
print(new_dict) # Output: {'name': 'unknown', 'age': 'unknown', 'grade':
'unknown'}

11. copy()

Returns a shallow copy of the dictionary.

Example:

copy_dict = student.copy()
print(copy_dict) # Output: {'name': 'John', 'grade': '11th', 'school':
'High School'}

12. pop()
Removes a specified key and returns its value. If the key is not found, it raises a KeyError
unless a default value is provided.

Example:

name = student.pop("name")
print(name) # Output: John
print(student) # Output: {'grade': '11th', 'school': 'High School'}

13. popitem()

Removes and returns the last key-value pair from the dictionary as a tuple.

Example:

item = student.popitem()
print(item) # Output: ('school', 'High School')
print(student) # Output: {'grade': '11th'}

14. setdefault()

Returns the value of a key if it is in the dictionary. If not, it inserts the key with a specified
default value and returns that value.

Example:

value = student.setdefault("grade", "unknown")

print(value) # Output: 11th

15. max()

Returns the maximum key from the dictionary based on lexicographical order.

Example:

print(max(student)) # Output: grade (based on lexicographical order of

keys)

16. min()

Returns the minimum key from the dictionary based on lexicographical order.

Example:

print(min(student)) # Output: grade (based on lexicographical order of

keys)

17. sorted()

Returns a sorted list of the dictionary’s keys.

Example:
sorted_keys = sorted(student)
print(sorted_keys) # Output: ['grade']

Summary

Python dictionaries come equipped with a variety of built-in methods that simplify many
common tasks, from adding and updating items to accessing and manipulating data. Whether
you're looking to explore key-value pairs, make modifications, or clear the entire dictionary,
these functions and methods make handling dictionary data straightforward and efficient.

Suggested Programs

Here are two simple programs using dictionaries to tackle common tasks: counting characters
and managing employee data.

1. Count the Number of Times a Character Appears in a Given String Using a

Dictionary

This program counts how often each character appears in a string and stores the counts in a
dictionary.

Example Program:

def count_characters(input_string):
# Create an empty dictionary to store character counts
char_count = {}

# Loop through each character in the string

for char in input_string:
# If character is already in the dictionary, increment its count
if char in char_count:
char_count[char] += 1
# If character is not in the dictionary, add it with a count of 1
else:
char_count[char] = 1

return char_count

# Test the function

text = "hello world"
result = count_characters(text)
print(result) # Output: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1,
'r': 1, 'd': 1}

Explanation:

 The program uses a dictionary char_count to track how many times each character
appears.

 It loops through the input_string, updating the count in the dictionary for each
character.

2. Create a Dictionary with Names of Employees, Their Salaries, and Access Them
This program creates a dictionary to store employee names and their salaries, and then
accesses this data.

Example Program:

# Create a dictionary with employee names as keys and salaries as values

employees = {
"Alice": 55000,
"Bob": 60000,
"Charlie": 70000
}

# Access and print employee details

def print_employee_salaries(employee_dict):
for name, salary in employee_dict.items():
print(f"Employee: {name}, Salary: ${salary}")

# Test the function

print_employee_salaries(employees)

Explanation:

 The dictionary employees maps employee names to their respective salaries.

 The print_employee_salaries function iterates through the dictionary using

.items() to print each employee’s name and salary.

Introduction to Python Modules

Python modules are a great way to organize and reuse code across different programs. Think
of a module as a file containing Python code that defines functions, classes, and variables you
can use in your own programs. By importing these modules, you can make use of their
functionality without having to rewrite code.

Importing a Module Using import <module>

When you use the import statement, you're telling Python to load a module so you can use
its functions, classes, or variables. For example:

import math

# Using a function from the math module

result = math.sqrt(16)
print(result) # Output: 4.0

In this example:

 import math loads the math module.

 You access functions in the math module using the dot notation (math.sqrt()),
where sqrt is a function that calculates the square root of a number.
Using From Statement to Import Specific Components

If you only need specific functions or variables from a module, you can use the from
<module> import <item> syntax. This approach makes your code cleaner and more
efficient by importing only what you need.

from math import sqrt, pi

# Using the imported functions and variables directly

result = sqrt(25)
print(result) # Output: 5.0

print(pi) # Output: 3.141592653589793

In this example:

 from math import sqrt, pi imports only the sqrt function and pi constant from
the math module.

 You can then use sqrt() and pi directly without prefixing them with math.

Importing and Using the Math Module

The math module in Python provides various mathematical functions and constants that make
it easier to perform complex calculations. By importing the math module, you gain access to
functions and constants such as pi, e, and mathematical functions like sqrt(), ceil(), and
sin(). Here’s a quick guide on how to use these features:

Importing the Math Module

First, you need to import the math module:

import math

Using Constants

 math.pi: The mathematical constant π (pi), approximately equal to 3.14159.

 math.e: The mathematical constant e, approximately equal to 2.71828.

Example:

import math

print("Value of pi:", math.pi) # Output: Value of pi: 3.141592653589793

print("Value of e:", math.e) # Output: Value of e: 2.718281828459045

Using Functions

 math.sqrt(x): Returns the square root of x.

 print("Square root of 16:", math.sqrt(16)) # Output: Square root of
16: 4.0

 math.ceil(x): Returns the smallest integer greater than or equal to x.

print("Ceiling of 4.2:", math.ceil(4.2)) # Output: Ceiling of 4.2: 5

 math.floor(x): Returns the largest integer less than or equal to x.

print("Floor of 4.7:", math.floor(4.7)) # Output: Floor of 4.7: 4

 math.pow(x, y): Returns x raised to the power of y.

print("2 to the power of 3:", math.pow(2, 3)) # Output: 2 to the

power of 3: 8.0

 math.fabs(x): Returns the absolute value of x.

print("Absolute value of -5.3:", math.fabs(-5.3)) # Output: Absolute

value of -5.3: 5.3

 math.sin(x), math.cos(x), math.tan(x): Return the sine, cosine, and tangent of x

(where x is in radians).

import math

angle = math.pi / 4 # 45 degrees in radians

print("Sine of 45 degrees:", math.sin(angle)) # Output: Sine of 45
degrees: 0.7071067811865475
print("Cosine of 45 degrees:", math.cos(angle)) # Output: Cosine of
45 degrees: 0.7071067811865476
print("Tangent of 45 degrees:", math.tan(angle)) # Output: Tangent
of 45 degrees: 0.9999999999999999

Summary

The math module is a powerful toolkit for performing mathematical operations in Python. By
importing it, you can utilize constants like pi and e, and functions for arithmetic,
trigonometric, and other calculations. Whether you're solving complex equations or just need
basic mathematical operations, the math module simplifies the process.

Using the Random and Statistics Modules

Python provides built-in modules like random and statistics to handle various tasks
related to randomness and statistical analysis. Here’s how you can use these modules to
simplify your programming tasks.

Random Module

The random module includes functions to generate random numbers and perform random
operations. Here's a look at some of its useful functions:
  random.random(): Returns a random floating-point number between 0.0 and 1.0.

 Example:

import random

print("Random number between 0 and 1:", random.random())

# Output: Random number between 0 and 1: 0.37444887175646646 (varies)

 random.randint(a, b): Returns a random integer between a and b (inclusive).

 Example:

import random

print("Random integer between 1 and 10:", random.randint(1, 10))

# Output: Random integer between 1 and 10: 7 (varies)

 random.randrange(start, stop, step): Returns a randomly selected element

from the range created by start, stop, and step.

 Example:

import random

print("Random number from range 1 to 10:", random.randrange(1, 10,

2))
# Output: Random number from range 1 to 10: 7 (varies)

Statistics Module

The statistics module is used for statistical operations and includes functions to compute
various statistical metrics:

 statistics.mean(data): Returns the average (mean) of the data set.

 Example:

import statistics

data = [2, 4, 6, 8, 10]

print("Mean of data:", statistics.mean(data))
# Output: Mean of data: 6

 statistics.median(data): Returns the middle value (median) of the data set.

 Example:

import statistics

data = [1, 3, 5, 7, 9]
print("Median of data:", statistics.median(data))
# Output: Median of data: 5
  statistics.mode(data): Returns the most frequently occurring value (mode) in the
data set. Note: If there's no unique mode, it raises a StatisticsError.

 Example:

import statistics

data = [1, 1, 2, 3, 4]
print("Mode of data:", statistics.mode(data))
# Output: Mode of data: 1

Summary

The random and statistics modules are invaluable tools in Python for dealing with random
number generation and statistical calculations. The random module helps you generate
random numbers for simulations and games, while the statistics module lets you easily
compute common statistical measures like the mean, median, and mode. Whether you're
doing data analysis or just adding some randomness to your programs, these modules provide
a straightforward approach to handle these tasks.

Basic Python Programming and Simple Data Types:

Familiarization with the basics of Python programming

Guido van Rossum created the Python programming language in the late 1980s. In contrast to
other popular languages such as C, C++, Java, and C#, Python strives to provide a simple but
powerful syntax. Python is used for software development at companies and organizations
such as Google, Yahoo, and NASA.

Simple Hello program: Python programs must be written with a particular structure. The
syntax must be correct, or the interpreter will generate error messages and not execute the
program. When we want to write a program, we use a text editor to write the Python
instructions into a file, which is called a script. By convention, Python scripts have names
that end with .py. For example, we will name our first program as “hello.py”.

>>print(“This is my first program”)

We will consider two ways in which we can run “hello.py”:

1. Enter the program directly into IDLE’s interactive shell

2. Enter the program into IDLE’s editor, save it, and run it.

IDLE’s interactive shell:

IDLE is a simple Python integrated development environment available for Windows, Linux,
and Mac OS X. To open IDLE interactive shell “Goto start menu on windows -> open
IDLE”. You may type the above one-line Python program directly into IDLE and press enter
to execute the program. Since it does not provide a way to save the code you enter, the
interactive shell is not the best tool for writing larger programs. The IDLE interactive shell is
useful for experimenting with small snippets of Python code.
IDLE’s editor: IDLE has a built-in editor. From the IDLE menu, select New Window, Type
the text print(“This is my first program”) into the editor. You can save your program
using the Save option in the File menu. Save the code to a file named “hello.py”. The
extension .py is the extension used for Python source code. We can run the program from
within the IDLE editor by pressing the F5 function key or from the editor’s Run menu: Run -
> Run Module. The output appears in the IDLE interactive shell window.

Print(“This is my first program”)

This is a Python statement. A statement is a command that the interpreter executes. This
statement prints the message “This is my first program” on the screen. A statement is the
fundamental unit of execution in a Python program. Statements may be grouped into larger
chunks called blocks, and blocks can make up more complex statements.

The statement print(“This is my first program”) makes use of a built-in function named
“print”. Python has a variety of different kinds of statements that may be used to build
programs.

**We generally write a computer program using a high-level language. A high-level

language is one which is understandable by us humans. It contains words and phrases from
the English (or other) language. But a computer does not understand high-level language. It
only understands program written in 0’s and 1 ’s in binary, called the machine code. A
program written in the high-level language is called a source code. We need to convert the
source code into machine code and this is accomplished by compilers and interpreters.
Hence, a compiler or an interpreter is a program that converts program written in high-level
language into machine code understood by the computer.
**Interpreter: Interpreter executes one statement at a time.
**Compiler: Compiler scans the entire program and translates it as a whole into machine
code.

Simple Data-Types

A data type, in programming, is a classification that specifies which type of value a variable
has and what type of mathematical, relational or logical operations can be applied to it
without causing an error. A string, for example, is a data type that is used to classify text and
an integer is a data type used to classify whole numbers.

Some basic data types that python support are integer, float, string.

Integer (int): Int, or integer, is a whole number, positive or negative, without decimals, of
unlimited length. The number four (4) is an example of a numeric value. In mathematics, 4 is
an integer value. Integers are whole numbers, which means they have no fractional parts, and
they can be positive, negative, or zero. Examples of integers include 4, −19, 0, and −1005. In
contrast, 4.5 is not an integer, since it is not a whole number. Python supports a number of
numeric and non-numeric values. In particular, Python programs can use integer values. Let’s
take an example integer.py

X=10

Y=223313445534
Z=-987

Print(X)

Print(Y)

Print(Z)

Print(X+Y+Z)

In above program, there are three variable holding integer values in x,y, and z. Then there are
three print statements which will display the three integer variables and last print statement
will display addition of all the 3 numbers that are in the variables.

Float: Many computational tasks require numbers that have fractional parts. For example, to
compute the area of a circle given the circle’s radius, the value pi, or approximately 3.14159
is used. Python supports such non-integer numbers, and they are called floating point
numbers. The name implies that during mathematical calculations the decimal point can
move or “float” to various positions within the number to maintain the proper number of
significant digits. The Python name for the floating-point type is float. Let’s take an example
of float in this program we will calculate area of circle

PI=3.14

Radius=5.5

Area=PI*Radius*Radius

Print(‘Area of circle is ‘, Area)

In the above example we are taking 3 float variables PI Radius and area. In a statement
Area=PI*Radius*radius, we are calculating the area of circle and putting the value in variable
area. Then in print statement, we are printing the area of circle with a message.

String: String literals in python are surrounded by either single quotation marks or double
quotation marks. ‘hello’ is the same as “hello”. String variable holds the text.
Let’s take an example in this example we will see how to print string variables and how to
take input from the user.

x=”hello”
print(“Enter text”)
y=input()
print(x,y)

In above program, there are 2 variables x and y. x is holding the string “hello” and y will take
text from the keyboard at run time and next line will print both the strings.