From ef8ed1834c24159ff951192985b00886b78c5342 Mon Sep 17 00:00:00 2001 From: skovorodkin Date: Tue, 31 Dec 2013 04:28:30 +0300 Subject: [julia/ru] Add first version --- ru-ru/julia-ru.html.markdown | 749 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 749 insertions(+) create mode 100644 ru-ru/julia-ru.html.markdown (limited to 'ru-ru/julia-ru.html.markdown') diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown new file mode 100644 index 00000000..51654cfe --- /dev/null +++ b/ru-ru/julia-ru.html.markdown @@ -0,0 +1,749 @@ +--- +language: julia +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Sergey Skovorodkin", "https://github.com/skovorodkin"] +filename: learnjulia.jl +--- + +Julia — гомоиконный функциональный язык программирования для технических расчётов. +Несмотря на полную поддержку гомоиконных макросов, функций первого класса и конструкций управления низкого уровня, этот язык так же прост в изучении и применении, как и Python. + +Документ описывает текущую dev-версию Julia от 18-о октября 2013 года. + +```ruby + +# Однострочные комментарии начинаются со знака решётки. + +#################################################### +## 1. Примитивные типы данных и операторы +#################################################### + +# Всё в Julia — выражение. + +# Простые численные типы +3 #=> 3 (Int64) +3.2 #=> 3.2 (Float64) +2 + 1im #=> 2 + 1im (Complex{Int64}) +2//3 #=> 2//3 (Rational{Int64}) + +# Доступны все привычные инфиксные операторы +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7.0 +5 / 2 #=> 2.5 # деление Int на Int всегда возвращает Float +div(5, 2) #=> 2 # для округления к нулю используется div +5 \ 35 #=> 7.0 +2 ^ 2 #=> 4 # возведение в степень +12 % 10 #=> 2 + +# С помощью скобок можно изменить приоритет операций +(1 + 3) * 2 #=> 8 + +# Побитовые операторы +~2 #=> -3 # НЕ (NOT) +3 & 5 #=> 1 # И (AND) +2 | 4 #=> 6 # ИЛИ (OR) +2 $ 4 #=> 6 # сложение по модулю 2 (XOR) +2 >>> 1 #=> 1 # логический сдвиг вправо +2 >> 1 #=> 1 # арифметический сдвиг вправо +2 << 1 #=> 4 # логический/арифметический сдвиг влево + +# Функция bits возвращает бинарное представление числа +bits(12345) +#=> "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +#=> "0100000011001000000111001000000000000000000000000000000000000000" + +# Логические значения являются примитивами +true +false + +# Булевы операторы +!true #=> false +!false #=> true +1 == 1 #=> true +2 == 1 #=> false +1 != 1 #=> false +2 != 1 #=> true +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true +# Сравнения можно объединять цепочкой +1 < 2 < 3 #=> true +2 < 3 < 2 #=> false + +# Строки объявляются с помощью двойных кавычек — " +"This is a string." + +# Символьные литералы создаются с помощью одинарных кавычек — ' +'a' + +# Строки индексируются как массивы символов +"This is a string"[1] #=> 'T' # Индексы начинаются с единицы +# Индексирование не всегда правильно работает для UTF8-строк, +# поэтому рекомендуется использовать итерирование (map, for-циклы и т.п.). + +# Для строковой интерполяции используется знак доллара ($): +"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" +# В скобках можно использовать любое выражение языка. + +# Другой способ форматирования строк — макрос printf +@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 + +#################################################### +## 2. Переменные и коллекции +#################################################### + +# Вывод +println("I'm Julia. Nice to meet you!") + +# Переменные инициализируются без предварительного объявления +some_var = 5 #=> 5 +some_var #=> 5 + +# Попытка доступа к переменной до инициализации вызывает ошибку +try + some_other_var #=> ERROR: some_other_var not defined +catch e + println(e) +end + +# Имена переменных начинаются с букв. +# После первого символа можно использовать буквы, цифры, +# символы подчёркивания и восклицательные знаки. +SomeOtherVar123! = 6 #=> 6 + +# Допустимо использование unicode-символов +☃ = 8 #=> 8 +# Это особенно удобно для математических обозначений +2 * π #=> 6.283185307179586 + +# Рекомендации по именованию: +# * имена переменных в нижнем регистре, слова разделяются символом +# подчёркивания ('\_'); +# +# * для имён типов используется CamelCase; +# +# * имена функций и макросов в нижнем регистре +# без разделения слов символом подчёркивания; +# +# * имя функции, изменяющей переданные ей аргументы (in-place function), +# оканчивается восклицательным знаком. + +# Массив хранит последовательность значений, индексируемых с единицы до n: +a = Int64[] #=> пустой массив Int64-элементов + +# Одномерный массив объявляется разделёнными запятой значениями. +b = [4, 5, 6] #=> массив из трёх Int64-элементов: [4, 5, 6] +b[1] #=> 4 +b[end] #=> 6 + +# Строки двумерного массива разделяются точкой с запятой. +# Элементы строк разделяются пробелами. +matrix = [1 2; 3 4] #=> 2x2 Int64 Array: [1 2; 3 4] + +# push! и append! добавляют в список новые элементы +push!(a,1) #=> [1] +push!(a,2) #=> [1,2] +push!(a,4) #=> [1,2,4] +push!(a,3) #=> [1,2,4,3] +append!(a,b) #=> [1,2,4,3,4,5,6] + +# pop! удаляет из списка последний элемент +pop!(b) #=> возвращает 6; массив b снова равен [4,5] + +# Вернём 6 обратно +push!(b,6) # b снова [4,5,6]. + +a[1] #=> 1 # индексы начинаются с единицы! + +# Последний элемент можно получить с помощью end +a[end] #=> 6 + +# Операции сдвига +shift!(a) #=> 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) #=> [7,2,4,3,4,5,6] + +# Восклицательный знак на конце названия функции означает, +# что функция изменяет переданные ей аргументы. +arr = [5,4,6] #=> массив из 3 Int64-элементов: [5,4,6] +sort(arr) #=> [4,5,6]; но arr равен [5,4,6] +sort!(arr) #=> [4,5,6]; а теперь arr — [4,5,6] + +# Попытка доступа за пределами массива выбрасывает BoundsError +try + a[0] #=> ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] #=> ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# Вывод ошибок содержит строку и файл, где произошла ошибка, +# даже если это случилось в стандартной библиотеке. +# Если вы собрали Julia из исходных кодов, +# то найти эти файлы можно в директории base. + +# Создавать массивы можно из последовательности +a = [1:5] #=> массив из 5 Int64-элементов: [1,2,3,4,5] + +# Срезы +a[1:3] #=> [1, 2, 3] +a[2:] #=> [2, 3, 4, 5] +a[2:end] #=> [2, 3, 4, 5] + +# splice! удаляет элемент из массива +# Remove elements from an array by index with splice! +arr = [3,4,5] +splice!(arr,2) #=> 4 ; arr теперь равен [3,5] + +# append! объединяет списки +b = [1,2,3] +append!(a,b) # теперь a равен [1, 2, 3, 4, 5, 1, 2, 3] + +# Проверка на вхождение +in(1, a) #=> true + +# Длина списка +length(a) #=> 8 + +# Кортеж — неизменяемая структура. +tup = (1, 2, 3) #=> (1,2,3) # кортеж (Int64,Int64,Int64). +tup[1] #=> 1 +try: + tup[1] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# Многие функции над списками работают и для кортежей +length(tup) #=> 3 +tup[1:2] #=> (1,2) +in(2, tup) #=> true + +# Кортежи можно распаковывать в переменные +a, b, c = (1, 2, 3) #=> (1,2,3) # a = 1, b = 2 и c = 3 + +# Скобки из предыдущего примера можно опустить +d, e, f = 4, 5, 6 #=> (4,5,6) + +# Кортеж из одного элемента не равен значению этого элемента +(1,) == 1 #=> false +(1) == 1 #=> true + +# Обмен значений +e, d = d, e #=> (5,4) # d = 5, e = 4 + + +# Словари содержат ассоциативные массивы +empty_dict = Dict() #=> Dict{Any,Any}() + +# Для создания словаря можно использовать литерал +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# Значения ищутся по ключу с помощью оператора [] +filled_dict["one"] #=> 1 + +# Получить все ключи +keys(filled_dict) +#=> KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Заметьте, словарь не запоминает порядок, в котором добавляются ключи. + +# Получить все значения. +values(filled_dict) +#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# То же касается и порядка значений. + +# Проверка вхождения ключа в словарь +in(("one", 1), filled_dict) #=> true +in(("two", 3), filled_dict) #=> false +haskey(filled_dict, "one") #=> true +haskey(filled_dict, 1) #=> false + +# Попытка обратиться к несуществующему ключу выбросит ошибку +try + filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# Используйте метод get со значением по умолчанию, чтобы избежать этой ошибки +# get(dictionary,key,default_value) +get(filled_dict,"one",4) #=> 1 +get(filled_dict,"four",4) #=> 4 + +# Для коллекций неотсортированных уникальных элементов используйте Set +empty_set = Set() #=> Set{Any}() +# Инициализация множества +filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) + +# Добавление элементов +push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) + +# Проверка вхождения элементов во множество +in(2, filled_set) #=> true +in(10, filled_set) #=> false + +# Функции для получения пересечения, объединения и разницы. +other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) #=> Set{Int64}(3,4,5) +union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4) + + +#################################################### +## 3. Поток управления +#################################################### + +# Создадим переменную +some_var = 5 + +# Выражение if. Отступы не имеют значения. +if some_var > 10 + println("some_var is totally bigger than 10.") +elseif some_var < 10 # Необязательная ветка elseif. + println("some_var is smaller than 10.") +else # else-ветка также опциональна. + println("some_var is indeed 10.") +end +#=> prints "some var is smaller than 10" + + +# Цикл for проходит по итерируемым объектам +# Примеры итерируемых типов: Range, Array, Set, Dict и String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # Для вставки значения переменной или выражения в строку используется $ +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Другой вариант записи. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# Выведет: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Цикл while выполняется до тех пор, пока верно условие +x = 0 +while x < 4 + println(x) + x += 1 # Короткая запись x = x + 1 +end +# Выведет: +# 0 +# 1 +# 2 +# 3 + +# Обработка исключений +try + error("help") +catch e + println("caught it $e") +end +#=> caught it ErrorException("help") + + +#################################################### +## 4. Функции +#################################################### + +# Для определения новой функции используется ключевое слово 'function' +#function имя(аргументы) +# тело... +#end +function add(x, y) + println("x is $x and y is $y") + + # Функция возвращает значение последнего выражения + x + y +end + +add(5, 6) #=> Вернёт 11, напечатав "x is 5 and y is 6" + +# Функция может принимать переменное количество позиционных аргументов. +function varargs(args...) + return args + # для возвращения из функции в любом месте используется 'return' +end +#=> varargs (generic function with 1 method) + +varargs(1,2,3) #=> (1,2,3) + +# Многоточие (...) — это splat. +# Мы только что воспользовались им в определении функции. +# Также его можно использовать при вызове функции, +# где он преобразует содержимое массива или кортежа в список аргументов. +Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # формирует множество массивов +Set([1,2,3]...) #=> Set{Int64}(1,2,3) # эквивалентно Set(1,2,3) + +x = (1,2,3) #=> (1,2,3) +Set(x) #=> Set{(Int64,Int64,Int64)}((1,2,3)) # множество кортежей +Set(x...) #=> Set{Int64}(2,3,1) + + +# Опциональные позиционные аргументы +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') #=> "h g and 5 6" +defaults('h','g','j') #=> "h g and j 6" +defaults('h','g','j','k') #=> "h g and j k" +try + defaults('h') #=> ERROR: no method defaults(Char,) + defaults() #=> ERROR: no methods defaults() +catch e + println(e) +end + +# Именованные аргументы +function keyword_args(;k1=4,name2="hello") # обратите внимание на ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] +keyword_args() #=> ["name2"=>"hello","k2"=>4] + +# В одной функции можно совмещать все виды аргументов +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# Выведет: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Функции в Julia первого класса +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# Анонимная функция +(x -> x > 2)(3) #=> true + +# Эта функция идентичная предыдущей версии create_adder +function create_adder(x) + y -> x + y +end + +# Если есть желание, можно воспользоваться полным вариантом +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) #=> 13 + + +# Встроенные функции высшего порядка +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Списковые сборки +[add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] + +#################################################### +## 5. Типы +#################################################### + +# Julia has a type system. +# Каждое значение имеет тип, но переменные не определяют тип значения. +# Функция `typeof` возвращает тип значения. +typeof(5) #=> Int64 + +# Types are first-class values +# Типы являются значениями первого класса +typeof(Int64) #=> DataType +typeof(DataType) #=> DataType +# Тип DataType представляет типы, включая себя самого. + +# Типы используются в качестве документации, для оптимизации и организации. +# Статически типы не проверяются. + +# Пользователь может определять свои типы +# Типы похожи на структуры в других языках +# Новые типы определяются с помощью ключевого слова `type` + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # отсутствие типа равносильно `::Any` +end + +# Аргументы конструктора по умолчанию — свойства типа +# в порядке их определения. +tigger = Tiger(3.5,"orange") #=> Tiger(3.5,"orange") + +# Тип объекта по сути является конструктором значений такого типа +sherekhan = typeof(tigger)(5.6,"fire") #=> Tiger(5.6,"fire") + +# Эти типы, похожие на структуры, называются конкретными. +# Можно создавать объекты таких типов, но не их подтипы. +# Другой вид типов — абстрактные типы. + +# abstract Name +abstract Cat # просто имя и точка в иерархии типов + +# Объекты абстрактных типов создавать нельзя, +# но зато от них можно наследовать подтипы. +# Например, Number — это абстрактный тип. +subtypes(Number) #=> 6 элементов в массиве Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) #=> пустой массив Array{Any,1} + +# У всех типов есть супертип. Для его определения есть функция `super`. +typeof(5) #=> Int64 +super(Int64) #=> Signed +super(Signed) #=> Real +super(Real) #=> Number +super(Number) #=> Any +super(super(Signed)) #=> Number +super(Any) #=> Any +# Все эти типы, за исключением Int64, абстрактные. + +# Для создания подтипа используется оператор <: +type Lion <: Cat # Lion — это подтип Cat + mane_color + roar::String +end + +# У типа может быть несколько конструкторов. +# Для создания нового определите функцию с именем, как у типа, +# и вызовите имеющийся конструктор. +Lion(roar::String) = Lion("green",roar) +# Мы создали внешний (т.к. он находится вне определения типа) конструктор. + +type Panther <: Cat # Panther — это тоже подтип Cat + eye_color + + # Определим свой конструктор вместо конструктора по умолчанию + Panther() = new("green") +end +# Использование внутренних конструкторов позволяет +# определять, как будут создаваться объекты типов. +# Но по возможности стоит пользоваться внешними конструкторами. + +#################################################### +## 6. Мультиметоды +#################################################### + +# Все именованные функции являются generic-функциями, +# т.е. все они состоят из разных методов. +# Каждый конструктор типа Lion — это метод generic-функции Lion. + +# Приведём пример без использования конструкторов, создадим функцию meow + +# Определения Lion, Panther и Tiger +function meow(animal::Lion) + animal.roar # доступ к свойству типа через точку +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# Проверка +meow(tigger) #=> "rawwr" +meow(Lion("brown","ROAAR")) #=> "ROAAR" +meow(Panther()) #=> "grrr" + +# Вспомним иерархию типов +issubtype(Tiger,Cat) #=> false +issubtype(Lion,Cat) #=> true +issubtype(Panther,Cat) #=> true + +# Определим функцию, принимающую на вход объекты типа Cat +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) #=> выведет "The cat says 42" +try + pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# В объектно-ориентированных языках распространена одиночная диспетчеризация — +# подходящий метод выбирается на основе типа первого аргумента. +# В Julia все аргументы участвуют в выборе нужного метода. + +# Чтобы понять разницу, определим функцию с несколькими аргументами. +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +#=> fight (generic function with 1 method) + +fight(tigger,Panther()) #=> выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) #=> выведет The orange tiger wins! + +# Переопределим поведение функции, если Cat-объект является Lion-объектом +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +#=> fight (generic function with 2 methods) + +fight(tigger,Panther()) #=> выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) #=> выведет The green-maned lion wins! + +# Драться можно не только с тиграми! +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +#=> fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) #=> выведет The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) #=> ERROR: no method fight(Panther,Lion) +catch +end + +# Вообще, пускай кошачьи могут первыми проявлять агрессию +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +#=> Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# Предупреждение говорит, что неясно, какой из методов вызывать: +fight(Lion("RAR"),Lion("brown","rarrr")) #=> выведет The victorious cat says rarrr +# Результат может оказаться разным в разных версиях Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) #=> выведет The lions come to a tie + + +# Под капотом +# Язык позволяет посмотреть на сгенерированные ассемблерный и LLVM-код. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# Что происходит, когда мы передаём функции square_area целое число? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Вводная часть + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # + # imul RAX, RAX # + # pop RBP # + # ret # + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Произведение чисел одинарной точности (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Произведение чисел двойной точности (AVX) + # pop RBP + # ret + # +# Если хотя бы один из аргументов является числом с плавающей запятой, +# то Julia будет использовать соответствующие инструкции. +# Вычислим площать круга +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Загрузить целое число (r) + # movabs RAX, 4593140240 # Загрузить pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## Что дальше? + +Для более подробной информации читайте [документацию по языку](http://docs.julialang.org/en/latest/manual/) + +Если вам нужна помощь, задавайте вопросы в [списке рассылки](https://groups.google.com/forum/#!forum/julia-users). -- cgit v1.2.3 From a257b3bfbae6ab17237f89c44b0ad79514ba5b53 Mon Sep 17 00:00:00 2001 From: Adam Date: Wed, 29 Jan 2014 21:55:11 -0800 Subject: Updated russian julia --- ru-ru/julia-ru.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'ru-ru/julia-ru.html.markdown') diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown index 51654cfe..b8890a93 100644 --- a/ru-ru/julia-ru.html.markdown +++ b/ru-ru/julia-ru.html.markdown @@ -5,6 +5,7 @@ contributors: translators: - ["Sergey Skovorodkin", "https://github.com/skovorodkin"] filename: learnjulia.jl +lang: ru-ru --- Julia — гомоиконный функциональный язык программирования для технических расчётов. -- cgit v1.2.3 From 50158e3b02624b55b7e5dca85efe8358bb535d57 Mon Sep 17 00:00:00 2001 From: Adam Date: Wed, 29 Jan 2014 22:25:15 -0800 Subject: juliavonovich --- ru-ru/julia-ru.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ru-ru/julia-ru.html.markdown') diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown index b8890a93..c9213a42 100644 --- a/ru-ru/julia-ru.html.markdown +++ b/ru-ru/julia-ru.html.markdown @@ -4,7 +4,7 @@ contributors: - ["Leah Hanson", "http://leahhanson.us"] translators: - ["Sergey Skovorodkin", "https://github.com/skovorodkin"] -filename: learnjulia.jl +filename: learnjulia-ru.jl lang: ru-ru --- -- cgit v1.2.3 From a375065b1993d281a54a868675273de0a322ed04 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Tue, 18 Mar 2014 14:05:24 -0500 Subject: Fix julia comments in russian version --- ru-ru/julia-ru.html.markdown | 318 +++++++++++++++++++++---------------------- 1 file changed, 159 insertions(+), 159 deletions(-) (limited to 'ru-ru/julia-ru.html.markdown') diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown index c9213a42..cd55e116 100644 --- a/ru-ru/julia-ru.html.markdown +++ b/ru-ru/julia-ru.html.markdown @@ -24,58 +24,58 @@ Julia — гомоиконный функциональный язык прог # Всё в Julia — выражение. # Простые численные типы -3 #=> 3 (Int64) -3.2 #=> 3.2 (Float64) -2 + 1im #=> 2 + 1im (Complex{Int64}) -2//3 #=> 2//3 (Rational{Int64}) +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) # Доступны все привычные инфиксные операторы -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 -35 / 5 #=> 7.0 -5 / 2 #=> 2.5 # деление Int на Int всегда возвращает Float -div(5, 2) #=> 2 # для округления к нулю используется div -5 \ 35 #=> 7.0 -2 ^ 2 #=> 4 # возведение в степень -12 % 10 #=> 2 +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # деление Int на Int всегда возвращает Float +div(5, 2) # => 2 # для округления к нулю используется div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # возведение в степень +12 % 10 # => 2 # С помощью скобок можно изменить приоритет операций -(1 + 3) * 2 #=> 8 +(1 + 3) * 2 # => 8 # Побитовые операторы -~2 #=> -3 # НЕ (NOT) -3 & 5 #=> 1 # И (AND) -2 | 4 #=> 6 # ИЛИ (OR) -2 $ 4 #=> 6 # сложение по модулю 2 (XOR) -2 >>> 1 #=> 1 # логический сдвиг вправо -2 >> 1 #=> 1 # арифметический сдвиг вправо -2 << 1 #=> 4 # логический/арифметический сдвиг влево +~2 # => -3 # НЕ (NOT) +3 & 5 # => 1 # И (AND) +2 | 4 # => 6 # ИЛИ (OR) +2 $ 4 # => 6 # сложение по модулю 2 (XOR) +2 >>> 1 # => 1 # логический сдвиг вправо +2 >> 1 # => 1 # арифметический сдвиг вправо +2 << 1 # => 4 # логический/арифметический сдвиг влево # Функция bits возвращает бинарное представление числа bits(12345) -#=> "0000000000000000000000000000000000000000000000000011000000111001" +# => "0000000000000000000000000000000000000000000000000011000000111001" bits(12345.0) -#=> "0100000011001000000111001000000000000000000000000000000000000000" +# => "0100000011001000000111001000000000000000000000000000000000000000" # Логические значения являются примитивами true false # Булевы операторы -!true #=> false -!false #=> true -1 == 1 #=> true -2 == 1 #=> false -1 != 1 #=> false -2 != 1 #=> true -1 < 10 #=> true -1 > 10 #=> false -2 <= 2 #=> true -2 >= 2 #=> true +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true # Сравнения можно объединять цепочкой -1 < 2 < 3 #=> true -2 < 3 < 2 #=> false +1 < 2 < 3 # => true +2 < 3 < 2 # => false # Строки объявляются с помощью двойных кавычек — " "This is a string." @@ -84,12 +84,12 @@ false 'a' # Строки индексируются как массивы символов -"This is a string"[1] #=> 'T' # Индексы начинаются с единицы +"This is a string"[1] # => 'T' # Индексы начинаются с единицы # Индексирование не всегда правильно работает для UTF8-строк, # поэтому рекомендуется использовать итерирование (map, for-циклы и т.п.). # Для строковой интерполяции используется знак доллара ($): -"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" # В скобках можно использовать любое выражение языка. # Другой способ форматирования строк — макрос printf @@ -103,12 +103,12 @@ false println("I'm Julia. Nice to meet you!") # Переменные инициализируются без предварительного объявления -some_var = 5 #=> 5 -some_var #=> 5 +some_var = 5 # => 5 +some_var # => 5 # Попытка доступа к переменной до инициализации вызывает ошибку try - some_other_var #=> ERROR: some_other_var not defined + some_other_var # => ERROR: some_other_var not defined catch e println(e) end @@ -116,12 +116,12 @@ end # Имена переменных начинаются с букв. # После первого символа можно использовать буквы, цифры, # символы подчёркивания и восклицательные знаки. -SomeOtherVar123! = 6 #=> 6 +SomeOtherVar123! = 6 # => 6 # Допустимо использование unicode-символов -☃ = 8 #=> 8 +☃ = 8 # => 8 # Это особенно удобно для математических обозначений -2 * π #=> 6.283185307179586 +2 * π # => 6.283185307179586 # Рекомендации по именованию: # * имена переменных в нижнем регистре, слова разделяются символом @@ -136,49 +136,49 @@ SomeOtherVar123! = 6 #=> 6 # оканчивается восклицательным знаком. # Массив хранит последовательность значений, индексируемых с единицы до n: -a = Int64[] #=> пустой массив Int64-элементов +a = Int64[] # => пустой массив Int64-элементов # Одномерный массив объявляется разделёнными запятой значениями. -b = [4, 5, 6] #=> массив из трёх Int64-элементов: [4, 5, 6] -b[1] #=> 4 -b[end] #=> 6 +b = [4, 5, 6] # => массив из трёх Int64-элементов: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 # Строки двумерного массива разделяются точкой с запятой. # Элементы строк разделяются пробелами. -matrix = [1 2; 3 4] #=> 2x2 Int64 Array: [1 2; 3 4] +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] # push! и append! добавляют в список новые элементы -push!(a,1) #=> [1] -push!(a,2) #=> [1,2] -push!(a,4) #=> [1,2,4] -push!(a,3) #=> [1,2,4,3] -append!(a,b) #=> [1,2,4,3,4,5,6] +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] # pop! удаляет из списка последний элемент -pop!(b) #=> возвращает 6; массив b снова равен [4,5] +pop!(b) # => возвращает 6; массив b снова равен [4,5] # Вернём 6 обратно push!(b,6) # b снова [4,5,6]. -a[1] #=> 1 # индексы начинаются с единицы! +a[1] # => 1 # индексы начинаются с единицы! # Последний элемент можно получить с помощью end -a[end] #=> 6 +a[end] # => 6 # Операции сдвига -shift!(a) #=> 1 and a is now [2,4,3,4,5,6] -unshift!(a,7) #=> [7,2,4,3,4,5,6] +shift!(a) # => 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] # Восклицательный знак на конце названия функции означает, # что функция изменяет переданные ей аргументы. -arr = [5,4,6] #=> массив из 3 Int64-элементов: [5,4,6] -sort(arr) #=> [4,5,6]; но arr равен [5,4,6] -sort!(arr) #=> [4,5,6]; а теперь arr — [4,5,6] +arr = [5,4,6] # => массив из 3 Int64-элементов: [5,4,6] +sort(arr) # => [4,5,6]; но arr равен [5,4,6] +sort!(arr) # => [4,5,6]; а теперь arr — [4,5,6] # Попытка доступа за пределами массива выбрасывает BoundsError try - a[0] #=> ERROR: BoundsError() in getindex at array.jl:270 - a[end+1] #=> ERROR: BoundsError() in getindex at array.jl:270 + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 catch e println(e) end @@ -189,111 +189,111 @@ end # то найти эти файлы можно в директории base. # Создавать массивы можно из последовательности -a = [1:5] #=> массив из 5 Int64-элементов: [1,2,3,4,5] +a = [1:5] # => массив из 5 Int64-элементов: [1,2,3,4,5] # Срезы -a[1:3] #=> [1, 2, 3] -a[2:] #=> [2, 3, 4, 5] -a[2:end] #=> [2, 3, 4, 5] +a[1:3] # => [1, 2, 3] +a[2:] # => [2, 3, 4, 5] +a[2:end] # => [2, 3, 4, 5] # splice! удаляет элемент из массива # Remove elements from an array by index with splice! arr = [3,4,5] -splice!(arr,2) #=> 4 ; arr теперь равен [3,5] +splice!(arr,2) # => 4 ; arr теперь равен [3,5] # append! объединяет списки b = [1,2,3] append!(a,b) # теперь a равен [1, 2, 3, 4, 5, 1, 2, 3] # Проверка на вхождение -in(1, a) #=> true +in(1, a) # => true # Длина списка -length(a) #=> 8 +length(a) # => 8 # Кортеж — неизменяемая структура. -tup = (1, 2, 3) #=> (1,2,3) # кортеж (Int64,Int64,Int64). -tup[1] #=> 1 +tup = (1, 2, 3) # => (1,2,3) # кортеж (Int64,Int64,Int64). +tup[1] # => 1 try: - tup[1] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) catch e println(e) end # Многие функции над списками работают и для кортежей -length(tup) #=> 3 -tup[1:2] #=> (1,2) -in(2, tup) #=> true +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true # Кортежи можно распаковывать в переменные -a, b, c = (1, 2, 3) #=> (1,2,3) # a = 1, b = 2 и c = 3 +a, b, c = (1, 2, 3) # => (1,2,3) # a = 1, b = 2 и c = 3 # Скобки из предыдущего примера можно опустить -d, e, f = 4, 5, 6 #=> (4,5,6) +d, e, f = 4, 5, 6 # => (4,5,6) # Кортеж из одного элемента не равен значению этого элемента -(1,) == 1 #=> false -(1) == 1 #=> true +(1,) == 1 # => false +(1) == 1 # => true # Обмен значений -e, d = d, e #=> (5,4) # d = 5, e = 4 +e, d = d, e # => (5,4) # d = 5, e = 4 # Словари содержат ассоциативные массивы -empty_dict = Dict() #=> Dict{Any,Any}() +empty_dict = Dict() # => Dict{Any,Any}() # Для создания словаря можно использовать литерал filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] # => Dict{ASCIIString,Int64} # Значения ищутся по ключу с помощью оператора [] -filled_dict["one"] #=> 1 +filled_dict["one"] # => 1 # Получить все ключи keys(filled_dict) -#=> KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) # Заметьте, словарь не запоминает порядок, в котором добавляются ключи. # Получить все значения. values(filled_dict) -#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) # То же касается и порядка значений. # Проверка вхождения ключа в словарь -in(("one", 1), filled_dict) #=> true -in(("two", 3), filled_dict) #=> false -haskey(filled_dict, "one") #=> true -haskey(filled_dict, 1) #=> false +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false # Попытка обратиться к несуществующему ключу выбросит ошибку try - filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489 + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 catch e println(e) end # Используйте метод get со значением по умолчанию, чтобы избежать этой ошибки # get(dictionary,key,default_value) -get(filled_dict,"one",4) #=> 1 -get(filled_dict,"four",4) #=> 4 +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 # Для коллекций неотсортированных уникальных элементов используйте Set -empty_set = Set() #=> Set{Any}() +empty_set = Set() # => Set{Any}() # Инициализация множества -filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) # Добавление элементов -push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) # Проверка вхождения элементов во множество -in(2, filled_set) #=> true -in(10, filled_set) #=> false +in(2, filled_set) # => true +in(10, filled_set) # => false # Функции для получения пересечения, объединения и разницы. -other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3) -intersect(filled_set, other_set) #=> Set{Int64}(3,4,5) -union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6) -setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4) +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) #################################################### @@ -311,7 +311,7 @@ elseif some_var < 10 # Необязательная ветка elseif. else # else-ветка также опциональна. println("some_var is indeed 10.") end -#=> prints "some var is smaller than 10" +# => prints "some var is smaller than 10" # Цикл for проходит по итерируемым объектам @@ -368,7 +368,7 @@ try catch e println("caught it $e") end -#=> caught it ErrorException("help") +# => caught it ErrorException("help") #################################################### @@ -386,27 +386,27 @@ function add(x, y) x + y end -add(5, 6) #=> Вернёт 11, напечатав "x is 5 and y is 6" +add(5, 6) # => Вернёт 11, напечатав "x is 5 and y is 6" # Функция может принимать переменное количество позиционных аргументов. function varargs(args...) return args # для возвращения из функции в любом месте используется 'return' end -#=> varargs (generic function with 1 method) +# => varargs (generic function with 1 method) -varargs(1,2,3) #=> (1,2,3) +varargs(1,2,3) # => (1,2,3) # Многоточие (...) — это splat. # Мы только что воспользовались им в определении функции. # Также его можно использовать при вызове функции, # где он преобразует содержимое массива или кортежа в список аргументов. -Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # формирует множество массивов -Set([1,2,3]...) #=> Set{Int64}(1,2,3) # эквивалентно Set(1,2,3) +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # формирует множество массивов +Set([1,2,3]...) # => Set{Int64}(1,2,3) # эквивалентно Set(1,2,3) -x = (1,2,3) #=> (1,2,3) -Set(x) #=> Set{(Int64,Int64,Int64)}((1,2,3)) # множество кортежей -Set(x...) #=> Set{Int64}(2,3,1) +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # множество кортежей +Set(x...) # => Set{Int64}(2,3,1) # Опциональные позиционные аргументы @@ -414,12 +414,12 @@ function defaults(a,b,x=5,y=6) return "$a $b and $x $y" end -defaults('h','g') #=> "h g and 5 6" -defaults('h','g','j') #=> "h g and j 6" -defaults('h','g','j','k') #=> "h g and j k" +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" try - defaults('h') #=> ERROR: no method defaults(Char,) - defaults() #=> ERROR: no methods defaults() + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() catch e println(e) end @@ -429,9 +429,9 @@ function keyword_args(;k1=4,name2="hello") # обратите внимание return ["k1"=>k1,"name2"=>name2] end -keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] -keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] -keyword_args() #=> ["name2"=>"hello","k2"=>4] +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k2"=>4] # В одной функции можно совмещать все виды аргументов function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") @@ -455,7 +455,7 @@ function create_adder(x) end # Анонимная функция -(x -> x > 2)(3) #=> true +(x -> x > 2)(3) # => true # Эта функция идентичная предыдущей версии create_adder function create_adder(x) @@ -471,16 +471,16 @@ function create_adder(x) end add_10 = create_adder(10) -add_10(3) #=> 13 +add_10(3) # => 13 # Встроенные функции высшего порядка -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] # Списковые сборки -[add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13] -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] #################################################### ## 5. Типы @@ -489,12 +489,12 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] # Julia has a type system. # Каждое значение имеет тип, но переменные не определяют тип значения. # Функция `typeof` возвращает тип значения. -typeof(5) #=> Int64 +typeof(5) # => Int64 # Types are first-class values # Типы являются значениями первого класса -typeof(Int64) #=> DataType -typeof(DataType) #=> DataType +typeof(Int64) # => DataType +typeof(DataType) # => DataType # Тип DataType представляет типы, включая себя самого. # Типы используются в качестве документации, для оптимизации и организации. @@ -515,10 +515,10 @@ end # Аргументы конструктора по умолчанию — свойства типа # в порядке их определения. -tigger = Tiger(3.5,"orange") #=> Tiger(3.5,"orange") +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") # Тип объекта по сути является конструктором значений такого типа -sherekhan = typeof(tigger)(5.6,"fire") #=> Tiger(5.6,"fire") +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") # Эти типы, похожие на структуры, называются конкретными. # Можно создавать объекты таких типов, но не их подтипы. @@ -530,23 +530,23 @@ abstract Cat # просто имя и точка в иерархии типов # Объекты абстрактных типов создавать нельзя, # но зато от них можно наследовать подтипы. # Например, Number — это абстрактный тип. -subtypes(Number) #=> 6 элементов в массиве Array{Any,1}: +subtypes(Number) # => 6 элементов в массиве Array{Any,1}: # Complex{Float16} # Complex{Float32} # Complex{Float64} # Complex{T<:Real} # ImaginaryUnit # Real -subtypes(Cat) #=> пустой массив Array{Any,1} +subtypes(Cat) # => пустой массив Array{Any,1} # У всех типов есть супертип. Для его определения есть функция `super`. -typeof(5) #=> Int64 -super(Int64) #=> Signed -super(Signed) #=> Real -super(Real) #=> Number -super(Number) #=> Any -super(super(Signed)) #=> Number -super(Any) #=> Any +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any # Все эти типы, за исключением Int64, абстрактные. # Для создания подтипа используется оператор <: @@ -595,23 +595,23 @@ function meow(animal::Tiger) end # Проверка -meow(tigger) #=> "rawwr" -meow(Lion("brown","ROAAR")) #=> "ROAAR" -meow(Panther()) #=> "grrr" +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" # Вспомним иерархию типов -issubtype(Tiger,Cat) #=> false -issubtype(Lion,Cat) #=> true -issubtype(Panther,Cat) #=> true +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true # Определим функцию, принимающую на вход объекты типа Cat function pet_cat(cat::Cat) println("The cat says $(meow(cat))") end -pet_cat(Lion("42")) #=> выведет "The cat says 42" +pet_cat(Lion("42")) # => выведет "The cat says 42" try - pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,) + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) catch e println(e) end @@ -624,31 +624,31 @@ end function fight(t::Tiger,c::Cat) println("The $(t.coatcolor) tiger wins!") end -#=> fight (generic function with 1 method) +# => fight (generic function with 1 method) -fight(tigger,Panther()) #=> выведет The orange tiger wins! -fight(tigger,Lion("ROAR")) #=> выведет The orange tiger wins! +fight(tigger,Panther()) # => выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) # => выведет The orange tiger wins! # Переопределим поведение функции, если Cat-объект является Lion-объектом fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") -#=> fight (generic function with 2 methods) +# => fight (generic function with 2 methods) -fight(tigger,Panther()) #=> выведет The orange tiger wins! -fight(tigger,Lion("ROAR")) #=> выведет The green-maned lion wins! +fight(tigger,Panther()) # => выведет The orange tiger wins! +fight(tigger,Lion("ROAR")) # => выведет The green-maned lion wins! # Драться можно не только с тиграми! fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") -#=> fight (generic function with 3 methods) +# => fight (generic function with 3 methods) -fight(Lion("balooga!"),Panther()) #=> выведет The victorious cat says grrr +fight(Lion("balooga!"),Panther()) # => выведет The victorious cat says grrr try - fight(Panther(),Lion("RAWR")) #=> ERROR: no method fight(Panther,Lion) + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) catch end # Вообще, пускай кошачьи могут первыми проявлять агрессию fight(c::Cat,l::Lion) = println("The cat beats the Lion") -#=> Warning: New definition +# => Warning: New definition # fight(Cat,Lion) at none:1 # is ambiguous with # fight(Lion,Cat) at none:2. @@ -658,11 +658,11 @@ fight(c::Cat,l::Lion) = println("The cat beats the Lion") #fight (generic function with 4 methods) # Предупреждение говорит, что неясно, какой из методов вызывать: -fight(Lion("RAR"),Lion("brown","rarrr")) #=> выведет The victorious cat says rarrr +fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The victorious cat says rarrr # Результат может оказаться разным в разных версиях Julia fight(l::Lion,l2::Lion) = println("The lions come to a tie") -fight(Lion("RAR"),Lion("brown","rarrr")) #=> выведет The lions come to a tie +fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The lions come to a tie # Под капотом -- cgit v1.2.3 From ef6544a8868d3b19a115804b2db3962d91ad7979 Mon Sep 17 00:00:00 2001 From: Geoffrey Liu Date: Sun, 12 Oct 2014 14:24:42 -0700 Subject: Capitalize language names for translations. #137 --- ru-ru/julia-ru.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ru-ru/julia-ru.html.markdown') diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown index cd55e116..29392604 100644 --- a/ru-ru/julia-ru.html.markdown +++ b/ru-ru/julia-ru.html.markdown @@ -1,5 +1,5 @@ --- -language: julia +language: Julia contributors: - ["Leah Hanson", "http://leahhanson.us"] translators: -- cgit v1.2.3