Функции и их аргументы в python 3

Итераторы

Python 3 позволяет создавать собственные итераторы, которые работают быстрее и более оптимально используют память.

Доступные итераторы библиотеки

• accumulate();
• chain();
• chain.from_iterable();
• compress();
• dropwhile();
• filterfalse();
• groupby();
• islice();
• starmap();
• takewhile();
• tee();
• zip_longest().

Все вышеперечисленные итераторы конечны. Но в модуле также представлено три бесконечных итератора. При их использовании не забываете про .

1. count();
2. cycle();
3. repeat().

Наконец в модуле есть трио комбинаторных генераторов;

1. combinations();
2. combinations_with_replacement();
3. product().

Таким образом, библиотека – это мощнейший инструмент для создания и использования итераторов, о котором студенты, изучающие C++, могут лишь мечтать!

Область видимость и глобальные переменные

Концепт области (scope) в Пайтон такой же, как и в большей части языков программирования. Область видимости указывает нам, когда и где переменная может быть использована. Если мы определяем переменные внутри функции, эти переменные могут быть использованы только внутри это функции. Когда функция заканчиваются, их можно больше не использовать, так как они находятся вне области видимости. Давайте взглянем на пример:

Python

def function_a():
a = 1
b = 2
return a+b

def function_b():
c = 3
return a+c

print( function_a() )
print( function_b() )

1 2 3 4 5 6 7 8 9 10 11 12

deffunction_a() a=1 b=2 returna+b deffunction_b() c=3 returna+c print(function_a()) print(function_b())

Если вы запустите этот код, вы получите ошибку:

Python

NameError: global name ‘a’ is not defined

1	NameErrorglobalname’a’isnotdefined

Это вызвано тем, что переменная определенна только внутри первой функции, но не во второй. Вы можете обойти этот момент, указав в Пайтоне, что переменная а – глобальная (global). Давайте взглянем на то, как это работает:

Python

def function_a():
global a
a = 1
b = 2
return a+b

def function_b():
c = 3
return a+c

print( function_a() )
print( function_b() )

1 2 3 4 5 6 7 8 9 10 11 12 13

deffunction_a() globala a=1 b=2 returna+b deffunction_b() c=3 returna+c print(function_a()) print(function_b())

Этот код работает, так как мы указали Пайтону сделать а – глобальной переменной, а это значит, что она работает где-либо в программе. Из этого вытекает, что это настолько же хорошая идея, насколько и плохая. Причина, по которой эта идея – плохая в том, что нам становится трудно сказать, когда и где переменная была определена. Другая проблема заключается в следующем: когда мы определяем «а» как глобальную в одном месте, мы можем случайно переопределить её значение в другом, что может вызвать логическую ошибку, которую не просто исправить.

Объем переменных

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

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

1. Глобальны.
2. Локальные.

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

Рассмотрим следующий пример.

Пример 1. Локальная переменная

def print_message():  
    message = "hello !! I am going to print a message." # the variable message is local to the function itself  
    print(message)  
print_message()  
print(message) # this will cause an error since a local variable cannot be accessible here.    

Выход:
Пример 2. Глобальная переменная

def calculate(*args):  
    sum=0  
    for arg in args:  
        sum = sum +arg  
    print("The sum is",sum)  
sum=0  
calculate(10,20,30) #60 will be printed as the sum  
print("Value of sum outside the function:",sum) # 0 will be printed  Output:

Выход:

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Определение и вызов простой функции в Python

Ниже приведен пример базовой функции. В ней нет оператора return, и никаких параметров она тоже не принимает.

Эта функция просто выводит hello world при каждом вызове.

def hello_world_func():
    print("hello world")

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

Вызывать функцию можно столько раз, сколько вам нужно.

Для вызова функции используется следующий синтаксис:

function_name(arguments)

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

Для вызова функции из нашего примера пишем следующий код:

hello_world_func()

# Результат:
# hello world 

Определение функции Python 3

Вы можете задать функции для реализации нужной вам функциональности. Вот простые правила для определения функции в Python.

• Ключевое слово для определения функции: def, за которым следуют имя функции и круглые скобки () с параметрами.
• Любые входные параметры или аргументы должны быть помещены в эти круглые скобки.
• В качестве первой команды может быть необязательная конструкция — строка документации функции (эта часть функции — пояснение зачем функция создана, очень рекомендуется использовать для облегчения понимания кода при работе в команде или при повторном возвращении к коду через длительный промежуток времени).
• Блок кода в каждой функции начинается с двоеточия и имеет отступ.
• Оператор return возвращает результат из функции. Оператор return без аргументов аналогичен return None. Функции всегда возвращают значение, хотя бы None.

1.2. Проверка нескольких условий.

Для проверки нескольких условий одновременно, используйте ключевое слово and. Чтобы выражение было истинно (True) оба условия должны быть истинны. В примере проверим возраст людей, чтобы был младше или в возрасте 30 лет.

>>> age_1 = 29
>>> age_2 = 20
>>> age_1 <= 30 and age_2 <= 30True

Если оба условия выполнены, то возвращается True.

Использование or для проверки нескольких условий.

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

>>> age_1 = 29
>>> age_2 = 20
>>> age_1 < 25 or age_2 < 25True

Передача аргументов функции

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

Python

def add(a, b):
return a + b

print( add(1, 2) ) # 3

1 2 3 4

defadd(a,b) returna+b print(add(1,2))# 3

Каждая функция выдает определенный результат. Если вы не указываете на выдачу конкретного результата, она, тем не менее, выдаст результат None (ничего). В нашем примере мы указали выдать результат a + b. Как вы видите, мы можем вызвать функцию путем передачи двух значений. Если вы передали недостаточно, или слишком много аргументов для данной функции, вы получите ошибку:

Python

add(1)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() takes exactly 2 arguments (1 given)

1 2 3 4 5

add(1) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()takes exactly2arguments(1given)

Вы также можете вызвать функцию, указав наименование аргументов:

Python

print( add(a = 2, b = 3) ) # 5

total = add(b = 4, a = 5)
print(total) # 9

1 2 3 4

print(add(a=2,b=3))# 5 total=add(b=4,a=5) print(total)# 9

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

Это стандартный путь вызова функции в случае, если вы хотите дальше использовать её результат.

Вы, возможно, подумаете: «А что, собственно, произойдет, если мы укажем аргументы, но они названы неправильно? Это сработает?» Давайте попробуем на примере:

Python

add(c=5, d=2)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() got an unexpected keyword argument ‘c’

1 2 3 4 5

add(c=5,d=2) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()got an unexpected keywordargument’c’

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

Функции являются объектами

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

states = 

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

Первая попытка могла бы выглядеть так:

import re # Модуль регулярных выражений

def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('', '', value) # удалить знаки препинания
        value = value.title()
        result.append(value)
    return result

states = 

states = clean_strings(states)

print(states)

Результат:

Другой подход, который иногда бывает полезен, – составить список операций, которые необходимо применить к набору строк:

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('', '', value)

def clean_strings(strings, ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result

clean_ops = 
states = 

states = clean_strings(states, clean_ops)

print(states)

Результат:

Подобный функциональный подход позволяет задать способ модификации строк на очень высоком уровне. Степень повторной используемости функции clean_strings определенно возросла!

Функции можно передавать в качестве аргументов другим функциям, например встроенной функции map, которая применяет переданную функцию к коллекции:

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('', '', value)

states = 

states = list(map(remove_punctuation, states))
states = list(map(str.strip, states))
states = list(map(str.title, states))

print(states)

Результат:

5.1.5. Побочный эффект¶

Побочный эффект (англ. Side Effect) — любые действия программы, изменяющие среду выполнения (англ. Execution Environment).

К побочным эффектам выполнения функции можно отнести:

• изменение данных в памяти;

• чтение/запись файла или устройства;

• ввод/вывод значений;

• самостоятельную реакцию на исключительные ситуации;

• и др.

Часто функции с побочным эффектом при вызове несколько раз с одними и теми же аргументами в качестве результата возвращают разные значения. Пример — стандартная функция генерации случайного числа.

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

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

Листинг 5.1.16 — Локализация кода с побочным эффектом в отдельные функции |

def heron(a, b, c):
    """Вернуть площадь треугольника по формуле Герона.

    Параметры:
        - a, b, c (float): стороны треугольника.

    Результат:
        - float: значение площади.
        - None: если треугольник не существует.
    """
    if not (a + b > c and a + c > b and b + c > a):
        return

    p = (a + b + c)  2
    return (p * (p - a) * (p - b) * (p - c))**0.5


def input_data():
    """Запросить стороны треугольника с клавиатуры.

    Результат:
        - tuple of float: (a, b, c).

    Побочный эффект!
    """
    return (float(x) for x in input('Введите стороны (a b c): ').split())

def print_res(res):
    """Вывести на экран 'res'.

    Параметры:
        - res (float): площадь треугольника.

    Побочный эффект!
    """
    if res
        print('S = {:.2f}'.format(res))
    else
        print('Треугольник не существует!')


a, b, c = input_data()
res = heron(a, b, c)
print_res(res)

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

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

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

Что такое функция?

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

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

Синтаксис функции

def name_functions(parameters):

"""

Описание функции, желательно всегда писать.
Что бы спустя время, вы могли понять, что делает эта функция

"""

    pass

Выше я привел пример определения функции, оно состоит из следующих элементов.

Ключевое слово def — определяет начало функции
Затем следует указать название функции (обратите внимание, нельзя называть функции зарезервированными именами Python)
Далее после название идут круглые скобки, в них мы передаем (аргументы функции). Они необязательны
Знак двоеточия, как и в циклах и в условиях, означает конец заголовка
Внутри функции желательно указать комментарии, что бы мы всегда знали, что делает эта функция
Далее 4 отступа, и создаем тело функции
return — необязательный оператор, который возвращает значения из функции

Пример функции

def hello(name):

"""

Эта функция приветствия.
Аргумент name передается в качестве параметра

"""

    print("Привет, "+ name + " Доброе утро")

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

Как вызвать функцию?

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

hello("Тимур")
Результат:

Привет, Тимур Доброе утро

Уловили суть? Мы в самом начале создали функции, в парметр функции передаем переменную name, и в print выводим переданный параметр. Затем, мы в любом месте нашей программы, можем написать имя нашей функции, передать ей параметр, и она выведет наше приветствие.  Откройте свой Pycharm, и введите приведенный ниже листинг кода, и вы увидите результат.

def hello(name):

""" Эта функция приветствия.

Аргумент name передается в качестве параметра """

    print("Привет, "+ name + " Доброе утро")

hello("Тимур")
Результат:

Привет, Тимур Доброе утро

return — оператор возврата

Оператор return возвращает значение, если отсутствует значение, или отсутствует сам оператор return — мы получаем None объект. None объект — это пустой объект, то есть нечего ему возвращать. Рассмотрим пример:

def value(number):

"""

Возвращаем значение введенного числа

"""

    if number >= 0:

        return number

    else:

        return -number

print(value(2))

print(value(-4))

Результат:

2

4

Время жизни переменных, и область работы переменных

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

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

def testfunc():

    x = 10

    print("Значение внутри функции: ", x)

x = 20

testfunc()

print("Значение переменной за пределами функции: ", x)

Результат:

Значение внутри функции: 10

Значение переменной за пределами функции: 20

На примере выше, мы видим что изначальное значение переменной x равно 10, при вызове функции мы присвоили переменной х значение 20. В результате, как мы видим одна и та же переменная выводит разное значение. Это объясняется тем, что переменная внутри функции, это локальная переменная для функции, соответственно внешняя переменная, даже если имеет такое же название, будет другой, так как области действия этих переменных разное.

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

Функции в Python для начинающих

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

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

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

Левая часть определяет функцию f, принимающую один параметр, x. А правая часть — это определение функции, которое использует переданный параметр x, чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.

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

Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:

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

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

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

Ключевое слово return используется для определения значения, которое функция возвращает при вызове.

Чтобы вызвать функцию в Python, мы используем синтаксис имя_функции (параметры, через, запятую).

Ниже описан вызов функции f из предыдущего примера с параметром 2.

Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print.

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

У функции может быть один параметр, несколько параметров или вообще их не быть. Чтобы определить функцию, не требующую параметров, оставьте круглые скобки пустыми.

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

Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None.

Как определять параметр со значением по умолчанию

Аргументы функции также могут иметь значения по умолчанию.

Чтобы аргумент функции имел дефолтное значение, нужно назначить это самое значение параметру при определении функции.

Делается это в формате .

Ранее мы видели, что можем определять функции со значением по умолчанию. Аргументы со значением по умолчанию называются аргументами по умолчанию.

def fave_language(language="Python"):
    print(f"My favorite  programming language is {language}!")
    
fave_language()
# Выводит в консоль "My favorite  programming language is Python!" 

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

В нашем примере, если не передан аргумент, значением всегда будет .

Значения по умолчанию при желании можно легко перезаписать, указав другое значение при вызове функции:

def fave_language(language="python"):
    print(f"My favorite  programming language is {language}!")
    
fave_language("Java")
# Выводит в консоль "My favorite  programming language is Java!" 

В функции может быть и несколько значений по умолчанию.

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

def personal_details(name="Jimmy",age=28,city="Berlin"):
    print(f"I am {name},{age} years old and live in {city}") 
    
# Мы можем вызывать эту функцию так:

personal_details()
# Результат:
# I am Jimmy,28 years old and live in Berlin

personal_details(age=30)
# I am Jimmy,30 years old and live in Berlin

personal_details(city="Athens",name="Ben",age=24)
# I am Ben,24 years old and live in Athens

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

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

def fave_language(name,language="Python"):
    print(f"My name is {name} and my favorite  programming language is {language}!")
    
fave_language("Dionysia")
# Результат:
#"My name is Dionysia and my favorite  programming language is Python!" 

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

Важно помнить, что в этом случае порядок опять же имеет значение. Сначала идут позиционные аргументы, а за ними — аргументы с дефолтными значениями

Вот такой код не сработал бы:

def fave_language(language="Python",name):
    print(f"My name is {name} and my favorite  programming language is {language}!")
    
fave_language("Dionysia")

# Результат:
 File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

От редакции Pythonist. Иногда нельзя предсказать, сколько аргументов получит функция. Чтобы обработать их, используются специальные конструкции и . Почитать подробнее можно в статье «Что такое *args и **kwargs?».

Применение lambda в sort, filter, map, reduce

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

>>> words = 
>>> sorted(words, key=lambda x: x)

В качестве индекса мы указали -1, обозначающий последний элемент строки (str), т.е. последней буквы.

Вторым применением lamda-функций является фильтрация различных структур данных. Например, необходимо исключить все четные элементы в списке. Для этого имеется встроенная в Python функция :

>>> nums = 
>>> even = filter(lambda x: x % 2 == 0, nums)
>>> list(even)

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

Третий пример – это использование lambda-функций в отображениях нового пространства. Требуется из заданного списка чисел получить список кубов этих чисел. С помощью  это будет выглядеть так:

>>> nums = 
>>> cubes = map(lambda x: x**3, nums)
>>> list(cubes)

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

Четвертый пример, где используется lambda-функции – это . Если необходимо получить из списка одно значение, то используется  из Python-модуля . Получение произведения чисел в списке будет выглядеть следующим образом:

>>> nums = 
>>> reduce(lambda x, y: x * y, nums)
5040

Алгоритм выполнения reduce можно записать как . Каждый момент итерирования сопровождается обновлением первого аргумента lambda-функции x, таким образом, становясь результатом произведения.

Стоит отметить, не всегда lambda-функции являются уместными из-за их неочевидного интерфейса. Например, и могут быть переписаны через List comprehension, о котором мы говорили тут. Как использовать lambda-функции и List comprehension в реальных проектах Data Science, вы узнаете на наших практических курсах по Python в лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве.

Смотреть расписание
Записаться на курс

Источники

Лямбда-выражения

Пару недель назад мы получили вопрос от читателя, который и сподвиг нас на написание данной статьи. Вопрос был такой: «Почему объект типа совсем не занимает места, а вот после применения функции к данному объекту в памяти оказываются все значения этого выражения?»

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

map_obj = map(lambda x: x*2, )
for i in map_obj:
    print(i)
# 2,4,6,8,10

import sys
print(sys.getsizeof(x))
# 48

print(list(x))
# 
print(sys.getsizeof(list(x)))
# 56

Узнайте, какие встроенные методы Python используются в строковых последовательностях

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

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

Давайте узнаем, какие используются чаще всего

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

Код для этой статьи можно взять из соответствующего репозитория Github Repository.

1. center( )

Метод выравнивает строку по центру. Выравнивание выполняется с помощью заданного символа (пробела по умолчанию).

Синтаксис

, где:

• length — это длина строки
• fillchar—это символ, задающий выравнивание

Пример

2. count( )

Метод возвращает счёт или число появлений в строке конкретного значения.

Синтаксис

, где:

• value — это подстрока, которая должна быть найдена в строке
• start — это начальное значение индекса в строке, где начинается поиск заданного значения
• end — это конечное значение индекса в строке, где завершается поиск заданного значения

Пример

3. find( )

Метод возвращает наименьшее значение индекса конкретной подстроки в строке. Если подстрока не найдена, возвращается -1.

Синтаксис

, где:

• value или подстрока, которая должна быть найдена в строке
• start — это начальное значение индекса в строке, где начинается поиск заданного значения
• end — это конечное значение индекса в строке, где завершается поиск заданного значения

Пример

Метод возвращает копию строки, преобразуя все заглавные буквы в строчные, и наоборот. 

Синтаксис

Пример

5. startswith( ) and endswith( )

Метод возвращает True, если строка начинается с заданного значения. В противном случае возвращает False.

С другой стороны, функция возвращает True, если строка заканчивается заданным значением. В противном случае возвращает False.

Синтаксис

• value — это искомая строка в строке
• start — это начальное значение индекса в строке, где начинается поиск заданного значения
• end — это конечное значение индекса в строке, где завершается поиск заданного значения

Пример

6. split( )

Метод возвращает список слов в строке, где разделителем по умолчанию является пробел.

Синтаксис

• sep: разделитель, используемый для разделения строки. Если не указано иное, разделителем по умолчанию является пробел
• maxsplit: обозначает количество разделений. Значение по умолчанию -1, что значит «все случаи»

Пример

7. Строка заглавными буквами

Синтаксис

Синтаксис

Синтаксис

Пример

8. ljust( ) и rjust( )

С помощью заданного символа (по умолчанию пробел) метод возвращает вариант выбранной строки с левым выравниванием. Метод rjust() выравнивает строку вправо.

Синтаксис

• length: длина строки, которая должна быть возвращена
• character: символ для заполнения незанятого пространства, по умолчанию являющийся пробелом

Пример

9. strip( )

Метод возвращает копию строки без первых и последних символов. Эти отсутствующие символы — по умолчанию пробелы.

Синтаксис

character: набор символов для удаления

• : удаляет символы с начала строки.
• : удаляет символы с конца строки.

10. zfill( )

Метод zfill() добавляет нули в начале строки. Длина возвращаемой строки зависит от заданной ширины.

Синтаксис

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

Пример

Заключение

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

• PEG парсеры и Python
• Популярные лайфхаки для Python
• Овладей Python, создавая реальные приложения. Часть 1

Перевод статьи Parul PandeyUseful String Method

Использования функции в цикле while

Функции могут вызываться в циклах while где угодно. Приведем пример цикла while, где у посетителя запрашивают имя и фамилию, а с помощью функции form_name возвращается отформатированное имя и фамилия с приветствием:

def form_name(first_name, last_name):
    «»»Возвращает отформатированное полное имя»»»
    full_name = «{first_name} {last_name}»
    return full_name.

while True:
    print(«Введите ‘x’ если хотите завершить программу»)
    first_name = («Введите ваше имя: «)
     first_name == ‘x’:
        break
    last_name = («Введите вашу фамилию: «)
     last_name == ‘x’:
        break
    formatted_name = form_name(first_name, last_name)
    print(«Добрый день {formatted_name}!»)

В данном примере в цикле whle запрашивается имя и фамилия и с помощью функции form_name возвращается отформатированное полное имя и записывается в переменную formatted_name. А затем уже с помощью функции  данные выводятся на экран. 

Строки

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

Операции со строками

string извлекает символ в позиции i

string извлекает последний символ

string извлекает символы в диапазоне от i до j

Методы работы сос строками

string.upper() преобразует строку в верхний регистр

String.lower() преобразует в строку в нижний регистр

string.count(x) подсчитывает, сколько раз появляется x

string.find(x) позиция первой строки вхождения x

string.replace(x, y) заменяет x на y

string.strip(x) удаляет как начальные, так и конечные символы x

string.join (List) объединяет список строк

Global vs. Local variables

Variables that are defined inside a function body have a local scope, and those defined outside have a global scope.

This means that local variables can be accessed only inside the function in which they are declared, whereas global variables can be accessed throughout the program body by all functions. When you call a function, the variables declared inside it are brought into scope. Following is a simple example −

#!/usr/bin/python3

total = 0   # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

When the above code is executed, it produces the following result −

Inside the function local total :  30
Outside the function global total :  0

Previous Page
Print Page

Next Page