For-lus in Python

De For-lus in Python heeft een aantal andere functies dan andere programmeertalen. Ik laat je achter wat ik aan het leren ben om het meeste uit een van de meest gebruikte loops te halen.

In Python is het bedoeld om door een itereerbaar object te itereren, of het nu een lijst, een object of een ander element is.

De volgende structuur is:

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in h2:
   instructions

Hier is h2 een itereerbaar element, bijvoorbeeld een lijst h2=[ 'Valencia', 'Castellón', 'Alicante']. De lus heeft 3 iteraties, in de eerste j=Valencia in de tweede de variabele j=Castellón.

En hiermee kunnen we de instructies definiëren die we willen, waarbij we altijd de inspringing onthouden, iets essentieels in Python en dat veel mensen negeren, waardoor fouten in de code ontstaan.

Herhaal voor lus een exact aantal keren.

Als we willen dat het een bepaald aantal keren wordt herhaald, zoals we kunnen in C++, moeten we range() gebruiken. Om 10 keer te herhalen gebruiken we a

for element in Range(9):
    instructions

We zetten 9 en niet 10 omdat Range begint bij 0, dus van 0 tot 9 zijn er 10 iteraties of windingen van de lus.

Als we Range() kennen, kunnen we, in plaats van een getal erin te zetten, een variabele plaatsen, zodat we veel meer controle hebben.

var = 10
for element in Range(var):
    instructions

De Range-functie heeft veel opties, ik zal er in een ander bericht over praten, om de inhoud niet te mixen en zoveel mogelijk te ontwikkelen.

Er kan veel meer worden gedaan om de stroom van de for-lus te regelen.

Verklaringen breken en doorgaan

Er zijn 2 zeer handige functies waarmee we een for-lus erg functioneel kunnen maken, voor de pauze en de continue. Ze worden meestal gebruikt met conditionals, als, om te controleren of iets waar is.

Ze werken in andere lussen, en er is nog een interessante instructie die pass is, een instructie die wordt uitgevoerd maar niets doet en ideaal is voor wanneer we een structuur willen definiëren waarvoor commando's nodig zijn, maar we willen ze later plaatsen (opmerkingen zijn niet handig hiervoor)

Breken

Met pauze kunnen we de lus op elk moment verlaten. Zoals je je voorstelt erg handig. Het is waar dat er andere structuren zijn zoals While,

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        break
else:
    print('No se encontró el número 3')

voortzetten

Het zorgt ervoor dat we naar het volgende element in de lus gaan.

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        continue
else:
    print('No se encontró el número 3')

https://j2logo.com/bucle-for-en-python/

Voor … anders

Er is een structuur afgeleid van For, dat is voor … else

datos = [1, 2, 3, 4, 5]
for n in datos:
    if n == 2:
        break
else:
    print('No hay 2')

Deze structuur ontstond nadat ze zagen dat het nodig was en dat veel mensen alternatieve manieren gebruikten om dit te bereiken. Zo helpen ze mensen en krijgen ze een beter leesbare code

voor _ in iterabel

Ik heb dit in sommige programma's gezien, hoewel ik het nooit heb gebruikt.

Wanneer we een object, lijst, woordenboek, enz. herhalen, maar de inhoud van die elementen ons niet interesseert, kunnen we dit aangeven met _

Een voorbeeld:

We willen de elementen van een lijst tellen, maar het maakt ons niet uit wat deze bevat, we willen alleen de lengte ervan.

h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
    cont += 1

Op veel sites raden ze aan deze praktijk niet te misbruiken. Ik ken de voordelen die het biedt echt niet, is het sneller?

achteruit lopen

achteruit voor lus. Om van het einde tot het begin te herhalen

Het gebruikt de functie reversed() die is geïntroduceerd in python 3.

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in reversed(h2):
    print (j)

Looping met twee indices, waarde van de iterable en index

Met enumerate() kunnen we werken met de indices van een verzameling. Omdat we vaak, naast de waarde van het itereerbare object zelf, geïnteresseerd zijn in de index ervan.

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j, h in enumerate(h2):
    print j, '-->', h2[i] 

Itereren over 2 lijsten

Een andere zeer interessante optie is zip() die ons werk gemakkelijker zal maken en onze code eenvoudiger en leesbaarder zal maken.

h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]

for j, h in zip(h2, cod):
    print h2, '-->', cod 

In Python 2.x werd izip() gebruikt om deze functie te verbeteren, maar in Python 3 is izip zip()

Looping in gesorteerde volgorde

Herhaal in volgorde op de waarde van het object in plaats van op de index. gesorteerd() wordt gebruikt

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors):
    print color

En als we het achterstevoren willen doen

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, reverse=True):
    print color

Aangepaste sorteervolgorde

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, key=len):
    print color

Sentinel-waarde in for-lus

De schildwachtwaarde is een waarde die ervoor zorgt dat de lus eindigt. Het wordt meestal gepresenteerd in een while-lus, maar Raymond Hettinger laat ons zien hoe we het kunnen gebruiken met een for, wat sneller is.

blocks = []
for block in iter(partial(f.read, 32), ''):
    blocks.append(block)
    print (block)

Doorkruis woordenboeken met for

Woordenboeken zijn essentiële hulpmiddelen voor het uitdrukken van relaties en het maken van groeperingen.

Je kunt het woordenboek op een traditionele manier doornemen met for, maar dat geeft niet alle informatie terug, we kunnen niet met dergelijke waarden en indices werken, als we niet beginnen met het toevoegen van tellers en andere elementen.

d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}

for k in d.keys():
    if k.startswith('r'):
        del d[k]

Op deze manier kunnen we, naast het zien van de elementen, het woordenboek wijzigen door elementen te wijzigen of te verwijderen, terwijl de for-lus wordt herhaald.

d.keys() roept de argumenten aan en maakt een kopie die het opslaat in een lijst die we kunnen wijzigen.

Indexen en waarden krijgen in plaats van iets traditioneels en dat is het eerste dat in je opkomt voor degenen onder ons die beginnen met programmeren

for k in d:
    print k, '-->', d[k]

We zullen deze veel snellere optie gebruiken

for k, v in d.items():
    print k, '-->', v

iteritems() dan items()

Praten over Loops in Python door Raymond Hettinger

Het is een oude maar zeer illustratieve video, waarin Raymond Hettinger ons in de eerste 20 minuten de verschillende mogelijkheden van loops in Python leert en ons voorbeelden geeft van hoe ze structuren die veel door mensen worden gebruikt, omzetten in functies, om de loop leesbaarder en eenvoudiger te maken .code.

Laat een reactie achter