2025.01.10 TGIF~

 

 

 

 

 

 

 

 

 

 

 

¶

 

In [2]:

#offset: 상대주소; 기준이 되는 주소가 얼마나 떨어져 있는지
#Math Case문
#Match문: 패턴 매칭을 통해 값을 비교하고 실행 코드를 선택하는데 사용
#Case문: Match문 내에서 특정 패턴에 대한 처리를 정의하는데 사용

 

In [6]:

def classify_number(n):
    math n:
        case 0:
            print("Zero")
        case 1 | 2 | 3:
            print("Small number")
        case 4 | 5 | 6 | 7 | 8 | 9:
            print("Big number")
        case_:
            print('Other number')
    

 

 

  Cell In[6], line 2
    math n:
         ^
SyntaxError: invalid syntax

 

In [7]:

class MyClass():
    class_ver = "클래스 변수"

    @classmethod
    def class_method(cls):
        print('클래스의 매소드')

    def instance_method(self):
        self.instance_var = '인스턴스 변수'
        print('인스턴스의 매소드')

 

In [9]:

#class
#인스턴스(instance): 클래스가 실질적으로 객체를 만들었을 때 그 객체를 부르는 용어

class Myclass():
    pass #클래스를 선언

a = MyClass()
b = MyClass()
c = MyClass()
#함수처럼 call하여 사용

print(a, b, c)
#객체(object)생성

 

 

<__main__.MyClass object at 0x000001F135181F40> <__main__.MyClass object at 0x000001F135181A90> <__main__.MyClass object at 0x000001F135182840>

 

In [11]:

#인스턴스(instance)
# 클래스가 실질적으로 객체를 만들었을 때 그 객체를 부르는 용어
# 1.instance variable(인스턴스 변수): instance고유의 변수
#2. instance method(인스턴스 메소드): 인스턴스에 적용되는 함수

class Account():
    def make_account(self):
        self.balance = 0

    def deposit(self, money):
        self.balance += money

    def draw(self, money):
        self.balance -= money

#class를 선언

 

In [12]:

a1 = Account()
a1.make_account()
a1.deposit(1000)
print(a1.balance)

 

 

1000

 

In [14]:

#instance method
#인스턴스 메소드의 매개변수 중 가장 첫번째는 인스턴스의 자리

class person():
    def __init__(self):
        self.age = 17

p1 = person()
p1.age

 

Out[14]:

17

 

In [27]:

class TestClass1():
    def __init__(self, in1, in2): #in1과 in2는 인스턴스 메소드의 매개변수
        self.v1 = in1
        self.v2 = in2

 

In [28]:

t_cls1 = TestClass1(10,20)

 

In [31]:

#__init__(초기화자): 인스턴스가 생성될 때, 객체의 초기값을 설정하는 메소드로, 자동으로 호출됨
#__del__(소멸자): 인스턴스가 소멸될 때, 자동으로 호출되는 메소드

t_cls1.v1 #초기화자를 통해서 객체의 초기값을 자동으로 설정

 

Out[31]:

10

 

In [35]:

###인스턴스###

class test():
    name = '아무나'
    age = 0
    def __init__(self, name, age):
        print('생성자 호출!')
        self.name = name
        self.age = age
    def __del__(self):
        print('소멸자 호출!')
    def info(self):
        print('나의 이름은', self.name, '입니다!')
        print('나이는', self.age, '입니다!')

 

In [37]:

r = test('류영표',7)

 

 

생성자 호출!
소멸자 호출!

 

In [38]:

r.info()

 

 

나의 이름은 류영표 입니다!
나이는 7 입니다!

 

In [39]:

test('류영표', 7)

 

 

생성자 호출!

Out[39]:

<__main__.test at 0x1f135f162d0>

 

In [40]:

test_info()

 

 

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[40], line 1
----> 1 test_info()

NameError: name 'test_info' is not defined

 

In [43]:

class ClassExample:
    def __init__(self,name,age): #생성자 생성 시 자동 수행
        self.name = name
        self.age = age + 5 #변수 생성 후 파라미터로 보낸 값 할당
        print('[생성자] self와 변수 비교 ' + str(self.age) + 'age : ' + str(age))
        print('[생성자] 이름 : ' + self.name + ' 나이 : ' + str(self.age))
    def ten_year_call(self, val): #함수
        return self.age + 10 #반환

 

In [44]:

 a = ClassExample('철수', 20) #객체화 (ClassExample의 정보를 a에 담음)
print(a.age) #a의 age출력
print(a.ten_year_call(50)) #a의 ten_year_call 메소드 수행

 

 

[생성자] self와 변수 비교 25age : 20
[생성자] 이름 : 철수 나이 : 25
25
35

 

In [48]:

#객체 슬라이싱과 __getitem__

class CustomNumbers:
    def __init__(self):
        self._numbers = [n for n in range(1,11)]

a = CustomNumbers()

a._numbers[2:5] #instance에 접근을 해야 댐 

 

Out[48]:

[3, 4, 5]

 

In [49]:

#객체 슬라이싱과 __getitem__
#인스턴스 변수에 직접 접근하지 말고 객체 자체를 통해서 슬라이싱을 구현하기 위해서는 __getitem__ 특별 메서드를 정의해야 함

class CustomNumbers:
    def __init__(self):
        self._numbers = [n for n in range(1,11)]

    def __getitem__(self, idx):
        return self._numbers[idx]

a = CustomNumbers()
a[2:7]

 

Out[49]:

[3, 4, 5, 6, 7]

 

In [51]:

#메소드 오버라이딩(method overriding)

    
class Korea:

    def __init__(self, name, population, captial):
        self.name = name
        self.population = population
        self.captial = captial

    def show(self):
        print(
            """
            국가의 이름은 {} 입니다.
            국가의 인구는 {} 입니다.
            국가의 수도는 {} 입니다.
            """.format(self.name, self.population, self.capital)

        )

    def show(self, abc):
        print('abc : ', abc)

 

In [54]:

#Class Variable 과 Class Method
#1. class variable(클래스 변수): 클래스와 인스턴스 전체가 공유하는 변수
#2. class method(클래스 메소드): 클래스와 인스턴스 전체가 공유하는 함수

#인스턴스와 상관없이 사용(인스턴스가 없어도 사용 가능) 클래스와 인스턴스 전체에 공유됨

class MyClass2():
    class_var = '클래스 변수'

    @classmethod #데코레이터(decorator): wrapping을 통해 특정 코드를 재사용할 수 있게 해주는 역할
    def class_method(cls): #cls: 클래스를 위한 placeholder(self와 유사한 역할)
        print('클래스의 메소드')

 

In [57]:

#인스턴스.변수 클래스이름.변수 인스턴스.메소드 클래스이름.메소드
#=> 같은 방식으로 클래스 변수와 클래스 메소드를 사용할 수 있음

e = MyClass2()
print(e.class_var)
print(MyClass2.class_var)

 

 

클래스 변수
클래스 변수

 

In [58]:

e.class_method()
MyClass2.class_method()

 

 

클래스의 메소드
클래스의 메소드

 

In [59]:

class Account2():
    bank = '모두은행'
    total = 0

    @classmethod
    def merge(cls, acc1, acc2):
        cls.total = acc1.balance + acc2.balance
        print('당신의 재산은 %d' %cls.total)

    def __init__(self):
        self.balance = 0

    def deposit(self, money):
        self.balance += money

    def draw(self, money):
        self.balance -= money

 

In [60]:

Account2.bank

 

Out[60]:

'모두은행'

 

In [61]:

b1 = Account2()
b1.deposit(4000)
print(b1.balance)
print(b1.bank)

 

 

4000
모두은행

 

In [62]:

b2 = Account2()
b2.deposit(7000)
print(b2.balance)
print(b2.bank)

 

 

7000
모두은행

 

In [63]:

Account2.merge(b1, b2)

 

 

당신의 재산은 11000

 

In [64]:

Account2.total

 

Out[64]:

11000

 

In [65]:

class Hotel():
    def __init__(self):
        self.room = []

    def add_person(self, name):
        self.room.append(name)

 

In [66]:

r1 = Hotel()
r2 = Hotel()

r1.add_person('뽀로로')
r2.add_person('펭수')

 

In [69]:

r1.room

 

Out[69]:

['뽀로로']

 

In [70]:

r2.room

 

Out[70]:

['펭수']

 

In [73]:

class GuestHouse():

    guest = []

    def __init__(self):
        self.room = []

    @classmethod
    def check_in(cls, name):
        cls.guest.append(name)

    def add_person(self, name):
        self.check_in(name)
        self.room.append(name)

 

In [74]:

r3 = GuestHouse()
r4 = GuestHouse()

r3.check_in('뚝딱이')
r4.check_in('뿡뿡이')

 

In [75]:

GuestHouse.guest

 

Out[75]:

['뚝딱이', '뿡뿡이']

 

In [76]:

r3.room

 

Out[76]:

[]

 

In [77]:

r4.room

 

Out[77]:

[]

 

In [78]:

r3.add_person('홍길동')
r4.add_person('텔레토비')

 

In [79]:

r3.room

 

Out[79]:

['홍길동']

 

In [80]:

r4.room

 

Out[80]:

['텔레토비']

 

In [81]:

GuestHouse.guest

 

Out[81]:

['뚝딱이', '뿡뿡이', '홍길동', '텔레토비']

 

In [83]:

#클래스 상속(Inheritance)
#상속: 부모의 클래스를 물려받음 => 부모 클래스가 가지고 있는 함수/변수를 그대로 사용
#상속의 장점: 기존 클래스를 변형하지 않고 추가/변경이 가능함

 

In [84]:

class MyPhone():
    def __init__(self, model, color):
        self.model = model
        self.color = color

    def set_name(self, name):
        self.user = name
        print('사용자의 이름은 : %s' %self.user)

    def set_number(self, number):
        self.number = number



class MyPhone2(MyPhone): #상속받고자 하는 클래스(부모 클래스(super class)
    def has_case(self, val=False): #자식 클래스(sub class)의 새로운 메소드)
        self.case = val

 

In [85]:

p2 = MyPhone2('iphon', 'red')

 

In [87]:

p2.set_name("MJ") #부모 클래스의 메소드 사용 가능

 

 

사용자의 이름은 : MJ

 

In [88]:

p2.has_case(True)

 

In [89]:

p2.case

 

Out[89]:

True

 

In [92]:

p1 = MyPhone('iphone', 'blue')
p1.set_number('010-xxxx-xxxx')

 

In [93]:

class MyPhone3(MyPhone):
    def set_number(self, num):
        self.number = num
        print('이 핸드폰의 번호는 : %s' %self.number)

 

In [94]:

p3 = MyPhone3('iphone', 'red')
p3.set_number('010-xxxx-dddd')

 

 

이 핸드폰의 번호는 : 010-xxxx-dddd

 

In [90]:

#메소드 오버라이딩

 

In [91]:

#상속을 받은 자식클래스가 상속해 준 부모 클래스의 메소드를 변형하는 방법
#원본(부모 클래스)의 소스코드는 그대로 유지한 채 소스코드를 확장, 개인화 할 수 있다는 장점이 있음

 

In [98]:

###1번
#Human이라는 클래스를 만들어보자.
#Human 클래스는 아래와 같은 특징이 있다.
#Human 클래스는 인스턴스 생성 시 birth_date, sex, nation을 변수로 가지고 있다.
#give_name은 인스턴스 메소드로 이름을 input으로 받아서 
##name이라는 인스턴스 변수로 저장하고 화면에 이름을 출력하는 역할을 하는 함수
#can_sing이라는 함수는 True/False값을 input으로 받으며, 참이면 'Sing a song'을 화면에 출력하는 함수

class Human():
    def __init__(birth_date, sex, nation):
        self.birt_date = birth_date
        self.sex = sex
        self.nation = nation
    
    def give_name(self, name):
        self.name = name
        print(name)

    def can_sing(self, val=False):
        if val:
            print('Sing a song')

 

In [100]:

#Human이라는 클래스를 상속하는 Child라는 클래스를 만들기
#Child의 클래스에는 아래와 같은 변수와 함수들이 추가된다.
#눈동자 색깔을 나타내는 변수 eye를 인스턴스 선언시 사용할 수 있게 추가
#Child의 클래스는 노래하는 능력이 없다. 따라서 can_sing이라는 메소드가 호출되면 무조건 'Can't Sing'으로 출력
#Child는 노래 대신 춤을 출 수 있다. can_dance라는 메소드가 호출되면 'Dance Time!'을 출력

 

In [104]:

class Child(Human):
    def __init__(self, birth_date, sex, nation, eye):
        super().__init__(birth_date, sex, nation)
        self.eye = eye  # eye 변수 추가

    def can_sing(self, val=False):  # 부모 클래스의 메소드 시그니처와 동일하게 유지
        print("Can't Sing")

    def can_dance(self):
        print("Dance Time!")

# 테스트
ch = Child(20003, "F", "한국", "black")
ch.can_sing()      # "Can't Sing" 출력
ch.can_dance()     # "Dance Time!" 출력

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[104], line 13
     10         print("Dance Time!")
     12 # 테스트
---> 13 ch = Child(20003, "F", "한국", "black")
     14 ch.can_sing()      # "Can't Sing" 출력
     15 ch.can_dance()

Cell In[104], line 3, in Child.__init__(self, birth_date, sex, nation, eye)
      2 def __init__(self, birth_date, sex, nation, eye):
----> 3     super().__init__(birth_date, sex, nation)
      4     self.eye = eye

TypeError: Human.__init__() takes 3 positional arguments but 4 were given

 

In [106]:

# super().__init__() 호출 시, Python은 부모 클래스의 __init__ 메소드를 호출합니다.
# 부모 클래스(Human)의 __init__ 메소드가 올바르게 정의되어 있어야 합니다.
# self를 제외한 정확한 수의 인자를 전달해야 합니다.

 

In [105]:

class Human():
    def __init__(self, birth_date, sex, nation):
        self.birth_date = birth_date
        self.sex = sex
        self.nation = nation
    
    def give_name(self, name):
        self.name = name
        print(name)
    
    def can_sing(self, val=False):
        if val:
            print('Sing a song')

class Child(Human):
    def __init__(self, birth_date, sex, nation, eye):
        super().__init__(birth_date, sex, nation)
        self.eye = eye

    def can_sing(self, val=False):
        print("Can't Sing")

    def can_dance(self):
        print("Dance Time!")

# 테스트
ch = Child(20003, "F", "한국", "black")
ch.can_sing()      # "Can't Sing" 출력
ch.can_dance()     # "Dance Time!" 출력

 

 

Can't Sing
Dance Time!

 

In [107]:

for _ in ['11', 'number']:
    try:
        int(_)
    except ValueError as m:
        print(m)
    else:
        print('No Error!')
    finally:
        print('Finally Code')
    print('\n')

 

 

No Error!
Finally Code


invalid literal for int() with base 10: 'number'
Finally Code

 

In [109]:

#에러를 직접 일으키는 방법

#190이 넘는 학생을 발견하면 반복을 종료한다
school = {'1반' : [150, 156, 179, 191, 199],'2반' : [150, 195, 179, 191, 199]}

try:
    for class_number, students in school.items():
        for student in students:
            if student > 190:
                print(class_number, '190을 넘는 학생이 있습니다.')
                #break #바로 상위 for문은 종료되지만, 최고 상위 for문은 종료되지 않는다.
                raise StopIteration
                #예외가 try문 안에 있지 않으면 에러 발생시 프로그램이 멈춘다.

except StopIteration:
    print('정상종료')

 

 

1반 190을 넘는 학생이 있습니다.
정상종료

 

In [110]:

a = 10

#True인 경우
print("1. assert True인 경우")
assert a ==0, "a is not 10"

print("끝1")

#False인 경우
print("2. assert False인 경우")
assert a == 999, "a is not 999"

print("끝2")

 

 

1. assert True인 경우

 

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Cell In[110], line 5
      3 #True인 경우
      4 print("1. assert True인 경우")
----> 5 assert a ==0, "a is not 10"
      7 print("끝1")
      9 #False인 경우

AssertionError: a is not 10

 

In [113]:

c = 0
d = 1

while (d==1):
    a = input('값을 입력해주세요')
    try:
        if (a=='s' or a=="S"):
            d = 0 #break
        else:
            a = int(a)
            c +=a
    except:
        continue
print('합계는', c)

 

 

 

합계는 3

 

 

 

 

---

빅데이터 분석을 위한 수학

선형대수학(Linear Algebra)

• 선형대수학은 기계공학,  통계학, 수학, 전자공학 등 다양한 학문의 기초과목이다. 수많은 학문의 토대
• 선형+대수학
  • 선형: 1차
  • 대수학: 방성직을 푸는 것

 

선형성(linearity)란?

집합의 원소에 상수를 곱하여 더한 선형 결합이 집합 A에 속하는 경우: 선형

 

---