<jupyter_start><jupyter_text>Series 데이터 Pandas:파이썬 라이브러리, 구조화된데이터를 효과적으로 처리하고 저장,    array계산에 특화된 Numpy를 기반으로 설계 Series:numpy array가 보강된 형태, Data와 Index를 가지고 있음<jupyter_code>import pandas as pd

data = pd.Series([1, 2, 3, 4])
print(data)<jupyter_output>0    1
1    2
2    3
3    4
dtype: int64<jupyter_text>인덱스를 가지고 있고 인데긋로 접근 가능<jupyter_code>data = pd.Series([1,2,3,4], index=['a','b','c','d'])
print(data)
print(data['b'])<jupyter_output>a    1
b    2
c    3
d    4
dtype: int64
2<jupyter_text>name 인자로 이름을 지정할 수 있음<jupyter_code>data = pd.Series([1, 2, 3, 4], index=['a','b','c','d'], name="Title")
d_d= data['c'] = 5
print(d_d)
print(data)<jupyter_output>5
a    1
b    2
c    5
d    4
Name: Title, dtype: int64<jupyter_text>딕셔너리로 변환<jupyter_code>population_dict = {
    'korea': 5180,
    'japan':12718,
    'china':141500,
    'usa':32676
}

population = pd. Series(population_dict)
print(population)<jupyter_output>korea      5180
japan     12718
china    141500
usa       32676
dtype: int64<jupyter_text>DataFrame 여러개의 Series가 모여서 행과 열을 이룬 데이터<jupyter_code>gdp_dict={
    'korea': 169320000,
    'japan' : 516700000,
    'china' : 1409250000,
    'usa' : 2041280000
}
gdp = pd.Series(gdp_dict)
country = pd.DataFrame({
    'population':population,
    'gdp': gdp
})
print(country)
print(country.index)
print(country.columns)
print(country['gdp'])
print(type(country['gdp']))<jupyter_output>Index(['korea', 'japan', 'china', 'usa'], dtype='object')
Index(['population', 'gdp'], dtype='object')
korea     169320000
japan     516700000
china    1409250000
usa      2041280000
Name: gdp, dtype: int64
<class 'pandas.core.series.Series'><jupyter_text>Series도 numpy array 처럼 연산자를 활용<jupyter_code>gdp_per_capita = country['gdp']/country['population']
print(gdp_per_capita)
country['gdp per capita'] = gdp_per_capita
print(country)<jupyter_output>korea    32687.258687
japan    40627.457147
china     9959.363958
usa      62470.314604
dtype: float64
       population         gdp  gdp per capita
korea        5180   169320000    32687.258687
japan       12718   516700000    40627.457147
china      141500  1409250000     9959.363958
usa         32676  2041280000    62470.314604<jupyter_text>저장과 불러오기 데이터 프레임을 저장<jupyter_code>country.to_csv("./country.csv")

country = pd.read_csv("./country.csv")
print(country)<jupyter_output>Unnamed: 0  population         gdp  gdp per capita
0      korea        5180   169320000    32687.258687
1      japan       12718   516700000    40627.457147
2      china      141500  1409250000     9959.363958
3        usa       32676  2041280000    62470.314604<jupyter_text>indexing/slicing .loc:명시적인 인덱스를 참조하는 인덱싱/슬라이싱<jupyter_code>country.loc['china']

country.loc['japan':'korea', :'population']<jupyter_output><empty_output><jupyter_text>Indexing/Slicing .iloc: 파이썬 스타일 정수 인덱스 인덱싱/슬라이싱<jupyter_code>country.iloc[0]
country.iloc[1:3, :2]
country.iloc[: , :]<jupyter_output><empty_output><jupyter_text>DataFrame 새 데이터 추가/ 수정 리스트로 추가 or 딕셔너리로 추가<jupyter_code>dataframe = pd.DataFrame(columns=['이름','나이','주소'])
print(dataframe)
dataframe.loc[0]=['임원균', '26', '서울']
dataframe.loc[1]={'이름':'철수', '나이':'25', '주소':'인천'}
dataframe.loc[1,'이름'] = '영희'
print(dataframe)<jupyter_output>이름  나이  주소
0  임원균  26  서울
1   영희  25  인천<jupyter_text>새로운 컬럼 추가<jupyter_code>dataframe['전화번호'] = np.nan
print(dataframe)
print()
dataframe.loc[0, '전화번호'] = '01012341234'
print(dataframe)
len(dataframe)<jupyter_output>이름  나이  주소  전화번호
0  임원균  26  서울   NaN
1   영희  25  인천   NaN

    이름  나이  주소         전화번호
0  임원균  26  서울  01012341234
1   영희  25  인천          NaN<jupyter_text>컬럼 선택하기 컬럼 이름이 하나만 있다면 Series, 리스트로 들어가 있다면 DataFrame<jupyter_code>dataframe["이름"]

dataframe[["이름","주소","나이"]]<jupyter_output><empty_output><jupyter_text>누락된 데이터 체크 튜토리얼의 데이터와 다르게 현실 데이터는 일부 누락되어 있는 형태가 많음<jupyter_code>dataframe.isnull()
dataframe.notnull()
dataframe.dropna()
dataframe['전화번호'] = dataframe['전화번호'].fillna('전화번호 없음')
dataframe<jupyter_output><empty_output><jupyter_text>Series 연산 numpy array에서 사용했던 Series 연산자들을 동일하게 활용할 수 있음<jupyter_code>A = pd.Series([2,4,6], index=[0,1,2])
B = pd.Series([1,3,5], index=[1,2,3])
print(A)
print()
print(B)
print()
print(A+B)
A.add(B, fill_value=0)<jupyter_output><empty_output><jupyter_text>DataFrame 연산 add(+), sub(-), mul(*), div(/)<jupyter_code>A = pd.DataFrame(np.random.randint(0, 10, (2,2)), columns=list("AB"))
print(A)
print()
B = pd.DataFrame(np.random.randint(0, 10, (3,3)), columns=list("BAC"))
print(B)
print()

print(A+B)
print()

print(A.add(B, fill_value=0))<jupyter_output>A  B
0  7  1
1  5  4

   B  A  C
0  3  7  1
1  1  6  7
2  9  5  3

      A    B   C
0  14.0  4.0 NaN
1  11.0  5.0 NaN
2   NaN  NaN NaN

      A    B    C
0  14.0  4.0  1.0
1  11.0  5.0  7.0
2   5.0  9.0  3.0<jupyter_text>집계함수 numpy array에서 사용했던 sum, mean 등의 집계함수를 동일하게 사용할 수 있음<jupyter_code>data = {
    'A':[i+5 for i in range(3)],
    'B':[i**2 for i in range(3)]
}
df = pd.DataFrame(data)
print(df)
print()
print(df['A'].sum())
print(df.sum())
print(df.mean())<jupyter_output>A  B
0  5  0
1  6  1
2  7  4

18
A    18
B     5
dtype: int64
A    6.000000
B    1.666667
dtype: float64<jupyter_text>Dataframe 정렬하기 값으로 정렬하기sort_values()<jupyter_code>df = pd.DataFrame({
    'col1' : [2,1,9,8,7,4],
    'col2' : ['A', 'A', 'B', np.nan, 'D', 'C'],
    'col3' : [0, 1, 9, 4, 2, 3]
})
print(df)
df.sort_values('col1')
df.sort_values('col1', ascending=False) #ascending을 쓰니 역순으로나옴
df.sort_values(['col2','col1'])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14867094408799267, 'fraction_numerical': 0.10889092575618699, 'mean_word_length': 4.094304388422035, 'pattern_counts': {'":': 0, '<': 59, '<?xml version=': 0, '>': 59, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '17', 'dir': 'jupyter-structured-clean-dedup', 'id': '625375', 'license': 'Apache-2.0', 'n_tokens_mistral': 3079, 'n_tokens_neox': 3078, 'n_words': 515, 'path': 'pandas/Pandas_example.ipynb', 'repo_name': 'risker93/king', 'size': '5455'}