4. Systematic code examples: a guided tour of Transcrypt¶
One ready-to-run code example is worth more than ten lengthy descriptions. The autotest and demo suite, that is part of the distribution, is a collection of sourcecode fragments called testlets. These testlets are used for automated regression testing of Transcrypt against CPython. Since they systematically cover all language constructs, they are also very effective as a learning tool. The testlets are arranged alphabetically by subject.
from org.transcrypt.stubs.browser import __pragma__
import org.transcrypt.autotester
import arguments
import attribs_by_name
import classes
import complex_numbers
import conditional_expressions
import control_structures
import data_structures
import decorators
import dict_comprehensions
import dictionaries
import div_fixes
import div_pulls
import exceptions
import extended_slices
import general_functions
import indices_and_slices
__pragma__ ('ifdef', '__esv6__') # Needed because Transcrypt imports are compile time
if '__esv6__' in __symbols__: # Needed because CPython doesn't understand pragma's
import iterators_and_generators
__pragma__ ('endif')
import lambda_functions
import list_comprehensions
import local_classes
import module_builtin
import module_cmath
__pragma__ ('ifdef', '__esv6__')
if '__esv6__' in __symbols__:
import module_itertools
__pragma__ ('endif')
import module_math
import modules
import nonlocals
import operator_overloading
import properties
import set_comprehensions
import simple_and_augmented_assignment
import truthyness
import tuple_assignment
autoTester = org.transcrypt.autotester.AutoTester ()
autoTester.run (arguments, 'arguments')
autoTester.run (attribs_by_name, 'attribs_by_name')
autoTester.run (classes, 'classes')
autoTester.run (complex_numbers, 'complex_numbers')
autoTester.run (conditional_expressions, 'conditional_expressions')
autoTester.run (control_structures, 'control_structures')
autoTester.run (data_structures, 'data_structures')
autoTester.run (decorators, 'decorators')
autoTester.run (dict_comprehensions, 'dict_comprehensions')
autoTester.run (dictionaries, 'dictionaries')
autoTester.run (div_fixes, 'div_fixes')
autoTester.run (div_pulls, 'div_pulls')
autoTester.run (exceptions, 'exceptions')
autoTester.run (extended_slices, 'extended_slices')
autoTester.run (general_functions, 'general_functions')
autoTester.run (indices_and_slices, 'indices_and_slices')
__pragma__ ('ifdef', '__esv6__')
if '__esv6__' in __symbols__:
autoTester.run (iterators_and_generators, 'iterators_and_generators')
__pragma__ ('endif')
autoTester.run (lambda_functions, 'lambda_functions')
autoTester.run (list_comprehensions, 'list_comprehensions')
autoTester.run (local_classes, 'local_classes')
autoTester.run (module_builtin, 'module_builtin')
autoTester.run (module_cmath, 'module_cmath')
__pragma__ ('ifdef', '__esv6__')
if '__esv6__' in __symbols__:
autoTester.run (module_itertools, 'module_itertools')
__pragma__ ('endif')
autoTester.run (module_math, 'module_math')
autoTester.run (modules, 'modules')
autoTester.run (nonlocals, 'nonlocals')
autoTester.run (operator_overloading, 'operator_overloading')
autoTester.run (properties, 'properties')
autoTester.run (set_comprehensions, 'set_comprehensions')
autoTester.run (simple_and_augmented_assignment, 'simple_and_augmented_assignment')
autoTester.run (truthyness, 'truthyness')
autoTester.run (tuple_assignment, 'tuple_assignemt')
autoTester.done ()
4.1. Arguments: **kwargs, *args, defaults, at call and def time, also for lambda's¶
from org.transcrypt.stubs.browser import __pragma__
__pragma__ ('kwargs')
class A:
def __init__ (self, x = 123, y = 456, *args, m, n = 456, **kwargs):
self.x = x
self.y = y
self.args = args
self.m = m
self.n = n
self.kwargs = kwargs
self.extra = 'hello'
def f (self, autoTester):
autoTester.check (self.x, self.y, self.args, self.m, self.n, self.kwargs, self.extra)
class B (A):
def __init__ (self, x, y = -1, *args, m = -2, n, **kwargs):
A.__init__ (self, y, x, *args, m = n, n = m, **kwargs)
class C:
__pragma__ ('nokwargs')
def tricky (self, *args):
return args
__pragma__ ('kwargs')
def run (autoTester):
def f (x, y = -1, *args, m = -2, n, **kwargs):
def f2 (x, y = -3, *args, m = -4, n, **kwargs):
autoTester.check (x, y, args, m, n, kwargs)
f2 (11, 22, 1010, 2020, m = 100100, n = 200200, p = 10001000, q = 20002000)
autoTester.check (x, y, args, m, n, kwargs)
f (1, 2, 10, 20, m = 100, n = 200, p = 1000, q = 2000)
b = B (3, 4, 30, 40, m = 300, n = 400, p = 3000, q = 4000)
b.f (autoTester)
def g (*args, **kwargs):
autoTester.check (args, kwargs)
g (*(1, 2, 3), **{'p': 'aP', 'q': 'aQ', 'r': 'anR'})
(lambda x, y = -1, *args, m = -2, n, **kwargs: autoTester.check (x, y, args, m, n, kwargs)) (1, 2, 8, 16, m = 128, n = 256.3, p = 1024.3, q = 2048.3)
autoTester.check (C () .tricky (* range (4)))
autoTester.check ('{}-{}'.format (1, 3, 5, 7, 9))
autoTester.check ('{}-{}'.format (* range (4)))
4.2. Accessing attributes by name: getattr, setattr, hasattr¶
class A:
def __init__ (self):
self.s = 'hello'
a = A ()
def run (autoTester):
autoTester.check (a.s, getattr (a, 's'))
setattr (a, 's', 'goodbye')
autoTester.check (a.s, getattr (a, 's'))
setattr (a, 't', 'exists')
autoTester.check (hasattr (a, 't'), a.t, getattr (a, 't'))
delattr (a, 't')
autoTester.check (hasattr (a, 't'))
4.3. Classes: multiple inheritance and assignment of bound functions¶
def run (autoTester):
class A:
p = 123
def __init__ (self, x):
self.x = x
autoTester.check (self.p)
def show (self, label):
autoTester.check ('A.show', label, self.x)
def show2 (self, label):
autoTester.check ('A.show2', label, self.x)
class B:
p, q = 456, 789
def __init__ (self, y):
autoTester.check ('In B constructor')
self.y = y
autoTester.check (self.p)
def show (self, label):
autoTester.check ('B.show', label, self.y)
class C (A, B):
def __init__ (self, x, y):
autoTester.check ('In C constructor')
A.__init__ (self, x)
B.__init__ (self, y)
def show (self, label):
A.show (self, label)
B.show (self, label)
autoTester.check ('C.show', label, self.x, self.y)
a = A (1001)
a.show ('america')
autoTester.check (A.p)
autoTester.check (a.p)
b = B (2002)
b.show ('russia')
autoTester.check (B.p)
autoTester.check (b.p)
autoTester.check (b.q)
autoTester.check (A.p)
autoTester.check (a.p)
c = C (3003, 4004)
c.show ('netherlands')
autoTester.check (C.p)
autoTester.check (c.p)
autoTester.check (c.q)
c.show2 ('amsterdam')
A.show2 (c, 'rotterdam')
show3 = c.show
show3 ('copy')
autoTester.check (hasattr (a, 'x'))
autoTester.check (hasattr (a, 'y'))
autoTester.check (hasattr (a, 'p'))
autoTester.check (hasattr (a, 'q'))
4.4. Complex numbers: Python's builtin complex datatype¶
from org.transcrypt.stubs.browser import __pragma__
def run (autoTester):
x = 567
y = -3
z = 5 * x + 2 * y
autoTester.check (x, y, z)
__pragma__ ('opov')
a = 234 + 3j
b = 4 - 5j
c = complex (-6, 7)
autoTester.check (a, b, c)
t = 6 * x - 3 * y + 7 # Just to check, faster with 'noopov'
autoTester.check (t)
d = 2 * a
e = x * b
f = z + d + e
g = a / b
h = a - b
i = x - c
j = a - x
k = b + y
autoTester.check (d, e, f, round (g.real, 2), round (g.imag, 2), h, i, j, k)
__pragma__ ('noopov')
4.5. Conditional expressions: simple and nested¶
def f (x, b):
return x * x if b else x + x
def run (autoTester):
bools = (False, True)
for a in bools:
for b in bools:
autoTester.check (f (10 if a else 100, b))
for p in bools:
for q in bools:
for r in bools:
autoTester.check ('a' if p else 'b' if q else 'c' if r else 'd')
a = ((('e' if p else 'f') if q else 'g') if r else 'h')
b = ('i' if p else ('j' if q else ('k' if r else 'l')))
c = 'm' if (p if q else r) else 'n'
d = 'o' if p < q <= r else 'p'
autoTester.check (a, b, c, d)
odd = [x if x % 2 else x + 1 for x in range (10)]
noDuplicates = set (odd)
autoTester.check (odd, noDuplicates)
4.6. Control structures: for...else, while...else, if...elif...else, break, continue¶
def run (autoTester):
for index in range (10):
autoTester.check (index)
for index in range (8, 16):
autoTester.check (index)
for index in range (8, 16, 2):
autoTester.check (index)
for index in range (10, 0, -1):
autoTester.check (index)
for index in range (16, 8, -2):
autoTester.check (index)
for animal in ('cat', 'dog', 'turtle', 'goldfish'):
autoTester.check (animal)
for index, square in enumerate ([x * x for x in range (10) if x % 2]):
for y in (1, 2, 3):
for z in (10, 20, 30):
autoTester.check (square + y, z )
vehicles = ['bike', 'train', 'boat', 'car', 'plane', 'bus']
for doBreak in (False, True):
for doContinue in (False, True):
for index in range (10):
for index2 in range (0, 100, 10):
if doBreak and index2 == 50:
autoTester.check ('break2')
break
if doContinue and index2 == 50:
autoTester.check ('continue2')
continue
else:
autoTester.check ('noBreak2')
if doBreak and index == 5:
autoTester.check ('break')
break
if doContinue and index == 5:
autoTester.check ('continue')
continue
else:
autoTester.check ('noBreak')
index = 0
while index < len (vehicles) and vehicles [index] != 'bus':
autoTester.check (index, vehicles [index])
if doBreak and vehicles [index] == 'car':
autoTester.check ('breakWhile')
break
if doContinue and vehicles [index] == 'car':
autoTester.check ('continueWhile')
index += 1
continue
index += 1
else:
autoTester.check ('noBreakWhile')
for vehicle in vehicles:
if vehicle == 'bike':
autoTester.check ('netherlands')
elif vehicle == 'car':
autoTester.check ('america')
elif vehicle == 'boat':
autoTester.check ('oceania')
else:
autoTester.check ('anywhere')
4.7. Data structures: tuple, list, dict, set¶
def run (autoTester):
aList = [1, 2, 3, 'moon', 'stars']
autoTester.check (aList)
aList.insert (3, 'sun')
autoTester.check (aList)
autoTester.check (aList [2:4:1])
autoTester.check (aList [:])
autoTester.check (aList [2:])
autoTester.check (len (aList))
aList.append ('milkyway')
autoTester.check (aList)
aList.extend (['m1', 'm31'])
autoTester.check (aList)
anotherList = list (('a', 'b', 'c'))
autoTester.check (anotherList)
autoTester.check ('b' in anotherList)
autoTester.check ('d' in anotherList)
aDict = {1: 'plant', 'animal': 2}
autoTester.check (aDict)
autoTester.check (aDict [1], aDict ['animal'])
def p ():
return 3
q = 4
autoTester.check ({p (): 'three', q: 'four'})
aTuple = (1, 2, 3, 4, 5)
autoTester.check(aTuple)
autoTester.check (len (aTuple))
anotherTuple = (1,)
autoTester.check (anotherTuple)
aSet = {1, 2, 2, 3}
autoTester.check (aSet)
autoTester.check (len (aSet))
autoTester.check (2 in aSet)
autoTester.check (4 in aSet)
anotherSet = set ((4, 5, 5, 6))
autoTester.check (anotherSet)
emptySet = set ()
autoTester.check (emptySet)
autoTester.check (len (emptySet))
aString = 'c_cis_d_dis_e_f_fis_g_gis_a_ais_b_c'
autoTester.check ('cis' in aString)
autoTester.check ('g' in aString)
autoTester.check ('bes' in aString)
autoTester.check ('z' in aString)
4.8. Decorators: function and class, with and without parameters¶
Transcrypt supports decorators on methods and classes. A decorator itself can be a function or an object with an overloaded __call__ operator. Parameterized decorator factories are also supported. Decorators on methods are not supported, except trivially for @classmethod. Methods decorated with @classmethod can be called on an object as demonstrated in the code below, not on a class. All flavours of properties are fully supported, though directly and not through decorator syntax. Extensive use of properties is demonstrated in the properties testlet.
from org.transcrypt.stubs.browser import __pragma__
def run (autoTester):
def repeat3 (bareFunc):
__pragma__ ('kwargs')
def innerFunc (*args, **kwargs):
autoTester.check ('BEGIN repeat3')
for i in range (3):
bareFunc (*args, **kwargs)
autoTester.check ('END repeat3')
__pragma__ ('nokwargs')
return innerFunc
def repeatN (n):
def repeat (bareFunc):
__pragma__ ('kwargs')
def innerFunc (*args, **kwargs):
autoTester.check ('BEGIN repeatN ({})'.format (n))
for i in range (n):
bareFunc (*args, **kwargs)
autoTester.check ('END repeatN ({})'.format (n))
__pragma__ ('nokwargs')
return innerFunc
return repeat
class Repeater:
def __init__ (self, n):
self.n = n
def __call__ (self, bareFunc):
__pragma__ ('kwargs')
def innerFunc (*args, **kwargs):
autoTester.check ('BEGIN repeat3')
for i in range (self.n):
bareFunc (*args, **kwargs)
autoTester.check ('END repeat3')
__pragma__ ('nokwargs')
return innerFunc
@repeatN (4)
@repeat3
def funcNoArg ():
autoTester.check ('spam')
funcNoArg ()
autoTester.check ()
__pragma__ ('kwargs')
@repeat3
@repeatN (2)
def funcArg (a):
autoTester.check ('eggs', a)
__pragma__ ('nokwargs')
funcArg (3)
autoTester.check ()
funcArg (a = 4)
autoTester.check ()
__pragma__ ('opov')
@Repeater (3)
def funcNoArg2 ():
autoTester.check ('toast')
__pragma__ ('noopov')
funcNoArg2 ()
autoTester.check ()
__pragma__ ('opov')
__pragma__ ('kwargs')
@Repeater (5)
def funcArg2 (a):
autoTester.check ('jam', a)
__pragma__ ('nokwargs')
__pragma__ ('noopov')
funcArg2 (3)
autoTester.check ()
funcArg2 (a = 4)
autoTester.check ()
def next (bareFunc):
def innerFunc (value):
return bareFunc (value + 1)
return innerFunc
@next
class Number:
def __init__ (self, value):
self.value = value
autoTester.check ('two', Number (1) .value)
class Test:
@classmethod
def f (cls, x, y):
autoTester.check (cls.__name__, x, y)
def g (self, x, y):
autoTester.check (self.__class__.__name__, x, y)
test = Test ()
test.f (1, 2)
test.g (3, 4)
4.9. Dict comprehensions¶
from org.transcrypt.stubs.browser import __pragma__
__pragma__ ('iconv') # Convert dict to key list without using keys () method
def run (autoTester):
original = {'Isaac': 'Newton', 'Albert': 'Einstein', 'Paul': 'Dirac'}
autoTester.check (original)
inverted = {original [key]: key for key in original}
autoTester.check (inverted)
4.10. Diverse fixes¶
from org.transcrypt.stubs.browser import __pragma__
from div_fixes.issue55 import *
def run (autoTester):
autoTester.check ('Issue 40')
autoTester.check (65 / (5 * 2))
autoTester.check ('Issue 24')
switch = False
autoTester.check (switch)
autoTester.check ('Issue 37')
autoTester.check (15 // 7)
autoTester.check ('Issue 27')
autoTester.check (['zero', 'one', 'two', 'three', 'four'] .index ('three'))
autoTester.check ('Issue 36')
# Workaround for Python closures capturing variables rather than values
# An extra enclosing scope is created to remember the value of the variable
results = []
for i in range (10):
# results.append (lambda: i) # Works nowhere
# results.append (lambda j = i: j) # Works only in Python
results.append ((lambda j: lambda: j) (i)) # Works in Python and Trancrypt
autoTester.check ([result () for result in results])
autoTester.check ('Issue 50')
autoTester.check ((240 + 30 - 1) // 30 * 30)
autoTester.check ('Issue 51')
a = 1
b = 1
autoTester.check (a, b, {a, b} == {1, 2})
autoTester.check ('Issue 52')
switch, case, default = 'switch', 'case', 'default'
autoTester.check (switch, case, default)
autoTester.check ('Issue 54')
aDict = {1: 11, 2: 22, 3: 33}
autoTester.check (aDict)
aDict.clear ()
autoTester.check (aDict)
autoTester.check ('Issue 60')
three = 3
one = three & 1
seven = three | 4
eight = one << 3
four = eight >> 1
aTrue = bool (three & one)
aFalse = bool (three & four)
autoTester.check (3, three, 1, one, 7, seven, 8, eight, 4, four, True, aTrue, False, aFalse)
autoTester.check ('Issue 65')
__pragma__ ('opov')
aList = [4, 5, 6]
autoTester.check ([1, 2, 3,] + aList + [4, 5, 6])
autoTester.check (3 * [1, 2, 3])
autoTester.check ([1, 2, 3] * 3)
aString = 'Crocodile'
autoTester.check ('Tiger' + aString + 'Elephant')
autoTester.check (3 * aString)
autoTester.check (aString * 3)
__pragma__ ('noopov')
autoTester.check ('Issue 76')
initially17 = 17
autoTester.check (initially17)
initially17 //= 2
autoTester.check (initially17)
initially17 //= 2
autoTester.check (initially17)
4.11. Diverse pulls¶
'This is a single line docstring'
class A:
'''
This
is
a
multiline
docstring
'''
def __init__ (self, x):
'This is a single line comment'
self.x = x
'''
This
is
a
multiline
docstring
'''
'This is a single line docstring'
'''
This
is
a
multiline
docstring
'''
a = A (5.5)
def run (autoTester):
autoTester.check ('Pull 56')
s = 'abcdefghij'
autoTester.check (s [2:3])
autoTester.check (s [:3])
autoTester.check (s [2:])
autoTester.check (s [::2])
autoTester.check ('Pull 59')
autoTester.check (list (filter (lambda x: x % 2 == 0, range (10))))
autoTester.check (list (map (lambda x: x*x, range (0, 31, 3))))
4.12. Dictionaries: dict revisited¶
from org.transcrypt.stubs.browser import __pragma__
__pragma__ ('iconv')
def run (autoTester):
tel = {'guido': 4127, 'jack': 4098}
tel ['sape'] = 4139
autoTester.check (tel)
autoTester.check (tel ['jack'])
del tel ['sape']
tel ['irv'] = 4127
autoTester.check (tel)
autoTester.check (sorted (list (tel.keys ())), False)
autoTester.check (sorted (tel.keys ()))
autoTester.check ('guido' in tel)
autoTester.check ('jack' not in tel)
autoTester.check (dict ([('guido', 4127), ('jack', 4098), ('sape', 4139)]))
knights = {'robin': 'the brave', 'gallahad': 'the pure'}
for k, v in sorted (knights.items ()):
autoTester.check (k, v)
if 'gallahad' in knights:
autoTester.check ('gallahad is a knight')
for k in sorted (knights):
autoTester.check (k)
knight = {'rudolph': 'the righteous'}
for k in knight: # Autotest automatic conversion with one knight, since sort order of dict undefined
autoTester.check (k)
tel = {'guido': 123}
tel.update({'edsger': 42})
autoTester.check (tel.setdefault ('linus', 456))
autoTester.check (tel ['linus'])
autoTester.check (tel.setdefault ('guido', 789))
autoTester.check (tel.pop ('guido', 1))
autoTester.check (tel.pop ('guido', 1))
autoTester.check (tel.pop ('edsger', 2))
autoTester.check (tel.pop ('foo', 'bar'))
4.13. Exceptions: exception class hierarchy, finally¶
from org.transcrypt.stubs.browser import __envir__, __new__, __pragma__
class Ex1 (Exception):
pass
class Ex2 (Ex1):
pass
class Ex3 (Exception):
pass
if __envir__.executor_name == 'python':
class Table (BaseException):
def __init__ (self, *args):
self.fields = args
def __repr__ (self):
return 'Table' + repr (self.fields) .replace (', ', ',') .replace ('\'', '')
else:
__pragma__ ('js', '{}', '''
function _Table () {
this.fields = [] .slice.apply (arguments);
}
_Table.prototype.__str__ = function () {
return ('Table(' + this.fields.toString () + ')');
};
''')
Table = _Table
def test1 ():
raise (Exception ('mary'))
def test2 (autoTester):
try:
test1 ()
except Ex1 as exception:
autoTester.check (111)
autoTester.check (exception)
except Exception as exception:
autoTester.check (222)
autoTester.check (exception)
def run (autoTester):
test2 (autoTester)
try:
raise Ex2 ('had')
except Ex1 as exception:
autoTester.check ('a')
except Exception as exception:
autoTester.check ('little')
autoTester.check (exception)
autoTester.check (333)
try:
raise Ex1 ('lamb')
except Ex2 as exception:
autoTester.check ('his')
autoTester.check (exception)
except Ex1 as exception:
autoTester.check ('fleece')
autoTester.check (exception)
except Exception as exception:
autoTester.check ('was')
autoTester.check (exception)
finally:
autoTester.check ('white')
autoTester.check (444)
def test3 ():
raise Ex3 ('as')
autoTester.check (555)
try:
test3 ()
except Ex1 as exception:
autoTester.check ('snow')
autoTester.check (exception)
except Exception as exception:
autoTester.check ('and')
autoTester.check (exception)
finally:
autoTester.check ('everywhere')
autoTester.check (666)
try:
raise Ex3 ('that')
except Ex1 as exception:
autoTester.check ('mary')
autoTester.check (exception)
except:
autoTester.check ('went')
finally:
autoTester.check ('the')
autoTester.check (777)
try:
try:
raise Ex3 ('lamb')
except Ex1 as exception:
autoTester.check ('was')
autoTester.check (exception)
finally:
autoTester.check ('to')
except Ex3 as exception: # We should get here, exception not swallowed
autoTester.check ('go')
autoTester.check (exception)
try:
raise __new__ (Table ('he', 'followed', 'her'))
except Ex1 as exception:
autoTester.check ('to')
autoTester.check (exception)
except Table as exception: # Pure JavaScript exception, if no Python __class__
autoTester.check ('school')
autoTester.check (exception)
except Ex3 as exception:
autoTester.check ('one')
autoTester.check (exception)
finally:
autoTester.check ('day')
try:
assert 2 * 8 / 4 == 2, 'Assert error 1'
except AssertionError as exception:
autoTester.check (exception)
try:
assert 2 * 8 / 4 == 4, 'Assert error 2'
except AssertionError as exception:
autoTester.check (exception)
try:
assert 2 * 8 / 4 == 2
except AssertionError as exception:
autoTester.check (exception)
try:
assert 2 * 8 / 4 == 4
except AssertionError as exception:
autoTester.check (exception)
autoTester.check (888)
try:
autoTester.check ("hello world 1")
except:
autoTester.check ("error 1")
else:
autoTester.check ("no error 1")
i = 1 + 2
try:
autoTester.check ("hello world 2")
if i == 3: # Prevent unreachable code warning
raise Exception ()
except:
autoTester.check ("error 2")
else:
autoTester.check ("no error 2")
4.14. Extended slices: facilitating NumScrypt and such¶
from org.transcrypt.stubs.browser import *
from org.transcrypt.stubs.browser import __pragma__, __envir__
def indices (key):
if __envir__.executor_name == __envir__.transpiler_name:
return tuple (key) if type (key) == list else key
else:
try:
return key.indices (1000000000)
except:
try:
return tuple ([indices (subkey) for subkey in key])
except:
return key
class Test:
def __init__ (self, autoTester):
self.autoTester = autoTester
def __getitem__ (self, key):
self.autoTester.check ('getitem (', indices (key), ')')
return 1234567
def __setitem__ (self, key, value):
self.autoTester.check ('setitem (', indices (key), ')', value)
def run (autoTester):
a = b = c = d = e = f = g = h = i = j = k = l = Test (autoTester)
__pragma__ ('opov')
a [1:2:3, 4:5:6] = b [7:8:9]
c [1:2:3] = d [4:5:6, 7:8:9]
e [1, 1:2:3, 3] = f [4, 4:5:6, 6]
g [1, 2, 3] = h [1, 2, 3]
i [1] = j [1]
k [1:2:3] = l [1:2:3]
4.15. General functions: sort and sorted¶
from org.transcrypt.stubs.browser import __pragma__
class A:
foo='bar'
def __init__ (self):
self.foo2 = 'bar2'
class B (A):
foo3='bar3'
def __init__ (self):
self.foo4 = 'bar4'
def run (autoTester):
autoTester.check ('sort and sorted<br>')
a = [1, 5, 3, 2, -1]
b = ['sun', 'earth', 'moon']
autoTester.check (sorted (a))
autoTester.check (sorted (b))
a.sort ()
autoTester.check (a)
b.sort ()
autoTester.check (b)
autoTester.check (sorted (a, reverse = True))
autoTester.check (sorted (b, reverse = True))
a.sort (reverse = True)
autoTester.check (a)
b.sort (reverse = True)
autoTester.check (b)
b.sort (key = lambda x: len (x))
autoTester.check (b)
b.sort (key = lambda x: len (x), reverse = True)
autoTester.check (b)
autoTester.check ('<br><br>dir<br>')
autoTester.check ([entry for entry in dir (A) if not entry.startswith ('__')])
autoTester.check ([entry for entry in dir (A()) if not entry.startswith ('__')])
autoTester.check ([entry for entry in dir (B) if not entry.startswith ('__')])
autoTester.check ([entry for entry in dir (B()) if not entry.startswith ('__')])
autoTester.check ('<br><br>any, all, sum<br>')
list1 = ['ape', 'node', 'mice']
list2 = ['vim', '', 'jet']
list3 = ['', '', '']
list4 = [[1, 2], [1], []] # Truthyness into play
autoTester.check (list1, any (list1), all (list1))
autoTester.check (list2, any (list2), all (list2))
autoTester.check (list3, any (list3), all (list3))
autoTester.check (list4, any (list4), all (list4))
autoTester.check (sum (range (5)))
__pragma__ ('ifdef', '__esv6__')
if '__esv6__' in autoTester.symbols:
def generator1 ():
for i in range (5):
yield i;
def generator2 ():
for i in range (5):
if i % 2:
yield 0
else:
yield i;
def generator3 ():
for i in range (5):
yield 0;
autoTester.check (generator1 (), any (generator1 ()), all (generator1 ()))
autoTester.check (generator2 (), any (generator2 ()), all (generator2 ()))
autoTester.check (generator3 (), any (generator3 ()), all (generator3 ()))
autoTester.check (sum (generator1 ()))
__pragma__ ('endif')
4.16. Indices and slices: LHS, RHS, basic and extended¶
def run (autoTester):
# Right hand side slices
all = range (32)
autoTester.check (all)
autoTester.check (all [8 : 24])
autoTester.check (all [8 : 24 : 2])
# Left hand side slices
aList = [3, 4, 7, 8]
autoTester.check (aList)
aList [4 : 4] = [9, 10]
autoTester.check (aList)
aList [2 : 2] = [5, 6]
autoTester.check (aList)
aList [0 : 0] = [1, 2]
autoTester.check (aList)
aList [ : : 2] = [x + 0.001 for x in range (10) if x % 2]
autoTester.check (aList)
4.17. Iterators and generators¶
class Iterable:
def __init__ (self, i):
self.aList = range (0, 50, i)
def __iter__ (self):
return Iterator (self)
class Iterator:
def __init__ (self, iterable):
self.iterable = iterable
self.index = -1
def __next__ (self): # Should be auto-wrapped in a next (self) by the compiler
self.index += 1
if self.index > 5:
raise StopIteration ()
return self.iterable.aList [self.index]
def __iter__ (self):
return self
def generator (i):
for i in range (5):
yield 2 * i
def run (autoTester):
exhaustableGenExp = (a * a * a for a in [10, 20, 30]) # Currently still converted to iterator on list comprehension
iterables = [Iterable (7), generator (5), [i * 3 for i in range (5)], exhaustableGenExp]
for iterable in iterables:
autoTester.check ('***')
autoTester.check ('*')
iterator = iter (iterable)
try:
while True:
autoTester.check (next (iterator))
except:
pass
autoTester.check ('*')
for n in iterable: # The exhaustableGenExp will be exhausted, since it is an iterator, not a list
autoTester.check (n)
4.18. Lambda functions with all types of args¶
def run (autoTester):
z = 1000
autoTester.check ((lambda x, y: x + y + z) (111, 222))
def f (list0, list1, aFunc):
return [aFunc (*elem) for elem in zip (list0, list1)]
x = f (range (10), range (0, 100, 10), lambda x, y: x + y + z)
autoTester.check (x)
autoTester.check (f (range (10, 20), range (100, 200, 10), lambda x, y: x * y + 100 * z))
autoTester.check (f (range (10, 20), range (100, 200, 10), lambda *args: args [0] * args [1] + 100 * z))
4.19. List comprehensions: multi-loop and nested with multiple if's¶
def run (autoTester):
squares = [i * i for i in range (10) if i % 2]
autoTester.check (squares)
tuples = [
(x, y, z)
for x in (100, 200, 300, 400, 500, 600, 700)
for y in (10, 20, 30, 40, 50, 60, 70) if 20 < y < 60
for z in (1, 2, 3, 4, 5, 6, 7) if 200 < x < 600 if 2 < z < 6
]
autoTester.check (tuples)
tricky = [(2 * x, 3 * y) for x, y in ((10, 11), (20, 21))]
autoTester.check (tricky)
nested = [2 * x for x in [x * x for x in range (3)]]
autoTester.check (nested)
a = 100
x = 5
scopeTest = [x + a for x in range (5)]
autoTester.check (x)
autoTester.check (scopeTest)
4.20. Local classes: inside other classes and functions¶
def run (autoTester):
class A:
class B:
def __init__ (self, x):
self.x = x
def tell (self):
autoTester.check (self.x)
autoTester.check (self.d)
d = 1
c = 2
def __init__ (self, x):
self.x = x
def tell (self):
autoTester.check (self.x)
autoTester.check (self.c)
def f (x):
class G:
def __init__ (self, x):
self.x = x
def tell (self):
autoTester.check (self.x)
h = 3
g = G (4)
g.tell ()
autoTester.check (g.h)
class P (A.B):
pass
p = P (5)
p.tell ()
autoTester.check (p.d)
a = A (5)
b = a.B (6)
a.tell ()
b.tell ()
autoTester.check (a.c)
autoTester.check (b.d)
f (7)
4.21. Module builtin: a small part of it demo'ed¶
# coding: utf-8
from org.transcrypt.stubs.browser import __envir__
def canonizeString (aString):
if __envir__.executor_name == 'transcrypt':
return aString.replace ('\t', '\\t') .replace ('\n', '\\n')
else:
return aString
def canonizeStringList (stringList):
return [canonizeString (aString) for aString in stringList]
def run (autoTester):
autoTester.check ('min', min (-1.1, -1, -3))
autoTester.check ('max', max (-1.1, -1, -3))
autoTester.check ('abs', abs (-1), abs (1), abs (0), abs (-0.1), abs (0.1))
autoTester.check ('ord', ord ('a'), ord ('e´'[0])) # This is the 2 codepoint version
autoTester.check ('round',
round (4.006),
round (4.006, 2),
round (4060, -2),
round (-4.006),
round (-4.006, 2),
round (-4060, -2),
round (1/2.),
round (1/2., 1),
round (1/2, 1),
round (1/3., 2),
round (-1/2.),
round (-1/2., 1),
round (-1/2, 1),
round (-1/3., 2),
round (0.5),
round (0.51),
round (1.5),
round (1.51),
round (1.51),
round (2.5),
round (2.59),
round (3.5),
round (3.59),
round (-0.5),
round (-0.51),
round (-1.5),
round (-1.51),
round (-1.51),
round (-2.5),
round (-2.59),
round (-3.5),
round (-3.59)
)
strings = [
'der des dem den die der den die das des dem das',
'an auf hinter ueber neben vor zwischen',
'''
durch
fuer
ohne
um
bis
gegen
entlang
''',
'eins,zwei,drie,vier,fuenf,sechs,sieben'
]
autoTester.check ('<br><br>split')
for aString in strings:
autoTester.check (
canonizeString (aString),
canonizeStringList (aString.split ()),
canonizeStringList (aString.split (' ')),
canonizeStringList (aString.split (' ', 4)),
canonizeStringList (aString.split ('\t')),
canonizeStringList (aString.split ('\t', 4)),
canonizeStringList (aString.split ('\n')),
canonizeStringList (aString.split ('\n', 4)),
canonizeStringList (aString.split (',')),
canonizeStringList (aString.split (',', 4)),
'<br>'
)
autoTester.check ('<br>rsplit')
for aString in strings:
autoTester.check (
canonizeString (aString),
canonizeStringList (aString.rsplit ()),
canonizeStringList (aString.rsplit (' ')),
canonizeStringList (aString.rsplit (' ', 4)),
canonizeStringList (aString.rsplit ('\t')),
canonizeStringList (aString.rsplit ('\t', 4)),
canonizeStringList (aString.rsplit ('\n')),
canonizeStringList (aString.rsplit ('\n', 4)),
canonizeStringList (aString.rsplit (',')),
canonizeStringList (aString.rsplit (',', 4)),
'<br>'
)
4.22. Module cmath: allmost all of Python's cmath module¶
from org.transcrypt.stubs.browser import __pragma__
from cmath import *
twoPi = 2 * pi
nDecs = 5
__pragma__ ('opov')
def run (autoTester):
autoTester.check (phase (1 + 1j))
aPolar = polar (3 + 5j)
autoTester.check (round (aPolar [0], nDecs), aPolar [1])
aRect = rect (*aPolar)
autoTester.check (round (aRect.real), round (aRect.imag))
anExp = exp (-2.2 - 3.3j)
autoTester.check (round (anExp.real, nDecs), round (anExp.imag, nDecs))
aLog = log (anExp)
autoTester.check (round (aLog.real, nDecs), round (aLog.imag, nDecs))
anExp10 = aLog ** 10
autoTester.check (round (anExp10.real, nDecs), round (anExp10.imag, nDecs))
aLog10 = log10 (anExp10)
autoTester.check (round (aLog10.real, nDecs), round (aLog10.imag, nDecs))
anExpRect = aLog ** aRect
autoTester.check (round (anExpRect.real, nDecs), round (anExpRect.imag, nDecs))
aLogRect = log (anExpRect, aRect)
autoTester.check (round (aLogRect.real, nDecs), round (aLogRect.imag, nDecs))
aSqrt = sqrt (1j)
autoTester.check (round (aSqrt.real, nDecs), round (aSqrt.imag, nDecs))
autoTester.check (sqrt (4))
anotherSqrt = sqrt (-4)
autoTester.check (round (anotherSqrt.real), round (anotherSqrt.imag))
anAsin = asin (1 + 2j)
autoTester.check (round (anAsin.real, nDecs), round (anAsin.imag, nDecs))
anAcos = acos (-2 + 3j)
autoTester.check (round (anAcos.real, nDecs), round (anAcos.imag, nDecs))
anAtan = atan (3 - 4j)
autoTester.check (round (anAtan.real, nDecs), round (anAtan.imag, nDecs))
aSin = sin (anAsin)
autoTester.check (round (aSin.real), round (aSin.imag))
aCos = cos (anAcos)
autoTester.check (round (aCos.real), round (aCos.imag))
aTan = tan (anAtan)
autoTester.check (round (aTan.real), round (aTan.imag))
anAsinh = asinh (aCos)
autoTester.check (round (anAsinh.real, nDecs), round (anAsinh.imag, nDecs))
anAcosh = acosh (aSin)
autoTester.check (round (anAcosh.real, nDecs), round (anAcosh.imag, nDecs))
anAtanh = atanh (aTan)
autoTester.check (round (anAtanh.real, nDecs), round (anAtanh.imag, nDecs))
aSinh = sinh (anAsinh)
autoTester.check (round (aSinh.real), round (aSinh.imag))
aCosh = cosh (anAcosh)
autoTester.check (round (aCosh.real), round (aCosh.imag))
aTanh = tanh (anAtanh)
autoTester.check (round (aTanh.real), round (aTanh.imag))
4.23. Module itertools: allmost all of Python's itertools module¶
from itertools import *
from math import pow
def fibonacci():
a, b = 0, 1
for i in range (10):
yield a
a, b = b, a + b
squares = [i * i for i in range (10)]
chars = 'thequickbrownfoxjumpsoverthelazydog'
def run (autoTester):
autoTester.check ('islice count', list (islice (count (10, 2), 4, 40, 3)))
autoTester.check ('islice cycle', list (islice (cycle (fibonacci ()), 15)))
autoTester.check ('repeat', list (repeat (3.14, 15)))
autoTester.check ('islice repeat', list (islice (repeat (2.74), 15)))
autoTester.check ('accumulate', list (accumulate (range (5))))
def add (total, element):
return total + element
autoTester.check ('accumulate', list (accumulate (['alamak', 'mirach', 'sirrah'], add)))
autoTester.check ('chain', list (chain (fibonacci (), squares, chars)))
autoTester.check ('chain.from_iterable', list (chain.from_iterable (['ape', 'node', 'mice', 'vim', 'sus', 'jet'])))
selectors = [True, True, False, True, False, False, True, True, False, True]
autoTester.check ('compress', list (compress (
['{}{}'.format (('take' if selector else 'leave'), index) for index, selector in enumerate (selectors)],
selectors
)))
autoTester.check ('dropwhile', list (dropwhile (lambda x: x < 5, [1, 4, 6, 4, 1])))
autoTester.check ('filterfalse', list (filterfalse (lambda x: x % 2, range (10))))
things = [('animal', 'bear'), ('animal', 'duck'), ('plant', 'cactus'), ('vehicle', 'speed boat'), ('vehicle', 'school bus')]
for key, group in groupby (things, lambda x: x [0]):
for thing in group:
autoTester.check ('A {} is a {}.' .format (thing[1], key))
autoTester.check (' ')
autoTester.check ('islice', list (islice ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2, 9, 2)))
autoTester.check ('starmap', [int (x) for x in starmap (pow, [(2, 5), (3, 2), (10, 3)])])
autoTester.check ('takewhile', list (takewhile (lambda x: x < 5, [1, 4, 6, 4, 1])))
i1, i2 = tee (islice (count (), 5))
autoTester.check ('tee', list (i1), list (i1), list (i2))
autoTester.check ('product', list (product ('ABCD', 'xy')), list (product (range (2), repeat = 3)))
autoTester.check ('permutations', list (permutations ('ABCD')), list (permutations ('ABCD', 2)))
autoTester.check ('combinations',
list (combinations ('ABCD', 2)),
list (combinations ([1, 2, 3, 4, 5], 3)),
list (combinations (islice (count (), 6), 4))
)
autoTester.check ('combinations_with_replacement',
list (combinations_with_replacement ('ABCD', 2)),
list (combinations_with_replacement ([1, 2, 3, 4, 5], 3)),
list (combinations_with_replacement (islice (count (), 6), 4))
)
4.24. Module math: allmost all of Python's math module¶
from math import *
def run (autoTester):
autoTester.check (pi)
autoTester.check (e)
autoTester.check (exp (3))
autoTester.check (int (expm1 (5)))
autoTester.check (log (0.2))
autoTester.check (round (log (1024, 2)))
autoTester.check (log1p (5))
autoTester.check (int (log2 (257)))
autoTester.check (int (log10 (1001)))
autoTester.check (pow (3, 4.5))
autoTester.check (sqrt (25.1))
autoTester.check (sin (10))
autoTester.check (cos (10))
autoTester.check (tan (10))
autoTester.check (asin (0.5))
autoTester.check (acos (0.5))
autoTester.check (atan (0.5))
autoTester.check (atan2 (1, 2))
autoTester.check (int (hypot (3, 4.1)))
autoTester.check (degrees (pi/2.1))
autoTester.check (radians (90))
autoTester.check (sinh (1))
autoTester.check (cosh (1))
autoTester.check (tan (1))
autoTester.check (asinh (70))
autoTester.check (acosh (70))
autoTester.check (atan (70))
autoTester.check (floor (3.5))
autoTester.check (ceil (3.5))
autoTester.check (trunc (3.5))
4.25. Module random: most important functions of Python's random module¶
from random import *
result = ''
def output (any):
result += any + '<br>\n'
for fixedSeed in (False, True):
if fixedSeed:
seed (3)
else:
seed ()
output ('------ {} ------'.format ('fixed seed' if fixedSeed else 'auto seed'))
output ('--- randint ---')
for i in range (20):
output (randint (10, 20))
output ('<br>\n--- choice ---')
for i in range (20):
output (choice ([1, 2, 3, 4, 5]))
output ('<br>\n--- random ---')
for i in range (20):
output (random ())
output ('<br>\n')
document.getElementById ('output') .innerHTML = result
4.26. Modules: hierarchical, both local to the project and global url-based¶
import modules.mod1.mod11.mod111
import modules.mod3
import modules.mod1.mod11.mod112
import modules.mod1
import modules.mod1.mod11
import modules.mod2
import modules.mod2.mod21
import modules.mod2.mod22
import modules.mod1.mod11.mod111 as aliasMod111
import modules.mod1 as aMod1
from modules.mod1.mod11 import mod111, mod112
from modules.mod2 import mod21 as aMod21, mod22 as aMod22
from modules.mod3 import *
from modules.mod1.mod11.mod111 import A
a = modules.mod1.mod11.mod111.A (12345)
pi = modules.mod1.pi
f = modules.mod2.f
def run (autoTester):
# Import without 'as'
autoTester.check ('modules')
autoTester.check (a.f ())
autoTester.check (modules.mod1.mod11.mod112.f ())
autoTester.check (modules.mod1.mod11.e)
autoTester.check (pi)
autoTester.check (f (102030))
autoTester.check (modules.mod2.mod21.f ())
B = modules.mod2.mod22.B
b = B ()
autoTester.check (b.x)
autoTester.check (modules.mod3.x)
# Import with 'as'
a2 = aliasMod111.A (6789101112)
autoTester.check (a2.f ())
autoTester.check (aMod1.pi)
# From ... import without 'as'
a3 = mod111.A (100.001)
autoTester.check (a3.f ())
autoTester.check (mod112.f ())
# From ... import with 'as'
autoTester.check (aMod21.f ())
autoTester.check (aMod22.B () .x)
# From ... import *
autoTester.check (mod3Hundred)
autoTester.check (mod3GetTwoHundred ())
autoTester.check (A (123.321) .f ())
4.27. Nonlocals¶
def run (autoTester):
test1 = 1
test2 = 2
def f ():
test1 = 10
nonlocal test2
test2 = 20
autoTester.check (test1, test2)
f ()
autoTester.check (test1, test2)
4.28. Operator overloading¶
from org.transcrypt.stubs.browser import __pragma__
class Matrix:
def __init__ (self, nRows, nCols, elements = []):
self.nRows = nRows
self.nCols = nCols
if len (elements):
self._ = elements
else:
self._ = [[0 for col in range (nCols)] for row in range (nRows)]
def __mul__ (self, other):
if type (other) == Matrix:
result = Matrix (self.nRows, other.nCols)
for iTargetRow in range (result.nRows):
for iTargetCol in range (result.nCols):
for iTerm in range (self.nCols):
result._ [iTargetRow][iTargetCol] += self._ [iTargetRow][iTerm] * other._ [iTerm][iTargetCol]
return result
else: # other is a scalar
return self.__rmul__ (other)
def __rmul__ (self, scalar): # Only called if left operand is scalar, all other cases will call __mul__
result = Matrix (self.nRows, self.nCols)
for iRow in range (self.nRows):
for iCol in range (self.nCols):
result._ [iRow][iCol] = scalar * self._ [iRow][iCol]
return result
def __add__ (self, other):
result = Matrix (self.nRows, self.nCols)
for iRow in range (self.nRows):
for iCol in range (self.nCols):
result._ [iRow][iCol] = self._ [iRow][iCol] + other._ [iRow][iCol]
return result
def __getitem__ (self, index):
return self._ [index]
def __setitem__ (self, index, value):
self._ [index] = value
def __repr__ (self):
return repr (self._)
class Functor:
def __init__ (self, factor):
self.factor = factor
__pragma__ ('kwargs')
def __call__ (self, x, y = -1, *args, m = -2, n, **kwargs):
return (
self.factor * x,
self.factor * y,
[self.factor * arg for arg in args],
self.factor * m,
self.factor * n,
# !!! [self.factor * kwargs [key] for key in sorted (kwargs.keys ())] Add supoprt for keys () on kwargs
)
__pragma__ ('nokwargs')
f = Functor (10)
__pragma__ ('kwargs')
def g (x, y = -1, *args, m = -2, n, **kwargs):
return (x, y, args, m, n) # !!! , [kwargs [key] for key in sorted (kwargs.keys ())]) Add support for keys () on kwargs
__pragma__ ('nokwargs')
def run (autoTester):
m0 = Matrix (3, 3, [
[1, 2, 3],
[4, 5, 6],
[7, 8, 10]
])
m1 = Matrix (3, 3, [
[10, 20, 30],
[40, 50, 60],
[70, 80, 90]
])
x = 3
y = x * 4 * x
fast = 2 * 3
__pragma__ ('opov')
m1 [1][2] = m0 [1][2]
slow = 2 + 3
m2 = m0 * m1 + m1 * (m0 + m1)
m3 = 2 * (2 * m0 * 3 * m1 + m2 * 4) * 2
autoTester.check (m0 [1][1], m0 [1][2], m1 [1][1], m1 [1][2])
__pragma__ ('noopov')
fast2 = 16 * y + 1
autoTester.check (m0, m1)
autoTester.check (x, y)
autoTester.check (m2)
autoTester.check (m3)
autoTester.check (fast, slow, fast2)
x = 'marker'
__pragma__ ('opov')
autoTester.check (f (3, 4, 30, 40, m = 300, n = 400, p = 3000, q = 4000))
autoTester.check (g (3, 4, 30, 40, m = 300, n = 400, p = 3000, q = 4000))
autoTester.check (set ((1, 2, 3)) == set ((3, 2, 1)))
autoTester.check (set ((1, 2, 3)) != set ((3, 2, 1)))
autoTester.check (set ((1, 3)) == set ((3, 2, 1)))
autoTester.check (set ((1, 3)) != set ((3, 2, 1)))
autoTester.check (set ((1, 2)) < set ((3, 2, 1)))
autoTester.check (set ((1, 2, 3)) <= set ((3, 2, 1)))
autoTester.check (set ((1, 2, 3)) > set ((2, 1)))
autoTester.check (set ((1, 2, 3)) >= set ((3, 2, 1)))
autoTester.check ((1, 2, 3) == (1, 2, 3))
autoTester.check ([1, 2, 3] == [1, 2, 3])
autoTester.check ((1, 2, 3) != (1, 2, 3))
autoTester.check ([1, 2, 3] != [1, 2, 3])
autoTester.check ((2, 1, 3) == (1, 2, 3))
autoTester.check ([2, 1, 3] == [1, 2, 3])
autoTester.check ((2, 1, 3) != (1, 2, 3))
autoTester.check ([2, 1, 3] != [1, 2, 3])
__pragma__ ('noopov')
4.29. Properties¶
class A:
p = 1234
def getX (self):
return self._x
def setX (self, value):
self._x = value
def getY (self):
return self._y
def setY (self, value):
self._y = 1000 + value # Weird but should be possible
def getY2 (self):
return self._y
def setY2 (self, value):
self._y = value
def getT (self):
return self._t
def setT (self, value):
self._t = value
def getU (self):
return self._u + 10000
def setU (self, value):
self._u = value - 5000
x, y, y2 = property (getX, setX), property (getY, setY), property (getY2, setY2)
t = property (getT, setT)
u = property (getU, setU)
A.q = 5678
class B:
def getZ (self):
return self.z_
def setZ (self, value):
self.z_ = value
z = property (getZ, setZ)
class C:
def __init__ (self):
self.offset = 1234
def getW (self):
return self.w_ + self.offset
def setW (self, value):
self.w_ = value - self.offset
w = property (getW, setW)
def run (autoTester):
a1 = A ()
a2 = A ()
a1.y2 = 1000
a2.y2 = 2000
a1.x = 5
a1.y = 6
a2.x = 7
a2.y = 8
a1.t = 77
a1.u = 88
autoTester.check (a1.x, a1.y, a1.y2)
autoTester.check (a2.x, a2.y, a2.y2)
autoTester.check (a1.p, a2.p, a1.q, a2.q)
autoTester.check (a1.t, a1.u)
b = B ()
c = C ()
b.z = 100100
c.z = 200200
c.w = 300300
autoTester.check (a1.x, b.z, c.z, c.w)
c.w = 400400
c.z = 500500
b.z = 600600
autoTester.check (a1.x, b.z, c.z, c.w)
4.30. Set comprehensions¶
def run (autoTester):
even = {2 * i for i in [0, 9, 1, 7, 2, 8, 3, 6, 4, 5]}
autoTester.check (even)
odd = {2 * i + 1 for i in [5, 6, 7, 8, 9, 4, 3, 1, 2, 0]}
autoTester.check (odd)
even.add (12)
even.add (12)
autoTester.check (even)
even.discard (12)
even.discard (12)
autoTester.check (even)
uni = even.union (odd)
autoTester.check (uni)
autoTester.check (odd.isdisjoint (even))
autoTester.check (uni.isdisjoint (even))
autoTester.check (even.issuperset (uni))
autoTester.check (uni.issuperset (even))
autoTester.check (even.issubset (uni))
autoTester.check (uni.issubset (even))
first = {4, 1, 0, 5, 3, 2, 6}
autoTester.check (first)
second = {3, 5, 6, 9, 4, 7, 8}
autoTester.check (second)
inter = first.intersection (second)
autoTester.check (inter)
diff = first.difference (second)
autoTester.check (diff)
symDiff = first.symmetric_difference (second)
autoTester.check (symDiff)
aSet = {200, 4, 5, 100}
aSet.update (first, symDiff, second)
autoTester.check (aSet)
4.31. Simple and augmented assignment¶
class A:
def __init__ (self):
self.i = 0
def f (self):
return self.i
a = A ()
def run (autoTester):
x = 3
y = 5
z = x + y
autoTester.check (z)
l = [1, 2, 3]
l [1] = l [2]
autoTester.check (l)
# Should generate x++
x += 1
autoTester.check (x)
x += +1
autoTester.check (x)
x -= -1
autoTester.check (x)
# Should generate y--
y -= 1
autoTester.check (y)
y -= +1
autoTester.check (y)
y += -1
autoTester.check (y)
x += -3
autoTester.check (x)
x += 6
autoTester.check (x)
y -= 3
autoTester.check (y)
l [1] += l [1]
autoTester.check (l)
x += y
y += x
autoTester.check (x, y)
f = a.f
a.i += 1
autoTester.check (f ())
a.i += 10
autoTester.check (f ())
a.i += a.i
autoTester.check (f ())
4.32. Truthyness: optional Python-style evaluation of truthyness, falsyness and non-empty container selection¶
from org.transcrypt.stubs.browser import __pragma__
__pragma__ ('tconv')
def run (autoTester):
autoTester.check (len ({1:2}))
autoTester.check ('Select nonemtpy container, if any<br>')
autoTester.check ((0) or (1, 2, 3))
autoTester.check (() or (1, 2, 3))
autoTester.check (() or ())
autoTester.check ((-1) or (0) or (1, 2, 3))
autoTester.check (() or (0) or (1, 2, 3))
autoTester.check (() or () or (1, 2, 3))
autoTester.check (() or () or ())
autoTester.check ([0] or [1, 2, 3])
autoTester.check ([] or [1, 2, 3])
autoTester.check ([] or [])
autoTester.check ([-1] or [0] or [1, 2, 3])
autoTester.check ([] or [0] or [1, 2, 3])
autoTester.check ([] or [] or [1, 2, 3])
autoTester.check ([] or [] or [])
autoTester.check ({0} or {1, 2, 3})
autoTester.check (set () or {1, 2, 3})
autoTester.check (set () or set ())
autoTester.check ({-1} or {0} or {1, 2, 3})
autoTester.check (set () or {0} or {1, 2, 3})
autoTester.check (set () or set () or {1, 2, 3})
autoTester.check (set () or set () or set ())
autoTester.check ({0:10} or {1:11, 2:12, 3:13})
autoTester.check ({} or {1, 2, 3})
autoTester.check ({} or {})
autoTester.check ({-1:-11} or {0:10} or {1:11, 2:12, 3:13})
autoTester.check ({} or {0:10} or {1:11, 2:12, 3:13})
autoTester.check ({} or {} or {1:11, 2:12, 3:13})
autoTester.check ({} or {} or {})
autoTester.check ('<br><br>')
autoTester.check ('Boolean evaluations')
for expression in (
'<br> -- falsy -- <br>',
(),
[],
set (),
{},
0,
'',
3 > 5,
False,
'<br> -- truthy -- <br>',
(1, 2, 3),
[1, 2, 3],
{1, 2, 3},
{'a': 1, 'b': 2, 'c': 3},
3,
'hello',
5 > 3,
True
):
if expression in ('<br> -- falsy -- <br>', '<br> -- truthy -- <br>'):
autoTester.check (expression)
else:
autoTester.check (expression, ' . . . ')
autoTester.check ('operators')
autoTester.check (not not expression)
autoTester.check (not not (True and expression))
autoTester.check (not not (False or expression))
autoTester.check (not not (expression and True))
autoTester.check (not not (expression and False))
autoTester.check ('if')
if expression:
autoTester.check (True)
else:
autoTester.check (False)
if expression or expression:
autoTester.check (True)
else:
autoTester.check (False)
if False:
autoTester.check ('if')
elif expression:
autoTester.check ('elif')
else:
autoTester.check ('else')
autoTester.check ('while')
while expression:
autoTester.check (True)
break
autoTester.check ('condex')
autoTester.check (True if expression else False)
if (0.0):
autoTester.check ('0.0')
elif (0.1):
autoTester.check ('0.1')
else:
autoTester.check ('Shouldn\'t be here...')
4.33. Tuple assignment: recursive and in for-headers using enumerate¶
def run (autoTester):
((a, b), santa, [c, d], e) = ((1, 2), 'santa-claus', {3, 4}, 5)
autoTester.check (a, b, c, d, e, santa)
for i, x in enumerate ((0.5, 1.5, 2.5, 3.5)):
autoTester.check (i, x)
e, pi = 3.14, 2.74
e, pi = pi, e
autoTester.check (e, pi)
def f ():
return [(i, 2 * i) for i in range (7000, 10000, 1000)]
def g ():
return f
[k, l], [m, n], (o, p) = g () ()
autoTester.check (k, l, m, n, o, p)