crushed-taro 님의 블로그

1. datetime 모듈

날짜와 시간을 처리하는 파이썬의 표준 모듈

• datetime.date : 날짜(연, 월, 일)만 저장.
• datetime.time : 시간(시, 분, 초)만 저장.
• datetime.datetime : 날짜와 시간을 모두 저장.
• datetime.timedelta : 날짜/시간의 차이를 나타냄.

2. 포맷팅 및 파싱

• strftime() : 날짜/시간 객체를 문자열로 변환.
• strptime() : 문자열을 날짜/시간 객체로 변환.

3. 예제문제

사용자가 입력한 두 날짜 사이의 일수를 계산하는 프로그램을 작성하세요.

import datetime

def calculate_days_between_dates(date1_str, date2_str):
    date_format = "%Y-%m-%d"
    date1 = datetime.datetime.strptime(date1_str, date_format).date()
    date2 = datetime.datetime.strptime(date2_str, date_format).date()
    
    delta = abs((date2 - date1).days)
    return delta

# 사용자 입력
date1_input = input("첫 번째 날짜를 입력하세요 (YYYY-MM-DD): ")
date2_input = input("두 번째 날짜를 입력하세요 (YYYY-MM-DD): ")

# 결과 출력
print("{calculate_days_between_dates(date1_input, date2_input)}일")

###
입력:
2024-02-01
2024-02-10

출력:
9일
###

출처 : https://school.programmers.co.kr/learn/courses/2

1. 컴프리헨션 (Comprehension)

컴프리헨션은 기존의 반복문(loop)과 조건문(if)을 이용해 리스트(list), 딕셔너리(dictionary), 세트(set) 등을 한 줄로 생성하는 문법입니다.

• 리스트 컴프리헨션 (List Comprehension)
• 딕셔너리 컴프리헨션 (Dictionary Comprehension)
• 세트 컴프리헨션 (Set Comprehension)

2. 리스트 컴프리헨션 (List Comprehension)

• expression : 리스트에 추가할 값 (예 : i, i * 2 등)
• iterable : 반복 가능한 객체 (예 : 리스트, 문자열, range 등)
• condition (선택) : 조건에 맞는 경우만 리스트에 추가

[expression for item in iterable if condition]

numbers = [i for i in range(1, 11)]
print(numbers) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_numbers = [i for i in range(1, 21) if i % 2 == 0]
print(even_numbers) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

words = ["cat", "dog", "elephant", "tiger", "rat"]
long_words = [word for word in words if len(word) >= 2]
print(long_words) # ['elephant', 'tiger']

3. 딕셔너리 컴프리헨션 (Dictionary Comprehension)

딕셔너리 컴프리헨션은 키(key)와 값(value)을 한 줄로 정의할 수 있습니다.

{key_expression: value_expression for item in iterable if condition}

squares = {i: i**2 for i in range(1, 6)}
print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

words = ["apple", "banana", "cherry"]
word_lengths = {word: len(word) for word in words}
print(word_lengths) # {'apple': 5, 'banana': 6, 'cherry': 6}

4. 세트 컴프리헨션 (Set Comprehension)

세트 컴프리헨션은 중복을 제거하고 고유한 값을 저장하는 집합(Set)을 만듭니다.

{expression for item in iterable if condition}

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = {i for i in numbers}
print(unique_numbers) # {1, 2, 3, 4, 5}

odd_numbers = {i for i in range(1, 11) if i % 2 != 0}
print(odd_numbers) # {1, 3, 5, 7, 9}

5. 중첩 컴프리헨션 (Nested Comprehension)

컴프리헨션 안에 다른 컴프리헨션을 중첩해서 사용할 수도 있습니다.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

6. 예제. 대문자만 필터링하기

sentence = "Hello World! Welcome to Python."
uppercase_letters = [char for char in sentence if char.isupper()]
print(uppercase_letters) # ['H', 'W', 'W', 'P']

출처 : https://school.programmers.co.kr/learn/courses/2

1. 상속(Inheritance)이란

상속은 기존 클래스(부모 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스)가 물려받아 사용하는 것을 의미합니다.

상속을 활용하면 코드 중복을 줄이고, 유지보수가 쉬워집니다.

• Child 클래스는 Parent 클래스를 상속받아 greet() 메서드를 사용할 수 있습니다.
• 자식 클래스에서 별도로 정의하지 않아도 부모 클래스의 기능을 그대로 가져옵니다.

class Parent:
    def greet(self):
        print("안녕하세요, 저는 부모 클래스입니다!")

class Child(Parent):
    pass

child = Child()
child.greet()  # 안녕하세요, 저는 부모 클래스입니다!

2. 메서드 오버라이딩(Method Overriding)

자식 클래스가 부모 클래스의 메서드를 재정의(Overriding)할 수도 있습니다. 이걸 통해 클래스마다 다른 동작을 정의할 수 있습니다.

• Child 클래스에서 greet(0 메서드를 새롭게 정의했기 때문에 부모 클래스의 메서드 대신 자식 클래스의 메서드가 호출됩니다.
• 이처럼 부모 클래스의 메서드를 덮어쓰는 것을 오버라이딩이라고 합니다.

class Parent:
    def greet(self):
        print("안녕하세요, 저는 부모 클래스입니다!")

class Child(Parent):
    def greet(self):
        print("안녕하세요, 저는 자식 클래스입니다!")

child = Child()
child.greet()  # 출력: 안녕하세요, 저는 자식 클래스입니다!

3. super()로 부모 클래스 접근하기

자식 클래스에서 부모 클래스의 메서드를 호출하고 싶을 때는 super() 키워드를 사용합니다.

• super().greet()를 통해 부모 클래스의 메서드를 호출한 후, 자식 클래스의 추가 동작을 수행했습니다.
• 이 방식은 부모 클래스의 기능을 확장할 때 유용합니다.

class Parent:
    def greet(self):
        print("안녕하세요, 저는 부모 클래스입니다!")

class Child(Parent):
    def greet(self):
        super().greet()  # 안녕하세요, 저는 부모 클래스입니다!
        print("안녕하세요, 저는 자식 클래스입니다!")

child = Child()
child.greet() # 안녕하세요, 저는 자식 클래스입니다!

4. 다형성(Polymorphism)

다형성은 하나의 인터페이스가 여러 형태로 동작할 수 있게 하는 개념입니다. 쉽게 말해, 같은 메서드가 다른 클래스에서 다른게 동작하도록 만드는 것입니다.

• Dog와 Cat 클래스는 각각 sound() 메서드를 다르게 구현했습니다.
• 반복문에서 animal.sound()를 호출할 때, 객체에 따라 다른 결과가 출력됩니다.
• 같은 메서드가 객체에 따라 다르게 동작하는 것이 다형성입니다.

class Animal:
    def sound(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def sound(self):
        print("멍멍!")

class Cat(Animal):
    def sound(self):
        print("야옹!")

animals = [Dog(), Cat()]

for animal in animals:
    animal.sound()
    
###
멍멍!
야옹!
###

5. 계산기 프로그램

class Calculator:
    def calculate(self, a, b):
        pass  # 기본 동작 정의 X

class Adder(Calculator):
    def calculate(self, a, b):
        return a + b

class Subtractor(Calculator):
    def calculate(self, a, b):
        return a - b

class Multiplier(Calculator):
    def calculate(self, a, b):
        return a * b

class Divider(Calculator):
    def calculate(self, a, b):
        if b != 0:
            return a / b
        else:
            return "0으로 나눌 수 없습니다."

calculators = [Adder(), Subtractor(), Multiplier(), Divider()]
a, b = 10, 5

for calc in calculators:
    print(calc.calculate(a, b))

출처 : https://school.programmers.co.kr/learn/courses/2

1. 객체지향 프로그래밍

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 데이터를 객체로 다루고, 이 객체들이 상호작용하며 프로그램을 구성하는 방법

• 캡슐화(Encapsulation) : 데이터와 메서드를 하나의 클래스 안에 묶어 데이터를 보호.
• 상속(Inheritance) : 기존 클래스(부모)의 속성과 메서드를 새로운 클래스(자식)에게 재사용.
• 다형성(Polymorhpism) : 동일한 이름의 메서드가 클래스에 따라 다르게 동작.
• 추상화(Abstraction) : 불필요한 세부 정보를 숨기고, 중요한 정보만 노출.

2. 클래스와 객체

• 클래스(Class) : 객체를 생성하기 위한 청사진(설계도), 속성(변수)과 동작(메서드)을 정의.
• 객체(Object) : 클래스에서 만들어진 실체, 클래스의 인스턴스(instance)라고도 함.

# 클래스 정의
class Person:
    def __init__(self, name, age):  # 생성자
        self.name = name  # 속성
        self.age = age

    def introduce(self):  # 메서드
        print("안녕하세요! 저는 {self.name}, 나이는 {self.age}살입니다.")

# 객체 생성
person1 = Person("철수", 25)
person1.introduce()  # 안녕하세요! 저는 철수, 나이는 25살입니다.

3. OOP의 주요 문법

• 캡슐화

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance  # private 속성

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500

• 상속

class Animal:
    def __init__(self, name):
        self.name = name

    def sound(self):
        print("소리를 냅니다.")

class Dog(Animal):
    def sound(self):
        print("{self.name}가 멍멍 소리를 냅니다.")

dog = Dog("바둑이")
dog.sound()  # 바둑이가 멍멍 소리를 냅니다.

• 다형성

class Shape:
    def draw(self):
        print("모양을 그립니다.")

class Circle(Shape):
    def draw(self):
        print("원을 그립니다.")

class Rectangle(Shape):
    def draw(self):
        print("사각형을 그립니다.")

shapes = [Circle(), Rectangle()]
for shape in shapes:
    shape.draw()

4.  객체지향의 장점

• 재사용성 : 클래스를 재사용하여 효율적인 코드 작성 가능.
• 유지보수성 : 코드 구조가 명확하여 수정과 확장이 쉬움.
• 유연성 : 다형성을 통해 코드를 더 유연하게 설계.

출처 : https://school.programmers.co.kr/learn/courses/2

1. 예외(Exception)란 무엇인가

예외는 프로그램 실행 중 발생하는 에러(오류)의 한 종류입니다. 예를 들어, 숫자를 0으로 나누거나 존재하지 않는 파일을 읽으려고 하면 예외가 발생합니다.

print(10 / 0)  # ZeroDivisionError 발생

2. 기본적인 예외 처리

try:
    result = 10 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
    
"""
0으로 나눌 수 없습니다.
"""

3. 여러 예외 처리하기

try:
    num = int(input("숫자를 입력하세요: "))
    result = 10 / num
except ValueError:
    print("숫자를 입력해야 합니다.")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")

4. 모든 예외 처리하기

try:
    result = 10 / 0
except Exception as e:
    print("에러 발생: {e}") # 에러 발생: division by zero

5. else와 finally

• else 블록 : 예외가 발생하지 않을 때 실행됩니다.
• finally 블록 : 예외 발생 여부와 상관없이 항상 실행됩니다.

try:
    result = 10 / 2
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
else:
    print(f"결과: {result}")
finally:
    print("프로그램 종료.")
    
"""
결과: 5.0
프로그램 종료.
"""

6. 예외 직접 발생시키기 (raise)

def check_age(age):
    if age < 0:
        raise ValueError("나이는 0보다 작을 수 없습니다.")
    return age

try:
    print(check_age(-5))
except ValueError as e:
    print(e)

"""
나이는 0보다 작을 수 없습니다.
"""

7. 사용자 정의 예외

class NegativeNumberError(Exception):
    pass

def check_positive(num):
    if num < 0:
        raise NegativeNumberError("음수는 허용되지 않습니다.")
    return num

try:
    print(check_positive(-10))
except NegativeNumberError as e:
    print(e)
    
"""
음수는 허용되지 않습니다.
"""

출처 : https://school.programmers.co.kr/learn/courses/2

1. While문

while문은 조건이 참(True)인 동안 반복해서 실행됩니다. 조건이 거짓(False)이 되면 반복을 종료합니다.

count = 0

while count < 5:
    print("현재 카운트: {count}")
    count += 1
    
"""
현재 카운트: 0
현재 카운트: 1
현재 카운트: 2
현재 카운트: 3
현재 카운트: 4
"""

2. 반복 제어 : break와 continue

• break : 반복문 즉시 종료

count = 0

while count < 10:
    print(f"현재 카운트: {count}")
    if count == 5:  # count가 5일 때 종료
        print("반복문 종료!")
        break
    count += 1
    
"""
현재 카운트: 0
현재 카운트: 1
현재 카운트: 2
현재 카운트: 3
현재 카운트: 4
현재 카운트: 5
반복문 종료!
"""

• continue : 특정 반복 건너뛰기

count = 0

while count < 5:
    count += 1
    if count == 3:  # count가 3이면 건너뜀
        print("3은 건너뜁니다!")
        continue
    print(f"현재 카운트: {count}")
    
"""
현재 카운트: 1
현재 카운트: 2
3은 건너뜁니다!
현재 카운트: 4
현재 카운트: 5
"""

3. 무한 루프와 종료 조건

무한 루프는 조건이 항상 참(True)이기 때문에 끝나지 않는 반복문입니다. 일반적으로 break를 사용해 종료합니다.

while True:
    print("무한 루프입니다!")
    user_input = input("종료하려면 'exit'을 입력하세요: ")
    if user_input == "exit":
        print("종료합니다!")
        break

4. else와 함께 사용하는 While문

while문에는 else를 붙여 사용할 수 있습니다. 반복문이 break 없이 정상 종료되었을 때만 else 블록이 실행됩니다.

count = 0

while count < 5:
    print(f"현재 카운트: {count}")
    count += 1
else:
    print("반복문이 정상 종료되었습니다!")
    
"""
현재 카운트: 0
현재 카운트: 1
현재 카운트: 2
현재 카운트: 3
현재 카운트: 4
반복문이 정상 종료되었습니다!
"""

5. 중첩된 While문

row = 1

while row <= 3:
    col = 1
    while col <= 3:
        print(f"row: {row}, col: {col}")
        col += 1
    row += 1
    
"""
row: 1, col: 1
row: 1, col: 2
row: 1, col: 3
row: 2, col: 1
row: 2, col: 2
row: 2, col: 3
row: 3, col: 1
row: 3, col: 2
row: 3, col: 3
"""

출처 : https://school.programmers.co.kr/learn/courses/2

1. 딕셔너리 (Dictionary)

딕셔너리는 키(key)와 값(value)의 쌍으로 데이터를 저장하는 가변적이고 순서가 유지되는 자료구조입니다. Python에서 데이터를 빠르게 검색하거나 저장할 때 매우 유용합니다.

• 딕셔너리 생성

# 딕셔너리 생성 방법
my_dict = {"name": "Alice", "age": 25, "city": "Seoul"}

print(my_dict)  # {'name': 'Alice', 'age': 25, 'city': 'Seoul'}

• 딕셔너리 주요 기능

# 새로운 키-값 추가
my_dict["job"] = "Developer"

# 기존 키의 값 수정
my_dict["age"] = 26

print(my_dict)  # {'name': 'Alice', 'age': 26, 'city': 'Seoul', 'job': 'Developer'}

# 'city' 키 삭제
del my_dict["city"]  

print(my_dict)  # {'name': 'Alice', 'age': 26, 'job': 'Developer'}

print(my_dict["name"])  # Alice

"""
존재하지 않는 키를 조회하면 오류가 발생할 수 있습니다. 이를 방지하려면 get 메서드를 사용하면 됩니다.
"""
print(my_dict.get("city"))  # None (키가 없으면 None 반환)

# 딕셔너리 반복문
for key, value in my_dict.items():
    print(f"{key}: {value}")
    
"""
name: Alice
age: 26
job: Developer
"""

# 주요 메서드
# keys() : 딕셔너리의 키를 반환
# values() : 딕셔너리의 값을 반환
# items() : 키와 값을 쌍으로 반환

print(my_dict.keys())    # dict_keys(['name', 'age', 'job'])
print(my_dict.values())  # dict_values(['Alice', 26, 'Developer'])
print(my_dict.items())   # dict_items([('name', 'Alice'), ('age', 26), ('job', 'Developer')])

2. 튜플 (Tuple)

튜플은 순서가 있는 불변(immutable) 자료형입니다. 리스트와 유사하지만, 생성된 후 값을 변경할 수 없다는 점이 다릅니다.

• 튜플 생성

# 튜플 생성
my_tuple = (1, 2, 3)
print(my_tuple)  # (1, 2, 3)

# 요소가 하나일 때는 반드시 쉼표(,)를 붙여야 함
single_tuple = (5,)
print(single_tuple)  # (5,)

• 튜플 주요 기능

# 튜플을 리스트처럼 인덱싱과 슬라이싱이 가능합니다.
print(my_tuple[0])   # 1 (첫 번째 요소)
print(my_tuple[1:3]) # (2, 3) (두 번째부터 세 번째까지)

# 요소의 개수
print(len(my_tuple))  # 3

# 요소 포함 여부 확인
print(2 in my_tuple)  # True
print(4 in my_tuple)  # False

# 튜플끼리의 결합
tuple1 = (1, 2, 3)
tuple2 = (4, 5)

new_tuple = tuple1 + tuple2
print(new_tuple)  # (1, 2, 3, 4, 5)

3. 딕셔너리와 튜플 비교

출처 : https://school.programmers.co.kr/learn/courses/2

1. 모듈이란

모듈(Module)은 파이썬 코드가 들어 있는 파일로, 다른 파이썬 코드에서 가져와 사용할 수 있습니다. 모듈을 사용하면 코드의 재사용성과 가독성을 높일 수 있습니다.

2. 모듈의 종류

1. 내장 모듈 (Built-in Modules)
   1. Python에서 기본적으로 포함된 모듈로, 설치 없이 바로 사용할 수 있습니다.
   2. Ex) math, random, os, datetime
2. 외부 모듈 (External modules)
   1. Python 커뮤니티에서 제공하는 모듈로, pip을 통해 설치 후 사용합니다.
   2. Ex) numpy, pandas, requests
3. 사용자 정의 모듈 (User-defined Modules)
   1. 사용자가 직접 만든 모듈로, 필요한 함수나 클래스를 정의해 다른 파일에서 가져와 사용할 수 있습니다.

3. 모듈 사용법

• 모듈 가져오기

import math

print(math.sqrt(16))  # 제곱근 계산
print(math.pi)        # 파이 값 출력

• 모듈에서 특정 함수만 가져오기

from 모듈명 import 함수명

from math import sqrt, pi

print(sqrt(25))  # 5.0
print(pi)        # 3.141592653589793

• 별칭(alias) 사용

import 모듈명 as 별칭

import math as m

print(m.sqrt(9))  # 3.0

4. 자주 사용하는 내장 모듈

• math 모듈

import math

print(math.factorial(5))  # 120 (5!)
print(math.gcd(48, 18))   # 6 (최대공약수)

• random 모듈

import random

print(random.randint(1, 10))  # 1~10 사이의 랜덤 정수
print(random.choice(['사과', '바나나', '체리']))  # 리스트에서 랜덤 선택

• datetime 모듈

import datetime

now = datetime.datetime.now()
print(now)                   # 현재 날짜와 시간
print(now.strftime("%Y-%m-%d"))  # 날짜 포맷팅

5. 사용자 정의 모듈

• 모듈 파일 생성

# my_module.py
def greet(name):
    return "안녕하세요, {name}님!"

def add(a, b):
    return a + b

• 모듈 사용

# main.py
import my_module

print(my_module.greet("홍길동"))  # 안녕하세요, 홍길동님!
print(my_module.add(3, 5))       # 8

6. 외부 모듈 설치 및 사용

외부 모듈은 pip 명령어로 설치 후 사용할 수 있습니다.

pip install 모듈명
pip install requests

import requests

response = requests.get("https://api.github.com")
print(response.status_code)  # 상태 코드 출력
print(response.json())       # JSON 데이터 출력

출처 : https://school.programmers.co.kr/learn/courses/2

1. for 반복문이란

for 반복문은 반복 가능한 객체(iterable)의 요소를 하나씩 꺼내 반복 작업을 수행할 수 있게 해줍니다. Python에서는 리스트, 튜플, 문자열, range() 등 여러 자료형과 함께 사용할 수 있어 매우 유용합니다.

2. for 반복문의 기본 문법

• 변수 : 반복 가능한 객체의 각 요소를 순차적으로 담습니다.
• 반복가능한객체 : 리스트, 튜플, 문자열, range() 등.

for 변수 in 반복가능한객체:
    실행할 코드

3. 다양한 반복문 예제

• 리스트와 함께 사용

fruits = ['사과', '바나나', '체리']
for fruit in fruits:
    print(fruit)
    
"""
사과
바나나
체리
"""

• 문자열과 함께 사용

for char in "Python":
    print(char)
    
"""
P
y
t
h
o
n
"""

• range() 함수와 함께 사용
  • range(n) 함수는 반복문에서 특정 범위를 숫자를 생성하는 데 유용합니다.
  • range(n) : 0부터 n - 1 까지 숫자 생성.
  • range(start, stop) : start 부터 stop - 1 까지 숫자 생성.
  • range(start, stop, step) : start 부터 stop - 1 까지 step 간격으로 생성.

# 0부터 4까지 출력
for i in range(5):
    print(i)
    
"""
0
1
2
3
4
"""

# 1부터 10까지 2씩 증가
for i in range(1, 11, 2):
    print(i)
    
"""
1
3
5
7
9
"""

• 중첩 for 반복문

for i in range(1, 4):
    for j in range(1, 4):
        print(f"i: {i}, j: {j}")
        
"""
i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 2, j: 1
i: 2, j: 2
i: 2, j: 3
i: 3, j: 1
i: 3, j: 2
i: 3, j: 3
"""

• break
  • break는 반복문을 즉시 종료합니다.

for i in range(10):
    if i == 5:
        break
    print(i)
    
"""
0
1
2
3
4
"""

• continue
  • continue는 현재 반복을 건너뛰고 다음 반복으로 넘어갑니다.

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
    
"""
1
3
5
7
9
"""

• enumerate() 함수 : 반복문에서 인덱스와 값을 동시에 가져올 때 유용합니다.

fruits = ['사과', '바나나', '체리']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
    
"""
0: 사과
1: 바나나
2: 체리
"""

출처 : https://school.programmers.co.kr/learn/courses/2

1. 리스트의 정의

• 리스트란
  • 여러 값을 하나의 변수에 저장할 수 있는 자료형.
  • 대괄호([])를 사용해 생성.
  • 다양한 자료형을 한 리스트에 저장 가능.

# 정수 리스트
numbers = [1, 2, 3, 4, 5]

# 문자열 리스트
fruits = ["apple", "banana", "cherry"]

# 혼합 리스트
mixed = [1, "hello", 3.14, True]

2.  리스트의 주요 특징

1. 순서 유지 (Ordered)
   1. 리스트는 요소가 추가된 순서를 유지하며, 각 요소는 고유한 인덱스(index)로 접근 가능.
2. 가변적 (Mutable)
   1. 생성된 후에도 요소를 변경, 추가, 삭제할 수 있습니다.
3. 중복 허용
   1. 동일한 값이 여러 번 포함될 수 있습니다.

data = [1, 2, 2, 3]
print(data)  # [1, 2, 2, 3]

3. 리스트의 기본 연산

• 인덱싱 (Indexing)
  1. 특정 위치의 요소에 접근.
  2. 인덱스는 0부터 시작.
  3. 음수 인덱스를 사용하면 뒤에서부터 접근.

data = [10, 20, 30, 40, 50]
print(data[0])   # 10 (첫 번째 요소)
print(data[-1])  # 50 (마지막 요소)

• 슬라이싱 (Slicing)
  1. 리스트의 특정 구간을 추출.
  2. 형식 : list[start:end] (start는 포함, end는 제외)

data = [1, 2, 3, 4, 5]
print(data[1:4])  # [2, 3, 4]
print(data[:3])   # [1, 2, 3] (처음부터)
print(data[3:])   # [4, 5] (끝까지)

• 리스트 연결
  1. + 연산자를 사용해 리스트를 결합.

list1 = [1, 2]
list2 = [3, 4]
print(list1 + list2)  # [1, 2, 3, 4]

• 리스트 반복
  1. * 연산자를 사용해 리스트 요소를 반복.

data = [1, 2]
print(data * 3)  # [1, 2, 1, 2, 1, 2]

4. 리스트의 주요 메서드

Python은 리스트와 관련된 유용한 메서드를 제공합니다.

data = [3, 1, 4, 1, 5]

# 요소 추가
data.append(9)
print(data)  # [3, 1, 4, 1, 5, 9]

# 정렬
data.sort()
print(data)  # [1, 1, 3, 4, 5, 9]

# 요소 삭제
data.remove(1)
print(data)  # [1, 3, 4, 5, 9]

5. 리스트 컴프리헨션

리스트 컴프리헨션(List Comprehension)은 리스트를 간결하게 생성할 수 있는 문법입니다.

# [expression for item in iterable if condition]

# 1부터 10까지의 제곱 리스트 생성
squares = [x ** 2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 짝수만 포함하는 리스트
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]

6. 리스트 활용 팁

• 중복 제거하기.
  1. 리스트를 집합(set)으로 변환 후 다시 리스트로 변환.

data = [1, 2, 2, 3, 4, 4]
unique_data = list(set(data))
print(unique_data)  # [1, 2, 3, 4]

• 리스트 합치기
  1. extend() 메서드를 사용하면 기존 리스트에 다른 리스트를 추가 가능.

list1 = [1, 2]
list2 = [3, 4]
list1.extend(list2)
print(list1)  # [1, 2, 3, 4]

출처 : https://school.programmers.co.kr/learn/courses/2