[SK플래닛] ASAC 빅데이터전문가 11기 | 04일차

파이썬이 조금 더 익숙해진 날

4일차는 파이썬 문법을 하나 더 외운 날이라기보다, 왜 파이썬이 짧고 편하게 느껴지는지 조금 감이 잡힌 날에 가까웠다.

 

반복문, enumerate, *args, lambda, map, filter 같은 문법을 따로 보면 각각의 기능처럼 보이는데, 오늘은 실습 코드를 따라가면서 이 문법들이 전부 코드를 덜 길게 쓰고, 필요한 값을 더 빠르게 꺼내 쓰기 위한 도구라는 게 조금씩 보였다.

특히 for i in 리스트가 인덱스가 아니라 원소값을 순회한다는 점, input().split()으로 들어온 문자열을 map(int, ...)으로 숫자로 바꿔 다루는 흐름, 그리고 lambda처럼 한 번만 쓰고 끝낼 함수를 짧게 처리하는 방식이 인상적이었다.

오늘은 그 흐름을 기준으로 4일차에 남았던 포인트들을 정리해보려고 한다.

---

오늘 글은 이런 분께 맞습니다

• 파이썬 문법이 아직 낯선 분
• enumerate, lambda, map, filter가 헷갈리는 분
• 코드를 짧게 쓰는 감각을 익히고 싶은 분
• 실습 문제를 풀면서 왜 이런 문법을 쓰는지 알고 싶은 분

---

1. 파이썬 반복문 기초: for문은 정해진 대상을 처리할 때 더 편했다

오늘 실습에서 가장 먼저 다시 남은 건 반복문이었다.

강의에서는 반복문을 크게 for와 while로 나눠 설명했다.

for문은 돌릴 대상이 정해져 있을 때, while문은 언제 끝날지 아직 모를 때 더 자주 쓰인다는 흐름이었다.

데이터 처리에서는 대부분 이미 돌릴 대상이 정해져 있기 때문에 자연스럽게 for문을 더 자주 쓰게 된다는 설명도 함께 나왔다.

예전에는 그냥

“for는 이렇게 쓰는 거, while은 저렇게 쓰는 거”

정도로만 봤는데,

오늘은 둘을 문법이 아니라 상황에 따라 쓰는 방식으로 보게 됐다.

실습에서 본 코드는 이런 식이었다.

b = []

for i in range(len(a)):
    if i % 2 == 0:
        b.append(a[i] + "h")

print(b)

짧은 코드인데도 흐름이 분명했다.

• len(a)로 길이를 구하고
• range()로 인덱스를 만들고
• if로 짝수번째만 걸러서
• append()로 결과를 모은다

단순한 예제처럼 보이지만, 이 안에는 이미 반복 → 조건 확인 → 결과 저장 구조가 다 들어가 있다.

여기서 내가 제일 크게 느낀 건,

for문이 그냥 반복 문법이 아니라 데이터를 하나씩 처리하는 기본 골격이라는 점이었다.

---

2. len()과 인덱스 사용법: 리스트를 규칙적으로 다룰 때 왜 필요한지 보였다

예전에는 len()도 그냥 길이 구하는 함수 정도로만 외웠다.

그런데 오늘은 왜 필요한지가 조금 더 명확하게 보였다.

리스트 길이는 상황에 따라 달라질 수 있는데,

그걸 사람이 하나씩 세면서 맞춰 쓸 수는 없다.

결국 리스트 원소가 4개든 10개든 100개든 같은 구조로 처리하려면, 코드가 리스트 길이를 스스로 알아야 한다.

예를 들면 이런 식이다.

a = ["a", "b", "c", "d"]

for i in range(len(a)):
    print(i, a[i])

이 코드는 아주 단순하지만,

리스트 길이가 바뀌어도 같은 구조로 계속 돌릴 수 있다는 점에서 되게 중요하게 느껴졌다.

처음엔

“왜 굳이 len()까지 쓰지?”

싶었는데,

이제는 오히려

“길이를 코드가 알아야 하드코딩 안 하고 계속 재사용할 수 있겠구나”

쪽으로 생각이 바뀌었다.

---

3.enumerate

사용법: 인덱스와 값을 같이 꺼낼 때 코드가 훨씬 깔끔해졌다

오늘 다시 보면서 진짜 실용적이라고 느낀 문법이 enumerate였다.

기본 형태는 이렇다.

for i, v in enumerate(a_list):
    print(i, v)

전에는 그냥

“인덱스를 같이 꺼내주는 함수”

정도로만 알고 있었는데, 실제로 보니까 이건 꽤 편했다.

예를 들어 인덱스와 값을 같이 쓰고 싶을 때,

평범하게 쓰면 보통 이렇게 된다.

a_list = ["apple", "banana", "grape"]

for i in range(len(a_list)):
    print(i, a_list[i])

물론 이것도 맞는 코드다.

그런데 enumerate를 쓰면 더 바로 읽힌다.

a_list = ["apple", "banana", "grape"]

for i, v in enumerate(a_list):
    print(i, v)

오늘 여기서 제일 크게 남은 포인트는 이거였다.

파이썬에서 for i in 리스트는 인덱스가 아니라 원소값을 돈다.

예를 들면:

a_list = ["a", "b", "c"]

for i in a_list:
    print(i)

여기서 i는 0, 1, 2가 아니라 "a", "b", "c"다.

이걸 알고 나니까

언제 range(len(...))를 써야 하는지,

언제 enumerate()를 쓰는 게 더 좋은지,

언제 그냥 값만 꺼내면 되는지가 훨씬 또렷해졌다.

이건 오늘 내 기준에서 진짜 WOW point였다.

---

4. 파이썬 자료형 정리: list, tuple, set, dict 를 상황별로 보는 연습

오늘 자료형 정리 파트도 꽤 크게 남았다.

강의에서는 여러 값을 다루는 기본 자료형으로 리스트, 튜플, set, dict를 다시 짚어줬는데, 이걸 그냥 정의처럼 외우는 것보다 왜 다르게 생겼는지를 보는 쪽이 더 도움이 됐다.

내 기준에서 다시 정리하면 이런 느낌이다.

하나의 값을 다룰 때

• 정수
• 실수
• 복소수
• 문자 1개
• True / False

여러 개의 값을 다룰 때

• 리스트
• 튜플
• set
• dict

실제로 짧게 보면 이런 식이다.

# list
a = [1, 2, 3]
a.append(4)

# tuple
b = (1, 2, 3)

# set
c = {1, 1, 2, 3}
print(c)  # {1, 2, 3}

# dict
d = {"name": "min", "age": 20}
print(d["name"])

오늘 보면서 다시 느낀 건 이거였다.

• list는 수정 가능
• tuple은 수정 불가
• set은 중복 제거
• dict는 키로 접근

예전에는 자료형을 그냥 외워야 하는 개념처럼 봤는데,

오늘은

“지금 이 데이터를 뭘로 담는 게 맞을까?”를 정하는 문제

처럼 보였다.

이건 생각보다 관점이 많이 달라진 부분이었다.

---

5. dict 사용 이유: 왜 딕셔너리를 작은 데이터베이스처럼 쓰는지 알 것 같았다

자료형 중에서는 dict가 특히 더 인상에 남았다.

강의에서는 dict를 단순히 값을 나열하는 구조가 아니라,

키와 값을 연결해서 각 데이터에 접근할 수 있게 만드는 구조로 설명했다.

값을 모아두는 것에서 끝나는 게 아니라, 각 값에 이름표를 붙여두는 느낌에 가까웠다.

예를 들면 이런 식이다.

data = {
    "name": "min",
    "age": 20,
    "job": "student"
}

print(data["name"])
print(data["age"])

비슷한 걸 리스트로 보면 느낌이 다르다.

person = ["min", 20, "student"]
print(person[0])  # 이게 name인지 기억해야 함

딕셔너리로 바꾸면 더 바로 읽힌다.

person = {
    "name": "min",
    "age": 20,
    "job": "student"
}

print(person["name"])

여기서 내가 알게 된 건,

딕셔너리는 단순한 자료형이 아니라 찾는 방식 자체를 바꿔주는 도구라는 점이었다.

리스트는 순서를 알아야 접근하지만,

딕셔너리는 키만 알면 바로 꺼낼 수 있다.

그래서 왜 딕셔너리를 작은 데이터베이스 같다고 하는지 조금 알 것 같았다.

---

6. 파이썬 함수 기초: 입력, 출력, 기능을 묶는다는 말이 조금 이해됐다

오늘 함수 파트도 꽤 남았다.

강의에서는 함수를 입력과 출력, 그리고 그 둘의 관계를 묶는 기능 단위로 설명했다.

예전에는 그냥 def 문법부터 외우는 느낌이었는데, 오늘은 그보다 먼저 입력 → 처리 → 출력 흐름으로 보게 됐다.

가장 단순하게 보면 이런 식이다.

def add_one(x):
    return x + 1

print(add_one(3))

이 코드는 짧지만 구조가 분명하다.

• 입력: x
• 처리: x + 1
• 출력: return

그래서 오늘은 함수가 문법이라기보다,

반복되는 작업에 이름을 붙여서 묶는 방식처럼 느껴졌다.

그리고 프로그래머스 같은 코딩테스트 사이트에서는 직접 input()을 계속 받기보다, 문제에서 요구하는 solution() 함수를 작성해서 테스트 케이스를 여러 번 호출하는 방식이 많다는 설명도 같이 나왔다.

그 얘기를 들으니까

왜 함수 구조가 중요한지도 조금 더 현실적으로 보였다.

---

*7. args 사용법: 인자 개수가 달라도 받을 수 있는 함수가 편했다

오늘 함수 파트에서 제일 기억에 남은 건 *args였다.

• args는 몇 개가 들어올지 모르는 입력을 한꺼번에 받는 방식이다.

즉 하나를 넣든, 세 개를 넣든, 열 개를 넣든 들어오는 만큼 묶어서 처리할 수 있다.

정리된 형태는 이런 식이다.

def sumrandom(*args):
    result = 0

    for i in args:
        result += i

    return result

그리고 이걸 실제 입력이랑 연결하면 이렇게 된다.

def sumrandom(*args):
    result = 0

    for i in args:
        result += i

    return result

total = list(map(int, input().split()))
print(sumrandom(*total))

이 코드는 짧은데 생각보다 많은 걸 담고 있다.

• input()으로 문자열을 받고
• split()으로 나누고
• map(int, ...)으로 숫자로 바꾸고
• list()로 묶은 다음
• 를 붙여서 함수 인자로 풀어준다

처음에는 *args가 그냥 특이한 문법처럼 보였는데,

지금은 오히려

“입력이 몇 개 들어올지 모를 때 진짜 편하겠다”

쪽으로 보인다.

오늘 여기서 느낀 건,

문법을 따로 외우는 것보다

입력이 어떤 형태로 들어오고, 그걸 함수에 어떻게 넘길지 이해하는 게 훨씬 중요하다는 점이었다.

---

8. input().split()과 map(int, ...) 정리: 문자열 입력을 숫자 리스트로 바꾸는 흐름

예전에는 아래 코드만 보면 괜히 긴장했다.

list(map(int, input().split()))

한 줄에 너무 많은 게 들어가 있는 느낌이었기 때문이다.

그런데 오늘은 이걸 단계별로 끊어서 보니까 훨씬 덜 복잡하게 느껴졌다.

s = input()              # 예: "10 20 30"
parts = s.split()        # ["10", "20", "30"]
nums = list(map(int, parts))  # [10, 20, 30]

이걸 한 줄로 줄이면 다시 이렇게 된다.

nums = list(map(int, input().split()))

즉 흐름은 명확하다.

• 입력받고
• 쪼개고
• 숫자로 바꾸고
• 리스트로 묶는다

예전에는 그냥 통째로 외우는 느낌이었는데,

오늘은

“아, 입력을 이런 단계로 정리하는구나”

가 보였다는 점이 꽤 컸다.

이건 오늘 또 다른 WOW point였다.

---

9. lambda, map, filter 정리: 짧게 처리하는 문법이 왜 자주 쓰이는지 보였다

오늘 실습에서 제일 파이썬스럽다고 느껴진 건 lambda였다.

lambda는 이름 없는 일회용 함수처럼 보였다.

굳이 함수 이름을 따로 만들지 않고, 필요한 순간에 바로 써버릴 수 있다는 점이 인상적이었다.

예시는 이런 식이었다.

data = [('a', 3), ('b', 1), ('c', 2)]
sorted(data, key=lambda x: x[1])

list(map(lambda x: x * 2, [1, 2, 3]))
list(filter(lambda x: x > 0, [-1, 2, -3, 4]))

(lambda a, b: a + b)(10, 20)

특히 정렬 기준을 줄 때가 제일 인상적이었다.

data = [('a', 3), ('b', 1), ('c', 2)]

result = sorted(data, key=lambda x: x[1])
print(result)

이건 굳이 함수 하나를 따로 선언하지 않아도

“두 번째 값 기준으로 정렬할게요”를 바로 적을 수 있다.

그리고 map, filter도 같이 보면 더 이해가 됐다.

print(list(map(lambda x: x * 2, [1, 2, 3])))
print(list(filter(lambda x: x > 0, [-1, 2, -3, 4])))

• map은 값을 바꾸는 쪽
• filter는 조건으로 거르는 쪽

즉 둘 다 반복문으로 길게 쓸 수 있는 걸 조금 더 짧게 표현하는 방법이었다.

예전엔 lambda가 어려운 문법처럼 느껴졌는데,

지금은 오히려

“굳이 이름 만들 필요 없을 때 짧게 쓰는 함수”

쪽으로 보인다.

이렇게 보니까 훨씬 덜 부담스럽다.

---

10. 리스트 컴프리헨션 감각: 반복문과 조건문을 짧게 줄여 쓰는 방식 익히기

오늘 강의에서는 리스트 컴프리헨션 얘기도 함께 나왔다.

이건 결국 for문으로 돌리면서 무언가를 모으고, 필요하면 조건까지 붙이는 걸 짧게 줄여 쓰는 방식이다.

처음엔 조금 낯설지만, 흐름만 보면 반복문과 크게 다르지 않다.

예를 들어 반복문으로 쓰면 이런 식이다.

result = []

for x in [1, 2, 3, 4]:
    if x % 2 == 0:
        result.append(x * 2)

print(result)

이걸 리스트 컴프리헨션으로 바꾸면 이렇게 된다.

result = [x * 2 for x in [1, 2, 3, 4] if x % 2 == 0]
print(result)

if/else가 둘 다 들어가면 이런 식도 가능하다.

result = [x + 2 if x % 2 == 0 else x + 5 for x in [1, 2, 3, 4]]
print(result)

아직은 눈에 바로 익지는 않지만,

왜 사람들이 자꾸 “파이썬은 짧게 쓴다”고 하는지는 여기서 더 느껴졌다.

단순히 줄 수를 줄이는 느낌보다는,

반복 + 조건 + 결과 모으기를 하나의 구조로 본다는 쪽이 더 가까웠다.

---

11. 오늘 정리: 파이썬은 복잡하게 쓰는 언어가 아니라, 간결하게 쓰는 언어였다

오늘 강의를 쭉 따라가면서 느낀 건 문법들이 따로 노는 게 아니라는 점이었다.

반복문은 돌리고,

조건문은 나누고,

함수는 묶고,

자료형은 담고,

enumerate는 인덱스와 값을 같이 꺼내고,

• args는 유동적인 입력을 받고,

lambda, map, filter는 짧게 처리하게 도와준다.

결국 방향은 비슷했다.

파이썬은 복잡한 걸 간단하게 적게 해주는 언어 같다.

오늘 실습에서 남은 문장도 딱 이 느낌이었다.

파이썬은 필요한 걸 빠르고 간결하게 표현하는 언어

전에는 이 말이 조금 추상적으로 들렸는데,

오늘은 왜 그렇게 말하는지 조금 알 것 같았다.

---

마무리

4일차는 파이썬이 조금 덜 낯설어진 날이었다.

아직 enumerate, lambda, map, filter를 완전히 자연스럽게 쓰는 단계는 아니지만, 적어도 이제는 왜 이런 문법을 배우는지 조금은 알 것 같다.

예전에는 문법을 하나씩 따로 외우는 느낌이 강했다면,

오늘은 그 문법들이 결국 다 코드를 더 짧고 덜 번거롭게 만들기 위한 도구라는 게 보였다.

그리고 오늘 제일 크게 남은 건 이것 같다.

문법을 외우는 것보다,

“이걸 더 짧고 읽기 좋게 쓰려면 어떻게 바꿀까”를 먼저 생각하는 게 더 중요하다.

파이썬은 결국 생각을 더 단순하게 적게 해주는 언어인 것 같다.