Python: Dasar-dasar Listas [ ] Metode tidak permanen Diccionarios { key : value , } zip() Pernyataan kontrol

lista = []buat daftar kosong diccionario = {x:y}compuestos por un key(x) unica zip(iterable1, iterable2) membuat daftar tupel dari jika ... elif ... lain
Variabel yang diperluas oleh teks dan sebuah nilai(y) (jenis data apa pun) pasangan dari elemen-elemen di kedua daftar (sementara itu tetapkan syarat agar kode tersebut dijalankan
bisa) ini di bawah if. *harus diindentasikan*
(KONKATENASI) len(lista) mengembalikan jumlah elemen kamus() elif untuk memeriksa lebih banyak kondisi setelah if
variable = dict(x=y, m=n)crear un diccionario [Link]() mengurutkan tuple dari zip berdasarkan yang pertama kelompokkan kondisi yang belum terpenuhi; tidak bisa
min(lista)/max(lista)saring nilai minimum dan maksimum
Untuk mengikat teks elemen membawa kondisi baru
[Link]() mengembalikan jumlah elemen yang ada di [Link]() membuat salinan
categoria1 = "verde" daftar nilai tertentu di () jika x > y:
color_detalle = categoria1 + ' ' + 'oscuro" len(dicc) mengembalikan jumlah elemen (x:y) yang ada di Himpunan {} x lebih besar dari y
mengurutkan(lista) mengurutkan daftar dari yang terkecil ke yang terbesar kamus
tidak memperbolehkan duplikat, tidak memiliki urutan elif x == y:
print(categoria1 + ' gelap') sorted(dicc) mengurutkan kunci; gunakan dengan .items() print("x sama dengan y")
print(categoria1, 'gelap') [Link]() membuat salinan daftar
untuk mengurutkan tuple dari elemen atau .values() set = {x,y} lainnya:
untuk mengurutkan nilai-nilai saja x dan y adalah sama
type() dan isinstance() Metode dengan indeks
set(iterable) hanya memperbolehkan satu argumen iterable; menghapus
duplicados sementara
[Link](x) mengembalikan indeks x dalam daftar
float/int/str(variable) mengubah tipe data/type Kamus–Metode dalam/tidak memeriksa apakah ada elemen
•ulang kode selama kondisi
akan berhenti ketika kondisi adalah False
adalah True, atau dengan kata lain
lista[i] mengembalikan elemen di indeks i
type(variable) mengembalikan: class 'float/int/str' •kondisi dapat disertakan dengan if... elif... else
[start:stop:step] Mengambil informasi dari sebuah kamus len(set) mengembalikan jumlah elemen
•*dapat tak terhingga* (jika kondisi tidak pernah tercapai
lista[i:j:x] mengembalikan elemen dalam rentang i [Link]() mengembalikan semua kunci Salah)
isinstance(variable, float/int/str) memeriksa tipe
a j (termasuk i tapi tidak j) melompat melalui x Memperluas satu set
de dato (mengembalikan True/False) [Link]() mengembalikan semua nilai
lista[-i:-j] mengembalikan elemen berdasarkan indeks [Link]() mengembalikan tuple dari key:value sementara x < 5:
[Link](x)#menambahkan elemen
negatif (termasuk–j tetapi tidak–i) x lebih besar dari 5
tidak/tidak memverifikasi apakah sebuah kunci ada
Operasi Aljabar [Link](x, y) mengembalikan nilai yang terkait dengan kunci x,
[Link](set atau daftar)#menambahkan satu atau lebih elemen dengan
[] o {} o sebuah variabel tipe daftar atau set
+ menjumlah / membagi atau jika tidak ada, kembalikan output dan Untuk loop
restart // pembagi y membulatkan (modulus) Daftar–Tindakan Permanen dicc["key"] mengembalikan nilai dari key (lihat di bawah Menghapus elemen dari himpunan •digunakan untuk mengiterasi semua elemen dalam sebuah variabel
mengalikan % sisa dari pembagian (lantai yang memiliki lebih banyak kegunaan)
** mengangkat [Link]()#menghapus satu elemen secara acak yang harus menjadi iterable (daftar, kamus, tuple,
divisi) Memperluas daftar
round(x) pembulatan angka x [Link](x)#menghapus elemen x set, atau string
[lista1, lista2] gabungkan daftar tetapi tetap terpisah sebagai Memperluas sebuah kamus •dapat digabungkan dengan if ... elif ... else, while, atau yang lainnya
[Link](x)#menghapus elemen x (dan tidak mengembalikan
daftar terpisah
Operasi Biner lista1 + lista2hace una lista mas larga
.perbarui() kesalahan jika tidak ada)
perulangan for

[Link]({x:y})#untuk memasukkan elemen baru •dalam kamus secara default berinteraksi melalui kunci; kita bisa
[Link]()#mengosongkan set
== periksa apakah nilai cocok gunakan [Link]() untuk mengakses values
.tambahkan() dicc["key"] = valor#para inserter un nuevo key o
memeriksa apakah nilai-nilai benar-benar sama nilai, atau mengubah nilai dari sebuah kunci untuk i dalam lista:
!=memeriksa apakah nilai berbeda [Link](x)#menambahkan satu elemen (daftar, Operasi dengan dua Set
dicc. setdefault(x, y)#mengembalikan nilai dari kunci cetak("halo dunia")
tidakmemeriksa apakah nilai tidak persis string, integer atau tuple) ke dalam daftar
x, jika kunci x tidak ada, maka membuatnya dan menetapkan
sama [Link](set2) mengembalikan gabungan dari kedua set: semua
.extend() nilai dan kekurangan
>(=) lebih besar dari (lebih besar atau sama dengan)
[Link](lista2)#menambahkan elemen dari satu
elemen yang kurang ganda. Pemahaman daftar
< (<=)kurang dari (kurang dari atau sama dengan) [Link](set2) mengembalikan elemen-elemen yang umum dari
daftar di akhir daftar
danambas yang sejati Menghapus elemen dari kamus dua set •penggunaan utamanya adalah untuk membuat daftar baru dari sebuah for
Orambas atau hanya yang sebenarnya .masukkan() [Link](x)#menghapus kunci x (dan mengembalikannya) loop dalam satu baris kode
[Link](set2) mengembalikan himpunan yang ada di set1
.insert(i, x)#memasukkan sebuah elemen (x) ke dalam indeks (i)
tidak memeriksa apakah ada nilai dalam daftar, dll. [Link]()#menghapus pasangan key:value terakhir tapi tidak di set2 (mengurangi) [ apa yang ingin kita dapatkan iterable kondisi (opsional) ]
[Link]() #mengosongkan kamus
Mengurutkan daftar set1.symmetric_difference(set2) mengembalikan semua
elemen yang tidak ada di keduanya
Metode String .sort() coba ... kecuali
Tupla (,) tidak dapat diubah, diindeks [Link](set2) memeriksa apakah semua elemen dari
[Link]()#mengurutkan dari yang paling kecil ke yang paling besar, gunakan dengan
[Link]()zMAYUSCULAS dua set berbeda
(reverse=True) untuk mengurutkan dari yang terbesar ke yang terkecil Digunakan untuk mencegah kode kita berhenti karena kesalahan
[Link]()minusculas [Link](set2) memeriksa apakah semua elemen dari
[Link]()#mengurutkan elemen secara terbalik dari tupla = (x,y) tuplas didefinisikan dengan () dan , atau hanya , en el código. Se puede imprimir un mensaje que avisa del error.
[Link]()Huruf pertama dari kalimat dalam huruf besar.
perintah disimpan set1 ada di set2
[Link]()Primer Huruf Dari Setiap Kata Dalam Huruf Besar. tupla1 + tupla2gabungkan tuple coba:
[Link]()mINUSCULAS A mAYUSCULAS O vICEVERSA [Link](set2)periksa apakah semua elemen dari
print("[Link]())
[Link]() menghapus spasi dari awal dan akhir Menghapus elemen dari daftar set2 ada di set1
tuple(lista) membuat tuple dari sebuah daftar kecuali
[Link]() membagi string menjadi daftar - berdasarkan spasi
.pop() tuple(dicc)buat tuple dari kunci sebuah tidak berfungsi
[Link](i) #menghapus elemen di indeks i dan kamus
secara default, atau spesifikasikan pembagi lain di ()
kembalikan nilainya tuple([Link]()) membuat tuple dari nilai-nilainya
masukan()
[Link]("frase", "frase") menggantikan yang pertama
frasa dari string oleh yang lain .hapus() tuple([Link]()) membuat tuple dari key:values •mengizinkan untuk mendapatkan teks yang ditulis menggunakan keyboard oleh
rentang()
pengguna

Gabungkan elemen-elemen dari sebuah daftar dalam [Link](x)#menghapus elemen pertama dari daftar masukkan("teks yang ingin Anda tampilkan kepada pengguna")
sebuah string dengan pemisah yang ditentukan dalam " " dengan nilai x len(tupla) mengembalikan jumlah elemen •dapat disimpan dalam sebuah variabel •mengembalikan daftar angka yang secara default
list(string) mengubah variabel string menjadi sebuah di/tidak memverifikasi apakah ada elemen meningkat satu per satu mulai dari 0
[Link]()#mengosongkan daftar •secara default disimpan sebagai string
daftar [Link](x) mengembalikan indeks dari x rentang(mulai:henti:langkah)
x = int(input("tuliskan sebuah angka")) untuk menggunakan variabel
[Link]("substring") menemukan indeks di mana del lista#borra la lista [Link](x) mengembalikan jumlah elemen dengan •dapat ditentukan dari mana mulai dan batasnya (yang harus
mulai substring/'-1' jika substring tidak ada nilai x dalam tuple bagaimana integer atau float dapat diubah menjadi variabel
del lista[i]#menghapus elemen pada indeks i ser +1 karena kita berhenti sebelum batas yang kita tetapkan sebagai
berhenti)
string[i]mengembalikan elemen pada indeks i untuk mengubah isi dari sebuah tuple, harus
•juga dapat ditentukan lompatan
string[i:j] mengembalikan rentang karakter ubah menjadi daftar dan kemudian ke tuple

# metode permanen (mengubah variabel, tidak mengembalikan apa-apa)

Fungsi dan Kelas; Perpustakaan Regex Modul/Pustaka (paket fungsi) Ficheros xml Penghubung MySQL/Python
- singkatan dari `ekspresi reguler`, Impor dan gunakan modul serta fungsinya impor [Link] sebagai ETimpor pustaka xml Mendapatkan hasil dari sebuah query
Fungsi `regex` adalah rangkaian teks yang memungkinkan impor modul untuk mengimpor modul variable_tree = [Link]('ruta/[Link]') buka
variable_cursor.fetchone() mengembalikan hasil pertama
membuat pola yang membantu mencocokkan, dari modulo impor fungsi hanya satu fungsi berkas
Mendefinisikan sebuah fungsi: lokalisasi dan pengelolaan string [Link]() menggunakan sebuah fungsi dari modul variable_root = variable_tree.getroot() ambil elemen variable_cursor.fetchall() mengembalikan semua hasil
[Link]() untuk menggunakan sebuah fungsi dari sebuah kelas yang membungkus semuanya (elemen akar) dalam sebuah daftar sebagai iterable–setiap baris adalah tuple
def nama_fungsi(parameter1, parameter2, ...): impor repara untuk bisa bekerja dengan regex
impor modul sebagai mdasignar alias untuk modul <root>
kembalikan nilai_dari_kembali
Operator umum dari regex <child_tag atributo1="valor" atributo2=valor> Dataframe Pandas dengan SQL
+bertepatan dengan karakter sebelumnya satu atau lebih Perpustakaan os <subchild_tag> elemen </subchild_tag> impor pandas sebagai pd
Memanggil sebuah fungsi: </child_tag>
nama_fungsi(argumen1, argumen2, ...) kadang-kadang [Link]() mengembalikan jalur tempat kita bekerja; se variable_df = [Link](variable_resultado_fetchall,
Anda dapat menyimpan dalam variabel misalnya ruta = [Link]()
</root>
*coincide con el carácter precedente cero o variable_root.tag mengembalikan nama tag dari akar kolom = ['kolom1', 'kolom2', ...])buat sebuah
return: adalah opsional, tetapi tanpa return mengembalikan None lebih banyak kali atau opsional [Link]() mengembalikan daftar file dan folder dataframe dengan hasil dari sebuah query dalam sebuah variabel
variable_root.attrib mengembalikan atribut dari berkas
parameter default: -selalu harus menjadi lo di mana kita bekerja
?indica nol atau satu kejadian dari elemen variable_df.head(n) mengembalikan n baris pertama dari df,
terakhir [Link]('carpeta') mengembalikan isi dari folder lain
preseden variable_root.find("tag").find("childtag").textmengembalikan o 5 secara default
[Link]('ruta') mengubah folder di mana Anda berada
.cocok dengan karakter individu mana saja kesempatan pertama di mana tag elemen cocok variable_df = pd.read_sql_query(variable_query,
*args: tuple argumen tanpa batas [Link]('nueva_carpeta') membuat folder baru
dengan string variable_cnx) mengubah hasil query menjadi df
**kwargs: kamus di mana kunci dikonversi menjadi coincide dengan posisi awal dari mana pun [Link]('nombre_carpeta', 'nueva_nombre') mengubah nama
variable_root.findall("tag").findall("childtag").text
parameter dan nilainya dalam argumen dari string dari sebuah folder pd.read_sql(variable_query, variable_cnx)
kembalikan semua elemen yang tag-nya cocok
parámetros $coincide dengan posisi akhir dari mana saja [Link]('carpeta') menghapus folder
variable_df.to_csv("nombre_archivo.csv") simpan dalam csv
string
def nama_fungsi(param, *args, **kwargs, Pustaka shutil Penghubung MySQL/Python variable_df.to_string() format data dalam string
Sintaksis dasar regex dari shutil import rmtree
parametro_por_defecto = valor) variable_df.to_latex()formatkan data dalam string yang
arg/kwarg: sin */** di dalam fungsi wcualquier karakter tipe alfabet rmtree('carpeta') menghapus folder dan subfolder Menghubungkan ke basis data mempermudah penyisipan dalam dokumen latex
arg[0] karakter jenis numerik apapun impor [Link] untuk mengimpor MySQL Connector
spasi Membuka dan menutup berkas Membuat dan mengubah basis data
pip instal mysql-connector
Memanggil sebuah fungsi dengan *args: salto baris Pertama-tama, simpan jalur file: variable_cursor.execute("CREATE DATABASE nombre_BBDD")
pip install mysql-connector-Python
nama_fungsi(argumento, argumento, argumento, ...) ubicacion_carpeta = [Link]()
Karakter apapun yang bukan huruf connect() untuk menghubungkan ke basis data: variable_cursor.execute("CREATE TABLE nombre_tabla");
o nombre_archivo = "[Link]"
Karakter apa pun yang bukan digit ubicacion_archivo = ubicacion_carpeta + "/" + nombre_archivo variable_cnx = [Link](user='root', (nama_kolom TIPE, nama_kolom2 TIPE2)
nombre_funcion(*[daftar_atau_tuple_argumen])
Setiap elemen yang bukan ruang password='AlumnaAdalab', variable_cursor.execute("ALTER TABLE nombre_tabla
f = open(ubicacion_archivo) membuka sebuah file dalam variabel f host='[Link]', ALTERASI
Memanggil sebuah fungsi dengan **kwargs: aísla hanya sebagian dari pola kami
[Link]()menutup file* PENTING * database='nombre_BBDD')
nama_fungsi(**kamus) cari yang ingin kita kembalikan
dengan open(ubicacion_archivo) sebagai f: dari [Link] import errorcodeimportar errores Sisipkan data
[] termasuk semua karakter yang kita inginkan
kode e.g. variabel = [Link]() membuka file hanya untuk variable_query = "INSERT INTO nombre_tabla (columna1,
yang cocok dan bahkan mencakup rentang seperti jalankan kode yang ditentukan (dan setelah itu tinggalkan)
[Link] dapat digunakan dalam try/except
ini: a-z dan 0-9 columna2) VALUES (%s, %s)
Kelas itu seperti operator 'atau'
[Link]()putuskan sambungan dari basis data
variable_valores = (valor1, valor2)
Pengkodean Melakukan kueri
Tentukan sebuah kelas: tunjukkan urutan khusus (melarikan diri dari locale impor getpreferredencoding variable_cursor.execute(variable_query, variable_valores)
karakter spesial) variable_cursor = [Link]() membuat objek kursor yang
kelas NamaKelas: getpreferredencoding() untuk mengetahui sistem encoding metode lain:
memungkinkan kita untuk berkomunikasi dengan basis data
{}Jumlah yang ditentukan secara tepat dari kami sedang menggunakan
variable_query = "UPDATE nombre_tabla SET nombre_columna =
kejadian f = open(ubicacion_archivo, encoding="utf-8") membuka sebuah file variable_cursor.close()memutuskan koneksi kursor
def __init__(self, atribut1, atribut2): dan membacanya dengan encoding yang digunakan; simpan dengan .read()
"nuevo_valor" WHERE nombre_columna = "valor"
{n}Tepatnya n kali variable_query = ("Kueri SQL") simpan sebuah kueri dalam sebuah
self.atributo1 = atributo1
self.atributo2 = atributo2 {n,}Setidaknya n kali variabel Menyisipkan banyak baris ke dalam tabel
{n,m} Antara n dan m kali
mode: argumen opsional saat membuka file variable_cursor.execute(variable_query) jalankan query;
self.atributo_por_defecto = 'valor' variable_valores_en_tuplas = ((valor1kolom1,
r–baca kembalikan daftar tupel (nilai1kolom2), (nilai2kolom1, nilai2kolom2)
w–write - sobreescribe
def nama_fungsi1(self, parameter) impor tanggal dengan format AAAA-MM-DD variable_cursor.executemany(variable_query,
Metode Regex x–pembuatan eksklusif, hanya buat jika belum ada
nilai_variabel_dalam_tuples
[Link] += 1 a–menambahkan, menambahkan teks ke file tanpa memanipulasi teks [Link](AAAA, M, D) mengembalikan format tanggal
[Link]("patron", string) mencari di seluruh yang sudah ada
nilai baru adalah {[Link]} query_dinamis = "SQL Query... %s DAN %s"
string y mengembalikan daftar dengan semua harus menambahkan satu huruf lagi:
korespondensi dalam string kami variable_conexion.commit() setelah menjalankan
t–teks–baca dalam teks variable_cursor.execute(query, (variable1, variable2))
Mendefinisikan kelas anak: inserción, agar perubahan diterapkan di BBDD
b–bytes–kosong dan bytes (tidak dapat digunakan dengan encoding) nilai yang menggantikan %s
class NamaKelasAnak(NamaKelasInduk): [Link]("patron", string_original) mencari di variable_conexion.rollback() dapat digunakan setelah
todo el string y devuelve un objeto con la variable_cursor.execute("SHOW DATABASES") menunjukkan BBDD
def __init__(self, atribut1, atribut2): f = open(ubicacion_archivo, mode = "rt") eksekusi y sebelum commit untuk membatalkan perubahan
pertama kali cocok di string kami variable_cursor.execute("SHOW TABLES") menunjukkan tabel
super().__init__(atributo_heredado1, ...) cetak(variable_cursor.rowcount, "pesan")cetak el
dari BBDD yang ditunjukkan dalam koneksi
[Link]("patron", "string_original)busca en Baca berkas jumlah baris di mana tindakan telah diambil
def nama_fungsi_anak (self, parameter): ambil baris pertama dari string dan kembalikan sebuah variable_cursor.execute("TUNJUKKAN TABEL")
[Link]() membaca konten dari sebuah berkas
objek dengan kecocokan pertama di kami [Link](n) membaca n karakter pertama dari sebuah file variable_cursor.execute("TAMPILKAN KOLOM DARI [Link]") Menghapus catatan
string variabel = [Link]() menyimpan konten file (atau n menampilkan kolom-kolom dari tabel yang ditentukan; harus variable_query = "DROP TABLE nombre_tabla"
Buat objek dari kelas:
karakter dari sebuah file) dalam sebuah variabel menghubungkan ke bbdd information_schema
variable_objeto = NamaKelas(nilai_atribut1, resultado_match.span() mengembalikan referensi Tambahkan kesalahan
[Link](n) secara default mengembalikan baris pertama atau n baris
valor_atributo2) menginstansiasi (membuat) sebuah objek dari posisi di mana ia membuat "cocok"
[Link]() mengembalikan daftar semua baris dari
Argumen kursor:
impor kesalahan kode dan menggunakan coba/eksepsi:
variable_objeto.atributodevuelve el valor del arsip (setiap baris adalah elemen); digunakan kosong tanpa n dan variable_cursor = [Link]([arg=value[, arg=value]...])
atribut yang disimpan untuk objek tersebut resultado_match.group()mengembalikan elemen
list_name[x:] untuk memilih baris tertentu coba:
hasil dari kecocokan 'match' buffered=True mengembalikan semua baris dari bbdd
variable_objeto.atribut = nilai_baru untuk mengubah aksi
nilai atribut [Link]("patron", "string_original") mencari di raw=Trueel kursor tidak akan melakukan konversi kecuali [Link] sebagai err:
Menulis di file otomatis antara tipe data
variabel_objek.nama_fungsi()memanggil sebuah fungsi seluruh string dan mengembalikan daftar dengan yang cetak(err)
dengan open(ubicacion_archivo, "w") sebagai f:
elemen yang dipisahkan oleh pola dictionary=Truedevuelve las filas como diccionarios print("Kode Kesalahan:", [Link])
[Link]("Teks yang akan masuk ke dalam file.") untuk menulis
cetak(bantuan(NombreClase) cetak informasi tentang cetak("SQLSTATE", [Link])
dengan open(ubicacion_archivo, "a") sebagai f: named_tuple=Truedevuelve las filas como named tuples
[Link]("patron", "string_nuevo", cetak("Pesan", [Link])
kelas [Link]("Teks yang akan dimasukkan ke dalam berkas.") untuk menambahkan teks
string_asli")mencari di seluruh string dan cursor_class adalah sebuah argumen yang dapat digunakan untuk menunjukkan
[Link]('lista') untuk menambahkan baris teks dari sebuah daftar
kembalikan string dengan elemen yang cocok subkelas mana yang ingin kita gunakan untuk menginstansiasi kursor baru
Python: Pandas DataFrames Metode eksplorasi Tipe data Nilai nol
Membuat DataFrame [Link](n) mengembalikan n baris pertama dari dataframe Tipe data di Pandas: Mengidentifikasi nol
Serial: struktur dalam satu dimensi df = [Link](data, index, kolom) [Link](n) mengembalikan n baris terakhir dari dataframe - objek
[Link]()[Link]()mengembalikan True atau False tergantung pada apakah setiap
data: NumPy Array, diccionario, lista de diccionarios int64
[Link](n) mengembalikan n baris acak dari kita float64
valor adalah null atau tidak
Membuat seri indeks: indeks yang secara default ditetapkan sebagai 0-(n-1), n dataframe, atau satu secara default - tanggal dan waktu, selisih waktu[ns] [Link]().sum() [Link]().sum() mengembalikan sebuah seri dengan
serie = [Link]() membuat seri kosong menjadi jumlah baris;
index = [lista] untuk menetapkan 'label' (nama dari [Link] mengembalikan jumlah baris dan kolom - category jumlah nilai null per kolom
seri = [Link](array)membuat seri dari sebuah bool
filas df_%_nulos = (([Link]().sum() / [Link][0] *
array dengan indeks default [Link] mengembalikan jenis data yang ada di setiap
column: nombre de las columnas; por defecto 0-(n-1); [Link] mengembalikan jenis data yang ada 100).reset_index()
serie = [Link](array, index = ['a', 'b', 'c'...]) kolom
buat serangkaian dengan indeks yang ditentukan; harus berupa daftar columns =[lista]para poner mas nombres di setiap kolom df_%_nulos.columns = ['kolom', '% nulos']buat sebuah dataframe
panjang yang sama dari array [Link] mengembalikan nama-nama kolom df_tipo = df.select_dtypes(include = "tipe") dari persentase nilai yang nol
df = [Link](array) membuat dataframe dari sebuah buat dataframe dari kolom tipe
serie = [Link](lista) membuat sebuah seri dari [Link] mengembalikan dataframe dengan ringkasan dari
sebuah daftar array dengan indeks dan kolom default data yang ditentukan Hapus nula
statistik utama dari kolom numerik df['columna'] = df['columna'].astype('tipo',
serie = [Link](nomor, indeks) buat sebuah seri df = [Link](diccionario) membuat dataframe dari [Link](inplace = True, axis=b, subset=[lista_de_columnas],
dari sebuah kamus - kunci adalah nama-nama dari [Link]() mengembalikan ringkasan tentang jumlah kolom, salin = True, kesalahan = 'abaikan') mengubah sebuah
berangkat dari sebuah skalar dengan panjang yang sama dengan nomor cara=)menghapus nol
kolom nama kolom, jumlah nilai tidak null dan yang kolom dalam tipe data yang ditentukan
indeks bagaimana = 'apa saja' | 'semua' secara default 'apa saja': jika ada nilai NA,
tipe data df["nama_kolom"].unik() salin = Truedevolves una copia
serie = [Link](diccionario) membuat sebuah seri menghapus baris atau kolom; semua: jika semua nilai adalah NA,
df.nombre_columna.unique() mengembalikan sebuah array dengan salinan = Salah*perhatian: perubahan pada
berangkat dari sebuah kamus baris atau kolom dihapus
DataFrames:pemrosesan data nilai unik dari kolom nilai dapat menyebar ke objek lain
subsetuna kolom atau daftar kolom
pandas*
Mengakses informasi tentang suatu seri df["nombre_columna"].value_counts() kesalahan = abaikan kecuali; dalam hal Jenis-jenis nol
[Link] mengembalikan indeks Pemrosesan data df.nombre_columna.value_counts() mengembalikan sebuah seri dengan error mengembalikan objek asli
df = pd.read_csv("ruta/nombre_archivo.csv")buat sebuah [Link] "bukan angka"; ini adalah jenis numerik
[Link] mengembalikan nilai penghitungan nilai unik dalam urutan menurun errors = raise memungkinkan untuk menghasilkan
[Link] mengembalikan bentuk (jumlah baris) dataframe dari file Nilai Terpisah Koma Tidak ada nilai null di kolom tipe string
[Link]().sum() mengembalikan jumlah baris eksepsi NaTnilai null tipe datetime
[Link] mengembalikan ukuran df = pd.read_csv("ruta/nombre_archivo", sep=";") membuat sebuah
dataframe dari csv jika pemisahnya adalah ; duplikat valores texto: "n/a", "NaN", "nan", "null"strings que
[Link] mengembalikan jenis data
biasanya akan secara otomatis diubah menjadi [Link]
df = pd.read_csv("ruta/nombre_archivo", index_col= 0) Menghapus baris duplikat 99999o00000bilangan bulat yang dapat diubah menjadi nol
serie[i] mengembalikan nilai dari elemen di indeks i membuat dataframe dari csv jika file sudah ada [Link].max_columns = Tidak ada
serie[[i,j]] mengembalikan nilai dari dua elemen kolom indeks df.hapus_duplikat(inplace = True, abaikan_indeks=True) Mengganti nilai nol
hilangkan baris duplikat; abaikan_index untuk tidak memiliki sebelum [Link]() untuk dapat melihat semua
serie[i:m] mengembalikan nilai dari suatu rentang kolom
df = pd.read_excel("ruta/nombre_archivo.xlsx")crear un indeks dalam rekening df = pd.read_csv('[Link]', na_values = ['n/a'])
serie["etiqueta"]devuelve el valor de los elementos dataframe dari file Excel .fillna([Link]) menggantikan string 'n/a' dengan [Link]
pd.set_option("[Link]", 2)
pada indeks i dan j - muncul "ImportError:... openpyxl...", di terminal: Metode statistik memuat dataframe
pip3 instal openpyxlopip instal openpyxl
Operasi dengan deret
Pencilan [Link](df[value=n, axis=b, inplace=True) menggantikan semua
ganti NaN pada dataframe dengan nilai yang kita tentukan
df['columna'].rata-rata() | modus() | median() | varian() | standar deviasi()
seri1 +-*/ seri2jumlah/kurang/kali/bagi df = pd.read_json("ruta/nombre_archivo.json")crear un
hitung rata-rata/modus/media/varians/deviasi Menghitung tiga deviasi standar: df['columna'].[Link](df['columna'].median, axis=b,
baris dengan indeks yang sama antara kedua seri dataframe dari file JavaScript Object Notation
standar nilai dari sebuah kolom media = [Link]() inplace=True) mengganti nilai null di suatu kolom dengan
[Link](serie2, fill_value = nomor) menjumlahkan baris (format mentah)
desviacion = [Link]() mediana dari kolom itu
dengan indeks yang sama, dan tambahkan nilai isi ke df = df['data'].apply([Link]) mengonversi dataframe dari df['columna1'].corr(df['columna2']menghitung
nilai=npor default NaN; ini adalah nilai yang kita inginkan
nilai tanpa indeks umum json en un formato legible korelasi antara dua variabel
lcb = media–deviasi * 3 mengganti nilai nol yang bisa berupa skalar,
[Link](serie2, fill_value = número) sisa dari matriks_korelasi = [Link]() buat sebuah matriks yang menunjukkan kamus, seri atau dataframe
df = pd.read_clipboard(sep=' ') buat sebuah dataframe dari korelasi antara semua variabel ucb = media + deviasi * 3
baris dari seri2 dari seri1 ketika memiliki indeks axispor defecto 0 (baris)
umum, dan mengurangi nilai isian dari indeks lainnya data dalam bentuk dataframe di clipboard; pemisah
df_crosstab = [Link](df['columna1'], [Link](valor_nulo, valor_nuevo, inplace=True, regex=False)
seri1 bisa jadi ; , dll.
df['columna2'], normalisasi = True, margin = True)
Menghapus Outlier mengganti nilai nol dengan nilai baru
[Link](serie2, fill_value = angka)mengalikan langkah_outlier = 1,5 * IQRmenghitung langkah outlier
dengan open('ruta/nombre_archivo.pkl', 'wb') sebagai f: normalizemuestra nilai dalam persen (per satu)
baris dengan indeks umum dan kalikan nilai isi outliers_data = df[(df['columna'] < Q1– Imputasi nol
dengan yang lain *gunakan 1 untuk mempertahankan nilai*
[Link](df,f) menyimpan data dari sebuah dataframe di margin menunjukkan total dan subtotals outlier_step) | (df['columna'] > Q3 + dari [Link] import SimpleImputer
[Link](serie2, fill_value = número) bagi las file pkl media_ponderada = [Link](df['columna'], weights = w) mengidentifikasi data di luar
rentang dari maksimum hingga minimum imputer = SimpleImputer(strategy='mean', missing_values =
baris dari seri1 antara seri2 ketika hitung rata-rata tertimbang berdasarkan bobot
pd.read_pickle('ruta/nombre_archivo.csv').head(n) baca n lista_outliers_index = list(outliers_data. [Link]) memulai instansi dari metode, dengan menyebutkan bahwa
mempunyai indeks yang sama, dan membagi yang lain dengan fill percentil_n = [Link](df['columna'], n) ambil itu
baris dan 5 kolom dari file pickle kami ingin mengganti nilai yang kosong dengan rata-rata
nilai indeks) membuat daftar indeks dari
nilai pada persentil n
[Link](serie2, fill_value = angka) mengembalikan filas dengan outlier imputer = [Link](df['columna1']) kami menerapkan imputer
pd.read_parquet('ruta/nombre_archivo.parquet') baca un q3, q1 = [Link](df["columna"], [75, 25]) ambil yang
modulo (pembagian tanpa sisa) df['media_columna1'] = [Link](df[['harga']])isi
arsip parquet tercer y primer cuartiles jika outliers_data.shape[0] > 0: nilai kosong sesuai dengan yang telah kami spesifikasikan
[Link](serie2, fill_value = nomor) menghitung
eksponensial dicc_indices[key] =
dari [Link] mengimpor enable_iterative_imputer
Guardado de datos membuat sebuah
[Link](serie2) membandingkan jika serie1 lebih besar dari
seri2 dan mengembalikan True atau False df.to_csv('ruta/nombre_archivo.csv') simpan dataframe Sidetable: frecuencias de datos kamus indeks baris dengan
dari [Link] import IterativeImputer
[Link](serie2) membandingkan jika serie1 lebih kecil dari sebagai file csv nulos; dapat dilakukan dengan mengiterasi melalui kolom imputer = IterativeImputer(n_nearest_features=n,
[Link](['columna']) mengembalikan sebuah dataframe dengan imputation_order='ascending') buat instansinya
seri2 dan mengembalikan True atau False df.to_excel('ruta/nombre_archivo.xlsx') simpan dataframe
sebagai file Excel informasi tentang frekuensi terjadinya masing-masing valores = dicc_indices.values()sacar todos n_nearest_features secara default None; jumlah kolom untuk
df.to_json('ruta/nombre_archivo.json') simpan dataframe kategori dari variabel kategorik nilai misalnya semua indeks menggunakan untuk memperkirakan nilai null
Penyaringan boolean parametros: valores = {indeks untuk sublista dalam valores untuk
seri < > >= <= == nilai mengembalikan True atau False tergantung pada sebagai file JSON imputasi_order secara default meningkat; urutan imputasi
df.to_parquet('ruta/nombre_archivo.parquet')simpan thresh = nlimita nilai yang ditampilkan yang paling indeks di subdaftar} pemahaman himpunan untuk
jika setiap kondisi memenuhi syarat frekuensi hingga ambang n% kumulatif dan mengelompokkan [Link](df_numericas) kita menerapkan imputer
dataframe sebagai file parquet hapus duplikat
serie1[serie1 < > >= <= == nilai] hanya mengembalikan yang yang tersisa di bawah label "lainnya" df_datos_trans = [Link]([Link](df_numericas),
df.to_pickle('ruta/nombre_archivo.pkl') simpan dataframe df_sin_outliers = [Link]([Link][list
nilai yang memenuhi syarat other_label = 'etiqueta'cambia la etiqueta 'other' kolom = df_numericas.columns) buatlah dataframe dari data
sebagai file pickle (valores)]) membuat dataframe baru tanpa outlier
[Link] membuat nilai nulo (NaN) value = 'columna'ordena los resultados por la columna transformasi; kami memasukkan kolom-kolom ini ke dalam dataframe asli
[Link]() mengembalikan True atau False tergantung apakah
Spesifik
nilai ada atau null ("" tidak dihitung sebagai null) PenulisExcel
[Link](['columna1', 'columna2']) menggabungkan dua
Mengganti Pencilan dari [Link] import KNNImputer
[Link]() mengembalikan True atau False tergantung apakah
dengan [Link]("ruta/[Link]") sebagai penulis: untuk k, v dalam dicc_indices.items(): imputerKNN = KNNImputer(n_neighbors=5) buat instansinya
df.to_Excel(writer, nama_lembar = 'nama') kolom dan kembalikan frekuensi subkategori
nilai ada atau kosong ("" tidak dihitung sebagai kosong) media = df[k].mean() [Link](df_numericas)
menyimpan dataframe ke dalam lembar Excel untuk i di v:
[Link](['columna']) mengembalikan informasi tentang df_knn_imp = [Link]([Link](df_numericas),
[Link][i,k] = media menggantikan
frekuensi data nol outliers berdasarkan rata-rata
kolom = [Link]) buat dataframe dari data
ditransformasikan; kami memasukkan kolom-kolom ini ke dalam dataframe asli
Panda Subset: loc dan iloc Penyaringan data Membuat kolom Mengubah nilai
Metode pandas untuk menyaring Pembuatan rasio Mengganti nilai berdasarkan indeks dan kondisi:
Penggabungan data [Link]["etiqueta_fila", "etiqueta_columna"]
mengembalikan konten dari sebuah field di sebuah kolom df_filtrado = df["columna?ratio"] = [Link](lambda df: df["columna1"] indices_filtrados = [Link][df["columna"] == "valor"]
dari satu baris df[df["nombre_columna"].isin(iterable)]ekstrak yang / df["columna2"], axis = 1)
.concat()menggabungkan dataframe dengan kolom yang sama baris yang nilai kolom yang diberi nama ada di
untuk indeks dalam indeks_filtrados:
df_union = [Link]([df1, df2, df3], axis=b, join = [Link]["etiqueta_fila",:] mengembalikan nilai iterator (daftar, seri, dataframe atau Pembuatan persentase df["nama_kolom"].iloc[indeks] = "nilai_baru"
'dalam/luar', abaikan_indeks = Benar/Salah dari semua kolom dalam sebuah baris kamus def persentase(kolom1, kolom2): Mengganti nilai berdasarkan metode NumPy:
parametros:
[Link][:,"etiqueta_columna"] mengembalikan kembali (columna1 * 100) / columna2
axis = 0 satu per kolom – dataframes berada satu di atas yang lain df_filtrado= df[df["nombre_columna"].[Link] [Link](to_replace = valor, value = valor_nuevo,
lain; kolom harus memiliki format yang kompatibel nilai dari semua baris di sebuah kolom inplace = True) mengganti nilai tertentu dengan nilai lain yang
(patron, regex = True, na = False)]mengambil baris df["kolom_%"] = [Link](lambda df:
sumbu = 1 satu per baris–dataframe berada berdampingan satu sama lain; [Link][indice_fila, indice_columna] mengembalikan yang kami spesifikasikan
yang nilai dalam kolom yang disebut berisi persentase(df["kolom1"], data["kolom2"]), axis = 1)
data harus saling terkait agar memiliki makna konten dari sebuah bidang dalam sebuah kolom dari baris pola regex df["nueva_columna"] =[Link](df["nombre_columna"] > n, df["nombre_columna"].replace(to_replace = nilai,
gabung = 'dalam' hanya elemen yang muncul di semua yang tersisa
data frame "kategori_jika_benar", "kategori_jika_salah") buat baru value = valor_nuevo, inplace = True) menggantikan tertentu
[Link][indice_fila, :] mengembalikan nilai dari df_filtrado = df[df["nombre_columna"].[Link]
join = 'outer'se queda todo los datos de todos los dataframes kolom berdasarkan kondisi nilai dalam satu kolom oleh yang kami tentukan
semua kolom dari satu baris
ignore_index = True/False, secara default adalah False; jika True tidak digunakan ekstrak
df[["columna1", "columna2"]] = df[["columna1",
indeks untuk gabungan (misalnya untuk gabungan berdasarkan sumbu 0) [Link][:,indice_columna] mengembalikan konten baris-baris yang nilai kolom yang bernama df["nueva_columna"] =[Link](lista_de_condiciones, "columna2"]].replace(r"string", "string", regex=True)
dari sebuah kolom dalam sebuah baris mengandung substring, tidak peka huruf besar daftar_opsi) buat kolom baru dengan nilai
.gabungkan()menggabungkan kolom dari satu dataframe ke dataframe lain mengganti pola/string dengan yang lain secara massal
berdasarkan banyak kondisi kolom
df_nuevo = [Link](df2, on = 'columna') gabungan dalam [Link][[lista_etiquetas_baris], df_filtrado = df[df["nombre_columna"].[Link] df["columna_nueva"] =[Link](x = df["nombre_columna"],
df_nuevo = [Link](kiri = df1, kanan = df2, bagaimana='kiri', kiri_berdasarkan = [lista_etiquetas_columnas]]mengembalikan ekstrak df["nama_kolom"] = df["nama_kolom"] + x
isi dari beberapa baris / beberapa kolom bins = [n,m,l..], labels = ['a', 'b', 'c']) pisahkan
'columna_df1', right_on = 'columna_df2') penggabungan kiri barisan yang nilai-nilainya pada kolom yang dinamakan gantikan nilai di kolom dengan nilai + x
elemen-elemen dari dataframe dalam interval yang berbeda (n-m, (atau nilai lain yang kami tunjukkan)
parameter: mengandung substring, tidak case sensitive
[Link][[lista_indices_baris], m-l, dll), membuat kolom baru yang menunjukkan di mana
how = 'left' | 'right' | 'outer' | 'inner' | 'cross'
[lista_indices_columnas]]mengembalikan konten intervalo jatuh nilainya; dengan label dapat ditugaskan
on = kolom|[kolom1, kolom2, dll] jika kolom-kolomnya disebut
sama di kedua dataframe dari beberapa baris / beberapa kolom df[[Link](df["nombre_columna"])] mengembalikan yang string a cada interval tanggal dan waktu
baris yang tidak memiliki nilai nol di kolom
left_on = columna_df1 | right_on = columna_df2 untuk mengkhususkan Indeks/range daftar dapat digunakan ditentukan Membuat kolom mengimpor datetime
dari mana melakukan penggabungan df["nueva_columna"] = (df["etiqueta_columna"] + x)crea
[mulai:stop:langkah] di dalam loc/iloc [Link]() dan [Link]() mengembalikan tanggal
sufiks = ['kiri', 'kanan'] secara default tidak ada, sufiks yang kolom baru yang didasarkan pada yang lain aktual
akan muncul di kolom yang duplikat [Link][[Link] > x] memilih data berdasarkan Mengubah kolom df = [Link](nueva_columna= df["etiqueta_columna] + x) timedelta(n) mewakili suatu durasi perbedaan
.bergabung()menggabungkan dataframe berdasarkan indeks dalam suatu kondisi menggunakan operator perbandingan buat yang baru berdasarkan yang lain
antara dua instansi; n adalah jumlah hari tetapi se
lista_kolom = [Link].to_list() buatlah sebuah daftar df = [Link](nueva_columna= [lista_valores])buat satu dapatkah Anda menentukan hari, detik, atau mikrodetik
df_nuevo = [Link](df2, on = 'columna', how = 'kiri') inner merge [Link][([Link] > x) & ([Link] == y)] dari nama-nama kolom pada dataframe kolom baru dari daftar nilai *harus dari
parametros: memilih data yang harus memenuhi keduanya ayer = [Link]() - timedelta(1)
panjang yang sama seperti jumlah baris dataframe
how = 'left' | 'right' | 'outer' | 'inner'por defecto left kondisi (dan) [Link](indice_nueva_columna, "nombre_columna", ayer = [Link](ayer, '%Y-%m-%d')
on = kolomala kolom atau indeks yang ingin kita lakukan df.set_index(["nombre_columna"], inplace = True)
[Link][([Link] > x) | ([Link] == y)] valores) buat kolom baru di indeks yang ditunjukkan df["fecha"] = ayer menciptakan kolom dengan tanggal
union; harus memiliki nama yang sama di kedua dataframe tetapkan indeks menggunakan satu atau lebih kolom;
lsuffix = 'string' | rsuffix = 'string' secara default tidak ada, el memilih data yang harus dipenuhi allow_duplicates = Trueparametro cuando queremos kemarin
dapat menggantikan atau memperluas indeks yang ada
salah satu dari dua kondisi (atau) mengizinkan kolom duplikat (secara default adalah False)
sufiks yang akan muncul di kolom duplikat inplace = Perubahan yang benar-benar menimpa df
strftime() memungkinkan kita untuk membuat format yang lebih mudah dibaca dari

Pengelompokan Berdasarkan
[Link][list([Link] > x), :] iloc tidak menerima * ketika sebuah kolom diubah menjadi indeks, itu tidak lagi Mendaftar data tipe datetime
sebuah seri boolean; harus mengubahnya menjadi daftar kolom *
apply() mengambil sebuah fungsi sebagai argumen dan menerapkannya pada
[Link](variable_fecha, '%Y-%m-%d')memformat
variable_df.head(n) mengembalikan n yang pertama df.reset_index(inplace = True)hapus satu kolom tanggal ke format yang ditentukan
df_groupby = [Link]("columna_categoría") menciptakan sebuah objek panjang sumbu DataFrame
baris df, atau 5 secara default sebagai indeks agar menjadi kolom lagi; buatlah sebuah
DataFrameGroupBy; mengelompokkan nilai berdasarkan kategori dari dataframe dari sebuah seri df['columna_nueva'] = df['col_1'].apply(fungsi) Sintaksis strftime()
nilai dari kolom yang ditunjukkan (atau beberapa kolom dalam daftar) %hari minggu (Sun)
buat kolom baru dengan nilai dari kolom lain
df_groupby.ngroups mengembalikan jumlah grup Mengganti nama kolom ditransformasikan sesuai dengan fungsi yang ditunjukkan %Adía de la semana (Sunday)
df_groupby.groups mengembalikan sebuah kamus di mana kunci adalah Penyaringan data [Link](columns = {"nombre_columna": df['columna_nueva'] = df['col_1'].apply(lambda x: %hari dalam seminggu dari 0 (Minggu) sampai 6 (Sabtu)
kategori dan nilai adalah daftar indeks dari setiap nombre_nueva [Link]() jika x > 1) %bmes abreviada (Sep)
elemen dalam kategori Difiltrasi berdasarkan kolom dengan operator dari satu atau lebih kolom
buat kolom baru dengan nilai dari kolom lain Bmes (September)
df_grupo1 = df_groupby.get_group("grupo1") mengembalikan sebuah dataframe perbandingan contoh pemahaman kamus untuk membuat kamus ditransformasikan sesuai dengan lambda yang ditentukan
%mmes dengan nol (09)
dengan hasil dari sebuah grup (kategori yang ditunjuk sebagai grup1) tentang kolom-kolom yang ada di dataframe:
df_filtrado = df[df["nombre_columna"] == valor] df['columna_nueva'] = [Link](lambda nombre: %-mmes sebagai float
Perhitungan dengan groupby:
ambil baris di mana nilai kolom diccionario = {col : [Link]() for col in fungsi(nama['kolom1'], nama['kolom2']), sumbu =
df_nuevo = [Link]("columna_categoría").mean() mengembalikan sebuah sama dengan nilai yang diberikan
%hari bulan dengan nol (08)
[Link] b) buat kolom baru menggunakan fungsi yang mengambil dua
dataframe dengan rata-rata dari semua kolom nilai numerik, parameter (kolom 1 dan kolom 2) %-hari bulan sebagai float (8)
berdasarkan kategori [Link](columns = diccionario, inplace = True) %tahun tanpa abad (99)
Penyaringan berdasarkan beberapa kolom dengan operator
ubah nama kolom sesuai dengan [Link](funcion, na_action=None, **kwargs) menerima dan
df_nuevo = [Link]("columna_categoría")["columna1"].mean() logis kamus mengembalikan skalar ke setiap elemen dari dataframe; itu %Yaño dengan abad (1999)
kembalikan dataframe dengan rata-rata kolom yang ditentukan ini harus diterapkan pada seluruh DataFrame %Zzona waktu (UTC)
df_filtrado = df[(df["columna1"] == nilai) & Hapus kolom
count() jumlah pengamatan (df["columna2"] == nilai) & (df["columna3"] > n df['columna'] = df['columna'].map(mapa, na_action = %pAM o PM
tidak ada yang boleh kosong
nilai)]mengambil baris di mana nilai dari [Link](columns = ["kolom1", "kolom2"], axis = abaikan) ganti nilai pada kolom sesuai dengan peta, %c tanggal dan waktu
kolom-kolom memenuhi syarat di menghapus satu atau lebih kolom atau baris apa bisa menjadi kamus atau serangkaian; hanya bisa
deskripsi() ringkasan dari %xfecha
kurung sesuai dengan yang kami spesifikasikan menerapkan pada kolom tertentu.
statistik utama
%Xhora (07:06:05)
jumlah() jumlah dari semua nilai Mengatur ulang kolom apply() dengan datetime
df_filtrado = df[(df["columna1"] == valor) | %Hjam nol (07)
mean() media dari nilai-nilai df['columna_fecha'] = df['columna_fecha']
(df["columna1"] == valor) ekstrak baris di mana df = [Link](columns = lista_reordenada) ubah %-Hhora sebagai float (7)
.apply(pd.to_datetime) mengubah kolom data tipe
df_nuevo = [Link]("kolom_kategori", dropna = False) nilai-nilai kolom memenuhi dengan sebuah urutan kolom dari dataframe sesuai dengan urutan %Mmenit dengan nol (06)
daftar yang diurutkan ulang tanggal dalam format datetime
["columna_valores"].agg([nombre_columna= ‘estadistico1’, kondisi atau lainnya
def ambil_tahun(x): %-Mmenit sebagai float (6)
nombre_columna2 = ‘estadistico2’])añade columnas con los cálculos
dari statistik yang ditentukan df_filtrado = ~(df[df["columna1"] == nilai]) kembali [Link]("%Y") %Sdetik dengan nol (05)
dropna = False untuk memperhitungkan Nan dalam perhitungan (untuk ambil baris di mana nilai-nilai dari df['columna_año'] = (df['columna_fecha'].apply %-Sdetik sebagai float (5)
defecto adalah True) kolom-kolom TIDAK memenuhi kondisi (sacar_año)buat kolom baru untuk tahun hanya menggunakan
metode pustaka datetime; ("%B") untuk bulan
Matplotlib dan Seaborn Grafik Seaborn Multigrafik Personalisasi Personalisasi
Plot garis fig, ax = [Link](jumlah_baris, jumlah_kolom) Judul Colores
Matplotlib fig = [Link](x = 'columna1', y = 'columna2', data = membuat sebuah figura dengan beberapa grafik; fig adalah
[Link](label = "judul") menetapkan sebuah judul untuk
figura dan ax adalah array dengan subplots sebagai elemen color = "color"establece el color de la grafica
df, ci = None) buat grafik linier di mana sumbu adalah:
grafik facecolor = "color"establece el color del relleno
Gráficas columna1–x, columna2–y
ci = None agar tidak menampilkan interval kepercayaan dari
ditetapkan bagaimana setiap grafik dengan indeks:
edgecolor = "color"establece el color de los bordes
ax[indice].tipo_grafika(rincian grafika)
data Warna di Diagram Sebaran:
impor [Link] sebagai plt hue = columnaopcional; menunjukkan garis dalam berbagai
ax[indice].set_title('judul') Sumbu
ax[indice].set_xlabel('xlabel') c= df['kolom'].peta(diccionario)
warna berdasarkan kategori menurut variabel [Link]("etiqueta_eje_x") asigne nombre al eje x
[Link]["[Link]"] = (10,8) ax[indice].set_ylabel('ylabel') diccionario = {"valor1": "color1", "valor1": "color1"}
Diagram sebar [Link]("etiqueta_eje_y") untuk memberi nama pada sumbu y
[Link](figsize = (n,m)) memulai sebuah grafik daftar warna
fig = [Link](x = 'columna1', y = 'columna2', data ax[indice].set_xlim(min, max [Link]([n,m] menetapkan rentang sumbu x; di mana n adalah
menggambar bingkai figura; n adalah lebar dan
m adalah tinggi, dalam inci = df, hue = 'columna') buatlah grafik dispersi ax[indice].set_ylim(min, max) yang minimum adalah m dan m adalah maksimum Palet Seaborn:
[Link]() menampilkan gambar Plot swarm ax[indice].set_xticklabels(labels = df['kolom'], [Link]([n,m]) menetapkan rentang sumbu y; di mana n ["Aksen","Aksen_r","Blues","Blues_r","BrBG","BrBG_r"]
fig = [Link](x = 'columna1', y = 'columna2', data = rotasi = n) untuk mengubah nama dan/atau rotasi e adalah minimum dan m adalah maksimum 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r',
df, hue = 'columna') buat grafik sebar di mana dari label nilai di sumbu 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens',
Grafik dasar ["Hijau_r","Abu-abu","Abu-abu_r","OranyeMerah","OranyeMerah_r"]
los marcadores no se solapan Membuat subplot dalam sebuah loop for
[Link](xlabel = 'etiqueta_eje_x', ylabel =
Diagram batang ["Jeruk","Jeruk_r","PRGn","PRGn_r","Pasangan"]
Plot hitung fig, axes = [Link](jumlah_baris, jumlah_kolom, 'etiqueta_eje_y')asignar nombre a los ejes
[Link](df["columna1"], df["columna2"]) membuat sebuah ["Paired_r","Pastel1","Pastel1_r","Pastel2"]
fig = [Link](x = 'columna1', data = df, hue = figsize = (n, m)) fig.set_title('judul') menetapkan judul untuk grafik
diagram batang di mana sumbu adalah: kolom1– ["Pastel2_r","PiYG","PiYG_r","PuBu","PuBuGn"]
'columna')buat grafik batang dengan hitungan satu axes = [Link]()
x, kolom2–y 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r',
variabel kategorikal; hanya dapat ditentukan satu
Plot batang horizontal untuk kol dalam [Link]: fig.set_xlabel(xlabel = "etiqueta_eje_x", fontsize = n) 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy',
variabel di sumbu x atau y, serta satu variabel opsional dengan
[Link](df["columna1"], df["columna2"]) membuat sebuah fig = [Link](x=col, data=df, ax=axes[i] 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r',
nuansa fig.set_ylabel(ylabel = "etiqueta_eje_y", fontsize = n)
diagram batang horizontal di mana sumbu Membuat subplots dalam sebuah loop for 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r',
Histogram ["Set2","Set2_r","Set3","Set3_r","Spektral"]
son: columna1–x, columna2–y fig = [Link](x = 'columna1', data = df, hue = fig, axes = [Link](numero_filas, numero_columnas, [Link](xticks = [1, 2, 3]) ["Spektral_r","Wistia","Wistia_r","YlGn","YlGnBu"]
Diagram batang bertumpuk figsize = (n, m))
'columna3', kde = True, bins = n) membuat histogram yang [Link](yticks = [1, 2, 3, 4, 5]) 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd',
[Link](x, y, label = 'etiket') menunjukkan frekuensi dari distribusi data; di mana ["YlOrRd_r","afmhot","afmhot_r","musim gugur","musim gugur_r"]
[Link](x2, y2, bottom = y, label = 'etiqueta2') [Link](xticklabels = ['0%','20%', '40%', '60%', '80%',
x adalah variabel yang menarik dan n adalah jumlah batang 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r',
100%
buatlah diagram batang bertumpuk untuk
memvisualisasikan dua variabel bersama; dan menunjukkan batang
kde = True menunjukkan kurva distribusi Penggunaan jenis-jenis grafik [Link](yticklabels = ['cat1', 'cat2', 'cat3'])
'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r',
Diagram Kotak 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'crest',
referensi Data kategorikal ["crest_r","cubehelix","cubehelix_r","flag","flag_r"]
fig = [Link](x = 'columna1', data = df, hue =
Diagram sebar kolom') buat diagram kotak; x adalah variabel dari fig.set_xticklabels(labels = [0, 500, 1000, 1500], 'flare', 'flare_r', 'gist_earth', 'gist_earth_r',
Barras ["gist_gray","gist_gray_r","gist_heat","gist_heat_r"]
[Link](df["columna1"], df["columna2"])crea minat; secara default ditampilkan dengan orientasi horizontal ukuran=n)
grafik sebar di mana sumbu adalah: gunakan sumbu y untuk orientasi vertikal - menunjukkan hubungan antara variabel numerik dan ["gist_ncar","gist_ncar_r","gist_rainbow"]
fig.set_yticklabels(labels = fig.get_yticklabels(),
columna1–x, columna2–y kategoris ["gist_rainbow_r","gist_stern","gist_stern_r"]
Catplot size=n)
- diagram batang jika Anda memiliki variabel numerik ["gist_yarg","gist_yarg_r","gnuplot","gnuplot2"]
fig = [Link](x = 'columna1', y = 'columna2', data = 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot',
Grafik statistik df, hue = 'columna', kind = 'tipo') buat grafik yang - countplot untuk menghitung catatan/baris per kategori
Untuk menempatkan label di atas batang ["hot_r","hsv","hsv_r","icefire","icefire_r"]
Histogram tunjukkan hubungan antara variabel kategorik dan satu Diagram lingkaran/quesitos
untuk indeks, nilai dalam enumerate(df ["col"]): ["neraka","neraka_r","jet","jet_r","magma"]
[Link](x = df['columna1'], bins = n) menciptakan sebuah variabel numerik 'magma_r', 'mako', 'mako_r', 'nipy_spectral',
penentuan frekuensi [Link](valor+1, indice, valor,
histogram yang menunjukkan frekuensi dari kind = 'box' | 'bar' | 'violín' | 'boxen' | 'point' por ["nipy_spectral_r","lautan","lautan_r","pink","pink_r"]
distribusi data; di mana x adalah variabel dari defek adalah plot strip Datos numéricos horizontalalignment='kiri', fontsize= 16)
["plasma","plasma_r","prisma","prisma_r","pelangi"]
minat dan n adalah jumlah batang Pasangan plot Garis ["pelangi_r","roket","roket_r","seismik","seismik_r"]
Diagram Kotak fig = [Link](data = df, hue = 'columna', jenis = order = df.sort_values('columnay', ascending=False) 'spring', 'spring_r', 'summer', 'summer_r', 'tab10',
- tren/evolusi satu atau lebih variabel numerik
[Link](x = df['columna1']) menciptakan sebuah diagram 'tipo') buat histogram dan diagram sebar dari ['columnax'] ["tab10_r","tab20","tab20_r","tab20b","tab20b_r"]
(biasanya selama periode waktu)
kotak untuk mempelajari karakteristik sebuah semua variabel numerik yang tersedia [Link](font_scale=2) ["tab20c","tab20c_r","terrain","terrain_r","turbo"]
variabel numerik; x adalah variabel yang menarik dataset yang kita kerjakan; hue bersifat opsional Histograma ["turbo_r","senja","senja_r","senja_geser"]
[Link]({'[Link]': 22}) ukuran font
- nilai minimum sama dengan Q1 - 1.5 * IQR kind = 'scatter' | 'kde' | 'hist' | 'reg' | 'point' por distribusi variabel numerik {"twilight_shifted_r":"twilight_shifted_r","viridis":"viridis","viridis_r":"viridis_r","vlag":"vlag"}
umum
- maksimum adalah sama dengan Q3 + 1,5 * IQR defek adalah scatter 'vlag_r', 'winter', 'winter_r
Diagram kotak
Peta panas representasi dari ukuran posisi yang paling umum digunakan: palette='light:nombre_paleta'|'dark:nombre_paleta'
[Link]([Link](), cmap = 'color_palette', annot = Legenda
mediana, IQR, outliers
Benar, vmin = -1, vmax = 1) buat heatmap dengan skala [Link](labels = ['label1', 'label2', dll]) menunjukkan Pita
de colores yang mencerminkan nilai korelasi Diagram Sebar legenda ketika kami menunjukkan gambar marker = 'tipo'establece el tipo de marcador; se usa con
annot = True agar nilai-nilai muncul - menunjukkan hubungan antara dua variabel numerik [Link](bbox_to_anchor = (1, 1)menempatkan legenda di [Link] y [Link]
vmin/vmax menetapkan skala warna Regplot hubungan dengan sumbu
diagram sebar dengan garis regresi . "P" Más (pengisi)
Regplot , * Estrella
fig = [Link](x = 'columna1', y = 'columna2', data = Plot Kumpulan Menghapus tepi o Lingkaran "h" Hexágono 1
df, scatter_kws = {'warna':'biru'}, line_kws = {'warna'; tipe grafik sebar untuk mewakili [Link][[ "v" Segitiga bawah "H" Hexágono 2
'biru'})buat diagram pencar serta garis regresi; kami variabel kategorikal; mencegah tumpang tindih "^" Segitiga atas + Lebih
memungkinkan untuk menemukan fungsi garis terbaik yang memungkinkan marcadores < Segitiga kiri "x" x
memprediksi nilai suatu variabel mengetahui nilai-nilai dari Garis tiga deviasi standar: Segitiga kanan "X" x (pengisi)
Diagram Lingkaran
variabel lain Plot biola [Link](x=valor, c='warna', label='valor') "8" Oktagon "D" Diamante
[Link](x, labels = categorias, radius = n)membuat sebuah - untuk memvisualisasikan distribusi data dan. [Link](x=valor, c='warna', label='valor')
Grafik Gabungan "s" Kuadrat "d" Diamante fino
grafik sektor di mana x adalah variabel dari kepadatan probabilitas
[Link](x = 'columna1', y = 'columna2', data = df, Pentagon
minat (harus dikelompokkan menurut kategori); n adalah
warna = 'biru', jenis = 'tipo') buatlah scatterplot atau Grafik Pasangan Kotak grid
ukuran
regplot dengan histogram yang dipasang di sisi untuk setiap - untuk mewakili beberapa hubungan antara dua [Link]() membuat grid di latar belakang gambar;
variabel ambil parameter-parameter itu:
Plot Biola variables
[Link](x, showmedians = True, showmeans = color = "color"
Peta panas
Benar) buat diagram biola di mana x adalah Ekspor angka linestyle = "solid"|"dashed"|"dashdot"|"dotted"
variabel yang menarik dan menunjukkan median dan rata-rata [Link]('nama_figura.extensi') menilai korelasi antara variabel dalam sebuah
matriks korelasi linewidth = nestable menetapkan lebar garis
NumPy (Numerical Python) Indeks, Subset, Metode Array Operasi statistik dan matematis Fungsi himpunan Statistik
Indeks array Operasi statistik dan matematika [Link](array) mengembalikan array dengan nilai unik Tabel frekuensi
Membuat array del array ordenados
array[i] mengembalikan indeks i; indeks dari Parameter axis pada array berdimensi dua: [Link](array, return_index=True) mengembalikan sebuah array dengan Frekuensi absolut
Membuat array dari daftar arrays unidimensionales funcionan igual que las listas axis = 0columnas nilai unik dari array yang diurutkan dan sebuah array dengan jumlah kali suatu angka diulang dalam sebuah
array = [Link](lista, dtype= tipo) buat array array[i, j] atau array[i][j] mengembalikan elemen dari sumbu = 1baris posisi instance pertama dari setiap nilai kumpulan data
unidimensional dari sebuah daftar kolom j dari baris i - jika kita menentukan sumbu, operasi akan mengembalikan [Link](array, return_inverse=True) mengembalikan array dengan df = [Link]('columna').count().reset_index()
array = [Link]([lista1, lista2]) buat sebuah array array[:,:n] memilih semua baris dan kolom hasil untuk setiap baris atau kolom. nilai unik dari array yang diurutkan dan sebuah array dengan
Frekuensi relatif
dua dimensi dari dua daftar sampai n-1 Misalnya: posisi setiap elemen dari setiap nilai
jumlah kali suatu angka atau kategori diulang dalam sebuah
array = [Link]([listadelistas1, listadelistas2])crea [Link](array, axis = 0) mengembalikan sebuah array dengan [Link](array, return_counts=True) mengembalikan sebuah array dengan
array[h, i, j] atau array[h][i][j] mengembalikan elemen dari kumpulan data mengenai total, dalam persentase
array dua dimensi dari dua daftar kolom j dari baris i dari array h jumlah setiap baris los valores únicos del array ordenados y un array con el
jumlah kemunculan setiap nilai df_group_sin_str = df_group.drop('columna_str',
array[h][i][j] = tidak mengubah nilai elemen di [Link](array, axis = b) mengembalikan sebuah array dengan sumbu=1)
Membuat jenis array lain posisi ini pada nilai n
Parameter sumbu pada array multidimensi:
axis = 0dimensión nilai unik yang terurut dari baris atau kolom frecuencia_relativa = df_group_sin_str / [Link][0] *
array = [Link](valor_inicio, valor_final, saltos)buat
sebuah array menggunakan format [start:stop:step] axis = 1columnas 100
array = [Link](z,y,x) membuat array yang berisi semua satu Himpunan bagian axis = 2filas Fungsi untuk array unidimensional columnas = df_group_sin_strings.columns
bentuk yang ditentukan - jika kita menentukan sumbu, operasi tersebut mengembalikan hasil
array > ndevuelve la forma del array con True o False np.intersect1d(array1, array2) mengembalikan array dengan df_group[columnas] = frecuencia_relativa
array2 = np.ones_like(array1) buat array yang semuanya satu sesuai dengan apakah elemen tersebut memenuhi kondisi atau tidak hasil untuk setiap dimensi, baris atau kolom.
nilai-nilai unik dari elemen yang sama di dua array
dari bentuk yang didasarkan pada array lain
array[array > n]mengembalikan sebuah subset: semua nilai
Misalnya:
np.intersect1d(array1, array2, return_indices=True) Tabel kontingensi
array = [Link](z,y,x) buat array yang semua elemennya nol dari [Link](array_3D, axis = 0) mengembalikan sebuah array dari satu
kembalikan sebuah array dengan nilai-nilai unik dari elemen-elemen tabel frekuensi yang menghitung semua
yang memenuhi kondisi dalam sebuah daftar di dalam matriks dengan jumlah semua matriks
bentuk yang ditetapkan kombinasi yang mungkin untuk setiap pasangan nilai dari
array [Link](array_3D, axis = 1) mengembalikan sebuah array di mana persemaan dua array dan array dengan indeks masing-masing
array2 = np.zeros_like(array1) buat array dari semuanya nilai, menurut array kolom-kolom yang sedang kita coba bandingkan
nol dari bentuk yang didasarkan pada array lain array[(array > n) & (array < m)] mengembalikan sebuah subset: baris-baris berisi jumlah kolom dari
np.union1d(array1, array2) mengembalikan array terurut dengan df_crosstab = [Link](df['columna1'],
array = [Link]((z,y,x), tipo) membuat array kosong dengan semua nilai yang memenuhi syarat dalam satu setiap matriks
daftar di dalam array; dapat menggunakan | untuk "atau"
elemen-elemen yang dihasilkan dari menggabungkan dua array (nilai df['columna2'], normalisasi = True, margin = True
data default tipe float unik
Operasi dengan parameter sumbu: normalizemuestra nilai dalam persentase (per satu)
array2 = np.empty_like(array1) buat array kosong dengan np.in1d(array1, array2) mengembalikan array dengan True atau False
bentuk berdasarkan array lain [Link](array_3D) mengembalikan jumlah dari semua margins menunjukkan total dan subtotal
Metode array untuk setiap elemen dari array1 tergantung apakah nilai yang sama muncul
array = [Link](z,y,x, k = n) buat array dengan satu di elemen dari matriks
nuevo_array = [Link]() menciptakan salinan dari array en array2 Koefisien korelasi Pearson
diagonal mulai dari posisi k [Link](array) mengembalikan rata-rata dari seluruh array
np.setdiff1d(array1, array2) mengembalikan array terurut dengan
array = [Link](x) buat matriks identitas dengan [Link](array_bidimensional) mengubah baris dari [Link](array) mengembalikan deviasi standar dari - nos permite conocer la intensidad y dirección de la
los valores únicos que están en array1 pero no en array2 hubungan antara kedua variabel
nol dalam baris dan satu di diagonal, berbentuk persegi array a kolom dan kolom ke baris todo np.setxor1d(array1, array2) mengembalikan array terurut dengan
[Link](array_multidimensional) mengubah angka [Link](array) mengembalikan varians nilai dari - koefisien > 0: korelasi positif
nilai-nilai unik yang TIDAK ada kesamaan dari kedua array
dari kolom ke jumlah array dan sebaliknya; jumlah todo - koefisien < 0: korelasi negatif
de filas tidak berubah [Link](array) mengembalikan nilai minimum dari array
NumPy Acak [Link](array_multidimensional, (z,y,x)) melakukan
[Link](array) mengembalikan nilai maksimum dari array Statistika - koefisien = 1 atau -1: korelasi total
[Link](array) mengembalikan jumlah elemen dari - koefisien = 0: tidak ada hubungan linier
transposisi sesuai dengan apa yang kita tentukan menggunakan
array df['columna1'].corr(df['columna2']hitunglah
[Link](x) menetapkan benih acak dari posisi tuple (0,1,2) dari bentuk asli Ukuran penyebaran
[Link](array) mengembalikan array dengan jumlah korelasi antara dua variabel
generator angka acak, untuk fungsi-fungsi Penyimpangan terhadap rata-rata
array = [Link](n).reshape((y,x)) buat array akumulasi elemen di sepanjang array matriz_korelasi = [Link]() buat sebuah matriks
acak yang selalu akan mengambil nilai yang sama menggunakan reshape untuk menentukan bentuk selisih dalam nilai absolut antara setiap nilai dari
[Link](array) mengembalikan sebuah array dengan menunjukkan korelasi antara semua variabel
acak data dan rata-rata aritmatika
array = [Link](array, (z, y, x)) buat array dengan perkalian terkumpul dari elemen sepanjang [Link]([Link]()[['kolom1', 'kolom2']], cmap =
nilai dari array lain menggunakan reshape untuk mendefinisikan hapus array diferencias = df['columna'] - df['columna'].mean()
Membuat array dengan nilai acak bentuk
'palet_warna', annot = True, vmin = -1, vmax = 1
desviación_media = [Link](diferencias)
array = [Link](inicio, final, bentuk_matriks) buatlah grafik heatmap dari matriks korelasi
buat array angka acak antara dua nilai; array = [Link](array, posisi, posisi) Operasi tanpa parameter sumbu: Varianza
pertukaran dua sumbu dalam sebuah matriks menggunakan [Link](array) mengembalikan array dengan akar Sesgos (kemiringan)
forma_matriz: (z,y,x) ukur penyebaran; variabilitas terhadap rata-rata
z: jumlah array posisi (z=0,y=1,x=2) dari bentuk asli kuadrat tidak negatif dari setiap elemen array ukuran asimetri distribusi dari
[Link](array) mengembalikan array dengan eksponensial df['columna'].var()
y: jumlah baris nilai-nilai dari sebuah variabel di sekitar nilai rata-ratanya
x: número de columnas dari setiap elemen array Deviasi standar atau deviasi tipikal - valor de sesgo positivo: sesgado a la derecha
Operasi lainnya [Link](array1, array2) mengembalikan array dengan akar kuadrat dari varians; semakin besar, semakin besar
array = [Link](inicio, final) mengembalikan sebuah - nilai bias negatif: terdistorsi ke kiri
nomor acak dalam rentang [Link](array) mengembalikan array dengan nilai dari sisa pembagian antara dua array akan menjadi dispersi atau variabilitas dalam data kami - nilai bias sama dengan 0: nilai simetris
setiap baris diurutkan dalam urutan menaik secara default [Link](array1, n) mengembalikan array dengan sisa dari [Link](df['columna'], kde = True) membuat sebuah
array = [Link](z,y,x) buat array float df['columna'].std()
aleatorias con la forma que le especificemos; por defecto [Link](array, axis = 0) mengembalikan array dengan pembagian antara array dan nilai n histogram yang menunjukkan distribusi nilai
nilai setiap kolom diurutkan dalam urutan menaik [Link](array) mengembalikan array dengan kosinus dari Kekuatan
hasilkan angka acak antara 0-1 impor [Link] import skew
setiap elemen dari array semakin banyak jumlah data, semakin kokoh
array = [Link].random_sample((z,y,x)) membuat sebuah array dari [Link](-array) mengembalikan sebuah array dengan nilai-nilai dari skew(df['columna'] menunjukkan nilai dari bias suatu
[Link](array) mengembalikan sebuah array dengan sinus dari masing-masing
angka acak dengan bentuk yang kita tentukan; untuk setiap baris diurutkan dalam urutan menurun 1/n dimana n adalah jumlah catatan variabel
elemen dari array
defecto menghasilkan angka acak antara 0-0.9999999... [Link](array, decimals = x) mengembalikan sebuah array dengan Koefisien variasi
array = [Link].z,y,x=None) mengembalikan sebuah angka [Link](array) mengembalikan array dengan tangen dari
rasio antara deviasi standar dan rata-rata; berapa
Interval kepercayaan
nilai array dibulatkan ke x desimal setiap elemen dari array deskripsikan variabilitas antara ukuran yang diperoleh di
acak antara 0 dan 0.999999999999... semakin besar, semakin besar penyebaran dalam data kami
[Link](array, decimals = x) mengembalikan sebuah array dengan sebuah studi dan ukuran nyata dari populasi (nilai
[Link]([Link](z,y,x), n) buat array dengan float
de n desimal nilai array dibulatkan ke x desimal Operasi perbandingan pada array df['columna'].std() / df['columna'].mean() nyata)
[Link](n,m, size = (z,y,x)) menghasilkan sampel [Link](array > x) mengembalikan indeks dari nilai-nilai bidimensional impor [Link] sebagai st
Persentil
acak dari distribusi uniform dalam interval yang memenuhi kondisi, per baris dan kolom [Link](array > n) mengembalikan True atau False tergantung pada apakah
bagi data terurut dari yang terkecil hingga yang terbesar menjadi seratus bagian; [Link](alpha = n, df = len(df['columna']-1, loc
antara n dan m nilai apa pun dari array memenuhi kondisi = [Link](df['columna']), skala =
tunjukkan proporsi data di bawah nilainya
[Link](n,m, size = (z,y,x)) menghasilkan sampel [Link](array > n, axis = b) mengembalikan array dengan [Link](df['columna'])
dengan distribusi binomial; n adalah jumlah total dari
Operasi dengan array Benar atau Salah untuk setiap kolom atau baris sesuai dengan apakah ada percentil_n = [Link](df['columna'], n) keluarkan nilai
di persentil n kembalikan rentang nilai untuk yang ada n% dari
uji coba; m adalah probabilitas keberhasilan [Link](array1, array2)suma dua array nilai baris atau kolom memenuhi kondisi probabilitas bahwa suatu nilai nyata jatuh dalam rentang itu
[Link](array > n) mengembalikan True atau False tergantung pada apakah
[Link](loc = n, scale = m, size = (z,y,x)) [Link](array1, array2) mengurangkan array2 dari array1
hasilkan angka acak dari distribusi normal semua nilai dalam array memenuhi kondisi Jangkauan interkuartil alpha: porcentaje de confianza ([Link]. 90%, 95%, o 99%)
[Link](array1, array2)mengalikan dua array ukuran dispersi: selisih antara kuartil 75 dan 25 df: data
(kurva lonceng); loc adalah rata-rata; skala adalah [Link](array > n, axis = b) mengembalikan sebuah array dengan
[Link](array1, array2) membagi array1 dengan array2 True atau False untuk setiap kolom atau baris sesuai dengan apakah semua q3, q1 = [Link](df["columna"], [75, 25]) ambil yang
desviación estándar lok: la media
[Link](array) mengembalikan sebuah array dengan array2 nilai dari baris atau kolom memenuhi dengan tercer y primer cuartiles scale: la desviación estándar
nilai yang sama dicampur secara acak array + n, n * array, dll. - operator aljabar kondisi rango_intercuartílico = q3 - q1
EDAy ETL ETL: Extract, Transform, Load Pembelajaran Mesin: Persiapan Uji statistik Normalisasi
Ekstraksi Independensi antara variabel prediktor Metode manual
EDA: Analisis eksplorasi data Hipotesis Nol dan Kesalahan Tipe I dan II
mengambil data mentah dan menyimpannya kami mengambil nilai yang ingin kita normalisasi dan
- variabel prediktor harus independen untuk
Tabel basis data SQL atau NoSQL
Analisis Eksploratori Data mengacu pada
File teks biasa
Hipotesis nol (H0) dapat membuat model regresi linier kita mengurangi rata-rata kolom, dan membagi
proses melakukan serangkaian penelitian - secara umum adalah pernyataan yang bertentangan dengan apa yang ingin kita buktikan hasil dari maksimum dikurangi minimum dari
inisiatif tentang data yang kita miliki untuk dapat Email Variabel numerik: Korelasi kolom
menemukan pola, mendeteksi anomali, menguji - Informasi halaman web Hipotesis alternatif (H1) grafik pasangan
Lembar kerja df["col_norm"] = (df["col_VR"] -
hipotesis dan memeriksa asumsi dengan bantuan secara umum pernyataan yang ingin kami buktikan [Link](df)
File yang diperoleh dari API df["col_VR"].media()) / (df["col_VR"].max() -
statistik dan representasi grafis. df["col_VR"].min())
p-valor covarianza
Transformasi ukuran probabilitas bahwa hipotesis nol benar df_numé[Link]() Metode logaritma
1. Memahami variabel memproses data, menggabungkannya,
memvalidasi mereka, memfilter mereka, dll.
membersihkannya, nilai antara 0 dan 1 korelasi Pearson (hubungan linier) *tidak dapat dilakukan jika ada nilai yang nol*
- si *p-valor* < 0.05❌Kami menolak hipotesis nol. df_numé[Link]()
- variabel apa yang kita miliki Format tanggal df["col_norm"] = df["col_VR"].apply(lambda x:
- si *p-valor* > 0.05 Aceptamos hipotesis nol. korelasi Spearman (hubungan non-linier) [Link](x) jika x > 0 selain 0)
.head(), .tail(), .describe(), .info(), .shape Mengatur ulang baris atau kolom
- que tipos de datos - Menggabungkan atau memisahkan data
Kesalahan Tipe I: df_numé[Link](metode = 'spearman')
Metode akar kuadrat
.dtypes(), .info() Mengombinasikan sumber data menolak hipotesis nol ketika itu benar - korelasi Kendall (data numerik tetapi
apakah ada kolom yang kosong atau duplikat Membersihkan dan menstandarkan data kategoris dan ordinal impor matematika
.isnull().sum() Verifikasi dan validasi data Error Tipo II: df_numé[Link](metode = 'kendall') df["col_norm"] = df["col_VR"].apply(lambda x:
.duplikat().jumlah() Menghapus duplikat atau data yang salah menerima hipotesis nol ketika itu salah [Link](x))
apa nilai unik yang kita miliki - Penyaringan, pelaksanaan perhitungan atau pengelompokan
.unik(), .hitung_nilai() Variabel kategorikal: Chi-kuadrat Metode [Link]()
Muatan
Uji statistik - V-Cramer: bervariasi antara 0 dan 1
terapkan transformasi logaritma untuk
perpustakaan meja samping: - lebih dekat ke 1 lebih tergantung
- memuat data dalam format tujuannya, jenis nilai positif dan eksponensial untuk nilai
[Link]() mengembalikan value_counts dari variabel
yang akan tergantung pada sifat, ukuran dan
Normalitas -hasil < 0,7 untuk membuat ML negatif dari kolom kami
kategoris, tetapi persentase, jumlah kumulatif dan
persentase kumulatif
kompleksitas data. Sistem yang paling umum Variabel respons harus memiliki distribusi normal untuk dapat impor researchpy sebagai rp dari scipy import stats
biasanya adalah: membuat model regresi linier
[Link]() tabel akun null dan tabel silang, hasil_uji, diharapkan = rp.tabel_silang df["col_norm"], lambda disesuaikan =
- Berkas csv [Link](df["col_VR"])
persentase dari total
- Berkas json Secara visual: (df["col1"], df["col2"], uji= "chi-square",
expected_freqs= True, prop= "cell")
Basis data - histogram atau distribusi Metode MinMaxScaler
2. Bersihkan dataset Gudang data (Data Warehouse) grafik kuantil teoritis (Q-Q) hasil_uji_mengembalikan_hasil_uji_dalam_sebuah
dari [Link] import MinMaxScaler
Lagos data semakin sejajar titik-titik di sekitar garis, semakin normal dataframe
modelo = MinMaxScaler(feature_range=(0,1),
- menghapus duplikat (baris atau kolom) akan menjadi data kami Homokedastisitas (homogenitas varians) salin=True)
mengubah nama kolom impor [Link] sebagai sm
[Link](df["col_VR"])
mengubah tipe data kolom variabel prediktor harus memiliki homogenitas
[Link](datos, line ='45') datos_normalizados = [Link](df["col_VR"])
mengurutkan kolom varianzas dibandingkan dengan variabel respons
- memisahkan kolom menjadi dua dengan [Link]() API Metode analitis:
Secara visual: df_datos_norm = [Link](datos_normalizados,
- membuat interval dengan [Link]() Asimetri columns = ['col_norm'])
violinplot
membuat persentase atau rasio import requests library untuk melakukan permintaan HTTP df['col_norm'] = df_datos_norm
- memutuskan bagaimana menangani outlier: mempertahankannya, ke sebuah URL, untuk melakukan web scraping
- distribusi asimetris positif: rata-rata > median dan moda boxplot
- distribusi asimetris negatif: rata-rata < median dan moda - regplot (kolom numerik vs variabel respon)
menghilangkan mereka, atau menggantinya dengan rata-rata,
mediana atau moda; atau menerapkan imputasi
url = 'enlace'el enlace de la que queremos extraer
data dari [Link] import skew
ANOVA
Metode analitis:
header = {}opcional; contiene informacion sobre las skew(datos_normales)método dari scipy yang menghitung kemiringan impor [Link] sebagai sm
- uji Levene (lebih robust terhadap kekurangan dari
- memutuskan bagaimana menangani nilai nol: permintaan yang dilakukan (tipe file, kredensial)
df['columna'].skew() metode pandas yang menghitung skewness normalitas) atau Bartlett dari [Link] import ols
- menghapus baris atau kolom dengan nilai nol [Link]() response = [Link](url=url, header = header)
imputar nilai yang hilang kami meminta kepada API untuk memberikan data Kurtosis dari scipy import stats lm = ols('col_VR ~ col_VP1 + col_VP2 + col_VP3',
menggantinya dengan rata-rata, median, atau modus variables = {'parametro1':'valor1', -leptocurtosis: valor de curtosis mayor que 0 (pico alto) dari [Link] import levene data=df).fit()
menggunakan .fillna() atau .replace() 'parametro2':'valor2'} Variabel kategoris: mengembalikan sebuah dataframe dari hasil:
-mesocurtosis: valor de curtosis igual a 0 (pico medio)
imputer dengan metode pembelajaran mesin response = [Link](url=url, params=variables) df (derajat kebebasan): variabel kategori
kami meminta API untuk memberikan data dengan -platikurtosis: nilai kurtosis kurang dari 0 (datar) harus membuat dataframe untuk setiap nilai unik dari
menggunakan pustaka sklearn: Simple-Imputer, akan menjadi jumlah nilai unik kurang 1; untuk
dari [Link] import kurtosistest kolom kategorikal
Iterative-Imputer, atau KNN Imputer parameter sesuai dengan kamus parameter yang dia variabel numerik akan selalu 1
kita melewati kurtosistest(datos) mengembalikan nilai p df_valor1 = df[df['col1'] == 'valor1']['col_VR']
sum_sq: medida de variación/desviación de la media
response.status_codedevuelve status dari permintaan - p-valor tes > 0,05: data normal df_valor2 = df[df['col1'] == 'valor2']['col_VR']
[Link] mengembalikan alasan kode status mean_sq: es el resultado de dividir la suma de
3. Menganalisis hubungan antara variabel [Link] mengembalikan data dalam format string - p-valor dari uji < 0.05: data TIDAK normal levene_test = [Link](df_valor1, df_valor2,
center='median'
kuadrat antara jumlah derajat kebebasan.
[Link]() mengembalikan data dalam format json Uji Shapiro-Wilk F: sebuah tes yang digunakan untuk mengevaluasi kemampuan
Menganalisis hubungan antara variabel bartlett_test = [Link](df_valor1, df_valor2,
df = pd.json_normalize([Link]) mengembalikan - untuk sampel < 5000 eksplanatif yang dimiliki oleh variabel prediktor tentang
- untuk menemukan pola, hubungan atau anomali center='median'
data dalam dataframe variasi dari variabel respon
Hubungan antara dua variabel numerik: - hipotesis nol: distribusi normal Variabel numerik: - PR(>F): jika elp-valor < 0.05 adalah sebuah variabel
diagram sebar dari scipy impor statistik
- regplot – diagram sebar dengan garis regresi
Kode respons HTTP harus membuat dataframe dari kolom-kolom numerik signifikan; yang dapat mempengaruhi VR
[Link](df["datos"]) tanpa variabel jawaban
matriks korelasi dan heatmap 1XX menginformasikan tentang sebuah -p-valor dari tes > 0.05: data normal [Link]() mengembalikan ringkasan dari
kesalahan 4XX selama permintaan untuk kol di df_numericas.kolom:
- joinplot – memungkinkan untuk menggabungkan dua grafik –satu resultados:
jawaban yang benar 401 permintaan tidak sah - p-valor dari uji <) 0.05: data TIDAK normal statistik, p_val = levene(df[col], df['col_VR'],
histogram dengan scatter atau reg plot misalnya coef: mewakili perubahan rata-rata dalam VR untuk
kode sukses 2XX 402 tanpa otorisasi
Hubungan antara dua variabel kategori: Uji Kolmogorov-Smirnov center='median') sebuah unit perubahan dalam VP saat dipertahankan
200 OK 403 dilarang
plot hitung - untuk sampel > 5000 resultados[col] = p_val konstanta sisa dari VP; tanda-tanda kita
201 dibuat 404 tidak ditemukan
Hubungan antara variabel numerik dan kategorikal: indikasikan apakah hubungan ini positif atau negatif
202 aceptado Kesalahan 5XX dari server hipotesis nol: distribusi normal mengembalikan nilai p dalam sebuah kamus
plot serangga std err: semakin kecil kesalahan standar, semakin
204 tanpa konten 501 kesalahan internal server -p-valor uji > 0.05: varians sama,
violinplot dari scipy impor kstest Estimasi akan sangat tepat
3XX pengalihan 503 layanan tidak tersedia homoskedastisitas
plot titik kstest(df["datos"], 'norm')
adalah hasil dari membagi koefisien dengan
boxplot - p-valor dari uji > 0.05: data normal - p-valor dari tes < 0.05: varians berbeda,
kesalahan standar
- p-valor dari uji < p-valor (alpha) 0.05: data TIDAK normal heteroskedastisitas
Pembelajaran Mesin Regresi Linier: Metrik Regresi Logistik: Metrik Penyeimbangan untuk Regresi Logistik GridSearch y best_estimator_
dari [Link] mengimpor r2_score, mean_squared_error, Matriks kebingungan Pengurangan sampel Setelah membuat prediksi dari sebuah model
Standarisasi mean_absolute_error
menyesuaikan jumlah data dari kategori mayoritas menjadi
Pohon Keputusan, kami memeriksa metrik dari
Prediksi resultados:
R2: mewakili proporsi varians yang dapat Matriz de yang minoritas
- mengubah nilai-nilai kolom kita sedemikian rupa sehingga dijelaskan oleh VP dari model; R2 yang lebih tinggi= model yang lebih baik Untuk mengurangi overfitting, kita perlu mengurangi si temenos.
deviasi standar dari distribusi sama dengan 1 dan r2_skore(y_latih,y_tebak_latih)
kebingungan Positif Negatif Metode manual kedalaman model
rata-rata sama dengan 0; agar VP dapat dibandingkan df_minoritaria = df[df['col'] == valor_min]
r2_score(y_test,y_predict_test) si temenos underfitting harus meningkatkan
Metode manual MAE (Mean absolute error): ukuran perbedaan antara yang Positif Benar Falso negatifdf_muestra = df[df['col'] == valor_max].sample kedalaman model
valores predichos vs los reales; menor MAE=mejor modelo positif (num_minoritarios, random_state = 42) max_fitur = [Link](len(x_latih.kolom))
df["col_esta"] = (df["col_VR"]–df["col_VR"].media()) /
kesalahan_rata_rata_mutlak(y_train,y_predict_train) Realitas df_balanceado = [Link]([df_minoritaria,
(df ["col_VR"].std() kita bisa menghitung nilai max_features sebagai
Negatif Palsu Benar df_muestra], sumbu = 0)
mean_absolute_error(y_test,y_predict_test) akar kuadrat dari jumlah variabel prediktor
Sklearn StandardScaler positif negatif Metode RandomUnderSample
MSE (Mean Squared Error): mengukur rata-rata (mean) dari arbol.tree_.max_depth tidak menunjukkan kedalaman maksimal
dari [Link] impor StandardScaler kesalahan kuadrat; MSE lebih kecil = model yang lebih baik impor imblearn digunakan secara default, untuk dapat menyesuaikannya; kita seharusnya
scaler = StandardScaler() mean_squared_error(y_train,y_predict_train) untuk membuat heatmap dari matriks kebingungan: X = [Link]('col_VR', axis=1) gunakan setengah sebagai maksimal
[Link](df_num_sin_VR) mean_squared_error(y_test,y_predict_test) dari [Link] impor matriks kebingungan y = df['col_VR'] - GridSearch menjalankan semua kemungkinan
datos_estandarizados = [Link] (df_num_sin_VR) RMSE (Akar Rata-rata Kesalahan Kuadrat): jarak rata-rata antara mat_lr = confusion_matrix(y_test, y_pred_test) down_sampler = RandomUnderSampler() kombinasi hiperparameter yang kita berikan dengan
df_datos_esta = [Link](datos_estandarizados, kolom nilai yang diprediksi dan yang nyata; RMSE lebih kecil = model yang lebih baik [Link](figsize = (n,m)) X_down, y_down = down_sampler.fit_resample(X,y) parameter 'param' dan best_estimator_ mengembalikan
= df_num_sin_VR.kolom) kombinasi utama ditemukan
[Link](mean_squared_error(y_train,y_predict_train)) [Link](mat_lr, square=True, annot=True= df_balanceado = [Link]([X_down, y_down], axis = 1)
Kami mendefinisikan sebuah kamus hiperparameter
Sklearn RobustScaler [Link](mean_squared_error(y_test,y_predict_test)) [Link]('nilai yang diprediksi')
Metode Tomek
dari [Link] import RobustScaler [Link]('nilai nyata') param = {"max_depth": [n,m,l], "max_features":
x = [Link]('col_VR', axis=1) [a,b,c,d], "min_samples_split": [x,y,z],
scaler = RobustScaler() Regresi Linier: Model [Link]()
y = df['col_VR'] "min_samples_leaf": [r,s,t]} from
[Link](df_num_sin_VR) Metrik x_train, x_test, y_train, y_test = train_test_split(x, y, sklearn.model_selection impor GridSearchCV
datos_estandarizados = [Link] (df_num_sin_VR) 1. separar los datos de las variables predictoras (x) de la ukuran_uji = 0.2, keadaan_acak = 42)
dari [Link] import confusion_matrix 2. Kami memulai model dengan GridSearch
df_datos_esta = [Link](datos_estandarizados, columns variable respuesta (y) tomek_sampler = SMOTETomek()
accuracy_score, precision_score, recall_score,
= df_num_sin_VR.kolom) X = [Link]('col_VR', axis=1) gs = GridSearchCV(estimator =
f1_score , cohen_kappa_score, X_train_res, y_train_res =
DecisionTreeRegressor(), param_grid = param, cv=10,
y = df['col_VR'] roc_curve,roc_auc_score tomek_sampler.fit_resample(X_train, y_train)
verbose=-1, return_train_score = True, scoring =
Pengkodean 2. kami membagi data menjadi data pelatihan dan data Accuracy (exactitud):porcentaje de los valores
prediksi ini telah diprediksi dengan baik Peningkatan Sampel neg_mean_squared_error
uji con train_test_split()
Variabel kategorikal menyesuaikan jumlah data dari kategori minoritas ke Kami menyesuaikan model di GridSearch
dari sklearn.model_selection impor train_test_split skor_akurasi(y_latih, y_prediksi_latih)
mayoritas [Link](x_train, y_train)
Ordinaria: no requiere números pero sí consta de un orden x_latih, x_uji, y_latih, y_uji = pisah_latih_uji(X, y, skor_akurasi(y_test,y_predict_test)
atau sebuah posisi; perbedaan median antara kategori test_size = 0.2, random_state = 42) Ingat: persentase kasus positif yang ditangkap Metode manual 4. Kami menerapkan metode best_estimator_
Nominal: variabel yang tidak diwakili oleh angka, tidak 3. Kami menyesuaikan model *jika kita lebih memilih FP, kita ingin recall yang tinggi* df_mayoritaria = df[df['col'] == valor_may] mejor_modelo = gs.best_estimator_
memiliki jenis urutan tertentu, dan oleh karena itu adalah
dari sklearn.linear_model import LinearRegression skor_pengembalian(y_train, y_predict_train) df_muestra = df[df['col'] == valor_min].sample mengembalikan kombinasi hiperparameter terbaik
secara matematis kurang tepat; tidak akan ada yang besar (num_mayoritarias, random_state = 42)
lr = LinearRegression(n_jobs=-1) skor_recall(y_test,y_predict_test)
perbedaan median antara kategori 5. Kami kembali mengeluarkan prediksi
[Link](x_train, y_train) Presisi (sensitivitas): persentase dari df_balanceado = [Link]([df_mayoritaria,
Binari: dua kemungkinan; bisa teratur atau tidak df_muestra],axis = 0) y_pred_test_dt2 = mejor_modelo.predict(x_test)
4. Kami membuat prediksi prediksi positif yang benar
Variabel tanpa urutan:kami membuat kolom baru berdasarkan nilai *jika kita lebih memilih FN, kita ingin presisi tinggi* Metode RandomOverSample y_pred_train_dt2 = mejor_modelo.predict(x_train)
y_predict_train = [Link](x_train)
unik, menetapkan nol dan satu
y_prediksi_uji = [Link](x_uji) precision_score(y_train,y_predict_train) impor imblearn Pentingnya prediktor
One-Hot Encoding X = [Link]('col_VR', axis=1)
5. Kami menyimpan hasilnya dalam dataframe dan menggabungkannya presicion_score(y_test,y_predict_test) importancia_predictores = [Link](
dari [Link] impor OneHotEncoder y = df['col_VR']
train_df = [Link]({'Real': y_train, 'Predicted': Spesifisitas: persentase kasus negatif {'predictor': x_train.columns, 'importancia':
oh = OneHotEncoder() ditangkap down_sampler = RandomUnderSampler()
y_predict_train, 'Set': ['Train']*len(y_train)}) mejor_modelo.feature_importances_})
df_transformados = oh.fit_transform(df[['kolom']]) F1: rata-rata dari presisi dan recall X_down, y_down = down_sampler.fit_resample(X,y)
test_df = [Link]({'Real': y_test, 'Predicted': importancia_predictores.sort_values(by=["importanci
oh_df = [Link](df_transformados.toarray()) y_predict_test, 'Set': ['Test']*len(y_test)}) df_balanceado = [Link]([X_down, y_down], axis = 1)
f1_skor(y_latih,y_prediksi_latih) a"], urutkan=False, di tempat = True) buat sebuah
oh_df.columns = oh.get_feature_names_out() resultados = [Link]([train_df,test_df], axis = 0) f1_score(y_test, y_predict_test) dataframe dengan pentingnya masing-masing VP
df_final = [Link]([df, oh_df], axis=1) 6. kami membuat kolom limbah: selisih antara kappa: ukuran kesesuaian yang berdasarkan pada Regresi Logistik: Model
get_dummies nilai yang diamati dan yang diprediksi membandingkan kesesuaian yang diamati dalam suatu kumpulan - untuk variabel kategorikal nominal kepada
df_dum = pd.get_dummies(df['col'], prefix='prefijo', resultados['residuos'] = resultados['Real'] - data, sehubungan dengan apa yang bisa terjadi hanya karena ikuti langkah yang sama seperti untuk Regresi Linear tetapi apa yang telah diterapkan encoding, harus dijumlahkan
dtype=int) resultados['Predicted'] azar conLogisticRegression() hasil kolom yang dibagi:
df[df_dum.columns] = [Link] - <0 Tidak setuju dari sklearn.linear_model import LogisticRegression
Validasi silang df_sum = importancia_predictores_esta.iloc[[n, m]]
[Link]('col', axis=1, inplace=True) - 0.0-0.2 Tidak Signifikan
dari sklearn.model_selection import cross_val_score importancia_predictores_esta.drop(df_sum.index,
Variabel yang memiliki urutan: dari sklearn.model_selection impor cross_validate
0.2-0.4 Bajo Pohon Keputusan: Model inplace = True)
0.4-0.6 Sedang
Label Encoding memberikan nomor pada setiap nilai unik dari sebuah cv_scores = cross_val_score(estimator = LinearRegression(), importancia_predictores_esta.loc[n] =
- 0.6-0.8 Baik dari sklearn.model_selection import train_test_split
variable X = X, y = y, penilaian = 'neg_root_mean_squared_error', cv = ["nombre_col", df_sum["importancia"].sum()]
10) 0.8-1.0 Sangat baik dari [Link] import DecisionTreeRegressor
dari [Link] import LabelEncoder
dari sklearn impor tree
le = LabelEncoder() cv_scores.rata-rata() skor_kappa_cohen(y_latih,y_prediksi_latih)
mengikuti langkah yang sama seperti untuk Regresi Linier tetapi
Random Forest: Model
df['col_VR_le'] = le.fit_transform(df[col_VR']) hitung rata-rata hasil CV dari suatu metrik skor_kappa_cohen(y_test,y_predict_test) conDecisionTreeRegressor() atau DecisionTreeClassifier()
map() menetapkan nilai yang kita inginkan sesuai dengan peta yang cv_scores = cross_validate(estimator = LinearRegression(), X kurva ROC: bentuk grafis untuk melihat kappa; mengikuti langkah yang sama seperti untuk Decision Tree
= X, y = y, skor ='r2', 'neg_root_mean_squared_error', cv sensitivitas vs. spesifisitas arbol = DecisionTreeRegressor(random_state=42) tapi denganRandomForestRegressor() atau
kita buat
= 10) AUC (area di bawah kurva): area di bawah kurva ROC; Untuk menggambar pohon: RandomForestClassifer()
df['col_VR_map'] = df[col_VR'].map(diccionario)
cv_scores["test_r2"].mean() semakin dekat ke 1, semakin baik model kita fig = [Link](figsize = (10,6)) dari [Link] import RandomForestRegressor
Pengkodean Ordinal kami menetapkan label berdasarkan urutan atau
cv_scores["test_neg_root_mean_squared_error"].mean() menghitung mengklasifikasikan VP tree.plot_tree(arbol, feature_names = x_train.columns,
hierarki Anda bisa menggunakan hiperparameter yang sama dari
rata-rata hasil validasi ganda diisi = Benar best_estimator_ untuk menjalankan kembali GridSearch
dari [Link] import OrdinalEncoder
metrik [Link]()