Как записать два неизвестных переменных в python
Перейти к содержимому

Как записать два неизвестных переменных в python

  • автор:

Запись переменной в файл

Суть задачи: Программа спрашивает у пользователя (. ) Потом выводит результат записывая его в переменную. Затем этот результат мне нужно записать в файл. Вот код:

eye_color = input("Какой у Вас цвет глаз: ") # определяет цвет глаз. result_eye_color = print("Ваш цвет глаз: " + eye_color + "\n") f = open("test.txt", "w") f.write(result_eye_color)) f.close() 

Выводит ошибку:

TypeError: write() argument must be str, not None

Вроде как исправил.

eye_color = input("Какой у Вас цвет глаз: ") # определяет цвет глаз. result_eye_color = print("Ваш цвет глаз: " + eye_color + "\n") f = open("test.txt", "w") f.write(str(result_eye_color)) # исправил так f.close() 

Но теперь в файл записывается только строка None Помогите, пожалуйста.
Отслеживать
17.2k 4 4 золотых знака 21 21 серебряный знак 32 32 бронзовых знака
задан 17 авг 2019 в 13:42
Joseph Bass Joseph Bass
35 1 1 серебряный знак 7 7 бронзовых знаков

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

result_eye_color = print("Ваш цвет глаз: " + eye_color + "\n") 

Функция print() возвращает None , так что result_eye_color будет None , и потому string(result_eye_color) даст строку «None» .

Используйте просто переменную eye_color :

f.write(eye_color) 

Отслеживать
ответ дан 17 авг 2019 в 13:46
17.2k 4 4 золотых знака 21 21 серебряный знак 32 32 бронзовых знака

Как верно заметил @MarianD, ошибка находится в строке:

result_eye_color = print("Ваш цвет глаз: " + eye_color + "\n") 

Вы пытаетесь выполнить два разных действия в один заход. Первое действие — вывод в консоль текста методом print , а второе — присваивание текста переменной result_eye_color .

Рабочий вариант выглядел бы примерно так:

eye_color = input("Какой у Вас цвет глаз: ") # определяет цвет глаз. result_eye_color = "Ваш цвет глаз: " + eye_color + "\n" print(result_eye_color) # если вы действительно хотите вывести этот текст в консоль f = open("test.txt", "w") f.write(result_eye_color) f.close() 

Как записать два неизвестных переменных в python

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

False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield

Например, создадим переменную:

name = "Tom"

Здесь определена переменная name , которая хранит строку «Tom».

В пайтоне применяется два типа наименования переменных: camel case и underscore notation .

Camel case подразумевает, что каждое новое подслово в наименовании переменной начинается с большой буквы. Например:

userName = "Tom"

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

user_name = "Tom"

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

# две разные переменные name = "Tom" Name = "Tom"

Определив переменную, мы можем использовать в программе. Например, попытаться вывести ее содержимое на консоль с помощью встроенной функции print :

name = "Tom" # определение переменной name print(name) # вывод значения переменной name на консоль

Например, определение и применение переменной в среде PyCharm:

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

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

name = "Tom" # переменной name равна "Tom" print(name) # выводит: Tom name = "Bob" # меняем значение на "Bob" print(name) # выводит: Bob

Типы данных

Переменная хранит данные одного из типов данных. В Python существует множество различных типов данных. В данном случае рассмотрим только самые базовые типы: bool , int , float , complex и str .

Логические значения

Тип bool представляет два логических значения: True (верно, истина) или False (неверно, ложь). Значение True служит для того, чтобы показать, что что-то истинно. Тогда как значение False , наоборот, показывает, что что-то ложно. Пример переменных данного типа:

isMarried = False print(isMarried) # False isAlive = True print(isAlive) # True

Целые числа

Тип int представляет целое число, например, 1, 4, 8, 50. Пример

age = 21 print("Возраст:", age) # Возраст: 21 count = 15 print("Количество:", count) # Количество: 15

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

Для указания, что число представляет двоичную систему, перед числом ставится префикс 0b :

a = 0b11 b = 0b1011 c = 0b100001 print(a) # 3 в десятичной системе print(b) # 11 в десятичной системе print(c) # 33 в десятичной системе

Для указания, что число представляет восьмеричную систему, перед числом ставится префикс 0o :

a = 0o7 b = 0o11 c = 0o17 print(a) # 7 в десятичной системе print(b) # 9 в десятичной системе print(c) # 15 в десятичной системе

Для указания, что число представляет шестнадцатеричную систему, перед числом ставится префикс 0x :

a = 0x0A b = 0xFF c = 0xA1 print(a) # 10 в десятичной системе print(b) # 255 в десятичной системе print(c) # 161 в десятичной системе

Стоит отметить, что в какой-бы системе мы не передали число в функцию print для вывода на консоль, оно по умолчанию будет выводиться в десятичной системе.

Дробные числа

Тип float представляет число с плавающей точкой, например, 1.2 или 34.76. В качесте разделителя целой и дробной частей используется точка.

height = 1.68 pi = 3.14 weight = 68. print(height) # 1.68 print(pi) # 3.14 print(weight) # 68.0

Число с плавающей точкой можно определять в экспоненциальной записи:

x = 3.9e3 print(x) # 3900.0 x = 3.9e-3 print(x) # 0.0039

Число float может иметь только 18 значимых символов. Так, в данном случае используются только два символа — 3.9. И если число слишком велико или слишком мало, то мы можем записывать число в подобной нотации, используя экспоненту. Число после экспоненты указывает степень числа 10, на которое надо умножить основное число — 3.9.

Комплексные числа

Тип complex представляет комплексные числа в формате вещественная_часть+мнимая_часть j — после мнимой части указывается суффикс j

complexNumber = 1+2j print(complexNumber) # (1+2j)

Строки

Тип str представляет строки. Строка представляет последовательность символов, заключенную в одинарные или двойные кавычки, например «hello» и ‘hello’. В Python 3.x строки представляют набор символов в кодировке Unicode

message = "Hello World!" print(message) # Hello World! name = 'Tom' print(name) # Tom

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

text = ("Laudate omnes gentes laudate " "Magnificat in secula ") print(text)

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

''' Это комментарий ''' text = '''Laudate omnes gentes laudate Magnificat in secula Et anima mea laudate Magnificat in secula ''' print(text)

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

Управляющие последовательности в строке

Строка может содержать ряд специальных символов — управляющих последовательностей. Некоторые из них:

  • \\ : позволяет добавить внутрь строки слеш
  • \’ : позволяет добавить внутрь строки одинарную кавычку
  • \» : позволяет добавить внутрь строки двойную кавычку
  • \n : осуществляет переход на новую строку
  • \t : добавляет табуляцию (4 отступа)

Применим несколько последовательностей:

text = "Message:\n\"Hello World\"" print(text)

Консольный вывод программы:

Message: "Hello World"

Хотя подобные последовательности могут нам помочь в некоторых делах, например, поместить в строку кавычку, сделать табуляцию, перенос на другую строку. Но они также могут и мешать. Например:

path = "C:\python\name.txt" print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы «\n», которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:

C:\python ame.txt

Чтобы избежать подобной ситуации, перед строкой ставится символ r

path = r"C:\python\name.txt" print(path)
Вставка значений в строку

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

userName = "Tom" userAge = 37 user = f"name: age: " print(user) # name: Tom age: 37

В данном случае на место будет вставляться значение переменной userName. Аналогично на вместо будет вставляться значение переменной userAge.

Динамическая типизация

Python является языком с динамической типизацией. А это значит, что переменная не привязана жестко к определенному типу.

Тип переменной определяется исходя из значения, которое ей присвоено. Так, при присвоении строки в двойных или одинарных кавычках переменная имеет тип str . При присвоении целого числа Python автоматически определяет тип переменной как int . Чтобы определить переменную как объект float, ей присваивается дробное число, в котором разделителем целой и дробной части является точка.

При этом в процессе работы программы мы можем изменить тип переменной, присвоив ей значение другого типа:

userId = "abc" # тип str print(userId) userId = 234 # тип int print(userId)

С помощью встроенной функции type() динамически можно узнать текущий тип переменной:

userId = «abc» # тип str print(type(userId)) # userId = 234 # тип int print(type(userId)) #

Создание пользовательских типов данных в Python

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

Содержание:

  • Зачем нужны пользовательские типы данных;
  • Определение пользовательского типа данных;
  • Инициализация пользовательского типа данных;
  • Доступ к полям объекта пользовательского класса данных;
  • Пользовательские типы данных и функции;
  • Вложенные пользовательские типы данных.

Зачем нужны пользовательские типы данных?

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

book_title = 'Название книги' book_date = '01-01-2019' book_author = ['Автор 1', 'Автор 2'] book_price = 256 book_num = 9 book_total = book_price * book_num 

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

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

Определение пользовательского типа данных.

Пользовательские типы данных создаются программистом с использованием синтаксиса класса:

class Book: def __init__(self, title=None, date=None, authors=None, price=0, num=0): self.title = title self.date = date self.price = price self.num = num self.total = self.price * self.num if authors is None: self.authors = [] else: self.authors = authors def __repr__(self): return f'self.__class__.__name__>(title=self.title>, date=self.date>, \ authors=self.authors>, price=self.price>, num=self.num>, total=self.total>)' 

Код выше определяет тип данных Book , для хранения информации о книге в книжном магазине. Но такая запись пользовательского типа данных очень многословна, что совсем не по питонически. Для упрощенного и удобного создания пользовательских типов данных, с версии Python 3.7 введен встроенный модуль dataclasses . Этот модуль использует декоратор @dataclass и несколько вспомогательных функций для упрощенного написания пользовательских типов данных.

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

from dataclasses import dataclass, field @dataclass class Book(): """Тип данных книга""" title: str = None date: str = None authors: list = field(default_factory=list) price: float = 0 num: int = 0 total: float = field(init=False) def __post_init__(self): # инициализация переменной `total` self.total = self.price * self.num 

И это все! Коротко? На самом деле, модуль класса данных dataclasses автоматически добавит сгенерированные специальные методы __init__() и __repr__() . Этот модуль дает очень много дополнительных возможностей и полезных фич при создании собственных типов данных, а вызов функции dataclasses.field() для определенного поля, поможет его кастомизировать под свои нужды. При создании своих типов данных, обязательно используете этот модуль, т.к. он защитит вас от многих распространенных ошибок (например объявления изменчивых типов данных по умолчанию).

Примечание. модуль dataclasses не проверяет, указанный в аннотации тип переменной!

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

  • title — название книги,
  • date — дата выхода книги,
  • authors — авторы книги.
  • price — стоимость одной книги,
  • num — количество книг в магазине,
  • total — общая стоимость книг.

Эти переменные называются полями типа данных. Код класса Book — это простое объявление типа. Чтобы использовать тип данных Book() , необходимо просто создать его экземпляр:

>>> book = Book() 

Инициализация пользовательского типа данных.

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

# создаем отдельную переменную типа Book, например для книги gold_key >>> gold_key = Book('Золотой ключик', '1989', ['А. Толстой'], 512, 7) >>> gold_key # Book(title='Золотой ключик', date='1989', authors=['А. Толстой'], # price=512, num=7, total=3584) # создаем отдельную переменную типа Book для day_watch >>> day_watch = Book('Дневной Дозор', '2006', ['В. Васильев', 'С. Лукьяненко'], 1024, 9) >>> day_watch # Book(title='Дневной Дозор', date='2006', authors=['В. Васильев', 'С. Лукьяненко'], # price=1024, num=9, total=9216) 

Доступ к полям объекта пользовательского класса данных.

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

>>> gold_key.title # 'Золотой ключик' >>> gold_key.price # 512 >>> gold_key.authors # ['А. Толстой'] >>> day_watch.title # 'Дневной Дозор' >>> day_watch.date # '2006' >>> day_watch.authors[0] # 'В. Васильев' >>> day_watch.authors # ['В. Васильев', 'С. Лукьяненко'] 

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

Переменные — поля типа данных работают так же, как и простые переменные, поэтому с ними можно выполнять обычные операции доступные типу данных, к которому они относятся:

# присвоение новых значений >>> gold_key.title = 'Современный золотой ключик' >>> gold_key.title # 'Современный золотой ключик' >>> gold_key.authors.append('Неизвестный соавтор') >>> gold_key.authors # ['А. Толстой', 'Неизвестный соавтор'] >>> gold_key.date = 2021 >>> gold_key # Book(title='Золотой ключик', date=2021, authors=['А. Толстой', 'Неизвестный соавтор'], # price=512, num=7, total=3584) # операции сравнения отдельных полей >>> gold_key.total  day_watch.total # True 

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

Пользовательские типы данных и функции.

Большим преимуществом использования пользовательских типов данных является возможность передать сразу весь тип в функцию, а не по одной переменной:

from dataclasses import dataclass, field @dataclass class Book(): """Тип данных книга""" title: str = None date: str = None authors: list = field(default_factory=list) price: float = 0 num: int = 0 total: float = field(init=False) def __post_init__(self): # инициализация переменной `total` self.total = self.price * self.num def print_state_book(book): """Печать сведений о книге""" print(f'Название: book.title>') print('Авторы:') for author in book.authors: print(' '*2, author) print(f'Стоимость книги: book.price:0.2f>') print(f'Количество: book.num>') print(f'Итого: book.total:0.2f>') >>> gold_key = Book('Золотой ключик', '1989', ['А. Толстой'], 512, 7) >>> day_watch = Book('Дневной Дозор', '2006', ['В. Васильев', 'С. Лукьяненко'], 1024, 9) >>> print_state_book(gold_key) # Название: Золотой ключик # Авторы: # А. Толстой # Стоимость книги: 512.00 # Количество: 7 # Итого: 3584.00 >>> print_state_book(day_watch) # Название: Дневной Дозор # Авторы: # В. Васильев # С. Лукьяненко # Стоимость книги: 1024.00 # Количество: 9 # Итого: 9216.00 

Вложенные пользовательские типы данных.

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

from dataclasses import dataclass, field @dataclass class Point: """Точка на плоскости""" x: int = 0 y: int = 0 @dataclass class Rect: """Прямоугольник на плоскости""" top_left: Point = field(default=Point) bottom_right: Point = field(default=Point) # создаем точки на плоскости >>> point1 = Point(10, 20) >>> point2 = Point(30, 55) # чертим прямоугольник >>> rect = Rect(point1, point2) >>> rect Rect(top_left=Point(x=10, y=20), bottom_right=Point(x=30, y=55)) 

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

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

from dataclasses import dataclass, field @dataclass class Point: """Точка на плоскости""" x: int = 0 y: int = 0 # наследуемся от пользовательского типа `Point` @dataclass class SpacePoint(Point): """Точка в пространстве""" z: int = 0 # создаем тип `RectBox` на # основе типа `SpacePoint` @dataclass class RectBox: """Прямоугольный параллелепипед""" front_top_left: SpacePoint = field(default=SpacePoint) back_bottom_right: SpacePoint = field(default=SpacePoint) # создаем точки в пространстве >>> space_point1 = SpacePoint(10, 20, 10) >>> space_point2 = SpacePoint(30, 55, 80) # рисуем прямоугольный параллелепипед >>> rect_box = RectBox(space_point1, space_point2) >>> rect_box # RectBox(front_top_left=SpacePoint(x=10, y=20, z=10), # back_bottom_right=SpacePoint(x=30, y=55, z=80)) # изменим одну координату >>> rect_box.front_top_left.y = 10 >>> rect_box # RectBox(front_top_left=SpacePoint(x=10, y=10, z=10), # back_bottom_right=SpacePoint(x=30, y=55, z=80)) 
  • ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
  • Пространство имен и область видимости в классах
  • Определение классов
  • Объект класса и конструктор класса
  • Создание экземпляра класса
  • Метод экземпляра класса
  • Что такое метод класса и зачем нужен
  • Что такое статический метод в классах Python и зачем нужен
  • Атрибуты класса и переменные экземпляра класса
  • Кэширование методов экземпляра декоратором lru_cache
  • Закрытые/приватные методы и переменные класса Python
  • Наследование классов
  • Множественное наследование классов
  • Абстрактные классы
  • Перегрузка методов в классе Python
  • Перегрузка операторов в классах Python
  • Что такое миксины и как их использовать
  • Класс Python как структура данных, подобная языку C
  • Создание пользовательских типов данных
  • Специальные (магические) методы класса Python
  • Базовая настройка классов Python магическими методами
  • Настройка доступа к атрибутам класса Python
  • Дескриптор класса для чайников
  • Протокол дескриптора класса
  • Практический пример дескриптора
  • Использование метода .__new__() в классах Python
  • Специальный атрибут __slots__ класса Python
  • Специальный метод __init_subclass__ класса Python
  • Определение метаклассов metaclass
  • Эмуляция контейнерных типов в классах Python
  • Другие специальные методы класса
  • Как Python ищет специальные методы в классах
  • Шаблон проектирования Фабрика и его реализация

2. Переменные, выражения и предложения¶

Значение — это одна из фундаментальных вещей, которыми манипулирует программа. Значения, которые мы уже видели в главе 1:

  • 2 (результат сложения 1 + 1 ) и
  • "Hello, World!" .

Эти значения относятся к разным типам: 2целое число, а "Hello, World!"строка, представляющая собой последовательность символов. Строковые значения можно опознать по кавычкам, в которые они заключаются.

Предложение print работает не только со строками, но и с целыми числами.

>>> print 4 4 

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

>>> type(«Hello, World!») >>> type(17)

Строки (англ.: string) принадлежат типу str, а целые числа (англ.: integer) — типу int.

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

В России при записи чисел, имеющих целую и дробную части, принято отделять целую часть от дробной при помощи запятой, например: 3,2 . Тогда как во многих других странах, а также в языках программирования (и Python не является исключением), целую часть числа от дробной отделяют при помощи точки. В таких случаях точку называют десятичной точкой.

>>> type(3.2)

Что касается запятой, то она является допустимым символом в Python, но используется для других целей. Хотя 3,2 — неверная запись числа, это допустимая конструкция Python. Если попробовать вывести значение 3,2 , то получим:

>>> print 3,2 3 2 

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

А что можно сказать о таких значениях, как "17" и "3.2" ? Они выглядят как числа, но они заключены в кавычки, как строки.

>>> type(«17») >>> type(«3.2»)

Строки в Python могут заключаться в одиночные (‘) или в двойные кавычки (”):

>>> type(‘This is a string.’) >>> type(«And so is this.»)

Строки, заключенные в двойные кавычки, могут содержать внутри одинарные кавычки, как в "Say 'Hello'" , а строки, заключенные в одинарные кавычки, могут содержать двойные кавычки, как в 'Say "Hi"' .

2.2. Переменные¶

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

Предложение присваивания создает новые переменные и присваивает им значения:

>>> message = "Say 'Hello'" >>> n = 17 >>> pi = 3.14159 

В этом примере три предложения присваивания. Первое присваивает строку "Say 'Hello'" новой переменной с именем message . Второе присваивает целое значение 17 переменной n , а третье присваивает число с плавающей точкой 3.14159 переменной pi .

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

>>> 17 = n 

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

Имена и значения переменных

Предложение print также работает с переменными.

>>> print message Say 'Hello' >>> print n 17 >>> print pi 3.14159 

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

>>> type(message) >>> type(n) >>> type(pi)

Тип переменной в Python есть тип присвоенного ей значения.

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

2.3. Имена переменных и ключевые слова¶

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

Имена переменных могут быть произвольной длины. Они могут содержать буквы и цифры, но обязаны начинаться с буквы. Хотя допустимо использовать буквы верхнего регистра, по существующему соглашению они не используются. Если вы захотите их использовать, помните, что регистр имеет значение. Bruce и bruce — это две разные переменные.

В имени можно использовать символ подчеркивания ( _ ). Он часто используется в именах, состоящих из нескольких слов, таких, как my_name или price_of_tea_in_china .

Если дать переменной недопустимое имя, это приведет к синтаксической ошибке:

>>> 76trombones = "big parade" SyntaxError: invalid syntax >>> more$ = 1000000 SyntaxError: invalid syntax >>> SyntaxError: invalid syntax

Имя 76trombones недопустимо потому, что начинается не с буквы. Имя more$ неправильно потому, что содержит недопустимый символ доллара. А что не так с class ?

Слово class является одним из ключевых слов Python. Ключевые слова определяют правила и структуру языка, и не могут использоваться как имена переменных.

В языке Python 31 ключевое слово:

and as assert break class continue
def del elif else except exec
finally for from global if import
in is lambda not or pass
print raise return try while with
yield

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

2.4. Предложения¶

Предложение — это инструкция, которую интерпретатор Python может выполнить. До сих пор мы видели два вида предложений: print и присваивание.

Если ввести предложение в строке с приглашением, Python выполнит его и отобразит результат, если таковой имеется. Результатом выполнения предложения print является выведенное значение. Предложение присваивания не производит результата.

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

print 1 x = 2 print x 

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

2.5. Вычисление выражений¶

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

>>> 1 + 1 2 

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

>>> 17 17 >>> x 2 

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

>>> message = "Say 'Hello'" >>> message "Say 'Hello'" >>> print message Say 'Hello' 

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

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

17 3.2 "Hello, World!" 1 + 1 

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

2.6. Операторы и операнды¶

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

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

20 + 32 hour - 1 hour * 60 + minute minute / 60 5 ** 2 (5 + 9) * (15 - 7) 

Символы + , - и / , а также использование скобок для группировки операций, означают в Python то же, что и в математике. Звездочка * обозначает умножение, а две звездочки подряд ** обозначают возведение в степень. Пробелы вокруг операторов не обязательны, однако они облегчают чтение выражений.

Когда на месте операнда оказывается имя переменной, оно заменяется значением переменной, прежде чем выполняется операция.

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

>>> minute = 59 >>> minute / 60 0 

Значением minute является 59, а 59, деленное на 60, дает 0.98333, а не 0. Полученный результат объясняется тем, что Python выполняет целочисленное деление.

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

Поскольку нельзя получить дробный результат, пользуясь операцией / , то вычислим проценты:

>>> minute * 100 / 60 98 

Вновь результат округлен в меньшую сторону, но, по крайней мере, теперь он приблизительно правильный.

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

2.7. Порядок выполнения операций¶

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

  1. Скобки имеют наивысший приоритет. Поскольку выражение в скобках вычисляется первым, то 2 * (3 - 1) дает 4, а (1 + 1) ** (5 - 2) дает 8. Можно использовать скобки и для того, чтобы сделать выражения легче для чтения, например, (minute * 100) / 60 , хотя на результат это никак не влияет.
  2. Возведение в степень имеет следующий приоритет после скобок, так что 2 ** 1 + 1 дает 3, а не 4, и 3 * 1 ** 3 дает 3, а не 27.
  3. Умножение и деление имеют одинаковый приоритет, более высокий, чем сложение и вычитание, приоритет которых также одинаковый. Так, 2 * 3 - 1 дает 5, а не 4, и 2 / 3 - 1 даст -1, а не 1 (помните о целочисленном делении, 2 / 3 = 0).
  4. Операторы с одинаковым приоритетом вычисляются слева направо. Так, в выражении minute * 100 / 60 сначала выполняется умножение, что дает 5900 / 60, которое, в свою очередь, дает 98. Если бы операции выполнялись справа налево, результат бы был 59 * 1 , что дает 59, и в целом неверно.

2.8. Операции над строками¶

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

message - 1 "Hello" / 123 message * "Hello" "15" + 2 

Интересно, что оператор + все же работает со строками, хотя и делает не то, чего можно было бы ожидать. Для строк оператор + выполняет конкатенацию, то есть соединение двух операндов вместе. Например:

>>> fruit = "banana" >>> baked_good = " nut bread" >>> print fruit + baked_good banana nut bread 

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

Оператор * также работает со строками. Он выполняет повторение строки. Например, 'Fun' * 3 дает 'FunFunFun' . Один из операндов обязан быть строкой, другой — целым числом.

С одной стороны, такая интерпретация символов + и * имеет смысл по аналогии со сложением и умножением. Так же, как 4 * 3 эквивалентно 4 + 4 + 4 , мы ожидаем, что "Fun" * 3 будет эквивалентно "Fun" + "Fun" + "Fun" , и так оно и есть. С другой стороны, есть существенный момент, который отличает конкатенацию и повторение строк от сложения и умножения чисел. Можете сами отыскать свойство, которым обладают сложение и умножение чисел, но не обладают конкатенация и повторение строк?

2.9. Ввод¶

В Python есть две встроенные функции для получения ввода с клавиатуры:

n = raw_input("Please enter your name: ") print n n = input("Enter a numerical expression: ") print n 

Пример выполнения этого скрипта может выглядеть так:

$ python tryinput.py Please enter your name: Arthur, King of the Britons Arthur, King of the Britons Enter a numerical expression: 7 * 3 21

Каждая из этих функций позволяет внутри скобок указать приглашение для пользователя.

2.10. Композиция¶

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

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

>>> print 17 + 3 20 

В действительности, сложение должно быть выполнено до вывода, так что действия, на самом деле, выполняются не одновременно. Важно то, что любое выражение, включающее числа, строки и переменные, может использоваться в предложении print:

print "Number of minutes since midnight: ", hour * 60 + minute 

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

percentage = (minute * 100) / 60 

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

Предупреждение: Существуют ограничения на то, где можно использовать определенные выражения. Например, левая часть предложения присваивания должна быть именем переменной, а не выражением. Поэтому следующее предложение неверно: minute + 1 = hour .

2.11. Комментарии¶

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

Поэтому хорошей идеей является добавление к вашим программам заметок, которые бы на естественном языке объясняли, что делает программа. Такие заметки называются комментариями, и помечаются символом # :

# calculate elapsed hour percent percentage = (minute * 100) / 60 

В этом случае комментарий занимает целую строку. Можно также поместить комментарий в конец строки, содержащей предложение Python:

percentage = (minute * 100) / 60 # integer division! 

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

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

2.12. Глоссарий¶

int Тип данных Python, представляющий положительные и отрицательные целые числа. float Тип данных Python, представляющий числа с плавающей точкой. Числа с плавающей точкой имеют внутреннее представление, состоящее из двух частей: мантиссы и степени. При выводе в стандартном формате, они выглядят как десятичные числа с целой и дробной частями. Используя тип float , имейте в виду, что возможны ошибки округления, и всегда помните, что имеете дело с приблизительными значениями. str Тип данных Python, представляющий последовательности символов. выражение Комбинация переменных, операторов и значений, результатом вычисления которой является единственное значение. значение Число или строка (или что-то другое, о чем мы поговорим позднее), которые могут быть сохранены в переменной или использованы в выражении. имя переменной Имя, данное переменной. Имена переменных в Python есть последовательность букв ( a..z, A..Z ), цифр ( 0..9 ) и символа _ , начинающаяся с буквы или символа подчеркивания. Хорошей практикой программирования является выбор таких имен для переменных, которые описывают использование этих переменных в программе. ключевое слово Слово, зарезервированное для специального использования в языке программирования. На ключевые слова опирается компилятор при синтаксическом разборе программы; нельзя использовать ключевые слова, например, if , def и while , в качестве имен переменных. комментарий Информация в программе, предназначенная для программистов (или любого читателя исходного кода) и не оказывающая влияния на выполнение программы. композиция Комбинирование простых выражений и предложений в составные для того, чтобы представить сложные вычисления в удобной и краткой форме. конкатенация Соединение двух строк. операнд То, над чем выполняется операция. оператор Специальный символ, который обозначает операцию, например, сложение, умножение или конкатенацию строк. оператор присваивания Символ = есть оператор присваивания в Python. Его не следует путать со знаком равенства в математике, так как они семантически различны. переменная Имя, связанное со значением. предложение Инструкция, которую интерпретатор Python может выполнить. Примерами предложений языка программирования являются предложение присваивания и предложение print. предложение присваивания

Предложение, которое присваивает значение имени (переменной). Слева от оператора присваивания = находится имя, справа — выражение, которое вычисляется интерпретатором Python и затем присваивается имени. Разница между левой и правой частями предложения присваивания часто сбивает с толку начинающих программистов. В следующем предложении присваивания:

n = n + 1 

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

приоритет операций Набор правил, управляющий порядком вычисления выражений, включающих более одного оператора. тип данных Множество значений. Тип значения определяет, как это значение можно использовать в выражениях. Типы, которые мы встречали до сих пор: целые числа (тип int ), числа с плавающей точкой (тип float ) и строки (тип str ). целочисленное деление Операция деления целого на целое, результатом которой является целое. Целочисленное деление дает полное число раз, которое делитель умещается в делимое, и отбрасывает остаток.

2.13. Упражнения¶

  1. Выясните, что произойдет, если попробовать напечатать предложение присваивания:
>>> print n = 7 

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *