Brain-wiki - Wkład użytkownika [pl]

TI/Skrypty z zajęć/pyqt5

2020-06-17T12:28:12Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys import numpy as np licznik = 0 znaki = np.array([["","",""],["","",..."

<source lang="python">
# -*- coding: utf-8 -*-
from PyQt5 import QtCore, QtGui, QtWidgets
import sys
import numpy as np

licznik = 0
znaki = np.array([["","",""],["","",""],["","",""]])
znaki_old = znaki.copy()

class NaszButton(QtWidgets.QPushButton):
def __init__(self,i,j,*args,**kwargs):
super().__init__(*args,**kwargs)
self.setGeometry(QtCore.QRect(i*200, j*200, 200, 200))
self.setText("")
self.clicked.connect(self.clickniecie)
self.i = i
self.j = j

def clickniecie(self):
global licznik
global znaki
global znaki_old
if znaki[self.i][self.j] == "":
licznik += 1
znaki_old = znaki
znaki = znaki_old.copy()
if licznik%2:
znaki[self.i][self.j] = 'X'
else:
znaki[self.i][self.j] = 'O'
self.setText(str(znaki[self.i][self.j]))

class NaszWidget(QtWidgets.QWidget):
def __init__(self,*args,**kwargs):
super().__init__(*args,**kwargs)
self.setObjectName("PlusMinus")
self.resize(600, 800)
self.buttony = []
for i in range(3):
for j in range(3):
self.buttony.append(NaszButton(i,j,self))
self.czyszczenie = QtWidgets.QPushButton(self)
self.czyszczenie.setGeometry(QtCore.QRect(0, 600, 600, 200))
self.czyszczenie.setText("czyszczenie")
self.czyszczenie.clicked.connect(self.czysc)
self.show()

def czysc(self):
global znaki
global licznik
znaki = znaki_old.copy()
licznik -=1
for button in self.buttony:
button.setText(str(znaki[button.i][button.j]))

if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
PlusMinus = NaszWidget()
sys.exit(app.exec_())
</source>

TI/Skrypty z zajęć

2020-06-17T12:27:26Z

Tgub:

TI/Skrypty z zajęć/kz15-17

2020-06-03T18:24:34Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- ''' Zadanie 15 Przepisz klasę ciąg arytmetyczny z zadania 8, tak by zwracała odpowideni wyjątek przy odwołaniu się d..."

<source lang="python">
# -*- coding: utf-8 -*-
'''
Zadanie 15
Przepisz klasę ciąg arytmetyczny z zadania 8, tak by zwracała odpowideni wyjątek przy odwołaniu się do niewłasciwego elementu
'''

class CiagArytmetyczny():
def __init__(self, a1, r):
self.__a1 = float(a1)
self.__r = float(r)

def __get_a1__(self):
return self.__a1

def __get_r__(self):
return self.__r

def __set_a1__(self, a1):
self.__a1 = float(a1)

def __set_r__(self, r):
self.__r = float(r)

a1 = property(__get_a1__,__set_a1__)
r = property(__get_r__,__set_r__)

def __getitem__(self,n):
if isinstance(n,int):
if n < 1: raise IndexError
return self.__a1 + (n-1)*self.__r
raise TypeError

def __add__(self, other):
return CiagArytmetyczny(self.a1 + other.a1, self.r + other.r)

def __str__(self):
return 'CiagArytmetyczny a1 = '+str(self.__a1)+' r = '+str(self.__r)

def __repr__(self):
return str(self)

'''
Zadanie 16
Początek jak w zadaniu 9:
"Napisz klasę CiągArytmetycznyZeSlownikiem, która dziedziczy po klasie
CiągArtymetyczny. Zaimplementuj w niej metodę __setitem__, która będzie
zapisywać wywołane klucze i wartości do prywatnego słownika.
Klasa powinna zapewniać dostęp do tego słownika, ale bez możliwości jego edycji."
ale tym rezem można już używać super(). Nadpisz również metodę __getitem__ tak, by zwracała wartosci wczesniej przypisane
przez __setitem__. Skorzystaj z try except
'''

class CiagArytmetycznyZeSlownikiem(CiagArytmetyczny):

def __init__(self,*args, **kwargs):
super().__init__(*args, **kwargs)
self.__sl = {}

def __setitem__(self, key, value):
self.__sl[key] = value

@property
def sl(self):
return self.__sl.copy()

def __str__(self):
return 'CiagArytmetycznyZeSlownikiem a1 = '+str(self.a1)+' r = '+str(self.r)

def __getitem__(self,n):
try:
return self.__sl[n]
except:
return super().__getitem__(n)

'''
Zadanie 17
Napisz dekorator mierzący czas działania funkcji i wypisujący ten czas przy każdym wywołaniu.
'''
import time

def timeit(fun):
def f(*args, **kwargs):
start = time.time()
result = fun(*args, **kwargs)
stop = time.time()
print('Obliczenie trwalo',stop-start,'s')
return result
return f

</source>

TI/Skrypty z zajęć/k8a

2020-06-03T18:23:59Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Jun 3 12:16:05 2020 @author: Tomek """ def inv(x): try: value = 1/x return value..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 3 12:16:05 2020

@author: Tomek
"""

def inv(x):
try:
value = 1/x
return value
except (ZeroDivisionError,TypeError):
print('podaj liczbe rozna od zera !!!!')
return 0

# finally:
# print('oo')

class ArgumentCiaguError(Exception):
pass

class CiagArytmetyczny():
def __init__(self, a1, r):
self.__a1 = float(a1)
self.__r = float(r)

def __get_a1__(self):
return self.__a1

def __get_r__(self):
return self.__r

def __set_a1__(self, a1):
self.__a1 = float(a1)

def __set_r__(self, r):
self.__r = float(r)

a1 = property(__get_a1__,__set_a1__)
r = property(__get_r__,__set_r__)

def __getitem__(self,n):
if isinstance(n,int):
if n < 1: raise ArgumentCiaguError('tylko naturalne bez zera')
return self.__a1 + (n-1)*self.__r
raise TypeError

def __add__(self, other):
return CiagArytmetyczny(self.a1 + other.a1, self.r + other.r)

def __str__(self):
return 'CiagArytmetyczny a1 = '+str(self.__a1)+' r = '+str(self.__r)

def __repr__(self):
return str(self)

z = CiagArytmetyczny(1,1)
x = CiagArytmetyczny(100,1)

for n in range(-10,11):
try:
print(z[n])
except ArgumentCiaguError:
pass #print('zly argument')
</source>

TI/Skrypty z zajęć/k8

2020-06-03T18:23:12Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Jun 3 11:09:18 2020 @author: Tomek """ def dodajAutora(fun): fun.autor = 'Tomasz Gubiec' retu..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 3 11:09:18 2020

@author: Tomek
"""
def dodajAutora(fun):
fun.autor = 'Tomasz Gubiec'
return fun

def opiszWykonanie(fun):
def f(*args,**kwargs):
print('Poczatek wykonania funkcji',fun.__name__, 'dla argumentow', args, kwargs)
value = fun(*args,**kwargs)
print('Koniec wykonania funkcji',fun.__name__, 'dla argumentow', args, kwargs)
print(' a otrzymany wynik to', value)
return value
return f

class dodajAutora2():
def __init__(self,fun):
self.__fun = fun

@property
def autor(self):
return 'Tomasz Gubiec'

def __call__(self, *args, **kwargs):
return self.__fun(*args, **kwargs)

class memoize():
def __init__(self,fun):
self.__fun = fun
self.__memo = {}

def __call__(self, *args):
if args in self.__memo:
print('to juz kiedys bylo liczone')
return self.__memo[args]
else:
value = self.__fun(*args)
self.__memo[args] = value
return value

@memoize #kwadratowa = dodajAutora(kwadratowa)
def kwadratowa(x):
return x*x

@memoize #liniowa = dodajAutora(liniowa)
def liniowa(x):
return 2*x + 3

@dodajAutora
@memoize
def fibo(n):
if (n == 1) or (n == 2): return 1
return fibo(n-1) + fibo(n-2)

#a = [kwadratowa(i) for i in range(100)]

</source>

TI/Skrypty z zajęć

2020-06-03T18:22:30Z

Tgub:

TI/Skrypty z zajęć/k7

2020-06-02T13:25:57Z

Tgub:

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 2 12:30:34 2020

@author: Tomek
"""

class Punkt():
__ile_nas = 0

@staticmethod
def kwadratowa(x):
return x**2

@classmethod
def ile_nas(cls):
return cls.__ile_nas

def __init__(self, x, y):
self.__x = x
self.__y = y
Punkt.__ile_nas += 1

def __del__(self):
Punkt.__ile_nas -=1

def getX(self): return self.__x
def getY(self): return self.__y

p1 = Punkt(1,1)
p1 = Punkt(1,4)
p2 = Punkt(5,4)
p3 = Punkt(5,1)

</source>

TI/Skrypty z zajęć/kz10-14

2020-06-02T13:25:28Z

Tgub:

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 2 11:03:05 2020

@author: Tomek
"""

'''
Zadanie 10
Utwórz klasę Punkt, która będzie służyła do reprezentowania punktu na płaszczyźnie.
Klasa powinna mieć dwa pola (współrzędne punktu), konstruktor dwuparametrowy oraz metody:
getX, getY,setX, seyY, odlegloscOdPkt (o parametrze typu Punkt),
__str__ (opis punktu postaci (x; y)).
'''

class Punkt():
def __init__(self, x, y):
self.__x = x
self.__y = y

def getX(self): return self.__x
def getY(self): return self.__y
def setX(self, x): self.__x = x
def setY(self, y): self.__y = y
def __str__(self): return '('+str(self.__x)+'; '+str(self.__y)+')'
def odlegloscOdPkt(self, other):
return ((self.__x-other.getX())**2 + (self.__y-other.getY())**2)**(0.5)
#p1 = Punkt(1,1)
#p2 = Punkt(4,5)
#print(p1)
#print(p2)
#print(p1.odlegloscOdPkt(p2))
#print(p2.odlegloscOdPkt(p1))
'''
Zadanie 11
Napisz klasę Wielobok opisującą wielobok. Klasa powinna zawierać listę obiektów klasy Punkt
(z zadania poprzedniego) przechowującą informację o współrzędnych punktów tworzących wielobok, konstruktor, który jako argument powinien przyjmować dowolną liczbę elementów typu Punkt, metodę
zwracającą liczbę boków, metodę liczącą obwód wieloboku oraz metodę __str__ wypisująca
na ekranie wszystkie wierzchołki wieloboku.
'''
class Wielobok():
def __init__(self, *args):
self.__punkty = list(args)

def n(self):
return len(self.__punkty)

def obwod(self):
result = 0.0
poczatek = self.__punkty[-1]
for koniec in self.__punkty:
result += poczatek.odlegloscOdPkt(koniec)
poczatek = koniec
return result

def __str__(self):
# result = ''
# for punkt in self.__punkty:
# result += str(punkt)
# return result
return ' '.join([str(p) for p in self.__punkty])

p1 = Punkt(1,1)
p2 = Punkt(1,4)
p3 = Punkt(5,4)
p4 = Punkt(5,1)
#w = Wielobok(p1,p2,p3,p4)
#print(w)
#print(w.n())
#print(w.obwod())

'''
Zadanie 12
Napisz klasę Trojkat dziedziczącą po klasie Wielobok. Konstruktor powinien przyjmować trzy
obiekty klasy punkt. Napisz metodę liczącą pole trójkąta (polecam wzór Herona)
oraz metodę __str__ korzystającą z tej samej metody klasy rodzica.
'''
class Trojkat(Wielobok):
def __init__(self, p1, p2, p3):
super().__init__(p1, p2, p3)

def pole(self):
p = 0.5 * self.obwod()
boki = (p1.odlegloscOdPkt(p2),p2.odlegloscOdPkt(p3),p3.odlegloscOdPkt(p1))
return (p*(p-boki[0])*(p-boki[1])*(p-boki[2]))**0.5

def __str__(self):
return 'Trojkat '+ super().__str__()

tr = Trojkat(p1,p2,p4)
#print(tr)
#print(tr.obwod())
#print(tr.pole())

'''
Zadanie 13
Napisz klasę Rownoleglobok dziedziczącą po klasie Wielobok. Konstruktor dostaje trzy
Punkty (A,B i C). Czwarty punkt powstaje z odbicie punktu A względem środka odcinka
BC. Napisz metodę obliczająca pole powierzchni za pomocą tworzonych na tę potrzebę
obiektów klasy Trojkat.
'''
class Rownoleglobok(Wielobok):
def __init__(self, A, B, C):
BC = Punkt((B.getX()+C.getX())/2,(B.getY()+C.getY())/2)
D = Punkt(BC.getX()+ (BC.getX() - A.getX()), BC.getY()+ (BC.getY() - A.getY()))
super().__init__(A, B, D, C)
self.__A = A
self.__B = B
self.__C = C
#self.__D = D

def pole(self):
tr1 = Trojkat(self.__A, self.__B, self.__C)
# tr2 = Trojkat(self.__D, self.__B, self.__C)
return 2*tr1.pole()# + tr2.pole()

r = Rownoleglobok(p1, p2, p4)
#print(r)
#print(r.obwod())
#print(r.pole())
'''
Zadanie 14
Napisz klasę „dziwnaLiczba”, która dziedziczy po klasie „int” (liczbach całkowitych).
„Dziwność” polega na tym, że przy dodawaniu dwóch obiektów klasy „dziwnaLiczba”
otrzymujemy „dziwnąLiczbę” będącą wynikiem mnożenia liczb im odpowiadających,
a przy mnożeniu dwóch „dziwnychLiczb” otrzymujemy „dziwnąLiczbę” będącą wynikiem dodawania liczb im odpowiadających. W skrócie, znaki mnożenia i dodawania są zamienione miejscami
'''

class dziwnaLiczba(int):
def __mul__(self, other):
return dziwnaLiczba(super().__add__(other))

def __add__(self, other):
return dziwnaLiczba(super().__mul__(other))

a = dziwnaLiczba(3)
b = dziwnaLiczba(4)

</source>

TI/Skrypty z zajęć/k7

2020-06-02T13:24:57Z

Tgub: Utworzono nową stronę "<source lang="python"> aa </source>"

TI/Skrypty z zajęć/kz10-14

2020-06-02T13:24:43Z

Tgub: Utworzono nową stronę "<source lang="python"> aa </source>"

TI/Skrypty z zajęć

2020-06-02T13:23:45Z

Tgub:

TI/Skrypty z zajęć/k6

2020-05-27T19:51:27Z

Tgub:

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 27 11:11:31 2020

@author: Tomek
"""

class CiagArytmetyczny():
def __init__(self, a1, r):
self.__a1 = float(a1)
self.__r = float(r)

def __get_a1__(self):
return self.__a1

def __get_r__(self):
return self.__r

def __set_a1__(self, a1):
self.__a1 = float(a1)

def __set_r__(self, r):
self.__r = float(r)

a1 = property(__get_a1__,__set_a1__)
r = property(__get_r__,__set_r__)

def __getitem__(self,n):
if isinstance(n,int):
if (n > 0):
return self.__a1 + (n-1)*self.__r

def __add__(self, other):
return CiagArytmetyczny(self.a1 + other.a1, self.r + other.r)

def __str__(self):
return 'CiagArytmetyczny a1 = '+str(self.__a1)+' r = '+str(self.__r)

def __repr__(self):
return str(self)

z = CiagArytmetyczny(1,1)
x = CiagArytmetyczny(100,1)

class CiagArytmetycznyZeSlownikiem(CiagArytmetyczny):

def __init__(self, a1, r, sl = None):
#self(ale potraktuj mnie jako obiekt klasy CiagAtrytmetyczny).__init__(a1,r)
super().__init__(a1,r)
self.__sl = sl
if self.__sl==None:
self.__sl = {}

def __setitem__(self, key, value):
self.__sl[key] = value

@property
def sl(self):
return self.__sl.copy()

def __str__(self):
return 'CiagArytmetycznyZeSlownikiem a1 = '+str(self.a1)+' r = '+str(self.r)+' oraz sl = '+ str(self.sl)

def __add__(self, other):
return CiagArytmetycznyZeSlownikiem(self.a1 + other.a1, self.r + other.r)

y = CiagArytmetycznyZeSlownikiem(50,1)

class CiagArytmetycznyR1(CiagArytmetyczny):
def __init__(self, a1):
super().__init__(a1,1)

</source>

TI/Skrypty z zajęć/k6a

2020-05-27T19:50:32Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed May 27 11:50:27 2020 @author: Tomek """ class rownoleglobok(): def __init__(self, a, b):..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 27 11:50:27 2020

@author: Tomek
"""

class rownoleglobok():
def __init__(self, a, b):
print('wywolanie init z klasy rownoleglobok')
self.__a = a
self.__b = b

@property
def a(self):
return self.__a

@property
def b(self):
return self.__b

def __str__(self):
return 'Rownoleglobok o bokach ' + str(self.__a) + ', ' + str(self.__b)

def __repr__(self):
return str(self)

@property
def obwod(self):
return 2* (self.__a + self.__b)

class prostokat(rownoleglobok):
# def __init__(self, a, b):
# print('wywolanie init z klasy prostokat')
# super().__init__(a, b)

@property
def pole(self):
return self.a*self.b

# def __str__(self):
# return 'Jakis prostokat'

class kwadrat(prostokat):
def __init__(self, a):
print('wywolanie init z klasy kwadrat')
super().__init__(a, a)

def __str__(self):
return super().__str__() + ' ale bedacy kwadratem'

k = kwadrat(5)
print(k)

</source>

TI/Skrypty z zajęć/k6

2020-05-27T19:48:43Z

Tgub: Utworzono nową stronę "<source lang="python"> a </source>"

TI/Skrypty z zajęć

2020-05-27T19:47:51Z

Tgub:

TI/Skrypty z zajęć/kz7-9

2020-05-26T10:50:53Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Tue May 26 11:12:02 2020 @author: Tomek """ ''' Zadanie 7 Napisze klasę InnyNawias. Konstruktor klasy pr..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Tue May 26 11:12:02 2020

@author: Tomek
"""

'''
Zadanie 7
Napisze klasę InnyNawias. Konstruktor klasy przyjmuje jeden parametr:
jednoargumentową funkcję f. Zapisz otrzymaną funkcję w zmiennej prywatnej.
Zaimplementuj metodę __getitem__(x), która ma zwracać f(x).
'''

#zadanie 7
class InnyNawias():
def __init__(self, f):
self.__f = f

def __getitem__(self, x):
return self.__f(x)

def fun(x):
return x*x

z = InnyNawias(fun)

'''
Zadanie 8
Napisz klasę CiągArtymetyczny, która:
-przyjmuje w konstruktorze dwa argumenty a1 oraz r, które są pierwszym
elementem ciągu oraz różnicą ciągu. Zachowaj argumenty w zmiennych prywatnych,
ale zapewnij do nich dostęp poprzez property.
-ma zaimplementowaną metodę __getitem__, która zwraca odpowiedni element ciągu
(lub None, gdy jej argument nie jest liczbą naturalną)
- Ma zaimplementowaną metodę dodawania ciągów arytmetycznych

'''

#zadanie 8
class CiagArytmetyczny():
def __init__(self, a1, r):
self.__a1 = float(a1)
self.__r = float(r)

def __get_a1__(self):
return self.__a1

def __get_r__(self):
return self.__r

def __set_a1__(self, a1):
self.__a1 = float(a1)

def __set_r__(self, r):
self.__r = float(r)

a1 = property(__get_a1__,__set_a1__)
r = property(__get_r__,__set_r__)

def __getitem__(self,n):
if isinstance(n,int):
if (n > 0):
return self.__a1 + (n-1)*self.__r

def __add__(self, other):
return CiagArytmetyczny(self.a1 + other.a1, self.r + other.r)

def __str__(self):
return 'CiagArytmetyczny a1 = '+str(self.__a1)+' r = '+str(self.__r)

def __repr__(self):
return str(self)

z = CiagArytmetyczny(1,1)
x = CiagArytmetyczny(100,1)
#print(x+z)

'''
Zadanie 9
Napisz klasę CiągArytmetycznyZeSlownikiem, która dziedziczy po klasie
CiągArtymetyczny. Zaimplementuj w niej metodę __setitem__, która będzie
zapisywać wywołane klucze i wartości do prywatnego słownika.
Klasa powinna zapewniać dostęp do tego słownika, ale bez możliwości jego edycji.
'''

class CiagArytmetycznyZeSlownikiem(CiagArytmetyczny):

def __setitem__(self, key, value):
if not ('_CiagArytmetycznyZeSlownikiem__sl' in dir(self)):
self.__sl = {}
self.__sl[key] = value

@property
def sl(self):
if not ('_CiagArytmetycznyZeSlownikiem__sl' in dir(self)):
self.__sl = {}
return self.__sl.copy()

def __str__(self):
return 'CiagArytmetycznyZeSlownikiem a1 = '+str(self.a1)+' r = '+str(self.r)

def __add__(self, other):
return CiagArytmetycznyZeSlownikiem(self.a1 + other.a1, self.r + other.r)

y = CiagArytmetycznyZeSlownikiem(50,1)

</source>

TI/Skrypty z zajęć

2020-05-26T10:49:57Z

Tgub:

TI/Skrypty z zajęć/k5a

2020-05-20T22:19:52Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed May 20 11:56:29 2020 @author: Tomek """ class A(): def __nazwa(self): return 'klasa A'..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 20 11:56:29 2020

@author: Tomek
"""

class A():
def __nazwa(self):
return 'klasa A'

def aa(self):
print('jestem metoda aa z ' + self.__nazwa())

def a(self):
print('jestem metoda a z ' + self.__nazwa())

class B(A):
def __nazwa(self):
return 'klasa B'

def bb(self):
print('jestem metoda bb z ' + self.__nazwa())

def aa(self):
print('jestem metoda aa z ' + self.__nazwa())

#class C(A,B):
# def cc(self):
# print('jestem metoda cc z klasy C')

a = A()
a.__c = 100
b = B()
#c = C()
</source>

TI/Skrypty z zajęć/k5

2020-05-20T22:18:40Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed May 20 11:17:56 2020 @author: Tomek """ class A(): def __str__(self): return 'Jestem obie..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 20 11:17:56 2020

@author: Tomek
"""

class A():
def __str__(self):
return 'Jestem obiektem klasy A'

def __call__(self, *args):
return 'Jestem metoda call wywolana z argumentami '+str(args)

def __getitem__(self,index):
return str(index)

def __setitem__(self,ind,val):
print('index =', ind, 'value =', val)

a = A()

#a+b = a.__add__(b)
#a(x) = a.__call__(x)
#a[n] = a.__getitem__(x)

class naszSlownik():
def __init__(self,dic={}):
self.__sl = dic.copy()

def __str__(self):
return 'Nasz Slownik ' + str(self.__sl)

def __getitem__(self,index):
return self.__sl[index]

def __setitem__(self,ind,val):
if ind == 1:
print('nie wolno Ci!!!')
return None
self.__sl[ind] = val

a = {1:2,2:3,3:4}
b = naszSlownik(a)
a[1] = 100
print(b)

</source>

TI/Skrypty z zajęć

2020-05-20T22:17:12Z

Tgub:

TI/Skrypty z zajęć/kz4-6

2020-05-19T11:54:58Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Tue May 19 11:03:13 2020 @author: Tomek """ ''' Zadanie 4. Dopisz w klasie Wielomian (omawianej na zajęc..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Tue May 19 11:03:13 2020

@author: Tomek
"""

'''
Zadanie 4.
Dopisz w klasie Wielomian (omawianej na zajęciach) metodę "pochodna"
która zwraca Wielomian odpowiadający pochodnej danego Wielomianu (self).

Zadanie 5.
Dopisz do klasy Wielomian metodę "calka" zwracającą Wielomian
(nazwijmy go chwilowo w) odpowiadający całce nieoznaczonej z danego Wielomianu.
Przyjmijmy w(0) = 0.

Zadanie 6.
W klasie Wielomian zaimplementuj operator mnożenia wielomianów.

'''
import numpy as np

class Wielomian():
def __init__(self,*args):
self.__a = args
self.__n = len(args)

def __str__(self):
if self.__n>0:
wynik = str(self.__a[0])
for i in range(1,self.__n):
wynik += ' + ' + str(self.__a[i]) + '*x^' + str(i)
return wynik
return '0'

def __call__(self, x):
return sum([self.__a[i] * x**i for i in range(self.__n)])

def __add__(self, other):
wynik = np.zeros(max(self.__n, other.__n))

for i in range(self.__n):
wynik[i] += self.__a[i]

for i in range(other.__n):
wynik[i] += other.__a[i]

return Wielomian(*tuple(wynik))

#Zadanie 4
def pochodna(self):
return Wielomian(*[i*self.__a[i] for i in range(1,self.__n)])

#Zadanie 5
def calka(self):
return Wielomian(0,*[self.__a[i]/(i+1) for i in range(self.__n)])

# def __mul__(self, other):
# wynik = np.zeros(self.__n + other.__n - 1)
# for i in range(self.__n):
# for j in range(other.__n):
# #(self.__a[i] * x^i )*(other.__a[j] * x^j ) = self.__a[i]*other.__a[j] * x^(i+j)
# wynik[i+j] += self.__a[i]*other.__a[j]
# return Wielomian(*wynik)

#Zadanie 6 - splot
def __mul__(self, other):
#print(np.outer(self.__a,other.__a))
a = np.outer(self.__a,other.__a)[:,::-1]
return Wielomian(*[a.trace(i) for i in range(other.__n-1,-self.__n,-1)]) #[2,1,0,-1]]

w1 = Wielomian(3,4)
w2 = Wielomian(2,1)

# (3 , 4)
# (2) 6 8
# (1) 3 4

# 6 + (3+8)* x^1 + 4 * x^2

print(w1)
print(w2)
print(w2*w1)

#w1 = Wielomian(1,20,3,4)

#1 + 2*x^1 + 3*x^2 + 4*x^3 ->(1,20,3,4)
# (0,1,2,3)
#pochodna to:
#20*1 + 3*2*x^1 + 4*3*x^2 -> (20,6,12)
#
#calka to: (a,b,c,d,e)
# (0,1,2,3,4)

# (b,2*c,3*d,4*e) = (1,20,3,4)
# b=1, c=20/2 d = 3/3, e = 4/4
# (0,1,10,1,1)
#

</source>

TI/Skrypty z zajęć

2020-05-19T11:53:49Z

Tgub:

TI/Skrypty z zajęć

2020-05-19T11:52:25Z

Tgub:

TI/Skrypty z zajęć/k4

2020-05-13T21:37:00Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed May 13 11:17:39 2020 @author: Tomek """ import numpy as np class Liniowa(): def __init__(self, a,..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 13 11:17:39 2020

@author: Tomek
"""
import numpy as np

class Liniowa():
def __init__(self, a, b):
self.__a = float(a)
self.__b = float(b)

# @property
# def a(self):
# return self.__a
#
# @property
# def b(self):
# return self.__b

def __str__(self):
return 'Funkcja liniowa '+str(self.__a)+'*x+'+str(self.__b)

def __repr__(self):
return self.__str__()

#print(f1) = print( str(f1) ) = print( f1.__str__() )
#f1(x) = f1.__call__(x)

def __call__(self, x):
return self.__a*x + self.__b

def __add__(self, other):
return Liniowa(self.__a + other.__a, self.__b + other.__b)

def __mul__(self, other):
return Liniowa(self.__a * other.__b + self.__b * other.__a, self.__b*other.__b)

f1 = Liniowa(1,1)
f2 = Liniowa(2,2)

#print(f1)
#print(f2)

#Wielomian(a,b) = a+b*x
#Wielomian(a,b,c) = a+b*x+c*x^2

class Wielomian():
def __init__(self,*args):
self.__a = args
self.__n = len(args)

def __str__(self):
if self.__n>0:
wynik = str(self.__a[0])
for i in range(1,self.__n):
wynik += ' + ' + str(self.__a[i]) + '*x^' + str(i)
return wynik
return '0'

def __call__(self, x):
# if self.__n>0:
# wynik = self.__a[0]
# for i in range(1,self.__n):
# wynik += self.__a[i] * x**i
# return wynik
# return 0
return sum([self.__a[i] * x**i for i in range(self.__n)])

def __add__(self, other):
wynik = np.zeros(max(self.__n, other.__n))

for i in range(self.__n):
wynik[i] += self.__a[i]

for i in range(other.__n):
wynik[i] += other.__a[i]

return Wielomian(*tuple(wynik))

def __mul__(self, other):
# (3 , 4)
# (2) 6 8
# (1) 3 4

# 6 + (3+8)* x^1 + 4 * x^2

pass

w1 = Wielomian(3,4)
w2 = Wielomian(2,1)

print(w1)
print(w2)

</source>

TI/Skrypty z zajęć/kz1-3

2020-05-13T21:35:56Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Tue May 12 11:14:04 2020 @author: Tomek """ ''' Zadanie 1. Utwórz klasę Punkt1, która będzie służy..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Tue May 12 11:14:04 2020

@author: Tomek
"""

'''
Zadanie 1. Utwórz klasę Punkt1, która będzie służyła do reprezentowania punktu
na płaszczyźnie. Klasa powinna mieć dwa prywatne pola (współrzędne punktu),
konstruktor (chodzi o metodę __init__) oraz metody: get_x, get_y, set_x, set_y,
odlegloscOdZera (liczy odległość od zera),
nachylenie (współczynnik kierunkowy prostej przechodzącej przez zero i ten punkt),
__str__ (opis punktu postaci (x; y)).

Zadanie 2. Utwórz klasę Punkt2, która jest kopią klasy Punkt1,
ale zamiast metod get_x, get_y, set_x, set_y posiada atrybuty x i y utworzone za pomocą property.

Zadanie 3. Utwórz klasę Kwadrat. Obiekty tej klasy powinny:
przechowywać długość boku kwadratu w postaci zmiennej prywatne
( ale zapewnić do niej dostęp beż możliwości zmiany wartości - dekorator property),
posiadać reprezentację tekstową, posiadać metody zwracające pole i obwód kwadratu.'''

class Punkt1():
def __init__(self, x, y):
self.__x = float(x)
self.__y = float(y)

def get_x(self):
return self.__x

def get_y(self):
return self.__y

def set_x(self,x):
self.__x = float(x)

def set_y(self,y):
self.__y = float(y)

def odlegloscOdZera(self):
return (self.__x*self.__x+self.__y*self.__y)**(0.5)

def nachylenie(self):
return self.__y/self.__x

def __str__(self):
return '('+str(self.__x)+'; '+str(self.__y)+')'

class Punkt2():
def __init__(self, x, y):
self.__x = float(x)
self.__y = float(y)

def __get_x(self):
return self.__x

def __get_y(self):
return self.__y

def __set_x(self,x):
self.__x = float(x)

def __set_y(self,y):
self.__y = float(y)

x = property(__get_x,__set_x)
y = property(__get_y,__set_y)

def odlegloscOdZera(self):
return (self.__x*self.__x+self.__y*self.__y)**(0.5)

def nachylenie(self):
return self.__y/self.__x

def __str__(self):
return '('+str(self.__x)+'; '+str(self.__y)+')'

class Kwadrat():
def __init__(self, bok):
self.__a = bok

@property
def bok(self):
return self.__a

def __str__(self):
return 'Kwadrat o boku '+str(self.bok)

def obwod(self):
return 4*self.__a

def pole(self):
return self.__a**2

class Punkt3():
def __init__(self, x, y):
self.__wsp = [float(x),float(y)]

@property
def wsp(self):
return self.__wsp[:]

</source>

TI/Skrypty z zajęć

2020-05-13T18:25:25Z

Tgub:

TI/Skrypty z zajęć/k3

2020-05-06T15:00:09Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed May 6 10:53:01 2020 @author: Tomek """ class wektor2D(): def __init__(self, x ,y): self...."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed May 6 10:53:01 2020

@author: Tomek
"""

class wektor2D():
def __init__(self, x ,y):
self.__x = int(x)
self.__y = int(y)

def __get_x(self):
return self.__x

def __set_x(self,x):
self.__x = int(x)

x = property(__get_x, __set_x)

def __get_y(self):
return self.__y

def __set_y(self,y):
self.__y = int(y)

y = property(__get_y, __set_y)

# @property
# def x(self):
# return self.__x

def __str__(self):
return 'wektor 2D: ' + str(self.__x) + ', ' + str(self.__y)

def __repr__(self):
return self.__str__()

def __dlugosc(self):
return ((self.__x)**2 + (self.__y)**2)**(0.5)

def __abs__(self):
return self.__dlugosc()

def kwadratowa(self, x):
return self.__x*x

def mnozenie(self,mnoznik):
self.__x = int(mnoznik) * self.__x
self.__y = int(mnoznik) * self.__y

a = wektor2D(3,4)
print(a)
</source>

TI/Skrypty z zajęć/k2

2020-05-06T14:58:41Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 22 12:23:28 2020 @author: Tomek """ ''' klasa - pracownikUW atrybuty: imie, nazwisko, wydzia..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 22 12:23:28 2020

@author: Tomek
"""

'''
klasa - pracownikUW
atrybuty: imie, nazwisko, wydział

objekt - TG jest obiektem klasy człowiek
imie = 'Tomasz'
nazwisko = 'Gubiec'
wydział = 'Fizyki'

'''

class pracownikUW():
def __init__(self, imie, nazwisko, wydzial='Fizyki'): #inicjacja nowego obiektu, ustawianie wartosci zmiennych
self.Imie = imie
self.Nazwisko = nazwisko
self.Wydzial = wydzial

def __str__(self):
return 'pracownik UW: ' + str(self.Imie) + ' ' + str(self.Nazwisko)

def __repr__(self):
return self.__str__() + ' z Wydziału ' + str(self.Wydzial)

#TG = pracownikUW # nowa nazwa 'TG' dla klasy prawcownikUW. TG - jest teraz klasa
TG = pracownikUW('Tomasz','Gubiec','Fizyki') # tworzy obiekt klasy pracownikUW o nazwie TG
JK = pracownikUW('Jan', 'Kowalski', 'Chemii')

print(TG)
print(JK)

</source>

TI/Skrypty z zajęć

2020-05-06T14:57:09Z

Tgub:

TI/Skrypty z zajęć/9

2020-04-29T11:10:22Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 29 11:31:12 2020 @author: Tomek """ ''' W tym zadaniu napiszemy automat komórkowy, który będz..."

<source lang="python">

# -*- coding: utf-8 -*-
"""
Created on Wed Apr 29 11:31:12 2020

@author: Tomek
"""

'''
W tym zadaniu napiszemy automat komórkowy, który będzie bardzo uproszczonym modelem sterty piachu.
Automat działa na prostokątnej tablicy (przyjmijmy 100 na 100). Początkowo, każda z komórek przyjmuje
losową wartość ze zbioru [0,1,2,3]. Dynamika modelu jest następująca:
1. Losowo wybieramy jedną komórkę w tablicy i zwiększamy przechowywaną tam liczbę o jeden.
2. Mówimy że układ jest niestabilny, gdy gdziekolwiek w tablicy znajduje się wartość 4.
3. Jeżeli układ jest niestabilny, losowo wybieramy jedną z komórek z wartością 4.
Zmieniamy jej wartość na 0, natomiast wartości sąsiadujących komórek (czterech, lub mniej jeżeli jesteśmy przy brzegu)
zwiększamy o jeden.
4. Powtarzamy punkt 3 aż do momentu gdy układ jest stabilny (nie jest niestabilny).
Liczymy ile razy trzeba było powtórzyć punkt 3 aby dojść do punktu 4 i zapisujemy tę liczbę (N) w oddzielnej liście.
Powtarzamy punkty 1-4 tysiąc razy. Zadanie polega na wykreśleniu histogramu z tysiąca liczb N odpowiadających kolejnym powtórzeniom.
Wykonaj animację ostatnich stu powtórzeń punktów 1-4.
'''

import numpy as np
import pylab as py
import matplotlib.pyplot as plt
import matplotlib.animation as animation

Nx = 50+2
Ny = 50+2

tab = np.random.randint(4, size = (Nx,Ny))

def zerujBrzegi():
global tab
tab[0,:] = 0
tab[-1,:] = 0
tab[:,0] = 0
tab[:,-1] = 0
zerujBrzegi()
Nki = []
klatki = []

for i in range(1000):
#punkt 1
x = np.random.randint(1,Nx-1)
y = np.random.randint(1,Ny-1)
tab[x,y] +=1
#punkt 3
N = 0 #licznik powt
while np.sum(tab>3):
N += 1
ktory = np.random.randint(np.sum(tab>3))
punkty = np.nonzero(tab>3)
x = punkty[0][ktory]
y = punkty[1][ktory]
tab[x,y] -= 4
tab[x+1,y] += 1
tab[x-1,y] += 1
tab[x,y+1] += 1
tab[x,y-1] += 1
zerujBrzegi()
if (i>900):
klatki.append(np.copy(tab))
Nki.append(N)
print(len(klatki))

#print(Nki)
#py.hist(Nki)

fig = plt.figure( figsize=(8,8) )
im = plt.imshow(tab, cmap="Greys")
def animuj(i):
im.set_array(klatki[i])
return [im] #magia tutaj!!!!
ani = animation.FuncAnimation(fig, animuj, frames = len(klatki), interval = 100)
plt.show()
</source>

TI/Skrypty z zajęć

2020-04-29T11:09:02Z

Tgub:

TI/Skrypty z zajęć/8

2020-04-23T23:22:12Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Mon Apr 20 15:14:18 2020 @author: Tomek """ import numpy as np import matplotlib.pyplot as plt import matp..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 20 15:14:18 2020

@author: Tomek
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

R = np.zeros((11,18))
R[4:7,5:13]=1
R[5,6]=0
R[5,11]=0

def step_a(a):
result = np.zeros(a.shape)
for x in range(a.shape[0]):
for y in range(a.shape[1]):
#liczenie sasiadow
nei = np.sum(a[max(x-1,0):x+2,max(y-1,0):y+2])-a[x,y]
if nei==3: result[x,y] = 1
if nei==2: result[x,y] = a[x,y]
return result

def animuj(i):
global R
R = step_a(R)
im.set_array(R)
return [im] #magia tutaj!!!!

fig = plt.figure( figsize=(8,8) )
im = plt.imshow(R, cmap="Greys")
ani = animation.FuncAnimation(fig, animuj, frames = 20, interval = 1000)

plt.show()

</source>

TI/Skrypty z zajęć/hanoi

2020-04-23T23:21:50Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 22 10:19:10 2020 @author: Tomek """ """ Opis zagadnienia dostępny jest w załączonym nagraniu ze..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 22 10:19:10 2020

@author: Tomek
"""
"""
Opis zagadnienia dostępny jest w załączonym nagraniu ze spotkania.
Należy napisać funkcję o nazwie "hanoi", która jako parametry przyjmuje:
n - liczbę dysków do przeniesienia,
z - nazwę wieży z której przenosimy,
przez - nazwę wieży pośredniczącej,
do - nazwę wieży docelowej.
Funkcja ma wypisywać kolejność ruchów prowadzących do przeniesienia "n" dysków z wieży "z" do wieży "do".
Przykład: hanoi(2, 'A' , 'B' , 'C' ) powinno wyświetlić:
"Przenieś dysk z A do B
Przenieś dysk z A do C
Przenieś dysk z B do C"
"""

def hanoi(n, z, przez, do):
"""Przenieś (n-1) dysków z A do B przez C
Przenieś dysk z A do C
Przenieś (n-1) dysków z B do C przez A """
if n>0:
hanoi(n-1, z, do, przez)
print('Przednies dysk z', z, 'do', do)
hanoi(n-1, przez, z, do)

hanoi(7,'A','B','C')

</source>

TI/Skrypty z zajęć/k1

2020-04-23T23:21:38Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 22 12:23:28 2020 @author: Tomek """ ''' klasa - pracownikUW atrybuty: imie, nazwisko, wydzia..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 22 12:23:28 2020

@author: Tomek
"""

'''
klasa - pracownikUW
atrybuty: imie, nazwisko, wydział

objekt - TG jest obiektem klasy człowiek
imie = 'Tomasz'
nazwisko = 'Gubiec'
wydział = 'Fizyki'

'''

class pracownikUW():
def __init__(self, imie, nazwisko, wydzial='Fizyki'): #inicjacja nowego obiektu, ustawianie wartosci zmiennych
self.Imie = imie
self.Nazwisko = nazwisko
self.Wydzial = wydzial

TG = pracownikUW # nowa nazwa 'TG' dla klasy prawcownikUW. TG - jest teraz klasa
TG = pracownikUW('Tomasz','Gubiec','Fizyki') # tworzy obiekt klasy pracownikUW o nazwie TG

</source>

TI/Skrypty z zajęć

2020-04-23T23:19:45Z

Tgub:

TI/Skrypty z zajęć/7

2020-04-15T13:40:06Z

Tgub:

<source lang="python">
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt

'''
• Żywa komórka, która ma mniej niż dwóch żywych sąsiadów umiera z „osamotnienia”
• Żywa komórka, która ma dwóch lub trzech żywych sąsiadów pozostaje żywa
• Żywa komórka, która ma więcej niż trzech żywych sąsiadów umiera z „przeludnienia”
• Każda martwa komórka z dokładnie trzema żywymi sąsiadami staje się żywa poprzez „reprodukcję”
'''
R = np.array([[0,0,0,0,0],[0,0,1,1,0],[0,1,1,0,0],[0,0,1,0,0],[0,0,0,0,0]])
#R = np.array([[0,0,0,0,0],[0,0,0,0,0],[0,1,1,1,0],[0,0,0,0,0],[0,0,0,0,0]])

def step_a(a):
result = np.zeros(a.shape)
for x in range(a.shape[0]):
for y in range(a.shape[1]):
#liczenie sasiadow
nei = np.sum(a[max(x-1,0):x+2,max(y-1,0):y+2])-a[x,y]
if nei==3: result[x,y] = 1
if nei==2: result[x,y] = a[x,y]
return result

def step_b(a):
result = np.zeros(a.shape)
temp = np.zeros((a.shape[0]+2,a.shape[1]+2))
temp[1:-1,1:-1] = a
for x in range(a.shape[0]):
for y in range(a.shape[1]):
#liczenie sasiadow
nei = np.sum(temp[x:x+3,y:y+3])-temp[x+1,y+1]
if nei==3: result[x,y] = 1
if nei==2: result[x,y] = a[x,y]
return result

def step_c(a):
neib = [(-1,-1),(-1,0),(-1,1),(1,-1),(1,0),(1,1),(0,-1),(0,1)]
temp = np.zeros((a.shape[0]+2,a.shape[1]+2))
temp[1:-1,1:-1] = a

result = np.zeros(a.shape)
for x in range(a.shape[0]):
for y in range(a.shape[1]):
#liczenie sasiadow
nei = np.sum([temp[1+x+xx,1+y+yy] for xx,yy in neib])
if nei==3: result[x,y] = 1
if nei==2: result[x,y] = a[x,y]
return result

for n in range(15):
plt.imshow(R, cmap="Greys")
plt.show()
R = step_c(R)

</source>

TI/Skrypty z zajęć/7 sudoku

2020-04-15T13:39:21Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 15 11:16:40 2020 @author: Tomek """ p = np.array([[0,0,6,0,3,0,7,0,8], [0,3,0,0,0,0..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 15 11:16:40 2020

@author: Tomek
"""

p = np.array([[0,0,6,0,3,0,7,0,8],
[0,3,0,0,0,0,0,0,1],
[2,0,0,0,0,0,6,0,0],
[1,0,0,3,5,0,0,0,6],
[0,7,9,0,4,0,1,5,0],
[5,0,0,0,1,7,0,0,4],
[0,0,2,0,0,0,0,0,7],
[6,0,0,0,0,0,0,8,0],
[4,0,7,0,6,0,2,0,0]])

def rysuj(t):
for i in range(9):
tab=t[i]
print(tab[0],tab[1],tab[2],'|',tab[3],tab[4],tab[5],'|',tab[6],tab[7],tab[8])
if (i==2) or (i==5):
print('------+-------+------')
print()

def Sudoku_tester(tab,x,y,n):
if tab[x,y]!=0: return False
if (n in tab[x,:]): return False
if (n in tab[:,y]): return False
if (n in tab[3*(x//3):3*(x//3)+3,3*(y//3):3*(y//3)+3]): return False
return True

def sudoku(tab):
for x in range(9):
for y in range(9):
if tab[x,y]==0:
for n in range(1,10):
if Sudoku_tester(tab,x,y,n):
tab[x,y]=n
sudoku(tab)
tab[x,y]=0
return
rysuj(tab)
return

sudoku(p)

#rysuj(p)
#for n in range(1,10):
# print(n, Sudoku_tester(p,3,5,n))

#def silnia(n):
# if n==0: return 1
# return n*silnia(n-1)
#
#print(silnia(200))
</source>

TI/Skrypty z zajęć/7

2020-04-15T13:38:42Z

Tgub: Utworzono nową stronę "<source lang="python"> </source>"

TI/Skrypty z zajęć

2020-04-15T13:37:40Z

Tgub:

TI/Skrypty z zajęć

2020-04-15T13:37:01Z

Tgub:

TI/Skrypty z zajęć

2020-04-15T13:36:16Z

Tgub:

TI/Skrypty z zajęć/6a

2020-04-02T08:27:34Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 1 12:13:20 2020 @author: Tomek """ # import numpy as np import pylab as py N=50 def wolfram(r):..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 1 12:13:20 2020

@author: Tomek
"""

#
import numpy as np
import pylab as py
N=50

def wolfram(r):
rule = [int(char) for char in format(r, 'b').zfill(8)]
p = np.zeros((N,N))
p[0,N//2] = 1
for t in range(1,N):
for x in range(N):
#sasiedztwo komórki x w chwili t-1
nei = [p[t-1,N-1] if x==0 else p[t-1,x-1], p[t-1,x],p[t-1,0] if x==N-1 else p[t-1,x+1]]

#przypisanie nowego stanu komórki x w chwili t na podstawie nei
#przykład nei=[1,1,0] -> odpowiada temu liczba 6 -> rule[7-6]
p[t,x]= rule[7-int(4*nei[0]+2*nei[1]+nei[2])]

return p

#pusty obrazek
image=np.zeros((16*N,16*N))

#wypelnianie obrazka
for x in range(16):
for y in range(16):
image[N*x:N*x+N,N*y:N*y+N] = wolfram(y*16+x)

py.imshow(image, interpolation='nearest',cmap='Greys')
</source>

TI/Skrypty z zajęć/6

2020-04-02T08:26:43Z

Tgub: Utworzono nową stronę "<source lang="python"> # -*- coding: utf-8 -*- """ Created on Wed Apr 1 10:18:35 2020 @author: Tomek """ import numpy as np import random plansza = np.zeros((3,3))..."

<source lang="python">
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 1 10:18:35 2020

@author: Tomek
"""

import numpy as np
import random

plansza = np.zeros((3,3))
plansza[0,0] = 1
plansza[2,2] = 2

def rysuj(plansza):
kreska = ('---+'*plansza.shape[1])[:-1]
def znak(z):
if z == 1: return ' O '
if z == 2: return ' X '
return ' '
for i in range(plansza.shape[0]):
print('|'.join([znak(liczba) for liczba in plansza[i,:]]))
if (i<plansza.shape[0]-1): print(kreska)

#vec to jednowymiarowa tablica
def sprawdz_linie(vec):
#gdy vec ma same jedynki zwraca 1
#gdy vec ma same dwojki zwraca 2
# w pozostałych przypadkach zwraca 0
for i in [1,2]:
if np.count_nonzero(vec-i) == 0: return i
return 0

def sprawdz_czy_dwa_identyczne_i_zero(vec,gracz):
if (sum(vec==0)==1) and (sum(vec==gracz)==2):
return (np.argwhere(vec==0))[0][0]

def czy_koniec():
global plansza
if (len(plansza.flatten())-np.count_nonzero(plansza)) == 0:
return 'REMIS'

wyniki=[]
for j in range(len(plansza)):
wyniki.append(sprawdz_linie(plansza[j,:]))
wyniki.append(sprawdz_linie(plansza[:,j]))
wyniki.append(sprawdz_linie(np.diag(plansza)))
wyniki.append(sprawdz_linie(np.diag(plansza[:,::-1])))

wynik=max(wyniki)
if wynik:
return 'wygral gracz '+str(wynik)

def ruch_losowy():
global plansza
mozliwe_ruchy=[]
for x in range(plansza.shape[0]):
for y in range(plansza.shape[1]):
if plansza[x,y]==0: mozliwe_ruchy.append((x,y))
ruch=random.choice(mozliwe_ruchy)
plansza[ruch[0],ruch[1]]=2

def ofensywa(gracz):
global plansza

#po wierszach
for j in range(len(plansza)):
wynik = sprawdz_czy_dwa_identyczne_i_zero(plansza[j,:],gracz)
if wynik!=None:
plansza[j,wynik]=2
return True

#po kolumnach
for j in range(len(plansza)):
wynik = sprawdz_czy_dwa_identyczne_i_zero(plansza[:,j],gracz)
if wynik!=None:
plansza[wynik,j]=2
return True

#diagonala
wynik = sprawdz_czy_dwa_identyczne_i_zero(np.diag(plansza),gracz)
if wynik!=None:
plansza[wynik,wynik]=2
return True

#antydiagonala
wynik = sprawdz_czy_dwa_identyczne_i_zero(np.diag(plansza[:,::-1]),gracz)
if wynik!=None:
plansza[wynik,plansza.shape[0]-1-wynik]=2
return True
return False

def ruch_komputera():
czy_byl_ruch = False
czy_byl_ruch = ofensywa(2)
if czy_byl_ruch==False: czy_byl_ruch = ofensywa(1)
if czy_byl_ruch==False: ruch_losowy()

while True:

#rysujemy plansze
rysuj(plansza)

#ruch gracza i
while True:
x = int(input('graczu podaj wspolrzedna x:'))
y = int(input('graczu podaj wspolrzedna y:'))
if (plansza[x,y] == 0): break
plansza[x,y] = 1

#sprawdzanie warunku konca
if czy_koniec():
print(czy_koniec())
break

#ruch komputera
ruch_komputera()

#sprawdzanie warunku konca
if czy_koniec():
print(czy_koniec())
break

</souce>

TI/Skrypty z zajęć

2020-04-02T08:25:39Z

Tgub:

TI/Skrypty z zajęć/5

2020-03-10T13:06:23Z

Tgub: Utworzono nową stronę "<source lang="python"> #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Mar 10 12:47:27 2020 @author: tgub """ import numpy as np import random plansz..."

<source lang="python">
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 10 12:47:27 2020

@author: tgub
"""
import numpy as np
import random

plansza = np.zeros((3,3))
plansza[0,0] = 1
plansza[2,2] = 2

def rysuj(plansza):
kreska = ('---+'*plansza.shape[1])[:-1]
def znak(z):
if z == 1: return ' O '
if z == 2: return ' X '
return ' '
for i in range(plansza.shape[0]):
print('|'.join([znak(liczba) for liczba in plansza[i,:]]))
if (i<plansza.shape[0]-1): print(kreska)

#vec to jednowymiarowa tablica
def sprawdz_linie(vec):
#gdy vec ma same jedynki zwraca 1
#gdy vec ma same dwojki zwraca 2
# w pozostałych przypadkach zwraca 0
for i in [1,2]:
if np.count_nonzero(vec-i) == 0: return i
return 0

def sprawdz_czy_dwa_identyczne_i_zero(vec,gracz):
if (sum(vec==0)==1) and (sum(vec==gracz)==2):
return (np.argwhere(vec==0))[0][0]

def czy_koniec():
global plansza
if (len(plansza.flatten())-np.count_nonzero(plansza)) == 0:
return 'REMIS'

wyniki=[]
for j in range(len(plansza)):
wyniki.append(sprawdz_linie(plansza[j,:]))
wyniki.append(sprawdz_linie(plansza[:,j]))
wyniki.append(sprawdz_linie(np.diag(plansza)))
wyniki.append(sprawdz_linie(np.diag(plansza[:,::-1])))

wynik=max(wyniki)
if wynik:
return 'wygral gracz '+str(wynik)

def ruch_losowy():
global plansza
mozliwe_ruchy=[]
for x in range(plansza.shape[0]):
for y in range(plansza.shape[1]):
if plansza[x,y]==0: mozliwe_ruchy.append((x,y))
ruch=random.choice(mozliwe_ruchy)
plansza[ruch[0],ruch[1]]=2

def ofensywa(gracz):
global plansza
#po wierszach
for j in range(len(plansza)):
wynik = sprawdz_czy_dwa_identyczne_i_zero(plansza[j,:],gracz)
if wynik:
plansza[j,wynik]=2
return True
#po kolumnach
for j in range(len(plansza)):
wynik = sprawdz_czy_dwa_identyczne_i_zero(plansza[:,j],gracz)
if wynik:
plansza[wynik,j]=2
return True
#diagonala
wynik = sprawdz_czy_dwa_identyczne_i_zero(np.diag(plansza),gracz)
if wynik:
plansza[wynik,wynik]=2
return True
#antydiagonala
wynik = sprawdz_czy_dwa_identyczne_i_zero(np.diag(plansza[:,::-1]),gracz)
if wynik:
plansza[wynik,plansza.shape[0]-1-wynik]=2
return True
return False

def ruch_komputera():
czy_byl_ruch = False
czy_byl_ruch = ofensywa(2)
if czy_byl_ruch==False: ruch_losowy()

while True:
#rysujemy plansze
rysuj(plansza)

#ruch gracza i
while True:
x = int(input('graczu podaj wspolrzedna x:'))
y = int(input('graczu podaj wspolrzedna y:'))
if (plansza[x,y] == 0): break
plansza[x,y] = 1
if czy_koniec():
print(czy_koniec())
break
ruch_komputera()
if czy_koniec():
print(czy_koniec())
break

</source>

TI/Skrypty z zajęć

2020-03-10T13:05:51Z

Tgub:

TI/Skrypty z zajęć/4

2020-03-04T11:53:27Z

Tgub:

<source lang="python">
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 4 10:17:21 2020

@author: tgub
"""

import numpy as np

#a = np.array(range(9)).reshape((3,3))
#print(a)
#
#s = 0
#for i in range(a.shape[0]):
# s += a[0,i]*a[1,i]
#print(s)
#
#print(np.dot(a[1,:],a[0,:]))

#poczatek k i k
plansza = np.zeros((3,3))
plansza[0,0] = 1
plansza[2,2] = 2

def rysuj(plansza):
kreska = ('---+'*plansza.shape[1])[:-1]
def znak(z):
if z == 1: return ' O '
if z == 2: return ' X '
return ' '
for i in range(plansza.shape[0]):
print('|'.join([znak(liczba) for liczba in plansza[i,:]]))
if (i<plansza.shape[0]-1): print(kreska)

rysuj(plansza)

'''
O | |
---+---+---
| X |
---+---+---
| |
'''
'''
#schemat gry
while 'sa wolne pola':
#ruch gracza i
while 'nie mam wspolrzednych wolnego pola':
'podaj wspolrzedne'
'wstaw znak'
rysuj(plansza)
'zmien gracza'
print('KONIEC GRY')

#schemat gry
i=1
while (len(plansza.flatten())-np.count_nonzero(plansza)):
#rysujemy plansze
rysuj(plansza)

#ruch gracza i
while True:
x = int(input('graczu '+str(i)+' podaj wspolrzedna x:'))
y = int(input('graczu '+str(i)+' podaj wspolrzedna y:'))
if (plansza[x,y] == 0): break
plansza[x,y] = i

#zmien gracza
i = 1 + i%2

print('KONIEC GRY')
'''
#vec to jednowymiarowa tablica
def sprawdz_linie(vec):
#gdy vec ma same jedynki zwraca 1
#gdy vec ma same dwojki zwraca 2
# w pozostałych przypadkach zwraca 0
for i in [1,2]:
if np.count_nonzero(vec-i) == 0: return i
return 0

i=1
while True:
#rysujemy plansze
rysuj(plansza)

#ruch gracza i
while True:
x = int(input('graczu '+str(i)+' podaj wspolrzedna x:'))
y = int(input('graczu '+str(i)+' podaj wspolrzedna y:'))
if (plansza[x,y] == 0): break
plansza[x,y] = i

if (len(plansza.flatten())-np.count_nonzero(plansza)) == 0:
print('REMIS')
break

wyniki=[]
for j in range(len(plansza)):
wyniki.append(sprawdz_linie(plansza[j,:]))
wyniki.append(sprawdz_linie(plansza[:,j]))
wyniki.append(sprawdz_linie(np.diag(plansza)))
wyniki.append(sprawdz_linie(np.diag(plansza[:,::-1])))

wynik=max(wyniki)
if wynik:
print('wygral gracz '+str(wynik))
break

#zmien gracza
i = 1 + i%2

</source>

TI/Skrypty z zajęć/4

2020-03-04T11:24:29Z

Tgub:

TI/Skrypty z zajęć/4

2020-03-04T10:41:27Z

Tgub: Utworzono nową stronę "<source lang="python"> #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Mar 4 10:17:21 2020 @author: tgub """ import numpy as np #a = np.array(range..."

TI/Skrypty z zajęć

2020-03-04T10:41:05Z

Tgub:

*[[TI/Skrypty z zajęć/1|1]]
*[[TI/Skrypty z zajęć/2|2]]
*[[TI/Skrypty z zajęć/3|3]]
*[[TI/Skrypty z zajęć/4|4]]