DEVELOPPO

pip install flask_cors

​

--------------------------------------------------------

​

import flask_cors CORS, cross_origin

​

CORS(app) # 모든 요청

​

--------------------------------------------------------

​

CORS(app, resources={r'*': {'origins': '*'}}) #모든 곳에서 호출하는 것을 허용

​

CORS(app, resources={r'*': {'origins': 'http://www.test.com'}}) # http://www.test.com 에서의 호출만 허용

​

CORS(app, resources={r'/_api/*': {'origins': 'http://www.test.com:5000'}}) # http://www.test.com:5000 에서의 호출만 허용

from urllib import request
from bs4 import BeautifulSoup as bs
import re
 
url = 'https://search.musinsa.com/ranking/brand'
 
target = request.urlopen(url)
soup = bs(target, 'html.parser')
 
brand = soup.select('.brandLogo img')
brandname = []
 
print('----------------------------------------------------')
 
for alt in brand[:5] :
    #print(alt.get('alt'))
    brandname.append(alt.get('alt'))
 
 
print(brandname)
print('----------------------------------------------------')
 
import json
jsonString = json.dumps(brandname, ensure_ascii=False)
 
print(jsonString)
 
 
from flask import Flask
 
# 웹서버 생성
app = Flask(__name__)
print(app)
print(__name__)
 
#url
@app.route('/brand')
def brandName():
    return jsonString
    
if __name__ == '__main__':
     app.run(debug=True, port=8000)

from urllib import request
from bs4 import BeautifulSoup as bs
import re
 
url = 'https://search.musinsa.com/ranking/brand'
 
target = request.urlopen(url)
soup = bs(target, 'html.parser')
 
brand = soup.select('.brandLogo img')
rankup = soup.select('.rank')
result_list = soup.find_all('span', class_="rank")
 
brandname = []
brandrank = []
brandrank_data = []
rank_data = []
 
for span in result_list[:10] :
    brandrank_data.append(span.text)
 
print(brandrank_data)
 
print('----------------------------시작------------------------')
 
for alt in brand[:10] :
    #print(alt.get('alt'))
    brandname.append(alt.get('alt'))
 
 
print(brandname)
print(brandname[0])
print('----------------------------------------------------')
 
 
for cla in rankup[:10] :
    brandrank.append(cla.get('class'))
 
print(brandrank)
print('----------------------------------------------------')
 
 
for i in range(10) :
    rank_data.append(
        {
            'name':brandname[i],
            'rank':brandrank_data[i]
        }
        
        )
 
print(rank_data)
print('----------------------------------------------------')
 
 
 
 
 
import json
jsonString = json.dumps(rank_data, ensure_ascii=False)
 
print(jsonString)
 
 
from flask import Flask
 
# 웹서버 생성
app = Flask(__name__)
#print(app)
#print(__name__)
 
 
from flask_cors import CORS
CORS(app) 
 
#url
@app.route('/brand')
def brandName():
    return jsonString
    
 if __name__ == '__main__':
     app.run(debug=True, port=8000)

없으면 cmd에서 pip install pymysql 해준다.

포트는 기본 3306

import pymysql
project_db = pymysql.connect(host='127.0.0.1', db='open', user='aia', password='aia')
 
cursor1=project_db.cursor()
 
sql_select = 'select * from member'
cursor1.execute(sql_select)
 
while True :
 
    row = cursor1.fetchone()
 
    if row==None :
        break;
    print(row)
 
project_db.close()

import sys
import io
 
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = 'utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = 'utf-8')
#한글깨짐 방지

를 위에 넣어주거나

환경변수에 인코딩 추가하는 방법

사용하는 윈도우 환경 변수에 "PYTHONIOENCODING=utf-8" 추가합니다.

환경변수를 추가하려면 "제어판 -> 시스템 -> 고급시스템설정 -> 고급탭 -> 환경변수"로 이동 하셔서

환경변수 창 아래쪽에 있는 시스템 변수 항목에서 "새로만들기" 버튼 을 클릭 하고 새 시스템 변수에서 아래의 그림과 같이 변수 이름과 변수 값을 적어 넣으시고 확인 버튼을 누르시면 

위의 그림과 같이 시스템 변수에 인코딩이 추가된 모습을 볼 수 있습니다. 여기서 "확인" 버튼을 누르면 끝!!!

출처: https://mrcoding.tistory.com/entry/아톰에서-파이썬-스크립트-실행시-한글-깨짐현상-잡는-꿀팁 [Mr. Coding]

=

from flask import Flask
 
 
# 웹서버 생성
app = Flask(__name__)
print(app)
print(__name__) #main
 
# url mapping
@app.route('/')
def index():
    return 'Hello, Python'
 
@app.route('/hello')
def hello():
    return '<h1> /hello 요청의 응답입니다 </h1>'
 
 
if __name__ == '__main__':
    app.run(debug=True, port=8000)

파이썬이 설치된 위치의 Script에 들어가서 cmd를 실행해준다.

그리고 pip install beatufulsoup4라고 치고 이렇게 나오면 설치완료!

아톰 사용하고 있고 그 뒤로는 이렇게 불러오기 가능!

쥬피터 노트북에는 깔려있고? VS CODE도 그냥 이렇게 쓰는 것 같다능~

근데 vscode는 터미널이 있어서 거기에서 하는듯..

설치 목록확인은 pip list

pip install flask

# Chapter09_02
# csv 파일 읽기 및 쓰기
 
# csv : meme - text/csv;
 
import csv
 
# 예제1
with open('./resource/test1.csv','r') as f :
    reader = csv.reader(f)
    next(reader) #header (첫줄) skip
 
    # 객체확인
    print(reader)
 
    # 타입확인
    print(type(reader))
 
    # 속성확인
    print(dir(reader))
    print()
 
    # 내용 출력
    for c in reader :
        #print(c)
        #print(type(c)) #list~~
        print(''.join(c))
 
 
# 예제2
with open('./resource/test2.csv','r') as f :
    reader = csv.reader(f,delimiter='|') # 구분자
 
    for c in reader:
        print(c)
        # 리스트안에 각각 두개 ['나라','약자']로 가져옴
 
# 예제3
with open('./resource/test1.csv','r') as f :
    reader = csv.DictReader(f)
 
    print(reader)
    print(type(reader))
    print(dir(reader))
 
    for c in reader:
        #print(c) #{'Name|Code': 'Zimbabwe|ZW'}
        for k,v in c.items():
            print(k,v)
        print('--------------------')
 
 
# 예제4
w = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18],[19,20,21]]
with open('./resource/write1.csv', 'w', encoding='utf-8') as f:
    print(dir(csv))
    wt=csv.writer(f)
 
    #dic확인
    #print(dir(wt))
 
    for v in w :
        wt.writerow(v) # 한줄씩 입력.row단위로.
 
# 예제5
with open('./resource/write2.csv', 'w', encoding='utf-8') as f:
    # 필드명
    fields = ['one', 'two','three']
 
    #DictWriter
 
    wt = csv.DictWriter(f, fieldnames=fields)
    #header Writer
    wt.writeheader()
 
    for v in w :
        wt.writerow({'one': v[0],'two':v[1],'three':v[2]})

# chapter09_01
# 파일 읽기 및 쓰기
 
# 읽기 모드 r 쓰기모드 w 추가모드 a 텍스트모드 t 바이너리모드 b
# 상대경로('../, ./') 절대 경로("C:\django\example..")
 
# 파일 읽기, 읽기 작업(read)
# 예제1)
import sys
import io
 
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = 'utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = 'utf-8')
#한글깨짐 방지
 
f = open('./resource/it_news.txt', 'r', encoding='UTF-8')
 
# 속성확인
print(dir(f))
# 인코딩 확인
print(f.encoding)
# 파일이름
print(f.name)
# 모드 학인
print(f.mode)
 
cts=f.read()
print(cts)
 
#반드시 clos
f.close()
 
 
print('--------------------------------------')
 
# 예제2
with open('./resource/it_news.txt', 'r', encoding='UTF-8') as f :
    c = f.read()
    print(c)
    print(iter(c))
    print(list(c))
    # with문에서는 알아서 close해준다.
 
print('--------------------------------------')
 
 
# 예제3
# read() : 전체 읽기, read(10) : 10byte만 읽어옴
with open('./resource/it_news.txt', 'r', encoding='UTF-8') as f :
    c = f.read(20)
    print(c)
    c = f.read(20)
    print(c) # 다음 20byte를 읽어봄. 내가 마지막에 어디까지 읽었는지 내부적으로 기억.
    c = f.read(20)
    print(c)
    f.seek(0,0) # 처음으로 from 0 to 0
    c = f.read(20)
    print(c)
print('--------------------------------------')
 
# 예제4
# readline : 한줄씩 읽기
with open('./resource/it_news.txt', 'r', encoding='UTF-8') as f :
    line = f.readline()
    print(line)
    line = f.readline()
    print(line) #반복문 안에서 읽어오는 것이 좋다.
print('--------------------------------------')
 
# 예제5
# readlines : 전체를 읽은 후 라인 단위 리스트로 저장
with open('./resource/it_news.txt', 'r', encoding='UTF-8') as f :
    cts = f.readlines()
    print(cts)
    print(cts[0])
 
    for c in cts :
        print(c, end='')
 
print('--------------------------------------')
 
 
# 파일쓰기 (write)
 
# 예제1
with open('./resource/contents1.txt', 'w') as f :
    f.write('I love Python\n')
 
# 예제2
with open('./resource/contents1.txt', 'a') as f :
    f.write('I love Python\n')       # w로하면 덮어쓰기 a 뒤에추가 (append)
 
# 예제3
# writelines : 리스트 > 파일로 한줄씩
with open('./resource/contents2.txt', 'w') as f :
    list=['orange\n', 'Apple\n', 'banana\n','melon\n']
    f.writelines(list)
 
# 예제4
with open('./resource/contents3.txt', 'w') as f :
    print('Test Text Write', file=f) #콘솔이 아니라, 파일로 출력

# chapter08_02
# 파이썬 외장 (External)함ㅅ
# 실제 프로그램 개발 중 자주 사용
# 종류 : sys. pickle, shutil, temfile, time, randome 등
 
# 예제1
import sys
print(sys.argv) #sys.argv라고 구글에 검색해보면 좋다.
 
 
# 예제2 (강제종료)
# sys.exit()
 
# 예제3 (파이선 패키지 위치)
print(sys.path)
 
 
#pickle : 객체 파일 읽기, 쓰기
import pickle
 
# 예제4(쓰기)
 
f = open("test.obj", 'wb')
obj = {1:'python',2:'study', 3:'basic'}
pickle.dump(obj,f)
f.close()
 
 
# 예제5(열기)
 
f = open('test.obj', 'rb')
data = pickle.load(f)
print(data, type(data))
f.close()
 
 
# os : 환경변수, 디렉토리(파일) 처리 관련, 운영체제 작업 관련
# mkdir, rmdir(비어있으면 삭제), rename,
 
# 예제6
import os
print(os.environ)
print(os.environ["USERNAME"])
print(os.environ["ATOM_HOME"])
 
# 예제7 (현재 경로)
print(os.getcwd())
 
 
# time : 시간 관련 처리.
import time
 
# 예제8
print(time.time())
 
# 예제9 형태변환
print(time.localtime(time.time()))
 
# 예제10 (간단 표현)
print(time.ctime())
 
# 예제11 (형식 표현)
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
 
# 예제12 (시간 간격 발생)
# for i in range(5) :
#     print(i)
#     time.sleep(1) #1초마다 실행하겠다는 뜻
 
# random : 난수 리턴
import random
 
# 예제13
print(random.random()) #0~1 실수
 
# 예제14
print(random.randint(1,45))
print(random.randrange(1,45))
 
# 예제15(섞기)
d=[1,2,3,4,5]
random.shuffle(d)
print(d)
 
# 예제16 (무작위 선택)
c = random.choice(d)
print(c)
 
# webbrowser : 본인 os의 웹 브라우저 실행
import webbrowser
 
webbrowser.open("http://naver.com")
webbrowser.open_new("http://naver.com")

docs.python.org/ko/3.9/library/functions.html

# Chapter08-1
# 파이썬 내장(Built-in) 함수
# 자주 사용하는 함수 위주로 실습
# 사용하다보면 자연스럽게 숙달
# str(), int(), tuple() 형변환 이미 학습
 
# 절대값
# abs()
 
print(abs(-3))
 
# all, any : iterable 요소 검사(참, 거짓)
print(all([1,2,3])) # and
print(any([1,2,0])) # or
 
# chr : 아스키 -> 문자 , ord : 문자 -> 아스키
 
print(chr(67))
print(ord('C'))
 
# enumerate : 인덱스 + Iterable 객체 생성
for i, name in enumerate(['abc', 'bcd', 'efg']):
    print(i, name)
 
 
#  filter : 반복가능한 객체 요소를 지정한 함수 조건에 맞는 값 추출
 
def conv_pos(x):
    return abs(x) > 2
    
print(list(filter(conv_pos, [1, -3, 2, 0, -5, 6])))
print(list(filter(lambda x: abs(x) > 2, [1, -3, 2, 0, -5, 6])))
 
# id : 객체의 주소값(레퍼런스) 반환
 
print(id(int(5)))
print(id(4))
 
# len : 요소의 길이 반환
print(len('abcdefg'))
print(len([1,2,3,4,5,6,7]))
 
# max, min : 최대값, 최소값
 
print(max([1,2,3]))
print(max('python study'))
print(min([1,2,3]))
print(min('python study'))
 
# map : 반복가능한 객체 요소를 지정한 함수 실행 후 추출
def conv_abs(x):
    return abs(x)
    
print(list(map(conv_abs,[1,-3,2,0,-5,6])))
print(list(map(lambda x:abs(x),[1,-3,2,0,-5,6])))
 
# pow : 제곱값 반환
print(pow(2,10))
 
# range : 반복가능한 객체(Iterable) 반환
print(list(range(1,10,2))) # 1 3 5 7 9
print(list(range(0,-15,-1))) # 0 ~ -14
 
# round : 반올림
 
print(round(6.5781, 2))
print(round(5.6))
 
# sorted : 반복가능한 객체(Iterable) 정렬 후 반환 
 
print(sorted([6,7,4,3,1,2]))
a = sorted([6,7,4,3,1,2])
print(a)
print(sorted(['p','y','t','h','o','n']))
 
 
# sum : 반복가능한 객체(Iterable) 합 반환
print(sum([6,7,8,9,10]))
print(sum(range(1,101)))
 
# type : 자료형 확인
 
print(type(3))
print(type({}))
print(type(()))
print(type([]))
 
# zip : 반복가능한 객체(Iterable)의 요소를 묶어서 반환
 
print(list(zip([10,20,30],[40,50,777]))) #짝이 맞지 않으면 반환되지않음 3:2 면 2개만.
print(type(list(zip([10,20,30],[40,50,777]))[0]))

# chapter07-01
# 파이썬예외처리의 이해
# 예외종류
# syntax, type, name, index, value, key..error
# 문법적으로는 틀리지 않았지만, 코드실행 프로세스(단계) 발생하는 예외도 중요
 
# 1. 예외는 반드시 처리
# 2. 로그는 반드시 남긴다.
# 3. 예외는 던져진다.
# 4. 예외 무시.
 
 
# syntaxError / 문법 오류.
# print('error) / print('error'))
 
 
# nameError / 참조 없음
# a=10
# b=15
# pring(c)
 
# ZeroDivisionError
# print(100/0)
 
#IndexError
x=[50,70,90]
print(x[1])
# print(x[4])
 
 
# KeyError
dic={'name' :'Lee' , 'age' : 41, 'city':'busan'}
# print(dic['hobby'])
 
# 예외가 없는 것을 가정하고 프로그램을 작성 > 런타임 예외 발생 시 예외 처리 권장(EAFP)
 
 
# AttributeError : 모듈, 클래스에 있는 잘못된 속성 사용 예외
import time
# print(time.time2()) time2는 없다
 
 
# ValueError
 
x = [10,50,90]
x.remove(50)
print(x)
# x.remove(200)
 
# FileNotFoundError
# f = open('text.txt') 파일 없음 에러.
 
 
# TypeError : 자료형에 맞지 않는 연산 수행할 경우
x = [1,2]
y = (1,2)
z = 'test'
# print(x+y)
print(x+list(y))
 
 
# 예외처리 기본
# try : 에러가 발생할 가능성이 있는 코드 실행
# except 에러명1 : 여러개 가능
# except 에러명2 :
# else : try 블록의 에러가 없을 경우 실행
# finally : 항상 실행.
 
 
name = ['kim', 'lee', 'park']
 
# 예제1
 
try :
    z = 'kim' #'Cho' 예외처리가 된다.
    x = name.index(z)
    print('{} Found it {} in name'.format(z,x+1))
except   ValueError :
    print('not fount it = occurred ValueError!')
else :
    print('ok! else.')
 
print()
 
 
# 예제2
 
try :
    z = 'kim' #'Cho' 예외처리가 된다.
    x = name.index(z)
    print('{} Found it {} in name'.format(z,x+1))
except : # except Exception : 와 같다.
    print('not fount it = occurred')
else :
    print('ok! else.')
 
print()
 
 
# 예제3
 
try :
    z = 'cho' #'Cho' 예외처리가 된다.
    x = name.index(z)
    print('{} Found it {} in name'.format(z,x+1))
except Exception as e :
    print(e) #'cho' is not in list
    print('not fount it = occurred')
else :
    print('ok! else.')
finally :
    print('ok! finally!')
 
print()
 
 
# 예제4
# 에외 발생 : raise
# raise 키워드로 예외 직접 발생
 
try :
    a = 'park'
    if a == 'kim' :
        print('Ok! pass')
    else :
        raise ValueError #강제로 발생시키는에러.
except ValueError :
    print('Occurred! Exception!')
else :
    print('OK! else.')

__all__ = ['module1', 'py명', '파이썬파일이름!']
 
# __init__.py
# import 했을때 사용허락할 파일명만 적는다

# chapter06_03
# 패키지 작성 및 사용법
# 파이썬은 패키지로 분할 된 개별적인 모듈로 구성
# 상대경로 : ..(부모 디렉토리) .(현재 디렉토리) > 모듈 내부에서만 사용
 
#__pycache__ : 파이캐시 빠른실행을 위해 파이썬이 만듦 삭제가능 > 어차피 실행하면 또생김
 
#__init__.py : python3.3부터는 없어도 패키지로 인식
# 과거에는 init 파일이 없으면 import를 할 수 없었다.
# > 단 하위 호환을 위해 작성 추천,
 
 
# 예제1
 
import sub.sub1.module1 # 같은 경로일떄는 이렇게 가져오기도.
import sub.sub2.module2
 
# 사용
sub.sub1.module1.mod1_test1()
sub.sub1.module1.mod1_test2()
 
sub.sub2.module2.mod2_test1()
sub.sub2.module2.mod2_test2()
 
print()
print()
print()
 
# 예제2
from sub.sub1 import module1
from sub.sub2 import module2 as m2 #별칭 alias
 
module1.mod1_test1()
module1.mod1_test2()
 
m2.mod2_test1()
m2.mod2_test2()
 
print()
print()
print()
 
# 예제3
from sub.sub1 import *
from sub.sub2 import *
# 전체가져오기 > 하지만 필요한 것만 가져오는 것이 좋다.
 
module1.mod1_test1()
module1.mod1_test2()
 
module2.mod2_test1()
module2.mod2_test2()

# chapter06_02
# 파이썬 모듈
# Module : 함수, 변수, 클래스 등 파이썬 구성 요소 등을 모아놓은 파일.
 
def add(x,y):
    return x+y
 
def subtract(x,y):
    return x-y
 
def multiply(x,y):
    return x*y
 
def divide(x,y):
    return x / y
 
def power(x,y):
    return x ** y
 
 
 
 
# print('-' * 15)
# print('called! inner!')
# print(add(5,5))
# print(subtract(15,5))
# print(multiply(5,5))
# print(divide(10,2))
# print(power(5,3))
# print('-' * 15)
 
 
# __name__ 사용 > import할 땐 실행되지 않는다.
if __name__ == "__main__":
    print('-' * 15)
    print('called! inner!')
    print(add(5,5))
    print(subtract(15,5))
    print(multiply(5,5))
    print(divide(10,2))
    print(power(5,3))
    print('-' * 15)

# 모듈 사용 실습
 
import sys
import time
 
print(sys.path)
print(type(sys.path))
 
## 모듈 경로 삽입 (영구등록방법아님.)
# sys.path.append('D:/JAVA/inflearnPython/math')
#
# print(sys.path)
# import test_module (math안에 06_02를 테스트용으로 복사해서 만들었음)
#
# # 모듈 사용.
# print(test_module.power(10,3))
 
import Chapter06_02
print(Chapter06_02.add(10,1000000))

append 후 print(sys.path)

# Chapter06_01
# 클래스 (ㅋㅋ붕어빵기계)
# OOP(객체 지향 프로그래밍), self, 인스턴스 메소드, 인스턴스 변수
 
 
# 클래스와 and  인스턴스의 차이를 이해하는 것이 중요
# 네임스페이스 : 객체를 인스턴스화 할 때 저장된 공간
# 클래스 변수 : 직접 접근 가능, 공유 (정수기! 공용화장실! 같은 것 ㅋㅋ)
# 인스턴스 변수 : 객체마다 별도 존재.
 
# 예제1)
# class dog():, class dog:, class(object):
class dog(): #object 상속
    # 클래스 속성
    specied = 'firstdog' #클래스 변수.
 
    # 초기화/인스턴스 속성 (java생성자)
    def __init__(self,name, age):
        self.name = name
        self.age = age
 
 
# 클래스 정보
print(dog)
 
# 인스턴스화 (- 코드로 구현해서 메모리에 올라간 시점.)
a = dog('happy',15)
b = dog('micky',2)
c = dog('micky',2)
# 비교
print(a == b, id(a), id(b))
print(a == c, id(b), id(c))
 
# 네임스페이스
print('dog1',a.__dict__)
print('dog2',b.__dict__)
 
# 인스턴스 속성 확인
print('{} is {} and {} is {}'.format(a.name, a.age, b.name, b.age))
 
if a.specied == 'firstdog':
    print('{0} is a {1}'.format(a.name, a.specied))
 
print(dog.specied) # 클래스에서도
print(a.specied) # 인스턴스변수에서도 바로 접근 공유 가능하다. (같은값.)
 
 
# 예제2) - self의 이해. (this같은 느낌인듯)
 
class SelfTest:
    def func1():
        print('func1 called')
    def func2(self): #__init__이 없어도 알아서 생성해주는 똑쟁이 파이썬..
        print(id(self)) #f값.
        print('func2 called')
 
f = SelfTest()
 
print(dir(f)) #func1과 func2가 있음을 확인 가능
print(id(f))
 
# f.func1() 에러! 예외.
f.func2() # self가 있는 인스턴스 메서드
SelfTest.func1() # 클래스로바로 접근해서 접근. (매개변수가 없는 클래스메소드)
                # self가 있으면 인스턴스화 시킨 변수가 self로 넘어감.
# SelfTest.func2() 반대로 에러! 예외
SelfTest.func2(f)
 
 
# 예제3)
# 클래스 변수, 인스턴스 변수
 
class Warehouse:
    #클래스 변수
    stock_num = 0 #재고
 
    def __init__(self, name):
        # 인스턴스 변수
        self.name=name
        Warehouse.stock_num +=1
 
    def __del__(self):
        Warehouse.stock_num -=1
 
user1 = Warehouse('Lee')
user2 = Warehouse('Jin')
 
print(Warehouse.stock_num) # 붕어빵 몇개구웠어! = 2개
 
print(user1.name)
print(user2.name)
print(user1.__dict__)
print(user2.__dict__)
print('before>>',Warehouse.__dict__) #stock_num:2
 
del user1
print('after>>',Warehouse.__dict__)
 
# 예제4
 
class dog2():
    specied = 'firstdog'
 
    def __init__(self,name, age):
        self.name = name
        self.age = age
 
    def info(self):
        return '{} is {} years old'.format(self.name, self.age)
 
    def speak(self, sound):
        return "{} says {}!".format(self.name, sound)
 
# 인스턴스 생성
d = dog2('july',4)
e = dog2('merry',10)
 
# 메서드 호출
print(d.info())
print(e.info())
print(d.speak('wal wal'))
print(e.speak('mung mung'))

# chapter05_02
# 파이선 사용자 입력
# Input 사용법
# 기본 타입(Str)
 
# 예제1
 
name = input("Enter Your Name : ")
grade = input("Enter Your Grade : ")
company = input("Enter Your Company : ")
 
print(name, grade, company)
 
# 예제2
 
number = input("enter number :")
name = input("enter name : ")
print("type : ", type(number), type(name)) #둘다 str로받는다.
 
# 예제3 (계산)
first_number = int(input("number 1 : "))
second_number = int(input("number 2 : "))
 
print("두수의 합 : " , first_number+second_number)
 
# 예제4
float_num = float(input("enter float number : "))
print("num : " float_num)
print("type : " type(float_num))
 
# 예제5
print("FirstName - {0}, LastName - {1}"
.format(input("enter first name : "),input("enter second name : ")))

# Chapter05_01
# 파이썬 함수(Function)
# 파이썬 함수식 및 람다
 
# 함수 정의방법
# def function_name(parameter):
#   code
 
# 예제1)
def first_func(w):
    print("Hello,", w)
 
word = "Good boy"
first_func(word)
 
 
 
# 예제2
def return_func(w):
    result = "Hello," + str(w)
    return result
 
x = return_func('goodgirl')
print(x)
 
 
# 예제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)
 
 
# 튜플리턴
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)
 
# 리스트리턴
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)
 
def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return {'v1' : y1 , 'v2' : y2 , 'v3' :y3}
 
d = func_mul2(40)
print(type(d), d, d.items(), d.keys())
 
 
 
# 증요
# *args, **kwargs
 
# *args(언팩킹)
# *뒤에 단어는 아무거나 가능, 여러개 받기 가능. 튜플에자주사용.
 
def args_func(*args) :
    for i, v in enumerate(args) :
        print('Result : {}'.format(i), v)
    print('--------')
 
args_func('Lee')
args_func('Lee','Park','Jin')
 
# **kwargs
# 딕셔너리로 이해.
def kwargs_func(**kwa) :
    for v in kwa.keys():
        print("{}".format(v), kwa[v])
    print('--------')
 
kwargs_func(name1='Lee')
kwargs_func(name1='Lee', name2='Park', name3='Jin')
 
# 전체 혼합
def example(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)
example(10, 20, 'Lee', 'Kim', 'Park', age1=20, age2=30, age3=40)
 
 
# 중첩함수
# 함수안의 함수는 바깥에서 사용 불가.
def nested_func(num):
    def func_in_func(num):
        print(num) #2
    print("In func") #1
    func_in_func(num+100) #2
 
nested_func(100)
 
 
# 람다식 예제
# 메모리 절약, 가독성 향상, 코드 간결
# 함수는 객체 생성 > 리소스(메모리) 할당
# 람다는 즉시 실행 함수 (heap초기화) > 메모리 heap초기화
# 남발 시 가독성이 오히려 감소.
 
def mul_func(x,y):
    return x*y
 
lambda x, y : x*y
 
a = lambda x, y : x*y
print(a(5,6))
 
def mul2_func(x,y):
    return x*y
###############################
# 일반적 함수 > 변수 할당.
q = mul2_func(10,50)
print(q)
print(mul2_func(10,50))
mul2_func_var = mul_func
print(mul2_func_var(20,50))
 
# 간단한 것은 람다식으로 사용하는 것이 편함.
lamdbd_mul2_func = lambda x,y:x*y
print(lamdbd_mul2_func(50,50))
 
def func_final(x, y, func):
    print('>>>>', x * y * func(100,100))
 
func_final(10,20, mul2_func_var)
func_final(10,20, lambda x,y:x*y) #이름이 없기에 즉시실행!