воскресенье, 22 декабря 2013 г.

Горячие клавиши в FireFox

Навигация

Команда Сочетание клавиш
Назад Alt +
Backspace
Вперёд Alt +
Shift + Backspace
Домашняя страница Alt + Home
Открыть файл Ctrl + O
Обновить F5
Ctrl + R
Обновить (не используя кэш) Ctrl + F5
Ctrl + Shift + R
Остановить Esc

Текущая страница

Команда Сочетание клавиш
Перейти в конец страницы End
Перейти в начало страницы Home
Переместиться в следующий фрейм (на страницах с фреймами) F6
Переместиться в предыдущий фрейм (на страницах с фреймами) Shift + F6
Печать Ctrl + P
Сохранить страницу как Ctrl + S
Увеличить масштаб Ctrl + +
Уменьшить масштаб Ctrl + -
Вернуть исходный масштаб Ctrl + 0

Редактирование

Команда Сочетания клавиш
Копировать Ctrl + C
Вырезать Ctrl + X
Удалить Del
Вставить Ctrl + V
Вставить (как простой текст) Ctrl + Shift + V
Повторить Ctrl + Y
Выделить всё Ctrl + A
Отменить последнее действие Ctrl + Z

Поиск

Команда Сочетания клавиш
Найти Ctrl + F
Найти ещё раз F3
Ctrl + G
Найти предыдущее совпадение Shift + F3
Ctrl + Shift + G
Быстрый поиск только в тексте ссылок по мере ввода '
Быстрый поиск текста по мере ввода /
Закрыть панель поиска или быстрого поиска Esc - когда фокус находится в панели поиска или быстрого поиска
Панель поиска Ctrl + K
Ctrl + E
Выбор или управление поисковыми системами Alt +
Alt +
F4
- когда фокус находится в строке поиска

Окна и вкладки

Для работы некоторых из этих сочетаний клавиш необходимо, чтобы выбранная в данный момент вкладка была "в фокусе". В настоящее время единственный способ сделать это заключается в выборе соседнего объекта и "переключения" на выбранную в данный момент вкладку, например, нажав Alt + D для выбора строки адреса, а затем дважды нажав Shift + Tab.
Команда Сочетания клавиш
Закрыть вкладку Ctrl + W
Ctrl + F4
- за исключением закреплённых вкладок
Закрыть окно Ctrl + Shift + W
Alt + F4
Переместить вкладку влево (когда фокус на вкладке) Ctrl + Shift + Page Up
Переместить вкладку вправо (когда фокус на вкладке) Ctrl + Shift + Page Down
Переместить вкладку в начало (когда фокус на вкладке) Ctrl + Home
Переместить вкладку в конец (когда фокус на вкладке) Ctrl + End
Новая вкладка Ctrl + T
Новое окно Ctrl + N
Новое приватное окно Ctrl + Shift + P
Перейти к следующей вкладке Ctrl + Tab
Ctrl + Page Down
Открыть адрес в новой вкладкеAlt + Enter - из адресной строки или панели поиска
Перейти к предыдущей вкладке Ctrl + Shift + Tab
Ctrl + Page Up
Восстановить закрытую вкладку Ctrl + Shift + T
Восстановить закрытое окно Ctrl + Shift + N
Выбрать вкладку по её порядковому номеру (от 1 до 8) Ctrl + 1по8
Выбрать последнюю вкладку Ctrl + 9
Вид групп вкладок Ctrl + Shift + E
Закрыть вид групп вкладок Esc
Следующая группа вкладок Ctrl + ` - только для некоторых раскладок клавиатуры
Предыдущая группа вкладок Ctrl + Shift + ` - только для некоторых раскладок клавиатуры

История

Команда Сочетания клавиш
Боковая панель журнала Ctrl + H
Окно Библиотеки (История) Ctrl + Shift + H
Удалить недавнюю историю Ctrl + Shift + Del

Закладки

Команда Сочетания клавиш
Добавить все вкладки в закладки Ctrl + Shift + D
Добавить страницу в закладки Ctrl + D
Боковая панель закладок Ctrl + B
Ctrl + I
Окно Библиотека (Закладки) Ctrl + Shift + B

Инструменты

Команда Сочетания клавиш
Загрузки Ctrl + J
Дополнения Ctrl + Shift + A
Переключить Инструменты разработчика F12
Ctrl + Shift + I
Веб-консоль Ctrl + Shift + K
Инспектор Ctrl + Shift + C
Отладчик Ctrl + Shift + S
Редактор стилей Shift + F7
Профайлер Shift + F5
Сеть Ctrl + Shift + Q
Панель разработки Shift + F2
Режим адаптивного дизайна Ctrl + Shift + M
Простой редактор JavaScript Shift + F4
Исходный код страницы Ctrl + U
Консоль браузера Ctrl + Shift + J

Просмотр PDF

Команда Сочетания клавиш
Следующая страница n или k или
Предыдущая страница p или j или
Увеличить масштаб Ctrl + +
Уменьшить масштаб Ctrl + -
Автоматический масштаб Ctrl + 0
Повернуть документ по часовой стрелке r
Повернуть документ против часовой стрелки Shift + r

Разное

Команда Сочетания клавиш
Дополнить адрес доменным суффиксом .com Ctrl + Enter
Дополнить адрес доменным суффиксом .net Shift + Enter
Дополнить адрес доменным суффиксом .org Ctrl + Shift + Enter
Удалить строку из списка автозаполнения адресов Del
Переключить полноэкранный режим F11
Показать панель меню (когда скрыта) Alt
F10
Скрыть/Показать панель дополнений Ctrl + \
Режим активного курсора F7
Выделить весь текст в панели адреса F6
Alt + D
Ctrl + L
Остановить анимацию GIF Esc - после того, как страница будет полностью загружена

Сочетания клавиш для медиа (только видео в формате Ogg и WebM)


Команда Сочетания клавиш
Переключение между воспроизведением и паузой Пробел
Уменьшить громкость
Увеличить громкость
Выключить звук Ctrl +
Включить звук Ctrl +
Прокрутить назад на 15 секунд
Прокрутить назад на 10 % Ctrl +
Прокрутить вперёд на 15 секунд
Прокрутить вперёд на 10 % Ctrl +
Прокрутить в начало Home
Прокрутить в конец End



Горячие клавиши VirtualBox


Действие Клавиша по умолчанию Действие
TakeSnapshot Host key + T сделать снимок
TakeScreenshot Host key +E сделать скриншот
MouseIntegration Host key +I переключение интеграции мыши
TypeCAD Host key +Del ввод Ctrl+Alt+Del
TypeCABS Host key +Backspace ввод Ctrl+Alt+Backspace
Pause Host key +P пауза VM
Reset Host key +R жёсткий сброс гостевой OS
SaveState
сохранить состояние ВМ и завершить
Shutdown Host key +H кнопка питания ACPI - выключение гостевой OS
Close Host key +Q показать диалог ЗАКРЫТЬ VM
FullscreenMode Host key +F переключение в полноэкранный режим
SeamlessMode Host key +L переключить VM в режиме интеграции
ScaleMode Host key +C переключить VM в режим масштабирования
GuestAutoResize Host key +G автоматически изменять размер окна гостевой OS
WindowAdjust Host key +A немедленно изменить размер окна гостевой
PopupMenu Host key +Home показать контекстное меню в полноэкранном  режиме
SettingsDialog Host key +S открыть диалог настроек VM
InformationsDialog Host key +N показать информационное окно
NetworkAdaptersDialog
показать диалоговое окно сетевых интерфейсов
SharedFoldersDialog
показать диалоговое окно виртуальной машины с общим папкам
InstallGuestAdditions Host key +D смонтировать ISO содержащий гостевые дополнения

Host key - это клавиша правый CTRL.
Но её можно сменить на любую другую в настройках.

четверг, 24 октября 2013 г.

Редактор EMACS

Команды:

CONTROL-F и CONTROL-B

перемещают курсор вперед и назад по символам.


META-f и META-b

перемещают курсор вперед и назад по словам.


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

META--

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

CONTROL-U 5

Если шаг отрицательный, то направление перемещения меняется:

CONTROL-U -3


Команда:

CONTROL-D

удаляет символ под курсором


META-d

стирает символы от курсора до конца текущего слова.


META-t

меняет местами слово до указателя со словом после него.


CONTROL-A

переместить курсор к началу строки


CONTROL-E

переместить курсор к концу строки


CONTROL-K

стирает символы от курсора до конца текущей строки
(она не удаляет символ перевода строки, указатель ставит перед ним)


META-a

перемещает курсор к началу предложения


META-e

перемещает курсор к концу предложения


META-k

стирает текст от текущего положения курсора до конца предложения.


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

Чтобы отобразить значение этой переменной, нужно ввести команду:

CONTROL-H v sentence-end ВВОД


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

paragraph-separate
paragraph-start

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

Команда

META-{

перемещает курсор назад на начало самого последнего пройденного абзаца


META-}

перемещает курсор вперед на конец следующего абзаца


META-h

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

(то есть она помещает указатель на начало, а метку - на конец этого абзаца)


Заполнение

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

Команда

META-x auto-fill-mode

включает и выключает режим автозаполнения.

 Когда этот режим включен, emacs автоматически разбивает строки, когда
вы вводите пробел или нажимаете клавишу ВВОД и оказываетесь за
пределами указанной ширины строки. Это свойство полезно при вводе
нового текста.


 Режим автозаполнения не занимается автоматическим перезаполнением
всего абзаца, с которым вы работаете в данный момент.  Если текст
добавляется в середине абзаца, режим автозаполнения разбивает новый
текст по мере его ввода, но не занимается перезаполнением всего
абзаца.

 Чтобы провести перезаполнение абзаца или области абзаца, нужно
использовать либо команду:

META-q

для перезаполнения текущего абзаца либо команду:

META-x fill-region

для перезаполнения каждого абзаца в области.


 Можно изменить установленную по умолчанию ширину заполнения, имеющую
значение 70, присвоив новое значение переменной:

fill-column

Чтобы установить значение переменной fill-column на текущую позицию
курсора, нужно ввести команду:

CONTROL-X f

а чтобы установить значение переменной fill-column равным числу nnn,
где число 0 указывает на левую границу, нужно ввести команду:

CONTROL-U nnn CONTROL-X f










воскресенье, 29 сентября 2013 г.

Homebrew в Mac OS


Для начала нужно установить XCode.

Далее устанавливаем homebrew командой:
 
$ ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go/install)"

Проверяем, что все установилось правильно:

brew doctor


Для PowerPC (Mac OS Tiger или Leopard):

ruby -e "$(curl -fsSkL raw.github.com/mistydemeo/tigerbrew/go)"

В ~/.bash_profile:

пропишем пути

export PATH=/usr/local/sbin:/usr/local/bin:$PATH





понедельник, 16 сентября 2013 г.

Start/Stop Oracle WebLogic Server

Запуск Oracle WebLogic Server:

1. Запускаем Node Manager:

nohup /u01/app/orawls/middleware/wlserver_10.3/server/bin/startNodeManager.sh &


2. Откроем  консоль:

cd /u01/app/orawls/middleware/wlserver_10.3/common/nodemanager
/u01/app/orawls/middleware/wlserver_10.3/common/bin/wlst.sh


3. Приконнектимся к Node Manager:

nmConnect('weblogic','weblogic1','localhost','5556','TestDomain')


где

weblogic     - имя администратора WebLogic Server;
weblogic1    - пароль администратора WebLogic Server;
localhost    - имя хоста на котором запущен NodeManager;
5556         - порт хоста на котором запущен NodeManager;
TestDomain   - имя домена.


4.  Запускаем  AdminServer:

nmStart('AdminServer')

Если не хватит памяти,  добавте в файл startup.properties параметр Arguments:
Arguments=-Xms512m -Xmx512m -XX\:PermSize\=256m -XX\:MaxPermSize\=256m


5. Запускаем ManagedServer:

nmStart('mng1')

Эта команда для запуска требует наличия:

/u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/data/nodemanager/boot.properties
/u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/security/boot.properties
/u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/data/nodemanager/startup.properties


Файлы boot.properties можно создать вручную,
прописав там имя пользователя и пароль открытым текстом:

username=weblogic
password=weblogic1

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


Файл startup.properties автоматически будет создан при запуске AdminServer-а каким-либо другим способом
кроме использования команды nmStart:

скриптом startWebLogic.sh
или
командой startServer().


Если управляемый сервер запускается первый раз и для него еще не созданы файлы запуска, то
для создания файлов  startup.properties и boot.properties можно использовать команду
nmGenBootStartupProps(), принимающую в качестве аргумента имя сервера.

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

nmGenBootStartupProps('mng1')

При запуске данной команды необходимо, чтобы AdminServer работал и из WLST к нему было выполнено подключение.

Команда генерирует файлы по умолчанию в каталог, из которого запущен WLST.

Изменить путь к каталогу Root Directory можно, отредактировав значение одноименного параметра на вкладке Server Start страницы соответствующего сервера в консоли администрирования WebLogic.

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

$ more /u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/data/nodemanager/boot.properties

#Fri Sep 13 17:49:29 MSK 2013
TrustKeyStore=DemoTrust
password={AES}9DsWvwnj6BxghpZcWKGvKU3VGP0T/Utsu+bNktxrl/I\=
username={AES}VFoYEru88XaP7Bo/fU3+goxYOWanGXwFftclu3DWaCg\=


$ more /u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/security/boot.properties

# Generated by Configuration Wizard on Thu Sep 05 17:03:07 MSK 2013
username={AES}lqqktTtksY25qS5oyPmYatr3ze/qEOhmf2KTPCWbXA4=
password={AES}RnNVF+J9ZX6vK3FI2gI6pGi4DqzcYqn2G9GuE64wWgM=


$ more /u01/app/orawls/middleware/user_projects/domains/TestDomain/servers/mng1/data/nodemanager/startup.properties

#Server startup properties
#Fri Sep 13 17:49:29 MSK 2013
SSLArguments=-Dweblogic.security.SSL.ignoreHostnameVerification\=false -Dweblogic.ReverseDNSAllowed\=false
RestartMax=2
RestartDelaySeconds=0
RestartInterval=3600
AdminURL=http\://10.1.2.235\:7001
AutoRestart=true
AutoKillIfFailed=false


После успешной генерации файлов необходимо перезапустить NodeManager.


6. Выход из консоли.

exit()



Остановка Oracle WebLogic Server:


1. Запускаем Node Manager:

nohup /u01/app/orawls/middleware/wlserver_10.3/server/bin/startNodeManager.sh &


2. Откроем  консоль:

cd /u01/app/orawls/middleware/wlserver_10.3/common/nodemanager
/u01/app/orawls/middleware/wlserver_10.3/common/bin/wlst.sh


3. Приконнектимся к Node Manager:

nmConnect('weblogic','weblogic1','localhost','5556','TestDomain')


где

weblogic     - имя администратора WebLogic Server;
weblogic1    - пароль администратора WebLogic Server;
localhost    - имя хоста на котором запущен NodeManager;
5556         - порт хоста на котором запущен NodeManager;
TestDomain   - имя домена.



4. Останавливаем  ManagedServer:

nmKill('mng1')


5. Останавливаем AdminServer:

nmKill('AdminServer')


6. Отконнектиться от Node Manager

nmDisconnect()


7. Выйдем из консоли

exit()


8. Останавливаем Node Manger

kill -9 `ps -ef | grep [N]odeManager | awk '{print $2}'`




Для автозапуска можно использовать скрипт:


# more    /etc/init.d/wls


#!/bin/bash
#
# oracle Init file for starting and stopping WLS
#
# chkconfig: 35 80 30
# description: Oracle WLS startup script
# Source function library

ORACLE_OWNER="orawls"
MW_HOME=/u01/app/orawls/middleware
WL_HOME=/u01/app/orawls/middleware/wlserver_10.3
DOMAIN_HOME=$MW_HOME/user_projects/domains/TestDomain
cp -p $MW_HOME/user_projects/domains/TestDomain/servers/AdminServer/security/boot.properties $MW_HOME/user_projects/domains/Test
Domain/servers/mng1/security/boot.properties
cp -p $MW_HOME/user_projects/domains/TestDomain/servers/AdminServer/security/boot.properties $MW_HOME/user_projects/domains/Test
Domain/servers/mng1/data/nodemanager/boot.properties
case "$1" in
start)
echo -n $"Starting WLS:"
su - $ORACLE_OWNER -c "$WL_HOME/server/bin/startNodeManager.sh &"
su - $ORACLE_OWNER -c "$DOMAIN_HOME/bin/startWebLogic.sh  &"
su - $ORACLE_OWNER -c "$DOMAIN_HOME/bin/startManagedWebLogic.sh mng1  &"
echo "OK"
;;
stop)
echo -n $"Stopping WLS:"
su - $ORACLE_OWNER -c "$DOMAIN_HOME/bin/stopManagedWebLogic.sh mng1"
su - $ORACLE_OWNER -c "$DOMAIN_HOME/bin/stopWebLogic.sh"
# STOP NODE_MANAGER
kill -9 `ps -ef | grep [N]odeManager | awk '{print $2}'`
echo "OK"
;;
*)
echo $"Usage: $0 {start|stop}"
esac




# chmod 750 /etc/init.d/wls
# chkconfig --add wls --level 0356





вторник, 10 сентября 2013 г.

Логические операции в Python


is - оператор идентичности

is not - оператор неидентичности


a = ["red", 5, None]
b = ["red", 5, None]

здесь a и b ссылаются на разные объекты

print(a is b)

>False


Возвращает True, если ссылка слева указывает на тот же самый объект, что и ссылка справа:

b = a

print(a is b)

>True


Существует понятие пустого объекта None:

a = "Oracle12c"
b = None

print(a is not None)
print(b is None)

>True
>True



Операторы сравнения:

<   -  меньше

<=  -  меньше либо равно

>   -  больше

>=  -  больше либо равно

==  -  равно

!=  -  не равно



a = 2
b = 6

print(a==b)

>False

print(a<b)

>True

print(a<=b, a!=b, a>=b, a>b)

>True True False False




a = ["red", 5, None]
b = ["red", 5, None]

print(a is b)
>False

print(a == b)
>True


Операторы сравнения могут объединяться в цепочки:

a = 9

print(0<=a<=10)

>True

Это удобнее чем выполнять два отдельных оператора сравнения и объединения их результатов через and.


Попытка сравнить несовместимые значения вызывает исключение:

print("oracle" < 5)

Traceback (most recent call last):
  File "None", line 1, in <module>
builtins.TypeError: unorderable types: str() < int()


print("10" < 5)

Traceback (most recent call last):
  File "None", line 1, in <module>
builtins.TypeError: unorderable types: str() < int()


Оператор членства

Для типов данных являющихся последовательностями или коллекциями
таких как:
 строки
 списки
 картежи
мы можем выполнить проверку членства с помощью оператора in
или не членства с помощью оператора not in

f = ("oracle", "java", 3, -9)

print( 3 in f )

>True


print( "python" in f )

>False



phrase = "oracle database administration"

print( "m" in phrase )

>True

print( "base" in phrase )

>True


Логические операторы

and
or
not

Операторы and и or  вычисляются по короткой схеме и возвращают операнд.
Они не возвращают значение типа Boolean, если операнды не являются значениями типа Boolean.

x  or y   -  if x is False, then y, else x
x and y   -  if x is False, then x, else y
not x     -  if x is False, then True, else False


Унарный оператор not оценивает свой операнд в булевом контексте и всегда возвращает значение типа Boolean.

five = 5
two = 2
zero = 0

print(five and two)

>2


print(two and five)

>5


print(five and zero)

>0


Если выражение участвует в логическом контексте, результат оценивается как значение типа Boolean,
поэтому предыдущие выражения могли бы рассматриваться, как имеющие значения True, True и False
в контексте инструкции if.

five = 5
two = 2
zero = 0
nought = 0

print(five or two)

>5

print(two or five)

>2

print(zero or five)

>5

print(zero or nought)

>0

Оператор or напоминает оператор and  -  здесь в булевом контексте были бы получены значения
True, True, True и False.

print(not(zero or nought))

>True

print(not two)

>False




воскресенье, 11 августа 2013 г.

Дополнительные наборы модулей (библиотек) языка программирования Python

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


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



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


Matplotlib - библиотека на языке программирования Python для визуализации данных двумерной (2D) графикой
(3D графика также поддерживается). 
Matplotlib написан и поддерживался в основном Джоном Хантером (англ. John Hunter)
и распространяется на условиях BSD-подобной лицензии.


Pygame - набор модулей (библиотек) языка программирования Python,
предназначенный для написания компьютерных игр и мультимедиа-приложений.
Pygame базируется на мультимедийной библиотеке SDL.
Изначально Pygame был написан Питом Шиннерсом (Pete Shinners).
Начиная примерно с 2004/2005 года поддерживается и развивается сообществом свободного программного обеспечения.


PyOpenGL - библиотека, позволяющим в программах на языке Python легко работать с
функциями OpenGL, GLU и GLUT, а также с рядом расширений OpenGL.


PyQt - набор «привязок» графического фреймворка Qt для языка программирования Python, выполненный в виде расширения Python.



SIP - это инструмент для автоматической генерации Python-привязок к C и C++ библиотекам.
Первоначально SIP был разработан в 1998 году для PyQt — Python-привязки для инструментария виджетов Qt,
но подходит и для создания привязок к любым другим C или C++ библиотекам.
SIP берёт набор инструкций (.sip файлы), описывающих API и генерирует требуемый C++ код.
Потом он компилируется и на выходе получается модуль Python. Файлы .sip — файлы заголовков класса,
у которых кое-что убрано (потому что SIP не содержит полноценный C++-парсер) и кое-что добавлено
(поскольку C++ не несет достаточной информации о работе API).


Python Imaging Library (сокращенно PIL) — библиотека языка Python, предназначенная для работы с растровой графикой.


Django — свободный фреймворк для веб-приложений на языке Python, использующий шаблон проектирования MVC.
Проект поддерживается организацией Django Software Foundation.


Tornado - расширяемый, не блокирующий веб-сервер и фреймворк, написанный на Python.
Он создан для использования в проекте FriendFeed.
Компания была приобретена Facebook в 2009 году и после этого были открыты исходные коды Tornado.
Tornado был создан для обеспечения высокой производительности и является одним из веб-серверов,
способных выдержать проблему 10000 соединений.
Следует понимать, что при сравнении производительности речь идет о т. н. «легких» запросах.
Ибо длительная обработка запроса (например, по причине взаимодействия с сервером баз данных),
сводит преимущества Торнадо на нет.


Pylons — программный каркас для разработки веб-приложений (web application framework) с открытым исходным кодом,
написанный на языке Python. В нём широко используется стандарт WSGI, что способствует эффективности повторного
использования кода и модульности.
В настоящее время развитие Pylons завершено на версии 1.0, а дальнейшего развития (помимо исправления ошибок) не планируется.
В качестве основы для следующего поколения программного каркаса проекта Pylons взят программный каркас repoze.bfg,
получивший в рамках проекта Pylons новое имя — Pyramid. Само название Pylons становится отныне зонтичным брендом.


Pyramid — программный каркас (фреймворк) для разработки веб-приложений
с открытым исходным кодом, написанный на языке Python в рамках проекта Pylons.
На создание Pyramid оказали влияние такие фреймворки, как Zope, Pylons и Django.
Код Pyramid разрабатывался в проекте repoze.bfg, а название поменялось в результате слияния проектов BFG и Pylons.




Комплексные числа в Python

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

Литералы комплексных  чисел записываются как действительная и мнимая части,
объединенные знаком "+" или "-", а за мнимой частью следует символ j.

3.5+2j

0.5j  - если действительная часть равна 0, ее можно вообще опустить.

4+0j

-1-3.7j

 Отдельные части комплексного числа доступны в виде атрибутов real и imag:

>>> z = -89.5+2.125j

>>> z.real, z.imag
(-89.5, 2.125)


За исключением //, %, divmod и версии pow() с тремя аргументами все остальные арифметические операторы и функции,
которые используются для работы с целыми числами, также могут использоваться и для работы с комплексными числами.

Значения типа complex имеют метод:

conjugate()

который изменяет знак мнимой части.


>>> z = -89.5+2.125j

>>> z.conjugate()
(-89.5-2.125j)


>>> 3-4j.conjugate()
(3+4j)



>>> 4j.real
0.0

>>> 4j.imag
4.0

>>> 4j+3+2j
(3+6j)


Тип данных complex может вызываться как функция complex()

без аргументов она вернет:

>>> complex()
0j

с аргументами типа complex она вернет копию аргумента:

>>> complex(9+3j)
(9+3j)

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

>>> complex(0)
0j

>>> complex(1)
(1+0j)

>>> complex(0,1)
1j

При использовании для преобразования функция complex() принимает:
либо единственный строковый аргумент
либо одно или два значения типа float

Если ей передается единственное значение типа float, возвращается комплексное число с мнимой частью равной 0j.


Функции в модуле math не работают с комплексными числами.

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

cmath.phase()
cmath.polar()
cmath.rect()

а также константы:

cmath.pi
cmath.e

которые хранят те же самые значения типа float, что и родственные им константы в модуле math.

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



>>> "{0.real:.3f}{0.imag:+.3f}j".format(4.75917+1.2042j)
'4.759+1.204j'

>>> "{0.real:.3f}{0.imag:+.3f}j".format(4.75917-1.2042j)
'4.759-1.204j'


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




Спецификаторы формата для чисел с плавающей точкой Python

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

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

 В самом конце мы можем указать символ типа:

e  - для вывода числа в экспоненциальной форме, с символом "e" в нижнем регистре.

E  - для вывода числа в экспоненциальной форме, с символом "E" в верхнем регистре.

f  - для вывода числа в стандартной форме

g  - для вывода числа в общей форме, т.е. для небольших чисел действует как символ "f"
      а для очень больших чисел как символ "e".

G  - тоже самое как символ "g", только используется формат  "f" или "E".


Кроме того, допускается использовать символ %, при использовании которого выводимое число умножается на 100
и для вывода применяется формат "f" с добавлением символа "%" в конце числа.


Примеры:

Установим минимальную ширину поля вывода 12 символов и 2 знака после дестичной точки.

import math

s = (10**3) * math.pi
print("[{0:12.2e}]  [{0:12.2E}]   [{0:12.2f}]   [{0:12.2g}]   [{0:12.2G}]  [{0:12.2%}]".format(s))

>  [    3.14e+03]  [    3.14E+03]   [     3141.59]   [     3.1e+03]   [     3.1E+03]  [  314159.27%]


              
Добавим вывод символа-заполнителя (при этом символ выравнивания указывать обязательно).

import math

s = (10**3) * math.pi
print("[{0:*>12.2e}]  [{0:->12.2E}]   [{0:#>12.2f}]   [{0:.>12.2g}]   [{0:$>12.2G}]  [{0:&>12.2%}]".format(s))

> [****3.14e+03]  [----3.14E+03]   [#####3141.59]   [.....3.1e+03]   [$$$$$3.1E+03]  [&&314159.27%]



Добавим символ "+" для принудительного вывода знака числа.

import math

s = (10**3) * math.pi
print("[{0:*>+12.2e}]  [{0:->+12.2E}]   [{0:#>+12.2f}]   [{0:.>+12.2g}]   [{0:$>+12.2G}]  [{0:&>+12.2%}]".format(s))

> [***+3.14e+03]  [---+3.14E+03]   [####+3141.59]   [....+3.1e+03]   [$$$$+3.1E+03]  [&+314159.27%]


суббота, 10 августа 2013 г.

Спецификаторы формата для целых чисел Python

Спецификаторы формата для целых чисел.

Начинаются с символа двоеточия (:)

Далее следует пара необязательных символов:

- символ заполнителя (который не может быть правой фигурной скобкой   } )

- символ выравнивания:

"<"  - по левому краю
"^"  - по центру
">"  - по правому краю
"="  - указывающий на необходимость заполнять пространство между знаком числа и первой значащей цифрой.

Далее следует необязательный символ знака числа:

"+"  - говорит об обязательной необходимости вывода знака числа

"-"  - знак выводится только для отрицательных чисел

" "  - для положительных чисел вместо знака выводить пробел, для отрицательных чисел знак "-"

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


Рассмотрим некоторые примеры:

print("{0:0=12}".format(8749203))
print("{0:0=12}".format(-8749203))

print("{0:012}".format(8749203))
print("{0:012}".format(-8749203))

> 000008749203
   -00008749203
   000008749203
   -00008749203

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

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


Управление выравниванием:

print("{0:*<15}".format(18340427))

> 18340427*******



print("{0:*>15}".format(18340427))

> *******18340427


print("{0:*^15}".format(18340427))

> ***18340427****


print("{0:*^15}".format(-18340427))

> ***-18340427***


Управление выводом знака числа:

пробел или знак "-"

print("[{0: }][{1: }]".format(539802, -539802))

> [ 539802][-539802]



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

print("[{0:+}][{1:+}]".format(539802, -539802))

> [+539802][-539802]


знак "-" выводится только принеобходимости

print("[{0:-}][{1:-}]".format(539802, -539802))

> [539802][-539802]



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

b  - для двоичной

o  - для восьмеричной

x  - для шестнадцатеричной с символами в нижнем регистре

X  - для шестнацатеричной с символами в верхнем регистре

d  - для десятичной


Использование символов управления типом:

print("{0:b}   {0:o}   {0:x}   {0:X}   {0:d}".format(14613198))

> 110111101111101011001110   67575316   deface   DEFACE   14613198


если перед символом типа поставить символ "#"
то вывод будет выглядеть с указанием системы исчисления:

print("{0:#b}   {0:#o}   {0:#x}   {0:#X}   {0:#d}".format(14613198))

> 0b110111101111101011001110   0o67575316   0xdeface   0XDEFACE   14613198



Существует еще один символ типа:

c  - означает что должен выводиться символ unicode соответствующий целому числу.

print("{0:#c}".format(1288))

> Ԉ



И последний символ управления форматом вывода:

n  - когда реобходимо обеспечить вывод чисел с учетом региональных настроек.

он доступен также для чисел с плавающей точкой

Он имеет то же действие что и d в случае целых чисел
или g в случае вывода чиселс плавающей точкой.

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

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

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


import locale
locale.setlocale(locale.LC_ALL, "")

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

import locale
locale.setlocale(locale.LC_ALL, "")

x, y = (1234567890, 1234.56)
print("{0:n}    {1:n}".format(x,y))

> 1 234 567 890    1 234,56



import locale
locale.setlocale(locale.LC_ALL, "C")

x, y = (1234567890, 1234.56)
print("{0:n}    {1:n}".format(x,y))

> 1234567890    1234.56



import locale
locale.setlocale(locale.LC_ALL, "en_US.UTF-8")

x, y = (1234567890, 1234.56)
print("{0:n}    {1:n}".format(x,y))

> 1,234,567,890    1,234.56



import locale
locale.setlocale(locale.LC_ALL, "de_DE.UTF-8")

x, y = (1234567890, 1234.56)
print("{0:n}    {1:n}".format(x,y))

> 1.234.567.890    1.234,56


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



Форматирование строк в Python

Метод   str.format()   возвращает новую строку, замещая поля в контекстной строке соответствующими аргументами.

 "строка".format()

print("строка".format())

> строка

 print("abc".format())

> abc


Функция format() может принимать аргументы:

- строки
- числа
- другие коллекции


.format("строка",  число,  имя_коллекции)

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

"строка     ....    .....    ......    ....   abc".format(arg1, arg2, arg3)


Примеры:

print("   {0}   {1}   {2}   ".format("abc", 13, 8))

>   abc   13   8


print("   {1}   {2}   {0}   ".format("abc", 13, 8))

 >  13   8   abc



print("xxx   {0}   xxx".format("abcd"))

> xxx   abcd   xxx


xx   {0[0]}   xxx".format("abcd"))

> xxx   a   xxx


print("xxx   {0[0]}  {0[3]}   xxx".format("abcd"))

> xxx   a  d   xxx


print("Цвет: {0}\nРазмер: {1}".format("зеленый", 44))

> Цвет: зеленый
   Размер: 44


print("{1}{0}".format(500, "Цена $"))

> Цена $500


Если попытаться объединить строку и число, интерпретатор Python совершенно справедливо возбудит исключение TypeError.

Но это легко сделать с помощью метода str.format()

print("{0}{1}".format("The amount due is  $", 500))

> The amount due is  $500



Если нам потребуется включить фигурные скобки в строку формата, то это можно сделать дублируя их:

print("{{ {0} }},  {1}: }}".format("Эта строка в фигурных скобках", "а это просто фигурная скобка"))

> { Эта строка в фигурных скобках },  а это просто фигурная скобка: }


С помощью str.format()  мы также легко можем объединять строки.
(хотя для этой цели лучше подойдет метод str.join() )

x = "three"
s = "{0} {1} {2}"
s = s.format("The", x, "tops")
print(s)

> The three tops


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

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

{field_name}

{field_name!conversion}

{field_name:format_specification}

{field_name!conversion:format_specification}


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


Имена полей


Имя поля может быть либо целым числом, соответствующим одному из аргументов метода str.format() либо именем одного из именованных аргументов метода.

Кроме позиционных аргументов можно использовать именованные аргументы:

" {имя_1} {имя_2} ".format(имя_1 = "строка",  имя_2 = число)



print("Цвет: {цвет} Размер: {размер}".format(цвет = "зеленый", размер = 44))

> Цвет: зеленый  Размер: 44


print("Цвет: {цвет}  Размер: {0}".format(44, цвет = "зеленый"))

> Цвет: зеленый  Размер: 44


В первом примере используется два именованных аргумента: цвет и размер.
Во втором примере используется один позиционный аргумент и один именованный аргумент.

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

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


Позиционные и именованные аргументы

Используем индекс позиционного элемента или имя именованного аргумента
{0} или размер, цвет


print("Размер {0}".format(44))
print("Размер {размер}".format(размер = 44))

> Размер 44
   Размер 44

print("Цвет {0}".format("зеленый"))
print("Цвет {цвет}".format(цвет = "зеленый"))

> Цвет зеленый
   Цвет зеленый



Если это список

Используем индекс позиционного элемента или имя именованного аргумента
{0} или n - имя списка

цвет = ["красный", "синий", "зеленый"]
print("{0[1]}".format(цвет))
print("{n[2]}".format(n = цвет))

> синий
   зеленый

Если это словарь

Используем индекс позиционного элемента или имя именованного аргумента
{0} или n - имя словаря

d = dict(цвет = "зеленый", размер = 44)
print("{0[цвет]}".format(d))
print("{n[размер]}".format(n = d))

> зеленый
   44


Если это объект

Используем индекс позиционного элемента или имя именованного аргумента
{0} или n - имя объекта

import math
print("{0.pi}".format(math))
print("{m.pi}".format(m = math))

> 3.141592653589793
   3.141592653589793


Различные типы данных в Python могут одним из двух способов:

Первый способ отображения - это репрезентативная форма.
Ее назначение состоит в том, чтобы предоставить строку, которая может быть воспринята интерпретатором Python для воссоздания объекта, который она представляет.

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

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

Например репрезентативной формой модуля sys является строка:

>>> import sys
>>> sys

>>> print(sys)

>>>



Функция  print()  пытается отобразить объект в строковой форме, если тип данных не имеет строковой формы представления объект будет отображен в репрезентативной форме.

Метод str.format()  по умолчанию также использует строковую форму, но с помощью спецификаторов можно изменить форму вывода объекта.

Метод str.format() поддерживает три спецификатора преобразования:

s - для принудительного вывода строковой формы

r - для принудительного вывода репрезентативной формы

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


import decimal
print("{0}  {0!s}  {0!r}  {0!a}".format(decimal.Decimal("3.1415")))

> 3.1415  3.1415  Decimal('3.1415')  Decimal('3.1415')


 Пример с unicode:

s = 'AÜBÖC'
print("{0}".format(s))
print("{0!a}".format(s))
print(ascii(s))

> AÜBÖC
  'A\xdcB\xd6C'
  'A\xdcB\xd6C'


Спецификаторы формата строк.

Начинаются с символа двоеточия (:)

Далее следует пара необязательных символов:

- символ заполнителя (который не может быть правой фигурной скобкой   } )

- символ выравнивания:

"<"  - по левому краю
"^"  - по центру
">"  - по правому краю


Если указан символ-заполнитель, то должно быть и направление выравнивания.

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

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


s = "Строка символов"
print("{0}".format(s))

> Строка символов


s = "Строка символов"
print("{0:}".format(s))

> Строка символов


Если символ-заполнитель и символ выравнивания не указаны, то по умолчанию строка будет выравнена по левому краю и в конце дополнена пробелами до указанной минимальной ширины поля:

s = "Строка символов"
print("{0:25}".format(s))

> Строка символов


Символ заполнителя без символа выравнивания использовать нельзя:
s = "Строка символов"
print("{0:#25}".format(s))

> Traceback (most recent call last):
  File "None", line 2, in
builtins.ValueError: Alternate form (#) not allowed in string format specifier



s = "Строка символов"
print("{0:#<25}".format(s))

> Строка символов##########


А символ выравнивания можно использовать без символа заполнителя:

s = "Строка символов"
print("{0:>25}".format(s))

>          Строка символов


Еще примеры:

s = "Строка символов"
print("{0:^25}".format(s))

>      Строка символов


s = "Строка символов"
print("{0:-^25}".format(s))

> -----Строка символов-----


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

s = "Строка символов"
print("{0:.<25}".format(s))

> Строка символов..........


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

s = "Строка символов"
print("{0:.10}".format(s))

> Строка сим


Как уже отмечалось ранее, внутри спецификатора формата можно использовать замещаемые поля.
Это делает возможным динамически определять формат вывода.

Два способа определить максимальную ширину строки с помощью переменной maxwidth:

s = "Строка символов"
maxwidth = 12
print("{0}".format(s[:maxwidth]))

> Строка симво


s = "Строка символов"
maxwidth = 12
print("{0:.{1}}".format(s, maxwidth))

 > Строка симво


В первом случае используется обычная операция извлечения среза.

Во втором - вложенное замещаемое поле.




понедельник, 5 августа 2013 г.

Основы JavaScript

Любой HTML или XHTML - документ состоит из четырех разделов:

<!DOCTYPE>
контейнера <html>
заголовка <head>
тела документа <body>


Любой HTML-документ начинается со строки, содержащей декларацию типа документа (DTD, document type declaration).
HTML 4.0 поддерживает три типа таких деклараций:


Документ строго соответствует стандарту HTML 4.0, т. е. не содержит ни морально устаревших элементов, ни фреймов:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">


Документ является переходным к стандарту HTML 4.0, т. е. может содержать морально устаревшие элементы:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">


Документ содержит фреймы:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Frameset//EN"
 "http://www.w3.org/TR/html4/frameset.dtd">




Любой XHTML-документ также начинается со строки, содержащей декларацию типа документа:

XHTML 1.0 Strict
Используется в том случае, если в документе идет четкое разделение оформления и содержания.
При этом код веб-страницы содержит только теги разметки, а сам вид элементов задается через стили:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">


XHTML 1.0 Frameset
Применяется, когда окно браузера делится на два или более фрейма:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">



Простейший HTML-документ

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
   <!-- Заголовка страницы -->
  </head> 
  <body>
   <!-- Содержимое страницы -->
  </body>
</html>


Сценарии JavaScript можно вставлять между тегами:

<head></head>

или

<body></body>

Простейший пример сценария:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
  <title> Заголовок документа </title>
  </head> 
  <body>
    Пример сценария
    <br />
    <script type="text/javascript">
      document.write("Hello World!");
    </script>
    <br />
    Простой вывод текста
  </body>
</html>



Можно текст сценария помесить во внешний файл, например jsfile1.js
Этот файл содержит следующее:

document.write("Hello World!");

а затем  вызвать его из html - документа:

<script type="text/javascript" src="jsfile1.js">
</script>


Предыдущий пример изменится так:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
  <title> Заголовок документа </title>
  </head>
  <body>
    Пример сценария
    <br />
    <script type="text/javascript" src="jsfile1.js">
    </script>
    <br />
    Простой вывод текста
  </body>
</html>



На самом деле все сценарии лучше выносить во внешние файлы.

Например усли поместить в html - документ сценарий javascript,
который содержит символы сравнения (меньше чем)  x < y то будут проблемы
и страница не пройдет проверку т.к. символ  <  выглядит как начало нового тега.

Чтобы этого избежать нужно использовать раздел CDATA и закомментарить его:

<script type="text/javascript">

/*<![CDATA[*/

var x=5;
var y=10;
if (x < y) {
window.alert("x меньше, чем y");
}

/*]]>*/


</script>


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

Теперь наш пример будет выглядеть так:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
  <title> Заголовок документа </title>
  </head>
  <body>
    Пример сценария
    <br />
    <script type="text/javascript">
    /*<![CDATA[*/
    var x=5;
    var y=10;
    if (x < y) {
    window.alert("x меньше, чем y");
    }
    /*]]>*/
    </script>
    <br />
    Использование сценария внутри html - документа
  </body>
</html>




Для html 4.01 тип документа описывался так:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/html4/strict.dtd">


В html 5 все намного проще:

<!doctype html>
<html>
  <head>
  <meta charset="UTF-8">
  <title> Заголовок документа </title>
    <script>
    alert("Hello World!")
    </script>
  </head>
  <body>
  <!-- Содержимое страницы -->
  </body>
</html>


Пример html - документа, который содержит внешний скрипт, внутренний скрипт и таблицу стилей:

<!doctype html>
<html>
  <head>
  <meta charset="UTF-8">
  <title> Заголовок документа </title>

    <link href="../_css/title.css" rel="stylesheet">

    <script src="../_js/jquery-1.6.3.min.js">
    </script>

    <script>
    $(document).ready(function() {
    $('body').hide().fadeIn(3000);
    });
    </script>

  </head>
  <body>
  <!-- Содержимое страницы -->
  </body>
</html>



суббота, 27 июля 2013 г.

Работа с файлами в Python

Вывод в файлы:

file = open('data.txt', 'w')

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


myfile = open("C:\\projects\\data.txt", "w")
myfile.write("# Name Email Phone\n")
myfile.write("Larry larry@example.com 111-1111\n")
myfile.write("Curly curly@example.com 222-2222\n")
myfile.write("Moe moe@example.com 333-3333\n")
myfile.close()


c:\projects>type data.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

c:\projects>

В отличии от функции print, метод write объекта файла записывает в точности то,
что ему передано, без дополнительного форматирования.
Поэтому мы явно добавляем символ конца строки.

Метод close завершает формирование содержимого файла и освобождает системные ресурсы.
Обычно файлы автоматически закрываются, когда объект файла уничтожается
интерпретатором при сборке мусора (т.е. когда в сценарии исчезнет послдняя ссылка на объект)

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

open('tempfile.txt','w').write("Scott Tiger\n")
open('tempfile.txt','r').read()


Гарантированное закрытие файлов:

- Использовать обработчик исключений

myfile = open("C:\\projects\\data.txt", "w")
try:
    myfile.write("# Name Email Phone\n")
    myfile.write("Larry larry@example.com 111-1111\n")
    myfile.write("Curly curly@example.com 222-2222\n")
    myfile.write("Moe moe@example.com 333-3333\n")
finally:
    myfile.close()


c:\projects>type data.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

- использовать менеджер контекста

Инструкция with - обеспечивает  более краткий способ реализации заключительных
операций для объектов определенных типов, включая закрытие файлов.

with open("C:\\projects\\data.txt", "w")  as myfile:
    # обработка файла
    myfile.write("# Name Email Phone\n")
    myfile.write("Larry larry@example.com 111-1111\n")
    myfile.write("Curly curly@example.com 222-2222\n")
    myfile.write("Moe moe@example.com 333-3333\n")
    # закрывается автоматически после выхода
    # независимо от возникновения исключений

c:\projects>type data.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

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

with A() as a, B() as b:
    # инструкции

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

Это действует так:
with A() as a:
    with B() as b:
        # инструкции


Например:

with open("C:\\projects\\data.txt") as fin, open("C:\\projects\\data1.txt", 'w') as fout:
    for line in fin:
        fout.write(line.upper())

C:\Users\angor>cd c:\projects

c:\projects>type data.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

c:\projects>type data1.txt
# NAME EMAIL PHONE
LARRY LARRY@EXAMPLE.COM 111-1111
CURLY CURLY@EXAMPLE.COM 222-2222
MOE MOE@EXAMPLE.COM 333-3333

c:\projects>

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

myfile = open("C:\\projects\\data.txt", "w")
myfile.writelines(["# Name Email Phone\n",
                  "Larry larry@example.com 111-1111\n",
                  "Curly curly@example.com 222-2222\n",
                  "Moe moe@example.com 333-3333\n"])
myfile.close()

C:\Users\angor>cd c:\projects

c:\projects>type data.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

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


Чтение из файлов:

file = open('data.txt', 'r')

режим r используется по умолчанию, поэтому можем писать так:

file = open('data.txt')


пример:

myfile = open("C:\\projects\\data.txt")
lines = myfile.readlines()
for line in lines:
    print(line, end='')


# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


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

Существует много способов чтения вхлдного файла:

file.read()
возвращает строку, содержащую все символы (или байты), хранящиеся в файле.


file.read(N)
возвращает строку, содержащую очередные N символов (или байтов), из файла.


file.readline()
читает содержимое файла до ближайшего символа \n и возвращает строку.


file.readlines()
читает файл целиком и возвращает список строк


Вызов метода seek(0) перед каждой попыткой чтения переустанавливает текущую позицию чтения в начало файла.

Python 3.3.1 (v3.3.1:d9893d13c628, Apr  6 2013, 20:30:21) [MSC v.1600 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> myfile = open("C:\\projects\\data.txt")
>>> myfile.seek(0)
0
>>> myfile.read()
'# Name Email Phone\nLarry larry@example.com 111-1111\nCurly curly@example.com 222-2222\nMoe moe@example.com 333-3333\n'


>>> myfile.seek(0)
0
>>> myfile.readlines()
['# Name Email Phone\n', 'Larry larry@example.com 111-1111\n', 'Curly curly@example.com 222-2222\n', 'Moe moe@example.com 333-3333\n']


>>> myfile.seek(0)
0
>>> myfile.readline()
'# Name Email Phone\n'

>>> myfile.readline()
'Larry larry@example.com 111-1111\n'

>>> myfile.readline()
'Curly curly@example.com 222-2222\n'

>>> myfile.readline()
'Moe moe@example.com 333-3333\n'

>>> myfile.readline()
''

>>> myfile.readline()
''


>>> myfile.seek(0)
0
>>> myfile.read(1)
'#'
>>>
>>> myfile.read(8)
' Name Em'



>>> myfile.seek(0)
0
>>> myfile.read(1), myfile.read(8)
('#', ' Name Em')
>>>



Методы read() и readlines() загружают в память сразу весь файл.
Их можно использовать при работе с небольшими файлами.

Для работы с потенциально большими файлами необходимо использовать вызовы

readline() и read(N)

Оба метода возвращают пустую строку по достижении конца файла.

seek(0) - означает вернуться в начало файла
это альтернатива повторному открытию файла перед очередной попыткой чтения из него.


Чтение строк с помощью итераторов файлов

В старых версиях Python принято было читать файл в список и одход этого списка в цикле:

myfile = open("C:\\projects\\data.txt")
for line in myfile.readlines():
    print(line, end='')

# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333

Больше не делайте так никогда !!!

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

Теперь нет необходимости вызывать метод readlines.

myfile = open("C:\\projects\\data.txt")
for line in myfile:
    print(line, end='')


# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


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

for line in open("C:\\projects\\data.txt"):
    print(line, end='')


# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


Это наиболее предпочтительный способ чтения из файла на сегодняшний день.


Вообще итератор это всего лишь метод

__next__ , вызываемый встроенной функцией next.

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

Python 3.3.1 (v3.3.1:d9893d13c628, Apr  6 2013, 20:30:21) [MSC v.1600 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> myfile = open("C:\\projects\\data.txt")
>>> myfile.readline()
'# Name Email Phone\n'
>>> myfile.readline()
'Larry larry@example.com 111-1111\n'
>>> myfile.readline()
'Curly curly@example.com 222-2222\n'
>>> myfile.readline()
'Moe moe@example.com 333-3333\n'
>>> myfile.readline()
''
>>>
>>>
>>>
>>> myfile = open("C:\\projects\\data.txt")
>>> myfile.__next__()
'# Name Email Phone\n'
>>> myfile.__next__()
'Larry larry@example.com 111-1111\n'
>>> myfile.__next__()
'Curly curly@example.com 222-2222\n'
>>> myfile.__next__()
'Moe moe@example.com 333-3333\n'
>>> myfile.__next__()
Traceback (most recent call last):
  File "", line 1, in
    myfile.__next__()
StopIteration
>>>


Интересно отметить, что итераторы автоматически используются во всех итерационных контекстах,
включая конструктор списка, генераторы списков, функцию map и оператор in проверки на вхождение:

>>> open("C:\\projects\\data.txt").readlines()
['# Name Email Phone\n', 'Larry larry@example.com 111-1111\n', 'Curly curly@example.com 222-2222\n', 'Moe moe@example.com 333-3333\n']
>>>
 

>>> list(open("C:\\projects\\data.txt"))
['# Name Email Phone\n', 'Larry larry@example.com 111-1111\n', 'Curly curly@example.com 222-2222\n', 'Moe moe@example.com 333-3333\n']
>>>

>>> lines=[line.rstrip() for line in open("C:\\projects\\data.txt")]
>>> lines
['# Name Email Phone', 'Larry larry@example.com 111-1111', 'Curly curly@example.com 222-2222', 'Moe moe@example.com 333-3333']
>>>

>>> lines=[line.upper() for line in open("C:\\projects\\data.txt")]
>>> lines
['# NAME EMAIL PHONE\n', 'LARRY LARRY@EXAMPLE.COM 111-1111\n', 'CURLY CURLY@EXAMPLE.COM 222-2222\n', 'MOE MOE@EXAMPLE.COM 333-3333\n']
>>>

>>> list(map(str.split, open("C:\\projects\\data.txt")))
[['#', 'Name', 'Email', 'Phone'], ['Larry', 'larry@example.com', '111-1111'], ['Curly', 'curly@example.com', '222-2222'], ['Moe', 'moe@example.com', '333-3333']]
>>>

>>> line = '# Name Email Phone\n'
>>> line in open("C:\\projects\\data.txt")
True
>>>


Примеры:

Чтение строк из файла и вывод их с помощью функции print:


f = open("C:\\projects\\data.txt", "r")
while True:
    theline = f.readline()
    if len(theline) == 0:
        break
    print(theline, end="")
f.close()

# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


Чтение строк из файла, сортировка их в памяти и запись в другой файл:

fin = open("C:\\projects\\data.txt", "r")
buf = fin.readlines()
fin.close()
buf.sort()
fout = open("C:\\projects\\data1.txt", "w")
for line in buf:
    fout.write(line)
    print(line)
fout.close()

# Name Email Phone
Curly curly@example.com 222-2222
Larry larry@example.com 111-1111
Moe moe@example.com 333-3333

Чтение строк из файла, создание списка слов из этого файла, и вывод количества слов:

f = open("C:\\projects\\data.txt")
content = f.read()
f.close()
words = content.split()
print(words)
print("There are {0} words in the file.".format(len(words)))


['#', 'Name', 'Email', 'Phone', 'Larry', 'larry@example.com', '111-1111', 'Curly', 'curly@example.com', '222-2222', 'Moe', 'moe@example.com', '333-3333']

There are 13 words in the file.


Пример работы с бинарными файлами:

fin  = open("C:\\projects\\data.txt", "rb")
fout = open("C:\\projects\\data2.txt", "wb")
while True:
    buf = fin.read(1024)
    if len(buf) == 0:
        break
    fout.write(buf)
fin.close()
fout.close()


c:\projects>type data2.txt
# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333



Считать все строки из одного файла и записать все строки кроме тех,
которые начинаются на "#" в другой файл:


def filter(oldfile, newfile):
    infile = open(oldfile, "r")
    outfile = open(newfile, "w")
    while True:
        text = infile.readline()
        if len(text) == 0:
            break
        if text[0] == "#":
            continue
        outfile.write(text)
    infile.close()
    outfile.close()

filter("C:\\projects\\data.txt","C:\\projects\\data3.txt")

c:\projects>type data3.txt
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


Считать все строки из файла в список.
Вывести первые два элемента списка (первые две строки):

wordsfile = open("C:\\projects\\data.txt", "r")
wordlist = wordsfile.readlines()
print(wordlist[:2])


['# Name Email Phone\n', 'Larry larry@example.com 111-1111\n']


Другие режимы открытия файлов

Помимо режимов "r" и "w" большинство платформ поддерживает режим "a"

a - append

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


myfile = open("C:\\projects\\data.txt", "w")
myfile.write("# Name Email Phone\n")
myfile.write("Larry larry@example.com 111-1111\n")
myfile.close()
print(open("C:\\projects\\data.txt").read())
myfile.close()


# Name Email Phone
Larry larry@example.com 111-1111


myfile = open("C:\\projects\\data.txt", "a")
myfile.write("Curly curly@example.com 222-2222\n")
myfile.write("Moe moe@example.com 333-3333\n")
myfile.close()
print(open("C:\\projects\\data.txt").read())
myfile.close()


# Name Email Phone
Larry larry@example.com 111-1111
Curly curly@example.com 222-2222
Moe moe@example.com 333-3333


Чаще всего функцию open используют так:

open(имя_файла, режим_открытия, размер_буфера)

обязательный только первый аргумент

По умолчанию:

режим открытия  r
буферизация     полная


Режимы открытия:


r+
файл доступен как для чтения так и для записи, при этом содержимое существующих файлов сохраняется.

w+
файл доступен как для чтения так и для записи, при этом создается файл заново, уничтожая прежнее его содержимое.


rb
читать файл в двоичном режиме

wb
записывать файл в лвоичном режиме


rb+
файл доступен как для чтения так и для записи в двоичном режиме, при этом содержимое существующих файлов сохраняется.

wb+                                                          
файл доступен как для чтения так и для записи в двоичном режиме, при этом создается файл заново, уничтожая прежнее его содержимое.


Проще говоря, по умолчанию используется режим для чтения r, но вы можете использовать режим
w - для записи
a - для дополнения

Можете добавлять символ + , чтобы обеспечить возможность изменения содержимого файла,
а также указывать b и t  чтобы задать двоичный или текстовый режим.

Размер буфера

Функция open принимает необязятельный третий аргумент с размером буфера

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

1
построчная буферизация

Любое другое положительное число означает использование режима полной буферизации
этот режим используется по умолчанию


Двоичные и текстовые файлы

Двоичные файлы:

- изображения JPEG
- аудиоклипы
- упакованные двоичные данные


открыть двоичный файл для записи
myfile = open("C:\\projects\\data.txt", "wb")

открыть двоичный файл для чтения
myfile = open("C:\\projects\\data.txt", "rb")

Далее можно использовать стандартные методы:

read
write

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

Python 3.3.1 (v3.3.1:d9893d13c628, Apr  6 2013, 20:30:21) [MSC v.1600 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.

>>> open("C:\\projects\\data.txt").read()
'# Name Email Phone\nLarry larry@example.com 111-1111\nCurly curly@example.com 222-2222\nMoe moe@example.com 333-3333\n'
>>>

>>> open("C:\\projects\\data.txt", "rb").read()
b'# Name Email Phone\r\nLarry larry@example.com 111-1111\r\nCurly curly@example.com 222-2222\r\nMoe moe@example.com 333-3333\r\n'
>>>
>>>


>>> myfile = open("C:\\projects\\data.txt", "rb")
>>> for line in myfile:
    print(line)

   
b'# Name Email Phone\r\n'
b'Larry larry@example.com 111-1111\r\n'
b'Curly curly@example.com 222-2222\r\n'
b'Moe moe@example.com 333-3333\r\n'
>>>
>>>


>>> open("C:\\projects\\data.bin", 'wb').write(b'# Name Email Phone\n')
19

>>> open("C:\\projects\\data.bin", 'rb').read()
b'# Name Email Phone\n'
>>>
>>>


>>> open("C:\\projects\\data.bin", 'wb').write('# Name Email Phone\n')
Traceback (most recent call last):
  File "", line 1, in
    open("C:\\projects\\data.bin", 'wb').write('# Name Email Phone\n')
TypeError: 'str' does not support the buffer interface
>>>
аргумент должен быть типа bytes


Кодирование символов Unicode в текстовых файлах

>>> data = 'sp\xe4m'
>>> data
'späm'
>>>
>>> 0xe4, bin(0xe4), chr(0xe4)
(228, '0b11100100', '
ä')
>>>

Закодируем эту строку вручную

>>> data = 'sp\xe4m'
>>> data
'späm'
>>>


>>> 0xe4, bin(0xe4), chr(0xe4)
(228, '0b11100100', '
ä')
>>>


>>> data.encode('latin1')
b'sp\xe4m'
>>>


>>> data.encode('utf8')
b'sp\xc3\xa4m'
>>>


>>> data.encode('ascii')
Traceback (most recent call last):
  File "", line 1, in
    data.encode('ascii')
UnicodeEncodeError: 'ascii' codec can't encode character '\xe4' in position 2: ordinal not in range(128)
>>>


>>> data.encode('utf-16')
b'\xff\xfes\x00p\x00\xe4\x00m\x00'
>>>


>>> data.encode('cp500')
b'\xa2\x97C\x94'
>>>


>>> open("C:\\projects\\data.txt", 'w', encoding='latin1').write(data)
4

>>> open("C:\\projects\\data.txt", 'r', encoding='latin1').read()
'späm'
>>>


>>> open("C:\\projects\\data.txt", 'rb').read()
b'sp\xe4m'
>>>


>>> open("C:\\projects\\data.txt", 'w', encoding='utf8').write(data)
4
>>>


>>> open("C:\\projects\\data.txt", 'r', encoding='utf8').read()
'späm'
>>>


>>> open("C:\\projects\\data.txt", 'rb').read()
b'sp\xc3\xa4m'>>>


>>> open("C:\\projects\\data.txt", 'w', encoding='ascii').write(data)
Traceback (most recent call last):
  File "", line 1, in
    open("C:\\projects\\data.txt", 'w', encoding='ascii').write(data)
UnicodeEncodeError: 'ascii' codec can't encode character '\xe4' in position 2: ordinal not in range(128)
>>>


>>> open(r'C:\Python33\python.exe', 'r').read()
Traceback (most recent call last):
  File "", line 1, in
    open(r'C:\Python33\python.exe', 'r').read()
  File "C:\Python33\lib\encodings\cp1251.py", line 23, in decode
    return codecs.charmap_decode(input,self.errors,decoding_table)[0]
UnicodeDecodeError: 'charmap' codec can't decode byte 0x98 in position 16964: character maps to
>>>


>>> open("C:\\projects\\data.txt", 'w', encoding='cp500').writelines(['spam\n', 'ham\n'])

>>> open("C:\\projects\\data.txt", 'r', encoding='cp500').readlines()
['spam\n', 'ham\n']
>>>


>>> open("C:\\projects\\data.txt", 'r').readlines()
['ў—Ѓ”\n', '%€Ѓ”\n', '%']
>>>


>>> open("C:\\projects\\data.txt", 'rb').readlines()
[b'\xa2\x97\x81\x94\r%\x88\x81\x94\r%']
>>>


>>> open("C:\\projects\\data.txt", 'rb').read()
b'\xa2\x97\x81\x94\r%\x88\x81\x94\r%'
>>>


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


Преобразование символов конца строки в Windows

Конец строки текста в файле:

\n     в Unix и Linux

\r\n   в Windows


В Python объекты файлов автоматически отображают последовательность DOS \r\n в одиночный символ \n

При выполннии сценариев в Windows:

- для файлов открытых в текстовом режиме, при чтении \r\n преобразуется в \n
  при записи \n  преобразуется в \r\n

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

В UNIX - подобных системах преобразование не производится в любом режиме, т.к. там используется \n

Python скрипт всегда работает с \n
Просто во внешних файлах на платформе Windows он преобразует конец строки в \r\n

Поэтому если на платформе Windows вы ошибочно откроете двоичный файл в текстовом режиме,
то при сохранении вы можете повредить файл, если в файле  случайно втретился символ \n
вы его перезапиите в \r\n
а при чтении \r\n  символ  \r  будет отброшен


>>> open("C:\\projects\\data.txt", 'w').write('shrubbery\n')
10
>>>
\n  преобразован в \r\n


>>> open("C:\\projects\\data.txt", 'rb').read()
b'shrubbery\r\n'
>>>
>>> open("C:\\projects\\data.txt", 'r').read()
'shrubbery\n'
>>>
>>> data = b'a\0b\rc\r\nd'      # 4 байта 4 обычных символа
>>> len(data)
8
>>>

Запись двоичных данных
>>> open("C:\\projects\\data.bin", 'wb').write(data)
8
>>>

Чтение двоичных данных
>>> open("C:\\projects\\data.bin", 'rb').read()
b'a\x00b\rc\r\nd'
>>>
0 - отобразился как шестнадцатеричная последовательность x00


Попробуем прочитать в текстовом режиме:
>>> open("C:\\projects\\data.bin", 'r').read()
'a\x00b\nc\nd'
>>>

символы \r - искажены

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

>>> open("C:\\projects\\data.bin", 'w').write(data)
Traceback (most recent call last):
  File "", line 1, in
    open("C:\\projects\\data.bin", 'w').write(data)
TypeError: must be str, not bytes
>>>

В текстовом режиме должна передаваться строка типа str
Используйте  bytes.decode() для преобразования типа.

>>> data.decode()
'a\x00b\rc\r\nd'
>>> open("C:\\projects\\data.bin", 'w').write(data.decode())
8
>>>


>>> open("C:\\projects\\data.bin", 'rb').read()
b'a\x00b\rc\r\r\nd'
>>>
запись в текстовом режиме добавила символ \r


>>> open("C:\\projects\\data.bin", 'r').read()
'a\x00b\nc\n\nd'
>>>
опять символы \r искажены



Произвольный доступ к данным в файлах

При открытии файлов текущая позиция обычно устанавливается в смещение 0 от начала файла
и перемещается вперед по мере чтения/записи данных.

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

seek(n)

seek(n, mode)

mode = 0 абсолютное смещение на n байтов (по умолчанию)
mode = 1 смещение относительно текущей позиции на n байтов
mode = 2 смещение относительно конца файла на n байтов


seek(0)  - перемотать файл в начало (rewind) т.е. текущую позицию переместить в начало файла.


>>> records = [bytes([char]*8) for char in b'mars']
>>> records
[b'mmmmmmmm', b'aaaaaaaa', b'rrrrrrrr', b'ssssssss']
>>>
 


>>> myfile = open("C:\\projects\\random.bin", "w+b")
>>> for rec in records:
    size = myfile.write(rec) # записать 4 записи

   
>>> myfile.flush()
>>> pos = myfile.seek(0)    # прочитать файл целиком


>>> print(myfile.read())
b'mmmmmmmmaaaaaaaarrrrrrrrssssssss'
>>>


Теперь повторно откроем файл в режиме r+b
он также позволяет читать из файла и писать в него,
но не очищает файл при открытии.

>>> myfile = open("C:\\projects\\random.bin", "r+b")
>>> print(myfile.read())    # прочитать файл целиком
b'mmmmmmmmaaaaaaaarrrrrrrrssssssss'
>>>
 

>>> record = b'X' * 8
>>> myfile.seek(0)
0
>>>
 

>>> myfile.write(record)         # изменим первую запись
8
>>>
 

>>> myfile.seek(len(record)*2)
16
>>>
 

>>> myfile.write(b'Y' * 8)       # изменим 3-ю запись
8
>>>
 

>>> myfile.seek(8)
8
>>>
 

>>> myfile.read(len(record))     # извлечем 2-ю запись
b'aaaaaaaa'
>>>
 

>>> myfile.read(len(record))     # извлечем следующую (3-ю) запись
b'YYYYYYYY'
>>>
 

>>> myfile.seek(0)
0
>>>
 

>>> myfile.read()                # прочитать файл целиком
b'XXXXXXXXaaaaaaaaYYYYYYYYssssssss'
>>>


C:\projects>type random.bin
XXXXXXXXaaaaaaaaYYYYYYYYssssssss






Метод seek можно использовать, даже если файл открыт только для чтения.

Пример:

Чтение произвольных записей фиксированной длины.
Используем текстовый режим r
Данные представляют простой текст ASCII, где каждый символ представлен одним байтом
и текст не содержит символов конца строки.

>>> myfile = open("C:\\projects\\random.bin", "r")
>>>

>>> reclen = 8
>>>

>>> myfile.seek(reclen * 3)
24

>>> myfile.read(reclen)         # извлечь 4-ю запись
'ssssssss'
>>>

>>> myfile.seek(reclen * 1)
8

>>> myfile.read(reclen)         # извлечь 2-ю запись
'aaaaaaaa'
>>>


Двоичный режим с таким файлом работает также:

>>> myfile = open("C:\\projects\\random.bin", "rb")
>>>

>>> myfile.seek(reclen * 2)
16

>>> myfile.read(reclen)
b'YYYYYYYY'
>>>



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

Пример:

Соответствие между строкой Python и ее кодированным представлением в файле нарушается сразу же за первым не ASCII символом:


>>> data = 'sp\xe4m'

>>> data, len(data)
('späm', 4)

>>> data.encode('utf-8'), len(data.encode('utf-8'))
(b'sp\xc3\xa4m', 5)

Как видим , до кодирования длина строки составляла 4 байта, а после кодирования ее длина стала 5 байтов.
Это существенно осложняет возможность позиционирования по абсолютному смещению.

>>> myfile = open("C:\\projects\\test", mode = "w+", encoding = 'utf8')
>>>

>>> myfile.write(data)
4
>>>

>>> myfile.flush()
>>>

>>> myfile.seek(0); myfile.read(1)
0
's'                                    # для байтов ASCII все OK
>>>

>>> myfile.seek(2); myfile.read(1)
2
'ä'                                    # двухбайтоый не ASCII
>>>

>>> data[3]
'm'                                    # а в смещении 3 не "m" !!!
>>>

>>> myfile.seek(3); myfile.read(1)
3
Traceback (most recent call last):
  File "", line 1, in
    myfile.seek(3); myfile.read(1)
  File "C:\Python33\lib\codecs.py", line 300, in decode
    (result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xa4 in position 0: invalid start byte
>>>



Пример:

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

list.txt

come - приходить                  
get - получить                    
give - давать                     
go - идти                         
keep - держать                    
let - позволять                   
make - сделать                    
put - поместить                   
seem - казаться                   
take - взять                      
be - быть                         

trans.txt

the [ðə:]
think [θiŋk]
or [ɔ:]
got [gɔt]
good [gud]
eye [ai]
before [bi'fɔ:]
long [lɔŋ]
let [let]
take [teik]
saw [sɔ:]
room [ru:m]
place [pleis]
those [ðəuz]
work [wз:k]
put [put]
 

 with open("C:\\test\\list.txt", "r", encoding='utf-8') as f1, open("C:\\test\\trans.txt", "r", encoding='utf-8') as f2, open("C:\\test\\out.txt", "w", encoding='utf-8') as f3:
    for line1 in f1:
        p1 = line1.split()
        f2.seek(0)
        i=0
        for line2 in f2:
            p2 = line2.split()
            if p2 != []:
                if (p2[0].lower() == p1[0].lower()):
                    f3.write("{0:20} {1:20} {2:3} {3:30}\n".format(p1[0],p2[1],p1[1]," ".join(str(x) for x in p1[2:len(p1)])))
                    i+=1
        if i == 0:
            f3.write("{0:20} {1:20} {2:3} {3:30}\n".format(p1[0],"[]",p1[1]," ".join(str(x) for x in p1[2:len(p1)])))







out.txt
 
come                []                   -   приходить                    
get                  []                   -   получить                     
give                 []                   -   давать                       
go                   []                   -   идти                         
keep                 []                   -   держать                      
let                  [let]                -   позволять                    
make                 []                   -   сделать                      
put                  [put]                -   поместить                    
seem                 []                   -   казаться                     
take                 [teik]               -   взять                        
be                   []                   -   быть                         



Или так:

with open("C:\\test\\list.txt", "r", encoding='utf-8-sig') as f1, open("C:\\test\\trans.txt", "r", encoding='utf-8-sig') as f2, open("C:\\test\\out.txt", "w", encoding='utf-8-sig') as f3:
    for line1 in f1:
        p1 = line1.split()
        f2.seek(0)
        i=0
        for line2 in f2:
            p2 = line2.split()
            if p2 != []:
                if (p2[0].lower() == p1[0].lower()):
                    i+=1
                    if i == 1:
                        f3.write("{0:20} {1:20} {2:3} {3:30}\n".format(p1[0],p2[1],p1[1]," ".join(str(x) for x in p1[2:len(p1)])))
        if i == 0:
            f3.write("{0:20} {1:20} {2:3} {3:30}\n".format(p1[0],"[]",p1[1]," ".join(str(x) for x in p1[2:len(p1)])))