251002 TIL

Numpy 연산

# numpy 모듈 기반 배열 연산

ls1 = [82, 76, 91, 65]

# 문제) ls1 각 요소에 2씩 더하기
# -> [84, 78, 93, 67]

ls2 = []
for idx in range(4):
    ls2.append(ls1[idx] + 2)

print(ls2)  # [84, 78, 93, 67]

# 문제) 인덱스가 동일한 각 요소끼리 더해서 ls5에 저장
ls3 = [10, 15, 20, 25, 30]
ls4 = [2, 3, 4, 5, 6]
ls5 = [0, 0, 0, 0, 0]

i = 0
for idx in range(5):
    ls5[idx] = ls3[idx] + ls4[idx]

print(ls5)  # [12, 18, 24, 30, 36]
#################################################################

import numpy as np

grade = np.array([82, 76, 91, 65])
print(grade)

# new1 = ls1 + 2 -> 에러

new1 = grade + 2  # 각 요소에 2씩 더함
print(grade)  # [84, 78, 93, 67]

new2 = grade - 5  # 각 요소에 5씩 뺌
print(new2)  # [77 71 86 60]

arr1 = np.array([10, 15, 20, 25, 30])
arr2 = np.array([2, 3, 4, 5, 6])

arr3 = arr1 + arr2  # 인덱스가 동일한 요소끼리 더하기
print(arr3)  # [12, 18, 24, 30, 36]

arr4 = arr2 - arr1
print(arr4)  # [ -8 -12 -16 -20 -24]

# 집계함수
aver = np.array([82, 76, 91, 65])
print("총점 : %d" % np.sum(aver))  # 314
print("평균 : %d" % np.average(aver))  # 78
print("최대값 : %d" % np.max(aver))  # 91
print("최소값 : %d" % np.min(aver))  # 65
#################################################################

# numpy 모듈을 활용한 정형화된 배열 만들기
a = np.arange(15)
print(a)  # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

b = np.arange(100, 115)
print(b)  # [100 101 102 103 104 105 106 107 108 109 110 111 112 113 114]
print(len(b))  # 15

# 모든 요소가 실수형
c = np.zeros(3)
print(c)  # [0. 0. 0.]

d = np.zeros(4, dtype="int")
print(d)  # [0 0 0 0]

e = np.ones(3)
print(e)  # [1. 1. 1.]

f = np.ones(4, dtype="int")
print(f)  # [1 1 1 1]

g = np.full(5, 7)
print(g)  # [7 7 7 7 7]

h = np.full(4, 7, dtype="float")
print(h)  # [7. 7. 7. 7.]

함수

# 참조 https://www.w3schools.com/python/python_functions.asp

# 1. Arguments와 Keyword Arguments
# -> Argument 전달값, 보내는 값
# -> Parameter 받는값
# -> 함수 선언시 파라미터의 수를 특정할 수 없을 경우 사용
# -> keyword arguments의 경우 아규먼트로 함수 호출 시 키워드를 작성하여 호출
# -> arguments는 튜플 타입
# -> keyword arguments는 딕셔너리 타입

## 1) Arguments, *args
def test1(fname, lname):
    print(fname + " " + lname)

test1("손", "흥민")  # 손 흥민
# test1("김") TypeError: test1() missing 1 required positional argument: 'lname'

def test2(*names):
    print(names)
    print(type(names))  # 튜플
    print(len(names))
    # 맨 마지막 요소값 출력
    print(names[-1])

test2("개나리", "진달래", "무궁화", "라일락", "코리아")
# ('개나리', '진달래', '무궁화', '라일락', '코리아')
# <class 'tuple'>
# 5
# 코리아

## 2) Keyword Arguments, **Kwargs
def test3(**phones):
    print(phones)
    print(type(phones))  # 딕셔너리
    print(phones["phone3"])

test3(phone1="123", phone2="456", phone3="789")
# {'phone1': '123', 'phone2': '456', 'phone3': '789'}
# <class 'dict'>
# 789

## 3) *args와 **kwargs
def hap(*args, **kwargs):
    print(type(args), args)
    print(type(kwargs), kwargs)
    return sum(args) + sum(kwargs.values())

print(hap(1, 2, 3, 4, num1=5, num2=6))
# <class 'tuple'> (1, 2, 3, 4)
# <class 'dict'> {'num1': 5, 'num2': 6}
# 21

## 4) list 타입 데이터를 args로 호출하는 방법
def gop(n1, n2, n3):
    return n1 * n2 * n3

ls = [2, 3, 4]
print(gop(ls[0], ls[1], ls[2]))  # 24
print(gop(*ls))  # 24

# 주의사항 : list 요소의 갯수와 파라미터의 갯수가 일치해야 함
ls2 = [2, 3, 4, 5]
# gop(*ls2)   TypeError: gop() takes 3 positional arguments but 4 were given

def hap2(*args):
    return sum(args)

ls3 = [3, 4, 5, 6]
print(hap2(*ls3))  # 18

데코레이터

# 참조 https://www.w3schools.com/python/python_decorators.asp

# 2. Decorators
# -> 함수의 코드를 변경하지 않고도 함수에 추가 동작을 추가할 수 있다
# -> 다른 기능을 입력으로 받아 새로운 기능을 반환하는 기능
# -> 선언) @함수이름

## 1) 함수안에 함수가 선언되는 경우 (inner function)
## -> 함수를 지역영역에 선언
## -> 함수 안에 함수

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

    return inner(a, b)

print(outer(1, 2))  # 3
# inner(1, 2) NameError: name 'inner' is not defined.

## 외부에서 inner function 접근
def outer2():
    def inner(c, d):
        return c + d

    return inner

print(outer2()(3, 4))  # 7

## 2) @decorator_name
def changecase(fn):
    def myinner():
        print("start...")
        res = fn().upper()
        print(res)
        print("end...")

    return myinner

@changecase
def myfunction():
    return "Hello Python"

myfunction()
# start...
# HELLO PYTHON
# end...

## 예제) password가 일치하면 연산이 가능하고, 그렇지 않으면 로그인실패 출력하는 decorator 만들기
def checkPassword(fn):
    def wrapper(*args, **kwargs):
        pw = "itwill"
        login = input("비밀번호 : ")
        if login == pw:
            return fn(*args, **kwargs)
        return "로그인 실패"

    return wrapper

@checkPassword
def hap(a, b):
    return a + b

print(hap(3, 4))

클래스

# 참조
# https://www.w3schools.com/python/python_oop.asp
# https://www.w3schools.com/python/python_classes.asp

# 객체 지향 프로그램 (Object Oriented Progarm)
# 클래스(class, 사용자 정의 자료형)와 객체(Object)
# 클래스명의 첫글자는 대부분 대문자로 한다
"""
class 클래스명:
    멤버변수
    멤버함수()
"""

# 클래스 선언
class Member:
    userid = "python"
    email = "webmaster@itwill.com"
    phone = "0269017010"

a = 3  # a는 변수

# Member() 생성자 함수(Constructor)
# -> 클래스명과 동일한 함수
mem1 = Member()  # mem1 -> 객체(Object) 선언

# . 연산자를 이용해서 멤버에 접근
# 객체명.멤버
print(mem1.userid)
print(mem1.email)
print(mem1.phone)

mem2 = Member()
print(mem2.userid)
print(mem2.email)
print(mem2.phone)

# 2) 멤버함수를 포함하는 클래스 정의
# ->클래스내에 선언된 함수(멤버함수)들은
# ->반드시 첫번째 파라미터 self를 정의해야 한다
class Calc:
    def plus(self, x, y):
        return x + y

    def minus(self, x, y):
        return x - y

    def all(self, x, y):
        a = self.plus(x, y)
        b = self.minus(x, y)
        return a, b

calc = Calc()
print(calc.plus(2, 4))  # 6
print(calc.minus(2, 4))  # -2
print(calc.all(2, 4))  # (6, -2)

x = calc.all(6, 8)
print(x)  # (14, -2)
print(x[0])  # 14
print(x[1])  # -2

i, j = calc.all(6, 8)
print(i)  # 14
print(j)  # -2

# 3) 멤버변수(field, column)와 멤버함수(method)를 모두 내장하는 클래스 정의
class User:
    # 멤버변수의 유효범위는 클래스 내부에서는 모두 접근가능
    username = ""
    email = ""

    def join(self, username, email):  # 매개변수와 멤버변수는 이름이 동일해도 된다
        self.username = username  # slef.멤버변수 = 매개변수
        self.email = email

    def disp(self):
        print(self.username)
        print(self.email)

# 객체 선언
user1 = User()
user1.join("user1", "user1@itwill.co.kr")
user1.disp()

user2 = User()
user2.join("user2", "user2@itwill.co.kr")
user2.disp()
#######################################################################################

# 4) 성적 클래스
class Sungjuk:
    # 멤버변수
    uname = ""
    kor = 0
    eng = 0
    mat = 0
    aver = 0

    # 멤버함수
    def init(self, uname, kor, eng, mat):  # 이름, 국, 영, 수 값을 전달받는 함수
        self.uname = uname
        self.kor = kor
        self.eng = eng
        self.mat = mat
        self.aver = sum((kor, eng, mat)) / 3

    def disp(self):
        print(f"{self.uname} {self.kor} {self.eng} {self.mat} {self.aver:.2f}")

stu1 = Sungjuk()
stu1.init("손흥민", 90, 85, 90)
stu1.disp()  # 손흥민 90 85 90 88.33

stu2 = Sungjuk()
stu2.init("김연아", 50, 40, 60)
stu2.disp()  # 김연아 50 40 60 50.00

stu3 = Sungjuk()
stu3.init("박지성", 75, 85, 95)
stu3.disp()  # 박지성 75 85 95 85.00

생성자와 소멸자

# 생성자와 소멸자

# 1. 생성자 함수 Constructor
# ->생성자 함수는 클래스를 이용해서 객체를 생성할 때 사용한다
# ->클래스명과 동일한 함수이름으로 호출한다

## 1) 매개변수가 없는 생성자 함수
class Member:
    uname = None
    email = None

    # 생성자 함수. init 앞뒤로 언더라인 2개
    # 객체 생성할 때 Member()라는 이름으로 호출된다
    # 기본생성자 함수 default constructor
    def __init__(self):
        # pass 함수 안에 아무 내용도 없을 때
        print("Member() 생성자 함수 호출됨")
        self.uname = "손흥민"
        self.email = "son@itwill.com"

    def disp(self):
        print(f"이름: {self.uname} / 이메일: {self.email}")

mem1 = Member()  # Member() 생성자 함수 호출됨
mem1.disp()  # 이름: 손흥민 / 이메일: son@itwill.com

mem2 = Member()
mem2.disp()

## 2) 매개변수가 있는 생성자 함수
class User:
    uname = None
    email = None

    def __init__(self, uname, email):
        print("매개변수가 있는 User() 생성자 함수 호출됨")
        self.uname = uname
        self.email = email

    def disp(self):
        print(f"이름: {self.uname} / 이메일: {self.email}")

user1 = User("김연아", "kim@itwill.com")  # 매개변수가 있는 User() 생성자 함수 호출됨
user1.disp()  # 이름: 김연아 / 이메일: kim@itwill.com

user2 = User("박지성", "park@itwill.com")
user2.disp()

# 2. 소멸자 Destructor
# -> 메모리에서 객체를 소멸할 때 자동으로 호출되는 함수
class Student:
    uname = None
    email = None

    def __init__(self, uname, email):
        print("매개변수가 있는 Student() 생성자 함수 호출됨")
        self.uname = uname
        self.email = email

    def disp(self):
        print(f"이름: {self.uname} / 이메일: {self.email}")

    def __del__(self):
        print("소멸자 함수 호출됨...")

stu1 = Student("라일락", "ra@itwill.com")
stu1.disp()

stu2 = Student("무궁화", "mu@itwill.com")
del stu2  # stu2 객체 강제 삭제
# stu2.disp()  # NameError: name 'stu2' is not defined.