


Sebagai pengarang terlaris, saya menjemput anda untuk menerokai buku saya di Amazon. Jangan lupa ikuti saya di Medium dan tunjukkan sokongan anda. terima kasih! Sokongan anda bermakna dunia!
Sebagai pembangun Python yang mempunyai pengalaman luas dalam pemprosesan data besar, saya mendapati penjana adalah alat yang sangat diperlukan untuk mengendalikan set data besar dengan cekap. Dalam artikel ini, saya akan berkongsi lima teknik penjana berkuasa yang telah meningkatkan aliran kerja pemprosesan data saya dengan ketara.
Ekspresi penjana ialah asas pemprosesan data yang cekap memori dalam Python. Tidak seperti pemahaman senarai, yang mencipta keseluruhan senarai dalam ingatan, ungkapan penjana menghasilkan nilai atas permintaan. Pendekatan ini amat berfaedah apabila bekerja dengan set data yang besar.
Pertimbangkan contoh ini di mana kita perlu memproses fail CSV yang besar:
def csv_reader(file_path): with open(file_path, 'r') as file: for line in file: yield line.strip().split(',') def process_large_csv(file_path): data_gen = csv_reader(file_path) processed_gen = (process_row(row) for row in data_gen) for processed_row in processed_gen: # Further processing or storage pass
Dalam kod ini, kami menggunakan fungsi penjana csv_reader untuk menghasilkan baris daripada fail CSV satu demi satu. Kami kemudian menggunakan ungkapan penjana untuk memproses setiap baris. Pendekatan ini membolehkan kami mengendalikan fail dalam sebarang saiz tanpa memuatkan keseluruhan set data ke dalam memori.
Hasil daripada penyata ialah alat yang berkuasa untuk meratakan penjana bersarang. Ia memudahkan kod dan meningkatkan prestasi apabila bekerja dengan struktur data yang kompleks.
Berikut ialah contoh penggunaan hasil daripada untuk memproses data JSON bersarang:
import json def flatten_json(data): if isinstance(data, dict): for key, value in data.items(): yield from flatten_json(value) elif isinstance(data, list): for item in data: yield from flatten_json(item) else: yield data def process_large_json(file_path): with open(file_path, 'r') as file: data = json.load(file) for item in flatten_json(data): # Process each flattened item pass
Kod ini meratakan struktur JSON bersarang dengan cekap, membolehkan kami memproses data yang kompleks tanpa membuat senarai perantaraan.
Penjana tak terhingga amat berguna untuk mencipta aliran data atau mensimulasikan proses berterusan. Ia boleh digunakan dalam senario di mana kita perlu menjana data selama-lamanya atau sehingga syarat tertentu dipenuhi.
Berikut ialah contoh penjana tak terhingga yang mensimulasikan data penderia:
import random import time def sensor_data_generator(): while True: yield { 'timestamp': time.time(), 'temperature': random.uniform(20, 30), 'humidity': random.uniform(40, 60) } def process_sensor_data(duration): start_time = time.time() for data in sensor_data_generator(): print(f"Temperature: {data['temperature']:.2f}°C, Humidity: {data['humidity']:.2f}%") if time.time() - start_time > duration: break time.sleep(1) process_sensor_data(10) # Process data for 10 seconds
Penjana tak terhingga ini secara berterusan menghasilkan data sensor simulasi. Fungsi process_sensor_data menggunakan penjana ini untuk memproses data untuk tempoh tertentu.
Saluran paip penjana ialah cara yang elegan untuk membina rantaian transformasi data yang kompleks. Setiap langkah dalam perancangan boleh menjadi penjana, membolehkan pemprosesan set data besar yang cekap.
Berikut ialah contoh saluran paip penjana untuk memproses fail log:
import re def read_logs(file_path): with open(file_path, 'r') as file: for line in file: yield line.strip() def parse_logs(lines): pattern = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) \[(\w+)\] (.+)' for line in lines: match = re.match(pattern, line) if match: yield { 'timestamp': match.group(1), 'level': match.group(2), 'message': match.group(3) } def filter_errors(logs): for log in logs: if log['level'] == 'ERROR': yield log def process_log_file(file_path): logs = read_logs(file_path) parsed_logs = parse_logs(logs) error_logs = filter_errors(parsed_logs) for error in error_logs: print(f"Error at {error['timestamp']}: {error['message']}") process_log_file('application.log')
Saluran paip ini membaca fail log, menghuraikan setiap baris, menapis untuk mesej ralat dan memprosesnya. Setiap langkah adalah penjana, membolehkan pemprosesan fail log besar yang cekap.
Modul itertools dalam Python menyediakan satu set alatan yang cepat dan cekap memori untuk bekerja dengan iterator. Fungsi ini amat berguna apabila memproses output penjana.
Berikut ialah contoh menggunakan itertools.islice dan itertools.groupby untuk memproses set data yang besar:
def csv_reader(file_path): with open(file_path, 'r') as file: for line in file: yield line.strip().split(',') def process_large_csv(file_path): data_gen = csv_reader(file_path) processed_gen = (process_row(row) for row in data_gen) for processed_row in processed_gen: # Further processing or storage pass
Dalam contoh ini, kami menggunakan islice untuk mengehadkan bilangan item yang diproses dan berkumpulan untuk mengumpulkan data mengikut kategori. Pendekatan ini membolehkan kami memproses dan menganalisis subset set data yang besar dengan cekap.
Apabila bekerja dengan penjana, pengendalian ralat yang betul adalah penting. Memandangkan penjana boleh kehabisan tenaga, kami perlu mengendalikan kemungkinan pengecualian StopIteration dan ralat lain yang mungkin berlaku semasa pemprosesan.
Berikut ialah contoh pengendalian ralat yang mantap dalam saluran paip pemprosesan data berasaskan penjana:
import json def flatten_json(data): if isinstance(data, dict): for key, value in data.items(): yield from flatten_json(value) elif isinstance(data, list): for item in data: yield from flatten_json(item) else: yield data def process_large_json(file_path): with open(file_path, 'r') as file: data = json.load(file) for item in flatten_json(data): # Process each flattened item pass
Kod ini menunjukkan cara mengendalikan ralat pada peringkat item dan peringkat penjana, memastikan pemprosesan set data besar yang mantap.
Untuk mengoptimumkan prestasi apabila bekerja dengan penjana, pertimbangkan petua berikut:
- Gunakan ungkapan penjana dan bukannya pemahaman senarai apabila boleh.
- Laksanakan caching untuk pengiraan mahal dalam penjana.
- Gunakan modul itertools untuk operasi iterator yang cekap.
- Pertimbangkan pemprosesan selari untuk tugas terikat CPU menggunakan berbilang pemprosesan.
Berikut ialah contoh melaksanakan caching dalam penjana:
import random import time def sensor_data_generator(): while True: yield { 'timestamp': time.time(), 'temperature': random.uniform(20, 30), 'humidity': random.uniform(40, 60) } def process_sensor_data(duration): start_time = time.time() for data in sensor_data_generator(): print(f"Temperature: {data['temperature']:.2f}°C, Humidity: {data['humidity']:.2f}%") if time.time() - start_time > duration: break time.sleep(1) process_sensor_data(10) # Process data for 10 seconds
Kod ini menggunakan penghias lru_cache untuk cache hasil pengiraan yang mahal, meningkatkan prestasi dengan ketara untuk nilai berulang.
Penjana amat berguna untuk memproses fail log yang besar. Berikut ialah contoh yang lebih maju yang menunjukkan pemprosesan log akses Apache:
import re def read_logs(file_path): with open(file_path, 'r') as file: for line in file: yield line.strip() def parse_logs(lines): pattern = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) \[(\w+)\] (.+)' for line in lines: match = re.match(pattern, line) if match: yield { 'timestamp': match.group(1), 'level': match.group(2), 'message': match.group(3) } def filter_errors(logs): for log in logs: if log['level'] == 'ERROR': yield log def process_log_file(file_path): logs = read_logs(file_path) parsed_logs = parse_logs(logs) error_logs = filter_errors(parsed_logs) for error in error_logs: print(f"Error at {error['timestamp']}: {error['message']}") process_log_file('application.log')
Kod ini memproses fail log akses Apache yang besar dengan cekap, memberikan cerapan tentang kekerapan alamat IP, pengedaran kod status dan jumlah data yang dipindahkan.
Apabila bekerja dengan dokumen XML yang besar, penjana boleh sangat membantu. Berikut ialah contoh menggunakan modul xml.etree.ElementTree untuk memproses fail XML yang besar:
import itertools def large_dataset(): for i in range(1000000): yield {'id': i, 'category': chr(65 + i % 26), 'value': i * 2} def process_data(): data = large_dataset() # Process only the first 100 items first_100 = itertools.islice(data, 100) # Group the first 100 items by category grouped = itertools.groupby(first_100, key=lambda x: x['category']) for category, items in grouped: print(f"Category {category}:") for item in items: print(f" ID: {item['id']}, Value: {item['value']}") process_data()
Kod ini menggunakan iterparse untuk memproses fail XML yang besar dengan cekap tanpa memuatkan keseluruhan dokumen ke dalam memori. Ia menghasilkan elemen dengan nama teg tertentu, membolehkan pemprosesan disasarkan bagi struktur XML yang besar.
Penjana juga sangat baik untuk melaksanakan saluran paip data dalam proses ETL (Extract, Transform, Load). Berikut ialah contoh saluran paip ETL mudah menggunakan penjana:
def safe_process(generator): try: for item in generator: try: yield process_item(item) except ValueError as e: print(f"Error processing item: {e}") except StopIteration: print("Generator exhausted") except Exception as e: print(f"Unexpected error: {e}") def process_item(item): # Simulate processing that might raise an error if item % 10 == 0: raise ValueError("Invalid item") return item * 2 def item_generator(): for i in range(100): yield i for result in safe_process(item_generator()): print(result)
Saluran paip ETL ini membaca data daripada fail CSV, mengubahnya dengan menggunakan beberapa logik perniagaan, dan kemudian memuatkannya ke dalam fail JSON. Penggunaan penjana membolehkan pemprosesan set data yang besar dengan cekap dengan penggunaan memori yang minimum.
Kesimpulannya, penjana Python ialah alat yang berkuasa untuk pemprosesan data besar yang cekap. Mereka membenarkan kami bekerja dengan set data yang besar tanpa memuatkan semuanya ke dalam memori sekaligus. Dengan menggunakan teknik seperti ungkapan penjana, hasil daripada, penjana tak terhingga, saluran paip penjana dan modul itertools, kami boleh mencipta aliran kerja pemprosesan data yang cekap memori dan berprestasi.
Sepanjang kerjaya saya, saya mendapati teknik penjana ini tidak ternilai apabila berurusan dengan fail log besar, dokumen XML/JSON yang kompleks dan proses ETL berskala besar. Mereka telah membenarkan saya memproses data yang mungkin mustahil untuk dikendalikan dengan kaedah tradisional.
Sambil anda bekerja dengan data besar dalam Python, saya menggalakkan anda untuk meneroka teknik penjana ini dan memasukkannya ke dalam projek anda. Ia bukan sahaja akan meningkatkan kecekapan kod anda tetapi juga membolehkan anda menangani tugas pemprosesan data yang lebih besar dan lebih kompleks dengan mudah.
101 Buku
101 Buku ialah syarikat penerbitan dipacu AI yang diasaskan bersama oleh pengarang Aarav Joshi. Dengan memanfaatkan teknologi AI termaju, kami memastikan kos penerbitan kami sangat rendah—sesetengah buku berharga serendah $4—menjadikan pengetahuan berkualiti boleh diakses oleh semua orang.
Lihat buku kami Kod Bersih Golang tersedia di Amazon.
Nantikan kemas kini dan berita menarik. Apabila membeli-belah untuk buku, cari Aarav Joshi untuk mencari lebih banyak tajuk kami. Gunakan pautan yang disediakan untuk menikmati diskaun istimewa!
Ciptaan Kami
Pastikan anda melihat ciptaan kami:
Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS
Kami berada di Medium
Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden
Atas ialah kandungan terperinci Teknik Penjana Python yang hebat untuk Pemprosesan Data Besar yang Cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Tomergelistsinpython, operator youCanusethe, extendmethod, listcomprehension, oritertools.chain, eachwithspecificadvantages: 1) operatorSimpleButlessefficientficorlargelists;

Dalam Python 3, dua senarai boleh disambungkan melalui pelbagai kaedah: 1) Pengendali penggunaan, yang sesuai untuk senarai kecil, tetapi tidak cekap untuk senarai besar; 2) Gunakan kaedah Extend, yang sesuai untuk senarai besar, dengan kecekapan memori yang tinggi, tetapi akan mengubah suai senarai asal; 3) menggunakan * pengendali, yang sesuai untuk menggabungkan pelbagai senarai, tanpa mengubah suai senarai asal; 4) Gunakan itertools.chain, yang sesuai untuk set data yang besar, dengan kecekapan memori yang tinggi.

Menggunakan kaedah Join () adalah cara yang paling berkesan untuk menyambungkan rentetan dari senarai di Python. 1) Gunakan kaedah Join () untuk menjadi cekap dan mudah dibaca. 2) Kitaran menggunakan pengendali tidak cekap untuk senarai besar. 3) Gabungan pemahaman senarai dan menyertai () sesuai untuk senario yang memerlukan penukaran. 4) Kaedah mengurangkan () sesuai untuk jenis pengurangan lain, tetapi tidak cekap untuk penyambungan rentetan. Kalimat lengkap berakhir.

PythonexecutionistheprocessoftransformingpythoncodeIntoExecutableInstructions.1) TheinterpreterreadsTheCode, convertingIntoByteCode, yang mana -mana

Ciri -ciri utama Python termasuk: 1. Sintaks adalah ringkas dan mudah difahami, sesuai untuk pemula; 2. Sistem jenis dinamik, meningkatkan kelajuan pembangunan; 3. Perpustakaan standard yang kaya, menyokong pelbagai tugas; 4. Komuniti dan ekosistem yang kuat, memberikan sokongan yang luas; 5. Tafsiran, sesuai untuk skrip dan prototaip cepat; 6. Sokongan multi-paradigma, sesuai untuk pelbagai gaya pengaturcaraan.

Python adalah bahasa yang ditafsirkan, tetapi ia juga termasuk proses penyusunan. 1) Kod python pertama kali disusun ke dalam bytecode. 2) Bytecode ditafsirkan dan dilaksanakan oleh mesin maya Python. 3) Mekanisme hibrid ini menjadikan python fleksibel dan cekap, tetapi tidak secepat bahasa yang disusun sepenuhnya.

UseAforLoopWheniteratingOvereForforpecificNumbimes; Useaphileloopwhencontinuinguntilaconditionismet.forloopsareidealforknownownsequences, sementara yang tidak digunakan.

Pythonloopscanleadtoerrorslikeinfiniteloops, pengubahsuaianListsduringiteration, off-by-oneerrors, sifar-indexingissues, andnestedloopinefficies.toavoidthese: 1) use'i


Alat AI Hot

Undresser.AI Undress
Apl berkuasa AI untuk mencipta foto bogel yang realistik

AI Clothes Remover
Alat AI dalam talian untuk mengeluarkan pakaian daripada foto.

Undress AI Tool
Gambar buka pakaian secara percuma

Clothoff.io
Penyingkiran pakaian AI

Video Face Swap
Tukar muka dalam mana-mana video dengan mudah menggunakan alat tukar muka AI percuma kami!

Artikel Panas

Alat panas

SublimeText3 versi Inggeris
Disyorkan: Versi Win, menyokong gesaan kod!

SecLists
SecLists ialah rakan penguji keselamatan muktamad. Ia ialah koleksi pelbagai jenis senarai yang kerap digunakan semasa penilaian keselamatan, semuanya di satu tempat. SecLists membantu menjadikan ujian keselamatan lebih cekap dan produktif dengan menyediakan semua senarai yang mungkin diperlukan oleh penguji keselamatan dengan mudah. Jenis senarai termasuk nama pengguna, kata laluan, URL, muatan kabur, corak data sensitif, cangkerang web dan banyak lagi. Penguji hanya boleh menarik repositori ini ke mesin ujian baharu dan dia akan mempunyai akses kepada setiap jenis senarai yang dia perlukan.

Pelayar Peperiksaan Selamat
Pelayar Peperiksaan Selamat ialah persekitaran pelayar selamat untuk mengambil peperiksaan dalam talian dengan selamat. Perisian ini menukar mana-mana komputer menjadi stesen kerja yang selamat. Ia mengawal akses kepada mana-mana utiliti dan menghalang pelajar daripada menggunakan sumber yang tidak dibenarkan.

Muat turun versi mac editor Atom
Editor sumber terbuka yang paling popular

Notepad++7.3.1
Editor kod yang mudah digunakan dan percuma
