Python: Unterschied zwischen den Versionen

Aus Info-Theke
Zur Navigation springen Zur Suche springen
Zeile 25: Zeile 25:


= Datentypen =
= Datentypen =
== String ==
* "x" und 'x' sind gleichwertig
* Formatierung
<pre>
"{:3.7f} {:s} {:07d}".format(3.14, "hello", 100)
"{0:d} / {0:x}".format(714)
"{}-{}: {}".format('abc.txt', 9, 7.99)
</pre>
== Container ==
* List: ['a', 1]; x[1] = 5; x.insert(0, 'firstItem'); x.remove('a'); ix=x.index('a'); del x[0];
* List: ['a', 1]; x[1] = 5; x.insert(0, 'firstItem'); x.remove('a'); ix=x.index('a'); del x[0];
* Tupel: t = ('a', 1); l = list(t)
* Tupel: t = ('a', 1); l = list(t)
== Spezielle Methoden/Attribute ==
* Statische Methoden:
<pre>
class X:
  @staticmethod
  def doIt(param):
      pass
X.doIt(True)
</pre>
* Feststellen, ob Attribut existiert: hasattr(instance, nameOfAttribute)
* dynamischer Code:
<pre>
exec 'import ' + module
</pre>


== Dictionary==
== Dictionary==
Zeile 73: Zeile 67:
isPartOf = s <= f
isPartOf = s <= f
diff = s - f
diff = s - f
</pre>
== Dateien ==
<pre>
with open(self._filename, "r") as fp:
  for line in fp:
    print(line)
  # fp.close() ist implizit
</pre>
</pre>


Zeile 91: Zeile 77:
</pre>
</pre>


== Formatierung ==
== Spezielle Methoden/Attribute ==
* Statische Methoden:
<pre>
class X:
  @staticmethod
  def doIt(param):
      pass
X.doIt(True)
</pre>
* Feststellen, ob Attribut existiert: hasattr(instance, nameOfAttribute)
* dynamischer Code:
<pre>
exec 'import ' + module
</pre>
 
 
= Typische Situationen =
== Externes Programm aufrufen ==
<pre>
with supbprocess.popen([ '/usr/bin/wc', '-l', file ], stdout=subprocess.PIPE) as proc:
  count = int(proc.stdout.read().decode())
</pre>
 
== Dateien ==
<pre>
<pre>
"{:3.7f} {:s} {:07d}".format(3.14, "hello", 100)
with open(self._filename, "r") as fp:
"{0:d} / {0:x}".format(714)
  for line in fp:
"{}-{}: {}".format('abc.txt', 9, 7.99)
    print(line)
  # fp.close() ist implizit
</pre>
</pre>



Version vom 27. April 2018, 10:09 Uhr

Exception

try:
   raise Exception("not allowed")
except ValueError as error:
   print('value error: ' + repr(error))
except SyntaxError as error:
   print('syntax error: ' + repr(error))
else:
    raise Exception("unknown")
try:
   doit()
finally:
   closeIt()

Regular Expression

rexpr = compile(r"([\da-z]+)")
match = rexpr.match(line)
if match != None:
   number = (int) rexpr.group(1)

Datentypen

String

  • "x" und 'x' sind gleichwertig
  • Formatierung
"{:3.7f} {:s} {:07d}".format(3.14, "hello", 100)
"{0:d} / {0:x}".format(714)
"{}-{}: {}".format('abc.txt', 9, 7.99)

Container

  • List: ['a', 1]; x[1] = 5; x.insert(0, 'firstItem'); x.remove('a'); ix=x.index('a'); del x[0];
  • Tupel: t = ('a', 1); l = list(t)

Dictionary

x = { 'key' : 'val', 'xyz': 3 }
x['key'] = value
del x['key'];
contains = 'key' in x and 'key2' not in x
size = len(x)
for pair in x.iteritems():
  key = pair[0]
for key in x.iterkeys():
  print key
  • x.itervalues()
  • x.setdefault(key[, value]): setzt Wert nur, wenn noch nicht gesetzt
  • x.keys(), x.values()
  • x.copy(): flache Kopie
  • x.update(dict): addiert dict zu x

Mengen

s = set(['y', 3]) ; f = frozenset(['y', 3]) 
for elem in s:
  print elem
size = len(s)
contains = 3 in s and 4 not in s
intersection = s & f
union = s | f
isPartOf = s <= f
diff = s - f

Typcheck

isStringOrSubclass = isinstance(aVariable, str)
isString = type(aVariable) is str
isList = type([1, 2]) is list
isDict = type({ 0:"a", 1:"b" }) is dict

Spezielle Methoden/Attribute

  • Statische Methoden:
class X:
   @staticmethod
   def doIt(param):
      pass
X.doIt(True)
  • Feststellen, ob Attribut existiert: hasattr(instance, nameOfAttribute)
  • dynamischer Code:
exec 'import ' + module


Typische Situationen

Externes Programm aufrufen

with supbprocess.popen([ '/usr/bin/wc', '-l', file ], stdout=subprocess.PIPE) as proc:
   count = int(proc.stdout.read().decode())

Dateien

with open(self._filename, "r") as fp:
  for line in fp:
     print(line)
  # fp.close() ist implizit

Klasse als Sequenz

Damit eine Klasse mit "x in classInstance" angesprochen werden kann, muss es einen Iterator geben. Im Beispiel wird dies in einer Klasse zusammengefasst:__iter__() liefert als Iterator sich selbst und __next__() implementiert diesen Iterator:

class Example:
  def __init__():
    self._nextItems = []
  def __iter__():
    self._nextItems = [1, 2, 3]
    return self
  def __next__():
    if len(self._nextItem) == 0:
      raise StopIteration
    else:
      rc = self._nextItems[0]
      del self._nextItems[0]
      return rc
  def next():
    return self.__next__()