И теперь пришло время познакомиться с типами данных, а также способами их представления, одним из которых являются переменные. Также есть ещё константы, но с ними мы будем знакомиться немного позже.
С типами данных мы уже частично познакомились, когда выводили данные различного типа напрямую в консоль посредством функции printf, не задавая их заранее и никак не преобразовывая. Конечно же, можно делать и так, но какой прок от программы, которая просто выводит данные, никак их не обрабатывая и ничего с ними не делая, это не совсем хорошо. Ведь на то он и процессор, чтобы заниматься какой-то автообработкой, а наша программа должна как-то его на это натолкнуть.
В данном уроке мы также не будем данные никак обрабатывать и преобразовывать, но он станет ещё одной ступенькой к данной теме — различным арифметическим и логическим преобразованиям данных, так как без переменных в данном случае не обойтись. Вообще, конечно, можно и обойтись, работая непосредственно с памятью, но это было бы весьма неудобно и ни о какой наглядности и читабельности не было бы и речи.
Python для начинающих. Как работают переменные в Python. #2
Прежде чем приступить к переменным, мы познакомимся с типами данных, являющимися самой главной основой переменных, так как переменная всегда несёт в себе и представляет какой-то определённый тип.
Данные различного типа — это величины, которые располагаются в каком-то месте памяти и могут занимать в ней различное количество пространства.
Типы данных можно разделить условно на три группы:
- целые — данные целого типа,
- вещественные — данные, которые могут иметь дробную часть,
- символы — данные типа char, которые представляют собой какой-то символ и занимают в памяти всего один байт.
Рассмотрим первый тип. Данные целого типа могут быть различной величины, следовательно будут иметь разный возможный диапазон значений, а также занимать различное количество байт в памяти. Также данные этого типа могут быть знаковыми (возможно отрицательное значение) или беззнаковыми (не меньше нуля).
Рассмотрим, какие бывают данные целого типа (в принципе char тоже можно считать целым типом малой величины, так как зачастую его используют в этом качестве, когда хотят оперировать малыми значениями, чтобы сэкономить память, так как они занимают в ней всего один байт).
Данная таблица, думаю, всё это расскажет:
-9 223 372 036 854 775 808 …
9 223 372 036 854 775 807
Аналогичным образом ведёт себя и вещественный тип. Только представители данного типа могут иметь ещё некоторые свойства. Кроме того, что они тоже занимают в памяти каждый определенное количество байт и имеют диапазоны, они могут быть представлены ещё в нормированной форме — в виде числа, умноженного на 10 в определённой степени. Также данный вид представления называют экспоненциальной записью числа.
Например, число 135.543 можно представить как 1,35543 . 10 2 .
А, например, число 0.00001245 — как 1.245 . 10 -5 .
Первый множитель — это мантисса или значащее число, а степень десятки — это экспонент или показатель, но чаще всего употребляется слово порядок, так как степень у нас именно десяти.
Уроки Python — Типы данных, переменные
В коде мы так написать не можем, в исходном коде первое число будет выглядеть как 1.35543E2, а второе 1.245E-5.
Переменные в Java
Часто Вы можете услышать такое определение переменной:
- Переменная — это некоторый контейнер, в котором может храниться значение для дальнейшего использования в программе.
Помните, как в школе было: y = x + 1
И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.
Если x = 1, тогда x+ 1 =2
Если x = 2, тогда x +1 = 3
Если х = 1.5 , тогда x + 1 =2.5
В Java переменные играют такую же роль, как и в приведенном примере со школы y = x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере — в переменную x.
Типы переменных в Java. Объявление переменной
В Java можно указать, какие именно значения может принимать переменная.
Для этого все переменные сгруппировали в 4 группы:
- Целочисленные (к ним относятся byte, short, int, long)
- С плавающей точкой (к ним относятся float, double)
- Символы (char)
- Логические (boolean)
Примечание: Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.
Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.
Целочисленные: byte, short, int, long
Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.
- byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
- short принимает значения от -32768 до 32767 и занимает 2 байта памяти
- int от -2147483648 до 2147483647 и занимает 4 байта памяти
- long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти
«Ну, хорошо», — скажете Вы. «Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать? » Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.
Задача 1: 
У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?
Как видите, в задаче речь идет о целых яблоках. Не предполагается, что яблоки будут делить на части.
Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?
Всегда необходимо отталкиваться от контекста.
- Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
- Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127. Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767
- Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
- Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.
Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом «по умолчанию» для целочисленных типов. Что это значит, Вы узнаете на практике.
Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные так.
А вот и примеры объявления переменных:
И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и как бы «горбиками» как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel — «верблюд»).
Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете — это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже статью написали
Ну что ж, самое время понять за что отвечают переменные с плавающей точкой.
С плавающей точкой: float, double
И снова обратимся к примеру школьной задачи.
Задача 2: 
У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?
Как видите, в задаче речь идёт уже не о целых яблоках. Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float и ли double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, — 9.4, -107.0, -107.356 и т.д.
Как видно из таблички:
- float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
- double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти
Запомните:
- дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку. Например, 1,5 — это неправильно. Правильно 1.5
- float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
- double обеспечивает двойную точность и это видно из названия (double — двойная).
Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные float и double по такому же принципу.
А вот и примеры объявления переменных:
float money; // объявили переменную money типа float
float wage; // объявили переменную wage типа float
float c; // объявили переменную c типа float
double stat; //объявили переменную stat типа double
Символы: char
В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.
Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные char по такому же принципу, что и ранее.
Примеры объявления переменных:
char y; //объявили переменную y типа char
char f; //объявили переменную f типа char
Логические: boolean
Логические или их еще называют булевы значения могут принимать только одно из двух возможных значений: true или false.
Только у славян возможен такой разговор:
— Да нет, наверное.
Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?
Так вот в языке программирования Java всё очень точно:
- либо true (с английского — «истина»)
- либо false (с английского — «ложь)
Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы конструкции ветвления. А пока просто запомните, что есть такой тип. Пусть это будет пока «черной лошадкой» для Вас.
Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные boolean по такому же принципу, что и ранее.
Примеры объявления переменных:
boolean check1; //объявили переменную check1 типа boolean
boolean check2; //объявили переменную check2 типа boolean
Ну вот, теперь Вы знаете за что отвечают эти типы переменных:
Что ещё Вы должны знать?
1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите «примитивные типы данных» , «примитивы» или «primitives», знайте, речь идёт о 8 типах переменных — byte, short, int, long, float, double, char, boolean.
2. Есть еще один тип переменных — тип String . О нём мы поговорим в статье «Как присвоить значение переменной»
3. В Java очень важно правильно оформлять код . Да-да, не только писать работающие программы, но ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.
5 правил выбора названий для переменных:
Правило №1 — переменные пишутся только латинскими буквами. Никакой кириллицы.
Например:
Правило №2 – имя переменной, по возможности, должно быть «говорящим»
Например:
int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать
int size; // этот вариант более «говорящий», чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то
Правило №3 — с чего может/не может начинаться имя переменной
Может начинаться с :
- Любых латинских букв
- $ или _
Не может начинаться с:
Ниже приводим несколько примеров — правильных и неправильных.
Правильно:
- int square;
- int $money;
- int width;
- int boxSize;
- double sum;
- double sumJune;
Неправильно:
- int 2square;
- int 101dalmatians;
Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle
Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.
Правило №5 – нельзя использовать в названиях переменных эти 54 слова:
abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while
Эти 54 слова имеют особое значение при написании кода на Java . Постепенно Вы поймёте где используется каждое слово. Причём после прочтения этой статьи, из 54 слов Вам уже станут знакомы те слова, которые мы выделили синим:
abstract, assert, boolean , break, byte , case, catch, char , class, const, continue, default, do, double , else, enum, extends, false , final, finally, float , for, goto, if, implements, import, instanceof, int , interface, long , native, new, null, package, private, protected, public, return, short , static, strictfp, String , super, switch, synchronized, this, throw, throws, transient, true , try, void, volatile, while
ПОДЫТОЖИМ:
Всего 4 группы переменных:
- Целочисленные (к ним относятся byte, short, int, long)
- С плавающей точкой (к ним относятся float, double)
- Символы (char)
- Логические (boolean)
Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.
Прежде чем использовать переменную, её необходимо объявить:
5 правил выбора названий переменных:
- Переменные пишутся только латинскими буквами. Никакой кириллицы.
- Имя переменной, по возможности, должно быть «говорящим»
- Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название — CamelCase)
- Есть 54 слова, которые нельзя использовать в названиях переменных
- Имя переменной:
- может начинаться с любых латинских букв, $ или _
- не может начинаться с цифр
Также есть еще один тип переменных — тип String, о котором мы поговорим в статье «Как присвоить значение переменной в Java»
Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.
По всем вопросам звоните:
+38 050 205 77 99
+38 098 205 77 99
Или читайте информацию по нашим курсам Java c нуля у нас на сайте.
- ← Что такое CamelCase или CamelStyle?
- Как создать первую веб-страницу →
Источник: vertex-academy.com
Python 3 — Урок 004. Типы переменных
Переменные — это не что иное, как зарезервированные ячейки памяти для хранения значений. Это означает, что при создании переменной вы резервируете некоторое пространство в памяти. На основе типа данных переменной интерпретатор выделяет память и решает, что можно сохранить в зарезервированной памяти. Поэтому, присваивая переменным разные типы данных, вы можете хранить целые числа, десятичные знаки или символы в этих переменных.
Присвоение значений переменным
Переменные Python не требуют явного объявления для резервирования пространства памяти. Объявление присваивается автоматически, когда вы присваиваете значение переменной. Знак равенства (=) используется для присвоения значений переменным. Операнд слева от оператора = является именем переменной, а операнд справа от оператора = является значением, которое хранится в переменной. Например,
#!/usr/bin/python3 counter = 100 # Целочисленная переменная miles = 1000.0 # Переменная с плафающей точкой name = «John» # Строковая переменная print (counter) print (miles) print (name)
Здесь 100, 1000.0 и «John» являются значениями, присвоенными счетчику, милям и переменной имени, соответственно. Это дает следующий результат:
100 1000.0 John
Множественное присвоение
Python позволяет одновременно назначать одно значение нескольким переменным. Например,
a = b = c = 1
Здесь создается целочисленный объект со значением 1, и все три переменные назначаются в одну и ту же ячейку памяти. Вы также можете назначить несколько объектов нескольким переменным. Например,
a, b, c = 1, 2, «john»
Переменным a и b присваиваются целочисленные значения 1 и 2 соответсвенно, а переменной c присваивается строка john .
Стандартные типы данных
- Числа — Numbers
- Строки — String
- Список — List
- Кортеж — Tuple
- Словарь — Dictionary
Числа Python
Числовые типы данных хранят числовые значения. Числовые объекты создаются при назначении им значения. Например,
var1 = 1 var2 = 10
Вы также можете удалить ссылку на числовой объект, используя оператор del. Синтаксис инструкции del —
del var1[,var2[,var3[. varN]]]]
Вы можете удалить один объект или несколько объектов, используя инструкцию del.
del var del var_a, var_b
Python поддерживает три разных числовых типа —
- int (целые числа со знаком)
- float (реальные значения с плавающей запятой)
- complex (комплексные числа)
Все целые числа в Python3 представлены как long числа. Следовательно, нет отдельного типа long.
Примеры
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3+e18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2-E12 | 4.53e-7j |
Комплексное число состоит из упорядоченной пары вещественных чисел с плавающей запятой, обозначаемой x + yj, где x и y — вещественные числа, j — мнимая единица.
Строки Python
Строки в Python идентифицируются как непрерывный набор символов, представленных в кавычках. Python позволяет использовать пару одиночных или двойных кавычек. Подмножества строк могут быть взяты с использованием оператора среза ([] и [:]) с индексами, начинающимися с 0 в начале строки и работающими от -1 до конца.
Знак плюс (+) является оператором конкатенации строк, а звездочкой (*) является оператор повторения. Например,
#!/usr/bin/python3 str = ‘Hello World!’ print (str) # Вывод всей строки print (str[0]) # Вывод первого символа строки print (str[2:5]) # Вывод символов с третьего по пятый print (str[2:]) # Вывод строки с третьего символа print (str * 2) # Вывод строки дважды print (str + «TEST») # Вывод склеенной строки
Это приведет к следующему результату —
Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST
Списки Python
Списки являются наиболее универсальными составными типами данных Python. Список содержит элементы, разделенные запятыми и заключенные в квадратные скобки ([]). В некоторой степени списки аналогичны массивам в C. Одно из различий между ними состоит в том, что все элементы, принадлежащие списку, могут быть разных типов данных.
Доступ к значениям, хранящимся в списке, можно получить с помощью оператора среза ([] и [:]) с индексами, начинающимися с 0 в начале списка и заканчивающимися -1. Знак плюс (+) — это оператор конкатенации списка, а звездочка (*) — оператор повторения. Например,
#!/usr/bin/python3 list = [ ‘abcd’, 786 , 2.23, ‘john’, 70.2 ] tinylist = [123, ‘john’] print (list) # Вывод всего списка print (list[0]) # Вывод первого элемента списка print (list[1:3]) # Вывод элементов со второго по третий print (list[2:]) # Вывод элементов начиная с третьего print (tinylist * 2) # Вывод списка дважды print (list + tinylist) # Вывод результирующего списка
Это приведет к следующему результату —
[‘abcd’, 786, 2.23, ‘john’, 70.200000000000003] abcd [786, 2.23] [2.23, ‘john’, 70.200000000000003] [123, ‘john’, 123, ‘john’] [‘abcd’, 786, 2.23, ‘john’, 70.200000000000003, 123, ‘john’]
Кортежи Python
Кортеж — это другой тип данных последовательности, аналогичный списку. Кортеж состоит из нескольких значений, разделенных запятыми. Однако, в отличие от списков, кортежи заключены в круглые скобки.
Основное различие между списками и кортежами — Списки заключены в скобки ([]), и их элементы и размер могут быть изменены, а кортежи заключены в круглые скобки (()) и не могут быть обновлены. Кортежи можно рассматривать как списки только для чтения. Например,
#!/usr/bin/python3 tuple = ( ‘abcd’, 786 , 2.23, ‘john’, 70.2 ) tinytuple = (123, ‘john’) print (tuple) # Вывод всего кортежа print (tuple[0]) # Вывод первого элемента в кортеже print (tuple[1:3]) # вывод элементов со второго по третий print (tuple[2:]) # Вывод элементов кортежа с третьего print (tinytuple * 2) # Вывод кортежа дважды print (tuple + tinytuple) # Вывод результирующего кортежа
Это приведет к следующему результату —
(‘abcd’, 786, 2.23, ‘john’, 70.200000000000003) abcd (786, 2.23) (2.23, ‘john’, 70.200000000000003) (123, ‘john’, 123, ‘john’) (‘abcd’, 786, 2.23, ‘john’, 70.200000000000003, 123, ‘john’)
Следующий код недопустим с кортежем, потому что мы попытались обновить кортеж, что запрещено. Подобный случай возможен со списками —
#!/usr/bin/python3 tuple = ( ‘abcd’, 786 , 2.23, ‘john’, 70.2 ) list = [ ‘abcd’, 786 , 2.23, ‘john’, 70.2 ] tuple[2] = 1000 # запрещено для кортежей list[2] = 1000 # допустимо для списков
Словари Python
Словарь Python — это тип хеш-таблицы. Они работают как ассоциативные массивы или хэши, как в Perl, и состоят из пар ключ-значение. Ключ словаря может быть почти любым типом Python, но обычно это числа или строки.
Значения, с другой стороны, могут быть любым произвольным объектом Python.
Словари заключены в фигурные скобки (<>), и значения могут быть получены с помощью квадратных скобок ([]). Например,
#!/usr/bin/python3 dict = <> dict[‘one’] = «This is one» dict[2] = «This is two» tinydict = print (dict[‘one’]) # Вывод значения для ключа ‘one’ print (dict[2]) # Вывод значения для клюса 2 print (tinydict) # Вывод всего словаря print (tinydict.keys()) # Вывод всез ключей словаря print (tinydict.values()) # Вывод всех значений
Это приведет к следующему результату —
This is one This is two dict_keys([‘name’, ‘dept’, ‘code’]) dict_values([‘john’, ‘sales’, 6734])
Словари не имеют понятия об упорядочивании среди элементов.
Преобразование типа данных
Иногда вам может потребоваться выполнить преобразования между встроенными типами. Чтобы преобразовать типы, вы просто используете имена типов как функцию.
Существует несколько встроенных функций для преобразования из одного типа данных в другой. Эти функции возвращают новый объект, представляющий преобразованное значение.