我的NLTK库已经下载并且解压到安卓/zip解/文件夹下，怎样导入python？

GPT给我的答案xx**

pip install nltk

构建文件报错
提示：
下载或获取'aarch64-linux-android21-clang'命令的源代码或二进制文件。

img

要在Python中导入已下载并解压的NLTK库，可以按照以下步骤进行操作：

1.确保已经将NLTK库解压到适当的文件夹。在你的情况下，将NLTK库解压到了"安卓/zip解/"文件夹。
2.打开Python的交互式解释器或创建一个Python脚本。
3.在代码中，通过设置nltk.data.path变量来告诉NLTK库搜索路径，将解压的库添加到该变量中。具体步骤如下：

   import nltk

   # 添加解压的库的路径到nltk.data.path中
   nltk.data.path.append('安卓/zip解/')

这样，NLTK库将搜索指定的路径以寻找数据文件和资源。
4.现在，可以使用NLTK库中的功能了。例如，您可以使用nltk.word_tokenize()进行词语分词操作，或者使用其他NLTK功能。
确保代码中的解压路径与实际解压的路径一致，以便正确导入和使用NLTK库。

不知道你这个问题是否已经解决, 如果还没有解决的话:
  • 请看👉 ：使用Python+NLTK实现英文单词词频统计
  • 除此之外, 这篇博客: Python 数据科学入门教程：NLTK中的 十六、使用 NLTK 组合算法 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

    现在我们知道如何使用一堆算法分类器，就像糖果岛上的一个孩子，告诉他们只能选择一个，我们可能会发现很难只选择一个分类器。 好消息是，你不必这样！ 组合分类器算法是一种常用的技术，通过创建一种投票系统来实现，每个算法拥有一票，选择得票最多分类。

    为此，我们希望我们的新分类器的工作方式像典型的 NLTK 分类器，并拥有所有方法。 很简单，使用面向对象编程，我们可以确保从 NLTK 分类器类继承。 为此，我们将导入它：

    from nltk.classify import ClassifierI
from statistics import mode

    我们也导入mode（众数），因为这将是我们选择最大计数的方法。

    现在，我们来建立我们的分类器类：

    class VoteClassifier(ClassifierI):
    def __init__(self, *classifiers):
        self._classifiers = classifiers

    我们把我们的类叫做VoteClassifier，我们继承了 NLTK 的ClassifierI。 接下来，我们将传递给我们的类的分类器列表赋给self._classifiers。

    接下来，我们要继续创建我们自己的分类方法。 我们打算把它称为.classify，以便我们可以稍后调用.classify，就像传统的 NLTK 分类器那样。

        def classify(self, features):
        votes = []
        for c in self._classifiers:
            v = c.classify(features)
            votes.append(v)
        return mode(votes)

    很简单，我们在这里所做的就是，遍历我们的分类器对象列表。 然后，对于每一个，我们要求它基于特征分类。 分类被视为投票。 遍历完成后，我们返回mode(votes)，这只是返回投票的众数。

    这是我们真正需要的，但是我认为另一个参数，置信度是有用的。 由于我们有了投票算法，所以我们也可以统计支持和反对票数，并称之为“置信度”。 例如，3/5 票的置信度弱于 5/5 票。 因此，我们可以从字面上返回投票比例，作为一种置信度指标。 这是我们的置信度方法：

        def confidence(self, features):
        votes = []
        for c in self._classifiers:
            v = c.classify(features)
            votes.append(v)

        choice_votes = votes.count(mode(votes))
        conf = choice_votes / len(votes)
        return conf

    现在，让我们把东西放到一起：

    import nltk
import random
from nltk.corpus import movie_reviews
from nltk.classify.scikitlearn import SklearnClassifier
import pickle

from sklearn.naive_bayes import MultinomialNB, BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC

from nltk.classify import ClassifierI
from statistics import mode


class VoteClassifier(ClassifierI):
    def __init__(self, *classifiers):
        self._classifiers = classifiers

    def classify(self, features):
        votes = []
        for c in self._classifiers:
            v = c.classify(features)
            votes.append(v)
        return mode(votes)

    def confidence(self, features):
        votes = []
        for c in self._classifiers:
            v = c.classify(features)
            votes.append(v)

        choice_votes = votes.count(mode(votes))
        conf = choice_votes / len(votes)
        return conf

documents = [(list(movie_reviews.words(fileid)), category)
             for category in movie_reviews.categories()
             for fileid in movie_reviews.fileids(category)]

random.shuffle(documents)

all_words = []

for w in movie_reviews.words():
    all_words.append(w.lower())

all_words = nltk.FreqDist(all_words)

word_features = list(all_words.keys())[:3000]

def find_features(document):
    words = set(document)
    features = {}
    for w in word_features:
        features[w] = (w in words)

    return features

#print((find_features(movie_reviews.words('neg/cv000_29416.txt'))))

featuresets = [(find_features(rev), category) for (rev, category) in documents]

training_set = featuresets[:1900]
testing_set =  featuresets[1900:]

#classifier = nltk.NaiveBayesClassifier.train(training_set)

classifier_f = open("naivebayes.pickle","rb")
classifier = pickle.load(classifier_f)
classifier_f.close()




print("Original Naive Bayes Algo accuracy percent:", (nltk.classify.accuracy(classifier, testing_set))*100)
classifier.show_most_informative_features(15)

MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier.train(training_set)
print("MNB_classifier accuracy percent:", (nltk.classify.accuracy(MNB_classifier, testing_set))*100)

BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB_classifier.train(training_set)
print("BernoulliNB_classifier accuracy percent:", (nltk.classify.accuracy(BernoulliNB_classifier, testing_set))*100)

LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression_classifier.train(training_set)
print("LogisticRegression_classifier accuracy percent:", (nltk.classify.accuracy(LogisticRegression_classifier, testing_set))*100)

SGDClassifier_classifier = SklearnClassifier(SGDClassifier())
SGDClassifier_classifier.train(training_set)
print("SGDClassifier_classifier accuracy percent:", (nltk.classify.accuracy(SGDClassifier_classifier, testing_set))*100)

##SVC_classifier = SklearnClassifier(SVC())
##SVC_classifier.train(training_set)
##print("SVC_classifier accuracy percent:", (nltk.classify.accuracy(SVC_classifier, testing_set))*100)

LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC_classifier.train(training_set)
print("LinearSVC_classifier accuracy percent:", (nltk.classify.accuracy(LinearSVC_classifier, testing_set))*100)

NuSVC_classifier = SklearnClassifier(NuSVC())
NuSVC_classifier.train(training_set)
print("NuSVC_classifier accuracy percent:", (nltk.classify.accuracy(NuSVC_classifier, testing_set))*100)


voted_classifier = VoteClassifier(classifier,
                                  NuSVC_classifier,
                                  LinearSVC_classifier,
                                  SGDClassifier_classifier,
                                  MNB_classifier,
                                  BernoulliNB_classifier,
                                  LogisticRegression_classifier)

print("voted_classifier accuracy percent:", (nltk.classify.accuracy(voted_classifier, testing_set))*100)

print("Classification:", voted_classifier.classify(testing_set[0][0]), "Confidence %:",voted_classifier.confidence(testing_set[0][0])*100)
print("Classification:", voted_classifier.classify(testing_set[1][0]), "Confidence %:",voted_classifier.confidence(testing_set[1][0])*100)
print("Classification:", voted_classifier.classify(testing_set[2][0]), "Confidence %:",voted_classifier.confidence(testing_set[2][0])*100)
print("Classification:", voted_classifier.classify(testing_set[3][0]), "Confidence %:",voted_classifier.confidence(testing_set[3][0])*100)
print("Classification:", voted_classifier.classify(testing_set[4][0]), "Confidence %:",voted_classifier.confidence(testing_set[4][0])*100)
print("Classification:", voted_classifier.classify(testing_set[5][0]), "Confidence %:",voted_classifier.confidence(testing_set[5][0])*100)

    所以到了最后，我们对文本运行一些分类器示例。我们所有输出：

    Original Naive Bayes Algo accuracy percent: 66.0
Most Informative Features
                thematic = True              pos : neg    =      9.1 : 1.0
                secondly = True              pos : neg    =      8.5 : 1.0
                narrates = True              pos : neg    =      7.8 : 1.0
                 layered = True              pos : neg    =      7.1 : 1.0
                 rounded = True              pos : neg    =      7.1 : 1.0
                 supreme = True              pos : neg    =      7.1 : 1.0
                  crappy = True              neg : pos    =      6.9 : 1.0
               uplifting = True              pos : neg    =      6.2 : 1.0
                     ugh = True              neg : pos    =      5.3 : 1.0
                 gaining = True              pos : neg    =      5.1 : 1.0
                   mamet = True              pos : neg    =      5.1 : 1.0
                   wanda = True              neg : pos    =      4.9 : 1.0
                   onset = True              neg : pos    =      4.9 : 1.0
               fantastic = True              pos : neg    =      4.5 : 1.0
                   milos = True              pos : neg    =      4.4 : 1.0
MNB_classifier accuracy percent: 67.0
BernoulliNB_classifier accuracy percent: 67.0
LogisticRegression_classifier accuracy percent: 68.0
SGDClassifier_classifier accuracy percent: 57.99999999999999
LinearSVC_classifier accuracy percent: 67.0
NuSVC_classifier accuracy percent: 65.0
voted_classifier accuracy percent: 65.0
Classification: neg Confidence %: 100.0
Classification: pos Confidence %: 57.14285714285714
Classification: neg Confidence %: 57.14285714285714
Classification: neg Confidence %: 57.14285714285714
Classification: pos Confidence %: 57.14285714285714
Classification: pos Confidence %: 85.71428571428571

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^