다른 명령
Pandas,DataFrame 생성, 추가, 삭제, 조회, 메타 등
데이터프레임 개체 생성(create)
- Table이나 Sheet형식 데이터 저장 개체
- index 와 여러 column으로 구성
# -*- coding: utf-8 -*- from pandas import Series, DataFrame import numpy as np
기본 데이터프레임 생성
df = DataFrame([1000, 2000, 3000, 4000])
print df
df = DataFrame([1000, 2000, 3000, 4000], index=["i1", "i2", "i3", "i4"])
print df
df = DataFrame({"c1":[1000, 2000, 3000, 4000]}, index=["i1", "i2", "i3", "i4"])
print df
print("-" * 100 + "{[1]}") # ----- #
여러 컬럼 데이터프레임 생성
df2 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]})
print df2
df2 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
print df2
print("-" * 100 + "{[2]}") # ----- #
컬럼만 있는 데이터프레임 생성
df4 = DataFrame(columns=("lib","qt1","qt2"))
print df4
for i in range(5):
df4.loc[i] = [(i+1)*(n+1) for n in range(3)]
print df4
print("-" * 100 + "{[3]}") # ----- #
난수를 이용한 데이터프레임 생성
df3 = DataFrame(np.random.randn(6,3))
print df3
print("-" * 100 + "{[4]}") # ----- #
리스트로 데이터프레임으로 생성
lst1 = [1,2,3,4]
df = DataFrame(lst1)
print df
lst2 = [[1,2,3,4,5], ["a", "b","c","d","e"]]
df = DataFrame(lst2)
print df
print("-" * 100 + "{[5]}") # ----- #
딕셔너리(Dictionary)로 데이터프레임으로 생성
data = {'name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
'year': [2012, 2012, 2013, 2014, 2014],
'reports': [4, 24, 31, 2, 3],
'coverage': [25, 94, 57, 62, 70]}
df0 = DataFrame(data, index=['Cochice', 'Pima', 'Santa Cruz', 'Maricopa', 'Yuma'])
print df0
print("-" * 100 + "{[5.5]}") # ----- #
데이터프레임 개체 수정(alter)
df = DataFrame([1000, 2000, 3000, 4000])
df2 = DataFrame({"x1":[1,2,3], "x2":[11,22,33], "x3":[111,222,333]})
df3 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
컬럼명 변경
df.columns = ["C1"]
print df
df2.columns = ["c1", "c2", "c3"]
print df2
df2.rename(columns={"c1":"CC1"}, inplace = True) # 많이 쓰임!!!
print df2
print("-" * 100 + "{[6]}") # ----- #
df.columns.values[0] = 999 # 컬럼명이 숫자일 땐 숫자로..
print df
df3.columns.values[0] = "ttt" # 컬럼명이 문자일 땐 문자로..
print df3
컬럼명 변경2
df8 = pd.DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
df8.columns.values[0] = "id_area8"
print df8
df8.rename(columns={df8.columns[0]:"id_area7"}, inplace = True)
print df8
컬럼 추가 : 값 지정
df["newC2"] = 5 print df df["newC3"] = ["a","b","c","d"] print df
컬럼 추가 : Boolean 조건 지정
df2["new9"] = df2["c3"] > 300
print df2
print("-" * 100 + "{[7]}")
컬럼 추가 : 다른 column을 계산하여 생성
df2["newC9"] = df2["c2"] + df2["c3"]
print df2
print("-" * 100 + "{[8]}") # ----- #
컬럼 추가 : 시리즈로 추가
df9 = DataFrame([1000, 2000, 3000, 4000], index=["i1", "i2", "i3", "i4"])
print df9
add_srs = Series([1001, 2001, 3001, 4001], index = ["i1","i2","i3","i4"])
print add_srs
df9["c3"] = add_srs
print df9
add_srs = Series([1011, 3011, 4011], index = ["i3","i4","i5"]) # "i5"는 반영 안됨(outer join 방식)
df9["c4"] = add_srs
print df9
print("-" * 100 + "{[9]}") # ----- #
컬럼 추가 : 리스트로 추가(가장 편리)
add_lst = [1111,2222,3333,4444]
df9["c5"] = add_lst
print("-" * 100 + "{[10]}") # ----- #
컬럼 추가 : 빈 데이터프레임에 컬럼 추가(인덱스 포함)
df22 = DataFrame()
dd22 = df22.append({"c1":"", "c2":"", "c3":""}, ignore_index=True)
print df22
컬럼 추가 : 빈 데이터프레임에 컬럼 추가(인덱스 제외)
df33 = pd.DataFrame(columns=("c1", "c2", "c3")
print df33
print("-" * 100 + "{[10.3]}") # ----- #
컬럼 삭제
df2 = DataFrame({"x1":[1,2,3], "x2":[11,22,33], "x3":[111,222,333]})
df3 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
del df2["x2"]
print df
df2 = df2.drop("x1", 1)
print df2
df3 = df3.drop(["c2", "c3"], 1)
print df3
print("-" * 100 + "{[11]}") # ----- #
인덱스 컬럼명 변경
df2.index.name = "Count" print df2.index print df2
데이터프레임 개체 속성 조회 및 변경(meta)
df = DataFrame([1000, 2000, 3000, 4000], index=["i1","i2","i3","i4"])
df2 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
컬럼 이름 리턴
print df2.columns.values
인덱스 이름 리턴
print df2.index
기타 속성 리턴
print df2.shape[0] # 행 개수 : for문 range에 활용
print df2.shape[1] # 열 개수
print df2.size # 행 * 열 개수
print df2.ndim # n 차원
print df2.info() # DF정보
print df2.describe() # DF 일괄 통계 정보 추출
print("-" * 100 + "{[12]}") # ----- #
개체 타입 확인
print type(df.ix["i1"]) # 결과 : pandas.core.series.Series
print type(df.ix[1:3, 0:2]) # 결과 : pandas.core.frame.DataFrame
print("-" * 100 + "{[12.5]}") # ----- #
데이터프레임 데이터 조회(select)
df = DataFrame([1000, 2000, 3000, 4000], index=["i1","i2","i3","i4"])
df2 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
원하는 컬럼만 출력
newColList = [0,1] print df2[newColList]
데이터 추출 : 컬럼단위
print df2[["c1","c3"]]
print df2[["c2"]] # 인덱스와 컬럼명까지 출력
print df2["c2"] # 인덱스만 출력
print("-" * 100 + "{[13]}") # ----- #
데이터 추출 : 행단위
print df2.iat[0,0]
print df2.at["i1","c1"]
print df2.loc["i2"]
print df2.loc["i2"]["c1"]
print df2.iloc[0,0:3]
print("-" * 100 + "{[14]}") # ----- #
데이터 추출 : 부분
print df2.ix[0,0]
print df2.ix[1:3, 0:2]
print df2.ix["i1":"i2", "c2":"c3"]
print df2.ix[:,["c2", "c3"]]
print df2.ix[["i2","i3"], :]
print("-" * 100 + "{[15]}") # ----- #
데이터 추출 : 아래 3개 동일
print df2[0:2]
print df2.ix[0:2]
print df2.ix[0:2, :]
print("-" * 100 + "{[16]}") # ----- #
데이터 추출 : 조건 처리
df2["c4"] = df2["c3"] > 300
print df2
print("-" * 100 + "{[17]}") # ----- #
데이터 컬럼 원하는 값만 필터링
조건 연산자/함수 예제 단일 조건 ==, >, <, >=, <= df[df['Age'] >= 22] AND/OR 조건 `& / ` 값 리스트 필터링 isin() df[df['Name'].isin(['Alice', 'Bob'])] 문자열 포함 여부 필터링 str.contains() df[df['Name'].str.contains('a')] 결측치 필터링 isnull() / notnull() df[df['Age'].isnull()] 특정 값 제외 필터링 ~ (NOT) df[~df['Name'].isin(['Alice'])]
단일 조건으로 필터링
import pandas as pd
# 예제 DataFrame 생성
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [24, 19, 22, 25]}
df = pd.DataFrame(data)
# 'Age'가 22 이상인 행만 필터링
filtered_df = df[df['Age'] >= 22]
print(filtered_df)
출력:
Name Age
0 Alice 24
2 Charlie 22
3 David 25
여러 조건으로 필터링 (AND, OR 사용)
# 'Age'가 22 이상이고 'Name'이 'Alice'가 아닌 행 필터링 (AND 조건)
filtered_df = df[(df['Age'] >= 22) & (df['Name'] != 'Alice')]
print(filtered_df)
출력:
Name Age
2 Charlie 22
3 David 25
- AND 조건: & 사용.
- OR 조건: | 사용.
특정 값 리스트로 필터링
# 'Name'이 'Alice' 또는 'Charlie'인 행 필터링
filtered_df = df[df['Name'].isin(['Alice', 'Charlie'])]
print(filtered_df)
출력:
Name Age
0 Alice 24
2 Charlie 22
문자열 포함 여부로 필터링 (str.contains())
# 'Name' 열에 'a'를 포함한 이름 필터링 (대소문자 구분 없이)
filtered_df = df[df['Name'].str.contains('a', case=False)]
print(filtered_df)
출력:
Name Age
0 Alice 24
2 Charlie 22
3 David 25
null(결측치) 있는 행 필터링 (isnull() 사용)
# 결측치가 있는 행만 필터링
data_with_nan = {'Name': ['Alice', 'Bob', None], 'Age': [24, None, 22]}
df_with_nan = pd.DataFrame(data_with_nan)
filtered_df = df_with_nan[df_with_nan['Age'].isnull()]
print(filtered_df)
출력:
Name Age
1 Bob NaN
특정 값이 아닌 값 필터링 (~ 연산자 사용)
# 'Name'이 'Alice'가 아닌 행 필터링
filtered_df = df[~df['Name'].isin(['Alice'])]
print(filtered_df)
출력:
Name Age
1 Bob 19
2 Charlie 22
3 David 25
데이터프레임 데이터 변경(update, delete, insert)
df2 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
컬럼값 전체 변경
df2["c3"] = df2["c1"] + df2["c2"]
print df2
df2["c3"] = 111
print df2
print("-" * 100 + "{[18]}") # ----- #
컬럼 추가 후 데이터 입력
df2["newC4"] = ["a","b","c"] print df2
컬럼 데이터 수정
df2["newC4"] = [111,222,333]
print df2
df2.ix[1,2] = 2000
print df
print("-" * 100 + "{[19]}") # ----- #
행 추가
rows = [4, 44, 444, "d"]
df2.loc[len(df2)] = rows
print df2
df2 = df2.rename(index={3:"i4"})
print df2
행 추가 : 빈 데이터프레임에 행 추가(인덱스 포함)
df22 = DataFrame()
dd22 = df22.append({"c1":"", "c2":"", "c3":""}, ignore_index=True)
df22.ix[0, "c1"] = "111"
df22.ix[0, "c2"] = "222"
df22.ix[0, "c3"] = "333"
print df22
행 추가 : 빈 데이터프레임에 행 추가(인덱스 제외)
df33 = pd.DataFrame(columns=("c1", "c2", "c3"))
df33.loc[0] = [ "111", "222", "333"]
print df33
행 삭제
df2 = df2.drop("i2", axis = 0)
print df2
print("-" * 100 + "{[20]}") # ----- #
데이터프레임 출력 변환
print df2.T # 피벗
print df2.values # array로 받음
print df2.shape # 행렬(Array) 형태 출력
print("-" * 100 + "{[21]}") # ----- #
데이터프레임 형 변환
- 변환 함수
- astype() 특정 열 또는 DataFrame의 데이터 타입을 변경
- pd.to_datetime() 날짜 형식으로 변환
- pd.to_numeric() 숫자 형식으로 변환, 비정상 값 처리 가능
- astype('category') 범주형 데이터로 변환
열의 데이터 타입 확인
import pandas as pd
# 예제 DataFrame 생성
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': ['24', '19', '22']}
df = pd.DataFrame(data)
# 각 열의 데이터 타입 확인
print(df.dtypes)
출력:
Name object
Age object
dtype: object
특정 열의 데이터 타입 변환 (astype())
- astype() 함수로 특정 열의 타입을 변환
# 'Age' 열을 정수형(int)으로 변환 df['Age'] = df['Age'].astype(int) print(df.dtypes) 출력: Name object Age int64 dtype: object
- 주의: 문자열 데이터가 숫자로 변환될 때, 비정상적인 값이 포함되어 있으면 오류가 발생
여러 열의 타입을 동시에 변환
# 여러 열의 데이터 타입을 동시에 변환
df = df.astype({'Name': 'string', 'Age': 'int'})
print(df.dtypes)
- 각 열을 원하는 타입으로 동시에 변환
- "string"은 pandas의 StringDtype으로 처리됩니다.
날짜 형식으로 변환 (to_datetime())
- 날짜 관련 열을 datetime 형식으로 변환
data = {'Name': ['Alice', 'Bob'], 'Birthday': ['2000-01-01', '1999-05-15']}
df = pd.DataFrame(data)
# 'Birthday' 열을 날짜 형식으로 변환
df['Birthday'] = pd.to_datetime(df['Birthday'])
print(df.dtypes)
출력:
Name object
Birthday datetime64[ns]
dtype: object
범주형 데이터로 변환 (astype('category'))
- 범주형 데이터는 메모리 사용량을 줄이고 성능 향상
df['Name'] = df['Name'].astype('category')
print(df.dtypes)
출력:
Name category
Age int64
dtype: object
문자열로 변환 (astype(str))
- 숫자나 날짜를 문자열로 변환할 때 사용
df['Age'] = df['Age'].astype(str) print(df.dtypes)
결측치 처리와 변환 (pd.to_numeric())
- 숫자로 변환할 때 결측치나 비정상적인 값을 처리.
data = {'Value': ['10', '20', 'missing']}
df = pd.DataFrame(data)
# 'Value'를 숫자로 변환, 비정상 값은 NaN으로 처리
df['Value'] = pd.to_numeric(df['Value'], errors='coerce')
print(df)
출력:
Value
0 10.0
1 20.0
2 NaN
인덱싱(index, reindex)
df = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
print df
df = df.reindex(["i1", "i2", "i3", "i4", "i5"])
print df
print("-" * 100 + "{[22]}") # ----- #
df = df.reindex(["i1", "i2", "i3", "i4", "i5"]).interpolate() # 보간법
print df
df["interPo"] = df["c1"].interpolate()
print df
print("-" * 100 + "{[23]}") # ----- #
Unique(중복) 인덱싱
df = df.reindex(["i1", "i2", "i4", "i4", "i5"])
print df
print df.index.is_unique # 인덱스가 unique이면 True 리턴
print df.ix["i4"]
print("-" * 100 + "{[24]}") # ----- #
인덱스 컬럼명 변경
df7 = DataFrame({"c1":[1,2,3], "c2":[11,22,33], "c3":[111,222,333]}, index=["i1","i2","i3"])
df7.index.name = "id_area9"
print("-" * 100 + "{[24.5]}") # ----- #
기존 컬럼을 인덱스로 변경
df33 = DataFrame({"c1":[1,2], "c2":[11,22]}, index=["i1", "i2"]
print df33
df33.index.name = "idx"
print df33
df33 = df33.set_index("c1")
print df33
정렬(sort_index, sort_values)
df = DataFrame({"c2":[10,40,70], "c3":[50,20,20], "c1":[60,30,90]}, index=["i2","i1","i3"])
print df
정렬 : 인덱스 기준
print df.sort_index() # 인덱스명으로 정렬
print df.sort_index(axis=0) # 인덱스(?)로 정렬
print df.sort_index(axis=1) # 컬럼명(?)으로 정렬
print df.sort_index(axis=0, ascending = False) # descending
print("-" * 100 + "{[25]}") # ----- #
df2 = df.sort_index(axis = 0)
df3 = df2.sort_index(axis = 1)
print df3
print("-" * 100 + "{[26]}") # ----- #
정렬 : 컬럼 기준
print df.sort_values(by = "c1")
print df.sort_values(by = "c1", ascending=False)
print df.sort_values(by = ["c3","c2"])
print("-" * 100 + "{[27]}") # ----- #
NULL 처리(NaN, NA, NULL)
from numpy import nan as NA df = DataFrame(np.random.randn(7,3)) print df
강제로 NA 추가
df.ix[2,1] = NA df.ix[3,2] = NA print df
NaN 변경(null if)
df.replace(np.NaN, 'NULL Value', inplace=True)
#df.column_nm.replace(np.NaN, 'NULL Value', inplace=True)
print("-" * 100 + "{[28]}") # ----- #
랭킹 및 집계처리(lambda, apply)
data = {'name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
'year': [2012, 2012, 2013, 2014, 2014],
'reports': [4, 24, 31, 2, 3],
'coverage': [25, 94, 57, 62, 70]}
df = DataFrame(data, index=['Cochice', 'Pima', 'Santa Cruz', 'Maricopa', 'Yuma'])
print df
print("-" * 100 + "{[29]}") # ----- #
랭킹
# print df.rank(method="first") # 에러나는데.. 무슨 numeric일때만?
print df.rank(axis=0) # 행단위로 순위
print df.rank(axis=1) # 컬럼단위로 순위
print df.rank(ascending=False, method="max")
print("-" * 100 + "{[30]}") # ----- #
#-- 랭킹 : 한 컬럼으로 순위 선정
df['coverageRanked'] = df['coverage'].rank(ascending=1)
print df
print("-" * 100 + "{[31]}") # ----- #
lambda를 이용한 apply함수 사용
# 행이나 열에서의 max() - min() 활용
df = DataFrame({"c1":[20,30,90], "c2":[30,30,80], "c3":[100,40,50]}, index=["i1","i2","i3"])
print df
print df.apply(lambda x:x.max() - x.min(), axis = 0) # 행간 계산
df["newC4"] = df.apply(lambda x:x.max() - x.min(), axis = 1) # 컬럼간 계산
print df
print df.apply(lambda x:x+1) # 행/컬럼 모두
Pandas Numpy 사용법
numpy : 배열 구조 및 연산
import numpy as np
난수를 통한 배열 생성
data = np.random.randn(2,3)
print(data)
print("-"*100) # ---------------------------
리스트를 통한 배열 생성
data1 = [6,7,5,8,0,1] print(data1) arr1 = np.array(data1) print(arr1)
2차원 리스트를 통한 배열 생성
data2 = [[1,2,3,4],[5,6,7,8]]
arr2 = np.array(data2)
print(arr2)
print("-"*100) # ---------------------------
array 구조 출력
print(arr2.shape)
0으로 채워진 배열 생성
print(np.zeros((2,3)))
순번으로 채워진 배열 생성
print(np.arange(15))
print("-"*100) # ---------------------------
다차원 배열 생성 및 계산
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr+arr)
print(arr*arr)
print("-"*100) # ---------------------------
n차 배열
-- 다차원 배열 생성 및 조회
arr2d = np.array([[11,12,13],[14,15,16],[17,18,19]])
print(arr2d)
print(arr2d[1])
print(arr2d[1][2])
print(arr2d[:2, 1:])
print("-"*100) # ---------------------------
불리언 색인(Boolean Index)
names = np.array(["Bob", "Joe", "Will", "Bob", "Will", "Joe", "Joe"]) data = np.random.randn(7,4) print(names) print(data)
조건에 맞는지 boolean 리턴
print(names == "Bob")
print("-"*100) # ---------------------------
두 배열을 조합한 조회
print(data[names=="Bob"]) # Bob이 있는 행
print(data[names=="Bob",0]) # Bob이 있는 행의 0번째 열
print("-"*100) # ---------------------------
배열의 OR 조건 Boolean 조회
mask = (names=="Bob") | (names=="Will") print(mask)
조건에 따라 배열 값 변경 조회
data[data<0] = 0
print(data)
data[names!="Joe"] = 7
print(data)
print("-"*100) # ---------------------------
피벗팅 및 배열 재조합
-- 피벗팅
arr = np.arange(15).reshape((3,5))
print(arr)
print(arr.T)
print("-"*100) # ---------------------------
-- 재조합
aaa = np.arange(16)
print aaa
arr = np.arange(16).reshape(2,2,4)
print(arr)
# -- 피벗팅
arr2 = arr.swapaxes(1,2)
print arr2
배열 조회 조건 및 집계
arr = np.random.randn(4,4)
print(arr)
print(np.where(arr>0,1,-1))
print(arr)
print("-"*100) # ---------------------------
# -- where를 이용한 조건 조회
print(np.where((0<arr) & (arr<10), 2, -2))
print(np.where(np.logical_and(arr>0, arr<10), 3, -3))
print(np.where((0<arr) & (arr<10), arr, -4))
print("-"*100) # ---------------------------
# -- 배열 집계
print(arr.mean())
print(np.mean(arr))
print(arr.sum())
print(arr.cumsum())
print(arr.min())
print(arr.max())
print("-"*100) # ---------------------------
정렬 및 중복제거
arr = np.random.randn(5,3)
print(arr)
# -- 정렬
arr.sort(1) # 행 단위로 정렬
print(arr)
# -- 중복제거
names = np.array(["Bob", "Joe", "Will", "Bob", "Will", "Joe", "Joe"])
print(np.unique(names)) # 중복제거
print(len(np.unique(names))) # 중복제거 개수
print(set(names)) # 뭐지?
print(np.unique(names)[1]) # 또 뭐더라?
print("-"*100) # ---------------------------
선형대수(행렬 연산)
x = np.array([[1,2,3],[4,5,6]])
y = np.array([[6,3],[-1,7],[8,9]])
print(x)
print(y)
# -- 행렬 곱하기?
print(x.dot(y)) # print(x*y)는 에러발생
print("-"*100) # ---------------------------
-- ?
from numpy.linalg import inv, qr
x = np.random.randn(5,5)
mat = x.T.dot(x)
print(inv(mat))
print(mat.dot(inv(mat)))
난수 생성
samples = np.random.normal(size =(3,4)) print(samples) samples = np.random.normal(size =(2,2)) print(samples) data = np.random.randn(2,2) print(data)
For 문을 사용한 List,Dictionary 출력
import pandas as pd
리스트의 index, value 출력
lst = ["AAA", "BBB", "", "DDD"]
for index in range(len(lst)):
print(index, lst[index])
print("... 리스트 index, value 출력[range(len()) 사용]", "." * 100, "\n")
for idx, val in enumerate(lst):
print(idx, val)
print("... 리스트 index, value 출력[enumerate() 사용]", "." * 100, "\n")
for index in lst:
print(index)
print("... 리스트 출력", "." * 100, "\n")
list-in-list에서의 중복제거
oldlist = [['a', 'b', 'a'], ['a', 'p', 'f', 'b'], ['b', 's', 'r']]
newlist = list()
for sublist in oldlist:
for list in sublist:
if list not in newlist:
newlist.append(list)
print(newlist)
print(",,, list in list 중복제거", "," * 100, "\n")
딕셔너리(Dirionary)의 key, value 출력
d = {"apple": 100, "orange": 200, "banana": 300}
for key, value in d.items():
print(key, value)
print(";;; 사전 key, value 출력[items() 사용]", ";" * 100, "\n")
데이터프레임의 index, value 출력
inp = [{'c1': 10, 'c2': 100}, {'c1': 11, 'c2': 110}, {'c1': 12, 'c2': 120}]
df = pd.DataFrame(inp)
print(df, '\n')
print("^^^ df 원본 출력", "^" * 100, "\n")
for idx, row in df.iterrows():
print("idx=", idx, " c1=", row['c1'], " c2=", row['c2']) # row[0] 형식 가능
print("^^^ DF index, column 출력[iterrows() 사용]", "^" * 100, "\n")
for idx in df.index:
print("idx=", idx)
print("^^^ DF index 출력[df.index 사용]", "^" * 100, "\n")
for row in range(0, len(df)):
print("row=", row)
DataFrame 비교
import pandas as pd
# 두 개의 DataFrame 생성
df1 = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': ['X', 'Y', 'Z', 'W'],
'C': [10, 20, 30, 40]
})
df2 = pd.DataFrame({
'A': [1, 2, 3, 5],
'B': ['X', 'Y', 'Z', 'V'],
'C': [10, 20, 30, 50]
})
# DataFrame 간 차이점 비교
diff_df1 = df1[~df1.isin(df2)].dropna()
diff_df2 = df2[~df2.isin(df1)].dropna()
print("df1과 df2의 차이점:\n", diff_df1)
print("df2과 df1의 차이점:\n", diff_df2)
~ 의 의미
- 파이썬에서 ~ 연산자는 bitwise NOT 연산자로, 값의 비트를 반전시키는 역할
- 하지만 pandas에서 ~는 **부정(NOT)**의 의미로 많이 사용
- 예를 들어, ~df.isin(df2)는 isin() 함수로 매칭되는 값을 제외하고, 즉 매칭되지 않는 값만 반환
예시:
# 두 DataFrame에서 차이점을 찾기 위해 사용 diff_df = df1[~df1.isin(df2)]
- df1에서 df2에 존재하지 않는 값만을 필터링하는 의미
- 따라서 ~는 조건을 반전시키는 용도로 자주 사용
데이터프레임을 딕셔너리로 변환 to_dict(orient="list")
- pandas의 to_dict(orient="list")는 DataFrame을 딕셔너리로 변환할 때, 각 열(column)을 리스트로 변환하는 것을 의미.
- orient 파라미터는 딕셔너리로 변환할 때, 어떻게 구조화할지를 지정
- orient="list"로 설정하면, 각 열의 값들이 리스트 형태로 변환되어, 딕셔너리의 값으로 들어감
예시:
import pandas as pd
# DataFrame 생성
df = pd.DataFrame({
'A': [1, 2, 3],
'B': ['a', 'b', 'c']
})
# to_dict(orient="list") 사용
result = df.to_dict(orient="list")
print(result)
출력 결과:
{
'A': [1, 2, 3],
'B': ['a', 'b', 'c']
}
- orient="list"는 DataFrame의 각 열이 리스트로 변환되어 딕셔너리의 값으로 들어감.
orient 파라미터의 다양한 값들
- pandas의 to_dict() 함수에서 orient 파라미터는 여러 가지 옵션을 제공하여 DataFrame을 다양한 방식으로 딕셔너리로 변환할 수 있음.
- 각 옵션은 변환된 딕셔너리의 구조를 다르게 만듬
- dict: 기본 방식 (열 이름을 기준으로 딕셔너리로 변환)
- list: 각 열을 리스트로 변환
- series: 각 열을 Series로 변환
- split: 인덱스, 열 이름, 데이터를 따로 리스트로 변환
- records: 각 행을 딕셔너리로 변환하여 리스트에 담음
- index: 인덱스를 기준으로 각 행을 딕셔너리로 변환
dict (기본값)
- 각 열의 이름이 딕셔너리의 키가 되고, 열의 값들이 또 다른 딕셔너리로 변환됩니다. 이 때, 행 인덱스가 내부 딕셔너리의 키로 사용됩니다.
df.to_dict(orient='dict')
결과:
{
'A': {0: 1, 1: 2, 2: 3},
'B': {0: 'a', 1: 'b', 2: 'c'}
}
list
- 각 열의 값들이 리스트로 변환되며, 열 이름이 키가 됩니다.
df.to_dict(orient='list')
결과:
{
'A': [1, 2, 3],
'B': ['a', 'b', 'c']
}
series:
- 각 열을 pandas.Series 객체로 변환하여 딕셔너리로 반환합니다.
df.to_dict(orient='series')
결과:
{
'A': pd.Series([1, 2, 3]),
'B': pd.Series(['a', 'b', 'c'])
}
split
- 딕셔너리는 세 부분으로 나뉩니다: 인덱스(index), 열 이름(columns), 그리고 데이터(data)가 각각 리스트로 변환됩니다.
df.to_dict(orient='split')
결과:
{
'index': [0, 1, 2],
'columns': ['A', 'B'],
'data': [[1, 'a'], [2, 'b'], [3, 'c']]
}
records
- 각 행이 하나의 딕셔너리로 변환되며, 그 딕셔너리들은 리스트 안에 담겨 반환됩니다.
df.to_dict(orient='records')
결과:
[
{'A': 1, 'B': 'a'},
{'A': 2, 'B': 'b'},
{'A': 3, 'B': 'c'}
]
index
- 행 인덱스를 기준으로 각 행을 딕셔너리로 변환하여 반환합니다. 열 이름이 내부 딕셔너리의 키가 됩니다.
df.to_dict(orient='index')
결과:
{
0: {'A': 1, 'B': 'a'},
1: {'A': 2, 'B': 'b'},
2: {'A': 3, 'B': 'c'}
}
DataFrame DB INSERT (ORACLE)
import pandas as pd
import cx_Oracle
-- Excel 파일읽기
df = pd.read_excel('D:\\MPAA\상장법인목록.xlsx', sheet_name='상장법인목록',usecols=[0, 1], dtype={0:str, 1:str})
-- 컬럼명 지정
df1 = df[['종목코드', '회사명']]
-- 데이터프레임을 튜플로 변경
rows = [tuple(x) for x in df1.to_records(index=False)]
-- 오라클 연결
con = cx_Oracle.connect('STOCK', '1234', 'ORCL')
cursor = con.cursor()
cursor.execute('DELETE FROM ITEM_CODE')
cursor.executemany("INSERT INTO ITEM_CODE (ITEM_CD, ITEM_NM) VALUES (:1, :2)", rows)
con.commit()
cursor.execute('SELECT COUNT(*) FROM ITEM_CODE')
cnt = cursor.fetchone()
print('Insert 건수: ', cnt)
DataFrame DB INSERT (mssql)
import pymssql
import pandas as pd
# ------------------------------
# -- Create Dataframe
# ------------------------------
df = pd.DataFrame({"a_key":[111,222,333], "b_sect":['a1','a2','a3',],
"c_mop":["aaaaa","bbbbb","ccccc"], "d_mop":["aaaaa","bbbbb","ccccc"],
"e_mop":["aaaaa","bbbbb","ccccc"], "f_mop":["aaaaa","bbbbb","ccccc"]})
print (df)
print ("... dataframe", "." * 100, "\n")
# ------------------------------
# -- Connection String
# ------------------------------
conn = pymssql.connect(host='hostname', user='user', password='password', database='db')
cur = conn.cursor()
# ------------------------------
# -- Create SQL
# ------------------------------
sql = "insert into mop.cn values(%d, %s, %s, %s, %s, %s);"
data = [tuple(x) for x in df.values]
print("sql:", sql)
print("data:", data)
print (",,, sql_statement", "," * 100, "\n")
# ------------------------------
# -- Execute SQL
# ------------------------------
cur.executemany(sql, data)
conn.commit()
DataFrame 결합
- 두 개의 pandas DataFrame을 합치는 방법에는 여러 가지가 있음
- 주로 concat, merge, join 함수를 사용 하고 각 방법은 목적에 따라 다르게 동작 햄.
concat() 함수
- 두 DataFrame을 행 또는 열 기준으로 단순히 이어 붙일 때 사용
import pandas as pd
# 두 개의 DataFrame 생성
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': ['X', 'Y', 'Z']
})
df2 = pd.DataFrame({
'A': [4, 5, 6],
'B': ['W', 'V', 'U']
})
# 행 기준으로 DataFrame 이어 붙이기
result = pd.concat([df1, df2], axis=0)
print(result)
출력:
A B
0 1 X
1 2 Y
2 3 Z
0 4 W
1 5 V
2 6 U
열 기준으로 이어 붙이기:
result = pd.concat([df1, df2], axis=1)
출력:
A B A B
0 1 X 4 W
1 2 Y 5 V
2 3 Z 6 U
merge() 함수
- merge() 함수는 두 DataFrame을 특정 열을 기준으로 병합할 때 사용
- SQL의 JOIN과 유사하게 작동
# 두 개의 DataFrame 생성
df1 = pd.DataFrame({
'key': ['A', 'B', 'C'],
'value1': [1, 2, 3]
})
df2 = pd.DataFrame({
'key': ['A', 'B', 'D'],
'value2': [4, 5, 6]
})
# key 열을 기준으로 병합
result = pd.merge(df1, df2, on='key', how='inner') # inner join
print(result)
출력:
key value1 value2
0 A 1 4
1 B 2 5
- how 옵션:
- inner: 교집합 (공통된 키에 대해서만 병합)
- outer: 합집합 (모든 데이터를 포함하고, 없는 값은 NaN으로 표시)
- left: 왼쪽 DataFrame 기준 병합
- right: 오른쪽 DataFrame 기준 병합
- outer join 예시:
result = pd.merge(df1, df2, on='key', how='outer') 출력: key value1 value2 0 A 1.0 4.0 1 B 2.0 5.0 2 C 3.0 NaN 3 D NaN 6.0
join() 함수
- join() 함수는 인덱스를 기준으로 두 DataFrame을 병합할 때 사용
- 기본적으로 왼쪽 기준으로 병합
# 인덱스를 기준으로 병합할 두 DataFrame 생성
df1 = pd.DataFrame({
'value1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({
'value2': [4, 5, 6]
}, index=['A', 'B', 'D'])
# 인덱스를 기준으로 병합
result = df1.join(df2, how='inner') # inner join
print(result)
출력:
value1 value2
A 1 4
B 2 5
outer join 예시:
result = df1.join(df2, how='outer')
출력:
value1 value2
A 1.0 4.0
B 2.0 5.0
C 3.0 NaN
D NaN 6.0
- 요약:
- concat(): 여러 DataFrame을 단순히 위아래 또는 좌우로 이어 붙일 때 사용.
- merge(): 특정 열을 기준으로 SQL JOIN 방식으로 병합할 때 사용.
- join(): 인덱스를 기준으로 DataFrame을 병합할 때 사용.