파이썬

 

 

 

 

 

1.  NaN 사용

 

1-1.  숫자가 아닌 데이터 (NaN : Not a Number) 삽입

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

#결과
'''
[1, 3, 5, nan, 6, 8]

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

 

 

 

1-2.  pandas의 data_range 사용 : data_range('시작날짜', periods=갯수)

dates = pd.date_range('20211208', periods=6)

#결과
'''
DatetimeIndex(['2021-12-08', '2021-12-09', '2021-12-10', '2021-12-11', '2021-12-12',
			 '2021-12-13'], dtype='datetime64[ns]', freq='D')
'''

 

 

 

1-3. numpy로 행열 형태의 난수(임의 수) 생성 : np.random.randn(행, 열)

np.random.randn(6, 4)

#결과
'''
array([[-0.78694227, -0.39382895, -1.30222199, -0.31517125],
       [-1.33947656,  0.88645615, -1.03778297, -0.60052824],
       [ 0.67206179, -1.20505304,  1.08646716, -0.55195954],
       [ 0.4785254 ,  0.38805122,  1.77204731, -0.27905548],
       [-0.28070526,  0.87060175, -0.99529807, -1.16565425],
       [ 0.79059187,  0.20672588,  0.51974029,  1.87050974]])
'''

 

 

 

1-4. numpy로 행열 형태의 난수(임의 수) 생성 : np.random.randn(행, 열)

#dates를 index로, np.random.randn(6, 4)를 데이터로 하는 DataFrame 객체 df 생성
dates = pd.date_range('20211208', periods=6)
df = pd.DataFrame(np.random.randn(6, 4),     #values라는 매개변수 사용
                  index=dates,               #index라는 매개변수 사용
                  columns=['A', 'B', 'C', 'D'])     #columns라는 매개변수 사용
                  
#결과
'''
                   A         B         C         D
2021-12-08 -1.208131 -2.194505 -0.592236  0.080834
2021-12-09 -1.195402 -0.327135 -1.630431  1.326106
2021-12-10  0.111884  3.096611 -0.282745  0.513996
2021-12-11  1.032994 -1.051557  1.020307  1.172119
2021-12-12  0.223649  0.167089 -0.991968  1.080597
2021-12-13  0.992869 -1.636204  0.357904 -1.777964
'''

 

 

 

 

 

 

파이썬

 

 

 

 

 

1.  특징

 

1) 신속하고 효율적인 표현


    
- 행과 열 바꾸기 가능

    - 실 세계 데이터 분석


2) 다양한 형태의 데이터 표현


    - 서로 다른 형태의 데이터 표현    예) 시계열, 레이블 가진 데이터, 다양한 관측 데이터

 

3) Seiries : 1차원 행 구조    /    DataFrame : 2차원 행렬 구조


4) 결측null 데이터 처리


    - 데이터 추가 및 삭제 : 특정 행렬에 삽입과 삭제 및 추가 가능
    - 데이터 정렬과 조작

 

 

 

 

 

2.  기능

 

1) 리스트, 딕셔너리, numpy 배열 등의 데이터를 DataFrame으로 변환

 

2) csv / xls 파일 등으로 작업


3) url을 통해 웹페이지의 csv, json과 같은 원격데이터 및 데이터베이스 등 분석


4) 데이터 보기 및 검사

 

    - mean() : 특정 열의 평균
    - corr() : 상관 관계
    - count() : 열의 데이터 수


5) 필터, 정렬, 그룹화


    - sort_values() : 정렬
    - groupby() : 기준에 의해 몇 가지의 그룹화


6) 데이터 정제

 

    데이터 누락 및 특정 값을 다른 값으로 일관 변경

 

 

 

 

 

3. 구조

 

1) Series 사용

 

1-1. Series 생성

kakao = Series([92600, 92400, 92100, 94300, 92300])
print(type(kakao))

 

사용할  List의 이름을 부여하고,

이름 = series([값1, 값2, 값3 ... 값n])    의 형태로 생성.

 

각 값이 행에 삽입된 한개의 열 형태의 series가

별도의 index이 없이 0부터 index가 부여된 채 생성됨.

 

 

 

1-2. index를 부여한 Series 생성 

#series의 index로 사용할 열 생성
idx = ['2024-01-02', '2024-02-06', '2024-03-02', '2024-04-07', '2024-06-08']

#series의 데이터로 사용할 list 생성 _ index와 데이터 수 일치
data = [92600, 92400, 92100, 94300, 92300]

#index와 데이터를 이용해 Series 객체 생성 _ 별도의 이름 부여 예) sample = 
sample = Series(data, index=idx)



#한꺼번에 생성 가능
sample = Series([92600, 92400, 92100, 94300, 92300],
	index=['2024-01-02', '2024-02-06', '2024-03-02', '2024-04-07', '2024-06-08'])

 

 list 형태의 데이터 객체를 생성 후,

별도로 index로 사용할 list 형태의 열을 생성.

 

두 데이터를 하나의 series로 병합해 사용 가능.

 

 

 

1-3. index와 값 각각 추출

for data in sample.index:
    print(data)

for data in sample.values:
    print(data)

 

.index  /  .values를 이용해 각각  index와 값을 추출.

 

 

 

1-4. Series 간의 연산

 

mine = Series([10, 20, 30], index=['naver', 'kt', 'sk'])
friend = Series([10, 30, 20], index=['kt', 'naver', 'sk'])

#두 series를 더해 같은 index 별 병합
merge = mine+friend
sub = mine-friend
mul = mine*friend
div + mine/friend

#결과
'''
kt       30
naver    40
sk       50
dtype: int64

kt       10
naver   -20
sk       10
dtype: int64

kt       200
naver    300
sk       600
dtype: int64

kt       2.000000
naver    0.333333
sk       1.500000
dtype: float64
'''

 

 

 

2) DataFrame 사용

 

    주로 딕셔너리 사용해 각 열에 대한 데이터 저장

 

2-1. DataFrame 생성

 

#Dataframe 객체 생성을 위한 key : value의 구조의 dictionary 생성
raw_data = {'col0': [1, 2, 3, 4],
            'col1': [10, 20, 30, 40],
            'col2': [100, 200, 300, 400]}

#DataFrame 이름 = DataFrame(딕셔너리이름) 구조로 Dataframe 객체 생성
dataframe_data = DataFrame(raw_data)
print(dataframe_data)

 

dinctionary를 이용해 DataFrame객체를 생성 시,
dinctionary의 key가 DataFrame의 열 이름으로 자동 indexing.


dinctionary의 values에는 list로 0부터 정수로 각각 indexing.

 

#DataFrame의 컬럼은 Series 형태
print(type(dataframe_data['col0']))

#결과
'''
<class 'pandas.core.series.Series'>
'''

 

 

 

2-2. DataFrame의 index 변경

 

daeshin = {'open': [11650, 11100, 11200, 11100, 11000],
           'high': [12100, 11800, 11200, 11200, 11500],
           'low': [11600, 11050, 11120, 11450, 11450],
           'close': [12350, 11540, 11540, 11500, 11300]}

#DataFrame의 열 이름 별도 설정 : columns = [list]
#부여한 열 이름 순서 변경하는 법 : columns = [dictionary의 key]
daeshin_day = DataFrame(daeshin)
daeshin_day2 = DataFrame(daeshin, columns=['open', 'low', 'close', 'high'])

#list 생성하여 DataFrame의 index 설정 : index = [list]
#단, 열(dictionary의 key)의 데이터(dictionary의 value) 갯수, 즉 행의 숫자와 동일
daeshin_index = ['21.12.01', '21.12.02', '21.12.03', '21.12.04', '21.12.05']
daeshin_day3 = DataFrame(daeshin, columns=['open', 'low', 'close', 'high'],
                         index=daeshin_index)

 

 

 

2-3. DataFrame의 데이터 추출

 

#DataFrame의 데이터 추출 1 : 열 이름 이용 _ 해당 열의 각 행의 값
print(daeshin_day3['open'])

#결과
'''
21.12.01    11650
21.12.02    11100
21.12.03    11200
21.12.04    11100
21.12.05    11000
Name: open, dtype: int64
'''



#DataFrame의 데이터 추출 2 : index 이용 _ 해당 행의 각 열의 값
print(daeshin_day3['21.12.01' : '21.12.05'])

#결과
'''
           open    low  close   high
21.12.01  11650  11600  12350  12100
21.12.02  11100  11050  11540  11800
21.12.03  11200  11120  11540  11200
21.12.04  11100  11450  11500  11200
21.12.05  11000  11450  11300  11500
'''

 

 

 

 

 

파이썬

 

 

 

 

 

1. 라이브러리 모음

1) 파일 읽기 _ pandas / numpy

import pandas as pd

import numpy as np

 

2) 시각화 _ matplot / seaborn

import matplotlib.pyplot as plt

from matplotlib import font_manager, rc
import platform
if platform.system() == 'Windows' :
    path = 'c:/Windows/Fonts/malgun.ttf'
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family = font_name)
elif platform.system() == 'Darwin' :
    rc('font', family = 'AppleGothic')
else :
    print('Check your OS System')
    
import seaborn as sns

 

3) 랜덤 _  random

import random

 

4) 타임 _ time

import time

 

5) 운영체제 모듈 _ os

import os


6) csv 모듈 _ csv

import csv

 

 

2. 시각화별 특징

1) 파이 차트

데이터의 카테고리별 비율 시각화에 효과적.
비율을 쉽게 비교할 수 있고, 각 칵테고리의 상대적 중요성 한눈에 파악 가능.

2) 막대 그래프

데이터의 항목 간의 비교를 명확하게 시각화하는데 유용.
각 장르의 빈도를 막대 그래프로 시각화.

3) 히트맵

데이터의 밀도나 강도를 색상으로 시각화하여 복잡한 데이터셋에서 패턴, 트렌드 파악 용이
콘텐츠 기획에 대한 인사이트 도출

4) 워드크라우드

텍스트 데이터에서 빈도가 높은 단어를 시각적으로 강조.
데이터의 주요 주제, 키워드를 한눈에 파악.
어떤 주제나, 키워드가 자주나오는지 콘텐츠의 주요 테마 파악.
마케팅, 콘텐츠 기획, 전략, 사용자 분석 등 유용한 인사이트 파악.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

파이썬

 

 

 

 

 

입출력

 

 

 

1. 함수

1) 기본 구조

 

def 함수_이름(매개변수):
    수행할_문장1
    수행할_문장2
    ...

 

def add(a, b): 
    return a + b

pirnt(add(1, 2)

>>> 3

: a와 b는 매개변수/인자, 1과 2는 인수

 

 

 

2. 파일 읽기 / 쓰기

 

파일_객체 = open(파일_이름, 파일_열기_모드)

 

1) 쓰기 : 'w'

 

f = open("새파일.txt", 'w')
f.close()

 

f = open("C:/doit/경로/새파일.txt", 'w')
f.close()

 

f = open("C:/doit/새파일.txt", 'w')
for i in range(1, 11):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
f.close()

 

 

2) 읽기 : 'r'

 

f = open("C:/doit/새파일.txt", 'r')
line = f.readline()
print(line)
f.close()

>>> 1번째 줄입니다.

 

f = open("C:/doit/새파일.txt", 'r')
while True:
    line = f.readline()
    if not line:

        break
    print(line)
f.close()

: .readline() 첫째줄만 읽기

 

f = open("C:/doit/새파일.txt", 'r')
lines = f.readlines()
for line in lines:
    print(line)
f.close()

 

f = open("C:/doit/새파일.txt", 'r')
data = f.read()
print(data)
f.close()

 

 

3) for문과 읽기


f = open("C:/doit/새파일.txt", 'r')
for line in f:
    print(line)
f.close()

 

 

4) 내용 추가 : 'a'

 

f = open("C:/doit/새파일.txt",'a')
for i in range(11, 20):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
f.close()

 

: 'w'는 새 파일이 생기면서 데이터를 새로 쓰는 것, 따라서 같은 이름의 파일이 있다면 삭제되고 새 데이터가 쓰임.

그러나 'a'는 기존 데이터 뒤에 이어서 씀.

 

 

5) with로 읽기

 

with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")

 

 

 

 

파이썬

 

 

 

 

 

제어문

 

 

 

1. if문

1) 기본 구조

 

if 조건문:
    수행할_문장1
    수행할_문장2
else:
    수행할_문장A
    수행할_문장B

 

조건문 : 참과 거짓을 판단하는 문장으로

if 이하의 문장이 참이면 하위 문장1, 2를 실행,

거짓이면(아니면else ) 하위 문장A, B를 실행.

 

'돈이 있으면 택시를 타고 가고, 돈이 없으면 걸어간다.’

 

money = True
if money:
    print("택시를 타고 가라")
else:
    print("걸어 가라")

>>> 택시를 타고 가라

 

a = 'money'
if a:
    print("참입니다")
else:
    print("거짓입니다")

>>> 참입니다

: a라는 변수에 값 money가 들어있어, 그 속성 자체로 참이다.

 

a = ''
if a:
    print("참입니다")
else:
    print("거짓입니다")

>>> 거짓입니다

: a라는 변수에 값이 없으므로, 그 속성 자체가 거짓이다.

 

 

2) 비교 연산자를 이용 : <, >, ==, !=, >=, <=

 

'만약 3000원 이상의 돈을 가지고 있으면 택시를 타고 가고, 그렇지 않으면 걸어가라.'

 

money = 2000
if money >= 3000:
    print("택시를 타고 가라")
else:
    print("걸어가라")
>>> 걸어가라

 

: 만약 money >= 3000이 참True이면, "택시를 타고 가라"를 출력하고,

거짓False이면 "걸어가라"를 출력하라.

 

 

3) and, or, not을 이용

 

3-1) or : x or y

: 둘중 하나만 참이어도 참

 

'만약 3000원 이상의 돈이나 카드를 가지고 있으면 택시를 타고 가고, 그렇지 않으면 걸어가라.'

 

money = 2000
card = True
if money >= 3000 or card:
    print("택시를 타고 가라")
else:
    print("걸어가라")
>>> 택시를 타고 가라

: 만약 money >= 3000이 참True 혹은 card가 있다면, "택시를 타고 가라"를 출력하고,

거짓False이면 "걸어가라"를 출력하라.

 

 

3-2) and : 둘 다 참이어야 참

: x and y

 

 

3-3) not : x가 거짓이면 참

: not x

 

 

4) in과 not in을 이용

: x in 리스트/튜플/문자열

: x not in 리스트/튜플/문자열

 

1 in [1, 2, 3]
>>> True
1 not in [1, 2, 3]
>>> False

 

'a' in ('a', 'b', 'c')
>>> True
'j' not in 'python'
>>> True

 

"만약 주머니에 돈이 있으면 택시를 타고 가고, 없으면 걸어가라."

 

pocket = ['paper', 'cellphone', 'money']
if 'money' in pocket:
    print("택시를 타고 가라")
else:
    print("걸어가라")
>>> 택시를 타고 가라

 

5) 아무 것도 실행하지 않음 : pass

 

"만약 주머니에 돈이 있으면 택시를 타고 가고, 없으면 걸어가라."

 

pocket = ['paper', 'cellphone', 'money']
if 'money' in pocket:
    pass
else:
    print("걸어가라")

>>>

 

 

1. elif

1) 기본 구조

: elif를 이용해 여러개의 조건과 실행을 제시

 

if 조건문:
    수행할_문장1 
    수행할_문장2
elif 조건문:
    수행할_문장1
    수행할_문장2
elif 조건문:
    수행할_문장1
    수행할_문장2
else:
   수행할_문장1
   수행할_문장2

 

>>> pocket = ['paper', 'cellphone']
>>> card = True
>>> if 'money' in pocket:
...      print("택시를 타고가라")
... elif card: 
...      print("택시를 타고가라")
... else:
...      print("걸어가라")
...
택시를 타고가라

 

 

 

2. while문

1) 기본 구조

 

while 조건문:
    수행할_문장1
    수행할_문장2
    수행할_문장3

 

coffee = 10
while True:
    money = int(input("돈을 넣어 주세요: "))
    if money == 300:
        print("커피를 줍니다.")
        coffee = coffee -1
    elif money > 300:
        print("거스름돈 %d를 주고 커피를 줍니다." % (money -300))
        coffee = coffee -1
    else:
        print("돈을 다시 돌려주고 커피를 주지 않습니다.")
        print("남은 커피의 양은 %d개 입니다." % coffee)
    if coffee == 0:
        print("커피가 다 떨어졌습니다. 판매를 중지 합니다.")
        break

: 강제로 while문을 중지시킴.

 

a = 0
while a < 10:
    a = a + 1
    if a % 2 == 0:

        continue
    print(a)

: 처음으로 돌아가 수행하게 함.

 

 

 

3.  for문

 

1) 기본 구조

: 리스트의 첫 값부터 하나씩 변수에 '수행할 문장'하는 것을 마지막 값까지 반복.

: 따라서 리스트 안의 값을 다 돌 때까지 반복.

 

for 변수 in 리스트(또는 튜플, 문자열):
    수행할_문장1
    수행할_문장2
    ...

 

test_list = ['one', 'two', 'three'] 
for i in test_list: 
    print(i)
>>> one 
        two 
        three

 

marks = [90, 25, 67, 45, 80]          # 학생들의 시험 점수 리스트
number = 0   # 학생에게 붙여 줄 번호
for mark in marks:          # 90, 25, 67, 45, 80을 순서대로 mark에 대입
    number = number +1 
    if mark >= 60: 
        print("%d번 학생은 합격입니다." % number)
    else: 
        print("%d번 학생은 불합격입니다." % number)

>>> 1번 학생은 합격입니다.

        2번 학생은 불합격입니다.

        3번 학생은 합격입니다.

        4번 학생은 불합격입니다.

        5번 학생은 합격입니다.

 

marks = [90, 25, 67, 45, 80]
number = 0 
for mark in marks: 
    number = number +1 
    if mark < 60:
        continue 
    print("%d번 학생 축하합니다. 합격입니다. " % number)

>>> 1번 학생 축하합니다. 합격입니다.

         3번 학생 축하합니다. 합격입니다.

         5번 학생 축하합니다. 합격입니다.

 

 

2) 이중 for문

 

for i in range(2,10):          # 1번 for문
for j in range(1, 10):          # 2번 for문
    print(i*j, end=" ") 
print('') 
... 
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81

: 1번 for문의 첫번째 값이 2번 for문의 값 처음부터 끝까지를 다 돌아야,

1번 for문의 두번째 값으로 넘어감.

 

for i in range(2,10):
for j in range(1, 10):
    print(i*j) 
print('') 
... 
2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54  7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81

: print('')에서 ''에는 줄바꿈이\n이 기본으로 들어가 있는 상태로,

줄띄움을 하고 싶다면 print(x, end=' ')형태로 end를 넣어 줌.

*end=''은 end'\n'이 기본이므로 end=' '스페이스를 넣어 줘야 함.

파이썬

 

 

 

 

 

자료형

 

 

 

1. 딕셔너리

 

사전과 같이 각 요소의 key값과 value값이 상응하는 자료형.

{Key1: Value1, Key2: Value2, Key3: Value3, ...}

dic = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

 

 

1) 요소 추가 : 딕셔너리이름[key값] = 'value값'

: 딕셔너리이름이라는 딕셔너리 안에 key값:value값을 추가.

 

a = {1: 'a'}
a[3] = 'b'
a
>>> {1: 'a', 3: 'b'}

 

 

2) 요소 삭제 : del 딕셔너리이름[key값]

: 딕셔너리이름이라는 딕셔너리 안의 key값과 그에 해당하는 value값을 한쌍으로 삭제.

 

a = {2: 'b', 'name': 'pey', 3: [1, 2, 3]}

del a[1]
a
>>>  {2: 'b', 3: [1, 2, 3]}

 

 

1-2. 딕셔너리 함수

 

1) key 리스트 생성 : .key()

: 딕셔너리의 key 값만 dict_keys([]) 형태로 하나의 리스트 생성.

: list(.key())로 입력 시, [key1, key2, key3, ..., n] 형태로 생성.

 

 

2) value 리스트 생성 : .values()

: 딕셔너리의 vlaue 값만 dict_values([]) 형태로 하나의 리스트 생성.

: list(.values())로 입력 시, [values1, values2, values3, ..., n] 형태로 생성.

 

 

3) key와 value 한꺼번에 리스트 생성 : .items()

: 딕셔너리의 key와 value를 한쌍의 튜플로, dict_items([]) 형태로 하나의 리스트 생성.

 

a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

a.items()
dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

 

 

4) 딕셔너리 내부 해당 key 값 유무 확인 : in

 

a = {'name':'pey', 'phone':'010-9999-1234', 'birth': '1118'}
'name' in a
>>> True
'email' in a
>>> False

 

 

 

2. 집합 : .set()

 

중복을 허용하지 않음.

순서가 없으므로(Unordered), 인덱싱할 수 없음.

인덱싱하기 위해 list(.set()) 혹은 tuple(.set()) 형태로 변형해주어야 함.

중복을 허용하지 않는 특징 때문에 데이터 중복을 제거하기 위한 필터로 사용 가능.

교집합, 차집합, 합집합 구할 때 용이.

 

s1 = set([1, 2, 3])
s1
>>> {1, 2, 3}


s2 = set("Hello")
s2
>>>  {'e', 'H', 'l', 'o'}

 

 

1) 교집합, 합집합, 차집합 구하기

 

s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

 

 

1-1) 교집합 : &  /  .intersection()

 

s1 & s2
>>> {4, 5, 6}

 

s1.intersection(s2)
>>> {4, 5, 6}

 

 

1-2) 합집합 : |  /  .union()

 

s1 | s2
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

 

s1.union(s2)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

 

 

1-3) 차집합 : -  /  .difference()

 

s1 - s2
>>> {1, 2, 3}
s2 - s1
>>> {8, 9, 7}

 

s1.difference(s2)
>>> {1, 2, 3}
s2.difference(s1)
>>> {8, 9, 7}

 

 

2-2. 집합 함수

 

1) 1개의 값 추가 : .add()

: 중복된 값은 오류

 

s1 = set([1, 2, 3])
s1.add(4)
s1
>>> {1, 2, 3, 4}

 

 

2) 2개 이상의 값 추가 : .update()

: 중복된 값은 고유한 값만 남김

 

s1 = set([1, 2, 3])
s1.update([4, 5, 6])
s1
>>> {1, 2, 3, 4, 5, 6}

 

 

3) 특정 값 제거 : .remove()

 

s1 = set([1, 2, 3])
s1.remove(2)
s1
>>> {1, 3}

 

 

 

3. 불

 

참True과 거짓False을 나타내는 자료형.

 

a = True
b = False

 

type(a)
>>> <class 'bool'>
type(b)
>>> <class 'bool'>

 

 

1) 불 연산 : bool()

: 일반적으로 값이 있다면 True, 없다면 False

 

bool('python')
>>> True

 

bool('')
>>> False

 

bool([1, 2, 3])
>>> True
bool([])
>>> False
bool(0)
>>> False
bool(3)
>>> True

 

 

 

4.  변수 : 변수_이름 = 변수에_저장할_값

 

a = 1
b = "python"
c = [1, 2, 3]

 

 

1) 변수의 리스트 복사

 

a = [1, 2, 3]
b = a

: b는 a와 같은 주소를 사용 즉, 값이 동일하다는 의미.

 

a[1] = 4
a
>>> [1, 4, 3]
b
>>> [1, 4, 3]

 

 

1-1) [:] 로 복사

 

a = [1, 2, 3]
b = a[:]
a[1] = 4
a
>>> [1, 4, 3]
b
>>> [1, 2, 3]

: a 전체를 리스트로 복사해 b라는 독립적인 리스트 생성 즉, 주소가 동일하지 않음.

 

1-2) .copy() 함수로 복사

 

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


b is a

>>> False

b == a

>>> False

 

 

2) 변수 만들기

 

2-1) 튜플을 이용해 만들기

 

a, b = 'python', 'life'

>>> a = 'python'

>>> b = 'life'

 

a, b = ('python', 'life')

>>> a = 'python'

>>> b = 'life'

 

(a, b) = 'python', 'life'

>>> a = 'python'

>>> b = 'life'

 

 

2-2) 리스트를 이용해 만들기

 

[a, b] = ['python', 'life']

>>> a = 'python'

>>> b = 'life'

 

2-3) 기타 변수 대입

 

a = b = 'python'

>>> a = 'python'

>>> b = 'python'

 

a = 3
b = 5

a
>>> 5
b
>>> 3
a, b = b, a
a
>>> 5
b
>>> 3

파이썬

 

 

 

 

 

자료형

 

 

 

1. 리스트

 

a = 1 변수가 ' 1이라는 단일 값을 a라는 박스 속에 넣어 준다.'라는 개념이라면,

a  = [1, 2, 3, ..., n] 리스트는 '1, 2, 3, ... n이라는 다수의 값을 a라는 서랍에 넣어 준다. 혹은 포함한다.'의 개념.

 

한개의 리스트 안에 다양한 자료형을 담을 수 있으므로,

리스트 내부의 자료형을 잘 확인해야 함.

 

 

1) 리스트 인덱싱

a = [1, 2, 3]
a
>>> [1, 2, 3]

 

a = [1, 2, 3]
a[1]
>>> 2

 

 

1-2) 다중 리스트 인덱싱

 

_ 이중 리스트

a = [1, 2, 3, ['a', 'b', 'c']]

a[0]
>>> 1
a[-1]
>>> ['a', 'b', 'c']
a[3]
>>> ['a', 'b', 'c']

 

_ 삼중 리스트

a = [1, 2, ['a', 'b', ['Life', 'is']]]

a[2][2][0]
>>> 'Life'

 

a = [1, 'hello', 3]

a[1][1]
>>> 'e'

 

 

2) 리스트 슬라이싱

: 리스트를 범위를 정해 덩어리째로 가져옴.

: a[0:5] => 0이상 5미만 1칸(기본)씩 간격으로

: a[0:5:2] => 0이상 5미만 2칸씩 간격으로

: a[::2] => 앞에서 2칸씩 간격으로

: a[::-2] => 뒤에서 2칸씩 간격으로

 

a = [1, 2, 3, 4, 5]
a[0:2]
>>> [1, 2]

 

a = "12345"
a[0:2]
>>> '12'

 

 

3) 리스트 값 수정

 

a = [1, 2, 3]
a[2] = 4
a
>>> [1, 2, 4]

 

 

4) 리스트 삭제 : del a[]

: 해당 값을 삭제하고 리스트가 다시 만들어짐.

 

a = [1, 2, 3]
del a[1]
a
>>> [1, 3]

 

 

 

1-2. 리스트 관련 함수

 

1) 요소 추가 : .append()

: 리스트.append(값)

: 리스트 안에 괄호 안의 값을 마지막에 추가

 

a = [1, 2, 3]
a.append(4)
a
>>> [1, 2, 3, 4]

 

a.append([5, 6])
a
>>> [1, 2, 3, 4, [5, 6]]

 

 

1-2) 요소 삽입 : .insert()

: 리스트.insert(해당 인덱스 값, 해당 값)

: 해당 값을 리스트 안에 해당 인덱스 값으로 삽입

 

a = [1, 2, 3]
a.insert(0, 4)
a
>>> [4, 1, 2, 3]

 

 

1-3) 확장 : .extend([])

: 리스트.extend([리스트2])

: 리스트 안에 리스트2의 값을 추가

 

a = [1, 2, 3]
a.extend([4, 5])
a
>>> [1, 2, 3, 4, 5]
b = [6, 7]
a.extend(b)
a
>>> [1, 2, 3, 4, 5, 6, 7]

 

a.extend([4, 5])

a += [4, 5]

a = a + [4, 5]

*위 세개는 같은 개념

 

 

2) 정렬 : .sort()

: 숫자 혹은 알파벳 오름차순 정렬 

 

a = [1, 4, 3, 2]
a.sort()
a
>>> [1, 2, 3, 4]

 

 

3) 뒤집기 : .reverse(): 값을 단순히 역순으로 정렬

 

a = ['a', 'c', 'b']
a.reverse()
a
>>> ['b', 'c', 'a']

 

a = ['a', 'c', 'b']

a.sort()
a.reverse()
a
>>> ['c', 'b', 'a']

 

 

4) 인덱스 반환 : .index()

: 리스트.index(값)

: 리스트에 값이 있다면, 해당 값의 위치인 인덱스 값을 반환

 

a = [1, 2, 3]
a.index(3)
>>> 2
a.index(1)
>>> 0

 

 

5) 요소 제거: .remove()

: 리스트.remove(해당 값)

: 리스트에서 첫번째로 나오는 해당 값을 삭제

 

a = [1, 2, 3, 1, 2, 3]
a.remove(3)
a
>>> [1, 2, 1, 2, 3]

a.remove(3)
a
>>> [1, 2, 1, 2]

 

 

 

2. 튜플

 

a  = [1, 2, 3, ..., n] 리스트는 '다수의 값을 a라는 서랍에 넣어 준다. 혹은 포함한다.'의 개념이라면, 

a = (1, 2, 3, ..., n) 튜플은 '다수의 값을 a라는 잠긴서랍에 넣어 둔다. 혹은 포함한다.'의 개념.

 

리스트는 내부 값의 변경이 자유로우나,

튜플은 내부 값을 변경할 수 없음.

 

리스트 함수와 동일하게 사용 가능하나,

변경되는 것이 아닌 또 하나의 튜플이 생성되는 개념.

그러므로 sort, insert, remove, pop과 같은 함수는 사용할 수 없음.

 

 

 

 

_

함수가 언뜻 보기엔 비슷하게 쓰이는 경우가 많아 보인다.

약간 차이가 나는 그 쓰임들을 알아 두어야 한다.

파이썬

 

 

 

 

 

a = 1

: a는 1과 같다는 의미가 아니라, ' 1라는 값을 a라는 상자 속에 넣어 준다. 혹은 포함시킨다.' 는 개념.

* a == 1 : a는 1과 같다.

 

 

 

 

문자열

 

 

 

1. 숫자형

 

1) int와 float

 

int() : 정수

float() : 실수

 

 

2) 사칙연산

 

a + b : 덧셈

a - b : 뺄셈

a * b : 곱셈

a ** b : 제곱

a / b : 나누기

a // b : 몫

a % b : 나머지

 

 

 

2. 문자열 자료형 str()

 

1) 문자열 생성

: 문자들의 배열(list)

: 동일한 따옴표로 시작해서 끝나는 지점까지 문자열 생성

: 문자열 중간에 따옴표를 넣는다면, 서로 다른 따옴표 사용,  *3

 

'hello' : 작은 따옴표

"hello" : 큰 따옴표

'''hello''' : 작은 따옴표 * 3

"""hello""" : 큰 따옴표 *3

 

 

2) 문자열 계산

 

_더하기

a = 'hello'

b = 'stranger!'

a + b

>>> 'hello stranger!'

 

_곱하기

a = 'hello'

a * 2

>>> 'hellohello'

 

 

3)  문자열 길이 구하기 : len()

 

a = 'life is too short'

len(a)

>>> 17

*문자열에 공백 포함

 

 

4) 문자열 인덱싱

: 문자를 한글자씩 가져와, 맨 앞 글자가 0부터 번호index를 붙임.

: 맨 처음부터 끝까지 [0]...[n]

: 맨 마지막부터 역순으로 [-1]...[-n]

 

a = "Life is too short, You need Python"
a[3]
>>> 'e'

* a[3]:'e' : 파이썬의 시각

 

 

5) 문자열 슬라이싱

: 문자를 범위를 정해 덩어리째로 가져옴.

: a[0:5] => 0이상 5미만 1칸(기본)씩 간격으로

: a[0:5:2] => 0이상 5미만 2칸씩 간격으로

: a[::2] => 앞에서 2칸씩 간격으로

: a[::-2] => 뒤에서 2칸씩 간격으로

 

a = "20230331Rainy"
date = a[:8]
weather = a[8:]
print('date')
>>> '20230331'
print('weather')
>>> 'Rainy'

 

 

6-1) 문자열 포매팅

: 숫자 대입 : %d

 

"I eat %d apples." % 3
>>> 'I eat 3 apples.'

 

: 숫자를 변수로 대입

 number = 3
"I eat %d apples." % number
>>> 'I eat 3 apples.'

 

: 소숫점 대입 : %f

"I eat %0.4f apples." % 0.12345678
>>> 'I eat 0.1234 apples.'

=> 소숫점 넷째자리까지 표시

 

"I eat %.2f apples." % 0.12345678
>>> 'I eat 0.12 apples.'

=> 소숫점 둘째자리까지 표시

 

: 문자 대입 : %s

: 문자열은 문자와 숫자 모두 수용

"I eat %s apples." % "five"
>>> 'I eat five apples.'

 

"I eat %s apples." % 3
>>> 'I eat 3 apples.'

: 2개 이상의 값 대입

number = 10
day = "three"
"I ate %d apples. so I was sick for %s days." % (number, day)
>>> 'I ate 10 apples. so I was sick for three days.'

 

 

6-2) 문자열 포매팅 format함수

: {0}.format(b)

: 0를 b로 대체

 

: 숫자 대입

"I eat {0} apples.".format(3)
>>> 'I eat 3 apples.'

 

: 숫자를 변수로 대입

number = 10

"I eat {0} apples.".format(number)
>>> 'I eat 10 apples.'

 

: 문자 대입

"I eat {0} apples.".format('five')
>>> 'I eat five apples.'


: 2개 이상의 값 대입

number = 10
day = "three"
"I ate {0} apples. so I was sick for {1} days.".format(number, day)
>>> 'I ate 10 apples. so I was sick for three days.'

 

: name=value 값으로 대입

"I ate {number} apples. so I was sick for {day} days.".format(number=10, day='three')
>>> 'I ate 10 apples. so I was sick for three days.'

 

: 혼용

"I ate {0} apples. so I was sick for {day} days.".format(10, day='three')
>>> 'I ate 10 apples. so I was sick for three days.'

 

 

6-2) 가장 간단한 f 문자열 포맷팅

: 포매팅하려는 문자 앞에 f

name = '홍길동'
age = 30
f'나의 이름은 {name}입니다. 나이는 {age}입니다.'
>>> '나의 이름은 홍길동입니다. 나이는 30입니다.'

 

: 딕셔너리 형태로 key:value를 한쌍으로 포맷팅

d = {'name':'홍길동', 'age':30}
f'나의 이름은 {d["name"]}입니다. 나이는 {d["age"]}입니다.'
>>> '나의 이름은 홍길동입니다. 나이는 30입니다.'

 

 

7) 문자열 바꾸기 : .replace()

 a = "Life is too short"
a.replace("Life", "Your leg")
>>> 'Your leg is too short'
=> 'Life'라는 key값에 'Your leg'라는 value를 넣음

 

 

8)문자열 나누기 : .split()

a = "Life is too short"
a.split()
>>> ['Life', 'is', 'too', 'short']

=> 괄호 안의 공백을 기본으로 나눔

 

b = "a:b:c:d"
 b.split(':')
>>> ['a', 'b', 'c', 'd']

 

 

 

 

 

_

교재를 전달 받아 앞부분부터 복습한다는 생각으로 훑는데,

정리를 해 두자니 시간이 제법 걸린다.

+ Recent posts