1+2

%pwd

%ls

%whos

%reset

%whos

!echo python

!ls

# 주석 : 앞에 #을 붙이면 코드로 실행이 안됩니다.
# 코드에 대한 설명이나 중간에 코드를 샐행시키고 시퓨지 않을때 사용
# 단축키 : ctrl(cmd) + /
# 블럭설정 : shift + 방향키

# 1,2,3을 출력하는 코드
print(1)
#print(2)
print(3)

# 출력 : print 함수
# 코드 중간에 변수안에 들어있는 값을 확인하고 싶을때 사용

a = 1
b = 2
print(b)
c = 3
b = 4
print(b)

# print 함수의 옵션
# docstring : 함수에 대한 설명 : 단축키(shift + tab)
# 자동완성 : tab
print(1,2, sep="-", end="\t")
print(3)

python_data_science = 1

python_data_science

a = 1
b = 2
c = a + b

d, e = 3, 4
f = g = 5

a = 1
# int a = 1 
b = "python"
type(a), type(b)

# 기본 데이터 타입 : int, float, bool, str
a = 1
b = 1.2
c = True
d = "data"
type(a),type(b),type(c),type(d)

a + b

a + d

# 데이터 타입에 함수 : 문자열
# upper : 대문자로 변환
e = d.upper()

d, e

f = "Fast Campus"

# lower : 소문자로 변환
f.lower()

# strip : 공백제거
f.strip()

# replace : 특정 문자열 치환
f.replace("Fast", "Slow")

f.replace(" ", "")

dir(f)

# 오프셋 인덱스 : 마스크, 마스킹 : []
# 문자열은 순서가 있는 문자들의 집합
g = "abcdefg"

g[2], g[-2], g[2:5], g[:2], g[3:], g[-2:], g[::2], g[::-1]

numbers = "123456789" # 97531 출력

result = numbers[::2]
result[::-1]

numbers[::2][::-1]

numbers[::-2]

# list
ls = [1,2,3,"four", [5,6], True, 1.2]
type(ls), ls

# offset index 사용 가능
ls[3], ls[1:3], ls[::-1]

# list 함수
ls = [1, 5, 2, 4]

# append : 가장 뒤에 값을 추가
ls.append(3)
ls

# sort : 오름차순으로 정렬
ls.sort()
ls[::-1]

# pop : 가장 마지막 데이터를 출력하고 출력한 데이터를 삭제
# ctrl + enter : 현재 셀을 계속 실행
num = ls.pop()
num, ls

# 리스트의 복사

ls1 = [1, 2, 3]
ls2 = ls1 # 얕은 복사 : 주소값 복사
ls1, ls2

ls1[2] = 5
ls1, ls2

ls3 = ls1.copy()
ls1, ls3

ls1[2] = 10

ls1, ls3

tp1 = 1, 2, 3
tp2 = (4, 5, 6)
type(tp1), type(tp2), tp1, tp2

a, b = 1, 2
a, b

# offset index 사용 가능
tp1[1], tp1[::-1]

# 리스트와 튜플의 저장공간 차이 비교
import sys

ls = [1, 2, 3]
tp = (1, 2, 3)

print(sys.getsizeof(ls), sys.getsizeof(tp))

# 선언 : 키는 정수, 문자열 데이터 타입만 사용 가능
# 인덱스 대신 키를 사용
dic = {
    1: "one",
    "two": 2,
    "three" : [1, 2, 3],
}
type(dic), dic

dic[1], dic["three"]

dic["two"] = 123
dic

# 아래의 데이터를 list와 dict로 선언
# 도시 : seoul, busan, daegu
# 인구 : 9,700,000, 3,400,00, 2,400,000

# 리스트
city = ["seoul", "busan", "daegu"]
population = [9700000, 3400000, 2400000]

# 딕셔너리
data = {
    "seoul" : 9700000,
    "busan" : 3400000,
    "daegu" : 2400000,
}

sum(population)

sum(data.values())

a = 1
b = "2"
a + int(b)

str(a) + b

list(data.values())

city, population

# zip : 같은 인덱스 데이터끼리 묶어주는 함수
list(zip(city, population))

result = dict(zip(city, population))

data1 = list(result.keys())
data2 = list(result.values())
data1, data2

string = "python"
int(string)

# 산술연산
1 + 4 / 2 ** 2

# 할당연산
a = 10
a+=10
a+=10
a

# 비교연산
b=2
print(a, b)
a < b, a == b, a !=b

# 논리연산
True and False, True or False, not True or False

# 멤버연산
ls = ['jin', 'andy', 'john']

'andy' in ls, 'anchel' in ls

### 랜덤함수
import random

random.randint(1, 10)

# 입력함수
data = input("insert string: ")
data

# 해결의 책 : 질문을 하면 질문에 대한 답변을 해주는 책

# 솔루션을 리스트로 작성
# 질문 입력 받음
# 솔루션의 갯수에 맞게 랜덤한 index 정수 값을 생성
# index 해당하는 솔루션 리스트의 데이터를 출력

# 솔루션을 리스트로 작성
solutions = [
    "무엇을 하든 잘 안될것이다.",
    "생각지도 않게 좋은 일이 생길것이다.",
    "무엇을 상상하든 그 이상이다."
]

# 질문 입력 받음
input("질문을 입력하세요.: ")

# 솔루션의 갯수에 맞게 랜덤한 index 정수 값을 생성
idx = random.randint(0, len(solutions) - 1)

# index 해당하는 솔루션 리스트의 데이터를 출력
solutions[idx]

# 조건부분에 bool 데이터 타입 이외의 테이터 타입이 오면 bool으로 형변환 되어 판단
if False:
    print("python")
    
print("done")

# int : 0을 제외한 나머지 값은 True
bool(0), bool(1), bool(-1), bool(100)

num = 0

if num :
    print("python_1")

num = 1
if num :
    print("python_2")

number = 7

if number % 2:
    print("홀수")

# float : 0.0을 제외한 나머지 실수는 True
# str : ""를 제외한 나머지 문자열은 True
# list, tuple, dict : [], (), {}를 제외한 나머지는 True

# 지갑에 돈이 10000원 이상 있으면 택시를 타고 그렇지 않으면 걸어서 집에 갑니다.
# 2000원 이상이면 버스
money = 5000

if money >= 10000:
    print("택시")
    
if money < 10000:
    print("걸어서")

if money >= 10000:
    print("택시")
else:
    print("걸어서")

if money >= 10000:
    print("택시")
elif money > 2000:
    print("버스")
else:
    print("걸어서")

# 계좌에 10000원이 들어 있다.
# 인출 금액을 입력 받습니다.
# 인출 금액이 계좌에 있는 금액보다 크면 "잔액 부족" 출력
# 아니면 "인출" 출력
# 마지막에 현재 잔액 출력

data = int(input("draw money: "))
type(data), data

10000 - data

account = 10000
draw_money = int(input("insert draw money: "))

if account >= draw_money:
    account -= draw_money
    print(str(draw_money) + "원 출금")
else:
    print("잔액 부족, "+ str(draw_money - account) + "원 부족")

print("현재 잔액 : " + str(account) + "원")

# string 데이터 타입의 format 함수
print("현재 잔액은 {}원, 인출금액은 {}원 입니다.".format(account, draw_money))
print("현재 잔액은 {data1}원, 인출금액은 {data2}원 입니다.".format(data2 = draw_money, data1 = account))

f'현재 {account}'

# data  변수에 0이면 "zero" 출력, 아니면 "not zero" 출력
data = 0
if data:
    print("not zero")
else:
    print("zero")

data = 1
result = "not zero" if data else "zero"
result

# while
data = 3
while data:# 조건이 False가 될때까지 구문의 코드를 실행
    # 반복되는 코드
    print(data)
    data -= 1

# 무한루프
# break : 반복문을 중단 시킬때 사용되는 예약어
result = 1
while result:
    if result >= 10:
        break
    result += 1
print(result)

# for : continue : 조건부분으로 올라가서 코드가 실행
ls = [0, 1, 2, 3, 4]
for data in ls: # data가 홀수면 continue 실행
    if data % 2:
        continue
    # data가 짝수면 print 실행
    print(data, end=" ")

# for문을 이용하여 코드를 100번 실행
# range 함수
list(range(100))
result = 0
for data in range(100):
    result += data
result

# offset index 개념과 비슷하게 사용
list(range(5)), list(range(5, 10)), list(range(0, 10, 2)), list(range(10, 0, -2))

# 0~10 까지 짝수 합
result = 0
for number in range(0, 11, 2):
    result += number
result

dict = {"one": 1, "two":2, "three":3}

# 키값만 출력
for data in dict:
    print(data)

list(dict.items())

for subject, point in dict.items():
    print(subject, point)

# 구구단
for num2 in range(1, 10):
    for num1 in range(2, 10):
        print("{}*{}={}".format(num1, num2, num1*num2), end='\t')
    print()

# 각각 값에 제곡한 결과 출력
ls = [0, 1, 2, 3]
result = []
for data in ls:
    result.append(data**2)
result

result = [data**2 for data in ls]
result

# 리스트 컴프리헨션을 써서 홀수와 짝수를 리스트로 출력해주는 코드
# 삼항연산 사용
ls = [0, 1, 2, 3]
result = ["짝수", "홀수", "짝수", "홀수"]

result = [
    "홀수" if data % 2 else "짝수" for data in ls
]
result

# 리스트 컴프리헨션 조건문
ls = range(10)
[data for data in ls if data % 2]

ls = [1, 2, 3]
[func for func in dir(ls) if func[:2] != "__" and func[0] == 'c']

# for문과 list comprehention 성능 비교

%%timeit
ls = []
for num in range(1, 10001):
    ls.append(num)
len(ls)

%%timeit
ls = [num for num in range(1, 10001) if num % 3 == 0]
len(ls)

point = 88

if point >= 90:
    print("A")
elif point >= 80:
    print("B")
elif point >= 70:
    print("C")

%reset

%whos

# 함수 선언
def grade(point):
    if point >= 90:
        print("A")
    elif point >= 80:
        print("B")
    elif point >= 70:
        print("C")

a = 1
ls = [1, 2, 3]

%whos

# 함수 호출
grade(88)

# code ...

grade(78)

def plus(num1, num2=10, num3=20): # 파라미터 : 디폴트 파라미터
    print(num1 + num2 - num3)

plus(1, 2) # 아규먼트

plus(3) # 아규먼트

plus(3, num3=100) # 아규먼트 : 키워드 아큐먼트

print(1, 2, end="-")
print(3)

def plus(num1, num2):
    print(num1+num2)
    return num1+num2

result = plus(1, 2)
print(result)

data1 = "python"
result = data1.upper()
print(result)

data2 = [3, 1, 2]
result = data2.sort()
print(result)

# 함수에서 return 코드가 샐행되면 무조건 함수의 코드 실행이 종료
def echo(msg):
    if msg == "quit":
        return
    print(msg)

echo("python")

echo("quit")

def plus(*args, **kwargs):
    print(type(args), args)
    print(type(kwargs), kwargs)
    return sum(args) + sum(list(kwargs.values()))

plus(1, 2, num1=3, num2=4)

def func(num1, num2, num3):
    return num1, num2, num3
data = [1, 2, 3]
func(*data) # func(1, 2, 3)

data = {
    "num2": 100,
    "num3": 200,
}
func(1, **data) # func(1, num2=100, num3=200)

def echo(msg):
    """
    echo return its input agument
    The operation is:
        1. print msg
        2. return msg parameter
    param : msg : str
    return str
    """
    return msg

help(echo)

print(echo.__doc__)

# global
gv = 10
def echo():
    print(gv)
echo()

# global
gv = 10
def echo():
    gv = 100
    print(gv)
echo()

gv

# global
gv = 10
def echo():
    global gv
    gv = 100
    print(gv)
echo()
gv # 100

def outer(a, b):
    
    def inner(c, d):
        return c + d
    
    return inner(a, b)

outer(1,2)

inner(2, 3)

def outer(a, b):
    
    def inner(c, d):
        return c + d
    
    return inner

outer(1,2)(3, 4)

# callback function : 함수를 아규먼트 파라미터로 설정해서 사용

def calc(func, a, b):
    # code
    a **= 2
    b **= 2
    return func(a, b)

def plus(a, b):
    return a + b

def minus(a, b):
    return a - b

calc(plus, 1, 2) # 덧셈

calc(minus, 1, 2) # 뺄셈

def plus(a, b):
    return a + b

plus(1, 2)

plus2 = lambda a, b: a + b
plus(1, 3)

# calc(func, a, b)
calc(lambda a, b: a + b, 3, 4)

calc(plus, 3, 4)

ls = [1, 2, 3, 4]
def odd_even(num):
    return "odd" if num%2 else "even"
    
odd_even(3), odd_even(4)

list(map(odd_even, ls))

# input 함수로 구분자로  " "으로 여러개의 숫자를 입력 받습니다.
# str.split(" ") 리스트로 만들고
# 만들어진 리스트의 값들을 int 형변환

datas = input("insert numbers : ")

result = datas.split(" ")
result

result = list(map(int, result))
result

# ctrl + alt + 드래그 : 여러줄 수정

ls = range(10)

# 홀수만 출력
list(filter(lambda data: True if data % 2 else False, ls))

from functools import reduce

ls = [3, 1, 2, 4, 5]
reduce(lambda x, y : x + y, ls)

# a
def plus(a, b):
    print("start") # code_1
    result = a+b # code_2
    print(f'result : {result}') # code_3
    return result

# b
def minus(a, b):
    print("start") # code_1
    result = a-b # code_4
    print(f'result : {result}') # code_3
    return result

# c
def disp(func):
    def wrapper(*args, **kwargs):
        print("start") # code_1
        result = func(*args, **kwargs) # code_2, code_4
        print(f'result : {result}') # code_3
        return result
    return wrapper        

plus(1, 2)

@disp
def plus(a, b):
    result = a + b
    return result

plus(1, 2)

# 데코레이터를 이용해서 함수의 실행 시간을 출력

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time() # code_1
        result = func(*args, **kwargs) # code_2, code_4
        end_time = time.time() # code_3
        print("running time : {}".format(end_time - start_time)) # code 3
        return result
    return wrapper

@timer
def test1(num1, num2):
    data = range(num1, num2)
    return sum(data)

@timer
def test2(num1, num2):
    result = 0
    for num in range(num1, num2+1):
        result += num
    return result

test1(1, 100000)

test2(1, 100000)

# 패스워드를 입력 받아야 함수가 실행되도록하는 데코레이터 작성

import random

def check_password(func):
    def wrapper(*args, **kwargs):
        pw = "dss11"
        # check password
        input_pw = input("insert pw: ")
        if input_pw == pw:
            result = func(*args, **kwargs)
        else:
            result = "not allow!"
        return result
    return wrapper

@check_password
def plus(a, b):
    return a+b

plus(1, 2)

@check_password
def lotto_func():
    lotto = list(range(1, 46))
    lotto = random.sample(lotto, 6)
    lotto.sort()
    return lotto

lotto_func()

lotto_func()

user_datas = [
    {"user":"test", "pw":"1234", "count":0},
    {"user":"python", "pw":"5678", "count":0},
]

ls = ["a", "b", "c"]
print(list(range(len(ls))))
print(list(zip(range(len(ls)), ls)))
for idx, data in list(zip(range(len(ls)), ls)):
    print(idx, data)

list(enumerate(user_datas))

# user data를 입력 받아서 아이디와 패스워드를 체크하는 데코레이터 함수를 코드로 작성하세요.
# 로그인 될때마다 count를 1씩 증가
def need_login(func):
    def wrapper(*args, **kwargs):
        # 아이디 패스워드 입력
        user, pw = tuple(input("insert user pw :").split(" "))
        # 존재하는 아이디, 패스워드 확인
        # for idx, user_data in zip(range(len(user_datas)), user_datas):
        for idx, user_data in enumerate(user_datas):
            if user_data["user"] == user and user_data["pw"] == pw:
                # count 데이터 추가
                user_datas[idx]["count"] += 1
                # 함수 실행
                return func(*args, **kwargs)
        return "wrong login data!"
        
        # 카운트 증가 및 함수 실행
    return wrapper

@need_login
def plus(num1, num2):
    return num1 + num2

plus(1, 2)

user_datas

# 스타크래프트의 마린을 클래스로 설계
# 체력(health) = 40, 공격력(attack_pow) = 5, 공격(attack())
# 마린 클래스로 마린 객체 2개를 생성해서 마린1이 마린2를 공격하는 코드를 작성
# attack(self, unit)

class Marine:
    
    def __init__(self, health=40, attack_pow=5):
        self.health = health
        self.attack_pow = attack_pow
        
    def attack(self, unit):
        unit.health -= self.attack_pow
        print(unit.health)
        if unit.health <= 0:
            unit.health = 0
            print("사망")
        pass

marine_1 = Marine()

marine_2 = Marine()

marine_1.attack(marine_2)

marine_1.health, marine_2.health # 40, 35

# 메딕 : heal_pow, heal(unit)
class Medic:
    
    def __init__(self, health = 40, heal_pow=6):
        self.health = health
        self.heal_pow = heal_pow
    
    def heal(self, unit):
        if unit.health > 0:
            unit.health += self.heal_pow
            if unit.health >=40:
                unit.health = 40
        else:
            print("이미 사망")
    

medic = Medic()

marine_1.attack(marine_2)

marine_1.health, marine_2.health

medic.heal(marine_2)

marine_3 = Marine(attack_pow=25)

marine_3.attack(marine_1)

class Calculator:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
    
    def plus(self):
        return self.num1 + self.num2

calc = Calculator(1, 2)
calc.plus()

class Calculator2:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
    
    def plus(self):
        return self.num1 + self.num2
    
    def minus(self):
        return self.num1 - self.num2

calc2 = Calculator2(1, 2)

calc2.minus(), calc2.plus()

# 상속을 사용하여 minus 함수 추가
class Calculator3(Calculator):
    def minus(self):
        return self.num1 - self.num2

calc3 = Calculator3(1, 2)

calc3.plus(), calc3.minus()

# 메서드 오버라이딩
class Calculator4(Calculator3):
    def plus(self):
        return self.num1**2 + self.num2**2
        

calc4 = Calculator4(1, 2)

calc4.plus()

# 아이폰 1, 2, 3
# 아이폰 1 : calling : print("calling")
# 아이폰 2 : send msg
# 아이폰 3 : internet

class iPhon1:
    def calling(self):
        print("calling")

class iPhon2(iPhon1):
    def send_msg(self):
        print("send_msg")

class iPhon3(iPhon2):
    def internet(self):
        print("internet")

iphon3 = iPhon3()

iphon3.calling(), iphon3.send_msg(), iphon3.internet()

class Galuxy:
    def show_img(self):
        print("show_img")

class DssPhone(iPhon3, Galuxy):
    def camera(self):
        print("camera")

dss_phone = DssPhone()

[func for func in dir(dss_phone) if func[:2] != '__']

class Marine:
    
    def __init__(self):
        self.health = 40
        self.attack_pow = 5
        
    def attack(self, unit):
        unit.health -= self.attack_pow
        if unit.health <= 0:
            unit.health = 0

class Marine2(Marine):
    def __init__(self):
#         self.health = 40
#         self.attack_pow = 5
        super().__init__()
        self.max_health = 40

marine = Marine2()

marine.health, marine.attack_pow, marine.max_health

class User:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name
    
    def setter(self, first_name):
        if len(first_name) >= 3:
            self.first_name = first_name
        else:
            print("error")
        
    def getter(self):
        print("getter")
        return self.first_name.upper()
        
    def disp(self):
        print(self.first_name, self.last_name)
    
    name = property(getter, setter)

user1 = User("andy", "kim")

user1.first_name

# getter 함수 실행
user1.name

# setter 함수 실행
user1.name = "john"

user1.name

class Calculator:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.__num2 = num2
    
    def getter(self):
        return self.__num2
    
    def setter(self, num2):
        num2 = 1 if num2 == 0 else num2
        self.__num2 = num2
        
    def __disp(self):
        print(self.num1, self.__num2)
        
    def div(self):
        self.__disp()
        return self.num1/self.__num2
    
    number2 = property(getter, setter)

calc = Calculator(1, 2)

calc.div()

calc.number2

calc.number2 = 0

calc.num2 = 0

calc.div()

calc.__num2

calc._Calculator__num2

calc.__disp()

calc._Calculator__disp()

# 사람 : 이름, 이메일, 정보출력()

# is a
class Person:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class Person2(Person):
    def info(self):
        print(self.name, self.email)

p = Person2("andy", "andy@gmail.com")

p.info()

# has a
class Name:
    def __init__(self, name):
        self.name_str = name
class Email:
    def __init__(self, email):
        self.email_str = email

class Person:
    def __init__(self, name_obj, email_obj):
        self.nmae = name_obj
        self.email = email_obj
    def info(self):
        print(name.name_str, email.email_str)

name = Name("andy")
email = Email("andy@gmail.com")
p = Person(name, email)

p.info()

"test" == "test"

"test".__eq__("test")

1+2

'1'+'2'

class Txt:
    def __init__(self, txt):
        self.txt = txt
    
    def __eq__(self, txt_obj):
        return self.txt.lower() == txt_obj.txt.lower()
    
    def __repr__(self):
        return "Txt(txt={})".format(self.txt)
    
    def __str__(self):
        return self.txt

t1 = Txt("python")
t2 = Txt("PYTHON")
t3 = t1

t1 == t2, t1 == t3, t2 == t3

t1 

print(t1)

range(0, 5)

# Integer 객체
class Integer:
    def __init__(self, number):
        self.number = number
    
    def __add__(self, obj):
        return self.number + obj.number
    
    def __str__(self):
        return str(self.number)
    
    def __repr__(self):
        return str(self.number)

num1 = Integer(1)
num2 = Integer(2)
num1 + num2

num1

num2

# 계좌 클래스 만들기
# 변수 : 자산(asset), 이자율(interest)
# 함수 : 인출(draw), 입금(insert), 이자추가(add_interest)

class Account:
    
    def __init__(self, asset=0, interest=1.05):
        self.asset = asset
        self.interest = interest
    
    def draw(self, money):
        if self.asset >= money:
            self.asset -= money
            print("출금 : {}원".format(money))
        else:
            print("금액부족 : {}원".format(money-self.asset))
    
    def insert(self, money):
        self.asset += money
        print("{}원 입금".format(money))
    
    def add_interest(self):
        self.asset *= self.interest
        print("이자 지급")
    
    def __repr__(self):
        return "Account(asset:{}, interest:{})".format(self.asset, self.interest)