반응형

설치

!sudo pip install kaggle

Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/
Collecting kaggle
  Downloading kaggle-1.5.13.tar.gz (63 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 63.3/63.3 kB 4.4 MB/s eta 0:00:00
Successfully built kaggle
Installing collected packages: kaggle
Successfully installed kaggle-1.5.13

kaggle api 받기

  • kaggle 로그인 > profile > api > Create New Token 클릭
  • json 파일이 다운 로드 됨
  • json 파일에는 username 과 key 값이 존재함.

colab 에 kaggle.json 파일 생성 및 copy

# kaggle.json 파일을 colab 에 생성 (생성하지 않고 다운로드된 파일을 직접 업로드 해도 된다.)
!echo "{\"username\":\"########\",\"key\":\"###############################\"}" > kaggle.json

# kaggle 에서 받은 key 파일 이동
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json

!kaggle --version

# 아래와 같이 username 과 key를 환경변수로 넣어줘도 된다는것 같은데 안되서 위 방법을 사용함.
!export KAGGLE_USERNAME=########
!export KAGGLE_KEY=###############################

 

728x90
반응형

'Development > Python' 카테고리의 다른 글

맥(Mac)에서 아나콘다(Anaconda) 제거하기  (0) 2023.08.11
머신러닝 관련 용어  (0) 2023.06.12
Pandas 사용  (0) 2023.05.23
NumPy 사용  (0) 2023.05.09
Conda python 버전 업데이트  (0) 2023.04.15
반응형

시리즈(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[] : 행 이름과 열 이름 사용
    • iloc[] : 행번호와 열 번호 사용
# 나이가 35세 초과인 사람의 이름과 나이 출력
t.loc[t['Age']>35, ['Name', 'Age']]
  • 통계 관련 기능
    • mean() : 평균값
    • median() : 중앙값
    • describe() : 통계 요약
    • agg() : 여러개 열에 여러 함수 적용
    • groupby() : 그룹별 집계
    • value_counts() : 값 개수
  • 행, 열추가
    • DataFrame.loc[새로운 행 이름] = 데이터 값
    • DataFrame['열이름']
728x90
반응형

'Development > Python' 카테고리의 다른 글

머신러닝 관련 용어  (0) 2023.06.12
colab 에서 kaggle 설정  (0) 2023.06.07
NumPy 사용  (0) 2023.05.09
Conda python 버전 업데이트  (0) 2023.04.15
Mac 에서 Conda 설치  (0) 2023.04.05
반응형

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]])]
728x90
반응형

'Development > Python' 카테고리의 다른 글

colab 에서 kaggle 설정  (0) 2023.06.07
Pandas 사용  (0) 2023.05.23
Conda python 버전 업데이트  (0) 2023.04.15
Mac 에서 Conda 설치  (0) 2023.04.05
파이썬 가상 환경 실행 및 VS Code 설정  (0) 2023.03.27
반응형

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

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

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

2. python 설치
conda install python=버전

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

 

728x90
반응형

'Development > Python' 카테고리의 다른 글

Pandas 사용  (0) 2023.05.23
NumPy 사용  (0) 2023.05.09
Mac 에서 Conda 설치  (0) 2023.04.05
파이썬 가상 환경 실행 및 VS Code 설정  (0) 2023.03.27
파이썬 문법 : 데코레이터 함수  (0) 2023.03.13
반응형

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

 

728x90
반응형

'Development > Python' 카테고리의 다른 글

NumPy 사용  (0) 2023.05.09
Conda python 버전 업데이트  (0) 2023.04.15
파이썬 가상 환경 실행 및 VS Code 설정  (0) 2023.03.27
파이썬 문법 : 데코레이터 함수  (0) 2023.03.13
파이썬 문법 : 제너레이터 함수  (0) 2023.03.09
반응형
  • 이터러블 객체
    • 순서가 있는 자료형
    • 문자열, 리스트, 튜플, 딕셔너리, 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

 

728x90
반응형
반응형
  • 내부함수
    • 함수 안에서 정의 되는 함수
  • 클로저(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" 을 출력할 수 있는 이유는 클로저 공간에 변수의 값을 저장하고 있기 때문이다.

 

728x90
반응형
반응형
  • 인스턴스 메소드
    • 인스턴스 속성에 접근하는 메소드
    • 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__ :  객체를 출력하는 메소드

 

728x90
반응형
반응형
  • 인스턴스 속성
    • 객체마다 다르게 갖고 있는 속성
    • 코드에서 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

 

728x90
반응형

+ Recent posts