在 Python 和 Numpy 中使用奇异值分离 (linalg.svd)

在此 pythonn - Numpy 教程中，我们将了解 Numpy linalg.svd：Python 中的奇异值分解。在数学中，矩阵的奇异值分解 (SVD) 是指将矩阵分解为三个单独的矩阵。它是矩阵特征值分解的更一般化版本。它进一步与极性分解有关。

在 Python 中，使用数值 python 或 numpy 库很容易计算复数或实数矩阵的奇异分解。numpy 库由各种线性代数函数组成，包括用于计算矩阵奇异值分解的函数。

在机器学习模型中，奇异值分解被广泛用于训练模型和神经网络。它有助于提高准确性和减少数据中的噪音。奇异值分解将一个向量转换为另一个向量，而它们不一定具有相同的维度。因此，它使向量空间中的矩阵操作更加容易和高效。它也用于回归分析。

Numpy linalg.svd() 函数的语法

python中计算矩阵奇异值分解的函数属于numpy模块，名为linalg.svd()。

numpy linalg.svd() 的语法如下：

numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)

您可以根据您的要求自定义 true 和 false 布尔值。

该函数的参数如下：

• A->array_like：这是需要计算奇异值分解的矩阵。根据需要，它可以是真实的或复杂的。它的维度应该> = 2。
• full_matrices->boolean value（可选）：如果设置为 true，则给定矩阵的 Hermitian 转置为正方形，如果为 false，则不是。
• compute_uv->boolen value(optional)：决定是否在奇异值分解的基础上计算Hermitian转置。
• hermitian->boolean value（可选）：给定的矩阵被认为是 hermitian（即对称的，具有实数值），这可能提供更有效的计算方法。

该函数根据上述参数返回三种类型的矩阵：

• S->array_like：包含奇异值的向量，按降序排列，维度与原始矩阵相同。
• u->array_like：这是一个可选的解决方案，当 compute_uv 设置为 True 时返回。它是一组具有奇异值的向量。
• v-> array_like：单一数组集仅在 compute_uv 设置为 True 时返回。

当奇异值不同时，它会引发LinALgError 。

设置的先决条件

在深入研究示例之前，请确保您已在本地系统中安装了 numpy 模块。这是使用线性代数函数（如本文中讨论的函数）所必需的。在您的终端中运行以下命令。

pip install numpy

这就是您现在所需要的，让我们看看我们将如何在下一节中实现代码。

要在 Python 中计算奇异值分解 (SVD)，请使用 NumPy 库的 linalg.svd() 函数。它的语法是 numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)，其中 A 是计算 SVD 的矩阵。它返回三个矩阵：S、U 和 V。

示例 1：计算 3×3 矩阵的奇异值分解

在第一个示例中，我们将采用 3X3 矩阵并按以下方式计算其奇异值分解：

#importing the numpy module
import numpy as np
#using the numpy.array() function to create an array
A=np.array([[2,4,6],
       [8,10,12],
       [14,16,18]])
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

输出将是：

the output is=
s(the singular value) =  [3.36962067e+01 2.13673903e+00 8.83684950e-16]
u =  [[-0.21483724  0.88723069  0.40824829]
 [-0.52058739  0.24964395 -0.81649658]
 [-0.82633754 -0.38794278  0.40824829]]
v =  [[-0.47967118 -0.57236779 -0.66506441]
 [-0.77669099 -0.07568647  0.62531805]
 [-0.40824829  0.81649658 -0.40824829]]

示例 1

示例 2：计算随机矩阵的奇异值分解

在这个例子中，我们将使用numpy.random.randint()函数来创建一个随机矩阵。让我们开始吧！

#importing the numpy module
import numpy as np
#using the numpy.array() function to craete an array
A=np.random.randint(5, 200, size=(3,3))
#display the created matrix
print("The input matrix is=",A)
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

输出将如下所示：

The input matrix is= [[ 36  74 101]
 [104 129 185]
 [139 121 112]]
the output is=
s(the singular value) =  [348.32979681  61.03199722  10.12165841]
u =  [[-0.3635535  -0.48363012 -0.79619769]
 [-0.70916514 -0.41054007  0.57318554]
 [-0.60408084  0.77301925 -0.19372034]]
v =  [[-0.49036384 -0.54970618 -0.67628871]
 [ 0.77570499  0.0784348  -0.62620264]
 [ 0.39727203 -0.83166766  0.38794824]]

示例 2

建议：Numpy linalg.eigvalsh：特征值计算指南。

包起来

在本文中，我们探讨了数学中奇异值分解的概念以及如何使用 Python 的 numpy 模块对其进行计算。我们使用 linalg.svd() 函数来计算给定矩阵和随机矩阵的奇异值分解。Numpy 为执行线性代数运算提供了一种高效且易于使用的方法，使其在机器学习、神经网络和回归分析中具有很高的价值。继续探索 numpy 中的其他线性代数函数，以增强您在 Python 中的数学工具集。

文章来源：https: //www.askpython.com

#python  #numpy 

Разделение единственного числа в Python и Numpy (linalg.svd)

В этом руководстве по pythonn — Numpy мы узнаем о Numpy linalg.svd: разложение по единственному значению в Python. В математике разложение матрицы по сингулярным числам (SVD) относится к разложению матрицы на три отдельные матрицы. Это более обобщенная версия разложения матриц по собственным значениям. Это также связано с полярными разложениями.

В Python легко вычислить сингулярное разложение сложной или вещественной матрицы, используя числовой python или библиотеку numpy. Библиотека numpy состоит из различных линейных алгебраических функций, включая функцию для вычисления разложения матрицы по сингулярным числам.

В моделях машинного обучения разложение по сингулярным числам широко используется для обучения моделей и в нейронных сетях. Это помогает повысить точность и уменьшить шум в данных. Разложение по сингулярным значениям преобразует один вектор в другой, при этом они не обязательно имеют одинаковую размерность. Следовательно, это делает матричные операции в векторных пространствах более простыми и эффективными. Он также используется в регрессионном анализе .

Синтаксис функции Numpy linalg.svd()

Функция, которая вычисляет разложение матрицы по сингулярным числам в python, принадлежит модулю numpy с именем linalg.svd() .

Синтаксис numpy linalg.svd() следующий:

numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)

Вы можете настроить истинные и ложные логические значения в соответствии с вашими требованиями.

Параметры функции приведены ниже:

• A->array_like: это требуемая матрица, для которой вычисляется разложение по сингулярным числам. Он может быть реальным или сложным по мере необходимости. Его размер должен быть >= 2.
• full_matrices->boolean value(необязательно): если установлено значение true, то эрмитовское транспонирование данной матрицы является квадратом, если оно false, то это не так.
• calculate_uv->boolen value (необязательно): определяет, следует ли вычислять эрмитову транспонирование в дополнение к разложению по сингулярным значениям.
• hermitian->boolean value(необязательно): Данная матрица считается эрмитовой (то есть симметричной, с действительными значениями), что может обеспечить более эффективный метод вычислений.

Функция возвращает три типа матриц на основе указанных выше параметров:

• S->array_like : вектор, содержащий сингулярные значения в порядке убывания с размерами, такими же, как исходная матрица.
• u->array_like : это необязательное решение, которое возвращается, когда для параметра calculate_uv установлено значение True. Это набор векторов с сингулярными значениями.
• v-> array_like : Набор унитарных массивов возвращается только в том случае, если для параметра calculate_uv установлено значение True.

Он вызывает LinALgError , когда сингулярные значения различаются.

Предварительные условия для настройки

Прежде чем мы углубимся в примеры, убедитесь, что в вашей локальной системе установлен модуль numpy. Это необходимо для использования линейных алгебраических функций, подобных той, что обсуждается в этой статье. Запустите следующую команду в своем терминале.

pip install numpy

Это все, что вам нужно прямо сейчас, давайте посмотрим, как мы будем реализовывать код в следующем разделе.

Чтобы вычислить разложение по сингулярным значениям (SVD) в Python, используйте функцию linalg.svd() из библиотеки NumPy. Его синтаксис таков: numpy.linalg.svd(A, full_matrices=True, calculate_uv=True, hermitian=False), где A — матрица, для которой вычисляется SVD. Он возвращает три матрицы: S, U и V.

Пример 1. Вычисление сингулярного разложения матрицы 3×3

В этом первом примере мы возьмем матрицу 3X3 и вычислим ее разложение по сингулярным числам следующим образом:

#importing the numpy module
import numpy as np
#using the numpy.array() function to create an array
A=np.array([[2,4,6],
       [8,10,12],
       [14,16,18]])
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

Вывод будет:

the output is=
s(the singular value) =  [3.36962067e+01 2.13673903e+00 8.83684950e-16]
u =  [[-0.21483724  0.88723069  0.40824829]
 [-0.52058739  0.24964395 -0.81649658]
 [-0.82633754 -0.38794278  0.40824829]]
v =  [[-0.47967118 -0.57236779 -0.66506441]
 [-0.77669099 -0.07568647  0.62531805]
 [-0.40824829  0.81649658 -0.40824829]]

Пример 1

Пример 2. Вычисление сингулярного разложения случайной матрицы

В этом примере мы будем использовать функцию numpy.random.randint() для создания случайной матрицы. Давайте погрузимся в это!

#importing the numpy module
import numpy as np
#using the numpy.array() function to craete an array
A=np.random.randint(5, 200, size=(3,3))
#display the created matrix
print("The input matrix is=",A)
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

Вывод будет следующим:

The input matrix is= [[ 36  74 101]
 [104 129 185]
 [139 121 112]]
the output is=
s(the singular value) =  [348.32979681  61.03199722  10.12165841]
u =  [[-0.3635535  -0.48363012 -0.79619769]
 [-0.70916514 -0.41054007  0.57318554]
 [-0.60408084  0.77301925 -0.19372034]]
v =  [[-0.49036384 -0.54970618 -0.67628871]
 [ 0.77570499  0.0784348  -0.62620264]
 [ 0.39727203 -0.83166766  0.38794824]]

Пример 2

Предложено: Numpy linalg.eigvalsh: руководство по вычислению собственных значений .

Подведение итогов

В этой статье мы рассмотрели концепцию разложения по сингулярным числам в математике и способы ее вычисления с помощью модуля Python numpy. Мы использовали функцию linalg.svd() для вычисления разложения по сингулярным числам как заданных, так и случайных матриц. Numpy предоставляет эффективный и простой в использовании метод выполнения операций линейной алгебры, что делает его очень ценным для машинного обучения, нейронных сетей и регрессионного анализа. Продолжайте изучать другие линейные алгебраические функции в numpy, чтобы расширить свой набор математических инструментов в Python.

Источник статьи: https://www.askpython.com

#python #numpy 

Usando separação de valor singular em Python e Numpy (linalg.svd)

Neste tutorial pythonn - Numpy, aprenderemos sobre Numpy linalg.svd: Decomposição de valor singular em Python. Em matemática, uma decomposição de valor singular (SVD) de uma matriz refere-se à fatoração de uma matriz em três matrizes separadas. É uma versão mais generalizada de uma decomposição de valores próprios de matrizes. Está ainda relacionado com as decomposições polares.

Em Python, é fácil calcular a decomposição singular de uma matriz complexa ou real usando o python numérico ou a biblioteca numpy. A biblioteca numpy consiste em várias funções algébricas lineares, incluindo uma para calcular a decomposição do valor singular de uma matriz.

Em modelos de aprendizado de máquina , a decomposição de valor singular é amplamente utilizada para treinar modelos e em redes neurais. Ajuda a melhorar a precisão e a reduzir o ruído nos dados. A decomposição em valor singular transforma um vetor em outro sem que eles tenham necessariamente a mesma dimensão. Portanto, torna a manipulação de matrizes em espaços vetoriais mais fácil e eficiente. Também é usado na análise de regressão .

Sintaxe da função Numpy linalg.svd()

A função que calcula a decomposição do valor singular de uma matriz em python pertence ao módulo numpy, chamado linalg.svd() .

A sintaxe do numpy linalg.svd () é a seguinte:

numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)

Você pode personalizar os valores booleanos verdadeiro e falso com base em seus requisitos.

Os parâmetros da função são dados a seguir:

• A->array_like: Esta é a matriz necessária cuja decomposição de valor singular está sendo calculada. Pode ser real ou complexo, conforme necessário. Sua dimensão deve ser >= 2.
• full_matrices->boolean value(opcional): Se definido como true, então a transposta Hermitiana da matriz dada é um quadrado, se for false então não é.
• compute_uv->boolen value(opcional): Determina se a transposição hermitiana deve ser calculada ou não além da decomposição do valor singular.
• hermitian->valor booleano (opcional): A matriz fornecida é considerada hermitiana (ou seja, simétrica, com valores reais), o que pode fornecer um método de cálculo mais eficiente.

A função retorna três tipos de matrizes com base nos parâmetros mencionados acima:

• S->array_like : O vetor contendo os valores singulares na ordem decrescente com as mesmas dimensões da matriz original.
• u->array_like : Esta é uma solução opcional que é retornada quando compute_uv é definido como True. É um conjunto de vetores com valores singulares.
• v-> array_like : Conjunto de arrays unitários retornados apenas quando compute_uv é definido como True.

Gera um LinALgError quando os valores singulares são diversos.

Pré-requisitos para configuração

Antes de mergulharmos nos exemplos, certifique-se de ter o módulo numpy instalado em seu sistema local. Isso é necessário para usar funções algébricas lineares como a discutida neste artigo. Execute o seguinte comando em seu terminal.

pip install numpy

Isso é tudo que você precisa agora, vamos ver como vamos implementar o código na próxima seção.

Para calcular a Decomposição de Valor Singular (SVD) em Python, use a função linalg.svd() da biblioteca NumPy. Sua sintaxe é numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False), onde A é a matriz para a qual SVD está sendo calculado. Ele retorna três matrizes: S, U e V.

Exemplo 1: Calculando a Decomposição de Valor Singular de uma Matriz 3 × 3

Neste primeiro exemplo, pegaremos uma matriz 3X3 e calcularemos sua decomposição de valor singular da seguinte maneira:

#importing the numpy module
import numpy as np
#using the numpy.array() function to create an array
A=np.array([[2,4,6],
       [8,10,12],
       [14,16,18]])
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

A saída será:

the output is=
s(the singular value) =  [3.36962067e+01 2.13673903e+00 8.83684950e-16]
u =  [[-0.21483724  0.88723069  0.40824829]
 [-0.52058739  0.24964395 -0.81649658]
 [-0.82633754 -0.38794278  0.40824829]]
v =  [[-0.47967118 -0.57236779 -0.66506441]
 [-0.77669099 -0.07568647  0.62531805]
 [-0.40824829  0.81649658 -0.40824829]]

Exemplo 1

Exemplo 2: Calculando a Decomposição de Valor Singular de uma Matriz Aleatória

Neste exemplo, usaremos a função numpy.random.randint() para criar uma matriz aleatória. Vamos entrar nisso!

#importing the numpy module
import numpy as np
#using the numpy.array() function to craete an array
A=np.random.randint(5, 200, size=(3,3))
#display the created matrix
print("The input matrix is=",A)
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

A saída será a seguinte:

The input matrix is= [[ 36  74 101]
 [104 129 185]
 [139 121 112]]
the output is=
s(the singular value) =  [348.32979681  61.03199722  10.12165841]
u =  [[-0.3635535  -0.48363012 -0.79619769]
 [-0.70916514 -0.41054007  0.57318554]
 [-0.60408084  0.77301925 -0.19372034]]
v =  [[-0.49036384 -0.54970618 -0.67628871]
 [ 0.77570499  0.0784348  -0.62620264]
 [ 0.39727203 -0.83166766  0.38794824]]

Exemplo 2

Sugerido: Numpy linalg.eigvalsh: um guia para cálculo de valores próprios .

Empacotando

Neste artigo, exploramos o conceito de decomposição de valor singular em matemática e como calculá-la usando o módulo numpy do Python. Usamos a função linalg.svd() para calcular a decomposição de valor singular de matrizes fornecidas e aleatórias. O Numpy fornece um método eficiente e fácil de usar para realizar operações de álgebra linear, tornando-o altamente valioso em aprendizado de máquina, redes neurais e análise de regressão. Continue explorando outras funções algébricas lineares em numpy para aprimorar seu conjunto de ferramentas matemáticas em Python.

Fonte do artigo em: https://www.askpython.com

#python  #numpy 

Sử dụng Phân tách giá trị số ít trong Python và Numpy (linalg.svd)

Trong hướng dẫn pythonn - Numpy này, chúng ta sẽ tìm hiểu về Numpy linalg.svd: Phân tách giá trị số ít trong Python. Trong toán học, phân tích giá trị đơn lẻ (SVD) của ma trận đề cập đến việc phân tích ma trận thành ba ma trận riêng biệt. Nó là một phiên bản tổng quát hơn của phép phân tách giá trị riêng của ma trận. Nó liên quan nhiều hơn đến sự phân hủy cực.

Trong Python, thật dễ dàng để tính toán phép phân tách số ít của một ma trận thực hoặc phức bằng cách sử dụng python số hoặc thư viện numpy. Thư viện numpy bao gồm các hàm đại số tuyến tính khác nhau, bao gồm một hàm để tính toán phân tích giá trị đơn lẻ của ma trận.

Trong các mô hình học máy , phân tách giá trị đơn lẻ được sử dụng rộng rãi để huấn luyện các mô hình và trong các mạng thần kinh. Nó giúp cải thiện độ chính xác và giảm nhiễu trong dữ liệu. Phép phân tích giá trị đơn biến đổi một vectơ thành một vectơ khác mà không nhất thiết chúng phải có cùng chiều. Do đó, nó làm cho thao tác ma trận trong không gian vectơ dễ dàng và hiệu quả hơn. Nó cũng được sử dụng trong phân tích hồi quy .

Cú pháp của hàm Numpy linalg.svd()

Hàm tính toán phân tách giá trị số ít của ma trận trong python thuộc về mô-đun numpy, có tên là linalg.svd() .

Cú pháp của numpy linalg.svd() như sau:

numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)

Bạn có thể tùy chỉnh các giá trị boolean đúng và sai dựa trên yêu cầu của mình.

Các tham số của chức năng được đưa ra dưới đây:

• A->array_like: Đây là ma trận bắt buộc có sự phân tách giá trị đơn lẻ đang được tính toán. Nó có thể là thực hoặc phức tạp theo yêu cầu. Kích thước của nó phải là> = 2.
• full_matrices->boolean value(tùy chọn): Nếu được đặt thành true, thì phép chuyển vị Hermitian của ma trận đã cho là một hình vuông, nếu nó sai thì không.
• toán_uv->giá trị boolen (tùy chọn): Nó xác định liệu phép chuyển vị Hermiti có được tính toán hay không ngoài việc phân tách giá trị số ít.
• hermitian->giá trị boolean (tùy chọn): Ma trận đã cho được coi là hermitian (nghĩa là đối xứng, với các giá trị thực) có thể cung cấp một phương pháp tính toán hiệu quả hơn.

Hàm trả về ba loại ma trận dựa trên các tham số được đề cập ở trên:

• S->array_like : Vectơ chứa các giá trị số ít theo thứ tự giảm dần với kích thước giống như ma trận ban đầu.
• u->array_like : Đây là một giải pháp tùy chọn được trả về khi compute_uv được đặt thành True. Nó là một tập hợp các vectơ có giá trị số ít.
• v->array_like : Tập hợp các mảng đơn vị chỉ được trả về khi compute_uv được đặt thành True.

Nó làm tăng LinALgError khi các giá trị đơn lẻ đa dạng.

Điều kiện tiên quyết để thiết lập

Trước khi chúng tôi đi sâu vào các ví dụ, hãy đảm bảo rằng bạn đã cài đặt mô-đun numpy trong hệ thống cục bộ của mình. Điều này là cần thiết để sử dụng các hàm đại số tuyến tính giống như hàm được thảo luận trong bài viết này. Chạy lệnh sau trong thiết bị đầu cuối của bạn.

pip install numpy

Đó là tất cả những gì bạn cần ngay bây giờ, hãy xem cách chúng tôi sẽ triển khai mã trong phần tiếp theo.

Để tính toán Phân tách giá trị số ít (SVD) trong Python, hãy sử dụng hàm linalg.svd() của thư viện NumPy. Cú pháp của nó là numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False), trong đó A là ma trận mà SVD đang được tính toán. Nó trả về ba ma trận: S, U và V.

Ví dụ 1: Tính toán phân tích giá trị đơn lẻ của ma trận 3 × 3

Trong ví dụ đầu tiên này, chúng ta sẽ lấy một ma trận 3X3 và tính toán phân tích giá trị đơn lẻ của nó theo cách sau:

#importing the numpy module
import numpy as np
#using the numpy.array() function to create an array
A=np.array([[2,4,6],
       [8,10,12],
       [14,16,18]])
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

Đầu ra sẽ là:

the output is=
s(the singular value) =  [3.36962067e+01 2.13673903e+00 8.83684950e-16]
u =  [[-0.21483724  0.88723069  0.40824829]
 [-0.52058739  0.24964395 -0.81649658]
 [-0.82633754 -0.38794278  0.40824829]]
v =  [[-0.47967118 -0.57236779 -0.66506441]
 [-0.77669099 -0.07568647  0.62531805]
 [-0.40824829  0.81649658 -0.40824829]]

ví dụ 1

Ví dụ 2: Tính toán phân tích giá trị đơn lẻ của một ma trận ngẫu nhiên

Trong ví dụ này, chúng ta sẽ sử dụng hàm numpy.random.randint() để tạo một ma trận ngẫu nhiên. Hãy đi vào nó!

#importing the numpy module
import numpy as np
#using the numpy.array() function to craete an array
A=np.random.randint(5, 200, size=(3,3))
#display the created matrix
print("The input matrix is=",A)
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

Đầu ra sẽ như sau:

The input matrix is= [[ 36  74 101]
 [104 129 185]
 [139 121 112]]
the output is=
s(the singular value) =  [348.32979681  61.03199722  10.12165841]
u =  [[-0.3635535  -0.48363012 -0.79619769]
 [-0.70916514 -0.41054007  0.57318554]
 [-0.60408084  0.77301925 -0.19372034]]
v =  [[-0.49036384 -0.54970618 -0.67628871]
 [ 0.77570499  0.0784348  -0.62620264]
 [ 0.39727203 -0.83166766  0.38794824]]

ví dụ 2

Đề xuất: Numpy linalg.eigvalsh: Hướng dẫn tính toán giá trị riêng .

kết thúc

Trong bài viết này, chúng ta đã khám phá khái niệm phân tách giá trị số ít trong toán học và cách tính toán nó bằng cách sử dụng mô-đun numpy của Python. Chúng tôi đã sử dụng hàm linalg.svd() để tính toán phân tách giá trị số ít của cả ma trận đã cho và ma trận ngẫu nhiên. Numpy cung cấp một phương pháp hiệu quả và dễ sử dụng để thực hiện các phép toán đại số tuyến tính, làm cho nó có giá trị cao trong học máy, mạng thần kinh và phân tích hồi quy. Tiếp tục khám phá các hàm đại số tuyến tính khác trong numpy để nâng cao bộ công cụ toán học của bạn trong Python.

Nguồn bài viết tại: https://www.askpython.com

#python #numpy 

Using Singular Value Separation in Python and Numpy (linalg.svd)

In this pythonn - Numpy tutorial we will learn about Numpy linalg.svd: Singular Value Decomposition in Python. In mathematics, a singular value decomposition (SVD) of a matrix refers to the factorization of a matrix into three separate matrices. It is a more generalized version of an eigenvalue decomposition of matrices. It is further related to the polar decompositions.

In Python, it is easy to calculate the singular decomposition of a complex or a real matrix using the numerical python or the numpy library. The numpy library consists of various linear algebraic functions including one for calculating the singular value decomposition of a matrix.

In machine learning models, singular value decomposition is widely used to train models and in neural networks. It helps in improving accuracy and in reducing the noise in data. Singular value decomposition transforms one vector into another without them necessarily having the same dimension. Hence, it makes matrix manipulation in vector spaces easier and efficient. It is also used in regression analysis.

Syntax of Numpy linalg.svd() function

The function that calculates the singular value decomposition of a matrix in python belongs to the numpy module, named linalg.svd() .

The syntax of the numpy linalg.svd () is as follows:

numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False)

You can customize the true and false boolean values based on your requirements.

The parameters of the function are given below:

• A->array_like: This is the required matrix whose singular value decomposition is being calculated. It can be real or complex as required. It’s dimension should be >= 2.
• full_matrices->boolean value(optional): If set to true, then the Hermitian transpose of the given matrix is a square, if it’s false then it isn’t.
• compute_uv->boolen value(optional): It determines whether the Hermitian transpose is to be calculated or not in addition to the singular value decomposition.
• hermitian->boolean value(optional): The given matrix is considered hermitian(that is symmetric, with real values) which might provide a more efficient method for computation.

The function returns three types of matrices based on the parameters mentioned above:

• S->array_like: The vector containing the singular values in the descending order with dimensions same as the original matrix.
• u->array_like: This is an optional solution that is returned when compute_uv is set to True. It is a set of vectors with singular values.
• v-> array_like: Set of unitary arrays only returned when compute_uv is set to True.

It raises a LinALgError when the singular values diverse.

Prerequisites for setup

Before we dive into the examples, make sure you have the numpy module installed in your local system. This is required for using linear algebraic functions like the one discussed in this article. Run the following command in your terminal.

pip install numpy

That’s all you need right now, let’s look at how we will implement the code in the next section.

To calculate Singular Value Decomposition (SVD) in Python, use the NumPy library’s linalg.svd() function. Its syntax is numpy.linalg.svd(A, full_matrices=True, compute_uv=True, hermitian=False), where A is the matrix for which SVD is being calculated. It returns three matrices: S, U, and V.

Example 1: Calculating the Singular Value Decomposition of a 3×3 Matrix

In this first example we will take a 3X3 matrix and compute its singular value decomposition in the following way:

#importing the numpy module
import numpy as np
#using the numpy.array() function to create an array
A=np.array([[2,4,6],
       [8,10,12],
       [14,16,18]])
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

The output will be:

the output is=
s(the singular value) =  [3.36962067e+01 2.13673903e+00 8.83684950e-16]
u =  [[-0.21483724  0.88723069  0.40824829]
 [-0.52058739  0.24964395 -0.81649658]
 [-0.82633754 -0.38794278  0.40824829]]
v =  [[-0.47967118 -0.57236779 -0.66506441]
 [-0.77669099 -0.07568647  0.62531805]
 [-0.40824829  0.81649658 -0.40824829]]

Example 1

Example 2: Calculating the Singular Value Decomposition of a Random Matrix

In this example, we will be using the numpy.random.randint() function to create a random matrix. Let’s get into it!

#importing the numpy module
import numpy as np
#using the numpy.array() function to craete an array
A=np.random.randint(5, 200, size=(3,3))
#display the created matrix
print("The input matrix is=",A)
#calculatin all three matrices for the output
#using the numpy linalg.svd function
u,s,v=np.linalg.svd(A, compute_uv=True)
#displaying the result
print("the output is=")
print('s(the singular value) = ',s)
print('u = ',u)
print('v = ',v)

The output will be as follows:

The input matrix is= [[ 36  74 101]
 [104 129 185]
 [139 121 112]]
the output is=
s(the singular value) =  [348.32979681  61.03199722  10.12165841]
u =  [[-0.3635535  -0.48363012 -0.79619769]
 [-0.70916514 -0.41054007  0.57318554]
 [-0.60408084  0.77301925 -0.19372034]]
v =  [[-0.49036384 -0.54970618 -0.67628871]
 [ 0.77570499  0.0784348  -0.62620264]
 [ 0.39727203 -0.83166766  0.38794824]]

Example 2

Suggested: Numpy linalg.eigvalsh: A Guide to Eigenvalue Computation.

Wrapping Up

In this article, we explored the concept of singular value decomposition in mathematics and how to calculate it using Python’s numpy module. We used the linalg.svd() function to compute the singular value decomposition of both given and random matrices. Numpy provides an efficient and easy-to-use method for performing linear algebra operations, making it highly valuable in machine learning, neural networks, and regression analysis. Keep exploring other linear algebraic functions in numpy to enhance your mathematical toolset in Python.

Article source at: https://www.askpython.com

#python #numpy 

使用 grsync 备份 Ubuntu 系统

作为 Linux 用户，您听说过 rsync 命令行实用程序，该实用程序广泛用于使用不同的命令在 Linux 系统上创建文件备份。但是，还有一个基于 GUI 的工具，它基于名为grsync的 rsync 实用程序。它是一个基于 rsync 的开源轻量级实用程序，允许用户从 Linux 桌面创建系统备份。它的创建是为了简化整个备份系统，并且无需使用复杂的命令即可备份文件和目录。

在本指南中，我们将演示使用grsync备份系统的过程。

如何使用 grsync 备份 Ubuntu 系统

grsync是一个跨平台实用程序，已在 Ubuntu 源代码库中提供。您可以通过运行以下命令从存储库安装此工具：

sudo apt-get install grsync

安装过程完成后，您可以使用下面给出的命令运行该工具，默认界面如下所示：

grsync

您还可以通过在应用程序菜单中搜索从 GUI 启动它：

提供三个不同的选项，基本、高级和额外选项。所有这些选项都是不言自明的，当您将光标悬停在它们上面时，与这些选项相关的信息将出现在您的屏幕上。

要备份系统，您需要在基本选项下输入源路径和目标路径。在这里，我将下载目录的备份创建到视频中。

注意：您可以将硬盘驱动器或 USB 连接到您的 Linux 系统并选择它作为目的地。

在Advanced Options下，为您的备份选择不同的可用选项。

注意：这完全取决于您，您要选择哪个选项。您可以保留它们并使用默认值。

您可以通过单击顶部菜单中的播放按钮来启动备份过程：

该过程完成后，“成功完成”消息将出现在您的屏幕上：

至此，Ubuntu系统备份成功。您可以通过运行 ls 命令查看目标目录中的备份文件：

如何从 Ubuntu 中删除 grsync

如果你想从你的 ubuntu 中删除 grsync，你可以在你的终端中执行以下命令：

sudo apt-get remove grsync

结论

grsync是 rsync 的前端工具，用于备份个人文件和目录。它是 Ubuntu 系统的一个强大的备份应用程序，可以直接从 apt 命令安装。它支持 rsync 的大部分重要功能，并为您的 Linux 桌面提供了一个用户友好的界面。您只需选择源目录和目标目录即可执行备份过程，然后点击播放按钮开始备份。

文章原文出处：https: //linuxhint.com/

#ubuntu #system #using 

Резервное копирование системы Ubuntu с помощью grsync

Как пользователь Linux, вы слышали об утилите командной строки rsync, которая широко используется для создания резервных копий файлов в системе Linux с помощью различных команд. Однако существует также инструмент с графическим интерфейсом, основанный на утилите rsync, которая называется grsync . Это легкая утилита на основе rsync с открытым исходным кодом, которая позволяет пользователям создавать резервную копию системы с рабочего стола Linux. Он был создан для упрощения всей системы резервного копирования и позволяет создавать резервные копии файлов и каталогов без использования сложных команд.

В этом руководстве мы продемонстрируем процедуру резервного копирования системы с помощью grsync .

Как сделать резервную копию системы Ubuntu с помощью grsync

grsync — это кроссплатформенная утилита, которая уже доступна в исходном репозитории Ubuntu. Вы можете установить этот инструмент из репозитория, выполнив следующую команду:

sudo apt-get install grsync

Когда процесс установки будет завершен, вы можете запустить инструмент с помощью приведенной ниже команды, и интерфейс по умолчанию будет выглядеть следующим образом:

grsync

Вы также можете запустить его из графического интерфейса, выполнив поиск в меню приложения:

Доступны три различных варианта: базовый , расширенный и дополнительный . Все эти параметры говорят сами за себя, когда вы наводите на них курсор, информация, связанная с этими параметрами, появляется на вашем экране.

Для резервного копирования системы вам потребуется ввести исходный и конечный пути в основных параметрах. Здесь я создаю резервную копию каталога Download в Videos.

Примечание . Вы можете подключить жесткий диск или USB к вашей системе Linux и выбрать его в качестве места назначения.

В разделе «Дополнительные параметры» выберите различные доступные параметры резервного копирования.

Примечание . Какой вариант вы выберете, зависит только от вас. Вы можете оставить их и использовать по умолчанию.

Вы можете запустить процесс резервного копирования, нажав кнопку Play в верхнем меню:

Когда процесс завершится, на экране появится сообщение « Выполнено успешно »:

На данный момент резервное копирование успешно выполняется в системе Ubuntu. Вы можете просмотреть файлы резервных копий в каталоге назначения, выполнив команду ls:

Как удалить grsync из Ubuntu

Если вы хотите удалить grsync из своей Ubuntu, вы можете выполнить следующую команду в своем терминале:

sudo apt-get remove grsync

Заключение

grsync — это интерфейсный инструмент rsync, который используется для резервного копирования личных файлов и каталогов. Это мощное приложение для резервного копирования для системы Ubuntu, которое можно установить непосредственно из команды apt. Он поддерживает большинство важных функций rsync и предоставляет удобный интерфейс для ваших рабочих столов Linux. Вам просто нужно выбрать исходный и целевой каталог для выполнения процесса резервного копирования, а затем нажать кнопку «Воспроизвести» , чтобы начать резервное копирование.

Оригинальный источник статьи: https://linuxhint.com/

#ubuntu #system #using 

Back Up Ubuntu System Using grsync

As a Linux user, you have heard about the rsync command-line utility that is widely used to create files backup on a Linux system using different commands. However, there is a GUI-based tool as well based on the rsync utility called grsync. It’s an open-source lightweight rsync-based utility that allows users to create a system backup from a Linux desktop. It was created to simplify the entire backup system and has the power to back up files and directories without using complex commands.

In this guide, we will demonstrate the procedure of backing up the system using grsync.

How to Back Up Ubuntu System Using grsync

grsync is a cross-platform utility, which is already available in the Ubuntu source repository. You can install this tool from the repository by running the following command:

sudo apt-get install grsync

When the installation process is finished, you can run the tool with the below-given command and the default interface will look like this:

grsync

You can also launch it from the GUI by searching it in the application menu:

There are three different options available, Basic, Advanced, and Extra options. All these options are self-explanatory, when you hover the cursor over them the information related to these options will appear on your screen.

For backing up the system you will need to enter the source and destination paths under the Basic options. Here I am creating the backup of the Download’s directory into the Videos.

Note: You can connect a hard drive or USB to your Linux system and choose it as a destination.

Under Advanced Options, choose the different available options for your backup.

Note: It’s entirely up to you, which option you are going to pick. You can leave them and go with the default one.

You can start the backup process by clicking the Play button from the top menu:

Once the process is finished, the “Completed successfully” message will appear on your screen:

At this point, the backup is successfully performed on the Ubuntu system. You can view the backup files in the Destination directory by running the ls command:

How to Remove grsync From Ubuntu

If you want to remove grsync from your ubuntu you can execute the following command in your terminal:

sudo apt-get remove grsync

Conclusion

grsync is a front-end tool of rsync that is used to backup personal files and directories. It is a powerful backup application for the Ubuntu system that can be installed directly from the apt command. It supports most of the important features of rsync and provides a user-friendly interface for your Linux desktops. You just need to select the source and destination directory to perform the backup process and then hit the Play button to start the backup.

Original article source at: https://linuxhint.com/

#ubuntu #system #using 

5 cách nối danh sách (concatenate lists) trong Python

Hướng dẫn này chỉ ra 5 cách để nối các danh sách (concatenate lists) trong Python, bao gồm sử dụng +toán tử, *toán tử, phương thức ext(), phương thức append() và khả năng hiểu danh sách. Chúng tôi sẽ thảo luận về phương pháp tốt nhất bạn có thể sử dụng cho trường hợp sử dụng của mình.

Quá trình kết hợp hai hoặc nhiều chuỗi, danh sách hoặc cấu trúc dữ liệu khác thành một thực thể duy nhất được gọi là phép nối trong lập trình.

Phép nối tạo ra một đối tượng mới với tất cả các thành phần của các đối tượng ban đầu, được sắp xếp theo thứ tự nối.

Nối trong ngữ cảnh của chuỗi đề cập đến việc nối một chuỗi với phần cuối của chuỗi khác để tạo chuỗi dài hơn. Chẳng hạn, tạo chuỗi " helloworld " bằng cách nối các từ " hello " và " world " với nhau.

Nối trong ngữ cảnh của danh sách có nghĩa là bạn tạo một danh sách mới kết hợp mọi thành phần từ hai danh sách trở lên. Chẳng hạn, danh sách [1, 2, 3, 4, 5, 6] sẽ được tạo từ việc nối hai danh sách [1, 2, 3] và [4, 5, 6] .

Ghép nối là một thao tác lập trình phổ biến được sử dụng để kết hợp dữ liệu cho nhiều mục đích khác nhau, bao gồm tạo báo cáo, xử lý tập dữ liệu lớn và tạo cấu trúc dữ liệu phức tạp.

Mục lục:

• Danh sách nối trong Python
• Cách nối danh sách bằng +toán tử
• Cách nối danh sách bằng *toán tử
• Cách nối các danh sách bằng cách hiểu danh sách
• Cách nối danh sách bằng append()phương thức trong vòng lặp
• Cách nối danh sách bằng extend()phương pháp
• Vì vậy, khi nào bạn nên sử dụng từng phương pháp?
• Phần kết luận

Danh sách nối trong Python

Nối các danh sách là một thao tác phổ biến trong lập trình Python. Trong nhiều trường hợp, bạn có thể cần hợp nhất hai hoặc nhiều danh sách thành một danh sách để thực hiện một số thao tác trên dữ liệu được kết hợp.

Python cung cấp nhiều phương thức để nối danh sách, từ các hàm tích hợp đơn giản đến các phương thức phức tạp hơn liên quan đến việc hiểu và cắt danh sách.

Trong bài viết này, chúng ta sẽ xem xét các kỹ thuật nối Python khác nhau. Khi đọc xong, bạn sẽ biết chính xác cách nối các danh sách trong Python và có thể chọn phương pháp phù hợp nhất cho trường hợp sử dụng cụ thể của mình.

Cách nối danh sách bằng +toán tử

Kỹ thuật đầu tiên và đơn giản nhất để nối hai danh sách là sử dụng   +toán tử. Nó tạo một danh sách mới bằng cách nối hai danh sách lại với nhau.

Ví dụ:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

Đầu ra:

[1, 2, 3, 4, 5, 6]

Cách nối danh sách bằng *toán tử

Bạn có thể sử dụng *toán tử để lặp lại danh sách một số lần nhất định. Bằng cách lặp lại một danh sách và nối nó với chính nó, chúng ta có thể nối nhiều bản sao của một danh sách.

Ví dụ:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

Đầu ra:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Cách nối các danh sách bằng cách hiểu danh sách

Hiểu danh sách là một cách ngắn gọn và dễ đọc để tạo một danh sách mới trong Python bằng cách lặp qua một đối tượng có thể lặp lại hiện có (như danh sách , tuple , chuỗi , v.v.) và áp dụng một phép biến đổi hoặc bộ lọc cho từng phần tử trong có thể lặp lại.

Cú pháp hiểu danh sách:

new_list = [expression for item in iterable if condition]

Ở đây, expressionlà hoạt động hoặc chức năng để áp dụng cho từng phần tử trong iterable, itemlà một biến lần lượt đảm nhận từng phần tử của iterable, iterablelà đối tượng iterable ban đầu và conditionlà một điều kiện tùy chọn để lọc những phần tử nào sẽ đưa vào phần tử mới. danh sách.

Bạn có thể sử dụng khả năng hiểu danh sách để nối nhiều danh sách thành một danh sách. Hãy xem xét một ví dụ.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

Đầu ra:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Cách nối danh sách bằng append()phương thức trong vòng lặp

Một phần tử có thể được thêm vào cuối danh sách hiện có trong Python bằng cách sử dụng phương append()thức, đây là hàm tích hợp sẵn của danh sách.

Cú pháp để sử dụng append()là:

list_name.append(element)

Từ mã, list_namelà tên của danh sách mà bạn muốn thêm một phần tử và elementlà giá trị mà bạn muốn thêm vào danh sách.

Bạn có thể sử dụng append()phương thức bên trong vòng lặp để nối các phần tử của danh sách này với danh sách khác.

Ví dụ:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

Đầu ra:

[1, 2, 3, 4, 5, 6]

Cách nối danh sách bằng extend()phương pháp

Bằng cách nối một danh sách hiện có với một đối tượng có thể lặp lại khác, extend()phương thức danh sách trong Python cho phép bạn thêm nhiều phần tử vào danh sách hiện có.

Cú pháp extend()cho như sau:

list_name.extend(iterable)

Ở đây, iterablelà bất kỳ đối tượng có thể lặp lại nào (chẳng hạn như list , tuple , string , v.v.) chứa các phần tử bạn muốn thêm vào danh sách và list_namelà tên của danh sách mà bạn muốn thêm phần tử vào.

Bạn có thể sử dụng extend()phương thức này để nối tất cả các phần tử của một danh sách vào cuối danh sách ban đầu.

Ví dụ:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Đầu ra:

[1, 2, 3, 4, 5, 6]

Vì vậy, khi nào bạn nên sử dụng từng phương pháp?

Sử dụng *toán tử : Bạn có thể sử dụng *toán tử trong nối danh sách khi bạn muốn lặp lại danh sách một số lần nhất định hoặc để tạo danh sách mới bằng cách lặp lại các phần tử của danh sách ban đầu theo một giá trị vô hướng.

Sử dụng +toán tử : Phương pháp này đơn giản và dễ đọc nhưng có thể không hiệu quả khi xử lý các danh sách lớn vì nó tạo ra một danh sách mới mỗi khi sử dụng.

Sử dụng append()phương thức : append()Phương thức trong Python thêm một phần tử vào cuối danh sách. Bạn thường không sử dụng nó để nối danh sách, mà là để thêm các phần tử riêng lẻ vào danh sách hiện có.

Sử dụng extend()phương thức : Phương pháp này liên quan đến việc sử dụng extend()phương thức để thêm các phần tử của một danh sách vào cuối danh sách khác. Phương thức này extend()sửa đổi danh sách ban đầu thay vì tạo danh sách mới, làm cho nó hiệu quả hơn về bộ nhớ so với toán tử +. Tuy nhiên, nó vẫn có thể chậm hơn so với phương pháp hiểu danh sách đối với các danh sách rất lớn.

Phần kết luận

Trong bài viết này, chúng ta đã khám phá các cách khác nhau để nối danh sách trong Python, bao gồm sử dụng toán +tử, *toán tử, extend()phương thức, append()phương thức và hiểu danh sách. Chúng tôi cũng đã thảo luận về phương pháp tốt nhất mà bạn có thể sử dụng cho trường hợp sử dụng của mình.

Mã hóa vui vẻ!

Nguồn: https://www.freecodecamp.org

#python

5 maneiras de concatenar listas em Python

Este tutorial mostra 5 maneiras de concatenar listas em Python, incluindo o uso do +operador, o *operador, o método extend(), o método append() e a compreensão de lista. Discutiremos o melhor método que você pode usar para o seu caso de uso.

O processo de combinar duas ou mais strings, listas ou outras estruturas de dados em uma única entidade é conhecido como concatenação na programação.

A concatenação produz um novo objeto com todos os componentes dos objetos originais, organizados na ordem de concatenação.

A concatenação no contexto de strings refere-se à junção de uma string ao final de outra string para criar uma string mais longa. Por exemplo, criar a string " helloworld " juntando as palavras " hello " e " world " .

A concatenação no contexto de listas significa que você cria uma nova lista que incorpora todos os elementos de duas ou mais listas. Por exemplo, a lista [1, 2, 3, 4, 5, 6] seria criada a partir da concatenação das duas listas [1, 2, 3] e [4, 5, 6] .

A concatenação é uma operação de programação comum usada para combinar dados para diversas finalidades, incluindo a criação de relatórios, manipulação de grandes conjuntos de dados e criação de estruturas de dados intrincadas.

Índice:

• Listar concatenação em Python
• Como concatenar listas usando o +operador
• Como concatenar listas usando o *operador
• Como concatenar listas usando a compreensão de lista
• Como concatenar listas usando o append()método em um loop
• Como concatenar listas usando o extend()método
• Então, quando você deve usar cada método?
• Conclusão

Listar concatenação em Python

A concatenação de listas é uma operação comum na programação Python. Em muitas situações, pode ser necessário mesclar duas ou mais listas em uma única lista para executar algumas operações nos dados combinados.

Python oferece uma variedade de métodos para concatenar listas, desde funções integradas diretas até métodos mais sofisticados envolvendo compreensão e divisão de listas.

Neste artigo, veremos várias técnicas de concatenação do Python. Quando terminar de ler, você saberá exatamente como concatenar listas em Python e será capaz de selecionar a abordagem que funciona melhor para seu caso de uso específico.

Como concatenar listas usando o +operador

A primeira e mais simples técnica para concatenar duas listas é usar o   +operador. Ele cria uma nova lista concatenando as duas listas.

Exemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

Saída:

[1, 2, 3, 4, 5, 6]

Como concatenar listas usando o *operador

Você pode usar o *operador para repetir uma lista um determinado número de vezes. Repetindo uma lista e concatenando-a consigo mesma, podemos obter a concatenação de várias cópias de uma lista.

Exemplo:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

Saída:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Como concatenar listas usando a compreensão de lista

A compreensão de lista é uma maneira concisa e legível de criar uma nova lista em Python iterando sobre um objeto iterável existente (como uma lista , tupla , string , etc.) e aplicando uma transformação ou filtro a cada elemento no iterável.

Sintaxe de compreensão da lista:

new_list = [expression for item in iterable if condition]

Aqui, expressioné a operação ou função a ser aplicada a cada elemento no iterável, itemé uma variável que assume cada elemento do iterável por vez, iterableé o objeto iterável original e conditioné uma condição opcional que filtra quais elementos incluir no novo lista.

Você pode usar a compreensão de lista para concatenar várias listas em uma única lista. Vamos dar uma olhada em um exemplo.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

Saída:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Como concatenar listas usando o append()método em um loop

Um elemento pode ser adicionado ao final de uma lista existente em Python usando o append()método, que é uma função interna de listas.

A sintaxe para usar append()é:

list_name.append(element)

No código, list_nameé o nome da lista à qual você deseja adicionar um elemento e elementé o valor que deseja adicionar à lista.

Você pode usar o append()método dentro de um loop para anexar os elementos de uma lista a outra.

Exemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

Saída:

[1, 2, 3, 4, 5, 6]

Como concatenar listas usando o extend()método

Ao concatenar uma lista existente com outro objeto iterável, o extend()método de listas em Python permite adicionar vários elementos a uma lista existente.

A sintaxe para extend()é a seguinte:

list_name.extend(iterable)

Aqui, iterableé qualquer objeto iterável (como uma lista , tupla , string , etc.) que contém os elementos que você deseja adicionar à lista e list_nameé o nome da lista à qual deseja adicionar elementos.

Você pode usar o extend()método para anexar todos os elementos de uma lista ao final da lista original.

Exemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Saída:

[1, 2, 3, 4, 5, 6]

Então, quando você deve usar cada método?

Usando o *operador : Você pode usar o *operador na concatenação de listas quando quiser repetir uma lista um determinado número de vezes ou criar uma nova lista repetindo os elementos da lista original por um valor escalar.

Usando o +operador : Este método é simples e fácil de ler, mas pode ser ineficiente ao lidar com listas grandes, pois cria uma nova lista toda vez que é usado.

Usando o append()método : O append()método em Python adiciona um elemento ao final de uma lista. Você normalmente não o usa para concatenação de lista, mas sim para adicionar elementos individuais a uma lista existente.

Usando o extend()método : Este método envolve o uso do extend()método para adicionar elementos de uma lista ao final de outra lista. O extend()método modifica a lista original em vez de criar uma nova lista, tornando-a mais eficiente em termos de memória do que o operador +. Mas ainda pode ser mais lento do que o método de compreensão de lista para listas muito grandes.

Conclusão

Neste artigo, exploramos diferentes maneiras de concatenar listas em Python, incluindo o uso do +operador, o *operador, o extend()método, o append()método e a compreensão da lista. Também discutimos o melhor método que você pode usar para o seu caso de uso.

Codificação feliz!

Fonte: https://www.freecodecamp.org

#python

Python에서 목록을 연결하는 5가지 방법

+이 튜토리얼은 연산자, *연산자, extend() 메서드, append() 메서드 및 목록 내포를 사용하는 것을 포함하여 Python에서 목록을 연결하는 5가지 방법을 보여줍니다 . 사용 사례에 사용할 수 있는 최상의 방법에 대해 논의할 것입니다.

둘 이상의 문자열, 목록 또는 기타 데이터 구조를 단일 엔터티로 결합하는 프로세스를 프로그래밍에서 연결이라고 합니다.

연결은 연결 순서로 정렬된 원래 개체의 모든 구성 요소가 포함된 새 개체를 생성합니다.

문자열 컨텍스트에서 연결이란 하나의 문자열을 다른 문자열의 끝에 연결하여 더 긴 문자열을 만드는 것을 말합니다. 예를 들어, " hello "와 " world " 라는 단어를 결합하여 문자열 " helloworld "를 생성합니다 .

목록 컨텍스트에서 연결이란 두 개 이상의 목록에서 모든 요소를 ​​통합하는 새 목록을 만드는 것을 의미합니다. 예를 들어, 목록 [1, 2, 3, 4, 5, 6] 은 두 개의 목록 [1, 2, 3] 및 [4, 5, 6] 을 연결하여 생성됩니다 .

연결은 보고서 생성, 대규모 데이터 세트 처리, 복잡한 데이터 구조 생성 등 다양한 목적으로 데이터를 결합하는 데 사용되는 일반적인 프로그래밍 작업입니다.

목차:

• Python의 목록 연결
• 연산자를 사용하여 목록을 연결하는 방법+
• 연산자를 사용하여 목록을 연결하는 방법*
• List Comprehension을 사용하여 목록을 연결하는 방법
• 루프에서 메서드를 사용하여 목록을 연결하는 방법append()
• 메서드를 사용하여 목록을 연결하는 방법extend()
• 그렇다면 언제 각 방법을 사용해야 할까요?
• 결론

Python의 목록 연결

목록 연결은 Python 프로그래밍에서 일반적인 작업입니다. 대부분의 경우 결합된 데이터에 대해 일부 작업을 수행하기 위해 둘 이상의 목록을 단일 목록으로 병합해야 할 수 있습니다.

Python은 간단한 내장 함수부터 목록 이해 및 슬라이싱을 포함하는 보다 정교한 방법에 이르기까지 목록을 연결하는 다양한 방법을 제공합니다.

이 기사에서는 다양한 Python 연결 기술을 살펴보겠습니다. 읽기를 마치면 Python에서 목록을 연결하는 방법을 정확히 알게 되고 특정 사용 사례에 가장 적합한 접근 방식을 선택할 수 있습니다.

연산자를 사용하여 목록을 연결하는 방법+

두 목록을 연결하는 첫 번째이자 가장 간단한 기술은   +연산자를 사용하는 것입니다. 두 목록을 함께 연결하여 새 목록을 만듭니다.

예:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

산출:

[1, 2, 3, 4, 5, 6]

연산자를 사용하여 목록을 연결하는 방법*

*연산자를 사용하여 특정 횟수만큼 목록을 반복 할 수 있습니다 . 목록을 반복하고 자신과 연결하면 목록의 여러 복사본을 연결할 수 있습니다.

예:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

산출:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

List Comprehension을 사용하여 목록을 연결하는 방법

List Comprehension은 Python에서 기존 iterable 객체(예: list , tuple , string 등 )를 반복하고 변환 또는 필터를 iterable의 각 요소에 적용하여 간결하고 읽기 쉬운 방법입니다.

목록 이해 구문:

new_list = [expression for item in iterable if condition]

여기서 는 expressioniterable의 각 요소에 적용할 연산 또는 함수이고, 는 itemiterable의 각 요소를 차례로 취하는 변수이고, iterable는 원래 iterable 객체이며, 는 condition새로운 요소에 포함할 요소를 필터링하는 선택적 조건입니다. 목록.

목록 내포를 사용하여 여러 목록을 단일 목록으로 연결할 수 있습니다. 한 가지 예를 살펴보겠습니다.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

산출:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

루프에서 메서드를 사용하여 목록을 연결하는 방법append()

목록의 내장 함수인 메서드를 사용하여 파이썬에서 기존 목록의 끝에 요소를 추가할 수 있습니다 append().

사용 구문은 append()다음과 같습니다.

list_name.append(element)

코드에서 는 list_name요소를 추가하려는 목록의 이름이고 는 element목록에 추가하려는 값입니다.

append()루프 내에서 메서드를 사용하여 한 목록의 요소를 다른 목록에 추가할 수 있습니다.

예:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

산출:

[1, 2, 3, 4, 5, 6]

메서드를 사용하여 목록을 연결하는 방법extend()

기존 목록을 다른 반복 가능한 객체와 연결하면 extend()Python의 목록 메서드를 사용하여 기존 목록에 여러 요소를 추가할 수 있습니다.

구문은 extend()다음과 같습니다.

list_name.extend(iterable)

Here, iterable is any iterable object (such as a list, tuple, string, etc.) that contains the elements you want to add to the list, and list_name is the name of the list to which you want to add elements.

You can use the extend() method to append all the elements of one list to the end of the original list.

Example:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Output:

[1, 2, 3, 4, 5, 6]

So When Should You Use Each Method?

Using the * operator: You can use the * operator in list concatenation when you want to repeat a list a certain number of times or to create a new list by repeating the elements of the original list by a scalar value.

+연산자 사용 : 이 방법은 간단하고 읽기 쉽지만 사용할 때마다 새로운 목록을 생성하기 때문에 큰 목록을 처리할 때 비효율적일 수 있습니다.

append()방법 사용 : append()Python의 방법은 목록 끝에 요소를 추가합니다. 일반적으로 목록 연결에 사용하지 않고 기존 목록에 개별 요소를 추가하는 데 사용합니다. 방법

사용 : 이 방법은 한 목록의 요소를 다른 목록의 끝에 추가하는 방법을 사용합니다 . 이 메서드는 새 목록을 만드는 대신 원래 목록을 수정하여 + 연산자보다 메모리를 효율적으로 만듭니다. 그러나 매우 큰 목록의 경우 목록 이해 방법보다 여전히 느릴 수 있습니다.extend()extend()extend()

결론

+이 기사에서는 연산자, *연산자, extend()메서드, append()메서드 및 목록 내포를 사용하는 것을 포함하여 Python에서 목록을 연결하는 다양한 방법을 살펴보았습니다 . 또한 사용 사례에 사용할 수 있는 최상의 방법에 대해서도 논의했습니다.

행복한 코딩!

출처: https://www.freecodecamp.org

#python

5 способов объединения списков в Python

В этом руководстве показано 5 способов объединения списков в Python, включая использование +оператора, *оператора, метода extend(), метода append() и понимания списка. Мы обсудим лучший метод, который вы можете использовать для вашего случая использования.

Процесс объединения двух или более строк, списков или других структур данных в единую сущность в программировании называется конкатенацией.

Конкатенация создает новый объект со всеми компонентами исходных объектов, расположенных в порядке конкатенации.

Конкатенация в контексте строк означает присоединение одной строки к концу другой строки для создания более длинной строки. Например, создание строки « helloworld » путем соединения слов « hello » и « world » вместе.

Конкатенация в контексте списков означает, что вы создаете новый список, который включает каждый элемент из двух или более списков. Например, список [1, 2, 3, 4, 5, 6] будет создан путем объединения двух списков [1, 2, 3] и [4, 5, 6] .

Конкатенация — это обычная операция программирования, которая используется для объединения данных для различных целей, включая создание отчетов, обработку больших наборов данных и создание сложных структур данных.

Оглавление:

• Конкатенация списка в Python
• Как объединить списки с помощью +оператора
• Как объединить списки с помощью *оператора
• Как объединить списки, используя понимание списка
• Как объединить списки, используя append()метод в цикле
• Как объединить списки с помощью extend()метода
• Итак, когда вы должны использовать каждый метод?
• Заключение

Конкатенация списка в Python

Объединение списков — обычная операция в программировании на Python. Во многих ситуациях может потребоваться объединить два или более списков в один список, чтобы выполнить некоторые операции с объединенными данными.

Python предлагает множество методов для объединения списков, от простых встроенных функций до более сложных методов, включающих понимание списка и его нарезку.

В этой статье мы рассмотрим различные методы конкатенации Python. К тому времени, когда вы закончите чтение, вы будете точно знать, как объединять списки в Python, и сможете выбрать подход, который лучше всего подходит для вашего конкретного случая использования.

Как объединить списки с помощью +оператора

Первый и самый простой метод объединения двух списков — использование   +оператора. Он создает новый список, объединяя два списка вместе.

Пример:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

Выход:

[1, 2, 3, 4, 5, 6]

Как объединить списки с помощью *оператора

Вы можете использовать *оператор, чтобы повторить список определенное количество раз. Повторяя список и объединяя его сам с собой, мы можем добиться объединения нескольких копий списка.

Пример:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

Выход:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Как объединить списки, используя понимание списка

Понимание списков — это краткий и удобочитаемый способ создания нового списка в Python путем перебора существующего итерируемого объекта (например, списка, кортежа , строки и т . д.) и применения преобразования или фильтра к каждому элементу в итерируемом.

Синтаксис понимания списка:

new_list = [expression for item in iterable if condition]

Здесь expression— операция или функция, применяемая к каждому элементу в итерируемом объекте, itemэто переменная, которая по очереди принимает каждый элемент итерируемого объекта, iterableэто исходный итерируемый объект и conditionнеобязательное условие, которое фильтрует, какие элементы включить в новый список.

Вы можете использовать понимание списков, чтобы объединить несколько списков в один список. Давайте посмотрим на пример.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

Выход:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Как объединить списки, используя append()метод в цикле

Элемент можно добавить в конец существующего списка в Python с помощью метода append(), который является встроенной функцией списков.

Синтаксис использования append():

list_name.append(element)

Из кода — list_nameэто имя списка, в который вы хотите добавить элемент, и elementзначение, которое вы хотите добавить в список.

Вы можете использовать append()метод внутри цикла для добавления элементов одного списка в другой.

Пример:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

Выход:

[1, 2, 3, 4, 5, 6]

Как объединить списки с помощью extend()метода

Объединяя существующий список с другим итерируемым объектом, extend()метод списков в Python позволяет добавлять несколько элементов в существующий список.

Синтаксис для extend()следующий:

list_name.extend(iterable)

Здесь iterable— любой итерируемый объект (например, список , кортеж , строка и т. д.), содержащий элементы, которые вы хотите добавить в список, и list_nameимя списка, в который вы хотите добавить элементы.

Вы можете использовать этот extend()метод для добавления всех элементов одного списка в конец исходного списка.

Пример:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Выход:

[1, 2, 3, 4, 5, 6]

Итак, когда вы должны использовать каждый метод?

Использование *оператора : вы можете использовать *оператор при объединении списков, когда хотите повторить список определенное количество раз или создать новый список, повторяя элементы исходного списка по скалярному значению.

Использование +оператора : этот метод прост и удобен для чтения, но он может быть неэффективным при работе с большими списками, поскольку каждый раз при использовании создается новый список.

Использование append()метода : append()метод в Python добавляет элемент в конец списка. Обычно вы не используете его для объединения списков, а скорее для добавления отдельных элементов в существующий список.

Использование extend()метода : этот метод предполагает использование extend()метода для добавления элементов одного списка в конец другого списка. Этот extend()метод изменяет исходный список вместо создания нового списка, что делает его более эффективным с точки зрения использования памяти, чем оператор +. Но он все же может быть медленнее, чем метод понимания списка для очень больших списков.

Заключение

В этой статье мы рассмотрели различные способы объединения списков в Python, включая использование оператора +, *оператора, extend()метода, append()метода и понимания списка. Мы также обсудили лучший метод, который вы можете использовать для своего варианта использования.

Удачного кодирования!

Источник: https://www.freecodecamp.org

#python

Python でリストを連結する 5 つの方法

+このチュートリアルでは、演算子、*演算子、extend() メソッド、append() メソッド、およびリスト内包表記の使用を含む、Python でリストを連結する 5 つの方法を示します。ユースケースに使用できる最適な方法について説明します。

2 つ以上の文字列、リスト、またはその他のデータ構造を 1 つのエンティティに結合するプロセスは、プログラミングでは連結と呼ばれます。

連結により、元のオブジェクトのすべてのコンポーネントが連結順に配置された新しいオブジェクトが生成されます。

文字列のコンテキストでの連結とは、ある文字列を別の文字列の末尾に結合して、より長い文字列を作成することを指します。たとえば、 「 hello」と「world 」という単語を結合して文字列「 helloworld 」を作成します。

リストのコンテキストでの連結とは、2 つ以上のリストのすべての要素を組み込んだ新しいリストを作成することを意味します。たとえば、リスト[1, 2, 3, 4, 5, 6] は、 2 つのリスト[1, 2, 3]と[4, 5, 6]を連結して作成されます。

連結は、レポートの作成、大規模なデータ セットの処理、複雑なデータ構造の作成など、さまざまな目的でデータを結合するために使用される一般的なプログラミング操作です。

目次：

• Python でのリスト連結
• 演算子を使用してリストを連結する方法+
• 演算子を使用してリストを連結する方法*
• リスト内包表記を使用してリストを連結する方法
• メソッドをループで使用してリストを連結する方法append()
• メソッドを使用してリストを連結する方法extend()
• では、いつ各方法を使用する必要があるのでしょうか?
• 結論

Python でのリスト連結

リストの連結は、Python プログラミングの一般的な操作です。多くの場合、結合されたデータに対して何らかの操作を実行するために、2 つ以上のリストを 1 つのリストに結合する必要があります。

Python は、単純な組み込み関数から、リストの理解とスライスを含むより洗練された方法まで、リストを連結するためのさまざまな方法を提供します。

この記事では、さまざまな Python 連結手法を見ていきます。読み終わるころには、Python でリストを連結する方法を正確に理解し、特定のユース ケースに最適なアプローチを選択できるようになります。

演算子を使用してリストを連結する方法+

2 つのリストを連結する最初の最も簡単な手法は、  +演算子を使用することです。2 つのリストを連結して新しいリストを作成します。

例：

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

出力：

[1, 2, 3, 4, 5, 6]

演算子を使用してリストを連結する方法*

*演算子を使用して、リストを特定の回数繰り返すことができます。リストを繰り返してそれ自体と連結することで、リストの複数のコピーを連結することができます。

例：

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

出力：

[1, 2, 3, 1, 2, 3, 1, 2, 3]

リスト内包表記を使用してリストを連結する方法

リスト内包表記は、既存の反復可能なオブジェクト ( list 、 tuple 、 stringなど) を反復処理し、反復可能なオブジェクトの各要素に変換またはフィルターを適用することによって、Python で新しいリストを作成するための簡潔で読みやすい方法です。

リスト内包構文:

new_list = [expression for item in iterable if condition]

ここで、expressionは iterable の各要素に適用する操作または関数、itemは iterable の各要素を順番に受け取る変数、iterableは元の iterable オブジェクト、conditionは新しいオブジェクトに含める要素をフィルタリングするオプションの条件です。リスト。

リスト内包表記を使用して、複数のリストを 1 つのリストに連結できます。例を見てみましょう。

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

出力：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

メソッドをループで使用してリストを連結する方法append()

append()リストの組み込み関数であるメソッドを使用して、Python の既存のリストの末尾に要素を追加できます。

使用するための構文は次append()のとおりです。

list_name.append(element)

コードから、list_nameは要素を追加するリストの名前であり、 はelementリストに追加する値です。

append()ループ内でメソッドを使用して、あるリストの要素を別のリストに追加できます。

例：

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

出力：

[1, 2, 3, 4, 5, 6]

メソッドを使用してリストを連結する方法extend()

既存のリストを別の反復可能なオブジェクトと連結することにより、extend()Python のリストのメソッドを使用すると、既存のリストに複数の要素を追加できます。

の構文はextend()次のとおりです。

list_name.extend(iterable)

ここで、はリストに追加する要素を含むiterable反復可能なオブジェクト ( list、tuple、stringlist_nameなど) であり、要素を追加するリストの名前です。

extend()メソッドを使用して、1 つのリストのすべての要素を元のリストの末尾に追加できます。

例：

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

出力：

[1, 2, 3, 4, 5, 6]

では、いつ各方法を使用する必要があるのでしょうか?

*演算子の使用*: リストを特定の回数繰り返したい場合、または元のリストの要素をスカラー値で繰り返して新しいリストを作成する場合は、リストの連結で演算子を使用できます。

+演算子の使用: この方法はシンプルで読みやすいですが、使用するたびに新しいリストが作成されるため、大きなリストを扱う場合は非効率になる可能性があります。

append()メソッドの使用: append()Python のメソッドは、リストの末尾に要素を追加します。通常、リストの連結には使用しませんが、個々の要素を既存のリストに追加するために使用します。メソッド

の使用: このメソッドは、メソッドを使用して、あるリストの要素を別のリストの最後に追加することを含みます。このメソッドは、新しいリストを作成する代わりに元のリストを変更するため、+ 演算子よりもメモリ効率が高くなります。ただし、非常に大きなリストの場合、リスト内包法よりも遅くなる可能性があります。extend()extend()extend()

結論

+この記事では、演算子、*演算子、メソッド、extend()メソッドappend()、リスト内包表記の使用など、Python でリストを連結するさまざまな方法を調べました。また、ユースケースに使用できる最適な方法についても説明しました。

ハッピーコーディング！

ソース: https://www.freecodecamp.org

#python

5 façons de concaténer des listes en Python

Ce tutoriel montre 5 façons de concaténer des listes en Python, notamment en utilisant l' +opérateur, l' *opérateur, la méthode extend(), la méthode append() et la compréhension de liste. Nous discuterons de la meilleure méthode que vous pouvez utiliser pour votre cas d'utilisation.

Le processus de combinaison de deux ou plusieurs chaînes, listes ou autres structures de données en une seule entité est appelé concaténation en programmation.

La concaténation produit un nouvel objet avec tous les composants des objets d'origine, disposés dans l'ordre de concaténation.

La concaténation dans le contexte des chaînes fait référence à la jonction d'une chaîne à la fin d'une autre chaîne pour créer une chaîne plus longue. Par exemple, créer la chaîne " helloworld " en joignant les mots " hello " et " world " ensemble.

La concaténation dans le contexte des listes signifie que vous créez une nouvelle liste qui incorpore chaque élément de deux listes ou plus. Par exemple, la liste [1, 2, 3, 4, 5, 6] serait créée en concaténant les deux listes [1, 2, 3] et [4, 5, 6] .

La concaténation est une opération de programmation courante utilisée pour combiner des données à diverses fins, notamment la création de rapports, la gestion de grands ensembles de données et la création de structures de données complexes.

Table des matières:

• Concaténation de listes en Python
• Comment concaténer des listes à l'aide de l' +opérateur
• Comment concaténer des listes à l'aide de l' *opérateur
• Comment concaténer des listes à l'aide de la compréhension de liste
• Comment concaténer des listes à l'aide de la append()méthode dans une boucle
• Comment concaténer des listes à l'aide de la extend()méthode
• Alors, quand devriez-vous utiliser chaque méthode ?
• Conclusion

Concaténation de listes en Python

La concaténation de listes est une opération courante dans la programmation Python. Dans de nombreuses situations, vous devrez peut-être fusionner deux ou plusieurs listes en une seule liste pour effectuer certaines opérations sur les données combinées.

Python offre une variété de méthodes pour concaténer des listes, des fonctions intégrées simples aux méthodes plus sophistiquées impliquant la compréhension et le découpage des listes.

Dans cet article, nous examinerons différentes techniques de concaténation Python. Lorsque vous aurez fini de lire, vous saurez exactement comment concaténer des listes en Python et serez en mesure de sélectionner l'approche qui convient le mieux à votre cas d'utilisation particulier.

Comment concaténer des listes à l'aide de l' +opérateur

La première technique et la plus simple pour concaténer deux listes consiste à utiliser l'   +opérateur. Il crée une nouvelle liste en concaténant les deux listes ensemble.

Exemple:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

Sortir:

[1, 2, 3, 4, 5, 6]

Comment concaténer des listes à l'aide de l' *opérateur

Vous pouvez utiliser l' *opérateur pour répéter une liste un certain nombre de fois. En répétant une liste et en la concaténant avec elle-même, nous pouvons réaliser la concaténation de plusieurs copies d'une liste.

Exemple:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

Sortir:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Comment concaténer des listes à l'aide de la compréhension de liste

La compréhension de liste est un moyen concis et lisible de créer une nouvelle liste en Python en itérant sur un objet itérable existant (comme une liste , un tuple , une chaîne , etc.) et en appliquant une transformation ou un filtre à chaque élément de l'itérable.

Syntaxe de compréhension de liste :

new_list = [expression for item in iterable if condition]

Ici, expressionest l'opération ou la fonction à appliquer à chaque élément de l'itérable, itemest une variable qui prend tour à tour chaque élément de l'itérable, iterableest l'objet itérable d'origine et conditionest une condition facultative qui filtre les éléments à inclure dans le nouveau liste.

Vous pouvez utiliser la compréhension de liste pour concaténer plusieurs listes en une seule liste. Jetons un oeil à un exemple.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

Sortir:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Comment concaténer des listes à l'aide de la append()méthode dans une boucle

Un élément peut être ajouté à la fin d'une liste existante en Python en utilisant la append()méthode, qui est une fonction intégrée des listes.

La syntaxe d'utilisation append()est :

list_name.append(element)

D'après le code, list_nameest le nom de la liste à laquelle vous souhaitez ajouter un élément, et elementest la valeur que vous souhaitez ajouter à la liste.

Vous pouvez utiliser la append()méthode à l'intérieur d'une boucle pour ajouter les éléments d'une liste à une autre.

Exemple:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

Sortir:

[1, 2, 3, 4, 5, 6]

Comment concaténer des listes à l'aide de la extend()méthode

En concaténant une liste existante avec un autre objet itérable, la extend()méthode des listes en Python vous permet d'ajouter plusieurs éléments à une liste existante.

La syntaxe pour extend()est la suivante :

list_name.extend(iterable)

Ici, iterableest n'importe quel objet itérable (tel qu'un list , tuple , string , etc.) qui contient les éléments que vous voulez ajouter à la liste, et list_nameest le nom de la liste à laquelle vous voulez ajouter des éléments.

Vous pouvez utiliser la extend()méthode pour ajouter tous les éléments d'une liste à la fin de la liste d'origine.

Exemple:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Sortir:

[1, 2, 3, 4, 5, 6]

Alors, quand devriez-vous utiliser chaque méthode ?

Utilisation de l' *opérateur : Vous pouvez utiliser l' *opérateur en concaténation de liste lorsque vous souhaitez répéter une liste un certain nombre de fois ou pour créer une nouvelle liste en répétant les éléments de la liste d'origine par une valeur scalaire.

Utilisation de l' +opérateur : Cette méthode est simple et facile à lire, mais elle peut être inefficace lorsqu'il s'agit de grandes listes car elle crée une nouvelle liste à chaque fois qu'elle est utilisée.

Utilisation de la append()méthode : La append()méthode en Python ajoute un élément à la fin d'une liste. Vous ne l'utilisez généralement pas pour la concaténation de listes, mais plutôt pour ajouter des éléments individuels à une liste existante.

Utilisation de la extend()méthode : Cette méthode consiste à utiliser la extend()méthode pour ajouter des éléments d'une liste à la fin d'une autre liste. La extend()méthode modifie la liste d'origine au lieu de créer une nouvelle liste, ce qui la rend plus économe en mémoire que l'opérateur +. Mais, cela peut toujours être plus lent que la méthode de compréhension de liste pour les très grandes listes.

Conclusion

Dans cet article, nous avons exploré différentes manières de concaténer des listes en Python, notamment en utilisant l' +opérateur, l' *opérateur, la extend()méthode, la append()méthode et la compréhension de liste. Nous avons également discuté de la meilleure méthode que vous pouvez utiliser pour votre cas d'utilisation.

Bon codage !

Source : https://www.freecodecamp.org

#python

5 formas de concatenar listas en Python

Este tutorial muestra 5 formas de concatenar listas en Python, incluido el uso del +operador, el *operador, el método extend(), el método append() y la comprensión de listas. Discutiremos el mejor método que puede usar para su caso de uso.

El proceso de combinar dos o más cadenas, listas u otras estructuras de datos en una sola entidad se conoce como concatenación en programación.

La concatenación produce un nuevo objeto con todos los componentes de los objetos originales, dispuestos en el orden de concatenación.

La concatenación en el contexto de cadenas se refiere a unir una cadena al final de otra cadena para crear una cadena más larga. Por ejemplo, crear la cadena " holamundo " uniendo las palabras " hola " y " mundo ".

La concatenación en el contexto de las listas significa que crea una nueva lista que incorpora todos los elementos de dos o más listas. Por ejemplo, la lista [1, 2, 3, 4, 5, 6] se crearía a partir de la concatenación de las dos listas [1, 2, 3] y [4, 5, 6] .

La concatenación es una operación de programación común que se usa para combinar datos para una variedad de propósitos, incluida la creación de informes, el manejo de grandes conjuntos de datos y la creación de estructuras de datos complejas.

Tabla de contenido:

• Concatenación de listas en Python
• Cómo concatenar listas usando el +operador
• Cómo concatenar listas usando el *operador
• Cómo concatenar listas usando la comprensión de listas
• Cómo concatenar listas usando el append()método en un bucle
• Cómo concatenar listas usando el extend()método
• Entonces, ¿cuándo debe usar cada método?
• Conclusión

Concatenación de listas en Python

La concatenación de listas es una operación común en la programación de Python. En muchas situaciones, es posible que deba fusionar dos o más listas en una sola lista para realizar algunas operaciones en los datos combinados.

Python ofrece una variedad de métodos para concatenar listas, desde funciones integradas sencillas hasta métodos más sofisticados que implican la comprensión y el corte de listas.

En este artículo, veremos varias técnicas de concatenación de Python. Cuando termine de leer, sabrá exactamente cómo concatenar listas en Python y podrá seleccionar el enfoque que mejor se adapte a su caso de uso particular.

Cómo concatenar listas usando el +operador

La primera y más simple técnica para concatenar dos listas es usando el   +operador. Crea una nueva lista concatenando las dos listas juntas.

Ejemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#concatenating the two lists
concat_list = first_list + second_list

#print the concatenated list
print(concat_list)

Producción:

[1, 2, 3, 4, 5, 6]

Cómo concatenar listas usando el *operador

Puede usar el *operador para repetir una lista un cierto número de veces. Repitiendo una lista y concatenándola consigo misma, podemos lograr la concatenación de múltiples copias de una lista.

Ejemplo:

first_list = [1, 2, 3]
second_list = first_list * 3

print(second_list)

Producción:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Cómo concatenar listas usando la comprensión de listas

La comprensión de listas es una forma concisa y legible de crear una nueva lista en Python iterando sobre un objeto iterable existente (como una lista , tupla , cadena , etc.) y aplicando una transformación o filtro a cada elemento en el iterable.

Lista de sintaxis de comprensión:

new_list = [expression for item in iterable if condition]

Aquí, expressiones la operación o función que se aplica a cada elemento en el iterable, itemes una variable que toma cada elemento del iterable a su vez, iterablees el objeto iterable original y conditiones una condición opcional que filtra qué elementos incluir en el nuevo lista.

Puede usar la comprensión de listas para concatenar varias listas en una sola lista. Echemos un vistazo a un ejemplo.

#define the lists
first_list = [1, 2, 3]
second_list = [4, 5, 6]
third_list = [7, 8, 9]

#using list comprehension
fourth_list = [x for lst in [first_list, second_list, third_list] for x in lst]


print(fourth_list)

Producción:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Cómo concatenar listas usando el append()método en un bucle

Se puede agregar un elemento al final de una lista existente en Python usando el append()método, que es una función integrada de las listas.

La sintaxis para usar append()es:

list_name.append(element)

Desde el código, list_namees el nombre de la lista a la que desea agregar un elemento y elementes el valor que desea agregar a la lista.

Puede usar el append()método dentro de un ciclo para agregar los elementos de una lista a otra.

Ejemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

for element in second_list:
    first_list.append(element)
    
print(first_list)

Producción:

[1, 2, 3, 4, 5, 6]

Cómo concatenar listas usando el extend()método

Al concatenar una lista existente con otro objeto iterable, el extend()método de listas en Python le permite agregar múltiples elementos a una lista existente.

La sintaxis para extend()es la siguiente:

list_name.extend(iterable)

Aquí, iterablehay cualquier objeto iterable (como una lista , una tupla , una cadena , etc.) que contiene los elementos que desea agregar a la lista y list_namees el nombre de la lista a la que desea agregar elementos.

Puede usar el extend()método para agregar todos los elementos de una lista al final de la lista original.

Ejemplo:

first_list = [1, 2, 3]
second_list = [4, 5, 6]

#using the extend() method
first_list.extend(second_list)

print(first_list)

Producción:

[1, 2, 3, 4, 5, 6]

Entonces, ¿cuándo debe usar cada método?

Usando el *operador : Puede usar el *operador en la concatenación de listas cuando quiera repetir una lista un cierto número de veces o para crear una nueva lista repitiendo los elementos de la lista original por un valor escalar.

Uso del +operador : este método es simple y fácil de leer, pero puede ser ineficiente cuando se trata de listas grandes, ya que crea una nueva lista cada vez que se usa.

Usando el append()método : El append()método en Python agrega un elemento al final de una lista. Por lo general, no lo usa para la concatenación de listas, sino para agregar elementos individuales a una lista existente.

Usar el extend()método : este método implica usar el extend()método para agregar elementos de una lista al final de otra lista. El extend()método modifica la lista original en lugar de crear una nueva lista, lo que lo hace más eficiente en memoria que el operador +. Pero aún puede ser más lento que el método de comprensión de listas para listas muy grandes.

Conclusión

En este artículo, hemos explorado diferentes formas de concatenar listas en Python, incluido el uso del +operador, el *operador, el extend()método, el append()método y la comprensión de listas. También hemos discutido el mejor método que puede usar para su caso de uso.

¡Feliz codificación!

Fuente: https://www.freecodecamp.org

#python