회고

• 함수 만들기에 집중하여 코딩하기
• 람다의 일회성 사용법이 익숙하지 않다. 더 적어라.
• 함수를 다 만들어 놓고 마지막 출력 때 조합을 잘못하고 있다. 코드의 흐름을 타자!!

최선을 다하지 않으면 부끄러워 할 수도 없다. 항상 화이팅하자!

필기

함수

• 함수 만드는 것에 익숙해져야한다. 제발제발제발 더 적어보고 이해해라.

def toDouble(x): #x라는 매개변수를 이용해서 a의 값을 전달함.
    x = x * 2 #x는 값이 2배가 됨.
    
a = 10 #a라는 변수와 함수의 매개변수인 x는 서로 다른 공간입니다.
toDouble(a) #x라는 변수에 값을 복사해가고, 함수를 수행하면서 복사된 x값은 수정된다. 그러나 a와는 관계가 없다.
print(a)    #call by value 함수를 값 복사로 호출한다.
            #dick 타입이나 list타입의 경우에는 함수내부에서 값 변환이 가능함.
            #함수에 dict나 list는 주소를 전달하는 방식이다.
            
def toDouble2(mydic):
    mydic["x"] *=2
    mydic["y"] *=2
    
mydic = {"x":1, "y":1}
toDouble2(mydic)
print(mydic)

#파이썬의 경우는 오버로딩을 지원하지 않음.
#오버로딩은 동일한 이름의 함수를 여러개를 만드는 것이다.
#변수에 타입이 없다. 그냥 막 쓰니까 매개변수의 개수나 타입으로 호출할 함수가 뭔지를 알 길이 없다.
#대신 매개변수에 기본값을 줄 수 있다. 그래서 마치 오버로딩같은 효과를 가져올 수 있다.

def myadd(x=0,y=0,z=0):
    return x+y+z

result = myadd(1,2,3)
print(result)

result = myadd()
print(result)

result = myadd()
print(result)
print(myadd())
print(myadd(1))
print(myadd(1,2))
print(myadd(1,2,3))

#모든 매개변수에 기본값을 줘야 하는 것은 아니고, 기본값을 주기 시작했으면 나머지 매개변수도 다 줘야 한다.
def myfunction(a,b,c = 0, d=0, e=0):
    print(f"a={a} b={b} c={c} d={d} e={e}")
    return a+b+c+d+e

print(myfunction(4,5))

def Sigma(limit=10):
    s = 0
    for i in range(1,limit+1):
        s += i
    return s

print(Sigma())
print(Sigma(5))
print(Sigma(100))

lambda

• 람다는 일회용 함수이다. 임시함수를 만들어 값을 뽑아낸다.

# 람다는 한줄짜리 함수, 함수를 쓰고 버린다.
def add(x=0,y=0,z=0): # 함수는 그 자체가 주소이다.
    return x+y+z

myadd = add #myadd라는 변수에 add함수 주소가 들어간다.
print(myadd(3,4,5))

#함수의 매개변수로 함수를 줄 수 있다.
def myfunc(x, y, callback): #세번째 인자가 callback - 함수주소를 받아옴
    result = callback(x,y)
    print(x, y, result)
    
def add(x,y):
    return x+y

myfunc(4,5,add) # 함수주소를 전달한다.
myfunc(4,5, lambda x, y : x-y) # 임시함수를 만든다. lambda로 시작해야하고 이름은 없으면 두개의 매개변수를 가져야한다.
                              # : 콜론 뒤에는 함수의 내용을 기술하면 되고 return은 생략이다.
                              
fucList = [ lambda x, y : x+y,
           lambda x, y : x-y,
           lambda x, y : x*y,
           lambda x, y : x/y]
for fun in fucList:
    print(fun(9,7))
    
#앞에 함수, 두번째 인자에 iterable이 온다.
#특정 조건에 맞는 데이터의 iterable타입을 반환한다.

a = [1,2,3,4,5,6,7,8,9,10]
#첫번째 매개변수로 올 함수를 호출하는 호출자는 filter 임
#매개변수가 하나이어야 하고, 반환값을 bool타입 True or False이어야 함.

def isEven(n):
    return n % 2 == 0

for i in filter(isEven,a):
    print(i)
    
for i in filter(lambda x:x%2==0, a):
    print(i)
    
personList = [
    {"name":"홍길동", "age":34, "phone":"010-0000-0001"},
    {"name":"강감찬", "age":70, "phone":"010-0000-0004"},
    {"name":"서희", "age":54, "phone":"010-0000-0003"},
    {"name":"윤관", "age":39, "phone":"010-0000-0002"},
    {"name":"김종서", "age":38, "phone":"010-0000-0005"},
    {"name":"이순신", "age":44, "phone":"010-0000-0006"},
    {"name":"곽재우", "age":62, "phone":"010-0000-0009"}
]

#이름이 서희인 사람의 자료를 갖고 오고자 한다.
#filter가 personList를 가져갔으니까 람다의 매개변수도 personList안의 dick개체
#반환값도 dict객체임
keyname = "서희"
for person in filter(lambda e : e["name"] == "서희", personList):
    print(f"{person["name"]} {person["age"]} {person["phone"]}")

#filter를 감싸고 있는 list가 filter를 동작을 시키고 결과들을 list로 만들어서 반환한다.
findList = (list(filter(lambda e:e["name"] == keyname, personList)))
print(findList)

#40세 이상만 출력하기
keyage = 40
findList = (list(filter(lambda x:x["age"] >= keyage, personList)))
print(findList)

#map : 연산을 수행한다. ex) 나이 - 5
#첫번째 매개변수가 매개변수 하나, 값 하나를 반환하는 함수이어야 한다.
for i in map(lambda x:x*10,a):
    print(i)
    
for per in map(lambda x: {"name": x["name"], "age": x["age"] + 5}, personList):
    print(per)

#데이터 정렬 list타입 자체가 sort메서드를 가지고 있다.
#sorted 함수가 filter처럼 별도로 존재한다.
#key 라는 매개변수에 lambda를 전달해야한다.
a = [9,4,5,6,7,8,1,2,10,3]
a.sort() #내부 데이터가 정렬된다.
print(a) 

#dict type은 < 연산자가 없다. 에러발생
#lambda는 매개변수 하나고 반환값이 > 연산자가 지원되는 반환타입만 가능하다.
#오름차순이 기본값이다.
personList.sort(key = lambda x : x["name"],reverse=True) #정렬을 할때 a[0] < a[1]
print(personList)


personList.sort(key = lambda x : x["age"],reverse=True)
print(personList)

#list타입에 속한 함수 sort는 자신의 순서가 바뀐다.
#sorted(iterable데이터, key, reverse) 첫번째 매개변수로 전달된 데이터의 원래 순서는 안바꾸고
#바뀐 순서를 list로 만들어 전달한다.

a = [9,4,5,6,7,8,1,2,10,3]
b = sorted(a)
print("a=", a)
print("b=", b)

personList = [
    {"name":"홍길동", "age":34, "phone":"010-0000-0001"},
    {"name":"강감찬", "age":70, "phone":"010-0000-0004"},
    {"name":"서희", "age":54, "phone":"010-0000-0003"},
    {"name":"윤관", "age":39, "phone":"010-0000-0002"},
    {"name":"김종서", "age":38, "phone":"010-0000-0005"},
    {"name":"이순신", "age":44, "phone":"010-0000-0006"},
    {"name":"곽재우", "age":62, "phone":"010-0000-0009"}
]

list2 = sorted(personList, key = lambda per:per["name"])

성적출력_함수활용(김성재)

# 이름, 국어, 영어, 수학, 총점, 평균
# 평균에 대해서 수(90), 우(80), 미(70), 양(60), 가(60미만)

studentList = []

def append(): # 입력 함수
    student = {}
    student["name"] = input("이름 : ")
    student["kor"] = int(input("국어 : "))
    student["eng"] = int(input("영어 : "))
    student["math"] = int(input("수학 : "))
    cal_total(student)
    cal_avg(student)
    grade(student)
    
    studentList.append(student)
    
def cal_total(student): # 총점 계산
    student["total"] = student["kor"] + student["eng"] + student["math"]
    
def cal_avg(student): # 평균 계산
    student["avg"] = student["total"] / 3
    
def grade(student): # 등급 계산
    if student["avg"] >= 90:
        Grade = "수"
    elif student["avg"] >= 80:
        Grade = "우"
    elif student["avg"] >= 70:
        Grade = "미"
    elif student["avg"] >= 60:
        Grade = "양"
    else:
        Grade = "가, 재시험요망"
        
    student["grade"] = Grade
        
def output(studentList): # 출력 함수
    for student in studentList:
        print(f"{student['name']}님의 성적은 {student['grade']} 입니다.")
 
def start(): # 시작 함수
    while True:
        sel = int(input("1:추가, 2: 출력, 3: 종료 "))
        if sel == 1:
            append()
        elif sel == 2:
            output(studentList)
        elif sel == 0:
            print("프로그램을 종료합니다.")
            return
            
start()

성적출력_함수활용(백현숙강사님)

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

def output():
    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 

#n = getNumber()

def start():
    while True:
        print("1.추가")
        print("2.출력")
        print("0.종료")
        sel = input("선택 : ")
        if sel=="1":
            append()
        elif sel=="2":
            output()
        elif sel=="0":
            print("프로그램을 종료합니다.")
            return
        else:
            print("잘못 선택하셨습니다")
           
start()

#만약 이름을 기반으로 검색하고 싶다면

def init():
    for i in range(1,11):
        scoreList.append({"name":f"홍길동{i}", "kor":0, "eng":100, "mat":20})

주급_함수활용(김성재)

# 입력 : 이름, 시급, 근무시간

workerList = []

def append():
    worker = {}
    worker["name"] = input("이름 : ")
    worker["per_pay"] = int(input("시급 : "))
    worker["worktime"] = int(input("근무시간 :"))
    worker["pay"] = 0
    
    workerList.append(worker)
    

# 계산 : 총 급여 = 시급 * 근무시간

def cal_pay(worker):
    worker["pay"] = worker["per_pay"] * worker["worktime"]
    
def main():
    while True:
        print("1.추가")
        print("2.종료")
        print("3.계산")
        print("4.종료")
        sel = input("입력하세요")
        if sel == 1:
            append()
        elif sel == 2:
        
        elif sel == 3:	

주급_함수활용(백현숙강사님)

workerList = []

def append(): #데이터 추가 함수
        worker = {} #dict type 객체 생성
        worker["name"] = input("이름: ")
        worker["work_time"] = int(input("근무시간 : "))
        worker["per_pay"] = int(input("시급 : "))
        worker["pay"] = 0
        
        workerList.append(worker)
        
def process(worker): #dict 가져와서 반환하는 방법, 매개변수로 값을 받아오면 외부로 전달은 안된다.
    worker["pay"] = worker["work_time"] * worker["per_pay"]
    
def process_main():
    for w in workerList:
        process(w)
        

def output(): #데이터 출력 함수
    for worker in workerList:
        print(f"{worker["name"]}", end = "\t")
        print(f"{worker["work_time"]}", end = "\t")
        print(f"{worker["per_pay"]}", end = "\t")
        print(f"{worker["pay"]}", end = "\t")
        print() #줄바꿈 코드

append() # 함수호출
output() # 함수호출

def main(): #return : 함수를 종료하면서 함수의 작업 내용을 함수 외부로 전달한다. #return 값을 안주면 그냥 함수 종료의 의미이다.
    while(True): #무한루프 - 종료를 하지 않는다. break나 return 구문을 써야한다.
        print("1.추가")
        print("2.출력")
        print("3.계산")
        print("0.종료")
        sel = input("선택:") #select
        if sel == "1": # 사용자가 1을 입력했을 때
            append() # 추가함수 호출하기
        elif sel == "2":
            output() # 출력함수
        elif sel == "3":
            process_main()
        elif sel == "0":
            print("프로그램을 종료합니다.")
            return # 함수 자체를 종료시킨다.
        else:
            print("잘못 선택하셨습니다.")
            
main()

과제

lambda 활용(김성재)

words = ["assembly", "java", "rain", "notebook", "north", "south", "hospital", "programming", "house", "hour"]

# 문제1. filter를 사용해서 글자수가 6글자 이상인 단어만 출력하기 (컴프리핸션X)
resultList = list(filter(lambda x : len(x) >= 6, words))
print(resultList)

# 문제2. map함수를 사용해서 글자를 대문자로 바꾸어서 출력하기  (컴프리핸션X)
resultList = list(map(lambda x:x[0].upper() + x[1:],words))
print(resultList)

# 문제3. sorted 함수를 사용하여 단어들의 길이순으로 오름차순 정렬하여 출력하기
b = sorted(words)
print(b)

# 문제4. sorted 함수를 사용하여 알파벳 순으로 내림차순으로 정렬하여 출력하기
words.sort(key = lambda x : x,reverse=True)
print(words)

# 문제5. 단어중에 o가 포함되는 단어가 모두 몇개인지 카운트하기 (힌트,filter를 사용)
resultList = list(filter(lambda x : "o" in x, words))
print(len(resultList))

lambda 활용(백현숙강사님)

words = ["assembly", "java", "rain", "notebook", "north", "south", "hospital", "programming", "house", "hour"]

#문제1. filter를 사용해서 글자수가 6글자 이상인 단어만 출력하기 (컴프리핸션X)
resultList = list(filter(lambda x : len(x) >= 6, words))
print(resultList)

#문제2. map함수를 사용해서 글자를 대문자로 바꾸어서 출력하기  (컴프리핸션X)
resultList = list(map(lambda x:x[0].upper() + x[1:],words))
print(resultList)

#문제3. sorted 함수를 사용하여 단어들의 길이순으로 오름차순 정렬하여 출력하기
b = sorted(words)
print(b)

#문제4. sorted 함수를 사용하여 알파벳 순으로 내림차순으로 정렬하여 출력하기
words.sort(key = lambda x : x,reverse=True)
print(words)

#문제5. 단어중에 o가 포함되는 단어가 모두 몇개인지 카운트하기 (힌트,filter를 사용)
resultList = list(filter(lambda x : "o" in x, words))
print(len(resultList))

복습

gpt를 이용한 유사예제

리스트에서 짝수만 추출하는 함수

# 숫자 리스트가 주어졌을 때,
# 해당 리스트에서 짝수만 추출하는 함수를 작성하시오.
# 입력 예시: get_evens([1, 2, 3, 4, 5, 6]) → [2, 4, 6]
num_list = [1, 2, 3, 4, 5, 6]
even_list = []

def get_even(num_list):
    for num in num_list:
        if num % 2 == 0:
            even_list.append(num)
    print(even_list)
    
get_even(num_list)

리스트를 대문자로 변환하는 함수

# 문자열 리스트가 주어졌을 때,
# 모두 대문자로 변환하는 함수를 작성하시오.
# 입력 예시: to_upper(["hello", "world"]) → ["HELLO", "WORLD"]

sen_list = ["hello", "world"]

def to_upper(sen_list):
    large_list = []
    for sen in sen_list:
        large_list.append(sen.upper())
    return large_list

print(to_upper(sen_list))

두 수의 최대공약수(GCD)를 구하는 함수

# 입력 예시: gcd(36, 60) → 12

def gcd(num1,num2):
    for i in range(1, num1+1):
        if num1 % i ==0 and num2 % i ==0:
            gcd = i
    print(f"두수의 최대공약수는 {gcd}입니다.")
            
gcd(36,60)

주어진 문자열이 팰린드롬(앞뒤가 같은 문자열)인지 확인하는 함수를 작성하시오.

# 입력 예시: is_palindrome("level") → True

def is_palindrome(word):
    if word[0::] == word[::-1]:
        print(f"{word}는 팰린드롬 입니다.")
    
    if word[0::] != word[::-1]:
        print(f"{word}는 팰린드롬이 아닙니다.")
        
is_palindrome("level")

숫자 리스트를 입력받아 중복을 제거하고 정렬된 리스트를 반환하는 함수

# 입력 예시: unique_sorted([3, 1, 2, 3, 4, 2]) → [1, 2, 3, 4]

def unique_sorted(num):
    result = set(num) #set을 통한 중복제거와 정렬, dict로 반환
    result = list(result) #list를 통한 list 형태로 반환
    print(result)
    
unique_sorted([3, 1, 2, 3, 4, 2])

문자열을 받아 각 단어의 첫 글자만 대문자로 바꾼 문자열을 반환하는 함수를 작성하시오.

# 입력 예시: capitalize_words("hello python world") → "Hello Python World"

def capitalize_words(word):
    result = word.title() #title()은 각 단어의 첫글자를 대문자로 변경한다.
    print(result)
    
capitalize_words("hello python world")

이메일 주소 리스트에서 도메인(@ 뒤의 문자열)만 추출하는 함수를 작성하시오.

# 입력 예시: extract_domains(["a@test.com", "b@naver.com"]) → ["test.com", "naver.com"]

def extract_domains(s):
    domain_list = []
    for i in s:
        domain = i.split("@")[1] # @를 기준으로 분할하고 [1]번 인덱스 선택
        domain_list.append(domain)
    return domain_list

print(extract_domains(["a@test.com", "b@naver.com"]))

문자열을 받아 단어 수를 반환하는 함수를 작성하시오.

# 입력 예시: count_words("hello world from python") → 4

def count_words(s):
    result = len(s.split())
    print(result)

count_words("hello world from python")

학생의 이름과 과학, 사회 점수를 입력받고 총점과 평균을 계산하여 출력

# 단, 평균이 90 이상이면 “우수”, 60 미만이면 “재시험”, 그 외는 “보통”이라고 판단하라.
studentList = []

def append(): # 입력함수
    student = {}
    student["name"] = input("이름 : ")
    student["science"] = int(input("과학 : "))
    student["society"] = int(input("사회 : "))
    total(student)
    avg(student)
    grade(student)
    studentList.append(student)
    
def total(student): # 총점계산 
    student["total"] = student["science"] + student["society"]
    
def avg(student): # 평균계산 
    student["avg"] = student["total"] / 2

def grade(student): # 등급계산 
    avg = student["avg"]
    if avg >= 90:
        Grade = "우수"
    elif avg <= 60:
        Grade = "재시험"
    else:
        Grade = "보통"
        
    student["grade"] = Grade
    
def output(studentList):
    for student in studentList:
        print(f"{student['name']}", end = "\t")
        print(f"{student['science']}", end = "\t")
        print(f"{student['society']}", end = "\t")
        print(f"{student['total']}", end = "\t")
        print(f"{student['avg']}", end = "\t")
        print(f"{student['grade']}", end = "\t")
    
    
def start():
    while True:
        sel = int(input("1. 입력, 2. 출력, 3. 종료 "))
        if sel == 1:
            append()
        elif sel == 2:
            output(studentList)
        elif sel == 3:
            print("프로그램을 종료합니다.")
            return
    
start()

사용자로부터 이름과 출석일 수(0~30)를 입력받아 출결률을 계산하고, 출결률이 90% 이상이면 “만족”, 75% 이상이면 “주의”, 그 미만이면 “불만족”으로 평가하라.

userList = []

def append():
    user = {}
    user["name"] = input("이름을 입력하세요: ")
    user["attendance"] = int(input("출석일수를 입력하세요: "))
    cal(user)
    satis(user)
    
    userList.append(user)
    
    
def cal(user): #출결률 계산
    user["cal"] = user["attendance"] / 30 * 100

def satis(user): # 만족도
    cal = user["cal"]
    if cal >= 90:
        satisfy = "만족"
    elif cal >= 75:
        satisfy = "주의"
    else: satisfy = "불만족"
    
    user["satisfy"] = satisfy
    
def output(userList):
    for user in userList:
        print(f"{user['name']}", end = "\t")
        print(f"{user['attendance']}", end = "\t")
        print(f"{user['cal']:.2f}", end = "\t")
        print(f"{user['satisfy']}", end = "\t")
        
def start():
    while True:
        sel = int(input("1. 입력, 2. 출력, 3. 종료 "))
        if sel == 1:
            append()
        elif sel == 2:
            output(userList)
        elif sel == 3:
            print("프로그램을 종료합니다.")
            return
        
start()

직원의 이름과 시급, 근무시간을 입력받아 총 급여(시급 * 시간)를 계산하고, 급여가 200만 원 이상이면 “고소득”, 그 이하면 “일반”으로 평가하라.

workerList = []

def append(): #입력 
    worker = {}
    worker["name"] = input("이름 : ")
    worker["timepay"] = int(input("시급 : "))
    worker["worktime"] = int(input("근무시간 : "))
    cal_total(worker)
    evaluation(worker)
    
    workerList.append(worker)
    
    
def cal_total(worker): #급여계산 
    worker["total"] = worker["timepay"] * worker["worktime"]
    
def evaluation(worker): # 급여평가 
    if worker["total"] >= 2000000:
        grade = "고소득"
    else: grade = "일반"
    
    worker["grade"] = grade
    
def output(workerList):
    for worker in workerList:
        print(f"{worker['name']}", end = "\t")
        print(f"{worker['timepay']}", end = "\t")
        print(f"{worker['worktime']}", end = "\t")
        print(f"{worker['total']}", end = "\t")
        print(f"{worker['grade']}", end = "\t")
    
def start():
    while True:
        sel = int(input("1. 입력, 2. 출력, 3. 종료 "))
        if sel == 1:
            append()
        elif sel == 2:
            output(workerList)
        elif sel == 3:
            print("프로그램을 종료합니다.")
            return
        else: print("다시 입력하세요")
            

start()