Работа с датой и временем в python

Специфичные для потока данные

Некоторые ресурсы должны быть заблокированы, чтобы их могли использовать сразу несколько потоков. А другие должны быть защищены от просмотра в потоках, которые не «владеют» ими. Функция local() создает объект, способный скрывать значения для отдельных потоков.

import random
import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)


def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

local_data = threading.local()
show_value(local_data)
local_data.value = 1000
show_value(local_data)

for i in range(2):
    t = threading.Thread(target=worker, args=(local_data,))
    t.start()

Обратите внимание, что значение local_data.value не доступно ни для одного потока, пока не будет установлено

$ python threading_local.py

(MainThread) No value yet
(MainThread) value=1000
(Thread-1  ) No value yet
(Thread-1  ) value=34
(Thread-2  ) No value yet
(Thread-2  ) value=7

Чтобы все потоки начинались с одного и того же значения, используйте подкласс и установите атрибуты с помощью метода __init __() .

import random
import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )


def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)

def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

class MyLocal(threading.local):
    def __init__(self, value):
        logging.debug('Initializing %r', self)
        self.value = value

local_data = MyLocal(1000)
show_value(local_data)

for i in range(2):
    t = threading.Thread(target=worker, args=(local_data,))
    t.start()

__init __() вызывается для каждого объекта (обратите внимание на значение id()) один раз в каждом потоке

$ python threading_local_defaults.py

(MainThread) Initializing <__main__.MyLocal object at 0x100514390>
(MainThread) value=1000
(Thread-1  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=1000
(Thread-2  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=81
(Thread-2  ) value=1000
(Thread-2  ) value=54

Данная публикация является переводом статьи «threading – Manage concurrent threads» , подготовленная редакцией проекта.

11 ответов

Лучший ответ

Для того, что мне нужно, вот что я сделал, основываясь на комментарии @samplebias выше:

Quick’n’easy . Спасибо всем, простите за пукание мозга.

Для повторного использования:

Затем:

672

Naftuli Kay
9 Сен 2013 в 21:24

44

user3324131
18 Фев 2014 в 15:36

Просто пример кода:

Выход: 1534343781311

16

Wilson Wu
15 Авг 2018 в 14:37

Эти умножения до 1000 для миллисекунд могут быть приличными для решения или принятия некоторого предварительного условия приемлемым. Это может быть использовано, чтобы заполнить пробел в вашей базе данных, который на самом деле никогда не использует его. Хотя, для реальных ситуаций, которые требуют точного времени, это в конечном итоге потерпит неудачу. Я бы не советовал никому использовать этот метод для критически важных операций, которые требуют действий или обработки в определенные моменты времени.

Например: пинг в оба конца 30-80 мс в США … Вы не могли бы просто округлить это и использовать это эффективно.

Мой собственный пример требует выполнения задач каждую секунду, что означает, что если я соберусь после того, как первые задачи ответят, я все равно буду брать на себя время обработки, умноженное на каждый цикл основного цикла. В итоге это был полный вызов функции каждые 60 секунд. это ~ 1440 в день .. не слишком точно.

Просто мысль для людей, ищущих более точные рассуждения, помимо решения проблемы с базой данных, которая никогда не использует их.

Ratan Uday Kumar
17 Июн 2019 в 06:12

Если вы используете мой код (ниже), время будет отображаться в секундах, а затем, после десятичной точки, в миллисекундах. Я думаю, что есть разница между Windows и Unix — пожалуйста, прокомментируйте, если есть.

Мой результат (на Windows) был:

РЕДАКТИРОВАТЬ . Разницы нет 🙂 Спасибо tc0nn

PythonMaster202
24 Дек 2019 в 18:49

Если вы беспокоитесь об измерении прошедшего времени, вам следует использовать . На эти часы не влияют обновления системных часов, как, например, если бы запрос NTP скорректировал ваше системное время.

Он предоставляет эталонное время в секундах, которое можно использовать для последующего сравнения для измерения прошедшего времени.

5

phord
9 Сен 2019 в 21:59

Самый простой способ узнать текущее время UTC в миллисекундах:

5

Laymain
2 Май 2018 в 13:32

Другое решение — это функция, которую вы можете встроить в свой собственный utils.py.

12

I. J. Kennedy
30 Дек 2012 в 18:05

В вы можете использовать для получения время как прошло нано секунд с эпохи. Так что вы можете сделать

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

26

zardosht
4 Июн 2019 в 11:42

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

87

Delgan
9 Ноя 2018 в 13:39

Если вам нужен простой метод в вашем коде, который возвращает миллисекунды с датой и временем:

10

Pascal
20 Фев 2013 в 11:03

Форматирование даты с помощью strftime()

from datetime import datetime

# current date and time
now = datetime.now()

t = now.strftime("%H:%M:%S")
print("time:", t)

s1 = now.strftime("%m/%d/%Y, %H:%M:%S")
# mm/dd/YY H:M:S format
print("s1:", s1)

s2 = now.strftime("%d/%m/%Y, %H:%M:%S")
# dd/mm/YY H:M:S format
print("s2:", s2)

Когда вы запустите программу, результат будет примерно таким:

time: 04:34:52
s1: 12/26/2018, 04:34:52
s2: 26/12/2018, 04:34:52

Здесь % Y,% m,% d,% H и т.д. являются кодами формата. Метод strftime() принимает один или несколько кодов формата и возвращает на его основе отформатированную строку.

В приведенной выше программе t  s1 и s2 -‒ это строки:

• % Y — год
• % m — месяц
• % d — день
• % H — час [00, 01, …, 22, 23
• % M — минута
• % S — секунда

Время выполнения программы

Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов time() для получения текущего времени, чтобы в конечном итоге выявить, как долго работал блок кода. Метод sleep() здесь увеличивает время выполнения программы на 5 секунд.

import time
start = time.time()
time.sleep(5)
finish = time.time()
result = finish - start
print("Program time: " + str(result) + " seconds.")

Program time: 5.005090236663818 seconds.

Несмотря на простоту вышеописанного подхода, использовать его в серьезных целях, где требуется точный и независимый от ОС результат, не рекомендуется. Все дело в том, что числовое значение времени, получаемое таким образом, может иметь погрешности за счет внутренних особенностей работы компьютера, в среде которого выполняется программа. Например, системные часы могут быть подкорректированы вручную пользователем во время выполнения программы. Корректировка может произойти и автоматически, если настроена синхронизация системных часов по NTP.

Таким образом, может случиться такая ситуация, что функция вернет значение меньшее, чем при предыдущем вызове.

monotonic

По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.

import time
start = time.monotonic()
time.sleep(15)
result = time.monotonic() - start
print("Program time: {:>.3f}".format(result) + " seconds.")

Program time: 15.012 seconds.

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

Таймер Python с использованием потоковой передачи

Когда мы хотим выполнить какую-то операцию или хотим, чтобы наша функция выполнялась через определенное время, мы используем класс Python Timer. Класс timer является подклассом класса threading. Технически можно сказать, что мы создаем объекты таймера, когда хотим, чтобы действия (функции) были ограничены временем.

Например, предположим, что мы хотим организовать викторину, где участник должен ответить на каждый вопрос за 10 секунд. Здесь мы можем создать таймер, который будет работать в фоновом режиме, а тем временем участник будет думать над ответом. Теперь давайте разберемся, как создать объект timer .

Синтаксис класса Timer в Python

Если вы не поняли, что делает класс Timer, вы можете думать об этом следующим образом – Класс Timer вызывает функцию через заданное количество секунд.

Чтобы запустить таймер, нам нужно вызвать start()(как и обычные потоки), а чтобы остановить таймер, пока он все еще находится в фоновом режиме, мы можем вызвать cancel().

Чтобы использовать класс Timer, нам нужно импортировать класс threading

<сильная>резьба.Таймер(интервал, функция,,)

Параметры-

Интервал– Время (в секундах), которое вы хотите подождать перед вызовом следующей функции. Он может быть либо в float, либо в integer. Например, в течение 3 секунд.

Функция – Функция, которую вы хотите вызвать через указанный промежуток времени.

Распространенным способом описания параметров *args и **kwargs является- создание объекта таймера, который запускает функцию с аргументами’ args’ и аргументами ключевых слов’ kwargs’ после того, как прошли интервальные секунды. Args должны быть в виде списка и ключевого слова args или kwargs в виде словаря .

Методы в классе Timer

1. start() – Это означает начало выполнения таймера.
2. Cancel ()– Во время выполнения таймера мы можем вызвать функцию cancel, если хотим остановить его ().

Создание объекта таймера

<сильный>а. Понимание основ

Чтобы понять, как работает объект Timer, давайте создадим небольшую программу, которая поможет нам понять основы класса.

# Importing the Timer subclass from the threading Class
from threading import Timer

# creating a basic function that will print "hello"
def hello():
    print ("hello, world")

# creating the object of the Timer subclass
# Here, 5 sec means that the execution of the after 5 seconds(interval=5.0,)

# starting the execution
t.start() # after 30 seconds, "hello, world" will be printed

Output-
hello, world

Вы лучше поймете функционирование вышеприведенной программы, когда попытаетесь запустить ее самостоятельно href=”https://en.wikipedia.org/wiki/System”>система. href=”https://en.wikipedia.org/wiki/System”>система.

<сильный>б. Использование метода отмены

Давайте посмотрим, как использовать функцию cancel() класса Timer.

# Importing the Timer subclass from the threading Class
from threading import Timer

# creating a basic function that will print "hello"
def hello():
    print ("hello world")
    
# creating the object of the Timer subclass
# Here, 5 sec means that the execution of the after 5 seconds(interval=5.0,)
    
# starting the execution
t.start() # after 30 seconds, "hello, world" will be printed

print("Execution begins")

# cancelling the execution of the 'hello' function
t.cancel()
print("END")

Execution begins 
END

c. Как использовать параметр ‘args’ класса python timer

Когда нам нужно дать аргументы функции, которую нужно вызвать, мы используем параметр args. Мы должны дать аргумент args в массиве.

import threading

# To take multiple inputs we can use *before the parameter.
def print_name(*names):
    # From the array of names pick one name and print it
    for name in names:
        print("Hello",name)

# In the args parameter, give an array of names .Timer(3, print_name,)

# start the execution
t.start()
print("Execution begins...")

Execution begins...
Hello Ashwini
Hello Vandy
Hello Arijit

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

Examples¶

It is possible to provide a setup statement that is executed only once at the beginning:

$ python -m timeit -s 'text = "sample string"; char = "g"'  'char in text'
5000000 loops, best of 5: 0.0877 usec per loop
$ python -m timeit -s 'text = "sample string"; char = "g"'  'text.find(char)'
1000000 loops, best of 5: 0.342 usec per loop

>>> import timeit
>>> timeit.timeit('char in text', setup='text = "sample string"; char = "g"')
0.41440500499993504
>>> timeit.timeit('text.find(char)', setup='text = "sample string"; char = "g"')
1.7246671520006203

The same can be done using the class and its methods:

>>> import timeit
>>> t = timeit.Timer('char in text', setup='text = "sample string"; char = "g"')
>>> t.timeit()
0.3955516149999312
>>> t.repeat()

The following examples show how to time expressions that contain multiple lines.
Here we compare the cost of using vs. /
to test for missing and present object attributes:

$ python -m timeit 'try:' '  str.__bool__' 'except AttributeError:' '  pass'
20000 loops, best of 5: 15.7 usec per loop
$ python -m timeit 'if hasattr(str, "__bool__"): pass'
50000 loops, best of 5: 4.26 usec per loop

$ python -m timeit 'try:' '  int.__bool__' 'except AttributeError:' '  pass'
200000 loops, best of 5: 1.43 usec per loop
$ python -m timeit 'if hasattr(int, "__bool__"): pass'
100000 loops, best of 5: 2.23 usec per loop

>>> import timeit
>>> # attribute is missing
>>> s = """\
... try:
...     str.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.9138244460009446
>>> s = "if hasattr(str, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.5829014980008651
>>>
>>> # attribute is present
>>> s = """\
... try:
...     int.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.04215312199994514
>>> s = "if hasattr(int, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.08588060699912603

To give the module access to functions you define, you can pass a
setup parameter which contains an import statement:

def test():
    """Stupid test function"""
    L = i for i in range(100)]

if __name__ == '__main__'
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

Another option is to pass to the globals parameter, which will cause the code
to be executed within your current global namespace. This can be more convenient
than individually specifying imports:

def f(x):
    return x**2
def g(x):
    return x**4
def h(x):
    return x**8

import timeit
print(timeit.timeit('', globals=globals()))

Timing Multiple lines in python code

There are two you can execute multiple lines of code in timeit.timeit(), using a semicolon or by saving the code enclosed as a string with triple quotes.

Here are examples that show the working of it.

Example 1: Using semicolon

import timeit
print("The time taken is ",timeit.timeit(stmt='a=10;b=10;sum=a+b'))

Output:

The time taken is  0.137031482

Example 2: Using triple quotes

import timeit
import_module = "import random"
testcode = ''' 
def test(): 
    return random.randint(10, 100)
'''
print(timeit.repeat(stmt=testcode, setup=import_module))

Output:

C:\pythontest>python testtimeit.py
The time taken is  0.182619178

Многопоточность на Python

За пото­ки в Python отве­ча­ет модуль threading, а сам поток мож­но создать с помо­щью клас­са Thread из это­го моду­ля. Под­клю­ча­ет­ся он так:

from threading import Thread

После это­го с помо­щью функ­ции Thread() мы смо­жем создать столь­ко пото­ков, сколь­ко нам нуж­но. Логи­ка рабо­ты такая:

1. Под­клю­ча­ем нуж­ный модуль и класс Thread.
2. Пишем функ­ции, кото­рые нам нуж­но выпол­нять в потоках.
3. Созда­ём новую пере­мен­ную — поток, и пере­да­ём в неё назва­ние функ­ции и её аргу­мен­ты. Один поток = одна функ­ция на входе.
4. Дела­ем так столь­ко пото­ков, сколь­ко тре­бу­ет логи­ка программы.
5. Пото­ки сами сле­дят за тем, закон­чи­лась в них функ­ция или нет. Пока рабо­та­ет функ­ция — рабо­та­ет и поток.
6. Всё это рабо­та­ет парал­лель­но и (в тео­рии) не меша­ет друг другу.

Для иллю­стра­ции запу­стим такой код:

А вот как выгля­дит резуль­тат. Обра­ти­те вни­ма­ние — пото­ки про­сы­па­ют­ся не в той после­до­ва­тель­но­сти, как мы их запу­сти­ли, а в той, в какой их выпол­нил про­цес­сор. Ино­гда это может поме­шать рабо­те про­грам­мы, но про это мы пого­во­рим отдель­но в дру­гой статье.

Suspending Execution

One really useful Python time function is , which suspends the thread’s execution for a specified amount of time.

For example, you can suspend your program’s execution for 10 seconds like this:

>>>

Your program will print the first formatted string, then pause for 10 seconds, and finally print the second formatted string.

You can also pass fractional seconds to :

>>>

is useful for testing or making your program wait for any reason, but you must be careful not to halt your production code unless you have good reason to do so.

Before Python 3.5, a signal sent to your process could interrupt . However, in 3.5 and later, will always suspend execution for at least the amount of specified time, even if the process receives a signal.

is just one Python time function that can help you test your programs and make them more robust.

Вызов sleep() через time.sleep()

В Python есть встроенная поддержка для погружения программы в сон. У модуля есть функция , что позволяет отсрочить выполнение вызываемого потока на указанное количество секунд.

Мы собрали ТОП Книг для Python программиста которые помогут быстро изучить язык программирования Python.
Список книг: Книги по Python

Далее дан пример использования :

Python

import time
time.sleep(3) # Сон в 3 секунды

1 2	importtime time.sleep(3)# Сон в 3 секунды

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

Вы можете протестировать, как долго продлиться сон с помощью модуля Python timeit:

Shell

$ python3 -m timeit -n 3 «import time; time.sleep(3)»
3 loops, best of 3: 3 sec per loop

1 2	$python3-mtimeit-n3″import time; time.sleep(3)» 3loops,best of33sec per loop

Здесь модуль запускается с параметром , что указывает , сколько раз выполнять последующий оператор. Можно заметить, что выполнил оператор 3 раза, а лучшее время длилось 3 секунды, чего и следовало ожидать.

По умолчанию будет запускать код миллион раз. Если бы вы запустили вышеуказанный код, оставив значение по умолчанию, тогда при 3 секундах на итерацию код завис бы примерно на 34 дня! У модуля есть несколько других настроек для командной строки, с которыми можно ознакомиться в .

Создадим что-то более практичное. Системному администратору всегда нужно быть в курсе, если какой-то из сайтов упал. Вы бы хотели иметь возможность проверить код состояния сайта регулярно, но запрашивать веб сервер постоянно нельзя, ведь это сильно повлияет на производительность. В Python одним из простых способов совершить такую проверку является использование системного вызова :

Python

import time
import urllib.request
import urllib.error

def uptime_bot(url):
while True:
try:
conn = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
# Отправка admin / log
print(f’HTTPError: {e.code} для {url}’)
except urllib.error.URLError as e:
# Отправка admin / log
print(f’URLError: {e.code} для {url}’)
else:
# Сайт поднят
print(f'{url} поднят’)
time.sleep(60)

if __name__ == ‘__main__’:
url = ‘http://www.google.com/py’
uptime_bot(url)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 20 21 22

importtime importurllib.request importurllib.error defuptime_bot(url) whileTrue try conn=urllib.request.urlopen(url) excepturllib.error.HTTPError ase # Отправка admin / log print(f’HTTPError: {e.code} для {url}’) excepturllib.error.URLError ase # Отправка admin / log print(f’URLError: {e.code} для {url}’) else # Сайт поднят print(f'{url} поднят’) if__name__==’__main__’ url=’http://www.google.com/py’ uptime_bot(url)

Здесь создается , что принимает URL в качестве аргумента. Затем функция пытается открыть данный URL c . При возникновении или программа перехватывает ошибку и выводит на экран. На практике вам, скорее всего, придется зафиксировать ошибку и отправить письмо веб-мастеру или системному администратору.

Если ошибок нет, код спокойно выполняется. Вне зависимости от того, что произойдет, программа уходит в сон на 60 секунд. Это значит, что доступ к сайту будет раз за минуту. URL, используемый в примере, содержит ошибки. Ежеминутный вывод на консоли выглядит следующим образом:

Shell

HTTPError: 404 для http://www.google.com/py

1	HTTPError404дляhttpwww.compy

Попробуйте обновить код, используя проверенный хороший URL, к примеру https://www.google.com/. После этого вы можете перезапустить программу и проверить, что изменилось. Также можно попробовать обновить код для отправки сообщения или записи об ошибке. Для получения более подробной информации можете ознакомиться со статьями отправка писем smtp и логирование.

Basic Examples¶

The following example shows how the
can be used to compare three different expressions:

$ python3 -m timeit '"-".join(str(n) for n in range(100))'
10000 loops, best of 5: 30.2 usec per loop
$ python3 -m timeit '"-".join()'
10000 loops, best of 5: 27.5 usec per loop
$ python3 -m timeit '"-".join(map(str, range(100)))'
10000 loops, best of 5: 23.2 usec per loop

This can be achieved from the with:

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.3018611848820001
>>> timeit.timeit('"-".join()', number=10000)
0.2727368790656328
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.23702679807320237

A callable can also be passed from the :

>>> timeit.timeit(lambda "-".join(map(str, range(100))), number=10000)
0.19665591977536678

datetime.datetime

Объект datetime.datetime содержит всю информацию объектов datetime.date плюс datetime.time. Давайте приведем несколько примеров, для лучшего понимания разницы между этим объектом, и объектом datetime.date.

Python

import datetime

a = datetime.datetime(2017, 3, 5)
print(a) # datetime.datetime(2017, 3, 5, 0, 0)

b = datetime.datetime(2017, 3, 5, 12, 30, 10)
print(b) # datetime.datetime(2017, 3, 5, 12, 30, 10)

d = datetime.datetime(2017, 3, 5, 12, 30, 10)
print(d.year) # 2017
print(d.second) # 10
print(d.hour) # 12

1 2 3 4 5 6 7 8 9 10 11 12

importdatetime a=datetime.datetime(2017,3,5) print(a)# datetime.datetime(2017, 3, 5, 0, 0) b=datetime.datetime(2017,3,5,12,30,10) print(b)# datetime.datetime(2017, 3, 5, 12, 30, 10) d=datetime.datetime(2017,3,5,12,30,10) print(d.year)# 2017 print(d.second)# 10 print(d.hour)# 12

Мы видим, что datetime.datetime принимает несколько дополнительных аргументов: год, месяц, день, час, минута и секунда. Это также позволяет вам указывать информацию о микросекундах и часовом поясе. При работе с базами данных, данные типы объектов будут использоваться достаточно часто. Большую часть вашей работы, вам нужно будет конвертировать форматы date или datetime Python в форматы SQL datetime или timestamp

Обратите внимание на то, что today совместно с datetime.datetime использует два разных метода:

Python

import datetime

a = datetime.datetime.today()
print(a) # datetime.datetime(2017, 4, 5, 0, 16, 54, 989663)

b = datetime.datetime.now()
print(b) # datetime.datetime(2017, 4, 5, 0, 17, 8, 24239)

1 2 3 4 5 6 7

importdatetime a=datetime.datetime.today() print(a)# datetime.datetime(2017, 4, 5, 0, 16, 54, 989663) b=datetime.datetime.now() print(b)# datetime.datetime(2017, 4, 5, 0, 17, 8, 24239)

Модуль datetime содержит другой метод, под названием strftime. Этот метод позволяет разработчику создавать строку, отображающую время в более понятной для человека форме. Существует целая таблица параметров форматирования, с которой рекомендуется ознакомиться в документации Python, в . Давайте взглянем на несколько примеров, показывающих всю полезность данного метода:

Python

import datetime

a = datetime.datetime.today().strftime(«%Y%m%d»)
print(a) # ‘20170405’

today = datetime.datetime.today()
print( today.strftime(«%m/%d/%Y») ) # ’04/05/2017′

print( today.strftime(«%Y-%m-%d-%H.%M.%S») ) # 2017-04-05-00.18.00

1 2 3 4 5 6 7 8 9

importdatetime a=datetime.datetime.today().strftime(«%Y%m%d») print(a)# ‘20170405’ today=datetime.datetime.today() print(today.strftime(«%m/%d/%Y»))# ’04/05/2017′ print(today.strftime(«%Y-%m-%d-%H.%M.%S»))# 2017-04-05-00.18.00

Первый пример – это скорее хитрость. В нем показано, как конвертировать сегодняшний объект datetime в строку, следующую за форматом YYYYMMDD (ГГГГММДД). Второй пример более наглядный.

В нем мы присваиваем объект datetime переменной под названием today и применяем два разных параметра форматирования строки. Первый параметр добавляет косые черточки между элементами datetime, а также перегруппировывает datetime, теперь он делится на месяц, день и год. В последнем примере мы создаем временную отметку, которая следует типичному формату: YYYY-MM-DD.HH.MM.SS. Если вам нужно указать год как двухзначный (“YY”), вы можете заменить %Y на %y.

Разница между двумя датами и временем

from datetime import datetime, date

t1 = date(year = 2018, month = 7, day = 12)
t2 = date(year = 2017, month = 12, day = 23)
t3 = t1 - t2
print("t3 =", t3)

t4 = datetime(year = 2018, month = 7, day = 12, hour = 7, minute = 9, second = 33)
t5 = datetime(year = 2019, month = 6, day = 10, hour = 5, minute = 55, second = 13)
t6 = t4 - t5
print("t6 =", t6)

print("type of t3 =", type(t3)) 
print("type of t6 =", type(t6))  

Когда вы запустите программу, вывод будет:

t3 = 201 days, 0:00:00
t6 = -333 days, 1:14:20
type of t3 = <class 'datetime.timedelta'>
type of t6 = <class 'datetime.timedelta'>

Обратите внимание, что и t3, и t6 относятся к типу