---
title: "メールを送信する"
version: 6.0
locale: ja
source: https://docs.djangoproject.com/ja/6.0/topics/email/
canonical: https://djangodocs.dev/ja/6.0/topics/email/
---
# メールを送信する

Python は [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib) モジュールを使ってメール送信インタフェースを提供していますが、Django はさらにいくつかの軽いラッパーを用意しています。これらのラッパーは、 メールをよりすばやく送信したり、開発中にメール送信をテストしたり、SMTP を使用できないプラットフォームをサポートしたりするために用意されています。

コードは `django.core.mail` モジュールにあります。

## 簡単な例

簡単なメール送信には [`send_mail()`](#django.core.mail.send_mail) を使用します。たとえば、プレーンテキストのメッセージを送信するには、次のようにします。

```
from django.core.mail import send_mail

send_mail(
    "Subject here",
    "Here is the message.",
    "from@example.com",
    ["to@example.com"],
    fail_silently=False,
)
```

追加のメール送信機能が必要な場合は、[`EmailMessage`](#django.core.mail.EmailMessage) または [`EmailMultiAlternatives`](#django.core.mail.EmailMultiAlternatives) を使用してください。例えば、特定のテンプレートとカスタムヘッダーを使用して、HTMLバージョンとプレーンテキストバージョンの両方を含むマルチパートメールを送信する場合は、次のようにします。

```
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="Subject here",
    body=text_content,
    from_email="from@example.com",
    to=["to@example.com"],
    headers={"List-Unsubscribe": "<mailto:unsub@example.com>"},
)

# Lastly, attach the HTML content to the email instance and send.
msg.attach_alternative(html_content, "text/html")
msg.send()
```

設定内の [`EMAIL_HOST`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST) と [`EMAIL_PORT`](/ja/6.0/ref/settings/#std-setting-EMAIL_PORT) で指定された SMTP ホストとポートを使用して、メールが送信されます。[`EMAIL_HOST_USER`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_USER) と [`EMAIL_HOST_PASSWORD`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) が指定されている場合は、SMTP サーバーの認証に使われます。そして、[`EMAIL_USE_TLS`](/ja/6.0/ref/settings/#std-setting-EMAIL_USE_TLS) と [`EMAIL_USE_SSL`](/ja/6.0/ref/settings/#std-setting-EMAIL_USE_SSL) 設定により、セキュアコネクションを使うかどうかをコントロールします。

> **Note**
>
> `django.core.mail` で送信されるメールの文字セットは、[`DEFAULT_CHARSET`](/ja/6.0/ref/settings/#std-setting-DEFAULT_CHARSET) 設定の値にセットされます。

## `send_mail()`

#### `send_mail(subject, message, from_email, recipient_list, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)`

ほとんどの場合、 `django.core.mail.send_mail()` を使ってメールを送信できます。

`subject`、`message`、`from_email`、`recipient_list` の 4 つの引数は必須です。

- `subject`: 文字列。
- `message`: 文字列。
- `from_email`: 文字列。もし `None` なら、 Django は [`DEFAULT_FROM_EMAIL`](/ja/6.0/ref/settings/#std-setting-DEFAULT_FROM_EMAIL) 設定の値を使います。
- `recipient_list`: メールアドレスを表す文字列のリスト。`recipient_list` の各メンバーは、メールメッセージの "To:" フィールドで他の受信者を見ることができます。

The following parameters are optional, and must be given as keyword arguments
if used.

- `fail_silently`: 真偽値です。これが `False` の場合、エラーが発生したときに `send_mail()` は [`smtplib.SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException) を発生させます。可能な例外のリストについては [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib) のドキュメントを参照してください。これらの例外はすべて [`SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException) のサブクラスです。
- `auth_user`: SMTP サーバー認証のためのユーザー名で、省略可能。指定されなかった場合、Django [`EMAIL_HOST_USER`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_USER) 設定の値を使います。
- `auth_password`: SMTP サーバー認証のためのパスワードで、省略可能。指定されなかった場合、Django は [`EMAIL_HOST_PASSWORD`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) 設定の値を使います。
- `connection`: メール送信のために使うバックエンドで、省略可能。指定しなかった場合、デフォルトのバックエンドのインスタンスが使われます。詳しくは [メールのバックエンド](#topic-email-backends) を参照してください。
- `html_message`: `html_message` が指定された場合、送信されるメールは `multipart/alternative` となり、`text/plain` コンテンツタイプを持つ `message` と `text/html` コンテンツタイプを持つ `html_message` を合わせ持つものになります。

返り値は、送信に成功したメッセージの数です (送信されるメッセージが 1 つだけの場合もあるため、`0` や `1` になることもあります)。

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## `send_mass_mail()`

#### `send_mass_mail(datatuple, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, auth_user=None, auth_password=None, connection=None)`

`django.core.mail.send_mass_mail()` は、大量のメール送信を扱うために用意されています。

`datatuple` はメッセージの集合を表すタプルです。タプル内の各要素は、それぞれ1種類のメッセージを表すタプルであり、次の形式を持ちます。

```
(subject, message, from_email, recipient_list)
```

`fail_silently`, `auth_user`, `auth_password` and `connection` have the
same functions as in [`send_mail()`](#django.core.mail.send_mail). They must be given as keyword arguments
if used.

Each separate element of `datatuple` results in a separate email message.
As in [`send_mail()`](#django.core.mail.send_mail), recipients in the same `recipient_list` will all see
the other addresses in the email messages' "To:" field.

たとえば、次のコードは異なる 2 つのメッセージを 異なる 2 つの受信者のセットに送信します。しかし、メールサーバーへのコネクションは 1 つしか開かれません。

```
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)
```

戻り値は、メッセージ送信に成功した数です。

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

### `send_mass_mail()` と `send_mail()` の比較

The main difference between [`send_mass_mail()`](#django.core.mail.send_mass_mail) and [`send_mail()`](#django.core.mail.send_mail) is
that [`send_mail()`](#django.core.mail.send_mail) opens a connection to the mail server each time it's
executed, while [`send_mass_mail()`](#django.core.mail.send_mass_mail) uses a single connection for all of its
messages. This makes [`send_mass_mail()`](#django.core.mail.send_mass_mail) slightly more efficient.

## `mail_admins()`

#### `mail_admins(subject, message, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, connection=None, html_message=None)`

`django.core.mail.mail_admins()` は、[`ADMINS`](/ja/6.0/ref/settings/#std-setting-ADMINS) 設定で定義されているサイト管理者 (admin) に対してメールを送信するためのショートカットです。

`mail_admins()` は件名の前に [`EMAIL_SUBJECT_PREFIX`](/ja/6.0/ref/settings/#std-setting-EMAIL_SUBJECT_PREFIX) 設定の値を付けますが、デフォルトでは `"[Django] "` です。

メールの "From: " ヘッダは [`SERVER_EMAIL`](/ja/6.0/ref/settings/#std-setting-SERVER_EMAIL) 設定の値になります。

このメソッドは利便性と読みやすさのために存在します。

`html_message` が指定された場合、送信されるメールは `multipart/alternative` となり、`text/plain` コンテンツタイプを持つ `message` と `text/html` コンテンツタイプを持つ `html_message` を合わせ持つものになります。

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## `mail_managers()`

#### `mail_managers(subject, message, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, connection=None, html_message=None)`

`django.core.mail.mail_managers()` は、`mail_admins()` とほぼ同じで、[`MANAGERS`](/ja/6.0/ref/settings/#std-setting-MANAGERS) 設定で定義されているサイト管理者 (manager) にメールを送信します。

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## 例

以下の例は、[john@example.com](mailto:john@example.com) と [jane@example.com](mailto:jane@example.com) に1つのメールを送信します。2人とも "To:" 内に宛先が見られます。

```
send_mail(
    "Subject",
    "Message.",
    "from@example.com",
    ["john@example.com", "jane@example.com"],
)
```

This sends a message to `john@example.com` and `jane@example.com`, with
them both receiving a separate email:

```
datatuple = (
    ("Subject", "Message.", "from@example.com", ["john@example.com"]),
    ("Subject", "Message.", "from@example.com", ["jane@example.com"]),
)
send_mass_mail(datatuple)
```

## ヘッダインジェクションを防止する

[ヘッダインジェクション](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection.html) は、攻撃者が 、スクリプトで生成されたメールメッセージの "To:" と "From:" をコントロールするために、メールヘッダを挿入してしまうセキュリティ上の脆弱性です。

The Django email functions outlined above all protect against header injection
by forbidding newlines in header values. If any `subject`, `from_email` or
`recipient_list` contains a newline (in either Unix, Windows or Mac style),
the email function (e.g. [`send_mail()`](#django.core.mail.send_mail)) will raise [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) and,
hence, will not send the email. It's your responsibility to validate all data
before passing it to the email functions.

ヘッダーが含まれている文字列を `message` として渡した場合、ヘッダー部分はメールメッセージの冒頭に出力されます。

Here's an example view that takes a `subject`, `message` and `from_email`
from the request's POST data, sends that to `admin@example.com` and redirects
to "/contact/thanks/" when it's done:

```
from django.core.mail import 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 ValueError:
            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.")
```

> **Changed in Django 6.0**
>
> Older versions raised `django.core.mail.BadHeaderError` for some
> invalid headers. This has been replaced with `ValueError`.

## `EmailMessage` クラス

Django's [`send_mail()`](#django.core.mail.send_mail) and [`send_mass_mail()`](#django.core.mail.send_mass_mail) functions are actually
thin wrappers that make use of the [`EmailMessage`](#django.core.mail.EmailMessage) class.

Not all features of the [`EmailMessage`](#django.core.mail.EmailMessage) class are available through the
[`send_mail()`](#django.core.mail.send_mail) and related wrapper functions. If you wish to use advanced
features, such as BCC'ed recipients, file attachments, or multi-part email,
you'll need to create [`EmailMessage`](#django.core.mail.EmailMessage) instances directly.

> **Note**
>
> This is a design feature. [`send_mail()`](#django.core.mail.send_mail) and related functions were
> originally the only interface Django provided. However, the list of
> parameters they accepted was slowly growing over time. It made sense to
> move to a more object-oriented design for email messages and retain the
> original functions only for backwards compatibility.

[`EmailMessage`](#django.core.mail.EmailMessage) is responsible for creating the email message itself. The
[email backend](#topic-email-backends) is then responsible for sending the
email.

For convenience, [`EmailMessage`](#django.core.mail.EmailMessage) provides a [`send()`](#django.core.mail.EmailMessage.send)
method for sending a single email. If you need to send multiple messages, the
email backend API [provides an alternative](#topics-sending-multiple-emails).

### `EmailMessage` オブジェクト

#### `class EmailMessage`

The `EmailMessage` class is initialized with the following
parameters. All parameters are optional and can be set at any time prior
to calling the [`send()`](#django.core.mail.EmailMessage.send) method.

The first four parameters can be passed as positional or keyword arguments,
but must be in the given order if positional arguments are used:

- `subject`: メールの件名の行。
- `body`: 本文のテキスト。プレーンテキストのメッセージでなければなりません。
- `from_email`: 送信者のアドレス。 `fred@example.com` と `"Fred" <fred@example.com>` のどちらの形式でも構いません。省略された場合は [`DEFAULT_FROM_EMAIL`](/ja/6.0/ref/settings/#std-setting-DEFAULT_FROM_EMAIL) の設定が使用されます。
- `to`: 受信者のメールアドレスのリストまたはタプル。

The following parameters must be given as keyword arguments if used:

- メールを送信するときに "Cc" ヘッダ内で使われる、受信者のアドレスのリストまたはタプル。
- `bcc`: メールを送信するときに "Bcc" ヘッダ内で使われるメールアドレスのリストまたはタプル。
- `reply_to`: メールを送信するときに "Reply-To" ヘッダ内で使われる、受信者のアドレスのリストまたはタプル。
- `attachments`: A list of attachments to put on the message. Each can
  be an instance of [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) or
  [`EmailAttachment`](#django.core.mail.EmailAttachment), or a tuple with attributes
  `(filename, content, mimetype)`.

  > **Changed in Django 5.2**
  >
  > Support for [`EmailAttachment`](#django.core.mail.EmailAttachment) items of `attachments` was
  > added.

  > **Changed in Django 6.0**
  >
  > Support for [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) objects in the
  > `attachments` list was added.

  > **Deprecated since Django 6.0**
  >
  > バージョン 6.0 で非推奨: Support for Python's legacy [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase)
  > objects in `attachments` is deprecated. Use
  > [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) instead.
- `headers`: メッセージに追加するヘッダーの辞書。キーはヘッダ名、値はヘッダ値です。メールメッセージに対して適切なヘッダ名と値にするのは、呼び出す側の責任です。対応する属性は `extra_headers` です。
- `connection`: An [email backend](#topic-email-backends) instance.
  Use this parameter if you are sending the `EmailMessage` via
  [`send()`](#django.core.mail.EmailMessage.send) and you want to use the same connection for multiple
  messages. If omitted, a new connection is created when [`send()`](#django.core.mail.EmailMessage.send) is
  called. This parameter is ignored when using
  [send\_messages()](#topics-sending-multiple-emails).

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing all except the first four parameters as positional arguments is
> deprecated.

例:

```
from django.core.mail import EmailMessage

email = EmailMessage(
    subject="Hello",
    body="Body goes here",
    from_email="from@example.com",
    to=["to1@example.com", "to2@example.com"],
    bcc=["bcc@example.com"],
    reply_to=["another@example.com"],
    headers={"Message-ID": "foo"},
)
```

このクラスには以下のメソッドがあります。

#### `send(fail_silently=False)`

Sends the message. If a connection was specified when the email was
constructed, that connection will be used. Otherwise, an instance of
the default backend will be instantiated and used. If the keyword
argument `fail_silently` is `True`, exceptions raised while sending
the message will be quashed. An empty list of recipients will not raise
an exception. It will return `1` if the message was sent
successfully, otherwise `0`.

#### `message(* (Keyword-only parameters separator (PEP 3102)), policy=email.policy.default)`

Constructs and returns a Python [`email.message.EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage)
object representing the message to be sent.

The keyword argument `policy` allows specifying the set of rules for
updating and serializing the representation of the message. It must be
an [`email.policy.Policy`](https://docs.python.org/3/library/email.policy.html#module-email.policy) object. Defaults to
[`email.policy.default`](https://docs.python.org/3/library/email.policy.html#email.policy.default). In certain cases you may want to use
[`SMTP`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTP), [`SMTPUTF8`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTPUTF8) or a custom
policy. For example,
[`django.core.mail.backends.smtp.EmailBackend`](#django.core.mail.backends.smtp.EmailBackend) uses the
[`SMTP`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTP) policy to ensure `\r\n` line endings as
required by the SMTP protocol.

If you ever need to extend Django's [`EmailMessage`](#django.core.mail.EmailMessage) class,
you'll probably want to override this method to put the content you
want into the Python EmailMessage object.

> **Changed in Django 6.0**
>
> The `policy` keyword argument was added and the return type was
> updated to an instance of [`EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage).

#### `recipients()`

Returns a list of all the recipients of the message, whether they're
recorded in the `to`, `cc` or `bcc` attributes. This is another
method you might need to override when subclassing, because the SMTP
server needs to be told the full list of recipients when the message
is sent. If you add another way to specify recipients in your class,
they need to be returned from this method as well.

#### `attach(filename, content, mimetype)`

#### `attach(mimepart)`

Creates a new attachment and adds it to the message. There are two ways
to call `attach()`:

- You can pass it three arguments: `filename`, `content` and
  `mimetype`. `filename` is the name of the file attachment as it
  will appear in the email, `content` is the data that will be
  contained inside the attachment and `mimetype` is the optional MIME
  type for the attachment. If you omit `mimetype`, the MIME content
  type will be guessed from the filename of the attachment.

  例:

  ```
  message.attach("design.png", img_data, "image/png")
  ```

  If you specify a `mimetype` of `message/rfc822`,
  `content` can be a [`django.core.mail.EmailMessage`](#django.core.mail.EmailMessage) or
  Python's [`email.message.EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage) or
  [`email.message.Message`](https://docs.python.org/3/library/email.compat32-message.html#email.message.Message).

  `text/` で始まる `mimetype` では、コンテンツは文字列であることが期待されます。バイナリデータはUTF-8でデコードされ、それが失敗した場合、MIMEタイプは `application/octet-stream` に変更され、データは変更されずに添付されます。
- Or for attachments requiring additional headers or parameters, you
  can pass `attach()` a single Python
  [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) object. This will be attached
  directly to the resulting message. For example, to attach an inline
  image with a `Content-ID`:

  ```
  import email.utils
  from email.message import MIMEPart
  from django.core.mail import EmailMultiAlternatives

  message = EmailMultiAlternatives(...)
  image_data_bytes = ...  # Load image as bytes

  # Create a random Content-ID, including angle brackets
  cid = email.utils.make_msgid()
  inline_image = email.message.MIMEPart()
  inline_image.set_content(
      image_data_bytes,
      maintype="image",
      subtype="png",  # or "jpeg", etc. depending on the image type
      disposition="inline",
      cid=cid,
  )
  message.attach(inline_image)
  # Refer to Content-ID in HTML without angle brackets
  message.attach_alternative(f'… <img src="cid:{cid[1:-1]}"> …', "text/html")
  ```

  Python's [`email.contentmanager.set_content()`](https://docs.python.org/3/library/email.contentmanager.html#email.contentmanager.set_content) documentation
  describes the supported arguments for `MIMEPart.set_content()`.

  > **Changed in Django 6.0**
  >
  > Support for [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) attachments was
  > added.

  > **Deprecated since Django 6.0**
  >
  > バージョン 6.0 で非推奨: Support for [`email.mime.base.MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) attachments is
  > deprecated. Use [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) instead.

#### `attach_file(path, mimetype=None)`

Creates a new attachment using a file from your filesystem. Call it
with the path of the file to attach and, optionally, the MIME type to
use for the attachment. If the MIME type is omitted, it will be guessed
from the filename. You can use it like this:

```
message.attach_file("/images/weather_map.png")
```

For MIME types starting with `text/`, binary data is handled
as in [`attach()`](#django.core.mail.EmailMessage.attach).

#### `class EmailAttachment`

> **New in Django 5.2**

メールに添付するファイルを保持するための名前付きタプルです。

この名前付きタプルは、下記のインデックスを持ちます：

- `filename`
- `content`
- `mimetype`

### 代替のコンテンツタイプを送信する

#### 複数のバージョンを持つコンテンツを送る

It can be useful to include multiple versions of the content in an email; the
classic example is to send both text and HTML versions of a message. With
Django's email library, you can do this using the
[`EmailMultiAlternatives`](#django.core.mail.EmailMultiAlternatives) class.

#### `class EmailMultiAlternatives`

[`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative) メソッドを通じて、メール本文の別バージョンを追加できるようにした [`EmailMessage`](#django.core.mail.EmailMessage) のサブクラスです。このクラスは [`EmailMessage`](#django.core.mail.EmailMessage) からすべてのメソッド（初期化メソッドも含む）をそのまま継承しています。

#### `alternatives`

A list of [`EmailAlternative`](#django.core.mail.EmailAlternative) named tuples.
This is particularly useful in tests:

```
self.assertEqual(len(msg.alternatives), 1)
self.assertEqual(msg.alternatives[0].content, html_content)
self.assertEqual(msg.alternatives[0].mimetype, "text/html")
```

代替コンテンツは、 [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative) メソッドを使って追加するか、コンストラクタに渡して指定する必要があります。

> **Changed in Django 5.2**
>
> In older versions, `alternatives` was a list of regular tuples,
> as opposed to [`EmailAlternative`](#django.core.mail.EmailAlternative) named tuples.

#### `attach_alternative(content, mimetype)`

メール内にメッセージ本文の代替の表現を添付します。

例えば、テキスト版とHTML版を組み合わせて送信する場合、次のようにします。

```
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 = "<p>This is an <strong>important</strong> message.</p>"
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**

指定された `text` が、メールの `body` およびすべての `text/*` MIME タイプの代替コンテンツに含まれているかどうかを示す真偽値を返します。

これはメールのテストのときに便利です。たとえば：

```
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("<p>I am content.</p>", "text/html")

    self.assertIs(msg.body_contains("I am content"), True)
    self.assertIs(msg.body_contains("<p>I am content.</p>"), False)
```

#### `class EmailAlternative`

> **New in Django 5.2**

メールコンテンツの別バージョンを保持するための名前付きタプルです。

この名前付きタプルは、下記のインデックスを持ちます：

- `content`
- `mimetype`

#### デフォルトのコンテンツタイプを変更する

By default, the MIME type of the `body` parameter in an [`EmailMessage`](#django.core.mail.EmailMessage)
is `"text/plain"`. It is good practice to leave this alone, because it
guarantees that any recipient will be able to read the email, regardless of
their mail client. However, if you are confident that your recipients can
handle an alternative content type, you can use the `content_subtype`
attribute on the [`EmailMessage`](#django.core.mail.EmailMessage) class to change the main content type.
The major type will always be `"text"`, but you can change the subtype. For
example:

```
msg = EmailMessage(subject, html_content, from_email, [to])
msg.content_subtype = "html"  # Main content is now text/html
msg.send()
```

## メールのバックエンド

実際のメール送信は、メールバックエンドによって処理されます。

メールバックエンドのクラスには以下のメソッドがあります:

- `open()` は、長寿命のメール送信のコネクションをインスタンス化します。
- `close()` は、現在のメール送信のコネクションを閉じます。
- `send_messages(email_messages)` sends a list of [`EmailMessage`](#django.core.mail.EmailMessage)
  objects. If the connection is not open, this call will implicitly open the
  connection, and close the connection afterward. If the connection is already
  open, it will be left open after mail has been sent.

コンテキストマネジャーとしても使うことができ、必要に応じて自動的に `open()` と `close()` 呼びます:

```
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()
```

### メールバックエンドのインスタンスを取得する

`django.core.mail` 内の [`get_connection()`](#django.core.mail.get_connection) 関数は、利用可能なメールバックエンドのインスタンスを返します。

#### `get_connection(backend=None, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, **kwargs)`

デフォルトでは、`get_connection()` を呼び出すと [`EMAIL_BACKEND`](/ja/6.0/ref/settings/#std-setting-EMAIL_BACKEND) 内で指定されたメールバックエンドのインスタンスを返します。`backend` 引数を指定した場合、そのバックエンドがインスタンス化されます。

The keyword-only `fail_silently` argument controls how the backend should
handle errors. If `fail_silently` is True, exceptions during the email
sending process will be silently ignored.

その他のキーワード引数はメールバックエンドのコンストラクタに直接渡されます。

Django には複数のメール送信バックエンドを付属しています。SMTP バックエンド (デフォルトです) を除いて、これらのバックエンドはテストと開発のみで役立ちます。特別なメール送信が必要な場合には、[独自のメールバックエンドを記述する](#topic-custom-email-backend) を参照してください。

> **Deprecated since Django 6.0**
>
> バージョン 6.0 で非推奨: Passing `fail_silently` as positional argument is deprecated.

#### SMTP バックエンド

#### `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)`

デフォルトのバックエンド。メールは SMTP サーバを通して送信されます。

引数が `None` の場合、各引数に対する値は、以下のそれぞれの設定から取得されます。

- `host`: [`EMAIL_HOST`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST)
- `port`: [`EMAIL_PORT`](/ja/6.0/ref/settings/#std-setting-EMAIL_PORT)
- `username`: [`EMAIL_HOST_USER`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_USER)
- `password`: [`EMAIL_HOST_PASSWORD`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD)
- `use_tls`: [`EMAIL_USE_TLS`](/ja/6.0/ref/settings/#std-setting-EMAIL_USE_TLS)
- `use_ssl`: [`EMAIL_USE_SSL`](/ja/6.0/ref/settings/#std-setting-EMAIL_USE_SSL)
- `timeout`: [`EMAIL_TIMEOUT`](/ja/6.0/ref/settings/#std-setting-EMAIL_TIMEOUT)
- `ssl_keyfile`: [`EMAIL_SSL_KEYFILE`](/ja/6.0/ref/settings/#std-setting-EMAIL_SSL_KEYFILE)
- `ssl_certfile`: [`EMAIL_SSL_CERTFILE`](/ja/6.0/ref/settings/#std-setting-EMAIL_SSL_CERTFILE)

SMTP バックエンドは、Django によって継承されるデフォルトの構成です。明示的に指定したい場合は、設定内で以下の通り記述してください:

```
EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
```

If unspecified, the default `timeout` will be the one provided by
[`socket.getdefaulttimeout()`](https://docs.python.org/3/library/socket.html#socket.getdefaulttimeout), which defaults to `None` (no timeout).

#### コンソールバックエンド

実際のメールを送信する代わりに、コンソールバックエンドは単に標準出力に送信されるメールを書き込みます。 デフォルトでは、コンソールバックエンドは `stdout` に書き込みます。 コネクションを構築するときに `stream` キーワード引数を指定することで、別のストリーム的なオブジェクトを使用できます。

このバックエンドを指定するには、設定内に以下の通り記述してください:

```
EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
```

このバックエンドはプロダクトでの使用を想定していません -- 開発中の利便性のために提供されています。

#### ファイルバックエンド

The file backend writes emails to a file. A new file is created for each new
session that is opened on this backend. The directory to which the files are
written is either taken from the [`EMAIL_FILE_PATH`](/ja/6.0/ref/settings/#std-setting-EMAIL_FILE_PATH) setting or from the
`file_path` keyword when creating a connection with [`get_connection()`](#django.core.mail.get_connection).

このバックエンドを指定するには、設定内に以下の通り記述してください:

```
EMAIL_BACKEND = "django.core.mail.backends.filebased.EmailBackend"
EMAIL_FILE_PATH = "/tmp/app-messages"  # change this to a proper location
```

このバックエンドはプロダクトでの使用を想定していません -- 開発中の利便性のために提供されています。

#### インメモリーバックエンド

The `'locmem'` backend stores messages in a special attribute of the
`django.core.mail` module. The `outbox` attribute is created when the first
message is sent. It's a list with an [`EmailMessage`](#django.core.mail.EmailMessage) instance for each
message that would be sent.

このバックエンドを指定するには、設定内に以下の通り記述してください:

```
EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
```

このバックエンドはプロダクトでの使用を想定していません -- 開発とテストにおける利便性のために提供されています。

Django のテストランナーは [自動的にこのバックエンドをテストに使います](/ja/6.0/topics/testing/tools/#topics-testing-email) 。

#### ダミーバックエンド

名前が示すように、ダミーバックエンドはメッセージに何もしません。このバックエンドを指定するには、設定内に以下の通り記述してください:

```
EMAIL_BACKEND = "django.core.mail.backends.dummy.EmailBackend"
```

このバックエンドはプロダクトでの使用を想定していません -- 開発中の利便性のために提供されています。

> **There are community-maintained solutions too!**
>
> Django has a vibrant ecosystem. There are email backends
> highlighted on the [Community Ecosystem](https://www.djangoproject.com/community/ecosystem/#email-and-notifications) page. The Django Packages
> [Email grid](https://djangopackages.org/grids/g/email/) has even more options for you!

### 独自のメールバックエンドを定義する

メール送信の方法を変更する必要がある場合、独自のメールバックエンドを記述できます。設定ファイル内の [`EMAIL_BACKEND`](/ja/6.0/ref/settings/#std-setting-EMAIL_BACKEND) 設定が独自のバックエンドのクラスへの Python のインポートパスとなります。

Custom email backends should subclass `BaseEmailBackend` that is located in
the `django.core.mail.backends.base` module. A custom email backend must
implement the `send_messages(email_messages)` method. This method receives a
list of [`EmailMessage`](#django.core.mail.EmailMessage) instances and returns the number of successfully
delivered messages. If your backend has any concept of a persistent session or
connection, you should also implement the `open()` and `close()` methods.
Refer to `smtp.EmailBackend` for a reference implementation.

### 複数のメールを送信する

SMTP コネクション (またはその他のネットワークコネクション) の確立とクローズは、負荷の高い処理です。 送信するメールがたくさんある場合は、メールを送信するたびにコネクションの生成と破棄を繰り返すのではなく、SMTP コネクションを再利用する方が効率的です。

メールバックエンドにコネクションを再利用するよう通知するには、2 つの方法があります。

1つめは、1つの接続のもとで `send_messages()` メソッドを使用する方法です。このメソッドは、 [`EmailMessage`](#django.core.mail.EmailMessage) （またはそのサブクラス）のインスタンスのリストを受け取り、それらすべてを1つの接続を使用して送信します。その結果、個々のメッセージに設定された [`connection`](#django.core.mail.EmailMessage) は無視されます。

For example, if you have a function called `get_notification_email()` that
returns a list of [`EmailMessage`](#django.core.mail.EmailMessage) objects representing some periodic
email you wish to send out, you could send these emails using a single call to
`send_messages()`:

```
from django.core import mail

connection = mail.get_connection()  # Use default email connection
messages = get_notification_email()
connection.send_messages(messages)
```

この例では、`send_messages()` を呼び出してバックエンドのコネクションを開き、メッセージのリストを送信した後、再びコネクションを閉じています。

2つ目のアプローチは、メールバックエンドの `open()` メソッドと `close()` メソッドを使って手動でコネクションをコントロールする方法です。`send_messages()` は、すでにコネクションが開いている場合、自動でコネクションを開いたり閉じたりはしません。手動でコネクションを開いた場合、閉じるタイミングを自分でコントロールできます。たとえば、次のように書くことができます。

```
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()
```

## 開発用にメールを設定する

Django に電子メールをまったく送信させたくない場合もあるでしょう。たとえば、ウェブサイトの開発中に数千通のメールを送信したくはないでしょう。しかし、適切な条件で適切な人々にメールが送信され、これらのメールが正しい内容を含んでいるか検証したいことがあるかもしれません。

ローカル開発用にメールを設定する最も簡単な方法は [console](#topic-email-console-backend) メールバックエンドを使うことです。このバックエンドはすべてのメールを `stdout` にリダイレクトし、メールの内容を検査できるようにします。

[ファイル](#topic-email-file-backend) メールバックエンドも開発に役立ちます。このバックエンドは全ての SMTP コネクションをファイルにダンプし、都合の良いときに調べられるようにします。

もう1つのアプローチは、「ダム」SMTPサーバーを使用することです。このサーバーはメールをローカルで受信し、端末に表示するだけで、実際には何も送信しません。これを実現するには、[aiosmtpd](https://pypi.org/project/aiosmtpd/) パッケージを利用する方法があります。

```shell
python -m pip install "aiosmtpd >= 1.4.5"

python -m aiosmtpd -n -l localhost:8025
```

このコマンドは、localhostのポート8025で待ち受ける最小限のSMTPサーバを起動します。このサーバはすべてのメールヘッダとメール本文を標準出力に出力します。あとは [`EMAIL_HOST`](/ja/6.0/ref/settings/#std-setting-EMAIL_HOST) と [`EMAIL_PORT`](/ja/6.0/ref/settings/#std-setting-EMAIL_PORT) を適宜設定するだけです。SMTPサーバのオプションについてのより詳細な議論については、 [aiosmtpd](https://aiosmtpd.readthedocs.io/en/latest/) モジュールのドキュメントを参照してください。

アプリケーションでのメール送信のユニットテストについては、テストのドキュメントの [メールサービス](/ja/6.0/topics/testing/tools/#topics-testing-email) セクションを参照してください。