# Python Translator

Please put small code samples here from other languages, and we will try to translate it into PythonLanguage. The goal is to ease the learning curve for Python.

In AplLanguage: +/M where M is any numeric matrix of rank 2 thru X (integer), result is another matrix of rank (x-1), where the projection is summed up. Example of APL operation on a matrix (rank 2) results in a vector (rank 1):
```     | 1 2 3 |
M = | 4 5 6 |
| 7 8 9 |

```
'' +/ (reads Plus reduce) means the operator "+" is applied to the data. For a 1 dimensional vector, it just adds everything (to a scalar of rank 0). But it works on higher dimensions, too. The above would sum to:

```     | 12 15 18 |

```
If the input were a 3d matrix, the output would be a 2d matrix resulting from summing along the third dimension. The APL standard supports matrices up to at least 63 dimensions. So although it would be easy to implement sum for a 1-vector or a 2-matrix in any language, it is more complicated to handle X dimensions, yet the APL code is still just +/M -- so this problem was obviously posed by a SmugAplWeenie?. :-)

Python bites back :)

How's this (generalised OO version):
``` class Matrix(list):
def _reduce(self, f):
try:
return Matrix([f(x) for x in zip(*self)])
except TypeError:
try:
return Matrix([Matrix(x)._reduce(f) for x in zip(*self)])
except TypeError:
return f(self)

def r_sum(self):
return self._reduce(sum)

def r_mul(self):
mul = lambda x: reduce(operator.mul, x)
return self._reduce(mul)

a = Matrix([1,2,3])
b = Matrix([[1,2,3]])
c = Matrix([[1,2,3], [4,5,6], [7,8,9]])
d = Matrix([[[1,2,3], [4,5,6], [7,8,9]],
[[10,11,12], [13,14,15], [16,17,18]],
[[19,20,21],[22,23,24], [25,26,27]]])

>>> print a.r_sum()
6
>>> print b.r_sum()
[1, 2, 3]
>>> print c.r_sum()
[12, 15, 18]
>>> print d.r_sum()
[[30, 33, 36], [39, 42, 45], [48, 51, 54]]

```
It'll hit an upper limit when it runs out of stack, but should be able to handle a 64d matrix
• Is there a test one can do beforehand to test whether the stack is sufficiently free to do what it needs to?

Not that I'm aware of - Python tends to use the SamuraiPrinciple - though you can probably estimate by analysing the algorithm. That said, you're probably better off NOT using pure python for heavy number crunching (for a low number of dimensions Python should be fine - for a large number, you'll probably run out of memory - if not experience heat death of the universe). The Numeric or NumPy? package may be suitable, however. if you do run out of stack, you could always use StacklessPython

-- TaroOgawa

In PerlLanguage: Taken from (http://www.perlmonks.net/index.pl?node_id=6940). The expected output is the primes between 2 and 99, each on a new line:

``` perl -e 'while(\$l++<99){\$_.=x;print \$l,\$/if! /^x\$|^(xx+)\1+\$/}'

```
In Python:
``` import re
for i in range(1,100):
if not re.match(r"^x\$|^(xx+)\1+\$", "x"*i):
print i

```
Or if you want to be a little bit more Pythonic (and faster too):
``` def primes(low, high):
m = re.compile(r"^x\$|^(xx+)\1+\$")
primes = [str(i) for i in range(low, high+1) if not m.match("x"*i)]
print "\n".join(primes)

```

In PerlLanguage:
``` #!/usr/local/bin/perl -w
use strict;
use Tie::File;

my \$file = shift;
my @array;

tie @array, 'Tie::File', \$file or die "\$file can't be opened:\$!\n";

\$array[1] = 'blah';                     # line 2 of the file is now 'blah'
print "[" . \$array[2] . "]\n";          # display line 3 of the file
push( @array, "new line" );             # add a line to the file

Here's what this example does.

\$ cat junk
1 SimpleType?.pm
3 bitshift.pl
4 cat
\$ ./tie_array.pl junk
[3 bitshift.pl]
\$ cat junk
1 SimpleType?.pm
blah
3 bitshift.pl
4 cat
new line

Basically I am asking what is the Python equiv. of Tie::File

```
Python:
``` #! /usr/local/bin/python
class Tie(list):
def __init__(self, filename):
self.f = open(filename, 'r+')
list.__init__(self, [line[:-1] for line in self.f])
self.f.seek(0)

def close(self):
if self.f:
for line in self:
print >> self.f, line
self.f.close()
self.f = None

def __del__(self):
self.close()

if __name__ == '__main__':
import sys
fn = sys.argv[1]
array = Tie(fn)
array[1] = 'blah'
print "[%s]" % array[2]
array.append("newline")

```

In PerlLanguage:

print __FILE__ . "[" . __LINE__ . "] here is some debug on line foo of file bar\n";

You'll want to define a HelperFunction for that. Something like this:

``` import traceback

def log(*args):
caller = traceback.extract_stack()[-2]
print "%s:%d: %s" % (caller[0], caller[1], ''.join(str(a) for a in args))

```
And using caller[2] would give you the function name.

``` class MyObject {
public MyObject() {
System.out.println("uno");
}
}

class MyClass {
private int a;
private MyObject my;

public MyClass(int a) {
this.a = a;
}

public MyClass(MyObject? my) {
this.my = my;
}

}

class MyTest {

public static void main(String args[]) {
MyClass mc1 = new MyClass(42);
MyClass mc2 = new MyClass(new MyObject());
}
}

```
You don't. Python uses DynamicTypes? and thus doesn't offer any kind of "overloading" based on argument type. The way this is typically done in Python:

class MyObject:
```    def __init__(self): print "UNO"

```
class MyClass: pass

def MyClassWithInt(a):
```    new_instance = MyClass()
new_instance.a = a
return new_instance

```
def MyClassWithObject(my):
```    new_instance = MyClass()
new_instance.my = my
return new_instance

```
if __name__ == '__main__':
```    mc1 = MyClassWithInt(42)
mc2 = MyClassWithObject(MyObject())

```
You could also use class methods as factories instead of the module-level functions used here, but there's no practical difference for this contrived example.

Printing a hello message to someone, asking for their name:

In CeeLanguage:
``` #include <stdio.h>

int main(void) {
char name[30];
scanf("%s", name);
printf("Hello, %s\n", name);
return 0;
}

```
In Python:

``` name = raw_input("What's your name? ")
print "Hello, %s" % name

```
(Note that the Python version does not suffer from the BufferOverflow bug that the C version has.)

In CeePlusPlus:
``` /*pretty sure this code would compile*/
#include <iostream.h>
main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10};
cout << "This is my array, watch as I output it";
for(int i =0;i < 10; i ++)
{
cout << arr[i];
}
cout << "\nThis is my c++ example code to output an array, I wonder what it would be in python?";

}
```
-- camthompson@shaw.ca

``` arr = range(1,11)	# alternatively: arr = [ 1,2,3,4,5,6,7,8,9,10 ]
print "This is my array, which I will output."
for i in arr:
print i,
print "\nNot so different, just a bit simpler, isn't it?"

```
If you don't mind Python's list output style, you can avoid the loop:

``` arr = range(1,11)
print 'This is my array, which I will output.'
print arr
print "Even simpler, isn't it?"

```
If you do mind Python's list output style, you can convert and trim the edges:

``` arr = range(1,11)
print 'This is my array, which I will output.'
print str(arr)[1:-1]
print "This is a bit of a cheat."

```
Or more obscurely:

``` arr = range(1,11)
print 'This is my array, which I will output.'
print ' '.join([str(i) for i in arr])
print "Rather different, isn't it?"

```
Or even more obscurely:
``` arr = range(1,11)
print 'This is my array, which I will output.'
print 10*"%s "%tuple(arr)
print "TMTOWTDI but not all are equally good."

```

In PerlLanguage: taken from http://www.perlmonks.net/index.pl?node_id=358667
``` #
# draw the pegs on the board based on the information
# contained in the board object
#
# dx, dy, radius, units are global vars
#
# \$can is a Tk::Canvas object
sub placePegs {
my \$can = shift;
my \$board = shift;
my \$hole = 0;
my \$tag;

\$tag = "HOLE_\$hole";
-fill => \$board->{'holes'}[\$hole]->{'peg'},
-tag  => [\$tag] );
\$can->bind( \$tag,  '<Button>' , [\&selectPeg, \$hole] );
\$hole++;
}

```
In Python:
``` #
# draw the pegs on the board based on the information
# contained in the board object
#
def placePegs ( can, board, width, height ):
hole    = 0
units   = 10;
dx = width  / units;
dy = height / units;

tag = "HOLE_" + str(hole)
item = can.create_oval (
fill = 'white', #\$board->{'holes'}[\$hole]->{'peg'},
tag  = tag )
# for some reason I have to pass this e thing in.
can.tag_bind( tag,  '<Button>' , lambda e, h=hole: selectPeg(e,h))

hole = hole + 1

```
mailto:sheldonplankton@yahoo.com

"e" gets the Event object. The Perl program throws it away in the linked page; that's what that first "shift" in selectPeg does. Have you read http://www.pythonware.com/library/tkinter/introduction/events-and-bindings.htm ?

From GuySteele's LL1-discuss mailing list posting:

``` (defun @eval (exp env cont)
(cond ((numberp exp) (funcall cont exp))
((stringp exp) (funcall cont exp))
((symbolp exp) (@lookup exp env cont))
((eq (first exp) 'LAMBDA)
(funcall cont (list 'CLOSURE (second exp) (rest (rest exp)) env)))
((eq (first exp) 'IF)
(@eval (second exp) env
#'(lambda (test)
(@eval (cond (test (second exp)) (t (third exp))) env cont))))
((eq (first exp) 'LETREC)
(let ((newenv (pairlis (mapcar #'first (second exp))
(make-list (length (second exp)))
env)))
(@evletrec (second exp) newenv (third exp) newenv cont)))
(t (@eval (first exp) env
#'(lambda (fn)
(@evlis (rest exp) env
#'(lambda (args) (@apply fn args cont))))))))

(defun @lookup (name env cont)
(cond ((null env) (funcall cont name))
((eq (car (first env)) name) (funcall cont (cdr (first env))))
(t (@lookup name (rest env) cont))))

(defun @evlis (exps env cont)
(cond ((null exps) (funcall cont '()))
(t (@eval (first exps) env
#'(lambda (arg)
(@evlis (rest exps) env
#'(lambda (args) (funcall cont (cons arg args)))))))))

(defun @evletrec (bindings slots body env cont)
(cond ((null bindings) (@eval body env cont))
(t (@eval (second (first bindings)) env
#'(lambda (fn)
(rplacd (first slots) fn)  ;the side effect that "ties the knot"
(@evletrec (rest bindings) (rest slots) body env cont))))))

(defun @apply (fn args cont)
(cond ((eq fn '+) (funcall cont (+ (first args) (second args))))
((eq fn '*) (funcall cont (* (first args) (second args))))
((eq fn 'print)
(princ (first args))
(fresh-line)
(funcall cont (first args)))
((eq fn 'call/cc)
(@apply (first args) (list (list 'CONTINUATION cont)) cont))
((atom fn) (funcall cont 'UNDEFINED-FUNCTION))
((eq (first fn) 'CLOSURE)
(@evlis (third fn) (pairlis (second fn) args (fourth fn))
#'(lambda (vals) (funcall cont (first (last vals))))))
((eq (first fn) 'CONTINUATION)
(funcall (second fn) (first args)))
(t (funcall cont 'UNDEFINED-FUNCTION))))

```
This implements a ContinuationPassingStyle interpreter for a Lisp-like language that has only arithmetic and call/cc. It's in CommonLisp, though most of the functions have equivalents in Scheme (and hopefully in Python too). Steele's original posting is here: http://www.ai.mit.edu/~gregs/ll1-discuss-archive-html/msg00569.html.

I'm only half doing this to be a smartass, BTW. I'm hoping to write an interpreter for a language with CallWithCurrentContinuation in the near future, and I'd rather write it in Python than Scheme. But it looks like Scheme (or CL) will be the path of least resistance at this point. -- JonathanTang

see http://www.ps.uni-sb.de/~duchier/python/continuations.html, which is a little old as you'll notice that lambdas in Python now close...

Without actually translating the code, perhaps using something along these lines (plus possibly a generator - "yield")?:
``` def add(x, y, c):
c(x+y)

def mul(x, y, c):
c(x*y)

def print_and_stop(val):
print val

def myfunc(x, y, c):
if x > 20:
mul(x, y, c)
else:
add(x, 1, lambda z: myfunc(z, y, c))
myfunc(0, 7, print_and_stop)

```
Be aware that if you plan to use heavy recursion you MUST use StacklessPython.
In PrologLanguage: very basic differentiation

```  test :-
diff(a*x^i+b*x^j+c*x^k,x,Dx),
write(Dx).
% should output i*a*x^(i-1)+j*b*x^(j-1)+k*c*x^(k-1)

diff(A+B,X,DA+DB) :-
diff(A,X,DA),diff(B,X,DB).
diff(A*X^N,X,N*A*X^(N-1)).

```
I guess this one is too hard for python (at least in comparable number of lines) It's not so much being too hard, it's just that it hasn't been written. Here's a proof of concept. It's so fragile it'll break if you breathe on it, and the remainder is left as an exercise for the reader... ;-) [permission is given to incorporate this code in any product using an OpenSourceLicence?]
``` class Var(object):
def __init__(self, name, multiplier=1, power=1, adds=None):
self.name = name
self.multiplier = multiplier
self.power = power

return self

def __mul__(self, multiplier):
if multiplier == 0:
return 0

def __pow__(self, power):
if power == 0:
return self.multiplier

def diff(self):
multiplier = self.multiplier * self.power
power = self.power - 1
out =  multiplier * Var(self.name) ** power
try:
out += elem.diff()
except AttributeError?:
pass
return out

def __str__(self):
out = ""
if self.multiplier != 0:
if self.multiplier != 1:
out = "%s*"%self.multiplier
if self.power != 0:
out += self.name
if self.power != 1:
out += "**%s"%self.power
return " + ".join(out)

x = Var("x")
z = 3*x**3 + 2*x**2 + 1*x**1 + 4*x**0

print z
print z.diff()

```
Output is:
``` 3*x**3 + 2*x**2 + x + 4
9*x**2 + 4*x + 1

```
--TaroOgawa

See PythonTranslatorHoleExample for several refactorings of a rather long Perl example into a somewhat shorter Python version

Question about translating AmbInRuby moved to AmbInPython

To Taro and other Snake masters

Also looking for more help pls.

Thanks -- DavidLiu
Moved from PythonIdioms:

Question about the StatePattern in Python: I have a class Food, and there are many instances. I want each instance to have behaviour that changes at runtime, independently of the other instances. But I want it to be 'inheritance-style', instead of the 'composition-style' which is usual for StatePattern.

For example, I have a Floater class, and I want a particular food to take on the Floater behaviour -- as if it had inherited from Floater -- without affecting Food or any of the other foods. Here's what I've come up with.
``` class Food:
def __getattr__(self, name): # If we don't have it
method = getattr (self.state, name)
return lambda *args: method (*((self,) + args))

class Floater:
def move (f, x):
print 'Moving: %i' % x
move = staticmethod (move) #not a decorator since I can't use 2.4 at the moment

food = Food()
food.state = Floater
food.move(4) # works

```
This seems to do the job, but is there a 'cleaner' way?

• Staticmethods don't require a reference to self, and functions are first class:
• I should have clarified that the 'move' method does need a Food instance. I used staticmethod() as a bodge to allow an instance of one class to use a method of another class. There's probably a much better way to do that, though.

``` class State(object):
def __getattr__(self, name): # If we don't have it
try:
method = getattr (self.state, name)
except AttributeError?, msg:
classname = repr(self.__class__).split(".")[-1][:-2]
raise AttributeError?("In class %s, state %s"%(classname, msg))
return method

class Food(State):
pass

class Floater(object):
def move(x):
print 'Moving: %i' % x
move = staticmethod(move) #Use a decorator in 2.4

food = Food()
food.state = Floater
food.move(4) # works
food.blah(8)

```
''But a better way is just to swap the class:"
``` class State(object):
def get_state(self):
return self.__class__
def set_state(self, state):
self.__class__ = state
state = property(get_state, set_state)

class Person(State):
pass

class Runner(State):
def move(self, x):
print 'Moving: %i' % x

class Sitter(State):
def move(self, x):
print 'Not moving: %i' % x

person = Person()
person.state = Runner
person.move(4)
person.state = Sitter
person.move(4)

```
Another thing to question is whether you need StatePattern as python can swap its functions at runtime:
``` class Person(object):
def move_standing(self, x):
print 'Moving: %i' % x

def move_sitting(self, x):
print 'Not moving: %i' % x

def move(self, x):
return self.move_sitting(x)

def stand(self):
self.move = self.move_standing

def sit(self):
self.move = self.move_sitting

person = Person()
person.move(4)
person.stand()
person.move(6)
person.sit()
person.move(8)

```
-- TaroOgawa

Thanks, that's very useful and interesting information.

CategoryComparisons

View edit of May 21, 2010 or FindPage with title or text search