Introduction to Python Prog. - Lecture 3

Introduction to Python
Programming
By Mohamed Gamal
© Mohamed Gamal 2024

The topics of today’s lecture:
Agenda

Types of
Errors
Syntax Error
Semantic Error
Logical Error
Run-time Error

Types of Errors
– Syntax Errors: occur when the code does not follow the grammatical rules of the
programming language and detected by the interpreter during the code parsing phase.
– Semantic Errors: occur when the code follows the syntax rules but does not make logical
sense or produce the intended result, often arise from incorrect use of language constructs
and typically not detected by the interpreter.
– Logical Errors: occur when the code executes without syntax errors or semantic issues but
produces incorrect results due to flaws in the logic of the program, typically not detected by
the interpreter and identified through testing and debugging.
– Run-time Errors: occur while the program is executing and not detected during the parsing
phase and only show up during the actual execution of the code causing the program to
crash or terminate unexpectedly.

Examples
# Syntax Error: Missing colon
if x > 10
print("x is greater than 10")
# Semantic Error: Function name suggests addition
def add(a, b):
return a – b
# Logical Error: This function checks for odd numbers instead of even.
def is_even(n):
return n % 2 == 1
# Run-time Error: Division by zero
x = 10 / 0

Exception handling
– Exception handling in Python involves managing runtime errors that occur
during program execution.
– Python offers features for handling these errors, including exception handling
and assertions, to improve program stability and debugging.

1) Assertion
– Assertions in Python are a debugging aid that test whether a condition in your code is true.
– They are used to catch logical errors by ensuring that certain conditions hold true at specific
points in the program.
– How Assertions Work:
– An assertion is written using the assert keyword followed by a condition.
– If the condition is True, the program continues execution without interruption.
– If the condition is False, an AssertionError is raised, which can include an optional error message.
assert condition, "Error message if condition is False"
Syntax:

Example
def divide(a, b):
assert b != 0, "Division by zero is not allowed"
return a / b
print(divide(10, 2)) # Works fine
print(divide(10, 0)) # Raises AssertionError

2) Exceptions
– In Python, exceptions are errors that occur during program execution (run-time), disrupting
its normal flow.
– They can be raised automatically by the interpreter or manually using the raise keyword to
help manage errors and maintain program stability.
– Common Exceptions:
– ZeroDivisionError
– ValueError
– IndexError
– FileNotFoundError

Handling Exceptions
1) Use try to wrap code that might raise an exception.
2) Use except to handle the exception.
3) Optionally, use else for code that runs if no exception occurs.
4) Use finally for code that always executes, regardless of exceptions.

Python Try-Except Block
try:
# Code that might raise exceptions
except FirstExceptionType:
# Handle the first type of exception
except SecondExceptionType:
# Handle the second type of exception
...
Syntax:

try:
result = 10 / 0 # Division by zero
except ZeroDivisionError:
print("Error: Cannot divide by zero.")
try:
number = int("abc") # Invalid literal for int()
except ValueError:
print("Error: Invalid value provided.")
try:
my_list = [1, 2, 3]
print(my_list[5]) # Index out of range
except IndexError:
print("Error: Index out of range.")

Python Try-Except-Else Block
try:
user_input = input("Enter an integer: ") # Attempt to get user input
number = int(user_input) # Try to convert input to integer
except ValueError:
# Handle invalid input
print("Error: Invalid input. Please enter a valid integer.")
else:
square = number ** 2 # Compute square if no exception occurred
print(f"The square of {number} is {square}.") # Output the result

try:
result = 10 / 2 # No error
except ZeroDivisionError:
print("Error: Cannot divide by zero.")
else:
print(f"Division successful. Result: {result}")
finally:
print("This block always executes.")
Python Try-Except-Else-Finally Block

2) Raising Exceptions
– In Python, you can raise exceptions explicitly using the raise statement.
– Raising exceptions allows you to indicate that an error has occurred and to control
the flow of your program by handling these exceptions appropriately.
def check_positive(number):
if number <= 0:
raise ValueError("The number must be positive.")
return number
try:
result = check_positive(-5) # This will raise ValueError
except ValueError as e:
print(f"Error: {e}")

Raising Exceptions
– Multithreading allows you to run multiple threads (smaller units of a process)
concurrently, which can be useful for tasks like I/O-bound operations.
– Python’s threading module provides the tools for working with threads.

import threading
threading.current_thread().name
example_thread = threading.Thread()
example_thread.setName()
example_thread.daemon = True
example_thread.start()
example_thread.join()
Most commonly used Thread related methods

import threading
import time
def print_numbers():
for i in range(5):
print(f"Number: {i}")
time.sleep(1)
def print_letters():
for letter in 'abcde':
print(f"Letter: {letter}")
time.sleep(1)
# Create threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)
# Start threads
thread1.start()
thread2.start()
# Wait for threads to complete
thread1.join()
thread2.join()
print("Finished executing both threads")
Example 1

import threading
def print_repeated(text, times):
for _ in range(times):
print(text)
# Create threads with arguments
thread1 = threading.Thread(target=print_repeated, args=("Hello", 3))
thread2 = threading.Thread(target=print_repeated, args=("World", 3))
# Start threads
thread1.start()
thread2.start()
# Wait for threads to complete
thread1.join()
thread2.join()
Example 2

import threading, time
def background_task():
while True:
print("Background task running...")
time.sleep(1)
# Create a daemon thread
thread = threading.Thread(target=background_task)
thread.daemon = True # Set as daemon thread
# Start the daemon thread
thread.start()
# Main thread execution
print("Main thread is running")
# thread.join()
time.sleep(5)
print("Main thread is done")
Example 3
• A daemon thread runs in the
background and terminates when
the main program exits.

Python Generators
– Python generators are a powerful and efficient way to handle large sequences of
data.
– A generator is a special type of iterator that generates values on the fly and yields
them one at a time using the yield keyword. This makes them memory efficient
because they don’t store all the values in memory.
squares = (x * x for x in range(5))
for square in squares:
print(square)

Example 1
squares = (x * x for x in range(5))
print(type(squares))
print(squares)
# print next item
print(next(squares))
# print all items
for square in squares:
print(square)

Example 2
# generator function
def count_up_to(max):
count = 1
while count <= max:
yield count
count += 1
# Using the generator
counter = count_up_to(5)
for num in counter:
print(num)

PIP Package Installer
– pip is the package installer for Python, it allows you to install and manage Python
libraries and dependencies from the Python Package Index (PyPI) and other package
repositories.
– Here’s a basic usage:
$ pip install package_name
$ pip uninstall package_name
$ pip list
$ pip show package_name
$ pip install --upgrade package_name

import time
localtime = time.asctime(time.localtime(time.time()))
print(f"Local current time: {localtime}")
import calendar
cal = calendar.month(2024, 7)
print(cal)
Time and Calendar Modules

Some Applications
Snake Game
Snake Game
Keylogger Program
Keylogger Program
⋮
Final tip: Searching is a crucial skill.

Introduction to Python Prog. - Lecture 3

More Related Content

Similar to Introduction to Python Prog. - Lecture 3

More from Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt

Recently uploaded

Introduction to Python Prog. - Lecture 3