doomrender 님의 블로그

26-9-28 회고

doomrender — Mon, 28 Sep 2026 11:27:57 +0900

cross origin을 배웠다.

그런데 오리진이 존재하는데 굳이 왜 크로스 오리진이라는 개념을 만들었는지 의아했다.

그런데 찾아보니 오리진은 명사처럼 쓰이는데, 크로스오리진은 2개의 오리진의 관계를 칭하는 것이었다. 즉 오리진이 서로 다르면 크로스 오리진 관계다.

찾아보지 않았으면 모르고 헷갈릴뻔했다.

aio3기 오프라인강의 회고 5

doomrender — Mon, 21 Sep 2026 18:11:46 +0900

오늘 fastapi라는 프레임워크를 이용해서 서버를 구획하고 내가 요청을 보내고 응답을 받는 시간을 가졌다.

github 수업과 비슷하게 개념과 흐름을 주로 배우는 느낌이었다.

왜냐면 이걸 외워서 내가 수작업으로 작성할 수 없다는 확신을 받았기 때문이다.

그래서 목표는 'llm에게 최소한 물어보면서 내가 작성할 수 있을 정도는 되자'였다. 내가 직접 다 머리속에 외우고 수작업으로 하나하나 작성해서 구동시킬 수 있을 정도의 이해가 필요하다고 하면 매우 어려운 강의다.

그래서 특정 기능 소개와, 그 기능들을 어떤 연관을 갖는지, 그리고 이를 구동시키기 위해서는 어떤 형식을 띄는지만 놓고 보면 별로 내용이 없는거 같기도 하다.

aio3기 오프라인강의 회고 4

doomrender — Mon, 21 Sep 2026 18:11:01 +0900

35. try, except, else, finally 의 뜻

try:
        minutes = int(raw_value)
except ValueError as error:
        print(f"{raw_value!r} 변환 실패: {error}")
        return None
else:
        print(f"{raw_value!r} 변환 성공")
        return minutes
finally:
        print("입력 처리를 종료한다.")

try 문법의 기본 구조는 이렇게 이해하면 됩니다.

try:
    # 에러가 날 수도 있는 코드
except 어떤에러:
    # 그 에러가 발생했을 때 실행
else:
    # 에러가 발생하지 않았을 때 실행
finally:
    # 성공하든 실패하든 마지막에 실행

36.즉, try문법은 try라는 상황에서, 에러시 except를 실행, 정상일시 else를 실행, 마무리는 레어나 정상 관계없이 finally로.

37.except 는 키워드로 exception(예외)라는 단어로 만들어졌다.
Try 문법에서 x라는 예외사항에서라는 뜻을 가진다(=except x)
그래서 'except 예외사항:' 꼴을 가진다

except ValueError:는
try 안에서 발생한 예외 중에서 ValueError인 경우를 잡아서 처리하겠다는 뜻

처럼 except 바로 뒤에 :가 안 붙고, 뭔가가 더 오는가?
그 이유는 except가 “어떤 예외를 처리할 것인지”를 지정할 수 있는 문법이기 때문입니다.
기본 형태는 이렇습니다;
---------
try:
    실행할 코드

except 예외종류:
    예외가 발생했을 때 실행할 코드
---------

38.raise가 실행되면 그 순간 함수가 즉시 중단

예.
def get_task(task_id: int) -> str:
    if task_id not in TASKS:
        raise TaskNotFoundError(f"작업 {task_id}번이 없다")
    return TASKS[task_id]

여기서 raise이 발생하면 밑 줄의 return까지 안가고 종료됨

39.언패킹
pair = "파이썬 입문", True
#여기서 패킹이 된다
pair = ("파이썬 입문", True)

title, finished = pair
#여기서 언패킹이 된다
title = "파이썬 입문"
finished = True

print("언패킹:", title, finished)
#print("언패킹:", "파이썬 입문", True) 와 같으니
언패킹: 파이썬 입문 True

aio3기 오프라인강의 회고 3

doomrender — Mon, 21 Sep 2026 18:07:57 +0900

29.
task1 = [1, 4]
task2 = [1, 4]
task3 = task1
일때,

print(task1 == task2)  # True
print(task1 is task2)  # False
print(task3 == task1)  # True
print(task3 is task1)  # True

왜냐면 task1 과 task3는 같은 하나의 객체를 가르키고 있기 때문.
task1 ───→ [1, 4]
task3 ───↗
task2 ───→ [1, 4]

==는 값이 같은가를 물어보는 것이고
is는 같은 객체인가를 물어보는 것이다.

30.
질문:
    def position(self) -> tuple[int, int]:
        return (0, 0)

여기서 왜 tuple(int,int)가 아니라 tuple[int,int]인지

답:
()는 함수 호출 관련임.
그래서 tuple(int,int)는 인자에 int, int를 넣어서 tuple 라는 함수를 호출하겠다는 의미여서 안됨

왜 하필 []냐고 하면, 이건 Python 문법 설계에서 **"어떤 객체/타입에 구체적인 매개 정보를 붙인다"**는 표현으로 []를 사용하기로 정했기 때문입니다.

31. 컴프리핸션 문법으로 list, set, dict, tupple, generator 형태로 만들고 싶을때 표현법:

[number * number for number in numbers]           # list
tuple(number * number for number in numbers)     #tuple
{number for number in numbers}                   # set
{number: number * number for number in numbers} # dict
(number * number for number in numbers)          # generator

32. 반복문 for는 ~에 대해, ~마다 의 뜻이어서
for x in y는 y에 있는 x마다(=에 대해) 반복하라 라는 뜻임.

33.
Python에서는

if 조건:
    여기가 if 블록
for x in something:
    여기가 for 블록
def 함수():
    여기가 함수 블록
try:
    여기가 try 블록

처럼 : 다음에 들여쓰기된 코드 묶음을 블록이라고 합니다.

34.try 안에서 return을 만나도 finally는 실행됩니다.
단, finally 안에도 return을 쓰면 원래 return 값을 덮어씀

def test():
    try:
        return 10
    finally:
        return 20

이 경우 결과는 20입니다.
그래서 보통 finally 안에는 return을 넣지 않고, 파일 닫기나 정리 작업 같은 것을 넣습니다.

[SK네트웍스 Family 엔코아AI캠퍼스] AI 오케스트레이션 캠프 3기_9월 1주차 회고

doomrender — Fri, 18 Sep 2026 18:15:01 +0900

- `Keep` : 쉬는시간 시작과 끝이 늘어지지 않고 딱 제때 이루어지는 점. 화장실 손티슈 지급. 화장실 손 소독제 유치. 화장실 방향제 유치.
- `Problem` : 딱히 없지만 굳이 고르자면 환기시스템의 부재
- `Try` : 점심 시간에 환기하기.
- `Plus` : 좋았던 점: 노트북 대여해준다. 이외 환경들이 좋다. 청결하다.
- `Minus` : 아쉬웠던 점: 딱히 없긴하다.
- `Impressive` : 인상적이었던 점. 환경이 좋고 여러 이벤트들이 많다. 도전 과제등.
- `DROP` : 딱히..
- `ADD` : 딱히..
- `KEEP` : Ai 프롬프트를 이용해서 복습하는 일.
- `IMPROVE` : 수업 진행중 이해가 안되는 것을 미리 메모장에 옮겨두는 작업을 하는데, 그 과정에서 수업 흐름을 놓친다. 그래서 수업 진행 과정에 줄을 치는 걸로 대체해야겠다.
- **`FACTS`(사실, 객관)** : 안될거 같아도 그냥 시작하면 된다. 체력 관리를 잘하자.
- **`FEELINGS`(느낌, 주관)** : 아침에 덥다.
- **`FINDINGS`(배운 것)** : 자신의 언어로 표현하고 실행하는 것이 체화에 매우 직결적이다. 자신만의 표현을 의도적으로 하자.
- **`FUTURE`(미래)** : 깃허브를 이용하여 프로젝트를 등록하고, 다운하는 것을 통해 더 많은 서비스와 정보에 접근할 수 있다.

가장 저항 받고, 나의 투지를 불태우기도 가라앉게 한 것도 바로 문법이다.
파이선에서 문법 중 키워드가 가지각색의 문법을 지닌다.

하다가 느낀점은, 이거 다 외울 수 없고 다 외운다 해도 헷갈린다.
그래서 '적당히만 알자'를 깨닫게 해준다.
그런데 이게 왜 어려웠냐면, 나는 사전식 사람으로 특정 개념이 확실히 정의되어야지 다음 진도로 진행되는 사람인데, 새로운 키워드들의 문법이 발생하면서 정의가 안된 상태로 수업 진도가 나갔기 때문이다.
그리고 그 문법도, 규칙성이 있는것도 있고, 정말 '이럴거면 규칙을 왜 만들지' 할 정도로 규칙이 그냥 사례별로 있는 경우도 있었다.
그냥, 내가 ai를 이용해 사용할 때 참고할 정도로만 이해하자를 확실히 마인드셋을 하였다.
이 말은, 영화를 찍을때 활영기법을 알아야지 내가 영화를 찍을때 그 구도를 설계할 수 있는것처럼,
내가 Ai를 사용할때, 파이선의 기본 기능들을 알아야지 그래도 좀 더 ai를 잘 사용할 수 있지 않을까를 말하는 거다.

결론적으로, 욕심을 버리고 , 욕심을 내리고, 그 프레임만 보는 마인드셋을 가져야겠다는게 교훈이다.

aio3기 오프라인강의 회고 2

doomrender — Thu, 17 Sep 2026 18:07:21 +0900

20.함수에서 화면 출력값과 반환값은 독립적인 존재이다. 같은게 아니다.
예)
print("안녕하세요")는 "안녕하세요"를 반환하는 게 아닙니다.
그냥 화면에 보여주는 겁니다.
반환값은 None이다.

예)
def greet():
    print("안녕하세요")
result = greet()
print(result)
를 실행하면 결과값은;

안녕하세요
None

이다.
파이선 자체는 우항을 먼저 계산(=실행)하고 좌항으로 넘어가기 때문에
20-1.greet()이라는 함수를 실행함.
20-2.결과로 안녕하세요 가 '화면에'출력됨
20-3. 하지만 반환값은 None임. 즉 우항은 None이 됨
20-4 이제 result = None 이니 "None"을 result에 대입함
20-5. print(result)는 print("None") 이 됨.
20-6. 그에 따라 화면에 None이 출력됨.

21. 함수에 반환값의 표현이 없으면(= result 언급이 없으면) result None이 생략된 것과 같다.
예.
def greet():
    print("안녕하세요")
는

def greet():
    print("안녕하세요")
    return None
와 같다.

22. 즉, 반환값은 default이고, print는 그에 딸린 곁다리다.
다시말해, 함수는 반환값을 무조건 도출하고,(그렇다고 자동으로 화면에 출력되지는 않음.)
그 반환값이 return으로 명시가 안되어있으면 기본값처럼 None이 반환값으로 출력된다.

예1.
def b():
    return "안녕하세요"
에서 b()을 실행하면 아무것도 안뜨고
print(b())을 실행하면 "안녕하세요"가 뜬다

예2:
def greet():
    print("안녕하세요")
print(greet())

실행 순서는 이렇습니다.

22-1.greet() 실행
22-2.함수 안의 print("안녕하세요") 실행
22-3.화면에 안녕하세요 출력
22-4.greet()는 return이 없으므로 None 반환
22-5.바깥의 print(...)가 그 None을 출력

그래서 최종 출력은:
안녕하세요
None

23. 틀린 문제:
def test():
    return "A"
    print("B")
이면
print(test())로 화면에 출력되는 값은?

return을 만나면 함수가 종료되어서 A만 출력된다.

(정리 필요)
24.
self는 지금 사용하는 객체다
first_book.summary()를 호출하면 self는 first_book이다. second_book.summary()를 호출하면 self는 second_book이다. 메서드를 정의할 때는 첫 매개변수에 self를 적지만 호출할 때는 Python이 현재 객체를 전달한다.
self.title은 현재 책 객체의 제목이다.
first_book.title과 second_book.title은 서로 다른 객체에 저장된 값이다.
summary()는 값을 출력하지 않고 반환하므로 다른 코드에서도 결과를 사용할 수 있다.

관련 데이터와 그 데이터를 다루는 동작을 객체 안에 모으는 것을 캡슐화라고 한다. 이 예제의 title은 일반 속성이므로 first_book.title = "수정"처럼 객체 밖에서 직접 바꿀 수 있다. 바뀐 제목은 첫 번째 책의 summary()에만 반영된다.

25.
class Counter:
    created_count = 0

#클래스 속성임. 모든 counter 클래스는 이 것을 가진다.

    def __init__(self, start: int = 0) -> None:
        self.value = start
#이거는 인스턴스 속성임. 인스턴스에 뭔가를 하겠다.
인스턴스 속성은 init 함수 내에서 정의됨
        Counter.created_count += 1

    def increment(self) -> None:
        self.value += 1

first = Counter()
second = Counter(start=10)

first.increment()
first.increment()
second.increment()

26.
def increment(self):
self.value += 1
self.value += 1는 value라는 속성 값에 +1을 한다는 뜻

27.
class Task:
    def __init__(self, title: str) -> None:
        self.title = title
        self.done = False

'self.done = False'는 초기값을 False로 한다는 뜻.
'self.title = title' 에서 좌측title은 .title로 속성 문법이고, 우측title은 title 자체로 변수의 문법이다.
그래서 이름이 title로 같아도 다른 객체로 구분한다.

28.
조건 표현식 또는 삼항 연산자(ternary expression):
일반적인 if문과는 조금 다른 문법

<보통의 if문>
if self.done:
    status = "완료"
else:
    status = "진행 중"

<(이걸 한 줄로 줄여 쓴 것이 바로)조건 표현식>
atus = "완료" if self.done else "진행 중"

aio 3기 오프라인강의 회고1

doomrender — Wed, 16 Sep 2026 17:43:56 +0900

대부분 프리코스로 사전 온라인 강의로 배운 내용들을 오프라인 수업으로 다시 보게 되었다.

휘발되었던 정보도 있었다.

아는 내용 부분에서는 수업 분위기, 새로운 환경에 적응하는 시간을 가졌다.

1일차에서는 소크라테스식 복기 방법이 매우 인상적이었다.

llm에게 복기 프롬프트를 주어서 당일 학습한 내용을 효과적으로 복기하는 방법이었다.

이를 통해 확실히 각인한 내용은 다음과 같다;

[]은 자료형 안의 특정 항목에 접근할 때 쓴다는 것이다.

()은 함수를 실행할 때 쓴다는 것은 이미 알고 있었는데 []로 확장할 생각을 못했다.

그래서 dict 유형에서 키워드로 그와 관련된 값을 출력하기 위해선 print(parameter("키워드"))는 안되고 print(parameter["키워드"])가 된다는 것이다.

2. len 함수는 항목 개수를 구하는 함수이다

그러므로 항목이 있는 자료형이면 다 사용할 수 있다는 것이다.

list와 tuple에 사용 안될 거 같은데 된다는 것이다. 항목 개수가 있으니까.

#또한 수업 중 궁금해서 따로 찾아본 내용에 관한 것이다

1.프롬프트 작성에 관해서 역할 설정이 중요하다는 내용이 있었는데 왜인지 이해가 안갔다.

그러나 찾아보니 역할에 특정 변수 통제가 함축되어있기 때문이었다.

그러나 변수 통제는 역할에 의한 것보다 직접 적는 것이 더 효과적이라고 한다.

2일차에는 내가 복습하고 싶은 내용을 메모장에 기록하기로 했다.

1.원소가 하나인 튜플은 ("검색",)처럼 값 뒤에 쉼표를 붙인다. ("검색")은 괄호로 감싼 문자열일 뿐 튜플이 아니다.
example = ("검색") 이면
print(type(example).__name__) 해서 타입 보면 str이고
example = ("검색",)로 대입해서 타입 보면 tuple이다.

2.# dict는 키와 값을 함께 저장한다.
run = {
    "agent": "검색 에이전트",
    "status": "success",
    "seconds": 1.4,
}

# 새 키에 값을 대입하면 항목이 추가된다.
run["reviewed"] = True
이러면 키값 reviewed 고, 값이 True 인 원소를 추가한거

3.# 같은 dict 키에 새 값을 대입하면 기존 값이 덮어써진다.
run = {"agent": "검색", "status": "queued"}
run["status"] = "retrying"
print("1) 갱신한 상태:", run["status"])

4.# 바깥쪽 키부터 안쪽 키 순서로 접근한다.
print("1) 실행한 에이전트:", run["agent"])
print("2) 실행 상태:", run["result"]["status"])

# sources는 list이므로 마지막에는 숫자 인덱스를 사용한다.
print("3) 첫 번째 출처:", run["result"]["sources"][0])

5.is_member = input("회원인가요? (y/n): ") == "y"
order_amount = int(input("주문 금액을 입력하세요: "))

can_get_free_shipping = is_member and order_amount >= 30000
can_use_coupon = is_member or order_amount >= 50000
needs_shipping_fee = not can_get_free_shipping

print("1) 무료 배송 가능 여부:", can_get_free_shipping)
print("2) 쿠폰 사용 가능 여부:", can_use_coupon)
print("3) 배송비 필요 여부:", needs_shipping_fee)

--결과값--
회원인가요? (y/n): y
주문 금액을 입력하세요: 40000
1) 무료 배송 가능 여부: True
2) 쿠폰 사용 가능 여부: True
3) 배송비 필요 여부: False
(01_python_basic) PS C:\workspace\01_python_basic>

6. 나는 and, or 등의 논리 연산자 앞 뒤에 조건식이 무조건 와야한다고 생각했는데, 상수든 문자열이든 어떤 값이 와도 됐다.

주어진 조건:
is_member = input("도서관 회원인가요? (y/n): ") == "y"
overdue_count = int(input("연체한 책 수를 입력하세요: "))에서

내가 정리한 식:
# TODO: 연체한 책이 한 권 이상인지 has_overdue에 저장한다.
has_overdue=overdue_count >= 1
# TODO: 회원이고 연체한 책이 없을 때만 can_borrow를 True로 만든다.
can_borrow = is_member=="y" and has_overdue<1

다음과 같이 정리할 수 있었다
# TODO: 연체한 책이 한 권 이상인지 has_overdue에 저장한다.
has_overdue= overdue_count >= 1
# TODO: 회원이고 연체한 책이 없을 때만 can_borrow를 True로 만든다.
can_borrow = is_member and not has_overdue

즉, is_member 는 이미 True나 False 값이 나온 상수이고,
can_borrow는 그냥 1인지 0인지만 결정되면 되는거라 굳이 뒤에 조건식이 나올필요 없음.
0 and 1 은 0값을 갖고
1 and 1 은 1값을 갖지
and 라는게 있어서 굳이 and 앞뒤로 조건식이 올 필요가 없다.

7. if가 True일때 수행할 식은 if 조건식 밑에 들여쓰기로 적어야한다.
즉 들여쓰기된 모든 부분이 if블록이 된다.

또한 if문과 for문은 :을 써야한다
예)
for task in tasks:
    print(task)

8.내 의문점:is_member = input("도서관 회원인가요? (y/n): ") == "y"
여기서 우항 input("도서관 회원인가요? (y/n): ") == "y"의 의미를 알려주세요.
예를 들면 제 생각에는 우항은 [input("도서관 회원인가요? (y/n): ") 와 "y"가 같다]만을 뜻하는거 같은데 왜 이게 0과 1 둘 중 하나인 bool 값을 갖는지 이해가 안갑니다

답변:
여기서 중요한 점: ==는 "같은지 판단해서 그 판단 결과를 돌려주는" 연산자입니다. 사람이 "이 둘이 같나요?"라고 물으면 "네" 또는 "아니오"로 답하듯이, Python도 ==를 계산하면 반드시 True 또는 False 중 하나를 값으로 반환합니다.
+가 두 숫자를 받아서 합을 만들어내듯이, ==는 두 값을 받아서 bool을 만들어냅니다.

9. enumerate 함수의 이해와 언패킹:

for index, task in enumerate(tasks, start=1):
    print(f"{index}) 할 일: {task}")
이 값의 결과물이 다음과 같나여?
1) 할 일: 책 읽기
2) 할 일: 과제 하기
3) 할 일: 산책하기

답변:
enumerate(tasks, start=1)는 tasks 리스트를 돌면서, 각 항목마다 (순서번호, 항목값) 쌍을 하나씩 만들어줍니다.
예를 들어 tasks = ["책 읽기", "과제 하기", "산책하기"]라면:
enumerate(tasks, start=1)은 내부적으로 이런 쌍들을 순서대로 생성합니다:
(1, "책 읽기")
(2, "과제 하기")
(3, "산책하기")

그리고 for index, task in ...는 이 쌍 (1, "책 읽기")를 받아서 첫 번째 값은 index에, 두 번째 값은 task에 자동으로 나눠 담습니다 (이걸 "언패킹"이라고 부릅니다).
index, task = (1, "책 읽기")

10. 다음과 같은 형식으로 특정 수에 대한 9단을 만들어야했다;
dan = int(input("몇 단을 출력할까요? "))
# TODO: range()로 1부터 9까지 반복한다.
# TODO: 각 단계에서 "3 x 1 = 3" 형식으로 곱셈 결과를 출력한다.

이걸 못하고 있었는데 이걸 해내는 식은 다음과 같았다;

11. elif 식은 첫 조건이 참이면 뒤 조건은 보지 않고 건너뛰지만, if 식이 여러개 있으면, 모든 if식을 다 둘러본다.
단, 오류가 안나려면 여러개의 if식들이 상호배타적이어야 한다.(=겹치는 부분이 없어야 한다)

12. 반복문에서 분기에 관련된 명령어: 분기문
break: 반복문을 종료한다
continue: 반복문의 시작 지점으로 다시 돌아간다.

13. for문의 변수와 range 관계에 대한 이해:
for문의 변수에는 range의 값이 대입된다

예)
for num in range(0, 3):
    print(num)
이면
range가 내놓는 값이 num이라는 변수에 대입된다.

그리고 for문의 루프는 다음과 같이 진행됨;
1.range(0, 3)이 "0부터 시작해서 3 직전까지" 값을 하나씩 준다.
2.첫 번째로 0을 내놓으면, num이라는 변수에 그 값(0)이 **할당(대입)**된다.
3.루프 몸통(print(num))이 실행된다 → 0이 출력됨.
4.루프가 한 바퀴 끝났으니 다시 처음으로 가서, range가 다음 값인 1을 내놓는다.
5. ...

즉, range 값이 하나 나오고 그걸로 한 블록에 대한 실행이 다 되었다면,
다음 range 값으로 한 블록에 대한 실행이 다시 진행됨

14.for문에 따라 while문이나 match문을 계속 실행하려면, while문이나 match문을 for문의 하위에 둬야한다(=for문 아래에 들여쓰기 해서 작성한다)

statuses = ["success", "timeout", "pending", "unknown", "failed"]

for index, status in enumerate(statuses, start=1):
    message = "미분류"
    match status:
        case "success":
            message = "완료"
        case "failed"|"timeout":
            message = "확인필요"
        case _:
            message = "알 수 없는 상태"
    print(f"{index}) {status}: {message}")

즉 for가 한 번 반복될 때마다,
14-1.message = "미분류"
14-2.현재 status를 가지고 match 검사
14-3.알맞은 case에 따라 message 변경
14-4.print() 실행
이 과정 전체가 반복됩니다.

15.함수 정의
def 함수명(매개변수):
    함수 호출 시 수행할 동작
    ...
    ...

함수헤더의 ()안에 들어가는 것은 매개변수라 하고, 호출에서 ()에 들어가는
것은 인자라 한다.(def가 포함된 첫 줄을 함수 헤더라 함)
함수명() 은 호출한다는 의미함

함수 정의문에서 매개변수가 없으면 함수 호출할때 함수() 만 해도 함수가 실행됨
그러나 매개변수가 있으면 인자가 필요함

17. 함수 정의문에서 매개변수 뒤에 '='을  붙여 기본값을 설정가능.

def make_order_line(item: str, quantity: int = 1) -> str:
    line = f"{item} {quantity}개"
    return line

정의문 헤더에서 quantity = 1 을 하여 quantity 매개변수의 기본값을 1로 설정한거임.

print("기본 수량:", make_order_line("연필"))
하면 quantity 매개변수 인자로 기본값인 1이 들어가는 거임.
즉, make_order_line("연필", 1) 을 호출한거랑 같은거임

print(" 수량 지정:", make_order_line("공책", quantity=3))

18. return은 함수를 호출한 위치로 보내고, print()는 화면에 보낸다.

19.
'.py' 파일은
파이썬 코드를 작성하는 파일이면서, 직접 실행할 수도 있고, 다른 파일에서 import되어 모듈로 사용될 수도 있다

그래서 보통 모듈 파일에서는 다음 코드를 많이 씁니다;
if __name__ == "__main__":
    print("이 파일을 직접 실행했을 때만 실행됩니다.")
이로써 해당 파일에서 실행시 출력이 되지만, 다른 파일에서 실행시 출력이 안된다.
해당 파일에서는 name이 main이지만, 다른 파일에서는 name이 main이 아니기 때문이다.

AIO 3기 프리코스 학습 5일차 회고

doomrender — Sat, 12 Sep 2026 17:18:57 +0900

파이선 Ch6 ch7을 수강하여 마치고

git 강의 ch6까지 수강하였다.

#클래스상속

종의 map을 그리는 것처럼함.

# class class변수 (상위클래스변수) 를 하여 상위클래스의 성질을 그대로 가져올 수 있다

예:

여기서 class변수 Mage는 상위클래스변수인 Character의 성질을 그대로 갖는다.

#super()를 이용하여 상위클래스변수의 성질을 복사붙여넣기 할 수 있다.

그래서 Mage 클래스는 Character 클래스의 __init__(name, health)를 그대로 사용함.

엄밀히 말하면 복사 붙여넣기가 아니라, Character 의 __init__(name, health) 부분으로 이동하여 그 함수를 그대로 호출하는거임

#여기서 super()사용시 self는 적지 않는다

super().__init__(name, health) 처럼,

super().attack()처럼

()안에 self를 적지 않는다.

왜? 바로 super 자체가 상위클래스의 self에 대해서 지칭하는 함수이기 때문.

즉 super는 '상위클래스 걔(=self)의 속성 그대로 호출하겠다'라는 의미이기 때문에

()안에 Self를 넣으면 self를 중복하여 사용하는 것이기 때문에 에러가 남.

#list(str(range(2,11))) 하면 ['r','a','n','g','e','(','2',',',' ','1','1',')']의 결과가 나옴

#map은 mapping이라는 뜻을 가진 함수

즉, map(함수, iterable) 을 하면 각 iterable을 함수에 각각 넣게됨.

map은 지연 계산 형태이기 때문에 list 함수로 감싸줘야 결과값이 출력됨.

list(map(str, range(2,11)))=[2,3,4,5,6,7,8,9,10]

-------------------------------------------------

#modified 파일을 index(=staging area)에 올리는 방법 2가지

1.git add <파일명>

그 파일만 올린다

2. git add .

붉은색으로 감지된 모든 modified 파일들을 전부 올린다(git status 를 치면 Modified 파일들이 붉은색으로 감지됨)

# git commit -m "메시지"

메시지를 포함하여 커밋하는 명령어이다

#Vim 이용해서 커밋 메세지 적고 나서, 메시지를 적는 것을 저장하고 종료하는 방법

:wq

를 작성하면 된다

AIO 3기 프리코스 학습 4일차 회고

doomrender — Thu, 10 Sep 2026 23:36:55 +0900

ch5 6... 을 하였다.

강의를 수강하면서 복습을 위한 내용 정리를 한 내용이 있었으면 싶었다.

그래서 이번 회고에는 몰랐던 내용이나, 헷갈린 내용, 배워도 낯설은 개념을 정리할까 싶다.

#map: ()안의 함수에 각 요소들을 대입해주는 함수.

그래서 ()안에 함수와 요소 둘 다 있어야함.

대신, 값을 출력해주지는 않기에, list 함수를 이용해 리스트화 가능.

#요소들이 순서쌍이면, 호출할 함수의 범위가 구분시켜야함.

즉, 함수가 lambda로 변수(parameter)가 여러개 있고 요소를 바로 넣어 호출할 경우, Lambda라는 함수 전체를 괄호로 묶어야함.

예: lamda a,b : a*b(10,20) --> 틀린 수식: 파이선은 함수 (a*b)(10,20)이 아니라 a*(b(10,20))으로 처리함.

(lamda a,b: a*b)(10,20)--> 옳바른 수식

# iteralbe과 lambda 같이 쓰기

형태: lambda para1, para2, ... : 식 , iterable1, iterable2, ...

ex)

a=range(1,5)
b=range(10,14)
print(list(map(lambda x,y: x*y,a,b)))

#파이선 함수의 결과값은 숫자뿐만이 아니라 bool값일수도 있다.

lambda x: x%3==0 and x<10 도 함수이다.

x에 넣을 요소 값이 위 조건을 만족하면 True라는 값이 나오는 함수인것이다.

#iterable한것은 list화 할 수 있다.(List 함수를 적용시킬 수 있다)

print(map(x))는 리스트로 출력되지 않는다

이를 리스트로 출력하고 싶으면 리스트화해서 출력한다.

즉, print(list(map(x)))해서 리스트 출력

#내장함수 중 변환에 관한 함수

int() 정수로 변환

str() 문자열로 변환

float() 실수로 변환

tuple(), list(), bool(), set()

#함수를 정의해서 쓰려면 return을 반드시 이용. Return 뒤의 값이 표현식이나 다름없다

def f(x):
    2 * x
    return 3 * x
print(f(5))   # 15  (2*5=10은 계산됐지만 버려짐, 3*5=15만 반환됨)

즉,

f(5)를 호출 = 심부름꾼을 함수 안으로 보냄
함수 안에서 x * 2 계산 = 심부름꾼이 그 안에서 계산을 함
return = 심부름꾼이 계산 결과(5*3)를 들고 나옴
return이 없으면 = 심부름꾼이 계산은 했지만 빈손으로 나옴

#return 이후의 코드는 실행되지 않는다

def g(x):
return 3 * x
print("아아아") # 도달 불가능한 코드

그러므로 return할 표현식이 길면, ()등으로 감싸거나 변수로 정의해서 한줄로 표현하기

예)

def f(x):
    step1 = x * 2
    step2 = step1 + x * 3
    result = step2 - 5
    return result

#함수가 종료되면 필드는 사라지지만 필드값은 저장된다.(필드는 지역변수로 함수가 종료되면 사라진다.)

class Car:
def __init__ (self, brand, speed): #brand, speed라는 매개변수를 설정하는 일
self.brand = brand #brand라는 필드를 Car라는 클래스에 생성하는일.

self.speed = speed 그리고 객체에 그 특정 필드 저장 공간을 만드는 행위

my_car = Car("포르쉐", 100)
하지만 brand, speed 모두 함수 내 지역변수로, __init__라는 함수가 종료되면 데이터값이 사라짐.

하지만 my_car라는 인스턴스에 speed필드로 100이 저장됨.

그렇기에 print(my_car.speed) 로 인스턴스의 필드값을 출력 가능.

-만약 self.brand = brand처럼 필드 설정 코드식을 적지않는다면->인스턴스에 그 필드 데이터가 저장되지 않음

예:

class Car:
    def __init__(self, brand, speed):
        pass

Car("현대", 100)을 호출하면, 새 객체(빈 껍데기)가 하나 만들어짐
그 빈 객체가 self로 전달됨
"현대"는 brand라는 매개변수에, 100은 speed라는 매개변수에 일단 들어감
__init__ 함수 몸통 안에 self.brand = brand 같은 코드가 없으므로, brand와 speed라는 매개변수는 __init__ 함수가 끝나는 즉시 사라짐
결과: my_car라는 객체는 텅 빈 채로 남음 (아무 필드도 없음)

# 실행 중에 self.어떤이름 = 값이라는 코드가 실행되는 그 순간에 그 필드가 동적으로 생성됨.

예:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age #여기선 클래스에 필드 자체를 만드는 행위

my_dog = Dog("바둑이", 3)
my_dog.weight = 5 #여기선 my_dog라는 인스턴스에만 weight이라는 필드를 추가, 5라는 weight 필드값을 추가
your_dog = Dog("초코", 2)

print(my_dog.__dict__) # {'name': '바둑이', 'age': 3, 'weight': 5}
print(your_dog.__dict__) # {'name': '초코', 'age': 2}   ← weight 없음!

# f-string (formatted string literal)-형태가 부여된 문자열

즉, 값을 넣으면 형태가 정해지는 문자열.

문자열 앞에 f를 붙이면, 문자열 안의 {} 안에 변수나 표현식을 넣어서 그 값을 문자열 안에 바로 끼워 넣을 수 있게 해줍니다.

ex:

class Person:
    def __init__(self, name):
        self.name = name
        self.hello = f"안녕하세요, 저는 {self.name}입니다."

f가 없으면 {name}은 그냥 글자 그대로 {name}이라는 텍스트로 출력됩니다:

--------------------------------------

단어:

#syntax: 문법

syn 같이

tax 배열하다

같이 배열된것, 순서에 맞춰진것: 문

#iteralbe

iter 다시,또

다시 또 (꺼내쓸수있는)

#instance

in -안의, -위의

sta 서다

ce 명사형

(눈) 앞에 서있는것 -> 사례, 예시

->파이선의 뜻과 연결: 구체적 사례로 추상적인 개념인 class와 대비되는 개념

#field

영역--속성

파이선에서는 속성 뜻을 가짐.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
my_dog = Dog("바둑이", 3)

에서 Dog 라는 클래스는 name과 age라는 필드를 갖고,

my_dog라는 인스턴스의 name 필드값은 '바둑이'이다.

AIO 3기 프리코스 학습 3일차 회고

doomrender — Tue, 8 Sep 2026 23:23:05 +0900

ch4를 수강하였다. 이번에는 강의도 많고 길이도 길었다.

그러나 스트레스 받는 것은 따로 있었다.

4-5 세트 강의를 듣는데, 전에 못봤던 dict, 키, 값 등의 개념이 나온 것이다. 나는 처음에 강사님이 빠르게 언급만 하고 넘어간 부분인가 하고 클로드에 직접 물어보면서 학습을 이어갔다. 그런데 하다보니 이 개념이 방대한 개념이라는 것을 깨닫고 뭔가 잘못되었음을 깨달았다. 알고 보니 강의 순서상 4-6강의가 4-5보다 선행된 강의였던 것이다. dict, 키, 값 등이 4-6에 설명이 되어있었다.

이에 스트레스도 받고 굳이 안 받을 수 있는 스트레스였는데 하고 스트레스가 더 추가되었다. 그런데 다시 생각해보니 그만큼 내가 모르는 부분은 강의 등으로 알아가는게 쉽고 중요한 일이라는 것을 반증하는 거였다. 강의 잘 들어야겠다는 생각을 하였다.

이번 강의를 들으면서 저항을 받았던 것은 dict() 함수였다.

dict([[1, "value"], [2, "value2"]]) 처럼 한번 크게 []로 묶거나 ()로 묶어서 인자를 한개로 처리해야하고, print 결과값을 나오게 하면 그 결과가 {1: 'value', 2: 'value2'}로 나오는 것이었다. 클로드에 물어보니 함수이기 때문에 input은 한번에 하나만 들어가야 하니 리스트나 튜플 형태로 하나로 묶어야하고, dict이라는 함수의 정의 자체가 안의 원소들을 한번씩 체크한다는 것이다. 그리고 체크한 원소들이 2개의 쌍으로 묶여있을시 이 2개의 쌍을 각 '키:값'으로 본다는 것이다..

나는 뭔가 이유를 알아야지만 저항을 안 받는데, 왜 dict의 ()안에 하나로 묶는지 이유가 없어서 저항을 받았다. 그리고 갑자기 내가 모르는 결과값이 튀어나오는 도약에 저항을 받았다.