Использование vmin
и vmax
заставляет диапазон для цветов. Вот пример:
import matplotlib as m
import matplotlib.pyplot as plt
import numpy as np
cdict = {
'red' : ( (0.0, 0.25, .25), (0.02, .59, .59), (1., 1., 1.)),
'green': ( (0.0, 0.0, 0.0), (0.02, .45, .45), (1., .97, .97)),
'blue' : ( (0.0, 1.0, 1.0), (0.02, .75, .75), (1., 0.45, 0.45))
}
cm = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
x = np.arange(0, 10, .1)
y = np.arange(0, 10, .1)
X, Y = np.meshgrid(x,y)
data = 2*( np.sin(X) + np.sin(3*Y) )
def do_plot(n, f, title):
#plt.clf()
plt.subplot(1, 3, n)
plt.pcolor(X, Y, f(data), cmap=cm, vmin=-4, vmax=4)
plt.title(title)
plt.colorbar()
plt.figure()
do_plot(1, lambda x:x, "all")
do_plot(2, lambda x:np.clip(x, -4, 0), "<0")
do_plot(3, lambda x:np.clip(x, 0, 4), ">0")
plt.show()
Если Вы представляете свой класс через библиотеку, которой будут пользоваться другие, Вы обычно хотите представить его через интерфейсы, а не конкретные реализации. Это поможет, если Вы решите изменить реализацию своего класса позже для использования различного реального класса. В этом случае пользователи Вашей библиотеки не должны будут обновлять свой код, так как интерфейс не изменяется.
, Если Вы просто используете его внутренне, Вы не можете заботиться так, и использование List<T>
может быть в порядке.
Самый важный случай для использования интерфейсов по реализациям находится в параметрах к Вашему API. Если Ваш API берет параметр Списка, то любой, кто использует его, должен использовать Список. Если тип параметра является IList, то вызывающая сторона имеет намного больше свободы и может использовать классы, о которых Вы никогда не слышали, который даже не мог существовать, когда Ваш код был записан.
Принцип TDD и ООП обычно программирует к интерфейсу не реализацию.
В этом конкретном случае, так как Вы по существу говорите о конструкции языка, не пользовательской, он обычно не будет иметь значения, но говорить, например, что Вы нашли, Список не поддерживал что-то, в чем Вы нуждались. При использовании IList в остальной части приложения, Вы могли бы расширить Список с помощью своего собственного класса и все еще быть в состоянии раздать это без рефакторинга.
стоимость, чтобы сделать это минимально, почему бы не сохранить себя головная боль позже? Это - то, о чем интерфейсный принцип - все.
Вы были бы, потому что определение IList или ICollection откроется для других реализаций Ваших интерфейсов.
Вы могли бы хотеть иметь IOrderRepository, который определяет набор заказов или в IList или в ICollection. У Вас могли тогда быть различные виды реализаций для обеспечения списка заказов, пока они соответствуют "правилам", определенным IList или ICollection.
IList< T> интерфейс, таким образом, можно наследовать другой класс и все еще реализовать IList< T> при наследовании List< T> предотвращает Вас, чтобы сделать так.
, Например, если существует класс A и Ваш класс B, наследовал его тогда, Вы не можете использовать List< T>
class A : B, IList<T> { ... }
List<T>
определенная реализация IList<T>
, который является контейнером, который может быть обращен тот же путь как линейная матрица T[]
с помощью целочисленного индекса. Когда Вы определяете IList<T>
как тип аргумента метода, Вы только определяете необходимость в определенных возможностях контейнера.
, Например, интерфейсная спецификация не осуществляет определенную структуру данных, которая будет использоваться. Реализация List<T>
происходит с той же производительностью для доступа, удаления и добавления элементов как линейная матрица. Однако Вы могли вообразить реализацию, которая поддерживается связанным списком вместо этого, для которого добавление элементов до конца является более дешевым (постоянно-разовым), но намного более дорогим произвольным доступом. (Обратите внимание, что.NET LinkedList<T>
делает не реализация IList<T>
.)
Этот пример также говорит Вам, что могут быть ситуации, когда необходимо определить реализацию, не интерфейс, в списке аргументов: В этом примере, каждый раз, когда Вы требуете конкретной рабочей характеристики доступа. Это обычно гарантируется для определенной реализации контейнера (List<T>
документация: "Это реализует IList<T>
универсальный интерфейс с помощью массива, размер которого динамично увеличен как требуется".).
Кроме того, Вы могли бы хотеть рассмотреть представление наименьшего количества функциональности, в которой Вы нуждаетесь. Например. если Вы не должны изменять содержание списка, необходимо, вероятно, рассмотреть использование IEnumerable<T>
, который IList<T>
расширяется.
public void Foo(IList<Bar> list)
{
// Do Something with the list here.
}
В этом случае Вы могли передать в любом классе, который реализует IList< Панель> интерфейс. Если Вы использовали List< Панель> вместо этого, только List< Панель> экземпляр могла быть передана в.
IList< Панель> путь более слабо связывается, чем List< Панель> путь.
realloc
. Это могло бы копия и перемещать весь блок памяти, таким образом, it' s не дешевый. linux.die.net/man/3/realloc
– gnud
4 December 2010 в 11:04
Интерфейс является обещанием (или контракт).
, Поскольку это всегда с обещаниями - меньше лучше .
Я бы немного перевернул вопрос, вместо того, чтобы объяснять, почему вы должны использовать интерфейс вместо конкретной реализации, попытайтесь обосновать, почему вы должны использовать конкретную реализацию, а не интерфейс. Если вы не можете это оправдать, воспользуйтесь интерфейсом.
Менее популярным ответом является то, что программисты любят притворяться, что их программное обеспечение будет повторно использоваться во всем мире, когда на самом деле большинство проектов будет поддерживаться небольшим количеством людей и какими бы хорошими ни были звуковые фрагменты, связанные с интерфейсом, - это вы себя обманываете.
Архитектура Astronauts . Вероятность того, что вы когда-нибудь напишете свой собственный список IList, который добавит что-нибудь к уже имеющимся в .NET Framework, настолько мала, что это теоретические заморочки, зарезервированные для "лучших практик".
Очевидно, если вас спросят, что вы используете в Интервью, говорите вы Iist, улыбайтесь, и оба выглядят довольными своей умной способностью. Или для общедоступного API, IList. Надеюсь, вы поняли мою точку зрения.
Интерфейс гарантирует, что вы, по крайней мере, получите ожидаемые методы ; осведомленность об определении интерфейса, т.е. все абстрактные методы, которые должны быть реализованы любым классом, наследующим интерфейс. поэтому, если кто-то создает собственный огромный класс с несколькими методами, помимо тех, которые он унаследовал от интерфейса для некоторых дополнительных функций, и они бесполезны для вас, лучше использовать ссылку на подкласс (в этом случае interface) и назначьте ему конкретный объект класса.
Дополнительным преимуществом является то, что ваш код защищен от любых изменений конкретного класса, поскольку вы подписываетесь только на несколько методов конкретного класса, и это те, которые будут там до тех пор, пока конкретный класс наследуется от интерфейс, который вы используете. так что это безопасность для вас и свобода для кодировщика, который пишет конкретную реализацию, для изменения или добавления дополнительных функций в свой конкретный класс.