Zoeken…


Opmerkingen

dtypes zijn niet inheems in panda's. Ze zijn het resultaat van panda's die dicht bij architecturale koppeling aan numpy zijn.

het dtype van een kolom hoeft op geen enkele manier te correleren met het python-type van het object in de kolom.

Hier hebben we een pd.Series met praalwagens. Het dtype zal float .

Vervolgens gebruiken we astype om het te "casten" om bezwaar te maken.

pd.Series([1.,2.,3.,4.,5.]).astype(object)
0    1
1    2
2    3
3    4
4    5
dtype: object

Het dtype is nu object, maar de objecten in de lijst zijn nog steeds zwevend. Logisch als je weet dat in python alles een object is en naar object kan worden opgewaardeerd.

type(pd.Series([1.,2.,3.,4.,5.]).astype(object)[0])
float

Hier proberen we de drijvers aan snaren te "gieten".

pd.Series([1.,2.,3.,4.,5.]).astype(str)
0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
dtype: object

Het dtype is nu object, maar het type invoer in de lijst is string. Dit komt omdat numpy niet met tekenreeksen omgaat en dus werkt alsof het alleen maar objecten zijn en geen probleem zijn.

type(pd.Series([1.,2.,3.,4.,5.]).astype(str)[0])
str

Vertrouw geen dtypes, ze zijn een artefact van een architecturale fout in panda's. Geef ze op zoals u moet, maar vertrouw niet op wat dtype is ingesteld op een kolom.

Controle van de soorten kolommen

Typen kolommen kunnen worden gecontroleerd door .dtypes atrribute of DataFrames.

In [1]: df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.0, 3.0], 'C': [True, False, True]})

In [2]: df
Out[2]:
   A    B      C
0  1  1.0   True
1  2  2.0  False
2  3  3.0   True

In [3]: df.dtypes
Out[3]:
A      int64
B    float64
C       bool
dtype: object

Voor een enkele serie kunt u het kenmerk .dtype gebruiken.

In [4]: df['A'].dtype
Out[4]: dtype('int64')

Dtypes veranderen

astype() methode astype() wijzigt het dtype van een serie en retourneert een nieuwe serie.

In [1]: df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.0, 3.0], 
                           'C': ['1.1.2010', '2.1.2011', '3.1.2011'], 
                           'D': ['1 days', '2 days', '3 days'],
                           'E': ['1', '2', '3']})
In [2]: df
Out[2]:
   A    B          C       D  E
0  1  1.0   1.1.2010  1 days  1
1  2  2.0   2.1.2011  2 days  2
2  3  3.0   3.1.2011  3 days  3

In [3]: df.dtypes
Out[3]:
A      int64
B    float64
C     object
D     object
E     object
dtype: object

Wijzig het type kolom A in zwevend en type kolom B in geheel getal:

In [4]: df['A'].astype('float')
Out[4]:
0    1.0
1    2.0
2    3.0
Name: A, dtype: float64

In [5]: df['B'].astype('int')
Out[5]:
0    1
1    2
2    3
Name: B, dtype: int32

astype() methode astype() is voor een specifieke .astype(float64') u kunt bijvoorbeeld .astype(float64') , .astype(float32) of .astype(float16) . Voor algemene conversie kunt u pd.to_numeric , pd.to_datetime en pd.to_timedelta .

Het type wijzigen in numeriek

pd.to_numeric wijzigt de waarden in een numeriek type.

In [6]: pd.to_numeric(df['E'])
Out[6]:
0    1
1    2
2    3
Name: E, dtype: int64

Standaard geeft pd.to_numeric een foutmelding als een invoer niet naar een getal kan worden geconverteerd. U kunt dat gedrag wijzigen met de parameter errors .

# Ignore the error, return the original input if it cannot be converted
In [7]: pd.to_numeric(pd.Series(['1', '2', 'a']), errors='ignore')
Out[7]:
0    1
1    2
2    a
dtype: object

# Return NaN when the input cannot be converted to a number
In [8]: pd.to_numeric(pd.Series(['1', '2', 'a']), errors='coerce')
Out[8]:
0    1.0
1    2.0
2    NaN
dtype: float64

Indien nodig, vink alle rijen met invoer niet aan naar numeriek gebruik boolean indexing met isnull :

In [9]: df = pd.DataFrame({'A': [1, 'x', 'z'],
                           'B': [1.0, 2.0, 3.0],
                           'C': [True, False, True]})

In [10]: pd.to_numeric(df.A, errors='coerce').isnull()
Out[10]: 
0    False
1     True
2     True
Name: A, dtype: bool

In [11]: df[pd.to_numeric(df.A, errors='coerce').isnull()]
Out[11]: 
   A    B      C
1  x  2.0  False
2  z  3.0   True

Het type wijzigen in datetime

In [12]: pd.to_datetime(df['C'])
Out[12]:
0   2010-01-01
1   2011-02-01
2   2011-03-01
Name: C, dtype: datetime64[ns]

Merk op dat 2.1.2011 wordt geconverteerd naar 1 februari 2011. Als u in plaats daarvan 2 januari 2011 wilt, moet u de parameter dayfirst .

In [13]: pd.to_datetime('2.1.2011', dayfirst=True)
Out[13]: Timestamp('2011-01-02 00:00:00')

Het type wijzigen in timedelta

In [14]: pd.to_timedelta(df['D'])
Out[14]:
0   1 days
1   2 days
2   3 days
Name: D, dtype: timedelta64[ns]

Kolommen selecteren op basis van dtype

select_dtypes methode select_dtypes kan worden gebruikt om kolommen te selecteren op basis van dtype.

In [1]: df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.0, 3.0], 'C': ['a', 'b', 'c'], 
                           'D': [True, False, True]})

In [2]: df
Out[2]: 
   A    B  C      D
0  1  1.0  a   True
1  2  2.0  b  False
2  3  3.0  c   True

Met parameters voor include en exclude kunt u opgeven welke typen u wilt:

# Select numbers
In [3]: df.select_dtypes(include=['number'])  # You need to use a list
Out[3]:
   A    B
0  1  1.0
1  2  2.0
2  3  3.0    

# Select numbers and booleans
In [4]: df.select_dtypes(include=['number', 'bool'])
Out[4]:
   A    B      D
0  1  1.0   True
1  2  2.0  False
2  3  3.0   True

# Select numbers and booleans but exclude int64
In [5]: df.select_dtypes(include=['number', 'bool'], exclude=['int64'])
Out[5]:
     B      D
0  1.0   True
1  2.0  False
2  3.0   True

Samenvatting van de soorten

get_dtype_counts methode get_dtype_counts kan worden gebruikt om een uitsplitsing van dtypes te bekijken.

In [1]: df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.0, 3.0], 'C': ['a', 'b', 'c'], 
                           'D': [True, False, True]})

In [2]: df.get_dtype_counts()
Out[2]: 
bool       1
float64    1
int64      1
object     1
dtype: int64


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow