def main():
try:
with open('assets/type_1_refactor_naming_elements/original.txt',
'r',
encoding='utf8') as original:
original_contents = original.readlines()
original_contents = [
''.join(content.strip().split('|'))
for content in original_contents
]
with open('assets/type_1_refactor_naming_elements/naming_list.txt',
'r',
encoding='utf8') as source:
contents = source.readlines()
contents = [content.strip() for content in contents]
tokenized_contents = [
list(word_tokenize(content)) for content in contents
]
original_tokenized_contents = [
list(word_tokenize(content)) for content in original_contents
]
with open('assets/type_1_refactor_naming_elements/cosine_values.txt',
'w',
encoding='utf8') as result:
for sentence in (tokenized_contents):
for original_sentence in (original_tokenized_contents):
vector1 = (count(sentence))
vector2 = (count(original_sentence))
cosine = get_cosine(vector1, vector2)
if cosine >= 0.3:
result.write('"' + (''.join(sentence)) + '"' +
' COMPARED TO ' + '"' +
(''.join(original_sentence)) + '"' +
' = ' + str(cosine))
result.write('\n')
with open(
'assets/type_1_refactor_naming_elements/cosine_values_only_value.txt',
'w',
encoding='utf8') as result:
for sentence in (tokenized_contents):
for original_sentence in (original_tokenized_contents):
vector1 = (count(sentence))
vector2 = (count(original_sentence))
cosine = get_cosine(vector1, vector2)
if cosine >= 0.3:
result.write(str(cosine))
result.write('\n')
except Exception as e:
print(e)
def format_winners(winners_data, winners_list, first_season, last_season):
'''
Uses a winner list to generate a pie chart acceptable data set.
'''
for season in range(first_season, last_season + 1):
temp = []
season = str(season)
# make unique winners key amount of wins
seasonal_wins = dict(count(winners_data[season]['constructor']))
# append seasonal winners
seasonal_winners = []
for winner, wins in seasonal_wins.items():
seasonal_winners.append(winner)
temp.append({'label': winner, 'value': wins})
# append non seasonal winners with value = 0
for winner in winners_list:
if winner not in seasonal_winners:
temp.append({'label': winner, 'value': 0})
# sort the temp list alphabetically
sorted_list = sorted(temp, key=lambda k: k['label'])
winners_data[season]['constructor'] = sorted_list
def hand(self):
player_roll = self.roll
most_common = count(self.roll).most_common(
5) #Checks for dices that are the same
possible_score = []
if set(player_roll) == 1 and self.check_if_score("Yatzy") == "":
possible_score.append("Yatzy")
else:
if player_roll == [
2, 3, 4, 5, 6
] and self.check_if_score("Large Straight") == "":
hand_score = "Large Straight"
possible_score.append(hand_score)
if player_roll == [
1, 2, 3, 4, 5
] and self.check_if_score("Small Straight") == "":
hand_score = "Small Straight"
possible_score.append(hand_score)
if most_common[0][1] == 3 and most_common[1][
1] == 2 and self.check_if_score("Full House") == "":
hand_score = "Full House"
possible_score.append(hand_score)
if most_common[0][1] == 4 and self.check_if_score(
"Four Of A Kind") == "":
hand_score = "Four Of A Kind"
possible_score.append(hand_score)
if most_common[0][1] == 3 and self.check_if_score(
"Three Of A Kind") == "":
hand_score = "Three Of A Kind"
possible_score.append(hand_score)
if most_common[0][1] == 2 and most_common[1][
1] == 2 and self.check_if_score("Two Pairs") == "":
hand_score = "Two Pairs"
possible_score.append(hand_score)
if most_common[0][1] == 2 and self.check_if_score("Pair") == "":
hand_score = "Pair"
possible_score.append(hand_score)
if 6 in player_roll and self.check_if_score("6") == "":
hand_score = "6"
possible_score.append(hand_score)
if 5 in player_roll and self.check_if_score("5") == "":
hand_score = "5"
possible_score.append(hand_score)
if 4 in player_roll and self.check_if_score("4") == "":
hand_score = "4"
possible_score.append(hand_score)
if 3 in player_roll and self.check_if_score("3") == "":
hand_score = "3"
possible_score.append(hand_score)
if 2 in player_roll and self.check_if_score("2") == "":
hand_score = "2"
possible_score.append(hand_score)
if 1 in player_roll and self.check_if_score("1") == "":
hand_score = "1"
possible_score.append(hand_score)
if self.check_if_score("Chance") == "":
possible_score.append("Chance")
return possible_score
def new_order(self, event=None):
self.subtotal = self.tax = self.total = 0
for item in self.items.values():
item.button.config(state=tk.NORMAL)
self.box.delete(0, tk.END)
self.current_order = count()
self.current_codes = []
self.update_totals()
def score(s):
occurrences = count(s)
odd = 0
score = 0
for o in occurrences:
if (not odd):
if (occurrences[o] % 2):
odd = 1
score += (occurrences[o] // 2) * 2
return score + odd
def getTextCount(self): """ Regular expression that will look for English words It returns a Count object with the word frequency :return: object """ pattern = '(?:\w+|[' + re.escape(punctuation) + ']+)' # pattern = '\w+' regex = re.compile(pattern) words = regex.findall(self.getText().lower()) return count(words).items()
def rotate(cipher, ch):
alphabet = "abcdefghijklmnopqrstuvwxyz".upper()
plain = ""
num = alphabet.find(ch)
if num:
for char in cipher:
idx = alphabet.find(char) - num
plain += alphabet[idx]
print(count(plain))
return plain
else:
return False
def beauty_strings(s):
res = 0
out = s.translate(string.maketrans("", ""), string.punctuation)
c = count(out.replace(" ", ""))
a = c.most_common(26)
keys = []
values = reversed(range(1, 27))
for i in a:
keys.append(i[0])
dct = dict(zip(keys, values))
for c in s:
res += dct.get(c, 0)
return res
def tf_idf(self):
for word in self.word_bank:
print(word)
temp = self.word_bank[word]
t = count(temp)
te = t.keys()
tv = t.values()
w = []
for name in range(len(te)):
tr = tv[name] * math.log10(self.total_len / len(te))
# print (te[name], tr)
w.append([te[name], tr])
self.word_bank[word]=w
def __init__(self, parent):
self.parent = parent
self.money = 0
self.items = {
"candy bar":
Item(
"candy bar", 165,
tk.Button(root,
text="candy bar",
command=lambda: self.scan("cand bar"))),
"soda":
Item(
"soda", 115,
tk.Button(root, text="soda",
command=lambda: self.scan("soda"))),
"chips":
Item(
"chips", 285,
tk.Button(root,
text="chips",
command=lambda: self.scan("chips"))),
"granola bar":
Item(
"granola bar", 145,
tk.Button(root,
text="granola bar",
command=lambda: self.scan("granola bar"))),
"almond milk":
Item(
"almond milk", 535,
tk.Button(root,
text="almond milk",
command=lambda: self.scan("almond milk")))
}
self.server_label = tk.Label(root, text="Cashier: Christina")
self.server_label.grid(row=0, column=0, sticky='w')
self.time_label = tk.Label(root, text='')
self.time_label.grid(row=0, column=1, sticky='E')
for idx, item in enumerate(self.items.values(), start=1):
item.button.grid(row=idx, column=0, sticky='w')
self.frame = tk.Frame(root)
self.frame.grid(row=1, column=1, rowspan=6)
self.scrollbar = tk.Scrollbar(self.frame, orient=tk.VERTICAL)
self.box = tk.Listbox(self.frame,
yscrollcommand=self.scrollbar.set,
width=25)
self.scrollbar.config(command=self.box.yview)
self.box.grid(row=0, column=1, sticky='NS')
self.current_order = count()
self.tick()
def text_process(request):
value = request.POST.get("string")
string = "Original String capitalized : " + value.capitalize()
string += "<br> Number of characters in this string are : " + str(
len(value))
string += "<br> Number of vowels in this string are : " + str(
value.count('a') + value.count('e') + value.count('i') +
value.count('o') + value.count('u'))
counts = count(value)
result = {
'result': string,
'charcount': counts,
}
return render(request, 'textutils_result.html', result)
def cantidad_cursos(horario):
puntaje = 0
cursos = []
for dia in horario:
for hora in horario[dia]:
for salon in horario[dia][hora]:
cursos.append(horario[dia][hora][salon].numero)
cursos = count(cursos) #Se usa el metodo Count el cual retorna un diccionario con los cursos que tenga el horario y la frecuencia en que aparecen los mismos
cursos_faltantes = total_cursos - len(cursos.keys())
if(cursos_faltantes > 0): puntaje += 5000*(cursos_faltantes) #Se penalizan los cursos faltantes
bloques_cursos = cursos.values()
for bloque in bloques_cursos:
bloques_adicionales = abs(horas_semanales/2 - bloque)
if(bloques_adicionales > 0): puntaje += 500*(bloques_adicionales) #Se penalizan los bloques de cursos faltantes o excesivos
return puntaje
def build_hashtag_freq(tweets):
hashtag_counts = {}
for tweet in tweets: #each tweet will be a Python dictionary
hashtags = extract_hashtags(tweet['text'].encode('ascii', 'ignore'))
for hashtag in hashtags:
if hashtag in hashtag_counts:
hashtag_counts[hashtag] += 1
else:
hashtag_counts[hashtag] = 1
top_hashtags = {'hashtags': []}
hashtag_counts = count(hashtag_counts)
for k, v in hashtag_counts.most_common(7):
top_hashtags['hashtags'].append([k, v])
return top_hashtags
def score(hand):
"""
Compute the maximal score for a Yahtzee hand according to the
upper section of the Yahtzee score card.
hand: full yahtzee hand
Returns an integer score
"""
retval = 0
counter = count(hand).most_common()
if len(hand) > 0:
for item in counter:
if item[0] * item[1] > retval:
retval = item[0] * item[1]
return retval
def score(hand):
"""
Compute the maximal score for a Yahtzee hand according to the
upper section of the Yahtzee score card.
hand: full yahtzee hand
Returns an integer score
"""
retval = 0
counter = count(hand).most_common()
if len(hand) > 0:
for item in counter:
if item[0] * item[1] > retval:
retval = item[0] * item[1]
return retval
def __init__(self, parent):
self.parent = parent
parent.title('Point of Sale')
self.font = ('Courier New', 12)
self.till = 0
self.TAX = 1.08
self.items = {'lemonade':Item('Lemonade', 50,
tk.Button(root,
text='Lemonade',
command=lambda: self.scan('lemonade'),
font=self.font)),
'grapefruit_juice':Item('Grapefruit Juice', 75,
tk.Button(root,
text='Grapefruit Juice',
command=lambda: self.scan('grapefruit_juice'),
font=self.font)),
'cookie':Item('Cookie', 100,
tk.Button(root,
text='Cookie',
command=lambda: self.scan('cookie'),
font=self.font))}
self.MAX_NAME_WIDTH = max(map(len, (item.name for item in self.items.values()))) + 3
self.MAX_PRICE_WIDTH = 10
self.server_label = tk.Label(root, text='Cashier: Bob', font=self.font)
self.server_label.grid(row=0, column=0, sticky='W')
self.time_label = tk.Label(root, text='', font=self.font)
self.time_label.grid(row=0, column=1, sticky='E')
for idx,item in enumerate(self.items.values(), start=1):
item.button.grid(row=idx, column=0, sticky='W')
self.frame = tk.Frame(root)
self.frame.grid(row=1, column=1, rowspan=3)
self.scrollbar = tk.Scrollbar(self.frame, orient=tk.VERTICAL)
self.box = tk.Listbox(self.frame,
yscrollcommand=self.scrollbar.set,
width=self.MAX_NAME_WIDTH + self.MAX_PRICE_WIDTH,
font=self.font)
self.scrollbar.config(command=self.box.yview)
self.box.grid(row=0, column=1, sticky='NS')
self.scrollbar.grid(row=0, column=2, sticky='NS')
self.box.bind("<Double-Button-1>", self.modify_item)
self.total_label = tk.Label(root, text='', font=self.font)
self.total_label.grid(row=4, column=1, sticky='E')
self.current_order = count()
self.current_codes = []
self.update_totals()
self.tick()
def are_adj(num):
adj = []
if num[0] == num[1]:
adj.append(num[0])
if num[1] == num[2]:
adj.append(num[1])
if num[2] == num[3]:
adj.append(num[2])
if num[3] == num[4]:
adj.append(num[3])
if num[4] == num[5]:
adj.append(num[4])
test = count(adj).values()
if 1 in test:
return True
else:
return False
def filter_K_foldable(annotated, annotated_stats, K):
"""Filter peptides divisible into K cv-folds.
Returns sparser copies of the original DF and its statistics.
Derprecated.
Args:
annotated (pd.DataFrame): Annotated peptides.
annotated_stats (pd.DataFrame): Statistics on peptide groups.
K (int): Number of folds.
"""
run_counts = count(annotated_stats.runs)
infrequent_runs = set(el for el, cnt in run_counts.items() if cnt < K)
annotated_cv = annotated[~annotated.runs.isin(infrequent_runs)]
annotated_stats_cv = annotated_stats[~annotated_stats.runs.
isin(infrequent_runs)]
return annotated_cv, annotated_stats_cv, run_counts
def gramGraph(tokens, n, name, top=30):
countGram = count(listGrams(tokens, n))
test = countGram.most_common(top)
labels = []
values = []
indexes = range(len(test))
for i in indexes:
labels.append(', '.join(test[i][0]))
values.append(test[i][1])
fig = plt.gcf()
fig.set_size_inches(.7 * top, 10)
plt.bar(indexes, values, 1)
plt.xticks(indexes, labels, rotation=70, ha='right')
plt.title(name, fontsize=20)
return fig
def solution(N, stages):
answer = []
failure = dict()
userStage = count(stages)
totalUser = len(stages)
for i in range(1, N + 1):
stayUsers = userStage[i]
if stayUsers == 0:
failure[i] = 0
else:
failure[i] = stayUsers / totalUser
totalUser -= stayUsers
sorted_failure = sorted(failure.items(),
key=operator.itemgetter(1),
reverse=True)
for k, v in sorted_failure:
answer.append(k)
return answer
def mostFrequent(text, k):
wordsArray = text.split(" ") #O(n)
histogramOfWords = count(wordsArray) #O(n)
print(histogramOfWords)
lenHistogramOfWords = len(histogramOfWords)
results = []
while len(results) < k and lenHistogramOfWords > 0:
word = None
currentMax = float('-inf')
for key in histogramOfWords:
tempMax = currentMax
currentMax = max(currentMax, histogramOfWords[key])
if currentMax != tempMax or word == None:
word = key
results.append(word)
del histogramOfWords[word]
lenHistogramOfWords -= 1
return results
root = ET.fromstring(t_read)
doc_no = root.find('DOCNO').text
title = root.find('TITLE').text
text = root.find('TEXT').text
result = tokenizer(title + text)
for word in result:
if word in word_bank:
word_bank[word].append(doc_no)
else:
word_bank[word] = []
word_bank[word].append(doc_no)
file = 0
for word in word_bank:
temp = word_bank[word]
t = count(temp)
# print(t.keys(),t.values())
file += 1
te = t.keys()
tv = t.values()
w = []
# print(te)
for name in range(len(te)):
tr = tv[name] * math.log10(4 / len(te))
print(te[name], tr)
w.append([te[name], tr])
# print (te[name],tv[name]*math.log10(4/len(te)))
print('word completed')
print("-----------------------")
def reducefn(author, terms): # i.e. key, value from collections import Counter as count return count(terms)
# Path to cipher file
file1 = "./found2"
# Set key length
key_len = 6
# Read cipher file
f = open(file1)
found = f.readline()
found = found.replace(" ", "") # remove spaces
# Split cipher text into n (key_length) different mono alphapbetic ciphers
split_list = split_cipher(found, key_len)
for cipher in split_list:
print(count(cipher))
# 5 10 15 20 25
#alphabet = "abcdefghijklmnopqrstuvwxyz"
print("Frequency plain text:")
rot = []
rot.append(rotate(split_list[0], 'F'))
rot.append(rotate(split_list[1], 'R'))
rot.append(rotate(split_list[2], 'E'))
rot.append(rotate(split_list[3], 'K'))
rot.append(rotate(split_list[4], 'E'))
rot.append(rotate(split_list[5], 'Y'))
join_rot = join_cipher(rot, key_len)
print_with_len(join_rot, key_len)
def insert_new_player(self, x, y):
n = count(y)
self.cur.execute(
"insert into {}(player_name,run,six,four) values(?,?,?,?)".format(
self.game_name), (x, sum(y), n[6], n[4]))
self.db.commit()
from collections import count str = "vini is a little girl" counter = count(str) print count['a']
#!/usr/bin/python3
'''
john works at clothing store. He has a large pile of socks that he must pair by color for sale. Given an array of integers representing the color of each soc, determine how many pairs of socks with matching colors there are.
For Example, there are n = 7 socks with colors ar = [1,2,1,2,1,3,2]. There is one pair of color 1 and one of color 2.
and there are three odd socks left, one of each color. The number of pairs is 2.
Example: - Sample Input = 9
10 20 20 10 10 10 30 50 10 20
Sample Output = 3
'''
from collections import Counter as count
n = int(input())
socks = count(input().split())
print(sum(map(lambda x: x // 2, socks.values())))
print("Something wicked happened when trying to read from the database", file=stderr)
print(e, file=stderr)
exit(5)
finally:
db.close()
connection.close()
###################################################
### DATA OUTPUT ###
###################################################
# OUTPUT ON STDOUT #
from collections import Counter as count
formattedResults = count(dataToAnalyze)
total = len(dataToAnalyze)
print("\n".join([key+"\t"+str(formattedResults[key])+"\t"+str(formattedResults[key]*100.0/total)+"%" for key in sorted(formattedResults)]))
# PIE CHART OUTPUT #
try:
from matplotlib import pyplot as plt
except ImportError as e:
print("You don't appear to have matplotlib installed. Try `sudo apt install python3-matplotlib` or `sudo -H pip3 install matplotlib` and then run this program again.", file=stderr)
exit(3)
### set up inputs to matplotlib from the data ###
labels = tuple(sorted(formattedResults)) #pie slice labels
sizes = [formattedResults[label] for label in labels] #just the counts for each label (in the same order!)
def out_info(self, x, y, total_out):
n = count(y)
print('{} is out run({}) four({}) six({})'.format(
x, sum(y), n[4], n[6]))
total_out += 1
return total_out
def process_inputs_2(df):
df1 = df.copy()
df2 = df.copy()
df3 = df.copy()
df4 = df.copy()
df5 = df.copy()
from collections import Counter as count
bases = []
for j in range(len(df1)):
counts = dict(count(df1.iloc[j]['sequence']))
bases.append((counts['A'] / df1.iloc[j]['seq_length'],
counts['G'] / df1.iloc[j]['seq_length'],
counts['C'] / df1.iloc[j]['seq_length'],
counts['U'] / df1.iloc[j]['seq_length']))
bases = pd.DataFrame(
bases, columns=['A_percent', 'G_percent', 'C_percent', 'U_percent'])
del df1
print("Done : ['A_percent', 'G_percent', 'C_percent', 'U_percent']")
pairs = []
all_partners = []
for j in range(len(df2)):
partners = [-1 for i in range(130)]
pairs_dict = {}
queue = []
for i in range(0, len(df2.iloc[j]['structure'])):
if df2.iloc[j]['structure'][i] == '(':
queue.append(i)
if df2.iloc[j]['structure'][i] == ')':
first = queue.pop()
try:
pairs_dict[(df2.iloc[j]['sequence'][first],
df2.iloc[j]['sequence'][i])] += 1
except:
pairs_dict[(df2.iloc[j]['sequence'][first],
df2.iloc[j]['sequence'][i])] = 1
partners[first] = i
partners[i] = first
all_partners.append(partners)
pairs_num = 0
pairs_unique = [('U', 'G'), ('C', 'G'), ('U', 'A'), ('G', 'C'),
('A', 'U'), ('G', 'U')]
for item in pairs_dict:
pairs_num += pairs_dict[item]
add_tuple = list()
for item in pairs_unique:
try:
add_tuple.append(pairs_dict[item] / pairs_num)
except:
add_tuple.append(0)
pairs.append(add_tuple)
pairs = pd.DataFrame(pairs,
columns=['U-G', 'C-G', 'U-A', 'G-C', 'A-U', 'G-U'])
del df2
print("Done : ['U-G', 'C-G', 'U-A', 'G-C', 'A-U', 'G-U']")
pairs_rate = []
for j in range(len(df3)):
res = dict(count(df3.iloc[j]['structure']))
pairs_rate.append(res['('] / (df3.iloc[j]['seq_length'] / 2))
pairs_rate = pd.DataFrame(pairs_rate, columns=['pairs_rate'])
del df3
loops = []
for j in range(len(df4)):
counts = dict(count(df4.iloc[j]['predicted_loop_type']))
available = ['E', 'S', 'H', 'B', 'X', 'I', 'M']
row = []
for item in available:
try:
row.append(counts[item] / df4.iloc[j]['seq_length'])
except:
row.append(0)
loops.append(row)
loops = pd.DataFrame(loops, columns=available)
del df4
print("Done : ['E', 'S', 'H', 'B', 'X', 'I', 'M']")
return pd.concat([df5, bases, pairs, loops, pairs_rate], axis=1)
def add_score(self, comb):
comb = comb.title()
most_common = count(self.roll).most_common(5)
if comb not in self.hand():
if self.player == 1:
if self.score[comb] == "":
self.score[comb] = 0
else:
if self.score2[comb] == "":
self.score2[comb] = 0
else:
if comb == "Yatzy":
if self.player == 1:
self.score[comb] = 50
else:
self.score2[comb] = 50
elif comb == "Large Straight":
if self.player == 1:
self.score[comb] = 40
else:
self.score2[comb] = 40
elif comb == "Small Straight":
if self.player == 1:
self.score[comb] = 30
else:
self.score2[comb] = 30
elif comb == "Full House":
points = most_common[0][0] * most_common[0][1]
points2 = most_common[1][0] * most_common[1][1]
if self.player == 1:
self.score[comb] = points + points2
else:
self.score2[comb] = points + points2
elif comb == "Four Of A Kind":
points = most_common[0][0] * most_common[0][1]
if self.player == 1:
self.score[comb] = points
else:
self.score2[comb] = points
elif comb == "Three Of A Kind":
points = most_common[0][0] * most_common[0][1]
if self.player == 1:
self.score[comb] = points
else:
self.score2[comb] = points
elif comb == "Two Pairs":
points = most_common[0][0] * most_common[0][1]
points2 = most_common[1][0] * most_common[1][1]
if self.player == 1:
self.score[comb] = points + points2
else:
self.score2[comb] = points + points2
elif comb == "Pair":
points = most_common[0][0] * most_common[0][1]
if self.player == 1:
self.score[comb] = points
else:
self.score2[comb] = points
elif comb == "6":
points = [x for x in self.roll if x == 6]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "5":
points = [x for x in self.roll if x == 5]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "4":
points = [x for x in self.roll if x == 4]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "3":
points = [x for x in self.roll if x == 3]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "2":
points = [x for x in self.roll if x == 2]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "1":
points = [x for x in self.roll if x == 1]
if self.player == 1:
self.score[comb] = sum(points)
else:
self.score2[comb] = sum(points)
elif comb == "Chance" and self.check_if_score("Chance") == "":
if self.player == 1:
self.score[comb] = sum(self.roll)
else:
self.score2[comb] = sum(self.roll)
def listContains(l1, l2):
list1 = count(l1)
list2 = count(l2)
return list1 & list2 == list1 # bitwise &
def parse_line(self, line):
d = {}
c = count(d, line)
return d
return output #%% tokens = tokenList(comments) #%% #docs = ['why hello there', 'omg hello pony', 'she went there? omg'] vec = CountVectorizer() X = vec.fit_transform(tokens[1]) df = pd.DataFrame(X.toarray(), columns=vec.get_feature_names()) print(X) #%% # We have a list of a list of ordered tokens that we need to find the nGrams of countMonogram = count(listGrams(tokens, 1)) countBigram = count(listGrams(tokens, 2)) countTrigram = count(listGrams(tokens, 3)) countTetragram = count(listGrams(tokens, 4)) #%% countMonogram.most_common(30) #%% countBigram.most_common(30) #%% countTrigram.most_common(30) #%% countTetragram.most_common(30) #%% #%%
def score_card_update(self, x, y):
n = count(x)
self.cur.execute(
"update {} set run=?,six=?,four=? where player_name=?".format(
self.game_name), (sum(x), n[6], n[4], y))
self.db.commit()
