Típusok

TL;DR Tartalom

• Int - Egész - Jó hosszú lehet, több számrendszert is kezel
• Float - Tört - Max 64 bites és könnyedén lehet 10-es hatvánnyal szorozni
• Complex - Komplex szám
• String - Szöveg - Pár hasznos függvény, escapelés, speciális karakterek, """
• Boolean - Logikai - Típus, truthiness
• Pár művelet a típusainkkal - Matek, extra operátorok, _ jel, sztring műveletek, indexelés, sliceolás
• List - Lista - Létrehozás, tömb műveletek, pár függvény

Extra feladatok

Ezek nem kötelező feladatok, csak megoldásuk közben könyebb megtanulni a dolgokat

• 192.168.1.101 oktetjeit konvertáld át binárisba és írd ki
• 255.255.255.240 oktetjeit konvertáld át binárisba és írd ki
• Írd ki a hálózat címét az előző kettő alapján 10-es számrendszerben.
  (Spoiler: Össze éseled a bináris formát, majd vissza konvertálsz)
• Hogyan írnád le a 3.14*10^87 -ent Pythonban?
• Eiffel 65 - Blue című slágerét hallgatva észre vetted, hogy van egy pár ismétlődő rész.
  Mint jó programozó féltve az elpazarolt biteket, szeretnéd ezt kódból lerövidíteni. Tedd ezt meg a lehető legegyszerűbben
  (Spoiler: Sztring műveleteknél találsz hasonlót)
• Készíts egy listát a kedvenc 7 számoddal.
  (nem zene szám, hanem numerikus szám)
  Ezt követően ezekből vedd ki három legkedvencebb számod. Végül pedig oszd el az első és az utolsó számot úgy, hogy csak az egész része maradjon meg.
  (Spoiler: Pár művelet fejezetnél találsz majd egy operátort)

Int - Egész

Szám értéket jelöl és mérete bármekkora lehet. (Amíg van ram)

>>> print(123123123123123123123123123123123123123123123123123123123123123123 + 1)
123123123123123123123123123123123123123123123123123123123123123124

Bármilyen számjegyből álló sorozatot egészként fog értelmezni a Python egészen addig, míg nincs benne egy tizedes pont.

Több számrendszerben is tudunk dolgozni.

Szintaxis	Számrendszer	Konstruktor
0b vagy 0B	Bináris	bin
0o vagy 0O	Oktális	oct
0x vagy 0X	Hexadecimális	hex

>>> 0x10 + 0x02
18 # 16  +  2

Ezeknek mind Int a típusa

>>> type(10)
<class 'int'>
>>> type(0o10)
<class 'int'>
>>> type(0x10)
<class 'int'>

A megfelelő konstruktort használva, akár át is tudjuk őket konvertálni.

>>> hexa = hex(79) # 10-es számrendszerből hexába
>>> hexa
'0x4f'
>>> int(hexa, 16) # Vissza hexából 10-esbe
79

Float - Tört

Bármilyen számsorozat amiben van egy decimális pont.

64 bites precízióra vagyunk képesek, tehát a max értéke kb 1.8 * 10^308-on lehet.
E fölött inf-nek értelmezi a Python.

>> 1.79e308
1.79e+308
>> 1.8e308
inf

Magyarázat

Itt az e egy 10-es hatványt jelent és ilyenkor mindig Float-ot kapunk vissza.
Pl.: 3e4 = 30000.0

>>> 4e7
40000000.0
>>> .4e7
4000000.0

Complex - Komplex szám

Komplex szám ugyanúgy egy típus, mint az egész vagy a tört, továbbá egyes kódolást megkönnyítő funkciókkal is rendelkezik.

>>> 2+3j # létrehozása: szám + szám * j
(2+3j)
>>> complex(2, -3) # Vagy konstruktort használva
(2-3j)
>>> complex("2-3j") # Akár szövegesen is jó
(2-3j)
>>> type(2+3j)
<class 'complex'>
>>> (2+3j).conjugate()
(2-3j)
>>> (2+3j).real
2.0
>>> (2+3j).imag
3.0
>>> pow(3 + 4j, 2) # Második hatványát vesszük
(-7+24j)

String - Szöveg

Jelölése str és hossza bármekkora lehet. (Megint a RAM a határ)

"-k vagy '-k közti karaktersorozatot értünk str-nek

>>> "Egy szöveg vagyok"
'Egy szöveg vagyok'
>>> 'Én is'
'Én is'

Akár egy beépített print funkciót is használhatunk, mely a különböző speciális karaktereket is kifogja írni.

>>> print("Egy kis szöveg")
Egy kis szöveg

Ha szeretnénk benne "-t, akkor escapelnünk kell, mely igazából a speciális karakterek nem feldolgozását jelenti. Ezt a \ jel használatával tehetjük meg.

>>> print("Itt egy macskaköröm (") karakter.")
  File "<stdin>", line 1
    print("Itt egy macskaköröm (") karakter.")
                                   ^
SyntaxError: invalid syntax
>>> print("Itt egy macskaköröm (\") karakter.")
Itt egy macskaköröm (") karakter.

Error

Részletesebben a Hibák és azok kezelése című fejezetben lesz szó a hibák működéséről. Addig is látható, hogy a Python hogyan írja ki ezeket.

Említettem, hogy a Python sorról sorra értelmezi a kódunk.
Mégis akkor hogyan írunk egy több soros szöveget?
→ Escapelünk

>>> print("a
  File "<stdin>", line 1
    print("a
           ^
SyntaxError: EOL while scanning string literal

>>> print("a\
... b\
... c")
abc

Sőt, akár az escapelést is escapelhetjük.

veszély

Escapeception

>>> print('foo\\bar')
foo\bar

A sztringünkben egyes speciális karakterek is lehetnek.
Ilyen például az új sor (\n) és a tabulátor (\t).

>>> print("a\tb")
a    b
>>> print("a\141\x61")
aaa
>>> print("a\nb")
a
b
>>> print('\u2192 \N{rightwards arrow}')
→ →

Akár "raw" sztringünk is lehet. Ebben nem kerülnek értelmezésre a speciális karakterek.

>>> print('C:\user\name')  # \n új sort jelent
C:\user
ame
>>> print(r'C:\user\name')  # vedd észre az r-t a szöveg előtt
C:\user\name

Tripla idézőjeles stringben lehet ugyanaz a karakter, továbbá a sortörést is megőrzi.

>>> print('''Itt már minden is van, pl " és ' is.''')
Itt már minden is van, pl " és ' is.

Sőt ilyenkor az új sorok is belekerülnek.

>>> """Ez a
... szöveg több
... soros."""
'Ez a\nszöveg több\nsoros.'
>>> print("""Ez a
... szöveg több
... soros.""")
Ez a
szöveg több
soros.

Boolean - Logikai

True vagy False értéke lehet.

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

A különböző típusainkat képesek vagyunk logikaira konvertálni. Ilyenkor szoktunk beszélni a Truthiness / Falsinessről. Például hamis az üres sztring, a 0.

>>> bool(0)
False
>>> bool("")
False
>>> bool("0")
True
>>> bool(2+3j)
True
>>> bool([]) # Üres lista (2 alfejezettel lejebb)
False

Pár művelet a típusainkkal

Question of the Day

A Python használható számológépként?

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # Osztás mindig Float-tal tér vissza
1.6

Az alap matematikai műveletek mellett pár extra funkcionalitást is nyújt.

>>> 17 // 3  # Kerekítve osztás
5
>>> 17 // 4
4
>>> 5 ** 3  # Hatványozás
125
>>> 2 ** 7
128
>>> 1235 % 3 # Maradékos osztás
2

_

Ezek mellett egy másik érdekes beépített dolog az interpreterbe, hogy vissza tudjuk kérni az utoljára kapott értéket az _ karakter használatával.

>>> afa = 27 / 100 # Így hozunk létre változót
>>> ar = 1314
>>> afa * ar
354.78000000000003
>>> ar + _
1668.78
>>> round(_, 1) # Első tizedesre kerekítünk
1668.8

Egyébként lehet egy változó névben UTF-8 karakter is. Tehát az Áfa = 27 / 100 is egy valid kód. Viszont nem ajánlott, ugyanis lehet, hogy más is olvassa majd a kódod, sőt az is lehet, hogy nem is ismeri a magyar nyelvet.

Sztringeket akár össze tudunk adni +-al vagy megismételni *-al.

>>> "ski" + 2 * "-ba-bop" + "-ba-dop-bop"
'ski-ba-bop-ba-bop-ba-dop-bop' # ?v=Hy8kmNEo1i8

Ha csak szövegeink vannak, akkor el is hagyhatjuk a +-t és automatikusan összevonásra kerülnek.

>>> 'Egy' 'be'
'Egybe'

Ez akkor hasznos például, ha egy hosszú szöveget szeretnénk több sorban megadni.

>>> text = ('Írj pár dolgot így, '
...          'hogy összevonásra kerüljenek')
>>> text
'Írj pár dolgot így, hogy összevonásra kerüljenek'

Viszont ugyanez a változókkal nem fog működni.

>>> gyumolcs1 = "alma"
>>> gyumolcs2 = "korte"
>>> gyumolcs1 gyumolcs2
  File "<stdin>", line 1
    gyumolcs1 gyumolcs2
              ^
SyntaxError: invalid syntax

Sztringjeink egyes karaktereit akár indexelni is tudjuk:

>>> word = 'Python'
>>> word[0]  # Karakter a 0. pozícióban
'P'
>>> word[5]  # Karakter az 5. pozícióban
'n'

Akár visszafele is tudunk indexelni

>>> word[-1]  # Hátulról az első karakter
'n'
>>> word[-2]  # Hátulról a második karakter
'o'
>>> word[-6]
'P'

Mutatók

Indexeléskor az egyes karakterek memória címére mutatunk rá.
Az ez alatti ábra ezt jól mutatja

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Indexelés mellett sliceolni is tudunk (szeletet kivenni).

>>> word[0:2]  # Karakterek 0-tól (benne van) 2-ig (nincs benne)
'Py'
>>> word[2:5]  # Karakterek 2-tól (benne van) 5-ig (nincs benne)
'tho'

Látható, hogy az eleje még benne van az indexnek, viszont az utolsó nem.

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

List - Lista

Különböző típusainkat akár listába is tudjuk tenni.
Ehhez csak [ ] közé kell tenni őket.

>>> negyzetszamok = [1, 4, 9, 16, 25]
>>> negyzetszamok
[1, 4, 9, 16, 25]

Ezt is tudjuk indexelni, továbbá sliceolni, mint a sztringet.
Hasonló logikát követ, mint a sztringnél.

>>> negyzetszamok[0]  # Visszatér az adott elemmel
1
>>> negyzetszamok[-1]
25
>>> negyzetszamok[-3:]  # Slice visszatér egy új listával
[9, 16, 25]

Sztringgel ellentétben a megindexelt elemeink módosíthatóak.

>>> negyzetek = [1, 8, 27, 65, 125] # Az a 65 ott hibás!
>>> negyzetek[3] = 64  # Javítás
>>> negyzetek
[1, 8, 27, 64, 125]

Akár egy elemet ki is tudunk venni!

>>> negyzetek = [1, 8, 27, 65, 125]
>>> negyzetek = negyzetek[:3] + negyzetek[4:]
>>> negyzetek
[1, 8, 27, 125]

Akár a méretét is lekérhetjük a len() funkcióval.

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Ugyanez a függvény (len) sztringekkel is működik. próbáld ki!

Akár a tömbünkbe tömböt is bele tehetünk. próbáld ki!