1645157880

# Gradio ML UI Course: Gradio Multiple Inputs Outputs

Gradio Multiple Inputs Outputs | Gradio ML UI Beginners Course

1646789416

## Top 17 Machine Learning Algorithms with Scikit-Learn

### Machine Learning with Scikit-Learn

Scikit-learn is a library in Python that provides many unsupervised and supervised learning algorithms. It’s built upon some of the technology you might already be familiar with, like NumPy, pandas, and Matplotlib.

### The functionality that scikit-learn provides include:

• Regression, including Linear and Logistic Regression
• Classification, including K-Nearest Neighbors
• Clustering, including K-Means and K-Means++
• Model selection
• Preprocessing, including Min-Max Normalization

In this Article I will explain all machine learning algorithms with scikit-learn which you need to learn as a Data Scientist.

Lets start by importing the libraries:

``````%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.linear_model import LinearRegression
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from scipy import stats
import pylab as pl``````

### Estimator

Given a scikit-learn estimator object named model, the following methods are available:

#### Available in all Estimators

model.fit() : fit training data. For supervised learning applications, this accepts two arguments: the data X and the labels y (e.g. model.fit(X, y)). For unsupervised learning applications, this accepts only a single argument, the data X (e.g. model.fit(X)).

#### Available in supervised estimators

model.predict() : given a trained model, predict the label of a new set of data. This method accepts one argument, the new data X_new (e.g. model.predict(X_new)), and returns the learned label for each object in the array.

model.predict_proba() : For classification problems, some estimators also provide this method, which returns the probability that a new observation has each categorical label. In this case, the label with the highest probability is returned by model.predict(). model.score() : for classification or regression problems, most (all?) estimators implement a score method. Scores are between 0 and 1, with a larger score indicating a better fit.

#### Available in unsupervised estimators

model.predict() : predict labels in clustering algorithms. model.transform() : given an unsupervised model, transform new data into the new basis. This also accepts one argument X_new, and returns the new representation of the data based on the unsupervised model. model.fit_transform() : some estimators implement this method, which more efficiently performs a fit and a transform on the same input data.

``````data =  pd.read_csv('Iris.csv')
``print(data.shape)``
``````#Output
(150, 6)``````
``data.info()``
``````#Output
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 6 columns):
#   Column         Non-Null Count  Dtype
---  ------         --------------  -----
0   Id             150 non-null    int64
1   SepalLengthCm  150 non-null    float64
2   SepalWidthCm   150 non-null    float64
3   PetalLengthCm  150 non-null    float64
4   PetalWidthCm   150 non-null    float64
5   Species        150 non-null    object
dtypes: float64(4), int64(1), object(1)
memory usage: 7.2+ KB``````

### Visualization

Some graphical representation of information and data.

``````sns.FacetGrid(data,hue='Species',size=5)\
.map(plt.scatter,'SepalLengthCm','SepalWidthCm')\
``sns.pairplot(data,hue='Species')``

### Prepare Train and Test

scikit-learn provides a helpful function for partitioning data, train_test_split, which splits out your data into a training set and a test set.

Training and test usually is 70% for training and 30% for test

• Training set for fitting the model
• Test set for evaluation only
``````X = data.iloc[:, :-1].values    #   X -> Feature Variables
y = data.iloc[:, -1].values #   y ->  Target
# Splitting the data into Train and Test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)``````

### Algorithm 1 – Linear Regression

It is used to estimate real values (cost of houses, number of calls, total sales etc.) based on continuous variable(s). Here, we establish relationship between independent and dependent variables by fitting a best line. This best fit line is known as regression line and represented by a linear equation **Y= a *X + b.

``````#converting object data type into int data type using labelEncoder for Linear reagration in this case

XL = data.iloc[:, :-1].values    #   X -> Feature Variables
yL = data.iloc[:, -1].values #   y ->  Target

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Y_train= le.fit_transform(yL)

print(Y_train)  # this is Y_train categotical to numerical
``````
``````#Output
[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]``````
``````# This is only for Linear Regretion
X_trainL, X_testL, y_trainL, y_testL = train_test_split(XL, Y_train, test_size = 0.3, random_state = 0)``````
``````from sklearn.linear_model import LinearRegression
modelLR = LinearRegression()
modelLR.fit(X_trainL, y_trainL)
Y_pred = modelLR.predict(X_testL)``````
``````from sklearn import metrics
#calculating the residuals
print('y-intercept             :' , modelLR.intercept_)
print('beta coefficients       :' , modelLR.coef_)
print('Mean Abs Error MAE      :' ,metrics.mean_absolute_error(y_testL,Y_pred))
print('Mean Sqrt Error MSE     :' ,metrics.mean_squared_error(y_testL,Y_pred))
print('Root Mean Sqrt Error RMSE:' ,np.sqrt(metrics.mean_squared_error(y_testL,Y_pred)))
print('r2 value                :' ,metrics.r2_score(y_testL,Y_pred))``````
``````#Output
y-intercept             : -0.024298523519848292
beta coefficients       : [ 0.00680677 -0.10726764 -0.00624275  0.22428158  0.27196685]
Mean Abs Error MAE      : 0.14966835490524963
Mean Sqrt Error MSE     : 0.03255451737969812
Root Mean Sqrt Error RMSE: 0.18042870442282213
r2 value                : 0.9446026069799255``````

### Algorithm 2- Decision Tree

This is one of my favorite algorithm and I use it quite frequently. It is a type of supervised learning algorithm that is mostly used for classification problems. Surprisingly, it works for both categorical and continuous dependent variables.

In this algorithm, we split the population into two or more homogeneous sets. This is done based on most significant attributes/ independent variables to make as distinct groups as possible.

``````# Decision Tree's
from sklearn.tree import DecisionTreeClassifier

Model = DecisionTreeClassifier()

Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       0.95      1.00      0.97        18
Iris-virginica       1.00      0.91      0.95        11

accuracy                           0.98        45
macro avg       0.98      0.97      0.98        45
weighted avg       0.98      0.98      0.98        45

[[16  0  0]
[ 0 18  0]
[ 0  1 10]]
accuracy is 0.9777777777777777``````

## Algorithm 3- RandomForest

Random Forest is a trademark term for an ensemble of decision trees. In Random Forest, we’ve collection of decision trees (so known as “Forest”). To classify a new object based on attributes, each tree gives a classification and we say the tree “votes” for that class. The forest chooses the classification having the most votes (over all the trees in the forest).

``````from sklearn.ensemble import RandomForestClassifier
Model=RandomForestClassifier(max_depth=2)
Model.fit(X_train,y_train)
y_pred=Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test,y_pred))
print(confusion_matrix(y_pred,y_test))
#Accuracy Score
print('accuracy is ',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is  1.0``````

### Algorithm 4- Logistic Regression

Don’t get confused by its name! It is a classification not a regression algorithm. It is used to estimate discrete values ( Binary values like 0/1, yes/no, true/false ) based on given set of independent variable(s).

In simple words, it predicts the probability of occurrence of an event by fitting data to a logic function. Hence, it is also known as logic regression. Since, it predicts the probability, its output values lies between 0 and 1 (as expected).

``````# LogisticRegression
from sklearn.linear_model import LogisticRegression
Model = LogisticRegression()
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is 1.0``````

### Algorithm 5- K Nearest Neighbors

It can be used for both classification and regression problems. However, it is more widely used in classification problems in the industry. K nearest neighbors is a simple algorithm that stores all available cases and classifies new cases by a majority vote of its k neighbors. The case being assigned to the class is most common amongst its K nearest neighbors measured by a distance function.

``````# K-Nearest Neighbours
from sklearn.neighbors import KNeighborsClassifier

Model = KNeighborsClassifier(n_neighbors=8)
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score

print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is 1.0``````

### Algorithm 6- Naive Bayes

It is a classification technique based on Bayes’ theorem with an assumption of independence between predictors. In simple terms, a Naive Bayes classifier assumes that the presence of a particular feature in a class is unrelated to the presence of any other feature.

For example, a fruit may be considered to be an apple if it is red, round, and about 3 inches in diameter. Even if these features depend on each other or upon the existence of the other features, a naive Bayes classifier would consider all of these properties to independently contribute to the probability that this fruit is an apple.

``````# Naive Bayes
from sklearn.naive_bayes import GaussianNB
Model = GaussianNB()
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is 1.0``````

### Algorithm 7- Support Vector Machines

It is a classification method. In this algorithm, we plot each data item as a point in n-dimensional space (where n is number of features you have) with the value of each feature being the value of a particular coordinate.

For example, if we only had two features like Height and Hair length of an individual, we’d first plot these two variables in two dimensional space where each point has two co-ordinates (these co-ordinates are known as Support Vectors)

``````# Support Vector Machine
from sklearn.svm import SVC

Model = SVC()
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score

print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is 1.0``````

### Algorithm 8- Radius Neighbors Classifier

In scikit-learn RadiusNeighborsClassifier is very similar to KNeighborsClassifier with the exception of two parameters. First, in RadiusNeighborsClassifier we need to specify the radius of the fixed area used to determine if an observation is a neighbor using radius.

Unless there is some substantive reason for setting radius to some value, it is best to treat it like any other hyperparameter and tune it during model selection. The second useful parameter is outlier_label, which indicates what label to give an observation that has no observations within the radius – which itself can often be a useful tool for identifying outliers.

``````#Output
from sklearn.neighbors import  RadiusNeighborsClassifier
Model.fit(X_train,y_train)
y_pred=Model.predict(X_test)

#summary of the predictions made by the classifier
print(classification_report(y_test,y_pred))
print(confusion_matrix(y_test,y_pred))

#Accouracy score
print('accuracy is ', accuracy_score(y_test,y_pred))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is  1.0``````

### Algorithm 9- Passive Aggressive Classifier

PA algorithm is a margin based online learning algorithm for binary classification. Unlike PA algorithm, which is a hard-margin based method, PA-I algorithm is a soft margin based method and robuster to noise.

``````from sklearn.linear_model import PassiveAggressiveClassifier
Model = PassiveAggressiveClassifier()
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       0.89      1.00      0.94        16
Iris-versicolor       0.00      0.00      0.00        18
Iris-virginica       0.41      1.00      0.58        11

accuracy                           0.60        45
macro avg       0.43      0.67      0.51        45
weighted avg       0.42      0.60      0.48        45

[[16  0  0]
[ 2  0 16]
[ 0  0 11]]
accuracy is 0.6``````

## Algorithm 10- BernoulliNB

Like MultinomialNB, this classifier is suitable for discrete data. The difference is that while MultinomialNB works with occurrence counts, BernoulliNB is designed for binary/boolean features.

``````# BernoulliNB
from sklearn.naive_bayes import BernoulliNB
Model = BernoulliNB()
Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       0.00      0.00      0.00        16
Iris-versicolor       0.00      0.00      0.00        18
Iris-virginica       0.24      1.00      0.39        11

accuracy                           0.24        45
macro avg       0.08      0.33      0.13        45
weighted avg       0.06      0.24      0.10        45

[[ 0  0 16]
[ 0  0 18]
[ 0  0 11]]
accuracy is 0.24444444444444444``````

### Algorithm 11- ExtraTreeClassifier

ExtraTreesClassifier is an ensemble learning method fundamentally based on decision trees. ExtraTreesClassifier, like RandomForest, randomizes certain decisions and subsets of data to minimize over-learning from the data and overfitting. Let’s look at some ensemble methods ordered from high to low variance, ending in ExtraTreesClassifier.

``````# ExtraTreeClassifier
from sklearn.tree import ExtraTreeClassifier

Model = ExtraTreeClassifier()

Model.fit(X_train, y_train)

y_pred = Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
# Accuracy score
print('accuracy is',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      0.94      0.97        18
Iris-virginica       0.92      1.00      0.96        11

accuracy                           0.98        45
macro avg       0.97      0.98      0.98        45
weighted avg       0.98      0.98      0.98        45

[[16  0  0]
[ 0 17  1]
[ 0  0 11]]
accuracy is 0.9777777777777777``````

### Algorithm 12- Bagging classifier

Bagging classifier is an ensemble meta-estimator that fits base classifiers each on random subsets of the original dataset and then aggregate their individual predictions (either by voting or by averaging) to form a final prediction. Such a meta-estimator can typically be used as a way to reduce the variance of a black-box estimator (e.g., a decision tree), by introducing randomization into its construction procedure and then making an ensemble out of it.

``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       0.95      1.00      0.97        18
Iris-virginica       1.00      0.91      0.95        11

accuracy                           0.98        45
macro avg       0.98      0.97      0.98        45
weighted avg       0.98      0.98      0.98        45

[[16  0  0]
[ 0 18  1]
[ 0  0 10]]
accuracy is  0.9777777777777777``````

### Algorithm 13-AdaBoost classifier

An AdaBoost classifier is a meta-estimator that begins by fitting a classifier on the original dataset and then fits additional copies of the classifier on the same dataset but where the weights of incorrectly classified instances are adjusted such that subsequent classifiers focus more on difficult cases.

``````from sklearn.ensemble import AdaBoostClassifier
Model.fit(X_train,y_train)
y_pred=Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test,y_pred))
print(confusion_matrix(y_pred,y_test))
#Accuracy Score
print('accuracy is ',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       0.95      1.00      0.97        18
Iris-virginica       1.00      0.91      0.95        11

accuracy                           0.98        45
macro avg       0.98      0.97      0.98        45
weighted avg       0.98      0.98      0.98        45

[[16  0  0]
[ 0 18  1]
[ 0  0 10]]
accuracy is  0.9777777777777777``````

### Algorithm 14- Gradient Boosting Classifier

GBM is a boosting algorithm used when we deal with plenty of data to make a prediction with high prediction power. Boosting is actually an ensemble of learning algorithms which combines the prediction of several base estimators in order to improve robustness over a single estimator. It combines multiple weak or average predictors to a build strong predictor.

``````from sklearn.ensemble import GradientBoostingClassifier
Model.fit(X_train,y_train)
y_pred=Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test,y_pred))
print(confusion_matrix(y_pred,y_test))

#Accuracy Score
print('accuracy is ',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       0.95      1.00      0.97        18
Iris-virginica       1.00      0.91      0.95        11

accuracy                           0.98        45
macro avg       0.98      0.97      0.98        45
weighted avg       0.98      0.98      0.98        45

[[16  0  0]
[ 0 18  1]
[ 0  0 10]]
accuracy is  0.9777777777777777``````

### Algorithm 15- Linear Discriminant Analysis

A classifier with a linear decision boundary, generated by fitting class conditional densities to the data and using Bayes’ rule.

The model fits a Gaussian density to each class, assuming that all classes share the same covariance matrix.

The fitted model can also be used to reduce the dimensionality of the input by projecting it to the most discriminative directions.

``````from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
Model=LinearDiscriminantAnalysis()
Model.fit(X_train,y_train)
y_pred=Model.predict(X_test)

# Summary of the predictions made by the classifier
print(classification_report(y_test,y_pred))
print(confusion_matrix(y_pred,y_test))

#Accuracy Score
print('accuracy is ',accuracy_score(y_pred,y_test))``````
``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is  1.0``````

### Algorithm 16- Quadratic Discriminant Analysis

A classifier with a quadratic decision boundary, generated by fitting class conditional densities to the data and using Bayes’ rule.

The model fits a Gaussian density to each class.

``````#Output
precision    recall  f1-score   support

Iris-setosa       1.00      1.00      1.00        16
Iris-versicolor       1.00      1.00      1.00        18
Iris-virginica       1.00      1.00      1.00        11

accuracy                           1.00        45
macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

[[16  0  0]
[ 0 18  0]
[ 0  0 11]]
accuracy is  1.0``````

### Algorithm 17- K- means

It is a type of unsupervised algorithm which solves the clustering problem. Its procedure follows a simple and easy way to classify a given data set through a certain number of clusters (assume k clusters). Data points inside a cluster are homogeneous and heterogeneous to peer groups.

Remember figuring out shapes from ink blots? k means is somewhat similar this activity. You look at the shape and spread to decipher how many different clusters / population are present.

``````x = data.iloc[:, [1, 2, 3, 4]].values

#Finding the optimum number of clusters for k-means classification
from sklearn.cluster import KMeans
wcss = []

for i in range(1, 11):
kmeans = KMeans(n_clusters = i, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0)
kmeans.fit(x)
wcss.append(kmeans.inertia_)

#Plotting the results onto a line graph, allowing us to observe 'The elbow'
plt.plot(range(1, 11), wcss)
plt.title('The elbow method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS') # within cluster sum of squares
plt.show()``````
``````#Applying kmeans to the dataset / Creating the kmeans classifier
kmeans = KMeans(n_clusters = 3, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0)
y_kmeans = kmeans.fit_predict(x)
#Visualising the clusters

plt.scatter(x[y_kmeans == 0, 0], x[y_kmeans == 0, 1], s = 100, c = 'red', label = 'Iris-Setosa')
plt.scatter(x[y_kmeans == 1, 0], x[y_kmeans == 1, 1], s = 100, c = 'blue', label = 'Iris-Versicolour')
plt.scatter(x[y_kmeans == 2, 0], x[y_kmeans == 2, 1], s = 100, c = 'yellow', label = 'Iris-Virginica')

#Plotting the centroids of the clusters
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s = 100, c = 'green', label = 'Centroids',marker='*')

plt.legend()``````

I hope you like this article on All Machine Learning Algorithms.

Original article source at https://thecleverprogrammer.com

#machinelearning #algorithms

1639054860

## Variable de Impresión de Python

Python es un lenguaje versátil y flexible; a menudo hay más de una forma de lograr algo.

En este tutorial, verá algunas de las formas en que puede imprimir una cadena y una variable juntas.

¡Empecemos!

## Cómo usar la `print()`función en Python

Para imprimir cualquier cosa en Python, se utiliza la `print()`función - que es la `print`palabra clave seguida de un conjunto de apertura y cierre de paréntesis, `()`.

``````#how to print a string
print("Hello world")

#how to print an integer
print(7)

#how to print a variable
#to just print the variable on its own include only the name of it

fave_language = "Python"
print(fave_language)

#output

#Hello world
#7
#Python
``````

Si omite los paréntesis, obtendrá un error:

``````print "hello world"

#output after running the code:
#File "/Users/dionysialemonaki/python_articles/demo.py", line 1
#    print "hello world"
#    ^^^^^^^^^^^^^^^^^^^
#SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?
``````

Si escribe su código Python en Visual Studio Code, con la extensión Python , también obtendrá un subrayado y una pista que indican que algo no está del todo bien:

Como se mencionó anteriormente, la declaración de impresión se utiliza para generar todo tipo de información. Esto incluye datos textuales y numéricos, variables y otros tipos de datos.

También puede imprimir texto (o cadenas) combinado con variables, todo en una declaración.

Verá algunas de las diferentes formas de hacer esto en las secciones siguientes.

## Cómo imprimir una variable y una cadena en Python usando la concatenación

Concatenar, según el diccionario, significa enlazar (cosas) juntas en una cadena o serie.

Esto se hace mediante la adición de varias cosas (en este caso la programación - se añaden datos), junto con otros, utilizando el operador de suma Python, `+`.

Tenga en cuenta que la concatenación solo se usa para cadenas, por lo que si la variable que desea concatenar con el resto de las cadenas es de un tipo de datos entero, tendrá que convertirla en una cadena con la `str()`función.

En el siguiente ejemplo, quiero imprimir el valor de una variable junto con algún otro texto.

Agrego las cadenas entre comillas dobles y el nombre de la variable sin rodearlo, usando el operador de suma para encadenarlos todos juntos:

``````fave_language = "Python"

print("I like coding in " + fave_language + " the most")

#output
#I like coding in Python the most
``````

Con la concatenación de cadenas, debe agregar espacios usted mismo, por lo que si en el ejemplo anterior no hubiera incluido ningún espacio entre las comillas, la salida se vería así:

``````fave_language = "Python"

print("I like coding in" + fave_language + "the most")

#output
#I like coding inPythonthe most
``````

Incluso puede agregar los espacios por separado:

``````fave_language = "Python"

print("I like coding in" + " " + fave_language + " "  + "the most")

#output
#I like coding in Python the most
``````

Esta no es la forma más preferida de imprimir cadenas y variables, ya que puede ser propensa a errores y consumir mucho tiempo.

## Cómo imprimir una variable y una cadena en Python separando cada una con una coma

Puede imprimir texto junto a una variable, separados por comas, en una declaración de impresión.

``````first_name = "John"

print("Hello",first_name)

#output
#Hello John
``````

En el ejemplo anterior, primero incluí un texto que quería imprimir entre comillas dobles; en este caso, el texto era la cadena `Hello`.

Después de las comillas de cierre, agregué una coma que separa ese fragmento de texto del valor contenido en el nombre de la variable ( `first_name`en este caso) que luego incluí.

Podría haber agregado más texto siguiendo la variable, así:

``````first_name = "John"

print("Hello",first_name,"good to see you")

#output
#Hello John good to see you
``````

Este método también funciona con más de una variable:

``````first_name = "John"
last_name = "Doe"

print("Hello",first_name,last_name,"good to see you")

#output
Hello John Doe good to see you
``````

Asegúrate de separar todo con una coma.

Entonces, separa el texto de las variables con una coma, pero también las variables de otras variables, como se muestra arriba.

Si no se hubiera agregado la coma entre `first_name`y `last_name`, el código habría arrojado un error:

``````first_name = "John"
last_name = "Doe"

print("Hello",first_name last_name,"good to see you")

#output
#File "/Users/dionysialemonaki/python_articles/demo.py", line 4
#    print("Hello",first_name last_name,"good to see you")
#                 ^^^^^^^^^^^^^^^^^^^^
#SyntaxError: invalid syntax. Perhaps you forgot a comma?
``````

Como puede ver, los mensajes de error de Python son extremadamente útiles y facilitan un poco el proceso de depuración :)

## Cómo imprimir una variable y una cadena en Python usando formato de cadena

Utiliza el formato de cadena al incluir un conjunto de llaves de apertura y cierre `{}`, en el lugar donde desea agregar el valor de una variable.

``````first_name = "John"

print("Hello {}, hope you're well!")
``````

En este ejemplo hay una variable, `first_name`.

Dentro de la declaración impresa hay un conjunto de comillas dobles de apertura y cierre con el texto que debe imprimirse.

Dentro de eso, agregué un conjunto de llaves en el lugar donde quiero agregar el valor de la variable `first_name`.

Si intento ejecutar este código, tendrá el siguiente resultado:

``````#output
#Hello {}, hope you're well!
``````

¡En realidad, no imprime el valor de `first_name`!

Para imprimirlo, necesito agregar el `.format()`método de cadena al final de la cadena, que es inmediatamente después de las comillas de cierre:

``````first_name = "John"

print("Hello {}, hope you're well!".format(first_name))

#output
#Hello John, hope you're well!
``````

Cuando hay más de una variable, usa tantas llaves como la cantidad de variables que desee imprimir:

``````first_name = "John"
last_name = "Doe"

print("Hello {} {}, hope you're well!")
``````

En este ejemplo, he creado dos variables y quiero imprimir ambas, una después de la otra, así que agregué dos juegos de llaves en el lugar donde quiero que se sustituyan las variables.

Ahora, cuando se trata del `.format()`método, importa el orden en el que coloque los nombres de las variables.

Entonces, el valor del nombre de la variable que se agregará primero en el método estará en el lugar de la primera llave, el valor del nombre de la variable que se agregará en segundo lugar estará en el lugar de la segunda llave, y pronto.

Asegúrese de separar los nombres de las variables con comas dentro del método:

``````first_name = "John"
last_name = "Doe"

print("Hello {} {}, hope you're well!".format(first_name,last_name))

#output
#Hello John Doe, hope you're well!
``````

Si hubiera invertido el orden de los nombres dentro del método, la salida se vería diferente:

``````first_name = "John"
last_name = "Doe"

print("Hello {} {}, hope you're well!".format(last_name,first_name))

#output
#Hello Doe John, hope you're well!
``````

## Cómo imprimir una variable y una cadena en Python usando `f-strings`

`f-strings` son una forma mejor, más legible y concisa de lograr el formato de cadena en comparación con el método que vimos en la sección anterior.

La sintaxis es más sencilla y requiere menos trabajo manual.

La sintaxis general para crear un se `f-string`ve así:

``````print(f"I want this text printed to the console!")

#output
#I want this text printed to the console!
``````

Primero incluye el carácter `f`antes de las comillas de apertura y cierre, dentro de la `print()`función.

Para imprimir una variable con una cadena en una línea, vuelva a incluir el carácter `f`en el mismo lugar, justo antes de las comillas.

Luego agrega el texto que desea dentro de las comillas, y en el lugar donde desea agregar el valor de una variable, agrega un conjunto de llaves con el nombre de la variable dentro de ellas:

``````first_name = "John"

print(f"Hello, {first_name}!")

#output
#Hello, John!
``````

Para imprimir más de una variable, agrega otro conjunto de llaves con el nombre de la segunda variable:

``````first_name = "John"
last_name = "Doe"

print(f"Hello, {first_name} {last_name}!")

#output
#Hello, John Doe!
``````

El orden en que coloque los nombres de las variables es importante, así que asegúrese de agregarlos de acuerdo con la salida que desee.

Si hubiera invertido el orden de los nombres, obtendría el siguiente resultado:

``````first_name = "John"
last_name = "Doe"

print(f"Hello, {last_name} {first_name}!")

#output
#Hello, Doe John!
``````

## Conclusión

¡Gracias por leer y llegar hasta el final! Ahora conoce algunas formas diferentes de imprimir cadenas y variables juntas en una línea en Python.

Si desea obtener más información sobre Python, consulte la Certificación Python de freeCodeCamp .

Es adecuado para principiantes, ya que comienza desde los fundamentos y se construye gradualmente hacia conceptos más avanzados. También podrás construir cinco proyectos y poner en práctica todos los nuevos conocimientos que adquieras.

¡Feliz codificación!

https://www.freecodecamp.org/news/python-print-variable-how-to-print-a-string-and-variable/

1641884883

## Como anexar A Uma Lista Ou Matriz Em Python Como Um Profissional

Neste artigo, você aprenderá sobre o `.append()`método em Python. Você também verá como `.append()`difere de outros métodos usados ​​para adicionar elementos a listas.

Vamos começar!

## O que são listas em Python? Uma definição para iniciantes

Uma matriz na programação é uma coleção ordenada de itens e todos os itens precisam ser do mesmo tipo de dados.

No entanto, ao contrário de outras linguagens de programação, os arrays não são uma estrutura de dados embutida no Python. Em vez de arrays tradicionais, o Python usa listas.

Listas são essencialmente arrays dinâmicos e são uma das estruturas de dados mais comuns e poderosas em Python.

Você pode pensar neles como contêineres ordenados. Eles armazenam e organizam tipos semelhantes de dados relacionados juntos.

Os elementos armazenados em uma lista podem ser de qualquer tipo de dados.

Pode haver listas de inteiros (números inteiros), listas de floats (números de ponto flutuante), listas de strings (texto) e listas de qualquer outro tipo de dados interno do Python.

Embora seja possível que as listas contenham apenas itens do mesmo tipo de dados, elas são mais flexíveis do que as matrizes tradicionais. Isso significa que pode haver uma variedade de tipos de dados diferentes dentro da mesma lista.

As listas têm 0 ou mais itens, o que significa que também pode haver listas vazias. Dentro de uma lista também pode haver valores duplicados.

Os valores são separados por uma vírgula e colocados entre colchetes, `[]`.

### Como criar listas em Python

Para criar uma nova lista, primeiro dê um nome à lista. Em seguida, adicione o operador de atribuição ( `=`) e um par de colchetes de abertura e fechamento. Dentro dos colchetes, adicione os valores que você deseja que a lista contenha.

``````#create a new list of names
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#print the list to the console
print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']
``````

### Como as listas são indexadas em Python

As listas mantêm uma ordem para cada item.

Cada item na coleção tem seu próprio número de índice, que você pode usar para acessar o próprio item.

Índices em Python (e em qualquer outra linguagem de programação moderna) começam em 0 e aumentam para cada item da lista.

Por exemplo, a lista criada anteriormente tinha 4 valores:

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]
``````

O primeiro valor na lista, "Jimmy", tem um índice de 0.

O segundo valor na lista, "Timmy", tem um índice de 1.

O terceiro valor na lista, "Kenny", tem um índice de 2.

O quarto valor na lista, "Lenny", tem um índice de 3.

Para acessar um elemento na lista por seu número de índice, primeiro escreva o nome da lista, depois entre colchetes escreva o inteiro do índice do elemento.

Por exemplo, se você quisesse acessar o elemento que tem um índice de 2, você faria:

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

#output
#Kenny
``````

## Listas em Python são mutáveis

Em Python, quando os objetos são mutáveis , significa que seus valores podem ser alterados depois de criados.

As listas são objetos mutáveis, portanto, você pode atualizá-las e alterá-las depois de criadas.

As listas também são dinâmicas, o que significa que podem crescer e diminuir ao longo da vida de um programa.

Os itens podem ser removidos de uma lista existente e novos itens podem ser adicionados a uma lista existente.

Existem métodos internos para adicionar e remover itens de listas.

Por exemplo, para add itens, há as `.append()`, `.insert()`e `.extend()`métodos.

Para remove itens, há as `.remove()`, `.pop()`e `.pop(index)`métodos.

### O que o `.append()`método faz?

O `.append()`método adiciona um elemento adicional ao final de uma lista já existente.

A sintaxe geral se parece com isso:

``````list_name.append(item)
``````

Vamos decompô-lo:

• `list_name` é o nome que você deu à lista.
• `.append()`é o método de lista para adicionar um item ao final de `list_name`.
• `item` é o item individual especificado que você deseja adicionar.

Ao usar `.append()`, a lista original é modificada. Nenhuma nova lista é criada.

Se você quiser adicionar um nome extra à lista criada anteriormente, faça o seguinte:

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']
``````

### Qual é a diferença entre os métodos `.append()`e `.insert()`?

A diferença entre os dois métodos é que `.append()`adiciona um item ao final de uma lista, enquanto `.insert()`insere um item em uma posição especificada na lista.

Como você viu na seção anterior, `.append()`irá adicionar o item que você passar como argumento para a função sempre no final da lista.

Se você não quiser apenas adicionar itens ao final de uma lista, poderá especificar a posição com a qual deseja adicioná-los `.insert()`.

A sintaxe geral fica assim:

``````list_name.insert(position,item)
``````

Vamos decompô-lo:

• `list_name` é o nome da lista.
• `.insert()` é o método de lista para inserir um item em uma lista.
• `position`é o primeiro argumento para o método. É sempre um número inteiro - especificamente é o número de índice da posição onde você deseja que o novo item seja colocado.
• `item`é o segundo argumento para o método. Aqui você especifica o novo item que deseja adicionar à lista.

Por exemplo, digamos que você tenha a seguinte lista de linguagens de programação:

``````programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

#output
#['JavaScript', 'Java', 'C++']
``````

Se você quisesse inserir "Python" no início da lista, como um novo item da lista, você usaria o `.insert()`método e especificaria a posição como `0`. (Lembre-se de que o primeiro valor em uma lista sempre tem um índice de 0.)

``````programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

#output
#['Python', 'JavaScript', 'Java', 'C++']
``````

Se, em vez disso, você quisesse que "JavaScript" fosse o primeiro item da lista e, em seguida, adicionasse "Python" como o novo item, você especificaria a posição como `1`:

``````programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

#output
#['JavaScript', 'Python', 'Java', 'C++']
``````

O `.insert()`método oferece um pouco mais de flexibilidade em comparação com o `.append()`método que apenas adiciona um novo item ao final da lista.

### Qual é a diferença entre os métodos `.append()`e `.extend()`?

E se você quiser adicionar mais de um item a uma lista de uma só vez, em vez de adicioná-los um de cada vez?

Você pode usar o `.append()`método para adicionar mais de um item ao final de uma lista.

Digamos que você tenha uma lista que contém apenas duas linguagens de programação:

``````programming_languages = ["JavaScript", "Java"]

print(programming_languages)

#output
#['JavaScript', 'Java']
``````

Você então deseja adicionar mais dois idiomas, no final dele.

Nesse caso, você passa uma lista contendo os dois novos valores que deseja adicionar, como argumento para `.append()`:

``````programming_languages = ["JavaScript", "Java"]

#add two new items to the end of the list
programming_languages.append(["Python","C++"])

print(programming_languages)

#output
#['JavaScript', 'Java', ['Python', 'C++']]
``````

Se você observar mais de perto a saída acima, `['JavaScript', 'Java', ['Python', 'C++']]`, verá que uma nova lista foi adicionada ao final da lista já existente.

Então, `.append()` adiciona uma lista dentro de uma lista .

Listas são objetos, e quando você usa `.append()`para adicionar outra lista em uma lista, os novos itens serão adicionados como um único objeto (item).

Digamos que você já tenha duas listas, assim:

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]
``````

E se você quiser combinar o conteúdo de ambas as listas em uma, adicionando o conteúdo de `more_names`a `names`?

Quando o `.append()`método é usado para essa finalidade, outra lista é criada dentro de `names`:

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

#add contents of more_names to names
names.append(more_names)

print(names)

#output
#['Jimmy', 'Timmy', ['Kenny', 'Lenny']]
``````

Então, `.append()`adiciona os novos elementos como outra lista, anexando o objeto ao final.

Para realmente concatenar (adicionar) listas e combinar todos os itens de uma lista para outra , você precisa usar o `.extend()`método.

A sintaxe geral fica assim:

``````list_name.extend(iterable/other_list_name)
``````

Vamos decompô-lo:

• `list_name` é o nome de uma das listas.
• `.extend()` é o método para adicionar todo o conteúdo de uma lista a outra.
• `iterable`pode ser qualquer iterável, como outra lista, por exemplo, `another_list_name`. Nesse caso, `another_list_name`é uma lista que será concatenada com `list_name`, e seu conteúdo será adicionado um a um ao final de `list_name`, como itens separados.

Então, tomando o exemplo anterior, quando `.append()`for substituído por `.extend()`, a saída ficará assim:

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']
``````

Quando usamos `.extend()`, a `names`lista foi estendida e seu comprimento aumentado em 2.

A maneira como `.extend()`funciona é que ele pega uma lista (ou outro iterável) como argumento, itera sobre cada elemento e, em seguida, cada elemento no iterável é adicionado à lista.

Há outra diferença entre `.append()`e `.extend()`.

Quando você deseja adicionar uma string, como visto anteriormente, `.append()`adiciona o item inteiro e único ao final da lista:

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']
``````

Se, em `.extend()`vez disso, você adicionasse uma string ao final de uma lista, cada caractere na string seria adicionado como um item individual à lista.

Isso ocorre porque as strings são iteráveis ​​e `.extend()`iteram sobre o argumento iterável passado para ela.

Então, o exemplo acima ficaria assim:

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#pass a string(iterable) to .extend()
names.extend("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']
``````

## Conclusão

Resumindo, o `.append()`método é usado para adicionar um item ao final de uma lista existente, sem criar uma nova lista.

Quando é usado para adicionar uma lista a outra lista, cria uma lista dentro de uma lista.

Se você quiser saber mais sobre Python, confira a Certificação Python do freeCodeCamp . Você começará a aprender de maneira interativa e amigável para iniciantes. Você também construirá cinco projetos no final para colocar em prática o que aprendeu.

#python

1641616950

## Ajouter En Python - Comment Ajouter à Une Liste Ou à Un Tableau

Dans cet article, vous découvrirez la `.append()`méthode en Python. Vous verrez également en quoi `.append()`diffère des autres méthodes utilisées pour ajouter des éléments aux listes.

Commençons!

## Que sont les listes en Python ? Une définition pour les débutants

Un tableau en programmation est une collection ordonnée d'éléments, et tous les éléments doivent être du même type de données.

Cependant, contrairement à d'autres langages de programmation, les tableaux ne sont pas une structure de données intégrée à Python. Au lieu des tableaux traditionnels, Python utilise des listes.

Les listes sont essentiellement des tableaux dynamiques et sont l'une des structures de données les plus courantes et les plus puissantes de Python.

Vous pouvez les considérer comme des conteneurs commandés. Ils stockent et organisent ensemble des données similaires.

Les éléments stockés dans une liste peuvent être de n'importe quel type de données.

Il peut y avoir des listes d'entiers (nombres entiers), des listes de flottants (nombres à virgule flottante), des listes de chaînes (texte) et des listes de tout autre type de données Python intégré.

Bien qu'il soit possible pour les listes de ne contenir que des éléments du même type de données, elles sont plus flexibles que les tableaux traditionnels. Cela signifie qu'il peut y avoir une variété de types de données différents dans la même liste.

Les listes ont 0 ou plusieurs éléments, ce qui signifie qu'il peut également y avoir des listes vides. À l'intérieur d'une liste, il peut également y avoir des valeurs en double.

Les valeurs sont séparées par une virgule et placées entre crochets, `[]`.

### Comment créer des listes en Python

Pour créer une nouvelle liste, donnez d'abord un nom à la liste. Ajoutez ensuite l'opérateur d'affectation ( `=`) et une paire de crochets ouvrants et fermants. A l'intérieur des parenthèses, ajoutez les valeurs que la liste doit contenir.

``````#create a new list of names
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#print the list to the console
print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']
``````

### Comment les listes sont indexées en Python

Les listes maintiennent un ordre pour chaque article.

Chaque élément de la collection a son propre numéro d'index, que vous pouvez utiliser pour accéder à l'élément lui-même.

Les index en Python (et tout autre langage de programmation moderne) commencent à 0 et augmentent pour chaque élément de la liste.

Par exemple, la liste créée précédemment avait 4 valeurs :

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]
``````

La première valeur de la liste, "Jimmy", a un indice de 0.

La deuxième valeur de la liste, "Timmy", a un indice de 1.

La troisième valeur de la liste, "Kenny", a un indice de 2.

La quatrième valeur de la liste, "Lenny", a un indice de 3.

Pour accéder à un élément de la liste par son numéro d'index, écrivez d'abord le nom de la liste, puis entre crochets écrivez l'entier de l'index de l'élément.

Par exemple, si vous vouliez accéder à l'élément qui a un index de 2, vous feriez :

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

#output
#Kenny
``````

## Les listes en Python sont modifiables

En Python, lorsque les objets sont mutables , cela signifie que leurs valeurs peuvent être modifiées une fois qu'ils ont été créés.

Les listes sont des objets modifiables, vous pouvez donc les mettre à jour et les modifier après leur création.

Les listes sont également dynamiques, ce qui signifie qu'elles peuvent augmenter et diminuer tout au long de la vie d'un programme.

Des éléments peuvent être supprimés d'une liste existante et de nouveaux éléments peuvent être ajoutés à une liste existante.

Il existe des méthodes intégrées pour ajouter et supprimer des éléments des listes.

Par exemple, pour add articles, il y a les `.append()`, `.insert()`et les `.extend()`méthodes.

Pour supprimer des éléments, il existe les méthodes `.remove()`, `.pop()`et `.pop(index)`.

### A quoi sert la `.append()`méthode ?

La `.append()`méthode ajoute un élément supplémentaire à la fin d'une liste déjà existante.

La syntaxe générale ressemble à ceci :

``````list_name.append(item)
``````

Décomposons-le :

• `list_name` est le nom que vous avez donné à la liste.
• `.append()`est la méthode de liste pour ajouter un élément à la fin de `list_name`.
• `item` est l'élément individuel spécifié que vous souhaitez ajouter.

Lors de l'utilisation de `.append()`, la liste d'origine est modifiée. Aucune nouvelle liste n'est créée.

Si vous souhaitez ajouter un nom supplémentaire à la liste créée précédemment, procédez comme suit :

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']
``````

### Quelle est la différence entre les méthodes `.append()`et `.insert()`?

La différence entre les deux méthodes est qu'elle `.append()`ajoute un élément à la fin d'une liste, alors qu'elle `.insert()`insère et élément à une position spécifiée dans la liste.

Comme vous l'avez vu dans la section précédente, `.append()`ajoutera l'élément que vous passez comme argument à la fonction toujours à la fin de la liste.

Si vous ne souhaitez pas simplement ajouter des éléments à la fin d'une liste, vous pouvez spécifier la position à laquelle vous souhaitez les ajouter avec `.insert()`.

La syntaxe générale ressemble à ceci :

``````list_name.insert(position,item)
``````

Décomposons-le :

• `list_name` est le nom de la liste.
• `.insert()` est la méthode de liste pour insérer un élément dans une liste.
• `position`est le premier argument de la méthode. C'est toujours un entier - en particulier c'est le numéro d'index de la position où vous voulez que le nouvel élément soit placé.
• `item`est le deuxième argument de la méthode. Ici, vous spécifiez le nouvel élément que vous souhaitez ajouter à la liste.

Par exemple, supposons que vous disposiez de la liste suivante de langages de programmation :

``````programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

#output
#['JavaScript', 'Java', 'C++']
``````

Si vous vouliez insérer "Python" au début de la liste, en tant que nouvel élément de la liste, vous utiliseriez la `.insert()`méthode et spécifieriez la position comme `0`. (Rappelez-vous que la première valeur d'une liste a toujours un indice de 0.)

``````programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

#output
#['Python', 'JavaScript', 'Java', 'C++']
``````

Si vous aviez plutôt voulu que "JavaScript" soit le premier élément de la liste, puis ajoutez "Python" comme nouvel élément, vous spécifieriez la position comme suit`1` :

``````programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

#output
#['JavaScript', 'Python', 'Java', 'C++']
``````

La `.insert()`méthode vous donne un peu plus de flexibilité par rapport à la `.append()`méthode qui ajoute uniquement un nouvel élément à la fin de la liste.

### Quelle est la différence entre les méthodes `.append()`et `.extend()`?

Que faire si vous souhaitez ajouter plusieurs éléments à une liste à la fois, au lieu de les ajouter un à la fois ?

Vous pouvez utiliser la `.append()`méthode pour ajouter plusieurs éléments à la fin d'une liste.

Supposons que vous ayez une liste qui ne contient que deux langages de programmation :

``````programming_languages = ["JavaScript", "Java"]

print(programming_languages)

#output
#['JavaScript', 'Java']
``````

Vous souhaitez ensuite ajouter deux autres langues, à la fin.

Dans ce cas, vous passez une liste contenant les deux nouvelles valeurs que vous souhaitez ajouter, en argument à `.append()`:

``````programming_languages = ["JavaScript", "Java"]

#add two new items to the end of the list
programming_languages.append(["Python","C++"])

print(programming_languages)

#output
#['JavaScript', 'Java', ['Python', 'C++']]
``````

Si vous regardez de plus près la sortie ci-dessus, `['JavaScript', 'Java', ['Python', 'C++']]`vous verrez qu'une nouvelle liste a été ajoutée à la fin de la liste déjà existante.

Donc, `.append()` ajoute une liste à l'intérieur d'une liste .

Les listes sont des objets, et lorsque vous utilisez `.append()`pour ajouter une autre liste dans une liste, les nouveaux éléments seront ajoutés en tant qu'objet unique (élément).

Supposons que vous ayez déjà deux listes, comme ceci :

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]
``````

Et si vous vouliez combiner le contenu des deux listes en une seule, en ajoutant le contenu de `more_names`to `names`?

Lorsque la `.append()`méthode est utilisée à cette fin, une autre liste est créée à l'intérieur de `names`:

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

#add contents of more_names to names
names.append(more_names)

print(names)

#output
#['Jimmy', 'Timmy', ['Kenny', 'Lenny']]
``````

Donc, `.append()`ajoute les nouveaux éléments comme une autre liste, en ajoutant l'objet à la fin.

Pour réellement concaténer (ajouter) des listes et combiner tous les éléments d'une liste à une autre , vous devez utiliser la `.extend()`méthode.

La syntaxe générale ressemble à ceci :

``````list_name.extend(iterable/other_list_name)
``````

Décomposons-le :

• `list_name` est le nom de l'une des listes.
• `.extend()` est la méthode pour ajouter tout le contenu d'une liste à une autre.
• `iterable`peut être n'importe quel itérable tel qu'une autre liste, par exemple, `another_list_name`. Dans ce cas, `another_list_name`est une liste qui sera concaténée avec `list_name`, et son contenu sera ajouté un par un à la fin de `list_name`, en tant qu'éléments séparés.

Ainsi, en reprenant l'exemple précédent, lorsque `.append()`est remplacé par `.extend()`, la sortie ressemblera à ceci :

``````names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']
``````

Lorsque nous avons utilisé `.extend()`, la `names`liste s'est allongée et sa longueur a été augmentée de 2.

La façon dont cela `.extend()`fonctionne est qu'il prend une liste (ou un autre itérable) comme argument, itère sur chaque élément, puis chaque élément de l'itérable est ajouté à la liste.

Il existe une autre différence entre `.append()`et `.extend()`.

Lorsque vous souhaitez ajouter une chaîne, comme vu précédemment, `.append()`ajoutez l'élément entier et unique à la fin de la liste :

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']
``````

Si vous aviez `.extend()`plutôt l' habitude d'ajouter une chaîne à la fin d'une liste, chaque caractère de la chaîne serait ajouté en tant qu'élément individuel à la liste.

C'est parce que les chaînes sont un itérable et `.extend()`qu'elles itèrent sur l'argument itérable qui lui est transmis.

Ainsi, l'exemple ci-dessus ressemblerait à ceci :

``````names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#pass a string(iterable) to .extend()
names.extend("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']
``````

## Conclusion

En résumé, la `.append()`méthode est utilisée pour ajouter un élément à la fin d'une liste existante, sans créer de nouvelle liste.

Lorsqu'il est utilisé pour ajouter une liste à une autre liste, il crée une liste dans une liste.

Si vous souhaitez en savoir plus sur Python, consultez la certification Python de freeCodeCamp . Vous commencerez à apprendre de manière interactive et conviviale pour les débutants. Vous construirez également cinq projets à la fin pour mettre en pratique ce que vous avez appris.

Merci d'avoir lu et bon codage!

1642082760

## Cómo Recortar Una Cadena En Python Usando El Método .strip()

En este artículo, aprenderá cómo recortar una cadena en Python usando el `.strip()`método.

También verá cómo usar los métodos `.lstrip()`y `.rstrip()`, que son las contrapartes de `.strip()`.

¡Empecemos!

## Cómo recortar una cadena en Python

Python tiene tres métodos incorporados para recortar los espacios en blanco iniciales y finales y los caracteres de las cadenas.

• `.strip()`
• `.lstrip()`
• `.rstrip()`

### Cómo eliminar los espacios en blanco iniciales y finales de las cadenas en Python

Cuando el `.strip()`método no tiene argumentos, elimina cualquier espacio en blanco inicial o final de una cadena.

Por lo tanto, si tiene un espacio en blanco al principio y/o al final de una palabra o frase, `.strip()`solo, de forma predeterminada, lo eliminará.

La siguiente variable `greeting`tiene almacenada la cadena "Hola". La cadena tiene espacio tanto a la derecha como a la izquierda.

``````greeting = "     Hello!  "

print(greeting,"How are you?")

#output
#     Hello!   How are you?
``````

Para eliminar ambos, utiliza el `.strip()`método, así:

``````greeting = "     Hello!  "

stripped_greeting = greeting.strip()

print(stripped_greeting,"How are you?")

#output
#Hello! How are you?
``````

También podrías haber usado el `.strip()`método de esta manera:

``````greeting = "     Hello!  "

print(greeting.strip(),"How are you?")

#output
#Hello! How are you?
``````

### Cómo eliminar caracteres iniciales y finales de cadenas en Python

El `.strip()`método toma caracteres opcionales pasados ​​como argumentos.

Los caracteres que agrega como argumentos especifican qué caracteres desea eliminar del principio y el final de la cadena.

A continuación se muestra la sintaxis general para este caso:

``````str.strip(char)
``````

Los caracteres que especifique se encierran entre comillas.

Entonces, por ejemplo, supongamos que tiene la siguiente cadena:

``````greeting = "Hello World?"
``````

Desea eliminar "H" y "?", que están al principio y al final de la cadena, respectivamente.

Para eliminarlos, pasa ambos caracteres como argumentos a `strip()`.

``````greeting = "Hello World?"

stripped_greeting = greeting.strip("H?")

print(stripped_greeting)

#output
#ello World
``````

Observe lo que sucede cuando desea eliminar "W" de "World", que está en el medio y no al principio o al final de la cadena, y lo incluye como argumento:

``````greeting = "Hello World?"

stripped_greeting = greeting.strip("HW?")

print(stripped_greeting)
#ello World
``````

¡No se eliminará! Solo se eliminan los caracteres al principio y al final de dicha cadena.

Dicho esto, mira el siguiente ejemplo.

Digamos que desea eliminar los dos primeros y los dos últimos caracteres de la cadena:

``````phrase = "Hello world?"

stripped_phrase = phrase.strip("Hed?")

print(stripped_phrase)

#output
#llo worl
``````

Se han eliminado los dos primeros caracteres ("Él") y los dos últimos ("d?") de la cadena.

Otra cosa a tener en cuenta es que el argumento no elimina solo la primera instancia del carácter especificado.

Por ejemplo, supongamos que tiene una cadena con algunos puntos al principio y algunos signos de exclamación al final:

``````phrase = ".....Python !!!"
``````

Cuando especifica como argumentos `.`y `!`, se eliminarán todas las instancias de ambos:

``````phrase = ".....Python !!!"

stripped_phrase = phrase.strip(".!")

print(stripped_phrase)

#output
#Python
``````

### Cómo eliminar solo los espacios en blanco y los caracteres iniciales de las cadenas en Python

Para eliminar solo los espacios en blanco y los caracteres iniciales, use `.lstrip()`.

Esto es útil cuando desea eliminar espacios en blanco y caracteres solo desde el comienzo de la cadena.

Un ejemplo de esto sería eliminar el `www.`de un nombre de dominio.

``````domain_name = "www.freecodecamp.org www."

stripped_domain = domain_name.lstrip("w.")

print(stripped_domain)

#output
#freecodecamp.org www.
``````

En este ejemplo, utilicé los caracteres `w`y `.`tanto al principio como al final de la cadena para mostrar cómo `.lstrip()`funciona.

Si lo hubiera usado `.strip(w.)`, tendría el siguiente resultado:

``````freecodecamp.org
``````

Lo mismo ocurre con la eliminación de espacios en blanco.

Tomemos un ejemplo de una sección anterior:

``````greeting = "     Hello!  "

stripped_greeting = greeting.lstrip()

print(stripped_greeting,"How are you?" )

#output
#Hello!   How are you?
``````

Solo el espacio en blanco del comienzo de la cadena se ha eliminado de la salida.

### Cómo eliminar solo los espacios en blanco finales y los caracteres de las cadenas en Python

Para eliminar solo los espacios en blanco y los caracteres finales, utilice el `.rstrip()`método.

Digamos que desea eliminar todos los signos de puntuación solo del final de una cadena.

Harías lo siguiente:

``````enthusiastic_greeting = "!!! Hello !!!!"

less_enthusiastic_greeting = enthusiastic_greeting.rstrip("!")

print(less_enthusiastic_greeting)

#output
#!!! Hello
``````

Lo mismo ocurre con los espacios en blanco.

Tomando nuevamente el ejemplo anterior, esta vez el espacio en blanco se eliminaría solo al final de la salida:

``````greeting = "     Hello!  "

stripped_greeting = greeting.rstrip()

print(stripped_greeting,"How are you?")

#output
#     Hello! How are you?
``````

## Conclusión

¡Y ahí lo tienes! Ahora conoce los conceptos básicos de cómo recortar una cadena en Python.

Para resumir:

• Utilice el `.strip()`método para eliminar los espacios en blanco y los caracteres del principio y el final de una cadena.
• Use el `.lstrip()`método para eliminar espacios en blanco y caracteres solo desde el principio de una cadena.
• Use el `.rstrip()`método para eliminar espacios en blanco y caracteres solo del final de una cadena.