python数据类型之列表

已于 2024-05-28 09:29:23 修改
阅读量1.1k 收藏 14
点赞数 25
分类专栏： python知识点 文章标签： python
于 2024-05-25 11:31:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hutaotaotao/article/details/139189134
版权

目录

1.创建列表

2.列表基础操作

常用操作

对列表元素顺序随机打乱

列表下标和切片

字符串分割为列表

列表位移

列表切片替换

3.列表内置方法

4.列表排序

简单排序

使用key参数按指定规则排序

二维列表排序

自定义排序规则函数

5.列表排序算法

选择排序

柱状图动画展示插入排序

插入排序

柱状图动画展示插入排序

6.列表查找算法

线性查找

二分查找

7.引用、浅拷贝和深拷贝

引用（地址相同）

浅拷贝和深拷贝

列表作为函数参数注意事项

注意列表作为实参传递给函数形参是引用

用深浅拷贝处理列表参数

8.多维列表

二维列表：矩阵

三维列表

1.创建列表

用list方法创建

list1 = list()  # 创建一个空列表
list2 = list([2, 3, 4])
list3 = list(["red", "green", "blue"])
list4 = list(range(3, 6))
list5 = list("abcd")
使用更简洁的方法来创建列表 
list1 = []
list2 = [2, 3, 4]
list3 = ["red", "green"]
list4 = [2, "red", 4]  # 列表中可以包含不同类型的元素
进阶创建方法："列表构造表达式" 
list5 = [x for x in range(5)]
list6 = list3 = [x**2 for x in list2 if x < 3]
list6 = [[x, x+1, x**2] for x in list2 if x % 2 == 1]
mylist = [[x, y] for x in range(0, 10, 2) for y in range(1, 10, 2)]  # 生成矩阵
mylist = [[2*x, y+1] 
          for x in range(0, 10, 2) 
          for y in range(1, 10, 2) 
          if x % 2 == 0
          and y % 2 != 0]

2.列表基础操作

常用操作

对列表元素顺序随机打乱

import random

list1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print(list1)  # [4, 5, 2, 1, 3]

列表下标和切片

和字符串类似

myList[-1] = myList[-1 + len(myList)]

注意避免因 < 和 <= 的使用不当造成列表的“越级访问”，就是超过列表长度的访问，它会出现一个运行时的“IndexError”

示例代码

lst = [1, 2, 3, 4, 5]
print(lst[10])

结果报错

IndexError: list index out of range

考虑对“IndexError”异常的处理

lst = [1, 2, 3, 4, 5]
try:
    print(lst[10])
except IndexError:
    print("索引越界")

字符串分割为列表

string = "name xxx ttt" 
list1 = string.split()  # 默认用空格分隔
print(list1)  # ['name', 'xxx', 'ttt']

items = "09/17/2020".split("/")  # 用/分割
print(items)  # ['09', '17', '2020']

s1 = "welcome" 
list2 = s1.split("o")  # 用o分割
print(list2)  # ['welc', 'me']

列表位移

左移 
def left_shift(lst):
    temp = lst[0]
    for i in range(1, len(lst), 1):
        lst[i - 1] = lst[i]
    lst[len(lst) - 1] = temp


data = [1, 2, 3, 4]
left_shift(data)
print(data)   # [2, 3, 4, 1]

右移

def right_shift(lst):
    temp = lst[len(lst) - 1]
    for i in range(len(lst) - 1, 0, -1):
        lst[i] = lst[i - 1]
    lst[0] = temp


data = [1, 2, 3, 4]
right_shift(data)
print(data)   # [4, 1, 2, 3]

或者这样

data = [1, 2, 3, 4]

# 左移
num = 1
lst = data[num:] + data[:num]
print(lst)   # [2, 3, 4, 1]

# 右移
num = 1
lst = data[-num:] + data[:-num]
print(lst)   # [4, 1, 2, 3]

列表切片替换

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:2] = [0, 0]
print(lst)  # [0, 0, 3, 4, 5, 6, 7, 8, 9]

替换注意事项：多增少减

# 多增例子
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:2] = [0, 0, 0, 0, 0]
print(lst)  # [0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 8, 9]

# 少减例子
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:7] = [0, 0, 0]
print(lst)  # [0, 0, 0, 8, 9]
但 lst[i:j:k] = newList 个数不同时会报错 
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:7:2] = [0, 0, 0]   # 0:7:2为0 2 4 6共4个数，[0, 0, 0]为3个数
"""
会报错
ValueError: attempt to assign sequence of size 3 to extended slice of size 4
"""

3.列表内置方法

方法作用
append(x: object): None将元素添加到列表结尾
count(x: object): int返回元素x在列表中的出现次数
extend(lst: list): None将lst中的所有元素追加到列表中
insert(index: int, x:object): None

将元素x插入列表中指定下标处。

注意列表第一个元素的下标是0

pop(index): object

删除给定位置处的元素并返回它。

参数index是可选的，如果没有指定它

那么list.pop()将删除列表最后一个元素并返回它

remove(x: object): None删除列表中第一次出现的x
reverse(): None将列表中的所有元素倒序
sort(): None以升序对列表中的元素排序

示例代码

data = [x for x in range(5)]
print(data)  # [0, 1, 2, 3, 4]

# append方法
data.append(100)
print(data)  # [0, 1, 2, 3, 4, 100]

# count方法
data.append(100)
print(data)  # [0, 1, 2, 3, 4, 100, 100]
print(data.count(100))  # 2
print(data.count(99))   # 0

# extend方法
data.extend([10, 20, 30])
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 30]

# insert方法
data.insert(1, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 30]
data.insert(-1, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]
data.insert(100, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30, 9999]

# pop方法
ret = data.pop(1)
print(ret)   # 9999
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30, 9999]
data.pop()
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]

# data.pop(100)  # IndexError: pop index out of range

# remove方法
data.remove(0)
print(data)  # [1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]
# data.remove(666)  # ValueError: list.remove(x): x not in list

# reverse方法
data.reverse()
print(data)  # [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]

# sort方法
data.sort()
print(data)  # [1, 2, 3, 4, 10, 20, 30, 100, 100, 9999]

data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
data.reverse()
print(data)  # [9999, 100, 100, 30, 20, 10, 4, 3, 2, 1]

4.列表排序

简单排序

# 升序
data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
print(data)  # [1, 2, 3, 4, 10, 20, 30, 100, 100, 9999]

# 降序
data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
data.reverse()
print(data)  # [9999, 100, 100, 30, 20, 10, 4, 3, 2, 1]

data.sort(reverse=True)  # 简洁写法

使用key参数按指定规则排序

# 按照元素第一个元素排序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: x[1])  
print(data)  # ['watermelon', 'lemon', 'apple', 'orange'] 

# 按照元素长度排序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: len(x))  
print(data)  # ['apple', 'lemon', 'orange', 'watermelon']

# 按照元素长度排序的简洁写法
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=len)  
print(data)  # ['apple', 'lemon', 'orange', 'watermelon']

# 按照元素第一个元素排序，降序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: x[1], reverse=True)  
print(data)  # ['orange', 'apple', 'lemon', 'watermelon']

二维列表排序

按照每个子列表的第一个元素升序、第二个元素降序进行排序

# 二维列表
data = [
    [3, 1, 'apple'],
    [1, 2, 'orange'],
    [2, 5, 'banana'],
    [1, 3, 'grape']
]

# 按照每个子列表的第一个元素升序、第二个元素降序进行排序
sorted_list = sorted(data, key=lambda x: (x[0], -x[1]))
# data.sort(key=lambda x: (x[0], -x[1]))

# 打印排序后的结果
for item in sorted_list:
    print(item)

# [1, 3, 'grape']
# [1, 2, 'orange']
# [2, 5, 'banana']
# [3, 1, 'apple']

自定义排序规则函数

例子1：按照第一个元素排序，如果第一个元素相同，则按照第二个元素排序

# 定义一个比较函数，用于排序
def custom_sort(item):
    # 按照第一个元素排序
    first_element = item[0]
    # 如果第一个元素相同，则按照第二个元素排序
    second_element = item[1]
    return first_element, second_element


# 你的二维列表
data = [
    [3, 'apple', 'a'],
    [1, 'orange', 'b'],
    [2, 'banana', 'c'],
    [1, 'grape', 'd'],
    [3, 'pear', 'e']
]

# 使用sorted函数进行排序，传递自定义的比较函数
sorted_list = sorted(data, key=custom_sort)

# 输出排序后的结果
for x in sorted_list:
    print(x)

# [1, 'grape', 'd']
# [1, 'orange', 'b']
# [2, 'banana', 'c']
# [3, 'apple', 'a']
# [3, 'pear', 'e']

例子2：如果第一个元素相同，则按照第二个元素降序排序

# 定义一个比较函数，用于排序
def custom_sort(item):
    # 按照第一个元素升序排序
    first_element = item[0]
    # 按照第二个元素降序排序
    second_element = item[1]
    return first_element, -ord(second_element[0])


# 你的二维列表
data = [
    [3, 'apple'],
    [1, 'orange'],
    [2, 'banana'],
    [1, 'grape'],
    [3, 'pear']
]

# 使用sorted函数进行排序，传递自定义的比较函数
sorted_list = sorted(data, key=custom_sort)

# 输出排序后的结果
for x in sorted_list:
    print(x)
"""
[1, 'orange']
[1, 'grape']
[2, 'banana']
[3, 'pear']
[3, 'apple']
"""

5.列表排序算法

排序算法有很多
这里重点介绍两种简单、直观的排序算法：选择排序和插入排序

选择排序

  • 该算法的思路是先将第一个元素作为最小元素，然后依次将它后面所有元素与它比较，若比它小，则并将其交换（这样一来最小的元素将被排在第一个位置）
  • 然后将第二个元素作为最小元素，跟上面一样，将它后面所有元素与它比较，若比它小，则并将其交换（这样一来第2小的元素将被排在第二个位置）
  • 循环到只剩一个元素 
def selectionSort(lst):
    for i in range(len(lst) - 1):
        currentMin = lst[i]
        currentMinIndex = i

        for j in range(i + 1, len(lst)):
            if currentMin > lst[j]:
                currentMin = lst[j]
                currentMinIndex = j

        if currentMinIndex != i:
            lst[currentMinIndex] = lst[i]
            lst[i] = currentMin


def main():
    lst = [1, 9, 4.5, 10.6, 5.7, -4.5]
    selectionSort(lst)
    print(lst)


main()  # [-4.5, 1, 4.5, 5.7, 9, 10.6]

柱状图动画展示插入排序

# 柱状图：选择排序动画
from tkinter import *
import tkinter.messagebox
import random


class StepControl:
    def __init__(self):
        self.list = [x for x in range(1, 20 + 1)]
        self.reset()
    def reset(self):
        self.i = -1
        self.done = False
        random.shuffle(self.list)
        self.drawAStep()
    def step(self):
        if self.done:
            tkinter.messagebox.showinfo("showinfo", "列表已经排好升序")
            return # 没有这个 return 的话消息框要点两次才会消失
        if self.i == -1:
            self.i += 1
        self.drawAStep()

        if self.i >= len(self.list) - 1:
            self.done = True
            tkinter.messagebox.showinfo("showinfo", "列表已经排好升序")
        else:
            currentMin = self.list[self.i]
            currentIndex = self.i

            for j in range(self.i + 1, len(self.list)):
                if self.list[j] < currentMin:
                    currentMin = self.list[j]
                    currentIndex = j

            if currentIndex != self.i:
                self.list[currentIndex] = self.list[self.i]
                self.list[self.i] = currentMin

            self.i += 1
    def drawAStep(self):
        bottomGap = 10
        canvas.delete("line")
        canvas.create_line(10, height - bottomGap, width - 10, height - bottomGap, tags = "line")
        barWidth = (width - 20) / len(self.list)

        maxCount = int(max(self.list))

        for i in range(len(self.list)):
            canvas.create_rectangle(10 + i * barWidth,
                    (height - bottomGap) * (1 - self.list[i] / (maxCount + 4)),
                    10 + (i + 1) * barWidth,
                    height - bottomGap, tags = "line"
                    )

            canvas.create_text(10 + i * barWidth + barWidth / 2,
                            (height - bottomGap) * (1 - self.list[i] / (maxCount + 4)) - 8,
                            text = str(self.list[i]), tags = "line"
                            )
        if self.i >= 0:
            canvas.create_rectangle(10 + self.i * barWidth,
                        (height - bottomGap) * (1 - self.list[self.i] / (maxCount + 4)),
                        10 + (self.i + 1) * barWidth,
                        height - bottomGap, fill = "red", tags="line"
                        )


def step():
    control.step()


def reset():
    control.reset()


window = Tk()
window.title("选择排序动画")

width = 340
height = 150

canvas = Canvas(window, width=width, height=height, )
canvas.pack()

frame = Frame(window)
frame.pack()

Button(frame, text="Step", command=step).pack(side=LEFT)
Button(frame, text="Reset", command=reset).pack(side=LEFT)

control = StepControl()
control.drawAStep()

window.mainloop()

插入排序

该算法的思路是是重复地将一个新元素插入到一个已排好序的子列表中，直到整个列表排好序 
def insertionSort(lst):
    for i in range(1, len(lst)):
        currentValue = lst[i]
        k = i - 1
        
        while k >= 0 and lst[k] > currentValue:
            lst[k + 1] = lst[k]
            k -= 1
            
        lst[k + 1] = currentValue


def main():
    lst = [1, 9, 4.5, 10.6, 5.7, -4.5]
    insertionSort(lst)
    print(lst)  # [-4.5, 1, 4.5, 5.7, 9, 10.6]


main()

柱状图动画展示插入排序

# 柱状图：插入排序动画
from tkinter import *
import tkinter.messagebox
import random


class StepControl:
    def __init__(self, width, height, canvas):
        self.width = width
        self.height = height
        self.canvas = canvas

        self.list = [x for x in range(1, 20 + 1)]
        self.reset()

    def reset(self):
        self.i = -1
        self.done = False
        random.shuffle(self.list)
        self.drawAStep()

    def start(self):
        if self.done:
            tkinter.messagebox.showinfo("showinfo", "列表已经排好升序")
            return # 没有这个 return 的话消息框要点两次才会消失
        if self.i == -1:
            self.i += 1

        self.drawAStep()

        if self.i >= len(self.list) - 1:
            self.done = True
            tkinter.messagebox.showinfo("showinfo", "列表已经排好升序")
        else:
            self.i += 1
            currentValue = self.list[self.i]
            k = self.i - 1
            while k >= 0 and self.list[k] > currentValue:
                self.list[k + 1] = self.list[k]
                k -= 1

            self.list[k + 1] = currentValue

    def drawAStep(self):
        width = self.width
        height = self.height
        canvas = self.canvas

        bottomGap = 10
        barWidth = (width - 20) / len(self.list)

        maxCount = int(max(self.list))

        canvas.delete("line")
        canvas.create_line(10, height - bottomGap, width - 10, height - bottomGap, tags = "line")

        for i in range(len(self.list)):
            canvas.create_rectangle(10 + i * barWidth, (height - bottomGap) * (1 - self.list[i] / (maxCount + 4)),
                                    10 + (i + 1) * barWidth, (height - bottomGap),
                                    tags = "line")
            canvas.create_text(10 + i * barWidth + barWidth / 2,
                                (height - bottomGap) * (1 - self.list[i] / (maxCount + 4)) - 8,
                                text = str(self.list[i]), tags="line")
        if self.i >= 0:
            canvas.create_rectangle(10 + self.i * barWidth,
                                    (height - bottomGap) * (1-self.list[self.i]/(maxCount+4)),
                                    10 + (self.i + 1) * barWidth,
                                    height - bottomGap,
                                    fill="red", tags="line")


# 定义窗体类：来展示主界面窗口
class Window:
    def __init__(self):
        self.window = Tk()
        self.window.title("插入排序动画")
        self.window.geometry("600x400+0+0")
        self.width = 340
        self.height = 150
        self.canvas = Canvas(self.window, width= self.width, height=self.height)
        self.canvas.pack()

        #################################
        self.control = StepControl(self.width, self.height, self.canvas) # 类中创建类
        #################################

        self.frame = Frame(self.window)
        self.frame.pack()

        Button(self.frame, text="Start", command=self.start).pack(side=LEFT)
        Button(self.frame, text="Reset", command=self.reset).pack(side=LEFT)

        self.window.mainloop()

    def start(self):
        self.control.start()

    def reset(self):
        self.control.reset()


Window()

6.列表查找算法

查找最常见的两种方法是二分查找和线性查找
如果一个列表是排好序的，那么要查找列表中的某个元素，二分查找比线性查找更有效

线性查找

原理是暴力查找，依顺序将要查找的那个元素与列表的每一个元素进行比较 
# -*- coding: utf-8 -*-

def linear_search(lst, key):
    result = []
    for i in range(len(lst)):
        if key == lst[i]:
            result.append(i)
    return result


data = [1, 3, 4, 2, 4, -3, 6, 2]

a = linear_search(data, 4)
b = linear_search(data, -4)
c = linear_search(data, 3)

print(a)  # [2, 4]
print(b)  # []
print(c)  # [1]

二分查找

对大型列表而言，二分查找法更高效，但是它们需要列表是提前排好序的。

工作原理是，从数组的中间元素开始比较，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到该元素。二分查找的每一次比较都使搜索范围缩小一半，因此其效率较高。

二分查找的时间复杂度是O(log n)，其中n是数组中的元素数量。这意味着在最坏的情况下，需要比较的次数与数组的深度（以2为底数）成对数关系。

# -*- coding: utf-8 -*-

def binary_search(lst, key):
    low = 0
    high = len(lst) - 1
    while high >= low:
        mid = (low + high) // 2
        if key < lst[mid]:
            high = mid - 1
        elif key > lst[mid]:
            low = mid + 1
        else:
            return mid
    return -(low + 1)


# –(low + 1)中“-”表示查找不到这个元素，“low + 1”表示应该插入的位置，low + 1 = 1 话表示索引为 0 的位置
data = [1, 3, 4, 2, 4, -3, 6, 2]
data.sort()
print(data)  # [-3, 1, 2, 2, 3, 4, 4, 6]

i = binary_search(data, 4)
j = binary_search(data, -4)
k = binary_search(data, 3)
print(i)  # 5
print(j)  # -1
print(k)  # 4

7.引用、浅拷贝和深拷贝

引用（地址相同）

引用就是与原来变量为同一个内存地址

在python列表中，用=号复制的列表的 id 与原列表相同

# -*- coding: utf-8 -*-

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
print(id(lst1) == id(lst2))   # False 说明地址不同

lst2 = lst1
print(id(lst1) == id(lst2))   # True 现在lst2 和lst1指向同一块地址
print(lst1)  # [1, 2, 3]
print(lst2)  # [1, 2, 3]


# 现在修改lst1，然后查看lst2是否会变化
lst1[0] = 99
print(lst1)  # [99, 2, 3]
print(lst2)  # [99, 2, 3]

浅拷贝和深拷贝

  • 浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。
  • 深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。
浅拷贝：只能保证第一层不会被改变 
# -*- coding: utf-8 -*-

lst = [1, 2, 3, 4, 5]
lst1 = lst  # 引用
lst2 = lst.copy()  # 浅拷贝：保证第一层不会被改变

print(id(lst) == id(lst1))   # True
print(id(lst) == id(lst2))   # False
print(id(lst1) == id(lst2))  # False


lst[3] = 10000
print(lst)  # [1, 2, 3, 10000, 5]
print(lst1)  # [1, 2, 3, 10000, 5]
print(lst2)  # [1, 2, 3, 4, 5]
深拷贝：保证内层所有层不会被改变 
# -*- coding: utf-8 -*-

import copy

lst = [[1, 2], [3, 4]]
lst1 = lst.copy()    # 浅拷贝
lst2 = copy.deepcopy(lst)  # 深拷贝

print(id(lst), id(lst1), id(lst2))  
# 2096876497224 2096876497160 2096876497096

lst[0][0] = 100
print(lst)  # [[100, 2], [3, 4]]
print(lst1)  # [[100, 2], [3, 4]]
print(lst2)  # [[1, 2], [3, 4]]

列表作为函数参数注意事项

注意列表作为实参传递给函数形参是引用

列表用=赋值是引用。列表作为形参赋值给形参后，在函数内部若对形参进行了值修改，则原实参那个列表内容会发生改变。这一点需要非常注意，避免在调用函数后原列表发生改变，出现意外错误。

# -*- coding: utf-8 -*-

def m(number, numbers):
    number = 1001
    numbers[0] = 5555


def main():
    x = 1
    y = [1, 2, 3]
    m(x, y)
    print("x = ", x)
    print("y[0] = ", y[0])


main()
"""
结果
x = 1
y[0] = 5555
注意 x 未发生改变，而列表发生了改变，这是因为 y 和 numbers 都指向同一个列表对象
"""

用深浅拷贝处理列表参数

# -*- coding: utf-8 -*-

import copy


def test_list(m_list):
    # 调用函数时test_list(x)就是做了m_list=x这么一个赋值操作
    m_list[0] = 99
    return m_list


def test_list2(m_list):
    temp_list = m_list.copy()   # 浅拷贝
    temp_list[0] = 99
    return temp_list


def test_list3(m_list):
    temp_list = m_list.copy()  # 浅拷贝
    print(temp_list)
    temp_list[1] = [7, 8, 9]   # 改变第一层的值
    temp_list[0][0] = 88    # 改变第二层的值
    return temp_list


def test_list4(m_list):
    temp_list = copy.deepcopy(m_list)  # 深拷贝
    print(temp_list)
    temp_list[1] = [7, 8, 9]   # 改变第一层的值
    temp_list[0][0] = 88    # 改变第二层的值
    return temp_list


if __name__ == "__main__":
    # 1.列表赋值是引用，与原列表是同一个对象
    x = [1, 2, 3]
    y = x
    x[0] = 100
    print(y)   # [100, 2, 3]
    print(id(x) == id(y))  # True # 地址相同说明是同一个对象
    
    # 2.函数将实参传递给形参时是赋值
    x = [1, 2, 3]
    re_list = test_list(x)
    print(re_list)  # [99, 2, 3]
    print(x)  # [99, 2, 3]
    
    # 3.用浅拷贝解决列表做参数时改变原列表值的问题
    x = [1, 2, 3]
    re_list = test_list2(x)
    print(re_list)  # [99, 2, 3]
    print(x)  # [1, 2, 3]
    
    # 4.浅拷贝的局限：只能保证第一层不会变
    x = [[1, 2, 3], [4, 5, 6]]
    re_list = test_list3(x)
    print(re_list)  # [[88, 2, 3], [7, 8, 9]]
    print(x)  # [[88, 2, 3], [4, 5, 6]]
    
    # 5.用深拷贝保证所有层都不变
    x = [[1, 2, 3], [4, 5, 6]]
    re_list = test_list4(x)
    print(re_list)  # [[88, 2, 3], [7, 8, 9]]
    print(x)  # [[1, 2, 3], [4, 5, 6]]

8.多维列表

二维列表：矩阵

二维列表是将其他列表作为它元素的列表
二维列表可以用来存储矩阵中的数据，也就是存储二维数据

将矩阵数据转化为列表 
# -*- coding: utf-8 -*-

from random import randint

matrix = []
number_of_rows = 3
number_of_columns = 3

for row in range(number_of_rows):
    matrix.append([])
    for column in range(number_of_columns):
        # value = eval(input("请输入矩阵第{}行第{}列的值：".format(row, column)))
        value = randint(0, 99)
        matrix[row].append(value)

print(matrix)
二维列表遍历 
# -*- coding: utf-8 -*-

# 可以这样
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in range(len(matrix)):
    for column in range(len(matrix[row])):
        print(matrix[row][column], end=" ")
    print()

# 也可以这样
for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

二维列表求和

# -*- coding: utf-8 -*-


# 对所有元素求和
def sum_matrix(matrix):
    total = 0
    for row in matrix:
        for value in row:
            total += value
    return total


# 按列求和
def sum_matrix_column(matrix):
    sum_column_list = []
    for column in range(len(matrix[0])):
        sum_column = 0
        for row in range(len(matrix)):
            sum_column += matrix[row][column]
        sum_column_list.append(sum_column)
    return sum_column_list


# 找出和最大的行
def max_sum_row(matrix):
    max_value = sum(matrix[0])
    max_index = 0
    for row in range(1, len(matrix)):
        if sum(matrix[row]) > max_value:
            max_value = sum(matrix[row])
            max_index = row
    return max_value, max_index


data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(sum_matrix(data))  # 45
print(sum_matrix_column(data))  # [12, 15, 18]
print(max_sum_row(data))  # (24, 2)
随意打乱一个矩阵 
# -*- coding: utf-8 -*-


from random import randint


def shuffle_matrix(matrix):
    for row in range(len(matrix)):
        for column in range(len(matrix[row])):
            i = randint(0, len(matrix) - 1)
            j = randint(0, len(matrix[row]) - 1)
            matrix[row][column], matrix[i][j] = matrix[i][j], matrix[row][column]


data = [[1,2,3], [4,5,6], [7,8,9]]
shuffle_matrix(data)
print(data)
排序
直接使用 sort 方法可以对一个二维列表排序 
# -*- coding: utf-8 -*-


data = [[8, 1, 3], [6, 7, 4], [6, 3, 4], [9, 5, 2]]
data.sort()
print(data)   # [[6, 3, 4], [6, 7, 4], [8, 1, 3], [9, 5, 2]]

可以看到它像一维列表排序一样，将每个元素(列表)比较大小，比如[8, 1, 3]和[6, 7, 4]，从第一个元素依次比较，直到分出大小。

但是我们有时想按指定规则排序，参考前面的列表排序。

矩阵转置 
grid = [
    ['.', '.', '.', '.', '.', '.'],
    ['.', 'O', 'O', '.', '.', '.'],
    ['O', 'O', 'O', 'O', '.', '.'],
    ['O', 'O', 'O', 'O', 'O', '.'],
    ['.', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'O', 'O', 'O', 'O', '.'],
    ['O', 'O', 'O', 'O', '.', '.'],
    ['.', 'O', 'O', '.', '.', '.'],
    ['.', '.', '.', '.', '.', '.']
]


def transpose(matrix):
    new_matrix = [[0]*len(matrix) for i in range(len(matrix[0]))]
    # print(new_matrix)
    for column in range(len(matrix[0])):
        for row in range(len(matrix)):
            print(matrix[row][column], end="")
            new_matrix[column][row] = matrix[row][column]
        print()

    return new_matrix


new_grid = transpose(grid)
print("----------------------------")
for item in new_grid:
    print(item)

"""
..OO.OO..
.OOOOOOO.
.OOOOOOO.
..OOOOO..
...OOO...
....O....
----------------------------
['.', '.', 'O', 'O', '.', 'O', 'O', '.', '.']
['.', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '.']
['.', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '.']
['.', '.', 'O', 'O', 'O', 'O', 'O', '.', '.']
['.', '.', '.', 'O', 'O', 'O', '.', '.', '.']
['.', '.', '.', '.', 'O', '.', '.', '.', '.']
"""

三维列表

二维列表是将一维列表作为元素的列表
三维列表是将二维列表作为元素的列表
以此类推

end

hutaotaotao
关注
  • 25
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python返回列表数据类型_python 数据类型之列表（list）
weixin_28832121的博客
12-29 6206
一、表达方式1、英文[]表示2、列表内部可以存储任意类型的数据3、可变的有序序列二、常用函数1、type()：查询变量的类型，如type(["name", "sex", "age"]) = list2、len()：查询列表的长度，如len(["name", "sex", "age"]) = 33、min()：返回列表中的最小值，如min([1, 3, 5, 8]) = 1，字符串同样适用4、max...
Python数据类型详细介绍
m0_61232019的博客
03-27 1万+
一、数字（Number） 1. int （整型，长整型） 2. float (浮点型） 3. complex（复数） 二、布尔（Boolean） 三、字符串类型（String） 四、列表 1. 创建列表 2. 列表的索引 3. 列表的切片 4. 列表加法和乘法 5.列表的修改 6. 列表的删除 7. 列表追加、插入和扩展 8. 列表元素查找 9. 列表相关的相关内置函数 10.多维列表 五、元组 1. 元组相关概述 2. 元组修改 3. 元组删除
26. Python数据类型之列表
weixin_63986098的博客
09-03 3321
4.1 用`[ ]`新建一个空列表 4.2 列表的元素全部为整数 4.3 列表的元素全部为浮点数 4.4 列表的元素全部为字符串 4.5 列表的元素为混合型
Python数据类型——列表
静水流深，不显不露，喜欢迎难而上！
01-15 2865
前言 列表是python中最常用的数据类型，列表中的元素（又称数据项）不需要具有相同的类型，列表是可变数据类型，里面的元素用逗号隔开。常用操作方法有，添加、删除、修改、，还可以对列表进行遍历、排序、反转等。 目录 前言 一、列表的基本操作 1.查找 2.添加 3.修改 4.删除 5.反转、排序和复制 一、列表的基本操作 1.查找 index（）：返回指定数据所在位置的下标 语法：列列表序列.index(数据, 开始位置下标, 结束位置下标) count（）：返回列表中出现元素的
Python的数据类型
昊大侠的博客
04-02 6848
目录数据类型与数据结构数据类型数据结构举例基础结构运行特点 数据类型与数据结构 定义 数据类型 = 数据 + 处理方式 数据类型是一个元素的集合和定义在这个元素集合上的一组操作的总称 数据结构 = 数据 + 组成方式 数据结构是相互之间存在一种或多种特定关系的数据元素的集合 结论 数据类型包含数据结构 数据类型 Python 中有六个标准数据类型 1. 数字 Number 2. 字符串 String 3. 列表 List 4. 元组 Tuple 5. 字典 Dict
python数据类型怎么定义_Python
weixin_39608134的博客
11-23 2247
前言在Python 中定义了五种标准数据类型，具体有：• Numbers（数字）• String（字符串）• List（列表）• Tuple（元组）• Dictionary（字典）不同的数据类型用于存储不同种类的数据，例如数字型用于存储年龄，字符串用于存储姓名等。本节主要了解 Python 五大数据类型的基本定义及格式，具体怎么灵活使用后面会有单独的文章讲解！Python 数字类型数字数据类型用于...
Python 数据类型判断
u011699626的博客
09-15 1万+
Python 数据类型判断
Python数据类型转换
独乐乐不如众乐乐。
10-28 2万+
Python数据类型转换1. Python的数据类型2. Python数据类型转换2.1 自动类型转换2.2 强制类型转换2.2.1 其他转字符串 1. Python的数据类型 上一遍博文已经详细地介绍了Python的数据类型，详见链接Python的变量命名及数据类型。 在这里总结一下Python的数据类型： 字符串类型 String 数字类型 Number： 整形 int 浮点型 float 复数 complex 布尔类型 Bool 列表类型 List 元组类型 Tuple 字典类型 Dictionar
python内置数据类型char_Python数据类型
weixin_39900286的博客
12-10 4295
Python的数据类型：1、字符串2、布尔类型3、整数4、浮点数5、数字6、列表7、元组8、字典9、日期1.字符串str = "char" --> 这是一组字符串print(str) --> 屏幕输出字符串也可以用单引号：str = ‘char‘print(str) --> 输出结果以及含义是一样的利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号...
python七种数据类型
热门推荐
博客首页
05-12 4万+
概述 python数据类型主要分为以下七大类： Numbers（数字） Boolean（布尔） String（字符串） List（列表） Tuple（元组） Dictionary（字典） Set（集合） Python 的七个标准数据类型中： 不可变数据类型（4 个）：Number（数字）、Boolean（布尔）、String（字符串）、Tuple（元组）； 可变数据类型（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 可变数据类型的内容可以随着函数的执行发生变化，而不可变数据类
深入了解Python数据类型之列表
09-21
下面小编就为大家带来一篇深入了解Python数据类型之列表。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Python数据类型之列表的进阶操作
12-22
Python数据类型之列表的进阶操作 遍历 重复性的内容需要按照步骤，分步式的读取出来 对文件内容已经有相似结构的循环读取 for循环 魔法推导式 常见的错误：缩进错误、遗漏冒号 创建数值列表 range(参数1，参数2，...
Python数据类型之列表和元组的方法实例详解
09-19
主要介绍了Python数据类型之列表和元组的相关知识，列表是一组有序项目的集合 ,可变的数据类型可 进行增删改查，本文通过实例文字相结合的形式给大家介绍的非常详细 ,需要的朋友可以参考下
Python数据类型之List列表实例详解
09-19
主要介绍了Python数据类型之List列表,结合实例形式分析了PythonList列表的概念、功能、定义以及判断、截取、遍历、切片等常见操作技巧,需要的朋友可以参考下
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1420
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 807
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Java——简单图书管理系统
m0_74100417的博客
06-09 1617
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
YesPMP探索Python在生活中的应用，助力提升开发效率
YesPMP20的博客
06-13 768
Python是一种简单易学、高效强大的编程语言，正变成越来越多人选择的热门技能。学习Python不仅可以提供更多就业机会，还能让自己在职场更加有竞争力，那可以去哪里拓展自己的技能呢？
Python | Leetcode Python题解之第149题直线上最多的点数
Mopes__的博客
06-14 463
Python | Leetcode Python题解之第149题直线上最多的点数
python内置数据类型列表
11-01
Python内置数据类型之一是列表（List），它是一种有序的集合，可以存储不同类型的元素，包括数字、字符串、布尔值等。列表可以通过方括号[]来创建，也可以通过list()函数来创建。列表中的元素可以通过索引访问，索引从0开始，也可以使用负数索引从列表末尾开始访问。列表还支持切片操作，可以通过切片来获取列表的子集。此外，列表还有许多内置函数和方法，如len()函数用于获取列表长度，append()方法用于在列表末尾添加元素，sort()方法用于对列表进行排序等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值