This unit introduces Kotlin and how to set up the development environment for Android development.

What is Kotlin?

What is Kotlin?

Kotlin is a modern, trending programming language that was released in 2016 by JetBrains.

It has become very popular since it is compatible with Java (one of the most popular programming languages out there), which means that Java code (and libraries) can be used in Kotlin programs.

Kotlin is used for:

• Mobile applications (especially Android apps)
• Web development
• Server-side applications
• Data science
• And much more!

Why Use Kotlin?

• ✅ Fully compatible with Java
• ✅ Works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc.)
• ✅ Concise and safe
• ✅ Easy to learn, especially if you already know Java
• ✅ Free to use
• ✅ Big community/support

Get Started

This tutorial will teach you the very basics of Kotlin.

It is not necessary to have any prior programming experience.

Kotlin IDE and Installation Guide

Kotlin IDE

The easiest way to get started with Kotlin is by using an IDE (Integrated Development Environment).

An IDE is used to edit and compile code efficiently.

For this guide, we will use IntelliJ IDEA, developed by the same creators of Kotlin. It is free to download from:

Download IntelliJ IDEA

Kotlin Install

Once IntelliJ is downloaded and installed, click on the New Project button to get started:

Then, click on "Kotlin" in the left-side menu and enter a name for your project:

Next, we need to install the JDK (Java Development Kit) to run Kotlin projects. Click on the "Project JDK" menu, select "Download JDK", then choose a version and vendor (e.g., AdoptOpenJDK 11), and click "Download":

When the JDK is installed, select it from the menu and click "Next", then "Finish":

Now, let's start working with Kotlin! Open the src (source) folder and follow the steps in the image below to create a new Kotlin file:

Choose "File", enter a name for your Kotlin file (e.g., Main):

Kotlin Syntax

Kotlin Syntax

In the previous chapter, we created a Kotlin file called Main.kt, and we used the following code to print "Hello World" to the screen:

Example

fun main() {
                          println("Hello World")
                        }

---

Example Explained

The fun keyword is used to declare a function. A function is a block of code designed to perform a particular task.

In the example above, we declared the main() function, which is the entry point of every Kotlin program. Any code inside the main() function’s curly brackets { } will be executed.

The println() function is inside main(), meaning that it will be executed. The println() function is used to output/print text, and in our example, it will output:

Output:

Hello World

---

📌 Good to Know:

In Kotlin, **statements do not require a semicolon** (;) at the end, unlike Java, C++, or C#.

However, if you place multiple statements on the same line, you **must** use a semicolon to separate them:

Example:

fun main() { println("Hello"); println("World") }

Output:

Hello
                        World

---

Main Function Parameters

Before Kotlin version **1.3**, the main() function was required to have parameters.

The correct syntax was:

Example:

fun main(args: Array) {
                          println("Hello World")
                        }

However, starting from Kotlin 1.3, **parameters are optional**, and the program will run fine without them.

✅ Modern Syntax (No Parameters Required)

fun main() {
                          println("Hello World")
                        }

Even though parameters are no longer required, you can still use them if needed. For example, you can access command-line arguments like this:

Example:

fun main(args: Array) {
                          if (args.isNotEmpty()) {
                            println("Command-line argument: " + args[0])
                          } else {
                            println("No arguments provided.")
                          }
                        }

If you run the program with an argument (e.g., Hello Kotlin), the output will be:

Output:

Command-line argument: Hello Kotlin

---

Try it Yourself

Want to experiment with Kotlin code? Use the Try it yourself Tool to test the examples online.

🎉 Now that you understand Kotlin syntax, let's move on to writing more advanced Kotlin programs!

Kotlin Output (Print)

Kotlin Output (Print)

The println() function is used to output values or print text in Kotlin.

Example:

fun main() {
                          println("Hello World")
                        }

Output:

Hello World

---

Printing Multiple Lines

You can use multiple println() functions to print text on separate lines.

Example:

fun main() {
                          println("Hello World!")
                          println("I am learning Kotlin.")
                          println("It is awesome!")
                        }

Output:

Hello World!
                        I am learning Kotlin.
                        It is awesome!

---

Printing Numbers and Calculations

Kotlin allows you to print numbers and perform mathematical operations directly inside println().

Example:

fun main() {
                          println(3 + 3)
                        }

Output:

6

---

The print() Function

The print() function is similar to println(), but it does not insert a new line at the end of the output.

Example:

fun main() {
                          print("Hello World! ")
                          print("I am learning Kotlin. ")
                          print("It is awesome!")
                        }

Output:

Hello World! I am learning Kotlin. It is awesome!

💡 Notice how all the text is printed on the same line.

---

Comparing println() vs. print()

Function	Description	Example
println()	Prints text and moves to a new line	println("Hello")
print()	Prints text on the same line	print("Hello")

---

Try it Yourself

Want to test your Kotlin code? Use the Try it yourself Tool to practice printing output in Kotlin.

🎉 Now that you understand how to print text and numbers in Kotlin, let's move on to working with **variables**! 🚀

Kotlin Comments

Kotlin Comments

Comments are used to **document** code, make it more **readable**, and prevent execution when testing alternative code.

There are **two types** of comments in Kotlin:

• Single-line comments (Using //)
• Multi-line comments (Using /* */)

---

Single-line Comments

Single-line comments start with **two forward slashes (`//`)**.

Any text after // on the same line is **ignored by Kotlin** (will not be executed).

Example: Single-line comment before a line of code

// This is a comment
                        println("Hello World")

Example: Single-line comment at the end of a line

println("Hello World")  // This is a comment

Output:

Hello World

💡 The comment does not affect the execution of the code.

---

Multi-line Comments

Multi-line comments start with /* and end with */.

Everything inside /* ... */ will be **ignored** by the compiler.

Example: Multi-line comment (Block comment)

/* The code below will print the words "Hello World"
                           to the screen, and it is amazing */
                        println("Hello World")

Output:

Hello World

---

Using Comments to Disable Code

Developers often **disable code** by turning it into a comment:

Example:

// println("This line will not run")
                        println("Hello Kotlin!")

Output:

Hello Kotlin!

💡 The first line is ignored because it is a **comment**.

---

Why Use Comments?

• 📝 **Explain complex code** to make it more readable.
• 🛠 **Disable lines of code** during testing.
• 👥 **Help teams understand the purpose of the code**.

---

Try it Yourself

Want to experiment with Kotlin comments? Use the Try it yourself Tool to test the examples online.

🎉 Now that you understand Kotlin comments, let's move on to **Kotlin Variables!** 🚀

• Python Functions

  Python Functions - Short Notes for Kids

  A function in Python is like a magic box that performs a specific task when you call it. Functions help us organize code, avoid repetition, and make our programs easier to read.

  Why Are Functions Important?

  • They allow us to reuse code without writing it multiple times.
  • They make programs more organized and easier to understand.
  • They help break big problems into smaller parts.

  Creating a Function (Defining a Function)

  To create a function in Python, we use the def keyword, followed by the function name and parentheses ().

  def say_hello():
      print("Hello, World!")

  Output:

  Hello, World!

  Calling a Function

  Once a function is defined, you can call it by using its name followed by parentheses.

  say_hello()  # This will call the function and run its code.

  Output:

  Hello, World!

  Functions with Parameters (Inputs)

  A function can take inputs (called parameters) to perform a task based on the input.

  def greet(name):
      print("Hello, " + name + "!")
  
  greet("Alice")
  greet("Bob")

  Output:

  Hello, Alice!

  Hello, Bob!

  Functions with Return Values

  Instead of just printing, a function can return a value to be used later.

  def multiply(x, y):
      return x * y
  
  result = multiply(4, 3)
  print(result)

  Output:

  12

  Default Parameters

  Functions can have default values for parameters. If no value is provided when calling the function, the default is used.

  def greet(name="friend"):
      print("Hello, " + name + "!")
  
  greet()        # Uses the default value
  greet("Alice") # Uses the provided value

  Output:

  Hello, friend!

  Hello, Alice!

  Using Functions with input()

  We can take user input and pass it as an argument to a function.

  def favorite_color(color):
      print("Wow! " + color + " is a beautiful color!")
  
  user_color = input("Enter your favorite color: ")
  favorite_color(user_color)

  Calling Functions Inside Functions

  A function can call another function.

  def say_hello():
      print("Hello!")
  
  def greet_person(name):
      say_hello()
      print("Nice to meet you, " + name + "!")
  
  greet_person("Alice")

  Output:

  Hello!

  Nice to meet you, Alice!

  Breaking a Problem into Functions

  Functions can be used to divide a big problem into smaller tasks.

  def calculate_area(length, width):
      return length * width
  
  def display_area(length, width):
      area = calculate_area(length, width)
      print("The area is:", area)
  
  display_area(5, 3)

  Output:

  The area is: 15

  Fun Experiment

  Try creating a function that calculates the square of a number:

  def square(number):
      return number * number
  
  print(square(4))  # Output: 16
  print(square(7))  # Output: 49

  Key Points to Remember About Functions

  • Use the def keyword to define a function.
  • Functions can take parameters (inputs) and return results.
  • Use return to send a result back from a function.
  • Functions help you avoid repeating code by reusing the same logic.
  • Always indent the code inside a function.
• Python Operators

  Python Operators

  Operators in Python are special symbols or keywords that perform actions on values. They are used for calculations, comparisons, and logic-based tasks.

  Types of Python Operators

  • Arithmetic Operators: For performing basic mathematical operations like addition, subtraction, etc.
  • Comparison Operators: For comparing two values.
  • Logical Operators: For combining conditional statements.
  • Assignment Operators: For assigning values to variables.
  • Membership Operators: For testing whether a value is found in a sequence.

  Arithmetic Operators

  +  Add: 5 + 3 = 8
  -  Subtract: 10 - 4 = 6
  *  Multiply: 6 * 2 = 12
  /  Divide: 8 / 2 = 4.0
  // Floor Division: 9 // 2 = 4
  %  Modulus: 10 % 3 = 1
  ** Exponentiation: 2 ** 3 = 8

  Comparison Operators

  == Equal to: 5 == 5 results in True
  != Not equal to: 4 != 3 results in True
  > Greater than: 10 > 5 results in True
  < Less than: 3 < 5 results in True
  >= Greater or equal to: 6 >= 6 results in True
  <= Less or equal to: 2 <= 5 results in True

  Logical Operators

  and Both conditions true: (x > 5 and x < 10) results in True
  or At least one condition true: (x > 5 or x < 2) results in True
  not Reverses the condition: not(x > 5) results in False

  Assignment Operators

  x = 5
  x += 3  # x = x + 3
  x -= 2  # x = x - 2
  x *= 4  # x = x * 4
  x /= 2  # x = x / 2

  Membership Operators

  fruits = ["apple", "banana", "cherry"]
  "apple" in fruits  # Returns True
  "grape" not in fruits  # Returns True

  Operator Precedence

  Python follows a specific order of operations which is similar to that in mathematics. This determines how expressions are evaluated.

  Fun Experiment

  Try combining different types of operators to see the effect:

  x = 10
  y = 3
  print(x + y)  # Addition
  print(x > y and x < 15)  # Logical
  print("apple" in ["apple", "orange"])  # Membership

  Key Points to Remember: Understanding different operators and their precedence is crucial for writing effective Python code.

• String Concatenation in Python

  String Concatenation in Python

  String concatenation is the process of joining two or more strings together. This is useful for creating meaningful sentences, combining user inputs, or formatting text.

  Why is String Concatenation Important?

  • It allows us to create dynamic messages and outputs.
  • It makes programs interactive by combining strings with variables.
  • It is useful for tasks like creating greetings, reports, and more.

  How to Concatenate Strings

  We can concatenate strings in Python using the + operator.

  greeting = "Hello"
  name = "Alice"
  message = greeting + " " + name
  print(message)

  Output: Hello Alice

  Adding Spaces While Concatenating

  If you want spaces between words, you need to add them manually as part of the string.

  word1 = "Python"
  word2 = "is fun"
  sentence = word1 + " " + word2
  print(sentence)

  Output: Python is fun

  Concatenating Strings and Variables

  We can mix strings with variables to create personalized outputs.

  name = "Bob"
  age = 12
  message = "Hi, my name is " + name + " and I am " + str(age) + " years old."
  print(message)

  Output: Hi, my name is Bob and I am 12 years old.

  Using f-strings for Concatenation

  An f-string is an easier way to concatenate strings and variables. Just add an f before the string and put variables inside curly braces {}.

  name = "Charlie"
  age = 15
  message = f"My name is {name} and I am {age} years old."
  print(message)

  Output: My name is Charlie and I am 15 years old.

  Using .format() for Concatenation

  Another way to concatenate strings is by using the .format() method.

  name = "Alice"
  age = 10
  message = "My name is {} and I am {} years old.".format(name, age)
  print(message)

  Output: My name is Alice and I am 10 years old.

  Combining Strings in a Loop

  You can use concatenation inside loops to build strings dynamically.

  words = ["Python", "is", "fun"]
  sentence = ""
  for word in words:
      sentence += word + " "
  print(sentence)

  Output: Python is fun

  Key Points to Remember

  • Use the + operator to join strings.
  • Always add spaces manually when needed.
  • Use f-strings or .format() for easier concatenation with variables.
  • Convert numbers to strings using str() before concatenating.

  Common Mistakes in String Concatenation

  • Forgetting to add spaces:

  print("Hello" + "World")  # Output: HelloWorld

  • Trying to concatenate a string and a number without converting:

  age = 10
  print("I am " + age)  # Error: TypeError
  print("I am " + str(age))  # Correct way

  Fun Experiment

  Try creating a dynamic greeting program:

  name = input("What is your name? ")
  hobby = input("What is your favorite hobby? ")
  print("Hi " + name + "! It's great to know that you love " + hobby + ".")

  Output (Example): What is your name? Alice
  What is your favorite hobby? painting
  Hi Alice! It's great to know that you love painting.

• Python Conditional Statements

  Python Conditional Statements

  Conditional statements in Python allow programs to respond differently based on conditions.

  Why Are Conditional Statements Important?

  • They make programs smart by allowing them to react to different situations.
  • They allow us to perform different actions based on user input or data.
  • They are used in games, quizzes, and real-world applications.

  Types of Conditional Statements in Python

  Python includes several types of conditional statements:

  • if Statement: Executes a block of code if a condition is true.
  • if-else Statement: Provides an alternative action if the condition is false.
  • if-elif-else Statement: Checks multiple conditions sequentially.

  Examples of Conditional Statements

  age = 15
  if age > 12:
  print("You are a teenager!")

  Output: You are a teenager!

  age = 10
  if age > 12:
      print("You are a teenager!")
  else:
      print("You are still a child!")

  Output: You are still a child!

  marks = 85
  if marks >= 90:
      print("You got an A!")
  elif marks >= 75:
      print("You got a B!")
  else:
      print("You need to work harder.")

  Output: You got a B!

  Nested if Statements

  Nested if statements check conditions within conditions.

  age = 18
  has_ticket = True
      if age >= 18:
  if has_ticket:
      print("You can enter the movie theater!")
  else:
      print("You need a ticket!")
  else:
      print("You're too young to watch this movie.")

  Output: You can enter the movie theater!

  Using input() with Conditional Statements

  We can use user input to make decisions.

  password = input("Enter the password: ")
  if password == "python123":
      print("Access granted!")
  else:
      print("Wrong password!")

  Fun Experiment

  Create a simple quiz using conditional statements:

  answer = input("What is the capital of Kenya? ")
  if answer.lower() == "nairobi":
      print("Correct!")
  else:
      print("Oops! The correct answer is Nairobi.")

  Key Points to Remember

  • Indentation is crucial in Python, especially for conditional statements.
  • Comparison and logical operators are often used in conditional expressions.
  • The first true condition stops further checks in if-elif-else structures.

• Python Loops

  Python Loops

  Loops in Python allow repetitive actions to be executed multiple times without rewriting the code.

  Why Are Loops Important?

  • They save time by automating repetitive tasks.
  • They make programs shorter and easier to read.
  • They are useful for working with data collections like lists and ranges.

  Types of Loops in Python

  Python supports several types of loops:

  • for Loop: Executes a block of code a specified number of times, or through a collection.
  • while Loop: Continues to execute as long as a condition is true.

  Example: Using a for Loop with a Range

  for i in range(1, 6):
  print(i)

  Outputs numbers from 1 to 5.

  Example: Looping Through a List

  fruits = ["apple", "banana", "cherry"]
  for fruit in fruits:
      print(fruit)

  Outputs each fruit in the list.

  Example: Using a while Loop for Counting

  count = 1
  while count <= 5:
      print(count)
      count += 1

  Counts from 1 to 5.

  Using break and continue in Loops

  break is used to exit a loop prematurely, while continue skips to the next iteration.

  Example: Breaking Out of a Loop

  for num in range(1, 10):
  if num == 5:
      break
  print(num)

  Prints numbers 1 to 4 and then stops.

  Example: Skipping a Loop Iteration

  for num in range(1, 6):
  if num == 3:
      continue
  print(num)

  Skips number 3 and prints 1, 2, 4, 5.

  Nested Loops

  Loops can be nested inside other loops to perform multi-level actions.

  for i in range(1, 4):
  for j in range(1, 4):
      print(f"i = {i}, j = {j}")

  Prints a combination of i and j values.

  Fun Experiment with Loops

  Create a countdown using a while loop.

  countdown = 5
  while countdown > 0:
      print(countdown)
      countdown -= 1
  print("Happy New Year!")

  Counts down from 5 and then celebrates.

  Key Points to Remember About Loops

  • Use for loops for known iteration counts.
  • Use while loops for conditions that need to be checked before each iteration.
  • Control loop execution with break and continue.
  • Always ensure proper indentation to define the scope of loops.
• Python Lists

  Python Lists

  A list in Python is a collection which is ordered and changeable. In Python, lists are written with square brackets.

  Why Are Lists Important?

  • They allow you to store multiple values in one place.
  • You can easily add, remove, or change items in a list.
  • Lists are useful for organizing data like names, scores, or shopping items.

  Creating a List

  Lists are created using square brackets:

  fruits = ["apple", "banana", "cherry"]
  print(fruits)

  Outputs: ['apple', 'banana', 'cherry']

  Accessing Items in a List

  You can access the list items by referring to the index number:

  print(fruits[0])  # Outputs 'apple'
  print(fruits[2])  # Outputs 'cherry'

  Changing Items in a List

  Change the value of a specific item by referring to its index number:

  fruits[1] = "blueberry"
  print(fruits)  # Outputs ['apple', 'blueberry', 'cherry']

  Adding Items to a List

  Add items to the end of the list using the append() method or at the specified index using the insert() method:

  fruits.append("orange")  # Adds 'orange' to the end
  fruits.insert(1, "mango")  # Inserts 'mango' at index 1
  print(fruits)  # Outputs ['apple', 'mango', 'blueberry', 'cherry', 'orange']

  Removing Items from a List

  Remove specified items using the remove() method or remove items by index using the pop() method or del keyword:

  fruits.remove("mango")  # Removes 'mango'
  print(fruits)  # Outputs ['apple', 'blueberry', 'cherry', 'orange']
                          
  fruits.pop(1)  # Removes item at index 1
  print(fruits)  # Outputs ['apple', 'cherry', 'orange']
                          
  del fruits[0]  # Deletes item at index 0
  print(fruits)  # Outputs ['cherry', 'orange']

  Looping Through a List

  Iterate over the items of the list using a for loop:

  for fruit in fruits:
  print(fruit)  # Outputs each fruit in the list

  Checking if an Item Exists

  Check if an item exists within a list using the in keyword:

  if "apple" in fruits:
  print("Apple is in the list!")  # Confirms that apple is in the list

  Length of a List

  Use the len() method to get the number of items in a list:

  print(len(fruits))  # Outputs the number of items in the list

  Sorting a List

  Sort the list items alphabetically in ascending or descending order using the sort() method:

  numbers = [4, 1, 3, 2]
  numbers.sort()  # Sorts the list in ascending order
  print(numbers)  # Outputs [1, 2, 3, 4]
                          
  numbers.sort(reverse=True)  # Sorts the list in descending order
  print(numbers)  # Outputs [4, 3, 2, 1]

  Merging Lists

  Combine or merge two lists by using the + operator or the extend() method:

  list1 = ["cat", "dog"]
  list2 = ["bird", "fish"]
  combined_list = list1 + list2
  print(combined_list)  # Outputs ['cat', 'dog', 'bird', 'fish']

  Fun Experiment

  Create a list of your favorite hobbies and print them using a loop:

  hobbies = ["reading", "drawing", "cycling"]
  for hobby in hobbies:
      print("I love " + hobby)  # Outputs each hobby in a friendly format

  Key Points to Remember

  • Lists are mutable, meaning you can change their content without changing their identity.
  • You can mix data types in lists. A list can contain strings, integers, and even other lists.
  • Lists are ordered, each item has an index starting from 0.
• Python Tuples

  Python Tuples

  A tuple in Python is a collection of items that cannot be changed (immutable). Tuples are written with round brackets and the items are separated by commas.

  Why Are Tuples Important?

  • They store data that shouldn't change, ensuring data integrity.
  • Tuples are faster than lists due to their immutability.
  • They can be used as keys in dictionaries, which is not possible with lists.

  Creating a Tuple

  Tuples are created using round brackets:

  fruits = ("apple", "banana", "cherry")
  print(fruits)

  Outputs: ('apple', 'banana', 'cherry')

  Accessing Items in a Tuple

  Items in a tuple can be accessed by their index, similar to lists:

  print(fruits[0])  # Outputs 'apple'
  print(fruits[2])  # Outputs 'cherry'

  Attempting to Change a Tuple

  Tuples are immutable, so trying to change them will result in an error:

  # This will raise an error
  fruits[1] = "blueberry"

  Looping Through a Tuple

  You can loop through a tuple using a for loop:

  colors = ("red", "blue", "green")
  for color in colors:
      print(color)

  Tuple Length

  The number of items in a tuple can be determined using the len() function:

  print(len(fruits))  # Outputs 3

  Combining Tuples

  Two or more tuples can be combined using the + operator:

  tuple1 = ("red", "blue")
  tuple2 = ("green", "yellow")
  combined_tuple = tuple1 + tuple2
  print(combined_tuple)

  Outputs: ('red', 'blue', 'green', 'yellow')

  Slicing Tuples

  Parts of a tuple can be accessed using slicing:

  numbers = (10, 20, 30, 40, 50)
  print(numbers[1:4])  # Outputs (20, 30, 40)

  Checking if an Item is in a Tuple

  Check if an item exists within a tuple using the in keyword:

  if "banana" in fruits:
  print("Banana is in the tuple!")

  Converting Tuples to Lists

  If you need to modify a tuple, you can convert it to a list:

  fruits_list = list(fruits)
  fruits_list.append("orange")
  fruits = tuple(fruits_list)
  print(fruits)

  Outputs: ('apple', 'banana', 'cherry', 'orange')

  Packing and Unpacking Tuples

  Tuples can be used to assign multiple values at once:

  person = ("Alice", 25, "Engineer")
  name, age, profession = person
  print(name)  # Outputs 'Alice'
  print(age)   # Outputs 25
  print(profession)  # Outputs 'Engineer'

  Fun Experiment

  Try creating a tuple with your favorite foods and print them:

  foods = ("pizza", "burger", "pasta")
  for food in foods:
      print("I love " + food)

  Key Points to Remember About Tuples

  • Tuples are immutable (cannot be changed after creation).
  • Items in a tuple can be accessed using their index.
  • Tuples use round brackets ( ).
  • Use tuples for data that should remain constant, like days of the week or fixed settings.
• Python Dictionaries

  Python Dictionaries

  Dictionaries in Python are collections of key-value pairs that function like a real-life dictionary, allowing you to quickly retrieve information by looking up a key.

  Creating a Dictionary

  Dictionaries are defined with curly braces {} with items stored as key-value pairs separated by colons.

  student = {
      "name": "Alice",
      "age": 12,
      "grade": "7th"
      }
  print(student)

  This outputs: {'name': 'Alice', 'age': 12, 'grade': '7th'}

  Accessing Values

  Access dictionary values by key using brackets [] or the .get() method.

  print(student["name"])  # Outputs 'Alice'
  print(student.get("age"))  # Outputs 12

  Adding or Updating Items

  Add or update dictionary items by assigning a value to a key.

  student["grade"] = "8th"  # Updates if exists, adds if not
  print(student)

  Removing Items

  Remove items using .pop(), del, or .clear().

  student.pop("age")  # Removes 'age'
  del student["grade"]  # Removes 'grade'
  student.clear()  # Empties dictionary

  Looping Through a Dictionary

  Iterate through keys, values, or both using loops.

  for key in student:
      print(key)  # Prints all keys
                          
  for value in student.values():
      print(value)  # Prints all values
                          
  for key, value in student.items():
      print(key, ":", value)  # Prints all key-value pairs

  Checking if Key Exists

  Check for the existence of a key using in.

  if "name" in student:
  print("Name is available!")

  Dictionary Methods

  Use methods like keys(), values(), and items() to interact with dictionaries.

  print(student.keys())  # Outputs all keys
  print(student.values())  # Outputs all values
  print(student.items())  # Outputs all items

  Nested Dictionaries

  Dictionaries can contain other dictionaries, allowing complex data structures.

  school = {
      "student1": {"name": "Alice", "age": 12},
      "student2": {"name": "Bob", "age": 14}
  }
  print(school["student1"]["name"])  # Outputs 'Alice'

  Fun Experiment

  Create and manipulate your own dictionary with hobbies, friends, or any other interests.

  hobbies = {
      "hobby1": "reading",
      "hobby2": "drawing"
  }
  for hobby, description in hobbies.items():
      print("I enjoy " + description)

  Key Points to Remember About Dictionaries

  • Dictionaries are mutable, allowing changes by adding, removing, or modifying entries.
  • They provide a fast means to retrieve data based on custom keys.
  • They are essential for representing real-world data in a structured format.

• Python Sets

  Python Sets

  Sets in Python are collections of unique items that are unordered and do not allow duplicates. They are ideal for storing distinct values and performing set operations like unions and intersections.

  Creating a Set

  Sets can be created using curly braces {} or the set() function. Here is how you can initialize a set:

  fruits = {"apple", "banana", "cherry"}
  print(fruits)

  numbers = set([1, 2, 3, 3, 4])  # Duplicates are removed
  print(numbers)

  Accessing Items

  While sets do not support indexing, you can loop through them or ask if a value exists:

  for fruit in fruits:
      print(fruit)

  Adding and Updating Items

  Use add() to add single items and update() for multiple items:

  fruits.add("orange")
  fruits.update(["mango", "grape"])
  print(fruits)

  Removing Items

  Items can be removed using remove(), discard(), and pop():

  fruits.remove("banana")
  fruits.discard("cherry")
  random_fruit = fruits.pop()
  fruits.clear()

  Set Operations

  Perform mathematical set operations like union, intersection, and difference:

  set1 = {1, 2, 3}
  set2 = {2, 3, 4}
  print(set1 | set2)  # Union
  print(set1 & set2)  # Intersection
  print(set1 - set2)  # Difference
  print(set1 ^ set2)  # Symmetric Difference

  Nested Sets

  While sets cannot contain other sets due to their unhashable nature, they can contain immutable versions called frozensets:

  nested_set = {frozenset({1, 2}), frozenset({3, 4})}
  print(nested_set)

  Fun Experiment

  Create sets of your favorite movies or books and use set operations to combine them with friends' favorites:

  my_favorites = {"Star Wars", "The Matrix"}
  friends_favorites = {"The Matrix", "Inception"}
  print(my_favorites | friends_favorites)  # Find all unique favorites

  Key Points to Remember

  • Sets are great for handling unique items and performing efficient set operations.
  • The items in a set are unordered, and they do not support indexing.
  • Sets are mutable, but they only allow immutable items.
• String Manipulation

  String Manipulation in Python

  String manipulation involves altering, formatting, and working with strings to achieve desired outputs, using Python's rich set of string handling capabilities.

  Why String Manipulation is Important:

  • It's crucial for cleaning and formatting text data efficiently.
  • Allows for dynamic text outputs and customizations like capitalization and formatting.
  • Essential for generating user-facing messages, reports, and dynamically generated content.

  Common String Methods:

  Method	Description	Example
  lower()	Converts a string to lowercase.	"HELLO".lower() results in "hello"
  upper()	Converts a string to uppercase.	"hello".upper() results in "HELLO"
  capitalize()	Capitalizes the first letter of the string.	"python".capitalize() results in "Python"
  strip()	Removes any leading/trailing whitespace from the string.	" hello ".strip() results in "hello"
  replace(old, new)	Replaces all occurrences of a substring.	"cats".replace("c", "b") results in "bats"
  split(delimiter)	Splits the string into a list based on the delimiter.	"a,b,c".split(",") results in ['a', 'b', 'c']
  join(list)	Joins the elements of a list into a single string with the string as the delimiter.	" ".join(['Hello', 'World']) results in "Hello World"

  Accessing and Slicing Strings:

  word = "Python"
  print(word[0])  # Output: 'P'
  print(word[-1])  # Output: 'n'
  print(word[0:2])  # Output: 'Py'
  print(word[:2])   # Output: 'Py'
  print(word[2:])   # Output: 'thon'

  Modifying String Case:

  text = "python is fun"
  print(text.upper())  # Output: 'PYTHON IS FUN'
  print(text.capitalize())  # Output: 'Python is fun'

  Replacing Text:

  text = "I like cats"
  new_text = text.replace("cats", "dogs")
  print(new_text)  # Output: 'I like dogs'

  Formatting Strings:

  name = "Alice"
  age = 12
  print(f"My name is {name}, and I am {age} years old.")  # Using f-string
  print("My name is {}, and I am {} years old.".format(name, age))  # Using .format()

  Fun Experiment:

  Try modifying a user's input and combining various string methods:

  name = input("What is your name? ").strip().capitalize()
  hobby = input("What is your favorite hobby? ")
  print(f"Hello, {name}! It's great to know that you enjoy {hobby.lower()}!")

• File Handling

  File Handling in Python

  File Handling in Python allows us to work with files, enabling operations like reading, writing, and creating new files.

  Opening a File:

  To open a file, we use the open() function with the filename and the mode (e.g., "r" for read, "w" for write).

  file = open("filename.txt", "r")
  content = file.read()
  print(content)
  file.close()

  Reading from a File:

  file = open("example.txt", "r")
  for line in file:
      print(line.strip())
  file.close()

  Writing to a File:

  file = open("example.txt", "w")
  file.write("Hello, this is written to a file!\n")
  file.close()

  Appending to a File:

  file = open("example.txt", "a")
  file.write("Adding this line to the end of the file.")
  file.close()

  Creating a New File:

  file = open("newfile.txt", "x")
  file.write("New file created!")
  file.close()

  Deleting a File:

  We use the os module to check if a file exists and delete it:

  import os
  if os.path.exists("example.txt"):
      os.remove("example.txt")
      print("File deleted!")
  else:
      print("The file does not exist.")

  Using with Statement for File Handling:

  The with statement simplifies file handling by automatically taking care of closing the file after its suite finishes:

  with open("example.txt", "r") as file:
  content = file.read()
  print(content)

  Fun Experiment:

  Create a simple program to take user input and write it to a file:

  with open("userdata.txt", "w") as file:
  name = input("Enter your name: ")
      hobby = input("Enter your hobby: ")
      file.write(f"Name: {name}, Hobby: {hobby}")
  print("Data saved to file!")

• Exception Handling

  Python Exception Handling

  Exception handling in Python allows us to deal with errors during the execution of a program. It helps prevent the program from crashing and allows for more graceful error handling.

  Basic Syntax of Exception Handling

  try:
      # Code that might raise an error
      risky_code
  except:
      # Code to handle the error
      handle_error

  Example 1: Handling Division by Zero

  try:
      result = 10 / 0
  except:
      print("Oops! You can't divide by zero.")

  Output: "Oops! You can't divide by zero."

  Example 2: Catching Specific Exceptions

  try:
      numbers = [1, 2, 3]
      print(numbers[5])
  except IndexError:
      print("Index out of range!")

  Output: "Index out of range!"

  Using else and finally

  The else block runs if no exceptions are raised, and the finally block runs regardless of what happens in the try and except.

  try:
      file = open("example.txt", "r")
      content = file.read()
  except FileNotFoundError:
      print("File not found!")
  finally:
      print("This block always runs.")

  Output: Depending on if the file exists, either "File not found!" or the file content, followed by "This block always runs."

  Finding and Handling Multiple Exceptions

  try:
      x = int("hello")  # Causes ValueError
      result = 10 / 0   # Causes ZeroDivisionError
  except ValueError:
      print("Invalid value!")
  except ZeroDivisionError:
      print("Cannot divide by zero!")

  Output: "Invalid value!"

  Fun Experiment

  Create a simple program that handles exceptions:

  try:
      number = int(input("Enter a number: "))
      print("You entered:", number)
  except ValueError:
      print("That's not a valid number!")

  These examples show how to manage different types of errors gracefully without letting the program crash unexpectedly.

• Classes and Objects

  Python Classes and Objects

  Classes and Objects are fundamental to understanding Object-Oriented Programming (OOP) in Python, allowing data and functions to be encapsulated into a single entity.

  What is a Class?

  A class is like a blueprint for creating objects, defining the properties and behaviors that the objects will have.

  class Car:
  def drive(self):
      print("The car is driving!")

  Creating an Object

  Objects are instances of a class, created from the class's blueprint.

  my_car = Car()
  my_car.drive()

  Output: "The car is driving!"

  The __init__ Method

  The __init__ method initializes new objects by setting initial values for the object's properties.

  class Car:
  def __init__(self, brand, color):
      self.brand = brand
      self.color = color
                          
  def describe(self):
      print(f"This car is a {self.color} {self.brand}.")
                          
  my_car = Car("Toyota", "red")
  my_car.describe()

  Output: "This car is a red Toyota."

  Accessing and Modifying Object Attributes

  Attributes of objects can be accessed and modified directly using the dot notation.

  my_car = Car("Honda", "blue")
  print(my_car.brand)  # Output: Honda
  my_car.color = "green"
  print(my_car.color)  # Output: green

  Methods

  Methods are functions defined within a class that describe the behaviors of the class's objects.

  class Dog:
  def __init__(self, name):
      self.name = name
                          
  def bark(self):
      print(f"{self.name} is barking!")
                          
  my_dog = Dog("Buddy")
  my_dog.bark()

  Output: "Buddy is barking!"

  Using self

  The self keyword is used in methods to refer to the object on which the method is being called.

  class Person:
  def __init__(self, name):
      self.name = name
                          
  def greet(self):
      print(f"Hello, my name is {self.name}.")

  Fun Experiment

  Create a class for your favorite animal and make it perform an action.

  class Animal:
  def __init__(self, name, sound):
      self.name = name
      self.sound = sound
                          
  def make_sound(self):
      print(f"The {self.name} goes {self.sound}!")
                          
  cat = Animal("cat", "meow")
  cat.make_sound()

  Output: "The cat goes meow!"

• Python Modules and Packages

  Modules and Packages

  Modules and packages help organize Python code into manageable parts, making it easier to maintain and reuse code across different projects.

  What is a Module?

  A module is a Python file containing functions, classes, or variables. Modules allow you to logically organize your Python code.

  # math_tools.py
  def add(a, b):
      return a + b
                          
  def subtract(a, b):
      return a - b

  Importing a Module

  Modules can be imported into other modules or scripts, enabling you to use functions or classes defined in them.

  import math_tools
  result = math_tools.add(5, 3)
  print(result)  # Output: 8

  Using Built-in Modules

  Python includes several built-in modules that provide useful functionalities like mathematical operations and random number generations.

  import math
  print(math.sqrt(16))  # Output: 4.0

  import random
  print(random.randint(1, 10))  # Random number between 1 and 10

  Importing Specific Functions

  You can choose to import specific attributes or functions from a module, which is useful when you only need a part of the module.

  from math import sqrt, pi
  print(sqrt(25))  # Output: 5.0
  print(pi)        # Output: 3.141592653589793

  What is a Package?

  A package is a directory of Python scripts, each of which is a module that can include functions, classes, and variables.

  Creating Your Own Package

  To create a package, make a directory and add an `__init__.py` file to it, then place your module files in the directory.

  from my_package.greetings import say_hello
  from my_package.math_tools import multiply
                          
  print(say_hello("Alice"))  # Output: Hello, Alice!
  print(multiply(3, 4))      # Output: 12

  Installing External Packages

  External packages can be installed and managed with `pip`, Python's package installer.

  pip install requests

  Fun Experiment

  Create a package that includes several modules to handle different tasks. For example, a package for handling various math operations like addition, subtraction, and multiplication.

• Python List Comprehensions

  List Comprehensions

  List comprehensions provide a concise way to create lists. They can simplify code that would otherwise use loops and conditionals.

  Basic Syntax of List Comprehensions

  new_list = [expression for item in iterable if condition]

  Creating a List with a For Loop

  Traditionally, you might use a loop to create a list by appending items one by one.

  numbers = [1, 2, 3, 4, 5]
  squares = []
  for num in numbers:
      squares.append(num ** 2)
  print(squares)  # Output: [1, 4, 9, 16, 25]

  Using a List Comprehension

  A list comprehension can achieve the same result with less code.

  numbers = [1, 2, 3, 4, 5]
  squares = [num ** 2 for num in numbers]
  print(squares)  # Output: [1, 4, 9, 16, 25]

  Adding a Condition to a List Comprehension

  You can add conditions to filter items.

  numbers = [1, 2, 3, 4, 5, 6]
  evens = [num for num in numbers if num % 2 == 0]
  print(evens)  # Output: [2, 4, 6]

  Using an if-else in a List Comprehension

  List comprehensions can also include an if-else condition to perform different operations based on the condition.

  numbers = [1, 2, 3, 4, 5]
  result = ["even" if num % 2 == 0 else "odd" for num in numbers]
  print(result)  # Output: ['odd', 'even', 'odd', 'even', 'odd']

  Working with Strings

  List comprehensions can be used to manipulate strings efficiently.

  words = ["hello", "world", "python"]
  uppercase_words = [word.upper() for word in words]
  print(uppercase_words)  # Output: ['HELLO', 'WORLD', 'PYTHON']

  Nested Loops in List Comprehensions

  You can incorporate multiple loops within a list comprehension for more complex operations.

  numbers = [1, 2, 3]
  pairs = [(x, y) for x in numbers for y in numbers]
  print(pairs)  # Output: [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

  Using range() in List Comprehensions

  You can also use `range()` to create lists that represent a sequence of numbers.

  squares = [x ** 2 for x in range(1, 6)]
  print(squares)  # Output: [1, 4, 9, 16, 25]

  Combining Conditions and Loops

  Conditions can be combined with loops for filtering and applying complex logic.

  numbers = range(1, 11)
  even_squares = [x ** 2 for x in numbers if x % 2 == 0]
  print(even_squares)  # Output: [4, 16, 36, 64, 100]

  Fun Experiment

  Experiment with list comprehensions by using them to transform a list of names or to create patterns.

  names = ["Alice", "Bob", "Alex", "Charlie"]
  a_names = [name.lower() for name in names if name.startswith("A")]
  print(a_names)  # Output: ['alice', 'alex']

• Python Lambda Functions

  Lambda Functions

  Lambda functions in Python are small, anonymous functions defined with the lambda keyword. They can have any number of arguments but only one expression.

  Basic Syntax of Lambda Functions

  lambda arguments: expression

  Here is an example of a simple lambda function that adds two numbers:

  add = lambda a, b: a + b
  print(add(3, 5))  # Output: 8

  Lambda functions are commonly used with other functions, especially with map(), filter(), and sort() to apply functions to sequences.

  Using Lambda Functions with map()

  numbers = [1, 2, 3, 4]
  squared = list(map(lambda x: x ** 2, numbers))
  print(squared)  # Output: [1, 4, 9, 16]

  Using Lambda Functions with filter()

  numbers = [1, 2, 3, 4, 5, 6]
  evens = list(filter(lambda x: x % 2 == 0, numbers))
  print(evens)  # Output: [2, 4, 6]

  Using Lambda Functions with sort()

  names = ["Alice", "Bob", "Charlie"]
  sorted_names = sorted(names, key=lambda name: len(name))
  print(sorted_names)  # Output: ['Bob', 'Alice', 'Charlie']

  Lambda functions can also have default arguments:

  add = lambda x, y=5: x + y
  print(add(3))     # Output: 8 (3 + 5)
  print(add(3, 7))  # Output: 10 (3 + 7)

  Here's a fun experiment to try combining lambda functions with map() and filter():

  numbers = [1, 2, 3, 4, 5, 6]
  squared_evens = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))
  print(squared_evens)  # Output: [4, 16, 36]

• Python Recursion

  Recursion

  Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem. It simplifies complex problems by dividing them into more manageable parts.

  Understanding the Basics

  A recursive function consists of two parts: a base case that ends the recursion, and a recursive case that calls the function itself.

  Example: Countdown Function

  def countdown(n):
  if n == 0:
      print("Blast off!")
  else:
      print(n)
      countdown(n - 1)
                          
  countdown(5)

  This function prints numbers starting from the given number down to zero. When it reaches zero, it prints "Blast off!"

  Recursion for Calculating Factorials

  def factorial(n):
  if n == 1:
      return 1
  else:
      return n * factorial(n - 1)
                          
  print(factorial(5))  # Output: 120

  The factorial of a number is the product of all positive integers up to that number. This example uses recursion to calculate the factorial of 5.

  Fibonacci Sequence

  def fibonacci(n):
  if n == 0:
      return 0
  elif n == 1:
      return 1
  else:
      return fibonacci(n - 1) + fibonacci(n - 2)
                          
  print(fibonacci(6))  # Output: 8

  The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones. This function calculates the nth Fibonacci number.

  Infinite Recursion Example

  def infinite():
  infinite()

  This is an example of infinite recursion, which will cause a crash or a 'RecursionError' due to the stack overflow.

  Fun Experiment: Sum of Numbers

  def sum_numbers(n):
  if n == 0:
      return 0
  else:
      return n + sum_numbers(n - 1)
                          
  print(sum_numbers(5))  # Output: 15

  This recursive function calculates the sum of all numbers from 1 to n. It's a great way to understand how recursion works by breaking down the addition process.

• Working with APIs in Python

  Introduction to APIs

  An API (Application Programming Interface) allows two applications to communicate with each other. For instance, fetching weather information for a specific location from a weather service.

  Why Use APIs?

  • Real-time data access from external servers, such as weather updates or social media feeds.
  • Automating tasks by integrating external services directly into applications.
  • Enhancing functionality without having to create complex infrastructures from scratch.

  Using the Requests Library

  The requests library is a versatile HTTP client for Python that simplifies working with HTTP requests.

  pip install requests

  Fetching Data from an API

  import requests
                          
  response = requests.get("https://api.github.com")
  print(response.status_code)  # Status code check
  print(response.json())  # Parsing JSON response
                          

  Most APIs return data in JSON format, which can easily be converted to Python data structures for manipulation.

  Query Parameters

  params = {
      "q": "search_query",
      "appid": "your_api_key"
  }
  response = requests.get("https://api.example.com/search", params=params)
  data = response.json()
  print(data)
                          

  Error Handling

  response = requests.get("https://api.example.com/data")
  if response.status_code == 200:
      print("Success!")
  else:
      print("Error occurred: ", response.status_code)
                          

  POST Requests

  data = {"key": "value"}
  response = requests.post("https://api.example.com/submit", json=data)
  print(response.text)
                          

  API Authentication

  Some APIs require authentication using tokens or API keys, which should be included in request headers.

  headers = {
      "Authorization": "Bearer your_api_key"
  }
      response = requests.get("https://api.example.com/protected", headers=headers)
      print(response.json())
                          

  Practical Example: Consuming a Weather API

  Combine knowledge of GET requests, query parameters, and JSON handling to fetch and display weather data.

  api_url = "https://api.openweathermap.org/data/2.5/weather"
  params = {
      "q": "London",
      "appid": "your_api_key"
  }
  response = requests.get(api_url, params=params)
  weather = response.json()
  print("Weather in London: ", weather["main"]["temp"])
                          

  Fun Experiment

  Create a simple application that fetches daily quotes from an API and displays them.

  response = requests.get("https://api.quotable.com/random")
  quote = response.json()
  print(quote["content"])
                          

• Basic Data Visualization in Python

  Introduction to Data Visualization

  Data visualization involves creating visual representations of data to make it easier to understand and interpret. It's a powerful way to communicate information clearly and effectively.

  Why is Data Visualization Important?

  • Simplifies complex data into easily understandable visuals.
  • Helps identify trends, patterns, and outliers in data.
  • Essential for data-driven decision making in business, science, and technology.

  Getting Started with Matplotlib

  Matplotlib is a popular Python library for creating static, interactive, and animated visualizations in Python.

  pip install matplotlib

  Creating Your First Plot

  Here's how to create a simple line plot showing a linear relationship:

  import matplotlib.pyplot as plt
                          
  x = [1, 2, 3, 4, 5]
  y = [2, 3, 5, 7, 11]
                          
  plt.plot(x, y)
  plt.title("Simple Line Plot")
  plt.xlabel("X Axis")
  plt.ylabel("Y Axis")
  plt.show()
                          

  Plotting a Bar Chart

  Bar charts are great for comparing categorical data:

  categories = ['Red', 'Blue', 'Green', 'Purple']
  values = [50, 80, 60, 90]
                          
  plt.bar(categories, values)
  plt.title("Bar Chart Example")
  plt.xlabel("Colors")
  plt.ylabel("Values")
  plt.show()
                          

  Creating a Pie Chart

  Pie charts show parts of a whole as slices:

  labels = ['Apples', 'Bananas', 'Cherries', 'Dates']
  sizes = [15, 30, 45, 10]
                          
  plt.pie(sizes, labels=labels, autopct='%1.1f%%')
  plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
  plt.show()
                          

  Generating a Histogram

  Histograms help visualize the distributions of data points:

  data = [1, 2, 2, 3, 3, 3, 3, 4, 4, 5]
  plt.hist(data, bins=5)
  plt.title("Histogram")
  plt.show()
                          

  Customizing Graphs

  You can customize the look of your plots with different colors, markers, and line styles:

  plt.plot(x, y, marker='o', color='red', linestyle='--')
  plt.title("Customized Line Plot")
  plt.xlabel("X Axis")
  plt.ylabel("Y Axis")
  plt.grid(True)
  plt.show()
                          

  Fun Experiment

  Try creating a scatter plot to explore the relationship between two variables:

  x = [5, 2, 9, 4, 7]
  y = [10, 5, 8, 4, 2]
                          
  plt.scatter(x, y)
  plt.title("Scatter Plot Example")
  plt.xlabel("Independent Variable")
  plt.ylabel("Dependent Variable")
  plt.show()
                          

• Python Projects - Bringing It All Together

  Python Projects Overview

  Python projects help apply various concepts learned throughout Python tutorials, combining loops, conditionals, functions, and APIs to solve real-world problems and create functional applications.

  Why Build Projects?

  • Projects enhance your problem-solving skills by applying theoretical knowledge.
  • They illustrate the integration of different Python features in practical scenarios.
  • Projects prepare you for real-world programming challenges.

  Project 1: Quiz Game

  def quiz():
  questions = {
      "What is the capital of Kenya?": "Nairobi",
      "What is 2 + 2?": "4",
      "Who wrote 'Harry Potter'?": "J.K. Rowling"
  }
  score = 0
  for question, answer in questions.items():
      user_answer = input(question + " ")
      if user_answer.lower() == answer.lower():
          print("Correct!")
          score += 1
      else:
          print(f"Wrong! The correct answer is {answer}.")
      print(f"You got {score}/{len(questions)} questions right!")
  quiz()

  Project 2: Calculator

  def calculator():
  print("Simple Calculator")
  print("Choose an operation: +, -, *, /")
  operation = input("Enter operation: ")
  num1 = float(input("Enter the first number: "))
  num2 = float(input("Enter the second number: "))
  if operation == "+":
      print(f"The result is: {num1 + num2}")
  elif operation == "-":
      print(f"The result is: {num1 - num2}")
  elif operation == "*":
      print(f"The result is: {num1 * num2}")
  elif operation == "/":
      if num2 != 0:
          print(f"The result is: {num1 / num2}")
       else:
              print("Error! Division by zero.")
      else:
              print("Invalid operation.")
      calculator()

  Project 3: Number Guessing Game

  import random
  def number_guessing_game():
      number = random.randint(1, 100)
      print("Guess the number between 1 and 100!")
      while True:
          guess = int(input("Enter your guess: "))
          if guess < number:
              print("Too low!")
          elif guess > number:
              print("Too high!")
          else:
              print("Congratulations! You guessed the number!")
              break
          number_guessing_game()

  Project 4: To-Do List

  def to_do_list():
  tasks = []
  while True:
      print("\nTo-Do List:")
      for i, task in enumerate(tasks, start=1):
          print(f"{i}. {task}")
      print("\nOptions: 1. Add Task  2. Remove Task  3. Exit")
      choice = input("Choose an option: ")
      if choice == "1":
          task = input("Enter a new task: ")
          tasks.append(task)
      elif choice == "2":
          task_number = int(input("Enter the task number to remove: "))
          if 0 < task_number <= len(tasks):
              tasks.pop(task_number - 1)
          else:
                  print("Invalid task number.")
          elif choice == "3":
                  print("Goodbye!")
                  break
          else:
                  print("Invalid choice. Please try again.")
          to_do_list()

  Project 5: Weather App

  import requests
  def weather_app():
          api_key = "your_api_key"  # Replace with your API key
          city = input("Enter the city name: ")
          url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
          response = requests.get(url)
          if response.status_code == 200:
              data = response.json()
              print(f"City: {data['name']}")
              print(f"Temperature: {data['main']['temp']}°C")
              print(f"Weather: {data['weather'][0]['description']}")
          else:
              print("City not found. Please try again.")
      weather_app()