Как вывести имя класса python
Получить полное имя класса объекта в Python
для целей ведения журнала я хочу получить полное имя класса объекта Python. (С полной квалификацией я имею в виду имя класса, включая имя пакета и модуля.)
9 ответов
со следующей программой
и Bar определяется как
предоставленные ответы не касаются вложенных классов. Хотя он недоступен до Python 3.3 (PEP 3155), вы действительно хотите использовать __qualname__ класса. В конце концов (3.4? PEP 395), __qualname__ также будет существовать для модулей для решения случаев, когда модуль переименован (т. е. когда он переименован в __main__ ).
рассмотрите возможность использования inspect модуль, который имеет такие функции, как getmodule что может быть что ищем:
вот один, основанный на отличном ответе Грега Бэкона, но с парой дополнительных проверок:
__module__ может быть None (согласно документам), а также для типа str может быть __builtin__ (который вы, возможно, не хотите появляться в журналах или что-то еще). Следующие проверки для обеих этих возможностей:
__module__ будет делать трюк.
этот сайт говорит о том, что __package__ может работать для Python 3.0; однако приведенные примеры не будут работать под моей консолью Python 2.5.2.
это хак, но я поддерживаю 2.6 и просто нужно что-то простое:
поскольку интерес этой темы заключается в получении полных имен, вот ловушка, которая возникает при использовании относительного импорта вместе с основным модулем, существующим в том же пакете. Например, с приведенной ниже настройкой модуля:
вот результат, показывающий результат импорта одного и того же модуля по-разному:
когда Hum импортирует бар, используя относительный путь, бар видит Baz.__module__ Как только «баз», но во втором импорте, который использует полное имя, бар видит то же самое как » Фу.baz.»
Если вы где-то сохраняете полные имена, лучше избегать относительного импорта для этих классов.
ни один из ответов здесь работал для меня. В моем случае я использовал Python 2.7 и знал, что буду работать только с newstyle object классы.
заметьте, он также работает правильно для buildins:
Примеры работы с классами в Python
Python — объектно-ориентированный язык с начала его существования. Поэтому, создание и использование классов и объектов в Python просто и легко. Эта статья поможет разобраться на примерах в области поддержки объектно-ориентированного программирования Python. Если у вас нет опыта работы с объектно-ориентированным программированием (OOП), ознакомьтесь с вводным курсом или учебным пособием, чтобы понять основные понятия.
Создание классов
Пример создания класса на Python:
Создание экземпляров класса
Доступ к атрибутам
Теперь, систематизируем все.
При выполнении этого кода, мы получаем следующий результат:
Вы можете добавлять, удалять или изменять атрибуты классов и объектов в любой момент.
Вместо использования привычных операторов для доступа к атрибутам вы можете использовать эти функции:
Встроенные атрибуты класса
Для вышеуказанного класса давайте попробуем получить доступ ко всем этим атрибутам:
Когда этот код выполняется, он возвращает такой результат:
Удаление объектов (сбор мусора)
Python автоматически удаляет ненужные объекты (встроенные типы или экземпляры классов), чтобы освободить пространство памяти. С помощью процесса ‘Garbage Collection’ Python периодически восстанавливает блоки памяти, которые больше не используются.
Сборщик мусора Python запускается во время выполнения программы и тогда, когда количество ссылок на объект достигает нуля. С изменением количества обращений к нему, меняется количество ссылок.
Пример работы __del__()
Деструктор __del__() выводит имя класса того экземпляра, который должен быть уничтожен:
Когда вышеуказанный код выполняется и выводит следующее:
Наследование класса в python
Наследование — это процесс, когда один класс наследует атрибуты и методы другого. Класс, чьи свойства и методы наследуются, называют Родителем или Суперклассом. А класс, свойства которого наследуются — класс-потомок или Подкласс.
Вместо того, чтобы начинать с нуля, вы можете создать класс, на основе уже существующего. Укажите родительский класс в круглых скобках после имени нового класса.
Класс наследник наследует атрибуты своего родительского класса. Вы можете использовать эти атрибуты так, как будто они определены в классе наследнике. Он может переопределять элементы данных и методы родителя.
Синтаксис наследования класса
Классы наследники объявляются так, как и родительские классы. Только, список наследуемых классов, указан после имени класса.
Python получить имя класса
Итак, у меня есть проблема, я хочу получить имя класса Python следующим образом:
Но это имеет большую проблему, потому что я не могу получить имя класса, пока не создаю его экземпляр, я настаиваю на создании нескольких гигабайт данных для каждого экземпляра класса, который будет сохранен в saveDirectory, поэтому он может использовать повторно позже. Так что я на самом деле не хочу идти дальше с моим текущим решением.
Есть ли способ получить имя класса, как я задумал? Или я просто сплю?
Спасибо, ребята, за ваши отличные предложения. Я собираюсь потратить немного времени на изучение метаклассов. В противном случае я, вероятно, создам словарь глобально и вместо этого буду ссылаться на эти экземпляры классов.
6 ответов
Это определенно менее понятно, чем просто использование следующего:
Просто использовать метод?
Или у вас может быть атрибут класса, указывающий каталог сохранения; меньше магии, как правило, хорошо. Кроме того, вы можете изменить имя класса позже, не нарушая хранилища.
Кроме того, что? Гигабайт?!
Я думаю, что то, что вы делаете, невозможно, потому что класс даже не существует, когда вы делаете:
myName = (get class name here automatically)
Но вскоре после того, как класс был интерпретирован, вы можете передать объект класса другой функции сделать работу за вас.
С другой стороны, если вам действительно нужно имя класса из внутри тела класса (маловероятно), вы можете отслеживать стек вызовов. Имя класса, как оно выглядит в исходном коде, находится на объекте кода, выполняемого по определению класса:
Из представленных на данный момент только этот последний позволяет использовать имя в виде строки внутри тела класса. К сожалению, это работает не во всех версиях Python. в частности, IronPython не реализует самоанализ стека вызовов, так как он не доступен в DLR.
Начиная с python 3.3, вы можете использовать __qualname__ переменная:
Как я могу получить имя объекта в Python?
Есть ли способ получить имя объекта в Python? Например:
На самом деле я создаю список функций, которые я могу указать с помощью командной строки.
Я получаю имя функции из командной строки и хочу вызвать соответствующую функцию:
Таким образом, мне нужно написать имена функций только один раз.
15 ответов
Объекты не обязательно имеют имена в python, поэтому вы не можете получить имя. Обычно объекты имеют атрибут __name__ в тех случаях, когда у них есть имя, но это не является частью стандартного python, и большинство встроенных типов не имеют его.
Когда вы создаете переменную, такую как x, y, z выше, эти имена просто действуют как «указатели» или «ссылки» на объекты. Сам объект не знает, какое имя вы используете для него, и вы не можете легко (если вообще) получить имена всех ссылок на этот объект.
Обновление: однако функции имеют __name__ (если они не лямбда-выражения), поэтому в этом случае вы можете сделать:
Вот мой ответ, я также использую globals (). Items ()
Я добавил исключение_ слова, потому что я хочу отфильтровать слово, используемое в цикле for. Если вы не добавили его, ключевое слово в цикле for может запутать эту функцию, иногда ключевое слово «each_item» в следующем случае может отображаться в результате функции, в зависимости от того, что вы сделали с вашим циклом.
Надеюсь, это поможет.
Вы определяете class и добавляете приватную функцию Unicode, вставляете class как
Я наткнулся на эту страницу, задаваясь вопросом о том же вопросе.
Короче говоря, вы могли бы использовать модуль inspect, чтобы сделать обоснованное предположение о том, какой это, но вам, вероятно, придется знать, в каком кадре вы работаете / пройти по стеку, чтобы найти правильный. Но я бы не хотел представить, как весело будет пытаться справиться с кодом eval / exec.
Как описано в других ответах, вы можете использовать тот же подход с globals() и обычными функциями в вашем модуле, чтобы более точно соответствовать тому, что вы просили.
Имена переменных можно найти в словах globals () и locals (). Но они не дадут вам то, что вы ищете выше. «bla» будет содержать значение каждого элемента my_list, а не переменной.
Используйте обратный дикт.
Обратный dict отобразит каждую ссылку на функцию на точное имя, которое вы дали ей в fun_dict, которое может быть или не быть тем именем, которое вы использовали при определении функции. И эта техника обобщает на другие объекты, в том числе целые числа.
Для дополнительного удовольствия и безумия вы можете хранить прямое и обратное значения в одном и том же тексте. Я бы не стал этого делать, если бы вы отображали строки в строки, но если вы делаете что-то вроде ссылок на функции и строк, это не слишком безумно.
Для этого у вас есть замечательная getattr функция, которая позволяет вам получить объект под известным именем. Так что вы могли бы сделать, например:
Что должно name(e[2]) вернуть и почему?
Как уже упоминали другие, это действительно сложный вопрос. Решения для этого не «один размер подходит всем», даже удаленно. Трудность (или легкость) действительно будет зависеть от вашей ситуации.
Далее следует кое-что из того, что я придумал.
Вернуть имя функции
Вернуть первое совпадающее имя объекта
Сравните значение arg со значениями элементов в globals() и верните имя первого совпадения. Обратите внимание, что я отфильтровываю имена, начинающиеся с ‘_’.
Вернуть все совпадающие имена объектов
Этот однострочник работает для всех типов объектов, если они находятся в globals() dict, которым они должны быть:
Или, что эквивалентно:
На самом деле это невозможно, так как может быть несколько переменных, имеющих одно и то же значение, или значение может не иметь переменной, или значение может иметь то же значение, что и переменная, только случайно.
Если вы действительно хотите это сделать, вы можете использовать
Однако было бы лучше, если бы вы сначала перебирали имена:
Как создавать классы в Python со знанием дела: разбираем на примерах
Так что Python — это (n+1)-й язык, в котором была реализована концепция ООП.
Что же такое ООП?
В какой-то момент мы поймем, что утка чем-то похожа на других птиц: значит, ее можно отнести к категории (обобщенному, родительскому классу, шаблону) «птицы». С другой стороны, для нашей игры не важно, как устроен организм утки: главное, что она как-то выглядит и как-то крякает. То есть мы абстрагируемся от ненужных для нашей модели нюансов. А кто-то другой добавит эти нюансы в свою модель и реализует, например, утиный анатомический атлас. Но некто третий использует обе модели и на их базе создаст свою. Это в двух словах о том, каким образом формируются модели и каким образом объекты подразделяются на классы.
Утка и Птица — это классы, а утка1, утка2 и птица1, птица2 — объекты (экземпляры классов).
Концепция объектно-ориентированного программирования опирается на три известных утки кита. Давайте познакомимся с ними поближе.
Инкапсуляция
Этим словом обозначают сокрытие нюансов поведения объекта или его характеристик от «посторонних» программистов. Например, над компьютерной игрой работают два программиста. Один из них реализовал класс Утка, а другой просто хочет его использовать и у них случается такой диалог:
— Какой код написать, чтобы твоя утка полетела?
Наследование
В примере выше Утка — наследник класса Птица. В то же время Птица — родительский класс по отношению к Утке. Вот так принято выражаться.
Полиморфизм
Сколько способов есть у утки, чтобы поздороваться с вами голосом? Наверное, она просто скажет что-то вроде «кря». Допустим, у нее есть один способ. Хорошо, сколько способов есть у лебедя? Они вроде как просто шипят. Допустим, тоже один. А если у птиц в целом? Ну не знаю… много. Однако все в целом по-прежнему будет называться словом «поздороваться»:
Действие называется одинаково, но выполнено оно будет по-разному — в зависимости от объекта, который это действие будет выполнять. У объекта утка1 класса Утка и у объекта лебедь1 класса Лебедь это произойдет по-разному. В буквальном переводе греческое слово polýmorphos означает «многообразный». Поняли, да?
Далее перейдем к практике и разберемся, как создавать классы и делать с ними вот это все на Python. Остальную терминологию ООП и специальные термины из Python изучим по ходу дела.
Первый класс
Ключевое слово class мы уже обсудили. Оно ставится перед названием класса, которое пишется с большой буквы. Внутри класса для начала просто выведем сообщение.
Создаем объект (он же экземпляр класса) вот так — в одну строку:
Имя объекта (здесь создан объект по имени b ) пишем с маленькой буквы. В этом случае внутри скобок нет параметров, но позже мы посмотрим, как и зачем их туда вписывать. Для второго объекта — аналогично. И вот такой результат работы этой программы мы получим:
Птица, ты кто?
Пока мы толком ничего не можем сказать о созданном объекте b. Все потому, что мы создали для него пустой класс, который просто занимается самолюбованием. Давайте это исправим. Добавим один атрибут name классу Bird.
Атрибуты — это набор данных, характеризующих объект или его состояние.
Теперь можно дать каждой птице (объекту класса Bird) имя:
Запустив программу, получим:
Чтобы получить значение атрибута, мы обращаемся к нему через имя объекта с точкой (b.name).
Ключевое слово self
По аналогии внутри него мы будем делать это вот как:
Получается, что self заменяет имя любого объекта, когда мы пишем код внутри его класса.
Если внутри Bird использовать объект другого класса, слово self для него не применяется. Например, создадим класс Cird :
Создадим и используем объект класса Cird внутри класса Bird:
Результат выполнения кода:
Конструктор и инициализатор
Теперь стало немного понятнее, зачем нужен self в этом странном методе класса:
Хорошо… но почему это так? И зачем вообще нужен этот метод?
Это инициализатор. Обычно именно здесь в атрибуты объекта записываются значения. Это могут быть значения по умолчанию (как в классе Cird: self.message = «Я объект c, класса Cird» ) или значения, полученные с использованием параметров функции.
А как же создается сам объект?
Статические и динамические атрибуты
И такое тоже практикуют. И такие атрибуты даже имеют свое название и применение:
Статические атрибуты применяются для того, чтобы иметь одну общую переменную для всех объектов класса.
Дело в том, что при создании новых объектов создаются копии всех динамических атрибутов со сброшенными к «заводским настройкам» значениями. Статические атрибуты относятся не к объекту, а к классу и имеют только одну копию.
В примере выше статический атрибут ruClassName просто хранит название класса. В примере поинтереснее статический атрибут может служить для подсчета количества созданных объектов класса:
Методы класса
Что, если нам дали задачу расширить пример из предыдущего раздела?
1. Нужно добавить Птице больше атрибутов:
2. Реализовать возможность выводить атрибут имя ( name ), а также эти два атрибута для каждого объекта класса Птица.
С первым пунктом мы справимся легко, как говорится, по образу и подобию:
Вроде бы и вывод тоже можно сделать аналогично:
Результат работы кода:
Но наш тимлид считает, что такой код некрасивый и не очень читабельный. Да и ООП рекомендует помещать код обработки данных объекта внутрь его класса. Попробуем:
Функция info() внутри класса Bird называется методом. Теперь у каждого созданного объекта этого класса можно вызвать метод:
Код действительно выглядит более лаконично. Получается, что теперь каждый объект сам может сообщить информацию о себе. И теперь, используя объект, сторонний программист может не задумываться о том, как реализован вывод информации о нем. Он работает, и хорошо!
Результат работы такой же, как в предыдущем примере:
Уровни доступа атрибута и метода
Реализация концепции ООП должна предусмотреть возможность запретить прямой доступ к атрибуту (или к методу) со стороны внешнего кода. То есть сделать его скрытым, приватным (термин из англоязычного ООП — private). Прямая модификация некоторых особо важных атрибутов может привести к дефектам в программе. Часто это нужно для того, чтобы оставлять доступ открытым («публичным», public) только к тем атрибутам и методам, которые будут взаимодействовать с внешним кодом. Остальные атрибуты и функции, которые, например, просто (или сложно) обслуживают свой класс, не должны быть доступны извне.
В Python это реализовано с помощью добавления к имени атрибута или метода одинарного или двойного подчеркивания. Первое используется в расчете на более сознательных и внимательных граждан. Второе — более жесткий вариант для всех остальных. Что это означает? Перейдем к конкретике и возьмем из нашего примера атрибут name:
По заветам ООП, и в первом, и во втором случае нужно узнать, написаны ли специальные методы для получения значения ( getter ) и/или модификации ( setter ) интересующего вас скрытого атрибута. Если да, то используйте их.
Эти методы обычно выглядят примерно так:
Перепишем весь класс:
Создадим объект и покажем правильный доступ к атрибуту _name (для __name все будет аналогично), который теперь обозначен как скрытый:
Результат работы программы:
Оказывается, мы можем переименовать созданный объект. Здорово. Но что, если нам запрещено называть птиц Иванами?
Тогда программа будет работать по-другому:
Свойства
В остальном это обычные методы.
Код вызова извне тоже изменится:
Результат работы программы останется прежним:
Начать и закончить: наследование и полиморфизм
Про наследование и полиморфизм уже шла речь в начале статьи. Но тогда нельзя было приводить полноценные примеры на Python. Теперь, когда мы подтянули матчасть, написали и много раз переписали свой первый класс… как говорится, примеры в студию! Поэтому, если вам требуется время, чтобы вернуться в начало статьи и повторить эту тему — не волнуйтесь, я подожду.
Повторили? Тогда полетели дальше.
Наследование
Оттолкнемся от нашего класса Bird. Вспомним, как он выглядит:
Создадим новый класс Duck (утка), который максимально использует код класса Bird и допишем в него немного своего кода. То есть Duck будет наследником Bird, который является родителем, базовым классом. Это в принципе ожидаемо: чтобы некая сферическая птица в вакууме стала уткой, достаточно добавить пару опознавательных знаков (потому что для примера мы придумали простую модель). Итак, пусть у класса Duck будут такие динамические атрибуты:
Атрибуты «скорость полета» и «высота полета» бессмысленно помещать в базовый класс, потому что не все птицы умеют летать:
В строке class Duck (Bird) мы в скобках указываем имя класса, от которого хотим делать наследование.
В методе def __init__ (self, name, id, age, fly_speed, fly_height) мы, помимо заполнения значений атрибутов текущего объекта класса Duck, вызываем инициализатор объекта базового класса (Bird):
super().__init__(name, id, age)
Теперь проверим, как работает это ваше наследование. Как обычно, создаем объект, заполняем его данными и просим рассказать о себе:
Отметим, что внутри метода info() у утки (см. класс Duck) мы, по аналогии с инициализатором и чисто для полноты информации — вызываем свой метод info() у базового класса (то есть у Bird):
Ну вот, у нас получилась утка, которая может рассказать о себе и при этом помнит, что она Птица — не забывает свои корни. Жирным выделены атрибуты базового класса:
Идентификационный номер: 22
Скорость полета: 110
Отлично, с уткой все получилось удачно. Но означает ли это, что можно создавать еще много аналогичных классов-наследников, используя один и тот же код базового класса? А еще интереснее узнать вот что:
super().__init__(name, id, age)
Теперь проверим, как это сработает на этот раз. Жирным выделены атрибуты, относящиеся к базовому классу:
Идентификационный номер: 22
Вид: Галапагосский баклан
Количество особей: 60
Теперь сведем воедино работу объектов всех трех классов — родителя и наследников :
Создавать такие объекты можно в любом порядке. Как видите, вообще не обязательно, чтобы объект базового класса создавался первым.
Жирным выделены атрибуты, относящиеся к базовому классу:
Идентификационный номер: 22
Вид: Галапагосский баклан
Количество особей: 60
Идентификационный номер: 9
Идентификационный номер: 77
Скорость полета: 110
Мы показали, что метод info() действительно работает по-разному — в зависимости от класса того объекта, который обращается к этому методу.
Мы применили все знания, полученные в статье, и только в конце смогли написать код в соответствии с парадигмой полиморфизма.
Надеюсь, тот, кто дочитал это до конца, получил ответ на свой вопрос!