4 концепции Python, которые необходимо понять

Вы ожидаете, что все будет работать определенным образом, когда пишите код. В основном так оно и есть. Но в python есть несколько случаев, в которых код работает не совсем так, как кажется на первый взгляд. При программировании всегда лучше знать, что делаешь, и быть уверенным, что код работает так, как задумано. В python есть несколько понятий, которые часто понимают неправильно. Давайте рассмотрим некоторые из них в этом блоге.
Изменяемые и неизменяемые типы данных
Существует два типа типов данных, основанных на допустимых в них изменениях. Давайте сначала разберемся, что это такое, а затем перейдем к рассмотрению уникального поведения, которое они демонстрируют.
Мутабельные: Когда вы определяете мутабельный тип данных, вы можете изменять их на месте. В python часто встречаются следующие примеры мутабельных типов данных:
- Списки,
- Словарь,
- Набор и т.д.
Рассмотрим пример:
myArray = [1,2,3,4]
myArray[1]= 0 # Inplace change is allowed
print(myArray) # Outputs [1,0,3,4]
Неизменяемый: Когда вы определяете неизменяемый тип данных, вы не можете изменить его значение на месте. В python часто встречаются следующие неизменяемые типы данных:
- Строка,
- Кортеж,
- Integer и т.д.
Рассмотрим пример, чтобы понять, что именно это означает.
myString = "Hello World!"
print(myString) # Prints Hello World
print(myString[0]) # Prints H
# myString[0] = "W" # Throws an error
myString = "Hi World!" # Works perfectly fine
print(myString) # Output: Hi World!
Теперь давайте разберемся в их поведении. Взгляните на приведенный ниже код:
Неизменность:
Посмотрите, как работает копирование в неизменяемом типе данных по сравнению с изменяемым типом.
myString = "Hello World"
string1 = myString
string1 = "Hi"
print(myString) # Outputs Hello World
print(string1) # Outputs Hi
Здесь, в приведенном выше коде, все работает, как и ожидалось. Но в случае с неизменяемыми типами данных все обстоит иначе. Для понимания приведенного ниже кода:
Мутабельность:
first = [1,2,3,4,5]
second = first
# Changing the second
second[0] = 6
second[1] = 9
print(first) # Outputs [6,9,3,4,5]
print(second) # Outputs [6,9,3,4,5]
В приведенном примере внимательно посмотрите, как изменилось значение первой переменной, когда мы обновляли только значение второй. В мутабельных типах данных при присвоении значения другой переменной сохраняется ссылка на эту исходную переменную. Поэтому, когда вы пытаетесь изменить значение второй, элементы данных, находящиеся в соответствующих позициях исходного массива, также будут затронуты. Следует быть особенно внимательным при передаче аргументов в функцию и следить за тем, чтобы они не оказывали побочных эффектов на другую логику программы.
Для создания независимой копии первого массива, не затрагивающей его в дальнейшем при попытке модификации второго, можно использовать что-то вроде second = first.copy().
Параметры и аргументы
Под параметрами и аргументами обычно понимается одно и то же, т.е. информация, передаваемая в функцию. Однако это не совсем одно и то же.
Параметры: Переменные, перечисленные в круглых скобках внутри определения функции.
Аргументы: Переменные, которые передаются в функцию при ее вызове.
# Defining a function
def function(parameter1, parameter2):
print("This is a dummy function")
# Calling/Invoking a function
function(argument1, argument2)
Позиционные аргументы
Использование позиционных аргументов позволяет передавать аргументы в функцию без необходимости определять ключевые слова рядом.
def func(x,y,z)
print(x,y,z)
func(1,2,3) # Output: 1 2 3
func(y=2,x=1, z=3) # Output: 1 2 3
Но если вы хотите использовать некоторые позиционные аргументы и другие аргументы ключевых слов, то сначала необходимо определить позиционные аргументы,
func(1,z=3,y=2) # Output 1 2 3
func(z=3, 1, y=2) # Throws an error
Аргументы по умолчанию
Это аргументы, которые объявляются в самом определении функции и являются необязательными.
def func(x,y,z=3):
print(x,y,z)
func(1,2) # Output: 1 2 3
func(1,2,9) # Output: 1 2 9
*Args и **Kwargs
Args и kwargs также являются понятиями, связанными с аргументами, но я выделил их в отдельное понятие, поскольку они выделяются из того, что было объяснено ранее.
*Args и **Kwargs используются для передачи в нашу функцию большего количества информации, чем указано в определении функции. Если мы не уверены в количестве информации, которая будет передана в нашу функцию, мы можем использовать args и kwargs.
*Args
Они используются для передачи произвольного количества данных без ключевого слова. Переданные значения сохраняются отдельно в кортеже, доступ к которому можно получить с помощью переменной с именем args.
def func(x,y, *args):
print(args)
func(1,2,10,20,30,40) # Output: (10 20 30 40)
Посмотрите внимательно, как на выходе получается tuple – неизменяемый тип данных, о котором мы говорили ранее.
**Kwargs
Это сокращенное название аргументов с ключевыми словами. В этом случае мы также можем передавать любое количество аргументов, а их значение сохраняется в словаре, на который можно ссылаться с помощью переменной с именем kwargs.
def func(x,y, **kwargs):
print(kwargs)
func(1,2,a=10,b=20)
# Output: {'a':10, 'b'=20}
Передача args/kwargs в вызове функции
Посмотрите на приведенный ниже пример кода:
def func(x,y=0):
print(x,y)
# args
func([1,2]) # Output: [1,2] 0
func(*[1,2]) # Output: 1 2
# kwargs
func(**{'x':1, 'y':2}) # Output: 1 2
Здесь в первом вызове функции список передается только как значение, соответствующее x. Во втором случае список декомпозируется и передается как отдельные аргументы ключевого слова.
*Args и **Kwargs – очень полезные понятия в python. Они позволяют вашим функциям быть гибкими к входным данным, которые они могут получить.
Если name == “main”:
Это похоже на использование функции main() в других программах, например в C. Это точка входа в программу. Когда мы запускаем файл напрямую, то выполняются только строки внутри этой функции, иначе он не запустится.
# file1.py
print("This is outside main")
if __name__=="__main__":
print("This is inside main")
Если вы импортируете file1.py в другой файл, то первая строка print(“This is outside main”) будет выполнена, но строка print(“This is inside main”) не будет выведена. Поскольку в реальной жизни мы используем много импортируемых модулей в программах на Python, вы должны знать об этой концепции.
Вот несколько концепций в Python, которые вы должны знать. Их понимание поможет вам стать лучшим разработчиком и гарантировать, что написанный вами код окажет желаемое влияние на конечный результат.