Gebruik van asterisken in Python

De meesten van ons gebruiken asterisken als vermenigvuldigings- en machtsoperatoren, maar ze hebben ook een breed scala aan toepassingen als prefix-operator in Python. Na het lezen van dit artikel ken je het volledige gebruik van asterisken.

Asterisken hebben in Python veel specifieke use-cases. Over het algemeen kennen we de vermenigvuldigings- en machtsoperatoren. Ze kunnen echter ook andere bewerkingen uitvoeren, zoals unpacking, argumenten doorgeven, enz., in verschillende situaties. Laten we eerst de algemene toepassing van asterisken bekijken.

Algemeen gebruik van * en **

* wordt gebruikt als vermenigvuldigingsoperator, en ** wordt gebruikt als machtsoperator.

## declaring variables
a, b = 2,3

## multiplication
print("Multiplication of 2 and 3 is {}".format(a * b))

## as power operator
print("2 power 3 is {}".format(a ** b))

Multiplication of 2 and 3 is 6
2 power 3 is 8

Nu heb je het algemene en meest gebruikte asterisk-gebruik gezien. Er zijn echter asterisk-use-cases die je misschien nog niet kent. Laten we verder gaan en het verborgen gebruik van asterisken ontdekken.

1. Unpacking met *

Unpacking van elementen uit een list/tuple/set met *. We gaan unpacking in toekomstige code gebruiken om enkele andere features van asterisken te implementeren. Unpacking is het basisidee achter het gebruik van asterisken als prefix-operator.

Stel dat we het eerste element van een list/tuple/set aan a willen toewijzen en de resterende elementen aan b. Gewoonlijk doen we dit met slicing.

## general approach
nums = [i for i in range(1, 6)]
a = nums[0]
b = nums[1:]
print(a, b)

print("--------------------------")

## hard approach
squares = [i ** 2 for i in range(1, 6)]
a = squares[0]
b = []
for i in range(1, len(squares)):
    b.append(squares[i])
print(a, b)

1 [2, 3, 4, 5]
--------------------------
1 [4, 9, 16, 25]

Nu gaan we de *-operator gebruiken om dit in één regel code te implementeren.

nums = [i for i in range(1, 6)]

## a will be 1 and b will be a list containing remaining elements
a, *b = nums
print(a, b)

1 [2, 3, 4, 5]

Hier is a van hetzelfde type als het element dat uit de lijst komt en b is een lijst. Unpacking werkt voor tuples en sets hetzelfde als voor lists. Laten we wat voorbeelden bekijken.

## using tuple
## here first element will assign to a and last element to c
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c)

print("--------------------------")

## using sets
a, *b, c = {1, 4, 9, 16, 25}
print(a, b, c)

1 [2, 3, 4] 5
--------------------------
1 [4, 9, 16] 25

1.1. Verschillende iterables combineren

We kunnen twee verschillende iterables toevoegen aan lists/sets/tuples met unpacking. Normaal gesproken zouden we de iterables omzetten en ze dan combineren tot één. Dat is niet nodig als we *. gebruiken. Zie het voorbeeld.

## combining a tuple, list, set
nums = [1, 2, 3]
nums2 = (4, 5, 6)
nums3 = {7, 8, 9}

## we convert the combined elements into any iterable we want
## here i am converting into a list
_list = [*nums, *nums2, *nums3]
_tuple = (*nums, *nums2, *nums3)
_set = {*nums, *nums2, *nums3}

print(type(_list))
print(_list)
print("------------------------")
print(type(_tuple))
print(_tuple)
print("------------------------")
print(type(_set))
print(_set)

<class 'list'>
[1, 2, 3, 4, 5, 6, 8, 9, 7]
------------------------
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 8, 9, 7)
------------------------
<class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9}

1.2. Geneste unpacking

Geneste unpacking haalt elementen uit het eerste niveau van de geëxtraheerde items. Bekijk het voorbeeld om te zien wat ik bedoel.

languages = ["Python", "HTML", "CSS", "JS"]

## unpacking
[[first_letter, *remaining], *other] = languages

print(first_letter, remaining, other)

P ['y', 't', 'h', 'o', 'n'] ['HTML', 'CSS', 'JS']

2. Unpacking met **

Zoals we eerder zagen, wordt ** gebruikt om elementen uit een dictionary te unpacken. We moeten de keys van de dictionary kennen om tijdens het unpacken de waarden op te halen. Laten we een voorbeeld bekijken.

## sample dictionary
person = {"name":"John", "age":19, "year_of_passing":"2021"}
string = "Name:-{name} Year Of Graduation:-{year_of_passing} Age:-{age}".format(**person)
print(string)

Name:-John Year Of Graduation:-2021 Age:-19

Het is niet gebruikelijk om ** te gebruiken om elementen uit een dictionary te halen.

3. Asterisken in functies

We kunnen argumenten doorgeven en opvangen met asterisken in functies om het aantal regels code te verminderen.

3.1. Unpacking in functies

De *-operator wordt gebruikt om een functie aan te roepen door een iterable te unpacken. Stel, we hebben een list en moeten alle elementen daarvan afzonderlijk aan print() doorgeven. Wat zou je doen? Je denkt vast aan een lus. Maar * maakt dit heel eenvoudig voor ons.

Geef de iterable gewoon door als *iterable_naam. Het pakt de iterable uit en geeft alle elementen afzonderlijk door.

nums = [i for i in range(1, 6)]
## passsing list using the *
print(*nums)

1 2 3 4 5

nums = (i for i in range(1, 6))
## passsing tuple using the *
print(*nums, sep = ", ")

1, 2, 3, 4, 5

3.2. Elementen packen

Packing betekent meerdere elementen tegelijk opvangen. We gebruiken deze feature bij functiaanroepen.

def average(*nums):
    return sum(nums) / len(nums)

Nu kunnen we een willekeurig aantal integers doorgeven om het gemiddelde te berekenen. De functie average vangt alle argumenten als een lijst op.

## calling the average with some numbers
print(average(1, 2, 3, 4, 5))

3.0

We hebben gezien hoe je meerdere elementen met * in een lijst opvangt. Nu leren we hoe je verschillende key-value-paren opvangt met **.

def _object(name, **properties):
    print(name, properties)

_object("Car", color="Red", cost=999999, company="Ferrari")

Car {'ceo': 'Louis', 'color': 'Red', 'cost': 999999, 'company': 'Ferrari'}

4. Alleen-keywordargumenten met positionele argumenten

Argumenten met een naam heten keywordargumenten. En de andere argumenten heten positionele argumenten. Eerst moet je het verschil tussen keyword- en positionele argumenten begrijpen. Laten we een voorbeeld bekijken.

## name is a positional argument
## color and cost are keyword arguments
def sample(car, color = None, cost = None):
    print("Car:-{} Color:-{}, Cost:-{}".format(car, color, cost))

We kunnen de naam van de parameter gebruiken om de argumenten door te geven bij het aanroepen van een functie voor keywordargumenten. Als we niets opgeven voor de keywordargumenten, nemen ze de standaardwaarde uit de functiedefinitie.

We kunnen de keywordargumenten specificeren met de keywords of de positie van de argumenten.

sample("Ferrari", "Red", 999999)

Car:-Ferrari Color:-Red, Cost:-999999

sample("Ferrari", cost = 999999, color = "Red")

Car:-Ferrari Color:-Red, Cost:-999999

De volgorde van keywordargumenten is niet essentieel als we ze aanroepen met de namen die in de functie zijn gedefinieerd.

sample("Ferrari", color = "Green")

Car:-Ferrari Color:-Green, Cost:-None

Nu heb je een idee van positionele en keywordargumenten. Laten we naar ons hoofdonderwerp gaan.

Alleen-keywordargumenten worden uitsluitend met de keywords opgegeven. We kunnen ze niet positioneel instellen, zoals we eerder zagen. We moeten de keywordargumenten na de *-argumenten declareren om alleen-keyword vast te leggen.

def keyword_only(*items, _list, default = False):
    print(items)
    print(_list)
    print(default)

We moeten de _list- en default-keywords gebruiken bij het aanroepen van de functie, omdat ze na *items komen. Als we geen keywords gebruiken om ze aan te roepen, krijgen we een fout. Laten we beide gevallen bekijken.

nums = [i ** 2 for i in range(1, 6)]
## calling the function
keyword_only(1, 2, 3, 4, 5, _list = nums, default = True)

(1, 2, 3, 4, 5)
[1, 4, 9, 16, 25]
True

Wat als we de functie keyword_only aanroepen met positionele argumenten?

nums = [i ** 2 for i in range(1, 6)]
## calling the function will raise an error
keyword_only(1, 2, 3, 4, 5, nums, False)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-85-bf737d8a8bfc> in <module>()
      1 nums = [i ** 2 for i in range(1, 6)]
----> 2 keyword_only(1, 2, 3, 4, 5, nums, False)


TypeError: keyword_only() missing 1 required keyword-only argument: '_list'

We krijgen een foutmelding dat er één vereist alleen-keywordargument ontbreekt. We moeten dus de keywords gebruiken bij het aanroepen van de alleen-keywordargumenten. Alleen-keywordargumenten worden in functies alleen gedefinieerd na de *-argumenten.

5. Alleen-keywordargumenten zonder positionele argumenten

Als we alleen alleen-keywordargumenten willen accepteren zonder positionele argumenten, laat Python ons * gebruiken in functieparameters om dit te bereiken. Laten we een voorbeeld bekijken.

def _sample(*, name):
    print(name)

Bovenstaande functie neemt alleen alleen-keywordargumenten aan. We moeten het argument met het keyword doorgeven. Anders krijgen we een fout. * in de functiedefinitie zorgt ervoor dat de functie alleen argumenten met keywords accepteert. Alle parameters die we na de *-parameter in de functie definiëren, moeten tijdens de functiaanroep met de keywords worden opgegeven.

## calling the function using keyword 'name'
_sample(name = "Datacamp")

Datacamp

## calling the function without using keyword 'name'
## we will get a TypeError
_sample("Datacamp")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-fe0d3718b56c> in <module>()
      1 ## calling the function without using keyword 'name'
      2 ## we will get a TypeError
----> 3 samp("Datacamp")


TypeError: samp() takes 0 positional arguments but 1 was given

Het is duidelijk dat de functie _sample() alleen de alleen-keyword*-argumenten accepteert.

Conclusie

Ontwikkelaars voegen in elke nieuwe release van Python nieuwe features toe. Asterisken zijn speciaal en verminderen bepaalde delen van de code. We kunnen meerdere positionele argumenten niet accepteren zonder *, en alleen-keywordargumenten hebben * ook nodig om die feature te implementeren. Andere bewerkingen met asterisken kunnen met meerdere regels code worden bereikt. Oefen ermee om het volledig te begrijpen. Bedankt voor het lezen!

Wil je meer leren over Python? Volg dan de cursus Python Data Science Toolbox (Part 1) van DataCamp.

Happy Coding :)