# Numpy (Numeric python)
> - 패키지 이름과 같이 **수리적 파이썬 활용**을 위한 파이썬 패키지
> - **선형대수학 구현**과 **과학적 컴퓨팅 연산**을 위한 함수를 제공
> - (key) `nparray` 다차원 배열을 사용하여 **벡터의 산술 연산**이 가능
> - **브로드캐스팅**을 활용하여 shape(형태 혹은 모양)이 다른 데이터의 연산이 가능
>> - 기존 언어에서는 제공 X
>> - 굉장히 파워풀한 기능으로서 빅데이터 연산에 굉장히 효율이 좋음     

## Numpy 설치 와 import
> - 선행 학습을 통해 클래스와 함수에서 클래스를 불러들여 사용할 수 있다고 배웠습니다.
- 다만 직접 작성한 클래스가 아닐경우, 그리고 현재 컴퓨터에 사용해야 할 패키지가 없을경우 간단한 명령어로 설치가능.
>> - `pip`, `conda` 명령어 : python 라이브러리 관리 프로그램으로 오픈소스라이브러리를 간편하게 설치 할 수 있도록 하는 명령어

> - 1. 콘솔창에서 실행 시  
**`pip` `install` `[패키지명]`** 혹은  
**`conda` `install` `[패키지명]`**
> - 2. 주피터 노트북으로 실행 시  
**`!pip` `install` `[패키지명]`**  
> - 아나콘다 환경으로 python 환경설정 시 기본적으로 Numpy 설치가 되어있음


```python
# 주피터 노트북에서 Numpy 설치
!pip install numpy
```

    [33mDEPRECATION: Configuring installation scheme with distutils config files is deprecated and will no longer work in the near future. If you are using a Homebrew or Linuxbrew Python, please see discussion at https://github.com/Homebrew/homebrew-core/issues/76621[0m
    Requirement already satisfied: numpy in /opt/homebrew/lib/python3.9/site-packages (1.21.2)



```python
# Numpy 사용을 위해 패키지 불러들이기
import numpy as np
# 관례적으로 np라는 약자를 많이 사용하게 됩니다.
# 파이썬을 사용하는 대부분의 유저들이 사용하고 있는 닉네임이니 이건 꼭 지켜서 사용해주시는 것을 추천드립니다.
```

## 데이터분석을 위한 잠깐의 선형대수학
numpy는 기본적으로 수리적 컴퓨팅을 위한 패키지 입니다. 선형대수학을 약간만 이해한다면 데이터를 훨씬 더 깊이있게 다룰 수 있습니다.  


출처 : https://art28.github.io/blog/linear-algebra-1/

### 데이터의 구분에 따른 표현 방법과 예시

#### 스칼라
    1, 3.14, 실수 혹은 정수  
    
#### 벡터
    [1, 2, 3, 4], "문자열"
    
#### 3 X 4 매트릭스
    [[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 0, 11, 12]]
     
#### 2 X 3 X 4 텐서
    [[[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 0, 11, 12]],
     [[1, 2, 3, 4], 
     [5, 6, 7, 8],
     [9, 0, 11, 12]]]

### 데이터로 표현한 선형대수학


출처 : https://m.blog.naver.com/nabilera1/221978354680

### 데이터 형태에 따른 사칙연산

> 스칼라 +, -, *, / -> 결과도 스칼라  
벡터 +, -, 내적 -> +, - 결과는 벡터, 내적 결과는 스칼라  
매트릭스 +, -, *, /  
텐서 +, -, *, /  

### 데이터분석에 자주 사용하는 특수한 연산
벡터와 벡터의 내적
    
$$\begin{bmatrix}1 & 2 & 3 & 4 \end{bmatrix} \times \begin{bmatrix}1 \\ 2 \\ 3 \\ 4 \end{bmatrix} = 1 * 1 + \
2 * 2 + 3 * 3 + 4 * 4 = 30$$
# $$ A^TA $$

#### 벡터와 벡터의 내적이 이루어지려면
    
    1. 벡터가 마주하는 shape의 갯수(길이)가 같아야 합니다.
    2. 연산 앞에 위치한 벡터는 전치(transpose) 되어야 합니다.
  
출처 : https://ko.wikipedia.org/wiki/%EC%A0%84%EC%B9%98%ED%96%89%EB%A0%AC

#### 벡터 내적으로 방정식 구현

$$y = \begin{bmatrix}1 & 2 & 1 \end{bmatrix} \times \begin{bmatrix}x_1 \\ x_2 \\ x_3 \\ \end{bmatrix} = 1 * x_1 + \
2 * x_2 + 1 * x_3 = x_1 + 2x_2 + x_3$$

## 브로드캐스팅
> 파이썬 넘파이 연산은 브로드캐스팅을 지원합니다.  
벡터연산 시 shape이 큰 벡터의 길이만큼 shape이 작은 벡터가 연장되어 연산됩니다.

  
출처 : http://www.astroml.org/book_figures/appendix/fig_broadcast_visual.html


```python
np.arange(3).reshape((3,1))+np.arange(3)
```




    array([[0, 1, 2],
           [1, 2, 3],
           [2, 3, 4]])



## Numpy function(유니버셜함수)
> `numpy`는 컴퓨팅연산을 위한 다양한 연산함수를 제공합니다.  
>> 연산함수 기본구조  
ex) **`np.sum`**(연산대상, axis=연산방향)  
**`dtype()`**

### 수리연산
- **`prod()`**
- **`dot()`**
- **`sum()`**
- **`cumprod()`**
- **`cumsum()`**
- **`abs()`**
- **`sqaure()`**
- **`sqrt()`**
- **`exp()`**
- **`log()`**

### 통계연산
- **`mean()`**
- **`std()`**
- **`var()`**
- **`max()`**
- **`min()`**
- **`argmax()`**
- **`argmin()`**

### 로직연산
- **`arange()`**
- **`isnan()`**
- **`isinf()`**
- **`unique()`**

### 기하
- **`shape()`**
- **`reshape()`**
- **`ndim()`**
- **`transpose()`**
    
각종 연산 함수 참고: https://numpy.org/doc/stable/reference/routines.math.html

### numpy 함수 실습


```python
# 함수 예제를 위한 데이터셋
test_list = [1, 2, 3, 4]
test_list2 = [[1, 3], [5, 7]]
test_flist = [1, 3.14, -4.5]
test_list_2nd = [[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]]
test_list_3rd = [[[1, 2, 3, 4],
              [5, 6, 7, 8]],
              
              [[1, 2, 3, 4],
               [5, 6, 7, 8]],

              [[1, 2, 3, 4],
               [5, 6, 7, 8]]]
test_exp = [0, 1, 10]
test_nan = [0, np.nan, np.inf]
```


```python
# 곱연산
np.prod(test_list)
```




    24




```python
# 합연산
np.sum(test_list)
```




    10




```python
# 누적곱연산 벡터형태
np.cumprod(test_list)
```




    array([ 1,  2,  6, 24])




```python
# 누적합연산
# 매일/매월 매출에 대한 계산을 할 때 자주 사용
np.cumsum(test_list)
```




    array([ 1,  3,  6, 10])




```python
# 절대값
np.abs(test_flist)
```




    array([1.  , 3.14, 4.5 ])




```python
# 제곱
np.sqrt(test_list)
```




    array([1.        , 1.41421356, 1.73205081, 2.        ])




```python
# 루트

```


```python
# exp

```


```python
# 로그

```

### 통계값


```python
# 평균
np.mean(test_list)
```




    2.5




```python
# 표준편차
np.std(test_list)
```




    1.118033988749895




```python
# 분산
np.var(test_list)
```




    1.25




```python
# 최대값

```


```python
# 최소값

```


```python
test_list_2nd
```




    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]




```python
# 최대값이 존재하고 있는 인덱스 넘버를 리턴
# 출력값이 인덱스
np.argmax(test_list_2nd)
```




    8




```python
# 최소값 인덱스
np.argmin(test_list_2nd)
```




    0




```python
# 범위설정
# range() 함수와 동일하게 작동함
# for i in range(0, 100, 10):
#     print(i)
#(시작포인트, 마지막포인트+1, 스텝수)
np.arange(10, 100, 10)
```




    array([10, 20, 30, 40, 50, 60, 70, 80, 90])




```python
# 범위설정2
#(시작포인트, 마지막포인트+1, 데이터수)
np.linspace(0, 10, 50)  # 0~10까지 50개 동일간격으로
```




    array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,
            1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,
            2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,
            3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,
            4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,
            5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,
            6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,
            7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,
            8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,
            9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])




```python
test_nan
```




    [0, nan, inf]




```python
# 결측 확인(nan 확인)
np.isnan(test_nan)
```




    array([False,  True, False])




```python
# 발산 확인(무한대 확인)
np.isinf(test_nan)
```




    array([False, False,  True])




```python
test_list_3rd
```




    [[[1, 2, 3, 4], [5, 6, 7, 8]],
     [[1, 2, 3, 4], [5, 6, 7, 8]],
     [[1, 2, 3, 4], [5, 6, 7, 8]]]




```python
# 고유값 확인
np.unique(test_list_3rd)
len(np.unique(test_list_3rd))
```




    8




```python
# 데이터 구조(모양)확인(차원 확인)
# 안쪽(열)shape부터 확인하자
np.shape(test_list_3rd)
```




    (3, 2, 4)




```python
# 데이터 shape 변경
# 어떤 조건에서 reshape가능한가? 데이터 내부에 존재하는 속성 갯수가 같아야 함.
np.reshape(test_list_3rd, (4,6))
np.reshape(test_list_3rd, (2,2,6))
```




    array([[[1, 2, 3, 4, 5, 6],
            [7, 8, 1, 2, 3, 4]],
    
           [[5, 6, 7, 8, 1, 2],
            [3, 4, 5, 6, 7, 8]]])




```python
test_list_3rd
```




    [[[1, 2, 3, 4], [5, 6, 7, 8]],
     [[1, 2, 3, 4], [5, 6, 7, 8]],
     [[1, 2, 3, 4], [5, 6, 7, 8]]]




```python
# 데이터 차원확인
np.ndim(test_list_3rd)
# 기하학적 데이터의 차원수를 이야기하고 데이터분식시 열기준으로 차원을 이야기한다
```




    3




```python
test_list_2nd
```




    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]




```python
# 전치행렬
np.transpose(test_list_2nd)
```




    array([[1, 4, 7],
           [2, 5, 8],
           [3, 6, 9]])




```python
test_list
```




    [1, 2, 3, 4]




```python

```

## Numpy array (배열, 행렬)
> - numpy 연산의 기본이 되는 데이터 구조입니다.  
- 리스트보다 간편하게 만들 수 있으며 **연산이 빠른** 장점이 있습니다.  
- **브로드캐스팅 연산을 지원**합니다.  
- 단, **같은 type**의 데이터만 저장 가능합니다.  
- array 또한 numpy의 기본 함수로서 생성 가능합니다.  
>> array 함수 호출 기본구조  
ex) **`np.array(배열변환 대상 데이터)`**  
ex) **`np.arange(start, end, step_forward)`**

### numpy array 실습


```python
# 기존 데이터 구조를 array로 변환
test_array = np.array(test_list)
test_array2 = np.array(test_list2)
test_farray = np.array(test_flist)
test_array_2nd = np.array(test_list_2nd)
test_array_3rd = np.array(test_list_3rd)
```


```python
# array 생성 확인
test_array
```




    array([1, 2, 3, 4])




```python
array_list = [1,2,4.5]
```


```python
# 같은 타입의 데이터만 들어가는지 확인
array_test = np.array(array_list)
```


```python
array_test   # 정수, 실수, 문자열 순으로 전체 타입이 설정됨
```




    array([1. , 2. , 4.5])




```python
# 2차원 배열 확인
test_list_2nd
# 2차원 배열을 좀 더 편하게 보여줌
test_array_2nd
```




    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])




```python
# 3차원 배열 확인
test_list_3rd
test_array_3rd
```




    array([[[1, 2, 3, 4],
            [5, 6, 7, 8]],
    
           [[1, 2, 3, 4],
            [5, 6, 7, 8]],
    
           [[1, 2, 3, 4],
            [5, 6, 7, 8]]])




```python
# np.arange 함수로 생성
np.arange(25).reshape(5,5)
```




    array([[ 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]])




```python
np.arange(1,25).reshape(2,12)
```




    array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12],
           [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])



### 특수한 형태의 array를 함수로 생성
함수 호출의 기본구조
> ex) **`np.ones([자료구조 shape])`**  
>> 자료구조 shape은 정수, **[ ]**리스트, **( )** 튜플 로만 입력가능합니다.
- ones()
- zeros()
- empty()
- eye()


```python
# 1로 초기화한 array 생성
np.ones([3,3])
```




    array([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]])




```python
# 0으로 초기화
np.zeros((5,5))
```




    array([[0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0.]])




```python
# 빈 값으로 초기화
np.empty((2,2))
```




    array([[0., 0.],
           [0., 0.]])




```python
# 항등행렬 초기화
# A X 항등행렬 = A
# shape가 안맞는 경우 연산이 가능하도록 만들때 사용
np.eye(4,4)

# 예시
# 날짜 매출
# 날짜 매출
# 날짜 매출
# 날짜 매출
# 날짜 매출

# 날짜 날짜 날짜 날짜 날짜
# 매출 없고 없고 없고 없고
# 없고 매출 없고 없고 없고
# 없고 없고 매출 없고 없고 
```




    array([[1., 0., 0., 0.],
           [0., 1., 0., 0.],
           [0., 0., 1., 0.],
           [0., 0., 0., 1.]])




```python
np.arange(16).reshape(4,4) @ np.eye(4,4)
```




    array([[ 0.,  1.,  2.,  3.],
           [ 4.,  5.,  6.,  7.],
           [ 8.,  9., 10., 11.],
           [12., 13., 14., 15.]])




```python
test_array @ np.transpose(test_array)
```




    array([1, 2, 3, 4])



### array 속성 및 내장함수
`np.array` 에는 유용한 수리, 통계 연산을 위한 함수가 갖추어져 있습니다. 다차원 기하학적 연산을 위한 함수도 함께 살펴보겠습니다.  
    
> array 내장 속성 호출 기본구조  
ex) **`test_array.ndim`**  
자주 사용하는 속성 `shape`, `dtype`, `ndim`
    
> array 내장함수 호출 기본구조  
ex) **`test_array.prod()`**
    
위에 학습한 np.sum() 과는 달리 array 변수의 인자를 받아 그대로 사용합니다.

#### array 속성


```python
test_array_3rd
```




    array([[[1, 2, 3, 4],
            [5, 6, 7, 8]],
    
           [[1, 2, 3, 4],
            [5, 6, 7, 8]],
    
           [[1, 2, 3, 4],
            [5, 6, 7, 8]]])




```python
# 데이터 타입확인
test_array_3rd.dtype
```




    dtype('int64')




```python
# 데이터 타입 확인
test_array_3rd.shape
```




    (3, 2, 4)




```python
# 데이터 차원 확인
test_array_3rd.ndim
```




    3




```python
# 전치행렬
np.transpose(test_array_3rd)
test_array_3rd.T
```




    array([[[1, 1, 1],
            [5, 5, 5]],
    
           [[2, 2, 2],
            [6, 6, 6]],
    
           [[3, 3, 3],
            [7, 7, 7]],
    
           [[4, 4, 4],
            [8, 8, 8]]])



#### array 내장함수


```python
# 내장함수 호출
test_array.mean()
np.sqrt(test_array)
```




    array([1.        , 1.41421356, 1.73205081, 2.        ])




```python
# numpy 함수와 키워드가 같습니다.
test_array.prod()
test_array.sum(axis=)
...
... 
```

### array 연산
컴퓨팅 연산을 위한 패키지인 만큼 편리한 배열 연산 기능을 지원합니다. 여러 array 연산을 통해 다른 자료구조와의 연산 차이를 알아봅시다.


```python
test_list = [1,2,3,4,5]
test_list2 = [x*2 for x in test_list]
test_list2
```




    [2, 4, 6, 8, 10]




```python
# array 덧셈, 뺄셈, 곱셈, 나눗셈
test_array = np.array(test_list)
test_array > 1
```




    array([False,  True,  True,  True,  True])




```python
# 실제 연산속도 차이를 확인하기 위한 큰 데이터 생성
big_list = [x for x in range(400000)]
big_array = np.array(big_list)
len(big_list), len(big_array)
```




    (400000, 400000)




```python
# for로 각 리스트에 1씩 값을 더함
big_list2 = [x+1 for x in big_list]  # 일반적인 for문보다 빠름(파이썬은 줄단위로 값을 확인)

# for index, item in enumerate(big_list):
#     big_list[index] = item + 1
```

    UsageError: Line magic function `%%time` not found.



```python
# array성질을 이용
big_array + 1
```




    array([     1,      2,      3, ..., 399998, 399999, 400000])




```python
# 행렬내적
first_array = np.arange(15).reshape(5, 3)
second_array = np.arange(15).reshape(3, 5)
```


```python
first_array.shape, second_array.shape
```




    ((5, 3), (3, 5))




```python
# 행렬내적 연산
first_array @ second_array
```




    array([[ 25,  28,  31,  34,  37],
           [ 70,  82,  94, 106, 118],
           [115, 136, 157, 178, 199],
           [160, 190, 220, 250, 280],
           [205, 244, 283, 322, 361]])



### 벡터 가중합
벡터의 내적은 가중합을 계산할 때 쓰일 수 있다. **가중합(weighted sum)**이란 복수의 데이터를 단순히 합하는 것이 아니라 각각의 수에 어떤 가중치 값을 곱한 후 이 곱셈 결과들을 다시 합한 것을 말한다.  
만약 데이터 벡터가 $x=[x_1, \cdots, x_N]^T$이고 가중치 벡터가 $w=[w_1, \cdots, w_N]^T$이면 데이터 벡터의 가중합은 다음과 같다.

$$ 
\begin{align}
w_1 x_1 + \cdots + w_N x_N = \sum_{i=1}^N w_i x_i 
\end{align}
$$ 

이 값을 벡터 $x$와 $w$의 곱으로 나타내면 $w^Tx$ 또는 $x^Tw$ 라는 간단한 수식으로 표시할 수 있다.

쇼핑을 할 때 각 물건의 가격은 데이터 벡터, 각 물건의 수량은 가중치로 생각하여 내적을 구하면 총금액을 계산할 수 있다.


```python
# 벡터의 가중합 연습문제
# 삼성전자, 셀트리온, 카카오로 포트폴리오를 구성하려한다. 
# 각 종목의 가격은 80,000원, 270,000원, 160,000원이다.
# 삼성전자 100주, 셀트리온 30주, 카카오 50주로 구성하기 위한 매수금액을 구하시오
price = np.array([80000,270000,160000])
item = np.array([100,30,50])
price @ item.T
# shape가 맞지 않는데도 결과가 나옴 => @ 연산을하면 item.T로 작동함
price @ item
```




    24100000



### array 인덱싱, 슬라이싱(매우중요)
> 기본적으로 자료구조란 데이터의 묶음, 그 묶음을 관리 할 수 있는 바구니를 이야기 합니다.  
데이터 분석을 위해 자료구조를 사용하지만 자료구조안 내용에 접근을 해야 할 경우도 있습니다.
>> **인덱싱**이란?  
데이터 바구니 안에 든 내용 하나에 접근하는 명령, 인덱스는 내용의 순번  
>> **슬라이싱**이란?  
데이터 바구니 안에 든 내용 여러가지에 접근 하는 명령  

기본적으로 인덱싱과 슬라이싱의 색인은 리스트와 동일합니다.

#### 인덱싱, 슬라이싱 실습


```python
# 10부터 19까지 범위를 가지는 array생성
test = np.arange(10,20)
```


```python
# 0부터 3번 인덱스까지
test[:3]
```




    array([10, 11, 12])




```python
# 4번 인덱스부터 마지막 인덱스까지
test[4:]
```




    array([14, 15, 16, 17, 18, 19])




```python
# 마지막 인덱스부터 뒤에서 3번째 인덱스까지
test[-3:]
```




    array([17, 18, 19])




```python
# 0부터 3씩 증가하는 인덱스
test[::3]
```




    array([10, 13, 16, 19])



#### 여러가지 인덱싱 및 슬라이싱 방법을 시도해봅시다


```python
index_test2 = np.array(range(25)).reshape([5, 5])
index_test2
```




    array([[ 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]])




```python
index_test2[2:,1:4]
```




    array([[11, 12, 13],
           [16, 17, 18],
           [21, 22, 23]])




```python
index_test2[:2,2:]
```




    array([[2, 3, 4],
           [7, 8, 9]])




```python
index_test3 = np.arange(40).reshape(2, 5, 4)
index_test3
```




    array([[[ 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]]])




```python
index_test3[0,3:5,1:3]
```




    array([[13, 14],
           [17, 18]])




```python
index_test3[0:,0:,1]
```




    array([[ 1,  5,  9, 13, 17],
           [21, 25, 29, 33, 37]])



## 팬시인덱싱
numpy에서 벡터연산을 통해 bool 형태의 벡터를 기준으로 데이터를 선별하는 방법


```python
pet = np.array(['개','고양이','고양이','햄스터','개','햄스터'])
num = np.array([1,2,3,4,5,6])
indexing_test = np.random.randn(6,5)  # randn : 난수로 행렬생성
```


```python
indexing_test
```




    array([[ 1.21892182, -0.57278769, -2.01837856,  0.37751666, -2.14632145],
           [ 1.72627741,  0.19978955, -0.45559384,  2.3741275 ,  0.61280794],
           [ 0.38249301, -0.10195438,  1.1064851 ,  0.14316647, -0.01103692],
           [ 0.89879404, -0.08147537, -0.02147208,  0.77555509, -0.45326144],
           [ 0.12338784, -0.00431352, -1.31633818,  0.85516829,  0.29007829],
           [-0.17169369,  0.42409219,  1.69908292,  1.43223254, -1.29304307]])




```python
pet == '개'
```




    array([ True, False, False, False,  True, False])




```python
indexing_test[pet=='개']
```




    array([[ 1.21892182, -0.57278769, -2.01837856,  0.37751666, -2.14632145],
           [ 0.12338784, -0.00431352, -1.31633818,  0.85516829,  0.29007829]])




```python
indexing_test[~(pet=='개')]
```




    array([[ 1.72627741,  0.19978955, -0.45559384,  2.3741275 ,  0.61280794],
           [ 0.38249301, -0.10195438,  1.1064851 ,  0.14316647, -0.01103692],
           [ 0.89879404, -0.08147537, -0.02147208,  0.77555509, -0.45326144],
           [-0.17169369,  0.42409219,  1.69908292,  1.43223254, -1.29304307]])




```python
(pet=='개') | (pet=='햄스터')
```




    array([ True, False, False,  True,  True,  True])




```python
indexing_test[(pet=='개') | (pet=='햄스터')]
```




    array([[ 1.21892182, -0.57278769, -2.01837856,  0.37751666, -2.14632145],
           [ 0.89879404, -0.08147537, -0.02147208,  0.77555509, -0.45326144],
           [ 0.12338784, -0.00431352, -1.31633818,  0.85516829,  0.29007829],
           [-0.17169369,  0.42409219,  1.69908292,  1.43223254, -1.29304307]])




```python
num > 3
```




    array([False, False, False,  True,  True,  True])




```python
indexing_test[num>3]
```




    array([[ 0.89879404, -0.08147537, -0.02147208,  0.77555509, -0.45326144],
           [ 0.12338784, -0.00431352, -1.31633818,  0.85516829,  0.29007829],
           [-0.17169369,  0.42409219,  1.69908292,  1.43223254, -1.29304307]])




```python
# bool 형태는 1,0으로 계산이 된다
(pet =='개').sum()
```




    2




```python
# true가 1개라도 있으면 true
(pet =='개').any()
```




    True




```python
(pet =='개').all()
```




    False



37befcb53e5804c7b7f02bac823d4a10b4affb58
ipynb
Jupyter Notebook
python/210910-Python-numpy.ipynb
PpangPpang93/TIL
63e541f223f2317fff06d98cac79f372fd11ed1d
MIT
python/210910-Python-numpy.ipynb
PpangPpang93/TIL
63e541f223f2317fff06d98cac79f372fd11ed1d
MIT
python/210910-Python-numpy.ipynb
PpangPpang93/TIL
63e541f223f2317fff06d98cac79f372fd11ed1d
MIT
Qwen/Qwen-72B
1. YES
2. YES