Импортирование и области видимости

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

Что бы вы хотели узнать?

Все наверно заметили что большинство статей взяты из книги... что кстати не скрывалось. Из книги копировать скучно и не интересно... 

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

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

А так же кликайте по рекламе )

Квалификация имен атрибутов

Здравствуйте посетители и читатели. Перед тем как начну, хочу поздравить всех с наступившим новым 2015 годом и с прошедшими праздниками. Ну и всем удачи и успехов в поисках работы или же просто в работе... так как от нее будет зависеть - то, на сколько Вам сладко придется жить :)

Немного напомню, что в моих постах информации из замечательной книги... Сам я в питоне пока не шарю, так как я веб программист который в основном сталкивается с РНР,НТМЛ и т.д. - но в последнее время ЯваСкрипт начинает нравиться... думаю скоро выложить на своем втором блоге - про рнр информацию о том, на сколько нужно шарить, чтоб пройти хотяб на джуниора и немножко выше, а так же я постараюсь создать блог на yii с небольшим обьяснением. Ну и собственно ссылка на мой второй блог - http://phpekurs.blogspot.com/ надеюсь я не буду затягивать со временем выпуска материалов как это бывает с этим блогом. Ну что ж, теперь приступим к теме....

После  ознакомления  с модулями  мы  должны  поближе  рассмотреть  понятие квалификации имен. В языке Pythonдля доступа к атрибутам любого объекта используется синтаксис квалификации имени object.attribute.

Когда использовать import

И так, в предыдущем посте, было рассказано о минусах инструкции from и о том, что использование import более надежней и практичней. Поэтому речь пойдет о использовании import.

Минусы инструкции from

Здравствуйте читатели. Ну что, вот вам еще очередная порция текста по программированию используя Python )
На этот раз речь пойдет о минусах использовании инструкции from.

Поменять значение имен в других файлах

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

Чтобы изменить глобально переменную в определенном файле, необходимо использовать инструкцию import:
% python
>>> from small import x, y     # Скопировать два имени
>>> x = 42                     # Изменить только локальное имя x

>>> import small               # Получить имя модуля
>>> small.x = 42               # Изменить x в другом модуле

Вот такой короткий пост, скоро будет еще один...

Операции присваивания в import и from

Так же, как и инструкция def, инструкции import и from являются выполняемыми  инструкциями,  а  не  объявлениями  времени  компиляции.  Они  могут вкладываться в условные инструкции if, присутствовать в объявлениях функций def и так далее, и они не имеют никакого эффекта, пока интерпретатор не достигнет их в ходе выполнения программы. Другими словами, импортируемые модули и имена в них не будут доступны, пока не будут выполнены соответствующие инструкции import или from. Кроме того, подобно инструкции def, import и from – это явные операции присваивания:

•  Инструкция import присваивает объект модуля единственному имени.
•  Инструкция from присваивает одно или более имен объектам с теми же именами в другом модуле.

Почему import перестает работать?

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

import и from - функции для использования модулей

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

Файл модуля с расширением .py можно подключить используя команды import или же from. Эти функции могут отыскать и загрузить файл модуля, если этого еще не было сделано.
Отличие у этих команд в том что:
import - загружает модуль целиком;
from - загружает или же копирует отдельные имена из модуля.

Теперь несколько примеров для каждой:

Основы программирования модулей

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

Чтобы определить модуль, достаточно воспользоваться текстовым редактором, я использую Sublime Text, с его помощью ввести некоторый программный код на языке Python в текстовый файл и сохранить его с расширением «.py» – любой такой файл автоматически
будет считаться модулем Python. Все имена, которым будет выполнено присваивание на верхнем уровне модуля, станут его атрибутами (именами, ассоциированными с объектом модуля) и будут доступны для использования клиентами.

Операции импорта, углубляемся

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

Что ж с наступившим вас 2014 годом и с продолжением темы)

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

Как работает импорт

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

Как организована программа

Как правило, программа на языке Python состоит из множества текстовых файлов, содержащих инструкции. Программа организована как один главный файл, к которому могут подключаться дополнительные файлы, известные как модули. Главный файл (или сценарий) определяет, как будет двигаться основной поток выполнения программы, – это тот файл, который необходимо запустить, чтобы начать работу приложения. Файлы модулей – это библиотеки инструментальных средств, где содержатся компоненты, используемые главным файлом (и,
возможно, где-то еще). Главный файл использует инструменты, определенные в файлах модулей, а модули используют инструменты, определенные в других модулях.

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

Python модули

Модули в Python-e - самый "мощный" инструмент, который вмещает в себя данные и программный код для многократного использования. Каждый  файл – это отдельный модуль, и модули могут импортировать другие модули для доступа к именам, которые в них определены. Обработка модулей выполняется двумя инструкциями и одной важной функцией:
import - Позволяет клиентам (импортерам) получать модуль целиком.
from - Позволяет клиентам получать определенные имена из модуля.
imp.reload - Обеспечивает  возможность  повторной  загрузки модуля без  остановки  интерпретатора Python.

Понимание генераторов множеств и словарей

Сейчас 2 часа  ночи, я ничего не понимаю, что относится к программированию на Python, но пишу этот пост... надеюсь кому то он поможет.


>>> {x * x for x in range(10)}         # Генератор
{0, 1, 4, 81, 64, 9, 16, 49, 25, 36}

>>> set(x * x for x in range(10)) # Генератор и конструктор типа
{0, 1, 4, 81, 64, 9, 16, 49, 25, 36}

>>> {x: x * x for x in range(10)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

>>> dict((x, x * x) for x in range(10))
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Генераторы - объекты итераторов однократного применения

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


Например, для выражения-генератора из предыдущего поста итератором является сам генератор (фактически вызов
метода iter генератора не выполняет никаких действий):
>>> G = (c * 4 for c in ‘SPAM’)
>>> iter(G) is G # Итератором генератора является сам генератор: 
True # G имеет метод __next__

Другое

Пост похожий на 

полезные функции, но все так не то...

Добавление проверок и вложенных циклов (функция filter):

Добавив после цикла for

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

Две версии реализации выбора четных чисел в диапазоне от
0 до  4 –  с помощью генератора списка и  с помощью функции filter:
№1

>>> [x for x in range(5) if x % 2 == 0]

[0, 2, 4]

№2 (filter+lambda) 

>>> list(filter((lambda x: x % 2 == 0), range(5)))

[0, 2, 4]

Добиваемся эффекта действия функций filter и map в единственном выражении:
>>> list(map((lambda x: x**2), filter((lambda x: x % 2 == 0), range(10))))
[0, 4, 16, 36, 64]

Аргументы, углубляемся, продолжение

Передача аргументов, доходим до конца

Исчезнувшая встроенная функция apply (Python 2.6):
До появления версии Python 3.0 того же эффекта, который дает использование синтаксиса
*args и **args в вызовах функций, можно было добиться с помощью встроенной функции apply. Данная возможность убрана в версии 3.0, но осталась в версии 2.х и 2.6. Проще говоря, следующие две инструкции являются эквивалентными в версиях Python ниже версии 3.0:


func(*pargs, **kargs)     # Новейший синтаксис вызова:
                          #func(*sequence, **dict)

apply(func, pargs, kargs) # Устаревшая функция: 
                          #apply(func, sequence, dict)

В  качестве  примера  рассмотрим  следующую  функцию,  которая  принимает произвольное число позиционных и именованных аргументов:
>>> def echo(*args, **kwargs): print(args, kwargs)
...
>>> echo(1, 2, a=3, b=4)
(1, 2) {‘a’: 3, ‘b’: 4}

С использование функции  apply предыдущий код выглядел бы так:

>>> pargs = (1, 2)
>>> kargs = {‘a’:3, ‘b’:4}

>>> apply(echo, pargs, kargs)
(1, 2) {‘a’: 3, ‘b’: 4}

>>> echo(*pargs, **kargs)
(1, 2) {‘a’: 3, ‘b’: 4}

Аргументы, углубляемся

Передача аргументов

Углубляемся

Тонкости сопоставления:

• В вызове функции аргументы должны указываться в следующем порядке:
любые позиционные аргументы (значения), за которыми могут следовать любые именованные аргументы (name=value) и аргументы в форме *sequence, за которыми могут следовать аргументы в форме **dict.

• В заголовке функции аргументы должны указываться в следующем порядке: любые обычные аргументы (name), за которыми могут следовать аргументы со значениями по умолчанию (name=value), за которыми следуют аргументы в форме *name (или * в 3.0), если имеются, за которыми могут следовать любые имена или пары name=value аргументов, которые передаются только по имени (в 3.0), за которыми могут следовать аргументы в форме **name.

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

Действия, которые выполняет интерпретатор при сопоставлении аргументов перед присваиванием, грубо можно описать так:
1. Сопоставление не именованных аргументов по позициям.
2. Сопоставление именованных аргументов по именам.
3. Сопоставление дополнительных не именованных аргументов с  кортежем
          *name.
4. Сопоставление дополнительных именованных аргументов со словарем
          **name.
5. Сопоставление значений по умолчанию с отсутствующими именованными
         аргументами.
После этого интерпретатор убеждается, что каждому аргументу соответствует только одно значение, – в противном случае возбуждается исключение. По окончании сопоставления всех аргументов интерпретатор связывает имена аргументов с полученными объектами.

Аргументы

Передача аргументов

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

  • Аргументы передаются через автоматическое присваивание объектов локальным переменным (передача по указателям).

  • Операция присваивания именам аргументов внутри функции не оказывает влияния на вызывающую программу.

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

Передача аргументов очень близка к языку С:
  • Неизменяемые объекты передаются «по значению». Такие  объекты,  как целые числа  и строки, передаются в виде ссылок на объекты, а не в виде копий объектов.

  • Изменяемые объекты передаются «по указателю».  Такие  объекты,  как списки и словари, также передаются в виде ссылок на объекты, что очень похоже на то, как в языке C передаются указатели на массивы, – изменяемые объекты допускают возможность непосредственного изменения внутри функции так же, как и массивы в языке C.