Если вы намерены вызвать другие действия из текущей Деятельности, вы должны использовать намерения . Ваш фокус может быть меньше на сохраняющихся данных, чем на совместном использовании его по мере необходимости.
Однако, если вам действительно необходимо сохранить эти значения, вы можете перенести их в какой-то структурированный текстовый файл или базу данных на локальном хранилище. Файл свойств, файл XML или файл JSON могут хранить ваши данные и легко анализироваться во время создания активности. Не забывайте также, что у вас есть SQLite на всех устройствах Android, поэтому вы можете хранить их в таблице базы данных. Вы также можете использовать карту для хранения пар ключ-значение и сериализации карты для локального хранилища, но это может быть слишком громоздким, чтобы быть полезным для простых структур данных.
def strictly_increasing(L):
return all(x<y for x, y in zip(L, L[1:]))
def strictly_decreasing(L):
return all(x>y for x, y in zip(L, L[1:]))
def non_increasing(L):
return all(x>=y for x, y in zip(L, L[1:]))
def non_decreasing(L):
return all(x<=y for x, y in zip(L, L[1:]))
Если у вас есть большие списки чисел, лучше всего использовать numpy, а если вы:
import numpy as np
def monotonic(x):
dx = np.diff(x)
return np.all(dx <= 0) or np.all(dx >= 0)
должны сделать трюк.
np.diff()
сделал первый элемент NaN
, поэтому форма вывода соответствовала входу, но на самом деле это был другой фрагмент кода, который делал это, что меня било. :)
– Ryan
4 December 2015 в 01:00
import operator, itertools
def is_monotone(lst):
op = operator.le # pick 'op' based upon trend between
if not op(lst[0], lst[-1]): # first and last element in the 'lst'
op = operator.ge
return all(op(x,y) for x, y in itertools.izip(lst, lst[1:]))
Вот функциональное решение, использующее reduce
сложности O(n)
:
is_increasing = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999
is_decreasing = lambda L: reduce(lambda a,b: b if a > b else -9999 , L)!=-9999
Замените 9999
верхним пределом ваших значений и -9999
с нижним пределом. Например, если вы тестируете список цифр, вы можете использовать 10
и -1
.
Я проверил его производительность по сравнению с ответом @ 6502 и его
Случай True: [1,2,3,4,5,6,7,8,9]
# my solution ..
$ python -m timeit "inc = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999; inc([1,2,3,4,5,6,7,8,9])"
1000000 loops, best of 3: 1.9 usec per loop
# while the other solution:
$ python -m timeit "inc = lambda L: all(x<y for x, y in zip(L, L[1:]));inc([1,2,3,4,5,6,7,8,9])"
100000 loops, best of 3: 2.77 usec per loop
Случай False из второго элемента: [4,2,3,4,5,6,7,8,7]
:
# my solution ..
$ python -m timeit "inc = lambda L: reduce(lambda a,b: b if a < b else 9999 , L)!=9999; inc([4,2,3,4,5,6,7,8,7])"
1000000 loops, best of 3: 1.87 usec per loop
# while the other solution:
$ python -m timeit "inc = lambda L: all(x<y for x, y in zip(L, L[1:]));inc([4,2,3,4,5,6,7,8,7])"
100000 loops, best of 3: 2.15 usec per loop
@ 6502 имеет идеальный код для списков, я просто хочу добавить общую версию, которая работает для всех последовательностей:
def pairwise(seq):
items = iter(seq)
last = next(items)
for item in items:
yield last, item
last = item
def strictly_increasing(L):
return all(x<y for x, y in pairwise(L))
def strictly_decreasing(L):
return all(x>y for x, y in pairwise(L))
def non_increasing(L):
return all(x>=y for x, y in pairwise(L))
def non_decreasing(L):
return all(x<=y for x, y in pairwise(L))
Я приурочил все ответы в этом вопросе в разных условиях и обнаружил, что:
Вот код, чтобы попробовать:
import timeit
setup = '''
import random
from itertools import izip, starmap, islice
import operator
def is_increasing_normal(lst):
for i in range(0, len(lst) - 1):
if lst[i] >= lst[i + 1]:
return False
return True
def is_increasing_zip(lst):
return all(x < y for x, y in izip(lst, islice(lst, 1, None)))
def is_increasing_sorted(lst):
return lst == sorted(lst)
def is_increasing_starmap(lst):
pairs = izip(lst, islice(lst, 1, None))
return all(starmap(operator.le, pairs))
if {list_method} in (1, 2):
lst = list(range({n}))
if {list_method} == 2:
for _ in range(int({n} * 0.0001)):
lst.insert(random.randrange(0, len(lst)), -random.randrange(1,100))
if {list_method} == 3:
lst = [int(1000*random.random()) for i in xrange({n})]
'''
n = 100000
iterations = 10000
list_method = 1
timeit.timeit('is_increasing_normal(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)
timeit.timeit('is_increasing_zip(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)
timeit.timeit('is_increasing_sorted(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)
timeit.timeit('is_increasing_starmap(lst)', setup=setup.format(n=n, list_method=list_method), number=iterations)
Если список был уже монотонно возрастающим (list_method == 1
), самым быстрым для самого медленного был:
Если список был в основном монотонно возрастающим (list_method == 2
), самым быстрым и медленным было:
(независимо от того, была ли максимальная скорость starmap или zip зависела от исполнения, и я не мог идентифицировать шаблон. Starmap, казалось, обычно быстрее)
Если список был полностью случайным (list_method == 3
), , самый быстрый до самого медленного был:
import itertools
import operator
def monotone_increasing(lst):
pairs = zip(lst, lst[1:])
return all(itertools.starmap(operator.le, pairs))
def monotone_decreasing(lst):
pairs = zip(lst, lst[1:])
return all(itertools.starmap(operator.ge, pairs))
def monotone(lst):
return monotone_increasing(lst) or monotone_decreasing(lst)
Этот подход равен O(N)
в длине списка.
O(N)
. Вы можете сделать pairs = itertools.izip(lst, itertools.islice(lst, 1, None))
.
– Tomasz Elendt
13 February 2011 в 10:36
>>> l = [0,1,2,3,3,4]
>>> l == sorted(l) or l == sorted(l,reverse=True)
L = [1,2,3]
L == sorted(L)
L == sorted(L, reverse=True)
sorted()
, если бы он ничего не сортировал, просто проверьте. Плохо названный - звучит как предикат, когда это не так.
– progo
13 February 2011 в 10:07
itertools.izip
вместоzip
вы можете получить ранний выход (в python 3zip
уже работает как итератор) – 6502 13 February 2011 в 11:17