]*?>[^<>]*?', '', nostyle)
+ notags = re.sub('<[^>]*>', '', nospan)
+ notags1 = re.sub('{[^}]*}', '', notags)
+ text = re.sub('[&][^;]*;', ' ', notags1)
+ text = re.sub(r'\s+', ' ', text)
+ return text
+def html(text):
+ tags = re.findall(r'<[^>]*?>', text)
+ return tags
+def main():
+ with open('schizo.txt', 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ with open('html.txt', 'w', encoding = 'utf-8') as f:
+ output = f.write('\n'.join(html(text)))
+ with open('pure.txt', 'w', encoding = 'utf-8') as f:
+ output = f.write(clean(text))
+if __name__ == '__main__':
+ main()
+
+
+
+import re
+def main():
+ given = input('Введите свой телефонный номер: ')
+ right = re.search('\+7 \([0-9]{3}\) [0-9]{3}-[0-9]{2}-[0-9]{2}', given)
+ if right:
+ print('Введённый номер совпадает с шаблоном +7 (ХХХ) ХХХ-ХХ-ХХ.')
+ if re.search('\(9(?:2|3)', given):
+ print('Это Мегафон.')
+ elif re.search('\(9(?:1|8)', given):
+ print('Это МТС.')
+ elif re.search('\(96', given):
+ print('Это Билайн.')
+ else:
+ print('Я не могу точно сказать, какой это оператор.')
+ else:
+ print('Введённый номер не совпадает с шаблоном +7 (ХХХ) ХХХ-ХХ-ХХ.')
+ if re.search('\(9(?:2|3)', given) or re.search('\+7 ?9(?:2|3)', given) or re.match('8 ?9(?:2|3)', given):
+ print('Это Мегафон.')
+ elif re.search('\(9(?:1|8)', given) or re.search('\+7 ?9(?:1|8)', given) or re.match('8 ?9(?:1|8)', given):
+ print('Это МТС.')
+ elif re.search('\(96', given) or re.search('\+7 ?96', given) or re.match('8 ?96', given):
+ print('Это Билайн.')
+ else:
+ print('Я не могу точно сказать, какой это оператор.')
+if __name__ == '__main__':
+ main()
+
+
+
+
+
+import re
+def revert(dictionary):
+ reverted = {}
+ for key in dictionary:
+ reverted[dictionary[key]] = key
+ return reverted
+def russian_to_latin_dictionary(lines):
+ raw = {}
+ rus_to_lat = {}
+ for i in range(len(lines)):
+ raw[lines[i].split(' — ')[0]] = lines[i].split(' — ')[1].strip('\n')
+ raw = revert(raw)
+ for key in raw:
+ if len(key.split(',')) > 1:
+ for i in range(len(key.split(','))):
+ rus_to_lat[key.split(',')[i-1].strip()] = raw[key]
+ i +=10
+ else:
+ rus_to_lat[key] = raw[key]
+ return rus_to_lat
+def latin_to_russian_dictionary(lines):
+ raw = {}
+ lat_to_rus = {}
+ for i in range(len(lines)):
+ raw[lines[i].split(' — ')[0]] = lines[i].split(' — ')[1].strip('\n')
+ for key in raw:
+ if len(key.split(',')) > 1:
+ for i in range(len(key.split(','))):
+ lat_to_rus[key.split(',')[i-1].strip()] = raw[key]
+ i +=10
+ else:
+ lat_to_rus[key] = raw[key]
+ return lat_to_rus
+def main():
+ with open ('latin.txt', 'r', encoding = 'utf-8') as f:
+ lines = f.readlines()
+ for i in range(len(lines)):
+ lines[i] = re.sub('(?:–|−|-)', '—', lines[i])
+ lines[i] = re.sub(';', ',', lines[i])
+ print(latin_to_russian_dictionary(lines))
+ print(russian_to_latin_dictionary(lines))
+if __name__ == '__main__':
+ main()
+
+
+
+def process(fname):
+ with open (fname, 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ text = text.lower()
+ forms = text.split()
+ for i in range(len(forms)):
+ forms[i] = forms[i].strip('.,!?*()«»\'":][><')
+ return forms
+def freqlist(forms):
+ freqs = {}
+ for i in range(len(forms)):
+ if forms[i] not in freqs:
+ freqs[forms[i]] = 1
+ else:
+ freqs[forms[i]] +=1
+ return freqs
+def maxfreq(frequencies):
+ maximumfreq = []
+ for key in frequencies:
+ if frequencies[key] == max(frequencies.values()):
+ maximumfreq.append(key)
+ return maximumfreq
+def averagefreq(frequencies):
+ total = 0
+ for key in frequencies:
+ total += frequencies[key]
+ average = total/len(frequencies)
+ return average
+def main():
+ forms = process('text.txt')
+ frequencies = freqlist(forms)
+ print(*maxfreq(frequencies), '- самое частотное слово в тексте.')
+ print(averagefreq(frequencies), '- средняя частота слов в тексте.')
+if __name__ == '__main__':
+ main()
+
+
+
+
+
+
+
+
+
+
+
+import random
+def ask():
+ user_info = []
+ name = input('Как Вас зовут? ')
+ surname = input('Какая у Вас фамилия? ')
+ age = input('Сколько Вам лет? ')
+ food = input('Какая у Вас любимая еда? ')
+ musician = input('Какая у Вас любимая музыкальная группа? ')
+ dream = input('Какая у Вас заветная мечта? ')
+ user_info.append(name+' '+surname)
+ user_info.append([age, food, musician, dream])
+ return user_info
+def guess(database_dictionary):
+ person = random.choice(list(database_dictionary.keys()))
+ clue = random.choice(['его/её мечта: '+database_dictionary[person][3], 'его/её любимая музыкальная группа: '+database_dictionary[person][2], 'его/её мечта: '+database_dictionary[person][3]+'\nего/её любимая еда: '+database_dictionary[person][1], 'его/её любимая музыкальная группа: '+database_dictionary[person][2]+'\nего/её любимая еда: '+database_dictionary[person][1]])
+ guess = input('Угадайте, кто это (имя и фамилию)? Подсказка: '+clue+' ')
+ if guess == person:
+ return 'Правильно!'
+ else:
+ return 'Нет, неправильно, это - '+person
+def main():
+ database = {}
+ i = 0
+ while i < 7:
+ answer = ask()
+ i += 1
+ database[answer[0]] = answer[1]
+ print(guess(database))
+if __name__ == '__main__':
+ main()
+
+
+
+
+
+
+import re
+def main():
+ with open('Лингвистика.txt', 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ lang = 'язык((?:а(?:ми?|х)?)|и|о(?:в|м)|у|е)?([\s,.!\?:"\(\)\'»])'
+ Lang = 'Язык((?:а(?:ми?|х)?)|и|о(?:в|м)|у|е)?([\s,.!\?:"\(\)\'»])'
+ new_text = re.sub(lang,'шашлык\\1\\2', text)
+ new_text = re.sub(Lang,'Шашлык\\1\\2', new_text)
+ with open('Новая лингвистика.txt', 'w', encoding = 'utf-8') as f:
+ f.write(new_text)
+if __name__ == '__main__':
+ main()
+
+
+import os
+extension_frequency_list = {}
+for root, dirs, files in os.walk('.'):
+ for f in files:
+ file_name = f.split('.')[0]
+ file_ext = f.split('.')[1]
+ if file_ext not in extension_frequency_list:
+ extension_frequency_list[file_ext] = 1
+ else:
+ extension_frequency_list[file_ext] += 1
+max_ext = max(extension_frequency_list.values())
+i = 0
+for key in extension_frequency_list:
+ if extension_frequency_list[key] == max_ext:
+ if i == 0:
+ print('The most frequent extention is \''+key+'\'. There is(are) '+str(extension_frequency_list[key])+' file(s) with it.')
+ i = 1
+ else:
+ print('There is(are) also '+str(extension_frequency_list[key])+' \''+key+'\' file(s).')
+
+
+
+
+def opentext(fname):
+ forms = []
+ with open (fname, 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ text = text.lower()
+ forms = text.split()
+ for i in range(len(forms)):
+ forms[i] = forms[i].strip('.,!?*()«»\'"')
+ return forms
+def adj_hood(fname):
+ words = opentext(fname)
+ hoods = []
+ for i in range(len(words)):
+ if len(words[i])>4:
+ if words[i][-1] == 'd':
+ if words[i][-2] == 'o':
+ if words[i][-3] == 'o':
+ if words[i][-4] == 'h':
+ if words[i] not in hoods:
+ hoods.append(words[i])
+ return hoods
+def count_frequency(fname, word):
+ words = opentext(fname)
+ word_freq = 0
+ for i in range(len(words)):
+ if words[i] == word:
+ word_freq += 1
+ return word_freq
+def main():
+ fname = input('Введите имя файла: ')
+ hoods = adj_hood(fname)
+ print('В тексте встретилось', len(hoods), 'прилагательных с суффиксом -hood.')
+ freq = []
+ for i in range(len(hoods)):
+ freq.append(count_frequency(fname, hoods[i]))
+ min_freq = []
+ for i in range(len(hoods)):
+ if freq[i] == min(freq):
+ min_freq.append(hoods[i])
+ print('Самые редкие прилагательные с суффиксом -hood: ', ', '.join(min_freq))
+ roots = []
+ for i in range(len(hoods)):
+ roots.append(hoods[i][0:-4])
+ print('Корни прилагательных с суффиксом -hood: ', ', '.join(roots))
+if __name__ == '__main__':
+ main()
+
+
+
+words = []
+with open('text.txt','r', encoding = 'utf-8') as f:
+ text = f.read()
+ words_raw = text.split()
+ words = []
+ for i in range(len(words_raw)):
+ words.extend(words_raw[i].split('\n'))
+len3 = 0
+len1 = 0
+for word in words:
+ if len(word) == 3:
+ len3 += 1
+ elif len(word) == 1:
+ len1 += 1
+if len1 == 0:
+ print('В файле нет слов длины 1.')
+elif len3 == 0:
+ print('В файле нет слов длины 3.')
+else:
+ print('В файле в '+str(len3/len1)+' раз больше слов длины 3, чем слов длины 1.')
+
+
+
+import random
+def nom_noun():
+ with open('nomnouns.txt','r', encoding = 'utf-8') as f:
+ nomnouns = f.read().split('\n')
+ return random.choice(nomnouns)
+def acc_noun():
+ with open('accnouns.txt','r', encoding = 'utf-8') as f:
+ accnouns = f.read().split('\n')
+ return random.choice(accnouns)
+def adverb():
+ with open('adverbs.txt','r', encoding = 'utf-8') as f:
+ adverbs = f.read().split('\n')
+ return random.choice(adverbs)
+def intensifier(adv):
+ with open('intensifiers.txt','r', encoding = 'utf-8') as f:
+ intensifiers = f.read().split('\n')
+ return random.choice(intensifiers) + ' ' + adv
+def verb_of_thought(subj):
+ with open('thoughtverbs.txt','r', encoding = 'utf-8') as f:
+ thoughtverbs = f.read().split('\n')
+ return subj + ' ' + random.choice(thoughtverbs) + ', что ' + trans_verb(nom_noun(), acc_noun()) + '.'
+def trans_verb(subj, obj):
+ with open('transverbs.txt','r', encoding = 'utf-8') as f:
+ transverbs = f.read().split('\n')
+ return subj + ' ' + intensifier(adverb()) + ' ' + random.choice(transverbs)+ ' ' + obj
+def trans_verb_negative(subj, obj):
+ with open('transverbs.txt','r', encoding = 'utf-8') as f:
+ transverbs = f.read().split('\n')
+ negative_sentences = [subj + ' не ' + intensifier(adverb()) + ' ' + random.choice(transverbs)+ ' ' + obj, subj + ' ' + intensifier(adverb()) + ' не ' + random.choice(transverbs)+ ' ' + obj]
+ return random.choice(negative_sentences)
+def verb_of_thought_negative(subj, obj):
+ with open('thoughtverbs.txt','r', encoding = 'utf-8') as f:
+ thoughtverbs = f.read().split('\n')
+ return subj + ' не ' + random.choice(thoughtverbs) + ', что ' + trans_verb(nom_noun(), acc_noun()) + '.'
+def positive():
+ positive_sentences = [trans_verb(nom_noun(), acc_noun()) + '.', verb_of_thought(nom_noun())]
+ return random.choice(positive_sentences)
+def question():
+ questions = ['зачем ' + trans_verb(nom_noun(), acc_noun()) + '?', 'почему ' + verb_of_thought(nom_noun())]
+ return random.choice(questions)
+def negative():
+ negative_sentences = [verb_of_thought_negative(nom_noun(), acc_noun()), trans_verb_negative(nom_noun(), acc_noun())]
+ return random.choice(negative_sentences)
+def conditional():
+ with open('transverbs.txt','r', encoding = 'utf-8') as f:
+ transverbs = f.read().split('\n')
+ conditional_sentences = ['если ' + positive().strip('.') + ', то ' + nom_noun() + ' ' + random.choice(transverbs)+ ' ' + acc_noun(), 'если ' + positive().strip('.') + ', то ' + nom_noun() + ' не ' + random.choice(transverbs)+ ' ' + acc_noun(), 'если ' + negative().strip('.') + ', то ' + nom_noun() + ' ' + random.choice(transverbs)+ ' ' + acc_noun(), 'если ' + negative().strip('.') + ', то ' + nom_noun() + ' не ' + random.choice(transverbs)+ ' ' + acc_noun()]
+ return random.choice(conditional_sentences)
+def imperative():
+ with open('imperatives.txt','r', encoding = 'utf-8') as f:
+ imperatives = f.read().split('\n')
+ imperative_sentences = ['пусть ' + positive(), 'пусть ' + negative(), 'пусть ' + conditional(), random.choice(imperatives) + ' ' + acc_noun()]
+ return random.choice(imperative_sentences)
+def main():
+ sentences = [positive(), question(), negative(), conditional(), imperative()]
+ random.shuffle(sentences)
+ for i in range(5):
+ print(sentences[i].capitalize())
+if __name__ == '__main__':
+ main()
+
+
+
+a = input("Введите первое число. ")
+a = float(a)
+b = input("Введите второе число. ")
+b = float(b)
+c = input("Введите третье число. ")
+c = float(c)
+if b:
+ if a%b == c:
+ print("a даёт остаток c при делении на b")
+ else:
+ print("a не даёт остаток c при делении на b")
+else:
+ print("Делите на ноль сами!")
+if (a*c)+b == 0:
+ print("c является решением линейного уравнения ax + b = 0")
+else:
+ print("c не является решением линейного уравнения ax + b = 0")
+list_list = [['l'],['s'],['d']]
+def el_0(any_list):
+ return any_list[0]
+a = ' '.join([el_0(el) for el in list_list])
+print(a)
+
+b = list(map(el_0, list_list))
+print(b)
+
+b = ' '.join(list(map(el_0, list_list)))
+print(b)
+
+c = ' '.join(list(map(lambda any_list: any_list[0], list_list)))
+print(c)
+
+number = input("print any number")
+square = int(number)**0.5
+if square/1 == square//1:
+ print ("yes")
+else:
+ print ("no")
+
+
+
+import codecs, re
+def open_file(title):
+ a = codecs.open(title, 'r', 'utf-8')
+ words = [word.strip(' ,.?!-:;').lower() for word in a.read().split()]
+ return words
+def find_bigramm(words):
+ text = ''
+ for word in words:
+ text += word + ' '
+ found = 0
+ for x in range(len(words)-1):
+ bigramm = words[x] + ' ' + words[x+1]
+ m = re.findall(bigramm, text, flags = re.U)
+ if len(m) > 2:
+ print(True)
+ found = 1
+ break
+ if found == 0:
+ print(False)
+def main():
+ f = open_file('text.txt')
+ z = find_bigramm(f)
+if __name__ == "__main__":
+ main()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import os, codecs
+def open_file(title):
+ a = codecs.open(title, 'r', 'utf-8')
+ words = [word.strip(' ,.?!-:;').lower() for word in a.read().split()]
+ return words
+def count_word_frequency(words):
+ freq_dict = {}
+ for word in words:
+ try:
+ freq_dict[word] += 1
+ except KeyError:
+ freq_dict[word] = 1
+ return freq_dict
+def find_max_keys(dict_num_values, amount):
+ values_list = dict_num_values.values()
+ max_values = []
+ i = 0
+ while i < amount:
+ local_max = max(values_list)
+ max_values.append(local_max)
+ if local_max != 1:
+ values_list = [x for x in values_list if x != local_max]
+ i += 1
+ max_keys = []
+ for key in dict_num_values:
+ if dict_num_values[key] in max_values:
+ max_keys.append(key)
+ return max_keys
+def extract_words_from_txt_in_folder(path):
+ words = []
+ for root, dirs, files in os.walk(path):
+ for f in files:
+ if len(f.split('.')) == 2:
+ file_name = f.split('.')[0]
+ file_ext = f.split('.')[1]
+ if file_ext == 'txt':
+ words += open_file(os.path.join(root, f))
+ return words
+def main():
+ print(find_max_keys(count_word_frequency(extract_words_from_txt_in_folder('.')),10))
+if __name__ == "__main__":
+ main()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import random
+with open('words.txt','r', encoding = 'utf-8') as f:
+ lines = f.readlines()
+ lenlines = len(lines)
+ random.shuffle(lines)
+ score = 0
+ for line in lines:
+ line = line.strip()
+ word, hint = line.split(' ',1)
+ response = input('Какое слово я загадала?\n'+
+ 'Подсказка: '+hint+' ')
+ if response == word:
+ print('Правильно!')
+ score += 1
+ else:
+ print('Нет, слово было', word)
+with open('scores.txt', 'w', encoding = 'utf-8') as n:
+ percent = score/lenlines*100
+ n.write('Вот результат: ')
+ n.write(str(percent)+'%')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import codecs
+def open_file(file_name):
+ f = codecs.open(file_name, 'r', 'utf-8')
+ words = []
+ for line in f:
+ line = line.strip()
+ words += line.split()
+ for word in words:
+ word = word.strip('.,!?:;()\'\"1234567890')
+ word = word.lower()
+ return words
+def bigramms(words):
+
+ bi = create_list(words)
+ dic = {}
+ for j in bi:
+ if j not in dic:
+ dic[j] = 1
+ else:
+ dic[j] += 1
+ answer = ''
+ answer = [n+'\r\n' for n in dic]
+ for key in dic:
+ if dic[key] > 2:
+ answer = True
+ else:
+ answer = False
+ print(answer)
+ return answer
+def create_list(words):
+ bi = []
+ for i in range(len(words)):
+ if i < len(words) - 1:
+ j = i+1
+ bi.append(words[i] + ' ' + words[j])
+ return bi
+words = open_file('text.txt')
+bigramms(words)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import re
+def main():
+ with open ('china space programm.txt', 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ reg = '«[А-ЯЁа-яё]+?-[1-9]+»'
+ all_matches = re.findall(reg, text)
+ pure_names =[]
+ for i in range(len(all_matches)):
+ if re.sub(r'-[1-9]+', '', all_matches[i]) not in pure_names:
+ pure_names.append(re.sub(r'-[1-9]+', '', all_matches[i]))
+ all_matches += pure_names
+ print(all_matches)
+if __name__ == '__main__':
+ main()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def opentext(fname):
+ forms = []
+ with open (fname, 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ text = text.lower()
+ forms = text.split()
+ for i in range(len(forms)):
+ forms[i] = forms[i].strip('.,?*()«»')
+ return forms
+
+
+
+def first_letter(letter, fname = 'text.txt'):
+ starting_with_letter = []
+ forms = opentext(fname)
+ for i in range(len(forms)):
+ if forms[i][0] == letter:
+ starting_with_letter.append(forms[i])
+ return starting_with_letter
+
+
+
+def questions():
+ fname = input('Введите имя файла: ')
+ letter = input('Введите букву: ')
+ number = int(input('Введите целое число: '))
+ starting_with_letter = first_letter(letter, fname)
+ answer = []
+ for i in range(len(starting_with_letter)):
+ if len(starting_with_letter[i]) > number:
+ answer.append(starting_with_letter[i])
+ return answer
+
+
+
+def adjectives(fname):
+ forms = opentext(fname)
+ adj = []
+ for i in range(len(forms)):
+ if len(forms[i]) > 2:
+ if forms[i][-1] == 'й':
+ if forms[i][-2] == 'o' or forms[i][-2] == 'ы' or forms[i][-2] == 'и':
+ if i != len(forms)-1:
+ adj.append(forms[i]+' '+forms[i+1])
+ else:
+ adj.append(forms[i])
+ elif forms[i][-1] == 'я':
+ if forms[i][-2] == 'а' or forms[i][-2] == 'я':
+ if i != len(forms)-1:
+ adj.append(forms[i]+' '+forms[i+1])
+ else:
+ adj.append(forms[i])
+ elif forms[i][-1] == 'е':
+ if forms[i][-2] == 'o' or forms[i][-2] == 'е':
+ if i != len(forms)-1:
+ adj.append(forms[i]+' '+forms[i+1])
+ else:
+ adj.append(forms[i])
+ return adj
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+with open('information.txt', 'w', encoding = 'utf-8') as n:
+ name = input('Как Вас зовут? ')
+ n.write(name+'\n')
+ age = input('Сколько Вам лет? ')
+ n.write(str(age)+'\n')
+ color = input('Какой у Вас любимый цвет? ')
+ n.write(color+'\n')
+ musician = input('Какой у Вас любимый исполнитель? ')
+ n.write(musician+'\n')
+ dream = input('Какая у Вас мечта? ')
+ n.write(dream+'\n')
+with open('information about Mary.txt','r', encoding = 'utf-8') as f:
+ info = f.readlines()
+ for line in range(len(info)):
+ info[line] = info[line].strip()
+ response = input('Как Вашего соседа зовут? ')
+ if response == info[0]:
+ print('Правильно!')
+ else:
+ print('Нет, его зовут '+info[0]+'.')
+ response = input('Сколько Вашему соседу лет? ')
+ if str(response) == info[1]:
+ print('Правильно!')
+ else:
+ print('Нет, ему '+info[1]+' лет.')
+ response = input('Какой у Вашего соседа любимый цвет?')
+ if response == info[2]:
+ print('Правильно!')
+ else:
+ print('Нет, его любимый цвет - '+info[2]+'.')
+ response = input('Какой у Вашего соседа любимый исполнитель?')
+ if response == info[3]:
+ print('Правильно!')
+ else:
+ print('Нет, его любимый исполнитель - '+info[3]+'.')
+ response = input('Какая у Вашего соседа мечта?')
+ if response == info[4]:
+ print('Правильно!')
+ else:
+ print('Нет, его мечта - '+info[4]+'.')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+number = input("What's your phone number")
+if '+1' in number or number.endswith("2"):
+ pass
+elif '+7' in number or number.startswith('8'):
+ print("Как дела в России?")
+elif '+4' in number:
+ print("Как дела в Англии?")
+else:
+ print("Как дела в мире?")
+
+
+
+
+
+
+
+
+import os, codecs
+from math import log
+def preprocess(text):
+ punct = '[.,!«»?&@"$\[\]\(\):;%
+ tabs = '\t\n'
+ text_wo_punct = re.sub(punct, '', text.lower())
+ text_wo_punct = re.sub(tabs, '', text_wo_punct)
+ words = text_wo_punct.strip().split()
+ return words
+def count_tf(word, text):
+ n = text.count(word)
+ return n/len(text)
+def count_df(word, texts):
+
+
+
+
+ i = [True for text in texts if word in text]
+ df = len(i)
+ return df
+def count_idf(word, texts):
+ df = count_df(word, texts)
+ try:
+ idf = len(texts)/df
+ except ZeroDivisionError:
+ return 0
+ return idf
+def count_tfidf(word, text, texts):
+ tf = count_tf(word, text)
+ idf = count_idf(word, texts)
+ tfidf = log(tf, 10) * log(idf, 10)
+ return tfidf
+def extract_textS_from_folder(path):
+ texts = []
+ for root, dirs, files in os.walk(path):
+ for f in files:
+ with open(os.path.join(root, f) , "r", encoding = 'utf-8') as t:
+ content = t.read
+ text = preprocess(content)
+ texts.append(text)
+ return texts
+def keywords(text, texts):
+ keywords = {}
+ dic_tfidf = {}
+ for word in text:
+ if word in dic_tfidf:
+ continue
+ tfidf = count_tfidf(word, text, texts)
+ dic_tfidf[word] = tfidf
+ i = 0
+ for el in sorted(dic_tfidf, key = lambda x: dic_tfidf(x)):
+ if i > 5:
+ break
+ else:
+ i += 1
+ keywords[el] = dic_tfidf[el]
+ return keywords
+def main():
+ texts = extract_text_from_folder('wikipedia')
+ for t in texts:
+ kwords = keywords(t, texts)
+ for key in kwords:
+ print(key, kwords[key])
+if __name__ == "__main__":
+ main()
+
+
+
+
+import os
+import re
+from math import log
+def preprocessing(text):
+ punct = '[.,_!«»?&@"$\/\\[\]\(\):;%
+ tabs = '\n\t\s'
+ num = '[0-9]'
+ text_wo_punct = re.sub(punct, '', text.lower())
+ text_wo_punct = re.sub(tabs, ' ', text_wo_punct)
+ text_wo_punct = re.sub(num, '', text_wo_punct)
+ words = text_wo_punct.strip().split()
+ return words
+def count_tf(word, text):
+ i = 0
+ for w in text:
+ if w == word:
+ i += 1
+
+ tf = i / len(text)
+ return tf
+def count_df(word, texts):
+ i = 0
+
+
+
+
+
+ i = [1 for text in texts if word in text]
+ df = sum(i)
+ return df
+def count_idf(word, texts):
+ df = count_df(word, texts)
+ idf = len(texts)/ (1 + df)
+ return idf
+def count_tfidf(word, text, texts):
+ tf = count_tf(word, text)
+ idf = count_idf(word, texts)
+ tfidf = log(tf, 10) * log(idf, 10)
+ return tfidf
+def keywords(text, texts):
+ dic_tfidf = {}
+ kwords = {}
+ for word in text:
+ if word in dic_tfidf:
+ continue
+ tfidf = count_tfidf(word, text, texts)
+ dic_tfidf[word] = tfidf
+ i = 0
+ for el in sorted(dic_tfidf, key=lambda x: dic_tfidf[x]):
+ if i > 5:
+ break
+ else:
+ i += 1
+ kwords[el] = dic_tfidf[el]
+ return kwords
+def main():
+ texts = {}
+ for root, dirs, files in os.walk('wikipedia'):
+ for f in files:
+ with open(os.path.join(root, f), 'r', encoding='utf-8') as t:
+ content = t.read()
+ text = preprocessing(content)
+ texts[f] = text
+ raw_texts = list(texts.values())
+ for t in texts:
+ print('\nИзвлекаем ключевые слова для текста "{}"'.format(t.split('.')[0]))
+ kwords = keywords(texts[t], raw_texts)
+ for key in kwords:
+ print (key, kwords[key])
+if __name__ == '__main__':
+ main()
+import re
+import os
+from math import log
+
+def open_words(fname):
+ forms = []
+ with open (fname, 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ text = text.lower()
+ punct = '[.,?!|:;*№\"\'—@
+ text = re.sub(punct, '', text)
+ text = re.sub('[\n\t]', ' ', text)
+ forms = text.split()
+
+
+ return forms
+
+def make_freq(arr):
+ d = {}
+ for el in arr:
+ try:
+ d[el] += 1
+ except KeyError:
+ d[el] = 1
+ return d
+
+def make_bigrams(arr):
+ bigrams = []
+ for i in range(len(arr)-1):
+ bigr = arr[i] + ' ' + arr[i+1]
+ bigrams.append(bigr)
+ return bigrams
+
+def count_pmi(x, y):
+ try:
+ p_x = word_freq[x]/len(words)
+ except KeyError:
+ p_x = 0
+ try:
+ p_y = word_freq[x]/len(words)
+ except KeyError:
+ p_y = 0
+ try:
+ bigr = x + ' ' + y
+ p_xy = bigrams_freq[bigr]/len(bigrams)
+ except KeyError:
+ p_xy = 0
+ try:
+ pmi = log(p_xy/(p_x*p_y))
+ except ZeroDivisionError:
+ pmi = 0
+ return pmi
+
+def calculate_pmi():
+ pmis = {}
+ for bigr in bigrams:
+ x, y = bigr.split()
+ pmi = count_pmi(x, y)
+ pmis[bigr] = pmi
+ return pmis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def calculate_pmi_cats(word, cathegory):
+ p_word = freq_all[word]/len(words_all)
+ p_cat = 1/3
+ if cathegory == 'anek':
+ d = freq_anek
+ w = len(corpus_anek_words)
+ elif cathegory == 'izvest':
+ d = freq_izvest
+ w = len(corpus_izvest_words)
+ elif cathegory == 'teh':
+ d = freq_teh
+ w = len(corpus_teh_words)
+ p_word_cat = d[word]/w
+ pmi = log(p_word_cat/(p_word*p_cat))
+ return pmi
+def main():
+ corpus_anek_words = []
+ corpus_izvest_words = []
+ corpus_teh_words = []
+ for root, dirs, files in os.walk('texts'):
+ if 'anekdots' in root:
+ for f in files:
+ corpus_anek_words += open_words(os.path.join(root, f))
+ if 'teh_mol' in root:
+ for f in files:
+ corpus_teh_words += open_words(os.path.join(root, f))
+ if 'izvest' in root:
+ for f in files:
+ corpus_izvest_words += open_words(os.path.join(root, f))
+ words = corpus_anek_words + corpus_teh_words + corpus_izvest_words
+ freq_anek = make_freq(corpus_anek_words)
+ freq_izvest = make_freq(corpus_izvest_words)
+ freq_teh = make_freq(corpus_teh_words)
+ freq_all = make_freq(words)
+ words_cathegory_dict = {}
+ for w in words:
+ i = 0
+ try:
+ if i < 100:
+ pmi_anek = calculate_pmi_cats(w, 'anek')
+ pmi_cats(w, 'anek')
+ pmi_izvest = calculate_pmi_cats(w, 'izvest')
+ pmi_teh = calculate_pmi_cats(w, 'teh')
+ pmi_max = max(pmi_anek, pmi_izvest, pmi_teh)
+ if pmi_max == pmi_anek:
+ words_cathegory_dict[w] = 'anek'
+ if pmi_max == pmi_teh:
+ words_cathegory_dict[w] = 'teh'
+ if pmi_max == pmi_anek:
+ words_cathegory_dict[w] = 'teh'
+ i += 1
+ except KeyError:
+ pass
+ print(words_cathegory_dict)
+if __name__ == '__main__':
+ main()
+
+
+
+
+import shutil
+import os
+name = input('Print any sentence. ')
+words = name.split()
+path = words[0]
+for i in range(1, len(words)):
+ path = os.path.join(path, words[i])
+os.makedirs(path)
+
+
+
+import shutil
+import os
+num = int(input('Print any natural number. '))
+for i in range(num):
+ name = str(i+1)
+ os.makedirs(name)
+ for a in range(i+1):
+ filename = os.path.join(name,str(a+1)+'.txt')
+ with open(filename, 'w', encoding = 'utf-8') as f:
+ f.write('')
+
+import os
+import shutil
+filelist = [f for f in os.listdir() if os.path.isfile(f)]
+print(filelist)
+
+import os
+import shutil
+path = os.path.abspath('.')
+path2 = os.getcwd()
+universalpath = os.path.join('texts', '1.txt')
+exists = os.path.exists('texts\1.txt')
+exists2 = os.path.exists(os.path.join('texts', '1.txt'))
+filelist = os.listdir(r'C:\My\HSE\programming\HSE_programming\HSE_programming\CWs\CW13\texts')
+s = 'Hello! '
+i = 1
+for f in filelist:
+ if f.endswith('.txt'):
+ with open(f, 'a', encoding = 'utf-8') as w:
+ w.write(s*1)
+ i += 1
+texts = [f for f in os.listdir(r'C:\My\HSE\programming\HSE_programming\HSE_programming\CWs\CW13\texts') if f.endswith('.txt')]
+if not os.path.exists('ab'):
+ os.mkdir('ab')
+if not os.path.exists(r'a\long\long\long\long\path'):
+ os.makedirs(r'a\long\long\long\long\path')
+if os.path.exists('ab') and not os.path.exists('abc'):
+ os.rename('ab', 'abc')
+if os.path.exists(r'a\long\long\long') and not os.path.exists(r'a\long\long\longer'):
+ os.rename(r'a\long\long\long', r'a\long\long\longer')
+isfile = os.path.isfile(r'texts\1.txt')
+isdir = os.path.isdir(r'a\long\long')
+print(os.listdir())
+shutil.copy(r'texts\1.txt', r'newcorpus')
+shutil.copytree(r'texts', r'corpus')
+shutil.move(r'texts\2.txt', r'newcorpus')
+os.remove(r'corpus\2.txt')
+shutil.rmtree('newcorpus')
+shutil.rmtree('a')
+shutil.rmtree('abc')
+
+
+
+
+import os
+import shutil
+directory = input('Print any path working in your OS. ')
+if os.path.exists(directory):
+ filelist = [f for f in os.listdir() if os.path.isfile(f)]
+ extlist = []
+ for f in filelist:
+ ext = f.split('.')[1]
+ if ext not in extlist:
+ extlist.append(ext)
+ extdict = {}
+ for ext in extlist:
+ for f in filelist:
+ if f.endswith(ext):
+ if ext not in extdict:
+ extdict[ext] = 1
+ else:
+ extdict[ext] +=1
+else:
+ directory = os.getcwd()
+print(extdict)
+
+
+import re
+def main():
+ with open ('hse.html', 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ card_reg = ''
+ if re.search(card_reg, text):
+ card = re.search(card_reg, text).group()
+ t_reg = 'Преподаватели(?:.|\n)*?(.+?)<'
+ if re.search(t_reg, card):
+ profs = re.search(t_reg, card).group(1)
+ with open ('data about teachers.txt', 'a', encoding = 'utf-8') as f:
+ f.write(profs)
+ else:
+ print('No data about the nuber of professors found!')
+ with open ('data about teachers.txt', 'a', encoding = 'utf-8') as f:
+ f.write('No data about the nuber of professors found!')
+ else:
+ print('No card found in this article!')
+ with open ('data about teachers.txt', 'a', encoding = 'utf-8') as f:
+ f.write('No card found in this article!')
+if __name__ == '__main__':
+ main()
+import os
+import re
+def tagsaway(sentence):
+ s = ''
+ for word in sentence:
+ word = re.sub(u'<.+?>', u'', word)
+ s = s + word + ' '
+ return s
+def get_bigramms(text):
+ bi = []
+ text = text.split('')
+ for i, word in enumerate(text):
+ if 'gr="A=' and 'gen' in word:
+ if i+1 < len(text):
+ w = text[i+1]
+ if 'gr="S,' and 'gen' in w:
+ result1 = re.search('(.+?)', word)
+ result2 = re.search('(.+?)', w)
+ bi.append([result1.group(1), result2.group(1), tagsaway(text)])
+ return bi
+def newfile(arr):
+ f = open('bigramms.txt', 'w', encoding = 'utf8')
+ s = ''
+ for i in arr:
+ s = i[0] + '\t' + i[1] + '\t' + i[2] + '\n'
+ f.write(s)
+ s = ''
+ f.close
+def filework():
+ folder = 'news'
+ for file in os.listdir(folder):
+ with open(os.path.join(folder, file)) as text:
+ text = text.read().split('')
+ for se in text:
+ newfile(get_bigramms(se))
+def main ():
+ filework()
+main()
+
+
+import os
+import re
+def get_author (text):
+ for word in text:
+ if 'name="author"' in word:
+ result = re.search('content="(.+?)"', word)
+ return result.group(1)
+def get_day (text):
+ for word in text:
+ if 'name="created"' in word:
+ result = re.search('content="(.+?)"', word)
+ return result.group(1)
+def file_inf():
+ ff = []
+ folder = 'news'
+ for file in os.listdir(folder):
+ with open(os.path.join(folder, file)) as text:
+ text = text.read().split('<')
+ ff.append([file, get_author(text), get_day(text)])
+ return ff
+def newfile(arr):
+ f = open('files_info.csv', 'w', encoding = 'utf8')
+ f.write('Название файла;Автор;Дата создания текста\n')
+ s = ''
+ for i in arr:
+ s = i[0] + ';' + i[1] + ';' + i[2] + '\n'
+ f.write(s)
+ s = ''
+ f.close
+def main ():
+ ff = file_inf()
+ newfile(ff)
+main()
+import os
+import re
+def files():
+ ff = {}
+ folder = 'news'
+ for file in os.listdir(folder):
+ with open(os.path.join(folder, file)) as text:
+ words = re.findall('', text.read())
+ ff[file] = len(words)
+ return ff
+def newfile(dic):
+ f = open('words_in_files.txt', 'w', encoding = 'utf8')
+ s = ''
+ for k in dic:
+ s = k + '\t' + str(dic[k]) + '\n'
+ f.write(s)
+ s = ''
+ f.close
+def main ():
+ ff = files()
+ newfile(ff)
+main()
+import os
+def findanddel (folder):
+ for root, dirs, files in os.walk(folder, topdown = False):
+ for f in files:
+ os.remove(os.path.join(root, f))
+ for d in dirs:
+ os.remove(os.path.join(root, d))
+def main ():
+ folder = input()
+ findanddel (folder)
+main ()
+import os
+def draw ():
+ for root, dirs, files in os.walk ('.'):
+ for d in dirs:
+ print ('\t'*root.count('\\'), '--',d)
+ for f in files:
+ print ('\t'*root.count('\\'), f)
+def main ():
+ draw()
+main ()
+def pointsaway (file):
+ file = file.split()
+ for i, word in enumerate (file):
+ file[i] = file[i].strip('.,?!()*&^%$
+ file[i] = file[i].lower()
+ return file
+def words (file):
+ slova = {}
+ for word in file:
+ if word in slova:
+ slova[word] += 1
+ else:
+ slova[word] = 1
+ return slova
+def creation (dic):
+ f = open ('file.tsv', 'w', encoding = 'utf8')
+ arr = []
+ for k in dic:
+ arr.append(k)
+ arr.sort()
+ for i in arr:
+ f.write(i + '\t' + str(dic[i]) + '\n')
+ f.close()
+def main ():
+ f = open ('file.txt', 'r', encoding = 'utf8')
+ file = f.read()
+ f.close()
+ text = pointsaway (file)
+ semua = words (text)
+ creation (semua)
+main ()
+def pointsaway (file):
+ file = file.split()
+ for i, word in enumerate (file):
+ file[i] = file[i].strip('.,?!()*&^%$
+ file[i] = file[i].lower()
+ return file
+def creation (text):
+ f = open ('new.txt', 'w', encoding = 'utf8')
+ dic = {text[x]: x for x in range(0, len(text))}
+ arr = [k for k in dic]
+ arr.sort()
+ for i in arr:
+ f.write('{}\t{}\n'.format(i, str(dic[i])))
+ f.close()
+def main ():
+ f = open ('file.txt', 'r', encoding = 'utf8')
+ file = f.read()
+ f.close()
+ text = pointsaway (file)
+ creation (text)
+main ()
+import re
+def get_word (word):
+ result = re.search('.*?(\w+)', word)
+ if result:
+ return result.group(1)
+ else:
+ return None
+def find_ins (text):
+ inst = {}
+ for i, word in enumerate(text):
+ if 'gr="S' in word:
+ if 'ins' in word:
+ inst[i]=word
+ return inst
+def newfile (words, text):
+ f = open ('ins.txt', 'w', encoding = 'utf8')
+ s = ''
+ for k in words:
+ i = 0
+ j = 1
+ while i<3:
+ if get_word(text[k-j]) != None:
+ s = get_word(text[k-j])+ ' ' + s
+ i += 1
+ j += 1
+ else:
+ j += 1
+ s = s + '\t' + get_word(words[k]) + '\t'
+ i = 0
+ j = 1
+ while i<3:
+ if get_word(text[k+j]) != None:
+ s = s + ' ' + get_word(text[k+j])
+ i += 1
+ j += 1
+ else:
+ j +=1
+ f.write(s)
+ f.close
+def main ():
+ f = open ('/home/woods/Загрузки/text.xml', 'r', encoding = 'utf8')
+ file = f.read()
+ text = file.split('\n')
+ f.close()
+ ss = find_ins(text)
+ newfile (ss, text)
+main ()
+import re
+def find_and_count (file):
+ pos = {}
+ for word in file:
+ word = word.split('<')
+ for part in word:
+ result = re.search('.*?gr="(\w+)', part)
+ if result:
+ print (result.group(1))
+ if result.group(1) not in pos:
+ pos[result.group(1)] = 1
+ else:
+ pos[result.group(1)] += 1
+ return pos
+def newfile (dic):
+ f = open('pos.txt', 'w', encoding = 'utf8')
+ s = ''
+ for k in dic:
+ s = s + k + '\t' + str(dic[k]) + '\n'
+ f.write(s)
+ f.close
+def main ():
+ f = open ('/home/woods/Загрузки/text.xml', 'r', encoding = 'utf8')
+ file = f.read()
+ text = file.split('\n')
+ f.close()
+ pos = find_and_count(text)
+ newfile (pos)
+main ()
+import re
+
+def find_w (file):
+ words = re.findall('', file)
+ n = len(words)
+ return n
+def find_ana (file):
+ anas = re.findall('(.+?)', line)
+ if a:
+ if a.group(2) not in types:
+ types[a.group(2)] = 0
+ return types
+def countthem (file, types):
+ words = []
+ sum = 0
+ for key in types:
+ words.append(key)
+ for el in words:
+ for line in file:
+ if '"'+el+'"' in line:
+ sum += 1
+ types[el] = sum
+ sum = 0
+ return types
+def newfile (types):
+ s = ''
+ f = open('adj.txt', 'w', encoding = 'utf8')
+ for key in types:
+ s = s + key + '-' + str(types[key]) + '\n'
+ f.write(s)
+ f.close()
+def main():
+ text = filework()
+ dic = findthem(text)
+ dic = countthem (text, dic)
+ newfile(dic)
+main()
+import random
+file=open ('file_6.6.txt', 'r')
+def noun():
+ nouns=[]
+ for line in file:
+ if ' n ' in line:
+ line=line.split(' ')
+ nouns.append(line[0])
+ file.seek(0, 0)
+ return random.choice(nouns)
+def pronoun():
+ pronouns=[]
+ for line in file:
+ if ' pn ' in line:
+ line=line.split(' ')
+ pronouns.append(line[0])
+ file.seek(0, 0)
+ return random.choice(pronouns)
+def verb():
+ verbs=[]
+ for line in file:
+ if ' v ' in line:
+ line=line.split(' ')
+ verbs.append(line[0])
+ file.seek(0, 0)
+ return random.choice(verbs)
+def adjective ():
+ adjectives=[]
+ for line in file:
+ if ' adj ' in line:
+ line=line.split(' ')
+ adjectives.append(line[0])
+ file.seek(0, 0)
+ return random.choice(adjectives)
+def suborob (n, adj, pn):
+ x=random.randint(0,1)
+ if x==0:
+ return pn
+ else:
+ y=random.randint(0,1)
+ if y==0:
+ return n+' '+adj
+ else:
+ return n+' '+pn
+def declarative (subj, v, obj):
+ return subj.capitalize()+' '+v+' '+obj+'.'
+def question (subj, v):
+ x=random.randint (0, 1)
+ if x==0:
+ return 'Apa'+' '+subj+' '+v+'?'
+ else:
+ return 'Siapa'+' '+v+'?'
+def negative (subj, v, obj):
+ x=random.randint(0, 1)
+ if x==0:
+ return subj.capitalize()+' tidak '+v+' '+obj+'.'
+ else:
+ return subj.capitalize()+' bukan '+obj+'.'
+def imperative (v, obj):
+ x=random.randint(0,1)
+ if x==0:
+ return v.capitalize()+' '+obj+'!'
+ else:
+ return 'Jangan '+v+' '+obj+'!'
+def conditional (subj1, v1, obj1, subj2, v2, obj2):
+ return 'Kalau '+subj1+' '+v1+' '+obj1+', '+subj2+' '+v2+' '+obj2+'.'
+def sequence ():
+ a=[1, 2, 3, 4, 5]
+ b=[]
+ for i in range (5):
+ x=random.choice(a)
+ while x in b:
+ x=random.choice(a)
+ b.append(x)
+ return b
+def text():
+ seq=sequence()
+ for i in range (5):
+ if seq[i]==1:
+ print(declarative(suborob(noun(), adjective(), pronoun()), verb(), suborob(noun(), adjective(), pronoun())))
+ elif seq[i]==2:
+ print (question(suborob(noun(), adjective(), pronoun()), verb()))
+ elif seq[i]==3:
+ print (negative(suborob(noun(), adjective(), pronoun()), verb(), suborob(noun(), adjective(), pronoun())))
+ elif seq[i]==4:
+ print (imperative(verb(), suborob(noun(), adjective(), pronoun())))
+ else:
+ print (conditional(suborob(noun(), adjective(), pronoun()), verb(), suborob(noun(), adjective(), pronoun()), suborob(noun(), adjective(), pronoun()), verb(), suborob(noun(), adjective(), pronoun())))
+text()
+file.close()
+import re
+def search (text):
+ otr = re.search ('\n| Отряд: | \n(.+?) | \n
', text)
+ if otr:
+ result = otr.group(3)
+ return result
+def main ():
+ f = open('file_10.6.html', 'r', encoding = 'utf8')
+ file = f.read()
+ f.close()
+ ans = search (file)
+ print (ans)
+main()
+def pointsaway (file):
+ file = file.replace('?!', '.')
+ file = file.split('.')
+ for i, word in enumerate (file):
+ file[i] = file[i].replace('.,?!()*&^%$
+ file[i] = file[i].replace('-- ', ' ')
+ file[i] = file[i].lower()
+ return file
+def tenplus (text):
+ for sentence in text:
+ sentence = sentence.split()
+ n=0
+ s=0
+ for word in sentence:
+ word = word.strip('.,?!()*&^%$
+ s+=len(word)
+ n+=1
+ if n>10:
+ print ("Это предложение со словами длины %s"%(str(round(s/n, 1))))
+def main ():
+ f = open ("file_12.6.txt", "r", encoding = "utf8")
+ file = f.read()
+ f.close()
+ text = pointsaway (file)
+ tenplus (text)
+main ()
+import random
+def intothedic (file):
+ dic={}
+ for line in file:
+ line = line.split(';')
+ for j, word in enumerate(line):
+ line[j] = word.strip('\n')
+ dic[line[0]] = line[1]
+ return dic
+def youchoose (dic):
+ keys = []
+ for key in dic:
+ keys.append(key)
+ return random.choice(keys)
+def thegameison (noun, dic):
+ for key in dic:
+ if key == noun:
+ hint = dic[key]
+ n=key
+ break
+ print (hint, '...')
+ for i in range (3):
+ if input() == n:
+ print ('Победа!')
+ break
+ else:
+ if i == 0:
+ print ('Ещё 2 попытки')
+ continue
+ elif i == 1:
+ print ('Ещё 1 попытка')
+ continue
+ else:
+ print ('GAME OVER')
+f = open('file_8.6.csv', 'r', encoding = 'utf8')
+file = f.readlines()
+f.close()
+words = intothedic(file)
+word = youchoose(words)
+thegameison(word, words)
+import re
+def pointsaway (file):
+ file = file.split()
+ for i, word in enumerate (file):
+ file[i] = file[i].strip('.,?!()*&^%$
+ file[i] = file[i].lower()
+ return file
+def findverbs (file):
+ verbs = []
+ for word in file:
+ if re.search ('загру(з(и.*|ят.*)|ж(у.*|ен.*))', word) != None:
+ if word not in verbs:
+ verbs.append(word)
+ return verbs
+f = open ('file_9.6.txt', 'r', encoding = 'utf8')
+file = f.read()
+f.close()
+file = pointsaway(file)
+verbs = findverbs(file)
+print (verbs)
+def filework ():
+ f = open('corpus.txt', 'r', encoding = 'utf8')
+ file = f.readlines()
+ f.close()
+ return file
+def newfile (text):
+ f = open('lines.txt', 'w', encoding = 'utf8')
+ f.write(str(len(text)))
+ f.close
+def main():
+ text = filework()
+ newfile(text)
+main()
+import os
+def names(array):
+ names = []
+ for name in array:
+ if os.path.isfile(name):
+ names.append(name)
+ return names
+def haspoints(array):
+ points = ',!_-'
+ s = 0
+ su = 0
+ for name in array:
+ for c in name:
+ if c in points:
+ s += 1
+ if s > 0:
+ su += 1
+ s = 0
+ print ("Знаки препинания есть в названии такого количества файлов: ", su)
+def main():
+ files = names (os.listdir('.'))
+ print (os.listdir('.'))
+ haspoints (files)
+main()
+a=input ('Введите число ')
+for i in range (1, 11):
+ print (i, '*', a, '=', i*int(a))
+xs=[]
+for i in range (7):
+ xs.append(int(input()))
+for i in range (7):
+ if xs[i]>0:
+ for j in range (xs[i]):
+ print ('x', end='')
+ print ('\n')
+ else:
+ print ('\n')
+word=input()
+l=len(word)
+while l>0:
+ word=list(word)
+ x=word.pop(0)
+ print (''.join(word))
+ l=len(word)
+def pointsaway (file):
+ file = file.split()
+ for i, word in enumerate (file):
+ file[i] = file[i].strip('.,?!()*&^%$
+ file[i] = file[i].lower()
+ return file
+def findomni (file):
+ omni = []
+ for word in file:
+ if word.startswith('omni'):
+ w = word.replace('omni', '')
+ omni.append([word, w])
+ return omni
+def findwords (array, file):
+ n = 0
+ m = 0
+ for i, k in enumerate (array):
+ for word in file:
+ if word == array[i][0]:
+ n += 1
+ if word == array[i][1]:
+ m += 1
+ print (array[i][0], n, '-', array[i][1], m)
+ n = 0
+ m = 0
+def main ():
+ name = input('Введите имя файла ')
+ f = open (name, "r")
+ file = f.read()
+ f.close()
+ file = pointsaway (file)
+ findwords(findomni(file), file)
+main()
+import re
+def filework():
+ f = open('corpus.txt', 'r', encoding = 'utf8')
+ file = f.readlines()
+ f.close()
+ return file
+def findthem (file):
+ types = {}
+ for line in file:
+ a = re.search('(.+?)', line)
+ if a:
+ if a.group(2) not in types:
+ types[a.group(2)] = 0
+ return types
+def countthem (file, types):
+ words = []
+ sum = 0
+ for key in types:
+ words.append(key)
+ for el in words:
+ for line in file:
+ if '"'+el+'"' in line:
+ sum += 1
+ types[el] = sum
+ sum = 0
+ return types
+def newfile (types):
+ s = ''
+ f = open('types.txt', 'w', encoding = 'utf8')
+ for key in types:
+ s = s + key + '\n'
+ f.write(s)
+ f.close()
+def main():
+ text = filework()
+ dic = findthem(text)
+ dic = countthem (text, dic)
+ newfile(dic)
+main()
+capital='АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
+s=0
+cap=0
+f=open('file_5.6.txt', 'r', encoding='utf8')
+file=f.readlines()
+l=len(file)
+for i in range (0, l):
+ file[i]=file[i].split(' ')
+for i in range (0, l):
+ m=len(file[i])
+ for j in range (0, m):
+ if file[i][j][0] in capital:
+ cap+=1
+ s+=1
+print ((cap/s)*100)
+f.close()
+import xml.etree.ElementTree as a
+from os import walk
+def sent(filename):
+ tree = a.parse('./news/'+file)
+ root = tree.getroot()
+ tmp = root.findall('.//se')
+ return(len(tmp))
+def move(res,filename):
+ res_file = open(filename, 'w')
+ for item in res:
+ res_file.write(item+'\n')
+f = []
+words = []
+p = './news';
+for (dirpath, dirnames, filenames) in walk(p):
+ f.extend(filenames)
+ break
+for file in f:
+ words.append(file+'\t'+str(sent(file)))
+move(words,'counted.txt')
+n=[]
+while True:
+ word = input ('word:')
+ if word ==(''):break
+ elif word.endswith ('tur'):
+ n.append(word)
+ print ('/n'. join(n))
+d={'Germany':'Berlin','France':'Paris',
+ 'USA':'Washington DC',
+ 'Russia':'Moscow'}
+for key in d:
+ print (key+"*"+d[key])
+def capital(a):
+ a=input("Country:")
+ if a in d:
+ return (d[a])
+ else: print ("oops")
+def revert ():
+ k={}
+ countries=d.keys()
+ for key in countries:
+ k[d[key]]=key
+ return (k)
+a=revert()
+print(a)
+
+with open ('fr.txt', 'r', encoding = 'utf-8') as a:
+ text=a.readlines()
+ for line in text:
+ if 'союз' in line:
+ print (line)
+n = input("WORD: ")
+m = len(n)//2
+print (n[:m], n[:m-1:(-1)])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import os
+import shutil
+name=input ('напишите што-нибудь')
+f_name=name.replace(' ', '\\')
+os.makedirs(f_name)
+
+
+
+
+
+n = input ('word:')
+for i in range (len(n)):
+ print(n [-i-1::])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import re
+def open_html('xenokeryx.html'):
+ with open ('xenokeryx.html', 'r', encoding='utf-8') as f:
+ content=f.read()
+ return content
+def find_links (content):
+ reg=r'(.*?)'
+ links=re.findall (reg, content)
+ return links
+text=open_html ('xenokeryx.html')
+links=find_links(text)
+for link in links [:20]:
+ print (link[1], '-->', link[0])
+a=open (input(), 'r', encoding='utf-8')
+b=0
+c=0
+for line in a:
+ arr=line.split()
+ b=b+len(arr)
+ for d in arr:
+ if len(d)>10:
+ c=c+1
+ a.close()
+ e=c/b*100
+ print (e, '%')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import os
+def sup():
+ for root,dirs,files in os.walk('.'):
+ num=root.count('\\')
+ root+ root.split('\\')[-1]
+ print ('\t'*(num), root, sep='--')
+ for f in files:
+ print ('\t'*(num+1), f)
+sup()
+def opentext (file.txt):
+ forms = []
+ with open (file.txt, 'r', encoding='utf-8') as a:
+ text=a.read()
+ forms=text.split()
+ for i in range(len(forms)):
+ forms[i]=forms[i].strip(.,?!:;())
+ return forms
+def word ():
+ a=opentext(file.txt)
+ b=[]
+ for i in range (len(a)):
+ if a[i][-1]=='s':
+ if a[i][-2]=='u':
+ if a[i][-3]=='o':
+ b.append(a[i])
+ print (b)
+ c=b.split()
+ d=str.count(c)
+ return d
+import random
+def noun ():
+ file=open('Mnoun.txt', 'r', encoding='utf-8')
+ f=readlines()
+ nouns=[]
+ for line in f:
+ nouns.append(line.split(" "))
+ return random.choise(nouns)
+def verb ():
+ file=open ('verb1.txt', 'r', encoding='utf-8')
+ f=readlines()
+ verbs=[]
+ for line in f:
+ verbs.append(line.split(" "))
+ return random.choise(verbs)
+def adj ():
+ file=open ('adj.txt', 'r', encoding='utf-8')
+ f=readlines()
+ adjectives=[]
+ for line in f:
+ adjectives.append(line.split(" "))
+ return random.choise(adjectives)
+def noun2 ():
+ file=open ('noun2.txt','r', encoding='utf-8')
+ f=readlines()
+ plnouns=[]
+ for line in f:
+ plnouns.append(line.split(" "))
+ return random.choise(plnouns)
+def conj():
+ conjs=["и", "или", "но", "да", "однако", "зато", "когда", "пока", "потому что", "чтобы", "то есть"]
+ return "," + random.choise(conjs)
+def noun3 ():
+ file=open ('noun3.txt', 'r', encoding='utf-8')
+ f=readlines ()
+ fnouns=[]
+ for line in f:
+ fnouns.append (line.split(" "))
+ return random.choise(fnouns)
+def 2verb ():
+ file=open ('2verb.txt', 'r', encoding ='utf-8')
+ f=readlines ()
+ 2verbs=[]
+ for line in f:
+ 2verbs.append (line.split(" "))
+ return random.choise (2verbs)
+def sen ():
+ return (noun+" "+verb+" "+adj+" "+noun2+" "+conj+" "+noun3+" "+2verb+"."
+for i in range(5):
+ print (sen())
+import xml.etree.ElementTree as a
+from os import walk
+def sent(filename):
+ tree = a.parse('./news/'+file)
+ root = tree.getroot()
+ tmp = root.findall('.//se')
+ return(len(tmp))
+def move(res,filename):
+ res_file = open(filename, 'w')
+ for item in res:
+ res_file.write(item+'\n')
+f = []
+words = []
+p = './news';
+for (dirpath, dirnames, filenames) in walk(p):
+ f.extend(filenames)
+ break
+for file in f:
+ words.append(file+'\t'+str(sent(file)))
+move(words,'counted.txt')
+import xml.etree.ElementTree as a
+from os import walk
+import pandas as q
+def second(filename):
+ tree = a.parse('./news/'+file)
+ root = tree.getroot()
+ name = root.find(".//*[@name='author']")
+ topic = root.find(".//*[@name='topic']")
+ return(name.attrib['content']+":"+topic.attrib['content'])
+f = []
+d = []
+p = './news';
+for (dirpath, dirnames, filenames) in walk(p):
+ f.extend(filenames)
+for file in f:
+ tmp = second(file).split(':')
+ tmp_arr = [file,tmp[0],tmp[1]]
+ d.append(tmp_arr)
+df = q.DataFrame(d,columns=["название","автор","тема"])
+df.to_csv("2.csv", sep=';', encoding='windows-1251')
+import re
+def main ():
+ with open('F.xml', 'r', encoding='utf-8') as f:
+ text=f.readlines()
+ return text
+n=main ()
+m=len(n)
+print (m)
+import re
+dic = {}
+with open('f.xml') as f:
+ for row in f:
+ if(re.match(r'.*',row)):
+ arr = row.split("\"")
+ key = arr[3]
+ if key in dic:
+ dic[key]=dic[key]+1
+ else:
+ dic[key] = 1;
+ for key in dic.items():
+ print(key+" "+"\r\n")
+import os
+import shutil
+folder='.'
+print (os.listdir('.'))
+for f in os.listdir('.'):
+ with open (os.path.join(folder, f)) as text:
+ print('file: ', f)
+a=str_word_count(f, ' ')
+filelist = [f for f in os.listdir('.') if os.path.isfile(f)]
+if a>1:
+ print(filelist)
+def open_format(crab):
+ a = []
+ with open (crab.txt, 'r', encoding = 'utf-8') as f:
+ text = f.read()
+ text = re.sub('\.\.\.|[\.\?]', '!', text)
+ a = text.split('!')[:-1]
+ for i in range(len(a)):
+ a[i] = re.sub('[<>\*\.«»,\'\"]','', a[i])
+ a[i] = a[i].strip()
+ return a
+def repeat():
+ work=open_format (crab.txt)
+ words=re.findall(r'([a-zA-Z]+(?:[?:[\'-][a-zA-Z]+)*)',s)
+ res=[]
+ for x in range (a,z):
+ res.append (x)
+ print (res)
+import os
+os.listdir('.')
+file_tree=os.walk('.')
+names = {}
+for root, dirs, files in os.walk('.'):
+ for f in files:
+ name = f.split('.')[0]
+ if name not in names:
+ names[name]=1
+ print(len(names))
+import random
+def noun ():
+ file=open('Mnoun.txt', 'r', encoding='utf-8')
+ f=readlines()
+ nouns=[]
+ for line in f:
+ nouns.append(line.split(" "))
+ return random.choise(nouns)
+def verb ():
+ file=open ('verb1.txt', 'r', encoding='utf-8')
+ f=readlines()
+ verbs=[]
+ for line in f:
+ verbs.append(line.split(" "))
+ return random.choise(verbs)
+def adj ():
+ file=open ('adj.txt', 'r', encoding='utf-8')
+ f=readlines()
+ adjectives=[]
+ for line in f:
+ adjectives.append(line.split(" "))
+ return random.choise(adjectives)
+def noun2 ():
+ file=open ('noun2.txt','r', encoding='utf-8')
+ f=readlines()
+ plnouns=[]
+ for line in f:
+ plnouns.append(line.split(" "))
+ return random.choise(plnouns)
+def conj():
+ conjs=["и", "или", "но", "да", "однако", "зато", "когда", "пока", "потому что", "чтобы", "то есть"]
+ return "," + random.choise(conjs)
+def noun3 ():
+ file=open ('noun3.txt', 'r', encoding='utf-8')
+ f=readlines ()
+ fnouns=[]
+ for line in f:
+ fnouns.append (line.split(" "))
+ return random.choise(fnouns)
+def 2verb ():
+ file=open ('2verb.txt', 'r', encoding ='utf-8')
+ f=readlines ()
+ 2verbs=[]
+ for line in f:
+ 2verbs.append (line.split(" "))
+ return random.choise (2verbs)
+def sen ():
+ return (noun+" "+verb+" "+adj+" "+noun2+" "+conj+" "+noun3+" "+2verb+"."
+for i in range(5):
+ print (sen())
+import re
+def main():
+ with open ('lemon.html', 'r', encoding='utf-8') as f:
+ text=f.read()
+ a='+?
'
+ if re.search (a, text):
+ card = re.search(a, text).group()
+ b='Семейство(?:.|\n)*?(.+?)'
+ if re.search(b, a):
+ с = re.search(b, a).group(1)
+ with open ('family.txt', 'a', encoding = 'utf-8') as f:
+ f.write(с)
+ else:
+ print('Family type not found.')
+ with open ('family.txt', 'a', encoding = 'utf-8') as f:
+ f.write('Family type not found.')
+ else:
+ print('Error!')
+ with open ('family.txt', 'a', encoding = 'utf-8') as f:
+ f.write('Error!')
+import os
+import re
+def count_words():
+ with open('answer1.txt', 'w', encoding='utf-8') as fout:
+ for root, dirs, files in os.walk('./news'):
+ for f in files:
+ count = 0
+ with open(os.path.join(root, f), 'r') as fin:
+ f1 = fin.read().split()
+ for line in f1:
+ if '' in line:
+ count += 1
+ fout.write('%s \t %d \n' %(f, count))
+def annot():
+ with open('answer2.csv', 'w', encoding='utf-8') as fout:
+ fout.write('Название файла \t Автор \t Дата создания')
+ for root, dirs, files in os.walk('./news'):
+ for f in files:
+ with open(os.path.join(root, f), 'r') as fin:
+ f2 = fin.read()
+ nam = f
+ reg1 = ''
+ reg2 = ''
+ auth = re.search(reg1, f2).group(1)
+ date = re.search(reg2, f2).group(1)
+ fout.write('%s \t %s \t %s \n' %(f, auth, date))
+def bigramms():
+ with open('answer3.txt', 'w', encoding='utf-8') as fout:
+ for root, dirs, files in os.walk('./news'):
+ for f in files:
+ with open(os.path.join(root, f), 'r') as fin:
+ f3 = fin.read().split('\n')
+ reg = '(.+?)'
+ for indx, sentence in enumerate(f3):
+ if '' in sentence:
+ f3[indx] = [re.search(reg, sentence).group(1), re.search(reg, sentence).group(2)]
+ else:
+ f3.remove(sentence)
+ temp = True
+ for indx, word in enumerate(f3):
+ try:
+ if 'A' in word[0]:
+ if 'gen' in word[0]:
+ if 'S' in f3[indx + 1][0]:
+ if 'gen' in f3[indx + 1][0]:
+ fout.write('%s %s \n' %(word[1], f3[indx + 1][1]))
+ except IndexError:
+ temp = False
+def main():
+ count_words()
+ annot()
+ bigramms()
+if __name__ == '__main__':
+ main()
+def done_text():
+ f = open('ostin.txt', 'r', encoding='utf-8')
+ s = f.read().lower().split()
+ f.close()
+ for indx, word in enumerate(s):
+ s[indx] = word.strip('.,:;№-*!?/|\[]{}()\'"1234567890«»><')
+ return s
+def count_words(arr):
+ d = {}
+ for word in arr:
+ if word in d:
+ d[word] += 1
+ else:
+ d[word] = 1
+ return d
+def count_letters(arr):
+ dic = {}
+ alpha = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+ for letter in alpha:
+ dic[letter] = 0
+ for word in arr:
+ if word and word[0] in dic:
+ dic[word[0]] += 1
+ return dic
+def count_pos(arr):
+ dic = {key:ind for ind, key in enumerate(arr)}
+ return dic
+def create_antw(dic):
+ f = open('answer_keys2.tsv', 'w', encoding='UTF-8')
+ for key in sorted(dic):
+ f.write('{0}\t{1}\n'.format(key, str(dic[key])))
+ f.close()
+def main():
+ textik = done_text()
+ create_antw(count_pos(textik))
+if __name__ == '__main__':
+ main()
+my_num = 9
+your_num = int(input('Write a number from 1 to 10, please: '))
+if your_num == my_num:
+ print('You\'re lucky one :D')
+else:
+ if your_num > my_num:
+ print('Your number is too big')
+ else:
+ print('Your number is too small')
+ your_num = int(input('Try again: '))
+ if your_num == my_num:
+ print('You\'re lucky one :D')
+ else:
+ print('You\'re hopeless')
+import re
+def split_txt():
+ f = open('test1.txt', 'r', encoding='UTF-8')
+ s = f.read()
+ s.replace('\n', ' ')
+ s1 = re.sub('(\?|!|\.\.\.|([а-яa-z.]+ [а-яa-zА-ЯA-Z]{2,}\.))', '\\1^', s)
+ print(s1)
+def main():
+ split_txt()
+main()
+import re
+def find_space(fname):
+ f = open(fname, 'r', encoding='UTF-8')
+ s = f.read().split()
+ regex = '«[a-zA-ZА-Яа-я]+?-[0-9]'
+ wlist = re.findall(regex, s)
+ print(', '.join(wlist))
+def main():
+ find_space('test.txt')
+main()
+coinc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+while True:
+ s = input('Введите текст: ')
+ if s == '':
+ break
+ s = s.split()
+ res = ''
+ if s[0] == 'decode':
+ s.pop(0)
+ s = ' '.join(s)
+ for letter in s:
+ if letter == '!':
+ res += ' '
+ else:
+ for indx, i in enumerate(coinc):
+ if i == letter:
+ if i == 'A':
+ res += 'Z'
+ elif i == 'a':
+ res += 'z'
+ elif i == 'А':
+ res += 'Я'
+ elif i == 'а':
+ res += 'я'
+ else:
+ res += coinc[indx - 1]
+ else:
+ if s[0] == 'code':
+ s.pop(0)
+ s = ' '.join(s)
+ for letter in s:
+ if letter == ' ':
+ res += '!'
+ else:
+ for indx, i in enumerate(coinc):
+ if i == letter:
+ if i == 'Z':
+ res += 'A'
+ elif i == 'z':
+ res += 'a'
+ elif i == 'Я':
+ res += 'А'
+ elif i == 'я':
+ res += 'а'
+ else:
+ res += coinc[indx + 1]
+ print (res)
+print('Программа завершила свою работу!')
+words=[]
+check = True
+while check is True:
+ inp = input("Введите слово: ")
+ if inp == "":
+ check = False
+ else:
+ words.append(inp)
+for indx in range(len(words) - 1, -1, -1):
+ print(words[indx])
+check = True
+while check is True:
+ s = input("Введите текст: ")
+ if s == "":
+ check = False
+ else:
+ res = ""
+ for letter in s:
+ if ord(letter) == 90:
+ res += chr(65)
+ elif ord(letter) == 122:
+ res += chr(97)
+ elif ord(letter) == 1071:
+ res += chr(1040)
+ elif ord(letter) == 1103:
+ res += chr(1072)
+ else:
+ res += chr(ord(letter) + 1)
+ print (res)
+print("Программа завершила работу")
+names = ['Оля','Маша','Коля','Костя','Нина','Ира']
+surnames=['Кузнецова', 'Сидорова', 'Семенов', 'Иванов', 'Илларионова']
+if len(names) >= len(surnames):
+ for i in range(len(surnames)):
+ strng = names[i] + ' ' + surnames[i]
+ print(strng)
+ check = len(surnames)
+ while check < len(names):
+ print(names[check])
+ check += 1
+else:
+ for i in range(len(names)):
+ strng = names[i] + ' ' + surnames[i]
+ print(strng)
+ check = len(names)
+ while check < len(surnames):
+ print(surnames[check])
+ check += 1
+def doneText(fname):
+ f = open(fname, 'r')
+ s = f.read().split(' ')
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"')
+ f.close
+ return s
+fnm = input('Введите имя файла: ')
+arr = doneText(fnm)
+print('Количество слов в тексте = {0}'.format(arr.len()))
+my_num = 9
+check = False
+while (check == False):
+ try:
+ your_num = int(input('Write a number from 1 to 10, please: '))
+ except ValueError:
+ print("It's not a number, I'm out")
+ break
+ if your_num == my_num:
+ print('You\'re lucky one :D')
+ check = True
+ else:
+ if your_num > my_num:
+ print('Your number is too big')
+ else:
+ print('Your number is too small')
+print("End of programme")
+check = True
+while check == True:
+ word = input('Write a word in cyrillic: ')
+ if word == "":
+ check = False
+ print("Empty word, I'm out")
+ else:
+ if word.endswith('о') or word.endswith('н') or word.endswith('р'):
+ print('Possible forms: Nom. Sg. / Acc. Sg.')
+ elif word.endswith('а'):
+ print('Possible forms: Gen. Sg. / Nom. Pl. / Acc. Pl.')
+ elif word.endswith('у'):
+ print('Possible forms: Dat. Sg.')
+ elif word.endswith('ом'):
+ print('Possible forms: Instrum. Sg. / Nom. Sg.')
+ elif word.endswith('е'):
+ print('Possible forms: Prep. Sg.')
+ elif word.endswith('ам'):
+ print('Possible forms: Dat. Pl.')
+ elif word.endswith('ами'):
+ print('Possible forms: Instrum. Pl.')
+ elif word.endswith('ах'):
+ print('Possible forms: Prep. Pl.')
+ elif word.endswith('и'):
+ print('Possible forms: Nom. Pl.')
+ else:
+ print('Possible forms: Gen. Pl.')
+print('Thanks for using!')
+import os
+import re
+def rem_dir(name_dir):
+ for root, dirs, files in os.walk('.', topdown=False):
+ if re.findall(os.sep + name_dir, root):
+ for f in files:
+ os.remove(os.path.join(root, f))
+ for d in dirs:
+ os.rmdir(os.path.join(root, d))
+ for d in dirs:
+ if name_dir == d:
+ os.rmdir(os.path.join(root, d))
+def print_root():
+ s = '--'
+ for root, dirs, files in os.walk('.'):
+ print (s + root)
+ if len(dirs):
+ s = '\t' + s
+ for f in files:
+ print('\t{0}'.format(f))
+def main():
+ rem_dir('wrong')
+ print_root()
+if __name__ == '__main__':
+ main()
+word = input('Write a word in cyrillic: ')
+if word.endswith('о'):
+ print('Possible forms: Nom. Sg. / Acc. Sg.')
+elif word.endswith('а'):
+ print('Possible forms: Gen. Sg. / Nom. Pl. / Acc. Pl.')
+elif word.endswith('у'):
+ print('Possible forms: Dat. Sg.')
+elif word.endswith('ом'):
+ print('Possible forms: Instrum. Sg.')
+elif word.endswith('е'):
+ print('Possible forms: Prep. Sg.')
+elif word.endswith('ам'):
+ print('Possible forms: Dat. Pl.')
+elif word.endswith('ами'):
+ print('Possible forms: Instrum. Pl.')
+elif word.endswith('ах'):
+ print('Possible forms: Prep. Pl.')
+else:
+ print('Possible forms: Gen. Pl.')
+import re
+def done_text(fname):
+ f = open(fname, 'r', encoding='UTF-8')
+ s = f.read().split()
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"1234567890«»”“><')
+ f.close
+ return s
+def print_words(s):
+ regex = '.*[ауоиыеюя].*[ауоиыеюя].*[ауоиыеюя].*'
+ for word in s:
+ if re.search(regex, word):
+ print(word)
+def main():
+ textik = done_text(input('Введите имя файла с расширением: '))
+ print_words(textik)
+main()
+import os
+import re
+import math
+from math import log
+PUNCT = '[.,!«»?&@"$\[\]\(\):;%
+def preprocessing(text):
+ text_wo_punct = re.sub(PUNCT, '', text.lower())
+ words = text_wo_punct.strip().split()
+ return words
+def count_tf(word, text):
+ return text.count(word) / len(text)
+def count_df(word, texts):
+ n = [1 for text in texts if word in text]
+ return sum(n)
+def count_idf(word, texts):
+ n = len(texts) / (1 + count_df(word, texts))
+ return n
+def count_tfidf(word, text, texts):
+ tf = count_tf(word, text)
+ idf = count_idf(word, texts)
+ return log(tf, 10) * log(idf, 10)
+def get_texts():
+ texts_dic = {}
+ for root, dirs, files in os.walk('wikipedia'):
+ for f in files[:50]:
+ with open(os.path.join(root, f), 'r', encoding='utf-8') as t:
+ text = preprocessing(t.read())
+ texts_dic[f.split('.')[0]] = text
+ texts = list(texts_dic.values())
+ return texts_dic, texts
+def fin_output(texts_dic, texts):
+ for text in texts_dic:
+ print("Top words in document {}".format(text))
+ scores = {}
+ for word in texts_dic[text]:
+ scores[word] = count_tfidf(word, texts_dic[text], texts)
+ sorted_words = sorted(scores.items(), key=lambda x: x[1])
+ for word, score in sorted_words[:5]:
+ print("\tWord: {}, TF-IDF: {}".format(word, round(score, 5)))
+def main():
+ a = get_texts()
+ fin_output(a[0], a[1])
+if __name__ == '__main__':
+ main()
+check = True
+coinc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+while check is True:
+ s = input('Введите текст: ')
+ if s == '':
+ check = False
+ else:
+ res = ''
+ for letter in s:
+ if letter == ' ':
+ res += ' '
+ else:
+ for indx, i in enumerate(coinc):
+ if i == letter:
+ if i == 'A':
+ res += 'Z'
+ elif i == 'a':
+ res += 'z'
+ elif i == 'А':
+ res += 'Я'
+ elif i == 'а':
+ res += 'я'
+ else:
+ res += coinc[indx - 1]
+ print (res)
+print('Программа завершила свою работу!')
+def done_text(fname):
+ f = open(fname, 'r')
+ s = f.read().split()
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"1234567890«»”“><')
+ f.close
+ return s
+def freq_dic(arr):
+ dic = {}
+ for word in arr:
+ if word not in dic:
+ dic[word] = 1
+ else:
+ dic[word] += 1
+ return dic
+def print_dic(dic):
+ for word in dic:
+ if dic[word] >= 10:
+ print(word, dic[word])
+def main():
+ my_text = done_text(input('Введите имя файла с расшриением: '))
+ print_dic(freq_dic(my_text))
+main()
+def done_text(fname):
+ f = open(fname, 'r')
+ s = f.read().split()
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"1234567890«»><')
+ f.close
+ return s
+def count_syll(arr, n):
+ res = []
+ voc = 'аоуыиеёюя'
+ for word in arr:
+ num = 0
+ for letter in word:
+ if letter in voc:
+ num += 1
+ if num == n:
+ res.append(word)
+ return res
+def first_letter(arr, letter):
+ res = []
+ for word in arr:
+ if word.startswith(letter):
+ res.append(word)
+ return res
+def choice():
+ fnm = input('Введите имя файла: ')
+ textik = done_text(fnm)
+ make_choice = input('Если хотите, чтобы программа считала слоги, введите syllables; иначе - letter: ')
+ if make_choice == 'syllables':
+ numb = int(input('Введите количество слогов в словах: '))
+ print(' '.join(count_syll(textik, numb)))
+ else:
+ lett = input('Введите желаемую первую букву: ')
+ print(' '.join(first_letter(textik, lett)))
+def main():
+ choice()
+main()
+import os
+def mk_ppk(s):
+ s = s.split()
+ pth = '.'
+ for word in s:
+ pth += os.sep + word
+ if not os.path.exists(pth):
+ os.makedirs(pth)
+def mk_fls(num):
+ pth = '.'
+ for ppk in range(num):
+ pth += os.sep + str(ppk+1)
+ if not os.path.exists(pth):
+ os.makedirs(pth)
+ for pp_quant in range(ppk+1):
+ f = open(pth + os.sep + str(pp_quant + 1) + '.txt', 'w')
+ f.close()
+ pth = '.'
+def prnt_dir(nm_dir):
+ for fl in os.listdir(nm_dir):
+ if os.path.isdir(fl):
+ print(fl)
+def main():
+ mk_ppk(input('Введите приложение: '))
+ mk_fls(int(input('Введите число: ')))
+ prnt_dir('.')
+if __name__ == '__main__':
+ main()
+my_num = 9
+check = False
+your_num = int(input('Write a number from 1 to 10, please: '))
+while(your_num != my_num):
+ if your_num > my_num:
+ print('Your number is too big')
+ else:
+ print('Your number is too small')
+ try:
+ your_num = int(input('Try again: '))
+ except ValueError:
+ print("Not a number")
+ check = True
+ break
+if check == True:
+ print("See you next time")
+else:
+ print("You're right")
+check = True
+coinc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+while check is True:
+ s = input('Введите текст: ')
+ if s == '':
+ check = False
+ else:
+ res = ''
+ for letter in s:
+ if letter == ' ':
+ res += ' '
+ else:
+ for indx, i in enumerate(coinc):
+ if i == letter:
+ if i == 'Z':
+ res += 'A'
+ elif i == 'z':
+ res += 'a'
+ elif i == 'Я':
+ res += 'А'
+ elif i == 'я':
+ res += 'а'
+ else:
+ res += coinc[indx + 1]
+ print (res)
+print('Программа завершила свою работу!')
+f = open('freq_crlf.txt', 'r', encoding='utf-8')
+s = f.read().split('\n')
+f.close()
+for line in s:
+ line = line.split(' | ')
+ if line[1] == 'союз':
+ print(' | '.join(line))
+f = open('freq_crlf.txt', 'r', encoding='utf-8')
+s = f.read().split('\n')
+f.close()
+arr = []
+while True:
+ word = input('Введите слово: ')
+ if word == '':
+ print('Результаты:')
+ break
+ else:
+ arr.append(word)
+for word in arr:
+ check = False
+ for line in s:
+ line = line.split(' | ')
+ if word == line[0]:
+ print(' | '.join(line))
+ check = True
+ if check is False:
+ print(u'{0}: Такого слова в словаре нет.'.format(word))
+print('Завершение работы программы')f = open('freq_crlf.txt', 'r', encoding='utf-8')
+s = f.read().split('\n')
+f.close()
+while True:
+ word = input('Введите слово: ')
+ if word == '':
+ print('Завершение работы программы')
+ break
+ else:
+ check = False
+ for line in s:
+ line = line.split(' | ')
+ if word == line[0]:
+ print(' | '.join(line))
+ check = True
+ if check is False:
+ print('Такого слова в словаре нет.')
+import decimal
+f = open('freq_crlf.txt', 'r', encoding='utf-8')
+s = f.read().split('\n')
+f.close()
+ress = ''
+ipm_sum = 0
+for line in s:
+ line = line.split(' | ')
+ if line[1].find('ед жен') != -1:
+ ress += line[0]
+ ress += ', '
+ ipm_sum += decimal.Decimal(line[2])
+print(ress)
+print(u'Суммарное значение ipm = {0}'.format(ipm_sum))import re
+def open_file():
+ f = open('islandic.xml', 'r', encoding='UTF-8')
+ s = f.read()
+ f.close()
+ return s
+def count_lines():
+ s = open_file()
+ s = s.split('\n')
+ f = open('answer_length.txt', 'w', encoding='UTF-8')
+ f.write(str(len(s)))
+ f.close()
+def my_diction(arr):
+ dix = {}
+ for word in arr:
+ if word in dix:
+ dix[word] += 1
+ else:
+ dix[word] = 1
+ return dix
+def create_diction():
+ s = open_file()
+ regex = ''
+ arr = re.findall(regex, s)
+ dix = my_diction(arr)
+ f = open('answer_keys.txt', 'w', encoding='UTF-8')
+ f.write('Отсортированный список морфологических разборов:\n')
+ for key in sorted(dix):
+ f.write(key + '\n')
+ f.close()
+def count_adj():
+ s = open_file()
+ regex = ''
+ arr = re.findall(regex, s)
+ dix = my_diction(arr)
+ f = open('answer_adj.txt', 'w', encoding='UTF-8')
+ for key in sorted(dix):
+ f.write(key + ' ' + str(dix[key]) + '\n')
+ f.close()
+def create_csv():
+ s = open_file()
+ print(s)
+ regex1 = '(.+?)'
+ regex2 = '<.+?>\n'
+ s = re.sub(regex1, '\\1, \\2, \\3', s)
+ s = re.sub(regex2, '', s)
+ s = re.sub('( )+?', '', s)
+ s = s.split('\n')
+ f = open('answer_dict.csv', 'w', encoding='UTF-8')
+ for line in s:
+ f.write(line + '\n')
+ f.close()
+def main():
+ count_lines()
+ create_diction()
+ count_adj()
+ create_csv()
+if __name__ == '__main__':
+ main()
+check = True
+words = []
+while check is True:
+ s = input("Введите слово: ")
+ if s == "":
+ check = False
+ else:
+ temp = []
+ for letter in s:
+ temp.append(letter)
+ words.append(temp)
+for wrd in words:
+ for letterindx in range(2, len(wrd), 2):
+ if letterindx >= len(wrd):
+ break
+ wrd.pop(letterindx)
+ s = ""
+ for letterindx in range(len(wrd) - 1, -1, -1):
+ s += wrd[letterindx]
+ print(s)f = open('input.txt', 'r', encoding='UTF-8')
+s = f.read().split('\n')
+f.close()
+avgsum = 0
+for indx, line in enumerate(s):
+ s[indx] = line.split()
+ avgsum += len(s[indx])
+print(u'Среднее количество слов в строке = {0}'.format(avgsum / len(s)))import re
+word = input("Введите слово на кириллице: ")
+pattern1 = r'[А-Яа-я]'
+pattern2 = r'[1-9A-Za-z]'
+if re.match(pattern1, word) and re.search(pattern2, word) is None:
+ for indx, letter in enumerate(word):
+ if indx % 2 != 0:
+ if letter != "а" and letter != "к":
+ print(letter)
+else:
+ print("Вводить можно только кириллицу :Р")temp = False
+while (temp == False):
+ try:
+ a = float(input('Введите первое число (a) '))
+ b = float(input('Введите второе число (b) '))
+ c = float(input('Введите третье число (c) '))
+ temp = True
+ except (TypeError, ValueError):
+ print('Просила же только числа вводить!')
+if a + b == c:
+ print('Поздравляю! a + b = c')
+else:
+ print('Прошу прощения, но a + b != c')
+if a*c + b == 0:
+ print('Поздравляю! a*c + b = 0')
+else:
+ print('Прошу прощения, но a*c + b != 0')import random
+def ask_name():
+ return input('Введите имя файла с расширением: ')
+def get_words():
+ f = open(ask_name(), 'r', encoding='UTF-8')
+ s = f.read().split('\n')
+ f.close()
+ dic = {}
+ for ln in s:
+ temp = ln.split(',')
+ dic[temp[0]] = temp[1:]
+ return dic
+def guess_word(word):
+ num = len(word)
+ if num <= 4:
+ print('У вас {0} попытки'.format(num))
+ else:
+ print('У вас {0} попыток'.format(num))
+ while num > 0:
+ temp = input('Введите слово: ')
+ if temp == word:
+ print('Вы угадали!')
+ break
+ else:
+ print('Попробуйте еще раз!')
+ num -= 1
+ if num == 0:
+ print('Повезет в другой раз!')
+def game(d):
+ num_check = 0
+ for k in d:
+ print('Подсказка! {0} ...'.format(random.choice(d[k])))
+ guess_word(k)
+ num_check += 1
+ if num_check == len(d):
+ print('Это было последнее слово. Приходите еще')
+ break
+ ask = input('Хотите попробовать еще раз? Введите только "да" или "нет": ')
+ if ask == 'нет':
+ break
+def main():
+ d = get_words()
+ game(d)
+main()def done_text(fname):
+ f = open(fname, 'r')
+ s = f.read().split()
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"1234567890«»><')
+ f.close
+ return s
+def get_fname():
+ return input("Введите имя файла с расширением: ")
+def count_ing(arr):
+ res = 0
+ for word in arr:
+ if word.endswith('ing'):
+ res += 1
+ return res
+def count_form(arr, form):
+ res = 0
+ for word in arr:
+ if word == form:
+ res += 1
+ return res
+def main():
+ textik = done_text(get_fname())
+ print('Всего в тексте {0} форм на -ing'.format(count_ing(textik)))
+ form = input('Введите форму, количество вхождений которой хотите найти: ')
+ print('Эта форма встречается {0} раз'.format(count_form(textik, form)))
+main()import re
+def search_inf(fname):
+ f = open(fname, 'r', encoding='UTF-8')
+ s = f.read()
+ f.close()
+ regex = '>Столица.*?([А-Яа-я]+(-[А-Яа-я]+)*)'
+ res = re.search(regex, s, re.DOTALL)
+ if res:
+ k = open('answer.txt', 'w', encoding='UTF-8')
+ print(res.group(1))
+ k.write(res.group(1))
+ k.close()
+def main():
+ search_inf(input('Введите имя файла: '))
+if __name__ == '__main__':
+ main()import re
+def change_text():
+ f = open('mosq1.txt', 'r', encoding='UTF-8')
+ s = f.read()
+ f.close()
+ s1 = re.sub('Комар(»| |а|ы|у|ом|е|ов|ам|ами|ах)', 'Слон\\1', s)
+ s1 = re.sub('комар(»| |а|ы|у|ом|е|ов|ам|ами|ах)', 'слон\\1', s1)
+ f = open('antwort.txt', 'w', encoding='UTF-8')
+ f.write(s1)
+ f.close()
+def main():
+ change_text()
+if __name__ == '__main__':
+ main()import random
+def generate_adj():
+ f = open('adj.txt', 'r')
+ s = f.read().split()
+ f.close()
+ return random.choice(s)
+def generate_noun(num):
+ if num == 'sg':
+ f_name = 'noun_sg.txt'
+ else:
+ f_name = 'noun_pl.txt'
+ f = open(f_name, 'r')
+ s = f.read().split()
+ f.close()
+ return random.choice(s)
+def generate_verb():
+ f = open('verbs.txt', 'r')
+ s = f.read().split()
+ f.close()
+ return random.choice(s)
+def generate_punct(pos):
+ if pos == 'end':
+ f_name = 'end_punct.txt'
+ else:
+ f_name = 'mid_punct.txt'
+ f = open(f_name, 'r')
+ s = f.read().split()
+ f.close()
+ punct = random.choice(s)
+ if punct == '-':
+ punct = ' ' + punct
+ return punct
+def generate_pronoun():
+ f = open('pronouns.txt', 'r')
+ s = f.read().split()
+ f.close()
+ return random.choice(s)
+def generate_intj():
+ f = open('intj.txt', 'r')
+ s = f.read().split('\n')
+ f.close()
+ return random.choice(s)
+def generate_line(num):
+ if num == 1:
+ return generate_adj() + ' ' + generate_noun('sg') + generate_punct('end') + '\n'
+ elif num == 2:
+ return generate_verb() + ' ' + generate_noun('pl') + ' и' + '\n'
+ else:
+ return generate_pronoun() + generate_punct('mid') + ' ' + generate_intj() + generate_punct('end') + '\n'
+def generate_haiku():
+ return generate_line(1) + generate_line(2) + generate_line(3)
+print(generate_haiku())import re
+def done_text(fname):
+ f = open(fname, 'r', encoding='UTF-8')
+ s = f.read().lower()
+ rez1 = '(,|:|№|-|\*|/|\||\[|\]|{|}|\\|(|)|\'|"|[0-9]|«|»|>|<|V|I|X)+'
+ s = re.sub(rez1, ' ', s)
+ rez = '\.|\?|!|\.\.\.'
+ s = re.split(rez, s)
+ f.close()
+ for indx, sent in enumerate(s):
+ s[indx] = sent.split()
+ if len(s[indx]) == 0:
+ s.pop(indx)
+ return s
+def count_letters(arr):
+ mlist = [(indx + 1, word, len(word)) for indx, senten in enumerate(arr) for word in senten if len(word) >= 7]
+ f = open('answer_sheet12.txt', 'w', encoding='UTF-8')
+ for k in mlist:
+ f.write('предложение {0}, {1}-------{2}\n'.format(k[0], k[1], k[2]))
+ f.close()
+def main():
+ count_letters(done_text('tolstoy.txt'))
+if __name__ == '__main__':
+ main()import os
+import re
+def count_dirs():
+ res = '[0-9]'
+ arr = [thing for thing in os.listdir('.') if os.path.isdir(thing) and len(re.findall(res, thing))]
+ return arr
+def print_answer(arr):
+ fout = open('answer_sheet13.txt', 'w', encoding='UTF-8')
+ fout.write('Всего папок с цифрами в названии - {0}.'.format(str(len(arr))))
+ fout.write('Все имена в директории (без повторений):\n')
+ clear_names = []
+ for thing in os.listdir('.'):
+ temp = thing
+ if os.path.isfile(thing):
+ temp = re.sub('\..+', '', thing)
+ if temp not in clear_names:
+ clear_names.append(temp)
+ for nme in clear_names:
+ if nme:
+ fout.write(nme + '\n')
+ fout.close()
+def main():
+ print_answer(count_dirs())
+if __name__ == '__main__':
+ main()import os
+def count_dep():
+ count = 0
+ for root, dirs, files in os.walk('.', topdown=False):
+ if len(root.split(os.sep)) - 1 > count:
+ count = len(root.split(os.sep)) - 1
+ with open('answer_sheet14.txt', 'w', encoding='UTF-8') as answer:
+ answer.write(str(count))
+def main():
+ count_dep()
+if __name__ == '__main__':
+ main()while True:
+ s = input("Введите строку: ")
+ if s == "":
+ break
+ for indx, part in enumerate(s):
+ print(s[:len(s) - indx])s = input("Введите строку: ")
+for indx, part in enumerate(s):
+ print(s[:len(s) - indx])import re
+def ask_name():
+ return input('Введите имя файла с расширением: ')
+def get_words():
+ f = open(ask_name(), 'r', encoding='UTF-8')
+ s = f.read().split()
+ for indx, word in enumerate(s):
+ s[indx] = word.lower().strip('.,:;№-*!?/|\[]{}()\'"1234567890«»><')
+ f.close
+ return s
+def count_words(words):
+ regex = 'откр(ы|о)((т(ый|ая|ое|ые|ого|ой|ых|ому|ым|ую|ом|ою)|в(ш(ий?|ая|ее|ие|его|ей|их|ему|им|ую|ею))?)|(л(а|о|и)?)|(й(те)?)|(ют?|е(шь|м|те?)))(ся|сь)?'
+ wlist = []
+ for word in words:
+ if re.fullmatch(regex, word):
+ if word not in wlist:
+ wlist.append(word)
+ return wlist
+def main():
+ print(', '.join(count_words(get_words())))
+main()word = input('Введите слово: ')
+if word == '':
+ print ('Слово не введено')
+word2 = ''
+for i in range(len(word)):
+ for k in range(len(word)):
+ if k + i < len(word):
+ word2 += word[k + i]
+ else:
+ word2 += word[k + i - len(word)]
+ print (word2)
+ word2 = ''
+import re
+def open_and_edit():
+ f = open("verbs.txt", 'r', encoding = "utf-8")
+ s = f.read()
+ f.close()
+ s1 = s.lower()
+ a = s1.split()
+ for i, word in enumerate(a):
+ a[i] = word.strip('.,!?();:*/\|<>-_%&
+ return a
+def find_and_print(a):
+ arr = []
+ for word in a:
+ if re.search('^программир((у(ю(т|щ(и(й|ми?|е|х)|е(го|му?|й)|ая|ую))?|я|е(шь|те?))|ова(л(а|и)?|ть))(с(я|ь))?|уем(ы(й|ми?|е|х)?|о(го|му?|й)|ая?|ую))', word):
+ if word not in arr:
+ arr.append(word)
+ for verb in arr:
+ print(verb)
+def main():
+ text = open_and_edit()
+ find_and_print(text)
+main()
+import re
+import os
+def task1():
+ for root, dirs, files in os.walk('.\\news'):
+ s = ''
+ for f in files:
+ file = open(os.path.join(root, f), 'r', encoding = "WINDOWS-1251")
+ text = file.readlines()
+ words = 0
+ for line in text:
+ reg = ''
+ r = re.search(reg,line)
+ if r:
+ words += 1
+ s += f + '\t' + str(words) + '\n'
+ f2 = open("words_in_files.txt", 'w', encoding = "utf-8")
+ f2.write(s)
+def task2():
+ for root, dirs, files in os.walk('.\\news'):
+ s = ''
+ for f in files:
+ file = open(os.path.join(root, f), 'r', encoding = "WINDOWS-1251")
+ text = file.readlines()
+ author = ''
+ date = ''
+ for line in text:
+ reg_author = 'content="([ |(а-яА-яa-zA-Z)]+)" name="author"'
+ reg_date = 'content="([0-9]+\.[0-9]+\.[0-9]+)" name="created"'
+ r1 = re.search(reg_author, line)
+ if r1:
+ author = r1.group(1)
+ r2 = re.search(reg_date, line)
+ if r2:
+ date = r2.group(1)
+ s += f + '\t' + author + '\t' + date + '\n'
+ f3 = open("words_in_files.csv", 'w', encoding = "utf-8")
+ f3.write(s)
+def task3():
+ for root, dirs, files in os.walk('.\\news'):
+ s = ''
+ for f in files:
+ file = open(os.path.join(root, f), 'r', encoding = "WINDOWS-1251")
+ text = file.readlines()
+ for i, line in enumerate(text):
+ reg_adj = 'A=.+gen.+>?'
+ reg_sumj = 'S,.+gen.+>?'
+ reg_word = '([а-яА-Я]+|`)\n'
+ r1 = re.search(reg_adj, line)
+ if r1:
+ r2 = re.search(reg_word, line)
+ word1 = r2.group(1)
+ r3 = re.search(reg_subj, text[i+1])
+ if r3:
+ word2 = r3.group(1)
+def main():
+ task1()
+ task2()
+main()
+import re
+def open_and_edit():
+ f = open("linguistics.txt", 'r', encoding = "utf-8")
+ s = f.read()
+ f.close()
+ return s
+def replace_and_output(s):
+ s1 = re.sub('язык([а-я]{,3}( |\.|,|\)))','шашлык\\1', s)
+ s2 = re.sub('Язык([а-я]{,3}( |\.|,|\)))','Шашлык\\1', s1)
+ f = open("shashlyk.txt", 'w', encoding = "utf-8")
+ f.write(s2)
+ print('Текст записан в файл shashlyk.txt')
+ f.close()
+def main():
+ text = open_and_edit()
+ replace_and_output(text)
+main()
+import os
+import re
+def count_folders():
+ result = 0
+ for f in os.listdir('.'):
+ if os.path.isdir(f):
+ if re.search('^([а-яА-Я]| )+$',f):
+ result += 1
+ print('Найдено папок:',result)
+def print_names():
+ names = {}
+ file_name = '^(.+)(\.[a-z]+)$'
+ for f in os.listdir('.'):
+ if os.path.isdir(f):
+ if f not in names:
+ names[f] = 1
+ if os.path.isfile(f):
+ r = re.search(file_name,f)
+ if r:
+ name = r.group(1)
+ if name not in names:
+ names[name] = 1
+ for name in sorted(names):
+ print(name)
+def main():
+ count_folders()
+ print_names()
+main()
+def read_file():
+ f = open("words.csv", 'r', encoding = "utf-8")
+ a = f.readlines()
+ f.close()
+ return(a)
+def make_dict(a):
+ words = {}
+ for line in a:
+ a2 = line.split(';')
+ for i, h in enumerate(a2):
+ a2[i] = h.strip()
+ words[a2[1]] = a2[0]
+ return words
+def guess(dic):
+ for noun in dic:
+ print(dic[noun], '...')
+ attempt = 0
+ while attempt != len(dic[noun]):
+ print('Осталось попыток: ', len(dic[noun]) - attempt )
+ attempt += 1
+ if input() == noun:
+ print('Маладэц!')
+ attempt = len(dic[noun])
+ elif len(dic[noun]) - attempt == 0:
+ print('Не угадал :(')
+def main():
+ text = read_file()
+ words = make_dict(text)
+ print(words)
+ guess(words)
+main()
+import re
+def open_and_edit():
+ f = open("hse.html", 'r', encoding = "utf-8")
+ s = f.read()
+ f.close()
+ return s
+def find_and_print(s):
+ reg1 = 'Преподаватели.*?\n.*?\n[0-9]+ ?[0-9]+'
+ reg2 = 'Преподаватели.*?\n.*?\n
'
+ res1 = re.findall(reg1,s)
+ res2 = re.findall(reg2,s)
+ number = res1[0].replace(res2[0], '')
+ print('Число преподавателей:',number)
+ f = open("found_number.txt", 'w', encoding = "utf-8")
+ f.write(number)
+ f.close()
+def main():
+ text = open_and_edit()
+ find_and_print(text)
+main()
+words = []
+while True:
+ newword = input('Введите слово: ')
+ if newword == '':
+ break
+ else:
+ words.append(newword)
+for i in range(len(words)):
+ string = words[i]
+ if (i+1) >= len(string):
+ print('В этом слове не осталось символов')
+ else:
+ print(string[i+1:])
+a = input ('Введите число a: ')
+b = input ('Введите число b: ')
+c = input ('Введите число c: ')
+a = int (a)
+b = int (b)
+c = int (c)
+if a % b == c:
+ print ('a дает остаток c при делении на b')
+else:
+ print ('a не дает остаток c при делении на b')
+if a * c + b == 0:
+ print ('c является решением линейного уравнения ax + b = 0')
+else:
+ print ('c не является решением линейного уравнения ax + b = 0')
+import random
+
+def open_file():
+ f = open("words.txt", 'r', encoding = "utf-8")
+ text = f.readlines()
+ f.close()
+ return(text)
+
+def find_words(word,text):
+ for i in range(len(text)):
+ line = []
+ line = text[i].split()
+ for l, w in enumerate(line):
+ line[l] = w.strip('.,!?();:*/\|<>-_%&
+ if line[0] == word:
+ words = []
+ for j in range(len(line)):
+ if j > 0:
+ words.append(line[j])
+ return(words)
+
+def noun():
+ find = 'существительное'
+ nouns = find_words(find, text)
+ return random.choice(nouns)
+
+def imperative():
+ find = 'императив'
+ imper = find_words(find, text)
+ return random.choice(imper)
+
+def adverb(imp):
+ find = 'наречие'
+ adverbs = find_words(find, text)
+ return random.choice(adverbs) + ' ' + imp
+
+def verb():
+ find = 'глагол'
+ verbs = find_words(find, text)
+ return random.choice(verbs)
+
+def adjective():
+ find = 'прилагательное'
+ adj = find_words(find, text)
+ return random.choice(adj)
+
+def question_word():
+ find = 'вопрос'
+ quest = find_words(find, text)
+ return random.choice(quest)
+
+def pos_sentence():
+ sentence = adjective() + ' ' + noun() + ' ' + verb() +\
+ ' ' + adjective() + ' ' + noun() + '.'
+ sentence = sentence.capitalize()
+ return(sentence)
+
+def neg_sentence():
+ sentence = adjective() + ' ' + noun() + ' не ' + verb() +\
+ ' ' + adjective() + ' ' + noun() + '.'
+ sentence = sentence.capitalize()
+ return(sentence)
+
+def quest_sentence():
+ sentence = question_word()+ ' ' + adjective() + ' ' + noun() +\
+ ' ' + verb() + ' ' + adjective() + ' ' + noun() + '?'
+ sentence = sentence.capitalize()
+ return(sentence)
+
+def imper_sentence():
+ sentence = adverb(imperative()) + ' ' + noun() + '!'
+ sentence = sentence.capitalize()
+ return(sentence)
+
+def if_sentence():
+ sentence = 'если бы ' + noun() + ' ' + verb() + ' ' + noun() +\
+ ', то ' + noun() + ' ' + verb() + ' бы ' + noun() + '.'
+ sentence = sentence.capitalize()
+ return(sentence)
+
+def random_print():
+ spisok = [pos_sentence(), neg_sentence(), quest_sentence(),\
+ imper_sentence(), if_sentence()]
+ random.shuffle(spisok)
+ for i in range(len(spisok)):
+ print(spisok[i], end = ' ')
+text = open_file()
+random_print()
+word = input ('Введите слово: ')
+indx = len(word)-1
+while indx >= 0:
+ if (word[indx]!= 'я') & (word[indx]!= 'з') :
+ print (word[indx])
+ indx -= 1
+import os
+import re
+def extensions():
+ ext_count = {}
+ for root, dirs, files in os.walk('.'):
+ for file in files:
+ ext = re.findall('\.[a-z0-9A-Z]+$', file)
+ if ext[0] not in ext_count:
+ ext_count[ext[0]] = 1
+ else:
+ ext_count[ext[0]] += 1
+ numb = 0
+ found_ext = ''
+ for ext in ext_count:
+ if ext_count[ext] > numb:
+ numb = ext_count[ext]
+ found_ext = ext
+ print(found_ext)
+def main():
+ extensions()
+main()
+import re
+def open_and_read():
+ f = open("animal_farm.txt", 'r', encoding = "utf-8")
+ s = f.read()
+ f.close()
+ return s
+def read_sentences(s):
+ s1 = re.sub('[a-z](\.|!|\?)','\\1@@', s)
+ a = s1.split('@@')
+ return a
+def split_and_count(a):
+ for i in range(len(a)):
+ words = a[i].split()
+ words2 = [words[j].strip('.,!?();:*/\|<>-_%&
+ for word in range(len(words2)):
+ print('%s_%s' %(words2[word], len(words2[word])))
+def main():
+ text = open_and_read()
+ sent = read_sentences(text)
+ split_and_count(sent)
+main()
+f = open("1.txt", 'r', encoding = "utf-8")
+word1 = 0
+word3 = 0
+for line in f:
+ words = line.split()
+ for i in range(len(words)):
+ if len(words[i]) == 3:
+ word3 += 1
+ elif len(words[i]) == 1:
+ word1 += 1
+ words = []
+if word1 == 0:
+ print("Нет слов длинны 1")
+else:
+ print(float(word3)/float(word1))
+def open_and_edit():
+ name = input('Введите название файла: ')
+ f = open(name, 'r', encoding = "utf-8")
+ s = f.read()
+ f.close()
+ s1 = s.lower()
+ a = s1.split()
+ for i, word in enumerate(a):
+ a[i] = word.strip('.,!?();:*/\|<>-_%&
+ return a
+def find_in_text(t):
+ hood = []
+ for word in t:
+ if word.endswith('hood'):
+ hood.append(word)
+ print('В тексте нашлось ', len(hood), ' существительных с суффиксом -hood')
+ return hood
+def short_list(arr):
+ short = []
+ arr2 = []
+ for k in arr:
+ arr2.append(k)
+ for i in range(len(arr2)-1):
+ if arr2[i]:
+ short.append(arr2[i])
+ x = 1
+ for j in range(i+1, len(arr2)):
+ if arr2[i]:
+ if arr2[i] == arr2[j]:
+ x += 1
+ arr2[j] = []
+ short.append(x)
+ return short
+def min_freq(arr):
+ short = short_list(arr)
+ min = short[1]
+ index = 1
+ for k in range(1, len(short), 2):
+ if short[k] < min:
+ index = k
+ min = short[k]
+ print('Минимальную частотность имеет существительное', short[index-1])
+def print_nouns(arr):
+ nouns = []
+ short = short_list(arr)
+ for word in short:
+ if type(word) != int:
+ nouns.append(word.replace('hood', ''))
+ all_nouns = ', '.join(nouns)
+ print('Найденный слова образованы от существительных ', all_nouns)
+def main():
+ text = open_and_edit()
+ found = find_in_text(text)
+ min_freq(found)
+ print_nouns(found)
+main()
+f = open("aphor.txt", 'r', encoding = "utf-8")
+a = f.readlines()
+f.close()
+
+for i in range(len(a)):
+ words = []
+ words = a[i].split()
+ numb = 0
+ for j in range(len(words)):
+ if words[j] != '—':
+ numb += 1
+ if numb < 16:
+ print(a[i])
+
+author = []
+um = 0
+for i in range(len(a)):
+ words = []
+ words = a[i].split()
+ for l, word in enumerate(words):
+ words[l] = word.strip('.,!?();:*/\|<>-_%&
+ for j in range(len(words)):
+ if words[j] == 'ум':
+ um += 1
+ povtor = 0
+ for k in range(len(author)):
+ if author[k] == words[len(words)-1]:
+ povtor += 1
+ if povtor == 0:
+ author.append(words[len(words)-1])
+out = ''
+out = ', '.join(author)
+print('Количество цитат = ', um)
+print('Источники: ', out)
+
+inp_words = []
+while True:
+ newword = input('Введите слово: ')
+ if newword == '':
+ break
+ else:
+ inp_words.append(newword)
+for j in range(len(inp_words)):
+ found = 0
+ print(inp_words[j])
+ for i in range(len(a)):
+ words = []
+ words = a[i].split()
+ for l, word in enumerate(words):
+ words[l] = word.strip('.,!?();:*/\|<>-_%&
+ for k in range(len(words)):
+ if inp_words[j] == words[k]:
+ print(a[i])
+ found += 1
+ break
+ if found == 0:
+ print('Цитата с этим словом не найдена')
+import re
+def open_file():
+ f = open("file.txt", 'r', encoding = "utf-8")
+ a = []
+ for line in f:
+ a.append(line)
+ f.close()
+ return a
+def open_new_file():
+ f = open("created_file.txt", 'w', encoding = "utf-8")
+ return f
+def write_lines_number(a,f):
+ i = 0
+ for line in a:
+ i += 1
+ f.write(str(i))
+ f.write('\n')
+def create_dictionary(a,f):
+ dic = {}
+ for line in a:
+ if '= 5:\n'))
+ while n < 5:
+ n = int(input('Введённое число < 5. Пожалуйста, введите число >= 5:\n'))
+ return n
+def func3(dic, n):
+ for i in range(n):
+ key = random.choice(list(dic.keys()))
+ m = 3
+ print(i + 1, '-ое слово. ', 'Подсказка: ', random.choice(dic[key]), ' ...', sep = '')
+ fl = 0
+ while fl != 1 and m != 0:
+ print('Попыток осталось: ', m, sep = '')
+ if input('Введите ниже ваш ответ:\n').lower() == key:
+ fl = 1
+ print('Молодец! Всё верно!')
+ else:
+ print('Неверно. ', end = '')
+ if m != 1:
+ print('Ещё одна подсказка: ', random.choice(dic[key]), ' ...', sep = '')
+ m -= 1
+ if fl == 0:
+ print('Вы не угадали. Правильный ответ: ', key, sep = '')
+def main():
+ dic = func1(input('Введите, пожалуйста, название файла:\n'))
+ n = func2()
+ func3(dic, n)
+main()
+
+
+
+def func1(name):
+
+
+
+
+ f = open(name, 'r', encoding = 'utf-8', errors = 'ignore')
+ words = f.read().replace('\n', ' ').split()
+ f.close()
+ for i, word in enumerate(words):
+ words[i] = word.lower().strip('.”“,/1234567890@
+ return words
+
+def func3(words, word):
+ fl = 0
+ num = 0
+ while fl != 1:
+
+ try:
+ ind = words.index(word)
+ except ValueError:
+ fl = 1
+ continue
+ num += 1
+ words.pop(ind)
+ print(word, ': frequency = ', num, sep = '')
+ return words
+def func2(words):
+ prefix = 'omni'
+
+ length = len(prefix)
+ for word in words:
+ if word.startswith(prefix) and length < len(word):
+ words = func3(words, word)
+ words = func3(words, word[length:])
+ print('-------------------------------------')
+def main():
+ func2(func1('file.txt'))
+main()
+
+
+
+
+def func1(name):
+
+
+
+
+ f = open(name, 'r', encoding = 'utf-8', errors = 'ignore')
+ words = f.read().replace('\n', ' ').split()
+ f.close()
+ for i, word in enumerate(words):
+ words[i] = word.lower().strip('.”“,/1234567890@
+ return words
+
+def func3(words, word):
+ num = 0
+ for elem in words:
+ if elem == word:
+ num += 1
+ print(word, ': frequency = ', num, sep = '')
+def func2(words):
+ prefix = 'under'
+
+ length = len(prefix)
+ l = []
+ for word in words:
+ if word.startswith(prefix) and length < len(word) and word not in l:
+ func3(words, word)
+ func3(words, word[length:])
+ print('-------------------------------------')
+ l.append(word)
+def main():
+ func2(func1('file.txt'))
+main()
+
+
+import os
+def files_and_folders():
+ lst = os.listdir('.')
+ files = []
+ folders = []
+ for f in lst:
+ if os.path.isfile(f):
+ files.append(f)
+ else:
+ folders.append(f)
+ d_files = {}
+ for f in files:
+ f_name, f_ext = os.path.splitext(f)
+ if f_name not in d_files:
+ d_files[f_name] = 1
+ else:
+ d_files[f_name] += 1
+
+ return d_files, folders
+def counting(d_files):
+ num = 0
+ punct_marks = '.!?:;,-()"\'<>'
+
+ for key in d_files:
+ fl = 0
+ i = 0
+ while fl != 1 and i < len(punct_marks):
+ if punct_marks[i] in key:
+ fl = 1
+ i += 1
+ if fl == 1:
+ num += d_files[key]
+ return num
+def output(num, d_files, d_folders):
+
+ print('Количество файлов, названия которых содержит знаки препинания = ', num)
+ print('Названия файлов и папок в данной папке следующие:')
+ i = 1
+ for key in d_files:
+ print('%s) %s' % (str(i), str(key)))
+ i += 1
+ for key in d_folders:
+ if key not in d_files:
+ print('{}) {}'.format(str(i), str(key)))
+ i += 1
+def main():
+ d_files, folders = files_and_folders()
+ num = counting(d_files)
+ output(num, d_files, folders)
+if __name__ == '__main__':
+ main()
+
+import os
+def walking():
+ num = 0
+ for root, dirs, files in os.walk('.'):
+ d_files = {}
+ flag = False
+ for file in files:
+ file_name, file_ext = os.path.splitext(file)
+ if file_ext not in d_files:
+ d_files[file_ext] = 1
+ else:
+ flag = True
+ break
+ if flag:
+ num += 1
+ return num
+def main():
+ num = walking()
+ print('Количество папок, в которых встречаются несколько файлов с одним\
+и тем же расширением = {}.'.format(num))
+if __name__ == '__main__':
+ main()
+
+import os
+def walking():
+ num = 0
+ for root, dirs, files in os.walk('.'):
+ d_files = {}
+ flag = False
+ for file in files:
+ file_name, file_ext = os.path.splitext(file)
+ if file_ext not in d_files:
+ d_files[file_ext] = 1
+ else:
+ flag = True
+ print(file)
+ break
+ if not flag:
+ num += 1
+ return num
+def main():
+ num = walking()
+ print('Количество папок, в которых встречаются несколько файлов с одним\
+и тем же расширением = {}.'.format(num))
+if __name__ == '__main__':
+ main()
+import re
+def reading(name):
+ f = open(name, 'r', encoding = 'utf-8')
+ words = f.read().split(' ')
+ f.close()
+ return words
+def cleaning(words):
+ for i, word in enumerate(words) :
+ words[i] = word.lower().strip('.,/1234567890@
+ return words
+def printing(words):
+ l = []
+ for word in words:
+ if re.search('кот', word) and word not in l:
+ l.append(word)
+ print(word)
+def main():
+ words = reading(input('Введите, пожалуйста, название файла:\n'))
+ words = cleaning(words)
+ printing(words)
+if __name__ == '__main__':
+ main()
+
+n = float(input('Введите любое число\n'))
+print('число | ', n)
+for i in range(9 + len(str(round(n * 10, 3)))) :
+ print('-', end = '')
+print()
+for i in range(1,11) :
+ if i != 10 :
+ print(i, ' | ', round(i * n, 3), end = '\n')
+ else :
+ print(i, ' | ', round(i * n, 3), end = '\n')
+
+n = float(input('Введите любое число\n'))
+for i in range(1,11) :
+ print(i, '*', n, '=', i * n, end = '\n')
+import re
+def reading(name):
+ f = open(name, 'r', encoding = 'utf-8')
+ lines = f.readlines()
+ f.close()
+ return lines
+def array(lines):
+ text = ''.join(lines)
+ text = re.sub('((.|\n)*)', '\\1', text)
+ text = re.sub('<[wc](.*?)>(.*?)', '\\1 \\2', text)
+ print(text)
+ l = re.findall('lemma="(.*?)" type="(.*?)" (.*)', text)
+ return l
+def recording1(d, n):
+ f = open(input('Введите, пожалуйста, название выходного файла\n'), 'a', encoding = 'utf-8')
+ f.write(str(n) + '\n')
+ for key in d.keys():
+ f.write(key + '\n')
+ f.close()
+def recording2(d):
+ f = open(input('Введите, пожалуйста, название выходного файла\n'), 'a', encoding = 'utf-8')
+
+ for key, value in d.items():
+ if re.search('l.f.*', key):
+ f.write(key + ' - ' + str(value) + '\n')
+ f.close()
+def recording3(l):
+ name = input('Введите, пожалуйста, название выходного файла в формате csv\n')
+
+ while not name.endswith('.csv'):
+ name = input('Введите, пожалуйста, название выходного файла в формате csv\n')
+ f = open(name, 'a', encoding = 'utf-8')
+ for i, elem in enumerate(l):
+ f.write(elem[0] + ',' + elem[1] + ',' + elem[2] + '\n')
+ f.close()
+def dictionary(lines):
+ d = {}
+ for line in lines:
+ r = re.search('lemma=".*" type="(.*)"', line)
+ if r:
+ key = r.group(1)
+ if key in d:
+ d[key] += 1
+ else:
+ d[key] = 1
+ return d
+def main():
+ name = input('Введите, пожалуйста, название входного файла\n')
+ lines = reading(name)
+ n = len(lines)
+ d = dictionary(lines)
+ recording1(d, n)
+ recording2(d)
+ l = array(lines)
+ recording3(l)
+if __name__== '__main__':
+ main()
+import random
+
+def noun() :
+ f = open('nouns.txt', 'r', encoding = 'utf-8')
+ nouns = f.read().split()
+ f.close()
+ return random.choice(nouns)
+
+def personal_pronoun() :
+ f = open('personal_pronouns.txt', 'r', encoding = 'utf-8')
+ pronouns = f.read().split()
+ f.close()
+ return random.choice(pronouns)
+
+def adjective_before_noun() :
+ f = open('adjectives_before_noun.txt', 'r', encoding = 'utf-8')
+ adj = f.read().split()
+ f.close()
+ return random.choice(adj)
+
+def adjective_after_noun() :
+ f = open('adjectives_after_noun.txt', 'r', encoding = 'utf-8')
+ adj = f.read().split()
+ f.close()
+ return random.choice(adj)
+
+def adverb() :
+ f = open('adverbs.txt', 'r', encoding = 'utf-8')
+ adverbs = f.read().split()
+ f.close()
+ return random.choice(adverbs)
+
+def intensifier(adv):
+ f = open('intensifiers.txt', 'r', encoding = 'utf-8')
+ intensifiers = f.read().split()
+ f.close()
+ return random.choice(intensifiers) + ' ' + adv
+
+def transitive_infinitive() :
+ f = open('transitive_infinitives.txt', 'r', encoding = 'utf-8')
+ inf = f.read().split()
+ f.close()
+ return random.choice(inf)
+
+def intransitive_infinitive() :
+ f = open('intransitive_infinitives.txt', 'r', encoding = 'utf-8')
+ inf = f.read().split()
+ f.close()
+ return random.choice(inf)
+
+def temporary_marker() :
+ f = open('temporary_markers.txt', 'r', encoding = 'utf-8')
+ temporary_markers = f.read().split()
+ f.close()
+ return random.choice(temporary_markers)
+
+def interrogative() :
+ f = open('interrogatives.txt', 'r', encoding = 'utf-8')
+ interrogatives = f.read().split()
+ f.close()
+ return random.choice(interrogatives)
+
+def number() :
+ f = open('numbers.txt', 'r', encoding = 'utf-8')
+ numbers = f.read().split()
+ f.close()
+ return random.choice(numbers)
+
+
+def declension(noun, adjective, number) :
+ f = open('declension_of_nouns.txt', 'r', encoding = 'utf-8')
+ g = open('declension_of_adjectives.txt', 'r', encoding = 'utf-8')
+ nouns = dict()
+ adjectives = dict()
+ for line in f.readlines() :
+ s = line.split(' ', maxsplit = 1)
+ nouns[s[0]] = s[1].split()
+ for line in g.readlines() :
+ s = line.split(' ', maxsplit = 1)
+ adjectives[s[0]] = s[1].split()
+ f.close()
+ g.close()
+ if nouns[noun][0] == 'm' and number == 'sg' :
+ return noun, adjective, random.choice(['le', 'un'])
+ elif nouns[noun][0] == 'm' and number == 'pl' :
+ return nouns[noun][1], adjectives[adjective][1], random.choice(['les', 'des'])
+ elif nouns[noun][0] == 'f' and number == 'sg' :
+ return noun, adjectives[adjective][0], random.choice(['la', 'une'])
+ elif nouns[noun][0] == 'f' and number == 'pl' :
+ return nouns[noun][1], adjectives[adjective][2], random.choice(['les', 'des'])
+
+def collocation_bef(noun, adj_before_noun, article) :
+ return article + ' ' + adj_before_noun + ' ' + noun
+
+def collocation_aft(noun, adj_after_noun, article) :
+ return article + ' ' + noun + ' ' + adj_after_noun
+
+def conjugation(pronoun, infinitive) :
+ f = open('conjugations.txt', 'r', encoding = 'utf-8')
+ verbs = dict()
+ for line in f.readlines() :
+ s = line.split(' ', maxsplit = 1)
+ verbs[s[0]] = s[1].split()
+ f.close()
+ if pronoun == 'je' :
+ return verbs[infinitive][0]
+ elif pronoun == 'tu' :
+ return verbs[infinitive][1]
+ elif pronoun == 'il' or pronoun == 'elle' :
+ return verbs[infinitive][2]
+ elif pronoun == 'nous' :
+ return verbs[infinitive][3]
+ elif pronoun == 'vous' :
+ return verbs[infinitive][4]
+ else :
+ return verbs[infinitive][5]
+
+def affirmative_sequence(pronoun, verb) :
+ if verb[0] in 'aàâeéèêiîoôuùûy' and pronoun == 'je' :
+ return "j'" + verb
+ else :
+ return pronoun + ' ' + verb
+
+def interrogative_sequence(pronoun, verb) :
+ if verb[len(verb) - 1] in 'aàâeéèêiîoôuùûy' and pronoun[0] in 'aàâeéèêiîoôuùûy' :
+ return verb + '-t-' + pronoun
+ else :
+ return verb + '-' + pronoun
+
+def affirmative_sentence() :
+ pron = personal_pronoun()
+ noun1, adj1, art1 = declension(noun(), adjective_before_noun(), 'sg')
+ noun2, adj2, art2 = declension(noun(), adjective_before_noun(), 'pl')
+ return affirmative_sequence(pron, conjugation(pron, transitive_infinitive())) + ' ' + collocation_bef(noun1, adj1, art1) + ' et ' + number() + ' ' + adj2 + ' ' + noun2 + '.'
+
+def interrogative_sentence() :
+ pron = personal_pronoun()
+ return interrogative() + ' ' + interrogative_sequence(pron, conjugation(pron, intransitive_infinitive())) + ' ' + temporary_marker() + '?'
+
+def negative_sentence() :
+ noun1, adj1, art1 = declension(noun(), adjective_before_noun(), 'pl')
+ noun2, adj2, art2 = declension(noun(), adjective_before_noun(), 'sg')
+ return collocation_aft(noun1, adj1, art1) + ' ne ' + conjugation('elle', transitive_infinitive()) + ' pas ' + collocation_bef(noun2, adj2, art2) + ' ' + temporary_marker() + ' ' + intensifier(adverb()) + '.'
+
+def conditional_sentence() :
+ return '[Здесь должно быть условное предложение, но я пока не представляю, как оно устроено во французском :( ].'
+
+def imperative_sentence() :
+ return 'ne ' + conjugation('vous', intransitive_infinitive()) + ' pas' +'!'
+
+def random_sentence(n) :
+ if n == 1 :
+ return affirmative_sentence()
+ elif n == 2 :
+ return interrogative_sentence()
+ elif n == 3 :
+ return negative_sentence()
+ elif n == 4 :
+ return conditional_sentence()
+ else :
+ return imperative_sentence()
+
+def text_print() :
+ a = set('12345')
+ for n in a :
+ print(random_sentence(int(n)).capitalize(), end = ' ')
+
+text_print()
+
+import re
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def reading(name):
+ f = open(name, 'r', encoding = 'utf-8')
+ words = f.read().replace('\n', ' ').split()
+ f.close()
+ return words
+
+def cleaning(words):
+ for i, word in enumerate(words) :
+ words[i] = word.lower().strip('.,/1234567890@
+ return words
+
+def printing(words):
+ for word in words:
+ if re.search('загру(з(ят(ся)?|и(шь(ся)?|(сь)?|м(ся)?|л((ся)?|а(сь)?|и(сь)?|о(сь)?)|т((ся)?|е(сь)?|ь(ся)?)|в(ш(ую(ся)?|ая(ся)?|е(го(ся)?|му?(ся)?|й(ся)?|е(ся)?|ю(ся)?)|и((сь)?|й(ся)?|м(и)?(ся)?|е(ся)?|х(ся)?)))?))|ж(у(сь)?|ен(а|о|ы)?|ён|(е|ё)нн(ая|ую|о(м(у)?|ю|е|го|й)|ы(м(и)?|й|е|х))))$', word):
+ print(word)
+def main():
+ words = cleaning(reading(input('Введите, пожалуйста, название файла:\n')))
+ printing(words)
+main()
+
+import re
+def reading(name):
+ f = open(name, 'r', encoding = 'utf-8')
+ text = f.read()
+ f.close()
+ return text
+def find(text):
+ r = re.search('\= 0 :
+ bigw += 1
+ else :
+ j = 0
+ while j < len(l[i]) and alph.find(l[i][j]) == -1 :
+ j += 1
+ if j == len(l[i]) :
+ allw -= 1
+ elif alphUP.find(l[i][j]) >= 0 :
+ bigw += 1
+if allw != 0 :
+ print('The percentage of words, which start with uppercase equals to ', round(bigw / allw * 100, 3), '%', sep = '')
+else :
+ if fl == 0 :
+ print('There are no words at all! Try to use another file.')
+ else :
+ print('There are some symbols, but no words in Russian. Try to use another file!')
+f.close()
+
+
+
+fl = 0
+while fl != 1 :
+ word = input('Please input one word:\n')
+ ind = word.find(' ')
+ if ind == -1 :
+ fl = 1
+ else :
+ if ind == 0 :
+ word = word[1:]
+ flag = word.find(' ')
+ while flag == 0 :
+ word = word[1:]
+ flag = word.find(' ')
+ if flag > 0 :
+ subword = word[flag:]
+ ind = subword.find(' ')
+ while ind == 0 :
+ subword = subword[1:]
+ ind = subword.find(' ')
+ if subword != '' :
+ print('There is more than one word. Please try again!')
+ else :
+ word = word[:flag]
+ fl = 1
+ else :
+ if word != '' :
+ fl = 1
+ else :
+ print("You didn't type any word! Please try again!")
+ else :
+ subword = word[ind:]
+ flag = subword.find(' ')
+ while flag == 0 :
+ subword = subword[1:]
+ flag = subword.find(' ')
+ if subword != '' :
+ print('There is more than one word. Please try again!')
+ else :
+ word = word[:ind]
+ fl = 1
+for i in range(len(word)) :
+ print(word[i:])
+
+fl = 0
+while fl != 1 :
+ word = input('Please input one word:\n')
+ word = word.strip()
+ ind = word.find(' ')
+ if ind == -1 :
+ if word != '' :
+ fl = 1
+ else :
+ print("You didn't type any word! Please try again")
+ else :
+ print('There is more than one word. Please try again!')
+for i in range(len(word)) :
+ print(word[i:])
+
+
+
+a = float(input('enter the first number\n'))
+b = float(input('enter the second number\n'))
+c = float(input('enter the third number\n'))
+if b == 0. :
+ print('you can\'t divide by zero')
+elif a % b == c and a / b == c :
+ print('YES')
+else :
+ print('NO')
+
+
+a = float(input('enter the first number\n'))
+b = float(input('enter the second number\n'))
+c = float(input('enter the third number\n'))
+if b == 0. :
+ print('you can\'t divide by zero')
+else :
+ if a % b == c :
+ print('YES, a % b == c')
+ else :
+ print('NO, a % b != c')
+ if a / b == c :
+ print('YES, a / b == c')
+ else :
+ print('NO, a / b != c')
+
+
+a = int(input('enter the first number\n'))
+b = int(input('enter the second number\n'))
+c = int(input('enter the third number\n'))
+if b == 0 :
+ print('you can\'t divide by zero')
+elif a % b == c and a / b == c :
+ print('YES')
+else :
+ print('NO')
+
+
+a = int(input('enter the first number\n'))
+b = int(input('enter the second number\n'))
+c = int(input('enter the third number\n'))
+if b == 0 :
+ print('you can\'t divide by zero')
+else :
+ if a % b == c :
+ print('YES, a % b == c')
+ else :
+ print('NO, a % b != c')
+ if a / b == c :
+ print('YES, a / b == c')
+ else :
+ print('NO, a / b != c')
+import re
+import os
+import csv
+def printing(d1, d2, arr):
+ f = open('output1.txt', 'w', encoding = 'cp1251')
+ for key, value in sorted(d1.items()):
+ f.write(key + '\t' + str(value) + '\n')
+ f.close()
+ with open('output2.csv', 'w', encoding = 'cp1251') as csv_file:
+ writer = csv.writer(csv_file, delimiter = ';')
+ writer.writerow(['Название файла', 'Автор', 'Дата создания текста'])
+ for key, value in sorted(d2.items()):
+ lst = [str(key), str(value[0]), str(value[1])]
+ writer.writerow(lst)
+ f = open('output3.txt', 'w', encoding = 'cp1251')
+ for elem in arr:
+ f.write(elem + '\n')
+ f.close()
+def dictionary(name):
+ d1 = {}
+ d2 = {}
+ arr = []
+ for file in os.listdir(name):
+ with open(os.path.join(name, file), 'r', encoding = 'cp1251') as text:
+ text = text.read()
+ a = re.findall('(.*?)', text)
+ d1[file] = len(a)
+ b = re.findall('<.*?>