초롱스쿨

넘파이에서 ndarray 내의 일부 데이터 세트나 특정 데이터만을 선택할 수 있도록 하는 인덱싱에 대해 알아보자

1. 특정 데이터만 추출 : 원하는 위치의 인덱스 값을 지정하면 해당 위치의 데이터 반환됨

array1 = np.arange(10)  # [ 0 1 2 3 4 5 6 7 8 9 ]
print(array1[2])        # 2
print(array1[-1])       # 9

array1[0] = 10
print(array1)           # [ 10 1 2 3 4 5 6 7 8 9 ]

- 인덱스값을 [] 괄호 안 인덱스로 접근 할 수 있다. 그리고 파이썬과 같이 - 가 되면 뒷쪽부터 접근하게 된다.

- 특정 인덱스의 값을 변경하고 싶을 시 ndarray[index]  = 값 을 통해 변경 가능

2. 슬라이싱(Slicing) : 슬라이싱은 연속된 인덱스상의 ndarray를 추출하는 방식. ':' 기호 사이에 시작 인덱스와 종료 인덱스를 표시하면 시작인덱스에서 종료인덱스-1 위치에 있는 데이터의 ndarray를 반환합니다. 예를 들어 1:5라고 하면 시작 인덱스 1과 종료 인덱스 4까지에 해당하는 ndarray를 반환함

array1 = np.arange(start=1, stop=10)  # [1 2 3 4 5 6 7 8 9 ]

print(array1[0:3])
print(array1[:3])

print(array1[3:])
print(array2[:])

- start와 stop을 통해서 1 ~ 9까지 값을 가진 ndarray를 가진 array1

- 결과값

* 첫번째와 두번째는 같은 결과를 나타낸다.

* 다음은 2차원 배열에서 접근 방법을 나타낸다

3. 팬시 인덱스(Fancy indexing) : 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 데이터의 ndarray를 반환함

array1d = np.arange(start=1,stop=10).reshape(3,3)

print(array1d[[0,1],2].tolist())
print(array1d[[0,1],0:2].tolist())
print(array1d[[0,1]].tolist())

- array1d => [[1 2 3] [4 5 6] [7 8 9]]

- 결과값

  [3 6]    => 0행과 1행 + 2열

  [[ 1 2 ] [4 5]]    => 0행과 1행 + 0열 ~ 1열

  [[ 1 2 3 ] [ 4 5 6 ] [ 7 8 9 ]]     => 0행과 1행 + 모든 열

4. 불린 인덱싱(Boolean indexing) : 특정 조건에 해당하는지 여부인 True/False 값 인덱싱 집합을 기반을 기반으로 True에 해당하는 인덱스 위치에 있는 데이터의 ndarray를 반화함

array1d = np.arange(3)             # 0 1 2
array1d > 1                        # false false true
print(array1d[array1d > 1])        # [2]

- 조건에 만족하는 것을 확인하기 위해 사용하며, ndarray[ndarray에 비교할 조건식]으로 사용

앞 게시글에서는 넘파이의 기본과 np.array() 를 통해 생성하는 것을 학습하였다.

이번 게시글에서는 ndarray에서 지원하는 다양한 함수를 볼 것이다.

ndarray를 생성하는 numpy 함수들 사용할 때는 np.함수명으로 사용하다.

자료형이 명시 되지 않는 경우,

• 많은 numpy tutorial에서는 보통 float64가 될 것이라 하지만,
• numpy 구현체의 버전에 따라 일치하지 않는데,
• numpy 최신버전에서는 제시된 자료형을 담을 수 있는 최소 size의 자료형으로 정해진다고 document에서는 명시한다.

함수설명

1. arange() : 파이썬의 표준 함수인 range() 와 유사한 기능으로 array를 range()로 표현하는 것

sequence_array = np.arage(10)
pirnt(sequence_array)

- 파이썬처럼 0부터 n-1까지의 숫자를 넣어주기 때문에 출력값은 [ 0 1 2 3 4 5 6 7 8 9] 으로 나오게 된다.

- 기본 함수는 arange([start,] stop[, step,], dtype=None) 로 default 값이 stop이기 때문에 stop = 10이 되어 자동으로 0부터 시작하게 된다.

2. zeros() : 함수 인자로 튜플 형태의 shape 값을 입력하면 모든 값을 0으로 채운 해당 shape를 가진 ndarray를 반환함

zero_array = np.zeros((3,2), dtype='int32')
print(zero_array)
print(zero_array.dtype)

- [[ 0 0 ] [ 0 0 ] [ 0 0 ]] -> 0으로 채워진 (3,2) ndarray 반환

- int32 -> np.zeros() 함수를 통해 dtype 으로 설정한 값으로 나오게 됨

3. ones() : 함수 이자로 튜플 형태의 shape 값을 입력하면 모든 값을 1로 채운 해당 shape를 가진 ndarray를 반환함

one_array = np.ones((3,2))
print(one_array)
print(one_array.dtype)

- [[ 1 1 ] [ 1 1 ] [ 1 1 ]] -> 1으로 채워진 (3,2) ndarray 반환

- float64 -> 디폴트 값인 float64 가 나오게 됨

4. reshape() : ndarray의 차원과 크기를 변경하는 함수, 변환을 원하는 크기를 함수 인자로 부여

array1 = np.arange(10)  # [ 0 1 2 3 4 5 6 7 8 9]
array2 = array1.reshape(2,5)  # [[0 1 2 3 4 ][5 6 7 8 9 ]]
array3 = array1.reshape(5,2)  # [[0 1] [2 3] [4 5] [6 7] [8 9]]

- 여기서 지정된 사이즈로 변경이 가능하지만,  (4,3) 처럼 맞지 않은 사이즈를 입력 시 오류를 발생시킴

* 인덱스에 있어서 -1 인 경우 ndarray와 호환되는 새로운 shape로 반환해줌

array1 = np.arange(10)  # [ 0 1 2 3 4 5 6 7 8 9]
array2 = array1.reshape(-1,5)  # [[0 1 2 3 4 ][5 6 7 8 9 ]]
array3 = array1.reshape(5,-1)  # [[0 1] [2 3] [4 5] [6 7] [8 9]]

- -1 은 원본 ndarray가 어떤 차원의 형태이든 간에 결과는 2차원으로 나오게 되며, 여러개의 로우를 가지되 반드시 1개의 컬럼을 가진 ndarray로 변환됨을 보장한다.

넘파이(NumPy) : Numerical Python 

NumPy가 제공하는 기능은 다음과 같다:

• 빠르고 메모리 효율적인 벡터 연산과 세련된 브로드캐스팅 기능을 제공하는 다차원 배열인 ndarray
• 반복문을 작성할 필요 없이 전체 데이터 배열에 대해 빠른 연산을 제공하는 표준 수학 함수
• 배열 데이터를 디스크에 쓰거나 읽을 수 있는 도구와 메모리에 올려진 파일을 사용하는 도구
• 선형대수, 난수 발생기, 푸리에 변환 기능
• C, C++, 포트란으로 쓰여진 코드를 통합하는 도구

특히 마지막 기능으로 C API를 제공하여 저수준으로 씌여진 외부 라이브러리(c로 만들어진 openCV 등)를 쉽게 사용할 수 있도록 해준다.

NumPy는 고수준의 데이터분석 기능을 제공하지 않으나,

• 데이터를 array라는 연속된 메모리 공간에 저장하고,
• array라는 메모리 블럭 단위의 연산을 사용하도록 하여,
• 큰 규모의 데이터 연산을 빠르게 수행할 수 있도록 해줄 뿐 아니라,
• deep learning 이후 각광받고 있는 GPGPU를 통한 고속 연산 처리에 바로 적용할 수 있어,
• python 계열의 데이터분석, 데이터저장, 머신러닝, AI 도구들이 공통적으로 활용하여
• 데이터 객체인 ndarray와 이 객체의 메소드를 확장하여(상속하여) 구현하고 있다.

따라서, 고수준의 여러 python 계열의 분석 도구를 활용하려면, 그 기반이 되는 NumPy를 정확하게 이해하고 있어야 제대로된 분석이 가능하다.

고수준의 여러 python 계열의 분석 도구들이 주요하게 사용하는 기능은:

• 벡터 배열상에서 데이터 개조, 정제, 부분 집합, 필터링, 변형, 다른 종류 연산의 빠른 수행
• 정렬, 유일 원소 찾기, 집합연산 같은 일반적인 배열 처리 알고리즘
• 통계의 효과적인 표현과 데이터의 수집/요약
• 다른 종류의 데이터 묶음을 병합하고 엮기 위한 데이터 정렬과 데이터 간의 관계 조작
• if-elif-else를 포함하는 반복문 대신 사용할 수 있는 조건절을 표현할 수 있는 배열 표현
• 데이터 그룹 전체에 적용할 수 있는 수집, 변형, 함수 적용 같은 데이터 처리.

1. 넘파이 사용하기

import numpy as np

import를 통해서 넘파이 모듈을 추가할 수 있습니다.

as 를 통해 앞으로 소스에서 부를 때 별칭인 np로 호출할 것입니다.

2. array() -> 파이썬의 리스트와 같은, 배열

array1 = np.array([1,2,3])
print(type(array1))  # array1의 타입 출력
print(array1.shape)  # array1의 형태(3,)

array2 = np.array([[1,2,3],[4,5,6]])
print(type(array2))  # array2의 타입 출력
print(array2.shape)  # array2의 형태(2,3)

print('array1: : {.0}, array2 : {.2}'.format(array1.ndim, array2.ndim))

.type () : 변수에 대한 타입을 알 수 있는 함수로 결과값은 <class 'numpy.ndarray'>로 나오게 된다

.shape() : ndarray의 크기, 즉 행과 열의 수를 튜플 형태로 가지고 있으며, 배열의 차원을 알 수 있음

- array1 은 데이터 3개가 있는 1차원 배열이므로 (3,)가 나오게 된 것이고, array2 는 데이터가 1차원인 [1,2,3], [4,5,6] 이 두개인 2차원 배열이므로 (2,3)이 나오게 됩니다.

.ndim : 각 배열의 차원을 알 수 있는 함수

* 파이썬과 넘파이 비교

list1 = [1,2,3]
print(type(list1))

array1 = np.array([1,2,3])
print(type(array1))
print(array1.dtype)

- list1에 대한 type() 함수 -> <class 'list'>

- array1 에 대한 type() 함수 -> <class 'numpy.ndarray'>

* ndarray의 의미는 n-dimensional array(다차원 배열)의 약자이다.

즉, 파이썬의 리스트와 넘파이의 array는 다른 것으로 확인 할 수 있다. 넘파이를 사용하기 위해서는 파이썬의 데이터타입을 넘파이에서 처리하는 타입으로 변환이 필요하다.

- dtype : ndarray내의 데이터 타입을 확인 할 수 있는 함수로 결과는 int32 -> 모두 정수타입의 32비트임을 나타낸다.  정수와 실수가 섞여 있으면 가장 큰 데이터 타입을 따라가기 때문에 float64가 나오게 된다.

* 자료형, dtype은 ndarray가 특정 데이터를 메모리에서 해석하기 위해 필요한 정보를 담고 있는 특수한 객체다.

산술 데이터의 dtype은:

• float, int 같은 자료형의 이름과
• 하나의 원소가 차지하는 비트 수로 이루어진다.
• 예: float64 => 소수를 64bit 메모리 공간을 담는 data type.

종류Type Code설명

array_int = np.array([1,2,3])				# 기본 배열 형태
array_float = array_int.astype('float64')  	 # 타입 변환
print(array_float.dtype)

- .astype() : ndarray내 데이터 값의 타입 변경하는 함수

-> 정수로 들어간 array_int 는 float형태로 변환되어 출력값이 [1. , 2. , 3. ] 된다.

### 은행 계좌관리 프로그램

1. 클래스 구성
    - Account : 한 명의 고객의 계좌정보를 담아 관리할 목적으로 구현된 클래스
                멤버필드 : id(계좌번호), name(고객이름), balance(예금잔액)
                멤버메소드 : 판단에 의해 구현할 것
    - BankManager : 계좌정보를 이용하여 구현될 기능 담고있는 클래스
                    멤버필드: 판단에 의해 구현
                    멤버메소드: makeAccount() - 계좌개설 담당할 메서드
                                withdraw() - 출금처리 담당 메소드
                                deposit() - 입금처리를 담당할 메소드
                                check_id() - 계좌번호의 중복여부를 판단할 메소드
                                showAccount() - 전체고객의 계좌정보를 출력할 메소드
    - BankingSystem : 사용자와의인터페이스를 담당할 목적의 클래스
                      메버필드와 메소드는 판단에 의해 기술
2. 계좌번호는 사용자가 임의로 번호를 입력할 수 있도록 구현하되, 중복된 값이 있을 경우 에러 메시지 출력
3. 입금 및 출금 처리 시 계좌번호 먼저 묻고 해당 계좌의 존재유무에 의해 에러메시지 출력 또는 처리로직을 구현하도록 기술
4. 기타 조건은 주어진 입출력 형식에 맞게 구현
5. 둘 이상의 고객에 대한 정보를 담아서 관리 할 수 있도록 적당한 자료구조 활용, 또는 파일을 통한 입출력 가능
6. 모듈화(py 확장자 가진 파일 형태로 구현)하여 명령처리 가능하도록 구현
7. 기반 클래스 Account 는 제공하는 것을 사용하여도 좋고 본인 판단에 의해 새롭게 구현해도 됨

class Account: # 개인 계좌 관리
    def __init__(self):
        self.user = input("계좌번호 = ")
        self.name = input("고객이름 = ")
        self.balance = input("예금금액 = ")
        
    def disp(self):
        print("{0} : {1} : {2}".format(self.user, self.name, self.balance))
        
    def getid(self):
        return self.user
    
    def getBalance(self):
        return self.balance
    
        
class BankManager(Account):   # 여러 계좌 관리

    def one_user(self,user): # 한 고객의 정보 얻기 위해
        userlist = ""
        count = -1
        if self.check_user(user) == False: # 아이디 존재할 때
            try :
                f= open("account.txt","r")
            except FileNotFoundError as e: #
                pass
            else:
                for line in f:
                    count+=1
                    if user == line.split(",")[0]:
                        userlist= line
                        break
            finally:
                f.close()
        return count,userlist # 유저 정보 리턴
    
    def check_user(self,user): # - 계좌번호의 중복여부를 판단할 메소드
        check=True
        try :
            f= open("account.txt","r")
        except FileNotFoundError as e: #
            pass
        else:
            for line in f:
                if user == line.split(",")[0]: # 아이디 중복되면 break
                    check = False
                    break
        finally:
            f.close()
        return check
    
    def makeAccount(self):
        print("\n==== 계좌등록 ====")
        super().__init__()
        super().disp()
        result = self.check_user(super().getid())
        
        if result: # 참일때 txt파일에 저장
            try :
                f= open("account.txt","a")
            except FileNotFoundError as e: # 파일 존재하지 않을 때 새로 만들기
                f= open("account.txt","w") 
            finally:
                f.write(self.user+","+self.name+","+self.balance+"\n")
                f.close()
        else : # 거짓일 때 중복됬다고 알리기
            print("id가 중복됩니다. 다시 입력해주세요")
        print("===================")
        
        
    def showAccount(self): # - 전체고객의 계좌정보를 출력할 메소드
        userlist = []
        try :
            f= open("account.txt","r")
        except FileNotFoundError as e: #
            print("고객이 없습니다,")
        else:
            for line in f:
                userlist.append(line)
        finally:
            f.close()
        return userlist
        
    
class BankingSystem(BankManager):
    num = 0
    def __init__(self,num):
        self.num=int(num)
        
    def controler(self):
        if self.num == 1:
            super().makeAccount()
        elif self.num == 2:
            self.printdeposit()
        elif self.num == 3:
            self.printwithdraw()
        elif self.num == 4:
            self.printshow()
       
            
    def printwithdraw(self):
        print("==== 출금처리====") #- 출금처리 담당 메소드
        user = input("계좌번호 = ")
        count,userlist = self.one_user(user)
        print("===================")
        if userlist != "":
            user,username,userbalance = userlist.split(',')
            print("{0} : {1} : {2}".format(user,username,userbalance))
            print("===================\n")
        
            try:
                price = int(input("출금금액 = "))
                
            except ValueError as e:
                print("잘못입력하셨습니다")
            else :
                if (int(userbalance)-int(price)) < 0:
                    print("고객님 계좌의 잔액이 부족합니다.")
                else :
                    self.change_draw(user,username,int(userbalance)-price,count)
                    print("출금처리가 완료되었습니다.")
        else :
            print("일치하는 계좌번호가 존재하지 않습니다.")
        print("===================")
        
    def change_draw(self,user,username,userbalance,count):
        f = open("account.txt","r+")
        for i in range(0,count):
            f.readline()
        f.seek(f.tell(),0)
        f.writelines(user+","+username+","+str(userbalance)+"\n")
        f.close()
        
    def change_deposit(self,user,username,userbalance,count):
        f = open("account.txt","r+")
        for i in range(0,count):
            f.readline()
        f.seek(f.tell(),0)
        f.writelines(user+","+username+","+str(userbalance)+"\n")
        f.close()
        
    def printdeposit(self):
        print("==== 입금처리====") #- 입금처리 담당 메소드
        user = input("계좌번호 = ")
        count,userlist = self.one_user(user)
        print("===================")
        if userlist != "":
            user,username,userbalance = userlist.split(',')
            print("{0} : {1} : {2}".format(user,username,userbalance))
            price = 0
            print("===================\n")
            try:
                price = int(input("입금금액 = "))
            except ValueError as e:
                print("잘못입력하셨습니다")
            else :
                self.change_deposit(user,username,int(userbalance)+price,count)
                print("입금처리가 완료되었습니다.")
        else :
            print("일치하는 계좌번호가 존재하지 않습니다.")
        print("===================")
        
    def printshow(self):
        print("==== 전체고객====") #- 전체고객 조회 메소드
        userlist = super().showAccount()
        for i in range(0,len(userlist)):
            a,b,c = userlist[i].split(",")
            print("{0} : {1} : {2}".format(a, b, c),end="")
        print("===================")
      
    

if __name__ == "__main__":
    while True:
        print("==== Bank Menu ====")
        print("1. 계좌개설")
        print("2. 입금처리")
        print("3. 출금처리")
        print("4. 전체고객 잔액현황")
        print("5. 프로그램 종료")
        print("===================")
        try:
            num = int(input("선택 = "))
        except ValueError as e:
            print("잘못입력하셨습니다")
        
        else :
            if num == 5:
                break
            else :
                b = BankingSystem(num)
                b.controler()
        

[급여관리] - python 상속관계 알기 위해 

# 급여관리 
# A 라는 회사 직원급여 관리를 목적으로 프로그램 구현
# 정규직(permament) : 이름, 급여(기본급)
# 영업직(Sales) : 이름, 급여(기본급 + 수당)
# 임시직(Temparary) : 이름, 급여(근무시간 * 시간당 급여)

class Employee():
    def __init__(self, name=""):
        self.name = name
    def show(self):
        pass
class Permament(Employee):
    def __init__(self, name="", pay=0):
        super().__init__(name)
        self.pay = pay
    def show(self):
        print("정규직/",self.name,"/",self.pay)
class Sales(Employee):
    def __init__(self, name="", pay=0,bonus=0):
        super().__init__(name)
        self.pay = pay
        self.bonus=bonus
    def show(self):
        print("영업직/",self.name,"/",self.pay+self.bonus)
class Temparary(Employee):
    def __init__(self, name="", time=0,timepay=0):
        super().__init__(name)
        self.time = time
        self.timepay=timepay
    def show(self):
        print("임시직/",self.name,"/",self.time*self.timepay)

[숫자야구게임]

# 숫자야구게임



import random

randomnum = []



a = random.randint(1, 9) 

b = random.randint(1, 9)

while a==b:

    b = random.randint(1, 9) 

c = random.randint(1, 9) 



while a==c or b==c:

    c = random.randint(1, 9) 

    

randomnum.append(a)

randomnum.append(b)

randomnum.append(c)

result = True



while result:

    st = 0

    ball = 0

    lnputlist = []

    a,b,c = map(int,input('숫자 세 개를 입력하세요: ').split())



    lnputlist.append(a)

    lnputlist.append(b)

    lnputlist.append(c)

    

    for i in range(0,len(lnputlist)) :

        if lnputlist[i] in randomnum:

            ball+=1

            if lnputlist[i] == randomnum[i]:

                st+=1

                if ball > 0:

                    ball-=1

                else :

                    ball = 0

    print("스트라이크:",st, "볼:",ball)

    if st == 3:

        result=False

1. main menu
- 연락처 등록
- 연락처 조회 
- 연락처 삭제 : 이름으로 검색 후 동일 이름 전화번호 출력시켜서 삭제할 이름의 번호 입력하면 삭제되도록
- 연락처 출력
- (연락처 변경도 해보자)
- 프로그램 종료

2. 등록
- 이름
- 연락처
- 이메일

  참고 자료 :

- 더북 R을 이용한 데이터 처리 & 분석 실무 :  https://thebook.io/006723/ch01/

- ggplot 그래프 : http://freesearch.pe.kr/archives/3134 

- R, Python 분석과 프로그래밍 (by R Friend) : https://rfriend.tistory.com/m

- 차후 추가할 예정

#0717

#hist(데이터셋)
hist(iris$Sepal.Width, freq = FALSE)
lines(density(iris$Sepal.Width))

plot(density(iris$Sepal.Width))
#중첩된 데이터를 추가하고싶을 때는 
rug(jitter(iris$Sepal.Width))

# 파이차트(pie) : 데이터의 비율을 알아볼 때 적합한 그래프. 
x <- c(110, 200, 330, 400, 550, 600, 130)
pie(x)

cut(iris$Sepal.Width, breaks=10)

rep(c("A","B","C"),1:3)
table(cut(iris$Sepal.Width, breaks=10)) # 테이블함수를 통해서 cut한 벡터를 파이 그래프로 그릴 수 있음
pie(table(cut(iris$Sepal.Width, breaks=10)))
    
pie(x,init.angle=90,col=rainbow(length(x)),labels = c("월","화","수","목","금","토","일"))
legend("topright",c("월","화","수","목","금","토","일"),cex=0.7,fill=rainbow(length(x))) # fill 색 넣고 범례 만들기.

week <- c("월","화","수","목","금","토","일")
ratio <- round(x/sum(x)*100,1)  # -> round : 반올림 , 1 : 소수 첫쨋자리에서 반올림 하세요 /비율계산
label <- paste(week,"\n",ratio,'%') # -> 붙여주기 : 요일 줄 띄우고 비율 넣고 % 첨부

pie(x,init.angle=90,col=rainbow(length(x)), labels=label)
legend("topright",c("월","화","수","목","금","토","일"),cex=0.7,fill=rainbow(length(x))) # fill 색 넣고 범례 만들기.


# 3d pie 차트
install.packages("plotrix")
library(plotrix)

pie3D(x,col=rainbow(length(x)), labels=label) 
legend("topright",c("월","화","수","목","금","토","일"),cex=0.7,fill=rainbow(length(x))) # fill 색 넣고 범례 만들기.

pie3D(x,col=rainbow(length(x)), labels=label, explode = 0.1) 
legend("topright",c("월","화","수","목","금","토","일"),cex=0.7,fill=rainbow(length(x))) # fill 색 넣고 범례 만들기.


# 모자이크 플롯(mosaicplot)
# 범주형(R에서는 팩터로 표현) 다변량 데이터(하나 이상의 변수가 있는 데이터)를 표현하는 데 
# 적합한 그래프다. 모자이크 플롯에는 사각형들이 그래프에 나열되며, 
# 각 사각형의 넓이가 각 범주에 속한 데이터의 수에 해당한다.

# 타이타닉호 생존자의 정보를 담고 있는 titanic 데이터를 사용함
# 
# 변수명   변수명 설명
# survival   Survival (0 = No; 1 = Yes)
# pclass   Passenger Class (1 = 1st; 2 = 2nd; 3 = 3rd) 객실 등급
# name   Name
# sex   Sex
# age   Age
# sibsp   Number of Siblings/Spouses Aboard
# parch   Number of Parents/Children Aboard
# ticket   Ticket Number
# fare   Passenger Fare
# cabin   Cabin
# embarked   Port of Embarkation (C = Cherbourg; Q = Queenstown; S = Southampton)


titanic <- read.csv("C:/Users/User/Desktop/Data/titanic/train2.csv", header = T, as.is=T)
str(titanic)
str(Titanic)

class(titanic)


mosaicplot(Titanic, color=TRUE)
# 변수가 너무 많음 복잡함 객실타입과 성별 만으로 다시 만들어 보자
mosaicplot(~Class + Survived, data = Titanic, color=TRUE)

# 산점도 행렬(pairs) : 다변량 데이터에서 변수들간의 상관도를 그린 그래프
pairs(~ Sepal.Width + Sepal.Length + Petal.Width + Petal.Length, data=iris,col=c("red","green","blue")[iris$Species], pch=c(1, 2, 3)[iris$Species])


levels(iris$Species)
#a 범주를 numeric으로d 바꾸어 추출하라
as.numeric(iris$Species)


# 투시도 -> 3차원 데이터를 마치 투시한 것 처럼 그린 그래프
# persp()
# outer(x,y,함수) : 외적으로 그린다
outer(1:5, 1:3, function(x, y) { x + y })

xx <- seq(-3,3, length=50)
yy <- seq(-4,4, length=60)
f <- function(x,y){x^2+y^2+x*y}
y = outer(xx,yy,f)
persp(y)


install.packages("mvtnorm")
library(mvtnorm)
x <- seq(-3, 3, 0.1)
y <- x
f <-function(x,y){dmvnorm(cbind(x,y))}

persp(x,y,outer(x,y,f), theta = 30, phi = 30)
# theta : 기울어진 각도 

# 등고선 그래프 : 투시도와 유사하지만 튜시한 3차원 그림 대신 값이 같은 곳들을 선으로
# 연결한 등고선을 이용해데이터 표시
contour(x,y,outer(x,y,f))


#기초 통계분석

###머신러닝의 기본단계

# 1단계: 데이터 수집
# 2단계: 입력 데이터 준비
# 3단계: 데이터 분석
# 4단계: 알고리즘 선택 및 훈련
# 5단계: 알고리즘 테스트
# 6단계: 사용하기 (운영 및 배포)

# 합계 : sum(데이터)
# 사분위수 : quantile(데이터)
# 기초통계량 : summary()
# 다섯개의 통계값을 추출하주는 함수: fivenum(데이터)

library(ggplot2)
cafe<-read.csv("C:/Users/User/Desktop/R/Data/cafe/data.csv")
sort(cafe$Coffees,decreasing = T)[1] # 정렬하기 

mode(cafe$Coffees)

table(cut(cafe$Coffees,breaks = 5))


#난수생성 분포함수
# R에서는 난수를 발생시키는 다양한 함수를 제공한다.
# 일반적으로 이 함수명들은 R 뒤에 분포명을 붙인 이름을 갖는다.
#rbinom() 이항분포
#rf() F분포
#rgeom()  기하분포
#rnorm()  정규분포
#rpois()  포아송분포
#rt() t분포
#runif() 균일분포
#rhyper() 초기하분포

a<-rnorm(100,0,10) #평균이 0이고 표준편차가 10인 정규분포 100개 난수 발생
b<-pnorm(1) #정규분포의 누적분포
c<-qnorm(0.5) #분위수를 구할때
d<-dnorm(1000,0,10) #정규분포의 확률 밀도 

plot(d)





fibo<-function(n){
    if(n==1|n==2){
        return(1)
    }
    return(fibo(n-1)+fibo(n-2))
}
fibo(1)
fibo(5)


f<- function(x,y){
    print(x)
    print(y)
}
f(1,2)

f(y=1,x=2)


f<- function(x,y){
    print(x)
    g<-function(y){
        print(y)
    }
    g(y)
}

f(1,2)


#scope(범위, 영역)

n<-1
f<-function(){
    print(n)
}
f()

n<-2
f()

n<-100

f<-function(){
    print(n)
}
f()


rm(list=ls()) #  환경 지우기
f<-function(){
    x<-1
    print(x)
}

f()
x

library(ggplot2)
library(dplyr)
# cty => city, hwy => highway
# rename은 dplyr 패키지가 필요하다.
str(mpg)

mpg2<-mpg
mpg2 <- rename(mpg2, city=cty)
mpg2 <- rename(mpg2, highway=hwy)

#mpg2 의 통합 연비를 구하여라
mpg2
mpg2$mpg_total <- mpg2$city + mpg2$highway
mpg2$mpg_total

# 각 자동차의 모델의 연비를 이용하여 전체 자동차의 기준 연비를 구한 후
# 고연비합격 판정을 위한 파생변수 mpg_check를 생성하여 그 값으로 'pass', 'fail'


summary(mpg2$mpg_total/2)

# 연비에 따른 등급을 부여한다.
# 파생변수는 grad
# 등급은 연비가 30이상이면 'a',20~29이면 'b', 29미만이면 'c'


##깜짝 시험

#ggplot2 패키지에 포함되어 있는 데이터셋 중 midwest를 이용하여 다음 주어진 작업을 수행하시오
#midwest 데이터셋은 미국 437개 지역의 인구통계 정보를 가지고 있는 자료

#1. midwest 데이터를 데이터 프레임 형태로 불러온 다음 데이터의 특징을 파악하시오.
#2. poptotal(전체인구)변수를 total, popasian(아시아 인구) 변수를 asian으로 수정하시오.
#3. total,asian 변수를 이용해 '전체 인구 대비 아시아 인구 백분율'을 담을 파생변수를 생성하고,
#    히스토그램을 만들어 도시들이 어떻게 분포 되어 있는지 파악하시오.
#4. 아시아 인구 백분율 전체 평균을 구하고, 평균을 초과하면 "large" , 그외 "small"을  부여하는 
#    파생변수를 만들어 담으시오
#5. "large"와 "small"에 해당하는 지역이 얼마나 되는지 빈도표와 빈도 막대 그래프를 작성하여 분석하시오


str(midwest)
#1. midwest 데이터를 데이터 프레임 형태로 불러온 다음 데이터의 특징을 파악하시오.
west <- as.data.frame(ggplot2::midwest)
west <- west

west
# pid, county, state, area, poptotal, ,,,,

#2. poptotal(전체인구)변수를 total, popasian(아시아 인구) 변수를 asian으로 수정하시오.
west <- rename(west, total=poptotal)
west <- rename(west, asian=popasian)
west

#3. total,asian 변수를 이용해 '전체 인구 대비 아시아 인구 백분율'을 담을 파생변수를 생성하고,
#    히스토그램을 만들어 도시들이 어떻게 분포 되어 있는지 파악하시오.

west$per_asian<-(west$asian/west$total)*100
west
hist(west$per_asian)


#4. 아시아 인구 백분율 전체 평균을 구하고, 평균을 초과하면 "large" , 그외 "small"을  부여하는 
#    파생변수를 만들어 담으시오

avg <- mean(west$per_asian)

west$total_avg <- ifelse(west$per_asian >= avg, "large","small")  # if eles 문으로 평균 값 확인 

#5. "large"와 "small"에 해당하는 지역이 얼마나 되는지 빈도표와 빈도 막대 그래프를 작성하여 분석하시오
a<-table(west$total_avg)
a
barplot(a)

# 석준 코드

data(midwest)
str(midwest)
midwest <- midwest %>% mutate(category = factor(category),
                              state = factor(state),
                              county = factor(county))
summary(midwest)

midwest <- rename(midwest, total = poptotal,
                  asian = popasian)
midwest <- midwest %>% mutate(rate = asian/total)
ggplot(data = midwest, aes(x = rate)) +
    geom_histogram(bins = 13)
# 대부분의 도시들의 아시아인 비율이 2%를 넘지 못한다.

midwest <- midwest %>% 
    mutate(check = factor(ifelse(rate > mean(rate),
                                 "large", "small")))
table(midwest$check)
barplot(table(midwest$check))

# 
# 6.popadults는 해당 지역의 성인 인구, poptotal은 전체인구를 뜻한다.
# midwest 데이터에 "전체 인구 대비 미성년 인구 백분율" 변수를 추가하여 파생변수를 생성
# 7.미성년 인구 백분율이 가장 높은 상위 5개 country(지역)의 미성년 인구 백분율을
# 추출하시오
# 8.popasian은 해당 지역의 아시아인 인구를 나타냈다.
# "전체 인구 대비 아시아인 인구 백분율" 변수를 추가하고, 하위 10개 지역의
# state(),country(지역), 아시아인 인구 백분율을 추출
#



#6.popadults는 해당 지역의 성인 인구, poptotal은 전체인구를 뜻한다.
# midwest 데이터에 "전체 인구 대비 미성년 인구 백분율" 변수를 추가하여 파생변수를 생성
west$per_notadult <- (west$total - west$popadults)/west$total*100
west

# 7.미성년 인구 백분율이 가장 높은 상위 5개 country(지역)의 미성년 인구 백분율을
# 추출하시오
sort(west$per_notadult,decreasing=TRUE)[1:5]


#8.popasian은 해당 지역의 아시아인 인구를 나타냈다.
# "전체 인구 대비 아시아인 인구 백분율" 변수를 추가하고, 하위 10개 지역의
# state(),country(지역), 아시아인 인구 백분율을 추출
west$per_asian<- (west$asian / west$total) *100
aa <- subset(west[order(west$per_asian), ],select=c(state,county, per_asian))
tail(aa,n=10)

#-----------------------------------------------------------------------------------
# db연동 oracle과 연동

install.packages("rJava")
install.packages("DBI")
install.packages("RJDBC")

library(rJava)
library(DBI)
library(RJDBC)
library(dplyr)

drv <- JDBC("oracle.jdbc.driver.OracleDriver","파일 경로/ojdbc6.jar")
# DB connect
conn <- dbConnect(drv, "jdbc:oracle:thin:@//localhost:1521/(xe/orcl 맞는 것으로)", "id", "password")
#쿼리 입력
rst <- dbGetQuery(conn, "SELECT * FROM SCORE")
#출력
rst



# 77page
score <- c(80,60,70,50,90)
score

mean(score)
avg <- mean(score)
avg

# 88page
fruit <- data.frame(제품 = c("사과","딸기","수박"),
                      가격 = c(1800,1500,3000),
                      판매량 = c(24,38,13))
fruit
avgprice <- mean(fruit$가격)
avgcell <- mean(fruit$판매량)
avgprice
avgcell


#R과 mysql 연동
install.packages("rJava")
install.packages("DBI")
install.packages("RMySQL")
library(rJava)
library(DBI)
library(RMySQL)

#db connection
conn <- dbConnect(MySQL(),user="root",password="mysql비밀번호",dbname="db이름")

#db list 출력
print(dbListTables(conn))

score <- dbGetQuery(conn, "select count(*) from score")
score

#테이블 필드 목록
dbListFields(conn, "score")

# 테이블에 레코드를 삽입하는 작업
dbSendQuery(conn,"insert into score value (6,85,95,100)")

score <- dbGetQuery(conn, "select * from score")
score

# DDL(정의어) : CREATE , ALTER, DROP
# DML(조작어) : SELECT, DELETE, UPDATE, INSERT
#   execQuery() -> 테이블 바꾸지 않고 데이터 가져오는 것
#   execUpdate() -> 테이블의 내용이 바뀔 수 있는 것
# DCL(제어어) : GRANT(권한부여), REVOKE(권한제거), COMMIT(성공적인 종료), ROLLBACK(비정상정 종료)

dbGetQuery(conn, "update score set math = 90 where student_no = 6")

#dbDisconnect(conn) -> db연결 종료

# RMySql 패키지
# sqldf
install.packages("sqldf")
install.packages("chron") # 라이브러리 할 필요 없음

library("sqldf")

# sql문을 사용할 수 있도록 해주는 것 
detach("package:RMySQL", unload=TRUE)  
# RMySQL 이 메모리에서 제거되지 않으면 실행이 안될수도 있기 때문에 꺼줄때 사용하는 구문.
sqldf("select * from iris")

# 문제1
# setosa에 속하는 데이터에서 sepal.length의 평균 계산
sqldf('select avg("Sepal.Length") from iris where "Species"="setosa"')

# 문제2
# 각 품종별 sepal.length의 평균 구하시오
# db에는 . 쓸수있는데 여기선 _ 로 사용
sqldf('select avg("sepal.length") from iris group by species')

#apply(행렬 or 데이터, 방향, 함수)
# 방향 - 1 행, 2 열
d <- matrix(1:9, ncol = 3)
d

apply(d, 1, sum)
apply(d,2,sum)

head(iris)
apply(iris[,1:4], 2, sum )
# 위와 같은 뜻
colSums(iris[,1:4])

# lapply(벡터 or 리스트, 함수) : l은 list 약자
# 이때 x는 벡터, 데이터프레임, 리스트이고, 
# 함수는 x내 각 요소에 적용할 함수이다. 
# lapply()함수의 결과는 리스트로 반환된다.
# lapply()는 인자로 벡터를 받을 수 있다.
# 1~3까지의 숫자에 2를 곱한 값들을 리스트로 만든다.
result <- lapply(1:3, function(x){x*2})
result
class(result)  # 리스트 형태
#리스트 형태를 벡터로 변환하는 작업
class(unlist(result))  # numeric

x <- list(a=1:3, b=4:6)
x
lapply(x, mean) # -> list
lapply(x,sum)

# 평균 구하는 함수
colMeans(iris[,1:4])  #-> numeric

# sapply() 는 lapply()와 비슷하지만 행렬, 벡터등으로 결과를 반환함
lapply(iris[, 1:4], mean)   
sapply(iris[, 1:4], mean)
is.vector(sapply(iris[, 1:4], mean)) # vector

y <- sapply(iris[, 1:4], mean)
as.data.frame(y) # 데이터 프레임으로 변환
as.data.frame(t(y))

split(iris, iris$Species)
lapply(split(iris$Sepal.Length, iris$Species), mean) # 품종별로 sepal.length의 평균 구함 # list
sapply(split(iris$Sepal.Length, iris$Species), mean) #vector

#그래프
#R에서 사용되는 그래픽스 기능은 크게 graphics,lattice,ggplot 패키지가 있다

#1.graphics 패키지
#R에서 가장 기본이 되는 시각화 기능을 지원한다
#전체 함수의 목록은 library(help="graphics")

#산점도(산포도)
methods("plot")

install.packages("mlbench")
library(mlbench)

data(Ozone)
?Ozone


#축이름(xlab,ylab)
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone")

#점의 종류(pch)
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone",pch=20)
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone",pch="+")

#점의 크기(cex)
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone",pch=20,cex=1) 

#색상(col)
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone",pch=20,cex=1,col="red") 

# 좌표측 값의 범위(xlim, ylim)
# c(최솟값, 최댓값)
max(Ozone$V8)
max(Ozone$V8, na.rm=TRUE)  # 결측값 제거하고 최댓값 구하라
plot(Ozone$V8, Ozone$V9, xlab="Sanburg Temperature", ylab="어느도시 온도", main="Ozone",
     xlim=c(0,100), ylim=c(0,90))


# type - 그래프의 종류, p(점), l(선), b(점과 선)
data("cars")
str(cars)
head(cars)
# cars를 그리기
plot(cars, type="o", cex = 0.5)

# 같은 주행속도에 대해 두개이상의 제동거리를 가지고 있다
#  tapply(벡터, 요인, 함수) : 요인(factor) 변수를 기준으로 해서 그룹별로 나누어서 통계 분석을 하고자 할 때 유용하게 쓸 수 있는 함수입니다
# speed별로 묶어서 dist의 평균 계산

plot(tapply(cars$dist, cars$speed, mean), type = "o", xlab="speed", ylab="dist")

# 그래프 배열(mfrow)  : 그래프 여러개 그리기

# par( )를 호출하면 이전에 저장된 par 설정이 반환된다. 따라서 par(mfrow=c(nr, nc)) 호출 시
# 반환 값을 opar 변수에 저장했다가 코드의 마지막에서 par(opar)를 호출하면, mfrow 지정 이전
#의 par 설정으로 환경을 되돌릴 수 있다.

opar <- par(mfrow=c(1,2))  # 그래프를 nr개의 행, nc개의 컬럼으로 배열한다.
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone1",pch=20,cex=1,col="red")
plot(Ozone$V8,Ozone$V9,xlab="Sanburg Temperature",ylab="ElMonte Temperature",
     main="Ozone2",pch=20,cex=1)
par(opar)

# 지터 jitter : 데이터 값에 약간의 노이즈를 추가하는 방법을 말한다.
# 노이즈를 추가하면 데이터 값이 조금씩 움직여서 같은 값을 가지는 데이터가 
# 그래프에 여러 번 겹쳐서 표시되는 현상을 막아준다.

Ozone[,]

plot(Ozone$V6, Ozone$V7, xlab="Windspeed", ylab="Humidity", main="Ozone", pch=20, cex=.5)
plot(jitter(Ozone$V6), jitter(Ozone$V7), xlab="Windspeed", ylab="Humidity", main="Ozone",pch=20, cex=0.5)

# points() : 이미 생성된 plot에 점을 추가하여 그리는 옵션
# 처음꺼 위에 다음꺼 추가하고 싶을 때 라벨이나 상단 제목 제외
plot(iris$Sepal.Width, iris$Sepal.Length, cex=0.5,
     pch=10, xlab="width", ylab="length", main="iris1")
points(iris$Petal.Width, iris$Petal.Length, cex=0.5,
     pch="+", col="red")

# lines( )는 points( )와 마찬가지로 plot( )으로
#새로운 그래프가 시작된 뒤 그 위에 꺾은선을 추가하여 그리는 목적으로 사용한다

x <- seq(0, 2*pi, 0.1)
y <- sin(x)
plot(x, y, cex=.5, col="red")
lines(x, y)

example(lines)


# abline( )은 y = ax + b 형태의 직선이나 y=h 형태의 가로로 그은 직선 
# 또는 x=v 형태의 세로로 그은 직선을 그래프에 그린다. abline( )이 그리는 것은 
# 꺾이지 않고 그어진 일직선이다. 따라서 lines( )가 주어진 (x, y) 좌표들을 연결하는
# 꺾은선을 긋는 것과는 차이가 있다.

plot(cars, xlim=c(0, 25))
abline(a=-5, b=3.5, col="red")

# 선의 유형(linetype, lty)
# a & b : 함수식 y=a+bx 에서 a는 절편, b는 기울기를 의미합니다.
# h : 수평선 위치를 나타냅니다.
# v : 수직선 위치를 나타냅니다.

plot(cars, xlim=c(0, 25))
abline(a=-5, b=3.5, col="red")
abline(h=mean(cars$dist), lty=2) # y=h 형태의 수평선을 그릴 때 지정
abline(v=mean(cars$speed), lty=2) # x=v 형태의 수직선을 그릴 때 지정 # 2는 dashed로 점선 의미

# 곡선 (curve) curve(표현식, 구간 시작점, 구간 끝점)
curve(sin, 0, 2*pi)

#문자열(text) : 그래프에 문자를 그리는데 사용하는 함수
#text(x좌표,y좌표,내용)
plot(cars,cex=0.5)
text(cars$speed,cars$dist, cex=0.5,pos=4)

# 그래프에 그려진 데이터의 식별(identify)
# 이 십자 커서로 그래프에서 특정 점을 클릭하면 클릭된 점과 가장 가까운 데이터에 레이블을 표시한다
plot(cars,cex=0.5)
identify(cars$speed,cars$dist)

# 범례 (legend)
# legend(x,y,option)
# bottomright, bottomleft,bottom,left,right,center,top, topleft, topright

plot(iris$Sepal.Width, iris$Sepal.Length, pch=20, xlab="width", ylab="length")
points(iris$Petal.Width, iris$Petal.Length, pch=43, col="#FF0000")
legend("topright", legend=c("Sepal", "Petal"), pch=c(20, 43),col=c("black", "red"), bg="gray")

# 행렬에 저장된 데이터 그리기(matplot, matlines, matpoints)
# matplot, matlines, matpoints
# -2pi ~ 2pi
x <- seq(-2*pi, 2*pi, 0.01)
x

y <- matrix(c(cos(x), sin(x)), ncol=2)  # -> cos, sin의 값을 그래프로 나타내기 위해
matplot(x,y,col=c("red","blue"),cex=0.1)
abline(h=0, v=0)  # 가운데 축 보여주기 위해

# 상자 그림(boxplot)
# 데이터의 분포를 보여주는 그림으로 가운데 상자는 제1사분위수, 중앙값, 제3사분위수9를 보여준다
# 상자의 좌우 또는 상하로 뻗어나간 선(whisker라고 부름)
# 그래프에 보이는 점들은 이상치outlier에 해당
boxplot(iris$Sepal.Width)
boxstats<- boxplot(iris$Sepal.Width)
boxstats<- boxplot(iris$Sepal.Width, horizontal = TRUE)
text(boxstats$out, rep(1, NROW(boxstats$out)), labels=boxstats$out, pos=c(1, 1, 1, 1))

sv <- subset(iris, Species=="setosa" | Species=="versicolor")  # or 연산
sv$Species <- factor(sv$Species)
boxplot(Sepal.Width ~ Species, data=sv, notch=TRUE) # 그래프 오목하게 그려짐 / subset이 비록 두 개의 Species만 선택하는 역할
# 그래프 꺽인 구간 -> 중 앙값에 대한 일종의 신뢰구간
# setosa와 versicolor의 notch가 겹치지 않으므로 이 두 그룹의 중앙값은 서로 다르다고 결론을 내릴 수 있다.

# 히스토그램 : 값의 범위마다 빈도를 표시한 그래프
x <- hist(iris$Sepal.Width)
x <- hist(iris$Sepal.Width, freq=T)
ㅐ