Справочник Puthon. Операторы Python книга. Статья в разработке

• Название: Статья в разработке
• Анкор: Справочник Puthon
• Дата: 06.12.2022
• Размер: 132.29 Kb.
• Имя файла: Операторы Python книга.docx
• Тип: Статья; #830403
• страница: 4 из 4

3. Функции языка Python

Функции – это многократно используемые фрагменты программы. Они позволяют дать имя определённому блоку команд с тем, чтобы впоследствии запускать этот блок по указанному имени в любом месте программы и сколь угодно много раз. Это называется вызовом функции. Мы уже использовали много встроенных функций, как то len и range.

Функция – это, пожалуй, наиболее важный строительный блок любой нетривиальной программы (на любом языке программирования), поэтому в этой главе мы рассмотрим различные аспекты функций.

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

def sayHello():

print('Привет, Мир!') # блок, принадлежащий функции

# Конец функции
sayHello() # вызов функции

sayHello() # ещё один вызов функции

3.1. Параметры функций

Функции могут принимать параметры, т.е. некоторые значения, передаваемые функции для того, чтобы она что-либо сделала с ними. Эти параметры похожи на переменные, за исключением того, что значение этих переменных указывается при вызове функции, и во время работы функции им уже присвоены их значения.

Параметры указываются в скобках при объявлении функции и разделяются запятыми. Аналогично мы передаём значения, когда вызываем функцию. Обратите внимание на терминологию: имена, указанные в объявлении функции, называются параметрами, тогда как значения, которые вы передаёте в функцию при её вызове, – аргументами.

def printMax(a, b):

if a > b:

print(a, 'максимально')

elif a == b:

print(a, 'равно', b)

else:

print(b, 'максимально')
printMax(3, 4) # прямая передача значений
x = 5

y = 7
printMax(x, y) # передача переменных в качестве аргументов

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

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

x= 50
def func(x):

print('x равен', x)

x = 2

print('Замена локального x на', x)
func(x)

print('x по-прежнему', x)

3.3. Зарезервированное слово “global”

Чтобы присвоить некоторое значение переменной, определённой на высшем уровне программы (т.е. не в какой-либо области видимости, как то функции или классы), необходимо указать Python, что её имя не локально, а глобально (global). Сделаем это при помощи зарезервированного слова global. Без применения зарезервированного слова global невозможно присвоить значение переменной, определённой за пределами функции.

Можно использовать уже существующие значения переменных, определённых за пределами функции (при условии, что внутри функции не было объявлено переменной с таким же именем). Однако, это не приветствуется, и его следует избегать, поскольку человеку, читающему текст программы, будет непонятно, где находится объявление переменной. Использование зарезервированного слова global достаточно ясно показывает, что переменная объявлена в самом внешнем блоке.

x = 50
def func():

global x
print('x равно', x)

x = 2

print('Заменяем глобальное значение x на', x)
func()

print('Значение x составляет', x)

3.4. Зарезервированное слово “nonlocal”

Мы увидели, как получать доступ к переменным в локальной и глобальной области видимости. Есть ещё один тип области видимости, называемый “нелокальной” (nonlocal) областью видимости, который представляет собой нечто среднее между первыми двумя. Нелокальные области видимости встречаются, когда вы определяете функции внутри функций.

Поскольку в Python всё является выполнимым кодом, вы можете определять функции где угодно.

def func_outer():

x = 2

print('x равно', x)
def func_inner():

nonlocal x

x = 5
func_inner()

print('Локальное x сменилось на', x)
func_outer()

3.5. Значения аргументов по умолчанию

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

Обратите внимание, что значение по умолчанию должно быть константой. Или точнее говоря, оно должно быть неизменным[1] – это объясняется подробнее в последующих главах. А пока запомните это.

def say(message, times = 1):

print(message * times)
say('Привет')

say('Мир', 5)

Предупреждение

Важно Значениями по умолчанию могут быть снабжены только параметры, находящиеся в конце списка параметров. Таким образом, в списке параметров функции параметр со значением по умолчанию не может предшествовать параметру без значения по умолчанию. Это связано с тем, что значения присваиваются параметрам в соответствии с их положением. Например, def func(a, b=5) допустимо, а def func(a=5, b) – не допустимо.

3.6. Ключевые аргументы

Если имеется некоторая функция с большим числом параметров, и при её вызове требуется указать только некоторые из них, значения этих параметров могут задаваться по их имени – это называется ключевые параметры. В этом случае для передачи аргументов функции используется имя (ключ) вместо позиции (как было до сих пор).

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

def func(a, b=5, c=10):

print('a равно', a, ', b равно', b, ', а c равно', c)
func(3, 7)

func(25, c=24)

func(c=50, a=100)

3.7. Переменное число параметров

Иногда бывает нужно определить функцию, способную принимать любое число параметров. Этого можно достичь при помощи звёздочек (сохраните как function_varargs.py):

def total(a=5, *numbers, **phonebook):

print('a', a)
#проход по всем элементам кортежа

for single_item in numbers:

print('single_item', single_item)
#проходповсемэлементамсловаря

for first_part, second_part in phonebook.items():

print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

3.8. Только ключевые параметры

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

def total(initial=5, *numbers, extra_number):

count = initial

for number in numbers:

count += number

count += extra_number

print(count)
total(10, 1, 2, 3, extra_number=50)

total(10, 1, 2, 3)

# Вызовет ошибку, поскольку мы не указали значение

# аргумента по умолчанию для 'extra_number'.

3.9. Оператор “return”

Оператор return используется для возврата[5] из функции, т.е. для прекращения её работы и выхода из неё. При этом можно также вернуть некоторое значение из функции.

#!/usr/bin/python

# Filename: func_return.py
def maximum(x, y):

if x > y:

return x

elif x == y:

return 'Числа равны.'

else:

return y
print(maximum(2, 3))

3.10. Строки документации

Python имеет остроумную особенность, называемую строками документации, обычно обозначаемую сокращённо docstrings. Это очень важный инструмент, которым вы обязательно должны пользоваться, поскольку он помогает лучше документировать программу и облегчает её понимание. Поразительно, но строку документации можно получить, например, из функции, даже во время выполнения программы!

def printMax(x, y):

'''Выводит максимальное из двух чисел.
Оба значения должны быть целыми числами.'''

x = int(x) # конвертируем в целые, если возможно

y = int(y)
if x > y:

print(x, 'наибольшее')

else:

print(y, 'наибольшее')
printMax(3, 5)

print(printMax.__doc__)

1. Модули

1.1. Файлы байткода .pyc

Импорт модуля – относительно дорогостоящее мероприятие, поэтому Python предпри- нимает некоторые трюки для ускорения этого процесса. Один из способов – создать байт-компилированные файлы (или байткод) с расширением .pyc, которые являются некой промежуточной формой, в которую Python переводит программу (помните раздел “Введение” о том, как работает Python?). Такой файл .pyc полезен при импорте модуля в следующий раз в другую программу – это произойдёт намного быстрее, поскольку зна- чительная часть обработки, требуемой при импорте модуля, будет уже проделана. Этот байткод также является платформо-независимым.

Примечание

Обычно файлы .pyc создаются в том же каталоге, где расположены и соот- ветствующие им файлы .py. Если Python не может получить доступ для записи файлов в этот каталог, файлы .pyc созданы не будут.

1.2. Оператор from … import …

Чтобы импортировать переменную argv прямо в программу и не писать всякий раз sys. при обращении к ней, можно воспользоваться выражением “from sys import argv”. Для импорта всех имён, использующихся в модуле sys, можно выполнить команду “from sys import *”. Это работает для любых модулей. В общем случае вам следует избегать использования этого оператора и использовать вместо этого оператор import, чтобы предотвратить конфликты имён и не затруднять чтение программы.

from math import *

n = input("Введите диапазон:- ") p = [2, 3]

count = 2

a=5

while (count < n):

b=0

for i in range(2,a):

if ( i <= sqrt(a)): if (a % i == 0):

print("a neprost",a)

b=1

else:

pass

if (b != 1):

print("a prost",a) p = p + [a]

count = count + 1

a=a+2

print p

1.3. Имя модуля – __name__

У каждого модуля есть имя, и команды в модуле могут узнать имя их модуля. Это полез- но, когда нужно знать, запущен ли модуль как самостоятельная программа или импорти- рован. Как уже упоминалось выше, когда модуль импортируется впервые, содержащийся в нём код исполняется. Мы можем воспользоваться этим для того, чтобы заставить мо- дуль вести себя по-разному в зависимости от того, используется ли он сам по себе или импортируется в другую программа. Этого можно достичь с применением атрибута мо- дуля под названием __name__.

if __name__ == '__main__':

print('Эта программа запущена сама по себе.')

else:

print('Меня импортировали в другой модуль.')

Как это работает:

В каждом модуле Python определено его имя – __name__ . Если оно равно „__main__“, это означает, что модуль запущен самостоятельно пользователем, и мы можем выполнить соответствующие действия.

1.4. Создание собственных модулей

Создать собственный модуль очень легко. Да вы всё время делали это! Ведь каждая про- грамма на Python также является и модулем. Необходимо лишь убедиться, что у неё уста- новлено расширение .py. Следующий пример объяснит это.

# mymodule.py
def sayhi():

print('Привет! Это говорит мой модуль.')

__version__ = '0.1'

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

# mymodule_demo.py
import mymodule
mymodule.sayhi()

print ('Версия', mymodule.__version__)

Примечание

Обратите внимание, что мы используем всё то же обозначение точкой для до- ступа к элементам модуля. Python повсеместно использует одно и то же обо- значение точкой, придавая ему таким образом характерный «Python-овый» вид и не вынуждая нас изучать всё новые и новые способы делать что-либо.

Вот версия, использующая синтаксис from..import

# mymodule_demo2.py
from mymodule import sayhi, __version__
sayhi()

print('Версия', __version__)

Примечание

Обратите внимание, что если в модуле, импортирующем данный модуль, уже было объ- явлено имя __version__, возникнет конфликт. Это весьма вероятно, так как объявлять версию любого модуля при помощи этого имени – общепринятая практика. Поэтому всегда рекомендуется отдавать предпочтение оператору import, хотя это и сделает вашу программу немного длиннее.

Вы могли бы также использовать from mymodule import *

Это импортирует все публичные имена, такие как sayhi, но не импортирует __version__, потому что оно начинается с двойного подчёркивания

 Previous