Python中列表和数组的区别比较

Python列表

Python编程语言有四种集合数据类型，分别是:List、Tuple、Set和Dictionary。列表是一个可变且有序的集合，即列表的元素可以更改，并且它保持其项目的插入顺序。由于顺序维护的特性，列表的每个元素都有一个固定的索引，它允许列表有重复的元素。在 Python 中，list 非常有用，因为它能够包含非同质元素。

以下是可以对列表执行的一些操作：

# Python program to demonstrate
# some operations on list

# Declaring a List of integers
IntList = [10, 20, 30]
print("List of numbers: ")

# Printing the list
print(IntList)

# Declaring a List of strings
StrList = ["geekdocs", "For", "Geeks"]
print("List of Strings: ")

# Printing the list
print(StrList)

# Declaring a list of non-homogeneous elements
Non_homogeneous_list = [10, "Geeks", 20.890, "for", 30, "geeks"]
print("List of non-homogeneous elements: ")

# Printing the list
print(Non_homogeneous_list)

# Printing size of a list
print("Size of the Non-homogeneous list: ", len(Non_homogeneous_list))

# Declaring a list
NewList = ["geekdocs", "for", "Geeks"]
print("Original List: ", NewList)

# Adding an item to the list

# Adding an item in the list
# using the append method
NewList.append("the")

# Printing the modified list
print("After adding an element the list becomes: ")
print(NewList)

# Adding an item in the list using the insert
# method to add an element at a specific position
NewList.insert(3, "is")

# Printing the modified list
print("After adding an element at index 3 the list becomes: ")
print(NewList)

# Adding multiple items to the list at the
# end using extend method
NewList.extend(["best", "CS", "website"])

# Printing the modified list
print("After adding 3 elements at the end, the list becomes: ")
print(NewList)

# Removing an item from the list

# Removing an element by
# writing the element itself
NewList.remove("the")

# Printing the modified list
print("After removing an element the list becomes: ")
print(NewList)

# Removing an element by
# specifying its position
NewList.pop(3)

# Printing the modified list
print("After removing an element  from index 3 the list becomes: ")
print(NewList)

运行结果：

List of numbers: 
[10, 20, 30]
List of Strings: 
['geekdocs', 'For', 'Geeks']
List of non-homogeneous elements: 
[10, 'geekdocs', 20.89, 'for', 30, 'geeks']
Size of the Non-homogeneous list:  6
Original List:  ['geekdocs', 'for', 'Geeks']
After adding an element thelist becomes: 
['geekdocs', 'for', 'Geeks', 'the']
After adding an element atindex 3 the list becomes: 
['geekdocs', 'for', 'Geeks', 'is', 'the']
After adding 3 elements at theend, the list becomes: 
['geekdocs', 'for', 'Geeks', 'is', 'the', 'best', 'CS', 'website']
After removing an elementthe list becomes: 
['Geeks', 'for', 'Geeks', 'is', 'best', 'CS', 'website']
After removing an element from index 3 the list becomes: 
['geekdocs', 'for', 'Geeks', 'best', 'CS', 'website']

要获得有关 python 列表的更深入的知识，请单击此处。

Python数组

Python数组也是一个集合，但它的项目存储在连续的内存位置。它只能存储同质元素(相同数据类型的元素)。数组在对元素执行数学运算时非常有用。与列表不同，数组不能直接声明。要创建数组，必须导入数组模块，并且声明的语法与列表的语法不同。

以下是可以对数组执行的一些操作：

# Python program to demonstrate
# some operations on arrays

# importing array module
import array as arr

# declaring an array of integer type
# 'i' signifies integer type and 
# elements inside [] are the array elements
a1 = arr.array('i', [10, 20, 30])

# printing array with
# data type and elements
print("Array a1: ", a1)

# printing elements of array
print ("Elements of the array a1 is : ", end = " ")
for i in range (len(a1)):
    print (a1[i], end =", ")
print()

# Declaring an array of float type
# 'd' signifies integer type and
# elements inside [] are the array elements
a2 = arr.array('d', [1.5, 2.4, 3.9])

# printing elements of array
print ("Elements of the array a2 is : ", end = " ")
for i in range (len(a2)):
    print (a2[i], end =", ")
print()

# Adding an item to the array

# Printing the elements of array a1
print ("Original elements of the array a1 is : ", end = " ")
print(*a1)

# Adding an element at the end of
# array by using the append method
a1.append(40)

# printing the modified array
print ("Elements of the array a1 after adding an element at last: ", end = " ")
print(*a1)

# Adding an element to the array at a specific index using the insert method
a1.insert(3, 35)

# printing the modified array
print ("Elements of the array a1 after adding an element at index 3: ", end = " ")
print(*a1)

# Removing an element by writing the elements itself
a1.remove(20)

# Printing the modified array
print("Array a1 after removing element 20: ", end = " ")
print(*a1)

# Removing an element of a specific index
# Removing the element of array a1 present at index 2
a1.pop(2)

# Printing the modified array
print("Array a1 after removing element of index 2: ", end = " ")
print(*a1)

运行结果：

Array a1:  array('i', [10, 20, 30])
Elements of the arraya1 is :  10, 20, 30, 
Elements of the arraya2 is :  1.5, 2.4, 3.9, 
Original elements of thearray a1 is :  10 20 30
Elements of the array a1after adding an elementat last:  10 20 30 40
Elements of the array a1after adding an elementat index 3:  10 20 30 35 40
Array a1 after removingelement 20:  10 30 35 40
Array a1 after removingelement of index 2:  10 30 40

Python列表和数组的相似之处

数组和列表都用于存储数据：集合的目的都是存储数据。虽然列表用于存储同质和非同质数据，但数组只能存储同质数据。

# Python program to demonstrate data
# storing similarities in array and list

# importing array module
import array as arr

# Declaring a Homogeneous List of strings
Homogeneous_List = ["geekdocs", "For", "Geeks"]
print("List of Strings: ")

# Printing the list
print(Homogeneous_List)

# Declaring a list of
# non-homogeneous elements
Non_homogeneous_list = [10, "geekdocs", 20.890, "for", 30, "geeks"]
print("List of non-homogeneous elements: ")

# Printing the list
print(Non_homogeneous_list)

# declaring an array of float type
# 'd' signifies integer type and
# elements inside [] are the array elements
Homogeneous_array = arr.array('d', [1.5, 2.4, 3.9])

# printing elements of array
print ("Elements of the array is  : ", end = " ")
for i in range (len(Homogeneous_array)):
    print (Homogeneous_array[i], end =", ")

运行结果：

List of Strings: 
['geekdocs', 'For', 'Geeks']
List of non-homogeneous elements: 
[10, 'geekdocs', 20.89, 'for', 30, 'geeks']
Elements of the array is :  1.5, 2.4, 3.9,

List 和 Array 都是可变的： List 和数组一样，都可以修改它们的元素，即它们是可变的。

# Python program to demonstrate
# both the list and array is mutable

# importing array module
import array as arr

# Declaring a list
List1 = ["Geeks", 1, "Geeks"]

# Printing original list
print("Original list: ", List1)

# Changing the value of the
# element at a specific index
List1[1] = "for"\n
# Printing modified list
print("Modified list: ", List1)

# Declaring an array with integers values
Array1 = arr.array('i', [10, 20, 30, 37, 50, ])

# Printing original array
print ("Original array: ", end =" ")
for i in range (len(Array1)):
    print (Array1[i], end =" ")


# Updating an element in the array
Array1[3] = 40

# Printing modified Array:
print("Modified array: ", end ="")
for i in range (len(Array1)):
    print (Array1[i], end =" ")

运行结果：

Original list:  ['geekdocs', 1, 'Geeks']
Modified list:  ['geekdocs', 'for', 'Geeks']
Original array:  10 20 30 37 50 
Modified array: 10 20 30 40 50

列表和数组的元素都可以通过索引和迭代来访问： 为了访问列表和数组的元素，可以选择使用索引号，也可以通过迭代来遍历它们。

# importing array module
import array as arr

# Declaring a list
List1 = [10, 20, 30, 20, 10, 40]

# Printing the list
print("List1 elements: ", List1, "n")

# Accessing elements of list by index number
print("Element at index 0: ", List1[0])
print("Element at index 1: ", List1[1])
print("Element at index 3: ", List1[3])
print("Element at index 4: ", List1[4])

# Accessing elements of the list
# using negative indexing

# Printing last element of the list
print("Element at last index: ", List1[-1])

# Printing 3rd last
# the element of the list
print("Element at 3rd last index: ", List1[-3])

# Accessing elements of list through iteration
print("Accessing through iteration: ", end = " ")
for item in range(len(List1)):
    print(List1[item], end =" ")


# Declaring an array
Array1 = arr.array('i', [10, 20, 30, 40, 50, 60])
print("Array1: ", Array1)

# Accessing the elements of an array

# Access element of
# array by index number
print("Element of Array1 at index 3: ", Array1[3])

# Accessing elements of
# array through iteration
print("Accessing through iteration:  ", end = " ")
for i in range (len(Array1)):
    print (Array1[i], end =" ")

运行结果：

List1 elements:  [10, 20, 30, 20, 10, 40] 

Element at index 0:  10
Element at index 1:  20
Element at index 3:  20
Element at index 4:  10
Element at last index:  40
Element at 3rd last index:  20
Accessing through iteration:  10 20 30 20 10 40 
Array1:  array('i', [10, 20, 30, 40, 50, 60])
Element of Array1 at index 3:  40
Accessing through iteration:  10 20 30 40 50 60

列表和数组都可以切片： 切片操作对列表和数组都有效，可以得到一定范围的元素。

# importing array module
import array as arr

# Declaring a list
List1 = [10, 20, 30, 20, 10, 40]

# Accessing a range of elements in the
# list using slicing operation

# Printing items of the list
# from index 1 to 3
print("List elements from  index 1 to 4: ", List1[1:4])

# Printing items of the
# list from index 2 to end
print("List elements from index 2 to last: ", List1[2:])

# Declaring an array
Array1 = arr.array('i', [10, 20, 30, 40, 50, 60])

# Accessing a range of elements in the
# array using slicing operation
Sliced_array1 = Array1[1:4]
print(" Slicing elements of the "\n"array in a range from index 1 to 4: ")
print(Sliced_array1)

# Print elements of the array
# from a defined point to end
Sliced_array2 = Array1[2:]
print("nSlicing elements of the array fromn2nd index till the end: ")
print(Sliced_array2)

运行结果：

List elements from index 1 to 4:  [20, 30, 20]
List elements from index 2 to last:  [30, 20, 10, 40]

Slicing elements of the array in a
range from index 1 to 4: 
array('i', [20, 30, 40])

Slicing elements of the array from
2nd index till the end: 
array('i', [30, 40, 50, 60])

Python列表和数组的区别：
创建的区别：与 Python 语法中的 list 不同，数组只能通过导入 array 模块来创建。可以通过简单地将一系列元素放在方括号周围来创建列表。以上所有代码都是这种差异的证明。
数组和列表之间的内存消耗：列表和数组即使存储相同数量的元素，也会占用不同数量的内存。在这种情况下，数组被发现效率更高，因为它们以非常紧凑的方式存储数据。

# importing array module
import array as arr

# importing system module
import sys

# declaring a list of 1000 elements
List = range(1000)

# printing size of each element of the list
print("Size of each element of  list in bytes: ", sys.getsizeof(List))

# printing size of the whole list
print("Size of the whole list in bytes: ", sys.getsizeof(List)*len(List))

# declaring an array of 1000 elements
Array = arr.array('i', [1]*1000)

# printing size of each
# element of the Numpy array
print("Size of each element of the array in bytes: ", Array.itemsize)

# printing size of the whole Numpy array
print("Size of the whole array in bytes: ", len(Array)*Array.itemsize)

运行结果如下：

Size of each element of list in bytes:  48
Size of the whole list in bytes:  48000
Size of each element of the array in bytes:  4
Size of the whole array in bytes:  4000

执行数学运算： 可以在数组中执行数学运算，例如将集合中的每个元素除或添加一定数量，但列表不支持这些类型的算术运算。数组为此目的进行了优化，而要在列表中执行这些操作，必须将操作分别应用于每个元素。

# importing array module
from numpy import array

# declaring a list
List =[1, 2, 3]
# declaring an array
Array = array([1, 2, 3])

try:
    # adding 5 to each element of list
    List = List + 5
except(TypeError):
    print("Lists don't support list + int")

# for array
try:

    Array = Array + 5
    # printing the array
    print("Modified array: ", Array)

except(TypeError):
    print("Arrays don't support list + int")

运行结果：

Lists don't support list + int
Modified array:  [6 7 8]

调整大小： 数组一旦声明就不能调整大小。唯一的方法是将旧数组的元素复制到更大的数组中。虽然列表可以非常有效地调整大小。

可存储的数据： List 既可以存储同质数据，也可以存储非同质数据，而数组只支持存储同质数据。