请告诉我如何解决这个问题。有一个表格，其中 N 行填充了数字。有必要对列中的元素进行成对相加并除以它们的差异。联合上的正常交叉点。大致我们拥有的：
Col1 Col2 Col3
A
B
C
D
您需要成对执行该函数，以便结果如下：
Col1 Col2 Col3
(A+B)/(A-B)
(A+C)/(A-C)
(A+D)/(A-D)
(B+C)/(B-C)
(B+D)/(B-D)
在各列中，分别表示必须代入每个函数的数字。
请告诉我，我运行了代码，但没有加载 CPU，图表上没有任何动作。没有结果。我的关节在哪里？
stop = stopwords.words('russian')
class TextPreprocessor(BaseEstimator, TransformerMixin):
def __init__(self, n_jobs=-1):
"""
Text preprocessing transformer:
name - name of dataframe, saves files according to name
n_jobs - parallel jobs to run
"""
self.n_jobs = n_jobs
def fit(self, X, name, y=None):
self.name=name
return self
def transform(self, X, *_):
# main transformer
data=self._text_indexing(X)
data=self._multi(self._proc_target, data)
return data
def _proc_target(self, task):
#task=task.reset_index(drop=True, inplace=True)
data=self._preprocess_text(task)
data=self._stemmer(data)
data = self._punc(data)
data = self._stopwords_remover(data)
return data
def _multi(self, target, tasks, workers=None):
if workers is None: workers = max(2, mp.cpu_count() - 1)
pool = mp.Pool(processes=workers)
res = pool.map(target, tasks)
pool.close()
pool.join()
return res
def _preprocess_text(self, text):
low_cased_text = self._low_case(text['text'])
eng_cleaned = self._english(low_cased_text)
stopwords_cleaned = self._stopwords(eng_cleaned)
return self._numbers(stopwords_cleaned)
def _stemmer(self, text):
mst=MyStem(mystem_path='/home/azubochenko/work/plagiat/baseline/pipeline/mystem')
data=[]
for i in text:
data.append(mst._make_mystem_lemma(i))
return data
def _text_indexing(self, data):
for i in data.iloc[0]:
data.rename(columns={0: 'text'}, inplace=True)
return data
def _low_case(self, text):
#text to lower case
return text.str.lower()
def _english(self, text):
#delete english words
return text.apply(lambda x : re.sub(r'[a-z]+', '', x))
def _stopwords(self, text):
#delete stopwords from russian nltk vocabulary
return text.apply(lambda x: " ".join(x for x in str(x).split() if x not in stop))
def _numbers(self, text):
#delete digits
return text.apply(lambda x : re.sub(r'\d+', '', x))
def _punc(self, text):
#delete punctuation
return [[i.translate(str.maketrans(dict.fromkeys(string.punctuation))) for i in j] for j in text]
def _sentence_tok(self, data):
#indexing of texts to paragrapsh and text indexes
corp=[]
text_indexes=[]
indexes=[]
text_idx=0
for i in data.iloc[:,0]:
j=sent_tokenize(i)
sentences=[]
idx=1
text_idx+=1
for k in j:
if len(sentences)<3:
sentences.append(k)
else:
corp.append(str(sentences).strip('[]'))
sentences=[]
indexes.append(idx)
text_indexes.append(text_idx)
idx+=1
return pd.DataFrame({'text': corp, 'paragraph_index':indexes, 'text_index':text_indexes})
def _tokenize(self, data):
#text tokenizing
data.dropna(inplace=True)
return data.apply(word_tokenize)
def _get_text(self, url, encoding='utf-8', to_lower=True):
#stopwords getter of from Github stopwords-iso
url = str(url)
if url.startswith('http'):
r = requests.get(url)
if not r.ok:
r.raise_for_status()
return r.text.lower() if to_lower else r.text
elif os.path.exists(url):
with open(url, encoding=encoding) as f:
return f.read().lower() if to_lower else f.read()
else:
raise Exception('parameter [url] can be either URL or a filename')
def _remove_stopwords(self, tokens, stopwords=None, min_length=4):
#stopwords remover using stopwords-iso
if not stopwords:
return tokens
stopwords = set(stopwords)
tokens = [tok
for tok in tokens
if tok not in stopwords and len(tok) >= min_length]
return tokens
def _stopwords_remover(self, tokens):
url_stopwords_ru = "https://raw.githubusercontent.com/stopwords-iso/stopwords-ru/master/stopwords-ru.txt"
stopwords_ru = self._get_text(url_stopwords_ru).splitlines()
output=[]
[output.append(self._remove_stopwords(x, stopwords=stopwords_ru)) for x in tokens]
return output'''
text_preprocessing=TextPreprocessor()
test_df=text_preprocessing.fit_transform(test, name='test')
怀疑错误出在函数本身_multi，但我不明白在哪里。
pandas.core.series.Series在其中的每个单元格中都有一个类型测试对象list。
我通过转换系列
test=pd.DataFrame(test)
并获得标准数据框，但现在单元格中的数据类型变为pandas.core.series.Series.
我想弄清楚为什么会这样，以及如何通过在所有相同列表的单元格中获取数据框来赢得它。
我最近读了一篇关于 TF-ICF 的文章。简而言之，一般的意思是，与 TF-IDF 不同，我们在语料库中取词，而不是在文档中。这种方法对于文本聚类来说还不错，此外，如果有新文本出现，我们不需要重新计算单词的权重。理论上，这种方法将适用于稀疏矩阵，然后您可以通过余弦相似度或欧几里得或曼哈顿找到相似的文本。
问题 1：在语料库中存储字典长度x文本数量的 稀疏矩阵非常非常昂贵。特别是考虑到任务的细节：搜索相似的文本段落。语料库中的每个文本都被分成段落并搜索相似的段落。随着段落的增长，占用的内存量也会增加，这样的矩阵可能会占用几千兆字节。
问题 2： 创建 { word:weight } 结构的字典也是不可能的，因为 TF ICF 和 TF IDF 一样，是动态的。那些。对于相同单词的每个句子，由于 TF，权重会有所不同（回想一下，这是一个单词在文档中出现的次数与文档中的总单词数之比）。
帮助我想出一种适当的方法来查找相似的段落，而无需求助于创建稀疏矩阵和泡菜存档器。
PS我对此的看法：
谢谢你。
大家好，我对这样的任务很感兴趣：我有一个 csv 文件，每个单元格中都有文本。文本以这样的方式分为段落，每个段落落入一个单独的单元格。您需要在数据框中添加两列：第一列将包含文本的编号，第二列将包含文本中的段落编号。例如，我们有文本 foo 和 bar：
| Абзац | Индекс_Текста | Индекс_Абзаца |
|------- |--------------- |--------------- |
| foo_0 | 0 | 0 |
| foo_1 | 0 | 1 |
| foo_2 | 0 | 2 |
| foo_3 | 0 | 3 |
| bar_0 | 1 | 0 |
| bar_1 | 1 | 1 |
| bar_2 | 1 | 2 |
我处理了如何分成段落和制作 text_indexes 的任务，所以让我们假设我们有一个包含 1 列和 2 列的特定数据框。如何制作段落索引？
您能解释一下为什么 countDown(5) 函数会输出 0 到 5 的结果吗？也就是怎么到值0是可以理解的，但是值1、2、3、4、5是从哪里来的？？？
def countDown(start):
if start <= 0:
print(start)
else:
countDown(start - 1)
print(start)
由于什么是开始新值的分配？
告诉我如何处理错误？我知道服务器并不想响应我的请求，只是阻止了我。如何绕过它？我正在尝试保存来自 NASA 网站的照片。理论上，一切都应该有效，因为这是 Microsoft DEV330x 课程中的一项任务，它适用于所有人。但看起来美国宇航局已经厌倦了这些要求，他们对学生采取了某种保护措施。
%%writefile apod.py
import argparse
from datetime import date, timedelta
from random import randint
import os
import urllib.request
def parse_command_line():
parser = argparse.ArgumentParser()
parser.add_argument("-d",'--date', nargs = 3, metavar = ("month", "day", "year"), action = "store", type = int, help = "month day year formatted date (i.e. 03 28 1998)")
parser.add_argument ('-s', '--surprise', action = 'store_true', help = 'select a random date for a surprise image')
parser.add_argument ('-k', '--api_key', action = "store", type = str, help = 'NASA developer key')
parser.add_argument ('-v', '--verbose', action = 'store_true', help = 'verbose mode')
args = parser.parse_args()
return args
def create_date(datelist, surprise):
try:
if datelist != None:
d = date(datelist[2], datelist[0], datelist[1])
return d
else:
if surprise:
start_date = date(1995,6,16)
end_date = date.today()
delta = end_date - start_date
delta_random = randint(0, delta.days)
d = date.today() - timedelta(delta_random)
return d
else:
end_date = date.today()
d = date.today() - timedelta(days = 1)
return d
except :
return None
def query_url(d, api_key):
global date_obj
date_obj = d.strftime("%Y-%m-%d")
URL = "https://api.nasa.gov/planetary/apod?api_key={}&date={}"
complete_URL = URL.format(api_key,date_obj)
return complete_URL
def save_image(d, image):
year = d.strftime("%Y")
month = d.strftime("%m")
file_path = year+"/"+month+"/"+date_obj+".jpg"
open(file_path, 'wb')
return file_path
def request(url):
# request the content of url and save the retrieved binary data
with urllib.request.urlopen(url) as response:
data = response.read()
# convert data from byte to string
data = data.decode('UTF-8')
# convert data from string to dictionary
data = eval(data)
return data
def download_image(url):
# request the content of url and return the retrieved binary image data
with urllib.request.urlopen(url) as response:
image = response.read()
return image
def main():
# NASA developer key (You can hardcode yours for higher request rate limits!)
API_KEY = "cZX0zRDveiz7AfGfOW23typMH3NCnS3uvQJc0ZNS"
# parse command line arguments
args = parse_command_line()
# update API_KEY if passed on the command line
print(args.api_key)
if args.api_key != '':
API_KEY = args.api_key
# create a request date
d = create_date(args.date, args.surprise)
# ascertain a valid date was created, otherwise exit program
if d is None:
print("No valid date selected!")
exit()
# verbose mode
if args.verbose:
print("Image date: {}".format(d.strftime("%b %d, %Y")))
# generate query url
url = query_url(d, API_KEY)
# verbose mode
if args.verbose:
print("Query URL: {}".format(url))
# download the image metadata as a Python dictionary
metadata = request(url)
# verbose mode
if args.verbose:
# display image title, other metadata can be shown here
print("Image title: {}".format(metadata['title']))
# get the url of the image data from the dictionary
image_url = metadata['url']
# verbose mode
if args.verbose:
print("Downloading image from:", image_url)
# download the image itself (the returned info is binary)
image = download_image(image_url)
# save the downloaded image into disk in (year/month)
# the year and month directories correspond to the date of the image (d)
# the file name is the date (d) + '.jpg'
save_image(d, image)
print("Image saved")
if __name__ == '__main__':
main()
面临错误 ValueError: month out of range。请告诉我原因以及如何修复错误。简单说一下脚本的含义：我们输入月、日、年，我们在输出端得到一个一定格式的数据对象。然后我将添加脚本以仅显示星期几，而不显示输入的数据。
%%writefile day_finder.py
import time, datetime
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("month", type = int, help = "Month as a number (1, 12)")
parser.add_argument("day", type = int, help = "Day as a number (1, 31) depending on the month")
parser.add_argument("year", type = int, help = "Year as a 4 digits number (2018)")
parser.add_argument("-c", "--complete", action = 'store_true', help = "Show complete formatted date")
args = parser.parse_args()
d = ()
d = (args.month, args.day, args.year, 0, 0 , 0 , 0, 0, 0)
date_v = time.strftime("%m,%d,%Y", d)
print (date_v)
运行脚本：
%%bash
python3 day_finder.py 12 31 2017
给定：具有日期类键的字典和具有 4 个类型元素的值列表：
weather = {
datetime.date(1948, 1, 1): [51, 42, 0.47, True],
datetime.date(1948, 1, 2): [45, 36, 0.59, True],
datetime.date(1948, 1, 3): [45, 35, 0.42, True],
datetime.date(1948, 1, 4): [45, 34, 0.31, True],
datetime.date(1948, 1, 5): [45, 32, 0.17, True],
datetime.date(1948, 1, 6): [48, 39, 0.44, True],
...
}
任务是创建一个新字典，将统计每个元素在一年中的平均值，例如：
{
2017:
[45.666666666666664, 34.333333333333336, 2.28, 9, 15]
}
我的代码：
def avg(l):
return sum(l) / float(len(l))
for key in weather.keys():
value = weather[key]
#тут надо что-то написать, но у меня никак не выходит
yearly_weather[key.year] = x
请告诉我如何使用标准工具执行此操作，而不使用 pandas 或 numpy。
请告诉我如何编写 current_date() 函数，以便程序显示今天的日期、年份和月份。需要使用 strftime() 吗？如何使用？
from datetime import datetime
def current_date():
pass
#TODO return month, day, year
m, d, y = current_date()
print("Today's date is: {:2d}/{:2d}/{:4d}".format(m, d, y))
应在列表列表中查找从 1 到 9 输入的数字并返回 True 或 False 的函数无法正常工作。
board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]
location = input("select a number (1, 9):" )
def available(location, board):
for row in board:
if location in row:
return False
else:
return True
available(location, board)
请告诉我，我不明白出了什么问题。
我写了一个井字游戏程序，一切正常，但是当我输入数字 7 时，它说：选择不可用！也就是说，好像 7 无法与 available(location, board) 函数中的 7 进行比较。我不明白错误在哪里。
from IPython.display import clear_output #to clear the output (specific to Jupyter notebooks and ipython)
from random import randint
def draw(board):
for row in board:
print ("\t {} | {} | {}".format(*row))
print ("\t ","-"*10)
def available(location, board):
for row in board:
for col in row:
if location == col:
return False
else:
return True
def mark(player, location, board):
for row in board:
if location in row:
ind = row.index(location)
row.pop(ind)
row.insert(ind, player)
def check_win(board):
if board[0][0] == board[1][0] and board[1][0] == board[2][0]:
return True
elif board[0][1] == board[1][1] and board[1][1] == board[2][1]:
return True
elif board[0][2] == board[1][2] and board[1][2] == board[2][2]:
return True
elif board[0][0] == board[0][1] and board[0][1] == board[0][2]:
return True
elif board[1][0] == board[1][1] and board[1][1] == board[1][2]:
return True
elif board[2][0] == board[2][1] and board[2][1] == board[2][2]:
return True
elif board[0][0] == board[1][1] and board[1][1] == board[2][2]:
return True
elif board[0][2] == board[1][1] and board[1][1] == board[2][0]:
return True
else:
return False
def check_tie(board):
for row in board:
for col in row:
if col.isdigit():
return False
break
else:
return True
def dashes():
print("o" + 35 *'-' + "o")
def display(message):
print("|{:^35s}|".format(message))
def main():
# initializing game
board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]
# select the first player randomly
player = ['X', 'O']
turn = randint(0, 1)
win = False
tie = False
while(not win and not tie):
# switch players
turn = (turn + 1) % 2
current_player = player[turn] # contains 'X' or 'O'
clear_output()
# display header
dashes()
display("TIC TAC TOE")
dashes()
# display game board
print()
draw(board)
print()
# display footer
dashes()
# player select a location to mark
while True:
location = input("|{:s} Turn, select a number (1, 9): ".format(current_player))
if available(location, board):
break # Only the user input loop, main loop does NOT break
else:
print("Selection not available!")
dashes()
# mark selected location with player symbol ('X' or 'O')
mark(current_player, location, board)
# check for win
win = check_win(board)
# check for tie
tie = check_tie(board)
# Display game over message after a win or a tie
clear_output()
# display header
dashes()
display("TIC TAC TOE")
dashes()
# display game board (Necessary to draw the latest selection)
print()
draw(board)
print()
# display footer
dashes()
display("Game Over!")
if(tie):
display("Tie!")
elif(win):
display("Winner:")
display(current_player)
dashes()
main()
在 coursera 上学习了生物信息学课程。有一个我无法解决的问题。关键是我们有两个变量：
我们需要找出哪些组合是最重复的。我找到了一个解决方案，但无法理解一行：
Count = CountDict(Text, k)
我抛出一个错误，据我所知，它的含义是创建字典。
# Input: A string Text and an integer k
# Output: A list containing all most frequent k-mers in Text
def FrequentWords(Text, k):
FrequentPatterns = []
Count = CountDict(Text, k)
m = max(Count.values())
for i in Count:
if Count[i] == m:
FrequentPatterns.append(Text[i:i+k]
FrequentPatternsNoDuplicates = remove_duplicates(FrequentPatterns)
return FrequentPatternsNoDuplicates
请告诉我，随机函数在什么情况下可以接受变量作为条件？例如，我正在尝试编写一个算法，在其中我猜测一个从 0 到 x 的范围，然后我在这个范围内输入一个数字 n，然后计算机尝试猜测这个数字。或多或少是这样的：
x = int(input ("Введите число которое будет окончанием диапазона"))
number = int(input ("Введите число которое будет угадывать компьютер в введенном диапазоне"))
guess = 0
import random
while number != guess:
guess = random.randint(0, x/2)
if guess > number:
x= x + x/2
elif guess < number:
x = x - x/2
print ("Done!", guess)
自然，我得到一个错误，因为 randint 在这种情况下不适合。什么是合适的？
请帮助解决问题。
鉴于：
腿骨列表。有必要迭代列表并找到输入的单词与列表中的单词的匹配。两次尝试，每次尝试后立即响应。此外，您需要计算列表中有多少项目。
这是我生的（我无法以任何方式计算总数）：
foot_bones = ["calcaneus", "talus", "cuboid", "navicular", "lateral cuneiform",
"intermediate cuneiform", "medial cuneiform"]
total = 0
guess = ""
def bones_func (guess, foot_bones, total):
guess = input ("Enter the name of the foot bone: ")
for bone in foot_bones:
if guess.lower()== bone:
print ("Correct")
total += foot_bones.count(bone)
else:
print ("Incorrect")
total += foot_bones.count(bone)
bones_func (guess, foot_bones, total)
bones_func (guess, foot_bones, total)
print (total)
这是我在互联网上找到的，完全让我陷入了昏迷：
foot_bones = ["calcaneus", "talus", "cuboid", "navicular", "lateral cuneiform", "intermediate cuneiform", "medial cuneiform"]
def foot_bones_quiz(guess, answer):
total_bones = 0
for bones in answer:
total_bones += bones.count(bones)
if guess.lower() == bones.lower():
return True
else:
pass
return False
print("Total number of identified bones: " + str(total_bones))
user_guess = input("Enter a bone: ")
print("Is " + user_guess.lower() + " a foot bone?" , foot_bones_quiz(user_guess, foot_bones))
user_guess = input("Enter another bone: ")
print("Is " + user_guess.lower() + " a foot bone?", foot_bones_quiz(user_guess, foot_bones))
我不清楚猜测变量在解决方案中的来源？它们与 user_guess 有什么关系？答案变量与foot_bones 有何关系？如何在列表中进行完整计数？谢谢
我开始学习python，我不明白代码有什么问题。这是任务：
使用 while True 循环（永远循环）给 4 次机会在彩虹彩虹中输入正确颜色 =“红橙黄绿蓝靛紫”
简而言之，在 4 次尝试中，使用 while，在字符串变量中找到将通过 input 输入的颜色
rainbow = "red orange yellow green blue indigo violet"
tries = 0
while True:
color = input("Try your color: ")
tries += 1
if tries == 4:
break
elif color in rainbow == True:
print ("Correct!")
break