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

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


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

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

Основы 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>