Learn with Python Farm:
Core Python Syntax in 6 Steps

When you first learn Python syntax, it is easy to memorize functions, loops, conditionals, and dictionaries separately. In real programs, however, you combine several syntax features to read the current state and decide what to do next.

Farming follows the same structure. You till the field, plant seeds, water them, wait until the crops are fully grown, and then harvest them. If water is limited or the field is dark, you need to check the soil and crop conditions and select only the actions that are needed.

Codedash's Python Farm is a game-based learning environment where you automate this process with block coding and Python code. This guide follows six levels, from basic function calls through dictionaries, nested loops, and state-based problem solving.

Core Python Syntax to Know First

move(Dir.Down)
plant(Res.Tomato)

for i in range(5):
    harvest()

while not can_harvest():
    wait(1)

if ground == Ground.Tilled:
    water()
else:
    wait(1)

status = get_res_status()
status['ripeness']

for row in range(4):
    for column in range(5):
        harvest()

Functions such as move(), plant(), and harvest() are not Python built-in functions; they are game-specific functions provided by Python Farm. for, while, if/else, dictionaries, and indentation are actual Python syntax.

Chapter 1-1 First Harvest: Move and Harvest

CHAPTER 1 · LEVEL 1

The goal of the first level is to move down to the field and harvest five ripe wheat crops. Repeat the sequence of calling harvest() on the current tile and then moving to the next tile.

[Run Code]
  ├─ [Move Down]
  └─ [Repeat 5 Times]
      ├─ [Harvest]
      └─ [If i < 4, Move Right]

move(Dir.Down)

for i in range(5):
    harvest()
    if i < 4:
        move(Dir.Right)

There is no need to move again after harvesting the final wheat crop, so the farmer moves right only when i < 4. This level demonstrates function calls, loop counts, and execution order together.

Chapter 2-5 Farmer Basics: From Tilling to Harvesting

CHAPTER 2 · LEVEL 5

In Chapter 2-5, you must till five empty ground tiles, plant tomato seeds, and water them. The crops do not become harvestable immediately, so wait until can_harvest() is true before harvesting.

[Repeat While Moving Across 5 Tiles]
  ├─ [Till]
  ├─ [Plant Tomato]
  └─ [Water]

[Repeat While Returning Across 5 Tiles]
  ├─ [Wait Until Harvestable]
  └─ [Harvest]

move(Dir.Down)
for i in range(5):
    till()
    plant(Res.Tomato)
    water()
    if i < 4:
        move(Dir.Right)

for i in range(5):
    while not can_harvest():
        wait(1)
    harvest()
    if i < 4:
        move(Dir.Left)

The first for loop repeats the work sequence on each tile, and the second for loop harvests while moving in the opposite direction. The inner while loop checks when each crop has finished growing.

Chapter 3-5 Basics - Onion Farming: Limited Water and if/else

CHAPTER 3 · LEVEL 5

This level asks you to plant and harvest 25 onions in a 5×5 field. You receive exactly 20 units of water, but the five diagonal tiles have already been watered at the start.

Calling water() again on wet soil still consumes water. You must therefore check whether the current ground is Ground.Tilled and water only the dry tiles to complete all 25 tiles. You also need to remove weeds from the field before planting.

[Traverse 5 Rows in a Zigzag]
  ├─ [Clear if Weed]
  ├─ [ground = Ground State]
  ├─ [If Dry Tilled Soil]
  │    ├─ [Plant Onion]
  │    └─ [Water]
  └─ [Otherwise, Plant Onion Only]

[Return Across the Same Field and Harvest]

move(Dir.Down)
for row in range(5):
    step = Dir.Right if row % 2 == 0 else Dir.Left
    for i in range(5):
        if get_res_type() == Res.Weed:
            clear()
        ground = get_ground_type()
        if ground == Ground.Tilled:
            plant(Res.Onion)
            water()
        else:
            plant(Res.Onion)
        if i < 4:
            move(step)
    if row < 4:
        move(Dir.Down)

for row in range(5):
    step = Dir.Left if row % 2 == 0 else Dir.Right
    for i in range(5):
        while not can_harvest():
            wait(1)
        harvest()
        if i < 4:
            move(step)
    if row < 4:
        move(Dir.Up)

Use row % 2 to distinguish even and odd rows and reverse the movement direction, allowing you to traverse a large field in a zigzag pattern. The conditional connects the amount of water available with the soil state to prevent unnecessary resource use.

Chapter 4-1 Check Growth Status: Reading Dictionary Values

CHAPTER 4 · LEVEL 1

There are ten tomatoes in the field, but the locations of the ripe tomatoes change each time you run the level. You must harvest only the two tomatoes whose ripeness is 7 or higher; harvesting an unripe tomato causes the mission to fail.

get_res_status() returns the crop state as a dictionary. Reading the value of the ripeness key lets your code decide which crops to harvest instead of relying on color or memorizing their locations.

[Traverse 2 Rows in a Zigzag]
  ├─ [status = Resource State]
  ├─ [If status exists and ripeness > 6, Harvest]
  └─ [Move to the Next Tile]

move(Dir.Down)
for row in range(2):
    step = Dir.Right if row == 0 else Dir.Left
    for i in range(5):
        status = get_res_status()
        if status and status['ripeness'] > 6:
            harvest()
        if i < 4:
            move(step)
    if row < 1:
        move(Dir.Down)

Dictionaries are useful for passing several related states as a single value. In this level, you select and use only the needed ripeness value from resource_type, growthstatus, ripeness, and resource_state.

Chapter 6-5 Night Work: Weed Out Wrong Crops

CHAPTER 6 · LEVEL 5

The nighttime field is dark except around the farmer, so you cannot memorize the locations and types of all crops from the screen in advance. The crop type and quantity to keep in each row are set on that row's sign every time the level runs.

Read the sign's message to find the target crop, and call clear() only when the result of get_res_type() on the current tile differs from the target. Nested loops process the four rows and the four crops in each row.

[Map Crop Names to Res Values with a Dictionary]
[Repeat for 4 Rows]
  ├─ [target = Crop on Sign]
  ├─ [Move to Crop Tiles]
  ├─ [Repeat for 4 Crops]
  │    └─ [Clear if Different from target]
  └─ [Move to the Next Row's Sign]

crops = {
    'tomato': Res.Tomato,
    'onion': Res.Onion,
    'bellpepper': Res.Bellpepper,
    'wheat': Res.Wheat,
}

move(Dir.Down)
for row in range(4):
    target = crops[get_res_status()['message']]
    move(Dir.Right)
    for i in range(4):
        crop = get_res_type()
        if crop is not None and crop != target:
            clear()
        if i < 3:
            move(Dir.Right)
    if row < 3:
        for i in range(4):
            move(Dir.Left)
        move(Dir.Down)

The crops dictionary acts as a lookup table connecting the strings on the signs to actual game resources. The key idea is to base actions on states read at runtime rather than on hard-coded locations or crop types.

Chapter 8-3 Legendary 64-Tile Pumpkin: Final Automation Mission

CHAPTER 8 · LEVEL 3

The final level asks you to grow pumpkins on all 64 tiles of an 8×8 field and merge them into one legendary pumpkin. Ready pumpkins merge when they form a complete square, and the entire 8×8 field must grow correctly to produce a size 64 pumpkin.

Individual pumpkins can rot while growing. Rotten pumpkins are excluded from the merge, so you need to check resource states and selectively repair any problem tiles. This final comprehensive challenge combines nested loops over rows and columns, growth waiting, state checks, and exception handling.

Challenge Requirements

1. You must traverse all 64 tiles of the 8×8 field without missing any.
2. You must plant a pumpkin on each tile and check its growth state.
3. Rotten pumpkins cannot merge, so you must find and repair problem tiles.
4. You must confirm that the merged pumpkin's size is 64.
5. To clear the actual level, you must harvest the completed legendary pumpkin.

Why It Helps to View Block Coding and Python Code Together

Codedash runs in the browser without requiring a separate Python environment. After examining the structure with blocks, you can express the same problem again in Python code and gradually expand the scope of your automation.

Use Classroom Features in Lessons

Later chapters also cannot be skipped; each one unlocks only after you complete the preceding chapter. To access Chapter 3 and later as an individual user, sign in and purchase access or obtain access with a redemption code. Purchased access remains available for 365 days from the payment date.

Frequently Asked Questions