Delimited Files

    Read a matrix from the source where each line (separated by ) gives one row, with elements separated by the given delimiter. The source can be a text file, stream or byte array. Memory mapped files can be used by passing the byte array representation of the mapped segment as source.

    If T is a numeric type, the result is an array of that type, with any non-numeric elements as NaN for floating-point types, or zero. Other useful values of T include String, AbstractString, and Any.

    If header is true, the first row of data will be read as header and the tuple (data_cells, header_cells) is returned instead of only data_cells.

    Specifying skipstart will ignore the corresponding number of initial lines from the input.

    If skipblanks is true, blank lines in the input will be ignored.

    If use_mmap is true, the file specified by source is memory mapped for potential speedups if the file is large. Default is false. On a Windows filesystem, use_mmap should not be set to true unless the file is only read once and is also not written to. Some edge cases exist where an OS is Unix-like but the filesystem is Windows-like.

    If quotes is true, columns enclosed within double-quote (“) characters are allowed to contain new lines and column delimiters. Double-quote characters within a quoted field must be escaped with another double-quote. Specifying dims as a tuple of the expected rows and columns (including header, if any) may speed up reading of large files. If comments is true, lines beginning with comment_char and text following comment_char in any line are ignored.

    Examples

    1. julia> using DelimitedFiles
    3. julia> x = [1; 2; 3; 4];
    5. julia> y = [5; 6; 7; 8];
    7. julia> open("delim_file.txt", "w") do io
    8.            writedlm(io, [x y])
    9.        end
    11. julia> readdlm("delim_file.txt", '\t', Int, '\n')
    13.  1  5
    14.  2  6
    15.  3  7
    16.  4  8
    18. julia> rm("delim_file.txt")
    1. readdlm(source, delim::AbstractChar, eol::AbstractChar; options...)

    If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a heterogeneous array of numbers and strings is returned.

    — Method

    1. readdlm(source, delim::AbstractChar, T::Type; options...)

    The end of line delimiter is taken as \n.

    Examples

    DelimitedFiles.readdlm — Method

    1. readdlm(source, delim::AbstractChar; options...)

    The end of line delimiter is taken as \n. If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a heterogeneous array of numbers and strings is returned.

    Examples

    1. julia> using DelimitedFiles
    4. julia> y = [1.1; 2.2; 3.3; 4.4];
    6. julia> open("delim_file.txt", "w") do io
    7.            writedlm(io, [x y], ',')
    8.        end;
    10. julia> readdlm("delim_file.txt", ',')
    11. 4×2 Matrix{Float64}:
    12.  1.0  1.1
    13.  2.0  2.2
    14.  3.0  3.3
    15.  4.0  4.4
    17. julia> z = ["a"; "b"; "c"; "d"];
    19. julia> open("delim_file.txt", "w") do io
    20.            writedlm(io, [x z], ',')
    21.        end;
    23. julia> readdlm("delim_file.txt", ',')
    24. 4×2 Matrix{Any}:
    25.  1  "a"
    26.  3  "c"
    27.  4  "d"
    29. julia> rm("delim_file.txt")

    — Method

    1. readdlm(source, T::Type; options...)

    Examples

    DelimitedFiles.readdlm — Method

    1. readdlm(source; options...)

    The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as \n. If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a heterogeneous array of numbers and strings is returned.

    Examples

    1. julia> using DelimitedFiles
    3. julia> x = [1; 2; 3; 4];
    5. julia> y = ["a"; "b"; "c"; "d"];
    7. julia> open("delim_file.txt", "w") do io
    8.            writedlm(io, [x y])
    9.        end;
    11. julia> readdlm("delim_file.txt")
    12. 4×2 Matrix{Any}:
    13.  1  "a"
    14.  2  "b"
    15.  3  "c"
    16.  4  "d"

    — Function

    1. writedlm(f, A, delim='\t'; opts)

    Write A (a vector, matrix, or an iterable collection of iterable rows) as text to f (either a filename string or an IO stream) using the given delimiter delim (which defaults to tab, but can be any printable Julia object, typically a Char or AbstractString).

    For example, two vectors x and y of the same length can be written as two columns of tab-delimited text to f by either writedlm(f, [x y]) or by .

    Examples