диапазон и xrange для 13-разрядных чисел в Python?

Нет проблем с созданием диапазона, до тех пор, пока вы не хотите 10 ** 13 элементов, например,

range(10**14,10**15,10**14)

дает

[100000000000000, 200000000000000, 300000000000000, 400000000000000, 500000000000000, 600000000000000, 700000000000000, 800000000000000, 900000000000000]

Диапазон () и XRANGE () работают в последние версии Python; Однако в 2,5 или меньше вам нужно будет работать вокруг длительного конверсии.

def irange(start, stop=None, step=1):
    if stop is None:
        stop = long(start)
        num = 1L
    else:
        stop = long(stop)
        num = long(start)
    step = long(step)
    while num < stop:
        yield num
        num += step

Это не полное решение (он не обрабатывает отрицательных шагов), но он должен идти.

при необходимости перечисления целых чисел попробуйте использовать итертулы :

itertools.count(1000000000000)

не следует выделять память для списка 1000000000000 элементов

Monkeypatch warnings.showwarning () с собственной пользовательской функцией.

Разница между диапазоном () и xrange () заключается в том, что первый возвращает весь список, а второй возвращает генератор, который генерирует каждое число по мере необходимости. Второй должен работать на любое число, каким бы большим он ни был.

В Python 3.0 xrange () исчез, а диапазон () ведет себя как xrange () ранее.

если вам нужно перечислить целое число, попробуйте использовать itertools :

itertools.count(1000000000000)

он не должен выделять память для списка 1000000000000 elements

Не думаю, что это сработает. Такие функции как len ожидают, что результат уложится в 4-байтовое целое число, из-за ограничений в реализации cPython.

На Python 3.0:

>>> range(9999999999999)
range(0, 9999999999999)

Это выглядит так, как будто работает, но....

>>> len(range(9999999999999))
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    len(range(9999999999999))
OverflowError: Python int too large to convert to C ssize_t

Смотрите здесь по связанному с этим вопросу.

range(x) возвращает список. Python списки не могут содержать столько элементов. Вы должны использовать xrange() для итерации через эти цифры, если вам нужно сделать триллионы циклов.?

См. ответы на CSS/JavaScript Используйте Div для серого на странице .

Сначала необходимо разделить прочитанное здесь и там о транзакциях SQL Server на 2 отдельных случая: локальный и распределенный.

Локальные транзакции SQL :

• SQL Server разрешает выполнение только одного запроса для каждой локальной транзакции.
• По умолчанию только один сеанс может быть зарегистрирован в локальной транзакции. Использование sp_getbindtoken и sp_bindsession нескольких сеансов может быть зарегистрировано в локальной транзакции. Сеансы все еще ограничены только одним, выполняющим запрос в любое время.
• С помощью нескольких активных результирующих наборов (MARS) один сеанс может выполнять несколько запросов. Все запросы должны быть зарегистрированы в одной локальной транзакции.

Распределенные транзакции :

• Для нескольких сеансов локальная транзакция может быть зарегистрирована в одной распределенной транзакции.
• Каждый сеанс по-прежнему включен в локальную транзакцию с учетом всех ограничений, упомянутых выше для локальных транзакций
• Локальные транзакции, включенные в распределенную транзакцию, подлежат двухфазной фиксации, координируемой распределенной транзакцией
• . Все локальные транзакции в экземпляре, зарегистрированном в распределенной транзакции, по-прежнему являются независимыми локальными транзакциями, что в первую очередь означает, что они имеют конфликтующие пространства имен блокировок.

Таким образом, когда клиент создает .Net TransacityScope и под этой областью транзакции выполняет несколько запросов на одном сервере, все эти запросы являются локальными транзакциями, зарегистрированными в распределенной транзакции. Простой пример:

class Program
    {
        static string sqlBatch = @"
set nocount on;
declare @i int;
set @i = 0;
while @i < 100000
begin
    insert into test (a) values (replicate('a',100));
    set @i = @i+1;
end";

        static void Main(string[] args)
        {
            try
            {
                TransactionOptions to = new TransactionOptions();
                to.IsolationLevel = IsolationLevel.ReadCommitted;
                using (TransactionScope scp = new TransactionScope(TransactionScopeOption.Required, to))
                {
                    using (SqlConnection connA = new SqlConnection(Settings.Default.connString))
                    {
                        connA.Open();
                        using (SqlConnection connB = new SqlConnection(Settings.Default.connString))
                        {
                            connB.Open();

                            SqlCommand cmdA = new SqlCommand(sqlBatch, connA);
                            SqlCommand cmdB = new SqlCommand(sqlBatch, connB);

                            IAsyncResult arA = cmdA.BeginExecuteNonQuery();
                            IAsyncResult arB = cmdB.BeginExecuteNonQuery();

                            WaitHandle.WaitAll(new WaitHandle[] { arA.AsyncWaitHandle, arB.AsyncWaitHandle });

                            cmdA.EndExecuteNonQuery(arA);
                            cmdB.EndExecuteNonQuery(arB);
                        }
                    }
                    scp.Complete();
                }
            }
            catch (Exception e)
            {
                Console.Error.Write(e);
            }
        }
    }

Создайте фиктивную тестовую таблицу

create table test (id int not null identity(1,1) primary key, a varchar(100));

и запустите код в образце. Вы увидите, что оба запроса выполняются параллельно, каждый из которых вставляет 100 000 строк в таблицу, затем оба фиксируют, когда область транзакции завершена. Таким образом, проблемы, которые вы видите, не связаны ни с SQL Server, ни с TransacityScope, они могут легко справиться с описанным сценарием. Более того, код очень прост и прост, и нет необходимости создавать зависимые транзакции, клонировать или продвигать транзакции.

Обновлено

Использование явных потоков и зависимых транзакций:

 private class ThreadState
    {
        public DependentTransaction Transaction {get; set;}
        public EventWaitHandle Done {get; set;}
        public SqlConnection Connection { get; set; }
    }
    static void Main(string[] args)
    {
        try
        {
            TransactionOptions to = new TransactionOptions();
            to.IsolationLevel = IsolationLevel.ReadCommitted;
            using (TransactionScope scp = new TransactionScope(TransactionScopeOption.Required, to))
            {
                ThreadState stateA = new ThreadState 
                {
                    Transaction = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete),
                    Done = new AutoResetEvent(false),
                    Connection = new SqlConnection(Settings.Default.connString),
                };
                stateA.Connection.Open();
                ThreadState stateB = new ThreadState
                {
                    Transaction = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete),
                    Done = new AutoResetEvent(false),
                    Connection = new SqlConnection(Settings.Default.connString),
                };
                stateB.Connection.Open();

                ThreadPool.QueueUserWorkItem(new WaitCallback(Worker), stateA);
                ThreadPool.QueueUserWorkItem(new WaitCallback(Worker), stateB);

                WaitHandle.WaitAll(new WaitHandle[] { stateA.Done, stateB.Done });

                scp.Complete();

                //TODO: dispose the open connections
            }

        }
        catch (Exception e)
        {
            Console.Error.Write(e);
        }
    }

    private static void Worker(object args)
    {
        Debug.Assert(args is ThreadState);
        ThreadState state = (ThreadState) args;
        try
        {
            using (TransactionScope scp = new TransactionScope(state.Transaction))
            {
                SqlCommand cmd = new SqlCommand(sqlBatch, state.Connection);
                cmd.ExecuteNonQuery();
                scp.Complete();
            }
            state.Transaction.Complete();
        }
        catch (Exception e)
        {
            Console.Error.WriteLine(e);
            state.Transaction.Rollback();
        }
        finally
        {
            state.Done.Set();
        }

    }

В 64-разрядном Python:

>>> xrange(9999999999999)
xrange(9999999999999)

я не буду использовать диапазон () для 13-значного номера. Моя бедная машина не сможет удержать результирующий список.