Python 학습 곡선: Python 초보자에서 전문가로

Apr 22 2023

코드 스니펫 사용

소개: Python은 세계에서 가장 다양하고 널리 사용되는 프로그래밍 언어 중 하나이며 단순성, 가독성 및 다양성으로 유명합니다. 이 기사에서는 초심자, 중급자 및 전문가의 세 가지 전문 수준에서 프로그래머가 코드를 개발하는 일련의 예제 시나리오를 살펴볼 것입니다.

Unsplash의 Nathan Long 사진

소개:

Python은 세계에서 가장 다양하고 널리 사용되는 프로그래밍 언어 중 하나이며 단순성, 가독성 및 다양성으로 유명합니다. 이 기사에서는 초심자, 중급자 및 전문가의 세 가지 전문 수준에서 프로그래머가 코드를 개발하는 일련의 예제 시나리오를 살펴볼 것입니다.

중급 및 전문가는 일반적으로 다음을 사용합니다.

List comprehension: 한 줄의 코드로 목록을 만드는 간결한 방법입니다.

squares = [x**2 for x in range(1, 6)]
print(squares)  
# Output: [1, 4, 9, 16, 25]

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

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

def greet_decorator(func):
    def wrapper():
        print("Hello!")
        func()
        print("Welcome!")
    return wrapper

@greet_decorator
def greet_name():
    print("John")

greet_name()
# Output:
# Hello!
# John
# Welcome!

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

from typing import List

def sum_elements(elements: List[int]) -> int:
    return sum(elements)

result = sum_elements([1, 2, 3, 4, 5])
print(result)  # Output: 15

def fibonacci_gen(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci_gen(5):
    print(num, end=" ")
# Output: 0 1 1 2 3

import re

text = "The email addresses are [email protected] and [email protected]"
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, text)
print(emails)  # Output: ['[email protected]', '[email protected]']

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"An error occurred: {e}")
# Output: An error occurred: division by zero

# Importing the 'math' module and using its 'sqrt' function
import math

sqrt_result = math.sqrt(25)
print(sqrt_result)  # Output: 5.0

import threading

def print_square(num):
    print(f"Square: {num * num}")

def print_cube(num):
    print(f"Cube: {num * num * num}")

thread1 = threading.Thread(target=print_square, args=(4,))
thread2 = threading.Thread(target=print_cube, args=(4,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

# Output:
# Square: 16
# Cube: 64

# Built-in functions
numbers = [2, 4, 1, 6, 3, 8, 5, 7]
max_num = max(numbers)  # Find the maximum number in the list
min_num = min(numbers)  # Find the minimum number in the list
sorted_nums = sorted(numbers)  # Sort the list in ascending order
reversed_nums = list(reversed(numbers))  # Reverse the list

print("Maximum number:", max_num)
print("Minimum number:", min_num)
print("Sorted numbers:", sorted_nums)
print("Reversed numbers:", reversed_nums)

# Standard library modules
from collections import Counter
from itertools import combinations

# Counter (from collections module)
word = "mississippi"
counter = Counter(word)  # Count the occurrences of each character
print("Character count:", counter)

# Combinations (from itertools module)
combos = list(combinations(numbers, 2))  # Find all combinations of size 2
print("Combinations of size 2:", combos)

PEP 8 및 코딩 스타일: 코드 가독성 및 일관성을 위한 Python의 공식 스타일 가이드(PEP 8) 및 기타 모범 사례를 준수합니다.

# PEP 8 compliant code snippet

def calculate_area(radius):
    """Calculate the area of a circle given its radius.

    Args:
        radius (float): The radius of the circle.

    Returns:
        float: The area of the circle.
    """
    pi = 3.14159
    return pi * radius**2


def main():
    # Collect user input for the radius
    radius = float(input("Enter the radius of the circle: "))

    # Calculate the area using the defined function
    area = calculate_area(radius)

    # Display the result with appropriate formatting
    print(f"The area of the circle with radius {radius} is {area:.2f}")


if __name__ == "__main__":
    main()

import unittest

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

class TestAddition(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add_numbers(2, 3), 5)

if __name__ == '__main__':
    unittest.main(argv=['first-arg-is-ignored'], exit=False)
# Output: .
# ----------------------------------------------------------------------
# Ran 1 test in 0.002s
#
# OK

저자의 이미지

초보자:

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

for num in numbers:
    if num % 2 == 0:
        even_sum += num

print("The sum of even numbers is:", even_sum)

계수 연산자를 사용하는 숫자인지 확인합니다.
합계 변수에 짝수를 더합니다.

def is_even(num):
    return num % 2 == 0

def even_sum(numbers):
    result = 0
    for num in numbers:
        if is_even(num):
            result += num
    return result

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

even_sum짝수의 합을 계산하는 함수를 만듭니다.
코드가 더 모듈화되고 유지 관리가 더 쉽습니다.

def even_sum(numbers):
    return sum(filter(lambda num: num % 2 == 0, numbers))

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

짝수의 간결하고 효율적인 필터링을 위해 람다 함수를 사용합니다.
Python의 함수형 프로그래밍 기능을 활용하여 코드가 더 간결해졌습니다.

저자의 이미지

초보자:

text = "hello world"
char_count = {}

for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

print("Character counts:", char_count)

#Character counts: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

문자가 이미 사전에 있는지 확인하고 그에 따라 개수를 업데이트합니다.

def count_characters(text):
    char_count = {}
    for char in text:
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

메서드를 사용하여 dict.get()코드를 단순화합니다.

from collections import Counter

def count_characters(text):
    return Counter(text)

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

내장 기능을 활용하여 Counter문자 발생을 효율적으로 계산합니다.

저자의 이미지

초보자:

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

for num in numbers:
    total += num

average = total / len(numbers)
print("The average is:", average)

합계를 목록의 길이로 나누어 평균을 계산합니다.

def calculate_average(numbers):
    return sum(numbers) / len(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

내장 sum함수를 사용하여 코드 단순화

from statistics import mean

def calculate_average(numbers):
    return mean(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

내장 mean함수를 활용하여 평균을 계산합니다.

저자의 이미지

초보자:

text = "hello"
reversed_text = ""

for char in text:
    reversed_text = char + reversed_text

print("Reversed text:", reversed_text)
#text = "Hello"
#Reversed text: olleH

문자를 역순으로 연결하여 역 문자열을 만듭니다.

def reverse_string(text):
    return "".join(reversed(text))

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

reversed함수와 메서드를 사용하여 join문자열을 뒤집습니다.

def reverse_string(text):
    return text[::-1]

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

저자의 이미지

5. 목록에서 가장 큰 숫자 찾기:

초보자:

numbers = [1, 3, 7, 2, 5]
max_number = numbers[0]

for num in numbers:
    if num > max_number:
        max_number = num

print("The largest number is:", max_number)

#The largest number is: 7

각 숫자를 현재 최대값과 비교하고 그에 따라 최대값을 업데이트합니다.

def find_max(numbers):
    return max(numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

내장 max함수를 사용하여 최대 수를 찾습니다.

from functools import reduce

def find_max(numbers):
    return reduce(lambda x, y: x if x > y else y, numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

람다 함수가 있는 함수를 활용하여 reduce최대 수를 찾습니다.

저자의 이미지

초보자:

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = []

for item in original_list:
    if item not in unique_list:
        unique_list.append(item)

print("Unique list:", unique_list)

항목이 고유 목록에 없는지 확인하고 없으면 추가합니다.

def remove_duplicates(items):
    return list(set(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

내장 set데이터 구조를 사용하여 중복을 제거하고 다시 목록으로 변환합니다.

def remove_duplicates(items):
    return list(dict.fromkeys(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

저자의 이미지

7. 목록의 모든 숫자를 제곱:

초보자:

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

for num in numbers:
    squared_numbers.append(num ** 2)

print("Squared numbers:", squared_numbers)
#Squared numbers: [1, 4, 9, 16, 25]

각 숫자의 제곱을 제곱 숫자 목록에 추가합니다.

def square_numbers(numbers):
    return [num ** 2 for num in numbers]

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

목록 이해를 사용하여 제곱된 숫자 목록을 만듭니다.

def square_numbers(numbers):
    return list(map(lambda x: pow(x, 2), numbers))

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

      
                
                    
                    
       Image by the Author

초보자:

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

rotated_list = numbers[-positions:] + numbers[:-positions]
print("Rotated list:", rotated_list)
#Rotated list: [4, 5, 1, 2, 3]

중급:

def rotate_list(numbers, positions):
    return numbers[-positions:] + numbers[:-positions]

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

Python의 슬라이싱 구문을 사용하여 지정된 위치 수만큼 목록을 회전합니다.

from collections import deque

def rotate_list(numbers, positions):
    rotated_numbers = deque(numbers)
    rotated_numbers.rotate(positions)
    return list(rotated_numbers)

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

deque클래스와 해당 메서드를 활용하여 rotate지정된 위치 수만큼 목록을 효율적으로 회전합니다.

저자의 이미지

초보자:

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = []

for num in list1:
    if num in list2:
        common_elements.append(num)

print("Common elements:", common_elements)
#Common elements: [4, 5]

요소가 두 번째 목록에 있는지 확인하고 발견되면 공통 요소 목록에 추가합니다.

def find_common_elements(list1, list2):
    return [num for num in list1 if num in list2]

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

목록 이해를 사용하여 공통 요소 목록 생성

def find_common_elements(list1, list2):
    return list(set(list1) & set(list2))

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

결과를 다시 목록으로 변환

저자의 이미지

초보자:

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

transposed_matrix = []

for i in range(len(matrix[0])):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed_matrix.append(transposed_row)

print("Transposed matrix:", transposed_matrix)

원본 행렬의 각 행에서 요소를 추가하여 전치 행렬을 만듭니다.

def transpose_matrix(matrix):
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

중첩 목록 이해를 사용하여 전치 행렬을 생성합니다.

def transpose_matrix(matrix):
    return list(zip(*matrix))

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

저자의 이미지

11. 문자열이 회문인지 확인:

초보자:

string = "madam"
is_palindrome = True

for i in range(len(string) // 2):
    if string[i] != string[-(i + 1)]:
        is_palindrome = False
        break

print(f"Is '{string}' a palindrome?:", is_palindrome)
#Is 'madam' a palindrome?: True

각 문자를 문자열 끝에서 해당 문자와 비교하고 is_palindrome일치하지 않으면 False로 설정합니다.

def is_palindrome(string):
    return string == string[::-1]

string = "madam"
result = is_palindrome(string)
print(f"Is '{string}' a palindrome?:", result)

Python의 슬라이싱 구문을 사용하여 문자열을 뒤집고 원래 문자열과 비교합니다.

저자의 이미지

초보자:

num = 60
prime_factors = []

for i in range(2, num + 1):
    while num % i == 0:
        prime_factors.append(i)
        num = num // i

print("Prime factors:", prime_factors)
#Prime factors: [2, 2, 3, 5]

while 루프를 사용하여 숫자를 나눌 수 있는 동안 인수로 반복해서 나눕니다.
소인수를 목록에 추가합니다.

def prime_factors(num):
    factors = []
    for i in range(2, num + 1):
        while num % i == 0:
            factors.append(i)
            num = num // i
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

중첩 루프를 사용하여 소인수를 식별하고 목록에 추가합니다.

def prime_factors(num):
    factors = []
    i = 2
    while i * i <= num:
        if num % i:
            i += 1
        else:
            num //= i
            factors.append(i)
    if num > 1:
        factors.append(num)
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

단일 while 루프를 사용하여 숫자를 가장 작은 제수로 반복해서 나눕니다.
목록에 소인수를 추가하고 마지막 소인수를 설명하기 위해 나머지 숫자가 1보다 큰지 확인합니다.

저자의 이미지

초보자:

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = []

for sublist in nested_list:
    for item in sublist:
        flat_list.append(item)

print("Flat list:", flat_list)
#Flat list: [1, 2, 3, 4, 5, 6, 7, 8, 9]

새 플랫 목록에 각 항목을 추가합니다.

def flatten_list(nested_list):
    return [item for sublist in nested_list for item in sublist]

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

중첩 목록 이해를 사용하여 플랫 목록을 만듭니다.

from itertools import chain

def flatten_list(nested_list):
    return list(chain.from_iterable(nested_list))

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

flatten_list함수 를 사용하여 chain.from_iterable중첩 목록을 평면화하는 함수를 정의합니다.

저자의 이미지

초보자:

sentence = "apple banana apple kiwi banana apple"
word_count = {}

for word in sentence.split():
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print("Word count:", word_count)

기본 for 루프를 사용하여 단어를 반복하고 사전에서 단어의 발생 횟수를 계산합니다.

from collections import Counter

def count_words(sentence):
    return Counter(sentence.split())

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

count_words클래스 를 사용하여 Counter문장에서 단어의 빈도를 계산하는 함수를 정의합니다.

from collections import defaultdict

def count_words(sentence):
    word_count = defaultdict(int)
    for word in sentence.split():
        word_count[word] += 1
    return word_count

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

count_words단어의 빈도를 계산하기 위해 정수 값과 함께 defaultdict를 사용하는 함수를 정의합니다.
메소드 를 사용하여 split문장을 토큰화하고 for 루프를 사용하여 단어 수를 증가시킵니다.

저자의 이미지

초보자:

def merge_dicts(d1, d2):
    merged_dict = d1.copy()
    merged_dict.update(d2)
    return merged_dict

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

#Merged dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

메서드를 사용하여 copy첫 번째 사전의 복사본을 만들고 update두 번째 사전의 키-값 쌍으로 사전을 업데이트하는 메서드를 사용합니다.

def merge_dicts(d1, d2):
    return {**d1, **d2}

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

사전 압축 풀기( **d1, **d2)를 사용하여 사전을 병합합니다.

from collections import ChainMap

def merge_dicts(d1, d2):
    return dict(ChainMap(d1, d2))

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

merge_dicts두 개의 사전을 병합하는 기능을 정의합니다.
클래스 를 사용하여 ChainMap두 사전의 결합된 보기를 만들고 결과를 사전으로 변환합니다.

저자의 이미지

초보자:

def list_difference(lst1, lst2):
    difference = []
    for item in lst1:
        if item not in lst2:
            difference.append(item)
    return difference

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

#List difference: [1, 2, 3]

기본 for 루프를 사용하여 첫 번째 목록의 요소를 반복하고 각 요소가 두 번째 목록에 없는지 확인합니다.
차이점 목록에 고유한 요소를 추가합니다.

def list_difference(lst1, lst2):
    return list(set(lst1) - set(lst2))

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

목록을 집합으로 변환하고 차집합 연산자 ( -) 를 사용하여 고유한 요소를 찾습니다.
결과를 다시 목록으로 변환

def list_difference(lst1, lst2):
    return [item for item in lst1 if item not in set(lst2)]

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

조건과 함께 목록 이해를 사용하여 고유한 요소 목록을 생성합니다.
멤버십 테스트를 최적화하기 위해 두 번째 목록을 세트로 변환합니다.

저자의 이미지

초보자:

def create_dict(keys, values):
    result = {}
    for key, value in zip(keys, values):
        result[key] = value
    return result

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

#Dictionary: {'name': 'Alice', 'age': 25, 'gender': 'Female'}

함수 와 함께 for 루프를 사용하여 zip키와 값을 동시에 반복합니다.
각 값을 해당 키에 할당하여 사전을 구성합니다.

def create_dict(keys, values):
    return dict(zip(keys, values))

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

함수 를 사용하여 zip키와 값을 쌍으로 지정한 다음 dict생성자를 사용하여 사전을 만듭니다.

def create_dict(keys, values):
    return {key: value for key, value in zip(keys, values)}

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

함수 와 함께 사전 이해를 사용하여 zip사전을 생성합니다.

저자의 이미지

초보자:

def replace_word(sentence, old_word, new_word):
    return sentence.replace(old_word, new_word)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

#I like oranges. Apples are tasty.

import re

def replace_word(sentence, old_word, new_word):
    return re.sub(r'\b' + old_word + r'\b', new_word, sentence, flags=re.IGNORECASE)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

      
                
                    
                    
       Image by the Author

초보자:

def mean(numbers):
    return sum(numbers) / len(numbers)

def standard_deviation(numbers):
    avg = mean(numbers)
    return (sum((x - avg) ** 2 for x in numbers) / len(numbers)) ** 0.5

numbers = [1, 2, 3, 4, 5]
print(standard_deviation(numbers))

#1.4142135623730951

import numpy as np

numbers = [1, 2, 3, 4, 5]
print(np.std(numbers))

      
                
                    
                    
       Image by the Author

초보자:

from sklearn.preprocessing import OneHotEncoder

data = [['apple'], ['banana'], ['orange'], ['apple'], ['banana']]
encoder = OneHotEncoder()
one_hot_encoded = encoder.fit_transform(data).toarray()
print(one_hot_encoded)

import pandas as pd

data = pd.DataFrame({'fruit': ['apple', 'banana', 'orange', 'apple', 'banana']})
one_hot_encoded = pd.get_dummies(data, columns=['fruit'])
print(one_hot_encoded)

      
                
                    
                    
       Image by the Author

초보자:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = []
odd_numbers = []

for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
    else:
        odd_numbers.append(num)

grouped_numbers = {'even': even_numbers, 'odd': odd_numbers}
print("Grouped numbers:", grouped_numbers)
#Grouped numbers: {'even': [2, 4, 6, 8], 'odd': [1, 3, 5, 7, 9]}

목록 에 짝수를 추가 하고 목록 even_numbers에 홀수를 추가합니다.odd_numbers
숫자를 사전으로 그룹화

def group_by_parity(numbers):
    return {
        'even': [num for num in numbers if num % 2 == 0],
        'odd': [num for num in numbers if num % 2 != 0],
    }

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

사전 이해와 목록 이해를 사용하여 그룹화된 사전 생성

from collections import defaultdict

def group_by_parity(numbers):
    grouped_numbers = defaultdict(list)
    for num in numbers:
        key = 'even' if num % 2 == 0 else 'odd'
        grouped_numbers[key].append(num)
    return grouped_numbers

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

group_by_paritydefaultdict를 사용하여 패리티별로 숫자를 그룹화하는 함수를 정의합니다.
숫자를 반복하고 그룹화된 사전의 적절한 키('짝수' 또는 '홀수')에 추가합니다.

저자의 이미지

초보자:

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
element_count = {}

for num in numbers:
    if num in element_count:
        element_count[num] += 1
    else:
        element_count[num] = 1

most_common_element = max(element_count, key=element_count.get)
print("Most common element:", most_common_element)

#Most common element: 4

max인수 와 함께 함수를 사용하여 key가장 일반적인 요소를 찾습니다.

from collections import Counter

def most_common_element(lst):
    return Counter(lst).most_common(1)[0][0]

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

'Counter' 클래스를 사용하여 목록에서 요소의 발생을 계산하는 함수 'most_common_element'를 정의합니다.

from statistics import mode

def most_common_element(lst):
    return mode(lst)

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

most_common_element함수 를 사용하여 mode목록에서 가장 일반적인 요소를 찾는 함수를 정의합니다.
이 mode함수는 목록에서 가장 일반적인 요소를 반환합니다.

저자의 이미지

초보자:

def dict_to_tuples(d):
    return [(key, value) for key, value in d.items()]

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

# List of tuples: [('a', 1), ('b', 2), ('c', 3)]

사전의 방법 과 함께 목록 이해를 사용하여 items튜플 목록을 만듭니다.

def dict_to_tuples(d):
    return list(d.items())

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

사전의 메서드를 사용하여 items키-값 쌍을 튜플로 가져오고 결과를 목록으로 변환합니다.

from operator import itemgetter

def dict_to_tuples(d):
    return sorted(d.items(), key=itemgetter(0))

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

dict_to_tuples사전을 튜플 목록으로 변환하는 함수를 정의합니다.
items사전의 방법을 사용하여 키-값 쌍을 튜플로 가져오고 키를 기준으로 결과를 정렬합니다.

초보자:

def find_max_min(numbers):
    max_value = max(numbers)
    min_value = min(numbers)
    return max_value, min_value

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

# Maximum value: 5
# Minimum value: 1

내장 max및 min함수를 사용하여 최대값과 최소값을 찾습니다.

def find_max_min(numbers):
    return max(numbers), min(numbers)

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

내장 max및 min함수를 사용하여 최대값과 최소값을 찾고 튜플로 반환합니다.

from functools import reduce

def find_max_min(numbers):
    return reduce(lambda acc, x: (max(acc[0], x), min(acc[1], x)), numbers, (float('-inf'), float('inf')))

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

find_max_min숫자 목록에서 최대값과 최소값을 찾는 함수를 정의합니다.
reduce함수를 람다 함수와 함께 사용하여 각 요소를 누적 값과 비교하여 최대값과 최소값을 계산합니다.
에지 케이스를 처리하기 위해 음수 및 양수 무한대로 누산기를 초기화합니다.

저자의 이미지

초보자:

def calculate_mean(numbers):
    return sum(numbers) / len(numbers)

def calculate_median(numbers):
    numbers.sort()
    n = len(numbers)
    if n % 2 == 0:
        return (numbers[n // 2 - 1] + numbers[n // 2]) / 2
    else:
        return numbers[n // 2]

def calculate_mode(numbers):
    counts = {}
    for num in numbers:
        if num in counts:
            counts[num] += 1
        else:
            counts[num] = 1
    return max(counts, key=counts.get)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean = calculate_mean(numbers)
median = calculate_median(numbers)
mode = calculate_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

#Mean: 5.333333333333333, Median: 5.0, Mode: 4

이 calculate_mean함수는 숫자의 합을 목록의 길이로 나누어 평균을 찾습니다.
이 calculate_median함수는 목록을 정렬하고 중간 요소를 찾아 중앙값을 계산합니다.
이 calculate_mode함수는 사전을 사용하여 각 숫자의 발생 수를 세고 가장 높은 수를 찾습니다.

from statistics import mean, median, mode

def calculate_mean_median_mode(numbers):
    return mean(numbers), median(numbers), mode(numbers)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean, median, mode = calculate_mean_median_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

이 calculate_mean_median_mode함수는 평균, 중앙값 및 최빈값을 튜플로 반환합니다.

from statistics import mean, median, mode
from typing import List, Tuple

def calculate_mean_median_mode(numbers: List[float]) -> Tuple[float, float, float]:
    return mean(numbers), median(numbers), mode(numbers)

def main():
    numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
    mean_val, median_val, mode_val = calculate_mean_median_mode(numbers)
    print(f"Mean: {mean_val}, Median: {median_val}, Mode: {mode_val}")

if __name__ == "__main__":
    main()

이 함수는 statistics모듈을 사용하여 평균, 중앙값 및 최빈값을 계산합니다.
코드는 main스크립트가 실행될 때 호출되는 함수로 구성됩니다.

초보자:

def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    result.extend(list1[i:])
    result.extend(list2[j:])
    return result

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
merged_list = merge_sorted_lists(list1, list2)
print(merged_list)

이 함수는 두 개의 포인터(i 및 j)를 사용하여 두 개의 입력 목록을 반복하고 요소를 비교하여 병합된 목록을 만듭니다.
두 목록의 나머지 요소가 결과에 추가됩니다.

from heapq import merge
from typing import List

def merge_sorted_lists(list1: List[int], list2: List[int]) -> List[int]:
    return list(merge(list1, list2))

def main():
    list1 = [1, 3, 5, 7]
    list2 = [2, 4, 6, 8]
    merged_list = merge_sorted_lists(list1, list2)
    print(merged_list)

if __name__ == "__main__":
    main()

입력 매개변수 및 반환 유형에 대한 유형 주석이 포함됩니다.
코드는 main스크립트가 실행될 때 호출되는 함수로 구성됩니다.

초보자:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

number = 5
result = factorial(number)
print(f"The factorial of {number} is {result}.")
#The factorial of 5 is 120.

이 함수는 0일 때 1을 반환하는 기본 사례를 포함합니다 n.
재귀 사례는 의 계승을 곱하여 계승을 계산 n합니다 n - 1.

from functools import lru_cache
from typing import Optional

@lru_cache(maxsize=None)
def factorial(n: int) -> Optional[int]:
    if n < 0:
        print("Error: Factorial is not defined for negative numbers.")
        return None
    if n == 0:
        return 1
    return n * factorial(n - 1)

def main():
    number = 5
    result = factorial(number)
    if result is not None:
        print(f"The factorial of {number} is {result}.")
    else:
        print("Could not calculate factorial.")

if __name__ == "__main__":
    main()

데코레이터 @lru_cache는 factorial 함수를 메모하고 더 나은 성능을 위해 중간 결과를 캐싱하는 데 사용됩니다.
이 기능은 음수 입력 값을 확인하고 유효하지 않은 입력에 대해 오류 메시지를 제공합니다.
코드는 main코드 구성 및 계승을 계산할 수 없는 가능한 경우를 처리하기 위해 함수를 사용합니다.

초보자:

import pandas as pd

def load_csv(file_path):
    return pd.read_csv(file_path)

file_path = "data.csv"
df = load_csv(file_path)
print(df.head())

메서드를 load_csv사용하여 CSV 파일을 DataFrame으로 로드하는 함수를 정의합니다.read_csvpandas
head메서드를 사용하여 DataFrame의 처음 몇 행을 인쇄합니다.

import pandas as pd

def load_csv(file_path, use_cols=None, parse_dates=None):
    return pd.read_csv(file_path, usecols=use_cols, parse_dates=parse_dates)

file_path = "data.csv"
selected_columns = ['column1', 'column3']
date_columns = ['date_column']
df = load_csv(file_path, use_cols=selected_columns, parse_dates=date_columns)
print(df.head())

load_csv선택적 매개변수를 사용하여 use_cols각각 parse_dates열 선택 및 날짜 열 구문 분석을 위한 함수를 정의합니다 .
날짜 열을 datetime 개체로 구문 분석하여 CSV 파일에서 지정된 열을 로드합니다.
DataFrame의 처음 몇 행을 인쇄합니다.

def max_product(arr):
    max_product = float('-inf')
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            product = arr[i] * arr[j]
            if product > max_product:
                max_product = product
    return max_product

arr = [1, 3, 5, 2, 6, 4]
max_product_result = max_product(arr)
print("Maximum product of two integers:", max_product_result)
#30

이 함수는 중첩 루프를 사용하여 배열에서 가능한 모든 정수 쌍을 고려합니다.
각 쌍에 대해 제품이 계산되고 그에 따라 최대 제품 값이 업데이트됩니다.

from typing import List

def max_product(arr: List[int]) -> int:
    arr.sort(reverse=True)
    return arr[0] * arr[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

이 함수는 배열을 내림차순으로 정렬하고 가장 큰 처음 두 요소의 곱을 반환합니다.
코드는 main더 나은 구조와 가독성을 위해 함수로 구성됩니다.

from typing import List
from heapq import nlargest

def max_product(arr: List[int]) -> int:
    largest_nums = nlargest(2, arr)
    return largest_nums[0] * largest_nums[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

이 함수는 두 개의 가장 큰 정수의 곱을 반환합니다.
코드는 main스크립트가 실행될 때 호출되는 함수로 구성됩니다.

초보자:

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

arr = [1, 2, 4, 5, 6, 7, 9, 10]
target = 7
index = binary_search(arr, target)
print(f"Index of {target}:", index)

이 함수는 while루프를 사용하여 중간 요소의 값을 기준으로 검색 범위를 반복적으로 좁힙니다.
대상 값이 발견되면 함수는 중간 요소의 인덱스를 반환합니다. 그렇지 않으면 -1을 반환합니다.

from typing import List
from bisect import bisect_left

def binary_search(arr: List[int], target: int) -> int:
    index = bisect_left(arr, target)
    return index if index != len(arr) and arr[index] == target else -1

def main():
    arr = [1, 2, 4, 5, 6, 7, 9, 10]
    target = 7
    index = binary_search(arr, target)
    print(f"Index of {target}:", index)

if __name__ == "__main__":
    main()