Как найти минимальную дату в python

snapshots = ['2014-04-05',
        '2014-04-06',
        '2014-04-07',
        '2014-04-08',
        '2014-04-09']

earliest_date = snapshots[0]
earliest_date = [earliest_date for snapshot in snapshots if earliest_date > snapshot]

for snapshot in snapshots:
    if earliest_date > snapshot:
        earliest_date = snapshot

3

snapshots = ['2014-04-05',
        '2014-04-06',
        '2014-04-07',
        '2014-04-08',
        '2014-04-09']

earliest_date = snapshots[0]
earliest_date = [earliest_date for snapshot in snapshots if earliest_date > snapshot]

for snapshot in snapshots:
    if earliest_date > snapshot:
        earliest_date = snapshot

2014-07-28 19:14

3
ответа

Решение

earliest_date = min(snapshots)
lastest_date = max(snapshots)

earliest_date = snapshots[0]
lastest_date = snapshots[-1]

>>> snapshots = ['2014-04-05',
...         '2014-04-06',
...         '2014-04-07',
...         '2014-04-08',
...         '2014-04-09']
>>> min(snapshots)
'2014-04-05'

>>> snapshots = ['2014-04-05',
        '2014-04-06',
        '2014-04-07',
        '2014-04-08',
        '2014-04-09']

>>> min(snapshots)
2014-04-05

      from dateutil import parser
snapshots = ['2014-04-05',
        '2014-04-06',
        '2014-04-07',
        '2014-04-08',
        '2014-04-09']

snapshots = [parser.parse(i).date() for i in snapshots ]

max_date = max(snapshots )
min_date = min(snapshots )
print(max_date)
print(min_date)

Мне нужно найти минимальную дату из списка объектов времени даты в python. Однако создание списка вызывает синтаксическую ошибку в оболочке Python.

l = [datetime.datetime(2015, 3, 18, 13, 45, 2, tzinfo=<UTC>),datetime.datetime(2015, 3, 18, 3, 45, 2, tzinfo=<UTC>)]

Приведенное выше дает

File "<stdin>", line 1
l = [datetime.datetime(2015, 3, 18, 13, 45, 2, tzinfo=<UTC>),datetime.datetime(2015, 3, 18, 3, 45, 2, tzinfo=<UTC>)]
^
SyntaxError: invalid syntax .

Как преодолеть это и получить минимум из списка.

Это синтаксическая ошибка, потому что вы вставляете в <UTC> который не является законным Python, это просто метод __repr__ для объекта часового пояса. Используйте библиотеку часового пояса, такую как pytz если для вас важны временные pytz, в противном случае просто отбросьте их.

Прошлое, вы можете называть min на все, что реализует __lt__, что datetime время. Просто назовите min в списке datetimes, и он будет работать.

Я думаю, это поможет

In [1]: import datetime

In [2]: import pytz

In [3]: l = [datetime.datetime(2015, 3, 18, 13, 45, 2, tzinfo=pytz.UTC),datetime.datetime(2015, 3, 18, 3, 45, 2, tzinfo=pytz.UTC)]

In [4]: min(l)
Out[4]: datetime.datetime(2015, 3, 18, 3, 45, 2, tzinfo=<UTC>)

Привет, я борюсь с поиском столбца максимальных и минимальных значений в моем наборе данных.

Ниже мой набор данных:

customer_final['tran_date']

0       2014-02-28
1       2014-02-27
2       2014-02-24
3       2014-02-24
4       2014-02-23
           ...    
23048   2011-01-25
23049   2011-01-25
23050   2011-01-25
23051   2011-01-25
23052   2011-01-25

Как ясно видно из набора данных, у нас есть данные в период с 2011-01-25 по 2014-02-28.

Но выполнение приведенного ниже кода дает мне неправильный вывод.

print(customer_final['tran_date'].max())
print(customer_final['tran_date'].min())

2014-12-02 00:00:00
2011-01-02 00:00:00

Любая помощь будет высоко ценится.

Редактировать: публикация необработанных данных.

transaction_id  cust_id tran_date   prod_subcat_code    prod_cat_code   Qty Rate    Tax total_amt   Store_type
0   80712190438 270351  28-02-2014  1   1   -5  -772    405.300 -4265.300   e-Shop
1   29258453508 270384  27-02-2014  5   3   -5  -1497   785.925 -8270.925   e-Shop
2   51750724947 273420  24-02-2014  6   5   -2  -791    166.110 -1748.110   TeleShop
3   93274880719 271509  24-02-2014  11  6   -3  -1363   429.345 -4518.345   e-Shop
4   51750724947 273420  23-02-2014  6   5   -2  -791    166.110 -1748.110   TeleShop
... ... ... ... ... ... ... ... ... ... ...
23048   94340757522 274550  25-01-2011  12  5   1   1264    132.720 1396.720    e-Shop
23049   89780862956 270022  25-01-2011  4   1   1   677 71.085  748.085 e-Shop
23050   85115299378 271020  25-01-2011  2   6   4   1052    441.840 4649.840    MBR
23051   72870271171 270911  25-01-2011  11  5   3   1142    359.730 3785.730    TeleShop
23052   77960931771 271961  25-01-2011  11  5   1   447 46.935  493.935 TeleShop

Изменить 2: Типы данных всех столбцов в DF.

transaction_id               int64
cust_id                      int64
tran_date           datetime64[ns]
prod_subcat_code             int64
prod_cat_code                int64
Qty                          int64
Rate                         int64
Tax                        float64
total_amt                  float64
Store_type                  object
Unnamed: 10                 object
dtype: object

Очевидно, у вас есть даты (во входном файле), отформатированные различными способами.

Один из ваших комментариев содержит Timestamp('2014-12-02 00:00:00'), поэтому я вижу, что у вас есть форматирование % Y-% m-% d (возможно, в большинстве случаев), но в другом месте вы написали time data '12/2/2014', так что по крайней мере в некоторых строках у вас есть форматирование % d /% m /% Y .

Приведите свой вклад в порядок. Вы не можете иметь даты, отформатированные в двух разных форматах.

Редактировать

Я выполнил следующий эксперимент:

В качестве исходных данных я использовал часть ваших необработанных данных (первые 2 и последние 2 строки) с дополнительной строкой (№ 3) с различным форматированием даты, которая хранится в виде строковой переменной:

  transaction_id cust_id tran_date prod_subcat_code prod_cat_code Qty Rate Tax total_amt Store_type
3       93274880719 271509  24-02-2014  11  6   -3  -1363   429.345 -4518.345   e-Shop
4       51750724947 273420  23-02-2014  6   5   -2  -791    166.110 -1748.110   TeleShop
40      51750724947 273420  12/2/2014   6   5   -2  -791    166.110 -1748.110   TeleShop
23048   94340757522 274550  25-01-2011  12  5   1   1264    132.720 1396.720    e-Shop
23049   89780862956 270022  25-01-2011  4   1   1   677     71.085  748.085     e-Shop'''

Обратите внимание, что начальная строка имеет несколько пробелов в начале, чтобы предоставить пустое имя столбца для столбца индекса.

Затем я определил следующую функцию разбора даты (import re требуется), будет использоваться в ближайшее время:

def dPars(txt):
    if re.match(r'd{2}-d{1,2}-d{4}', txt):
        return pd.to_datetime(txt, format='%d-%m-%Y')
    if re.match(r'd{2}/d{1,2}/d{4}', txt):
        return pd.to_datetime(txt, format='%d/%m/%Y')
    return txt

Я прочитал вышеупомянутое содержание, с вышеупомянутой функцией конвертера даты:

customer_final = pd.read_csv(io.StringIO(txt), delim_whitespace=True,
    index_col=0, parse_dates=['tran_date'], date_parser=dPars)

Я напечатал столбец tran_date – print(customer_final.tran_date) – получаю

3       2014-02-24
4       2014-02-23
40      2014-02-12
23048   2011-01-25
23049   2011-01-25
Name: tran_date, dtype: datetime64[ns]

Поэтому все даты были проанализированы, как и должно быть.

Я напечатал минимальные / максимальные даты – print(customer_final['tran_date'].min(), customer_final['tran_date'].max()) – получая правильный результат:

2011-01-25 00:00:00 2014-02-24 00:00:00

Может быть, вы должны основывать свой код на моем эксперименте (в вашем коде заменить io.StringIO(txt) с вашим именем входного файла).

Также обратите внимание, что если у вас есть входная строка, отформатированная как 12/2/2014, то 12 – это число месяца , а 2 – это число дня (формат даты в США), тогда как другие строки имеют номер дня первым.

По сути, у вас есть две проблемы: 1) просмотр сокращенных данных и 2) просмотр несортированных данных.

Вы заявляете: Как ясно видно из набора данных, у нас есть данные в период с 2011-01-25 по 2014-02-28. Тем не менее, Pandas сокращает ваш несортированный данных, пропуская много строк вашего фрейма данных 23k строк с многоточием: .... Следовательно, эта ручная проверка дат, которые вы цитируете, происходит только из начала и конца неупорядоченных данных, которые не будут совпадать со значениями min и max.

customer_final['tran_date']

# 0       2014-02-28       # <---- HEAD OF UNSORTED DATA
# 1       2014-02-27
# 2       2014-02-24
# 3       2014-02-24
# 4       2014-02-23
#            ...           # <---- OMITTED VALUES OF UNSORTED DATA 
# 23048   2011-01-25
# 23049   2011-01-25
# 23050   2011-01-25
# 23051   2011-01-25
# 23052   2011-01-25       # <---- TAIL OF UNSORTED DATA

# SORT DATA FRAME IN DESCENDING ORDER BY tran_date
customer_final = customer_final.sort_values(by='tran_date', ascending = False)

# VIEW ALL DATA (ABBREVIATED UNLESS YOU CHANGE SETTING)
customer_final['tran_date']

# VIEW FIRST VALUES (DEFAULT TO 5)
customer_final['tran_date'].head(5)

# VIEW LAST VALUES (DEFAULT TO 5)
customer_final['tran_date'].tail(5)

def get_date(self, instance):
        user = instance.id
        today = date.today()

        if instance.date is not None:
            return instance.date

        # calculate last reported day if no specific date is set
        max_absence_date = Absence.objects.filter(user=user, date__lt=today).aggregate(
            date=Max("date")
        )
        max_report_date = Report.objects.filter(user=user, date__lt=today).aggregate(
            date=Max("date")
        )

        last_reported_date = max(
            max_absence_date["date"] or date.min, max_report_date["date"] or date.min
        )

        instance.date = last_reported_date
        return instance.date 

def start(self, data):
        # write down the 'reset when' value
        if not isinstance(self.p.when, integer_types):  # expect time/datetime
            self._rstwhen = self.p.when
            self._tzdata = self.p.tzdata
        else:
            self._tzdata = data if self.p.tzdata is None else self.p.tzdata

            if self.p.when == SESSION_START:
                self._rstwhen = self._tzdata.p.sessionstart
            elif self.p.when == SESSION_END:
                self._rstwhen = self._tzdata.p.sessionend

        self._isdata = isinstance(self._tzdata, AbstractDataBase)
        self._reset_when()

        self._nexteos = datetime.min
        self._curdate = date.min

        self._curmonth = -1  # non-existent month
        self._monthmask = collections.deque()

        self._curweek = -1  # non-existent week
        self._weekmask = collections.deque() 

def cast_date(value, connection):
    """Cast a date value."""
    # The output format depends on the server setting DateStyle.  The default
    # setting ISO and the setting for German are actually unambiguous.  The
    # order of days and months in the other two settings is however ambiguous,
    # so at least here we need to consult the setting to properly parse values.
    if value == '-infinity':
        return date.min
    if value == 'infinity':
        return date.max
    value = value.split()
    if value[-1] == 'BC':
        return date.min
    value = value[0]
    if len(value) > 10:
        return date.max
    fmt = connection.date_format()
    return datetime.strptime(value, fmt).date() 

def cast_timestamp(value, connection):
    """Cast a timestamp value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:5]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
    else:
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    return datetime.strptime(' '.join(value), ' '.join(fmt)) 

def cast_date(value, connection):
    """Cast a date value."""
    # The output format depends on the server setting DateStyle.  The default
    # setting ISO and the setting for German are actually unambiguous.  The
    # order of days and months in the other two settings is however ambiguous,
    # so at least here we need to consult the setting to properly parse values.
    if value == '-infinity':
        return date.min
    if value == 'infinity':
        return date.max
    value = value.split()
    if value[-1] == 'BC':
        return date.min
    value = value[0]
    if len(value) > 10:
        return date.max
    fmt = connection.date_format()
    return datetime.strptime(value, fmt).date() 

def cast_timestamp(value, connection):
    """Cast a timestamp value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:5]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
    else:
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    return datetime.strptime(' '.join(value), ' '.join(fmt)) 

def testTruncateRestart(self):
        truncate = self.db.truncate
        self.assertRaises(TypeError, truncate, 'test_table', restart='invalid')
        query = self.db.query
        self.createTable('test_table', 'n serial, t text')
        for n in range(3):
            query("insert into test_table (t) values ('test')")
        q = "select count(n), min(n), max(n) from test_table"
        r = query(q).getresult()[0]
        self.assertEqual(r, (3, 1, 3))
        truncate('test_table')
        r = query(q).getresult()[0]
        self.assertEqual(r, (0, None, None))
        for n in range(3):
            query("insert into test_table (t) values ('test')")
        r = query(q).getresult()[0]
        self.assertEqual(r, (3, 4, 6))
        truncate('test_table', restart=True)
        r = query(q).getresult()[0]
        self.assertEqual(r, (0, None, None))
        for n in range(3):
            query("insert into test_table (t) values ('test')")
        r = query(q).getresult()[0]
        self.assertEqual(r, (3, 1, 3)) 

def testDate(self):
        query = self.db.query
        for datestyle in ('ISO', 'Postgres, MDY', 'Postgres, DMY',
                'SQL, MDY', 'SQL, DMY', 'German'):
            self.db.set_parameter('datestyle', datestyle)
            d = date(2016, 3, 14)
            q = "select $1::date"
            r = query(q, (d,)).getresult()[0][0]
            self.assertIsInstance(r, date)
            self.assertEqual(r, d)
            q = "select '10000-08-01'::date, '0099-01-08 BC'::date"
            r = query(q).getresult()[0]
            self.assertIsInstance(r[0], date)
            self.assertIsInstance(r[1], date)
            self.assertEqual(r[0], date.max)
            self.assertEqual(r[1], date.min)
        q = "select 'infinity'::date, '-infinity'::date"
        r = query(q).getresult()[0]
        self.assertIsInstance(r[0], date)
        self.assertIsInstance(r[1], date)
        self.assertEqual(r[0], date.max)
        self.assertEqual(r[1], date.min) 

def cast_date(value, connection):
    """Cast a date value."""
    # The output format depends on the server setting DateStyle.  The default
    # setting ISO and the setting for German are actually unambiguous.  The
    # order of days and months in the other two settings is however ambiguous,
    # so at least here we need to consult the setting to properly parse values.
    if value == '-infinity':
        return date.min
    if value == 'infinity':
        return date.max
    value = value.split()
    if value[-1] == 'BC':
        return date.min
    value = value[0]
    if len(value) > 10:
        return date.max
    fmt = connection.date_format()
    return datetime.strptime(value, fmt).date() 

def cast_date(value, connection):
    """Cast a date value."""
    # The output format depends on the server setting DateStyle.  The default
    # setting ISO and the setting for German are actually unambiguous.  The
    # order of days and months in the other two settings is however ambiguous,
    # so at least here we need to consult the setting to properly parse values.
    if value == '-infinity':
        return date.min
    if value == 'infinity':
        return date.max
    value = value.split()
    if value[-1] == 'BC':
        return date.min
    value = value[0]
    if len(value) > 10:
        return date.max
    fmt = connection.date_format()
    return datetime.strptime(value, fmt).date() 

def cast_timestamp(value, connection):
    """Cast a timestamp value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:5]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
    else:
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    return datetime.strptime(' '.join(value), ' '.join(fmt)) 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False) 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False) 

def _make_combined_transactions(self):
        """
        Combine all Transactions and ScheduledTransactions from
        ``self._data_cache`` into one ordered list of similar dicts, adding
        dates to the monthly ScheduledTransactions as appropriate and excluding
        ScheduledTransactions that have been converted to real Transactions.
        Store the finished list back into ``self._data_cache``.
        """
        unordered = []
        # ScheduledTransaction ID to count of real trans for each
        st_ids = defaultdict(int)
        for t in self._data_cache['transactions']:
            unordered.append(self._trans_dict(t))
            if t.scheduled_trans_id is not None:
                st_ids[t.scheduled_trans_id] += 1
        for t in self._data_cache['st_date']:
            if t.id not in st_ids:
                unordered.append(self._trans_dict(t))
        for t in self._data_cache['st_monthly']:
            if t.id not in st_ids:
                unordered.append(self._trans_dict(t))
        ordered = []
        for t in self._data_cache['st_per_period']:
            d = self._trans_dict(t)
            for _ in range(0, (t.num_per_period - st_ids[t.id])):
                ordered.append(d)
        for t in sorted(unordered, key=lambda k: k['date']):
            ordered.append(t)

        def sortkey(k):
            d = k.get('date', None)
            if d is None:
                d = date.min
            return d, k['amount']

        return sorted(ordered, key=sortkey) 

def __init__(self, env, retry_times=5, retry_interval=1):
        self._env = env

        self._retry_times = retry_times
        self._retry_interval = retry_interval

        self._cache = DataCache()

        self._query_returns = {}
        self._data_update_date = date.min

        self.td_api = None

        Environment.get_ins_dict = self.get_ins_dict 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False) 

def test_timespan_list():
    x = N([])
    assert x._t == _k.KN
    d = timedelta(1, 2, 3)
    x = N([None, d, timedelta.max, timedelta.min])
    assert eq(x, q('0N 1D00:00:02.000003 0W -0Wn')) 

def test_date_and_month_extremes():
    dates = [date.min, date.max]
    assert eq(M(dates), q('0001.01 9999.12m'))
    assert eq(D(dates), q('0001.01.01 9999.12.31')) 

def _reset_when(self, ddate=datetime.min):
        self._when = self._rstwhen
        self._dtwhen = self._dwhen = None

        self._lastcall = ddate 

def _check_week(self, ddate=date.min):
        if not self.p.weekdays:
            return True

        _, dweek, dwkday = ddate.isocalendar()

        mask = self._weekmask
        daycarry = False
        if dweek != self._curweek:
            self._curweek = dweek  # write down new month
            daycarry = self.p.weekcarry and bool(mask)
            self._weekmask = mask = collections.deque(self.p.weekdays)

        dc = bisect.bisect_left(mask, dwkday)  # "left" for days before dday
        daycarry = daycarry or (self.p.weekcarry and dc > 0)
        if dc < len(mask):
            curday = bisect.bisect_right(mask, dwkday, lo=dc) > 0  # check dday
            dc += curday
        else:
            curday = False

        while dc:
            mask.popleft()
            dc -= 1

        return daycarry or curday 

def cast_timestamptz(value, connection):
    """Cast a timestamptz value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
        value, tz = value[:-1], value[-1]
    else:
        if fmt.startswith('%Y-'):
            tz = _re_timezone.match(value[1])
            if tz:
                value[1], tz = tz.groups()
            else:
                tz = '+0000'
        else:
            value, tz = value[:-1], value[-1]
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    if _has_timezone:
        value.append(_timezone_as_offset(tz))
        fmt.append('%z')
        return datetime.strptime(' '.join(value), ' '.join(fmt))
    return datetime.strptime(' '.join(value), ' '.join(fmt)).replace(
        tzinfo=_get_timezone(tz)) 

def testTimestamp(self):
        query = self.db.query
        for datestyle in ('ISO', 'Postgres, MDY', 'Postgres, DMY',
                'SQL, MDY', 'SQL, DMY', 'German'):
            self.db.set_parameter('datestyle', datestyle)
            d = datetime(2016, 3, 14)
            q = "select $1::timestamp"
            r = query(q, (d,)).getresult()[0][0]
            self.assertIsInstance(r, datetime)
            self.assertEqual(r, d)
            d = datetime(2016, 3, 14, 15, 9, 26)
            q = "select $1::timestamp"
            r = query(q, (d,)).getresult()[0][0]
            self.assertIsInstance(r, datetime)
            self.assertEqual(r, d)
            d = datetime(2016, 3, 14, 15, 9, 26, 535897)
            q = "select $1::timestamp"
            r = query(q, (d,)).getresult()[0][0]
            self.assertIsInstance(r, datetime)
            self.assertEqual(r, d)
            q = ("select '10000-08-01 AD'::timestamp,"
                " '0099-01-08 BC'::timestamp")
            r = query(q).getresult()[0]
            self.assertIsInstance(r[0], datetime)
            self.assertIsInstance(r[1], datetime)
            self.assertEqual(r[0], datetime.max)
            self.assertEqual(r[1], datetime.min)
        q = "select 'infinity'::timestamp, '-infinity'::timestamp"
        r = query(q).getresult()[0]
        self.assertIsInstance(r[0], datetime)
        self.assertIsInstance(r[1], datetime)
        self.assertEqual(r[0], datetime.max)
        self.assertEqual(r[1], datetime.min) 

def testTimestamptz(self):
        query = self.db.query
        timezones = dict(CET=1, EET=2, EST=-5, UTC=0)
        for timezone in sorted(timezones):
            tz = '%+03d00' % timezones[timezone]
            try:
                tzinfo = datetime.strptime(tz, '%z').tzinfo
            except ValueError:  # Python < 3.2
                tzinfo = pg._get_timezone(tz)
            self.db.set_parameter('timezone', timezone)
            for datestyle in ('ISO', 'Postgres, MDY', 'Postgres, DMY',
                    'SQL, MDY', 'SQL, DMY', 'German'):
                self.db.set_parameter('datestyle', datestyle)
                d = datetime(2016, 3, 14, tzinfo=tzinfo)
                q = "select $1::timestamptz"
                r = query(q, (d,)).getresult()[0][0]
                self.assertIsInstance(r, datetime)
                self.assertEqual(r, d)
                d = datetime(2016, 3, 14, 15, 9, 26, tzinfo=tzinfo)
                q = "select $1::timestamptz"
                r = query(q, (d,)).getresult()[0][0]
                self.assertIsInstance(r, datetime)
                self.assertEqual(r, d)
                d = datetime(2016, 3, 14, 15, 9, 26, 535897, tzinfo)
                q = "select $1::timestamptz"
                r = query(q, (d,)).getresult()[0][0]
                self.assertIsInstance(r, datetime)
                self.assertEqual(r, d)
                q = ("select '10000-08-01 AD'::timestamptz,"
                    " '0099-01-08 BC'::timestamptz")
                r = query(q).getresult()[0]
                self.assertIsInstance(r[0], datetime)
                self.assertIsInstance(r[1], datetime)
                self.assertEqual(r[0], datetime.max)
                self.assertEqual(r[1], datetime.min)
        q = "select 'infinity'::timestamptz, '-infinity'::timestamptz"
        r = query(q).getresult()[0]
        self.assertIsInstance(r[0], datetime)
        self.assertIsInstance(r[1], datetime)
        self.assertEqual(r[0], datetime.max)
        self.assertEqual(r[1], datetime.min) 

def cast_timestamptz(value, connection):
    """Cast a timestamptz value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
        value, tz = value[:-1], value[-1]
    else:
        if fmt.startswith('%Y-'):
            tz = _re_timezone.match(value[1])
            if tz:
                value[1], tz = tz.groups()
            else:
                tz = '+0000'
        else:
            value, tz = value[:-1], value[-1]
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    if _has_timezone:
        value.append(_timezone_as_offset(tz))
        fmt.append('%z')
        return datetime.strptime(' '.join(value), ' '.join(fmt))
    return datetime.strptime(' '.join(value), ' '.join(fmt)).replace(
        tzinfo=_get_timezone(tz)) 

def cast_timestamptz(value, connection):
    """Cast a timestamptz value."""
    if value == '-infinity':
        return datetime.min
    if value == 'infinity':
        return datetime.max
    value = value.split()
    if value[-1] == 'BC':
        return datetime.min
    fmt = connection.date_format()
    if fmt.endswith('-%Y') and len(value) > 2:
        value = value[1:]
        if len(value[3]) > 4:
            return datetime.max
        fmt = ['%d %b' if fmt.startswith('%d') else '%b %d',
            '%H:%M:%S.%f' if len(value[2]) > 8 else '%H:%M:%S', '%Y']
        value, tz = value[:-1], value[-1]
    else:
        if fmt.startswith('%Y-'):
            tz = _re_timezone.match(value[1])
            if tz:
                value[1], tz = tz.groups()
            else:
                tz = '+0000'
        else:
            value, tz = value[:-1], value[-1]
        if len(value[0]) > 10:
            return datetime.max
        fmt = [fmt, '%H:%M:%S.%f' if len(value[1]) > 8 else '%H:%M:%S']
    if _has_timezone:
        value.append(_timezone_as_offset(tz))
        fmt.append('%z')
        return datetime.strptime(' '.join(value), ' '.join(fmt))
    return datetime.strptime(' '.join(value), ' '.join(fmt)).replace(
        tzinfo=_get_timezone(tz)) 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False) 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False) 

def presence_percentage(self):
        event_time = 0
        for day in self.event.eventday_set.all():
            event_time += (datetime.combine(date.min, day.end) - datetime.combine(date.min, day.start)).seconds

        checked_time = 0
        for checked_day in self.eventdaycheck_set.filter(exit_date__isnull=False):
            checked_time += (checked_day.exit_date - checked_day.entrance_date).seconds

        result = checked_time * 100 / event_time

        return result 

def test_pivot_integer_columns(self):
        # caused by upstream bug in unstack

        d = date.min
        data = list(product(['foo', 'bar'], ['A', 'B', 'C'], ['x1', 'x2'],
                            [d + timedelta(i)
                             for i in range(20)], [1.0]))
        df = DataFrame(data)
        table = df.pivot_table(values=4, index=[0, 1, 3], columns=[2])

        df2 = df.rename(columns=str)
        table2 = df2.pivot_table(
            values='4', index=['0', '1', '3'], columns=['2'])

        tm.assert_frame_equal(table, table2, check_names=False)