def test_map():
assert functional.map(lambda e: e * 2,
functional.range(1, 11)) == \
[ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 ]
assert functional.map(lambda e: e,
[ [ 1 ], [ 2 ], [ 3 ] ]) == \
[ [ 1 ], [ 2 ], [ 3 ] ]
def test_requires_iterable(self):
from functional import map
try:
map(str, 5)
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_requires_callable(self):
from functional import map
try:
map(None, [4, 5])
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_requires_callable(self):
from functional import map
try:
map(None, [4, 5])
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_requires_iterable(self):
from functional import map
try:
map(str, 5)
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_single_iterable(self):
from functional import map
from operator import add
try:
map(add, [4, 5, 6], [6, 7, 8])
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_single_iterable(self):
from functional import map
from operator import add
try:
map(add, [4, 5, 6], [6, 7, 8])
except TypeError:
pass
else:
raise AssertionError("Failed to raise TypeError")
def test_partial():
def add(a, b):
return a + b
def add10(x):
return add(x, 10)
assert functional.map(add10,
functional.range(1, 11)) == \
[ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]
assert functional.map(functional.partial(add, 10),
functional.range(1, 11)) == \
[ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]
def handle_country(country: str, filter_func: callable,
qrz_session: requests.Session) -> (str, list):
return country[1], chain(
filter_func,
to(map(func=get_call_sign_data(qrz_session=qrz_session),
kw='call_sign'),
kw='iterable'),
)(func=startswith(substring=country[0]))
def handle_arrl_data(contacted_call_signs: tuple, missing_countries: dict,
qrz_session: requests.Session) -> dict:
return chain(
map(func=handle_country(filter_func=filterer(
iterable=contacted_call_signs, kw='string'),
qrz_session=qrz_session),
kw='country'), filter_empty_values,
dict)(iterable=missing_countries.items())
def test_map(self):
from functional import map
def as_listcomp(func, seq):
return map(func, seq), [func(x) for x in seq]
self.assertEqual(*as_listcomp(str, [4, 5, 6]))
self.assertEqual(*as_listcomp(str, "abc"))
self.assertEqual(*as_listcomp(str, (5, 6, 7)))
def gen():
yield 5
yield 6
yield 7
self.assertEqual(map(str, gen()), [str(x) for x in gen()])
def test_map(self):
from functional import map
def as_listcomp(func, seq):
return map(func, seq), [func(x) for x in seq]
self.assertEqual(*as_listcomp(str, [4, 5, 6]))
self.assertEqual(*as_listcomp(str, "abc"))
self.assertEqual(*as_listcomp(str, (5, 6, 7)))
def gen():
yield 5
yield 6
yield 7
self.assertEqual(map(str, gen()), [str(x) for x in gen()])
def test_curry():
def args(*a):
return a
cargs = functional.curry(args, 5)
cargsab = cargs('a')('b')
assert cargsab('c')('d')('e') == ('a', 'b', 'c', 'd', 'e')
assert cargsab('x')('y')('z') == ('a', 'b', 'x', 'y', 'z')
assert cargsab('c')('d')('e') == ('a', 'b', 'c', 'd', 'e')
assert cargsab('x')('y')('z') == ('a', 'b', 'x', 'y', 'z')
def add(a, b):
return a + b
cadd = functional.curry(add)
assert cadd(10)(5) == 15 and cadd(20)(5) == 25
assert functional.map(functional.curry(add)(10),
functional.range(1, 11)) == \
[ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]
def stock_history(init_investment, monthly_contribution, stock_prices):
stock_prices = F.map(stock_prices,
F.pipe(lambda x: x.split(" "),
lambda x: [int(a) for a in x]))
sell_prices = stock_prices[-1]
total_earning = 0
total_investment = 0
max_earning_rate = [1 for _ in sell_prices]
for month in range(len(stock_prices) -2, -1, -1):
current_prices = stock_prices[month]
earning_rate = [sell_prices[i] / price for i, price in enumerate(current_prices)]
max_earning_rate = [max(a, b) for a, b in zip(max_earning_rate, earning_rate)]
money = init_investment if month == 0 else monthly_contribution
total_earning += money * max(max_earning_rate)
total_investment += money
return int(round(total_earning - total_investment))
def as_listcomp(func, seq):
return map(func, seq), [func(x) for x in seq]
import functional as F
names = sorted(
F.map(
open("names.txt", 'r').readline().split(','),
lambda x: x.replace('"', '')))
A = ord('A')
def getValue(c):
return ord(c) - A + 1
score = 0
for i, name in enumerate(names):
score += (i + 1) * sum([getValue(c) for c in name])
print(score)
def test_factorial():
assert functional.map(functional.factorial, functional.range(1, 11)) == \
[ 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]
def listmultiply2(l):
return functional.map(lambda e: e * 2, l)
results = set()
for a in set_a:
len_a = len(a)
for num_b in range(1, 9 - len(a)):
set_b = get_except(sets[num_b], a)
for b in set_b:
len_b = len(b)
len_c = 9 - len_a - len_b
if not (len_c <= len_a + len_b <= len_c + 1):
continue
c = list((set_digits - set(a + b)))
for cm in M.combination(c):
cc = int("".join(F.map(cm, str)))
if cc in results:
continue
for am in M.combination(a):
for bm in M.combination(b):
aa = int("".join(F.map(am, str)))
bb = int("".join(F.map(bm, str)))
if aa * bb == cc:
print(aa, "x", bb, "=", cc)
results.add(cc)
results = list(results)
print(sum(results), ":", results)
def test_fibonacci():
assert functional.map(functional.fibonacci, functional.range(1, 11)) == \
[ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]
def test_map(self):
self.assertEqual(F.map(_list, lambda x: x * x), [1, 4, 9, 16])
self.assertEqual(F.map(_tuple, lambda x: x * x), [1, 4, 9])
def test_with_bound_and_unbound_methods(self):
data = map(str, range(10))
join = self.thetype(str.join, '')
self.assertEqual(join(data), '0123456789')
join = self.thetype(''.join)
self.assertEqual(join(data), '0123456789')
def softmax2D(M, t = 1.0):
E = F.map(M, lambda row: [math.exp(x/t) for x in row])
total = F.sum(F.map(E, lambda row: F.sum(row)))
return F.map(E, lambda row: [x/total for x in row])
"75",
"95 64",
"17 47 82",
"18 35 87 10",
"20 04 82 47 65",
"19 01 23 75 03 34",
"88 02 77 73 07 63 67",
"99 65 04 28 06 16 70 92",
"41 41 26 56 83 40 80 70 33",
"41 48 72 33 47 32 37 16 94 29",
"53 71 44 65 25 43 91 52 97 51 14",
"70 11 33 28 77 73 17 78 39 68 17 57",
"91 71 52 38 17 14 91 43 58 50 27 29 48",
"63 66 04 68 89 53 67 30 73 16 69 87 40 31",
"04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"
]
triangle = F.map(triangle, lambda y: [int(x) for x in y.split(' ')])
def get_upper(x, y):
pos_y = y - 1
start_x = 0 if x < 1 else x - 1
prev_x_len = len(triangle[pos_y])
end_x = min([x, prev_x_len])
return max(triangle[pos_y][start_x:end_x + 1])
for y in range(1, len(triangle)):
for x in range(len(triangle[y])):
triangle[y][x] += get_upper(x, y)
print(max(triangle[-1]))
def test_with_bound_and_unbound_methods(self):
data = map(str, range(10))
join = self.thetype(str.join, '')
self.assertEqual(join(data), '0123456789')
join = self.thetype(''.join)
self.assertEqual(join(data), '0123456789')
def as_listcomp(func, seq):
return map(func, seq), [func(x) for x in seq]
def listadd1(l):
return functional.map(lambda e: e + 1, l)
