Kurva Pembelajaran Python: Dari Pemula Python hingga Pro

Perkenalan:

Python adalah salah satu bahasa pemrograman yang paling serbaguna dan banyak digunakan di dunia, dikenal karena kesederhanaan, keterbacaan, dan keserbagunaannya. Pada artikel ini, kita akan menjelajahi serangkaian contoh skenario di mana kode dikembangkan oleh pemrogram pada tiga tingkat keahlian yang berbeda: pemula, menengah, dan ahli.

Perantara dan ahli biasanya menggunakan yang berikut ini:

• Pemahaman daftar: Cara ringkas untuk membuat daftar dengan satu baris kode.

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 dan gaya pengkodean: Kepatuhan terhadap panduan gaya resmi Python (PEP 8) dan praktik terbaik lainnya untuk keterbacaan dan konsistensi kode.

# 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

Pemula:

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)

• Memeriksa apakah suatu angka genap menggunakan operator modulus
• Menambahkan angka genap ke variabel jumlah

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)

• Membuat fungsi even_sumuntuk menghitung jumlah bilangan genap
• Kode lebih modular dan lebih mudah dipelihara

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)

• Menggunakan fungsi lambda untuk pemfilteran angka genap yang ringkas dan efisien
• Kodenya lebih ringkas, memanfaatkan kemampuan pemrograman fungsional Python

Pemula:

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}

• Memeriksa apakah suatu karakter sudah ada dalam kamus dan memperbarui hitungan yang sesuai.

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)

• Menggunakan dict.get()metode untuk menyederhanakan kode.

from collections import Counter

def count_characters(text):
    return Counter(text)

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

• Memanfaatkan built-in Counteruntuk menghitung kemunculan karakter secara efisien.

Pemula:

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

for num in numbers:
    total += num

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

• Membagi jumlah dengan panjang daftar untuk menghitung rata-rata

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

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

• Menggunakan fungsi bawaan sumuntuk menyederhanakan kode

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)

• Memanfaatkan fungsi bawaan meanuntuk menghitung rata-rata

Pemula:

text = "hello"
reversed_text = ""

for char in text:
    reversed_text = char + reversed_text

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

• Menggabungkan karakter dalam urutan terbalik untuk membuat string terbalik

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

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

• Menggunakan reversedfungsi dan joinmetode untuk membalikkan string

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

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

5. Menemukan angka terbesar dalam daftar:

Pemula:

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

• Bandingkan setiap angka dengan maksimum saat ini dan perbarui maksimum yang sesuai

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)

• Menggunakan fungsi bawaan maxuntuk menemukan jumlah maksimum

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)

• Manfaatkan reducefungsi dengan fungsi lambda untuk menemukan jumlah maksimum

Pemula:

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)

• Memeriksa apakah suatu item tidak ada dalam daftar unik dan menambahkannya jika tidak ada

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)

• Menggunakan struktur data bawaan setuntuk menghapus duplikat dan mengubahnya kembali menjadi daftar

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. Mengkuadratkan semua angka dalam daftar:

Pemula:

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]

• Menambahkan kuadrat dari setiap angka ke daftar angka kuadrat

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)

• Menggunakan pemahaman daftar untuk membuat daftar angka kuadrat

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)

      
                

                    
                    
                
            

Pemula:

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]

Intermediat:

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)

• Menggunakan sintaks pemotongan Python untuk memutar daftar dengan jumlah posisi yang ditentukan

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)

• Memanfaatkan dequekelas dan rotatemetodenya untuk memutar daftar secara efisien dengan jumlah posisi yang ditentukan

Pemula:

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]

• Memeriksa apakah ada elemen dalam daftar kedua dan menambahkannya ke daftar elemen umum jika ditemukan

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)

• Menggunakan pemahaman daftar untuk membuat daftar elemen umum

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)

• Mengubah hasilnya kembali ke daftar

Pemula:

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)

• Menambahkan elemen dari setiap baris dalam matriks asli untuk membuat matriks yang ditransposisikan

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)

• Menggunakan pemahaman daftar bersarang untuk membuat matriks yang dialihkan

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. Memeriksa apakah suatu string adalah palindrom:

Pemula:

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

• Membandingkan setiap karakter dengan karakter yang sesuai dari akhir string dan menyetel is_palindromeke False jika tidak cocok

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

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

• Menggunakan sintaks pemotongan Python untuk membalikkan string dan membandingkannya dengan string asli

Pemula:

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]

• Menggunakan while loop untuk berulang kali membagi angka dengan faktor saat angka tersebut dapat dibagi
• Menambahkan faktor prima ke dalam daftar

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)

• Menggunakan perulangan bersarang untuk mengidentifikasi faktor prima dan menambahkannya ke daftar

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)

• Menggunakan satu while loop untuk berulang kali membagi angka dengan pembagi terkecil
• Menambahkan faktor prima ke dalam daftar dan memeriksa apakah angka yang tersisa lebih besar dari 1 untuk memperhitungkan faktor prima terakhir

Pemula:

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]

• Menambahkan setiap item ke daftar datar baru

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)

• Menggunakan pemahaman daftar bersarang untuk membuat daftar datar

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)

• Menentukan fungsi flatten_listyang menggunakan chain.from_iterablefungsi untuk meratakan daftar bersarang

Pemula:

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)

• Menggunakan loop for dasar untuk mengulangi kata-kata dan menghitung kemunculannya dalam kamus

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)

• Mendefinisikan fungsi count_wordsyang menggunakan Counterkelas untuk menghitung frekuensi kata dalam kalimat

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)

• Menentukan fungsi count_wordsyang menggunakan defaultdict dengan nilai integer untuk menghitung frekuensi kata
• Menggunakan splitmetode untuk menandai kalimat dan perulangan for untuk menambah jumlah kata

Pemula:

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}

• Menggunakan copymetode untuk membuat salinan kamus pertama dan metode updateuntuk memperbarui kamus dengan pasangan nilai kunci dari kamus kedua

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)

• Menggunakan pembongkaran kamus ( **d1, **d2) untuk menggabungkan kamus

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)

• Mendefinisikan fungsi merge_dictsuntuk menggabungkan dua kamus
• Menggunakan ChainMapkelas untuk membuat tampilan gabungan dari dua kamus dan mengonversi hasilnya menjadi kamus

Pemula:

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]

• Menggunakan loop for dasar untuk beralih ke elemen dalam daftar pertama, dan memeriksa apakah setiap elemen tidak ada dalam daftar kedua
• Menambahkan elemen unik ke daftar perbedaan

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)

• Mengonversi daftar menjadi himpunan dan menggunakan operator selisih himpunan ( -) untuk menemukan elemen unik
• Mengubah hasilnya kembali ke daftar

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)

• Menggunakan pemahaman daftar dengan syarat untuk membuat daftar elemen unik
• Mengonversi daftar kedua menjadi satu set untuk mengoptimalkan pengujian keanggotaan

Pemula:

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

• Menggunakan for loop dengan zipfungsi untuk mengulang kunci dan nilai secara bersamaan
• Buat kamus dengan menetapkan setiap nilai ke kunci yang sesuai

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)

• Menggunakan zipfungsi untuk memasangkan kunci dan nilai, lalu menggunakan dictkonstruktor untuk membuat kamus

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)

• Menggunakan pemahaman kamus dengan zipfungsi untuk membuat kamus

Pemula:

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

      
                

                    
                    
                
            

Pemula:

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

      
                

                    
                    
                
            

Pemula:

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)

      
                

                    
                    
                
            

Pemula:

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

• Menambahkan angka genap ke even_numbersdaftar dan angka ganjil ke odd_numbersdaftar
• Kelompokkan angka-angka tersebut ke dalam kamus

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)

• Menggunakan pemahaman kamus dan pemahaman daftar untuk membuat kamus yang dikelompokkan

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)

• Menentukan fungsi group_by_parityyang menggunakan defaultdict untuk mengelompokkan nomor berdasarkan paritasnya
• Ulangi angka dan tambahkan ke kunci yang sesuai ('genap' atau 'ganjil') dalam kamus yang dikelompokkan

Pemula:

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

• Menggunakan maxfungsi dengan keyargumen untuk menemukan elemen yang paling umum

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)

• Menentukan fungsi `most_common_element` yang menggunakan kelas `Counter` untuk menghitung kemunculan elemen dalam daftar

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)

• Menentukan fungsi most_common_elementyang menggunakan modefungsi untuk menemukan elemen yang paling umum dalam daftar
• Fungsi modemengembalikan elemen paling umum dalam daftar

Pemula:

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

• Menggunakan pemahaman daftar dengan itemsmetode kamus untuk membuat daftar tupel

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)

• Menggunakan itemsmetode kamus untuk mendapatkan pasangan kunci-nilai sebagai tupel dan mengonversi hasilnya menjadi daftar

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)

• Menentukan fungsi dict_to_tuplesuntuk mengubah kamus menjadi daftar tupel
• Menggunakan itemsmetode kamus untuk mendapatkan pasangan kunci-nilai sebagai tupel dan mengurutkan hasilnya berdasarkan kunci

Pemula:

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

• Menggunakan built-in maxdan minfungsi untuk menemukan nilai maksimum dan minimum

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)

• Menggunakan built-in maxdan minfungsi untuk menemukan nilai maksimum dan minimum dan mengembalikannya sebagai tupel

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)

• Menentukan fungsi find_max_minuntuk menemukan nilai maksimum dan minimum dalam daftar angka
• Menggunakan reducefungsi dengan fungsi lambda untuk menghitung nilai maksimum dan minimum dengan membandingkan setiap elemen dengan nilai akumulasi
• Menginisialisasi akumulator dengan infinity negatif dan positif untuk menangani kasus tepi

Pemula:

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

• Fungsi calculate_meanmenemukan rata-rata dengan membagi jumlah angka dengan panjang daftar.
• Fungsi calculate_medianmengurutkan daftar dan menemukan elemen tengah untuk menghitung median.
• Fungsi calculate_modemenggunakan kamus untuk menghitung kemunculan setiap angka dan menemukan angka dengan hitungan tertinggi.

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

• Fungsi calculate_mean_median_modemengembalikan mean, median, dan mode sebagai tuple.

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

• Fungsi menggunakan statisticsmodul untuk menghitung rata-rata, median, dan modus.
• Kode disusun menjadi sebuah mainfungsi, yang dipanggil saat skrip dijalankan.

Pemula:

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)

• Fungsi ini menggunakan dua pointer (i dan j) untuk mengulang melalui dua daftar input dan membandingkan elemen untuk membuat daftar gabungan.
• Elemen yang tersisa dari salah satu daftar ditambahkan ke hasilnya.

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

• Anotasi tipe disertakan untuk parameter input dan tipe pengembalian.
• Kode disusun menjadi sebuah mainfungsi, yang dipanggil saat skrip dijalankan.

Pemula:

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.

• Fungsi tersebut mencakup kasus dasar untuk kapan nadalah nol, mengembalikan 1.
• Kasus rekursif menghitung faktorial dengan mengalikan ndengan faktorial dari 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()

• Dekorator @lru_cachedigunakan untuk memoisasi fungsi faktorial, menyimpan hasil antara untuk kinerja yang lebih baik.
• Fungsi memeriksa nilai input negatif dan memberikan pesan kesalahan untuk input yang tidak valid.
• Kode menggunakan mainfungsi untuk organisasi kode dan untuk menangani kemungkinan kasus di mana faktorial tidak dapat dihitung.

Pemula:

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

• Menentukan fungsi load_csvuntuk memuat file CSV ke dalam DataFrame menggunakan read_csvmetode daripandas
• Mencetak beberapa baris pertama DataFrame menggunakan headmetode

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

• Menentukan fungsi load_csvdengan parameter opsional use_colsdan parse_datesuntuk memilih kolom dan mem-parsing kolom tanggal
• Memuat kolom yang ditentukan dari file CSV, mem-parsing kolom tanggal sebagai objek waktu
• Mencetak beberapa baris pertama dari 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

• Fungsi menggunakan loop bersarang untuk mempertimbangkan semua kemungkinan pasangan bilangan bulat dalam array.
• Untuk setiap pasangan, produk dihitung, dan nilai produk maksimum diperbarui.

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

• Fungsi mengurutkan array dalam urutan menurun dan mengembalikan produk dari dua elemen pertama, yang terbesar.
• Kode diatur dengan mainfungsi untuk struktur dan keterbacaan yang lebih baik.

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

• Fungsi mengembalikan produk dari dua bilangan bulat terbesar.
• Kode disusun menjadi sebuah mainfungsi, yang dipanggil saat skrip dijalankan.

Pemula:

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)

• Fungsi ini menggunakan whileloop untuk berulang kali mempersempit rentang pencarian berdasarkan nilai elemen tengah.
• Jika nilai target ditemukan, fungsi mengembalikan indeks elemen tengah; jika tidak, ia mengembalikan -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()

• Fungsi memeriksa apakah nilai target ada pada indeks yang ditemukan dan mengembalikan indeks jika cocok dengan target; jika tidak, ia mengembalikan -1.
• Kode disusun menjadi sebuah mainfungsi, yang dipanggil saat skrip dijalankan.

Pemrogram pemula fokus pada sintaks dasar dan konsep dasar, pemrogram tingkat menengah memperkenalkan pengoptimalan dan kode modular, sementara pemrogram ahli memanfaatkan teknik canggih, penanganan kesalahan, organisasi kode, dan ketahanan keseluruhan. Untuk mempelajari lebih lanjut silakan periksa referensi.

Referensi:

1. Dokumentasi Resmi Python.org:
   Tautan:https://docs.python.org/3/tutorial/index.html
2. Kursus Python Codecademy:
   Tautan:https://www.codecademy.com/learn/learn-python-3
3. Python Coursera untuk Semua Orang:
   Tautan:https://www.coursera.org/specializations/python
4. Kelas Python Google:
   Tautan:https://developers.google.com/edu/python
5. LeetCode:
   Tautan:https://leetcode.com
6. Peringkat Peretas:
   Tautan:https://www.hackerrank.com/domains/tutorials/10-days-of-python
7. Codewars:
   Tautan:https://www.codewars.com
8. Stack Overflow:
   Tautan:https://stackoverflow.com/questions/tagged/python
9. Komunitas Python Reddit (r/Python):
   Tautan:https://www.reddit.com/r/Python/
10. Komunitas Perselisihan Python:
    Tautan:https://pythondiscord.com

Terima kasih telah menjadi bagian dari komunitas kami! Sebelum kamu pergi:

• Tepuk tangan untuk ceritanya dan ikuti penulisnya
• Lihat lebih banyak konten di publikasi Level Up Coding
• Kursus wawancara coding gratis ⇒ Lihat Kursus
• Ikuti kami: Twitter | LinkedIn | Buletin