Двойное подчеркивание в html: Свойство text-decoration, подчёркивание и другие эффекты — Оформление текста — HTML Academy

Выполнение запросов — Документация Django 1.5.2

После создания модели, Django автоматически создает API для работы с базой данных, который позволяет вам создавать, получать, изменять и удалять объекты. Этот раздел расскажет вам как использовать этот API. В описании моделей вы можете найти список всех существующих опций поиска.

В этом разделе(и последующих) мы будем использовать такие модели:

Создание объектов

Для представления данных таблицы в виде объектов Python, Django использует интуитивно понятную систему: класс модели представляет таблицу, а экземпляр модели — запись в этой таблице.

Что бы создать объект, создайте экземпляр класса модели, указав необходимые поля в аргументах и вызовите метод save() что бы сохранить его в базе данной.

Вы можете импортировать класс модели как и любой другой класс в Python. (Мы упомянули это потому что в ранних версиях Django импорт моделей выглядел немного необычно.)

Предположим, что модель находится в mysite/blog/models.

>>> from blog.models import Blog
>>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')
>>> b.save()

В результате выполнения этого кода будет создан INSERT SQL запрос. Django не выполняет запросов к базе данных, пока не будет вызван метод save().

Метод save() ничего не возвращает.

См.также

save() принимает ряд аргументов не описанных в этом разделе. Смотрите документацию о методе save() для подробностей.

Что бы создать и сохранить объект используйте метод create().

Сохранение изменений в объектах

Для сохранения изменений в объект, который уже существует в базе данных, используйте save().

В данном примере изменяется название объекта b5 модели «Blog«и обновляется запись в базе данных:

>> b5.name = 'New name'
>> b5.save()

В результате выполнения этого кода будет создан UPDATE SQL запрос. Django не выполняет каких либо запросов к базе данных, пока не будет вызван метод save().

Сохранение полей ForeignKey и ManyToManyField

Обновление ForeignKey работает так же как и сохранение обычных полей; просто назначьте полю объект необходимого типа. В этом примере обновляется атрибут blog модели Entry объектом entry, предполагается что в базе данных уже существуют используемые объекты:

>>> from blog.models import Entry
>>> entry = Entry.objects.get(pk=1)
>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")
>>> entry.blog = cheese_blog
>>> entry.save()

Обновление ManyToManyField работает немного по другому; используйте метод add() поля, что бы добавить связанный объект. В этом примере объект joe модели Author добавляется к объекту entry:

>>> from blog.models import Author
>>> joe = Author.objects.create(name="Joe")
>>> entry.authors.add(joe)

Для добавления сразу нескольких объектов в ManyToManyField, добавьте несколько аргументов в метод add(). Например:

>>> john = Author.objects.create(name="John")
>>> paul = Author.objects.create(name="Paul")
>>> george = Author.objects.create(name="George")
>>> ringo = Author.objects.create(name="Ringo")
>>> entry.authors.add(john, paul, george, ringo)

Django вызовет исключение, если вы попытаетесь добавить объект неверного типа.

Получение объектов

Для получения объектов из базы данных, создается QuerySet через Manager модели.

QuerySet представляет выборку объектов из базы данных. Он может не содержать, или содержать один или несколько фильтров – критерии для ограничения выборки по определенным параметрам. В терминах SQL, QuerySet — это оператор SELECT, а фильтры — условия такие, как WHERE или LIMIT.

Вы получаете QuerySet используя Manager. Каждая модель содержит как минимум один Manager, и он называется objects по умолчанию. Обратиться к нему можно непосредственно через класс модели:

>>> Blog. objects
<django.db.models.manager.Manager object at ...>
>>> b = Blog(name='Foo', tagline='Bar')
>>> b.objects
Traceback:
    ...
AttributeError: "Manager isn't accessible via Blog instances."

Примечание

Обратиться к менеджерам можно только через модель и нельзя через ее экземпляр. Это сделано для разделения “table-level” операций и “record-level” операций.

Manager — главный источник QuerySet для модели. Например, Blog.objects.all() вернет QuerySet, который содержит все объекты Blog из базы данных.

Получение всех объектов

Самый простой способ получить объекты из таблицы — это получить их всех. Для этого используйте метод all() менеджера(Manager):

>>> all_entries = Entry.objects.all()

Метод all() возвращает QuerySet всех объектов в базе данных.

Получение объектов через фильтры

QuerySet, возвращенный Manager, описывает все объекты в таблице базы данных. Обычно вам нужно выбрать только подмножество всех объектов.

Для создания такого подмножества, вы можете изменить QuerySet добавив условия фильтрации. Два самых простых метода изменить QuerySet — это:

filter(**kwargs)

Возвращает новый QuerySet, который содержит объекты удовлетворяющие параметрам фильтрации.

exclude(**kwargs)

Возвращает новый QuerySet содержащий объекты, которые не удовлетворяют параметры фильтрации.

Параметры фильтрации (**kwargs в определении функций выше) должны быть в формате описанном в разделе `Field lookups`_.

Например, для создания QuerySet что бы получить записи с 2006, используйте filter() таким образом:

Entry.objects.filter(pub_date__year=2006)

Это аналогично:

Entry.objects.all().filter(pub_date__year=2006)

Цепочка фильтров

Результат изменения QuerySet — это новый QuerySet, по этому можно использовать цепочки фильтров. Например:

>>> Entry.objects.filter(
...     headline__startswith='What'
. .. ).exclude(
...     pub_date__gte=datetime.date.today()
... ).filter(
...     pub_date__gte=datetime(2005, 1, 30)
... )

В этом примере к начальному QuerySet, который возвращает все объекты, добавляется фильтр, затем исключающий фильтр, и еще один фильтр. Полученный QuerySet содержит все объекты, у которых заголовок начинается с “What”, и которые были опубликованы между 30-го января 2005 и текущей датой.

Отфильтрованный QuerySet – уникален

Например:

>> q1 = Entry.objects.filter(headline__startswith="What")
>> q2 = q1.exclude(pub_date__gte=datetime.date.today())
>> q3 = q1.filter(pub_date__gte=datetime.date.today())

Эти три QuerySets независимы. Первый – это базовый QuerySet, который содержит все объекты с заголовками, которые начинаются с “What”. Второй – это множество первых с дополнительным критерием фильтрации, который исключает объекты с pub_date больше, чем текущая дата. Третий – это множество первого, с отфильтрованными объектами, у которых pub_date больше, чем текущая дата. Первоначальный QuerySet (q1) не изменяется последующим добавлением фильтров.

QuerySets – ленивы

QuerySets – ленивы, создание QuerySet не выполняет запросов к базе данных. Вы можете добавлять фильтры хоть весь день и Django не выполнит ни один запрос пока QuerySet не вычислен. Разберем такой пример:

>>> q = Entry.objects.filter(headline__startswith="What")
>>> q = q.filter(pub_date__lte=datetime.date.today())
>>> q = q.exclude(body_text__icontains="food")
>>> print(q)

Глядя на это можно подумать что было выполнено три запроса в базу данных. На самом деле был выполнен один запрос, в последней строке (print(q)). Результат QuerySet не будет получен из базы данных пока вы не “попросите” об этом. Когда вы делаете это, QuerySet вычисляется запросом к базе данных. Для подробностей, в какой момент выполняется запрос, смотрите Когда вычисляется QuerySets.

Получение одного объекта с помощью get

Если вы знаете, что только один объект возвращается запросом, вы можете использовать метод get() менеджера(Manager), который возвращает непосредственно объект:

>>> one_entry = Entry.objects.get(pk=1)

Вы можете использовать для get() аргументы, такие же как и для filter() — смотрите `Field lookups`_ далее.

Учтите, что есть разница между использованием get() и filter() с [0]. Если результат пустой, get() вызовет исключение DoesNotExist. Это исключение является атрибутом модели для которой выполняется запрос. Если в примере выше, не существует объекта Entry с первичным ключом равным 1, Django вызовет исключение Entry. DoesNotExist.

Также Django отреагирует, если запрос get() вернет не один объект. В этом случае будет вызвано исключение MultipleObjectsReturned, которое так же является атрибутом класса модели.

Другие методы QuerySet

В большинстве случаев вы будете использовать all(), get(), filter() и exclude() для получения объектов из базы данных. Однако это не все доступные возможности; смотрите документацию о QuerySet API для получения информации о всех существующих методах QuerySet.

Ограничение выборки

Используйте синтаксис срезов для списков Python для ограничения результата выборки QuerySet. Это эквивалент таких операторов SQL как LIMIT и OFFSET.

Например, этот код возвращает 5 первых объектов (LIMIT 5):

>>> Entry.objects.all()[:5]

Этот возвращает с шестого по десятый (OFFSET 5 LIMIT 5):

>>> Entry.objects.all()[5:10]

Отрицательные индексы (например, Entry.objects.all()[-1]) не поддерживается.

На самом деле, срез QuerySet возвращает новый QuerySet – запрос не выполняется. При использовании аргумента “шаг” синтаксиса срезов в Python будет вызвано исключение. Например, этот пример выполнил бы запрос, возвращающий каждый

>>> Entry.objects.all()[:10:2]

Для получения одного объекта, а не списка (например, SELECT foo FROM bar LIMIT 1), используйте индекс вместо среза. Например, этот код возвращает первый объект Entry в базе данных, после сортировки записей по заголовку:

>>> Entry.objects.order_by('headline')[0]

Это эквивалент:

>>> Entry.objects.order_by('headline')[0:1].get()

Заметим, что первый пример вызовет IndexError в то время как второй — DoesNotExist, если запрос вернет ни один объект. Смотрите get() для подробностей.

Фильтры полей

Фильтры полей – это “операторы” для составления условий SQL WHERE. Они задаются как именованные аргументы для метода filter(), exclude() и get() в QuerySet.

Фильтры полей выглядят как field__lookuptype=value. (Используется двойное подчеркивание). Например:

>>> Entry.objects.filter(pub_date__lte='2006-01-01')

будет транслировано в SQL:

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

How this is possible

Python позволяет определить функции, которые принимают именованные аргументы с динамически вычисляемыми названиями и значениями. Подробности смотрите в разделе Именованные аргументы в официальной документации Python.

При передаче неверного именованного аргумента, будет вызвано исключение TypeError.

API базы данных поддерживает около двух дюжин фильтров; полный список можно найти в разделе о фильтрах полей. Вот пример самых используемых фильтров:

exact

“Точное” совпадение. Например:

>>> Entry.objects.get(headline__exact="Man bites dog")

Создаст такой SQL запрос:

SELECT ... WHERE headline = 'Man bites dog';

Если вы не укажите фильтр – именованный аргумент не содержит двойное подчеркивание – будет использован фильтр exact.

Например, эти два выражения идентичны:

>>> Blog.objects.get(id__exact=14)  # Explicit form
>>> Blog.objects.get(id=14)         # __exact is implied

Это сделано для удобства, т.к. exact самый распространенный фильтр.

iexact

Регистро-независимый совпадение. Такой запрос:

>>> Blog.objects.get(name__iexact="beatles blog")

Найдет Blog с названием “Beatles Blog”, “beatles blog”, и даже “BeAtlES blOG”.

contains

Регистро-зависимая проверка на вхождение. Например:

Entry.objects.get(headline__contains='Lennon')

Будет конвертировано в такой SQL запрос:

SELECT ... WHERE headline LIKE '%Lennon%';

Заметим что этот пример найдет заголовок ‘Today Lennon honored’, но не найдет ‘today lennon honored’.

Существует так же регистро-независимые версии, icontains.

startswith, endswith

Поиск по началу и окончанию соответственно. Существуют также регистро-независимые версии istartswith и iendswith.

Это только основные фильтры. Полный список ищите в разделе о фильтрах по полям.

Фильтры по связанным объектам

Django предлагает удобный и понятный интерфейс для фильтрации по связанным объектам, самостоятельно заботясь о JOIN в SQL. Для фильтра по полю из связанных моделей, используйте имена связывающих полей разделенных двойным нижним подчеркиванием, пока вы не достигните нужного поля.

Этот пример получает все объекты Entry с Blog, name которого равен ‘Beatles Blog’:

>>> Entry.objects.filter(blog__name__exact='Beatles Blog')

Этот поиск может быть столь глубоким, как вам будет угодно.

Все работает и в другую сторону. Что бы обратиться к “обратной” связи, просто используйте имя модели в нижнем регистре.

Этот пример получает все объект Blog, которые имеют хотя бы один связанный объект Entry с headline содержащим ‘Lennon’:

>>> Blog. objects.filter(entry__headline__contains='Lennon')

Если вы используйте фильтр через несколько связей и одна из промежуточных моделей не содержит подходящей связи, Django расценит это как пустое значение (все значения равны NULL). Исключение не будет вызвано. Например, в этом фильтре:

Blog.objects.filter(entry__authors__name='Lennon')

(при связанной модели Author), если нет объекта author связанного с entry, это будет расценено как отсутствие name, вместо вызова исключения т.к. author отсутствует. В большинстве случаев это то, что вам нужно. Единственный случай, когда это может работать не однозначно — при использовании isnull. Например:

Blog.objects.filter(entry__authors__name__isnull=True)

вернет объекты Blog у которого пустое поле name у author и также объекты, у которых пустой author«в  «entry. Если вы не хотите включать вторые объекты, используйте:

Blog.objects.filter(entry__authors__isnull=False,
        entry__authors__name__isnull=True)

Фильтрация по связям много-ко-многим

Когда вы используете фильтрация по связанным через ManyToManyField объектам или по обратной связи для ForeignKey, может быть два вида фильтров. Рассмотрим свзять Blog/Entry (от Blog к Entry – это связь один-ко-многим). Нам может понадобиться получить блоги с записями, у которых заголовок содержит “Lennon” и которые были опубликованы в 2008. Или нам могут понадобиться блоги с записями с “Lennon” в заголовке и в то же время блоги с записями опубликованными до 2008. Т.к. один Blog может иметь несколько связанных Entry, оба варианта возможны.

Аналогичная ситуация и с ManyToManyField. Например, если Entry имеет ManyToManyField названное tags, нам могут понадобиться записи связанные с тегами “music” и “bands” или нам может понадобиться запись содержащая тег “music” и статусом “public”.

Что бы обеспечить оба варианта, Django использует определенные правила для вызовов filter() и exclude(). Все, что в одном вызове filter(), применяется одновременно, чтобы отфильтровать все объекты, соответствующие этим параметрам фильтрации. Успешные вызовы filter() каждый раз сокращают выборку объектов, но для множественных связей, они применяются каждый раз ко всем связанным объектам, а не только к объектам отфильтрованным предыдущим вызовом filter().

Звучит немного непонятно, но пример должен все прояснить. Для выбора всех блогов, содержащих записи и с “Lennon” в заголовке и опубликованные в 2008 (запись должна удовлетворять оба условия), мы будем использовать такой код:

Blog.objects.filter(entry__headline__contains='Lennon',
        entry__pub_date__year=2008)

Для выбора блогов с записями, у которых заголовок содержит “Lennon”, а так же с записями опубликованными в 2008, мы напишем:

Blog.objects.filter(entry__headline__contains='Lennon').filter(
        entry__pub_date__year=2008)

Предположим существует только один блог и в нем есть записи со словом “Lennon” и записи 2008-го года, но ни одна запись 2008-го не содержит слово “Lennon”. Первый запрос вернет пустой ответ, второй запрос — один блог.

В это примере, первый фильтр ограничит выборку блогами со связанными записями содержащими “Lennon” в заголовке. Второй фильтр ограничит выборку блогами с записями опубликованными в 2008. Записи выбранные вторым фильтром могут быть такими же как и из первого фильтра, а могут и не быть. Мы фильтруем объекты Blog с каждым вызовом filter(), а не объекты Entry.

Все эти правила так же распространяются и на exclude(): все условия в одном exclude() применяются к одному объекту (если это условия относятся к одной связи). Условия в последующих вызовах filter() или exclude() с условия для одной связи могут применяться к различным связанным объектам.

Фильтры могут ссылаться на поля на модели

class F

В примерах выше мы использовали фильтры, которые приравнивали поля к определенным значениям(константам). Но что, если вы хотите сравнить одно поле с другим полем одной модели?

Django предоставляет объект F() для таких сравнений. Экземпляр F() рассматривается как ссылка на другое поле модели. Эти ссылки могут быть использованы для сравнения значений двух разных полей одного объекта модели.

Например, что бы выбрать все записи, у которых количество комментариев больше, чем “pingback”, мы создаем объект F() с ссылкой на поле “pingback”, и использовать этот объект F() в запросе:

>>> from django.db.models import F
>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks'))

Django поддерживает операции суммирования, вычитания, умножения, деления и арифметический модуль для объектов F(), с константами или другими объектами F(). Что бы найти все записи с количеством комментариев в два раза больше чем “pingbacks”, используем такой запрос:

>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks') * 2)

Что бы найти все записи с рейтингом ниже суммы “pingback” и количества комментариев, необходимо выполнить такой запрос:

>>> Entry.objects.filter(rating__lt=F('n_comments') + F('n_pingbacks'))

Вы можете использовать два нижних подчеркивания для использования полей связанных объектов в F(). Объект F() с двойным нижним подчеркиванием обеспечит все необходимые JOIN для получения необходимых связанных объектов. Например, что бы получить все записи, у которых имя автора совпадает с названием блога, нужно выполнить такой запрос:

>>> Entry.objects.filter(authors__name=F('blog__name'))

Для полей даты и времени вы можете использовать сумму или разницу объектов timedelta. Этот код вернет все записи, которые были отредактированы через 3 дня после публикации:

>>> from datetime import timedelta
>>> Entry.objects.filter(mod_date__gt=F('pub_date') + timedelta(days=3))

Объект F() теперь позволяет использовать битовые операции .bitand() и .bitor(), например:

>>> F('somefield').bitand(16)

“Shortcut” для фильтрации по первичному ключу

Для удобства, Django предоставляет специальный фильтр pk для работы с первичным ключом.

Например, первичный ключ модели Blog – поле id. Эти три запроса идентичны:

>>> Blog.objects.get(id__exact=14) # Explicit form
>>> Blog.objects.get(id=14) # __exact is implied
>>> Blog.objects.get(pk=14) # pk implies id__exact

Использование pk не ограничено только фильтром __exact – любой фильтр может быть использован с pk:

# Get blogs entries with id 1, 4 and 7
>>> Blog.objects.filter(pk__in=[1,4,7])

# Get all blog entries with id > 14
>>> Blog.objects.filter(pk__gt=14)

pk работает так же и для связей. Например, эти три запроса идентичны:

>>> Entry.objects.filter(blog__id__exact=3) # Explicit form
>>> Entry.objects.filter(blog__id=3)        # __exact is implied
>>> Entry.objects.filter(blog__pk=3)        # __pk implies __id__exact

Экранирование знака процента и нижнего подчеркивания для оператора LIKE

Фильтры, эквивалентые оператору LIKE в SQL(iexact, contains, icontains, startswith, istartswith, endswith и iendswith), автоматически экранируют два символа используемых оператором LIKE – знак процента и нижнего подчеркивания. (В операторе LIKE, знак процента означает “wildcard” из нескольких символов, нижнего подчеркивания — одно-символьный “wildcard”.)

Это делает работу с API интуитивно-понятной. Например, что бы получить все записи со знаком процента, просто используйте символ знака процента как любой другой символ:

>>> Entry.objects.filter(headline__contains='%')

Django самостоятельно позаботится об экранировании; полученный SQL будет выглядеть приблизительно вот так:

SELECT ... WHERE headline LIKE '%\%%';

Так же работает и символ нижнего подчеркивания. Оба, знак процента и нижнего подчеркивания, обрабатываются автоматически, прозрачно для вас.

Кеширование и QuerySets

Каждый QuerySet содержит кеш, для уменьшения количества запросов. Очень важно знать как он работает, для эффективного использования Django.

В только что созданном QuerySet кеш пустой. После вычисления QuerySet – и будет выполнен запрос к базе данных – Django сохраняет результат запроса в кеше QuerySet и возвращает необходимый результат (например, следующий элемент при итерации по QuerySet). Последующие вычисления QuerySet используют кеш.

Помните о кешировании, что бы использовать QuerySet правильно. Например, этот код создаст два экземпляра QuerySet и вычислит их не сохраняя:

>>> print([e.headline for e in Entry.objects.all()])
>>> print([e.pub_date for e in Entry.objects.all()])

Это означает, что один и тот же запрос будет выполнен дважды, удваивая нагрузку на базу данных. Также, есть вероятность, что списки могут содержать разные результаты, потому что запись Entry может быть добавлена или удалена в доли секунды между запросами.

Что бы избежать этой проблемы, просто сохраните QuerySet и используйте его повторно:

>>> queryset = Entry.objects.all()
>>> print([p.headline for p in queryset]) # Evaluate the query set.
>>> print([p.pub_date for p in queryset]) # Re-use the cache from the evaluation.

Когда querysets не кешируется

Queryset не всегда кеширует результаты. При выполнении только части queryset-а, кеш проверяется, но если кеш пустой, выполняется запрос без сохранения его результата в кеш. Это значит, что ограничение выборки используя индекс или срез, как при использовании списков, не заполнит кеш.

Например, при получении объекта по индеку несколько раз будет каждый раз выполнять запрос к базе данных:

>>> queryset = Entry.objects.all()
>>> print queryset[5] # Queries the database
>>> print queryset[5] # Queries the database again

Однако, если уже был загружен весь queryset, он будет использоваться для получения значения:

>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset] # Queries the database
>>> print queryset[5] # Uses cache
>>> print queryset[5] # Uses cache

Еще несколько примеров, когда загружается весь queryset и результат сохраняется в кеше:

>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

Примечание

Используование print с queryset не заполнит кеш т.к. будет вызыван __repr__(), который показывает только часть объектов.

Сложные запросы с помощью объектов Q

class Q

Именованные аргументы функции filter() и др. – объединяются оператором “AND”. Если вам нужны более сложные запросы (например, запросы с оператором OR), вы можете использовать объекты Q.

Объект Q`) – объект, используемый для инкапсуляции множества именованных аргументов для фильтрации. Аргументы определяются так же как и в примерах выше.

Например, этот объект Q определяет запрос LIKE:

from django.db.models import Q
Q(question__startswith='What')

Объекты Q могут быть объединены операторами & и |, при этом будет создан новый объект Q.

Например, это определение представляет объект Q, который представляет операцию “OR” двух фильтров с «question__startswith»:

Q(question__startswith='Who') | Q(question__startswith='What')

Этот фильтр равнозначен такому оператору SQL WHERE:

WHERE question LIKE 'Who%' OR question LIKE 'What%'

Вы можете комбинировать различные объекты Q с операторами & и | и использовать скобки. Можно использовать оператор ~ для отрицания(NOT) в запросе:

Q(question__startswith='Who') | ~Q(pub_date__year=2005)

Каждый метод для фильтрации, который принимает именованные аргументы (например, filter(), exclude(), get()get()) так же может принимать объекты Q. Если вы передадите несколько объектов Q как аргументы, они будут объединены оператором “AND”. Например:

Poll.objects.get(
    Q(question__startswith='Who'),
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)

… примерно переводится в SQL:

SELECT * from polls WHERE question LIKE 'Who%'
    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

Вы можете использовать одновременно объекты Q и именованные аргументы. Все аргументы(будь то именованные аргументы или объекты Q) объединяются оператором “AND”. Однако, если присутствует объект Q, он должен следовать перед именованными аргументами. Например:

Poll.objects.get(
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
    question__startswith='Who')

… правильный запрос, идентичный предыдущему примеру; но:

# INVALID QUERY
Poll.objects.get(
    question__startswith='Who',
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

… будет не правильный`(Вообще Django здесь не причем. Синтаксис Python не позволяет передавать именованные аргументы перед позиционными – прим. переводчика)`.

Удаление объектов

Метод удаления соответственно называется delete(). Этот метод сразу удаляет объект и ничего не возвращает. Например:

Можно так же удалить несколько объектов сразу. Каждый QuerySet имеет метод delete(), который удаляет все объекты из QuerySet.

Например, этот код удаляет все объекты Entry у годом pub_date равным 2005:

Entry.objects.filter(pub_date__year=2005).delete()

Учтите, что при любой возможности будет использован непосредственно SQL запрос, то есть метод delete() объекта может и не использоваться при удалении. Если вы переопределяете метод delete() модели и хотите быть уверенным, что он будет вызван, вы должны “самостоятельно” удалить объект модели (например, использовать цикл по QuerySet и вызывать метод delete() для каждого объекта) не используя метод delete() QuerySet.

При удалении Django повторяет поведение SQL выражения ON DELETE CASCADE – другими словами, каждый объект, имеющий связь(ForeignKey) с удаляемым объектом, будет так же удален. Например:

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()

Это поведение можно изменить определив аргумент on_delete поля ForeignKey.

Метод delete() содержится только в QuerySet и не существует в Manager. Это сделано, что бы вы случайно не выполнили Entry.objects.delete(), и не удалили все записи. Если вы на самом деле хотите удалить все объекты, сначала явно получите QuerySet содержащий все записи:

Entry.objects.all().delete()

Изменение нескольких объектов

Если вам понадобиться установить значение поля для всех объектов в QuerySet, используйте метод update(). Например:

# Update all the headlines with pub_date in 2007.
Entry.objects.filter(pub_date__year=2007).update(headline='Everything is the same')

Вы можете изменить только обычные поля или ForeignKey используя этот метод. Для обычным полей просто определите новое значение как константу. Что бы обновить ForeignKey, укажите объект связанной модели. Например:

>>> b = Blog.objects.get(pk=1)

# Change every Entry so that it belongs to this Blog.
>>> Entry.objects.all().update(blog=b)

Метод update() применяется мгновенно и возвращает количество записей удовлетворяющих запросу(что может быть не равно колиству обновленных записей, если они уже содержат новые значения). Единственное ограничение для изменяемого QuerySet – он может изменять только главную таблицу модели. Вы можете использовать фильтры по связанным полям, но вы можете изменять поля только таблицы изменяемой модели. Например:

>>> b = Blog.objects.get(pk=1)

# Update all the headlines belonging to this Blog.
>>> Entry.objects.select_related().filter(blog=b).update(headline='Everything is the same')

Учтите, что метод update() использует непосредственно SQL запрос. Это операция для массового изменения. Метод save() модели не будет вызван, сигналы pre_save или post_save не будут вызваны (которые являются следствием вызова save()), аргумент auto_now не будет учтен. Если вы хотите сохранить каждый объект в QuerySet и удостовериться что метод save() вызван для каждого объекта, вы не должны использовать какой-либо специальный метод. Просто используйте цикл и вызовите метод save():

for item in my_queryset:
    item.save()

Метод update() может использовать объект F() для обновления одного поля значением другого поля модели. Это особенно полезно для изменения счетчика. Например, например увеличить значение n_pingbacks на один для каждой записи:

>>> Entry.objects.all().update(n_pingbacks=F('n_pingbacks') + 1)

Однако, в отличии от использования объектов F() в методах filter() и exclude(), вы не можете использовать связанные поля при обновлении. Если вы будете использовать связанное поле в объекте F(), буде вызвано исключение FieldError:

# THIS WILL RAISE A FieldError
>>> Entry.objects.update(headline=F('blog__name'))

Связанные объекты

Используя связанные объекты в модели (например, ForeignKey, OneToOneField или ManyToManyField), в объект модели будет добавлен API для работы со связанными объектами.

Используя модели из примеров выше, например, объект e модели Entry может получить связанные объекты Blog используя атрибут blog: e.blog.

(Это все работает благодаря дескрипторам Python. Это совсем не важно и упоминается для любознательных.)

Django так же предоставляет доступ к связанным объектам с “другой” стороны – ссылка с связанного объекта на объект, который определяет связь. Например, объект b модели Blog имеет доступ ко всем связанным объектам Entry через атрибут entry_set: b.entry_set.all().

Все примеры в этом разделе используют вышеупомянутые модели Blog, Author и Entry.

Связь один-к-одному

Прямая

Если модель содержит ForeignKey, объект этой модели может получить связанный объект через атрибут модели.

Например:

>>> e = Entry.objects.get(id=2)
>>> e.blog # Returns the related Blog object.

Вы можете получить и изменить его через атрибут внешнего ключа. Как вы можете предполагать, изменения не будут сохранены в базу данных пока не будет вызван метод meth:~django.db.models.Model.save. Например:

>>> e = Entry.objects.get(id=2)
>>> e.blog = some_blog
>>> e.save()

Если поле ForeignKey содержит null=True (то есть разрешено значение NULL), вы можете указать None для этого поля. Например:

>>> e = Entry.objects.get(id=2)
>>> e.blog = None
>>> e.save() # "UPDATE blog_entry SET blog_id = NULL ...;"

Прямой доступ для связи один-ко-многим кеширует полученное значение при первом обращении. Последующие обращения к внешнему ключу этого же объекта будут использовать кешированое значение. Например:

>>> e = Entry.objects.get(id=2)
>>> print(e.blog)  # Hits the database to retrieve the associated Blog.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

Запомните, что вызов метода select_related() QuerySet рекурсивно заполняет кеш значениями для всех связей один-ко-многим. Например:

>>> e = Entry.objects.select_related().get(id=2)
>>> print(e.blog)  # Doesn't hit the database; uses cached version.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

“Обратная” связь

Если модель содержит Manager, который вернет все связанные объекты первой модели. По-умолчанию, этот Manager называется FOO_set, где FOO названием основной модели в нижнем регистре. Этот Manager возвращает QuerySets, который может быть отфильтрован и изменен как было описано в разделе “Получение объектов”.

Например:

>>> b = Blog.objects.get(id=1)
>>> b.entry_set.all() # Returns all Entry objects related to Blog.

# b.entry_set is a Manager that returns QuerySets.
>>> b.entry_set.filter(headline__contains='Lennon')
>>> b.entry_set.count()

Вы можете переопределить название FOO_set установив параметр related_name при определении ForeignKey(). Например, если бы модель Entry содержала blog = ForeignKey(Blog, related_name=’entries’), пример выше выглядел бы как:

>>> b = Blog.objects.get(id=1)
>>> b.entries.all() # Returns all Entry objects related to Blog.

# b.entries is a Manager that returns QuerySets.
>>> b.entries.filter(headline__contains='Lennon')
>>> b.entries.count()

Вы не можете обращаться к “обратному” менеджеру через класс модели; вы должны использовать экземпляр модели:

>>> Blog.entry_set
Traceback:
    ...
AttributeError: "Manager must be accessed via instance".

В дополнение к методам QuerySet описанным в разделе “Получение объектов”, “обратный” менеджер ForeignKey содержит дополнительные методы для работы со связанными объектами. Краткий список находится ниже, полное описание смотрите в разделе о связанных объектах.

add(obj1, obj2, …)

Добавляет указанный объект к связанным объектам.

create(**kwargs)

Создает новый объект, сохраняет его и добавляет к связанным объектам. Возвращает созданный объект.

remove(obj1, obj2, …)

Удаляет указанный объект из списка связанных объектов.

clear()

Удаляет все объекты из списка связанных.

Что бы добавить несколько связанных объектов одним махом, просто установите любой итератор. Итератор должен содержать объекты или просто значения первичных ключей. Например:

b = Blog.objects.get(id=1)
b.entry_set = [e1, e2]

В этом примере, e1 и e2 могут быть экземплярами Entry, или значениями первичного ключа.

Если доступен метод clear(), все связанные объекты будут удаленны из entry_set перед тем, как все объекты из итератора(в примере это список) будут добавлены в список связанных объектов. Если метод clear() не доступен, все объекты из итератора будут добавлены без удаления существующих объектов.

Все вышеупомянутые методы сохраняют результат в базу. Каждое добавление, создание или удаление сразу и автоматически выполняет соответствующий запрос в базу данных.

Связь много-ко-многим

Обе “стороны” связи многое-ко-многим автоматически получает API для работы со связанными объектами. Этот API работает так же, как и “обратный” менеджер для связи один-ко-многим описанный выше.

Единственное отличие: Модель содержащая ManyToManyField использует имя атрибута этого поля, в то время, как “обратная” модель использует название состоящее из названия модели в нижнем регистре плюс ‘_set’ (так же как и для связи один-ко-многим).

Пример все разъяснит:

e = Entry.objects.get(id=3)
e.authors.all() # Returns all Author objects for this Entry.
e.authors.count()
e.authors.filter(name__contains='John')

a = Author.objects.get(id=5)
a.entry_set.all() # Returns all Entry objects for this Author.

Так же как и ForeignKey, ManyToManyField позволяет определить related_name. В примере выше, если поле ManyToManyField модели Entry содержит related_name=’entries’, тогда каждый объект модели Author будет с атрибутом entries вместо entry_set.

Связь один-к-одному

Связь один-к-одному похожа на связь многое-к-одному. При добавлении OneToOneField в модель, объект этой модели будет содержать ссылку на связанный объект через атрибут модели.

Например:

class EntryDetail(models.Model):
    entry = models.OneToOneField(Entry)
    details = models.TextField()

ed = EntryDetail.objects.get(id=2)
ed.entry # Returns the related Entry object.

Разница в обратной связи. Связанная модель так же имеет доступ к объекту Manager, но Manager представляет один объект, а не множество объектов:

e = Entry.objects.get(id=2)
e.entrydetail # returns the related EntryDetail object

Если ни один объект не добавлен в связь, Django вызовет исключение DoesNotExist.

Объект может быть назначен через обратную связь так же как и через прямую:

Как работает обратная связь?

Другие ORM требуют определять связь с обоих сторон. Разработчики Django считают, что это противоречит принципу DRY (Don’t Repeat Yourself — не повторяй себя), по этому Django требует определить связь только для одной модели.

Но как это возможно, учитывая, что модель не знает, какие другие модели связаны с ним, пока классы этих моделей не будут загружены?

Суть ответа в настройке INSTALLED_APPS. При загрузке любой модели в первый раз, Django перебирает все модели из приложений в INSTALLED_APPS и создает обратные связи для каждой модели.По сути, это одна из функций INSTALLED_APPS – определить все используемые модели для Django.

перевод на английский, синонимы, антонимы, примеры предложений, значение, словосочетания

Что означает двойное подчеркивание ( __константный) означает в C?

В C, символы, начинающиеся с подчеркивания, за которым следует либо заглавными буквами или другого подчеркивания зарезервированы для реализации. Вас как пользователя C не должны создавать каких-либо символов, которая начинается с зарезервированного последовательности. В C++, это ограничение является более жестким; вы не можете создать символ, содержащие двойное подчеркивание.

Дано:

На страницах__константный есть возможность (пусть и маловероятного), что компилятор, что этот код используется с поддержкой прототипа нотаций, но не имеет правильного понимания стандарта С89 ключевое слово const. Макросы версию autoconf все-таки можно проверить, является ли компилятор работает поддержка как const; этот код может быть использован с разбитым компилятора, которые не имеют такой поддержки.

Использование __имя и __адрес является мерой защиты для вас, пользователь заголовка. При компиляции с помощью GCC и -Wshadow опция, то компилятор будет предупреждать вас, когда все локальные переменные тень глобальной переменной. Если функция используется толькоимявместо__имя хоста, и если у вас функция под названиемИмя хоста()`, там’d быть собой слежку. Используя имена зарезервированы для реализации, нет никакого конфликта с вашим законным кодом.

Использование __бросайте означает, что код может, при некоторых обстоятельствах, может быть объявлен какой-то 'бросок спецификация'. Это не стандарт C; он больше похож на C++. Но код может быть использован компилятором с тех пор, пока один из заголовков (или сам компилятор) определяет__забросить в пустые, или с некоторыми компиляторами продление стандартный синтаксис c++.

<ч>

Раздел 7.1.3 из стандарта C (стандарт ISO 9899:1999) говорит:

7.1.3 зарезервированные идентификаторы

каждый заголовок провозглашает и определяет все идентификаторы, перечисленные в соответствующем разделе, и дополнительно провозглашает и определяет идентификаторы, перечисленные в соответствующем будущие направления деятельности библиотеки раздел и идентификаторы, которые всегда зарезервированы для любого использования или для использования в качестве файл область действия идентификаторов.

— все идентификаторы, начинающиеся с символа подчеркивания и прописной буквы или другой подчеркиваем, всегда зарезервированы для любого использования.

— все идентификаторы, начинающиеся с подчеркивания, резервируются для использования в качестве идентификаторов с области файла в обычным и имя тега пробелы.

— каждое имя макроса в любом из следующих подпунктов (в том числе будущей библиотеки направления) зарезервирован для использования, как указано, если любой из связанных с ним заголовки включен; если явно не указано иное (см. 7.1.4).

— все идентификаторы с внешней компоновкой в одном из следующих подпунктов (в том числе будущие направления библиотека) всегда зарезервированы для использования в качестве идентификаторов с внешними связь.<суп>154)</SUP и ГТ;

— каждый идентификатор с файл рамки указанные в одном из следующих подпунктов (в том числе будущие направления библиотека) предназначена для использования в качестве имени макроса и как идентификатор с объем файла в том же пространстве имен, если любой из связанных с ним заголовки включены.

никаких других идентификаторов зарезервированы. Если программа заявляет или определяет идентификатор в контекст, в котором оно зарезервировано (кроме как разрешенных 7.1.4), или определяет защищены идентификатор как имя макроса, поведение неопределено.

если программа удаляет (с #фдоон) любой макрос определение идентификатора в первом группы, перечисленные выше, поведение неопределено.

сноска 154) список зарезервированных идентификаторов внешних связей включает в себя ошибка, math_errhandling, команду setjmp и помощью va_end.

<ч>

См. также каковы правила об использовании знака подчеркивания в C++ идентификатор; те же правила действуют в обоих C и C++, хотя встроенные двойные подчеркивания правило в C++ только, как указано в верхней части этого ответа.

Что означает одиночное и двойное подчеркивание перед именем объекта?

Одно подчеркивание в начале:

Python не имеет реальных частных методов. Вместо этого, одно подчеркивание в начале имени метода или атрибута означает, что вы не должны обращаться к этому методу, потому что он не является частью API.

class BaseForm(StrAndUnicode):

    def _get_errors(self):
        "Returns an ErrorDict for the data provided for the form"
        if self._errors is None:
            self.full_clean()
        return self._errors

    errors = property(_get_errors)

(Этот фрагмент кода был взят из исходного кода django: django / forms / forms.py). В этом коде errorsэто открытое свойство, но метод, который вызывает это свойство, _get_errors, является «частным», поэтому вы не должны обращаться к нему.

Два подчеркивания в начале:

Это вызывает много путаницы. Он не должен использоваться для создания частного метода. Он должен использоваться, чтобы избежать переопределения вашего метода подклассом или случайного доступа. Давайте посмотрим на пример:

class A(object):
    def __test(self):
        print "I'm a test method in class A"

    def test(self):
        self.__test()

a = A()
a.test()
# a.__test() # This fails with an AttributeError
a._A__test() # Works! We can access the mangled name directly!

Вывод:

$ python test.py
I'm test method in class A
I'm test method in class A

Теперь создайте подкласс B и выполните настройку для метода __test.

class B(A):
    def __test(self):
        print "I'm test method in class B"

b = B()
b.test()

Выходной будет ….

$ python test.py
I'm test method in class A

Как мы уже видели, A.test () не вызывал методы B .__ test (), как мы могли ожидать. Но на самом деле это правильное поведение для __. Два метода с именем __test () автоматически переименовываются (искажаются) в _A__test () и _B__test (), поэтому они не переопределяются случайно. Когда вы создаете метод, начинающийся с __, это означает, что вы не хотите, чтобы кто-либо мог его переопределить, и вы намереваетесь получить к нему доступ только из его собственного класса.

Два подчеркивания в начале и в конце:

Когда мы видим такой метод __this__, не вызывайте его. Это метод, который Python должен вызывать, а не вы. Давайте взглянем:

>>> name = "test string"
>>> name.__len__()
11
>>> len(name)
11

>>> number = 10
>>> number.__add__(40)
50
>>> number + 50
60

Всегда есть оператор или нативная функция, которая вызывает эти магические методы. Иногда это просто зацепка вызовов Python в определенных ситуациях. Например, __init__()вызывается при создании объекта после __new__()вызова для создания экземпляра …

Давайте возьмем пример …

class FalseCalculator(object):

    def __init__(self, number):
        self.number = number

    def __add__(self, number):
        return self.number - number

    def __sub__(self, number):
        return self.number + number

number = FalseCalculator(20)
print number + 10      # 10
print number - 20      # 40

Для получения дополнительной информации см. Руководство PEP-8 . Дополнительные магические методы смотрите в этом PDF .

Почему некоторые функции подчеркивают «__» до и после имени функции?

Добавлен пример, чтобы понять использование __ в python. Вот список всех __

https://docs.python.org/3/genindex-all.html#_

Определенные классы идентификаторов (помимо ключевых слов) имеют особое значение. Любое использование имен * в любом другом контексте, которое не следует явно задокументированному использованию, может быть прервано без предупреждения

Ограничение доступа с помощью __

"""
Identifiers:
-  Contain only (A-z, 0-9, and _ )
-  Start with a lowercase letter or _.
-  Single leading _ :  private
-  Double leading __ :  strong private
-  Start & End  __ : Language defined Special Name of Object/ Method
-  Class names start with an uppercase letter.
-

"""


class BankAccount(object):
    def __init__(self, name, money, password):
        self.name = name            # Public
        self._money = money         # Private : Package Level
        self.__password = password  # Super Private

    def earn_money(self, amount):
        self._money += amount
        print("Salary Received: ", amount, " Updated Balance is: ", self._money)

    def withdraw_money(self, amount):
        self._money -= amount
        print("Money Withdraw: ", amount, " Updated Balance is: ", self._money)

    def show_balance(self):
        print(" Current Balance is: ", self._money)


account = BankAccount("Hitesh", 1000, "PWD")  # Object Initalization

# Method Call
account.earn_money(100)

# Show Balance
print(account.show_balance())

print("PUBLIC ACCESS:", account.name)  # Public Access

# account._money is accessible because it is only hidden by convention
print("PROTECTED ACCESS:", account._money)  # Protected Access

# account.__password will throw error but account._BankAccount__password will not
# because __password is super private
print("PRIVATE ACCESS:", account._BankAccount__password)

# Method Call
account.withdraw_money(200)

# Show Balance
print(account.show_balance())

# account._money is accessible because it is only hidden by convention
print(account._money)  # Protected Access

Как убрать или сделать подчёркивание в Word

В Word можно подчеркнуть надписи, пробелы, знаки табуляции. Доступны разные виды линий: волнистые, прямые, двойные. Ещё есть разделители страниц, таблицы. Красными, зелёными и синими «волнами» программа выделяет ошибки и неправильно оформленный текст. Чтобы пользоваться данным инструментарием, разберитесь, как добавить эти линии, как изменить их атрибуты и как убрать подчёркивание в Word, если его нельзя выделить.

В редакторе Word есть несколько способов подчеркивания текста. О них мы расскажем ниже.

Простое подчёркивание

Сделать полоску под надписью можно так:

1. Выделите фрагмент.
2. На главной панели меню найдите букву «Ч» с чёрточкой под ней. Или нажмите Ctrl+U. Избавиться от линии можно этим же сочетанием клавиш.
3. Чтобы печатать уже с полосками, кликните на значок «Ч», напишите что-то, и снова кликните на «Ч».

Сама операция достаточно проста. Но так можно добавить только обычную черту. Вот как подчеркнуть текст в Word, если вам хочется использовать разные виды и цвета полосок:

1. Выделите фрагмент.
2. Нажмите маленькую стрелочку рядом с буквой «Ч».
3. В выпавшем списке выберите расцветку и тип: двойная линия, штриховая, толстая, волнистая.

Чтобы создать полоску, которая будет оставаться на месте, пока над ней печатают текст, нужно сделать следующее:

1. Через раздел «Таблицы» (или Вставка — Таблицы, если у вас Word 2007) добавьте сетку.
2. Напишите в ней пару слов.
3. Кликните по рамке правой кнопкой мыши.
4. «Границы и заливка».
5. Откроются параметры. Справа будет область, в которой есть настройки видимости границ. Оставьте только нижнюю линию. Она останется на месте, даже если вы удалите текст.
6. В этом же меню выберите тип и толщину полоски.

Можно сделать проще:

1. После добавления сетки вверху окна появится раздел «Работа с таблицами». В нём перейдите во вкладку «Конструктор».
2. Нажмите стрелку рядом с «Границы».
3. Оставьте активной только опцию «Нижняя граница».

Такие полоски нужны при работе с HTML-документами. Этот приём подходит для создания полей ввода и веб-форм.

Если вы хотите добавить линии исключительно надписям, не задевая пробелов, необязательно настраивать оформления каждого предлога. Вот как подчеркнуть слово в Word:

1. Выделите текст.
2. Кликните на чёрную стрелочку рядом с буквой «Ч».
3. Пункт «Другие».
4. В поле «Подчёркивание» выберите «Только слово».

Подчёркивание пробелов

Иногда нужно, чтобы линии находились под пробелами. Например, если вы готовите к печати документ, в котором должно быть место для ввода имени, фамилии или других данных. Для этого подойдут таблицы (взаимодействие с ними описано выше). Но есть и другие способы. Вот как сделать подчёркивание в Word без слов:

1. Самый простой метод — нажмите Shift+[-] (дефис; без скобок). Появится линия. Это не часть оформления, а символ. К нему применимы все настройки шрифта.
2. Чтобы изменить цвет полоски, найдите на панели меню кнопку с пиктограммой в виде буквы «А». Нажмите на стрелочку рядом с ней — откроется палитра.

Нижнее подчёркивание не всегда подходит для оформления. Над ним нельзя печатать — он будет сдвигаться. Его сложно выровнять по ширине абзаца. Если у вас активирована автозамена, три линии подряд автоматически превратятся в границу.

В Word можно добавить полосы к знакам табуляции. Их разметку легче настроить.

1. Нажмите клавишу «TAB». Она находится над кнопкой Caps Look. Курсор Word сдвинется.
2. Лучше активировать отображение скрытых символов, чтобы видеть знаки табуляции, а не только набор слов. Для этого кликните на панели инструментов на иконку, похожую на букву «П» (кнопка называется «Абзац»). Или нажмите Ctrl+Shift+* (звёздочка). Табуляция в Word выглядит как стрелочка, указывающая вправо.
3. Выделите её.
4. Нажмите Ctrl+U.

Печатать над такими линиями тоже не получится. Но они гораздо шире пробелов — с ними будет легче выровнять строку.

Границы страниц

Если в Word ввести три звёздочки или три дефиса подряд, они могут стать горизонтальной линией (иногда для этого надо нажать Enter). Это автозамена превращает их в границу страницы. Чтобы создать определённый вид такой линии, надо сделать так:

• Введите три знака равенства (=), чтобы создать двойную полосу.
• Три звёздочки (*) — пунктирную.
• Три дефиса (-) — простую.
• Три нижних пробела (_) — жирную.

Данные границы похожи на обычное подчёркивание. Они занимают всю строку. Их нельзя выделить или отредактировать. Но над ними можно печатать.

Вот как убрать подобную линию:

1. Поставьте курсор Word в начало строки с полоской.
2. Нажмите Delete.

Если этот способ не поможет, лучше сделать так:

1. Раздел «Разметка страницы». Он находится в строке меню наверху окна.
2. Кнопка «Границы страниц».
3. В поле «Тип» задайте параметр «Нет». Горизонтальная линия пропадёт.

Красное, зелёное и синее подчёркивание — проверка орфографии

В Word есть функция проверки орфографии. Она отмечает волнистыми линиями ошибки орфографии, пунктуации, стилистики. С ней легче заметить случайную опечатку, проверить текст, найти какие-то недоработки. Ниже указано, что означает каждая полоса.

• Красная. Неправильно написано слово, или его нет в базе данных Office. Красным цветом также обозначаются повторы.
• Зелёная. Ошибки с грамматикой, стилистикой, пунктуацией. Лишние скобки. Несогласованный текст.
• Синяя. Несоответствие формата.

Обычно эта функция приносит пользу. Но если вы правильно всё написали, то внезапно появившиеся волнистые линии будут раздражать и мешать. Как убрать подчёркивание в Word, если оно поставлено автоматически при проверке орфографии:

1. Кликните правой кнопкой мыши на фрагмент, под которым появилась волнистая линия.
2. Чтобы избавиться от неё, выберите пункт «Пропустить».
3. Чтобы Word запомнил выбранное слово и записал его в свой словарь, нажмите «Добавить».

Если вы хотите совсем отключить проверку, откройте настройки:

1. Перейдите в меню Сервис — Правописание (в Word 2007 для этого надо нажать на логотип Office в левом верхнем углу и в выпавшем списке выбрать «Параметры»).
2. Уберите галочку в «Автоматически проверять орфографию» или отметьте «Скрыть ошибки только в этом документе». Автопроверка перестанет вам докучать. Но искать опечатки будет сложнее.

В инструментарии Word найдутся разнообразные типы линий, чтобы подчеркнуть текст или нарисовать горизонтальную полосу. Используйте эти функции, чтобы оформлять документы.

Что означает одинарное и двойное подчеркивание перед именем объекта?

подчеркивание ( _ ) в Python

ниже приведены различные места, где _ используется в Python:

Один Подчеркнуть:

• Переводчик
• название
• перед названием

двойная Подчеркивание:

Переводчик:

_ возвращает значение последнего выполненного значения выражения в Python REPL

>>> a = 10
>>> b = 10
>>> _
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_' is not defined
>>> a+b
20
>>> _
20
>>> _ * 2
40
>>> _
40
>>> _ / 2
20

для игнорирования значений:

несколько раз мы не хотите, чтобы возвращаемые значения в это время присваивали эти значения wnderscore. Он используется в качестве одноразовой переменной.

# Ignore a value of specific location/index
for _ in rang(10)
    print "Test"

# Ignore a value when unpacking
a,b,_,_ = my_method(var1)

название

Python имеет свои ключевые слова по умолчанию, которые мы не можем использовать в качестве имени переменной. Чтобы избежать такого конфликта между ключевым словом python и переменной, мы используем подчеркивание после имени

пример:

>>> class MyClass():
...     def __init__(self):
...             print "OWK"

>>> def my_defination(var1 = 1, class_ = MyClass):
...     print var1
...     print class_

>>> my_defination()
1
__main__.MyClass
>>>

перед названием

подчеркивания перед переменная / функция / имя метода указывает программисту, что это только для внутреннего использования, которое может быть изменено всякий раз, когда класс хочет.

здесь префикс имени подчеркиванием рассматривается как непубличный. Если указать из импорта * все имя начинается с _ не будет импортировать.

Python не указывает действительно частный, так что это можно вызвать непосредственно из других модулей, если он указан в все, мы также называем его слабым частная

class Prefix:
...     def __init__(self):
...             self.public = 10
...             self._private = 12
>>> test = Prefix()
>>> test.public
10
>>> test._private
12
Python class_file.py

def public_api():
    print "public api"

def _private_api():
    print "private api"

вызов файл из REPL

>>> from class_file import *
>>> public_api()
public api

>>> _private_api()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_private_api' is not defined

>>> import class_file
>>> class_file.public_api()
public api
>>> class_file._private_api()
private api
Double Underscore(__)

__ведущий_двойной_подчеркивания

ведущее двойное подчеркивание говорит интерпретатору python переписать имя, чтобы избежать конфликта в подклассе.Интерпретатор изменяет имя переменной с расширением класса и этой функцией, известной как искажение. testFile.py

class Myclass():
    def __init__(self):
        self.__variable = 10

звонок от REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.__variable
Traceback (most recent call last):
File "", line 1, in
AttributeError: Myclass instance has no attribute '__variable'
nce has no attribute 'Myclass'
>>> obj._Myclass__variable
10

в интерпретаторе Mangling python измените имя переменной с помощью ___. Так что несколько раз он использует в качестве частного член, потому что другой класс не может получить доступ к этой переменной напрямую. Основная цель _ _ — использовать переменную/метод в классе, только если вы хотите использовать его вне класса, вы можете сделать публичный api

class Myclass():
    def __init__(self):
        self.__variable = 10
    def func(self)
        print self.__variable

звонок от REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.func()
10

_ _ BEFORE_AFTER__

имя с началом С __ и заканчивается тем же рассматривает специальные методы в Python. Python предоставляет эти методы для использования его в качестве перегрузки оператора в зависимости от пользователь.

Python предоставляет это Соглашение для различения пользовательской функции с функцией модуля

class Myclass():
    def __add__(self,a,b):
        print a*b

звонок от REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.__add__(1,2)
2
>>> obj.__add__(5,2)
10

ссылка

Двойное подчеркивание и двойное перекрытие текста с помощью CSS

В этом уроке мы покажем, как сделать текст с двойным подчеркиванием и двойным перекрытием с помощью CSS.

Для некоторых целей отображения или выделения вашего контента вам может потребоваться двойной подчеркнутый или двойной подчеркнутый текст на ваших веб-страницах. Поскольку свойства CSS для создания двойных линий над или под текстом не существует, для создания этого эффекта следует использовать простой обходной путь.

Сначала мы дадим образцы для текста с двойным подчеркиванием и с надчётом ниже, а затем поговорим о том, как добиться их создания с помощью простых стилей CSS:

Двойной подчеркнутый текст

Двойной подчеркнутый текст

Метод 1

В первом методе мы используем верхнюю или нижнюю границы с двойными линиями, чтобы создать такой эффект.Следующий код создаст текст с двойным подчеркиванием:

<стиль>
. двойное подчеркивание {
нижняя граница: 4 пикселя двойной;
}

Текст с двойным подчеркиванием

Причина, по которой мы отображаем наш текст в элементе span , заключается в том, что вы можете использовать элементы span в любом другом элементе, таком как деления (div) или абзацы (p).

Вы можете изменить ширину (4 пикселя) границы по своему желанию.Наименьшая ширина в пикселях, которую вы можете использовать, составляет 3 пикселя, поскольку при 2 пикселях линии соприкасаются друг с другом, в результате получается одна линия. Вы можете увидеть двойные подчеркивания разного размера ниже:

Двойной подчеркнутый текст — ширина 3 пикселя

Двойной подчеркнутый текст — ширина 4 пикселя

Двойной подчеркнутый текст — ширина 5 пикселей

Чтобы создать двойную верхнюю линию с помощью этого метода, просто замените свойство border-bottom на свойство border-top .

Метод 2

Во втором методе мы используем свойства border-bottom / border-top и text-decoration для создания этого эффекта.Пожалуйста, проверьте приведенный ниже код, чтобы увидеть его в действии.

<стиль>
. двойное подчеркивание {
нижняя граница: сплошная 1px;
оформление текста: подчеркивание;
}

Текст с двойным подчеркиванием

Вот результат кода выше:

Двойной подчеркнутый текст

Для создания двойной линии с помощью этого метода используйте следующий код:

<стиль>
.двойная линия {
padding-top: 1px;
border-top: сплошной 1px;
текст-оформление: надстрочный;
}

Двойной текст с надписями

Двойной подчеркнутый текст

Первый метод, кажется, дает лучший результат, так как пространство между текстом и первой строкой выглядит лучше. Используйте тот метод, который, по вашему мнению, лучше всего подходит для вашего дизайна.

стиль оформления текста | CSS-уловки

Свойство text-decoration-style устанавливает стиль подчеркивания для ссылок, а также подчеркивания, надчеркивания или сквозной строки для любого текста с примененным text-decoration .

  a {
  стиль оформления текста: сплошной;
}  

Значения

• твердый : значение по умолчанию. Украшение представляет собой единую сплошную линию.
• двойной : Украшение представляет собой пару сплошных линий.
• пунктир : украшение — пунктирная линия.
• пунктирная : украшение — пунктирная линия.
• волнистый : украшение — волнистая линия.

Демо

На момент написания статьи text-decoration-style официально поддерживается только в Firefox.Он также будет работать в браузерах Chrome с включенным флагом экспериментальных функций веб-платформы.

См. Pen text-decoration-style от CSS-Tricks (@ css-tricks) на CodePen.

Сокращение

В браузерах, поддерживающих text-decoration-style и text-decoration-color , вы можете добавить стиль оформления к сокращенному свойству text-decoration :

 . Подчеркнутый {
  оформление текста: подчеркнутый красный пунктир;
}  

В настоящее время только Firefox поддерживает это без префикса.Safari поддерживает его с префиксом -webkit . Chrome также нуждается в префиксе -webkit и функциях экспериментальной веб-платформы, включенных в флагах Chrome.

Связанные

Дополнительная информация

Поддержка браузера

* только с экспериментальными функциями веб-платформы флаг включен

† Firefox 6+ с префиксом -moz , 36+ без префикса.

text-decoration-style — CSS: Каскадные таблицы стилей

Свойство CSS text-decoration-style устанавливает стиль строк, указанных в text-decoration-line . Стиль применяется ко всем строкам, для которых задано значение text-decoration-line .

Если указанное украшение имеет определенное семантическое значение, например сквозная линия, означающая, что некоторый текст был удален, авторам рекомендуется обозначать это значение с помощью тега HTML, например или .Поскольку в некоторых случаях браузеры могут отключать стили, семантическое значение в такой ситуации не исчезнет.

При одновременной установке нескольких свойств line-decoration может быть удобнее использовать сокращенное свойство text-decoration .

 
стиль оформления текста: сплошной;
стиль оформления текста: двойной;
стиль оформления текста: пунктирная;
стиль оформления текста: пунктирная;
стиль оформления текста: волнистый;


стиль оформления текста: наследование;
стиль оформления текста: начальный;
стиль оформления текста: не задано;
  

Значения

твердый

Рисует одну линию.

двойной

Рисует двойную линию.

с точками

Рисует пунктирную линию.

штриховые

Рисует пунктирную линию.

волнистый

Рисует волнистую линию.

-moz-none Этот API не стандартизирован.

Не рисует линии. Используйте вместо него text-decoration-line : none .

 твердый | двойной | пунктирная | пунктирная | волнистый 

Волнистая линия подчеркивания

 .пример {
       -moz-текст-украшение-строка: подчеркивание;
       -moz-text-decoration-style: волнистый;
       -moz-текст-украшение-цвет: красный;
    -webkit-text-decoration-line: подчеркивание;
    -webkit-text-decoration-style: волнистый;
    -webkit-текст-украшение-цвет: красный;
}  

CSS

  .wavy {
  текст-украшение-строка: подчеркивание;
  стиль оформления текста: волнистый;
  цвет оформления текста: красный;
}
  

HTML

  
 Под этим текстом есть волнистая красная линия.
  

Результаты

Таблицы BCD загружаются только в браузере.

• При одновременной установке нескольких свойств оформления строк может быть удобнее использовать сокращенное свойство text-decoration вместо этого.

Excel: двойное подчеркивание общей суммы

Проблема: Мой босс — CPA. Он говорит, что я должен дважды подчеркнуть общую сумму в отчете. На вкладке «Главная» ленты имеется один значок подчеркивания.Как добавить двойное подчеркивание?

  


   
 Пример подчеркивания текста HTML 
 

  
 Мне нравится poftut.com 

  
  Мне нравится poftut.com  

  
 Мне нравится   poftut.com   

  
   Мне нравится poftut.com   
 
  

  


   
 Пример подчеркивания текста HTML 
 

  
 Мне нравится poftut.com 

  
  Мне нравится poftut.com  

  
 Мне нравится   poftut.com   

  
   Мне нравится poftut.com   


  

  


   
 Пример подчеркивания текста HTML 
 

  
 Мне нравится poftut.com 

  
  Мне нравится poftut.com как волнистый  

  
  Мне нравится poftut.com как волнистый  
  
  
 Мне нравится  poftut.com как штриховой  
  
  
  Мне нравится пофтут.com как волнистый  
  
  
  Мне нравится poftut.com как волнистый  


  

  

  <стиль>
    .underline-red {украшение текста: красное подчеркивание;}
    .underline-green {украшение текста: зеленое подчеркивание;}
  



   
 Пример подчеркивания текста HTML 
 

  
 Мне нравится poftut.com 
  
  
 Мне нравится poftut.com