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

Логические операции в 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

Дополнительные наборы модулей (библиотек) языка программирования 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%]

Спецификаторы формата для целых чисел 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))

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


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

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