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:
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 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!
Pastikan anda melihat ciptaan kami:
Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS
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!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
