Функции с модулем как строить: Графики функций с модулем

import platform

x = platform.system()
print(x)

Попробуйте сами »

Использование функции dir()

Существует встроенная функция для вывода списка всех имен функций (или переменных). имена) в модуле. dir() функция:

Пример

Список всех определенных имен, принадлежащих платформенному модулю:

import platform

x = dir(platform)
print(x)

Попробуйте сами »

Примечание: Функция dir() может использоваться на всех модули, в том числе те, которые вы создаете сами.

Импорт из модуля

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

Пример

Модуль с именем mymodule имеет одну функцию и один словарь:

def приветствие(имя):
  print("Привет, " + имя)

человек1 = {
  "имя": "Джон",
  "возраст": 36,
  "страна": "Норвегия"
}

Пример

Импортировать только словарь person1 из модуля:

from mymodule import person1

print (person1["age"])

Пример запуска »

Примечание: При импорте с использованием из ключевое слово, не используйте имя модуля при обращении к элементам в модуле. Пример: person1["age"] , не mymodule.person1["возраст"]

Проверьте себя с помощью упражнений

Упражнение:

Каков правильный синтаксис для импорта модуля с именем "mymodule"?

 моймодуль
 

Начать упражнение

❮ Предыдущий Следующий ❯

ВЫБОР ЦВЕТА

Лучшие учебники

Основные каталожные номера

Основные примеры

ФОРУМ | О

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

Copyright 1999-2023 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.

Чтение и запись электронного текста

Эллисон Пэрриш

Эта глава посвящена функциям и модулям в Python. Функции – это удобный способ изолировать определенную часть функциональности вашей программы и сделать его многоразовым. Модули — это способ собрать ряд полезных функций в одном файле, который затем можно использовать в нескольких проектах и ​​делиться с другими программисты.

Мы уже широко использовали функции в наших программах; функции один из основных строительных блоков программирования на Python. Всякий раз, когда вы печатали что-то вроде len(x) или type(y) или даже random.choice([1, 2, 3]) , вы использовал функции. Просто эти функции предопределены Питон. В этой главе мы научимся писать собственные функции.

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

Случай с заглавной строкой

У меня проблема с Python, которая заключается в том, что строковые значения не имеют встроенного метод капитализации строк. Или, точнее, у него есть два метода, ни из которых делает именно то, что я хочу. Метод .title() делает каждое слово заглавным в строке:

>>> "это тест, Арлин".title() # каждое слово пишется с заглавной буквы
«Это испытание, Арлин»
 

Метод .capitalize() делает первую букву строки заглавной, но преобразует остальную часть строки в нижний регистр:

>>> "это тест, Арлин".capitalize() # преобразует оставшуюся часть строки в нижний регистр
«Это тест, Арлин»
 

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

>>> s = "это тест, Арлин"
>>> s[0].upper() + s[1:]
«Это испытание, Арлин»
 

Выражение s[0].upper() + s[1:] делает именно то, что я хочу — при условии, что строка, которую я хочу использовать, находится в переменной s . Так здорово, правда? Я понял это. Всякий раз, когда я хочу использовать строку с заглавной буквы, я могу просто вспомнить, что выражение, а затем перепишите выражение с соответствующей переменной.

Превратите это в функцию

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

>>> print ucfirst("это тест, Арлин")

(здесь я использую ucfirst как дань почтению почтенной Perl функция. )

«Невозможно», — скажете вы. «Только великая клика дизайнеров языка Python может работают такие хитрости. Для нас, простых смертных, это запрещено. Запрещенный! Я не буду терпеть эту ересь». Я не уверен, почему ты так говоришь. Вы действительно принимаете это программирование вещь серьезно.

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

 def your_function_name (параметры):
  заявления
  возвращаемое выражение
 

То есть определение функции состоит из:

• Ключевое слово def (сокращение от «define»), за которым следует имя вашей функции. Имя вашей функции может быть любым допустимым идентификатором Python.
• Пара круглых скобок после имени функции, которая представляет собой список из параметров к функции. (Мы поговорим об этом ниже.)
• Двоеточие после скобок.
• Возможно, некоторые операторы Python. (Эти операторы будут выполняться при вызове вашей функции.)
• Ключевое слово возвращает , за которым следует выражение. Это выражение — то, что функция будет оценивать с до при ее вызове.

Вот определение нашей функции ucfirst , которая вычисляет копию строка, которую вы ей передали, с заглавной буквой первого символа и остальными pf строка осталась одна:

 по умолчанию ucfirst(s):
  вернуть s[0].upper() + s[1:]
 

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

>>> def ucfirst(s):
... вернуть s[0].upper() + s[1:]
...
>>> ucfirst("это тест, Арлин")
«Это испытание, Арлин»
 

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

Когда Python начинает выполнять функцию, любые значения в скобках в вызов функции (в примере выше строка это тест, Arlene ) доступны функции как переменные, названные в функции скобки определения. В случае функции ucfirst значение это тест, Арлин теперь доступен как переменная s внутри функция.

Использование функций в программе

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

импорт системы
деф ucfirst(s):
  вернуть s[0].upper() + s[1:]
для строки в sys.stdin:
  строка = строка.strip()
  если длина (строка) > 0:
    напечатать ucfirst(строка)
  еще:
    линия печати
 

Программа: make_it_upper.py

Вот как это выглядит при использовании sea_rose.txt в качестве входных данных:

 $ python make_it_upper.py 
 Подробнее о параметрах 
 Функция может иметь более одного параметра. Напишем функцию, которая принимает
две строки в качестве параметров и возвращает первую половину одной добавленной строки
ко второй половине второй строки. Мы назовем эту функцию  половин  :
.
>>> определение половин (слева, справа):
... левая_часть = левая[:len(левая)/2]
... правая_часть = правая [длина (правая)/2:]
... вернуть левая_часть + правая_часть
...
>>> halfsies("Интерактивная Телекоммуникационная Программа", "Международный Блинный Дом")
«Интерактивная телекомуза блинов»
 
 В этом случае параметры  left  и  right  получают значения  Interactive
Телекоммуникационная программа  и  International House of Pancakes ,
соответственно. Внутри функции есть несколько операторов для получения
половины обеих строк, а затем функция  возвращает  результат
объединение этих двух строк вместе с оператором  + .
 Параметры функций, конечно, не обязательно должны быть строками: их можно
значения любого типа. Вот функция,  human_join  , который объединяет строки более «человеческим» способом (соединяет их запятой, а затем использует соединение между предпоследним и конечным элементами). Эта функция занимает два
параметры: список строк, которые нужно объединить, и «союз», который будет использоваться для их объединения.
>>> def human_join(части, соединение):
... если len(parts) == 1:
... вернуть запчасти[0]
... first_join = ', '.join(parts[:-1])
... return first_join + " " + соединение + " " + parts[-1]
...
>>> some_things = ["счеты", "колокольня", "кухонное искусство"]
>>> human_join(some_things, "и")
>>> human_join(["только это одно!"], "и")
'счеты, колокольня и кулинария'
'только это одно!'
 
 Здесь параметр  частей  функции должен быть списком. Этот
функция также сразу же использует оператор  if , чтобы проверить,
список имеет только один элемент; если это так, он просто возвращает один элемент
из списка без дальнейшей обработки. (Вы не можете объединить элементы из
в конце концов, список содержит менее двух элементов.)
 Упражнение: измените функцию  human_join  так, чтобы она принимала третий параметр,  oxford  , который определяет, будет ли функция использовать оксфордскую запятую.
 Значения по умолчанию для параметров 
 Одной из полезных функций Python является возможность иметь параметры функции с  значения по умолчанию  . Значение по умолчанию — это значение, присвоенное функциональному параметру.
если для этого параметра в вызове функции не передается значение. Вы можете установить
значение по умолчанию для параметра в определении функции, помещая
знак равенства (  =  ) после имени параметра, за которым следует желаемое значение
использовать по умолчанию.
 Например, вот функция, которая генерирует названия ресторанов в соответствии с
очень простой шаблон. Если вы не передаете параметры функции, она использует
значение «Дом» по умолчанию:
>>> ресторан определения (здание = "Дом"):
... отдача "Международная" + корпус + "Блины"
...
>>> restaurant() # возвращает "Международный блинный дом"
>>> restaurant("Лачуга") # возвращает "Международная Блинная Лачуга"
«Международный Дом Блинов»
«Международная блинная лачуга»
 
 Более чем один параметр может иметь значение по умолчанию. Давайте расширим пример
выше, чтобы сгенерировать названия ресторанов, содержащие как здание, так и продукт питания:
>>> def restaurant(building="Дом", foodtuff="Блины"):
... отдача "Международная" + строительная + "д" + продукты питания
...
>>> restaurant() # возвращает "Международный блинный дом"
>>> restaurant("Лачуга") # возвращает "Международная Блинная Лачуга"
>>> restaurant("Дуплекс", "Кастрюли") # и т.д.
«Международный Дом Блинов»
«Международная блинная лачуга»
«Международный дуплекс запеканок»
 
 Как показано в приведенном выше примере, если функция имеет более одного параметра
со значением по умолчанию параметры, переданные в вызове функции, назначаются
параметры в функции слева направо, т. е. во втором вызове выше,
значение  Лачуга  присваивается параметру  здание  , а не  продовольствие  (который вместо этого использует значение по умолчанию).
 Именованные параметры 
 Python имеет еще одну полезную функцию, связанную с функциями, которая заключается в том, что вы можете  укажите параметры по имени  в вашем вызове функции. Основное преимущество этого
заключается в том, что вам не нужно точно помнить, в каком порядке указывать параметры
для конкретной функции. (Это особенно полезно для функций с
много параметров.)
 Чтобы воспользоваться этой функцией, включите имя нужного параметра.
указать в функции  вызов  , за которым следует знак равенства (  =  ), за которым следует
значением, которое вы хотите передать для этого параметра. Для иллюстрации воспользуемся  ресторан  функция из предыдущего примера.
>>> def restaurant(building="Дом", foodtuff="Блины"):
... отдача "Международная" + строительная + "д" + продукты питания
...
>>> restaurant(building="Hangar") # Международный Ангар Блинов
>>> restaurant(foodstuff="Quinoa") # Международный Дом Киноа
>>> restaurant(foodstuff="Pineapple", building="Pyramid") # и т.д. и т.п.
«Международный ангар блинов»
«Международный дом киноа»
«Международная пирамида ананаса»
 
 Как видно из приведенного выше примера, использование именованных параметров имеет несколько
преимущества. Использование именованных параметров позволяет указать значения для конкретных
параметры, оставляя другие параметры с их значениями по умолчанию, даже если они
в порядке, который в противном случае воспрепятствовал бы этому. Именованные параметры также позволяют
для указания параметров функций не по порядку.
 Пример: генератор случайных названий ресторанов 
 Вот пример программы, использующей нашу простую функцию генератора названий ресторанов,
наш  функция human_join  и  ucfirst  совместно с  sowpods.txt  для
создать список случайно сгенерированных абсурдных названий ресторанов.
импорт системы
импортировать случайный
деф ucfirst(s):
  вернуть s[0].upper() + s[1:]
ресторан def(building="Дом", foodtuff="Блины"):
  возврат "Международный" + строительство + "д" + продукты питания
def human_join (части, соединение):
  если len(parts) == 1:
    возврат частей[0]
  first_join = ', '.join(части[:-1])
  return first_join + " " + соединение + " " + части[-1]
слова = список()
для строки в sys. stdin:
  строка = строка.strip()
  слова.append(ucfirst(строка))
для я в диапазоне (10):
  number_to_sample = случайный.randrange(1, 5)
  вещи = random.sample (слова, number_to_sample)
  напечатать ресторан (random.choice (слова), human_join (вещи, «и»))
 
 Программа: restaurant_forever.py
 Вот как это выглядит:
 $ python restaurant_forever.py 
 Итак! Как показано здесь, есть несколько преимуществ разбиения вашей программы на части.
в функции.
 Ваш код легче читать, особенно для тех, кто хочет читать ваш код
и просто понять суть этого, но не обязательно более глубокие детали. (Этот человек, вероятно, будет , вы , через неделю после того, как вы написали код.)  human_join  намного понятнее, чем выписывать всю процедуру внутри  на  цикл.
 Вы сократили количество повторений. Как только вы определили функцию, вы можете
используйте его в любом месте вашей программы, не вводя его снова.
 Вы изолировали места, где нужно внести изменения в программу. Если вы использовали
(например)  ресторан  функционирует более чем в одном месте в вашем коде, и вы
хотел изменить его, чтобы он возвращал строки в формате  International
[продукты питания] [здание]  (или что-то подобное), вам нужно будет внести это изменение в
только одно место.
 Модули 
 Модуль Python — это файл, содержащий одно или несколько определений функций.
Модули — это удобный способ объединения связанных функций, так что вы можете
легко повторно использовать их между проектами или делиться ими с другими программистами.
 Сделать модуль легко. Просто создайте файл с расширением  .py  и содержащий только  операторов импорта  и определений функций. (Вы также можете определить простой
переменные в модуле, если хотите.) Вот модуль с именем  restaurantutils  который содержит многие функции, над которыми мы работали в этой главе.
деф ucfirst(s):
  вернуть s[0].upper() + s[1:]
деф полуси (слева, справа):
  левая_часть = левая[:len(левая)/2]
  правая_часть = правая[длина(правая)/2:]
  вернуть левая_часть + правая_часть
ресторан def(building="Дом", foodtuff="Блины"):
  возврат "Международный" + строительство + "д" + продукты питания
def human_join (части, соединение):
  если len(parts) == 1:
    возврат частей[0]
  first_join = ', '.join(части[:-1])
  return first_join + " " + соединение + " " + части[-1]
 
 Программа: restaurantutils.py
 Обратите внимание, что если вы попытаетесь запустить этот файл, ничего не произойдет:
 $ python restaurantutils. py
 
 Это потому, что модуль на самом деле   ничего не делает — в нем нет кода.
там, что работает со стандартным вводом или выводит что-то на экран. Его
просто определения функций. Но как только мы создали файл, мы можем  использовать  те
функции в другой программе или в интерактивном интерпретаторе. Как? С использованием  импорт  ключевое слово:
>>> импортировать restaurantutils
>>> print restaurantutils.restaurant(building="Embassy", foodtuff="Ganache")
Международное посольство Ганаша
 
 Модуль, который вы создаете, ничем не отличается от любого другого модуля стандарта Python.
библиотеку или любой другой модуль, который вы установили с  pip  (с оговоркой
что он должен находиться в вашем текущем рабочем каталоге, чтобы  import  работал.)
Вы можете использовать  из X импортировать Y , чтобы получить только одну конкретную функцию из
модуль:
>>> от restaurantutils импортировать половинки
>>> print halfsies("Это были лучшие времена", "Это были худшие времена")
Это было самое тяжелое время
 
 И вы можете использовать свой модуль в других программах. Вот  restaurant_forever.py  переписан для использования функций, определенных в  restaurantutils  :
импорт системы
импортировать случайный
из restaurantutils импортировать ucfirst, restaurant, human_join
слова = список()
для строки в sys.stdin:
  строка = строка.strip()
  слова.append(ucfirst(строка))
для я в диапазоне (10):
  number_to_sample = случайный.randrange(1, 5)
  вещи = random.sample (слова, number_to_sample)
  напечатать ресторан (random.choice (слова), human_join (вещи, «и»))
 
 Программа: restaurant_forever_with_import.py
 
 Вывод должен быть практически таким же:
 $ python restaurant_forever_with_import.py 
 Модули, которые также являются программами 
 Иногда бывает полезно сделать модули, которые  и  функционируют как скрипты, поэтому
что вы можете  импортировать  их для использования содержащихся в них функций, но также
запускать их из командной строки. Например, допустим, у нас есть модуль
называется  ucfirst.py , в котором определена только одна функция,  ucfirst  функция из обсуждения выше.
деф ucfirst(s):
  вернуть s[0].upper() + s[1:]
 
 Программа: ucfirst.py
 Я могу использовать этот файл в интерактивном интерпретаторе так:
>>> из ucfirst импортировать ucfirst
>>> print ucfirst("давай вынесем это наружу, Бифф")
Давай вынесем это наружу, Бифф.
 
 Но было бы неплохо, если бы я мог использовать этот модуль напрямую в командной строке,
сделать что-то полезное — например, взять каждую строку стандартного ввода и
распечатайте его с заглавной первой буквы. С модулем как есть мы бы
необходимо создать отдельную программу Python, которая импортирует модуль, а затем
использовал функцию, которая является хлопот.
 К счастью, есть небольшая хитрость, которую вы можете использовать:  if __name__ == '__main__'  .
Если вы включите этот оператор  if  внутри вашего модуля, то любой код
в блоке  if  будет выполняться  только , когда ваш модуль запускается из
командной строки (а не если это  импорт  из интерактивного интерпретатора или
другая программа на Python). Давайте изменим файл  ucfirst.py , чтобы попробовать.
деф ucfirst(s):
  вернуть s[0].upper() + s[1:]
если __name__ == '__main__':
  импорт системы
  для строки в sys.stdin:
    строка = строка.strip()
    если длина (строка) > 0:
      напечатать ucfirst(строка)
    еще:
      линия печати
 
 Программа: ucfirst.py
 Теперь мы можем использовать модуль как отдельную программу, например:
 $ python ucfirst.py 
 … но работает и как модуль:
 
 >>> из ucfirst импортировать ucfirst
>>> print ucfirst("мои любимые имена Гертруда, Иосефат и Гэри")
Мои любимые имена — Гертруда, Иосефат и Гэри.
No related posts.