Питон в московском такси

Python в московском такси — часть 2

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

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

  1. Марка автомобиля
  2. Модель
  3. Год выпуска автомобиля
  4. Цвет

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

Пора за работу!
Итак… в прошлом записи я определил, что мы будем работать со страницами, которые находятся по адресу в виде: http://mtdi.mosreg.ru/deyatelnost/celevye-programmy/taksi1/proverka-razresheniya-na-rabotu-taksi?region=ALL&page=1 и отличаются только порядковым номером (что сильно упрощает задачу). Осталось понять — как определить, что данных на странице НЕТ, и остановить работу программы? Смотрим на страницу, расположенную по адресу: http://mtdi.mosreg.ru/deyatelnost/celevye-programmy/taksi1/proverka-razresheniya-na-rabotu-taksi?region=ALL&page=70000 — которая не выдает никакой информации кроме меню, и отличается от страницы с информацией только отсутствием поля page__content-section typical. От этого и будем отталкиваться: цикл будет перебирать страницы до тех пор, пока на странице будет найдено поле page__content-section typical:

  1. while True:
  2.     page = str(page)
  3.     link = 'http://mtdi.mosreg.ru/deyatelnost/celevye-programmy/taksi1/proverka-razresheniya-na-rabotu-taksi?region=ALL&page='
  4.     link_to_page = link + page
  5.     print('Открываем страницу:', link_to_page)
  6.  
  7.     response = requests.get(link_to_page, headers={'User-Agent': UserAgent().chrome})
  8.     print(response)
  9.     html = requests.get(link_to_page)
  10.     html = response.content
  11.     print('Получен исходный код страницы:\n', html)
  12.  
  13.     #Начинаем парсить - есть вообще информация на странице или нет? Если да - работаем дальше, если нет - остановка
  14.     html = str(html)
  15.     page_content_regular = 'page__content-section typical'
  16.     page_content_result = re.findall(page_content_regular, html)
  17.     print(page_content_result)
  18.     print(type(page_content_result))
  19.     page_content_result_len = len(page_content_result)
  20.     if page_content_result_len == 0:
  21.         print('Страница без информации, программа остановлена')
  22.         print('Последняя обработанная страница: ', link_to_page)
  23.         with open('log.txt', 'a', encoding='utf-8') as f_log:
  24.             f_log.write('Finish: ' + link_to_page)
  25.         break
  26.     else:
  27.         print('Страница с информацией - работаем далее.')

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

Итак… нашли страницу, проверили — поле с выводом информации есть. Получаем информацию, и видим, что вся информация представлена в виде кодировки, которая вроде как подходит под Юникод, но не сильно… и которая не может быть собрана через JSON-обращение 🙁 Может быть у вас получиться решить эту проблему как-то иначе, но я — после немалого времени гугления-общения смог решить проблему только безумно-топорным методом замены символов на читаемые через replace. С помощью регулярного выражения мы получаем все соответствующие значения со страницы, а потом просто заменяем все символы на русские. Выглядит это так:

  1. # Начинаем парсить марку автомобиля
  2.         brand_regular = 'brand\":\"([^"]+)\"'
  3.         brand_result = re.findall(brand_regular, html)
  4.         brand_list = []
  5.         for brand in brand_result:
  6.             brand = brand.replace('brand":"', '').replace('\\u0410', 'А').replace('\\u0430', 'а')\
  7.                 .replace('\\u0411', 'Б').replace('\\u0431','б').replace('\\u0412', 'В').replace('\\u0432', 'в')\
  8.                 .replace('\\u0413', 'Г').replace('\\u0433', 'г').replace('\\u0414', 'Д').replace('\\u0434', 'д')\
  9.                 .replace('\\u0415', 'Е').replace('\\u0435', 'е').replace('\\u0401', 'Ё').replace('\\u0451', 'ё')\
  10.                 .replace('\\u0416', 'Ж').replace('\\u0436', 'ж').replace('\\u0417', 'З').replace('\\u0437', 'з')\
  11.                 .replace('\\u0418', 'И').replace('\\u0438', 'и').replace('\\u0419', 'Й').replace('\\u0439', 'й')\
  12.                 .replace('\\u041a', 'К').replace('\\u043a', 'к').replace('\\u041b', 'Л').replace('\\u043b', 'л')\
  13.                 .replace('\\u041c', 'М').replace('\\u043c', 'м').replace('\\u041d', 'Н').replace('\\u043d', 'н')\
  14.                 .replace('\\u041e', 'О').replace('\\u043e', 'о').replace('\\u041f', 'П').replace('\\u043f', 'п')\
  15.                 .replace('\\u0420', 'Р').replace('\\u0440', 'р').replace('\\u0421', 'С').replace('\\u0441', 'с')\
  16.                 .replace('\\u0422', 'Т').replace('\\u0442', 'т').replace('\\u0423', 'У').replace('\\u0443', 'у')\
  17.                 .replace('\\u0424', 'Ф').replace('\\u0444', 'ф').replace('\\u0425', 'Х').replace('\\u0445', 'х')\
  18.                 .replace('\\u0426', 'Ц').replace('\\u0446', 'ц').replace('\\u0427', 'Ч').replace('\\u0447', 'ч')\
  19.                 .replace('\\u0428', 'Ш').replace('\\u0448', 'ш').replace('\\u0429', 'Щ').replace('\\u0449', 'щ')\
  20.                 .replace('\\u042a', 'Ъ').replace('\\u044a', 'ъ').replace('\\u042b', 'Ы').replace('\\u044b', 'ы')\
  21.                 .replace('\\u042c', 'Ь').replace('\\u044c', 'ь').replace('\\u042d', 'Э').replace('\\u044d', 'э')\
  22.                 .replace('\\u042e', 'Ю').replace('\\u044e', 'ю').replace('\\u042f', 'Я').replace('\\u044f', 'я')
  23.  
  24.             brand = brand.replace('\\', '')
  25.             brand_list.append(brand)

т.е. создаем регулярное выражение, которое получит все названия марок автомобилей, потом создаем чистый список, и заменяем все нелатинские символы на русские (казалось бы — государственный сайт, порядок, но хрен там… В порядке вещей написать Hundai в виде Хёнде и прочее 🙁 ). Заменили символы? Полученное слово сохраняем в список. Аналогично действуем с моделью автомобиля и цветом автомобиля. Для этого используем регулярные выражения:

model_regular = 'model\":\"([^"]+)\"'

и

colour_regular = 'colour\":\"([^"]+)\"'

А для парсинга года выпуска автомобилей используем регулярное выражение в виде:

releaseYear_regular = 'releaseYear\":\"\d+'

Итак… собрали данные, сформировали четыре списка. Дальше все просто: формируем строку в виде: Марка автомобиля: Модель автомобиля : Год выпуска : Цвет и сохраняем в файл в виде текста. Можно конечно и в Excel, но обработка полученных результатов — это уже следующий ход, о котором я задумаюсь чуть позднее 😉

  1. list_min = 1
  2.         while list_min <= 10:
  3.             with open('result.txt', 'a', encoding='utf8') as result_file:
  4.                 print(brand_list[0], ':', model_list[0], ':', releaseYear_list[0], ':', colour_list[0])
  5.                 car = brand_list[0], ':', model_list[0], ':', releaseYear_list[0], ':', colour_list[0]
  6.                 car = str(car).replace('(', '').replace(')', '').replace('\'', '').replace(',', '')
  7.                 print('Машина:', car)
  8.                 result_file.write(car + '\n'):'
  9.  
  10.                 del brand_list[0]
  11.                 del model_list[0]
  12.                 del releaseYear_list[0]
  13.                 del colour_list[0]
  14.  
  15.             list_min = list_min + 1

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

Код в полном виде выглядит вот так:

  1. import requests
  2. from fake_useragent import UserAgent #для генерации поддельного запроса на сервер
  3. from bs4 import BeautifulSoup #Для обработки получаемых данных
  4. import re #Для парсинга информации
  5.  
  6. #Получаем номер страницы, которую будем обрабатывать
  7. with open('number_page.txt', encoding='utf-8') as f:
  8.     page = f.readline()
  9.     # page = 1 #Начальная страница - потом перепрописать что бы данные из файла брались
  10.  
  11. while True:
  12.     page = str(page)
  13.     link = 'http://mtdi.mosreg.ru/deyatelnost/celevye-programmy/taksi1/proverka-razresheniya-na-rabotu-taksi?region=ALL&page='
  14.     link_to_page = link + page
  15.     print('Открываем страницу:', link_to_page)
  16.  
  17.     response = requests.get(link_to_page, headers={'User-Agent': UserAgent().chrome})
  18.     print(response)
  19.     html = requests.get(link_to_page)
  20.     html = response.content
  21.     print('Получен исходный код страницы:\n', html)
  22.  
  23.     #Начинаем парсить - есть вообще информация на странице или нет? Если да - работаем дальше, если нет - остановка
  24.     html = str(html)
  25.     page_content_regular = 'page__content-section typical'
  26.     page_content_result = re.findall(page_content_regular, html)
  27.     print(page_content_result)
  28.     print(type(page_content_result))
  29.     page_content_result_len = len(page_content_result)
  30.     if page_content_result_len == 0:
  31.         print('Страница без информации, программа остановлена')
  32.         print('Последняя обработанная страница: ', link_to_page)
  33.         with open('log.txt', 'a', encoding='utf-8') as f_log:
  34.             f_log.write('Finish: ' + link_to_page)
  35.         break
  36.     else:
  37.         print('Страница с информацией - работаем далее.')
  38.  
  39.         #Начинаем парсить информацию:
  40.         '''
  41.         - Дата выдачи
  42.         - Регистрационный номер
  43.         - Перевозчик
  44.         - ОГРН / ОГРНИП
  45.         - ИНН
  46.         - Марка автомобиля
  47.         - Модель автомобиля
  48.         - Номерной знак
  49.         - Год выпуска автомобиля
  50.         - Серия и номер бланка разрешения
  51.         - Полное наименование ЮЛ или ИП
  52.         - Срок действия разрешения
  53.         - Статус
  54.         - Регион выдачи разрешения
  55.         '''
  56.         # Начинаем парсить дату выдачи свидетельства
  57.         # permissionDate_regular = 'permissionDate\W+\d+.\d+.\d+'
  58.         # permissionDate_result = re.findall(permissionDate_regular, html)
  59.         # print(permissionDate_result)
  60.         # permissionDate_list = []
  61.         # for permissionDate in permissionDate_result:
  62.         #     permissionDate = permissionDate.replace('permissionDate":"', '')
  63.         #     print(permissionDate)
  64.         #     permissionDate_list.append(permissionDate)
  65.  
  66.         # # Начинаем парсить регистрационный номер свидетельства
  67.         # regNumber_regular = 'regNumber\W+\d+'
  68.         # regNumber_result = re.findall(regNumber_regular, html)
  69.         # print(regNumber_result)
  70.         # regNumber_list = []
  71.         # for regNumber in regNumber_result:
  72.         #     regNumber = regNumber.replace('regNumber":', '')
  73.         #     print(regNumber)  # Получили номер разрешения в чистом виде
  74.         #     regNumber_list.append(regNumber)
  75.  
  76.         # # Начинаем парсить ОГРН/ОГРНИП
  77.         # ogrn_regular = 'ogrn\W+\d+.\d+.\d+'
  78.         # ogrn_result = re.findall(ogrn_regular, html)
  79.         # print(ogrn_result)
  80.         # ogrn_list = []
  81.         # for ogrn in ogrn_result:
  82.         #     ogrn = ogrn.replace('ogrn":"', '')
  83.         #     ogrn_list.append(ogrn)
  84.  
  85.         # # Начинаем парсить ИНН
  86.         # inn_regular = 'inn\W+\d+.\d+.\d+'
  87.         # inn_result = re.findall(inn_regular, html)
  88.         # print(inn_result)
  89.         # inn_list = []
  90.         # for inn in inn_list:
  91.         #     inn = inn.replace('inn":"', '')
  92.         #     inn_list.append(inn)
  93.  
  94.         # Начинаем парсить марку автомобиля
  95.         brand_regular = 'brand\":\"([^"]+)\"'
  96.         brand_result = re.findall(brand_regular, html)
  97.         #print(brand_result)
  98.         brand_list = []
  99.         for brand in brand_result:
  100.             brand = brand.replace('brand":"', '').replace('\\u0410', 'А').replace('\\u0430', 'а')\
  101.                 .replace('\\u0411', 'Б').replace('\\u0431','б').replace('\\u0412', 'В').replace('\\u0432', 'в')\
  102.                 .replace('\\u0413', 'Г').replace('\\u0433', 'г').replace('\\u0414', 'Д').replace('\\u0434', 'д')\
  103.                 .replace('\\u0415', 'Е').replace('\\u0435', 'е').replace('\\u0401', 'Ё').replace('\\u0451', 'ё')\
  104.                 .replace('\\u0416', 'Ж').replace('\\u0436', 'ж').replace('\\u0417', 'З').replace('\\u0437', 'з')\
  105.                 .replace('\\u0418', 'И').replace('\\u0438', 'и').replace('\\u0419', 'Й').replace('\\u0439', 'й')\
  106.                 .replace('\\u041a', 'К').replace('\\u043a', 'к').replace('\\u041b', 'Л').replace('\\u043b', 'л')\
  107.                 .replace('\\u041c', 'М').replace('\\u043c', 'м').replace('\\u041d', 'Н').replace('\\u043d', 'н')\
  108.                 .replace('\\u041e', 'О').replace('\\u043e', 'о').replace('\\u041f', 'П').replace('\\u043f', 'п')\
  109.                 .replace('\\u0420', 'Р').replace('\\u0440', 'р').replace('\\u0421', 'С').replace('\\u0441', 'с')\
  110.                 .replace('\\u0422', 'Т').replace('\\u0442', 'т').replace('\\u0423', 'У').replace('\\u0443', 'у')\
  111.                 .replace('\\u0424', 'Ф').replace('\\u0444', 'ф').replace('\\u0425', 'Х').replace('\\u0445', 'х')\
  112.                 .replace('\\u0426', 'Ц').replace('\\u0446', 'ц').replace('\\u0427', 'Ч').replace('\\u0447', 'ч')\
  113.                 .replace('\\u0428', 'Ш').replace('\\u0448', 'ш').replace('\\u0429', 'Щ').replace('\\u0449', 'щ')\
  114.                 .replace('\\u042a', 'Ъ').replace('\\u044a', 'ъ').replace('\\u042b', 'Ы').replace('\\u044b', 'ы')\
  115.                 .replace('\\u042c', 'Ь').replace('\\u044c', 'ь').replace('\\u042d', 'Э').replace('\\u044d', 'э')\
  116.                 .replace('\\u042e', 'Ю').replace('\\u044e', 'ю').replace('\\u042f', 'Я').replace('\\u044f', 'я')
  117.  
  118.             brand = brand.replace('\\', '')
  119.             brand_list.append(brand)
  120.  
  121.             #print(brand)
  122.             #brand_list.append(brand)
  123.  
  124.         # Начинаем парсить модель автомобиля
  125.         model_regular = 'model\":\"([^"]+)\"'
  126.         model_result = re.findall(model_regular, html)
  127.         #print(model_result)
  128.         model_list = []
  129.         for model in model_result:
  130.             model = model.replace('colour":"', '').replace('\\u0410', 'А').replace('\\u0430', 'а') \
  131.                 .replace('\\u0411', 'Б').replace('\\u0431', 'б').replace('\\u0412', 'В').replace('\\u0432', 'в') \
  132.                 .replace('\\u0413', 'Г').replace('\\u0433', 'г').replace('\\u0414', 'Д').replace('\\u0434', 'д') \
  133.                 .replace('\\u0415', 'Е').replace('\\u0435', 'е').replace('\\u0401', 'Ё').replace('\\u0451', 'ё') \
  134.                 .replace('\\u0416', 'Ж').replace('\\u0436', 'ж').replace('\\u0417', 'З').replace('\\u0437', 'з') \
  135.                 .replace('\\u0418', 'И').replace('\\u0438', 'и').replace('\\u0419', 'Й').replace('\\u0439', 'й') \
  136.                 .replace('\\u041a', 'К').replace('\\u043a', 'к').replace('\\u041b', 'Л').replace('\\u043b', 'л') \
  137.                 .replace('\\u041c', 'М').replace('\\u043c', 'м').replace('\\u041d', 'Н').replace('\\u043d', 'н') \
  138.                 .replace('\\u041e', 'О').replace('\\u043e', 'о').replace('\\u041f', 'П').replace('\\u043f', 'п') \
  139.                 .replace('\\u0420', 'Р').replace('\\u0440', 'р').replace('\\u0421', 'С').replace('\\u0441', 'с') \
  140.                 .replace('\\u0422', 'Т').replace('\\u0442', 'т').replace('\\u0423', 'У').replace('\\u0443', 'у') \
  141.                 .replace('\\u0424', 'Ф').replace('\\u0444', 'ф').replace('\\u0425', 'Х').replace('\\u0445', 'х') \
  142.                 .replace('\\u0426', 'Ц').replace('\\u0446', 'ц').replace('\\u0427', 'Ч').replace('\\u0447', 'ч') \
  143.                 .replace('\\u0428', 'Ш').replace('\\u0448', 'ш').replace('\\u0429', 'Щ').replace('\\u0449', 'щ') \
  144.                 .replace('\\u042a', 'Ъ').replace('\\u044a', 'ъ').replace('\\u042b', 'Ы').replace('\\u044b', 'ы') \
  145.                 .replace('\\u042c', 'Ь').replace('\\u044c', 'ь').replace('\\u042d', 'Э').replace('\\u044d', 'э') \
  146.                 .replace('\\u042e', 'Ю').replace('\\u044e', 'ю').replace('\\u042f', 'Я').replace('\\u044f', 'я')
  147.  
  148.             model = model.replace('\\', '')
  149.             model_list.append(model)
  150.  
  151.             #model = model.replace('model":"', '')
  152.             #print(model)
  153.             #model_list.append(model)
  154.  
  155.         # Начинаем парсить цвет автомобиля
  156.         colour_regular = 'colour\":\"([^"]+)\"'
  157.         colour_result = re.findall(colour_regular, html)
  158.         #print(colour_result)
  159.         colour_list = []
  160.         for colour in colour_result:
  161.             colour = colour.replace('colour":"', '').replace('\\u0410', 'А').replace('\\u0430', 'а')\
  162.                 .replace('\\u0411', 'Б').replace('\\u0431','б').replace('\\u0412', 'В').replace('\\u0432', 'в')\
  163.                 .replace('\\u0413', 'Г').replace('\\u0433', 'г').replace('\\u0414', 'Д').replace('\\u0434', 'д')\
  164.                 .replace('\\u0415', 'Е').replace('\\u0435', 'е').replace('\\u0401', 'Ё').replace('\\u0451', 'ё')\
  165.                 .replace('\\u0416', 'Ж').replace('\\u0436', 'ж').replace('\\u0417', 'З').replace('\\u0437', 'з')\
  166.                 .replace('\\u0418', 'И').replace('\\u0438', 'и').replace('\\u0419', 'Й').replace('\\u0439', 'й')\
  167.                 .replace('\\u041a', 'К').replace('\\u043a', 'к').replace('\\u041b', 'Л').replace('\\u043b', 'л')\
  168.                 .replace('\\u041c', 'М').replace('\\u043c', 'м').replace('\\u041d', 'Н').replace('\\u043d', 'н')\
  169.                 .replace('\\u041e', 'О').replace('\\u043e', 'о').replace('\\u041f', 'П').replace('\\u043f', 'п')\
  170.                 .replace('\\u0420', 'Р').replace('\\u0440', 'р').replace('\\u0421', 'С').replace('\\u0441', 'с')\
  171.                 .replace('\\u0422', 'Т').replace('\\u0442', 'т').replace('\\u0423', 'У').replace('\\u0443', 'у')\
  172.                 .replace('\\u0424', 'Ф').replace('\\u0444', 'ф').replace('\\u0425', 'Х').replace('\\u0445', 'х')\
  173.                 .replace('\\u0426', 'Ц').replace('\\u0446', 'ц').replace('\\u0427', 'Ч').replace('\\u0447', 'ч')\
  174.                 .replace('\\u0428', 'Ш').replace('\\u0448', 'ш').replace('\\u0429', 'Щ').replace('\\u0449', 'щ')\
  175.                 .replace('\\u042a', 'Ъ').replace('\\u044a', 'ъ').replace('\\u042b', 'Ы').replace('\\u044b', 'ы')\
  176.                 .replace('\\u042c', 'Ь').replace('\\u044c', 'ь').replace('\\u042d', 'Э').replace('\\u044d', 'э')\
  177.                 .replace('\\u042e', 'Ю').replace('\\u044e', 'ю').replace('\\u042f', 'Я').replace('\\u044f', 'я')
  178.  
  179.             colour = colour.replace('\\', '')
  180.             colour_list.append(colour)
  181.  
  182.         # # Начинаем парсить номер автомобиля
  183.         # gosNumber_regular = 'gosNumber\":\"\\\\\\\\\w+\\\\\\\\\w+'
  184.         # gosNumber_result = re.findall(gosNumber_regular, html)
  185.         # print(gosNumber_result)
  186.         # gosNumber_list = []
  187.         # for gosNumber in gosNumber_result:
  188.         #     gosNumber = gosNumber.replace('gosNumber":"', '').replace('\\', '\'')
  189.         #     print(gosNumber)
  190.         #     gosNumber_list.append(gosNumber)
  191.  
  192.         # Начинаем парсить год выпуска автомобиля
  193.         releaseYear_regular = 'releaseYear\":\"\d+'
  194.         releaseYear_result = re.findall(releaseYear_regular, html)
  195.         #print(releaseYear_result)
  196.         releaseYear_list = []
  197.         for releaseYear in releaseYear_result:
  198.             releaseYear = releaseYear.replace('releaseYear":"', '')
  199.             #print(releaseYear)
  200.             releaseYear_list.append(releaseYear)
  201.  
  202.         # # Начинаем парсить серию и номер бланка разрешения
  203.         # form_regular = 'form\":\"([^"]+)\"'
  204.         # form_result = re.findall(form_regular, html)
  205.         # print('\n \n \n \n', form_result, '\n \n \n \n')
  206.         # form_list = []
  207.         # for form in form_list:
  208.         #     form = form.replace('form":"', '')
  209.         #     print('Номер бланка:', form)
  210.         #     form_list.append(form)
  211.  
  212.         # # Полное наименование ЮЛ или ИП
  213.         # name_regular = 'name\":\"([^"]+)\"'
  214.         # name_result = re.findall(name_regular, html)
  215.         # print(name_result)
  216.         # name_list = []
  217.         # for name in name_result:
  218.         #     name = name.replace('name":"', '')
  219.         #     name_list.append(name)
  220.  
  221.         # # Начинаем парсить срок действия разрешения
  222.         # expireDate_regular = 'expireDate\W+\d+.\d+.\d+'
  223.         # expireDate_result = re.findall(expireDate_regular, html)
  224.         # print(expireDate_result)
  225.         # expireDate_list = []
  226.         # for expireDate in expireDate_list:
  227.         #     expireDate = expireDate.replace('expareDate":"', '')
  228.         #     expireDate_list.append(expireDate)
  229.  
  230.         # # Начинаем парсить статус разрешения
  231.         # full_status_regular = 'full_status\":\"([^"]+)\"'
  232.         # full_status_result = re.findall(full_status_regular, html)
  233.         # print(full_status_result)
  234.         # full_status_list = []
  235.         # for full_status in full_status_list:
  236.         #     full_status = full_status.replace('full_status":"', '')
  237.         #     full_status_list.append(full_status)
  238.  
  239.         # # Начинаем парсить регион разрешения
  240.         # regionName_regular = 'regionName\":\"([^"]+)\"'
  241.         # regionName_result = re.findall(regionName_regular, html)
  242.         # print(regionName_result)
  243.         # regionName_list = []
  244.         # for regionName in regionName_result:
  245.         #     regionName = regionName.replace('', '')
  246.         #     print(regionName)
  247.         #     regionName_list.append(regionName)
  248.  
  249.         # print('Дата выдачи разрешения:\n Количество:', len(permissionDate_list), permissionDate_list)
  250.         # print('Регистрационный номер:\n Количество:', len(regNumber_list), regNumber_list)
  251.         # print('ОГРН:\n Количество:', len(ogrn_list), ogrn_list)
  252.         # print('ИНН:\n Количество:', len(inn_list), inn_list)
  253.         print('Марка автомобиля\n Количество:', len(brand_list), brand_list)
  254.         print('Модель автомобиля:\n Количество:', len(model_list), model_list)
  255.         print('Цвет автомобиля:\n Количество:', len(colour_list), colour_list)
  256.         # print('Гос.номер автомобиля:\n Количество:', len(gosNumber_list), gosNumber_list)
  257.         print('Год выпуска автомобиля:\n Количество:', len(releaseYear_list), releaseYear_list)
  258.         # print('Серия и номер бланка разрешения:\n Количество:', len(form_list), form_list)
  259.         # print('Полное название ИП или ЮЛ:\n Количество:', len(name_list), name_list)
  260.         # print('Срок действия разрешения:\n Количество:', len(expireDate_list), expireDate_list)
  261.         # print('Статус разрешения:\n Количество:', len(full_status_list), full_status_list)
  262.         # print('Регион разрешения:\n Количество:', len(regionName_list), regionName_list)
  263.  
  264.         list_min = 1
  265.         while list_min <= 10:
  266.             with open('result.txt', 'a', encoding='utf8') as result_file:
  267.                 print(brand_list[0], ':', model_list[0], ':', releaseYear_list[0], ':', colour_list[0])
  268.                 car = brand_list[0], ':', model_list[0], ':', releaseYear_list[0], ':', colour_list[0]
  269.                 car = str(car).replace('(', '').replace(')', '').replace('\'', '').replace(',', '')
  270.                 print('Машина:', car)
  271.                 result_file.write(car + '\n')
  272.                 # for_write_2 = model_list[0] + ':'
  273.                 # for_write_3 = releaseYear_list[0] + ':'
  274.                 # for_write_4 = colour_list[0] + ':'
  275.  
  276.                 del brand_list[0]
  277.                 del model_list[0]
  278.                 del releaseYear_list[0]
  279.                 del colour_list[0]
  280.  
  281.             list_min = list_min + 1
  282.  
  283.     with open('number_page.txt', 'w', encoding='utf8') as f_number_page:
  284.         f_number_page.write(page)
  285.  
  286.     page = int(page)
  287.     page = page + 1

На этом пока все 🙂 В случае возникновения вопросов — пишите на почту или в Telegram. И да — код доступен в Git.

P.S. И да — код вполне способен собрать более полную информацию — налоговые данные, даты выдачи лицензий, номера бланков и прочее… разберетесь 😉