Главная страница
Навигация по странице:

  • IPython и Jupyter QtConsole

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


    Скачать 6.2 Mb.
    НазваниеВведение в научный Python
    Дата09.01.2020
    Размер6.2 Mb.
    Формат файлаpdf
    Имя файлаВведение в научный Python-1.pdf
    ТипДокументы
    #103229
    страница2 из 22
    1   2   3   4   5   6   7   8   9   ...   22
    _модуля.имя_функции(...).
    >>> import math
    >>> math.exp(1.0)
    2.718281828459045
    Используя функцию dir(имя_модуля) можно узнать имена функций, которые доступны из этого модуля.
    >>> dir(math)
    ['__doc__', '__loader__', ..., 'acos', 'acosh', 'asin', 'asinh',
    'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh',
    'degrees', 'e', 'erf', 'erfc', 'exp', '..., 'pi', 'pow',
    'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
    Имена с двумя подчеркиваниями являются внутренними. Все остальные – это функции, а также константы такие, как π и e.
    >>> math.pi
    3.141592653589793
    >>> math.cos(math.pi)
    -1.0
    >>> math.log(math.e)
    1.0
    Можно (и рекомендуется) импортировать только те функции, которые вы собираетесь использовать. Для этого нужно указать их имена в команде from имя_модуля import имя_функции, имя_функции,...
    В этом случае перед именем функции (или константы) имя модуля указывать не требуется. Например,
    >>>from math import sin,pi
    >>>pi
    3.141592653589793
    >>>sin(pi/2)
    >>>1.0
    Для импорта всех функций модуля можно использовать команду
    >>>from math import *

    10
    При импорте функции из модуля ей можно назначить другое имя. В этом случае одновременно с добавлением функции создается ее новое имя.
    Например
    >>> from math import factorial as f
    >>> f(5)
    120
    Python умеет работать с комплексными числами. Для записи мнимой части используется j (а не i). При этом операция умножения перед мнимой единицей не используется. Например, запись x=1-2*j приведет к ошибке.
    >>> x=3+4j
    >>> y=4-7j
    >>> z=x*y
    >>> z
    (40-5j)
    >>> z/y
    (3+4.000000000000001j)
    >>> x**2
    (-7+24j)
    Прежде, чем продолжать дальше, скажем несколько слов о переменных и объектах Python. Каждая переменная хранит информацию о каком–либо объекте. Каждый объект относится к какому-нибудь типу данных. Типы в
    Python называются классами, и пользователь имеет возможность создавать собственные классы. Фактически класс представляет собой коллекцию данных и функций, которые называются атрибутами и методами. Атрибут – это переменная, метод – это функция. В языке Python все является объектами: числа, списки, функции, модули и т.д. Объект, созданный на основе некоторого класса, называется экземпляром класса. Экземпляры одного класса отличаются один от другого значениями своих атрибутов. Для доступа к объекту используются переменные. Переменная создается при присваивании ей значения с помощью знака равенства '='. Во время присваивания в переменной сохраняется ссылка на объект (адрес объекта в памяти компьютера). При доступе к атрибутам и методам используется точка, которая разделяет имя объекта/переменной и имя атрибута или метода. Удалить переменную из пространства имен исполнительной системы (очистить область памяти, занимаемую переменной, и удалить ссылку на эту область) можно с помощью команды del: del Имя1[, ... , ИмяN].
    Например,
    >>> х = 10; х
    10
    >>> del х; х
    Ошибка!!!
    Комплексная переменная z, созданная выше, тоже является объектом, и она имеет свои атрибуты и методы. Например, в выражении z.real, real — это атрибут объекта z, а z.conjugate() – метод. Следующие команды вычисляют

    11 вещественную и мнимую часть комплексной переменной z, а также сопряженное значение. Обычно атрибут возвращает уже хранящееся в объекте значение, а метод вычисляет что – то новое.
    >>> z.real
    40.0
    >>> z.imag
    -5.0
    >>> z.conjugate()
    (40+5j)
    Другие функции, предназначенные для работы с комплексными переменными, собраны в модуле cmath:
    >>> from cmath import sqrt
    >>> sqrt(z)
    (6.336848141682612-0.39451789661100817j)
    В Python пользователь может создавать свои функции. Создание функции начинается со слова def, за которым следует имя функции, аргументы в круглых скобках и двоеточие. Затем на новой строке с отступом начинаются инструкции. Оператор return значение возвращает из функции значение и является командой выхода.
    >>> def f(x): return x**2
    >>> f(3)
    9
    Здесь была использована многострочная команда, признаком которой является символ „:„ (двоеточие). После ввода двоеточия и нажатия клавиши
    Enter курсор переходит на следующую строку. В Python Shell автоматически вставляется отступ (в консоли Spyder вставляется троеточие и отступ следует делать самостоятельно) и интерпретатор ожидает дальнейшего ввода
    (продолжения многострочной команды). Чтобы сообщить о конце ввода многострочной команды, необходимо дважды нажать клавишу
    Enter
    Многострочные команды встречаются при программировании циклов, в условных операторах и в ряде других случаев. Следующий пример демонстрирует использование оператора цикла.
    >>> for n in range(1,3): print(n)
    1 2
    Результаты работы программы можно вывести с помощью функции print(), общий формат которой имеет следующий вид: print([Объекты][,sep=„ „][,end =„\n„] [,file=sys.stdout])
    Здесь элементы, указанные в квадратных скобках, являются необязательными.
    Параметр sep задает строку–разделитель между объектами, а параметр end задает строку (или один символ), которая выводится после последнего объекта.
    Функция print() преобразует свой аргумент в строку и отображает его в окне

    12 исполнительной системы. После вывода строки автоматически добавляется символ перевода строки (если не указано другое значение в параметре end).
    >>> print ("Строка 1"); print ("Строка 2")
    Строка 1
    Строка 2
    Если необходимо вывести результат на той же строке, то объекты указываются через запятую.
    >>> print("Cтpoкa 1", "Строка 2")
    Строка 1 Строка 2
    Между выводимыми строками автоматически вставляется пробел. С помощью параметра sep можно указать другой символ–разделитель.
    >>>print("Cтpoкa1", "Строка2", sep="")
    Строка 1Строка 2
    Здесь мы вывели строки без пробела между ними. После вывода данных в конце добавляется символ новой строки. Если последующий вывод должен продолжиться в той же строке, то в параметре end следует указать другой символ, например, пробел.
    >>>print("C
    тpoкa 1", "Строка 2", end=" "); print ("Строка 3")
    Строка 1 Строка 2 Строка 3
    Если необходимо вывести большой блок текста, то его следует разместить между утроенными кавычками. В этом случае текст сохраняет свое форматирование.
    >>> print("""Строка 1
    Строка 2
    Строка 3""")
    Строка 1
    Строка 2
    Строка 3
    До сих пор все наши примеры состояли из нескольких строк, и все команды записывались и выполнялись в окне Python Shell. Опишем некоторые его особенности, связанные с вводом и выполнением команд.
    Если ввести несколько первых букв инструкции и нажать комбинацию клавиш
    Ctrl+Пробел
    , то будет отображен список, из которого можно выбрать нужное имя. Если при открытом списке дальше вводить буквы, то список имен будет фильтроваться, и показываться будут идентификаторы, начинающиеся с этих букв. Выбирать идентификатор необходимо с помощью клавиш управления курсором „↑„ и „↓„. После выбора не следует нажимать клавишу
    Enter
    , иначе это приведет к выполнению команды. Просто вводите инструкцию дальше, а список закроется.
    Для вставки последней введенной инструкции Python Shell можно использовать комбинацию клавиш
    Alt+P
    (это не работает в консоли Spyder).
    Каждое следующее нажатие этих комбинаций клавиш будет вставлять предыдущую инструкцию, а
    Alt
    –N
    – следующую. Для еще более быстрого повторного ввода инструкции следует предварительно ввести ее первые буквы.

    13
    В этом случае перебираться будут только инструкции, начинающиеся с этих букв. Комбинация клавиш
    Ctrl
    – z отменяет в Python Shell последний ввод.
    Для того, чтобы получить справку о функции, достаточно написать help(имя_функции) или help(имя_модуля.имя_функции).
    Обычный командный режим работы (ввод одной или нескольких строк) не очень удобен. Поэтому в Python предусмотрена возможность записывать инструкции в текстовый файл и затем выполнять его. Имя этого файла должно иметь расширение py (или pyw для программ с оконным интерфейсом). Среда
    IDLE содержит встроенный текстовый редактор, специально предназначенный для создания Python программ. Для примера создадим и выполним программу, которая выводит текст "Привет, мир!". В Python Shell для создания файла с программой в меню
    File выберите пункт
    New File
    . В открывшемся окне редактора введите текст рrint ("Привет, мир !")
    Сохраните файл с именем, например, hello.py.
    Запускается программа на выполнение выбором в окне редактора пункта меню
    Run
    – Run Module или нажатием клавиши F5. Результат выполнения будет отображен в окне Python Shell. Запустить программу можно также с помощью двойного щелчка мыши по имени файла. В этом случае результат отобразится в консоли Windows. Однако после вывода окно консоли сразу закроется и вы, скорее всего, ничего не успеете заметить. Чтобы предотвратить автоматическое закрытие окна, в программу необходимо добавить вызов функции input(), которая будет ожидать нажатия клавиши
    Enter и не даст программе сразу завершиться.
    Аналогично создается и выполняется программа в Spyder. Для этого активируйте окно редактора Spyder, щелкнув мышью внизу по закладке Editor
    (на рис. 1.3 она видна слева внизу). Откроется окно редактора с пустым файлом. Введите в нем текст программы, сохраните файл, и запустите на выполнение командой меню
    Run
    – Run
    (или F5).
    1.2
    Среды разработки и выполнения Python программ.
    Мы уже говорили, что в стандартный комплект поставки Python входит интегрированная среда разработки IDLE, в которой редактировать и выполнять программы удобнее, чем в консоли. Краткое (и не полное) описание ее возможностей было приведено в предыдущем параграфе. Однако жизнь не стоит на месте и в последние годы появилось много новых интегрированных сред, предназначенных для создания, редактирования и выполнения Python программ. Здесь мы опишем некоторые из них.
    IPython и Jupyter QtConsole. IPython (Interactive Python, улучшенная консоль
    Python) предоставляет расширенный список возможностей по редактированию команд. Вместо символов приглашения консоли „>>>‟, делящих сессию работы с Python на части, IPython делит документ на последовательность ячеек.
    Некоторые из них содержат код, другие текст и графику. Ячейки с кодом

    14 помечаются метками In[n]. Введя в такой ячейке команду и нажав клавишу
    Enter
    , вы отправляете код интерпретатору Python. Результат появляется в поле вывода, которое помечается меткой Out[n].
    Еще одна усовершенствованная консоль включена в состав пакета
    Anaconda с названием Jupyter QtConsole. Если вы установили пакет Anaconda, то обе программы вы найдете в меню Все программы – Anaconda3 (64–
    bit)
    В интерпретаторе Jupyter QtConsole команды выполняются нажатием комбинации клавиш
    Shift
    – Enter
    (для однострочных инсрукций можно также использовать
    Enter
    ). Отличие в редактировании команд в обеих консолях небольшое и мы кратко опишем работу с программой Jupyter QtConsole.
    Запустите ее.
    Всѐ, что можно было делать в Python Shell, можно делать и здесь: выполнять команды Python, пользоваться справкой, импортировать модули. Но есть несколько дополнительных возможностей. Рассмотрим некоторые из них.
    1. Быстрый просмотр информации по объекту. Добавив вопросительный знак к имени объекта, вы получите информацию о его типе, классе, пространстве имѐн, а также строку документации.
    In[1]: s = '
    строка'
    In[2]: s?
    Более полную информацию можно получить, добавив два вопросительных знака.
    Команда pdef fun (или %pdef fun) подскажет, какие аргументы нужны для вызова функции или метода fun.
    In[3]: pdef list
    Посмотреть документацию по функции можно командой pdoc fun. Вывести информацию по функции можно командой pinfo fun. Часто доступен

    15 исходный код функции. Чтобы его посмотреть, можно использовать команду psource fun.
    2. Функции автодополнения команд. Введя имя объекта, точку и, нажав клавишу
    Tab
    , вы получите список всех атрибутов и методов объекта.
    Введя первую букву желаемого атрибута или метода и опять нажав
    Tab
    , вы получите сокращенный список только тех атрибутов и методов, которые начинаются с этой буквы. Например, введите после точки букву „c‟ и вы увидите следующее:
    Если ввести следующую букву „e‟ и нажать
    Tab
    , то ввод будет завершен и появится инструкция s.center, которая представляет имя метода s.center(width). Если в качестве аргумента ввести число, например 20, то метод создаст строку длиной 20 символов и в ее середине поместит строку s.
    Если сразу ввести несколько первых букв команды, а вариант автозавершения один, то нажатие
    Tab автоматически отобразит соответствующую команду в поле ввода.
    Автодополнение работает почти везде, где оно имеет смысл. Например, команда import a
    <
    Tab
    > отобразит список модулей, имена которых начинаются с буквы „a‟, и которые могут быть импортированы.
    3. Встроенные «магические» команды. Многие из них выполняют те же функции, которые имеются в консоли. Например, команда %cd покажет текущий каталог, а команда %cd „dir‟ сделает текущей папку „dir‟. Команда
    %load имя_файла загрузит код в окно консоли. В следующем примере после выполнения команды %load 'hello.py' нужно еще дважды нажать
    Enter
    , чтобы завершить выполнение кода загруженного файла.
    In[1]:
    %cd
    „D:\Work\Python\StartProgs‟
    D:\Work\Python\StartProgs
    In[2]:
    %load „hello.py‟
    In[3]:
    # load „hello.py‟
    ...: print
    (“Привет мир!”)

    16
    ...: input()
    ...:
    Привет мир!
    Out[3]: „‟
    In[3]:
    Другие магические команды служат для расширения возможностей IPython.
    Обычно такие команды начинаются с символа „%‟ (процент), за которым следует имя команды. Но если нет конфликта с глобальными именами, то команды можно вводить без процента. Команда
    %del имя_переменной удаляет переменную из пространства имен IPython. Команда
    %reset
    (без аргументов) очищает пространство имен. Команда
    %who выводит список имен доступных переменных. У нее есть опции, например, чтобы вывести переменные только типа int, следует написать:
    %who int
    Команда
    %whos печатает имена, типы и значения всех объектов из пространства имен.
    Чтобы переменная была доступна после перезапуска IPython, ее нужно сохранить в профайле командой %store имя_переменной. Чтобы посмотреть все сохраненные переменные, надо выполнить команду store без параметров.
    Для восстановления переменных, которые были ранее сохранены в профайле, надо выполнить команду
    %store
    –r
    Проверить, что переменные восстановились, можно командой %whos. Для очистки всего, что находится в профайле, используется команда
    %store
    –z
    При следующем запуске IPython пространство имен будет пустым.
    Полный список магических команд можно получить с помощью команды
    %lsmagic
    Для получения справки по конкретной магической команде достаточно поставить знак вопроса в конце ее имени.
    %run?
    Обратите внимание, что в Jupyter QtConsole справка открывается в дополнительном окне, расположенном поверх командного окна интерпретатора. Чтобы вернуться в окно документа следует нажать клавишу
    Esc
    . В стандартной консоли Ipython справка отображается в ее окне.
    Если напечатать % (процент) и нажать клавишу
    Tab
    , то система автодополнения также выведет полный список магических команд. Он весь не поместится в окне, но вы можете передвигаться по нему, нажимая клавишу
    Tab
    Опишем еще несколько часто используемых магических команд.
    Команда %run имя_файла запускает файл на выполнение.

    17
    In[1]:
    %cd 'D:\Work\Python\StartProgs'
    D:\Work\Python\StartProgs
    In[2]: run hello.py
    Привет мир!
    Команда %save имя_файла номера_строк сохраняет в файл команды входных полей, номера которых перечислены.
    In[3]: a=3; b=4; print(a**b)
    81
    In[4]:
    %save 'testsave.py' 3
    The following commands were written to file `testsave.py`: a=3; b=4; print(a**b)
    Файл сохраняется в текущем каталоге.
    Вот пример сохранения нескольких строк кода.
    In[10]: from math import *
    In[11]: a=3; b=4; c=a**b
    In[12]: x=pi/6; y=sin(x)
    In[13]: print(c,y)
    81 0.49999999999999994
    In[14]:
    %save 'testsave2.py' 10-13
    The following commands were written to file `testsave2.py`: from math import * a=3; b=4; c=a**b x=pi/6; y=sin(x) print(c,y)
    Здесь в файл testsave2.py были сохранены команды входных ячеек
    In[10] – In[13].
    Команда %%writefile имя_файла сохраняет содержимое (код) своей ячейки в файл.
    In[13]:
    %%writefile 'testsave3.py'
    x=6;
    y=5;
    z=x*(y+2)
    Writing testsave3.py
    Кстати, для того, чтобы создать в Jupyter QtConsole такую многострочную ячейку, в конце первой строки нужно нажать комбинацию клавиш
    Ctrl
    – Enter
    , а последующие строки завершать нажатием клавиши
    Enter
    . Для завершения ввода и выполнения кода ячейки следует нажать комбинацию клавиш
    Shift

    Enter
    У команды %%writefile имеется опция „-a‟ или „--append’, которая позволяет добавлять код ячейки в уже существующий файл. Добавление выполняется без вставки вспомогательных символов (пробелов или переводов строк) так, что первая инструкция ячейки «пристыковывается» к последним символам файла. Чтобы этого не происходило, перед сохраняемым кодом можно вставлять пустую строку.

    18
    In[15]:
    %%writefile -a 'testsave3.py'
    z=x*(y+2**x)
    Appending to testsave3.py
    Обратите внимание на то, что магическая команда %%writefile содержит впереди два символа процента.
    Имеется большое количество других магических команд. С ними вы можете познакомиться самостоятельно по справочной системе.
    4. Механизм истории команд. Кроме традиционных стрелок ↑ и ↓ (стрелка вверх и вниз), последовательно пролистывающих введенные ранее команды, можно просмотреть список предыдущих команд, используя магическую команду %history. Кстати, команды ↑ и ↓ (стрелка вверх и вниз) можно использовать после введения нескольких букв. Тогда пролистывание будет выполняться только по предыдущим командам, которые начинались с этих букв.
    Если последняя команда возвращала результат, то обратиться к нему
    (результату) можно, используя символ „_‟ (одно подчеркивание). Можно использовать „__‟ и „___‟ (двойное и тройное подчеркивание) для обращения к предпоследнему и пред-предпоследнему результатам.
    In[1]: from math import sqrt
    In[2]: a=3
    In[3]: b=4
    In[4]: a**b
    Out[4]: 81
    In[5]: sqrt(_)
    # одно подчеркивание
    Out[5]: 9.0
    In[6]: sqrt(sqrt(__))
    # два подчеркивания
    Out[6]: 3.0
    Переменная „_i‟ (одинарное подчеркивание + i) содержит строку последней команды.
    In[7]: a**b
    Out[7]: 81
    In[8]: len(_i)
    Out[8]: 4
    Помимо прочего, метка ячейки ввода In[n] содержит строку своей команды, а метка Out[n] содержат результат. Доступ к результату поля вывода Out[n] позволяет использовать его значение в последующих командах.
    In[9]:
    Out[8]**3
    Out[9]: 64
    Команда %recall повторяет предыдущую команду, а инструкция %recall n повторяет команду из поля ввода с номером n (из ячейки In[n]).
    In[10]:
    %recall 7
    In[11]: a**b

    19
    Команда %recall n1-n2 повторяет команды из полей ввода In[n1] –
    In[n2].
    In[11]: a=3
    In[12]: b=4
    In[13]: c=a**b+1
    In[14]: print(c)
    82
    In[15]:
    % recall 11-14
    In[16]: a=3
    b=4 c=a**b+1
    print(c)
    5. Дополнительные возможности.
    Магическая команда %pprint включает и выключает режим «красивой» печати. Она полезна при совместном использовании с командой
    %precision N, которая задает точность при отображении вещественных чисел
    (N – количество десятичных цифр после десятичной точки).
    In[17]:
    %pprint
    # включить режим «красивой» печати
    Pretty printing has been turned ON
    In[18]: from math import pi
    In[19]:
    %precision 0
    # отображать 0 десятичных цифр
    Out[19]: '%.0f'
    In[20]: pi
    Out[20]: 3
    # приближение числа π
    In[21]: a=pi**2; a
    # вычисление с процессорной точностью, но
    Out[21]: 10
    # отображение 0 десятичных цифр
    In[22]:
    %precision 2
    # отображать 2 десятичных цифры
    Out[22]: '%.2f'
    In[23]: a
    # показать число с точностью 2 – х десятичных цифр
    Out[23]: 9.87
    In[24]:
    %precision
    # включить точность по умолчанию
    Out[24]: '%r'
    In[25]: a
    # показать число с точностью по умолчанию
    Out[25]: 9.869604401089358
    In[26]: pi**2
    # сравнить результаты
    Out[26]: 9.869604401089358
    В приведенном примере значение a вычислялось как
    2

    при установленной точности 0 десятичных цифр, отобразилось значение 10, но в памяти вычисление выполнялось с процессорной точностью. Поэтому для печати значения переменной a при другой точности пересчет не потребовался.
    Опции %i и %e включают режимы отображения целой части и экспоненциальной формы представления чисел.

    20
    In[27]:
    %precision %i
    Out[27]: '%i'
    In[28]: a
    Out[28]: 9
    In[29]:
    %precision %e
    Out[29]: '%e'
    In[30]: a
    Out[30]: 9.869604e+00
    In[31]:
    %pprint
    # выключить режим «красивой» печати
    Pretty printing has been turned OFF
    Имеется еще одна важная магическая команда %matplotlib, которая управляет способом отображения графических команд модуля matplotlib. Ее поведение может немного различаться для различных версий консоли IPython.
    Построим график в стандартной IPython консоли.
    In[1]: from matplotlib.pylab import *
    In[2]: plot([1,-2,4,8,7,-3,5,3],linewidth=3);
    In[3]: show()
    # следующее окно слева
    Инструкция plot() строит график в памяти, а команда show() отображает его в отдельном окне. При этом приглашение на ввод следующей команды не появится, пока вы не закроете графическое окно. Ели перед приведенным выше кодом выполнить команду
    In[4]:
    %matplotlib qt то инструкцию show() можно не использовать, графическое окно откроется автоматически и в документе появится метка In[n] новой ячейки. Можно выполнить еще несколько графических команд и их результат отобразится в том же (открытом) графическом окне.
    In[5]: plot([-1,2,-4,-8,-7,3,-5,-3], linewidth=3)
    In[6]: plot([5,4,-3,-2,7,4,-1,3], linewidth=3)
    In[7]: grid(True)
    Будет построено несколько кривых и добавлены элементы оформления (см. предыдущий рисунок справа). Пока графическое окно открыто все графические команды работают с ним.
    График можно сохранить в файл, используя командную кнопку
    Save the figer этого окна.

    21
    Поведение среды Jupyter QtConsole после команды
    %matplotlib qt такое же, как у стандартной консоли IPython. Однако теперь доступна еще инструкция:
    %matplotlib inline
    Она включает режим отображения графики прямо в текущем документе.
    Конечно, для того, чтобы графические функции были доступны, их следует импортировать. from matplotlib.pylab import *
    Тогда команда plot([1,-2,4,8,7,-3,5,3],linewidth=5); построит график ломаной прямо в документе. Если в ячейке ввести несколько графических команд, то результат их работы отобразится на одном графике.
    In[12]:
    plot([1,-2,4,8,7,-3,5,3],linewidth=5);
    plot([-1,2,-4,-8,-7,3,-5,-3], linewidth=5)
    plot([5,4,-3,-2,7,4,-1,3], linewidth=5)
    grid(True)
    Вы можете переключаться из режима „qt‟ в режим „inline‟ и обратно. В режиме „qt‟ команда show() показывает график в отдельном окне, а в режиме
    „inline‟ никак себя не проявляет – все графики будут встроенными в документ.
    Кроме опций „qt‟ и „inline‟ у магической команды %matplotlib могут быть и другие опции, название которых можно узнать из справочной системы. Однако их «работоспособность» зависит от версии среды IPython и от ее настроек.
    1   2   3   4   5   6   7   8   9   ...   22


    написать администратору сайта