Лекция 1. Основы Python

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

  1. Базовые типы - базовые виды данных, с которыми приходится сталкиваться (числа, строки, последовательности объектов)
  2. Ввод - получение данных через клавиатуру, файл или через другой источник
  3. Вывод - отображение данных на экране, в файле или другом источнике
  4. Условные инструкции - проверка на определенные условия и исполнения кода только если они выполняются/не выполняются
  5. Циклы - повторять какое-то действие много раз

Объект

Котам почему-то всегда говорят «ты», хотя ни один кот ещё ни с кем не пил брудершафта! @Бегемот

cat0

Все в мире объект. Допустим, вы шли по темному переулку и внезапно о что-то споткнулись..

Это что-то мяукает.

In [1]:
from переулок import Котя

cat

Вы видите котенка. Знаете, что котята могут мурлыкать и мяукать и их можно чесать и гладить

In [2]:
dir(Котя())
Out[2]:
['девиз', 'мурлыкнуть', 'мяукнуть', 'погладить', 'позвать', 'почесать']

Решаете его взять домой и напоить молоком.

Но к котам, даже маленьким, надо обращаться культурно. Потому решаете придумать ему имя - Гав. Теперь к коту можно обращаться, кормить и чесать за ухом.

Переменная

In [3]:
Гав = Котя()
In [4]:
Гав.почесать()

Мур
Мур
In [5]:
Гав.погладить()

Мур
Мур
In [6]:
Гав.позвать()

Мяу
In [7]:
Гав.девиз()

Как же туда не ходить? Они, неприятности, же ждут!

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

Базовые типы

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

  1. Целые числа
  2. Числа с плавающей запятой
  3. Логический тип
  4. Строковый тип
  5. То, что мы разберем на следующих лекциях:)

Целые числа

In [22]:
a = 11 # мы присвоили целочисленное значение нашей переменной
b = 5 # ну и вторую для порядка

Над целыми числами можно выполнять множество математических операций

In [23]:
a - b # вычитание
Out[23]:
6
In [24]:
a + b # сложение
Out[24]:
16
In [25]:
a * b # умножение
Out[25]:
55

С делением чуть посложнее, если хотим продолжить работать с целыми числами:

In [29]:
a // b # целочисленное деление
Out[29]:
2
In [30]:
a % b # остаток от целочисленного деления
Out[30]:
1
In [31]:
a ** b # возведение в степень
Out[31]:
161051
In [32]:
abs(-10) # взятие модуля
Out[32]:
10
In [1]:
2 ** 10
Out[1]:
1024

Числа с плавающей запятой

Числа с плавающей запятой в Python - способ хранения значений вещественных чисел

In [2]:
a = 10 / 2 # выполняем обычное деление
a
Out[2]:
5.0

Заметьте, что a поменяла свой тип, это одно из свойств Python - переменная может спокойно менять свой тип. Переменным с вещественным типом доступны те же операции

In [3]:
b = 5.2 
a - b
Out[3]:
-0.20000000000000018
In [40]:
a + b
Out[40]:
10.2
In [44]:
a * b
Out[44]:
26.0
In [45]:
a / b
Out[45]:
0.9615384615384615
In [46]:
a ** 0.5
Out[46]:
2.23606797749979
In [48]:
b // a # ТАК МОЖНО, НО НЕ НУЖНО!!!
Out[48]:
1.0
In [50]:
round(a ** 0.5, 2) # можем округлять переменную до нужного нам числа знаков после запятой
Out[50]:
2.24

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

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

In [6]:
x = 3
y = 5
z = x + y # создаём новую переменную z и присваиваем ей значение суммы x и y
z
Out[6]:
8
In [2]:
x = 3
y = 5
x = x + y # оператор + создаёт новый объект, равный сумме x и y, а оператор = присваивает новый объект переменной x
x
Out[2]:
8
In [3]:
x = 3
y = 5
x += y # оператор += обновляет переменную x, добавляя к её значению значение y. Эквивалент: x = x + y
x
Out[3]:
8

Другие операторы присваивания:

In [4]:
x, y, z = 3, 4, 5 #Оператор = может работать сразу с несколькими переменными и значениями! (обязательно с запятыми)
a, b, c = 1, 2, 3
In [7]:
x, y, z
Out[7]:
(3, 4, 5)
In [6]:
a
Out[6]:
1
In [8]:
z -= x # z = z - x
z
Out[8]:
2
In [4]:
y *= x # y = y * x
y
Out[4]:
12
In [5]:
x //= x # x = x // x
x
Out[5]:
1
In [6]:
c %= b # c = c % b
c
Out[6]:
1
In [9]:
b = 5
In [10]:
b **= b # b = b**b
b
Out[10]:
3125

А вот так в питоне запросто можно обменять значения двух переменных:

In [7]:
x = 3
y = 5

x, y = y, x #Правда ведь красиво?

x,y
Out[7]:
(5, 3)
In [12]:
x = 3
y = 5
x = y
y = x
x, y
Out[12]:
(5, 5)

Логический тип (bool)

Переменные логического типа могут хранить два значения - True и False

In [9]:
a = True
b = False
In [10]:
a and b # и
Out[10]:
False
In [3]:
a or b # или
Out[3]:
True
In [4]:
not a # отрицание
Out[4]:
False

Сравнение

Результаты сравнений переменных принимают значения типа bool.

В Python существуют следующие операторы сравнения:

  • == - проверка равенства
  • > - больше
  • < - меньше
  • >= - больше либо равно
  • <= - меньше либо равно
  • != - проверка НЕравенства

Смотрите сами:

In [19]:
5 == 7
Out[19]:
False
In [11]:
8 > 0
Out[11]:
True
In [12]:
-10 <= 9
Out[12]:
True
In [13]:
'Курица' == 'Птица'
Out[13]:
False
In [12]:
'делать мне' > 'Нечего' # Как может работать сравнение строк?
Out[12]:
True
In [13]:
'Делать мне' > 'Нечего' # Как может работать сравнение строк?
Out[13]:
False
In [16]:
'Лекция' != 'Семинар'
Out[16]:
True
In [17]:
3.0 == 3 # Python может даже сравнивать разные типы данных!
Out[17]:
True
In [14]:
3.0 == '42' # Python может даже сравнивать разные типы данных.. а вот из-за этого будут ошибки
Out[14]:
False
In [15]:
3 == "3"
Out[15]:
False
In [20]:
a = 0.3 + 0.3 + 0.3
a
Out[20]:
0.8999999999999999
In [21]:
0.9 == a
Out[21]:
False
In [22]:
eps = 0.00001
In [23]:
abs(0.9 - a) < eps
Out[23]:
True

Строки

Строковые переменные хранят строки..

In [24]:
a = "Hello, "
b = 'world'
a
Out[24]:
'Hello, '
In [23]:
a + b # сложение строк, называется "конкатенация"
Out[23]:
'Hello, world'
In [24]:
a - b # не, ну а вы что ожидали? 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-24-89323daed4c2> in <module>()
----> 1 a - b # не, ну а вы что ожидали?

TypeError: unsupported operand type(s) for -: 'str' and 'str'
In [14]:
"3" - "5"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-14-27f2e33fbfbd> in <module>()
----> 1 "3" - "5"

TypeError: unsupported operand type(s) for -: 'str' and 'str'
In [25]:
"3" + "5"
Out[25]:
'35'
In [25]:
a * b # однако кто ищет..

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-25-905fef375011> in <module>()
----> 1 a * b # однако кто ищет..

TypeError: can't multiply sequence by non-int of type 'str'
In [26]:
a * 5 # тот всегда найдет! нечасто такое нужно, правда
Out[26]:
'Hello, Hello, Hello, Hello, Hello, '
In [27]:
a[0] # у строки можно взять какой-то определенный символ, отсчет с нуля..
Out[27]:
'H'
In [28]:
a[0:5] # или несколько, называется "срез" [0, 5)
Out[28]:
'Hello'
In [20]:
a[0:3] + "p"
Out[20]:
'Help'
In [26]:
c = a + b
c
Out[26]:
'Hello, world'
Длина строки
In [27]:
len(c)
Out[27]:
12

Ввод

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

In [28]:
a = input() 
a

hello
Out[28]:
'hello'
In [22]:
a # теперь a хранит значение, которое ввел пользователь
Out[22]:
'hello'
In [29]:
a = input() # а если хотим получить число? 

55
In [24]:
a
Out[24]:
'55'
In [30]:
a = int(a) # преобразование того, что хранится в a к целочисленной переменной
a
Out[30]:
55
In [31]:
a = float(a) # преобразование того, что хранится в a к вещественной переменной
a
Out[31]:
55.0
In [32]:
str(a) # преобразование того, что хранится в a к строковой переменной
Out[32]:
'55.0'
In [25]:
str(10)
Out[25]:
'10'
In [34]:
a = int("100")
a = a * 5 
a
Out[34]:
500
In [35]:
a = int("100gg")
a = a * 5  
a

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-35-a916eca18e1e> in <module>()
----> 1 a = int("100gg")
      2 a = a * 5
      3 a

ValueError: invalid literal for int() with base 10: '100gg'

Вывод

Самый простой способ - использовать функцию print

In [89]:
a = 45
print(a)

45

А если хотим вывести две переменные? Можно так:

In [90]:
a = 10
b = "Hi"
print(a, b)

10 Hi

А можно так:

In [36]:
a = 10
b = "Hi"
print (str(a) + ", " + str(b))

10, Hi
In [36]:
c = str(a) + ", " + str(b)
print(c)

500, world
In [37]:
print(a, b, sep=', ')

500, world
In [31]:
10 + "hi"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-31-e65ee25badf4> in <module>()
----> 1 10 + "hi"

TypeError: unsupported operand type(s) for +: 'int' and 'str'
In [39]:
a = 10
b = "Hi"
c = "{}, {}".format(a, b)
print (c )
c = "{0}, {1}".format(a, b)
print (c )

10, Hi
10, Hi
In [ ]:
pi = 3.141592653589793
In [42]:
r = input()
r = int(r)
print(2 * pi * r)

10
62.83185307179586
In [43]:
r = input()
r = int(r)
print(round(2 * pi * r, 3))

10
62.832
In [44]:
answer = 10.0000000
print(round(answer, 3))

10.0
In [45]:
answer = 10.0000000
k = "{}".format(answer)
print(k)

10.0
In [46]:
answer = 10.0000000
k = "{:.3f}".format(answer)
print(k)

10.000

Конец

ach