[Numpy] Numpy 의 주요함수

1. 배열 생성 함수

•  np.array()  : 파이썬 리스트나 튜플을 배열로 변환
•  np.zeros()  : 모든 요소가 0 인 배열을 생성
•  np.ones()  : 모든 요소가 1인 배열을 생성
•  np.arange()  : 등간격의 숫자를 생성
• np.linspace()  : 지정한 구간을 균등하게 나눈 값을 생성

 np.array() 

• 파이썬 리스트나 튜플을 배열로 변환한다.

import numpy as np

a = np.array([1, 2, 3])
print(a)  # [1 2 3]

 

 

 np.zeros() 

• 모든 요소가 0 인 배열을 생성한다.

zeros_array = np.zeros((2, 3))  # 2x3 크기의 0으로 채워진 배열
print(zeros_array)
# [[0. 0. 0.]
#  [0. 0. 0.]]

 

 

 np.ones() 

• 모든 요소가 1인 배열을 생성한다.

ones_array = np.ones((3, 2))
print(ones_array)
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

 

 

 np.arange() 

• 등간격의 숫자를 생성

range_array = np.arange(0, 10, 2)  # 0부터 10까지 2 간격
print(range_array)  # [0 2 4 6 8]

 

 

 np.linspace() 

• 지정한 구간을 균등하게 나눈 값을 생성

linear_array = np.linspace(0, 1, 5)  # 0부터 1까지 5개 값 생성
print(linear_array)  # [0.   0.25 0.5  0.75 1.  ]

 

---

2. 배열 형태 변경

•  np.reshape()  : 배열의 형태를 변경
•  np.ravel()  : 다차원 배열을 1D 로 펼침

 np.reshape() 

• 배열의 형태를 변경

a = np.arange(6)
reshaped = a.reshape(2, 3)  # 1D 배열을 2x3 배열로 변환
print(reshaped)
# [[0 1 2]
#  [3 4 5]]

 

 

 np.ravel() 

• 다차원 배열을 1D로 펼침

b = np.array([[1, 2], [3, 4]])
flattened = b.ravel()
print(flattened)  # [1 2 3 4]

---

3. 수학 함수

•  np.sum()  : 배열의 합을 계산
•  np.mean()  : 평균을 계산
•  np.max()  와  np.min()  : 최대값과 최소값을 반환
•  np.sqrt()  : 각 요소의 제곱근을 계산

 np.sum() 

• 배열의 합을 계산

a = np.array([1, 2, 3])
print(np.sum(a))  # 6

 

 

 np.mean() 

• 평균을 계산

print(np.mean(a))  # 2.0

 

 

 np.ravel()  와  np.min() 

• 최대값과 최소값을 반환

print(np.max(a))  # 3
print(np.min(a))  # 1

 

 

 np.sqrt() 

• 각 요소의 제곱근을 계산

print(np.sqrt(a))  # [1. 1.41421356 1.73205081]

 

---

 

4. 브로드캐스팅 연산

• 넘파이는 크기가 다른 배열끼리도 연산을 가능하게 한다

a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
print(a + b)
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

 

---

5. 논리연산

•  np.where()  : 조건에 따라 요소를 선택합니다.
•  np.any()  와  np.all() 
  •  np.any()  : 하나라도 참이면  True 
  •  np.all()  : 모두 참이어야  True 

 np.where()  

• 조건에 따라 요소를 선택

a = np.array([1, 2, 3, 4, 5])
result = np.where(a > 3, a, -1)
print(result)  # [-1 -1 -1  4  5]

 

 

 np.any()  와  np.all()  

•  np.any()  : 하나라도 참이면  True 
•  np.all()  : 모두 참이어야  True 

b = np.array([True, False, True])
print(np.any(b))  # True
print(np.all(b))  # False

---

6. 난수 생성

•  np.random.rand()  : 0과 1 사이의 난수를 생성
•  np.random.randint()  : 지정된 범위의 정수를 생성
•  np.random.normal()  : 정규 분포를 따르는 난수를 생성
•  np.random.choice()  : 주어진 배열에서 임의의 요소를 선택

 np.random.rand()  

• 0과 1사이의 난수를 생성

random_array = np.random.rand(2, 3)  # 2x3 난수 배열
print(random_array)

 

 

 np.random.randint()  

• 지정된 범위의 정수를 생성

random_int = np.random.randint(0, 10, (2, 2))  # 0부터 10까지 정수로 2x2 배열 생성
print(random_int)

 

 

 np.random.normal()  

• 정규 분포를 따르는 난수를 생성

normal_array = np.random.normal(loc=0, scale=1, size=(2, 3))  # 평균 0, 표준편차 1
print(normal_array)

 

 

 np.random.choice()  

• 주어진 배열에서 임의의 요소를 선택

a = np.array([1, 2, 3, 4, 5])
choices = np.random.choice(a, size=3, replace=False)  # 중복 없이 3개 선택
print(choices)

---

7. 배열 병합 및 분할

•  np.concatenate()  : 배열을 연결
•  np.split()  : 배열을 여러 개로 분할
•  np.stack()  : 새 축을 따라 배열을 쌓음
•  np.hstack()  와   np.vstack()  : 수평 및 수직 방향으로 배열을 병합

 np.concatenate()  

• 배열을 연결

a = np.array([1, 2])
b = np.array([3, 4])
print(np.concatenate((a, b)))  # [1 2 3 4]

 

 

 np.split()  

• 배열을 여러 개로 분할

c = np.array([1, 2, 3, 4])
split_array = np.split(c, 2)
print(split_array)  # [array([1, 2]), array([3, 4])]

 

 

 np.stack()  

• 새 축을 따라 배열을 쌓음

a = np.array([1, 2])
b = np.array([3, 4])
stacked = np.stack((a, b), axis=0)
print(stacked)
# [[1 2]
#  [3 4]]

 

 

 np.hstack()  와   np.vstack()  

• 수평 및 수직 방향으로 배열을 결합

hstacked = np.hstack((a, b))  # [1 2 3 4]
vstacked = np.vstack((a, b))  # [[1 2]
                             #  [3 4]]
print(hstacked)
print(vstacked)

---

8. 배열 정보 확인

•  np.shape()  : 배열의 형태를 반환
•  np.size()  : 배열의 총 요소 개수를 반환
•  np.ndim()  : 배열의 차원 수를 반환

 np.shape()  

• 배열의 형태를 반환

a = np.array([[1, 2], [3, 4], [5, 6]])
print(a.shape)  # (3, 2)

 

 

 np.size()  

• 배열의 총 요소 개수를 반환

print(a.size)  # 6

 

 

 np.ndim()  

• 배열의 차원 수를 반환

print(a.ndim)  # 2

---

9. 배열 정렬 및 집계

•  np.sort()  : 배열을 정렬
•  np.argsort()  : 정렬된 순서의 인덱스를 반환
•  np.unique()  : 배열에서 고유한 값을 반환

 np.sort()  

• 배열을 정렬

a = np.array([3, 1, 2])
sorted_array = np.sort(a)
print(sorted_array)  # [1 2 3]

 

 

 np.argsort()  

• 정렬된 순서의 인덱스를 반환

print(np.argsort(a))  # [1 2 0]

 

 

 np.unique()  

• 배열에서 고유한 값을 반환

b = np.array([1, 2, 2, 3, 3, 3])
unique_vals = np.unique(b)
print(unique_vals)  # [1 2 3]

---

10. 선형 대수

•  np.dot()  : 행렬 곱셈을 수행
•  np.linalg.inv()  : 역행렬을 계산
•  np.linalg.eig()  : 행렬의 고유값과 고유벡터를 반환

 np.dot()  

• 행렬 곱셈을 수행

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
result = np.dot(a, b)
print(result)
# [[19 22]
#  [43 50]]

 

 

 np.linalg()  

• 역행렬을 계산

a = np.array([[1, 2], [3, 4]])
inverse = np.linalg.inv(a)
print(inverse)
# [[-2.   1. ]
#  [ 1.5 -0.5]]

 

 

 np.linalg.eig()  

• 행렬의 고유값과 고유벡터를 반환

eigenvalues, eigenvectors = np.linalg.eig(a)
print(eigenvalues)  # [ 5.37228132 -0.37228132]
print(eigenvectors)
# [[ 0.57604844  0.81741556]
#  [ 0.81741556 -0.57604844]]

---

11. 논리 연산 및 필터링

•  np.nonzero()  : 조건을 만족하는 인덱스를 반환
•  np.isin()  : 요소가 특정 값의 집합에 포함되는지 확인

 np.nonzero()  

• 조건을 만족하는 인덱스를 반환

a = np.array([1, 2, 0, 4, 0])
nonzero_indices = np.nonzero(a)
print(nonzero_indices)  # (array([0, 1, 3]),)

 

 

 np.isin()  

• 요소가 특정 값의 집합에 포함되는지 확인

a = np.array([1, 2, 3, 4])
result = np.isin(a, [2, 4])
print(result)  # [False  True False  True]

---

12. 배열 변환

•  np.transpose()  : 배열의 축을 전환
•  np.flatten()  : 배열을 1차원으로 펼침

 np.transpose()  

• 배열의 축을 전환

a = np.array([[1, 2], [3, 4]])
transposed = np.transpose(a)
print(transposed)
# [[1 3]
#  [2 4]]

 

 

 np.flatten()  

• 배열을 1차원으로 펼침

b = a.flatten()
print(b)  # [1 2 3 4]

---

13. 기타

•  np.clip()  : 값을 특정 범위로 제한
•  np.cumsum()  : 누적 합을 계산
•  np.diff()  : 배열의 차분을 계산

 np.clip()  

• 값을 특정 범위로 제한

a = np.array([1, 2, 3, 4, 5])
clipped = np.clip(a, 2, 4)  # 2 이하를 2로, 4 이상을 4로 제한
print(clipped)  # [2 2 3 4 4]

 

 

 np.cumsum()  

• 누적 합을 계산

a = np.array([1, 2, 3])
cumsum = np.cumsum(a)
print(cumsum)  # [1 3 6]

 

 

 np.diff()  

• 배열의 차분을 계산

a = np.array([1, 2, 4, 7])
difference = np.diff(a)
print(difference)  # [1 2 3]