Scikit-learn (sklearn)速通 -【莫凡Python学习笔记】

news/2024/7/9 8:44:15 标签: python, scikit-learn, sklearn

视频教程链接：【莫烦Python】Scikit-learn (sklearn) 优雅地学会机器学习

视频教程代码

scikit-learn官网

莫烦官网学习链接

本人matplotlib、numpy、pandas笔记

1 为什么学习

Scikit learn 也简称 sklearn, 是机器学习领域当中最知名的 python 模块之一.

Sklearn 包含了很多种机器学习的方式:

Classification 分类
Regression 回归
Clustering 非监督分类
Dimensionality reduction 数据降维
Model Selection 模型选择
Preprocessing 数据预处理

我们总能够从这些方法中挑选出一个适合于自己问题的, 然后解决自己的问题

2 安装

  • Python(>=2.6 or >=3.3)
  • Numpy(>=1.6.1)
  • SciPy(>=0.9)
pip install -U scikit-learn
# or conda
conda install scikit-learn

3 如何选择机器学习方法

在这里插入图片描述
从 START 开始，首先看数据的样本是否 >50，小于则需要收集更多的数据。

由图中可以看到算法有四类，分类，回归，聚类，降维。

其中 分类 和 回归 是监督式学习，即每个数据对应一个 label。
聚类 是非监督式学习，即没有 label。
另外一类是 降维，当数据集有很多很多属性的时候，可以通过 降维 算法把属性归纳起来。例如 20 个属性只变成 2 个，注意，这不是挑出 2 个，而是压缩成为 2 个，它们集合了 20 个属性的所有特征，相当于把重要的信息提取的更好，不重要的信息就不要了。

然后看问题属于哪一类问题，是分类还是回归，还是聚类，就选择相应的算法。 当然还要考虑数据的大小，例如 100K 是一个阈值。

可以发现有些方法是既可以作为分类，也可以作为回归，例如 SGD。

4 通用学习模式

Sklearn 把所有机器学习的模式整合统一起来了，学会了一个模式就可以通吃其他不同类型的学习模式。
注：其数据库十分强大，可用作各种练习（包括Tensorflow等）

例如，分类器，

Sklearn 本身就有很多数据库，可以用来练习。 以 Iris 的数据为例，这种花有四个属性，花瓣的长宽，茎的长宽，根据这些属性把花分为三类。

我们要用 分类器 去把四种类型的花分开。
在这里插入图片描述

数据集：Iris plants dataset官网链接

4.1 导入模块

# sklearn.cross_validation 模块已经在 Scikit-learn 0.20 版本中被弃用
# 现使用 sklearn.model_selection 模块中的 train_test_split 函数来进行训练集和测试集的划分
import numpy as np
from sklearn import datasets 
from sklearn.model_selection import train_test_split

4.2 创建数据

加载 iris 的数据，把属性存在 X，类别标签存在 y：

iris = datasets.load_iris()
iris_X = iris.data
iris_y = iris.target

观察一下数据集，X 有四个特征，y 有 0，1，2 三类：

print(iris_X[:2, :])
print(iris_y)

"""
[[ 5.1  3.5  1.4  0.2]
 [ 4.9  3.   1.4  0.2]]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]
 """

把数据集分为训练集和测试集，其中 test_size=0.3，即测试集占总数据的 30%：

X_train, X_test, y_train, y_test = train_test_split(iris_X, iris_y, test_size=0.3)

可以看到分开后的数据集，顺序也被打乱，这样更有利于学习模型：

print(y_train)

"""
[2 1 0 1 0 0 1 1 1 1 0 0 1 2 1 1 1 0 2 2 1 1 1 1 0 2 2 0 2 2 2 2 2 0 1 2 2
 2 2 2 2 0 1 2 2 1 1 1 0 0 1 2 0 1 0 1 0 1 2 2 0 1 2 2 2 1 1 1 1 2 2 2 1 0
 1 1 0 0 0 2 0 1 0 0 1 2 0 2 2 0 0 2 2 2 1 2 0 0 2 1 2 0 0 1 2]
 """

4.3 建立模型－训练－预测

什么是KNN（K近邻算法）？

定义模块方式 KNeighborsClassifier()， 用 fit 来训练 training data，这一步就完成了训练的所有步骤， 后面的 knn 就已经是训练好的模型，可以直接用来 predict 测试集的数据， 对比用模型预测的值与真实的值，可以看到大概模拟出了数据，但是有误差，是不会完全预测正确的

# 创建 KNN 分类器对象，并对训练集进行拟合
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)

# 打印预测结果和真实标签
print(knn.predict(X_test))
print(y_test)

"""
[2 0 0 1 2 2 0 0 0 1 2 2 1 1 2 1 2 1 0 0 0 2 1 2 0 0 0 0 1 0 2 0 0 2 1 0 1
 0 0 1 0 1 2 0 1]
[2 0 0 1 2 1 0 0 0 1 2 2 1 1 2 1 2 1 0 0 0 2 1 2 0 0 0 0 1 0 2 0 0 2 1 0 1
 0 0 1 0 1 2 0 1]
 """

4.4 汇总

# sklearn.cross_validation 模块已经在 Scikit-learn 0.20 版本中被弃用
# 现使用 sklearn.model_selection 模块中的 train_test_split 函数来进行训练集和测试集的划分
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# 加载鸢尾花数据集
iris = datasets.load_iris()
iris_X = iris.data   # 特征矩阵
iris_y = iris.target # 分类标签


##print(iris_X[:2, :])
##print(iris_y)

# 使用 train_test_split 函数将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(iris_X, iris_y, test_size=0.3)  # 返回值是一个长度为 4 的元组

# 输出训练集标签
##print(y_train)

# 创建 KNN 分类器对象，并对训练集进行拟合
knn = KNeighborsClassifier()  # 创建 KNN（K-Nearest Neighbors）分类器对
knn.fit(X_train, y_train)     # 根据 X_train 和 y_train 的对应关系进行拟合，返回新knn

# 打印预测结果和真实标签
print(knn.predict(X_test)) # 使用训练好的 KNN 分类器对测试数据集 X_test 中的样本进行预测，并返回预测结果
print(y_test)

sklearn__164">5 sklearn 强大数据库

5.1 波士顿房价

注： 波士顿数据因道德问题已从系统库中移除，这里改从其他地方获取数据

python">import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

# 获取替代数据集
data_url = "http://lib.stat.cmu.edu/datasets/boston"

raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None) 
# header=None是Pandas中read_csv函数的一个参数选项，用于指示读取的CSV文件是否包含列名
# sep="\s+" 以空格进行分割
# skiprows=22 跳过前22行

data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]
model = LinearRegression()

# 机器学习y与x的关系
model.fit(data, target)

print(model.predict(data[:4, :]))
print(target[:4])

5.2 创建虚拟数据－可视化

下面是创造数据的例子。

用函数来建立 100 个 sample，有一个 feature，和一个 target，这样比较方便可视化。

python">import matplotlib.pyplot as plt
from sklearn import datasets
X, y = datasets.make_regression(n_samples=100, n_features=1, n_targets=1, noise=10) #噪声程度视实际情况而定
plt.scatter(X, y)
plt.show()

在这里插入图片描述

sklearn__204">6 sklearn 常用属性与功能

以 LinearRegressor 为例，导入包、数据和模型

python">from sklearn import datasets
from sklearn.linear_model import LinearRegression

loaded_data = datasets.load_boston()
data_X = loaded_data.data
data_y = loaded_data.target

model = LinearRegression()

6.1 训练和预测

model.fit 和 model.predict 属于 Model 的功能，用于训练模型 和 用训练好的模型预测

python">model.fit(data_X, data_y)

print(model.predict(data_X[:4, :]))

"""
[ 30.00821269  25.0298606   30.5702317   28.60814055]
"""

6.2 参数和分数

model.coef_ 和 model.intercept_ 属于 Model 的属性， 例如对于 LinearRegressor 这个模型，这两个属性分别输出模型的斜率和截距（与y轴的交点）

python">print(model.coef_)
print(model.intercept_)


"""
[ -1.07170557e-01   4.63952195e-02   2.08602395e-02   2.68856140e+00
  -1.77957587e+01   3.80475246e+00   7.51061703e-04  -1.47575880e+00
   3.05655038e-01  -1.23293463e-02  -9.53463555e-01   9.39251272e-03
  -5.25466633e-01]
36.4911032804
"""

model.get_params() 用于获取当前机器学习模型的参数设置

python">print(model.get_params())


"""
{'copy_X': True, 'normalize': False, 'n_jobs': 1, 'fit_intercept': True}
"""

model.score(data_X, data_y) 可对 Model 用 R^2 的方式进行打分，输出精确度。关于 R^2 coefficient of determination 可以查看 wiki

python">print(model.score(data_X, data_y)) # R^2 coefficient of determination

"""
0.740607742865
"""

7 正规化 Normalization

7.1 数据标准化

将范围相差较大的数据压缩到相近的范围中

python">from sklearn import preprocessing #标准化数据模块
import numpy as np

#建立Array
a = np.array([[10, 2.7, 3.6],
              [-100, 5, -2],
              [120, 20, 40]], dtype=np.float64)

#将normalized后的a打印出
print(preprocessing.scale(a))
# [[ 0.         -0.85170713 -0.55138018]
#  [-1.22474487 -0.55187146 -0.852133  ]
#  [ 1.22474487  1.40357859  1.40351318]]

7.2 数据标准化对机器学习成效的影响

加载模块

python"># 标准化数据模块
from sklearn import preprocessing 
import numpy as np

# 将资料分割成train与test的模块
from sklearn.model_selection import train_test_split

# 生成适合做classification资料的模块
from sklearn.datasets.samples_generator import make_classification 

# Support Vector Machine中的Support Vector Classifier
from sklearn.svm import SVC 

# 可视化数据的模块
import matplotlib.pyplot as plt

生成适合做Classification数据

python">#生成具有2种属性的300笔数据
X, y = make_classification(
    n_samples=300, n_features=2,
    n_redundant=0, n_informative=2, 
    random_state=22, n_clusters_per_class=1, 
    scale=100)

#可视化数据
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()

在这里插入图片描述
数据标准化前

标准化前的预测准确率只有0.477777777778

python">X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
clf = SVC()
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
# 0.477777777778

数据标准化后

数据的单位发生了变化, X 数据也被压缩到差不多大小范围
在这里插入图片描述
标准化后的预测准确率提升至0.9

python">X = preprocessing.scale(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
clf = SVC()
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
# 0.9

8 检验神经网络 (Evaluation)

在神经网络的训练当中，神经网络可能会因为各种各样的问题， 出现学习的效率不高， 或者是因为干扰太多, 学到最后并没有很好的学到规律 。而这其中的原因可能是多方面的，可能是数据问题，学习效率 等参数问题

8.1 Training and Test data

为了检验并评价神经网络， 避免和改善这些问题，通常会把收集到的数据分为 训练数据 和 测试数据，一般用于训练的数据可以是所有数据的70%，剩下的30%可以拿来测试学习结果

8.2 误差曲线

对于神经网络的评价基本上是基于30%的测试数据
评价机器学习可以从误差值开始， 随着训练时间的变长，优秀的神经网络能预测到更为精准的答案，预测误差也会越少，到最后能够提升的空间变小，曲线也趋于水平
在这里插入图片描述

8.3 准确度曲线

最好的精度是趋向于100%精确
在神经网络的分类问题中, 100个样本中，有90个样本分类正确，预测精确度就是90%
在回归的问题中，可以引用 R2 分数在测量回归问题的精度，R2给出的最大精度也是100%
所以分类和回归有统一的精度标准
在这里插入图片描述

8.4 正规化

对于测试样本太过依赖，会产生过拟合现象，如下图，红色的是训练误差， 黑色的是测试误差，训练时的误差比测试的误差小
在机器学习中，解决过拟合也有很多方法 ，比如 l1，l2 正规化，dropout 方法
在这里插入图片描述

9 交叉验证

9.1 Model 基础验证法

python">from sklearn.datasets import load_iris # iris数据集
from sklearn.model_selection import train_test_split # 分割数据模块
from sklearn.neighbors import KNeighborsClassifier # K最近邻(kNN，k-NearestNeighbor)分类算法

#加载iris数据集
iris = load_iris()
X = iris.data
y = iris.target

#分割数据并
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=4)

#建立模型
knn = KNeighborsClassifier()

#训练模型
knn.fit(X_train, y_train)

#将准确率打印出
print(knn.score(X_test, y_test))
# 0.973684210526

9.2 Model 交叉验证法(Cross Validation)

python">from sklearn.cross_validation import cross_val_score # K折交叉验证模块

#使用K折交叉验证模块
scores = cross_val_score(knn, X, y, cv=5, scoring='accuracy')

#将5次的预测准确率打印出
print(scores)
# [ 0.96666667  1.          0.93333333  0.96666667  1.        ]

#将5次的预测准确平均率打印出
print(scores.mean())
# 0.973333333333

9.3 以准确率(accuracy)判断

k个邻居

python">import matplotlib.pyplot as plt #可视化模块

#建立测试参数集
k_range = range(1, 31)

k_scores = []

#藉由迭代的方式来计算不同参数对模型的影响，并返回交叉验证后的平均准确率
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, X, y, cv=10, scoring='accuracy')
    k_scores.append(scores.mean())

#可视化数据
plt.plot(k_range, k_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated Accuracy')
plt.show()

在这里插入图片描述
从图中可以得知，选择12~18的k值最好。高过18之后，准确率开始下降则是因为过拟合(Over fitting)的问题

9.4 以均方误差(Mean squared error)

一般来说均方误差(Mean squared error)会用于判断回归(Regression)模型的好坏

python">import matplotlib.pyplot as plt
k_range = range(1, 31)
k_scores = []
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
    loss = -cross_val_score(knn, X, y, cv=10, scoring='mean_squared_error') # 注意加负号
    k_scores.append(loss.mean())

plt.plot(k_range, k_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated MSE')
plt.show()

在这里插入图片描述
由图可以得知，平均方差越低越好，因此选择13~18左右的K值会最好

9.5 Learning curve 检视过拟合

learning_curve()官方API

这个函数主要是用来判断（可视化）模型是否过拟合的

加载对应模块:

python">from sklearn.learning_curve import learning_curve #学习曲线模块
from sklearn.datasets import load_digits #digits数据集
from sklearn.svm import SVC #Support Vector Classifier
import matplotlib.pyplot as plt #可视化模块
import numpy as np

补充说明：

learning_curve()函数: earning_curve(estimator, X, y, cv=None, train_sizes=None, scoring=None)

  • estimator：要评估的模型（例如：SVC()）
  • X：特征数据
  • y：目标数据
  • cv：交叉验证的折数
  • train_sizes：训练集大小的数组（例如：[0.1, 0.25, 0.5, 0.75, 1]），表示按百分比划分的训练集大小
  • scoring：评估指标（例如：‘mean_squared_error’）
  • 返回值：训练集大小、训练集上的损失和交叉验证集上的损失
    train_sizes是一个表示不同训练集大小的数组，由learning_curve()生成，其中每个元素都是相对于总样本数的百分比，例如0.1表示使用10%的样本进行训练
    train_scores是一个数组，表示在不同训练集大小下的训练集得分，即模型在训练集上的表现情况
    test_scores是一个数组，表示在不同训练集大小下的交叉验证集得分，即模型在验证集上的表现情况。

SVC类的主要参数包括以下几个：

  • C：惩罚参数，用于控制分类决策边界的平衡，C越小表示决策边界越平滑
  • kernel：核函数，用于将数据从输入空间映射到另一个特征空间。常用的核函数包括’linear’（线性核函数）、‘poly’（多项式核函数）、‘rbf’（径向基函数）等
  • degree：多项式核函数的阶数，仅当kernel为’poly’时有效
  • gamma：核函数的系数，影响模型的复杂度和拟合效果，值越大模型越复杂
  • coef0：核函数中的独立系数，仅当kernel为’poly’或’rbf’时有效

train_sizes参数可以是以下几种形式之一：

  • 浮点数：表示相对于整个训练集大小的比例。例如，0.1表示使用10%的训练集大小
  • 整数：表示具体的训练集大小。例如，100表示使用100个样本作为训练集
  • 数组：包含了多个浮点数或整数，表示多个具体的训练集大小。例如，[0.1, 0.25, 0.5, 0.75, 1]表示使用10%、25%、50%、75%和100%的训练集大小
python"># 加载digits数据集，其包含的是手写体的数字，从0到9。数据集总共有1797个样本，每个样本由64个特征组成， 分别为其手写体对应的8×8像素表示，每个特征取值0~16

digits = load_digits()
X = digits.data
y = digits.target

# 观察样本由小到大的学习曲线变化, 采用K折交叉验证 cv=10, 选择平均方差检视模型效能 scoring='mean_squared_error', 样本由小到大分成5轮检视学习曲线(10%, 25%, 50%, 75%, 100%):

train_sizes, train_loss, test_loss = learning_curve(
    SVC(gamma=0.001), X, y, cv=10, scoring='mean_squared_error',
    train_sizes=[0.1, 0.25, 0.5, 0.75, 1])  # 参数顺序先后不影响


# 平均每一轮所得到的平均方差(共5轮，分别为样本10%、25%、50%、75%、100%)
train_loss_mean = -np.mean(train_loss, axis=1)  # 单纯用numpy方法求平均值
test_loss_mean = -np.mean(test_loss, axis=1)


# 可视化图形：
plt.plot(train_sizes, train_loss_mean, 'o-', color="r",
         label="Training")
plt.plot(train_sizes, test_loss_mean, 'o-', color="g",
        label="Cross-validation")

plt.xlabel("Training examples")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()

在这里插入图片描述

9.6 validation_curve 检视过拟合

validation_curve()官方API

validation_curve()：这个函数主要是用来查看在参数不同的取值下模型的性能

validation_curve(estimator, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=None)

  • estimator：要使用的机器学习模型对象
  • X：特征数据
  • y：目标变量数据
  • param_name：超参数的名称
  • param_range：超参数的取值范围
  • cv：交叉验证的折数
  • scoring：可选参数，评估指标
  • n_jobs：可选参数，指定并行计算的作业数量
python">from sklearn.learning_curve import validation_curve #validation_curve模块
from sklearn.datasets import load_digits 
from sklearn.svm import SVC 
import matplotlib.pyplot as plt 
import numpy as np

# digits数据集
digits = load_digits()
X = digits.data
y = digits.target

# 建立参数测试集
param_range = np.logspace(-6, -2.3, 5)

# 使用validation_curve快速找出参数对模型的影响
train_loss, test_loss = validation_curve(
    SVC(), X, y, param_name='gamma', param_range=param_range, cv=10, scoring='mean_squared_error')

# 平均每一轮的平均方差
train_loss_mean = -np.mean(train_loss, axis=1)
test_loss_mean = -np.mean(test_loss, axis=1)

# 可视化图形
plt.plot(param_range, train_loss_mean, 'o-', color="r",
         label="Training")
plt.plot(param_range, test_loss_mean, 'o-', color="g",
        label="Cross-validation")

plt.xlabel("gamma")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()

在这里插入图片描述

10 保存模型

10.1 使用 pickle 保存

简单建立与训练一个SVCModel

python">from sklearn import svm
from sklearn import datasets

clf = svm.SVC()
iris = datasets.load_iris()
X, y = iris.data, iris.target
clf.fit(X,y)

用pickle来保存与读取训练好的Model

pickle学习链接

python">import pickle #pickle模块

#保存Model(注:save文件夹要预先建立，否则会报错)
with open('save/clf.pickle', 'wb') as f:
    pickle.dump(clf, f)

#读取Model
with open('save/clf.pickle', 'rb') as f:
    clf2 = pickle.load(f)
    #测试读取后的Model
    print(clf2.predict(X[0:1]))

# [0]

10.2 使用 joblib 保存

joblib是sklearn的外部模块

python">from sklearn.externals import joblib #jbolib模块

#保存Model(注:save文件夹要预先建立，否则会报错)
joblib.dump(clf, 'save/clf.pkl')

#读取Model
clf3 = joblib.load('save/clf.pkl')

#测试读取后的Model
print(clf3.predict(X[0:1]))

# [0]

joblib在使用上比较容易，读取速度也相对pickle快


http://www.niftyadmin.cn/n/5349870.html

相关文章

nginx复现负载均衡案例

nginx复现负载均衡案例

这里是下载好了docker，并显示了下镜像这里是拉到了nginx的镜像这里是把容器起来，-itd是容器关闭后销毁这里是显示起来的容器进入到这个容器里面查看许多命令用不了，应该想办法把docker里的文件夹映射到物理机中 这里是如果访问6666端口那么隧…
阅读更多...
【智能家居】6、语音控制及网络控制代码实现

【智能家居】6、语音控制及网络控制代码实现

一、语音控制 1、指令结构体编写 这个结构体定义了一个命令输入的模型。在这个模型中，包含以下几个部分： cmdName：一个长度为128的字符串，用于存储命令名称。dvicesName：一个长度为128的字符串，用于存储设备名称。cmd：一个长度为32的字符串，用于存储具体的命令。Init：…
阅读更多...
初识Cargo-Rust的包管理器

初识Cargo-Rust的包管理器

Cargo 是Rust的 包管理器。Cargo 会下载您Rust 的包依赖项，编译包，生成可分发的包，并将它们上传到crates.io - Rust 社区的包注册表。 安装的方法 安装 Rust 和 Cargo 获得 Cargo 的最简单方法是使用rustup脚本，获取当前稳定版本…
阅读更多...
Leetcode2376. 统计特殊整数

Leetcode2376. 统计特殊整数

Every day a Leetcode 题目来源：2376. 统计特殊整数 解法1：数位 DP 题解：数位 DP 通用模板，附题单（Python/Java/C/Go） 代码： /** lc appleetcode.cn id2376 langcpp** [2376] 统计特殊整数…
阅读更多...
基于python flask茶叶网站数据大屏设计与实现，可以做期末课程设计或者毕业设计

基于python flask茶叶网站数据大屏设计与实现，可以做期末课程设计或者毕业设计

基于Python的茶叶网站数据大屏设计与实现是一个适合期末课程设计或毕业设计的项目。该项目旨在利用Python技术和数据可视化方法，设计和开发一个针对茶叶行业的数据大屏，用于展示和分析茶叶网站的相关数据。 项目背景 随着互联网的快速发展，越…
阅读更多...
首页热卖推荐商品显示axios异步请求数据动态渲染实现

首页热卖推荐商品显示axios异步请求数据动态渲染实现

flex-wrap属性： 默认情况下，项目都排在一条线（又称“轴线”）上。flex- wrap属性定义，如果一条轴线 排不下，如何换行？ flex-wrap:wrap 该样式用于设置 换行。 .product_name{white-space: nowrap…
阅读更多...
编程语言比较—ruby，python，php比较

编程语言比较—ruby，python，php比较

ruby语言 ruby语言是日本人开发的，在全球范围内广收欢迎的编程语言。这是一种经常被人评价"写代码很快乐"的编程语言，并且很容易学习。 ruby的ruby on rauls框架非常有名，不仅用于网页开发，而且也越来越多用于编程教育…
阅读更多...
node.js Redis SETNX命令实现分布式锁解决超卖/定时任务重复执行问题

node.js Redis SETNX命令实现分布式锁解决超卖/定时任务重复执行问题

Redis SETNX 特性 当然，让我们通过一个简单的例子，使用 Redis CLI（命令行界面）来模拟获取锁和释放锁的过程。 在此示例中，我将使用键“lock:tcaccount_[pk]”和“status:tcaccount_[pk]”分别表示锁定键和状态键。 获…
阅读更多...
最新文章

Copyright @ 2022~2023