Python中的数据结构

        在任何语言中，数据结构都用于存储和操作复杂的数据。 在 Python 中，数据结构是一种存储容器，可以有效地管理、组织和搜索数据。 它们用于存储一组称为集合的数据元素，需要一起存储和处理。 在 Python 中，有五种不同的数据结构可用于存储集合。

一、列表（Lists）

        有序的可变元素序列。

        在 Python 中，列表是用于存储可变元素序列的主要数据结构。 存储在列表中的数据元素序列不必是同一类型。

要创建列表，数据元素需要包含在 [ ] 中，并且需要用逗号分隔。 例如，以下代码一起创建了四个不同类型的数据元素。

aList = ["John", 33,"Toronto", True]
type(aList)

1、切片

        通过指定索引范围可以检索列表中的元素子集，这个过程叫作切片。

bin_colors=['Red','Green','Blue','Yellow']

        查看如下示例 

bin_colors[0:2]
#会输出['Red', 'Green']

bin_colors[1]
#会输出'Green'

bin_colors[2:]
#会输出['Blue', 'Yellow']

bin_colors[:2]
#会输出['Red', 'Green']

2、负索引

        负索引从列表的末尾开始计数。

        查看如下示例

bin_colors[:-1]
#['Red', 'Green', 'Blue']

bin_colors[:-2]
#['Red', 'Green']

bin_colors[-2:-1]
#['Blue']

3、嵌套

        列表的元素可以是简单数据类型或复杂数据类型。 这允许嵌套在列表中。 对于迭代和递归算法，这提供了重要的功能。

        查看如下示例

a = [1,2,[100,200,300],6]
max(a[2])
#300

a[2][1]
#200

4、迭代

for aColor in bin_colors:
    print(aColor+ " Square")

#Red Square
#Green Square
#Blue Square
#Yellow Square

5、Lambda

        lambda 函数可用于列表。 它们在算法的上下文中特别重要，并提供了动态创建函数的能力。 它们也被称为匿名函数。

        过滤数据

list(filter(lambda x: x > 100, [-5, 200, 300, -10, 10, 1000]))
#[200, 300, 1000]

        数据转换

list(map(lambda x: x ** 2, [11, 22, 33, 44,55]))
#[121, 484, 1089, 1936, 3025]

        数据聚合

        对于数据聚合，可以使用 reduce() 函数，它递归地运行一个函数来处理列表每个元素上的值对。

from functools import reduce
def doSum(x1,x2):
    return x1+x2
x = reduce(doSum, [100, 122, 33, 4, 5, 6])
print (f"数据聚合 is {x}")

#数据聚合 is 270

        范围功能

        range 函数可用于轻松生成大量数字列表。 它用于自动填充列表中的数字序列。

        range 函数使用起来很简单。 我们可以通过指定列表中我们想要的元素数量来使用它。 默认情况下，它从零开始并递增一。

二、元组（Tuples）

        有序的不可变元素序列。

        可用于存储集合的第二种数据结构是元组。 与列表相反，元组是不可变（只读）的数据结构。 元组由 ( ) 包围的几个元素组成。

        像列表一样，元组中的元素可以是不同的类型。 它们还允许其元素使用复杂的数据类型。 所以元组中可以有一个元组，提供一种创建嵌套数据结构的方法。 创建嵌套数据结构的能力在迭代和递归算法中特别有用。

        以下代码演示了如何创建元组

bin_colors=('Red','Green','Blue','Yellow')
print(f"The second element of the tuple is {bin_colors[1]}")
#The second element of the tuple is Green

print(f"The elements after thrid element onwards are {bin_colors[2:]}")
#The elements after thrid element onwards are ('Blue', 'Yellow')


nested_tuple = (1,2,(100,200,300),6)
print(f"The maximum value of the inner tuple {max(nested_tuple[2])}")
#The maximum value of the inner tuple 300

三、字典（dictionary）

        无序的键值对序列。

        创建一个简单的字典，将颜色分配给各种变量，键值对需要包含在 {} 中。 例如，以下代码创建一个由三个键值对组成的简单字典：

bin_colors ={
  "manual_color": "Yellow",
  "approved_color": "Green",
  "refused_color": "Red"
}
print(bin_colors)
#{'manual_color': 'Yellow', 'approved_color': 'Green', 'refused_color': 'Red'}

        获取和赋值

bin_colors.get('approved_color')
#'Green'

bin_colors['approved_color']
#'Green'

bin_colors['approved_color']="Purple"
print(bin_colors)
#{'manual_color': 'Yellow', 'approved_color': 'Purple', 'refused_color': 'Red'}

四、集合（Set）

        无序元素序列（其中元素不重复）。

        集合被定义为可以是不同类型的元素的集合。 元素用 { } 括起来。 例如，看看下面的代码块：

green = {'grass', 'leaves'}
print(green)
#{'leaves', 'grass'}

yellow = {'dandelions', 'fire hydrant', 'leaves'}
red = {'fire hydrant', 'blood', 'rose', 'leaves'}
print(f"The union of yellow and red sets is {yellow|red}")
#The union of yellow and red sets is {'rose', 'dandelions', 'blood', 'fire hydrant', 'leaves'}

print(f"The intersaction of yellow and red is {yellow&red}")
#The intersaction of yellow and red is {'fire hydrant', 'leaves'}

五、数据帧（DataFrame）

        存储二维数据的二维结构。       

        DataFrame 是一种数据结构，用于存储 Python 的 pandas 包中可用的表格数据。 它是算法最重要的数据结构之一，用于处理传统的结构化数据。

        可以使用以下代码创建一个简单的 DataFrame。

import pandas as pd
df = pd.DataFrame([
    ['1', 'Fares', 32, True],
    ['2', 'Elena', 23, False],
    ['3', 'Steven', 40, True]])
df.columns = ['id', 'name', 'age', 'decision']
print(df)

  id    name  age  decision
0  1   Fares   32      True
1  2   Elena   23     False
2  3  Steven   40      True

1、选择列

df[['name','age']]

        列的位置在数据框中是确定的。 第四列可以通过它的位置来检索，如下所示：

df.iloc[:,3] 

0     True
1    False
2     True
Name: decision, dtype: bool

2、选择行

df.iloc[1:3,:]

df[df.age>30]

df[(df.age<35)&(df.decision==True)]

六、Stack和Queue

1、Stack

        堆栈是一种线性数据结构，用于存储一维列表。 它可以以后进先出 (LIFO) 或先进后出 (FILO) 方式存储项目。 堆栈的定义特征是从其中添加和删除元素的方式。 在一端添加一个新元素，仅从该端删除一个元素。

        以下是与堆栈相关的操作：

        isEmpty：如果堆栈为空，则返回 true push：添加一个新元素。 pop：它返回最近添加的元素并将其删除。

        让我们在 Python 中创建一个名为 Stack 的类，我们将在其中定义与堆栈类相关的所有操作。 这个类的代码如下：

class Stack:
     def __init__(self):
         self.items = []
     def isEmpty(self):
         return self.items == []
     def push(self, item):
         self.items.append(item)
     def pop(self):
         return self.items.pop()
     def peek(self):
         return self.items[len(self.items)-1]
     def size(self):
         return len(self.items)

        要将四个元素压入堆栈，可以使用以下代码：

stack=Stack()
stack.push('Red')
stack.push('Green')
stack.push("Blue")
stack.push("Yellow")

stack.pop()
#'Yellow'

stack.isEmpty()
#False

2、Queue

        与栈一样，队列将 n 个元素存储在一维结构中。 元素以先进先出 (FIFO) 格式添加和删除。 队列的一端称为后端，另一端称为前端。 元素从前面移除，这个操作称为出队。 元素添加在后面，操作称为入队。

        上图中的队列可以使用如下代码实现：

class Queue(object):
   def __init__(self):
      self.items = []
   def isEmpty(self):
      return self.items == []
   def enqueue(self, item):
       self.items.insert(0,item)
   def dequeue(self):
      return self.items.pop()
   def size(self):
      return len(self.items)

queue = Queue()
queue.enqueue("Red")
queue.enqueue('Green')
queue.enqueue('Blue')
queue.enqueue('Yellow')

print(f"Size of queue is {queue.size()}")
#Size of queue is 4

print(queue.dequeue())
#Red