Python序列类型

已于 2023-11-24 17:08:44 修改
阅读量849 收藏 15
点赞数 23
分类专栏： Python 文章标签： python序列类型 python列表切片 python元组切片 python元组和列表的区别 python列表常用方法 python元组常用方法 python范围常用方法
于 2023-11-24 17:05:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39706570/article/details/134466051
版权

目录

目标

版本

官方文档

序列分类

对比

list（列表）

创建

循环

常用方法

切片

tuple（元组）

创建

循环 

常用方法

切片

range（范围）

创建

循环

常用方法

切片

优势

目标

        掌握Python序列类型（list、tuple、range）的常用方法（创建、循环、查询、删除、切片等）。

版本

        Python 3.12.0

官方文档

Sequence Types — list, tuple, rangeicon-default.png?t=N7T8https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range

序列分类

定义

        在Python中，序列是一种基本的数据类型，用于表示有序的元素集合。序列中的每个元素都有一个唯一的索引，从0开始递增。

官方定义

Sequence Types — list, tuple, range

There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of binary data and text strings are described in dedicated sections.

译文

        有三种基本序列（实际上字符串也是序列类型，但是字符串有很多自己特有的方法。所以官方可能为了文档排版，没有将字符串写入到序列类型板块。），分别是：

  1. list（列表）
  2. tuple（元组）
  3. range（范围）

对比

特性列表 (List)元组 (Tuple)范围 (Range)
是否可变可变不可变不可变
表达方式[1,2,3](1,2,3)、(1,)range(start,stop,step)
Java 类似对象ArrayList无无
主要用途存储可变序列存储不可变序列表示数字范围
索引和切片可以通过索引和切片访问和修改元素可以通过索引访问元素，但不可修改可以通过索引访问元素，但不可修改
适用场景当需要频繁修改序列时使用当希望创建不可变的序列时使用当表示数字范围时使用

list（列表）

创建

方法一（直接创建）

#直接创建
allList=["Tom",True,False,3.14,500]
#输出：['Tom', True, False, 3.14, 500]
print(allList)

方法二（通过迭代对象，使用构造方法创建。）

先来看一下官方文档对list构造方法的描述：

def __init__(self, seq=()): # known special case of list.__init__
    """
    Built-in mutable sequence.
    
    If no argument is given, the constructor creates a new empty list.
    The argument must be an iterable if specified.
    # (copied from class doc)
    """
    pass

翻译

  1. list构造方法有一个参数，默认这个参数是空的元组，即表示不填写参数将默认创建一个空列表。
  2. 该参数必须是可迭代的，比如：list、tuple、string、set、dictionary、文件对象、迭代器对象。

案例

#参数是字符串
myList=list("I LOVE YOU.")
#输出：['I', ' ', 'L', 'O', 'V', 'E', ' ', 'Y', 'O', 'U', '.']
print(myList)

#参数是元组
myList=list((1,2,'a',True))
#输出：[1, 2, 'a', True]
print(myList)

#参数是列表
myList=list([1,2,'a',True])
#输出：[1, 2, 'a', True]
print(myList)

#参数是集合
myList=list({2,'a',True,False,"1",0})
#输出：[False, True, 2, '1', 'a']
#注意：集合中的元素不能重复，True和False分别会被看成是1和0，所以0没有被输出。
print(myList)

#参数是字典
dic={"name":"Tome","age":13,"sex":True}
myList=list(dic.keys())
#输出：['name', 'age', 'sex'] ['Tome', 13, True]
print(list(dic.keys()),list(dic.values()))

方法三（根据文件对象创建列表）

#我桌面有个a.txt文件
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = file.readlines()
#输出：['1\n', '2\n', '3\n', '4\n', '5\n', 'False\n', 'True\n', '2.13\n', 'Tom']
print(myList)

#去掉\n
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = [line.strip() for line in file.readlines()]
print(myList)

方法四（根据迭代器对象创建列表）

#创建一个迭代器对象
myIterator = iter([1, False, True, "Tom", 5])
myList = list(myIterator)
#输出：[1, False, True, 'Tom', 5]
print(myList)

yourIterator = iter([1, False, True, "Tom", 5])
#使用列表推导式创建列表
yourList = [x for x in yourIterator]
#输出：[1, False, True, 'Tom', 5]
print(yourList)

循环

方法一（for循环）

myList = ["Tom", "Jack", 3.14, True]
for item in myList:
    print(item)

方法二（enumerate() 函数）

myList = ["Tom", "Jack", 3.14, True]
for index,value in enumerate(myList):
    print(f"下标={index}；值={value}")

方法三（while循环）

myList = ["Tom", "Jack", 3.14, True]
index=0
while index<len(myList):
    print(myList[index])
    index=index+1

方法四（迭代器遍历）

myList = ["Tom", "Jack", 3.14, True]
myIter = iter(myList)
#输出：<class 'list_iterator'>
print(type(myIter))
while True:
    try:
        print(next(myIter))
    except StopIteration:
        #结束循环
        break;

常用方法

在列表末尾添加元素

myList = ["Tom", "Jack", 3.14, True]
myList.append("Cat")

将可迭代对象中的元素依次添加到列表中

myList = ["Tom", "Jack", 3.14, True]
#这里以set为例
myList.extend({"23","a"})
#输出：['Tom', 'Jack', 3.14, True, '23', 'a']
print(myList)

将元素插入到指定的下标位置

myList = ["Tom", "Jack", 3.14, True]
#把love插入到下标为2的位置
myList.insert(2,"love")
#输出：['Tom', 'Jack', 'love', 3.14, True]
print(myList)

移除列表中第一个元素值=value的元素

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
myList.remove("Jack")
#输出：['Tom', 3.14, True, 'Jack', False]
print(myList)

移除列表中的元素并返回元素（默认移除最后一个元素）

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
item=myList.pop(2)
#输出：['Tom', 'Jack', True, 'Jack', False]
print(myList)
#输出：3.14
print(item)


nameList = ["Tom", "Jack"]
#默认移除最后一个元素
name=nameList.pop()
#输出：['Tom']
print(nameList)
#输出：Jack
print(name)

移除所有元素

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
myList.clear()
#输出：[]
print(myList)

返回第一个值为value的索引，可以设定范围。

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
item=myList.index("Jack")
#输出：1
print(item)

item=myList.index("Jack",1)
#输出：1
print(item)

item=myList.index("Jack",2)
#输出：4
print(item)

item=myList.index("Jack",4,5)
#输出：4
print(item)

统计某元素在列表中出现的次数

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
count=myList.count("Jack")
#输出：2
print(count)

排序

升序排序

numList=[6,2,1,5,4,3]
numList.sort()
#输出：[1, 2, 3, 4, 5, 6]
#分析：默认升序排序
print(numList)

降序排序

numList=[6,2,1,5,4,3]
#分析：设置降序排序
numList.sort(reverse=True)
#输出：[6, 5, 4, 3, 2, 1]
print(numList)

区分字母大小写排序

fruitList = ['apple', 'Banana', 'orange', 'Grapes', "Strawberry", "Cherry", "Peach", "Mango", "Watermelon"]
#输出：['Banana', 'Cherry', 'Grapes', 'Mango', 'Peach', 'Strawberry', 'Watermelon', 'apple', 'orange']
#分析：'apple', 'orange'排在后面，是因为这两个元素以小写开头。
fruitList.sort()
print(fruitList)

不区分字母大小写排序

fruitList = ['apple', 'Banana', 'orange', 'Grapes', "Strawberry", "Cherry", "Peach", "Mango", "Watermelon"]

#设置列表中的字符串按照小写形式进行比较，实现对字符串的不区分大小写排序。
fruitList.sort(key=str.lower)
#输出：['apple', 'Banana', 'Cherry', 'Grapes', 'Mango', 'orange', 'Peach', 'Strawberry', 'Watermelon']
print(fruitList)

#设置列表中的字符串按照小写形式进行比较，实现对字符串的不区分大小写排序。并且降序排序。
fruitList.sort(key=str.lower,reverse=True)
#输出：['Watermelon', 'Strawberry', 'Peach', 'orange', 'Mango', 'Grapes', 'Cherry', 'Banana', 'apple']
print(fruitList)

自定义排序

myList = ["王五", None, "张三", "李四", "赵六"]
#这里定义一个字典，来设置排序规则，指定元素的顺序。
order = {"张三": 0, "李四": 1, "王五": 2, "赵六": 3}

#分析：lambda函数的作用是，当列表中的元素x在字典 order 中存在时，返回对应的值（指定的顺序），如果x在字典中不存在，则返回正无穷大。
myList.sort(key=lambda x: order.get(x, float('inf')))
#输出：['张三', '李四', '王五', '赵六', None]
print(myList)

#使用自定义排序规则进行反向排序
myList.sort(key=lambda x: order.get(x, float('inf')),reverse=True)
#输出：[None, '赵六', '王五', '李四', '张三']
print(myList)

反转元素

myList = ["王五", None, "张三", "李四", "赵六"]
myList.reverse()
#输出：['赵六', '李四', '张三', None, '王五']
print(myList)

浅拷贝

列表浅拷贝会创建新的列表对象，但是新的列表中的元素引用了旧的列表中的元素。所以说，浅拷贝创建的对象不是一个完全独立的副本。特别注意：如果旧列表中的元素是不可变对象（如整数、字符串等）则修改旧列表元素的值，新列表不会有变化。反之，如果则新列表会跟随变化。

myList = ["王五", None, "张三", "李四", "赵六"]
yourList=myList.copy()
#输出：['王五', None, '张三', '李四', '赵六']
print(yourList)
#输出两个不同的id
print(id(myList),id(yourList))
#输出相同的id
print(id(myList[0]),id(yourList[0]))

myList[0]="钱七"
print(myList)
print(yourList)
#输出不相同的id
print(id(myList[0]),id(yourList[0]))

otherList=[[1,2,3],[4,5,6]]
copyOtherList=otherList.copy()
otherList[0][0]=9
#输出：[[9, 2, 3], [4, 5, 6]]
print(otherList)
#输出：[[9, 2, 3], [4, 5, 6]]
print(copyOtherList)

深拷贝

深拷贝创建的对象是一个完全独立的副本。这里不做测试，如果大家想测试的话，可以按照上述浅拷贝的方法去测试。

import copy

myList = ["王五", None, "张三", "李四", "赵六"]
yourList = copy.deepcopy(myList)
print(yourList)

切片

即从原来的列表获取子列表。格式为：list[start:stop:step]。start表示切片起始索引，默认为0。stop表示切片结束索引（不包含stop），默认为len(list)。step表示步长，默认步长为1。步长可以为负整数（表示反向切片），但不能为0。如果start>=stop，则返回空集合。

用法案例

myList = [0,1,2,3,4,5,6,7,8,9]
yourList = myList[2:5]
#输出：[2, 3, 4]
print(yourList)

yourList = myList[2:8:2]
#输出：[2, 4, 6]
print(yourList)

#等同于：myList[2::]
yourList = myList[2:]
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[:2:]
#输出：[0, 1]
print(yourList)

yourList = myList[::3]
#输出：[0, 3, 6, 9]
print(yourList)

yourList = myList[::]
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[::]
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[-2:-1:]
#输出：[8]
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(yourList)

yourList = myList[::-1]
#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#分析：步长为负数表示反向步长切片。
print(yourList)

使用场景

（1）复制列表

以下案例证明了通过切片复制来的列表是浅拷贝模式。参考上述我对浅拷贝的描述。

myList = ["王五", None, "张三", "李四", "赵六"]
#等同于：myList[::]
yourList=myList[:]
#输出：['王五', None, '张三', '李四', '赵六']
print(yourList)
#输出两个不同的id
print(id(myList),id(yourList))
#输出相同的id
print(id(myList[0]),id(yourList[0]))

myList[0]="钱七"
print(myList)
print(yourList)
#输出不相同的id
print(id(myList[0]),id(yourList[0]))

otherList=[[1,2,3],[4,5,6]]
copyOtherList=otherList.copy()
otherList[0][0]=9
#输出：[[9, 2, 3], [4, 5, 6]]
print(otherList)
#输出：[[9, 2, 3], [4, 5, 6]]
print(copyOtherList)

tuple（元组）

（1）官方描述

Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the enumerate() built-in). Tuples are also used for cases where an immutable sequence of homogeneous data is needed (such as allowing storage in a set or dict instance).

译文

  1. 元组是不可变序列。
  2. 元组的元素可以是不同类型。

（2）官方描述（重点）

Using a trailing comma for a singleton tuple: a, or (a,)

译文

只有一个元素的元组，这个元素后面要加逗号。演示案例如下：

a=(8)
b=(8,)
#输出：<class 'int'>
print(type(a))
#输出：<class 'tuple'>
print(type(b))

a=("Hello World.")
b=("Hello World.",)
#输出：<class 'str'>
print(type(a))
#输出：<class 'tuple'>
print(type(b))

创建

方法一（直接创建）

myTuple=(1,2,3,True,2,"Hello World!")
#输出：(1, 2, 3, True, 2, 'Hello World!')
print(myTuple)

方法二（通过迭代对象，使用构造方法创建。）

#参数是字符串
myTuple=tuple("I LOVE YOU.")
#输出：('I', ' ', 'L', 'O', 'V', 'E', ' ', 'Y', 'O', 'U', '.')
print(myTuple)

#参数是元组
myTuple=tuple((1,2,'a',True))
#输出：(1, 2, 'a', True)
print(myTuple)

#参数是列表
myTuple=tuple([1,2,'a',True])
#输出：(1, 2, 'a', True)
print(myTuple)

#参数是集合
myTuple=tuple({2,'a',True,False,"1",0})
#输出：(False, True, 2, '1', 'a')
#注意：集合中的元素不能重复，True和False分别会被看成是1和0，所以0没有被输出。
print(myTuple)

#参数是字典
dic={"name":"Tome","age":13,"sex":True}
myTuple=tuple(dic.keys())
#输出：('name', 'age', 'sex') ('Tome', 13, True)
print(tuple(dic.keys()),tuple(dic.values()))

方法三（根据文件对象创建元组）

#我桌面有个a.txt文件
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myTuple = tuple(file)
#输出：('1\n', '2\n', '3\n', '4\n', '5\n', 'False\n', 'True\n', '2.13\n', 'Tom')
print(myTuple)

#去掉\n
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = tuple(line.strip() for line in file.readlines())
#输出：('1', '2', '3', '4', '5', 'False', 'True', '2.13', 'Tom')
print(myList)

方法四（根据迭代器对象创建元组）

#创建一个迭代器对象
myIterator = iter([1, False, True, "Tom", 5])
myTuple = tuple(myIterator)
#输出：(1, False, True, 'Tom', 5)
print(myTuple)

yourIterator = iter([1, False, True, "Tom", 5])
#使用列表推导式创建列表
yourTuple = tuple(x for x in yourIterator)
#输出：(1, False, True, 'Tom', 5)
print(yourTuple)

循环 

方法一（for循环）

myTuple = ("Tom", "Jack", 3.14, True)
for item in myTuple:
    print(item)

方法二（enumerate() 函数）

myTuple= ("Tom", "Jack", 3.14, True)
for index,value in enumerate(myTuple):
    print(f"下标={index}；值={value}")

方法三（while循环）

myTuple= ("Tom", "Jack", 3.14, True)
index=0
while index<len(myTuple):
    print(myTuple[index])
    index=index+1

方法四（迭代器遍历）

myTuple = ("Tom", "Jack", 3.14, True)
myIter = iter(myTuple)
#输出：<class 'tuple_iterator'>
print(type(myIter))
while True:
    try:
        print(next(myIter))
    except StopIteration:
        #结束循环
        break;

常用方法

返回第一个值为value的索引，可以设定范围。

myTuple = ("Tom", "Jack", 3.14, True,"Jack",False)
item=myTuple.index("Jack")
#输出：1
print(item)

item=myTuple.index("Jack",1)
#输出：1
print(item)

item=myTuple.index("Jack",2)
#输出：4
print(item)

item=myTuple.index("Jack",4,5)
#输出：4
print(item)

统计某元素在元组中出现的次数

myTuple = ("Tom", "Jack", 3.14, True,"Jack",False)
count=myTuple.count("Jack")
#输出：2
print(count)

浅拷贝

注意：虽然我使用copy模块的deepcopy方法，但是两个元组和两个元组同下标的元素都指向相同索引，也就是说元组和元素都没有创建新的副本。如果元组中的元素有可变的对象，则使用copy模块的deepcopy方法，元组和元素才会创建新的副本，案例在深拷贝栏目下见。

myTuple=("a",1,2,3,False)
yourTuple=myTuple[:]
#输出：相同的id
print(id(yourTuple),id(myTuple))
#输出：相同的id
print(id(yourTuple[0]),id(myTuple[0]))

import copy

myTuple= ("王五", None, "张三", "李四", "赵六")
yourTuple = copy.deepcopy(myTuple)
#输出：返回相同的id
print(id(yourTuple),id(myTuple))
#输出：返回相同的id
print(id(yourTuple[0]),id(myTuple[0]))

深拷贝

import copy

myTuple= ([1,2,3], None, "张三", "李四", "赵六")
yourTuple = copy.deepcopy(myTuple)
#输出：不相同的id
print(id(yourTuple),id(myTuple))
#输出：不相同的id
print(id(yourTuple[0]),id(myTuple[0]))

yourTuple[0][1]="aaa"
#输出：([1, 2, 3], None, '张三', '李四', '赵六')
print(myTuple)
#输出：([1, 'aaa', 3], None, '张三', '李四', '赵六')
print(yourTuple)

切片

myTuple = (0,1,2,3,4,5,6,7,8,9)
yourTuple = myTuple[2:5]
#输出：(2, 3, 4)
print(yourTuple)

yourTuple = myTuple[2:8:2]
#输出：(2, 4, 6)
print(yourTuple)

#等同于：myTuple[2::]
yourTuple = myTuple[2:]
#输出：(2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[:2:]
#输出：(0, 1)
print(yourTuple)

yourTuple = myTuple[::3]
#输出：(0, 3, 6, 9)
print(yourTuple)

yourTuple = myTuple[::]
#输出：(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[::]
#输出：(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[-2:-1:]
#输出：(8,)
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(yourTuple)

yourTuple = myTuple[::-1]
#输出：(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#分析：步长为负数表示反向步长切片。
print(yourTuple)

range（范围）

官方描述

The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops.

译文

range类型表示一个不可变的数字序列，通常用于在for循环中循环特定次数。

创建

  1. 如果start>=stop，则range对象表示的范围为空。
  2. step为负数，表示倒序排列元素。
myRange=range(10);
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))

myRange=range(2,10);
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))

myRange=range(2,2,1);
#输出：[]
print(list(myRange))

myRange=range(2,10,3);
#输出：[2, 5, 8]
print(list(myRange))

myRange=range(2,-10,-1);
#输出：[2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
print(list(myRange))

myRange=range(2,-10,1);
#输出：[]
print(list(myRange))

循环

方法一（for循环）

myRange=range(10);
for value in myRange:
    print(value)

方法二（enumerate() 函数）

myRange=range(10);
for index,value in enumerate(myRange):
    print("index={},value={}".format(index,value))

 方法三（while循环）

myRange=range(10);
index=0
while index<len(myRange):
    print(list(myRange)[index])
    index=index+1

方法四（迭代器遍历）

myRange = range(10);
myIter = iter(myRange)
while True:
    try:
        print(next(myIter))
    except StopIteration:
        break

常用方法

排序

注意：range是不可变序列，不可以进行排序。对range使用sorted方法实际上是创建了一个list类型的新对象。

升序

myRange = range(5, 1, -1)
sortedRange = sorted(myRange)
#输出：[5, 4, 3, 2]
print(list(myRange))
#输出：[2, 3, 4, 5]
print(list(sortedRange))

#输出：<class 'list'> <class 'range'>
print(type(sortedRange),type(myRange))
#输出：不同的id
print(id(sortedRange),id(myRange))

降序

myRange = range(10)
sortedRange = sorted(myRange,reverse=True)
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))
#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(list(sortedRange))

#输出：<class 'list'> <class 'range'>
print(type(sortedRange),type(myRange))
#输出：不同的id
print(id(sortedRange),id(myRange))

最大值和最小值

myRange = range(10)
#输出：0
print(min(myRange))
#输出：9
print(max(myRange))

表示的元素个数

myRange = range(10)
#输出：10
print(len(myRange))

某元素是否在范围内

myRange = range(10)
#输出：True
print(2 in myRange)
#输出：False
print(20 in myRange)

切片

myRange = range(10)
#输出：[2, 3, 4]
print(list(myRange[2:5]))

#输出：[2, 4, 6]
print(list(myRange[2:8:2]))

#等同于：myRange[2::]
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange[2:]))

#输出：[0, 1]
print(list(myRange[:2:]))

#输出：[0, 3, 6, 9]
print(list(myRange[::3]))

#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange[::]))

#输出：[8]
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(list(myRange[-2:-1:]))

#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#分析：步长为负数表示反向步长切片。
print(list(myRange[::-1]))

优势

官方描述

The advantage of the range type over a regular list or tuple is that a range object will always take the same (small) amount of memory, no matter the size of the range it represents (as it only stores the start, stop and step values, calculating individual items and subranges as needed).

Range objects implement the collections.abc.Sequence ABC, and provide features such as containment tests, element index lookup, slicing and support for negative indices (see Sequence Types — list, tuple, range):

译文

  1. range相对于普通列表和元组的优势在于：range对象始终占用相同（少量）的内存空间，不受范围大小影响。
  2. range对象只存储start（起始值）、stop（终止值）、step（步长）并不存储元素。
  3. range对象实现了collections.abc.Sequence抽象基类（ABC），并提供一些序列类型的特性，如包含测试、元素索引查找、切片和支持负索引。
# 使用 range 对象
import sys

myRange = range(1000)
yourRange = range(2000)
#sys.getsizeof方法：获取对象的字节大小（在内存中占用的字节数）。
#sys.getsizeof 在某些情况下可能并不是百分之百准确，因为它可能不考虑由解释器或底层系统分配的一些额外开销。
# 输出:48
print(sys.getsizeof(myRange))
# 输出:48
print(sys.getsizeof(yourRange))
# 使用列表
myList = list(range(1000))
# 输出: 8056
print(sys.getsizeof(myList))
我的身前一尺是我的世界
关注
  • 23
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客
FastDFS安装与测试
01-06 1102
在Linux服务器上搭建单机版FastDFS系统。（考虑到Linux服务器访问GitHub受限，这里我将依赖包下载到本地，再将本地的依赖包上传到Linux服务器上。所以我的操作与Wiki上的操作略有不同，但本质一样）。在Linux服务器上，使用命令行实现文件上传、下载、删除等功能。熟悉FastDFS系统架构。
博客
Python字典类型
11-28 1175
掌握字典类型的使用方法，包括：创建、循环、常用方法等操作。
博客
Python集合类型
11-26 1028
掌握set和frozenset两种集合的使用方法，包括：创建、交集、并集、差集等操作。
博客
Python字符串类型
11-17 240
掌握字符串类型的使用方法。本文参考官方文档列举了各种字符串方法的使用方法，如有错误烦请指正。
博客
Python数字类型
10-22 296
掌握Python两种数据类型的使用方法。数字类型有三种，分别是：整数（int）浮点数（float）复数（complex）另外，布尔值类型（bool）是整数类型的子类型。
博客
用Netty搭建文件上传系统
05-23 1614
客户端向服务端发送一个文件（可以是视频、音频、文本、表格等格式的文件），服务端接收文件并保存到指定的目录下。服务端保存好文件之后向客户端发送回应：xxx文件收到了。
博客
适配器模式知多少
05-15 397
熟悉适配器设计模式，了解适配器设计模式的使用场景、具体实现。
博客
装饰者设计模式知多少
05-13 512
熟悉装饰者设计模式，了解装饰者设计模式的使用场景、具体实现。
博客
策略设计模式知多少
04-26 730
熟悉策略设计模式，了解策略设计模式的使用场景、具体实现。
博客
观察者设计模式知多少
04-26 802
熟悉观察者设计模式，了解观察者设计模式的使用场景、具体实现（包括：推设计模式、拉设计模式、被动观察者设计模式）。
博客
责任链设计模式知多少
04-25 853
熟悉责任链设计模式，了解责任链设计模式的使用场景、具体实现，单链责任链设计模式和双链责任链设计模式的区别。
博客
用Netty做一个简单的聊天室程序
04-16 1063
一个服务端支持多个客户端同时连接，服务端关注客户端的在线，离线情况，客户端关注其他客户端的离线情况、在线情况，发送的消息。
博客
BIO和NIO的区别与实现
04-14 1001
了解BIO和NIO的区别和应用场景。分析BIO和NIO的线程模型，利用Socket实现BIO和NIO的核心功能。
博客
JAVA反射机制知多少
03-31 1025
了解反射机制的概念，通过反射的方式动态地获取类的名称、成员变量、构造方法、成员变量，注解信息。
博客
Netty黏包半包解决方案
03-24 1517
了解黏包半包发生的原因，了解各个解决方案适用的场景。
博客
Netty之ByteBuf应用详解
03-16 2365
掌握ByteBuf的常用方法。了解池化的ByteBuf和非池化的ByteBuf的区别。了解直接内存的ByteBuf和堆内存的ByteBuf的区别。掌握对ByteBuf的内存释放方法。
博客
Netty之ChannelHandler初解
03-07 847
掌握ChannelHandler基本使用方法。熟悉入栈ChannelHandler和出栈ChannelHandler的执行顺序。分析ChannelHandlerContext和NioSocketChannel写入数据时有什么不同。了解Pipeline添加多个ChannelHandler有什么意义。
博客
Netty之io.netty.util.concurrent.Promise与io.netty.util.concurrent.Future初解
03-01 1319
了解io.netty.util.concurrent.Promise与io.netty.util.concurrent.Future的基本使用方法。了解java.util.concurrent.Future、io.netty.util.concurrent.Promise，io.netty.util.concurrent.Future之间的关系。
博客
Netty之ChannelFuture详解
03-01 2475
了解Netty如何处理客户端与服务器之间的连接与关闭问题。
博客
Netty之EventLoopGroup详解
02-11 1836
了解io.netty.channel.nio.NioEventLoopGroup和io.netty.channel.DefaultEventLoop的区别。掌握EventLoopGroup如何实现对内部EventLoop的轮询，以及EventLoop对普通任务和定时任务的实现方法。划分EventLoopGroup职责，指定EventLoopGroup操作ChannelHandler。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值