Python 문법

변수

a = 3
b = 3.5
c = "hello"

:

{}라고 생각하면 됨
그리고 Python은 : 를 해주고나서 들여쓰기를 하지않으면 method안에 있다고 생각하지 않음

print

print(a)
//""랑 변수랑 같이 나타내기
a = 1
print("a", a) // a 1
//end는 print끝에 나타내기
for i in range(0, 10, 1):
  print("t", end="b")
  
//출력 포맷
i = 5
print("{}-{}".format(i, "35"))

타입 확인

type(a)

입력 받기

a = int(input('첫 번째 숫자를 입력하세요'))
// 자료형 입력
a = float(input('숫자를 입력하시오 : '))
a = int(input('숫자를 입력하시오 : '))

if elif else

a = int(input("숫자를 입력하세요"))
b = int(input("숫자를 입력하세요"))
c = int(input("숫자를 입력하세요"))

if a > b and a > c :
    print("a가 가장 큼")
elif b > a and b > c :
    print('b가 가장 큼')
else :
    print('c가 가장 큼')

for문

for 변수 in range(start, end, 증가값) :

for i in range(0, 10, 1):
    print(i, end=" ")
        
 //구구단
a = int(input())

for i in range(1,10,1):
    print('{} * {} = {}'.format(a,i,a*i))

list

d = [1,  2,  3,  4,  5,  6,  7,  8]

//1~101까지 1씩 더해서 list를 만들어 주는 방법
a = list(range(1,101,1))
print("a : ", a)

//for문 사용하여서 * 찍는 예시
for i in range(1, 6, 1):
  for j in range(1, 6-i, 1):
    print("*", end="")
  print(end="\n")

list에서 tip

n = 5
//range(n) = [0, 1, 2, 3, 4]
for i in range(n):
  print(i)
  print(p[0:i])

range(n) - 0~n-1까지의 리스트 만들기
p[0:i] - 0~i-1까지의 리스트를 전부출력

append

list에 추가해주는 메소드(javascript의 push)

c = 0
d = 0
c_name = []
d_name = []

c_name.append(c)
d_name.append(d+1)

print("{}:{}".format(c,d))
print(c_name)
print(d_name)

python의 이중 list

a = [[1,2], [3,4], [4,5]]
print(a)

for i in a:
  for j in i:
    print(j, end=" ")
  print(end="\n")
print()

set

set은 list안에 있는 값들의 중복을 제외하여서 만들어진다.(javascript의 set과 같음)

a = [1, 2, 5, 8, 2, 4, 5]
b = [1, 2, 5, 4, 8]

s1 = set(a)
s2 = set(b)

print("s1: ", s1)
print("s2: ", s2)


print( s1 & s2)
print( s1 | s2)
print( s1 - s2)

list, set, tuple, dictionary

a = [1,2,3,4,5] #값 변경 가능 => 리스트
b = {1,2,3,3,4} #값 변경 불가 => 셋
c = (2,2,3,4,5) #값 변경 불가 => 튜플
d = {'aaa':1, 'bbb':2, 'ccc':3} #값 변경 가능 => 딕셔너리

def

//def 함수명 (parameter:자료형)->반환값 자료형:
  def box_count(n:int)->int:
	return ret

1. List (리스트)

리스트는 순서가 있는 변경 가능한(mutable) 데이터 구조로, 같은 데이터 타입뿐만 아니라 다른 타입의 값도 함께 저장할 수 있다.

🛠️ CRUD

✅ Create (생성)

# 빈 리스트 생성
lst = []

# 리스트 생성 및 값 추가
lst = [1, 2, 3, 4, 5]

# append(): 마지막에 값 추가
lst.append(6)  # [1, 2, 3, 4, 5, 6]

# insert(index, value): 특정 위치에 값 추가
lst.insert(2, 10)  # [1, 2, 10, 3, 4, 5, 6]

# extend(): 여러 개의 요소 추가
lst.extend([7, 8])  # [1, 2, 10, 3, 4, 5, 6, 7, 8]

🔍 Read (읽기)

# 인덱스로 요소 접근
print(lst[0])   # 1 (첫 번째 요소)
print(lst[-1])  # 8 (마지막 요소)

# 슬라이싱
print(lst[1:4])  # [2, 10, 3]

# 리스트 길이
print(len(lst))  # 8

✏️ Update (갱신)

# 특정 인덱스 값 변경
lst[2] = 20  # [1, 2, 20, 3, 4, 5, 6, 7, 8]

# 여러 개의 요소 변경
lst[1:3] = [9, 99]  # [1, 9, 99, 3, 4, 5, 6, 7, 8]

❌ Delete (삭제)

# pop(): 마지막 요소 또는 특정 인덱스 요소 제거
lst.pop()  # [1, 9, 99, 3, 4, 5, 6, 7]
lst.pop(2)  # [1, 9, 3, 4, 5, 6, 7]

# remove(): 특정 값을 찾아서 삭제 (첫 번째 값만 삭제됨)
lst.remove(9)  # [1, 3, 4, 5, 6, 7]

# del 키워드 사용
del lst[0]  # [3, 4, 5, 6, 7]

# 리스트 비우기
lst.clear()  # []

---

2. Set (셋)

집합은 순서가 없고(unique) 중복이 없는 변경 가능한 데이터 구조이다.

🛠️ CRUD

✅ Create (생성)

# 빈 set 생성
s = set()

# 값이 있는 set 생성
s = {1, 2, 3, 4, 5}

🔍 Read (읽기)

# 요소 확인
print(3 in s)  # True
print(10 in s)  # False

# set 길이 확인
print(len(s))  # 5

# set 전체 출력
print(s)  # {1, 2, 3, 4, 5}

✏️ Update (갱신)

# add(): 요소 추가
s.add(6)  # {1, 2, 3, 4, 5, 6}

# update(): 여러 개의 요소 추가
s.update([7, 8, 9])  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

❌ Delete (삭제)

# remove(): 특정 요소 삭제 (없으면 KeyError 발생)
s.remove(3)  # {1, 2, 4, 5, 6, 7, 8, 9}

# discard(): 특정 요소 삭제 (없어도 에러 없음)
s.discard(10)  # {1, 2, 4, 5, 6, 7, 8, 9}

# pop(): 랜덤 요소 삭제
s.pop()  # 삭제된 요소는 예측 불가

# set 비우기
s.clear()  # set()

---

3. Tuple (튜플)

튜플은 순서가 있는 변경 불가능한(immutable) 데이터 구조이다.

🛠️ CRUD

✅ Create (생성)

# 빈 튜플 생성
t = ()

# 값이 있는 튜플 생성
t = (1, 2, 3, 4, 5)

🔍 Read (읽기)

# 인덱싱
print(t[0])  # 1
print(t[-1])  # 5

# 슬라이싱
print(t[1:4])  # (2, 3, 4)

# 길이 확인
print(len(t))  # 5

✏️ Update (갱신)

튜플은 변경 불가능(immutable) 하므로 직접 수정할 수 없다.

하지만 리스트로 변환하여 변경 후 다시 튜플로 변환하는 방법이 있다.

t = (1, 2, 3, 4, 5)
t_list = list(t)
t_list[2] = 99
t = tuple(t_list)
print(t)  # (1, 2, 99, 4, 5)

❌ Delete (삭제)

튜플은 수정이 불가능하므로 요소를 개별 삭제할 수 없다.

전체 삭제는 가능하다.

del t

---

4. Dictionary (딕셔너리)

딕셔너리는 키-값(Key-Value) 쌍으로 이루어진 변경 가능한 데이터 구조이다.

🛠️ CRUD

✅ Create (생성)

# 빈 딕셔너리 생성
d = {}

# 값이 있는 딕셔너리 생성
d = {"name": "Alice", "age": 25, "city": "Seoul"}

🔍 Read (읽기)

# 키를 이용한 값 접근
print(d["name"])  # Alice

# get()을 이용한 값 접근 (키가 없을 경우 None 반환)
print(d.get("age"))  # 25
print(d.get("gender", "Not Found"))  # Not Found

# 키 목록 조회
print(d.keys())  # dict_keys(['name', 'age', 'city'])

# 값 목록 조회
print(d.values())  # dict_values(['Alice', 25, 'Seoul'])

# 키-값 쌍 조회
print(d.items())  # dict_items([('name', 'Alice'), ('age', 25), ('city', 'Seoul')])

✏️ Update (갱신)

# 키 값 변경
d["age"] = 30  # {"name": "Alice", "age": 30, "city": "Seoul"}

# 새로운 키 추가
d["gender"] = "Female"

❌ Delete (삭제)

# pop(): 특정 키 삭제
d.pop("age")  # {"name": "Alice", "city": "Seoul", "gender": "Female"}

# del 키워드 사용
del d["city"]

# 전체 비우기
d.clear()  # {}

🔥 정리

데이터 구조	순서 유지	변경 가능	중복 허용	CRUD 가능 여부
List	✅	✅	✅	CRUD 모두 가능
Set	❌	✅	❌	CRUD 가능 (단, 순서 없음)
Tuple	✅	❌	✅	R만 가능 (U, D 불가능)
Dict	❌	✅	키는 중복 불가, 값은 가능	CRUD 모두 가능