반복문, 함수,람다

python built-in data type

# Numeric
  # int(정수)
  # float(실수)
  # complex(복소수)
# Sequence
  # list
  # tuple
  # range
# Text Sequence
  # str
# Mapping
  # dict
# Set
  # set
# Bool
  # True, False

 

# python control statement
# if, for, while

# 논리식 => 3 > 5 => False
a = 100

if a > 5:
    print('aa')
    print('bb')
elif a > 2:
    print('haha')
else:
    print('cc')
    print('dd')

# for문은 크게 2가지 형태로 사용이 되요!

# for ~ in range
# for ~ in list, tuple, dict

mySum = 0
for aaa in range(100):
    mySum += aaa
print('결과 : {}'.format(mySum))

# a = [1, 2, 3, 4]
a = { 'name' : '홍길동', '주소' : '서울', '나이' : 30 }

for aaa in a:
    print('key : {}, value : {}'.format(aaa,a[aaa]))
    
# list comprehension

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 위의 리스트에서 각각의 요소에 x2를 해서 새로운 list를 만들어 보아요!
result = list()
for a in myList:
    result.append(a*2)
    
print(result)    # [2, 4, 6, 8, 10, 12, 14, 16, 18]

myList_1 = [tmp * 2 for tmp in myList]
print(myList_1)  # [2, 4, 6, 8, 10, 12, 14, 16, 18]

# 위의 리스트에서 요소의 값이 짝수인것을 찾아서 해당 요소에 x2를 해서 
# 새로운 list를 만들어 보아요!
myList_2 = [tmp * 2 for tmp in myList if tmp % 2 == 0]
print(myList_2)

 

 

# 반복문의 또 다른 방법
# while

idx = 0


while idx < 10:
    print('haha')
    idx += 1
    if idx > 5:
        break   # break : 가장 인접한 루프를 탈출하는 keyword
        
for tmp in range(10):
    pass

 

 

# 함수(function) , 객체지향(Object Oriented)
# 함수 
# 특정 역할을 수행하는 코드 집합을 하나의 단위로 묶어놓은것

a = [3,7,2,6,10,0]
a.sort()  # 함수를 사용하기 위해서 호출(call)
          # 함수를 호출하면 원본이 변하는 경우가 있어요!
          # 함수를 호출하면 원본은 변화하지 않고 함수가 적용된 결과가 만들어져요(리턴)
          # 결과가 리턴되요!
print(a)

a = [1, 2, 3]
result = a.append(4)  # 인자를 넘겨줘요(함수에 전달해요)
print(result)  # None
print(a)

####

# 과거에는 함수기반의 언어가 많았어요. 대표적으로 C 언어
# 내가 구현해야 하는 내용을 기능으로 세분화
# 은행프로그램을 만들어요!
#  - 예금기능
#    - 무통장입금
#    - 자행이체
#      - 일반 이체  -> 함수형태로 코드 구현
#      - 예약 이체
#    - 타행이체
#  - 대출기능
#  - 보험기능
#  - 외환기능

# 구조적 프로그래밍, 절차지향 프로그래밍, Top down방식 프로그래밍
# divide and Conquer

# 장점 : 분석과 설계가 비교적 간단
#        => 프로그램 작성기간이 짧아져요
#        => 인력과 돈이 작게 들어요!
# 단점 : 프로그램의 유지보수가 힘들어요!
#       프로그램의 유지보수가 많이 필요한 세상이 되었어요!    

# 객체지향으로 넘어가게 되요!

 

 

# python의 함수적 특징

# python의 함수는 크게 2가지 분류가 있어요!
# 내장함수( len() )
# 사용자 정의 함수(User define function)

# 내장함수
# a = 'Hello'
# print(len(a))

# 사용자 정의 함수
# 함수를 정의할 때 사용하는 keyword : def
# 함수이름(함수명)을 지어야 해요 -> 가독성이 있어야 해요. 숫자로 시작하면 안되요!
#                                 대문자로 시작하지 않습니다. 한글안되요!
#                                 name_search
#   

def my_sum(*a):    # *는 tuple형태로 입력데이터를 받아요!
    print('입력받은 값은 {} 입니다.'.format(a))
    result = 0
    for tmp in a:
        result += tmp
    return result

my_result = my_sum(10,20,30,40)
print(my_result)

 

id 주소에 관하여

# 자바 파이썬은 메모리값을 건들수 없으나
# c, c++은 메모리값을 건드릴수 있다
# 그러므로 하드웨어적인 작업은 c언어가 적합하다(ex) 게임 핵)

# a = 100
# print(a)  # 100
# # a라는 변수가 가지고 있는 주소값을 찍고 싶어요!
# print(id(a))   # 140703410269696(100이라는 정수값이 저장된 메모리 주소값)

# a = [1, 2, 3]  # 1783259816392 
# print(id(a))
# b = [1, 2, 3]  
# print(id(b))   # 1783259120200

# print( a == b )  # True   == 내용이 같니?
# print( a is b )  # False  is   주소가 같니?

# a = 50
# b = 50

# print (a is b) # True
# # 숫자는 워낙 많이 사용되서 256까지는 객체를 1개만 만들어서 공유

# a = 256
# b = 256
# print (a is b) # True
#숫자 주소값은 256까지는 공유

# a = 257
# b = 257
# print (a is b) # False

#만든변수() = 만든변수야 (주소값에 있는걸) 실행해 라는 의미

def my_sum(a,b):
    print("안녕하세요")
    result = a + b
    return result

def my_test(hoho):
    hoho(10,20)
    
my_test(my_sum)    

# 일급함수 - 함수를 인자로 넘길수 있다
# 는 자바스크립트, 파이썬 가능, 자바,c는 불가능

 

return값에 대한 오해

# python의 함수는 return값을 여러개 사용할 수 있어요! (X)
# return값은 1개이나 여러개로 오해 (튜플을 리턴)

def my_program(a,b):
    result1 = a + b
    result2 = a * b
    return result1, result2

a,b = my_program(10,20)

 

default parameter

# python의 함수는  default parameter를 사용할 수 있어요!
#인자를 받는것을 paramater라고 한다
#default parameter는 끝에서만 사용 가능

def my_sum(a,b,c=True):
    if c:
        print(a+b)
    else:
        print(a*b)

# my_sum(10,20,True)  
my_sum(10,20)    # default parameter가 있는 경우 맨 마지막 입력인자를 
                 # 생략할 수 있어요!

 

 

입력 인자에 대한 가변과 불변

# python 함수는 입력인자에 대해 mutable(가변의), immutable(불변의)
# call-by-value, call-by-reference(전공자는 이렇게 이해)
# 숫자, 문자열, tuple => immutable
# list => mutable

# stack = 함수를 위한 임시저장공간, 
#            함수가 종료되면 해당 함수의 활용된 영영 삭제
#            그러므로 def 생성시 함수 생성하여도 stack에서 삭제되므로
#            return이 불과
# 메모리 위치를 스택에 넣느냐 그 값 자체를 넣느냐에 따라
# 머터블 이머터블이 나뉜다


def my_func(tmp_number, tmp_list):
    tmp_number += 10
    tmp_list.append(100)

data_x = 10
data_list = [1,2,3]

print('현재 data_x : {}, data_list : {}'.format(data_x, data_list))
my_func(data_x, data_list)
print('현재 data_x : {}, data_list : {}'.format(data_x, data_list))

 

 

지역변수와 전역변수

# local variable          vs.    global variable
# (지역변수)(stack안)            (전역변수)(stack밖) *코딩이 꼬일수 있으므로 필요한 상황아님 사용x



def my_func(x):
    tmp = 100    
    tmp += x
    return tmp

print(my_func(100))
print(tmp)

*함수 내부에서 사용한 변수는 밖에서 사용 불가라 return을 해주어야 한다

 

# python의 내장함수

# type()
# id()
# print()
# len()

a = 3.141592
print(int(a))
print(str(a))
# float()
# list()
# tuple()
# set()
# dict()

a = 'this is a sample text'
my_list = a.split()
print(my_list)   # ['this', 'is', 'a', 'sample', 'text']

for (idx,tmp) in enumerate(my_list):
    print((idx, tmp)) # 0 this
    
    
my_list = [3,6,8,1,2,7]
# my_list.sort()
# print(my_list)  # [1, 2, 3, 6, 7, 8]
print(sorted(my_list))  # [1, 2, 3, 6, 7, 8]

 

def 함수(*args아규먼트): 시 (여러개)사용가능
**kyargs 키워드 아규먼트

lamda = 함수 축약모드, 이름없이도 리스트안에서 간단히 사용가능
my list = [lamda a, b: a+b, lamda a, b: a * b]
print(my list[0(1,2)]) = 3

 

람다식: 함수의 형태를 더울 짧게 쓸 수 있도록 해주는 문법
add = lamda x, y : x + y
print(add(1, 2)) == 3

map() : 다수의 원소에 대한 함수의 결과를 한 번에 얻을 수 있도록 도와줌

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]
a = lamda a, b: a + b
result = map(a, list1, list2)
print(list(result))

함수 호출할때 넘기는 값을 인수, 인자 (arg)
def f(x):     <ㅡㅡ 5
인수를 받고 저장 하는값을 매개변수(parameter)

def f(parameter):