Пишем на Python зная Powershell и наоборо

У системных, сетевых и DevOps администраторах есть несколько языков, которые они часто применяют в работе. Наиболее популярные языки, которые приходится применять в работе, это Powershell, Python и Bash. В этой статье будет рассмотрены преимущества и разница первых двух языков, а так же их сходство и различие в синтаксисе.

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

Основные различия языков и какой выбрать

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

Когда интерпретатор установлен в ОС мы можем вызвать его через терминал. Варианты, описанные ниже, актуальны для Windows.

Python - предустановлен на большинстве ОС Linux. Его так же можно установить и на Windows отдельно. В каких-то ОС он может быть запущен по названию 'python', а в каких-то с обязательным указанием версии. Например 'python3.11'. Скачать Python для Windows можно через официальный сайт https://www.python.org/.

Powershell - предустановлен на ОС Windows (версия 5.1). Версии Powershell от 6.0 устанавливаются отдельно и ее можно так же установить на Linux. После установки версии Powershell 6+, интерпретатор можно вызвать командой 'pwsh'. В статье рассматривается версия 5.1, но и для остальных версий изменения могут быть незначительными.

Основные преимущества Python

Репозиторий

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

Модуль - это код, который решает какую-то задачу. Приведу пример... Создавая почтовый клиент, вам может понадобиться протокол: pop3, imap или smtp. Написание протоколов с нуля займет время. Так же их придется поддерживать т.к. могут появиться какие-то ошибки. Часто такие задачи решаются за счет других разработчиков, которые уже реализовали такие решения, выложили в открытый доступ и поддерживают их.

Что бы найти нужный модуль для Python, чаще всего, используется репозиторий PyPi (в т.ч. одноименный сайт). Иногда такие модули ищутся и на GitHub.

В Powershell так же есть свой репозиторий, который подключен по умолчанию. Это PowershellGallery. Преимущество PyPi над PowershellGallery:

Если проект не обновлялся в PyPi (или на странице GitHub) год, то это может вызвать сомнение в том актуален ли он вообще.
В случае с Powershell, обычная ситуация, если проект не обновлялся 3-5 лет.
Если вам нужно будет создать, например, SMTP сервер, то в PyPi вы найдете множество модулей. В PowershellGallery вы можете вообще не найти нужной реализации.

Через Powershell можно так же использовать репозиторий NuGet, который имеет отношение к библиотеке .NET и больше предназначается для C#. Т.е. вы должны обладать очень хорошими знаниями что бы в этом разобраться или вовсе знать дополнительно C#.

Модули так же важны так как технологии меняются. Если когда-то использовался протокол HTTP 1.0, под который вы писали свою программу, а сейчас HTTP 3.0, то вам может потребоваться существенно переписать свою программу. Если есть модуль, который поддерживался все время, то вы временные затраты могут стать незначительными.

Синтаксис

Python является языком более интуитивной понятным. Это его преимущество не только над Powershell, но и над многими другими. Вам не нужно использовать разные виды скобок для создания функций, знак '$' для переменных и многое другое. Это будет видно по коду, который написан позже в статье.

В сообществе Python есть правила, которым следуют разработчики. Они прописаны в 'Дзен Python' (python zen) и PEP 8. Это общий подход к написанию программ и правила касающиеся конкретных участков кода.

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

Основные преимущества Powershell

Командлеты

Powershell, так же, называют языком командлетов (команд). Если в Python решение задачи в одну строку - это дурной тон (не в 100% случаев), то Powershell создан для этого.

Администрирование

Powershell хорошо подходит для приложений и задач, которые нуждаются в администрировании. В основном это приложения от Microsoft, но и другие крупные вендоры (например VMWare) создают свои модули и команды для администрирования.

У Powershell так же есть модуль DSC (desired state configuration), который по предназначению похож на Ansible. Задача модуля приводить операционные системы (Linux/Windows) и приложения к одному состоянию.

Синтаксис

Если Python имеет преимущество в синтаксисе при разработке, то Powershell в командах. Для примера синтаксис большинства программ которые используются в командной строке:

tar -xvf archive.tar.gz

При этом этот синтаксис может отличаться в каких-то программах и команда может писаться так:

tar -x -v -f archive.tar.gz
# или
tar /x /v /f archive.tar.gz

В Powershell похожая задача решается следующим образом:

Expand-Archive -Path "C:\a.zip" -DestinationPath "C:\a"

Команда длиннее, но интуитивно понятная. Скорость написания таких команд не велика т.к. используется автозаполнение. У команд Powershell так же есть разные сокращения, которые можно использовать что бы сделать команду короче.

Так же как и в Python, у Powershell есть свои правила создания командлетов. Например, первой частью команды является глагол (Get - получение, New-создание и т.д.), а второе - существительное (например Archive или Computer).

Командлеты - это те же функции. Пример их создания так же будет показан.

Создание комментариев

Комментарии помогают описать какую-то задачу. В обоих языках вы можете написать однострочный комментарий используя знак '#'.

# Комментарий Powershell

# Комментарий Python

Кроме однострочных есть и многострочные комментарии. Они различаются в обоих языках:

<# Многострочный
Powershell #>

'''Многострочный
Python'''

Переменные

Переменные - хранят ссылку на объект (значения). Объекты могут быть разных типов: строки, числа, списки и т.д..

При работе в Powershell - нам нужно использовать знак '$' перед названием переменной.

# переменная Powershell
$a = 123

# переменная Python
a = 123

У Python есть ряд ограничений при использовании символов в названии переменных. Например переменная не может состоять только из начинаться с них.

Вывод значений переменных в консоль

У обоих языков есть несколько способов вывести значение переменной на экран.

Когда используется консоль, это происходит автоматически при написании названия переменной:

# Powershell
$a = 123
$a

# Python
a = 123
a

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

# Powershell
Write-Host $a

# Python
print(a)

Для Powershel, часто, используется первый способ. Это связано с тем, что мы часто работаем в консоли интерпретатора и выполняем команды результат работы которых нам нужен в реальном времени. Например получение IP адреса узла.

В Python, часто, создаются отдельные программы для вывода значений на экран. Это может быть веб сайт, графический интерфейс (GUI) и т.д. Но функция 'print' один из лучших способов для тестирования и поиска ошибок в программах.

Подстановка переменных

Подстановка переменных (так же называется форматирование строки) используется, когда нам нужно вставить какое-то значение в строку. В обоих языках есть несколько способов сделать это. Один из способов, который наиболее похож в обоих языках, так и называется 'format'.

В обоих случаях, на примерах ниже, используются указатели в виде {0} и {1}, которые указывают куда вставлять указанные переменные. Мы не ограничены в количествах использования этих подстановок в обоих случаях.

# Powershell
$a = 123
$b = 789
$val = 'Some value: {0} {1}' -f $a,$b

# Python
a = 123
b = 789
val = 'Some value: {0} {1}'.format(a,b)

Есть и другие, более популярные, способы выполнить эту задачу. В Powershell, например, основное различие одинарных и двойных кавычек в том, что вторые могут использоваться для подстановки переменных. В Python же можно добавить букву 'f' перед кавычками и использовать скобки '{}' для переменных:

# Powershell
$a = 231
$b = 789
$val = "Значение: $b $a"

# Python
a = 231
b = 789
val = f'Значение: {b} {a}'

Типы данных

В обоих языках есть разные типы данных: строки, числа, массивы и т.д.. Основных типов данных, в Python меньше, чем в Powershell. Это связано с тем, что в Powershell мы можем использовать типы .NET. В Python мы так же можем их бесконечно расширять за счет пакетов, библиотек и модулей. В основном используются следующие типы данных:

Целые числа
Числа с плавающей точной
Строки
Булевы значения (true и false)
Nonetype object (Null/None)
Списки (массивы)
Словари (ассоциативные массивы или массивы ключ-значения)

Самые простые примеры - это создание первых четырех. Их создание почти одинаково в обоих языках:

# Powershell
$int_var = 231
$float_var = 2.2
$string_var = 'variable'
$bool_var = $True
$nonetype = $null

# Python
int_var = 231
float_var = 2.2
string_var = 'variable'
bool_var = True
nonetype = None

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

Неизменяемые массивы

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

В Powershell, такой тип массивов, так и называется 'array'. В Python, на такой тип массивов, больше всего похож кортеж (tuple).

# Powershell
$array = @(2,3,4)
# получение первого значения по индексу
$array[0]
# пересоздание массива с дополнительным значением
$array += 1

# Python
array = (2,3,4)
# получение значения по индексу
array[0]
# пересоздание массива с дополнительным значением
array += (1,)

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

Изменяемые массивы

Изменяемые массивы - имеют возможность добавления и удаления элемента. При этом мы работаем с одним и тем же массивом, а не новым (как в примере выше). Применяется чаще, но требует больше ресурсов.

В Python, такой тип массивов, называется список (list).

В Powershell он так же называется и списком (List), но имеет отличия. Мы должны дополнительно указывать тип объектов, который будет в нем хранится. Это может быть список, например, с числами, разными объектами (System.Object), строками и т.д.

# Powershell
$array = [System.Collections.Generic.List[System.Object]]@()
# добавляем элементы
$array.add('1')
$array.add('2')
$array
# вывод первого и последнего элемента по индексу
$array[0]
$array[-1]
# вырезаем последний элемент
$last_val_index = $array.Count - 1
$b = $array[$last_val_index]
$array.RemoveAt($last_val_index)

# Python
array = []
# добавляем элементы
array.append('1')
array.append('2')
array
# вывод первого и последнего элемента по индексу
array[0]
array[-1]
# вырезаем последний элемент
b = array.pop()

Первый элемент, в обоих языках, имеет индекс 0.

Метод 'pop' (приведенный в примере), который есть у Python, одновременно удаляет последнее значение из списка и привязывает это значение к переменной.

В Powershell нет аналогичного метода, поэтому это выполняется в несколько действий:

В Powershell мы можем получить последнее значение массива используя '-1', но не можем использовать '-1' в методе RemoteAt. Поэтому нам нужно узнать его длину используя Count и вычесть 1;
Записываем последнее значение получая его по индексу;
Удаляем значение из списка.

Ассоциативные массивы (словари и хэштаблицы)

Ассоциативные массивы используются, когда нам нужно что бы к какому-то ключу соответствовало одно или несколько значений. Они так же часто называются массивами "ключ-значение".

В Powershell есть два вида таких массивов. Это Hashtable и PSCustomObject. Основная разница между ними в том, что PSCustomObject чаще используется во взаимодействии с другими командами. Например использование PSCustomObject важно, когда нам нужно выполнить конвертацию в формат: JSON, CSV, XML. Так же его удобнее использовать, когда нам нужно хранить вложенную коллекцию (словарь в словаре). Я сам использовать PSCustomObject в основном.

В Python есть только один вид - это словарь (dict).

# Powershell - создание hashtable
$d = @{'Name'='Alex'; 'Age'=30;}
# получение значения по ключу
$d['Age']
# изменение значения по ключу
$d['Age'] = 32
# Добавление ключа
$d['Sex'] = 'Male'
# Получение всех ключей
$d.Keys


# Python
d = {'name': 'Alex', 'age': 30}
# получение значения по ключу
d['age']
# изменение значения по ключу
d['Age'] = 32
# Добавление ключа
d['Sex'] = 'Male'
# Получение всех ключей
d.keys()

Так же продемонстрирую, как создается и выводится PSCustomObject в сравнении с Hashtable.

# Powershell
$d = [PSCUstomObject]@{'Name'='Alex'; 'Age'=30;}
# получение значения по ключу
$d.Age
# изменение значения по ключу
$d.Age = 32
# Добавление ключа
Add-Member -InputObject $d -MemberType NoteProperty -Name 'Sex' -Value 'Male'
# Получение всех ключей
($d | Get-Member -MemberType Properties).Name

Преобразование типов данных

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

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

В Powershell, например, если вы сложите строку и число - результат будет строкой. В Python это приведет к ошибке.

# Powershell
$a  = '1'
$a + 1
[int]$a + 1

# Python
a = '1'
# будет ошибка
a + 1
# преобразуем строку в число
int(a) + 1

Такая ситуация не касается булевых типов, но касается Null/None.

# Powershell
$True + 1
$Null + 1

# Python
True + 1
# будет ошибка
None + 1

Есть более неочевидные моменты, если вы, в основном, используете Powershell. При попытке преобразования вещественного числа в целое, в Python, оно будет округлено в меньшую сторону. Что бы этого избежать используется round.

# Powershell
[int]1.4
[int]1.6

# Python
int(1.6)
int(1.4)
# правильное округление
round(1.4)
round(1.6)

Дополнительные операции над строками

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

# Powershell
$a = 'Hello World'
$a.substring(0,5) # получение среза
$a[0] # получение первого символа
$a.indexOf('W') # индекс символа W

# Python
a = 'Hello World'
a[0:5] # получение среза
a[0] # получение первого символа
a.index('W') # индекс символа W

Так же, часто, требуется заменить какие-то символы в тексте.

# Powershell
$a = 'Hello World'
$b = $a -replace 'World', 'Earth'

# Python
a = 'Hello World'
b = a.replace('World', 'Earth')

Вывод длины строки.

# Powershell
$a = 'Hello World'
$a.Length

# Python
a = 'Hello World'
len(a)

Преобразование строки в массив (используя пробел как разделитель).

# Powershell
$a = 'Hello World'
$a -split ' '

# Python
a = 'Hello World'
a.split(' ')

Обратный процесс - создание строки из массива.

# Powershell
$a = @('Hello', 'World')
$a -join ' '

# Python
a = ['Hello', 'World']
' '.join(a)

Ввод данных через командную строку

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

# Powershell
$a = Read-Host -Prompt 'Введите значение'
Write-Host ([int]$a + 1)

# Python
a = input('Введите значение: ')
print(int(a) + 1)

У Python так же популярен модуль sys.argv, который позволяет запускать скрипты используя ключи типа 'ping -source 1.1.1.1'. В Powershell это не требуется т.к. функции изначально имеют такую возможность (будет более понятно в статье ниже).

Логические операторы и операторы сравнения

Когда нам нужно проверить равны ли значения друг другу - мы должны использовать определенные операторы. Python используется более популярный способ, где:

'==' - равно ли одно значение другому;
'!=' - значение не равно;
'>=' - больше или равно;
'>' - больше;
'<' - меньше;
'<=' - меньше или равно.

В Powershell используется буквенное сокращение, которое можно понять следующим образом:

'-eq' - равно (equal);
'-ne' - не равно (not equal);
'-gt' - больше (greater than);
'-ge' - больше или равно (greater or equal);
'-lt' - меньше (less than);
'-le' - меньше или равно (less or equal).

В Powershell, перед каждым оператором, ставится знак '-'.

# Powershell
1 -ge 2
2 -ne 1
'1' -eq 1

# Python
1 > 2
2 != 1
'1' == 1

Есть и дополнительные логические операторы:

or - логическое или;
and - логическое и;
is - имеет разное значение в обоих языка. В случае Python - это проверка того, что значения находятся в одном участке памяти. В Powershell - что они относятся к одному типу;
in - так же разное значение. Для powershell только вхождение значение в массив. Для Python вхождение в массив и строку;
not - логическое "не".

В Powershell они так же дополняются знаком '-' в начале.

# Powershell
1 -ge 2 -or 2 -eq 2 # (1 больше либо равно 2) либо (2 равно 2)
-not (1 -in @(2,3)) # обратное значение результату (1 есть в массиве 2 и 3)
'1' -eq 1 -and $a -is [int] # (строка 1 равно числу 1) и (переменная (необъявленная раннее) является числом)


# Python
1>=2 or 2==2
1 not in [2,3]
a = 1
1==1 and a is not None
isinstance(a, int) # проверка соответствия типа (т.е. такое же значение как -is в PS)

В обоих языках есть дополнительные операторы, например, для битового сравнения, которые не рассматриваются.

Регистр

Python, в отличие от Powershell, регистро-зависимый язык. Это значит что буквы верхнего регистра имеют отличия от нижнего.

# Powershell
'A' -EQ 'a'

# Python
'A' == 'a'

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

В Powershell - для этого есть операторы, к которым добавляется буква 'c' (case-sensitive). Так же можно указать явно, что чувствительность к регистру не нужна используя 'i' (case-insensitive). Для примера:

eq - проверка равенства без учета регистра;
ieq - проверка равенства без учета регистра;
ceq - проверка равенства с учетом регистра;

Для python, если вам нужно сравнить символы без учета регистра, легче всего преобразовать их в один регистр. Это делается через upper() или lower(). Так же можно сделать и в PS.

# Powershell
'A' -ceq 'a' # сравнение с учетом регистра
'A'.ToLower() -eq 'a' # преобразование в нижний регистр и сравнение
'a'.ToUpper() -eq 'A' # преобразование в верхний регистр и сравнение


# Python
'a'.upper() == 'A'
'A'.lower() == 'a'

Регулярные выражения и wildcard

В Powershell есть возможность использования простых регулярных выражений (wildcard/подстановочные знаки) и расширенных.

Для простого варианта используется оператор 'like'. Знак '*', который обозначает один или несколько пропущенных символов, может ставиться многократно.

# Powershell
$a = 'MESSAGE LIKE THIS'
$a -clike 'L*KE*' # ищем только в начале строки с учетом регистра (c)
$a -clike '*L*KE*' # с учетом регистра везде

Простые и расширенные регулярные выражения, в Python, используются за счет импортирования модулей 'fnmatch' (wildcard) и 're' (регулярные выражения). Их не нужно устанавливать отдельно т.к. они есть в базовой версии. Есть еще одна особенность, что в Python можно искать подстроку в другой строке используя 'in'. Обычно используется либо 'in' либо регулярные выражения.

# Powershell
$a = 'SOME STRING'
$a -match '^S.*G$' # регулярные выражения

# Python
a = 'SOME STRING'
'SOME' in a # поиск подстроки в строке

import re # импорт модуля
re.search('^S.*G$', a) # регулярные выражения

import fnmatch
fnmatch.fnmatch(a, 'S*ME*') # wildcard
fnmatch.fnmatch(a, '*SOME')

Условные операторы

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

Есть три оператора:

if - если;
elseif для Powershell, elif для Python - так же если. Можно использовать несколько раз в одном блоке;
else - если остальные условия не подошли.

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

В Powershell более типичный способ работы с условиями - они оформляются в скобки. Условия прописываются в круглых скобках () сразу после объявления условия, а затем действия в фигурные {}.

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

# Powershell
$i = 1
if ($i -eq 0){
    Write-Host 'Значение равно 0'
} elseif (($i -ge 1) -and ($i -lt 2)){
    Write-Host 'Значение больше или равно 0 и меньше 2'
} elseif (($i -eq 3) -or ($i -eq 4)){
    Write-Host 'Значение равно 3 или 4'
} else {
    Write-Host 'Остальные случаи'
}

# Python
i = 1
if i == 0:
    print('Значение равно 0')
elif i >= 1 and i < 2:
    print('Значение больше или равно 0 и меньше 2')
elif i == 3 or i == 4:
    print('Значение равно 3 или 4')
else:
    print('Остальные случаи')

switch

Когда условий много - их можно сократить использовав такую конструкцию как switch. В Python такая возможность появилась достаточно недавно, в версии 3.10 (октябрь 2021).

# Powershell
$i = 1
switch ($i)
{
    1 {'Равно 1'}
    2 {'Равно 2'}
    3 {'Равно 3'}
    default {'Остальные случаи'}
}

# Python
i = 1
match i:
    case 1:
        print('Равно 1')
    case 2:
        print('Равно 2')
    case 3:
        print('Равно 3')
    case _:
        print('Остальные случаи')

Циклы

В Python есть 2 цикла, в Powershell больше 7. Чаще всего циклы используются для обхода массивов либо пока не будет выполнено какое-то условие.

Циклы for и foreach для обхода массивов

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

# Powershell
$array = @(1,2,3,4)
foreach ($i in $array){
   Write-Host $i
}

# Python
array = [1,2,3,4]
for i in array:
   print(i)

Использовать вариант с индексами можно в обоих языках. В каких-то случаях такой вариант будет работать быстрее.

Цикл с условием

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

# Powershell
$a = 0
While ($a -le 10){
    $a += 1
    if ($a -eq 9){
        Write-Host 'Остановили цикл через break'
        break
    }
}

# Python
a = 0
while a <= 10:
    a += 1
    if a == 9:
        print('Остановили цикл через break')
        break

У Powershell так же есть множество других циклов: 'foreach', метод 'ForEach()', командлет 'Foreach-Object', Do-While и т.д.. Подробнее о них можно почитать в статье "Как использовать циклы While и Foreach в Powershell Foreach на примерах". По моему опыту, варианты описанные выше, закрывают большинство задач.

Функции

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

Функция в Python объявляются через аббревиатуру 'def' (define), в Powershell через 'function'.

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

# Powershell
function Get-Number ($value1, $value2=3){
   return $value1 + $value2 # возвращаем сумму двух переменных
}
Get-Number -Value1 1 # вызов функции
get-number 1 2

# Python
def get_number(value1, value2=3):
   return value1 + value2  # возвращаем сумму двух переменных

get_number(value2=2, value1=1) # вызов функции
get_number(1)

В Powershell есть, так называемые, "расширенные функции". Такой тип функций используется, в основном, для создания командлетов или более крупных программ. Ряд возможностей, которые есть в расширенных функциях и которых нет в Python:

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

function Get-PlusPlus {
	param (
		[parameter(Mandatory=$true, Position=0)]
		[int]
		$item1,
        [parameter(Position=1)]
        [int]
        $item2,
        [parameter(Position=2)]
        [string]
        $item3
        )

    $summ = $item1 + $item2
    Write-Output $item3 $summ
	}

Get-PlusPlus 2 5 "Summ"

Подробнее о них можно почитать в статье "Как создавать команды и функции в Powershell вызывать их и передавать параметры".

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

Просмотр методов объекта и справки

Имея какой-то объект, например массив, вам может потребоваться узнать какими возможностями (методами) он обладает. Для этого можно использовать справку или посмотреть описание методов объекта.

# Powershell
# Просмотр возможностей объекта
1 | Get-Member

# Python
help(1) # получение справки по объекту
dir(1) # вывод списка методов

Просмотр типа объектов.

# Powershell
(1).GetType()

# Python
type(1)

У Powershell есть дополнительные команды для поиска команд и получению справок по ним:

# Powershell
# Поиск команды с глаголом Get и существительным IPsecRule
Get-Command -Verb Get -Noun *IPsecRule*
# Получение справки по команде
Get-Help Get-NetIPsecRule

Импорт и установка модулей

В Powershell 5.1 все установленные модули импортируются при запуске оболочки. Есть так же отдельная комманда для импорта. Я ее использую, когда есть сомнения в том что модуль установлен правильно и работает.

# Powershell
Import-Module -Name PSReadLine
Get-Command -Module PSReadline # вывод команд модуля

# Python
import os
os.getcwd() # использование метода модуля (вывод директории)

Установка модулей Python выполняется отдельной программой 'pip'. Обычно она устанавливается вместе с интерпретатором (для Windows). Для Linux, часто, требуется отдельная установка.

# Powershell
Install-Module sqlserver 

# Python
python.exe -m pip install requests # Windows
python3.11 -m pip install requests # Linux

Название модулей и пакетов для Python, а так же их документацию и описание, можно найти на https://pypi.org/ . Для Powershell - https://www.powershellgallery.com/ . Это репозитории, которые уже подключены к языкам.

Либо используется github. В случае Powershell так же можно использовать https://www.nuget.org/, но там модули .NET и у вас могут возникнуть сложности.

Сохранение и запуск скриптов

Скрипты Python сохраняются с расширением .py. Скрипты Powershell сохраняются с расширением .ps1.

Что бы запустить скрипт Powershell в Windows так же может потребоваться разрешить подобный запуск явно через команду 'Set-ExecutionPolicy'. Дело в том, что, по умолчанию, неподписанные скрипты запрещено выполнять. Режим 'Bypass' никак не блокирует такие скрипты и не выводит предупреждения.

Set-ExecutionPolicy -ExecutionPolicy Bypass

...

Рекомендую

Подписывайтесь на наш Telegram канал

Теги: #powershell #python

Учимся применять Python зная Powershell и наоборот