Программирование на Python: быстрый старт. Т.В. Гурьянова

Программирование на Python: быстрый старт

Книга 6, часть I

 

Т.В. Гурьянова

Предисловие

Эта брошюра — краткое введение к обширной литературе по языку Python, объектно-ориентированному программированию и web-программированию. В нее вошли теория и задания 30-часового курса, который читался Т.В. Гурьяновой школьникам 6-8 классов «Юни-центра XXI» ФПМИ БГУ во втором полугодии 2014/2015 года.

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

 

 

 

Скачать и установить Python на свой компьютер легко. Ссылка для скачивания версии, работающей под Windows: https://www.python.org/downloads/release/python-342/ (программа устанавливается в любую («расшаренную») папку, в реестр ничего не прописывается). Тут можно посмотреть вводный урок:

https://www.youtube.com/watch?v=EXWE2Qgkl-M

 

 

Команда вывода на экран текста, заключенного в двойные кавычки » «:

print("Первая программа на Python")
>>> print("Пирожные"*10);
ПирожныеПирожныеПирожныеПирожныеПирожныеПирожныеПирожныеПирожныеПирожныеПирожные
>>> print("Пирожные\t"*10);
Пирожные Пирожные Пирожные Пирожные Пирожные Пирожные Пирожные Пирожные Пирожные Пирожные
>>> print("Пирожные\n"*10);
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
Пирожные
>>> input("Нажмите enter, чтобы выйти")

Полезные строковые методы

Метод         Описание

uррег()          Возвращает строку, символы которой приведены к верхнему регисгру

lower()            Возвращает строку, символы которой приведены к нижнему регистру

swapcase()   Возвращает новую строку, в которой регистр всех символов обращен:
верхний становится нижним и наоборот

capitalize()     Возвращает новую строку, в которой первая буква прописная, а
остальные -строчные

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

strip()                Возвращает строку, из которой убраны все интервалы (табуляция,
пробелы символы пустых строк) в начале и конце

герlасе( old,

new                      Возвращает строку, в которой вхождения строки old
замещаются строкой new.

[,max])                Необязательный параметр max устанавливает наибольшее
возможное количество замен

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

Функция  Описание                                                                                              Пример    Резупьтат

float(x)       Преобразует значение х в десятичную дробь        float(«10.5″)           10.5

int(x)            Преобразует значение х в целое число                     int(«10″)                    10

str(x)             Преобразует значение х в строку                                  str(10)                      ’10’

 

Программа, демонстрирующая использовавние вышеописанных методов и функций

name = input( "Как тебя зовут? ")
print("Здравствуй ", name.upper())
age = inрut("Сколько тебе лет? ")
age = int(age)
seconds = age * 365 * 24 * 60 * 60
print("\nTвoй нынешний возраст - свыше", seconds, "секунд.")

 

Полезные математические операторы

Оператор   Описание            Пример     Реэультат

+                         Сложение             7+3                10

—                         Вычитание             7-3                  4

*                        Умножение             7*3                21

/               Деление (обычное)     7/3                2.3 33333 33333 33335

//           Деление (с остатком)   7 // 3            2

%           Остаток от деления    7%3               1

 

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

Оператор           Пример        Равносильная запись

*=                            х *= 5                 x=x*5

/=                           х /= 5                   х = х/ 5

%=                         х%= 5                  х = х% 5

+=                           х += 5                  x=x+5

-=                            х-= 5                   х=х-5

 

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

Оператор         Значение        Пример           Истинность

==                            Равно                5==5                   True

!=                              Не равно         8 != 5                  True

>                                Больше          3>10                    False

<                                Меньше          5<8                      True

>=             Больше или равно    5>=10                 False

<=             Меньше или равно    5<=5                   True

 

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

if <условие>: <блок> Простейшая условная конструкция. Если <условие> истинно, то <блок> выполняется,

в противном случае — пропускается

if i<n: print(i)

if <условие>: <блок 1> Условная конструкция с условием else. Если <условие> истинно, выполняется

else:<блок 2> <блок 1>, если ложно — <блок 2>

if b!=0: print(a/b)
else: print("На ноль делить нельзя")

 

if <условие 1>:<блок 1> Условная конструкция с дополнительными условиями elif и необязательным else в

elif <условие 2>:<блок 2> конце. Будет исполнен блок после первого же условия, которое окажется истинным.

… Если ни одно условие не принимает значение True, будет исполнен блок после

elif <условие N>:<блок N> заключительного else.

else:<блок N+1>

if i<0: print(-i)
elif i>=0: print(i)
else:("Повторите ввод")

Знак ‘ # ‘ комментирует следующую за нам строку

#Демонстрируем работу команд break и continue

count = 0
while True:
count += 1

#завершить цикл, если count принимает значение больше 10

if count > 10 :
break
# пропустить 5
if count == 5:
continue
print(count)
input("\n \ n Haжмитe Enter. чтобы выйти.")

 

Упражнения

  1. Напишите программу, которая выводит на экран все натуральные числа от введенного пользователем до 1.
  2. Исправьте программу, чтобы числа выводились в обратном порядке: от 1 до введенного пользователем.
  3. Допишите программу, чтобы в результате выводилась на экран сумма первых N натуральных чисел.
print( "\t Добро пожаловать в игру 'Отгадай число'!")
print("\n Мы загадали натуральное число из диапазона от 1 до 100.")
рrint("Постарайтесь отгадать его за минимальное число попыток.\n")
import random
the_number = random.randint(1,100)
guess = int(input("Baшe предположение: "))
tries = 1
while guess != the_number:
if guess > the_number:
print( "Меньше.")
else:
print( "Больше.")
guess = int(input ("Ваше предположение: "))
tries += 1
  1. Напишите программу, которая бы «Подбрасывала» условную монету 100 раз и сообщала, сколько раз выпал орел, а сколько — решка.
  2. Измените программу «Отгадай число» таким образом, чтобы у игрока было ограниченное количество попыток. Если игрок не укладывается в заданное число (и проигрывает), то программа должна выводить суровый текст.
  3. Напишите программу, в которой случайное число от 1 до 100 загадывает человек, а отгадывает компьютер.

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

 

Цикл for

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

После достижения конца последовательности цикл завершается.

# Слово по буквам
# Демонстрирует применение цикла for к строке
word=input("Введите слово: ")
print("\n Boт все буквы вашего слова по порядку:")
for letter in word:
print(letter)
input("\n\nHaжмитe Enter. чтобы выйти.")

Это программа выведит на экран введенное вами слово по буквом (в каждой строчке будет по одной букве).

А вот как можно сделать с помощью цикла for предыдущее упражнение (вывод на экран первых n чисел в прямом и обратном порядке):

n=input("Введите число")
n=int(n)
for i in range (n):
print(i,end=" ")
print("\n\nПocчитaeм в обратном порядке:")
for i in range(n,0,-1):
print(i, end=" ")
input("\n\n Haжмитe Enter. чтобы выйти.\n")

Эта программа выводит четные числа от 2 до n

n=input("Введите число")
n=int(n)
print("\n\nПеречислим четные числа:")
for i in range(2,n,2):
print(i, end=" ")

 

Упражнение

Перепешите программу, чтобы она выводила

a) только нечетные числа от 1 до n;

b) считала «пятерками»

А вот как с помощью цикла for можно 10 раз вывести на экран слово «Пирожные» (заметьте: вместо переменной цикла стоит знак подчеркивания ‘_’ !):

for _ in range(10):
print("Пирожные ")
# Анализатор текста
#Демонстрирует работу функции len() и оператора in
message = input("Введите текст: ")
print( "\nДлина введенного вами текста составляет:", len(message))
if 'а' in message: print("\n Гласная 'а' встречается в этом тексте ")
else:
print("\n Гласная 'а' не встречается в этом тексте ")

 

Упражнения

  1. Перепешите программу, чтобы в результате ее Вы знали точное количество

букв ‘а’ встречающихся в введенном Вами тексте.

  1. Напишите прогрмму, подсчитаывющую количество слогов ‘ра’ в слове ‘Абракадабра’
  2. Найдите место (буква по счету, считая с начала предложение), в котором первый раз встречается слово ‘lazy’ в предложении The quick brown dog jumps over the lazy fox

 

В яыке Python для маркера начала и конца блока нет видимого значка, как в Паскале (begin end), C/C++, Java ({ }). Начало блока означает табуляционный отступ, конец — возврат на табуляцию обратно.

Последовательность команд:

word=inut("Введите слово")
for letter in word:
         int(letter)
input("\n\n Haжмитe Enter. чтобы выйти.")

выведет на экран введенное Вами слово по буквам, а в конце ‘Haжмитe Enter. чтобы выйти.’

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

word=inut("Введите слово")
for letter in word:
            print(letter)
            input("\n\n Haжмитe Enter. чтобы выйти.")

Будет работать иначе.

Упражнение. Проверьте.

Вот пример, как можно описывать нестандартные функции(пример стандартной функции — len(),upper() — см. выше):

# Инструкция
#Демонстрирует, как создавать собственные функции
def instructions():
   """Выводит на экран инструкцию для игрока."""
   print("""
   Добро пожаловать в игру "Крестики-нолики". Чтобы сделать ход. введи число от 0 до 8. Числа однозначно соответствуют полям доски - так. как показано ниже:
   0 | 1 | 2
   3 | 4 | 5
   6 | 7 | 8
   \n""")
instructions()
instructions()
instructions()

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

Три раза повторяющимися тройными кавычками («»») обозначают документирующие строки

 # Принимай - возвращай
# Демонстрирует параметры и возвращаемые значения
def display(message) :
print(message)
def give_me_five() :
five = 5
return five
def ask_yes_no(question) :
"'"'Задает вопрос с ответом 'да' или 'нет ' . """
response = None
while response not in ("у", "n") :
 response = input(question) .lower()
return response
# основная часть
display("Baм сообщение. \n")
number = give me five()
print("Boт что возвратила функция give_me_five() :" . number)
answer = аsk_уеs_nо("\n Пожалуйста, введите 'у' или 'n': ")
print( "Спасибо, что ввели", answer)
input("\n\nHaжмитe Enter. чтобы выйти.")

 

# День рождения
# Демонстрирует именованные аргументы и значения параметров по умолчанию
# позиционные параметры
def Ьirthday1(name,age):
print( "С днем рождения, ", name, "!", " Вам сегодня исполняется", age, " не так ли? \ n")
# параметры со значениями по умолчанию
def birthday2(name = " товарищ Иванов", age = 1):
print( "С днем рождения,", name, "!", " Вам сегодня исполняется " , age , " не так ли? \ n")
birthday1("Тoвapищ Иванов " , 1)
birthday1(1, "Тoвapищ Иванов ")
birthday2()
birthday2(name: "Катя")
birthday2(age: 12)
birthday2( name: "Катя", age : 12)
birthday2( "Катя", 12)
input("\n\nHaжмитe Enter. чтобы выйти.")

В одном вызове функции можно сочетать позиционные (как в функции birthday1()) и именованные арrументы (как в функции birthday2()), но от этого возникают некоторые трудности. Если где-либо в вызове функции вы указали именованный арrумент, то все следующие за ним арrументы тоже должны быть именованы. Чтобы обойтись без лишних усложнений, старайтесь применять или только позиционные, или только именованные аргументы.

Изящество именованных аргументов состоит в том, что для них порядок неважен; значения присваиваются параметрам в той последовательности, которую укажет программист. Например, в функции birthday1 можно из позиционных аргументов сделать именованные: birthday1(age = 1, name = «товарищ Иванов»).

Переменные, описанные внутри блока видны только в этом блоке от момента их появления до конца блока.

Оператор return может вернуть переменную из функции в основную часть программы (пример — описанная выше функция give_me_five()).

Упражнение. Попробуйте написать игру «Крестики-нолики», в которой человек играет с компьютером.

 

Инкапсуляция и абстракция

Ни одна переменная, созданная внутри функции (в том числе и параметры), непосредственно не доступна извне. Эта полезная техника называется инкапсуляцией. Переменная five не существует вне блока выражений описанной выше функции give_me_five( ). Инкапсуляция помогает сохранять независимость отдельных фрагментов кода: для этого прячутся (инкапсулируются) частности. Параметры и возвращаемые значения используются именно затем, чтобы передавать важную информацию и игнорировать прочую. Кроме того, за значениями переменных, созданных внутри функции, не приходится следить во всем остальном коде.

Создавая и вызывая функции, вы прибегаете к так называемой абстракции. Абстракция позволяет сконцеmрироваться на целом, не задерживаясь на мелких деталях. Например, в программе-игре «крестики-нолики», мы применяем функцию instructions() и не беспокоимся о том, как именно в ней реализован вывод текста на экран. Достаточно вызвать функцию одной строкой кода: instructions() — и задача решена.

Абстракция позволяет не заботиться о деталях, а инкапсуляция прячет детали.

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

# Доступ отовсюду
# Демонстрирует работу с глобальными переменными
def read_global():
print( "В области видимости функции read_global() значение value равно", value)
def shadow_global():
value = -10
print("B области видимости функции shadow_global() значение value равно", value)
def change_global():
global value
value = -10
print("B области видимости функции change_global() значение value равно", value)
# основная часть
# value - глобальная переменная. потому что сейчас мы находимся в глобальной области видимости
value = 10
print("B глобальной области видимости значение переменной value сейчас стало равным", value, "\n")
read_global()
print("Вернемся в глобальную область видимости. Здесь value по-прежнему равно", value, "\n")
shadow_global ()
print("Bepнeмcя в глобальную область видимости. Здесь value по-прежнему равно", value, "\n")
change_glоbаl()
print("Bepнeмcя в глобальную область видимости. Значение value изменилось на", value)
input("\n\nHaжмитe Enter, чтобы выйти.")

 

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

не сможет (если не запросит специальных полномочий). Так, если бы в read_glоbаl() мы попробовали бы написать, например,

value += 1

то произошла бы ошибка.

Если переменной внутри функции вы присваиваете то же самое имя, что и глобальной переменной, это называется ‘затенять’ глобальную переменную — скрывать

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

shadow_global()
return value,

а в код основной программы дописать

value=shadow_global().

Упражнение Проверьте!

Полный доступ к глобальной переменной дает служебное слово glоbаl (см. описание функции

change_glоbаl( ))

 

Спланируем написание игры «Крестики-нолики»: напишем псевдокод, каждая строка которого будет соответствовать одному вызову функции.

Вывести на экран инструкции для игрока
Решить, кому принадлежит первый ход
Создать пустую доску для игры в «Крестики-нолики»
Отобразить эту доску
До тех пор пока никто не выиграл или не состоялась ничья

Если сейчас ход пользователя
получить ход из пользовательского ввода
изменить вид доски

иначе
рассчитать ход компьютер
изменить вид доски

Вывести на экран обновленный вид доски

Осуществить переход хода

Поздравить победителя или констатировать ничью

 

Вот вариант описание соответсвующих функций, некоторые из которых были описаны выше:

Функция                                      Описание

display _iпstruct()                 Выводит инструкцию для игрока

ask_yes_пo(questioп)         Задает вопрос, ответом на который может быть «Да» или
«Нет».
Принимает текст вопрос, возвращает ‘у’ или ‘n’

ask_пumber(questioп, low,high)    Просит ввести число из указанного диапазона.
Принимает текст вопроса, нижнюю (low) и верхнюю (high)
границы диапазона.
Возвращает целое число не меньше low и не больше high

pieces()                                    Определяет принадлежность первого хода человеку или
компьютеру. Возвращает типы фишек соответственно
компьютера и человека

пew_board()                         Создает пустую игровую доску. Возвращает эту доску

display_board(board)      Отображает игровую доску на экране. Принимает эту доску

legal_moves(board)          Создает список доступных ходов. Принимает доску.
Возвращает список доступных ходов

winner(board)                      Определяет победителя игры. Принимает доску.
Возвращает тип фишек победителя: «Ничья» или None

human_move(board, human)           Узнает, какой ход желает совершить игрок.
Принимает доску и тип фишек человека. Возвращает ход
человека

computer_move(board,        Рассчитывает ход компьютерного противника.
Принимает доску,

computer, human)             тип фишек компьютера и тип фишек человека.
Возвращает ход  компьютера

next_turn(turn)                   Осуществляет переход к следующему ходу. Принимает
тип фишек. Возвращает тип фишек

congrat_winner(the_winnrer,            Поздравляет победителя или констатирует
ничью.      Принимает тип фишек победителя,
computer, human)              тип фишек компьютера и тип фишек человека

 

Упражнение. Напишите программу игры на языках Python, Java, C++, используя в функции, описанные выше

(реализацию этих функций нужно написать самостоятельно!).

Упражнение*. То же самое, используя графические компоненты системы Swing (для Java), C++Builder, WinForms (для С/C++)

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

Описание глобальных переменных:

# Крестики-нолики
# Компьютер играет в крестики-нолики против пользователя
# глобальные константы
X="X"
O= "0"
ЕМРТУ =" "
TIE = "Ничья"
NUM_SQUARES = 9

ЕМРТУ представляет пустое поле на игровой доск: пробел на экране выглядит как пустой прямоугольник. ТIЕ представляет состояние ничьей. NUM _ SQUARES — количество полей на доске.

Функция display _instruct() — см. описанную ранее функцию instructions().

Функция ask_yes_no() тоже уже была нами описана.

Функция ask_number()

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

Функция pieces()

"""Определяет принадлежность первого хода."""
def pieces():
go_first=ask_yes_no("хочешь оставить за собой первый ход?(y/n):")
if go first=="y":
print("\n ну что ж, играй крестиками")
human=X computer=O else: print("\nБуду начинать я.")
human=X human=O
return computer, human

Функция display_board()

def display _board(board):
"""Отображает игеровую доску на экране."""
print("\n\t", board[0], "|", board[1], "|". board[2])
print("\t", "---------")
print("\t", board[З], "|", board[4], "| ", board[5])
print("\t", "---------")
print("\t", board[З], "|", board[4], "| ", board[5], "\n")

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

Функция legal_moves() перебирает список, которым представлена доска.

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

def legal_moves(board):
"""создает список доступных ходов."""
moves = []
for square in range(NUM SQUARES):
if board[square] ==-ЕМРТУ:
moves.append(square)
return moves

Функция winner() принимает доску и возвращает победителя игры.

Может быть возвращено одно из четырех значений: Х или О — если один из игроков побеждает; TIE — если все поля заполнены, но победы не достиг ни один из противников; наконец, None — если хотя бы одно из полей пусто и при этом победитель не определен.

Первым делом в этой функции я задал константу WAYS_TO_WIN, описывающую все восемь возможных способов поместить три фишки в ряд. Каждый способ достичь победы изображается кортежем — тройкой таких позиций на доске, что фишки на соответствующих полях образуют ряд. Возьмем для примера первый кортеж: (0. 1. 2). Он представляет верхний ряд, поля с позициями номер О, 1 и 2. Следующий кортеж — (3. 4. 5) — представляет средний ряд и т. д.

def winner(board):
"""Определяет победителя в игре."""
WAYS ТО WIN = ((0, 1, 2),
(3, 4, 5),
(6, 7, 8),
(0, 3, 6),
(1, 4, 7),
(2, 5, 8),
(0, 4, 8),
(2, 4, 6))

Затем цикл for перебирает все способы достижения победы, чтобы узнать, нет

ли уже у одного из игроков трех фишек в ряд. Применяемая здесь конструкция if

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

Если все именно так, то, значит, тройка содержит ровно три крестика или

нолика и один из игроков одержал верх. Одну из фишек выигрывающего ряда

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

for row in WAYS ТО WIN:
if board[row[0]] == board[row[1]] == board[row[2]]!= ЕМРТУ:
winner = board[row[0]]
return winner

Если ни один игрок не победил, работа функции продолжается. Теперь надо проверить,

не осталось ли пустых полей на доске. Если нет, то игра сыграна вничью (потому

что перебор в цикле for не выявил победителя) и возвращается значение TIE.

if ЕМРТУ not in bоаrd :
return TIE

В противном случае работа функции продолжается. Если победитель не определен,

но вместе с тем игра не сыграна вничью, то, значит, конец игры еще не достигнут

и функция возвращает None.

return None

 

Функция human_move()

def human_move(board, human):
"""Получает ход человека. """
legal = legal_moves(board)
move = None
while move not in legal:
move = ask_number("Tвoй ход. Выбери одно из полей (0 - 8):", 0, NUM_SQUARES)
if move not in legal :
print("\nЭто поле уже занято. Выбери дpyroe.\n")
print( "Ладно ... ")
return move

Функция computer_move()

  1. Если существует такой ход компьютера, после которого тот одерживает победу,
    надо сделать этот ход.
  2. Если  существует такой ход человека, после которого тот может одержать победу на следующем ходу,
    надо предупредить этот ход.
  3. Вином случае
    компьютер выбирает для своего хода «лучшее» из доступных полей.

Будем считать, что самое лучшее поле — центральное, ему уступают по качеству угловые поля, а тем — все остальные.

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

 

Литература

 

Майкл Доусон. Программируем на Python. СПб.: Питер, 2014.

Яков Файн. Программирование на Java для детей, родителей, дедушек и бабушек. http://myflex.org/books/java4kids/JavaKid8x11_ru.pdf

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Можно использовать следующие HTML-теги и атрибуты: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>