재시도

c = """
        <div class="select_div">
            <span data-i18n="footer.relationSites">연관사이트</span>
            <ul>


            </ul>
        </div>
        <ul class="list_sns">

페이스북"></a></li>

블로그"></a></li>

유트브"></a></li>
        </ul>
"""

# 키워드 검색
print(c.find("list_sns"))

# 키워드를 이용한 스키핑
c = c[167:] # 필요없는 데이터 날리기
print(c)

# <li> 태그를 기준으로 쪼개기
c = c.split("</li>")
print(c)

print("-----------------------------------------------------------")
# c[0] 데이터 출력
print(c[0])

# 각 태그에서 usrl만 출력
url = c[0].split('" target')[0]
print(url)

# 각 태그에서 usrl만 출력 2
url = url.split('href="')[1]
print(url)

print("------------------------------------------------------------")
#
print(c[0])

#
name = c[0].split('alt="')[1]
print(name)

name = name.split('"')[0]
print(name)

print()


for i in range(len(c)-1):
    url = c[i].split(' "target')[0]
    url = url.split('href="')[1]
    print(url)
    name = c[i].split('alt="')[1]
    name = name.split('"')[0]
    print(name)
    

# 정규표현식
import re

c = """
        <div class="select_div">
            <span data-i18n="footer.relationSites">연관사이트</span>
            <ul>


            </ul>
        </div>
        <ul class="list_sns">

페이스북"></a></li>

블로그"></a></li>

유트브"></a></li>
        </ul>
"""

pattern = re.compile('https://.*" target')
result = pattern.search(c)
print(result.group())

pattern = re.compile('[a-z:/.]*')
result = pattern.search(result.group())
print(result.group())

class StaticTest :

    num = 3 # 클래스 프로퍼티

    # 단점
    def __init__(self, aaa):
        self.aaa = aaa

    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def min(x):
        # return x - self.aaa # 인스턴스의 프로퍼티(속성)에 접근을 불허한다; 내부 프로퍼티를 사용할 경우에는 staticmethod의 사용은 안된다.
        pass

    @classmethod
    def class_info(cls):
        print(cls)
        print(cls.num) # 클래스메서드는 클래스 프로퍼티를 가져올 수 있다.

    @classmethod
    def class_info2(cls,x):
        return cls.num

# 인스턴스를 생성할 필요가 없음
print(StaticTest.add(1,2))
StaticTest.class_info()

class Country:

    name = "국가명"
    population = "인구"
    capital = "수도"

    @classmethod
    def show(cls):
        print("{} {} {}".format(cls.name, cls.population, cls.capital))



class Korea(Country): # Country 클래스에 있는 모든 기능을 쓰겠다.

    @classmethod
    def introduceCtr(cls):
        print("어서오세요, 대한민국에.")


    @classmethod
    def set_name(cls, name):
        cls.name = name

b = Country() # 부모클래스
b.show()

a = Korea() # 자식클래스
a.set_name("대한민국")
a.introduceCtr()
a.show()

class Parent1:

    def __init__(self, a):
        self.a = a

    def show(self):
        print(self.a)


class Child1(Parent1):

    def show_a_plus(self):
        print("자식클래스에서 호출한 부모클래스 속성 : {}".format(self.a))

a = Child1(10) # init 메서드 호출 가능. 대신에 하위 값들에 대해서 강제성을 가진다.
a.show_a_plus()

# 오버라이딩.

# 덮어씌우기. 부모클래스의 기능을 자식클래스의 기능으로 덮어씌우는 기능.

# 부모클래스
class Machine1:

    def __init__(self, a, b):
        self.a = a
        self.b = b

    def show(self):
        print("{} : {}".format(self.a, self.b))


# 자식클래스
class Machine2(Machine1): # Machine1을 상속받은 Machine2

    # 기능 고치기
    # 동일한 이름으로 함수를 생성
    # 완전히 새로운 기능으로 출력시켜줌.
    def show(self):
        print("자식메서드의 기능 {} : {}".format(self.a, self.b)) # 부모자식간의 변수는 바뀔 수 없다.

a = Machine2("abc", 1234)
a.show() # 부모에 있는 기능이 오버라이딩 (덮어씌우기) 됐다.

# 데코레이터

def decorator_func(original_func):
    def wrapper_func(*args, **kwargs): # 가변 파라미터를 넣어준다. 파라미터의 갯수가 몇개인지 알 수 없을 때! 연속적인 파라미터를 받을 수 있다.
        print("{} 함수가 실행되기 전 실행되는 문구".format(original_func.__name__))
        return original_func(*args, **kwargs) # 실행한 뒤의 결과값을 출력해야함
    return wrapper_func # 실행되지 않은 function 그대로를 출력해야함.


@decorator_func # annotation
def display_1():
    # 앞에 실행되는 로직
    print("display_1 함수가 실행되었습니다.")
    # 뒤에 실행되는 로직

@decorator_func
def display_2():
    print("display_2 함수가 실행되었습니다.")

@decorator_func
def display_3(name, age):
    print("display_3 함수가 실행되었다. {}, {}".format(name, age))




display_1()
display_2()
display_3("철수", 30)


print("====================================================")

def decorator_func(original_func):
    def wrapper_func():
        print("{} 함수가 실행되기 전 실행되는 문구".format(original_func.__name__)) # 전처리
        val = original_func()
        print("{} 함수가 실행되기 후 실행되는 문구".format(original_func.__name__)) # 후처리
        return val if bool(val) else None
    return wrapper_func # 함수 속 함수인 wraapper_fucn을 여기서 선언

@decorator_func # annotation
def display_1():
    print("display_1 함수가 실행되었습니다.")

display_1()


# @decorator_func
# def display_2():
#     print("display_2 함수가 실행되었습니다.")
#
# display_2()

# 데코레이터 클래스 방식

class DecoratorClass:
    def __init__(self, original_func):
        self.original_func = original_func

    # 내장함수 사용
    def __call__(self, *args, **kwargs):
        print("메서드가 호출되기 전 실행되는 문장".format(self.original_func.__name__)) # 전처리
        a = self.original_func(*args, **kwargs)
        print("메서드가 호출되기 후 실행되는 문장".format(self.original_func.__name__)) # 전처리
        return a

@DecoratorClass # 클래스명이 annotaion이다.
def display_1(name, age):
    print("display1 함수가 실행되었습니다.")


a = display_1("ddd", 111)
print(a)








# @DecoratorClass
# def display_2(name, age):
#     print("display2 함수가 실행되었습니다. {} {} ".format(name, age))

# display_2("jajaj", 1234)

class Person:
    bag = []
    val1 = 123

    def __init__(self,val2):
        self.bag2 = []
        self.val2 = []

    def put_bag(self, stuff):
        self.bag.append(stuff)

    def put_bag2(self, stuff):
        self.bag2.append(stuff)


    def minus_val1(self):
        # self.val1 -= 10
        Person.val1 -= 10

    def class_method(self):
        print("클래스 메소드 출력")

    @staticmethod  # 클래스메서드에 접근하는 방식
    def class_method(): # 셀프를 지우면 일반적인 호출이 아니라 클래스에서 막바로 매서드를 호출
        print("클래스 메소드 출력")


# 클래스 메서드 (=public method 혹은 static method 라고 자바에서 불림)
# Person.class_method() # 클래스에서 바로 호출하는 매서스



# 인스턴스 메서드
per1 = Person(456)
per1.put_bag("책") # 클래스 필드에 삽입.
per1.put_bag2("책") # 클래스 필드에 삽입

per2 = Person(789)
per2.put_bag("열쇠") # 클래스 필드에 삽입.
per2.put_bag2("열쇠")

print(per1.bag)
print(per2.bag)
print(per1.bag2)
print(per2.bag2)

per1.minus_val1()
per2.minus_val1()

print(per1.val1)
print(per2.val1)

# 이스턴스 삭제

class Cls1:
    def __init__(self, name):
        self.name = name
    def print_info(self):
        print("이름 : {} ".format(self.name))

    def __del__self(self):
        print("인스턴스 종료 : {}".format(self.name))

    def __del__(self):
        print("인스턴스 종료 : {}".format(self.name))


user1 = Cls1("철수")
user2 = Cls1("영희")
user3 = Cls1("ㅎㅎ")


del user1
del user2
print("-------------------------------")

class Cls1 :
    def __init__(self, val1):
        self.val1 = val1

    def get_number(self):
        print(self.val1)


# 객체가 생성될 떄 그 객체의 초기 상태를 설정.
ins1 = Cls1(10)
ins1.get_number()

class Cls1:
    gval1 = 1234

    def __init__(self, val1, val2):
        self._val1 = val1
        self._val2 = val2
        print("init")
        super().__init__()

    def __new__(cls, val1, val2):
        print(val1, val2)
        print("new")
        return super().__new__(cls)

    def get_global_val(self):
        print(self.gval1)
        self.gval1 -= 5


ins1 = Cls1(1, 3)
ins2 = Cls1(1, 3)
ins3 = Cls1(1, 3)

ins1.get_global_val()
ins2.get_global_val()
ins3.get_global_val()


# 1 3  -> init으로 메모리 공간 생성
# new  -> 인스턴스가 만들어지고 난 후에 생성됨. ; self에 new에 접근을 못함.
# init

# 접근 제어

class Cls1 :
    def sef_data1(self, val1, val2): # 지정하고자하는 외부의 값에 설정할 수 있다. #프로퍼티값을 입력받아 사용할 수 있다.
        self.val1 = val1
        self.val2 = val2

    def get_data1(self):
        print(self.val1) # 인스턴스에 있는 val1
        print(self.val2) # 인스턴스에 있는 val2


ins1 = Cls1()
ins1.sef_data1(10, "abc") # 외부에서 self에 접근할 수는 없다. val1 과 val2만 접근해서 쓰면 된다.
ins1.get_data1()  # 인스턴스에 프로퍼티값이 들어간다.

print("--------------------------------------------------------")

class Cls2 :
    def set_data2(self, val1, val2):
        self.val1 = val1
        self.val2 = val2

# 메서드로 접근할 필요 없는 방식 ; 하지만 실무에서는 사용 못한다 ;
ins2 = Cls2()
ins2.set_data2(100, "aaaaa")
print(ins2.val1) # 필드로 접근 가능   instance.property
print(ins2.val2) # 필드로 접근 가능

ins2.val2 = "cccc"
print(ins2.val2)

# 그러면 메서드는 왜 쓰냐? ;
# 무결성, 원자성이 깨진다. ;
# 만약 외부에서 프로퍼티값을 수정할 때는 어떠한 조건을 거쳐야한다.
# 어떻게 제어할까 ? ;

# 접근 제어

class Cls1:
    def set_data1(self,val1,val2,val3):
        self.val1 = val1
        self._val1 = val1
        self.__val2 = val2
        self.__val3__ = val3

    def __get_print1(self):
        print("이것은 비공개 메서드 입니다.")

    def __get_print2__(self): # 되더라도 이렇게 메서드를 선언하면 안됨. # 내가 제어하는 건지 파이선이 제어하는 건지 구분이 안됨.
        print("이것은 공용 메서드 입니다.")



# 1
ins1 = Cls1()
ins1.set_data1(10,20, 30)
print(ins1._val1) # _ 는 접근 경고가 뜬다. ;
print()
# print(ins1.__val2) # __ 는 에러가 발생 ; 강제성을 띈다 ; 프로퍼티값 비공개 속성 ; 해당 클래스 내에서만 접근이 가능하다. 외부에서의 접근을 막는다 ; 메서드로만 접근이 가능하다
print(ins1.__val3__) # __의 예외 ; 접근 가능 ; 공용으로 사용하는 레퍼런스로 인식한다.

#2
# ins1.__get_print1() # 에러 발생 ; __  메서드 또한 비공개 가능하다. ; 비공개 메서드
ins1.__get_print2__() # 되더라도 이렇게 메서드를 선언하면 안됨.

# self

class Cls1 : # 클래스생성
    def get_self(self):
        print(self)
        print(id(self)) # 메서드

ins1 = Cls1() # 객체 생성
ins1.get_self() # 객체의 주소 참조함. # sefl를 사용하면 내부에서 사용했었던 리소스를 사용하게해준다.
print(id(ins1)) # 메서드에서도 찍었는데, 여기서 바로 찍으면 주소가 같을까? ; == 같다. # self는 안에서. instance는 바깥에서.
print()
ins2 = Cls1() # 객체 생성
ins2.get_self() # 객체의 주소를 출력함. #
print(id(ins2)) # 메서드에서도 찍었는데, 여기서 바로 찍으면 주소가 같을까? ; == 같다.

# class



# 일반 함수 방식

scv1 = {"atk" : 3, "def" : 5, "hp" : 50}
scv2 = {"atk" : 8, "def" : 5, "hp" : 50}

def attack1(dic1):
    print("{}의 공격을 가함" .format(dic1["atk"]))

def defense(dic1):
    print("{}의 데미지를 방어".format(dic1["def"]))
    dic1["hp"] -= 1

attack1(scv1)
defense(scv1)
print(scv1)


attack1(scv2)
defense(scv2)
defense(scv2)
print(scv2)


print("-----------------------------------------------------")

# class
class SCV : # 클래스 생성 # 빵틀 생성
    def __int__(self):
        self.state = {"atk" : 5, "def" : 3, "hp" : 50 } #속성 #멤버변수
    state = {"atk" : 5, "def" : 3, "hp" : 50 } # state 변수 생성

    def attack2(self): # 함수 생성
        print("{}의 공격을 가함".format(self.state["atk"])) # self의 state라는 애를 참조하겠다.

    def defense2(self): # 함수 생성
        print("{}의 데미지를 방어".format(self.state["def"])) # self의 state라는 애를 참조하겠다.
        self.state["hp"] -= 1 # self의 state라는 hp값을 -1 하겠다.

    def get_state(self): # 함수 생성
        print(self.state)

# 빵틀 활용

scv3 = SCV() # 클래스 사용하기 # 객체선언(생성)
scv3.attack2()
scv3.defense2()
scv3.get_state()
print()
scv4 = SCV() # 클래스 사용하기 # 객체선언(생성)
scv4.defense2()
scv4.defense2()
scv4.get_state()

# class


a = 10
print(type(a))

b = "abc"
print(type(b))

# 클래스에서 가져오는 메서드...
print(b.format(a)) # b.format 은 메서드다.

class Class1: # 클래스명은 명사형
    def set_data(self): # self는 자기자신을 나타낸다. # 객체의 나 자신. # 객체 내부에서 사용할
        # property
        self.aaa = 1
        self.bbb = "abc"

    def get_data(self): # 정상접근방법
        print(self.aaa) # 나 자신을 타겟팅함.
        print(self.bbb)

    def get_total_state(self):
        print(self.aaa)
        print(self.bbb)
        print("----------------get data를 사용한 케이스--------------")
        self.get_data() # 메서드 참조


var1 = Class1()
var1.set_data()
var1.get_data()
var1.get_total_state() # 메서드 참조 가능

def func1():
    return 5

x1  = func1()
print("{}".format(x1))
print("{}".format(func1()))


# 두 개의 숫자를 더해서 나온 합산 값을 return하는 함수
def func2(a,b):
    print("이것은 두 개의 값을 더하는 함수 입니다.") # 리턴 전에 출력값을 넣으면 먼저 출력된다.
    return(a+b) # 합산한 결과를 return
    # 리턴을 만나면 그 후에 어떠한 함수를 만나도 여기서 멈춘다.
    print("이것은 리턴 후에 실행되는 함수 입니다.") # 리턴 후에 출력은 안된다.

# 예외 사항
# 조건부
def func3(a):
    if a == 10 :
        return # 로직을 강제로 블락한다. return 이후의 출력값을 출력한다.
    print("입력한 숫자 : {}".format(a))

# 처리 순서는 위에서 아래로
# print 값을 먼저 출력하고 그 다음 값이 return이 된다.
print("{}".format(func2(3,5)))

func3(5)
func3(10) # 로직을 강제로 블락한다.

def func1(x, y):
    return x+y, x-y # 복수개로 리턴을 하면 결과값이 튜플로 떨어진다.

x1 = func1(20,5)
print(x1)
print("{}".format(x1), type(x1)) # 복수개로 리턴을 하면 결과값이 튜플로 떨어진다.

x2, y2 = func1(20, 5)
print(x2) # 25
print(y2) # 15


print("---------------------------------------------")

def func2(x, y):
    return x+y, x-y, x*y # 복수개

# 일부데이터를 한꺼번에 받기 위해 * 를 변수에 사용하여 받을 수 있다.
x3, *y3 = func2(20, 10)
print(x3) # singlarity
print(y3) # multiplier 형태의 데이터타입을 받는다.
print(y3, type(y3)) # 리스트 형태로 떨어진다.

a = 1

def func1(a):
    a = a + 1 # 스택

func1(2)
print(a)

# 전역 메모리
# a => 1
# func1
# 실제로 교체될 일이 없다.

# 메모리에 대한 참조는 본인의 구역상에서 메모리 참조는 가능하다.
# 현재 구역에서 다른 구역의 메모리를 참조하지는 못한다.

# func1 메모리 (스택 메모리)
# a => 2 + 1

print("--------------------------------")
a = 1
b = 2
# 본인의 메모리 스택상에 없으면 상위 스택(전역메모리)상의 메모리를 참조한다.
def func1(a):
    a = a + 1 # 스택
    print(b)
    return a

func1(2)
print(a)
# b 출력됨
print(func1(2))

print("--------------------------------")

def func2(b):
    global a # 상위 메모리(전역메모리) 를 참조하고 싶을 때.
    a += 1

func2(10)
print(a)

def test1(a):
    a += 10

# 메모리는 다르다.
# 하나는 전역
# 하나는 스택
a = 1
test1(a)
print(a)


# 주소에 의해서 참조가 일어난다. = 로직이 바뀐다.
def test2(b):
    b[0] = "zzz"

b = ["aaa"]
test2(b)
print(b)

# 값을 비교
print( (1,2,3) == (1,2,3) )
print( [1,2,3] == [1,2,3] )
print( {1,2,3} == {1,2,3} )

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

print(func1(2,3))

print("---------------------------------------")
# 람다식
add = lambda a, b: a+b
result = add(3,4)
print(result)
print(add(3,4))

print("---------------------------------------")
print((lambda a,b: a-b)(3, 4))

print("---------------------------------------")
# 함수 채로 넣어서 사용 가능.
def func2(a):
    print(a)

func2((lambda a: "{}".format(a))("aaa"))


print("---------------------------------------")

def func3():
    return lambda x: x**2

x1 = func3()
print(x1(3))


print("---------------------------------------")

def func4():
    print("복잡한 수식")
    return 1

x3 = lambda x: x+func4()
print(x3(3))

# map

def func1(x):
    return x*2

list1 = list(map(func1, [1,2,3,4]))  # list로 변환을 한번 시켜주고 넘겨줘야함.
print(list1)

print("------------------------------------------------------")


dic1 = {1: 10, 2: 20, 3: 30}
list2 = list(map(func1, [dic1[i] for i in dic1]))
print(list2)

print("------------------------------------------------------")
# 굳이 func1 을 사용할 필요없이 람다식 사용
print(list(map(lambda x: x+10, [1,2,3])))

print("------------------------------------------------------")

a3 = [1,2,3,4,5,6,7,8,9]
# 3의 배수를 문자열로 처리하고 싶다
# str(x) -> 숫자를 문자열로 변환
# 삼항연산자 사용
print(list(map(lambda x: str(x) if x % 3 == 0 else x, a3)))

print("------------------------------------------------------")

a4 = [1,2,3,4,5]
b4 = [2,4,6,8,10]

print(list(map(lambda x, y : x * y, a4, b4)))

# filter

def func1(x):
    return 5 <= x <= 10

a1 = [8,1,3,4,5,8,10,11,15,12,16]

print(list(filter(func1, a1)))

print(list(filter(lambda x : 5 <= x < 12, a1)))

from functools import reduce
# reduce -> 누적계산
a1 = [1,2,3,4,5]

def func1(x, y) :
    return x+y

# reduce(이미존재하는값, 새로들어오는값)
print(reduce(func1, a1))
# 람다식
print(reduce(lambda x, y : x + y, a1))

def outer_func1(a) :
    hello = "hello outer func1"
    def inner_func1() :
        print(hello)
        return 1

    return inner_func1()



def outer_func2(a):
    hello = a
    return lambda x : hello + ":" + x

inner_func2 = outer_func2("hello")
print(inner_func2("world"))

def func1(a: int) :
    return a + 1

print(func1(1))


def func2(a: int, b: str) -> int: # return 타입을 int로
    return "asdasdsd"

print(func2(1, "asdada"))


def func3(a: list) :
    pass

print(func3())

# 정규 표현식 

import re # regular expression 

str1 = "asdasd 010-1234-5678 asdasdasd"
pattern1 = re.compile("[0-9]{3}-[0-9]{4}-[0-9]{4}")
result = pattern1.findall(str1)
print(result)

def func1(x):
    return x+2

# 리스트 컴프리헨션

# 0~4 까지 각 2를 더한다.
list1 = [2+x for x in range(0,5)]
print(list1)

# 셋 컴프리헨션

# 0~4 까지 각 2를 더한다.
set1 = {2+x for x in range(0,5)}
print(set1)
set1 = {func1(x) for x in range(0,5)}
print(set1)

# 딕셔너리 컴프리헨션
std1 = ['철수','영희','길동','순희'] # std1에 리스트를 넣는다.
std1_comp = {st : 0 for st in std1} # std1에 리스트를 가져와서 for문을 돌리고 : 0 을 값으로 넣는다.
print(std1_comp) # std_comp1 출력한다.

std2 = {"철수" : 80, "영희" : 70, "길동" : 60, "순희" : 50, "히히" : 40}
std_part1 = { name : score for name, score in std2.items() if name == "히히"}
# 히히 빼고 출력
# std_part1 = { name : score for name, score in std2.items() if name != '히히'}
print(std_part1)

# 삼항 연산자 조합
# 1. 네임은 pass
# 2. 네임에서 실제 값이 70 이상 값을 나오면 pass를 출력한다.
# 3. std2.items 에서 name, value를 돌린다.
ispass = {name : 'PASS' if value > 70 else 'Fail' for name, value in std2.items()}
print(ispass)

# <<<<<<<<<<<<<<<<<<함수>>>>>>>>>>>>>>>>>>
# 아무것도 없는 함수
# 매개변수가 있는 함수
# 리턴값이 있는 함수
# 매개변수와 리턴 둘다 있는 함수



# 함수를 선언하기 위해 무조건 필요함
# 괄호는 무조건 줘야함.
def do_something() : # 무엇가를 입련한다.
    print("do_something 함수 호출") # 문자열을 출력하는 함수를 하나 만들었다.
# 함수만으로는 실행이 안된다.
# 해당 기능을 만드는 것까지는 좋았다.
# 다만 호출을 하지 않았기 때문에 발동되지 않음.

# 함수 호출
# 어디서든 필요한 만큼 외부에서 호출하면 된다.
# 함수의 순기능
do_something() # 반드시 () 들어가야함.
do_something() # 반드시 () 들어가야함.
do_something() # 반드시 () 들어가야함.
do_something() # 반드시 () 들어가야함.

# 매개변수 = 실제 호출한 곳에서 받을 수 있도록 만든 변수
# 매개변수는 딕셔너리 패턴으로 저장된다.
# 키로 접근이 가능하다는 얘기네?
# 우리가 넣고자하는 값을 변수에 넣어서 함수를 사용할 수 있게 한다 -> 목적
# 하나의 함수로 굉장히 다양한 variation 결과값을 출력할 수 있다.
def func1(num1):
    print("내가 출력할 숫자는 {} 입니다.".format(num1))

# 매개변수를 통해서 값을 출력할 수 있다.
# variation의 범위가 달라지는 것 -> 함수의 매개변수.
func1(2)
func1(10)
func1(20)
func1(30)
# 아무것도 안넣으면?
# 바로 에러가 난다. 함수가 요구하는 매개변수를 무조건 넣어줘야한다.
# func1()

print("=================================================")
# 매개변수는 복수개의 변수를 설정 가능하다. 원하는 만큼.
# 만약 매개변수가 3개면, 3개의 갯수에 맞춰서 출력값을 호출해야된다.
# 두개의 매개변수 설정하기.
def func2(num1, num2):
    print("내가 출력할 숫자는 {} {} 입니다.".format(num1, num2)) # 두개의 매개변수가 들어간다.

func2(2, 10)

print("=================================================")
# <<<<<<<<<<<Optional Parameter 기능>>>>>>>>>
def func3(num1, num2, num3=4) :
    print("num1 : {}, num2 : {}, num3 : {}".format(num1, num2, num3))

func3(1,2,3)
# 공동 개발시 전역함수의 기능에 대해서 문제가 된다.
# 나는 num3 매개변수가 필요없을 시에는?
# Optional Parameter.
# 데이터가 오지 않을 것을 대비하고, 매개변수에 디폴트로 새로 넣을 수 있다
# 매개변수를 미리 셋팅하는 거임.
func3(9,8) # num1 : 9, num2 : 8, num3 : 4


print("=================================================")
def func4(num1=1, num2=2, num3=3) :
    print("{} {} {}".format(num1, num2, num3))
# 옵셔널 파라미터가 매개변수로 모두 들어가있는 경우에는,
# 아래 처럼 안넣어도된다.
func4()
# 만약 넣으면, 가장 맨앞으로 채워진다.
func4(4)
# 매개변수 이름만으로도 접근이 가능하다.
# 임시메모리형태로 저장이 되니까 반대로 딕셔너리형태인 키로 접근할 수 있다.
# 키 밸류 의 쌍으로 가능하다.
func4(num2=6, num3=7)
# 키를 통해서 접근하기 때문에 매개변수의 순서는 뒤밖여도 상관없다.
func4(num3=7, num2=6)


# <<<<<<<<<<<<<<<<<<<옵셔널 파라미터 특징>>>>>>>>>>>>>>>>>>>>>>>>
# 매개변수에 값을 안넣어서 에러가 난다.
# 강제성 때문에 파이썬 인터프리터가 막는다.
# !!!!!!!!!옵셔널 파라미터를 넣으려면 뒤에서 부터 넣어줘야된다!!!!!!!!!!!!!
# 앞에서부터 넣으면 무조건 에러난다. 파이썬 자체의 금지정책임.
# 아래와 같은 형태는 존재하지 않는다.
# 앞에 있는 것은 강제 해야할 파라미터임.
# 뒤에 있는 것은 선택적인 파라미터임.
# def func5(num1=2, num2=3, num3) :
#     print("asdasddsadas")

def func6(num1, num2, num3=3, num4=4):
    print("{} {} {} {}".format(num1, num2, num3, num4))

func6(4, 7)
# 절대 안됨~!
# func6(num1=4, num3=7)

# 필수 => Named Parameter
# 선택 => Optional Parameter
func6(num1=4, num2=10, num3=7)

from random import *

def do_strike(s1 = 2, s2 = 3, s3 = 4) :
    print("{} {} {}".format(s1, s2, s3))

def do_ball(b1 = 1, b2 = 2, b3 = 3) :
    print("{} {} {}".format(b1, b2, b3))


com= []

while True :
    compute = randint(1, 10)
    com.append(compute)
    print("컴퓨터가 제시한 숫자는 {}".format(compute))
    compute = randint(1, 10)
    com.append(compute)
    print("컴퓨터가 제시한 숫자는 {}".format(compute))
    compute = randint(1, 10)
    com.append(compute)
    print("컴퓨터가 제시한 숫자는 {}".format(compute))
    break

print(com)

print()

numbers = []

while True :
    input_number = int(input("1 부터 10까지 숫자를 입력하세요. : "))
    numbers.append(input_number)
    input_number = int(input("1 부터 10까지 숫자를 입력하세요. : "))
    numbers.append(input_number)
    input_number = int(input("1 부터 10까지 숫자를 입력하세요. : "))
    numbers.append(input_number)
    break

print(numbers)

print()

for i in range(3) :
    if com[i] == numbers[i] :
        print("strike")
    elif com[i] != numbers[i] :
        print("out")








print("===================================================")

from random import *

c = []
while len(c) < 3 :
    s1 = 0
    b1 = 0
    o1 = 1
    cnt1 = 0
    ran1 = randint(2,10)
    if ran1 not in c:
        c.append(ran1)

print("컴퓨터 랜덤 값: {}".format(c))


while s1 != 4 :
    user1 = []
    for i in range(1, 4) :
        user1.append(int(input("{}번째 수를 입력하세요 : ".format(i))))

    for i in range(1, 4) :
        if user1[i] == c[i] :
            s1 += 1
            o1 = 0 # 숫자 하나라도 맞으면 out은 쓸 필요가 없으니까.
        elif user1[i] in c :
            b1 += 1
            o1 = 0

print("{}S {}B {}O".format(s1, b1, o1))

cnt1 += 1


# 반복구간이 끝나게 되었을 시 이닝 종료라는 문구를 출력.
# 몇번에 걸쳐서 3S가 되었는지 출력.
print("{}회 만에 이닝 종료".format(cnt1))






# 로직 -
# - 초기값 설정
# 컴퓨터가 3개의 랜덤한 값을 입력 받아 리스트에 저장한다.
    # 겹치는 숫자가 있을 경우 해당 숫자를 넣지 않고 다시 재굴림.
# 스트라이크, 볼, 아웃을 저장하는 변수가 각각 하나씩 생성

# 로직 실행 -
# 반복구간 시작 -> 3S가 될 때까지
    # 유저가 3개의 값을 입력받는다.
        # 1~9 수를 리스트에 입력받아서 저장

    # 비교해서 결과를 출력
        # 1. 사용자가 입력한 리스트의 각 위치와 숫자를, 컴퓨터의 리스의 숫자와 위치를 비교해서
        # 하나라도 맞으면 스트라이프를 카운트한다.
        # 2. 사용자가 입력한 리스트 내부의 3개의 값 중 하나라도 리스트 안에 들어가 있으면 ball을 카운트한다.
        # 3. 사용자가 입력한 값이 리스트 내에 단 한개도 없다면, out 카운트.
        # 4. 스트라이크 볼 아웃을 출력하고 초기화.
# 반복구간 끝

# func1 a - 3, b - 4, c - 5

# 함수 입력 파라미터를 몇개인지 모를 때, *(아스타링크) 을 쓴다.
# <<<<<<<<<<<<<<<<<<<<<<<가변 길이 파라미터>>>>>>>>>>>>>>>>>>>>>>>
def do_sum(*numbers):
    total = 0
    print(numbers)
    for n in numbers : # 리스트 또는 튜플로 들어온다.
        total += n
    print(total)

# !!파라미터가 얼마만큼의 숫자를 받을 수 있는지는 모른다.!!
# 하지만 형식만 맞게 만드면, 이런 방식도 가능하다.
do_sum(1,2,3,4,5,6,7,8)
do_sum(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
# 튜플로 출력된다.
# 잘 안쓰이는 방식임.

print("================================================")
# 이방식을 더 사용한다.
# 언패킹 방식
def do_sum2(a,b,c):
    print(a+b+c)
# 리스트 언패킹
x1 = [10, 20, 30]
do_sum2(*x1)   # 각각에 있는 매개변수에 들어가게 한 후 수행시킴.

# 튜플 언패킹
x2 = (10, 20, 30)
do_sum2(*x2)   # 각각에 있는 매개변수에 들어가게 한 후 수행시킴.

def get_personal_info(name, age, address):
    print("이름 : ", name)
    print("나이 : ", age)
    print("주소 : ", address)

# set 언패킹
set1 = {"김아무개", 37, "경기도"}
get_personal_info(*set1)

print("================================================")
# 딕셔너리 언패킹 1
dic1 = {"name" : "김아무개", "age" : 40, "address": "서울시"}
get_personal_info(*dic1)


print("================================================")
# 딕셔너리 언패킹 2
# 순서는 책임 안져.
get_personal_info(*dic1.values())

print("================================================")
# 딕셔너리 언패킹 3
# 순서 해결
# ** 두개를 넣으면
# 파라미터의 순서에 맞춰서 알아서 들어감.
# 파라미터의 순서를 신경 쓸 필요가 전혀 없음!!!!!!!!!!!!!!!!!!
dic2 = {"age" : 40, "address": "서울시", "name" : "김아무개"}
get_personal_info(**dic2)

print("================================================")
def get_personal_info2(**kwargs):
    print(kwargs)
    for kw, arg in kwargs.items() :
        print("{} : {}".format(kw, arg))

# dic을 넣으면 되잖아? 근데 **kwargs 를 왜써?

dic3 = {"age" : 50, "address": "울산시", "name" : "이아무개"}
get_personal_info2(**dic3) # 이정도만 써도 아주 굿

# 가변데이터 (원자형) 를 받아서 출력
# 실제 받는 함수는 딕셔너리 형태임.
# 따라서 포맷은 딕셔너리 형태로 출력됨.
# !!!!!!!!!!!!!!!!!재활용성이 좋아진다!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
get_personal_info2(name="박아무개", age="55", address="경기도 시흥시")

def func1(a,b,c, **kwargs): # 딕셔너리형태로 매개변수 받기
    print(a)
    print(b)
    print(c)
    print(kwargs)

# 함수의 매개변수와 겹치면 안됨.
dic1 = {"a1":1, "b1":2, "c1":3}
func1(1,2,3, **dic1)

func1(1,2,3, a1="aaa", b1="bbb")


def func2(*args, **kwargs):
    print(*args)
    print(kwargs)

# 리스트 언패킹과 딕셔너리 언패킹을 함께 쓰고 싶을 때.

func2(1,2,3, **dic1)
# 1 2 3
# {'a1': 1, 'b1': 2, 'c1': 3}


print("=====================================================")

# 가변인자와 매개변수를 같이 출력하고 싶을 떄
def func3(a,*args):
    print(a)
    print(*args)

func3(1)
func3(1,2,3)
func3(*[10,20,30])