Code: Alles auswählen
size = 0
def test():
global size
size += 123
if __name__ == "__main__":
test()
print sizeCode: Alles auswählen
size = 0
def test():
size_add(123)
def size_add(size1)
size += size1
if __name__ == "__main__":
test()
print sizeCode: Alles auswählen
def test(size):
return size_add(size, 123)
def size_add(size, inkrement):
return size + inkrement
def main():
size = test(0)
print size
if __name__ == '__main__':
main()Code: Alles auswählen
In [1]: class Size(object):
...: def __init__(self):
...: self.size = 0
...: def add(self, number):
...: return self.size + number
...:
In [2]: size = Size()
In [3]: size.add(23)
Out[3]: 23
In [4]: size.add(42)
Out[4]: 65
Wieso Missbrauch? Das ist eine der Ideen von OOP - die Logik zusammen mit den Daten zu kapseln. Solange sich die Grösse einer Klasse in grenzen hält funktioniert das auch ganz gutSchneiderWeisse hat geschrieben:@jens: So mache ich es jetzt auch, das ist zwar in gewisser Weise ein Klassenmissbrauch, macht das Programm aber sehr viel übersichtlicher und erspart einem sehr viel Arbeit...
Code: Alles auswählen
#!/usr/bin/env python
# C style
size_struct = {'size': 10}
def size_add(struct, size):
struct['size'] += size
# Lisp style
def make_sizer(size):
return [size]
def get_size(sizer):
return sizer[0]
def set_size(sizer, size):
sizer[0] = size
return sizer
def add_size(sizer, size):
return make_sizer(get_size(sizer) + size)
def destructive_add_size(sizer, size):
return set_size(sizer, get_size(sizer) + size)
# Python OO style
class Sizer(object):
def __init__(self, size):
self.size = size
def __add__(self, other):
return self.size + other
def __iadd__(self, other):
self.size += other
return self
def __repr__(self):
return "('Sizer', %d)" % self.size
def __str__(self):
return '%d' % self.size
####
def main_sizer():
print 'C style:'
size_add(size_struct, 123)
print size_struct['size']
print 'Lisp style:'
s = make_sizer(10)
print get_size(add_size(s, 123))
print get_size(s)
destructive_add_size(s, 123)
print get_size(s)
print 'Python OO style:'
s = Sizer(10)
print s + 123
print s
s += 123
print s
print repr(s)
####
if __name__ == '__main__':
main_sizer()
Code: Alles auswählen
a=0
b=0
c=0
def f():
global a,b,c
# Teil der Funktion, der auf a, b, c zugreift oder a, b, c verändert
f()
Code: Alles auswählen
a=0
b=0
c=0
def ff(a,b,c):
# Teil der Funktion, der auf a, b, c zugreift oder a, b, c verändert
return a,b,c
a,b,c = ff(a,b,c)
Code: Alles auswählen
a+=1
c=b+2
Code: Alles auswählen
class VarHandler:
def __init__(self):
self.state1 = False
self.state2 = False
self.state3 = False
self.var1 = None
variable = VarHandler()
variable.state1 = True
print variable.state1
Code: Alles auswählen
#!/usr/bin/env python
# coding: utf8
from __future__ import absolute_import, division, print_function
def main():
state1 = False
state2 = False
state3 = False
var1 = None
state1 = True
print(state1)
if __name__ == '__main__':
main()Code: Alles auswählen
class VarHandler:
def __init__(self):
self.state1 = False
self.state2 = False
self.state3 = False
self.var1 = None
variable = VarHandler()
def main():
variable.state1 = True
print variable.state1
if __name__ == 'main':
main()
Code: Alles auswählen
def set(self,variable,value):
self.variable = value
def get(self,varaible):
return self.variable