Функций, операторы, модули

Функции

Функции вызываются стандартно:

print("Привет!")

Могут принимать:

# Аргументы по порядку
foo(1, 2, "test")

# Аргументы по имени
bar(arg = 2, namedarg = "hello")

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

bar(1, 2, arg = 2, namedarg = "hello") # Правильно
bar(arg = 2, namedarg = "hello", 1, 2) # Ошибка

Возвращаемые значения

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

loo(24)

x = foo(24)

x,y,t = bar(42)

Функции как переменные

Функция в Python — переменная специального типа function. Объявление функции можно рассматривать как объявление одноименной переменной:

def foo(x, y):
    return x + y

bar = foo

bar(2, 3) # 5

def comcall(x, y, fun):
    return fun(x, y)

comcall(2, 3, foo) # 5

Некоторые встроенные функции

Функция	Назначение
`len(x)`	Длина перечисляемого `x`, например строки, возвращает `int`
`abs(x)`	Абсолютное значение числа `x`
`type(x)`	Тип данных `x`, возвращает специальный объект — тип
`print(x)`	Печать на экран `x`, возвращает `None`
`id(x)`	Возвращает уникальный идентификатор объекта

Операторы

Об операторах надо думать, как об упрощенной форме записи вызовов функций:

y = 1+2*3 # тоже, что и y = __add__(1,__mult__(2,3))

Операторы и вызовы функций можно свободно смешивать:

y = 2*len(x)+1

Многие операторы имеют сокращенную форму записи:

y = y + 1
y += 1

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

Оператор	Тип данных	Действие	Пример
+	bool, int, float	Сложение	2+5
+	str, bytes, list	Конкатенация	"a"+"b"
-	bool, int, float	Вычитание	2-5
*	bool, int, float	Умножение	2*5
*	str, bytes, list * int	Повторение	"a"*2
**	bool, int, float	Возведение в степень	2**5
/	bool, int, float	Действительное деление тип результата всегда `float`	2/5
//	bool, int, float	Целочисленное деление	2//5
%	bool, int, float	Остаток от деления	2%5
%	str, bytes	Операция подстановки для `str`	"hello %s" % "world"

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

Некоторые логические операторы

Логические операторы возвращают значения типа bool и используются, в основном, в качестве различных условий.

Оператор	Действие	Пример
not	Логическое НЕ для `bool`, возвращает `bool`	not x
and	Логическое И для `bool`, возвращает `bool`	x and y
or	Логическое ИЛИ для `bool`, возвращает `bool`	x or y
!=, >, <, >=, <=	Неравенство, возвращает `bool`, возвращает `bool`	x >= y
==	Равенство, возвращает `bool`	x == y
is	Тождество, возвращает `bool`	x is y
~	Побитовое НЕ для `int`, возвращает `int`	~ x
&	Побитовое И для `int`, возвращает `int`	x & y
\|	Побитовое ИЛИ для `int`, возвращает `int`	x \| y

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

Оператор	Действие	Пример
in, not in	Содержание, возвращает `bool`	x in data
[x]	Индексирование переменных перечислимых типов	data[x]
.	Обращение к полю или методу объекта или модуля	data.x, data.foo(2)

Подробнее: https://docs.python.org/3/reference/expressions.html

Модули

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

import math
math.cos(3) # Успешно: вызван метод ''cos'' модуля ''math''
cos(3) # Ошибка: метода ''cos'' неизвестен

from math import cos
cos(3) # Успешно: вызван метод ''cos'' модуля ''math''

import math as m
m.cos(3) # Успешно: вызван метод ''cos'' модуля ''math''

Собственные модули

Аналогично происходит импорт из одного файла в другой: если я хочу вызвать метод foo из файла myfuncs.py, то мне следует воспользоваться одним из следующих вариантов:

import myfuncs
myfuncs.foo()

from myfuncs import foo
foo()

Специальной командой from myfuncs import * можно импортировать все доступные методы из модуля, но это считается плохим стилем.

Приведение типов

Типы автоматически не приводятся. Но типы int, float и bool можно смешивать в арифметических выражениях. Результат будет определяться наиболее ёмким типом (float > int > bool).

	Исходный тип — переменная `x`
Целевой тип	`bool`	`int`	`float`	`str`	`bytes`
`bool`		`bool(x)`	`bool(x)`	`bool(x)`	`bool(x)`
`int`	`int(x)`		`round(x)`, `math.ceil(x)`, `math.trunc(x)`	`int(x)`	`struct.unpack(fmt,x)`
`float`	`float(x)`	`float(x)`		`float(x)`	`struct.unpack(fmt,x)`
`str`	`str(x)`	`str(x)`	`str(x)`		`x.decode(encoding)`
`bytes`	`x.to_bytes(length, order), struct.pack(fmt, x)`	`x.to_bytes(length, order), struct.pack(fmt,x)`	`struct.pack(fmt,x)`	`x.encode(encoding)`

Используются модули math и struct.

Функция print

print() — печатает текст в консоли. Принимает произвольное число аргументов, производного типа, если аргумент не строка, то у него вызывается метод __str__(), а при отсутствии потом __repr__() (есть у всех переменных всех типов). Таким образом print так или иначе выведет на печать переменную любого типа.

a = 25
print("тест:", a , "-", 3.158)

#тест: 25 - 3.158
#

Дополнительные аргументы: sep — разделитель, по умолчанию пробел, end — конец строки, по умолчанию \n.

a = 25
print("тест:", a , "-", 3.158, sep=";", end="\nконец.\n")

тест:;25;-;3.158
конец.