python 3.8 怎么安装tensorflow

折腾了一下午终于用阿里镜像成功安装tensorflow，赶快分享一下。
看网上都说要把版本降到python 3.7，觉得很麻烦，不想屈服，发现阿里爸爸那有。

pip config set global.index-url https://mirrors.aliyun.com/pypi/simple

之后正常安装：

pip install tensorflow

即可。

如果上述方式还不能成功或者下载过慢，可以采用复制链接：
https://mirrors.aliyun.com/pypi/packages/ad/fc/fccaa149d7ccc165de01d62d19e5e9492e87ad23a7106f6dfe132800ca6f/tensorflow-2.4.1-cp38-cp38-win_amd64.whl

到迅雷里下载。
下载后输入：

pip install + 你下载的文件地址

如：
pip install E:\Anaconda\Lib\tensorflow_gpu-2.0.0-cp37-cp37m-win_amd64.whl 即可。

关于TensorFlow，为什么选择python语言？和tensorflow必须用python吗的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于hello tensorflow，我的第一个tensorflow程序、https://www.w3cschool.cn/tensorflow_python/tensorflow_python-c1ov28so.html、python 3.8 下安装 tensorflow 1.14、python 3.8 怎么安装tensorflow的相关知识，请在本站寻找。

本文将分享如何使用scikit learning计算多类案例的精度，召回率，准确性和f1-得分？的详细内容，并且还将对在scikit-learn中,如何处理多类分类问题进行详尽解释，此外，我们还将为大家带来关于Machine Learning from Start to Finish with Scikit-Learn、Python 2.x 中如何使用scikit-learn模块进行机器学习、Python 3.x 中如何使用scikit-learn模块进行机器学习、python – 使用scikit-learn(sklearn),如何处理线性回归的缺失数据？的相关知识，希望对你有所帮助。

• 如何使用scikit learning计算多类案例的精度，召回率，准确性和f1-得分？（在scikit-learn中,如何处理多类分类问题）
• Machine Learning from Start to Finish with Scikit-Learn
• Python 2.x 中如何使用scikit-learn模块进行机器学习
• Python 3.x 中如何使用scikit-learn模块进行机器学习
• python – 使用scikit-learn(sklearn),如何处理线性回归的缺失数据？

如何使用scikit learning计算多类案例的精度，召回率，准确性和f1-得分？（在scikit-learn中,如何处理多类分类问题）

我正在研究情绪分析问题，数据看起来像这样：

label instances    5    1190    4     838    3     239    1     204    2     127

所以，我的数据是不平衡的，因为1190instances标有5。对于使用scikit的SVC进行的分类Im
。问题是我不知道如何以正确的方式平衡我的数据，以便准确地计算多类案例的精度，召回率，准确性和f1得分。因此，我尝试了以下方法：

第一：

    wclf = SVC(kernel=''linear'', C= 1, class_weight={1: 10})    wclf.fit(X, y)    weighted_prediction = wclf.predict(X_test)print ''Accuracy:'', accuracy_score(y_test, weighted_prediction)print ''F1 score:'', f1_score(y_test, weighted_prediction,average=''weighted'')print ''Recall:'', recall_score(y_test, weighted_prediction,                              average=''weighted'')print ''Precision:'', precision_score(y_test, weighted_prediction,                                    average=''weighted'')print ''\n clasification report:\n'', classification_report(y_test, weighted_prediction)print ''\n confussion matrix:\n'',confusion_matrix(y_test, weighted_prediction)

第二：

auto_wclf = SVC(kernel=''linear'', C= 1, class_weight=''auto'')auto_wclf.fit(X, y)auto_weighted_prediction = auto_wclf.predict(X_test)print ''Accuracy:'', accuracy_score(y_test, auto_weighted_prediction)print ''F1 score:'', f1_score(y_test, auto_weighted_prediction,                            average=''weighted'')print ''Recall:'', recall_score(y_test, auto_weighted_prediction,                              average=''weighted'')print ''Precision:'', precision_score(y_test, auto_weighted_prediction,                                    average=''weighted'')print ''\n clasification report:\n'', classification_report(y_test,auto_weighted_prediction)print ''\n confussion matrix:\n'',confusion_matrix(y_test, auto_weighted_prediction)

第三：

clf = SVC(kernel=''linear'', C= 1)clf.fit(X, y)prediction = clf.predict(X_test)from sklearn.metrics import precision_score, \    recall_score, confusion_matrix, classification_report, \    accuracy_score, f1_scoreprint ''Accuracy:'', accuracy_score(y_test, prediction)print ''F1 score:'', f1_score(y_test, prediction)print ''Recall:'', recall_score(y_test, prediction)print ''Precision:'', precision_score(y_test, prediction)print ''\n clasification report:\n'', classification_report(y_test,prediction)print ''\n confussion matrix:\n'',confusion_matrix(y_test, prediction)F1 score:/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:676: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, ''micro'', ''macro'', ''weighted'', ''samples''). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".  sample_weight=sample_weight)/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1172: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, ''micro'', ''macro'', ''weighted'', ''samples''). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".  sample_weight=sample_weight)/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1082: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, ''micro'', ''macro'', ''weighted'', ''samples''). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".  sample_weight=sample_weight) 0.930416613529

但是，我收到这样的警告：

/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:1172:DeprecationWarning: The default `weighted` averaging is deprecated,and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, ''micro'', ''macro'', ''weighted'', ''samples''). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1"

如何正确处理我的不平衡数据，以便以正确的方式计算分类器的指标？

答案1

我认为对于将哪些砝码用于什么有很多困惑。我不确定我是否确切知道让您感到困扰，所以我将涉及不同的话题，请耐心等待;）。

班级重量

来自class_weight参数的权重用于 训练分类器 。它们 不会用于计算您正在使用的任何指标
：使用不同的类别权重，数字会有所不同，只是因为分类器不同。

基本上，在每个scikit-
learn分类器中，都使用类权重来告诉您的模型，类的重要性。这意味着在训练过程中，分类器将付出更多的努力来对权重较高的类进行正确分类。
他们如何做到的是特定于算法的。如果您想了解有关SVC如何工作的详细信息，而该文档对您而言没有意义，请随时提及。

指标

有了分类器后，您想知道其效果如何。在这里，你可以使用你所提到的指标：accuracy，recall_score，f1_score…

通常，当班级分布不平衡时，准确性会被认为是较差的选择，因为它会给只预测最频繁班级的模型打高分。

我不会详细介绍所有这些指标，但是请注意，除之外accuracy，它们自然地应用于类级别：如您在print分类报告中所见，它们是为每个类定义的。他们依赖诸如truepositives或false negative要求定义哪个类是 肯定 类的概念。

             precision    recall  f1-score   support          0       0.65      1.00      0.79        17          1       0.57      0.75      0.65        16          2       0.33      0.06      0.10        17avg / total       0.52      0.60      0.51        50

警告

F1 score:/usr/local/lib/python2.7/site-packages/sklearn/metrics/classification.py:676: DeprecationWarning: The default `weighted` averaging is deprecated, and from version 0.18, use of precision, recall or F-score with multiclass or multilabel data  or pos_label=None will result in an exception. Please set an explicit value for `average`, one of (None, ''micro'', ''macro'', ''weighted'', ''samples''). In cross validation use, for instance, scoring="f1_weighted" instead of scoring="f1".

之所以收到此警告，是因为您使用的是f1分数，召回率和精确度，而未定义应如何计算它们！问题可以改写：从以上分类报告中，您如何为f1分数输出 一个
全局数字？你可以：

1. 取每个班级的f1分数的平均值：这就是avg / total上面的结果。也称为 宏 平均。
2. 使用真实阳性/阴性阴性等的总计数来计算f1-分数（您将每个类别的真实阳性/阴性阴性的总数相加）。又名 微 平均。
3. 计算f1分数的加权平均值。使用''weighted''在scikit学习会由支持类的权衡F1评分：越要素类有，更重要的F1的得分这个类在计算中。

这是scikit-learn中的3个选项，警告提示您 必须选择一个 。因此，您必须average为score方法指定一个参数。

选择哪种方法取决于您如何衡量分类器的性能：例如，宏平均不考虑类的不平衡，并且类1的f1分数与类的f1分数一样重要5.但是，如果您使用加权平均，则对于第5类，您将变得更加重要。

这些度量标准中的整个参数规范目前在scikit-
learn中尚不十分清楚，根据文档，在0.18版中会更好。他们正在删除一些不太明显的标准行为，并发出警告，以便开发人员注意到它。

计算分数

我要说的最后一件事（如果您知道它，可以跳过它）是，分数只有在基于分类 器从未见过的
数据进行计算时才有意义。这是非常重要的，因为您获得的用于拟合分类器的数据得分都是完全不相关的。

这是使用的一种方法StratifiedShuffleSplit，它可以随机分配数据（经过改组后），以保留标签的分布。

from sklearn.datasets import make_classificationfrom sklearn.cross_validation import StratifiedShuffleSplitfrom sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix# We use a utility to generate artificial classification data.X, y = make_classification(n_samples=100, n_informative=10, n_classes=3)sss = StratifiedShuffleSplit(y, n_iter=1, test_size=0.5, random_state=0)for train_idx, test_idx in sss:    X_train, X_test, y_train, y_test = X[train_idx], X[test_idx], y[train_idx], y[test_idx]    svc.fit(X_train, y_train)    y_pred = svc.predict(X_test)    print(f1_score(y_test, y_pred, average="macro"))    print(precision_score(y_test, y_pred, average="macro"))    print(recall_score(y_test, y_pred, average="macro"))

希望这可以帮助。

Machine Learning from Start to Finish with Scikit-Learn

Machine Learning from Start to Finish with Scikit-Learn

This notebook covers the basic Machine Learning process in Python step-by-step. Go from raw data to at least 78% accuracy on the Titanic Survivors dataset.

Steps Covered

1. Importing a DataFrame
2. Visualize the Data
3. Cleanup and Transform the Data
4. Encode the Data
5. Split Training and Test Sets
6. Fine Tune Algorithms
7. Cross Validate with KFold
8. Upload to Kaggle

CSV to DataFrame

CSV files can be loaded into a dataframe by calling pd.read_csv . After loading the training and test files, print a sample to see what you''re working with.

In [1]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

data_train = pd.read_csv(''../input/train.csv'')
data_test = pd.read_csv(''../input/test.csv'')

data_train.sample(3)

Out[1]:

Visualizing Data

Visualizing data is crucial for recognizing underlying patterns to exploit in the model.

In [2]:

sns.barplot(x="Embarked", y="Survived", hue="Sex", data=data_train);

In [3]:

sns.pointplot(x="Pclass", y="Survived", hue="Sex", data=data_train,
              palette={"male": "blue", "female": "pink"},
              markers=["*", "o"], linestyles=["-", "--"]);

Transforming Features

1. Aside from ''Sex'', the ''Age'' feature is second in importance. To avoid overfitting, I''m grouping people into logical human age groups.
2. Each Cabin starts with a letter. I bet this letter is much more important than the number that follows, let''s slice it off.
3. Fare is another continuous value that should be simplified. I ran data_train.Fare.describe() to get the distribution of the feature, then placed them into quartile bins accordingly.
4. Extract information from the ''Name'' feature. Rather than use the full name, I extracted the last name and name prefix (Mr. Mrs. Etc.), then appended them as their own features.
5. Lastly, drop useless features. (Ticket and Name)

In [4]:

def simplify_ages(df):
    df.Age = df.Age.fillna(-0.5)
    bins = (-1, 0, 5, 12, 18, 25, 35, 60, 120)
    group_names = [''Unknown'', ''Baby'', ''Child'', ''Teenager'', ''Student'', ''Young Adult'', ''Adult'', ''Senior'']
    categories = pd.cut(df.Age, bins, labels=group_names)
    df.Age = categories
    return df

def simplify_cabins(df):
    df.Cabin = df.Cabin.fillna(''N'')
    df.Cabin = df.Cabin.apply(lambda x: x[0])
    return df

def simplify_fares(df):
    df.Fare = df.Fare.fillna(-0.5)
    bins = (-1, 0, 8, 15, 31, 1000)
    group_names = [''Unknown'', ''1_quartile'', ''2_quartile'', ''3_quartile'', ''4_quartile'']
    categories = pd.cut(df.Fare, bins, labels=group_names)
    df.Fare = categories
    return df

def format_name(df):
    df[''Lname''] = df.Name.apply(lambda x: x.split('' '')[0])
    df[''NamePrefix''] = df.Name.apply(lambda x: x.split('' '')[1])
    return df    
    
def drop_features(df):
    return df.drop([''Ticket'', ''Name'', ''Embarked''], axis=1)

def transform_features(df):
    df = simplify_ages(df)
    df = simplify_cabins(df)
    df = simplify_fares(df)
    df = format_name(df)
    df = drop_features(df)
    return df

data_train = transform_features(data_train)
data_test = transform_features(data_test)
data_train.head()

Out[4]:

In [5]:

In [5]:

sns.barplot(x="Age", y="Survived", hue="Sex", data=data_train);

In [6]:

sns.barplot(x="Cabin", y="Survived", hue="Sex", data=data_train);

In [7]:

sns.barplot(x="Fare", y="Survived", hue="Sex", data=data_train);

Some Final Encoding

The last part of the preprocessing phase is to normalize labels. The LabelEncoder in Scikit-learn will convert each unique string value into a number, making out data more flexible for various algorithms.

The result is a table of numbers that looks scary to humans, but beautiful to machines.

In [8]:

from sklearn import preprocessing
def encode_features(df_train, df_test):
    features = [''Fare'', ''Cabin'', ''Age'', ''Sex'', ''Lname'', ''NamePrefix'']
    df_combined = pd.concat([df_train[features], df_test[features]])
    
    for feature in features:
        le = preprocessing.LabelEncoder()
        le = le.fit(df_combined[feature])
        df_train[feature] = le.transform(df_train[feature])
        df_test[feature] = le.transform(df_test[feature])
    return df_train, df_test
    
data_train, data_test = encode_features(data_train, data_test)
data_train.head()

Out[8]:

Splitting up the Training Data

Now its time for some Machine Learning.

First, separate the features(X) from the labels(y).

X_all: All features minus the value we want to predict (Survived).

y_all: Only the value we want to predict.

Second, use Scikit-learn to randomly shuffle this data into four variables. In this case, I''m training 80% of the data, then testing against the other 20%.

Later, this data will be reorganized into a KFold pattern to validate the effectiveness of a trained algorithm.

In [9]:

from sklearn.model_selection import train_test_split

X_all = data_train.drop([''Survived'', ''PassengerId''], axis=1)
y_all = data_train[''Survived'']

num_test = 0.20
X_train, X_test, y_train, y_test = train_test_split(X_all, y_all, test_size=num_test, random_state=23)

Fitting and Tuning an Algorithm

Now it''s time to figure out which algorithm is going to deliver the best model. I''m going with the RandomForestClassifier, but you can drop any other classifier here, such as Support Vector Machines or Naive Bayes.

In [10]:

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import make_scorer, accuracy_score
from sklearn.model_selection import GridSearchCV

# Choose the type of classifier. 
clf = RandomForestClassifier()

# Choose some parameter combinations to try
parameters = {''n_estimators'': [4, 6, 9], 
              ''max_features'': [''log2'', ''sqrt'',''auto''], 
              ''criterion'': [''entropy'', ''gini''],
              ''max_depth'': [2, 3, 5, 10], 
              ''min_samples_split'': [2, 3, 5],
              ''min_samples_leaf'': [1,5,8]
             }

# Type of scoring used to compare parameter combinations
acc_scorer = make_scorer(accuracy_score)

# Run the grid search
grid_obj = GridSearchCV(clf, parameters, scoring=acc_scorer)
grid_obj = grid_obj.fit(X_train, y_train)

# Set the clf to the best combination of parameters
clf = grid_obj.best_estimator_

# Fit the best algorithm to the data. 
clf.fit(X_train, y_train)

Out[10]:

RandomForestClassifier(bootstrap=True, class_weight=None, criterion=''entropy'',
            max_depth=5, max_features=''sqrt'', max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=3,
            min_weight_fraction_leaf=0.0, n_estimators=9, n_jobs=1,
            oob_score=False, random_state=None, verbose=0,
            warm_start=False)

In [11]:

predictions = clf.predict(X_test)
print(accuracy_score(y_test, predictions))

0.798882681564

Validate with KFold

Is this model actually any good? It helps to verify the effectiveness of the algorithm using KFold. This will split our data into 10 buckets, then run the algorithm using a different bucket as the test set for each iteration.

In [12]:

from sklearn.cross_validation import KFold

def run_kfold(clf):
    kf = KFold(891, n_folds=10)
    outcomes = []
    fold = 0
    for train_index, test_index in kf:
        fold += 1
        X_train, X_test = X_all.values[train_index], X_all.values[test_index]
        y_train, y_test = y_all.values[train_index], y_all.values[test_index]
        clf.fit(X_train, y_train)
        predictions = clf.predict(X_test)
        accuracy = accuracy_score(y_test, predictions)
        outcomes.append(accuracy)
        print("Fold {0} accuracy: {1}".format(fold, accuracy))     
    mean_outcome = np.mean(outcomes)
    print("Mean Accuracy: {0}".format(mean_outcome)) 

run_kfold(clf)

Fold 1 accuracy: 0.8111111111111111
Fold 2 accuracy: 0.8651685393258427
Fold 3 accuracy: 0.7640449438202247
Fold 4 accuracy: 0.8426966292134831
Fold 5 accuracy: 0.8314606741573034
Fold 6 accuracy: 0.8202247191011236
Fold 7 accuracy: 0.7528089887640449
Fold 8 accuracy: 0.8089887640449438
Fold 9 accuracy: 0.8876404494382022
Fold 10 accuracy: 0.8426966292134831
Mean Accuracy: 0.8226841448189763

/opt/conda/lib/python3.6/site-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)

Predict the Actual Test Data

And now for the moment of truth. Make the predictions, export the CSV file, and upload them to Kaggle.

In [13]:

ids = data_test[''PassengerId'']
predictions = clf.predict(data_test.drop(''PassengerId'', axis=1))


output = pd.DataFrame({ ''PassengerId'' : ids, ''Survived'': predictions })
# output.to_csv(''titanic-predictions.csv'', index = False)
output.head()

Out[13]:

Python 2.x 中如何使用scikit-learn模块进行机器学习

python 2.x 中如何使用scikit-learn模块进行机器学习

导语：
机器学习是一门研究如何使计算机能够通过数据学习并改进自身性能的学科。scikit-learn是一个基于Python的机器学习库，它提供了许多机器学习算法和工具，使得机器学习变得更加简单和高效。

本文将介绍如何在Python 2.x 中使用scikit-learn模块进行机器学习，同时提供示例代码。

一、安装scikit-learn模块
首先，我们需要确保已经安装了Python 2.x 版本。然后，可以通过pip命令安装scikit-learn模块：

pip install -U scikit-learn

安装完成后，就可以开始使用scikit-learn模块进行机器学习了。

立即学习“Python免费学习笔记（深入）”；

二、加载数据集
在机器学习中，我们通常需要加载和处理数据集。scikit-learn提供了许多内置的数据集，可以直接使用。下面以鸢尾花数据集为例进行示范：

from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target

上述代码中，我们使用load_iris()函数加载了鸢尾花数据集，然后将数据集中的输入数据存储在变量X中，将对应的标签存储在变量y中。

三、划分数据集
在训练机器学习模型之前，我们需要将数据集划分为训练集和测试集。scikit-learn提供了train_test_split函数来实现数据集的划分。

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

上述代码中，我们将数据集划分为训练集和测试集，其中test_size=0.2表示测试集的比例为20%，random_state=42表示随机种子，以确保每次划分结果的一致性。

四、选择模型
在机器学习中，我们可以选择不同的模型来训练我们的数据集。在scikit-learn中，每个模型都有对应的类，我们可以通过创建模型类的实例来选择不同的模型。

以支持向量机（SVM）为例，使用SVC类来创建一个SVM模型的实例：

from sklearn.svm import SVC
model = SVC()

五、训练模型
一旦选择了模型，我们就可以使用训练数据集对模型进行训练。

model.fit(X_train, y_train)

上述代码中，我们使用fit方法对模型进行训练，将训练数据集X_train和对应的标签y_train作为输入。

六、模型评估
在训练完成后，我们需要使用测试数据集来评估模型的性能。

score = model.score(X_test, y_test)
print("模型准确率：", score)

上述代码中，我们使用score方法计算模型在测试数据集上的准确率，并输出评估结果。

七、模型预测
最后，我们可以使用训练好的模型进行预测。

y_pred = model.predict(X_test)
print("预测结果：", y_pred)

上述代码中，我们使用predict方法对测试数据集进行预测，并输出预测结果。

总结：
通过本文的介绍，我们了解到了如何在Python 2.x 中使用scikit-learn模块进行机器学习。我们学习了加载数据集、划分数据集、选择模型、训练模型、模型评估和模型预测等基本步骤，并给出了相应的代码示例。

希望本文对你在学习机器学习以及使用scikit-learn模块时有所帮助。祝你学习进步，掌握机器学习的技巧！

以上就是Python 2.x 中如何使用scikit-learn模块进行机器学习的详细内容，更多请关注php中文网其它相关文章！

Python 3.x 中如何使用scikit-learn模块进行机器学习

python 3.x 中如何使用scikit-learn模块进行机器学习

引言：
机器学习是一种人工智能的分支，它可以使计算机通过学习和训练数据来提高其性能。其中，scikit-learn是一个强大的Python机器学习库，它提供了许多常用的机器学习算法和工具，能够帮助开发者快速构建和部署机器学习模型。本文将介绍如何使用Python 3.x中的scikit-learn模块进行机器学习，并附带代码示例。

一、安装scikit-learn模块
要使用scikit-learn模块，首先需要安装它。可以使用pip工具来完成安装，只需在命令行中输入以下命令：
pip install scikit-learn

二、导入scikit-learn模块
安装完成后，可以在Python脚本中导入scikit-learn模块，以便使用它的功能。导入的代码如下：
import sklearn

三、加载数据集
在机器学习中，通常需要先加载数据集，然后对它进行处理和分析。scikit-learn提供了一些内置数据集，可以用于练习和测试算法。以下代码演示如何加载scikit-learn内置的一个数据集Iris（鸢尾花）：
from sklearn.datasets import load_iris

立即学习“Python免费学习笔记（深入）”；

加载鸢尾花数据集

iris = load_iris()

四、数据预处理
在机器学习中，数据预处理是一个重要的步骤。它包括数据清洗、特征选择、数据归一化等操作，以确保数据的质量和准确性。下面的代码片段展示了如何对数据集进行归一化处理：
from sklearn.preprocessing import MinMaxScaler

创建MinMaxScaler对象

scaler = MinMaxScaler()

对数据集进行归一化

normalized_data = scaler.fit_transform(iris.data)

五、拆分数据集
在机器学习中，通常需要将数据集分为训练集和测试集，以便在训练模型和评估模型性能时使用。以下代码展示了如何将数据集分为训练集和测试集：
from sklearn.model_selection import train_test_split

将数据集分为训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(normalized_data, iris.target, test_size=0.2)

六、训练模型
scikit-learn提供了许多机器学习算法，可以根据数据的特点和目标选择合适的算法进行训练。以下代码展示了使用逻辑回归算法训练模型的示例：
from sklearn.linear_model import LogisticRegression

创建逻辑回归模型对象

model = LogisticRegression()

使用训练集对模型进行训练

model.fit(X_train, y_train)

七、评估模型性能
训练完成后，需要评估模型的性能。scikit-learn提供了多种评估指标，可以帮助我们判断模型的准确性和稳定性。以下代码展示了如何使用准确率来评估模型的性能：
from sklearn.metrics import accuracy_score

使用测试集进行预测

y_pred = model.predict(X_test)

计算准确率

accuracy = accuracy_score(y_test, y_pred)

八、模型调优
根据评估结果，我们可以进行模型的调优，以提高模型的性能。scikit-learn提供了参数调优的功能，可以通过网格搜索等方法寻找最佳模型参数。以下代码展示了如何使用网格搜索来调优模型参数：
from sklearn.model_selection import GridSearchCV

定义参数网格

param_grid = {''C'': [0.01, 0.1, 1, 10], ''penalty'': [''l1'', ''l2'']}

创建GridSearchCV对象

grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5)

使用训练集进行网格搜索

grid_search.fit(X_train, y_train)

获取最佳模型参数

best_params = grid_search.best_params_

九、使用模型进行预测
完成模型的训练和调优后，可以使用模型来进行预测。以下代码展示了如何使用训练好的模型对新数据进行预测：

使用最佳模型参数创建新的模型对象

best_model = LogisticRegression(**best_params)

使用整个数据集进行模型训练

best_model.fit(normalized_data, iris.target)

准备新数据

new_data = [[5.1, 3.5, 1.4, 0.2], [6.7, 3.1, 4.4, 1.4], [6.5, 3.0, 5.2, 2.0]]

对新数据进行预测

predictions = best_model.predict(new_data)

结论：
本文介绍了如何使用Python 3.x中的scikit-learn模块进行机器学习。通过安装模块、导入模块、加载数据集、数据预处理、拆分数据集、训练模型、评估模型性能、模型调优以及使用模型进行预测，读者可以了解到如何应用scikit-learn模块来构建和部署机器学习模型。通过实践和不断学习，我们可以进一步深入机器学习的领域，并在实际应用中取得更好的效果。

以上就是Python 3.x 中如何使用scikit-learn模块进行机器学习的详细内容，更多请关注php中文网其它相关文章！

python – 使用scikit-learn(sklearn),如何处理线性回归的缺失数据？

X = DataFrame_1
for col in DataFrame_2.columns:
    y = DataFrame_2[col]
    model = LinearRegression()
    model.fit(X,y)

#ValueError: Input contains NaN,infinity or a value too large for dtype('float64').

from sklearn.preprocessing import Imputer
imputer = Imputer()
y_imputed = imputer.fit_transform(y)

关于如何使用scikit learning计算多类案例的精度，召回率，准确性和f1-得分？和在scikit-learn中,如何处理多类分类问题的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Machine Learning from Start to Finish with Scikit-Learn、Python 2.x 中如何使用scikit-learn模块进行机器学习、Python 3.x 中如何使用scikit-learn模块进行机器学习、python – 使用scikit-learn(sklearn),如何处理线性回归的缺失数据？的相关信息，请在本站寻找。

本文将介绍flex-grow在列布局中不起作用的详细情况，特别是关于flex列表布局的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于android – 布局权重在ScrollView中不起作用、android – 进度可见性在列表视图页脚中不起作用、c# – RowSpan在iTextSharp中不起作用？、CSS Flexbox在IE10中不起作用的知识。

• flex-grow在列布局中不起作用（flex列表布局）
• android – 布局权重在ScrollView中不起作用
• android – 进度可见性在列表视图页脚中不起作用
• c# – RowSpan在iTextSharp中不起作用？
• CSS Flexbox在IE10中不起作用

flex-grow在列布局中不起作用（flex列表布局）

我正在尝试views-cntnr占用views-cntnr和menubardiv未使用的任何空间。为此，我将flex显示设置为列方向。然后，我将flex-grow属性设置views-cntnr为1。似乎没有做任何事情。

注意：不确定这是否重要，但是我正在进行一些嵌套的flex显示。

HTML

<script src="https://code.jquery.com/jquery.min.js"></script><script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script><script src="https://code.jquery.com/jquery-2.1.4.js"></script><script src="https://code.jquery.com/jquery-1.11.3.js"></script><script src="https://code.jquery.com/ui/1.11.4/jquery-ui.js"></script><section>  <div>    <div>      <divrole="group">        <buttonng-ng-click="toggleView(0)">R-Theta</button>        <buttonng-ng-click="toggleView(1)">Cartesian</button>        <buttonng-ng-click="toggleView(2)">Longitudinal</button>        <buttonng-ng-click="">Console</button>      </div>    </div>  </div>  <div id="views-cntnr">    <div>      <div id="v1">V1</div>      <div id="v2">V2</div>      <div id="v3">V3</div>    </div>    <div>      <div id="v4">V4</div>    </div>  </div>  <div id="frame-ctrl-cntnr">    <div id="frame-num"># X</div>    <div id="frame-range-cntnr">      <input type="range">    </div>  </div></section>

CSS

.analysis {  display: flex;  flex-direction: column;}/* MENUBAR */.menubar {  padding: 4px 0 4px;  background-color: #eee;}/* menubar *//* VIEWS */#views-cntnr {  display: flex;  flex-direction: column;  flex-grow: 1;}/* ROW 1 */.r1 {  display: flex;}.r1 .view {  flex-grow: 1;  border: black 1px solid;  border-right: none;}.r1 .view:last-child {  border-right: black 1px solid;}/* row 1 *//* ROW 2 */.r2 .view {  border: black 1px solid;  border-top: none;}/* row 2 *//* views *//* FRAME CTRL */#frame-ctrl-cntnr {  display: flex;}.frame-ctrl {  border: black 1px solid;  border-top: none;  border-right: none;}.frame-ctrl:last-child {  border-right: black 1px solid;}#frame-num { width: 50px;}#frame-range-cntnr {  flex-grow: 1;  padding: 4px;}/* frame ctrl */

答案1

您代码中的所有内容都可以正常工作。

唯一的问题是 您的flex容器没有指定的高度 。因此，高度解析为auto，表示内容的高度。

该flex-grow属性在容器中分配 可用 空间。容器中没有可用空间，flex-grow因此无关。

尝试对CSS进行此调整：

.analysis {    display: flex;    flex-direction: column;    height: 100vh;}

这告诉flex容器是视口的高度。现在，容器的高度比内容容器的高度高，您会注意到flex-grow它正在工作。

android – 布局权重在ScrollView中不起作用

我想将布局权重分配给ScrollView内的LinearLayout内的多个项目.但是,ScrollView忽略LinearLayout weightSum.

我的目标是将布局的权重分为2,1,1(总和为4),但这在ScrollView内部无法正常工作.

我该如何解决这个布局问题？

main.xml中

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/scrollView1"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <LinearLayout 
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" 
        android:weightSum="4">

        <LinearLayout android:id="@+id/logo"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" 
            android:layout_weight="2"
            android:background="#FFFFFF" />

        <LinearLayout android:id="@+id/logo1"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" 
            android:layout_weight="1"
            android:background="#000000" />


        <LinearLayout android:id="@+id/logobutton"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal" 
            android:layout_weight="1" 
            android:background="#4B4B4B" />

    </LinearLayout>
</ScrollView>

解决方法:

我以前遇到过这个问题.只需在ScrollView中使用android：fillViewport =“true”,它就会填满屏幕.

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/scrollView1"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:fillViewport="true" >

android – 进度可见性在列表视图页脚中不起作用

LayoutInflater inflater = (LayoutInflater)getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.list_footer,null);    
myListView.addFooter(view).

ProgressBar progressBar = (ProgressBar) getFooterView().findViewById(R.id.progressBar);
mAdapter = new MyAdapter(BaseActivity.getActivity(),progressBar,myArrayList);
mList.setAdapter(mAdapter);

if(position == MAX_RECORDS)
    {
        progressBar.setVisibility(View.VISIBLE);
        // Some code goes here.
    } else
        progressBar.setVisibility(View.GONE);

c# – RowSpan在iTextSharp中不起作用？

<table border="1" width="700">
    <tr>
            <td colspan="5" align="center" bgcolor="lightblue">INVOICE</td>
    </tr>
    <tr>
            <td colspan="2" rowspan="4" bgcolor="white"><b>AIRNET NETWORKS</b>
                    <br>asdadadadaada asd asd a ads adsadsadsadasd</td>
            <td>INVOICE</td>
            <td>DATE</td>
            <td>aDATEsd</td>
    </tr>
    <tr>
            <td>Order</td>
            <td>XXXX</td>
            <td>Ref XXXXXX</td>
    </tr>
    <tr>
            <td>Delivery</td>
            <td>XXXX</td>
            <td>Ref XXXXXX</td>
    </tr>
    <tr>
            <td>Due Date</td>
            <td>XXXX</td>
            <td>Ref XXXXXX</td>
    </tr>
    <tr>
            <td colspan="2" rowspan="4" bgcolor="white">
                    <p><b>CUSTOMER NAME</b>
                    </p>asd asd adadaadadadada adadaadsasdad ada asd adad</td>
    </tr>
    <tr>
            <td>Customer Care No:</td>
            <td colspan="2">544646454,88877978975</td>
    </tr>
    <tr>
            <td>Email Id</td>
            <td colspan="2">airnet@gmail.com</td>
    </tr>
    <tr>
            <td>Account Details</td>
            <td colspan="2">5522245125545455 IFSC 323hasd</br>SBI India</td>
    </tr>
</table>

<table border="1" width="700">
    <tr>
            <td bgcolor="lightblue" height="15">Srno</td>
            <td bgcolor="lightblue">Particulars</td>
            <td bgcolor="lightblue">Quantity</td>
            <td bgcolor="lightblue">Rate/Month</td>
            <td bgcolor="lightblue">Total Rupees</td>
            <tr>
                    <td valign="top">1</td>
                    <td valign="top">1 MBPS Plan</td>
                    <td valign="top">1</td>
                    <td valign="top">600</td>
                    <td valign="top">692</td>
            </tr>
    </tr>
    <tr>
            <td height="300" valign="top">1</td>
            <td valign="top">1 MBPS Plan</td>
            <td valign="top">1</td>
            <td valign="top">600</td>
            <td valign="top">692</td>
    </tr>
    <tr>
            <td colspan="3" rowspan="3" valign="top">asdasdasd</td>
            <td colspan="1">Total</td>
            <td colspan="1">692</td>
    </tr>
    <tr>
            <td>Service Tax</td>
            <td>692</td>
    </tr>
    <tr>
            <td>Grand Total</td>
            <td>692</td>
    </tr>
</table>

Document document = new Document();
document.SetPageSize(iTextSharp.text.PageSize.A4);
iTextSharp.text.pdf.draw.Lineseparator line1 = new iTextSharp.text.pdf.draw.Lineseparator(0f,100f,iTextSharp.text.Color.BLACK,Element.ALIGN_LEFT,1);    
string NEWhtmlText="<table border='1' width='500' > <tr> <td bgcolor='lightblue' height='15' >Srno</td><td bgcolor='lightblue'>Particulars</td><td bgcolor='lightblue' >Quantity</td><td bgcolor='lightblue'>Rate/Month</td><td bgcolor='lightblue'>Total Rupees</td> </tr> <tr> <td valign='top' >1</td><td valign='top' >1 MBPS Plan</td><td valign='top'>1</td><td valign='top'>600</td><td valign='top'>692</td> </tr> <tr> <td height='300' valign='top' >1</td><td valign='top' >1 MBPS Plan</td><td valign='top'>1</td><td valign='top'>600</td><td valign='top'>692</td> </tr> <tr><td colspan='3' rowspan='3' valign='top'>asdasdasd</td><td colspan='1'>Total</td><td colspan='1'>692</td></tr> <tr><td>Service Tax</td><td>692</td></tr> <tr><td>Grand Total</td><td>692</td></tr> </table>";
PdfWriter.GetInstance(document,new FileStream(saveFileDialog1.FileName,FileMode.Create));
document.open();
iTextSharp.text.html.simpleparser.HTMLWorker hw = new iTextSharp.text.html.simpleparser.HTMLWorker(document);
hw.Parse(new StringReader(NEWhtmlText));
document.Close();

public void createPdf(String file) throws IOException,DocumentException {
    // step 1
    Document document = new Document();
    // step 2
    PdfWriter writer = PdfWriter.getInstance(document,new FileOutputStream(file));
    // step 3
    document.open();
    // step 4
    XMLWorkerHelper.getInstance().parseXHtml(writer,document,new FileInputStream(HTML));
    // step 5
    document.close();
}

CSS Flexbox在IE10中不起作用

如何解决CSS Flexbox在IE10中不起作用？

IE尚不完全支持Flex布局模式。IE10实现了规范的“补间”版本，该版本不是完全最新的，但仍然可以使用。

解决方法

在IE10中，此代码无法正常工作：

.flexbox form {
    display: -webkit-flex;
    display: -moz-flex;
    display: -ms-flex;
    display: -o-flex;
    display: flex;
    -webkit-flex-direction: row;
    -moz-flex-direction: row;
    -ms-flex-direction: row;
    -o-flex-direction: row;
    flex-direction: row;
}

.flexbox form input[type=submit] {
    width: 31px;
}

.flexbox form input[type=text] {
    width: auto;
    display: -webkit-flex;
    display: -moz-flex;
    display: -ms-flex;
    display: -o-flex;
    display: flex;
    -webkit-flex: auto 1;
    -moz-flex: auto 1;
    -ms-flex: auto 1;
    -o-flex: auto 1;
    flex: auto 1;
}

应该发生的是，该input[type=submit]宽度应为31px，并input[type=text]占用内的其余可用空间form。input[type=text]由于某种原因，发生的事情只是默认为263px。

在Chrome和Firefox中可以正常运行。

关于flex-grow在列布局中不起作用和flex列表布局的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于android – 布局权重在ScrollView中不起作用、android – 进度可见性在列表视图页脚中不起作用、c# – RowSpan在iTextSharp中不起作用？、CSS Flexbox在IE10中不起作用的相关信息，请在本站寻找。

此处将为大家介绍关于arr .__ len __的详细内容，并且为您解答有关是在Python中获取数组长度的首选方法吗？的相关问题，此外，我们还将为您介绍关于arr .__ len __（）是获取Python数组长度的首选方法吗？、arr.__len__() 是在 Python 中获取数组长度的首选方法吗？、module .__ init __（）在Python中最多接受2个参数错误、os.system（）是在Python脚本中获取一组文件的最佳方法吗？的有用信息。

本文目录一览：

• arr .__ len __（）是在Python中获取数组长度的首选方法吗？（python求array长度）
• arr .__ len __（）是获取Python数组长度的首选方法吗？
• arr.__len__() 是在 Python 中获取数组长度的首选方法吗？
• module .__ init __（）在Python中最多接受2个参数错误
• os.system（）是在Python脚本中获取一组文件的最佳方法吗？

arr .__ len __（）是在Python中获取数组长度的首选方法吗？（python求array长度）

在Python中，以下是获取元素数量的唯一方法吗？

arr.__len__()

如果是这样，为什么会有奇怪的语法？

答案1

小编典典

my_list = [1,2,3,4,5]len(my_list)# 5

对于元组也是如此：

my_tuple = (1,2,3,4,5)len(my_tuple)# 5

和字符串，实际上只是字符数组：

my_string = ''hello world''len(my_string)# 11

这样做的目的是使列表，元组和其他容器类型或可迭代对象不需要全部显式实现公共.length()方法，而只需检查len()实现“
magic”__len__()方法的所有内容即可。

当然，这似乎是多余的，但是长度检查的实现可能会有很大的不同，即使在同一语言中也是如此。经常会看到一种类型的集合使用一种.length()方法，而另一种类型使用一种.length属性，而另一种类型使用.count()。使用语言级关键字可以统一所有这些类型的入口点。因此，即使您可能不认为是元素列表的对象仍然可以进行长度检查。这包括字符串，队列，树等。

的功能性质len()也很适合编程的功能样式。

lengths = map(len, list_of_containers)

arr .__ len __（）是获取Python数组长度的首选方法吗？

在Python中 ，以下是获取元素数量的唯一方法吗？

arr.__len__()

如果是这样，为什么奇怪的语法？

---

#1楼

您可以使用前面答案中建议的len(arr)来获取数组的长度。 如果你想要2D数组的尺寸，你可以使用arr.shape返回高度和宽度

---

#2楼

len(list_name)函数将list作为参数，它调用list的__len__()函数。

---

#3楼

my_list = [1,2,3,4,5]
len(my_list)
# 5

对于元组也是如此：

my_tuple = (1,2,3,4,5)
len(my_tuple)
# 5

和字符串，它们实际上只是字符数组：

my_string = ''hello world''
len(my_string)
# 11

它是故意以这种方式完成的，因此列表，元组和其他容器类型并不都需要显式实现公共.length()方法，而是只需检查实现''magic'' __len__()的任何东西的len() __len__()方法。

当然，这似乎是多余的，但长度检查实现可能会有很大差异，即使在同一种语言中也是如此。 这不是经常看到一个集合类型使用.length()方法，而另一种类型的使用.length属性，而另一个使用.count() 使用语言级关键字统一所有这些类型的入口点。 因此，即使是您可能不认为是元素列表的对象仍然可以进行长度检查。 这包括字符串，队列，树木等。

len()的功能特性也很适合函数式编程。

lengths = map(len, list_of_containers)

---

#4楼

只需使用len（arr）：

>>> import array
>>> arr = array.array(''i'')
>>> arr.append(''2'')
>>> arr.__len__()
1
>>> len(arr)
1

---

#5楼

获取任何python对象长度的首选方法是将其作为参数传递给len函数。 在内部，python将尝试调用传递的对象的特殊__len__方法。

arr.__len__() 是在 Python 中获取数组长度的首选方法吗？

在Python中，以下是获取元素数量的唯一方法吗？

arr.__len__()

如果是这样，为什么会有奇怪的语法？

答案1

小编典典

my_list = [1,2,3,4,5]len(my_list)# 5

同样适用于元组：

my_tuple = (1,2,3,4,5)len(my_tuple)# 5

还有字符串，它们实际上只是字符数组：

my_string = ''hello world''len(my_string)# 11

它是故意这样做的，因此列表、元组和其他容器类型或可迭代对象并不都需要显式实现公共.length()方法，而是您可以检查len()任何实现“魔术”__len__()方法的东西。

当然，这似乎是多余的，但长度检查实现可能会有很大差异，即使在同一种语言中也是如此。一种集合类型使用.length()方法而另一种类型使用.length属性而另一种使用.count().
拥有一个语言级别的关键字统一了所有这些类型的入口点。因此，即使您可能不认为是元素列表的对象仍然可以进行长度检查。这包括字符串、队列、树等。

的函数性质len()也很适合于函数式编程风格。

lengths = map(len, list_of_containers)

module .__ init __（）在Python中最多接受2个参数错误

我有3个文件，factory_imagenet.py，imdb.py和imagenet.py

factory_imagenet.py具有：

import datasets.imagenet

它也有一个函数调用

datasets.imagenet.imagenet(split,devkit_path))...

imdb.py具有：

class imdb(object):def __init__(self, name):    self._name = name    ...

imagenet.py具有：

import datasetsimport datasets.imagenetimport datasets.imdb

它也有

class imagenet(datasets.imdb):    def __init__(self, image_set, devkit_path=None):        datasets.imdb.__init__(self, image_set)

所有这三个文件都在数据集文件夹中。

当我运行与这些文件交互的另一个脚本时，出现此错误：

Traceback (most recent call last):  File "./tools/train_faster_rcnn_alt_opt.py", line 19, in <module>    from datasets.factory_imagenet import get_imdb  File "/mnt/data2/abhishek/py-faster-rcnn/tools/../lib/datasets/factory_imagenet.py", line 12, in <module>    import datasets.imagenet  File "/mnt/data2/abhishek/py-faster-rcnn/tools/../lib/datasets/imagenet.py", line 21, in <module>    class imagenet(datasets.imdb):TypeError: Error when calling the metaclass basesmodule.__init__() takes at most 2 arguments (3 given)

这是什么问题，如何解决此类继承问题的直观解释是什么？

答案1

小编典典

module.__init__() takes at most 2 arguments (3 given)

这意味着您正在尝试从模块继承，而不是从类继承。其实datasets.imdb是一个模块；datasets.imdb.imdb是你的课。

您需要更改代码，使其看起来像这样：

class imagenet(datasets.imdb.imdb):    def __init__(self, image_set, devkit_path=None):        datasets.imdb.imdb.__init__(self, image_set)

os.system（）是在Python脚本中获取一组文件的最佳方法吗？

有一些很好的库可以通过Python本机通过HTTP下载文件，而不是启动外部程序。一种非常流行但功能强大但易于使用的请求称为“请求：https://requests.readthedocs.io/en/master/

如果需要，您必须自己实现某些功能，例如@IBOutlet（尽管您的示例令人困惑，因为您使用--recursive却表示正在下载一个文件）。例如参见recursive image download with requests。

如果需要进度条，可以将另一个名为--recursive的库与请求一起使用。参见Python progress bar and downloads。

如果要下载的文件很大，这是我写的一个答案，该答案显示了如何获得最佳性能（最快tqdm）：https://stackoverflow.com/a/39217788/4323。

今天的关于arr .__ len __和是在Python中获取数组长度的首选方法吗？的分享已经结束，谢谢您的关注，如果想了解更多关于arr .__ len __（）是获取Python数组长度的首选方法吗？、arr.__len__() 是在 Python 中获取数组长度的首选方法吗？、module .__ init __（）在Python中最多接受2个参数错误、os.system（）是在Python脚本中获取一组文件的最佳方法吗？的相关知识，请在本站进行查询。

以上就是给各位分享virtualenv的问题-无法激活，其中也会对激活virtualenv环境进行解释，同时本文还将给你拓展bash – 激活virtualenv的问题、Centos7 虚拟环境 virtualenv 与 virtualenvwrapper 的安装及基本使用、Linux下virtualenv与virtualenvwrapper详解、Linux下安装virtualenv与virtualenvwrapper等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• virtualenv的问题-无法激活（激活virtualenv环境）
• bash – 激活virtualenv的问题
• Centos7 虚拟环境 virtualenv 与 virtualenvwrapper 的安装及基本使用
• Linux下virtualenv与virtualenvwrapper详解
• Linux下安装virtualenv与virtualenvwrapper

virtualenv的问题-无法激活（激活virtualenv环境）

我在项目周围创建了一个virtualenv，但是当我尝试激活它时却无法。它可能只是语法或文件夹位置，但是我现在很困惑。

您可以在下面看到，我创建了virtualenv并将其称为venv。一切看起来不错，然后我尝试通过运行来激活它sourcevenv/bin/activate

我在想它可能只与我的系统路径有关，但不确定将其指向什么（我确实知道如何编辑路径）。我在python 7 / Windows操作系统上，虚拟环境2.2.x

处理virtualenv的依赖项已完成virtualenv的处理依赖性c：\ testdjangoproj \ mysite> virtualenv --no-site-packages venv--no-site-packages标志已弃用；现在是默认行为。使用真实的前缀''C：\\ Program Files（x86）\\ Python''venv \ Scripts \ python.exe中的新python可执行文件venv \ Lib \ distutils \ distutils.cfg文件存在不同的内容；不过度ting安装setuptools ........完成。安装pip .........完成。c：\ testdjangoproj \ mysite>源venv / bin / activate无法将“源”识别为内部或外部命令，可操作的程序或批处理文件。c：\ testdjangoproj \ mysite>源venv / bin / activate无法将“源”识别为内部或外部命令，可操作的程序或批处理文件。c：\ testdjangoproj \ mysite>源mysite / bin / activate无法将“源”识别为内部或外部命令，可操作的程序或批处理文件。c：\ testdjangoproj \ mysite>

答案1

小编典典

source 是专门为在Linux（或任何Posix，但不包括Windows）上运行的用户设计的Shell命令。

在Windows上，virtualenv会创建一个批处理文件，因此您应该venv\Scripts\activate改为运行它（根据Activate脚本上的virtualenv文档）。

编辑： 这里的Windows技巧不指定BAT扩展名：

PS C：\ DEV \ aProject \ env \ Scripts> 和..activate
（env）PS C：\ DEV \ aProject \ env \ Scripts>

bash – 激活virtualenv的问题

我通过命令安装了 python环境：

SYS_INSTALL="apt-get install -y"
PIP_INSTALL="pip install"

# Be sure to install setuptools before pip to properly replace easy_install.
$SYS_INSTALL git 
$SYS_INSTALL python-dev
$SYS_INSTALL python-setuptools
$SYS_INSTALL python-pip
$PIP_INSTALL virtualenv

还能够创建新的虚拟环境：

virtualenv .env

但是,在运行如下命令之后：

. .env/bin/activate

我有

-bash: .env/bin/activate: No such file or directory

在查看文件夹.env / bin后,我发现只有一个python文件.这里的整个文件列表：

.env/lib:
python2.7

.env/include:
python2.7

.env/bin:
python

这是什么问题？

解决方案添加–always-copy

virtualenv .env –always-copy

接受的答案是不完整的！建议的代码遗漏了您的错误,但没有对其进行评论.

命令 . .env / bin / activate确实与文件夹.env / bin中激活文件的源相同.事实上,显然命令“source”是命令“.”的别名,而不是相反.注意 .这里有一个空格,并使用不同于.下面讨论(隐藏文件和文件夹).

我注意到你正在调用你的文件夹.env,这不是标准做法.前面的文件和文件夹.由Mac OS X“隐藏”.标准做法是调用虚拟环境目录env或venv,并调用虚拟环境规范文件.env.

因此,如果您的spec文件名为.env,并且您的虚拟环境目录名为env,则可以运行

source env / bin / activate要么. ENV /斌/激活.

Centos7 虚拟环境 virtualenv 与 virtualenvwrapper 的安装及基本使用

一. 使用虚拟环境的原因

在使用 Python 开发的过程中，工程一多，难免会碰到不同的工程依赖不同版本的库的问题；亦或者是在开发过程中不想让物理环境里充斥各种各样的库，引发未来的依赖灾难。此时，我们需要对于不同的工程使用不同的虚拟环境来保持开发环境以及宿主环境的清洁。这里，就要使用 virtualenv 与 virtualenvwrapper 来解决这个问题，一个可以帮助我们管理不同 Python 环境的绝好工具。virtualenv 可以在系统中建立多个不同并且相互不干扰的虚拟环境。

二.virtualenv 安装与使用

1. 安装 virtualenv

#指定清华源下载 pip 的包 (-i 后面为清华源)

pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv

#也可以直接使用命令

pip3 install virtualenv

#(如果提示 pip 版本太旧可以使用) 升级 pip 工具

pip3 install --upgrade pip

2.virtualenv 使用方法

(1) 创建目录

mkdir Myproject

cd Myproject

(2) 创建独立运行环境 - 命名

virtualenv --python=/usr/bin/python3 demo1

#得到独立第三方包的环境，并且指定解释器是 python3

(3) 进入虚拟环境

source  activate

#此时进入虚拟环境 (venv)Myproject

4. 安装第三方包

(venv)Myproject: pip3 install django==2.2

#此时 pip 的包都会安装到 venv 环境下，venv 是针对 Myproject 创建的

5. 退出 venv 环境

deactivate 命令

6.

virtualenv 是如何创建 “独立” 的 Python 运行环境的呢？原理很简单，就是把系统 Python 复制一份到 virtualenv 的环境，用命令 source activate 进入一个 virtualenv 环境时，virtualenv 会修改相关环境变量，让命令 python 和 pip 均指向当前的 virtualenv 环境。

7. 安装最简单的 django 项目

# mysite2 为项目名

django-admin startproject mysite2

python3 manage.py startapp app01 #app01 为 app 名称
修改下 settings.py
ALLOWED_HOSTS = ["*"]

# centos7 需要开启 web 端口
firewall-cmd --permanent --add-port=8000/tcp
firewall-cmd --reload

python manage.py runserver 0.0.0.0:8000

 

三.virtualenvwrapper 安装与使用 (推荐)

virtualenv 的一个最大的缺点就是：

每次开启虚拟环境之前要去虚拟环境所在目录下的 bin 目录下 source 一下 activate，这就需要我们记住每个虚拟环境所在的目录。

一种可行的解决方案是，将所有的虚拟环境目录全都集中起，并且针对不同的目录做不同的事。

使用 virtualenvwrapper 管理你的虚拟环境（virtualenv），其实他就是统一管理虚拟环境的目录，并且省去了 source 的步骤。

1. 安装 virtualenvwrapper

# 安装

pip3 install virtualenvwrapper

# 配置全局变量

[root@hsz Myproject]# find / -name virtualenvwrapper.sh

find: ‘/proc/70508’: No such file or directory

/usr/local/python3/bin/virtualenvwrapper.sh

[root@hsz Myproject]# vi ~/.bashrc

# 添加内容

# 虚拟环境的保存目录

WORKON_HOME=~/Envs

VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3

export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=''--no-site-packages''

source /usr/local/python3/bin/virtualenvwrapper.sh

# 使之生效

source ~/.bashrc

也可以:
vi ~/.bash_profile
写入以下几行代码(export可以先去掉)
export WORKON_HOME=~/Envs   # 设置virtualenv的统一管理目录, 以后自动下载的虚拟环境，全部都放在这
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=''--no-site-packages''   # 添加virtualenvwrapper的参数，生成干净隔绝的环境
export VIRTUALENVWRAPPER_PYTHON=/opt/python347/bin/python3     # 指定python解释器的本体(注意此路径随不同的linux环境改变而改变)
source /opt/python34/bin/virtualenvwrapper.sh # 执行virtualenvwrapper安装脚本

 

2. 使用 virtualenvwrapper 创建项目

# 创建虚拟环境 demo3

# 如果使用: mkvirtualenv demo3 -p python3  (使用相应的 python 版本)

[root@hsz Myproject]# mkvirtualenv demo3

Using base prefix ''/usr/local/python3''

New python executable in /root/Envs/demo3/bin/python3.6

Also creating executable in /root/Envs/demo3/bin/python

Installing setuptools, pip, wheel...

done.

# 查看有哪些虚拟环境

(demo3) [root@hsz Myproject]# workon

demo3

# 进入 demo3 虚拟环境

(demo3) [root@hsz Myproject]# workon demo3

(demo3) [root@hsz Myproject]# ls

demo1  demo2  mysite

# 安装 django == 后面表示版本

(demo3) [root@hsz]#  pip3 install django==2.2

# 创建 django 项目

(demo3) [root@hsz Myproject]# django-admin startproject mysite3

(demo3) [root@hsz Myproject]# ls

demo1  demo2  mysite  mysite3

# mysite3 下的 mysite3 修改 settings.py 的配置 , 在 []  加”*”

ALLOWED_HOSTS = ["*"]

# 运行 django 成功

python manage.py runserver 0.0.0.0:8000

 

# 注意 centos7 需要开启 web 端口，步骤如下

firewall-cmd --permanent --add-port=8000/tcp

firewall-cmd --reload 

# 或者直接关闭 firewall

## 关闭命令

systemctl stop firewalld

## 查看 firewall 状态

systemctl status firewalld

 

Linux下virtualenv与virtualenvwrapper详解

在使用 Python 开发的过程中，工程一多，难免会碰到不同的工程依赖不同版本的库的问题；

亦或者是在开发过程中不想让物理环境里充斥各种各样的库，引发未来的依赖灾难。

此时，我们需要对于不同的工程使用不同的虚拟环境来保持开发环境以及宿主环境的清洁。

这里，就要隆重介绍 virtualenv，一个可以帮助我们管理不同 Python 环境的绝好工具。

virtualenv 可以在系统中建立多个不同并且相互不干扰的虚拟环境。

一、Linux下安装、配置virtualenv

#指定清华源下载pip的包
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv
#升级pip工具
pip3 install --upgrade pip

 

1.安装virtualenv
pip3 install virtualenv 


2.创建目录
mkdir Myproject
cd Myproject
3.创建独立运行环境-命名
virtualenv --no-site-packages --python=python3  venv#得到独立第三方包的环境，并且指定解释器是python3
4.进入虚拟环境
source venv/bin/activate#此时进入虚拟环境(venv)Myproject
5.安装第三方包
(venv)Myproject: pip3 install django==1.9.8
#此时pip的包都会安装到venv环境下，venv是针对Myproject创建的
6.退出venv环境
deactivate命令
7.
virtualenv是如何创建“独立”的Python运行环境的呢？原理很简单，就是把系统Python复制一份到virtualenv的环境，用命令source venv/bin/activate进入一个virtualenv环境时，virtualenv会修改相关环境变量，让命令python和pip均指向当前的virtualenv环境。

二、确保开发环境的一致性

1.假设我们在本地开发环境，准备好了项目+依赖包环境
2.现在需要将项目上传至服务器，上线发布
3.那么就要保证服务器的python环境一致性

解决方案：
1.通过命令保证环境的一致性，导出当前python环境的包
pip3 freeze > requirements.txt   

这将会创建一个 requirements.txt 文件，其中包含了当前环境中所有包及 各自的版本的简单列表。
可以使用 “pip list”在不产生requirements文件的情况下， 查看已安装包的列表。


2.上传至服务器后，在服务器下创建virtualenv，在venv中导入项目所需的模块依赖
pip3 install -r requirements.txt

 三、虚拟环境之virtualenvwrapper

virtualenv 的一个最大的缺点就是：

每次开启虚拟环境之前要去虚拟环境所在目录下的 bin 目录下 source 一下 activate，这就需要我们记住每个虚拟环境所在的目录。

并且还有可能你忘记了虚拟环境放在哪。。。

• 一种可行的解决方案是，将所有的虚拟环境目录全都集中起来，例如/opt/all_venv/，并且针对不同的目录做不同的事。
• 使用virtualenvwrapper管理你的虚拟环境（virtualenv），其实他就是统一管理虚拟环境的目录，并且省去了source的步骤。

步骤1：安装virtualenvwrapper

pip3 install virtualenvwrapper

步骤2：设置Linux的环境变量，每次启动就加载virtualenvwrapper

把下面两行代码添加到 ~/.bashrc(针对于当前用户)文件中 或 /etc/profile(针对于所有的用户)  #写入如下内容 
打开文件
vim ~/.bashrc
写入以下两行代码
export WORKON_HOME=~/Envs   #设置virtualenv的统一管理目录
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=''--no-site-packages''   #添加virtualenvwrapper的参数，生成干净隔绝的环境
export VIRTUALENVWRAPPER_PYTHON=/opt/python347/bin/python3     #指定python解释器
source /opt/python34/bin/virtualenvwrapper.sh #执行virtualenvwrapper安装脚本
读取文件，使得生效，此时已经可以使用virtalenvwrapper
source ~/.bashrc

 

步骤3：基本使用virtualenvwrapper

创建一个虚拟环境：
$ mkvirtualenv my_django115
这会在 ~/Envs 中创建 my_django115 文件夹。

在虚拟环境上工作：激活虚拟环境my_django115
$ workon my_django115


再创建一个新的虚拟环境
$ mkvirtualenv my_django2

virtualenvwrapper 提供环境名字的tab补全功能。
当有很多环境， 并且很难记住它们的名字时，这就显得很有用。

workon还可以任意停止你当前的环境，可以在多个虚拟环境中来回切换
workon django1.15

workon django2.0

也可以手动停止虚拟环境
deactivate

删除虚拟环境，需要先退出虚拟环境
rmvirtualenv my_django115

步骤四：常用其他命令

lsvirtualenv
列举所有的环境。
cdvirtualenv
导航到当前激活的虚拟环境的目录中，比如说这样您就能够浏览它的 site-packages 。
cdsitepackages
和上面的类似，但是是直接进入到 site-packages 目录中。
lssitepackages
显示 site-packages 目录中的内容。

完整官网介绍：https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html

图解

二、Mac下创建pycharm

 

第二步：

第三步：此时这里的Django环境是虚拟环境的版本

第四步：检查venv下的django版本

第五步：添加已创建的虚拟环境venv的python解释器，至pycharm，用于创建1.98指定版本的django

第六步：成功启动1.98版本的django

 

Linux下安装virtualenv与virtualenvwrapper

一、Linux下安装、配置virtualenv

在使用 Python 开发的过程中，工程一多，难免会碰到不同的工程依赖不同版本的库的问题；
亦或者是在开发过程中不想让物理环境里充斥各种各样的库，引发未来的依赖灾难。
此时，我们需要对于不同的工程使用不同的虚拟环境来保持开发环境以及宿主环境的清洁。
这里，就要隆重介绍 virtualenv，一个可以帮助我们管理不同 Python 环境的绝好工具。
virtualenv 可以在系统中建立多个不同并且相互不干扰的虚拟环境。

#指定清华源下载pip的包
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv
#升级pip工具
pip3 install --upgrade pip

1.安装virtualenv
pip3 install virtualenv 


2.创建目录
mkdir Myproject
cd Myproject
3.创建独立运行环境-命名
virtualenv --no-site-packages --python=python3  venv#得到独立第三方包的环境，并且指定解释器是python3
4.进入虚拟环境
source venv/bin/activate#此时进入虚拟环境(venv)Myproject
5.安装第三方包
(venv)Myproject: pip3 install django==1.9.8
#此时pip的包都会安装到venv环境下，venv是针对Myproject创建的
6.退出venv环境
deactivate命令
7.
virtualenv是如何创建“独立”的Python运行环境的呢？原理很简单，就是把系统Python复制一份到virtualenv的环境，用命令source venv/bin/activate进入一个virtualenv环境时，virtualenv会修改相关环境变量，让命令python和pip均指向当前的virtualenv环境。

二、确保开发环境的一致性

1.假设我们在本地开发环境，准备好了项目+依赖包环境
2.现在需要将项目上传至服务器，上线发布
3.那么就要保证服务器的python环境一致性

解决方案：
1.通过命令保证环境的一致性，导出当前python环境的包
pip3 freeze > requirements.txt   

这将会创建一个 requirements.txt 文件，其中包含了当前环境中所有包及 各自的版本的简单列表。
可以使用 “pip list”在不产生requirements文件的情况下， 查看已安装包的列表。


2.上传至服务器后，在服务器下创建virtualenv，在venv中导入项目所需的模块依赖
pip3 install -r requirements.txt

三、虚拟环境之virtualenvwrapper

virtualenv 的一个最大的缺点就是： 每次开启虚拟环境之前要去虚拟环境所在目录下的 bin 目录下 source 一下 activate，这就需要我们记住每个虚拟环境所在的目录。 并且还有可能你忘记了虚拟环境放在哪。。。

• 一种可行的解决方案是，将所有的虚拟环境目录全都集中起来，例如/opt/all_venv/，并且针对不同的目录做不同的事。
• 使用virtualenvwrapper管理你的虚拟环境（virtualenv），其实他就是统一管理虚拟环境的目录，并且省去了source的步骤。

步骤1：安装virtualenvwrapper

pip3 install virtualenvwrapper

步骤2：设置Linux的环境变量，每次启动就加载virtualenvwrapper

把下面两行代码添加到 ~/.bashrc文件中
打开文件
vim ~/.bashrc
写入以下几行代码
export WORKON_HOME=~/Envs   #设置virtualenv的统一管理目录
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=''--no-site-packages''   #添加virtualenvwrapper的参数，生成干净隔绝的环境
export VIRTUALENVWRAPPER_PYTHON=/opt/python36/bin/python3     #指定python解释器
source /opt/python36/bin/virtualenvwrapper.sh #执行virtualenvwrapper安装脚本
读取文件，使得生效，此时已经可以使用virtalenvwrapper
source ~/.bashrc

步骤3：基本使用virtualenvwrapper

创建一个虚拟环境：
$ mkvirtualenv my_django115
这会在 ~/Envs 中创建 my_django115 文件夹。

在虚拟环境上工作：激活虚拟环境my_django115
$ workon my_django115


再创建一个新的虚拟环境
$ mkvirtualenv my_django2

virtualenvwrapper 提供环境名字的tab补全功能。
当有很多环境， 并且很难记住它们的名字时，这就显得很有用。

workon还可以任意停止你当前的环境，可以在多个虚拟环境中来回切换
workon django1.15

workon django2.0

也可以手动停止虚拟环境
deactivate

删除虚拟环境，需要先退出虚拟环境
rmvirtualenv my_django115

步骤四：常用其他命令

lsvirtualenv
列举所有的环境。
cdvirtualenv
导航到当前激活的虚拟环境的目录中，比如说这样您就能够浏览它的 site-packages 。
cdsitepackages
和上面的类似，但是是直接进入到 site-packages 目录中。
lssitepackages
显示 site-packages 目录中的内容。

完整官网介绍：https://virtualenvwrapper.readthedocs.io/en/latest/command_ref.html

学习运维架构技术乃王道
1.Nginx高可用负载均衡/缓存、限流/提升集群处理并发能力
2.mysql主从复制，读写分离
3.redis缓存加速与主从复制，哨兵，集群
4.异步消息/服务解耦之rabbitMQ消息队列
5.代码层优化/改进算法/多线程与内存优化
6.使用golang,Erlang等csp并发编程语言
7.docker容器时代


服务器介绍：
1.路飞的7台阿里云，腾讯云，亚马逊云，华为云
    数据都放在其他人的电脑上，安全性由别人掌控

2.公司有钱，有26台Dell实体服务器，vmware  esxi虚拟化的300+Linux
    公司有钱，自建机房（盖了一个厂房，里面专业托管服务器）
    有专业的公司，建造机房（世纪互联）
    机房都是有严格的标准，保护机器不断电，不损坏
    1.无静电
    2.无尘
    3.无湿度
    4.低温

Linux发行部：
Linux是一个名词，是系统的代表
1.红帽子公司  redhat Linux 收费
    -2045之前，外企
    -红帽Linux 资格认证证书
    rhcsa 红帽系统管理员
    rhce 红帽工程师
    rhca 红帽构架师
2.centos 免费版，社区版 centos7
3.Ubuntu 乌班图系统
4.suse 德国    Linux 收费


保证开发环境的一致性
1.手动解决
2.自动化解决
3.通过docker镜像
4.通过vmware系统模板镜像


Linux网络连接方式
桥接：
在一个局域网内，添加了一个新的机器

vmware就像是虚拟化的一个机房的服务器

远程连接
1.使用ssh命令
2.获取服务器的ip地址
3.window的xshell中输入：ssh root@192.168.0.101 远程连接Linux机器

Linux重要的目录
bin目录 有关bin的文件夹都是存放可执行文件的
etc目录存放配置文件的  /etc/my.conf   /etc/nginx.conf   /etc/redis.conf
    配置文件就是定制一堆参数，自己控制的参数
opt目录 存放第三方软件的安装路径的   /opt/redis   /opt/nginx   /opt/python36
root目录 存放超级用户的家目录
var目录 存放系统日志相关

Linux目录结构的操作
cd - 上一次的工作目录
cd ~ 当前登录用户的家目录
cd . 当前目录
cd .. 上一级目录

绝对路径：一切从根目录开始，就是一个绝对路径
相对路径：以当前位置为相对，找到路径

PATH变量是用于,当用户直接输入命令的时候，去查找的一个路径寻找点
当我们输入ls的时候，Linux回去PATH中寻找，哪里有ls


Linux命令学习：
ssh root@192.168.0.101
1.查看ip地址
ip a
ifconfig
2.linux目录分割是正斜杠/
3.w 那些用户在登录
4.whoami 我是谁
5.pwd 我在哪
6.更改目录
cd /
7.用于输出文件夹的内容
ls 
ll
ls -a 查看隐藏文件
ls -la
ls -lh 带文件大小
8.linux文件的颜色
浅蓝是软链接目录
蓝色是文件夹
白色是普通文件
绿色是可执行文件
9.创建目录
mkdir
mkdir -p ./a/b/c/d
mkdir -p ./bubu/{linux,python}
10.创建文件
touch
11.vi/vim写入内容
    a.此时进入了命令模式，输入键盘的i，进入编辑模式
    b.编辑模式下可以写入代码
    c.退出编辑模式按下Esc,此时就进入了底线命令模式
    d.输入:wq!
        :进入底线模式
        w 写入
        q 退出
        ！强制的
    底线命令模式 :set nu 显示行号    
12.cat查看写入cat >>ceshi.txt <<EOF
[root@localhost /tmp/bubu 00:19:28]#cat >>ceshi.txt <<EOF
> ceshi
> 123
> EOF
[root@localhost /tmp/bubu 00:20:02]#cat ceshi.txt
ceshi
[root@localhost /tmp/bubu 00:20:09]#

cat /etc/passwd > ./passwd.txt 将/etc/passwd的内容写入到当前passwd.txt文件中

13.创建新用户
useradd bubu
passwd bubu
14.切换用户
su bubu
15.删除
rmdir 删除空文件夹
rm -rf * == rm -rf ./*  强制删除当前目录的所有内容
rm -rf /*  删除根（作死）
    -f递归删除文件夹
    -r强制性删除
    -i提示性操作，是否删除

16.ctrl+c 中断当前操作
17.which ls 
18.echo $PATH
19.hostname 查看主机名
20.hostnamectl set-hostname localhost
21.logout 退出重新登录查看
22.Linux命令提示符
[root@localhost ~]#
23.修改命令提示符
PS1变量控制

[root@localhost ~]# echo $PS1
[\u@\h \W]\$

修改命令提示符：
PS1=''[\u@\h \w \t]\$''


24.软件时间date，硬件时间hwclock
ntpdate -u ntp.aliyun.com
25.clear
26.history

27.yum install tree -y 安装树状图命令
28.tree mysite/
29.echo 写入文件内容
echo ''hello'' > ./test.txt
> 重定向覆盖写入符
>> 追加

30.拷贝 cp 目标文件 拷贝后的文件
cp my.py my.py.bak 

31.重命名命令，以及移动命令
mv 旧文件名 新文件名
mv 目标文件 移动后的路径
mv ../tmp/ceshi/txt ./

32.find 查找文件
find / -name test.txt  从根目录开始找，一个叫做test.txt的文件
find /opt -name ''*.py''  从/opt目录下查找所有的.py文件
linux 管道符“|” 语法就是将第一条命令的结果传给第二条

33.过滤出python有关的进程
ps -ef | grep python
34.过滤出22端口的信息
netstat -tunlp| grep 22

35.过滤命令grep
grep nobody ./passwd.txt  从当前的passwd.txt文件中过滤出nobody的信息
grep all settings.py  过滤出django中settings.py 中allow_hosts的信息
grep all settings.py -n 过滤出allow_hosts的信息且输出行号
grep -v all settings.py  过滤出除allow_hosts之外的信息
grep -v all settings.py -n  过滤出除allow_hosts之外的信息且输出行号
cat settings.py | grep allow

36.head 
head -5 test.txt 
37.tail
tail -5 test.txt
tail -f test.txt 实时监控

37.alias别名
alias rm="rm -i"
alias rm="echo 求求你了，你可别坑我了！！！"

38.unalias rm 取消别名

39.远程传输文件，在两台Linux上
scp  想要操作的文件地址  存放的目标文件地址
scp  test.txt root@192.168.0.109:/tmp/
scp -r a root@192.168.0.109:/tmp/     -r递归传输文件夹

40.查看文件夹大小
方式1：ls -lh
方式2：du -h
du -sh /var/log/
    -s 合计文件夹大小
    -h 显示友好的单位换算

41.top命令（任务管理器）用于动态地监视进程活动和系统负载等信息 q退出
42.wget 下载
wget -r -p http://www.luffycity.com
43.Linux和window互相传递文件
    1.lrzsz
        sz test.txt(下载 从Linux传给window)
        rz test.txt(上传)
    2.xftp
    
44.reboot 重启
45.poweroff 关闭系统
46.free -m 查看内存
47.man grep 查看grep的帮助手册
48.防火墙
iptables -L #查看规则
iptables -F #清空防火墙规则
永久关闭防火墙，可能防火墙会阻挡你的Linux环境配置实验，为了方便，关闭它。
systemctl stop firewalld  #关闭防火墙服务
systemctl disable firewalld #永久关闭，开机自启

49.tar -xf Python-3.6.2.tgz 解压
50.logout 退出账号


#######################################################################
用户权限相关
[root@localhost ~]# id       #返回用户的身份信息，当uid为0的时候，这个用户就是超级用户 
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
[root@localhost ~]# id root
uid=0(root) gid=0(root) groups=0(root)

用户的存放文件：
/etc/passwd
/etc/shadow  存放用户密码的文件

用户的管理命令：
添加普通用户（只有root用户有这个权利）
[root@localhost ~]# useradd tom     #创建用户，这个用户的信息会存放到/etc/passwd
[root@localhost ~]# grep tom /etc/passwd  #查看用户信息，普通用户的id默认是从1000开始的
tom:x:1001:1001::/home/tom:/bin/bash
[root@localhost ~]# 

修改普通用户的密码
passwd 用户名

切换用户（必须加上中横线- 代表完全用户切换）
[root@localhost ~]# su - tom   
[tom@localhost root]$ 

添加用户组
groupadd it_dep

删除用户
userdel -rf tom
-f     强制删除用户
-r    同事删除用户以及家目录

sudo命令用来以其他身份来执行命令，预设的身份为root
1.编辑sudoers配置文件，添加tom用户信息  
vim /etc/sudoers    (/查找root   n查找下一个)
2.定位权限设置到
root    ALL=(ALL)       ALL
添加
root    ALL=(ALL)       ALL
tom     ALL=(ALL)       ALL
3.使用sudo命令，去执行Linux命令，解决权限不足
[tom@localhost ~]$ ls /root
ls: cannot open directory /root: Permission denied
[tom@localhost ~]$ sudo ls /root
[sudo] password for tom: 
anaconda-ks.cfg
4.sudo还提供了一个语法检测的命令 visudo
 

文件权限：
读取(vim)  查看(cat)   执行（xx.py   xx.sh）
通过解释器执行  ./xx.sh    或者  source  xx.sh    或者   . xx.sh  
文件夹的权限：
新增  修改  删除   进入目录

Linux软链接创建注意用绝对路径
ln -s 目标文件绝对路径  软链接绝对路径



tar命令，参数
-x 解压
-v 显示压缩解压过程
-f 指定压缩文件
-z 指定调用gzip命令
-c 压缩当前目录的所有内容：
-r 添加文件到已有的压缩文件中
tar -rf alltmp.tgz 新加的文件名

压缩当前目录的所有内容：
tar -cf alltmp.tgz ./*
tar -cf alltmp.tgz *
tar -cf alltmp.tar *

tar -zcf alltmp.tar.gz *


解压到当前目录
tar -xf alltmp.tgz 

查看命令帮助：
tar --help
man tar
linum 中文手册


进程查看
ps -ef 查看所有进程的状态
ps -ef | grep python

网络端口管理命令
netstat -tunlp | grep 8000

kill命令 杀死进程
kill pid    （pid通过ps -ef 查看）

一次性杀死多个匹配的进程,一个是pkill,一个是killall, 
如果没有killall就安装一下 yum install psmisc -y
killall python

查看磁盘空间
df -h

Linux的dns服务相关
1.dns服务指定配置文件，这个文件，告诉Linux去那解析dns域名，
有主备两个dns服务器ip地址
[root@localhost ~]# cat /etc/resolv.conf
# Generated by NetworkManager
domain www.tendawifi.com
search www.tendawifi.com
nameserver 192.168.0.1
[root@localhost ~]# 

2.Linux解析dns的命令
nslookup www.baidu.com #解析到这个域名对应的ip地址

3.Linux强制dns，或者本地dns域名解析
vim /etc/hosts
ip 自定义的域名

4.域名解析的流程，（一个域名从浏览器访问，解析过程是如何的）
    1.浏览器输入域名，浏览器首先会去当前机器的本地dns缓存中查找记录
    2.去hosts文件中查找是否写死了对应的记录
    3.去指定的dns服务器中寻找dns记录，如果找到了域名解析记录后
    4.将这个dns记录缓存到本机的缓存记录中
    5.下一次寻找域名，就去缓存中找

Linux的计划任务，也叫做定时任务，名字是crond
1.查看Linux本机的定时任务
crontab -l  #查看计划任务
2.编写自己的计划任务
crontab -e #编辑计划任务
分时日月周  命令绝对路径
* * * * * /user/bin/echo "666" >> /tmp/ceshi.txt

Linux系统服务管理命令
系统服务（Linux安装的软件名）
只有通过yum安装的软件才可以使用这个命令
systemctl 这是centos7系列的命令
service 这是centos6系统的服务管理命令

查看网络状态
systemctl status network

查看发行版
cat /etc/os-release

Linux常用命令

pip3是管理python模块的工具，自动解决模块依赖
pip3 list
pip3 install flask 默认是去python官方下载，网速很慢
更改pip下载的源，加速下载，使用离咱们近的豆瓣源，163源或者清华源
pip3 install -i https://pypi.douban.com/simple flask


Linux安装软件包
rpm手动安装
yum工具自动化安装    效果等同于 pip3

1.理解yum源（阿里云的yum源  epel额外仓库）
yum源仓库的位置：cd /etc/yum.repos.d/，并且只能读出第一层的repo文件
yum仓库的文件都是以.repo结尾的

2.下载阿里云的.repo仓库文件，放到/etc/yum.repos.d/
    第一步：备份原本的仓库文件
    cd /etc/yum.repos.d/
    mkdir allbak
    mv * allbak
    
    1.下载第一个阿里云仓库文件
    wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
         -O 参数，指定一个下载地址，且改名
    2.配置第二个仓库文件 epel 额外仓库（redis,nginx,mongo,ipython）
    wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
    
    3.清空原本yum缓存
    yum clean all
    4.生成新的阿里云的yum缓存，加速下载预热数据(此步骤非必须)
    yum makecache


代码：    
1.cd /etc/yum.repos.d/
2.mkdir allbak
3.mv * allbak
4.wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
5.wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
6.yum clean all
7.yum makecache


yum安装nginx:
1.yum install nginx -y
2.systemctl start/restart/stop nginx
3.netstat -tunlp | grep 80 查看端口，过滤80端口的信息
4.iptables -F （清空防火墙规则） 
5.客户端：192.168.0.101:80 访问

/usr/share/nginx/html/index.html
yum remove nginx

配置yum源安装软件

编译安装python3
1.切换opt目录（这是一个约定）
cd /opt 
2.下载python3的源代码
wget https://www.python.org/ftp/python/3.6.2/Python-3.6.2.tgz
3.安装python前的库环境，非常重要
yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel -y

4.解压缩python3的源代码压缩文件
cd /opt/ 进入存在这个文件的目录
tar -xf Python-3.6.2.tgz 解压
5.cd Python-3.6.2/  进入源代码目录下，准备开始编译安装 
6.编译安装三部曲
第一曲：
cd Python-3.6.2/
#configure 这个脚本文件，只是为了释放makefile，用于指定python3安装到哪里
./configure    --prefix=/opt/python36  --with-ssl
        --prefix 这个参数用于指定python安装的路径
第二曲：
执行make开始编译python3.6的源代码
make

第三曲：
make install  生成/opt/python36

（第二曲和第三曲可以写成    make && make install）

7.配置环境变量
echo $PATH             #$PATH是有优先级顺序的
将/opt/python36/bin/放入环境变量，注意要添加到path的最前面
#变量的赋值只是临时有效
PATH="/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin"
#将这个参数，写入到Linux的全局变量配置文件中
vim /etc/profile     #打开这个全局变量文件，写入PATH="/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin"到文件最后

8.退出（logout），重新加载全局变量.
9.which python3 确认是否正确安装
10.不要将系统默认的python 改成python3  这是一个大坑。
(因为Linux有很多工具，默认是用的python2，例如yum)


11.在Linux下安装django程序
pip3 install -i https://pypi.douban.com/simple django==1.11.16
pip3 install django==1.11.16
pip3 list

12.使用django命令创建项目
[root@localhost ~]# cd /opt
[root@localhost opt]# django-admin startproject mysite

13.修改mysite的settings.py中的ALLOWED_HOSTS
vim /opt/mysite/mysite/settings.py     #/查找
ALLOWED_HOSTS = ["*"]

14.启动项目
[root@localhost opt]# cd mysite/
[root@localhost mysite]# python3 manage.py runserver 0.0.0.0:9999

补充：
python3的管理工具是pip3 install flask
python2的是easy_install flask


[root@localhost ~]# python -V
Python 2.7.5
[root@localhost ~]# python --version
Python 2.7.5
[root@localhost ~]# python3 --version
Python 3.6.2
[root@localhost ~]# pip3 list
DEPRECATION: The default format will switch to columns in the future. You can use --format=(legacy|columns) (or define a format=(legacy|columns) in your pip.conf under the [list] section) to disable this warning.
Django (1.11.16)
pip (9.0.1)
pytz (2019.2)
setuptools (28.8.0)
You are using pip version 9.0.1, however version 19.2.3 is available.
You should consider upgrading via the ''pip install --upgrade pip'' command.
[root@localhost ~]#

编译安装python3

virtualenv 是python解释器的分身
它是基于物理解释器，进行一个解释器分身，这个分身，可以用于运行各种python开发环境，
并且创建简单，删除销毁也简单，解决环境依赖灾难。
1.安装虚拟环境
pip3 install -i https://pypi.douban.com/simple virtualenv
2.通过virtualenv创建虚拟环境
mkdir /opt/allenv   #建立统一管理目录
cd /opt/allenv  #进入统一管理目录
virtualenv --no-site-packages --python=python3  venv1 #建立虚拟环境venv1
--no-site-packages 创建一个干净隔离的python环境
--python=python3 基于python3创建虚拟环境
venv1 虚拟环境文件夹的名字，自己定义
3.激活虚拟环境
cd /opt/allenv
通过source命令，读取激活脚本，激活虚拟环境
source /opt/allenv/venv1/bin/activate
4.激活虚拟环境后，检查以下几个步骤，是否正确激活
which pip3
which python3
5.检查虚拟环境是否干净隔离
pip3 list
6.退出虚拟环境的命令
deactivate



[root@localhost ~]# pip3 install -i https://pypi.douban.com/simple virtualenv
[root@localhost ~]# cd /opt
[root@localhost opt]# mkdir allenv
[root@localhost opt]# cd allenv
[root@localhost allenv]# virtualenv --no-site-packages --python=python3  venv1
Running virtualenv with interpreter /opt/python36/bin/python3
Already using interpreter /opt/python36/bin/python3
Using base prefix ''/opt/python36''
New python executable in /opt/allenv/venv1/bin/python3  # 这个就是虚拟环境venv1的python3解释器
Also creating executable in /opt/allenv/venv1/bin/python
Installing setuptools, pip, wheel...
done.
[root@localhost allenv]# 
[root@localhost allenv]# ls
venv1
[root@localhost allenv]# cd venv1
[root@localhost venv1]# ls
bin  include  lib
[root@localhost venv1]# cd bin
[root@localhost bin]# ls
activate      activate.fish  activate_this.py  easy_install      pip   pip3.6  python3    python-config
activate.csh  activate.ps1   activate.xsh      easy_install-3.6  pip3  python  python3.6  wheel
[root@localhost bin]# source activate
(venv1) [root@localhost bin]# 
(venv1) [root@localhost bin]# which pip3
/opt/allenv/venv1/bin/pip3
(venv1) [root@localhost bin]# 
(venv1) [root@localhost bin]# pip3 list
Package    Version
---------- -------
pip        19.2.3 
setuptools 41.2.0 
wheel      0.33.6 
(venv1) [root@localhost bin]# which python3
/opt/allenv/venv1/bin/python3
(venv1) [root@localhost bin]# 
(venv1) [root@localhost bin]# echo $PATH
/opt/allenv/venv1/bin:/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin
(venv1) [root@localhost bin]# pip3 install -i https://pypi.douban.com/simple django==2.0


确保开发环境的一致性：

解决方案：
1.通过命令保证环境的一致性，导出当前python环境的包
pip3 freeze > requirements.txt   

这将会创建一个 requirements.txt 文件，其中包含了当前环境中所有包及 各自的版本的简单列表。
可以使用 “pip list”在不产生requirements文件的情况下， 查看已安装包的列表。

2.上传至服务器后，在服务器下创建virtualenv，在venv中导入项目所需的模块依赖
pip3 install -r requirements.txt

virtualenv

虚拟环境之virtualenvwrapper：
1.因为virtualenv工具使用并不方便
2.安装virtualenvwrapper
pip3 install virtualenvwrapper
3.设置Linux的环境变量，每次启动就加载virtualenvwrapper
    1.打开文件
    vim ~/.bashrc  （这个文件是用户个人配置文件）
    2.写入以下几行代码 （export和source一样都是读取Linux shell 变量的命令）
    export WORKON_HOME=~/Envs   #设置virtualenv的统一管理目录
    export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=''--no-site-packages''   #添加virtualenvwrapper的参数，生成干净隔绝的环境
    export VIRTUALENVWRAPPER_PYTHON=/opt/python36/bin/python3     #指定python解释器
    source /opt/python36/bin/virtualenvwrapper.sh #这一步才是真正使用工具的步骤，执行virtualenvwrapper安装脚本
    3.退出当前会话，重新登录Linux
    logout
    4.重新登录，查看是否可以使用virtalenvwrapper
    5.确保可以使用后，学习这个工具的命令
        1.创建新的虚拟环境 
        mkvirtualenv django201
        mkvirtualenv django115
        2.切换不同的虚拟环境
        workon django201
        workon django115
        3.退出虚拟环境
        deactivate
        4.删除虚拟环境
        rmvirtualenv django116
        5.进入虚拟环境的家目录（直接进入到 site-packages 目录中）
        cdsitepackages
        6.列举所有的环境。
        lsvirtualenv
        7.显示 site-packages 目录中的内容。
        lssitepackages

virtualenvwrapper

运行crm
1.准备代码
2.上传代码到Linux中
    方式1:lrzsz（只能传单个的文件,必须是压缩包）
        yum install lrzsz -y # 安装传输工具
        sz test.txt(下载 从Linux传给window)
        rz test.txt(上传)
    方式2:xftp
3.解压
unzip crm.zip
4.用之前建好的虚拟环境去运行 ：
workon django201        
5.启动
python3 /opt/crm/manage.py runserver 0.0.0.0:9000



上面第四步也可以新建虚拟环境去运行 ：
1.mkvirtualenv myblog
2.解决环境依赖，少什么装什么
  pip3 install -i https://pypi.douban.com/simple django==2.0
  pip3 install -i https://pypi.douban.com/simple pymysql
  pip3 install -i https://pypi.douban.com/simple django-multiselectfield   [multiselectfield模块]
3.安装Linux的mysql数据库
在centos7中，mysql叫mariadb  安装mariadb的服务端和客户端
yum install mariadb-server  mysql -y 
4.启动mariadb数据库
[root@localhost ~]# systemctl start mariadb
5.检查数据库是否正常(下面几种方式都可以)
ps -ef|grep mariadb
netstat -tunlp |grep 3306
systemctl status mariadb
6.看settings的配置，DATABASES,ALLOWED_HOSTS
7.建数据库,导入数据
[root@localhost ~]# systemctl start mariadb
[root@localhost ~]# mysql -uroot -p
MariaDB [(none)]> create database myblog;
MariaDB [(none)]> use myblog;
MariaDB [myblog]> source /opt/myblog.sql;
MariaDB [myblog]> show databases;

8.运行
python3 /opt/myblog/manage.py runserver 0.0.0.0:9000

运行crm

运行路飞学城
1.下载代码
路飞学城django代码
wget https://files.cnblogs.com/files/pyyu/luffy_boy.zip
vue代码
wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip
2.解压
unzip 07-luffy_project_01.zip  
unzip luffy_boy.zip
3.先从后端代码开始，进入后端代码文件夹
4.新建虚拟环境
mkvirtualenv luffy
5.解决所需的依赖模块，准备一个模块版本文件：requirements.txt 这个文件可以手动创建写入如下依赖
(luffy) [root@localhost opt]# cd /opt/luffy/luffy_boy
(luffy) [root@localhost luffy_boy]# touch requirements.txt
(luffy) [root@localhost luffy_boy]# vim requirements.txt 
##############################
certifi==2018.11.29
chardet==3.0.4
crypto==1.4.1
Django==2.1.4
django-redis==4.10.0
django-rest-framework==0.1.0
djangorestframework==3.9.0
idna==2.8
Naked==0.1.31
pycrypto==2.6.1
pytz==2018.7
PyYAML==3.13
redis==3.0.1
requests==2.21.0
shellescape==3.4.1
urllib3==1.24.1
uWSGI==2.0.17.1
##############################
(luffy) [root@localhost luffy_boy]# ls
api  db.sqlite3  keys  luffy_boy  manage.py  requirements.txt  static  templates
6.安装所需的依赖模块
(luffy) [root@localhost luffy_boy]# pip3 install -i https://pypi.douban.com/simple -r requirements.txt 
7.看一看
pip3 list
8.运行
python3 manage.py runserver 0.0.0.0:8000  （注意端口得是8000，因为前端的vue发的就是8000）


9.新开一个终端开始前端(要在服务器上，编译打包vue项目，必须得有node环境)
1.准备node环境
下载node二进制包，此包已经包含node，不需要再编译
[root@localhost ~]# cd /opt
[root@localhost opt]# wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz
2.解压缩
[root@localhost opt]# tar -zxvf node-v8.6.0-linux-x64.tar.gz
3.进入node文件夹
[root@localhost opt]# cd node-v8.6.0-linux-x64/
[root@localhost node-v8.6.0-linux-x64]# ls
bin  CHANGELOG.md  etc  include  lib  LICENSE  README.md  share
[root@localhost node-v8.6.0-linux-x64]# cd bin
[root@localhost bin]# ls
node  npm  npx
[root@localhost bin]# pwd

/opt/node-v8.6.0-linux-x64/bin
4.配置环境变量
[root@localhost bin]# vim /etc/profile
PATH="/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/node-v8.6.0-linux-x64/bin"
5.读取全局配置文件，加载node的环境变量
[root@localhost bin]# source /etc/profile   #就不需要退出重新加载了
[root@localhost bin]# echo $PATH
/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/node-v8.6.0-linux-x64/bin
[root@localhost bin]# which node
/opt/node-v8.6.0-linux-x64/bin/node
6.检测node环境
[root@localhost bin]# node -v
v8.6.0
[root@localhost bin]# npm -v
5.3.0
[root@localhost bin]# 
【注意】进入vue代码包中，开始进行打包，注意修改vue的api请求接口地址！！
【注意】进入vue代码包中，开始进行打包，注意修改vue的api请求接口地址！！
【注意】进入vue代码包中，开始进行打包，注意修改vue的api请求接口地址！！
7.修改src/restful/api.js中Axios的请求地址 ##里面的127.0.0.1都换成你后端服务器的id地址 192.168.0.101
[root@localhost ~]# sed -i "s/127.0.0.1/192.168.0.101/g" /opt/luffy/07-luffy_project_01/src/restful/api.js  ##全局替换命令
8.进入vue目录(安装vue模块，默认去装package.json的模块内容，如果出现模块安装失败，手动再装)
[root@localhost bin]# cd /opt/luffy/07-luffy_project_01/
[root@localhost 07-luffy_project_01]# ls
build  config  index.html  package.json  package-lock.json  README.md  src  static
[root@localhost 07-luffy_project_01]# npm install
[root@localhost 07-luffy_project_01]# ls     #增加了node_modules
build  config  index.html  node_modules  package.json  package-lock.json  README.md  src  static  
9.打包vue项目，生成一个dist静态文件夹
[root@localhost 07-luffy_project_01]# npm run build
10.检查dist文件夹
[root@localhost 07-luffy_project_01]# ls
build  config  dist  index.html  node_modules  package.json  package-lock.json  README.md  src  static  #增加了dist
[root@localhost 07-luffy_project_01]# ls dist
index.html  static
11.只需要将vue的静态文件，发布到web我放弃，访问web服务器即可。
12.安装配置nginx web服务器，访问到vue的静态文件
[root@localhost ~]# yum install nginx -y
[root@localhost ~]# systemctl start nginx
[root@localhost ~]# netstat -tunlp|grep nginx
[root@localhost ~]# find / -name index.html   # 192.168.0.101  看到的就是这个页面/usr/share/nginx/html/index.html
[root@localhost ~]# vim /etc/nginx/nginx.conf
###################
server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /opt/luffy/07-luffy_project_01/dist;   ##更改这的路径
        #root这个参数代表定义网页根目录，只要访问Nginx，Nginx就去这个根目录下寻找一个index.html的文件
        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
###################
12.重启nginx服务才能生效
[root@localhost ~]# systemctl restart nginx
13.添加课程数据是存放到redis中的，需要安装redis
yum install redis -y
14.启动redis
[root@localhost ~]# systemctl start redis
[root@localhost ~]# netstat -tunlp |grep 6379
[root@localhost ~]# redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> FLUSHDB  #手动清除数据
OK
127.0.0.1:6379> keys *
15.测试
http://192.168.0.101

运行路飞学城

关于virtualenv的问题-无法激活和激活virtualenv环境的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于bash – 激活virtualenv的问题、Centos7 虚拟环境 virtualenv 与 virtualenvwrapper 的安装及基本使用、Linux下virtualenv与virtualenvwrapper详解、Linux下安装virtualenv与virtualenvwrapper等相关内容，可以在本站寻找。

本文将介绍Python中使用python-memcache的详细情况，特别是关于memcached的好例子？的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Memcache/Memcached的PHP操作手册（纯手稿版） memcached java memcached官网 redis memcached 比较、memcached - ThinkPHP3.2.3 使用S方法（Memcache）无法正确输出结果、memcached python 客户端编写实践、Memcached 安装/使用(Python操作)的知识。

本文目录一览：

• Python中使用python-memcache（memcached）的好例子？（python memcache）
• Memcache/Memcached的PHP操作手册（纯手稿版） memcached java memcached官网 redis memcached 比较
• memcached - ThinkPHP3.2.3 使用S方法（Memcache）无法正确输出结果
• memcached python 客户端编写实践
• Memcached 安装/使用(Python操作)

Python中使用python-memcache（memcached）的好例子？（python memcache）

我正在使用Python和web.py框架编写Web应用程序，并且需要在整个过程中使用memcached。

我一直在互联网上搜索，试图在python-
memcached模块上找到一些好的文档，但是我所能找到的只是MySQL网站上的该示例，而其方法的文档也不是很好。

答案1

小编典典

这很简单。您可以使用键和有效时间来写值。您可以使用键获取值。您可以使系统中的密钥失效。

大多数客户遵循相同的规则。您可以在memcached主页上阅读通用说明和最佳做法。

如果您真的想深入研究它，我会看看源代码。这是标题注释：

"""client module for memcached (memory cache daemon)Overview========See U{the MemCached homepage<http://www.danga.com/memcached>} for more about memcached.Usage summary=============This should give you a feel for how this module operates::    import memcache    mc = memcache.Client([''127.0.0.1:11211''], debug=0)    mc.set("some_key", "Some value")    value = mc.get("some_key")    mc.set("another_key", 3)    mc.delete("another_key")    mc.set("key", "1")   # note that the key used for incr/decr must be a string.    mc.incr("key")    mc.decr("key")The standard way to use memcache with a database is like this::    key = derive_key(obj)    obj = mc.get(key)    if not obj:        obj = backend_api.get(...)        mc.set(key, obj)    # we now have obj, and future passes through this code    # will use the object from the cache.Detailed Documentation======================More detailed documentation is available in the L{Client} class."""

Memcache/Memcached的PHP操作手册（纯手稿版） memcached java memcached官网 redis memcached 比较

data-id="1190000005001849" data-licence="">

memcache和memcached 其实是一个东西，只是php中要是用的扩展不一样一个是 php_memcache.dll 和 php_memcached.dll , 2009年左右有人丰富memcache的用法和性能，才有了memcached ,用法也有了很大的改进比如添加了 getmulti() 批量获取键值

---

Memcache 类

$memcache = new Memcache;

登录后复制

$memcache->connect(''127.0.0.1'', 11211);

登录后复制

$memcache->pconnec(''127.0.0.1'', 11211); 
// 打开一个到服务器的持久化连接 , 连接不会在脚本执行结束后或者close()被调用后关闭

登录后复制

$memcache->addServer(''123.57.210.55'', 11211,$persistent,$weight); 
// 向连接池中添加一个memcache服务器 $persistent 是否持久化连接 $weight 
   控制桶的数量提升被选中的权重 $timeout 表示连续持续时间

登录后复制

$memcache->set(''name'', ''TK''); 
// 默认存储不压缩 不过期 , 其中字符串和数值直接存储，其他类型序列化后存储 
   set其实是add方法和replace方法集合

登录后复制

$memcache->set(''email'', ''julylovin@163.com'',MEMCACHE_COMPRESSED,5);
// MEMCACHE_COMPRESSED设置存储是否压缩 , 5表示5秒后过期但是最大只能设置2592000秒(30天)
   如果设置为0 表示永不过期, 可以设置将来的时间戳

登录后复制

$memcache->set(''info'',array(''age''=>''26'',''salary''=>''1000''));  
// 可以直接存储数组,redis中存储需要手动serialize()序列化

登录后复制

$memcache->add(''counter'', ''10'', MEMCACHE_COMPRESSED, 0); 
//如果键值存在会返回false , 如果不存在, 和set方法一样，生成一个counter的key并赋值10

登录后复制

$memcache->replace (''counter'', ''10'');
 //如果键值不存在会返回false , 如果存在, 替换counter的值为10

登录后复制

$memcache->increment(''counter'', 3); 
// 首先将元素当前值转换成数值然后减去value 操作counter键值+3 
   若键不存在 则返回false 不能用于压缩的键值操作，否则get键会失败

登录后复制

$memcache->decrement(''counter'', 3); // 操作counter键值-3 , 若键不存在 则返回false

登录后复制

$memcache->delete(''counter'', 3); // 操作删除键counter ， 3表示3秒内删除，默认是0即立即删除

登录后复制

$memcache->flush(); //flush()立即使所有已经存在的元素失效

登录后复制

$memcache->getExtendedStats (); 
// 返回一个二维关联数据的服务器统计信息。数组的key由host:port方式组成

登录后复制

$memcache->getServerStatus (''127.0.0.1''); // 获取返回一个服务器的在线/离线状态  0表示离线 非0在线

登录后复制

$memcache->getStats(); // 获取服务器统计信息

登录后复制

$memcache->getVersion(); // 返回服务器版本信息

登录后复制

$memcache->setCompressThreshold ($threshold, $min_saving); 
//  开启大值自动压缩   $threshold设置压缩阀值 2000字节 ，即字节数大于2K 就压缩
    $min_saving  0--1之间  0.2表示压缩20%

登录后复制

$memcache->setServerParams(''memcache_host'', 11211, 1, 15, true, ''_callback_memcache_failure''); 
// $memcache->addServer(''memcache_host'', 11211, false, 1, 1, -1, false);
   已经通过addServer 配置过服务器 使用setServerParams 重新设置配置信息

登录后复制

以上就介绍了Memcache/Memcached的PHP操作手册（纯手稿版），包括了Memcached方面的内容，希望对PHP教程有兴趣的朋友有所帮助。

memcached - ThinkPHP3.2.3 使用S方法（Memcache）无法正确输出结果

1.使用tp3.2.3自带的s方法使用memcache，memcache支持已开，根据网上的教程ctrl+v的方法不能够正常输出结果
2.先看图

这是配置：

php-ini文件也已经添加相关内容

---

但是输出结果为false
求帮助

这样子 也是试过的……

立即学习“PHP免费学习笔记（深入）”；

回复内容：

1.使用tp3.2.3自带的s方法使用memcache，memcache支持已开，根据网上的教程ctrl+v的方法不能够正常输出结果
2.先看图

这是配置：

php-ini文件也已经添加相关内容

---

但是输出结果为false
求帮助

这样子 也是试过的……

立即学习“PHP免费学习笔记（深入）”；

朋友, 你装memcached 服务了吗?

得有个服务才能连接使用, 就像mysql需要一个mysql服务器

没有的话, 使用File速度也还可以的

确认下有没有配置 S 函数使用 memcache，已经 memcache 的地址端口是否正确

看看有没有装memcache服务

memcached python 客户端编写实践

Memcached Python Client

本小菜刚学完 python，想写点小东西练练手，然后看到 memcached 这个东东熟悉了下，感觉自己还能实现一点基本的功能（对于 memcached 这种分布式靠客户端来实现的神器，一些最重要的功能我都是还没有实现的。。。这个。。。），于是写了如下拙劣的代码，请各位大牛拍砖。。。

#!/usr/bin/env python

''''''
This is a fake memcached client.

Overview
========
Cachedog use python native socket APIs to access memcached server. 
It is inspired by python-memcached. This stuff is aim to be familiar
with Python language, for the author is a beginner for python.

Commands
========
Standard Protocol:
	command <key> <flags> <expiration time> <bytes>
	<value>

The "standard protocol stuff" of memcached involves running a command against an "item".
An item consists of:

1. A key (arbitrary string up to 250 bytes in length. No space or newlines for ASCII mode)
2. A 32bit "flag" value
3. An expiration time, in seconds. Can be up to 30 days. After 30 days, is treated as a unix
   timestamp of an exact date.
4. A 64bit "CAS" value, which is kept unique.
5. Arbitrary data

CAS is optional (can be disabled entirely with -C, and there are more fields that internally
make up an item, but these are what your client interacts with.

Full command list can be found here: https://code.google.com/p/memcached/wiki/NewCommands

Usage summary
=============
You must know it... :)

TODO
====
add compress
add log
add multi-servers

Release note
============
0.1.0
Can access ONLY one server
Basic memcached command supported
Can log command history
''''''
import os
import sys
import time
import socket
import logging


# try:
# 	import cPickle as pickle
# except ImportError:
# 	import pickle

#from binascii import crc32

# try:
#     from threading import local
# except ImportError:
#     class local():
#         pass

__author__ = ''xishvai <xishvai@gmail.com>''
__version__ = ''0.1.0''
__license__ = ''Python Software Foundation License''


SERVER_MAX_KEY_LENGTH = 250  # ordinary value
# assume not larger than 1M, you can change it as you need.
SERVER_MAX_VALUE_LENGTH = 1024 * 1024

MAX_DATA_LENGTH = 1024 * 1024

LOCALHOST = ''127.0.0.1''
DEFAULT_PORT = 11211
DEFAULT_ADDRESS = (LOCALHOST, DEFAULT_PORT)


class Noreply:
    pass


class Client:

    def __init__(self, url):
        self.url = url
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.cmdlog = []
        self.cmd = None

        try:
            a_url, a_port = self.url.split('':'')
            addr = (a_url, int(a_port))
            self.sock.connect(addr)
        except socket.error, msg:
            print(''Connecting %s error'' % msg[1])
            sys.exit(1)

    #
    # constants & exception & tools
    #
    _FLAG_INTEGER = 1 << 0
    _FLAG_LONG = 1 << 1
    _FLAG_PICKLE = 1 << 2
    _FLAG_COMPRESS = 1 << 3

    class MemcachedKeyError(Exception):
        pass

    class MemcachedKeyNoneError(MemcachedKeyError):
        pass

    class MemcachedKeyTypeError(MemcachedKeyError):
        pass

    class MemcachedKeyLengthError(MemcachedKeyError):
        pass

    class MemcachedKeyCharacterError(MemcachedKeyError):
        pass

    class MemcachedStringEncodingError(MemcachedKeyError):
        pass

    #
    # Storage Commands: (set,add,replace,append,prepend,cas)
    #
    def set(self, key, value, flags=0, expired=0):
        ''''''
        Most common command. Store this data, possibly overwriting any existing data.
        New items are at the top of the LRU.
        ''''''

        self.cmd = ''%s %s %d %d %d\r\n%s\r\n'' % (
            ''set'', key, flags, expired, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def add(self, key, value, flags=0, expired=0):
        ''''''
        Store this data, only if it does not already exist. New items are at the top of
        the LRU. If an item already exists and an add fails, it promotes the item to the
        front of the LRU anyway.
        ''''''

        self.cmd = ''%s %s %d %d %d\r\n%s\r\n'' % (
            ''add'', key, flags, expired, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def replace(self, key, value, flags=0, expired=0):
        ''''''
        Store this data, but only if the data already exists. Almost never used,
        and exists for protocol completeness (set, add, replace, etc)
        ''''''

        self.cmd = ''%s %s %d %d %d\r\n%s\r\n'' % (
            ''replace'', key, flags, expired, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def append(self, key, value, flags=0, expired=0):
        ''''''
        Add this data after the last byte in an existing item. This does not allow
        you to extend past the item limit. Useful for managing lists.
        ''''''

        self.cmd = ''%s %s %d %d %d\r\n%s\r\n'' % (
            ''append'', key, flags, expired, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def prepend(self, key, value, flsgs=0, expired=0):
    	''''''
    	Same as append, but adding new data before existing data.
    	''''''

        self.cmd = ''%s %s %d %d %d\r\n%s\r\n'' % (
            ''prepend'', key, flags, expired, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def cas(self, key, value, flags=0, expired=0, cas_value=0):
    	''''''
    	Check And Set (or Compare And Swap). An operation that stores data, but only if
    	no one else has updated the data since you read it last. Useful for resolving race
    	conditions on updating cache data.
    	''''''

        self.cmd = ''%s %s %d %d %d %d\r\n%s\r\n'' % (
            ''cas'', key, flags, expired, cas_value, len(value), value)
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    #
    # Retrieval Commands: (get,gets,delete,incr/decr)
    #
    def get(self, key):
        ''''''
        Command for retrieving data. Takes one or more keys and returns all found items.
        ''''''

        self.cmd = ''%s %s\r\n'' % (''get'', key)
        self.cmdlog.append(self.cmd)
        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def gets(self,key):
        ''''''
        An alternative get command for using with CAS. Returns a CAS identifier
        (a unique 64bit number) with the item. Return this value with the cas command.
        If the item''s CAS value has changed since you gets''ed it, it will not be stored.
        ''''''

        self.cmd = ''%s %s\r\n'' % (''gets'', key)
        self.cmdlog.append(self.cmd)
        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data        

    def delete(self, key):
        ''''''Removes an item from the cache, if it exists.''''''

        self.cmd = ''%s %s\r\n'' % (''delete'', key)
        self.cmdlog.append(self.cmd)
        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def incr(self, key):
    	''''''
    	Increment and Decrement. If an item stored is the string representation of a 64bit
    	integer, you may run incr or decr commands to modify that number. You may only incr
    	by positive values, or decr by positive values. They does not accept negative values.

		If a value does not already exist, incr/decr will fail.
    	''''''

        pass

    def decr(self, key):
    	''''''
    	Increment and Decrement. If an item stored is the string representation of a 64bit
    	integer, you may run incr or decr commands to modify that number. You may only incr
    	by positive values, or decr by positive values. They does not accept negative values.

		If a value does not already exist, incr/decr will fail.
    	''''''
        pass

    #
    # Statistics: (stats,stats items,stats slabs,stats sizes,flush_all)
    #
    def stats(self):
        ''''''ye ''ole basic stats command.''''''

        self.cmd = ''%s\r\n'' % ''stats''
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def stats_items(self):
        ''''''Returns some information, broken down by slab, about items stored in memcached.''''''

        self.cmd = ''%s\r\n'' % ''stats items''
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def stats_slabs(self):
        ''''''
        Returns more information, broken down by slab, about items stored in memcached.
        More centered to performance of a slab rather than counts of particular items.
        ''''''

        self.cmd = ''%s\r\n'' % ''stats slabs''
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def stats_sizes(self):
        ''''''
        A special command that shows you how items would be distributed if slabs were broken
        into 32byte buckets instead of your current number of slabs. Useful for determining
        how efficient your slab sizing is.

		WARNING this is a development command. As of 1.4 it is still the only command which
		will lock your memcached instance for some time. If you have many millions of stored
		items, it can become unresponsive for several minutes. Run this at your own risk. It
		is roadmapped to either make this feature optional or at least speed it up.
        ''''''

        self.cmd = ''%s\r\n'' % ''stats sizes''
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def flush_all(self):
    	# flush_all([timeout])
    	# lazy delete
        ''''''
        Invalidate all existing cache items. Optionally takes a parameter, which means to invalidate
        all items after N seconds have passed.

		This command does not pause the server, as it returns immediately. It does not free up or
		flush memory at all, it just causes all items to expire.
        ''''''

        self.cmd = ''%s\r\n'' % ''flush_all''
        self.cmdlog.append(self.cmd)

        self.sock.sendall(self.cmd.encode())
        data = self.sock.recv(MAX_DATA_LENGTH)
        return data

    def stats_reset(self):
    	pass

    # stats cachedump slab_id limit_num

if __name__ == ''__main__'':
    mc = Client(''127.0.0.1:11211'')
    mc.set(''xs'', ''xishvai'')
    mc.set(''yj'', ''yangjun'')
    data = mc.get(''xs'')
    print(''get xs = '', data)

    data1 = mc.get(''yj'')
    print(''get yj = '', data1)

    mc.replace(''yj'', ''youngsmart'')
    print(''get yj = '', mc.get(''yj''))

    mc.add(''xs'', ''xishvai'')  # NOT_STORED
    mc.delete(''yj'')

    mc.get(''yj'')

    mc.flush_all()
    print(''get xs = '', mc.get(''xs''))

    # for s in mc.cmdlog:
    #     print(s, '' '')
    # print(''stats = '', mc.stats())
    # print(''stats items= '', mc.stats_items())
    # print(''stats slabs= '', mc.stats_slabs())
    # print(''stats sizes= '', mc.stats_sizes())

啥也不说了，头上血迹斑斑啊。。。

Memcached 安装/使用(Python操作)

memcached官网 http://memcached.org 简单介绍 Memcached很强大，它可以支持分布式的共享内存缓存，大型站点都用它。对小站点来说，有足够内存的话，使用它也可以得到超赞的效果。 使用目的 由前面的介绍看到，大家使用它都是为了速度，不过我却是为了解决Se

memcached官网 http://memcached.org

简单介绍

Memcached很强大，它可以支持分布式的共享内存缓存，大型站点都用它。对小站点来说，有足够内存的话，使用它也可以得到超赞的效果。

使用目的

由前面的介绍看到，大家使用它都是为了速度，不过我却是为了解决Session在不同浏览器中偶尔丢失的数据。其实也不能怪浏览器啦，主要是我需要一个dict类型的session。

安装

Linux

安装

# Debian/Ubuntu
sudo apt-get install memcached
# Redhat/Fedora/CentOS
sudo yum install memcached

登录后复制

启动Memcached

立即学习“Python免费学习笔记（深入）”；

-d 选项是启动一个守护进程
-m 是分配给Memcache使用的内存数量，单位是MB，默认64MB
-M return error on memory exhausted (rather than removing items)
-u 是运行Memcache的用户，如果当前为root 的话，需要使用此参数指定用户
-l 是监听的服务器IP地址，默认为所有网卡
-p 是设置Memcache的TCP监听的端口，最好是1024以上的端口
-c 选项是最大运行的并发连接数，默认是1024
-P 是设置保存Memcache的pid文件
-f chunk size growth factor (default: 1.25)
-I Override the size of each slab page. Adjusts max item size(1.4.2版本新增)

登录后复制

例子

/usr/local/memcached/bin/memcached -d -m 100 -c 1000 -u root -p 11211

登录后复制

可以启动多个守护进程，但是端口不能重复。 设置开机启动的话可以将上行命令增加到/etc/rc.d/rc.local文件中。

Windows

1. 下载memcache的windows稳定版 http://splinedancer.com/memcached-win32/
2. 解压放某个盘下面，比如在c:\memcached
3. 在终端（也即cmd命令界面）cd到解压目录（这里是c:\memcached），运行 memcached.exe -d install 安装服务
4. 运行memcached.exe -d start，memcached会使用默认的端口(11211)来启动，你可以在任务管理器中看到memcached.exe

Python 操作 Memcached

memcached API地址 http://code.google.com/p/memcached/wiki/Clients

网上流传说Python-API中效率最高的是python-libmemcached，这里居然看到了hongqn（豆瓣首席架构师，后来也得到证实python-libmemcached是豆瓣贡献，看来豆瓣的阳光真的是撒满了Python的各个角落）。

另外还有python-memcached（100%纯Python），python-memcache（据说有内存泄漏问题？），cmemcache（代码多年未更新？）。

不过由于目前需要中效率并没有太高要求，于是选择了使用最多的python-memcached： 安装 python-memcached

sudo easy_install python-memcached

登录后复制

Python操作memcached

import memcache
mc = memcache.Client([''127.0.0.1:11211''],debug=True)
mc.set(''name'',''luo'',60)
print mc.get(''name'')
mc.delete(''name'')

登录后复制

Memcached常用方法

memcache其实是一个map结构，最常用的几个函数：

保存数据

set(key,value,timeout) 把key映射到value，timeout指的是什么时候这个映射失效
add(key,value,timeout)  仅当存储空间中不存在键相同的数据时才保存
replace(key,value,timeout) 仅当存储空间中存在键相同的数据时才保存

登录后复制

获取数据

get(key) 返回key所指向的value
get_multi(key1,key2,key3,key4) 可以非同步地同时取得多个键值， 比循环调用get快数十倍

登录后复制

删除数据

delete(key, timeout) 删除键为key的数据，timeout为时间值，禁止在timeout时间内名为key的键保存新数据（set函数无效）。

登录后复制

原文地址：Memcached 安装/使用(Python操作), 感谢原作者分享。

我们今天的关于Python中使用python-memcache和memcached的好例子？的分享就到这里，谢谢您的阅读，如果想了解更多关于Memcache/Memcached的PHP操作手册（纯手稿版） memcached java memcached官网 redis memcached 比较、memcached - ThinkPHP3.2.3 使用S方法（Memcache）无法正确输出结果、memcached python 客户端编写实践、Memcached 安装/使用(Python操作)的相关信息，可以在本站进行搜索。

最近很多小伙伴都在问classmethod在此代码中做什么？和class在代码中是什么意思这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展(转)python3-staticmethod与classmethod、3D在此HTML中做什么？、c – * 1.0在此代码中做了什么？、django classonlymethod和python classmethod有什么区别？等相关知识，下面开始了哦！

本文目录一览：

• classmethod在此代码中做什么？（class在代码中是什么意思）
• (转)python3-staticmethod与classmethod
• 3D在此HTML中做什么？
• c – * 1.0在此代码中做了什么？
• django classonlymethod和python classmethod有什么区别？

classmethod在此代码中做什么？（class在代码中是什么意思）

在django.utils.tree.py中：

def _new_instance(cls, children=None, connector=None, negated=False):        obj = Node(children, connector, negated)        obj.__class__ = cls        return obj    _new_instance = classmethod(_new_instance)

我不知道classmethod此代码示例中的功能。有人可以解释它的作用和用法吗？

答案1

小编典典

classmethod 是一个装饰器，包装了一个函数，您可以在类或（等效地）其实例上调用结果对象：

>>> class x(object):...   def c1(*args): print ''c1'', args...   c1 = classmethod(c1)...   @classmethod...   def c2(*args): print ''c2'', args... >>> inst = x()>>> x.c1()c1 (<class ''__main__.x''>,)>>> x.c2()c2 (<class ''__main__.x''>,)>>> inst.c1()c1 (<class ''__main__.x''>,)>>> inst.c2()c2 (<class ''__main__.x''>,)

如您所见，无论是直接定义它还是使用装饰器语法定义它，以及在类或实例上调用它，classmethod总是会将该类作为其第一个参数。

classmethod的主要用途之一是定义 替代构造函数 ：

>>> class y(object):...   def __init__(self, astring):...     self.s = astring...   @classmethod...   def fromlist(cls, alist):...     x = cls('''')...     x.s = '',''.join(str(s) for s in alist)...     return x...   def __repr__(self):...     return ''y(%r)'' % self.s...>>> y1 = y(''xx'')>>> y1y(''xx'')>>> y2 = y.fromlist(range(3))>>> y2y(''0,1,2'')

现在，如果您子类化y，则类方法将继续工作，例如：

>>> class k(y):...   def __repr__(self):...     return ''k(%r)'' % self.s.upper()...>>> k1 = k.fromlist([''za'',''bu''])>>> k1k(''ZA,BU'')

(转)python3-staticmethod与classmethod

原文：https://blog.csdn.net/youngbit007/article/details/68957848

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/youngbit007/article/details/68957848
classmethod：类方法
staticmethod：静态方法

在Python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

@classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。

普通对象方法至少需要一个self参数，代表类对象实例

类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。

对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。

静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少

classmethod必须使用类对象作为第一个参数，而staticmethod则可以不传递任何参数。

class Date:

def __init__(self,day=0, month=0, year=0):
self.day=day
self.month = month
self.year = year

@classmethod
def from_string(cls, date_as_string):
day, month, year = map(int,date_as_string.split(''-''))
my_date = cls(day, month, year)
return my_date

@staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split(''-''))
return day <= 31 and month <= 12 and year <= 3999

if __name__ == ''__main__'':
my_date = Date.from_string(''11-09-2012'')
print(my_date.day, my_date.month,my_date.year)
is_date = Date.is_date_valid(''13-13-2012'')
print(is_date)

outputs:
11 9 2012
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
在来看另外的例子，为了验证有子类继承时，子类调用该类方法时，传入的类变量cls是子类，而非父类

class A:
@classmethod
def cm(cls):
print(''类方法cm(cls)调用者：'', cls.__name__)

@staticmethod
def sm():
print(''静态方法sm()被调用'')

class B(A):
pass

A.cm() # 类方法cm(cls)调用者： A
B.cm() # 类方法cm(cls)调用者： B
A.sm() # 静态方法sm()被调用
B.sm() # 静态方法sm()被调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
下面我们来看为什么要用到staticmethod与classmethod。

class Kls:
def __init__(self,data):
self.data = data
def printd(self):
print(self.data)

ik1=Kls(''arun'')
ik2=Kls(''seema'')
ik1.printd()
ik2.printd()

# 如果现在我们想写一些仅仅与类交互而不是和实例交互的方法会怎么样呢? 我们可以在类外面写一个简单的方法来做这些，
# 但是这样做就扩散了类代码的关系到类定义的外面. 如果像下面这样写就会导致以后代码维护的困难:
def get_no_of_instances(cls_obj):
return cls_obj.no_inst
class Kls:
no_inst = 0
def __init__(self):
Kls.no_inst = Kls.no_inst + 1
ik1 = Kls()
ik2 = Kls()
print(get_no_of_instances(Kls)) # 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
应用classmethod

class Kls(object):
no_inst = 0
def __init__(self):
Kls.no_inst = Kls.no_inst + 1
@classmethod
def get_no_of_instance(cls_obj):
return cls_obj.no_inst
ik1 = Kls()
ik2 = Kls()
print(ik1.get_no_of_instance())
print(Kls.get_no_of_instance())
# 2
# 2
1
2
3
4
5
6
7
8
9
10
11
12
13
@staticmethod
经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法

3D在此HTML中做什么？

我正在尝试通过查看其代码来复制我进入gmail的邮件程序。我在多个源代码查看器中看到了很多：

 <td style=3D"border-bottom: 1px dotted rgb(153,157, 147); border-top: 1px solid rgb(28, 140, 78);" width=3D"90">=A0</td> <td style=3D"border-bottom: 1px dotted rgb(153,157, 147); border-top: 1px solid rgb(28, 140, 78);" align=3D"right" width=3D"110">

3D是否是我不知道的某种邮件渲染方式？

答案1

小编典典

这是一种称为“ quoted-printable ”的电子邮件编码系统，该系统允许将非ASCII字符表示为ASCII以便进行电子邮件传输。

在带引号的可打印格式中，任何非标准的电子邮件八位字节均以一个=符号表示，后跟两个十六进制数字，代表该八位字节的值。当然，要=在电子邮件中表示纯=文本，也必须使用带引号的可打印编码来表示：3D是与的ASCII值（61）相对应的十六进制数字。

c – * 1.0在此代码中做了什么？

这是一个用于检查数字是否为素数的代码：

bool IsPrime(int num)
{
    if(num<=1)
        return false;
    if(num==2)
        return true;
    if(num%2==0)
        return false;
    int sRoot = sqrt(num*1.0);
    for(int i=3; i<=sRoot; i+=2)
    {
        if(num%i==0)
            return false;

    }
    return true;
}

表达“num * 1.0”是什么意思？

解决方法

乘以1.0会将num强制为double.您可以使用显式强制转换来执行相同操作.

django classonlymethod和python classmethod有什么区别？

为什么Django需要引入装饰器classonlymethod？为什么它不能重用python classmethod？

关于classmethod在此代码中做什么？和class在代码中是什么意思的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于(转)python3-staticmethod与classmethod、3D在此HTML中做什么？、c – * 1.0在此代码中做了什么？、django classonlymethod和python classmethod有什么区别？的相关知识，请在本站寻找。

本文标签：

• class_method
• code_explanation
• programming_concept
• tutorial_guide