Basic Elements of Python
Prof. Murali Krishna Gurram
Dept. of Geo-Engineering & RDT
Centre for remote Sensing, AUCE
Andhra University, Visakhapatnam – 530 003
Dt. 27/09/2024
Basic Elements of Python
a) Rapid introduction to procedural programming
b) Data Types:
• Identifiers and Keywords,
• Integral types,
• Floating Point Types
Procedural Programming
Procedural Programming
Definition:
Procedural programming is a programming paradigm derived from
structured programming.
It relies on the concept of procedure calls, where procedures (or
functions) are blocks of code that perform a task.
Key Concepts:
• Sequential Execution: Instructions are executed in order.
• Procedures (Functions): Encapsulated code blocks that perform a
specific task.
• Variables: Store data used in procedures.
• Control Structures: Decision-making (if-else) and loops (for, while).
Procedural Programming
Key Concepts:
Sequential Execution: Instructions are executed in order.
Procedures (Functions): Encapsulated code blocks that perform
a specific task.
Variables: Store data used in procedures.
Control Structures: Decision-making (if-else) and loops (for,
while).
Procedural Programming
Key Concepts:
Example: A simple Python program that uses a function to print a message.
def greet():
print("Hello, world!") # Procedure (function) definition
greet() # Function call
Procedural Programming
2. Functions: The Core of Procedural Programming:
Why Use Functions?
Code Reusability: Avoid repeating code.
Modularity: Break complex problems into smaller,
manageable tasks.
Maintainability: Easier to update and maintain.
Procedural Programming
2. Functions: The Core of Procedural Programming:
Basic Function Structure:
Function Definition: Uses the def keyword.
Parameters: Inputs to the function.
Return Values: Functions can return values.
Example: A function to add two numbers.
def add_numbers(a, b):
return a + b # Returns the sum of a and b
# Calling the function
result = add_numbers(3, 5)
print("Sum:", result)
Procedural Programming
3. Variables: Local vs. Global Scope:
Local Variables: Defined inside a function and only
accessible within that function.
Global Variables: Defined outside all functions and
accessible throughout the program.
Example: Demonstrating local and global variables.
x = 10 # Global variable
def my_function():
x = 5 # Local variable
print("Inside function:", x) # Local x is used
my_function()
print("Outside function:", x) # Global x is used
Procedural Programming
4. Control Structures in Procedural Programming:
Procedural programming heavily relies on control structures
to define the flow of execution.
Conditionals (If-Else Statements):
Allows decision-making in code based on conditions.
Example: Checking if a number is positive, negative, or zero.
def check_number(n):
if n > 0:
print("Positive number")
elif n < 0:
print("Negative number")
else:
print("Zero")
check_number(10)
Procedural Programming
4. Control Structures in Procedural Programming:
Loops (For and While Loops):
Loops are essential for repetitive tasks.
For Loop: Iterates over a sequence (like a list or range).
# Print numbers from 1 to 5
for i in range(1, 6):
print(i)
While Loop: Repeats as long as a condition is true.
count = 0
while count < 5:
print("Count:", count)
count += 1
Procedural Programming
5. Example: Simple Python Calculator using Functions:
Procedural programming enables the creation of organized
and reusable code like a calculator with functions.
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b != 0:
return a / b
else:
return "Error: Division by zero"
# Example usage
num1 = 10
num2 = 5
print("Addition:", add(num1, num2))
print("Subtraction:", subtract(num1, num2))
print("Multiplication:", multiply(num1, num2))
print("Division:", divide(num1, num2))
Procedural Programming
6. Real-World Application:
Key Takeaways:
Procedural programming breaks complex problems into smaller,
manageable tasks through functions.
It is widely used in automation scripts, data processing, and
solving computational problems.
Practical Example: Procedural programming in Python is commonly
used for:
Building automation scripts.
Performing mathematical computations.
Data analysis tasks in fields like finance and research.
Procedural Programming
Quick Exercise:
Write a function that calculates the factorial of a given number
using a loop.
def factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
print(factorial(5)) # Output: 120
Data Types:
Identifiers and Keywords,
Integral types,
Floating Point Types
Introduction to Data Types in Python
Definition:
A data type in Python refers to the kind of value a variable can
hold.
Python’s dynamically typed nature allows it to infer the type of
a variable when it’s assigned a value.
Common Data Types in Python:
Numeric Types : int, float
Text Type : str
Boolean Type : bool
Sequence Types : list, tuple, etc.
Introduction to Data Types in Python
Why Data Types are Important:
Data Types help Python interpret and perform operations on
data correctly.
Data Types ensure efficient memory usage and error-free code.
Visual Example:
Imagine each data type as a box that holds values of a specific
kind:
Integers (whole numbers) go into one type of box.
Floating-point numbers (with decimal points) go into another.
Introduction to Data Types in Python
2. Identifiers and Keywords:
Identifiers:
Definition: Identifiers are names given to variables, functions,
classes, or other objects in Python.
Rules for Naming Identifiers:
Can contain letters (a-z, A-Z), digits (0-9), and underscores
(_).
Cannot start with a digit (e.g., 1st_place is invalid).
Python is case-sensitive, so 'Var' and 'var' are different
identifiers.
Introduction to Data Types in Python
2. Identifiers and Keywords:
Example:
# Valid Identifiers
age = 25
student_name = "Alice"
height_in_meters = 1.75
# Invalid Identifiers
1st_place = "Winner" # Starts with a number
student-name = "Alice" # Contains hyphen (-), which is not allowed
Introduction to Data Types in Python
2. Identifiers and Keywords:
Best Practices:
Use descriptive names: student_name instead of x.
Follow naming conventions:
lowercase with underscores for variable names.
PascalCase for class names.
Keywords:
Definition: Keywords are reserved words in Python that have a
special meaning. These cannot be used as identifiers.
List of Common Keywords:
if, else, for, while, class, def, return, True, False
Introduction to Data Types in Python
2. Identifiers and Keywords:
A flowchart illustrating the use of keywords in Python (such as if-
else structures).
Introduction to Data Types in Python
2. Identifiers and Keywords:
Example: The following would raise an error because def is a
keyword.
def = 5 # Invalid, because "def" is a keyword
Example: To list all Python keywords.
import keyword
print(keyword.kwlist)
Introduction to Data Types in Python
3. Integral Types (int):
Integer Data Type:
Definition:
• The int type in Python represents whole numbers, both positive
and negative, without a decimal point.
Memory Usage:
• Python automatically adjusts the size of integers based on the
magnitude of the number. Unlike other languages, Python does
not restrict integer size.
Key Characteristics:
• No size limit.
• Python supports both positive and negative integers.
Introduction to Data Types in Python
3. Integral Types (int):
Example: To list all Python keywords.
x = 10 # Positive integer
y = -25 # Negative integer
z = 0 # Zero
Introduction to Data Types in Python
3. Integral Types (int):
Basic Arithmetic Operations:
Python provides built-in operators for performing arithmetic on
integers.
• Addition: +
• Subtraction: -
• Multiplication: *
• Division: / (Always results in a float, even if both operands are
integers)
a = 15
b=4
print("Addition:", a + b) # Output: 19
print("Subtraction:", a - b) # Output: 11
print("Multiplication:", a * b) # Output: 60
print("Division:", a / b) # Output: 3.75 (Float result)
Introduction to Data Types in Python
3. Integral Types (int):
Integer Division (//):
Integer Division returns the floor value of the division, discarding
the decimal part.
print("Integer Division:", a // b) # Output: 3 (floored result)
Introduction to Data Types in Python
3. Integral Types (int):
Modulus (%):
Modulus returns the remainder of the division.
print("Modulus:", a % b) # Output: 3 (remainder of 15/4)
Introduction to Data Types in Python
3. Integral Types (int):
Exponentiation (**):
Exponentiation raises one number to the power of another.
print("Exponentiation:", a ** b) # Output: 50625 (15 raised to the power
of 4)
Introduction to Data Types in Python
3. Floating Point Data Types (int):
Definition:
The float type represents numbers with decimal points. It's used when more
precision is needed than integers can offer, especially for scientific and financial
calculations.
Key Characteristics:
Follows the IEEE 754 standard for floating-point arithmetic.
Can represent very large or small numbers using scientific notation.
pi = 3.14159 # A common floating-point number
g = -9.8 # Negative floating-point number
scientific = 1.23e4 # 1.23 × 10^4 = 12300.0
Introduction to Data Types in Python
3. Floating Point Data Types (int):
Floating-Point Arithmetic:
Just like integers, floating-point numbers support basic arithmetic operations,
but with decimal precision.
x = 10.5
y = 4.2
print("Addition:", x + y) # Output: 14.7
print("Subtraction:", x - y) # Output: 6.3
print("Multiplication:", x * y) # Output: 44.1
print("Division:", x / y) # Output: 2.5
Introduction to Data Types in Python
3. Floating Point Data Types (int):
Precision Issues in Floating-Point Numbers:
Floating-point numbers are not always 100% precise due to how they're stored
in memory.
result = 0.1 + 0.2
print(result) # Output: 0.30000000000000004 (slight precision error)
Introduction to Data Types in Python
3. Floating Point Data Types (int):
Rounding Floats:
To handle precision errors, you can use Python’s round() function to round off
floating-point numbers to a specified number of decimal places.
value = 3.14159
print(round(value, 2)) # Output: 3.14 (rounded to 2 decimal places)
Introduction to Data Types in Python
3. Floating Point Data Types (int):
Scientific Notation with Floats:
Python allows very large or small numbers to be written in scientific notation
using e (exponent) notation.
large_number = 2.5e6 # 2.5 × 10^6 = 2500000.0
print(large_number) # Output: 2500000.0
Thank You
