Einführung in Python numpy pandas matplotlib (für ~ B3 ~ part2)

Verwenden wir das Modul!

Eine der Stärken von Python ist die große Anzahl von Modulen und Bibliotheken. Selbst wenn Sie nicht nacheinander Allzweckfunktionen und -klassen definieren, können Sie die Arbeitseffizienz erheblich verbessern, indem Sie Open-Source-Module verwenden, die in der Vergangenheit als Prototyp erstellt oder von unseren Vorgängern erstellt wurden.

Verwenden wir jetzt eine typische Bibliothek!

Numpy Numpy ist eine schnelle und effiziente Bibliothek für numerische Berechnungen in Python. Verwenden Sie die Anweisung import, wenn Sie die Bibliothek verwenden.

import numpy as np

Durch Hinzufügen von "as" am Ende der "import" -Anweisung Sie können den Namen des Moduls in Ihrem Code in XX ändern. Dieses Mal wird numpy in np geändert. numpy verwendet ein eigenes Array (ein Array der ndarray-Klasse). Das Folgende sind Beispiele für Objekte der Klasse "ndarray".

import numpy as np

#Deklaration des Numpy-Arrays
a = np.arange(15).reshape(3, 5)
b = np.array([1.2,3.5,5.1])
c = ([(1.5,2,3),(4,5,6)])
print(a)
print(b)
#Array-Form
print(a.shape)
#Array-Dimensionen
print(a.ndim)
#Array-Elementtypen
print(a.dtype.name)
#Anzahl der Elemente im Array
print(a.size)

#Anzeige des Arrays
#Array a
[[ 0  1  2  3  4 ]
 [ 5  6  7  8  9 ] 
 [10 11 12 13 14 ]]
#Array b
[1.2 3.5 5.1 ]
#Sequenz c
[(1.5, 2, 3), (4, 5, 6)]
#Array-Form
(3, 5)
#Anzahl der Dimensionen des Arrays
2
#Array-Elementtypen
int64
#Anzahl der Elemente im Array
15

Sie können ein Numpy-Array mithilfe des Attributs ** array ** generieren. Mehrdimensionale Arrays können ebenfalls einfach erstellt werden. Verwenden Sie die Eigenschaft ** shape **, um die Anzahl der Elemente wie Zeilen und Spalten zu überprüfen. Sie können die Gesamtzahl der Elemente mit der Eigenschaft ** size ** überprüfen. Wenn Sie überprüfen möchten, welchen Typ die Elemente der Matrix haben (int, float usw.) Sie können dies tun, indem Sie die Eigenschaft ** type ** verwenden.

Nullmatrix Leere Matrix

Nullmatrix, Matrix mit allen Elementen auf 1 gesetzt, leere Matrix Sie können es auch generieren.

import numpy as np

print(np.zeros((3,4)))
print(np.ones((2,3,4),dtype = np.int16))
print(np.empty((2,3)))

#Nullmatrix
[[0. 0. 0. 0. ]
 [0. 0. 0. 0. ]
 [0. 0. 0. 0. ] ]

#Eine Matrix mit allen Elementen 1
[[[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1] ]

 [[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1 ] ] ]

#Leere Numpy-Matrix
[[1.39069238e-309 1.39069238e-309 1.39069238e-309 ]
 [1.39069238e-309 1.39069238e-309 1.39069238e-309 ] ]

Herausforderungen

Lassen Sie uns aus einer Nullmatrix eine 5 * 5-Einheitenmatrix erstellen. Ich überlasse es Ihnen, wie die diagonalen Komponenten platziert werden.

Anordnung von Elementen mit Seriennummern und Überspringen 〇

Wie oben erwähnt, können Sie auch das Attribut ** arrangieren ** verwenden, um ein Numpy-Array zu generieren, in dem Elemente in der angegebenen Reihenfolge eingegeben werden. In np.arange. (Stop) wird n bis 0 <= n <stop nacheinander eingegeben. In np.arange. (Start, Stop) wird n bis start <= n <stop nacheinander eingegeben. Mit np.arange. (Start, Stopp, Schritt) wird n bis zu Start <= n <Stopp durch Überspringen von Schritt eingegeben. Die zu überspringende Nummer entspricht einer kleinen Nummer.

print(np.arange(10))
print(np.arange(0,10))
print(np.arange(10,30,5))
print(np.arange(0,2,0.3))

[0 1 2 3 4 5 6 7 8 9 ]
[0 1 2 3 4 5 6 7 8 9 ]
[10 15 20 25 ]
[0.  0.3 0.6 0.9 1.2 1.5 1.8 ]

Es gibt auch ein ** Linspace-Attribut **, das den Bereich "[start: stop)" in regelmäßigen Abständen in die angegebene Anzahl von Elementen unterteilt.

print(np.linspace(0,2,9))

[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]

Vier Regeln des Numpy-Arrays

In den vier Regeln des Numpy-Arrays wird die Berechnung grundsätzlich zwischen denselben Zeilen- und Spaltenelementen durchgeführt.

A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
print(A+B)
print(A-B)
print(A*B)

#A+B
[[3 1 ]
 [3 5 ] ]
#A-B
[[ - 1  1 ]
 [ - 3 - 3 ] ]
#A*B
[[2 0 ]
 [0 4 ] ]

Wenn Sie das innere Produkt finden möchten, anstatt die quadratischen Elemente zu multiplizieren, verwenden Sie "@" oder "Punktfunktion".

print(A@B)
print(A.dot(B))

#A@B
[[5 4 ]
 [3 4 ]]
#A.dot(B)
[[5 4 ]
 [3 4 ]]

Quartäre Quadratwurzel

Die Leistung von Numpy-Arrays wird zwischen Arrays berechnet (A ** B) Die B [i] -Leistung von A [i] wird ausgegeben. Die Quadratwurzel wird auch für jedes Element verarbeitet.

a = np.arange(1, 11, 1)
b = np.array([1,2,1,2,1,2,1,2,1,2])
print(np.power(a, b))
print(np.sqrt(a))

[  1   4   3  16   5  36   7  64   9 100 ]
[1.   1.41421356 1.73205081 
 2.   2.23606798 2.44948974 2.64575131 2.82842712 
 3.   3.16227766 ]

Trigonometrische Funktion

Numpy unterstützt auch Dreiecks- und Bikurvenfunktionen. Seien Sie vorsichtig, da das Argument ** Radian ** ist.

print(np.sin(0))
print(np.cos(0))
print(np.tan(np.pi/4))
print(np.tanh(2))

0.0
1.0
0.9999999999999999
0.9640275800758169

Es gibt auch eine inverse Dreiecksfunktion. Die Ausgabe ist auch ** Radian **.

print(np.arcsin(1.0))
print(np.arcsin(1.0)*2/np.pi)
print(np.arccos(-1.0))
print(np.arctan(-0.5))

#arcsin(1.0)
1.5707963267948966
#arcsin(1.0)*2/np.pi
1.0
#arccos(-1.0)
3.141592653589793
#arctan(-0.5)
- 0.4636476090008061

Elemente zählen

Es gibt mehrere Funktionen, die alle Elemente eines Numpy-Arrays zählen.

onehot = np.array([0, 1, 1, 0, 1, 0, 1, 1])

#Beispiel für das Zählen der Zahl 1
print(np.count_nonzero(onehot))                    
print(len(np.where(onehot != 0)[0])) 

#Beispiel für das Zählen der Zahl 0
print(np.count_nonzero(1 - onehot)) 
 
#Beispiel für das gleichzeitige Zählen von 0 und 1
#Verwendung einer einzigartigen Funktion
print(np.unique(onehot, return_counts=True))

#Anzeige im Wörterbuchtyp
unique, count = np.unique(onehot, return_counts=True)
print(dict(zip(unique, count)))

#Verwendung der Bincount-Funktion
c = np.bincount(onehot)
print(c)   

#Nummer 1
5    #count_nonzero
5    #len(np.where(onehot != 0)[0])
#Nummer 0
3    #count_nonzero(1 - onehot)
#Zur gleichen Zeit zählen
(array([0, 1]), array([3, 5]))    #unique
{0: 3, 1: 5}                      #Wörterbuchtyp
[3 5 ]                            #

Insbesondere zählen die "eindeutige Funktion" und die "Bindungsfunktion" alle Arten von Elementen. Der Unterschied zwischen den beiden besteht darin, dass die "eindeutige Funktion" nicht die Anzahl der Werte anzeigt, die im Numpy-Array nicht vorhanden sind.

A = np.array([2,3,4,3,4,4,4,6,7,1])
#Verwendung einer einzigartigen Funktion
u,c = np.unique(A,return_counts=True)
print(dict(zip(u,c)))
#Verwendung der Bincount-Funktion
print(np.bincount(A))

#Verwendung einer einzigartigen Funktion
{1: 1, 2: 1, 3: 2, 4: 4, 6: 1, 7: 1}
#Verwendung der Bincount-Funktion
[0 1 1 2 4 0 1 1 ]

Herausforderungen

Erstellen Sie ein Array von Werten, die in jede sin-Funktion mit π / 4 eingegeben werden (von 0 bis 4π). Zähle jedes Element.

Extrahieren Sie das größte und das kleinste Element

Verwenden Sie die Funktionen "argmax" und "argmin", um die Indizes (Indizes) der größten und kleinsten Elemente des Arrays abzurufen. Der Index (Index) ist die Position des Elements.

A = np.array([2,4,3,6,7,8,8,5,4,7,8])
#Maximalwert des Elements
print(np.max(A))
#Maximaler Index
print(np.argmax(A))
print(A.argmax())
#Mindestwert des Elements
print(np.min(A))
#Minimaler Index
print(np.argmin(A))
print(A.argmin())

#Maximalwert des Elements
8
#Index des Maximalwerts des Elements
5
5
#Mindestwert des Elements
2
#Index des Mindestwerts des Elements
0
0

Die argmax, argmin Funktion ist Es gibt zwei Typen: "np.argmax (argmin)" und "np.ndarray.argmax (argmin)". Die Funktion "np.argmax" gibt ein Array als erstes Argument der Funktion und an Die Funktion "np.ndarray.argmax" wird verwendet, indem sie wie eine Methode aufgerufen wird. Der Index "5" des größten Elements von Array A ab Index "0" wird ausgegeben. Jedes Argument hat einen "Achse" -Parameter, der auch in einem mehrdimensionalen Array nach den Maximal- und Minimalwerten auf der angegebenen Achse sucht.

B = np.array([[2,4,5],[9,2,8]])
#Achse(axis=0)Maximalwert jedes Elements basierend auf
print(B.max(axis=0))
#Achse(axis=0)Index des Maximalwerts jedes Elements basierend auf
print(B.argmax(axis=0))
#Achse(axis=1)Maximalwert jedes Elements als Referenz
print(B.max(axis=1))
#Achse(axis=1)Index des Maximalwerts jedes Elements basierend auf
print(B.argmax(axis=1))

#Achse(axis=0)Maximalwert jedes Elements basierend auf
[9 4 8 ]
#Achse(axis=0)Index des Maximalwerts jedes Elements basierend auf
[1 0 1 ]
#Achse(axis=1)Maximalwert jedes Elements als Referenz
[5 9 ]
#Achse(axis=1)Index des Maximalwerts jedes Elements basierend auf
[2 0 ]

Wenn "Achse = 0" ist, wird der Index des Maximalwerts jeder Spalte des Arrays ausgegeben. Wenn "Achse = 1" ist, wird der Index des Maximalwerts jeder Zeile des Arrays ausgegeben.

Herausforderungen

Array früherer Aufgaben Maximal- und Minimalwerte Finden Sie den ersten Index.

Pandas Pandas ist ein schnelles, leistungsstarkes, flexibles und benutzerfreundliches Open-Source-Tool zur Analyse und Bearbeitung von Daten. Importieren wir zunächst die Bibliothek.

import pandas as pd

Laden Sie als Nächstes das Iris-Dataset aus dem UCI Machine Learning Repository. In Pandas heißt die Datentabelle ** DataFrame **. df ist eine Abkürzung, daher hat der Name keine besondere Bedeutung. Oft als "df" deklariert.

import pandas as pd
#Anzeigen von Datenrahmen
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',header=None)
print(df)

#Anzeigen von Datenrahmen
       0    1    2    3               4
0    5.1  3.5  1.4  0.2     Iris-setosa
1    4.9  3.0  1.4  0.2     Iris-setosa
2    4.7  3.2  1.3  0.2     Iris-setosa
3    4.6  3.1  1.5  0.2     Iris-setosa
4    5.0  3.6  1.4  0.2     Iris-setosa
..   ...  ...  ...  ...             ...
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

[150 rows x 5 columns]

Ich denke, ich könnte es so lesen. Wenn Sie nur den Anfang und das Ende überprüfen möchten, verwenden Sie die Funktion "Kopf, Schwanz".

#Anzeige der ersten 10 Zeilen
print(df.head(n=10))
#Anzeige der letzten 5 Zeilen
print(df.tail(n=5))

#Anzeige der ersten 10 Zeilen
     0    1    2    3            4
0  5.1  3.5  1.4  0.2  Iris-setosa
1  4.9  3.0  1.4  0.2  Iris-setosa
2  4.7  3.2  1.3  0.2  Iris-setosa
3  4.6  3.1  1.5  0.2  Iris-setosa
4  5.0  3.6  1.4  0.2  Iris-setosa
5  5.4  3.9  1.7  0.4  Iris-setosa
6  4.6  3.4  1.4  0.3  Iris-setosa
7  5.0  3.4  1.5  0.2  Iris-setosa
8  4.4  2.9  1.4  0.2  Iris-setosa
9  4.9  3.1  1.5  0.1  Iris-setosa
#Anzeige der letzten 5 Zeilen
       0    1    2    3               4
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

Lassen Sie uns die Form des Datensatzes überprüfen.

#Überprüfen Sie die Anzahl der Zeilen und Spalten
print(df.shape)
#Index prüfen
print(df.index)
#Überprüfen Sie die Spalte
print(df.columns)
#Überprüfen Sie den Datentyp jeder Spalte des Datenrahmens
print(df.dtypes)

#Überprüfen Sie die Anzahl der Zeilen und Spalten
(150, 5)
#Index prüfen
RangeIndex(start=0, stop=150, step=1)
#Überprüfen Sie die Spalte
Int64Index([0, 1, 2, 3, 4], dtype='int64')
#Überprüfen Sie den Datentyp jeder Spalte des Datenrahmens
0    float64
1    float64
2    float64
3    float64
4     object
dtype: object

Datenrahmenstatistiken können mit der Funktion "description ()" gefunden werden.

print(df.describe())

                0           1           2           3
count  150.000000  150.000000  150.000000  150.000000
mean     5.843333    3.054000    3.758667    1.198667
std      0.828066    0.433594    1.764420    0.763161
min      4.300000    2.000000    1.000000    0.100000
25%      5.100000    2.800000    1.600000    0.300000
50%      5.800000    3.000000    4.350000    1.300000
75%      6.400000    3.300000    5.100000    1.800000
max      7.900000    4.400000    6.900000    2.500000

Sie können auch nur einen Teil des Datenrahmens abrufen.

#100~Holen Sie sich 109. Daten
print(df[100:110],"\n\n")
#Holen Sie sich nur die 100. Daten
print(df.loc[100],"\n\n")
#0~Holen Sie sich nur die 4. Spalte von 100 Zeilen
print(df.iloc[0:100,4])

       0    1    2    3               4
100  6.3  3.3  6.0  2.5  Iris-virginica
101  5.8  2.7  5.1  1.9  Iris-virginica
102  7.1  3.0  5.9  2.1  Iris-virginica
103  6.3  2.9  5.6  1.8  Iris-virginica
104  6.5  3.0  5.8  2.2  Iris-virginica
105  7.6  3.0  6.6  2.1  Iris-virginica
106  4.9  2.5  4.5  1.7  Iris-virginica
107  7.3  2.9  6.3  1.8  Iris-virginica
108  6.7  2.5  5.8  1.8  Iris-virginica
109  7.2  3.6  6.1  2.5  Iris-virginica 


0               6.3
1               3.3
2                 6
3               2.5
4    Iris-virginica
Name: 100, dtype: object 


0         Iris-setosa
1         Iris-setosa
2         Iris-setosa
3         Iris-setosa
4         Iris-setosa
           ...       
95    Iris-versicolor
96    Iris-versicolor
97    Iris-versicolor
98    Iris-versicolor
99    Iris-versicolor
Name: 4, Length: 100, dtype: object

Feature-Feature-Mapping bestellen

Zum Beispiel, wenn die Merkmalsmenge wie die Größe der Kleidung bestellt wird, indem die Merkmalsmenge einer ganzen Zahl usw. zugeordnet wird. Lernalgorithmen können Ordnungsmerkmale korrekt interpretieren. Es ermöglicht auch die umgekehrte Konvertierung.

df = pd.DataFrame([
                   ['green','M',10.1,'class1'],
                   ['red','L',13.5,'class2'],
                   ['blue','XL',15.3,'class1']
])
#Spaltennamen festlegen
df.columns = ['color','size','price','classlabel']
print(df,"\n")
size_mapping = {'XL':3,'L':2,'M':1}
df['size']= df['size'].map(size_mapping)
print(df,"\n")
#Definieren Sie eine Funktion für die inverse Konvertierung
inv_size_mapping = {v:k for k,v in size_mapping.items()}
df['size']=df['size'].map(inv_size_mapping)
print(df)

   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1 
#Nach der Konvertierung
   color  size  price classlabel
0  green     1   10.1     class1
1    red     2   13.5     class2
2   blue     3   15.3     class1 
#Nach inverser Umwandlung
   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1

Klassenbeschriftungscodierung

Bibliotheken für maschinelles Lernen erfordern häufig Klassenbezeichnungen als ganzzahlige Werte. Codieren Sie sie daher. Bereiten Sie die inverse Konvertierung sowie die bestellte Merkmalsmenge vor.

class_mapping = {label:idx for idx, label in enumerate(np.unique(df['classlabel']))}
df['classlabel']=df['classlabel'].map(class_mapping)
print(df,"\n")
inv_class_mapping = {v : k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
print(df)

   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0 

   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0

One-Hot-Codierung

Konvertieren Sie kategoriale Variablen in Dummy-Variablen

Es ist selten, dass die Klassifizierungselemente der Klassifizierungsklassifizierung für maschinelles Lernen von Anfang an numerische Werte wie Klasse 1, Klasse 2 ... sind. Wenn Sie beispielsweise Männer und Frauen klassifizieren, ist es möglicherweise einfacher, sie in Dummy-Variablen wie 0 und 1 zu konvertieren. Möglicherweise möchten Sie auch Funktionen für mehrere Klassen in eine One-Hot-Darstellung konvertieren. In einem solchen Fall ist die Funktion "get_dummies ()" praktisch. Dieses Mal führen wir eine ** One-Hot-Codierung ** für Farben durch, bei denen es sich um eine Art von Merkmalsmenge handelt, die als nominale Merkmalsmenge in keiner Reihenfolge bezeichnet wird.

pd.get_dummies(df[['price','color','size']])

    price size	color_blue	color_green	color_red
0	10.1	1      0	        1           0
1	13.5	2      0	        0           1
2	15.3	3      1	        0           0

Fehlende Werte auffüllen

Nicht alle Daten sind vollständig gefüllt. In solchen Fällen müssen Sie die fehlenden Werte (NaN) eingeben.

from io import StringIO
#Beispieldaten erstellen
csv_data = '''A,B,C,D 
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df)
print(df.describe())

Wobei StringIO der der Variablen csv_data zugewiesene String ist Ich benutze es, damit es in ein DataFrame-Objekt eingelesen werden kann.

    A     B     C   D 
0   1.0   2.0   3.0  4.0
1   5.0   6.0   NaN  8.0
2  10.0  11.0  12.0  NaN
               A          B          C        D 
count   3.000000   3.000000   2.000000  2.000000
mean    5.333333   6.333333   7.500000  6.000000
std     4.509250   4.509250   6.363961  2.828427
min     1.000000   2.000000   3.000000  4.000000
25%     3.000000   4.000000   5.250000  5.000000
50%     5.000000   6.000000   7.500000  6.000000
75%     7.500000   8.500000   9.750000  7.000000
max    10.000000  11.000000  12.000000  8.000000

In diesem DataFrame wurden zwei fehlende Werte gefunden. Wenn der DataFrame sehr groß ist, gibt es eine Grenze für die visuelle Überprüfung. Versuchen Sie daher, mit der Funktion isnull () nach fehlenden Daten zu suchen.

print(df.isnull(),"\n")
print(df.isnull().sum())

       A      B      C     D 
0  False  False  False  False
1  False  False   True  False
2  False  False  False   True 

A     0
B     0
C     1
D     1
dtype: int64

Jetzt wissen wir, dass in den Spalten C und D Werte fehlen. Dieses Mal werden wir diese mit dem Median anderer Werte in derselben Spalte ergänzen. Verwenden Sie zum Abschluss die Funktion fillna ().

df["C"]=df["C"].fillna(df["C"].median())
df["D"]=df["D"].fillna(df["D"].median())
print(df.isnull().sum())

A    0
B    0
C    0
D    0
dtype: int64

Dies füllt die fehlenden Werte aus.

Andererseits ist es auch möglich, Zeilen und Spalten mit fehlenden Werten mit der Methode "dropna ()" zu löschen.

csv_data = '''A,B,C,D
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df.dropna(),"\n")
print(df.dropna(axis=1))

     A    B    C    D
0  1.0  2.0  3.0  4.0 

      A     B
0   1.0   2.0
1   5.0   6.0
2  10.0  11.0

Wenn in der `dropna () -Methode nichts in das Argument eingefügt wird, werden die Zeile (Achse = 0) und die Achse in das Argument eingefügt, um die Spalte zu löschen, die den fehlenden Wert in axialer Richtung enthält.

Herausforderungen von hier

https://www.kaggle.com/ Holen Sie sich den Datensatz von kaggle.

Geben Sie Mein Konto ein.

Klicken

Ich denke, die Datei Kaggle.json ist gespeichert. Wechseln Sie zu Google Colab.

Gib Folgendes ein:

from google.colab import files
files.upload()
!mkdir -p ~/.kaggle
!mv kaggle.json ~/.kaggle/
!chmod 600 /root/.kaggle/kaggle.json
!pip install kaggle
!kaggle competitions download -c titanic

Dann startet files.upload () Ein solches Dateiauswahlfeld wird angezeigt. Wählen Sie daher die zuvor gespeicherte Datei Kaggle.json aus. Dann speichert der folgende Befehl die Titandaten im Kaggle-Ordner. Verwenden Sie also diese Zugdaten.

df = pd.read_csv('/content/train.csv',header=None)
print(df.tail(n=10))

     0  1  2   ...       9     10 11
882  882  0  3  ...   7.8958   NaN  S
883  883  0  3  ...  10.5167   NaN  S
884  884  0  2  ...     10.5   NaN  S
885  885  0  3  ...     7.05   NaN  S
886  886  0  3  ...   29.125   NaN  Q
887  887  0  2  ...       13   NaN  S
888  888  1  1  ...       30   B42  S
889  889  0  3  ...    23.45   NaN  S
890  890  1  1  ...       30  C148  C
891  891  0  3  ...     7.75   NaN  Q

[10 rows x 12 columns ]

1. Suchen Sie die Spalte, die den fehlenden Wert enthält.
2. Füllen Sie Spalten mit fehlenden Werten, die Zahlen mit Medianwerten angeben.
3. Setzen Sie ein S in den fehlenden Wert der Spalte, deren Spalte eingeschifft ist (der häufigste Wert war "S").
4. Löschen Sie die verbleibenden Spalten mit den am meisten fehlenden Elementen.
5. Wenn das Element eine Zeichenfolge ist, konvertieren wir die Elemente der Spalte "Geschlecht" und der Spalte "Eingeschifft" als Dummy in numerische Werte. Sex besteht jedoch aus zwei Kategorien von "männlich" und "weiblich", und "Eingeschifft" besteht aus drei Zeichenfolgen von "S", "C" und "Q".

Matplotlib ** Matplotlib ** ist eine umfassende Bibliothek zum Erstellen statischer, animierter und interaktiver Visualisierungen. Visualisierung ist eine relativ wichtige Aufgabe. In vielen Fällen kann die Korrelation durch Visualisierung von Daten gesehen werden, die mit nur einer Zeichenfolge schwer zu erkennen sind. Importieren wir es jetzt.

import matplotlib.pyplot as plt

Zeichnen wir eine einfache gerade Linie.

plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Zeichnen Sie die Daten mit der "Plotfunktion". Dieses Mal wird dasjenige, das der x-Achse entspricht, nicht explizit beschrieben, aber wenn ein einzelnes Array angegeben wird, wird es automatisch als eine Folge von y-Werten betrachtet und ein x-Wert wird erzeugt. Sie können den Beschriftungsnamen der y-Achse mit der Funktion "ylabel" angeben. So funktioniert das x-zu-y-Diagramm.

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('x-axis')
plt.ylabel('y-axis')

Natürlich können Sie auch streuen.

import numpy as np
t = np.arange(0., 5., 0.2)
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bX', t, t**3, 'g^',t,t**4,'y*')
plt.show()

Hier sind "r -", "bs", "g ^", "y-" usw. Ploteinstellungen, und das erste alphabetische Zeichen ist die Farbabkürzung. Es gibt acht Arten von Abkürzungen: {b (lue), g (ray), r (ed), c (ian), m (asenta), y (gelb), k (augenplatte schwarz), w (hite)} es gibt. Wenn Sie andere Farben ausprobieren möchten https://qiita.com/KntKnk0328/items/5ef40d9e77308dd0d0a4 Siehe hier. Darüber hinaus sind die Linientypen des Diagramms wie folgt.

Es gibt verschiedene Marker.

3D-Zeichnung, Konturlinienzeichnung

Es ist auch möglich, ein Diagramm im 3D-Raum als Konturlinie oder als 3D-Diagramm anzuzeigen.

from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#Rasterpunkte erstellen
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
#Berechnung des Wertes der Funktion an jedem Punkt
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

fig_1 = plt.figure()
ax = Axes3D(fig_1)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.viridis)
fig_2, ax_2 = plt.subplots(figsize=(8, 6))
#Anzeige von Konturlinien
contour = ax_2.contourf(X, Y, Z)
#Farbbalkenanzeige
fig_2.colorbar(contour)
plt.show()

Erstellen Sie zunächst einen Rasterpunkt mit der Funktion numpy.meshgrid. Berechnen Sie dann den Wert der Funktion auf den Gitterpunkten. Diesmal zeichne ich Z. Das Zeichnen eines 3D-Diagramms erfolgt durch Übergabe von "plot_surface (X, Y, Z)" als Argument. Die Bedeutung anderer Argumente ist

Konturlinien werden mit der Funktion "countourf" gezeichnet. Außerdem wird die Entsprechungstabelle (Farbbalken) der Werte für die Konturlinien angezeigt, indem die Konturlinien an die "Farbleistenfunktion" übergeben werden.

Herausforderungen

Zeichnen wir Ihre Lieblings-3D-Daten!

Färben Sie den geschlossenen Bereich

Die Funktion "fill_between" unterstützt das Füllen des Bereichs, der erstellt werden kann, wenn zwei oder mehr Funktionen vorhanden sind.

x = np.arange(0,5,0.01)
y1 = np.sin(x) 
y2 = np.cos(x)
plt.plot(x,y1,color='k',label="sin")
plt.plot(x,y2,color='r',label="cos")
plt.legend()
plt.fill_between(x,y1,y2,color='b',alpha = 0.1)

Zeigen Sie ein Bild oder ein zweidimensionales Array an

Verwenden Sie die Imshow-Funktion, um ein vorhandenes Bild oder ein zweidimensionales Array anzuzeigen, das die Werte jedes Pixels enthält. Das Bild wird angezeigt, indem ein Array-Objekt oder ein PIL-Bild als erstes Argument übergeben wird.

Speichern Sie Ihr Lieblingsbild im JPEG-Format und beginnen Sie mit der Datei auf der linken Seite

Ich werde es hochladen.

import matplotlib.image as mpimg
img = mpimg.imread("〇〇.jpg ")
plt.imshow(img)

Wenn Sie den Dateinamen anstelle von "j.jpg " eingeben, sollte das Bild angezeigt werden.

Gehen Sie wie folgt vor, um das Array anzuzeigen. Zeichnen wir ein zweidimensionales zufälliges Array.

x = np.random.random((100, 100))
plt.imshow(x, cmap="plasma")
plt.colorbar()