Никита Волков
Модуль - это просто файл типа .py, содержащий последовательность операторов питона. Его можно использовать двумя способами: либо запустить как программу, либо импортировать в другой модуль, чтобы сделать доступными определённые там функции и переменные. При импортировании все операторы модуля выполняются от начала до конца, включая определения функций и классов и присваивания переменным. Впрочем, при повторном импортировании модуль не выполняется. Если Вы его изменили и хотите импортировать изменённую версию, нужно приложить специальные усилия.
In [1]:
import math
math, type(math)
Out[1]:
Модуль имеет своё пространство имён. Оператор import math вводит объект типа модуль math в текущее пространство имён. Имена, определённые в модуле, при этом в текущем пространстве имён не появляются - их нужно использовать как math.что_то. Функция dir возвращает список имён в модуле (как и в классе или объекте).
In [2]:
dir(math)
Out[2]:
In [3]:
math.__doc__
Out[3]:
In [4]:
math.pi, math.exp
Out[4]:
Встроенные функции, классы и т.д. языка питон живут в модуле builtins.
In [5]:
import builtins
dir(builtins)
Out[5]:
Если Вам лень полностью писать имя модуля перед каждым использованием функции из него, можно использовать as и задать ему краткое имя.
In [6]:
import random as r
r
Out[6]:
In [7]:
dir(r)
Out[7]:
In [8]:
[r.random() for i in range(10)]
Out[8]:
Такая форма оператора import вводит перечисленные имена (функции, переменные, классы) из модуля в текущее пространство имён.
In [9]:
from sys import path
Переменная path - это список имён директорий, в которых оператор import ищет модули. В начале в него входит '' - директория, в которой находится текущая программа (или текущая директория в случае интерактивной сессии); директории, перечисленные в переменной окружения PYTHONPATH (если такая переменная есть); и стандартные директории для данной версии питона. Но это обычный список, его можно менять стандартными языковыми средствами. Например, ревнители безопасности считают, что опасно включать текущую директорию в path - если пользователю в его директорию кто-нибудь подсунет зловредную версию math.py, а программа пользователя выполнит import math, то этот модуль выполнится, и может, скажем, удалить все файлы этого пользователя. Такие ревнители могут сделать path=path[1:].
In [10]:
path
Out[10]:
Если Вам лень писать каждый раз длинное имя функции из модуля, можно дать ему короткий псевдоним.
In [11]:
from math import factorial as f
In [12]:
f(100)
Out[12]:
Для самых ленивых есть оператор from ... import *, который импортирует в текущее пространство имён все имена, определённые в модуле. Обычно это плохая идея - Вы засоряете текущее пространство имён, и даже не знаете, чем. Такую форму импорта разумно использовать, когда Вы импортируете свой модуль, про который Вы всё знаете. Ну или в интерактивной сессии, когда Вы хотите попробовать всякие функции из какого-нибудь модуля. Но не в программе, которая пишется всерьёз и надолго.
Например, в текущей директории есть файл fac.py. Мы работаем в ipython, который предоставляет всякие удобства для интерактивной работы. Например, можно выполнить shell команду, если в начале строки поставить ! (только не пробуйте этого делать в обычном интерпретаторе питон). Так что легко распечатать этот файл. В нём определена одна функция fac.
In [13]:
!cat fac.py
In [14]:
from fac import *
fac(10)
Out[14]:
Файл fac.py показывает типичное устройство любого файла на питоне. Первая строка позволяет запустить такой файл, если у него установлен бит, позволяющий исполнять его текущему пользователю. Почему не просто #!/usr/bin/python3 ? Потому что на некоторых машинах питон может быть в /usr/local/bin или ещё где-то; стандартная unix-утилита env (предположительно) всегда живёт в /usr/bin. Она позволяет установить какие-нибудь переменные окружения, а затем, если есть аргумент - имя программы, запускает эту программу в этом модифицированном окружении; если такого аргумента нет, просто печатает это окружение. Так что, вызвав просто env, Вы получите список всех текущих переменных окружения с их значениями. В данном случае вызывается /usr/bin/env python3, то есть никакие изменения окружения не произвадятся, и env вызывает python3, расположенный где угодно в $PATH. Почему python3? python может быть симлинком либо на python2, либо на python3; в свою очередь, python3 может быть симлинком, скажем, на python3.5. Если наша программа предназначена для питона 3, то в первой строке лучше указывать python3, иначе на некоторых машинах могут возникнуть неприятные сюрпризы.
Дальше следует док-строка модуля. Потом определения всех функций, классов и т.д. Заключительная часть файла выполняется, если он запущен как программа, а не импортируется куда-то. В этой части обычно пишут какие-нибудь простые тесты определённых в файле функций. В данном случае используется sys.argv - список строк-аргументов командной строки. argv[0] - это имя программы, нас интересует переданный ей параметр, argv[1].
In [15]:
import fac
fac.__doc__
Out[15]:
Функция dir без аргумента возвращает список имён в текущем пространстве имён. Многие имена в этом списке определены ipython-ом; в сессии с обычным интерпретатором питон их бы не было.
In [16]:
dir()
Out[16]:
В локальном пространстве имён этой функции два имени.
In [17]:
def f(x):
y = 0
print(dir())
In [18]:
f(0)
В каждом модуле есть строковая переменная __name__, она содержит имя модуля. Главная программа (или интерактивная сессия) тоже является модулем, его имя __main__. Этим и объясняется вид оператора if, который стоит в конце файла fac.py.
In [19]:
__name__
Out[19]:
In [20]:
r.__name__
Out[20]:
Модули не обязательно должны размещаться непосредственно в какой-нибудь директории из sys.path; они могут находиться в поддиректории. Например, в текущей директории (включённой в path) есть поддиректория d1, в ней поддиректория d2.
In [23]:
!ls d1
In [24]:
!ls d1/d2
Мы можем импортировать модули m1 и m2 так.
In [25]:
import d1.m1
d1.m1.f1()
Out[25]:
In [26]:
import d1.d2.m2
d1.d2.m2.f2()
Out[26]:
Такое поддерево директорий с модулями можно превратить в пакет, который с точки зрения пользователя выглядит как единый модуль. Для этого нужно добавить файл __init__.py. Вот другое поддерево с теми же файлами m1.py и m2.py.
In [27]:
!ls p1
In [28]:
!ls p1/p2
Только добавлен файл __init__.py.
In [29]:
!cat p1/__init__.py
Теперь мы можем импортировать этот пакет.
In [30]:
import p1
Питон находит в sys.path директорию p1, содержащую __init__.py, и интерпретирует её как пакет. При импорте выполняется этот файл __init__.py, инициализирующий пакет. Все функции, переменные и т.д., определённые в этом файле (непосредственно или через импорт), становятся символами этого пакета. __init__.py может включать не все функции из модулей этого дерева директорий (и даже не все модули); символы, не определённые в __init__.py, недоступны после импорта пакета (конечно, пользователь всегда может импортировать любой модуль напрямую и получить доступ ко всем его символам).
In [31]:
p1.f1(), p1.f2()
Out[31]:
In [32]:
f = open('text.txt')
f, type(f)
Out[32]:
Получился объект f одного из файловых типов. Что с ним можно делать? Можно его использовать в for цикле, каждый раз будет возвращаться очередная строка файла (включая '\n' в конце; в конце последней строки текстового файла '\n' может и не быть).
In [33]:
for s in f:
print(s)
Теперь файл нужно закрыть.
In [34]:
f.close()
Такой стиль работы с файлом (f=open(...); работа с f; f.close()) на самом деле не рекомендуется. Гораздо правильнее использовать оператор with. Он гарантирует, что файл будет закрыт как в том случае, когда исполнение тела with нормально дошло до конца, так и тогда, когда при этом произошло исключение, и мы покинули тело with аварийно.
В операторе with может использоваться любой объект класса, реализующего методы __enter__ и __exit__. Обычно это объект-файл, возвращаемый функцией open.
In [35]:
with open('text.txt') as f:
for s in f:
print(s[:-1])
Метод f.read(n) читает n символов (когда файл близится к концу и прочитать именно n символов уже невозможно, читает меньше; в самый последний раз он читает 0 символов и возвращает ''). Прочитаем файл по 1 символу.
In [36]:
with open('text.txt') as f:
while True:
c = f.read(1)
if c == '':
break
else:
print(c)
Вызов f.read() без аргумента читает файл целиком (что не очень разумно, если в нём много гигабайт).
In [37]:
with open('text.txt') as f:
s = f.read()
s
Out[37]:
f.readline() читает очередную строку (хотя проще использовать for s in f:).
In [38]:
with open('text.txt') as f:
while True:
s = f.readline()
if s == '':
break
else:
print(s)
Метод f.readlines() возвращает список строк (опять же его лучше не применять для очень больших файлов).
In [39]:
with open('text.txt') as f:
l = f.readlines()
l
Out[39]:
Теперь посмотрим, чем же оператор with лучше, чем пара open - close.
In [40]:
def a(name):
global f
f = open(name)
s = f.readline()
n = 1 / 0
f.close()
return s
In [41]:
a('text.txt')
In [42]:
f.closed
Out[42]:
In [43]:
f.close()
Произошло исключение, мы покинули функцию до строчки close, и файл не закрылся.
In [44]:
def a(name):
global f
with open(name) as f:
s = f.readline()
n = 1 / 0
return s
In [45]:
a('text.txt')
In [46]:
f.closed
Out[46]:
Теперь всё в порядке.
Чтобы открыть файл на запись, нужно включить второй аргумент 'w'.
In [47]:
f = open('newtext.txt', 'w')
In [48]:
f.write('aaa\n')
Out[48]:
In [49]:
f.write('bbb\n')
Out[49]:
In [50]:
f.write('ccc\n')
Out[50]:
In [51]:
f.close()
Метод write возвращает число записанных символов.
Опять же, лучше использовать with.
In [52]:
with open('newtext.txt', 'w') as f:
f.write('aaa\n')
f.write('bbb\n')
f.write('ccc\n')
In [53]:
!cat newtext.txt
Эта функция копирует старый текстовый файл в новый. Если строки нужно как-нибудь обработать, в последней строчке вместо line будет стоять что-нибудь вроде f(line).
In [54]:
def copy(old_name, new_name):
with open(old_name) as old, open(new_name,'w') as new:
for line in old:
new.write(line)
In [55]:
copy('text.txt', 'newtext.txt')
In [56]:
!cat newtext.txt
В интерактивной сессии (или в программе, запущенной с командной строки) можно попросить пользователя что-нибудь ввести. Аргумент функции input - это приглашение для ввода (prompt). Можно использовать просто input(), тогда приглашения не будет. Но это неудобно, т.к. в этом случае трудно заметить, что программа чего-то ждёт.
In [57]:
s = input('Введите целое число ')
In [58]:
s
Out[58]:
In [59]:
n = int(s)
n
Out[59]:
Питон - интерпретатор, поэтому он может во время выполнения программы интерпретировать строки как куски исходного текста на языке питон. Так, функция eval интерпретирует строку как выражение и вычисляет его (в текущем контексте - подставляя текущие значения переменных).
In [61]:
s = input('Введите выражение ')
In [62]:
s
Out[62]:
In [63]:
eval(s)
Out[63]:
А функция exec интерпретирует строку как оператор и выполняет его. Оператор может менять значения переменных в текущем пространстве имён.
In [65]:
s = input('Введите оператор ')
In [66]:
s
Out[66]:
In [67]:
exec(s)
x
Out[67]:
Строка s может быть результатом длинного и сложного вычисления. Но лучше таких фокусов не делать, так как программа фактически становится самомодифицирующейся. Такие программы очень сложно отлаживать.
Для работы с путями к файлам и директориям в стандартной библиотеке существует модуль pathlib. Объект класса Path представляет собой путь к файлу или директории.
In [68]:
from pathlib import Path
Path() возвращает текущую директорию.
In [69]:
p = Path()
p
Out[69]:
Очень полезный метод resolve приводит путь к каноническому виду.
In [ ]:
p.resolve()
Путь может быть записан в совершенно идиотском виде; resolve его исправит.
In [ ]:
p=Path('.././/python')
p=p.resolve()
p
Статический метод cwd возвращает текущую директорию (current working directory).
In [ ]:
Path.cwd()
Если p - путь к директории, то можно посмотреть все файлы в ней.
In [ ]:
for f in p.iterdir():
print(f)
Если p - путь к директории, то p/'fname' - путь к файлу fname в ней (он, конечно, тоже может быть директорией).
In [ ]:
p2 = p/'python_2.ipynb'
p2
Существует ли такой файл?
In [78]:
p2.exists()
Out[78]:
Является ли он симлинком, директорией, файлом?
In [79]:
p2.is_symlink(), p2.is_dir(), p2.is_file()
Out[79]:
Части пути p2.
In [ ]:
p2.parts
Родитель - директория, в которой находится этот файл.
In [ ]:
p2.parent, p2.parent.parent
Имя файла, его основа и суффикс.
In [82]:
p2.name, p2.stem, p2.suffix
Out[82]:
Метод stat возвращает всякую ценную информацию о файле.
In [83]:
s = p2.stat()
s
Out[83]:
Например, его размер в байтах.
In [84]:
s.st_size
Out[84]:
В питоне можно работать с переменными окружения как с обычным словарём.
In [85]:
from os import environ
In [86]:
environ['PATH']
Out[86]:
In [87]:
environ['ABCD']
In [88]:
environ['ABCD'] = 'abcd'
In [89]:
environ['ABCD']
Out[89]:
Мы не просто добавили пару ключ-значение в словарь, а действительно добавили новую переменную к текущему окружению. Если теперь вызвать из питона какую-нибудь внешнюю программу, то она эту переменную увидит. Эта переменная исчезнет, когда закончится выполнение текущей программы на питоне (или интерактивная сессия).