Содержание

Pythonicway — Типы данных в Python

Переменные в Python:

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

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

Для понимания, можете думать о переменной как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Это не совсем верное определение, но оно дает общее представление о картине в целом.

Присвоение значения переменной:

В Python вам не нужно объявлять тип переменной вручную (как, например в С++). Объявление происходит автоматически (это называется динамическая типизация), когда вы присваиваете значение переменной. Знак равенства ( = ) используется для присвоения значения переменной.

Операнд по левую сторону от знака равно ( = ) это имя переменной, операнд по правую сторону — значение присвоенное этой переменной.

Например:

country = "Swiss" # Присвоить значение Swiss переменной под названием country
age = 23 # Присвоение значения 23 переменной age 
print country
print age

При выполнении, данный код выведет:

Swiss
23

Множественное присвоение значений:

В Python возможно присваивать одно значение нескольким переменным сразу. Например:

a = b = c = 1

В данном создается объект со значением 1, и все 3 переменные указывают на область в памяти, в которой он находится.

Встроенные типы данных в Python:

Информация, сохраненная в памяти может быть разных типов данных. Например, возраст человека может быть числовым значением, а его адрес — буквенно-числовым. В Python существует множество стандартных типов данных, которые используются для хранения определенных значений и обладают своими специфическими методами.

К стандартным типам данных в Python относят:

Числовой тип данных в Python:

Числовой тип данных в Python предназначен для хранения числовых значений. Это неизменяемый тип данных, что означает, что изменение значения числового типа данных приведет к созданию нового объекта в памяти (и удалению старого)

Числовые объекты создаются, когда вы присваиваете им значение. Например:

num1 = 23
num2 = 42

Также вы можете удалять числовой объект при помощи ключевого слова del. Синтаксис команды del следующий:

del num1 # удаляет переменную num1
del num2, num3 # удаляет обе переменные num2 за num3 за раз

 В Python есть четыре вида числового типа данных:

  • int (целое число)
  • long (длинное целое число [может быть представлено в восьмеричной или шестнадцатеричной системе исчисления])
  • float (число с плавающей точкой: -0.2, 0.0, 3.14159265 и т.д.)
  • complex (комплексное число) 

Примеры видов числового типа данных:








int long float complex
1 51924361L 0.0 3.14j
102 -0x19323L 15.20 45.j
-786 0122L -21.9 9.322e-36j
0 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j
0b10 535633629843L -90. -.6545+0J
-0x260 -052318172735L -32.54e100 3e+26J
0x69 -4721885298529L 70.2-E12 4.53e-7j

Строки в Python:

Под строками в Python подразумевается набор символов между кавычками. В Python можно использовать пары одинарных либо двойных кавычек. Из строк можно взять подстроку используя оператор нарезки ( [ ] и [ : ] ) с индексами от нуля для первого символа строки и до последнего. Так же можно использовать обратную индексацию от -1 для последнего символа до начала.

Оператор плюс ( + ) для строк соединяет две строки в одну, звездочка ( * ) оператор повторения. Например:

text = "Hello, Python!"
print text[0] # Выводит первый символ
print text[0:5] # Выводит подстроку text от 0 символа до 5 (включительно с нулевым, исключая пятый)
print text[4:10] # Выведет строку от 4 символа до 10 (включая четвертый, исключая 10)
print text[0:14] # Выведет всю строку
print text[7:] # Выведет строку с 7 символа до конца
print text[:5] # Выведет строку с начала до 5 символа. Аналогично print text[0:5]
print text[:] # Выведет всю строку
print text[-1] # Выводит последний символ
print text[-1:-14] # Не сработает, выведет пустую строку
print text[::2] # Третий аргумент - шаг. Выведет каждый второй символ
print text[::-1] # Шаг отрицательный. Выведет фразу наоборот
print text + "Nice to code you" # Выведет новую строку
print text[-1] * 10 # Выведет 10 восклицательных знаков

В результате вы увидите следующее

 

Списки в Python:

Списки, пожалуй, самый универсальный составной тип данных в Python. Список состоит из элементов, разделенных запятыми, находящихся между квадратными скобками ( [ ] ). В определенной мере, списки подобны массивам в C. Единственной разницей является то, что элементы одного списка могут иметь разные типы данных.

Получить доступ к элементам, сохраненным в списке можно, точно так же, как и в строках, при помощи оператора нарезки ( [ ] и [:] ) и индексов, начиная с нуля и до конца. Знак плюс ( + ) объединяет два списка, а звездочка ( * ) — оператор повторения для списка. Например:

my_list =[True, 786, 3.14, 'text', 70.2]
second_list =[123, 'text']

print my_list          # Напечатает весь список
print my_list[0]       # Напечатает первый элемент списка
print my_list[1:3]     # Напечатает элементы списка со второго по третий 
print my_list[2:]      # Напечатает элементы списка начиная с третьего
print second_list *2  # Напечатает удвоенный список
print my_list + second_list # Напечатает объединенные списки 


В результате вы увидите:

[True, 786, 3.14, 'text', 70.2]
True
[786, 3.14]
[3.14, 'text', 70.2]
[123, 'text', 123, 'text']
[True, 786, 3.14, 'text', 70.2, 123, 'text']

Кортежи в Python:

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

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

my_tuple =(True, 786, 3.14, 'text', 70.2)
second_tuple =(123, 'text') 

print my_tuple # Печатает весь кортеж
rint my_tuple[0] # Печатает первый элемент
print second_tuple *2 # Печатает удвоенный кортеж
print my_tuple + second_tuple # Печатает объединенные кортежи

В результате вы получите:

(True, 786, 3.14, 'text', 70.2)
True
(123, 'text', 123, 'text')
(True, 786, 3.14, 'text', 70.2, 123, 'text')

При этом, следующие действия доступны для списков и недоступны для кортежей:

my_list = ["Rome", 23, ["cat","dog"], True, 3.14]
my_tuple = ("Rome", 23, ["cat","dog"], True, 3.14)

my_list[0] = "Paris" # Замена значения первого элемента сработает для списка
my_tuple[0] = "Paris" # Та же операция для кортежа вызовет ошибку

Словари в Python:

Словари в Python это неотсортированная колекция элементов, доступ к которым осуществляется по ключу. То есть, каждому ключу словаря соответствует определенное значение. Ключом может быть любой неизменяемый тип данных (число, строка, кортеж), значением — любой тип данных.

Пары ключ, значение словаря заключаются в фигурные скобки ( { } ). Есть несколько способов создания словарей:

my_dict = { } # Создаем пустой словарь
my_dict["country"] = "Mexico" # Присваиваем ключу country значение Mexico
print my_dict["country"] # Выведет Mexico

# Заполнение словаря при инициализации
another_dict = {"number":23, 2: True, "my_list":[1,2,3]}
print another_dict.keys() # Напечатает список всех ключей
print another_dict.values() # Напечатает список всех значений

Данный код выведет следующее:

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

Сеты в Python:

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

Создать сеты можно следующими способами:

# Создание пустого сета
s = set()
# Создание сета инициализацией
s = {"hi", "bye"}

Для добавление элемента в сет используется метод add, для удаления — pop или remove. Добавление в сет уже существующего элемента не повлияет на сет. Сеты обладают множеством методов для работы с уникальными элементами, например difference — возвращает элементы сета отсутствующие в другом сете, intersection — наоборот, возвращает елементы сета присутствующие в другом сете.

Преобразование типов данных:

Иногда может возникнуть необходимость преобразовать один тип данных в другой. Для этого существуют специальные встроенные функции Python. Вот некоторые из них:









Функция Описание

int(x [,base])

Преобразовывает х в целое число. Например, int(12.4) -> 12

long(x [,base] )

Преобразовывает х в long. Например, long(20) -> 20L

float(x)

Преобразовывает х в число с плавающей точкой. Например float(10) -> 10.0

complex(real [,imag])

Создает комплексное число. Например complex(20) -> (20+0j)

str(x)

Преобразовывает х в строку. Например str(10) -> ’10’

tuple(s)

Преобразовывает s в кортеж. Например tuple(«hello») -> ( «h»,»e»,»l»,»l»,»o» )

list(s)

Преобразовывает s в список. Например list(«Python») -> [ «P»,»y»,»t»,»h»,»o»,»n» ]

dict(d)

Создает словарь из d. Например dict( [ (1,2), (3,4) ] ) -> { 1:2, 3:4 }

pythonicway.com

Переменные в Python: теория с примерами

Всем привет!

В данном уроке мы рассмотрим чрезвычайно важную концепцию языка Python: переменные. Они позволят нам запоминать, переиспользовать и передавать данные в программах. Поскольку переменные можно найти в любом современном языке программирования, поэтому вам уже могут быть знакомы основные концепции. Однако я настоятельно рекомендую прочитать статью даже тем, для кого Python является не первым языком, поскольку здесь будут разобраны особености, которые не имеют аналогов в других языках.

Объявление переменных

Во первых стоит отметить что Python является языком с динамической типизацией. Это означает что любая переменная может содержать любые значение. Это отличается от тех же переменных, например, в C++. Там нужно явно указывать тип, значение которого будет содержать переменная.

Теперь давайте посмотрим как мы можем создать переменную и присвоить ей значение:

В данном примере мы создаем две переменные: foo и bar. Первая переменная содержит число, а вторая строку. Подробнее о типах в Python в следующем уроке. Как видите, для того чтобы присвоить переменной значение достаточно слева от оператора = указать ее имя, а с права ее значение. Если во время присваивания такой переменной нет, то интерпретатор Python’a создаст новую переменную с указанным именем и присвоит ей указанное значение.

Переменные в Python следует именовать в нижнем регистре и слова разделять нижним подчеркиванием: _. Например: max_age, init_state.

После объявления переменной мы можем ее использовать в любом выражении. В нашем примере, мы передали переменную bar в функцию print().

Вот результат работы программы:

Мы также можем указать значение для нескольких переменных за одну операцию:

a, b, c = 1, 1 + 1, ‘three’

a, b, c = 1, 1 + 1, ‘three’

В итоге мы получим следующие:

  • a: значение 1 типа int
  • b: два числа будут просуммированы и результат (2) будет записан в b
  • c: в данном случае мы просто запишем строку в c

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

a = 1
b = 1 + 1
c = ‘three’

a = 1

b = 1 + 1

c = ‘three’

Теперь давайте рассмотрим в каком случае Python будет создавать новую переменную, а в каком будет использовать существующую.

Область видимости переменной

Данный раздел будет тесно связан с понятием функции в Python, поэтому я сейчас дам небольшое введение в тему.  Тем кто знаком с понятием функций в других языках читать следующий абзац не обязательно.

На данный момент вы можете думать о функциях как о кусочке кода, который может быть вызван по необходимости. Например:

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

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

Локальные переменные

По умолчанию, все переменные объявляются как локальные. Это значит, что переменная будет видна только из той же функции где была объявлена (кроме случаев когда мы объявляем переменные на верхнем уровне, тогда переменная будет видна из всего файла). Пример:

Выполнив данный код вы увидите следующие:

Хоть мы и указали в f, что переменная a равна двум, интерпретатор создал новую локальную переменную a и присвоил ей значение 2. После выхода из функции данная переменная больше не видна и при выводе переменной a ниже, мы уже указываем на глобальную переменную.

Глобальные переменные (global)

В примерах выше мы уже объявляли глобальные переменные. Собственно переменные, которые объявлены не в рамках функций являются глобальными. Однако в Python есть механизм указать внутри функции, что мы хотим использовать глобальную переменную вместо локальной с помощью ключевого слова global:

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

Использование переменной внешней функции (nonlocal)

Также есть возможность указать что должна использоваться переменная из родительского контекста. То есть мы не объявляем новую переменную внутри функции, а используем уже существующею (при этом не обязательно глобальную). Пример:



Как видите, инструкция nonlocal говорит Python’у что мы должны взять внешнюю переменную, а не создавать новую. Вообще данный трюк возможен, поскольку мы можем объявить функцию внутри функции и таким образом расширить одну область видимости другой.

Константы

В Python нет неизменяемых переменных, однако есть соглашение. Принято записывать название переменной в верхнем регистре если она должна использоваться только для чтения. Пример:

UP = 1
RIGHT = 2
DOWN = 3
LEFT = 4

UP = 1

RIGHT = 2

DOWN = 3

LEFT = 4

Операторы присваивания

В Python для увеличения скорости написания кода предусмотрены сокращения для часто используемых операторов:

  • += тоже что x = x + ...
  • -= тоже что x = x - ...
  • *= тоже что x = x  * ...
  • /= тоже что x = x / ...
  • %= тоже что x = x % ...

Пример:

Тест по теме: переменные в Python

Если ты усвоил материал данного урока, тогда попробуй пройти тест и убедиться в своих знаниях!

Переменные в Python

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

If loading fails, click here to try again

Тест по уроку «Переменные в Python». Он поможет вам лучше усвоить материал.

Количество оставшихся вопросов: 4.

Задание

В рамках данного урока поэкспериментируйте с переменными. Попробуйте разные операторы, такие как +, -, * и т.д.

Поделиться ссылкой:

codelessons.ru

Что такое локальные и глобальные переменные в Python: подробное описание работы

От автора: что такое переменная в Python? Переменная Python является зарезервированной ячейкой памяти для хранения значений. Другими словами, переменная в программе Python передает данные на компьютер для обработки.

Каждое значение в Python имеет тип данных. Различные типы данных в Python: Numbers, List, Tuple, Strings, Dictionary и т. д. Переменные могут быть объявлены с любым именем или даже буквами, например, a, aa, abc и т. д. В этом руководстве мы узнаем, как:

Объявить и использовать переменную

Повторно объявить переменную

Объединить переменные

Что такое локальные и глобальные переменные

Как удалить переменную

Как объявить и использовать переменную

Давайте рассмотрим пример. Мы объявим переменную «а» и выведем ее.

Повторное объявление переменной

Вы можете повторно объявить переменную даже после того, как уже объявили ее один раз. Здесь у нас есть переменная, инициализированная как, f =0. Позже мы переназначим для переменной f значение «guru99″.

Пример Python 2

# Объявление переменной и ее инициализация
f = 0
print f
# повторное объявление переменной тоже работает
f = ‘guru99’
print f

# Объявление переменной и ее инициализация

f = 0

print f

# повторное объявление переменной тоже работает

f = ‘guru99’

print f

Пример Python 3

# Объявление переменной и ее инициализация
f = 0
print(f)
# повторное объявление переменной тоже работает
f = ‘guru99’
print(f)

# Объявление переменной и ее инициализация

f = 0

print(f)

# повторное объявление переменной тоже работает

f = ‘guru99’

print(f)

Объединение переменных

Посмотрим, сможете ли вы объединить разные типы данных, такие как строка и число. Например, мы объединяем «Guru» с числом «99».

В отличие от Java, который объединяет число со строкой, не объявляя число как строку, Python требует, чтобы число было объявлено как строка, иначе будет отображаться ошибка TypeError.

Для следующего кода вы получите неопределенный вывод:

a=»Guru»
b = 99
print a+b

После того, как целое число объявлено как строка, мы можем объединить в выходных данных «Guru» + str («99″) = «Guru99″.

a=»Guru»
b = 99
print(a+str(b))

a=»Guru»

b = 99

print(a+str(b))

Локальные и глобальные переменные

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

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

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится.

Переменная f снова объявлена в функции и предполагает локальную область видимости. Ей присваивается значение «I am learning Python.», которое выводится. Эта переменная отличается от глобальной переменной «f», определенной ранее.

После завершения вызова функции локальная переменная f уничтожается. В строке 12, когда мы снова выводим значение «f», оно отображает значение глобальной переменной f =101.

Пример Python 2

# Объявляем переменную и инициализируем ее
f = 101
print f
# Глобальные и локальные переменные в функциях
def someFunction():
# Глобальная f
f = ‘I am learning Python’
print f
someFunction()
print f

# Объявляем переменную и инициализируем ее

f = 101

print f

# Глобальные и локальные переменные в функциях

def someFunction():

# Глобальная f

    f = ‘I am learning Python’

    print f

someFunction()

print f

Пример Python 3

# Объявляем переменную и инициализируем ее
f = 101
print(f)
# Глобальные и локальные переменные в функциях
def someFunction():
# Глобальная f
f = ‘I am learning Python’
print(f)
someFunction()
print(f)

# Объявляем переменную и инициализируем ее

f = 101

print(f)

# Глобальные и локальные переменные в функциях

def someFunction():

# Глобальная f

    f = ‘I am learning Python’

    print(f)

someFunction()

print(f)

Используя ключевое слово global, вы можете ссылаться на глобальную переменную внутри функции.

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится на выходе

Переменная f объявляется с использованием ключевого слова global. Это НЕ локальная переменная, но та же глобальная переменная, объявленная ранее. Следовательно, когда мы выводим ее значение, результат равен 101

Мы изменили значение «f» внутри функции. После завершения вызова функции измененное значение переменной «f» сохраняется. В строке 12, когда мы снова выводим значение «f», оно отображает значение «changing global variable»

Пример Python 2

f = 101;
print f
# Глобальные и локальные переменные в функциях
def someFunction():
global f
print f
f = «changing global variable»
someFunction()
print f

f = 101;

print f

# Глобальные и локальные переменные в функциях

def someFunction():

  global f

print f

f = «changing global variable»

someFunction()

print f

Пример Python 3

f = 101;
print(f)
# Глобальные и локальные переменные в функциях
def someFunction():
global f
print(f)
f = «changing global variable»
someFunction()
print(f)

f = 101;

print(f)

# Глобальные и локальные переменные в функциях

def someFunction():

  global f

print(f)

f = «changing global variable»

someFunction()

print(f)

Удаление переменной

Вы также можете удалить переменную с помощью команды del «имя переменной». В приведенном ниже примере мы удалили переменную f, и когда мы приступили к ее выводу, мы получили ошибку «variable name is not defined», что означает, что вы удалили переменную.

f = 11;
print(f)
del f
print(f)

f = 11;

print(f)

del f

print(f)

Заключение:

Переменными называют «конверты» или «контейнеры», в которых может храниться информация. Как и любой другой язык программирования, Python также использует переменную для хранения информации.

Переменные могут быть объявлены любым именем или даже буквами, например, aa, abc и т. д.

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

В Python вы не можете объединить строку с числом напрямую, вам нужно объявить их как отдельную переменную, и после этого вы можете объединить число со строкой

Объявляйте локальную переменную, когда хотите использовать ее для текущей функции

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

Для удаления переменной используется ключевое слово «del».

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Хотите изучить ООП PHP?

Посмотрите видео по объектно-ориентированному программированию на PHP (ООП PHP)!

Смотреть

webformyself.com

изучение с нуля # 1. Синтаксис.

Этот курс познакомит вас с объектно-ориентированным, интерпретируемым языком программирования — Python.

Это перевод курса Python на сайте www.codecademy.com. Так как там он предоставлен только в английском виде — появилась идея перевести его на русский. По мере появления перевода других частей  они будут добавляться сюда.

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

Большая часть курса написана Eric Weinstein.

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

UPD: Продолжения перевода этого курса не будет, по крайней мере в обозримом будущем. Вместо него — в процессе перевода новый цикл, от tutorialspoint.com — Курс Python с нуля

Python Syntax

Часть 1. Переменные и типы данных
Часть 2. Пробелы и выражения
Часть 3. Комментарии
Часть 4. Математические операции
Часть 5. Заключение
Закрепление знаний

Часть 1. Переменные и типы данных

1. Добро пожаловать в Летающий Цирк.

Python — это мощный и гибкий язык программирования, который можно использовать для разработки web-приложений, для написания декстопных программ с графическим интерфейсом (GUI), на нём можно разрабатывать игры и многое другое.

Python это:

  • язык программирования высокого уровня, то есть чтение кода на Python и написание кода на нём очень простое — он весьма схож с обычным английским языком;
  • интерпретируемый — то есть, вам не потребуется специальный компилятор скриптов, чтобы писать на Python и запускать его скрипты;
  • он объектно-ориентированный, то есть — позволяет пользователям управлять структурами данных, называемыми «объекты«, для построения и выполнения программ, мы обсудим объекты позже, в нашем курсе.;
  • весёлый в изучении и использовании. Python получил своё название в честь Летающего Цирка Монти Пайтона (Monty Python’s Flying Circus), и примеры в коде и учебники часто ссылаются на это шоу и включают в себя шутки, что бы сделать изучения языка более интересным.

Этот курс не предполагает каких-либо знаний у вас о Python в частности, или о программировании в целом.

2. Переменные

Одним из наиболее важных понятий в программировании является понятие «переменная«. Переменными называют слово/идентификатор, которое содержит единственное значение. Например, предположим что вам требуется число 5 в вашей программе, но вы не хотите использовать его немедленно. Вы можете назначить переменную, назовём её «spam« которая имеет значение «5» и хранит его для использования в дальнейшем:

>>> spam = 5

Объявить переменную в Python очень просто — просто указываете имя/идентификатор, как spam и используете знак = для присвоения ей значения — всё готово!

Давайте зададим переменной my_variable значение 10, и посмотрим его вывод:

>>> my_variable = 10
>>> my_variable
10

3. Типы данных

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

В этом случае, тип данных переменной my_variable является integer (положительное или отрицательное целое число). В Python на сегодняшний день существует три типа данных: integers, floats (дробные числительные, например 1.970) и booleans (логический тип данных, который может принимать значение либо True (истина), либо False (ложно)).

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

Никогда не используйте кавычки ( или « ) при определении логических True или False, и всегда указывайте их с Большой буквы. Python — регистро-зависимый язык, и значения для true, truE или True будут совершенно разными. Что касается кавычек, мы начнём использовать их, когда дойдём до изучения последовательностей (strings), которые будут обсуждать в следующих частях.

Давайте установим такие значения нашим переменным:

  1. my_int to the value 7
  2. my_float to the value 1.23
  3. my_bool to the value True

Python detected the following datatypes:
my_int is of <type ‘int’>
my_float is of <type ‘float’>
my_bool is of <type ‘bool’>

4. Переназначение данных

Теперь вы знаете как объявлять переменные и присваивать им разные значения. Так же, вы узнали о трёх типах данных — integers, floats, и booleans.

Вы можете переназначить значение переменной в любое время. Если сначала вы установили для переменной my_int значение 7, но потом решили изменить его на 3 — просто скажите Python-у: my_int = 3 — и он изменит значение этой переменной:

>>> my_int = 7
>>> my_int
7
>>> my_int = 3
>>> my_int
3

Часть 2. Пробелы и выражения

1. Что такое операторы

Вы можете думать о выражениях (statements) Python-a как о простых фразах в английском: это наименьшие объекты в языке, которые имеют смысл. Как, например — «Я«, «люблю» и «Спам» не являются простыми выраженими сами по себе и не несут смысловой нагрузки, но «Я люблю спам» — это уже фраза, имеющая определённое значение. Так же переменные и типы данных не являются выражениями сами по себе, но они являются «строительными блоками», из которых формируются выражения.

Продолжая аналогию с выражения ясно, что нам нужны определённые правила пунктуации, что бы определить где заканчивается одно выражения и начинается другое. Если вы знакомы с JavaScript, вы знаете что в нём операторы заканчиваются символом точки с запятой — » ; «. В Python операторы разделяются пробелами. Так же, как вы не можете в JavaScript вынести часть кода за пределы ограничивающих его точки с запятой, так же не сможете обойти пробел в Python-е.

Возможно, к этому придётся привыкнуть, особенно — если вы начали изучение Python после изучения языка, в котором пробелы не играют роли.

Возьмём, например, скрипт с таким кодом:

def spam():
eggs = 12
return eggs
print spam()

При его выполнении — мы получим сообщени от интерпретатора Python-a об ошибке:

File «./codeacademy_example_1.py», line 5
eggs = 12
^
IndentationError: expected an indented block

Вот само описание: «expected an indented block» — ожидаются отступы блока.

2. Пробелы — значит Правильные отступы

Запомните ошибку, которую вы получили в предыдущем примере: «ожидаются отступы блока«. Вы будете получать такое же сообщение везде, где в коде Python вы будете неправильно использовать пробелы. Если вы ранее изучали JavaScript — думайте о неправильном использовании пробелов в Python как о неправильном использовании символов ; или {} в JS. Если вы используете неправильные знаки препинания, смысл ваших слов может совершенно измениться:

Крестьянин сказал — «Ведьма превратила меня в лягушку!».

Или:

«Крестьянин, — сказала ведьма, — превратил меня в лягушку!».

Понимаете, что мы имеем ввиду?

Давайте правильно расставим отступы в коде с помощью клавиши табуляции Tab на вашей клавиатуре — один раз на второй строке перед eggs, и ещё раз на строке 3 перед return:

def spam():

eggs = 12
return eggs

print spam()

3. Про интерпретатор

Во введении в эту главу мы писали, что Python — интерпретируемый язык, то есть — он обрабатывается интерперетатором.

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

Давайте дадим задачу интепретатору назначить значение True для переменной spam, и False — для eggs:

>>> spam = True
>>> eggs = False
>>> spam
True
>>> eggs
False
>>> print spam, eggs
True False

Часть 3. Комментарии

1. Однострочные комментарии

Вы можете добавлять заметки в ваш код, устанавливая символ # (hash) в начале строки. Эти строки в коде называются комментариями, и они игнорируются интерпретатором — они совершенно не влияют на исполнение кода. Это просто текстовые замечания, написанные программистами что бы дать некоторые инструкции или пояснения к конкретной части программы.

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

2. Многострочные комментарии

Иногда требуется написать большой комментарий, который не поместится в одну строку. Вы можете, конечно, написать комментарии в несколько строк, начиная каждую их них символом # —  но это, согласитесь, лишняя головная боль.

Для написания мультистрочных комментариев — используйте тройные кавычки, как в примере ниже:

«»»Я программист, и я счастлив.
Я ем Мивину и запиваю её чаем!»»»

Часть 4. Математические операции

1. Арифметические операторы

Выражения в Python не ограничены только простыми выражениями типа spam = 3. Они могут так же включать в себя математические выражения, использующие арифметические операторы (arithmetic operators).

Есть шесть таких арифметических операторов, которые мы и будем рассматривать:

  1. Сложение (Addition) (+)
  2. Вычитание (Subtraction) (-)
  3. Умножение (Multiplication) (*)
  4. Деление (Division) (/)
  5. Возведение в квадрат (Exponentiation) (**)
  6. Деление с остатком (Modulo) (%)

Давайте начнём со сложения. Установим значение переменной big_var равным сумме 1 + 2:

>>> big_var = 3 + 2
>>> big_var
5

2. Вычитание (Subtraction)

Теперь — попробуем вычитание.

Мы уже посчитали, что значение переменной big_var равняется 5, но теперь хотим уменьшить его. Укажем интерпретатору переназначить значение переменной, выполнив вычитание 5 — 2:

>>> big_var = 5 — 2
>>> big_var
3

3. Умножение (Multiplication)

Теперь — давайте попробуем выполнить умножение.

Рыцарь, который сказал «Ni!» сказал это дважды. Давайте сделаем это 20 раз, умножив 2 * 10:

>>> ni = 2 * 10
>>> ni
20

4. Деление (Division)

Немного подумав, мы решили что 20 «Ni!» будет слишком много. Давайте используем деление, что бы уменьшить значение до 5:

>>> ni = 20 / 4
>>> ni
5

5. Возведение в степень (Exponentiation)

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

Арифметический оператор ** возводит первое число — base, в значение второго числа — exponent. Так, если вы наберёте 2 ** 3 — вы получите 8 (2 ** 3 это тоже самое, что 2 * 2 * 2 — обе операции дадут значение 8). 5 ** 2 = 25, 2 ** 4 = 16 и так далее.

Итак, наш дровосек очень голоден, и хочет съесть сразу 100 яиц. Давайте установим значение переменной eggs равным 100, используя Exponentiation:

>>> eggs = 10**2
>>> eggs
100

6. Деление с остатком (Modulo)

Теперь у нас множество яиц. Надеюсь — вы оставили место в комнате для spam? (что тут имеется ввиду — затрудняюсь сказать… вероятно — мясные консервы производителя Spam — прим. перевод.)

Наша последняя арифметическая операция — деление с остатком, modulo (так же называемая modulus). Modulo возвращает остаток, полученный в результате деления (division) двух целых (integer) чисел.

Так, если вы попросите интерпретатор посчитать значение 5 % 2 — вы получите результат 1 (т.к. 2 входит в 5 дважды и даёт остаток 1). 10 % 5 = 0, 113 % 100 = 13 и так далее. Давайте у становим значение переменной spam равным 1, используя modulo:

>>> spam = 45 % 22
>>> spam
1

Часть 5. Заключение.

1. Соберём всё в одном

Итак, вы изучили такие понятия в Python:

  • Переменные, которые заключают в себе значения;
  • Типы данных, такие как integers, floats, и booleans;
  • Пробелы, и почему они так важны;
  • Операнды, и чем они схожи с фразами в английском языке;
  • Комментарии, и почему они так нужны в вашем коде;
  • Арифметические действия и оператыры, такие как +, -, *, /, **, и %)

Давайте соберём все наши знания в одно целое, и заставим это всё поработать.

  • напишем однострочный комментарий;
  • объявим переменную monty и установим её значение равным True;
  • объявим вторую переменную, и устанвоим её значеине раыным 1.234;
  • объявим третью переменную, и установим её значение равнывм python в степени 2.

>>> monty = True
>>> python = 1.234
>>> monty_python  = python ** 2
>>> monty_python
1.522756

Закрепление знаний

1. Ваша любимая еда.

Этот раздел написан специально для закрепления материала первого раздела — Python Syntax.

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

Вот как это выглядит в цифрах:

Стоимость еды (meal): $44.50

Надбавка ресторана (tax): 6.75%

Чаевые (tip): 15%

Вы хотите дать чаевые, учитывая полную стоимость еды, включая надбавку ресторана.

Для начала, давайте зададим значение переменной meal равным 44.50:

>>> meal = 44.50
>>> meal
44.5

2. Ресторанная надбавка

Теперь — давайте создадим значение для переменной надбавка.

Надбавка стоимости вашей еды составит 6.75%. Так как мы будем иметь дело с дробными числами, а не с процентами, давайте переведём это значение в float, т.е. дробное десятичное число. Для этого — поделим 6.75 на 100, в результате мы получим обычное десятичное число.

Создадим переменную tax и установим её значение равным десятичному значению 6.75%:

>>> tax = 6.75 / 100
>>> tax
0.0675

3. Чаевые

Вам понравилось обслуживание, и и вы хотите оставить 15% сверх общей цены мяса и надбавки в качестве чаевых.

Перед тем, как с читать общую стоимость, давайте установим значение для переменной tip в размере 15%. Опять-таки, эта цифра в процентах — так что нам надо поделить 15.0 на 100, чтобы получить десятичное значение:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 15.0 / 100
>>> tip
0.15

4. Переназначем значение в одну строку

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

Мы видели в предыдущих уроках, что мы можем переназначать значение переменной когда нам потребуется. Например, мы можем установить значение переменной spam = 7 в одном месте программы, и позже изменить его на другое, указав spam = 3.

Давайте переназначим значение переменной meal на значение meal + meal * tax. Вы можете менять значение переменной, применяя в новом значении её старое значение:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 0.15
>>> meal = 44.50 + 44.50 * 0.0675
>>> print meal
47.50375

5. Второй куплет похож на первый

Почти всё готово. Теперь мы выполним почти то же самое, только на этот раз мы введём новую переменную, вместо того, что бы сбрасывать и назначать новое значение старой.

Теперь, когда значение переменной meal равно стоимости food + tax, давайте зададим новую переменную total, которая будет содержать значение равное meal + meal * tip. Это действие очень похоже на выполненное только что.

Наш код красиво отформатирует значение переменной total и выведет результат на консоль с ограничением в два знака после запятой (мы поговорим о форматировании строк, о консоли, и о форме print в следующих занятиях).

Установим значение total в качестве суммы meal + meal * tip:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 0.15
>>> meal = meal + meal * tax
>>> total = meal + meal * tip
>>> print(«%.2f» % total)
54.63

На этом упражнение закончено, и вы можете переходить ко второй части — Python: изучение с нуля # 2. Strings and Console Output.

rtfm.co.ua

Основы языка программирования Python за 10 минут / Habr

На сайте Poromenos’ Stuff была

опубликована статья, в которой, в сжатой форме,

рассказывают об основах языка Python. Я предлагаю вам перевод этой статьи. Перевод не дословный. Я постарался подробнее объяснить некоторые моменты, которые могут быть непонятны.

Если вы собрались изучать язык Python, но не можете найти подходящего руководства, то эта

статья вам очень пригодится! За короткое время, вы сможете познакомиться с

основами языка Python. Хотя эта статья часто опирается

на то, что вы уже имеете опыт программирования, но, я надеюсь, даже новичкам

этот материал будет полезен. Внимательно прочитайте каждый параграф. В связи с

сжатостью материала, некоторые темы рассмотрены поверхностно, но содержат весь

необходимый метриал.

Основные свойства

Python не требует явного объявления переменных, является регистро-зависим (переменная var не эквивалентна переменной Var или VAR — это три разные переменные) объектно-ориентированным языком.

Синтаксис

Во первых стоит отметить интересную особенность Python. Он не содержит операторных скобок (begin..end в pascal или {..}в Си), вместо этого блоки выделяются отступами: пробелами или табуляцией, а вход в блок из операторов осуществляется двоеточием. Однострочные комментарии начинаются со знака фунта «#», многострочные — начинаются и заканчиваются тремя двойными кавычками «»»»».

Чтобы присвоить значение пременной используется знак «=», а для сравнения —

«==». Для увеличения значения переменной, или добавления к строке используется оператор «+=», а для уменьшения — «-=». Все эти операции могут взаимодействовать с большинством типов, в том числе со строками. Например

>>> myvar = 3

>>> myvar += 2

>>> myvar -= 1
«»«Это многострочный комментарий

Строки заключенные в три двойные кавычки игнорируются»»»

>>> mystring = «Hello»

>>> mystring += » world.»

>>> print mystring

Hello world.
# Следующая строка меняет

значения переменных местами. (Всего одна строка!)

>>> myvar, mystring = mystring, myvar

Структуры данных

Python содержит такие структуры данных как списки (lists), кортежи (tuples) и словари (dictionaries). Списки — похожи на одномерные массивы (но вы можете использовать Список включающий списки — многомерный массив), кортежи — неизменяемые списки, словари — тоже списки, но индексы могут быть любого типа, а не только числовыми. «Массивы» в Python могут содержать данные любого типа, то есть в одном массиве может могут находиться числовые, строковые и другие типы данных. Массивы начинаются с индекса 0, а последний элемент можно получить по индексу -1 Вы можете присваивать переменным функции и использовать их соответственно.

>>> sample = [1, [«another», «list»], («a», «tuple»)] #Список состоит из целого числа, другого списка и кортежа

>>> mylist = [«List item 1», 2, 3.14] #Этот список содержит строку, целое и дробное число

>>> mylist[0] = «List item 1 again» #Изменяем первый (нулевой) элемент листа mylist

>>> mylist[-1] = 3.14 #Изменяем последний элемент листа

>>> mydict = {«Key 1»: «Value 1», 2: 3, «pi»: 3.14} #Создаем словарь, с числовыми и целочисленным индексами

>>> mydict[«pi»] = 3.15 #Изменяем элемент словаря под индексом «pi».

>>> mytuple = (1, 2, 3) #Задаем кортеж

>>> myfunction = len #Python позволяет таким образом объявлять синонимы функции

>>> print myfunction(list)
3

Вы можете использовать часть массива, задавая первый и последний индекс через двоеточие «:». В таком случае вы получите часть массива, от первого индекса до второго не включительно. Если не указан первый элемент, то отсчет начинается с начала массива, а если не указан последний — то масив считывается до последнего элемента. Отрицательные значения определяют положение элемента с конца. Например:

>>> mylist = [«List item 1», 2, 3.14]

>>> print mylist[:] #Считываются все элементы массива

[‘List item 1’, 2, 3.1400000000000001]

>>> print mylist[0:2] #Считываются нулевой и первый элемент массива.

[‘List item 1’, 2]

>>> print mylist[-3:-1] #Считываются элементы от нулевого (-3) до второго (-1) (не включительно)

[‘List item 1’, 2]

>>> print mylist[1:] #Считываются элементы от первого, до последнего

[2, 3.14]

Строки

Строки в Python обособляются кавычками двойными «»» или одинарными «’». Внутри двойных ковычек могут присутствовать одинарные или наоборот. К примеру строка «Он сказал ‘привет’!» будет выведена на экран как «Он сказал ‘привет’!». Если нужно использовать строку из несколько строчек, то эту строку надо начинать и заканчивать тремя двойными кавычками «»»»». Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.

>>>print «Name: %s\nNumber: %s\nString: %s» % (myclass.name, 3, 3 * «-«)

Name: Poromenos

Number: 3

String: —  

strString = «»«Этот текст расположен

на нескольких строках»»»

 

>>> print «This %(verb)s a %(noun)s.» % {«noun»: «test», «verb»: «is»}

This is a test.

Операторы

Операторы while, if, for составляют операторы перемещения. Здесь нет аналога оператора select, так что придется обходиться if. В операторе for происходит сравнение переменной и списка. Чтобы получить список цифр до числа <number> — используйте функцию range(<number>). Вот пример использования операторов

rangelist = range(10) #Получаем список из десяти цифр (от 0 до 9)

>>> print rangelist

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in rangelist: #Пока переменная number (которая каждый раз увеличивается на единицу) входит в список…
# Проверяем входит ли переменная
# numbers в кортеж чисел (3, 4, 7, 9)
if number in (3, 4, 7, 9): #Если переменная number входит в кортеж (3, 4, 7, 9)…
# Операция «break» обеспечивает
# выход из цикла в любой момент
break
else:
# «continue» осуществляет «прокрутку»
# цикла. Здесь это не требуется, так как после этой операции
# в любом случае программа переходит опять к обработке цикла
continue
else:
# «else» указывать необязательно. Условие выполняется
# если цикл не был прерван при помощи «break».
pass # Ничего не делать

 
if rangelist[1] == 2:
print «The second item (lists are 0-based) is 2»
elif rangelist[1] == 3:
print «The second item (lists are 0-based) is 3»
else:
print «Dunno»

 
while rangelist[1] == 1:
pass

Функции

Для объявления функции служит ключевое слово «def». Аргументы функции задаются в скобках после названия функции. Можно задавать необязательные аргументы, присваивая им значение по умолчанию. Функции могут возвращать кортежи, в таком случае надо писать возвращаемые значения через запятую. Ключевое слово «lambda» служит для объявления элементарных функций .

# arg2 и arg3 — необязательые аргументы, принимают значение объявленное по умолчни,
# если не задать им другое значение при вызове функци.
def myfunction(arg1, arg2 = 100, arg3 = «test»):
return arg3, arg2, arg1
#Функция вызывается со значением первого аргумента — «Argument 1», второго — по умолчанию, и третьего — «Named argument».

>>>ret1, ret2, ret3 = myfunction(«Argument 1», arg3 = «Named argument»)
# ret1, ret2 и ret3 принимают значения «Named argument», 100, «Argument 1» соответственно

>>> print ret1, ret2, ret3

Named argument 100 Argument 1

 
# Следующая запись эквивалентна def f(x): return x + 1

functionvar = lambda x: x + 1

>>> print functionvar(1)
2

Классы

Язык Python ограничен в множественном наследовании в классах. Внутренние переменные и внутренние методы классов начинаются с двух знаков нижнего подчеркивания «__» (например «__myprivatevar»). Мы можем также присвоить значение переменной класса извне. Пример:

class Myclass:

common = 10
def __init__(self):
self.myvariable = 3
def myfunction(self, arg1, arg2):
return self.myvariable

 
# Здесь мы объявили класс Myclass. Функция __init__ вызывается автоматически при инициализации классов.

>>> classinstance = Myclass() # Мы инициализировали класс и переменная myvariable приобрела значение 3 как заявлено в методе инициализации

>>> classinstance.myfunction(1, 2) #Метод myfunction класса Myclass возвращает значение переменной myvariable
3
# Переменная common объявлена во всех классах

>>> classinstance2 = Myclass()

>>> classinstance.common
10

>>> classinstance2.common
10
# Поэтому, если мы изменим ее значение в классе Myclass изменятся
# и ее значения в объектах, инициализированных классом Myclass

>>> Myclass.common = 30

>>> classinstance.common
30

>>> classinstance2.common
30
# А здесь мы не изменяем переменную класса. Вместо этого
# мы объявляем оную в объекте и присваиваем ей новое значение

>>> classinstance.common = 10

>>> classinstance.common
10

>>> classinstance2.common
30

>>> Myclass.common = 50
# Теперь изменение переменной класса не коснется
# переменных объектов этого класса

>>> classinstance.common
10

>>> classinstance2.common
50

 
# Следующий класс является наследником класса Myclass
# наследуя его свойства и методы, ктому же класс может
# наследоваться из нескольких классов, в этом случае запись
# такая: class Otherclass(Myclass1, Myclass2, MyclassN)
class Otherclass(Myclass):
def __init__(self, arg1):
self.myvariable = 3
print arg1

 

>>> classinstance = Otherclass(«hello»)

hello

>>> classinstance.myfunction(1, 2)
3
# Этот класс не имеет совйтсва test, но мы можем
# объявить такую переменную для объекта. Причем

# tэта переменная будет членом только classinstance.

>>> classinstance.test = 10

>>> classinstance.test
10

Исключения

Исключения в Python имеют структуру tryexcept [exceptionname]:

def somefunction():
try:
# Деление на ноль вызывает ошибку
10 / 0
except ZeroDivisionError:
# Но программа не «Выполняет недопустимую операцию»
# А обрабатывает блок исключения соответствующий ошибке «ZeroDivisionError»
print «Oops, invalid.»

 

>>> fnexcept()

Oops, invalid.

Импорт

Внешние библиотеки можно подключить процедурой «import [libname]», где [libname] — название подключаемой библиотеки. Вы так же можете использовать команду «from [libname] import [funcname]», чтобы вы могли использовать функцию [funcname] из библиотеки [libname]

import random #Импортируем библиотеку «random»
from time import clock #И заодно функцию «clock» из библиотеки «time»

 

randomint = random.randint(1, 100)

>>> print randomint
64

Работа с файловой системой

Python имеет много встроенных библиотек. В этом примере мы попробуем сохранить в бинарном файле структуру списка, прочитать ее и сохраним строку в текстовом файле. Для преобразования структуры данных мы будем использовать стандартную библиотеку «pickle»

import pickle

mylist = [«This», «is», 4, 13327]
# Откроем файл C:\binary.dat для записи. Символ «r»
# предотвращает замену специальных сиволов (таких как \n, \t, \b и др.).

myfile = file(r«C:\binary.dat», «w»)
pickle.dump(mylist, myfile)

myfile.close()

 

myfile = file(r«C:\text.txt», «w»)

myfile.write(«This is a sample string»)

myfile.close()

 

myfile = file(r«C:\text.txt»)

>>> print myfile.read()
‘This is a sample string’

myfile.close()

 
# Открываем файл для чтения

myfile = file(r«C:\binary.dat»)

loadedlist = pickle.load(myfile)

myfile.close()

>>> print loadedlist

[‘This’, ‘is’, 4, 13327]

Особенности

  • Условия могут комбинироваться. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
  • Используйте операцию «del» чтобы очищать переменные или элементы массива.
  • Python предлагает большие возможности для работы со списками. Вы можете использовать операторы объявлении структуры списка. Оператор for позволяет задавать элементы списка в определенной последовательности, а if — позволяет выбирать элементы по условию.

>>> lst1 = [1, 2, 3]

>>> lst2 = [3, 4, 5]

>>> print [x * y for x in lst1 for y in lst2]

[3, 4, 5, 6, 8, 10, 9, 12, 15]

>>> print [x for x in lst1 if 4 > x > 1]

[2, 3]
# Оператор «any» возвращает true, если хотя
# бы одно из условий, входящих в него, выполняется.

>>> any(i % 3 for i in [3, 3, 4, 4, 3])
True
# Следующая процедура подсчитывает количество
# подходящих элементов в списке

>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 3)
3

>>> del lst1[0]

>>> print lst1

[2, 3]

>>> del lst1

  • Глобальные переменные объявляются вне функций и могут быть прочитанны без каких либо объявлений. Но если вам необходимо изменить значение глобальной переменной из функции, то вам необходимо объявить ее в начале функции ключевым словом «global», если вы этого не сделаете, то Python объявит переменную, доступную только для этой функции.

number = 5

 
def myfunc():
# Выводит 5
print number

 
def anotherfunc():
# Это вызывает исключение, поскольку глобальная апеременная
# не была вызванна из функции. Python в этом случае создает
# одноименную переменную внутри этой функции и доступную
# только для операторов этой функции.
print number

number = 3

 
def yetanotherfunc():
global number
# И только из этой функции значение переменной изменяется.

number = 3

Эпилог

Разумеется в этой статье не описываются все возможности Python. Я надеюсь что эта статья поможет вам, если вы захотите и в дальнейшем изучать этот язык программирования.

Преимущества Python

  • Скорость выполнения программ написанных на Python очень высока. Это связанно с тем, что основные библиотеки Python

    написаны на C++ и выполнение задач занимает меньше времени, чем на других языках высокого уровня.
  • В связи с этим вы можете писать свои собственные модули для Python на C или C++
  • В стандартныx библиотеках Python вы можете найти средства для работы с электронной почтой, протоколами

    Интернета, FTP, HTTP, базами данных, и пр.
  • Скрипты, написанные при помощи Python выполняются на большинстве современных ОС. Такая переносимость обеспечивает Python применение в самых различных областях.
  • Python подходит для любых решений в области программирования, будь то офисные программы, вэб-приложения, GUI-приложения и т.д.
  • Над разработкой Python трудились тысячи энтузиастов со всего мира. Поддержкой современных технологий в стандартных библиотеках мы можем быть обязаны именно тому, что Python был открыт для всех желающих.

habr.com

Часто задаваемые вопросы | Python 3 для начинающих и чайников

Некоторые не совсем очевидные вещи, с которыми сталкиваются начинающие программисты Python.

Почему я получаю исключение UnboundLocalError, хотя переменная имеет значение?

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

Этот код:

>>> x = 10
>>> def bar():
...     print(x)
>>> bar()
10

работает, но следующий код:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

приводит к UnboundLocalError:

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

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

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

В примере выше можно получить доступ к переменной, объявив её глобальной:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
>>> foobar()
10

Это явное объявление требуется для того, чтобы напомнить вам, что (в отличие от внешне аналогичной ситуации с переменными класса и экземпляра), вы на самом деле, изменяете значение переменной во внешней области видимости:

>>> print(x)
11

Вы можете сделать подобную вещь во вложенной области видимости использованием ключевого слова nonlocal:

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
>>> foo()
10
11

Каковы правила для глобальных и локальных переменных в Python?

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

Хотя это немного удивительно на первый взгляд, это легко объяснимо. С одной стороны, требование global для присваиваемых переменных предотвращает непреднамеренные побочные эффекты в bar. С другой стороны, если global был обязательным для всех глобальных ссылок, вы бы использовали global все время. Вы должны были бы объявить как глобальную каждую ссылку на встроенную функцию или компонент импортируемого модуля.

Почему анонимные функции (lambda), определенные в цикле с разными значениями, возвращают один и тот же результат?

Например, вы написали следующий код:

>>> squares = []
>>> for x in range(5):
...    squares.append(lambda: x**2)

Это даёт вам список из 5 функций, считающих x**2. Можно ожидать, что, будучи вызванными, они вернут, соответственно, 0, 1, 4, 9, и 16. Однако, вы увидите, что все они возвращают 16:

>>> squares[2]()
16
>>> squares[4]()
16

Это случается, поскольку x не является локальной для lambda, а определена во внешней области видимости, и получается тогда, когда она вызывается — а не когда определяется.

В конце цикла, x=4, поэтому все функции возвращают 4**2, то есть 16. Это можно также проверить, изменив значение x и посмотрев на результат:

>>> x = 8
>>> squares[2]()
64

Чтобы избежать подобного, необходимо сохранять значения переменных локально:

>>> squares = []
>>> for x in range(5):
...    squares.append(lambda n=x: n**2)

Здесь, n=x создаёт локальную для функции переменную n и вычисляется в момент определения функции:

>>> squares[2]()
4
>>> squares[4]()
16

Это применимо не только к анонимным, а также и к обычным функциям.

Как организовать совместный доступ к глобальным переменным для нескольких модулей?

Канонический способ организовать подобный доступ — это создать отдельный модуль (часто называемый config или cfg). Просто добавьте import config в каждый модуль приложения. При этом модуль становится доступен через глобальное имя. Поскольку существует только один экземпляр модуля, любые изменения, произведённые в модуле отражаются везде. Например:

config.py:

x = 0

mod.py:

import config
config.x = 1

main.py:

import config
import mod
print(config.x)

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

Как правильнее использовать импортирование?

В общих случаях не используйте from modulename import *. Это засоряет пространство имён того, кто импортирует. Некоторые люди избегают этой идиомы даже для тех немногих модулей, которые были спроектированны, чтобы так импортироваться. Это такие модули как Tkinter и threading.

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

Хорошая практика, если Вы импортируете модули в следующем порядке:

  • стандартные библиотечные модули (например, sys, os, getopt, re)
  • модули сторонних разработчиков (всё, что установлено в директории site-packages) — например, PIL, NumPy и т.д.
  • локально созданные модули

Иногда бывает необходимо поместить импорт в функцию или класс, чтобы избежать проблем с циклическим импортом. Gordon McMillan советует:

Циклический импорт отлично работает, если оба модуля используют форму import <module>. Но они терпят неудачу, когда второй модуль хочет извлечь имя из первого (from module import name) и импорт находится на внешнем уровне. Это происходит из-за того, что имена первого модуля ещё недоступны, так как первый модуль занят импортом второго.

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

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

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

Эта техника полезна, если многие из импортов не являются необходимыми, и зависят от того, как программа будет исполняться. Вы также можете поместить импорт в функцию, если конкретные модули используются только в этой функции. Обратите внимание, что загрузить модуль в первый раз может оказаться дорого из-за задержки на инициализацию модуля, однако повторные загрузки «бесплатны», они стоят только пары поисков в словарях. Даже если имя модуля исчезло из области видимости, модуль скорее всего до сих пор находится в sys.modules.

Почему значения по умолчанию разделяются между объектами?

Этот тип ошибки часто встречается среди начинающих. Предположим, функция:

def foo(mydict={}):  # Опасность: разделяемая ссылка между вызовами
    ... compute something ...
    mydict[key] = value
    return mydict

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

Часто ожидается, что вызов функции создаёт новые объекты для значений по умолчанию. Но это не так. Значения по умолчанию создаются лишь однажды, когда функция определяется. Если этот объект изменяется, как словарь в нашем примере, последующие вызовы функции будут использовать изменённый объект.

По определению, неизменяемые объекты (числа, строки, кортежи и None), безопасны при изменении. Изменение изменяемых объектов, таких как словари, списки, и экземпляры пользовательских классов может привести к неожиданным последствиям.

Поэтому, хорошей практикой является не использовать изменяемые объекты в качестве значений по умолчанию. Вместо этого, используйте None и внутри функции, проверяйте аргумент на None и создавайте новый список/словарь. Например, не пишите:

def foo(mydict={}):
    ...

Но пишите так:

def foo(mydict=None):
    if mydict is None:
        mydict = {}  # create a new dict for local namespace

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

def expensive(arg1, arg2, _cache={}):
    if (arg1, arg2) in _cache:
        return _cache[(arg1, arg2)]

    # Расчёт значения
    result = ... expensive computation ...
    _cache[(arg1, arg2)] = result     # Кладём результат в кэш
    return result

Как передать опциональные или именованные параметры из одной функции в другую?

Получить такие параметры можно с помощью спецификаторов * и ** в списке аргументов функции; они возвращают кортеж позиционных аргументов и словарь именованых параметров. После этого Вы можете передать их в другую функцию, используя в её вызове * и **:

def f(x, *args, **kwargs):
    ...
    kwargs['width'] = '14.3c'
    ...
    g(x, *args, **kwargs)

Почему изменение списка ‘y’ изменяет также список ‘x’?

Если вы написали код:

>>> x = []
>>> y = x
>>> y.append(10)
>>> y
[10]
>>> x
[10]

вы, возможно, будете удивлены тому, что добавление в y изменяет также и x.

Два факта приводят к такому результату:

  • Переменные — это просто ссылки на объекты. y = x не создаёт копию списка — это просто создаёт переменную y, которая ссылается на тот же объект, что и x.
  • Списки изменяемы.

После вызова append, содержимое объекта было изменено с [] на [10]. Поскольку x и y ссылаются на один и тот же объект, использование любого из них даёт нам [10].

Если мы используем неизменяемые объекты:

>>> x = 5  # числа неизменяемы
>>> y = x
>>> x = x + 1  # 5 нельзя изменить. Мы создаём НОВЫЙ объект
>>> x
6
>>> y
5

мы можем видеть, что x и y больше не равны, поскольку числа неизменяемы, и x = x + 1 не изменяет число 5 путем увеличения. Вместо этого, создаётся новый объект 6 и присваивается переменной x (то есть, изменяется то, на какой объект ссылается x). После этого у нас 2 объекта (6 и 5) и 2 переменные, которые на них ссылаются.

Некоторые операции (например y.append(10) и y.sort()) изменяют объект, в то время, как внешне похожие операции (например y = y + [10] и sorted(y)) создают новый объект. Вообще в Python (и во всех случаях в стандартной библиотеке), метод, который изменяет объект, возвращает None, чтобы помочь избежать ошибок. Поэтому, если вы написали

y = y.sort()

думая, что это даст вам отсортированную копию y, вы вместо этого получите None, что скорее всего приведёт к легко диагностируемой ошибке.

Однако, существует один класс операций, где одна и та же операция ведёт себя по-разному с различными типами: расширенные операторы присваивания. Например, += изменяет списки, но не кортежи или числа (a_list += [1, 2, 3] эквивалентно a_list.extend([1, 2, 3])) и изменяет список, в то время, как some_tuple += (1, 2, 3) и some_int += 1 создают новый объект.

Если вы хотите знать, ссылаются ли 2 переменные на один объект или нет, вы можете использовать оператор is, или встроенную функцию id.

Как создавать функции более высокого порядка?

Есть два пути: использовать вложенные функции или вызываемые объекты. Например, с использованием вложенных функций:

def linear(a, b):
    def result(x):
        return a * x + b
    return result

Использование вызываемого объекта:

class linear:

    def __init__(self, a, b):
        self.a, self.b = a, b

    def __call__(self, x):
        return self.a * x + self.b

В обоих случаях,

taxes = linear(0.3, 2)

даёт функцию, что (к примеру) taxes(10e6) == 0.3 * 10e6 + 2.

Использование вызываемого объекта — немного медленнее, и в результате получается больше кода. Однако, заметьте, что несколько функций могут разделять свою сигнатуру с помощью наследования:

class exponential(linear):
    # __init__ наследуется
    def __call__(self, x):
        return self.a * (x ** self.b)

Объект может сохранять свое состояние для нескольких вызовов:

class counter:

    value = 0

    def set(self, x):
        self.value = x

    def up(self):
        self.value = self.value + 1

    def down(self):
        self.value = self.value - 1

count = counter()
inc, dec, reset = count.up, count.down, count.set

Здесь inc, dec, reset выступают в роли функций, которые разделяют одну и ту же переменную.

Как скопировать объект в Python?

В общем случае, с помощью модуля copy.

Некоторые объекты можно скопировать более просто. Словари имеют метод copy:

newdict = olddict.copy()

Последовательности могут быть скопированы путём срезов:

new_l = l[:]

Как узнать доступные методы и атрибуты объекта?

dir(x) возвращает список методов и атрибутов.

Как можно узнать имя объекта?

Вообще говоря, никак, поскольку объекты в действительности не имеют имён. Важно: присваивание всегда связывает имя с объектом. Это верно и для инструкций def и class.

>>> class A:
...    pass
...
>>> B = A
>>>
>>> a = B()
>>> b = a
>>> print(b)
<__main__.A object at 0x7fbcc3ee5160>
>>> print(a)
<__main__.A object at 0x7fbcc3ee5160>

Возможно, класс имеет имя: однако, хотя он связан с двумя именами и запрашивается через имя B, созданный экземпляр всё ещё считается экземпляром класса A. Однако, невозможно сказать, имя экземпляра a или b, поскольку оба они связаны с одним и тем же значением.

Какой приоритет у оператора «запятая»?

Запятая не является оператором в Python.

>>> "a" in "b", "a"
(False, 'a')

Поскольку запятая — не оператор, но разделитель между выражениями, пример выше исполняется как если бы было введено:

("a" in "b"), "a"

А не

"a" in ("b", "a")

То же самое верно и для операторов присваивания (=, += и другие). Они не являются операторами как таковыми, а лишь синтаксическими разделителями в операциях присваивания.

Есть ли в Python эквивалент тернарного оператора «?:» в C?

Да. Синтаксис:

[on_true] if [expression] else [on_false]
x, y = 50, 25
small = x if x < y else y

Можно ли писать обфусцированные однострочники?

Можно.

from functools import reduce

# Простые числа < 1000
print(list(filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))))

# Первые 10 чисел Фибоначчи
print(list(map(lambda x,f=lambda x,f:(f(x-1,f)+f(x-2,f)) if x>1 else 1:
f(x,f), range(10))))

# Множество Мандельброта
print((lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+y,map(lambda y,
Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
>=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24))
#    \___ ___/  \___ ___/  |   |   |__ lines on screen
#        V          V      |   |______ columns on screen
#        |          |      |__________ maximum of "iterations"
#        |          |_________________ range on y axis
#        |____________________________ range on x axis

Не пытайтесь это делать дома!

Почему -22 // 10 равно -3?

Поскольку i % j имеет тот же знак, что j. А ещё

i == (i // j) * j + (i % j)

Как можно изменить строку?

Никак, поскольку строки неизменяемы. В большинстве ситуаций, нужно просто сделать новую строку из различных частей. Однако, если так нужно, можно использовать io.StringIO, либо модуль array:

>>> import io
>>> s = "Hello, world"
>>> sio = io.StringIO(s)
>>> sio.getvalue()
'Hello, world'
>>> sio.seek(7)
7
>>> sio.write("there!")
6
>>> sio.getvalue()
'Hello, there!'

>>> import array
>>> a = array.array('u', s)
>>> print(a)
array('u', 'Hello, world')
>>> a[0] = 'y'
>>> print(a)
array('u', 'yello, world')
>>> a.tounicode()
'yello, world'

Как использовать строки для вызова функций/методов?

Существует несколько приёмов.

  • Лучший — использование словаря, ставящего соответствие строке функцию. Его главное достоинство — строки не обязаны совпадать с названиями функций.
def a():
    pass

def b():
    pass

dispatch = {'go': a, 'stop': b}  # Note lack of parens for funcs

dispatch[get_input()]()
  • Использование встроенной функции getattr:
import foo
getattr(foo, 'bar')()
  • Использование locals или eval (не рекомендуется)
def myFunc():
    print("hello")

fname = "myFunc"

f = locals()[fname]
f()

f = eval(fname)
f()

Как удалить все символы новой строки в конце строки?

Можно использовать S.rstrip(«\r\n») для удаления символов новой строки, без удаления конечных пробелов:

>>> lines = ("line 1 \r\n"
...          "\r\n"
...          "\r\n")
>>> lines.rstrip("\r\n")
'line 1 '

Как создать многомерный список?

Возможно, вы попробуете этот неудачный вариант:

>>> A = [[None] * 2] * 3

Это выглядит правильно, если напечатать:

>>> A
[[None, None], [None, None], [None, None]]

Но если вы присвоите значение, то оно появится в нескольких местах:

>>> A[0][0] = 5
>>> A
[[5, None], [5, None], [5, None]]

Причина в том, что оператор * не создаёт копию, а только ссылку на существующий объект. *3 создаёт список из 3 ссылок на один и тот же список. Изменение в одной строке изменяют другие, что, вероятно, не то, что вы хотите.

Возможные пути решения:

A = [None] * 3
for i in range(3):
    A[i] = [None] * 2
w, h = 2, 3
A = [[None] * w for i in range(h)]

Или, можно использовать специальные модули, предоставляющие матрицы. Наиболее известным является NumPy.

Почему a_tuple[i] += [‘item’] не работает, а добавление работает?

Это из-за того, что расширенный оператор присваивания — оператор присваивания, а также из-за разницы между изменяемыми и неизменяемыми объектами в Python.

Это обсуждение относится в общем, когда расширенные операторы присваивания применяются к элементам кортежа, которые указывают на изменяемые объекты, но мы будем использовать список и +=, как образец.

Если вы напишете:

>>> a_tuple = (1, 2)
>>> a_tuple[0] += 1
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

Причина исключения должна быть понятна: 1 добавляется к объекту a_tuple[0], но когда мы пытаемся присвоить результат, 2, к первому элементу в кортеже, мы получаем ошибку, поскольку мы не можем изменить элемент кортежа.

То есть, это выражение делает следующее:

>>> result = a_tuple[0] + 1
>>> a_tuple[0] = result
Traceback (most recent call last):
 ...
TypeError: 'tuple' object does not support item assignment

Когда мы пишем что-то вроде:

>>> a_tuple = (['foo'], 'bar')
>>> a_tuple[0] += ['item']
Traceback (most recent call last):
 ...
TypeError: 'tuple' object does not support item assignment

Исключение немного более неожиданное, но более удивителен тот факт, что, несмотря на ошибку, элемент добавился!

>>> a_tuple[0]
['foo', 'item']

Чтобы понять, что случилось, нужно знать, что:

  • Если объект определяет метод __iadd__, он вызывается, когда выполняется +=, и возвращенное значение используется для присваивания
  • Для списков, __iadd__ эквивалентен вызову extend для списка

Таким образом,

>>> a_list = []
>>> a_list += [1]
>>> a_list
[1]

Эквивалентен:

>>> result = a_list.__iadd__([1])
>>> a_list = result

Таким образом, наш пример с кортежом эквивалентен:

>>> result = a_tuple[0].__iadd__(['item'])
>>> a_tuple[0] = result
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

__iadd__ завершился успешно, и список увеличился, но присваивание законилось ошибкой.

pythonworld.ru

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

.

Стандартные типы данных

Данные, хранящиеся в памяти, могут быть разных типов. Например, возраст человека хранится как числовое значение, а его адрес хранится в виде буквенно-цифровых символов. Python имеет различные стандартные типы данных, которые используются для определения возможных операций и методов хранения для каждого из них.

Python имеет пять стандартных типов данных —

  • Числа — 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.

Примеры
int float complex
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 = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one'])       # Вывод значения для ключа 'one'
print (dict[2])           # Вывод значения для клюса 2
print (tinydict)          # Вывод всего словаря
print (tinydict.keys())   # Вывод всез ключей словаря
print (tinydict.values()) # Вывод всех значений

Это приведет к следующему результату —


This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])

Словари не имеют понятия об упорядочивании среди элементов.

Преобразование типа данных

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

Существует несколько встроенных функций для преобразования из одного типа данных в другой. Эти функции возвращают новый объект, представляющий преобразованное значение.

S.No. Функция & Описание
1


int(x [,base])

Преобразует x в целое число.

2


float(x)

Преобразует x в число с плавающей запятой.

3


complex(real [,imag])

Создает комплексное число.

4


str(x)

Преобразует объект x в строковое представление.

5


repr(x)

Преобразует объект x в строковое выражение.

6


eval(str)

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

7


tuple(s)

Преобразует s в кортеж.

8


list(s)

Преобразует s в список.

9


set(s)

Преобразует s в набор.

10


dict(d)

Создает словарь. d должен быть последовательностью (ключ, значение) кортежей.

11


frozenset(s)

Преобразует s в неизменяемый набор.

12


chr(x)

Преобразует целое число в символ.

13


unichr(x)

Преобразует целое число в символ Unicode.

14


ord(x)

Преобразует один символ в его целочисленное значение.

15


hex(x)

Преобразует целое число в шестнадцатеричную строку.

16


oct(x)

Преобразует целое число в восьмеричную строку.

evileg.com