Написание скриптов для windows на python

Введение в скрипты на Python

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

Картинка с сайта: sky.pro

Установка и настройка среды разработки

Прежде чем начать писать скрипты, необходимо установить Python и настроить среду разработки. Следуйте этим шагам:

1. Скачайте и установите Python:
   – Перейдите на официальный сайт python.org.
   – Скачайте последнюю версию Python для вашей операционной системы. На сайте есть версии для Windows, macOS и Linux.
   – Следуйте инструкциям по установке, которые включают в себя добавление Python в системный PATH, что позволит вам запускать Python из командной строки.

2. Установите текстовый редактор или IDE:
   – Рекомендуемые редакторы: Visual Studio Code, PyCharm, Sublime Text. Каждый из этих редакторов имеет свои преимущества. Visual Studio Code — это бесплатный и мощный редактор с множеством расширений. PyCharm — это профессиональная IDE, которая предлагает множество инструментов для разработки на Python. Sublime Text — это легкий и быстрый редактор с поддержкой множества языков программирования.
   – Установите выбранный редактор и настройте его для работы с Python. Например, в Visual Studio Code можно установить расширение Python, которое добавляет поддержку синтаксиса, отладку и другие полезные функции.

3. Проверьте установку Python:
   – Откройте терминал (или командную строку).
   – Введите команду python --version или python3 --version, в зависимости от вашей операционной системы.
   – Убедитесь, что установлена последняя версия Python. Если команда возвращает ошибку, возможно, Python не был добавлен в системный PATH, и вам нужно будет сделать это вручную.

Основы написания скриптов на Python

Теперь, когда у вас установлена среда разработки, можно приступить к написанию первого скрипта. Рассмотрим основные элементы скрипта на Python и познакомимся с базовыми конструкциями языка.

Создание первого скрипта

1. Откройте текстовый редактор.
2. Создайте новый файл и сохраните его с расширением .py (например, hello_world.py). Расширение .py указывает на то, что файл содержит код на Python.
3. Напишите следующий код:

1. Сохраните файл. Теперь у вас есть первый скрипт на Python, который выводит строку «Hello, World!» на экран.

Основные конструкции языка

Python использует простую и понятную синтаксическую структуру. Вот несколько основных конструкций, которые вам нужно знать:

• Переменные и типы данных:

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

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

Условные операторы позволяют выполнять разные блоки кода в зависимости от условий. В примере выше, если переменная age больше 18, будет выведено «Adult», иначе — «Minor».

• Циклы:

Циклы позволяют выполнять блок кода несколько раз. В данном примере цикл for выполняется 5 раз, выводя значения от 0 до 4.

• Функции:

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

Запуск и отладка скриптов

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

Запуск скрипта

1. Откройте терминал.
2. Перейдите в директорию, где сохранен ваш скрипт:

1. Запустите скрипт:

Если все сделано правильно, вы увидите вывод «Hello, World!» в терминале. Это означает, что ваш скрипт успешно выполнен.

Отладка скриптов

Отладка помогает найти и исправить ошибки в коде. Вот несколько способов отладки:

• Используйте встроенные функции:

Добавление print-заявлений в код позволяет отслеживать значения переменных и выполнение программы. Это простой, но эффективный способ отладки.

• Используйте отладчик:
  – В Visual Studio Code и PyCharm есть встроенные отладчики, которые позволяют пошагово выполнять код и проверять значения переменных. Вы можете устанавливать точки останова (breakpoints), чтобы остановить выполнение программы в определенных местах и исследовать состояние программы.

Примеры полезных скриптов и их применение

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

Скрипт для переименования файлов

Этот скрипт переименовывает все файлы в указанной директории, добавляя префикс к их именам:

Скрипт использует модуль os для работы с файловой системой. Функция rename_files принимает два аргумента: путь к директории и префикс, который будет добавлен к именам файлов. Скрипт перебирает все файлы в директории и переименовывает их, добавляя префикс.

Скрипт для отправки email

Этот скрипт отправляет email с использованием библиотеки smtplib:

Этот скрипт использует библиотеку smtplib для отправки email. Функция send_email принимает три аргумента: тему письма, тело письма и адрес получателя. Скрипт создает объект MIMEText для тела письма и устанавливает необходимые заголовки. Затем он подключается к SMTP-серверу и отправляет письмо.

Скрипт для парсинга веб-страниц

Этот скрипт извлекает заголовки статей с веб-страницы с использованием библиотеки BeautifulSoup:

Скрипт использует библиотеку requests для загрузки веб-страницы и библиотеку BeautifulSoup для парсинга HTML-кода. Функция fetch_article_titles принимает URL страницы, загружает ее содержимое и извлекает заголовки статей, заключенные в теги <h2>. Затем она возвращает список заголовков.

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

Читайте также

Время на прочтение10 мин

Количество просмотров81K

Python — это язык программирования, который отлично подходит для разработки самостоятельных скриптов. Для того чтобы добиться с помощью подобного скрипта желаемого результата, нужно написать несколько десятков или сотен строк кода. А после того, как дело сделано, можно просто забыть о написанном коде и перейти к решению следующей задачи.

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

Картинка с сайта: habr.com

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

Автор материала, перевод которого мы сегодня публикуем, собирается продемонстрировать подобное «превращение» на примере классической задачи «Fizz Buzz Test». Эта задача заключается в том, чтобы вывести список чисел от 1 до 100, заменив некоторые из них особыми строками. Так, если число кратно 3 — вместо него нужно вывести строку Fizz, если число кратно 5 — строку Buzz, а если соблюдаются оба этих условия — FizzBuzz.

Исходный код

Вот исходный код Python-скрипта, который позволяет решить задачу:

import sys
for n in range(int(sys.argv[1]), int(sys.argv[2])):
    if n % 3 == 0 and n % 5 == 0:
        print("fizzbuzz")
    elif n % 3 == 0:
        print("fizz")
    elif n % 5 == 0:
        print("buzz")
    else:
        print(n)

Поговорим о том, как его улучшить.

Документация

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

#!/usr/bin/env python3

"""Simple fizzbuzz generator.

This script prints out a sequence of numbers from a provided range
with the following restrictions:

 - if the number is divisible by 3, then print out "fizz",
 - if the number is divisible by 5, then print out "buzz",
 - if the number is divisible by 3 and 5, then print out "fizzbuzz".
"""

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

Аргументы командной строки

Следующей задачей по улучшению скрипта станет замена значений, жёстко заданных в коде, на документированные значения, передаваемые скрипту через аргументы командной строки. Реализовать это можно с использованием модуля argparse. В нашем примере мы предлагаем пользователю указать диапазон чисел и указать значения для «fizz» и «buzz», используемые при проверке чисел из указанного диапазона.

import argparse
import sys


class CustomFormatter(argparse.RawDescriptionHelpFormatter,
                      argparse.ArgumentDefaultsHelpFormatter):
    pass


def parse_args(args=sys.argv[1:]):
    """Parse arguments."""
    parser = argparse.ArgumentParser(
        description=sys.modules[__name__].__doc__,
        formatter_class=CustomFormatter)

    g = parser.add_argument_group("fizzbuzz settings")
    g.add_argument("--fizz", metavar="N",
                   default=3,
                   type=int,
                   help="Modulo value for fizz")
    g.add_argument("--buzz", metavar="N",
                   default=5,
                   type=int,
                   help="Modulo value for buzz")

    parser.add_argument("start", type=int, help="Start value")
    parser.add_argument("end", type=int, help="End value")

    return parser.parse_args(args)


options = parse_args()
for n in range(options.start, options.end + 1):
    # ...

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

$ ./fizzbuzz.py --help
usage: fizzbuzz.py [-h] [--fizz N] [--buzz N] start end

Simple fizzbuzz generator.

This script prints out a sequence of numbers from a provided range
with the following restrictions:

 - if the number is divisible by 3, then print out "fizz",
 - if the number is divisible by 5, then print out "buzz",
 - if the number is divisible by 3 and 5, then print out "fizzbuzz".

positional arguments:
  start         Start value
  end           End value

optional arguments:
  -h, --help    show this help message and exit

fizzbuzz settings:
  --fizz N      Modulo value for fizz (default: 3)
  --buzz N      Modulo value for buzz (default: 5)

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

Логирование

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

import logging
import logging.handlers
import os
import sys

logger = logging.getLogger(os.path.splitext(os.path.basename(sys.argv[0]))[0])

Затем сделаем так, чтобы подробностью сведений, выводимых при логировании, можно было бы управлять. Так, команда logger.debug() должна выводить что-то только в том случае, если скрипт запускают с ключом --debug. Если же скрипт запускают с ключом --silent — скрипт не должен выводить ничего кроме сообщений об исключениях. Для реализации этих возможностей добавим в parse_args() следующий код:

# В parse_args()
g = parser.add_mutually_exclusive_group()
g.add_argument("--debug", "-d", action="store_true",
               default=False,
               help="enable debugging")
g.add_argument("--silent", "-s", action="store_true",
               default=False,
               help="don't log to console")

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

def setup_logging(options):
    """Configure logging."""
    root = logging.getLogger("")
    root.setLevel(logging.WARNING)
    logger.setLevel(options.debug and logging.DEBUG or logging.INFO)
    if not options.silent:
        ch = logging.StreamHandler()
        ch.setFormatter(logging.Formatter(
            "%(levelname)s[%(name)s] %(message)s"))
        root.addHandler(ch)

Основной код скрипта при этом изменится так:

if __name__ == "__main__":
    options = parse_args()
    setup_logging(options)

    try:
        logger.debug("compute fizzbuzz from {} to {}".format(options.start,
                                                             options.end))
        for n in range(options.start, options.end + 1):
            # ..
    except Exception as e:
        logger.exception("%s", e)
        sys.exit(1)
    sys.exit(0)

Если скрипт планируется запускать без прямого участия пользователя, например, с помощью crontab, можно сделать так, чтобы его вывод поступал бы в syslog:

def setup_logging(options):
    """Configure logging."""
    root = logging.getLogger("")
    root.setLevel(logging.WARNING)
    logger.setLevel(options.debug and logging.DEBUG or logging.INFO)
    if not options.silent:
        if not sys.stderr.isatty():
            facility = logging.handlers.SysLogHandler.LOG_DAEMON
            sh = logging.handlers.SysLogHandler(address='/dev/log',
                                                facility=facility)
            sh.setFormatter(logging.Formatter(
                "{0}[{1}]: %(message)s".format(
                    logger.name,
                    os.getpid())))
            root.addHandler(sh)
        else:
            ch = logging.StreamHandler()
            ch.setFormatter(logging.Formatter(
                "%(levelname)s[%(name)s] %(message)s"))
            root.addHandler(ch)

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

$ ./fizzbuzz.py --debug 1 3
DEBUG[fizzbuzz] compute fizzbuzz from 1 to 3
1
2
fizz

Тесты

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

def fizzbuzz(n, fizz, buzz):
    """Compute fizzbuzz nth item given modulo values for fizz and buzz.

    >>> fizzbuzz(5, fizz=3, buzz=5)
    'buzz'
    >>> fizzbuzz(3, fizz=3, buzz=5)
    'fizz'
    >>> fizzbuzz(15, fizz=3, buzz=5)
    'fizzbuzz'
    >>> fizzbuzz(4, fizz=3, buzz=5)
    4
    >>> fizzbuzz(4, fizz=4, buzz=6)
    'fizz'

    """
    if n % fizz == 0 and n % buzz == 0:
        return "fizzbuzz"
    if n % fizz == 0:
        return "fizz"
    if n % buzz == 0:
        return "buzz"
    return n

Проверить правильность работы функции можно с помощью pytest:

$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 1 item

fizzbuzz.py::fizzbuzz.fizzbuzz PASSED                                  [100%]

========================== 1 passed in 0.05 seconds ==========================

Для того чтобы всё это заработало, нужно, чтобы после имени скрипта шло бы расширение .py. Мне не нравится добавлять расширения к именам скриптов: язык — это лишь техническая деталь, которую не нужно демонстрировать пользователю. Однако возникает такое ощущение, что оснащение имени скрипта расширением — это самый простой способ позволить системам для запуска тестов, вроде pytest, находить тесты, включённые в код.

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

$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py -k fizzbuzz.fizzbuzz
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 1 item

fizzbuzz.py::fizzbuzz.fizzbuzz FAILED                                  [100%]

================================== FAILURES ==================================
________________________ [doctest] fizzbuzz.fizzbuzz _________________________
100
101     >>> fizzbuzz(5, fizz=3, buzz=5)
102     'buzz'
103     >>> fizzbuzz(3, fizz=3, buzz=5)
104     'fizz'
105     >>> fizzbuzz(15, fizz=3, buzz=5)
106     'fizzbuzz'
107     >>> fizzbuzz(4, fizz=3, buzz=5)
108     4
109     >>> fizzbuzz(4, fizz=4, buzz=6)
Expected:
    fizz
Got:
    4

/home/bernat/code/perso/python-script/fizzbuzz.py:109: DocTestFailure
========================== 1 failed in 0.02 seconds ==========================

Модульные тесты можно писать и в виде обычного кода. Представим, что нам нужно протестировать следующую функцию:

def main(options):
    """Compute a fizzbuzz set of strings and return them as an array."""
    logger.debug("compute fizzbuzz from {} to {}".format(options.start,
                                                         options.end))
    return [str(fizzbuzz(i, options.fizz, options.buzz))
            for i in range(options.start, options.end+1)]

В конце скрипта добавим следующие модульные тесты, использующие возможности pytest по использованию параметризованных тестовых функций:

# Модульные тесты
import pytest                   # noqa: E402
import shlex                    # noqa: E402


@pytest.mark.parametrize("args, expected", [
    ("0 0", ["fizzbuzz"]),
    ("3 5", ["fizz", "4", "buzz"]),
    ("9 12", ["fizz", "buzz", "11", "fizz"]),
    ("14 17", ["14", "fizzbuzz", "16", "17"]),
    ("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),
    ("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]),
])
def test_main(args, expected):
    options = parse_args(shlex.split(args))
    options.debug = True
    options.silent = True
    setup_logging(options)
    assert main(options) == expected

Обратите внимание на то, что, так как код скрипта завершается вызовом sys.exit(), при его обычном вызове тесты выполняться не будут. Благодаря этому pytest для запуска скрипта не нужен.

Тестовая функция будет вызвана по одному разу для каждой группы параметров. Сущность args используется в качестве входных данных для функции parse_args(). Благодаря этому механизму мы получаем то, что нужно передать функции main(). Сущность expected сравнивается с тем, что выдаёт main(). Вот что сообщит нам pytest в том случае, если всё работает так, как ожидается:

$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 7 items

fizzbuzz.py::fizzbuzz.fizzbuzz PASSED                                  [ 14%]
fizzbuzz.py::test_main[0 0-expected0] PASSED                           [ 28%]
fizzbuzz.py::test_main[3 5-expected1] PASSED                           [ 42%]
fizzbuzz.py::test_main[9 12-expected2] PASSED                          [ 57%]
fizzbuzz.py::test_main[14 17-expected3] PASSED                         [ 71%]
fizzbuzz.py::test_main[14 17 --fizz=2-expected4] PASSED                [ 85%]
fizzbuzz.py::test_main[17 20 --buzz=10-expected5] PASSED               [100%]

========================== 7 passed in 0.03 seconds ==========================

Если произойдёт ошибка — pytest даст полезные сведения о том, что случилось:

$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
[...]
================================== FAILURES ==================================
__________________________ test_main[0 0-expected0] __________________________

args = '0 0', expected = ['0']

    @pytest.mark.parametrize("args, expected", [
        ("0 0", ["0"]),
        ("3 5", ["fizz", "4", "buzz"]),
        ("9 12", ["fizz", "buzz", "11", "fizz"]),
        ("14 17", ["14", "fizzbuzz", "16", "17"]),
        ("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),
        ("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]),
    ])
    def test_main(args, expected):
        options = parse_args(shlex.split(args))
        options.debug = True
        options.silent = True
        setup_logging(options)
       assert main(options) == expected
E       AssertionError: assert ['fizzbuzz'] == ['0']
E         At index 0 diff: 'fizzbuzz' != '0'
E         Full diff:
E         - ['fizzbuzz']
E         + ['0']

fizzbuzz.py:160: AssertionError
----------------------------- Captured log call ------------------------------
fizzbuzz.py                125 DEBUG    compute fizzbuzz from 0 to 0
===================== 1 failed, 6 passed in 0.05 seconds =====================

В эти выходные данные включён и вывод команды logger.debug(). Это — ещё одна веская причина для использования в скриптах механизмов логирования. Если вы хотите узнать подробности о замечательных возможностях pytest — взгляните на этот материал.

Итоги

Сделать Python-скрипты надёжнее можно, выполнив следующие четыре шага:

• Оснастить скрипт документацией, размещаемой в верхней части файла.
• Использовать модуль argparse для документирования параметров, с которыми можно вызывать скрипт.
• Использовать модуль logging для вывода сведений о процессе работы скрипта.
• Написать модульные тесты.

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

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

Уважаемые читатели! Планируете ли вы применять рекомендации по написанию Python-скриптов, данные в этой публикации?

Картинка с сайта: habr.com

Have you heard about the Python programming language and do you want to create your first Python script? You will learn how to do it with this guide.

A Python script is a sequence of instructions that can be executed as a program to perform a specific task. The instructions are lines of Python code. The .py file extension is used to identify Python scripts.

In this guide, I will show you how to create and run your first Python script!

Pre-requisite: Make sure you have installed Python on your computer so you can execute the simple program you will create in this tutorial. You can download the Python version for your platform (Windows/Linux/macOS) on the Official Python website and follow the installation instructions.

What is a Python Script: The First Step If You Want to Learn Python

A Python script is a file that contains Python code. Python scripts have the .py extension which tells your computer to handle their content as a Python program. You set the .py extension for a file when you create it.

What are examples of scripts?

An example could be a Python script that generates a report of the monthly sales for a company. Another example is a script that calculates the result of a complex formula given a set of inputs.

Usually, when you get started with Python, you begin by writing simple scripts and then you increase the complexity of your programs the more you improve your skills as a Python developer.

Below you can see an example of a filename for a Python script:

your_program.py

Once Python is installed and added to the PATH on your computer, you will be able to execute the code in this Python script using the following command:

python3 your_program.py

This way, you will ask Python to execute the code in the file your_program.py line by line.

Notice that we have specified python3 in the command above. In this way, we make sure to execute the code in the file using the version of Python 3 installed on your computer.

Note: the previous version of Python was Python 2 and you shouldn’t use it considering that it’s no longer supported.

How Do I Create a Python Script Using a Text Editor?

Now that you know that to create a Python script you have to give the .py extension to it, let’s learn how to create a .py file.

To create a .py file with a text editor follow the steps below:

Open a Text Editor or Code Editor: Technically you can use any text editor for this, like Notepad on Windows or TextEdit on macOS but this is not a good approach. If you really have to use a text editor to start writing your first scripts at least use code editors like Visual Studio Code or Sublime Text. A code editor is a text editor with advanced features to support software development.

Write Some Code: Create a new file in your code editor and then write a simple Python program by adding the following line of code to the file you created:

print("Hello, CodeFatherTech!")

This is the code of a program that prints the message “Hello, CodeFatherTech!” as output.

Note: Python provides a variety of built-in functions that allow you to build programs faster by using functionality already built for you. The print() function is one of Python’s built-in functions.

Save the File: Go to “File > Save As” and save your file with the .py extension. For example, you could name it:

hello_codefathertech.py

Well done! You have created your first Python program!

How Do I Write a Python Script Using a Python IDE?

Another approach to creating Python scripts is to use a Python IDE (Integrated Development Environment).

An IDE is a software application that gives you a complete set of tools to write, test, and execute your code. Popular IDEs for Python include PyCharm and JupyterLab.

To create a script in your IDE go through the following steps:

Open the IDE: Launch your chosen IDE and create a new file.

Write Some Code: Add the following line of code to the file:

print("Hello, CodeFatherTech!")

Save the File: Save your file using the .py extension.

Et voilà, you have your script!

How to Create a .py File Using the Command Line or the Terminal

Another way to create a .py file for your Python code is via the command line. This is an approach for those of you who are used to the Windows/Linux/macOS command line.

Open the Command Line: Open the Command Prompt on Windows or the Terminal on macOS / Linux.

Navigate to the Folder: Use the cd command to navigate to the folder where you want to create your Python script.

Create the File:

1. macOS / Linux: Type the following command to create an empty file: touch hello_codefathertech.py
2. Windows: Type the following command to create an empty file: echo. > hello_codefathertech.py

Edit the File:

1. macOS / Linux: Open this file using Vim with the following command: vim hello_codefathertech.py
2. Windows: In the Windows cmd type the command copy con hello_codefathertech.py to start editing the file and add type the Python code in it. To save the file press Ctrl+Z followed by Enter.

The use of the command line can work just for very simple code changes but it’s not the ideal tool for creating scripts or making code changes to existing scripts.

As you can see from the commands mentioned above, the process of editing files in the Windows command line is quite convoluted. Definitely not ideal for code changes!

If you want to make code changes in a reliable way that you can test, using a strong code editor like Visual Studio Code or an IDE like PyCharm is the best option.

That’s because with Visual Studio Code or PyCharm, you have additional features like syntax highlighting, code auto-completion, and debugging. These three features will make your Python coding experience a lot smoother!

Where Should You Save Your Python Script?

You might be tempted to save your Python files in the first random directory that comes to your mind. For example, the desktop!

Please don’t do that as over time you will end up with a huge number of files that are impossible to find and maintain.

It’s a good idea to have a specific directory on your computer dedicated to your Python programming. You can then create sub-directories for individual Python projects.

This will make it easier for you to quickly open the code related to a specific project without having to remember where you saved the files for that project when you created it in the first place!

How Do You Add Python Code to a .py File

Now that you have created a .py file for your Python program, it’s time to add some code to it.

In one of the previous sections, we have written the following line of code in our file:

print("Hello, CodeFatherTech!")

What if you want to add multiple lines to a .py file?

To add multiple lines of code to a Python script, open your code editor or IDE and write the lines of code one under the other. Python will execute each line of code in the script sequentially.

Depending on the programming constructs (or keywords) you will add to your code you will have to provide specific levels of indentation to your script. If you don’t do that, Python will flag those lines with syntax errors when you run your code.

This is also the reason why writing your code in a good code editor or IDE is important. That’s because they understand and verify Python syntax so they can immediately flag errors in your Python code while you are writing it (this is a way to fail fast and to get working code written faster).

How Do You Run a Python Script?

After creating a Python .py script, you can execute the code in that script using the “python” command.

In the examples below we will assume that the script we want to execute is called hello_codefathertech.py.

To execute the code in a script from the directory where the file is located (using a relative path), type the following commands:

cd <directory_where_the_python_file_is_located>
python3 hello_codefathertech.py

You can also run the script using its absolute path. In other words, you won’t have to enter the directory where the script is located before executing it.

python <directory_where_the_python_file_is_located>/hello_codefathertech.py

When you execute your Python program you want to make sure you are using the latest version of Python on your system which should be a version of Python 3 (for example Python 3.11.5).

Running Python code from the command line is not the only option you have. You can also execute your program directly from your Visual Studio Code or PyCharm IDE. They both provide a “Run” button that allows you to execute your code and see its output in the IDE.

This is quite handy because this means that you can develop Python code in your code editor / IDE and execute it from the same window without having to switch to a different window.

This could save you lots of time in the long term! That’s because while building a Python program you will have to run it multiple times to verify that it’s working fine at every stage of the development process.

Would You Use a Single File for a Python Project?

A single file can work well if you create a simple Python script that you want to execute.

The more the length of your Python application code increases the more you will realize that is not ideal to have all your Python code in a single .py file.

This means that for a Python project, you will need multiple .py files organized in a specific directory structure that makes your project easy to maintain and enhance over time.

What are Common Mistakes When Creating and Executing a Python Script?

Below you can see three common beginner mistakes to avoid when you write and run Python scripts for the first time.

Forgetting the .py Extension

It can happen to forget the .py extension when saving your Python script.

Always remember to include the .py extension. This way you and your computer will be able to identify that file as a Python script.

Syntax Errors

Make sure the syntax of the code you write in your Python script is correct. Even small errors like incorrect characters specified in the wrong place or missing/incorrect indentation can cause errors when executing your Python code.

Also, when you are getting started with Python it’s harder to understand the root cause of the errors. But don’t worry, it becomes easier when you get used to Python’s syntax.

That’s why it’s important to use an IDE or code editor that notifies you about syntax errors as early as possible in the development process.

Imagine how bad it would be if you wrote a 100-line script and found several syntax errors only after finishing writing the code.

You would have to go back and review your script from scratch to fix all the errors instead of dealing with them one at a time while they occur when writing your code.

Executing the Python script from the wrong directory

Another common error is accessing an incorrect directory when you try to execute your Python script. The result is that you will see an error that tells you that your Python script cannot be found.

Example of Windows/Linux/macOS error

python: can't open file 'C:\\dev\\test_file.py': [Errno 2] No such file or directory

This is a common error especially if you are running your Python code via the command line.

Tutorial Summary

Well done!

You have taken the first step to becoming a Python developer and started understanding how Python works.

Now you know what you need to write your first Python scripts!

In this tutorial, we have also covered the commands you need to run your Python program.

As explained, the use of a simple text editor can work when creating a single Python file that contains very simple code. This would be just a test for you to start learning how to create your first Python script.

However, the right approach to create and modify files containing Python code is to use a robust code editor like Visual Studio Code or IDE like PyCharm.

Related article: Continue your journey to learn Python by going through the beginner CodeFatherTech tutorial to print “Hello, World” in multiple ways!