외곈 World 👽🌏

🎈 내장함수

파이썬에는 기본적으로 제공되는 내장 함수들이 있어 별도의 설치 없이 사용할 수 있다. 내장 함수는 데이터 처리, 입력/출력, 수학 계산 등 다양한 작업을 쉽게 수행할 수 있게 한다.

- abs(): 숫자의 절대값을 반하는 함수.

    print(abs(-5)) # 출력: 5

- all(): 반복 가능한 객체(리스트, 튜플 등) 안의 모든 값이 참이면 True를 반환하는 함수.

    print(all([True, 1, "hello"])) # 출력: True

- any(): 반복 가능한 객체 안의 값 중 하나라도 참이면 True를 반환하는 함수.

    print(any([False, 0, None, "text"])) # 출력: True

- chr(): 유니코드 값을 문자로 변환하는 함수.

  print(chr(65))  # 출력: 'A'

- ord(): 문자의 유니코드 값을 반환하는 함수.

  print(ord('A'))  # 출력: 65

- divmod(): 두 수를 나눈 몫과 나머지를 튜플로 반환하는 함수.

  print(divmod(10, 3))  # 출력: (3, 1)

- enumerate(): 반복 가능한 객체(리스트 등)에서 인덱스와 값을 함께 반환하는 함수.

  fruits = ['apple', 'banana']
  for index, fruit in enumerate(fruits):
      print(index, fruit)
  # 출력:
  # 0 apple
  # 1 banana

- eval(): 문자열 형태의 표현식을 실행하는 함수.

  print(eval("3 + 5"))  # 출력: 8

- filter(): 함수의 조건을 만족하는 요소만 걸러내는 함수.

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

- hex(): 정수를 16진수 문자열로 변환하는 함수.

  print(hex(255))  # 출력: '0xff'

- id(): 객체의 고유한 ID 값을 반환하는 함수.

  a = 3
  print(id(a))  # 출력: 메모리 주소값 (예: 140722945015568)

- int(): 문자열이나 실수를 정수로 변환하는 함수.

  print(int("10"))  # 출력: 10
  print(int(3.14))  # 출력: 3

- isinstance(): 인스턴스가 특정 클래스의 인스턴스인지 확인하는 함수.

  print(isinstance(5, int))  # 출력: True

- len(): 객체(문자열, 리스트 등)의 길이를 반환하는 함수.

  print(len("hello"))  # 출력: 5

- list(): 반복 가능한 객체를 리스트로 변환하는 함수.

  print(list("hello"))  # 출력: ['h', 'e', 'l', 'l', 'o']

- map(): 리스트 등의 각 요소에 함수를 적용하는 함수.

  numbers = [1, 2, 3]
  print(list(map(str, numbers)))  # 출력: ['1', '2', '3']

- max(): 반복 가능한 객체의 최댓값을 반환하는 함수.

  numbers = [10, 20, 30]
  print(max(numbers))  # 출력: 30

- min(): 반복 가능한 객체의 최솟값을 반환하는 함수.

  numbers = [10, 20, 30]
  print(min(numbers))  # 출력: 10

- pow(): x의 y 제곱을 반환하는 함수.

  print(pow(2, 3))  # 출력: 8

- range(): 정수 범위를 생성하는 함수.

  print(list(range(5)))  # 출력: [0, 1, 2, 3, 4]

- round(): 숫자를 반올림하는 함수.

  print(round(3.14159, 2))  # 출력: 3.14

- sorted(): 반복 가능한 객체를 정렬된 리스트로 반환하는 함수.

  numbers = [5, 2, 9, 1]
  print(sorted(numbers))  # 출력: [1, 2, 5, 9]

- str(): 객체를 문자열로 변환하는 함수.

  num = 100
  print(str(num))  # 출력: '100'

- sum(): 반복 가능한 객체의 합을 반환하는 함수.

  numbers = [1, 2, 3, 4, 5]
  print(sum(numbers))  # 출력: 15

- tuple(): 반복 가능한 객체를 튜플로 변환하는 함수.

  print(tuple("hello"))  # 출력: ('h', 'e', 'l', 'l', 'o')

- zip(): 여러 개의 리스트나 튜플을 짝지어주는 함수.

  names = ["Alice", "Bob"]
  scores = [90, 85]
  print(list(zip(names, scores)))  # 출력: [('Alice', 90), ('Bob', 85)]

예외 처리 (Exception Handling)

예외 처리는 코드 실행 중 발생할 수 있는 오류 상황을 처리하는 방법이다.

try, except, finally 구문을 사용하여 예외 발생 시 코드를 안전하게 종료하거나 특정 동작을 수행할 수 있다.

1. 기본적인 예외 처리 구조

try:
    # 예외가 발생할 가능성이 있는 코드
except ExceptionType:
    # 예외가 발생했을 때 실행되는 코드
else:
    # 예외가 발생하지 않았을 때 실행되는 코드
finally:
    # 예외 발생 여부와 상관없이 항상 실행되는 코드

• try: 예외가 발생할 가능성이 있는 코드를 작성. 예를 들어 파일을 열거나, 숫자를 0으로 나누는 등의 작업이 포함될 수 있다.
• except: 예외가 발생했을 때 실행할 코드를 작성. 발생한 예외 유형에 따라 여러 개의 except 블록을 지정할 수도 있다.
• else: 예외가 발생하지 않았을 때 실행되는 코드를 작성. else는 선택 사항으로, try 블록이 성공적으로 완료된 경우에만 실행된다.
• finally: 예외 발생 여부와 상관없이 항상 실행되는 코드를 작성. 파일을 열었다면 닫는 작업을 여기에 넣을 수 있다.

# 예제 코드 

사용자가 입력한 숫자를 100으로 나누는 프로그램으로,여기서 발생할 수 있는 ValueError와 ZeroDivisionError 예외를 처리하는 코드

try:
    num = int(input("숫자를 입력하세요: "))
    result = 100 / num
except ValueError:
    print("유효한 숫자가 아닙니다. 숫자를 입력해주세요.")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
else:
    print(f"결과: {result}")
finally:
    print("프로그램이 종료되었습니다.")

• try 블록에서는 사용자가 입력한 값을 정수로 변환한 후, 100을 그 값으로 나누는 연산을 수행.
• except ValueError 블록은 사용자가 숫자가 아닌 값을 입력했을 때 실행되며, "유효한 숫자가 아닙니다"라는 메시지를 출력.
• except ZeroDivisionError 블록은 사용자가 0을 입력했을 때 실행되며, "0으로 나눌 수 없습니다"라는 메시지를 출력.
• else 블록은 예외가 없을 경우 실행되며, 나눗셈 결과를 출력.
• finally 블록은 예외 발생 여부와 관계없이 항상 실행되며, "프로그램이 종료되었습니다"라는 메시지를 출력.

이와 같은 예외 처리 방식으로 프로그램은 오류 상황에서도 안전하게 작동할 수 있다.

1. 모듈 (Modules)

모듈은 Python 코드가 포함된 파일로, 다른 Python 파일에서 이를 불러와 사용할 수 있다. 모듈은 코드 재사용성을 높이고, 코드를 구조화하여 유지보수에 용이하게 한다. 모듈을 사용하려면 import 키워드를 통해 불러올 수 있다.

# example_module.py 파일

def greet(name):  
print(f"Hello, {name}!")

다른 파일에서 불러오기:

import example_module
example_module.greet("Cheolsu")  # Output: Hello, Cheolsu!

2. 패키지 (Packages)

패키지는 모듈들을 디렉토리로 묶어 관리하는 방식이다. 패키지의 각 디렉토리에는 __init__.py 파일이 포함되어 있어 Python이 이 디렉토리를 패키지로 인식하게 한다. 이를 통해 계층 구조의 코드 모듈을 관리할 수 있다.

my_package/
├── __init__.py
├── module1.py
└── module2.py

불러오기 예시:

from my_package import module1
module1.some_function()

d = Dog("Buddy")
d.bark()  # Output: Buddy says woof!

1. 클래스의 정의

클래스는 객체지향 프로그래밍에서 코드의 재사용성을 높이기 위한 구조이다. 클래스는 특정 기능을 가진 데이터와 함수를 포함하며, 새로운 객체를 생성하는 틀로 활용된다. Python에서 클래스는 class 키워드를 사용해 정의할 수 있다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, {self.name}!")

Person 클래스는 이름과 나이를 속성으로 가지며, greet 메서드를 통해 인사말을 출력할 수 있다. 객체는 클래스를 기반으로 생성되며, 이를 통해 클래스를 호출하여 새로운 인스턴스를 만들 수 있다.

* self는 Python에서 클래스 인스턴스 자신을 참조하기 위한 특별한 변수다. 클래스의 메서드를 정의할 때 항상 첫 번째 매개변수로 self를 적어야 하며, 이를 통해 해당 인스턴스의 속성이나 메서드에 접근할 수 있다. JavaScript에서는 일반적으로 this를 통해 객체 내부의 프로퍼티에 접근하는데, Python에서는 self를 명시적으로 전달해야 한다.

p = Person("Cheolsu", 20)
p.greet()  # Output: Hello, Cheolsu!

2. __init__ 메서드 (Initializer)

__init__ 메서드는 클래스로부터 생성된 객체의 초기값을 설정하는 특별한 메서드이다. 객체 생성 시 자동으로 호출되며, 속성을 초기화한다. 여기서 첫 번째 매개변수 self는 해당 인스턴스를 나타내며, Python 클래스 메서드에서 항상 첫 번째 매개변수로 사용된다.

class Animal:
    def __init__(self, species, sound):
        self.species = species
        self.sound = sound

    def make_sound(self):
        print(f"{self.species} makes {self.sound}")

a = Animal("Cat", "meow")
a.make_sound()  # Output: Cat makes meow

3. 클래스 속성과 인스턴스 속성

클래스 속성은 클래스 자체에 속하는 반면, 인스턴스 속성은 특정 인스턴스에 속한다. 클래스 속성은 모든 인스턴스에서 공유되며, 객체를 생성하지 않고 클래스명으로 접근할 수 있다.

class Car:
    wheels = 4  # 클래스 속성

    def __init__(self, color):
        self.color = color  # 인스턴스 속성

print(Car.wheels)  # Output: 4
car1 = Car("Red")
print(car1.color)  # Output: Red

4. 메서드(Method)

클래스 내부에서 정의된 함수는 메서드라 불리며, 객체의 동작을 정의한다. 메서드는 객체를 통해 호출되며, 메서드 내부에서 인스턴스 속성에 접근할 수 있다.

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

    def bark(self):
        print(f"{self.name} says woof!")

5. 상속(Inheritance)

상속은 기존 클래스를 확장하여 새로운 클래스를 만드는 방법이다. 상속을 통해 코드 중복을 줄일 수 있으며, 상위 클래스의 속성과 메서드를 하위 클래스가 물려받는다.

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

    def speak(self):
        return "Sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

d = Dog("Dog")
print(d.speak())  # Output: Bark

6. super() 함수

하위 클래스에서 상위 클래스의 메서드를 호출할 때 super() 함수를 사용한다. 이를 통해 상위 클래스의 기능을 확장할 수 있다.

class Bird(Animal):
    def __init__(self, species, can_fly):
        super().__init__(species)
        self.can_fly = can_fly        

7. 매직 메서드 (Magic Method)

매직 메서드는 특별한 기능을 수행하는 메서드로, 두 언더스코어(__)로 시작하고 끝나는 메서드다. 예를 들어, __str__은 객체를 문자열로 표현할 때 사용되며, __len__은 객체의 길이를 반환하는 데 사용된다.

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages

    def __str__(self):
        return f"{self.title} ({self.pages} pages)"

b = Book("Python Basics", 250)
print(b)  # Output: Python Basics (250 pages)

8. 클래스와 인스턴스 메서드

클래스 메서드는 @classmethod 데코레이터로 정의하며, 클래스 자체에 대한 동작을 수행한다. 반면, 인스턴스 메서드는 특정 인스턴스에 대한 동작을 수행한다.

class MyClass:
    @classmethod
    def class_method(cls):
        print("Class method called")

9. 정적 메서드 (Static Method)

정적 메서드는 특정 인스턴스나 클래스에 의존하지 않는 메서드이다. @staticmethod 데코레이터를 사용해 정의하며, 독립적으로 동작하는 함수를 클래스 내부에 정의할 수 있다.

class Math:
    @staticmethod
    def add(a, b):
        return a + b

print(Math.add(3, 5))  # Output: 8

10. 객체지향의 특징: 캡슐화, 상속, 다형성

• 캡슐화는 객체의 세부 구현을 감추고, 외부에는 인터페이스만 제공하는 방식이다. 이를 통해 외부에서는 객체 내부의 복잡한 로직을 알 필요 없이 필요한 정보에만 접근할 수 있다.
• 상속은 기존 클래스의 속성과 메서드를 새로운 클래스가 물려받아 재사용할 수 있게 한다. 코드의 중복을 줄이고 유지보수를 용이하게 한다.
• 다형성은 동일한 인터페이스를 사용하여 다른 동작을 수행할 수 있게 하는 특징이다. 예를 들어, 여러 클래스가 같은 이름의 메서드를 가지고 있어도 각 클래스의 동작에 맞게 사용할 수 있다.

React와 Vite 프로젝트를 시작을 위한 셋팅하기

npm create vite@latest 프로젝트명 --template react

npm create vite@latest 프로젝트명 --template react-ts

cd 프로젝트명

npm install

npm run dev

🎈 Vite를 사용한 이유

Vite를 프로젝트에 사용한 이유는 빠르고 효율적인 개발 환경을 제공하기 때문이다. Vite는 특히 초기 로딩과 실시간 개발에서 탁월한 성능을 보이며, 이러한 장점이 프로젝트 진행을  원활하게 만들어준다. 구체적으로는 다음과 같은 이유에서 Vite를 선택했다.

1. 빠른 개발 서버 시작: Vite는 모듈 기반으로 필요한 파일만 로딩하므로, 개발 서버가 즉시 시작된다. 특히 프로젝트 규모가 커질수록 이러한 빠른 로딩 속도는 큰 차이를 만든다. 개발 초기부터 빠르게 테스트하고 피드백을 받을 수 있어 개발 속도가 향상된다.
2. 효율적인 Hot Module Replacement (HMR): Vite는 변경된 모듈만 갱신하는 방식의 HMR을 지원하여, 코드 수정 후 즉각적으로 화면에 반영된다. 이로 인해 코드 수정 사항을 실시간으로 확인하며 개발할 수 있어 작업 효율성이 높아진다.
3. 최적화된 빌드: Vite는 개발 환경과 빌드 환경을 각각 최적화하여 사용한다. 개발 중에는 ESM(ES 모듈)을 사용하고, 최종 빌드 시에는 Rollup을 통해 번들링을 최적화하여 성능 좋은 결과물을 만들 수 있다.
4. 설정의 간단함과 유연성: Vite는 설정이 간단해 빠르게 개발을 시작할 수 있도록 돕는다. vite.config.js를 통해 필요한 설정을 쉽게 변경할 수 있으며, React와 같은 프레임워크와도 자연스럽게 통합되어 추가 설정 없이도 개발을 진행하기 용이하다.

이러한 이유로 Vite는 프로젝트에서 빠르고 효율적인 개발 환경을 지원하며, 초기 로딩부터 빌드까지 개발자가 원하는 성능과 유연성을 제공한다. Vite를 통해 생산성을 높이고 개발 프로세스를 간소화하는 것이 주요 목적이었다.

🎈 기타 다른 번들러 도구들

🌼 피그마 단축키

# 피그마 썸네일 설정

프레임 기본 사이즈 : 1920*1080

보호영역 : 1600*1080

# 속성 피그마

• 작업은 중앙 캔버스에서
• 디자인 속성 설정은 오른쪽 디자인 탭에서 (추가+, 빼기-)
• 캔버스 확대 축소는 ctrl +/- , ctrl 마우스 휠 ⬆/⬇ 
• 화면 이동은 스페이스바 누르며 이동
• 요소를 맨 앞으로 가져올때는 ]  / 맨 뒤로 보낼때는 [
• 레이어 복제 : alt 누른채로 드래그 앤 드롭 or ctrl + d
  
  

함수 (Functions)

1. 함수 정의 (Defining a Function)

함수는 반복적인 작업을 모듈화하여 코드 재사용성을 높이는 방법이다. def 키워드를 사용해 함수를 정의하며, 함수 이름과 괄호 안에 매개변수를 작성할 수 있다. 함수는 호출되었을 때에만 실행된다.

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("철수")  # 출력: 안녕하세요, 철수님!

2. 매개변수와 인자 (Parameters and Arguments)

함수는 매개변수를 사용해 외부에서 값을 전달받을 수 있다. 함수 호출 시 전달되는 값을 인자라고 한다. 매개변수는 함수 내부에서 변수를 선언한 것과 같은 역할을 한다.

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

result = add(3, 4)
print(result)  # 출력: 7

3. 기본 매개변수 (Default Parameters)

함수를 정의할 때 기본값을 설정할 수 있다. 함수 호출 시 해당 인자가 전달되지 않으면 기본값이 사용된다.

기본 매개변수는 매개변수의 순서가 중요하며, 기본값이 없는 매개변수보다 뒤에 위치해야 한다.

def greet(name="친구"):
    print(f"안녕하세요, {name}님!")

greet()  # 출력: 안녕하세요, 친구님!
greet("영희")  # 출력: 안녕하세요, 영희님!

1. 기본 매개변수 정의 및 규칙

기본값이 없는 매개변수는 먼저 작성되고, 기본값이 있는 매개변수는 뒤에 작성해야 한다.

기본값이 없는 매개변수는 반드시 기본값이 있는 매개변수보다 앞에 위치해야 합니다.

def add(a, b=3):
    return a + b
    
# a 값만 전달하면 b는 기본값 3을 사용
print(add(2))  # 출력: 5

이 함수는 a는 필수 매개변수로 받고, b는 기본값 3을 가진다. 함수 호출 시 b 값을 제공하지 않으면 기본값이 사용된다.

잘못된 매개변수 사용 예시:: 기본값이 없는 매개변수는 반드시 기본값이 있는 매개변수보다 앞에 위치해야 한다.

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

print(add(b=3))  
# 오류 발생: 기본값이 없는 매개변수 b가 기본값이 있는 매개변수 a 뒤에 위치해 있어 오류가 발생.
# 기본값이 없는 매개변수 b는 기본값이 있는 매개변수 a 앞에 위치해야 함.

# 수정된 함수
def add(b, a=1):
    return a + b

print(add(b=3))  # 출력: 4

4. 반환값 (Return Value)

함수는 return 키워드를 사용해 값을 반환할 수 있다. return을 만나면 함수는 실행을 종료하고, 값을 반환한다. 반환된 값은 함수 호출 시 변수에 저장되거나 다른 계산에 사용할 수 있다.

def multiply(a, b):
    return a * b

result = multiply(5, 6)
print(result)  # 출력: 30

5. 가변 인자 (Variable-length Arguments)

가변 인자는 함수가 몇 개의 인자를 받을지 미리 알 수 없을 때 사용된다.

*args는 위치 기반의 가변 인자를, **kwargs는 키워드 기반의 가변 인자를 의미한다.

하나의 함수에서 여러 개의 인자를 받을 수 있다.

*args

• *args는 여러 개의 위치 인자를 하나의 튜플로 받는다.
• 인자 개수가 정해져 있지 않을 때 사용한다.

def sum_all(*args):
    return sum(args)

result = sum_all(1, 2, 3, 4, 5)
print(result)  # 출력: 15

**kwargs

• **kwargs는 여러 개의 키워드 인자를 하나의 딕셔너리로 받는다.
• kwargs.items()는 딕셔너리의 키와 값을 가져올 때 사용한다.

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="영희", age=30)  
# 출력:
# name: 영희
# age: 30

+) JavaScript에서도 유사하게 가변 인자를 사용할 수 있다. 

스프레드 연산자(...)는 Python의 *args와 유사하게 동작하며, 객체로 받은 인자는 kwargs와 비슷하다.

// JavaScript에서 가변 인자
function sumAll(...args) {
    return args.reduce((acc, cur) => acc + cur, 0);
}

console.log(sumAll(1, 2, 3, 4, 5));  // 출력: 15

// JavaScript에서 객체 키-값 받기
function printInfo(obj) {
    for (let key in obj) {
        console.log(`${key}: ${obj[key]}`);
    }
}

printInfo({ name: "영희", age: 30 });
// 출력:// name: 영희// age: 30

6. 람다 함수 (Lambda Functions)

람다 함수는 익명 함수로, 이름 없이 사용할 수 있는 간단한 함수이다. 주로 일회성 함수나 코드가 짧을 때 사용한다. lambda 키워드를 사용하며, 함수의 매개변수와 반환값을 간단히 정의할 수 있다.

# 람다 함수 예시
square = lambda x: x ** 2
print(square(5))  # 출력: 25

# 일반 함수로 작성한 경우
def square_fn(x):
    return x ** 2

print(square_fn(5))  # 출력: 25

• lambda x : x는 매개변수. 함수의 인자를 의미한다.
• x ** 2 : **는 제곱 연산자로, x의 제곱을 계산한다. 따라서 x가 5라면 x ** 2는 5 ** 2가 되어 25가 된다.
• x ** 3은 x의 세제곱을 의미합니다. 즉, x를 3번 곱한 결과를 반환합니다. x**3은 125(5의 세제곱)가 된다.

1. If문

if문은 주어진 조건이 참일 경우에만 코드 블록을 실행한다. 조건이 True일 때만 들여쓰기된 코드가 실행된다.

x = 10
if x > 5:
    print("x는 5보다 큽니다.")  # 출력: x는 5보다 큽니다.
else:
    print("x는 5 이하입니다.")

2. For문

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

# range()를 사용해 숫자 시퀀스를 반복
for i in range(3):
    print(i)  # 출력: 0, 1, 2

3. While문 

while문은 조건이 참인 동안 코드를 반복 실행한다. 조건이 False가 되거나 break를 만나면 반복이 종료된다.

x = 0
while x < 5:
    print(x)  # 출력: 0, 1, 2, 3, 4
    x += 1

import random

target = random.randint(1, 10)  # 1부터 10 사이의 랜덤 숫자를 생성

while True:
    guess = int(input("1-10 사이의 숫자를 입력하세요: "))  # 사용자 입력을 받음
    if guess == target:
        print("정답😆")
        break  # 정답을 맞췄으므로 반복 종료
    elif guess < target:
        print("up😉") # 입력한 숫자가 목표 숫자보다 작을 때
    elif guess > target:
        print("down😉") # 입력한 숫자가 목표 숫자보다 클 때