Каковы некоторые хорошие примеры Mixins и или Черты?
Ваше регулярное выражение не работает, как вы использовали \1 при замене, но шаблон регулярного выражения не имеет соответствующей группы захвата. \1 относится к первой группе захвата в шаблоне.
Если вы хотите попробовать свои силы в регулярных выражениях, вы можете использовать
re.sub(r'^(\d+)-(\d+)-(\d+) См. Демо Python .
Здесь ^(\d+)-(\d+)-(\d+)$ соответствует строке, которая начинается с 1+ цифр, затем имеет -, затем 1+ цифр, - и снова 1+ цифр, за которыми следует конец строки. Существуют три группы захвата, значения которых можно ссылаться с помощью обратных ссылок \1, \2 и \3 из шаблона замены. Однако, поскольку нам нужно применить .zfill(5) к каждому захваченному тексту, лямбда-выражение используется в качестве аргумента замены, а к захватам обращаются с помощью метода объекта данных соответствия group().
Однако, если ваши строки уже в правильном формате, вы можете просто разделить строки и отформатировать их по мере необходимости:
for i in range (0, len(input)):
splits = input[i].split('-')
if len(splits) == 1:
new_list.append(input[i])
else:
new_list.append("{}-{}-{}".format(splits[0].zfill(5), splits[1].zfill(5), splits[2].zfill(5)))
См. еще одну демонстрацию Python . Оба раствора дают
['00090-00010-07457', '000480087800784', '00001-00713-00926', '00012-00710-08197', '00001-00345-01715', '00009-00023-04532', '000200007100272']
, lambda x: "{}-{}-{}".format(x.group(1).zfill(5), x.group(2).zfill(5), x.group(3).zfill(5)), input[i])
См. Демо Python .
Здесь ^(\d+)-(\d+)-(\d+)$ соответствует строке, которая начинается с 1+ цифр, затем имеет -, затем 1+ цифр, - и снова 1+ цифр, за которыми следует конец строки. Существуют три группы захвата, значения которых можно ссылаться с помощью обратных ссылок \1, \2 и \3 из шаблона замены. Однако, поскольку нам нужно применить .zfill(5) к каждому захваченному тексту, лямбда-выражение используется в качестве аргумента замены, а к захватам обращаются с помощью метода объекта данных соответствия group().
Однако, если ваши строки уже в правильном формате, вы можете просто разделить строки и отформатировать их по мере необходимости:
for i in range (0, len(input)):
splits = input[i].split('-')
if len(splits) == 1:
new_list.append(input[i])
else:
new_list.append("{}-{}-{}".format(splits[0].zfill(5), splits[1].zfill(5), splits[2].zfill(5)))
См. еще одну демонстрацию Python . Оба раствора дают
['00090-00010-07457', '000480087800784', '00001-00713-00926', '00012-00710-08197', '00001-00345-01715', '00009-00023-04532', '000200007100272']
4 ответа
Хорошо обычным примером, я думаю, является Персистентность
module Persistence
def load sFileName
puts "load code to read #{sFileName} contents into my_data"
end
def save sFileName
puts "Uber code to persist #{@my_data} to #{sFileName}"
end
end
class BrandNewClass
include Persistence
attr :my_data
def data=(someData)
@my_data = someData
end
end
b = BrandNewClass.new
b.data = "My pwd"
b.save "MyFile.secret"
b.load "MyFile.secret"
Предположите, что модуль записан ниндзя Ruby, который сохраняет состояние Вашего класса в файл.
Теперь предположите, что я пишу совершенно новый класс, я могу снова использовать функциональность персистентности путем смешивания его в путем высказывания include ModuleILike. Можно даже включать модули во время выполнения. Я получаю загрузку и сохраняю методы бесплатно, просто смешав ее в. Эти методы точно так же, как те, что Вы записали себя для своего класса. Code/Behavior/Functionality-reuse без наследования!
Таким образом, то, что Вы делаете, включает методы в таблицу метода для Вашего класса (не буквально корректный, но близко).
Они обычно используются для добавления некоторой формы стандартной функциональности к классу, не имея необходимость переопределять все это. Можно, вероятно, думать о них немного как интерфейсы в Java, но вместо того, чтобы просто определить список методов, которые должны быть реализованы, многие из них будут на самом деле реализованы включением модуля.
В стандартной библиотеке существует несколько примеров:
Singleton - модуль, который может быть смешан в любой класс для создания этого одиночным элементом. Инициализировать метод сделан частным, и добавленный метод экземпляра, который гарантирует, что существует только когда-либо один экземпляр того класса в Вашем приложении.
Сопоставимый - Если Вы включаете этот модуль в класс, определяя <=> метод, который сравнивает текущий экземпляр с другим объектом и говорит, который больше, достаточно должен обеспечить <<=, ==,> =,>, и между? методы.
Счетный - Путем смешивания в этом модуле и определения каждого метода, Вы получаете поддержку всех других связанных методов тех, которые собирают, вводят, выбирают, и отклонение. Если это также добралось <=> метод, то это будет также поддерживать вид, минута, и максимум.
DataMapper является также интересным примером того, что может быть сделано с простым, включают оператор, посещая стандартный урок, и добавляя способность сохранить его к хранилищу данных.
Это в основном используется, как можно было бы использовать множественное наследование в C++ или реализующие интерфейсы в Java/C#. Я не уверен, где Ваш опыт находится, но если бы Вы сделали те вещи прежде, mixins - то, как Вы сделали бы их в Ruby. Это - систематизируемый способ ввести функциональность в классы.
В рубине причина, что Mixins не являются множественным наследованием, состоит в том, что объединение смешивания методов является одной вещью времени. Это не было бы такой большой проблемой, за исключением того, что модули и классы Ruby открыты для модификации. Это означает, что, если Вы смешивающий модуль к Вашему классу, затем добавите метод к модулю, то метод не будет доступен Вашему классу; где, если Вы сделали это в противоположном порядке, это было бы.
Это похоже на упорядочивание сливочного рожка. Если Вы получаете шоколадные опрыскивания и биты ириски как Ваш mixins, и уходите с Вашим конусом, какой конус мороженого, который Вы имеете, не изменится, если кто-то добавит разноцветные опрыскивания к шоколадному мусорному ведру опрыскиваний назад в магазине мороженого. Ваш класс, конус мороженого, не изменяется, когда смесительный модуль, мусорное ведро опрыскиваний. Следующий человек, который будет использовать тот модуль смешивания, будет видеть изменения.
Когда Вы include модуль в рубине, это звонит Module#append_features на том модуле, которые добавляют копию методов того модуля к includer одно время.
Множественное наследование, насколько я понимаю, больше похоже на делегацию. Если Ваш класс не знает, как сделать что-то, он спрашивает своих родителей. В среде открытого класса, возможно, были изменены родители класса после того, как класс был создан.
Это похоже на отношения отцов и детей RL. Ваш родительский элемент, возможно, изучил, как манипулировать после того, как Вы родились, но если кто-то просит, чтобы Вы манипулировали, и Вы спрашиваете ее к также: покажите Вам, как (копируют его, когда Вам нужен он) или делают это для Вас (чистая делегация), затем она сможет в той точке, даже при том, что Вы были созданы, прежде чем ее способность манипулировать была.
Возможно, что Вы могли изменить рубиновый модуль, 'включают' для действия больше как множественное наследование путем изменения Module#append_features сохранить список includers и затем обновить их использующий method_added обратный вызов, но это было бы большим сдвигом от стандартного Ruby и могло вызвать главные проблемы при работе с кодом других. Вы могли бы лучше создавать a Module#inherit метод, который звонил include и обработанная делегация также.
Что касается примера реального мира, Enumerable является потрясающим. Если Вы определяете #each и включайте Enumerable в Вашем классе затем это предоставляет Вам доступ к большому количеству итераторов без Вас имеющий необходимость кодировать каждого.