Banyak artikel telah ditulis tentang fitur Python yang menarik. Mereka berbicara tentang membongkar daftar dan tuple ke dalam variabel, tentang aplikasi parsial fungsi, tentang bekerja dengan objek yang dapat diubah. Tetapi dalam Python ada begitu banyak hal untuk itu. Penulis artikel yang kami terjemahkan hari ini mengatakan ia ingin berbicara tentang beberapa fitur Python yang ia gunakan. Pada saat yang sama, ia belum menemukan deskripsi tentang kemungkinan-kemungkinan ini, mirip dengan yang diberikan di sini. Mungkin saja Anda belum membacanya di tempat lain.
Menghapus data string input
Tugas membersihkan data yang dimasukkan oleh pengguna relevan untuk hampir semua program. Seringkali, pemrosesan input ini diturunkan untuk mengubah karakter menjadi huruf besar atau kecil. Terkadang data dapat dihapus menggunakan ekspresi reguler. Tetapi dalam kasus-kasus di mana tugasnya rumit, Anda bisa menerapkan cara yang lebih sukses untuk menyelesaikannya. Sebagai contoh - ini:
user_input = "This\nstring has\tsome whitespaces...\r\n" character_map = { ord('\n') : ' ', ord('\t') : ' ', ord('\r') : None } user_input.translate(character_map)
Di sini Anda dapat melihat bagaimana karakter spasi putih
"\n" dan
"\t" diganti dengan spasi reguler, dan bagaimana karakter
"\r" dihapus sepenuhnya dari string. Ini adalah contoh sederhana, tetapi kita dapat memperluasnya dengan membuat tabel pemetaan ulang karakter besar menggunakan paket
unicodedata dan fungsinya
combining() . Pendekatan ini memungkinkan Anda untuk menghapus dari garis segala sesuatu yang tidak diperlukan di sana.
Mendapatkan irisan iterator
Jika Anda mencoba untuk mendapatkan sepotong iterator, Anda akan menemukan kesalahan
TypeError , yang menunjukkan bahwa Anda tidak dapat berlangganan objek generator. Namun, masalah ini dapat diselesaikan:
import itertools s = itertools.islice(range(50), 10, 20)
Menggunakan metode
itertools.islice ,
itertools.islice bisa membuat objek
islice , yang merupakan iterator yang
islice elemen yang diperlukan. Namun, penting untuk dicatat di sini bahwa konstruksi ini menggunakan semua elemen generator hingga awal slice dan semua elemen dalam objek
islice .
Lewati mulai dari objek yang dapat diubah
Terkadang Anda perlu bekerja dengan file yang, seperti Anda ketahui, dimulai dengan sejumlah baris yang tidak perlu - seperti baris dengan komentar. Untuk melewati baris ini, Anda dapat kembali menggunakan
itertools :
string_from_file = """ // Author: ... // License: ... // // Date: ... Actual content... """ import itertools for line in itertools.dropwhile(lambda line: line.startswith("//"), string_from_file.split("\n")): print(line)
Kode ini hanya mengembalikan baris setelah blok komentar yang terletak di awal file. Pendekatan semacam itu dapat berguna ketika Anda hanya perlu membuang elemen (dalam kasus kami, garis) di awal objek yang dapat diubah, tetapi jumlah pastinya tidak diketahui.
Fungsi hanya mendukung argumen bernama (kwargs)
Untuk memungkinkannya saat menggunakan fungsi tertentu sehingga hanya argumen yang dinamai yang dapat diteruskan ke sana, Anda dapat melakukan hal berikut:
def test(*, a, b): pass test("value for a", "value for b")
Ini dapat bermanfaat untuk meningkatkan kelengkapan kode. Seperti yang Anda lihat, masalah kita mudah diselesaikan dengan menggunakan argumen
* di depan daftar argumen bernama. Di sini, yang cukup jelas, Anda juga dapat menggunakan argumen posisi - jika Anda menempatkannya sebelum argumen
* .
Membuat objek yang mendukung pernyataan with
Semua orang tahu bagaimana, misalnya, untuk membuka file, atau, mungkin, cara mengatur kunci menggunakan pernyataan
with . Tetapi apakah mungkin untuk secara mandiri menerapkan mekanisme kontrol kunci? Ya, itu sangat nyata. Protokol manajemen konteks eksekusi diimplementasikan menggunakan metode
__enter__ dan
__exit__ :
class Connection: def __init__(self): ... def __enter__(self):
Ini adalah cara paling umum untuk mengimplementasikan kapabilitas manajer konteks dalam Python, tetapi hal yang sama dapat dilakukan dengan lebih mudah:
from contextlib import contextmanager @contextmanager def tag(name): print(f"<{name}>") yield print(f"</{name}>") with tag("h1"): print("This is Title.")
Di sini, protokol manajemen konteks diimplementasikan menggunakan dekorator manajer konteks. Bagian pertama dari fungsi
tag (sebelum
yield ) dijalankan ketika Anda memasukkan blok
with . Blok ini kemudian dieksekusi, dan setelah itu sisa dari fungsi
tag dieksekusi.
Hemat memori dengan __slots__
Jika Anda pernah menulis program yang benar-benar membuat instance kelas tertentu dalam jumlah besar, maka Anda mungkin memperhatikan bahwa program semacam itu secara tak terduga membutuhkan banyak memori. Ini karena Python menggunakan kamus untuk mewakili atribut instance kelas. Ini memiliki efek yang baik pada kinerja, tetapi, dalam hal konsumsi memori, itu tidak efisien. Namun, biasanya fitur ini tidak menimbulkan masalah. Namun, jika Anda dihadapkan dengan kekurangan memori dalam situasi yang serupa, Anda dapat mencoba menggunakan atribut
__slots__ :
class Person: __slots__ = ["first_name", "last_name", "phone"] def __init__(self, first_name, last_name, phone): self.first_name = first_name self.last_name = last_name self.phone = phone
Di sini, ketika kita mendeklarasikan atribut
__slots__ , Python menggunakan array kecil dengan ukuran tetap untuk menyimpan atribut, bukan kamus. Ini sangat mengurangi jumlah memori yang diperlukan untuk setiap instance kelas. Ada beberapa kelemahan menggunakan atribut
__slots__ . Jadi, dengan menggunakannya, kami tidak dapat mendeklarasikan atribut baru, kami hanya terbatas pada atribut yang ada di
__slots__ . Selain itu, kelas dengan atribut
__slots__ tidak dapat menggunakan multiple inheritance.
Batas CPU dan memori
Jika, alih-alih mengoptimalkan program, atau meningkatkan cara menggunakan prosesor, Anda hanya perlu menetapkan batasan ketat pada sumber daya yang tersedia untuk itu, Anda dapat menggunakan perpustakaan yang sesuai:
import signal import resource import os
Ini menunjukkan keterbatasan waktu prosesor dan ukuran memori. Untuk membatasi penggunaan prosesor pada program, pertama-tama kami memperoleh nilai batas non-keras (lunak) dan keras (keras) untuk sumber daya tertentu (
RLIMIT_CPU ). Kemudian kita menetapkan batas menggunakan jumlah detik tertentu yang ditentukan oleh argumen
seconds dan nilai batas keras yang diperoleh sebelumnya. Setelah itu, kami mendaftarkan penangan
signal , yang, ketika waktu prosesor yang dialokasikan untuk program terlampaui, memulai prosedur keluar. Dalam hal memori, kami kembali mendapatkan nilai untuk batas yang tidak kaku dan keras, setelah itu kami menetapkan batas menggunakan metode
setrlimit , yang kami berikan ukuran batasan (
size ) dan nilai batas keras yang diperoleh sebelumnya.
Mengontrol apa yang bisa diimpor dari modul dan apa yang tidak bisa
Beberapa bahasa memiliki mekanisme ekspor yang sangat jelas dari modul variabel, metode, dan antarmuka. Misalnya, hanya entitas yang namanya dimulai dengan huruf kapital yang diekspor ke Golang. Dengan Python, semuanya diekspor. Tetapi hanya sampai atribut
__all__ :
def foo(): pass def bar(): pass __all__ = ["bar"]
Dalam contoh di atas, hanya fungsi
bar akan diekspor. Dan jika Anda membiarkan atribut
__all__ kosong, maka tidak ada yang akan diekspor dari modul sama sekali. Mencoba mengimpor sesuatu dari modul semacam itu akan menimbulkan kesalahan
AttributeError .
Sederhanakan pembuatan operator pembanding
Ada banyak operator pembanding. Misalnya,
__lt__ ,
__le__ ,
__gt__ ,
__ge__ . Hanya sedikit orang yang akan menyukai prospek implementasi mereka untuk kelas tertentu. Apakah ada cara untuk menyederhanakan tugas yang membosankan ini? Ya, Anda bisa - dengan bantuan
functools.total_ordering dekorator:
from functools import total_ordering @total_ordering class Number: def __init__(self, value): self.value = value def __lt__(self, other): return self.value < other.value def __eq__(self, other): return self.value == other.value print(Number(20) > Number(3)) print(Number(1) < Number(5)) print(Number(15) >= Number(15)) print(Number(10) <= Number(2))
Dekorator
functools.total_ordering digunakan di sini untuk menyederhanakan proses penerapan pemesanan instance kelas. Untuk memastikan operasinya, hanya perlu agar operator pembanding
__lt__ dan
__eq__ . Ini adalah minimum yang diperlukan oleh seorang dekorator untuk membangun operator pembanding yang tersisa.
Ringkasan
Ini bukan untuk mengatakan bahwa semua yang saya bicarakan di sini benar-benar diperlukan dalam pekerjaan sehari-hari setiap programmer Python. Tetapi beberapa teknik yang disajikan di sini, dari waktu ke waktu, bisa sangat membantu. Mereka, di samping itu, dapat menyederhanakan solusi masalah, untuk solusi biasa yang mungkin memerlukan banyak kode dan sejumlah besar pekerjaan monoton. Selain itu, saya ingin mencatat bahwa semua yang dibahas adalah bagian dari pustaka standar Python. Sejujurnya, beberapa fitur ini tampaknya agak tidak terduga untuk perpustakaan standar. Ini menunjukkan bahwa jika seseorang akan mengimplementasikan Python sesuatu yang tampaknya tidak cukup biasa, ia harus mencari-cari di perpustakaan standar. Jika Anda tidak dapat segera menemukan apa yang Anda butuhkan di sana, maka mungkin itu layak untuk dilakukan lagi, dengan sangat hati-hati, untuk menggali di sana. Benar, jika pencarian menyeluruh tidak berhasil, maka, kemungkinan besar, yang Anda butuhkan sebenarnya tidak ada. Dan jika demikian, maka Anda harus beralih ke perpustakaan pihak ketiga. Di dalamnya pasti dapat ditemukan.
Pembaca yang budiman! Apakah Anda tahu ada fitur Python standar yang mungkin tampak agak tidak biasa pada pandangan pertama disebut "standar"?
