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, которые вы должны знать. Их понимание поможет вам стать лучшим разработчиком и гарантировать, что написанный вами код окажет желаемое влияние на конечный результат.

+1
2
+1
3
+1
0
+1
0
+1
0

Ответить

Ваш адрес email не будет опубликован. Обязательные поля помечены *