Legjobb válasz
** Első dolog **:
A 64 bites Python csak a 64 bites rendszerre telepíthető, amely csak a 64 bites számítógépre telepíthető.
** Második dolog: **
Ha azt mondjuk, hogy a számítógép / program n-bites, az nem azt jelenti, hogy n méretű változókat használ. Ez azt jelenti, hogy legfeljebb 2 ^ n memória darabot képes megszólítani (általában bájtokat). Ezért a Windows XP vagy bármely más 32 bites operációs rendszer nem használhat kb. 3,5 GB-nál nagyobb RAM-ot. Számítsuk ki: 32 bináris bitek, így akár 2 ^ 32 bájtot is megcímezhetünk. 2 ^ 32 = 4294967296 [bájt] = 4096 [MB] = 4 [GB]. Mint látható, elméletileg a rendszernek legfeljebb 4 GB RAM-ot kell megcímeznie. Ez a körülbelül 0,5 [GB] “hiányzó” rész a PCI (AGP, USB stb.) Eszközök memóriájának címzésére szolgál. 64 bites rendszerrel akár 16777216 [TB] memóriát is meg tudunk címezni. Nagyon jó, mi?
** tl; dr **
A programok 32 bites A python legfeljebb (ideális esetben) 4 [GB] memóriát használhat fel, ami általában elég, de néha problémákat okozhat. Másrészt a python 64 bites példánya (tehát a programok is futtatnak vele) korlátlan * memóriamennyiséget tudnak címezni és használni, ami nagyon jó. De még egyszer, Adam Jorgensen válaszára: ugyanaz a 32 és 64 bites pythonon futtatott program ugyanannyi memóriát fog használni, amennyiben kevesebb, mint kb. 4 [GB]. Ez nem lesz lassabb 64 bites python is.
* ez nem teljesen igaz. Lásd a Második dolog, ha érdekel.
Remélem, hogy ez segít. 🙂
Válasz
Kérdése a megértés hiányát mutatja, ami történik, ezért időt szánok arra, hogy erről az egészről részletesen beszéljek.
Az első sorba a következőt írja: for loop in range(1, 11). A loop névnek egyáltalán nincs értelme. A teljes konstrukció egy hurok , azaz csak egyszer hurkol az 1-től 10-ig terjedő számokon. Amit írt, úgy tűnik, mintha 10-szer hurkolna, ami nem igaz. Tehát bár a kódja helyes, a változó neve azt jelzi, hogy nem érti a mi folyik itt.
for number in range(1, 11):
print(number)
Ez az egész (ez a két teljes kódsor) a for loop. Egy for loop.
Nem ” ne értsd meg, mit akarsz elérni a while ciklussal számos okból. Először is, ha meg akarja ismételni az összes számot, és lehetőséget ad a felhasználónak arra, hogy minden szám után kitörjön a hurokból, akkor ezt egyszerűen megteheti egy for-ciklussal.
for number in range(1, 11):
print(number)
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y"): #allow for variations and upper/lower case
break
Megjavíthatja a range(1, 11) nyomtatását úgy, hogy becsomagolja a list() fájlba, de úgy tűnik, ez még mindig nem az, amit szeretne. Feltételezem, hogy ugyanazt akarja csinálni, mint a for ciklusban, nevezetesen az egyes számok kinyomtatását, de lehetőséget ad arra, hogy minden szám után kitörjön a hurokból. Miért lenne másképp hurkja, ha ugyanazt a dolgot újra és újra kinyomtatná újra?
Ha nem akarja a for ciklust használni, használhat például:
current = 1
while True:
print(current)
current += 1
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y") or current == 10:
break
vagy
numbers = iter(range(1, 11))
while True:
current = next(numbers)
print(current)
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y") or current == 10: #avoid StopIteration
break
Vegye figyelembe az iter. A range(1, 11) nem nem iterátor , de egy iterálható , vagyis olyan objektum, amely iterátort hozhat létre. Ez nagyon finom, de fontos megkülönböztetés. A list iterálható, de nem iterátor. Az iterátor állapotot tart, vagyis emlékezik arra, hogy melyik értéket állítsa elő legközelebb. Ezt nem lehet egy listával megtenni, de a listát iterátorrá alakíthatja.
Például:
>>> my\_list = [1, 2, 3, 4, 5]
>>> my\_list\_iterator = iter(my\_list)
>>> first\_value = next(my\_list\_iterator)
>>>
>>> first\_value
1
>>> second\_value = next(my\_list\_iterator)
>>> second\_value
2
>>> type(my\_list)
>>> type(my\_list\_iterator)
Ha meg szeretné tudni, hogyan működik” a motorháztető alatt “, nézzük meg a következő példákat:
>>> class Counter:
... def \_\_init\_\_(self, start=1):
... self.current = start
... def \_\_next\_\_(self):
... value = self.current
... self.current += 1
... return value
... def \_\_iter\_\_(self):
... return self
...
>>> my\_counter = Counter()
>>> next(my\_counter)
1
>>> next(my\_counter)
2
>>> next(my\_counter)
3
iterátor , mivel állapotot tart (úgymond emlékszik a helyére). Pontosabban meg van határozva egy \_\_next\_\_() módszer. Bármely ponton előállíthatja a következő értéket. Ez egy iterálható , mivel a \_\_iter\_\_( ) módszer meghatározása.
A generátor olyan iterátor, amely lustán állít elő értékeket, például:
def counter(current=1):
while True:
yield current
current += 1
És igen, a generátoroknak így állapotuk van:
>>> my\_counter = counter()
>>> next(my\_counter)
1
>>> next(my\_counter)
2
>>> next(my\_counter)
3
Most az érdekes, hogy range nem a generátor , ellentétben a közhiedelemmel. A range iterálható , de nem iterátor , és így határozottan nem generátor . Ez bosszantónak tűnhet, de ennek néhány jó oka van (olyan plusz attribútumok, mint start, stop és step, megváltoztathatatlanság (” nem lehet megváltoztatni; ahhoz, hogy valami állapotot tartson, a lábujjaknak változtathatónak kell lennie). Természetesen lehetséges a range megvalósítása generátor:
>>> def my\_range\_generator(start, stop, step=1):
... current = start
... while current
... yield current
... current += step
...
>>> test\_range = my\_range\_generator(1, 11, 2)
>>> list(test\_range)
[1, 3, 5, 7, 9]
Remélem, elegendő hátteret adtam a probléma megértésének megkezdéséhez, nem csupán kijavításhoz.