회고

• 함수를 만들다보니 뇌가 점점 정지된다. 입력/계산/출력에서도 하나씩 잘 쪼개서 함수를 코드를 작성해야 나중에 유지보수도 편하고 틀린 부분을 찾기도 쉽다고한다. 근데 만드는게 쉽나..? 의문이긴 하다. 생각이 많아서 gpt한테 고민상담을 했다. 아래는 그 내용이다.

✅ 1. 자신의 생각을 먼저 말로 풀어보기
예: "리스트에 있는 숫자 중에서 짝수만 골라서 제곱한 값을 새 리스트에 담고 싶어"

→ 이걸 말로 풀었으면, 코드로는 아래와 같이 접근할 수 있죠:

python
복사
편집
nums = [1, 2, 3, 4, 5]
result = []
for n in nums:
if n % 2 == 0:
result.append(n**2)
📌 생각 → 말 → 코드 순서를 습관화해 보세요.

✅ 2. 작게 나눠서 구현하기
한 번에 다 하려 하지 말고, 한 줄씩 생각해 보세요.

예:

사용자가 입력한 숫자 3개를 더하는 코드

① 사용자에게 숫자 입력 받기
② 숫자형으로 바꾸기
③ 더하기
④ 출력

→ 이렇게 나누면, 한 줄씩 차근히 작성할 수 있게 됩니다.

✅ 3. 비슷한 예제 많이 따라 치기
머리로 이해만 하지 말고 손으로 많이 쳐보는 게 핵심입니다.

단순 반복도 괜찮습니다. 10번 이상 치면 머리에 익습니다.

✅ 4. 에러 메시지를 두려워하지 말기
에러는 방향을 알려주는 힌트입니다.

한 줄씩 찍어가면서 "지금 여기까지는 됐는가?"를 확인하세요.

✅ 5. 질문하거나 설명해보기
다른 사람에게 내가 짜고 싶은 로직을 설명하거나,

ChatGPT 같은 도구에 "이걸 코드로 바꾸고 싶은데 어떻게 해야 해?"라고 자주 물어보세요.

📌 마인드셋 팁
"잘하려 하지 말고, 자주 하자"

지금 "생각은 되는데 코드로 못 옮기겠어"는, 실력 올라가는 전조입니다. 포기하지 마세요.

그렇다.. 그냥 꾸준히 하자. GPT야 응원해줘서 고맙다.

필기

함수

• 매개변수에 집중하여 함수를 만들자.

#가변매개변수 -> 함수는 매개변수 개수가 바뀌는 경우에
print(3,4,5,6,7)
print(1,2,3)

#가변매개변수 - 매개변수의 개수가 바뀐다.
#매개 변수 앞에 *을 붙인다.
#매개 변수에 기본값을 줄때는 변수 자체가 여러개 만들어진다.

def myadd(*args): #변수하나에 값을 여러개 전달한다.
    print(type(args))
    for a in args:
        print(a)

myadd(1,2)
myadd(1,2)

def myadd2(*data):
    s = 0
    for i in data:
        s += i
        return s

print(myadd2(1,3,5))
print(myadd2(1,3,5,7,9))
print(myadd2(1,3,5,7,10,12,13))

#일반인자와 tuple인자를 같이 써야 할때는 일반 인자가 먼저 와야 한다.
#나머지를 tuple로 받으니까

def myadd3(n,*data):
    print("n",n)
    for i in data:
        print(i)
        
myadd3(1,2,3,4,5)

#dict타입을 매개변수로 넘길 수도 있다. **
#매개변수 전달 방식이 달라진다.
def myfunc(d):
    print(d)
    
person = {"name":"홍길동", "age":12}
myfunc(person)

def myfunc2(**d):
    print(d)
    
myfunc2(name = "홍길동", age = 23)

def pickup_even(numList):
    even = []
    for n in numList:
        if n % 2 == 0:
            even.append(numList)
    return even
        
            
pickup_even([3, 4, 5, 6, 7, 8])
#일반인자랑 tuple인자랑 dict인자 셋 다 쓰고 싶으면 순서가 있다.
#순서 : 일반인자, tuple인자, dict인자
#일반인자, tuple타입, dict타입입
def profile(role, *skills, **details):
    print("Role",role)
    print("Skills",skills)
    print("details",details)
    
profile("programmer","python", "react", "deeplearnin",
        yearpay = 100000000, position = "개발자:")
        

zip과 filter

• filter 함수와 lambda를 적절히 활용하여 일회용 함수를 잘 만들어 쓰자.

#zip 함수 => 파이썬만 제공한다.
#["a","b","c","d","e"]
#[1,2,3,4,5]
#[("a",1), ("a",2).....]

a = ["a","b","c","d","e"]
b = [1,2,3,4,5]
for item in zip(a,b,a): #
    print(item)
    
"""
검색 알고리즘 
1.순차검색(선형검색): 데이터를 첫번째부터 순서대로 읽어서 해당데이터를 
찾을때까지 또는 끝까지 끝까지 가도 없으면 존재하지 않음, 자료구조에서 
실행 타임을 결정할때 빅O표기법  O(n)
... 1
... 2
... 3  O(3)
...
for i in range(0, n):    n+100 n이 무한정커지면 100은 의미가 없어 
    ..........           3n + 100    O(n)
                         n**2 + 3n + 30  O(n**2)
2.색인순차:정렬해서 
3.이분검색
 데이터가 반드시 정렬되어 있어야 한다. 
 내부 데이터가 자주 바뀌면 정렬하는 시간이 더 오래걸려서 항상 빠르다고 할 수는
 없다. 
 데이터를 절반을 쪼개서  왼쪽을 선택할지 오른쪽선택할지 
 데이터를 절반을 쪼개서  왼쪽을 선택할지 오른쪽선택할지 
 데이터를 절반을 쪼개서  왼쪽을 선택할지 오른쪽선택할지 
 데이터를 찾을때까지 두개로 나누는 작업을 한다. (이분검색) - O(logN)
3. 해쉬검색 - 이론상 검색 속도가 O(1) 이다. 속도때문에 
메모리를 미친듯이 차지한다. 구현도 어렵다 
trade off -거래할때 서로 합의점  파이썬의 dict - dictionary의 약자 
HashMap, HashTable, Map, Dictionary
"""
a = [1,2,3,4,5,6,7,8,9,10]
key=5 #찾아야할 값 
find=-1  #정수 변수못찾은 상태
for i in range(0, len(a)):
    if key==a[i]: #찾았다
        find=i 
        break
if find==-1:
    print("not found")
else:
    print(f"{find}번째에 있음")

def myfilter( aList, key):
    for i in range(0, len(a)):
        if key==a[i]: #찾았다
            return i 
    return -1  #for문을 다 끝나도 못찾았다 -1을  반환 

pos = myfilter(a, 4)
print(pos)

a=["red", "green", "blue", "cyan", "gray"]
pos = myfilter(a, "cyan")
print(pos)


a = [{"name":"A", "age":12},
     {"name":"B", "age":11},
     {"name":"C", "age":13},
     {"name":"D", "age":14},
     {"name":"E", "age":15} ]
pos = myfilter(a, {"name":"C", "age":34})
print(pos)

def myfilter2( funcKey, a):
    for i in range(0, len(a)):
        if funcKey(a[i]): #찾았다
            return i 
    return -1  #for문을 다 끝나도 못찾았다 -1을  반환 

pos = myfilter2( lambda x  : x["name"]=="C", a)
print(pos)

"""
정렬 => 데이터베이스를 사용하는 순간 데이터베이스 쿼리에서 
       검색과 정렬을 지원한다
       데이터베이스 못쓰는 상황에 파일을 써야 한다면 직접 구현해야 한다 
    순서대로 데이터를 늘어놓는것 
    오름차순 정렬 - 올라가면서 정렬 작은것부터 큰거순으로 
    내림차순 정렬 - 내려가면서 정렬 큰것부터 작은거순으로 
    select, bubble, quick(엄청빠름)

    select 정렬 오름차순의 경우에 
       5  1   2  4  3
      0번방 데이터가 제일 작다고 가정하자 
      0,1 0,2 0,3 0,4  조건에 위배되면 바꿔치기 

      1  5 2 4 3 
      1번방 , 2,3,4
      1 2 5 4 3  2,(3,4)

      1 2 3 5 4   3 4 비교

      1 2 3 4 5  마지막 
"""
def selectSort(aList):
    #0 ...1~n-1
    #1 ...2~n
    #2 ...1~n
    #n-1...n
    for i in range(0,len(aList)):
        for j in range(i+1, len(aList)):
            if aList[i] > aList[j]: #더 작은것이 앞에 있어야 한다.
                temp = aList[i]
                aList[j] = aList[i]
                aList[i] = temp

과제

성적프로그램(백현숙강사님)

• 이거 함수끼리 이어지는 부분이 이해가 안된다. 계속 반복해서 보자

import random #외부 모듈(파이썬의 경우에는 파일)을 
            #이 메모리로 가져와서 결합해라 

scoreList = [] #모든 함수가 공유해야할 메모리이다. 
#함수내에 선언된 변수는 함수에서만 존재한다. 
#함수외부에 선언된 변수는 함수들이 같이 사용할 수 있다. 전역변수 

#맨처음에 기본 데이터 넣어놓고  시작
def init():
    names=["홍길동", "홍경래", "장길산", "강감찬", "서희", "윤관",
           "감강찬", "김연아", "안세영", "조승연"]
    for i in range(0, len(names)):
        scoreList.append({"name":names[i],
        "kor":random.randint(40, 100), 
        "eng":random.randint(40, 100), 
        "mat":random.randint(40, 100)})
    for s in scoreList:
        s["total"] = getTotal(s)
        s["avg"] = getAvg(s)
        s["grade"] = getGrade(s)
            

def output(scoreList):
    for s in scoreList: #scoreList로 부터 하나씩 s라는 변수에 전달된다. 
        print(f"{s["name"]}", end="\t")
        print(f"{s["kor"]}", end="\t")
        print(f"{s["eng"]}", end="\t")
        print(f"{s["mat"]}", end="\t")
        print(f"{s["total"]}", end="\t")
        print(f"{s["avg"]:.2f}", end="\t")
        print(f"{s["grade"]}")  

def append():
    #각 과목별로 0~100점만 입력이 되도록, 숫자만 입력되게 하고 싶다. 
    s = {}
    s["name"]=input("이름 : ")
    #숫자가 들어와야하고, 0~100 사이어야 한다. 
    s["kor"] = getScore("국어",100)
    s["eng"] = getScore("영어") 
    s["mat"] = getScore("수학")    
    s["total"] = getTotal(s)
    s["avg"] = getAvg(s)
    s["grade"] = getGrade(s)
    scoreList.append(s)

def getTotal(s):
    return s["kor"]+s["eng"]+s["mat"]
    
def getAvg(s):
    return s["total"]/3

def getGrade(s):
    if s["avg"]>=90:
        return "수"
    elif s["avg"]>=80:
        return "우"
    elif s["avg"]>=70:
        return "미"
    elif s["avg"]>=60:
        return "양"
    return "가"
   
#숫자만 입력되게 : input으로 받는 모든 데이터는 String이다. 
#ord함수를 통해서 숫자인지 아닌지 판단가능하다. 
#ord('0'), ord('9')  문자열 받아서 한글자씩 '0' ~'9' 사이에 있으면 글자중에 하나라도 
#저 사이에 존재하지 않으면 숫자가 아님  
#함수는 기능 하나만, 하나의 기능에 집중하라
#함수도 입출력이다. 매개변수가 입력이고 반환값이 출력이다. 
#입력과 출력에 대한 정의가 먼저 진행되어야 한다. 
#에러처리는  먼저 처리하자 
"""
def myfunc():
    if error1:
        return -1
    if error2:
        return -2
    
    .........
        
"""
def isDigit(s):
    for i in range(0, len(s)):
        if ord(s[i])<ord('0') or ord(s[i])>ord('9'):
            return False 
        
    return True #끝까지 다 완수했어 다 숫자임   

def getNumber(subject):
    s = input(f"{subject} : ")
    while( isDigit(s)==False):
        print("숫자만 입력하세요")
        s = input(f"{subject} : ")
    return int(s) 

def getScore(subject="국어", limit=100):
    n = getNumber(subject)
    while( n<0 or n >limit):
        print(f"0~{limit} 사이의 값을 입력하세요")
        n = getNumber(subject)  #while문 마지막에 조건식을 벗어나는 수식이 와야 한다 
    return n 

def search():
    key = input("찾을 이름은 ? ")
    #filter 에서 두번째 파라미터 iterable(반복적인) 데이터 - list류
    #filter 안에서는 scoreList로부터 한개씩 객체를 갖고 온다. 
    # dict 타입 
    resultList = list(filter(lambda x:x["name"]==key, scoreList))
    #반환값이 list타입이고 list안에 dict 타입이 있음 
    #resultList, scoreList가 동일한 구조 - 함수 하나로 둘다 
    #전역변수로 scoreList가 이미 있다. 
    #함수안에서 매개변수로 전역변수와 이름이 똑같으면 외부  전역변수를 가려버린다
    #내눈앞에 보이는게 우선 
    output(resultList)


def modify():
    key = input("수정할 이름은 ? ")
    #filter 에서 두번째 파라미터 iterable(반복적인) 데이터 - list류
    #filter 안에서는 scoreList로부터 한개씩 객체를 갖고 온다. 
    # dict 타입 
    resultList = list(filter(lambda x:x["name"]==key, scoreList))
    if len(resultList)==0:
        print(f'{key} 를 찾을 수 없습니다')
        return  #끝내라, 함수를 끝내라 

    #두명이상 있을때의 처리를 해야 한다 
    st = resultList[0]  
    st["name"]=input("바꿀이름 : ")
    st["kor"]=getScore("국어")
    st["eng"]=getScore("영어")
    st["mat"]=getScore("수학")
    st["total"]=getTotal(st)
    st["avg"]=getAvg(st)
    st["grade"]=getGrade(st)
    print("수정되었습니다")
    
def menuDisplay():
    print("1.추가")
    print("2.출력")
    print("3.검색")
    print("4.수정")
    print("5.삭제")
    print("0.종료")

def start():
    init() #데이터 초기화 

    while True:
        menuDisplay()     
        sel = input("선택 : ")
        if sel=="1":
            append()  #insert
        elif sel=="2":
            output(scoreList)
        elif sel=="3":
            search()
        elif sel=="4":
            modify() #update
        elif sel=="0":
            print("프로그램을 종료합니다.")
            return
        else:
            print("잘못 선택하셨습니다")
           
start()

가위바위보(김성재)

• 진짜 만들기 힘들었다.. 함수의 전체적인 흐름을 제발 봐라 쫌!!

#가위바위보 게임 10판 했을 때 이긴횟수를 카운트하라

import random

# 사람이 내는 거
def userchoice():
    user = int(input("1. 가위, 2.바위, 3. 보 : "))
    if user in [1,2,3]:
        return user
    else:
        print("1~3중에서 선택하세요! ")
        return userchoice()

# 컴퓨터가 내는거
def computerchoice():
    return random.randrange(1,4)

# 누가 이겼는지
def whoiswinner(user,computer):
    if user == computer:
        return 1
    elif (user == 1 and computer == 3) or (user == 2 and computer == 1) or (user == 3 and computer == 2):
        return 2
    else: return 3
    
def start():
    print("가위, 바위, 보를 시작합니다.")

def main():
    start()
    drawcount = 0
    userwincount = 0
    computerwincount = 0
    for i in range(0,10):
        user = userchoice()
        computer = computerchoice()
        result = whoiswinner(user, computer)

        if result == 1:
            print("무승부")
            drawcount += 1
        elif result == 2:
            print("사람승")
            userwincount += 1
        else:
            print("컴퓨터승")
            computerwincount += 1
            
    print("\n게임종료")
    print(f"사람 승 : {userwincount}, 컴퓨터 승 : {computerwincount}, 무승부 {drawcount}")
    print(f"사람 승률 : {userwincount / 10:.2f}, 컴퓨터 승률 : {computerwincount / 10:.2f}")
    
main()

가위바위보(백현숙강사님)

#가위바위보 게임 :통계 
import random #import 외부 파일(모듈)을 이 파일로 갖고 들어와라 
#거듭해서 import를 하더라도 한번만 들어온다. 
#게임게시 : gameStart() 

# 출력값  : 컴퓨터이김 1, 사람이김 2 : 무승부 3 판단하는 함수 
# 입력값  : 매개변수는 컴퓨터의 생각, 사람의입력값 

def isWinner(computer, person):
    if computer == person: #사람하고 컴퓨터가 같다 
        return 3  #무승부임 
    
    #컴퓨터가 이기는 경우의 수 or
    # 가위-1 바위-2 보-3 
    # \ 기호는 여러줄에 걸쳐서 문장을 작성할때 같은줄이다라는 의미 \ 앞뒤로 
    # 공백이 필요하다  
    if (computer==1 and person==3) or \
       (computer==2 and person==1) or \
       (computer==3 and person==2):
        return 1 #컴퓨터가 이김 
    
    #사람이 이기는 경우의 수 or .....
    return 2 

titles = ["", "가위", "바위", "보"]
titles2= ["", "컴퓨터승", "사람승", "무승부"]
gameList=[] #{"computer":"값", "person":"값", winner:"값"}

def test():
    for i in range(0, 10):
        computer = random.randint(1,3)
        person = random.randint(1,3)
        winner = isWinner(computer, person)
        print("컴퓨터:", titles[computer], "사람:",titles[person], titles2[winner])

def gameStart():
    gameList.clear() #데이터만 삭제 
    #계속 반복 
    while True:
        computer = random.randint(1,3)
        person = int(input("1.가위 2.바위 3.보 "))
        winner = isWinner(computer, person)
        print("컴퓨터:", titles[computer], "사람:",titles[person], titles2[winner])
        gameList.append({"computer":computer, "person":person, 
                         "winner":winner})
        again = input("게임을 계속 하시겠습니까?(y/n) ")
        if again !="Y" and again!="y":
            return  

def gameStatistic():
    computer_win=0
    person_win=0
    equal_win=0
    for game in gameList:
        if game["winner"]=="1":
            computer_win+=1 
        elif game["winner"]=="2":
            person_win+=1 
        else:
            equal_win+=1 

    for game in gameList:
        print(f"컴퓨터:{game["computer"]}", end="\t")
        print(f"사람:{game["person"]}", end="\t")
        print(f"승패:{game["winner"]}")
    
    print("컴퓨터 승 ", computer_win)
    print("사람 승 ", person_win)
    print("무승부 ", equal_win)
    
        
#gameStart() #함수호출을 하자 
def gameMain():
    
    while True:
        print("1.게임시작")
        print("2.게임통계")
        print("3.게임종료")
        sel = input("선택 : ")
        if sel=="1": 
            gameStart() 
        elif sel=="2":
            gameStatistic()
        elif sel=="3":
            print("게임을 종료합니다")
            return 
        
gameMain()

복습

gpt를 이용한 유사예제

숫자 맞추기 게임 (업다운)

# 컴퓨터가 1~100 사이의 숫자 중 하나를 랜덤하게 선택한다.
# 사용자는 숫자를 반복해서 입력하여 맞춰야 한다.
# 사용자의 숫자가 정답보다 크면 "Down!", 작으면 "Up!"을 출력한다.
# 정답을 맞히면 "정답입니다!"와 함께 시도 횟수를 출력하고 종료한다.

import random
def computer():
    com_num = random.randint(1,100)
    return com_num

def user():
    while True:
        user_num = int(input("1~100사이 숫자를 입력하세요. "))
        if user_num in range(1,101):
            return user_num
        else:
            print("다시 입력하세요.(1~100사이의 숫자만 가능)")

def start():
    print("숫자 맞추기를 시작합니다.")
    
def compare(user_num, com_num):
    if user_num >= com_num:
        print("Down")
    elif user_num <= com_num:
        print("UP")
    else:
        print("정답입니다!")

def game():
    start()
    com_num = computer()
    attempts = 0
    while True:
        user_num = user()
        compare(user_num, com_num)
        attempts += 1
        
        if user_num == com_num:
            print(f"{attempts}번 만에 맞췄습니다. 축하합니다")
    
game()

단어 맞추기 게임

# 컴퓨터가 과일 이름 중 하나를 랜덤하게 선택한다.
# 사용자는 단어를 입력해 정답을 맞춰야 한다.
# 틀리면 "틀렸습니다.", 맞히면 "정답입니다!"를 출력하고 종료한다.
# 정답을 맞힐 때까지 반복 입력이 가능하다.

import random

words = ["apple", "grape", "mango", "peach", "melon"]

def com_fruit():
    return random.choice(words)

def user_fruit():
    return input("과일을 입력하세요 : ").lower()

def compare(user_choice, com_choice):
    if user_choice == com_choice:
        print("정답입니다.")
        return True
    else:
        print("틀렸습니다. 다시 입력하세요.")
        return False

def start():
    print("과일 맞추기 게임을 시작합니다.")

def main():
    start()
    com_choice = com_fruit()
    attempts = 1

    while True:
        user_choice = user_fruit()
        attempts += 1

        if compare(user_choice, com_choice):
            print(f"{attempts}번 만에 맞췄습니다. 축하합니다!")
            break

main()

4자리 pin번호 맞추기

import random

def computer():
    # 4자리 문자열로 반환 (예: '0426')
    com_pw = str(random.randint(0, 9999)).zfill(4)
    return com_pw

def user():
    while True:
        user_pw = input("4자리 숫자를 입력하세요: ")
        if len(user_pw) == 4 and user_pw.isdigit():
            return user_pw
        else:
            print("잘못된 입력입니다. 4자리 숫자를 입력하세요.")

def compare(user_pw, com_pw):
    correct = 0
    error = 0
    for i in range(4):
        if user_pw[i] == com_pw[i]:
            correct += 1
        else:
            error += 1
    return correct, error

def start():
    print("비밀번호 맞추기 게임을 시작합니다.")

def main():
    start()
    com_pw = computer()
    attempts = 0

    while True:
        user_pw = user()
        attempts += 1

        if user_pw == com_pw:
            print(f"비밀번호 맞았습니다! {attempts}번 만에 성공했습니다.")
            break
        else:
            correct, error = compare(user_pw, com_pw)
            print(f"{correct}개 맞고, {error}개 틀렸습니다.")
            print("다시 시도하세요.\n")

main()