Pandas를 사용하는 '대용량 데이터'워크 플로
나는 판다를 배우면서 몇 달 동안이 질문에 대한 답을 찾기 위해 노력했습니다. 저는 일상적인 작업에 SAS를 사용하고 있으며 핵심 지원이 아닌 경우에도 좋습니다. 그러나 SAS는 다른 여러 가지 이유로 소프트웨어로서 끔찍합니다.
언젠가는 SAS 사용을 python 및 pandas로 바꾸고 싶지만 현재 대규모 데이터 세트를위한 아웃 오브 코어 워크 플로가 부족합니다. 나는 분산 네트워크를 필요로하는 "빅 데이터"에 대해 말하는 것이 아니라 메모리에 맞기에는 너무 큰 파일이지만 하드 드라이브에 들어갈만큼 충분히 작은 파일입니다.
내 첫 번째 생각은 HDFStore디스크에 대용량 데이터 세트를 보관하고 필요한 부분 만 분석을 위해 데이터 프레임으로 가져 오는 데 사용 하는 것입니다. 다른 사람들은 MongoDB를 사용하기 쉬운 대안으로 언급했습니다. 내 질문은 다음과 같습니다.
다음을 수행하기위한 몇 가지 모범 사례 워크 플로는 무엇입니까?
- 영구 디스크상의 데이터베이스 구조에 플랫 파일로드
- pandas 데이터 구조에 공급할 데이터를 검색하기 위해 해당 데이터베이스 쿼리
- Pandas에서 조각을 조작 한 후 데이터베이스 업데이트
특히 "대용량 데이터"에 대해 팬더를 사용하는 모든 사람이 실제 사례를 많이 볼 수 있습니다.
편집-이 작업을 수행하는 방법의 예 :
- 대용량 플랫 파일을 반복적으로 가져와 영구 디스크 데이터베이스 구조에 저장합니다. 이러한 파일은 일반적으로 너무 커서 메모리에 맞지 않습니다.
- Pandas를 사용하기 위해 메모리에 맞을 수있는이 데이터의 하위 집합 (일반적으로 한 번에 몇 개의 열만)을 읽고 싶습니다.
- 선택한 열에 대해 다양한 작업을 수행하여 새 열을 만듭니다.
- 그런 다음 이러한 새 열을 데이터베이스 구조에 추가해야합니다.
이 단계를 수행하는 최상의 방법을 찾으려고합니다. pandas 및 pytables에 대한 링크를 읽으면 새 열을 추가하는 것이 문제가 될 수있는 것 같습니다.
편집-Jeff의 질문에 구체적으로 응답 :
- 저는 소비자 신용 위험 모델을 구축하고 있습니다. 데이터 종류에는 전화, SSN 및 주소 특성이 포함됩니다. 속성 값; 범죄 기록, 파산 등과 같은 경멸적인 정보 ... 매일 사용하는 데이터 세트에는 숫자 및 문자 데이터의 연속, 명목 및 순서 변수와 같은 혼합 데이터 유형의 평균 1,000 ~ 2,000 개의 필드가 있습니다. 행을 거의 추가하지 않지만 새 열을 만드는 많은 작업을 수행합니다.
- 일반적인 작업에는 조건부 논리를 사용하여 여러 열을 새로운 복합 열로 결합하는 작업이 포함됩니다. 예 :
if var1 > 2 then newvar = 'A' elif var2 = 4 then newvar = 'B'. 이러한 작업의 결과는 내 데이터 세트의 모든 레코드에 대한 새 열입니다. - 마지막으로 이러한 새 열을 디스크상의 데이터 구조에 추가하고 싶습니다. 2 단계를 반복하여 교차 분석 및 기술 통계를 사용하여 데이터를 탐색하여 모델에 대한 흥미롭고 직관적 인 관계를 찾으려고합니다.
- 일반적인 프로젝트 파일은 일반적으로 약 1GB입니다. 파일은 행이 소비자 데이터 레코드로 구성되는 방식으로 구성됩니다. 각 행에는 모든 레코드에 대해 동일한 수의 열이 있습니다. 항상 그렇습니다.
- 새 열을 만들 때 행별로 하위 집합을 만드는 것은 매우 드뭅니다. 그러나 보고서를 만들거나 기술 통계를 생성 할 때 행의 하위 집합을 만드는 것은 매우 일반적입니다. 예를 들어 소매 신용 카드와 같이 특정 비즈니스 라인에 대한 간단한 빈도를 만들 수 있습니다. 이를 위해보고 할 열에 추가로 비즈니스 라인 = 소매인 레코드 만 선택합니다. 그러나 새 열을 만들 때 모든 데이터 행과 작업에 필요한 열만 가져옵니다.
- 모델링 프로세스에서는 모든 열을 분석하고 일부 결과 변수와 흥미로운 관계를 찾고 이러한 관계를 설명하는 새로운 복합 열을 만들어야합니다. 내가 탐색하는 컬럼은 일반적으로 작은 세트로 이루어집니다. 예를 들어, 부동산 가치를 다루는 20 개의 열 세트에 초점을 맞추고 대출 채무 불이행과 어떤 관련이 있는지 관찰합니다. 그것들을 탐구하고 새로운 칼럼이 생성되면, 나는 대학 교육이라고하는 다른 칼럼 그룹으로 이동하고 그 과정을 반복합니다. 내가하는 일은 내 데이터와 일부 결과 간의 관계를 설명하는 후보 변수를 만드는 것입니다. 이 과정의 마지막에 저는 복합 열에서 방정식을 만드는 몇 가지 학습 기술을 적용합니다.
데이터 세트에 행을 추가하는 경우는 드뭅니다. 나는 거의 항상 새로운 열 (통계 / 기계 학습 용어의 변수 또는 기능)을 만들 것입니다.
나는 일상적으로 이러한 방식으로 수십 기가 바이트의 데이터를 사용합니다. 예를 들어, 쿼리를 통해 읽고 데이터를 만들고 다시 추가하는 디스크에 테이블이 있습니다.
그것의 가치가 읽기 워드 프로세서 및 후반이 스레드에 데이터를 저장하는 방법에 대한 몇 가지 제안.
다음과 같이 데이터를 저장하는 방법에 영향을 미치는 세부 정보 :
가능한 한 많은 세부 정보를 제공하십시오. 구조 개발을 도와 드릴 수 있습니다.
- 데이터 크기, 행 수, 열, 열 유형; 행을 추가합니까, 아니면 열만 추가합니까?
- 일반적인 작업은 어떤 모습일까요? 예를 들어 열에 대한 쿼리를 수행하여 행과 특정 열을 선택한 다음 작업 (메모리 내)을 수행하고 새 열을 만들고 저장합니다.
(장난감 예제를 제공하면 더 구체적인 권장 사항을 제공 할 수 있습니다.) - 그 처리 후에 당신은 무엇을합니까? 2 단계는 임시입니까, 아니면 반복 할 수 있습니까?
- 입력 플랫 파일 : 대략적인 총 크기 (GB). 예를 들어 레코드별로 어떻게 구성됩니까? 각각 다른 필드가 포함되어 있습니까? 아니면 각 파일의 모든 필드가있는 파일 당 레코드가 있습니까?
- 기준에 따라 행 (레코드)의 하위 집합을 선택 했습니까 (예 : 필드 A> 5 인 행 선택)? 그런 다음 무언가를 수행하거나 모든 레코드가있는 필드 A, B, C를 선택합니까 (다음에 수행)?
- 모든 열을 (그룹으로) '작업'합니까, 아니면 보고서에만 사용할 수있는 적절한 비율이 있습니까 (예 : 데이터를 유지하고 싶지만 그 열을 명시 적으로 가져올 필요는 없습니다) 최종 결과 시간)?
해결책
팬더가 최소한0.10.1 설치되어 있는지 확인하십시오 .
읽기 파일을 덩어리별로 덩어리 반복 과 다중 테이블 쿼리를 .
pytables는 행 방식 (당신이 쿼리하는 것)에서 작동하도록 최적화 되었기 때문에 각 필드 그룹에 대한 테이블을 만들 것입니다. 이렇게하면 작은 필드 그룹을 쉽게 선택할 수 있습니다 (큰 테이블에서 작동하지만 이렇게하는 것이 더 효율적입니다 ...이 제한을 나중에 수정할 수있을 것 같습니다. 더 직관적 임) :
(다음은 의사 코드입니다.)
import numpy as np
import pandas as pd
# create a store
store = pd.HDFStore('mystore.h5')
# this is the key to your storage:
# this maps your fields to a specific group, and defines
# what you want to have as data_columns.
# you might want to create a nice class wrapping this
# (as you will want to have this map and its inversion)
group_map = dict(
A = dict(fields = ['field_1','field_2',.....], dc = ['field_1',....,'field_5']),
B = dict(fields = ['field_10',...... ], dc = ['field_10']),
.....
REPORTING_ONLY = dict(fields = ['field_1000','field_1001',...], dc = []),
)
group_map_inverted = dict()
for g, v in group_map.items():
group_map_inverted.update(dict([ (f,g) for f in v['fields'] ]))
파일 읽기 및 저장소 만들기 (본질적으로 수행하는 작업 append_to_multiple) :
for f in files:
# read in the file, additional options hmay be necessary here
# the chunksize is not strictly necessary, you may be able to slurp each
# file into memory in which case just eliminate this part of the loop
# (you can also change chunksize if necessary)
for chunk in pd.read_table(f, chunksize=50000):
# we are going to append to each table by group
# we are not going to create indexes at this time
# but we *ARE* going to create (some) data_columns
# figure out the field groupings
for g, v in group_map.items():
# create the frame for this group
frame = chunk.reindex(columns = v['fields'], copy = False)
# append it
store.append(g, frame, index=False, data_columns = v['dc'])
이제 파일에 모든 테이블이 있습니다 (실제로 원하는 경우 별도의 파일에 저장할 수 있습니다. group_map에 파일 이름을 추가해야 할 수도 있지만 필요하지 않을 수도 있습니다).
다음은 열을 가져오고 새 열을 만드는 방법입니다.
frame = store.select(group_that_I_want)
# you can optionally specify:
# columns = a list of the columns IN THAT GROUP (if you wanted to
# select only say 3 out of the 20 columns in this sub-table)
# and a where clause if you want a subset of the rows
# do calculations on this frame
new_frame = cool_function_on_frame(frame)
# to 'add columns', create a new group (you probably want to
# limit the columns in this new_group to be only NEW ones
# (e.g. so you don't overlap from the other tables)
# add this info to the group_map
store.append(new_group, new_frame.reindex(columns = new_columns_created, copy = False), data_columns = new_columns_created)
사후 처리 준비가되면 :
# This may be a bit tricky; and depends what you are actually doing.
# I may need to modify this function to be a bit more general:
report_data = store.select_as_multiple([groups_1,groups_2,.....], where =['field_1>0', 'field_1000=foo'], selector = group_1)
data_columns 정보, 당신은 실제로 정의 할 필요가 없습니다 모든 data_columns을; 열을 기준으로 행을 하위 선택할 수 있습니다. 예 :
store.select(group, where = ['field_1000=foo', 'field_1001>0'])
최종 보고서 생성 단계에서 가장 흥미로울 수 있습니다. 기본적으로 데이터 열은 다른 열과 분리되어 있으므로 많은 것을 정의하면 효율성에 다소 영향을 미칠 수 있습니다.
다음을 수행 할 수도 있습니다.
- 필드 목록을 가져오고 groups_map에서 그룹을 조회 한 다음이를 선택하고 결과를 연결하여 결과 프레임을 얻는 함수를 만듭니다 (이는 본질적으로 select_as_multiple이 수행하는 작업입니다). 이렇게하면 구조가 매우 투명 해집니다.
- 특정 데이터 열에 대한 인덱스 (행 부분 집합 화가 훨씬 빨라짐)
- 압축을 활성화합니다.
질문이 있으면 알려주세요!
위의 답변에는 매우 유용하다고 생각되는 간단한 접근 방식이 누락되어 있다고 생각합니다.
너무 커서 메모리에로드 할 수없는 파일이 있으면 파일을 여러 개의 작은 파일 (행 또는 열)로 나눕니다.
예 : 30 일 분량의 거래 데이터가 ~ 30GB 크기 인 경우 하루에 ~ 1GB 크기의 파일로 나눕니다. 이후에 각 파일을 개별적으로 처리하고 마지막에 결과를 집계합니다.
가장 큰 장점 중 하나는 파일 (다중 스레드 또는 프로세스)의 병렬 처리를 허용한다는 것입니다.
다른 장점은 파일 조작 (예에서 날짜 추가 / 제거와 같은)이 일반 셸 명령으로 수행 될 수 있다는 것입니다. 이는 고급 / 복잡한 파일 형식에서는 불가능합니다.
이 접근 방식은 모든 시나리오를 포함하지는 않지만 많은 시나리오에서 매우 유용합니다.
질문이 있은 지 2 년이 지난 지금, '핵심이없는'판다에 해당하는 dask가 있습니다. 훌륭합니다! 모든 pandas 기능을 지원하지는 않지만 정말 멀리 할 수 있습니다.
데이터 세트가 1GB에서 20GB 사이 인 경우 48GB RAM이있는 워크 스테이션이 있어야합니다. 그러면 Pandas는 전체 데이터 세트를 RAM에 보관할 수 있습니다. 여기에서 원하는 답이 아니라는 것을 알고 있지만 4GB RAM 노트북에서 과학 컴퓨팅을 수행하는 것은 합리적이지 않습니다.
나는 이것이 오래된 스레드라는 것을 알고 있지만 Blaze 라이브러리를 확인해 볼 가치가 있다고 생각합니다 . 이러한 유형의 상황을 위해 만들어졌습니다.
문서에서 :
Blaze는 NumPy 및 Pandas의 유용성을 분산 및 코어 외부 컴퓨팅으로 확장합니다. Blaze는 NumPy ND-Array 또는 Pandas DataFrame과 유사한 인터페이스를 제공하지만 이러한 친숙한 인터페이스를 Postgres 또는 Spark와 같은 다양한 다른 계산 엔진에 매핑합니다.
편집 : 그건 그렇고, ContinuumIO와 NumPy의 저자 인 Travis Oliphant가 지원합니다.
이것은 pymongo의 경우입니다. 또한 파이썬에서 SQL Server, sqlite, HDF, ORM (SQLAlchemy)을 사용하여 프로토 타입을 만들었습니다. 가장 먼저 pymongo는 문서 기반 DB이므로 각 사람은 문서 ( dict속성)가됩니다. 많은 사람들이 컬렉션을 구성하고 많은 컬렉션 (사람, 주식 시장, 수입)을 가질 수 있습니다.
pd.dateframe-> pymongo 참고 : chunksizein read_csv을 사용하여 5 ~ 10k 레코드로 유지합니다 (pymongo가 더 크면 소켓을 삭제함).
aCollection.insert((a[1].to_dict() for a in df.iterrows()))
질의 : gt =보다 큼 ...
pd.DataFrame(list(mongoCollection.find({'anAttribute':{'$gt':2887000, '$lt':2889000}})))
.find()반복자를 반환하므로 일반적 ichunked으로 더 작은 반복자로 자르는 데 사용 합니다.
일반적으로 10 개의 데이터 소스를 함께 붙여 넣기 때문에 조인은 어떻습니까?
aJoinDF = pandas.DataFrame(list(mongoCollection.find({'anAttribute':{'$in':Att_Keys}})))
그런 다음 (제 경우에는 aJoinDF"병합 가능"하기 전에 먼저 agg해야합니다 .)
df = pandas.merge(df, aJoinDF, on=aKey, how='left')
그런 다음 아래 업데이트 방법을 통해 새 정보를 기본 컬렉션에 쓸 수 있습니다. (논리적 수집 대 물리적 데이터 소스).
collection.update({primarykey:foo},{key:change})
작은 조회에서는 비정규 화하십시오. 예를 들어 문서에 코드가 있고 필드 코드 텍스트를 추가하고 dict문서를 만들 때 조회를 수행하기 만하면 됩니다.
이제 사람을 기반으로 한 멋진 데이터 세트가 있으므로 각 사례에 대한 논리를 풀고 더 많은 속성을 만들 수 있습니다. 마지막으로 3 to memory max 주요 지표를 읽고 피벗 / agg / 데이터 탐색을 수행 할 수 있습니다. 이것은 숫자 / 큰 텍스트 / 카테고리 / 코드 / 부동산 / ...
MongoDB에 내장 된 두 가지 방법 (MapReduce 및 집계 프레임 워크)을 사용할 수도 있습니다. 집계 프레임 워크에 대한 자세한 내용은 여기를 참조하세요. MapReduce보다 쉽고 빠른 집계 작업에 편리해 보입니다. 필드 나 관계를 정의 할 필요가 없었으며 문서에 항목을 추가 할 수 있습니다. 빠르게 변화하는 numpy, pandas, python 도구 집합의 현재 상태에서 MongoDB는 작업을 시작하는 데 도움이됩니다. :)
나는 이것을 조금 늦게 발견했지만 비슷한 문제 (모기지 선불 모델)를 가지고 일하고 있습니다. 내 해결책은 pandas HDFStore 레이어를 건너 뛰고 곧은 pytables를 사용하는 것입니다. 최종 파일에 각 열을 개별 HDF5 배열로 저장합니다.
내 기본 워크 플로는 먼저 데이터베이스에서 CSV 파일을 가져 오는 것입니다. 나는 그것을 gzip으로, 그렇게 크지 않습니다. 그런 다음 파이썬에서 반복하고 각 행을 실제 데이터 유형으로 변환하고 HDF5 파일에 기록하여 행 지향 HDF5 파일로 변환합니다. 수십 분이 걸리지 만 행 단위로만 작동하기 때문에 메모리를 사용하지 않습니다. 그런 다음 행 지향 HDF5 파일을 열 지향 HDF5 파일로 "전치"합니다.
테이블 조옮김은 다음과 같습니다.
def transpose_table(h_in, table_path, h_out, group_name="data", group_path="/"):
# Get a reference to the input data.
tb = h_in.getNode(table_path)
# Create the output group to hold the columns.
grp = h_out.createGroup(group_path, group_name, filters=tables.Filters(complevel=1))
for col_name in tb.colnames:
logger.debug("Processing %s", col_name)
# Get the data.
col_data = tb.col(col_name)
# Create the output array.
arr = h_out.createCArray(grp,
col_name,
tables.Atom.from_dtype(col_data.dtype),
col_data.shape)
# Store the data.
arr[:] = col_data
h_out.flush()
다시 읽으면 다음과 같습니다.
def read_hdf5(hdf5_path, group_path="/data", columns=None):
"""Read a transposed data set from a HDF5 file."""
if isinstance(hdf5_path, tables.file.File):
hf = hdf5_path
else:
hf = tables.openFile(hdf5_path)
grp = hf.getNode(group_path)
if columns is None:
data = [(child.name, child[:]) for child in grp]
else:
data = [(child.name, child[:]) for child in grp if child.name in columns]
# Convert any float32 columns to float64 for processing.
for i in range(len(data)):
name, vec = data[i]
if vec.dtype == np.float32:
data[i] = (name, vec.astype(np.float64))
if not isinstance(hdf5_path, tables.file.File):
hf.close()
return pd.DataFrame.from_items(data)
이제 저는 일반적으로 메모리가 많은 컴퓨터에서 이것을 실행하므로 메모리 사용량에 충분히주의하지 않을 수 있습니다. 예를 들어 기본적으로로드 작업은 전체 데이터 세트를 읽습니다.
이것은 일반적으로 나를 위해 작동하지만 약간 투박하고 멋진 pytables 마법을 사용할 수 없습니다.
Edit: The real advantage of this approach, over the array-of-records pytables default, is that I can then load the data into R using h5r, which can't handle tables. Or, at least, I've been unable to get it to load heterogeneous tables.
One trick I found helpful for large data use cases is to reduce the volume of the data by reducing float precision to 32-bit. It's not applicable in all cases, but in many applications 64-bit precision is overkill and the 2x memory savings are worth it. To make an obvious point even more obvious:
>>> df = pd.DataFrame(np.random.randn(int(1e8), 5))
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float64(5)
memory usage: 3.7 GB
>>> df.astype(np.float32).info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000000 entries, 0 to 99999999
Data columns (total 5 columns):
...
dtypes: float32(5)
memory usage: 1.9 GB
As noted by others, after some years an 'out-of-core' pandas equivalent has emerged: dask. Though dask is not a drop-in replacement of pandas and all of its functionality it stands out for several reasons:
Dask is a flexible parallel computing library for analytic computing that is optimized for dynamic task scheduling for interactive computational workloads of “Big Data” collections like parallel arrays, dataframes, and lists that extend common interfaces like NumPy, Pandas, or Python iterators to larger-than-memory or distributed environments and scales from laptops to clusters.
Dask emphasizes the following virtues:
- Familiar: Provides parallelized NumPy array and Pandas DataFrame objects
- Flexible: Provides a task scheduling interface for more custom workloads and integration with other projects.
- Native: Enables distributed computing in Pure Python with access to the PyData stack.
- Fast: Operates with low overhead, low latency, and minimal serialization necessary for fast numerical algorithms
- Scales up: Runs resiliently on clusters with 1000s of cores Scales down: Trivial to set up and run on a laptop in a single process
- Responsive: Designed with interactive computing in mind it provides rapid feedback and diagnostics to aid humans
and to add a simple code sample:
import dask.dataframe as dd
df = dd.read_csv('2015-*-*.csv')
df.groupby(df.user_id).value.mean().compute()
replaces some pandas code like this:
import pandas as pd
df = pd.read_csv('2015-01-01.csv')
df.groupby(df.user_id).value.mean()
and, especially noteworthy, provides through the concurrent.futures interface a general for the submission of custom tasks:
from dask.distributed import Client
client = Client('scheduler:port')
futures = []
for fn in filenames:
future = client.submit(load, fn)
futures.append(future)
summary = client.submit(summarize, futures)
summary.result()
One more variation
Many of the operations done in pandas can also be done as a db query (sql, mongo)
Using a RDBMS or mongodb allows you to perform some of the aggregations in the DB Query (which is optimized for large data, and uses cache and indexes efficiently)
Later, you can perform post processing using pandas.
The advantage of this method is that you gain the DB optimizations for working with large data, while still defining the logic in a high level declarative syntax - and not having to deal with the details of deciding what to do in memory and what to do out of core.
And although the query language and pandas are different, it's usually not complicated to translate part of the logic from one to another.
It is worth mentioning here Ray as well,
it's a distributed computation framework, that has it's own implementation for pandas in a distributed way.
Just replace the pandas import, and the code should work as is:
# import pandas as pd
import ray.dataframe as pd
#use pd as usual
can read more details here:
https://rise.cs.berkeley.edu/blog/pandas-on-ray/
Consider Ruffus if you go the simple path of creating a data pipeline which is broken down into multiple smaller files.
I recently came across a similar issue. I found simply reading the data in chunks and appending it as I write it in chunks to the same csv works well. My problem was adding a date column based on information in another table, using the value of certain columns as follows. This may help those confused by dask and hdf5 but more familiar with pandas like myself.
def addDateColumn():
"""Adds time to the daily rainfall data. Reads the csv as chunks of 100k
rows at a time and outputs them, appending as needed, to a single csv.
Uses the column of the raster names to get the date.
"""
df = pd.read_csv(pathlist[1]+"CHIRPS_tanz.csv", iterator=True,
chunksize=100000) #read csv file as 100k chunks
'''Do some stuff'''
count = 1 #for indexing item in time list
for chunk in df: #for each 100k rows
newtime = [] #empty list to append repeating times for different rows
toiterate = chunk[chunk.columns[2]] #ID of raster nums to base time
while count <= toiterate.max():
for i in toiterate:
if i ==count:
newtime.append(newyears[count])
count+=1
print "Finished", str(chunknum), "chunks"
chunk["time"] = newtime #create new column in dataframe based on time
outname = "CHIRPS_tanz_time2.csv"
#append each output to same csv, using no header
chunk.to_csv(pathlist[2]+outname, mode='a', header=None, index=None)
I'd like to point out the Vaex package.
Vaex is a python library for lazy Out-of-Core DataFrames (similar to Pandas), to visualize and explore big tabular datasets. It can calculate statistics such as mean, sum, count, standard deviation etc, on an N-dimensional grid up to a billion (109) objects/rows per second. Visualization is done using histograms, density plots and 3d volume rendering, allowing interactive exploration of big data. Vaex uses memory mapping, zero memory copy policy and lazy computations for best performance (no memory wasted).
Have a look at the documentation: https://vaex.readthedocs.io/en/latest/ The API is very close to the API of pandas.
참고URL : https://stackoverflow.com/questions/14262433/large-data-work-flows-using-pandas
'developer tip' 카테고리의 다른 글
| 전화 번호 확인을위한 포괄적 인 정규식 (0) | 2020.09.28 |
|---|---|
| 명령 줄에서 .bash_profile을 다시로드하는 방법은 무엇입니까? (0) | 2020.09.28 |
| 자바의 정적 클래스 (0) | 2020.09.28 |
| 푸시 후 자식 커밋 메시지 변경 (원격에서 아무도 가져 오지 않은 경우) (0) | 2020.09.28 |
| C ++ 식별자에서 밑줄을 사용하는 규칙은 무엇입니까? (0) | 2020.09.28 |