# Introduction to Keras

`Keras` is a user-friendly library for building and training **deep learning models**. With Keras, you can easily create various AI models without needing an in-depth understanding of the complex technical details of machine learning.

Keras can be used alongside AI frameworks like `TensorFlow`, and as of TensorFlow `v2.0`, Keras is built into TensorFlow.

<br/>

## What can you do with Keras?

Using Keras, you can build various machine learning models, such as:

1. *Image recognition* (e.g., recognizing handwritten digits)
2. *Text processing* (e.g., predicting the next word in a sentence)
3. *Speech and sound analysis* (e.g., recognizing spoken words)
4. *Recommendation systems* (e.g., suggesting products or movies)

<br/>

## How does the number recognition in the practice screen work?

The AI model understands a user’s handwritten numbers through the following process:

1. *Input data*: The computer views handwritten digit images. Each image is divided into pixels (small dots that make up the picture).
2. *Model training*: Keras teaches the computer to recognize patterns in numbers. For example, the model learns that the number “3” often has a curved shape.
3. *Model testing*: Once trained, the model attempts to predict numbers from new images it has never seen before.
4. *Output*: The model provides its best prediction for each number.

Try drawing a number between 0 and 9 in the square box on the practice screen to see how the AI model trained with Keras recognizes it. :)

### What is the most appropriate word for the blank?

# Building a Machine Learning Model for Spam Email Classification

In this lesson, we’ll create a machine learning model that classifies an email as `spam or normal` based on its content.

Run each code cell by pressing `Shift + Enter` to train your machine learning model and predict the spam status of new emails.

The process of creating the machine learning model consists of the following steps:

<br />

## 1. Preparing the Data

We'll start by loading a simple dataset of 10 emails in CSV format as strings.

> `CSV` stands for Comma-Separated Values, a file format where data is stored separated by commas.

<br />

CSV files are commonly used in data analysis and machine learning because they store tabular data in a simple, readable format that can be opened in tools such as Excel.

```python title="Example of a CSV file"
email_text,label
"Free money now!!! Click here",spam
"Limited offer just for you",spam
"Meeting schedule attached",normal
"Please review the project proposal",normal
"Win a free iPhone by answering this",spam
"Lunch meeting confirmed for tomorrow",normal
"Urgent: Your account has been suspended",spam
```

Each email is represented in the `email_text` column, and its classification — either `spam` or `normal` — is shown in the `label` column.

<br />

## 2. Text Vectorization (TF-IDF)

Machine learning models cannot directly understand text data, so we need a process to **convert sentences into numbers**.

Here, we use `TF-IDF` vectorization. This method transforms the text into numerical features by evaluating the **importance of each word**, based on how often it appears in a document and how rare it is across the dataset.

<br />

## 3. Model Training and Evaluation

Now, we will train our machine learning model with the vectorized data.

We will use the `Multinomial Naive Bayes` algorithm, which is well-suited for text classification tasks.

<br />

## 4. Predictions for New Emails

Finally, we will use the trained model to predict whether a new email is spam or not.

<br />

With just simple data and code, machine learning models can be used to automatically `classify text`. In the next lesson, we will learn about essential Python libraries necessary for studying machine learning and deep learning.

# Real-time Object Detection Using TensorFlow.js

This lesson guides you through creating a real-time object detection application using `TensorFlow.js` and the `COCO-SSD` model. The lesson on the right detects objects in real time using a **webcam**, labels them, and displays the results directly in the browser.

Since the lesson utilizes the `camera` of a smart device (e.g., a laptop webcam or a smartphone front camera) for object recognition, the relevant functionality must be enabled for the lesson to proceed smoothly.

If you are using a desktop without a webcam, you may find it difficult to follow along. We recommend using a `tablet` or `laptop` instead.

<br/>

## What is TensorFlow.js?

`TensorFlow.js` is a **JavaScript library** designed to run and train machine learning (ML) models in both browser and Node.js environments.

It is based on Google’s TensorFlow and enables web applications to run deep learning models directly or convert existing models for use.

Since TensorFlow.js runs in the browser, it requires no additional setup and leverages WebGL for GPU-accelerated computations, ensuring fast processing.

Thanks to these features, it is widely used in fields such as image recognition, natural language processing (NLP), and biometric signal analysis.

<br/>

## What AI model is used?

The AI model used for object detection is `COCO-SSD`.

COCO-SSD is a **pre-trained** machine learning model for **object detection**, trained on the `COCO` (Common Objects in Context) dataset. It utilizes the `SSD` (Single Shot Multibox Detector) architecture to perform real-time object detection.

The COCO dataset contains `80 object classes`, including people, cars, bicycles, dogs, and laptops. Compared to other deep learning-based object detection models like YOLO and Faster R-CNN, COCO-SSD is lighter and requires fewer computations, making it suitable for execution in the browser.

### What is the most suitable word for the blank?

# What is Natural Language Processing?

Humans use language to express thoughts and communicate with others. However, can computers process and respond to human language in a meaningful way?

`Natural Language Processing` (NLP) is an AI technology that enables computers to understand and utilize human language.

Natural Language Processing involves converting human language into a structured format that computers can interpret and then analyzing its meaning.

In this lesson, we will explore the concept of Natural Language Processing and its key applications.

<br/>

## What are the steps in Natural Language Processing?

Natural Language Processing involves converting sentences into a **form that computers can understand** and analyzing their meaning.

Since computers cannot directly comprehend human language, NLP technology processes sentences through the following stages.

<br/>

### 1. Preprocessing

This is the process of removing unnecessary parts from a sentence and extracting essential information.

For example, preprocessing may involve removing punctuation or eliminating stop words — commonly used words such as “the” or “is” that carry little semantic value and do not contribute significantly to the meaning of a sentence.

```plaintext title="Preprocessing Example"
text = "Hello! Wow, the weather is really nice today."
preprocessed_text = "Hello the weather really nice today"
```

<br/>

### 2. Morphological Analysis

Morphological analysis involves splitting sentences into words and identifying the part of speech (noun, verb, etc.) for each word.

For example, the sentence "I like apples" is divided into `"I/pronoun"`, `"like/verb"`, `"apples/noun"`.

<br/>

### 3. Vectorization

This is the process of converting the words separated through morphological analysis into numerical forms that computers can understand.

By representing words as vectors, which are numerical arrays, computers can begin to interpret the patterns and relationships within textual data.

For example, the word "apple" can be represented as the vector `[0.1, 0.2, 0.3]`.

<br/>

## Key Applications of Natural Language Processing

The following are key applications of NLP technology:

<br/>

### 1. Machine Translation

Machine translation is a technology that uses AI to translate one language into another.

`Google Translate` and similar services are widely used examples, and the quality of translations improves as the model is trained on larger datasets.

<br/>

### 2. Sentiment Analysis

Sentiment analysis is a technology that extracts emotions from a sentence.

It is used by companies to classify customer feedback as positive or negative, and is also applied in trend prediction through the analysis of social media data.

```plaintext title="Sentiment Analysis Example"
text = "This movie is really fun!"
sentiment = "Positive"
```
<br />

### 3. Chatbots

Chatbots are conversational AIs that communicate naturally with people.

Chatbot services such as `ChatGPT`, `Perplexity`, and `Claude` are widely used in customer service, reservation systems, and automated information delivery.

<br />

### 4. Speech Recognition

Speech recognition is the technology that converts spoken language into text.

It is used in voice assistants like `Siri` and `Google Assistant`.

This technology is also employed in transcription services that convert meeting recordings into written text automatically.

---

<br />

Natural Language Processing is utilized in various AI fields and is expected to further develop as a technology aiding communication between humans and computers.

On the practice screen, input the same prompt into different AI chatbots and compare their responses to observe how each model interprets natural language.

# Real-Time Face Tracking with AI and Augmented Reality (AR)

In this lesson, we will use **MindAR** and **A-Frame** to track faces in real time and experience virtual try-ons with Augmented Reality (AR).

Since this lesson utilizes the `camera` of a smart device (e.g., a laptop webcam or a smartphone front camera) to recognize faces, you need to enable the necessary camera permissions for the lesson to proceed.

If you are using a desktop without a webcam, you may have difficulty following along. We recommend using a `tablet` or `laptop` instead.

The `MindAR` library used in this lesson is a web-based Augmented Reality (AR) library that enables AR experiences directly in the browser using JavaScript and WebAR technology.

For more details, please refer to the <a href='https://hiukim.github.io/mind-ar-js-doc/' target='_blank'>official MindAR documentation</a>.

Now, let’s explore how AI detects faces in real time and applies AR effects. :)

---

## 1. Face Detection
The system uses `AI-powered facial landmark detection` provided by MindAR.

`Landmarks` refer to **key points** on the face, such as the tip of the nose or the centers of both eyes. MindAR leverages a lightweight machine learning model to detect facial landmarks, including the eyes, nose, and mouth, using webcam input.

These landmarks act as `anchor points`, allowing AR objects to stay aligned with the user's face in real time, even as they move.

---

## 2. Applying Augmented Reality Content
Once facial landmarks are detected, 3D models are aligned to these anchors.

Even as the user moves their face, the 3D model remains positioned naturally by following these anchor points.

To render AR content, we use `A-Frame`.

A-Frame is an open-source framework based on WebVR (WebXR) and WebGL, making it easy to create 3D content using HTML.

MindAR integrates with A-Frame to implement both marker-based AR and face-tracking AR directly in HTML.

For more information about A-Frame, please visit the <a href='https://aframe.io/' target='_blank'>official documentation</a>.

# Coding Quiz

The first coding quiz involves writing a function that **outputs 10 times the given number**.

This is a simple program that takes one integer input from the user, calculates 10 times that number, and outputs the result.

```python title="Output 10 Times the Given Number"
def solution(number):
    return # Write your code here
```

<br />

## Hint

- `def` is a keyword used to define a function, which is a block of code that performs a specific task.

- `return` is a keyword used to return the result of a function. The value following `return` will be the function's output.

- To return 10 times the given number (`number`), write an expression that multiplies `number` by 10 next to `return`. In Python, multiplication is performed using the `*` operator.

Based on what you've learned so far, write a function that outputs 10 times the input number and check if it passes the tests.

Click the `Sample Answer` button in the bottom-right corner to see an example of how to write the function.

<br />

---

<br />

## _Input and Output Examples_

1.

- Input: `16`

- Output: `160`

2.

- Input: `3`

- Output: `30`

# Importing requests and BeautifulSoup libraries
import requests
from bs4 import BeautifulSoup

# Wikipedia homepage URL
url = "https://www.wikipedia.org"

# Fetch HTML from the URL using the requests library
response = requests.get(url)

# Set the encoding of the fetched HTML to UTF-8
response.encoding = 'utf-8'

# Process the fetched HTML using BeautifulSoup and store it in the soup variable
soup = BeautifulSoup(response.text, 'html.parser')

# Extract h1 (heading 1, title) from the webpage
h1_title = soup.find('h1').text

# Extract p (paragraph) tag from the webpage
p_description = soup.find('p').text

print('Title:')
print(h1_title) # Print the title

print('-' * 10) # Separator line

print('Description:')
print(p_description) # Print the description

# Fetching Wikipedia Homepage Information with Python

Wikipedia is an online encyclopedia collaboratively built by people around the world. 📘

In this lesson, we'll use Python code to collect specific information from a Wikipedia page.

Using the `BeautifulSoup` and `requests` libraries, we can fetch the title and description of the Wikipedia homepage, as shown below.

<br />

## Step 1: Import Required Libraries

```python title="Importing requests and BeautifulSoup Libraries"
import requests
from bs4 import BeautifulSoup
```

The above code performs the following tasks:

- Uses the `import` keyword to load the **requests** library for HTTP communication

- Uses the `from` keyword to load the **bs4** package for collecting webpage data and imports the **BeautifulSoup** class from it

<br />

## Step 2: Fetch HTML from URL and Store It in a Variable

Use **BeautifulSoup** to fetch and store the HTML of a webpage in a variable, as shown below:

```python title="Fetching HTML from Wikipedia Homepage"
# Wikipedia homepage URL
url = "https://www.wikipedia.org"

# Fetch HTML from the URL using the requests library
response = requests.get(url)

# Set the encoding of the fetched HTML to UTF-8
response.encoding = 'utf-8'

# Store the fetched HTML in the soup variable
soup = BeautifulSoup(response.text, 'html.parser')
```

The above code performs the following tasks:

- Stores the Wikipedia homepage URL in the `url` variable

- Fetches HTML from the URL using `requests.get(url)`

- Parses the fetched HTML using `BeautifulSoup(response.text, 'html.parser')` and stores the parsed result in the **soup** variable

<br />

## Step 3: Extract Title and Description Information

Extract the desired information from the **soup** variable as shown below:

```python title="Extracting Title and Description from Wikipedia Homepage"
# Extract h1 (heading 1, title) from the webpage
h1_title = soup.find('h1').text

# Extract p (paragraph) tag from the webpage
p_description = soup.find('p').text
```

The above code performs the following tasks:

- Uses `soup.find('h1').text` to find the **h1** tag in the **soup** variable, extracts the title, and stores it in the **h1_title** variable

- Uses `soup.find('p').text` to find the **p** tag in the **soup** variable, extracts the description, and stores it in the **p_description** variable

Finally, use the print function to display the title and description fetched from the URL.

<br />

## Practice

Click the _`Run Code`_ button on the right-hand side to see the scraping results.
The first execution of the code may take some time.

You can also modify the `url` address in the code (e.g., `https://www.codefriends.net`) to fetch information from other webpages.

BeautifulSoup is a Python library used to extract data from HTML and XML files. It is very useful for parsing HTML and extracting necessary information during web scraping tasks.

# String Case Conversion - Solutions

Explore three methods to solve the problem of converting string cases.

<br />

```python title="Method 1"
def solution(s):
    result = ""
    for i in range(len(s)): # Loop through the string length
        if i % 2 == 0: # Convert even-indexed characters to lowercase
            result += s[i].lower()
        else: # Convert odd-indexed characters to uppercase
            result += s[i].upper()
    return result
```

Using this method, you can convert even-indexed characters in the input string `s` to lowercase and odd-indexed characters to uppercase, then return the result.

<br />

## Example Usage

```python title="Input and Output Example"
input_string = "CoDeFrIeNds"

result = solution(input_string)
print(result)  # Output: "cOdEfRiEnDs"
```

### What Python function best fills the blank below?

import pandas as pd
from docx import Document

# Example of monthly sales data
data = {
    'Month': ['January', 'January', 'January', 'February', 'February', 'February', 'March', 'March', 'March'],
    'Product': ['Camera', 'Computer', 'Smartphone', 'Camera', 'Computer', 'Smartphone', 'Camera', 'Computer', 'Smartphone'],
    'Quantity Sold': [50, 30, 100, 45, 35, 90, 40, 40, 95],
}

unit_prices = {
    'Camera': 300,
    'Computer': 1000,
    'Smartphone': 800,
}

# 2. Create a DataFrame
df = pd.DataFrame(data)

# 3. Add unit price
df['Unit Price'] = df['Product'].map(unit_prices)

# 4. Calculate revenue (Quantity Sold * Unit Price)
df['Revenue'] = df['Quantity Sold'] * df['Unit Price']

# 5. Create a Document object
doc = Document()

# 6. Add a title to the document
doc.add_heading('Monthly Product Revenue Report', level=1)

# 7. Create a table (number of columns matches the DataFrame)
table = doc.add_table(rows=1, cols=len(df.columns))

# 8. Set table style with borders
table.style = 'Table Grid'

# 9. Add headers to the first row of the table
hdr_cells = table.rows[0].cells

# 10. Use a loop to add column names to the first row
for i, column in enumerate(df.columns):
    hdr_cells[i].text = column

# 11. Use a loop to add rows from the DataFrame to the table
for index, row in df.iterrows():
    row_cells = table.add_row().cells
    
    row_cells[0].text = str(row['Month'])
    row_cells[1].text = str(row['Product'])
    row_cells[2].text = str(row['Quantity Sold'])
    row_cells[3].text = f"{row['Unit Price']:,}"  # Add commas to integers
    row_cells[4].text = f"{row['Revenue']:,}"  # Add commas to calculated revenue

# 12. Save the document
doc.save('output_file.docx')

# How to Create Tables with Python Code

For simple tables, it’s faster to manually create them using the **Table** feature in a word processor.

However, if you need to insert large datasets into tables or automate repetitive table creation, it’s better to use the `python-docx` library.

In this lesson, we’ll explore the main methods for adding tables to Word documents using python-docx.

> *Note*: For convenience, the data visualized as tables is defined as Python lists. In practice, it is common to use the `pandas` library to load `CSV` files from URLs.

<br />

## add_table()

This method adds a new table to the document.

It is used as `document.add_table(rows, cols)` where `rows` specifies the number of rows (horizontal) and `cols` specifies the number of columns (vertical).

```python title="Adding a Table"
from docx import Document

doc = Document()
table = doc.add_table(rows=3, cols=3)
```

<br />

## table.cell(row, col)

This method accesses a specific cell to set or retrieve its value.

It is used as `table.cell(row, col)` where `row` is the row number (starting at 0) and `col` is the column number (starting at 0).

```python title="Adding Text to a Cell"
cell = table.cell(0, 0)  # First row, first column
cell.text = "Hello, World!"
```

<br />

### table.style

This property sets the style of the table.

To create a table with borders, use `table.style = 'Table Grid'`.

```python title="Setting Table Style"
doc = Document()
table = doc.add_table(rows=3, cols=3)

table.style = 'Table Grid'  # Use a predefined style in Word
```

<br />

## table.add_row()

This method adds a new row (horizontal line) to the table.

Use `table.add_row()` to add a new row.

```python title="Adding a New Row"
row = table.add_row()
row.cells[0].text = "New Cell"
```

<br />

## table.add_column()

This method adds a new column (vertical line) to the table.

Use `table.add_column(width)` to add a new column with a specified width.

```python title="Adding a New Column"
from docx.shared import Inches

table.add_column(Inches(1))
```

<br />

### cell.text

This property is used to set or retrieve text in a cell.

```python title="Adding Text to a Cell"
cell = table.cell(1, 1)
cell.text = "Sample Text"
```

<br />

### cell.merge(other_cell)

This method merges cells.

The following code demonstrates merging two cells in the first row.

```python title="Merging Cells"
a = table.cell(0, 0)
b = table.cell(0, 1)
a.merge(b)  # Merge two cells in the first row
```

The method to add a horizontal row to a table is table.add_row().

# Getting Started with Fine-Tuning

When you click the `Run Fine-Tuning` button in the practice environment, fine-tuning begins based on the uploaded training data and the configured hyperparameters.

![thumbnail-600](https://academy.codefriends.net/assets/ai/fine-tuning/application/run-fine-tuning-demo.png)

Once fine-tuning is complete, you can interact with the tuned model (e.g., a middle-aged woman speaking in the Gyeongsang dialect) on the right side of the practice environment.

> Note: As mentioned in previous lessons, due to policy and technical constraints, the fine-tuning model used in the practice environment is a pre-tuned model by CodeFriends.

<br />

## What Happens During Training?

As fine-tuning progresses, the weights and biases of the AI model are updated based on the configured hyperparameters.

- *Weights*: Determine how important specific features of the input data are.

- *Bias*: Adjusts the output of the model to ensure it doesn't lean too heavily in one direction, controlling the activation function of the neural network.

<br />

You can think of weights and biases using the following analogy:

- *Weights* are like adjusting the amount of ingredients in bread. For instance, controlling the amount of sugar to adjust the sweetness.

- *Bias* is like setting the base level of sweetness by deciding how much sugar to add as a default.

- *The training process* is like tasting the bread periodically and tweaking the ingredient amounts to find the optimal flavor.

<br />

## The Fine-Tuning Process

### 1. Initialization

When AI model training begins, weights and biases are initialized randomly.

In fine-tuning, the weights and biases from a pre-trained model are used as initial values.

<br />

### 2. Forward Propagation

Input data passes through the model. Each input value is multiplied by the weights, and the bias is added to calculate the output.

For example, in `y = wx + b`, `y` is the output, `w` is the weight, `x` is the input, and `b` is the bias.

<br />

### 3. Loss Calculation

The difference between the model's prediction (output) and the actual value (ground truth) is calculated to determine the loss. The loss indicates how inaccurate the model's predictions are.

For example, if the prediction is 5 and the actual value is 3, the loss is the difference between them. (e.g., using the mean squared error function, (5-3)^2 = 4)

<br />

### 4. Backpropagation

The model adjusts the weights and biases to minimize the loss.

To achieve this, it calculates how much each weight and bias contributes to the loss. This process uses differentiation to compute gradients.

<br />

### 5. Updating Weights and Biases

Using the calculated gradients, the weights and biases are updated. This adjustment is made in the direction that reduces the loss.

Weights and biases are always initialized randomly during the fine-tuning process.

// Defining the sayHello function
function sayHello() {
  console.log('Hello');
  console.log('Nice to meet you');
}

// Calling the function
// Outputs 'Hello' and 'Nice to meet you' line by line
sayHello();

// Function expression
const greet = function (name) {
  console.log('Hello, ' + name + '!');
};

// Calling the function
greet('???');

// Function to return the sum of two numbers
function add(a, b) {
  return a + b;
}

// Calling the function
const result = add(10, 20); // 30
console.log('result: ' + result);

# Functions: Code Blocks for Specific Tasks

A function is a **reusable block of code** that performs a specific task.

To create a function, you group one or more lines of code within curly braces `{ }`, forming a `block`, and give it a name.

```javascript title="Function Definition Example"
function sayHello() {
  console.log('Hello');
  console.log('Nice to meet you');
}
```

The above function is named `sayHello` to represent its purpose: printing the messages 'Hello' and 'Nice to meet you'.

Two `console.log` statements are written inside the function, and the `{ }` curly braces form a single block.

When the function is called, the code inside the function runs, printing the messages 'Hello' and 'Nice to meet you' line by line.

```javascript title="Calling the Function"
sayHello(); // Outputs 'Hello' and 'Nice to meet you'
```

<br />

## Why Use Functions?

The primary purpose of a function is to improve code **reusability**.

Once a function is defined, it can be called multiple times using its name. This reduces code duplication and improves maintainability.

<br />

## How to Declare a Function

In JavaScript, you define a function using the `function` keyword, followed by the function name and parameters.

```javascript title="Defining the add Function"
function add(a, b) {
  return a + b;
}
```

Here, `add` is the function's name, and `a` and `b` are its parameters.

Inside the curly braces `{ }`, you write the code the function will execute. The `return` keyword is used to return the result of the function.

<br />

### How to Call a Function

Calling a function means executing the code inside it.

You call a function by writing its name followed by parentheses `()`.

```javascript title="Calling the add Function"
const result = add(10, 20); // 30
```

In the above code, `add(10, 20)` calls the `add` function, passing 10 and 20 as arguments.

When the function is called, the parameters `a` and `b` receive the values 10 and 20, and the function executes.

The `return a + b` line inside the function calculates 30 and returns it.

The returned value, 30, is stored in the constant `result`.

<br />

## What’s the Difference Between Parameters and Arguments?

- **Parameters** are variables defined in the function declaration and used inside the function.
- **Arguments** are the actual values passed to the function when it is called.

```javascript title="multiply Function Example"
function multiply(a, b) {
  return a * b;
}

const result = multiply(2, 3); // 6
```

For example, in the `multiply` function, `a` and `b` are parameters, while 2 and 3 are the arguments passed when the function is called.

A function is a `reusable block of code` that performs a specific task. Once defined, a function can be called multiple times, reducing code duplication and improving maintainability.

### What is the most appropriate word to fill in the blank?

# Machine Learning Terms for AI Beginners

Before diving into fine-tuning, let’s review some key terms in AI and understand what `Machine Learning` is, which you might have heard of at least once.

<br />

## What is Artificial Intelligence?

`Artificial Intelligence` (AI) is the implementation of human-like learning, reasoning, and problem-solving abilities in computer programs to mimic intelligent human behavior.

AI is divided into various fields, such as **Natural Language Processing (NLP)**, which enables machines to understand and interact using human language, and **Computer Vision**, which processes and interprets visual data like images.

For AI to analyze patterns in the input data and generate appropriate responses, a learning process is required. The most widely used method for this is `Machine Learning`.

<br />

## What is Machine Learning?

Machine Learning refers to the process of **analyzing data**, **learning patterns from it**, and building models that can make **predictions or decisions** on new data.

It primarily consists of methods like `Supervised Learning`, `Unsupervised Learning`, and `Reinforcement Learning`.

<br />

### Supervised Learning

Supervised Learning is a learning method where **input data is accompanied by corresponding answers (labels)**. AI models are trained using this data to predict outcomes for new data.

For example, using email content and information about whether an email is spam or not, the model can be trained to predict if a new email is spam.

<br />

### Unsupervised Learning

Unsupervised Learning uses **data without answers (labels)** to discover structures or patterns within the data. For instance, customer purchase data can be used to group customers with similar buying patterns.

<br />

### Reinforcement Learning

Reinforcement Learning is a method where actions are learned through trial and error to **maximize rewards**. For example, a robot learning to escape a maze can be rewarded for finding the correct path and penalized for taking wrong turns, ultimately learning the optimal route.

<br />

In the next lesson, we will explore `Deep Learning`, another frequently mentioned AI term.

Machine Learning refers to the process of analyzing data, learning patterns from it, and building models that can make predictions or decisions on new data.

from pptx import Presentation

# Create a new presentation object
prs = Presentation()

# Add the first slide
slide_content = prs.slides.add_slide(prs.slide_layouts[1])

# Select the title of the first slide
title_content = slide_content.shapes.title

# Select the body content of the first slide
content = slide_content.placeholders[1]

# Add text to the selected title
title_content.text = "Hello"

# Add text to the selected body content
content.text = "This is CodeFriends"

# Save the presentation file
prs.save("output_file.pptx")

# Automating Repetitive PowerPoint Tasks

Have you ever created a `report in the same format` every week or month or filled a PowerPoint template like a certificate with `different data each time`?

Manually editing slides or repeating tasks can waste time and lead to errors.

`python-pptx` is a Python library designed to **automate repetitive PPT tasks**.

In this lesson, we will learn how to create simple PowerPoint slides using python-pptx.

> *Note*: To run the practice code on your computer, install the python-pptx library using the command `pip install python-pptx`.

<br />

## How to Create PowerPoint Slides Using Python Code

Let’s start with a simple presentation to understand the basic usage of the `python-pptx` library.

When importing the `python-pptx` library, use the format `from pptx import {class or function}` to bring in the required components.

The following example creates a PowerPoint file object and adds simple text to a slide.

```python title="Creating a Simple Presentation"
# Import the python-pptx library
from pptx import Presentation

# Create a new presentation object
prs = Presentation()

# Add the first slide
slide_content = prs.slides.add_slide(prs.slide_layouts[1])

# Select the title of the first slide
title_content = slide_content.shapes.title

# Select the body content (2nd placeholder)
content = slide_content.placeholders[1]

# Add text to the selected title
title_content.text = "Hello"

# Add text to the selected body content
content.text = "This is CodeFriends"

# Save the presentation file
prs.save("output_file.pptx")
```

`placeholders` is an attribute that refers to predefined spaces in a slide layout, known as `placeholders`.

Placeholders are **content boxes** that exist at specific positions in a slide, such as for titles, subtitles, body content, images, and tables.

`placeholders[1]` refers to the second placeholder, which may contain different types of content depending on the PowerPoint slide layout.

When you run the code, a PowerPoint file named `output_file.pptx` will be created.

Opening the file will show the first slide with a "title" and "body content" added.

<br/>

## Code Explanation

```python title="Creating a Simple Presentation"
prs = Presentation()
```

`Presentation()` is a method in python-pptx used to create a new PowerPoint file object.

<br />

```python title="Adding a Slide"
slide_content = prs.slides.add_slide(prs.slide_layouts[1])
```

`slides.add_slide()` is used to add a slide to the PowerPoint file object.

The argument `prs.slide_layouts[1]` represents the slide layout.

PowerPoint provides several standard layouts, and `slide_layouts[1]` is a layout that includes a title box and a body content box.

<br />

```python title="Adding a Title and Body Content"
# Select the title of the first slide
title_content = slide_content.shapes.title

# Select the body content of the first slide
content = slide_content.placeholders[1]

# Add text to the selected title
title_content.text = "Hello"

# Add text to the selected body content
content.text = "This is CodeFriends"
```

The `slide_content` variable contains the added first slide, and `slide_content.shapes.title` selects the title box.

`shapes` represents all objects in the slide, and among them, `title` refers to the title box.

`slide_content.placeholders[1]` selects the content box for the body text.

`placeholders` is an attribute that refers to predefined spaces in the slide layout, such as placeholders for titles, subtitles, body content, images, and tables.

<br />
  
```python title="Saving the PowerPoint File"
prs.save("output_file.pptx")
```

Finally, the `save` method saves the PowerPoint file created with the presentation object.

<br />

## Practice

Run the code and check the PowerPoint slide with the added `title` and `body content`.

`slide_content.placeholders[1]` selects the second predefined placeholder for body content in the slide.

### What is the most appropriate code to fill in the blank below?

# Why Should You Learn Prompt Engineering?

In an era where AI is applied across nearly all industries,
AI is utilized everywhere, from personal travel planning to sales data analysis.

However, AI can sometimes provide irrelevant answers to questions
or overwhelm users with overly lengthy responses to simple queries.

At times, you might not even know what to ask to resolve a problem.

Just as humans need clear instructions to work effectively, generative AI also requires **proper guidance**.

To address this, the systematic method of crafting effective questions for AI is called `Prompt Engineering.`

A **prompt** is a sentence that conveys the user's request to AI.
Prompt engineering optimizes these prompts to help AI deliver the desired responses.

<br />

## Examples of Prompt Engineering in Action

Let’s look at specific examples to understand how prompt engineering can be applied.

Imagine asking AI to create a workout schedule and diet plan for a healthy lifestyle.

```text title="Prompt Producing Unorganized Responses"
I want to create a workout schedule for the gym.

From June 1 to June 10, 2024, on alternate days,
tell me what exercises I should do each day along with a diet plan.
```

The prompt above requests a workout schedule and diet plan,
but the AI's response may contain excessive, irrelevant information,
making it difficult for users to quickly grasp the desired details.

What if we revise the prompt as follows?

```text title="Prompt Producing Well-Structured Responses"
I want to create a workout schedule for the gym.

From June 1 to June 10, 2024, on alternate days,
please organize the schedule into a table, including the exercises for each day
along with breakfast and dinner plans.

---Table Format---

### Title

| No | Date       | Day  | Exercise  | Breakfast      | Dinner        |
```

Now, the workout schedule is neatly organized into a **table** alongside the diet plan,
making the output much easier to interpret.

By applying this, you can prevent ChatGPT from generating unnecessarily long responses
or structure its output into `.csv` or `.xlsx` formats suitable for spreadsheets.

Note that the `###` used next to the table format serves as a `delimiter` to clearly separate and structure information within the prompt.

This delimiter helps AI distinguish the **context of the prompt**, ensuring it recognizes that everything below `###` pertains to the table format.

The vertical bars `|` used to define the table format act as delimiters for table columns,
and they are commonly used when writing tables in `Markdown`.

> Markdown: A simple markup language for styling text and creating elements like headings, bold text, and tables.

<br />

```text title="Markdown Table Example"
| No | Date       | Day  | Exercise | Diet       |
|----|------------|------|----------|------------|
| 1  | 2024-06-10 | Mon  | Running  | Salad      |
| 2  | 2024-06-11 | Tue  | Swimming | Pasta      |
```

The Markdown table above appears in an AI response or Markdown document as shown below:

| No | Date       | Day  | Exercise | Diet       |
|----|------------|------|----------|------------|
| 1  | 2024-06-10 | Mon  | Running  | Salad      |
| 2  | 2024-06-11 | Tue  | Swimming | Pasta      |

<br />

Prompt engineering not only **formats responses** and **improves readability**, but also helps **prevent incorrect answers** from AI.

Examples of using prompt engineering to prevent incorrect answers will be covered in the next lesson. :)

<br />

## Practice

Click on the provided prompt examples and compare the AI’s responses.

Prompt engineering aims to provide clear instructions to AI to get the desired responses, specify response formats, and improve readability. Expanding AI’s database is not a primary purpose of prompt engineering.

print('?')
# Print the result of dividing 4 by 2 as a floating-point number

# Separator line
print('=' * 30)

# Conditional statement output
number = 5

if number > 0:
    print("+++")
else:
    print("---")

# Printing Output in Python

The `print()` function, which means "to output" in English, displays the data inside parentheses `( )` on the screen.

<br />

## How Do You Use It?

Simply input the data you want to output inside the parentheses, and that's it!

```python title="Using the print() Function"
print("Python")           # Outputs the string "Python"

print(123)              # Outputs the number 123

message = "CodeFriends"     # Assigns "CodeFriends" to the variable message
print(message)          # Outputs the value stored in the variable message
```

<br />

## Printing Multiple Data Items at Once

By using a `comma (,)` inside the print function, you can output multiple items simultaneously.

Each item separated by a comma is divided by a **whitespace**.

```python title="Printing Multiple Data Items"
name = "CodeFriends"
age = 20

print(name, "is", age, "years old")
# Outputs "CodeFriends is 20 years old"
```

<br />

## Coding Practice

Enter `print(4 / 2)` into the practice code editor.

"print(4 / 2)" outputs the result of dividing 4 by 2. In Python, division is performed using the slash symbol`(/)`, and the result is returned as a floating-point number.

Thus, the result of **4 / 2** is a floating-point number `2.0` instead of an integer `2`.

In Python, the `print()` function is used to output the data inside parentheses onto the screen.

### Complete the function to display data on the screen in Python.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd
import time

# Launch Chrome WebDriver
driver = webdriver.Chrome()

# Navigate to Yahoo Finance's 'Markets' page
driver.get('https://finance.yahoo.com/markets/')

# Wait until the page is fully loaded (max 10 seconds)
wait = WebDriverWait(driver, 10)

# Locate the 'Americas' section
try:
    americas_section = wait.until(EC.presence_of_element_located((By.XPATH, "//h3[text()='Americas']")))

    # Scroll to the 'Americas' section
    actions = ActionChains(driver)
    actions.move_to_element(americas_section).perform()

    # Locate the parent section containing the table
    parent_section = americas_section.find_element(By.XPATH, "./ancestor::section[contains(@data-testid, 'world-indices')]")

    # Find the table within the section
    table = parent_section.find_element(By.XPATH, ".//table")

    # Extract headers from the table
    headers = [header.text for header in table.find_elements(By.XPATH, ".//th")]

    # Extract rows from the table
    rows = table.find_elements(By.XPATH, ".//tbody/tr")

    # Initialize list to store data
    table_data = []

    # Extract data from each row
    for row in rows:
        columns = row.find_elements(By.XPATH, ".//td")
        row_data = {}
        for i in range(len(headers)):
            header = headers[i]
            column_value = columns[i].text
            row_data[header] = column_value
        table_data.append(row_data)

    # Convert data to a Pandas DataFrame
    df = pd.DataFrame(table_data)

    # Filter for 'Symbol' and 'Price' columns
    df_filtered = df[['Symbol', 'Price']]

    # Print the filtered data
    print(df_filtered)

except Exception as e:
    print(f"ERROR: WebDriver error occurred: {str(e)}")

finally:
    # Close the browser
    driver.quit()

# Crawling U.S. Stock Market Indices with Selenium

In this lesson, we’ll practice real-world web crawling by applying the **Selenium** knowledge we’ve learned so far.

The practice code demonstrates using Selenium to extract table data from the `Americas` section on the `Yahoo Finance` website and organizing the data using the `pandas` library for output.

> *Note*: Web crawling may fail if the `HTML` or `CSS` structure of the website changes. In such cases, the code must be updated accordingly.

Let’s go through the code step by step.

<br />

### 1. Import Required Libraries

```python title="Importing Libraries"
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd
import time
```

- selenium: A library for web automation and scraping. It allows interaction with web page elements.

- pandas: A library for handling data in table formats. It’s useful for data analysis similar to working with Excel.

- time: A Python built-in module that provides time-related functions.

<br />

### 2. Launch WebDriver and Navigate to Website

```python title="Launching WebDriver and Navigating to Website"
driver = webdriver.Chrome()
driver.get('https://finance.yahoo.com/markets/')
```

- webdriver.Chrome(): Launches the Chrome WebDriver to control the browser automatically. It opens a browser window.

- driver.get(URL): Navigates to the specified URL. Here, it opens the Yahoo Finance ‘Markets’ page.

<br />

### 3. Wait for Page to Load

```python title="Waiting for the Page to Load"
wait = WebDriverWait(driver, 10)
```

- WebDriverWait(driver, 10): Waits up to 10 seconds for an element to appear. This prevents errors caused by running the code before the page has fully loaded.

<br />

### 4. Locate the 'Americas' Section

```python title="Locating the Section"
americas_section = wait.until(EC.presence_of_element_located((By.XPATH, "//h3[text()='Americas']")))
```

- wait.until(): Waits until the `h3` tag containing the text ‘Americas’ appears on the page. `EC.presence_of_element_located()` checks if the element is present on the page.

<br />

### 5. Scroll and Locate the Table within the Section

```python title="Finding the Table in the Section"
actions = ActionChains(driver)
actions.move_to_element(americas_section).perform()

parent_section = americas_section.find_element(By.XPATH, "./ancestor::section[contains(@data-testid, 'world-indices')]")
table = parent_section.find_element(By.XPATH, ".//table")
```

- ActionChains(driver): Automates actions like mouse movements and clicks. Here, it scrolls to the ‘Americas’ section.

- find_element(By.XPATH): Finds the parent `section` element containing the ‘Americas’ table.

<br />

### 6. Extract Table Data

```python title="Extracting Data from the Table"
headers = [header.text for header in table.find_elements(By.XPATH, ".//th")]
rows = table.find_elements(By.XPATH, ".//tbody/tr")
```

- table.find_elements(): Extracts the table headers and data from rows.
    - `th`: Refers to table headers.
    - `tr`: Refers to table rows.

<br />

### 7. Store Data in a List

```python title="Storing Table Data as a Dictionary"
table_data = []
for row in rows:
    columns = row.find_elements(By.XPATH, ".//td")
    row_data = {}
    for i in range(len(headers)):
        header = headers[i]
        column_value = columns[i].text
        row_data[header] = column_value
    table_data.append(row_data)
```

- Extracts column data (`td`) for each row (`tr`) and stores them as key-value pairs in a dictionary, with headers as keys and corresponding values.

<br />

### 8. Convert Data to a Pandas DataFrame and Display

```python title="Converting to DataFrame and Displaying"
df = pd.DataFrame(table_data)
df_filtered = df[['Symbol', 'Price']]
print(df_filtered)
```

- pd.DataFrame(): Converts the extracted data into a Pandas DataFrame.

- df[['Symbol', 'Price']]: Filters only the `Symbol` and `Price` columns for a clean display of data.

<br />

### 9. Close the Browser

```python title="Closing the Browser"
driver.quit()
```

- driver.quit(): Closes the browser to release resources after completing all tasks.

selenium

# Why English Matters as Much as Coding for Developers

> In an era where AI can write code, technical skills alone are no longer enough to stay competitive.

While many developers are proficient in coding, few have the English communication skills needed to thrive in global tech communities.

If you're aiming to grow your career internationally or collaborate with global teams, learning English isn’t optional—it’s essential.

So why exactly is English so important for developers?

<br />

## 1. Most technical documentation is written in English

Open-source libraries and frameworks like React, TensorFlow, and Node.js are built around English documentation and communities.

In fact, English dominates the internet, while content in many other languages makes up a tiny fraction.

If you rely only on non-English sources, you're missing out on the vast majority of technical knowledge—some of which could help you solve complex bugs or gain valuable career advice.

<br />

## 2. Tech English is different from business or academic English

To work smoothly with international teams or contribute to open-source projects, you need to be familiar with the language commonly used in the software industry.

If you can articulate technical concepts clearly in English, you'll be ready when opportunities at global tech companies arise.

However, translating even simple concepts from your native language into English can be challenging.

For example, should you say `stored on the server` or `stored in the server`?

Is it `deliver a value to a function` or `pass a value to a function`?

What do abbreviations like `LGTM`, `TL;DR`, `PR`, and `Headless` mean?

These terms don’t appear in standard business English, so you’ll need to learn them in context.

<br />

## 3. Developers who speak English get more opportunities

The world is big, and the possibilities are endless.

Limiting yourself to a local market can restrict your potential. To reach a global audience and compete in an international job market, English should be a stepping stone—not a barrier.

When your coding skills are paired with strong English, the world becomes your stage.

<br />

## Course Overview

This course is designed for developers who want to become global professionals. It focuses on practical English expressions used in software development and includes an AI-powered interview practice tool.

The course is divided into two parts. *In the first part*, you’ll learn essential tech vocabulary, how to read code in English, and common Git-related expressions.

*In the second part*, you’ll practice introducing yourself and answering common technical interview questions in English.

<br />

## Practice

The first step to becoming a global developer is learning how to introduce yourself in English.

The interview practice tool on the right is mainly used in the second part of the course. It includes real-time speech recognition, MP3 downloads of your recordings, and instant AI feedback.

For the best experience, we recommend using the Chrome browser on a desktop. Other browsers may have limited support for speech recognition.

Click the blue record button to start your personalized English introduction.

Fluent English allows developers to access a wider range of resources and collaborate more effectively with global teams. It’s a key asset for expanding your career beyond local boundaries.

### Developers who speak fluent English have access to more global opportunities.

-- Retrieve names and emails of all customers
SELECT first_name, last_name, email FROM customers;

-- Retrieve products with 10 or more items in stock
SELECT product_name, stock FROM products WHERE stock >= 10;

# SQL: The Language for Interacting with Databases

`SQL (Structured Query Language)` is the standard language used for **defining, creating, reading, updating, and deleting** data in relational database management systems (RDBMS).

Developed in the 1970s at IBM Research Labs, SQL has become an essential language for managing databases and is widely used across various relational database systems today.

## What Are the Features of SQL?

SQL is a query-based language that makes it easy to access and manipulate data in a database. Key features of SQL include:

- Standardized by ANSI (American National Standards Institute) and ISO (International Organization for Standardization), ensuring **compatibility** across various database systems.
- Allows you to **define**, **add**, **modify**, and **delete** tables and other database objects.
- Provides mechanisms such as `transactions` (a set of database operations treated as a single logical unit) to ensure data **consistency** and **integrity**.

## How Is SQL Structured?

SQL is broadly divided into `DDL` (Data Definition Language), which deals with database design, and `DML` (Data Manipulation Language), which focuses on data manipulation.

### 1. Data Definition Language (DDL)

*DDL* defines database schemas (the structure and design of a database). It is primarily used to define:

- `Table`: The basic data structure that stores data in rows and columns.
- `Index`: A tool to improve data retrieval speed.
- `View`: A virtual table displaying query results.

Key DDL commands include:

- `CREATE`: Creates tables, indexes, views, etc.
- `ALTER`: Modifies the structure of existing database objects.
- `DROP`: Deletes database objects.

### 2. Data Manipulation Language (DML)

*DML* consists of commands for manipulating data within the database. Key DML commands include:

- `INSERT`: Adds new records to a table.
- `UPDATE`: Modifies existing records.
- `DELETE`: Removes records matching specific conditions.
- `SELECT`: Retrieves data that matches specific conditions.

SQL queries are generally written to retrieve specific data from database tables. The basic structure of an SQL query includes `SELECT`, `FROM`, and `WHERE` clauses.

```sql title="Basic SQL Structure"
SELECT column1, column2, ...
FROM table_name
WHERE condition;
```

- `SELECT`: Specifies the columns to retrieve.
- `FROM`: Specifies the table to retrieve data from.
- `WHERE`: Filters data that meets specific conditions.

## How Can SQL Be Utilized?

SQL allows you to efficiently search and manipulate information in large-scale databases.

For example, if you want to retrieve the `product name` and `stock quantity` of products with `10 or more` items in stock, you can use the following SQL query:

```sql title="SQL Example"
SELECT product_name, stock
FROM products
WHERE stock >= 10;
```

This query retrieves `product_name` and `stock` from the `products` table for items where the `stock` is 10 or more (`stock >= 10`).

SQL is essential for working with databases and is a **universal language** useful even for non-developers. By learning SQL, you can efficiently manage and utilize databases in organizations or institutions that handle large-scale data.

In SQL, the `SELECT` command is used to search and retrieve data that matches specific conditions. `INSERT`, `UPDATE`, and `DELETE` commands are used to add, modify, and delete data, respectively.

### What is the most appropriate command to fill in the blank?

# Essential English Terms Every Developer Should Know

When reading technical documentation or observing communication in open-source communities, you'll notice certain English vocabulary and expressions that come up frequently in the tech industry.

For example, the verb `implement` is commonly used when introducing a new feature.
(e.g., Implement a JWT-based authentication system)

Communicating with global clients can also be tricky if you're unfamiliar with terms like `overwrite` or `user-defined`.

You may even mispronounce common technical terms like `execution` or `deprecated` if you’ve only seen them in writing.

Learning these industry-standard terms and expressions will significantly boost your comprehension when reading docs or watching tech conference talks.

Don’t just read these words—say them out loud and try using them in your own sentences.

That’s because our brains retain information better when we actively use what we’ve learned.

Let’s go over the must-know English terms and expressions for software professionals.

`Execute` is pronounced [ek-si-kyoot], with the stress on the first syllable. It's commonly used in software to mean 'to run' or 'to carry out'.

### `Execute` is pronounced like [eek-see-kyoot].

Essential English for Developers

# AI-driven Speech Synthesis

Have you ever wondered how the voices from automated responders, smart speakers, and navigation systems are created?

AI now possesses the capability to mimic human voices. It can generate not only simple mechanical sounds but also replicate emotions, intonations, and even imitate specific people's voices.

`Speech Synthesis` is the technology that enables computers to generate speech by mimicking human voices.

AI learns from large volumes of voice data by analyzing sound and sentence patterns, applying them to produce new speech.

Speech synthesis technology typically converts input text into human-like speech, known as `Text-to-Speech` (TTS).

In this lesson, we will explore the concept of speech synthesis and the technical processes AI uses to create speech.

<br/>

--

Computers cannot directly interpret written text. The process begins with a text preprocessing stage that breaks sentences into smaller, analyzable units.

<br/>

## 1. Tokenization

Tokens are the smaller units obtained by breaking down a sentence.

For example, when tokenizing `"Hello, how are you?"`, it can be split into `["Hello", ",", "how", "are", "you", "?"]`.

<br/>

### 2. Pronunciation Conversion

The characters are converted into `phonemes`, which are units that can be pronounced. Common systems for this include ARPAbet or the International Phonetic Alphabet (IPA).

For instance, `"Hello"` is converted to `HH AH0 L OW1` in the ARPAbet format that machines easily understand.

<br/>

### 3. Contextual Analysis

It involves analyzing which parts of a sentence should be emphasized or the flow of the sentence.

`"I am going to school."` has a declarative intonation, whereas `"Am I going to school?"` has an interrogative intonation.

AI learns these differences in intonation to generate speech that matches the tone of the sentence.

<br/>

## 4. Speech Generation via Vocoder Conversion

The initial audio data generated by AI is not immediately audible as natural speech. A `Vocoder` is used to convert this data into realistic, human-like voice output.

It generates speech by modeling the frequency and amplitude characteristics of human vocal signals.

Recently, deep learning-based vocoders like WaveNet and HiFi-GAN have become widely used, creating voices so natural that they're nearly indistinguishable from human speech.

<br/>

AI-based speech synthesis continues to evolve, enabling increasingly natural pronunciation and expressive intonation.

In the next lesson, we will recap what we've learned and reinforce key concepts through a quiz.

TTS is an abbreviation for Text-To-Speech, which is a technology that converts text into speech.

### TTS is an abbreviation for Text-Tone-Signal.

<html>
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    
    <title>Website Title</title>
    <meta name="title" content="Website Title" />
    <meta name="description" content="#" />

    
    <meta property="og:title" content="Website Title" />
    <meta property="og:description" content="#" />
    <meta property="og:type" content="website" />
    <meta property="og:image" content="#" />

    <link
      rel="icon"
      type="image/x-icon"
      href="https://www.codefriends.net/icons/favicon.ico"
    />
    <link
      rel="stylesheet"
      type="text/css"
      href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css"
    />
  </head>

  <body>
    <header id="hero">
      <nav class="navbar">
        <div class="container">
          <span id="logo">
            <a href="#">Website Title</a>
          </span>
          <ul class="nav-menu">
            <li><a class="nav-link" href="#about">About</a></li>
            <li><a class="nav-link" href="#interests">Hobbies</a></li>
            <li><a class="nav-link" href="#memory">Memories</a></li>
            <li>
              <a class="nav-link btn btn-primary" href="#contact"
                >Contact <i class="fas fa-arrow-right"></i
              ></a>
            </li>
          </ul>
          <div class="hamburger">
            <span class="bar"></span>
            <span class="bar"></span>
            <span class="bar"></span>
          </div>
        </div>
      </nav>

      <section class="header-container">
        <img
          class="profile-image"
          src="https://assets.codefriends.net/assets/images/bio-website/hero-image.png"
          alt="hero-image"
        />
        <h1 class="intro">Hello!</h1>

        <div class="content-text">
          <h2>I am {Name}.</h2>
          <p>Thank you for visiting 🙂</p>
        </div>

        <a
          href="https://www.instagram.com/codefriends.korea/"
          class="social-media"
          target="_blank"
        >
          <svg
            xmlns="http://www.w3.org/2000/svg"
            width="16"
            height="16"
            fill="currentColor"
            class="bi bi-instagram"
            viewBox="0 0 16 16"
          >
            <path
              d="M8 0C5.829 0 5.556.01 4.703.048 3.85.088 3.269.222 2.76.42a3.917 3.917 0 0 0-1.417.923A3.927 3.927 0 0 0 .42 2.76C.222 3.268.087 3.85.048 4.7.01 5.555 0 5.827 0 8.001c0 2.172.01 2.444.048 3.297.04.852.174 1.433.372 1.942.205.526.478.972.923 1.417.444.445.89.719 1.416.923.51.198 1.09.333 1.942.372C5.555 15.99 5.827 16 8 16s2.444-.01 3.298-.048c.851-.04 1.434-.174 1.943-.372a3.916 3.916 0 0 0 1.416-.923c.445-.445.718-.891.923-1.417.197-.509.332-1.09.372-1.942C15.99 10.445 16 10.173 16 8s-.01-2.445-.048-3.299c-.04-.851-.175-1.433-.372-1.941a3.926 3.926 0 0 0-.923-1.417A3.911 3.911 0 0 0 13.24.42c-.51-.198-1.092-.333-1.943-.372C10.443.01 10.172 0 7.998 0h.003zm-.717 1.442h.718c2.136 0 2.389.007 3.232.046.78.035 1.204.166 1.486.275.373.145.64.319.92.599.28.28.453.546.598.92.11.281.24.705.275 1.485.039.843.047 1.096.047 3.231s-.008 2.389-.047 3.232c-.035.78-.166 1.203-.275 1.485a2.47 2.47 0 0 1-.599.919c-.28.28-.546.453-.92.598-.28.11-.704.24-1.485.276-.843.038-1.096.047-3.232.047s-2.39-.009-3.233-.047c-.78-.036-1.203-.166-1.485-.276a2.478 2.478 0 0 1-.92-.598 2.48 2.48 0 0 1-.6-.92c-.109-.281-.24-.705-.275-1.485-.038-.843-.046-1.096-.046-3.233 0-2.136.008-2.388.046-3.231.036-.78.166-1.204.276-1.486.145-.373.319-.64.599-.92.28-.28.546-.453.92-.598.282-.11.705-.24 1.485-.276.738-.034 1.024-.044 2.515-.045v.002zm4.988 1.328a.96.96 0 1 0 0 1.92.96.96 0 0 0 0-1.92zm-4.27 1.122a4.109 4.109 0 1 0 0 8.217 4.109 4.109 0 0 0 0-8.217zm0 1.441a2.667 2.667 0 1 1 0 5.334 2.667 2.667 0 0 1 0-5.334z"
            />
          </svg>
        </a>
      </section>
    </header>

    <div class="division"></div>

    <section id="about" class="container">
      <div class="content-text">
        <h2>About</h2>
        <p>Let me introduce myself briefly!</p>
      </div>

      <div class="bio-container">
        <div class="bio-item">
          <h4>Date of Birth</h4>
          <p class="bio-text">2000.01.01</p>
        </div>

        <div class="bio-item">
          <h4>Location</h4>
          <p class="bio-text">USA</p>
        </div>

        <div class="bio-item">
          <h4>Age</h4>
          <p class="bio-text">25</p>
        </div>
      </div>
    </section>

    <div class="division"></div>

    <section id="interests" class="container">
      <div class="content-text">
        <h2>Hobbies</h2>
        <p>Check out the photos and videos 📹</p>
      </div>

      <div class="grid">
        <div onclick="gridImageClick(this)">
          <img
            src="https://assets.codefriends.net/assets/images/bio-website/gallery-1.jpeg"
            width="100%"
            height="100%"
            alt="Description 1"
            class="grid-image"
          />
        </div>
        <div onclick="gridImageClick(this)">
          <img
            src="https://assets.codefriends.net/assets/images/bio-website/gallery-2.jpeg"
            width="100%"
            height="100%"
            alt="Description 2"
            class="grid-image"
          />
        </div>
        
    </section>

    <div id="modal">
      <div class="modal-content">
        <div class="modal-close">&times;</div>
        <div id="modal-image"></div>
        <div id="modal-text"></div>
      </div>
    </div>

    <div class="division"></div>

    <section id="memory" class="container">
      <div class="content-text">
        <h2>Memories</h2>
        <p>Preserving precious memories 📷</p>

        <div class="slideshow-container">
          <div class="my-slides fade">
            <img
              src="https://assets.codefriends.net/assets/images/bio-website/carousel-1.webp"
              class="slide-image"
            />
            <div class="slide-text">Image Description 1</div>
          </div>

          <div class="my-slides fade">
            <img
              src="https://assets.codefriends.net/assets/images/bio-website/carousel-2.jpeg"
              class="slide-image"
            />
            <div class="slide-text">Image Description 2</div>
          </div>

          <div class="my-slides fade">
            <img
              src="https://assets.codefriends.net/assets/images/bio-website/carousel-3.jpeg"
              class="slide-image"
            />
            <div class="slide-text">Image Description 3</div>
          </div>

          
          <a class="prev" onclick="plusSlides(-1)">&#10094;</a>
          <a class="next" onclick="plusSlides(1)">&#10095;</a>
        </div>
        <br />

        
        <div>
          <span class="dot" onclick="currentSlide(1)"></span>
          <span class="dot" onclick="currentSlide(2)"></span>
          <span class="dot" onclick="currentSlide(3)"></span>
        </div>
      </div>
    </section>

    <div class="division"></div>

    <section id="contact" class="container">
      <div class="content-text">
        <h3 style="margin-top: 32px; margin-bottom: 12px">
          Feel free to contact me anytime!
        </h3>
        <a href="mailto:contact@codefriends.net">contact@codefriends.net</a>
      </div>
    </section>

    <footer id="footer">
      <div class="container">
        <p>Instagram & YouTube</p>
        <div class="social">
          <a href="#" target="_blank">
            <svg
              xmlns="http://www.w3.org/2000/svg"
              height="20px"
              viewBox="0 0 448 512"
            >
              <path
                fill="white"
                d="M224.1 141c-63.6 0-114.9 51.3-114.9 114.9s51.3 114.9 114.9 114.9S339 319.5 339 255.9 287.7 141 224.1 141zm0 189.6c-41.1 0-74.7-33.5-74.7-74.7s33.5-74.7 74.7-74.7 74.7 33.5 74.7 74.7-33.6 74.7-74.7 74.7zm146.4-194.3c0 14.9-12 26.8-26.8 26.8-14.9 0-26.8-12-26.8-26.8s12-26.8 26.8-26.8 26.8 12 26.8 26.8zm76.1 27.2c-1.7-35.9-9.9-67.7-36.2-93.9-26.2-26.2-58-34.4-93.9-36.2-37-2.1-147.9-2.1-184.9 0-35.8 1.7-67.6 9.9-93.9 36.1s-34.4 58-36.2 93.9c-2.1 37-2.1 147.9 0 184.9 1.7 35.9 9.9 67.7 36.2 93.9s58 34.4 93.9 36.2c37 2.1 147.9 2.1 184.9 0 35.9-1.7 67.7-9.9 93.9-36.2 26.2-26.2 34.4-58 36.2-93.9 2.1-37 2.1-147.8 0-184.8zM398.8 388c-7.8 19.6-22.9 34.7-42.6 42.6-29.5 11.7-99.5 9-132.1 9s-102.7 2.6-132.1-9c-19.6-7.8-34.7-22.9-42.6-42.6-11.7-29.5-9-99.5-9-132.1s-2.6-102.7 9-132.1c7.8-19.6 22.9-34.7 42.6-42.6 29.5-11.7 99.5-9 132.1-9s102.7-2.6 132.1 9c19.6-7.8 34.7 22.9 42.6 42.6 11.7 29.5 9 99.5 9 132.1s2.7 102.7-9 132.1z"
              />
            </svg>
          </a>
          <a href="#" target="_blank">
            <svg
              xmlns="http://www.w3.org/2000/svg"
              height="20px"
              viewBox="0 0 576 512"
            >
              <path
                fill="white"
                d="M549.655 124.083c-6.281-23.65-24.787-42.276-48.284-48.597C458.781 64 288 64 288 64S117.22 64 74.629 75.486c-23.497 6.322-42.003 24.947-48.284 48.597-11.412 42.867-11.412 132.305-11.412 132.305s0 89.438 11.412 132.305c6.281 23.65 24.787 41.5 48.284 47.821C117.22 448 288 448 288 448s170.78 0 213.371-11.486c23.497-6.321 42.003-24.171 48.284-47.821 11.412-42.867 11.412-132.305 11.412-132.305s0-89.438-11.412-132.305zm-317.51 213.508V175.185l142.739 81.205-142.739 81.201z"
              />
            </svg>
          </a>
        </div>
        <div class="attribution">
          Built with <a href="https://www.codefriends.net">CodeFriends</a>
        </div>
      </div>
    </footer>
  </body>
</html>

# `<img>` Tag

The `<img>` tag is used to insert images into web pages.

<br />

## **Key Attributes**

The key attributes of the `<img>` tag are `src`, `alt`, `width`, and `height`.

<br />

## `src`

The `src` attribute specifies the URL of the image. It is a required attribute. The URL can point to an image within the same website or an image hosted on an external website. Without this attribute, the `<img>` tag will not display an image.

```html title="The `src` Attribute in the `<img>` Tag"
<img src="https://example.com/myimage.jpg" />
```

<br />

## `alt`

The `alt` attribute provides alternative text for the image. It is used as a fallback when the image fails to load or to describe the image for screen readers, improving web accessibility. While not mandatory, it is essential for SEO (Search Engine Optimization) and accessibility enhancement.

```html title="Setting Alternative Text"
<img src="https://picsum.photos/300" alt="A sunset view of the ocean" />
```

<br />

## `width` and `height`

These attributes define the width and height of the image. The default unit is pixels (`px`).

```html title="Setting Image Dimensions"
<img src="https://picsum.photos/300" width="300" height="200" />
```

<br />

## **Usage Examples**

1. Using `src` and `alt`

```html title="Basic Usage of the `<img>` Tag"
<img src="https://picsum.photos/300" alt="Profile picture" />
```

<br />

2. Specifying Image Dimensions with `width` and `height`

```html title="Setting Image Dimensions"
<img
  src="https://picsum.photos/300"
  alt="Random image"
  width="200"
  height="150"
/>
```

<br />

## **Summary of the `<img>` Tag**

- Use the `<img>` tag to embed images into web pages.

- The `src` attribute specifies the URL of the image.

- The `alt` attribute provides a description or alternative text when the image is unavailable.

- Use the `width` and `height` attributes to adjust the image size.

The `src` attribute in the `<img>` tag is a required attribute that specifies the URL of the image. Without this attribute, the `<img>` tag will not display any image.

### The `src` attribute in the HTML `<img>` tag is optional.

from openpyxl import Workbook
from openpyxl.chart import LineChart, Reference

# Create a new workbook
wb = Workbook()

# Select the active sheet
ws = wb.active

# Input data (e.g., monthly sales)
data = [
    ['Month', 'Sales'],
    ['January', 30],
    ['February', 40],
    ['March', 50],
    ['April', 20],
    ['May', 60],
]

for row in data:
    ws.append(row)

# Create a chart
line_chart = LineChart()

# Reference the chart data (B2 to B6)
data = Reference(ws, min_col=2, min_row=2, max_row=6)

# Reference the X-axis (category) labels (A2 to A6)
cats = Reference(ws, min_col=1, min_row=2, max_row=6)

# Exclude titles from the data
line_chart.add_data(data, titles_from_data=False)
line_chart.set_categories(cats)
line_chart.title = "Monthly Sales"
line_chart.x_axis.title = "Month"
line_chart.y_axis.title = "Sales"

# Add the chart to the sheet (at cell D1)
ws.add_chart(line_chart, "A10")

# Save the file
wb.save("output_file.xlsx")

# How to Visualize Data Using Charts

Using `charts` and `graphs`, you can visualize data for a more intuitive understanding.

For simple data, drawing charts directly in Excel is faster.

However, when dealing with large-scale data or frequently updated data, **automating chart creation through programming** is much more efficient.

`openpyxl` provides useful methods to create charts and graphs with code.

In this session, we’ll learn how to add charts to an Excel file using openpyxl.

> Note: In this lesson, we’ll cover creating `line charts` and `bar charts`. However, openpyxl supports various chart types, including doughnut charts and pie charts.

<br />

## Creating a Line Chart

A `line chart` is often used to visualize data changes over time.

Below is an example of Python code to create a line chart using openpyxl.

```python title="Creating a Line Chart"
from openpyxl import Workbook
from openpyxl.chart import LineChart, Reference

# Create a new workbook
wb = Workbook()

# Select the active sheet
ws = wb.active

# Input data (e.g., monthly sales)
data = [
    ['Month', 'Sales'],
    ['January', 30],
    ['February', 40],
    ['March', 50],
    ['April', 20],
    ['May', 60],
]

for row in data:
    ws.append(row)

# Create a chart
line_chart = LineChart()

# Reference the chart data (B2 to B6)
data = Reference(ws, min_col=2, min_row=2, max_row=6)

# Reference the X-axis (category) labels (A2 to A6)
cats = Reference(ws, min_col=1, min_row=2, max_row=6)

# Exclude titles from the data
line_chart.add_data(data, titles_from_data=False)
line_chart.set_categories(cats)
line_chart.title = "Monthly Sales"
line_chart.x_axis.title = "Month"
line_chart.y_axis.title = "Sales"

# Add the chart to the sheet (at cell D1)
ws.add_chart(line_chart, "A10")

# Save the file
wb.save("output_file.xlsx")
```

<br />

### Code Explanation

- `line_chart = LineChart()`: Creates a line chart object

- `Reference`: References the data range and categories (months) for the chart

- `line_chart.add_data(data, titles_from_data=False)`: Adds data to the chart without including titles

- `line_chart.set_categories(cats)`: Sets the X-axis (category) labels

- `line_chart.title`: Sets the chart title

- `line_chart.x_axis.title`: Sets the X-axis title

- `line_chart.y_axis.title`: Sets the Y-axis title

- `ws.add_chart(line_chart, "A10")`: Adds the chart to the sheet

<br />

For simplicity, the code defines monthly sales data in a `data` variable as a list.

Using openpyxl, you can also specify a file path (e.g., `C:/Users/Username/Desktop/output_file.xlsx`) to load an Excel file, read the data, and create a chart.

```python title="Reading Data from an Excel File"
from openpyxl import load_workbook

# Load an Excel file
wb = load_workbook("C:/Users/Username/Desktop/input_file.xlsx")
ws = wb.active

# Read data
data = []

for row in ws.iter_rows(min_row=2, values_only=True):
    data.append(row)
```

<br />

## Creating a Bar Chart

A bar chart is commonly used to compare data sizes.

Below is an example of Python code to create a bar chart.

```python title="Creating a Bar Chart"
from openpyxl import Workbook
from openpyxl.chart import BarChart, Reference

# Create a new workbook
wb = Workbook()

# Select the active sheet
ws = wb.active

# Input data (e.g., monthly revenue)
data = [
    ['Month', 'Revenue'],
    ['January', 1000],
    ['February', 1500],
    ['March', 1200],
    ['April', 1700],
    ['May', 1300],
]

for row in data:
    ws.append(row)

# Create a chart
bar_chart = BarChart()

# Reference the chart data (B2 to B6)
data = Reference(ws, min_col=2, min_row=2, max_row=6)

# Reference the X-axis (category) labels (A2 to A6)
cats = Reference(ws, min_col=1, min_row=2, max_row=6)

# Exclude titles from the data
bar_chart.add_data(data, titles_from_data=False)
bar_chart.set_categories(cats)
bar_chart.title = "Monthly Revenue"
bar_chart.x_axis.title = "Month"
bar_chart.y_axis.title = "Revenue"

# Add the chart to the sheet (at cell D1)
ws.add_chart(bar_chart, "A10")

# Save the file
wb.save("output_file.xlsx")
```

### Code Explanation

- `bar_chart = BarChart()`: Creates a bar chart object

- `Reference`: References the data range and categories (months) for the chart

- `bar_chart.add_data(data, titles_from_data=False)`: Adds data to the chart without including titles

- `bar_chart.set_categories(cats)`: Sets the X-axis (category) labels

- `bar_chart.title`: Sets the chart title

- `bar_chart.x_axis.title`: Sets the X-axis title

- `bar_chart.y_axis.title`: Sets the Y-axis title

- `ws.add_chart(bar_chart, "A10")`: Adds the chart to the sheet

<br />

## Creating Various Charts

Using openpyxl, you can create various chart types such as **pie charts**, **doughnut charts**, and **histograms** in addition to line and bar charts.

You can learn more about each chart type in the <a href="https://openpyxl.readthedocs.io/en/stable/charts/introduction.html" target="_blank">chart module</a>.

The Reference object is used to specify the data range and X-axis category labels for charts in an Excel sheet. It ensures precise referencing of the data required for the chart.

### Which object is most appropriate to fill in the blank?

import openpyxl
from docx import Document
from copy import deepcopy
import os

# Input file paths
xlsx_file_path = 'input_file.xlsx'
docx_file_path = 'input_file.docx'

# Output file path
output_file_path = 'output_file.docx'

# Load the original DOCX template
original_template = Document(docx_file_path)

# Load the Excel file
wb = openpyxl.load_workbook(xlsx_file_path)
sheet = wb.active

# Create a new document to store the final result
final_document = Document()

# Remove the first empty paragraph in the default document (to prevent an initial blank page)
if len(final_document.paragraphs) > 0:
    final_document._element.body.remove(final_document.paragraphs[0]._element)

# Iterate over each row in the Excel sheet and read data
for row in sheet.iter_rows(min_row=2, values_only=True):
    # Create a dictionary for the dataset
    data = {
        "AWARD_NAME": row[0],
        "NAME": row[1],
        "CONTENT": row[2],
        "DATE": row[3],
        "ORGANIZATION": row[4],
        "GRADE": row[5]
    }
    
    # Copy the original template to create a new document
    temp_document = deepcopy(original_template)
    
    # Replace text placeholders
    for paragraph in temp_document.paragraphs:
        for run in paragraph.runs:
            for key, value in data.items():
                if f"<{key}>" in run.text:
                    run.text = run.text.replace(f"<{key}>", str(value))
    
    # Replace text placeholders in tables
    for table in temp_document.tables:
        for row in table.rows:
            for cell in row.cells:
                for paragraph in cell.paragraphs:
                    for run in paragraph.runs:
                        for key, value in data.items():
                            if f"<{key}>" in run.text:
                                run.text = run.text.replace(f"<{key}>", str(value))
    
    # Merge the template content into the final document
    for element in temp_document.element.body:
        final_document.element.body.append(deepcopy(element))

# Save the final document to output_file_path
final_document.save(output_file_path)

# Read Excel with openpyxl & Write to Word

Converting Excel data into Word documents is a common task in report generation and document automation workflows.

In this lesson, we will use the **openpyxl** library to read data from an Excel file and the **python-docx** library to add text and tables to a Word document.

<br />

## Excel File Structure

Let’s first look at the structure of the Excel file we’ll be working with.

The Excel file contains sales data with the following structure:

| Date       | Product Name | Quantity | Unit Price | Total Sales |
|------------|--------------|----------|------------|-------------|
| 2024-01-01 | Product A    | 100      | 500        | 50,000      |
| 2024-01-02 | Product B    | 150      | 750        | 112,500     |
| 2024-01-03 | Product C    | 200      | 800        | 160,000     |
| 2024-01-04 | Product A    | 130      | 500        | 65,000      |
| 2024-01-05 | Product B    | 170      | 750        | 127,500     |

The file calculates the total sales for each product by multiplying the quantity by the unit price.

Our goal is to transform this data into a Word document and include it in a report.

<br />

## Step 1: Reading Data from an Excel File

First, we use the **openpyxl** library to read data from the Excel file.

This library provides features for reading and writing Excel files and allows you to extract data with simple code.

```python title="Reading Data from an Excel File"
from openpyxl import load_workbook

# Load the Excel file
workbook = load_workbook('sales_data.xlsx')
sheet = workbook.active

# Read data
data = []
for row in sheet.iter_rows(min_row=2, values_only=True):
    data.append(row)
```

- `load_workbook('sales_data.xlsx')` loads the 'sales_data.xlsx' file.

- `sheet = workbook.active` selects the active sheet.

- `iter_rows(min_row=2, values_only=True)` reads data row by row, starting from the second row (`min_row=2`) to skip the header.

This code retrieves the Excel data as a list.

<br />

## Step 2: Creating a Word Document

Next, we use **python-docx** to create a new Word document and add a title and paragraph.

```python title="Creating a New Word Document"
from docx import Document

# Create a new Word document
doc = Document()
doc.add_heading('Sales Report', 0)
doc.add_paragraph('Below is the recent sales data.')
```

- `Document()` creates a new Word document.

- `add_heading('Sales Report', 0)` adds a title to the document.

- `add_paragraph('Below is the recent sales data.')` adds a paragraph to the document.

<br />

## Step 3: Adding Excel Data as a Table to the Word Document

We insert the data read from Excel into the Word document as a table.

```python title="Adding Excel Data as a Table to the Word Document"
# Create a table
table = doc.add_table(rows=1, cols=len(sheet[1]), style='Table Grid')

# Add headers to the first row of the table
hdr_cells = table.rows[0].cells
for i, heading in enumerate(sheet[1]):
    hdr_cells[i].text = str(heading.value)

# Add data to the table
for row in data:
    row_cells = table.add_row().cells
    for i, value in enumerate(row):
        row_cells[i].text = str(value)
```

- `doc.add_table(rows=1, cols=len(sheet[1]), style='Table Grid')` creates a table with the same number of columns as the Excel data.

- The first row of the table is populated with headers (e.g., Date, Product Name, etc.).

- The data is added row by row to the table using `table.add_row().cells`.

<br />

## Step 4: Saving the Document

After adding all the data, save the Word document.

```python title="Saving the Word Document"
# Save the document
doc.save('sales_report.docx')
```

This code saves the completed document as 'sales_report.docx'.

Reading Excel data using openpyxl is the first step. Only after retrieving the data can you proceed to add tables and text to the Word document.

import openpyxl
from pptx import Presentation
from io import BytesIO
from pptx.enum.shapes import MSO_SHAPE_TYPE

# Load the PowerPoint file
presentation = Presentation("input_file.pptx")

# Load the Excel file
wb = openpyxl.load_workbook("input_file.xlsx")
sheet = wb.active

# Create a list to store data
data_sets = []
for row in sheet.iter_rows(min_row=2, values_only=True):
    data = {
        "AWARD_NAME": row[0],
        "NAME": row[1],
        "CONTENT": row[2],
        "DATE": row[3],
        "ORGANIZATION": row[4],
    }
    data_sets.append(data)

# Use the first slide as a template
template_slide = presentation.slides[0]

# Copy slide elements
for data in data_sets:
    new_slide = presentation.slides.add_slide(template_slide.slide_layout)

    for shape in template_slide.shapes:
        # Process grouped shapes
        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
            for sub_shape in shape.shapes:
                if sub_shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
                    image_stream = sub_shape.image.blob
                    new_slide.shapes.add_picture(
                        BytesIO(image_stream), sub_shape.left, sub_shape.top, sub_shape.width, sub_shape.height
                    )
        # Process picture shapes
        elif shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
            image_stream = shape.image.blob
            new_slide.shapes.add_picture(
                BytesIO(image_stream), shape.left, shape.top, shape.width, shape.height
            )

        # Process text shapes
        elif shape.has_text_frame:
            new_shape = new_slide.shapes.add_textbox(shape.left, shape.top, shape.width, shape.height)
            new_shape.text_frame.clear()
            for paragraph in shape.text_frame.paragraphs:
                new_paragraph = new_shape.text_frame.add_paragraph()
                new_paragraph.text = paragraph.text
                new_paragraph.alignment = paragraph.alignment
                if len(paragraph.runs) > 0:
                    new_paragraph.font.size = paragraph.runs[0].font.size
                    new_paragraph.font.bold = paragraph.runs[0].font.bold
                    new_paragraph.font.italic = paragraph.runs[0].font.italic

        # Process basic shapes
        elif shape.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE:
            new_shape = new_slide.shapes.add_shape(
                shape.auto_shape_type, shape.left, shape.top, shape.width, shape.height
            )
            if shape.has_text_frame:
                new_shape.text = shape.text

    # Replace text with data
    for shape in new_slide.shapes:
        if shape.has_text_frame:
            for paragraph in shape.text_frame.paragraphs:
                if "<AWARD_NAME>" in paragraph.text:
                    paragraph.text = data["AWARD_NAME"]
                elif "<NAME>" in paragraph.text:
                    paragraph.text = data["NAME"]
                elif "<CONTENT>" in paragraph.text:
                    paragraph.text = data["CONTENT"]
                elif "<DATE>" in paragraph.text:
                    paragraph.text = data["DATE"]
                elif "<ORGANIZATION>" in paragraph.text:
                    paragraph.text = data["ORGANIZATION"]

# Remove the first slide (template slide)
presentation.slides._sldIdLst.remove(presentation.slides._sldIdLst[0])

# Save the final result to a file
presentation.save("output_file.pptx")

# Creating Completion Certificate Slides from Excel Data

In this lesson, we will read a PowerPoint template (`.pptx`) for certificates and an Excel file (`.xlsx`) containing student information to generate **new PowerPoint slides** that incorporate data from the Excel file.

> *Note*: If you are running the Python program provided for practice on your computer, ensure that both the `template PPT` (input_file.pptx) and `student information` (input_file.xlsx) files are in the same folder as the Python program.

<br />

## 1. Importing Required Libraries

```python title="Importing Libraries"
import openpyxl
from pptx import Presentation
from io import BytesIO
from pptx.enum.shapes import MSO_SHAPE_TYPE
```

- `openpyxl`: A Python library for reading and modifying Excel files.

- `pptx`: A library for creating and editing PowerPoint files.

- `io.BytesIO`: A class that allows byte data (composed of 0s and 1s) to be stored in memory and used as a file.

- `pptx.enum.shapes.MSO_SHAPE_TYPE`: Constants defining various shape types in PowerPoint, used to differentiate shapes, images, text boxes, etc.

<br />

## 2. Loading PowerPoint and Excel Files

```python title="Loading pptx and xlsx Files"
presentation = Presentation("input_file.pptx")
wb = openpyxl.load_workbook("input_file.xlsx")
sheet = wb.active
```

- `Presentation("input_file.pptx")`: Loads the PowerPoint file.

- `openpyxl.load_workbook("input_file.xlsx")`: Loads the Excel file.

- `wb.active`: Selects the first sheet of the Excel file.

<br />

## 3. Reading Data from Excel

```python title="Creating the data_sets List"
data_sets = []

for row in sheet.iter_rows(min_row=2, values_only=True):
    data = {
        "AWARD_NAME": row[0],
        "NAME": row[1],
        "CONTENT": row[2],
        "DATE": row[3],
        "ORGANIZATION": row[4],
    }
    data_sets.append(data)
```

- `sheet.iter_rows()`: Iterates through rows in the Excel sheet. Here, it starts from the second row (`min_row=2`).

- `values_only=True`: Directly retrieves cell values.

- `data_sets.append(data)`: Stores each row's data as a dictionary and adds it to the list.

<br />

## 4. Selecting a Slide Template

```python title="Selecting the Template Slide"
template_slide = presentation.slides[0]
```

- `presentation.slides[0]`: Selects the first slide in the PowerPoint file as the template. This slide is used to generate new slides.

<br />

## 5. Copying Slides and Processing Images and Text

```python title="Copying Slide Elements"
for data in data_sets:
    # Create a new slide by copying the template slide
    new_slide = presentation.slides.add_slide(template_slide.slide_layout)

    for shape in template_slide.shapes:
        # Processing grouped shapes
        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
            for sub_shape in shape.shapes:
                if sub_shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
                    # ...omitted...
        
        # Processing picture shapes
        elif shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
            image_stream = shape.image.blob
            # ...omitted...

        # Processing text shapes
        elif shape.has_text_frame:
            new_shape = new_slide.shapes.add_textbox(shape.left, shape.top, shape.width, shape.height)
            new_shape.text_frame.clear()

            # Copy text
            for paragraph in shape.text_frame.paragraphs:
                new_paragraph = new_shape.text_frame.add_paragraph()
                # ...omitted...
```

- `presentation.slides.add_slide()`: Adds a new slide based on the template slide.

- `shape.shape_type == MSO_SHAPE_TYPE.GROUP`: Processes grouped shapes by handling individual shapes within the group.

- `shape.shape_type == MSO_SHAPE_TYPE.PICTURE`: Copies images from the template slide to the new slide.

- `shape.has_text_frame`: Copies text shapes by creating a new text box and transferring the text, maintaining font size, boldness, and italics.

<br />

## 6. Replacing Text with Excel Data

```python title="Replacing Text with Data"
for shape in new_slide.shapes:
    if shape.has_text_frame:
        for paragraph in shape.text_frame.paragraphs:
            if "<AWARD_NAME>" in paragraph.text:
                paragraph.text = data["AWARD_NAME"]
            elif "<NAME>" in paragraph.text:
                paragraph.text = data["NAME"]
            elif "<CONTENT>" in paragraph.text:
                paragraph.text = data["CONTENT"]
            elif "<DATE>" in paragraph.text:
                paragraph.text = data["DATE"]
            elif "<ORGANIZATION>" in paragraph.text:
                paragraph.text = data["ORGANIZATION"]
```

- Replaces specific placeholders (e.g., `<AWARD_NAME>`) in the PowerPoint slides with corresponding Excel data.

<br />

## 7. Removing the Template Slide and Saving the Result

```python title="Removing Template Slide and Saving"
presentation.slides._sldIdLst.remove(presentation.slides._sldIdLst[0])
presentation.save("output_file.pptx")
```

- `_sldIdLst.remove()`: Deletes the initial template slide. This is an unofficial method to remove the first slide from the PowerPoint slide list.

- `presentation.save()`: Saves the final result as `output_file.pptx`.

<br />

## Summary of the Workflow

1. Read data from the Excel file.

2. Use the first slide as a template and insert data from the Excel file into new slides.

3. Copy text and images from the template slide, replacing text with Excel data.

4. Remove the template slide and save the final result as a file.

Demo

Printing Output in Python

How Do You Use It?

Printing Multiple Data Items at Once

Coding Practice

Complete the function to display data on the screen in Python.

Loved the Demo? Let's Keep Building.

For Individuals

For Institutions