레이블이 Python인 게시물을 표시합니다. 모든 게시물 표시

2020년 6월 16일 화요일

람다 표현식(Lambda expression)

람다 표현식으로 함수를 정의하고, 이를 변수에 할당하여 변수를 함수처럼 사용한다.

(1) 람다 표현식

lambda <매개변수> : 수식

※ 람다식을 실행하면 함수 객체가 만들어진다. 이런 함수를 익명 함수(anonymous
function)이라고 한다.

(예) lambda x : 2 * x + 1

(2) 변수에 람다 식을 할당하여 사용하는 방법

>>> linear_eq = lambda x : 2 * x + 1
>>> linear_eq(3)
7

(3) 함수와 람다식 비교

2020년 6월 11일 목요일

Miniconda3 + Tensorflow 2 + PyCharm

Mac에 Tensorflow2 사용 환경 설치!!

설치과정은 https://www.youtube.com/watch?v=MpUvdLD932c 를 참고하였음. 동영상은 2020년 1월에 업로드 되었으며, 아래는 동영상 내용을 요약한 것임

Miniconda3 다운로드 : 구글에서 검색 (https://docs.conda.io/en/latest/miniconda.html)
Miniconda3 설치 : 설치 후 터미널을 실행시키면 (base)라는 가상환경이 동작하는 것을 확인할 수 있다.
Jupyter 설치 : 터미널에서 conda install jupyter 입력하면 (base) 환경에 jupyter가 설치된다.
Environment Setup Script 파일 다운로드 : https://github.com/jeffheaton/t81_558_deep_learning에서 아래로 스크롤 다운하면, tensorflow.yml이라는 파일이 보이며, 이 파일을 다운로드하여 홈디렉토리에 tensorflow.yml로 저장한다.

<파일내용>

name: tensorflow

dependencies:
- python=3.7
  - pip>=19.0
  - jupyter
  - tensorflow=2.0
  - scikit-learn
  - scipy
  - pandas
  - pandas-datareader
  - matplotlib
  - pillow
  - tqdm
  - requests
  - h5py
  - pyyaml
  - flask
  - boto3
  - pip:
      - bayesian-optimization
      - gym
      - kaggle
Environment Setup Script 파일 실행 : conda env create -v -f tensorflow.yml를 실행시키면 위 파일 내용이 설치된다. 시간이 조금 걸린다.
conda activate tensorflow로 (tensorflow) 가상환경을 활성화 시킨다.
conda deactivate로 (tensorflow) 가상환경을 비활성화 시킬 수 있다.
(tensorflow) 가상환경에 jupyter 커널 설치 : (tensorflow) 가상환경 상태에서 python -m ipykernel install --user --name tensorflow --display-name "Python3.7 (tensorflow)"을 입력한다.
jupyter notebook 실행 : 커널에서 Python3.7 (tensorflow)를 선택하면 tensorflow를 사용할 수 있다.

Mac 터미널에서 가상환경 설정 변경!!

이렇게 Miniconda와 Tensorflow를 성공적으로 설치하고 나니, 터미널을 켤 때마다 (base) 환경이 기본적으로 설정되는 문제가 발생하였다.

===> 해결방법 : (base) 프롬프트 상태에서 conda config --set auto_activate_base False 를 입력하고, 터미널을 재실행 시켜주면 해결된다.

(출처 : https://qastack.kr/ubuntu/1026383/why-does-base-appear-in-front-of-my-terminal-prompt)

PyCharm에서 project interpreter에 tensorflow 연결하기!!

Miniconda와 Tensorflow를 설치하고, 터미널도 이전처럼 사용할 수 있도록 만들고나니 실제 개발환경인 PyCharm에서 tensorflow 환경을 연결할 일이 남았다.

PyCharm 메뉴에서 Preferences를 누르면 창이 뜨는데,
왼쪽 메뉴 중 Project 서브 메뉴인 Project Interpreter를 선택하고,
오른쪽에 Project Interpreter 선택 창 옆 [톱니바퀴 모양] 버튼을 눌러 [Add...]를 선택하면 새 창이 뜨는데,
왼쪽 메뉴에서 Virtualenv Environment를 선택하고,
오른쪽 메뉴에서 Existing Environment 라디오 버튼을 선택하고, Interpreter 선택 창의 옆 [...] 버튼을 눌러 경로를 찾는 창이 나타나면, .../miniconda3/envs/tensorflow/bin/를 찾아 python을 선택한다.
내 맥의 경우 /Users/sangjincho/opt/miniconda3/envs/tensorflow/bin/python 으로 선택되었고, Miniconda설치 환경에 따라 경로가 바뀔 수 있다.
Interpreter를 선택한 후 아래의 Make available to all projects 체크박스를 선택하여 나중에 다른 프로젝트에서도 동일한 환경을 선택할 수 있도록 한다.
[OK] 버튼을 누르면 창이 닫히고, Preferences 창에 사용할 수 있는 패키지 리스트가 나타난다. 마지막으로 [OK] 버튼을 누르면 PyCharm에서 tensorflow 환경이 갖춰진다.

5번 항목에서 Miniconda 설치 위치를 확인하려면, Finder에서 홈을 선택하고 숨김파일 보기(command+shift+.)로 전환하면 .conda라는 폴더가 보이고, 그 안에 environments.txt 파일이 있는데, 거기에 내가 설치한 가상환경, 여기서는 tensorflow에 해당하는 위치가 기록되어 있다.

2020년 5월 28일 목요일

파이썬 + MySQL

0. MySQL 설치

https://bitnami.com/stack/wamp/installer

I. PyMySQL 모듈 설치

$ pip install PyMySQL

II. MySQL사용법

PyMySql 모듈을 import 한다.

pymysql.connect() 메소드를 사용하여 MySQL에 Connect 한다. 호스트명, 로그인, 암호, 접속할 DB 등을 파라미터로 지정한다.

DB 접속이 성공하면, Connection 객체로부터 cursor() 메서드를 호출하여 Cursor 객체를 가져온다. DB 커서는 Fetch 동작을 관리하는데 사용되는데, 만약 DB 자체가 커서를 지원하지 않으면, Python DB API에서 이 커서 동작을 Emulation 하게 된다.

Cursor 객체의 execute() 메서드를 사용하여 SQL 문장을 DB 서버에 보낸다.

SQL 쿼리의 경우 Cursor 객체의 fetchall(), fetchone(), fetchmany() 등의 메서드를 사용하여 데이타를 서버로부터 가져온 후, Fetch 된 데이터를 사용한다.

fetchall() : 모든 데이터를 한 번에 클라이언트로 가져온다.
fetchone() : 한 번에 하나의 row만 가져온다.
fetchmany(n) : n개의 데이터를 한 번에 가져온다.
삽입, 갱신, 삭제 등의 DML(Data Manipulation Language) 문장을 실행하는 경우, INSERT/UPDATE/DELETE 후 Connection 객체의 commit() 메서드를 사용하여 데이터를 확정 갱신한다.

Connection 객체의 close() 메서드를 사용하여 DB 연결을 닫는다.

(예제코드)

id	name	age
1526	Doldori	125
1533	Haechi	332
1577	Nari	498

1 import pymysql

2 connection = pymysql.connect( host='localhost',

user='admin',

password='',

db='testdb',

charset='utf8' )

3 cursor = connection.cursor() # Array based cursor
# cursor = connection.cursor(pymysql.cursors.DictCursor) # Dictionary based cursor

sql = "select * from My_Table"

4 cursor.excute(sql)

5 rows = cursor.fetchall() # Tuple로 반환
# rows = cursor.fetchall() # Dictionary로 반환

for row in rows:
print(row)
# Tuple인 경우 : row --> (1526, 'Doldori', 125)
# Dictionary인 경우 : row --> {'id': 1526, 'name': 'Doldori', 'age': 125}

sql = "insert into My_Table(id, name, age) values('1000', 'Gildong', '525')"

6 connection.commit()

# 동적 SQL문을 구성하기 위해서 파라미터값이 들어가는 위치에
# Parameter Placeholder인 %s (MySql의 경우)를 넣고, execute() 메서드의
# 두번째 파라미터에 실제 파라미터값들의 Tuple을 넣어 주면 된다.

sql = "select * from My_Table where name=%s and age=%s"

cursor.excute(sql, ('Doldori', 125))

7 connection.close()

출처 : http://pythonstudy.xyz/python/article/202-MySQL-%EC%BF%BC%EB%A6%AC

2020년 5월 21일 목요일

영교차점(zero-crossing) 찾기 (파이썬)

a = [1, 2, 1, 1, -3, -4, 7, 8, 9, 10, -2, 1, -3, 5, 6, 7, -10]

일 때,

In[61]: z = np.where(np.diff(np.sign(a)))[0]

In[61]: z

Out[62]: array([ 3, 5, 9, 10, 11, 12, 15], dtype=int64)

-------------------------------------------------------------------------------------------
a : [ 1, 2, 1, 1, -3, -4, 7, 8, 9,10, -2, 1, -3, 5, 6, 7, -10]
k = np.sign(a) : [ 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1]
d = np.diff(k) : [ 0, 0, 0, -2, 0, 2, 0, 0, 0, -2, 2, -2, 2, 0, 0, -2]
np.where(d) : (array([ 3, 5, 9, 10, 11, 12, 15], dtype=int64),)
np.where(d)[0] : [ 3, 5, 9, 10, 11, 12, 15]
-------------------------------------------------------------------------------------------

np.diff()의 결과가 음수이면 데이터가 양수에서 음수로 바뀐 것이고,
np.diff()의 결과가 양수이면 데이터가 음수에서 양수로 바뀐 것이다.

np.where(d)라고 사용하면 d가 영이 아닌 모든 위치를 알려주며, 튜플로 반환된다.
따라서 결과만 얻고자 한다면 np.where(d)[0]로 사용한다.

np.where(d)[0]의 결과는 데이터에서 zero-crossing이 발생하는 시작점을 의미한다.
위의 예에서 "3"은 데이터가 4번째 샘플에서 5번째 샘플로 바뀌는 시점에서 zero-crossing이 발생함을 뜻한다.

2019년 10월 30일 수요일

선형회귀

[데이터 사이언스 스쿨] 2.1 선형 회귀분석의 기초

2019년 9월 29일 일요일

2축 그래프 그리기

파이썬 - 2축 그래프 그리기

import numpy as np
import matplotlib.pyplot as plt
from random import *

x = np.arange(10)
y1 = [random() for _ in x]
y2 = [uniform(1,10) for _ in x]

fig, ax1 = plt.subplots()
ax2 = ax1.twinx()

data_y1 = ax1.plot(x, y1, color='b', linestyle='-.', marker='o', label='y1')
data_y2 = ax2.plot(x, y2, color='r', linestyle='--', marker='s', label='y2')

ax1.set_xlabel('x')
ax1.set_ylabel('data_y1')
ax2.set_ylabel('data_y2')

data_y = data_y1+data_y2
labels = [l.get_label() for l in data_y]
plt.legend(data_y, labels, loc=1)

plt.show()

# 각 y축의 범위 설정 방법

# http://blog.naver.com/PostView.nhn?blogId=onlyjeje&logNo=221168953266

ax1.set_ylim(bottom, top)

ax2.set_ylim(bottom, top)

2019년 9월 24일 화요일

map() 함수

python map() 함수

python docs 의 map 함수에 대한 정의를 보자.

map(function, iterable, ...)

Apply function to every item of iterable and return a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items. If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list.

map() 함수는 built-in 함수로 list 나 dictionary 와 같은 iterable 한 데이터를 인자로 받아 list 안의 개별 item을 함수의 인자로 전달하여 결과를 list로 형태로 반환해 주는 함수이다. 글로 설명하면 복잡하니 아래 예제를 보자.

def func(x):

return x * 2

인자로 받은 정수를 두배로 곱하여 반환해 주는 매우 간단한 함수이다.

이 함수에 인자를 map() 함수를 이용해 전달해 보자.

>>> map( func, [1, 2, 3, 4] )

[2, 4, 6, 8]

위와 같이 map() 함수는 for문과 같은 반복문을 사용하지 않아도 지정한 함수로 인자를 여러번 전달해 그 결과를 list 형태로 뽑아 주는 유용한 함수이다. 한줄로 처리되다 보니 매우 간결한 형태의 코딩이 가능하다는 것이 큰 장점이다.

map() 함수의 경우 보통 위와 같이 인자를 list 형태로 전달하는게 일반적이지만 iterable 한 형태인 dictionary 같은 인자도 가능하다.

>>> x = { 1 : 10, 2 : 20, 3: 30 }

>>> map(func, x)

[ 2, 4, 6 ]

dictionary 의 key 값이 전달되게 되지만, 아래와 같이 조금만 응용하면 value 값을 전달하는 것도 가능하다.

>>> x = { 1 : 10, 2 : 20, 3: 30 }

>>> map(func, [ x[i] for i in x ])

[ 20, 40, 60 ]

[ 참고 ]

https://docs.python.org/2/library/functions.html#map

출처: https://bluese05.tistory.com/58 [ㅍㅍㅋㄷ]

unix timestamp를 datatime으로 바꾸는 방법

Python Exercise: Convert unix timestamp string to readable date

Python datetime: Exercise-6 with Solution

Write a Python program to convert unix timestamp string to readable date.

Sample Solution:

Python Code:

import datetime
print(
    datetime.datetime.fromtimestamp(
        int("1284105682")
    ).strftime('%Y-%m-%d %H:%M:%S')
)

Sample Output:

2010-09-10 13:31:22

출처 : https://www.w3resource.com/python-exercises/date-time-exercise/python-date-time-exercise-6.php

numpy array 슬라이싱 [1][2]와 [1,2]

예전에 Python Pandas 의 DataFrame 전처리에 대해서 연재할 때 DataFrame의 행 또는 열 데이터 선택해서 가져오기 (Indexing and selection of DataFrame objects) 하는 방법에 대해서 소개했던 적이 있습니다.

이번 포스팅에서는 Python NumPy 배열의 일부분, 부분집합을 선택 (Indexing and slicing an ndarray) 하는 방법을 알아보겠습니다.

다차원 배열 다룰 때 indexing, slicing 은 마치 밥 먹을 때 수시로 김치에 젖가락이 가듯이 그냥 일상적으로 사용하곤 하므로 정확하게 알아둘 필요가 있습니다.

1차원 배열, 2차원 배열, 3차원 배열의 순서대로 indexing 하는 방법을 간단한 예를 들어서 설명해보겠습니다.

(1-1) Indexing a subset of 1D array : a[from : to]

#%% NumPy array Indexing and Slicing

In [1]: import numpy as np

In [2]: a = np.arange(10)

In [3]: a
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# (1-1) Indexing a subset of 1D array
In [4]: a[0]
Out[4]: 0
In [5]: a[0:5]
Out[5]: array([0, 1, 2, 3, 4])

(1-2) array slices are views of the original array and are not a copy

Python NumPy의 배열 indexing, slicing에서 유의해야할 것이 있습니다. 배열을 indexing 해서 얻은 객체는 복사(copy)가 된 독립된 객체가 아니며, 단지 원래 배열의 view 일 뿐이라는 점입니다. 따라서 view를 새로운 값으로 변경시키면 원래의 배열의 값도 변경이 됩니다.

아래 예에서 원래의 배열 'b'의 0, 1, 2 위치의 원소에 빨간색으로 밑줄을 그어놨습니다. 배열 b에서 0, 1, 2, 3, 4 위치의 값을 indexing 해서 만든 b_idx 배열은 원래 배열 b의 view 일 뿐이며, copy가 아닙니다. b_idx 에서 뭔가 변화가 일어나면 원래의 배열 b에도 b_idx의 변화가 반영됩니다. b_idx의 0, 1, 2 위치의 원소 값을 '10'으로 바꿔치기 했더니 원래의 배열 b의 0, 1, 2 위치의 값도 '10'으로 바뀌어있음을 알 수 있습니다.

In [6]: b = np.arange(10)

In [7]: b
Out[7]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [8]: b_idx = b[0:5]

In [9]: b_idx
Out[9]: array([0, 1, 2, 3, 4])

# Assigning(Broadcasting) a scalar to a slice of 1D array
In [10]: b_idx[0:3] = 10

In [11]: b_idx
Out[11]: array([10, 10, 10, 3, 4])

# compare this 'b' with the original array 'b' above, it's different!!!
In [12]: b
Out[12]: array([10, 10, 10, 3, 4, 5, 6, 7, 8, 9])

R 사용자라면 위 상황을 보고 아주 당황스러울 것입니다. R에서는 indexing을 하면 무조건 copy 가 되고, 원래의 배열과 indexing한 후의 배열은 전혀 별개의, 독립된 객체로 간주가 되거든요. 그래서 저 같은 경우는 크기가 매우 큰 배열의 경우 아주 작은 일부분만 indexing을 해 온후에, 작은 크기의 indexing한 배열을 가지고 데이터 조작 test를 이렇게 저렇게 다양하게 해 본 후에, 제대로 작동하는 걸 확인한 최종 R script를 원래의 크기가 큰 배열에 적용하곤 했거든요. indexing 했던 배열에 제가 무슨 짓을 하던 그건 원래의 배열에 영향이 없었던 거지요.

반면에, Python NumPy의 배열에서는 indexing해온 배열에 제가 무슨 짓을 하면요, 그게 원래의 배열에도 반영이 되는 줄을 처음에 몰랐었습니다. 그러다 보니 indexing했던 배열에 이런, 저런 test 해보고 나서 원래 배열이 변질(?)이 된 것 보고 '이게 뭐지? 왜 이런 거지? 무슨 일이 벌어진 거지? 이거 혹시 버그?'... 뭐, 이랬습니다. 한참을 이랬습니다. 에휴... -_-;

Python NumPy가 배열 indexing 할 때 copy가 view를 반환하는데는 이유가 있겠지요? 그건 성능(performance)을 높이고 메모리(memory) 이슈를 피하기 위해서 입니다.

(1-3) indexing한 배열을 복사하기 : arr[0:5].copy()

배열을 indexing 한 후에 얻은 배열을 복사하고 싶으면, 그래서 원래의 배열과 독립된 배열로 처리하고 싶으면 copy() method 를 사용하면 됩니다. 아래 예는 c[0:5].copy() 만 다르고, 나머지는 위의 예와 동일한데요, 제일 마지막의 [19] 번 결과를 보면 원래의 배열 'c'가 indexing된 배열 'c_idx_copy'가 중간에 바뀐것에 영향을 안받고 원래의 값을 그대로 유지하고 있습니다. 빨간색으로 밑줄 그어놓은 부분을 위의 [12]번 결과와 아래의 [19]번 결과를 비교해보시기 바랍니다.

In [13]: c = np.arange(10)

In [14]: c
Out[14]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [15]: c_idx_copy = c[0:5].copy()

In [16]: c_idx_copy
Out[16]: array([0, 1, 2, 3, 4])

In [17]: c_idx_copy[0:3] = 10

In [18]: c_idx_copy
Out[18]: array([10, 10, 10, 3, 4])

In [19]: c
Out[19]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

이제 2차원 배열로 넘어가 볼까요?

(2-1) Indexing and Slicing 2D array with comma ',' : d[0:3, 1:3]

행과 열 기준으로 위치를 지정해주어서 indexing을 하며, 연속된 위치 값의 경우 '0:2' 처럼 콜론(colon) ':' 를 사용하면 편리합니다. 행과 열의 구분은 콤마(comma) ',' 를 사용합니다.

아래 몇 가지 유형별로 예시를 들어놓았으니 indexing 방법과 결과를 살펴보시기 바랍니다.

In [20]: d = np.arange(20).reshape(4, 5)

In [21]: d
Out[21]:
array([[ 0, 1, 2, 3, 4],
        [ 5, 6, 7, 8, 9],
        [10, 11, 12, 13, 14],
      [15, 16, 17, 18, 19]])

# indexing a row of 2D array => returning a 1D array
In [22]: d[0]
Out[22]: array([0, 1, 2, 3, 4])

# indexing mutiple rows in a row of 2D array : use colon ':'

In [23]: d[0:2]
Out[23]:
array([[0, 1, 2, 3, 4],
      [5, 6, 7, 8, 9]])

# indexing an element of of 2D array : use comma ','

In [24]: d[0, 4]
Out[24]: 4

In [25]: d[0:3, 1:3]
Out[25]:
array([[ 1, 2],
      [ 6, 7],
        [11, 12]])

(2-2) Indexing and Slicing 2D array with square bracket '[ ][ ]' : d[0:3][1:3]

NumPy 배열을 행과 열을 기준으로 indexing 할 때 콤마(comma) ','를 사용하지 않고 아래 처럼 대괄호(square bracket)을 두개 '[ ][ ]' 처럼 사용할 수도 있습니다. 다만, indexing 하는 순서와 결과가 위에서 예를 들었던 콤마 ','를 사용하는 것과 조금 다르므로 주의하기 바랍니다.

대괄호 두개 '[ ][ ]'는 첫번째 대괄호 '[ ]'에서 indexing을 먼저 하고 나서, 그 결과를 가져다가 두번째 대괄호 '[ ]'에서 한번 더 indexing을 하게 됩니다.

In [26]: d
Out[26]:
array([[ 0, 1, 2, 3, 4],
        [ 5, 6, 7, 8, 9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]])

In [27]: d[0][4] # the same result with the above [24]
Out[27]: 4

In [28]: d[0:3][1:3] # a different result from the above [25], working sequencially
Out[28]:
array([[ 5, 6, 7, 8, 9],
        [10, 11, 12, 13, 14]])

(2-3) array slices are views of the original array and are not a copy

위의 (1-2) 에서 NumPy 배열을 indexing해서 얻은 배열은 원래 배열의 copy가 아니라 view 라고 했었습니다. 2차원 배열도 똑같습니다. 복습하는 차원에서 2차원 배열에서 indexing한 view 'd_idx_0'에 일부 변화를 줘보겠습니다. 그랬더니 원래 배열 'd'에도 view 'd_dix_0'의 변화가 반영이 되었음을 알 수 있습니다.

# assigning a scalar value to the subset(1D array) of 2D array

In [29]: d
Out[29]:
array([[ 0, 1, 2, 3, 4],
        [ 5, 6, 7, 8, 9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]])

In [30]: d_idx_0 = d[0]

In [31]: d_idx_0
Out[31]: array([0, 1, 2, 3, 4])

In [32]: d_idx_0[0:2] = 100

In [33]: d_idx_0
Out[33]: array([100, 100, 2, 3, 4])

# once again, subset of array by indexing is not a copy, but a view!!!
In [34]: d
Out[34]:
array([[100, 100,   2,   3,   4],
      [ 5,   6,   7,   8,   9],
        [ 10, 11, 12, 13, 14],
        [ 15, 16, 17, 18, 19]])

3차원 배열 indexing도 마저 알아보겠습니다.

(3-1) Indexing and Slicing of 3D array : e[0, 0, 0:3]

방법은 위의 1차원 배열, 2차원 배열 indexing과 동일합니다. 3차원이 되면 2차원 배열이 층을 이루어서 겹겹이 쌓여서 나타나게 되어서 좀 헷갈릴 수 있는데요, 아래에 몇 개 indexing 유형별로 예를 들었으니 참고하시기 바랍니다.

층을 먼저 선택(2차원 배열 덩어리 중에서 먼저 indexing) 하는 것이 추가가 된 것이구요, 그 다음의 indexing은 위의 2차원 배열 indexing 방법과 동일합니다.

# (3-1) Indexing and Slicing 3D array

In [35]: e = np.arange(24).reshape(2, 3, 4)

In [36]: e
Out[36]:
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]]])

# indexing the first array with shape(3, 4) from the 3D array with shape(2, 3, 4)
In [37]: e_idx_0 = e[0]

In [38]: e_idx_0
Out[38]:
array([[ 0, 1, 2, 3],
        [ 4, 5, 6, 7],
        [ 8, 9, 10, 11]])

# indexing the first row of the first array with shape(3, 4) from the 3D array with shape(2, 3, 4)
In [39]: e_idx_0_0 = e[0, 0]

In [40]: e_idx_0_0
Out[40]: array([0, 1, 2, 3])

# indexing the '0, 1, 2' elements from the first row of the first array with shape(3, 4)
# from the 3D array with shape(2, 3, 4)
In [41]: e_idx_0_0_0_2 = e[0, 0, 0:3]

In [42]: e_idx_0_0_0_2
Out[42]: array([0, 1, 2])

(3-2) 축 하나를 통째로 가져오기( indexing the entire axis by using colon ':')

콜론(colon) ':' 을 사용해서 행 축(row, axis 0)을 통째로 slicing 해올 수 있습니다.

In [44]: e
Out[44]:
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]]])

# indexing the entire axis by using colon ':'

In [43]: e[0, :, 0:3]
Out[43]:
array([[ 0, 1, 2],
        [ 4, 5, 6],
      [ 8, 9, 10]])

Python NumPy 배열 Indexing과 R의 행렬 Indexing 비교

마지막으로, R을 사용하면서 Python을 사용하는 분이라면 indexing이 처음에 혼란스러울 것입니다.

저는 R indexing이 훨씬 더 쉬운데요, 여러분은 어떤지 모르겠습니다. Python indexing은 '0'부터 시작하는 것도 어색하고, '0:3'이라고 했을 때 '3' 위치는 포함하지 않는 것도 어색합니다. Python indexing 할 때는 항상 긴장하고, 실수 하지 않기 위해 머리 써야 해서 피곤합니다. -_-;;;

(Java 나 C 프로그래밍 하셨던 분이라면 Python indexing이 더 쉽고 R indexing이 혼란스럽다고 하겠지요? ㅎㅎ)

아래에 Python NumPy 2차원 배열 indexing과 똑같은 결과를 얻을 수 있는 R의 행렬 indexing을 비교해보았습니다.

Python NumPy : Indexing of 2D array	R : Indexing of Matrix
In [44]: d = np.arange(20).reshape(4, 5) In [45]: d Out[45]: array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) In [46]: d[0:3, 1:3] Out[46]: array([[ 1, 2], [ 6, 7], [11, 12]])	> R_matrix_4_5 <- matrix(0:19, + nrow=4, + byrow=T) > >>> R_matrix_4_5 [,1] [,2] [,3] [,4] [,5][1,] 0 1 2 3 4[2,] 5 6 7 8 9[3,] 10 11 12 13 14[4,] 15 16 17 18 19> > R_matrix_4_5[1:3, 2:3] [,1] [,2][1,] 1 2[2,] 6 7[3,] 11 12

출처: https://rfriend.tistory.com/290 [R, Python 분석과 프로그래밍의 친구 (by R Friend)]

ZINNIAS_TOP