Higher의 창작소

input

# 파이썬 사용자 입력
# Input 사용법
# 기본 타입(str)

##input사용법

사용자 입력
형 변환 입력
입출력 실습

# 예제1

name = input("Enter Your Name : ") #Enter Your Name : Goodboy
grade = input("Enter Your Grade : ") #Enter Your Grade : 4
company = input("Enter Your Company name : ") #Enter Your Company name : Samsung

#맥은 터미널, 윈도우는 명령 프롬프트에서 실행


print(name, grade, company) #Goodboy 4 Samsung

#맥은 터미널, 윈도우는 명령 프롬프트에서 실행

# 예제2

number = input("Enter number : ") #Enter number : 5(여기서 5는 숫자형이 아니라 문자형이다.)
name = input("Enter name : ") #Enter name : kim

print("type of number", type(number), number * 3) #type of number <class 'str'> 555
print("type of name", type(name)) #type of name <class 'str'>

# 예제3(계산)

first_number = int(input("Enter number1 : ")) #Enter number1 : 100 (int형으로 형 변환)
second_number = int(input("Enter number2 : ")) #Enter number2 : 200

total = first_number + second_number
print("first_number + second_number : ", total)#first_number + second_number : 300

# 예제4

float_number = float(input("Enter a float number : ")) #Enter a float number : 3.14

print("input float : ", float_number) #input float : 3.14
print("input type : ", type(float_number)) #input type : <class 'float'>

# 예제5

print("FirstName - {0}, LastName - {1}".format(input("Enter first name : "), input("Enter second name : ")))

#Enter first name : Kim
#Enter second name : niceman
#FirstName - Kim, LastName - niceman

함수

# 파이썬 함수
# 파이썬 함수식 및 람다(lambda)

함수 사용법

함수 선언 및 사용
다양한 리턴 사용
중첩함수
함수 hint
기타 사용법
람다(Lambda)개념


# 함수 정의 방법
# def function_name(parameter):
#     code

# 예제1
def first_func(w1):   #w1 매개변수(parameter)
    print("Hello, ", w1) #Hello,  Goodboy

word = "Goodboy"

first_func(word) #word 인자(argument)

# 예제2(return)
def return_func(w1):
    value = "Hello, " + str(w1)
    return value

x = return_func('Goodboy2')
#return이 있는 함수는 이 함수에서 넘어오는 결과값으로 반환되는 값을 받을 변수를 선언한 것이다.

print(x) #Hello, Goodboy2

# 예제3(다중반환)

def func_mul(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return y1, y2, y3

x, y, z = func_mul(10) #언팩킹

print(x, y ,z) #100 200 300

# 튜플 리턴

def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return (y1, y2, y3) #팩킹

q = func_mul2(20)

print(type(q), q, list(q)) #<class 'tuple'> (200, 400, 600) [200, 400, 600]

# 리스트 리턴

def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return [y1, y2, y3]


p = func_mul2(30)

print(type(p), p, set(q)) #<class 'list'> [300, 600, 900] {200, 600, 400}

# 딕셔너리 리턴

def func_mul3(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return {'v1': y1, 'v2': y2, 'v3': y3}


d = func_mul3(30)
print(type(d), d, d.get('v2'), d.items(), d.keys())

#<class 'dict'> {'v1': 300, 'v2': 600, 'v3': 900} 600 dict_items([('v1', 300), ('v2', 600), ('v3', 900)]) dict_keys(['v1', 'v2', 'v3'])

# 중요
# *args, **kwargs

# *args(언팩킹)튜플 자료형 언팩킹

def args_func(*args): # 매개변수 명 자유 꼭 args라고 할 필요없다.
    for i, v in enumerate(args):  #i는 인덱스/ v는 실제 값
        print('Result : {}'.format(i), v)
    print('-----')
#어떤 자료 묶음이 오더라도 풀어서 사용하는 것.
#튜플 형태가 넘어올 때 많이 사용한다.

args_func('Lee')

Result : 0 Lee
-----

# 매개변수가 args면 하나의 문자형으로 인식한다.
#Result : 0 L
#Result : 1 e
#Result : 2 e
#*가 있으면 튜플 형태의 0번 index로 인식한다.

args_func('Lee', 'Park')

Result : 0 Lee
Result : 1 Park
-----

args_func('Lee', 'Park', 'Kim')

Result : 0 Lee
Result : 1 Park
Result : 2 Kim
-----
#즉, 이것들을 하나의 튜플로 간주했다는 것을 알 수 있다.



# **kwargs(언팩킹) 딕셔너리 자료형 언팩킹

def kwargs_func(**kwargs): # 매개변수 명 자유
    for v in kwargs.keys():
        print("{}".format(v), kwargs[v])
    print('-----')

kwargs_func(name1='Lee')

name1 Lee
-----

kwargs_func(name1='Lee', name2='Park')

name1 Lee
name2 Park
-----

kwargs_func(name1='Lee', name2='Park', name3='Cho')

name1 Lee
name2 Park
name3 Cho
-----



# 전체 혼합
def example(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)

example(10, 20, 'Lee', 'Kim', 'Park', 'Cho', age1=20, age2=30, age3=40)

#10 20 ('Lee', 'Kim', 'Park', 'Cho') {'age1': 20, 'age2': 30, 'age3': 40}

# 중첩함수

def nested_func(num):
    def func_in_func(num):
        print(num)
    print("In func")
    func_in_func(num + 100)

nested_func(100)

#In func
#200



func_in_func(1000)

#'func_in_func'is not defined라고 오류가 나온다.
#이 함수가 정의되는 시점은 메모리에 올라와서 우리가 사용할 수 있게 되는 시점은
#nested_func함수가 호출되고 func_in_func가 실행될 때이다.
#부모함수를 호출하지 않고는 중첩되어있는 자식 함수는 정의되지 않는다.

# 람다식 예제
# 메모리 절약, 가독성 향상, 코드 간결
# 일반적인 함수는 객체 생성 -> 리소스(메모리) 할당
# 람다는 즉시 실행 함수(Heap영역에 저장) -> 메모리 초기화
# 남발 시 가독성 오히려 감소

#일반적인 함수식
#def mul_func(x, y):
#    return x * y

#lambda식 x, y:x*y

# 일반적함수 -> 할당
def mul_func(x, y):
    return x * y

print(mul_func(10, 50)) #500

mul_func_var = mul_func
print(mul_func_var(20,50)) #1000

# 람다 함수 -> 할당
lambda_mul_func = lambda x,y:x*y   #익명함수이기 때문에 변수에 담는다.
print(lambda_mul_func(50,50)) #2500

def func_final(x, y, func):
    print('>>>>', x * y * func(100, 100))

func_final(10, 20, lambda x,y:x*y) #>>>> 2000000
func_final(10, 20, lambda_mul_func) #>>>> 2000000
func_final(10, 20, mul_func_var) #>>>> 2000000

# Hint

def tot_length1(word: str, num: int) -> int:
    return len(word) * num


print('hint exam1 : ', tot_length1("i love you", 10)) #hint exam1 :  100


def tot_length2(word: str, num: int) -> None:
    print('hint exam2 : ', len(word) * num) #hint exam2 :  70


tot_length2("niceman", 10)

반복문- while문

# 파이썬 반복문
# While 실습

While 흐름 제어 실습

while 기본 사용법
Break,continue
while-Else 구문
무한 반복 구문
기본 패턴 실습



# while <expr>:          expr은 <expression>표현
#    <statement(s)>     statement(s)는 <code>
#조건을 만족할 동안 계속 반복하고 만족하지 않을 때 While문을 빠져나간다.

# 예제1
n = 5
while n > 0:
    print(n)
    n = n - 1 #이게 없으면 무한히 반복한다.

5
4
3
2
1
    

# 예제2
a = ['foo', 'bar', 'baz']

while a:          #0개가 되면 a가 false가 된다.
    print(a.pop())
    
baz
bar
foo

# if 중첩
# break , continue

# 예제3

n = 5
while n > 0:
    n -= 1 #n = n - 1
    if n == 2:
        break
    print(n)
print('Loop Ended.')

4
3
Loop Ended.



# 예제4
m = 5
while m > 0:
    m -= 1
    if m == 2:
        continue
    print(m)
print('Loop Ended.')

4
3
1
0
Loop Ended.



# 예제5
i = 1

while i <= 10:
    print('i:',i)
    if i == 6:
        break
    i += 1
    
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6

# While - else 구문

# 예제6
n = 10
while n > 0: #else구문은 실행되지 않음.
    n -= 1
    print(n)
    if n == 5:
        break
else:
    print('else out.')
    
9
8
7
6
5



n2 = 10
while n2 > 0:
    n2 -= 1
    print(n2)
else:
    print('else out.')
    
9
8
7
6
5
4
3
2
1
0
else out.

#for문과 마찬가지로 정상적으로 모든 반복을 수행한다면 마지막에 else문을 딱 한번 실행하고 끝난다.
#else구문에 for문이나 while문에서 처리하고 마지막에 한 번 실행되야 하는 코드를 넣어주면
#깔끔하게 프로세스에 맞는 코딩을 흐름을 제어할 수 있다.




# 예제7
a = ['foo', 'bar', 'baz', 'qux']
s = 'qux'

i = 0

while i < len(a): # i < 4 len길이
    if a[i] == s:
        break
    i += 1
else:
    print(s, 'not found in list.')
    
#출력값 없음

#찾았기 때문에 else구문이 실행되지 않음
#만약에 s = 'kim'이라고 하면 kim not found in list라고 나온다.

# 무한반복
# while True:
#     print('Foo')

# 예제8
a = ['foo', 'bar', 'baz']
while True:   #break문이 없으면 영원히 실행됨
    if not a: #a가 False가 되면 not이 있어서 True가 되니까 빠져나온다.
        break
    print(a.pop())
    
baz
bar
foo

반복문- for문

# 파이썬 반복문
# FOR 실습

For 흐름제어 실습

반복문 중요성
기본For사용
For문 패턴 실습
For-Else 구문


# 코딩의 핵심
# for i in <collection> collection형태는 어떤 집합의 모음이라고 생각하자 ex)리스트 튜플 딕셔너리
#     <loop body>

for v1 in range(10): # range(stop)
    print("v1 is :", v1)
    
v1 is : 0
v1 is : 1
v1 is : 2
v1 is : 3
v1 is : 4
v1 is : 5
v1 is : 6
v1 is : 7
v1 is : 8
v1 is : 9



for v2 in range(1, 11): # range(start,stop)
    print("v2 is :", v2) #
    
v2 is : 1
v2 is : 2
v2 is : 3
v2 is : 4
v2 is : 5
v2 is : 6
v2 is : 7
v2 is : 8
v2 is : 9
v2 is : 10



for v3 in range(1, 11, 2): #range(start,stop,step)
    print("v3 is :", v3) #

v3 is : 1
v3 is : 3
v3 is : 5
v3 is : 7
v3 is : 9

# 1 ~ 1000합

sum1 = 0

for v in range(1, 1001):
    sum1 += v  #sum1 = sum1 + v

print('1 ~ 1000 Sum : ', sum1) #1 ~ 1000 Sum :  500500

print('1 ~ 1000 Sum : ', sum1) #1 ~ 1000 Sum :  500500

print('1 ~ 1000 Sum : ', sum(range(1, 1001))) #1 ~ 1000 Sum :  500500

#sum(iterable) sum함수 안에서는 iterable한 자료형을 받는다.
#range라는 함수도 iterable한 값을 return한다.
#<class 'range'>다.

print('1 ~ 1000 안에 4의 배수의 합 : ', sum(range(1, 1001, 4)))
#1 ~ 1000 안에 4의 배수의 합 :  124750

# Iterables(반복할 수 있는 객체) 자료형 반복
# 문자열, 리스트, 튜플, 집합, 사전(딕셔너리)
# iterable 리턴 함수 : range, reversed, enumerate, filter, map, zip

# 예제1(리스트안에 문자열)
names = ["Kim", "Park", "Cho", "Lee", "Choi", "Yoo"]

for name in names:
    print("You are", name)
    
You are Kim
You are Park
You are Cho
You are Lee
You are Choi
You are Yoo


# 예제2(리스트안에 숫자int형)
lotto_numbers = [11, 19, 21, 28, 36, 37]

for number in lotto_numbers:
    print("Current number : ", number)

Current number :  11
Current number :  19
Current number :  21
Current number :  28
Current number :  36
Current number :  37


# 예제3(문자열)
word = 'Beautiful'

for s in word:
    print('word : ', s)
    
word :  B
word :  e
word :  a
word :  u
word :  t
word :  i
word :  f
word :  u
word :  l



# 예제4(딕셔너리)
my_info = {
    "name": "Lee",
    "Age": 33,
    "City": "Seoul"
}

for key in my_info:
    print("key, :", my_info[key]) #my_info.get(key) get메소드에 key를 넣어도 된다.
    
key, : Lee
key, : 33
key, : Seoul

for val in my_info.values():
    print(val)
    
Lee
33
Seoul


# 예제5(if문과 for문 같이쓰기)
name = 'FineApplE'

for n in name:
    if n.isupper(): #대문자인지 검사
        print(n)
    else:
        print(n.upper()) #대문자가 아니라면 대문자로 변환
 
F
I
N
E
A
P
P
L
E

# break(순차 검색중 원하는 값을 찾으면 for문 탈출)

numbers = [14, 3, 4, 7, 10, 24, 17, 2, 33, 15, 34, 36, 38]


for num in numbers:
    if num == 34:
        print("Found : 34!")
        break
    else:
        print("Not found : ", num)
#34를 찾고 탈출했으므로 Not found :  36, Not found :  38 출력이 되질않는다.

Not found :  14
Not found :  3
Not found :  4
Not found :  7
Not found :  10
Not found :  24
Not found :  17
Not found :  2
Not found :  33
Not found :  15
Found : 34!

# continue(어떤 조건 안에서 continue를 만나면 다시 조건을 검사하는 부분으로 이동한다.)

lt = ["1", 2, 5, True, 4.3, complex(4)]

for v in lt:
    if type(v) is bool:  #자료형을 대조할 떄는 is를 쓴다.
        continue

    print("current type : ", type(v))
    print("multiply by 3:", v * 3)
    
#많은 데이터 중에 보기 싫거나 불필요하게 출력되거나 계산되지 않아야 될 값들이 있을 때
#continue를 써서 패스시킬 수 가 있다.
#print(True*3)은 True는 1로 볼 수 있어서 3이 나온다.

current type :  <class 'str'>
multiply by 3: 111
current type :  <class 'int'>
multiply by 3: 6
current type :  <class 'int'>
multiply by 3: 15
current type :  <class 'float'>
multiply by 3: 12.899999999999999
current type :  <class 'complex'>
multiply by 3: (12+0j)

# for else 구문

numbers = [14, 3, 4, 7, 10, 24, 17, 2, 33, 15, 34, 36, 38]

for num in numbers:  #34가 있기 때문에 break를 만나고 탈출한다.
    if num == 34:
        print("Found : 34!")  #Found : 34!
        break
else:
    print("Not Found 34...")



for num in numbers:  #자료에서 45가 없으므로 else구문이 실행된다.
    if num == 45:
        print("Found : 45!")
        break
else:
    print("Not Found 45...")  #Not Found 45...

# 구구단 출력

for i in range(2, 10):   #2일 때 1~9, 3일 때 1~9....9일 때 1~9
    for j in range(1, 10):
        print('{:4d}'.format(i * j), end='') #{:4d} 4자리의 정수형으로 출력
    print() #줄바꿈
    
   2   4   6   8  10  12  14  16  18
   3   6   9  12  15  18  21  24  27
   4   8  12  16  20  24  28  32  36
   5  10  15  20  25  30  35  40  45
   6  12  18  24  30  36  42  48  54
   7  14  21  28  35  42  49  56  63
   8  16  24  32  40  48  56  64  72
   9  18  27  36  45  54  63  72  81

# 변환 예제

name = 'Aceman'

print('Reversed : ', reversed(name)) #Reversed :  <reversed object at 0x00000219A8C49EE0>
#reversed함수를 호출하니까 reversed object형이 나오고 주소값(identity)이 나온다.
#형 변환을 해야 제대로 된 값이 나온다.

print('List : ', list(reversed(name))) #List :  ['n', 'a', 'm', 'e', 'c', 'A']
print('Tuple : ', tuple(reversed(name))) #Tuple :  ('n', 'a', 'm', 'e', 'c', 'A')
print('Set : ', set(reversed(name)))  #Set :  {'e', 'a', 'c', 'm', 'A', 'n'} 순서X