%%html
<iframe src='https://docs.python.org/3/library/stdtypes.html#truth', width=100%, height=400></iframe>
def myReversed(it):
s = Stack()
for x in it :
s.push(x)
z = []
#while not s.isEmpty() :
while s :
z.append(s.pop())
return z
Stack(it)
Stack
objektuak iteragarriak baliradef myReversed(it):
return Stack(it)
→ Interesgarria litzateke bi propietate hauek inplementatzea
Stack.push
→ list.append
Stack.pop
→ list.pop
len(Stack)
→ len(list)
iter(Stack)
$\not \Rightarrow$ iter(list)
class Stack(object):
def __init__(self,it):
pass
def push(self,value):
pass
def top(self):
pass
def pop(self):
pass
def __len__(self):
pass
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
#self.z = []
# for x in it :
# self.push(x) (edo self.z.append(x))
self.z = list(it)
def push(self,value):
pass
def top(self):
pass
def pop(self):
pass
def __len__(self):
pass
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
pass
def pop(self):
pass
def __len__(self):
pass
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
pass
def __len__(self):
pass
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
return self.z.pop()
def __len__(self):
pass
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
return self.z.pop()
def __len__(self):
return len(self.z)
def __iter__(self):
pass
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
return self.z.pop()
def __len__(self):
return len(self.z)
def __iter__(self):
# hustu egin behar dugu!!!
#return iter(self.z[::-1])
# kontuz honekin..
#return iter(list(self))
x = list()
while self.z :
x.append(self.z.pop())
#while self :
# x.append(self.pop())
return iter(x)
def __iter__(self):
return (self.pop() for _ in range(len(self)))
def __iter__(self):
while self :
yield self.pop()
s = Stack(range(10))
print(len(s))
#print(list(s))
print(*s)
print(len(s))
s = Stack()
for i in "aeiou":
s.push(i)
print(f'top: {s.top()} len: {len(s)}')
print('-----')
while s :
x = s.pop()
print(f'pop: {x} len: {len(s)}')
s = Stack()
for i in "aeiou":
s.push(i)
print(f'top: {s.top()} len: {len(s)}')
print('-----')
for x in s:
print(f'pop: {x} len: {len(s)}')
str
?¶print(Stack("aeiou"))
:---
'u'
'o'
'i'
'e'
'a'
---
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
return self.z.pop()
def __len__(self):
return len(self.z)
def __iter__(self):
return (self.pop() for _ in range(len(self)))
def __str__(self):
return '\n'.join(['---'] + [repr(x) for x in self.z[::-1]] + ['---'])
s = Stack("aeiou")
print(s)
print(len(s))
print(Stack([1,2,3,'kaixo',1.3]))
repr
?¶s == eval(repr(s))
bete dadin saiatuStack([., ., ., ...])
erabili==
→ __eq__()
class Stack(object):
def __init__(self,it=()):
self.z = list(it)
def push(self,value):
self.z.append(value)
def top(self):
return self.z[-1]
def pop(self):
return self.z.pop()
def __len__(self):
return len(self.z)
def __iter__(self):
return (self.pop() for _ in range(len(self)))
def __str__(self):
return '\n'.join(['---'] + [repr(x) for x in self.z[::-1]] + ['---'])
def __repr__(self):
return f'Stack({repr(self.z)})'
def __eq__(self,other):
return type(other) == Stack and self.z == other.z
s = Stack([1,2,3,'kaixo',1.3,(5,6),[64,24,(23,234,265)]])
print(s)
print(repr(s))
s == eval(repr(s)) , s == Stack() , s == Stack(range(10)) , s == "kaixo"
* , /
→ + , -
InFix | PostFix |
---|---|
A + B | A B + |
A + B * C | A B C * + |
(A + B) * C | A B + C * |
A + B * C + D | A B C * + D + |
(A + B) * (C + D) | A B + C D + * |
A * B + C * D | A B * C D * + |
A + B + C + D | A B + C + D + |
Adibidea: $\;\;3 \;\; 4 \; + \; 10 \;\; * \;\; \equiv \;\; (3+4) * 10$
# sarrerako sekuentzia: 3 4 + 10 *
s = Stack()
# 3 --> pilara
s.push(3)
# 4 --> pilara
s.push(4)
# + --> bi eragileak atera eta emaitza pilara
b = s.pop()
a = s.pop()
s.push(a+b)
# 10 --> pilara
s.push(10)
# * --> bi eragileak atera eta emaitza pilara
b = s.pop()
a = s.pop()
s.push(a*b)
# EMAITZA: pilako gailurra (elementu bakarra dago)
e = s.pop()
print(e,len(s))
# sarrera: hutsunez banandutako karaktere katea
def eval_postfix(txt):
s = Stack()
for x in txt.split():
if x in '+-*/' :
b = s.pop()
a = s.pop()
if x == '+' :
s.push(a+b)
elif x == '-' :
s.push(a-b)
elif x == '*' :
s.push(a*b)
else :
s.push(a/b)
else :
s.push(eval(x))
return s.pop()
print(((3+4)*10), eval_postfix('3 4 + 10 *'))
print(((7+3)*8/2+4), eval_postfix('7 3 + 8 * 2 / 4 +'))
print((8*(7+3)/2+4), eval_postfix('8 7 3 + * 2 / 4 +'))
print((4+8*(7+3)/2), eval_postfix('4 8 7 3 + * 2 / +'))
70 70 44.0 44.0 44.0 44.0 44.0 44.0
Adibidez: 1 * 2 + 3 * 4
→ 1 2 * 3 4 * +
# Sarrerako sekuentzia: 1 * 2 + 3 * 4
s = Stack()
z = []
# 1 --> irteerara
z.append(1)
# * --> pilako lehentasun handiko eragileak irteerara eta eragile hau pilara
print(len(s) == 0)
s.push('*')
# 2 --> irteerara
z.append(2)
# + --> pilako lehentasun handiko eragileak irteerara eta eragile hau pilara
print(s.top() == '*')
z.append(s.pop())
print(len(s) == 0)
s.push('+')
# 3 --> irteerara
z.append(3)
# * --> pilako lehentasun handiko eragileak irteerara eta eragile hau pilara
print(s.top() == '+')
s.push('*')
# 4 --> irteerara
z.append(4)
# pila hustu
z.extend(s)
print(z,len(s))
# sarrera: hutsunez banandutako karaktere katea
# irteera: hutsunez banandutako karaktere katea
def infix2postfix(txt):
s = Stack()
z = []
priority = {'*':2 , '/':2 , '+':1 , '-':1}
for x in txt.split():
if x in '+-*/' :
px = priority[x]
while s and priority[s.top()] >= px :
z.append(s.pop())
s.push(x)
else :
z.append(x)
z.extend(s)
return ' '.join(z)
frogak='''
A + B
A + B * C
A + B * C + D
A * B + C * D
A + B + C + D
A / B * C / D
A / B * C + D * E - F / G
'''
for x in frogak.strip().split('\n') :
print(f'{x} --> {infix2postfix(x)}')
A + B --> A B + A + B * C --> A B C * + A + B * C + D --> A B C * + D + A * B + C * D --> A B * C D * + A + B + C + D --> A B + C + D + A / B * C / D --> A B / C * D / A / B * C + D * E - F / G --> A B / C * D E * + F G / -
x = "34.1 + 254 * 67"
print(eval(x))
print(infix2postfix(x))
print(eval_postfix(infix2postfix(x)))
17052.1 34.1 254 67 * + 17052.1