[패스트 캠퍼스] 데이터 분석 부트캠프(BDA) 11기 3주차

📌Python으로 하는 데이터분석 

 

🙋🏻‍♀️ 오늘부터 Python 수업 시작!

3~4주간 진행될 강의를 이끌어주실 김상모 강사님과의 첫 수업은 5점 만점 중에 5점👍

프로그래밍 문제를 포함하여 간단한 설문조사를 시작하며 수업이 시작되었는데 파이썬을 안 한 지 반년이 지나서 오랜만에 코드작성 하려 하니깐 기본적인 문법조차 생각이 안났다... 리스트에 추가하는 append가 생각이 안나다니..! 지난 2학기 동안(한번 수업 드롭하고 재수강함..ㅎ) 내가 어떻게 15112를 들었는데ㅠㅠ 고작 몇 개월 안 했다고 잊어버리는 이런🤪 역시 코딩은 손을 놓으면 안 된다는 다른 분들의 말씀 하나도 틀린 것 없다.. 파이썬 수업을 시작으로 부트캠프가 끝날 때까지 매일은 아니더라도 조금씩 코드연습을 해야겠다..!

 

 

 

목차

1. 파이썬 기본 문법

2. 시퀀스 자료형(리스트, 튜플, range, 문자열), 딕셔너리

3. 인덱스, 슬라이싱

4. 반복문, 조건문

 

 

< 파이썬 기본 문법 >

 

✔ 진법 (수의 체계)

✔ 컴퓨터의 기본 구조

✔ 파이썬 프로그래밍 개요

✔ 파이썬 기본 문법

 

 

✔ 진법 (수의 체계) 

>> 2진법 (Binary System)

• 0과 1로 나타냄
• 각 자리는 2의 거듭제곱
• 1011(2) = 1 x 2^3 + 0 x 2^2 + 1 x 2^1 + 1 x 2^0

 

>> 10진법 (Decimal System)

• 0부터 9까지 총 10개의 숫자를 사용하여 수를 나타냄

 

>> 16진법 (Hexadecimal System)

• 0부터 9까지 숫자와 A부터 F까지의 알파벳을 사용하여 수를 나타냄
• 각 자리는 16의 거듭제곱으로 표현

 

 

---

 

 

✔ 컴퓨터의 기본 구조 

>> CPU (Central Processing Unit, 중앙처리장치)

• PU는 컴퓨터에서 연산과 제어를 담당하는 핵심 부품. 프로그램의 명령을 해석하고 실행하여 원하는 작업을 수행
• CPU는 주기억장치(메모리)에 저장된 명령어와 데이터를 읽어와 계산하며, 프로그램의 로직을 처리
• 프로그램은 CPU가 처리할 수 있는 명령어로 작성되며, CPU는 이러한 명령어를 순차적으로 실행하여 프로그램을 수행

 

>> Memory (주기억장치)

• 메모리는 CPU가 사용하는 데이터와 명령어를 저장하는 공간. 프로그램이 실행될 때 필요한 데이터, 변수, 그리고 프로그램 코드 등이 메모리에 저장
• 메모리는 빠른 읽기와 쓰기 속도를 제공하여 CPU가 빠르게 데이터에 접근하고 처리할 수 있도록 함. 프로그램이 종료되면 메모리에 저장된 데이터는 삭제됨
• 메모리는 주기억장치(RAM)와 보조기억장치(하드 드라이브, SSD 등)로 나뉨. 주기억장치는 CPU가 직접 접근할 수 있는 고속의 메모리이며, 보조기억장치는 데이터를 장기간 보존할 수 있는 저장소

 

>> Storage (저장장치)

• 저장장치는 데이터를 장기적으로 저장하는 역할. 프로그램, 파일, 이미지, 비디오 등 모든 종류의 데이터는 저장장치에 저장
• 저장장치는 주로 하드 디스크 드라이브(HDD)나 SSD(고체 상태 드라이브)로 나타냄. 이러한 장치들은 데이터를 읽고 쓰는 데 시간이 조금 더 걸리지만, 대용량의 데이터를 오랫동안 보존할 수 있는 특성이 있음

 

 

---

 

 

✔ 파이썬 프로그래밍 개요 

>> Python

• 간결한 문법: 파이썬은 간결하고 읽기 쉬운 문법을 가지고 있어 초보자도 쉽게 배울 수 있음
• 인터프리터 언어: 코드를 컴파일하지 않고 바로 실행할 수 있음 => 빠르게 프로그램을 개발하고 테스트할 수 있음
• 객체지향 및 함수형 프로그래밍 지원: 객체지향 프로그래밍과 함수형 프로그래밍을 모두 지원하여 다양한 프로그래밍 스타일을 사용 가능
• 풍부한 라이브러리: 다양한 목적에 맞는 라이브러리가 풍부하게 제공되어 있어 개발 시간을 단축할 수 있음

 

 

---

 

 

✔ 파이썬 기본 문법

>> print() 

print('single quotes')
print("double quotes")
print('''triple single quotes''')
print("""triple double quotes""")
print('문장 안에 "쌍따옴표" 사용하기')

print(" Double quote: \" ") 		# Double-quote: "
print(" Blackslahs: \\ ")		# Bakslash: \
print(" Newline: [\n] ") 		# Newline: [
					# ]
print("Tab: [\t]")			# Tab: [	]

# -----------------------------------------------------
# 구분자 sep (separation)
print("A", "B", "C", sep='/')	# A/B/C
print(1, 2, 3, sep=', ')	# 1, 2, 3

# end
print(1, end="")
print(2, end="")
print(3)
# printout => 123

print("a", end=", ")
print("b", end=", ")
print("c")
# printout => a, b, c

# -----------------------------------------------------
# 문자열 Formatting
food = "banana"
print(f"I ate {food} today.")	# I ate banana today.

x, y, z = 11, 22, 33
print("My favorite numbers are {0}, {1} and {2}.".format(x,y,z))	
# => My favorite numbers are 11, 22 and 33.

apple = 42
print("There are %d apples." %apple)	# There are 42 apples.

 

 

>> input() 

• 사용자의 입력을 받음 → 입력되는 것은 모두 문자열 형태로 저장
• 입력을 숫자로 처리하고 싶다면 int( ) 함수를 사용해서 정수로 변환

elem = input("숫자를 입력하세요: ")
elem
>> 숫자를 입력하세요: 333
>> '333'

age = int(input("나이를 입력하세요: "))
age
>> 나이를 입력하세요: 12
>> 12

 

 

>> 문자열 나누기 .split()

# .split()
str = 'a b c d e f g'
res = str.split() 
print(res)		# ['a', 'b', 'c', 'd', 'e', 'f', 'g']


# .split(separator)
str = 'a, b, c, d, e, f, g'
res2 = str.split(",")
print(res2)		# ['a', ' b', ' c', ' d', ' e', ' f', ' g']


# .split(separator, maxsplit)
str = 'a, b, c, d, e, f, g'
res3 = str.split(",", 3)
print(res3)		# ['a', ' b', ' c', ' d, e, f, g']

res4 = str.split(sep=",", maxsplit=3)
print(res4)		# ['a', ' b', ' c', ' d, e, f, g']

 

 

>> map()

• map(function, iterable_sequence)
• 여러 변수에 대한 값을 한 번에 입력받는 다중 할당 가능

L = ['1', '2']
a, b = map(int, L)
print(a, b) 	# 1 2

x, y, z = map(int, input().split())
print(x, y, z)	# 입력: 1 2 3 => output: 1 2 3

 

 

 

>> 변수 자료형

: str, int, float, list, tuple, set, dict

print(type(2))           # <class 'int'>
print(type(2.2))         # <class 'float'>
print(type(2 < 2.2))     # <class 'bool' (boolean)>
print(type(type(42)))    # <class 'type'>

print(type("2.2"))       # <class 'str'>
print(type([1,2,3]))     # <class 'list'>
print(type((1,2,3)))     # <class 'tuple'>
print(type({1,2}))       # <class 'set'>
print(type({1:42}))      # <class 'dict' dictionary or map>
print(type(2+3j))        # <class 'complex'>

 

 

>> ASCII (American Standard Code for Information Interchange)

출처:&nbsp;https://www.w3resource.com/python-exercises/python-basic-exercise-86.php

• ord() : char --> int
• chr() : int --> character

print(ord("A"))			# 65
print(chr(65))			# A
print(chr(ord("A")+1)		# B

 

 

>> 연산자(Operators)

# Some Builtin Operators

'''
Arithmetic: +, -, *, /, //(quotient), **(square), %(remainder), -(unary), +(unary)
Relational: <, <=, >=, >, ==(equal), !=(unequal)
Assignment: +=, -=, *=, /=, //=, **=, %=, <<=, >>=
   			 e.g. c//a -> c = c//a
Logical: and, or, not
Boolean: True, False
'''

# / => 'normal' float division
print("5/3 = ", (5/3))		# 5/3 = 1.6666666666666667


# // => integer division
print(" 5//3 =", ( 5//3))	# 5//3 = 1
print(" 2//3 =", ( 2//3))	# 2//3 = 0
print("-1//3 =", (-1//3))	# -1//3 = -1
print("-4//3 =", (-4//3))	# -4//3 = -2


# Modulus (remainder operator %)
print(" 6%3 =", ( 6%3)) 	# 0
print(" 5%3 =", ( 5%3)) 	# 2
print(" 2%3 =", ( 2%3)) 	# 2
print(divmod(5, 2))		# (2, 1) = (몫, 나머지)

 

 

 

 

 

---

 

 

 

< 시퀀스자료형, 딕셔너리 >

: 리스트, 튜플, range, 문자열은 모두 시퀀스(sequence) 자료형으로 분류됨

✔ 리스트

✔ 튜플

✔ 인덱스 & 슬라이싱

✔ 딕셔너리

 

 

✔ 리스트 (List, 1D) 

>> List = [elem1, elem2, elem3, ... ]

• 변수에 값을 저장할 때 대괄호 [ ] 로 묶어주면 리스트가 되며 각 값은 콤마(,)로 구분
• range(start, stop, step)

# 1. 
L1 = list(range(10))
L1 					# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 2.  
L2 = list(range(1, 10))
L2 					# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 3.
L3 = list(range(-4, 10, 2))
L3					# [-4, -2, 0, 2, 4, 6, 8]

# 4. 
L4 = list(range(5, 0, -1))
L4 					# [5, 4, 3, 2, 1]

 

 

---

 

 

✔ 튜플 (Tuple) 

>> tuple = (elem1, elem2, elem3, ... )

• 리스트처럼 여러 값을 저장할 수 있음
• BUT!! 안에 저장된 요소를 변경, 추가, 삭제 할 수 없음 => immutable lists
• 변수에 값을 저장할 때 괄호 ( )로 묶어주고, 괄호로 묶지 않고 콤마로만 구분해도 튜플이 됨.

t1 = (38, 21, 53, 62, 19)
t1	# (38, 21, 53, 62, 19)


t2 = tuple(range(-4, 10, 2))
t2	# (-4, -2, 0, 2, 4, 6, 8)

 

 

---

 

 

✔ 인덱스 & 슬라이싱 

>> Index

• 시퀀스 객체의 각 요소는 순서가 정해져 있으며, 이 순서를 인덱스라고 부름
• 시퀀스 객체에 [ ]를 붙이고 안에 각 요소의 인덱스를 지정하면 해당 요소에 접근할 수 있음
• 음수 인덱스: 리스트 뒤에서부터 요소에 접근, 마지막 리스트 요소에 대해 -1로 시작해서 왼쪽으로 한 칸씩 감소
• 인덱스 범위를 벗어나면 IndexError 발생
• 요소에 값 할당/삭제하기 --> 리스트는 가능 vs. 튜플, range, 문자열은 변경 X

 

 

 

>> Slicing

→→ 시퀀스객체[start:end:step]

• 리스트 슬라이싱

L = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

L[:] # 리스트 전체

L[:4] # 처음부터 3번째까지
>> [0, 10, 20, 30]

L[2:5] # 2번째부터 4번째까지
>> [20, 30, 40]

L[1:9:2] # 1번째부터 8번째까지 2간격으로
>> [10, 30, 50, 70]

L[:-1] # 처음부터 마지막-1까지
>> [0, 10, 20, 30, 40, 50, 60, 70, 80]

L[4:-1] # 4번째부터 마지막-1까지
>> [40, 50, 60, 70, 80]


r = range(10)
r
>> range(0, 10)

r[4:7] # 인덱스 4부터 6까지 3개 생성
>> range(4, 7)

r[4:] # 인덱스 4부터 끝까지
>> range(4, 10)

r[:7:2] # 인덱스 처음부터 6까지 step 2씩
>> range(0, 7, 2)

 

 

• 슬라이스 요소 할당 ⇒ 증가폭을 지정했을 때 슬라이스 범위의 요소 개수와 할당할 요수 개수가 정확히 일치해야함

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:5] = ['a', 'b', 'c']
a
>> [0, 10, 'a', 'b', 'c', 50, 60, 70, 80, 90]


a[2:8:2] = ['a', 'b', 'c'] # index 2부터 2씩 증가
a
>> [0, 10, 'a', 30, 'b', 50, 'c', 70, 80, 90]

 

• 슬라이스 요소 삭제

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
del a[2:5]
a
>> [0, 10, 50, 60, 70, 80, 90]

 

 

---

 

 

✔ 딕셔너리 (Dictionary) 

>> dict(key1=value1, key2=value2, ... )

• 키(key)와 값(value)의 쌍으로 데이터를 저장하는 구조
• 중괄호{ }를 사용하며 각 키와 값은 콜론(:)으로 구분됨
• 키는 immutable, 값은 mutable or immutable  (Note: 딕셔너리 자체는 mutable)

# 1. dict(key1=value1, key2=value2)
d = dict(a=1000, b=700)
d
>> {'a': 1000, 'b': 700}


# 2. dict(zip([key1, key2, ...], [value1, value2, ...])
d = dict(zip(['health', 'mana', 'melee', 'armor'], [490, 334, 550, 18.72]))
d
>> {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

# 3. dict([key1,value1), (key2, value2)])
d = dict([('a',1000), ('b', 700)])
d
>> {'a': 1000, 'b': 700}

 

• 키와 값 추출
• 딕셔너리에 value 추가 -- dict.update()
• 키가 있는지 확인 -- in
• 키 개수 구하기 -- len()

# 키와 값 추출
fruit = {'apple':1000,
        'banana':700,
        'orange':1500,
        'pineapple':2000}

keys = fruit.keys()		# dict_keys(['apple', 'banana', 'orange', 'pineapple'])
values = fruit.values()		# dict_values([1000, 700, 1500, 2000])


d = dict(zip(['health', 'mana', 'melee', 'armor'], [490, 334, 550, 18.72]))
d		# {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
d['health']	# 490


# 값 추가
dictionary = {key1:value1, key2:value2, key3:value3}
dictionary.update({key4:value4, key5:value5})

# 키 확인
lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
'health' in lux			# True
'atttack_speed' in lux 		# False

# 키 개수 구하기
len(lux) 		# 4

 

 

 

 

 

---

 

 

 

< 반복문, 조건문 >

 

✔ 조건문 if

✔ 반복문 for

✔ 반복문 while

✔ break, continue

 

 

✔ 조건문 IF 

• if 조건문은 조건식을 지정하고 콜론(:)을 붙이며 다음 줄에 실행할 코드가 옴
• 이때, 실행할 코드는 반드시 들여쓰기(indentation) 해야함

if condition:
	# code

 

>> if-else

if condition:
	# <statement>
	# <statement>

else:
	# <statement>

 

>> if-elif-else

if condition:
	# <statement>
	# <statement>

elif condition:
	# <statement>
    
else:
	# <statement>

 

 

---

 

 

✔ 반복문 for

• 조건에 따라 반복 작업을 수행해야 할 때 사용하는 statement
• 횟수에 따른 반복 수행
• 특정 횟수를 지정할 수도 있고, list와 같은 시퀀스를 처음부터 끝까지 반복할 수도 있음

 

 

✔ 반복문 while

• 조건에 따라 반복 수행
• 특정 횟수를 반복하는 것이 아닌 조건의 만족 여부에 따라 반복 수행
• 조건을 만족할 때 까지 반복
• 무한루프 주의!

 

✔ break & continue

• break - 반복문을 강제로 종료시키고 반복문을 빠져나오게함
• continue - 반복문을 중단하고 다음 반복으로 넘어감. continue문이 실행되면 반복문의 나머지 부분은 실행되지 않음

for n in range(200):
    if (n % 3 == 0):
        continue    # skips rest of this pass
    elif (n == 8):
        break       # skips rest of entire loop
    else:
        pass        # does nothing. pass is a placeholder, not needed here
    print(n, end=" ")
    
print()     # 1 2 4 5 7