#Python Course Notes

##What is Python?

Python is a widely used programming language, created in the early 1990s, applicable to tasks such as automation, web development, machine learning, and neural networks. Its simple syntax makes it easy to learn and run across platforms like Windows, macOS, and Linux.

##Running Python Code

Python is an interpreted language, eliminating the need for compilation, simplifying the

edit-test-debug

1. >Interactive Mode: Commands executed immediately after being entered.
2. >Script Mode: Commands written into a

   .py

   file are executed using the Python interpreter.
   bash

   python file_name.py

##The Python REPL

Python provides an interactive console called

REPL

##Variables

Variables store data and are created using the assignment operator

=

##Data Types

Python includes various built-in data types:

• >int: Whole numbers.
• >float: Decimal numbers.
• >bool:

  True

  or

  False

  .
• >str: Strings of characters.

##The

print

Function

The

print()

##User Input

You can collect input using the

input()

Convert user input to an integer with

int()

##Line Continuation (

;\

)

You can continue a line of code across multiple lines using

;\

##Operators

Python supports various operators:

• >Arithmetic:

  +

  ,

  -

  ,

  *

  ,

  /

  .
• >Comparison:

  ==

  ,

  !=

  ,

  <

  ,

  >

  .
• >Logical:

  and

  ,

  or

  ,

  not

  .

##Command-Line Input

Python scripts can accept command-line arguments using the

sys

##Conditional Statements

Use

if

elif

else

##Boolean Logic

Combine conditions with

and

or

##Strings

Strings in Python are sequences of characters and are immutable.

###Quotation Marks

Strings can use single, double, or triple quotes for multiline text.

###String Methods

Python offers several methods for working with strings, like

split()

find()

count()

##Searching in Strings

Check if a substring exists using the

in

Use

.find()

.count()

###String Formatting in Python

1. Percent (%) Formatting

• >

  Placeholder for variable:

  %s

  .

• >

  Format:

  "string" % variable

  .

• >

  Example:

  python

  mass_percentage = "1/6" print("On the Moon, you would weigh about %s of your weight on Earth." % mass_percentage)

  Output:

  On the Moon, you would weigh about 1/6 of your weight on Earth.

• >

  Multiple values require parentheses around variables:

  python

  print("""Both sides of the %s get the same amount of sunlight, but only one side is seen from %s because the %s rotates around its own axis when it orbits %s.""" % ("Moon", "Earth", "Moon", "Earth"))

  Output:

  Both sides of the Moon get the same amount of sunlight, but only one side is seen from Earth because the Moon rotates around its own axis when it orbits Earth.

• >

  Tip: This method can lead to errors with multiple variables. Other methods are better for complex formatting.

2. The

.format()

Method

• >

  Use

  {}

  as placeholders.

• >

  Format:

  "string".format(variable)

  .

• >

  Example:

  python

  mass_percentage = "1/6" print("On the Moon, you would weigh about {} of your weight on Earth.".format(mass_percentage))

  Output:

  On the Moon, you would weigh about 1/6 of your weight on Earth.

• >

  Reuse variables by referencing their index:

  python

  print("You are lighter on the {0}, because on the {0} you would weigh about {1} of your weight on Earth.".format("Moon", mass_percentage))

  Output:

  You are lighter on the Moon, because on the Moon you would weigh about 1/6 of your weight on Earth.

• >

  Use keyword arguments for improved readability:

  python

  print("You are lighter on the {moon}, because on the {moon} you would weigh about {mass} of your weight on Earth.".format(moon="Moon", mass=mass_percentage))

  Output:

  You are lighter on the Moon, because on the Moon you would weigh about 1/6 of your weight on Earth.

3. f-strings (Python 3.6+)

• >

  Variables directly placed inside

  {}

  .

• >

  Format:

  f"string {variable}"

  .

• >

  Example:

  python

  print(f"On the Moon, you would weigh about {mass_percentage} of your weight on Earth.")

  Output:

  On the Moon, you would weigh about 1/6 of your weight on Earth.

• >

  Supports expressions inside

  {}

  :
  python

  print(f"On the Moon, you would weigh about {round(100/6, 1)}% of your weight on Earth.")

  Output:

  On the Moon, you would weigh about 16.7% of your weight on Earth.

• >

  String methods within f-strings:

  python

  subject = "interesting facts about the moon" heading = f"{subject.title()}" print(heading)

  Output:

  Interesting Facts About The Moon.

#Operators in Python

In Python, operators are symbols that perform operations on values or variables. Math typically involves four core operations—addition, subtraction, multiplication, and division—and Python supports these operators as well as many others. Here's a look at the most common ones you'll encounter in Python programs.

###1. Addition

The

+

You can use the

+

###2. Subtraction

The

-

###3. Multiplication

The

*

###4. Division

The

/

###5. Floor Division

Floor division

//

###6. Modulo

The

%

###7. Order of Operations

Python follows the standard order of operations (PEMDAS), which dictates the sequence in which operations should be evaluated:

• >Parentheses
• >Exponents
• >Multiplication and Division
• >Addition and Subtraction

Parentheses are evaluated first, making them useful for controlling the order in which operations are performed.

In both cases, the result is the same because Python first evaluates the multiplication before performing the addition. However, using parentheses in

result_2

#Working with Numbers in Python

Python provides a wide variety of tools to handle numbers, including conversion, rounding, and working with absolute values. Let's explore some common tasks and how to perform them in Python.

###1. Convert Strings to Numbers

Python supports two primary number types: integers (

int

float

To convert strings to numbers, use

int()

float()

If the string cannot be converted (e.g.,

'abc'

###2. Absolute Values

The absolute value is the non-negative version of a number, regardless of its sign. To get the absolute value of a number, use the

abs()

In both cases,

abs()

###3. Rounding

Python's

round()

.5

.5

.5

###4. Math Library

Python also provides a

math

ceil

floor

• >

  ceil()

  always rounds up.
• >

  floor()

  always rounds down.

The

math

These basic tools for working with numbers are essential for performing calculations and processing numerical data in Python.

#Introducing Lists in Python

##What is a List?

• >A list is a Python data type used to store collections of values.

##Creating a List

• >

  Lists are created by assigning a sequence of values to a variable using brackets

  []

  and separating items with commas:
  python

  planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

##Accessing List Items by Index

• >

  Items in a list can be accessed using their index (starting from 0):

  python

  print("The first planet is", planets[0]) # Output: Mercury print("The second planet is", planets[1]) # Output: Venus

##Modifying List Items

• >

  You can modify values in a list by assigning a new value at a specific index:

  python

  planets[3] = "Red Planet" print("Mars is also known as", planets[3]) # Output: Mars is also known as Red Planet

##Determining the Length of a List

• >

  Use the

  len()

  function to get the number of items in a list:
  python

  number_of_planets = len(planets) print("There are", number_of_planets, "planets in the solar system.") # Output: 8

##Adding Values to Lists

• >

  Use the

  .append()

  method to add an item to the end of the list:
  python

  planets.append("Pluto") number_of_planets = len(planets) print("There are actually", number_of_planets, "planets in the solar system.") # Output: 9

##Removing Values from Lists

• >

  The

  .pop()

  method removes the last item in the list:
  python

  planets.pop() # Removes Pluto print("No, there are definitely", len(planets), "planets in the solar system.") # Output: 8

##Using Negative Indexes

• >

  Negative indexes access items from the end of the list:

  python

  print("The last planet is", planets[-1]) # Output: Neptune print("The penultimate planet is", planets[-2]) # Output: Uranus

##Finding a Value in a List

• >

  The

  .index()

  method returns the index of a value in the list:
  python

  jupiter_index = planets.index("Jupiter") print("Jupiter is the", jupiter_index + 1, "planet from the sun") # Output: 5th planet

Here is a concise summary of the provided text, along with a beautified markdown version:

###Short Notes

Working with Numbers in Lists

• >Planetary Gravity: Measured in G, relative to Earth's gravity (1G).
• >Floats in Python: Use floats to represent gravitational forces.
• >Gravity on Planets:
  python

  gravity_on_planets = [0.378, 0.907, 1, 0.377, 2.36, 0.916, 0.889, 1.12]
• >Calculate Weights on Different Planets:
  • >Multiply object weight by the planet's gravity:
    python

    bus_weight = 124054 # Newtons on Earth mercury_weight = bus_weight * gravity_on_planets[0] # On Mercury
• >Use

  min()

  and

  max()

  to Find Weight Extremes:
  • >

    min()

    gives the smallest weight,

    max()

    gives the largest.

Example:

#Work with Numbers in Lists

###Planetary Gravity

Gravity varies across planets and is measured in G, where Earth's gravity is 1G. For example, the Moon's gravity is 0.166G, and Neptune's is 1.12G.

###Store Numbers in Lists

To store numbers with decimal places, Python uses the

float

Here,

gravity_on_planets[0]

###Calculate Weight on Different Planets

To find how much an object weighs on other planets, you multiply its weight on Earth by the planet’s gravity.

For example, to calculate the weight of a double-decker bus (124,054N) on Mercury:

Output:

On Mercury, a double-decker bus weighs 46892.4 N

###Use

min()

and

max()

with Lists

You can find the smallest and largest gravitational values using

min()

max()

To determine the minimum and maximum weights a bus could have in the solar system:

Output:

The lightest a bus would be in the solar system is 46768.35 N
The heaviest a bus would be in the solar system is 292767.44 N

###Manipulating List Data

Slicing Lists

• >Slices let you access portions of a list. You specify a starting and ending index using the syntax

  list[start:end]

  .
• >The element at the end index is not included.

Example:

Joining Lists

• >You can concatenate two lists using the

  +

  operator, which creates a new list.

Example:

Sorting Lists

• >Use the

  .sort()

  method to sort lists. This sorts alphabetically for strings and numerically for numbers. Sorting modifies the original list.

Example:

• >To reverse sort, use the

  reverse=True

  option:

###Key Points:

• >Slicing returns a new list without modifying the original.
• >Joining lists with

  +

  creates a new list.
• >Sorting modifies the original list in place.

#About

while

Loops

One common challenge when writing code is performing a task an unknown number of times. For example, you may want to allow a user to enter a list of planet names but don't know how many names they will input. In these situations, you can use a

while

###What is a

while

Loop?

A

while

while

• >Check for another line in a file.
• >Monitor if a flag has been set.
• >Determine if a user has finished entering values.
• >Check if something has changed, allowing the loop to end.

Important: The key thing to remember with

while

loops is to ensure that the condition changes. If the condition remains true indefinitely, Python will continue to run the loop, eventually causing the program to crash.

###

while

Loop Syntax

The syntax of a

while

if

1. >The keyword

   while

   , followed by a space.
2. >The condition you want to test. If this condition is true, the code inside the loop runs.
3. >The code that should run with each iteration, indented properly.

Example:

###Example: Prompting for User Input

The following code prompts users to enter values until they type

done

while

Note:
We use the

.lower()

function to make the comparison case-insensitive, allowing the user to type

done

in any case.

###Adding User Input to a List

You can capture each value and store it in a list by expanding on the previous example:

Note:
The

if

statement inside the loop checks whether there is a value in

user_input

. The first time the loop runs,

user_input

is empty, so there’s nothing to store. Once the loop starts, the condition ensures that the input is only stored if it is not

done

.

###Python Doesn't Support

do-while

Loops

Some programming languages provide a

do

while

#Using

for

Loops with Lists

In Python, lists can store various types of values, including strings and numbers. Here's an example of a list that stores the names of planets:

You can access any item in a list using its index, which starts at 0:

###Looping Over Lists with

for

Loops

You can determine the length of a list using the

len()

while

for

for

Note: Python lists are iterable, and you can use

for

loops to go through each element of the list.

###Example: A Simple

for

Loop

Here’s an example of a

for

How

for

Loops Work

A

for

1. >The word

   for

   , followed by a space.
2. >A variable name (in this case,

   number

   ) that will represent each value in the sequence.
3. >The word

   in

   , surrounded by spaces.
4. >The name of the list or iterable you want to loop over (in this example,

   countdown

   ), followed by a colon (

   :

   ).
5. >The code you want to execute for each item in the iterable, indented properly.

###Adding Delays with the

sleep()

Function

You can modify the countdown example to wait for one second between each number using the

sleep()

time

###A Quick Note on Whitespace

Most Python code uses four spaces as the unit of indentation. To avoid pressing the space bar four times, many code editors provide a Tab key shortcut that automatically inserts four spaces.

In conclusion,

for

sleep()

#Introducing Python Dictionaries

In Python, variables can store different types of data such as strings or numbers. For instance:

However, when working with related data—such as storing details for different planets and their moons—this approach becomes inefficient. Here’s an example:

This redundancy makes the code unwieldy, especially when dealing with larger datasets. Fortunately, Python dictionaries can simplify how you manage related data.

##What Are Dictionaries?

A dictionary in Python is a collection of key/value pairs. Think of it as a container that holds multiple variables, where each key (name) is associated with a specific value.

Dictionaries use curly braces (

{}

In this dictionary:

• >

  'name'

  is a key with the value

  'Earth'

  (a string).
• >

  'moons'

  is a key with the value

  1

  (an integer).

Keys can be strings, numbers, or other immutable types, while values can be of any type.

##Accessing Values in a Dictionary

You can access values stored in a dictionary using the

get()

[]

'name'

Alternatively, you can use square brackets, which are more concise:

###Difference between

get()

and

[]

:

• >

  get()

  returns

  None

  if the key doesn’t exist.
• >Square brackets (

  []

  ) raise a

  KeyError

  if the key isn’t found.

##Modifying Dictionary Values

You can modify dictionary values using the

update()

###Using

update()

:

###Using square brackets:

Both methods work, but

update()

Using square brackets would require two separate operations for the same result:

##Adding and Removing Keys

You can add new keys to a dictionary at any time. For example, to add the orbital period of a planet:

To remove a key, use the

pop()

##Nested Dictionaries

Dictionaries can store any type of value, including other dictionaries. This is useful for modeling more complex data. For example, let’s store both the polar and equatorial diameters of Jupiter:

To retrieve values from a nested dictionary, chain square brackets or

get()

###Summary of Key Dictionary Operations:

• >Create: Use curly braces

  {}

  to define a dictionary with key/value pairs.
• >Access: Use

  get()

  or

  []

  to retrieve values.
• >Modify: Use

  update()

  or

  []

  to change values.
• >Add: Use

  []

  to add new keys.
• >Remove: Use

  pop()

  to delete keys.
• >Nested Data: Store dictionaries inside other dictionaries for complex data structures.

Dictionaries provide a powerful and flexible way to work with structured data, making them an essential tool for many programming tasks.

##Dynamic Prgramming With Dictionaries

Dynamic programming with dictionaries in Python allows you to perform calculations and manipulate data dynamically. Let's break down some useful techniques with dictionaries, using an example of rainfall data for various months.

###1. Retrieve All Keys and Values:

You can use the

keys()

values()

Output:

october: 3.5 cm
november: 4.2 cm
december: 2.1 cm

###2. Check if a Key Exists:

To avoid overwriting an existing value in the dictionary, you can use the

in

This prevents overwriting existing data unless you're updating it intentionally.

###3. Retrieve All Values for Calculations:

The

values()

For instance, to calculate the total rainfall over the last quarter:

Output:

Total rainfall in the last quarter: 9.8 cm

This dynamic approach eliminates the need to hard-code values, making your program more flexible and efficient.

###4. Adding or Updating Dictionary Entries:

When adding or updating entries dynamically, you can either overwrite existing values or add new keys.

Output:

{'october': 3.5, 'november': 4.7, 'december': 2.1, 'january': 4.0}

Using these techniques, you can effectively manage and manipulate dictionary data dynamically in Python, enabling you to handle more complex tasks.

#Python Functions

Python functions are a fundamental part of the language, allowing you to encapsulate reusable code. Here's a breakdown of the basics:

###1. Defining a Function

A function in Python is defined using the

def

This creates a function named

rocket_parts()

Output:

payload, propellant, structure

###2. Return Values

If a function doesn't return anything explicitly, it returns

None

To return a value, use the

return

Output:

payload, propellant, structure

###3. Arguments in Functions

You can pass arguments to functions to make them more dynamic. For example:

Output:

Hello, Alice!

Required Arguments:

Functions like

any()

Optional Arguments:

Some functions, like

str()

In this case, calling

str()

###4. Summary

• >Functions encapsulate reusable logic.
• >Return values explicitly using

  return

  or implicitly return

  None

  .
• >Arguments allow you to pass data to functions; they can be required or optional.
• >Python’s built-in functions like

  any()

  and

  str()

  demonstrate how functions can work with or without arguments.

##Function Arguments In Python

In Python, functions can be made more flexible by using arguments. Arguments allow a function to take in data, perform calculations, or make decisions based on that input.

###1. Requiring an Argument

A function can require an argument by including it inside the parentheses when defining the function. For example, a function that computes the distance to a destination from Earth could look like this:

To call this function, you need to provide a destination:

If you don't provide a required argument, Python will raise a

TypeError

###2. Multiple Required Arguments

Functions can also take multiple arguments. For example, you can calculate the number of days it would take to reach a destination based on the distance and speed:

You can call this function by passing both the distance and speed:

###3. Functions as Arguments

You can also use the result of one function as an argument for another function. For instance, you can use

days_to_complete()

round()

Or pass the function result directly:

This pattern can be useful, but it's important to ensure readability when nesting multiple function calls.

##Keyword Arguments In Python

In Python, keyword arguments allow you to pass arguments to a function by explicitly naming them, providing flexibility in how you call the function. Here's how you can work with keyword arguments effectively:

###1. Defining Keyword Arguments

To define a keyword argument, assign it a default value in the function definition. For example, you can create a function that estimates the time of arrival for a space mission:

###2. Calling Functions with Keyword Arguments

You can call the function without any arguments, and it will use the default value for

hours

If you want to test the function with a specific duration, you can specify the

hours

###3. Mixing Positional and Keyword Arguments

When you have both required and optional arguments in a function, you should always define positional arguments first, followed by keyword arguments. For example, you can update the

arrival_time

###4. Calling Functions with Mixed Arguments

Now, since

destination

You can still use keyword arguments for the optional parameters:

###Summary

• >Keyword arguments allow for more flexibility and clarity when calling functions.
• >You can mix positional and keyword arguments, but positional arguments must always come first in the function definition.
• >Default values for keyword arguments make it possible to call functions without specifying every argument, making your code cleaner and easier to read.

##Variable Arguments In Python

In Python, variable arguments allow you to pass an arbitrary number of arguments to a function, making it versatile and able to handle different input scenarios. Here's how you can use variable arguments effectively, along with variable keyword arguments.

###1. Using Variable Arguments

To create a function that accepts any number of positional arguments, use an asterisk (*) before the argument name. This collects all positional arguments into a tuple.

Example: Function with Variable Arguments

###2. Practical Application of Variable Arguments

You can create a function that calculates the total time until a launch, taking a variable number of time inputs:

###3. Using Variable Keyword Arguments

To handle an arbitrary number of keyword arguments, use a double asterisk (**). This collects all keyword arguments into a dictionary.

Example: Function with Variable Keyword Arguments

###4. Practical Application of Variable Keyword Arguments

You can create a function that reports the astronauts assigned to a mission, using variable keyword arguments:

###5. Important Notes

• >Variable arguments (

  *args

  ) can accept any number of positional arguments.
• >Variable keyword arguments (

  **kwargs

  ) can accept any number of keyword arguments, which are treated as dictionary entries.
• >If you use repeated keywords in

  **kwargs

  , Python will raise a

  SyntaxError

  .

###Summary

Using variable arguments and keyword arguments makes your functions flexible and able to handle varying numbers of inputs. They help create functions that can adapt to different contexts, which is particularly useful for larger projects.

#Error Handling

Even the best-written code will have errors. Errors can happen because of updates, moved files, or other unexpected changes. Fortunately, Python offers rich support for tracking down and handling errors.

##Using Traceback in Python

Understanding tracebacks in Python is essential for debugging and error handling. Tracebacks provide a detailed report of the sequence of events leading to an exception, helping developers identify and resolve issues in their code.

###What is a Traceback?

A traceback is a report generated by Python when an unhandled exception occurs. It details the call stack at the time of the error, including the sequence of function calls that led to the error, the line numbers, and the nature of the exception.

###Key Components of a Traceback

1. >File Paths: The traceback shows the paths of all files involved in the function calls.
2. >Line Numbers: Each file path includes the line number where the function is called.
3. >Function Names: It lists the names of functions or methods involved in the exception.
4. >Exception Name: The traceback ends with the name of the exception raised.

###Example of Traceback in Action

Let's explore a practical example to see how tracebacks work in Python.

Step 1: Create a Python Script

1. >Open your desired directory in Visual Studio Code.
2. >Create a new Python file named

   open.py

   .
3. >Add the following code to the file:

Step 2: Run the Script

Run the script in your terminal:

Expected Output

You should see an output similar to this:

Traceback (most recent call last):
  File "/path/to/open.py", line 5, in <module>
    main()
  File "/path/to/open.py", line 2, in main
    open("/path/to/mars.jpg")
FileNotFoundError: [Errno 2] No such file or directory: '/path/to/mars.jpg'

###Breakdown of the Output

1. >Traceback Start: Indicates the start of the traceback and the most recent call that failed.
2. >File Information:
   • >

     File "/path/to/open.py", line 5, in <module>

     : This line shows that the error occurred when executing the script located at

     /path/to/open.py

     , specifically at line 5 during the call to

     main()

     .
3. >Function Call Details:
   • >

     File "/path/to/open.py", line 2, in main

     : This line tells you that within the

     main()

     function, the error occurred at line 2 when trying to open the file.
4. >Error Type: Finally, you see the

   FileNotFoundError

   exception with the error message indicating that the file does not exist.

###Why Tracebacks Are Useful

• >Debugging: Tracebacks help you locate the source of an error quickly.
• >Understanding Flow: They illustrate the flow of execution and how various functions relate to one another.
• >Error Information: You get context about what went wrong and where, making it easier to implement fixes.

###Handling Exceptions Gracefully

Instead of allowing the program to crash with an unhandled exception, you can use try-except blocks to handle exceptions more gracefully:

###Summary

Tracebacks are powerful tools in Python for diagnosing errors and understanding the execution path leading to those errors. By mastering the interpretation of tracebacks, you can enhance your debugging skills, making it easier to develop robust software.

##Exception Handling

When you first find exceptions that show large tracebacks as output, you might be tempted to catch every error to prevent that from happening.

###Key Concepts of Exception Handling in Python

1. >

   Tracebacks:

   • >When an unhandled exception occurs, Python provides a traceback that shows the sequence of function calls that led to the error, helping you diagnose the problem.
   • >Example:
     python

     try: open("/path/to/mars.jpg") except FileNotFoundError as e: print(e) # This will print the traceback when the file is not found.
2. >

   Try and Except Blocks:

   • >Use

     try

     to wrap code that may raise an exception, followed by

     except

     to handle the specific exception.
   • >Example:
     python

     try: configuration = open('config.txt') except FileNotFoundError: print("Couldn't find the config.txt file!")
3. >

   Handling Multiple Exceptions:

   • >You can catch multiple specific exceptions separately to provide more descriptive error messages.
   • >Example:
     python

     try: configuration = open('config.txt') except FileNotFoundError: print("Couldn't find the config.txt file!") except IsADirectoryError: print("Found config.txt but it is a directory, couldn't read it")
4. >

   Grouping Exceptions:

   • >You can group similar exceptions together in a single

     except

     clause using parentheses.
   • >Example:
     python

     try: configuration = open('config.txt') except (FileNotFoundError, IsADirectoryError) as err: print("Error occurred:", err)
5. >

   Accessing Error Information:

   • >Use

     as

     to store the exception instance and access its attributes for more detailed information.
   • >Example:
     python

     try: open("mars.jpg") except FileNotFoundError as err: print("Got a problem trying to read the file:", err)
6. >

   Using the OSError Exception:

   • >For more generalized error handling, catch the

     OSError

     , which can provide information for several types of file-related issues.
   • >Example:
     python

     try: open("config.txt") except OSError as err: if err.errno == 2: print("Couldn't find the config.txt file!") elif err.errno == 13: print("Found config.txt but couldn't read it")

###Best Practices

• >Descriptive Error Messages: Always provide meaningful messages that help users understand what went wrong and how to potentially fix it.
• >Specificity Over Generalization: Catch specific exceptions unless you have a good reason to handle them all generically. This improves debuggability.
• >Maintain Readability: Write code that is easy to read and maintain, while ensuring users get useful feedback during errors.

###Summary

By effectively using exceptions in Python, you can create robust programs that handle errors gracefully, providing users with clear feedback on issues and helping maintain control flow during unexpected situations. This is especially crucial in applications where errors can lead to severe consequences, such as in critical systems like navigation software for space missions.

##Raise Exceptions

Raising exceptions is an important part of writing robust and user-friendly code. It allows you to signal error conditions clearly and provides context for what went wrong.

###Summary of Raising Exceptions

1. >

   Identifying Error Conditions:

   • >Determine when an error condition arises in your code. For example, if there is not enough water left for astronauts based on their daily usage.
2. >

   Using

   raise

   :
   • >Use the

     raise

     statement to trigger an exception when an error condition is detected. This can help other parts of your program handle the error appropriately.
   • >Example:
     python

     if total_water_left < 0: raise RuntimeError(f"There is not enough water for {astronauts} astronauts after {days_left} days!")
3. >

   Catching Exceptions:

   • >In the calling code, use

     try

     and

     except

     blocks to catch raised exceptions and take appropriate action, such as alerting the navigation system in the case of insufficient water.
4. >

   Validating Input Types:

   • >Check if input arguments are of the expected types, and raise a

     TypeError

     with a user-friendly message if they are not.
   • >Example:
     python

     for argument in [astronauts, water_left, days_left]: try: argument / 10 # Check if argument is an int except TypeError: raise TypeError(f"All arguments must be of type int, but received: '{argument}'")
5. >

   Improving Error Messages:

   • >Make error messages more informative and useful for debugging. This can help users understand what went wrong and how to fix it.
   • >Example:
     python

     TypeError: All arguments must be of type int, but received: '3'

###Example Code for Reference

Here’s a complete example based on the concepts you learned:

###Conclusion

##By raising exceptions and handling them effectively, you can create a more robust and user-friendly codebase. This practice not only helps in debugging but also provides clarity on the types of errors that can occur during execution, allowing users to address issues promptly. If you have any specific questions about this topic or need further examples, feel free to ask!