Ch 13. NumPy 배열과 효율적인 계산 [파이썬 고등 수학 정복]

빠른 배열(ndarray) 처리, 벡터화, 강력한 함수 지원! 대규모 데이터, 벡터/행렬 연산도 NumPy와 함께라면 전문가처럼 쉽고 빠르게 해결할 수 있습니다.

Part 3: 더 강력한 수학 도구 (라이브러리 활용)

Chapter 13: NumPy: 숫자를 다루는 전문가

학습 목표

• 많은 양의 숫자 데이터를 파이썬 리스트 대신 NumPy로 다루면 왜 더 좋은지 구체적인 예시를 통해 이해한다.
• 수열, 벡터, 행렬 같은 수학적 대상을 NumPy 배열(ndarray)로 만들고, 그 정보(크기, 타입 등)를 확인할 수 있다.
• 만들어진 배열(예: 점수 목록, 좌표 벡터)에서 원하는 값을 뽑아내는 방법(인덱싱, 슬라이싱)을 익힌다.
• 반복문 없이 배열의 모든 요소에 똑같은 계산(예: 점수 일괄 조정)을 빠르게 적용하는 벡터화 연산을 이해하고 활용한다.
• sin, cos, sqrt 같은 수학 함수를 배열의 모든 값에 한 번에 적용하는 유니버설 함수(ufunc)를 사용한다.
• NumPy로 벡터 내적, 행렬 곱셈 같은 기본 선형대수 연산을 수행하는 방법을 익힌다.

 

---

1. 계산 속도 UP! 코드 길이 DOWN! NumPy가 필요한 이유

우리가 앞에서 파이썬 리스트(List)를 사용해서 여러 학생의 점수를 저장하고 평균을 구했었죠? (Chapter 5 참고) 예를 들어, 5명의 수학 점수가 scores = [85, 92, 78, 100, 95] 라면 평균은 sum(scores) / len(scores) 로 쉽게 구할 수 있었습니다.

하지만 만약 학생이 5명이 아니라 100만 명이라면 어떨까요? 파이썬 리스트로도 계산은 가능하지만, 컴퓨터는 내부적으로 약간 비효율적으로 동작할 수 있습니다. 특히, 각 학생 점수에 5점씩 보너스를 주려면 파이썬 리스트로는 보통 이렇게 코드를 작성해야 합니다.

scores_list = [85, 92, 78, 100, 95] # 만약 이게 100만 개라면?
bonus_scores_list = []
for score in scores_list:
    bonus_scores_list.append(score + 5) # 각 점수에 5를 더해서 새 리스트에 추가

# print(bonus_scores_list) # [90, 97, 83, 105, 100]

또는, 수학에서 자주 사용하는 벡터(Vector) 연산을 생각해 봅시다. 벡터 a = (1, 2) 와 b = (3, 4) 를 더하면 a + b = (1+3, 2+4) = (4, 6) 이 됩니다. 파이썬 리스트로 이걸 하려면 어떻게 해야 할까요?

a_list = [1, 2]
b_list = [3, 4]
sum_list = []
for i in range(len(a_list)):
    sum_list.append(a_list[i] + b_list[i]) # 같은 위치의 요소끼리 더하기

# print(sum_list) # [4, 6]

리스트만 사용하면 이렇게 for 반복문을 써야 하는 경우가 많습니다. 데이터가 많아지면 속도가 느려지고, 코드가 길어지는 불편함이 있죠.

바로 이럴 때 NumPy(넘파이, Numerical Python) 가 마법을 부립니다! NumPy는 숫자로 이루어진 대규모 데이터(특히 배열 형태)를 매우 빠르고 간결하게 처리하도록 특별히 설계된 라이브러리입니다.

NumPy를 쓰면 뭐가 좋을까요? (파이썬 리스트와 비교)

1. 속도가 훨씬 빠릅니다: 내부적으로 C언어처럼 빠른 코드로 동작하여, 특히 큰 데이터에 대한 계산 속도가 압도적입니다.
2. 코드가 간결해집니다: 위에서 본 보너스 점수 계산이나 벡터 덧셈 같은 작업을 for 반복문 없이 단 한 줄로 끝낼 수 있습니다. (이것을 벡터화 연산이라고 부릅니다!)
3. 다양한 수학 함수: 기본적인 사칙연산 외에도 삼각함수, 로그, 지수, 제곱근 등 수많은 수학 함수를 배열 전체에 쉽게 적용할 수 있습니다.
4. 벡터, 행렬 연산: 선형대수에서 배우는 벡터 내적, 행렬 곱셈 등을 위한 편리한 기능을 제공합니다.
5. 다른 과학 라이브러리의 기반: 앞으로 배울 Pandas나 그래프를 그리는 Matplotlib 등 많은 중요 라이브러리들이 NumPy를 바탕으로 만들어졌습니다. NumPy를 알면 이들을 배우기가 더 쉬워집니다.

NumPy의 핵심 도구는 ndarray(n-dimensional array, 다차원 배열)라는 특별한 데이터 통입니다. 이제 이 ndarray를 만들고 사용하는 방법을 알아봅시다!

 

2. NumPy 시작하기: 설치 및 불러오기

NumPy는 파이썬에 기본으로 포함된 기능이 아니라서, 필요하면 설치해야 합니다. (Replit 같은 온라인 환경에는 보통 이미 설치되어 있습니다.)

# 터미널이나 명령 프롬프트에서 입력 (한 번만 해주면 됩니다)
pip install numpy

파이썬 코드에서 NumPy 기능을 사용하려면, 맨 처음에 import 명령으로 불러와야 합니다. 이때, 전 세계 개발자들이 약속처럼 사용하는 별명(alias)이 있는데, 바로 np 입니다.

import numpy as np # 앞으로 np 라는 이름으로 NumPy 기능을 사용할 거예요!

자, 이제 np. 으로 시작하는 NumPy의 강력한 기능들을 사용할 준비가 완료되었습니다!

 

3. 수학 데이터를 담는 그릇: NumPy 배열(ndarray) 만들기

NumPy 작업을 시작하려면 먼저 데이터를 NumPy 배열이라는 그릇에 담아야 합니다. 만드는 방법은 여러 가지가 있습니다.

가. 파이썬 리스트를 NumPy 배열로 변환하기: np.array()

가장 기본적인 방법입니다. 우리가 이미 익숙한 파이썬 리스트를 np.array() 안에 넣어주면 NumPy 배열로 변신합니다!

# 예시 1: 학생 5명의 수학 점수 리스트
math_scores_list = [85, 92, 78, 100, 95]

# 리스트를 NumPy 배열로 변환
scores_array = np.array(math_scores_list)

print("파이썬 리스트:", math_scores_list)
print("NumPy 배열:", scores_array)
print("NumPy 배열의 타입:", type(scores_array)) # <class 'numpy.ndarray'>
# 출력 결과 보면 대괄호는 같지만, 요소 사이에 쉼표가 없는 형태로 출력됨

# 예시 2: 2차원 좌표 벡터들을 리스트의 리스트로 표현
points_list = [[1, 2], [3, -1], [0, 5]] # 점 3개의 좌표

# 리스트의 리스트를 NumPy 배열로 변환 -> 2차원 배열(행렬)이 됨!
points_array = np.array(points_list)
print("\n좌표 리스트:\n", points_list)
print("좌표 NumPy 배열 (행렬 형태):\n", points_array)
# [[ 1  2]
#  [ 3 -1]
#  [ 0  5]]

나. 규칙적인 배열 쉽게 만들기

NumPy는 특정 값으로 채워지거나 연속된 숫자를 가진 배열을 만드는 편리한 함수들을 제공합니다.

• 0 또는 1로 채우기: np.zeros(개수 또는 모양), np.ones(개수 또는 모양)

  • 수학에서 영벡터나 영행렬을 만들 때 유용합니다.

  # 0으로만 이루어진 크기 5의 벡터 (1차원 배열)
  zero_vector = np.zeros(5)
  print("영벡터:", zero_vector) # 출력: [0. 0. 0. 0. 0.] (기본은 실수형)
  
  # 1로만 이루어진 2행 3열 행렬 (2차원 배열)
  one_matrix = np.ones((2, 3)) # 모양(shape)은 튜플 (행, 열) 로 지정
  print("1로 채워진 행렬:\n", one_matrix)
  # [[1. 1. 1.]
  #  [1. 1. 1.]]
  
  # 정수형 0으로 채우려면? dtype=int 옵션 추가
  zero_vector_int = np.zeros(5, dtype=int)
  print("정수형 영벡터:", zero_vector_int) # 출력: [0 0 0 0 0]
  

• 연속된 숫자 만들기:

  • np.arange(시작, 끝, 간격): 파이썬 range()와 비슷하지만 결과가 NumPy 배열입니다.
  • np.linspace(시작, 끝, 개수): 시작점과 끝점을 포함하여 그 사이를 균등한 간격으로 나눈 점들을 만듭니다. (그래프 그릴 때 x좌표 만들 때 아주 유용!)

  # 1부터 10까지 홀수 만들기 (1, 3, 5, 7, 9)
  odd_numbers = np.arange(1, 11, 2) # 1부터 11 전까지 2씩 증가
  print("1~10 홀수 배열:", odd_numbers) # 출력: [1 3 5 7 9]
  
  # 0부터 1까지 5개의 점 만들기 (0, 0.25, 0.5, 0.75, 1)
  # 그래프 그릴 때 x축 좌표 만들 때 딱 좋아요!
  x_points = np.linspace(0, 1, 5)
  print("0~1 사이 5개 점:", x_points) # 출력: [0.   0.25 0.5  0.75 1.  ]
  

다. 배열 정보 확인하기: shape, ndim, size, dtype

만들어진 NumPy 배열이 어떻게 생겼는지 확인하는 것은 중요합니다.

print("점수 배열:", scores_array)       # [ 85  92  78 100  95]
print("점수 배열의 모양(shape):", scores_array.shape)  # 출력: (5,) -> 1차원 배열이고 요소 5개
print("점수 배열의 차원(ndim):", scores_array.ndim)   # 출력: 1
print("점수 배열의 총 요소 개수(size):", scores_array.size) # 출력: 5
print("점수 배열의 데이터 타입(dtype):", scores_array.dtype) # 출력: int64 (정수형)

print("\n좌표 배열:\n", points_array)    # [[ 1  2] [ 3 -1] [ 0  5]]
print("좌표 배열의 모양(shape):", points_array.shape)  # 출력: (3, 2) -> 3행 2열
print("좌표 배열의 차원(ndim):", points_array.ndim)   # 출력: 2
print("좌표 배열의 총 요소 개수(size):", points_array.size) # 출력: 6 (3 * 2)
print("좌표 배열의 데이터 타입(dtype):", points_array.dtype) # 출력: int64

• shape: 배열이 몇 행 몇 열인지 알려줍니다. (1차원은 (개수,) 형태로 표시)
• ndim: 배열의 차원 수 (1차원 벡터는 1, 2차원 행렬은 2).
• size: 배열 안의 총 숫자 개수.
• dtype: 배열 안의 숫자가 정수(int)인지 실수(float)인지 등 데이터 종류.

 

4. 배열에서 원하는 값 콕 집어내기: 인덱싱과 슬라이싱

NumPy 배열에서 특정 위치의 값을 가져오거나(인덱싱), 배열의 일부를 잘라내는(슬라이싱) 방법은 파이썬 리스트와 매우 비슷하지만, 2차원 이상 배열에서 더 편리합니다.

가. 1차원 배열 (벡터): 리스트와 거의 동일!

a = np.arange(0, 10) # [0 1 2 3 4 5 6 7 8 9]
print("배열 a:", a)

# 첫 번째 요소 (인덱스는 0부터 시작!)
print("a[0] =", a[0]) # 출력: 0

# 마지막 요소
print("a[-1] =", a[-1]) # 출력: 9

# 2번 인덱스부터 5번 인덱스 *전*까지 (인덱스 2, 3, 4)
print("a[2:5] =", a[2:5]) # 출력: [2 3 4]

# 처음부터 3개 요소 (인덱스 0, 1, 2)
print("a[:3] =", a[:3]) # 출력: [0 1 2]

# 맨 뒤 3개 요소
print("a[-3:] =", a[-3:]) # 출력: [7 8 9]

# 2칸 간격으로 모든 요소
print("a[::2] =", a[::2]) # 출력: [0 2 4 6 8]

나. 2차원 배열 (행렬): [행, 열] 로 접근!

쉼표(,)를 사용해서 행과 열의 위치를 지정하는 것이 핵심입니다. 배열이름[행번호, 열번호]

# 3x3 행렬 만들기
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print("행렬 matrix:\n", matrix)

# 1행 2열의 요소 (인덱스는 0부터 시작하니 주의!) -> 6
print("matrix[1, 2] =", matrix[1, 2]) # 출력: 6

# 첫 번째 행(0번 행) 전체 가져오기
print("matrix[0, :] =", matrix[0, :]) # 출력: [1 2 3]
# ':'는 '전체'를 의미합니다. 열 부분을 ':'로 하면 해당 행 전체를 가져옵니다.
# 또는 간단히 행 번호만 써도 됩니다.
print("matrix[0] =", matrix[0]) # 위와 동일

# 두 번째 열(1번 열) 전체 가져오기
print("matrix[:, 1] =", matrix[:, 1]) # 출력: [2 5 8]
# 이번엔 행 부분을 ':'로 해서 해당 열 전체를 가져옵니다.

# 부분 행렬 잘라내기: 0~1행, 1~2열 -> [[2, 3], [5, 6]]
sub_matrix = matrix[0:2, 1:3] # 행 슬라이싱, 열 슬라이싱
print("부분 행렬 matrix[0:2, 1:3]:\n", sub_matrix)
# [[2 3]
#  [5 6]]

다. 조건으로 골라내기: 불리언 인덱싱

이 기능은 정말 강력합니다! 특정 조건을 만족하는 요소만 골라낼 수 있습니다.

예시: 우리 반 수학 점수 배열에서 80점 이상인 점수만 뽑아내기

scores = np.array([85, 92, 78, 100, 95, 65, 77])
print("전체 점수:", scores)

# 1단계: 각 점수가 80점 이상인지 True/False 로 판단하기
condition = scores >= 80
print("80점 이상인가?:", condition) # 출력: [ True  True False  True  True False False]

# 2단계: 이 True/False 배열을 인덱스 자리에 넣기!
high_scores = scores[condition]
print("80점 이상 점수:", high_scores) # 출력: [ 85  92 100  95]

# 한 줄로 줄여 쓰면:
print("80점 이상 점수 (한 줄 코드):", scores[scores >= 80])

# 짝수 점수만 뽑기
print("짝수 점수:", scores[scores % 2 == 0]) # 출력: [92 78 100]

# 특정 조건을 만족하는 값을 다른 값으로 바꾸기도 가능
# 예: 70점 미만 점수를 70점으로 조정 (Pass/Fail 경계 조정 등)
scores[scores < 70] = 70
print("70점 미만 조정 후:", scores) # 출력: [ 85  92  78 100  95  70  77]

불리언 인덱싱은 데이터를 필터링하거나 특정 조건에 따라 값을 변경할 때 아주 유용합니다.

 

5. 반복문은 이제 안녕! 초고속 요소별 연산 (Vectorization)

NumPy의 진정한 힘은 바로 벡터화(Vectorization) 에 있습니다! 배열 안의 모든 요소에 대해 for 반복문을 쓰지 않고도 연산을 한 방에 처리하는 기능입니다. 코드가 훨씬 간결해지고, 속도는 비교할 수 없을 정도로 빨라집니다.

가. 배열과 숫자(스칼라)의 연산: 모든 요소에 똑같이 적용!

예시: 모든 학생 수학 점수에 5점씩 보너스 주기

scores = np.array([85, 92, 78, 100, 95])
print("원래 점수:", scores)

# 각 점수에 5점 더하기 (for문 없이!)
bonus_scores = scores + 5
print("보너스 적용:", bonus_scores) # 출력: [ 90  97  83 105 100]

# 각 점수를 10점 만점으로 환산하기 (100으로 나누고 10 곱하기)
scaled_scores = scores / 100 * 10
print("10점 만점 환산:", scaled_scores) # 출력: [ 8.5  9.2  7.8 10.   9.5]

# 각 점수의 편차 제곱 구하기 (평균 90이라고 가정)
mean_score = 90
deviation_squared = (scores - mean_score)**2
print("편차 제곱:", deviation_squared) # 출력: [ 25   4 144 100  25]

놀랍지 않나요? + 5, / 100, - mean_score 같은 연산을 배열에 직접 하니, 배열 안의 모든 요소에 알아서 적용됩니다!

나. 같은 크기 배열끼리의 연산: 같은 위치끼리 계산!

예시: 두 벡터의 덧셈과 뺄셈

vector_a = np.array([1, 2, 3])
vector_b = np.array([10, 20, 30])
print("벡터 a:", vector_a)
print("벡터 b:", vector_b)

# 벡터 덧셈 (같은 위치 요소끼리 더함)
sum_vector = vector_a + vector_b
print("a + b =", sum_vector) # 출력: [11 22 33]

# 벡터 뺄셈
diff_vector = vector_b - vector_a
print("b - a =", diff_vector) # 출력: [ 9 18 27]

# 각 요소별 곱셈 (★주의: 행렬 곱셈 아님!)
product_elementwise = vector_a * vector_b
print("a * b (요소별 곱) =", product_elementwise) # 출력: [10 40 90]

크기가 같은 NumPy 배열끼리 사칙연산을 하면, 같은 위치에 있는 요소들끼리 연산이 이루어집니다. (단, * 는 요소별 곱셈이지 행렬 곱셈이 아님을 기억하세요!)

 

6. 수학 함수도 한 방에! 유니버설 함수 (ufuncs)

NumPy는 sin, cos, sqrt(제곱근), log(로그), exp(지수) 같은 다양한 수학 함수들을 배열 전체에 빠르게 적용할 수 있도록 유니버설 함수(Universal Functions, 줄여서 ufuncs) 형태로 제공합니다.

예시: 여러 각도에 대한 삼각함수 값 계산하기

# 각도 배열 만들기 (0도, 30도, 45도, 60도, 90도를 라디안으로)
# np.pi 는 원주율 π 입니다.
angles_degree = np.array([0, 30, 45, 60, 90])
angles_radian = angles_degree * np.pi / 180
print("각도(라디안):", angles_radian)

# 각 각도에 대한 sin 값 계산 (for문 없이!)
sin_values = np.sin(angles_radian)
print("sin 값:", sin_values)
# [0.         0.5        0.70710678 0.8660254  1.        ]

# 각 각도에 대한 cos 값 계산
cos_values = np.cos(angles_radian)
print("cos 값:", cos_values)
# [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17] (90도 cos 값은 0에 매우 가깝게)

# 여러 숫자의 제곱근 구하기
numbers = np.array([1, 4, 9, 16, 25])
sqrt_values = np.sqrt(numbers)
print("\n제곱근:", sqrt_values) # 출력: [1. 2. 3. 4. 5.]

# 여러 숫자의 자연로그 값 구하기 (e는 자연상수)
exp_numbers = np.array([1, np.e, np.e**2])
log_values = np.log(exp_numbers)
print("자연로그:", log_values) # 출력: [0. 1. 2.]

math.sin()은 숫자 하나만 받지만, np.sin()은 배열을 통째로 받아 모든 요소에 sin 함수를 적용해 줍니다. 정말 편리하죠!

 

7. 벡터와 행렬 계산의 기초: 선형대수 맛보기

NumPy는 벡터와 행렬을 다루는 데 최적화되어 있어서, 선형대수 계산의 기본 도구로 널리 쓰입니다.

가. 벡터 내적 (Dot Product): 두 벡터 사이의 관계 알기

기하학에서 두 벡터의 내적은 두 벡터 사이의 각도와 관련된 중요한 값이죠. NumPy에서는 np.dot(벡터1, 벡터2) 또는 @ 연산자(Python 3.5 이상)를 사용합니다.

vec_a = np.array([1, 2]) # 벡터 (1, 2)
vec_b = np.array([3, -1]) # 벡터 (3, -1)

# 내적 계산: 1*3 + 2*(-1) = 3 - 2 = 1
dot_ab = np.dot(vec_a, vec_b)
print(f"벡터 a와 b의 내적 (np.dot): {dot_ab}") # 출력: 1

# @ 연산자 사용
dot_ab_at = vec_a @ vec_b
print(f"벡터 a와 b의 내적 (@): {dot_ab_at}") # 출력: 1

# 내적을 이용하면 두 벡터 사이의 각도 θ의 cos 값도 구할 수 있어요!
# cos(θ) = (a · b) / (|a| |b|)
norm_a = np.linalg.norm(vec_a) # 벡터 a의 크기 |a| = sqrt(1^2 + 2^2)
norm_b = np.linalg.norm(vec_b) # 벡터 b의 크기 |b| = sqrt(3^2 + (-1)^2)
cos_theta = dot_ab / (norm_a * norm_b)
print(f"두 벡터 사이 각도의 코사인 값: {cos_theta:.4f}") # 소수점 4자리까지
# θ 값을 구하려면 np.arccos() 사용 -> theta_radian = np.arccos(cos_theta)

• np.linalg.norm(): 벡터의 크기(노름)를 계산하는 함수입니다.

나. 행렬 곱셈 (Matrix Multiplication): 변환과 연립방정식의 언어

행렬 곱셈은 기하학적 변환이나 연립방정식 풀이 등에 사용되는 중요한 연산입니다. 매우 중요: NumPy에서 그냥 * 를 쓰면 요소별 곱셈입니다! 행렬 곱셈은 반드시 np.dot() 이나 @ 를 사용해야 합니다.

matrix_A = np.array([[1, 2],
                   [0, 3]])
matrix_B = np.array([[4, 1],
                   [2, 2]])
print("행렬 A:\n", matrix_A)
print("행렬 B:\n", matrix_B)

# 행렬 곱셈 AB 계산
# 1행1열: 1*4 + 2*2 = 8
# 1행2열: 1*1 + 2*2 = 5
# 2행1열: 0*4 + 3*2 = 6
# 2행2열: 0*1 + 3*2 = 6
matrix_AB = np.dot(matrix_A, matrix_B)
print("행렬 곱셈 AB (np.dot):\n", matrix_AB)
# [[8 5]
#  [6 6]]

# @ 연산자 사용
matrix_AB_at = matrix_A @ matrix_B
print("행렬 곱셈 AB (@):\n", matrix_AB_at) # 위와 동일

# 참고: BA는 일반적으로 AB와 다릅니다!
matrix_BA = matrix_B @ matrix_A
print("행렬 곱셈 BA (@):\n", matrix_BA)
# [[ 4  11]
#  [ 2  10]]

다. 전치 행렬 (Transpose): 행과 열 뒤집기

행렬의 행과 열을 서로 바꾼 것을 전치행렬이라고 하죠. NumPy 배열 뒤에 .T 를 붙이면 간단하게 얻을 수 있습니다.

print("행렬 A:\n", matrix_A)
# [[1 2]
#  [0 3]]

print("행렬 A의 전치행렬 A.T:\n", matrix_A.T)
# [[1 0]
#  [2 3]]

(더 나아가기) NumPy에는 역행렬(np.linalg.inv), 행렬식(np.linalg.det), 연립 선형 방정식 풀이(np.linalg.solve) 등 더 많은 선형대수 기능이 np.linalg 모듈 안에 준비되어 있습니다.

 

8. 정리: NumPy, 수학 공부의 강력한 조력자!

이번 장에서는 NumPy를 이용해 파이썬으로 숫자 데이터를 더 효율적으로 다루는 방법을 배웠습니다.

• NumPy 배열(ndarray)은 파이썬 리스트보다 빠르고 메모리를 효율적으로 사용하며, 수학 계산에 특화되어 있습니다.
• np.array(), np.arange(), np.linspace(), np.zeros() 등으로 배열을 쉽게 만들 수 있습니다.
• 인덱싱/슬라이싱 ([ ], [:], [,]) 과 불리언 인덱싱 ([조건식]) 으로 원하는 데이터를 정확하게 뽑아낼 수 있습니다.
• 벡터화 연산 (+, * 등)으로 for 반복문 없이 배열 전체에 빠르고 간결하게 계산을 적용할 수 있습니다.
• 유니버설 함수(ufunc) (np.sin, np.sqrt 등)로 다양한 수학 함수를 배열 전체에 한 번에 적용할 수 있습니다.
• 벡터 내적(@) 과 행렬 곱셈(@) 등 기본적인 선형대수 연산을 쉽게 수행할 수 있습니다.

앞으로 수학 문제를 파이썬으로 해결할 때,

• 많은 양의 숫자 데이터(점수, 좌표, 실험값 등)를 다룰 때는 NumPy 배열을 사용하세요.
• 반복적인 계산이 필요하다면, 벡터화 연산이나 ufunc를 활용하여 코드를 간결하고 빠르게 만드세요.
• 벡터나 행렬이 등장하는 문제(기하, 선형대수)에서는 NumPy의 기능을 적극 활용하세요.
• 그래프를 그릴 때는 NumPy로 데이터를 생성하는 것이 매우 편리합니다 (Matplotlib과 찰떡궁합!).

NumPy는 이후에 배울 Pandas나 다른 과학 라이브러리의 기본이 되므로, 여기서 배운 내용을 잘 익혀두면 앞으로의 학습에 큰 도움이 될 것입니다!

 

연습 문제

1. 점수 배열 생성 및 기본 정보 확인: 5명의 국어 점수 [80, 95, 72, 100, 88] 을 NumPy 배열로 만들고, 배열의 모양(shape), 차원 수(ndim), 데이터 타입(dtype)을 출력하세요.

2. 수열 생성: np.arange()를 사용하여 10부터 1까지 역순으로 2씩 감소하는 정수 배열 (즉, [10, 8, 6, 4, 2]) 을 만드세요.

3. 벡터 연산: 벡터 a = np.array([5, -2]) 와 b = np.array([1, 4]) 에 대해 다음을 계산하세요.

   • a + b
   • 2 * a - b
   • a와 b의 내적 (a @ b)

4. 배열 슬라이싱 및 불리언 인덱싱: 0부터 24까지의 정수로 채워진 5x5 크기의 2차원 배열 M을 만드세요 (np.arange(25).reshape(5, 5) 활용).

   • M의 두 번째 행 전체를 출력하세요.
   • M에서 10보다 큰 요소들만 모두 선택하여 출력하세요.
   • M에서 3의 배수인 요소들만 0으로 바꾸고, 변경된 M을 출력하세요.

5. 함수 값 계산: x 값을 0부터 π 까지 10개의 균일한 간격으로 생성하고(np.linspace), 각 x 값에 대한 y = x * sin(x) 값을 계산하여 y 배열을 출력하세요. (np.sin 사용)