Polpid's Pensieve

Pandas

• 데이터 형식

  • 시리즈(Series)

    • 데이터가 순차적으로 나열된 1차원 배열 형태

    • 딕셔터리로 Series 생성시 -> key 는 시리즈의 인덱스와 대응된다.

    • 리스트로 Series 생성시 -> 리스트의 인덱스가 시리즈의 인덱스로 대응된다.

      dict_data = {'a':1,'b':2,'c':3}
      series_data=pd.Series(dict_data)
      
      a    1
      b    2
      c    3
      
      list_data = ['2022-10-11',3.14,'ABC',100,True]
      series_data1=pd.Series(list_data)
      
      0    2022-10-11
      1          3.14
      2           ABC
      3           100
      4          True

• 데이터프레임(DataFrame)

  • 행과 열로 만들어지는 2차원 배열 형태

  • 열은 각각의 시리즈 객체이다. key 값이 열 이름이 된다.

    dict_data = {'c0':[1,2,3],'c1':[4,5,6],'c2':[7,8,9],'c3':[10,11,12],'c4':[13,14,15]}
    df=pd.DataFrame(dict_data)
    
       c0  c1  c2  c3  c4
    0   1   4   7  10  13
    1   2   5   8  11  14
    2   3   6   9  12  15

• 데이터 내용 확인

  • columns : 컬럼명 확인
  • head() : 상단 5개 확인
  • tail() : 하단 5개 확인
  • shape : 행,열 크기 확인
  • info() : 데이터에 대한 정보 확인
    • 행,열 크기, 컬럼명..
  • type() : 데이터 타입

• 열선택

  • 열 1개 선택 : 시리즈 객체를 반환한다.

    Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
           'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
          dtype='object')
    
    names = t['Name'].head()   # t.Name 으로도 사용 가능
    print(names)
    print(type(names))
    0                                Kelly, Mr. James
    1                Wilkes, Mrs. James (Ellen Needs)
    2                       Myles, Mr. Thomas Francis
    3                                Wirz, Mr. Albert
    4    Hirvonen, Mrs. Alexander (Helga E Lindqvist)
    Name: Name, dtype: object
    <class 'pandas.core.series.Series'>

  • 열 다중 선택 : 데이터 프레임으로 반환 한다.

    names_age = t[["Name", "Age"]]
    print(names_age)
    print(type(names_age))
    
                                               Name   Age
    0                              Kelly, Mr. James  34.5
    1              Wilkes, Mrs. James (Ellen Needs)  47.0
    2                     Myles, Mr. Thomas Francis  62.0
    3                              Wirz, Mr. Albert  27.0
    4  Hirvonen, Mrs. Alexander (Helga E Lindqvist)  22.0
    <class 'pandas.core.frame.DataFrame'>

• 데이터 필터링

  PassengerId    Survived    Pclass    Name    Sex    Age    SibSp    Parch    Ticket    Fare    Cabin    Embarked
  0    892    0    3    Kelly, Mr. James    male    34.5    0    0    330911    7.8292    NaN    Q
  1    893    1    3    Wilkes, Mrs. James (Ellen Needs)    female    47.0    1    0    363272    7.0000    NaN    S
  2    894    0    2    Myles, Mr. Thomas Francis    male    62.0    0    0    240276    9.6875    NaN    Q
  3    895    0    3    Wirz, Mr. Albert    male    27.0    0    0    315154    8.6625    NaN    S
  4    896    1    3    Hirvonen, Mrs. Alexander (Helga E Lindqvist)    female    22.0    1    1    3101298    12.2875    NaN    S

  • Boolean 인덱싱 : true 만 추출

    # 35살 초과인 데이터 추출
    d1 = t["Age"]>35
    print(t[d1])
    
       PassengerId  Survived  Pclass  \
    1           893         1       3   
    2           894         0       2   
    11          903         0       1   
    13          905         0       2   
    14          906         1       1   

  • isin() : 각각의 요소가 데이터 프레임, 시리즈에 존재하는지 파악하여 true/false 반환

    # Pclass 변수의 값이 1일 경우, True/False 값 반환
    t['Pclass'].isin([1])
    
        PassengerId    Survived    Pclass    Name    Sex    Age    SibSp    Parch    Ticket    Fare    Cabin    Embarked
    11    903    0    1    Jones, Mr. Charles Cresson    male    46.0    0    0    694    26.0000    NaN    S
    12    904    1    1    Snyder, Mrs. John Pillsbury (Nelle Stevenson)    female    23.0    1    0    21228    82.2667    B45    S
    14    906    1    1    Chaffee, Mrs. Herbert Fuller (Carrie Constance...    female    47.0    1    0    W.E.P. 5734    61.1750    E31    S
    20    912    0    1    Rothschild, Mr. Martin    male    55.0    1    0    PC 17603    59.4000    NaN    C
    22    914    1    1    Flegenheim, Mrs. Alfred (Antoinette)    female    NaN    0    0    PC 17598    31.6833    NaN    

  • isna() : 결측값은 true 반환, 그외에는 false 반환

  • notna() : 결측값은 false 반환, 그외에는 true 반환

    9    901    0    3    Davies, Mr. John Samuel    male    21.0    2    0    A/4 48871    24.1500    NaN    S
    10    902    0    3    Ilieff, Mr. Ylio    male    NaN    0    0    349220    7.8958    NaN    S
    
    t["Age"].isna()[0:12]  #10번째에 Age 가 NaN
    9     False
    10     True            # NaN 은 true 값 반환
    11    False
    
    t[t["Age"].isna()].head()
    
        PassengerId    Survived    Pclass    Name    Sex    Age    SibSp    Parch    Ticket    Fare    Cabin    Embarked
    10    902    0    3    Ilieff, Mr. Ylio    male    NaN    0    0    349220    7.8958    NaN    S

• 결측치 제거

  • dropna(axis=0) : 결측치 존재하는 행 전체 제거
  • dropna(axis=1) : 결측치 존재하는 열 전체 제거

• 이름과 인덱스로 행, 열 선택

  • loc[] : 행 이름과 열 이름 사용

    # 나이가 35세 초과인 사람의 이름과 나이 출력
    t.loc[t['Age']>35, ['Name', 'Age']]

  • iloc[] : 행번호와 열 번호 사용

• 통계 관련 기능

  • mean() : 평균값

  • median() : 중앙값

  • describe() : 통계 요약

  • agg() : 여러개 열에 여러 함수 적용

    t.agg({'Age':['min', 'max']})
        Age
    min    0.17
    max    76.00

  • groupby() : 그룹별 집계

  • value_counts() : 값 개수

• 행, 열추가

  • DataFrame.loc[새로운 행 이름] = 데이터 값
  • DataFrame['열이름']

NumPy 배열

• 차원(Dimension)을 축(axis)이라고 표현한다.

배열 속성값

• shape : 배열의 각 축(axis)의 크기
• ndim : 축의 개수(Dimension)
• dtype : 각 요소(Element)의 타입
• itemsize : 각 요소(Element)의 타입의 bytes 크기
• size : 전체 요소(Element)의 개수

배열 생성

• np.array 이용 : 튜플이나 List 입력

  print(np.array([2,3,4]))
  [2 3 4]

• np.zeros(shape) : 0 으로 구성된 N 차원 배열 생성

  print(np.zeros((3,4)))
  [[0. 0. 0. 0.]
   [0. 0. 0. 0.]
   [0. 0. 0. 0.]]

• np.ones(shape) : 1로 구성된 N차원 배열 생성

  print(np.ones((2,3,4)))
  [[[1. 1. 1. 1.]
    [1. 1. 1. 1.]
    [1. 1. 1. 1.]]
   [[1. 1. 1. 1.]
    [1. 1. 1. 1.]
    [1. 1. 1. 1.]]]

• np.empty(shape) : 초기화 되지 않은 N차원 배열 생성

  print(np.empty((2,3)))
  [[2.45757343e-316 0.00000000e+000 0.00000000e+000]
   [0.00000000e+000 0.00000000e+000 0.00000000e+000]]

• np.arange(start, stop, step): N 만큼 차이나는 숫자 생성, stop 은 포함되지 않는다

  print(np.arange(0, 10, 2))
  [0 2 4 6 8]

• np.linspace(start, stop, num): N 등분한 숫자 생성, 처음, stop 포함됨.

  print(np.linspace(0,99, 100))
  [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17.
   18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35.
   36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53.
   54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71.
   72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89.
   90. 91. 92. 93. 94. 95. 96. 97. 98. 99.]

기본 연산

• "*" : 각각의 원소끼리 곱셈

• @ : 행렬 곱셈

  A = np.array( [[1,1], [0,1]] )
  B = np.array( [[2,0], [3,4]] )
  print(A)
  print(B)
  ---------------
  [[1 1]
   [0 1]]
  [[2 0]
   [3 4]]
  
  print(A*B)
  print(A@B)
  ---------------
  [[2 0]
   [0 4]]
  [[5 4]
   [3 4]]

• 집계함수

  • sum

  • min

  • max

  • argmax : 최대값 인덱스

  • cumsum : 누적합

  • axis 값을 매개변수로 입력하면 축을 기준으로 연산이 가능하다.

    • axis=0 (열기준)

    • axis=1 (행기준)

      b = np.arange(12).reshape(3, 4)
      [[ 0  1  2  3]
       [ 4  5  6  7]
       [ 8  9 10 11]]
      
       print(b.sum(axis=0))
       [12 15 18 21]
       print(b.sum(axis=1))
       [ 6 22 38]

• 인덱싱, 슬라이싱

  • 배열 자체를 가지고 인덱싱이 가능 하다. 배열의 인덱스 값으로 배열 자체가 들어갈 수도 있다.

    a = np.arange(12).reshape(3,4)
    print(a)
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    
    b=a>4
    print(b)
    [[False False False False]
     [False  True  True  True]
     [ True  True  True  True]]
    
    print(a[b])
    a[b].shape 
    [ 5  6  7  8  9 10 11]
    (7,)
    
    a[b]=0
    print(a)
    [[0 1 2 3]
     [4 0 0 0]
     [0 0 0 0]]

• 크기 변경

  • revel : 1차원으로 변경
  • reshape : 지정한 차원으로 변경
  • T : 전치 변환

  a = np.arange(12).reshape(3,4)
  print(a)
  print(a.shape)
  
  [[ 0  1  2  3]
   [ 4  5  6  7]
   [ 8  9 10 11]]
  (3, 4)
  
  print(a.ravel())   # a.reshape(-1)
  [ 0  1  2  3  4  5  6  7  8  9 10 11]
  
  print(a.T)
  [[ 0  4  8]
   [ 1  5  9]
   [ 2  6 10]
   [ 3  7 11]]

• 데이터 합치기

  • vstack (열기준), hstack(행기준)

    a = np.array([1, 2, 3, 4]).reshape(2, 2)
    print(a)
    [[1 2]
     [3 4]]
    
    b = np.array([5, 6, 7, 8]).reshape(2, 2)
    print(b)
    [[5 6]
     [7 8]]
    
    print(np.vstack((a,b)))
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    
    print(np.hstack((a,b)))
    [[1 2 5 6]
     [3 4 7 8]]

  • hsplit

    • 숫자 1개일경우 숫자기준으로 X개 등분

    • 리스트 넣을 경우 인덱스 기준 분할 (start, end) 일경우 end 는 포함되지 않음

      [[ 0  1  2  3  4  5]
       [ 6  7  8  9 10 11]]
      
      np.hsplit(a, 3)
      [array([[0,1],[6,7]]), 
       array([[2,3],[8,9]]), 
       array([[4,5],[10,11]])]
      
      np.hsplit(a, (3,4))
      [array([[0, 1, 2],[6, 7, 8]]), 
       array([[3],[9]]), 
       array([[ 4,  5],[10, 11]])]

현재 conda 를 사용한  python 가상 환경의 버전은 3.8.2 로 되어있다.

이것을 변경하기 위해서는 다음과 같은 절차를 거친다.

1. 설치 가능한 python 버전 확인
conda search python
위 명령어를 사용하면 설치 가능한 python 버전을 확인 할 수 있다.

2. python 설치
conda install python=버전

3. 가상환경 재접속
가상환경을 deactivate 하고 다시 activate 하면 파이썬 버전이 변경되어있다.

Mac 에서 Conda 는 간단히 설치가 가능 하다. .

brew install conda
....
## 설치 완료시
anaconda was successfully installed!

➜  ~ conda -V
zsh: command not found: conda

설치 완료 후에 실행을 해보면 저렇게 not found 가 나올수 있다. 현재 사용중인 터미널에 path 가 입력이 안되어서 저런 현상이 발생한다. 

➜  ~ /usr/local/anaconda3/bin/conda init zsh
no change     /usr/local/anaconda3/condabin/conda
no change     /usr/local/anaconda3/bin/conda
no change     /usr/local/anaconda3/bin/conda-env
no change     /usr/local/anaconda3/bin/activate
no change     /usr/local/anaconda3/bin/deactivate
no change     /usr/local/anaconda3/etc/profile.d/conda.sh
no change     /usr/local/anaconda3/etc/fish/conf.d/conda.fish
no change     /usr/local/anaconda3/shell/condabin/Conda.psm1
modified      /usr/local/anaconda3/shell/condabin/conda-hook.ps1
no change     /usr/local/anaconda3/lib/python3.10/site-packages/xontrib/conda.xsh
no change     /usr/local/anaconda3/etc/profile.d/conda.csh
modified      /Users/test/.zshrc

==> For changes to take effect, close and re-open your current shell. <==

/usr/local/anaconda3/bin 은 conda 가 설치된 위치이다. conda 명령어와 함께 init 현재 사용중인 쉘을 입력해주면 저렇게 뭔가 쭉 나온다. 마지막에 보면 modified /Users~ 가 보인다. .zshrc 파일이 뭔가 수정된것으로 보인다. 한번 확인해보면 다음과 같은 내용들이 추가되어 있다.

# >>> conda initialize >>>
# !! Contents within this block are managed by 'conda init' !!
__conda_setup="$('/usr/local/anaconda3/bin/conda' 'shell.zsh' 'hook' 2> /dev/null)"
if [ $? -eq 0 ]; then
    eval "$__conda_setup"
else
    if [ -f "/usr/local/anaconda3/etc/profile.d/conda.sh" ]; then
        . "/usr/local/anaconda3/etc/profile.d/conda.sh"
    else
        export PATH="/usr/local/anaconda3/bin:$PATH"
    fi
fi
unset __conda_setup
# <<< conda initialize <<<

이렇게 확인한 후 쉘을 닫았다가 다시 열면 정상적으로 명령어들이 동작한다.

➜  ~ conda -V
conda 23.1.0
➜  ~ conda activate
(base) ➜  ~

참고로 현재 사용중인 shell 을 확인하는 방법은 다음과 같다.
echo $SHELL

• 이터러블 객체
  • 순서가 있는 자료형
  • 문자열, 리스트, 튜플, 딕셔너리, range 객체
  • __iter__(), __next__() 메소드가 정의되어있다.
• 제너레이터 함수
  • 이터레이터를 만드는 함수이다.
  • yield 사용한다
  • 제너레이터 표현식을 사용해서 만들 수 있다.
  • 메모리 사용이 효율적이다.
    • List 같은 경우 결과 값을 메모리에 저장한다.
    • 제너레이터의 경우 식만 저장할뿐 값을 저장 하지 않는다. __next__ 함수가 호출 될 때에 결과값을 만든다

# yield 사용
def gen_func(*args):
  for arg in args:
    yield arg

month = gen_func('1월', '2월', '3월', '4월')

print(month.__next__())   # 1월
print(month.__next__())   # 2월
print(month.__next__())   # 3월
print(month.__next__())   # 4월


# 제너레이터 표현식 -> () 를 사용한다.
double_generator = (i * 2 for i in range(1,10))

for i in double_generator:
  print(i)


# 메모리 차이
import sys

list_data = [i * 3 for i in range(1, 10000+1)]
generator_data = (i * 3 for i in range(1, 10000+1))

print(sys.getsizeof(list_data))       # 85176
print(sys.getsizeof(generator_data))  # 208

• 내부함수
  • 함수 안에서 정의 되는 함수
• 클로저(closure)
  • 함수가 종료되어도 자원을 사용할 수 있는 함수
  • 클로저 조건
    • 내부함수
    • 외부함수 변수를 참조해야 한다.
    • 외부함수가 내부함수를 반환 해야 한다.

def outer(name):			# 외부함수
  def inner():				# 내부함수
    print(name, "하이")			# 외부함수 변수 참조
  return inner				# 내부함수 반환
  
callfunc = outer("tom")  
callfunc()  

# OUTPUT
tom 하이

• 클로저 살펴보기

print(dir(callfunc))
# ['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
print(type(callfunc.__closure__))
# <class 'tuple'>
print(callfunc.__closure__[0])
# <cell at 0x00000233CBE8A6E0: str object at 0x00000233CBE93B30>
print(dir(callfunc.__closure__[0]))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']
print(callfunc.__closure__[0].cell_contents)
# tom

• 라인 1: dir 로 callfunc 를 살표보면 __closure__ 가 존재하는것을 볼수 있다.
• 라인 3: __closure__ 의 타입은 tuple 이다.
• 라인 5: __closure__[0] 번째 항목을 출력한 결과이다.
• 라인 7:__closure__[0] 을 dir 로 살펴보면 cell_contents 가 존재하는 것을 볼수 있다.
• 라인 9: cell_contents 를 출력해보면 외부함수 변수의 값인 tom 이 있는것을 확인 할 수 있다.
• 위 코드에서 callfunc = outer("tom") 호출 시점에 외부함수는 종료가 된다. 하지만 종료가 된 후에도 callfunc() 가 외부함수 변수 값인 "tom" 을 출력할 수 있는 이유는 클로저 공간에 변수의 값을 저장하고 있기 때문이다.

• 인스턴스 메소드
  • 인스턴스 속성에 접근하는 메소드
  • self 를 파라미터로 받는다.
• 클래스 메소드
  • 클래스 속성에 접근하는 메소드
  • 클래스를 의미하는 cls 를 파라미터로 받는다
  • @classmethod 를 붙인다

class Unit:
  count = 0
  def __init__(self, name, weight, height, hidden):
    self.name=name
    self.weight=weight
    self.height=height
    self.__hidden=hidden
    Unit.count +=1
    print(f"{self.name} Unit 생성")
  
  def __str__(self):
    return f"name={self.name} weight={self.weight} height={self.height}"
  
  # 인스턴스 메소드
  # 인스턴스 속성에 접근하는 메소드
  def loseWeight(self, value):
    self.weight = self.weight - value
    print(f"무게가 {value} 만큼 줄었습니다. 현재는 {self.weight} 입니다.")

  # 클래스 메서드
  # 클래스 속성에 접근하는 메소드
  # cls를 파라미터로 받는다
  @classmethod
  def print_count(cls):
    print(f"생성된 Unit 개수 = {cls.count}")
    
unit1 = Unit("Unit1", 20, 30, "magic")
print(unit1)
print(unit1.loseWeight(10))
Unit.print_count()

# OUTPUT
Unit1 Unit 생성
name=Unit1 weight=20 height=30
무게가 10 만큼 줄었습니다. 현재는 10 입니다.
생성된 Unit 개수 = 2

• 정적 메소드
  • 인스턴스를 만들 필요가 없다.
  • self 를 받지 않는다.
  • @staticmethod 를 붙인다

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

print(Math.add(3,5))

• 매직 메소드
  • __이름__ 형태로 되어있다.
  • __init__ : 객체가 생성될때 실행되는 메소드
  • __str__ :  객체를 출력하는 메소드

• 인스턴스 속성
  • 객체마다 다르게 갖고 있는 속성
  • 코드에서 self 로 표기된 속성들이 인스턴스 속성이다.
• 클래스 속성
  • 모든 객체가 공유하는 속성
  • count 가 클래스 속성
  • 접근시에는 클래스이름.속성 으로 접근 (ex : Unit.count)
• 비공개 속성
  • 클래스 안에서만 접근 가능한 속성
  • __hidden 이 비공개 속성이다.
  • 외부에서 변경시 Unit.__hidden 으로는 접근이 불가능 하다
  • 네이밍 맹글링에 의해서 접근은 가능하다 (unit1._Unit__hidden)

class Unit:
  count = 0
  def __init__(self, name, weight, height, hidden):
    self.name=name
    self.weight=weight
    self.height=height
    self.__hidden=hidden
    Unit.count +=1
    print(f"{self.name} Unit 생성")
  
  def __str__(self):
    return f"name={self.name} weight={self.weight} height={self.height}"


unit1 = Unit("Unit1", 20, 30, "magic")
unit2 = Unit("Unit2", 100, 200, "power")

print(unit1)
print(unit2)
print(Unit.count)
print(unit1._Unit__hidden)

# OUTPUT
Unit1 Unit 생성
Unit2 Unit 생성
name=Unit1 weight=20 height=30
name=Unit2 weight=100 height=200
2
magic

• map 함수
  • map(함수, 순서가 있는 자료형)
  • map 의 결과는 map object 이기 때문에 사용하기 편한 list 형태로 변환한다.

def remove_blank(x):
  return x.strip()

items=[' mouse', ' monitor ']

items=list(map(remove_blank, items))

print(items)

# output
# ['mouse', 'monitor']

# 람다함수로 표기할 경우
items=list(map(lambda x:x.strip(), items))

• filter 함수
  • filter(함수, 순서가 있는 자료형)

def func(x):
  return x < 0

print(list(filter(func, [-3, 0, 2, 7, -7])))

# output
# [-3, -7]

# 람다함수로 표현
print(list(filter(lambda x:x<0, [-3, 0, 2, 7, -7])))