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

Инструменты сайта


python_konspekt

Содержание

Конспект книги Майк Доусен "Программируем на Python"

Строковые методы

МетодОписание
uрреr() Возвращает строку, символы которой приведены к верхнему регистру
lower() Возвращает строку, символы которой приведены к нижнему регистру
swapcase()Возвращает новую строку, в которой регистр всех символов обращен: верхний становится нижним и наоборот
capitalize()Возвращает новую строку, в которой первая буква прописная, а остальные - строчные
title()Возвращает новую строку, в которой первая буква каждого слова прописная, а остальные - строчные
strip() Возвращает строку, из которой убраны все интервалы (табуляция, пробелы, символы пустых строк) в начале и конце
rерlасе( old, Возвращает строку, в которой вхождения строки old замещаются строкой new.new [,max]) Необязательный параметр max устанавливает наибольшее возможное количество замен

Некоторые функции, выполняющие преобразования типов

Функция Описание ПримерРезультат
float(x) Преобразует значение х в десятичную дробь float(«10.0») 10.0
int(x) Преобразует значение х в целое число int(«10»} 10
str(x) Преобразует значение х в строку str(10) '10'

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

ОператорОбразецРавносильная запись
*= х *= 5 x=x*S
/= х /= 5 х = х/ 5
%= х%= 5 х = х% 5
+= х += 5x=x+S
-= х-= 5 х=х-5

Строка:
print(word[start:finish])

Кортеж

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

*если в кортеж добавляется одно значение, то после значения ставится ,

Действия с кортежами:

Создание кортежа:

inventory = ()
 
inventory = ("меч",
	"кольчуга",
	"щит" ,
	"целебное снадобье")

Перебор элементов кортежа последовательно:

for item in inventory:
    print (item)

Кортеж как условие:

if not inventory:
	print ( "Вы безоружны.")

Вывод элементов кортежа на экран:

print (inventory)	

Применение функции len() к кортежам:

len(inventory)

Применение оператора in к кортежам(проверка вхождения):

if "целебное снадобье" in inventory:
	print ("Вы еще поживете и повоюете.")	

Срезы кортежей:

inventory[1:3]

Сцепление кортежей:

chest = ("золото". "драгоценные камни")
inventory += chest

Распаковка кортежа:

a,b,c,d = inventory

Списки.

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

  1. Списки можно умножать на число!!!
  2. Списки измеряемы

Создание списка.

inventory = [«меч». «кольчуга». «щит». «целебное снадобье»]

Перебор элементов списка последовательно:

for item in inventory:
	print (item)

Применение функции len() к спискам:

len(inventory)	

Применение оператора in к спискам:

if "целебное снадобье" in inventory:
	print("Bы еще поживете и повоюете.")	

Индексация списков:

inventory[index]

Срезы списков:

start = int(input("\nBвeдитe начальный индекс среза: "))
finish = int(input("Bвeдитe конечный индекс среза: "))
print("Cpeз inventory[", start. ":". finish. "] - это", end=" ")
print(inventory[start:finish])

Сцепление списков:

chest = ["золото", "драгоценные камни"]
inventory += chest

Присвоение нового значения элементу, выбранному по индексу

inventory[0] = "арбалет"

Присвоение новых значений срезу списка:

inventory[4:6] = ["магический кристалл"]

Удаление элемента списка:

del inventory[2]

Удаление среза списка:

del i nventory[: 2]

Добавление элемента:

inventory+=	["меч"]

Вложенные последовательности. Последовательности, которые содержат внутри другие последовательности.

Создание вложенных последовательностей:

scores = [("Маша" , 1000), ("Вася", 1500), ("Петя", 3000)]

Доступ к вложенным элементам:

	>>> print(scores[l])
	('Вася'. 1500)
 
	>>> a_score = scores[2]
	>>> print(a score)
	('Петя'. 3000)
	>>> print(a_score[0])
	Петя
 
 
 
	>>> print(scores[2][0])
	Петя

Распаковка последовательности:

<code python>
>>> name, score =("Иван Иванович", 175)
>>> print(name)
Иван Иванович
>>> print(score)
175
</code>

Избранные списочные методы

Метод Описание
аppend(значение)Добавляет значение в конец списка
sort() Сортирует элементы по возрастанию. Необязательный параметр reverse принимает логическое значение. Если передать ему True, список будет отсортирован по убыванию
reverse()Обращает порядок элементов списка
соunt(значение)Сообщает, сколько раз данное значение входит в список
index(значение)Возвращает номер первой из позиций списка, которые заполнены данным значением
insert(i, значение) Вставляет значение в позицию номер i
pop([i])Возвращает значение в позиции номер i и удаляет этот элемент из списка. Указывать число i не обязательно. Если этот аргумент не передан, возвращается и удаляется последний элемент списка
remоve(значение)Удаляет первое вхождение данного значения в список
extand(значения)Расширить список

Кортежи и списки

Можно преобразовывать друг в друга.

tuple()#list -> tuple\\
list() #tuple -> list\\


Словари.

Словари. Набор пар «ключ» - «значение», по ключу можно получить значение, но не на оборот.

Создание словарей.

geek = {"404": "Не знать. не владеть информацией. От сообщения об ошибке 404 'Страница не найдена'.",

«Googling»: «'Гугление·. nоиск в Сети сведений о ком-либо.», «Keyboard Plaque» : «Мусор. который скапливается в клавиатуре компьютера.», «Link Rot» : «Процесс устаревания гиперссылок на веб-страницах . » , «Percussive Maintenance» : «О ситуации. когда кто-либо бьет по корпусу неисправного электронного прибора в надежде восстановить его работу.», «Uninstalled» : «Об увольнении кого-либо. Особенно популярно на рубеже 1990-2000-х годов . »}

Доступ к значению по ключу

term = input("Какой термин вы хотите перевести на русский? ")
      if term in geek:
          definition = geek[term]

Проверка существования ключа с помощью оператора in

if term in geek

Доступ к значениям с помощью метода get()

>>>printCgeek.getC"Dancing Baloney", "Понятия не имею."))
Понятия не имею.
"Понятия не имею." является значением по умолчанию, если ключ не найден.

Добавление пары «ключ - значение»

term = input("Kaкoй термин гикского языка вы хотите добавить? ")
if term not in geek:
	definition = inрut("\nВпишите ваше толкование: ")
	geek[term] = definition
	print("\nTepмин". term. "добавлен в словарь.")
	
	

Замена пары "ключ-значение":

term = input("Kaкoй термин вы хотите переопределить? ")
	if term in geek:
		definition = inрut("Впишите ваше толкование: ")
		geek[term] = definition		

Удаление пары "ключ-значение":

term = input("Kaкoй термин вы хотите удалить? ")
if term in geek:
	del geek[term]	
	

Избранные словарные методы

Метод skil - название словаряОписание
skil.get(ключ, [умолчание])Возвращает значение по ключу. Если ключ не определен в словаре, то возвращается умолчание. Если, в свою очередь, умолчание не задано, возвращается None
skil.keys()Возвращает набор всех ключей словаря
skil.values()Возвращает набор всех значений словаря
skil.items() Возвращает набор всех пар в словаре. Каждая пара представляет собой кортеж из двух элементов: первый - ключ, второй - соответствующее значение

Функции.

Объявление функции.

def instructioпs():	

Документирование функции.

"""Выводит на экран инструкцию для игрока."""	

Вызов нестандартной функции:

nstructions()

Передача данных с помощью параметров:

	def display(message):
		print (message)
	display("Вам сообщение.\n")

Возврат значения функциям:

def giv_me_five():
    five=5
    return five
 
giv_me_five() #возвратит 5

Функции, которые принимают и возвращают значения:

	def ask_yes_no(question):
		"""Задать вопрос с ответом ДА или НЕТ"""
		response=None
		while response not in ("y","n"):
			response=input(question).lower()
		return response

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

	def birthday1(name,age):
		print("С днем рождения,",name,"!","Вам сегодня",age)
 
	s1=input("Name ")
	s2=input("Vozrast ")
	birthday1(s1,s2)

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

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

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

def birthday1(name,age):
	print("С днем рождения,",name,"!","Вам сегодня",age)
 
birthdayl(age = 1, name = "товарищ Иванов")

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

Значения параметров по умолчанию.

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

def birthday2(name = "товарищ Иванов", age = 1):

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

Локальная переменная\константа находится внутри функции, и доступна только ей.
Глобальная переменная\константа объявлена вне функции и доступна всем.

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

def change_global():
	global value

Можно использовать, но менять нельзя:

def read_global():
	value += 1
import random
number_otgadai = None
number=int(random.randrange(100))
 
def ask_number(number_otgdai):
    if number_otgadai in range(100):
        if number_otgadai > number:
            print("Меньше...")
        elif number_otgadai < number:
            print ("Больше...")
        elif number_otgadai == number:
            print ("Это оно!!!")
    else:
        print("Данное число не входит в диапазон от 0 до 100")
 
def main():
    global number_otgadai
    while number_otgadai != number:
        number_otgadai = int(input("Ваше предположение: "))
        ask_number(number_otgadai)
main()
 
input("Нажмите Enter...")

Импорт.

from urllib2 import urlopen
from urllib2 import *
import urllib2.urlopen
if __name__ == "__main__":

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

from ulrlib2 import urlopen as uop	

Файлы и исключения:

Открытие и закрытие файла.

text_file = open("read_it.txt","r",encoding='utf-8')
text_file.close()

Режимы доступа к текстовым файлам

РежимОписание
«r»Чтение из текстового файла. Если файл не существует, Python сообщит об ошибке.
«w»Запись в текстовый файл. Если файл существует, его содержимое будет заменено. Если файл не существует, он будет создан.
«а»Дозапись в текстовый файл. Если файл существует, новые данные будут дописаны в конец. Если файл не существует, он будет создан.
«r+«Чтение и запись в текстовый файл. Если файл не существует, Python сообщит об ошибке.
«w+«Запись и чтение из текстового файла. Если файл существует, его содержимое будет заменено. Если файл не существует, он будет создан.
«а+«Дозапись и чтение из текстового файла. Если файл существует, новые данные будут дописаны в конец. Если файл не существует, он будет создан.

Чтение текстового файла.

text_file = open("read_it.txt","r")
print(text_file.read(5)) 

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

Посимвольное чтение строки.

text_file = open("read_it.txt","r")
print(text_file.readline(5))

Читает первые 5 символов 1-ой строки, если запустить еще раз, то будут читаться первые 5 символов 2-ой строки и т.д. Если количество символов не указано, то читается целиком строка.

Чтение всех строк файла в список.

text_file = open("read_it.txt","r")
lines = text_file.readlines() # получается список состоящий из строк
print(lines)
print (len(lines))
 
for line in lines:
	print (line)
text_file.close()

За чтение всех строк отвечает метод readlines()

Перебор строк файла

text_file = open("read_it.txt","r")
for line in text_file:
	print(line)
	

Запись строк в файл

	print ("Создадим текстовый файл методом writr().")
 
	text_file = open("write_it.txt","w",encoding='utf-8')
 
	text_file.write("Строка 1\n")
	text_file.write("Строка 2\n")
	text_file.write("Строка 3\n")
 
	text_file.close()
 
	print("\nЧитаю созданный файл: ")
 
	text_file = open("write_it.txt","r",encoding='utf-8')
 
	print (text_file.read())
 
	text_file.close()	

Запись списка строк в файл

	text_file = open("write_it.txt","w",encoding='utf-8')
	Используется метод writelines()
		lines = ["Строка 1\n",
         "Это строка 2\n",
         "Этой строке достался номер 3\n"]
 
		text_file.writelines(lines)

Методы работы с файлом

МетодОписание
close() Закрывает файл. закрытый файл недоступен для чтения и записи до тех пор, пока не будет открыт снова
read([число])Читает указанное количество символов из файла и возвращает их в виде строки. Если число не указано, метод возвратит все символы, начиная с текущей позиции и до конца файла.
readline([чиcлo]) Читает указанное количество символов из текущей строки файла и возвращает их в виде строки. Если число не указано, метод возвратит все символы,начиная с текущей позиции и до конца строки
readlines()Читает все строки файла и возвращает список, элементами которого они все являются
write(crpoкa)Записывает строку в файл
writellnes(список строк) записывает список сrрок текста в файл

Хранение структурированных данных в файлах.

Консервация данных и запись в файл.

pickle - модуль позволяющий консервировать структуры данных и сохранять их в файлах
shelve - модуль обеспечивающий произвольный доступ к законсервированным объектам.
 
import pickle, shelve
print ("Консервация списков.")
 
variety = ["огурцы","помидоры","капуста"]
shape = ["целые","кубиками","соломкой"]
brand = ["Главпродукт","Чумак","Бондюэль"]
 
f = open ("pikles.dat","wb")
 
pickle.dump(variety,f)
pickle.dump(shape,f)
pickle.dump(brand,f)
 
f.close()

Режимы доступа к бинарным файлам

Режим Описание
«rb» Чтение из бинарного файла. Если файл не существует, то Python сообщит об ошибке
«wb» запись в бинарный файл. Если файл существует, его содержимое будет заменено. Если файл не существует, он будет создан
«аb» До запись в бинарный файл. Если файл существует, новые данные будут дописаны в конец. Если файл не существует, он будет создан
«rb+« Чтение и запись в бинарный файл. Если файл не существует, то Python сообщит об ошибке
«wb+» запись и чтение из бинарного файла. Если файл существует, его содержимое будет заменено. Если файл не существует, то он будет создан
«аb+« До запись и чтение из бинарного файла. Если файл существует, новые данные будут дописаны в конец. Если файл не существует, он будет создан

Чтение и расконсервация данных из файла

print("\nРасконсервация списков.")
f = open("pikles.dat","rb")
variety = pickle.load(f)
shape = pickle.load(f)
brand = pickle.load(f)

Функции модуля pickle

Функция Описание
dump(объект,файл, [,bin]) Пишет законсервированную версию объекта в файл. Если параметр bin равен True, объект записывается в двоичном формате, а если False - в менее практичном, но более удобочитаемом текстовом формате. По умолчанию bin = False
load(файл) Расшифровывает очередной консервированный объект из файла и возвращает его.

Полка для хранения данных.

print ("\nПомещение списков на полку.")
 
s = shelve.open("pickles2.dat")
 
s["variety"] = ["огурцы","помидоры","капуста"]
s["shape"] = ["целые","кубиками","соломкой"]
s["brand"] = ["Главпродукт","Чумак","Бондюэль"]
 
s.sync()
s.close()

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

Извлечение консервированных данных через интерфейс полки.

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

s = shelve.open("pickles2.dat")
 
print ("\nИзвлечение списков из файла полки:")
print("торговые марки - ", s["brand"])
print ("формы - ", s["shape"])
print ("виды овощей - ",s["variety"])
 
s.close()

Режимы доступа к полке

Режим Описание
«с» Открытие файла на чтение или запись. Если файл не существует, он будет создан
«n»Создание нового файла для чтения или записи. Если файл существует, его содержимое будет заменено
«r»Чтение из файла. Если файл не существует, Python сообщит об ошибке
«w»Запись в файл. Если файл не существует, Python сообщит об ошибке

Применение конструкции try/except

try:
	num = float(input("Введите число: "))
except:
	print("Похоже это не число!")

Избранные типы исключений

Тип исключения Описание
IOError Генерируется, если невозможно выполнить операцию ввода/вывода, например, открыть на чтение несуществующий файл
IndexError Генерируется, если в последовательности не найден элемент с указанным индексом
КeyError Генерируется, если в словаре не найден указанный ключ
NameError Генерируется, если не найдено имя (например, имя функции или переменной)
SyntaxErrorГенерируется, если интерпретатор обнаруживает в коде синтаксическую ошибку
TypeError Генерируется, если стандартная операция или функция применяется к объекту неподходящего типа
ValueError Генерируется, если стандартная операция или функция принимает аргумент подходящего типа, но с неподходящим значением
ZeroDivisionErrorГенерируется, если в операции деления или нахождения остатка второй аргумент - ноль
try:
	num = float(input("Введите число: "))
except ValueError:
	print("Похоже это не число!")
	
	
Обработка нескольких типов исключений.
except (TypeError, ValueError):
	print("Пoxoжe. это не число!")
	
	либо
	
except TypeError:
	print("Я умею преобразовывать только строки и числа!")
except ValueError:
	print("Я умею преобразовывать только строки составленные из цифр!")	

Аргумент исключения это описывающий ошибку текст.

try:
	num = float(input("Введите число: "))
except ValueError as error:
	print ("Это не число!!!")
	print (error)

Введите число: e
Это не число!!!
could not convert string to float: 'e'

Блок else

После всех блоков с except в конструкции с оператором try можно добавить заключительный блок else. Он будет исполнен лишь в том случае, если блок try сработает безошибочно.

try:
	num = float(input("Введите число: "))
except ValueError as error:
	print ("Это не число!!!")
	print (error)
else:
	print("Вы ввели число",num)
	
Введите число: 3
Вы ввели число 3.0	

Викторина:

import sys,pickle
 
"""
Пример списка с вопросами:
#################################################################
If a host experiences intermittent issues that relate to congestion within a network while remaining connected, what could cause congestion on this LAN?
1. half-duplex operation
2. broadcast storms
3. network segmentation 
4. multicasting
2
10
Which layer of the TCP/IP stack combines the OSI model physical and data link layers?
1. Internet layer
2. transport layer
3. application layer
4. network access layer
4
10
Which layer of the OSI model controls the reliability of communications between network devices using flow control, sequencing and acknowledgments?
1. Physical
2. Data-link
3. Transport
4. Network
3
10
################################################################
"""
def open_file(file_name,mode):
    """Open file"""
    try:
        file = open(file_name,mode)
    except IOError as error: #если возникает ошибка(файл не найден), завершение работы
        print("Can not open file! Error:",error)
        print("Program whas shutdown!!!")
        input("Press ENTER...")
        sys.exit()
    else:
        print("\t\tФайл открыт....\n \t\tНачинаем тест!!!\n")
        return file
 
 
def extract_questions(file_name):
    """Извлечение вопросов из файла"""
    pool=[]
    for i in range(7): #Добавляем первые 7 строк в список
        pool.append(file_name.readline())
 
    return pool
 
def welcome(name):
    """Приветствие"""
    print("\tДобро пожаловать,",name,". Тебе необходимо ответить на предложеные",\
          "\n\tвопросы. Для выбора ответа необходимо нажать цифру и нажать ENTER.\n")
    input("Если готов, нажмите ENTER...\n")
 
def begin():
 
    file=open_file("questions.txt","r")
    #pool=[1]
    point=0
    number_question=1
    name = input("Введите ваше имя: ")
    while not name: #Пока не введено имя, мучаем игрока
        name = input("Введите ваше имя: ")
 
    print("")
    welcome(name)
    while number_question!=4: #4 число вопросов в тесте
 
        pool=extract_questions(file)
        question=(pool[0]) #Вопрос
        print(pool[0])
 
        for i in range(4):#4 Варианта ответа
            i+=1
            print(pool[i])
 
        answer_r=int(pool[5]) #Правильный ответ
        try:
            answer=int(input("Ваш ответ: ")) #Ответ даваемый игроком
        except:
            print("Ваш ответ не засчитан!!! Следующий вопрос!!!\n") # Если игрок пишет чушь его ответ не засчитывается
        else:    
            while answer not in [1,2,3,4]: # Пока не будет введена цифра из списка
                answer=int(input("Ваш ответ: "))
 
            if answer == answer_r:
                point+=int(pool[6]) # Если ответ правильный игроку прибовляется очков
                print("\n\tВы правильно ответили. Сумма полученых баллов",point)
                input("\tНажмите Enter, чтоб продолжить...\n\n")
            else:
                print("\n\tВы не правы! Правильный ответ:",answer_r )
                input("\tНажмите Enter, чтоб продолжить...\n\n")
        number_question+=1 #Счетчик вопросов
    return point, name # Возвращает количество очков и имя
 
def reco(point, name):
    """Записывает результат"""
    try: # Пробует открыть файл с рекордами
        file_record=open ("record.dat","rb")
        file_record.close()
    except:#Если его нет создает новый с пустым списком
        file_record=open ("record.dat","wb")
        rec=[]
        pickle.dump(rec,file_record)
        file_record.close()
 
        #Извлекает список рекордов
    file_record=open("record.dat","rb")
    rec=pickle.load(file_record)
    file_record.close()
 
        #Добавляет к списку новые значения
    record=(point,name)
    file_record=open ("record.dat","wb")
    rec.append(record)
    pickle.dump(rec,file_record)
    file_record.close()
 
def main():
    "Главная функция"
    print()    
    point, name = begin() # Получаем значени очков и имени из функции begin()
    print(name,",ваше количество балов:",point)
    record = input("\nВы хотите добавить свой результат в таблицу рекордов(y/n)? ") # Нужно ли записать результат в таблицу с рекордами
 
    while record not in ("y","n"): # Пока ответ не y или n мучаем пользователя
        record = input("Вы хотите добавить свой результат в таблицу рекордов(y/n)? ")
 
    if record == "y":
        reco(point,name) # Если y, передаем значение функции reco()
 
    file_rec=open("record.dat","rb") # Открываем файл с рекордами
    rec=pickle.load(file_rec) #Загружаем список rec 
    rec.sort(reverse=True) # Сортируем его по убыванию по очкам
    print("\n\tТаблица рекордов: \n")
    print("\tИгрок\t\tРезультат")
    for i in range(len(rec)): # Для i  в диапазоне длины списка rec
        score,player=rec[i] # Извлекаем занчеия баллов и имени игрока из кортежа входящего в список 
        print("\t",player,"\t\t",score)
 
    file_rec.close()    
 
    input("\n\nНажмите Enter, чтобы выйти...")
 
main()

Програмные объекты:

Основы объектно ориентированного подхода.

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

Пр. Класс банковских счетов, на основе его создается 2 счета с атрибутом баланс, но у одного баланс 10, а у другого 100.

Создание классов, методов и объектов.

class Critter(object): #Заголовок класса созданый на основе фундаментального встроеного типа object
  """ Виртуальный питомец """ # Документирующая строка
  def talk(self): # В составе класса объявляется метод, по своей структуре надпоминающий функцию, у всех методов должен быть специальный первый параметр self
      print("Я зверушка - экземпляр класса Critter.")
crit = Critter() # инстацируем его (создаем объект-экземпляр класса Critter и делаем его значением переменной crit)
сrit.talk() #Вызов метода talk()
input("\n\nНажмите Enter, чтобы выйти...")

Применение конструктора.

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

#Зверушка с конструктором

class Critter(object):

  """Виртуальный питомец"""
  def __init__(self): # метод - конструктор(метод инициализации) вызываемый при инициализации, вызывается при возникновении объекта.
      print("Появилась на свет новая зверушка!!!")
  def talk(self):
      print("\nПривет. Я зверушка экземпляра класса Critter.")

# Появляются 2 объекта, при их инициализации метод конструктор сообщает «Появилась на свет новая зверушка!!!» crit1=Critter() crit2=Critter() crit1.talk() crit2.talk() input(«Нажмите Enter…»)

»> Появилась на свет новая зверушка!!! Появилась на свет новая зверушка!!!

Привет. Я зверушка экземпляра класса Critter.

Привет. Я зверушка экземпляра класса Critter. Нажмите Enter…

Применение атрибутов.

# Зверушка с атрибутами.

class Critter(object):

  """Виртуальный питомец"""
  def __init__(self,name):
      print("Появилась на свет новая зверушка!")
      self.name = name #создает у нового объекта атрибут name, значение которого равно значению параметра name
  def __str__(self):
      rep = "Объект класса Critter\n"
      rep+= "имя: " + self.name + "\n"
      return rep
  def talk(self):
      print ("Привет. Меня зовут " + self.name + "\n")

crit1=Critter(«Бобрик») #Инициализация атрибутов. Создает новый объект класса Critter, у которого атрибут name равен Бобрик, связывается с переменной crit1. crit1.talk() # Доступ к атрибутам. Чтоб зверушка сообщила о себе, нужно вызвать метод talk(), через параметр self, это метод автоматически получает ссылку на объект. Затем функция print выводит на экран сообщение, для этого с помощю self.name выполняется доступ к атрибуту name нашего объекта. crit2=Critter(«Чубака») crit2.talk()

print («Вывод объекта crit на экран: ») print (crit1) print («Непосредственный доступ к атрибуту crit1.name: ») print (crit1.name)

input(«\n\nНажмите Enter…»)

»> Появилась на свет новая зверушка! Привет. Меня зовут Бобрик

Появилась на свет новая зверушка! Привет. Меня зовут Чубака

Вывод объекта crit на экран: Объект класса Critter имя: Бобрик

Непосредственный доступ к атрибуту crit1.name: Бобрик

Нажмите Enter…

Вывод объекта на экран.

Если попробовать вывести на экран объект просто командой print(crit1), то получим <_main_.Critter object at ОхООАОВА90>,
Если в объекте класса будет реализован специальный метод __str__(), это позволит представить объект строками для вывода на экран. Если мы попросим интерпритатор напечатать нам объект, то на экран будет выводится строка, которую нам возвращает метод __str__().

Применение атрибутов класса и статических методов.

Атрибут класса - информация, кторая относится не к индивидуальным объектам, а ко всему классу.

# Классово верная зверушка.

# Демонстрирует атрибуты класса и статические методы.

class Critter(object):

  """Виртуальный питомец"""
  total = 0
  @staticmethod
  def status():
      print("\nВсего сейчас зверушек", Critter.total)
  def __init__(self,name):
      print("Появилась на свет новая зверушка!",name)
      self.name = name
      Critter.total+=1

#Основная часть

print(«Нахожу значение атрибута класса Critter.total:», end=» ») print(Critter.total) print(«\nСоздаю зверей: ») crit1=Critter(«Зверь №1») crit1=Critter(«Зверь №2») crit1=Critter(«Зверь №3») crit1=Critter(«Зверь №4») Critter.status() print(«\nНахожу значение атрибута класса Critter.total:», end=» ») print(Critter.total)

total = 0 создает атрибут total класса Critter и присваивает ему значение 0
print(Critter.total) осуществляет доступ к объекту total класса Critter
Critter.total+=1 в методе конструкторе увеличивается значение атрибута на 1

Создание статического метода(относящийся к классу целиком(лишен параметра self))
@staticmethod
def status():
      print("\nВсего сейчас зверушек", Critter.total)

@staticmethod декоратор, блогадаря ему метод оказывается статическим.

Вызов статического метода.
Critter.status()

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

Применение закрытых атрибутов и методов.

class Critter(object):

  def __init__(self,name,mood):
      print("Появилась на свет новая зверушка!")
      self.name = name #открытый атрибут
      self.__mood = mood #закрытый атрибут
    def talk(self):
      print("\nМеня зовут",self.name)
      print("\nСейчас я чувствую себя",self.__mood,"\n")
  def __private_method(self):
      print("Это закрытый метод")
  def public_method(self):
      print("Это открытый метод")
      self.__private_method()

crit=Critter(name=«Бобик», mood = «прекрасно») crit.talk() crit.public_method()

print(crit._Crittermood) self.mood = mood два символа подчеркивания заставляют интерпритатор рассматривать этот атрибут как закрытый.

Доступ к закрытым атрибутам.

def talk(self):
      print("\nМеня зовут",self.name)
      print("\nСейчас я чувствую себя",self.__mood,"\n")
	
Метод выводит на экран текст из закрытого атрибута.
Если попробовать получить доступ к атрибуту вне объявления класса Critter, возникла бы проблема.

crit=Critter(name="Бобик", mood = "прекрасно")
print(crit.mood)

print(crit.mood)
AttributeError: 'Critter' object has no attribute 'mood'

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

crit=Critter(name="Бобик", mood = "прекрасно")
print(crit._Critter__mood)
>>> 
Появилась на свет новая зверушка!
прекрасно

Соблюдаем приватность.
Метод __init()__ вызываемый автоматически при создании каждого такого объекта, оповещает пользователей о том,что на свет появилась зверушка.
Метод talk() рассказывает о самочувствии зверушки
Метод public_method() выводит на экран строку и вызывает закрытый метод этого же объекта.



Создание свойств.

class Critter(object):

"""Виртуальный питомец"""
  def __init__(self,name):
      print("Появилась на свет новая зверушка!")
      self.__name = name
      @property
      def name(self):
          return self.__name
		
Чтоб создать свойство, я пишу метод, который возвращает интересующее меня значение(__name), и предваряю объявление метода декоратором @property

Программа моя зверушка:

class Critter(object):

  """Виртуальный питомец"""
  def __init__(self,name,hunger = 0,boredom = 0):
      self.name = name
      self.hunger = hunger
      self.boredom = boredom
  def __pass_time(self):
      self.hunger+=1
      self.boredom+=1
  @property
  def mood(self):
      unhappends = self.hunger + self.boredom
      if unhappends < 5:
          m = "прекрасно"
      elif 5 <= unhappends <= 10:
          m = "неплохо"
      elif 11 <= unhappends <= 15:
          m = "не сказать чтобы хорошо"
      else:
          m = "ужасно"
      return m
  def talk(self):
      print("Меня зовут",self.name,", и сейчас я чувствую себя", self.mood,"\n")
      self.__pass_time()
      
  def eat(self, food = 4):
      print ( "Мррр... Спасибо! " )
      self.hunger -= food
      if self.hunger < 0:
          self. hunger = 0
      self.__pass_time()        
  def play(self,fun=4):
      print("Yиии!")
      self.boredom -= fun
      if self .boredom < 0:
          self.boredom = 0
      self.__pass_time()

def main():

  crit_name = input("Kaк вы назовете свою зверюшку? ")
  crit = Critter(crit_name)
  choice = None
  while choice != "0":
      print ( """
  Моя зверюшка
  0 - Выйти
  1 - Узнать о самочувствии зверюшки
  2 - Покормить зверюшку
  3 - Поиграть со зверюшкой
  """
                  )
          
      choice = input("Baш выбор: ")
      print()
      # ВЫХОД
      if choice == "0":
          print("Дo свидания.")
      # беседа со зверюшкой
      elif choice == "1":
          crit.talk()
      # кормление зверюшки
      elif choice == "2":
          crit.eat()
      # игра со зверюшкой
      elif choice == "3" :
          crit.play()
      # непонятный пользовательский ввод
      else:
          print( "Извините. в меню нет пункта", choice)

main()

Объектно-ориентированое программирование.

Взаимодействие объектов.

class Player(object):

  """Игрок"""
  def blast(self,enemy):
      print ("Игрок среляет в врага: Пиу-пиу")
      enemy.die()

class Alien(object):

  def die(self):
      print("Тяжело дыша, пришелец произносит: \"Ну вот и все, прощай безжалостный мир...\"")

print(«\t\tГибель пришельца.\n») hero = Player() invader = Alien() hero.blast(invader) input («\nНажмте Enter…»)

Командой hero.blast(invader) вызывается метод blast() объекта hero, и передается ему как аргумент объект invader

Создание новых классов с помощю наследования.

class Card(object):

  """Одна игральная карта"""
  RANKS = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
  SUITS = ["c","d","h","s"]
  def __init__(self,rank,suit):
      self.rank = rank
      self.suit = suit
  def __str__(self):
      rep = self.rank + self.suit
      return rep

class Hand(object):

  """Рука: набор карт на руках у одного игрока."""
  def __init__(self):
      self.cards = []
  def __str__(self):
      if self.cards:
          rep = ""
          for card in self.cards:
              rep += str(card) + "\t"
      else:
          rep = "<пусто>"
      return rep
  def clear(self):
      self.cards = []
  def add(self,card):
      self.cards.append(card)
  def give(self,card,other_hand):
      self.cards.remove(card)
      other_hand.add(card)

class Deck(Hand):

  """Колода игральных карт"""
  def populate(self):
      self.cards = []
      for suit in Card.SUITS:
          for rank in Card.RANKS:
              self.add(Card(rank, suit))
  def shuffle(self):
      import random
      random.shuffle(self.cards)
  def deal(self,hands,per_hand=1):
      for rounds in range(per_hand):
          for hand in hands:
              if self.cards:
                  top_card = self.cards[0]
                  self.give(top_card, hand)
              else:
                  print ("Не могу больше сдавать: карты закончились!")

deck1 = Deck() print («Создана новая колода:») print (deck1) deck1.populate() print (deck1) deck1.shuffle() print (deck1)

my_hand = Hand() your_hand = Hand() hands = [my_hand, your_hand] deck1.deal(hands,per_hand=5) print («\nУ меня на руках:») print(my_hand) print («\nУ тебя на руках:») print(your_hand)

deck1.clear() print(«\nКолода очищена.») print(deck1)

Предопределение унаследованных методов.

class Card(object):

  """Одна игральная карта"""
  RANKS = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
  SUITS = ["c","d","h","s"]
  def __init__(self,rank,suit):
      self.rank = rank
      self.suit = suit
  def __str__(self):
      rep = self.rank + self.suit
      return rep

class Unprintable_Card(Card):

  """Карта, номинал и масть которой не могут быть выведены на экран"""
  def __str__(self):
      return "<нельзя напечатать>"

class Positionable_Card(Card):

  """Карта, которую можно положить лицом или рубашкой вверх"""
  def __init__(self,rank,suit,face_up = True):
      #super(Positionable_Card,self).__init__(rank,suit)
      super().__init__(rank,suit)
      self.is_face_up = face_up
  def __str__(self):
      if self.is_face_up:
          rep = super().__str__()
      else:
          rep = "XX"
      return rep    
  def flip(self):
      self.is_face_up = not self.is_face_up

card1 = Card(«A»,»c») card2 = Unprintable_Card(«A»,»d») card3 = Positionable_Card(«A»,»h»)

print(card1) print(card2) print(card3) card3.flip() print(card3)

Создание модулей.

#Создание модуля! games.py

class Player(object):

  """Участник игры"""
  def __init__(self,name,score = 0):
      self.name = name
      self.score = score
  def __str__(self):
      rep = self.name + ":\t" + str(self.score)
      return rep

def ask_yes_no(question):

  """Задает вопрос с ответом 'да' или 'нет'"""
  response = None
  while response not in ("y","n"):
      response = input(question).lower()
  return response

def ask_number(question, low, high):

  """Попросит ввести число из заданого диапазона"""
  response = None
  while response not in range(low,high):
      response = int(input(question))
  return response

if name == «main»:

  print ("Вы запустили этот модуль на прямую, а не импортировали его.")
  input ("\n\nНажмите Enter, чтобы выйти.")

#Импорт модуля games.py!

import games, random

print(«Добро пожаловать в самую простую игру!»)

again = None while again != «n»:

  players = []
  #Вызываем функцию из импортированного модуля.
  num = games.ask_number(question = "Сколько игроков учавствует? (2-5):",low = 2,high = 5)
  for i in range(num):
      name = input("Имя игрока: ")
      score = random.randrange(100)+1
      player = games.Player(score,name)
      players.append(player)
  print("\nВот результаты игры:")
  for player in players:
      print(player)

Разработка графических интерфейсов.

Избранные элементы GUI Эnемент Класс tkinter Оnисание кnасса Рамка Frame Служит базой для других элементов GUI Метка Label Отображает значок или текст, который нельзя править Кнопка Button Посnе польэовательа<оrо нажатия выполняет какое либо действие Текстовое поле Entry Принимает и отображает одну строку текста Текстовая область Text Принимает и отображает несколько строк текста Флажок Checkbutton Позволяет пользователю включить или выключкть какой-либо параметр Переключатель Radiobutton Позволяет пользователю выбрать один параметр из нескольких сгруппированных

Импорт модуля tkinter.

from tkinter import *

Чтоб создать базовое окно нужно инстанцировать класс Tk из модуля tkinter: root = Tk()

Изменение видимости базового окна.

root.title(«Простейший GUI») root.geometry(«200×100»)

Запуск событийного цикла базового окна.

root.mainloop()

Применение меток.

1.Создание рамки. Рамки - такой элемент управления внутри которого могут солержаться элементы.

app = Frame(root)
grid() метод размещения.
app.grid()

2. Создание метки. Для создания метки инсталируется класс Label.
lbl = Label(app,text = "Вот она я!!!")
Рамка app родительский элемент относительно метки.

Теперь вызывается метод grid() объекта-метки.
lbl.grid()

from tkinter import * root = Tk() root.title(«Простейший GUI») root.geometry(«200×600») app = Frame(root) app.grid() lbl = Label(app,text = «Вот она я!!!») lbl.grid() root.mainloop()

Применение кнопок

аналогично меткам

from tkinter import * root = Tk() root.title(«Простейший GUI») root.geometry(«200×600») app = Frame(root) app.grid() Bttn1 = Button(app, text = «Я ничего не делаю!») Bttn1.grid()

Модуль tkinter проявляет большую гибкость:

bttn2 = Button(app) bttn2.grid() bttn2.configure(text = «И я тоже!»)

bttn3 = Button(app) bttn3.grid() bttn3[«text»] = «И я!»

root.mainloop()

Создание GUI с помощю классов.

python_konspekt.txt · Последние изменения: 2016/11/28 14:55 — sander