소소하게

중첩 함수란 하나의 함수 내에서 다른 함수를 정의하는 것을 말합니다.  중첩 함수는 해당 부모 함수 내부에서만 유효하며 외부에서 직접 접근할 수 없습니다. 중첩 함수는 주로 부모 함수 내에서만 필요한 보조 작업을 수행하기 위해 사용됩니다.

def outer_function():
    def inner_function():
        return "This is inner function."
    
    return inner_function()

# outer_function을 호출하여 중첩된 inner_function을 실행합니다.
result = outer_function()
print(result)  # 출력: This is inner function.

위의 예시에서 inner_function은 outer_function 내에서만 정의되었습니다. 이는 outer_function 외부에서는 직접적으로 접근할 수 없음을 의미합니다.

일급객체(first-class object)란 프로그래밍에서 아래에 나열된 특징을 가지는 모든 객체들을 가리킵니다. 

• 모든 요소는 할당 명령문의 대상이 될 수 있습니다.
• 모든 요소는 동일 (equal, ==) 비교의 대상이 될 수 있습니다.
• 모든 요소는 함수의 파라미터가 될 수 있습니다. 
• 모든 요소는 함수의 반환 값이 될 수 있습니다.

파이썬의 일급 객체는 다음과 같은 특징을 가지는 요소들이 있습니다.

• 함수 (Function): 함수는 변수에 할당되거나 다른 함수의 인자로 전달될 수 있습니다.
• 클래스 (Class): 클래스도 일급 객체로 간주됩니다. 
• 메서드 (Method): 클래스 내부의 함수도 일급 객체로 취급됩니다.

다음은 함수를 일급 객체로 이용한 예제입니다. 

def add(n1, n2):
    return n1 + n2

def subtract(n1, n2):
    return n1 - n2

def multiply(n1, n2):
    return n1 * n2

def divide(n1, n2):
    return n1 / n2

## int/string/float 등과 같이 함수도 일급 객체로 활용

def calculate(calc_function, n1, n2):
    return calc_function(n1, n2)

result = calculate(add, 2, 3)
print(result)

파이썬 무제한 인자  이해하기

파이썬에서 무제한 인자를 사용하면 함수에 임의 개수의 인자를 전달할 수 있습니다. 이를 통해 함수를 더 유연하게 작성할 수 있습니다.

1. *args (Positional Arguments)

•  *args는 임의 개수의 인자를 받아서 튜플(Tuple) 형태로 저장합니다.
• 함수 내에서 *args를 사용하면 여러 개의 인자를 처리할 수 있습니다.

def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)  # 출력: 1 2 3

2. **kwargs (Keyword Arguments)

• **kwargs는 임의 개수의 키워드 인자를 받아서 딕셔너리(Dictionary) 형태로 저장합니다.
• 함수 내에서 **kwargs를 사용하면 여러 개의 키워드 인자를 처리할 수 있습니다.  

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

print_kwargs(name="Alice", age=30)  # 출력: name: Alice, age: 30

데코레이터란 데코레이터는 기존의 함수나 클래스를 수정하지 않고 그 기능을 확장하거나 변경하는 방법을 제공합니다. 이는 함수형 프로그래밍의 아이디어 중 하나로, 코드를 재사용하고 가독성을 향상시키는 데 도움이 됩니다.

데코레이터의 구조

데코레이터는 보통 함수로 정의되며, 다른 함수를 인수로 받아 처리한 후 그 함수를 반환합니다. 데코레이터를 사용하여 함수에 추가적인 기능을 덧붙일 수 있습니다.

def decorator_function(func):
    def wrapper():
        print("Before calling the function")
        func()
        print("After calling the function")
    return wrapper

@decorator_function
def say_hello():
    print("Hello, world!")

say_hello()

출력 :
Before calling the function
Hello, world!
After calling the function

위의 코드에서 decorator_function은 데코레이터 함수로, say_hello 함수를 인수로 받아 그 기능을 수정하고 있는 것을 볼 수 있습니다.

데코레이터의 장점

1. 재사용성: 데코레이터를 사용하면 코드의 재사용성을 높일 수 있습니다. 동일한 기능을 여러 함수에 적용하려면 데코레이터를 각 함수에 적용하면 됩니다.
2. 가독성: 데코레이터를 사용하면 함수의 핵심 기능과 추가 기능을 분리하여 코드를 더 읽기 쉽게 만듭니다.
3. 유연성: 데코레이터를 사용하여 함수의 동작을 동적으로 변경할 수 있습니다. 이는 코드를 더 유연하고 확장 가능하게 만듭니다.

데코레이터의 활용

• 로깅(logging)
• 인증 및 권한 부여(authentication, authorization)
• 성능 측정
• 캐싱(caching)
• 예외 처리

1.  len() : 문자열 길이 구하기 

str = "Life is good"
lenStr = len(str)  # 문자열 길이 구하기
print(lenStr)  # 출력: 12

2. find(),  index() : 문자열 특정 문자  인덱스 찾기

text = "Hello, World!"
print(text.find("World"))   # 출력: 7
print(text.index("World"))  # 출력: 7

3. upper(), lower() : 문자열 대/소문자 변환하기

text = "Hello, World!"
print(text.lower())  # 출력: hello, world!
print(text.upper())  # 출력: HELLO, WORLD!

4. strip(), lstrip(), rstrip() : 문자열 양쪽, 왼쪽, 오른쪽 공백 제거하기 

text = "   Hello, World!   "
print(text.strip())   # 출력: Hello, World!
print(text.lstrip())  # 출력: Hello, World!   
print(text.rstrip())  # 출력:    Hello, World!

5. split() : 문자열을 구분자를 기준으로 분할하여 리스트로 반환하기 

text = "apple, banana, cherry"
print(text.split(", "))  # 출력: ['apple', 'banana', 'cherry']

6. join() : 문자열 리스트를 지정된 구분자로 연결하기 

words = ['apple', 'banana', 'cherry']
print(", ".join(words))  # 출력: apple, banana, cherry

7. startswith(prefix), endswitch(suffix) : 문자열이 특정 접두사 혹은 접미사로 시작/끝나는지 확인하기

text = "Hello, World!"
print(text.startswith("Hello"))  # 출력: True
print(text.endswith("World!"))   # 출력: True

8. replace(old, new) : 문자열에서 지정된 문자 대체하기 

text = "Hello, World!"
new_text = text.replace("World", "Python")
print(new_text)  # 출력: Hello, Python!

파이썬은 데이터를 효율적으로 관리할 수 있는 다양한 자료구조를 제공합니다. 그 중에서도 딕셔너리(Dictionary)는 키(key)와 값(value)으로 이루어진 유연한 데이터 구조로, 파이썬 프로그래밍에서 빠질 수 없는 중요한 요소 중 하나입니다. 

파이썬 딕셔너리의 기초

파이썬 딕셔너리는 중괄호 {}를 사용하여 정의하며, 키와 값은 콜론(:)으로 구분하여 표현됩니다. 

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

위의 예시에서 'name', 'age', 'city'는 키(key)이고, 'Alice', 30, 'New York'은 각각 해당하는 값(value)입니다. 딕셔너리는 키를 사용하여 값을 검색하고 수정할 수 있습니다.

딕셔너리의 활용

값 접근과 수정

딕셔너리에서 값에 접근하려면 대괄호 [ ] 안에 키를 넣어주면 됩니다.

print(my_dict['name'])  # 출력: Alice

키를 사용하여 값을 수정할 수도 있습니다

my_dict['age'] = 31
print(my_dict)  # 출력: {'name': 'Alice', 'age': 31, 'city': 'New York'}

새로운 키-값 쌍 추가

my_dict['gender'] = 'Female'
print(my_dict)  # 출력: {'name': 'Alice', 'age': 31, 'city': 'New York', 'gender': 'Female'}

새로운 키-값 쌍을 추가하려면 해당 키를 지정하고 값을 할당하면 됩니다

딕셔너리의 중첩

파이썬 딕셔너리는 중첩하여 사용할 수 있습니다. 다음은 중첩된 딕셔너리의 예시입니다

nested_dict = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25}
}

위의 예시에서는 'person1', 'person2'라는 키에 각각 다른 딕셔너리가 할당되어 있습니다.

심화: 복잡한 중첩 구조

더 복잡한 중첩 구조의 딕셔너리를 사용할 수도 있습니다. 

complex_dict = {
    'outer_dict': {
        'inner_dict_1': {
            'inner_list': [
                {'key1': 'value1'},
                {'key2': 'value2'}
            ]
        },
        'inner_dict_2': {
            'inner_list': [
                {'key3': 'value3'},
                {'key4': 'value4'}
            ]
        }
    }
}

위의 예시에서는 'outer_dict' 안에 두 개의 'inner_dict'가 있고, 각각의 'inner_dict' 안에는 리스트가 있으며, 리스트 안에는 또 다른 딕셔너리가 포함되어 있습니다.

중첩 구조의 출력 

# 중첩된 딕셔너리 값 출력 예시
print(complex_dict['outer_dict']['inner_dict_1']['inner_list'][0]['key1'])  # 출력: value1

결론

파이썬의 딕셔너리는 데이터를 효율적으로 관리하기 위한 강력한 도구입니다. 기초적인 사용법부터 복잡한 중첩 구조까지 다양한 형태로 활용할 수 있으며, 이를 통해 다양한 데이터를 효율적으로 다룰 수 있습니다. 딕셔너리의 활용은 파이썬 프로그래밍에서 중요한 부분이므로, 잘 익혀두는 것이 좋습니다.

이상으로 파이썬 딕셔너리에 대한 기초부터 심화까지의 내용을 다뤄보았습니다. 

Slice Notation이란?

Slice notation은 데이터 시퀀스의 부분을 선택하는 방법입니다. 이것은 데이터를 가져오거나 잘라낼 때 사용됩니다. 일반적으로 start:stop:step 형식으로 작성되며, 각각의 요소는 선택할 범위를 지정합니다. 각 요소는 선택적이며, 생략할 수 있습니다.

1. 기본 슬라이스 표기법

• a[start:stop]: start부터 stop-1까지의 아이템을 선택합니다.
• a[start:]: start부터 끝까지의 아이템을 선택합니다.
• a[:stop]: 처음부터 stop-1까지의 아이템을 선택합니다.
• a[:]: 전체 어레이의 복사본을 생성합니다.

2. Step 이용 

• a[start:stop:step]: start부터 시작하여 step-1까지의 step별 아이템을 선택합니다.

3.  음수 인덱스 

• a[-1]: 어레이의 마지막 아이템을 선택합니다.
• a[-2:]: 어레이의 마지막 두 개의 아이템을 선택합니다.
• a[:-2]: 마지막 두 개의 아이템을 제외한 모든 아이템을 선택합니다

4. 역순 슬라이싱

• a[::-1]: 어레이의 모든 아이템을 역순으로 선택합니다.
• a[1::-1]: 처음 두 개의 아이템을 역순으로 선택합니다.
• a[:-3:-1]: 마지막 두 개의 아이템을 역순으로 선택합니다.
• a[-3::-1]: 마지막 두 개의 아이템을 제외한 모든 아이템을 역순으로 선택합니다.

5. 예시

 - 리스트(List) 슬라이싱

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 인덱스 2부터 5(포함하지 않음)까지의 요소를 선택
print(my_list[2:5])  # 출력: [2, 3, 4]

# 리스트의 처음부터 인덱스 5까지의 요소를 선택
print(my_list[:5])   # 출력: [0, 1, 2, 3, 4]

# 인덱스 5부터 끝까지의 요소를 선택
print(my_list[5:])   # 출력: [5, 6, 7, 8, 9]

# 인덱스 1부터 끝까지의 요소를 하나 건너뛰며 선택
print(my_list[1::2])  # 출력: [1, 3, 5, 7, 9]

# 리스트를 역순으로 출력
print(my_list[::-1])  # 출력: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

 - 문자열(String) 슬라이싱

my_string = "Hello, World!"

# 문자열의 인덱스 7부터 12(포함하지 않음)까지의 부분 문자열을 선택
print(my_string[7:12])  # 출력: World

# 문자열의 처음부터 인덱스 5까지의 부분 문자열을 선택
print(my_string[:5])    # 출력: Hello

# 인덱스 7부터 끝까지의 부분 문자열을 선택
print(my_string[7:])    # 출력: World!

# 문자열을 역순으로 출력
print(my_string[::-1])  # 출력: !dlroW ,olleH

타입 힌트는 코드의 가독성을 높이고 협업 효율성을 향상시키는데 도움이 됩니다.

파이썬은 동적 프로그래밍 언어로, 변수의 자료형이 중간에 변경될 수 있습니다. 하지만 큰 프로젝트에서는 변수의 타입을 명시적으로 지정하는 것이 좋습니다. 이때 타입 힌트를 사용하면 변수나 함수의 인자, 반환값에 대한 타입을 명시할 수 있습니다.

기본 사용법 

name: str = "John Doe"
age: int = 30
email: list = ["john@example.com", "jeny@gmail.com"]

함수에 타입 힌트

def greeting(name: str) -> str:
	return "Hello "  + name

typing 모듈 활용

파이썬의 typing 모듈을 사용하면 더 구체적인 타입 힌트를 작성할 수 있습니다. 

from typing import List, Set, Dict, Tuple

nums_list: List[int] = [1, 2, 3]
nums_set: Set[int] = {1, 2, 3}
students: Dict[int, str] = {1: "Alice", 2: "Bob"}
student: Tuple[int, str, List[float]] = (19, "John", [178.1])

class User:
    ...

def find_user(user_id: str) -> User:
    ...

def create_user(user: User) -> User:
    ...

파이썬에서 간결하고 효율적으로 딕셔너리를 생성하는 방법입니다. 이 기능은 리스트 컴프리헨션과 유사하지만, 딕셔너리를 다루는 데 특화되어 있습니다.

아래는 딕셔너리 컴프리헨션에 대한 예시와 설명입니다:

딕셔너리 컴프리헨션의 기본 구조

딕셔너리 컴프리헨션은 다음과 같은 형태를 가집니다.

{key: value for item in iterable if condition}

#key: 딕셔너리의 키(Key)로 사용할 값
#value: 해당 키에 대응하는 값(Value)
#iterable: 반복 가능한 객체 (예: 리스트, 집합, 문자열 등)
#condition: 필터링 조건 (선택 사항)

사용예

names =["Alex", "Bath", "Dave"]
score = {name:100 for name in names}
print(score)

결과 : {'Alex': 100, 'Bath': 100, 'Dave': 100}

dict = {"aa":"111", "bb": "222", "cc": "333"}
new_dict ={key:value for (key, value) in dict.items() if key=="aa"}
print(new_dict)

결과 : {'aa': '111'}

List Comprehension

파이썬에서 리스트를 생성하는 간결하고 효율적인 방법입니다.

기본적인 형태는 new_list = [표현식 for 항목 in 반복대상 if 조건]으로, 반복 가능한 객체에서 조건문을 만족하는 항목에 대해 표현식을 적용하여 새로운 리스트를 생성합니다.

예를 들어, 다음과 같은 코드를 살펴보겠습니다:

number = [1,2,3]
new_number = [n+1 for n in number]
print(new_number)

number = [1,2,3,4]
new_number = [n for n in number if n%2==0]
print(new_number)