Part 1. 데이터 분석을 위한 준비 운동
I. 파이썬 기초 - 변수
1. 변수
1-1. 정의
▶ 데이터를 저장하고 추후에 사용할 수 있게 해주는 저장 공간
▶ 이름과 값으로 구성
▶ 이름은 변수를 참조할 때 사용되고 값은 실제 데이터를 의미
- 변수는 왜 필요할까?
같은 숫자들로 여러 연산을 하고 싶을 때, 값을 변수에 저장하여 재사용하면 편리함.
- 변수 만드는 방법
변수이름 = 저장할 값
파이썬에서 '='는 변수를 저장할 때 사용하고, 등호는 '=='를 이용함.
- 변수는 변한다.
변수는 공간이다.
그 공간에 새로운 값을 할당하면 새로운 값으로 변경된다.
- 변수를 만드는 추가적인 방법
a, b = a에 저장할 값, b에 저장할 값 : 한 줄에 여러 개의 변수를 만들 수 있다.
a = b = 저장할 값 : a와 b에 같은 값이 저장된다.
1-2. 변수 이름 규칙
- 영문자 + 숫자(혹은 언더바 _)의 형식을 사용한다.
ex) a, a1, data1, data_12
- 주의할 점
숫자가 맨 앞에 오면 안된다.
언더바 외 특수문자가 들어가면 안된다.
공백이 들어가면 안된다.
소문자와 대문자는 구분되어 사용된다.
ex) 에러가 나는 변수 선언
1a = 100 >>> SyntaxError
a@1 = 100 >>> SyntaxError
a 1 = 100 >>> SyntaxError
a = 10
A = 100
print(a)
print(A)
>>> 10
>>> 100
1-3. 변수의 종류
변수의 종류를 자료형이라고 부른다.
많이 사용 하는 자료형들의 종류
숫자형
문자형
리스트(list)
튜플(tuple)
딕셔너리(dict)
집합(set)
a = 1 #숫자형(정수)
b = 0.1 #숫자형(실수)
c = "Hello, World" #문자형
d = [1,2,"Hello, World", b] #리스트(list)
e = (1,2,3,'a') #튜플(tuple) #소괄호사용
f = {'a':1, 'b':2} #딕셔너리(dict) #중괄호사용
g = {1,2,3,3} #집합(set) #중괄호사용
for i in [a,b,c,d,e,f,g]:
print(i)
print(type(i))
print()
>>> 1
>>> <class 'int'>
>>> 0.1
>>> <class 'float'>
>>> Hello, World
>>> <class 'str'>
>>> [1, 2, 'Hello, World', 0.1]
>>> <class 'list'>
>>> (1, 2, 3, 'a')
>>> <class 'tuple'>
>>> {'a': 1, 'b': 2}
>>> <class 'dict'>
>>> {1, 2, 3}
>>> <class 'set'>
1-4. print함수
▶ 결과물을 출력하는 함수
▶ print(변수 or 출력하고 싶은 결과물)
print("Hello, World")
print(100/1000)
a = 'ABCDEFG'
print(a)
>>> Hello, World
>>> 0.1
>>> ABCDEFG
- 여러 값을 한 줄에 출력
print("Hello, World", 100/1000, a) #sep 옵션이 없으면 디폴트로 공백(" ")
print("Hello, World", 100/1000, a, sep=' | ')
print("Hello, World", 100/1000, a, sep='\n') # \n은 줄바꿈을 의미
>>> Hello, World 0.1 ABCDEFG
>>> Hello, World | 0.1 | ABCDEFG
>>> Hello, World
0.1
ABCDEFG
- 여러 번 호출을 한 줄에 출력 ( , end=', ') 사용
print("Hello, World", end=', ')
print(100/1000, end=', ')
a = 'ABCDEFG'
print(a)
>>> Hello, World, 0.1, ABCDEFG
II. 파이썬 기초 – 숫자형(Number)
1. 숫자형(Integer, int)
1-1. 정의 : 숫자 형태로 이루어진 자료형
1-2. 종류 :
-정수형 (int) : 123, -123, 0
-실수형 (float) : 100.5, -100.5, 10e3, 10.e5
1-3. 예제
예제-1 (정수형)
A=123
print(a)
print(type(a))
>>> 123
>>> <class ‘int’>
예제-2 (정수형)
A=-123
print(a)
print(type(a))
>>> 123
>>> <class ‘int’>
예제-3 (실수형)
A=10.5
print(a)
print(type(a))
>>> 10.5
>>> <class ‘float’>
예제-4 (실수형)
A=10e3
print(a)
print(type(a))
>>> 10000.0
>>> <class ‘float’>
1-4. 사칙연산
a = 3
b = 4
print(a + b)
print(a - b)
print(a * b)
print(a / b) # 정수 나누기 정수는 타입이 실수(float)으로 바뀜
>>> 7
>>> -1
>>> 12
>>> 0.75
1-5. 다른연산
print(a ** b) # 제곱
print(a % b) # 나눗셈 후 나머지
print(a // b) # 나눗셈 후 몫
>>> 81
>>> 3
>>> 0
a == b # a와 b는 같다
>>> False
a + 1 == b #a와 b는 같다
>>> True
1-6. 할당연산
- 변수 a는 10의 값을 가질 때, 변수 a에 1을 더해서 a에 덮어씌우려면?
예제-1
a = 10
print(a)
a = a + 1
print(a)
>>> 10
>>> 11
예제-2
a = 10
print(a)
a += 1 # a = a + 1
print(a)
>>> 10
>>> 11
- 다른 사칙연산도 마찬가지로 계산할 수 있다.
예제-3
a = 10
print(a)
a += 1
print(a)
a -= 1
print(a)
a *= 2
print(a)
a /= 2
print(a)
>>> 11
>>> 10
>>> 20
>>> 10.0
III. 파이썬 기초 – 문자형(String)
1. 문자형(String) 기본 사용법
1-1. 문자형 생성
▶ 문자 형태로 이루어진 자료형
▶ 큰 따옴표 " " 혹은 작은 따옴표 ' '로 감싸주면 문자열이 된다.
a = 'Hello World'
print(a)
a = "Hello World"
print(a)
>>> Hello World
>>> Hello World
- print()와 셀에서 변수 출력의 차이
print함수로 출력시 : 따움표 없이 출력됨.
>>> Hello World
셀에서 변수 직접 출력시 : 따움표로 감싸져서 출력됨.
>>> 'Hello World'
- 큰 따옴표와 작은 따옴표를 혼용하면 에러가 난다.
- 문자열 안에 따옴표를 넣고 싶으면?
a = '"Hello, World"'
print(a)
a = "'Hello, World'"
print(a)
>>> "Hello, World"
>>> 'Hello, World'
a = '\'Hello, World\''
print(a)
a = "\"Hello, World\""
print(a)
>>> 'Hello, World'
>>> "Hello, World"
- 여러 줄을 하나의 변수에 넣고 싶으면?
a = '''
Hello, World
Hello, Python
'''
print(a)
a = """
Hello, World
Hello, Python
"""
print(a)
>>> Hello, World
Hello, Python
>>> Hello, World
Hello, Python
a = 'Hello, World\nHello, Python' # \n : 줄바꾸기
print(a)
>>> Hello, World
Hello, Python
1-2. 문자열 연산
a = 'Hello, World'
b = 'Hello, Python'
c = a + b
print(c)
>>> Hello, WorldHello, Python
a = 'Hello, World'
b = 'Hello, Python'
c = a + ' ' + b
print(c)
>>> Hello, World Hello, Python
a = 'Python'
print(a * 2)
>>> PythonPython
print('-' * 50)
print(a)
print('-' * 50)
>>> --------------------------------------------------
>>> Python
>>> --------------------------------------------------
1-3. 문자열과 숫자형의 혼용
- 문자열과 숫자형을 더하면 에러가 납니다.
- 숫자형을 문자열으로 변형한 후 더해주어야 합니다.
- str(숫자형 변수)
a = 'Number'
b = 7
print(a, b)
>>> Number 7 # 숫자형, 문자형 혼용 출력 가능하다.
print(a + b)
>>> TypeError : 문자형과 숫자형을 더할 수 없다.
print(a + str(b)) # 숫자형을 문자형으로 변경한 후 더할 수 있다.
>>> Number 7
- 숫자형을 문자열로 변환할 수 있는 것처럼, 문자열도 숫자형으로 변환할 수 있습니다.
정수형: int
실수형: float
a = "12345" # 변수의 문자형 선언
print(int(a) + 1) # 문자를 정수로으로 변경
>>> 12346
a = "12345.123" #변수의 문자형 선언
print(float(a) + 1) # 문자를 실수로 변경
>>> 12346.123
- 변환할 수 없는 경우에는 에러가 납니다.
a = 'abcd12'
int(a)
>>> ValueError #속성이 문자인 변수를 정수로 변경이 불가능하여 에러남.
a = '1234.5'
int(a)
>>> ValueError #속성이 실수인 변수를 정수로 변경이 불가능하여 에러남.
1-4. 문자형 결합
▶ 문자열 결합 : 문자열을 결합(Concatenation)하려면 + 연산자를 사용한다.
greeting = "Hello, "
name = "Alice"
message = greeting + name
print(message)
>>> Hello, Alice
1-5. 문자형 반복
▶ 문자열을 반복하려면 * 연산자를 사용한다.
text = "Python! "
print(text * 3)
>>> Python! Python! Python!
2. 문자형 인덱싱과 슬라이싱
2-1. 인덱싱
- 문자열의 각 문자는 인덱스로 접근할 수 있다. 0부터 시작하며, 음수 인덱스는 뒤에서 부터 접근한다.
- 공백도 한 칸을 차지한다.
ex) 변수[시작 인덱스:끝 인덱스:간격]
a = 'Hello, World' (0 1 2 3 4 5 _ 6 7 8 9 10 : 인덱스 번호)
print(a[0]) # H
print(a[-1]) # d (뒤에서 첫 번째)
print(a[5]) # ,
>>> H
>>> d # (뒤에서 첫 번째)
>>> ,
2-2. 슬라이싱 : 문자열의 부분을 출력할 때 사용한다. [start:end:step] 형태를 사용한다.
print(a[:]) # 전체출력
print(a[3:7]) # 3번째자리부터 6번째자리까지 (3번째 부터 7번째 미만)
print(a[:-1]) # 젤 뒷자리 앞쪽에 있는것 모두 (젤 쉿것은 제외됨)
print(a[-5:]) # -5번째 부터 뒤로 전부
>>> Hello, World
>>> lo,
>>> Hello, Worl
>>> World
print(a[::2]) # 처음부터 (첫자리수 포함한) 두칸에 한개씩 출력
print(a[1:-1:3]) # 두번째자리수 부터 젤뒤에서 두번째까지 구간중 3칸에 한개씩출력
>>> Hlo ol
>>> eoWl
print(a[::-1]) #문자열 전체를 뒤집을 때 사용
>>> dlroW ,olleH
3. 문자열 함수
3-1. 문자열 길이 확인
len( ) : 문자열의 길이를 반환
text = "Hello, Python!"
print(len(text)) # 14
3-2. 대소문자 변환
upper( ) : 문자열을 대문자로 반환
lower( ) : 문자열을 소문자로 반환
capitalize( ) : 첫 글자만 대문자로 변환
text = "hello world"
print(text.upper()) # HELLO WORLD
print(text.lower()) # hello world
print(text.capitalize()) # Hello world
3-3. 문자열 검색
find(sub) : 특정 문자열의 시작위치 반환 (없으면 -1을 반환)
count(sub) : 특정문자열이 몇 번 등장하는지 반환
text = "hello world, hello Python"
print(text.find("world")) # 6
print(text.find("Java")) # -1
print(text.count("hello")) # 2
3-4. 문자열 교체
replace( ) : 특정 부분 문자열을 다른 문자열로 교체
text = "I like Python"
new_text = text.replace("Python", "Java")
print(new_text) # I like Java
3-5. 문자열 분리와 결합
split(delimiter) : 특정 구분자를 기준으로 문자열을 나눔
join(iterable) : 리스트 같은 반복 가능한 객체를 문자열로 결합
# split 예제
text = "apple,banana,cherry"
fruits = text.split(",") # 리스트로 반환
print(fruits) # ['apple', 'banana', 'cherry']
# join 예제
fruits_list = ['apple', 'banana', 'cherry']
result = " ".join(fruits_list)
print(result) # apple banana cherry
3-6. 공백제거
lstrip( ), rstrip( ), strip( ) : 공백 제거한 값을 출력
text = " Hello, World! "
print(text.strip()) # "Hello, World!"
3-7. 문자열 포함 여부
in, not in : 특정 문자열이 포함되어 있는지 확인한다.
text = "Hello, Python"
print("Python" in text) # True
print("Java" not in text) # True
4. 문자열 포맷팅
▶ 문자열 안에 어떤 값을 삽입하는 방법
▶ 파이썬에서는 문자열을 동적으로 구성하기 위한 다양한 포맷팅 방법을 제공한다.
4-1. format( ) 사용
num = 14
a = 'My favorite number is { }'.format(num)
print(a)
>>> My favorite number is 14
4-2. f-string 사용
num = 14
a = f'My favorite number is {num}' # 이방법을 많이 사용한다.(사용편리) # 중괄호 사용
print(a)
>>> My favorite number is 14
num1 = 14
num2 = 17
a = f'My favorite numbers are {num1} and {num2}'
print(a)
>>> My favorite number are 14 and 17
color = 'blue'
a = f'My favorite color is {color}'
print(a)
>>> My favorite color is blue
- 참고
a = 'pie'
a.upper( ) # 결과물을 출력하는 역할 (변수의 값은 변화시키지 않음)
>>> PIE
- 문자열 함수들은 변수의 값을 변경하는 것이 아니라 함수의 결과물을 출력하는 역할을 하므로,
변수의 값을 변경하고 싶으면 변수에 값을 덮어씌워 주어야 한다.
print(a)
>>> pie
a = a.upper( ) # 변수의 값을 변경
print(a)
>>> PIE
a = a.lower( )
print(a)
>>> pie
IV. 파이썬 기초 – 리스트형(List)
▶ a, b, c, d, e를 한번에 담을 수는 없을까? 하는 생각에서 나온 자료형 ⇒ 즉, 여러 개의 데이터를 하나의 변수에 저장 할 수 있다.
▶ 리스트를 만들려면 대괄호([ ])로 감싸고, 각 요소들 사이에 콤마(,)를 넣는다.
▶ 각각의 값은 서로 다른 자료형도 가능하다.
Ex)
x = [“a”, “b”, “c”, “d”, “e”]
x = [“Hello”, “Python”]
x = [1, 2, 3, [“a”, “b”]]
1. 리스트의 주요 특징
1-1. 순서가 있다 (Ordered) :
- 리스트는 순서를 유지하며, **인덱스(index)**를 통해 각 값에 접근할 수 있다.
# 요소 읽기
my_list = [10, 20, 30, 40] # 0부터 시작
print(my_list[0]) # 10
my_list = [10, 20, 30, 40] # 양수 인덱스
print(my_list[2]) # 30
my_list = [10, 20, 30, 40] # 음수 인덱스
print(my_list[-1]) # 40
# 요소 수정
my_list = [10, 20, 30, 40] # 0부터 시작
my_list[1] = 25
print(my_list) # [10, 25, 30, 40]
1-2. 변경 가능 (Mutable) :
- 리스트의 값은 생성 후에도 변경 가능하다.
1-3. 중복 허용:
- 동일한 값을 여러 번 중복 포함 가능하다.
1-4. 다양한 자료형 포함 가능:
- 정수, 문자열, 리스트 등 혼합된 자료형을 저장할 수 있다.
2. 리스트 생성 및 기본 사용법
2-1. 리스트 생성
1) 빈 리스트 생성
empty_list = [ ]
2) 값이 있는 리스트 생성
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "apple", 3.14, [2, 4, 6]]
print(fruits) # ['apple', 'banana', 'cherry']
print(numbers) # [1, 2, 3, 4, 5]
print(mixed) # [1, 'apple', 3.14, [2, 4, 6]]
3. 리스트 인덱싱과 슬라이싱
3-1. 인덱싱
- 특정 위치의 값을 가져옴 (0부터 시작).
fruits = ["apple", "banana", "cherry", "date"]
print(fruits[0]) # apple
print(fruits[-1]) # date (뒤에서 첫 번째)
3-2. 슬라이싱
- 리스트의 일부를 잘라냄.
print(fruits[1:3]) # ['banana', 'cherry']
print(fruits[:2]) # ['apple', 'banana'] (처음부터 2번째까지)
print(fruits[::2]) # ['apple', 'cherry'] (2칸씩 건너뜀)
4. 리스트 주요 메서드
4-1. 값 추가
1) append(value) : 리스트의 끝에 값을 추가한다.
fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits) # ['apple', 'banana', 'cherry']
2) insert(index, value) : 특정 위치에 값을 삽입한다.
fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits) # ['apple', 'orange', 'banana', 'cherry']
4-2. 값 제거
1) remove(value) : 지정된 값을 제거한다.
fruits = ["apple", "banana", "cherry", "date"]
fruits.remove("banana")
print(fruits) # ['apple', 'cherry', 'date']
2) pop(index) : 지정된 인덱스의 값을 제거 후 반환한다. (인덱스를 생략하면 마지막 값을 제거함)
fruits = ["apple", "cherry", "date"]
last_fruit = fruits.pop( )
print(last_fruit) # date # 마지막값을 추출하여 반환한다.
print(fruits) # ['apple', 'cherry']
3) clear( ) : 리스트의 모든 값을 제거한다.
fruits = ["apple", "cherry"]
fruits.clear()
print(fruits) # [ ]
4-3. 값 검색
1) index(value) : 특정 값의 인덱스를 반환한다.
fruits = ["apple", "banana", "cherry", "apple"]
print(fruits.index("apple")) # 0 (첫 번째 'apple'의 위치)
2) count(value) : 특정 값이 리스트에 몇 번 등장하는지 반환한다.
fruits = ["apple", "banana", "cherry", "apple"]
print(fruits.count("apple")) # 2
4-4. 리스트 정렬
1) sort( ) : 리스트를 오름차순으로 정렬 (기본값).
numbers = [3, 1, 4, 2]
numbers.sort( )
print(numbers) # [1, 2, 3, 4]
2) reverse( ): 리스트를 뒤집음.
numbers = [3, 1, 4, 2]
numbers.reverse()
print(numbers) # [4, 3, 2, 1]
4-5. 리스트 복사
1) copy( ) : 리스트를 복사
original = [1, 2, 3]
copied = original.copy( )
copied.append(4)
print(original) # [1, 2, 3]
print(copied) # [1, 2, 3, 4]
V. 파이썬 기초 – 딕셔너리(Dict)
▶ Dict → 사전
▶ { 단어 : 뜻 }의 형태
중괄호 안에 키(key)와 벨류(value)로 구성되어 있는 형태
데이터의 빠른 검색, 추가, 삭제를 지원
{Key1:Value1, Key2:Value2, Key3:Value3, ...}
x = {“name” : “tony”, “age” : “25”, “country” : “korea”}
print(x[“name”])
value에는 리스트 형태도 가능
x = {“name” : “tony”, “age” : “25”, “country” : [“korea”, “usa”]}
단, 키(key)는 중복이 안된다.
1. 딕셔너리의 주요 특징
1-1. 키-값 쌍으로 구성
- 데이터는 고유한 키와 값의 쌍으로 저장된다.
예: {"name": "Alice", "age": 25}
1-2. 키는 고유
- 키는 중복될 수 없습니다.
1-3. 변경 가능 (Mutable)
- 딕셔너리는 생성 후 수정, 추가, 삭제가 가능하다.
1-4. 키(key)는 해시 가능한 값만 사용 가능
- (Hashability : 객체가 고유한 해시 값을 가질 수 있는 성질을 의미_객체가 불변함, 동등성을 비교할 수 있어야 한다.)
- 숫자, 문자열, 튜플 등 불변 자료형이 키로 사용된다.
2. 딕셔너리 생성 및 기본 사용법
2-1. 딕셔너리 생성
# 빈 딕셔너리 생성
empty_dict = { }
# 값이 있는 딕셔너리 생성
person = {"name": "Alice", "age": 25, "city": "New York"}
print(person) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
2-2. 딕셔너리 키로 값 접근
person = {"name": "Alice", "age": 25, "city": "New York"}
# 키로 값 가져오기
print(person["name"]) # Alice
print(person["age"]) # 25
2-3. 딕셔너리 값 추가 및 수정
person = {"name": "Alice", "age": 25}
# 값 추가
person["city"] = "New York"
print(person) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 값 수정
person["age"] = 26
print(person) # {'name': 'Alice', 'age': 26, 'city': 'New York'}
2-4. 딕셔너리 값 삭제
person = {"name": "Alice", "age": 25, "city": "New York"}
# 특정 키 삭제
del person["city"]
print(person) # {'name': 'Alice', 'age': 25}
# 모든 키-값 삭제
person.clear()
print(person) # { }
3. 딕셔너리 주요 메서드
3-1. keys(), values(), items()
- keys( ) : 모든 키를 반환한다.
- values( ) : 모든 값을 반환한다.
- items( ) : 모든 키-값 쌍을 튜플 형태로 반환한다.
person = {"name": "Alice", "age": 25, "city": "New York"}
print(person.keys()) # dict_keys(['name', 'age', 'city'])
print(person.values()) # dict_values(['Alice', 25, 'New York'])
print(person.items()) # dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])
3-2. get( )
- get(key, default): 키에 해당하는 값을 반환하며, 키가 없으면 기본값을 반환한다.
person = {"name": "Alice", "age": 25}
print(person.get("name")) # Alice
print(person.get("city", "Unknown")) # Unknown
3-3. update( )
- 다른 딕셔너리를 사용해 기존 딕셔너리를 업데이트한다.
person = {"name": "Alice", "age": 25}
person.update({"city": "New York", "age": 26})
print(person) # {'name': 'Alice', 'age': 26, 'city': 'New York'}
3-4. pop( )
- 특정 키의 값을 반환하고 딕셔너리에서 삭제한다.
person = {"name": "Alice", "age": 25}
age = person.pop("age")
print(age) # 25
print(person) # {'name': 'Alice'}
VI. 파이썬 기초 - 튜플형 (Tuple)
▶ 불변(Immutable) 데이터 타입으로, 여러 값을 순서대로 저장할 수 있는 자료 구조
▶ 리스트형[ ]과 거의 비슷하고, () 괄호로 생성.
▶ 리스트와 비슷하지만 생성 후 수정, 추가, 삭제가 불가능하다.
t = ()
t = (“a”, “b”, “c”, “d”, “e”)
t = (“Hello”, “Python”)
t = (1, 2, 3, (“a”, “b”))
1. 튜플의 주요 특징
1-1. 순서 유지 (Ordered)
- 튜플은 저장된 순서를 유지하며, 인덱스를 통해 각 요소에 접근할 수 있다.
1-2. 불변 (Immutable)
- 튜플의 요소는 한 번 생성되면 변경할 수 없다.
1-3. 중복 허용
- 동일한 값을 여러 번 포함할 수 있다.
1-4. 다양한 자료형 저장 가능
- 숫자, 문자열, 리스트 등 다양한 자료형을 저장할 수 있다.
2. 튜플 생성 및 기본 사용법
2-1. 튜플 생성
# 빈 튜플 생성
empty_tuple = ( )
# 값이 있는 튜플 생성
fruits = ("apple", "banana", "cherry")
numbers = (1, 2, 3, 4, 5)
mixed = (1, "hello", 3.14, [2, 4, 6])
print(fruits) # ('apple', 'banana', 'cherry')
print(numbers) # (1, 2, 3, 4, 5)
print(mixed) # (1, 'hello', 3.14, [2, 4, 6])
2-2. 튜플 인덱싱과 슬라이싱
- 인덱싱 : 특정 위치의 요소를 가져온다.
- 슬라이싱: 튜플의 일부를 추출한다.
fruits = ("apple", "banana", "cherry", "date")
# 인덱싱
print(fruits[0]) # apple
print(fruits[-1]) # date
# 슬라이싱
print(fruits[1:3]) # ('banana', 'cherry')
print(fruits[:2]) # ('apple', 'banana')
print(fruits[::-1]) # ('date', 'cherry', 'banana', 'apple') (역순)
2-3. 튜플은 불변
- 튜플은 불변이므로 수정, 추가, 삭제가 불가능하다.
fruits = ("apple", "banana", "cherry")
# fruits[0] = "orange" # TypeError: 'tuple' object does not support item assignment
2-4. 튜플 요소 반복
- 튜플의 요소를 순회하면서 작업할 수 있다.
fruits = ("apple", "banana", "cherry")
for fruit in fruits:
print(fruit)
>>> apple
>>> banana
>>> cherry
3. 튜플의 주요 메서드
3-1. count( )
- 특정 값이 튜플에 몇 번 등장하는지 반환한다.
numbers = (1, 2, 3, 2, 4, 2)
print(numbers.count(2)) # 3
3-2. index( )
- 특정 값의 첫 번째 위치(인덱스)를 반환한다.
numbers = (1, 2, 3, 2, 4, 2)
print(numbers.index(2)) # 1
3-3. 튜플 언패킹 (unpacking)
- 튜플의 요소를 여러 변수에 할당할 수 있다.
person = ("Alice", 25, "New York")
name, age, city = person
print(name) # Alice
print(age) # 25
print(city) # New York
3-4. 튜플 결합과 반복
- 튜플은 결합하거나 반복할 수 있다.
# 튜플 결합
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined = tuple1 + tuple2
print(combined) # (1, 2, 3, 4, 5, 6)
# 튜플 반복
repeated = tuple1 * 3
print(repeated) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
VII. 파이썬 기초 - 집합형 (Set)
▶ 중복을 허용하지 않는 데이터 타입으로, 수학의 집합 개념을 구현한 자료구조
▶ 중괄호 { }*로 표현하며, 순서가 없고, 중복된 요소가 자동으로 제거된다.
▶ set( )을 사용해 만들 수 있다.
x = set([5,2,1])
x = set(‘abcde’)
x = set(‘abccccde’)
1. 집합의 주요 특징
1-1. 중복 제거
- 집합은 동일한 값을 여러 번 저장하지 않는다.
1-2. 순서 없음 (Unordered)
- 인덱스나 슬라이싱을 사용할 수 없다.
1-3. 변경 가능 (Mutable)
- 값을 추가하거나 제거할 수 있다.
1-4. 다양한 자료형:
- 숫자, 문자열, 튜플 등 해시 가능한 자료형을 포함할 수 있습니다. 리스트와 딕셔너리는 포함 불가하다.
2. 집합 생성 및 기본 사용법
2-1. 집합 생성
# 빈 집합 생성
empty_set = set()
# 값이 있는 집합 생성
fruits = {"apple", "banana", "cherry", "apple"} # 중복 제거
print(fruits) # {'apple', 'banana', 'cherry'}
# 리스트, 튜플로부터 집합 생성
numbers = set([1, 2, 2, 3, 4])
print(numbers) # {1, 2, 3, 4}
2-2. 집합 주요 연산
- 집합은 수학적 연산을 지원한다.
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 합집합
print(set1 | set2) # {1, 2, 3, 4, 5}
# 교집합
print(set1 & set2) # {3}
# 차집합
print(set1 - set2) # {1, 2}
# 대칭차집합
print(set1 ^ set2) # {1, 2, 4, 5}
3. 집합의 주요 메서드
3-1. add(value)
- 집합에 값을 추가한다.
fruits = {"apple", "banana"}
fruits.add("cherry")
print(fruits) # {'apple', 'banana', 'cherry'}
3-2. remove(value) / discard(value)
- remove(value) : 값을 제거하며, 값이 없으면 에러 발생.
- discard(value) : 값을 제거하며, 값이 없으면 아무 동작도 하지 않음.
numbers = {1, 2, 3}
numbers.remove(2)
print(numbers) # {1, 3}
numbers.discard(4) # 에러 발생하지 않음
print(numbers) # {1, 3}
3-3. union( ), intersection( ), difference( ), symmetric_difference( )
- 각각 합집합, 교집합, 차집합, 대칭차집합을 반환한다.
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2)) # {1, 2, 3, 4, 5}
print(set1.intersection(set2)) # {3}
print(set1.difference(set2)) # {1, 2}
print(set1.symmetric_difference(set2)) # {1, 2, 4, 5}
3-4. issubset( ), issuperset( )
- issubset( ) : 부분집합 여부 확인.
- issuperset( ) : 상위집합 여부 확인.
set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2)) # True
print(set2.issuperset(set1)) # True
3-5. clear( )
- 집합의 모든 요소를 제거합니다.
fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(fruits) # set()
VIII. 파이썬 기초 - 불형 (Boolean)
▶ 참(True) 또는 거짓(False) 두 가지 값만 가질 수 있는 데이터 타입
▶ 조건식, 논리 연산, 제어문 등에 사용되며 True와 False로 표현
1. 불형의 주요 특징
1-1. True와 False:
- 불형은 두 가지 값만 가질 수 있다 : True, False.
- 대소문자 구분이 있으며, 반드시 첫 글자가 대문자여야 한다.
1-2. 숫자와의 관계:
- True는 숫자 1과 같고, False는 숫자 0과 같다.
1-3. 조건식에서 기본 값:
- 대부분의 값은 참(True)으로 평가되며, 다음은 거짓(False)으로 평가된다.
None
0, 0.0, 0j (숫자 0 계열)
" " (빈 문자열)
[ ], ( ), { } (빈 시퀀스)
2. 불형 값 생성 및 기본 사용법
1-1. 불형 값 생성
is_hungry = True
is_tired = False
print(is_hungry) # True
print(is_tired) # False
1-2. 숫자와 불형 비교
print(True == 1) # True
print(False == 0) # True
print(True + 1) # 2 (1 + 1)
print(False * 10) # 0 (0 * 10)
1-3. 불형의 주요 연산 및 메서드
1) 논리 연산자
- and : 두 조건이 모두 참일 때 참 반환.
- or : 하나라도 참이면 참 반환.
- not : 조건의 반대값 반환.
a = True
b = False
print(a and b) # False
print(a or b) # True
print(not a) # False
2) 비교 연산자
- 불형은 비교 연산자의 결과로 생성된다.
연산자 의미 예시
== 같음 1 == 1 → True
!= 같지 않음 1 != 2 → True
< 작음 5 < 10 → True
> 큼 10 > 5 → True
<= 작거나 같음 3 <= 3 → True
>= 크거나 같음 4 >= 2 → True
x = 10
y = 5
print(x > y) # True
print(x == y) # False
print(x != y) # True
3) 별형과 조건문
- 불형은 제어문과 함께 자주 사용된다.
is_raining = True
if is_raining:
print("Take an umbrella.") # 실행됨
else:
print("No need for an umbrella.")
4) 불형으로 변환 (bool() 함수)
- 파이썬의 모든 값은 bool() 함수로 불형으로 변환 가능하다.
# 참으로 평가되는 값
print(bool(1)) # True
print(bool("hello")) # True
print(bool([1, 2])) # True
# 거짓으로 평가되는 값
print(bool(0)) # False
print(bool("")) # False
print(bool([])) # False
5) 불형과 어울리는 유용한 함수
- any(iterable) : 하나라도 참이면 True 반환.
- all(iterable) : 모두 참이면 True 반환.
# any 예제
values = [0, 0, 1]
print(any(values)) # True (1이 있어서 참)
# all 예제
values = [1, 2, 3]
print(all(values)) # True (모두 참)
values = [1, 0, 3]
print(all(values)) # False (0이 있어서 거짓)
'데이터 분석 (DA)' 카테고리의 다른 글
| [패스트캠퍼스] 데이터 분석 부트캠프 17기 - 9주차 (DA_MySQL) (0) | 2025.02.14 |
|---|---|
| [패스트캠퍼스] 데이터 분석 부트캠프 17기 - 8주차 (DA_MySQL) (0) | 2025.02.06 |
| [패스트캠퍼스] 데이터 분석 부트캠프 17기 - 4주차 (DA_Python) (0) | 2025.01.12 |
| [패스트캠퍼스] 데이터 분석 부트캠프 17기 - 2주차 (DA_Statistics) (2) | 2024.12.29 |
| [패스트캠퍼스] 데이터 분석 부트캠프 17기 - 1주차 (DA_Excel, Statistics) (2) | 2024.12.22 |
