RoboMaster S1
Python 수업

어떤 문제를 풀까요?

바닥에 30 cm 간격으로 테이프 표시 두 개를 붙이고, 30과 0.30이 적힌 카드를 봅니다. 각 로봇에는 어떤 값을 전달해야 할까요?

거리에 이름을 붙여 저장하면 이동 계획을 바꿀 때 그 값만 수정할 수 있습니다. Tello는 cm, S1은 m 단위를 쓰므로 같은 숫자를 그대로 전달하면 이동 거리도 달라집니다.

30이라는 숫자만으로는 단위를 알 수 없습니다. 여러 명령에 같은 숫자를 반복해서 쓰면 경로를 바꿀 때 일부를 빠뜨리기 쉽습니다. 변수 이름으로 단위를 나타낼 수는 있지만, 이름을 붙이는 것만으로 값이 환산되지는 않습니다.

읽고, 예상하고, 실행 따라가기

대입은 값에 이름을 붙여 저장하는 작업입니다. m 단위 값에 100을 곱하면 cm 단위 값이 됩니다. int(round(...))는 명령에 쓸 거리를 정수 cm로 나타냅니다. 이 수업의 예제 거리는 모두 정수 cm로 정확히 표현할 수 있습니다.

• 변수(variable): 값에 붙인 이름
• 단위(unit): 숫자가 무엇을 얼마나 나타내는지 정한 기준
• 환산(conversion): 같은 양을 다른 단위로 표현하는 것

distance_m = 0.30
distance_cm = int(round(distance_m * 100))
print(distance_cm, distance_m)

30 0.3

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print(20 / 100)

length_m = 0.40
print(int(round(length_m * 100)))

leg_m = 0.25
print(int(round(leg_m * 100)), leg_m)

duration_ms = 250
print(duration_ms / 1000)

직접 만들어 보기

command_units(distance_m)를 완성하세요. 입력은 0.20~0.80 m이며 cm로 바꾸었을 때 정수가 되는 값입니다. (Tello의 cm 값, S1의 m 값)을 반환합니다. 이 함수는 값을 준비할 뿐 로봇에 연결하지 않습니다.

def command_units(distance_m):
    return (None, None)

print(command_units(0.4))

assert command_units(0.2) == (20, 0.2)
assert command_units(0.4) == (40, 0.4)
assert command_units(0.8) == (80, 0.8)

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 계획한 거리를 Tello에는 cm, S1에는 m로 전달하고, 두 명령이 같은 거리를 뜻하는 이유를 설명합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

단위 없이 숫자 30을 두 로봇에 똑같이 전달하면 어떤 문제가 생길까요?

카메라의 지연 시간을 밀리초에서 초로 환산하고, API에 값을 전달할 때 어떤 단위를 써야 하는지 설명합니다.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

이동 경로는 비어 있지만 배터리가 부족한 경우와, 배터리는 충분하지만 경로가 막힌 경우를 비교합니다. 어느 쪽이 출발해도 될까요?

입력이 달라지면 같은 프로그램도 다른 동작을 해야 합니다. 조건을 함께 쓰면 출발 규칙을 코드로 명확하게 나타내고 움직이기 전에 검사할 수 있습니다.

아무 조건 없이 출발하면 입력을 무시하게 되고, 조건 하나만 검사하면 나머지 조건을 놓칩니다. 수업에서 정한 배터리 기준은 실습 규칙이며 제조사가 보장한 기준은 아닙니다.

읽고, 예상하고, 실행 따라가기

if는 조건에 따라 실행할 갈래를 고릅니다. >=는 기준과 같은 값도 포함하고, A and B는 두 조건이 모두 True일 때만 True입니다. Tello에는 수업용 사전 점검 기준인 배터리 40% 이상을 적용합니다. 이동 구역이 비어 있는지는 감독하는 사람이 확인합니다.

• 조건(condition): True 또는 False로 판단하는 식
• 경계값(boundary): 판단 기준과 정확히 같은 값
• and: 두 조건을 모두 만족해야 참이 되는 연산

battery = 40
clear = False
if battery >= 40 and clear:
    print("go")
else:
    print("stop")

stop

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print(40 > 40)

battery = 41
clear = True
print(battery >= 40 and clear)

battery = 39
print("go" if battery >= 40 and True else "stop")

print("enter" if 12 >= 12 and False else "wait")

직접 만들어 보기

permit(battery, clear)를 작성하세요. 배터리가 40 이상이고 경로가 비어 있을 때만 "go"를, 나머지는 "stop"을 반환합니다. 배터리 입력은 백분율 숫자, 경로 입력은 불리언입니다.

def permit(battery, clear):
    return "stop"

print(permit(40, True))

assert permit(39, True) == "stop"
assert permit(40, True) == "go"
assert permit(41, False) == "stop"
assert permit(90, True) == "go"

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 두 조건을 모두 확인하는 출발 규칙을 만들고, 기준보다 작은 값·같은 값·큰 값으로 검사합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

코드를 고치지 않아도 입력에 따라 다른 갈래가 실행되는 이유는 무엇일까요?

나이와 보호자 허용 여부를 함께 확인하는 도서관 출입 규칙을 만듭니다. 기준 나이와 정확히 같은 경우도 포함하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

네 변을 따라 도는 정사각형 순찰을 그립니다. 모든 변을 30 cm에서 40 cm로 바꾸고, 회전 명령의 들여쓰기가 동작에 어떤 영향을 주는지 예상해 보세요.

반복문 안에 순찰 한 단계를 적으면 같은 동작을 되풀이할 수 있습니다. 반복 횟수나 매개변수 하나를 바꾸면 반복되는 동작 전체에 반영됩니다.

코드를 네 번 복사해도 움직일 수 있지만 세 곳만 고치고 한 곳을 놓치면 경로가 달라집니다. 반복되는 것은 들여쓴 코드이며, 반복문 뒤의 회전 명령은 한 번만 실행됩니다.

읽고, 예상하고, 실행 따라가기

for는 반복 대상의 항목을 차례로 꺼냅니다. range(4)가 만드는 값은 0, 1, 2, 3입니다. 정사각형 순찰에서는 매번 앞으로 이동하고 90도 회전합니다. 반복문 다음 코드는 반복이 끝난 뒤 한 번 실행됩니다.

• 반복(iteration): 반복문 내부를 한 차례 실행하는 것
• range: 끝값을 포함하지 않는 정수 범위
• 들여쓰기(indentation): 반복문에 포함되는 코드 줄을 구분하는 방법

for leg in range(2):
    print("move", leg)
    print("turn")
print("done")

move 0
turn
move 1
turn
done

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print(list(range(3)))

for leg in range(3):
    print("move")
print("land")

count = 0
for leg in range(4):
    count = count + 2
print(count)

for photo in range(2):
    print("save")
print("close")

직접 만들어 보기

square_commands(sides)를 완성하세요. 변 하나마다 "move", "turn" 문자열을 차례로 추가해 반환합니다. 이 함수는 명령 계획을 만들며, 실제 정사각형 예제는 항상 네 변을 사용합니다.

def square_commands(sides):
    commands = []
    # Repeat a move and a turn for each side.
    return commands

print(square_commands(4))

assert square_commands(0) == []
assert square_commands(1) == ["move", "turn"]
assert square_commands(4) == ["move", "turn"] * 4

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: range(4)의 실행을 따라가며 이동과 회전을 모두 반복문 안에 넣습니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

어느 값을 고치면 네 변의 길이가 모두 바뀔까요? 이동은 네 번, 회전은 한 번만 하게 되는 들여쓰기 오류는 무엇일까요?

사진을 찍고 기록하는 작업을 다섯 번 한 뒤 마지막에 한 번만 업로드하도록 계획합니다. 업로드를 반복문 밖에 두는 이유를 설명하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

처음에는 마커를 가렸다가 예상하기 어려운 순간에 보여 줍니다. 프로그램은 몇 번까지 확인해야 할까요?

새로 들어오는 관찰에 따라 종료 시점이 달라질 때 while 조건으로 이를 표현할 수 있습니다. 검사 횟수에 제한을 두면 끝없이 기다리는 일을 막을 수 있습니다.

횟수가 정해진 for문은 성공한 뒤에도 검사를 계속할 수 있습니다. while문에서 예전 값만 확인하면 새 마커를 알아차리지 못합니다. for와 break로 같은 동작을 만들 수도 있으므로 종료 규칙이 잘 드러나는 방식을 고릅니다.

읽고, 예상하고, 실행 따라가기

while은 매 반복 전에 조건을 검사합니다. 반복문 안에서 진행 상태를 갱신하고 새 관찰을 읽어야 합니다. 성공하거나 최대 검사 횟수에 도달하면 종료합니다. sleep은 검사 사이의 간격을 만들 뿐 새 센서 값을 읽는 동작은 아닙니다.

• 폴링(poll): 새 읽기 값을 요청하는 것
• 오래된 값(stale): 이전에 읽어 둔 값
• 검사 한도(budget): 허용한 최대 검사 횟수

readings = [False, False, True]
checks = 0
found = False
while not found and checks < 3:
    found = readings[checks]
    checks += 1
print(checks, found)

3 True

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

count = 0
while count < 2:
    count += 1
print(count)

values = [False, True, False]
i = 0
found = False
while not found and i < 3:
    found = values[i]
    i += 1
print(i, found)

values = [False, False, False]
i = 0
found = False
while not found and i < 2:
    found = values[i]
    i += 1
print(i, found)

pages = ["busy", "ready", "ready"]
i = 0
while i < len(pages):
    state = pages[i]
    i += 1
    if state == "ready":
        break
print(i)

직접 만들어 보기

first_ready(readings, max_checks)를 완성하세요. 준비된 불리언 입력을 최대 max_checks개까지 읽고 (사용한 검사 횟수, 찾았는지 여부)를 반환합니다. 입력이 비었거나 검사 한도가 0이면 (0, False)를 반환합니다. 기록된 입력으로 새 읽기를 흉내 내는 연습이며 장애물 감지기가 아닙니다.

def first_ready(readings, max_checks):
    checks = 0
    found = False
    # Update both variables from the next reading.
    return checks, found

print(first_ready([False, True], 4))

assert first_ready([False, True, False], 3) == (2, True)
assert first_ready([False, False, True], 2) == (2, False)
assert first_ready([True], 0) == (0, False)
assert first_ready([], 4) == (0, False)

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 매번 새 입력을 읽으며, 성공했을 때와 검사 횟수를 다 썼을 때의 종료를 각각 구현하고 설명합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

예전에 읽은 값 하나로 조건을 반복 검사하면 새 사건을 알아차릴 수 없는 이유는 무엇일까요?

인쇄 작업 대기열을 확인하는 프로그램을 생각해 봅니다. 어떤 정보를 갱신하고 무엇을 성공으로 볼지, 검사 횟수가 끝나면 어떻게 할지 설명하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

세 구간으로 된 경로를 만들고, 이동 코드는 그대로 둔 채 첫 번째와 마지막 거리 카드를 바꿔 보세요.

경로를 순서 있는 묶음으로 저장하면 경로 데이터와 이동 코드를 나눌 수 있습니다. 관찰을 리스트에 계속 추가하면 새 값 하나로 이전 기록을 덮어쓰지 않아도 됩니다.

변수를 세 개로 나누면 각각 따로 처리해야 하고, 변수 하나에 새 관찰을 계속 대입하면 이전 값을 잃습니다. 한 관찰의 항목에 이름을 붙일 때는 딕셔너리, 여러 관찰의 순서를 보관할 때는 리스트가 적합합니다.

읽고, 예상하고, 실행 따라가기

리스트는 항목의 순서를 보관합니다. 인덱스 0은 첫 항목, -1은 마지막 항목을 고릅니다. append는 맨 뒤에 항목 하나를 추가하고, 반복문으로 리스트를 순회하면 경로의 값을 차례로 읽습니다.

• 인덱스(index): 항목의 위치
• append: 맨 뒤에 항목을 추가하는 메서드
• 순서(order): 항목이 놓인 차례에도 의미가 있음

route_cm = [20, 30]
route_cm.append(40)
print(route_cm[0], route_cm[-1], sum(route_cm))

20 40 90

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print([25, 35, 45][0])

log = [20]
log.append(30)
print(log)

route = [20, 40, 30]
print(route[1], route[-1])

playlist = ["intro", "theme"]
playlist.append("end")
print(playlist[1])

직접 만들어 보기

route_summary(route_cm)에서 (구간 수, 전체 거리 cm, 마지막 구간 거리 cm)를 반환하세요. 빈 경로는 (0, 0, None)을 반환합니다. 이 값은 이동 거리이며 비행 좌표가 아닙니다.

def route_summary(route_cm):
    return (0, 0, None)

print(route_summary([20, 30, 40]))

assert route_summary([20, 30, 40]) == (3, 90, 40)
assert route_summary([50]) == (1, 50, 50)
assert route_summary([]) == (0, 0, None)

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 순서가 있는 경로를 고치고, 앞서 읽은 값을 잃지 않으면서 새 관찰을 덧붙입니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

reading = new_value를 반복해서 대입하는 것보다 append로 관찰을 더 많이 보관할 수 있는 이유는 무엇일까요?

재생 목록이나 실험 읽기 값의 순서를 저장하고, 순서를 바꾸면 언제 의미가 달라지는지 설명하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

[70, 80]을 보고 70이 배터리인지 높이인지 생각해 보세요. 각 값에 이름을 붙인 기록으로 바꿔 봅니다.

항목에 이름을 붙이면 서로 다른 측정값을 구분할 수 있습니다. 같은 항목을 여러 번 관찰할 때는 딕셔너리들을 리스트로 묶어 보관할 수 있습니다.

리스트의 위치로 항목을 구분하면 모두가 같은 순서를 기억해야 합니다. 딕셔너리는 항목에 이름을 붙여 주지만, 단위가 맞는지 또는 센서가 실제로 측정한 값인지까지 검증하지는 않습니다.

읽고, 예상하고, 실행 따라가기

딕셔너리는 키와 값을 연결합니다. 같은 키에 다시 대입하면 그 값이 바뀝니다. 시간에 따른 변화를 보관하려면 읽을 때마다 별도의 딕셔너리를 만들어 리스트에 넣습니다. None은 값이 없음을, 0은 실제로 측정한 영을 나타낼 수 있습니다.

• 키(key): 항목의 이름
• 기록(record): 이름 붙은 항목으로 구성된 한 차례의 관찰
• 결측(missing): 0이 아니라 측정값이 없는 상태

reading = {"battery_pct": 70, "height_cm": 80}
reading["height_cm"] = 85
print(reading["battery_pct"], reading["height_cm"])

70 85

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print({"height_cm": 90, "battery_pct": 60}["battery_pct"])

r = {"count": 1}
r["count"] = 4
print(r["count"])

r = {"robot": "s1", "height_cm": None}
print(r["height_cm"] is None)

weather = {"temp_c": 0, "rain_mm": None}
print(weather["temp_c"] is None)

직접 만들어 보기

make_record(robot, sample, battery_pct, height_cm)는 이 네 이름을 키로 쓰는 새 딕셔너리를 반환합니다. 빠진 측정값은 None으로 둡니다. 함수를 두 번 호출해 서로 다른 딕셔너리가 만들어지는지 확인하세요.

def make_record(robot, sample, battery_pct, height_cm):
    return {}

print(make_record("s1", 1, None, None))

a = make_record("tello", 1, 80, 90)
b = make_record("s1", 2, None, None)
assert a == {"robot": "tello", "sample": 1, "battery_pct": 80, "height_cm": 90}
assert b["height_cm"] is None
assert a is not b
assert set(b) == {"robot", "sample", "battery_pct", "height_cm"}

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 의미 있는 키로 기록을 만들고, 빠진 값과 0을 구분하며 여러 차례의 관찰을 보관합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

키에 height_cm라고 적으면 어떤 점이 읽기 쉬워질까요? 그래도 알 수 없는 것은 무엇일까요?

실제 0인 값 하나와 빠진 값 하나를 포함한 날씨 기록을 만들고 둘의 차이를 설명하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

짧은 순찰과 긴 순찰을 요청받았다고 생각해 보세요. 프로그램 전체를 복사해야 할까요, 같은 동작에 다른 입력을 주면 될까요?

함수로 자주 쓰는 동작에 이름을 붙이고 매개변수로 입력을 바꿀 수 있습니다. 하드웨어 메서드를 실행하기 전에 반환값으로 계산을 검사할 수 있습니다.

이동 코드를 복사하면 고칠 곳도 여러 군데가 됩니다. 환산한 거리를 출력하는 것과 다른 함수에 반환하는 것은 다릅니다. tello.move_forward(...)는 특정 기체 객체의 메서드이며, 단순한 환산 함수에는 기체가 필요하지 않습니다.

읽고, 예상하고, 실행 따라가기

def는 함수를 정의하고, 호출하면 함수 내부가 실행됩니다. return은 호출한 곳으로 값을 돌려줍니다. 메서드는 samples.append(value), drone.move_forward(cm)처럼 객체를 통해 호출합니다. 둘 다 호출이지만 어떤 객체의 기능인지, 무엇을 바꾸는지는 다릅니다.

• 매개변수(parameter): 전달받은 입력에 붙이는 이름
• return: 호출한 곳에 결과를 돌려주는 문장
• 메서드(method): 객체를 통해 호출하는 함수

def to_cm(metres):
    return int(round(metres * 100))

commands = []
commands.append(to_cm(0.4))
print(commands)

[40]

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

def leg():
    print("move")
print("ready")

def double(x):
    return x * 2
print(double(3))

def to_cm(m):
    return int(round(m * 100))
print(to_cm(0.25) + to_cm(0.35))

def seconds(milliseconds):
    return milliseconds / 1000
print(seconds(500))

직접 만들어 보기

out_and_back(distance_m)는 [("forward", cm), ("back", cm)]를 반환합니다. 입력은 0.20~0.80 m이며 cm로 바꾸었을 때 정수가 되는 값입니다. 환산 함수를 사용하되 로봇 라이브러리를 가져오거나 이동 명령을 보내지 않습니다.

def to_cm(distance_m):
    return 0

def out_and_back(distance_m):
    return []

print(out_and_back(0.3))

assert to_cm(0.2) == 20
assert out_and_back(0.3) == [("forward", 30), ("back", 30)]
assert out_and_back(0.6) == [("forward", 60), ("back", 60)]

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 값을 환산하는 함수와 동작을 수행하는 메서드를 구분하고, 각 호출이 반환하거나 바꾸는 것을 설명합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

to_cm(0.3)을 호출하는 것과 drone.move_forward(30)을 호출하는 것은 어떻게 다를까요?

사진 파일 이름을 만들어 주는 함수를 작성합니다. 이름을 만드는 작업과 실제 파일 저장은 분리하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

종이로 2행 3열의 점검 격자를 만듭니다. 반복문 두 개를 쓰면 다섯 번 점검할지 여섯 번 점검할지 예상해 보세요.

두 차원의 모든 조합을 살피려면 행과 열을 함께 순회해야 합니다. 바깥 반복문이 행을 고를 때마다 안쪽 반복문이 그 행의 열들을 확인합니다.

행 수와 열 수를 더해서는 모든 조합을 나열할 수 없습니다. 논리적인 격자 좌표는 그 자체로 비행이나 바퀴 이동 명령이 되지 않으므로 실제 경로의 모양과 거리를 따로 정해야 합니다.

읽고, 예상하고, 실행 따라가기

바깥쪽 행이 바뀔 때마다 안쪽 열 반복문은 처음부터 다시 시작합니다. 2행 3열 격자의 칸 수는 2 * 3입니다. 실제로 이동할 때는 행마다 진행 방향을 바꾸면 불필요하게 되돌아가는 거리를 줄일 수 있습니다.

• 바깥 반복문(outer loop): 행 하나를 고름
• 안쪽 반복문(inner loop): 그 행의 열들을 차례로 살핌
• 좌표(coordinate): 행과 열을 묶은 위치

for row in range(2):
    for col in range(2):
        print(row, col)

0 0
0 1
1 0
1 1

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print(2 * 3)

n = 0
for row in range(2):
    for col in range(3):
        n += 1
print(n)

for row in range(1):
    for col in range(3):
        print(row, col)

for day in range(2):
    for sensor in ["A", "B"]:
        print(day, sensor)

직접 만들어 보기

grid_cells(rows, cols)는 행을 기준으로 (row, col) 쌍을 차례로 반환합니다. 입력은 0 이상의 정수입니다. 행이 0인 경우와 열이 0인 경우도 검사하세요. 결과는 점검 목록이며 로봇을 움직이지 않습니다.

def grid_cells(rows, cols):
    cells = []
    return cells

print(grid_cells(2, 3))

assert grid_cells(2, 3) == [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
assert grid_cells(0, 3) == []
assert grid_cells(2, 0) == []

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 격자의 모든 칸을 한 번씩 나열하고, 논리적인 좌표와 실제 이동을 구분합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

점검 횟수는 왜 행 수와 열 수를 곱한 값일까요? 격자 번호만으로는 실제 로봇을 움직일 수 없는 이유도 설명해 보세요.

각 센서를 매일 확인하는 일정을 만듭니다. 어느 반복문이 다시 시작되는지, 전체 읽기 횟수는 몇 번인지 설명하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

결과를 화면에만 출력한 프로그램을 종료합니다. 다음 수업에서 어떤 기록을 다시 살펴볼 수 있을까요?

표를 파일로 저장하면 프로그램이 끝나도 남아 다른 도구로 다시 열 수 있습니다. 기록 형식과 출처를 함께 적어 두어야 나중에 측정값을 해석할 수 있습니다.

메모리의 리스트는 프로그램이 종료되면 사라지고, 성공한 실험만 복사하면 기록이 한쪽으로 치우칩니다. S1 Lab은 노트북의 CSV 파일을 직접 쓸 수 없으므로 관찰자가 제공된 노트북 도구로 실제 실험을 기록합니다.

읽고, 예상하고, 실행 따라가기

CSV는 첫 줄에 열 이름을 쓰고, 그다음부터 한 행에 기록 하나씩 저장합니다. DictWriter는 정해진 항목 목록에 맞춰 값을 씁니다. CSV의 값은 텍스트이므로 다시 읽은 숫자 문자열을 계산에 쓰려면 변환해야 합니다.

• 스키마(schema): 예상하는 열과 각 열의 의미
• 출처(provenance): 값을 어디서 얻었는지 나타내는 정보
• CSV: 쉼표로 항목을 나누어 저장하는 표 형태의 텍스트

import csv
from io import StringIO
text = "robot,target_cm\ntello,30\ns1,30\n"
rows = list(csv.DictReader(StringIO(text)))
print(len(rows), rows[0]["target_cm"])

2 30

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

import csv
from io import StringIO
r = list(csv.DictReader(StringIO("x\n3\n4\n")))
print(len(r))

import csv
from io import StringIO
r = next(csv.DictReader(StringIO("cm\n30\n")))
print(type(r["cm"]).__name__)

import csv
from io import StringIO
r = list(csv.DictReader(StringIO("cm\n20\n35\n")))
print(sum(int(x["cm"]) for x in r))

import csv
from io import StringIO
r = list(csv.DictReader(StringIO("day,rain_mm\nMon,0\nTue,2\n")))
print(r[0]["rain_mm"])

직접 만들어 보기

target_cm 열이 있는 CSV 텍스트를 읽어 목표 거리를 숫자로 바꾼 뒤 순서대로 반환하세요. 입력에는 유효한 정수 문자열이 들어 있습니다. 이어서 record_trial.py로 완료하거나 중단한 실제 실험을 origin=measured로 저장합니다. 연습용 가상 데이터를 고쳐 실측값처럼 쓰지 않습니다.

import csv
from io import StringIO

def read_targets(text):
    return []

print(read_targets("target_cm\n30\n40\n"))

assert read_targets("target_cm\n30\n40\n") == [30, 40]
assert read_targets("target_cm\n") == []
assert read_targets("target_cm\n0\n") == [0]

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 항목 이름·단위·출처·실패 결과를 포함한 실험 기록을 저장하고 다시 읽습니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

저장한 행에 실험 결과와 측정 방법을 함께 적어야 하는 이유는 무엇일까요?

다른 학생이 일주일 뒤에도 이해할 수 있도록 출처와 단위를 포함한 날씨 관찰 기록을 남기세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

거리를 적지 않은 빈칸과 숫자 0을 비교합니다. 모든 빈칸을 0으로 채우면 로봇의 성능을 더 잘 알 수 있을까요?

컴퓨터가 읽을 수 있는 파일에도 사용할 수 없거나 빠진 값이 들어 있을 수 있습니다. 변환 방법과 표시 이유를 명시하면 정리 과정을 확인할 수 있고, 없던 측정값을 만들어 넣는 일을 막을 수 있습니다.

빠진 거리를 0으로 바꾸면 큰 오차를 임의로 만들어 냅니다. 실패한 행을 모두 지우면 로봇이 실제보다 잘 작동한 것처럼 보입니다. 원본 파일을 보관하고 각 행을 어떻게 처리했는지 별도 파일에 남깁니다.

읽고, 예상하고, 실행 따라가기

pd.to_numeric(errors="coerce")는 숫자로 바꿀 수 없는 텍스트를 결측값으로 만듭니다. isna로 이를 찾고, 불리언 마스크로 분석 대상 행을 고릅니다. 제외한 행과 제외 이유도 다시 확인할 수 있어야 합니다.

• DataFrame: 열 이름이 있는 표
• 마스크(mask): 행마다 True/False로 선택 여부를 나타낸 값
• coerce: 숫자로 바꿀 수 없는 텍스트를 결측값으로 처리하는 옵션

import pandas as pd
s = pd.to_numeric(pd.Series(["30", "bad", "0"]), errors="coerce")
print(int(s.isna().sum()), int(s.dropna().sum()))

1 30

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

import pandas as pd
print(pd.isna(None))

import pandas as pd
s = pd.to_numeric(pd.Series(["20", "oops", "40"]), errors="coerce")
print(int(s.notna().sum()))

import pandas as pd
s = pd.Series([0.0, None, 30.0])
print(int(s.isna().sum()), int((s == 0).sum()))

import pandas as pd
s = pd.to_numeric(pd.Series(["0", "", "2"]), errors="coerce")
print(int(s.notna().sum()))

직접 만들어 보기

clean_distances(values)는 pandas로 문자열을 숫자로 바꾸고, 빠진 값과 음수를 제외한 나머지 값을 원래 순서대로 반환합니다. 이 작은 연습이 전체 실험 기록의 행을 지우는 것은 아닙니다. 전체 실험에서는 모든 시도의 결과 개수를 보관합니다.

import pandas as pd

def clean_distances(values):
    return []

print(clean_distances(["30", "", "-2", "0"]))

assert clean_distances(["30", "", "-2", "0"]) == [30, 0]
assert clean_distances(["bad", None]) == []
assert clean_distances([]) == []
assert clean_distances(["12.5"]) == [12.5]

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 숫자 텍스트를 변환해 누락되거나 불가능한 값을 찾고, 실패한 실험의 개수도 보관합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

실제로 측정한 0은 남기고 빠진 값은 통계에서 제외하는 것이 왜 둘 다 올바른 처리일까요?

관찰하지 않은 날을 비가 오지 않은 날로 바꾸지 않으면서 강수량 열을 정리하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

평균 오차는 같지만 값이 퍼진 정도가 다른 설정 두 개를 봅니다. 평균 하나로는 어떤 정보를 알 수 없을까요?

비슷한 조건끼리 묶어 비교하고 개수와 퍼짐을 함께 보면 요약값을 뒷받침하는 기록이 얼마나 있는지 알 수 있습니다. 각 점을 표시한 그래프는 평균에 가려진 차이를 보여 줍니다.

잘된 실험 한 번만으로 결론을 내리기는 어렵습니다. 서로 다른 로봇을 합치면 기계적인 차이가 가려집니다. 느린 실험과 빠른 실험의 바닥까지 다르면 속도와 바닥 중 무엇이 영향을 주었는지 구분하기 어렵습니다.

읽고, 예상하고, 실행 따라가기

부호 있는 오차는 실측값에서 목표를 뺀 값이고, 절대오차는 빗나간 크기입니다. 로봇과 조건별로 묶어 모든 시도의 결과를 세고, 거리 통계는 완료된 유효 측정값으로 계산합니다. 유효한 점을 모두 그리며 제외한 시도의 개수도 적습니다.

• 그룹(group): 비교할 수 있는 행의 묶음
• 절대오차(absolute error): 목표에서 빗나간 크기
• 교란 요인(confound): 함께 바뀌어 영향을 구분하기 어렵게 하는 다른 조건
• 퍼짐(spread): 시도 사이에서 값이 달라지는 정도

import pandas as pd
df = pd.DataFrame({"setting": ["slow", "slow", "fast", "fast"], "error_cm": [1, -1, 4, -4]})
df["abs_error"] = df["error_cm"].abs()
print(df.groupby("setting")["abs_error"].mean().to_dict())

{'fast': 4.0, 'slow': 1.0}

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

print((4 + -4) / 2)

errors = [3, -5]
print(sum(abs(e) for e in errors) / len(errors))

import pandas as pd
df = pd.DataFrame({"condition": ["a", "a", "b"], "error": [2, 4, 9]})
print(float(df.groupby("condition")["error"].mean()["a"]))

waits = [1, 1, 7]
print(max(waits) - min(waits))

직접 만들어 보기

error_summary(target_cm, observed_cm)는 개수, 부호 있는 오차의 평균, 절대오차의 평균, 부호 있는 오차의 범위를 반환합니다. 관찰값은 모두 완료된 유효 숫자입니다. 빈 리스트는 개수 0과 세 통계값에 대해 None을 반환합니다. 이어서 analyze_trials.py가 만든 그룹별 CSV와 그래프를 확인하세요.

def error_summary(target_cm, observed_cm):
    return {"n": 0, "bias_cm": None, "mae_cm": None, "range_cm": None}

print(error_summary(30, [29, 31]))

assert error_summary(30, [29, 31]) == {"n": 2, "bias_cm": 0, "mae_cm": 1, "range_cm": 2}
assert error_summary(30, []) == {"n": 0, "bias_cm": None, "mae_cm": None, "range_cm": None}
assert error_summary(30, [34])["mae_cm"] == 4

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 같은 로봇 안에서 설정을 짝지어 반복 비교합니다. 시도 수·절대오차·값의 퍼짐·결과 비율을 함께 보고 자료가 뒷받침하는 범위에서 설명합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

평균 오차와 함께 시도 수와 실패한 시도도 보고해야 하는 이유는 무엇일까요?

대기열 처리 규칙 두 개를 여러 번 비교하세요. 가장 짧았던 대기 시간만 보여 주지 말고 작업량과 실행 순서도 기록합니다.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.

어떤 문제를 풀까요?

표시된 지점 네 곳을 점검하고, 설정을 바꾸었을 때 더 안정적으로 작동했는지 설명해 달라는 요청을 받았습니다. 정답 코드를 보기 전에 어떤 구조를 쓸지 골라 보세요.

실제 작업에는 계획, 실행, 기록이 함께 필요합니다. 리스트는 지점의 순서, 딕셔너리는 읽기 값의 이름, 반복문은 반복이나 대기, 함수는 여러 번 쓸 판단을 맡는 식으로 각 구조의 역할을 정합니다.

로봇이 움직였다고 모든 지점을 점검한 것은 아닙니다. 공개 검사 통과만으로 이해도나 실제 장비의 신뢰성을 입증할 수도 없습니다. 가상 데이터로 그린 그래프는 실제 로봇의 결과가 아닙니다.

읽고, 예상하고, 실행 따라가기

미션 데이터, 동작 규칙, 관찰 기록을 구분합니다. 한 구간이라도 움직이기 전에 전체 경로를 검사하고, 정상 경로·빈 경로·허용하지 않는 값을 시험합니다. 알려진 지점은 정해진 순찰로 확인하고, 관찰 결과를 기다려야 할 때만 횟수가 제한된 대기를 사용합니다.

• 요구 사항(requirement): 관찰로 확인할 수 있는 성공 조건
• 통합(integration): 각 부분을 연결해 함께 작동시키는 것
• 재현성(reproducibility): 다른 사람도 같은 분석을 다시 실행할 수 있음

route_cm = [20, 30]
records = []
for station, distance_cm in enumerate(route_cm):
    records.append({"station": station, "target_cm": distance_cm})
print(len(records), records[1]["target_cm"])

2 30

실행 전에 풀어 보기

이 문제는 개념을 익히는 연습입니다. 답을 보거나 도움을 받아 푼 것은 연습 기록이며 LMS 수업 완료로 처리하지 않습니다.

route = [20, 30, 40]
print(len(route))

rows = []
for station in range(2):
    rows.append({"station": station})
print(rows[-1]["station"])

route = [20, 0, 30]
print(all(20 <= x <= 80 for x in route))

queue = ["A", "B"]
receipts = []
for job in queue:
    receipts.append({"job": job, "done": False})
print(receipts[1]["done"])

직접 만들어 보기

mission_plan(route_cm)는 기록을 만들기 전에 경로 전체를 검사합니다. 불리언을 제외한 정확한 int 자료형만 받으며, 값은 20~80 cm, 최대 네 구간, 전체 합계는 200 cm 이하여야 합니다. 그 밖의 입력에는 ValueError를 발생시킵니다. 구간마다 {station, target_cm} 딕셔너리를 하나씩 반환하세요. 이어서 제공된 실행 코드로 검토한 고정 경로를 시연하고 모든 시도를 기록한 뒤, 기록이 뒷받침하는 설명을 적습니다.

def mission_plan(route_cm):
    return []

print(mission_plan([20, 30]))

assert mission_plan([20, 30]) == [{"station": 0, "target_cm": 20}, {"station": 1, "target_cm": 30}]
assert mission_plan([]) == []
for route in ([0], [81], [True], [20.5], ["30"], [80, 80, 80], [20] * 5):
    try:
        mission_plan(route)
    except ValueError:
        pass
    else:
        raise AssertionError("invalid route accepted: " + repr(route))

• 구체적인 입력과 값의 변화를 따라가며 목표를 설명합니다: 각 구조를 선택한 이유를 설명하고, 정한 범위 안의 동작을 시연하며 다른 사람이 다시 확인할 수 있는 기록과 한계를 제시합니다.
• 시작 코드를 수정해 공개 검사를 통과하고, 예상과 실제 결과를 비교할 새 사례를 하나 추가합니다.
• 로봇 실험이나 모의실험임을 밝힌 결과물을 제시하고, 관찰의 한계와 조건을 바꾼 과제의 풀이를 설명합니다.

설명하고 다른 상황에 적용하기

반복문, 자료구조, 함수를 하나씩 골라 해결하는 요구 사항을 설명하세요. 다른 방법과, 어떤 경우에 그 방법을 택할지도 함께 이야기합니다.

사진 처리 대기열에 계획-실행-기록을 나누는 방식을 적용합니다. 그대로 설명할 수 있는 점과 새 근거가 필요한 점을 구분하세요.

코드, 예상 결과, 실제 결과와 관찰의 한계를 남깁니다. 명령 기록만 실행했다면 모의실험으로 표시하세요. 선생님과 상의해 첫 학습 약 2일 뒤와 7일 뒤에 새 문제로 다시 확인합니다. 간격은 필요에 따라 조정합니다.