תרגילים נוספים: שבוע 5

from collections import Counter


def noga_encoding(my_string):
    my_string = my_string.lower()
    char_list = Counter(my_string)
    
    encrypted_string = ""
    for character in my_string:
        if char_list.get(character, 0) == 1:
            encrypted_string += "_"
        else:
            encrypted_string += "*"
    return encrypted_string


print(noga_encoding("ABBA"))
print(noga_encoding("Ali Baba"))
print(noga_encoding("CatDog"))

def print_recipe(number_of_servings, is_regular=False, **toppings):
    if is_regular:
        print("Hey, nice to see you again!")
    
    print(f'{number_of_servings} servings of falafel for you!')

    for topping, amount in toppings.items():
        print(f'With {amount} of {topping}!')


print_recipe(2, True, tahini='a bucket', parsley='a lot', amba='a little bit')
print()
print_recipe(4, tahini='tons', Tabasco='a bottle')

def get_prime_number(number):
    for divider in range(2, int((number / 2) + 1)):
        if number % divider == 0:
            return None
    return number


def get_prime_numbers(index):
    counter = 0
    number = 2
    while counter != index:
        prime_number = get_prime_number(number)
        if prime_number:
            yield prime_number
            counter += 1
        number += 1


def get_prime_number_by_index(index):
    counter = 1
    for item in get_prime_numbers(index):
        if counter != index:
            counter += 1
        else:
            print(item)


get_prime_number_by_index(10)
get_prime_number_by_index(4000)

def get_t_numbers():
    num_list = []
    current_num = 1
    while True:
        num_list.append(current_num)
        yield sum(num_list)
        current_num += 1


def get_number_with_n_number_of_dividers(number, number_of_dividers):
    dividers = 0
    for i in range(1, int(number / 2) + 1):
        if number % i == 0:
            dividers += 1
    return dividers == (number_of_dividers - 1)
     

def main():
    for number in get_t_numbers():
        is_equal = get_number_with_n_number_of_dividers(number, 120)
        if is_equal:
            print(number)

main()

import os


def is_all_words(file_name, words):
    counter = 0
    is_all_match = True
    while is_all_match and counter < len(words):
        if words[counter] in file_name:
            counter += 1
        else:
            is_all_match = False
    return is_all_match


def all_files_with_words(path, words):
    for directory in os.walk(path):
        files = directory[2]
        if len(files) > 0:
            for file in files:
                if is_all_words(file, words):
                    yield file


words = ['python', 'hello']
path = r'\Users\Aviad\Desktop\test'

for file in all_files_with_words(path, words):
    print(file)  

def number_of_triangles():
    i = 1
    while True:
        number = 0
        for j in range(1, i + 1):
            number += j
        yield number
        i += 1


def number_of_dividers(number):
    if number == 1:
        return 1
    else:
        dividers = 2
        counter = 2
        while counter <= number // 2:
            if number % counter == 0:
                dividers += 1
            counter += 1
        return dividers


limit = 120
is_found = False
generator = number_of_triangles()
while not is_found:
    result = next(generator)
    if number_of_dividers(result) == limit:
        is_found = True
        print(result)

import collections


# Returns a string - if a letter is existed more than one time - change each apperance of it to '*', otherwise to - '_'
def make_weird_string(string):
    string = string.lower()
    words_counter = collections.Counter(string)
    final_string = ""
    for letter in string:
        if words_counter[letter] > 1:
            final_string += '*'
        else:
            final_string += '_'
    return final_string


print(make_weird_string("Ali Baba"))

# Prints the recipe of the falafel
def print_recipe(num_of_dishes, regular_customer=False, **extras):
    if regular_customer:
        print("Hey, nice to see you again!")
    print(f"{num_of_dishes} servings of falafel for you!")
    for each in extras:
        print(f"With {extras[each]} of {each}!")


print_recipe(2, True, tahini='a bucket', parsley='a lot', amba='a little bit')
print_recipe(4, tahini='tons', Tabasco='a bottle')

# Checks if n is a prime number
def is_prime_number(n):
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    limit = int(n ** 0.5) + 1    # Divisors that are bigger than sqrt(n) can be eliminated
    for divisor in range (3, limit, 2):
        if n % divisor == 0:
            return False
    return True


# Generates all the prime numbers
def get_prime_numbers():
    yield 2
    number = 3
    while True:
        if is_prime_number(number):
            yield number
        number += 2

# Returns the 'index' prime number
def get_prime_number_by_index(index):
    generator_iterator = get_prime_numbers()
    for _ in range(index - 1):
        next(generator_iterator)
    return next(generator_iterator)


print(get_prime_number_by_index(100))    # => 541
print(get_prime_number_by_index(4000))   # => 37,813

# Generates all the triangle numbers
def triangle_number():
    number = 1
    next_organ = 2
    while True:
        yield number
        number += next_organ
        next_organ += 1


# Returns the number of divisors of a number
def get_num_of_divisors(number):
    limit = number // 2    # We can eliminate all the numbers that are bigger than the half of the number
    num_of_divisors = 2    # Every number divides by himself and also '1'
    current_divisor = 2
    while current_divisor <= limit:
        if number % current_divisor == 0:
            num_of_divisors += 1
        current_divisor += 1
    return num_of_divisors


# Returns the first triangle number that his number of divisors is as the paramather
def get_triangle_number_by_num_of_divisors(num_of_divisors):
    generator_iterator = triangle_number()
    for number in generator_iterator:
        if get_num_of_divisors(number) == num_of_divisors:
            return number


print(get_triangle_number_by_num_of_divisors(120))

import os


# Gets a file-name and checks if all the searching words are included in his name
def include_words(filename, *searching_words):
    for word in searching_words:
        if word not in filename:
            return False
    return True


# Generates all the files that have all the searching words in their names
def search_files(path, *searching_words):
    for route in os.walk(path):
        files = route[-1]
        for filename in files:
            if include_words(filename, *searching_words):
                yield filename

# Generates in a recursive way the files that have all the searching words in their names
def search_files_recursive(path, *searching_words):
    for file in os.listdir(path):
        if os.path.isdir(file):
            iterator = search_files_recursive(os.path.join(path, file), *searching_words)
            for each in iterator:
                if include_words(each, *searching_words):
                    yield each
        if include_words(file, *searching_words):
            yield file


PATH = r"I:\Python Course\week5"

searching_iterator = search_files(PATH, "1", "Pt")
for file in searching_iterator:
    print(file)
print('-' * 50)
searching_recursive_iterator = search_files_recursive(PATH, "1", "Pt")
for file in searching_recursive_iterator:
    print(file)

import os


def are_words_in_file(file_path, *words):
    words_list = list(words)
    with open(file_path, 'r', encoding="utf8") as file_handler:
        for line in file_handler:
            line = line.lower()
            for word in words_list:
                if word in line:
                    words_list.remove(word)
    if not words_list:
        return True

    else:
        return False


def files_generator(path):
    for dirpath, dirnames, filenames in os.walk(path):
        for name in filenames:
            file_path = os.path.join(dirpath, name)
            if name.endswith('.txt'):
                yield file_path


def return_files_with_words(path, *words):
    for file_path in files_generator(path):
        print(file_path)
        print(are_words_in_file(file_path, *words))
        if are_words_in_file(file_path, *words):
            return file_path