datetime datetime转时间戳 - 如何将日期时间转换为日期(使用Python)?





10位时间戳 python毫秒时间戳转时间 (6)


使用date()方法:

datetime.datetime.now().date()

如何将datetime.datetime对象(例如, datetime.datetime.now())的返回值datetime.datetime.now())转换为Python中的datetime.date对象?




您使用datetime.datetime.date()方法:

datetime.datetime.now().date()

显然,上面的表达式可以(也应该是恕我直言)写成:

datetime.date.today()



import time
import datetime

# use mktime to step by one day
# end - the last day, numdays - count of days to step back
def gen_dates_list(end, numdays):
  start = end - datetime.timedelta(days=numdays+1)
  end   = int(time.mktime(end.timetuple()))
  start = int(time.mktime(start.timetuple()))
  # 86400 s = 1 day
  return xrange(start, end, 86400)

# if you need reverse the list of dates
for dt in reversed(gen_dates_list(datetime.datetime.today(), 100)):
    print datetime.datetime.fromtimestamp(dt).date()



您可以使用日期时间对象的date()方法将日期时间对象转换为日期,如下所示:

<datetime_object>.date()



不要忘记导入日期时间

import datetime
dt=str(datetime.datetime.now().date())



元类是类的类。 就像类定义了类的实例的行为一样,元类定义了类的行为方式。 类是元类的实例。

虽然在Python中你可以为元类使用任意的callables(比如Jerub节目),实际上更有用的方法是使它成为一个真正的类本身。 type是Python中常用的元类。 如果您想知道,是的, type本身就是一个类,它是它自己的类型。 你将无法在Python中重新创建纯type东西,但是Python会有所作为。 要在Python中创建自己的元类,你真的只想子type

元类最常用作类工厂。 就像你通过调用类来创建类的实例一样,Python通过调用元类来创建一个新类(当它执行'class'语句时)。 结合正常的__init____new__方法,元类因此允许您在创建类时执行“额外的事情”,例如使用某个注册表注册新类,或者甚至完全用其他类替换该类。

执行class语句时,Python首先执行class语句的主体作为正常的代码块。 生成的命名空间(dict)保存了将要进行的类的属性。 元类是通过在__metaclass__类(如果有)的__metaclass__属性或__metaclass__全局变量中查看要被定义的类的基类(继承元类)来确定的。 然后使用类的名称,基数和属性调用元类来实例化它。

但是,元类实际上定义了类的类型 ,而不仅仅是它的工厂,所以你可以用它们做更多的事情。 例如,您可以在元类上定义常规方法。 这些元类方法类似于类方法,因为它们可以在没有实例的类上调用,但它们也不像类方法,因为它们不能在类的实例上调用。 type.__subclasses__()type元类的方法示例。 您还可以定义常规的“魔术”方法,如__add__ __iter____getattr__ __add____getattr__ ,以实现或更改类的行为方式。

这是比特和碎片的汇总示例:

def make_hook(f):
    """Decorator to turn 'foo' method into '__foo__'"""
    f.is_hook = 1
    return f

class MyType(type):
    def __new__(mcls, name, bases, attrs):

        if name.startswith('None'):
            return None

        # Go over attributes and see if they should be renamed.
        newattrs = {}
        for attrname, attrvalue in attrs.iteritems():
            if getattr(attrvalue, 'is_hook', 0):
                newattrs['__%s__' % attrname] = attrvalue
            else:
                newattrs[attrname] = attrvalue

        return super(MyType, mcls).__new__(mcls, name, bases, newattrs)

    def __init__(self, name, bases, attrs):
        super(MyType, self).__init__(name, bases, attrs)

        # classregistry.register(self, self.interfaces)
        print "Would register class %s now." % self

    def __add__(self, other):
        class AutoClass(self, other):
            pass
        return AutoClass
        # Alternatively, to autogenerate the classname as well as the class:
        # return type(self.__name__ + other.__name__, (self, other), {})

    def unregister(self):
        # classregistry.unregister(self)
        print "Would unregister class %s now." % self

class MyObject:
    __metaclass__ = MyType


class NoneSample(MyObject):
    pass

# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
    def __init__(self, value):
        self.value = value
    @make_hook
    def add(self, other):
        return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
    pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__




python datetime