Как стирать в python
Я вывожу надпись «Нажмите любую клавишу…». После нажатия клавиши я хотел бы, чтобы эта надпись исчезла.
Покопавшись по форуму, не нашёл нормального и адекватного ответа, потому хочу получить помощь в отдельном вопросе.
Чтобы не было никаких вопросов привожу конкретику:
- С возвратом каретки не совсем получилось по примеру из Обновление вывода print в Console pyCharm.Как изменить строку вывода? 10 , после обновилось на 9 и тд.?. Нужен был другой, более конкретный пример, который мне дал в ответах ниже Pashok.
- Не понятно, к чему была дана эта ссылка Ввод с клавиатуры не приостанавливая работу программы на python. Никак применить данное не смог.
- Вот отсюда Python проверка наличия данных в sys.stdin я смог только вытащить сам модуль msvcrt.
- Параллельное исполнение двух функций python — пока с многопоточностью в Python не работаю. Рано мне ещё)))
- Первая ссылка Cоздание анимации пишущей машинки c обратным процессом в python пригодилась, но в дальнейшем мне не удалось скомбинировать анимацию с кареткой. Т.к. дело моё, то считаю, что без этого можно обойтись. Собственно, в новом вопросе это не описываю.
Код моей текстовой игры работает в двух файлах: один функциональный, второй исполнительный.
Перед вами функция, которая выводит комментаторский текст, не являющийся речью персонажей.
def cnt(text, centers=’center’):
if centers == «left»:
print(‘{:<80}’.format(text), end=»)
elif centers == «right»:
print(‘{:>80}’.format(text), end=»)
elif centers == «center»:
print(‘{:^80}’.format(text), end=»)
sys.stdout.flush()
sys.stdout.write(‘Нажмите Enter для продолжения…r’)
while not msvcrt.kbhit():
pass
sys.stdout.write(‘ r’)
input()
задан 27 мая ’18 в 23:44
Я вывожу надпись «Нажмите любую клавишу…». После нажатия клавиши я хотел бы, чтобы эта надпись исчезла.
Чтобы ожидать любую клавишу на Windows, можно msvcrt.getch() использовать:
import msvcrt
text = «Нажмите любую клавишу…»
print(text, end=», flush=True)
msvcrt.getch()
print(‘b’ * len(text) + ‘ ‘ * len(text), end=», flush=True)
Это стирает текст, печатая пробелы поверх него, если среда поддерживает b управляющую последовательность. См. Не работает цикл из itertools.cycle() использующий b в PyCharm.
Обратите внимание, что ‘b’ * len(text) вместо r использовано для случая, когда text не сначала строки печатается.
ответ дан 28 мая ’18 в 12:13
jfsjfs
46.3k99 золотых знаков6868 серебряных знаков246246 бронзовых знаков
Можно очищать консоль после нажатия кнопки.
>>> import os
>>> # Для windows:
>>> clear = lambda: os.system(‘cls’)
>>> # Для linux / os x:
>>> clear = lambda: os.system(‘clear’)
>>> clear()
ответ дан 28 мая ’18 в 4:38
Отдельно строку удалить не получиться её можно лишь изменить. Тогда, если вы хотите перезаписать свою последнюю строку, вам нужно добавить r (возврат символа) и end = «», чтобы вы не переходили к следующей строке.
Допустим так.
values = range(0, 101)
for i in values:
print («Complete: «, i, «%», end=»r»)
print («nr», end=»»)
Конечно можно попробовать и по-другому. К примеру так:
import sys
sys.stdout.write(‘text1…r’)
sys.stdout.write(‘text2…r’)
sys.stdout.write(‘text3…n’)
ответ дан 28 мая ’18 в 9:01
PashokPashok
41622 серебряных знака2020 бронзовых знаков
Всё ещё ищете ответ? Посмотрите другие вопросы с метками python windows cmd вывод или задайте свой вопрос.
Предлагаю читателям «Хабрахабра» перевод статьи «Python Tips, Tricks, and Hacks». Статья будет полезна на начальном и среднем этапах изучения Python.
Хотите писать более лаконичный и читаемый код? Вы хотите уместить как можно больше смысла в одно выражение? Считаете, что прочитать о нескольких уловках лучше, чем провести остаток жизни за чтением документации? Вы обратились по адресу. Мы начнем с маленьких уловок, которые вы уже могли встретить, если немного работали с Python. Но я обещаю, что ближе к концу статьи вас ожидает больше безумных вещей.
Содержание
1. Маленькие уловки. Четыре типа кавычек. Правдивость различных объектов. Проверка на вхождение подстроки. Красивый вывод списка. Целочисленное деление и деление с плавающей точкой. Лямбда-функции.
2. Списки. Генераторы списков и выражения-генераторы.
Я старался сделать, чтобы все фрагменты кода запускались без дополнительных изменений. Если хотите, можете скопировать их в оболочку Python и посмотреть, что получится. Обратите внимание, что многие примеры содержат «неправильные» фрагменты, которые закомментированы. Ничто вам не мешает раскомментировать строку и посмотреть, что произойдет.
Небольшое разграничение между true и True в этой статье: когда я говорю, что объект true, это значит, что будучи приведенным к типу boolean, он становится True. Аналогично с false и False.
1 Маленькие уловки
1.1 Четыре типа кавычек
Начнем с того, что вы, возможно, уже знаете. В некоторых языках программирования одинарные и двойные кавычки предназначены для разных вещей. Python позволяет использовать оба варианта (но строка должна начинаться и заканчиваться одним и тем же типом кавычек). В Python также есть еще два типа кавычек: »’ (тройные одинарные) и «»» (тройные двойные). Таким образом, можно использовать несколько уровней кавычек, прежде чем придется заботиться об их экранировании. Например, этот код правильный:
print «»»Я бы не хотел никогда услышать, как он говорит: »’Она сказала: «Он сказал: ‘Дай мне двести рублей'»»'»»»
1.2 Правдивость различных объектов
В отличие от некоторых языков программирования, в Python объект считается false, только если он пуст. Это значит, что не нужно проверять длину строки, кортежа или словаря — достаточно проверить его как логическое выражение.
Легко предсказать, что 0 — тоже false, а остальные числа — true.
Например, следующие выражения эквивалентны. В данном случае my_object — строка, но здесь мог оказаться другой тип (с соответствующими изменениями условий блока if).
my_object = ‘Test’ # True example
# my_object = » # False example
if len(my_object) > 0:
print ‘my_object не пуст’
if len(my_object): # 0 преобразовывается к False
print ‘my_object не пуст’
if my_object != »:
print ‘my_object не пуст’
if my_object: # пустая строка преобразовывается к False
print ‘my_object не пуст’
Итак, нет необходимости проверять длину объекта, если вас интересует только, пуст он или нет.
1.3 Проверка на вхождение подстроки
Это маленькая, довольно очевидная подсказка, но я узнал о ней лишь через год изучения Python. Должно быть, вы знаете, что можно проверить, содержится ли нужный элемент в кортеже, списке, словаре, с помощью конструкции ‘item in list’ или ‘item not in list’. Я не мог представить, что это сработает для строк. Я всегда писал что-то вроде этого:
string = ‘Hi there’ # True example
# string = ‘Good bye’ # False example
if string.find(‘Hi’) != -1:
print ‘Success!’
Этот код довольно неуклюжий. Совершенно так же работает ‘if substring in string’:
string = ‘Hi there’ # True example
# string = ‘Good bye’ # False example
if ‘Hi’ in string:
print ‘Success!’
Проще и понятней. Может быть, очевидно для 99% людей, но мне хотелось бы узнать об этом раньше, чем я узнал.
1.4 Красивый вывод списка
Обычный формат вывода списка с помощью print не очень удобен. Конечно, становится понятно, что из себя представляет список, но чаще всего пользователь не хочет видеть кавычки вокруг каждого элемента. Есть простое решение, использующее метод join строки:
recent_presidents = [‘Борис Ельцин’, ‘Владимир Путин’, ‘Дмитрий Медведев’]
print ‘Последними президентами были %s.’ % ‘, ‘.join(recent_presidents)
# печатает «Последними президентами были Борис Ельцин, Владимир Путин, Дмитрий Медведев.»
Метод join преобразовывает список в строку, рассматривая каждый элемент как строку. Разделителем является та строка, для которой был вызван join. Он достаточно умен, чтобы не вставлять разделитель после последнего элемента.
Дополнительный бонус: join работает линейное время. Никогда не создавайте строку складыванием элементов списка в цикле for: это не просто некрасиво, это занимает квадратичное время!
1.5 Целочисленное деление и деление с плавающей точкой
Если вы делите целое число на целое, по умолчанию результат обрезается до целого. Например, 5/2 вернет 2.
Есть два способа это исправить. Первый и самый простой способ заключается в том, чтобы преобразовать одно из чисел к типу float. Для констант достаточно добавить «.0» к одному из чисел: 5.0/2 вернет 2.5. Также вы можете использовать конструкцию float(5)/2.
Второй способ дает более чистый код, но вы должны убедиться, что ваша программа не сломается от этого существенного изменения. После вызова ‘from __future__ import division’ Python всегда будет возвращать в качестве результата деления float. Если вам понадобится целочисленное деление, используйте оператор //: 5//2 всегда возвращает 2.
5/2 # Возвращает 2
5.0/2 # Возвращает 2.5
float(5)/2 # Возвращает 2.5
5//2 # Возвращает 2
from __future__ import division
5/2 # Возвращает 2.5
5.0/2 # Возвращает 2.5
float(5)/2 # Возвращает 2.5
5//2 # Возвращает 2
В одной из следующих версий Python такое поведение станет дефолтным. Если вы хотите, чтобы ваш код оставался совместимым, используйте оператор // для целочисленного деления, даже если вы не используете этот импорт.
1.6 Лямбда-функции
Иногда нужно передать функцию в качестве аргумента или сделать короткую, но сложную операцию несколько раз. Можно определить функцию обычным способом, а можно использовать лямбда-функцию — маленькую функцию, возвращающую результат одного выражения. Следующие два определения полностью идентичны:
def add(a,b): return a+b
add2 = lambda a,b: a+b
Преимущество лямбда-функции в том, что она является выражением и может быть использована внутри другого выражения. Ниже приведен пример, использующий функцию map, которая вызывает функцию для каждого элемента списка и возвращает список результатов. (В следующем пункте я покажу, что map практически бесполезен. Но он дает нам возможность привести хороший пример в одну строку.)
squares = map(lambda a: a*a, [1,2,3,4,5])
# теперь squares = [1,4,9,16,25]
Без лямбда-функций нам пришлось бы определить функцию отдельно. Мы просто сэкономили одну строку кода и одно имя переменной.
Синтаксис лямбда-функции: lambda переменные: выражение
переменные — список аргументов, разделенных запятой. Нельзя использовать ключевые слова. Аргументы не надо заключать в скобки.
выражение — инлайновое выражение Python. Область видимости включает локальные переменные и аргументы. Функция возвращает результат этого выражения.
2 Списки
2.1 Генераторы списков
Если вы использовали Python достаточно долго, вы должны были хотя бы слышать о понятии «list comprehensions». Это способ уместить цикл for, блок if и присваивание в одну строку.
Другими словами, вы можете отображать (map) и фильтровать списки одним выражением.
2.1.1 Отображение списка
Начнем с простейшего примера. Допустим, нам надо возвести в квадрат все элементы списка. Свежеиспеченный программист на Python может написать код вроде этого:
numbers = [1,2,3,4,5]
squares = []
for number in numbers:
squares.append(number*number)
# теперь squares = [1,4,9,16,25]
Мы «отобразили» один список на другой. Это также можно сделать с помощью функции map:
numbers = [1,2,3,4,5]
squares = map(lambda x: x*x, numbers)
# теперь squares = [1,4,9,16,25]
Этот код определенно короче (одна строка вместо трех), но всё еще некрасив. С первого взгляда сложно сказать, что делает функция map (она принимает в качестве аргументов функцию и список и применяет функцию к каждому элементу списка). К тому же мы вынуждены определять функцию, это выглядит довольно беспорядочно. Если бы только существовал более красивый путь… например, генератор списка:
numbers = [1,2,3,4,5]
squares = [number*number for number in numbers]
# и снова squares = [1,4,9,16,25]
Этот код делает абсолютно то же самое, но он короче, чем первый пример, и понятней, чем второй. Человек без проблем определит, что делает код, для этого даже не обязательно знать Python.
2.1.2 Фильтрация списка
А что, если нас интересует фильтрация списка? Например, требуется удалить элементы, большие или равные 4. (Да, примеры не очень реалистичны. Как бы то ни было…)
Новичок напишет так:
numbers = [1,2,3,4,5]
numbers_under_4 = []
for number in numbers:
if number < 4:
numbers_under_4.append(number)
# numbers_under_4 = [1,4,9]
Очень просто, не так ли? Но код занимает 4 строки, содержит два уровня отступов и при этом делает тривиальную вещь. Можно уменьшить размер кода с помощью функции filter:
numbers = [1,2,3,4,5]
numbers_under_4 = filter(lambda x: x < 4, numbers)
# numbers_under_4 = [1,2,3]
Аналогично функции map, о которой мы говорили выше, filter сокращает код, но выглядит довольно уродливо. Что, черт возьми, происходит? Как и map, filter получает функцию и список. Если функция от элемента возвращает true, элемент включается в результирующий список. Разумеется, мы можем сделать это через генератор списка:
numbers = [1,2,3,4,5]
numbers_under_4 = [number for number in numbers if number < 4]
# numbers_under_4 = [1,2,3]
Снова мы получили более короткий, ясный и понятный код.
2.1.3 Одновременное использование map и filter
Теперь мы можем использовать всю силу генератора списков. Если я вас еще не убедил, что map и filter тратят слишком много вашего времени, надеюсь, теперь вы со мной согласитесь.
Пусть требуется отобразить и отфильтровать список одновременно. Другими словами, я хочу увидеть квадраты элементов списка, меньших 4. Еще раз, неофит напишет так:
numbers = [1,2,3,4,5]
squares = []
for number in numbers:
if number < 4:
squares.append(number*number)
# squares = [1,4,9]
Увы, код начал растягиваться вправо. Может, получится упростить его? Попробуем использовать map и filter, но у меня плохое предчувствие…
numbers = [1,2,3,4,5]
squares = map(lambda x: x*x, filter(lambda x: x < 4, numbers))
# squares is = [1,4,9]
Раньше map и filter было трудно читать, теперь — невозможно. Очевидно, это не лучшая идея. И снова генератор списков спасает ситуацию:
numbers = [1,2,3,4,5]
squares = [number*number for number in numbers if number < 4]
# square = [1,4,9]
Получилось немного длиннее, чем предыдущие примеры с генератором списков, но, по моему мнению, вполне читабельно. Определенно лучше, чем цикл for или использование map и filter.
Как вы видите, генератор списков сначала фильтрует, а затем отображает. Если вам обязательно нужно наоборот, получится сложнее. Придется использовать либо вложенные генерации, либо map и filter, либо обычный цикл for, в зависимости от того, что проще. Но это уже выходит за рамки статьи.
Синтаксис генератора списков: [ element for variable(s) in list if condition ]
list — любой итерируемый элемент
variable(s) — переменная или переменные, которые приравниваются к текущему элементу списка, аналогично циклу for
condition — инлайновое выражение: если оно равно true, элемент добавляется в результат
element — инлайновое выражение, результат которого используется как элемент списка-результата
2.1.4 Выражения-генераторы
Существует обратная сторона генератора списков: весь список должен находиться в памяти. Это не проблема для маленьких списков, как в предыдущих примерах, и даже на несколько порядков больше. Но в конце концов это становится неэффективным.
Выражения-генераторы (Generator Expressions) появились в Python 2.4. Из всех фишек Python им уделяется, наверно, меньше всего внимания. Отличие их от генераторов списков состоит в том, что они не загружают в память список целиком, а создают ‘generator object’, и в каждый момент загружен только один элемент списка.
Конечно, если вы хотите использовать список для чего-нибудь, это не особо поможет. Но если вы просто передаете его куда-нибудь, где нужен любой итерируемый объект (цикл for, например), стоит использовать функцию генератора.
Выражения-генераторы имеют такой же синтаксис, как генераторы списков, но вместо квадратных скобок используются круглые:
numbers = (1,2,3,4,5) # мы стремимся к эффективной работе, поэтому используем кортеж вместо списка 😉
squares_under_10 = (number*number for number in numbers if number*number < 10)
# squares_under_10 — generator object, из которого можно получить следующее значение, вызвав метод .next()
for square in squares_under_10:
print square,
#выводит ‘1 4 9’
Это более эффективно, чем использование генератора списков.
Итак, имеет смысл использовать выражения-генераторы для списков больших размеров. Если весь список целиком нужен вам для какой-то другой цели, то можно использовать любой из вариантов. Но использовать выражения-генераторы — хорошая привычка, если нет аргументов против этого. Правда, не надейтесь увидеть ускорение работы, если список небольшой.
В качестве финального штриха хочу заметить, что выражения-генераторы достаточно заключить в одни круглые скобки. Например, в случае, если вы вызываете функцию с одним аргументом, можно писать так: some_function(item for item in list).
2.1.5 Заключение
Мне не хочется этого говорить, но мы только прикоснулись к тому, что можно делать с помощью выражений-генераторов и генераторов списков. Здесь можно использовать всю силу for и if, а также оперировать с чем угодно, лишь бы оно было итерируемым объектом.
Статья целиком в PDF
Python — это язык, который любят многие программисты. Этим языком невероятно легко пользоваться. Всё дело в том, что код, написанный на Python, отличается интуитивной понятностью и хорошей читабельностью. Однако в разговорах о Python часто можно слышать одну и ту же жалобу на этот язык. Особенно тогда, когда о Python говорят знатоки языка C. Вот как она звучит: «Python — это медленно». И те, кто так говорят, не грешат против истины.
В сравнении со многими другими языками программирования Python — это, и правда, медленно. Вот результаты испытаний, в ходе которых сопоставляется производительность разных языков программирования при решении различных задач.
Есть несколько способов ускорения Python-программ. Например, можно применять библиотеки, рассчитанные на использование нескольких ядер процессора. Тем, кто работает с Numpy, Pandas или Scikit-Learn, можно посоветовать взглянуть на программный комплекс Rapids, позволяющий задействовать GPU при проведении научных расчётов.
Все эти методики ускорения работы хороши в тех случаях, когда решаемые с помощью Python задачи могут быть распараллелены. Например — это задачи по предварительной обработке данных или операции с матрицами.
Но как быть в том случае, если ваш код — это чистый Python? Что если у вас есть большой цикл for, который вам совершенно необходимо использовать, и выполнение которого просто нельзя распараллелить из-за того, что обрабатываемые в нём данные должны обрабатываться последовательно? Можно ли как-то ускорить сам Python?
Ответ на этот вопрос даёт Cython — проект, используя который можно значительно ускорить код, написанный на Python.
Что такое Cython?
Cython, по своей сути, это промежуточный слой между Python и C/C++. Cython позволяет писать обычный Python-код с некоторыми незначительными модификациями, который затем напрямую транслируется в C-код.
Единственное изменение Python-кода при этом заключается в добавлении к каждой переменной информации об её типе. При написании обычного кода на Python переменную можно объявить так:
x = 0.5
При использовании Cython при объявлении переменной нужно указать её тип:
cdef float x = 0.5
Эта конструкция сообщает Cython о том, что переменная представляет собой число с плавающей точкой. По такому же принципу объявляют переменные и в C. При использовании обычного Python типы переменных определяются динамически. Явное объявление типов, применяемое в Cython — это то, что делает возможным преобразование Python-кода в C-код. Дело в том, что в C необходимо явное объявление типов переменных.
Установка Cython предельно проста:
pip install cython
Типы в Cython
При использовании Cython можно выделить два набора типов. Один — для переменных, второй — для функций.
Если речь идёт о переменных, то тут нам доступны следующие типы:
- cdef int a, b, c
- cdef char *s
- cdef float x = 0.5 (число одинарной точности)
- cdef double x = 63.4 (число двойной точности)
- cdef list names
- cdef dict goals_for_each_play
- cdef object card_deck
Обратите внимание на то, что тут, фактически, показаны типы C/C++!
При работе с функциями нам доступны следующие типы:
- def — обычная Python-функция, вызывается только из Python.
- cdef — Cython-функция, которую нельзя вызвать из обычного Python-кода. Такие функции можно вызывать только в пределах Cython-кода.
- cpdef — Функция, доступ к которой можно получить и из C, и из Python.
Теперь, когда мы разобрались с типами Python, можно заняться ускорением Python-кода.
Ускорение кода с использованием Cython
Начнём с создания Python-бенчмарка. Это будет цикл for, в котором выполняется вычисление факториала числа. Соответствующий код на чистом Python будет выглядеть так:
def test(x):
y = 1
for i in range(1, x+1):
y *= i
return y
Cython-эквивалент этой функции очень похож на её исходный вариант. Соответствующий код нужно поместить в файл с расширением .pyx. Единственное изменение, которое нужно внести в код, заключается в добавлении в него сведений о типах переменных и функции:
cpdef int test(int x):
cdef int y = 1
cdef int i
for i in range(1, x+1):
y *= i
return y
Обратите внимание на то, что перед функцией стоит ключевое слово cpdef. Это позволяет вызывать данную функцию из Python. Кроме того, тип назначен и переменной i, играющей роль счётчика цикла. Не будем забывать о том, что типизировать нужно все переменные, объявленные в функции. Это позволит компилятору C узнать о том, какие именно типы ему использовать.
Теперь создадим файл setup.py, который поможет нам преобразовать Cython-код в C-код:
from distutils.core import setup
from Cython.Build import cythonize
setup(ext_modules = cythonize(‘run_cython.pyx’))
Выполним компиляцию:
python setup.py build_ext —inplace
Теперь С-код готов к использованию.
Если взглянуть в папку, в которой находится Cython-код, там можно будет найти все файлы, необходимые для запуска C-кода, включая файл run_cython.c. Если вам интересно — откройте этот файл и посмотрите на то, какой С-код сгенерировал Cython.
Теперь всё готово к тестированию нашего сверхбыстрого C-кода. Ниже приведён код, используемый для тестирования и сравнения двух вариантов программы.
import run_python
import run_cython
import time
number = 10
start = time.time()
run_python.test(number)
end = time.time()
py_time = end — start
print(«Python time = {}».format(py_time))
start = time.time()
run_cython.test(number)
end = time.time()
cy_time = end — start
print(«Cython time = {}».format(cy_time))
print(«Speedup = {}».format(py_time / cy_time))
Код этот устроен очень просто. Мы импортируем необходимые файлы — так же, как импортируются обычные Python-файлы, после чего вызываем соответствующие функции, делая это так же, как если бы мы всё время работали бы с обычными Python-функциями.
Взгляните на следующую таблицу. Можно заметить, что Cython-версия программы оказывается быстрей её Python-версии во всех случаях. Чем масштабнее задача — тем больше и ускорение, которое даёт использование Cython.
Итоги
Использование Cython позволяет значительно ускорить практически любой код, написанный на Python, не прилагая к этому особенных усилий. Чем больше в программе циклов и чем больше данных она обрабатывает — тем лучших результатов можно ждать от применения Cython.
Уважаемые читатели! Используете ли вы Cython в своих проектах?