🐷전동준(Jeon DongJun)

Go with the flow

[Pandas]내가 보려고 올린 Pandas 정리1

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!


Pandas

  • Python Data Analysis Library
  • 데이터 분석 및 가공을 위한 파이썬 라이브러리
  • series, DataFrame 등의 자료구조를 활용
  • R의 데이터프레임을 모방
  • 데이터를 수정하고 목적에 맞게 변경시키기 위해 사용
  • 데이터 프레임은 엑셀과 유사
  • Numpy를 사용하고 있어 계산이 빠름
  • 라이브러리 구성
    • 여러종류의 클래스와 다양한 함수로 구성
    • 시리즈와 데이터 프레임의 자료 구조 제공
    • 시리즈(1차원 배열), 데이터프레임(2차원 배열)
  • https://pandas.pydata.org/

판다스의 목적

  • 서로 다른 유형의 데이터를 공통된 포맷으로 정리하는 것
  • 행과 열로 이루어진 2차원 데이터프레임을 처리 할 수 있는 함수제공 목적
  • 실무 사용 형태 : 데이터 프레임
# pandas 모듈 import
# 대부분의 코드에서 pandas를 pd 라는 별칭으로 사용
import pandas as pd
import numpy as np

pd.__version__

'1.1.3'

pandas의 데이터 구조

  1. Series 데이터
    벡터처럼 되어있는 1차원적인 구조
  2. 데이터 프레임
    행과 열을 갖고 있는 테이블(Matrix)적, 2차원적 구조

image

출처 : https://www.kdnuggets.com/2017/01/pandas-cheat-sheet.html

1. Series 데이터

Series

  • pandas의 기본 객체 중 하나
  • numpy의 ndarray를 기반으로 인덱싱 기능을 추가하여 1차원 배열을 나타냄
  • index를 지정하지 않을 시, 기본적으로 ndarray와 같이 0-based 인덱스 생성, 지정할 경우 명시적으로 지정된 index를 사용
  • 같은 타입의 0개 이상의 데이터를 가질 수 있음
  1. 자료구조 : 시리즈
    • 데이터가 순차적으로 나열된 1차원 배열 형태
    • 인덱스(index)와 데이터 값(value)이 일대일로 대응
    • 딕셔너리와 비슷한 구조 : {key(index):value}
  2. 시리즈의 인덱스
    • 데이터 값의 위치를 나타내는 이름표 역할
  3. 시리즈 생성: 판다스 내장함수인 Series()이용
    • 리스트로 시리즈 만들기
    • 딕셔너리로 시리즈 만들기
    • 튜플로 시리즈 만들기

Series 생성하기

pd.Series(seq_data) 함수 이용

* seq_data : 리스트, 딕셔너리, 튜플 타입 데이터

1) seq_data 를 이용하여 Series 생성하기

: index는 기본적으로 0부터 자동적으로 생성

  • 리스트로 시리즈 만들기
# pd.Series
s = pd.Series([1,2,3])
s

0    1
1    2
2    3
dtype: int64

# 정수값을 갖은 리스트로 시리즈 생성
s1 = pd.Series(np.arange(10,60,10))
s1

0    10
1    20
2    30
3    40
4    50
dtype: int32

# 문자열을 갖은 리스트로 시리즈 생성
s2 = pd.Series(['A', 'B', 'C'])
s2

0    A
1    B
2    C
dtype: object

# 문자열을 갖은 리스트로 시리즈 생성2
s2 = pd.Series('A B C'.split()) # 스플릿 사용
s2

0    A
1    B
2    C
dtype: object
  • 범위를 시리즈의 value 생성하는데 사용하기
    • range()/np.arange() 함수 사용
# range()를 이용하여 정수범위 자료를 시리즈로 생성
s3 = pd.Series(range(10, 14))
s3

0    10
1    11
2    12
3    13
dtype: int64

# arange()를 이용하여 정수범위 자료를 시리즈로 생성
s4 = pd.Series(np.arange(5))
s4

0    0
1    1
2    2
3    3
4    4
dtype: int32
  • 결측값을 포함해서 시리즈 만들기
    • 결측값 NaN - numpy 라는 모듈에서 생성할 수 있음
    • 결측값 생성 위해서는 numpy 모듈 import
### pandas와 numpy 패키지는 import 해서 사용
# import numpy as np

s = pd.Series([1,2,3,np.nan,6,8])
s

# 인덱스 : 0부터 시작하는 정수값

0    1.0
1    2.0
2    3.0
3    NaN
4    6.0
5    8.0
dtype: float64

2) 인덱스 명시해서 시리즈 만들기

  • 숫자 인덱스 지정
    • s = pd.Series([값1,값2,값3,…], index=[1,2,3,…])
# 숫자 인덱스 지정
s1 = pd.Series([10,20,30], index=[1,2,3])
s1

1    10
2    20
3    30
dtype: int64
  • 문자 인덱스 지정
# 문자 인덱스 지정
s2 = pd.Series([95,100,88], index=['홍길동','이몽룡','성춘향'])
s2

홍길동     95
이몽룡    100
성춘향     88
dtype: int64

3) 인덱스 활용

  • 시리즈의 index
    • 시리즈의 index는 index 속성으로 접근 : 시리즈index
# 시리즈.index
s1.index

Int64Index([1, 2, 3], dtype='int64')

s2.index

Index(['홍길동', '이몽룡', '성춘향'], dtype='object')

s = pd.Series([9904312, 3448737, 289045, 2466052],
             index = ['서울', '부산', '인천', '대구'])
s.index

# dtype = 'object' : datatype = '문자열객체'

Index(['서울', '부산', '인천', '대구'], dtype='object')
  • 시리즈.index.name 속성
    • 시리즈의 인덱스에 이름을 붙일 수 있음
print(s.index.name)
s # None

None





서울    9904312
부산    3448737
인천     289045
대구    2466052
dtype: int64

s.index.name = '도시' 
s # 도시라는 index 제목이 생김

도시
서울    9904312
부산    3448737
인천     289045
대구    2466052
dtype: int64

4) 시리즈의 값

  • numpy 자료 구조 : 1차원 배열
  • values 속성으로 접근 : 시리즈.values
# 시리즈 값
s.values

array([9904312, 3448737,  289045, 2466052], dtype=int64)

5) 시리즈.name 속성

  • 시리즈 데이터에 이름을 붙일 수 있음
  • name 속성은 값의 의미 전달에 사용
# 시리즈의 name 속성 출력
print(s.name)

None

# 시리즈 name 속셩 변경
s.name = '인구수'
s # Name에 인구수가 생김

도시
서울    9904312
부산    3448737
인천     289045
대구    2466052
Name: 인구수, dtype: int64

시리즈 인덱싱(indexing)

  • 인덱싱 : 데이터에서 특정한 데이터를 골라내는 것

시리즈의 인덱싱 종류

  1. 정수형 위치 인덱스(integer position)
  2. 인덱스 이름(index name) 또는 인덱스 라벨(index label)
    • 인덱스 별도 지정하지 않으면 0부터 시작하는 정수형 인덱스가 지정됨

원소접근

  • 정수형 인덱스 : 숫자 s[0]
  • 문자형 인덱스 : 문자 s[‘인천’] , s.인천
# 정수형 인덱스 접근
print(s.index)
s[0]

Index(['서울', '부산', '인천', '대구'], dtype='object', name='도시')





9904312

# 문자형 인덱스 접근
s['서울']

9904312

# 한 줄에 위치 인덱스와 문자 인덱스를 동시에 접근
s[2], s['인천']

(289045, 289045)

리스트 이용 인덱싱

  • 자료의 순서를 바꾸거나 특정자료 여러개를 선택할 수 있다.
  • 인덱스값 여러 개를 이용해 접근시 []안에 넣는다.
# 여러 개 접근
s[[1,2]]

도시
부산    3448737
인천     289045
Name: 인구수, dtype: int64

s[['서울','대구']]

도시
서울    9904312
대구    2466052
Name: 인구수, dtype: int64

문자 인덱스를 이용한 인덱싱

  • [.]연산자를 이용하여 접근가능 : 객체명.문자인덱스명
# 인덱스를 문자값으로 지정한 시리즈
s.서울

9904312

# s1의 인덱스가 a,b,c
s1 = pd.Series(range(3), index=['a','b','c'])
s1

a    0
b    1
c    2
dtype: int64

s1.a, s1.b, s1.c # 각 인덱스에 해당하는 value들이 나온다.

(0, 1, 2)

시리즈 슬라이싱(slicing)

  • 정수형 위치 인덱스를 사용한 슬라이싱
    • 시리즈[start : stop+1]
  • 문자(라벨)인덱스 이용 슬라이싱
    • 시리즈[‘시작라벨’:’끝라벨’] : 표시된 라벨 범위 모두 추출
# 값 2개 추출 - [1,2]
s[1:3]

도시
부산    3448737
인천     289045
Name: 인구수, dtype: int64

# 문자 인덱스를 이용한 슬라이싱
# 2~4번째 값 (3개값)

s['부산':'대구']

도시
부산    3448737
인천     289045
대구    2466052
Name: 인구수, dtype: int64

인덱스 통한 시리즈 데이터 업데이트

s

도시
서울    9904312
부산    3448737
인천     289045
대구    2466052
Name: 인구수, dtype: int64

# '서울' 데이터 변경
s.서울 = 10000000
# s['서울'] = 10000000
# s[0] = 10000000
s

도시
서울    10000000
부산     3448737
인천      289045
대구     2466052
Name: 인구수, dtype: int64

인덱스 재사용

s1 = pd.Series(np.arange(4), s.index) 
# value를 새로 적고 s의 인덱스를 불러옴
s1

도시
서울    0
부산    1
인천    2
대구    3
dtype: int32

시리즈 연산

벡터화 연산

  • numpy 배열처럼 pandas의 시리즈도 벡터화 연산 가능
  • 벡터화 연산이란 집합적 자료형의 원소 각각을 독립적으로 계산을 진행하는 방법
    • 단, 연산은 시리즈의 값에만 적용되며 인덱스 값은 변경 불가
# 시리즈와 스칼라의 합
pd.Series([1,2,3]) + 4

0    5
1    6
2    7
dtype: int64

# s시리즈의 값을 1/1000000로 변경
s/1000000

# s 시리즈의 모든 value에 대하여 각각 연산을 진행
# 실수형으로 반환

도시
서울    10.000000
부산     3.448737
인천     0.289045
대구     2.466052
Name: 인구수, dtype: float64

벡터화 인덱싱 : Boolean selection

  • boolean Series 가 []와 함께 사용되면 True 값에 해당하는 값만 새로 반환되는 Series 객체에 포함됨
  • 다중조건의 경우, &(and), (or)를 사용하여 연결 가능 
# 벡터화 인덱싱
# s 시리즈 값 중 2500000 보다 크고 5000000 보다 작은 원소를 추출
# 각 원소의 값 모두 각각 조건식을 확인 하여 결과가 True인 원소만 추출
s[(s > 2500000) & (s < 5000000)] # 반드시 ()해야함
# (s > 25e05) & (s < 50e05) : 데이터의 수가 너무 큰경우 이렇게 줄일 수 있다.

도시
부산    3448737
Name: 인구수, dtype: int64

s0 = pd.Series(np.arange(10), np.arange(10)+1)
s0

1     0
2     1
3     2
4     3
5     4
6     5
7     6
8     7
9     8
10    9
dtype: int32

# 5보다 큰가?
s0 > 5

1     False
2     False
3     False
4     False
5     False
6     False
7      True
8      True
9      True
10     True
dtype: bool

# 5보다 큰 요소 추출
s0[s0>5]

7     6
8     7
9     8
10    9
dtype: int32

# 짝수 추출
s0[(s0 % 2 == 0) & (s0 != 0)]

3    2
5    4
7    6
9    8
dtype: int32

s0

1     0
2     1
3     2
4     3
5     4
6     5
7     6
8     7
9     8
10    9
dtype: int32

# 인덱스가 5보다 큰가?
s0.index > 5

array([False, False, False, False, False,  True,  True,  True,  True,
        True])

# 인덱스가 5이상인 요소 추출
s0[s0.index>=5]

5     4
6     5
7     6
8     7
9     8
10    9
dtype: int32

# 값이 5보다 크고 8보다 작은 요소 추출
s0[(s0 > 5) & (s0 < 8)]

7    6
8    7
dtype: int32

# 값이 7이상인 수들의 합
s0[s0 >= 7].sum()

24

# 값이 7 이상인 값들의 개수(True값들의 개수)
(s0 >= 7).sum()

3

두 시리즈간의 연산

num_s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
num_s1

a    1
b    2
c    3
d    4
dtype: int64

num_s2 = pd.Series([5,6,7,8], index=['b','c','d','a'])
num_s2

b    5
c    6
d    7
a    8
dtype: int64
  • 시리즈간의 연산은 같은 인덱스를 찾아 연산을 진행

  • 동일한 인덱스는 연산을 진행하고 나머지 인덱스는 연산처리가 불가해 NaN값 처리

  • 시리즈 + 시리즈
    • 같은 인덱스를 찾아 + 연산을 진행
# 두 시리즈에 대한 + 연산
num_s1 + num_s2

a     9
b     7
c     9
d    11
dtype: int64
  • 시리즈 + 시리즈
    • 동일한 인덱스는 연산을 진행하고 나머지 인덱스는 연산처리가 불가해 NaN값 처리
num_s3 = pd.Series([5,6,7,8], index=['e','b','f','g'])
num_s4 = pd.Series([1,2,3,4], index=['a','b','c','d'])

# 두 시리즈의 + 연산
num_s3 + num_s4 # 겹치는 인덱스인 b만 + 연산이 된 것을 확인

a    NaN
b    8.0
c    NaN
d    NaN
e    NaN
f    NaN
g    NaN
dtype: float64
  • 시리즈 - 시리즈
# 두 시리즈의 -연산
num_s3  - num_s4

a    NaN
b    4.0
c    NaN
d    NaN
e    NaN
f    NaN
g    NaN
dtype: float64
  • 시리즈의 values 속성을 이용한 연산
    • values 속성을 사용하면 시리즈의 형태가 사라지므로 동일 위치 원소들끼리 연산
    • 시리즈.values 는 array 형태 반환
#  두 시리즈 values 들 간의 - 연산
num_s3.values - num_s4.values

array([4, 4, 4, 4], dtype=int64)

in 연산자/for 반복문 사용

  • 시리즈 객체는 라벨(문자)에 의해 인덱싱이 가능
  • 실질적으로는 라벨을 key로 가지는 딕셔너리 형과 같다고 볼 수 있음
  • 딕셔너리에서 제공하는 대부분의 연산자 사용 가능
    • in 연산자 : T / F
    • for 루프를 통해 각 원소의 key와 value에 접근
s

도시
서울    10000000
부산     3448737
인천      289045
대구     2466052
Name: 인구수, dtype: int64

# 인덱스가 서울인 원소가 시리즈에 있는지
'서울' in s

True

# 인덱스가 대전인 원소가 시리즈에 있는지
'대전' in s

False

# 인덱스가 대전인 원소가 시리즈에 없는지
'대전' not in s

True

# 딕셔너리의 items()과 같은 함수가 시리즈에도 있음
s.items() # zip 객체

<zip at 0x23007690f00>

# list로 변환 후 확인
list(s.items())

[('서울', 10000000), ('부산', 3448737), ('인천', 289045), ('대구', 2466052)]

# 시리즈 각 원소 출력
for k, v in s.items():
    print(f'{k}={v}')

서울=10000000
부산=3448737
인천=289045
대구=2466052

딕셔너리로 시리즈 만들기

  • Series({key1:value1, key2:value2, key3:value3, …})
    • 인덱스 -> key
    • 값 -> value
scores = {'홍길동':96, '이몽룡':100, '성춘향':88}
s = pd.Series(scores)
s

홍길동     96
이몽룡    100
성춘향     88
dtype: int64

city = {'서울':9631482, '부산':3393191, '인천':2632035, '대전':1490158}
s = pd.Series(city)
s

서울    9631482
부산    3393191
인천    2632035
대전    1490158
dtype: int64

딕셔너리 기반으로 생성한 시리즈 인덱스 설정

  • 딕셔너리의 원소는 순서를 갖지 않는다.
    • 딕셔너리로 생성된 시리즈의 원소도 순서가 보장되지 않는다.
    • 만약 순서를 보장하고 싶으면 인덱스를 리스트로 지정해야 한다.
# 딕셔너리 기반으로 생성한 시리즈 인덱스 설정
s = pd.Series(city, index = ['부산','인천','서울','대전'])
s

부산    3393191
인천    2632035
서울    9631482
대전    1490158
dtype: int64

시리즈 데이터의 갱신, 추가, 삭제

  • 인덱싱을 이용하면 딕셔너리 처럼 갱신, 추가 가능
s

부산    3393191
인천    2632035
서울    9631482
대전    1490158
dtype: int64
  • 시리즈 데이터 갱신
# s2 시리즈의 부산 인구 값을 1630000으로 변경
s.부산 = 1630000
s

부산    1630000
인천    2632035
서울    9631482
대전    1490158
dtype: int64
  • 시리즈 데이터 삭제
# 데이터를 삭제할 때도 딕셔너리처럼 del 명령을 사용
del s['부산']
s

인천    2632035
서울    9631482
대전    1490158
dtype: int64
  • 시리즈 데이터 추가
# 시리즈에 새로운 값 추가
s['대구'] = 1875000
s

인천    2632035
서울    9631482
대전    1490158
대구    1875000
dtype: int64

Series 함수

Series size, shape, unique, count, value_counts 함수

  • size : 시리즈 원소 개수 반환
  • shape : 튜플 형태로 shape 반환
  • unique() : 유일한 값만 ndarray로 반환
  • count() : NaN을 제외한 개수를 반환
  • mean() : NaN을 제외한 평균
  • value_counts() : NaN을 제외하고 각 값들의 빈도를 반환
s1 = pd.Series([1, 1, 2, 1, 2, 2, 2, 1, 1, 3, 3, 4, 5, 5, 7, np.NaN])
s1

0     1.0
1     1.0
2     2.0
3     1.0
4     2.0
5     2.0
6     2.0
7     1.0
8     1.0
9     3.0
10    3.0
11    4.0
12    5.0
13    5.0
14    7.0
15    NaN
dtype: float64
  • 시리즈 원소 크기
s1.size

16

len(s1)

16

s1.shape
# 결과가 튜플형태로 (차원, )

(16,)
  • unique() : 시리즈의 유일한 값 반환
s1.unique()

array([ 1.,  2.,  3.,  4.,  5.,  7., nan])
  • count() : NaN을 제외한 개수를 반환
s1.count()

15
  • mean() : 데이터의 평균(결측치 제외)
s1.mean()

2.6666666666666665

# numpy의 1차원 데이터 생성하고 평균을 계산
a = np.array([2, 2, 2, 2, np.NaN])
a.mean() # 결측치를 포함해버림

nan

# 시리즈의 경우 평균은 NaN을 제외하고 계산
b = pd.Series(a) # numpy array 데이터를 시리즈로 변경
b.mean() # NaN 빼고 계산

2.0
  • value_counts() : 그룹핑 된 원소별 개수
# 각 원소들 그룹핑하여 개수를 셈(빈도계산)
s1.value_counts()

1.0    5
2.0    4
5.0    2
3.0    2
7.0    1
4.0    1
dtype: int64

날짜 인덱스를 이용하여 시리즈 생성

# 날짜 인덱스를 이용하여 시리즈 만들기
# 날자 표시 : '년-월-일' 형태의 문자열로 표시

index_date = ['2021-10-07', '2021-10-08', '2021-10-09', '2021-10-10']

s = pd.Series([200,195, np.nan, 205], index=index_date )
s

2021-10-07    200.0
2021-10-08    195.0
2021-10-09      NaN
2021-10-10    205.0
dtype: float64

type(s.index[0]) # 문자열 형태

str

날짜 생성 함수 : date_range()

  • 판다스 패키지의 date_range 함수 (날짜생성)
  • pd.date_range(start=None, end=None, periods=None, freq=’D’)
    • start : 시작 날짜
    • end : 끝 날짜
    • periods : 날짜 생성기간
    • freq : 날짜 생성 주기, 기본값은 ‘D’(Days)
    • start는 필수 옵션/end 나 periods는 둘 중 하나가 있어야 함

freq 옵션

image

  • 일별 간격으로 날짜 생성
# dtype = 'datetime64[ns] 데이트 타입 형태로 생성

date = pd.date_range(start='2021-10-01', end='2021-10-20')
date
# default로 D(일) 기준으로 생성된다.(freq='D')

DatetimeIndex(['2021-10-01', '2021-10-02', '2021-10-03', '2021-10-04',
               '2021-10-05', '2021-10-06', '2021-10-07', '2021-10-08',
               '2021-10-09', '2021-10-10', '2021-10-11', '2021-10-12',
               '2021-10-13', '2021-10-14', '2021-10-15', '2021-10-16',
               '2021-10-17', '2021-10-18', '2021-10-19', '2021-10-20'],
              dtype='datetime64[ns]', freq='D')

type(date)

pandas.core.indexes.datetimes.DatetimeIndex

# 하루 주기로 '2022-01-07'에서 '2022-01-31' 사이의 일자 생성
pd.date_range(start='2022-01-07', end='2022-01-31', freq='D')

DatetimeIndex(['2022-01-07', '2022-01-08', '2022-01-09', '2022-01-10',
               '2022-01-11', '2022-01-12', '2022-01-13', '2022-01-14',
               '2022-01-15', '2022-01-16', '2022-01-17', '2022-01-18',
               '2022-01-19', '2022-01-20', '2022-01-21', '2022-01-22',
               '2022-01-23', '2022-01-24', '2022-01-25', '2022-01-26',
               '2022-01-27', '2022-01-28', '2022-01-29', '2022-01-30',
               '2022-01-31'],
              dtype='datetime64[ns]', freq='D')
  • 3일 간격의 날짜 생성
# '2022-01-07'에서 '2022-01-31' 사이의 3일 간격의 일자 생성
pd.date_range(start='2022-01-07', end='2022-01-31', freq='3D')

DatetimeIndex(['2022-01-07', '2022-01-10', '2022-01-13', '2022-01-16',
               '2022-01-19', '2022-01-22', '2022-01-25', '2022-01-28',
               '2022-01-31'],
              dtype='datetime64[ns]', freq='3D')
  • 주간격으로 날짜 생성
    • 지정한 일자가 포함된 주의 요일 시작 일자 기준으로 일주일 주기로 생성
    • freq=’W’ : 일요일 기준으로 일주일 주기로 생성
    • freq=’W-MON’ : 월요일 기준으로 일주일 주기로 생성
# 2022-01-07을 기준으로 1주일씩 증가하는 4개의 1주 시작일(일요일)
# '2022-01-07'은 금요일

pd.date_range(start='2022-01-07', periods=4, freq='W')

DatetimeIndex(['2022-01-09', '2022-01-16', '2022-01-23', '2022-01-30'], dtype='datetime64[ns]', freq='W-SUN')

# 2022-01-07을 기준으로 1주일씩 증가하는 4개의 1주 시작일(일요일)
# '2022-01-07'은 금요일

pd.date_range(start='2022-01-07', periods=4, freq='W-SUN')

DatetimeIndex(['2022-01-09', '2022-01-16', '2022-01-23', '2022-01-30'], dtype='datetime64[ns]', freq='W-SUN')

# 2022-01-07을 기준으로 1주일씩 증가하는 4개의 1주 시작일(월요일)
# '2022-01-07'은 금요일

pd.date_range(start='2022-01-07', periods = 4, freq='W-MON')
# periods 로 월요일 4개 생성

DatetimeIndex(['2022-01-10', '2022-01-17', '2022-01-24', '2022-01-31'], dtype='datetime64[ns]', freq='W-MON')

# 2022-01-07을 기준으로 1주일씩 증가하는 4개의 1주 시작일(금요일)
# '2022-01-07'은 금요일

pd.date_range(start='2022-01-07', periods=4, freq='W-FRI')

DatetimeIndex(['2022-01-07', '2022-01-14', '2022-01-21', '2022-01-28'], dtype='datetime64[ns]', freq='W-FRI')
  • 월 간격으로 날짜 생성
    • freq=’M’ : 월말 날짜 기준 주기
    • freq=’BM’ : 업무 월말 날짜 기준 주기
    • freq=’MS’ : 월초 날짜 기준 주기
# 2022-01-07 기준으로 한 달 간격의 일자 4개 생성 : 월말 기준
pd.date_range(start='2022-01-07', periods = 4, freq='M')

DatetimeIndex(['2022-01-31', '2022-02-28', '2022-03-31', '2022-04-30'], dtype='datetime64[ns]', freq='M')

# 2022-01-07 기준으로 한 달 간격의 일자 4개 생성 : 월초 기준
pd.date_range(start='2022-01-07', periods = 4, freq='MS')

DatetimeIndex(['2022-02-01', '2022-03-01', '2022-04-01', '2022-05-01'], dtype='datetime64[ns]', freq='MS')

# 2022-01-07 기준으로 한 달 간격의 일자 4개 생성 : 업무 월말 기준
pd.date_range(start='2022-01-07', periods = 4, freq='BM')

DatetimeIndex(['2022-01-31', '2022-02-28', '2022-03-31', '2022-04-29'], dtype='datetime64[ns]', freq='BM')

# 2022-01-07 기준으로 세 달 간격의 일자 4개 생성 : 월말 기준
pd.date_range(start='2022-01-07', periods = 4, freq='3M')

DatetimeIndex(['2022-01-31', '2022-04-30', '2022-07-31', '2022-10-31'], dtype='datetime64[ns]', freq='3M')

# 2개월 월초주기로 12개의 월말 날짜 생성
pd.date_range(start='2022-01-07', periods = 12, freq='2MS')

DatetimeIndex(['2022-02-01', '2022-04-01', '2022-06-01', '2022-08-01',
               '2022-10-01', '2022-12-01', '2023-02-01', '2023-04-01',
               '2023-06-01', '2023-08-01', '2023-10-01', '2023-12-01'],
              dtype='datetime64[ns]', freq='2MS')
  • 분기별 주기로 날짜 생성
    • freq = Q : 분기 끝 날짜 기준 주기
    • freq = BQ : 업무 분기 끝 날짜 기준 주기
    • freq = QS : 분기 시작 날짜 기준 주기
# 2022-01-07 기준으로 분기 간격의 일자 4개 생성 : 분기 끝 날짜 기준
pd.date_range(start='2022-01-07', periods = 4, freq='Q')

DatetimeIndex(['2022-03-31', '2022-06-30', '2022-09-30', '2022-12-31'], dtype='datetime64[ns]', freq='Q-DEC')

# 2022-01-07 기준으로 업무 분기 간격의 일자 4개 생성 : 업무 분기 끝 날짜 기준
pd.date_range(start='2022-01-07', periods = 4, freq='BQ')

DatetimeIndex(['2022-03-31', '2022-06-30', '2022-09-30', '2022-12-30'], dtype='datetime64[ns]', freq='BQ-DEC')

# 2022-01-07 기준으로 분기 간격의 일자 4개 생성 : 분기 시작 날짜 기준
pd.date_range(start='2022-01-07', periods = 4, freq='QS')

DatetimeIndex(['2022-04-01', '2022-07-01', '2022-10-01', '2023-01-01'], dtype='datetime64[ns]', freq='QS-JAN')
  • 연별 주기로 날짜 생성
    • freq = A : 일년 끝 날짜 기준 주기
    • freq = BA : 업무 일년 끝 날짜 기준 주기
    • freq = AS : 일년 시작 날짜 기준 주기
# 2022-01-07일 이후 부터 일년 끝 날짜기준으로 4개의 날짜 생성
pd.date_range(start='2022-01-07', periods=4, freq='A')

DatetimeIndex(['2022-12-31', '2023-12-31', '2024-12-31', '2025-12-31'], dtype='datetime64[ns]', freq='A-DEC')

# 2022-01-07일 이후 부터 업무 일년 끝 날짜기준으로 4개의 날짜 생성
pd.date_range(start='2022-01-07', periods=4, freq='BA')

DatetimeIndex(['2022-12-30', '2023-12-29', '2024-12-31', '2025-12-31'], dtype='datetime64[ns]', freq='BA-DEC')

# 2022-01-07일 이후 부터 연초 기준으로 4개의 날짜 생성
pd.date_range(start='2022-01-07', periods=4, freq='AS')

DatetimeIndex(['2021-01-01', '2022-01-01', '2023-01-01', '2024-01-01'], dtype='datetime64[ns]', freq='AS-JAN')
  • 시간 기준 주기로 날짜 생성
    • freq = H : 시간 주기
    • freq = BH : 업무 시간 주기
    • freq = T 또는 min : 분 주기
    • freq = S : 초 주기
# 2022-01-07일 08:00 부터 시간 기준으로 10개의 날짜 생성

pd.date_range(start='2022-01-07 08:00', periods=10, freq='H')

DatetimeIndex(['2022-01-07 08:00:00', '2022-01-07 09:00:00',
               '2022-01-07 10:00:00', '2022-01-07 11:00:00',
               '2022-01-07 12:00:00', '2022-01-07 13:00:00',
               '2022-01-07 14:00:00', '2022-01-07 15:00:00',
               '2022-01-07 16:00:00', '2022-01-07 17:00:00'],
              dtype='datetime64[ns]', freq='H')

# 2022-01-07일 08:00 부터 업무시간 기준으로 10개의 날짜 생성
# 업무시간기준 9 to 5로 설정되어 있음

pd.date_range(start='2022-01-07 08:00', periods=10, freq='BH')

DatetimeIndex(['2022-01-07 09:00:00', '2022-01-07 10:00:00',
               '2022-01-07 11:00:00', '2022-01-07 12:00:00',
               '2022-01-07 13:00:00', '2022-01-07 14:00:00',
               '2022-01-07 15:00:00', '2022-01-07 16:00:00',
               '2022-01-10 09:00:00', '2022-01-10 10:00:00'],
              dtype='datetime64[ns]', freq='BH')

# 30분 단위 : 30T로 해도 됨
pd.date_range(start='2022-01-07 08:00', periods=10, freq='30min')

DatetimeIndex(['2022-01-07 08:00:00', '2022-01-07 08:30:00',
               '2022-01-07 09:00:00', '2022-01-07 09:30:00',
               '2022-01-07 10:00:00', '2022-01-07 10:30:00',
               '2022-01-07 11:00:00', '2022-01-07 11:30:00',
               '2022-01-07 12:00:00', '2022-01-07 12:30:00'],
              dtype='datetime64[ns]', freq='30T')

# 10초 단위로 증가
pd.date_range(start='2022-01-07 08:00', periods=10, freq='10S')

DatetimeIndex(['2022-01-07 08:00:00', '2022-01-07 08:00:10',
               '2022-01-07 08:00:20', '2022-01-07 08:00:30',
               '2022-01-07 08:00:40', '2022-01-07 08:00:50',
               '2022-01-07 08:01:00', '2022-01-07 08:01:10',
               '2022-01-07 08:01:20', '2022-01-07 08:01:30'],
              dtype='datetime64[ns]', freq='10S')

2022

[web]jQuery 복습 3

2 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]jQuery 복습 2

11 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]jQuery 복습 1

16 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]JavaScript 정리4

6 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]JavaScript 정리3

6 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]JavaScript 정리2

6 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]JavaScript 정리1

7 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]CSS 기초 정리

9 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[web]HTML 기초 정리

2 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

[Pandas]pandas 연습

3 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

맨 위로 이동 ↑

2021

[Python기초]module

1 분 소요

[Noitce] 고쳐야하거나 틀린 것이 있으면 말씀해주세요!

맨 위로 이동 ↑