0825 Python , jupyterNoteBook

주피터 노트북 / 아나콘다 / 주피터 마크다운 / 포트폴리오

1. 주피터 노트북 실행

2. 실행 확인

3. 주피터 노트북 환경 확인

본인이 만든 python 폴더의 내용입니다.

 

 

4.주피터 마크다운 활용

-용이한 HTML 태그

• div
• font
• img

-Code / MarkDown 전환가능

 

 

 

 

쉘 모드 변경¶

• Code셀로 변경 : ESC + Y
• Markdown 셀로 변경 : ESC + M

In [3]:

#파이썬 코드
a = 'hello'
print(a)
a = 100
print(a)

 

hello
100

 

서울 지하철 이용객 수 분석¶

가장 이용자수가 많은 지하철은 ?¶

• 강남
• 홍대
  • 성수
  • 합정
  • -가산 디지털단지

 

• 별표 하나는 번호 없는 목록 별표로감싸면기울이기(주의:띄어쓰기없어야함) 별표2개로감싸면굵게(주의:띄어쓰기없이) 별표3개로감싸면굵게(주의:띄어쓰기없이)

가로선 --- 이면

---

 

---

인용문으로 맨 앞에 >

안녕하세요

 

Hello World

링크걸기

이미지링크

 

[참고] 지하철의 노선도

역명	지역
가산	금천구

 

 

 

 

 

 

 

5.파이썬 리스트 복습

 

 

 

파이썬의 리스트와 튜플¶

In [4]:

## (1) 22, 44, 11 요소의 리스트 a_data 생성
## (2) 길자, 길동, 길길 요소의 튜플 b_data생성
## (3) b_data 튜플을 a_data 리스트에 추가

a_data = [22,44,11]
b_data = ('길자','길동','길길')
print(type(a_data))
print(type(b_data))

a_data.append(b_data)
print(a_data)

 

<class 'list'>
<class 'tuple'>
[22, 44, 11, ('길자', '길동', '길길')]

In [8]:

## (4) b_data에서 2번째 요소까지 출력

print(b_data[:2])

 

('길자', '길동')

In [10]:

## (5) a_data를 튜플로 변경
##      11을 10으로 변경하려면?

a_data = tuple(a_data) #a_data를 튜플로 변경

a_data = list(a_data) #a_data를 리스트에 넣음

a_data[2] = 10 #a_data 2 index 값을 10으로 변경

a_data = tuple(a_data) #a_data를 튜플로 변경

print(a_data[:]) #a_data 출력

 

(22, 44, 10, ('길자', '길동', '길길'))

 

리스트 복습¶

• append(추가요소) : 리스트 맨 마지막에 하나 추가
• pop() : 마지막요소를 지움
• extend([추가요소들]) : 리스트 마지막에 여러 개 추가
• remove('요소값') : 해당 요소값 지움

---

• insert(idx, '데이타') : 원하는 위치에 자료 삽입

---

[슬라이싱]

• 리스트명(n:m) : n부터 m-1까지 데이타 추출

In [15]:

movies = ['어밴져스','기생충','가디언스갤럭시','어떤영화','유명한 영화']
movies

Out[15]:

['어밴져스', '기생충', '가디언스갤럭시', '어떤영화', '유명한 영화']

 

(1) '어젠져스2' 추가

In [16]:

movies.append('어벤져스2')
print(movies)

 

['어밴져스', '기생충', '가디언스갤럭시', '어떤영화', '유명한 영화', '어벤져스2']

 

(2) 마지막요소 제거

In [25]:

movies.pop()

Out[25]:

'어벤져스2'

 

(3) '어벤져스2','기생충2' 요소를 한꺼번에 추가

In [26]:

movies.extend(['어벤져스2','기생충'])
print(movies)

 

['어밴져스', '기생충', '가디언스갤럭시', '어떤영화', '유명한 영화', '어벤져스2', '기생충']

 

(4) '어벤져스2' 요소 제거

In [27]:

movies.remove('어벤져스2')
print(movies)

 

['어밴져스', '기생충', '가디언스갤럭시', '어떤영화', '유명한 영화', '기생충']

 

(5) 네번째 위치에 '오래된 영화' 추가

In [29]:

movies.insert(4,'오래된영화')
print(movies)

 

['어밴져스', '기생충', '가디언스갤럭시', '어떤영화', '오래된영화', '유명한 영화', '기생충']

 

(6) 영화목록에서 3번째에서 5번째까지 추출

In [30]:

print(movies[3:6])

 

['어떤영화', '오래된영화', '유명한 영화']

 

 

 

numpy¶

• 행렬 / 선형대수 / 통계 패키지
• 머신러닝의 이론적 백그라운드는 선형대수와 통계로 이루어져 있다
• 사이킷런 같은 머신러닝 패키지가 넘파이 기반으로 되어 있다

* 머신러닝 알고리즘이나 사이파이와 같은 과학, 통계 지원용 패키지를 직접 만드는 개발이 아니라면
넘파이를 상세하기 알 필요는 없다지만, 넘파이를 이해하는 것이 파이썬 기반의 데이타분석과 머신러닝에 중요하다

* 넘파이가 데이타 핸들링에 효율적으로 쉽고 편하고 할 수 없다.
  그러나 데이타 핸들링에 주로 사용하는 판다스도 많은 부분이 넘파이를 기반으로 만들어져 있다.

* ndarray 
    - 넘파이 기반 데이타 타입
    - np.array()       

In [4]:

import numpy as np

list_1 = [1,2,3]
list_2 = [9,8,7]

arr = np.array([list_1, list_2] )
print(arr)
print(type(arr))
print(arr.shape)

 

[[1 2 3]
 [9 8 7]]
<class 'numpy.ndarray'>
(2, 3)

In [6]:

#두 번쨰 행에서 두번쨰 열의 요소값을 100변경
arr[1][1] = 100
arr

Out[6]:

array([[  1,   2,   3],
       [  9, 100,   7]])

In [19]:

a = np.array([1,2,3])
b = np.array([[1,2,3]])

print(a.shape) # 튜플
print(b.shape)

print(a.ndim, '차원')
print(b.ndim, '차원')

 

(3,)
(1, 3)
1 차원
2 차원

 

자료형¶

• numpy의 배열 안에는 동일한 타입의 데이터만 저장 ( ** )
• 이 점 떄문에 파이썬 보다 속도가 빠르다.

In [24]:

a = np.array([1,2,3.0])
print(type(a))
print(a.dtype) #numpy 안에 있는애 확인 int32 /float 64

 

<class 'numpy.ndarray'>
float64

In [25]:

a #0이 생략된 결과 출력

Out[25]:

array([1., 2., 3.])

In [27]:

b = np.array([100,3.6, 'Hello']) #배열 막 선언
print(type(b))
print(b.dtype) #U32 - >유니코드 문자열

 

<class 'numpy.ndarray'>
<U32

In [28]:

b #보면 문자열 ''이 들어갔음

Out[28]:

array(['100', '3.6', 'Hello'], dtype='<U32')

In [1]:

  # [결과] <U11   : Unicode 문자열 

 

nparray를 편리하게 생성¶

• arange() : 범위를 이용한 배열 만들기
• zeros() : 0으로 채우는 배열 만들기
• ones() : 1로 채우는 배열 만들기

In [30]:

import numpy as np

In [34]:

d = np.zeros((5,5))
print(d.dtype)

d

 

float64

Out[34]:

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

In [35]:

#1로 채워진 3행 2열
a = np.ones((3,2))

Out[35]:

array([[1., 1.],
       [1., 1.],
       [1., 1.]])

 

ndarray의 차원과 크기를 변경 : reshape()¶

In [38]:

arr = np.arange(20)
print(arr.shape)
arr

 

(20,)

Out[38]:

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

In [40]:

arr2 =arr.reshape(4,5)
print(arr2.shape)
arr2

 

(4, 5)

Out[40]:

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

In [41]:

arr2 =arr.reshape(-1,4) #하나를 모를때는 -1값
print(arr2.shape)
arr2

 

(5, 4)

Out[41]:

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

 

인덱싱: 특정 데이타 추출¶

In [43]:

#------------------------------------------ (1) 단일값 출력
import numpy as np
arr = np.arange(1, 11)
print(arr)

## 세번째 요소 추출 
print('3번째 요소 추출',arr[2])

## 뒤에서 세번째 요소 추출 
print('뒤에서 세번쨰 요소 추출', arr[-3])

 

[ 1  2  3  4  5  6  7  8  9 10]
3번째 요소 추출 3
뒤에서 세번쨰 요소 추출 8

In [56]:

## 1부터 9까지 nparray를 만들고 3행 3열 2차원 구조로 변경한후
## 두번째 행의 세번째 열의 값 추출

good = np.arange(1,10)
good2 = good.reshape(3,3)
good2
print('두번째 행의 세번째 열의 값 추출 : ', good2[1][2])

 

두번째 행의 세번째 열의 값 추출 :  6

In [61]:

#------------------------------------------ (2) 슬라이싱 (:)
arr = np.arange(1, 10)

# 인덱스 2번째부터 4번째까지
print('# 인덱스 2번째부터 4번째까지 :', arr[2:5])

# 인덱스 2번째부터 끝까지
print('# 인덱스 2번째부터 끝까지 :', arr[2:])

# 처음부터 인덱스 4번째까지
print('처음부터 인덱스 4번째까지 :', arr[:5])

 

# 인덱스 2번째부터 4번째까지 : [3 4 5]
# 인덱스 2번째부터 끝까지 : [3 4 5 6 7 8 9]
처음부터 인덱스 4번째까지 : [1 2 3 4 5]

In [121]:

## 2차원 배열에서 생성
"""
    1 2 3
    4 5 6
    7 8 9
"""

arr = np.arange(1,10)
arr2 = arr.reshape(3,3)

    
## 배열에서 1, 2, 4, 5 추출

print(arr2[:2,:2])
print('='*10)

## 배열에서 4, 5, 6, 7, 8, 9 추출

print(arr2[1:,:3])
print('='*10)

## 배열에서 2, 3, 5, 6 추출

print(arr2[0:2,1:])
print('='*10)

## 배열에서 1, 4 추출
print(arr2[:2,:1])
print('='*10)

## 배열에서 전체 요소 추출
print(arr2[:])
print('='*10)

## 배열에서 3, 6 추출
print(arr2[:2,2:3])
print('='*10)
# 지금은 너무 간단하다고 여기지만 추후에 데이타에서 많이 헷갈려서 여기서 시간 소요를 많이 한다

 

[[1 2]
 [4 5]]
==========
[[4 5 6]
 [7 8 9]]
==========
[[2 3]
 [5 6]]
==========
[[1]
 [4]]
==========
[[1 2 3]
 [4 5 6]
 [7 8 9]]
==========
[[3]
 [6]]
==========

In [141]:

#------------------------------------------ (3) 블린인덱싱
# 조건 필터링과 검색을 같이 하기에 자주 사용

arr = np.arange(1, 10)
ndarr = arr.reshape(3,3)
print(ndarr)

# 5보다 큰 요소들 추출
for i in ndarr:
    for j in i:
        if j > 5:
            print(j)
            
#print(ndarr[ndarr>5])

# 8값 요소를 88로 변경
ndarr[ndarr ==8] = 88
print(ndarr)

 

[[1 2 3]
 [4 5 6]
 [7 8 9]]
6
7
8
9
[[ 1  2  3]
 [ 4  5  6]
 [ 7 88  9]]

 

 

 

 

 

 

 

 

 

numpy 연산¶

• abx / fabs : 절대값
• sqrt : 제곱근
• square : 제곱
• exp : 지수
• ceil / floor : 소수자릿수 올림/내림
• rint :소수자릿수 반올림
• modf : 원소의 몫과 나머지를 각 배열로 변환
• lsnan : 각 원소가 Nan인지 아닌지 불린 배열로 리턴
• add / subtract : 두 배열의 같은 위치의 요소끼리 덧셈/뺄셈
• multiply : 배열 원소끼리 곱셉
• divide : 첫번째 배열의 원소에서 두번째 배열 원소로 나눔
• power : 첫번째 배열의 원소에 두번째 배열의 원소만큼 제곱
• maximum : 비교하는 두 원소 중 큰 값
• mod : 첫번째 배열의 원소에서 두번째 배열 원소로 나눈 나머지

 

선형대수 연산¶

In [2]:

import numpy as np

# (1) 배열의 연산
arr1 = np.array([[1,2,3]
                 ,[4,5,6]])
arr2 = np.array([[1,1,1]
                 ,[2,2,2]])

In [6]:

# (2) 행렬의 곱

A = np.array(
    [[1, 2, 3],
    [4, 5, 6]])
B = np.array(
    [[7,8],
     [9,10],
     [11, 12]])

In [8]:

# (3) 전치행렬
#       - 원 행렬에서 행과 열 위치를 교환한 원소로 구성한 행렬
A = np.array(
    [[1, 2, 3],
    [4, 5, 6]])

print(A)

B = np.transpose(A)
print(B)

 

[[1 2 3]
 [4 5 6]]
[[1 4]
 [2 5]
 [3 6]]

 

넘파이 통계 함수¶

• sum : 배열 원소들의 합
• mean :산술 평균
• std / var : 표준편차 / 분산
• min / max : 최소 값 / 최대 값
• cumsum : 각 원소의 누적값
• cumprod : 각 원소의 누적곱

In [10]:

import numpy as np

ar = np.array([1,3,5,7])

In [11]:

# 평균
np.mean(ar)

Out[11]:

4.0

In [12]:

# 총합
np.sum(ar)

Out[12]:

16

In [13]:

# 큰값
np.max(ar)

Out[13]:

7

In [15]:

# 각 원소의 누적곱
np.cumprod(ar)

Out[15]:

array([  1,   3,  15, 105], dtype=int32)

 

2차원 배열에서¶

In [17]:

# 2차원 배열을 arr 생성
arr = np.array([[1,2,3],[4,5,6]])
arr

Out[17]:

array([[1, 2, 3],
       [4, 5, 6]])

In [18]:

# 총합
np.sum(arr)

#  특정 행의 합
np.sum(arr[0])
# axis=0 : 행방향 - 열단위 합 -> 생각해야할 점 '행 의 방 향 !!!!! ' 행은 하단으로 내려가니까 ↓ (요 라인의 연산)
np.sum(arr. axis =0)
# axis=1 : 열방향 - 행단위 합 -> 생각해야할 점 '열 의 방 향 !!!!! ' 열은 우측으로 늘어나니까 → (요 라인의 연산)
np.sum(arr. axis =1)

Out[18]:

6

In [24]:

# 불린 배열에서의 배열
arr2 = np.array([[12, 7, 22], [20,33, 44], [4,5,6]])

sum(arr2[arr2>20]) 

(arr2>20).sum () # 3 -> True 값을 카운팅

Out[24]:

99

In [26]:

# unique 연산자를 이용하여 중복제거
region = np.array(['가산','서울','서울','판교','가산'])

np.unique(region)

region # 원본을 건드리진 않으니 unique는 return을 위한 변수를 선언해 놓는게 좋겠다! ex) region2 = np.unique(region)

Out[26]:

array(['가산', '서울', '서울', '판교', '가산'], dtype='<U2')

 

행렬의 정렬¶

In [31]:

arr = np.array([9,3,6,1,7,2,4,8,5,6])

print(np.sort(arr))
print(np.sort(arr)[::-1])

 

[1 2 3 4 5 6 6 7 8 9]
[9 8 7 6 6 5 4 3 2 1]

In [39]:

arr2 = np.array([[9,3,6],
                 [1,7,2],
                 [4,8,5]])

print(np.sort(arr2))#행 단위로 정렬 즉, 기본값은 열 방향  => 행 단위 = 열 방향

print('='*10)

print(np.sort(arr2,axis =0)) #행 방향으로 정렬 - >즉 세로 라인 ↓

 

[[3 6 9]
 [1 2 7]
 [4 5 8]]
==========
[[1 3 2]
 [4 7 5]
 [9 8 6]]

 

 

 

 

 

 

난수 발생¶

• 파이썬 내장 random 모듈보다 더 빠르게 많은 난수 표본 데이타를 생성
• 적합한 난수는 시뮬레이션의 결과에 영향을 미치기에 중요함

[ ex ] 시뮬레이션의 난수 발생

침대 매트릭스의 충격완화 시뮬레이션을 한다고 할 때 1번 실험에 공을 50번을 던진다면 힘의 세기를 0~1 단위라고 할 때 임의의 힘의 세기로 50번 던졌을 때 평균 강도를 구할 수 있는데, 이 때 임의의 수 난수 발생을 numpy를 이용한다. 그러나 기본 패키지의 random 함수를 이용하지 않고 numpy을 이용하는 이유는 numpy가 속도도 빠르고 더 세밀하게 난수를 발생시킨다.

numpy의 난수 발생 함수의 차이를 조사하세요¶

1) np.random.random([n, m])

2) np.random.normal(size=( n, m))

3) np.random.randn(n,m)

4) np.random.rand(n,m)

5) np.random.randint(n, m)

In [1]:

import numpy as np

np.random.random([3, 4])

Out[1]:

array([[0.96694528, 0.39541743, 0.5719864 , 0.20568113],
       [0.3539649 , 0.78631799, 0.96867859, 0.86038012],
       [0.17085188, 0.71276692, 0.01269293, 0.38860375]])

In [2]:

arr2 = np.random.normal(size=(3,4))
arr2 #정규분포에 의하여 뽑아주는 랜덤수

Out[2]:

array([[-0.29397723,  0.79584549, -0.95907273, -0.9946922 ],
       [-0.43626039, -0.5886309 ,  1.8448181 ,  0.02046772],
       [-0.46037818, -0.37184547,  0.1562229 , -1.22321065]])

In [44]:

arr2 = np.random.normall((3,4)) #mistake
arr2

Out[44]:

array([3.5136884 , 4.45142617])

In [45]:

arr3 = np.random.randn(3,4) #실수
arr3

Out[45]:

array([[-0.28012605,  0.60698876, -1.52821139, -2.04266524],
       [ 0.59484882,  0.30676555, -1.77802459, -0.01061151],
       [-0.83148671,  0.16749708, -0.06063069, -1.67556308]])

In [46]:

arr4 = np.random.rand(3,4) #양수만 나옴
arr4

Out[46]:

array([[0.33065395, 0.98600306, 0.38242555, 0.27691448],
       [0.19327693, 0.16842392, 0.03805503, 0.1148873 ],
       [0.1808067 , 0.14306771, 0.204505  , 0.36399307]])

In [ ]:

 

[참고]¶

• random : 0.0에서 1.0 사이의 난수 추출
• rand : 균등분포에서 표준 추출
• randint : 최소, 최대 범위내에서 임의의 난수 추출
• randn : 표준편차 1, 평균값 0인 정규분포에서 표준 추출
• normal : 정규분포에서 표준추출
• shuffle : 리스트나 배열의 순서를 뒤섞음

 

[참고]¶

NumPy의 random 서브패키지에는 난수를 생성하는 다양한 명령을 제공한다. 그 중 가장 간단하고 많이 사용되는 것은 다음 3가지 명령이다.

• rand: 0부터 1사이의 균일 분포

• randn: 가우시안 표준 정규 분포

• randint: 균일 분포의 정수 난수

rand 명령은 0부터 1사이에서 균일한 확률 분포로 실수 난수를 생성한다. 숫자 인수는 생성할 난수의 크기이다. 여러개의 인수를 넣으면 해당 크기를 가진 행렬을 생성한다.

 

[참고] 데이타 사이언스 스쿨¶

파이썬 > 난수 발생과 카운팅

 

 

 

행렬의 정렬¶

1. np.sort() : 넘파이에서 sort() 호출
2. np.array.sort() : 행렬자체에서 sort() 호출

두 방식 sort() 함수의 차이점¶

1. np.sort() : 원 행렬을 그대로 유지한채 원 행렬의 정렬된 행렬을 반환
2. np.array.sort() : 원 행렬 자체를 정렬한 형태로 변환하며 None을 반환

In [2]:

import numpy as np

origin = np.array([3,1,9,7])
print('원본:', origin)

 

원본: [3 1 9 7]

In [3]:

# 넘파이 sort
sorted1 = np.sort(origin)
print('원본 :',origin)
print('정렬 후 :',sorted1)

 

원본 : [3 1 9 7]
정렬 후 : [1 3 7 9]

In [4]:

# 행렬의 sort
sorted2 = origin.sort()
print('원본 :',origin)
print('정렬 후 :',sorted2)

 

원본 : [1 3 7 9]
정렬 후 : None

 

내림차순 정렬 [::-1]¶

In [10]:

sorted1 [::-1] #거꾸로내림차순정렬

Out[10]:

array([9, 7, 3, 1])

In [ ]:

 

2차원 이상의 행렬에서 np.sort() 이해하기¶

• axis=0 : 행방향 -> 열단위
• axis=1 : 열방향 -> 행단위

In [11]:

arr = np.array([[9, 6, 3],[5, 11, 2]])


print(arr)


row_sort = np.sort(arr, axis=0)
print(row_sort)


row_sort = np.sort(arr, axis=1)
print(row_sort)

 

[[ 9  6  3]
 [ 5 11  2]]
[[ 5  6  2]
 [ 9 11  3]]
[[ 3  6  9]
 [ 2  5 11]]

In [12]:

?np.sort

 

정렬된 행렬의 인덱스 반환 : argsort()¶

In [15]:

arr = np.array([3, 8, 2, 5])
sorted = np.sort(arr)
print(sorted)

idx = np.argsort(arr)
print(idx) #정렬한 배열의 인덱스 값

 

[2 3 5 8]
[2 0 3 1]

In [ ]:

 

In [ ]:

 

 

 

 

Series¶

• DataFrame의 한 컬럼 데이터 세트
• Series 역시 DataFrame의 인덱스와 동일한 인덱스를 가진다
• 즉 Series는 컬럼이 하나인 데이타 구조체이고, DataFrame은 컬럼이 여러개인 데이타 구조체이다

DataFrame을 RDBMS의 테이블과 유사하다면, Series는 테이블의 한 컬럼과 유사다하고 볼 수 있다

In [1]:

# from pandas import Series
# age_in = Series([22,33,44,25,28])

import pandas as pd
age_in = pd.Series([22,33,44,25,28])

In [2]:

age_in.index

Out[2]:

RangeIndex(start=0, stop=5, step=1)

In [3]:

age_in.values

Out[3]:

array([22, 33, 44, 25, 28], dtype=int64)

In [4]:

age_in.keys

Out[4]:

<bound method Series.keys of 0    22
1    33
2    44
3    25
4    28
dtype: int64>

 

인덱스 지정하며 시리즈 생성

In [7]:

age_in = pd.Series([22,33,44,25,28], index=['가','나','다','라','마'])
age_in # 자동으로 인덱스 잡혀있음 위에서 설정한 index로 출력가능

Out[7]:

가    22
나    33
다    44
라    25
마    28
dtype: int64

In [10]:

#'다' 요소에 100으로 변경
age_in['다'] = 100
#age_in[2] = 200
age_in

Out[10]:

가     22
나     33
다    100
라     25
마     28
dtype: int64

In [13]:

# Series 인덱스 중복 확인
srs = pd.Series(['가','나','다'], index = ['a','b','b']) #Series 인덱스는 중복이 가능하다
print(srs)
print(srs['b'])
print('-'*30)
print(srs[1])

 

a    가
b    나
b    다
dtype: object
b    나
b    다
dtype: object
------------------------------
나

 

딕셔러리를 시리즈 형태로 변환

In [17]:

# 딕셔러리를 시리즈 형태로 변환
info_list = { 'kim': 25, 'park':22, 'lee':34 }
info_series = pd.Series(info_list)
info_series

Out[17]:

kim     25
park    22
lee     34
dtype: int64

In [19]:

# 인덱스를 지정하면 -> NaN로
# 이미 인덱스 역할을 할 요소가 있는데 index를 지정해서 그런가
info_series = pd.Series(info_list, index=[0,1,2])
info_series

Out[19]:

0   NaN
1   NaN
2   NaN
dtype: float64

In [20]:

## 가,나,다 요소에 A, B, C 인덱스를 가진 시리즈 생성
info_series = pd.Series(info_list.items(), index=[0,1,2])
info_series

Out[20]:

0     (kim, 25)
1    (park, 22)
2     (lee, 34)
dtype: object

 

Series 인덱스¶

• 리스트, 튜플의 index와 dict 의 key 와 유사
• 같은 값의 index 가 가능 ( 즉, 중복 가능 )

---

정리¶

• 리스트 튜플 index : 일련번호로 변경불가 / 순서 개념이 있다
• Series Index : 중복 가능 / 순서 개념이 있다
• Dict key : 중복 불가 / 순서 개념 없다

 

판다스를 사용하는 이유¶

만일 파이썬의 리스트와 판다스의 Series가 거의 유사하다면, 우리는 왜 파이썬의 리스트가 아닌 판다스의 Series를 사용할까?

파이썬의 리스트를 사용하면 판다스에서 제공하는 다양한 기능을 사용할 수 없기 때문이다.

In [22]:

# 파이썬 기초 -리스트

odd = [1,3,5,7,9]

#평균 ?

In [23]:

import pandas as pd
sr = pd.Series(odd)
sr.mean()

Out[23]:

5.0

 

 

 

 

 

판다스 (Pandas)¶

• 핵심객체는 DataFrame이다
• 데이타프레임은 2차원 데이터 구조체로 넘파이보다 편리하게 데이타 핸들링한다.
• R 언어의 데이타 프레임과 비슷하고 많이 사용된다

DataFrame 에서 데이타 필터링 ( 추출하기 )¶

1. 맨처음에는
   • df[2] : 2행의 데이타 추출
   • df['A'] : A열(컬럼) 데이타 추출
   • df[n:m] : n번째부터 m-1번째까지의 행 추출` 판다스를 만든 사람이 쓴 책의 번역서를 보면 이 부분을 후회한다고 나옴
   • ` df[2] 이 형식은 에러 발생 ( 2021.01)
   • ` 행과 열을 섞어서 추출함.

1. 열(컬럼) 추출
   • df.컬럼명
   • df['컬럼명']

1. 행 추출
   • df.loc[] : 인덱스 지정하지 않으면 인덱스(순서), 인덱스 지정하면 인덱스로 추출
   • df.iloc[] : 인덱스(순서)로 추출
   • [참고]
   • 위 3 연산자는 노련한 개발자들도 혼동하기에, 일반적으로 하나만 선택해서 사용하는 것을 권장한단다
   • 넘파이와 유사한 부분으로 더우 혼동하기 쉽다
   • 판다스의 DataFrame와 Series에서도 다른이 있어서 주의해야 한다

1. 행과 열에서 추출
   • df.loc[2, 3] : 2 행의 3열 데이타
   • df.loc[1:3, 2:4] : 1부터 3행전까지의 행에서 2부터 4전까지의 열의 데이타

In [2]:

import pandas as pd

# 데이타 프레임 자료 생성
mydata = {
          'name':['홍길동','박길동','김길동'], 
          'age':[22,33,44], 
          'dept':['컴공','국어','산업']
         }

df = pd.DataFrame(mydata)

print(type(mydata))
print(type(df))

df

 

<class 'dict'>
<class 'pandas.core.frame.DataFrame'>

Out[2]:

	name	age	dept
0	홍길동	22	컴공
1	박길동	33	국어
2	김길동	44	산업

In [6]:

#열추출
print(df.name)
# df['컬럼명']
print(df['name'])

#행추출
print(df.loc[1])
print(df.iloc[1])

 

0    홍길동
1    박길동
2    김길동
Name: name, dtype: object
0    홍길동
1    박길동
2    김길동
Name: name, dtype: object
name    박길동
age      33
dept     국어
Name: 1, dtype: object
name    박길동
age      33
dept     국어
Name: 1, dtype: object

In [11]:

df = pd.DataFrame(mydata, index=['일','이','삼'])
df

print(df.loc['이'])

 

name    박길동
age      33
dept     국어
Name: 이, dtype: object

In [12]:

df.index

Out[12]:

Index(['일', '이', '삼'], dtype='object')

In [13]:

df.values

Out[13]:

array([['홍길동', 22, '컴공'],
       ['박길동', 33, '국어'],
       ['김길동', 44, '산업']], dtype=object)

In [15]:

df.columns

Out[15]:

Index(['name', 'age', 'dept'], dtype='object')

In [21]:

# '박길동'
print(df.loc['이'].values[0])

 

박길동

 

컬럼 추가, 행 추가¶

In [23]:

# 컬럼 추가
df['gender'] = ['여자','여자','남자']
df

Out[23]:

	name	age	dept	gender
일	홍길동	22	컴공	여자
이	박길동	33	국어	여자
삼	김길동	44	산업	남자

In [24]:

# 행 추가
df.loc[3] = ['이길동','33','컴공','남자']
df

Out[24]:

	name	age	dept	gender
일	홍길동	22	컴공	여자
이	박길동	33	국어	여자
삼	김길동	44	산업	남자
3	이길동	33	컴공	남자

In [27]:

# 행 추가
df.loc['사'] = ['장길동2','33','컴공','남자'] # [index] = [value] , #같은 index 로 하면 수정이 됨
df

Out[27]:

	name	age	dept	gender
일	홍길동	22	컴공	여자
이	박길동	33	국어	여자
삼	김길동	44	산업	남자
3	이길동	33	컴공	남자
9	장길동	33	컴공	남자
사	장길동2	33	컴공	남자

 

변경¶

In [47]:

# 인덱스순서를 변경하려면 -> 인덱스는 우선 DataFrame이 있는 상태에서 변경해야 한다
mydata = {
          'name':['홍길동','박길동','김길동'], 
          'age':[22,33,44], 
          'dept':['컴공','국어','산업']
         }

df = pd.DataFrame(mydata)
print(df)
df2 =df.reindex([1,0,2]) #index값을 새로 변경
print(df2)

 

  name  age dept
0  홍길동   22   컴공
1  박길동   33   국어
2  김길동   44   산업
  name  age dept
1  박길동   33   국어
0  홍길동   22   컴공
2  김길동   44   산업

In [31]:

# 컬럼연산
df['age+10'] = df['age'] + 10
df

Out[31]:

	name	age	dept	age+10
0	홍길동	22	컴공	32
1	박길동	33	국어	43
2	김길동	44	산업	54

In [54]:

# 2행에 'dept'열의 값을 '인문'으로 변경
#df.dept.iloc[2] = '인문' 
#df.loc[2,'deft'] = '인문' -pick
#df.dept[2] = '인문'
#df.loc[2] = ['김길동',44,'인문',54]

 

C:\Users\xorms\anaconda3\lib\site-packages\pandas\core\indexing.py:1637: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  self._setitem_single_block(indexer, value, name)

Out[54]:

	name	age	dept
0	홍길동	22	컴공
1	박길동	33	인문
2	김길동	44	산업

 

컬럼 속성 추출¶

In [8]:

# 컬럼 속성 추출
df.컬럼명
df['컬럼명']

In [9]:

# 특정 컬럼의 특정행 추출 -> 즉 특정셀 추출 (2번 인덱스의 dept 컬럼값은? )

In [78]:

# 30세 이상의 레코드 검색
df[df.age >= 30]

Out[78]:

	name	age	dept
1	박길동	33	인문
2	김길동	44	산업

In [11]:

# 인덱스 1의 name 값을 '맹길동'로 변경하려면?

 

데이타 필터링¶

• 넘파이와 유사한 부분으로 더우 혼동하기 쉽다
• 판다스의 DataFrame와 Series에서도 다른 부분이 있어서 주의해야 한다

1. loc[] : 인덱스와 명칭으로 추출
2. iloc[] : 인덱스로 추출
3. ix[] : 명치 기반 인덱싱과 위치 기반 인덱싱 모두 사용 (* 그러나 곧 사라질 예정 )

위 3 연산자는 노련한 개발자들도 혼동하기에, 일반적으로 하나만 선택해서 사용하는 것을 권장한단다

In [98]:

mydata = {
          'name':['홍길동','박길동','김길동'], 
          'age':[22,33,44], 
          'dept':['컴공','국어','산업']
         }

df = pd.DataFrame(mydata, index= ['일','이','삼'])

In [82]:

# 명칭기반 인덱스 : 문자열이 인덱스인 경우
print(df.loc[1]) # loc는 써있는 숫자를 따라감
print(df.iloc[1]) # iloc은 진짜 0,1,2 번째의 index

 

name    박길동
age      33
dept     국어
Name: 1, dtype: object
name    박길동
age      33
dept     국어
Name: 1, dtype: object

In [88]:

print(df)
print(df.loc['일']) 
#print(df.iloc['일']) -> 에러 #진짜 index 0,1~ 값이기 때문

 

  name  age dept
일  홍길동   22   컴공
이  박길동   33   국어
삼  김길동   44   산업
name    홍길동
age      22
dept     컴공
Name: 일, dtype: object

In [93]:

df.loc[['일','삼']] #2차원배열 아님
df[['name','dept']]

Out[93]:

	name	dept
일	홍길동	컴공
이	박길동	국어
삼	김길동	산업

In [95]:

# 특정 컬럼으로 인덱스를 지정
df2=df.set_index('name',inplace=True) #inplace=True ->원본을 변경하겠다.
df2

Out[95]:

	age	dept
name
홍길동	22	컴공
박길동	33	국어
김길동	44	산업

In [96]:

df #원본은 바꾸지않음

Out[96]:

	name	age	dept
일	홍길동	22	컴공
이	박길동	33	국어
삼	김길동	44	산업

 

정렬과 T¶

In [106]:

# 나이를 오름차순으로
# df.sort_index(ascending=0)   # 인덱스 정렬 기본값이 ascending=1

df.sort_index(ascending=False) # index 값으로정렬

df.sort_values('name', ascending=False, inplace=True) #values 값으로정렬 #inplace 값은 기본적으로 False로 원본값 변경이 안된다.


# 전문가들은 원본이 변경하지 않는 것을 권장

Out[106]:

	name	age	dept
일	홍길동	22	컴공
이	박길동	33	국어
삼	김길동	44	산업

In [107]:

# 행,열 바꾸기

df.T

Out[107]:

	일	이	삼
name	홍길동	박길동	김길동
age	22	33	44
dept	컴공	국어	산업

 

정보확인¶

In [108]:

# 총 데이터 건수와 데이타 타입등 정보 확인
df.info()

 

<class 'pandas.core.frame.DataFrame'>
Index: 3 entries, 일 to 삼
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   name    3 non-null      object
 1   age     3 non-null      int64 
 2   dept    3 non-null      object
dtypes: int64(1), object(2)
memory usage: 204.0+ bytes

In [111]:

# 기본통계량 구하기 ( 총개수, 평균, 표준편차, 최소값, 4분위수 등)

df.describe() #숫자로 이루어진 컬럼만 딱 계산해줌

Out[111]:

	age
count	3.0
mean	33.0
std	11.0
min	22.0
25%	27.5
50%	33.0
75%	38.5
max	44.0