kinggoddino 님의 블로그

[Git] 이미 추적 중인 파일 제거

kinggoddino — Wed, 27 Nov 2024 23:13:04 +0900

.gitignore 파일에 경로 추가

.gitignore 파일에 무시하고 싶은 파일 및 폴더 경로를 추가한다.

my_pjt/config.py
.idea/

Git에서 추적 중인 파일 제거

아직 .gitignore에 포함하지 않은 상태에서 git init 명령어를 실행하여

이미 Git에서 추적 중이라면,

staging area에서 제거해준다.

git rm --cached my_pjt/config.py
git rm -r --cached .idea

git rm --cached my_pjt/config.py: config.py 파일을 staging area에서 제거
git rm -r --cached .idea: .idea 폴더와 그 하위 파일들을 staging area에서 제거
--cached 옵션: 파일이 로컬 시스템에는 남아 있지만, Git에서는 추적하지 않게 됨

오류

user@NS2409101124 MINGW64 ~/Desktop/Pinterest (dev)
$ git rm --cached pinterest/config.py
error: the following file has staged content different from both the
file and the HEAD:
    pinterest/config.py
(use -f to force removal)

my_pjt/config.py 파일이 현재 staging area에 있으며,

HEAD와 파일 상태가 달라서 Git이 안전을 위해 제거를 막고 있다는 의미임.

-f 옵션을 사용하여 강제로 제거 해주면 된다.

강제 제거 명령어 실행

git rm --cached -f pinterest/config.py
git rm -r --cached .idea

.gitignore에 이미 추가된 상태이므로 앞으로는 Git에서 이 파일을 무시하게 됨

[Python] 데코레이터 decorator

kinggoddino — Tue, 26 Nov 2024 23:12:41 +0900

데코레이터

이름 그대로 파이썬의 함수를 장식해주는 역할
데코레이터는 선언되는 함수 위에 @를 사용해 @decorator 형태로 작성함
해당 함수가 실행될 때 데코레이터에서 선언 된 코드가 같이 실행된다

데코레이터 코드 구조

# 데코레이터는 호출 할 함수를 인자로 받도록 선언합니다.
def decorator(func):
    # 호출 할 함수를 감싸는 wrapper 함수를 선언합니다.
    def wrapper():
        # func.__name__에는 데코레이터를 호출 한 함수의 이름이 들어갑니다.
        print(f"{func.__name__} 함수에서 데코레이터 호출")
        func()
        print(f"{func.__name__} 함수에서 데코레이터 끝")

    # wrapper 함수를 리턴합니다.
    return wrapper

1. 데코레이터로 사용할 함수를 선언

- func을 인자로 받는다

- 함수 안에 함수가 있는 구조임

- 호출할 함수를 감싸주는 wrapper 함수 선언

@decorator
def decorator_func():
    print("decorator_func 함수 호출")

decorator_func()

# result output
"""
decorator_func 함수에서 데코레이터 호출
decorator_func 함수 호출
decorator_func 함수에서 데코레이터 끝
"""

2. 선언되는 함수 위에 @decorator를 추가해 데코레이터를 사용 가능

- @ 뒤에 오는 이름은 내가 선언한 데코레이터 함수 이름을 의미함

- 1번에서 "decorator" 라는 이름으로 함수를 만들었기 때문에 @decorator

정리

데코레이터 함수를 정의한 이후에는 @decorator 형태를 사용해서

특정 함수가 실행될 때, 데코레이터를 같이 실행해줄 수 있다

또는 함수가 실행되기 전, 후에 내가 원하는 코드를 실행 할 수 있음

데코레이터 예제

내가 실행하는 함수의 실행 시간이 얼마나 걸렸는지 확인하는 코드

# 특정 함수의 실행 시간 구하기
import time
import random

def time_checker(func):
    def wrapper():
        # 함수가 실행될 때 시간을 저장
        start_time = time.time()

        # 함수를 실행
        func()

        # 함수가 종료된 후 시간에 실행될 때 시간을 빼 실행 시간을 구함
        executed_time = time.time() - start_time

        # 실행 시간을 소수점 5자리까지만 출력
        print(f"{func.__name__} 함수의 실행시간 : {executed_time:.05f}s")

    return wrapper

@time_checker
def main():
    # 함수의 실행 시간을 테스트하기 위해 0.1초 ~ 1초간 sleep
    time.sleep(random.randint(1, 10) / 10)

for i in range(10):
    main()

# result output
"""
main 함수의 실행시간 : 0.80095s
main 함수의 실행시간 : 0.90009s
main 함수의 실행시간 : 1.00027s
main 함수의 실행시간 : 0.20020s
main 함수의 실행시간 : 0.90011s
main 함수의 실행시간 : 0.60041s
main 함수의 실행시간 : 0.30027s
main 함수의 실행시간 : 0.40024s
main 함수의 실행시간 : 0.10026s
main 함수의 실행시간 : 0.50032s
"""

이런식으로 다양한 활용 가능!

ex) 사용자 권한 체크 - 인증된 사용자만 실행가능하도록 만들기

예를 들어 login_required 라는 데코레이터를 만들어서,

사용자가 인증된 사용자인지 체크하는 코드를 넣은 후,

if 문으로 분기하여 인증 여부에 따라 함수 실행 여부를 나누면 된다.

실제로 많이 사용되는 방식임.

인자가 있는 함수의 데코레이터 예제

wrapper 함수에 인자를 받아준다.

# 입력받은 인자에 2를 곱해주기
def double_number(func):
    def wrapper(a, b):
        # 함수에서 받은 인자에 2를 곱해준다
        double_a = a * 2
        double_b = b * 2

        return func(double_a, double_b)
    return wrapper


@double_number
def double_number_add(a, b):
    return a + b


def add(a, b):
    return a + b
    
    
print(double_number_add(5, 10))  # 30
print(add(5, 10))                # 15

double_number 데코레이터를 사용할 경우, 각 숫자에 2를 곱해준 값을 기준으로 계산한 결과가 출력되는 것을 확인할 수 있다.

이런식으로 함수에 인자가 있을 때도

데코레이터에서 그 인자를 동일하게 받아서 사용할 수 있다

그리고

어떤 함수에든 데코레이터를 갖다 붙히기만 하면

내가 원하는 방식으로 코드를 실행할 수 있우

[Python] itertools

kinggoddino — Mon, 25 Nov 2024 22:50:12 +0900

itertools

효율적인 루핑을 위한 이터레이터를 만드는 함수.

특정 패턴이 무한하게 반복되는 배열을 만들거나 배열의 값을 일괄적으로 계산하는 등의 작업을 할 수 있음.

그 중 조합형 이터레이터에 대해서만 알아볼 예정

1. 데카르트곱 구하기

from itertools import product

sample1 = ["A", "B", "C", "D", "E"]
sample2 = [1, 2, 3, 4]

# 행 / 열을 구분하여 프린트 하기 위해 enumerate 사용
for i, v in enumerate(product(sample1, sample2), 1):
    print(v, end=" ")
    if i % len(sample2) == 0:
        print("")

# result output
"""
('A', 1) ('A', 2) ('A', 3) ('A', 4) 
('B', 1) ('B', 2) ('B', 3) ('B', 4) 
('C', 1) ('C', 2) ('C', 3) ('C', 4) 
('D', 1) ('D', 2) ('D', 3) ('D', 4) 
('E', 1) ('E', 2) ('E', 3) ('E', 4) 
"""

itertools 를 사용하려면 모듈을 import 해줘야함.

여기서는 데카르트 곱을 만들기 위해 product 모듈을 import 했다.

product 안에 sample data 를 넣어주기만 하면 끝난다.

product(sample1, sample2)

나머지는 표 형태로 결과를 출력하기 위해 enumerate 등을 사용한거임.

2. 원소의 개수가 n개인 순열

from itertools import permutations

sample = ["A", "B", "C"]

# 원소의 개수가 3개인 순열 출력
for i in permutations(sample, 3):
    print(i)

# result output
"""
('A', 'B', 'C')
('A', 'C', 'B')
('B', 'A', 'C')
('B', 'C', 'A')
('C', 'A', 'B')
('C', 'B', 'A')
"""

3. 원소의 개수가 n개인 조합 구하기

from itertools import combinations

sample = ["A", "B", "C"]

# 원소의 개수가 2개인 조합 출력
for i in combinations(sample, 2):
    print(i)

# result output
"""
('A', 'B')
('A', 'C')
('B', 'C')
"""

4. 원소의 개수가 n개인 조합 구하기(중복 허용)

from itertools import combinations_with_replacement

sample = ["A", "B", "C"]

# 중복을 포함한 원소의 개수가 3개인 조합 출력
for i in combinations_with_replacement(sample, 3):
    print(i)

# result output
"""
('A', 'A', 'A')
('A', 'A', 'B')
('A', 'A', 'C')
('A', 'B', 'B')
('A', 'B', 'C')
('A', 'C', 'C')
('B', 'B', 'B')
('B', 'B', 'C')
('B', 'C', 'C')
('C', 'C', 'C')
"""

그 외 이터레이터에 대한 참고

https://docs.python.org/ko/3/library/itertools.html

itertools — Functions creating iterators for efficient looping

This module implements a number of iterator building blocks inspired by constructs from APL, Haskell, and SML. Each has been recast in a form suitable for Python. The module standardizes a core set...

docs.python.org

itertools 에서 import 해서 사용한 모듈들은

보통 알고리즘, 혹은 프로젝트에 수학적 로직이 필요할 경우에 사용됨.

어떤 모듈이 어떤 기능을 하는지 외울 필요는 없고,

이런걸 할 수 있구나 정도만 알고 넘어간 후에

필요할 때마다 링크 들어가서 찾아보고 갖다 쓰면 된다.

코드컨벤션

kinggoddino — Sun, 24 Nov 2024 21:03:36 +0900

https://peps.python.org/pep-0008/

PEP 8 – Style Guide for Python Code | peps.python.org

This document gives coding conventions for the Python code comprising the standard library in the main Python distribution. Please see the companion informational PEP describing style guidelines for the C code in the C implementation of Python.

peps.python.org

1. 네이밍 컨벤션

파이썬에서는 네이밍 컨벤션으로 변수 / 함수를 네이밍할 때는 Snake 표기법을,

Class를 네이밍할 때는 Pascal 표기법을 사용한다.

1-1. Pascal

: PythonIsVeryGood / 각 단어를 대문자로 구별한다.

1-2. Camel

: pythonIsVeryGood / Pascal과 동일하지만, 첫 문자가 소문자로 시작한다.

모양이 쌍봉낙타와 비슷하게 생겼다고 해서 지어진 이름.

Camel 표현식은 첫 번째 문자가 소문자로 시작하는 Lower Camel Case와
첫 번째 문자가 대문자로 시작하는 Upper Camel Case가 존재한다.

이 때문에 간혹 Pascal과 Camel 표현법의 용어가 혼동되기도 하는데,
Microsoft에서는 소문자로 시작하는 표현법만 Camel로, 대문자로 시작하는 것은
Pascal이라고 명시하고 있다.

더 자세한 내용
https://en.wikipedia.org/wiki/Camel_case

Camel case - Wikipedia

From Wikipedia, the free encyclopedia Writing words with internal uppercase letters Camel case is named after the "hump" of its protruding capital letter, similar to the hump of common camels. Camel case (sometimes stylized autologically as camelCase or Ca

en.wikipedia.org

1-3. Snake

: python_is_very_good / 각 단어를 언더바( _ )로 구분한다.

모양이 뱀과 비슷하게 생겼다고 해서 지어진 이름.

1-4. 예시

# 함수정의
def HelloWorld():   # X
def hello_world():  # O

# 변수선언
hello_world = "123"   # O
Hello_World = "123"   # X

# 클래스선언
class HelloWorld():   # O
class hello_world():  # X

2. 네이밍

클래스, 함수, 변수 등을 네이밍할 때는 이름만 보고 해당 코드가 어떤걸 의미하는지 추측할 수 있어야 한다.

PIE = 3.14 상수를 표현할 때는 예외적으로 모든 문자를 대문자로 표현함.
numbers = [1,2,3,4] list를 표기할 때는 복수로 표현한다. 혹은 number_list와 같이 표현할 수도 있음.
- for number in numbers: 반복문 사용 시 가독성을 늘릴 수 있다.
def add(a, b): return a + b 함수를 네이밍할 때는 해당 함수가 어떤 역할을 하는지 표현해야 한다.

# 상수 정의 (한번 선언하고 바뀌지 않는 값)
PIE = 3.14
PIE = 1        # (코드컨벤션 틀림)
print(PIE)     # 1 (문법에 문제는 없지만 코드컨벤션이 틀림)

NUMBER_LIST    # 긴 상수 정의

3. VScode

확장 프로그램 autopep8 설치 후 settings 에서 설정해줌

settings 에서 저장 시 autopep8 활성화 시켜줌

4. Pycharm

pip install black

설정에서 black 검색 후 저장 시 black 활성화 시켜줌

변수 유효 범위 variable scope

kinggoddino — Sat, 23 Nov 2024 01:08:32 +0900

python을 포함한 대부분의 언어에는

변수 유효 범위

라는 개념이 있음

변수가 선언된 위치나 키워드에 따라 변수를 사용할 수 있는 범위가 달라지는데,
이를 변수 유효 범위 혹은 variable scope라고 부른다.

파이썬에서 변수는 유효 범위에 따라 두 가지로 나뉜다.

지역 변수(local variable) : 함수 내부에서 선언되며 다른 함수에 영향을 끼치지 않음
전역 변수(global variable) : 함수 밖에서 선언되며 어디서든 접근할 수 있음

지역 변수(local variable)

지역 변수로 선언된 변수는 global 키워드를 사용해 전역 변수로 재선언할 수 있다.

def func1():
    number = 10 # 함수 내에서 number라는 지역 변수를 선언
    
def func2():
    print(number) # func1에서 생성된 지역 변수는 funt2에서 접근할 수 없다.
    
func1()
func2()

"""
NameError: name 'number' is not defined
"""

전역 변수(global variable)

일단 선언만 해주면 함수 밖, 안 어디서든 자유롭게 접근할 수 있다.

number = 10 # 함수 밖에서 number라는 전역 변수 생성

def func():
    print(number) # 전역 변수는 자유롭게 접근할 수 있다.
    
func() # 함수를 실행하면 10이 정상적으로 출력된다.

그럼 무조건 전역 변수로 선언하는 게 좋은거 아닌가

라고 생각할 수 있지만 문제점도 있다.

전역 변수 사용 시 주의할 점

1) 함수 내에서 전역 변수의 값을 바꾸려 할 경우

number = 10

def func():
    number = 5 # 전역 변수의 값이 바뀌는 것이 아닌, 지역 변수로 다시 선언됨
    
func()

print(number)  # 10
# 함수 내에서 재할당 된 지역 변수는 전역 변수에 영향을 끼치지 않음

2) 전역 변수 사용과 지역 변수 할당을 같이 하는 경우

number = 10

# 전역 변수인 10을 출력하고 지역 변수로 다시 선언하는 코드 작성
def func():
    print(number)
    number = 5

func()
# 실행시켜 보면 에러가 발생함
"""
UnboundLocalError: local variable 'number' referenced before assignment
"""

왜 UnboundLocalError가 발생할까?

함수 내부에서 전역 변수와 동일한 이름으로 지역 변수를 할당할 경우,

함수에서는 해당 변수를 지역 변수로 간주한다.

즉, number 는 이제 전역 변수가 아니라 지역 변수가 되었음.

따라서 func() 함수 내의 print(number) 에서는

아랫줄에서 number 지역 변수가 선언되기 이전에 출력을 시도한 셈.

3) 함수 내에서 전역 변수의 값을 바꾸려면?

test = 123

def func():
    test = 456
    print(test)
    
def func2():
    print(test)
    
func()    # 456
func2()   # 123

global 키워드를 사용해 함수 내에서 전역 변수를 다시 할당할 수 있긴함

number = 10

def func():
    global number # 함수에서 number 변수를 다시 할당할 수 있도록 해줌
    number = 5 # global 키워드를 사용했기 때문에 전역 변수의 값이 변경됨
    print(number)
    
func()   # 5

근데 권장하지는 않음.

전역 변수를 권장하지 않는 이유

파이썬을 포함한 많은 프로그래밍 언어에서 전역 변수를 남용하는 것은 권장하지 않음.

코드가 길어질수록 전역 변수로 선언 된 값은 어디서 값이 변했는지 추적하기 어렵고,
문제가 생겼을 때 디버깅을 하기 어려워지기 때문.

이와 같은 이유로 PIE = 3.14와 같은 전역 상수를 선언하는 것을 제외하면

전역 변수를 사용하지 않는 것이 좋은 코드를 만드는 방법이다.

더 자세한 참고

https://stackoverflow.com/questions/19158339/why-are-global-variables-evil

Why are global variables evil?

I'm trying to find out why the global keyword is considered bad practice in Python (and programming in general). Can somebody explain? Links with more info would also be appreciated.

stackoverflow.com

따라서

다른 함수에서 사용된 결과값을 가져와서 사용하고 싶다면

변수로 저장하고 사용하는 게 아니라 return 을 사용하는 것을 권장

test = 123

def func():
    return 456

def func2(value):
    print(value)

result = func()
func2(result)     # 456

패킹과 언패킹

kinggoddino — Fri, 22 Nov 2024 23:18:50 +0900

패킹과 언패킹

패킹(packing)과 언패킹(unpacking)은 단어의 뜻 그대로 요소들을 묶어주거나 풀어주는 것을 의미

list 혹은 dictionary의 값을 함수에 입력할 때 주로 사용됨

받을 인자의 개수가 정해져 있지 않을 떄.

== 받는 값 개수에 제한 없이 유동적으로 인자를 받고 싶을 때.

유용하게 사용할 수 있다.

list에서의 활용

def add(*args):
    result = 0
    for i in args:
        result += i
    return result

numbers = [1, 2, 3, 4]
print(add(*numbers))   # 10


""" 다 같은 코드임

print(add(*numbers))
print(add(*[1,2,3,4]))
print(add(1, 2, 3, 4))

"""

dictionary에서의 활용

def sample(**kwargs):
    print(kwargs)
    
sample_dict = {
    "key": "value",
    "key2": "value2",
    "key3": "value3",
}

sample(**sample_dict)
sample(key="value" key2="value2", key3="value3")

def set_profile(**kwargs):
    profile = {}
    profile["name"] = kwargs.get("name", "-")
    profile["gender"] = kwargs.get("gender", "-")
    profile["birthday"] = kwargs.get("birthday", "-")
    profile["age"] = kwargs.get("age", "-")
    profile["phone"] = kwargs.get("phone", "-")
    profile["email"] = kwargs.get("email", "-")
    
    return profile

user_profile = {
    "name": "lee",
    "gender": "man",
    "age": 32,
    "birthday": "01/01",
    "email": "python@sparta.com",
}

print(set_profile(**user_profile))
# {
#     'name': 'lee',
#     'gender': 'man',
#     'birthday': '01/01',
#     'age': 32,
#     'phone': '-',
#     'email': 'python@sparta.com'
# }


""" 아래 코드와 동일

profile = set_profile(
    name="lee",
    gender="man",
    age=32,
    birthday="01/01",
    email="python@sparta.com",
)

"""

같이도 쓸 수 있음!

def sample(a, b, *args, **kwargs):
    print(a)        # 1
    print(b)        # 2
    print(args)     # (3, 4, 5)
    print(kwargs)   # {'test': 'a', 'test_key': 'test_value'}
    
sample(1, 2, 3, 4, 5, test="a", test_key="test_value")

이런 형태의 함수를 많이 만날 수 있는데,

*, **을 보면 패킹과 언패킹을 활용한 문법이구나 라고 생각하면 된다.

try / exception 에러 처리

kinggoddino — Thu, 21 Nov 2024 23:52:17 +0900

파이썬에서 에러가 발생하면 기본적으로 코드가 중단되는데,

try except 문법을 활용하면 코드가 중단되지 않고 계속 진행할 수 있다.

try - except : 에러가 있어도 건너뛰게 할 수 있는 방법

예시1

- 정상 상황

people = [
    {'name': 'carry', 'age': 38},
    {'name': 'john', 'age': 7},
    {'name': 'smith', 'age': 17},
    {'name': 'ben', 'age': 27},
]

for person in people:
    if person['age'] > 20:
        print (person['name'])

# carry
# ben

- 데이터가 하나 잘못 입력된 상황

people = [
    {'name': 'carry', 'age': 38},
    {'name': 'john'},
    {'name': 'smith', 'age': 17},
    {'name': 'ben', 'age': 27},
]

for person in people:
    if person['age'] > 20:
        print (person['name'])

# KeyError: 'age'       # 에러 발생함
# carry

- try except 사용하기

people = [
    {'name': 'carry', 'age': 38},
    {'name': 'john'},
    {'name': 'smith', 'age': 17},
    {'name': 'ben', 'age': 27},
]

for person in people:
    try:
        if person['age'] > 20:
            print (person['name'])
    except:
        name = person['name']
        print(f'{name} - 에러입니다')

# carry
# john - 에러입니다
# ben

이렇게 에러가 있어도 멈추지 말고 except 로 빼고 싶을 때 사용한다

예시2 에러 종류에 따라 다른 로직 처리

number = "num"

try: # try 구문 안에서 에러가 발생할 경우 except로 넘어감
    number = int(number) # "num"을 숫자로 바꾸는 과정에서 에러 발생
except: # 에러가 발생했을 때 처리
    print(f"{number}은(는) 숫자가 아닙니다.")

어떤에러가 발생했을 때 >>> 어떤 결과를 출력해라

라고 따로 명령할 수 있음.

number = input()

try:
    # number = int(number)
    int(number)
    10 / number

except ValueError: # int로 변환하는 과정에서 에러가 발생했을 떄
    print(f"{number}은(는) 숫자가 아닙니다")
    
except ZeroDivisionError: # 0으로 나누면서 에러가 발생했을 때
    print("0으로는 나눌수 없습니다")
    
except Exception as e: # 위에서 정의하지 않은 에러가 발생했을 때(권장하지 않음)
    print(f"예상하지 못한 에러가 발생했습니다 error : {e}")

# except 문법 또한 if / elif와 같이 연달아서 작성할 수 있음

여기서 마지막에 있는

except Exception as e

정의되지 않은 에러를 e 변수에 담아서 출력하려고 하는거다.

근데 남발하면 좋지 않음.

왜 에러가 발생했는지 알 수가 없기 때문이다.

이왕이면 위에서처럼

except ValueError:
except ZeroDivisionError:

이런식으로 구체적인 에러 발생 상황을 명시해서 빼주는 게 좋다.

에러명칭을 아는 방법은 그냥

내가 예외처리하고싶은 코드를 일부러 입력해보고,

출력된 에러 중에 앞부분을 따오면 된다.

예를 들어

10/0 
# ZeroDivisionError: division by zero

int("number") 
# ValueError: invalid literal for int() with base 10: 'number'

이렇게 하면 됨

정규표현식 regex

kinggoddino — Wed, 20 Nov 2024 23:21:41 +0900

정규표현식이란

정규표현식은 문자열이 특정 패턴과 일치하는지 판단하는 형식 언어이다.

regular expression의 약자인 regex라고도 함.

사용예시

사용자가 입력한 이메일이 유효한 이메일인지,
유효한 핸드폰 번호를 입력했는지,
대문자로 시작하고 숫자로 끝나는 패턴의 단어가 몇번 반복되는지 등
다양한 패턴을 지정하고 검증할 수 있음.

정규표현식을 사용하지 않은 코드

정규표현식을 사용한 코드

두 가지의 차이를

예제를 통해 비교해보자

예제 : 이메일 형식 검증

유효한 이메일인지 판단하는 최소한의 패턴은 다음과 같다.

숫자, 알파벳 대/소문자, 일부 특수문자( - _ . )를 조합한 문자로 시작함
문자열 중간에는 @가 반드시 1개 포함되어 있어야 함
@ 이후에는 숫자, 알파벳 대/소문자, 일부 특수문자( - _ . )를 조합한 문자가 들어감
3번 문자 이후에는 .이 한 개 이상 포함되어 있어야 함
마지막 . 이후에는 2 ~ 4글자의 숫자, 알파벳 대/소문자, 일부 특수문자( - _ )를 조합한 문자 포함되어 있어야 함

정규표현식 없이 위 조건들을 만족하기 위한 코드

from pprint import pprint

alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
number = "0123456789"
special_char = "-_."

def verify_email(email):
    # 이메일에 @가 한개 포함되어 있는지 확인
    if email.count("@") != 1:
        return False
    
    # @를 기준으로 사용자명과 도메인을 분리
    username, domain = email.split("@")
    
    # username이 1자 이상인지 확인
    if len(username) < 1:
        return False
    
    # 도메인에 한개 이상의 .이 포함되어 있는지 확인
    if domain.count(".") < 1:
        return False
    
    # username에 알파벳, 숫자, 허용된 특수문자 이외의 문자가 포함되어 있는지 확인
    if not all([x in alphabet + number + special_char for x in username]):
        return False
    
    # domain에 알파벳, 숫자, 허용된 특수문자 이외의 문자가 포함되어 있는지 확인
    if not all([x in alphabet + number + special_char for x in domain]):
        return False
    
    # 마지막 .을 기준으로 도메인을 분리
    _, last_level_domain = domain.rsplit(".", 1)
    
    # 마지막 레벨의 도메인의 길이가 2~4글자인지 확인
    if not 2 <= len(last_level_domain) <= 4:
        return False
    
    # 모든 검증이 완료되면 True를 리턴
    return True

정규표현식을 사용한 코드

from pprint import pprint
import re

# rstring : backslash(\)를 문자 그대로 표현
# ^[\w\.-]+@([\w-]+\.)+[\w-]{2,4}$ : 이메일 검증을 위한 정규표현식 코드
email_regex = re.compile(r"^[\w\.-]+@([\w-]+\.)+[\w-]{2,4}$")

def verify_email(email):
    return bool(email_regex.fullmatch(email))

후자의 코드가 훨씬 간결하고, 결과는 똑같다

test_case = [
    "apple",                  # False
    "sparta@regex",           # False
    "$parta@regex.com",       # False
    "sparta@re&ex.com",       # False
    "spar_-ta@regex.com",     # True
    "sparta@regex.co.kr",     # True
    "sparta@regex.c",         # False
    "sparta@regex.cooom",     # False
    "@regex.com",             # False
]

result = [{x: verify_email(x)} for x in test_case]
pprint(result)

정규표현식 코드를 짜는 방법

위 예제에서 사용한 정규표현식 코드 부분만 다시 확인해 보면,

email_regex = re.compile(r"^[\w\.-]+@([\w-]+\.)+[\w-]{2,4}$")

머라는건지 모르겠고 이걸 외울 순 없을 것 같다.

이처럼 정규표현식으로 내가 원하는 패턴의 코드를 직접 짜는 것은 매우 어렵기 때문에

이미 만들어져 있고 검증 된 정규표현식을 가져다가 사용하는 것이 권장된다.

위 예제와 같이 이메일 검증, 패스워드 안정성 검증, 핸드폰번호 검증과 같이 대중적으로 많이 사용되는 정규표현식 코드들은 구글에서 검색 해 보면 쉽게 찾아볼 수 있다.

검색하면 답지가 바로 나옴

반대로 다른 사람이 작성한 코드 중에서 알수 없는 정규표현식 코드가 있다면,

아래의 사이트에 복붙으로 넣어주면

해당 정규표현식 문법에 대한 설명을 자세하게 확인할 수 있다.

https://regexr.com/

RegExr: Learn, Build, & Test RegEx

RegExr is an online tool to learn, build, & test Regular Expressions (RegEx / RegExp).

regexr.com

주의해야할 점

언어마다 정규식을 다루는 방법이 조금씩 다를 수 있다.

따라서, 정규식 사이트에서는 잘 동작하던 코드가 내 로컬에서 안돌아간다?

그러면 구글에 Python password validation regex 이런식의 키워드로 검색해서 찾아보자.

마지막으로

email_regex = re.compile(r"^[\w\.-]+@([\w-]+\.)+[\w-]{2,4}$")

regex 문자열 앞에 있는 r 의 의미는

정규표현식에서 특정한 문자들을 특수문자로 인식하는 것을 방지하기 위함이다.

무슨말이냐면

파이썬 문자열에서 역슬래시 \ 뒤에 오는 문자는 특수문자 의미를 갖고 있는데,

\n   # 개행을 의미함
\t   # Tab 을 의미함

이 때 앞에 r을 붙여주면 역슬래시 다음의 문자들을 특수 문자가 아니라

온전히 그 문자 그대로를 의미할 수 있게 해준다.

[Python] 자주 사용되는 모듈/패턴

kinggoddino — Tue, 19 Nov 2024 06:53:45 +0900

type( ) : 값의 자료형 확인하기

변수에 담긴 값들이 어떤 자료형인지 알 수 있음.

integer = 10
float_ = 1.23
string = "hello world!!"
list_ = [1, 2, 3]
tuple_ = (1, 2, 3)
set_ = {1, 2, 3}
dictionary = {"key": "value"}
boolean = True

print(type(integer))    # <class 'int'>
print(type(float_))     # <class 'float'>
print(type(string))     # <class 'str'>
print(type(list_))      # <class 'list'>
print(type(tuple_))     # <class 'tuple'>
print(type(set_))       # <class 'set'>
print(type(dictionary)) # <class 'dict'>
print(type(boolean))    # <class 'bool'>

특히, 결과값으로 받아온 숫자가 어떤 형태인지(정수형인지 문자형인지) 확인할 때 유용함

a = 1
b = "1"

print(a, type(a))   # 1 <class 'int'>
print(b, type(b))   # 1 <class 'str'>

split( ) : string을 list로 변환하기

특정 문자를 기준으로 문자열을 쪼갤 수 있음.

# split은 string.split("구분자")로 구성되어 있습니다.

string = "hello/python/world!!"
string_list = string.split("/") # split() 안에 들어간 값을 기준으로 문자를 나눈다.

print(string_list) # ['hello', 'python', 'world!!']

join( ) : list를 string으로 변환하기

split 과 반대로 특정 문자를 기준으로 문자열을 연결해줌.

# join은 "사이에 들어갈 문자".join(리스트) 로 구성되어 있습니다.

string_list = ["hello", "python", "world"]
string = "!! ".join(string_list)

print(string) # hello!! python!! world

replace( ) : 문자열 바꾸기

특정 문자를 내가 원하는 문자로 바꿔줌.

# replace는 "변경할 문자".replace("변경 전 문자", "변경 후 문자")로 구성되어 있습니다.

before_string = "hello world!!!"
after_string = before_string.replace("!", "~") # !를 ~로 변경

print(after_string) # hello world~~~

pprint( ) : 코드 예쁘게 출력하기

pprint는 pretty print의 약자이고, 데이터를 더 예쁘게 출력해줌.

예시

# 예시

sample_data = {
    "id": "0001",
    "type": "donut",
    "name": "Cake",
    "ppu": 0.55,
    "batters":
        {
            "batter":
                [
                    {"id": "1001", "type": "Regular"},
                    {"id": "1002", "type": "Chocolate"},
                    {"id": "1003", "type": "Blueberry"},
                    {"id": "1004", "type": "Devil's Food"}
                ]
        },
    "topping":
        [
            {"id": "5001", "type": "None"},
            {"id": "5002", "type": "Glazed"},
            {"id": "5005", "type": "Sugar"},
            {"id": "5007", "type": "Powdered Sugar"},
            {"id": "5006", "type": "Chocolate with Sprinkles"},
            {"id": "5003", "type": "Chocolate"},
            {"id": "5004", "type": "Maple"}
        ]
}

예시 출력 비교

일반 print 출력일 경우

print(sample_data)

{'id': '0001', 'type': 'donut', 'name': 'Cake', 'ppu': 0.55, 'batters': {'batter': [{'id': '1001', 'type': 'Regular'}, {'id': '1002', 'type': 'Chocolate'}, {'id': '1003', 'type': 'Blueberry'}, {'id': '1004', 'type': "Devil's Food"}]}, 'topping': [{'id': '5001', 'type': 'None'}, {'id': '5002', 'type': 'Glazed'}, {'id': '5005', 'type': 'Sugar'}, {'id': '5007', 'type': 'Powdered Sugar'}, {'id': '5006', 'type': 'Chocolate with Sprinkles'}, {'id': '5003', 'type': 'Chocolate'}, {'id': '5004', 'type': 'Maple'}]}print(sample_data)

pprint 출력일 경우

(모듈 import 해줘야함)

from pprint import pprint
pprint(sample_data)

{'batters': {'batter': [{'id': '1001', 'type': 'Regular'},
{'id': '1002', 'type': 'Chocolate'},

{'id': '1003', 'type': 'Blueberry'},

{'id': '1004', 'type': "Devil's Food"}]},
'id': '0001',
'name': 'Cake',
'ppu': 0.55,
'topping': [{'id': '5001', 'type': 'None'},
{'id': '5002', 'type': 'Glazed'},
{'id': '5005', 'type': 'Sugar'},
{'id': '5007', 'type': 'Powdered Sugar'},
{'id': '5006', 'type': 'Chocolate with Sprinkles'},
{'id': '5003', 'type': 'Chocolate'},
{'id': '5004', 'type': 'Maple'}],
'type': 'donut'}

결과를 보면
딕셔너리, 리스트의 구분이 뚜렷하고 데이터마다 개행도 시켜주고 인덴트도 맞춰서 출력해준다.
변수에 많은 양의 데이터가 담겨있을 때 내용을 깔끔하게 보고싶으면 사용함

random : 랜덤한 로직 만들기

이름처럼 임의의 숫자를 생성하거나 무작위의 동작이 필요할 때 사용한다
코드를 실행할 때마다 결과값이 달라진다.
shuffle (리스트 안의 요소를 섞기)
randint (random integer 의 약자, 무작위 숫자라는 뜻)

# 난수 생성, 임의의 번호 생성 등 랜덤한 동작이 필요할 때 사용
import random

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(numbers) # numbers를 무작위하게 섞기
print(numbers) # [2, 8, 6, 4, 3, 7, 1, 5]

random_number = random.randint(1, 10) # 1 ~ 10 사이의 무작위 번호 생성
print(random_number) # 4

time : 시간 다루기

코드의 실행속도를 측정하거나, 코드를 잠시 중지시킬 때 사용

import time

start_time = time.time() # 현재 시간 저장

time.sleep(1) # 1초간 대기

end_time = time.time()

# 코드가 종료된 시간 - 코드가 시작된 시간으로 실행 시간 구하기 (단위 : 초)
print(f"코드 실행 시간 : {end_time-start_time:.5f}") # 코드 실행 시간 : 1.00018

.5f 는 소수점 5째 자리 수까지 표기하겠다는 뜻임.

datetime : 날짜 다루기

현재 날짜 및 시각 출력해보기

from datetime import datetime

print(datetime.now()) # 2023-02-22 15:55:32.277095

datetime은 string 이 아니라 datetime 클래스임.

print(datetime.now())  # 2024-11-19 06:39:03.326788

now = datetime.now()
now = now.split(" ")   # 공백 기준으로 나누기 시도
# AttributeError: 'datetime.datetime' object has no attribute 'split'

# 에러 발생 이유
print(type(now))   # <class 'datetime.datetime'>

datetime 을 string 으로 변경하는 법

now = str(datetime.now())  # 문자열로 형변환 해주기
print(now.split(" "))      # ['2024-11-19', '06:44:59.605220']

strptime(입력받을 날짜 변수, 변경할 문자열의 포맷)

# datetime 날짜를 string으로 변환하기
now = datetime.now()
string_datetime = datetime.strftime(now, "%y/%m/%d %H:%M:%S")
print(string_datetime) # 22/09/04 04:04

반대로 string 을 datetime 으로 변경하는 법
strptime(입력받을 문자열 변수, 입력받은 문자열의 포맷)

# string을 datetime 날짜로 변경하기
string_datetime = "23/12/25 13:20"
datetime_ = datetime.strptime(string_datetime, "%y/%m/%d %H:%M")
print(datetime_) # 2023-12-25 13:20:00

포맷 종류

'''
%y : 두 자리 연도 / 20, 21, 22
%Y : 네 자리 연도 / 2020, 2021, 2022
%m : 두 자리 월 / 01, 02 ... 11 ,12
%d : 두 자리 일 / 01, 02 ...  30, 31
%I : 12시간제 시간 / 01, 02 ... 12
%H : 24시간제의 시간 / 00, 01 ... 23
%M : 두 자리 분 / 00, 01 ... 58, 59
%S : 두 자리 초 / 00, 01 ... 58, 59
'''

datetime의 format code 더 제세한건 여기서 확인 가능
https://docs.python.org/ko/3/library/datetime.html#strftime-and-strptime-format-codes

datetime — Basic date and time types

Source code: Lib/datetime.py The datetime module supplies classes for manipulating dates and times. While date and time arithmetic is supported, the focus of the implementation is on efficient attr...

docs.python.org

timedelta

특정 날짜를 더하거나 뺄 때 사용함
사용하는 방법은 사칙연산이랑 비슷함

from datetime import timedelta

# 3일 전 날짜 구하기
three_days_ago = datetime.now() - timedelta(days=3)
print(three_days_ago) # 2023-02-19 16:27:52.526502

[Python] map, lambda, filter

kinggoddino — Mon, 18 Nov 2024 23:58:27 +0900

map, lambda, filter

데이터 처리와 변환을 간결하게 할 수 있도록 도와주는 함수들

map

언제

map은 리스트나 iterable한 데이터의 각 요소에 대해 동일한 함수를 적용하고 싶을 때 사용

왜

반복문 없이 데이터를 변환할 수 있어 코드가 간결해짐
동일한 작업을 여러 요소에 효율적으로 적용할 수 있음

기본 구조

map(함수, 리스트/iterable)

예시

ex) 숫자 리스트의 각 요소를 제곱하기

기본 반복문 for 사용할 경우:

numbers = [1, 2, 3, 4, 5]

def square(x):                            # 1) square라는 함수를 정의한다
    return x ** 2

squared_numbers = []                      # 2) 빈 리스트를 만들고
for num in numbers:                       # 3) for 반복문으로 각 요소에 대해 square 호출
    squared_numbers.append(square(num))   # 4) 결과를 리스트에 추가

print(squared_numbers)                    # [1, 4, 9, 16, 25]

map 사용할 경우:

numbers = [1, 2, 3, 4, 5]

def square(x):                                # 1) square라는 함수를 정의한다
    return x ** 2

squared_numbers = list(map(square, numbers))  # 2) map이 자동으로 각 요소에 square 적용

print(squared_numbers)                        # [1, 4, 9, 16, 25]

정리

간결성: 여러 요소에 동일한 작업(함수 적용)을 한 줄로 간결하게 표현할 수 있음
list(map(...)): 리스트나 다른 iterable 데이터의 변환이 쉽다. 결과를 리스트로 바로 얻을 수 있음.
성능 개선: 특히 대량의 데이터에서 map은 반복문보다 더 빠르게 작동할 수 있음.

lambda

언제

lambda는 짧고 간단한 함수를 빠르게 정의하고 싶을 때 사용

왜

이름 없는 함수로 짧고 간단한 작업을 즉석에서 작성 가능함
재사용하지 않을 간단한 함수를 정의할 때 유용함

기본 구조

lambda 매개변수: 표현식

예시

ex) 두 숫자를 더하는 함수

기본 함수 정의할 경우:

def add(x, y):
    return x + y

print(add(3, 5))  # 8

lambda 사용할 경우:

add = lambda x, y: x + y
print(add(3, 5))  # 8

한 번만 사용하거나, map과 함께 사용할 경우:

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6, 8, 10]

filter

언제

filter는 리스트의 요소 중 특정 조건을 만족하는 요소만 선택하고 싶을 때 사용

왜

데이터에서 필터링 작업을 간단히 수행 가능함
조건에 맞는 요소만 걸러낼 때 유용함

기본 구조

filter(함수, 리스트/iterable)

예시

ex) 두 숫자를 더하는 함수

기본 for 반복문 사용할 경우:

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = []
for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
print(even_numbers)  # [2, 4, 6]

filter 사용할 경우:

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

장점

조건에 따라 요소를 간단히 추출
if 조건문을 줄이고 가독성 향상

정리: 언제 사용하면 좋을까

map:

모든 요소에 동일한 변환 작업을 할 때.
데이터 변환이 필요한 경우 (lambda와 자주 사용).

lambda:

간단한 함수를 빠르게 작성할 때.
재사용하지 않을 간단한 로직을 적용할 때.

filter:

조건에 따라 데이터를 걸러낼 때.
특정 조건을 만족하는 요소만 추출할 때.