1. 함수 정의와 호출¶

1.1 인자도 반환값도 없는 함수¶

In [1]:

def my_func():       # 인자가 없어 ()만 입력
    print("My first function!")
    print("This is a function.")

In [2]:

my_func()           # 인자가 없기 때문에 함수명과 소괄호만 입력

My first function!
This is a function.

1.2 인자는 있지만 반환값이 없는 함수¶

In [3]:

def my_friend(friendName):     # friendName이라는 인자있음
    print("{}는 나의 친구입니다.".format(friendName))

In [4]:

my_friend("철수")       #각각 인자를 다르게 입력해 출력결과 2개 나옴
my_friend("영미")

철수는 나의 친구입니다.
영미는 나의 친구입니다.

In [5]:

def my_student_info(name, school_ID, phoneNumber):    # 인자가 3개
    print("------------------------")
    print("- 학생이름:", name)
    print("- 학급번호:", school_ID)
    print("- 전화번호:", phoneNumber)

In [6]:

my_student_info("현아", "01", "01-235-6789")     # 3개의 인자대로 출력됨
my_student_info("진수", "02", "01-987-6543")

------------------------
- 학생이름: 현아
- 학급번호: 01
- 전화번호: 01-235-6789
------------------------
- 학생이름: 진수
- 학급번호: 02
- 전화번호: 01-987-6543

1.3 인자도 있고 반환값도 있는 함수¶

In [7]:

def my_calc(x,y):
    z = x*y
    return z     # return 반환값

In [8]:

my_calc(3,4)   # 가로길이, 세로길이의 인자 두개 입력

Out[8]:

1.4 인자에 리스트도 가능¶

In [9]:

def my_student_info_list(student_info):      # 인자에 리스트도 가능
    print("****************************")
    print("* 학생이름:", student_info[0])
    print("* 학급번호:", student_info[1])
    print("* 전화번호:", student_info[2])
    print("****************************")

In [10]:

student1_info = ["현아", "01", "01-235-6789"]    # 인자가 리스트이므로 인자를 리스트로 입력해 함수출력
my_student_info_list(student1_info)

****************************
* 학생이름: 현아
* 학급번호: 01
* 전화번호: 01-235-6789
****************************

In [11]:

my_student_info_list(["진수", "02", "01-987-6543"])   #리스트를 변수에 넣어 함수의 인자로 넣을 필요없이
                                                      #리스트를 바로 인자로 지정할 수도 있음

****************************
* 학생이름: 진수
* 학급번호: 02
* 전화번호: 01-987-6543
****************************

2. 변수의 유효 범위¶

In [12]:

a = 5             # 전역변수

def func1():
    a = 1         # 지역변수 a에 1을 할당하고 출력
    print("[func1] 지역 변수 a =", a)

def func2():
    a = 2         # 지역변수 a에 2를 할당하고 출력
    print("[func2] 지역 변수 a =", a)  
    
def func3():      # 지역변수 a를 정의하지 않고 a를 출력      # 이때는 전역변수 a를 가져와서 출력
    print("[func3] 전역 변수 a =", a)   
    
def func4():      # 지역변수 a를 정의하지 않고 a를 출력  
    global a      # (global 전역변수명) 이용해 전역변수 변경
    a = 4         # 전역변수 변경된 값
    print("[func4] 전역 변수 a =",a)

In [13]:

func1() 
func2() 
print("전역 변수 a =", a)   # 전역변수 출력 

[func1] 지역 변수 a = 1
[func2] 지역 변수 a = 2
전역 변수 a = 5

지역변수는 전역변수보다 먼저 참조되고 함수가 끝나면 사라짐

In [14]:

func3()
func4() 
func3() 

[func3] 전역 변수 a = 5
[func4] 전역 변수 a = 4
[func3] 전역 변수 a = 4

func4의 호출로 전역변수 a의 값이 변경됬음을 확인

3. 람다 함수¶

In [15]:

(lambda x : x**2) (3)     # (lambda 인자 : 인자활용 수행코드) (인자)

Out[15]:

In [16]:

mySquare = lambda x : x**2   # lambda_function = lambda 인자 : 인자활용 수행코드
mySquare(2)                  # lambda_function(인자)

Out[16]:

In [17]:

mySquare(5)     # 위에서 람다함수를 변수로 할당했으니 인자만 바꿔서 출력가능

Out[17]:

In [18]:

mySimpleFunc = lambda x,y,z : 2*x + 3*y + z     # 여러 개의 인자를 쓸 경우 ,콤마로 구분
mySimpleFunc(1,2,3)

Out[18]:

4. 내장 함수¶

4.1 형 변환 함수¶

정수형으로 변환하는 함수 - int¶

In [19]:

[int(0.123), int(3.5123456), int(-1.312367)]    # 실수를 정수로 변환

Out[19]:

[0, 3, -1]

In [20]:

[int('1234'), int('5678'), int('-9012')]        # 문자열일 때는 실수를 표시하는 게 있어야 변환 가능

Out[20]:

[1234, 5678, -9012]

실수형으로 변환하는 함수 - float¶

In [21]:

[float(0), float(123), float(-567)]               # 정수를 실수로 변환

Out[21]:

[0.0, 123.0, -567.0]

In [22]:

[float('10'), float('0.123'), float('-567.89')]   # 문자열일 때는 실수를 표시하는 게 있어야 변환 가능

Out[22]:

[10.0, 0.123, -567.89]

문자형으로 변환하는 함수 - str¶

In [23]:

[str(123), str(459678), str(-987)]        # 정수를 문자열로 변환

Out[23]:

['123', '459678', '-987']

In [24]:

[str(0.123), str(345.678), str(-5.987)]   # 실수를 문자열로 변환

Out[24]:

['0.123', '345.678', '-5.987']

리스트, 튜플, 세트형으로 변환하는 함수 - list, tuple, set¶

In [25]:

list_data = ['abc', 1, 2, 'def']      # 리스트 데이터 생성
tuple_data = ('abc', 1, 2, 'def')     # 튜플 데이터 생성
set_data = {'abc', 1, 2, 'def'}       # 세트 데이터 생성

In [26]:

[type(list_data), type(tuple_data), type(set_data)]  # type함수로 각 데이터 타입 확인

Out[26]:

[list, tuple, set]

In [27]:

print("리스트로 변환: ", list(tuple_data), list(set_data))   # 튜플과 세트를 리스트로 변환

리스트로 변환:  ['abc', 1, 2, 'def'] [1, 'abc', 2, 'def']

In [28]:

print("튜플로 변환:", tuple(list_data), tuple(set_data))     # 리스트와 세트를 튜플로 변환

튜플로 변환: ('abc', 1, 2, 'def') (1, 'abc', 2, 'def')

In [29]:

print("세트로 변환:", set(list_data), set(tuple_data))       # 리스트와 튜플을 세트로 변환

세트로 변환: {1, 'abc', 2, 'def'} {1, 'abc', 2, 'def'}

4.2 bool 함수¶

True, False 결과를 반환

bool 함수의 인자가 숫자인 경우¶

In [30]:

bool(0)     # 인자: 숫자 0일 때만 False

Out[30]:

False

In [31]:

bool(1)     # 인자: 양의 정수이면 True

Out[31]:

True

In [32]:

bool(-10)   # 인자: 음의 정수이면 True

Out[32]:

True

In [33]:

bool(5.12)  # 인자: 양의 실수이면 True

Out[33]:

True

In [34]:

bool(-3.26) # 인자: 음의 실수이면 True

Out[34]:

True

bool 함수의 인자가 문자열인 경우¶

문자열이 있으면 True, 없으면 False
문자열이 빈 문자열인지 알고 싶을 때 사용

In [35]:

bool('a')    # 인자: 문자열 'a'    

Out[35]:

True

In [36]:

bool(' ')    # 인자: 공백(공백문자열이 있는 것임)  

Out[36]:

True

In [37]:

bool('')     # 인자: 빈문자열    

Out[37]:

False

In [38]:

bool(None)   # 인자: None     

Out[38]:

False

리스트, 튜플, 세트를 인자로 bool 함수 호출¶

항목이 있으면 Ture, 없으면 False
데이터에서 항목이 있는지 없는지 검사할 때 유용

In [39]:

myFriends = []     # 인자: 항목이 없는 빈 리스트 
bool(myFriends) 

Out[39]:

False

In [40]:

myFriends = ['James', 'Robert', 'Lisa', 'Mary']  # 인자: 항목이 있는 리스트
bool(myFriends)    

Out[40]:

True

In [41]:

myNum = ()        # 인자: 항목이 없는 빈 튜플
bool(myNum)  

Out[41]:

False

In [42]:

myNum = (1,2,3)   # 인자: 항목이 있는 튜플
bool(myNum)  

Out[42]:

True

In [43]:

mySetA = {}      # 인자: 항목이 없는 빈 세트
bool(mySetA) 

Out[43]:

False

In [44]:

mySetA = {10,20,30}   # 인자: 항목이 있는 세트
bool(mySetA) 

Out[44]:

True

bool 함수의 활용¶

In [45]:

def print_name(name):
    if bool(name):      # name인자에 문자열이 있으면 
        print("입력된 이름:", name)    # 이름을 출력
    else:
        print("입력된 이름이 없습니다.")    # 없으면 입력된 문자열이 없다고 출력

In [46]:

print_name("James")    # 문자열이 있는 경우

입력된 이름: James

In [47]:

print_name("")         # 문자열이 없는 경우

입력된 이름이 없습니다.

4.3 min, max¶

In [48]:

myNum = [10, 5, 12, 0, 3.5, 99.5, 42]  # 숫자 리스트에서 최소, 최대 구하기
[min(myNum), max(myNum)]

Out[48]:

[0, 99.5]

In [49]:

myStr = 'zxyabc'                       # 문자열 리스트에서도 최소, 최대 구할 수 있음
[min(myStr), max(myStr)]

Out[49]:

['a', 'z']

In [50]:

myNum = (10, 5, 12, 0, 3.5, 99.5, 42)  # 튜플에서 최소, 최대 구하기
[min(myNum), max(myNum)]

Out[50]:

[0, 99.5]

In [51]:

myNum = {"Abc", "abc", "bcd", "efg"}   # 세트에서 최소, 최대 구하기
[min(myNum), max(myNum)]

Out[51]:

['Abc', 'efg']

4.4 abs, sum¶

In [52]:

[abs(10), abs(-10)]      # 절댓값

Out[52]:

[10, 10]

In [53]:

sumList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]      # 리스트, 튜플, 세트 데이터의 모든 항목을 더해 전체 합을 출력
sum(sumList)

Out[53]:

4.5 len¶

In [54]:

len("ab cd")    # 문자열은 공백을 포함한 문자 길이(개수)

Out[54]:

In [55]:

len([1, 2, 3, 4, 5, 6, 7, 8])     # 리스트는 항목의 길이(개수)

Out[55]:

In [56]:

len((1, 2, 3, 4, 5))              # 튜플은 항목의 길이(개수)

Out[56]:

In [57]:

len({'a', 'b', 'c', 'd'})         # 세트

Out[57]:

In [58]:

len({1:"Thomas", 2:"Edward", 3:"Henry"})    # 딕셔너리는 항목의 길이(개수)

Out[58]:

5. 내장 함수의 활용¶

In [59]:

scores = [90, 80, 95, 85] # 과목별 시험 점수

score_sum = 0                      # 총점 계산을 위한 초깃값 설정
subject_num = 0                    # 과목수 계산을 위한 초깃값 설정
for score in scores:
    score_sum = score_sum + score  # 과목별 점수 모두 더하기
    subject_num = subject_num + 1  # 과목수 계산
    
average = score_sum / subject_num  # 평균(총점 / 과목수) 구하기

print("총점:{0}, 평균:{1}".format(score_sum,average))

총점:350, 평균:87.5

In [60]:

scores = [90, 80, 95, 85]  # 과목별 시험 점수

print("총점:{0}, 평균:{1}".format(sum(scores), sum(scores)/len(scores)))

총점:350, 평균:87.5

In [61]:

print("최하 점수:{0}, 최고 점수:{1}".format(min(scores), max(scores)))

최하 점수:80, 최고 점수:95