На мой взгляд, покрытие кода - это хороший способ увидеть, пропустили ли вы какую-либо функциональность, которую вы должны покрыть.
Когда вы проверяете покрытие вручную с помощью его красивой раскраски, можно утверждать, что простые геттеры и сеттеры не нуждаются в проверке (хотя я всегда это делаю).
Когда вы только проверьте процент покрытия кода на свой проект, тогда процент покрытия, равный 80%, не имеет смысла. Вы можете проверить все логические части и забыть некоторые важные части. В этом случае только 100% означает, что вы протестировали весь ваш жизненно важный код (и весь нелогичный код). Как только это 99,9%, вы знаете, что что-то забыли.
Кстати: покрытие кода - это окончательная проверка, чтобы проверить, полностью ли вы тестировали класс. Но 100% охват кода не обязательно означает, что вы действительно протестировали все функциональные возможности этого класса. Поэтому модульные тесты всегда должны выполняться по логике класса. В конце вы запустите покрытие, чтобы узнать, не забыли ли вы что-нибудь. Когда вы сделали это правильно, вы попали на 100% в первый раз.
Еще одно: недавно работая в большом банке в Нидерландах, я заметил, что Sonar указала 100% -ный охват кода. Однако я знал, что чего-то не хватает. Проверяя процент заполнения кода на файл, он указал файл с меньшим процентом. Весь процент кодовой базы был таким большим, что в одном файле процент не отображался как 99,9%. Так что вы можете посмотреть на это ...
Это несколько зависит, на какой платформе Вы идете. Наиболее распространенный способ сделать это путем печати escape-последовательностей ANSI. Для простого примера вот некоторый код Python от сценарии сборки блендера :
class bcolors:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
Для использования кода как это можно сделать что-то как [1 111]
print bcolors.WARNING + "Warning: No active frommets remain. Continue?"
+ bcolors.ENDC
, Это будет работать над unixes включая OS X, Linux и окна (если Вы используете ANSICON, или в Windows 10, если Вы включаете эмуляция VT100 ). Существуют коды ANSI для того, чтобы выбрать цвет, перемещая курсор, и т.д.
, Если Вы собираетесь быть сложными с этим (и это походит, Вы - то, если Вы пишете игру), необходимо изучить модуль "проклятий", который обрабатывает много сложных частей этого для Вас. HowTO Проклятий Python является хорошим введением.
, Если Вы не используете расширенный ASCII (т.е. не на ПК), Вы застреваете с символами ASCII ниже 127, и '#' или является, вероятно, Вашим лучшим выбором для блока. Если можно удостовериться, что терминал использует расширенный набор символов ASCII IBM , у Вас есть намного больше опций. Символы 176, 177, 178 и 219 являются "символами блока".
Некоторые современные основанные на тексте программы, такие как "Карликовая Крепость", эмулируют текстовый режим в графическом режиме и используют изображения классического шрифта ПК. Можно найти некоторые из этих битовых массивов, которые можно использовать на , Карликовая крепость Wiki видит ( сделанный пользователем tilesets).
Конкурс Демонстрации Текстового режима имеет больше ресурсов для того, чтобы сделать графику в текстовом режиме.
Хм.. Я думаю, увлекся немного на этом ответе. Я посреди планирования эпической основанной на тексте игры приключения, все же. Удача с Вашим цветным текстом!
asciimatics обеспечивает портативную поддержку для создания текстового пользовательского интерфейса и анимации:
#!/usr/bin/env python
from asciimatics.effects import RandomNoise # $ pip install asciimatics
from asciimatics.renderers import SpeechBubble, Rainbow
from asciimatics.scene import Scene
from asciimatics.screen import Screen
from asciimatics.exceptions import ResizeScreenError
def demo(screen):
render = Rainbow(screen, SpeechBubble('Rainbow'))
effects = [RandomNoise(screen, signal=render)]
screen.play([Scene(effects, -1)], stop_on_resize=True)
while True:
try:
Screen.wrapper(demo)
break
except ResizeScreenError:
pass
Asciicast:
https://raw.github.com/fabric/fabric/master/fabric/colors.py
"""
.. versionadded:: 0.9.2
Functions for wrapping strings in ANSI color codes.
Each function within this module returns the input string ``text``, wrapped
with ANSI color codes for the appropriate color.
For example, to print some text as green on supporting terminals::
from fabric.colors import green
print(green("This text is green!"))
Because these functions simply return modified strings, you can nest them::
from fabric.colors import red, green
print(red("This sentence is red, except for " + \
green("these words, which are green") + "."))
If ``bold`` is set to ``True``, the ANSI flag for bolding will be flipped on
for that particular invocation, which usually shows up as a bold or brighter
version of the original color on most terminals.
"""
def _wrap_with(code):
def inner(text, bold=False):
c = code
if bold:
c = "1;%s" % c
return "\033[%sm%s\033[0m" % (c, text)
return inner
red = _wrap_with('31')
green = _wrap_with('32')
yellow = _wrap_with('33')
blue = _wrap_with('34')
magenta = _wrap_with('35')
cyan = _wrap_with('36')
white = _wrap_with('37')
Еще один модуль pypi, который включает в себя функцию печати python 3:
https://pypi.python.org/pypi/colorprint
Он применим в python 2.x если вы тоже from __future__ import print
. Вот пример Python 2 со страницы Pypi для модулей:
from __future__ import print_function
from colorprint import *
print('Hello', 'world', color='blue', end='', sep=', ')
print('!', color='red', format=['bold', 'blink'])
Вывод «Hello, world!» со словами в синем и восклицательным знаком, выделенным красным и мигающим.
# Pure Python 3.x demo, 256 colors
# Works with bash under Linux and MacOS
fg = lambda text, color: "\33[38;5;" + str(color) + "m" + text + "\33[0m"
bg = lambda text, color: "\33[48;5;" + str(color) + "m" + text + "\33[0m"
def print_six(row, format):
for col in range(6):
color = row*6 + col + 4
if color>=0:
text = "{:3d}".format(color)
print (format(text,color), end=" ")
else:
print(" ", end=" ")
for row in range(-1,42):
print_six(row, fg)
print("",end=" ")
print_six(row, bg)
print()
# Simple usage: print(fg("text", 160))
Если вы используете Джанго
>>> from django.utils.termcolors import colorize
>>> print colorize("Hello World!", fg="blue", bg='red',
... opts=('bold', 'blink', 'underscore',))
Hello World!
>>> help(colorize)
снимок:
(я обычно использую цветной вывод для отладка на терминале сервера выполнения, поэтому я добавил его.)
Вы можете проверить, установлен ли он на вашем компьютере:
$ python -c "import django; print django.VERSION"
Чтобы установить его, проверьте: Как установить Django
Попробуйте! !!
Ваш терминал, скорее всего, использует символы Unicode (обычно в кодировке UTF-8), поэтому выбор подходящего шрифта для просмотра вашего любимого символа - это только вопрос. Я использую Unicode char U + 2588, «Полный блок».
Попробуйте следующее:
import unicodedata
fp= open("character_list", "w")
for index in xrange(65536):
char= unichr(index)
try: its_name= unicodedata.name(char)
except ValueError: its_name= "N/A"
fp.write("%05d %04x %s %s\n" % (index, index, char.encode("UTF-8"), its_name)
fp.close()
Изучите файл позже с вашим любимым зрителем.
curses - это модуль, который вы хотите использовать. Проверьте это учебник .
Если вы программируете игру, возможно, вы хотели бы изменить цвет фона и использовать только пробелы? Например:
print " "+ "\033[01;41m" + " " +"\033[01;46m" + " " + "\033[01;42m"
Ответ - Colorama для всех кроссплатформенных раскрасок в Python.
Вы можете использовать CLINT:
from clint.textui import colored
print colored.red('some warning message')
print colored.green('nicely done!')
Вы можете использовать экранирующие символы оболочки, доступные на любом языке. Эти escape-символы начинаются с символа ESC, за которым следует ряд аргументов.
Например, для вывода красной строки Hello world
в вашем терминале:
echo "\e[31m Hello world \e[0m"
Или из скрипта на python:
print("\e[31m Hello world \e[0m")
Кроме того, я написал статью о Побег последовательности , которые могут помочь вам лучше понять этот механизм. Я надеюсь, что это поможет вам.
Мои два цента ( PyColorTerm ):
Установка:
sudo apt-get install python-pip
pip install pycolorterm
Скрипт Python:
from pycolorterm import pycolorterm
with pycolorterm.pretty_output(pycolorterm.FG_GREEN) as out:
out.write('Works OK!')
«работает нормально!» показывает зеленым.
Я закончил тем, что делал это, я чувствовал, что это было самым чистым:
formatters = {
'RED': '\033[91m',
'GREEN': '\033[92m',
'END': '\033[0m',
}
print 'Master is currently {RED}red{END}!'.format(**formatters)
print 'Help make master {GREEN}green{END} again!'.format(**formatters)
Вы хотите узнать о escape-последовательностях ANSI. Вот краткий пример:
CSI="\x1B["
print(CSI+"31;40m" + "Colored Text" + CSI + "0m")
Для большего количества информации видят http://en.wikipedia.org/wiki/ANSI_escape_code
Для символа блока, пробуют unicode символ как \u2588:
print(u"\u2588")
Соединение всего этого:
print(CSI+"31;40m" + u"\u2588" + CSI + "0m")
Я удивлен, что никто не упомянул Python termcolor модуль . Использование довольно просто:
from termcolor import colored
print colored('hello', 'red'), colored('world', 'green')
Или в Python 3:
print(colored('hello', 'red'), colored('world', 'green'))
Это не может быть достаточно сложно, однако, для игрового программирования и "цветных блоков", которые Вы хотите сделать...
sty похож на colorama, но он менее многословный, поддерживает 8bit и 24bit (rgb) цветов, позволяет регистрировать собственные цвета, действительно гибкий и хорошо документированный.
from sty import fg, bg, ef, rs, RgbFg
foo = fg.red + 'This is red text!' + fg.rs
bar = bg.blue + 'This has a blue background!' + bg.rs
baz = ef.italic + 'This is italic text' + rs.italic
qux = fg(201) + 'This is pink text using 8bit colors' + fg.rs
qui = fg(255, 10, 10) + 'This is red text using 24bit colors.' + fg.rs
# Add new colors:
fg.set_style('orange', RgbFg(255, 150, 50))
buf = fg.orange + 'Yay, Im orange.' + fg.rs
print(foo, bar, baz, qux, qui, buf, sep='\n')
печатает:
обратите внимание, насколько хорошо ключевое слово with
смешивается с такими модификаторами, которые необходимо сбросить (используя Python 3 и Colorama):
from colorama import Fore, Style
import sys
class Highlight:
def __init__(self, clazz, color):
self.color = color
self.clazz = clazz
def __enter__(self):
print(self.color, end="")
def __exit__(self, type, value, traceback):
if self.clazz == Fore:
print(Fore.RESET, end="")
else:
assert self.clazz == Style
print(Style.RESET_ALL, end="")
sys.stdout.flush()
with Highlight(Fore, Fore.GREEN):
print("this is highlighted")
print("this is not")
Можно использовать реализацию Python библиотеки проклятий: http://docs.python.org/library/curses.html
кроме того, выполняет это, и Вы найдете свое поле:
for i in range(255):
print i, chr(i)
Определите строку, начинающую цвет, и строку, оканчивающую цвет, затем напечатайте текст с начальной строкой впереди и конечной строкой в конце.
CRED = '\033[91m'
CEND = '\033[0m'
print(CRED + "Error, does not compute!" + CEND)
Это приводит к следующему в bash
, в urxvt
с цветовой схемой в стиле Ценберна:
Экспериментируя, мы можем получить больше цветов:
Примечание: \33[5m
и \33[6m
мигают.
Таким образом, мы можем создать полную коллекцию цветов:
CEND = '\33[0m'
CBOLD = '\33[1m'
CITALIC = '\33[3m'
CURL = '\33[4m'
CBLINK = '\33[5m'
CBLINK2 = '\33[6m'
CSELECTED = '\33[7m'
CBLACK = '\33[30m'
CRED = '\33[31m'
CGREEN = '\33[32m'
CYELLOW = '\33[33m'
CBLUE = '\33[34m'
CVIOLET = '\33[35m'
CBEIGE = '\33[36m'
CWHITE = '\33[37m'
CBLACKBG = '\33[40m'
CREDBG = '\33[41m'
CGREENBG = '\33[42m'
CYELLOWBG = '\33[43m'
CBLUEBG = '\33[44m'
CVIOLETBG = '\33[45m'
CBEIGEBG = '\33[46m'
CWHITEBG = '\33[47m'
CGREY = '\33[90m'
CRED2 = '\33[91m'
CGREEN2 = '\33[92m'
CYELLOW2 = '\33[93m'
CBLUE2 = '\33[94m'
CVIOLET2 = '\33[95m'
CBEIGE2 = '\33[96m'
CWHITE2 = '\33[97m'
CGREYBG = '\33[100m'
CREDBG2 = '\33[101m'
CGREENBG2 = '\33[102m'
CYELLOWBG2 = '\33[103m'
CBLUEBG2 = '\33[104m'
CVIOLETBG2 = '\33[105m'
CBEIGEBG2 = '\33[106m'
CWHITEBG2 = '\33[107m'
Вот код для генерации теста:
x = 0
for i in range(24):
colors = ""
for j in range(5):
code = str(x+j)
colors = colors + "\33[" + code + "m\\33[" + code + "m\033[0m "
print(colors)
x=x+5
В Windows вы можете использовать модуль 'win32console' (доступный в некоторых дистрибутивах Python) или модуль 'ctypes' (Python 2.5 и выше) для доступа к Win32 API.
Чтобы увидеть полный код, который поддерживает оба способа, см. Код сообщения о консоли цвета из Testoob .
Пример ctypes:
import ctypes
# Constants from the Windows API
STD_OUTPUT_HANDLE = -11
FOREGROUND_RED = 0x0004 # text color contains red.
def get_csbi_attributes(handle):
# Based on IPython's winconsole.py, written by Alexander Belchenko
import struct
csbi = ctypes.create_string_buffer(22)
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(handle, csbi)
assert res
(bufx, bufy, curx, cury, wattr,
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
return wattr
handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
reset = get_csbi_attributes(handle)
ctypes.windll.kernel32.SetConsoleTextAttribute(handle, FOREGROUND_RED)
print "Cherry on top"
ctypes.windll.kernel32.SetConsoleTextAttribute(handle, reset)
Я обернул ответ @joeld в модуль с глобальными функциями, которые я могу использовать в любом месте своего кода.
файл: log.py
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = "\033[1m"
def disable():
HEADER = ''
OKBLUE = ''
OKGREEN = ''
WARNING = ''
FAIL = ''
ENDC = ''
def infog( msg):
print OKGREEN + msg + ENDC
def info( msg):
print OKBLUE + msg + ENDC
def warn( msg):
print WARNING + msg + ENDC
def err( msg):
print FAIL + msg + ENDC
использовать следующим образом:
import log
log.info("Hello World")
log.err("System Error")
Для Windows Вы не можете распечатать к консоли с цветами, если Вы не используете win32api.
Для Linux это столь же просто как использующий печать с escape-последовательностями, обрисованными в общих чертах здесь:
Для символа для печати как поле это действительно зависит, на каком шрифте Вы используете для консоли. Символ фунта работает хорошо, но он зависит от шрифта:
#
Мой любимый способ - использовать библиотеку Благословения (полное раскрытие: я ее написал). Например:
from blessings import Terminal
t = Terminal()
print t.red('This is red.')
print t.bold_bright_red_on_black('Bright red on black')
Для печати цветных кубиков наиболее надежным способом является печать пробелов с фоновыми цветами. Я использую эту технику, чтобы нарисовать индикатор выполнения в прогрессивный нос :
print t.on_green(' ')
Вы также можете печатать в определенных местах:
with t.location(0, 5):
print t.on_yellow(' ')
Если у вас есть чтобы использовать другие возможности терминала в ходе вашей игры, вы также можете сделать это. Вы можете использовать стандартное форматирование строк Python, чтобы сделать его читабельным:
print '{t.clear_eol}You just cleared a {t.bold}whole{t.normal} line!'.format(t=t)
Хорошая особенность Blessings в том, что он старается работать со всеми видами терминалов, а не только с (в подавляющем большинстве распространенным) цветом ANSI из них. Он также сохраняет нечитаемые escape-последовательности в вашем коде, оставаясь при этом лаконичным в использовании. Веселись!
Я написал простой модуль, доступный по адресу: http://pypi.python.org/pypi/colorconsole
Он работает с Windows, Mac OS X и Linux. Он использует ANSI для Linux и Mac, но имеет собственные вызовы консольных функций в Windows. У вас есть цвета, позиционирование курсора и ввод с клавиатуры. Он не заменяет проклятия, но может быть очень полезен, если вам нужно использовать его в простых скриптах или играх ASCII.
def black(text):
print('\033[30m', text, '\033[0m', sep='')
def red(text):
print('\033[31m', text, '\033[0m', sep='')
def green(text):
print('\033[32m', text, '\033[0m', sep='')
def yellow(text):
print('\033[33m', text, '\033[0m', sep='')
def blue(text):
print('\033[34m', text, '\033[0m', sep='')
def magenta(text):
print('\033[35m', text, '\033[0m', sep='')
def cyan(text):
print('\033[36m', text, '\033[0m', sep='')
def gray(text):
print('\033[90m', text, '\033[0m', sep='')
black("BLACK")
red("RED")
green("GREEN")
yellow("YELLOW")
blue("BLACK")
magenta("MAGENTA")
cyan("CYAN")
gray("GRAY")
Вот пример проклятия:
import curses
def main(stdscr):
stdscr.clear()
if curses.has_colors():
for i in xrange(1, curses.COLORS):
curses.init_pair(i, i, curses.COLOR_BLACK)
stdscr.addstr("COLOR %d! " % i, curses.color_pair(i))
stdscr.addstr("BOLD! ", curses.color_pair(i) | curses.A_BOLD)
stdscr.addstr("STANDOUT! ", curses.color_pair(i) | curses.A_STANDOUT)
stdscr.addstr("UNDERLINE! ", curses.color_pair(i) | curses.A_UNDERLINE)
stdscr.addstr("BLINK! ", curses.color_pair(i) | curses.A_BLINK)
stdscr.addstr("DIM! ", curses.color_pair(i) | curses.A_DIM)
stdscr.addstr("REVERSE! ", curses.color_pair(i) | curses.A_REVERSE)
stdscr.refresh()
stdscr.getch()
if __name__ == '__main__':
print "init..."
curses.wrapper(main)