Незамысловатый блог

О GCC, компиляции и библиотеках

noreply@blogger.com (Вий) — Fri, 03 Dec 2010 14:44:00 +0000

GCC - GNU Compiler Collection - набор компиляторов и сопутствующих утилит, разработанный в рамках движения GNU. GCC один из старейших Open Source проектов, первый релиз состоялся в 1985 году, автор сам Ричард Столлман. В исходном варианте поддерживал только язык C и аббревиатура GCC расшифровывалась как GNU C Compiler. Постепенно набор доступных языков расширялся, были добавлены компиляторы Fortran, C++, Ada. С уверенностью можно сказать, что современный мир Open Source обязан своим рождением GCC (по крайней мере без GCC он был бы другим). В настоящее время проект находиться под крылом Free Software Foundation. GCC выпускается под лицензией GPLv3 и является стандартным компилятором для большинства свободных UNIX-подобных операционных систем. В базовый набор входят компиляторы языков: C, C++, Objective-C, Java, Fortran, Ada. GCC поддерживает все основные процессорные архитектуры. Официальный сайт проекта gcc.gnu.org

Основы

GCC входит в состав любого дистрибутива Linux и, как правило, устанавливается по умолчанию. Интерфейс GCC, это стандартный интерфейс компилятора на UNIX платформе, уходящий своими корнями в конец 60-х, начало 70-х годов прошлого века - интерфейс командной строки. Не стоит пугаться, за прошедшее время механизм взаимодействия с пользователем был отточен до возможного в данном случае совершенства, и работать с GCC (при наличии нескольких дополнительных утилит и путного текстового редактора) проще, чем с любой из современных визуальных IDE. Авторы набора постарались максимально автоматизировать процесс компиляции и сборки приложений. Пользователь вызывает управляющую программу gcc, она интерпретирует переданные аргументы командной строки (опции и имена файлов) и для каждого входного файла, в соответствии с использованным языком программирования, запускает свой компилятор, затем, если это необходимо, gcc автоматически вызывает ассемблер и линковщик (компоновщик).

Любопытно, компиляторы одни из немногих приложений UNIX для которых не безразлично расширение файлов. По расширению GCC определяет что за файл перед ним и, что с ним нужно (можно) сделать. Файлы исходного кода на языке C должны иметь расширение .c, на языке C++, как вариант, .cpp, заголовочные файлы на языке C .h, объектные файлы .o и так далее. Если использовать неправильное расширение, gcc будет работать не корректно (если вообще согласиться, что-либо делать).

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

/* hello.c */

#include <stdio.h>

main(void)

{

        printf("Hello World\n");

        return 0;

}

Теперь в каталоге c hello.c отдадим команду:

$ gcc hello.c

Через несколько долей секунды в каталоге появиться файл a.out:

$ ls

a.out  hello.c

Это и есть готовый исполняемый файл нашей программы. По умолчанию gcc присваивает выходному исполняемому файлу имя a.out (когда-то очень давно это имя означало assembler output).

$ file a.out

a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, not stripped

Запустим получившийся программный продукт:

$ ./a.out

Hello World

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

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

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

Почему не рекомендуется вносить . в PATH? Считается, что в реальной многопользовательской системе всегда найдется какой-нибудь нехороший человек, который разместит в общедоступном каталоге вредоносную программу с именем исполняемого файла, совпадающим с именем какой-нибудь команды, часто вызываемой местным администратором с правами суперпользователя... Заговор удастся если . стоит в начале списка каталогов.

Утилита file выводит информацию о типе (с точки зрения системы) переданного в коммандной строке файла, для некоторых типов файлов выводит всякие дополнительные сведения касающиеся содержимого файла.

$ file hello.c
hello.c: ASCII C program text
$ file annotation.doc
annotation.doc: CDF V2 Document, Little Endian, Os: Windows, Version 5.1, Code page: 1251, Author: MIH, Template: Normal.dot, Last Saved By: MIH, Revision Number: 83, Name of Creating Application: Microsoft Office Word, Total Editing Time: 09:37:00, Last Printed: Thu Jan 22 07:31:00 2009, Create Time/Date: Mon Jan 12 07:36:00 2009, Last Saved Time/Date: Thu Jan 22 07:34:00 2009, Number of Pages: 1, Number of Words: 3094, Number of Characters: 17637, Security: 0

Вот собственно и всё, что требуется от пользователя для успешного применения gcc :)

Имя выходного исполняемого файла (как впрочем и любого другого файла формируемого gcc) можно изменить с помощью опции -o:

$ gcc -o hello hello.c

$ ls

hello  hello.c

$ ./hello

Hello World

В нашем примере функция main() возвращает казалось бы ни кому не нужное значение 0. В UNIX-подобных системах, по завершении работы программы, принято возвращать в командную оболочку целое число - в случае успешного завершения ноль, любое другое в противном случае. Интерпретатор оболочки автоматически присвоит полученное значение переменной среды с именем ?. Просмотреть её содержимое можно с помощью команды echo $?:

$ ./hello
Hello World
$ echo $?
0

Выше было сказано, что gcc это управляющая программа, предназначенная для автоматизации процесса компиляции. Посмотрим что же на самом деле происходит в результате исполнения команды gcc hello.c.

Процесс компиляции можно разбить на 4 основных этапа: обработка препроцессором, собственно компиляция, ассемблирование, линковка (связывание).

Опции gcc позволяют прервать процесс на любом из этих этапов.

Препроцессор осуществляет подготовку исходного файла к компиляции - вырезает комментарии, добавляет содержимое заголовочных файлов (директива препроцессора #include), реализует раскрытие макросов (символических констант, директива препроцессора #define).

Воспользовавшись опцией -E дальнейшие действия gcc можно прервать и просмотреть содержимое файла, обработанного препроцессором.

$ gcc -E -o hello.i hello.c

$ ls

hello.c  hello.i

$ less hello.i

. . .

# 1 "/usr/include/stdio.h" 1 3 4

# 28 "/usr/include/stdio.h" 3 4

# 1 "/usr/include/features.h" 1 3 4

. . .

typedef unsigned char __u_char;

typedef unsigned short int __u_short;

typedef unsigned int __u_int;

. . .

extern int printf (__const char *__restrict __format, ...);

. . .

# 4 "hello.c" 2

main (void)

{

 printf ("Hello World\n");

 return 0;

}

После обработки препроцессором исходный текст нашей программы разбух и приобрел не удобочитаемый вид. Код, который мы когда-то собственноручно набили, свелся к нескольким строчкам в самом конце файла. Причина - подключение заголовочного файла стандартной библиотеки C. Заголовочный файл stdio.h сам по себе содержит много всего разного да ещё требует включения других заголовочных файлов.

Обратите внимание на расширение файла hello.i. По соглашениям gcc расширение .i соответствует файлам с исходным кодом на языке C не требующим обработки препроцессором. Такие файлы компилируются минуя препроцессор:

$ gcc -o hello hello.i

$ ls

hello  hello.c  hello.i

$ ./hello

Hello World

После препроцессинга наступает очередь компиляции. Компилятор преобразует исходный текст программы на языке высокого уровня в код на языке ассемблера.

Значение слова компиляция размыто. Википедисты, например, считают, ссылаясь на международные стандарты, что компиляция это "преобразование программой-компилятором исходного текста какой-либо программы, написанного на языке программирования высокого уровня, в язык, близкий к машинному, или в объектный код." В принципе это определение нам подходит, язык ассемблера действительно ближе к машинному, чем C. Но в обыденной жизни под компиляцией чаще всего понимают просто любую операцию, преобразующую исходный код программы на каком-либо языке программирования в исполняемый код. То есть процесс, включающий все четыре означенных выше, этапа также может быть назван компиляцией. Подобная неоднозначность присутствует и в настоящем тексте. С другой стороны, операцию преобразования исходного текста программы в код на языке ассемблера можно обозначить и словом трансляция - "преобразование программы, представленной на одном из языков программирования, в программу на другом языке и, в определённом смысле, равносильную первой".

Остановить процесс создания исполняемого файла по завершении компиляции позволяет опция -S:

$ gcc -S hello.c

$ ls

hello.c  hello.s

$ file hello.s

hello.s: ASCII assembler program text

$ less hello.s

        .file   "hello.c"

        .section        .rodata

.LC0:

        .string "Hello World"

        .text

.globl main

        .type   main, @function

main:

        pushl   %ebp

        movl    %esp, %ebp

        andl    $-16, %esp

        subl    $16, %esp

        movl    $.LC0, (%esp)

        call    puts

        movl    $0, %eax

        leave

        ret

        .size   main, .-main

        .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"

        .section        .note.GNU-stack,"",@progbits

В каталоге появился файл hello.s, содержащий реализацию программы на языке ассемблера. Обратите внимание, задавать имя выходного файла с помощью опции -o в данном случае не потребовалось, gcc автоматически его сгенерировал, заменив в имени исходного файла расширение .c на .s. Для большинства основных операций gcc имя выходного файла формируется путем подобной замены. Расширение .s стандартное для файлов с исходным кодом на языке ассемблера.

Получить исполняемый код разумеется можно и из файла hello.s:

$ gcc -o hello hello.s

$ ls

hello  hello.c  hello.s

$ ./hello

Hello World

Следующий этап операция ассмеблирования - трансляция кода на языке ассемблера в машинный код. Результат операции - объектный файл. Объектный файл содержит блоки готового к исполнению машинного кода, блоки данных, а также список определенных в файле функций и внешних переменных (таблицу символов), но при этом в нем не заданы абсолютные адреса ссылок на функции и данные. Объектный файл не может быть запущен на исполнение непосредственно, но в дальнейшем (на этапе линковки) может быть объединен с другими объектными файлами (при этом, в соответствии с таблицами символов, будут вычислены и заполнены адреса существующих между файлами перекрестных ссылок). Опция gcc -c, останавливает процесс по завершении этапа ассемблирования:

$ gcc -c hello.c

$ ls

hello.c  hello.o

$ file hello.o

hello.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped

Для объектных файлов принято стандартное расширение .o.

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

$ gcc -o hello hello.o

$ ls

hello  hello.c  hello.o

$ ./hello

Hello World

То, что мы сейчас проделали (вернее gcc проделал за нас) и есть содержание последнего этапа - линковки (связывания, компоновки).

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

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

Опция -Wall - выводит предупреждения, вызванные потенциальными ошибками в коде, не препятствующими компиляции программы, но способными привести, по мнению компилятора, к тем или иным проблемам при её исполнении. Важная и полезная опция, разработчики gcc рекомендуют пользоваться ей всегда. Например масса предупреждений будет выдана при попытке компиляции вот такого файла:

/* remark.c */



static int k = 0;

static int l(int a);



main()

{



       int a;



       int b, c;



       b + 1;



       b = c;



       int *p;



       b = *p;



}

$ gcc -o remark remark.c

$ gcc -Wall -o remark remark.c

remark.c:7: warning: return type defaults to ‘int’

remark.c: In function ‘main’:

remark.c:13: warning: statement with no effect

remark.c:9: warning: unused variable ‘a’

remark.c:21: warning: control reaches end of non-void function

remark.c: At top level:

remark.c:3: warning: ‘k’ defined but not used

remark.c:4: warning: ‘l’ declared ‘static’ but never defined

remark.c: In function ‘main’:

remark.c:15: warning: ‘c’ is used uninitialized in this function

remark.c:19: warning: ‘p’ is used uninitialized in this function

Опция -Werror - превращает все предупреждения в ошибки. В случае появления предупреждения прерывает процесс компиляции. Используется совместно с опцией -Wall.

$ gcc -Werror -o remark remark.c

$ gcc -Werror -Wall -o remark remark.c

cc1: warnings being treated as errors

remark.c:7: error: return type defaults to ‘int’

remark.c: In function ‘main’:

remark.c:13: error: statement with no effect

remark.c:9: error: unused variable ‘a’

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

Опции -O1, -O2, -O3 - задают уровень оптимизации кода генерируемого компилятором. С увеличением номера, степень оптимизации возрастает. Действие опций можно увидеть вот на таком примере.

Исходный файл:

/* circle.c */

main(void)

{

        int i;

        for(i = 0; i < 10; ++i)

                ;

        return i;

}

Компиляция с уровнем оптимизации по умолчанию:

$ gcc -S circle.c

$ less circle.s

        .file   "circle.c"

        .text

.globl main

        .type   main, @function

main:

        pushl   %ebp

        movl    %esp, %ebp

        subl    $16, %esp

        movl    $0, -4(%ebp)

        jmp     .L2

.L3:

        addl    $1, -4(%ebp)

.L2:

        cmpl    $9, -4(%ebp)

        jle     .L3

        movl    -4(%ebp), %eax

        leave

        ret

        .size   main, .-main

        .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"

        .section        .note.GNU-stack,"",@progbits

Компиляция с максимальным уровнем оптимизации:

$ gcc -S -O3 circle.c

$ less circle.s

        .file   "circle.c"

        .text

        .p2align 4,,15

.globl main

        .type   main, @function

main:

        pushl   %ebp

        movl    $10, %eax

        movl    %esp, %ebp

        popl    %ebp

        ret

        .size   main, .-main

        .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"

        .section        .note.GNU-stack,"",@progbits

Во втором случае в полученном коде даже нет намёка на какой-либо цикл. Действительно, значение i, можно вычислить ещё на этапе компиляции, что и было сделано.

Увы, для реальных проектов разница в производительности при различных уровнях оптимизации практически не заметна...

Опция -O0 - отменяет какую-либо оптимизацию кода. Опция необходима на этапе отладки приложения. Как было показано выше, оптимизация может привести к изменению структуры программы до неузнаваемости, связь между исполняемым и исходным кодом не будет явной, соответственно, пошаговая отладка программы будет не возможна. При включении опции -g, рекомендуется включать и -O0.

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

Опция -march=architecture - задает целевую архитектуру процессора. Список поддерживаемых архитектур обширен, например, для процессоров семейства Intel/AMD можно задать i386, pentium, prescott, opteron-sse3 и т.д. Пользователи бинарных дистрибутивов должны иметь в виду, что для корректной работы программ с указанной опцией желательно, что бы и все подключаемые библиотеки были откомпилированы с той же опцией.

Об опциях передаваемых линковщику будет сказано ниже.

Собственно о компиляции все. Далее поговорим о раздельной компиляции и создании библиотек.

Небольшое дополнение:

Выше было сказано, что gcc определяет тип (язык программирования) переданных файлов по их расширению и, в соответствии с угаданным типом (языком), производит действия над ними. Пользователь обязан следить за расширениями создаваемых файлов, выбирая их так, как того требуют соглашения gcc. В действительности gcc можно подсовывать файлы с произвольными именами. Опция gcc -x позволяет явно указать язык программирования компилируемых файлов. Действие опции распространяется на все последующие перечисленные в команде файлы (вплоть до появления следующей опции -x). Возможные аргументы опции:

c c-header c-cpp-output

c++ c++-header c++-cpp-output

objective-c objective-c-header objective-c-cpp-output

objective-c++ objective-c++-header objective-c++-cpp-output

assembler assembler-with-cpp

ada

f77 f77-cpp-input

f95 f95-cpp-input

java

Назначение аргументов должно быть понятно из их написания (здесь cpp не имеет ни какого отношения к C++, это файл исходного кода предварительно обработанный препроцессором). Проверим:

$ mv hello.c hello.txt
$ gcc -Wall -x c -o hello hello.txt
$ ./hello
Hello World

Раздельная компиляция

Сильной стороной языков C/C++ является возможность разделять исходный код программы по нескольким файлам. Даже можно сказать больше - возможность раздельной компиляции это основа языка, без неё эффективное использование C не мыслимо. Именно мультифайловое программирование позволяет реализовать на C крупные проекты, например такие как Linux (здесь под словом Linux подразумевается как ядро, так и система в целом). Что даёт раздельная компиляция программисту?

1. Позволяет сделать код программы (проекта) более удобочитаемым. Файл исходника на несколько десятков экранов становиться практически неохватным. Если, в соответствии с некой (заранее продуманной) логикой, разбить его на ряд небольших фрагментов (каждый в отдельном файле), совладать со сложностью проекта будет гораздо проще.

2. Позволяет сократить время повторной компиляции проекта. Если изменения внесены в один файл нет смысла перекомпилировать весь проект, достаточно заново откомпилировать только этот изменённый файл.

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

4. Без раздельной компиляции не существовало бы библиотек. Посредством библиотек реализовано повторное использование и распространение кода на C/C++, причем кода бинарного, что позволяет с одной стороны предоставить разработчикам простой механизм включения его в свои программы, с другой стороны скрыть от них конкретные детали реализации. Работая над проектом, всегда стоит задумываться над тем, а не понадобиться что-либо из уже сделанного когда-нибудь в будущем? Может стоит заранее выделить и оформить часть кода как библиотеку? По моему, такой подход, существенно упрощает жизнь и экономит массу времени.

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

Вот практический пример (правда весьма и весьма условный).

Набор файлов исходного кода:

/* main.c */

#include <stdio.h>

#include "first.h"

#include "second.h"

int main(void)

{

        first();

        second();

        printf("Main function...\n");

        return 0;

}

/* first.h */

void first(void);

/* first.c */

#include <stdio.h>

#include "first.h"

void first(void)

{

        printf("First function...\n");

}

/* second.h */

void second(void);

/* second.c */

#include <stdio.h>

#include "second.h"

void second(void)

{

        printf("Second function...\n");

}

В общем имеем вот что:

$ ls

first.c  first.h  main.c  second.c  second.h

Все это хозяйство можно скомпилировать в одну команду:

$ gcc -Wall -o main main.c first.c second.c

$ ./main

First function...

Second function...

Main function...

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

$ gcc -Wall -c main.c

$ gcc -Wall -c first.c

$ gcc -Wall -c second.c

$ ls

first.c  first.h  first.o  main.c  main.o  second.c  second.h  second.o

$ gcc -o main main.o first.o second.o

$ ./main

First function...

Second function...

Main function...

Что мы сделали? Из каждого исходного файла (компилируя с опцией -c) получили объектный файл. Затем объектные файлы слинковали в итоговый исполняемый. Разумеется команд gcc стало больше, но в ручную ни кто проекты не собирает, для этого есть утилиты сборщики (самая популярная make). При использовании утилит сборщиков и проявятся все из перечисленных выше преимуществ раздельной компиляции.

Возникает вопрос: как линковщик ухитряется собирать вместе объектные файлы, правильно вычисляя адресацию вызовов? Откуда он вообще узнаёт, что в файле second.o содержится код функции second(), а в коде файла main.o присутствует её вызов? Оказывается всё просто - в объектном файле присутствует так называемая таблица символов, включающая имена некоторых позиций кода (функций и внешних переменных). Линковщик просматривает таблицу символов каждого объектного файла, ищет общие (с совпадающими именами) позиции, на основании чего делает выводы о фактическом местоположении кода используемых функций (или блоков данных) и, соответственно, производит перерасчёт адресов вызовов в исполняемом файле.

Просмотреть таблицу символов можно с помощью утилиты nm.

$ nm main.o

         U first

00000000 T main

         U puts

         U second

$ nm first.o

00000000 T first

         U puts

$ nm second.o

         U puts

00000000 T second

Появление вызова puts объясняется использованием функции стандартной библиотеки printf(), превратившейся в puts() на этапе компиляции.

Таблица символов прописывается не только в объектный, но и в исполняемый файл:

$ nm main

08049f20 d _DYNAMIC

08049ff4 d _GLOBAL_OFFSET_TABLE_

080484fc R _IO_stdin_used

         w _Jv_RegisterClasses

08049f10 d __CTOR_END__

08049f0c d __CTOR_LIST__

08049f18 D __DTOR_END__

08049f14 d __DTOR_LIST__

08048538 r __FRAME_END__

08049f1c d __JCR_END__

08049f1c d __JCR_LIST__

0804a014 A __bss_start

0804a00c D __data_start

080484b0 t __do_global_ctors_aux

08048360 t __do_global_dtors_aux

0804a010 D __dso_handle

         w __gmon_start__

080484aa T __i686.get_pc_thunk.bx

08049f0c d __init_array_end

08049f0c d __init_array_start

08048440 T __libc_csu_fini

08048450 T __libc_csu_init

         U __libc_start_main@@GLIBC_2.0

0804a014 A _edata

0804a01c A _end

080484dc T _fini

080484f8 R _fp_hw

080482b8 T _init

08048330 T _start

0804a014 b completed.7021

0804a00c W data_start

0804a018 b dtor_idx.7023

0804840c T first

080483c0 t frame_dummy

080483e4 T main

         U puts@@GLIBC_2.0

08048420 T second

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

$ gcc -s -o main main.o first.o second.o

$ ./main

First function...

Second function...

Main function...

$ nm main

nm: main: no symbols

Необходимо отметить, что в ходе компоновки, линковщик не делает ни каких проверок контекста вызова функций, он не следит ни за типом возвращаемого значения, ни за типом и количеством принимаемых параметров (да ему и не откуда взять такую информацию). Все проверки корректности вызовов должны быть сделаны на этапе компиляции. В случае мультифайлового программирования для этого необходимо использовать механизм заголовочных файлов языка C.

Библиотеки

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

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

С точки зрения операционной системы и прикладного программного обеспечения библиотеки бывают статическими и разделяемыми (динамическими).

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

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

Парадигма разделяемых библиотек предоставляет три существенных преимущества:

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

2. Код разделяемой библиотеки используемый несколькими приложениями храниться в оперативной памяти в одном экземпляре (на самом деле не всё так просто...), в результате сокращается потребность системы в доступной оперативной памяти.

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

Без парадигмы разделяемых библиотек не существовало бы прекомпиллированных (бинарных) дистрибутивов Linux (да ни каких бы не существовало). Представьте размеры дистрибутива, в каждый бинарный файл которого, был бы помещен код стандартной библиотеки C (и всех других подключаемых библиотек). Так же представьте что пришлось бы делать для того, что бы обновить систему, после устранения критической уязвимости в одной из широко задействованных библиотек...

Теперь немного практики.

Для иллюстрации воспользуемся набором исходных файлов из предыдущего примера. В нашу самодельную библиотеку поместим код (реализацию) функций first() и second().

В Linux принята следующая схема именования файлов библиотек (хотя соблюдается она не всегда) - имя файла библиотеки начинается с префикса lib, за ним следует собственно имя библиотеки, в конце расширение .a (archive) - для статической библиотеки, .so (shared object) - для разделяемой (динамической), после расширения через точку перечисляются цифры номера версии (только для динамической библиотеки). Имя, соответствующего библиотеке заголовочного файла (опять же как правило), состоит из имени библиотеки (без префикса и версии) и расширения .h. Например: libogg.a, libogg.so.0.7.0, ogg.h.

В начале создадим и используем статическую библиотеку.

Функции first() и second() составят содержимое нашей библиотеки libhello. Имя файла библиотеки, соответственно, будет libhello.a. Библиотеке сопоставим заголовочный файл hello.h.

/* hello.h */

void first(void);

void second(void);

Разумеется, строки:

#include "first.h"

#include "second.h"

в файлах main.c, first.c и second.c необходимо заменить на:

#include "hello.h"

Ну а теперь, введем следующую последовательность команд:

$ gcc -Wall -c first.c

$ gcc -Wall -c second.c

$ ar crs libhello.a first.o second.o

$ file libhello.a

libhello.a: current ar archive

Как уже было сказано - библиотека это набор объектных файлов. Первыми двумя командами мы и создали эти объектные файлы.

Далее необходимо объектные файлы скомпоновать в набор. Для этого используется архиватор ar - утилита "склеивает" несколько файлов в один, в полученный архив включает информацию требуемую для восстановления (извлечения) каждого индивидуального файла (включая его атрибуты принадлежности, доступа, времени). Какого-либо "сжатия" содержимого архива или иного преобразования хранимых данных при этом не производится.

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

Опция r - задает режим обновления архива, если в архиве файл с указанным именем уже существует, он будет удален, а новый файл дописан в конец архива.

Опция s - добавляет (обновляет) индекс архива. В данном случае индекс архива это таблица, в которой для каждого определенного в архивируемых файлах символического имени (имени функции или блока данных) сопоставлено соответствующее ему имя объектного файла. Индекс архива необходим для ускорения работы с библиотекой - для того чтобы найти нужное определение, отпадает необходимость просматривать таблицы символов всех файлов архива, можно сразу перейти к файлу, содержащему искомое имя. Просмотреть индекс архива можно с помощью уже знакомой утилиты nm воспользовавшись её опцией -s (так же будут показаны таблицы символов всех объектных файлов архива):

$ nm -s libhello.a

Archive index:

first in first.o

second in second.o

first.o:

00000000 T first

         U puts

second.o:

         U puts

00000000 T second

Для создания индекса архива существует специальная утилита ranlib. Библиотеку libhello.a можно было сотворить и так:

$ ar cr libhello.a first.o second.o

$ ranlib libhello.a

Впрочем библиотека будет прекрасно работать и без индекса архива.

Теперь воспользуемся нашей библиотекой:

$ gcc -Wall -c main.c

$ gcc -o main main.o -L. -lhello

$ ./main

First function...

Second function...

Main function...

Работает...

Ну теперь комментарии... Появились две новые опции gcc:

Опция -lname - передаётся линковщику, указывает на необходимость подключить к исполняемому файлу библиотеку libname. Подключить значит указать, что такие-то и такие-то функции (внешние переменные) определены в такой-то библиотеке. В нашем примере библиотека статическая, все символьные имена будут ссылаться на код находящийся непосредственно в исполняемом файле. Обратите внимание в опции -l имя библиотеки задается как name без приставки lib.

Опция -L/путь/к/каталогу/с/библиотеками - передаётся линковщику, указывает путь к каталогу содержащему подключаемые библиотеки. В нашем случае задана точка ., линковщик сначала будет искать библиотеки в текущем каталоге, затем в каталогах определённых в системе.

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

$ gcc -Wall -c main.c

$ gcc -o main -L. -lhello main.o

main.o: In function `main':

main.c:(.text+0xa): undefined reference to `first'

main.c:(.text+0xf): undefined reference to `second'

collect2: ld returned 1 exit status

$ gcc -o main main.o -L. -lhello

$ ./main

First function...

Second function...

Main function...

Такая особенность поведения gcc обусловлена желанием разработчиков предоставить пользователю возможность по разному комбинировать файлы с библиотеками, использовать пересекающие имена... На мой взгляд, если возможно, лучше этим не заморачиваться. В общем подключаемые библиотеки необходимо перечислять после имени ссылающегося на них файла.

Существует альтернативный способ указания местоположения библиотек в системе. В зависимости от дистрибутива, переменная окружения LD_LIBRARY_PATH или LIBRARY_PATH может хранить список разделенных знаком двоеточия каталогов, в которых линковщик должен искать библиотеки. Как правило, по умолчанию эта переменная вообще не определена, но ни чего не мешает её создать:

$ echo $LD_LIBRARY_PATH

$ gcc -o main main.o -lhello

/usr/lib/gcc/i686-pc-linux-gnu/4.4.3/../../../../i686-pc-linux-gnu/bin/ld: cannot find -lhello

collect2: выполнение ld завершилось с кодом возврата 1

$ export LIBRARY_PATH=.

$ gcc -o main main.o -lhello

$ ./main

First function...

Second function...

Main function...

Манипуляции с переменными окружения полезны при создании и отладке собственных библиотек, а так же если возникает необходимость подключить к приложению какую-нибудь нестандартную (устаревшую, обновленную, изменённую - в общем отличную от включенной в дистрибутив) разделяемую библиотеку.

Теперь создадим и используем библиотеку динамическую.

Набор исходных файлов остается без изменения. Вводим команды, смотрим что получилось, читаем комментарии:

$ gcc -Wall -fPIC -c first.c

$ gcc -Wall -fPIC -c second.c

$ gcc -shared -o libhello.so.2.4.0.5 -Wl,-soname,libhello.so.2 first.o second.o

Что получили в результате?

$ file libhello.so.2.4.0.5

libhello.so.2.4.0.5: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, not stripped

Файл libhello.so.2.4.0.5, это и есть наша разделяемая библиотека. Как её использовать поговорим чуть ниже.

Теперь комментарии:

Опция -fPIC - требует от компилятора, при создании объектных файлов, порождать позиционно-независимый код (PIC - Position Independent Code), его основное отличие в способе представления адресов. Вместо указания фиксированных (статических) позиций, все адреса вычисляются исходя из смещений заданных в глобальной таблицы смещений (global offset table - GOT). Формат позиционно-независимого кода позволяет подключать исполняемые модули к коду основной программы в момент её загрузки. Соответственно, основное назначение позиционно-независимого кода - создание динамических (разделяемых) библиотек.

Опция -shared - указывает gcc, что в результате должен быть собран не исполняемый файл, а разделяемый объект - динамическая библиотека.

Опция -Wl,-soname,libhello.so.2 - задает soname библиотеки. О soname подробно поговорим в следующем абзаце. Сейчас обсудим формат опции. Сея странная, на первый взгляд, конструкция с запятыми предназначена для непосредственного взаимодействия пользователя с линковщиком. По ходу компиляции gcc вызывает линковщик автоматически, автоматически же, по собственному усмотрению, gcc передает ему необходимые для успешного завершения задания опции. Если у пользователя возникает потребность самому вмешаться в процесс линковки он может воспользоваться специальной опцией gcc -Wl,-option,value1,value2.... Что означает передать линковщику (-Wl) опцию -option с аргументами value1, value2 и так далее. В нашем случае линковщику была передана опция -soname с аргументом libhello.so.2.

Теперь о soname. При создании и распространении библиотек встает проблема совместимости и контроля версий. Для того чтобы система, конкретно загрузчик динамических библиотек, имели представление о том библиотека какой версии была использована при компиляции приложения и, соответственно, необходима для его успешного функционирования, был предусмотрен специальный идентификатор - soname, помещаемый как в файл самой библиотеки, так и в исполняемый файл приложения. Идентификатор soname это строка, включающая имя библиотеки с префиксом lib, точку, расширение so, снова точку и оду или две (разделенные точкой) цифры версии библиотеки - libname.so.x.y. То есть soname совпадает с именем файла библиотеки вплоть до первой или второй цифры номера версии. Пусть имя исполняемого файла нашей библиотеки libhello.so.2.4.0.5, тогда soname библиотеки может быть libhello.so.2. При изменении интерфейса библиотеки её soname необходимо изменять! Любая модификация кода, приводящая к несовместимости с предыдущими релизами должна сопровождаться появлением нового soname.

Как же это все работает? Пусть для успешного исполнения некоторого приложения необходима библиотека с именем hello, пусть в системе таковая имеется, при этом имя файла библиотеки libhello.so.2.4.0.5, а прописанное в нем soname библиотеки libhello.so.2. На этапе компиляции приложения, линковщик, в соответствии с опцией -lhello, будет искать в системе файл с именем libhello.so. В реальной системе libhello.so это символическая ссылка на файл libhello.so.2.4.0.5. Получив доступ к файлу библиотеки, линковщик считает прописанное в нем значение soname и наряду с прочим поместит его в исполняемый файл приложения. Когда приложение будет запущено, загрузчик динамических библиотек получит запрос на подключение библиотеки с soname, считанным из исполняемого файла, и попытается найти в системе библиотеку, имя файла которой совпадает с soname. То есть загрузчик попытается отыскать файл libhello.so.2. Если система настроена корректно, в ней должна присутствовать символическая ссылка libhello.so.2 на файл libhello.so.2.4.0.5, загрузчик получит доступ к требуемой библиотеки и далее не задумываясь (и ни чего более не проверяя) подключит её к приложению. Теперь представим, что мы перенесли откомпилированное таким образом приложение в другую систему, где развернута только предыдущая версия библиотеки с soname libhello.so.1. Попытка запустить программу приведет к ошибке, так как в этой системе файла с именем libhello.so.2 нет.

Таким образом, на этапе компиляции линковщику необходимо предоставить файл библиотеки (или символическую ссылку на файл библиотеки) с именем libname.so, на этапе исполнения загрузчику потребуется файл (или символическая ссылка) с именем libname.so.x.y. При чем имя libname.so.x.y должно совпадать со строкой soname использованной библиотеки.

В бинарных дистрибутивах, как правило, файл библиотеки libhello.so.2.4.0.5 и ссылка на него libhello.so.2 будут помещены в пакет libhello, а необходимая только для компиляции ссылка libhello.so, вместе с заголовочным файлом библиотеки hello.h будет упакована в пакет libhello-devel (в devel пакете окажется и файл статической версии библиотеки libhello.a, статическая библиотека может быть использована, также только на этапе компиляции). При распаковке пакета все перечисленные файлы и ссылки (кроме hello.h) окажутся в одном каталоге.

Убедимся, что заданная строка soname действительно прописана в файле нашей библиотеки. Воспользуемся мега утилитой objdump с опцией -p:

$ objdump -p libhello.so.2.4.0.5 | grep SONAME

  SONAME               libhello.so.2

Утилита objdump - мощный инструмент, позволяющий получить исчерпывающую информацию о внутреннем содержании (и устройстве) объектного или исполняемого файла. В man странице утилиты сказано, что objdump прежде всего будет полезен программистам, создающими средства отладки и компиляции, а не просто пишущих какие-нибудь прикладные программы :) В частности с опцией -d это дизассемблер. Мы воспользовались опцией -p - вывести различную метаинформацию о объектном файле.

В приведенном примере создания библиотеки мы неотступно следовали принципам раздельной компиляции. Разумеется скомпилировать библиотеку можно было бы и вот так, одним вызовом gcc:

$ gcc -shared -Wall -fPIC -o libhello.so.2.4.0.5 -Wl,-soname,libhello.so.2 first.c second.c

Теперь попытаемся воспользоваться получившейся библиотекой:

$ gcc -Wall -c main.c

$ gcc -o main main.o -L. -lhello -Wl,-rpath,.

/usr/bin/ld: cannot find -lhello

collect2: ld returned 1 exit status

Линковщик ругается. Вспоминаем, что было сказано выше о символических ссылках. Создаем libhello.so и повторяем попытку:

$ ln -s libhello.so.2.4.0.5 libhello.so

$ gcc -o main main.o -L. -lhello -Wl,-rpath,.

Теперь все довольны. Запускаем созданный бинарник:

$ ./main

./main: error while loading shared libraries: libhello.so.2: cannot open shared object file: No such file or directory

Ошибка... Ругается загрузчик, не может найти библиотеку libhello.so.2. Убедимся, что в исполняемом файле действительно прописана ссылка на libhello.so.2:

$ objdump -p main | grep NEEDED

  NEEDED               libhello.so.2

  NEEDED               libc.so.6

Создаем соответствующую ссылку и повторно запускаем приложение:

$ ln -s libhello.so.2.4.0.5 libhello.so.2

$ ./main

First function...

Second function...

Main function...

Заработало... Теперь комментарии по новым опциям gcc.

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

$ objdump -p main | grep RPATH

  RPATH                .

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

$ mv main ..

$ ../main

First function...

Second function...

Main function...

$ cd ..

$ ./main

./main: error while loading shared libraries: libhello.so.2: cannot open shared object file: No such file or directory

Узнать какие разделяемые библиотеки необходимы приложению можно и с помощью утилиты ldd:

$ ldd main

 linux-vdso.so.1 =>  (0x00007fffaddff000)

 libhello.so.2 => ./libhello.so.2 (0x00007f9689001000)

 libc.so.6 => /lib/libc.so.6 (0x00007f9688c62000)

 /lib64/ld-linux-x86-64.so.2 (0x00007f9689205000)

В выводе ldd для каждой требуемой библиотеки указывается её soname и полный путь к файлу библиотеки, определённый в соответствии с настройками системы.

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

В соответствии с соглашениями FHS (Filesystem Hierarchy Standard) в системе должны быть два (как минимум) каталога для хранения файлов библиотек:

/lib - здесь собраны основные библиотеки дистрибутива, необходимые для работы программ из /bin и /sbin;

/usr/lib - здесь хранятся библиотеки необходимые прикладным программам из /usr/bin и /usr/sbin;

Соответствующие библиотекам заголовочные файлы должны находиться в каталоге /usr/include.

Загрузчик по умолчанию будет искать файлы библиотек в этих каталогах.

Кроме перечисленных выше, в системе должен присутствовать каталог /usr/local/lib - здесь должны находиться библиотеки, развернутые пользователем самостоятельно, минуя систему управления пакетами (не входящие в состав дистрибутива). Например в этом каталоге по умолчанию окажутся библиотеки скомпилированные из исходников (программы установленные из исходников будут размещены в /usr/local/bin и /usr/local/sbin, разумеется речь идет о бинарных дистрибутивах). Заголовочные файлы библиотек в этом случае будут помещены в /usr/local/include.

В ряде дистрибутивов (в Ubuntu) загрузчик не настроен просматривать каталог /usr/local/lib, соответственно, если пользователь установит библиотеку из исходников, система её не увидит. Сиё авторами дистрибутива сделано специально, что бы приучить пользователя устанавливать программное обеспечение только через систему управления пакетами. Как поступить в данном случае будет рассказано ниже.

В действительности, для упрощения и ускорения процесса поиска файлов библиотек, загрузчик не просматривает при каждом обращении указанные выше каталоги, а пользуется базой данных, хранящейся в файле /etc/ld.so.cache (кэшем библиотек). Здесь собрана информация о том, где в системе находится соответствующий данному soname файл библиотеки. Загрузчик, получив список необходимых конкретному приложению библиотек (список soname библиотек, заданных в исполняемом файле программы), посредством /etc/ld.so.cache определяет путь к файлу каждой требуемой библиотеки и загружает её в память. Дополнительно, загрузчик может просмотреть каталоги перечисленные в системных переменных LD_LIBRARY_PATH, LIBRARY_PATH и в поле RPATH исполняемого файла (смотри выше).

Для управления и поддержания в актуальном состоянии кэша библиотек используется утилита ldconfig. Если запустить ldconfig без каких-либо опций, программа просмотрит каталоги заданные в командной строке, доверенные каталоги /lib и /usr/lib, каталоги перечисленные в файле /etc/ld.so.conf. Для каждого файла библиотеки, оказавшегося в указанных каталогах, будет считано soname, создана основанная на soname символическая ссылка, обновлена информация в /etc/ld.so.cache.

Убедимся в сказанном:

$ ls

hello.h  libhello.so  libhello.so.2.4.0.5  main.c

$ gcc -Wall -o main main.c -L. -lhello

$ ./main

./main: error while loading shared libraries: libhello.so.2: cannot open shared object file: No such file or directory

$ sudo ldconfig /полный/путь/к/катаогу/c/примером

$ ls

hello.h  libhello.so  libhello.so.2  libhello.so.2.4.0.5  main  main.c

$ ./main

First function...

Second function...

Main function...

$ sudo ldconfig

$ ./main

./main: error while loading shared libraries: libhello.so.2: cannot open shared object file: No such file or directory

Первым вызовом ldconfig мы внесли в кэш нашу библиотеку, вторым вызовом исключили. Обратите внимание, что при компиляции main была опущена опция -Wl,-rpath,., в результате загрузчик проводил поиск требуемых библиотек только в кэше.

Теперь должно быть понятно как поступить если после установки библиотеки из исходников система её не видит. Прежде всего необходимо внести в файл /etc/ld.so.conf полный путь к каталогу с файлами библиотеки (по умолчанию /usr/local/lib). Формат /etc/ld.so.conf - файл содержит список разделённых двоеточием, пробелом, табуляцией или символом новой строки, каталогов, в которых производится поиск библиотек. После чего вызвать ldconfig без каких-либо опций, но с правами суперпользователя. Всё должно заработать.

Ну и в конце поговорим о том как уживаются вместе статические и динамические версии библиотек. В чем собственно вопрос? Выше, когда обсуждались принятые имена и расположение файлов библиотек было сказано, что файлы статической и динамической версий библиотеки хранятся в одном и том же каталоге. Как же gcc узнает какой тип библиотеки мы хотим использовать? По умолчанию предпочтение отдается динамической библиотеки. Если линковщик находит файл динамической библиотеки, он не задумываясь цепляет его к исполняемому файлу программы:

$ ls

hello.h  libhello.a  libhello.so  libhello.so.2  libhello.so.2.4.0.5  main.c

$ gcc -Wall -c main.c

$ gcc -o main main.o -L. -lhello -Wl,-rpath,.

$ ldd main

 linux-vdso.so.1 =>  (0x00007fffe1bb0000)

 libhello.so.2 => ./libhello.so.2 (0x00007fd50370b000)

 libc.so.6 => /lib/libc.so.6 (0x00007fd50336c000)

 /lib64/ld-linux-x86-64.so.2 (0x00007fd50390f000)

$ du -h main

12K main

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

Существует опция gcc -static - указание линковщику использовать только статические версии всех необходимых приложению библиотек:

$ gcc -static -o main main.o -L. -lhello

$ file main

main: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.15, not stripped

$ ldd main

 не является динамическим исполняемым файлом

$ du -h main

728K main

Размер исполняемого файла в 60 раз больше, чем в предыдущем примере - в файл включены стандартные библиотеки языка C. Теперь наше приложение можно смело переносить из каталога в каталог и даже на другие машины, код библиотеки hello внутри файла, программа полностью автономна.

Как же быть если необходимо осуществить статическую линковку только части использованных библиотек? Возможный вариант решения - сделать имя статической версии библиотеки отличным от имени разделяемой, а при компиляции приложения указывать какую версию мы хотим использовать на этот раз:

$ mv libhello.a libhello_s.a

$ gcc -o main main.o -L. -lhello_s

$ ldd main

 linux-vdso.so.1 =>  (0x00007fff021f5000)

 libc.so.6 => /lib/libc.so.6 (0x00007fd0d0803000)

 /lib64/ld-linux-x86-64.so.2 (0x00007fd0d0ba4000)

$ du -h main

12K main

Так как размер кода библиотеки libhello ничтожен,

$ du -h libhello_s.a

4,0K libhello.a

размер получившегося исполняемого файла практически не отличается от размера файла созданного с использованием динамической линковки.

Ну вот пожалуй и все. Большое спасибо всем, кто закончил чтение на этом месте.

Пакет matplotlib. Наводим красивости

noreply@blogger.com (Вий) — Wed, 30 Sep 2009 11:45:00 +0000

Продолжаем разговор о пакете matplotlib. Сегодня обсудим способы изменения внешнего вида элементов диаграмм - другими словами способы наведения красивостей.

Изменение свойств графических элементов пакета matplotlib

Как уже неоднократно отмечалось - в логике matplotlib каждый графический элемент (линия, подпись, рамка, сетка и т.д.) представлен объектом соответствующего класса. Команды (функции) пакета matplotlib, отвечающие за создание какого-либо элемента, как результат выполнения возвращают ссылку на объект представляющий данный элемент:

>>> import matplotlib.pyplot as plt
>>> line, = plt.plot([1, 2, 3])
>>> line
<matplotlib.lines.Line2D object at 0x030509D0>
>>> type(line)
<class 'matplotlib.lines.Line2D'>
>>> caption = plt.title(u'Заголовок диаграммы')
>>> caption
<matplotlib.text.Text object at 0x0308FC90>
>>> type(caption)
<class 'matplotlib.text.Text'>

Авторы пакета matplotlib предусмотрели три способа изменения свойств графических объектов.

Первый способ. Каждая команда пакета, создающая тот или иной графический элемент, принимает набор именованных переменных (для каждой из этих переменных уже задано значение по умолчанию), имена которых, как правило, совпадают с именами соответствующих полей (свойств) объекта. Изменяя значения именованных переменных можно изменять свойства создаваемого объекта:

>>> plt.plot([1, 2, 3], color = 'red', marker = '^', linestyle = '--', linewidth = 2, markersize = 5, label = u'Прямая линия')
[<matplotlib.lines.Line2D object at 0x02E3E150>]
>>> plt.title(u'Заголовок диаграммы', color = 'black', family = 'fantasy', fontsize = 'x-large')
<matplotlib.text.Text object at 0x02E66E10>

Второй способ. Как и подобает в соответствии с догмами объектно-ориентированного программирования, для каждого поля объекта существуют методы, предоставляющие возможность читать/писать значение поля. Уже существующий объект можно настроить посредством указанных методов:

>>> line, = plt.plot([1, 2, 3])
>>> line.set_color('red')
>>> line.set_marker('^')
>>> line.set_linestyle('--')
>>> line.set_linewidth(2)

В matplotlib принято следующее соглашение по именованию методов - метод возвращающий значение свойства property именуется get_property(), метод изменяющий значение свойства set_property()

Третий способ. Часто возникает необходимость для группы объектов (не обязательно экземпляров одного и того же класса) установить одинаковые значения для одного (нескольких) общих свойств. На этот случай авторы matplotlib предусмотрели специальную функцию matplotlib.pyplot.setp(*args, **kwargs) - "setup property" - установить свойство. Функция принимает ссылку или список ссылок на объекты и произвольный набор именованных переменных соответствующих изменяемым свойствам:

>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> X = np.linspace(0.0, 5.0, 10)
>>> Y1 = X
>>> Y2 = 3 * X
>>> Y3 = 7 * X
>>> lines = plt.plot(X, Y1, X, Y2, X, Y3)
>>> plt.setp(lines, color = 'red', marker = '^', linestyle = '--', linewidth = 2)
[None, None, None, None, None, None, None, None, None, None, None, None]
>>> plt.show()

В результате выполнения кода примера появиться вот такое окно:

Все три линии на диаграмме оформлены одинаково.

А какой глубокий смысл кроется в структуре возвращаемой функцией setp() я, честно говоря, не знаю.

Возможен и альтернативный синтаксис вызова функции. Вместо набора именованных переменных функция принимает набор пар: строка - имя свойства, произвольный тип - значение свойства (так принято работать с объектами в Matlab):

>>> plt.setp(lines, 'color', 'red', 'marker', '^', 'linestyle', '--', 'linewidth', 2)

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

>>> plt.setp(line, 'linestyle')
 linestyle: [ '-' | '--' | '-.' | ':' | 'None' | ' ' | '' ] and any drawstyle in combination with a linestyle, e.g. 'steps--'.
>>> plt.setp(line, 'color')
 color: any matplotlib color

Если вызвать функцию setp(), передав только ссылку на объект, будет выведен список всех свойств объекта и список возможных значений для каждого из свойств:

>>> plt.setp(line)
  alpha: float (0.0 transparent through 1.0 opaque)
  animated: [True | False]
  antialiased or aa: [True | False]
  axes: an :class:`~matplotlib.axes.Axes` instance
  ...

Ну и если первый аргумент функции - список ссылок на объекты, описанные выше действия производятся для объекта, ссылка на который стоит в переданном списке первой.

В качестве примера приведу код программы использующей все три способа настройки объектов.

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

# -*- coding: UTF-8 -*-

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

# Значения по оси X
X = np.linspace(0.0, 2.0, 15)
# Значения по оси Y
Y_01 = X
Y_02 = X * 3
Y_03 = X * 7

# Задаем размер диаграммы
mpl.rcParams['figure.figsize'] = (8.0, 6.0)

# Строим диаграмму
# Линии
line_01 = plt.plot(X, Y_01)
line_02 = plt.plot(X, Y_02)
line_03 = plt.plot(X, Y_03)

# Сохраняем диаграмму в файл
plt.savefig('set_exmp_01.png', format = 'png')

В результате получим вот такое изображение:

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

# -*- coding: UTF-8 -*-

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

# Значения по оси X
X = np.linspace(0.0, 2.0, 15)
# Значения по оси Y
Y_01 = X 
Y_02 = X * 3
Y_03 = X * 7

# Задаем размер диаграммы
mpl.rcParams['figure.figsize'] = (8.0, 6.0)

# Строим диаграмму

# Линии

# Первый способ настройки объектов
line_01, = plt.plot(X, Y_01, color = 'blue', linestyle = ':', linewidth = 1, marker = 's',  markersize = 6, markeredgecolor = 'black', markerfacecolor = 'blue', markeredgewidth = 1, label = u'y = x' )

line_02,  = plt.plot(X, Y_02)
line_03,  = plt.plot(X, Y_03)

# Второй способ настройки объектов
line_02.set_color('red')
line_02.set_linestyle(':')
line_02.set_linewidth(1)
line_02.set_marker('D')
line_02.set_markersize(5)
line_02.set_markeredgecolor('black')
line_02.set_markerfacecolor('red')
line_02.set_markeredgewidth(1)
line_02.set_label(u'y = 3 * x')

# Третьий способ настройки объектов
plt.setp(line_03, color = 'magenta', linestyle = ':', linewidth = 1, marker = 'o', markersize = 6, markeredgecolor = 'black', markerfacecolor = 'magenta', markeredgewidth = 1, label = u'y = 7 * x')

# Задаем интервалы значений по осям X, Y
plt.axis((-0.03, 2.03, -0.2, 14.2))

# Добавим легенду
plt.legend(loc = 'best')

# Сохраняем диаграмму в файл
plt.savefig('set_exmp_02.png', format = 'png')

Теперь изображение будет выглядеть вот так:

В примерах, для формирования массивов значений был использован модуль NumPy. С описанием использованных функций этого модуля можно познакомиться прочтя пост Пакет NumPy. Краткое введение

Остановимся подробнее на свойствах объектов класса matplotlib.lines.Line2D - линии, которая неизбежно присутствует практически на каждой диаграмме.

О свойствах объектов класса matplotlib.lines.Line2D

Ниже в таблице приведены основные свойства объекта класса matplotlib.lines.Line2D.

Свойство	Значение	Описание
alpha	Вещественное число в интервале [0.0, 1.0]	Степень прозрачность элементов линии (собственно линии и маркеров) - от полностью прозрачного 0.0, до полностью непрозрачного 1.0. Пример использования смотри ниже
antialiased или aa	True, False	Включить (True), выключить (False) режим антиалиазинга элементов линии
color или c	Один из возможных способов представления цвета в matplotlib, подробности смотри ниже	Цвет линии
dash_capstyle	Строки: 'butt', 'round', 'projecting'	Стиль оконечностей пунктирной линии. Пример использования смотри ниже
dash_joinstyle	Строки: 'miter', 'round', 'bevel'	Стиль соединения пунктирных линий
dashes	Список (кортеж) целых чисел, количество элементов списка должно быть четным	Каждая пара чисел в списке рассматривается как количество индуцируемых точек, количество погашенных точек. С помощью свойства dashes можно рисовать линии состоящие из произвольного повторяющегося набора штрихов и пунктиров. Пример использования смотри ниже
drawstyle	Строки: 'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'	Стиль отображения линии: 'default' - соседние точки соединены прямой, остальные значения - соседние точки соединены пересекающимися под прямым углом отрезками ("ступенькой") с различными вариациями пересечения отрезков. Пример использования смотри ниже
label	Произвольная строка	Подпись к линии, используется при создании легенды диаграммы
linestyle или ls	Строки: '-', '--', '-.', ':', 'steps', 'steps-pre', 'steps-mid', 'steps-post', 'None', ' ', ''	Стиль линии. Пример использования первых четырех стилей был приведен ранее, пример использования следующих четырех (можно задавать и через свойство drawstyle) смотри ниже, 'None', пробел и пустая строка выключают отображение линии, (собственно линии, маркеры, при этом, будут отображаться)
linewidth или lw	float	Толщина линии в точках
marker	Строки: '.', ',', 'o', 'v', '^', '<', '>', '1', '2', '3', '4', 's', 'p', '*', 'h', 'H', '+', 'x', 'D', 'd', '\|', '_'	Стиль маркера. Пример использования был приведен ранее
markeredgecolor или mec	Один из возможных способов представления цвета в matplotlib, подробности смотри ниже	Цвет границы маркера
markeredgewidth или mew	float	Толщина границы маркера в точках
markerfacecolor или mfc	Один из возможных способов представления цвета в matplotlib, подробности смотри ниже	Цвет маркера
markersize или ms	float	Размер маркера в точках
markevery	None, integer N, список/кортеж (integer start, integer N)	Свойство определяет, как будут использоваться маркеры при построении данной линии. Если None будут отображены все маркеры. Если целое число N, будет отображен каждый N-ый маркер. Если кортеж целых чисел (start, N) будет отображен каждый N-ый маркер начиная с start. Пример использования смотри ниже
solid_capstyle	Строки: 'butt', 'round', 'projecting'	Стиль оконечностей непрерывной линии
solid_joinstyle	Строки: 'miter', 'round', 'bevel'	Стиль соединения непрерывных линий
visible	True, False	В случае False линия и маркеры становятся невидимыми. True включает отображение элементов линии
zorder	integer	Порядок наложения элементов диаграммы (Z-order). Элемент с наибольшим значением zorder будет отображен на переднем плане (по отношению к наблюдателю) или, другими словами, элемент с наибольшим zorder будет отображен последним (самым верхним). Пример использования смотри ниже

Способы представления цвета в пакете matplotlib

Как следует из названия подраздела цвет в matplotlib может быть задан несколькими способами.

Способ первый. Из системы Matlab позаимствованы обозначения для восьми базовых цветов в виде отдельных символов.

Символ	Цвет
'b'	blue	синий
'g'	green	зеленый
'r'	red	красный
'c'	cyan	бирюзовый
'm'	magenta	пурпурный
'y'	yellow	желтый
'k'	black	черный
'w'	white	белый

>>> plt.plot(X, Y_02, color = 'm')

Способ второй. Цвет можно задать используя стандартные обозначения цветов принятые в html, как то 'red', 'silver', 'olive' и так далее.

>>> plt.plot(X, Y_02, color = 'navy')

Способ третий. Произвольный цвет можно задать воспользовавшись HEX стилем представления цвета в html: '#cc00cc', '#9900ff', '#0099cc'.

>>> plt.plot(X, Y_02, color = '#003399')

Способ четвертый. Произвольный цвет так же можно задать передав кортеж из трех вещественных чисел, каждое из которых пренадлежит интервалу [0.0, 1.0]. Числа соответствуют представлению цвета в системе RGB: (0.75, 0.0, 1.0), (1.0, 0.33, 0.33), (0.0, 0.47, 0.21).

>>> plt.plot(X, Y_02, color = (0.0, 0.5, 0.32))

Способ пятый. Вариация на тему четвертого способа. Цвет в градации серого можно задать передав строку являющуюся представлением вещественного числа в диапазоне [0.0, 1.0], '0.0' - совсем черный, '1.0' - совсем белый.

>>> plt.plot(X, Y_02, color = '0.75')

Свойства linestyle и drawstyle

Свойство linestyle включает в себя свойство drawstyle - стили отрисовки "ступенек" можно задать как через drawstyle так и через linestyle. Пример использования на рисунке ниже:

Значения свойства drawstyle и остальные значения свойства linestyle можно комбинировать. Пример на рисунке ниже:

Свойство dash_capstyle

Для того, чтобы ясно углядеть различия в начертаниях "кончика штриха" необходимо установить толщину линии как минимум в четыре точки. Пример использования на рисунке:

Свойство dashes

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

Свойство markevery

Когда данных много и при этом хочется отобразить линию с маркерами, избыточные маркеры, во избежании их слияния, необходимо как то удалить. Можно конечно специально отфильтровать данные (сделать выборку данных), но проще воспользоваться свойством markevery. Вот код примера:

# -*- coding: UTF-8 -*-

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

# Значения по оси X
X = np.linspace(0.0, 2.0, 36)
# Значения по оси Y
Y_01 = np.exp(X)
Y_02 = np.exp(X) + 5.0

# Задаем размер диаграммы
mpl.rcParams['figure.figsize'] = (8.0, 6.0)

# Строим диаграмму

# Линии
line_01,  = plt.plot(X, Y_01, 'ro--', markevery = None, label ='markevery = None')
line_02,  = plt.plot(X, Y_02, 'bo--', markevery = (0, 5), label = 'markevery = (0, 5)')
# Подпись к диаграмме
plt.title(u'Свойство markevery')
# Добавляем легенду
plt.legend(loc = 'best')
# Задаем интервалы значений по осям X, Y
plt.axis((-0.03, 2.03, -0.03, 14.0))

# Сохраняем диаграмму в файл
plt.savefig('markevery.png', format = 'png')

А вот результат прогона кода:

Свойство zorder

Чем больше значение свойства zorder тем ближе к наблюдателю объект:

Свойство alpha

Для иллюстрации "прозрачности" воспользуемся предыдущим рисунком. Получилось коряво, но смысл свойства alpha понять можно (в matplotlib атрибут прозрачности жутко портит некоторые цвета)

Ну вот пожалуй на сегодня и все...

Предыдущий пост по теме: Пакет matplotlib. График с дополнительной осью ординат.

Подсветка синтаксиса в блоге. Используем онлайновые маркеры синтаксиса

noreply@blogger.com (Вий) — Tue, 15 Sep 2009 12:07:00 +0000

О том, как вставить в блог фрагмент кода с подсвеченным синтаксисом, используя редактор Vim, я уже писал. А недавно мне подсказали еще более простое решение, не требующее для своей реализации ни чего кроме браузера - в сети имеются специальные (абсолютно бесплатные) сервисы, позволяющие разукрашивать, перед публикацией, практически любой код. Принцип работы с клиентом у таких сервисов-маркеров общий: пользователь вводит в форму фрагмент кода, выбирает из выпадающего списка тип оформляемого кода, включает (если нужно) пару дополнительных опций и, нажав соответствующую кнопку, отправляет запрос сервису. Сервис возвращает подсвеченный код в виде блока тегов html, который можно скопировать и вставить в свою страницу. Список поддерживаемых языков кода у сервисов весьма обширный, разукрасить можно практически все что угодно.

Вот два таких онлайновых маркера.

Online syntax highlighting

Online syntax highlighting, способен автоматически угадывать тип введенного кода, позволяет выбрать несколько стилей оформления. Вставляем код в редактор Source code, выбираем язык программирования в списке Type, стиль оформления в списке Style, жмем кнопку Highlight, в появившемся редакторе выделяем и копируем блок html тегов.

Примеры подсвеченного кода при различных стилях оформления:

Стиль: white

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt

# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]

# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

Стиль: navy

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt

# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]

# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

Стиль: Bred3

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt

# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]

# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

Стиль: black

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt

# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]

# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

Во всех примерах использован код из поста Пакет matplotlib. Строим банальный график

Syntax Highlighter

В целом порядок работы с сервисом Syntax Highlighter аналогичен описанному выше. Имеются опции: Line numbers - включить/выключить автоматическую нумерацию строк кода, Use tag (for Habrahabr) - если включена, код оформляется посредством тега , в противном случае с помощью классов css (внешний вид подсвеченного кода при этом несколько отличается).

Примеры:

При включенной опции Use tag (for Habrahabr):

# -*- coding: UTF-8 -*-
 
import matplotlib.pyplot as plt
 
# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]
 
# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

При выключенной опции Use tag (for Habrahabr):

# -*- coding: UTF-8 -*-
 
import matplotlib.pyplot as plt
 
# Значения по оси X
X = [20.0, 40.0, 60.0, 80.0, 100.0]
# Набор значений по оси Y
Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]
 
# Строим диаграмму
plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
# Задаем подписи
plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')
# Включаем легенду
plt.legend(loc = 'best')
# Сохраняем построенную диаграмму в файл
plt.savefig('spirit.png', format = 'png')

Ну вот на этом и все. Спасибо за внимание.

Предыдущий пост по теме: Как вставить в блог фрагмент кода с подсветкой синтаксиса

Пакет NumPy. Краткое введение

noreply@blogger.com (Вий) — Fri, 11 Sep 2009 12:15:00 +0000

Введение. Пакет NumPy - зачем нужен, где взять

Пакет (библиотека) языка Pyton NumPy предоставляет программисту средства для высокоэффективной работы с огромными многомерными массивами данных. Как составная часть и основа, пакет NumPy входит в большинство проектов, использующих язык Python и требующих мало-мальски громоздких вычислений. В частности, с его использованием написаны популярные пакеты вычислительной математики и научной графики SciPy и mathplotLib.

Python интерпретируемый язык программирования, как следствие, математические алгоритмы, написанные на Python'е, часто работают заметно медленнее по сравнению с теми же алгоритмами, реализованными на компилируемых языках. Авторы NumPy постарались разрешить эту проблему в части обработки массивов, предложив модуль, включающий набор функций для создания многомерных массивов и работы с ними, причем исполняемый код функций реализован на языках C и Fortran. Кроме того, в пакете определены функции линейной алгебры, преобразования Фурье и генерации случайных чисел.

Сейчас я постараюсь дать самое краткое описание основ использования пакета.

Взять дистрибутив NumPy можно из репозитория SourceForge. На момент написания крайняя версия 1.3.0, выпущена 05 апреля 2009 года. Установка пакета не должна вызвать каких-либо затруднений, какой-либо особой настройки пакет так же не требует.

Модуль NumPy предназначен для работы с массивами, соответственно основной тип данных определенных в модуле - массив (nump.ndarray). Массив - контейнер, содержащий элементы одного типа (и одной длинны, если элементы вложенные массивы), организованные в упорядоченную многомерную таблицу. Доступ к элементам осуществляется по индексу - кортежу целых чисел.

Создать массив можно несколькими способами.

Способы создания массивов

Массив может быть создан на основе имеющегося списка:

>>> import numpy as np

>>> a = np.array([.1, .2, .3, .4, .5])
>>> a
array([ 0.1,  0.2,  0.3,  0.4,  0.5])
>>> type(a)
<type 'numpy.ndarray'>

Имя класса numpy.ndarray выбрано специально, чтобы не было путаницы со стандартным классом Python array.

Аналогично можно создать многомерный массив:

>>> a3 = np.array([ [ [1, 2], [3, 4], [5, 6] ], [ [7, 8], [9, 10], [11, 12] ] ])
>>> a3
array([[[ 1,  2],
        [ 3,  4],
        [ 5,  6]],

       [[ 7,  8],
        [ 9, 10],
        [11, 12]]])
>>> type(a3)
<type 'numpy.ndarray'>

Массивы NumPy во многом аналогичны стандартным спискам Python.

Доступ к элементам массива получают по индексу (разумеется, индекс первого элемента 0):

>>>print a[0]
0.1

>>>print a[3]
0.4

Для индексации многомерных массивов используют кортежи (индексы перечисляют через запятую):

>>> a3[1]
array([[ 7,  8],
       [ 9, 10],
       [11, 12]])

>>> a3[1, 1]
array([ 9, 10])

>>> a3[1, 1, 1]
10

От массивов можно брать срезы:

>>> a[2:4]
array([ 0.3,  0.4])

>>> a3[0, 1:]
array([[3, 4],
       [5, 6]])

Массивы можно использовать в различных итерациях:

>>> for i in a:
...     print i
...
0.1
0.2
0.3
0.4
0.5

>>> for i in a3:
...     for j in i:
...             print j
...
[1 2]
[3 4]
[5 6]
[7 8]
[ 9 10]
[11 12]

Каждый объект numpy.ndarray имеет атрибут shape - кортеж целых чисел, который определяет шаблон массива. Здесь под шаблоном подразумевается количество элементов каждой размерности массива, так для матрицы с n строк и m столбцов шаблон (n, m).

>>> a.shape
(5,)

>>> a3.shape
(2, 3, 2)

Изменяя атрибут shape, можно изменять размерность и структуру массива, но при этом число элементов массива должно оставаться неизменным:

>>> a3.shape = (6, 2)
>>> a3
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12]])

>>> a3.shape = (12)
>>> a3
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

>>> a3.shape = (3, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged

Массив может быть создан с помощью функции numpy.arange().

Функция arange() в самом простом варианте вызова принимает в качестве аргумента целое положительное число n, возвращает массив из n элементов от 0 до n-1:

>>> b = np.arange(5)
>>> b
array([0, 1, 2, 3, 4])
>>> type(b)
<type 'numpy.ndarray'>

Полный формат вызова функции: numpy.arange([start,] stop[, step,], dtype = None),

где:

start - опциональный аргумент, начальное значение интервала, по умолчанию равен 0;

stop - обязательный аргумент, конечное значение интервала, не входящее в сам интервал, интервал замыкает значение stop - step;

step - опциональный аргумент, шаг итерации, разность между каждым последующим и предыдущим значениями интервала, по умолчанию равен 1;

dtype - тип элементов массива, по умолчанию None, в этом случае тип элементов определяется по типу переданных функции аргуметов start, stop.

Массив может быть создан с помощью функции numpy.linspace().

Функция linspace() в простейшем случае принимает три аргумента - числа: начальный элемент массива, конечный элемент массива, количество элементов массива. Возвращает массив чисел равномерно распределенных от начального до конечного значения.

>>> c = np.linspace(-3.0, 3.0, 7)
>>> c
array([-3., -2., -1.,  0.,  1.,  2.,  3.])
>>> type(c)
<type 'numpy.ndarray'>

Полный формат вызова функции: numpy.linspace(start, stop, num = 50, endpoint = True, retstep = False),

где:

start - обязательный аргумент, первый член последовательности элементов массива;

stop - обязательный аргумент, последний член последовательности элементов массива;

num - опциональный аргумент, количество элементов массива, по умолчанию равен 50;

endpoint - опциональный аргумент, логическое значение, по умолчанию True. Если передано True, stop, последний элемент массива. Если установлено в False, последовательность элементов формируется от start до stop для num + 1 элементов, при этом в возвращаемый массив последний элемент не входит;

>>> d = np.linspace(1.0, 6.0, 5, endpoint = False)
>>> d
array([ 1.,  2.,  3.,  4.,  5.])

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

>>> f = np.linspace(.5, -.5, 5, retstep = True)
>>> f
(array([ 0.5 ,  0.25,  0.  , -0.25, -0.5 ]), -0.25)

Массив может быть создан с помощью функций numpy.zeros(), numpy.ones(), numpy.empty().

Функции принимают один обязательный аргумент - кортеж, размерность массива и возвращают массив затребованной структуры содержащий: нули (функция numpy.zeros()), единицы numpy.ones(), произвольный мусор (неинициализированный массив, функция numpy.empty()):

>>> z = np.zeros((3,3))
>>> z
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

>>> o = np.ones((3, 3))
>>> o
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

>>> e = np.empty((3,3))
>>> e
array([[  8.32475314e-306,   8.32468797e-306,   8.32462278e-306],
       [  8.32455759e-306,   8.32449240e-306,   5.99491582e+197],
       [  5.30481132e+180,   5.51965256e-311,   0.00000000e+000]])

Полный формат вызова функций:

numpy.zeros(shape, dtype = float, order = 'C')

numpy.ones(shape, dtype = float, order = 'C')

numpy.empty(shape, dtype = float, order = 'C')

где:

shape - обязательный аргумент, кортеж, требуемая размерность массива;

dtype - опциональный аргумент, тип элементов массива, по умолчанию float;

order - опциональный аргумент, строка, способ представления данных массива в памяти, два возможных значения 'C' и 'F', пока я не сталкивался с необходимостью изменять умолчальное значение.

Ну и последний из рассматриваемых способов с помощью функций numpy.zeros_like(), numpy.ones_like(), numpy.empty_like().

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

>>> d
array([ 1.,  2.,  3.,  4.,  5.])

>>> dz = np.zeros_like(d)
>>> dz
array([ 0.,  0.,  0.,  0.,  0.])

>>> do = np.ones_like(d)
>>> do
array([ 1.,  1.,  1.,  1.,  1.])

>>> de = np.empty_like(d)
>>> de
array([  2.24122267e+201,   6.32526950e-317,   0.00000000e+000,
         2.24686637e+201,   6.34874355e-321])

Полный формат вызова функций:

numpy.zeros_like(a)

numpy.ones_like(a)

numpy.empty_like(a)

где:

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

О массивах чуть подробней

Как я уже говорил массив это упорядоченная "многомерная таблица" содержащая элементы одного типа, доступ к которым осуществляется по индексу. Индекс - кортеж целых чисел, однозначно определяющий положение элемента в массиве.

Многомерную таблицу можно представить как некое расширение обычной, "двумерной" таблицы, включающей кроме строк и столбцов еще произвольное число "измерений", вместе образующих некую многомерную решетку. В документации NumPy такие измерения именуют осями (axis), а число осей у конкретного массива рангом (rank) массива (при этом термин ранг применяется и в контексте матриц, что, разумеется, не одно и тоже). Для еще большей путаницы вместо числа осей или ранга используют термин размерность (dimension). В разделе документации официального сайта проекта есть Numpy Glossary, там для слова axis приводиться одно значение, для слова rank два, а для слова dimension - три. На текущем уровне просветления моё воображение позволяет представить массив с размерностью не большей четырех, а в практической деятельности, я не сталкивался с массивами имеющими более трех осей :) Так вектор это одномерный массив, матрица, растровый черно-белый рисунок, таблица Excel двумерный, цветной растровый рисунок трехмерный.

Каждый объект класса numpy.ndarray имеет атрибут ndarray.ndim - число осей, ранг, размерность массива. По определению ранга массива значение ndarray.ndim должно быть равно числу элементов в кортеже ndarray.shape.

Общее число элементов массива можно узнать, обратившись к атрибуту ndarray.size.

>>> import numpy as np

>>> vector = np.array([1, 3, 5, 7, 9])
>>> print vector.ndim
1
>>> print vector.shape
(5,)
>>> vector.size
5

>>> bwimage = np.array([ [255, 247, 236, 12, 149], [123, 34, 147, 45, 102], [34, 69, 108, 81, 94] ])
>>> print bwimage.ndim
2
>>> print bwimage.shape
(3, 5)
>>> bwimage.size
15

>>> rgbimage = np.array([ [ [234, 126, 34, 45, 18], [123, 123, 49, 34, 56], [255, 233, 233, 233, 233] ],
... [ [12, 12, 12, 12, 12], [14, 15, 16, 17, 17], [13, 12, 14, 12, 12] ],
... [ [67, 56, 56, 57, 56], [56, 57, 56, 57, 58], [59, 58, 58, 59, 57] ] ])
>>> print rgbimage.ndim
3
>>> print rgbimage.shape
(3, 3, 5)
>>> rgbimage.size
45

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

>>> good = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ])
>>> wrong = np.array([ [1, 2, 3], [4, 5, 6], [7, 8] ])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.

Операции над массивами

Все вышесказанное было бы абсолютно бесполезной белибердой, если бы над массивами (над данными содержащимися в массивах) невозможно было б производить каких либо содержательных действий. Разумеется это не так. Цель создания пакета NumPy - предоставить пользователю Python инструменты для "быстрой" работы с большими наборами данных.

Объекты класса numpy.ndarray можно использовать как операнды в выражениях, при этом все операции с массивами будут выполняться поэлементно, то есть итогом операции будет новый массив, содержащий результаты применения операции к каждому элементу исходного массива:

>>> import numpy as np

>>> a = np.arange(6)
>>> print a
[0 1 2 3 4 5]

>>> print a + 1
[1 2 3 4 5 6]

>>> print a * 3
[ 0  3  6  9 12 15]

>>> print a ** 3
[  0   1   8  27  64 125]

>>> print a < 3
[ True  True  True False False False]

>>> a += 2
>>> print a
[2 3 4 5 6 7]

В пакете NumPy определены основные математические функции, так же позволяющие проводить поэлементные вычисления:

>>> t = np.linspace(0.0, 2 * np.pi, 4)
>>> print t
[ 0.          2.0943951   4.1887902   6.28318531]

>>> print np.cos(t)
[ 1.  -0.5 -0.5  1. ]

>>> print np.sin(t)
[  0.00000000e+00   8.66025404e-01  -8.66025404e-01  -2.44929360e-16]

>>> print np.tan(t)
[  0.00000000e+00  -1.73205081e+00   1.73205081e+00  -2.44929360e-16]

>>> s = np.linspace(2.0, 6.0, 5)
>>> print s
[ 2.  3.  4.  5.  6.]

>>> s = np.exp(s)
>>> print s
[   7.3890561    20.08553692   54.59815003  148.4131591   403.42879349]

>>> s = np.log(s)
>>> print s
[ 2.  3.  4.  5.  6.]

>>> print np.sqrt(s ** 2)
[ 2.  3.  4.  5.  6.]

Привожу список самых полезных (на мой взгляд) математических функций пакета NumPy:

Во всех определениях ниже a массив или скаляр.

numpy.abs(a) - абсолютное значение a;

numpy.around(a, decimals = 0, out = None) - округляет a до заданного количества десятичных разрядов, по умолчанию до целого. Придерживается следующего правила округления. Если значение a находиться точно по середине между двумя целыми, округление производиться до ближайшего четного целого. Так если a равно 1.5 или 2.5 будет возвращено 2, если a равно -0.5 или 0.5 будет возвращено 0.0. Аргумент decimals - целое, десятичный разряд после запятой, до которого производиться округление, если decimals отрицательное, разряд отсчитывается влево от запятой.

>>> print np.around(np.array([0.5, 1.8, 2.5, 3.5]))
[ 0.  2.  2.  4.]

>>> print np.around(np.array([1, 5, 15, 45]), decimals = 1)
[ 1  5 15 45]

>>> print np.around(np.array([1, 5, 15, 45]), decimals = -1)
[ 0  0 20 40]

Аргумент out - массив, в который будет передан результат, структура массива out, должна совпадать со структурой возвращаемого массива. Если None (по умолчанию) будет создан новый массив.

numpy.fix(a, out = None) - отбрасывает дробную часть a;

numpy.ceil(a, out = None) - округляет a до меньшего из целых больших или равных a;

>>>  print np.ceil(np.array([-2.7, -1.2, -0.5, 1.8, 2.4, 3.6]))
[-2. -1. -0.  2.  3.  4.]

numpy.floor(a, out = None) - округляет a до большего из целых меньших или равных a;

>>> print np.floor(np.array([-2.7, -1.2, -0.5, 1.8, 2.4, 3.6]))
[-3. -2. -1.  1.  2.  3.]

numpy.sign(a) - возвращает -1 если a < 0, 0 если a == 0, 1 если a > 0;

numpy.degrees(a) - конвертирует a из радиан в градусы;

numpy.radians(a) - конвертирует a из градусов в радианы;

numpy.cos(a), numpy.sin(a), numpy.tan(a) - возвращает косинус, синус, тангенс a. a в радианах;

numpy.cosh(a), numpy.sinh(a), numpy.tanh(a) - возвращает гиперболические косинус, синус, тангенс a. a в радианах;

numpy.arccos(a), numpy.arcsin(a), numpy.arctan(a) - возвращает арккосинус, арксинус, арктангенс a в радианах. Для арккосинуса в диапазоне [0, nump.pi], для арксинуса [-numpy.pi/2, numpy.pi/2], для арктангенса [-numpy.pi/2, numpy.pi/2];

numpy.arccosh(a), numpy.arcsinh(a), numpy.arctanh(a) - возвращает гиперболические косинус, синус, тангенс a. a в радианах;

numpy.exp(a) - возвращает основание натурального логарифма (число e) в степени a;

numpy.log(a), numpy.log10(a), numpy.log2(a) - возвращает натуральный логарифм a, логарифм a по основанию 10, логарифм a по основанию 2;

numpy.log1p(a) - возвращает натуральный логарифм a + 1;

numpy.sqrt(a) - возвращает положительный квадратный корень a;

numpy.square(a) - возвращает квадрат a.

В выражения можно включать несколько массивов. В случае если атрибуты ndarray.shape этих массивов совпадают, результат очевиден - действия над массивами будут производиться поэлементно:

>>> a1 = np.array([ [1.0, 2.0], [3.0, 4.0] ])
>>> a2 = np.array([ [5.0, 6.0], [7.0, 8.0] ])
>>> a3 = np.array([ [9.0, 10.0], [11.0, 12.0] ])

>>> print a1 + a2 + a3
[[ 15.  18.]
 [ 21.  24.]]

>>> print a1 * a2
[[  5.  12.]
 [ 21.  32.]]

>>> print a3 / a1
[[ 9.          5.        ]
 [ 3.66666667  3.        ]]

>>> print (a3 - a1) * a2
[[ 40.  48.]
 [ 56.  64.]]

Если атрибуты ndarray.shape не совпадают - действия над массивами производятся в соответствии с концепцией транслирования (broadcasting).

Операция транслирования - расширение одного или обоих массивов операндов до массивов с равной размерностью.

Для начала несколько примеров:

>>> a2 = np.array([1, 2])
>>> print a2
[1 2]
>>> print a2.shape
(2,)

>>> a22 = np.array([ [1, 2], [3, 4] ])
>>> print a22
[[1 2]
 [3 4]]
>>> print a22.shape
(2, 2)

>>> a32 = np.array([ [1, 2], [3, 4], [5, 6] ])
>>> print a32
[[1 2]
 [3 4]
 [5 6]]
>>> print a32.shape
(3, 2)

>>> a222 = np.array([ [ [1, 2], [3, 4] ], [ [5, 6], [7, 8] ] ])
>>> print a222
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
>>> print a222.shape
(2, 2, 2)

>>> print a22 + a2
[[2 4]
 [4 6]]
 
>>> print a32 + a2
[[2 4]
 [4 6]
 [6 8]]

>>> print a222 + a2
[[[ 2  4]
  [ 4  6]]

 [[ 6  8]
  [ 8 10]]]

>>> print a32 + a22
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

>>> print a222 + a22
[[[ 2  4]
  [ 6  8]]

 [[ 6  8]
  [10 12]]]

>>> print a222 + a32
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

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

>>> a = np.ones((7, 3, 4, 9, 8))
>>> b = np.ones((4, 9, 8))
>>> c = np.ones((4, 3, 8))

>>> print (a + b).shape
(7, 3, 4, 9, 8)

>>> print (a + c).shape
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

>>> d = np.ones((9, 7, 1, 6, 1))
>>> e = np.ones((7, 2, 1, 4))
>>> print (d + e).shape
(9, 7, 2, 6, 4)

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

>>> f = np.array([1, 2])
>>> print f
[1 2]
>>> print f.shape
(2,)

>>> g = np.array([ [3], [4], [5] ])
>>> print g
[[3]
 [4]
 [5]]
>>> print g.shape
(3, 1)

>>> h = f + g
>>> print h
[[4 5]
 [5 6]
 [6 7]]
>>> print h.shape
(3, 2)

Трансляция массивов происходит и при вызове некоторых функций.

Например, функция numpy.power(a1, a2), где a1, a2 массив или скаляр, возвращает a1 в степени a2:

>>> print np.power(np.array([-2.0, -1.0, 0.0, 2.0, 3.0, 4.0]), 4)
[  16.    1.    0.   16.   81.  256.]

>>> print np.power(np.array([-2.0, -1.0, 0.0, 2.0, 3.0, 4.0]), -4)
[ 0.0625      1.                 Inf  0.0625      0.01234568  0.00390625]

в случае если у переданных массивов не совпадает структура, проводит трансляцию.

>>> print np.power(np.array([3, 7]), np.array([ [1], [2], [3] ]))
[[  3   7]
 [  9  49]
 [ 27 343]]

Некоторые полезные функции

Здесь я приведу еще один набор полезных функций.

numpy.min(a, axis = None, out = None),

numpy.max(a, axis = None, out = None) -

возвращает минимальное, максимальное значение элементов массива соответственно:

>>> import numpy as np

>>> print np.min(np.array([ [1.0, -0.5, 3.0], [4.0, 3.0, -0.5] ]))
-0.5

axis - опциональный аргумент, индекс оси (измерения) массива по которому проводится поиск минимального, максимального значения. Под индексом оси понимается индекс в кортеже ndarray.shape.

>>> a = np.array([ [ [1.0, 2.0, 3.0], [4.0, 5.0, 6.0] ], [ [7.0, 8.0, 9.0], [11, 12, 13] ] ])
>>> print a
[[[  1.   2.   3.]
  [  4.   5.   6.]]

 [[  7.   8.   9.]
  [ 11.  12.  13.]]]
>>> print a.shape
(2, 2, 3)

>>> print np.min(a, axis = 0)
[[ 1.  2.  3.]
 [ 4.  5.  6.]]

>>> print np.min(a, axis = 1)
[[ 1.  2.  3.]
 [ 7.  8.  9.]]

>>> print np.min(a, axis = 2)
[[  1.   4.]
 [  7.  11.]]

out - опциональный аргумент, массив, в который будет помещен результат. Структура массива out должна соответствовать структуре массива результата. Если out = None (по умолчанию) будет создан новый массив.

numpy.argmin(a, axis = None),

numpy.argmax(a, axis = None) -

возвращает индекс минимального, максимального значения элементов массива соответственно:

>>> print np.argmin(np.array([ [1.0, -0.5, 3.0], [4.0, 3.0, -0.5] ]))
1

>>> print np.argmin(a, axis = 0)
[[0 0 0]
 [0 0 0]]

>>> print np.argmin(a, axis = 1)
[[0 0 0]
 [0 0 0]]

>>> print np.argmin(a, axis = 2)
[[0 0]
 [0 0]]

numpy.sum(a, axis = None, dtype = None, out = None),

numpy.prod(a, axis = None, dtype = None, out = None) -

возвращает сумму, произведение элементов массива соответственно:

>>> print np.sum(np.array([ [1.0, -0.5, 3.0], [4.0, 3.0, -0.5] ]))
10.0
>>> print np.sum(a, axis = 0)
[[  8.  10.  12.]
 [ 15.  17.  19.]]
>>> print np.sum(a, axis = 1)
[[  5.   7.   9.]
 [ 18.  20.  22.]]
>>> print np.sum(a, axis = 2)
[[  6.  15.]
 [ 24.  36.]]

Ну вот пожалуй на сегодня и все. Разговор о пакете NumPy продолжим в следующий раз.

Дополнение Firefox gTranslate. Мгновенный доступ к сервису Переводчик Google

noreply@blogger.com (Вий) — Tue, 01 Sep 2009 13:32:00 +0000

Среди многочисленных сервисов Google скромно существует Google Переводчик - попытка всемогущего поисковика создать свою собственную систему автоматического перевода. Насколько удачная? Настолько, насколько были удачны все подобные попытки предпринятые до Google.

Сервис полностью бесплатен. Поддерживает все, более менее значимые, мировые языки.

А дополнение Firefox gTranslate предназначено для максимального упрощения доступа к указанному сервису.

Установив дополнение, пользователь Firefox может выделить фрагмент текста, кликнуть правой кнопкой мыши на выделении, в контекстном меню браузера перейти на новый пункт Translate, и подождав несколько секунд (в зависимости от скорости соединения), там же в меню увидеть предлагаемый толмачом Google вариант перевода.

Если был выделен большой фрагмент текста и перевод полностью не помещается в пункте меню, для просмотра перевода необходимо активировать этот пункт. По клику откроется новая вкладка со страницей переводчика Google содержащая полный вариант перевода.

Настроек дополнение минимум, но они несколько путанные.

Чекбокс Page language включает алгоритм автоматического распознавания языка страницы.

Чекбокс Browser default language включает механизм определения языка перевода по локализации браузера.

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

Зачем тогда нужен самый верхний выпадающий список в окне настроек (в котором так же присутствует пункт Detect language и повторяющий его пункт в контекстном меню?

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

В общем я выключил оба чекбокса, выбрав из списков пункты Detect language и Russian.

Возможность выбора языка исходного текста и языка перевода присутствует и в контекстном меню.

Можно задать автоматическое распознавание языка источника (пункт меню Detect language), можно назначить исходный язык принудительно, ну и указать соответствующий ему язык перевода.

Вот еще несколько примеров перевода :)

Арабский

Китайский

Хинди

Я использую дополнение gTranslate (и сервис Переводчик Google соответственно) не как собственно переводчик (усилия по пониманию результатов автоматического перевода сопоставимы с непосредственным чтением английского текста), а как бесплатный словарь с относительно удобным интерфейсом.

Дополнение Firefox Lazarus. Восстановление данных веб-форм

noreply@blogger.com (Вий) — Mon, 24 Aug 2009 12:03:00 +0000

Бывает весьма грустно и досадно, когда, текст, набранный в веб форме любимого форума, блога или какого-нибудь социального сервиса (типа одноклассников) безвозвратно исчезает в результате ошибки на стороне сервере (характерно для выше помянутых одноклассников), дисконнекта (если вовремя не заметишь и нажмешь на кнопку "отправить") или сбоя питания (владельцы UPS могут по этому поводу не переживать). Сильное раздражение можно испытать и при попытке зарегистрироваться на некоторых популярных ресурсах - неофиту предлагается заполнить длинную форму, начиная с предполагаемого логина и пароля и заканчивая указанием в обязательных полях пола, возраста, даты рождения, часового пояса, города обитания и прочих личных предпочтений. После угадывания четырех цифр в тесте на дальтонизм происходит отправка данных заполненной формы. И вот как раз тут выясняется, что пользователь с указанным логином уже существует, причем сообщение об этом появляется на новой странице, замещающей страницу с формой. При возврате на страницу регистрации последняя так же перегружается, теряя при этом содержимое всех полей.

Пользователи Firefox легко могут избежать описанных недоразумений установив дополнение Lazarus. Это дополнение позволяет, в случае необходимости, восстановить данные веб форм одним не сильным кликом мышки.

Скачать последнюю версию Lazarus можно с официального репозитория дополнений addons.mozilla.org, домашняя страница дополнения lazarus.interclue.com.

После установки Lazarus будет автоматически сохраняет все данные вводимые пользователем в веб формы. При этом поддерживаются как "обычные" html формы, так и (частично) формы WYSIWYG редакторов, формы AJAXified, текстовые поля Richtext. Ввод в приложения Java и Flash дополнение перехватывать не способно.

Lazarus хранит собранную информацию в базе данных (на основе SQLite, файл lazarus.sqlite в папке профиля) в зашифрованном виде (авторы дополнения настаивают на более чем достаточной надежности принятого способа шифрования), и каждой форме, с которой сталкивался пользователь (URL страницы содержащей форму), в базе данных соответствует запись, включающая историю пользовательского ввода.

Как использовать дополнение?

И так, для того, что бы восстановить потерянные данные веб формы, необходимо повторно открыть страницу с злополучной формой. Кликнут правой кнопкой мыши на поле ввода формы (или на любом участке страницы охваченном тегом <form>), в появившемся меню найти два пункта относящихся к Lazarus - Recover Form и Recover Text.

Если выбрать любой из этих пунктов, раскроется подменю, состоящее из обрывков первых строк сохраненного в разное время текстового ввода. Необходимо выбрать понравившийся фрагмент и активировать его, в форме будет восстановлен соответствующий ему полный текст.

Пункт Recover Form задействует механизм реализующий восстановление данных обычных html форм, пункт Recover Text механизм восстановления содержимого форм других поддерживаемых типов.

Строка примера текста может заканчиваться символами (A) или (S). В первом случае ввод был сохранен в базу данных Lazarus по ходу набора текста, во втором случае после того как пользователь инициировал отправку содержимого формы на сервер.

Утерянное содержимое можно восстановить и не открывая страницу с формой. После установки Lazarus в строке состояния браузера появляется иконка с крестом. По клику на иконке всплывет меню в котором присутствует пункт Search Lazarus...

Lazarus предоставляет пользователю возможность проводить поиск по своей базе данных.

База поискового индекса Lazarus зашифрована, в следствие чего адекватные результаты поиска будут получены только при подстановке в поле поиска целых слов и фраз.

Выбрав из результатов поиска самую приглянувшиюся запись, можно просмотреть весь сохраненный текст, кликнув на кнопку в поле Recover

Забавно, если ввод в форму содержал теги html, окно просмотра будет содержать две вкладки - исходный код и его вид в браузере.

Ну а если кликнуть по ссылке на страницу с формой (поле Url)будет открыта эта страница, а сохраненный ввод помещен в форму.

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

Не много о настройках.

Окно настроек дополнения разбито на три вкладки: General, Security и Database.

Вкладка General.

Радиочекбоксы Show text in menu, Show saved time in menu - выбор, что показывать в меню Lazarus, начальный фрагмент текста или время сохранения.

Чекбокс Show icon in context menu - смысл прост, показывать/не показывать иконку Lazarus в контекстном меню.

Чекбокс Show icon in status bar - аналогичен предыдущему, показывать/не показывать иконку Lazarus в строке состояния.

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

Вкладка Security.

Чекбокс Save passwords - если включить, Lazarus будет сохранять содержимое форм ввода паролей. Авторы дополнения рекомендуют этого не делать!

Чекбокс Remove saved forms after - установить время по прошествии которого сохраненный ввод будет автоматически удален из базы данных.

Чекбокс Require a password to restore forms - если установить, будет запрошен пароль, который, в дальнейшем, потребуется вводить при попытке восстановить содержимое любой формы.

Чекбокс Disable Search Indexing - во включенном состоянии запрещает ведение поискового индекса. Авторы расширения заявляют, если злопыхатель получит доступ к папке профиля ни чего не подозревающего человека, то, используя зашифрованный файл поискового индекса и пользуясь каким то, не совсем мне понятным, хакерским методом атаки с помощью словаря, сможет восстановить отдельные слова ранее введенные пользователем в форму. Вот так. Пишите со всяким грамматическими ошибками и тогда ни какие словари хакерам не помогут.

Чекбокс Enable Lazarus in Private Browsing Mode - разрешить Lazarus в режиме приватного просмотра. Авторы дополнения, в случае активации этого чекбокса, советуют не забыть установить пароль на восстановление содержимого форм.

Вкладка Database.

Кнопка Search Lazarus - если нажать появится уже знакомое окно поиска по базе данных Lazaru.

Кнопка Remove all saved forms - удалить все сохраненные формы и их содержимое.

Кнопка Delete The Database - удалить файл базы данных, браузер при этом перезагрузится.

Ну вот собственно и все.

P.S.

Название дополнения Lazarus - это имя библейского персонажа Лазаря, простого парня воскрешонного Исусом Христом, а иконка дополнения это Анх (Анкх) - египетский крест, в частности символизирующий бессмертие, предстоящую вечную жизнь.

Пакет matplotlib. График с дополнительной осью ординат

noreply@blogger.com (Вий) — Fri, 21 Aug 2009 08:53:00 +0000

Часто для различных научно-технических надобностей требуется график с двумя осями ординат (осями Y) и одной общей осью абсцисс (осью X). Вот python скрипт, который строит такой график.

 1 # -*- coding: UTF-8 -*-
 2 
 3 import matplotlib as mpl
 4 import matplotlib.pyplot as plt
 5 
 6 # Значения по оси X (Большая часть данных опущена)
 7 
 8 # Время, ч
 9 
10 X = [0.00, 0.08, 0.17, ... 3.42, 3.50]
11 
12 # Значения по осям Y (Большая часть данных опущена)
13 
14 # Степнь разложения
15 
16 Y_01 = [0.0000, 0.0000, 0.0000, ... 0.8180, 0.8482]
17 
18 # Температура, oC
19 
20 Y_02 = [ 21, 30, 70, ... 721, 724 ]
21 
22 # Задем размеры изображения диаграммы
23 
24 mpl.rcParams['figure.figsize'] = (8.0, 6.0)
25 
26 # Строим диаграмму
27 
28 # Получаем ссылку на объект типа matplotlib.axes.AxesSubplot, текущую диаграмму 
29 
30 ax_01 = plt.axes()
31 
32 # Задаем исходные данные для первой линии диаграммы (линии степени разложения), внешний вид линии и маркера.
33 # Функция plot() возвращает ссылку на объект класса matplotlib.lines.Line2D
34 
35 line_01, = ax_01.plot(X, Y_01, 'bh:')
36 
37 # Задаем интервалы значений по осям X и основной оси Y
38 
39 ax_01.axis([-0.04, 3.6, -0.01, 0.90])
40 
41 # Включаем сетку по оси X и основной оси Y. Задаем цвет сетки
42 
43 ax_01.grid(color = 'b')
44 
45 # Задаем подписи к осям X и основной оси Y
46 
47 ax_01.set_xlabel(u'Время, ч')
48 ax_01.set_ylabel(u'Степень разложения')
49 
50 # Задаем заголовок диаграммы
51 
52 ax_01.set_title(u'Термограмма разложения оксалата кальция')
53 
54 # Включаем дополнительную ось Y
55 
56 ax_02 = ax_01.twinx()
57 
58 # Задаем исходные данные для второй линии диаграммы (линии степени разложения), внешний вид линии и маркера.
59 # Функция plot() возвращает ссылку на объект класса matplotlib.lines.Line2D
60 
61 line_02 = ax_02.plot(X, Y_02, 'ro:')
62 
63 # Задаем интервалы значений по осям X и дополнительной оси Y
64 
65 ax_02.axis([-0.04, 3.6, 0.0, 800.0])
66 
67 # Задаем подпись к дополнительной оси Y
68 
69 ax_02.set_ylabel(u'Температура, \u00b0C')
70 
71 # Включаем сетку по дополнительной оси Y. Задаем цвет сетки
72 
73 ax_02.grid(color = 'r')
74 
75 # Задаем исходные данные для легенды и место ее размещение
76 
77 ax_02.legend((line_01, line_02), (u'Степень разложения', u'Температура'), loc = 'best')
78 
79 # Сохраняем построенную диаграмму в файл
80 # Задаем имя файла и его тип
81 
82 plt.savefig('termo.png', format = 'png')

В результате выполнения скрипта, в файле termo.png будет сохранено такое изображение:

Пояснения к скрипту.

В начале небольшое отступление. Matplotlib при работе со своими графическими объектами придерживается следующей идеологии: существуют текущая фигура (в документации figure) и текущая гм... диаграмма (в документации axes). Фигура это некое полотно на котором происходит построение чего либо. Диаграмма это объект принадлежащий фигуре (одной фигуре может принадлежать несколько диаграмм), к которому собственно и применяются команды pyplot. Диаграммы могут быть различных типов (в нашем случае прямоугольная 2D - обычный график). Тип диаграммы задается командой её построения (в нашем случае plot()) и определяет назначение диаграммы, внешний вид, свойства и возможные действия с ней.

В выражении ax_01 = plt.axes() мы получаем ссылку на объект типа matplotlib.axes.AxesSubplot - текущую диаграмму. Далее, при построении графика, мы пользуемся методами этого объекта, действие которых в целом аналогично действию рассмотренным в предыдущих постах функций модуля pyplot.

После построения первой линии диаграммы (зависимости степени разложения от времени) создаем новый объект класса matplotlib.axes.Axes и получаем ссылку на него: ax_02 = ax_01.twinx(). В результате на диаграмму ax_01 будет "наложена" вторая диаграмма ax_02, при этом, ось X будет общей для обеих диаграмм. Далее с помощью тех же методов, только уже принадлежащими объекту ax_02 строим и оформляем вторую линию (зависимость температуры от времени).

Вот и все, сохраняем получившееся творение.

Подробнее о фигурах и диаграммах поговорим позже.

Предыдущий пост по теме: Пакет matplotlib. Строим банальный график.

Следующий пост по теме: Пакет matplotlib. Наводим красивости.

Как вставить в блог фрагмент кода с подсветкой синтаксиса

noreply@blogger.com (Вий) — Tue, 18 Aug 2009 10:26:00 +0000

Часто в блоге (на сайте) необходимо разместить фрагмент кода на том или ином языке программирования. Такой фрагмент будет выглядеть гораздо красивей и понятнее если сделать подсветку синтаксиса как в продвинутых текстовых редакторах. Но редактировать вручную каждую строчку кода, раскрашивая элементы каждый в свой цвет, совсем не хочется. Конечно можно воспользоваться каким-нибудь бесплатным скриптом разукрашивающим код автоматически. Но скрипт надо ещё где-то разместить, а подключать и настраивать его все равно придется правя html код сообщения (страницы).

К счастью можно обойтись без всяких дополнительных скриптов и не очень то напрягаться при этом. Для этого достаточно воспользоваться редактором Vim. В командной строке Vim вводим:

:help convert-to-html

и узнаем, что в редакторе имеется скрипт 2html, который преобразует отображение активного окна в html файл. Запустить скрипт можно обычным образом:

:runtime! syntax/2html.vim

или воспользоваться командой:

:TOhtml

Готовый html файл откроется в отдельном окне редактора. Окно редактор после выполнения команды будет выглядеть вот так:

Из полученного html файла необходимо удалить всё непосредственно не касающееся кода (несколько строк в начале и конце файла). Если при размещении кода в блоге используется тег <pre> командой редактора:

:%s/<br>//g

можно удалить все теги .

В blogger'е раскрашенный таким образом код будет выглядеть вот так:

 1 # -*- coding: UTF-8 -*-
 2 
 3 import matplotlib.pyplot as plt
 4 
 5 # Значения по оси X
 6 
 7 X = [20.0, 40.0, 60.0, 80.0, 100.0]
 8 
 9 # Набор значений по оси Y
10 
11 Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
12 Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
13 Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]
14 
15 # Строим диаграмму
16 
17 # Задаем исходные данные для каждой линии диаграммы, внешний вид линий и маркеров.
18 
19 plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
20 plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
21 plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')
22 
23 # Задем интервалы значений по осям X и Y
24 
25 plt.axis([15.0, 105.0, 0.75, 1.0])
26 
27 # Задаем заголовок диаграммы
28 
29 plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')
30 
31 # Задаем подписи к осям X и Y
32 
33 plt.xlabel(u'Массовая доля этилового спирта, %')
34 plt.ylabel(u'Плотность, г/мл')
35 
36 # Задаем исходные данные для легенды и ее размещение
37 
38 plt.legend(loc = 'best')
39 
40 # Включаем сетку
41 
42 plt.grid()
43 
44 # Сохраняем построенную диаграмму в файл
45 # Задаем имя файла и его тип
46 
47 plt.savefig('spirit_02.png', format = 'png')
48 
49 plt.show()

Код на языку Python позаимствован из прошлого поста.

Под конец замечу, что Vim умеет подсвечивать синтаксис всех мыслимых языков программирования и описанным способом разукрасить и вставить в блог можно код чего угодно.

Предыдущий пост по теме: Как вставить картинку в блог.

Как вставить картинку в блог

noreply@blogger.com (Вий) — Fri, 14 Aug 2009 11:16:00 +0000

Такой вопрос рано или поздно задет себе любой блогер.

Вот, на мой взгляд, самый простой способ.

Для того чтобы вставить изображение в сообщение блога, как и в любую другую html страницу, необходимо воспользоваться тегом <img>, в атрибуте src которого указать ссылку на это изображение. Для этого, прежде всего, необходимо разместить файл с изображением где-то в Интернет, так, чтобы любой пользователь мог получить к нему доступ. Здесь лучше всего (на мой взгляд) воспользоваться сервисом Google Picasa. Заводим (если еще нет) аккаунт Google, заходим на сайт сервиса. Жмем на кнопку "загрузить" сверху в середине страницы.

Появится окно с предложением создать или выбрать альбом

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

Кстати, если блог размещен на Blogger'е то при первой попытке вставит картинку с помощью кнопки "добавить изображения" редактора сообщений, на сервисе Picasa автоматически будет создан частный альбом с именем блога и файлы картинок будут загружаться в этот альбом.

После выбора альбома, сервис Picasa покажет форму для загрузки изображений. Пользователь за раз может загрузить пять файлов.

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

После того как кнопка изменения масштаба станет неактивной, кликаем правой кнопкой мыши на изображении. В всплывающем меню выбираем "Copy Image Location" (если у Вас браузер Firefox).

Далее в html редакторе блога в нужном месте Вашего сообщения размещаем тег <img src=""/>, устанавливаем курсор между двумя знаками кавычек и вставляем из буфера обмена ссылку на изображение.

<img src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhKG7ApGZzLT_ERuv8mTgJLHVBAtVonuAPN7L4UFk0_Emid4vIVt24AsujkgAJHRcQYZ1e192H8HPdiDgSYKq-1T7l3NT0aTCJt9FpqbIsCmiQowwB0tMCIu4cPYtexmFOlH7JOfOFLEc4/"/>

Сохраняем сообщение. Вот собственно и все.

Ну можно еще добавить, что в контекстном меню браузера Internet Explorer нет пункта "Copy Image Location", но там есть пункт "Property/Свойства". Кликаем правой кнопкой на картинке, выбираем пункт "Property".

В появившемся окне копируем ссылку на изображение.

Далее поступаем как описано выше.

Следующий пост по теме: Как вставить в блог фрагмент кода с подсветкой синтаксиса.

Пакет matplotlib. Строим банальный график

noreply@blogger.com (Вий) — Mon, 10 Aug 2009 13:45:00 +0000

Те кому хотя бы раз в жизни приходилось обучаться в техническом ВУЗ'е строили такие графики штук по 5-10 в день. Банальный график это две пересекающиеся под прямым углом линии (координатные оси) на которые нанесены масштабные деления с числами. Линии снабжены подписями - что собственно эти числа обозначают. В плоскости образованной линиями, тем или иным способом (с помощью точек, кружков, треугольничков, крестиков и т.д.) помечаются некоторые значения. График снабжается легендой, чтобы можно было узнать чем кружки отличаются от крестиков и подписью, чтобы можно было узнать что и зачем построено. Вот именно такой график рисует нижеприведенный скрипт.

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt

# Значения по оси X

X = [20.0, 40.0, 60.0, 80.0, 100.0]

# Набор значений по оси Y

Y_10 = [0.97252, 0.94238, 0.89927, 0.85197, 0.79784]
Y_20 = [0.96864, 0.93518, 0.89113, 0.84344, 0.78934]
Y_30 = [0.96395, 0.92770, 0.88278, 0.83473, 0.78075]

# Строим диаграмму

# Задаем исходные данные для каждой линии диаграммы, внешний вид линий и маркеров.
# Функция plot() возвращает кортеж ссылок на объекты класса matplotlib.lines.Line2D

line_10, line_20, line_30 = plt.plot(X, Y_10, 'bD:', X, Y_20, 'r^:', X, Y_30, 'go:')

# Задаем интервалы значений по осям X и Y

plt.axis([15.0, 105.0, 0.75, 1.0])

# Задаем заголовок диаграммы

plt.title(u'Зависимость плотности водных растворов этилового спирта от температуры')

# Задаем подписи к осям X и Y

plt.xlabel(u'Массовая доля этилового спирта, %')
plt.ylabel(u'Плотность, г/мл')

# Задаем исходные данные для легенды и ее размещение

plt.legend( (line_10, line_20, line_30), (u'Температура 10 \u00b0C', u'Температура 20 \u00b0C', u'Температура 30 \u00b0C'), loc = 'best')

# Включаем сетку

plt.grid()

# Сохраняем построенную диаграмму в файл

# Задаем имя файла и его тип

plt.savefig('spirit.png', format = 'png')

В результате выполнения скрипта файл spirit.png должен содержать такое изображение.

Комментарии к коду.

Функция plot() строит 2D диаграмму - задает исходные данные и внешний вид линии (линий) диаграммы. Функция принимает произвольное число наборов аргументов вида X_set, Y_set, format_string. Где X_set и Y_set типа list или numpy.array - значения откладываемые по осям X и Y соответственно, format_string - строка форматирования (не обязательный аргумент набора), определяет стиль и цвет линии. Строка форматирования (позаимствована из системы Matlab) включает (в произвольном порядке) три подстроки определяющих стиль линии, стиль маркера, цвет. Например 'g^:' = 'g' + '^' + ':' - цвет зеленый, маркер треугольник вершиной вверх, линия состоит из точек.

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

Стили линий

Символ	Описание
'-'	solid line style	непрерывная линия
'--'	dashed line style	линия из штрихов
'-.'	dash-dot line style	чередование штрихов и точек
':'	dotted line style	линия из точек

Стили маркеров

Я умышленно не стал переводить названия маркеров из документации, дабы не придумывать как по русски выразить различия между point marker и pixel marker или как обозвать tri_right marker с thin_diamond marker.

Символ	Описание
'.'	point marker
','	pixel marker
'o'	circle marker
'v'	triangle_down marker
'^'	triangle_up marker
'<'	triangle_left marker
'>'	triangle_right marker
'1'	tri_down marker
'2'	tri_up marker
'3'	tri_left marker
'4'	tri_right marker
's'	square marker
'p'	pentagon marker
'*'	star marker
'h'	hexagon1 marker
'H'	hexagon2 marker
'+'	plus marker
'x'	x marker
'D'	diamond marker
'd'	thin_diamond marker
'\|'	vline marker
'_'	hline marker

Цвета

Символ	Цвет
'b'	blue	синий
'g'	green	зеленый
'r'	red	красный
'c'	cyan	бирюзовый
'm'	magenta	пурпурный
'y'	yellow	желтый
'k'	black	черный
'w'	white	белый

Функция plot() возвращает кортеж ссылок на объекты класса matplotlib.lines.Line2D. Каждый из объектов кортежа представляет линию на диаграмме. Посредством методов объектов можно менять свойства (внешний вид) любой из линий. В нашем случае кортеж ссылок в дальнейшем передается функции legend().

Функция axis() задает свойства осей диаграммы. В частности с её помощью можно установит масштаб осей. Для этого функции необходимо передать одни аргумент - список из четырех значений. Функция рассматривает такой список как [x_min, x_max, y_min, y_max], где x_min, y_min минимальные, x_max, y_max максимальные значения откладываемые по осям X и Y соответственно.

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

Аргумент	Действие
'off'	Выключает отображение осей (вместе с подписями)
'equal'	Изменяет масштаб по осям так, чтобы равному изменению x или y соответсвовала одинаковая длинна на диаграмме. Как сказано в документации "круг превращается в круг".
'scaled'	Тот же эффект, что у 'equal' достигается изменением соотношения сторон диаграммы.
'tight'	Масштаб по осям изменяется так, что бы отображались все данные. Если все данные уже находятся в поле диаграммы, масштаб изменяется так, чтобы линии располагались в центре диаграммы.

Функция legend() задает свойства и расположения легенды диаграммы. В примере использован вызов функции принимающий в качестве первых двух аргументов кортежи - первый содержит ссылки на объекты типа Line2D, второй соответствующие им подписи. Именованный аргумент loc задает расположение легенды, может быть или строкой или числом. Возможные варианты значений аргумента loc представлены в таблице.

Значения аргумента loc		Расположение легенды
Строка	Число	Расположение легенды
'best'	0	Оптимальное расположение легенды определяется автоматически. Значение по умолчанию.
'upper right'	1	сверху справа
'upper left'	2	сверху слева
'lower left'	3	снизу слева
'lower right'	4	снизу справа
'right'	5	справа
'center left'	6	в центре слева
'center right'	7	в центре справа, не отличается от 'right'
'lower center'	8	в сентер снизу
'upper center'	9	в центре сверху
'center'	10	в центре диаграммы

Сформировать легенду можно и другим (на мой взгляд менее громоздким) способом. Функция plot() (если задано построение только одной линии) принимает именованный аргумент label. Это строка, подпись к линии, на основании которой вызов функции legend() без аргументов добавляет к диаграмме легенду. Вышеприведенный скрипт мог быть написан и так:

# Строим диаграмму

# Задаем исходные данные для каждой линии диаграммы, внешний вид линий и маркеров, подписи.

plt.plot(X, Y_10, 'bD:',  label = u'Температура 10 \u00b0C')
plt.plot(X, Y_20, 'r^:',  label = u'Температура 20 \u00b0C')
plt.plot(X, Y_30, 'go:',  label = u'Температура 30 \u00b0C')

# Добавляем к диаграмме легенду

plt.legend(loc = 'best')

Функция grid() строит сетку координатных осей.

Функция savefig() сохраняет диаграмму в файл. Первый аргумент - строка, путь к файлу. Именованный аргумент format - строка, задает формат файла, может принимать значения 'png', 'pdf', 'ps', 'eps', 'svg'.

Здесь необходимо сказать пару слов о размерах и разрешении получающихся изображений диаграмм. В файле matplotlibrc можно задать два свойства figure.figsize и figure.dpi (свойства можно задать, разумеется и через структуру rcParams, смотри предыдущий пост).

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

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

Предыдущий пост по теме: Пакет matplotlib. Установка, проверка, настройка.

Следующий пост по теме: Пакет matplotlib. График с дополнительной осью ординат.

Пакет matplotlib. Установка, проверка, настройка

noreply@blogger.com (Вий) — Sun, 09 Aug 2009 09:30:00 +0000

Введение

matplotlib - набор дополнительных модулей (библиотек) языка Python. Предоставляет средства для построения самых разнообразных 2D графиков и диаграмм данных. Достоинства. Отличается простотой использования - для построения весьма мудреных и красочно оформленных диаграмм достаточно нескольких строк кода. При этот качество получаемых изображений более чем достаточно для их публикования. Один из выходных формата файлов - Postscript, что, соответственно, позволяет вставлять изображения в документы TeX. Предоставляет API для встраивания своих графических объектов в приложения пользователя.

Установка

Официальный сайт проекта matplotlib. Дистрибутив для Windows можно заполучить на Sourceforge. Текущая версия 0.99.0, выпущена 06 августа 2009.

Для установки необходим, разумеется, сам Python и модуль NumPy. NumPy предоставляет методы для работы с огромными многомерными массивами. Дистрибутив для Windows так же можно взять на Sourceforge. Текущая версия 1.3.0 от 05 апреля 2009.

В Windows установка и matplotlib и NumPy не должна вызвать ни каких проблем. Скачиваем и запускаем файл дистрибутива.

Проверка

После установки проверяем работоспособность. Запускаем консоль Python, вводим:

>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3])
[<matplotlib.lines.Line2D object at 0x0301E810>]
>>> plt.title('Прямая линия')
<matplotlib.text.Text object at 0x03062430>
>>> plt.show()

В результате должно появиться вот такое окно диаграммы:

Что было сделано? Из пакета matplotlib импортирован модуль pyplot под именем plt. Модуль pyplot содержит функции (похожие на команды) создания диаграмм и изменения свойств их элементов. Функция plot() строит прямоугольные двумерные диаграммы (графики) в координатах X - Y. Если функции plot передан один аргумент (в нашем случае - список [1,2,3]), она рассматривает его как совокупность значений откладываемых по оси Y, тогда по оси X ему будет соответствовать автоматически сгенерированный набор чисел 0,1,2...N - 1, где N - число элементов в переданном списке. Функция title() задает заголовок диаграммы, а функция show() выводит интерактивное окно диаграммы. В общем все очень просто. Вот только вместо заголовка диаграммы "Прямая линия" 11 прямоугольников, не настроенный matplotlib не может найти шрифты с кириллическими символами.

Настройка

Пакет matplotlib можно легко настроить через конфигурационный файл matplotlibrc. Если Python установлен в папку C:\Python26\ файл matplotlibrc находится в папке: C:\Python26\Lib\site-packages\matplotlib\mpl-data\. Вносить изменения можно прямо здесь, но лучше скопировать файл в папку пользователя: C:\Documents and Settings\UserName\.matplotlib\, иначе при переустановке пакета конфигурационный файл будет перезаписан. Параметры пакета задаются в файле в виде пар свойство : значение, символ # отделяет комментарий. Свойство font.family определяет тип активного шрифта по умолчанию, может принимать пять значений: serif, sans-serif, cursive, fantasy, monospace. В свою очередь свойства font.serif, font.sans-serif, font.cursive, font.fantasy, font.monospace содержат списки имен шрифтов (через запятую, в порядке уменьшения приоритета) соответствующих каждому типу. Для "русификации" matplotlib необходимо изменить имена шрифтов в списке, на имена доступных в системе шрифтов, содержащих кириллические символы. Например так:

font.serif : Verdana, Arial
font.sans-serif : Tahoma, Arial
font.cursive : Courier New, Arial
font.fantasy : Comic Sans MS, Arial
font.monospace : Arial

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

plt.title(u'Прямая линия')

В случае скрипта исходный файл должен быть в кодировке UTF-8. Кодировку файла так же следует указать явно. Для этого в первых строках программы пишем:

# -*- coding: UTF-8 -*-

Вносим изменения в файл matplotlibrc, повторяем ввод в консоле Python:

>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3])
[<matplotlib.lines.Line2D object at 0x02F118F0>]
>>> plt.title(u'Прямая линия')
<matplotlib.text.Text object at 0x02F59510>
>>> plt.xlabel(u'Значения по оси X')
<matplotlib.text.Text object at 0x02F1BBF0>
>>> plt.ylabel(u'Значения по оси Y')
<matplotlib.text.Text object at 0x02F44D10>
>>> plt.show()

Ну вот теперь подписи диаграммы отображаются корректно:

Функции pyplot.xlabel(), pyplot.ylabel(), как легко догадаться по названию, устанавливают подписи к осям X и Y соответственно.

Пакет matplotlib можно настраивать и динамически (во время выполнения программы). В пакете определена структура matplotlib.rcParams, с которой работают как со словарем. Ключевые слова в данном случае - имена свойств файла matplotlibrc.

Настройки шрифтов через matplotlib.rcParams можно изменить например так:

>>> import matplotlib as mpl
>>> import matplotlib.pyplot as plt
>>> mpl.rcParams['font.family'] = 'fantasy'
>>> mpl.rcParams['font.fantasy'] = 'Comic Sans MS, Arial'
>>> plt.plot([1,2,3,4], [1,4,9,16], 'ro')
[<matplotlib.lines.Line2D object at 0x02E837B0>]
>>> plt.title(u'Парабола')
<matplotlib.text.Text object at 0x02E65530>
>>> plt.xlabel(u'Значения x')
<matplotlib.text.Text object at 0x02E2DC70>
>>> plt.ylabel(u'Значения x в квадрате')
<matplotlib.text.Text object at 0x02E50D30>
>>> plt.show()

В результате должно получиться вот что:

Функции pyplot.plot() можно передать произвольное число пар аргументов типов list или array (тип array определен в модуле numpy). В примере выше передана одна пара: [1,2,3,4], [1,4,9,16]. Первый элемент каждой пары функция рассматривает как значения откладываемые по оси X, второй элемент как значения по оси Y. Соответственно для каждой пары элементов строиться своя кривая на диаграмме. После каждой пары данных может быть передан дополнительный аргумент типа string - строка форматирования, которая определяет внешний вид кривой. Формат строки позаимствован из системы Matlab. Строка включает три подстроки. Первая подстрока задает цвет графического элемента, вторая стиль маркера, третья стиль линии. В примере 'ro' = 'r' + 'o', где 'r' - красный, 'o' - кружок. По умолчанию 'b-' - синяя непрерывная линия.

Немного о назначении кнопок интерактивного окна диаграммы.

Кнопка

(pan/zoom) предназначена для прокрутки/масштабирования диаграммы. Нажимаем на кнопку, указатель мыши приобретает вид перекрещенных стрелок. Если двигать мышь и удерживать левую кнопку - диаграмма будет прокручиваться по направлению движения указателя. Если двигать мышь и удерживать правую кнопку - масштаб диаграммы будет изменяться, при движении вверх/вправо - уменьшаться, вниз/влево - увеличиваться. При нажатых клавишах "x" и "y" перемещение/масштабирование диаграммы будет происходить по осям X и Y соответственно, при нажатой клавише Ctrl диаграмма будет изменяться так, чтобы сохранились её пропорции (aspect ratio).

Кнопка

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

Кнопки

позволяют перемещаться по истории изменения диаграммы. Все изменения вносимые в диаграмму пользователем (масштабирование, прокрутка) запоминаются. Кнопки со стрелками позволяют перемещаться вперед/назад по имеющимся вариантам диаграммы. Кнопка с домиком возвращает диаграмму к исходному состоянию.

Кнопка

вызывает стандартный для системы диалог сохранения файла. Позволяет сохранить диаграмму в файл. Можно выбрать следующие форматы файла диаграммы: png, pdf, svg, eps, ps. К сожалению не работает сохранение в формате emf (модуль pyemf разработчиком больше не поддерживается). Через формат emf было очень удобно вставлять диаграммы в документы Word.

Следующий пост по теме: Пакет matplotlib. Строим банальный график.

Приветствую Вас на Незамысловатом блоге

noreply@blogger.com (Вий) — Sun, 09 Aug 2009 09:00:00 +0000

Решил тоже поиграться с блогами - вот моя первая попытка блогописания.

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

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