分隔符文件

DelimitedFiles.readdlm — Method

  1. readdlm(source, delim::AbstractChar, T::Type, eol::AbstractChar; header=false, skipstart=0, skipblanks=true, use_mmap, quotes=true, dims, comments=false, comment_char='#')

Read a matrix from the source where each line (separated by eol) 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_mmapshould not be set totrue` 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')
  12. 4×2 Matrix{Int64}:
  13.  1  5
  14.  2  6
  15.  3  7
  16.  4  8
  18. julia> rm("delim_file.txt")

DelimitedFiles.readdlm — Method

  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.

DelimitedFiles.readdlm — Method

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

The end of line delimiter is taken as \n.

Examples

  1. julia> using DelimitedFiles
  3. julia> x = [1; 2; 3; 4];
  5. julia> y = [1.1; 2.2; 3.3; 4.4];
  7. julia> open("delim_file.txt", "w") do io
  8.            writedlm(io, [x y], ',')
  9.        end;
  11. julia> readdlm("delim_file.txt", ',', Float64)
  12. 4×2 Matrix{Float64}:
  13.  1.0  1.1
  14.  2.0  2.2
  15.  3.0  3.3
  16.  4.0  4.4
  18. julia> rm("delim_file.txt")

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
  3. julia> x = [1; 2; 3; 4];
  5. julia> y = [1.1; 2.2; 3.3; 4.4];
  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{Float64}:
  13.  1.0  1.1
  14.  2.0  2.2
  15.  3.0  3.3
  16.  4.0  4.4
  18. julia> z = ["a"; "b"; "c"; "d"];
  20. julia> open("delim_file.txt", "w") do io
  21.            writedlm(io, [x z], ',')
  22.        end;
  24. julia> readdlm("delim_file.txt", ',')
  25. 4×2 Matrix{Any}:
  26.  1  "a"
  27.  2  "b"
  28.  3  "c"
  29.  4  "d"
  31. julia> rm("delim_file.txt")

DelimitedFiles.readdlm — Method

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

The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as \n.

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", Int64)
  12. 4×2 Matrix{Int64}:
  13.  1  5
  14.  2  6
  15.  3  7
  16.  4  8
  18. julia> readdlm("delim_file.txt", Float64)
  19. 4×2 Matrix{Float64}:
  20.  1.0  5.0
  21.  2.0  6.0
  22.  3.0  7.0
  23.  4.0  8.0
  25. julia> rm("delim_file.txt")

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"
  18. julia> rm("delim_file.txt")

DelimitedFiles.writedlm — 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 writedlm(f, zip(x, y)).

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')
  12. 4×2 Matrix{Int64}:
  13.  1  5
  14.  2  6
  15.  3  7
  16.  4  8
  18. julia> rm("delim_file.txt")