Summary

Samenvatting Python Library en Tutorial

1 purchase

Course
Inleiding Programmeren voor CIW (800873B6)

Institution
Tilburg University (UVT)

In dit bestand vind je een samenvatting van de Python Library en de Python Tutorial die op de officiële site van Python te vinden zijn. In deze samenvatting staat alles wat relevant is voor het van Inleiding Programmeren voor CIW (800873-B-6)

[Show more]

Preview 4 out of 31 pages

View example

Uploaded on January 11, 2024
Number of pages 31
Written in 2023/2024
Type Summary

python
programmeren
aantekeningen
communicatie
informatie
wetenschappen
samenvatting

Institution
Tilburg University (UVT)
Education
Communicatie- en Informatiewetenschappen
Course
Inleiding Programmeren voor CIW (800873B6)

KHnx

Member since 1 year 57 documents sold

$8.06

Add to cart

Add to wishlist

100% satisfaction guarantee
Immediately available after payment
Both online and in PDF
No strings attached

Python library
Built-in functies
- abs() = returnt de absolute waarde van een nummer (input: integer of float, waarde is positief)
* De afstand tussen 0 en het desbetreffende getal
- all() = returnt True wanneer alle elementen tussen haakjes waar zijn, of wanneer de haakjes leeg zijn
(uitspraken over lijst van booleans)
- any() = returnt True wanneer één of meerdere elementen tussen de haakjes waar is, wanneer de
haakjes leeg zijn is de return False
- bool() = True of False
- dict() = maakt een nieuwe dictionary (zonder argument een leeg woordenboek)
* my_dict = dict(a=1, b=2, c=3), print(my_dict)  output: {“a”: 1, “b”: 2, “c”: 3}
- dir() = returnt een lijst van valide attributen voor het gegeven object tussen haakjes (mogelijkheden
om te doen met het object)
* my_list = [1, 2, 3], print(dir(my_list))  output: [“capitalize”, “find”, ...]
- enumerate() = returnt een tuple met telling (index), hetgeen wat je tussen haakjes invult is dus een
sequentie
* my_list = [“a”, “b”, “c”], result = list(enumerate(my_list, start=1)), print(result)  output:
[(1, “a”), (2, “b”), (3, “c”)]
- float() = maakt een kommagetal van de gegeven iterable (een “string” in dit geval), hierbij kun je +
en - gebruiken (0 wanneer er geen argument wordt gegeven)
- hash() = geeft de hash waarde van het object, wanneer het dit heeft (is een integer). Even grote
getallen (1.0 en 1 bv) hebben dezelfde hashwaarde (hashwaarde is een bepaald getal)
- help() = laat zien waarvoor de functies dienen (wat je met de variabele kunt doen)
* Geeft ingebouwde functies, modules en klassen van het ingegeven object
* Help(str.upper) -> geeft aan wat dit doet/waarvoor je het kunt gebruiken
- id() = geeft de identiteit van een object, is een unieke “code” (integer, identificaitenummer)
- input() = iemand anders moet tijdens het uitvoeren van de code hier iets invullen
- int() = maakt een heel/afgerond getal van de gegeven iterable (een string in dit geval), wanneer er
geen argument wordt gegeven geeft het 0 terug
- len() = returnt de lengte (aantal items) van een object. Het argument kan een sequentie (string,
bytes, tuple, list, range) of een collectie (dictionary, set) zijn
- list() = maakt een lijst, een mutable sequentie (kan ook leeg zijn wanneer er geen
argumenten/iterable gegeven wordt)
* my_list = list(range(5)), print(my_list)  output: [0, 1, 2, 3, 4]
- max() = geeft de hoogste waarde van twee of meer argumenten (in een iterable)
- min() = geeft de laagste waarde van een of meer argumenten (in een iterable)
- next() = geeft het volgende item van de iterator
- open() = opent het document
* file = open(“example.txt”, “r”), content = file.read(), print(content)

- print() = print de inhoud van het gegeven argument

,- pow( , ) = eerste getal tot de macht tweede getal
- range() = immutable sequentie, verschillende vormen: range(stop), range(start, stop), range(start,
stop, stepsize), de output eindigt vóór de aangegeven stop en neemt dat getal/woord niet meer mee
* my_range = list(range(1, 5)), print(my_range)  output: [1, 2, 3, 4]
- reversed() = draai het argument (sequentie) om
- round() = wanneer je geen ndigits aangeeft (of None) dan returnt het een integer die het dichtste
ligt bij de input, wanneer je wel een nummer aangeeft wordt het achter het decimale punt zo precies
mogelijk afgerond (round(number, ndigits=1)
* result = round(3.14159, 2), print(result)  output: 3.14
- set() = returnt een set {}, kan ook leeg zijn
- slice() = knip in een object, net als bij range: slice(start, stop, stepsize)
1) my_string[i] -> je krijgt het karakter van index i
2) my_string[start:end] -> de substring die starten bij start en eindigen voor eind
3) my_string[start:end:stepsize] -> alle karakters die starten bij start en eindigen voor eind
4) my_string[:i] -> de substring die beginnen bij index 0 en eindigen net voor i
5) my_string[i:] -> de substring die start bij i en tot het eind loopt
6) my_string[::i] -> de substring die van het begin tot het einde loopt met stapgrootte i
7) my_string[:] = maak een kopie van my_string
8) my_string[::-1] = kopieer my_string, maar dan achterstevoren (string keren)
- sorted() = sorteert de gegeven argumenten op alfabetische volgorde of van klein naar groot
- str() = maakt van een object een “string”
- sum() = telt het begin en de items van de iterable op van links naar rechts en returnt het totaal
(nummers)
- tuple() = immutable sequentie type (verandert iterables in tuples)
* my_tuple = tuple([1, 2, 3]), print(my_tuple)  output: (1, 2, 3)
- type() = het type object dat het gegeven argument/variabele is
* result = type(“Hello”), print(result)  output: <class “str”>
- zip() = maakt een tuple van de iterable, met de variabele en het bijpassende nummer bij elkaar
* names = [“Alice”, “Bob”, “Charlie”], ages = [25, 30, 35], result = list(zip(names, ages)),
print(result)  output: [(“Alice”, 25), (“Bob”, 30), (“Charlie”, 35)]
-> None = afwezigheid van een waarde

Boolean operatoren
- x OR y = if x is true, then x, else y (kijkt alleen naar het tweede argument als de eerste false is, want
één van de twee moet true zijn om true als uitkomst te hebben)
- x AND y = if x is false, then x, else y (kijkt alleen naar het tweede argument als de eerste true is, want
beide argumenten moeten true zijn om true als uitkomst te hebben, anders false)
- NOT x = if x is false, then True, else False
Vergelijkingen
- x < y = x is kleiner dan y
- x <= y = x is kleiner dan of gelijk aan y
- x > y = x is groter dan y
- x >= x = x is groter of gelijk aan y
- x == y = x en y zijn gelijk
- x != y = x en y zijn NIET gelijk
Bool() verandert elke waarde naar een boolean -> True/False
- Boolean operators: and (&), or (|) en not (!=) -> woorden over tekens verkozen

,Numerieke types (int, float)
Operatoren
- x + y = som van x en y
- x – y = verschil tussen x en y
- x * y = x keer y
- x / y = x gedeeld door y
- x // y = afgeronde quotiënt van x en y (afgerond naar dichtstbijzijnde hele getal)
* 10 // 3 = 3
- x % y = overblijfsel van x/y
* 10 % 3 = 1 (want 10/3 = 9, nog 1 getal is dan over tot de 10)
- -x = x negatief
- +x = x onveranderd
- abs(x) = absolute waarde van x (positief getal, afstand tot 0)
- int(x) = x verandert naar integer
- float(x) = x verandert naar float
- pow(x, y) = x tot de macht y
- x ** y = x tot de macht y
- x | y = x óf y
* 1010 | 0011 = 1011 (geeft een 1 wanneer er op die plek minimaal één 1 staat)
- x ^ y = vergelijking van de bits van x en y en produceert een nieuw getal?
- x & y = x én y
* 1010 & 0011 = 0010 (geeft een 1 wanneer er op die plek twee 1’en staan)
- x << n = x verschoven naar links met n bits
- x >> n = x verschoven naar rechts met n bits

Sequentie types (lists, tuples, range)
- x in s = True wanneer een item van s gelijk is aan x, anders False
- x not in s = False wanneer een item van s gelijk is aan x, anders True
- s + t = samenvoeging/aaneenschakeling van s en t
- s * n or n * s = het n keer optellen van s (dus n herhalingen van s)
- s[i] = het zoveelste item van s (index, begint bij 0)
- s[i:j] = slice van s, van i tot j
- s[I:j:k] = slice van s, van i tot j, met stapgrootte k
- len(s) = lengte van s (aantal karakters, inclusief spaties)
- min(s) = kleinste item van s
- max(s) = grootste item van s
- s.index(x[, i[, j]]) = index van de eerste verschijning van x in s (op of na index i en vóór index j)
- s.count(x) = het aantal keer dat x in s voorkomt
-> Wanneer i of j negatief is, is de index relatief aan het einde van de sequentie s: len(s) + i of len(s) + j
is vervangen. (-0 is nog steeds 0)

, Immutable sequentie types
- De enige bewerking die door onveranderlijke reekstypen doorgaans wordt geïmplementeerd en die
niet ook door veranderbare reekstypen wordt geïmplementeerd, is ondersteuning voor de
ingebouwde hash().
- Dankzij deze ondersteuning kunnen onveranderlijke reeksen, zoals tuple-instanties, worden gebruikt
als dicteersleutels en worden opgeslagen in set- en frozenset-instanties.

Mutable sequentie types
- s[i] = x = item i van s is vervangen door x
- s[i:j] = t = slice van s van i tot j is vervangen de content van iterable t
- del s[i:j] = slice van s i tot j is verwijderd (hetzelfde als s[i:j] = [])
- s[i:j:k] = t = de elementen van s[i:j:k] worden vervangen door deze van t
- s.append(x) = voegt x toe aan het einde van de sequentie (hetzelfde als s[len(s):len(s)] = [x])
- s.clear() = verwijdert alle items van s (hetzelfde als del s[:])
- s.copy() = maakt een kopie van s (hetzelfde als s[:])
- s.extend(t) or s += t = breidt s uit met de content van t
- s *= n = update s met de content, maar dan n keer herhaald
- s.insert(i, x) = voegt x toe bij index i (zelfde als s[i:i] = [x])
- s.pop() or s.pop(i) = haalt item i op en verwijdert het uit s
- s.remove(x) = verwijdert het eerste item uit s waar s[i] gelijk is aan x
- s.reverse() = draait de items van s om (op volgorde)

Lists []
- Mutable sequenties, geordende lijst van elementen
Een lijst maken
- Gebruik een paar vierkante haken om de lege lijst aan te duiden: []
- Gebruik vierkante haken en scheid items met komma's: [a], [a, b, c]

The benefits of buying summaries with Stuvia:

Guaranteed quality through customer reviews

Stuvia customers have reviewed more than 700,000 summaries. This how you know that you are buying the best documents.

Quick and easy check-out

You can quickly pay through credit card or Stuvia-credit for the summaries. There is no membership needed.

Focus on what matters

Your fellow students write the study notes themselves, which is why the documents are always reliable and up-to-date. This ensures you quickly get to the core!

Frequently asked questions

What do I get when I buy this document?

You get a PDF, available immediately after your purchase. The purchased document is accessible anytime, anywhere and indefinitely through your profile.

Satisfaction guarantee: how does it work?

Our satisfaction guarantee ensures that you always find a study document that suits you well. You fill out a form, and our customer service team takes care of the rest.

Who am I buying these notes from?

Stuvia is a marketplace, so you are not buying this document from us, but from seller KHnx. Stuvia facilitates payment to the seller.

Will I be stuck with a subscription?

No, you only buy these notes for $8.06. You're not tied to anything after your purchase.

Can Stuvia be trusted?

4.6 stars on Google & Trustpilot (+1000 reviews)

69411 documents were sold in the last 30 days

Founded in 2010, the go-to place to buy study notes for 15 years now

Start selling

Summary

Samenvatting Python Library en Tutorial

Document information

Subjects

Written for

Seller

Reviews received

Content preview