U
|
¬ý°d(- ã 2 @ sd d Z ddlmZ ddlmZ ddlZddlZddlmZ ddl m
|
Z
|
ddl m Z m Z mZmZmZmZmZmZ ddlZddlZddlmZ dd lmZ dd
|
lm Z m Z m Z m Z m Z m!Z!m"Z"m#Z# dd l$m%Z%m&Z& dd l'm(Z( dd l)m*Z* ddl+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9m:Z:m;Z;m<Z< ddl=m>Z> ddl?m@Z@mAZAmBZB ddlCmDZD ddlEmFZFmGZG ded HeIe¡ddd d ZJd d d d dd ZKd!d"dd#ZLd$hZMd%d&hZNd$d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d%hZOG d6d7 d7eZPed£d9d:d9d;d<d=ZQed¤d>d:d:d;d?d=ZQed¥d@d:d@d;dAd=ZQd¦dBd:d@d;dCd=ZQdDd9dEdFdGZRdHdIdJdKdLZSed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8dM/dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdUdVdTdWdTdTdXd@dYdWdZdWdZd:dTdWdWdWdWd[dTdTd\d]d^d_d`)dadbZTed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8dc/dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdUdVdTdWdTdTdTd:dYdWdZdWdZd:dTdWdWdWdWd[dTdTd\d]d^d_d`)dddbZTed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8de0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdUdVdTdWdTdTdfd9dYdWdZdWdZd:dTdWdWdWdWd[dTdTd\d]d^dgd`)dhdbZTed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8de0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdUdVdTdWdTdTdTd@dYdWdZdWdZd:dTdWdWdWdWd[dTdTd\d]d^dId`)didbZTe(eJjUdbdjdke7dl e7dm dn doejVdd!ejVdddddddd ddddd d d d dejVd ejVdd d d dd!ddpddqejWd ddddrddsd eKd% d ddejVde0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdUdVdTdWdTdTdTd@dYdWdZdWdZd:dTdWdWdWdWd[dZdTdTd\d]d^dIdt*dudbZTed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8dM/dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdvdVdTdWdTdTdXd@dYdWdZdWdZd:dTdWdWdWdWd[dTdTdWd]d^d_d`)dwdxZXed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8dc/dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdvdVdTdWdTdTdTd:dYdWdZdWdZd:dTdWdWdWdWd[dTdTdWd]d^d_d`)dydxZXed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8de0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdvdVdTdWdTdTdfd9dYdWdZdWdZd:dTdWdWdWdWd[dTdTdWd]d^dgd`)dzdxZXed8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8de0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdvdVdTdWdTdTdTd@dYdWdZdWdZd:dTdWdWdWdWd[dTdTdWd]d^dId`)d{dxZXe(eJjUdxd|d}e7dl e7dm dn doejVdd!ejVdddddddd ddddd d d d d ejVd ejVdd d d dd!ddpddqejWd ddddrddsd eKd% d ddejVde0dHdNdNdOdPdQdRdSdTd:d@dTdTdTdTdvdVdTdWdTdTdTd@dYdWdZdWdZd:dTdWdWdWdWd[dZdTdTdWd]d^dIdt*d~dxZXd!dd"ejVddHddd:d^dIdddZYG d
d_ d_ejZZ[d_dddZ\d§dTdddZ]dd Z^dd Z_d[dNdTdSdNddPdd^d ddZ`dddddZadZbdd9dddZcdddddd Zddd9dd¡d¢ZedS )¨z
|
Module contains tools for processing files into DataFrames or other objects
|
|
GH#48849 provides a convenient way of deprecating keyword arguments
|
é )Ú annotations)ÚabcN)Úfill)Ú TracebackType)ÚIOÚAnyÚCallableÚHashableÚLiteralÚ
|
NamedTupleÚSequenceÚoverload)Úlib)Ú STR_NA_VALUES)ÚCompressionOptionsÚ CSVEngineÚDtypeArgÚ DtypeBackendÚFilePathÚ
|
IndexLabelÚ ReadCsvBufferÚStorageOptions)ÚAbstractMethodErrorÚ ParserWarning)ÚAppender)Úfind_stack_level)Úcheck_dtype_backend)Ú is_file_likeÚis_floatÚ
|
is_integerÚ is_list_like)Ú DataFrame)Ú
|
RangeIndex)Ú _shared_docs)Ú IOHandlesÚ
|
get_handleÚstringify_pathÚvalidate_header_arg)ÚArrowParserWrapper)Ú
|
ParserBaseÚ is_index_colÚparser_defaults)ÚCParserWrapper)ÚFixedWidthFieldParserÚ PythonParseraá
|
{summary}
|
|
Also supports optionally iterating or breaking of the file
|
into chunks.
|
|
Additional help can be found in the online docs for
|
`IO Tools <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
|
|
Parameters
|
----------
|
filepath_or_buffer : str, path object or file-like object
|
Any valid string path is acceptable. The string could be a URL. Valid
|
URL schemes include http, ftp, s3, gs, and file. For file URLs, a host is
|
expected. A local file could be: file://localhost/path/to/table.csv.
|
|
If you want to pass in a path object, pandas accepts any ``os.PathLike``.
|
|
By file-like object, we refer to objects with a ``read()`` method, such as
|
a file handle (e.g. via builtin ``open`` function) or ``StringIO``.
|
sep : str, default {_default_sep}
|
Delimiter to use. If sep is None, the C engine cannot automatically detect
|
the separator, but the Python parsing engine can, meaning the latter will
|
be used and automatically detect the separator by Python's builtin sniffer
|
tool, ``csv.Sniffer``. In addition, separators longer than 1 character and
|
different from ``'\s+'`` will be interpreted as regular expressions and
|
will also force the use of the Python parsing engine. Note that regex
|
delimiters are prone to ignoring quoted data. Regex example: ``'\r\t'``.
|
delimiter : str, default ``None``
|
Alias for sep.
|
header : int, list of int, None, default 'infer'
|
Row number(s) to use as the column names, and the start of the
|
data. Default behavior is to infer the column names: if no names
|
are passed the behavior is identical to ``header=0`` and column
|
names are inferred from the first line of the file, if column
|
names are passed explicitly then the behavior is identical to
|
``header=None``. Explicitly pass ``header=0`` to be able to
|
replace existing names. The header can be a list of integers that
|
specify row locations for a multi-index on the columns
|
e.g. [0,1,3]. Intervening rows that are not specified will be
|
skipped (e.g. 2 in this example is skipped). Note that this
|
parameter ignores commented lines and empty lines if
|
``skip_blank_lines=True``, so ``header=0`` denotes the first line of
|
data rather than the first line of the file.
|
names : array-like, optional
|
List of column names to use. If the file contains a header row,
|
then you should explicitly pass ``header=0`` to override the column names.
|
Duplicates in this list are not allowed.
|
index_col : int, str, sequence of int / str, or False, optional, default ``None``
|
Column(s) to use as the row labels of the ``DataFrame``, either given as
|
string name or column index. If a sequence of int / str is given, a
|
MultiIndex is used.
|
|
Note: ``index_col=False`` can be used to force pandas to *not* use the first
|
column as the index, e.g. when you have a malformed file with delimiters at
|
the end of each line.
|
usecols : list-like or callable, optional
|
Return a subset of the columns. If list-like, all elements must either
|
be positional (i.e. integer indices into the document columns) or strings
|
that correspond to column names provided either by the user in `names` or
|
inferred from the document header row(s). If ``names`` are given, the document
|
header row(s) are not taken into account. For example, a valid list-like
|
`usecols` parameter would be ``[0, 1, 2]`` or ``['foo', 'bar', 'baz']``.
|
Element order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.
|
To instantiate a DataFrame from ``data`` with element order preserved use
|
``pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]`` for columns
|
in ``['foo', 'bar']`` order or
|
``pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]``
|
for ``['bar', 'foo']`` order.
|
|
If callable, the callable function will be evaluated against the column
|
names, returning names where the callable function evaluates to True. An
|
example of a valid callable argument would be ``lambda x: x.upper() in
|
['AAA', 'BBB', 'DDD']``. Using this parameter results in much faster
|
parsing time and lower memory usage.
|
dtype : Type name or dict of column -> type, optional
|
Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32,
|
'c': 'Int64'}}
|
Use `str` or `object` together with suitable `na_values` settings
|
to preserve and not interpret dtype.
|
If converters are specified, they will be applied INSTEAD
|
of dtype conversion.
|
|
.. versionadded:: 1.5.0
|
|
Support for defaultdict was added. Specify a defaultdict as input where
|
the default determines the dtype of the columns which are not explicitly
|
listed.
|
engine : {{'c', 'python', 'pyarrow'}}, optional
|
Parser engine to use. The C and pyarrow engines are faster, while the python engine
|
is currently more feature-complete. Multithreading is currently only supported by
|
the pyarrow engine.
|
|
.. versionadded:: 1.4.0
|
|
The "pyarrow" engine was added as an *experimental* engine, and some features
|
are unsupported, or may not work correctly, with this engine.
|
converters : dict, optional
|
Dict of functions for converting values in certain columns. Keys can either
|
be integers or column labels.
|
true_values : list, optional
|
Values to consider as True in addition to case-insensitive variants of "True".
|
false_values : list, optional
|
Values to consider as False in addition to case-insensitive variants of "False".
|
skipinitialspace : bool, default False
|
Skip spaces after delimiter.
|
skiprows : list-like, int or callable, optional
|
Line numbers to skip (0-indexed) or number of lines to skip (int)
|
at the start of the file.
|
|
If callable, the callable function will be evaluated against the row
|
indices, returning True if the row should be skipped and False otherwise.
|
An example of a valid callable argument would be ``lambda x: x in [0, 2]``.
|
skipfooter : int, default 0
|
Number of lines at bottom of file to skip (Unsupported with engine='c').
|
nrows : int, optional
|
Number of rows of file to read. Useful for reading pieces of large files.
|
na_values : scalar, str, list-like, or dict, optional
|
Additional strings to recognize as NA/NaN. If dict passed, specific
|
per-column NA values. By default the following values are interpreted as
|
NaN: 'z', 'éF z )Úsubsequent_indenta;) '.
|
keep_default_na : bool, default True
|
Whether or not to include the default NaN values when parsing the data.
|
Depending on whether `na_values` is passed in, the behavior is as follows:
|
|
* If `keep_default_na` is True, and `na_values` are specified, `na_values`
|
is appended to the default NaN values used for parsing.
|
* If `keep_default_na` is True, and `na_values` are not specified, only
|
the default NaN values are used for parsing.
|
* If `keep_default_na` is False, and `na_values` are specified, only
|
the NaN values specified `na_values` are used for parsing.
|
* If `keep_default_na` is False, and `na_values` are not specified, no
|
strings will be parsed as NaN.
|
|
Note that if `na_filter` is passed in as False, the `keep_default_na` and
|
`na_values` parameters will be ignored.
|
na_filter : bool, default True
|
Detect missing value markers (empty strings and the value of na_values). In
|
data without any NAs, passing na_filter=False can improve the performance
|
of reading a large file.
|
verbose : bool, default False
|
Indicate number of NA values placed in non-numeric columns.
|
skip_blank_lines : bool, default True
|
If True, skip over blank lines rather than interpreting as NaN values.
|
parse_dates : bool or list of int or names or list of lists or dict, default False
|
The behavior is as follows:
|
|
* boolean. If True -> try parsing the index.
|
* list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
|
each as a separate date column.
|
* list of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and parse as
|
a single date column.
|
* dict, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
|
result 'foo'
|
|
If a column or index cannot be represented as an array of datetimes,
|
say because of an unparsable value or a mixture of timezones, the column
|
or index will be returned unaltered as an object data type. For
|
non-standard datetime parsing, use ``pd.to_datetime`` after
|
``pd.read_csv``.
|
|
Note: A fast-path exists for iso8601-formatted dates.
|
infer_datetime_format : bool, default False
|
If True and `parse_dates` is enabled, pandas will attempt to infer the
|
format of the datetime strings in the columns, and if it can be inferred,
|
switch to a faster method of parsing them. In some cases this can increase
|
the parsing speed by 5-10x.
|
|
.. deprecated:: 2.0.0
|
A strict version of this argument is now the default, passing it has no effect.
|
|
keep_date_col : bool, default False
|
If True and `parse_dates` specifies combining multiple columns then
|
keep the original columns.
|
date_parser : function, optional
|
Function to use for converting a sequence of string columns to an array of
|
datetime instances. The default uses ``dateutil.parser.parser`` to do the
|
conversion. Pandas will try to call `date_parser` in three different ways,
|
advancing to the next if an exception occurs: 1) Pass one or more arrays
|
(as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the
|
string values from the columns defined by `parse_dates` into a single array
|
and pass that; and 3) call `date_parser` once for each row using one or
|
more strings (corresponding to the columns defined by `parse_dates`) as
|
arguments.
|
|
.. deprecated:: 2.0.0
|
Use ``date_format`` instead, or read in as ``object`` and then apply
|
:func:`to_datetime` as-needed.
|
date_format : str or dict of column -> format, default ``None``
|
If used in conjunction with ``parse_dates``, will parse dates according to this
|
format. For anything more complex,
|
please read in as ``object`` and then apply :func:`to_datetime` as-needed.
|
|
.. versionadded:: 2.0.0
|
dayfirst : bool, default False
|
DD/MM format dates, international and European format.
|
cache_dates : bool, default True
|
If True, use a cache of unique, converted dates to apply the datetime
|
conversion. May produce significant speed-up when parsing duplicate
|
date strings, especially ones with timezone offsets.
|
|
iterator : bool, default False
|
Return TextFileReader object for iteration or getting chunks with
|
``get_chunk()``.
|
|
.. versionchanged:: 1.2
|
|
``TextFileReader`` is a context manager.
|
chunksize : int, optional
|
Return TextFileReader object for iteration.
|
See the `IO Tools docs
|
<https://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_
|
for more information on ``iterator`` and ``chunksize``.
|
|
.. versionchanged:: 1.2
|
|
``TextFileReader`` is a context manager.
|
{decompression_options}
|
|
.. versionchanged:: 1.4.0 Zstandard support.
|
|
thousands : str, optional
|
Thousands separator.
|
decimal : str, default '.'
|
Character to recognize as decimal point (e.g. use ',' for European data).
|
lineterminator : str (length 1), optional
|
Character to break file into lines. Only valid with C parser.
|
quotechar : str (length 1), optional
|
The character used to denote the start and end of a quoted item. Quoted
|
items can include the delimiter and it will be ignored.
|
quoting : int or csv.QUOTE_* instance, default 0
|
Control field quoting behavior per ``csv.QUOTE_*`` constants. Use one of
|
QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3).
|
doublequote : bool, default ``True``
|
When quotechar is specified and quoting is not ``QUOTE_NONE``, indicate
|
whether or not to interpret two consecutive quotechar elements INSIDE a
|
field as a single ``quotechar`` element.
|
escapechar : str (length 1), optional
|
One-character string used to escape other characters.
|
comment : str, optional
|
Indicates remainder of line should not be parsed. If found at the beginning
|
of a line, the line will be ignored altogether. This parameter must be a
|
single character. Like empty lines (as long as ``skip_blank_lines=True``),
|
fully commented lines are ignored by the parameter `header` but not by
|
`skiprows`. For example, if ``comment='#'``, parsing
|
``#empty\na,b,c\n1,2,3`` with ``header=0`` will result in 'a,b,c' being
|
treated as the header.
|
encoding : str, optional, default "utf-8"
|
Encoding to use for UTF when reading/writing (ex. 'utf-8'). `List of Python
|
standard encodings
|
<https://docs.python.org/3/library/codecs.html#standard-encodings>`_ .
|
|
.. versionchanged:: 1.2
|
|
When ``encoding`` is ``None``, ``errors="replace"`` is passed to
|
``open()``. Otherwise, ``errors="strict"`` is passed to ``open()``.
|
This behavior was previously only the case for ``engine="python"``.
|
|
.. versionchanged:: 1.3.0
|
|
``encoding_errors`` is a new argument. ``encoding`` has no longer an
|
influence on how encoding errors are handled.
|
|
encoding_errors : str, optional, default "strict"
|
How encoding errors are treated. `List of possible values
|
<https://docs.python.org/3/library/codecs.html#error-handlers>`_ .
|
|
.. versionadded:: 1.3.0
|
|
dialect : str or csv.Dialect, optional
|
If provided, this parameter will override values (default or not) for the
|
following parameters: `delimiter`, `doublequote`, `escapechar`,
|
`skipinitialspace`, `quotechar`, and `quoting`. If it is necessary to
|
override values, a ParserWarning will be issued. See csv.Dialect
|
documentation for more details.
|
on_bad_lines : {{'error', 'warn', 'skip'}} or callable, default 'error'
|
Specifies what to do upon encountering a bad line (a line with too many fields).
|
Allowed values are :
|
|
- 'error', raise an Exception when a bad line is encountered.
|
- 'warn', raise a warning when a bad line is encountered and skip that line.
|
- 'skip', skip bad lines without raising or warning when they are encountered.
|
|
.. versionadded:: 1.3.0
|
|
.. versionadded:: 1.4.0
|
|
- callable, function with signature
|
``(bad_line: list[str]) -> list[str] | None`` that will process a single
|
bad line. ``bad_line`` is a list of strings split by the ``sep``.
|
If the function returns ``None``, the bad line will be ignored.
|
If the function returns a new list of strings with more elements than
|
expected, a ``ParserWarning`` will be emitted while dropping extra elements.
|
Only supported when ``engine="python"``
|
|
delim_whitespace : bool, default False
|
Specifies whether or not whitespace (e.g. ``' '`` or ``' '``) will be
|
used as the sep. Equivalent to setting ``sep='\s+'``. If this option
|
is set to True, nothing should be passed in for the ``delimiter``
|
parameter.
|
low_memory : bool, default True
|
Internally process the file in chunks, resulting in lower memory use
|
while parsing, but possibly mixed type inference. To ensure no mixed
|
types either set False, or specify the type with the `dtype` parameter.
|
Note that the entire file is read into a single DataFrame regardless,
|
use the `chunksize` or `iterator` parameter to return the data in chunks.
|
(Only valid with C parser).
|
memory_map : bool, default False
|
If a filepath is provided for `filepath_or_buffer`, map the file object
|
directly onto memory and access the data directly from there. Using this
|
option can improve performance because there is no longer any I/O overhead.
|
float_precision : str, optional
|
Specifies which converter the C engine should use for floating-point
|
values. The options are ``None`` or 'high' for the ordinary converter,
|
'legacy' for the original lower precision pandas converter, and
|
'round_trip' for the round-trip converter.
|
|
.. versionchanged:: 1.2
|
|
{storage_options}
|
|
.. versionadded:: 1.2
|
|
dtype_backend : {{"numpy_nullable", "pyarrow"}}, defaults to NumPy backed DataFrames
|
Which dtype_backend to use, e.g. whether a DataFrame should have NumPy
|
arrays, nullable dtypes are used for all dtypes that have a nullable
|
implementation when "numpy_nullable" is set, pyarrow is used for all
|
dtypes if "pyarrow" is set.
|
|
The dtype_backends are still experimential.
|
|
.. versionadded:: 2.0
|
|
Returns
|
-------
|
DataFrame or TextFileReader
|
A comma-separated values (csv) file is returned as two-dimensional
|
data structure with labeled axes.
|
|
See Also
|
--------
|
DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
|
read_csv : Read a comma-separated values (csv) file into DataFrame.
|
read_fwf : Read a table of fixed-width formatted lines into DataFrame.
|
|
Examples
|
--------
|
>>> pd.{func_name}('data.csv') # doctest: +SKIP
|
FT)Údelim_whitespaceÚ na_filterÚ
|
low_memoryÚ
|
memory_mapÚfloat_precisionÚinferéd )ÚcolspecsÚ infer_nrowsÚwidthsÚ
|
skipfooterr3 r5 Ú chunksizeÚcommentÚnrowsÚ thousandsr4 ÚdialectÚ on_bad_linesr1 ÚquotingÚlineterminatorÚ
|
convertersÚiteratorÚdayfirstÚverboseÚskipinitialspacec @ s e Zd ZU ded< ded< dS )Ú_DeprecationConfigr Ú default_valueú
|
str | NoneÚmsgN)Ú__name__Ú
|
__module__Ú __qualname__Ú__annotations__© rQ rQ úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/io/parsers/readers.pyrI Ò s
|
rI .ÚNoneÚint)ÚvalÚmin_valÚreturnc C s d S ©NrQ ©ÚnamerU rV rQ rQ rR Úvalidate_integer× s r[ Úfloatc C s d S rX rQ rY rQ rQ rR r[ Ü s ú
|
int | Nonec C s d S rX rQ rY rQ rQ rR r[ á s zint | float | Nonec C sf |dkr |S d| dd|d}t |rFt||kr<t|t|}nt|rV||ks^t|t|S )a½
|
Checks whether the 'name' parameter for parsing is either
|
an integer OR float that can SAFELY be cast to an integer
|
without losing accuracy. Raises a ValueError if that is
|
not the case.
|
|
Parameters
|
----------
|
name : str
|
Parameter name (used for error reporting)
|
val : int or float
|
The value to check
|
min_val : int
|
Minimum allowed value (val < min_val will result in a ValueError)
|
Nú'Úsz' must be an integer >=Úd)r rT Ú
|
ValueErrorr )rZ rU rV rL rQ rQ rR r[ æ s
|
zSequence[Hashable] | None)ÚnamesrW c C sH | dk rDt | t t| kr$tdt| ddsDt| tjsDtddS )aZ
|
Raise ValueError if the `names` parameter contains duplicates or has an
|
invalid data type.
|
|
Parameters
|
----------
|
names : array-like or None
|
An array containing a list of the names used for the output DataFrame.
|
|
Raises
|
------
|
ValueError
|
If names are not unique or are not ordered (e.g. set).
|
Nz Duplicate names are not allowed.F)Z
|
allow_setsz&Names should be an ordered collection.)ÚlenÚsetra r Ú
|
isinstancer ÚKeysView)rb rQ rQ rR Ú_validate_names s
|
ÿ
|
ÿrg z4FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str]zDataFrame | TextFileReader)Úfilepath_or_bufferrW c
|
C sð | dd¡dkrF| dtj¡tjkr>| dd¡dkr>d|d< nd|d< | dd¡}| dd¡}| d ¡d
|
kr|rxtd |dk rtd n td|d }| dd¡}t| dd¡ t| f|}|sÆ|rÊ|S | | |¡W 5 Q R £ S Q R X dS )z Generic reader of line files.Ú parse_datesNÚ date_parserÚ date_formatFTrE r< ÚengineÚpyarrowz@The 'iterator' option is not supported with the 'pyarrow' enginezAThe 'chunksize' option is not supported with the 'pyarrow' engineé r> rb )Úgetr Ú
|
no_defaultra r[ rg ÚTextFileReaderÚread)rh ÚkwdsrE r< r> ÚparserrQ rQ rR Ú_read s4 ÿþ
|
ÿÿ ru )/ÚsepÚ delimiterÚheaderrb Ú index_colÚusecolsÚdtyperl rD Ú true_valuesÚ false_valuesrH Úskiprowsr; r> Ú na_valuesÚkeep_default_nar2 rG Úskip_blank_linesri Úinfer_datetime_formatÚ keep_date_colrj rk rF Ú cache_datesr< Ú compressionr? ÚdecimalrC Ú quotecharrB Ú doublequoteÚ
|
escapecharr= ÚencodingÚencoding_errorsr@ rA r1 r3 r4 r5 Ústorage_optionsÚ dtype_backendzstr | None | lib.NoDefaultz-int | Sequence[int] | None | Literal['infer']z)Sequence[Hashable] | None | lib.NoDefaultz"IndexLabel | Literal[False] | NonezDtypeArg | NoneúCSVEngine | NoneÚboolz bool | Sequence[Hashable] | Nonezbool | lib.NoDefaultrK z Literal[True]r Ústrzstr | csv.Dialect | Nonez"Literal[('high', 'legacy')] | Noner z DtypeBackend | lib.NoDefaultrq ))rh rv rw rx rb ry r{ rl rH r; r> r r2 rG r ri r r rk rF r rE r< r
r? r rC r rB r r r= r r r@ r1 r4 r5 r r rW c 0 1 C s d S rX rQ ©1rh rv rw rx rb ry rz r{ rl rD r| r} rH r~ r; r> r r r2 rG r ri r r rj rk rF r rE r< r
r? r rC r rB r r r= r r r@ rA r1 r3 r4 r5 r r rQ rQ rR Úread_csvK s 5r )/rv rw rx rb ry rz r{ rl rD r| r} rH r~ r; r> r r r2 rG r ri r r rj rk rF r rE r
r? r rC r rB r r r= r r r@ rA r1 r3 r4 r5 r r c 0 1 C s d S rX rQ r rQ rQ rR r s 5)0rv rw rx rb ry rz r{ rl rD r| r} rH r~ r; r> r r r2 rG r ri r r rj rk rF r rE r< r
r? r rC r rB r r r= r r r@ rA r1 r3 r4 r5 r r zLiteral[False]r! c 0 1 C s d S rX rQ r rQ rQ rR r ½ s 5c 0 1 C s d S rX rQ r rQ rQ rR r ö s 5z8Read a comma-separated values (csv) file into DataFrame.z','r Údecompression_optionsrh )Ú func_nameÚsummaryZ _default_sepr r Ú.ú"ÚstrictÚerror)*rh rv rw rx rb ry r{ rl rH r; r> r r2 rG r ri r r rk rF r rE r< r
r? r rC r rB r r r= r r r@ rA r1 r4 r5 r r rW c 0 3 C sd |t jk r tjdtt d t ¡ }1|1d= |1d= t|)||+|||*|ddi|0d }2|1 |2¡ t
|
| |1S )NúùThe argument 'infer_datetime_format' is deprecated and will be removed in a future version. A strict version of it is now the default, see https://pandas.pydata.org/pdeps/0004-consistent-to-datetime-parsing.html. You can safely remove this argument.©Ú
|
stacklevelrh rv rw ú,©Údefaultsr © r rp ÚwarningsÚwarnÚ FutureWarningr ÚlocalsÚcopyÚ_refine_defaults_readÚupdateru ©3rh rv rw rx rb ry rz r{ rl rD r| r} rH r~ r; r> r r r2 rG r ri r r rj rk rF r rE r< r
r? r rC r rB r r r= r r r@ rA r1 r3 r4 r5 r r rs Z kwds_defaultsrQ rQ rR r . s, F
|
ù
|
|
÷
|
zbool | Sequence[Hashable]c 0 1 C s d S rX rQ r rQ rQ rR Ú
|
read_table s 5r© c 0 1 C s d S rX rQ r rQ rQ rR r© Í s 5c 0 1 C s d S rX rQ r rQ rQ rR r© s 5c 0 1 C s d S rX rQ r rQ rQ rR r© ? s 5z+Read general delimited file into DataFrame.z'\\t' (tab-stop)c 0 3 C sd |t jk r tjdtt d t ¡ }1|1d= |1d= t|)||+|||*|ddi|0d }2|1 |2¡ t
|
| |1S )Nr r rh rv rw ú r r r¨ rQ rQ rR r© w s, F
|
ù
|
÷
|
)r8 r: r9 r z&Sequence[tuple[int, int]] | str | NonezSequence[int] | None)rh r8 r: r9 r rW c K s< |dkr|dkrt d|dkr0|dk r0t d|dk rfg d }}|D ] }| ||| f¡ ||7 }qF|dk srt| d¡}|dk r
|
t|t|kr
|
|dkr
|
d} | d¡dk rÜ| d¡}
|
|
|
d k rÜt|
|
sÔd
|
} nt|
|
} | d ¡dkr
|
t|| t|kr
|
t d ||d < ||d< d|d< t| ||d< t| |S )aH
|
Read a table of fixed-width formatted lines into DataFrame.
|
|
Also supports optionally iterating or breaking of the file
|
into chunks.
|
|
Additional help can be found in the `online docs for IO Tools
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
|
|
Parameters
|
----------
|
filepath_or_buffer : str, path object, or file-like object
|
String, path object (implementing ``os.PathLike[str]``), or file-like
|
object implementing a text ``read()`` function.The string could be a URL.
|
Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
|
expected. A local file could be:
|
``file://localhost/path/to/table.csv``.
|
colspecs : list of tuple (int, int) or 'infer'. optional
|
A list of tuples giving the extents of the fixed-width
|
fields of each line as half-open intervals (i.e., [from, to[ ).
|
String value 'infer' can be used to instruct the parser to try
|
detecting the column specifications from the first 100 rows of
|
the data which are not being skipped via skiprows (default='infer').
|
widths : list of int, optional
|
A list of field widths which can be used instead of 'colspecs' if
|
the intervals are contiguous.
|
infer_nrows : int, default 100
|
The number of rows to consider when letting the parser determine the
|
`colspecs`.
|
dtype_backend : {"numpy_nullable", "pyarrow"}, defaults to NumPy backed DataFrames
|
Which dtype_backend to use, e.g. whether a DataFrame should have NumPy
|
arrays, nullable dtypes are used for all dtypes that have a nullable
|
implementation when "numpy_nullable" is set, pyarrow is used for all
|
dtypes if "pyarrow" is set.
|
|
The dtype_backends are still experimential.
|
|
.. versionadded:: 2.0
|
|
**kwds : optional
|
Optional keyword arguments can be passed to ``TextFileReader``.
|
|
Returns
|
-------
|
DataFrame or TextFileReader
|
A comma-separated values (csv) file is returned as two-dimensional
|
data structure with labeled axes.
|
|
See Also
|
--------
|
DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
|
read_csv : Read a comma-separated values (csv) file into DataFrame.
|
|
Examples
|
--------
|
>>> pd.read_fwf('data.csv') # doctest: +SKIP
|
Nz&Must specify either colspecs or widths)Nr6 z4You must specify only one of 'widths' and 'colspecs'r rb r6 ry Frn rz z-Length of colspecs must match length of namesr8 r9 ú
|
python-fwfrl r )ra ÚappendÚAssertionErrorro rc r r ru ) rh r8 r: r9 r rs ÚcolÚwrb Z len_indexry rQ rQ rR Úread_fwfÝ s8 C
|
|
|
|
|
&r° c @ sÚ e Zd ZdZd0ddddddZdd d
|
d Zd d dddZd ddddZd d ddddZdd ddZ d1dd d dd d Z
|
dd d d Z d2d!dd"d#d$Z d3d!dd%d&d'Z d d d(d)Zd*d+d,dd-d.d/ZdS )4rq zF
|
|
Passed dialect overrides any of the related parser options
|
|
Nz;FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | listr rS )Úfrl rW c K s |d k rd}nd}d}|| _ | d|¡| _t| t|}|d k r\|dkrRtdt||}| dd¡dkr| d ¡d kr~d
|
nd |d< || _d
|
| _| |¡}| d d ¡|d < |
|
d d ¡| _ |
|
d d ¡| _ | ||¡ | ||¡\| _| _ d|krþ|d | jd< d | _| || j ¡| _d S )NTÚpythonFÚengine_specifiedrm z?The 'dialect' option is not supported with the 'pyarrow' enginerx r6 rb r r r< r> Zhas_index_names)rl ro Ú_engine_specifiedÚ_validate_skipfooterÚ_extract_dialectra Ú _merge_with_dialect_propertiesÚ orig_optionsÚ_currowÚ_get_options_with_defaultsÚpopr< r> Ú_check_file_or_bufferÚ_clean_optionsÚoptionsÚhandlesÚ _make_engineÚ_engine)Úselfr± rl rs r³ r@ r¾ rQ rQ rR Ú__init__R s8 ÿ
|
|
zTextFileReader.__init__©rW c C s" | j d k r| j ¡ | j ¡ d S rX )r¿ ÚcloserÁ ©r rQ rQ rR rÅ s
|
|
zTextFileReader.closer údict[str, Any])rl rW c C s | j }i }t ¡ D ]X\}}| ||¡}|dkrb|tkrb||krb|t|d|krbtdt| d|||< qt ¡ D ]f\}}||krÎ|| }|dkrÒ||krÒd|kr®|t kr®qÒtdt| dt| dn|}|||< qt|d krt
|
¡ D ]\}}| ||¡||< qî|S )
|
Nrm ÚvaluezThe z2 option is not supported with the 'pyarrow' engineÚcr² z" option is not supported with the z enginer« ) r¸ r+ Úitemsro Ú_pyarrow_unsupportedÚgetattrra ÚreprÚ_c_parser_defaultsÚ_python_unsupportedÚ _fwf_defaults)r rl rs r¾ ÚargnameÚdefaultrÈ rQ rQ rR rº s> ÿþýüÿ
|
ÿ
|
|
z)TextFileReader._get_options_with_defaultsc C s& t |r"|dkr"t|ds"tdd S )NrÉ Ú__iter__z<The 'python' engine cannot iterate through this file buffer.)r Úhasattrra )r r± rl rQ rQ rR r¼ ² s ÿz$TextFileReader._check_file_or_bufferz tuple[dict[str, Any], CSVEngine])r¾ rl rW c C s | ¡ }d }|dkr(|d dkr(d}d}|d }|d }|d kr^|s^|dkr\d | d
|
}d}nÚ|d k r¬t|d kr¬|dkr|d krd |d< |d= n|dkrªd | d}d}n|rÂd|krÀd |d< nv|d k r8d }t ¡ pÚd}zt| |¡d krôd}W n tk
|
r d}Y nX |s8|dkr8d| d| d}d}|d } | d k rt| ttfrt| d krt | dkr|dkrd| d}d}|r¦| j
|
r¦t ||dkrÂt D ] }
|
||
|
= q´d|krt D ]>}
|
|r||
|
t|
|
krt d| dt|
|
d||
|
= qÐ|r0tjd| d tt d |d } |d } |d } |d! }|d" }t|d# | d krvt d$t| rt| tttjfs| g} | |d < | d k r´t| n| } | d k rät| tsètd%t | j ni } |d& }t ||\}}|d'kr&t |s`|d k r`t d(n:t |r<tt |}|d krNt! }nt"|s`t!|}| |d < | |d < ||d!< ||d)< ||d"< ||fS )*NrÉ r; r z*the 'c' engine does not support skipfooterr² rw r1 )rÉ rm zthe 'z>' engine does not support sep=None with delim_whitespace=Falsern z\s+T)r² r« zr' engine does not support regex separators (separators > 1 char and different from '\s+' are interpreted as regex)úutf-8Fzthe separator encoded in z is > 1 char long, and the 'z)' engine does not support such separatorsr é zNord(quotechar) > 127, meaning the quotechar is larger than one byte, and the 'z)' engine does not support such quotecharsz,Falling back to the 'python' engine because z, but this causes z= to be ignored as it is not supported by the 'python' engine.z;; you can avoid this warning by specifying engine='python'.r ry rb rD r r~ rx z)The value of index_col couldn't be 'True'z8Type converters must be a dict or subclass, input was a r rm z@skiprows argument must be an integer when using engine='pyarrow'Ú
|
na_fvalues)#r¥ rc ÚsysÚgetfilesystemencodingÚencodeÚUnicodeDecodeErrorre r ÚbytesÚordr´ ra Ú_c_unsupportedrÏ rÎ rÍ r¡ r¢ r r r' r* ÚlistÚtupleÚnpZndarrayÚdictÚ TypeErrorÚtyperM Ú_clean_na_valuesr Úrangerd Úcallable)r r¾ rl ÚresultZfallback_reasonrv r1 Z
|
encodeabler r Úargry rb rD r r~ r r× rQ rQ rR r½ ½ sÎ
|
ÿ
|
ÿ
|
|
|
ÿ
|
ÿ
|
þý
|
ÿ
|
|
|
ÿ
|
|
ù
|
|
|
|
ÿ
|
ÿ
|
|
|
z TextFileReader._clean_optionsr! c C s. z
|
| ¡ W S tk
|
r( | ¡ Y nX d S rX )Ú get_chunkÚ StopIterationrÅ rÆ rQ rQ rR Ú__next__V s
|
|
zTextFileReader.__next__rÉ z@FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list | IOr) c C s\ t tttd}||kr0td| d| ¡ dt|tsôd}d}|dkrTd}d }n<|d
|
kr| j d d ¡d krtt
|
|t rd}d |kr|d 7 }t ||| j d d ¡| j dd ¡| j dd¡|| j dd¡| j dd ¡d| _ | j d k sêt| j j}n |dkrdt| }t|z|| |f| jW S tk
|
rV | j d k rP| j ¡ Y nX d S )N)rÉ r² rm r« zUnknown engine: z (valid options are ú)TÚrrm FÚrbrÉ r rÕ Úbr
r4 r r r )r r
r4 Úis_textÚerrorsr r² z)Invalid file path or buffer object type: )r, r. r( r- ra Úkeysre rß r¾ ro r& r r% r¿ r Úhandlerä Ú ExceptionrÅ )r r± rl Úmappingrñ ÚmoderL rQ rQ rR rÀ ] sZ üÿ
|
ÿþ ý ø
|
|
|
|
zTextFileReader._make_enginec C s t | d S rX )r rÆ rQ rQ rR Ú_failover_to_python s z"TextFileReader._failover_to_pythonr] )r> rW c C sÜ | j dkr:z| j ¡ }W qØ tk
|
r6 | ¡ Y qØX ntd|}z| j |¡\}}}W n tk
|
rx | ¡ Y nX |d kr´|r®ttt| ¡ }t
|
| j | j | }q¼d}nt|}t |||d}| j |7 _ |S )Nrm r> r )ÚcolumnsÚindex) rl rÁ rr rõ rÅ r[ rc ÚnextÚiterÚvaluesr" r¹ r! )r r> Zdfrú rù Zcol_dictZnew_rowsrQ rQ rR rr s8
|
|
|
ÿüýzTextFileReader.read)ÚsizerW c C sF |d kr| j }| jd k r:| j| jkr(tt|| j| j }| j|dS )N)r> )r< r> r¹ rë Úminrr )r rþ rQ rQ rR rê ¾ s
|
zTextFileReader.get_chunkc C s | S rX rQ rÆ rQ rQ rR Ú __enter__Ç s zTextFileReader.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | None)Úexc_typeÚ exc_valueÚ tracebackrW c C s | ¡ d S rX )rÅ )r r r r rQ rQ rR Ú__exit__Ê s zTextFileReader.__exit__)N)rÉ )N)N)rM rN rO Ú__doc__rà rÅ rº r¼ r½ rì rÀ rø rr rê r r rQ rQ rQ rR rq K s ý/,
|
ý8& rÄ c O s d|d< t | |S )a¤
|
Converts lists of lists/tuples into DataFrames with proper type inference
|
and optional (e.g. string to datetime) conversion. Also enables iterating
|
lazily over chunks of large files
|
|
Parameters
|
----------
|
data : file-like object or list
|
delimiter : separator character to use
|
dialect : str or csv.Dialect instance, optional
|
Ignored if delimiter is longer than 1 character
|
names : sequence, default
|
header : int, default 0
|
Row to use to parse column labels. Defaults to the first row. Prior
|
rows will be discarded
|
index_col : int or list, optional
|
Column or columns to use as the (possibly hierarchical) index
|
has_index_names: bool, default False
|
True if the cols defined in index_col have an index name and are
|
not in the header.
|
na_values : scalar, str, list-like, or dict, optional
|
Additional strings to recognize as NA/NaN.
|
keep_default_na : bool, default True
|
thousands : str, optional
|
Thousands separator
|
comment : str, optional
|
Comment out remainder of line
|
parse_dates : bool, default False
|
keep_date_col : bool, default False
|
date_parser : function, optional
|
|
.. deprecated:: 2.0.0
|
date_format : str or dict of column -> format, default ``None``
|
|
.. versionadded:: 2.0.0
|
skiprows : list of integers
|
Row numbers to skip
|
skipfooter : int
|
Number of line at bottom of file to skip
|
converters : dict, optional
|
Dict of functions for converting values in certain columns. Keys can
|
either be integers or column labels, values are functions that take one
|
input argument, the cell (not column) content, and return the
|
transformed content.
|
encoding : str, optional
|
Encoding to use for UTF when reading/writing (ex. 'utf-8')
|
float_precision : str, optional
|
Specifies which converter the C engine should use for floating-point
|
values. The options are `None` or `high` for the ordinary converter,
|
`legacy` for the original lower precision pandas converter, and
|
`round_trip` for the round-trip converter.
|
|
.. versionchanged:: 1.2
|
r² rl )rq )Úargsrs rQ rQ rR Ú
|
TextParserÓ s 7r )r c C s´ | d kr |rt } nt } t }nt| tr| ¡ }i } | ¡ D ].\}}t|sT|g}|rdt|t B }|| |< q>dd | ¡ D }n*t| s| g} t| } |r¤| t B } t| }| |fS )Nc S s i | ]\}}|t |qS rQ )Ú_floatify_na_values)Ú.0ÚkÚvrQ rQ rR Ú
|
<dictcomp>& s z$_clean_na_values.<locals>.<dictcomp>) r rd re râ r¥ rÊ r Ú_stringify_na_valuesr )r r r× Z old_na_valuesr
|
r rQ rQ rR rå s,
|
|
rå c C sP t }| D ]@}z t|}t |¡s,| |¡ W q
|
tttfk
|
rH Y q
|
X q
|
|S rX )rd r\ rá ÚisnanÚaddrã ra Ú OverflowError)r rè r rQ rQ rR r 3 s
|
r c C sÀ g }| D ]®}| t|¡ | |¡ zHt|}|t|kr`t|}| | d¡ | t|¡ | |¡ W n tttfk
|
r Y nX z| t|¡ W q tttfk
|
r´ Y qX qt|S )z1return a stringified and numeric for these valuesz.0)r¬ r r\ rT rã ra r rd )r rè Úxr rQ rQ rR r @ s$
|
r zstr | CallablerÇ ) r@ rw r1 rl rv rA rb r r c C s\ |d } i }
|
| dk r2|dko,|t jkp,|| k|
|
d< |rH|t jk rHtd|t jkrVdn||
|
d< |dkrj|}|r|t jk rtd|dkrtd|t jkr¤| |
|
d< n||
|
d< |dk r¾d |
|
d
|
< nd |
|
d < d |
|
d
|
< |dkrätjj|
|
d< nd|dkrútjj|
|
d< nN|dkrtjj|
|
d< n6t|r8|dkr.td||
|
d< ntd| dt | ||
|
d< |
|
S )aÌ Validate/refine default values of input parameters of read_csv, read_table.
|
|
Parameters
|
----------
|
dialect : str or csv.Dialect
|
If provided, this parameter will override values (default or not) for the
|
following parameters: `delimiter`, `doublequote`, `escapechar`,
|
`skipinitialspace`, `quotechar`, and `quoting`. If it is necessary to
|
override values, a ParserWarning will be issued. See csv.Dialect
|
documentation for more details.
|
delimiter : str or object
|
Alias for sep.
|
delim_whitespace : bool
|
Specifies whether or not whitespace (e.g. ``' '`` or ``' '``) will be
|
used as the sep. Equivalent to setting ``sep='\s+'``. If this option
|
is set to True, nothing should be passed in for the ``delimiter``
|
parameter.
|
engine : {{'c', 'python'}}
|
Parser engine to use. The C engine is faster while the python engine is
|
currently more feature-complete.
|
sep : str or object
|
A delimiter provided by the user (str) or a sentinel value, i.e.
|
pandas._libs.lib.no_default.
|
on_bad_lines : str, callable
|
An option for handling bad lines or a sentinel value(None).
|
names : array-like, optional
|
List of column names to use. If the file contains a header row,
|
then you should explicitly pass ``header=0`` to override the column names.
|
Duplicates in this list are not allowed.
|
defaults: dict
|
Default values of input parameters.
|
|
Returns
|
-------
|
kwds : dict
|
Input parameters with correct values.
|
|
Raises
|
------
|
ValueError :
|
If a delimiter was specified with ``sep`` (or ``delimiter``) and
|
``delim_whitespace=True``.
|
rw NÚ sep_overridez:Specified a sep and a delimiter; you can only specify one.rb zXSpecified a delimiter with both sep and delim_whitespace=True; you can only specify one.Ú
|
z¯Specified \n as separator or delimiter. This forces the python engine which does not accept a line terminator. Hence it is not allowed to use the line terminator as separator.Tr³ rÉ rl Fr rA r¢ Úskipr² z>on_bad_line can only be a callable function if engine='python'z Argument z is invalid for on_bad_linesr )
|
r rp ra r) ZBadLineHandleMethodÚERRORÚWARNZSKIPrç r ) r@ rw r1 rl rv rA rb r r Z delim_defaultrs rQ rQ rR r¦ Y sT 7 ÿÿÿ
|
|
|
|
|
|
ÿ
|
r¦ zcsv.Dialect | None)rs rW c C s< | d¡dkrdS | d }|t ¡ kr0t |¡}t| |S )za
|
Extract concrete csv dialect instance.
|
|
Returns
|
-------
|
csv.Dialect or None
|
r@ N)ro ÚcsvÚ list_dialectsÚ get_dialectÚ_validate_dialect)rs r@ rQ rQ rR r¶ Û s
|
r¶ )rw r r rH r rB z csv.Dialect)r@ rW c C s( t D ] }t| |std| dqdS )zx
|
Validate csv dialect instance.
|
|
Raises
|
------
|
ValueError
|
If incorrect dialect is provided.
|
zInvalid dialect z providedN)ÚMANDATORY_DIALECT_ATTRSrÔ ra )r@ ÚparamrQ rQ rR r ù s
|
r )r@ r rW c C s | ¡ }tD ]}t| |}t| }| ||¡}g }|||fkrtd| d| d| d}|dkrj| dd¡st| |¡ |rtjd |¡t
|
t d |||< q |S )
|
a
|
Merge default kwargs in TextFileReader with dialect parameters.
|
|
Parameters
|
----------
|
dialect : csv.Dialect
|
Concrete csv dialect. See csv.Dialect documentation for more details.
|
defaults : dict
|
Keyword arguments passed to TextFileReader.
|
|
Returns
|
-------
|
kwds : dict
|
Updated keyword arguments, merged with dialect parameters.
|
zConflicting values for 'z': 'z+' was provided, but the dialect specifies 'z%'. Using the dialect-specified value.rw r Fz
|
|
r ) r¥ r rÌ r+ ro r» r¬ r¡ r¢ Újoinr r ) r@ r rs r Z dialect_valZparser_defaultÚprovidedZ conflict_msgsrL rQ rQ rR r· s&
|
ÿ
|
ÿ
|
r· c C s< | d¡r8| d¡s | d¡r&td| d¡r8tddS )a
|
Check whether skipfooter is compatible with other kwargs in TextFileReader.
|
|
Parameters
|
----------
|
kwds : dict
|
Keyword arguments passed to TextFileReader.
|
|
Raises
|
------
|
ValueError
|
If skipfooter is not compatible with other parameters.
|
r; rE r< z('skipfooter' not supported for iterationr> z''skipfooter' not supported with 'nrows'N)ro ra )rs rQ rQ rR rµ = s
|
|
|
rµ ).).).)r )T)fr Ú
|
__future__r Ú collectionsr r rØ Útextwrapr Útypesr Útypingr r r r r
|
r r r r¡ Únumpyrá Z pandas._libsr Zpandas._libs.parsersr Zpandas._typingr r r r r r r r Z pandas.errorsr r Zpandas.util._decoratorsr Zpandas.util._exceptionsr Zpandas.util._validatorsr Zpandas.core.dtypes.commonr r r r Zpandas.core.framer! Zpandas.core.indexes.apir" Zpandas.core.shared_docsr# Zpandas.io.commonr$ r% r& r' Z&pandas.io.parsers.arrow_parser_wrapperr( Z pandas.io.parsers.base_parserr) r* r+ Z"pandas.io.parsers.c_parser_wrapperr, Z pandas.io.parsers.python_parserr- r. r ÚsortedZ_doc_read_csv_and_tablerÎ rÐ rÞ rÏ rË rI r[ rg ru r Úformatrp Ú QUOTE_MINIMALr© r° ÚIteratorrq r rå r r r¦ r¶ r r r· rµ rQ rQ rQ rR Ú<module> s¾ (
|
(
|
yzÿ gû î /Îd8Îd8Îd8Îd7ÿûÿ Æf\Îd8Îd8Îd8Îd7ÿûÿ Æf_ú n ;%
|
6
|
