--- title: "Skicka e-post" version: 5.2 locale: sv source: https://docs.djangoproject.com/sv/5.2/topics/email/ canonical: https://djangodocs.dev/sv/5.2/topics/email/ --- # Skicka e-post Även om Python tillhandahåller ett gränssnitt för e-post via modulen [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib), tillhandahåller Django ett par lätta omslag över det. Dessa omslag tillhandahålls för att göra det extra snabbt att skicka e-post, för att hjälpa till att testa e-postsändning under utveckling och för att ge stöd för plattformar som inte kan använda SMTP. Koden finns i modulen `django.core.mail`. ## Snabba exempel Använd [`send_mail()`](#django.core.mail.send_mail) för att skicka e-post på ett enkelt sätt. Till exempel, för att skicka ett vanligt textmeddelande: ``` from django.core.mail import send_mail send_mail( "Subject here", "Here is the message.", "from@example.com", ["to@example.com"], fail_silently=False, ) ``` Om du behöver ytterligare funktioner för att skicka e-post använder du [`EmailMessage`](#django.core.mail.EmailMessage) eller [`EmailMultiAlternatives`](#django.core.mail.EmailMultiAlternatives). Om du t.ex. vill skicka ett flerdelat e-postmeddelande som innehåller både HTML- och klartextversioner med en specifik mall och anpassade rubriker kan du använda följande metod: ``` from django.core.mail import EmailMultiAlternatives from django.template.loader import render_to_string # First, render the plain text content. text_content = render_to_string( "templates/emails/my_email.txt", context={"my_variable": 42}, ) # Secondly, render the HTML content. html_content = render_to_string( "templates/emails/my_email.html", context={"my_variable": 42}, ) # Then, create a multipart email instance. msg = EmailMultiAlternatives( "Subject here", text_content, "from@example.com", ["to@example.com"], headers={"List-Unsubscribe": ""}, ) # Lastly, attach the HTML content to the email instance and send. msg.attach_alternative(html_content, "text/html") msg.send() ``` E-post skickas via den SMTP-värd och port som anges i inställningarna [`EMAIL_HOST`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST) och [`EMAIL_PORT`](/sv/5.2/ref/settings/#std-setting-EMAIL_PORT). Inställningarna [`EMAIL_HOST_USER`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_USER) och [`EMAIL_HOST_PASSWORD`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_PASSWORD), om de är angivna, används för att autentisera SMTP-servern och inställningarna [`EMAIL_USE_TLS`](/sv/5.2/ref/settings/#std-setting-EMAIL_USE_TLS) och [`EMAIL_USE_SSL`](/sv/5.2/ref/settings/#std-setting-EMAIL_USE_SSL) kontrollerar om en säker anslutning används. > **Note** > > Teckenuppsättningen för e-post som skickas med `django.core.mail` kommer att ställas in till värdet för din [`DEFAULT_CHARSET`](/sv/5.2/ref/settings/#std-setting-DEFAULT_CHARSET)-inställning. ## `send_mail()` #### `send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)` I de flesta fall kan du skicka e-post med hjälp av `django.core.mail.send_mail()`. Parametrarna `subject`, `message`, `from_email` och `recipient_list` är obligatoriska. - `subject`: En sträng. - `meddelande`: En sträng. - `from_email`: En sträng. Om `None`, kommer Django att använda värdet av inställningen [`DEFAULT_FROM_EMAIL`](/sv/5.2/ref/settings/#std-setting-DEFAULT_FROM_EMAIL). - `mottagare_lista`: En lista med strängar, var och en en e-postadress. Varje medlem i `recipient_list` kommer att se de andra mottagarna i fältet ”To:” i e-postmeddelandet. - `fail_silently`: En boolean. När den är `False` kommer `send_mail()` att ge upphov till ett [`smtplib.SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException) om ett fel uppstår. Se [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib)-dokumenten för en lista över möjliga undantag, som alla är underklasser till [`SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException). - `auth_user`: Det valfria användarnamnet som ska användas för att autentisera sig mot SMTP-servern. Om detta inte anges kommer Django att använda värdet för inställningen [`EMAIL_HOST_USER`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_USER). - `auth_password`: Det valfria lösenordet som ska användas för att autentisera sig mot SMTP-servern. Om detta inte anges kommer Django att använda värdet för inställningen [`EMAIL_HOST_PASSWORD`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_PASSWORD). - `anslutning`: Den valfria e-postbackend som ska användas för att skicka e-post. Om inget anges kommer en instans av standardbackend att användas. Se dokumentationen på [Email backends](#topic-email-backends) för mer information. - `html_message`: Om `html_message` anges kommer det resulterande e-postmeddelandet att vara ett e-postmeddelande av typen `multipart/alternative` med `message` som innehållstyp av typen `text/plain` och `html_message` som innehållstyp av typen `text/html`. Returvärdet är antalet framgångsrikt levererade meddelanden (som kan vara `0` eller `1` eftersom det bara kan skicka ett meddelande). ## `sänd_mass_mail()` #### `send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)` `django.core.mail.send_mass_mail()` är avsedd att hantera massutskick av e-post. `datatuple` är en tupel där varje element är i detta format: ``` (subject, message, from_email, recipient_list) ``` `fail_silently`, `auth_user` och `auth_password` har samma funktioner som i [`send_mail()`](#django.core.mail.send_mail). Varje enskilt element i `datatuple` resulterar i ett separat e-postmeddelande. Precis som i [`send_mail()`](#django.core.mail.send_mail) kommer mottagarna i samma `recipient_list` att se alla andra adresser i e-postmeddelandets ”Till:”-fält. Exempelvis skulle följande kod skicka två olika meddelanden till två olika uppsättningar mottagare, men endast en anslutning till e-postservern skulle öppnas: ``` message1 = ( "Subject here", "Here is the message", "from@example.com", ["first@example.com", "other@example.com"], ) message2 = ( "Another Subject", "Here is another message", "from@example.com", ["second@test.com"], ) send_mass_mail((message1, message2), fail_silently=False) ``` Returvärdet är antalet framgångsrikt levererade meddelanden. ### `send_mass_mail()` vs. `send_mail()` Den största skillnaden mellan [`send_mass_mail()`](#django.core.mail.send_mass_mail) och [`send_mail()`](#django.core.mail.send_mail) är att [`send_mail()`](#django.core.mail.send_mail) öppnar en anslutning till e-postservern varje gång den körs, medan :func: ~django.core.mail.send\_mass\_mail använder en enda anslutning för alla sina meddelanden. Detta gör [`send_mass_mail()`](#django.core.mail.send_mass_mail) något mer effektiv. ## `mail_admins()` #### `mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_admins()` är en genväg för att skicka ett e-postmeddelande till webbplatsadministratörerna, enligt definitionen i inställningen [`ADMINS`](/sv/5.2/ref/settings/#std-setting-ADMINS). `mail_admins()` prefixar ämnet med värdet på inställningen [`EMAIL_SUBJECT_PREFIX`](/sv/5.2/ref/settings/#std-setting-EMAIL_SUBJECT_PREFIX), som är `"[Django]"` som standard. ”From:”-rubriken i e-postmeddelandet kommer att vara värdet för inställningen [`SERVER_EMAIL`](/sv/5.2/ref/settings/#std-setting-SERVER_EMAIL). Denna metod finns för enkelhetens och läsbarhetens skull. Om `html_message` anges kommer det resulterande e-postmeddelandet att vara ett `multipart/alternative` e-postmeddelande med `message` som innehållstyp `text/plain` och `html_message` som innehållstyp `text/html`. ## `mail_managers()` #### `mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_managers()` är precis som `mail_admins()`, förutom att den skickar ett e-postmeddelande till webbplatsansvariga, enligt definitionen i inställningen [`MANAGERS`](/sv/5.2/ref/settings/#std-setting-MANAGERS). ## Exempel Detta skickar ett enda e-postmeddelande till [john@example.com](mailto:john@example.com) och [jane@example.com](mailto:jane@example.com), där de båda visas i ”Till:”: ``` send_mail( "Subject", "Message.", "from@example.com", ["john@example.com", "jane@example.com"], ) ``` Detta skickar ett meddelande till [john@example.com](mailto:john@example.com) och [jane@example.com](mailto:jane@example.com), och de får båda ett separat e-postmeddelande: ``` datatuple = ( ("Subject", "Message.", "from@example.com", ["john@example.com"]), ("Subject", "Message.", "from@example.com", ["jane@example.com"]), ) send_mass_mail(datatuple) ``` ## Förhindra injektion av rubrik [Header injection](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection.html) är en säkerhetsbrist som innebär att en angripare infogar extra e-postrubriker för att styra ”To:” och ”From:” i e-postmeddelanden som dina skript genererar. De Django-e-postfunktioner som beskrivs ovan skyddar alla mot header-injektion genom att förbjuda radbrytningar i header-värden. Om någon av `subject`, `from_email` eller `recipient_list` innehåller en radbrytning (i antingen Unix-, Windows- eller Mac-format) kommer e-postfunktionen (t.ex. [`send_mail()`](#django.core.mail.send_mail)) att generera ett `django.core.mail. BadHeaderError` (en underklass till `ValueError`) och kommer därför inte att skicka e-postmeddelandet. Det är ditt ansvar att validera all data innan du skickar den till e-postfunktionerna. Om ett `message` innehåller rubriker i början av strängen skrivs rubrikerna ut som första bit i e-postmeddelandet. Här är ett exempel på en vy som tar ett ”subject”, ”message” och ”from\_email” från POST-data, skickar det till [admin@example.com](mailto:admin@example.com) och omdirigerar till ”/contact/thanks/” när det är klart: ``` from django.core.mail import BadHeaderError, send_mail from django.http import HttpResponse, HttpResponseRedirect def send_email(request): subject = request.POST.get("subject", "") message = request.POST.get("message", "") from_email = request.POST.get("from_email", "") if subject and message and from_email: try: send_mail(subject, message, from_email, ["admin@example.com"]) except BadHeaderError: return HttpResponse("Invalid header found.") return HttpResponseRedirect("/contact/thanks/") else: # In reality we'd use a form class # to get proper validation errors. return HttpResponse("Make sure all fields are entered and valid.") ``` ## Klassen ”E-postmeddelande Djangos funktioner [`send_mail()`](#django.core.mail.send_mail) och [`send_mass_mail()`](#django.core.mail.send_mass_mail) är egentligen tunna omslag som använder klassen [`EmailMessage`](#django.core.mail.EmailMessage). Alla funktioner i klassen [`EmailMessage`](#django.core.mail.EmailMessage) är inte tillgängliga via [`send_mail()`](#django.core.mail.send_mail) och relaterade wrapper-funktioner. Om du vill använda avancerade funktioner, såsom BCC-mottagare, bifogade filer eller flerdelade e-postmeddelanden, måste du skapa [`EmailMessage`](#django.core.mail.EmailMessage)-instanser direkt. > **Note** > > Detta är en designfunktion. [`send_mail()`](#django.core.mail.send_mail) och relaterade funktioner var ursprungligen det enda gränssnittet som Django tillhandahöll. Men listan över parametrar som de accepterade växte sakta med tiden. Det var logiskt att övergå till en mer objektorienterad design för e-postmeddelanden och behålla de ursprungliga funktionerna endast för bakåtkompatibilitet. [`EmailMessage`](#django.core.mail.EmailMessage) är ansvarig för att skapa själva e-postmeddelandet. [email backend](#topic-email-backends) är sedan ansvarig för att skicka e-postmeddelandet. För enkelhetens skull tillhandahåller [`EmailMessage`](#django.core.mail.EmailMessage) en `send()`-metod för att skicka ett enda e-postmeddelande. Om du behöver skicka flera meddelanden tillhandahåller API:et för e-postbackend :ref:\` ett alternativ \\`. ### objekten `EmailMessage` #### `class EmailMessage` Klassen [`EmailMessage`](#django.core.mail.EmailMessage) initialiseras med följande parametrar (i angiven ordning, om positionella argument används). Alla parametrar är valfria och kan ställas in när som helst innan du anropar metoden `send()`. - `subject`: Ämnesraden för e-postmeddelandet. - `kropp`: Texten i brödtexten. Detta bör vara ett vanligt textmeddelande. - `from_email`: Avsändarens adress. Både `fred@example.com` och `"Fred" ` är lagliga former. Om den utelämnas används inställningen [`DEFAULT_FROM_EMAIL`](/sv/5.2/ref/settings/#std-setting-DEFAULT_FROM_EMAIL). - `till`: En lista eller tupel av mottagaradresser. - `bcc`: En lista eller tupel av adresser som används i ”Bcc”-rubriken när e-postmeddelandet skickas. - `anslutning`: En [email backend](#topic-email-backends)-instans. Använd denna parameter om du skickar `EmailMessage` via `send()` och du vill använda samma anslutning för flera meddelanden. Om den utelämnas skapas en ny anslutning när `send()` anropas. Denna parameter ignoreras när du använder [send\_messages()](#topics-sending-multiple-emails). - `attachments`: En lista med bilagor som ska läggas till meddelandet. Dessa kan vara instanser av [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) eller [`EmailAttachment`](#django.core.mail.EmailAttachment), eller en tupel med attributen `(filnamn, innehåll, mimetype)`. > **Changed in Django 5.2** > > Stöd för [`EmailAttachment`](#django.core.mail.EmailAttachment)-objekt i `attachments` har lagts till. - `headers`: En ordbok med extra rubriker som ska läggas till meddelandet. Nycklarna är rubriknamnet, värdena är rubrikvärdena. Det är upp till den som anropar att se till att rubriknamn och värden är i rätt format för ett e-postmeddelande. Motsvarande attribut är `extra_headers`. - `cc`: En lista eller tupel av mottagaradresser som används i ”Cc”-rubriken när e-postmeddelandet skickas. - `reply_to`: En lista eller tupel av mottagaradresser som används i ”Reply-To”-rubriken när e-postmeddelandet skickas. Till exempel: ``` from django.core.mail import EmailMessage email = EmailMessage( "Hello", "Body goes here", "from@example.com", ["to1@example.com", "to2@example.com"], ["bcc@example.com"], reply_to=["another@example.com"], headers={"Message-ID": "foo"}, ) ``` Klassen har följande metoder: - `send(fail_silently=False)` skickar meddelandet. Om en anslutning angavs när e-postmeddelandet konstruerades kommer den anslutningen att användas. Annars kommer en instans av standardbackend att instansieras och användas. Om nyckelordsargumentet `fail_silently` är `True`, kommer undantag som uppkommer när meddelandet skickas att kväsas. En tom lista över mottagare kommer inte att ge upphov till något undantag. Det kommer att returnera `1` om meddelandet skickades framgångsrikt, annars `0`. - `message()` konstruerar ett `django.core.mail.SafeMIMEText`-objekt (en underklass av Pythons [`MIMEText`](https://docs.python.org/3/library/email.mime.html#email.mime.text.MIMEText)-klass) eller ett `django.core.mail.SafeMIMEMultipart`-objekt som innehåller det meddelande som ska skickas. Om du någonsin behöver utöka [`EmailMessage`](#django.core.mail.EmailMessage)-klassen, kommer du förmodligen att vilja åsidosätta den här metoden för att lägga in det innehåll du vill ha i MIME-objektet. - `recipients()` returnerar en lista över alla mottagare av meddelandet, oavsett om de är registrerade i attributen `to`, `cc` eller `bcc`. Detta är en annan metod som du kan behöva åsidosätta när du underklassar, eftersom SMTP-servern måste få veta hela listan över mottagare när meddelandet skickas. Om du lägger till ett annat sätt att ange mottagare i din klass, måste de också returneras från den här metoden. - `attach()` skapar en ny filbilaga och lägger till den i meddelandet. Det finns två sätt att anropa `attach()`: - Du kan skicka ett enda argument till den som är en [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase)-instans. Denna kommer att infogas direkt i det resulterande meddelandet. - Alternativt kan du skicka tre argument till `attach()`: `filnamn`, `innehåll` och `mimetype`. `filnamn` är namnet på den bifogade filen som den kommer att visas i e-postmeddelandet, `innehåll` är de data som kommer att finnas i den bifogade filen och `mimetype` är den valfria MIME-typen för den bifogade filen. Om du utelämnar `mimetype` kommer MIME-innehållstypen att gissas från filnamnet på bilagan. Till exempel: ``` message.attach("design.png", img_data, "image/png") ``` Om du anger en `mimetype` av `message/rfc822`, kommer den också att acceptera [`django.core.mail.EmailMessage`](#django.core.mail.EmailMessage) och [`email.message.Message`](https://docs.python.org/3/library/email.compat32-message.html#email.message.Message). För en `mimetype` som börjar med `text/` förväntas innehållet vara en sträng. Binära data kommer att avkodas med UTF-8, och om det misslyckas kommer MIME-typen att ändras till `application/octet-stream` och data kommer att bifogas oförändrat. Dessutom kommer `message/rfc822` bilagor inte längre att base64-kodas i strid med [**RFC 2046 Section 5.2.1**](https://datatracker.ietf.org/doc/html/rfc2046.html#section-5.2.1), vilket kan orsaka problem med att visa bilagorna i [Evolution](https://bugzilla.gnome.org/show_bug.cgi?id=651197) och [Thunderbird](https://bugzilla.mozilla.org/show_bug.cgi?id=333880). - `attach_file()` skapar en ny bilaga med hjälp av en fil från ditt filsystem. Anropa den med sökvägen till filen som ska bifogas och, eventuellt, MIME-typen som ska användas för bilagan. Om MIME-typen utelämnas kommer den att gissas från filnamnet. Du kan använda den så här: ``` message.attach_file("/images/weather_map.png") ``` För MIME-typer som börjar med `text/` hanteras binära data på samma sätt som i `attach()`. #### `class EmailAttachment` > **New in Django 5.2** En namngiven tupel för att lagra bilagor till ett e-postmeddelande. Den namngivna tupeln har följande index: - `filnamn` - `innehåll` - `mimetype` ### Skicka alternativa innehållstyper #### Skicka flera versioner av innehållet Det kan vara användbart att inkludera flera versioner av innehållet i ett e-postmeddelande; det klassiska exemplet är att skicka både text- och HTML-versioner av ett meddelande. Med Djangos e-postbibliotek kan du göra detta med hjälp av klassen [`EmailMultiAlternatives`](#django.core.mail.EmailMultiAlternatives). #### `class EmailMultiAlternatives` En underklass till [`EmailMessage`](#django.core.mail.EmailMessage) som tillåter ytterligare versioner av meddelandetexten i e-postmeddelandet via metoden [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative). Denna ärver direkt alla metoder (inklusive klassinitialiseringen) från [`EmailMessage`](#django.core.mail.EmailMessage). #### `alternatives` En lista med [`EmailAlternative`](#django.core.mail.EmailAlternative) namngivna tuples. Detta är särskilt användbart i tester: ``` self.assertEqual(len(msg.alternatives), 1) self.assertEqual(msg.alternatives[0].content, html_content) self.assertEqual(msg.alternatives[0].mimetype, "text/html") ``` Alternativ bör endast läggas till med hjälp av metoden [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative) eller skickas till konstruktören. > **Changed in Django 5.2** > > I äldre versioner var `alternatives` en lista med vanliga tupler, till skillnad från [`EmailAlternative`](#django.core.mail.EmailAlternative) namngivna tupler. #### `attach_alternative(content, mimetype)` Bifoga en alternativ representation av meddelandetexten i e-postmeddelandet. Om du t.ex. vill skicka en kombination av text och HTML kan du skriva: ``` from django.core.mail import EmailMultiAlternatives subject = "hello" from_email = "from@example.com" to = "to@example.com" text_content = "This is an important message." html_content = "

This is an important message.

" msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() ``` #### `body_contains(text)` > **New in Django 5.2** Returnerar ett booleskt värde som anger om den angivna `texten` finns med i e-postmeddelandets `body` och i alla bifogade alternativ av MIME-typen `text/*`. Detta kan vara användbart när du testar e-postmeddelanden. Till exempel: ``` def test_contains_email_content(self): subject = "Hello World" from_email = "from@example.com" to = "to@example.com" msg = EmailMultiAlternatives(subject, "I am content.", from_email, [to]) msg.attach_alternative("

I am content.

", "text/html") self.assertIs(msg.body_contains("I am content"), True) self.assertIs(msg.body_contains("

I am content.

"), False) ``` #### `class EmailAlternative` > **New in Django 5.2** En namngiven tupel för att lagra alternativa versioner av e-postinnehåll. Den namngivna tupeln har följande index: - `innehåll` - `mimetype` #### Uppdatering av standardinnehållstypen Som standard är MIME-typen för parametern `body` i ett [`EmailMessage`](#django.core.mail.EmailMessage) `"text/plain"`. Det är god praxis att låta detta vara, eftersom det garanterar att alla mottagare kommer att kunna läsa e-postmeddelandet, oavsett deras e-postklient. Men om du är säker på att dina mottagare kan hantera en alternativ innehållstyp kan du använda attributet `content_subtype` på [`EmailMessage`](#django.core.mail.EmailMessage)-klassen för att ändra huvudinnehållstypen. Huvudtypen kommer alltid att vara `"text"`, men du kan ändra subtypen. Till exempel: ``` msg = EmailMessage(subject, html_content, from_email, [to]) msg.content_subtype = "html" # Main content is now text/html msg.send() ``` ## Backend för e-post Själva sändningen av ett e-postmeddelande hanteras av e-postbackend. Klassen för e-postbackend har följande metoder: - `open()` instansierar en långlivad anslutning för e-postsändning. - `close()` stänger den aktuella anslutningen för e-postsändning. - `send_messages(email_messages)` skickar en lista med [`EmailMessage`](#django.core.mail.EmailMessage)-objekt. Om anslutningen inte är öppen kommer detta anrop att implicit öppna anslutningen och stänga anslutningen efteråt. Om anslutningen redan är öppen kommer den att lämnas öppen efter att mailet har skickats. Den kan också användas som en kontexthanterare, som automatiskt anropar `open()` och `close()` efter behov: ``` from django.core import mail with mail.get_connection() as connection: mail.EmailMessage( subject1, body1, from1, [to1], connection=connection, ).send() mail.EmailMessage( subject2, body2, from2, [to2], connection=connection, ).send() ``` ### Hämta en instans av en e-postbackend Funktionen [`get_connection()`](#django.core.mail.get_connection) i `django.core.mail` returnerar en instans av e-postbackend som du kan använda. #### `get_connection(backend=None, fail_silently=False, **kwargs)` Som standard kommer ett anrop till `get_connection()` att returnera en instans av den e-postbackend som anges i [`EMAIL_BACKEND`](/sv/5.2/ref/settings/#std-setting-EMAIL_BACKEND). Om du anger argumentet `backend` kommer en instans av den backend att instansieras. Argumentet `fail_silently` styr hur backend ska hantera fel. Om `fail_silently` är True, kommer undantag under e-postsändningsprocessen att ignoreras tyst. Alla andra nyckelordsargument skickas direkt till konstruktören för e-postbackend. Django levereras med flera backends för att skicka e-post. Med undantag för SMTP-backend (som är standard) är dessa backends endast användbara under testning och utveckling. Om du har speciella krav på att skicka e-post kan du [skriva din egen e-postbackend](#topic-custom-email-backend). #### SMTP-backend #### `class backends.smtp.EmailBackend(host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs)` Detta är standardbackend. E-post kommer att skickas via en SMTP-server. Värdet för varje argument hämtas från den matchande inställningen om argumentet är `None`: - `host`: `` EMAIL_HOST` `` - `port`: [`EMAIL_PORT`](/sv/5.2/ref/settings/#std-setting-EMAIL_PORT) - `username`: [`EMAIL_HOST_USER`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_USER) - `password`: [`EMAIL_HOST_PASSWORD`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) - `use_tls`: `` EMAIL_USE_TLS` `` - `use_ssl`: `` EMAIL_USE_SSL` `` - `timeout`: `` EMAIL_TIMEOUT` `` - `ssl_keyfile`: [`EMAIL_SSL_KEYFILE`](/sv/5.2/ref/settings/#std-setting-EMAIL_SSL_KEYFILE) - `ssl_certfile`: `` EMAIL_SSL_CERTFILE` `` SMTP-backend är standardkonfigurationen som ärvs av Django. Om du vill ange det uttryckligen lägger du till följande i dina inställningar: ``` EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend" ``` Om inget anges kommer standard `timeout` att vara den som tillhandahålls av [`socket.getdefaulttimeout()`](https://docs.python.org/3/library/socket.html#socket.getdefaulttimeout), som har standardvärdet `None` (ingen timeout). #### Backend för konsol Istället för att skicka ut riktiga e-postmeddelanden skriver konsolbackend bara de e-postmeddelanden som skulle skickas till standardutmatningen. Som standard skriver konsolbackend till `stdout`. Du kan använda ett annat strömliknande objekt genom att ange nyckelordsargumentet `stream` när du konstruerar anslutningen. För att ange denna backend, lägg till följande i dina inställningar: ``` EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend" ``` Denna backend är inte avsedd att användas i produktion - den tillhandahålls som en bekvämlighet som kan användas under utveckling. #### Backend för filer Filbackend skriver e-postmeddelanden till en fil. En ny fil skapas för varje ny session som öppnas på denna backend. Katalogen som filerna skrivs till hämtas antingen från inställningen [`EMAIL_FILE_PATH`](/sv/5.2/ref/settings/#std-setting-EMAIL_FILE_PATH) eller från nyckelordet `file_path` när en anslutning skapas med [`get_connection()`](#django.core.mail.get_connection). För att ange denna backend, lägg till följande i dina inställningar: ``` EMAIL_BACKEND = "django.core.mail.backends.filebased.EmailBackend" EMAIL_FILE_PATH = "/tmp/app-messages" # change this to a proper location ``` Denna backend är inte avsedd att användas i produktion - den tillhandahålls som en bekvämlighet som kan användas under utveckling. #### Backend i minnet Backend `'locmem` lagrar meddelanden i ett speciellt attribut i modulen `django.core.mail`. Attributet `outbox` skapas när det första meddelandet skickas. Det är en lista med en [`EmailMessage`](#django.core.mail.EmailMessage)-instans för varje meddelande som skulle skickas. För att ange denna backend, lägg till följande i dina inställningar: ``` EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend" ``` Denna backend är inte avsedd att användas i produktion - den tillhandahålls som en bekvämlighet som kan användas under utveckling och testning. Djangos testlöpare [använder automatiskt denna backend för testning](/sv/5.2/topics/testing/tools/#topics-testing-email). #### Dummy backend Som namnet antyder gör dummy-backend ingenting med dina meddelanden. För att ange denna backend, lägg till följande i dina inställningar: ``` EMAIL_BACKEND = "django.core.mail.backends.dummy.EmailBackend" ``` Denna backend är inte avsedd att användas i produktion - den tillhandahålls som en bekvämlighet som kan användas under utveckling. ### Definiera en anpassad backend för e-post Om du behöver ändra hur e-postmeddelanden skickas kan du skriva din egen e-postbackend. Inställningen [`EMAIL_BACKEND`](/sv/5.2/ref/settings/#std-setting-EMAIL_BACKEND) i din inställningsfil är sedan Python-importsökvägen för din backend-klass. Anpassade e-postbackends bör underordna sig `BaseEmailBackend` som finns i modulen `django.core.mail.backends.base`. En anpassad e-postbackend måste implementera metoden `send_messages(email_messages)`. Denna metod tar emot en lista med [`EmailMessage`](#django.core.mail.EmailMessage)-instanser och returnerar antalet framgångsrikt levererade meddelanden. Om din backend har något koncept för en ihållande session eller anslutning bör du också implementera metoderna `open()` och `close()`. Referera till `smtp.EmailBackend` för en referensimplementering. ### Skicka flera e-postmeddelanden Att upprätta och stänga en SMTP-anslutning (eller någon annan nätverksanslutning för den delen) är en dyr process. Om du har många e-postmeddelanden att skicka är det klokt att återanvända en SMTP-anslutning i stället för att skapa och förstöra en anslutning varje gång du vill skicka ett e-postmeddelande. Det finns två sätt att tala om för en e-postbackend att den ska återanvända en anslutning. För det första kan du använda metoden `send_messages()` på en anslutning. Detta tar en lista över [`EmailMessage`](#django.core.mail.EmailMessage) (eller underklass) instanser, och skickar dem alla med hjälp av den enda anslutningen. Som en konsekvens ignoreras alla [`connection`](#django.core.mail.EmailMessage) som anges för ett enskilt meddelande. Om du till exempel har en funktion som heter `get_notification_email()` som returnerar en lista med [`EmailMessage`](#django.core.mail.EmailMessage)-objekt som representerar några periodiska e-postmeddelanden som du vill skicka ut, kan du skicka dessa e-postmeddelanden med ett enda anrop till send\_messages: ``` from django.core import mail connection = mail.get_connection() # Use default email connection messages = get_notification_email() connection.send_messages(messages) ``` I det här exemplet öppnar anropet till `send_messages()` en anslutning på backend, skickar listan med meddelanden och stänger sedan anslutningen igen. Det andra tillvägagångssättet är att använda metoderna `open()` och `close()` på e-postbackend för att manuellt styra anslutningen. `send_messages()` öppnar eller stänger inte anslutningen manuellt om den redan är öppen, så om du öppnar anslutningen manuellt kan du styra när den ska stängas. Till exempel: ``` from django.core import mail connection = mail.get_connection() # Manually open the connection connection.open() # Construct an email message that uses the connection email1 = mail.EmailMessage( "Hello", "Body goes here", "from@example.com", ["to1@example.com"], connection=connection, ) email1.send() # Send the email # Construct two more messages email2 = mail.EmailMessage( "Hello", "Body goes here", "from@example.com", ["to2@example.com"], ) email3 = mail.EmailMessage( "Hello", "Body goes here", "from@example.com", ["to3@example.com"], ) # Send the two emails in a single call - connection.send_messages([email2, email3]) # The connection was already open so send_messages() doesn't close it. # We need to manually close the connection. connection.close() ``` ## Konfigurera e-post för utveckling Det finns tillfällen då man inte vill att Django ska skicka e-post överhuvudtaget. Till exempel när du utvecklar en webbplats vill du förmodligen inte skicka ut tusentals e-postmeddelanden - men du kanske vill validera att e-postmeddelanden kommer att skickas till rätt personer under rätt förhållanden och att dessa e-postmeddelanden innehåller rätt innehåll. Det enklaste sättet att konfigurera e-post för lokal utveckling är att använda e-postbackend [console](#topic-email-console-backend). Denna backend omdirigerar all e-post till `stdout`, så att du kan inspektera innehållet i e-postmeddelanden. E-postbackend [file](#topic-email-file-backend) kan också vara användbar under utvecklingsarbetet - den här backend-enheten dumpar innehållet i varje SMTP-anslutning till en fil som kan inspekteras när du vill. En annan metod är att använda en ”dum” SMTP-server som tar emot e-postmeddelanden lokalt och visar dem på terminalen, men som faktiskt inte skickar något. Paketet [aiosmtpd](https://pypi.org/project/aiosmtpd/) tillhandahåller ett sätt att åstadkomma detta: ```shell python -m pip install aiosmtpd python -m aiosmtpd -n -l localhost:8025 ``` Detta kommando startar en minimal SMTP-server som lyssnar på port 8025 på localhost. Den här servern skriver ut alla e-postrubriker och e-posttexten till standardutdata. Du behöver sedan bara ställa in [`EMAIL_HOST`](/sv/5.2/ref/settings/#std-setting-EMAIL_HOST) och [`EMAIL_PORT`](/sv/5.2/ref/settings/#std-setting-EMAIL_PORT) i enlighet med detta. För en mer detaljerad diskussion om SMTP-serveralternativ, se dokumentationen för modulen [aiosmtpd](https://aiosmtpd.readthedocs.io/en/latest/). Information om hur du enhetstestar e-postmeddelanden i din applikation finns i avsnittet [E-posttjänster](/sv/5.2/topics/testing/tools/#topics-testing-email) i testdokumentationen.