Mengapa variabel pada python dikatakan bertipe dinamis?

Saya melihat istilah-istilah ini di mana-mana dalam pemrograman dan saya memiliki gagasan yang kabur tentang apa artinya. Pencarian menunjukkan kepada saya bahwa hal-hal seperti itu telah ditanyakan di seluruh stack overflow sebenarnya. Sejauh yang saya ketahui, pengetikan Statis / Dinamis dalam bahasa sedikit berbeda dengan pengetikan Kuat / Lemah, tetapi apa perbedaannya adalah di luar jangkauan saya. Sumber yang berbeda tampaknya menggunakan makna yang berbeda atau bahkan menggunakan istilah tersebut secara bergantian. Saya tidak dapat menemukan tempat yang membicarakan keduanya dan sebenarnya menjelaskan perbedaannya. Apa yang akan menyenangkan adalah jika seseorang bisa menjelaskan ini dengan jelas di sini untuk saya dan seluruh dunia.

• Pengetikan Statis / Dinamis adalah tentang kapan informasi jenis diperoleh (Baik pada waktu kompilasi atau saat runtime)

• Pengetikan Kuat / Lemah adalah tentang bagaimana jenis ketat dibedakan (misalnya apakah bahasa mencoba melakukan konversi tersirat dari string ke angka).

Lihat halaman wiki untuk informasi lebih detail.

Anda telah menemukan titik lemah dalam terminologi yang digunakan amatir untuk berbicara tentang bahasa pemrograman. Jangan menggunakan istilah pengetikan "kuat" dan "lemah" , karena mereka tidak memiliki kesepakatan universal tentang makna teknis. Sebaliknya, pengetikan statis berarti bahwa program diperiksa sebelum dieksekusi , dan suatu program mungkin ditolak sebelum dimulai. Pengetikan dinamis berarti bahwa tipe nilai diperiksa selama eksekusi , dan operasi yang diketik dengan buruk dapat menyebabkan program berhenti atau menandakan kesalahan pada saat dijalankan . Alasan utama untuk pengetikan statis adalah untuk mengesampingkan program yang mungkin memiliki "kesalahan tipe dinamis".

Pengetikan yang kuat umumnya berarti bahwa tidak ada celah dalam sistem tipe, sedangkan pengetikan yang lemah berarti sistem tipe dapat ditumbangkan (membatalkan jaminan apa pun). Istilah ini sering digunakan secara tidak benar untuk maksud pengetikan statis dan dinamis. Untuk melihat perbedaannya, pikirkan C: bahasanya dicentang jenisnya pada waktu kompilasi (pengetikan statis), tetapi ada banyak celah; Anda bisa melempar nilai dari tipe apa pun ke tipe lain dengan ukuran yang sama --- khususnya, Anda dapat menggunakan tipe pointer secara bebas. Pascal adalah bahasa yang dimaksudkan untuk diketik dengan kuat tetapi terkenal memiliki celah yang tidak terduga: rekaman varian tanpa tag.

Implementasi bahasa yang sangat diketik sering mendapatkan celah dari waktu ke waktu, biasanya sehingga bagian dari sistem run-time dapat diimplementasikan dalam bahasa tingkat tinggi. Sebagai contoh, Objective Caml memiliki fungsi yang disebut Obj.magicyang memiliki efek run-time hanya mengembalikan argumennya, tetapi pada waktu kompilasi ia mengkonversi nilai dari jenis apa pun ke salah satu dari jenis lainnya. Contoh favorit saya adalah Modula-3, yang desainernya disebut tipe-casting construct LOOPHOLE.

Karena itu, Anda tidak dapat mengandalkan dua orang yang menggunakan kata "kuat" dan "lemah" dengan cara yang persis sama. Jadi hindari mereka.

Sederhananya seperti ini: dalam bahasa yang diketik secara statis , jenisnya statis , artinya setelah Anda menetapkan variabel ke suatu jenis, Anda TIDAK BISA mengubahnya. Itu karena mengetik dikaitkan dengan variabel daripada nilai yang dirujuk.

Misalnya di Jawa:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

Sedangkan dalam bahasa yang diketik secara dinamis , jenisnya dinamis , artinya setelah Anda menetapkan variabel ke suatu jenis, Anda BISA mengubahnya. Itu karena mengetik dikaitkan dengan nilai daripada variabel.

Misalnya dengan Python:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

Di sisi lain, pengetikan kuat / lemah dalam bahasa terkait dengan konversi tipe implisit (sebagian diambil dari jawaban @ Dario):

Misalnya dengan Python:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

sedangkan di PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Pengetikan statis memungkinkan untuk memeriksa kebenaran jenis pada waktu kompilasi. Bahasa yang diketik secara statis biasanya dikompilasi, dan bahasa yang diketik secara dinamis ditafsirkan. Oleh karena itu, bahasa yang diketik secara dinamis dapat memeriksa pengetikan saat dijalankan.

Lemah mengetik berarti bahwa jenis objek dapat berubah tergantung pada konteksnya. Misalnya dalam bahasa yang diketik dengan lemah, string "123" dapat dianggap sebagai angka 123 jika Anda menambahkan nomor lain ke dalamnya. Contoh bahasa dengan pengetikan lemah adalah bash, awk dan PHP.

Jenis lain dari bahasa yang diketik dengan lemah adalah C, di mana data pada alamat memori dapat diperlakukan sebagai jenis yang berbeda dengan casting.

Dalam bahasa yang sangat diketik, jenis objek tidak berubah - int selalu int dan mencoba menggunakannya sebagai string akan menghasilkan kesalahan. Baik Java dan Python sangat diketik.

Perbedaan antara pengetikan dinamis dan statis adalah ketika aturan tipe diberlakukan. Dalam bahasa yang diketik secara statis, jenis setiap variabel dan parameter harus dideklarasikan di sumber dan diberlakukan pada waktu kompilasi. Dalam bahasa yang diketik secara dinamis, tipe-tipe tersebut hanya diperiksa ketika digunakan saat runtime. Jadi Java diketik secara statis dan Python diketik secara dinamis.

Namun batas-batasnya terkadang sedikit buram. Sebagai contoh meskipun Java diketik secara statis, setiap kali Anda menggunakan refleksi atau gips (misalnya ketika menggunakan wadah Obyek) mereka Anda menunda pemeriksaan tipe untuk runtime.

Demikian pula bahasa yang paling diketik kuat masih akan secara otomatis mengkonversi antara bilangan bulat dan mengapung (dan dalam beberapa bahasa BigInts presisi abitrary).

Hari ini meneliti tentang hal ini saya menemukan artikel hebat ini http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Ini telah membersihkan banyak hal-hal untuk saya dan saya pikir itu dapat menambah beberapa jawaban besar di atas.

Mengetik Kuat dan Lemah:

Mungkin sistem tipe cara yang paling umum diklasifikasikan adalah "kuat" atau "lemah." Ini sangat disayangkan, karena kata-kata ini hampir tidak memiliki makna sama sekali. Pada batas tertentu, dimungkinkan untuk membandingkan dua bahasa dengan sistem tipe yang sangat mirip, dan menunjuk satu sebagai yang lebih kuat dari kedua sistem tersebut. Di luar itu, kata-kata itu tidak ada artinya sama sekali.

Tipe Statis dan Dinamis

Ini hampir merupakan satu-satunya klasifikasi umum dari sistem tipe yang memiliki arti nyata. Faktanya, signifikansinya sering di bawah perkiraan [...] Sistem tipe dinamis dan statis adalah dua hal yang sangat berbeda, yang tujuannya terjadi sebagian tumpang tindih.

Sistem tipe statis adalah mekanisme di mana kompiler memeriksa kode sumber dan memberikan label (disebut "tipe") ke potongan sintaks, dan kemudian menggunakannya untuk menyimpulkan sesuatu tentang perilaku program. Sistem tipe dinamis adalah mekanisme di mana kompiler menghasilkan kode untuk melacak jenis data (kebetulan, juga disebut "tipe" -nya) yang digunakan oleh program. Penggunaan kata "jenis" yang sama di masing-masing dari kedua sistem ini, tentu saja, tidak sepenuhnya sepenuhnya kebetulan; namun paling baik dipahami memiliki semacam signifikansi sejarah yang lemah. Kebingungan hebat muncul karena mencoba menemukan pandangan dunia di mana "tipe" benar-benar berarti hal yang sama di kedua sistem. Tidak.

Jenis Eksplisit / Implisit:

Ketika istilah-istilah ini digunakan, mereka merujuk pada sejauh mana kompiler akan beralasan tentang jenis statis bagian dari suatu program. Semua bahasa pemrograman memiliki beberapa bentuk alasan tentang jenis. Beberapa memiliki lebih dari yang lain. ML dan Haskell memiliki tipe implisit, karena tidak diperlukan (atau sangat sedikit, tergantung pada bahasa dan ekstensi yang digunakan) deklarasi tipe diperlukan. Java dan Ada memiliki tipe yang sangat eksplisit, dan seseorang secara konstan mendeklarasikan jenis-jenisnya. Semua hal di atas memiliki (relatif, dibandingkan dengan C dan C ++, misalnya) sistem tipe statis yang kuat.

Dari Scott's Programming Language Pragmatics , edisi ke-3 halaman 291, kami miliki

Pemeriksaan jenis adalah proses memastikan bahwa suatu program mematuhi aturan kompatibilitas jenis bahasa. Pelanggaran aturan dikenal sebagai tipe bentrokan. Suatu bahasa dikatakan sangat diketik jika ia melarang, dengan cara yang bisa diterapkan oleh implementasi bahasa, penerapan operasi apa pun untuk objek apa pun yang tidak dimaksudkan untuk mendukung operasi itu. Suatu bahasa dikatakan diketik secara statis jika diketik dengan kuat dan pemeriksaan tipe dapat dilakukan pada waktu kompilasi. Dalam pengertian istilah yang paling ketat, beberapa bahasa diketik secara statis. Dalam prakteknya, termis sering diterapkan pada bahasa-bahasa di mana sebagian besar pemeriksaan tipe dapat dilakukan pada waktu kompilasi, dan sisanya dapat dilakukan pada saat run time.

Beberapa contoh: Ada diketik dengan kuat, dan sebagian besar diketik secara statis (batasan tipe tertentu harus diperiksa pada saat run time). Implementasi Pascal juga dapat melakukan sebagian besar pengecekan tipenya pada waktu kompilasi, meskipun bahasa tersebut tidak diketik dengan sangat kuat: catatan varian yang tidak ditandai (akan dibahas dalam Bagian 7.3.4) adalah satu-satunya jalan keluarnya. C89 secara signifikan lebih kuat diketik daripada dialek pendahulunya, tetapi masih secara signifikan lebih sedikit diketik daripada Pascal. Celahnya termasuk serikat pekerja, subrutin dengan jumlah parameter variabel, dan interoperabilitas pointer dan array (akan dibahas dalam Bagian 7.7.1). Implementasi C jarang memeriksa apa pun saat dijalankan.

Pengecekan tipe dinamis (run-time) adalah bentuk pengikatan yang terlambat, dan cenderung ditemukan dalam bahasa yang menunda masalah lain hingga waktu berjalan juga. Lisp dan Smalltalk diketik secara dinamis (meskipun sangat). Sebagian besar bahasa scripting juga diketik secara dinamis; beberapa (misalnya, Python dan Ruby) sangat diketik. Bahasa dengan pelingkupan dinamis umumnya diketik secara dinamis (atau tidak diketik sama sekali): jika kompiler tidak dapat mengidentifikasi objek yang dirujuk oleh suatu nama, ia biasanya tidak dapat menentukan jenis objek tersebut.

Jadi secara sederhana, pengetikan statis / dinamis mengacu pada waktu ketika pengecekan tipe terjadi: waktu kompilasi untuk pengetikan statis, dan jangka waktu untuk bahasa dinamis. Demikian juga, pengetikan kuat / lemah mengacu pada seberapa agresif suatu bahasa dalam menegakkan sistem tipenya.

Saya sudah mencoba menerjemahkan deskripsi Scott ke dalam diagram yang bagus, yang saya posting di bawah ini.

Saya pikir kolega lain membuat pekerjaan yang baik esp. menjelaskan perbedaan antara pengetikan statis dan dinamis. Namun sejauh menyangkut pengetikan kuat dan lemah, harus dikatakan bahwa ada perbedaan pemahaman / pandangan.

Berikut dua contoh:

• Beberapa mengatakan bahwa Haskell sangat diketik, karena Anda tidak diperbolehkan melakukan konversi jenis apa pun .

• Lainnya (mis. Dario view) mengatakan bahasa yang memungkinkan untuk secara implisit mengkonversi dari string ke nomor sengaja diketik, tetapi bahkan yang lain menyebut ini hanya mengetik bebek.

Kedua pernyataan tersebut menyoroti bukan ekstrem yang berlawanan dari sistem tipe, tetapi aspek yang sama sekali berbeda. Jadi saya bergabung dengan pandangan Pak Ramsey untuk tidak menggunakan istilah "kuat" dan "lemah" untuk membedakan antara sistem tipe.

Statis v / s bahasa yang diketik secara dinamis

• Bahasa yang diketik secara statis adalah bahasa di mana pemeriksaan tipe dilakukan pada waktu kompilasi, jadi ini juga berarti bahwa dalam bahasa yang diketik secara statis, setiap variabel memiliki tipe dan itu tidak berubah selama kursus. Sekarang, sebaliknya, bahasa yang diketik secara dinamis adalah yang di mana pemeriksaan tipe dilakukan pada saat runtime, dan tidak ada pemeriksaan tipe pada waktu kompilasi, jadi ini juga berarti bahwa dalam bahasa yang diketik secara dinamis mungkin ada atau mungkin bukan tipe yang terkait dengan variabel , dan jika suatu tipe dikaitkan maka itu bisa menjadi tipe generik seperti "var" di JS yang cocok untuk string dan angka.
  • “Implementasi bahasa yang dicentang secara dinamis umumnya mengasosiasikan setiap objek runtime dengan tag jenis (yaitu, referensi ke suatu jenis) yang berisi informasi jenisnya. Informasi jenis runtime (RTTI) ini juga dapat digunakan untuk mengimplementasikan pengiriman dinamis, pengikatan lambat, pengecoran turun, refleksi, dan fitur serupa. "
• Bahkan jika bahasa diketik secara statis, tetap saja ia dapat memiliki beberapa fitur yang diketik secara dinamis, yang pada dasarnya berarti semacam pemeriksaan pada saat runtime juga. Ini berguna dalam casting tipe.
  • “Sejumlah fitur bahasa pemrograman yang berguna dan umum tidak dapat diperiksa secara statis, seperti down casting. Dengan demikian, banyak bahasa akan memiliki pemeriksaan tipe statis dan dinamis; pemeriksa tipe statis memverifikasi apa yang bisa, dan pemeriksaan dinamis memverifikasi sisanya. "
• “Beberapa bahasa memungkinkan penulisan kode yang tidak aman untuk mengetik. Sebagai contoh, di C, programmer dapat dengan bebas memberikan nilai antara dua tipe yang memiliki ukuran yang sama. "
• Keuntungan dari bahasa yang diketik "statis" adalah:
  • Karena sebagian besar pengecekan tipe dilakukan pada waktu kompilasi sehingga interpreter atau runtime dapat berjalan dengan kecepatan penuh, tanpa khawatir tentang jenisnya.
  • Ini menyebabkan jumlah pengecualian runtime yang lebih sedikit atau kesalahan yang terkait dengan tipe, karena sebagian besar pemeriksaan tipe dilakukan pada waktu kompilasi.
• Keuntungan dari bahasa yang diketik "secara dinamis" adalah:
  • Mereka dapat membantu dalam pembuatan prototipe yang sangat cepat, karena pengembang tidak perlu memahami sistem tipe sehingga dev dapat secara bebas membuat variabel dan menjalankannya, dan ini mengarah pada pembuatan prototipe yang sangat cepat.
• Daftar bahasa yang diketik secara statis dan dinamis :
  • Secara statis:
    • Jawa
    • C (C adalah bahasa yang diketik secara statis tetapi lebih sedikit "sangat" diketik dibandingkan dengan Java karena memungkinkan konversi yang lebih implisit)
    • C ++
    • C #
  • Secara dinamis:
    • PERL
    • PHP
    • Python
    • JavaScript
    • Rubi
• Pengecekan tipe adalah fitur keamanan yang penting. Misalkan, tidak ada pengecekan tipe, dan sebuah metode menerima objek bertipe “BankAccount” yang memiliki metode yang disebut “creditAccount (BankAccountDetails)”, sekarang pada saat runtime jika tidak ada pengecekan tipe maka saya dapat melewati objek saya sendiri kelas yang memiliki metode yang sama "creditAccount (BankAccountDetails)" dan itu akan dieksekusi, mengingat kita berbicara tentang bahasa berorientasi objek karena OOP mendukung "polimorfisme" dan di sini yang kita bicarakan hanyalah "polimorfisme". Jadi, pada dasarnya bahasa berorientasi objek (yang pada dasarnya berarti mendukung "polimorfisme") yang tidak memiliki pemeriksaan tipe yang kuat dapat menyebabkan masalah keamanan.

Sangat v / s bahasa yang diketik dengan lemah

• Bahasa yang diketik dengan sangat baik adalah bahasa yang konversi implisitnya tidak diizinkan jika ada kehilangan presisi. Misalnya, di Jawa, Anda dapat menggunakan "int to long" karena tidak ada kehilangan presisi, tetapi Anda tidak dapat "secara implisit" melemparkan "long to int" karena akan ada kehilangan presisi. Sebaliknya, dalam bahasa yang diketik dengan buruk, konversi implisit diperbolehkan meskipun ada kehilangan presisi.
• Saya pikir bahasa yang diketik secara dinamis juga bisa menjadi bahasa yang sangat diketik jika "saat runtime" itu tidak memungkinkan konversi tersirat di mana ada kehilangan presisi.

Bacaan lanjutan yang bagus

• Type_system
• Strong_and_weak_typing
• Kategori: Statically_typed_programming_languages
• Kategori: Dynamically_typed_programming_languages

Bahasa yang diketik secara statis umumnya mengharuskan Anda untuk mendeklarasikan jenis variabel, yang kemudian diperiksa pada waktu kompilasi untuk mengurangi kesalahan. Kata "statis" dalam "diketik secara statis" mengacu pada "analisis kode statis", yang merupakan proses memeriksa kode sebelum menjalankannya. Meskipun dimungkinkan untuk bahasa yang diketik secara statis untuk menyimpulkan jenis variabel dari sisi kanan ekspresi atau parameter aktual, dalam praktiknya sebagian besar bahasa yang diketik secara statis memerlukan jenis variabel untuk dinyatakan secara eksplisit.

Bahasa yang diketik secara dinamis umumnya tidak memerlukan deklarasi variabel untuk memiliki tipe, dan mereka menyimpulkan tipe variabel berdasarkan tipe yang dihitung sebagai hasil dari mengevaluasi sisi kanan setiap pernyataan penugasan atau parameter aktual untuk panggilan fungsi. Karena variabel dapat diberikan beberapa tugas selama masa pakainya, jenisnya dapat berubah dari waktu ke waktu dan inilah mengapa ini disebut "diketik secara dinamis". Selain itu, lingkungan runtime perlu melacak tipe saat ini untuk setiap variabel, sehingga tipe terikat ke nilai daripada dengan deklarasi variabel. Ini dapat dianggap sebagai sistem informasi jenis runtime (RTTI).

Elemen bahasa yang diketik secara statis dan dinamis dapat digabungkan. Sebagai contoh, C # mendukung variabel yang diketik secara statis dan dinamis, dan bahasa berorientasi objek umumnya mendukung down-casting hirarki jenis. Bahasa yang diketik secara statis biasanya menyediakan berbagai cara untuk mem-bypass pengecekan jenis, misalnya dengan menggunakan casting, refleksi, dan pemanggilan dinamis.

Pengetikan Kuat vs. Lemah mengacu pada rangkaian seberapa banyak bahasa mencoba untuk mencegah bug karena menggunakan variabel seolah-olah itu satu jenis ketika itu sebenarnya jenis lain. Misalnya C dan Java adalah bahasa yang diketik secara statis, namun Java menggunakan pemeriksaan tipe yang jauh lebih kuat daripada C. Kode C berikut senang dikompilasi dan dijalankan, dan akan menempatkan nilai acak ke dalam variabel b pada saat runtime, kemungkinan besar menyebabkan bug:

char *a = "123";
int b = (int)a;

Kode Java yang setara akan menghasilkan kesalahan kompilasi, yang umumnya lebih disukai:

String a = "123"
int b = (int)a;