언제쯤 검색없이 코딩을 짤까요.

immutable

immutable은 값이 변경 안되는 요소를 얘기한다. 즉, 이뮤테이블은 상수다.

예를 들면 int, str, float, bool, tuple 이런 변수들을 말한다.

def f1(num, name):
    print('f1에서 변경 전')
    print('num:', num)
    print('name:', name)
    num = 123
    name = 'asf'
    print('f1에서 변경후')
    print('num:', num)
    print('name:', name)

def main():
    num = 10
    name = 'aaa'
    print('main에서 변경 전')
    print('num:', num)
    print('name:', name)
    f1(num, name)
    print('main에서 변경후')
    print('num:', num)
    print('name:', name)    

main()

out)

 출력을 봤을 때, f1에서는 변수 값이 변화됐지만 메인에서는 변화되지 않았다.

이뮤테이블들은 변화가 불가능한 값이기 때문!

mutable

뮤테이블은 이뮤테이블의 반대이다. 변경되는 값들을 얘기한다. 대표적으로 리스트, 셋, 딕셔너리 등

def f1(arr):
    print('f1안에서 변경전:',arr)
    arr[0]=100
    print('f1안에서 변경후:',arr)

def main():
    x = [1,2,3,4,5]
    print('main안에서 변경전:',x)
    f1(x)
    print('main안에서 변경후:',x)   

main()

out)

출력에서 보다시비 함수 f1 안에서도 튜플 0번이 바뀌었고 메인에서도 바뀌었다.

이뮤테이블과 뮤테이블의 차이는 변수를 튜플로 인식하냐는 것에서 큰 차이가 있다.

hp = 30
exp = 0
lv = 1



def 밥먹기():

    global hp    #hp는 전역변수

    print('피카츄가 밥먹는다')  # hp 5증가
    hp += 5
    return hp


def 잠자기():
    global hp

    print('피카츄가 잠잔다')  # hp 10증가
    hp += 10
    return hp


def 놀기():
    global hp, exp, lv

    print('피카츄가 논다')  # hp 5감소, exp 7증가. hp감소(죽었나?). exp증가(레벨업체크)
    hp -= 5
    flag = hp>0  #살았나 죽었나
    if flag:
        exp +=7
        레벨체크()
    return flag


def 운동하기():
    global hp, exp, lv

    print('피카츄가 운동한다')  # hp 5감소, exp 7증가. hp감소(죽었나?). exp증가(레벨업체크)
    hp -= 15
    flag = hp > 0  # 살았나 죽었나
    if flag:
        exp += 15
        레벨체크()
    return flag

def 상태체크(): #그냥 읽어올때는 전역변수를 알아서 찾아가기 때문에, 따로 변수 지정 안해도 됌.
    print('Lv:', lv, 'HP:', hp, 'EXP:', exp)

def 레벨체크():
    global exp, lv
    if exp>=20:
        lv+=1
        exp -=20
        print('레벨업!!')


def 종료():
    print('종료')


def main():

    global hp, exp, lv
    global exp
    global lv

    flag = True
    while flag:
        print('메뉴를 선택하시오.')
        num = int(input('1.밥먹기 2.잠자기 3.놀기 4.운동하기 5.상태체크 6.종료'))

        if num == 1:
            밥먹기()
        elif num == 2:
            잠자기()
        elif num == 3:
            flag = 놀기()
        elif num == 4:
            flag = 운동하기()
        elif num == 5:
            상태체크()
        elif num == 6:
            종료()
            break
        if not flag:
            print('캐릭터사망')
            종료()

main()

out)

지역변수vs 전역변수

지역변수? 지역구! 즉, 함수 내에서 선언하여 그 함수 내에서만 사용가능한 변수이다.

전역변수? 전역구! 즉, 함수 밖에서 선언하여 파일 내 모든 함수에서 사용 가능한 변수이다.

num=10   #전역변수
def f1():
    num=20   #지역변수. 저장하는 메모리가 전역과 서로 다르기때문에 에러안남.
    print('f1:',num)

def f2():
    x=5
    print('f2 x:',x)
    print('f2 num:', num)

def main():
    print('main num:', num)
#    print('main x:', x)  : 다른 함수의 지역변수 사용불가가
    f1()
    f2()
    print('main num:', num)

main()   #메인함수 먼저 출력

out)

그런데 코딩을 짜다보니 전역변수를 바꾸고 싶다면?

그럴 때는 함수 내에서 global <변수> 를 지정해주면 되지롱~

num=10   #전역변수
def f1():
    global num  #num을 전역변수로 지정(즉, 전역변수 수정).
    num=20   #지역변수. 저장하는 메모리가 전역과 서로 다르기때문에 에러안남.
    print('f1:',num)

def f2():
    num=15
    x=5
    print('f2 x:',x)
    print('f2 num:', num)

def main():
    print('main num:', num)
#    print('main x:', x)  : 다른 함수의 지역변수 사용불가가
    f1()
    f2()
    print('main num:', num)

main()   #메인함수 먼저 출력

out)

근데 왜 global을 써도 에러가 뜨는거지...? (멘붕)

def f1():
    print('파라메터, 리턴값 없는 함수')

def f2(num):
    print('입력받은 숫자:',num)

def f3(name, age):
    print('당신의 이름은:',name)
    print('당신의 나이는:',age)

def f4(name, age):
    msg = '당신의 이름은:'+name+', 당신의 나이는:'+str(age)
    return msg

def f5(name, age):
    return name, age  #return 값이 여러개면 하나의 튜플로 반환됨


f1()
f2(3)
f3('aaa', 12)
s = f4('aaa', 12)
print(s)

#n, a = f5('bbb', 13)
#print(n, ':', a)
t=f5('bbb', 13) #t는 튜플, 위에 있는 출력값하고 같음.

print(type(t))
print('name:',t[0],', age:', t[1])

out)

Q. 리스트 요소의 총합, 최댓값, 최솟값을 반환하는 함수를 만들어보자.

def printlist(arr):
    for i in arr:
        print(i, end=' ')
    print()

#리스트 요소의 총합 반환 함수
def sumlist(x):
    s = 0
    for i in x:
        s += i
    return s

#리스트의 최댓값 반환 함수
def maxlist(x):
    max = x[0]   #첫 요소를 max값으로 조기화
    for i in x:
        if max < i:
            max = i
    return max

#리스트의 최솟값 반환 함수
def minlist(x):
    min = x[0]
    for i in x:
        if min > i:
            min = i
    return min

def main():   #main함수. 프로그램의 시작점
    a = [1,2,3,4,5]
    printlist(a)
    k=sumlist(a)
    l=maxlist(a)
    n=minlist(a)
    print('총합:', k)
    print('최댓값:',l)
    print('최솟값:',n)

    b=[9,8,7,6,5,4]
    printlist(b)
    k=sumlist(b)
    l=maxlist(b)
    n=minlist(b)
    print('총합:', k)
    print('최댓값:', l)
    print('최솟값:', n)


main()  #main 호출

out)

Q. 숫자를 받아서 그 숫자의 약수를 출력하는 함수

#파라메터로 숫자를 받아서 그 숫자의 약수 출력하는 함수. 리턴값 없음

x=int(input('약수를 구할 숫자를 입력하세요:'))

def 약수(x):
    print(x, '의 약수', end='')
    for i in range(1, x+1):
        if x % i == 0:
            print(i, ',', end='')
    print()

약수(x)



#약수 구해서 리스트에 담아서 반환하는 함수

def 약수2(num):
    res = []   #빈 리스트 생성, 약수 구한거 담을라고
    for i in range(1, num+1):   #약수 구하기 위한 루프. i:1~6
        if num%i == 0:      #i가 약수인지 확인
            res.append(i)
    return res   #d=약수2(x)에 값 던짐

def 약수프린트(data):
    print(data[len(data)-1], '의 약수: ', end='')
    for i in data:
        print(i, end=', ')
    print()

x = int(input('num:'))
d = 약수2(x)
약수프린트(d)

out)

*리턴값을 사용하면 반환된 값이 따로 저장이 되어 나중에 어떤 함수에서는 활용이 가능하다!

 Q. 연산할 숫자 2개와 사칙연산자 한개를 입력받는 계산기를 만들어보자.

def 더하기(a, b):
    c = a+b
    return c    #return a+b 랑 같은 뜻

def 빼기(a, b):
    return a-b

def 곱하기(a, b):
    return a*b

def 나누기(a, b): #파이썬은 함수에서 아무값도 반환하지 않으면 None객체 전달됨
    if b !=0:
        return a/b

x=int(input('x='))    #계산할 숫자1
y=int(input('y='))    #계산할 숫자2
res = None     #계산 결과 담을 변수
op = input('사친연산(+, -, *, /):')   #이항연산자

if op == '+':
    res = 더하기(x,y)
elif op == '-':
    res = 빼기(x, y)
elif op == '*':
    res = 곱하기(x, y)
elif op == '/':
    res = 나누기(x, y)

if res == None:     #0으로 나누면 안되기 때문에 따로 None을 잡아줌
    print('잘못된 수식')
else:
    print(x, op, y, '=', res)

out)

*사칙연산에서는 0으로 나누게 되면 오류가 발생하기 때문에 res == None 이라는 변수를 미리 잡아주어 연산 오류가 나는 것을 막아준다!

def 더하기(a, b):
    c = a+b
    return c    #return a+b 랑 같은 뜻

def 빼기(a, b):
    return a-b

def 곱하기(a, b):
    return a*b

def 나누기(a, b): #파이썬은 함수에서 아무값도 반환하지 않으면 None객체 전달됨
    if b !=0:
        return a/b
    else :
        print('잘못된 수식')

x=int(input('x='))    #계산할 숫자1
y=int(input('y='))    #계산할 숫자2
op = input('사친연산(+, -, *, /):')   #연산자

if op == '+':
    res = 더하기(x,y)
    print(x, op, y, '=',res)
elif op == '-':
    res = 빼기(x, y)
    print(x, op, y, '=',res)
elif op == '*':
    res = 곱하기(x, y)
    print(x, op, y, '=',res)
elif op == '/':
    res = 나누기(x, y)
    print(x, op, y, '=',res)

out)

res = None 을 알지 못했을 때, if문으로 출력하려고 잡았던 코드.

if문이 잘 돌아가기는 하는데 마지막 줄 5 / 0 = None 이 출력되는 것이 아쉽다.

마지막 줄이 안나오게 수정할 방법이 없는건가?

함수

가장 간락현 코딩은 앞에서 봤던 변수, 연산자, 제어문들을 이용해서 루트를 짜는 것이다.

그런데 계속해서 코드가 반복적으로 나온다면 기본적인 변수들만으로는 번거롭고 귀찮다.

그래서 리스트나 함수를 이용하면 조금 더 간편하게 코드 작성이 가능한데 오늘은 함수에 대해서 정리해보자! 

함수는, 자주 사용하는 코드를 반복적으로 작성하지 않고 모듈화해서 필요할 때 호출해서 반복사용하는 방법이다.

프로그램의 입작으로는 하나의 기능을 구현하는 것이다.

1.함수사용방법

 1)함수정의

   def 함수명(파라미터들(매개변수):

  실행문1

  실행문2

 파라미터 : 매개변수

만약 함수가 2x+1 이고 파라미터가 0, 1,2 이면

리턴값(결과물)은 각각 1, 3, 5 이다. (파이썬은 리턴값 갯수의 제약이 없다.)

 2)함수호출

  함수를 불러옵니다.

  만약 함수에 파라미터가 있다면 호출시 그 값을 넣어줍니다.

   res = add(1,2)   #add() 함수 호출

   print(res)

함수를 호출하면 그 함수로 점프한다.

#함수 정의

def hello():  #hello라는 함수 정의. 파라미터는 아무것도 없다. 리턴도 없음.
    print('hello')

def add(x, y):    #x, y는 파라미터
    return x+y

def gugu(dan):  #파라메터로 구구단 한 단을 출력하는 함수를 만드시오.
    print('<', dan, '단>')
    for i in range(1, 10):
        print(dan, '*', i, '=' , dan*i)


#함수 호출
hello()
res = add(1,2)   #호출 시 파라메터에 넣어주는 값을 아규먼트(인자).
print(res)

gugu(4)

out)

그럼 추가 예제!

구구단을 2단부터 9단까지 출력하고 싶다면?

def gugu(dan):  #파라메터로 구구단 한 단을 출력하는 함수를 만드시오.
    print('<', dan, '단>')
    for i in range(1, 10):
        print(dan, '*', i, '=' , dan*i)
        

for i in range(2,10):       #출력에서 for문 사용하여 단을 늘려준다!
    gugu(i)

def에 단을 바꾸는 반복문을 정의해주는 것이 아니라 출력문에서 써줘도 된다!!! 언빌리버블!

딕셔너리
키와 값을 묶어서 저장
키는 중복허용안함. 값은 중복되도 됨
키의 타입은 변경불가한값, 값의 타입은 제약 없음
요소 추가, 변경, 삭제 가능

d1={'name':'aaa', 'age':12, 'flag':True}
print(d1)
print(type(d1))

d2 = {1:'aaa', 2:'bbb', 3:'ccc'}
print(d2)
print(type(d2))

#요소접근
print(d1['name'])
print(d1['age'])
print(d1['flag'])

print(d2[1])
print(d2[2])
print(d2[3])

out)

{'name': 'aaa', 'age': 12, 'flag': True}
<class 'dict'>
{1: 'aaa', 2: 'bbb', 3: 'ccc'}
<class 'dict'>
aaa
12
True
aaa
bbb
ccc

#요소추가
d1['tel'] = '1234'
print(d1)

#수정
d1['name'] ='bbb'
print(d1)

#전체 항목 불러오기
items = d1.items()
print(items)
for i in items:
    print(i)

#요소 삭제
del d1['name']
print(d1)

out)

{'name': 'aaa', 'age': 12, 'flag': True, 'tel': '1234'}
{'name': 'bbb', 'age': 12, 'flag': True, 'tel': '1234'}
dict_items([('name', 'bbb'), ('age', 12), ('flag', True), ('tel', '1234')])
('name', 'bbb')
('age', 12)
('flag', True)
('tel', '1234')
{'age': 12, 'flag': True, 'tel': '1234'}

Process finished with exit code 0

#딕셔너리 함수
d1['name']='aaa'
print(d1.get('name')) #get(키):키로 검색된 값을 반환
keys = d1.keys()
print(keys)

vals = d1.values()
print(vals)

for k in keys:
    val = d1[k]
    print(k,':',val)

d1.clear()
print(d1)

out)

aaa
dict_keys(['name', 'age', 'flag'])
dict_values(['aaa', 12, True])
name : aaa
age : 12
flag : True
{}

셋: 집합
요소 중복 허용 안됌
순서 없음
요소 변경 불가
셋 자체는 변경 가능(요소를 추가/삭제 가능)

s={1,2,3}
print(s)
print(type(s))

s={}    #요소가 없으면 딕셔너리로 바뀜
print(type(s))

s = set()    #공집합!
print(type(s))

#요소 순서 없기 때문에 인덱스 없음 s[1] 이런거 존재 안함
s= {1,2,3,2,3}  #중복된 값이 있으면 에러 없이 저장 안함
for i in s:
    print(i)    #set은 중복된 값 상관없이 한 개만 출력

s={'aaa', 1, False} 
print(s)         #set은 순서가 상관이 없음.


# s={1,2 [3,4,5]} 이런 형태는 안됌. 변경가능한 요소를 가질 수 없음
# s={1,2 {3,4,5}} 얘도 안되네..

out)

{1, 2, 3}
<class 'set'>

<class 'dict'>

<class 'set'>

1
2
3

{False, 1, 'aaa'}

#셋에 요소 추가
s.add('bbb')   #한개만 추가

a=[5,6,7]
s.update(a)    #여러개 추가
print(s)

#요소 삭제
s.remove('aaa')   #없는 요소 삭제시 에러발생
s.discard(1)  #discard : 삭제함수, 없는 요소 삭제시 무시
print(s)

x = s.pop()   #맨 앞에 있는 애가 빠짐
print(x, '가 삭제됨')
print(s)

x = s.pop()
print(x, '가 삭제됨')
print(s)

s.clear()   #모든 요소 삭제
print(s)

out)

{False, 1, 'aaa'}

{False, 1, 5, 6, 'aaa', 7, 'bbb'}

{False, 5, 6, 7, 'bbb'}

False 가 삭제됨

{5, 6, 7, 'bbb'}

5 가 삭제됨

{6, 7, 'bbb'}

{}

Process finished with exit code 0

import copy
#얕은 복사
a=[1,2,3]
b=a #참조값 복사
print(a)
print(b)

a[2]=30
print(a)
print(b)

#얕은 복사2
a = [1,2,3]
b = copy.copy(a) # a리스트를 복사해서 같은 리스트를 b로 만들어라
print(a)
print(b)

a[2] = 30
print(a)
print(b)

###############
a=[1,2,[4,5,6]]
b = copy.copy(a)
print(a)
print(b)



a[2][0]=40
print(a)
print(b) #b까지 다 수정되네? 흠...