Как сделать камень ножницы бумага на python

Игра на python камень ножницы бумага

В этой статье мы напишем программу на python которая реализует известную игру камень ножницы бумага. При написании этой программы мы на практике применим знания циклов, условий, ввода и вывода в Python, а также работу со случайными числами в Python
Суть игры будет заключаться в следующем. Человек загадывает одно из трех камень, или ножницы или бумагу . Вводит свое решение с помощью кодов
камень – 1 ножницы -2 бумага -3
Компьютер случайным образом определяет свой выбор, в дальнейшем с помощью условий определяется, кто победил, результат игры выводится на экран. А теперь подробней и поэтапно разберем программу на Python которая реализует игру камень ножницы бумага.
1. Ввод выбора человека
Для номера варианта человека будет использоваться переменная player . Ввод будет осуществляться до тех пор пока не будет введено либо 1 либо2 либо 3. Проверку на корректность вводимых данных в программу python осуществляется с помощью цикла while. Подробно о циклах while в Python. Цикл while будет выполняться пока значение переменной ver равно 0.Эта переменная поменяет свое значение только при корректном вводе
ver = 0
while (ver == 0):
player = int(input(«1 — камень, 2 — ножницы, 3 — бумага. «))
if (player == 1 or player == 2 or player == 3):
ver = 1
Далее с помощью оператора условия if в python мы определяем ход человека и выводим его экран
if player == 1:
print(«Вы выбрали камень.»)
if player == 2:
print(«Вы выбрали ножницы.»)
if player == 3:
print(«Вы выбрали бумагу.»)
2. Выбор компьютера
для выбора компьютера будем использовать переменную comp Ей мы присвоим случайное значение в диапазоне от 1 до 3 с помощью команды модуля random
comp = random.randint(1, 3)
Подробнее о работе со случайными числами в Python
Далее с помощью оператора условия if в python мы определяем ход компьютера и выводим его экран
if comp == 1:
print(«Компьютер выбрал камень.»)
if comp == 2:
print(«Компьютер выбрал ножницы.»)
if comp == 3:
print(«Компьютер выбрал бумагу.»)
3. Анализ и выбор победителя
Введем специальную переменную win в которую будем записывать результат игры
win=1 если выиграл человек
win=2 если выиграл компьютер
win=0 если ничья
Мы должны с помощью условных операторов проанализировать все ситуации и определиться для них кто победил. Для этого в условном операторе If нам нужно проанализировать выполнение обоих условий на переменные player и comp, для этого используется логическая операция and. Например если человек выбрал камень, а компьютер ножницы, то будет условие
if player == 1 and comp == 2:
win = 1
Аналогично перебираются все варианты хода человека и компьютера и для каждого определяется переменная win
4 Вывод результата игры
Результат игры у нас хранится в переменной win, поэтому с помощью условий If мы легко его выведем на экран
if win == 0:
print(«Ничья!»)
if win == 1:
print(«Победил игрок!»)
if win == 2:
print(«Победил компьютер!»)
Полный текст программы на Python игры камень ножницы бумага
import random
ver = 0
while (ver == 0):
player = int(input(«1 — камень, 2 — ножницы, 3 — бумага. «))
if (player == 1 or player == 2 or player == 3):
ver = 1
if player == 1:
print(«Вы выбрали камень.»)
if player == 2:
print(«Вы выбрали ножницы.»)
if player == 3:
print(«Вы выбрали бумагу.»)
comp = random.randint(1, 3)
if comp == 1:
print(«Компьютер выбрал камень.»)
if comp == 2:
print(«Компьютер выбрал ножницы.»)
if comp == 3:
print(«Компьютер выбрал бумагу.»)
# определяем победителя
if player == comp:
win = 0
if player == 1 and comp == 2:
win = 1
if player == 1 and comp == 3:
win = 2
if player == 2 and comp == 1:
win = 2
if player == 2 and comp == 3:
win = 1
if player == 3 and comp == 1:
win = 1
if player == 3 and comp == 2:
win = 2
if win == 0:
print(«Ничья!»)
if win == 1:
print(«Победил игрок!»)
if win == 2:
print(«Победил компьютер!»)
Вернуться к содержанию курса python

Комментарии ( 0 )

Нет комментариев. Ваш будет первым!

Пишем игру «Камень-ножницы-бумага» на Python разными способами

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

В этой статье мы сделаем именно это. Вернёмся к стандартному проекту для начинающих — реализации игры «Камень, ножницы, бумага» на Python, посмотрев, как её можно «улучшить».

Правила игры «Камень-ножницы-бумага»

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

1. Камень бьёт ножницы.
2. Ножницы бьют бумагу.
3. Бумага бьёт камень.

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

Требования

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

Вот несколько примеров того, как вызывается функция play() и что она возвращает:

>>> play("камень", "бумага") 'побеждает бумага' >>> play("ножницы", "бумага") 'побеждают ножницы' >>> play("бумага", "бумага") 'ничья'

Если один или оба аргумента некорректны, то есть не являются «камень» , «бумага» или «ножницы» , функция play() должна вызвать какое-то исключение.

play() также должна быть коммутативной. Иными словами, строка play(«камень», «бумага») должна возвращать то же самое, что и play(«бумага», «камень») .

Решение для «начинающих»

В качестве базы для сравнения рассмотрим, как новичок мог бы реализовать функцию play() . Он, вероятно, начал бы записывать целую кучу выражений if:

def play(player1_choice, player2_choice): if player1_choice == "rock": if player2_choice == "rock": return "tie" elif player2_choice == "paper": return "paper wins" elif player2_choice == "scissors": return "rock wins" else: raise ValueError(f"Invalid choice: ") elif player1_choice == "paper": if player2_choice == "rock": return "paper wins" elif player2_choice == "paper": return "tie" elif player2_choice == "scissors": return "rock wins" else: raise ValueError(f"Invalid choice: ") elif player1_choice == "scissors": if player2_choice == "rock": return "rock wins" elif player2_choice == "paper": return "scissors wins" elif player2_choice == "scissors": return "tie" else: raise ValueError(f"Invalid choice: ") else: raise ValueError(f"Invalid choice: ")

Строго говоря, в этом коде нет ничего плохого. Он работает без ошибок и соответствует всем требованиям. Кроме того, он похож на ряд высоко ранжированных реализаций в поисковике Google для запроса «rock paper scissors python».

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

Продвинутое решение №1

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

Давайте назовем этот словарь loses_to (да-да, называть переменные — дело сложное):

loses_to =

loses_to предоставляет простой интерфейс для определения того, какой элемент проигрывает другому:

>>> loses_to["камень"] 'ножницы' >>> loses_to["ножницы"] 'бумага'

Имея это в виду, функцию play() можно было бы записать следующим образом:

def play(player1_choice, player2_choice): if player2_choice == loses_to[player1_choice]: return f"побеждает " if player1_choice == loses_to[player2_choice]: return f"побеждает " if player1_choice == player2_choice: return "ничья"

В этой версии play() использует встроенную ошибку KeyError , вызванную словарём loses_to при попытке получить доступ к несуществующему ключу. Это позволяет легко обработать некорректный ввод. Таким образом, если какой-либо игрок выбирает недопустимый предмет — что-то вроде «ящерицы» или 1234 — play() вызывает KeyError :

>>> play("ящерица", "бумага") Traceback (most recent call last): File "", line 1, in File "", line 2, in play KeyError: 'ящерица'

Хотя исключение KeyError не так информативно, как ValueError с точки зрения описания проблемы, но оно всё равно решает проблему.

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

1. player2_choice проигрывает player1_choice
2. player1_choice проигрывает player2_choice
3. player1_choice и player2_choice одинаковые.

Однако есть четвертый скрытый случай, который стоит заметить. Этот случай возникает, когда ни один из трёх других случаев не является истинным, и в этом случае функция play() возвращает значение None .

Но. может ли этот случай действительно произойти? На самом деле нет, не может. Согласно правилам игры, если игрок 1 не проигрывает игроку 2 и игрок 2 не проигрывает игроку 1, то оба игрока должны были выбрать один и тот же элемент.

Другими словами, мы можем удалить последний блок if из play() и просто написать return «ничья» , если ни один из двух других блоков if не выполняется:

def play(player1_choice, player2_choice): if player2_choice == loses_to[player1_choice]: return f"побеждает " if player1_choice == loses_to[player2_choice]: return f"побеждает " return "ничья"

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

Стоил ли этот компромисс того? Я не знаю. Побеждает ли краткость эффективность?

Продвинутое решение №2

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

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

1. Камень бьёт ножницы и ящерицу.
2. Бумага бьёт камень и Спока.
3. Ножницы бьют бумагу и ящерицу.
4. Ящерица бьёт Спока и бумагу.
5. Спок бьёт ножницы и камень.

Как можно адаптировать код, чтобы так расширить правила?

Сначала заменим строковые значения в словаре loses_to множествами. Каждое множество содержит все элементы, которые проигрывают соответствующему ключу. Вот как выглядит эта версия loses_to , использующая оригинальные правила «Камень-ножницы-бумага»:

loses_to = < "камень": , "бумага": , "ножницы": , >

Почему именно множества? Потому что нам важно только то, какие элементы проигрывают данному ключу. Нас не волнует порядок этих элемнтов.

Чтобы адаптировать play() для обработки нового словаря loses_to , всё, что нам нужно сделать, это заменить == на in , чтобы использовать проверку принадлежности вместо проверки равенства:

def play(player1_choice, player2_choice): # замена == на in if player2_choice in loses_to[player1_choice]: return f"побеждает " # замена == на in if player1_choice in loses_to[player2_choice]: return f"побеждает " return "ничья"

Можете проверить и убедиться, что всё работает корректно.

Теперь заменим loses_to словарём, реализующим правила для «Камень, ножницы, бумага, ящерица, Спок». Вот как это выглядит:

loses_to = < "камень": , "бумага": , "ножницы": , "ящерица": , "Спок": , >

Новая функция play() отлично работает и с новыми правилами:

>>> play("камень", "бумага") "побеждает бумага" >>> play("Спок", "ящерица") "побеждает ящерица" >>> play("Спок", "Спок") "ничья"

Это отличный пример того, как важно выбрать правильную структуру данных. Используя множества для хранения всех нужных элементов, которые проигрывают ключу в словаре loses_to , и заменив == на in , мы создали более универсальное решение без необходимости добавлять ни одной строки кода.

Продвинутое решение №3

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

Нам все ещё нужно что-то, чтобы представлять правила игры, поэтому давайте начнём с loses_to , как в предыдущем решении:

loses_to = < "камень": , "бумага": , "ножницы": , >

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

>>> build_results_table(loses_to) < : "побеждает камень", : "побеждает бумага", : "побеждают ножницы", : "ничья", : "ничья", : "ничья", >

Если вы думаете, что тут что-то не так, вы правы. В этом словаре есть две ошибки:

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

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

Чтобы реализовать build_results_table() , вы могли бы перебирать каждый из ключей в словаре loses_to и создавать экземпляр frozenset для каждого из значений строк в наборе, соответствующих ключу:

def build_results_table(rules): results = <> for key, values in rules.items(): for value in values: state = frozenset((key, value)) result = f"побеждает " results[state] = result return results

Благодаря такому подходу мы окажемся примерно на половине пути к цели:

>>> build_results_table(loses_to) ): 'побеждает камень', frozenset(): 'побеждает бумага', frozenset(): 'побеждают ножницы'>

Однако состояния, которые приводят к ничьей, не рассматриваются. Чтобы добавить их, вам нужно создать frozenset для каждого ключа в словаре правил, которые сопоставляются со строкой «ничья» :

def build_results_table(rules): results = <> for key, values in rules.items(): # Добавления состояния "ничья" results[frozenset((key,))] = "ничья" # " results[state] = result return results

Теперь значение, возвращаемое build_results_table() , выглядит правильно:

>>> build_results_table(loses_to) ): 'ничья', frozenset(): 'побеждает камень', frozenset(): 'ничья', frozenset(): 'побеждает бумага', frozenset(): 'ничья', frozenset(): 'побеждают ножницы'>

Зачем так заморачиваться? В конце концов, build_results_table() выглядит сложнее, чем функция play() из предыдущего решения.

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

Одним из реальных сценариев, в которых такой подход имеет смысл, является алгоритм Q-learning , используемый в приложениях для обучения с подкреплением. В этом алгоритме поддерживается таблица состояний — Q-таблица, которая сопоставляет каждое состояние с набором вероятностей для некоторых заранее определённых действий. Как только агент обучен, он может выбрать действие, основанное на вероятностях наблюдаемого состояния, а затем его выполнить.

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

Итак, теперь, когда у вас есть функция, которая может создавать таблицу результатов, создадим переменную outcomes с её результатами:

outcomes = build_results_table(loses_to)

Теперь можно написать функцию play() , которая ищет состояние в таблице результатов на основе переданных аргументов, а затем возвращает результат:

def play(player1_choice, player2_choice): state = frozenset((player1_choice, player2_choice)) return outcomes[state]

Эта версия play() невероятно проста. Всего две строки кода! Можно даже и одной написать:

def play(player1_choice, player2_choice): return outcomes[frozenset((player1_choice, player2_choice))]

Новая функция play() полностью соответствует правилам и является коммутативной:

>>> play("камень", "бумага") 'побеждает бумага' >>> play("бумага", "камень") 'побеждает бумага'

play() даже вызывает KeyError , если она вызывается с некорректным аргументом, но текст ошибки теперь менее явный из-за того, что ключи являются frozenset :

>>> play("ящерица", "бумага") Traceback (most recent call last): File "", line 1, in File "", line 21, in play return outcomes[state] KeyError: frozenset()

Но это не будет серьёзной проблемой. Сейчас мы реализуем только play() . В реальной реализации мы, скорее всего, приняли бы ввод пользователя и проверили его перед передачей в качестве аргумента в функцию.

Итак, насколько быстрее эта реализация по сравнению с предыдущими? Вот результаты замера времени для сравнения производительности различных вариантов с использованием магической функции %timeit . play1() — это версия play() из раздела Продвинутое решение #2 , а play2() — текущая версия:

%timeit play1("камень", "бумага") 141 ns ± 0.0828 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each) %timeit play2("камень", "бумага") 188 ns ± 0.0944 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

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

Заключение

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

Игра в камень, ножницы, бумага на Python

Мы готовимся представить вам простую программу на Python для игры в RPS (Rock, Paper, Scissors) с компьютером.

Цель: Создать RPS-игру с использованием программирования на Python.

1. Установлен Python

2. Знание Python (print-function, if-else, Random function, lists)

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

Для начала мы разобьем цели на небольшие шаги и достигнем их.

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

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

import random # declaring variables with values as sign for rock, paper and scissors rock = ''' _______ ---' ____) (_____) (_____) (____) ---.__(___) ''' paper = ''' _______ ---' ____)____ ______) _______) _______) ---.__________) ''' scissors = ''' _______ ---' ____)____ ______) __________) (____) ---.__(___) ''' # logic for taking input from player and display their choice selection = input("what do you choose? Type 0 for Rock, 1 for Paper or 2 for Scissors.: ") if selection == "0": print(rock) elif selection == "1": print(paper) else: print(scissors) #logic for displaying what computer chose randomly options = [rock, paper, scissors] computer_chose = random.choice(options) print("Computer chose:" , computer_chose) #logic to declare result on the basis of selection between you and computer if selection == "0" and computer_chose == scissors: print("You win") elif selection == "1" and computer_chose == rock: print("You win") elif selection == "2" and computer_chose == paper: print("You win") else: print("You lose")

Написать игру в «камень-ножницы-бумага»

33 Написать игру в «камень-ножницы-бумага» против компьютера.
Запустить игру в бесконечном цикле. Запросить ввод от пользователя (R — камень, S — ножницы, P — бумага). Сгенерировать случайный выбор компьютера. Вывести выбор компьютера. Определить победителя, выведя соответствующую информацию. Спросить пользователя — хочет ли он повторить игру. Если хочет — повторить, не хочет — выйти из цикла.

Лучшие ответы ( 1 )
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:

Камень, ножницы, бумага
Приветствую господа! Ссылка на задачу: https://stepik.org/lesson/906970/step/3?unit=912512 .

Игра камень ножницы бумага
Я сделал игру камень ножницы бумага, но не могу придумать как сделать так чтобы, пк спросил ‘Хотите.

КАМЕНЬ, НОЖНИЦЫ, БУМАГА ЧЕРЕЗ ООП
Задание: При помощи ООП и классов создайте программу «Rock, Paper, Scissors» или же «Камень.

Камень, ножницы, бумага – мини-игра
Здравствуйте. Решил тренироваться по мини проектам для новичков на сайте.

Зациклить игру Камень, Ножницы, Бумага
как сделать так, что-бы после выйгрыша/проигрыша/ничьей, программа не останавливалась, а заново.

Регистрация: 19.01.2022
Сообщений: 201

Сообщение было отмечено Romensoh как решение

Решение

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

import random ver = 0 while (ver == 0): player = int(input("1 - камень, 2 - ножницы, 3 - бумага. ")) if (player == 1 or player == 2 or player == 3): ver = 1 if player == 1: print("Вы выбрали камень.") if player == 2: print("Вы выбрали ножницы.") if player == 3: print("Вы выбрали бумагу.") comp = random.randint(1, 3) if comp == 1: print("Компьютер выбрал камень.") if comp == 2: print("Компьютер выбрал ножницы.") if comp == 3: print("Компьютер выбрал бумагу.") # определяем победителя if player == comp: win = 0 if player == 1 and comp == 2: win = 1 if player == 1 and comp == 3: win = 2 if player == 2 and comp == 1: win = 2 if player == 2 and comp == 3: win = 1 if player == 3 and comp == 1: win = 1 if player == 3 and comp == 2: win = 2 if win == 0: print("Ничья!") if win == 1: print("Победил игрок!") if win == 2: print("Победил компьютер!")

3105 / 1522 / 518
Регистрация: 21.11.2021
Сообщений: 3,022

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

import random #============================================================================== def greater_RSP(L, R): return L + R in ('RS','SP','PR') #============================================================================== while True: while True: user = input('Эна-бена-цо! (R,S,P): ') if user in ('R','S','P'): break print(f'Ваш ход - .') comp = 'RSP'[random.randint(0,2)] print(f'Ход компьютера - .') if greater_RSP( user, comp ): print('Вы победили!') elif greater_RSP( comp, user ): print('Победил искусственный интеллект!') else: print('Ничья!') cont = input('Для продолжения игры введите любой символ, для выхода - просто нажмите Enter: ') if not cont: print('До следующей игры!') break print()

535 / 312 / 78
Регистрация: 10.04.2012
Сообщений: 1,160
Записей в блоге: 2

Можно, ещё счёт игры вести

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

import random win, g = ['RS','SP','PR'], 'Y' cg, ca = 0,0 print('Начинаем игру! Для выхода из игры введете - N \n (варианты ходов: R, S или P)') while g != 'N': g = input('Ваш ход: ') a = 'RSP'[random.randint(0,2)] if (g+a) in win: cg += 1 print(f'Выиграл игрок, у компьютера . Счет : (игрок:комп)') if (a+g) in win: ca += 1 print(f'Выиграл компьютер - . Счет : (игрок:комп)') if a == g: print(f'Ничья - и ') print(f'\nОбщий счет - : (игрок:комп)\n\n Увидимся! ')

Добавлено через 8 минут
Вместо букв RSP лучше поставить цифры 123
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
Помогаю со студенческими работами здесь

Делал игру «камень ножницы бумага», но в конце программа не считает счёт, хотя условие для увеличение переменной выполне
import random w = 0 m = 0 int(w) int(m) def game(): w = 0

Камень, ножницы, бумага
написал код для игры КНБ: from random import choice my_choose = computer_choose =.

Камень-ножницы-бумага
Здравствуйте, задали написать простейшую игру на питоне, я выбрал камень,ножницы,бумага. Все в.

Камень ножницы бумага
Полина и Алина играют в "Камень-ножницы-бумага", кто проиграет, тот моет посуду. Если ничья, то.

Камень, ножницы, бумага
Здравствуйте. Видел такую задачу на Java, решил попробовать сделать то же самое на Python, но не.

Или воспользуйтесь поиском по форуму: