Note: this answer is deprecated. see other answers if you are using Django 1.7 or later.

This is how I do it.

#in models.py from django.contrib.auth.models import User from django.db.models.signals import post_save class UserProfile(models.Model): user = models.OneToOneField(User) #other fields here def __str__(self): return "%s's profile" % self.user def create_user_profile(sender, instance, created, **kwargs): if created: profile, created = UserProfile.objects.get_or_create(user=instance) post_save.connect(create_user_profile, sender=User) #in settings.py AUTH_PROFILE_MODULE = 'YOURAPP.UserProfile' 

This will create a userprofile each time a user is saved if it is created. You can then use

 user.get_profile().whatever 

Here is some more info from the docs

http://docs.djangoproject.com/en/dev/topics/auth/#storing-additional-information-about-users

Update: Please note that AUTH_PROFILE_MODULE is deprecated since v1.5: https://docs.djangoproject.com/en/1.5/ref/settings/#auth-profile-module

Well, some time passed since 2008 and it's time for some fresh answer. Since Django 1.5 you will be able to create custom User class. Actually, at the time I'm writing this, it's already merged into master, so you can try it out.

There's some information about it in docs or if you want to dig deeper into it, in this commit.

All you have to do is add AUTH_USER_MODEL to settings with path to custom user class, which extends either AbstractBaseUser (more customizable version) or AbstractUser (more or less old User class you can extend).

For people that are lazy to click, here's code example (taken from docs):

from django.db import models from django.contrib.auth.models import ( BaseUserManager, AbstractBaseUser ) class MyUserManager(BaseUserManager): def create_user(self, email, date_of_birth, password=None): """ Creates and saves a User with the given email, date of birth and password. """ if not email: raise ValueError('Users must have an email address') user = self.model( email=MyUserManager.normalize_email(email), date_of_birth=date_of_birth, ) user.set_password(password) user.save(using=self._db) return user def create_superuser(self, username, date_of_birth, password): """ Creates and saves a superuser with the given email, date of birth and password. """ u = self.create_user(username, password=password, date_of_birth=date_of_birth ) u.is_admin = True u.save(using=self._db) return u class MyUser(AbstractBaseUser): email = models.EmailField( verbose_name='email address', max_length=255, unique=True, ) date_of_birth = models.DateField() is_active = models.BooleanField(default=True) is_admin = models.BooleanField(default=False) objects = MyUserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = ['date_of_birth'] def get_full_name(self): # The user is identified by their email address return self.email def get_short_name(self): # The user is identified by their email address return self.email def __unicode__(self): return self.email def has_perm(self, perm, obj=None): "Does the user have a specific permission?" # Simplest possible answer: Yes, always return True def has_module_perms(self, app_label): "Does the user have permissions to view the app `app_label`?" # Simplest possible answer: Yes, always return True @property def is_staff(self): "Is the user a member of staff?" # Simplest possible answer: All admins are staff return self.is_admin 

Since Django 1.5 you may easily extend the user model and keep a single table on the database.

from django.contrib.auth.models import AbstractUser from django.db import models from django.utils.translation import ugettext_lazy as _ class UserProfile(AbstractUser): age = models.PositiveIntegerField(_("age")) 

You must also configure it as current user class in your settings file

# supposing you put it in apps/profiles/models.py AUTH_USER_MODEL = "profiles.UserProfile" 

If you want to add a lot of users' preferences the OneToOneField option may be a better choice thought.

A note for people developing third party libraries: if you need to access the user class remember that people can change it. Use the official helper to get the right class

from django.contrib.auth import get_user_model User = get_user_model() 

There is an official recommendation on storing additional information about users. The Django Book also discusses this problem in section Profiles.

The below one is another approach to extend an User. I feel it is more clear,easy,readable then above two approaches.

http://scottbarnham.com/blog/2008/08/21/extending-the-django-user-model-with-inheritance/

Using above approach:

1. you don't need to use user.get_profile().newattribute to access the additional information related to the user
2. you can just directly access additional new attributes via user.newattribute

You can Simply extend user profile by creating a new entry each time when a user is created by using Django post save signals

models.py

from django.db.models.signals import * from __future__ import unicode_literals class UserProfile(models.Model): user_name = models.OneToOneField(User, related_name='profile') city = models.CharField(max_length=100, null=True) def __unicode__(self): # __str__ return unicode(self.user_name) def create_user_profile(sender, instance, created, **kwargs): if created: userProfile.objects.create(user_name=instance) post_save.connect(create_user_profile, sender=User) 

This will automatically create an employee instance when a new user is created.

If you wish to extend user model and want to add further information while creating a user you can use django-betterforms (http://django-betterforms.readthedocs.io/en/latest/multiform.html). This will create a user add form with all fields defined in the UserProfile model.

models.py

from django.db.models.signals import * from __future__ import unicode_literals class UserProfile(models.Model): user_name = models.OneToOneField(User) city = models.CharField(max_length=100) def __unicode__(self): # __str__ return unicode(self.user_name) 

forms.py

from django import forms from django.forms import ModelForm from betterforms.multiform import MultiModelForm from django.contrib.auth.forms import UserCreationForm from .models import * class ProfileForm(ModelForm): class Meta: model = Employee exclude = ('user_name',) class addUserMultiForm(MultiModelForm): form_classes = { 'user':UserCreationForm, 'profile':ProfileForm, } 

views.py

from django.shortcuts import redirect from .models import * from .forms import * from django.views.generic import CreateView class AddUser(CreateView): form_class = AddUserMultiForm template_name = "add-user.html" success_url = '/your-url-after-user-created' def form_valid(self, form): user = form['user'].save() profile = form['profile'].save(commit=False) profile.user_name = User.objects.get(username= user.username) profile.save() return redirect(self.success_url) 

addUser.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <form action="." method="post"> {% csrf_token %} {{ form }} <button type="submit">Add</button> </form> </body> </html> 

urls.py

from django.conf.urls import url, include from appName.views import * urlpatterns = [ url(r'^add-user/$', AddUser.as_view(), name='add-user'), ] 

Extending Django User Model (UserProfile) like a Pro

I've found this very useful: link

An extract:

from django.contrib.auth.models import User class Employee(models.Model): user = models.OneToOneField(User) department = models.CharField(max_length=100) >>> u = User.objects.get(username='fsmith') >>> freds_department = u.employee.department 

It's very easy in Django version 3.0+ (If you are NOT in the middle of a project):

In models.py

from django.db import models from django.contrib.auth.models import AbstractUser class CustomUser(AbstractUser): extra_field=models.CharField(max_length=40) 

In settings.py

First, register your new app and then below AUTH_PASSWORD_VALIDATORS add

AUTH_USER_MODEL ='users.CustomUser' 

Finally, register your model in the admin, run makemigrations and migrate, and it will be completed successfully.

Official doc: https://docs.djangoproject.com/en/3.2/topics/auth/customizing/#substituting-a-custom-user-model

It's too late, but my answer is for those who search for a solution with a recent version of Django.

models.py:

from django.db import models from django.contrib.auth.models import User from django.db.models.signals import post_save from django.dispatch import receiver class Profile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) extra_Field_1 = models.CharField(max_length=25, blank=True) extra_Field_2 = models.CharField(max_length=25, blank=True) @receiver(post_save, sender=User) def create_user_profile(sender, instance, created, **kwargs): if created: Profile.objects.create(user=instance) @receiver(post_save, sender=User) def save_user_profile(sender, instance, **kwargs): instance.profile.save() 

you can use it in templates like this:

<h2>{{ user.get_full_name }}</h2> <ul> <li>Username: {{ user.username }}</li> <li>Location: {{ user.profile.extra_Field_1 }}</li> <li>Birth Date: {{ user.profile.extra_Field_2 }}</li> </ul> 

and in views.py like this:

def update_profile(request, user_id): user = User.objects.get(pk=user_id) user.profile.extra_Field_1 = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit...' user.save() 

Here I tried to explain how to extend Django's Default user model with extra fields It's very simple just do it.

Django allows extending the default user model with AbstractUser

Note:- first create an extra field model which you want to add in user model then run the command python manage.py makemigrations and python manage.py migrate

first run ---> python manage.py makemigrations then

second run python manage.py migrate

Step:- create a model with extra fields which you want to add in Django default user model (in my case I created CustomUser

model.py

from django.db import models from django.contrib.auth.models import AbstractUser # Create your models here. class CustomUser(AbstractUser): mobile_no = models.IntegerField(blank=True,null=True) date_of_birth = models.DateField(blank=True,null=True) 

add in settings.py name of your model which you created in my case CustomUser is the user model. registred in setttings.py to make it the default user model,

#settings.py AUTH_USER_MODEL = 'myapp.CustomUser' 

finally registred CustomUser model in admin.py #admin.py

@admin.register(CustomUser) class CustomUserAdmin(admin.ModelAdmin): list_display = ("username","first_name","last_name","email","date_of_birth", "mobile_no") 

then run command python manage.py makemigrations

then python manage.py migrate

then python manage.py createsuperuser

now you can see your model Default User model extended with (mobile_no ,date_of_birth)

New in Django 1.5, now you can create your own Custom User Model (which seems to be good thing to do in above case). Refer to 'Customizing authentication in Django'

Probably the coolest new feature on 1.5 release.

This is what i do and it's in my opinion simplest way to do this. define an object manager for your new customized model then define your model.

from django.db import models from django.contrib.auth.models import PermissionsMixin, AbstractBaseUser, BaseUserManager class User_manager(BaseUserManager): def create_user(self, username, email, gender, nickname, password): email = self.normalize_email(email) user = self.model(username=username, email=email, gender=gender, nickname=nickname) user.set_password(password) user.save(using=self.db) return user def create_superuser(self, username, email, gender, password, nickname=None): user = self.create_user(username=username, email=email, gender=gender, nickname=nickname, password=password) user.is_superuser = True user.is_staff = True user.save() return user class User(PermissionsMixin, AbstractBaseUser): username = models.CharField(max_length=32, unique=True, ) email = models.EmailField(max_length=32) gender_choices = [("M", "Male"), ("F", "Female"), ("O", "Others")] gender = models.CharField(choices=gender_choices, default="M", max_length=1) nickname = models.CharField(max_length=32, blank=True, null=True) is_active = models.BooleanField(default=True) is_staff = models.BooleanField(default=False) REQUIRED_FIELDS = ["email", "gender"] USERNAME_FIELD = "username" objects = User_manager() def __str__(self): return self.username 

Dont forget to add this line of code in your settings.py:

AUTH_USER_MODEL = 'YourApp.User' 

This is what i do and it always works.

I recommend Substituting a custom User model which is more customizable than Extending the existing User model.

Substituting a custom User model:

• can add extra fields.
• can remove default fields.
• can change default username and password authentication to email and password authentication.
• must be the 1st migration to database otherwise there is error.

*You can see my answer explaining how to set up email and password authentication with AbstractUser or AbstractBaseUser and PermissionsMixin and you can see my answer and my answer explaining the difference between AbstractUser and AbstractBaseUser.

Extending the existing User model:

• can add extra fields.
• cannot remove default fields.
• cannot change username and password authentication to email and password authentication.
• doesn't need to be the 1st migration to database.

*You can see my answer explaining how to extend User model to add extra fields with OneToOneField().

Simple and effective approach is models.py

from django.contrib.auth.models import User class CustomUser(User): profile_pic = models.ImageField(upload_to='...') other_field = models.CharField() 

Try this:

Create a model called Profile and reference the user with a OneToOneField and provide an option of related_name.

models.py

from django.db import models from django.contrib.auth.models import * from django.dispatch import receiver from django.db.models.signals import post_save class Profile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='user_profile') def __str__(self): return self.user.username @receiver(post_save, sender=User) def create_profile(sender, instance, created, **kwargs): try: if created: Profile.objects.create(user=instance).save() except Exception as err: print('Error creating user profile!') 

Now to directly access the profile using a User object you can use the related_name.

views.py

from django.http import HttpResponse def home(request): profile = f'profile of {request.user.user_profile}' return HttpResponse(profile) 

Currently as of Django 2.2, the recommended way when starting a new project is to create a custom user model that inherits from AbstractUser, then point AUTH_USER_MODEL to the model.

Source: https://docs.djangoproject.com/en/2.2/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project