Python Öğrenme Eğrisi: Python Newbie'den Pro'ya

Giriiş:

Python, basitliği, okunabilirliği ve çok yönlülüğü ile bilinen, dünyadaki en çok yönlü ve yaygın olarak kullanılan programlama dillerinden biridir. Bu makalede, kodun programcılar tarafından üç farklı uzmanlık düzeyinde geliştirildiği bir dizi örnek senaryo keşfedeceğiz: başlangıç, orta ve uzman.

Ara ve uzmanlar normalde aşağıdakileri kullanır:

• Liste kavrayışları: Tek bir kod satırıyla listeler oluşturmanın özlü bir yolu.

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 ve kodlama stili: Kodun okunabilirliği ve tutarlılığı için Python'un resmi stil kılavuzuna (PEP 8) ve diğer en iyi uygulamalara bağlılık.

# 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

Acemi:

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)

• Bir sayının katsayı operatörünü kullanıp kullanmadığını kontrol eder
• Toplam değişkenine çift sayıyı ekler

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Çift sayıların toplamını hesaplamak için bir işlev oluşturur
• Kod daha modüler ve bakımı daha kolay

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)

• Çift sayıların kısa ve verimli bir şekilde filtrelenmesi için bir lambda işlevi kullanır
• Kod, Python'un işlevsel programlama yeteneklerinden yararlanarak daha derli topludur

Acemi:

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}

• Bir karakterin zaten sözlükte olup olmadığını kontrol eder ve sayımı buna göre günceller.

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()Kodu basitleştirmek için yöntemi kullanır .

from collections import Counter

def count_characters(text):
    return Counter(text)

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

• CounterKarakter oluşumlarını verimli bir şekilde saymak için yerleşik olandan yararlanır .

Acemi:

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

for num in numbers:
    total += num

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

• Ortalamayı hesaplamak için toplamı listenin uzunluğuna böler

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

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

• sumKodu basitleştirmek için yerleşik işlevi kullanır

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)

• meanOrtalamayı hesaplamak için yerleşik işlevi kullanır

Acemi:

text = "hello"
reversed_text = ""

for char in text:
    reversed_text = char + reversed_text

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

• Tersine çevrilmiş dizeyi oluşturmak için karakterleri ters sırada birleştirir

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

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

• Dizeyi tersine çevirmek için reversedişlev ve yöntemi kullanırjoin

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

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

5. Bir listedeki en büyük sayıyı bulma:

Acemi:

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

• Her sayıyı mevcut maksimum değerle karşılaştırır ve maksimum değeri buna göre günceller

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)

• maxMaksimum sayıyı bulmak için yerleşik işlevi kullanır

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)

• reduceMaksimum sayıyı bulmak için işlevi bir lambda işleviyle kullanır

Acemi:

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)

• Bir öğenin benzersiz listede olup olmadığını kontrol eder ve yoksa onu ekler

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)

• Yinelenenleri kaldırmak için yerleşik setveri yapısını kullanır ve onu tekrar bir listeye dönüştürür

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. Bir listedeki tüm sayıların karesini alma:

Acemi:

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]

• Her sayının karesini karesi alınmış sayılar listesine ekler

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)

• Kareli sayılar listesi oluşturmak için liste kavrayışını kullanır

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)

      
                

                    
                    
                
            

Acemi:

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]

Orta seviye:

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)

• Listeyi belirtilen konum sayısına göre döndürmek için Python'un dilimleme sözdizimini kullanır

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)

• Listeyi belirtilen konum sayısına göre verimli bir şekilde döndürmek için dequesınıftan ve yönteminden yararlanırrotate

Acemi:

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]

• İkinci listede bir öğe olup olmadığını kontrol eder ve bulunursa onu ortak öğeler listesine ekler.

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)

• Ortak öğelerin bir listesini oluşturmak için liste kavrayışını kullanır

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)

• Sonucu tekrar bir listeye dönüştürür

Acemi:

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)

• Transpoze matrisi oluşturmak için orijinal matristeki her satırdaki öğeleri ekler

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)

• Aktarılan matrisi oluşturmak için iç içe geçmiş liste kavrayışını kullanır

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. Bir dizinin palindrom olup olmadığını kontrol etme:

Acemi:

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

• Her karakteri dizenin sonundaki karşılık gelen karakterle karşılaştırır ve is_palindromeeşleşmezlerse False olarak ayarlar

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

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

• Dizeyi tersine çevirmek için Python'un dilimleme sözdizimini kullanır ve orijinal dizeyle karşılaştırır

Acemi:

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]

• Bölünebilirken sayıyı tekrar tekrar bir çarpana bölmek için bir while döngüsü kullanır
• Asal çarpanları listeye ekler

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)

• Asal çarpanları belirlemek ve bunları listeye eklemek için iç içe geçmiş döngüler kullanır.

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)

• Sayıyı en küçük bölene göre art arda bölmek için tek bir while döngüsü kullanır
• Listeye asal çarpanları ekler ve son asal çarpanı hesaba katmak için kalan sayının 1'den büyük olup olmadığını kontrol eder.

Acemi:

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]

• Her öğeyi yeni düz listeye ekler

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)

• Düz liste oluşturmak için iç içe geçmiş liste kavrayışını kullanır

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)

• Yuvalanmış listeyi düzleştirmek için işlevi flatten_listkullanan bir işlevi tanımlar.chain.from_iterable

Acemi:

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)

• Kelimeler üzerinde yineleme yapmak için temel bir for döngüsü kullanır ve bunların bir sözlükte geçtiği yerleri sayar

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)

• Bir cümledeki kelimelerin sıklığını saymak için sınıfı count_wordskullanan bir işlevi tanımlar.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_wordsKelimelerin sıklığını saymak için tamsayı değerleri olan bir defaultdict kullanan bir işlev tanımlar.
• splitCümleyi belirtmek için yöntemi ve sözcük sayısını artırmak için bir for döngüsü kullanır

Acemi:

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İlk sözlüğün bir kopyasını oluşturmak için yöntemi ve updateikinci sözlükteki anahtar/değer çiftleriyle sözlüğü güncellemek için yöntemi kullanır.

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, **d2Sözlükleri birleştirmek için sözlük açmayı ( ) kullanır

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İki sözlüğü birleştirmek için bir işlev tanımlar
• ChainMapİki sözlüğün birleşik görünümünü oluşturmak için sınıfı kullanır ve sonucu bir sözlüğe dönüştürür

Acemi:

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]

• İlk listedeki öğeler üzerinde yineleme yapmak için temel bir for döngüsü kullanır ve her öğenin ikinci listede bulunup bulunmadığını kontrol eder.
• Benzersiz öğeleri fark listesine ekler

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)

• Listeleri kümelere dönüştürür ve benzersiz öğeleri bulmak için küme farkı işlecini ( -) kullanır.
• Sonucu tekrar bir listeye dönüştürür

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)

• Benzersiz öğelerden oluşan bir liste oluşturmak için bir koşulla birlikte liste kavrayışını kullanır
• Üyelik testini optimize etmek için ikinci listeyi bir kümeye dönüştürür

Acemi:

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'}

• zipAnahtarlar ve değerler üzerinde aynı anda yineleme işleviyle birlikte bir for döngüsü kullanır
• Her değeri karşılık gelen anahtarına atayarak sözlüğü oluşturur

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)

• zipAnahtarları ve değerleri eşleştirmek için işlevi kullanır ve ardından dictsözlüğü oluşturmak için yapıcıyı kullanır.

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)

• zipSözlük oluşturma işleviyle birlikte sözlük kavrayışını kullanır

Acemi:

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))

      
                

                    
                    
                
            

Acemi:

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))

      
                

                    
                    
                
            

Acemi:

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)

      
                

                    
                    
                
            

Acemi:

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]}

• Çift sayıları listeye even_numbers, tek sayıları listeye odd_numbersekler
• Sayıları bir sözlükte gruplandırın

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)

• Gruplandırılmış sözlüğü oluşturmak için sözlük kavrayışını ve liste kavrayışını kullanır

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_paritySayıları eşliklerine göre gruplandırmak için defaultdict kullanan bir işlevi tanımlar.
• Numaraları yineler ve gruplandırılmış sözlükte uygun anahtara ("çift" veya "tek") ekler.

Acemi:

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

• En yaygın öğeyi bulmak için maxişlevi bağımsız değişkenle birlikte kullanırkey

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)

• Listedeki öğelerin oluşumlarını saymak için "Counter" sınıfını kullanan bir "most_common_element" işlevini tanımlar

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)

• Listedeki en yaygın öğeyi bulmak için işlevi most_common_elementkullanan bir işlevi tanımlar.mode
• İşlev mode, listedeki en yaygın öğeyi döndürür

Acemi:

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)]

• itemsDemetlerin listesini oluşturmak için sözlük yöntemiyle bir liste kavrayışı kullanır

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)

• itemsAnahtar-değer çiftlerini demet olarak almak için sözlük yöntemini kullanır ve sonucu bir listeye dönüştürür

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_tuplesBir sözlüğü demetler listesine dönüştürmek için bir işlev tanımlar
• itemsAnahtar-değer çiftlerini demetler olarak almak için sözlük yöntemini kullanır ve sonucu anahtarlara göre sıralar

Acemi:

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

• Maksimum ve minimum değerleri bulmak için yerleşik maxve işlevleri kullanırmin

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)

• Maksimum ve minimum değerleri bulmak için yerleşik maxve işlevleri kullanır ve bunları bir demet olarak döndürürmin

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_minBir sayı listesindeki maksimum ve minimum değerleri bulmak için bir işlev tanımlar
• reduceHer öğeyi birikmiş değerlerle karşılaştırarak maksimum ve minimum değerleri hesaplamak için lambda işlevine sahip işlevi kullanır
• Edge durumlarını işlemek için akümülatörü negatif ve pozitif sonsuzlukla başlatır

Acemi:

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

• İşlev calculate_mean, sayıların toplamını listenin uzunluğuna bölerek ortalamayı bulur.
• İşlev, calculate_medianlisteyi sıralar ve medyanı hesaplamak için ortadaki öğeleri bulur.
• İşlev calculate_mode, her sayının tekrarını saymak için bir sözlük kullanır ve en yüksek sayıya sahip sayıyı bulur.

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}")

• İşlev calculate_mean_median_mode, ortalama, medyan ve modu bir demet olarak döndürür.

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()

• İşlev, statisticsortalama, medyan ve modu hesaplamak için modülü kullanır.
• mainKod , komut dosyası yürütüldüğünde çağrılan bir işlev halinde düzenlenmiştir .

Acemi:

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)

• İşlev, iki giriş listesini yinelemek için iki işaretçi (i ve j) kullanır ve birleştirilmiş listeyi oluşturmak için öğeleri karşılaştırır.
• Her iki listeden Kalan öğeler sonuca eklenir.

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()

• Giriş parametreleri ve dönüş tipi için tip ek açıklamaları dahildir.
• mainKod , komut dosyası yürütüldüğünde çağrılan bir işlev halinde düzenlenmiştir .

Acemi:

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.

• İşlev nsıfır olduğunda 1 döndüren bir temel durum içerir.
• Özyinelemeli durum faktöriyelini nfaktoriyeliyle çarparak hesaplar 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()

• Dekoratör, @lru_cachedaha iyi performans için ara sonuçları önbelleğe alarak faktöriyel işlevi ezberlemek için kullanılır.
• İşlev, negatif giriş değerlerini kontrol eder ve geçersiz girişler için bir hata mesajı sağlar.
• Kod, mainkod organizasyonu işlevini ve faktöriyelin hesaplanamadığı olası durumları işlemek için kullanır.

Acemi:

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())

• Yöntemini load_csvkullanarak bir CSV dosyasını bir DataFrame'e yüklemek için bir işlev tanımlar.read_csvpandas
• headYöntemi kullanarak DataFrame'in ilk birkaç satırını yazdırır

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İsteğe bağlı parametrelerle use_colsve parse_datessırasıyla sütunları seçmek ve tarih sütunlarını ayrıştırmak için bir işlev tanımlar
• Tarih sütunlarını tarih saat nesneleri olarak ayrıştırarak, belirtilen sütunları CSV dosyasından yükler
• DataFrame'in ilk birkaç satırını yazdırır

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

• İşlev, dizideki tüm olası tamsayı çiftlerini dikkate almak için iç içe döngüler kullanır.
• Her çift için ürün hesaplanır ve maksimum ürün değeri buna göre güncellenir.

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()

• İşlev, diziyi azalan düzende sıralar ve en büyük olan ilk iki öğenin çarpımını döndürür.
• Kod, daha iyi yapı ve okunabilirlik için bir işlevle düzenlenmiştir 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()

• İşlev, en büyük iki tam sayının çarpımını döndürür.
• mainKod , komut dosyası yürütüldüğünde çağrılan bir işlev halinde düzenlenmiştir .

Acemi:

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)

• İşlev, whileorta öğenin değerine göre arama aralığını tekrar tekrar daraltmak için bir döngü kullanır.
• Hedef değer bulunursa, işlev ortadaki öğenin dizinini döndürür; aksi halde -1 döndürür.

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()

• İşlev, hedef değerin bulunan dizinde olup olmadığını kontrol eder ve hedefle eşleşirse dizini döndürür; aksi halde -1 döndürür.
• mainKod , komut dosyası yürütüldüğünde çağrılan bir işlev halinde düzenlenmiştir .

Başlangıç ​​düzeyindeki programcılar temel sözdizimine ve temel kavramlara odaklanır, orta düzeydeki programcılar optimizasyonları ve modüler kodu tanıtırken, uzman programcılar gelişmiş tekniklerden, hata işlemeden, kod organizasyonundan ve genel sağlamlıktan yararlanır. Daha fazla bilgi edinmek için lütfen referansları kontrol edin.

Referanslar:

1. Python.org Resmi Belgeleri:
   Bağlantı:https://docs.python.org/3/tutorial/index.html
2. Codecademy Python Kursu:
   Bağlantı:https://www.codecademy.com/learn/learn-python-3
3. Coursera'nın Herkes İçin Python'u:
   Bağlantı:https://www.coursera.org/specializations/python
4. Google'ın Python Sınıfı:
   Bağlantı:https://developers.google.com/edu/python
5. LeetCode:
   Bağlantı:https://leetcode.com
6. HackerRank:
   Bağlantı:https://www.hackerrank.com/domains/tutorials/10-days-of-python
7. Kod Savaşları:
   Bağlantı:https://www.codewars.com
8. Yığın Taşması:
   Bağlantı:https://stackoverflow.com/questions/tagged/python
9. Python Reddit Topluluğu (r/Python):
   Bağlantı:https://www.reddit.com/r/Python/
10. Python Discord Topluluğu:
    Bağlantı:https://pythondiscord.com

Topluluğumuzun bir parçası olduğunuz için teşekkürler! Gitmeden önce:

• Hikaye için alkışlayın ve yazarı takip edin
• Seviye Atlama Kodlama yayınında daha fazla içerik görüntüleyin
• Ücretsiz kodlama mülakat kursu ⇒ Kursu Görüntüle
• Bizi takip edin: Twitter | LinkedIn | Bülten