Merge pull request #3189 from visr/julia1

[julia/en] update to run on julia 1.0
2025-08-27 08:37:36 +02:00 · 2018-08-23 22:18:39 -07:00
parent 79bcf8ce5b 67637e02eb
commit ba713d7261
1 changed files with 291 additions and 294 deletions
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -2,17 +2,17 @@
 language: Julia
 contributors:
    - ["Leah Hanson", "http://leahhanson.us"]
-    - ["Pranit Bauva", "http://github.com/pranitbauva1997"]
-    - ["Daniel YC Lin", "http://github.com/dlintw"]
+    - ["Pranit Bauva", "https://github.com/pranitbauva1997"]
+    - ["Daniel YC Lin", "https://github.com/dlintw"]
 filename: learnjulia.jl
 ---

 Julia is a new homoiconic functional language focused on technical computing.
 While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.

-This is based on Julia 0.6.4
+This is based on Julia 1.0.0

-```ruby
+```julia

 # Single line comments start with a hash (pound) symbol.
 #= Multiline comments can be written
@@ -37,7 +37,7 @@ This is based on Julia 0.6.4
 8 - 1      # => 7
 10 * 2     # => 20
 35 / 5     # => 7.0
-5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float
+5 / 2      # => 2.5  # dividing integers always results in a Float64
 div(5, 2)  # => 2    # for a truncated result, use div
 5 \ 35     # => 7.0
 2^2        # => 4    # power, not bitwise xor
@@ -55,10 +55,10 @@ xor(2, 4) # => 6 # bitwise xor
 2 >> 1     # => 1  # arithmetic shift right
 2 << 1     # => 4  # logical/arithmetic shift left

-# You can use the bits function to see the binary representation of a number.
-bits(12345)
+# Use the bitstring function to see the binary representation of a number.
+bitstring(12345)
 # => "0000000000000000000000000000000000000000000000000011000000111001"
-bits(12345.0)
+bitstring(12345.0)
 # => "0100000011001000000111001000000000000000000000000000000000000000"

 # Boolean values are primitives
@@ -81,33 +81,23 @@ false
 2 < 3 < 2  # => false

 # Strings are created with "
-try
 "This is a string."
-catch ; end
-
-# Julia has several types of strings, including ASCIIString and UTF8String.
-# More on this in the Types section.

 # Character literals are written with '
-try
 'a'
-catch ; end

-# Some strings can be indexed like an array of characters
-try
-"This is a string"[1] # => 'T' # Julia indexes from 1
-catch ; end
-# However, this is will not work well for UTF8 strings,
-# so iterating over strings is recommended (map, for loops, etc).
+# Strings are UTF8 encoded. Only if they contain only ASCII characters can
+# they be safely indexed.
+ascii("This is a string")[1]  # => 'T' # Julia indexes from 1
+# Otherwise, iterating over strings is recommended (map, for loops, etc).

 # $ can be used for string interpolation:
-try
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
-catch ; end
 # You can put any Julia expression inside the parentheses.

-# Another way to format strings is the printf macro.
-@printf "%d is less than %f" 4.5 5.3 # 4 is less than 5.300000
+# Another way to format strings is the printf macro from the stdlib Printf.
+using Printf
+@printf "%d is less than %f\n" 4.5 5.3  # => 5 is less than 5.300000

 # Printing is easy
 println("I'm Julia. Nice to meet you!")
@@ -127,7 +117,7 @@ some_var # => 5

 # Accessing a previously unassigned variable is an error
 try
-    some_other_var # => ERROR: some_other_var not defined
+    some_other_var  # => ERROR: UndefVarError: some_other_var not defined
 catch e
    println(e)
 end
@@ -167,7 +157,7 @@ b[end] # => 6
 # 2-dimensional arrays use space-separated values and semicolon-separated rows.
 matrix = [1 2; 3 4]  # => 2x2 Int64 Array: [1 2; 3 4]

-# Arrays of a particular Type
+# Arrays of a particular type
 b = Int8[4, 5, 6]  # => 3-element Int8 Array: [4, 5, 6]

 # Add stuff to the end of a list with push! and append!
@@ -189,9 +179,9 @@ a[1] # => 1 # remember that Julia indexes from 1, not 0!
 # indexing expression
 a[end]  # => 6

-# we also have shift and unshift
-shift!(a) # => 1 and a is now [2,4,3,4,5,6]
-unshift!(a,7) # => [7,2,4,3,4,5,6]
+# we also have popfirst! and pushfirst!
+popfirst!(a)  # => 1 and a is now [2,4,3,4,5,6]
+pushfirst!(a, 7)  # => [7,2,4,3,4,5,6]

 # Function names that end in exclamations points indicate that they modify
 # their argument.
@@ -201,15 +191,17 @@ sort!(arr) # => [4,5,6]; arr is now [4,5,6]

 # Looking out of bounds is a 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]
+    # => BoundsError: attempt to access 7-element Array{Int64,1} at index [0]
+    a[end + 1]
+    # => BoundsError: attempt to access 7-element Array{Int64,1} at index [8]
 catch e
    println(e)
 end

 # Errors list the line and file they came from, even if it's in the standard
-# library. If you built Julia from source, you can look in the folder base
-# inside the julia folder to find these files.
+# library. You can look in the folder share/julia inside the julia folder to
+# find these files.

 # You can initialize arrays from ranges
 a = [1:5;]  # => 5-element Int64 Array: [1,2,3,4,5]
@@ -235,13 +227,13 @@ length(a) # => 8
 # Tuples are immutable.
 tup = (1, 2, 3)  # => (1,2,3)  # an (Int64,Int64,Int64) tuple.
 tup[1]  # => 1
-try:
+try
    tup[1] = 3  # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
 catch e
    println(e)
 end

-# Many list functions also work on tuples
+# Many array functions also work on tuples
 length(tup)  # => 3
 tup[1:2]  # => (1,2)
 in(2, tup)  # => true
@@ -265,19 +257,20 @@ empty_dict = Dict() # => Dict{Any,Any}()

 # You can create a dictionary using a literal
 filled_dict = Dict("one" => 1, "two" => 2, "three" => 3)
-# => Dict{ASCIIString,Int64}
+# => Dict{String,Int64}

 # Look up values with []
 filled_dict["one"]  # => 1

 # Get all keys
 keys(filled_dict)
-# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.KeySet for a Dict{String,Int64} with 3 entries. Keys:
+# "two", "one", "three"
 # Note - dictionary keys are not sorted or in the order you inserted them.

 # Get all values
 values(filled_dict)
-# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.ValueIterator{Dict{String,Int64}} with 3 entries. Values: 2, 1, 3
 # Note - Same as above regarding key ordering.

 # Check for existence of keys in a dictionary with in, haskey
@@ -288,7 +281,7 @@ haskey(filled_dict, 1) # => false

 # Trying to look up a non-existent key will raise an error
 try
-    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+    filled_dict["four"]  # => KeyError: key "four" not found
 catch e
    println(e)
 end
@@ -301,20 +294,20 @@ get(filled_dict,"four",4) # => 4
 # Use Sets to represent collections of unordered, unique values
 empty_set = Set()  # => Set{Any}()
 # Initialize a set with values
-filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)
+filled_set = Set([1, 2, 2, 3, 4])  # => Set([4, 2, 3, 1])

 # Add more values to a set
-push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+push!(filled_set, 5)  # => Set([4, 2, 3, 5, 1])

 # Check if the values are in the set
 in(2, filled_set)  # => true
 in(10, filled_set)  # => false

 # There are functions for set intersection, union, and difference.
-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([4, 3, 5, 6])
+intersect(filled_set, other_set)       # => Set([4, 3, 5])
+union(filled_set, other_set)           # => Set([4, 2, 3, 5, 6, 1])
+setdiff(Set([1,2,3,4]), Set([2,3,5]))  # => Set([4, 1])


 ####################################################
@@ -355,8 +348,9 @@ end
 #    cat is a mammal
 #    mouse is a mammal

-for a in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
-    println("$(a[1]) is a $(a[2])")
+for pair in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
+    from, to = pair
+    println("$from is a $to")
 end
 # prints:
 #    dog is a mammal
@@ -372,11 +366,12 @@ end
 #    mouse is a mammal

 # While loops loop while a condition is true
-x = 0
+let x = 0
    while x < 4
        println(x)
        x += 1  # Shorthand for x = x + 1
    end
+end
 # prints:
 #   0
 #   1
@@ -530,13 +525,13 @@ typeof(DataType) # => DataType

 # Users can define types
 # They are like records or structs in other languages.
-# New types are defined using the `type` keyword.
+# New types are defined using the `struct` keyword.

-# type Name
+# struct Name
 #   field::OptionalType
 #   ...
 # end
-type Tiger
+struct Tiger
    taillength::Float64
    coatcolor  # not including a type annotation is the same as `::Any`
 end
@@ -556,6 +551,7 @@ sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
 abstract type Cat end  # just a name and point in the type hierarchy

 # Abstract types cannot be instantiated, but can have subtypes.
+using InteractiveUtils  # defines the subtype and supertype function
 # For example, Number is an abstract type
 subtypes(Number)  # => 2-element Array{Any,1}:
                 #     Complex{T<:Real}
@@ -563,13 +559,11 @@ subtypes(Number) # => 2-element Array{Any,1}:
 subtypes(Cat)  # => 0-element Array{Any,1}

 # AbstractString, as the name implies, is also an abstract type
-subtypes(AbstractString)        # 6-element Array{Union{DataType, UnionAll},1}:
-				# Base.SubstitutionString
-				# Base.Test.GenericString
-				# DirectIndexString      
-				# RevString              
+subtypes(AbstractString)  # 4-element Array{Any,1}:
                            #  String
                            #  SubString
+                            #  SubstitutionString
+                            #  Test.GenericString

 # Every type has a super type; use the `supertype` function to get it.
 typeof(5)  # => Int64
@@ -584,10 +578,10 @@ supertype(Any) # => Any
 typeof("fire")  # => String
 supertype(String)  # => AbstractString
 # Likewise here with String
-supertype(DirectIndexString) # => AbstractString
+supertype(SubString)  # => AbstractString

 # <: is the subtyping operator
-type Lion <: Cat # Lion is a subtype of Cat
+struct Lion <: Cat  # Lion is a subtype of Cat
    mane_color
    roar::AbstractString
 end
@@ -598,7 +592,7 @@ end
 Lion(roar::AbstractString) = Lion("green", roar)
 # This is an outer constructor because it's outside the type definition

-type Panther <: Cat # Panther is also a subtype of Cat
+struct Panther <: Cat  # Panther is also a subtype of Cat
    eye_color
    Panther() = new("green")
    # Panthers will only have this constructor, and no default constructor.
@@ -636,9 +630,9 @@ meow(Lion("brown","ROAAR")) # => "ROAAR"
 meow(Panther())  # => "grrr"

 # Review the local type hierarchy
-issubtype(Tiger,Cat) # => false
-issubtype(Lion,Cat) # => true
-issubtype(Panther,Cat) # => true
+Tiger <: Cat # => false
+Lion <: Cat # => true
+Panther <: Cat # => true

 # Defining a function that takes Cats
 function pet_cat(cat::Cat)
@@ -681,7 +675,8 @@ try
    fight(Panther(), Lion("RAWR"))
 catch e
    println(e)
-  # => MethodError(fight, (Panther("green"), Lion("green", "RAWR")), 0x000000000000557b)
+    # => MethodError(fight, (Panther("green"), Lion("green", "RAWR")),
+    #                0x000000000000557b)
 end

 # Also let the cat go first
@@ -689,10 +684,12 @@ fight(c::Cat,l::Lion) = println("The cat beats the Lion")

 # This warning is because it's unclear which fight will be called in:
 try
-  fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+    fight(Lion("RAR"), Lion("brown", "rarrr"))
+    # => prints The victorious cat says rarrr
 catch e
    println(e)
-  # => MethodError(fight, (Lion("green", "RAR"), Lion("brown", "rarrr")), 0x000000000000557c)
+  # => MethodError(fight, (Lion("green", "RAR"), Lion("brown", "rarrr")),
+  #                0x000000000000557c)
 end
 # The result may be different in other versions of Julia

@@ -705,7 +702,7 @@ fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie

 square_area(l) = l * l  # square_area (generic function with 1 method)

-square_area(5) #25
+square_area(5)  # => 25

 # What happens when we feed square_area an integer?
 code_native(square_area, (Int32,))
@@ -780,6 +777,6 @@ code_native(circle_area, (Float64,))

 ## Further Reading

-You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/#Manual-1)
+You can get a lot more detail from the [Julia Documentation](https://docs.julialang.org/)

 The best place to get help with Julia is the (very friendly) [Discourse forum](https://discourse.julialang.org/).