6 lessons 32 practices

Iterations and Loops in Python

Saddle up for a thrilling ride through Python’s looping mechanisms! This course is ingeniously crafted to make you loop literate. By the end of this adventure, you’ll be spinning through data with for and while loops, and streamlining code with Pythonic iteration patterns.

Lesson 1: The Interstellar For Loop Journey: Traversing Collections With Ease in Python

Introduction to The For Loop Journey

Welcome! In programming, just like playing a favorite song on repeat, loops execute code repeatedly. Here, we’ll explore the “For Loop” in Python, an iteration construct over sequences such as lists or strings.

Imagine a train journey: the train represents our loop, stopping at each station. Each station represents an item on its route, which is the iterable.

欢迎！在编程中，就像重复播放最喜欢的歌曲一样，循环重复执行代码。在这里，我们将探索Python中的“For Loop”，这是对列表或字符串等序列的迭代构造。

想象一次火车旅行：火车代表我们的循环，停在每个车站。每个车站代表其路线上的一个项目，即可迭代的。

Understanding the Concept of Loops

Like replaying a song or game level, a loop continually executes a block of code until a defined condition is met. It’s akin to saying, “Keep the popcorn machine running as long as the popcorn keeps popping!”

就像重播歌曲或游戏关卡一样，循环不断地执行代码块，直到满足定义的条件。这就像说：“只要爆米花一直在爆炸，就保持爆米花机运行！”

Introduction to For Loops in Python

A Python For Loop looks like this:

1
2
3

for variable in iterable_object:
    # executable code

In this construct, for and in are keywords. The variable holds the current item in each iteration, while iterable_object can be a list, string, or any object that provides an item sequentially.

Let’s print all elements of a list:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# List of planets
planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']

# Print each planet
for planet in planets:
  print(planet)
"""
Prints:
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
""" 

This code will print every planet from the list (Mercury, Venus, Earth, …), each on a separate line.

Riding through Python For Loops: Lists and Sets

Let’s delve further into For Loops by printing each number from a list:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# List of numbers
numbers = [1, 2, 3, 4, 5]

# Print each number
for num in numbers:
  print(num)
"""
Prints:
1
2
3
4
5
"""

The same works for sets:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Set of numbers
numbers = {1, 2, 5, 4, 3}

# Prints each number in the set
for num in numbers:
  print(num)
"""
Prints:
1
2
3
4
5
"""

Note that because sets are unordered, results might appear in any order.

Riding through Python For Loops: Strings

Strings in Python are also iterable, meaning we can iterate over each character:

Python中的字符串也是可迭代的，这意味着我们可以迭代每个字符：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# A string
word = "Python"

# Print each character
for letter in word:
  print(letter)
"""
Prints:
P
y
t
h
o
n
"""

Riding through Python For Loops: Dictionaries

Finally, you can also iterate over dictionaries, traversing all its keys: 最后，您也可以遍历字典，遍历其所有键：

1
2
3
4

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
    print(key)

Output:

1
2
3
4

a
b
c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# A dictionary
fruit_colors = {'Apple': 'Red', 'Banana': 'Yellow', 'Grape': 'Purple'}

# Printing fruit's color for each fruit key in the dictionary
for fruit in fruit_colors:
    print("The color of", fruit, "is", fruit_colors[fruit])
"""
Prints:
The color of Apple is Red
The color of Banana is Yellow
The color of Grape is Purple
"""

「practice」Revealing the Years of Notable Space Missions

Astronaut, we’ve received a transmission that has decrypted the years of key space missions! Look! We have a list, mission_years.

I created a code that uses our trusted Python skills with a For Loop to print out each year. Are you ready for the revelation? Click Run to see them appear!

宇航员，我们接收到了一个解密了关键太空任务年份的传输！看！我们有一份清单，任务年份。 我创建了一个代码，它使用我们信赖的Python技能，通过一个for循环来打印出每一年。你准备好迎接这个启示了吗？点击运行，就可以看到它们出现！(kimi翻译)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

 we've received a transmission that has decrypted the years of key space missions! Look! We have a list, mission_years.
I created a code that uses our trusted Python skills with a For Loop to print out each year. Are you ready for the revelation? Click Run to see them appear!

# List of numbers representing space mission years
mission_years = [1961, 1962, 1969, 1971, 1981, 1990, 1998, 2001, 2010]

# Using a For Loop to print each year when a notable space mission occurred
for year in mission_years:
    print("A notable space mission occurred in the year:", year)
 _______________

# List of numbers representing space mission years
mission_years = [1961, 1962, 1969, 1971, 1981, 1990, 1998, 2001, 2010]

# Using a For Loop to print each year when a notable space mission occurred
for year in mission_years:
    print("A notable space mission occurred in the year:", year)
_______________

「practice」Star Coordinates Calculation Fix

Let’s continue with our interstellar exploration. It seems that a minor bug has surfaced in our calculation of star coordinates. At the moment, the total output of the stars’ coordinates is incorrect. Could you identify and rectify this issue?

Onward to glory and beyond!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

It seems that a minor bug has surfaced in our calculation of star coordinates. At the moment, the total output of the stars' coordinates is incorrect. Could you identify and rectify this issue?
___________

# List representing star coordinates in space
stars = [1, 2, 3, 4, 5]

# Initialize sum
sum_coords = 0

# Add each star coordinate to sum_coords
for coord in stars:
  sum_coords = coord

# Print sum
print("The sum of star coordinates is", sum_coords)
_______________

The issue in your Python code arises from the way the sum of the coordinates is being calculated within the loop. Currently, the loop is replacing the value of sum_coords with each coord in the list stars, rather than adding each coord to the existing total of sum_coords. This results in sum_coords containing only the last coordinate value from the list, rather than the sum of all coordinates.

Here’s how you can fix the code to correctly calculate the sum of the star coordinates:

1 2 3 4 5 6 7 8 9 10 11 12

# List representing star coordinates in space stars = [1, 2, 3, 4, 5] # Initialize sum sum_coords = 0 # Add each star coordinate to sum_coords for coord in stars: sum_coords += coord # This line is corrected to add each coord to sum_coords # Print sum print("The sum of star coordinates is", sum_coords)

With this correction (sum_coords += coord), each coordinate in the list stars is added to the total sum_coords. When you run this corrected code, it will output the correct sum of the coordinates:

1	The sum of star coordinates is 15

This sum is the result of adding 1 + 2 + 3 + 4 + 5. This should resolve the issue and correctly calculate the total output of the stars’ coordinates.

「practice」Space Race: Finding the Fastest Spaceship

Bingo, Space Adventurer! Let’s make a small detour. In the provided code snippet, your task is to find the top speed from our list of spaceship speeds. You are required to replace the placeholder and complete the loop.

Remember, we have many more galaxies to explore!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# List of spaceship speeds in km/s
speeds = {28, 50, 120, 75, 98}

# Initialize variable
fastest_speed = 0

# TODO: Write a loop to go through each speed in the list.

# If the speed element from the list is faster than the current 'fastest_speed', update 'fastest_speed' to this new speed.

# Print the fastest speed
print("The fastest spaceship speed is", fastest_speed, "km/s.")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

 Let's make a small detour. In the provided code snippet, your task is to find the top speed from our list of spaceship speeds. You are required to replace the placeholder and complete the loop.
 _____________
 # List of spaceship speeds in km/s
speeds = {28, 50, 120, 75, 98}

# Initialize variable
fastest_speed = 0

# TODO: Write a loop to go through each speed in the list.

# If the speed element from the list is faster than the current 'fastest_speed', update 'fastest_speed' to this new speed.

# Print the fastest speed
print("The fastest spaceship speed is", fastest_speed, "km/s.")
_________________

Here’s the completed version of your code snippet with the loop implemented to find the fastest speed from the list of spaceship speeds:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# List of spaceship speeds in km/s speeds = {28, 50, 120, 75, 98} # Initialize variable fastest_speed = 0 # Loop through each speed in the set for speed in speeds: # If the current speed is faster than the 'fastest_speed', update it if speed > fastest_speed: fastest_speed = speed # Print the fastest speed print("The fastest spaceship speed is", fastest_speed, "km/s.")

This code correctly iterates over the set of speeds, compares each speed with the current fastest_speed, and updates fastest_speed if a faster speed is found. Finally, it prints the fastest speed from the list.

「practice」Unveiling the List of Earth-Like Planets

Excellent work, Space Explorer!

Let’s give it another go! There are some space suit models out there.

Can you traverse the suits dictionary and calculate the total weight of all suits there? Give it a try!

1
2
3
4
5
6
7
8

# Dictionary of space suits and their weights in kg
space_suit_weights = {'Mercury suit': 21, 'Gemini suit': 16, 'Apollo suit': 32, 'Space Shuttle suit': 50}

total_weight = 0

# TODO: Use a For Loop to calculate the total weight of all space suits
print('Total suits weight:', total_weight)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Let's give it another go! There are some space suit models out there.
Can you traverse the suits dictionary and calculate the total weight of all suits there? Give it a try!
__________

# Dictionary of space suits and their weights in kg
space_suit_weights = {'Mercury suit': 21, 'Gemini suit': 16, 'Apollo suit': 32, 'Space Shuttle suit': 50}

total_weight = 0

# TODO: Use a For Loop to calculate the total weight of all space suits
print('Total suits weight:', total_weight)
__________

To calculate the total weight of all space suits in the dictionary space_suit_weights, you need to iterate over the values of the dictionary and sum them up. Here’s how you can modify the code snippet to achieve this:

要计算字典space_suit_weights中所有太空服的总重量，您需要遍历字典的值并将它们相加。以下是如何修改代码片段以实现此目的：

1 2 3 4 5 6 7 8 9

# Dictionary of space suits and their weights in kg space_suit_weights = {'Mercury suit': 21, 'Gemini suit': 16, 'Apollo suit': 32, 'Space Shuttle suit': 50} total_weight = 0 # Use a For Loop to calculate the total weight of all space suits for weight in space_suit_weights.values(): total_weight += weight print('Total suits weight:', total_weight)

This code correctly sums up the weights of all the suits in the space_suit_weights dictionary and prints the total weight.

此代码正确求和space_suit_weights字典中所有套装的重量并打印总重量。

「practice」Charting the Orbits of Planets

Take a look at these planets and their orbits. Your next task is to print the name of each planet along with its orbit period in Earth days. Are you ready, Space Explorer?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# List of planets
planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']

# A dictionary of orbit periods (days) for planets
orbit_periods = {
    'Mercury': 88,
    'Venus': 225,
    'Earth': 365,
    'Mars': 687,
    'Jupiter': 4333,
    'Saturn': 10759,
    'Uranus': 30687,
    'Neptune': 60190,
}

# TODO: For each planet in the 'planets' list, print the name of the planet

# and its orbit period in Earth days, from the 'orbit_periods' dictionary.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Take a look at these planets and their orbits. Your next task is to print the name of each planet along with its orbit period in Earth days. Are you ready, Space Explorer?
_______

# List of planets
planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']

# A dictionary of orbit periods (days) for planets
orbit_periods = {
    'Mercury': 88,
    'Venus': 225,
    'Earth': 365,
    'Mars': 687,
    'Jupiter': 4333,
    'Saturn': 10759,
    'Uranus': 30687,
    'Neptune': 60190,
}

# TODO: For each planet in the 'planets' list, print the name of the planet

# and its orbit period in Earth days, from the 'orbit_periods' dictionary.
_______

It looks like there’s a typo in the list of planets in your Python code snippet. The planet ‘Uranus’ is missing an opening quotation mark. Here’s the corrected version:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

> # List of planets
> planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']
> 
> # A dictionary of orbit periods (days) for planets
> orbit_periods = {
>     'Mercury': 88,
>     'Venus': 225,
>     'Earth': 365,
>     'Mars': 687,
>     'Jupiter': 4333,
>     'Saturn': 10759,
>     'Uranus': 30687,
>     'Neptune': 60190,
> }
> 
> # For each planet in the 'planets' list, print the name of the planet and its orbit period in Earth days
> for planet in planets:
>     print(f"{planet}: {orbit_periods[planet]} days")

Now, the list of planets is correctly formatted, and this script should work without syntax errors.

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

> Mercury: 88 days
> Venus: 225 days
> Earth: 365 days
> Mars: 687 days
> Jupiter: 4333 days
> Saturn: 10759 days
> Uranus: 30687 days
> Neptune: 60190 days
> ```

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# [Lesson 2: Navigating For Loops in Python: Deep Dive into Range and Enumerate](https://learn.codesignal.com/preview/lessons/149)

Blast off! We're about to explore the exciting world of `range()` and `enumerate()`, co-steering our for loop spaceship! 🚀 Let's navigate through this together and get started on this interstellar journey!

Introduction to Range and Enumerate in For Loops

Greetings, Explorer! In today's adventure, we're traversing the vast expanse of `range()` and `enumerate()`. These two functions will serve as your co-pilots, guiding your spaceship, the for loop, through the expansive universe of Python. We're set to delve into each function, uncovering hands-on examples and real-life applications.

你好，探险家！在今天的冒险中，我们将穿越range（）和enumerate（）的广阔领域。这两个函数将作为你的共同飞行员，引导你的飞船for循环穿越广阔的Python宇宙。我们将深入研究每个函数，揭示动手示例和实际应用。

Exploring the Range Function

Our first destination is the planet `range()`. This Python function generates a sequence of numbers, which are pivotal when directing a loop a specified number of times.

The `range()` function can accept three different sets of parameters:

- `range(stop)`: generates numbers from `0` to `stop - 1`.
    
- `range(start, stop)`: generates numbers from `start` to `stop - 1`.
    
- `range(start, stop, step)`: generates numbers from `start` to `stop - 1` in steps of `step`.
    

The `start` parameter specifies the starting point of the sequence, `stop` marks the endpoint (which isn't included in the sequence), and `step` is the increment amount for the sequence. By default, `start` is `0`, and `step` is `1`.

> **Title:** Iterations and Loops in Python
> 
> **Starred Blocks:**
> 
> * The `start` parameter specifies the starting point of the sequence.
> * The `stop` parameter marks the endpoint (which isn't included in the sequence).
> * The `step` parameter is the increment amount for the sequence.
> 
> **Default Values:**
> 
> * If `start` is not specified, it defaults to `0`.
> * If `step` is not specified, it defaults to `1`.

我们的第一个目标是行星range（）。这个Python函数生成一个数字序列，当引导一个循环指定次数时，这是关键的。

range（）函数可以接受三组不同的参数：

range（stop）：生成从0到stop-1的数字。

range（start， stop）：从开始到停止生成数字-1。

range（start， stop，step）：从开始到停止生成数字-步长为1。

start参数指定序列的起点，stop标记终点（不包含在序列中），step是序列的增量。默认情况下，start为0，step为1。

Range Function: Examples

Let's see it in action with a simple `for loop`.

```Python

for i in range(5):
    print(i)

1
2
3
4
5
6

0
1
2
3
4

The range(5) command generates numbers from 0 to 4.

Now, let’s experiment with a different value for start and a step:

1
2
3

for i in range(1, 10, 2):
    print(i)

Output:

1
2
3
4
5
6

1
3
5
7
9

As you can see, the above code starts at 1 and goes up to 9, but it only prints every second number due to the step of 2.

如您所见，上面的代码从1开始，一直到9，但由于2的步骤，它只打印每秒钟的数字。

Enumerate: Indexing the Elements

Our next stop is galaxy enumerate(). This function serves as our real-time radar when voyaging through a list, as it provides both the index and value of each item. Here’s how:

1
2
3
4
5

check_points = ['start', 'midpoint', 'end']

for index, check_point in enumerate(check_points):
    print('At index', index, 'we are at the', check_point, 'of the journey.')

Output:

1
2
3
4

At index 0 we are at the start of the journey.
At index 1 we are at the midpoint of the journey.
At index 2 we are at the end of the journey.

It gives both the index (index) and corresponding checkpoint (check_point) in the journey.

Range Function: Use Case

Time to dock range() and enumerate() together on one spaceship! To illustrate their combined use, let’s consider a group of space cadets and their corresponding IDs.

1
2
3
4
5
6
7
8

cadets = ["Neo", "Trinity", "Morpheus", "Agent Smith"]
ids = [101, 102, 103, 104]

for i in range(len(cadets)):
    print('Cadet', cadets[i], 'has id', ids[i])
for i, cadet in enumerate(cadets):
    print('Cadet', cadet, 'has id', i)

Here, range(len(cadets)) creates indices for the list cadets from 0 to len(cadets) - 1, allowing us to access both cadets and ids.

Conclusion: Mastery Check and Recap

Great work, Space Explorer! You’ve decoded the mysteries of range() and enumerate(), preparing yourself for a robust for loop journey through your Python universe. Solidify your skills with some practice tasks and build confidence in your newly acquired expertise. Happy coding!

干得好，太空探险家！你已经破译了range（）和enumerate（）的奥秘，为穿越Python宇宙的强大for循环之旅做好了准备。通过一些练习任务巩固你的技能，并对你新获得的专业知识建立信心。快乐编码！

「practice」Exploring Space with Enumerate and Range

Welcome back, Space Explorer!

Now that we’ve finished learning about the enumerate() and range() functions let’s apply that knowledge to a practical scenario. We possess a list of space objects that we intend to iterate over in two distinct ways: using the enumerate() and range() functions.

But don’t worry, I’ve already made all the necessary arrangements for you. Your task is simply to click Run and observe.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

space_objects = ['Sun', 'Earth', 'Moon', 'Mars', 'Jupiter']

# Enumerate the space_objects list and print each object with its index
for index, space_object in enumerate(space_objects):
    print('The object at index', index, 'is', space_object)

print()

# Use the range function to iterate over space_objects in reverse order

# Start from the last element, and make the negative step to get to the previous element
for i in range(len(space_objects) - 1, -1, -1):
    print('The object at index', i, 'is', space_objects[i])

Output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

The object at index 0 is Sun  
The object at index 1 is Earth  
The object at index 2 is Moon  
The object at index 3 is Mars  
The object at index 4 is Jupiter  
  
The object at index 4 is Jupiter  
The object at index 3 is Mars  
The object at index 2 is Moon  
The object at index 1 is Earth  
The object at index 0 is Sun

You’re diving into a hands-on exploration of Python’s enumerate() and range() functions by applying them to iterate over a list of space objects like the Sun, Earth, Moon, Mars, and Jupiter. Your setup aims to demonstrate two approaches: the direct association of indices and objects using enumerate(), and the manual control of index order using range() for reverse iteration.

The code you’ve presented provides an excellent practical demonstration of these concepts:

1. Using enumerate(): This part of your code uses the enumerate() function to loop through space_objects. It automatically provides each item with its corresponding index, enhancing readability and reducing the risk of off-by-one errors which are common in manual index handling.

2. Using range(): This section leverages the range() function to iterate over the indices of space_objects in reverse order. It starts from the last element (index len(space_objects) - 1) and decrements the index until it reaches 0 (the step is -1). This method is particularly useful when you need to traverse a list backwards, but want to maintain access to the indices for operations like reordering or specific access patterns.

By running the provided code, you’ll see a straightforward output showing the index and the associated space object for each position, first in natural order and then in reverse. This kind of iteration can be crucial for tasks that require specific order processing, such as reversing data, creating stacks, or simply when the logic depends on the position of the elements within a list. 你正在深入实践探索Python的enumerate()和range()函数，通过将它们应用于遍历太阳、地球、月亮、火星和木星等空间对象的列表。你的设置旨在展示两种方法：使用enumerate()直接关联索引和对象，以及使用range()手动控制索引顺序以进行反向迭代。

你提供的代码为这些概念提供了一个很好的实践演示：

1. 使用enumerate()：这部分代码使用enumerate()函数遍历space_objects。它自动为每个项目提供相应的索引，增强了可读性，并减少了手动索引处理中常见的偏移误差。
2. 使用range()：这一节利用range()函数反向迭代space_objects的索引。它从最后一个元素（索引len(space_objects) - 1）开始，并递减索引直到达到0（步长是-1）。当你需要反向遍历列表，但希望保持对索引的访问以进行排序或特定访问模式的操作时，这种方法特别有用。 通过运行提供的代码，你将看到一个简单的输出，显示每个位置的索引和相关联的空间对象，首先是自然顺序，然后是反向。这种迭代对于需要特定顺序处理的任务至关重要，例如反转数据、创建栈，或者简单地当逻辑依赖于列表中元素的位置时。

Your solution is spot on! Stellar job applying your knowledge of enumerate() and range() functions.

Starred Blocks:

Starred blocks are used to unpack collections into individual variables. They can be used with the enumerate() and range() functions.

enumerate() function:

The enumerate() function takes an iterable (such as a list, tuple, or string) and returns an object that provides both the index and the value of each element. This can be useful for iterating over a collection and keeping track of the current index.

1
2
3
4
5

my_list = [1, 2, 3, 4, 5]

for index, value in enumerate(my_list):
  print(f"Index: {index}, Value: {value}")

Output:

1
2
3
4
5
6

Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5

range() function:

The range() function generates a sequence of numbers within a specified range. It can be used to create a loop with a fixed number of iterations.

1
2
3

for i in range(5):
  print(i)

Output:

1
2
3
4
5
6

0
1
2
3
4

You can also specify a starting and ending point for the range:

1
2
3

for i in range(2, 7):
  print(i)

Output:

1
2
3
4
5
6

2
3
4
5
6

Example using both enumerate() and range():

1
2
3
4
5
6

my_list = ["apple", "banana", "cherry", "dog", "elephant"]

for index, value in enumerate(my_list):
  if index >= 2 and index < 4:
    print(f"Index: {index}, Value: {value}")

Output:

1
2
3

Index: 2, Value: cherry
Index: 3, Value: dog

Ready for the next challenge? 🚀 你的解决方案非常准确！在应用 enumerate() 和 range() 函数的知识方面做得很棒。准备好迎接下一个挑战了吗？🚀

「practice」Changing Civilizations to Cosmic Objects

Fantastic! Now, it’s time for a minor adjustment. Instead of traversing the list using the range function, change the code to use enumerate, doing the same thing. 太棒了！现在，是时候进行一个小调整了。不要使用range函数遍历列表，而是将代码改为使用enumerate，做同样的事情。 You can do it! Let’s go!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

cosmic_objects = ['Nebula', 'Black Hole', 'Galaxy']

  

# Use the enumerate function to iterate over cosmic_objects

for index in range(len(cosmic_objects)):

print("Object", index + 1, "in my list is", cosmic_objects[index])

Output

1
2
3
4

Object 1 in my list is Nebula  
Object 2 in my list is Black Hole  
Object 3 in my list is Galaxy

Good try, but it looks like there’s a mix-up. The task was to use the enumerate function to iterate over the list, but your code still uses range. Remember, with enumerate, you get both the index and the item itself in the loop. How about giving it another shot? Need a hint?

RaR-GPT

It seems you are trying to refactor your code snippet to use the Python enumerate function for iterating over items in a list, while also accessing their indices. The enumerate function is very useful for this because it automatically provides a counter alongside the value from the iterable (like a list), which simplifies the loop and makes the code more Pythonic compared to using range and indexing. Here’s how you can correctly use the enumerate function for your list of cosmic objects:您似乎正在尝试重构代码片段以使用 Python enumerate 函数来迭代列表中的项目，同时还访问它们的索引。 enumerate 函数对此非常有用，因为它会自动在可迭代的值（如列表）旁边提供一个计数器，这简化了循环并使代码比使用 range 更Pythonic b2> 和索引。以下是如何正确使用 enumerate 函数来获取宇宙天体列表：

1
2
3
4
5
6

cosmic_objects = ['Nebula', 'Black Hole', 'Galaxy']

# Using the enumerate function to iterate over cosmic_objects
for index, obj in enumerate(cosmic_objects, start=1):
    print("Object", index, "in my list is", obj)

This version of the code uses enumerate directly on the list cosmic_objects. Notice that I added the start=1 argument to enumerate so that indexing starts from 1 instead of the default 0. This aligns the displayed index numbers with the way you formatted your output in your original snippet, making it easier to read and understand in contexts where indexing traditionally starts from 1.此版本的代码直接在列表 cosmic_objects 上使用 enumerate 。请注意，我将 start=1 参数添加到 enumerate 中，以便索引从 1 而不是默认的 0 开始。这会将显示的索引号与您在原始代码段中格式化输出的方式对齐，使得在传统上索引从 1 开始的上下文中更容易阅读和理解。

「practice」Planetary Index Error Fix

Greetings, Space Voyager!

The names of planets are stored in our database. However, something seems amiss. When we attempt to list the names alongside their corresponding index, an error appears. Could you assist us in resolving this issue? 问候，太空航行者！ 行星的名称存储在我们的数据库中。然而，似乎有些不对劲。当我们尝试列出名称及其对应的索引时，出现了一个错误。您能帮助我们解决这个问题吗？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

  

# Enumerate the planets list and print each planet with its index

for index, planet in range(planets):

print("The planet at index", index, "is", planet)

It looks like you are trying to iterate over the list of planets and print each planet’s name and index position. However, there’s a small mistake in the loop statement which is causing an error.![[8D4474F3-F517-426B-A81D-6BB307C9D03F.jpeg]] You need to use the enumerate function to correctly loop through the list with both index and the corresponding value. Here’s how you can correct and enhance your code snippet to achieve this: 看起来你正尝试遍历行星列表并打印每个行星的名称以及它的索引位置。然而，循环语句中有一个小错误导致了一个错误。你需要使用 enumerate 函数来正确地遍历列表，同时获取索引和相应的值。以下是你可以如何修正并改进你的代码片段以达到这个目的：(kimi免费翻译)

1
2
3
4
5

> planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']
> 
> # Enumerate the planets list and print each planet with its index
> for index, planet in enumerate(planets):
>     print("The planet at index", index, "is", planet)

In this corrected version, I’ve used the enumerate function, which is designed to return both the index and the value when iterating over a list. This will resolve the error and successfully output each planet with its corresponding index. 在这次修正的版本中，我使用了enumerate函数，它被设计为在迭代列表时返回索引和值。这将解决错误并成功输出每个行星及其对应的索引。(kimi免费翻译)

「practice」Contemplating the Constellations: Indexing and Iterating Star Names

Excellent work so far, Star Navigator!

Your next mission involves arranging our list of stars in two distinct ways, utilizing the functions we’ve learned. Be attentive! You must complete the sections marked with TODOs.

Iterate through the given list using enumerate in direct order and using range in reverse order.

Good luck, Cosmos Conqueror!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

stars = ["Sun", "Polaris", "Betelgeuse", "Sirius", "Vega"]

  

# TODO: Enumerate over the stars list and print each star with its index

for index, star in enumerate(___):

# Star indices should start with 1: 1, 2, 3, ...

print("Star", ___, "in my list is", ___)

  

# TODO: Use the range function to iterate over the stars list **in reverse order**

# and print each star with its index

for i in range(___, ___, ___):

# Star indices should start with 1: len(stars), len(stars) - 1, ..., 1

print("Star", ___, "in my list is", ___)

Alright, let’s break down your tasks into clear steps and then provide the Python code to achieve your goals.

Task 1: Enumerate the Stars List with Indices Starting from 1

You need to iterate over the list of stars, stars = ["Sun", "Polaris", "Betelgeuse", "Sirius", "Vega"], and print each star with its index, where indexing should start from 1 instead of the default 0. Python’s enumerate() function starts indexing from 0 by default, but you can adjust the starting index by providing a second argument.

Here’s how you can accomplish this:

1
2
3
4
5

stars = ["Sun", "Polaris", "Betelgeuse", "Sirius", "Vega"]

# Enumerate over the stars list and print each star with its index starting from 1
for index, star in enumerate(stars, start=1):
   print("Star", index, "in my list is", star)

Task 2: Iterate Over the Stars List in Reverse Order Using Range

Now, you want to iterate over the same list in reverse order and also print each star with its index, which should be counted backwards from the length of the list. You can use the range() function for this, which allows you to specify the start, stop, and step. To iterate in reverse, you set the start at the last index (length of the list), stop before the index 0, and use a negative step.

Here’s the code for this:

1
2
3
4
5
6

# Use the range function to iterate over the stars list in reverse order

# and print each star with its index
 for i in range(len(stars), 0, -1):
     print("Star", i, "in my list is", stars[i-1])

Both of these tasks utilize Python’s powerful enumeration and iteration capabilities to manage lists effectively. Each snippet accomplishes a specific arrangement and presentation of the data in your list of celestial names. Enjoy navigating through the cosmos with your Python skills!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

stars = ["Sun", "Polaris", "Betelgeuse", "Sirius", "Vega"]

# Enumerate over the stars list and print each star with its index starting from 1
for index, star in enumerate(stars, start=1):
    print("Star", index, "in my list is", star)

# Use the range function to iterate over the stars list in reverse order

# and print each star with its index
for i in range(len(stars), 0, -1):
    print("Star", i, "in my list is", stars[i-1])

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Star 1 in my list is Sun  
Star 2 in my list is Polaris  
Star 3 in my list is Betelgeuse  
Star 4 in my list is Sirius  
Star 5 in my list is Vega  
Star 5 in my list is Vega  
Star 4 in my list is Sirius  
Star 3 in my list is Betelgeuse  
Star 2 in my list is Polaris  
Star 1 in my list is Sun

「practice」Generating and Enumerating the First Letters of Planetary Names

Excellent work, Space Explorer! Now, let’s construct a program to explore our planetary systems even more. Please write a program that generates a list of the initial letters from all the planet names and then utilizes the enumerate function to display each letter accompanied by its index number on the console.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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

first_letters = []

  

# TODO: Write a for loop with a range to iterate through each planet in the planets list.

# Inside the loop, add the first letter of each planet to the first_letters list.

  

# TODO: Write a for loop using enumerate to print out each first letter and its corresponding planet index.

It seems like you’re interested in developing a program that not only lists the initial letters of planet names but also uses Python’s enumerate function to pair these letters with their indices for better visualization and understanding. This approach allows for an engaging way to explore planetary names in a programming context.

Here’s a Python program that will achieve your objectives. The program starts by extracting the first letter from each planet’s name and storing these in a list. Then, it utilizes the enumerate function to iterate through this list, printing both the index and the letter, thus providing a clear, indexed list of the first letters of the planetary names.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# List of planet names
planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

# Initialize an empty list to store the first letters
first_letters = []

# Iterate through each planet in the planets list
for planet in planets:
    # Add the first letter of each planet to the first_letters list
    first_letters.append(planet[0])

# Use enumerate in a for loop to print out each first letter with its corresponding index
for index, letter in enumerate(first_letters):
    print(f"{index}: {letter}")

1
2
3
4
5
6
7
8
9

0: M  
1: V  
2: E  
3: M  
4: J  
5: S  
6: U  
7: N

In this code:

• We iterate over each planet in the planets list and extract the first character using indexing (planet[0]).
• These characters are then added to the first_letters list.
• The enumerate function is used to loop over first_letters, providing both the index and the value (letter). Each pair is printed in a formatted string that shows the index followed by the corresponding letter.

This will output the index and the first letter of each planet, facilitating a straightforward way to reference them by their position in the list.

Lesson 3: Embarking on the While Loop Journey: Steering Through Python’s Control Flow Mechanics

「practice」Exploration of Earth Using a While Loop

Alright, we’re about to unlock the mystery of While Loops in Python! Such an important mission ahead. Let’s crush it together! 💪

Topic Overview and Actualization

Let’s buckle up for our journey into the fascinating world of While Loops. Visualize piloting a spaceship on an uncharted route, making a pit stop at every interesting planet until you find the one that harbors intelligent life. This adventure encapsulates what While Loops do: they continue running tasks until a specific condition changes. In this lesson, we aim to master the usage of While Loops, understand the concept of ‘indefinite iteration’, and control the loop’s execution effectively.

While Loop Discovery

A while loop allows the code to execute repeatedly based on a specific condition. If the condition remains True, it continues to run, similar to an if statement. Let’s look at a while loop that counts from 1 to 5:

1
2
3
4
5

count = 1
while count <= 5:
    print(count) # Will print numbers from 1 to 5, inclusive
    count += 1

The output of the code is:

1
2
3
4
5
6

1
2
3
4
5

Here’s the basic structure of a while loop:

1
2
3

while condition:
    # code to be executed

In our example, count <= 5 is the condition, and print(count); count += 1 is the code to be executed. As long as the condition count <= 5 holds True, the loop repeats and eventually prints numbers from 1 to 5, inclusive.

Journey through the While Loop Galaxy

Let’s delve into the intricacies of While Loops:

1. Firstly, Python checks if the while loop’s condition is True.
2. If the condition is True, it executes the loop’s code.
3. Then, it cycles back to the first step.

This continues until the condition becomes False.

Steering the While Loop Spaceship - Control Flow

While writing a while loop, make sure the loop’s condition eventually turns False to avoid infinite loops. An infinite loop could potentially crash your system. Here’s an example:

1
2
3
4
5
6

# INFINITE LOOP EXAMPLE - DO NOT RUN!
count = 1
while count <= 5: 
    print(count) # Always prints 1
    # Forgetting to increment count results in an infinite loop.

To prevent such a catastrophe, we often use the break statement. The break statement provides an escape hatch, immediately terminating the loop it’s in. We will cover the break operator more extensively later in this course.

The Universe of Indefinite Iteration

while loops offer indefinite iteration, repeating an unknown number of times until a specific goal is achieved. This real-life example demonstrates it:

1
2
3
4
5
6
7

score = 0
while score < 10:
    score += 2
    print("Current score: ", score)
    if score == 10:
        print("You won the game!")

1
2
3
4
5
6
7

Current score: 2
Current score: 4
Current score: 6
Current score: 8
Current score: 10
You won the game!

In this game, your score starts at 0. Every loop iteration increments your score by 2, until you reach a score of 10, at which point you win the game!

Note that if we check for score == 9, this loop will never print the “You won the game!” string.

Lesson Summary

Excellent work! You have just experienced the magic of While Loops! Be observant when crafting While Loops to avoid the dreaded infinite loops.

Now is the time to put your skills to use in the hands-on exercises. You’ll be crafting your while loops, integrating the lessons we’ve learned together. Remember, practice is key to refining your skills! So, wield your coding wand and take on the exercise. If you get stuck, don’t hesitate to ask for help. Happy coding!

「practice」Adjusting Cruise Distance While Approaching Saturn

Alright, Space Wanderer! Let’s get started on our While Loop space mission! We’re staying around Earth, exploring it year by year until we reach 2030.

Observe how Python repeats the print statement as it thoroughly explores the while loop — the starship of our course!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Space Exploration

planet = "Earth"

year = 2022

while year < 2030:

print("Exploring the planet", planet, "in the year", year)

year += 1

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

  

Exploring the planet Earth in the year 2022  
Exploring the planet Earth in the year 2023  
Exploring the planet Earth in the year 2024  
Exploring the planet Earth in the year 2025  
Exploring the planet Earth in the year 2026  
Exploring the planet Earth in the year 2027  
Exploring the planet Earth in the year 2028  
Exploring the planet Earth in the year 2029

Great job on navigating those while loops! You’ve successfully completed the exploration mission. 🚀 Ready for the next adventure?

「practice」Programming the Mars Landing

Fantastic job, Space Voyager! Let’s shake things up a bit. Why don’t we alter the code to stop the ship when it’s 500 million km away from Saturn? Let’s put this to the test!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

planet = "Saturn"

distance_from_saturn = 1433.5 # in millions of kilometers

while ___:

print("Navigating towards", planet, "which is", distance_from_saturn, "million km away")

distance_from_saturn -= 100.0

print("Hello:", planet)

It sounds like you’re aiming to modify a loop within a script that controls a space voyage simulation, specifically to halt the ship when it is exactly 500 million kilometers away from Saturn. The task involves altering the loop condition so that the loop ceases once the ship’s distance to Saturn reaches or falls below this threshold.

Here’s how you can adjust your loop to meet this new requirement:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

planet = "Saturn"
distance_from_saturn = 1433.5  # in millions of kilometers

# The loop should continue as long as the distance is greater than 500 million km
while distance_from_saturn > 500.0:
    print("Navigating towards", planet, "which is", distance_from_saturn, "million km away")
    distance_from_saturn -= 100.0  # reduce the distance by 100 million km each iteration

print("Hello:", planet)  # This line executes once the ship is 500 million km away or less

With this alteration, the while loop will repeatedly execute, decrementing the distance by 100 million kilometers each time, until distance_from_saturn exceeds 500 million kilometers. Once it’s equal to or less than 500, the loop terminates, and the program prints a greeting indicating arrival in proximity to Saturn. This effectively simulates stopping the ship at the designated distance from the planet.

「practice」Adding Print Statement to Track Orbits

Oh dear, Star Voyager! There’s a minor hiccup in our Mars mission code. It appears our spaceship perpetually voyages to Mars without ever landing. We entrust you to find and rectify this bug! Good luck!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Space Exploration

planet = "Mars"

distance = 0

landed = False

  

while not landed:

print("Currently traveling to", planet, "and covered", distance, "million km")

distance += 10

if distance == 85:

print("Landed on", planet, "after covering", distance, "million km!")

landed = True

It seems like the primary issue you’re encountering is that the spaceship continues to travel towards Mars but never executes the landing sequence properly. From your description, it sounds as if the spaceship’s loop is designed to run until it has successfully landed, which is controlled by the landed variable. However, despite reaching the correct distance, the loop might not be terminating correctly.

Let’s examine the logic you’ve shared. You have a loop that increments the distance by 10 million km each cycle and checks if the distance equals 85 million km to determine if the spaceship should land. This logic appears sound for landing exactly when the distance is 85 million km. If there are no other conditions affecting the landed variable or other interruptions in your broader codebase affecting this segment, this specific portion should function as intended.

However, if the spaceship is “perpetually voyaging” despite this logic, there are a few potential issues to consider:

1. Infinite Loop: If the loop continues beyond the specified landing condition, it could be due to the loop condition not updating as expected. Make sure landed is correctly set to True.
2. Condition Miss: If the increment leads the distance to skip over exactly 85 (like if distance changes due to other conditions elsewhere in the code), the condition to land won’t be met. This doesn’t seem to be the case here since you’re incrementing by 10, but it’s a common issue in similar scenarios.
3. External Modifications: Ensure no external modifications to distance or landed from other parts of the program that might affect the execution flow here.

Based on the provided code snippet, the program should correctly report landing when the distance reaches exactly 85 million km. If the problem persists, I would recommend checking for any external interferences or modifications to the distance or landed variables outside the shown code block. If the issue is solely within the provided code, then it should function as expected under normal circumstances.

Thank you for your patience! It seems like I need to look closer at the loop’s termination condition based on the hint you provided. Currently, the loop increments the distance by 10 million km each iteration, and the landing is supposed to occur when the distance is exactly 85 million km. However, if there is any inconsistency or missed increment that causes the distance to overshoot 85 million km without hitting it exactly, the landing would indeed not trigger, causing the spaceship to continue indefinitely.

One way to solve this problem would be to adjust the landing condition from an equality check (==) to a greater than or equal to check (>=). This change ensures that even if the distance overshoots 85 million km due to modifications elsewhere or potential rounding errors, the spaceship will still land. Here’s how you could adjust the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

planet = "Mars"
distance = 0
landed = False

while not landed:
    print("Currently traveling to", planet, "and covered", distance, "million km")
    distance += 10
    if distance >= 85:  # Changed from '==' to '>='
        print("Landed on", planet, "after covering", distance, "million km!")
        landed = True

This adjustment will ensure that the spaceship lands once it reaches or exceeds 85 million km, preventing it from continuing indefinitely if it somehow misses the exact 85 million km mark. This might be particularly important in a more complex program where distance could be influenced by other functions or conditions in ways that might cause unexpected behavior.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Currently traveling to Mars and covered 0 million km  
Currently traveling to Mars and covered 10 million km  
Currently traveling to Mars and covered 20 million km  
Currently traveling to Mars and covered 30 million km  
Currently traveling to Mars and covered 40 million km  
Currently traveling to Mars and covered 50 million km  
Currently traveling to Mars and covered 60 million km  
Currently traveling to Mars and covered 70 million km  
Currently traveling to Mars and covered 80 million km  
Landed on Mars after covering 90 million km!

「practice」Reverse Engineering the Voyage to Venus

You’ve done a stellar job so far, Space Explorer! Let’s continue our exploration of the universe. This time, you’ll need to write some code on your own. Complete the TODO comment in the code to maintain the orbit of the Earth!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

planet = "Earth"

orbit_cycles = 0

  

# TODO: keep looping while orbit cycles is less than 10

while ___:

# TODO: add a print statement to indicate the number of orbits completed by the planet

orbit_cycles += 1

You’re gearing up to track the Earth’s orbit through a loop in Python, and you need to complete the loop and print statements. Here’s a clear way to complete the provided code:

1. Condition for the While Loop: The loop should continue as long as orbit_cycles is less than 10.
2. Print Statement: Every iteration (orbit) should print out the current number of orbits completed by Earth.

Here’s the completed code:

1
2
3
4
5
6
7
8
9

planet = "Earth"
orbit_cycles = 0

# Keep looping while orbit cycles is less than 10
while orbit_cycles < 10:
    # Print the number of orbits completed by the planet
    print(f"{planet} has completed {orbit_cycles + 1} orbits.")
    orbit_cycles += 1

This script initializes the number of orbits at 0 and uses a while loop to increment this number until it reaches 10. Each time through the loop, it prints a message stating how many orbits Earth has completed. The output is updated each loop, so it accurately reflects the new number of completed orbits.

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Earthhas completed 1 orbits.  
Earthhas completed 2 orbits.  
Earthhas completed 3 orbits.  
Earthhas completed 4 orbits.  
Earthhas completed 5 orbits.  
Earthhas completed 6 orbits.  
Earthhas completed 7 orbits.  
Earthhas completed 8 orbits.  
Earthhas completed 9 orbits.  
Earthhas completed 10 orbits.

Time to wrap up our exploration journey, Pilot! Let’s reverse-engineer the journey from Venus to Earth. Please modify the given starter code to have the spacecraft start from Venus and move closer to the Earth by a million km increment until it reaches Earth.

Use TODO comments as a reference. Let’s go!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

planet = "Venus"

distance = 10 # distance, in millions of km

  

# TODO: Write a while loop that:

# Prints the current distance to Earth

# Decreases the distance between the Earth and the spacecraft by 1 million km until it reaches Earth.

Here is your modified code, reflecting a journey from Venus to Earth with the spacecraft reducing its distance by 1 million km on each loop iteration until it reaches Earth:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

planet = "Venus"
distance = 10  # distance, in millions of km

# TODO: Write a while loop that:

# Prints the current distance to Earth

# Decreases the distance between the Earth and the spacecraft by 1 million km until it reaches Earth
while distance > 0:
    print(f"Current distance from {planet} to Earth: {distance} million km")
    distance -= 1  # Decrease the distance by 1 million km each iteration
print("The spacecraft has reached Earth!")

This script will output the distance from Venus to Earth in each iteration of the loop, decreasing the distance by 1 million kilometers each time, and it will stop when the spacecraft has reached Earth.

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Current distance from Venus to Earth: 10 million km  
Current distance from Venus to Earth: 9 million km  
Current distance from Venus to Earth: 8 million km  
Current distance from Venus to Earth: 7 million km  
Current distance from Venus to Earth: 6 million km  
Current distance from Venus to Earth: 5 million km  
Current distance from Venus to Earth: 4 million km  
Current distance from Venus to Earth: 3 million km  
Current distance from Venus to Earth: 2 million km  
Current distance from Venus to Earth: 1 million km  
The spacecraft has reached Earth!

Lesson 4: Interstellar Strolls Through Python: Loop and Conditional Symbiosis

Lesson Introduction: Combining Loops with Conditionals - The Power Duo

Greetings, student! Today, we’re fusing Python loops and conditionals together. Conditionals empower our code to make decisions, while loops enable the execution of repetitive tasks. Let’s master this synergy!

The Basics of Conditions in Loops

Loops, such as for and while, repeat specific tasks, and conditionals — if, elif, and else — guide the path of the code. Combining these constructs equips us with a virtual super robot that performs repeated tasks with decision-making abilities.

Let’s consider sending personalized party invitations. In this context, loops go through each guest, and conditionals decide the style of the invitation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Invite guests using a loop with a conditional

# Each guest has a name and invitation type - VIP or Regular
guests = [('Alice', 'VIP'), ('Bob', 'VIP'), ('Tom', 'Regular'), ('Jerry', 'Regular')]

for guest in guests:
    if guest[1] == 'VIP':
        print("Dear", guest[0], ", join us for a grand celebration!")
    elif guest[1] == 'Regular':
        print("Hi", guest[0], ", you are invited!")

This code prints:

1
2
3
4
5

Dear Alice , join us for a grand celebration!
Dear Bob , join us for a grand celebration!
Hi Tom , you are invited!
Hi Jerry , you are invited!

Working with Conditionals in For Loops

Python’s For Loop iterates over a defined sequence of elements. When we pair a conditional with the loop, the execution adjusts with each iteration based on the condition.

For instance, consider hosting a party. We have a guest_list and an unwanted_list. By pairing a For Loop with a conditional, we can ensure that only welcomed guests gain admission:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# For Loop with a conditional
guest_list = ['Alice', 'Bob', 'Tom', 'Jerry', 'Snow']
unwanted_guests = ['Tom', 'Snow']

for guest in guest_list:
    if guest not in unwanted_guests:
        print("Welcome,", guest, "!")
    else:
        print("Sorry,", guest, ", the party is full.")

The code prints:

1
2
3
4
5
6

Welcome, Alice !
Welcome, Bob !
Sorry, Tom , the party is full.
Welcome, Jerry !
Sorry, Snow , the party is full.

Implementing Conditionals in While Loops

A While Loop continues as long as its condition remains valid. Inserting a conditional within it can alter or halt its iterations based on changing conditions.

Suppose that when an unwanted guest arrives, the doorman closes the gate:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# While Loop with a conditional
guest_list = ['Alice', 'Bob', 'Tom', 'Jerry', 'Snow']
unwanted_guests = ['Tom', 'Snow']
guest_index = 0

while guest_index < len(guest_list):
    if guest_list[guest_index] not in unwanted_guests:
        print("Please come in,", guest_list[guest_index], "!")
    else:
        print("Party Over:", guest_list[guest_index], "showed up!")
        break # This will stop the while loop completely
    guest_index += 1

The code prints:

1
2
3
4

Please come in, Alice !
Please come in, Bob !
Party Over: Tom showed up!

It looks like you’ve shared a Python code snippet using a while loop to manage a list of guests at a party, including a condition to check for unwanted guests. The code iterates over the guest list, inviting each one unless they are found in the unwanted guests list. When an unwanted guest is encountered, the loop terminates with a specific message indicating the party is over because of that guest’s arrival.

To clarify and expand upon the explanation: In your script, guest_list contains names of all invited people, while unwanted_guests lists those whose arrival would end the party. You initialize guest_index to 0 to start checking from the first guest in the list. The while loop continues as long as guest_index is less than the number of guests. Inside the loop, there’s a condition to check if the current guest (guest_list[guest_index]) is not in the unwanted_guests list. If true, a welcoming message is printed. If false, a message indicating the end of the party due to the unwanted guest is printed, and the loop is immediately stopped with break. The guest_index is incremented at the end of each loop iteration to move to the next guest.

This mechanism ensures that as long as no unwanted guests show up, everyone on the list is welcomed sequentially. The party continues until an unwanted guest arrives, at which point the script stops checking further guests. If you have any questions about modifying or understanding this script further, feel free to ask!

Understanding Different Scenarios

The combination of loops and conditionals provides immense versatility. For instance, consider these scenarios:

1. Picking out even numbers from a list.
2. Find all duplicates in the list of numbers.

Here’s how we can address these scenarios:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Filter out even numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for num in numbers:
    if num % 2 != 0:  # if the number is not divisible by 2
        print(num)
"""
Prints:
1
3
5
7
9
"""

# Find all duplicates in the list of numbers
num_list = [1, 3, 5, 3, 7, 2, 1]
unique_list = []
for num in num_list:
    if num not in unique_list:
        unique_list.append(num)
    else:
        print("Duplicate number found:", num)
"""
Prints:
Duplicate number found: 3
Duplicate number found: 1
"""

output

1
2
3
4
5
6
7
8

1  
3  
5  
7  
9  
Duplicate number found: 3  
Duplicate number found: 1

Lesson Summary: The Power Duo in Action

Fantastic! You’ve learned to combine Python’s loops and conditionals. We’ve covered for and while loops coupled with conditionals and showcased Python examples, using our combination to solve various scenarios.

Now, it’s time to exercise this new skill through practice. Just as a dancer perfects a dance routine by repeating each step, mastering these concepts requires ample practice. Let’s continue our journey to Python mastery!

「practice」Welcome the Party Guests

Welcome to our space party planner, Space Explorer! The guest list is quite extensive, but the party room, unlike the TARDIS, has limited space and time. Consequently, I designed a code that utilizes loops and conditionals, and invites VIP and Regular guests until the time_left becomes 0, while avoiding Unwanted guests.

Please press Run to see how it operates.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# You are hosting a party, and you have guests in line.

# You will invite-only VIPs and Regular guests until the time is up!

# Your goal is to greet as many people as you can, or else the party might be too quiet.

  

guests = [('Alice', 'VIP'), ('Bob', 'VIP'), ('Charlie', 'Regular'), ('Daisy', 'Unwanted'), ('Eve', 'VIP'), ('Frank', 'Regular'), ('Marcelo', 'VIP')]

time_left = 5

  

for guest in guests:

if time_left == 0:

break

if guest[1] != 'Unwanted':

print("Welcome,", guest[0], "!")

time_left -= 1

else:

print("Sorry,", guest[0], ", we cannot invite you this time!")

以上运行🙅❌ guest[1] ,guest[0]，# You are hosting a party, and you have guests in line.

You will invite-only VIPs and Regular guests until the time is up!

Your goal is to greet as many people as you can, or else the party might be too quiet.

自动生成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

def party(guests):
   """
   Invites VIPs and Regular guests to a party until the time is up.

   Args:
       guests (list): A list of guests, where each guest is a tuple
           containing the guest's name (string) and type (string, either
           "VIP" or "Regular").

   Returns:
       int: The number of guests invited to the party.
   """

   # Initialize the number of guests invited to 0.
   num_invited = 0

   # Iterate over the list of guests.
   for guest_name, guest_type in guests:

       # Check if the guest is a VIP.
       if guest_type == "VIP":

           # Invite the VIP to the party.
           print(f"Inviting {guest_name} (VIP) to the party.")
           num_invited += 1

       # Check if the guest is a Regular guest.
       elif guest_type == "Regular":

           # Check if there is still time left to invite Regular guests.
           if num_invited < 5:

               # Invite the Regular guest to the party.
               print(f"Inviting {guest_name} (Regular) to the party.")
               num_invited += 1

           # If there is no more time left, break out of the loop.
           else:
               break

   # Return the number of guests invited to the party.
   return num_invited

# Test the party function.
guests = [
   ("John", "VIP"),
   ("Mary", "Regular"),
   ("Bob", "VIP"),
   ("Alice", "Regular"),
   ("Tom", "Regular"),
   ("Susan", "VIP"),
   ("David", "Regular"),
]
num_invited = party(guests)
print(f"{num_invited} guests were invited to the party.")

RAR- GPT4 You’re focusing on ensuring that your guest invitation process at your party doesn’t exceed the allotted time, specifically by managing the decrementing of the time_left variable correctly. The challenge here is that you might invite one extra guest because the decrement of time_left happens after a guest is already welcomed, and the check for whether time_left has reached zero isn’t optimally placed to preemptively prevent this.

To address this, you need to adjust the placement and condition of the time_left check. This involves making sure you have enough time left before you invite each guest. Here’s a refactored version of your loop to ensure time_left is checked properly before welcoming any guest, and the loop exits correctly when no more time is left:

python

Copy code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

guests = [('Alice', 'VIP'), ('Bob', 'VIP'), ('Charlie', 'Regular'), ('Daisy', 'Unwanted'), ('Eve', 'VIP'), ('Frank', 'Regular'), ('Marcelo', 'VIP')]
time_left = 5

for guest in guests:
    # Check if we should skip inviting unwanted guests.
    if guest[1] == 'Unwanted':
        print("Sorry,", guest[0], ", we cannot invite you this time!")
        continue  # Skip the rest of the loop for unwanted guests.

    # Pre-check time_left before inviting to ensure we do not exceed the limit.
    if time_left > 0:
        print("Welcome,", guest[0], "!")
        time_left -= 1  # Decrement time only after ensuring the guest can be welcomed.
    else:
        break  # Stop inviting once we run out of time.

print("Time left after all invitations:", time_left)```
output

```python

Welcome, Alice !  
Welcome, Bob !  
Welcome, Charlie !  
Sorry, Daisy , we cannot invite you this time!  
Welcome, Eve !  
Welcome, Frank !

「practice」Adjusting Invitations for VIP Guests Only

Great job, Cosmic Voyager!

Now, let’s fine-tune our party invitation system a bit more.

Alter the code to ensure that a guest receives an invitation only if they are classified as a 'VIP'. Non-VIP guests should receive a decline message, specifying their name and that they can’t enter the party.

You’ve got the drill!

1
2
3
4
5
6

guests = [('Obi-Wan', 'VIP'), ('Anakin', 'Regular'), ('Yoda', 'VIP'), ('Jar Jar', 'Unwanted'), ('Leia', 'Regular'), ('Han', 'VIP')]

for guest in guests:

print("Welcome, Master", guest[0], ", we've been expecting you!")

自动生成

1
2
3
4
5
6
7
8

guests = [('Obi-Wan', 'VIP'), ('Anakin', 'Regular'), ('Yoda', 'VIP'), ('Jar Jar', 'Unwanted'), ('Leia', 'Regular'), ('Han', 'VIP')]

for guest in guests:
  if guest[1] == 'VIP':
    print("Welcome, Master", guest[0], ", we've been expecting you!")
  else:
    print("Sorry", guest[0], "you're not on the VIP list and cannot enter the party")

output

1
2
3
4
5
6
7

Welcome, Master Obi-Wan , we've been expecting you!  
Sorry Anakin you're not on the VIP list and cannot enter the party  
Welcome, Master Yoda , we've been expecting you!  
Sorry Jar Jar you're not on the VIP list and cannot enter the party  
Sorry Leia you're not on the VIP list and cannot enter the party  
Welcome, Master Han , we've been expecting you!

「practice」Cosmic Party Guest Greetings Issue

Hold your horses, Space Explorer! Something has gone haywire in our greeting system at the Cosmic party. The current code was intended to generate a different greeting based on the length of the guest’s name, but that just isn’t happening.

Can you help us fix the greeting machine’s logic? We need it to provide longer, more formal greetings to guests with names longer than 4 letters and shorter, more casual greetings to guests with names that are 4 letters or shorter.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12