Como definir o valor padrão de um campo de modelo do Django para uma chamada de função / chamável (por exemplo, uma data relativa ao tempo de criação do objeto de modelo)

EDITADO:

Como posso definir o padrão de um campo Django para uma função que é avaliada cada vez que um novo objeto de modelo é criado?

Eu quero fazer algo como o seguinte, exceto que neste código, o código é avaliado uma vez e define o padrão para a mesma data para cada objeto de modelo criado, em vez de avaliar o código cada vez que um objeto de modelo é criado:

from datetime import datetime, timedelta
class MyModel(models.Model):
  # default to 1 day from now
  my_date = models.DateTimeField(default=datetime.now() + timedelta(days=1))

ORIGINAL:

Quero criar um valor padrão para um parâmetro de função de forma que seja dinâmico e seja chamado e definido toda vez que a função for chamada. Como eu posso fazer isso? por exemplo,

from datetime import datetime
def mydate(date=datetime.now()):
  print date

mydate() 
mydate() # prints the same thing as the previous call; but I want it to be a newer value

Especificamente, quero fazer isso em Django, por exemplo,

from datetime import datetime, timedelta
class MyModel(models.Model):
  # default to 1 day from now
  my_date = models.DateTimeField(default=datetime.now() + timedelta(days=1))

A pergunta está equivocada. Ao criar um campo de modelo no Django, você não está definindo uma função, então os valores padrão da função são irrelevantes:

from datetime import datetime, timedelta
class MyModel(models.Model):
  # default to 1 day from now
  my_date = models.DateTimeField(default=datetime.now() + timedelta(days=1))

Esta última linha não está definindo uma função; é invocar uma função para criar um campo na classe.

PRE Django 1.7

Django permite que você passe um callable como o padrão , e ele irá invocá-lo todas as vezes, assim como você deseja:

from datetime import datetime, timedelta
class MyModel(models.Model):
  # default to 1 day from now
  my_date = models.DateTimeField(default=lambda: datetime.now() + timedelta(days=1))

Django 1.7+

Observe que desde o Django 1.7, o uso de lambda como valor padrão não é recomendado (cf comentário @stvnw). A maneira correta de fazer isso é declarar uma função antes do campo e usá-la como um callable em default_value chamado arg:

from datetime import datetime, timedelta

# default to 1 day from now
def get_default_my_date():
  return datetime.now() + timedelta(days=1)

class MyModel(models.Model):
  my_date = models.DateTimeField(default=get_default_my_date)

Mais informações na resposta @simanas abaixo

Fazer isso default=datetime.now()+timedelta(days=1)é absolutamente errado!

Ele é avaliado quando você inicia sua instância do django. Se você estiver usando o apache, provavelmente funcionará, porque em algumas configurações o apache revoga seu aplicativo django em todas as solicitações, mas ainda assim você pode se encontrar algum dia olhando seu código e tentando descobrir por que isso não foi calculado como você esperava .

A maneira certa de fazer isso é passar um objeto que pode ser chamado para o argumento padrão. Pode ser uma função datetime.today ou sua função personalizada. Então, ele é avaliado toda vez que você solicita um novo valor padrão.

def get_deadline():
    return datetime.today() + timedelta(days=20)

class Bill(models.Model):
    name = models.CharField(max_length=50)
    customer = models.ForeignKey(User, related_name='bills')
    date = models.DateField(default=datetime.today)
    deadline = models.DateField(default=get_deadline)

Há uma distinção importante entre os dois construtores DateTimeField a seguir:

my_date = models.DateTimeField(auto_now=True)
my_date = models.DateTimeField(auto_now_add=True)

Se você usar auto_now_add=Trueno construtor, a data e hora referenciada por my_date é "imutável" (definida apenas uma vez quando a linha é inserida na tabela).

Com auto_now=True, entretanto, o valor datetime será atualizado sempre que o objeto for salvo.

Isso foi definitivamente um problema para mim em um ponto. Para referência, os documentos estão aqui:

https://docs.djangoproject.com/en/dev/ref/models/fields/#datetimefield

Às vezes, você pode precisar acessar os dados do modelo após criar um novo modelo de usuário.

Aqui está como eu gero um token para cada novo perfil de usuário usando os primeiros 4 caracteres de seu nome de usuário:

from django.dispatch import receiver
class Profile(models.Model):
    auth_token = models.CharField(max_length=13, default=None, null=True, blank=True)


@receiver(post_save, sender=User) # this is called after a User model is saved.
def create_user_profile(sender, instance, created, **kwargs):
    if created: # only run the following if the profile is new
        new_profile = Profile.objects.create(user=instance)
        new_profile.create_auth_token()
        new_profile.save()

def create_auth_token(self):
    import random, string
    auth = self.user.username[:4] # get first 4 characters in user name
    self.auth_token =  auth + ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits + string.ascii_lowercase) for _ in range(random.randint(3, 5)))

Você não pode fazer isso diretamente; o valor padrão é avaliado quando a definição da função é avaliada. Mas existem duas maneiras de contornar isso.

Primeiro, você pode criar (e depois chamar) uma nova função a cada vez.

Ou, mais simplesmente, use um valor especial para marcar o padrão. Por exemplo:

from datetime import datetime
def mydate(date=None):
  if date is None:
    date = datetime.now()
  print date

Se Nonefor um valor de parâmetro perfeitamente razoável e não houver outro valor razoável que você possa usar em seu lugar, você pode apenas criar um novo valor que está definitivamente fora do domínio de sua função:

from datetime import datetime
class _MyDateDummyDefault(object):
  pass
def mydate(date=_MyDateDummyDefault):
  if date is _MyDateDummyDefault:
    date = datetime.now()
  print date
del _MyDateDummyDefault

Em alguns casos raros, você está escrevendo um meta-código que realmente precisa ser capaz de pegar absolutamente qualquer coisa, mesmo, digamos mydate.func_defaults[0],. Nesse caso, você deve fazer algo assim:

def mydate(*args, **kw):
  if 'date' in kw:
    date = kw['date']
  elif len(args):
    date = args[0]
  else:
    date = datetime.now()
  print date

Passe a função como um parâmetro em vez de passar o resultado da chamada da função.

Ou seja, em vez disso:

def myfunc(date=datetime.now()):
    print date

Experimente isto:

def myfunc(date=datetime.now):
    print date()