Основы Python в кратком изложении. Python реферат

Случайные заметки: Доклад по Python: часть I

Python - это интерпретируемый алгоритмический объектно-ориентированный язык со строгой динамической типизацией, полиморфизм в нем реализован в виде Duck Typing.

Трансляция питона организована очень схожим с Java образом. Именно, исходник компилируется в байт-код, а затем этот байт-код исполняется. Это сходство настолько велико, что существует реализация Питона (Jython), генерирующая Java байт-код для исполнения виртуальной машиной Java. Различие состоит в политике, когда записывать байт-код на диск. Напомню, для Java традиционный способ запустить только что написанную программу такой: запускаем компилятор, подсовывая ему исходник - он генерирует байт-код и записывает его в файл. Затем запускаем виртуальную машину, подсовывая ей байт-код - и она его исполняет.Питон же обычно не записывает байт-код на диск. В простейшем случае запуск программы происходит так: мы "скармливаем" исходник интерпретатору; он генерирует байт-код, но оставляет его в памяти, а затем передает виртуальной машине (являющейся частью интерпретатора). Это ускоряет запуск программы за счет отсутствия необходимости записывать байт-код на диск.Однако, при загрузке (импорте) модулей Питон пытается сохранить байт-код, чтобы в следующий раз загрузка модуля происходила быстрее. Есть возможность и саму программу записать в виде байт-кода. Интерпретатору Питона можно подсовывать не только исходники, но и байт-код - он загрузится быстрее.За счет такого сходства в устройстве с Java имеем и большое сходство в производительности (она примерно одинаковая, только Питон чуть быстрее загружает программы за счет того, что не пишет байт-код на диск).И именно из-за этого сходства Питон обычно сравнивают именно с Явой.

Еще одно сходство с Явой (и многими другими интерпретируемыми и даже некоторыми компилируемыми языками) - это автоматическое управление памятью. В Питоне нет new[] и delete[], память отводится и освобождается автоматически. Алгоритм сборки мусора как бы "двухслойный": во-первых, сам интерпретатор реализует reference counting (удаляя объекты, на которые никто не ссылается), и во-вторых, есть время от времени запускаемый garbage collector, работающий по более замысловатым, но более быстрым и надежным алгоритмам (например, reference counting не удалит два объекта, ссылающихся друг на друга, даже если на них больше никто не ссылается).

Удобным свойством интерпретатора Питона является наличие REPL (read-eval-print loop), то есть возможности вводить языковые конструкции с консоли и тут же получать результат. Это часто используется для проверки каких-нибудь идей или для отладки.

1.1. Синтаксис.

В самых общих чертах синтаксис Питона напоминает С или Паскаль. Операторы записываются обычно по одному на строку. Присваивание записывается как в С, знаком =. Но при этом присваивание не возвращает значения, поэтому его нельзя использовать в условии. Для сравнений используются обычные для С знаки ==, !=, >,=,if x < 0:print "Yes"elif x==0:print "X is 0"else:print "No"

for i in [1,2,3]:print ielse:print "Loop was not break'ed"

while x>0:print xx -= 1

try:z = x/yexcept ZeroDivisionError,e:print eelse:print "Divided sucsessfully."finally:print "Some cleanup."

def fun(x,y):return x+y

class Child(Parent):x = 0def method(self,x,y):return self.x - x + y

f = open("abc.txt")for line in f:print "<%s>" % linef.close()В последнем примере показана замена функции sprintf: "строка" % (данные). В проектируемой сейчас версии Python3000 этот способ исчезнет, а вместо него появится другой: "Value {0}, Value {1}".format("one", 2).

1.2. Типы данных.

В Питоне выделяют атомарные и структурные (или ссылочные) типы данных. К атомарным типам относятся числа и строки. Структурные типы - это списки, кортежи (tuples), словари, функции, классы и экземпляры классов.

Данные некоторых типов (а именно - кортежи и строки) являются неизменяемыми.

Списки записываются так: [1, "one", 25]. Список может содержать любое количество объектов любого типа. Обращение к элементу списка - по индексу: a[2] (элементы нумеруются с нуля). Добавление элементов в список можно делать так:

a = a + [25]

или так (предпочтительней, т.к. быстрее):

a.append(25).

Кортежи записываются как значения через запятую: a,b,c. Часто для ясности кортежи приходится записывать в скобках: (a,b,c). Кортежи, как и списки, могут содержать значения любых типов, но, в отличие от списков, являются неизменяемыми.

Для строк, списков и кортежей есть специальный синтаксис для обращения к части данных, называемый срезами (впервые такой синтаксис появился еще в Фортране):

>>> a = "abcde">>> a[3:5]'de'>>> a[:2]'ab'>>> a[4:]'e'>>> a[:-2]'abc'>>> a[::-1]'edcba'>>> a[5:2:-1]'ed'>>> a[:]'abcde'>>> a[::2]'ace'

Словари в Питоне - это структура, соответствующая хэшам в Перле, массивам в PHP и std::map в C++. Записываются так:

{'a': 1, 'b': 2, 'c': 3}

или так:

dict(a=1,b=2,c=3).

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

print d['key']

Метод keys() возвращает список из ключей словаря, а values() - список из значений. Порядок следования ключей не определен:

>>> d = dict(a=1,b=2,c=3)>>> d.keys()['a', 'c', 'b']>>> d.values()[1, 3, 2]

Функции создаются так:

def f(x):"Documentation string (docstring)"return x*x

или так:

f = lambda x: x*x

О классах и их экземплярах будем подробно говорить дальше.

2. Типизация.

Главное отличие Питона от Явы (если брать только чисто "лингвистические" свойства) - это типизация. Напомню, в Яве используется строгая статическая типизация с явным объявлением типов переменных. Это означает, что типы всех переменных известны в момент компиляции, и тогда же происходит проверка типов. Это дает преимущество в том плане, что значительная часть ошибок отлавливается в момент компиляции. Зато это замедляет компиляцию. В Питоне используется строгая динамическая типизация. "Динамическая" означает, что типы переменных становятся известными только во время выполнения, и тогда же выполняются проверки типов. Это дает больше возможностей написать неработающий код, но ускоряет компиляцию и дает значительную гибкость. Пример:

>> a = 20 # теперь a - это число, тип int>> a = "a string" # а теперь - строка, тип str.

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

>>> x = [1,2,3] # x - это список>>> y = x # y указывает туда же, куда x (копируется указатель).>>> y[1] = 5 # изменяем элемент из y>>> x # он изменился и в x.[1, 5, 3]

Таким образом, в терминах C++, имя переменной - это ссылка (указатель), (void*). Исключением являются атомарные типы данных - числа и строки. Пример:

>>> a = 1>>> b = a # здесь копируется уже не ссылка, а собственно значение>>> b = 3 # присваиваем другое значение...>>> a # на переменную a это не повлияло.1

По той же схеме передаются аргументы в функцию.

За счет того, что информация о типе хранится вместе со значением, она доступна во время исполнения. Пример:

>>> a = 1>>> type(a)<type 'int'>>>> a = "a string">>> type(a)<type 'str'>

Таким образом, имеет смысл запись вроде if type(a) == str:...

iportnov.blogspot.ru

Основы Python в кратком изложении / Хабрахабр

Python для начинающих. Глава первая. «О чем это мы»

На всякий случай, немного скучного «evangelism». Кому он надоел, можно пропустить несколько абзацев. Python (читается как «Пайтон» а не «питон») — скриптовый язык, разработанный Гвидо ван Россумом в качестве простого языка, легкого в изучении новичку. В наше время Пайтон – широко распространенный язык, который используется во многих областях: — Разработка прикладного ПО (например linux-утилиты yum, pirut, system-config-*, IM-клиент Gajim и многие другие) — Разработка web-приложений (мощнейший Application-сервер Zope и разработанная на его основе CMS Plone, на основе которой работает например сайт ЦРУ, и масса фреймворков для быстрой разработки приложений Plones, Django, TurboGears и многие другие) — Использование в качестве встраиваемого скриптового языка во многих играх, и не только (в офисном пакете OpenOffice.org, 3d редакторе Blender, СУБД Postgre) — Использование в научных рассчетах (с пакетами SciPy и numPy для расчетов и PyPlot для рисования графиков Пайтон становится практически сравним с пакетами типа MatLab)

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

1. Сам интерпретатор, его можно взять тут (http://python.org/download/). 2. Среда разработки. Она для начала необязательна, да и идущий в дистрибутиве IDLE подойдет новичку, но для серъезных проектов нужно что-то посерьезней. Для Windows я использую замечательный легковесный PyScripter (http://tinyurl.com/5jc63t), для Linux – Komodo IDE.

Хотя для первого урока достаточно будет просто интерактивной оболочки самого Пайтона.

Просто запустите python.exe. Приглашение ввода не заставит себя долго ждать, оно выглядит так:

Также можно записывать программы в файлы с расширением py, в вашем любимом текстовом редакторе, который не добавляет к тексту своих символов разметки (нет Word не подойдет). Также желательно чтобы этот редактор умел делать «умные табуляторы» и не заменял пробелы знаком табуляции. Для запуска файлов на исполнение по ним можно щелкать 2 раза. Если консольное окно закрывается слишком быстро, вставьте в конце программы следующую строку:

Тогда интерпретатор будет в конце программы ждать нажатия enter.

Или ассоциируйте py-файлы в Far с Пайтоном и открывайте нажимая enter.

Наконец можно воспользоваться одной из многих удобных IDE для Пайтона, которые предоставляют и возможности отладки и подсветку синтаксиса и многие другие «удобства».

Немного теории.

Для начала, Пайтон – язык со строгой динамической типизацией. Что это означает?

Есть языки со строгой типизацией (pascal, java, c и т.п.), у которых тип переменной определяется заранее и не может быть изменен, и есть языки с динамической типизацией (python, ruby, vb), в которых тип переменной трактуется в зависимости от присвоенного значения. Языки с динамической типизацией можно разделить еще на 2 вида. Строгие, которые не допускают неявного преобразования типа (Пайтон) и нестрогие, которые выполняют неявные преобразования типа (например VB, в котором можно легко сложить строку '123' и число 456). Разобравшись с классификацией Пайтона, попробуем немного «поиграть» с интерпретатором.

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

Следующее, что необходимо знать – как строятся базовые алгоритмические единицы – ветвления и циклы. Для начала, необходима небольшая справка. В Пайтоне нет специального ограничителя блоков кода, их роль выполняют отступы. То есть то что написано с одинаковым отступом – является одним командным блоком. Поначалу это может показаться странным, но после легкого привыкание, понимаешь что эта «вынужденная» мера позволяет получать очень читабельный код. Итак условия.

Условие задается с помощью оператора if, который заканчивается «:». Альтернативные условия которые будут выполняться если первая проверка «не прошла» задаются оператором elif. Наконец else задает ветку, которая будет выполнена если ни одно из условий не подошло. Обратите внимание, что после ввода if интерпретатор с помощью приглашения «...» показывает что он ожидает продолжения ввода. Чтобы сообщить ему что мы закончили, необходимо ввести пустую строку.

(Пример с ветвлениями почему-то рвет разметку на хабре, не смотря на танцы с тегами pre и code. Простите за неудобство, я его кинул сюда pastebin.com/f66af97ba, если кто-то подскажет что не так — буду очень признателен)

Циклы.

Простейшим случаем цикла является цикл while. В качестве параметра он принимает условие и выполняется до тех пор, пока оно истино. Вот маленький пример.

Обратите внимание что поскольку и print x и x+=1 написаны с одинаковым отступом, они считаются телом цикла (помните что я говорил про блоки? ;-) ).

Второй вид циклов в Пайтон – цикл for. Он аналогичен циклу foreach других языков. Его синтаксис условно таков.

for переменная in список: команды

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

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

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

На входе она принимает от одного до трех параметров, на выходе возвращает список чисел, по которому мы можем «пройтись» оператором for.

Вот несколько примеров использования функции range, которые объясняют роль ее параметров.

И маленький пример с циклом.

Ввод-вывод

Последнее, что следует знать перед тем как начать использовать Пайтон полноценно – это как осуществляется в нем ввод-вывод.

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

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

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

Вот и все для первого урока.

Домашнее задание.

1. Составить программу расчета гипотенузы прямоугольного треугольника. Длина катетов запрашивается у пользователя. 2. Составить программу нахождения корней квадратного уравнения в общем виде. Коэффициенты запрашиваются у пользователя. 3. Составить программу вывода таблицы умножения на число M. Таблица составляется от M * a, до M * b, где M, a, b запрашиваются у пользователя. Вывод должен осуществляется в столбик, по одному примеру на строку в следующем виде (например): 5 х 4 = 20 5 х 5 = 25 И так далее.

habrahabr.ru

Python_курсовая

МИНИСТЕРСТВО ОБРАЗОВАНИЯ НАУКИ МОЛОДЕЖИ И СПОРТА УКРАИНЫ

НАЦИОНАЛЬНЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ «ХПИ»

КУРСОВАЯ РАБОТА

По курсу информатики

Кафедра «Автомобиле- и тракторостроения»

Выполнил: ст. группы ТМ-71б

Дыга Вадим

Проверил: старший преподаватель

Андросенко Виталий Викторович

РЕФЕРАТ

Объект разработки – база данных для хранения дипломных проектов.

Цель работы – разработка базы данных на языке программирования Python.

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

База данных была экспериментально опробована, в результате чего было установлено, что существенных ошибок в коде программы не выявлено. Программа может быть успешно применена в работе стат. отделов ВУЗов.

Содержание:

1. Вступление

2. Структура б/д

3. Окна ввода-вывода информации

4. Технология переходов

5. Листинг с пояснениями

6. Специальное задание

7. Направления улучшения

8. Вывод

9. Список использованной литературы

Вступление

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

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

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

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

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

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

Структура базы данных

Исходя из задания была разработана база данных:

Рисунок 1 – Структура базы данных Base_stud.bso

Окна ввода/вывода информации

Окно «А»:

Окно «А» выполняет функции входа

Окно «В»:

В этом окне можно добавить диплом или открыть уже готовый. Так же можно настроить параметры шрифта и прочесть о готовой б/д.

Окно «С»:

Окно «С» служит для ввода всей информации о студенте, также здесь указуються пути к документу с текстом и папке с изображениями.

Окно «D»:

В окне «D» выполняется поиск записей по заданным параметрам

Окно «P»:

Окно «P» служит для вывода полной информации по студенту

Технология переходов

Листинг с пояснениями

osnovnoe okno.py

# -*- coding: utf-8 -*-

import Tkinter

import string

import tkMessageBox

import sys

import os

import New_Data

import Font

import Find_Data

import Copy_Rez

import O_Prog

import tkFont

class system:

def __init__(self, root, all_font):

self(root, all_font)

def __call__(self, root, all_font):

def font(event = None):

Font.font(root)

def VHOD (event = None):

if self.tip_dostupa == u"Студент":

B()

else:

pass

def B (even = None):

#if even == u"Студент":

def close_all_prevision(event = None):

try:

del (self.C.FRC)

print u"Окно С закрыто"

except: pass

try:

del(self.D.FRD)

print u"Окно D закрыто"

except:

pass

try:

del(self.E.FRE)

print u"Окно E закрыто"

except:

pass

try:

del(self.K)

print u"Окно K закрыто"

except:

pass

try:

del(self.O.FRO)

print u"Окно O закрыто"

except:

pass

#Создание окна "Новая запись"

def Window_C(event = None):

close_all_prevision()

self.C= New_Data.new_data(root,all_font)

#Создание окна "Найти запись"

def Window_D(event = None):

close_all_prevision()

self.D = Find_Data.find_data(root,all_font)

#Создание окна "Резервное копирование"

def Window_E (event = None):

close_all_prevision()

self.E = Copy_Rez.copy_rez(root,all_font)

#Создание окна "Шрифты"

def Window_K(event = None):

close_all_prevision()

self.K = Font.font(root,all_font)

def Window_O(event = None):

close_all_prevision()

self.O = O_Prog.o_prog(root,all_font)

FR.destroy()

root.geometry("1024x768+0+0")

root.update()

root.title(u"База данных дипломных робот студентов ТМ факультета")

Bar = Tkinter.Menu(root)

Bar ["font"] = all_font

Bar["tearoff"] = 0

Menu1 = Tkinter.Menu(Bar, tearoff = 0 , font = all_font)

Menu1.add_command(label = u"Новая запись", command = Window_C)

Menu1.add_command(label = u"Найти запись", command = Window_D)

Menu1.add_command(label = u"Резервное копирование", command = Window_E)

Menu1.add_command(label = u"Общая информация")

Menu1.add_separator()

Menu1.add_command(label = u"Выход", command=die)

Vid = Tkinter.Menu(Bar, tearoff = 0 , font = all_font)

Vid.add_command(label = u"Размер")

Vid.add_command(label = u"Шрифты",command = Window_K)

Prog = Tkinter.Menu(Bar, tearoff = 0 , font = all_font)

Prog.add_command(label = u"Помощь")

Prog.add_command(label = u"О программе", command = Window_O)

Bar.add_cascade(label = u"Управление базой", menu = Menu1)

Bar.add_cascade(label = u"Настройка вида", menu = Vid)

Bar.add_cascade(label = u"О программе", menu = Prog)

root.config(menu=Bar)

root.mainloop()

#else:

#pass

#Изминение состояния полей ввода и кнопок

def var123 (even = None):

if even == u"Студент":

Ent1["state"] = "disabled"

Ent2["state"] = "disabled"

But2["state"] = "normal"

else:

Ent1["state"] = "normal"

Ent2["state"] = "normal"

But2["state"] = "normal"

#Закрытие программы

def die(even = None):

response = tkMessageBox.askyesno(u"Важно!!!",u"Закрыть базу данных дипломных работ студентов ТМ-факультета?")

r = response

if r == 1:

sys.exit(0)

else:

responce.destroy()

FR = Tkinter.Frame(root)

FR["width"] = 250

FR["height"] = 300

FR.place(relx = 0.5, rely = 0.5, anchor = "center" )

FR["bg"] = "white"

FR ["bd"] = "4m"

FR["relief"] = "groove"

#Меню "Тип доступа"

def big(event = None):

MB_NEW["text"] = (NEW_text[event])

var123(NEW_text[event])

self.tip_dostupa = NEW_text[event]

MB_NEW = Tkinter.Menubutton(FR, relief = "raised", justify = "center")

MB_NEW.place(relx = 0.5, rely = 0.2, anchor = "center")

MB_NEW.menu = Tkinter.Menu(MB_NEW, tearoff = 0)

MB_NEW ["menu"] = MB_NEW.menu

MB_NEW ["bg"] = "grey"

MB_NEW ["activebackground"] = "white"

MB_NEW ["width"] = 20

NEW_text = [u"Администратор", u"Преподаватель", u"Студент"]

MB_NEW["text"] = (u"Тип доступа")

NEW = []

for i in NEW_text:

NEW.append(i+" "*(20-len(i)))

MB_NEW.menu.add("cascade", label = NEW[0], command = lambda m=0 :big(m))

MB_NEW.menu.add("cascade", label = NEW[1], command = lambda m=1 :big(m))

MB_NEW.menu.add("cascade", label = NEW[2], command = lambda m=2 :big(m))

#Поле ввода "Имя пользователя"

LaFR1 = Tkinter.LabelFrame(FR)

LaFR1["text"] = u"Имя пользователя"

LaFR1.place(relx = 0.5, rely = 0.4, anchor = "center")

Ent1 = Tkinter.Entry(LaFR1)

Ent1["width"] = 25

Ent1["state"] = "disabled"

Ent1.pack()

name = Ent1

#Поле ввода "Пароль"

LaFR2 = Tkinter.LabelFrame(FR)

LaFR2["text"] = u"Пароль"

LaFR2.place(relx = 0.5, rely = 0.55, anchor = "center")

Ent2 = Tkinter.Entry(LaFR2)

Ent2["width"] = 25

Ent2["state"] = "disabled"

Ent2 ["show"] = "*"

Ent2.pack()

parol = Ent2

#Кнопка "Вход"

But2 = Tkinter.Button(FR)

But2["bg"] = "white"

But2["bd"] = "1m"

But2["relief"] = "raised"

But2["text"] = u"Вход"

But2["state"] = "disabled"

But2.place(relx = 0.4, rely = 0.8, anchor = "center")

But2.bind("<Button-1>",VHOD)

But2.bind("<Return>", VHOD)

#Кнопка "Выход"

But1 = Tkinter.Button(FR)

But1["bg"] = "white"

But1["bd"] = "1m"

But1["relief"] = "raised"

But1.place(relx = 0.2, rely = 0.8, anchor = "center")

But1["text"] = u"Выход"

But1.bind("<Button-1>", die)

#Кнопка "Регистрация"

But3 = Tkinter.Button(FR)

But3["bg"] = "white"

But3["bd"] = "1m"

But3["relief"] = "raised"

But3.place(relx = 0.7, rely = 0.8, anchor = "center")

But3["text"] = u"Регистрация"

But3.bind("<Button-1>")

root.mainloop()

if __name__ == "__main__":

root = Tkinter.Tk()

vysota_vhod = root.winfo_screenheight()

shyrina_vhod = root.winfo_screenwidth()

x_vhod = (shyrina_vhod / 2) - 125

y_vhod = (vysota_vhod / 2) - 150

razm_x_y = "250x300+%s+%s"%(x_vhod,y_vhod)

root.geometry(razm_x_y)

root.title(u"Вход в базу данных дипломных проэктов

all_font = tkFont.Font()

all_font ["family"] = "Helvetica"

all_font ["size"] = 15

all_font ["weight"] = "normal"

system(root,all_font)

New_Data.py

# -*- coding: cp1251 -*-

import Tkinter

import ScrolledText

import tkFont

import os

import string

import pickle

import tkFileDialog

import Image

import ImageTk

#окно "С" - создание новой записи

class new_data:

def __init__(self, root,all_font):

self(root,all_font)

def __call__(self, root,all_font):

def New_dictonary(event = None):

Base = {}

ss = 0

for i in range(0,13):

self.Param_2[self.dosm[i]] = self.informatino[ss]

ss = ss + 1

print type(self.informatino[ss])

self.Param_2["Theme"] = self.ST.get(index1 = 0.0,index2 = "end")

self.Param_2["Stepen"] = self.stepen

self.Param_2["tabl"] = Ent15.get()

#print self.ST.get(index1 = 0.0,index2 = "end")

#*******************************************************************************

#ПРОВЕРКА ПУТЕЙ:

if os.path.exists("C:\\TM_Base") == 1:

os.chdir("C:\\TM_Base")

else:

os.makedirs("C:\\TM_Base")

os.chdir("C:\\TM_Base")

Sohranenie()

def Sohranenie (event= None):

def Sohranenie_pict(event = None): #сохранение картинок

os.chdir(self.path_pict)

print os.listdir(self.path_pict)

t = os.listdir(self.path_pict)

u = ["C:\\TM_Base\\Spec\\" + self.key_key + "\\",'C:\\TM_Base\\Bakalavr\\' + self.key_key + '\\','C:\\TM_Base\\Magistr\\' + self.key_key + '\\']

d = u[event]

for i in t:

os.chdir(self.path_pict)

open_pict = open(i,"rb")

p = open_pict.read()

open_pict.close()

os.chdir(u[event])

stud_pict = open(i ,"wb")

stud_pict.write(p)

stud_pict.close()

def Sohranenie_text (event = None):

u = ["C:\\TM_Base\\Spec\\" + self.key_key + "\\",'C:\\TM_Base\\Bakalavr\\' + self.key_key + '\\','C:\\TM_Base\\Magistr\\' + self.key_key + '\\']

z = string.split(self.path_pdf,"/")

try:

for i in z:

if i.find(".docx") != -1:

self.pdf = i

print self.pdf

elif i.find(".pdf") != -1:

self.pdf = i

print self.pdf

elif i.find(".txt") != -1:

self.pdf = i

print self.pdf

elif i.find(".doc") != -1:

self.pdf = i

print self.pdf

else:

pass

h = len (self.path_pdf)

j = len (self.pdf)

l = h - j

N = self.path_pdf[0:l]

print N

os.chdir(N)

open_pdf = open(self.pdf,"rb")

f = open_pdf.read()

open_pdf.close()

os.chdir(u[event])

stud_pdf = open(self.pdf,"wb")

stud_pdf.write(f)

stud_pdf.close()

except:

krasavchik_font = tkFont.Font()

krasavchik_font ["family"] = "Helvetica"

krasavchik_font ["size"] = 30

krasavchik_font ["weight"] = "bold"

krasavchik_font ["slant"] = "italic"

krasavchik = Tkinter.Label(self.FRC)

krasavchik["text"] = u"Не верный тип данных!\n Текстовый файл не сохранен!!!"

krasavchik["font"] = krasavchik_font

krasavchik["bg"] = "red"

krasavchik.place(relx = 0.5,rely = 0.6 , anchor = "center")

def create_folders (event = None):

#ПРОВЕРКА ПУТЕЙ К ПАПКЕ СПЕЦИАЛИСТ:

u = ["C:\\TM_Base\\Spec\\",'C:\\TM_Base\\Bakalavr\\','C:\\TM_Base\\Magistr\\']

if os.path.exists(u[event]) == 1:

os.chdir(u[event])

else:

os.makedirs(u[event])

os.chdir(u[event])

key_1 = self.Param_2.get("Name_S")

key_2 = self.Param_2.get("SName_S")

key_3 = self.Param_2.get("LName_S")

self.key_key = key_2 +"_" + key_1 +"_" + key_3

if os.path.exists(u[event] + self.key_key + "\\") == 1:

os.chdir(u[event] + self.key_key + "\\")

self.stud_file = open ("Base_stud.bso", "rb") #ОТКРЫВАЕМ ФАЙЛ С ИНФ О СТУДЕНТЕ

else:

os.makedirs(u[event] + self.key_key)

os.chdir(u[event] + self.key_key)

self.stud_file = open ("Base_stud.bso", "wb") #ОТКРЫВАЕМ ФАЙЛ С ИНФ О СТУДЕНТЕ

try:

pickle.dump(self.Param_2,self.stud_file)

except:

self.stud_file.close()

self.stud_file = open ("Base_stud.bso", "wb")

pickle.dump(self.Param_2,self.stud_file)

self.stud_file.close()

Sohranenie_text(event)

Sohranenie_pict(event)

if self.stepen == u"Специалист":

create_folders(0)

elif self.stepen == u"Бакалавр":

create_folders(1)

else:

create_folders(2)

#***********************************************************************************************************************

def otmena(event = None):

self.FRC.destroy()

root.title(u"Cоздание новой записи")

#root.geometry("1024x768+0+0")

def Seve_inform(event = None):

entry_get=[]

for i in Inform:

if i.get() == '':

i["bg"] = "red"

else:

i["bg"] = "white"

entry_get.append(i.get())

self.informatino = entry_get

if len(entry_get) == 14:

New_dictonary()

krasavchik_font = tkFont.Font()

krasavchik_font ["family"] = "Helvetica"

krasavchik_font ["size"] = 30

krasavchik_font ["weight"] = "bold"

krasavchik_font ["slant"] = "italic"

krasavchik = Tkinter.Label(self.FRC)

krasavchik["text"] = u"Новая запись успешно добавлена"

krasavchik["font"] = krasavchik_font

krasavchik["bg"] = "yellow"

krasavchik.place(relx = 0.5,rely = 0.5 , anchor = "center")

else:

pass

#Новая рамка для окна "С"

self.FRC = Tkinter.Frame(root)

self.FRC["width"] = 1024

self.FRC["height"] = 768

self.FRC.place(relx = 0, rely = 0, anchor = "nw" )

Inform = []

self.dosm = ["Spec","Grup","Mark","God_1","Name_S","SName_S","LName_S","Name_P","SName_P","LName_P","page","plac","pict","tabl"]

#Parametry = ["Специальность","Группа","Оценка","Год защити","Имя","Фамилия","Отчество","Имя2","Фамилия2","Отчество2","Тема дипломного проэкта","Количество страниц","Количество плакатов","Количество рисунков","Количество таблиц"]

self.Param_2 = {"Spec":u"","Grup":u"","Mark":"","God_1":"","Name_S":"","SName_S":"","LName_S":"","Name_P":"","SName_P":"","LName_P":"","page":"","plac":"","pict":"","tabl":u"попал ты чувак"}

#Создание полей ввода, первая строка

LaFR1 = Tkinter.LabelFrame(self.FRC)

LaFR1["text"] = u"Специальность"

LaFR1["font"] = all_font

LaFR1.place(relx = 0.02, rely = 0.03, anchor = "w")

Ent1 = Tkinter.Entry(LaFR1)

Ent1["width"] = 40

Inform.append(Ent1)

Ent1.pack()

LaFR2 = Tkinter.LabelFrame(self.FRC)

LaFR2["text"] = u"Группа"

LaFR2["font"] = all_font

LaFR2.place(relx = 0.34, rely = 0.03, anchor = "w")

Ent2 = Tkinter.Entry(LaFR2)

Ent2["width"] = 10

Inform.append(Ent2)

Ent2.pack()

LaFR3= Tkinter.LabelFrame(self.FRC)

LaFR3["text"] = u"Оценка"

LaFR3["font"] = all_font

LaFR3.place(relx = 0.42, rely = 0.03, anchor = "w")

Ent3 = Tkinter.Entry(LaFR3)

Ent3["width"] = 10

Inform.append(Ent3)

Ent3.pack()

LaFR4 = Tkinter.LabelFrame(self.FRC)

LaFR4["text"] = u"Год защити"

LaFR4["font"] = all_font

LaFR4.place(relx = 0.5, rely = 0.03, anchor = "w")

Ent4 = Tkinter.Entry(LaFR4)

Ent4["width"] = 10

Inform.append(Ent4)

Ent4.pack()

LaFR5= Tkinter.LabelFrame(self.FRC)

LaFR5["text"] = u"Степень"

LaFR5["font"] = all_font

LaFR5.place(relx = 0.66, rely = 0.03, anchor = "w")

def big(event = None):

MB_NEW["text"] = (NEW_text[event])

self.stepen = MB_NEW["text"]

#self.Inform.append(MB_NEW["text"])

MB_NEW = Tkinter.Menubutton(LaFR5, relief = "raised", justify = "center")

MB_NEW.menu = Tkinter.Menu(MB_NEW, tearoff = 0)

MB_NEW ["menu"] = MB_NEW.menu

MB_NEW ["bg"] = "grey"

MB_NEW ["activebackground"] = "white"

MB_NEW ["width"] = 15

NEW_text = [u"Специалист", u"Бакалавр", u"Магистр", u" Выбрать " ]

MB_NEW["text"] = (NEW_text[3])

NEW = []

for i in NEW_text:

NEW.append(i)

MB_NEW.menu.add("cascade", label = NEW[0], command = lambda m=0 :big(m))

MB_NEW.menu.add("cascade", label = NEW[1], command = lambda m=1 :big(m))

MB_NEW.menu.add("cascade", label = NEW[2], command = lambda m=2 :big(m))

MB_NEW.pack()

#Создание полей ввода, вторая строка (Данные о студенте)

LaFR_Date_1 = Tkinter.LabelFrame(self.FRC)

LaFR_Date_1["text"] = u"Данные о студенте"

LaFR_Date_1["font"] = all_font

LaFR_Date_1.place(relx = 0.01, rely = 0.12, anchor = "w")

LaFR_Date_1["width"] = 924

LaFR_Date_1["height"] = 85

LaFR6 = Tkinter.LabelFrame(LaFR_Date_1)

LaFR6["text"] = u"Имя"

LaFR6["font"] = all_font

LaFR6.place(relx = 0.01, rely = 0.5 , anchor = "w")

Ent6 = Tkinter.Entry(LaFR6)

Ent6["width"] = 40

Inform.append(Ent6)

Ent6.pack()

LaFR7 = Tkinter.LabelFrame(LaFR_Date_1)

LaFR7["text"] = u"Фамилия"

LaFR7["font"] = all_font

LaFR7.place(relx = 0.5, rely = 0.5 , anchor = "center")

Ent7 = Tkinter.Entry(LaFR7)

Ent7["width"] = 40

Inform.append(Ent7)

Ent7.pack()

LaFR8 = Tkinter.LabelFrame(LaFR_Date_1)

LaFR8["text"] = u"Отчество"

LaFR8["font"] = all_font

LaFR8.place(relx = 0.99, rely = 0.5 , anchor = "e")

Ent8 = Tkinter.Entry(LaFR8)

Ent8["width"] = 40

Inform.append(Ent8)

Ent8.pack()

#Создание полей ввода, третья строка (Данные о научном руководителе)

LaFR_Date_2 = Tkinter.LabelFrame(self.FRC)

LaFR_Date_2["text"] = u"Данные о научном руководителе"

LaFR_Date_2["font"] = all_font

LaFR_Date_2.place(relx = 0.01, rely = 0.25, anchor = "w")

LaFR_Date_2["width"] = 924

LaFR_Date_2["height"] = 85

LaFR9 = Tkinter.LabelFrame(LaFR_Date_2)

LaFR9["text"] = u"Имя"

LaFR9["font"] = all_font

LaFR9.place(relx = 0.01, rely = 0.5 , anchor = "w")

Ent9 = Tkinter.Entry(LaFR9)

Ent9["width"] = 40

Inform.append(Ent9)

Ent9.pack()

LaFR10 = Tkinter.LabelFrame(LaFR_Date_2)

LaFR10["text"] = u"Фамилия"

LaFR10["font"] = all_font

LaFR10.place(relx = 0.5, rely = 0.5 , anchor = "center")

Ent10 = Tkinter.Entry(LaFR10)

Ent10["width"] = 40

Inform.append(Ent10)

Ent10.pack()

LaFR11 = Tkinter.LabelFrame(LaFR_Date_2)

LaFR11["text"] = u"Отчество"

LaFR11["font"] = all_font

LaFR11.place(relx = 0.99, rely = 0.5 , anchor = "e")

Ent11 = Tkinter.Entry(LaFR11)

Ent11["width"] = 40

Inform.append(Ent11)

Ent11.pack()

#Поле ввода текста "Тема дипломного проэкта"

LaFR_Date_3 = Tkinter.LabelFrame(self.FRC)

LaFR_Date_3["text"] = u"Тема дипломного проэкта"

LaFR_Date_3["font"] = all_font

LaFR_Date_3.place(relx = 0.01, rely = 0.32, anchor = "nw")

self.ST =ScrolledText.ScrolledText(LaFR_Date_3,background="white")

self.ST["width"] = 150

self.ST["height"] =7

#self.self.ND = ST.get()

#Inform.append(ST)

#mm = ST.get()

#print self.ND

self.ST.pack()

#Создание полей ввода, третья строка (Данные о дипломном проэкте)

LaFR_Date_4 = Tkinter.LabelFrame(self.FRC)

LaFR_Date_4["text"] = u"Данные о дипломном проэкте"

LaFR_Date_4["font"] = all_font

LaFR_Date_4.place(relx = 0.01, rely = 0.55, anchor = "w")

LaFR_Date_4["width"] = 924

LaFR_Date_4["height"] = 90

LaFR12 = Tkinter.LabelFrame(LaFR_Date_4)

LaFR12["text"] = u"Количество страниц"

LaFR12["font"] = all_font

LaFR12.place(relx = 0.01, rely = 0.5 , anchor = "w")

Ent12 = Tkinter.Entry(LaFR12)

Ent12["width"] = 32

#Ent12 ["bd"] = 6

Inform.append(Ent12)

Ent12.pack()

LaFR13 = Tkinter.LabelFrame(LaFR_Date_4)

LaFR13["text"] = u"Количество плакатов"

LaFR13["font"] = all_font

LaFR13.place(relx = 0.38, rely = 0.5 , anchor = "center")

Ent13 = Tkinter.Entry(LaFR13)

Ent13["width"] = 32

Inform.append(Ent13)

Ent13.pack()

LaFR14 = Tkinter.LabelFrame(LaFR_Date_4)

LaFR14["text"] = u"Количество рисунков"

LaFR14["font"] = all_font

LaFR14.place(relx = 0.52, rely = 0.5 , anchor = "w")

Ent14 = Tkinter.Entry(LaFR14)

Ent14["width"] = 32

Inform.append(Ent14)

Ent14.pack()

LaFR15 = Tkinter.LabelFrame(LaFR_Date_4)

LaFR15["text"] = u"Количество таблиц"

LaFR15["font"] = all_font

LaFR15.place(relx = 0.99, rely = 0.5 , anchor = "e")

Ent15 = Tkinter.Entry(LaFR15)

Ent15["width"] = 32

Inform.append(Ent15)

Ent15.pack()

#Создание полей ввода пути к файлам

LaFR_Date_5 = Tkinter.LabelFrame(self.FRC)

LaFR_Date_5["text"] = u"Опредиление путей к файлам"

LaFR_Date_5["font"] = all_font

LaFR_Date_5.place(relx = 0.01, rely = 0.63, anchor = "nw")

LaFR_Date_5["width"] = 924

LaFR_Date_5["height"] = 120

def path_pict(event = None):

M = u"Выберете папку с изображениями и нажмите ОК"

path2 = tkFileDialog.askdirectory(title=M)

path_label1 = Tkinter.Label(LaFR_Date_5)

path_label1.place(relx = 0.65, rely = 0.7, anchor = "center")

path_label1['borderwidth'] = 5

path_label1["font"] = all_font

path_label1["height"] = 2

path_label1["width"] = 40

path_label1['text'] = path2

self.path_pict = path2

def path_pdf():

P = u"Выберете файл с текстом"

path = tkFileDialog.askopenfilename(title=P)

path_label = Tkinter.Label(LaFR_Date_5)

path_label.place(relx = 0.65, rely = 0.25, anchor = "center")

#path_label["bg"] = "red"

path_label['borderwidth'] = 5

path_label["font"] = all_font

path_label["height"] = 2

path_label["width"] = 40

path_label['text'] = path

self.path_pdf = path

#Создание кнопок

But3 = Tkinter.Button(LaFR_Date_5)

But3["bg"] = "white"

But3["bd"] = "1m"

But3["width"] = 30

But3 ["font"] = all_font

But3["relief"] = "raised"

But3.place(relx = 0.2, rely = 0.25, anchor = "center")

But3["text"] = u"Путь к документу с текстом"

But3["command"] = path_pdf

But4 = Tkinter.Button(LaFR_Date_5)

But4["width"] = 30

But4["bg"] = "white"

But4["bd"] = "1m"

But4 ["font"] = all_font

But4["relief"] = "raised"

But4.place(relx = 0.2, rely = 0.7, anchor = "center")

But4["text"] = u"Путь к изображениям"

But4["command"] = path_pict

But1 = Tkinter.Button(self.FRC)

But1["bg"] = "white"

But1["bd"] = "1m"

But1 ["font"] = all_font

But1["relief"] = "raised"

But1.place(relx = 0.25, rely = 0.85, anchor = "center")

But1["text"] = u"Отмена"

But1.bind("<Button-1>",otmena)

But2 = Tkinter.Button(self.FRC)

But2["bg"] = "white"

But2 ["font"] = all_font

But2["bd"] = "1m"

But2["relief"] = "raised"

But2.place(relx = 0.75, rely = 0.85, anchor = "center")

But2["text"] = u"Сохранить"

But2.bind("<Button-1>", Seve_inform)

def __delattr__ (self, a):

self.FRC.destroy()

#print u"ok))))))))))))))))))"

if __name__ == "__main__":

root = Tkinter.Tk()

root.geometry("1024x768+0+0")

all_font = tkFont.Font()

all_font ["family"] = "Helvetica"

all_font ["size"] = 14

all_font ["weight"] = "normal"

new_data(root,all_font)

root.mainloop()

Find_Data.py

# -*- coding: cp1251 -*-

import Tkinter

import ScrolledText

import tkFont

import os

import string

import pickle

import tkFileDialog

import Image

import ImageTk

import preview_find

#окно "D" - поиск данных

class find_data:

def __init__(self, root, all_font):

self(root, all_font)

def __call__(self, root, all_font):

self.FRD = Tkinter.Frame(root)

self.FRD["width"] = 1024

self.FRD["height"] = 768

self.FRD.place(relx = 0, rely = 0, anchor = "nw" )

self.FRD.pack()

#************************************************************************************

def find_data (event = None):

self.baza_vsia_sort = []

self.baza_vsia = []

self.u = ['C:\\TM_Base\\Bakalavr\\',"C:\\TM_Base\\Spec\\",'C:\\TM_Base\\Magistr\\']

for m in self.u:

os.chdir(m)

self.p = m

#print self.baza_vsia_sort

#print self.dictonary_find.keys()

for w in self.dictonary_find.keys():

#print self.dictonary_find.get(w)

self.folders = []

self.baza_vsia_sort

if w == "1":

folders = os.listdir(m)

for i in folders:

if i[-4] != '.':

self.folders.append(i)

for i in self.folders:

self.path_2 = self.p + i

os.chdir(self.path_2)

base = open ("Base_stud.bso" , "rb")

self.k = pickle.load(base)

base.close()

poisk = self.dictonary_find.get(w)[0]

data = self.dictonary_find.get(w)[1]

data_sr = self.k.get(poisk)

#if data.decode("cp1251") == data_sr:

if data == data_sr:

self.baza_vsia.append(self.k)

#print self.baza_vsia

else:

#print len(self.baza_vsia)

#print "baza vsja"

#print self.baza_vsia

for i in range(0, len(self.baza_vsia)):

b = self.baza_vsia[i]

#print b

poisk = self.dictonary_find.get(w)[0]

data = self.dictonary_find.get(w)[1]

data_sr = b.get(poisk)

if data == data_sr:

self.baza_vsia_sort.append(b)

#print "2"

#print self.baza_vsia_sort

self.baza_vsia = []

#print self.baza_vsia

#print self.baza_vsia_sort

def find_data_tabl(event = None):

self.dictonary_find.keys()

self.Frame_Listbox.destroy()

sroot_widget_create()

self.kol = 0

self.vibor = self.kol

self.Label_02 ["text"] = u"ФИО"

self.Label_03 ["text"] = u"Год защиты"

for i in self.baza_vsia:

self.base_for_prosmotr = []

print "2"

self.kol = self.kol + 1

m = i

key_1 = m.get("SName_S")

key_2 = m.get("Name_S")

key_3 = m.get("LName_S")

text_list_02 = key_1 + " " + key_2 + " " + key_3

text_list_03 = m.get("God_1")

self.Listbox_01.insert("end", self.kol)

self.Listbox_02.insert("end", text_list_02)

self.Listbox_03.insert("end", text_list_03)

self.base_for_prosmotr = self.baza_vsia

if len(self.baza_vsia_sort[0]) > 0:

self.base_for_prosmotr = self.baza_vsia_sort

for i in self.baza_vsia_sort:

print u"второй отбор"

self.kol = self.kol + 1

m = i

key_1 = m.get("SName_S")

key_2 = m.get("Name_S")

key_3 = m.get("LName_S")

text_list_02 = key_1 + " " + key_2 + " " + key_3

text_list_03 = m.get("God_1")

self.Listbox_01.insert("end", self.kol)

self.Listbox_02.insert("end", text_list_02)

self.Listbox_03.insert("end", text_list_03)

else:

print u"параметр поиска только один"

def die (event = None):

print self.baza_vsia_sort

print self.baza_vsia

self.FRD.destroy()

self.kol = 0

self.dictonary_find = {}

param_for_poisk = []

def DOBAVIT (event = None):

self.kol = self.kol + 1

self.vibor = self.kol

try:

text_list_03 = self.Znachenie_data.get()

except:

text_list_03 = self.Znachenie_data

self.Listbox_01.insert("end", self.kol)

self.Listbox_02.insert("end", self.vibor_data)

self.Listbox_03.insert("end", text_list_03)

param_for_poisk = []

param_for_poisk.append(self.parametp_poiska)

param_for_poisk.append(text_list_03)

studfiles.net

Реферат Питоны

Реферат на тему:

План:

Введение
• 1 Описание
  • 1.1 Внешний вид и особенности строения
  • 1.2 Распространение
  • 1.3 Образ жизни
  • 1.4 Питание
  • 1.5 Размножение
• 2 Значение для человека
• 3 Охранный статус
ПримечанияЛитература

Введение

Пито́ны (лат. Pythoninae) — подсемейство ложноногих змей, иногда выделяемое в отдельное семейство Pythonidae. В настоящее время насчитывается 8 родов и 26 видов. В более узком смысле питоны — представители рода Python.

1. Описание

1.1. Внешний вид и особенности строения

Размеры питонов колеблются от 0,5 до 10 м (сетчатый питон).

Окраска очень разнообразная: от более или менее одноцветной (бурого или буро-коричневого тонов) до довольно пёстрой — пятнистой, древесные виды (зёленый питон) могут быть зелёного цвета.

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

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

1.2. Распространение

Распространены в Восточном полушарии: в Африке к югу от Сахары, в Азии, Австралии.

1.3. Образ жизни

Обитают преимущественно в тропических лесах, саваннах, болотистых местностях; меньшее число видов живёт в пустынях. Часто питоны селятся вблизи воды; хорошо плавают и ныряют. Многие виды лазают по деревьям; существуют и почти полностью древесные виды. Активны в основном в сумерках и ночью.

1.4. Питание

Питаются главным образом млекопитающими (крупные питоны заглатывают шакалов, молодых леопардов, дикобразов, молодых кабанов и т. д.), а также птицами, крупными ящерицами; молодые питоны поедают мелких грызунов, ящериц, реже — лягушек. Добычу ловят, хватая её зубами и одновременно сжимая кольцами своего тела. Добыча заглатывается целиком, чему способствует строение челюстного аппарата змей. Питоны способны заглатывать очень крупную добычу, а затем переваривают её в течение довольно длительного времени, но могут подолгу (до 1,5 лет) обходиться без пищи.

1.5. Размножение

Самки питонов, как правило, крупнее и мощнее самцов. Во время спаривания самец трётся телом о самку и царапает её анальными шпорами.

Все питоны яйцекладущи, что отличает их от удавов, которые являются яйцеживородящими змеями. Отличительным свойством питонов является способность насиживать кладку яиц, причём за счёт сокращения мышц тела температура кладки на 12—15°С выше температуры окружающей среды.

2. Значение для человека

Morelia viridis

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

Известны случаи нападения питонов на человека.

Питоны часто содержатся в неволе: в зоопарках и любителями животных. Отдельные виды этих змей являются очень популярными террариумными животными и хорошо размножаются. В неволе живут до 20-25 лет и более[1].

3. Охранный статус

Некоторые виды питонов ранее интенсивно истреблялись ради кожи и мяса, численность других сократилась в результате разрушения местообитаний из-за хозяйственной деятельности человека. Часть видов включена в Приложения I и II Конвенции о международной торговле CITES или в Красную книгу МСОП.

Примечания

1. Search the AnAge Database - genomics.senescence.info/species/query.php?search=python

Литература

• Даревский И. С., Орлов Н. Л. Редкие и исчезающие животные. Земноводные и пресмыкающиеся: Справ. пособие. — М.: Высш. шк., 1988. — С. 310—325.
• Наумов Н.П., Карташев Н.Н. Зоология позвоночных. Часть 2. Пресмыкающиеся, птицы, млекопитающие. — М.: Высшая школа, 1979. — С. 272.
• Жизнь животных в 7-ми т. / Гл. редактор В. Е. Соколов. Т. 5. Земноводные и пресмыкающиеся. / А. Г. Банников, И. С. Даревский, М. Н. Денисова и др.; под ред. А. Г. Банникова — 2-е изд., перераб. — М.: Просвещение, 1985. - С. 268—272.

wreferat.baza-referat.ru

Случайные заметки: Доклад по Python: часть II

Питон - это объектно-ориентированный язык. Среди всего прочего, это означает: всё есть объект.В C++, на примере которого (к сожалению) обычно обучают объектно-ориентированному программированию, объектами являются только экземпляры классов. Числа, например, объектами не являются.В Java значения атомарных типов тоже являются объектами, но несколько искуственно: для них создаются так называемые boxed значения, то есть для каждого (например) числа создается экземпляр спецциального класса, содержащий это число.В Питоне же всё является объектом. Например: экземпляры классов, собственно классы, типы, атомарные объекты (числа и строки), а также функци. Пример с числом:

>>> a = 1>>> a.__str__() # этот метод дает строковое представление объекта'1'

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

Рассмотрим помаленьку все традиционные принципы ООП.

4. Инкапсуляция.

Инкапсуляция подразумевает: алгоритмы работы с данными хранятся вместе с данными. Для атомарных значений мы это уже видели в предыдущем разделе (a.__str__()). Для экземпляров пользовательских классов это реализуется образом, очень похожим на C++ или Java:

def move(self,x,y):self.x = xself.y = y

a = A()a.move(2,3)

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

Главное в инкапсуляции, как мы увидим позже - не надо путать инкапсуляцию и сокрытие данных.

5. Наследование.

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

class B(A):y = 1

Возможно и множественное наследование: class A(B,C,D):...

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

Эта проблема решается различными способами. В С++ для этого используется множественное наследование. В Java - интерфейсы. В Ruby - mix-ins (примеси).

В Питоне используется концепция, называемая Duck Typing: «Если ЭТО ходит, как утка, и крякает, как утка - значит, это утка». То есть, если у объекта есть все нужные функции свойства и методы, то он подходит в качестве аргумента. Например, в функцию

можно передавать объект любого типа, лишь бы у него был метод get_value().

Еще одна типичная проблема, возникающая в связи с множественным наследованием - не всегда очевидно, в каком порядке будут просматриваться родительские классы в поисках нужного свойства или метода. В Питоне для упрощения этой проблемы у каждого класса есть свойство __mro__ (method resolution order):

>>> class A(object): pass...>>> class B(object):... x = 0...>>> class C(A,B):... z = 3...>>> C.__mro__(<class 'C'>, <class 'A'>, <class 'B'>, <type 'object'>)

6. Полиморфизм.

Полиморфизм - это способность функции работать с аргументами разных типов.В C++ и Java полиморфизм тесно связан с наследованием. Например, в C++, если объявлено, что функция f принимает экземпляр класса A, то она может принимать экземпляр любого класса, унаследованного от A. В Java это поведение расширено: за счет интерфейсов (interfaces) есть возможность передавать в функцию экземпляры классов, не связанных "генетически" (но реализующих один интерфейс).

В Питоне полиморфизм реализован за счет Duck Typing: любая функция может принимать объекты любого типа, но если она попытается использовать свойства, которых у данного объекта нет, возникнет исключение (exception) (функция может перехватить его в конструкции try...except и сделать в этом случае что-то другое). За счет этого, например, функция, работающая с файлами, может принимать в качестве аргумента имя файла или дескриптор открытого файла - и действовать по обстоятельствам.

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

7. Интроспекция.

Про этот принцип регулярно забывают, когда рассказывают об ООП на примере С++, а между тем это один из основополагающих принципов.

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

У каждого объекта есть некоторое количество атрибутов. Атрибуты, имена которых, начинаются с подчеркивания, считаются приватными (private), хотя это и не влияет на область видимости - это только соглашение. "Более приватными" являются атрибуты, имена которых начинаются с двух подчеркиваний - снаружи они винды только как __имя-объекта__имя-атрибута__. Атрибуты, начинающиеся с двух подчеркиваний и заканчивающиеся двумя подчеркиваниями, имеют специальный смысл.

Список всех атрибутов любого объекта можно получить с помощью встроенной функции dir:

>>> a = 1>>> dir(a)['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__str__', '__sub__', '__truediv__', '__xor__']

Объект, имеющий атрибут __call__, можно вызывать как функцию (собственно, функции в Питоне отличаются от остальных объектов только наличием этого атрибута). Для проверки, можно ли использовать объект как функцию, используется стандартная функция callable(f). Таким образом, методы объекта - это атрибуты, которые можно вызывать.

У функций и классов есть атрибут __doc__, содержащий так называемый docstring - строку документации. При описании функции она пишется на отдельной строке после def, при описании класса - после class. Стандартная функция help() выдает информацию о любом объекте.

Атрибут __name__ любого объекта содержит его имя. У экземпляров классов атрибут __class__ содержит ссылку на класс этого объекта.

Стандартная функция type() возвращает тип объекта (тип - это тоже объект).

С помощью функции isinstance(obj,cls) можно выяснить, является ли объект экземпляром данного класса (или одного из дочерних классов). А функция issubclass(cls1,cls2) выясняет, является ли cls1 потомком cls2.

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

8. Динамизм.

Этот принцип не был сформулирован как один из основных для ООП, однако референсная реализация ООП - Smalltalk - этим свойством обладает.

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

>>> class A(object):... pass

>>> a = A()>>> a.x = 25 # создаем новый атрибут объекта>>> b = A() # другой экземпляр того же класса>>> print b.x # вызовет исключение: у объекта b нет атрибута x>>> b.y = 30 # создаем другой атрибут>>> dir(a)['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', 'x']>>> dir(b)['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', 'y']

Можно создавать "на ходу" даже методы класса:

>>> A.method = lambda self,s: "" % (s,self.x)>>> c = A()>>> c.x = 25>>> c.method("Text")'<Text 25>'

iportnov.blogspot.ru

Доклад к проекту "Электронный учебник по языку программирования Python"

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

Питон создал в 1991 году голандец Гвидо Ван Россум и назвал так в честь комедийного сериала.

Следует отметить следующие особенности этого языка:

1. Во-первых – ясный синтаксис. В других языках для указания программного блока (например , цикла или функции) используют больше специальных символов или ключевых слов, поэтому код получается более громоздким. В Питоне же их меньше. Зато очень важны отступы: они то и выполняют роль, скажем так, "указателя" на тот или иной программный блок. В результате программный код, написанный на языке Питон, получается более компактным и легко читаемым. Эту особенность можно увидеть, если сравнить цикл while на Паскале и Питоне: [слайд] в последнем случае код получается более компактный, однако наличие отступов в теле цикла является обязательным.
2. Python – это универсальный язык высокого уровня, поддерживающий большинство стилей программирования: структурное, объектно-ориентированное, функциональное программирование и другие.
3. Следующей особенностью Python можно отметить его модульность: он имеет большое количество модулей расширения практически по всем отраслям: средства обработки текстов и изображений, технологии Интернет, механизмы доступа к базам данных, пакеты для научных вычислений и т.п.
4. Также Питон имеет варианты под все самые распространенные операционные системы. И программы написанные в одной операционной системе, будут работать в другой, если установлен интерпретатор Питона.
5. Интерпретатор распространяется свободно на основании лицензии подобной GNU General Public Licence, под которой распространяется большинство свободного программного обеспечения.

Официальный сайт Питона – http://python.org/. Есть несколько русскоязычных ресурсов по Python`у: самый большой из них http://python.ru/. Помимо прочего, там собрана вся русскоязычная документация. Однако ее не так уж и много, а та что есть больше подходит для профессиональных программистов. Поэтому мы решили создать небольшой электронный учебник для начинающих программистов. Кстати, Питон может быть хорош для начинающих из-за своего легкого синтаксиса.

Содержание учебника в основном формировалось нами на переработке двух книг: Чаплыгин А. Н. Учимся программировать вместе с Питоном и Россум, Г. и др. Язык программирования Python.

Содержание учебника формировалось из основных понятий, характерных для большинства языков программирования. Например, таких как типы данных, условия, циклы, функции. А также из специфических для самого Питона. Например, модули, последовательности и словари, а также некоторые возможные области применения Питона. Во втором варианте учебника мы также сделали раздел посвящённый основным парадигмам программирования (структурному, функциональному и объектно-ориентированному).[демонстрация второго варианта учебника]

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

В учебнике есть меню из кнопок, текстовые поля с полосами прокрутки для текста и примеров программ, а также так называемый холст для рисунков. Холст – это экземпляр объекта canvas. Изображения на нем (например, линии, прямоугольники) были получены с помощью соответствующих методов. Существует два варианта учебника: в одном – графика и примеры программ располагаются во внешних виджетах по отношению к основному тексту [демонстрация первого варианта учебника]; в другом – внутри [демонстрация второго варианта учебника]. Tkinter содержит методы позволяющие одни текстовые поля и холсты вставлять в другие.

Конструирование графического интерфейса в Питоне является невизуальным, поэтому используются так называемые менеджеры расположения. В Tkinter есть три менеджера расположения: pack (простой упаковщик), place (произвольное расположение) и grid (сетка). В учебнике были использованы методы pack и place. [слайд]

[Перезагрузка системы]Учебник работает как в операционной системе Windows, так и Linux. Однако в любой системе должны быть заранее установленны интерпретатор Питона и модуль Tkinter. Для того, чтобы открыть учебник в Windows достаточно два раза кликнуть файл, а в Linux его можно открыть из консоли передав команде python в качестве параметра имя файла.

Как вы можете заметить, в Linux учебник выгладит немного по-другому. Это связано с тем, что здесь в системе присутствуют другие шрифты; и большинства шрифтов, которые есть в Windows, нет. Это единственная проблема, с которой мы столкнулись при переносе учебника из одной операционной системы в другую, однако она достаточно существенная. К тому же, мы проверяли учебник в разных дистрибутивах Линукс и везде он выглядел по своему. На данный момент проблема решается, можно сказать, механически – просто открывается исходный код изменяются параметры связанные со шрифтами. Хотя это сделать и достаточно просто, мы пришли к выводу, что лучше сделать отдельные функции, содержащие метоты для форматирования текста в той или иной операционной системе, а пользователю просто позволить выбирать ту или иную схему в зависимости от системы.

Применение PythonПервое, что можно рассмотреть, как возможную область применения Питона – это построение таблиц значений функций.

Большинство учебников по математике имеют приложения с таблицами значений различных функций. Раньше такие таблицы создавались вручную. Сейчас это делают с помощью компьютера. С помощью Питона можно быстро запрограммировать создание таких таблиц: достаточно использовать лишь цикл и символ табуляции (отступа).[пример таблицы степеней двойки] Также можно построить двумерную таблицу, если использовать вложенный цикл. Для примера можно взять таблицу умножения. В принципе сюда можно подставить любую формулу.

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

Часто требуется проанализировать какой-то ряд значений и определить количество значений, попавших в определенный диапазон. [слайд]

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

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

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

[работа с программой] Начинаем с пустого словаря. Для каждой буквы в строке мы находим текущий счетчик и увеличиваем его на единицу. В конце словарь содержит пары: буквы и их частоты.

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

Презентация

younglinux.info

Смотрите также

• 
  Реферат атэс
• 
  Полонез реферат
• 
  Карбюратор реферат
• 
  Реферат кулибин
• 
  Гофман реферат
• 
  Автоклав реферат
• 
  Реферат мегалиты
• 
  Тополь реферат
• 
  Реферат тополь
• 
  Реферат пекин
• 
  Реферат карбюратор