Sly_tom_cat .

А мне одному кажется, что весь описанный функционал потянет любая CMS-ка (даже опенсорсная типа joomla)?

... и не надо изобретать очередной велосипед с гипердвигателем и искусственным интеллектом...

А зачем вообще что-то преобразовывать?

>>> filter(lambda c: c.islower() or c.isdigit(), 'asd123ASD!@#')
'asd123'

В описании filter четко описано : If iterable is a string or a tuple, the result also has that type;
Но это если у вас 'a' - строка. Если 'a' - список - то вы сначала его в строку преобразуйте.

Но это верно для второго питона - в третьем filter это не функция, а итератор, которые нужно обработать прежде чем получишь строку:

>>> ''.join(filter(lambda c: c.islower() or c.isdigit(), 'asd123ASD!@#'))
'asd123'
>>>

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

На уровне учебных материалов (которых кстати больше по 2-й версии) разница - минимальна. Понимать в чем разница - все равно нужно, потому что на 2-м просто туча легаси кода написана.

Но писать я бы советовал все-таки на 3.

$ cat exit.py 
#!/usr/bin/env python3
if __name__ == '__main__':
  exit(1)

$ python3 exit.py 
$ echo $?
1

Вот тут: Как правильно закрыть поток в python? я описал пару шаблонов по работе с потоками - вам нужен шаблон "победитель".

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

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

"Коллектор":

import threading
def job(id, ...):
global res
  <Подготовка блока данных>
  res[id] = <блок подготовленных данных>
  return

res = []
for i in range(N):   # запуск N потоков
    res.append(<пустой блок>)
    threading.Thread(target=job, args=(i, ...)).start()
for th in threading.enumerate():  # ожидание всех потоков 
    if th != threading.currentThread():
      th.join()
<здесь массив с блоками полностью собран >

"Победитель":

import threading
def job(...):
  global val
  global event
  while <не нашли>
    <элементарный шаг поиска>
    if event.is_set():
      return   # кто-то уже нашел искомое
  val=<то что нашли>
  event.set()   # этот поток нашел искомое и радостно сообщает всем об этом
  return

val = None  # искомое значение
event = threading.Event() # флаг сигнализирующий о том что решение найдено
threads = []
for i in range(N):
    threads.append(threading.Thread(target=job, args=(i, ...)))
    threads[-1].start()
event.wait()  # тут основной поток ждет сигнала о победе от одного из запущенных потоков
# если есть шанс, что победителя может и не быть, то в wait() нужно указать таймаут
# и читать значение event.wait(), что бы узнать - сработал таймаут или появился победитель.
<тут обрабатываем найденное>
for th in threads:   # Подчищаем за собой - гарантированно собираем закрывшиеся потоки
      th.join()

ЗЫ последний цикл в "победителе" - часто не обязателен, но если сама эта процедура запущена во множестве потоков, то можно получить так называемый "потоковый потоп", когда потоки не успевают закрываться сами и плодятся в системе со страшной силой, с предсказуемыми последствиями.
ЗЫЫ также обратите внимание на варианты работы с набором потоков. В примере "Коллектор" не подразумевается, что в программе есть какие-то еще потоки, поэтому сборка потоков идет всех, кроме текущего (основного потока программы). А вот в "Победитель" потоки сохраняются в списке и из этого списка потом собираются. Это позволяет иметь в программе и другие потоки работающие в параллель с нашим поиском победителя (и в частности запускать сам такой поиск победителя в независимых потоках). Правда для оформления этого кода в отдельные потоки - возможно потребуется избавиться от глобальных переменных и работать только через передаваемые в job параметры.

from time import time
from threading import Thread
from multiprocessing import Process

def count(n):
while n > 0:
n -= 1

startTime = time()
count(100000000)
count(100000000)
print('\nSequential execution time : %3.2f s.'%(time() - startTime))

startTime = time()
t1 = Thread(target=count, args=(100000000,))
t2 = Thread(target=count, args=(100000000,))
t1.start(); t2.start()
t1.join(); t2.join()
print('\nThreaded execution time : %3.2f s.'%(time() - startTime))

startTime = time()
p1 = Process(target=count, args=(100000000,))
p2 = Process(target=count, args=(100000000,))
p1.start(); p2.start()
p1.join(); p2.join()
print('\nMultiprocessed execution time : %3.2f s.'%(time() - startTime))

Дает на 4-х ядерном проце:

Sequential execution time : 6.83 s.

Threaded execution time : 11.37 s.

Multiprocessed execution time : 6.30 s.

Но допустим распараллеливание запросов к http серверу и в thread варианте даст огромный выигрыш.
Т.е. без учета специфики задачи - в многопоточность/многопроцессорность - лучше просто не соваться.

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

Большинство дистрибутивов Linux (Ubuntu - особенно) содержит кучу утилит написанных на python2 и они не будут работать на python3 с вероятностью близкой к 100%. Подменив ссылку python -> python2 на python -> python3 вы получите в лучшем случае сильно окривевшую систему.

Если вам нужно что бы питонпрограмма исполнялась третьим питоном - просто измените в первой строчке программы
#!/usr/bin/env python
на
#!/usr/bin/env python3