데이터 분석/python
python 문법
fullfish
2025. 9. 24. 16:07
name = input("이름: ")
age = input("나이: ")
print("입력된 이름은",name,'이고 나이는',age,'입니다.')
print(f"입력된 이름은 {name}이고 나이는 {age}입니다.")
price = int(input("단가: "))
count = int(input("수량: "))
print(f"1입력된 단가는 {price}이고 수량은 {count}이며 가격은 {price*count}입니다.")
print("2입력된 단가는 ",price,"이고 수량은 ",count,"이며 가격은 ",price*count,"입니다.")
c=float(input('변환하고 싶은 섭씨온도를 입력하세요.'))
print(f"섭씨온도: {c}")
print(f"화씨온도: {c*1.8+32}")
a = int(input("국어: "))
b = int(input("영어: "))
c = int(input("수학: "))
sum = a + b + c
print(f"총점: {sum}")
print(f"평균: {sum / 3}")
print(f"평균: {sum / 3:.2f}") # 소수점 둘째 자리까지
리스트(list/arr)
colors = ["red", "blue", "green"]
print(colors)
print(colors[1])
print(len(colors))
print(colors[0:2])
list1 + list2 # 리스트 2개 붙임
list * 3 # 3번 반복
cities = ["서울", "광주", "부산", "동해", "전주"]
print(cities[::-2]) # ["전주", "부산", "서울"]
append() # 뒤에 추가
pop() # 뒤에 삭제
pop(0) # 앞에 삭제
extend() # 리스트 합치기 +와 같음
insert(n, "a") # n 인덱스에 "a" 끼워 넣기
remove() # 특정 값 1개 지움
del arr[1:3] # 범위 삭제
from collections import deque # 더 빠름
dq = deque([1, 2, 3])
dq.append(4) # push
dq.pop() # pop
dq.appendleft(0) # unshift
dq.popleft() # shift
t = [1, 2, 3] # 1, 2, 3을 변수 t에 패킹
a , b , c = t # t에 있는 값 1, 2, 3을 변수 a, b, c에 언패킹
print(t, a, b, c) # [1, 2, 3] 1 2 3
# enumerate 인덱스 함께
for index, v in enumerate(['tic', 'tac', 'toe']):
# zip
a, b, c = zip((1, 2, 3), (10, 20, 30), (100, 200, 300))
print(a, b, c) # (1, 10, 100) (2, 20, 200) (3, 30, 300)
[sum(x) for x in zip((1, 2, 3), (10, 20, 30), (100, 200, 300))] # [111, 222, 333]a = 300
b = 300
a is b False
a == b True
a = 1
b = 1
a is b True
a == b True
# 왜냐하면 -5 부터 256까지의 정수는 인터프리터가 구동될때 특정 메모리 주소에 저장해두고 그 주소값을 쓰기 떄문에
print((1 <= 100 < 10)) # False
print(((1 <= 100) < 10)) # True
논리
js는
&&, ||, !
쓰지만
python은
and, or, not으로 씀
print(4 and 2) # 2 (둘 다 True니까 마지막 값 반환)
print(4 & 2) # 0 (100 & 010 → 000 → 0)
python에서 &, |는 비트연산자임
반복
for i in range(1, 10, 2) # 1부터 9까지 2씩 증가
for i in range(10, 1, -1) # 10부터 2까지 1씩 감소
# 인덱스
fruits = ["apple", "banana", "cherry"]
for idx, f in enumerate(fruits):
print(idx, f)
# 객체
user = {"name": "만선", "age": 31}
for key, value in user.items():
print(key, value)
# 여러 리스트
names = ["철수", "영희", "민수"]
scores = [90, 85, 77]
for n, s in zip(names, scores):
print(n, ":", s)
# 인덱스 함께
fruits = ["apple", "banana", "cherry"]
for index, value in enumerate(fruits):
print(index, value)
for index, value in enumerate(fruits, start=1):
print(index, value)
list(enumerate(fruits)) # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]
# map
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, nums))
print(squares) # [1, 4, 9, 16]
nums = [1, 2, 3, 4]
squares = [x**2 for x in nums]
print(squares) # [1, 4, 9, 16]
# filter
nums = [1, 2, 3, 4]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens) # [2, 4]
nums = [1, 2, 3, 4]
evens = [x for x in nums if x % 2 == 0]
print(evens) # [2, 4]
# reduce
from functools import reduce
sum_val = reduce(lambda acc, cur: acc + cur, arr, 0)
조건
# 파이썬에서 삼항연산자
A if 조건 else B # js는 조건? a : b
정렬
arr.sort(reverse=True) # 내림차순
arr.sort(key=len) # 문자열 길이 기준 정렬
sorted(arr, reverse=True) # 원본 안건드림
sorted(["apple", "banana", "kiwi"], key=len)
# 예를 들어 2번째 요소 기준 정렬
data = [[1, 20300104, 100, 80],
[2, 20300804, 847, 37],
[3, 20300401, 10, 8]]
data.sort(key=lambda x: x[1])
sorted_data = sorted(data, key=lambda x: x[1])
함수
# 기본적으로 js는 전역 변수취급 파이썬은 global 써 줘야함
# js에서 내부 함수에 let해주면 지역 변수 취급 파이썬은 그냥 쓰면 지역 변수 취금
키워드 인수 # 이건 js에서는 없음
def print_something(my_name, your_name):
print("Hello {0}, My name is {1}".format(your_name, my_name))
print_something("Sungchul", "TEAMLAB")
print_something(your_name = "TEAMLAB", my_name = "Sungchul")
# Hello TEAMLAB, My name is Sungchul
# Hello TEAMLAB, My name is Sungchul
디폴트 인수
def print_something_2(my_name, your_name = "TEAMLAB"):
print("Hello {0}, My name is {1}".format(your_name, my_name))
print_something_2("Sungchul", "manseon")
print_something_2("Sungchul")
# Hello manseon, My name is Sungchul
# Hello TEAMLAB, My name is Sungchul
가변인수
def asterisk_test(a, b, *args): # js에서는 ...
return a + b + sum(args)
print(asterisk_test(1, 2, 3, 4, 5))
키워드 가변 인수
def kwargs_test(**kwargs):
print(kwargs)
print("First value is {first}".format(**kwargs))
print("Second value is {second}".format(**kwargs))
print("Third value is {third}".format(**kwargs))
kwargs_test(first = 3, second = 4, third = 5)
# {'first': 3, 'second': 4, 'third': 5}
# First value is 3
# Second value is 4
# Third value is 5
def kwargs_test(one, two, *args, **kwargs):
print(one + two + sum(args))
print(kwargs)
kwargs_test(3, 4, 5, 6, 7, 8, 9, first = 3, second = 4, third = 5)
# 42
# {'first': 3, 'second': 4, 'third': 5}
-----------------
def f(**args):
print(args)
print(args.keys())
print(list(args.keys()))
print(args.values())
print(args.items())
print(args.get("name"),False)
print(arges['name']
f(name="man", age=25)
문자열
import sys # sys 모듈을 호출
print(sys.getsizeof("a"), sys.getsizeof("ab"), sys.getsizeof("abc"))
50 51 52
# js에서
'123'.padStart(5, '0'); // "00123"
'123'.padEnd(5, '*'); // "123**"
# python에서
'123'.rjust(5, '0') # '00123'
'123'.ljust(5, '*') # '123**'
'123'.zfill(5) # '00123'
f'{"123":0>5}' # '00123' (왼쪽에 0 채움)
f'{"123":*<5}' # '123**' (오른쪽에 * 채움)print("Product: {0}, Price per unit: {1:.2f}".format("Apple", 5.243))
Product: Apple, Price per unit: 5.24
# 패딩
print("%10d" % 12)
12
print("%10.3f" % 5.94343) # 10자리를 확보하고 소수점 셋째 자리까지 출력
5.943
자료구조
set
dic
dic = dict(aa=100, bb=200)
print(dic)
dic.update(cc=300, dd=400)
print(dic)
dic.update({"ee": 500, "ff": 600})
print(dic)
{'aa': 100, 'bb': 200}
{'aa': 100, 'bb': 200, 'cc': 300, 'dd': 400}
{'aa': 100, 'bb': 200, 'cc': 300, 'dd': 400, 'ee': 500, 'ff': 600}
del dic['aa']
dic.pop['bb'] # 이건 리턴 있음
dic.popitem() # 마지막에 넣은 키:값을 튜플형태로
# 3가지 많이 쓰는 모듈
from collections import OrderedDict
from collections import defaultdict
from collections import Counter
# OrderedDict 모듈 선언
from collections import OrderedDict
d = dict()
d["x"] = 100
d["y"] = 200
d["z"] = 300
d["l"] = 500
# changed = OrderedDict(sorted(d.items(), key=sort_by_key)).items()
changed = OrderedDict(sorted(d.items(), key=lambda t: t[0])).items()
print(changed)
move_to_end(키) # 맨 뒤로
move_to_end(키,last=False) # 맨 앞으로
# defaultdict 모듈 선언
from collections import defaultdict
d = defaultdict(lambda: 0) # Default 값을 0으로 설정 / 그냥 int해도 됨 빈 배열 넣으려면 list
print(d["first"]) # 0
# Counter 모듈 선언
from collections import Counter
text = list("gallahad")
c = Counter(text)
print(c) # Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
print(list(c)) # ['g', 'a', 'l', 'h', 'd']
print(list(c.elements())) # ['g', 'a', 'a', 'a', 'l', 'l', 'h', 'd']
+ 합집합은 요소 더함
& 교집합은 작은 값
| or은 큰 값
- 는 차집합
c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
c.subtract(d)
print(c) # Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})
print(c - d) # Counter({'a': 2})
시간 측정
# 성능(시간) 테스트
import time
start = time.perf_counter()
end = time.perf_counter()
end - start
컴프리헨션
#리스트
print([i + 10 for i in range(10)]) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
필터
evens = list(filter(lambda x: x % 2 == 0, nums))
evens = [x for x in nums if x % 2 == 0]
# 속도 더 빠름
import time
iteration_max = 10000
vector = list(range(iteration_max))
scalar = 2
start = time.perf_counter()
for _ in range(iteration_max):
result = []
for value in vector:
result.append(scalar * value)
end = time.perf_counter()
print("for문 사용 경과 시간: ", end - start) # 약 4초
start = time.perf_counter()
for _ in range(iteration_max):
[scalar * value for value in range(iteration_max)]
end = time.perf_counter()
print("Comprehenstion문 사용 경과 시간: ", end - start) # 약 3초
# 위에껀 append를 따로 하지만 아래껀 원소 생성 및 추가를 c 레벨에서 동시에 함
클래스
# 기본 형태
class 클래스이름 (obj)
# 매직 매서드(Magic Method)
이름 앞뒤에 __(언더스코어 두 개)가 붙은 매서드, 던더 메서드(dunder method, double underscore)라고도 함
# 생성 소멸
class Person:
def __init__(self, name): # 객체 생성 시 자동 호출
self.name = name
def __del__(self): # 객체 소멸 시 자동 호출
print(f"{self.name} is deleted")
# 문자열 표현
class Person:
def __init__(self, name):
self.name = name
def __str__(self): # print()나 str()에서 사용
return f"Person({self.name})"
def __repr__(self): # 디버깅/REPL 표현
return f"Person(name={self.name!r})"
# 연산자 오버로딩
class Vector:
def __init__(self, x, y):
self.x, self.y = x, y
def __add__(self, other): # + 연산자 동작 정의
return Vector(self.x + other.x, self.y + other.y)
v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2) # Vector(4, 6)
# 컨테이너 관련
class MyList:
def __init__(self, data):
self.data = data
def __len__(self): # len() 동작 정의
return len(self.data)
def __getitem__(self, index): # [] 연산자 정의
return self.data[index]
ml = MyList([1,2,3])
print(len(ml)) # 3
print(ml[0]) # 1
# 자주 쓰는 매직 매서드
__init__ : 생성자
__del__ : 소멸자
__str__, __repr__ : 문자열 변환
__len__ : len() 호출 시
__getitem__, __setitem__, __delitem__ : 인덱싱 연산
__iter__, __next__ : 반복자
__eq__, __lt__, __gt__ 등 : 비교 연산자
__add__, __sub__, __mul__ 등 : 산술 연산자
# 예시
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __del__(self): # 객체 소멸 시 자동 호출
print(f"{self.name} is deleted")
def __str__(self): # print()나 str()에서 사용
return f"Person({self.name})"
def change_name(self, name):
self.name = name
def change_age(self, age):
self.age = age
def show_data(self):
print(f"이름: {self.name}")
print(f"나이: {self.age}")
p1 = Person("manseon", 32)
p1.gender = "F"
print(p1.name)
print(p1)
print(p1.gender)
p1.show_data()
p1.change_name("kim")
p1.show_data()
manseon
Person(manseon)
F
이름: manseon
나이: 32
이름: kim
나이: 32
kim is deleted
__name__ 변수
파이썬은 파일을 실행할 때, 특별한 전역 변수 __name__을 자동으로 만들어 줘.
두 가지 경우로 값이 달라져:
직접 실행한 경우 (예: python myfile.py) → __name__ == "__main__"
다른 파일에서 import한 경우 (예: import myfile) → __name__ == "myfile"
# 상속
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
class Korean(Person):
pass # 별도의 내용 없이 클래스만 존재한다는 뜻
first_korean = Korean("Sungchul", 35)
print(first_korean.name)
class Person(object): # 부모 클래스 Person 선언
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def about_me(self): # 메서드 선언
print("저의 이름은", self.name, "이고요, 제 나이는", str(self.age), "살입니다.")
class Employee(Person): # 부모 클래스 Person으로부터 상속
def __init__(self, name, age, gender, salary, hire_date):
super().__init__(name, age, gender) # 부모 객체 사용
self.salary = salary
self.hire_date = hire_date # 속성값 추가
def do_work(self): # 새로운 메서드 추가
print("열심히 일을 한다.")
def about_me(self): # 부모 클래스 함수 재정의
super().about_me() # 부모 클래스 함수 사용
print(
"제 급여는", self.salary, "원이고, 제 입사일은", self.hire_date, "입니다."
)
p1 = Person(name="manseon", age="32", gender="M")
p1.about_me()
print("----")
p2 = Employee(name="manseon", age="32", gender="M", salary=100, hire_date="2025")
p2.about_me()
저의 이름은 manseon 이고요, 제 나이는 32 살입니다.
----
저의 이름은 manseon 이고요, 제 나이는 32 살입니다.
제 급여는 100 원이고, 제 입사일은 2025 입니다.
