Введение в научный Python-1. Введение в научный Python

• Название: Введение в научный Python
• Дата: 09.01.2020
• Размер: 6.2 Mb.
• Имя файла: Введение в научный Python-1.pdf
• Тип: Документы; #103229
• страница: 5 из 22

Словарь – это набор объектов, доступ к которым осуществляется по ключу, а не по индексу, как в списках или массивах. Ключом может быть любой неизменяемый объект, например, число, строка или кортеж. Элементами словаря могут быть объекты произвольного типа данных. Чтобы получить элемент словаря, нужно указать ключ, который использовался при сохранении значения. Словари не являются последовательностями, и многие функции, используемые для работы с последовательностями, к ним не применимы.
Словари относятся к изменяемым типам данных. Поэтому вы можете не только получить значение по ключу, но и изменить его.
Создать словарь можно с помощью функции dict(...). Она имеет несколько форматов, основным из которых является следующий: diсt(<Ключ1>=<Значение1>[, ... , <КлючN>=<ЗначениеN>])
>>> d1 = dict(a=5, b=8); d1
{'b': 8, 'a': 5}
Если параметры не указаны, то создается пустой словарь.
>>> d0=dict(); d0
{}
Аргументом функции dict(...) может быть другой словарь (создается поверхностная копия словаря).
>>> d2=dict(d 1);d2
{'b': 8, 'a': 5}
Аргументом функции dict(...) может быть список кортежей с парой элементов (ключ, значение).
>>> d = dict([("a", 5), ("b", 8)]); d
# Список кортежей
{'b': 8, 'a': 5}
Аргументом функции dict(...) может быть список списков с парой элементов [ключ, значение].
>>> d = dict ( [ ["а", 5], ["b", 8]]); d
# Список списков
{'b': 8, 'а': 5}
Создать словарь можно с помощью операции присваивания, перечислив справа от знака равенства все его элементы внутри фигурных скобок. Ключ и значение разделяется двоеточием, а пары (ключ:значение) разделяются запятыми.
>>> d = { "а": 5, "b": 8 }; d
{'b': 8, 'а': 5}
Заполнить словарь можно поэлементно. При этом ключ указывается внутри квадратных скобок.
>>> d = {}
# Создаем пустой словарь
>>> d["a"]=5
# Добавляем ключ "а"
>>> d["b"]=8
# Добавляем ключ "b"

52
>>> d
{'b': 8, 'a': 5}
Как и для списков, при создании словаря в переменной сохраняется ссылка на объект, а не сам объект.
Для создания поверхностной копии можно воспользоваться методом сору( ) или функцией dict().
>>> d3=d.copy(); d3
{'b': 8, 'a': 5}
>>> d3 is d
# сравнение объектов
False
>>> d3["b"]=25
>>> d,d3
# Изменилось значение b в словаре d3
({'b': 8, 'a': 5}, {'b': 25, 'a': 5})
>>> d4=dict(d)
>>> d4["b"] = 55
>>> d,d4
({'b': 8, 'а': 5}, {'b': 55, 'а': 5})
Для создания полной копии словаря, следует воспользоваться функцией deepcopy() из модуля сору.
>>> import copy
>>> d4=copy.deepcopy(d)
Чтение значений элементов словаря выполняется с помощью квадратных скобок, в которых указывается ключ.
>>> d['a']
5
>>> d['a'],d['b']
(5, 8)
Если элемента в словаре нет (нет соответствующего ключа) то генерируется сообщение об ошибке. Проверить наличие ключа можно с помощью оператора in.
>>> 'a' in d
True
>>> ' c' in d
False
Используя ключ, можно изменить элемент словаря. Если элемента с указанным ключом в словаре не окажется, то он будет добавлен.
>>> d['a']=1000
>>> d['c']='KhNu'
>>> d
{'a': 1000, 'b': 8, 'c': 'KhNu'}
Функция len() возвращает количество элементов (ключей) словаря.
>>> len(d)
3
Оператор del удаляет элементы словаря.
>>> del d['b']

53
>>> d
{'a': 1000, 'c': 'KhNu'}
Перебрать все элементы словаря можно с помощью цикла for, поскольку словари поддерживают итерацию.
>>> for k in d: print("d['{0}'] = {1}".format(k,d[k]),end=' ')
d['a'] = 1000 d['c'] = KhNu
Словари являются неупорядоченными наборами. Чтобы вывести элементы с сортировкой по ключам, нужно получить набор ключей c помощью метода keys(), преобразовать полученный объект в список, отсортировать его, а затем выводить элементы, используя отсортированный список ключей.
>>> d={'x':200, 'c':5, 'z':1000, 'a':10, 'y': 33}
>>> k=list(d.keys())
# получение списка ключей
>>> k.sort()
# сортировка списка ключей
>>> for key in k: print("d['{0}'] = {1}".format(key,d[key]),end=' ')
d['a'] = 10 d['c'] = 5 d['x'] = 200 d['y'] = 33 d['z'] = 1000
При сортировке ключей вместо метода sort() можно использовать функцию sorted().
>>> for key in sorted(d.keys()): print("d['{0}'] = {1}".format(key,d[key]),end=' ')
Функции sorted() можно сразу передавать объект словаря, а не объект dict_keys()
, возвращаемый методом keys().
>>> for key in sorted(d): print("d['{0}'] = {1}".format(key,d[key]),end=' ')
У объектов dict_keys() есть одна особенность: они поддерживают операции на множествах.
>>> d1,d2={'a':10, 'z':1000,'b':'Hello'},{'y':50, 'b':'Hello','x':(21,77)}
>>> d1.keys () | d2. keys ()
# Объединение
{'a', 'x', 'b', 'y', 'z'}
>>> d1.keys () - d2. keys ()
# Разность
{'a', 'z'}
>>> d1.keys () & d2. keys ()
# Пересечение
{'b'}
>>> d1.keys () ^ d2. keys ()
# исключающее ИЛИ
{'a', 'x', 'y', 'z'}
Метод values() возвращает объект dict_values(), содержащий все значения словаря.
>>> d2.values() dict_values(['Hello', (21, 77), 50])
>>> [elem for elem in d2.values()]
['Hello', (21, 77), 50]

54
Метод items() возвращает объект dict_items, который содержит все ключи и значения элементов попарно в виде кортежей.
>>> d={'x':200, 'c':5, 'z':1000, 'a':10, 'y': 33}
>>> d.items()
dict_items([('y', 33),('a',10),('c',5),('x',200),('z',1000)])
>>> list(d.items())
[('y',33),('a',10),('c',5),('x',200),('z',1000)]
Метод get(ключ,значение) возвращает значение, соответствующее ключу
(если ключ в словаре есть). Если ключа нет, то возвращается None или значение, указанное во втором аргументе.
>>> d.get('a'), d.get('f'), d.get('f',111)
(10, None, 111)
Метод pop(ключ,значение) удаляет элемент с указанным ключом и возвращает его значение. Если ключ отсутствует, то возвращается значение второго аргумента.
>>> d.pop('a')
10
>>> d
{'y': 33, 'c': 5, 'x': 200, 'z': 1000}
Метод clear() очищает словарь (удаляет все элементы).
Метод update(...) вносит изменения в текущий словарь, добавляя в него элементы. Если элемент с указанным ключом есть в словаре, то его значение меняется.
>>> d.update(d=555, c=111); d
{'y': 33, 'x': 200, 'c': 111, 'z': 1000, 'd': 555}
>>> d.update({'c':222,'d':333}); d
{'y': 33, 'x': 200, 'c': 222, 'z': 1000, 'd': 333}
Возможны другие способы записи добавляемых пар в методе update().
Генераторы словарей в Python конструируются подобно генераторам списков, но вся конструкция заключается в фигурные скобки, и внутри перед циклом for указываются два значения через двоеточие. Левое от двоеточия значение становится ключом, а правое – значением элемента.
>>> keys=['a','x','b','z','y']
>>> vals=[2,5,7,1,3 ]
>>> {k:v for (k,v) in zip(keys,vals)}
{'y': 3, 'b': 7, 'x': 5, 'a': 2, 'z': 1}
Напомним, что функция zip() в качестве аргументов принимает два (или больше) списка и возвращает итератор (поддерживает итерацию и может быть преобразован в список), составленный из кортежей соответствующих элементов этих списков.
>>> list(zip(keys,vals))
[('a',2),('x',5),('b',7),('z',1),('y',3)]
>>> import random
>>> keys=['a','b','c','d','e']
>>> dr= {k: random.randrange(0,10) for k in keys}; dr

55
{'c': 9, 'e': 2, 'a': 6, 'b': 4, 'd': 9}
>>> {k: v for (k, v) in dr.items() if v% 2 == 0}
# выбор четных значений
{'e': 2, 'a': 6, 'b': 4}
Строки, списки, кортежи и словари широко используются в Python программах.
Здесь мы описали только основные функции, методы и приемы работы с ними.
Имеется еще много других функций и методов, не описанных нами. Вы можете познакомиться с ними самостоятельно по справочной системе.
2.3
Функции, модули и пакеты
Функция – это участок кода, который можно вызвать из любого места программы по его имени. В предыдущих параграфах мы много раз использовали встроенные функции. Например, функция len() возвращает количество элементов последовательности (списка, кортежа, строки и т.д.).
Здесь мы рассмотрим, как создаются функции.
Функция определяется с помощью ключевого слова def следующим образом: def имя_функции
(
[аргументы]
) :
[""" Строка документирования """] тело функции
[
return значение]
Имя функции должно быть уникальным идентификатором. В круглых скобках через запятую можно указать один или несколько аргументов. Если функция не принимает аргументов, то указываются пустые круглые скобки. После круглых скобок ставится двоеточие. Операторы тела функции смещаются на одинаковое количество пробелов. Концом функции считается команда, смещенная на меньшее количество пробелов.
Если тело функции не содержит команд, то ее тело должно состоять из одной команды pass. Вот пример функции, которая ничего не делает: def func () : pass
Необязательная команда return возвращает значение из функции. Она может отсутствовать. Тогда выполняются все команды тела функции, и возвращается значение None.
Определение функции должно быть расположено перед ее вызовом.
Обычно определение функций размещают в самом начале программы после подключения модулей. При вызове функции значения аргументов передаются внутри круглых скобок через запятую. Если функция не принимает аргументов, то указываются пустые скобки.
Переменные, используемые в теле функции, являются локальными.
Изменение локальной переменной в теле функции не влечет изменения одноименной глобальной переменной.
>>> def f(x): y=5;
# локальная переменная return x*y

56
>>> y=22
# глобальная переменная
>>> f(4)
20
>>> y
# глобальная переменная не изменилась
22
В этом примере в теле функции f(x) присваивание y=5 не меняет глобальную переменную, а создает локальную переменную y со значением 5. Изменить таким способом глобальную переменную внутри функции нельзя. Однако глобальные переменные внутри функции можно использовать.
>>> def g(x): return x*z
# использование глобальной переменной z
>>> z=2
>>> g(4)
8
Чтобы изменить глобальную переменную в теле функции, она должна быть объявлена глобальной внутри функции с помощью ключевого слова global.
>>> def f(x): global y
# объявление глобальной переменной y=5
# изменение глобальной переменной return x*y
>>> y=10
# глобальная переменная
>>> f(5)
25
>>> y
# глобальная переменная изменилась
5
Аргументы в функцию передаются по значению. Если объект относится к неизменяемому типу, то изменение его значения внутри функции не затронет его значения снаружи.
>>> def g(x): x+=2 return x
>>> z=4; g(z)
6
>>> z
# значение z не изменилось
4
Если объект относится к изменяемому типу, то изменение его значения внутри функции повлияет на него снаружи.
>>> def fun(x): x[0]=5 return sum(x)
>>> L=[1,2,3]
>>> fun(L)
10
>>> L
[5, 2, 3]

57
Как видно, значение первого элемента списка изменилось. Однако можно в функцию передавать и копию объекта.
>>> L=[1,2,3]
>>> fun(L.copy())
10
>>> L
[1, 2, 3]
Копию можно передать также по–другому.
>>> fun(L[:])
10
>>> L
[1, 2, 3]
Тип переменной при вызове функции может не совпадать с типом аргумента при определении функции. Например, в следующем примере мы вызываем функцию f(), созданную нами выше, с аргументом, который является списком.
>>> f([1,2,3])
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
Операция умножения списка на число определена и означает его многократное повторение. В результате, вместо арифметического умножения, функция выполнила операцию повторения списка.
Если значения аргументов, передаваемые в функцию, содержатся в кортеже или списке, то перед кортежем (списком) следует указать символ *
(звездочка).
>>> def prod(x,y):
""" произведение элементов"""
# строка документации return x*y
>>> L=[6,3]
>>> prod(*L)
18
Все в языке Python является объектом, и функции не являются исключением.
Команда def создает объект, имеющий тип function, и сохраняет ссылку на него в идентификаторе, указанном после инструкции def. Можно сохранить ссылку на функцию в другой переменной, тем самым, создав ее новое имя.
>>> f=prod
>>> f(5,8)
40
Можно передать ссылку на функцию в качестве аргумента другой функции.
>>> def fun(f,x,y): return f(x,y)**2
>>> fun(prod,2,3)
36
Функция может иметь необязательные аргументы. Чтобы сделать аргумент необязательным, в определении функции ему нужно присвоить начальное значение.
>>> def prod(x,y=1): return x*y**2

58
>>> prod(5)
5
>>> prod(5,2)
20
Таким образом, если второй аргумент функции prod() не задан, то его значение будет равно 1.
При определении функции необязательные аргументы должны следовать после обязательных, иначе возникает неоднозначность.
До сих пор мы использовали позиционную передачу аргументов в функцию. В Python можно передать значения аргументов также по ключевому имени, например,
>>> prod(y=4,x=3)
48
Для этого при вызове функции следует указать имя аргумента, использованное при ее определении, и после знака равенства – значение. Последовательность указания аргументов в таком случае не существенна, а важны только их имена.
Значение изменяемого объекта, передаваемого аргументом, может сохраняться между вызовами функции. Для этого такому аргументу следует назначить значение по умолчанию.
>>> def fn(a=[ ]): a.append(5) return a
Теперь
>>> L=fn([11]); L
[11, 5]
>>> fn(L)
[11, 5, 5]
>>> fn(L)
[11, 5, 5, 5]
Если перед аргументом в определении функции указать символ * (звездочка), то функции можно вызывать с произвольным количеством аргументов. Для примера создадим функцию суммирования произвольного количества чисел.
>>> def summa(*x): s=0 for i in x: s+=i return s
>>> summa(10,15,25)
50
>>> summa(2,4,6,8,10)
30
Перед аргументом со звездочкой можно указать несколько обязательных аргументов и аргументов по умолчанию.
>>> def summa(a,b=1,*x): s=a+b for i in x:

59 s+=i return s
>>> summa(5)
6
>>> summa(5,10,2,3,4)
24
Если при определении функции некоторые аргументы указываются после аргумента со звездочкой, то при вызове функции их обязательно надо задавать по имени, т.е. в виде имя=значение. Иначе не ясно, где заканчивается список аргументов со звездочкой.
>>> def fun(*z,a): s=sum(z) s*=a return s
>>> fun(2,3,4,a=5)
# параметр a должен передаваться по имени
45
>>> fun(a=5)
0
Кроме обычных функций, язык Python позволяет использовать анонимные функции, которые называются лямбда–функциями. Они создаются с помощью ключевого слова lambda следующим образом: lambda [аргумент_l [,... ,аргумент_N]]: результирующее значение
В качестве результирующего значения указывается выражение, результат выполнения которого будет возвращен функцией. У лямбда–функций нет имени, поэтому их и называют анонимными функциями. Лямбда–функция возвращает ссылку на объект–функцию, которую можно сохранить в переменной или передать в качестве аргумента в другую функцию.
Вызываются лямбда–функции как обычные, с использованием круглых скобок, внутри которых, через запятую, перечисляются значения аргументов.
>>> f1=lambda: 100
# функция без аргументов
>>> f1()
100
>>> f=lambda x,y: x**2+y**2
# функция с двумя аргументами
>>> f(1,2)
5
>>> (lambda x: x**2)(5)
# создание и вызов лямбда функции
25
Аргументы лямбда–функций могут быть необязательными. Для этого им в определении функции нужно присвоить значение по умолчанию.
>>> f=lambda x,y=2: x**y
>>> f(4)
16
>>> f(4,3)
64
В Python можно создавать рекурсивные функции, которые могут вызывать сами себя.

60
>>> def factorial(n): if n==0: return 1 else: return n*factorial(n -1)
>>> factorial(5)
120
Python разрешает создавать вложенные функции, причем уровень их вложения может быть неограниченным. Вложенная функция получает собственную локальную область видимости и имеет также доступ к идентификаторам внешней функции.
>>> def f1(x,y): z=2 def f2(x): return x**z return f2(x)*y
>>> f1(4,3)
48
У функций, как объектов, имеется множество атрибутов. Обращение к ним выполняется указанием названия атрибута через точку после имени функции.
Например, атрибут __name__ (два подчеркивания) содержит имя функции, а атрибут __doc__ – строку документирования.
>>> prod.__doc__
' произведение элементов'
Список всех атрибутов функции можно получить с помощью команды dir
(имя_функции)
Модулем в языке Python называется произвольный py–файл. Любой файл может импортировать другой модуль, получая, таким образом, доступ к функциям и переменным внутри импортированного модуля.
Откройте текстовый редактор и создайте следующий файл.
# модуль testmod.py def plus(x,y): return x+y def mult(x,y): return x*y
PiNumber=3.141592
Этот файл содержит две функции и одну константу. Сохраните его под именем testmod.py.
Теперь создайте файл, в который импортируйте файл testmod.py, и в котором будем вызывать его переменную и функции.
# файл test.py import testmod zp=testmod.plus(5,6)

61 print(zp) zm=testmod.mult(4,8) print(zm) print(testmod.PiNumber)
Сохраните этот файл под именем test.py в той же папке, что и предыдущий файл.
После импортирования файла можно получить доступ к функциям и переменным, определенным внутри него. Доступ выполняется путем указания имени функции (или переменной) через точку после имени модуля: testmod.plus(),testmod.mult() и testmod.PiNumber. При импортировании название модуля не должно содержать расширения имени и путь к файлу.
Запустите файл test.py на выполнение любым способом (из интегрированного текстового редактора командой F5 или двойным щелчком мыши по имени файла). Если ошибок не было, то результат работы программы должен отобразиться в окне исполнительной системы.
Теперь посмотрите на содержимое папки, в которой сохранены файлы.
Внутри нее автоматически был создан каталог __pycache__ с файлом testmod.cpython-35.pyc. Он содержит откомпилированный код модуля testmod.py
. Этот код создается при первом импортировании модуля, и при всех последующих подключениях модуля testmod будет выполняться откомпилированный код. Исходный файл не будет использоваться, даже если его код изменить (пока не выйти из исполнительной системы Python и снова не зайти). Для повторной компиляции и загрузки модуля в той же сессии Python следует использовать функцию reload() модуля imp.
>>>from imp import reload
# импортирование функции reload()
>>>reload(testmod)
При использовании функции reload() следует знать, что идентификаторы, импортированные с помощью инструкции from, перезагружены не будут. В таком случае вам нужно перезагрузить интерпретатор Python.
Обратите также внимание на то, что после первой загрузки и компиляции модуля его исходный файл testmod.py больше не требуется. Это значит, что вы можете поставлять клиентам свои модули в откомпилированном виде, скрывая, тем самым, их код.
В приведенном выше примере, импортируемый модуль и тестовый файл были размещены в общей папке. В этом случае нет необходимости настраивать пути поиска модулей, т.к. каталог с исполняемым файлом автоматически добавляется в начало списка каталогов, в которых выполняется поиск импортируемых модулей. Каждый из таких каталогов является строкой, и имеется возможность просмотреть список этих строк.
>>> import sys
>>> sys.path
['', 'D:\\ProgramFiles\\Anaconda3\\python35.zip', ...,
'D:\\ProgramFiles\\Anaconda3\\lib\\site-packages\\Pythonwin']
У вас будет свой длинный список.

62
При поиске модуля список путей просматривается от начала. Как только в каком–либо каталоге обнаруживается модуль с заданным именем, поиск заканчивается.
Список путей, кроме каталогов со стандартными библиотечными модулями, содержит каталоги, заданные в переменной окружения
PYTHONPATH.
На время текущей сессии работы интерпретатора Python пути поиска можно расширить, используя методы и функции работы со списками.
Например, каталог с нашим файлом testmod.py можно добавить в конец списка следующим образом:
>>> sys.path.append(r"D: \W ork\Python\StartProgs")
# ваш путь поиска
Его можно было бы добавить и в начало списка путей поиска.
>>>sys.path.insert(0, r"D: \W ork\Python\StartProgs")
# ваш путь поиска
Теперь вы можете вызывать функции и постоянные этого модуля из командной строки.
>>> import testmod
>>> testmod.plus(5,6)
11
>>> testmod.mult(4,8)
32
>>> testmod.PiNumber
3.141592
Обратите внимание на модификатор r, стоящий перед строкой каталога. Он нужен для того, чтобы специальные последовательности символов внутри строки не интерпретировались как спецсимволы. Если модификатор не использовать, т.е. использовать обычные строки, то необходимо удвоить каждый слэш в пути, например,
>>> sys.path.append( "D:\\W ork\\Python\\StartProgs")
# ваш путь поиска
Каждый модуль является объектом и его имя можно присвоить другой переменной. После этого обращаться к атрибутам и методам модуля можно посредством этого нового имени (через точку).
>>> tm=testmod
>>> tm.mult(4,5)
20
Получить список всех атрибутов и методов модуля позволяет функция dir().
>>> dir(testmod)
['PiNumber', '__builtins__', '__cached__', '__doc__', '__file__',
'__loader__', '__name__', '__package__', '__spec__', 'mult',
'plus']
Атрибут __name__ содержит имя выполняемого модуля. Обычно, запускаемый модуль, имеет имя __main__, а импортируемый – имя своего файла.
>>> tm.__name__
'testmod'
В коде выполняемого модуля к атрибуту __name__ можно обращаться по имени без использования какого–либо объекта.

63
Использовать имя модуля в виде строки нельзя.
>>> md='testmod'
>>> import md
Ошибка!
Чтобы подключить модуль, название которого содержится в строке, следует использовать функцию __import__(строка_имени_модуля).
>>> m =__import__(md)
>>> m.__name__
'testmod'
Для доступа ко всем идентификаторам модуля без использования его имени, используется команда: from имя_модуля import *
Например,
>>> from testmod import *
>>> plus(8,9)
17
>>> mult(8,9)
72
В этом случае идентификаторы, названия которых начинаются с символа подчеркивания, не импортируются.
У модулей есть атрибут __all__. Он содержит список идентификаторов модуля, которые будут импортироваться, если будет использоваться форма from имя_модуля import *
. Идентификаторы в этом списке указываются в виде строк. Рассмотрим пример.
Добавьте в конце модуля testmod.py строку
__all__=['plus','PiNumber'] и сохраните файл с тем же именем (первоначальный код модуля testmod.py приведен ранее). Закройте вашу исполнительную систему и снова откройте ее
(в Spider вы можете перезагрузить исполнительную консоль). Затем выполните команды
>>> import sys
>>> sys.path.insert(0, r"D:\W ork\Python\StartProgs")
# ваш путь поиска
>>> from testmod import *
>>> plus(6,7)
13
>>> mult(6,7)
Ошибка!
>>> PiNumber
3.141592
Как видите, функция plus() и переменная PiNumber загрузились, а функция mult() – нет. Можно посмотреть список всех загруженных идентификаторов
>>> print(list(vars().keys()))
[..., '__loader__', 'PiNumber', 'sys', '__IDLE_eventloop_set',
'__builtins__', '__spec__', '__name__', '__package__', 'plus',
'__doc__']

64
У вас будет свой список, но в нем будут присутствовать строки 'PiNumber' и 'plus'.
Модули в Python можно объединять в пакеты. Пакетом называется каталог с модулями, распределенными по подкаталогам, в каждом из которых должен присутствовать файл __init__.py. Он является файлом инициализации и выполняется один раз при первом обращении к модулям соответствующего подкаталога, и может быть пустым.
В вашем рабочем каталоге создайте следующую структуру подкаталогов и файлов в них: main.py dir1\
__init__.py testmod.py dir2\
__init__.py testmod.py test2.py
Пусть содержимое файлов __init__.py будет одинаковым.
# файл __init__.py print(“Инициализация из ”,__name__)
Код модуля testmod.py приведен выше. Мы только переместим его в каталог dir1, и еще создадим копию в каталоге dir2. Код файла test2.py приведен ниже.
# файл test2.py msg=”Модуль {}”.format(__name__)
Теперь выполните команды
>>> import sys
>>> sys.path.insert(0, r"D:\W ork\Python\StartProgs")
# ваш путь поиска
>>> import dir1.testmod as m1
# инициализация из каталога dir1
Инициализация из dir1
>>> m1.plus(7,9)
# функция plus() из модуля dir1\testmod.py
16
>>> from dir1 import testmod as m2
>>> print(m2.mult(7,9))
# функция mult() из модуля dir1\testmod.py
63
Импорт модулей из каталога ..\dir1\dir2 выполняется следующим образом.
>>> import dir1.dir2.testmod as m3
# инициализация из каталога dir1\dir2
Инициализация из dir1.dir2
>>> m3.plus(6,15)
# функция plus() из модуля dir1\dir2\testmod.py
21
>>> import dir1.dir2.test2 as m4
>>> m4.msg
# переменная msg из модуля dir1\dir2\test2.py
'Модуль dir1.dir2.test2'

65
Как видите, при первом обращении к каталогу dir1 автоматически выполнился файл dir1\__init__.py, а при первом обращении к каталогу dir1\dir2 – файл dir1\dir2\__init__.py.
Таким образом, чтобы импортировать модуль из вложенного каталога пакета, необходимо указать путь к нему, перечислив имена каталогов через точку. Если используется инструкция import, то после имен каталогов через точку нужно указать имя модуля.
>>>import dirl.dir2.testmod
Использовать такой длинный идентификатор неудобно, поэтому в Python предусмотрена возможность создания псевдонимов, которые указываются после ключевого слова as.
>>> import dir1.dir2.test2 as m4
Инструкция from позволяет импортировать сразу несколько модулей пакета. Для этого внутри файла инициализации _init_.py в атрибуте __all__ необходимо указать список модулей, которые будут импортироваться с помощью команды from пакет import *. Например,
# файл __init__.py из каталога dir1\dir2
__all__ = [ "testmod", "test2"]
Описанные правила импортирования касаются случая, когда импорт выполняется из основной программы или командной строки. Но иногда приходится выполнять импорт между модулями пакета. Чтобы импортировать модуль, расположенный в том же каталоге, перед названием модуля указывается точка. from .module import *
Для импортирования модуля, расположенного в родительском каталоге, перед названием модуля указываются две точки. from ..module import *
Если необходимо обратиться уровнем выше, то указываются три точки. from ...module import *
Чем выше уровень, тем больше точек необходимо указать.