[새싹 성동 2기]Python 데이터 타입과 연산자 기초 정리

 

1. 불변 객체와 가변 객체

불변 객체

• 정수(int), 문자열(str), 튜플(tuple) 등은 불변 객체입니다.
• 값이 변경되면 새로운 객체가 생성됩니다.

  x = 42
  print(x, id(x))  # 42 140720571869384
  
  x = x + 1
  print(x, id(x))  # 43 140720571869416  # 새로운 객체가 생성

 

가변 객체

• 리스트(list), 딕셔너리(dict), 집합(set) 등은 가변 객체입니다.
• 값을 변경해도 같은 객체를 참조합니다.

  my_list = [1, 2, 3]
  print(my_list, id(my_list))  # [1, 2, 3] 1952297804288
  
  my_list.append(4)
  print(my_list, id(my_list))  # [1, 2, 3, 4] 1952297804288  # 동일한 객체

 

2. 주요 데이터 타입

구분	데이터 타입	설명
숫자형	정수형(int)	소수점이 없는 숫자
	실수형(float)	소수점을 포함하는 숫자
	복소수형(complext)	실수부와 허수부로 구성된 숫자
불리형	불리언(bool)	참(True) 또는 거짓(False)을 나타내는 데이터 타입
시퀀스형	문자열(str)	문자나 단어의 시퀀스
	리스트(list)	순서가 있는 가변 시퀀스 타입 ⇐ JavaScript의 배열(array)
	튜플(tuple)	순서가 있는 불변 시퀀스 타입
	범위(range)	특정 범위 내의 숫자를 생성
매핑형	딕셔너리(dict)	키-값 쌍으로 구성된 매핑 타입 ⇐ JavaScript의 객체(object)
집합형	집합(set)	중복을 허용하지 않는 순서가 없는 컬렉션 타입
	프로즌셋(frozenset)	집합과 유사하지만 불변 집합
NoneType		아무 것도 없음을 나타내는 특수한 데이터 타입

3. 튜플

항목이 하나인 튜플 생성 시 쉼표 필요

single_element_tuple = (1,)
print(single_element_tuple, type(single_element_tuple))  # (1,) <class 'tuple'>


single_element_tuple = (1)
print(single_element_tuple, type(single_element_tuple))  # 1 <class 'int'>


single_element_tuple = ("abc",)
print(single_element_tuple, type(single_element_tuple))  # ('abc',) <class 'tuple'>


single_element_tuple = ("abc")
print(single_element_tuple, type(single_element_tuple))  # abc <class 'str'>

4. range 사용법

1부터 9까지 구구단 출력

for i in range(1, 10):
    for j in range(1, 10):
        print(i, "*", j, "=", i * j)

 

range 객체를 리스트로 변환

d = {1: "one", 2: "two", 3: "three"}
print(d[1])  # one  # 키를 이용해 값에 접근

5. 딕셔너리(dict)

딕셔너리 생성

d = {1: "one", 2: "two", 3: "three"}
print(d[1])  # one <= 1은 키를 의미 (인덱스가 아님)

person = dict(name="Alice", age=25, city="New York")
print(person)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}

person2 = {"name": "Alice", "age": 25, "city": "New York"}
print(person2)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}

6. 집합(set)

• 중복을 허용하지 않음

집합 연산

fruits = {"apple", "banana", "cherry", "apple", "cherry"}
print(type(fruits))  # <class 'set'>
print(fruits)  # {'banana', 'apple', 'cherry'} <== 중복을 허용하지 않음


number1 = {1, 2, 3, 8, 9, 1, 2, 3}  # {1, 2, 3, 8, 9}
number2 = {4, 5, 7, 8, 9}  # {4, 5, 7, 8, 9}

# 합집합
print(number1 | number2)  # {1, 2, 3, 4, 5, 7, 8, 9}
print(number1.union(number2))  # {1, 2, 3, 4, 5, 7, 8, 9}

# 교집합
print(number1 & number2)  # {8, 9}
print(number1.intersection(number2))  # {8, 9}

# 차집합
print(number1 - number2)  # {1, 2, 3}
print(number1.difference(number2))  # {1, 2, 3}

7. 데이터 타입 변환

# 변수 b에 Boolean 값 True를 할당
b = True
# 변수 i에 정수 100을 할당
i = 100
# b는 True로, 정수로 변환하면 1이 됨. 따라서 b + i는 1 + 100 = 101
print(b + i)  # 101 <= True = 1

# 변수 b에 Boolean 값 False를 할당
b = False
# 변수 i에 정수 100을 다시 할당
i = 100
# b는 False로, 정수로 변환하면 0이 됨. 따라서 b + i는 0 + 100 = 100
print(b + i)  # 100 <= False = 0

# 변수 i에 문자열 "123"을 할당
i = "123"
# i는 현재 문자열이므로, 타입은 <class 'str'>
print(type(i))  # <class 'str'>
# 문자열 "123"을 정수로 변환하면 123이 됨
print(int(i))  # 123

# i를 정수로 변환하여 다시 변수 i에 저장
i = int(i)
# 이제 i는 정수이므로, 타입은 <class 'int'>
print(type(i))  # <class 'int'>
# 이미 정수 값이므로 변환해도 동일하게 123 출력
print(int(i))  # 123

# 변수 i에 문자열 "abc"를 할당
i = "abc"
# "abc"는 숫자가 아니므로 정수로 변환하려 하면 ValueError가 발생
int(i)  # ValueError: invalid literal for int() with base 10: 'abc'

8. 연산자

산술 연산자

연산자	이름	설명
+	덧셈	두 피연산자를 더합니다.
-	뺄셈	첫 번째 피연산자에서 두 번째 피연산자를 뺍니다.
*	곱셈	두 피연산자를 곱합니다.
/	나눗셈	첫 번째 피연산자를 두 번째 피연산자로 나눕니다.  결과는 실수형 수입니다.
//	나눗셈 몫	첫 번째 피연산자를 두 번째 피연산자로 나눈 후, 몫 부분만 반환합니다. 결과는 정수형 입니다.
%	나머지	첫 번째 피연산자를 두 번째 피연산자로 나눈 후, 나머지만 반환합니다. 결과는 정수형 입니다.
**	거듭제곱	첫 번째 피연산자를 두 번째 피연산자로 거듭제곱합니다.
-	단항 음수	피연산자의 부호를 반대로 바꿉니다.

비교 연산자

연산자	이름	설명
==	같음	두 피연산자의 값이 같다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
!=	같지 않음	두 피연산자의 값이 다르다면 True를 반환하고, 같다면 False를 반환합니다.
>	큼	첫 번째 값이 더 크다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
<	작음	첫 번째 값이 더 작다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
>=	크거나 같음	첫 번째 값이 더 크거나 같다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
<=	작거나 같음	첫 번째 값이 더 작거나 같다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
is	객체 동일성	두 객체가 같은 객체이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
is not	객체 동일성 부정	두 객체가 다른 객체이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

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

#'값'이 같음을 비교
print(a == b)  # True
print(a == c)  # True


print(id(a), id(b))  # 2252041839104 2252041987584
print(id(a), id(c))  # 2252041839104 2252041839104

#'객체'가 같음을 비교(동일 id 여부)
print(a is b)  # False
print(a is c)  # True

 

논리 연산자

연산자	이름	설명
and	논리곱(AND)	두 조건이 모두 참일 때 참
or	논리합(OR)	두 조건 중 하나라도 참일 때 참
not	논리부정(NOT)	조건이 참이면 거짓, 거짓이면 참

할당 연산자

연산자	이름	설명
=	기본 할당	오른쪽 값을 왼쪽 변수에 할당합니다.
+=	덧셈 후 할당	변수의 현재 값에 오른쪽 피연산자의 값을 더한 후, 그 결과를 다시 변수에 할당합니다.
-=	뺄셈 후 할당	변수의 현재 값에서 오른쪽 피연산자의 값을 뺀 후, 그 결과를 다시 변수에 할당합니다.
*=	곱셈 후 할당	변수의 현재 값에 오른쪽 피연산자의 값을 곱한 후, 그 결과를 다시 변수에 할당합니다.
/=	나눗셈 후 할당	변수의 현재 값을 오른쪽 피연산자의 값으로 나눈 후, 그 결과를 다시 변수에 할당합니다. 결과는 부동 소수점 수입니다.
//=	몫 후 할당	변수의 현재 값을 오른쪽 피연산자의 값으로 정수 나누기를 수행한 후, 그 결과를 다시 변수에 할당합니다.
%=	나머지 후 할당	변수의 현재 값을 오른쪽 피연산자의 값으로 나눈 나머지를 구한 후, 그 결과를 다시 변수에 할당합니다.
**=	거듭제곱 후 할당	변수의 현재 값을 오른쪽 피연산자의 값으로 거듭제곱한 후, 그 결과를 다시 변수에 할당합니다.
&= |= ^= <<= >>=	비트 연산 후 할당	변수의 현재 값에 비트 연산을 수행한 후, 그 결과를 다시 변수에 할당합니다.

비트 연산자

연산자	이름	설명
&	비트 AND	두 피연산자의 대응되는 비트가 모두 1일 때, 그 결과 비트도 1이 되고, 그렇지 않으면 0이 됩니다.
|	비트 OR	두 피연산자의 대응되는 비트 중 하나라도 1이면, 그 결과 비트는 1이 되고, 둘 다 0이면 0이 됩니다.
^	비트 XOR	두 피연산자의 대응되는 비트가 서로 다를 때, 그 결과 비트는 1이 되고, 그렇지 않으면 0이 됩니다.
~	비트 NOT	피연산자의 모든 비트를 반전시킵니다. 즉, 1은 0으로, 0은 1로 바뀝니다.  파이썬에서는 비트 NOT 연산의 결과가 -(n+1)이 됩니다. (예: ~5 => -6)
<<	비트 왼쪽 시프트	피연산자의 비트를 지정된 수만큼 왼쪽으로 이동시키고, 오른쪽 빈자리는 0으로 채웁니다.
>>	비트 오른쪽 시프트	피연산자의 비트를 지정된 수만큼 오른쪽으로 이동시키고, 왼쪽 빈자리는 부호 비트로 채웁니다. (음수인 경우 1, 양수인 경우 0)

9. 문자열

기본 선언 및 출력

# 문자열 선언
s = "abcd"
s2 = "abc\nxyz"  # 줄바꿈 포함
print(s2)

# 여러 줄 문자열
s3 = """abc
xyz
    123     456"""
print(s3)

문자열 분할 및 결합(split, join)

str_data = "Hello, Python, JavaScript, Java"

# 분할
words = str_data.split(", ")
print(words)  # ['Hello', 'Python', 'JavaScript', 'Java']

# 결합
joined_str = " | ".join(words)
print(joined_str)  # Hello | Python | JavaScript | Java

 

문자열 검색(in, find, index)

# 포함 여부 확인
print("Python" in str_data)  # True
print(str_data.find("Python") >= 0)  # True
print(str_data.index("Python"))  # 위치 반환 (예외 없음)

# 포함되지 않는 경우
print("C++" in str_data)  # False
print(str_data.find("C++") >= 0)  # False
# print(str_data.index("C++"))  # ValueError 발생

 

문자열 중복 제거

def remove_duplicate_chars(s):
    return "".join(set(s))  # set()으로 중복 제거 후 문자열로 변환

# 실행 예시
user_input = input("문자열을 입력하세요: ")
result = remove_duplicate_chars(user_input)

print(f"원문: {user_input} >>> {len(user_input)}글자")
print(f"중복제거: {result} >>> {len(result)}글자")

조건문 (삼항 연상자)

Python에서 삼항 연산자는 value_if_true if condition else value_if_false로 사용:

# 나이에 따라 상태 출력
age = int(input("나이를 입력하세요: "))
status = "성인" if age >= 18 else "미성년"
print(status)

10. 함수와 람다 함수

여러 값을 반환하는 함수

# 여러 값을 반환하는 함수
def calculate(a, b):
    return a + b, a - b, a * b, a / b if b != 0 else None

c = calculate(10, 5)
print(c)  # (15, 5, 50, 2.0)
print(f"덧셈: {c[0]}, 뺄셈: {c[1]}, 곱셈: {c[2]}, 나눗셈: {c[3]}")

 

람다 함수

square = lambda x: x**2
print(square(2))  # 4

 

11. 고차 함수 활용

map, filter, reduce 사용

def square(x):
    return x**2


print(square(2))  # 4
print((lambda x: x**2)(2))  # 4


numbers = [1, 2, 3, 4, 5]
squared = map(square, numbers)
print(list(squared))  # [1, 4, 9, 16, 25]


numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # [1, 4, 9, 16, 25]


numbers = [1, 2, 3, 4, 5]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4]

from functools import reduce


numbers = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, numbers)
print(sum)  # 15


str = "abcdefg"
print(reduce(lambda x, y: y + x, str))  # gfedcba

 

 

 

 

 

*생성형 AI 활용한 클라우드&보안 전문가 양성캠프 과정의 교육내용 정리 자료입니다.