#-al kezdődő sorok kommentek, nem befolyásolják a programot. 2+2
# 2+3
import this
break: ha korábban ki akarunk lépni egy ciklusbólcontinue: ha korábban szeretnénk a következő ciklus futásra lépnifor i in range(10):
if i % 2 == 0:
continue
print(i)
for i in range(10):
if i > 4:
break
print(i)
def foo():
print("én egy nagyon okos függvény vagyok")
foo()
Először a pozíció szerintieket kell írni aztán a kulcsszavasokat
def foo(arg1, arg2, arg3):
print("arg1 ", arg1)
print("arg2 ", arg2)
print("arg3 ", arg3)
foo(1, 2,3)
foo(1, arg3=2, arg2=29)
arg3=4
return parancs¶return parancsot, a visszatérési érték automatikusan None lesz.return parancs is None-nal tér vissza. def foo(n):
if n < 0:
return "negative"
if 0 <= n < 10:
return "positive", n
# return None
# return
print(foo(-2))
print(foo(3), type(foo(3)))
print(foo(12))
l=["matek"]
def add_matek(k):
k.append("matek")
print(l)
add_matek(l)
print(l)
add_matek(l)
print(l)
s="matek"
def add_matek(k):
k=k+"matek"
print(s)
add_matek(s)
print(s)
add_matek(s)
print(s)
def foo(arg1, arg2, arg3=3):
print("arg1 ", arg1)
print("arg2 ", arg2)
print("arg3 ", arg3)
foo(1, 2)
foo(2, arg2=1)
foo(arg1=1, arg3=33, arg2=222)
Tetszőleges kihagyható közülük.
def foo(arg1, arg2=2, arg3=3):
print("arg1 ", arg1)
print("arg2 ", arg2)
print("arg3 ", arg3)
foo(11, 33)
print("")
foo(11, arg3=33)
Emiatt rengeteg argumentumod lehet úgy is, hogy ez nem nehezíti meg a függvény használatát. Sok könyvtárban találunk olyan függvényeket, amiknek rengeteg argumentumunk van.
Például a következő függvényt a pandas könyvtárban találjuk:
pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False, as_recarray=False, compact_ints=False, use_unsigned=False, low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)
i = 2
type(i), id(i)
i = "foo"
type(i), id(i)
i = 2
f = 1.2
s = i + f
print(type(i), type(f))
print(type(i + f))
print(s,type(s))
#print("Nekem " + 3.1415 + " az IQ-m")
Viszont explicit konverzióval működik:
print("Nekem " + str(3.1415) + " az IQ-m")
and, or and notx = 2
x < 2 and x >= 2
x > 0 and x < 10
not x < 0
True és False (nagybetűvel kell kezdeni!!!)x = True
type(x)
True and False
True or False
not True
True and True and False
int, float and complexi = 2
f = 1.2
c = 1+2j
type(i), type(f), type(c)
c2 = i + c
print(c2, type(c2))
2**100000
type(2**63 + 1)
sys.float_info parancs segítségével kapunkimport sys
sys.float_info
sys.int_info
i = 2
f = 4.2
c = 4.1-3j
s1 = i + f
s2 = f - c
s3 = i * c
print(s1, type(s1))
print(s2, type(s2))
print(s3, type(s3))
/ törtet is adhat// a hányados egész részét adja vissza3 / 2
-3.0 // 2, 3 // 2
4 / 0.8, 4.0 / 0.8, 4 // 0.8, 4.0 // 0.8
Mi a megoldás a ilyesmi problémák elkerülésére?
x = 23
x < 24, x >= 22
Össze is lehet őket láncolni
23 < x < 100
23 <= x < 100
5 % 3
2 ** 3
2 ** 0.5
abs(-2 - 1j), abs(1+1j)
round(2.3456), round(2.3456, 2), round(3.5)
float(2)
# 0 felé kerekít
int(-2.7), int(2.7)
math és cmath modulok még sok mást tartalmaznak¶import math
math.log(16), math.log(16, 2), math.exp(2), math.exp(math.log(10))
"asd"+"asd"
a=2
a=3
x = 2
old_id = id(x)
x = x + 1
print(id(x) == old_id)
for i in range(-10, 260):
x = i
y = i + 1 - 1
if x is not y:
print(i)
Egyedi immutable objektumok, csak egy példány van belőlük.
x = True
y = False
print(x is y)
x = False
print(x is y)
l1 = [0, 1]
old_id = id(l1)
l1.append(2)
old_id == id(l1)
[1,2] is [1,2]
A listák helyben megváltoztathatóak
| operation | behaviour |
|---|---|
x in s |
True ha s egyenlő x valamelyik elemével, különben False |
x not in s |
Flase ha s egyenlő x valamelyik elemével, különben True |
s + t |
s és t összefűzése |
s * n or n * s |
ekvivalens azzal, hogy összeadjuk s-nek n darab példányát |
s[i] |
s-nek az i. eleme, 0-tól kezdve |
s[i:j] |
s-nek az i-től j-ig tartó szelete |
s[i:j:k] |
s-nek az i-től j-ig tartó szelete k lépésközzel |
len(s) |
s hossza |
min(s) |
s legkisebb eleme |
max(s) |
s legnagyobb eleme |
s.index(x[, i[, j]]) |
s első előfordulásának indexe x-ben (az i. indextől a j.-ig tartó részen) |
s.count(x) |
s x-beli megjelenéseinek száma |
l = [1, 2, 2, 3]
l
l[1]
# l[4] # raises IndexError
l[-1], l[len(l)-1]
l = [1, 2, 3]
l.append(3)
l.clear()
l
l = [1, 2, 3]
l.insert(1, 5)
l
l= [1, 2, 5, 1]
del l[2]
l
l = []
for i in range(20):
l.append(2*i + 1)
l[2:5]
l[:10]
l[-4:]
for i in range(10):
print(l[i:i+3])
l[2:11:3]
l[::-1]
A lista mutable, elemek megváltoztathatóak:
l = []
old_id = id(l)
for element in range(1, 3):
l.append(element)
print(id(l) == old_id)
l
l[1] = 12
l = [1, 2]
l.extend([3, 4, 5])
len(l), l
l=[1,2]
l2 = l.copy()
print(l is l2)
l2.append(42)
l
a="alma"
b=a
b=b+"alma"
a
l = [1, -1, "foo", 2, "bar"]
l
for element in l:
print(element)
ha szükségünk van az indexre is, a beépített enumerate függvény index-elem párokon fut végig
l=["asd",1,2]
for i, element in enumerate(l):
print(i, element)
sorted függvény segítségévell = [3, -1, 2, 11]
for e in sorted(l):
print(e)
A key argumentummal megadhatjuk, hogy mi szerint rendezzünk
shopping_list = [
["apple", 5],
["pear", 2,2],
["milk", 1],
["bread", 3],
]
for product in sorted(shopping_list, key=lambda x: len(x)):
print(product)
Helyben is lehet rendezni a .sort() metódussal.
l=[3, -1, 2, 11]
l.sort()
l
A * operátor segítségével "kibonthatunk" egy listát. A *l kifejezés felsorolja az l lista elemeit de már nem egy lista objektum. Ez tipikusan akkor hasznos, ha egy függvény sok paramétert vár.
l=["alma","körte","piskóta"]
print(l)
print(*l)
def osszeg(x,y,z):
return x+y+z
osszeg(*[10,20,30])
args és kwargs¶* és ** operátorokkaldef arbitrary_positional_f(*args):
print(type(args))
for arg in args:
print(arg)
arbitrary_positional_f(1, 2, -1)
# arbitrary_positional_f(1, 2, arg=-1) # raises TypeError
l = [-1, 0, -10, 2, 3]
Rendezzünk például abszolút érték szerint. A beépített sorted függvény nem elég:
for e in sorted(l):
print(e)
De megadhatjuk, hogy milyen key kulcsot használjon:
for e in sorted(l, key=lambda x: abs(x)):
print(e)
Bármilyen függvényt használhatunk
for e in sorted(l, key=abs):
print(e)