У ссылок есть типы в Java / C #, но не в Python? [Дубликат]

Статически типизированные языки, такие как языки C ++, Java и динамически типизированные языки, такие как Python, различаются только в терминах выполнения типа переменной. Статически типизированные языки имеют статический тип данных для переменной, здесь тип данных проверяется во время компиляции, поэтому отладка намного проще ... тогда как динамически типизированные языки не делают то же самое, проверяется тип данных, который выполняет программу, и, следовательно,

Кроме того, они имеют очень небольшую разницу и могут быть связаны с сильно типизированными и слабо типизированными языками. Строго типизированный язык не позволяет использовать один тип как другой, например. C и C ++ ... тогда как слабо типизированные языки позволяют eg.python

• В статически типизированном языке переменная связана с типом, который известен во время компиляции, и этот тип остается неизменным во время выполнения программы. Эквивалентно переменной может быть присвоено значение, которое является экземпляром известного / заданного типа.
• В динамически типизированном языке переменная не имеет типа, а ее значение во время выполнения может быть любым формы и формы.

В статически типизированном языке каждое имя переменной привязано как 1. к типу (во время компиляции с помощью объявления данных). 2. к объекту. Связывание с объектом необязательно - если имя не привязано к объекту, имя считается нулевым. На динамически типизированном языке каждое имя переменной (если оно не равно null) связано только с объектом.

Имена привязаны к объектам во время выполнения с помощью операторов присваивания, и можно связать имя к объектам разных типов во время выполнения программы.

Статически типизированные языки программирования проверяют тип (процесс проверки и принудительного применения ограничений типов) во время компиляции, а не во время выполнения.

Динамически типизированные языки программирования проверяют тип при запуске - времени, в отличие от времени компиляции.

Скомпилировано и интерпретировано

«Когда исходный код переведен»

• Исходный код: исходный код (обычно вводимый человеком в компьютер)
• Перевод: Преобразование исходного кода в то, что компьютер может прочитать (т.е. машинный код)
• Время выполнения: Период, когда программа выполняет команды (после компиляции, если скомпилировано)
• Скомпилированный язык: код, переведенный до времени выполнения
• Интерпретированный язык: код, переведенный «на лету» во время исполнения

Ввод текста

Когда типы проверяются «

5 + '3' является примером ошибки типа в сильно типизированных языках , таких как Go и Python, потому что они не допускают« принуждение типа », -> способность значения изменять тип в определенных контекстах, например, слияние двух типов. Слабо напечатанные языки , такие как JavaScript, не будут вызывать ошибку типа (результаты в '53').

• Статический: типы проверяются перед временем выполнения
• Динамический: типы проверяются «на лету» во время исполнения

Определения «Static & amp; compiled» и «Dynamic & amp; Interpreted» весьма схожи. . но помните, что это «когда типы проверены» и «когда исходный код переводится».

Вы получите ошибки одного и того же типа независимо от того, скомпилирован или интерпретирован язык!

Пример Python

Динамический, интерпретированный

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

Поскольку Python интерпретируется и динамически типизируется, он только переводит и вводит код проверки, в котором он выполняется. Блок else никогда не выполняется, поэтому 5 + '3' никогда даже не смотрится!

Что делать, если он был статически введен?

Ошибка типа быть выброшенным до того, как код будет запущен.

Что делать, если он был скомпилирован?

Блок else будет выглядеть так, как если бы он был интерпретирован. переводится / просматривается до запуска, но поскольку он динамически набирается, он не будет вызывать ошибку! Динамически типизированные языки не проверяют типы до выполнения, и эта строка никогда не выполняется.

Перейти Пример

Статический, скомпилированный

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

типы проверяются перед запуском (статические), и ошибка типа сразу же попадает! Типы все еще проверялись до времени выполнения, если они были интерпретированы, имея тот же результат. Если он был динамическим, он не выдавал бы никаких ошибок, даже несмотря на то, что во время компиляции будет рассмотрен код.

Производительность

Скомпилированный язык будет иметь лучшую производительность при запуске -time, если он статически типизирован (по сравнению с динамическим); знание типов допускает оптимизацию машинного кода.

Статически типизированные языки имеют лучшую производительность во время выполнения по существу из-за того, что не требуется динамически проверять типы во время выполнения (он проверяет перед запуском).

Аналогично, скомпилированные языки быстрее во время выполнения, поскольку код уже был переведен вместо необходимости «интерпретировать» / переводить его на лету.

Обратите внимание, что как скомпилированные, так и статически типизированные языки будут иметь задержку перед запуском для перевода и проверки типов соответственно.

Дополнительные отличия

Статическая типизация задерживает ошибки раньше, а не находит их во время выполнения (особенно полезно для длинных программ). Это более «строгий», поскольку он не допускает ошибок типа в любом месте вашей программы и часто предотвращает изменение переменных типов, что еще больше защищает от непреднамеренных ошибок.

num = 2
num = '3' // ERROR

Динамическая типизация более гибкая, которые некоторые ценят. Обычно это позволяет переменным изменять типы, что может привести к неожиданным ошибкам.

Вот пример того, как Python (динамически типизированный) и Go (статически типизированный) обрабатывают ошибку типа:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python проверяет тип во время выполнения и, следовательно:

silly(2)

Выполняется отлично и производит ожидаемый выход Hi. Ошибка возникает только при попадании проблемной строки:

silly(-1)

Производит

TypeError: unsupported operand type(s) for +: 'int' and 'str'

, потому что соответствующая строка была фактически выполнена.

С другой стороны, проверяет тип во время компиляции:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

Вышеуказанное не будет компилироваться со следующей ошибкой:

invalid operation: "3" + 5 (mismatched types string and int)

Статически типизированные языки: каждая переменная и выражение уже известны во время компиляции.

(int a; a может принимать только значения целочисленного типа во время выполнения)

Пример: C, C ++, Java

Динамически типизированные языки: varialbes могут получать различные значения во время выполнения, и тип определяется во время выполнения.

(var a; a может принимать любые значения во время выполнения)

Например: Ruby, Python.

Сильная типизация, вероятно, означает, что переменные имеют четко определенный тип и что существуют строгие правила объединения переменных разных типов в выражениях. Например, если A является целым числом, а B является float, то строгим правилом относительно A + B может быть то, что A передается в float, а результат возвращается как float. Если A является целым числом, а B является строкой, то строгим правилом может быть то, что A + B недействителен.

Статическая типизация, вероятно, означает, что типы назначаются во время компиляции (или ее эквивалент для не- скомпилированные языки) и не может меняться во время выполнения программы.

Обратите внимание, что эти классификации не являются взаимоисключающими, и я ожидаю, что они будут встречаться вместе часто. Многие сильно типизированные языки также статически типизированы.

И обратите внимание, что, когда я использую слово «вероятно», это потому, что не существует общепринятых определений этих терминов. Как вы уже видели из ответов до сих пор.

Проще говоря так: на статически типизированном языке тип static , что означает, когда вы установите переменную на типа, вы НЕ МОЖЕТЕ изменить его. Это связано с тем, что типизация связана с переменной, а не с ее значением.

Например, в Java:

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

Если на динамически типизированном языке тип dynamic , то есть после того, как вы установите переменную типа, вы можете ее изменить. Это связано с тем, что типизация связана со значением, а не с переменной.

Например, в Python:

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

С другой стороны, сильная / слабая типизация на языке связанные с неявными преобразованиями типов (частично взятые из ответа @ Dario):

Например, в Python:

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

, тогда как в PHP:

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

Статическая типизация позволяет проверять правильность типа во время компиляции. Статически типизированные языки обычно скомпилированы, и интерпретируются языки с динамическим типизированием. Поэтому динамически типизированные языки могут проверять ввод текста во время выполнения.

Проще сказать так: в статически типизированных типах переменных языка static , что означает, что после того, как вы установите переменную в тип, вы не можете ее изменить. Это связано с тем, что типизация связана с переменной, а не с ее значением.

Например, в Java:

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

Где, с другой стороны: в динамически типизированных типах переменных языка есть dynamic , что означает, что после установки переменную типа, вы можете ее изменить. Это связано с тем, что типизация связана со значением, которое оно принимает, а не самой переменной.

Например, в Python:

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

Итак, лучше всего использовать переменные в динамически типизированных языках как только общие указатели для типизированных значений.

Подводя итог, тип описывает (или должен был описать) переменные на языке, а не сам язык. Его можно было бы лучше использовать в качестве языка со статически типизированными переменными по сравнению с языком с динамически типизированными переменными IMHO.

Статически типизированные языки, как правило, скомпилированные языки, поэтому компиляторы проверяют типы (правильно ли вы прав? поскольку типы не могут быть изменены позже во время выполнения).

Обычно типизированные языки обычно интерпретируются, поэтому проверка типа (если таковая имеется) происходит во время выполнения, когда они используются. Это, конечно, приносит некоторую производительность и является одной из причин, по которой динамические языки (например, python, ruby, php) не масштабируются так же хорошо, как типизированные (java, c # и т. Д.). С другой стороны, статически типизированные языки имеют большую начальную стоимость: вы обычно пишете больше кода, более сложный код. Но это уплачивается позже.

Хорошо, что обе стороны заимствуют функции с другой стороны. Типизированные языки включают более динамические функции, например, генерики и динамические библиотеки в c #, а динамические языки включают в себя больше проверки типов, например, аннотации типов в python или вариант HACK PHP, которые обычно не являются ядром языка и могут использоваться на спрос.

Когда дело доходит до выбора технологии, ни одна из сторон не обладает внутренним превосходством над другим. Это просто вопрос, нужно ли вам больше контролировать, чтобы начать с или гибкость. просто выберите подходящий инструмент для задания и убедитесь, что вы проверяете, что доступно с точки зрения противоположности, прежде чем рассматривать коммутатор.

динамически типизированный язык помогает быстро прототипировать концепции алгоритмов без накладных расходов на размышление о том, какие типы переменных необходимо использовать (что является необходимостью в статически типизированном языке).

Статическая типизация: языки, такие как Java и Scala, статичны.

Переменные должны быть определены и инициализированы до того, как они будут использоваться в коде.

для ex. int x; x = 10;

System.out.println (x);

Динамический ввод: Perl - это динамически типизированный язык.

Переменные не обязательно должны быть инициализированы до они используются в коде.

y = 10; используйте эту переменную в последней части кода

Терминология "динамически типизированная", к сожалению, вводит в заблуждение. Все языки статически типизированы, а типы - это свойства выражений (а не значений, как думают некоторые). Однако некоторые языки имеют только один тип. Они называются унифицированными языками. Одним из примеров такого языка является нетипизированное лямбда-исчисление.

В нетипизированном лямбда-исчислении все члены являются лямбда-членами, и единственная операция, которая может быть выполнена на члене, применяется к другому члену. Следовательно, все операции всегда приводят либо к бесконечной рекурсии, либо к лямбда-термину, но никогда не сигнализируют об ошибке.

Однако если бы мы увеличили нетипизированное лямбда-исчисление с примитивными числами и арифметическими операциями, тогда мы могли бы выполнять бессмысленные операции , добавляя вместе два лямбда-члена: (λx.x) + (λy.y). Можно утверждать, что единственная нормальная задача - сигнализировать об ошибке, когда это происходит, но чтобы это сделать, каждое значение должно быть помечено индикатором, указывающим, является ли этот термин лямбда-термином или числом. Затем оператор добавления проверяет, действительно ли оба аргумента помечены как числа, а если они нет, сообщите об ошибке. Обратите внимание, что эти теги являются типами not , потому что типы являются свойствами программ, а не значениями, создаваемыми этими программами.

Uni-typed language, который делает это, называется динамически типизированным.

Все языки, такие как JavaScript, Python и Ruby, являются унифицированными. Опять же, оператор typeof в JavaScript и функция type в Python имеют вводящие в заблуждение имена; они возвращают теги, связанные с операндами, а не их типы. Аналогично, dynamic_cast в C ++ и instanceof в Java do not делают проверки типа.

Статично типизированный тип проверки типов во время компиляции и тип не может измениться. [Нельзя получать симпатичные комментарии комментариев к типу, создается новая переменная / ссылка).

Динамическая типизация типов языков во время выполнения и тип переменной CAN могут быть изменены при запуске, время.

Слабые и простые определения, но соответствующие потребности: статически типизированные языки связывают тип с переменной во всей ее области (Seg: SCALA). Динамически типизированные языки связывают тип с фактическим значением, на которое ссылается переменная.