LE @pythonre
Showing posts older than #8904 · Back to latest
return to yield multiple valuesyield__slots__ attribute primarily optimize?collections.defaultdict?* operator do in function parameters?**kwargs in a function definition?for loops?__iter__ only__next__ only__iter__ and __next____getitem__asyncio from threading?await keyword do?functools.lru_cache?requests library and import time:import requests
import time
def get_btc_price():
url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
r = requests.get(url)
return r.json()["bitcoin"]["usd"]
threshold = 65000 # specify your goal
while True:
price = get_btc_price()
print(f"BTC: ${price}")
if price > threshold:
print("🚀 Time to sell!")
break
time.sleep(60)
Forwarded from Machine Learning with Python
Forwarded from Machine Learning with Python
schemdraw — a Python library that turns code into neat and clear electrical schematics.pip install schemdraw and you can start drawing.itertools.islicemy_list[start:end]) creates a new list in memory containing the sliced elements. While convenient for small lists, this becomes memory-inefficient for very large lists and is impossible for pure iterators (like generators or file objects) that don't support direct indexing.itertools.islice provides a memory-optimized solution by returning an iterator that yields elements from a source iterable (list, generator, file, etc.) between specified start, stop (exclusive), and step indices, without first materializing the entire slice into a new collection. This "lazy" consumption of the source iterable is crucial for processing massive datasets, infinite sequences, or streams where only a portion is needed, preventing excessive memory usage and improving performance. It behaves syntactically similar to standard slicing but operates at the iterator level.import itertools
import sys
# A generator for a very large sequence
def generate_large_sequence(count):
for i in range(count):
yield f"Data_Item_{i}"
# Imagine needing to process only a small segment of 10 million items
total_items = 10**7
data_stream = generate_large_sequence(total_items)
# Get items from index 500 to 509 (inclusive)
# Using islice:
print("--- Using itertools.islice ---")
# islice(iterable, [start], stop, [step])
# Here, start=500, stop=510 (exclusive)
for item in itertools.islice(data_stream, 500, 510):
print(item)
# Compare memory usage (conceptual, as actual list materialization would be massive)
# If you tried:
# large_list = list(generate_large_sequence(total_items)) # <-- HUGE memory consumption here!
# for item in large_list[500:510]:
# print(item)
# islice consumes minimal memory, only holding iterator state.
# The `data_stream` generator itself only holds its current state, not the whole sequence.
print("\n`itertools.islice` memory footprint is negligible compared to creating a full list slice.")