Python programozás

(3.x verzió)


Forrás (edureka.co)

Python programozási nyelv

A Python egy általános célú, nagyon magas szintű programozási nyelv, melyet Guido van Rossum holland programozó kezdett el fejleszteni 1989 végén, majd hozott nyilvánosságra 1991-ben.

A nyelv tervezési filozófiája az olvashatóságot és a programozói munka megkönnyítését helyezi előtérbe a futási sebességgel szemben.

A Python többek között a funkcionális, az objektumorientált, az imperatív és a procedurális programozási mintákat támogatja. Dinamikus típusokat és automatikus memóriakezelést használ, ilyen szempontból hasonlít a Scheme,

Perl és Ruby nyelvekhez, emellett szigorú típusrendszerrel rendelkezik.

A Python úgynevezett interpreteres nyelv, ami azt jelenti, hogy nincs különválasztva a forrás- és tárgykód, a megírt program máris futtatható, ha rendelkezünk a Python értelmezővel. A Python értelmezőt számos géptípusra és operációs rendszerre elkészítették, továbbá számtalan kiegészítő könyvtár készült hozzá, így rendkívül széles körben használhatóvá vált.

A nyelv a "Monthy Python-ék Repülő Cirkusza" nevű BBC-s sóműsor után kapta a nevét és semmi köze nincs a nyálas hüllőhöz...

Rövid története

Bemelegítő feladatok

E. Elágazások (if)

Írjuk ki a következő szöveget: 'Ha kisebb a fizetésed 200 eFt-nál, megemelem 25%-kal.'

Kérjük be a fizut, és ha kell, növeljük meg! 200000 Ft-os vagy ennél nagyobb fizetésnél ne emeljünk!

A fizetés valós típus (float) legyen, ne egész (int)!

Minden kiírás után álljon egy üres sor! (print())


Írjuk ki: "Kérek egy természetes számot: " !

Kérjünk be egyet (0, 1, 2, ...), majd írjuk ki, hogy "a szám páros" vagy "a szám páratlan"!

A bekért szám egész típus (int) legyen!

Minden kiírás után álljon egy üres sor! (print())


Írjuk ki az alábbi szöveget:

Dolgozatok szöveges értékelése
0% ... 30% - nem felelt meg
30% ... 75% - megfelelt
75% ... 100% - jól megfelelt

Írjuk ki: "Elért pont %-ban ? ", és kérjük is be az egész pontszámot (0 ... 100)!

Végezzük el a szöveges értékelést!

A "megfelelt" értékelésnél a határokat nem vesszük (a másik kettőnél igen)!

Minden kiírás után álljon egy üres sor! (print())

Help (csak tedd ide az egérkurzort)


Írjuk ki: "Kérem a korodat: " !

Kérje be ezt egész számként, majd a következő táblázat alapján írja ki a vastagított szövegek egyikét!

  •   0 < kor ≤   3 kisgyermek
  •   3 < kor ≤   6 óvodás
  •   6 < kor ≤ 14 általános iskolás
  • 14 < kor ≤ 18 középiskolás
  • 18 < kor          felnőtt

Kérbe egy tetszőleges egész számot, és vizsgáld meg 2-vel és 3-mal való oszthatóságát!

Írd ki az alábbi szöveget valamelyikét:

  • Osztható 2-vel és 3-mal is.
  • Osztható 2-vel, de 3-mal nem.
  • Osztható 3-mal, de 2-vel nem.
  • Sem 2-vel, sem 3-mal nem osztható.

Ne használj logikai műveleteket (and, or)!

Help (csak tedd ide az egérkurzort)


F. Ciklusok - számlálós (for)

Írjuk ki egymás alá 10-szer a "Szia" szöveget!
Írjuk ki egymás után 10-szer a "Szia" szöveget vesszővel elválasztva!

Help (csak tedd ide az egérkurzort)

Írd ki egymás után a 7-el osztható kétjegyű számokat!
Írd ki az előbbieket fordítva!
Írd ki a következő számsort: 10.0, 10.1, 10.2, ..., 11.9, 12.0,

Help (csak tedd ide az egérkurzort)


Írd ki az egyjegyű számokat és négyzeteiket kilenc sorba a következőképpen: 4^2 = 16

Help (csak tedd ide az egérkurzort)

Írd ki a "VAKÁCIÓ" szó betűit a következőképpen: "V, A, K, Á, C, I, Ó, "

Help (csak tedd ide az egérkurzort)

Módosítsd a kiírást úgy, hogy vessző ne legyen, csak három space!

Help (csak tedd ide az egérkurzort)

Írjuk ki a "VAKÁCIÓ" szó betűit fordítva, szorosan: "ÓICÁKAV" ! (Természetesen ciklusssal.)

Help (csak tedd ide az egérkurzort)


Kérjünk be egy ezévi (2017) fizetést, majd írjuk ki az évet és a minden évben 10%-kal megnöveltet is egészen 2020-ig! A fizetést valós számként kezeljük, legfeljebb a kiíráskor alakítsuk egésszé (lásd Help)!

Pl. ha fizu = 100000
2017-ben a fizetésed: 100000
...
2020-ben a fizetésed: 133100

Help (csak tedd ide az egérkurzort)


Dobjunk egy "számítógépes dobókockával" 20-szor! Írjuk ki a dobásokat, majd számítsuk ki és írjuk ki ezek átlagát is!

Ha véletlenszámokat szeretnénk generálni, először használjuk az "import" modult: import random !

A random.randint(1,90) utasítás például egy lottószámot ad 1 és 90 közt (ötöslottó), a random.randint(1,6) pedig kockadobást szimulál.


Írjuk ki ciklusokkal a következő karaktersorokat:

AbbbAbbbAbbbAbbb
Abbb Abbb Abbb Abbb

"Rajzoljuk" ki a következő táblát!

****
****
****

A print(...) utasításokban csak egy karakter szerepelhet, ilyen nem: print("bbb", ...), és ilyen sem: print("****", ...)!


Írd ki kettős ciklussal az egyjegyű szorzótáblát a következő formában:

 | a x b |   1   2   3   4   5   6   7   8   9
 +-------+-------------------------------------
 |   1   |   1   2   3   4   5   6   7   8   9
 |   2   |   2   4   6   8  10  12  14  16  18
 |   3   |   3   6   9  12  15  18  21  24  27
                    .....
 |   9   |   9  18  27  36  45  54  63  72  81

Help (csak tedd ide az egérkurzort)


Írj egy programot, ami 1-től 100-ig kiírja a számokat, a következő szabálynak megfelelően:

  • ha a szám osztható 3-mal, akkor a szám helyett az legyen kiírva, hogy fizz
  • ha a szám osztható 5-tel, akkor a szám helyett az legyen kiírva, hogy buzz
  • ha a szám 3-mal és 5-tel is osztható, akkor a szám helyett az legyen kiírva, hogy fizzbuzz
  • alapesetben csak maga a szám legyen kiírva

Például az első 20 számra: 1 / 2 / fizz / 4 / buzz / fizz / 7 / 8 / fizz / buzz / 11 / fizz / 13 / 14 / fizzbuzz / 16 / 17 / fizz / 19 / buzz ... (a / jel helyett új sor kezdődne)


W. Ciklusok - elöltesztelő (while)

Írjuk ki a következő szöveget: 'Ha kisebb a fizetésed 200 eFt-nál, megemelem 25%-kal.'

Kérjük be a fizut, és ha kell, növeljük meg! 200000 Ft-os vagy ennél nagyobb fizetésnél ne emeljünk!

A fizetés valós típus (float) legyen, ne egész (int)!

Minden kiírás után álljon egy üres sor! (print())


Gyakorló feladatok

E. Egyenletek megoldása

Oldd meg az "ax + b = 0" alakú elsőfokú egyenletet!

Először írasd ki, hogy mit csinál a program!

Kérd be az "a" és "b" számokat, ezek valósak (float) legyenek!

Ügyelj arra, hogy "a" nulla (0) is lehet!


Oldd meg az "ax2 + bx + c = 0" alakú másodfokú egyenletet!

Először írasd ki, hogy mit csinál a program!

Kérd be az "a", "b" és "c" számokat, ezek valósak (float) legyenek!

Ügyelj arra, hogy "a" nulla (0) nem lehet, mert ekkor nem másodfokú!

Help (csak tedd ide az egérkurzort)

Algoritmus   


Oldd meg az "x3 - 6x2 - 31x + 120 = 0" harmadfokú egyenletet a [-10;+10] intervallumon, ha tudjuk, hogy gyökei egész számok!

Először írasd ki, hogy mit csinál a program!

Végül írd ki a harmadfokú egyenlet három egész megoldását a következőképpen:
1. megoldás: ...
2. megoldás: ...
3. megoldás: ...


Oldd meg az "x4 + x3 - 30x2 - 32x + 150 = 0" negyedfokú egyenletet a [-6;+6] intervallumon!

Először írasd ki, hogy mit csinál a program!

Századonként lépkedj végig a [-6,+6] szakaszon, és azt az értéket tekintjük gyökhelynek, ahol a baloldal abszolút értéke kisebb 0,3-nál!

Végül írd ki a negyedfokú egyenlet négy megoldását a következőképpen:
1. megoldás: ...
.....


Oldd meg közelítően a következő egyenletet gyök(x+4) - 3 = -(x-2)^2 + 5

Javaslat:
- először készíts egy rajzot a két oldalon lévő függvényről, hogy behatárold a szükséges tartományt (grafikus megoldás!)
- lépkedj ezen balról jobbra századonként
- ott lesz gyök, ahol a baloldal-jobboldal különbség előjelet vált (az előzőleg számolthoz viszonyítunk)

Algoritmus   


O. Osztók, tökéletes és barátságos számok

Kérjünk be egy "n" pozitív egész számot, majd írjuk ki az osztóit, ezek darabszámát és összegét!

Ellenőrizzük, hogy a bekért szám pozitív egész legyen!


Kérjünk be egy "n" pozitív páratlan számot, majd írjuk ki az osztóit, ezek darabszámát és összegét!

Ellenőrizzük, hogy a bekért szám pozitív egész illetve páratlan legyen!


Kérjünk be két pozitív egész számot, és írjuk ki ezek LNKO-ját és LKKT-ét!

Ellenőrizzük, hogy a bekért számok pozitív egészek legyenek!


Kérjünk be egy "n" pozitív egész számot, majd írjuk ki, hogy ez tökéletes szám vagy nem!

Egy szám tökéletes szám, ha nála kisebb osztóinak összege egyenlő a számmal.
Pl. 1+2+3 = 6, 1+2+4+7+14 = 28

Ellenőrizzük, hogy a bekért szám pozitív egész legyen!


Kérjünk be egy "fh" pozitív egész számot (felső határ), majd írjuk ki eddig a barátságos számpárokat!

Két szám barátságos, ha az egyik nála kisebb osztóinak összege egyenlő a másik számmal, és fordítva is.
Pl.
220 => 1+2+4+5+10+11+20+22+44+55+110 = 284
284 => 1+2+4+71+142 = 220

Ellenőrizzük, hogy a bekért szám pozitív egész legyen!


P. Prímszámok

Kérjünk be egy "n" pozitív egész számot, majd írjuk ki hogy prím vagy nem!

Ellenőrizzük, hogy a bekért szám pozitív egész legyen!


Kérjük be az "fh" felső határt, majd írjuk ki eddig prímeket (beleértve a felső határt is)!

Ellenőrizzük, hogy a bekért szám pozitív egész legyen!

A számok prím voltát függvény (pl. primE) vizsgálja!


Kérjük be az "ah" és az "fh" határokat, majd írjuk ki a köztük lévő prímeket (beleértve a határokat is)!

Ellenőrizzük, hogy a két határ pozitív egész legyen, valamint a felső határ ne legyen kisebb az alsónál!

A számok prím voltát függvény (pl. primE) vizsgálja!


Kérjünk be egy pozitív egész számot, és írjuk ki a prímosztóit!

Ellenőrizzük, hogy a bekért szám pozitív egész!

A számok prím voltát függvény (pl. primE) vizsgálja!


Kérjünk be egy "n" pozitív egész számot, majd írjuk ki a prímeket "n"-ig!

Ellenőrizzük, hogy a bekért szám pozitív egész!

A számok prím voltát függvény (pl. primE) vizsgálja!

Algoritmus   


J. Játékprogramok

A számítógép kitalál egy véletlenszámot (szam) 1 és 100 közt. A feladatod ezt eltalálni (tipp):

  • ha nagyobb számot írsz be a gép számánál (szam<tipp), a számítógép kiírja, hogy "Nagy",
  • ha kisebbet (tipp<szam), "Kicsi",
  • ha eltaláltad (tipp=szam), akkor megdícsér (vagy nem?!).

Az értékelés ilyesmi legyen (tdb a tippek darabszáma):

  • ha tdb < 4, írja ki: "Mázlista vagy!!!"
  • ha 4 ≤ tdrb < 6, írja ki: "Ügyes (a legkisebb tapsifüles)!"
  • ha 6 ≤ tdrb < 8, írja ki: "Ez még elmegy!"
  • ha 8 ≤ tdrb < 10, írja ki: "Hát, ez gyenge volt!"
  • egyébként ezt írja ki: "Gyakorolj, nagyon gyatra voltál!!!"

Összekeverjük az 1, 2, 3, ...., 9 számsort. A feladat az, hogy ezt rendezni kell, azaz visszaállítani az előző sorrendbe.

A következőképpen tehetjük meg ezt:

  • bekér a program egy 2 és 9 közti egész számot
  • balról ilyen hosszan "alányúlunk" a számoknak (mint palacsintasütéskor késsel a fordítandó palacsinta alá)
  • ezek a számok sorrendileg megfordulnak (az utánuk állók eredeti sorrendben maradnak)
  • pl. ha a számsor éppen 3 2 5 1 8 6 9 4 5 7, és balról négyet fordítunk, akkor ezután 1 5 2 3 8 6 9 4 5 7 lesz belőle.
  • s ezt addig ismételjük, míg a számsor rendezett nem lesz

xxx – x


Játékszabály: az első rúdról / helyről az utolsóra kell átrakni a korongokat úgy, hogy minden lépésben egy korongot lehet áttenni, nagyobb korong nem tehető kisebb korongra, és ehhez összesen három rúd / hely áll rendelkezésre.


sdsdf

dsf

sdf


Mintafeladatok

Rövid összefoglalás


Standard adattípusok

  • logikai értékek (True, False)
  • számok (egészek, lebegőpontosak, törtek, komplex számok)
  • sztringek (karakterek sorozatai)
  • listák (értékek rendezett sorozatai)
  • tuple-ök (értékek rendezett, nem módosítható sorozatai)
  • halmazok (set - értékek rendezetlen kupacai)
  • szótárak (dictionary - kulcs-érték párok rendezetlen kupacai)



A logikai értékek igazak vagy hamisak lehetnek. A Python két konstanssal rendelkezik, amelyek közvetlenül logikai értékekhez rendelhetők, ezek a True és False. A kifejezések is logikai értékekké értékelődnek ki. Bizonyos helyeken (mint az if utasítások), a Python a kifejezés logikai értékre való kiértékelődését várja. Ezeket a helyeket logikai kontextusoknak nevezzük. Gyakorlatilag bármely kifejezést használhatod logikai kontextusban, és a Python megpróbálja meghatározni annak igazságértékét.


Összehasonlítások

     Művelet, függvény      Művelet rövid leírása
<, <=, >, >= kisebb mint, kisebb vagy egyenlő, nagyobb mint, nagyobb vagy egyenlő
==, != egyenlő (azonos), nem egyenlő (nem azonos) / értékadásnál csak egy = jel van /
in, not in benne van (tartalmazza), nincs benne (nem tartalmazza)

Logikai műveletek

     Művelet, függvény      Művelet rövid leírása, eredménye
x and y x és y, akkor igaz (True), ha x és y mindegyike igaz, egyébként hamis
x or y x vagy y, akkor hamis (False), ha x és y mindegyike hamis, egyébként igaz
not x nem x, akkor igaz (True), ha x hamis, egyébként hamis



Műveletek számokkal

     Művelet, függvény      Művelet rövid leírása
x + y, x - y, x * y, x / y x és y összege, különbsége, szorzata, hányadosa
x ** y, pow(x, y) x felemelve y hatványra
x // y x és y egész hányadosa (pl. 17 // 5 = 3)
x % y x és y egészosztásának maradéka (pl. 17 % 5 = 2)
-x, +x x ellentettje (-1*x), x változatlan (1*x)
abs(x) x abszolút értéke
int(x), float(x) x-et egész számmá, lebegőpontossá alakítja
complex(re, im) komplex szám (re - valós rész, im - imaginárius rész)
c.conjugate() a c komplex szám konjugálja
divmod(x, y) a következő párt adja: (x // y, x % y)

Egész számok formázott kiírása

a, b, c, d = 2, 12, -23, 3456 # többszörös értékadás: a=2, b=12, c=-23, d=3456 ugyanez lenne a "_" jel természetesen nem lesz kiírva
print('{:5d}'.format(b)) " kiírás 5 pozícióra ___12
print('{:5d}'.format(c)) __-23
print('{:+5d}'.format(c)) # kiírja mindkét előjelet __-23
print('{:+5d}'.format(d)) +3456
print('{:5d}{:5d}{:5d}{:5d}'.format(a,b,c,d)) # változók egyszerre formázása ____2___12__-23_3456
print('{:3d}{:4d}{:5d}{:+6d}'.format(a,b,c,d)) # változók más-más formázása __2__12__-23_+3456
print('{1:3d}{0:4d}{3:5d}{2:+6d}'.format(a,b,c,d)) # változók sorrendcseréje is (0↔1 2↔3) _12___2+3456___-23

Lebegőpontos számok formázott kiírása

x, pi = -456.456, 3.141592653589793 a "_" jel természetesen nem lesz kiírva
print('{:.4f}'.format(pi)) " kerekítés 4 tizedes jegyre 3.1416
print('{:8.4f}'.format(pi)) " kiírás 8 pozícióra és kerekítés 4 tizedes jegyre __3.1416
print('{0:8.1f}{1:8.1f}'.format(x,pi)) " kiírások 8 pozícióra és kerekítés 1 tizedes jegyre __-456.5_____3.1
print('{1:8.1f}{0:8.1f}'.format(x,pi)) " mint az előbbi, csak "pi" áll elöl és "x" hátul (0↔1) _____3.1__-456.5

Matematikai függvények (math modul)
Formátum specifikáció "Mini-Nyelv"


A Python 3-ban minden karakterlánc UTF-8 kódolású Unicode karakterek sorozata.

Az UTF-8 egy változó hosszúságú kódolási rendszer a Unicode-hoz. Ez azt jelenti, hogy különböző karakterek különböző számú bájtot foglalnak. Az ASCII karakterekhez (A-Z stb.) az UTF-8 karakterenként csak egy bájtot használ. Tulajdonképpen pontosan ugyanazokat a bájtokat használja. Az UTF-8 első 128 karaktere (0–127) megkülönböztethetetlen az ASCII-étól. A „kiterjesztett latin” karakterek, mint a ñ és ö két bájtot foglalnak. A kínai karakterek, mint a 中 három bájtot foglalnak. A ritkán használt „asztrálsík” karakterek négy bájtot.



Értékadás, string-szeletelés

Művelet Eredmény, megjegyzés
a = "Batman", a = 'Batman' a felveszi a Batman értéket
a[0], a[5], a[1:4], a[4:6],     a[3:], a[:3], a[::2] 'B', 'n', 'atm' / a 4. nincs! /, 'an',     'man', 'Bat', 'Bta' / minden 2.! /
a[-3], a[-6],     a[-3:], a[:-3],     a[::-1] 'm', 'B',     'man', 'Bat',     'namtaB' / fordítva! /
b, c, d = a + "72", a*3, "" a b 'Batman72' lesz, a c 'BatmanBatmanBatman', a d pedig '' / többszörös értékadás! /
len(a), len(b), len(c), len(d) a stringek hossza: 6, 8, 18, 0 / a d üres string /
ord("C"), chr(67) "C" kódja 67, 67 kódú karakter "C"

String trükkök

s = '''Ez egy
többsoros string lesz. Itt el-
választottam.'''


Néhány gyakori sztring metódus

s.lower(), s.upper() a sztring kisbetűs, nagybetűs verziójával tér vissza
s.lstrip(), s.rstrip(), s.strip() a whitespace karaktereket levágja a sztring elejéről, végéről, mindkét feléről
s.isalpha(), s.isdigit(), s.isspace()... megnézi, hogy a sztring vmennyi karaktere az adott karakterosztályba tartozik-e
s.startswith('other'), s.endswith('other') megnézi, hogy a sztring a másik sztringgel kezdődik-e ill. végződik-e
s.find('other') a sztringben szerepel-e a másik sztring (nem reguláris kifejezésként adjuk meg)
ha igen, akkor az első előfordulás első karakterének indexével tér vissza
ha nem, akkor -1 a visszatérési érték
s.replace('old', 'new') a sztringben az 'old' vmennyi előfordulását 'new'-ra cseréli
s.count('E') megszámolja a sztringben a "E" betűk számát
s.split('delim') a sztringet az adott szeparátor mentén részsztringek listájára bontja a szeparátor nem reguláris kifejezés. Példa: 'aaa,bbb,ccc'.split(',') – ['aaa', 'bbb', 'ccc']
ha csak s.split()-et írunk, akkor a whitespace karakterek mentén bontja fel a sztringet
s.join(list) a split() ellentéte, egy lista elemeit kapcsolja össze egy adott szeparátorral (ez lesz az s sztring)
példa: '---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc

Formátum specifikáció "Mini-Nyelv"

"""

Az alábbi metódusok alkalmazhatók String objektumokra. További, a reguláris kifejezésekhez kapcsolódó string műveletekről találhat leírást a Reguláris kifejezések részben.


str.capitalize()

Visszatér str másolatával úgy, hogy az első karaktert nagybetűssé alakítja

str.center(width[, fillchar])

Visszatér str középre igazított, width hosszúságú másolatával. A kitöltő karaktert az opcionális fillchar határozza meg (alapértelmezettként szóköz).

str.count(sub[start[, end]])

Visszatér sub előfordulásainak számával str-ben, a start-tól az end pozícióig.

str.decode([encoding[, errors]])

A megadott encoding objektum által kódolja a string-et

str.endswith(suffix[, start[, end]])

Igazzal tér vissza, ha str suffix stringre végződik. A suffix lehet egy stringehet tartalmazó tuple is, ebben az esteben igazat ad a metódus, ha valamelyik eleme szuffixe az str stringnek. A tesztelés az opcionális start paraméternél kezdődik és az opcionális end paramétrenél ér véget.

str.expandtabs([tabsize])

Visszatér str egy olyan másolatával, ahol minden tab karakter egy vagy több szóköz karakterre van lecserélve. A szóközök számát az opcionális tabsize paraméter határozza meg (alapértelmezettként 8)

str.find(sub[, start[, end]])

Visszaadja azt a legkisebb indexet, ahonnan kezdve sub előfordul az str stringben. -1-gyel tér vissza, ha sub nem található str-ben.

str.format(*args, **kwargs)

str-en végrehajt egy string formázási műveletet és visszaadja a formázott szöveget. A formázandó szöveg literálokból állhat, illetve {}-vel határolt kicserélendő mezőkből. Minden egyes kicserélendő mező vagy egy pozicionális argumentum indexét, vagy egy kulcsszavas argumentum nevét tartalmazza.


>>> "The sum of 1 + 2 is {0}".format(1+2)


'The sum of 1 + 2 is 3'


A string formázásról bővebben a String formázás résznél olvashat.

str.index(sub[, start[, end]])

Ugyanaz, mint a find(), de ValueError kivételt dob ha a string nem volt megtalálható.

str.isalnum()

Igazzal tér vissza, ha a stringben minden karakter alfanumerikus, és legalább egy karakter hosszú.

str.isalpha()

Igazzal tér vissza, ha a stringben minden karakter alfabetikus, és legalább egy hosszú.

str.isspace()

Igazzal tér vissza, ha a strig csak whitespace karaktereket tartalmaz és legalább egyet.

str.istitle()

Igazzal tér vissza, ha a string címszerű, azaz minden szava nagybetűvel kezdődik, és legalább egy karaktert tartalmaz.

str.isupper()

Igazzal tér vissza, ha a string minden karaktere nagybetűs és legalább egy hosszú.

str.join(iterable)

Visszatér egy olyan stringgel, amely az iterable objektumból való stringek konkatenációja. A stringek közötti elválasztó az str string.


>>> ", ".join(["alma", "korte", "dio"])


"alma, korte, dio"


str.ljust(width[, fillchar])

Visszatér azzal a width hosszú stringgel, amelyben str balra van igazítva. Az opcionális fillchar paraméter határozza meg a kitöltő karaktert.

str.lower()

Visszatér azzal a stringgel, amelyben str minden karaktere kisbetűs.

str.lstrip([chars])

Visszatér str azon másolatával, ahol a string eleji karakterek el vannak távolítva. A chars paraméter egy string, amely az eltávolítandó karaktereket tartalmazza. Ha hiányzik, akkor a metódus csak a whitespace karaktereket távolítja el.

str.partition(sep)

Patricionálja str stringet az első sep elválasztónál, és visszaad egy 3 elemű tuple-t, ahol az első elem a sep előtti, a második maga a sep, a harmadik pedig a sep utáni rész. Ha sep nem része str-nek, akkor a 3 elemű tuple első eleme maga a teljes str lesz, a további két elem pedig üres string.

str.replace(old, new[, count])

Visszatér str azon másolatával, ahol old összes előfordulása le van cserélve new-re. Az opcionális count paraméter azt határozza meg, hogy legfeljebb hány előfordulás legyen lecserélve.

str.rfind(sub[, start[, end]])

Visszaadja azt a legnagyobb indexet, amelytől kezdődően sub megtalálható az str stringben. Az opcionális start és end paraméterek segítségével str adott szeletében kereshetünk.

str.rindex(sub[, start[, end]])

Ugyanaz, mint a rfind(), de ValueError kivételt dob, ha a string nem volt megtalálható.

str.rjust(width[, fillchar])

Visszaadja az adott stringet jobbra igaítva egy width hosszúságú stringben. Az opcionális fillchar paraméter határozza meg a kitöltő karaktert (alapértelmezett: szóköz).

str.rpartition(sep)

Patricionálja str stringet az utolsó sep elválasztónál, és visszaad egy 3 elemű tuple-t, ahol az első elem a sep előtti, a második maga a sep, a harmadik pedig a sep utáni rész. Ha sep nem része str-nek, akkor a 3 elemű tuple első eleme maga a teljes str lesz, a további két elem pedig üres string.

str.rsplit([sep[, maxsplit]])

Visszatér az adott string szavait tartalmazó listával, ahol sep a szavakat elválasztó jel(sorozat). Ha a maxsplit paraméter meg van adva, akkor a metódus jobbról kezdve legfeljebb maxsplit szeletelést végez.

str.rstrip([chars])

Visszatér str azon másolatával, ahol a string végi karakterek el vannak távolítva. A chars paraméter egy string, amely az eltávolítandó karaktereket tartalmazza. Ha hiányzik, akkor a metódus csak a whitespace karaktereket távolítja el.

str.split([sep[, maxsplit]])

Visszatér az adott string szavait tartalmazó listával, ahol sep a szavakat elválasztó jel(sorozat). Ha a maxsplit paraméter meg van adva, akkor a metódus balról kezdve legfeljebb maxsplit szeletelést végez.

str.splitlines([keepends])

Feldarabolja az str stringet a sor határoknál, és visszatér a sorokat tartalmazó listával. Az egyes sorok a sorvége jeleket nem tartalmazzák, hacsak a keepends opcionális paraméter nem True igazságértékű.

str.startswith(prefix[, start[, end]])

Igazzal tér vissza, ha str a prefix string-gel kezdődik, ellenkező eseten hamissal. Ha az opcionális start ill. end paraméter adott, akkor az összehasonlítás a start indexnél kezdődik, illetve az end indexnél fejeződik be.

str.strip([chars])

Visszatér str azon másolatával, ahol a string eleji és végi karakterek el vannak távolítva. A chars paraméter egy string, amely az eltávolítandó karaktereket tartalmazza. Ha hiányzik, akkor a metódus csak a whitespace karaktereket távolítja el.

str.swapcase()

Visszaadja azt a stringet, amelyben str kisbetűi nagybetűssé vannak konvertálva és fordítva.

str.title()

Visszaadja azt a stringet, amelyben str minden szava nagybetűvel kezdődik és a szavak további karaktere kisbetűs.

str.translate(table[, deletechars])

Visszaadja str-nek azt a másolatát, amelyben minden karakter ki van törölve, amely szerepel a deletechars stringben, a maradék karakterek pedig le vannak képezve az adott konverziós tábla (table) által. A table kötelezően egy 256 hosszúságú string.

str.upper()

Visszadja str azon másolatát, amelyben a karakterek csupa nagybetűsek.

str.zfill(width)

Visszaadja az str numerikus stringnek azon másolatát, amely balról fel lett töltve annyi 0-val, hogy az új string width hosszúságú legyen. A metódus a negatív numerikus strinkeket is jól kezeli, továbbá ha width kisebb, mint az str hossza, akkor visszaadja az eredeti stringet.

"""



Néhány gyakori lista metódus

list.append(elem) elem beszúrása a lista végére, nem tér vissza a listával, a listát helyben módosítja
list.insert(index, elem) elem beszúrása az adott index pozícióra, a tőle jobbra lévő elemeket eggyel jobbra mozgatja
list.extend(list2) a list2-ben lévő elemeket a lista végére beszúrja, a + ill. a += operátorok hasonlóan működnek
list.index(elem) adott elem keresése a listában
   ha benne van, akkor az elem indexével tér vissza
   ha nincs benne, akkor ValueErrorkivételt dob (elkerüléséhez használjuk az „in” operátort)
list.remove(elem) az adott elem első előfordulását eltávolítja a listából, ha nincs benne, akkor ValueErrorkivétel lép fel
list.pop(index) az adott indexű elemet eltávolítja s ezzel az elemmel tér vissza
   ha az indexet nem adjuk meg, akkor a legjobboldalibb elemmel tér vissza
list.sort() helyben rendezi a listát (nem tér vele vissza)
list.reverse() helyben megfordítja az elemek sorrendjét (nem tér vissza a listával)

L i s t á k


ls = [ 1, 2, "Béla", 3.1459 ]
ls[1] – 2
ls[2] – "Béla"
ls[2:] – [ "Béla", 3.1459 ]
ls[::-1] – [ 3.1459, "Béla", 2, 1 ] # lista fordítva
li = [] # üres lista
len(ls) – 4
len(li) – 0
[3,4] + [1,2] – [3,4,1,2]
for e in ls:
	print(e,end=",") – 1,2,"Béla",3.1459,
for e in ls[::2]:
	print(e,end=",") – 1,"Béla",
"Béla" in ls – True

========

Néhány gyakori művelet listákkal

range(5) – [0,1,2,3,4]
range(5,8) – [5,6,7]
range(4,10,2) – [4,6,8]
range(10,6,-2) – [10,8]
print(list("Géza")) – ['G','é','z','a']

ls = [5,3,10,3,4]
max(ls) – 10
min(ls) – 3
sum(ls) – 25

join/split – lista=>string/string=>lista
a = ["xx","yy","zz"]
":".join(a) – "xx:yy:zz"
",".join(a) – "xx,yy,zz"
print("\n".join(a)) – xx yy zz új sorokba

b = "xx:yy:zz"
b.split(":") – ["xx","yy","zz"]
c = "Géza kék   az\tég" – tabulátor
c.split() – ["Géza","kék","az","ég"]

b.split(":") – ["xx","yy","zz"]





xxx


Szövegfájl nyitása

Művelet Eredmény, megjegyzés
with open(fnév,mód) as f: fnév – a szövegfájl neve,
mód – nyitás módja ("r" - olvasás, "w" - írás, "a" - hozzáfűzés),
f – fájlobjektum neve
f = open(fnév,mód) ugyanaz mint fenn / de le kell majd zárni a fájlt /
f.close() f fájlobjektum lezárása

Szövegfájl olvasása, írása

t = f.readline() az "f" fájl aktuális sorát olvassa be a "t" stringbe
t = f.read() az "f" fájl összes sorát beolvassa a "t" stringbe
t = f.readlines() beolvassa az "f" fájl sorait a "t" listába / t[0]-a szöv.fájl első sora, t[1]-a szöv.fájl 2. sora, stb. /
f.write(st) az "f" fájlba írja az "st" stringet / visszaadja a kiírt karakterek számát /
for sr in f:
    print(sr, end='')
kiírja az "f" szövegfájl sorait, "sr" a fájl aktuális sora



A matematikai modul használatához, importálnunk kell a math modult.

  • import math – a függvényhívások csak a math előtaggal ( math.sqrt(2) )
  • from math import * – a math modul összes függvényét importáljuk ( sqrt(2) alak is jó )
  • from math import sqrt, sin – csak ezt a két függvényt importáljuk ( a cos(3.14/2) nem megy )

Matematikai függvények, konstantsok


Számelméleti és reprezentációs függvények

math.ceil(x) a nála nagyobb vagy egyenlő egész
math.copysign(x, y) x abszulút értéke megkapja az y előjelét (0-t 0.0-nak vagy -0.0nak írjuk)
math.fabs(x) x abszulút értéke
math.factorial(x) x faktoriálisa (ha x nem egész, ValueError)
math.floor(x) a nála kisebb vagy egyenlő egész
math.fmod(x, y) x y-al való osztási maradéka
math.frexp(x) egy (m,k) párt ad vissza, ha x-et m * 2**k alakra hozzuk, ahol 0.5 ≤ m < 1 és k egy egész
math.ldexp(x, i)
math.fsum(lista) az elemek összege (mint a sum())
math.trunc(x) levágja a x szám törtrészét, csak az egészet adja vissza

Hatvány és logaritmus függvények

math.exp(x) e**x
math.expm1(x) e**x - 1 ????
math.log(x[, a]) x e alapú, vagy x a alapú logaritmusa
math.log10(x) x 10-es alapú logaritmusa
math.pow(x, y) x y-adik hatványa
math.sqrt(x) x négyzetgyöke

Trigonometrikus függvények (a szögek radiánban)

math.sin(x) x szinusza
math.cos(x) x koszinusza
math.tan(x) x tangense
math.acos(x) x arkusz koszinusza
math.asin(x) x arkusz szinusza
math.atan(x) x arkusz tangense
math.atan2(y, x) Return atan(y / x), in radians. (-pi <= eredmény <= pi)
math.hypot(x, y) sqrt(x*x + y*y)-t ad vissza

Szögek átváltása

math.degrees(x) x-et radiánból fokba alakítja
math.radians(x) x-et fokból radiánba alakítja

Konstantsok

math.pi π = 3.141592…
math.e e = 2.718281…



Ez a modul pszeudo-véletlenszámokat generál különböző eloszlásokhoz. Importálása:

  • import random – a függvényhívások csak a random előtaggal ( random.randint(1,90) - ötöslottó )
  • from random import * – a random modul összes függvényét importáljuk ( randint(1,90) alak is jó )

Véletlenszámok generálása


Egészeket generáló függvények

random.randrange(stop) visszaad egy N egész számot, ahol 0 ≤ N < stop
random.randrange(start, stop[, step]) egy N egész számot ad vissza, ahol start ≤ N < stop,
step lépésközzel ( start+step, start+2*step, start+3*step, ... )
random.randint(a, b) egy N egész számot ad vissza, ahol a ≤ N ≤ b

Szekvenciákkal kapcsolatos függvények

random.choice(seq) a seq nem üres szekvencia egy elemét adja (a seq lehet egy string, vagy egy lista)
random.shuffle(x[, random]) egy szekvenciát kever össze helyben

Valós számok függvényei

random.random() egy lebegőpontos számot generál a [0.0, 1.0) intervallumból
random.gauss(mu, sigma) Gauss eloszlás, a mu jelentése az átlag, és a sigma a szórás






Dokumentáció - magyarul

Dokumentáció - angol

Oktató videók

 
 

Könyvek