Python 상용 라 이브 러 리 Numpy 매트릭스 연산 상세 설명

Numpy 는 대량의 차원 배열 과 행렬 연산 을 지원 하고 배열 연산 에 대량의 수학 함수 라 이브 러 리 를 제공 합 니 다!
Numpy 는 Python 목록 보다 우세 하 며,그 중 하 나 는 속도 입 니 다.대형 배열 에 대한 작업 을 수행 할 때 Numpy 의 속 도 는 Python 목록 보다 수백 빠 릅 니 다.Numpy 배열 자체 가 메모 리 를 절약 할 수 있 고 Numpy 는 산술,통계 와 선형 대수 연산 을 수행 할 때 최적화 알고리즘 을 사용 하기 때문이다.
Numpy 의 또 다른 강력 한 기능 은 벡터 와 행렬 을 나타 내 는 다 차원 배열 데이터 구 조 를 가지 고 있다.Numpy 는 행렬 연산 을 최적화 시 켜 서 우 리 는 선형 대수 연산 을 효율적으로 집행 하여 기계 학습 문 제 를 해결 하 는 데 매우 적합 하도록 한다.
Python 목록 에 비해 Numpy 가 가 진 또 다른 강력 한 장점 은 대량의 최 적 화 된 내장 수학 함수 이다.이 함수 들 은 당신 으로 하여 금 각종 복잡 한 수학 계산 을 매우 신속하게 진행 할 수 있 게 하고,매우 적은 코드(복잡 한 순환 을 사용 할 필요 가 없다)를 사용 하여 프로그램 을 더욱 쉽게 읽 고 이해 하 게 할 수 있다.
주:ndarray 구조 에서 안의 요 소 는 반드시 같은 유형 이 어야 합 니 다.그렇지 않 으 면 자동 으로 아래로 진 행 됩 니 다.
Numpy 간단하게 배열 만 들 기

a = [1, 2, 3]
b = np.array(a)
c = np.array([[0, 1, 2, 10],
    [12, 13, 100, 101],
    [102, 110, 112, 113]], int)
print(c)
print(b)

1 인 배열 만 들 기
Numpy.ones(매개 변수 1:shape,배열 의 모양;인자 2:dtype,수치 형식)

array_one = np.ones([10, 10], dtype=np.int)
 print(array_one)

0 인 배열 만 들 기
Numpy.zeros(매개 변수 1:shape,배열 의 모양;인자 2:dtype,수치 형식)

array_zero = np.zeros([10, 9], dtype=np.float)
 print(array_zero)

지정 한 수치의 그룹 만 들 기
Numpy.full(매개 변수 1:shape,배열 의 모양;인자 2:constant value,배열 이 채 워 진 상수 값;인자 3:dtype,수치 형식)

 array_full = np.full((2, 3), 5)
 print(array_full)

단위 매트릭스 만 들 기
Numpy.eye(인자 1:N,방진 의 차원)

 array_eye = np.eye(5)
 print(array_eye)

대각 행렬 만 들 기
Numpy.diag(매개 변수 1:v,주 대각선 수치,매개 변수 2:k,대각선 요소):K=0 은 주 대각선,k>0 의 값 은 주 대각선 위의 대각선 에 있 는 요 소 를 선택 하고 k<0 의 값 은 주 대각선 아래 의 대각선 에 있 는 요 소 를 선택 합 니 다.

array_diag = np.diag([10, 20, 30, 40])
 print(array_diag)

Numpy 배열 속성 보기
배열 요소 개수:b.size 또는 np.size()
배열 모양:b.shape 또는 np.shape()
배열 차원:b.ndim
배열 요소 종류:b.dtype

#       ：3
print(b.size)
#     :(3,)
print(b.shape)
#     :1
print(b.ndim)
#       :int32
print(b.dtype)

행렬 1 차원 길이:shape[0]\#줄
행렬 2 차원 길이:shape[1]\#열
.......

 array_rand = np.random.rand(10, 10, 4)
 print(array_rand)
 print(array_rand.ndim)
 print(array_rand.shape[0])
 print(array_rand.shape[1])
 print(array_rand.shape[2])

Numpy 무 작위 배열 만 들 기(np.random)
균등 분포
지정 한 모양 의 배열 을 만 듭 니 다.수치 범 위 는 0~1 사이 입 니 다.

array_rand = np.random.rand(10, 10, 4)
 print(array_rand)
 print(array_rand.ndim)

지정 한 범위 내 숫자 만 들 기:Numpy.random.uniform(low,high,size=None)

 array_uniform = np.random.uniform(0, 100, size=5)
print(array_uniform)

지정 한 범위 의 정수 만 들 기:Numpy.random.randint(low,high,size=None)

array_int = np.random.randint(0, 100, size=3)
print(array_int)
print(array_int.size)

Numpy.arange()와 Numpy.linspace()함수 도 고 르 게 분포 할 수 있다
Numpy.arange(start,stop,step):반 개 구간[start,stop)에 위치 하고 고 르 게 분포 하 는 값 을 포함 하 는 배열 을 만 듭 니 다.step 는 두 개의 인접 값 간 의 차 이 를 표시 합 니 다.
Numpy.linspace(start,stop,N):닫 힌 구간[start,stop]에 고 르 게 분 포 된 값 을 만 듭 니 다.

 X = np.arange(1, 5, 2, dtype=np.int)
 print(X)
 y = np.linspace(1, 5, 3)
 print(y)

정상 분포
주어진 평균 값,표준 차,차원 의 정상 분포 만 들 기:Numpy.random.normal(loc,scale,size)

 #     4 5      
 array_normal = np.random.normal(loc=1.75, scale=0.1, size=[4, 5])
 print(array_normal)
 print(array_normal.ndim)

Numpy 배열 작업
배열 의 인덱스
array[start : end]
array[start:]
array[:end]
불 색인:array[array>10&array<20]

 #    0  3 ， 2  4 （  0  0   ）
 after_array = array_normal[:3, 2:4]
 print(after_array)

배열 복사
Numpy.copy(인자 1:배열):주어진 array 의 복사 본 을 만 드 는 방법 으로 도 사용 할 수 있 습 니 다.

after_array = array_normal[:3, 2:4].copy()
copy_array = np.copy(array_normal[:, 2:4])

Numpy.sort(인자 1:a,배열;인자 2:axis=0/1,0 표시 줄 1 표시 열):np.sort()를 함수 로 사용 할 때 정렬 된 원본 array 를 변경 하지 않 습 니 다.array.sort()를 방법 으로 사용 할 때 원본 array 를 정렬 후 배열 array 로 변경 합 니 다.

 #     
 np.sort(array_normal)
 #     
 np.sort(array_normal, axis=0)
 #     
 np.sort(array_normal, axis=1)

배열 유일 요소
Numpy.unique(인자 1:a,배열;파라미터 2:returnindex=True/False,새 목록 요소 가 이전 목록 에 있 는 위치;파라미터 3:returninverse=True/False,오래된 목록 요소 가 새 목록 에 있 는 위치;인자 4:returncounts,원소 의 수량;매개 변수 5:axis=0/1,0 표시 줄 1 표시 열):array 의 유일한 요 소 를 찾 습 니 다.

 print("      ", np.unique(array_normal))
 print("      ", np.unique(array_normal, return_index=True))
 print("      ", np.unique(array_normal, return_counts=True))
 print("      ", np.unique(array_normal, return_index=True, return_inverse=True, axis=0))

배열 의 변화
배열 변환

array_normal.T

reshape():지정 한 배열 을 모양 으로 바 꾸 지만 요소 의 개 수 는 변 하지 않 습 니 다.원본 다 차원 배열 을 수정 하지 않 는 반환 값 이 있 습 니 다.

c = np.array([[[0, 1, 2],
    [10, 12, 13]],
    [[100, 101, 102],
    [110, 112, 113]]])
"""
[[[ 0 1]
 [ 2 10]]

 [[ 12 13]
 [100 101]]

 [[102 110]
 [112 113]]]
"""
print(c.reshape(3, 2, 2))
"""
[[ 0 1 2 10]
 [ 12 13 100 101]
 [102 110 112 113]]
"""
#       -1 ，      
print(c.reshape(3, -1))
"""[[[ 0 1]
 [ 2 10]
 [ 12 13]]

 [[100 101]
 [102 110]
 [112 113]]]"""
print(c.reshape(2, -1, 2))

resize():지정 한 배열 의 모양 을 바 꾸 지만 요소 의 개 수 는 가 변 적 이 고 0 을 보충 할 수 없습니다.원본 다 차원 배열 을 수정 하 는 반환 값 이 없습니다.

a = np.array([[[0, 1, 2],
    [10, 12, 13]],
    [[100, 101, 102],
    [110, 112, 113]]])
b = np.array([[[0, 1, 2],
    [10, 12, 13]],
    [[100, 101, 102],
    [110, 112, 113]]])
'''[[0]
 [1]
 [2]]'''
a.resize((3, 1))
'''[[ 0 1 2 10 12]
 [ 13 100 101 102 110]
 [112 113 0 0 0]]'''
b.resize((3, 5))
print(a)
print(b)

*Numpy 계산
조건 부 연산
Numpy.where(condition,x,y):세 가지 연산 만족 condition,x;condition 에 만족 하지 않 으 면 y 입 니 다.

 score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
 #       80，   0，      80，   90
 re_score = np.where(score < 80, 0, 90)
 print(re_score)

]통계 연산
지정 축 최대 값:amax(매개 변수 1:배열;매개 변수 2:axis=0/1,0 표시 줄 1 표시 열)

#          
result = np.amax(score)
print(result)
#         （0   ）
result = np.amax(score, axis=0)
print(result)
#         （1   ）
result = np.amax(score, axis=1)
print(result)

지정 축 최소 값:amin(매개 변수 1:배열;매개 변수 2:axis=0/1,0 표시 줄 1 표시 열)

#          
result = np.amin(score)
print(result)
#         （0   ）
result = np.amin(score, axis=0)
print(result)
#         （1   ）
result = np.amin(score, axis=1)
print(result)

지정 축 평균 값:mean(매개 변수 1:배열;매개 변수 2:axis=0/1,0 표시 줄 1 표시 열;인자 3:dtype,출력 데이터 형식)

#          
result = np.mean(score, dtype=np.int)
print(result)
#         （0   ）
result = np.mean(score, axis=0)
print(result)
#         （1   ）
result = np.mean(score, axis=1)
print(result)

지정 축 분산:std(매개 변수 1:배열;매개 변수 2:axis=0/1,0 표시 줄 1 표시 열;인자 3:dtype,출력 데이터 형식)

#         
result = np.std(score)
print(result)
#        （0   ）
result = np.std(score, axis=0)
print(result)
#        （1   ）
result = np.std(score, axis=1)
print(result)

비슷 한,구 합:Numpy.sum(),중간 값:Numpy.median
배열 연산
수조 와 수의 연산(가,감,승,제,취 정,취 모)

#        ，       5
score[:, :] = score[:, :]+5
print(score)
#        ，       5
score[:, :] = score[:, :]-5
print(score)
#        ，        5
score[:, :] = score[:, :]*5
print(score)
#        ，        5
score[:, :] = score[:, :]/5
print(score)
#        ，       5  
score[:, :] = score[:, :] // 5
print(score)
#        ，       5  
score[:, :] = score[:, :] % 5
print(score)

배열 간 연산(더하기,빼 기,곱 하기,나 누 기),전 제 는 두 배열 의 shape 와 같다.
가:"+"또는 np.add(a,b)감:"-"또는 np.subtract(a,b)
곱 하기:"*"또는 np.multiply(a,b)나 누 기:"/"또는 np.divide(a,b)

 c = score + score
 d = score - score
 e = score * score
 #              0
 b = score / score

Numpy.intersect1d(인자 1:배열 a;인자 2:배열 b):두 배열 의 같은 요 소 를 찾 습 니 다.
Numpy.setdiff1d(인자 1:배열 a;인자 2:배열 b):배열 a 에서 배열 b 에 없 는 요 소 를 찾 습 니 다.
Numpy.union1d(인자 1:수조 a;인자 2:배열 b):두 배열 의 집합 요 소 를 찾 습 니 다.
매트릭스 연산(특수 한 2 차원 배열)
계산 규칙
(M 줄,N 열)*(N 줄,Z 열)=(M 줄,Z 열)

 st_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
 #      40%      60%,     
 q = np.array([[0.4], [0.6]])
 result = np.dot(st_score, q)
 print(result)

매트릭스 조인 트
매트릭스 수직 연결(전제 두 개의 매트릭스 열 수 는 같 고 줄 수 는 임 의):vstack(매개 변수:tuple)

v1 = [[0, 1, 2, 3, 4, 5],
  [6, 7, 8, 9, 10, 11]]
v2 = [[12, 13, 14, 15, 16, 17],
  [18, 19, 20, 21, 22, 23],
  [18, 19, 20, 21, 22, 23]]
result = np.vstack((v1, v2))
print(result)

매트릭스 수평 연결(전제 두 개의 매트릭스 줄 수 는 같 고 열 수 는 임 의):hstack(매개 변수:tuple)

 v1 = [[0, 1, 2, 3, 4, 5],
  [6, 7, 8, 9, 10, 11]]
 v2 = [[12, 13, 14, 15, 16, 17],
  [18, 19, 20, 21, 22, 23]]
 result = np.hstack((v1, v2))
 print(result)

매트릭스 삭제:Numpy.delete(인자 1:a,배열;인자 2:elements,삭 제 된 대상;매개 변수 3:axis=0/1)

OriginalY = np.array([[1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]])
 print(np.delete(OriginalY, [0, 2]))
 print(np.delete(OriginalY, [0, 2], axis=0))
 print(np.delete(OriginalY, [0, 2], axis=1))

매트릭스 추가:Numpy.append(매개 변수 1:array,배열;인자 2:elements,요소 추가;매개 변수 3:axis=0/1)

OriginalY = np.array([[1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]])
#       
print(np.append(OriginalY, [0, 2]))
#         
print(np.append(OriginalY, [[0, 2, 11]], axis=0))
#         （        ）
print(np.append(OriginalY, [[0], [2], [11]], axis=1))

매트릭스 삽입:Numpy.insert(매개 변수 1:array,배열;인자 2:index,위치 색인 삽입;인자 3:elements,요소 추가;인자 4:axis=0/1)

OriginalY = np.array([[1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]])
print(np.insert(OriginalY, 1, [11, 12, 10]))
print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=0))
#     1     （      ，       ）
print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=1))

파일 로드
np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)
fname:읽 은 파일,파일 이름
dtype:데이터 형식
주석
delimiter:구분자,기본 값 은 빈 칸 입 니 다.
skiprows:앞의 줄 을 건 너 뛰 어 읽 습 니 다.기본 값 은 0 입 니 다.
usecols:어떤 열 을 읽 습 니까?usecols=(1,2,5)1,2,5 열 을 읽 습 니 다.기본 모든 열 입 니 다.
파 이 썬 상용 라 이브 러 리 Numpy 의 행렬 연산 에 관 한 상세 한 글 은 여기까지 소개 되 었 습 니 다.더 많은 파 이 썬 Numpy 행렬 연산 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!