UKUUG

Paul Waring UKUUG Chairman Manchester · Call For Papers

def main(argv):

try: 	 
  <code>

except IOError, (errno, strerror):
  sys.exit('I/O error (%s): %s' % (errno, strerror))

except ValueError:
  sys.exit('Could not find x in string %s: %s' % (pwLine, sys.exc_info()[0]))

fd = csv.reader(open('shadow','r'), delimiter=':')

ldifOut = open(ldifFile, 'w+')
ldifOut.close()

pwLine = []

for row in fd:
  if row[1] in '*LK*' 'NP' '*' '!!':
    continue

String = pwd.getpwnam(line[0])

pwLine = list(String)

index = pwLine.index('x')
pwLine.pop(index)
pwLine.insert(index, line[1])

ldifOut.write('dn: cn=' + pwLine[0] + ',' + fullDN + '\n')

output = subprocess.Popen(ldapStr, shell=True, stdout=subprocess.PIPE)
output.wait()
stdout_value = output.communicate()[0]

if __name__ == '__main__':
  main(sys.argv[1:])

>>> 7/4
1
>>>

>>> print "%10s %10d %10.2f" % ('ACME',100,123.45)
ACME	100 	 123.45
>>>

>>> f = open("data.txt","r")
>>> data = f.read(100)
>>> f.tell()
100L
>>> f.seek(500)
>>>

>>> 7/4
1.75
>>>

print("Hello World")

>>> f = open("foo")
>>> f

>>>

print("{0:10} {1:10d} {2:10.2f}".format(name,shares,price))

def factorial(n):
  result = 1
  while n > 1:
    result *= n
    n -= 1
  return result

class Rectangle(object):
  def __init__(self,width,height):
    self.width = width
    self.height = height
  def area(self):
    return self.height*self.width
  def perimeter(self):
    return 2*self.height + 2*self.width

>>> print factorial(6)
720
>>> r = Rectangle(4,5)
>>> r.area()
20
>>> r.perimeter()
18
>>>

def debugged(func):
  def call(*args,**kwargs):
    print("Calling %s" % func.__name__)
    result = func(*args,**kwargs)
    print("%s returning %r" % (func.__name__, result))
    return result
  return call

>>> def add(x,y):
…   return x+y
…
>>> add(3,4)
7
>>> add = debugged(add) 
>>> add(3,4) 
Calling add 
add returning 7 
7 
>>>

@debugged
def add(x,y):
  return x+y

import os
def debugged(func):
  # If not in debugging mode, return func unmodified
  if os.environ.get('DEBUG','FALSE') != 'TRUE':
    return func
  # Put a debugging wrapper around func
  def call(*args,**kwargs):
    print("Calling %s" % func.__name__)
    result = func(*args,**kwargs)
    print("%s returning %r" % (func.__name__, result))
    return result
  return call

def positive(x):
  "must be positive"
  return x > 0
def negative(x):
  "must be negative"
  return x < 0
def foo(a:positive, b:negative) -> positive:
  return a - b

>>> foo(3,-2)
5
>>> foo(-5,2)
-7
>>>

>>> foo.__annotations__ 
{'a': ,
 'b': ,
 'return': }
>>>

def ensure(func):
  # Extract annotation data
  return_check = func.__annotations__.get('return',None)
  arg_checks = [(name,func.__annotations__.get(name))
                 for name in func.__code__.co_varnames]
  # Create a wrapper that checks argument values and the return
  # result using the functions specified in annotations
  def assert_call(*args,**kwargs):
    for (name,check),value in zip(arg_checks,args):
      if check: assert check(value), "%s %s" % (name, check.__doc__)
    for name,check in arg_checks[len(args):]:
      if check: assert check(kwargs[name]), "%s %s" % (name, check.__ doc__)
    result = func(*args,**kwargs)
    assert return_check(result), "return %s" % return_check.__doc__
    return result
  return assert_call

@ensure
def foo(a:positive, b:negative) -> positive:
  return a - b

>>> foo(3,-2)
5
>>> foo(-5,2) 
Traceback (most recent call last):
  File "", line 1, in
  File "meta.py", line 19, in call
    def assert_call(*args,**kwargs):
AssertionError: a must be positive
>>>

class mymeta(type):
  def __new__(cls,name,bases,dict):
    print("Creating class :", name)
    print("Base classes	:", bases)
    print("Class body :", dict)
    # Create the actual class object
    return type.__new__(cls,name,bases,dict)

class Rectangle(object,metaclass=mymeta):
  def __init__(self,width,height):
    self.width = width
    self.height = height
  def area(self):
    return self.height*self.width
  def perimeter(self):
    return 2*self.height + 2*self.width

class debugmeta(type):
  def __new__(cls,name,bases,dict):
    if os.environ.get('DEBUG','FALSE') == 'TRUE':
      # Find all callable class members and put a
      # debugging wrapper around them.
      for key,member in dict.items():
        if hasattr(member,'__call__'):
          dict[key] = debugged(member)
    return type.__new__(cls,name,bases,dict)

class Rectangle(object,metaclass=debugmeta):
…

# A special dictionary that detects duplicates
class dupdict(dict):
  def __setitem__(self,name,value):
    if name in self:
      raise TypeError("%s already defined" % name)
    return dict.__setitem__(self,name,value)

# A metaclass that detects duplicates
class dupmeta(type):
  @classmethod
  def __prepare__(cls,name,bases):
    return dupdict()

class Rectangle(metaclass=dupmeta):
  def __init__(self,width,height):
    self.width = self.width
    self.height = self.height
  def area(self):
    return self.width*self.height
  # This repeated method name will be rejected (a bug)
  def area(self):
    return 2*(self.width+self.height)

@foo class Bar:
  statements

class Bar:
  statements

Bar = foo(Bar)

>>> data = {'NAME': 'Dave', 'EMAIL':'dave@dabeaz.com'}
>>> data = {k.lower():v for k,v in data.items} 
>>> data 
{'name': 'Dave', 'email': 'dave@dabeaz.com'}
>>>

bash-3.2$ 2to3 hello.py 
RefactoringTool: Skipping implicit fixer: buffer
RefactoringTool: Skipping implicit fixer: idioms
RefactoringTool: Skipping implicit fixer: ws_comma
—- hello.py (original)
+++ hello.py (refactored) 
@@ -1,1 +1,1 @@ 
-print "hello world"
+print("hello world")
RefactoringTool: Files that need to be modified:
RefactoringTool: hello.py
bash-3.2$

for line in open("somefile.txt"):
  pass

% ls -b 
image.png jalape\361o.txt readme.txt
%

>>> f = open("jalape\361o.txt")
Traceback (most recent call last):
IOError: [Errno 2] No such file or directory: 'jalapeño.txt'
>>>

>>> os.listdir(".")
['image.png', 'readme.txt']
>>> glob.glob("*.txt")
['readme.txt']
>>>

% python3.0 *.txt
Could not convert argument 2 to string
%

s = b'Hello World'	 # String of 8-bit characters

>>> f = open(b'jalape\361o.txt')
>>> os.listdir(b'.')
[b'jalape\xf1o', b'image.png', b'readme.txt']
>>>

>>> s = b'Hello' 
>>> t = "World"
>>> s+t 
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can't concat bytes to str
>>>

>>> s[2] 
108
>>>

>>> print(s)
b'Hello'
>>>

>>> sys.stdout.write(s)
Traceback (most recent call last):
  File "", line 1, in
  File "/tmp/lib/python3.0/io.py", line 1484, in write
    s.__class__.__name__)
TypeError: can't write bytes to text stream
>>>

>>> b'Your age is %d' % 42
Traceback (most recent call last):
  File "", line 1, in
TypeError: unsupported operand type(s) for %: 'bytes' and 'int'
>>>

>>> 'Hell' in s
Traceback (most recent call last):
  File "", line 1, in
TypeError: Type str doesn't support the buffer API
>>>

>>> b'Hell' in s
True
>>>


UKUUG

(the UK's Unix & Open Systems User Group)

news@UK

From the Secretariat

Jane Morrison

From the Chairman

Paul Waring

Post-AGM Discussion

Social Networks

Get Involved

Summer Conference 2009

Roger Whittaker

Open Tech 2009

Roger Whittaker

Python: an untapped resource in system administration

Corey Brune

Password-to-LDAP Conversion Script

General Notes

Conclusion

Reference

Python 3: the good, the bad, and the ugly

David Beazley

Python's C Programming Roots

Python 3: Breaking Free of Its Past

Python's Evolution Into a Framework Language

Python Metaprogramming

Metaprogramming with Decorators

Metaclasses

Head explosion

Python 3: The Good

Python 3: The Bad

Python 3: The Ugly

Conclusions

General Advice

References

Using Drupal

Android Application Development

The Art of Concurrency

Version Control with Git

Automating System Administration with Perl

Beautiful Architecture

Cloud Application Architectures

Contributors