A-2: 연산과 문자열 — 계산하고, 글자를 자르고 합치기

안녕하세요! 여러분의 파이썬 가이드, 홍순구 튜터입니다.

지난 시간엔 변수에 값을 담고, 값의 종류(int·float·str·bool)를 type() 으로 확인하고, input() 과 print() 로 사용자와 묻고 답했죠. 빨간 에러 메시지를 읽는 법까지 익혔고요.

오늘은 그 값들을 가지고 본격적으로 계산을 하고, 글자(문자열)를 자르고 다듬고 합치는 도구들을 배웁니다. 지난 시간 REPL에서 2 + 2 를 살짝 맛봤는데, 오늘은 그 계산을 제대로 파헤쳐요. 그리고 인사말에 썼던 f-string의 정체도 드디어 밝혀집니다.

오늘 우리는 이런 길을 따라갑니다.

 오늘의 여정 — A-2 (총 8 단계)

  1. 산술 연산자   — 계산기가 된 파이썬
  2. 비교 연산자   — 참이야 거짓이야
  3. 논리 연산자   — and·or·not 으로 조건 묶기
  4. 형 변환       — 글자를 숫자로, 숫자를 글자로
  5. f-string      — 정체를 제대로 파헤치기
  6. 인덱싱·슬라이싱 — 글자 자르기
  7. 문자열 메서드  — 글자 다듬기
  8. split·join    — 해시태그 분리하고 다시 합치기

앞쪽 1~4단계는 숫자 계산, 뒤쪽 5~8단계는 글자 다루기예요. 한꺼번에 외우려 하지 말고, 직접 실행해 보면서 하나씩 익혀가요.

💡 오늘 수업의 핵심 — "숫자로 계산하고, 글자(문자열)를 자르고 다듬고 합치기"

🎯 학습 목표

• 산술·비교·논리 연산자로 계산하고 참/거짓을 판단할 수 있다
• int()·str()·float() 로 값의 종류를 바꾸고, 왜 input() 값을 변환해야 하는지 안다
• f-string으로 값을 끼워 넣고, 천단위·소수 자릿수 같은 형식을 지정할 수 있다
• 인덱싱·슬라이싱과 문자열 메서드(upper/strip/replace/split/join)로 글자를 자유롭게 다룰 수 있다

Step 1: "계산기가 된 파이썬 — 산술 연산자"

지난 시간 REPL에서 2 + 2 를 입력했더니 파이썬이 곧장 4 라고 답했죠. 파이썬은 아주 훌륭한 계산기예요. 오늘은 더하기를 넘어 다양한 계산 기호를 만나봅니다. 이렇게 계산에 쓰는 기호들을 산술 연산자(arithmetic operator)라고 불러요.

REPL로 계산기 두드려보기

REPL을 다시 켜고(uv run python) 한 줄씩 입력해 봅시다.

>>> 7 + 3
10
>>> 7 - 3
4
>>> 7 * 3
21
>>> 7 / 3
2.3333333333333335

더하기(+)·빼기(-)·곱하기(*)는 익숙하죠. 나누기는 별표가 아니라 빗금(/)을 씁니다. 그런데 결과를 보면 2.333... 처럼 소수가 나왔어요. 파이썬에서 / 나눗셈은 항상 소수(float) 로 답한다는 걸 기억해 두세요.

여기까지는 사칙연산이고, 파이썬에는 자주 쓰는 계산 기호가 세 개 더 있어요.

>>> 7 // 3
2
>>> 7 % 3
1
>>> 2 ** 10
1024

• // 는 나눗셈의 몫만 가져와요. 7을 3으로 나누면 3이 두 번 들어가고 1이 남으니, 몫은 2.
• % 는 나눗셈의 나머지예요. 7을 3으로 나눈 나머지는 1.
• ** 는 거듭제곱이에요. 2 ** 10 은 2를 열 번 곱한 1024.

// 와 % 는 한 쌍으로 떠올리면 쉬워요.

   7 // 3  →  2     (몫: 3이 두 번 들어감)
   7 % 3   →  1     (나머지: 그러고 1이 남음)

%(나머지)는 "짝수냐 홀수냐"를 가릴 때 두고두고 쓰니 눈에 익혀두면 좋아요. 연산자 일곱 개를 한 표로 정리하면 이렇습니다.

파일로 정리해 인스타에 적용하기

REPL은 실험용이라 끄면 입력한 게 사라지죠. 이번엔 파일에 담아 게시물 좋아요 수를 계산해 봅시다.

# src/a_intro/a2_operators.py
# 게시물 두 개의 좋아요 수
likes_post1 = 120
likes_post2 = 86

total_likes = likes_post1 + likes_post2
print(f"좋아요 합계: {total_likes}")

# 나누기 두 가지 — / 는 항상 소수(float), // 는 몫만(정수)
post_count = 3
average_float = total_likes / post_count
average_floor = total_likes // post_count
print(f"게시물당 평균 좋아요(/): {average_float}")
print(f"게시물당 평균 좋아요(//, 몫만): {average_floor}")

여기 f"..." 는 지난 시간에 맛본 그 f-string이에요. 정체는 Step 5에서 제대로 파헤치니, 지금은 "중괄호에 값을 끼워 출력한다" 정도로만 보고 넘어가요.

▶ 버튼으로 실행하거나 터미널에서 uv run python src/a_intro/a2_operators.py 를 입력하면 이렇게 나옵니다.

좋아요 합계: 206
게시물당 평균 좋아요(/): 68.66666666666667
게시물당 평균 좋아요(//, 몫만): 68

같은 나눗셈인데 / 는 68.66... 이라는 소수를, // 는 68 이라는 깔끔한 정수를 돌려줬죠. "몇 개씩 나눠 가질 수 있나" 처럼 정수가 필요할 땐 // 가 딱 맞아요.

💡 한 줄 정리

산술 연산자는 계산 기호예요. / 는 항상 소수, // 는 몫, % 는 나머지, ** 는 거듭제곱을 돌려줍니다.

Step 2: "참이야 거짓이야 — 비교 연산자"

지난 시간 '생각해볼 주제'에서 이런 질문을 던졌어요. "= 는 왜 '같다'가 아니라 '담는다'일까?" 오늘 그 답의 반쪽이 나옵니다. 값을 담을 땐 등호 하나(=), 두 값이 같은지 비교할 땐 등호 두 개(==)를 써요. 이렇게 두 값을 견주어 보는 기호를 비교 연산자(comparison operator)라고 부릅니다.

= 와 == 는 완전히 다른 기호

REPL에서 차이를 확인해 봅시다.

>>> likes = 120
>>> likes == 120
True
>>> likes == 200
False

• likes = 120 은 "likes 이름표에 120을 담아라" 라는 대입이에요 (지난 시간에 배웠죠).
• likes == 120 은 "likes 가 120과 같니?" 라고 묻는 거예요. 같으니 True.
• likes == 200 은 200과 같냐고 묻는 거고, 다르니 False.

비교의 답은 늘 True(참) 아니면 False(거짓), 둘 중 하나예요. 지난 시간에 배운 bool 자료형 기억나죠? 비교 연산자는 바로 그 bool 값을 만들어내는 도구랍니다.

여섯 가지 비교 연산자

파일로 두 게시물의 좋아요 수를 견주어 봅시다.

# src/a_intro/a2_operators.py
# = 는 "대입"(값을 담기), == 는 "비교"(같은지 묻기)
my_likes = 120
your_likes = 86

print(f"내 좋아요와 네 좋아요가 같은가(==): {my_likes == your_likes}")
print(f"내 좋아요와 네 좋아요가 다른가(!=): {my_likes != your_likes}")
print(f"내 좋아요가 더 큰가(>): {my_likes > your_likes}")
print(f"내 좋아요가 더 작은가(<): {my_likes < your_likes}")
print(f"내 좋아요가 120 이상인가(>=): {my_likes >= 120}")
print(f"네 좋아요가 100 이하인가(<=): {your_likes <= 100}")

실행하면 이렇게 나와요.

내 좋아요와 네 좋아요가 같은가(==): False
내 좋아요와 네 좋아요가 다른가(!=): True
내 좋아요가 더 큰가(>): True
내 좋아요가 더 작은가(<): False
내 좋아요가 120 이상인가(>=): True
네 좋아요가 100 이하인가(<=): True

여섯 개를 표로 정리하면 이렇습니다.

💡 한 줄 정리

비교 연산자(== != > < >= <=)는 두 값을 견주어 True/False 를 돌려줘요. 값을 담을 땐 =, 같은지 물을 땐 == 입니다.

Step 3: "and·or·not 으로 조건 묶기 — 논리 연산자"

비교 하나로는 "좋아요가 100 이상인가?" 같은 단순한 질문만 할 수 있어요. 그런데 실제로는 "좋아요도 많고 댓글도 많은가?" 처럼 조건을 여러 개 묶고 싶을 때가 많죠. 이때 쓰는 게 논리 연산자(logical operator) and·or·not 입니다.

and·or·not 으로 인기 게시물 판단하기

# src/a_intro/a2_operators.py
# 인기 게시물 기준: 좋아요 100 이상 그리고(and) 댓글 10 이상
likes = 120
comments = 14

is_many_likes = likes >= 100
is_many_comments = comments >= 10
is_popular = is_many_likes and is_many_comments
print(f"좋아요 100 이상인가: {is_many_likes}")
print(f"댓글 10 이상인가: {is_many_comments}")
print(f"인기 게시물인가(and): {is_popular}")

# 둘 중 하나만 만족해도 추천: 좋아요 1000 이상 또는(or) 댓글 100 이상
is_viral = likes >= 1000 or comments >= 100
print(f"화제의 게시물인가(or): {is_viral}")

# not 으로 결과를 뒤집기 — 인기 게시물이 아닌가?
is_not_popular = not is_popular
print(f"인기 게시물이 아닌가(not): {is_not_popular}")

실행 결과예요.

좋아요 100 이상인가: True
댓글 10 이상인가: True
인기 게시물인가(and): True
화제의 게시물인가(or): False
인기 게시물이 아닌가(not): False

세 연산자의 성격을 한눈에 보면 이래요.

• and 는 양쪽이 둘 다 참이어야 참. 좋아요도 많고(True) 댓글도 많으니(True) 인기 게시물은 True.
• or 는 하나만 참이어도 참. 좋아요 1000 이상도, 댓글 100 이상도 아니니 화제글은 False.
• not 은 참·거짓을 뒤집어요. 인기 게시물이 True 니, "아닌가?"는 False.

and 와 or 의 모든 경우를 표로 그리면 이렇습니다.

   A        B       A and B     A or B
 ───────────────────────────────────────
 True     True       True        True
 True     False      False       True
 False    True       False       True
 False    False      False       False

오늘 만든 이 True/False 는 그냥 출력하고 끝나는 게 아니에요. 다음 시간엔 이 참·거짓을 가지고 '갈림길'을 만듭니다. "좋아요가 100 이상이면(if) 인기글로 표시하고, 아니면 일반글로 두라" 처럼요. 오늘 만든 판단(is_popular)이 다음 시간 if 문의 재료가 되는 거예요.

💡 한 줄 정리

논리 연산자는 and(둘 다 참), or(하나만 참), not(뒤집기). 비교로 만든 참·거짓을 묶어 더 똑똑한 판단을 만들어요.

Step 4: "글자를 숫자로, 숫자를 글자로 — 형 변환"

지난 시간 input() 으로 사용자 입력을 받았죠. 그런데 input() 에는 한 가지 함정이 있어요. 숫자를 입력해도 항상 글자(str)로 준다는 거예요.

input 이 준 값은 늘 글자

# src/a_intro/a2_convert.py
age_text = "25"          # input("나이: ") 로 받으면 이렇게 글자로 들어와요
print(f"age_text 의 종류: {type(age_text)}")        # <class 'str'>

# 글자끼리 + 는 '이어붙이기' 라서 계산이 안 돼요
two_texts = "25" + "10"
print(f'"25" + "10" (글자 이어붙이기): {two_texts}')  # 2510

age_text 의 종류: <class 'str'>
"25" + "10" (글자 이어붙이기): 2510

"25" + "10" 이 35가 아니라 2510 이 나왔어요! 글자끼리의 + 는 계산이 아니라 '이어붙이기' 라서 그래요.

int() 로 글자를 숫자로, str()·float() 로 바꾸기

age = int(age_text)
next_age = age + 1
print(f"int 로 바꾼 뒤 +1: {next_age}")              # 26

likes = 206
likes_text = str(likes)
print("str 로 바꾼 좋아요: " + likes_text + "개")     # 글자끼리 이어붙이기 OK

height_text = "175.5"
height = float(height_text)
print(f"float 로 바꾼 키: {height} (종류: {type(height)})")

int 로 바꾼 뒤 +1: 26
str 로 바꾼 좋아요: 206개
float 로 바꾼 키: 175.5 (종류: <class 'float'>)

int() 는 글자를 정수로, float() 는 소수로, str() 은 숫자를 글자로 바꿔줘요. 글자 "25" 를 int() 로 바꾸니 진짜 숫자가 되어 +1 계산이 됐죠.

에러는 친구 — 글자와 숫자를 그냥 더하면?

지난 시간에 "에러는 친구" 라고 했죠? 일부러 글자와 숫자를 그냥 더해보고, 파이썬이 뭐라고 하는지 들어봅시다.

# src/a_intro/a2_convert_error.py
likes_text = "10"            # input() 으로 받으면 글자
bonus = 5                    # 숫자
total = likes_text + bonus   # 여기서 TypeError — 글자 + 숫자는 안 돼요
print(total)

실행하면 빨간 메시지가 떠요.

Traceback (most recent call last):
  File ".../a2_convert_error.py", line 7, in <module>
    total = likes_text + bonus   # 여기서 TypeError — 글자 + 숫자는 안 돼요
            ~~~~~~~~~~~^~~~~~~
TypeError: can only concatenate str (not "int") to str

TypeError 는 "종류(Type)가 안 맞아요" 라는 뜻이에요. 메시지 "can only concatenate str (not "int") to str" 는 "글자(str)에는 글자만 이어붙일 수 있고, 숫자(int)는 안 돼" 라는 거고요. 화살표 ^ 가 문제가 난 자리를 정확히 가리켜 주죠. 해결책은 간단해요. bonus 를 str(bonus) 로 글자로 바꾸거나, likes_text 를 int(likes_text) 로 숫자로 바꾸면 됩니다.

💡 한 줄 정리

int()·str()·float() 로 값의 종류를 바꿔요. 특히 input() 이 준 글자는 계산하기 전에 int()/float() 로 바꿔야 합니다.

Step 5: "f-string 제대로 파헤치기"

지난 시간 인사말에 f"안녕하세요 @{name}" 같은 걸 썼죠. 그때 "맨 앞의 f 는 뭐지?" 싶었을 거예요. 드디어 그 정체를 밝힙니다.

f 와 {} 의 정체

f-string은 따옴표 앞에 f 를 붙인 글자예요. 그 안에서 중괄호 {} 로 감싼 부분은 '값으로 바뀌어' 글자에 끼워집니다.

# src/a_intro/a2_fstring.py
username = "minji"
likes = 1240
comments = 86

# 1) f 와 {} — 중괄호 안의 변수가 값으로 바뀐다
print(f"@{username} 님의 게시물")

@minji 님의 게시물

{username} 자리에 변수 값 minji 가 쏙 들어갔죠.

중괄호 안에는 '식'도 넣을 수 있다

# 2) 중괄호 안에는 '식'도 넣을 수 있다 (계산 결과가 들어감)
print(f"좋아요 + 댓글 = {likes + comments}")
print(f"2의 10제곱 = {2 ** 10}")

좋아요 + 댓글 = 1326
2의 10제곱 = 1024

Step 1에서 배운 연산자를 중괄호 안에서 바로 계산할 수 있어요. {likes + comments} 가 1326 으로 바뀌어 들어갔죠.

보기 좋게 — 형식 지정

# 3) 포맷 지정 — 큰 수에 천단위 콤마(:,)
big_likes = 1234567
print(f"누적 좋아요: {big_likes:,}")           # 1,234,567

# 4) 포맷 지정 — 소수점 자리수(:.2f)
rating = 4.5678
print(f"평점: {rating:.2f}")                  # 4.57

누적 좋아요: 1,234,567
평점: 4.57

중괄호 안에서 : 뒤에 형식을 적어요. {값:,} 는 천 단위마다 콤마를 찍어주고, {값:.2f} 는 소수 둘째 자리까지 반올림해 보여줘요. 큰 숫자나 평점을 사람이 읽기 좋게 다듬을 때 아주 유용하답니다.

여러 줄도 한 번에 — 멀티라인 f-string

# 5) 멀티라인 f-string — 따옴표 세 개(""")로 여러 줄을 한 번에
card = f"""[게시물 카드]
작성자 : @{username}
좋아요 : {big_likes:,}
평점   : {rating:.2f}"""
print(card)

[게시물 카드]
작성자 : @minji
좋아요 : 1,234,567
평점   : 4.57

따옴표 세 개(""")로 감싸면 여러 줄짜리 글자를 한 번에 만들 수 있어요. 줄을 나눈 모양 그대로 출력되죠.

💡 한 줄 정리

f-string은 따옴표 앞에 f 를 붙이고 {} 안에 변수나 식을 넣어 글자에 끼우는 도구예요. :, :.2f 로 형식을 지정하고, """ 로 여러 줄도 만들어요.

Step 6: "글자 자르기 — 인덱싱과 슬라이싱"

지금까지 글자를 통째로 다뤘는데, 이번엔 글자 속 한 글자, 또는 일부분만 꺼내봅니다.

글자마다 번호가 있다

문자열의 각 글자에는 0 부터 시작하는 번호(인덱스)가 붙어 있어요.

   "instagram"
    i  n  s  t  a  g  r  a  m
    0  1  2  3  4  5  6  7  8     ← 앞에서부터 (0)
   -9 -8 -7 -6 -5 -4 -3 -2 -1     ← 뒤에서부터 (-1)

   [0:4]  →  i n s t  →  "inst"   (0,1,2,3 — 4번 직전까지!)

# src/a_intro/a2_strings.py
username = "instagram"

print(f"첫 글자 [0]: {username[0]}")           # i
print(f"마지막 글자 [-1]: {username[-1]}")       # m
print(f"앞 4글자 [0:4]: {username[0:4]}")        # inst
print(f"글자 수 len(): {len(username)}")         # 9

첫 글자 [0]: i
마지막 글자 [-1]: m
앞 4글자 [0:4]: inst
글자 수 len(): 9

• [0] 은 첫 글자예요. 번호가 1이 아니라 0부터 시작한다는 게 핵심이에요.
• [-1] 처럼 음수를 쓰면 뒤에서부터 세요. 마지막 글자는 [-1].
• [0:4] 처럼 콜론으로 범위를 주면 일부분을 잘라내요. 이걸 슬라이싱이라고 해요.
• len() 은 글자 수를 알려줘요. "instagram" 은 9글자.

💡 한 줄 정리

인덱싱 [n] 은 n번째 글자 하나(0부터, 음수는 뒤에서). 슬라이싱 [start:end] 는 start부터 end '직전'까지 잘라내요.

Step 7: "글자 다듬기 — 문자열 메서드"

문자열에는 스스로를 다듬는 편리한 기능들이 딸려 있어요. 이렇게 어떤 값에 점(.)을 찍어 부르는 기능을 메서드(method)라고 해요. (지난 시간 type() 처럼 그냥 부르는 건 함수, 점을 찍어 부르는 건 메서드인데, 이름 구분은 나중에 자세히 다뤄요. 지금은 "점 뒤에 붙는 기능" 정도면 충분해요.)

upper·lower·strip·replace

# src/a_intro/a2_strings.py
caption = "  Hello Instagram!  "

print(f"대문자: {caption.upper()}")
print(f"소문자: {caption.lower()}")
print(f"공백 제거: '{caption.strip()}'")
print(f"바꾸기: {caption.replace('Instagram', '인스타그램')}")
print(f"원본은 그대로: '{caption}'")

대문자:   HELLO INSTAGRAM!  
소문자:   hello instagram!  
공백 제거: 'Hello Instagram!'
바꾸기:   Hello 인스타그램!  
원본은 그대로: '  Hello Instagram!  '

• upper() / lower() 는 모두 대문자 / 모두 소문자로 바꿔요.
• strip() 은 앞뒤 공백을 없애요. 작은따옴표로 감싸 출력하니 공백이 사라진 게 보이죠.
• replace(찾을글자, 바꿀글자) 는 특정 글자를 다른 글자로 바꿔요.

중요 — 문자열은 '불변', 원본은 그대로

맨 아래 출력을 보세요. upper·strip·replace 를 다 했는데도 caption 원본은 공백도 대소문자도 그대로예요! 문자열 메서드는 원본을 바꾸지 않고 '다듬은 새 글자' 를 만들어 돌려주거든요. 이걸 문자열은 불변(immutable)이라고 해요. 바뀐 결과를 쓰려면 clean = caption.strip() 처럼 새 변수에 담아야 합니다.

💡 한 줄 정리

문자열 메서드는 점(.)으로 부르는 기능이에요. upper/lower(대소문자), strip(공백 제거), replace(바꾸기). 단, 원본은 그대로 두고 새 글자를 돌려줘요(불변).

Step 8: "해시태그 분리하고 다시 합치기 — split·join"

지난 시간 마무리에서 "글자를 자르고(split) 다듬고 합쳐서 캡션과 해시태그를 가지고 놀자" 고 예고했죠. 이제 그 split 과 join 을 만나봅니다. 오늘의 마지막 도구예요.

split — 글자를 여러 조각으로 자르기

# src/a_intro/a2_hashtags.py
caption = "오늘 카페 다녀왔어요 #일상 #카페 #감성"

parts = caption.split()
print(f"split 결과: {parts}")
print(f"조각 개수: {len(parts)}")
print(f"첫 조각 [0]: {parts[0]}")          # 오늘  (Step 6 의 [0] 그대로!)

split 결과: ['오늘', '카페', '다녀왔어요', '#일상', '#카페', '#감성']
조각 개수: 6
첫 조각 [0]: 오늘

split() 은 공백을 기준으로 글자를 토막내요. 결과가 대괄호 [] 와 따옴표로 묶여 나오는데, 이건 여러 조각을 담은 '리스트' 라는 그릇이에요. 리스트는 다음 카테고리에서 제대로 배우니, 지금은 "조각들이 순서대로 담긴다" 정도면 충분해요. 조각 하나를 꺼낼 땐 Step 6에서 배운 [0] 을 그대로 쓰면 되고요.

구분자를 직접 정하기

profile_line = "민지,서울,사진작가"
fields = profile_line.split(",")
print(f"콤마로 자른 결과: {fields}")

콤마로 자른 결과: ['민지', '서울', '사진작가']

split(",") 처럼 기준이 될 글자를 넣어주면 공백 대신 그 글자로 잘라요.

join — 조각을 다시 하나로 합치기

rejoined = " / ".join(parts)
print(f"join 으로 합치기: {rejoined}")

join 으로 합치기: 오늘 / 카페 / 다녀왔어요 / #일상 / #카페 / #감성

join 은 split 의 반대예요. "사이에 끼울 글자".join(조각들) 형태로, 조각 사이에 글자를 끼워 하나로 잇습니다. " / " 로 합치니 슬래시로 이어졌죠.

split + join 콤보 — 들쭉날쭉한 띄어쓰기 정리

messy = "  #Seoul   #Cafe   #Daily  "
clean = " ".join(messy.split())
print(f"정리 전: '{messy}'")
print(f"정리 후: '{clean}'")               # #Seoul #Cafe #Daily

정리 전: '  #Seoul   #Cafe   #Daily  '
정리 후: '#Seoul #Cafe #Daily'

split() 은 공백이 여러 칸이어도 알아서 깔끔하게 토막내요. 거기에 join 으로 한 칸씩 다시 붙이면, 지저분한 띄어쓰기가 한 번에 정리됩니다. 실무에서도 자주 쓰는 단골 기술이에요.

💡 한 줄 정리

split 은 글자를 조각으로 자르고(기본은 공백, 구분자 지정 가능), join 은 조각을 사이 글자로 이어 합쳐요. 둘을 합치면 들쭉날쭉한 글자도 깔끔하게 정리돼요.

마무리

오늘 숫자 계산과 글자 다루기, 정말 많은 도구를 만났어요. 고생 많으셨습니다.

오늘 배운 핵심 세 가지

💡 하나: 산술(+ - * / // % **)·비교(== != > < >= <=)·논리(and or not) 연산자로 계산하고 참·거짓을 판단했어요.

💡 둘: input() 이 준 글자는 int()/float() 로 바꿔야 계산할 수 있고, f-string으로 값을 끼우고 형식까지 지정했어요.

💡 셋: 인덱싱·슬라이싱으로 글자를 잘라 꺼내고, 메서드(upper/strip/replace)와 split·join 으로 글자를 다듬고 합쳤어요.

다음 시간 예고

다음 시간에는 "흐름 제어" 를 배웁니다. 오늘 비교·논리 연산자로 만든 True/False 기억하죠? 다음 시간엔 이 참·거짓을 가지고 '갈림길' 을 만들어요. "좋아요가 100 이상이면(if) 인기글, 아니면(else) 일반글" 처럼, 조건에 따라 프로그램이 다른 길로 가게 하는 거예요. 같은 일을 여러 번 되풀이하는 for·while 도 만나고요. 드디어 프로그램이 스스로 판단하고 반복하기 시작합니다. 기대해 주세요!

과제

오늘 배운 연산자·형 변환·f-string·문자열 도구를 직접 손으로 익혀봅시다. 눈으로 본 것과 직접 짜보는 것은 완전히 다르답니다.

[기초] 좋아요 통계 계산기

3일치 좋아요 수를 변수에 담고, 산술 연산자로 간단한 통계를 내보세요.

• 월·화·수 좋아요 수를 각각 변수에 담습니다
• 합계(+), 하루 평균(몫 //), 평균 내고 남는 수(%)를 계산합니다
• f-string으로 "3일 합계: N" 처럼 라벨을 붙여 출력합니다

[응용] 프로필 카드 만들기

input() 으로 정보를 받아 형식을 갖춘 카드를 출력하는 프로그램을 만들어 보세요.

• 사용자 이름, 총 좋아요 수, 평점을 input() 으로 받습니다 (좋아요는 정수, 평점은 소수)
• 받은 값을 알맞은 종류로 변환합니다 (int / float)
• 멀티라인 f-string으로 카드를 출력합니다. 좋아요엔 천단위 콤마(:,), 평점은 소수 둘째 자리(:.2f)

실행 예시:

사용자 이름: 민지
총 좋아요 수: 12345
평점: 4.789
[프로필 카드]
이름   : @민지
좋아요 : 12,345
평점   : 4.79

[심화] 해시태그 정리기

지저분하게 입력된 캡션을 깔끔하게 다듬는 프로그램을 만들어 보세요.

• 앞뒤 공백과 느낌표(!)가 섞인 캡션 문자열을 하나 준비합니다
• strip() 으로 앞뒤 공백을 없애고, replace() 로 느낌표를 지웁니다
• split() 과 join() 으로 여러 칸 띄어쓰기를 한 칸으로 정리합니다
• lower() 로 영문을 소문자로 통일해 출력합니다

생각해볼 주제

정답이 하나로 정해진 질문이 아니에요. 혼자 곰곰이 생각해 보거나, 함께 공부하는 동료와 이야기 나눠 보면 좋습니다.

1. 나누기가 / 와 // 두 개로 나뉜 이유는?

다른 계산기에선 나누기 버튼이 하나뿐인데, 파이썬은 /(소수)와 //(몫)를 따로 뒀어요. 왜 굳이 둘로 나눴을까요? 프로그램에서 "딱 떨어지는 정수" 가 필요한 상황은 어떤 게 있을까요?

2. 문자열이 '불변'인 게 왜 좋을까?

문자열 메서드는 원본을 바꾸지 않고 새 글자를 돌려줬어요. "그냥 원본을 바로 바꾸면 편할 텐데" 싶을 수도 있는데, 원본이 안 바뀌면 어떤 점이 안전할까요? 반대로 불편한 점은 없을까요?

3. input() 이 모든 값을 글자로 주는 건 친절일까 불편함일까?

input() 은 숫자를 입력해도 글자로 줘서, 계산하려면 매번 int() 로 바꿔야 했어요. 만약 input() 이 "숫자처럼 생겼으면 알아서 숫자로" 줬다면 더 편했을까요? 아니면 지금처럼 "항상 글자, 필요하면 직접 변환" 이 더 안전할까요? 왜 그렇게 생각하나요?