Basic Python

Variables

a = 1
b = "some string"
c = 'string as well '
b_c = 'some string'

Python jest dynamicznie typowanym językiem, czyli:

a = 1
print(a)
print(type(a)) # type służy do wyznaczania typu podanego argumentu
a = "asd"
print(a)
print(type(a))
a = [1,2,3]
print(a)
print(type(a))

1
<class 'int'>
asd
<class 'str'>
[1, 2, 3]
<class 'list'>

if

if ma składnie podobną do C/C++:

if condition :
    kod
elif condition : (opcjonalne)
    kod
else: (opcjonalne)
    kod 

***lub***

if(condition):
    kod
elif(condition): (opcjonalne)
    kod
else: (opcjonalne)
    kod 

one line if:

code if condition else code

Operatory porównania:

== - operator równości
!= - nierówność
<, >, >=, <= - ...

b = "string"
b_c = "string"

if(b == b_c):
    print("są równe")
else:
    print("nie są równe")


if b != "bit infra":
    print("super")

są równe
super

operatory logiczne:

and - operator koniunkcji (&& w C++)
or - operator alternatywy (|| w C++)
*not - operator negacji (! w C++)

a = 1
b = '1'

if a == 1 and b == '1':
    print("OK")
else:
    print("Nie OK")

OK

Pętle

while

while(condition):
    kod

i = 1
while(i<5):
    print(i)
    i+=1

1
2
3
4

for

for pętla która jest pętlą która iteruje po czymś, np. :

for i in range(1,5):
    print(i)

1
2
3
4

w ogólnym przypadku:

 for zmienna in iterable_object:
    kod

Także możemy iterować dowolną ilością zmiennych po kolekcjach o których niżej

a = [(1,2), (3,4)]

for x,y in a:
    print(x, y)

1 2
3 4

Kolekcje

list - zwykła tablica
tuple - ciąg
dict - słownik (HashMap(java), unordered_map(C++))
set - zbiór (HashSet(java), unordered_set(C++))

a = [4,5,6] # list()
a.append(1)
a.append(2)
a.insert(1,3)
print(a)

a[0] = 24
print(a)

print(len(a))
print(a.pop())
print(a)
print(a[0])

print(5 in a)

[4, 3, 5, 6, 1, 2]
[24, 3, 5, 6, 1, 2]
6
2
[24, 3, 5, 6, 1]
24
True

a = (1,2)
print(type(a))
#a[1] = 3 # typles are immutable throws TypeError
print(a[0])
print(5 in a)

a = list(a) #converte to list
a[1] = 3
print(a)

<class 'tuple'>
1
False
[1, 3]

a = set()
a.add('a')
a.add('b')
print(a)
a.add('a')
a.remove('a')
print(a)
# a.remove('a') # throws an KeyError
if('a' in a):
    a.remove('a')
else:
    print("there is no a")
print(len(a))

{'a', 'b'}
{'b'}
there is no a
1

a = dict()
a[(1,2)] = "para 1"
a[(4,5)] = "para 2"

keys = a.keys()

print(keys)
print(a.items())
print((1,2) in a)
print((1,3) in a)
print(a[(1,2)])
del a[(1,2)]
#print(a[(1,2)]) # throws an KeyError
print(keys)

dict_keys([(1, 2), (4, 5)])
dict_items([((1, 2), 'para 1'), ((4, 5), 'para 2')])
True
False
para 1
dict_keys([(4, 5)])

Tworzenie tablic wielowymiarowych

Do tego urzywamy generatorów, mają oni postać:
$[ zmiennazapisywana for iterator/lub '' in iterable_object ]
np.:

a = [[j for j in range(i)] for i in range(5)]
print(a)

[[], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]

Funkcje

def function_name(parameters divided by comma):
    kod

def func(a,b,c):
    print(a)
    return b+c

r = func(1,2,3)
r

1

5

def func2(a):
    print(a*2 + 1)

r = func2(2)
print(r)

5
None

def funcZ(a):
    
    def funcW(b):
        return b*a
    
    return funcW

my_f = funcZ(4)
my_f(5)

20

funcW(3)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-61-529d2743ae28> in <module>()
----> 1 funcW(3)

NameError: name 'funcW' is not defined

Importowanie bibliotek

import library_name

import numpy
a = numpy.array([1,2])
a

array([1, 2])

import library_name as alias

import numpy as np
a = np.array([1,2])
a

array([1, 2])

from library_name import function1, function2

from numpy import array, linspace
a = array([1,2])
print(linspace(1,5))
a

[1.         1.08163265 1.16326531 1.24489796 1.32653061 1.40816327
 1.48979592 1.57142857 1.65306122 1.73469388 1.81632653 1.89795918
 1.97959184 2.06122449 2.14285714 2.2244898  2.30612245 2.3877551
 2.46938776 2.55102041 2.63265306 2.71428571 2.79591837 2.87755102
 2.95918367 3.04081633 3.12244898 3.20408163 3.28571429 3.36734694
 3.44897959 3.53061224 3.6122449  3.69387755 3.7755102  3.85714286
 3.93877551 4.02040816 4.10204082 4.18367347 4.26530612 4.34693878
 4.42857143 4.51020408 4.59183673 4.67346939 4.75510204 4.83673469
 4.91836735 5.        ]

array([1, 2])

from library_name import function1 as alias, function2 as alias

from numpy import array as ar, linspace as ls
a = ar([1,2])
print(ls(1,5))
a

[1.         1.08163265 1.16326531 1.24489796 1.32653061 1.40816327
 1.48979592 1.57142857 1.65306122 1.73469388 1.81632653 1.89795918
 1.97959184 2.06122449 2.14285714 2.2244898  2.30612245 2.3877551
 2.46938776 2.55102041 2.63265306 2.71428571 2.79591837 2.87755102
 2.95918367 3.04081633 3.12244898 3.20408163 3.28571429 3.36734694
 3.44897959 3.53061224 3.6122449  3.69387755 3.7755102  3.85714286
 3.93877551 4.02040816 4.10204082 4.18367347 4.26530612 4.34693878
 4.42857143 4.51020408 4.59183673 4.67346939 4.75510204 4.83673469
 4.91836735 5.        ]

array([1, 2])

warning : can cause a mental diseases

from library_name import *

no examples for this s**t

Classes

class ClassName(object):
    
    def __init__(self, a, b):
        self.a = a
        self.b = b
    
    def class_method(self):
        return self.a+self.b
    
    def method2(self, a, b):
        self.a += a
        self.b += b
        return self.a + self.b

class_object1 = ClassName(2,3)
class_object2 = class_object1
class_object3 = ClassName(2,3)

class_object1.class_method()

5

class_object1.method2(1, 1)

7

print(class_object1.a, class_object1.b)

3 4

print(class_object2.a, class_object2.b)

3 4

print(class_object3.a, class_object3.b)

2 3

Print

print(1)
print("String")
print(1, "String")
try: 
    print(1 + "String")
except:
    print("no chyba nie")

1
String
1 String
no chyba nie

troche lepiej

print ( f " { zmienna } " )

num = 1
string = "String"
print(f"{num} {string}")

1 String

albo z .format

print ( " { 0 } ... { 1 } ... { n }".format( lista argumentów ) )

*len(lista argumentow) = n

num = 1
string = "String"
print("{0} {1}".format(num, string))

1 String

*args

a = 3
b = 4
a, b = b, a
print(f"a = {a}\nb = {b}")

a = 4
b = 3

a, *args, b = 1, 2, 3, 4

a

1

args

[2, 3]

def fun_arg(*arg):
    
    print("Item | index")
    
    for index, item in enumerate(arg):
        print(f"{item} | {index}")

fun_arg(1,2,3)

Item | index
1 | 0
2 | 1
3 | 2

**kwargs

def fun(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

fun(BIT="AI")

BIT = AI

Lambda

lambda zmienna : funkcja

fun = (lambda x : x**2)

tab = [1,2,3]

[fun(x) for x in tab]

[1, 4, 9]

tab = [5,4,612,7,5,8]

tab.sort(key=(lambda x : str(x)[-1]))
tab

[612, 4, 5, 5, 7, 8]