Python的列表和元组详情

目录
  • 一、Python 列表(list)
    • 1.序列介绍
    • 2.列表的概述
    • 3.创建列表
    • 4.列表的索引
    • 5.列表的分片
    • 6.列表的分片赋值
    • 7.循环遍历列表
    • 8.查找元素与计数
    • 9.列表增加元素
    • 10.列表删除元素
    • 11.列表排序
  • 二、 Python 元组(tuple)
    • 1.为什么要将元组设计成为不可变序列
    • 2.创建元组
    • 3.元组的遍历
    • 4.元组的内置函数

一、Python 列表(list)

1.序列介绍

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是

1,依此类推。Python有6个序列的内置类型,但最常见的是列表和元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

Python:可变序列和不可变序列

​可变序列:列表、集合、字典  可以进行增删改操作,序列地址页不会发生变化

​不可变序列:元组、字符串   没有增删改操作

#可变序列:列表、字典、集合
list_1 = [10,20,30]
print(id(list_1))   #list_1的地址为:2927159489792
list_1.append(40)
print(id(list_1))   #list_1的地址为:2927159489792 改变了值,列表地址并没有改变

#不可变序列:字符串、元组
str_1 = "HelloWorld"
print(id(str_1))    #str_1的地址为:2244899454896
str_1 = str_1+"1"
print(id(str_1))    #str_1的地址为:2244900762928  改变了值,字符串地址也发生了变化

2.列表的概述

列表是包含0个或者多个元素的有序序列,属于序列类型。

特点:

  • a.列表的长度和内容是可变的(可以自由的对列表中的元素进行,增加、删除或者替换)
  • b.列表没有长度限制
  • c.列表中的元素类型可以不同(可以是基本数据类型,也可以是列表、元组、字典、集合以及其他自定义类型的对象)

3.创建列表

创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示:

#创建列表方式一
list_0 = []  #空列表
list_1 = ['elephan','monkey','tiger']
list_2 = [1,2,3]
list_3 = [1,2.2,'tiger',True,list_1]   #列表可存储不同的数据类型

#创建列表方式二:使用list()内置函数  list(obj)函数将字符串、range()对象、元组等对象转换为列表。
list_4 = list("python")
list_5 = list([1,2,3,4,5])
list_6 = list((1,2,3))
list_7 = list(range(1,5,2))

4.列表的索引

#列表的索引
list_1 = [1,2.2,'tiger',True]
print(list_1[0])
print(list_1[3])
#print(list_1[4])  报错,超出列表的长度

5.列表的分片

#列表的分片
list_1 = [1,2.2,'tiger',True]
print(list_1[1:3])
print(list_1[0:3:2])
print(list_1[-1:0:-1])    #反向分片的时候,注意步长要为负数

6.列表的分片赋值

x = [1,2,3,4]
x[1] = 1    #替换下角标为1的索引
print(x)
x[2:] = 5,6 #从下角标为2的索引开始替换
print(x)
x[1:1] = [1,2,3,4,5,6,7]    #在变量索引为1的位置插入 “1,2,3,4,5,6,7”
print(x)

#运行结果
[1, 1, 3, 4]
[1, 1, 5, 6]
[1, 1, 2, 3, 4, 5, 6, 7, 1, 5, 6]

7.循环遍历列表

为了能有效地逐一输出列表中的数据,可以使用whilefor循环来便利输出列表。

while循环遍历列表:

x = [1,2,3,4,5,6,7,8,9]
length = len(x)
i = 0
while i<length:
    print(x[i])
    i+=1

for循环遍历列表:

x = [1,2,3,4,5,6,7,8,9]
for n in x:
    print(n)

8.查找元素与计数

index(obj)方法:用于返回指定元素在列表中首次出现的位置,如果该元素不在列表中则抛出异常。

animal = ['elephant','monkey','snake','tiger',(1,2,3)]
print(animal.index((1,2,3))
print(animal.index("snake"))
#print(animal.index("喵喵"))   #找不到喵喵会抛出异常
x = input("请输入您要查找的动物")
if x in animal:
    a = animal.index(x) #返回索引值
    print('元素{0}在列表中的索引为:{1}'.format(x,a))
else:
    print("列表中不存在该元素")

count(obj)方法:统计指定元素在列表中出现的次数

x = [1,2,2,2,3,4,[1,2,3,4],(1,2),(1,2)]
a = x.count(2)
print(a)
b = x.count((1,2))
print(b)
#运行结果
3
2

9.列表增加元素

列表增加元素:append(obj)方法  extend(seq)方法  insert(index,obj)方法

append(obj):在列表的末尾添加新的元素、对象

add_list = [0,1,2,3,4]
add_list.append(5)  #在末尾添加一个元素5
print(add_list)
add_list.append([6,7])  #在末尾添加一个列表对象[6,7]
print(add_list)
x = [8,9]
add_list.append(x)  #在末尾添加一个列表对象x
print(add_list)
#运行结果
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, [6, 7]]
[0, 1, 2, 3, 4, 5, [6, 7], [8, 9]]

 extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表拓展原来的列表)

list_1 = [1,2,3]
list_2 = [4,5,6]
list_1.extend("python") #将序列python与list_1合并
print(list_1)
list_1.extend(list_2) #将list_2看作一个序列,将这个序列和list_1合并
print(list_1)

insert(index,obj):可以将指定的对象添加到指定位置

#insert()方法
number = [1,2,4,5]
number.insert(2,3)  #在索引为2的位置添加元素3
print(number)
number.insert(5,[6,7])  #在索引为5的位置添加对象[6,7]
print(number)
x = [8,9]
number.insert(6,x)  #在索引为6的位置添加对象x
print(number)
#运行结果
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, [6, 7]]
[1, 2, 3, 4, 5, [6, 7], [8, 9]]

10.列表删除元素

列表删除元素:del命令  pop()方法  remove()方法

del命令:根据索引删除列表中的元素(删除一个或者多个)

number = [1,2,3,4,5,6,7,8,9]
del number[2]   #删除索引为2的元素
print(number)
del number[1:3] #分片删除索引1:3的元素
print(number)
del number[-1:0:-2] #分片删除索引-1:0:-2的元素
print(number)

pop([obj])方法:用于移除列表中的一个元素(默认最后一个),并且返回该元素的值 (删除一个)

number = [1,2,3,4,5,6,7,8,9]
print(number.pop())  #默认删除最后一个元素,并返回该元素的值
print(number)
print(number.pop(0) )  #删除索引为0的元素
print(number)

 remove(obj)方法:移除列表中某个值的第一个匹配项。

#使用remove方法删除列表x中的所有'abc'
x = ["123",'abc',"ABC",'python','abc']
while 'abc' in x:
    x.remove('abc')
print(x)
#运行结果
['123', 'ABC', 'python']

11.列表排序

reverse()方法:用于将列表中的元素反向存放(修改原列表值)。

x = [1,2,3,4]
x.reverse()
print(x)
#运行结果
[4, 3, 2, 1]

sort([key = None],[reverse = False])方法:用于对原列表进行排序(默认为升序排序),排序后的新列表会覆盖原列表

key:传递给key参数的是一个函数,它指定可迭代对象中的每一个元素来按照该函数进行排序

reverse: 表示是否反向排序,默认为False

# 这里先看一个不带key参数的sort()函数,大家很容易知道结果
li = [[1, 7], [1, 5], [2, 4], [1, 1]]
li.sort()
print(li)
# [[1, 1], [1, 5], [1, 7], [2, 4]] 默认按照0维排序 再按照1维排序

def fun(li):
    return li[1]
# 这时将函数fun传递给参数key 得出结果
li.sort(key=fun)
print(li) # [[1, 1], [2, 4], [1, 5], [1, 7]]
#是li中每个子元素的第二个数进行排序

#无参数排序
x = [1,2,3,4,5]
x.sort()
print(x)
#指定参数排序,长度,反向
x_1 = ['a','abc','abcd','ab']
x_1.sort(key=len,reverse=True)
print(x_1)

#运行结果
[1, 2, 3, 4, 5]
['abcd', 'abc', 'ab', 'a']

  sorted(iterable,[key = None],[reverse = False])  函数:排序方式与sort一样,但是sorted函数会返回一个新列表,对原列表不进行修改

iterable:表示可迭代对象,在这里就是列表名。

#无参数排序
x_1 = [1,5,2,3,4]
x_2 = sorted(x_1)
print(x_1)
print(x_2)

#指定参数排序
x_1 = ['a','abc','abcd','ab']
x_2 = sorted(x_1,key=len,reverse=True)
print(x_1)
print(x_2)

#运行结果
[1, 5, 2, 3, 4]
[1, 2, 3, 4, 5]
['a', 'abc', 'abcd', 'ab']
['abcd', 'abc', 'ab', 'a']

二、 Python 元组(tuple)

元组是不可变序列,所以增删改操作不能使用。

1.为什么要将元组设计成为不可变序列

  • 在多任务环境下,同时操作对象不需要加锁
  • 在程序中尽量使用不可变序列

注意:元组中存储的是对象的引用

  • 如果元组中存储的对象本身为不可变对象,则不能引用其他对象
  • 如果元组中存储的对象本身为可变对象,则可变对象的引用不可改变,但是数据可以

tuple_1 = (10,[20,30],"string")
print("1",tuple_1[0],type(tuple_1[0]),id(tuple_1[0]))
print("2",tuple_1[1],type(tuple_1[1]),id(tuple_1[1]))
print("3",tuple_1[2],type(tuple_1[2]),id(tuple_1[2]))
#tuple_1[0] = 1
#tuple_1[1] = 1       这三行代码报错,不能修改元组的值
#tuple_1[2] = 1
tuple_1[1].insert(2,40)  #使用list的方法修改list的值,但是列表的引用地址并没有改变
print("4",tuple_1[1],type(tuple_1[1]),id(tuple_1[1]))

运行结果:

1 10 <class 'int'> 2698032015952
2 [20, 30] <class 'list'> 2698040063232
3 string <class 'str'> 2698040230832
4 [20, 30, 40] <class 'list'> 2698040063232

2.创建元组

#方式一:直接使用()创建
tuple_1 = (1,2.2,"Python",True)
print(tuple_1)          #运行结果(1, 2.2, 'Python', True)
#()可以省略不写
tuple_1 = 1,2.22,"Python",True
print(tuple_1)          #运行结果(1, 2.22, 'Python', True)

#方式二:使用内置函数tuple(obj)函数将字符串、range()对象、元组等对象转换为元组
tuple_2 = tuple("python")
tuple_3 = tuple([1,2,3,4,5])
tuple_4 = tuple((1,2,3))
tuple_5 = tuple(range(1,5,2))
tuple_6 = tuple({"a":"张三",True:1})
print(tuple_2)      #运行结果('p', 'y', 't', 'h', 'o', 'n')
print(tuple_3)      #运行结果(1, 2, 3, 4, 5)
print(tuple_4)      #运行结果(1, 2, 3)
print(tuple_5)      #运行结果(1, 3)
print(tuple_6)      #运行结果('a', True)

#注意:当元组的值,只包含一个元素的时候,一定要加入一个逗号
tuple_7 = (1,)
tuple_8 = (1)
tuple_9 = ("你",)
tuple_10 = ("你")
print(tuple_7)      #运行结果(1,)
print(tuple_8)      #运行结果1
print(tuple_9)      #运行结果('你',)
print(tuple_10)     #运行结果你

3.元组的遍历

tuple_1 = ('python','world',94)
#方法一:使用循环利用索引,获取全部元组的元素
i = 0
length = len(tuple_1)
while i<length:
    print(tuple_1[i])
    i += 1
#方法二
for x in tuple_1:
    print(x)

4.元组的内置函数

序列都会具备的三个函数: len()   max()  min()
tuple():功能:以一个序列为参数,并把它转换为元组,如果参数本身是元组,则原样返回该参数(参考上文元组的知识点2,创建元组)

到此这篇关于Python的列表和元组详情的文章就介绍到这了,更多相关Python的列表和元组内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • python中必会的四大高级数据类型(字符,元组,列表,字典)

    一. 字符串 生活中我们经常坐大巴车,每个座位一个编号,一个位置对应一个下标. 字符串中也有下标,要取出字符串中的部分数据,可以用下标取. python中使用切片来截取字符串其中的一段内容,切片截取的内容不包含结束下标对应的数据. 切片使用语法:[起始下标:结束下标:步长] ,步长指的是隔几个下标获取一个字符. 注意:下标会越界,切片不会 常用函数 练习: Test='rodma ' print(type(Test)) print('Test的一个字符串%s'%Test[0])#跟数组差不多 #

  • python字符串,元组,列表,字典互转代码实例详解

    python字符串,元组,列表,字典互相转换直接给大家上代码实例 #-*-coding:utf-8-*- #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'} print type(str(dict)), str(dict) #字典可以转为元组,返回:('age', 'name', 'class

  • python中的列表和元组区别分析

    列表(list)和元组(tuple)的一些基础 list和tuple都是一个可以放置任意数据类型的有序集合,都是既可以存放数字.字符串.对象等 list和tuple都支持负索引 In [8]: nums[-2] Out[8]: 'ad' In [9]: tp[-2] Out[9]: '33' list和tuple都支持切片操作 In [10]: nums[1:3] Out[10]: [3, 'ad'] In [11]: tp[1:3] Out[11]: (3, '33') list和tuple都

  • Python数据结构之列表与元组详解

    目录 Python 列表(list): 1.序列介绍: 2.列表的概述: 3.创建一个列表 4.列表的索引 5.列表的分片 6.列表的分片赋值 7.循环遍历列表 8.查找元素与计数 9.列表增加元素: 10.列表删除元素: 11.列表排序 Python 元组(tuple): 1.为什么要将元组设计成为不可变序列 2.创建元组 3.元组的遍历 4.元组的内置函数 Python 列表(list): 1.序列介绍:   序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置

  • 简单了解python列表和元组的区别

    列表(list)和元组(tuple)的一些基础 list和tuple都是一个可以放置任意数据类型的有序集合,都是既可以存放数字.字符串.对象等 list和tuple都支持负索引 In [8]: nums[-2] Out[8]: 'ad' In [9]: tp[-2] Out[9]: '33' list和tuple都支持切片操作 In [10]: nums[1:3] Out[10]: [3, 'ad'] In [11]: tp[1:3] Out[11]: (3, '33') list和tuple都

  • python中列表(list)和元组(tuple)的深入讲解

    前言 在我们实际开发中,经常需要将一组数据存储起来,以便使用.如果学习了其他的语言可能知道数组(Array)这个数据结构,它就可以将多个数据进行存储,访问数据可以通过数组下标的方式,的进行获取.如果你是python开发者,那么可以使用更加灵活的列表(list)和元组(tuple),来进行数据储存.下面我们先简单了解下列表和元组的基本使用. 列表 列表是动态的,长度可以改变,可以随意增加,修改或删除元素. 初始化列表 a = list() b = [] # 可以通过range快速创建list c

  • Python内置数据结构列表与元组示例详解

    目录 1. 序列 2. 列表 2.1 列表的特性 2.1.1 列表的连接操作符和重复操作符 2.1.3 列表的索引 2.1.4 列表的切片 2.1.5 列表的循环(for) 2.2 列表的基本操作(增删改查) 2.2.1 列表的增加 2.2.2 列表的修改 2.2.3 查看 2.2.4 列表的删除 2.2.5 其他操作 3. 元组 3.1 元组的创建 3.2 元组的特性 3.3 元组的命名 4. 深拷贝和浅拷贝 4.1 值的引用 4.2 浅拷贝 4.3 深拷贝 5. is 和 ==的对比 总结

  • python 元组和列表的区别

    静态数据类型 静态数据类型是指不可以对该数据类型进行修改,即只读的数据类型.迄今为止学过的静态数据类型有字符串,元组. 在使用[]操作符对字符串,元组进行修改时,Python会抛出类型错误的异常信息,我们可以在交互模式中进行验证: >>> content = "static data type" >>> content[0]=S Traceback (most recent call last):  File "<stdin>&

  • python中读入二维csv格式的表格方法详解(以元组/列表形式表示)

    如何去读取一个没有表头的二维csv文件(如下图所示)? 并以元组的形式表现数据: ((1.0, 0.0, 3.0, 180.0), (2.0, 0.0, 2.0, 180.0), (3.0, 0.0, 1.0, 180.0), (4.0, 0.0, 0.0, 180.0), (5.0, 0.0, 3.0, 178.0)) 方法一,使用python内建的数据处理库: #python自带的库 rows = open('allnodes.csv','r',encoding='utf-8').readl

  • Python的列表和元组详情

    目录 一.Python 列表(list) 1.序列介绍 2.列表的概述 3.创建列表 4.列表的索引 5.列表的分片 6.列表的分片赋值 7.循环遍历列表 8.查找元素与计数 9.列表增加元素 10.列表删除元素 11.列表排序 二. Python 元组(tuple) 1.为什么要将元组设计成为不可变序列 2.创建元组 3.元组的遍历 4.元组的内置函数 一.Python 列表(list) 1.序列介绍 序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,

  • Python中列表与元组的乘法操作示例

    本文实例讲述了Python中列表与元组的乘法操作.分享给大家供大家参考,具体如下: 直接上code吧,还可以这么玩儿 列表乘法: li=[1,] li=li*3 print(li) out: [1, 1, 1] 元组乘法: >>> t=(1,2) >>> t*3 (1, 2, 1, 2, 1, 2) 但字典,集合不能这么玩 例如: >>> dict1={'k1':1,'k2':2} >>> dict1*2 #报错 Traceback

  • Python list列表查找元素详情

    目录 Python list列表 index() 方法 count()方法 Python list列表 Python 列表(list)提供了 index() 和 count() 方法,它们都可以用来查找元素. index() 方法 index() 方法用来查找某个元素在列表中出现的位置(也就是索引),如果该元素不存在,则会导致 ValueError 错误,所以在查找之前最好使用 count() 方法判断一下. index() 的语法格式为: listname.index(obj, start,

  • python中列表和元组的区别

    如果有了解过python中的列表和元组,你可能会知道相对于列表,元组是不可变的,也就是说元组中的数据不能随意更改.除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗? a = [1, 3, 5, 7, 'a'] b = (1, 3, 5, 7, 'b') # 现在改变b中的值 b[2] = 4 TypeError Traceback (most recent call last) <ipython-input-2-96f3d

  • Python中列表和元组的相关语句和方法讲解

    列表(list): 首先,列表属于序列,那么序列类型可用如下内建函数-- list(iter):把可迭代对象转换为列表. str(obj):把obj对象转换为字符串,即用字符串来表示这个对象. tuple(iter):把一个可迭代对象转换为一个元组. unicode(obj):把对象转换成Unicode字符串. basestring():抽象工厂函数,其作用仅仅是为str和unicode函数提供父类,所以不能被实例化,也不能被调用. enumerate(iter):接受一个可迭代对象作为参数,返

  • Python中列表和元组的使用方法和区别详解

    一.二者区别 列表: 1.可以增加列表内容 append 2.可以统计某个列表段在整个列表中出现的次数 count 3.可以插入一个字符串,并把整个字符串的每个字母拆分当作一个列表段追加到列表当中 extedn 4.可以查询某个列表段在整个列表的位置 index 5.可以在指定位置插入一个列表段 insert 6.可以删除列表的最后一个列表段 pop 7.可以删除指定列表中的某个列表段 remove 8.可以正向反向排序 reverse 9.可以按字母或数字排序 sort 10.定义列表时候使用

  • Python列表推导式详情

    目录 1.列表生成式 1.1 案例 2.集合生成式 3.字典生成式 1.列表生成式 列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式. 语法结构如下: # 普通的生成式 [表达式 for 变量 in 旧列表] # 加条件的生成式 [表达式 for 变量 in 旧列表 if 条件] # if...else条件的生成式 [表达式 if 条件1 else 条件2for 变量 in 旧列表] 1.1 案例 过滤掉名词字母不足4的名字,示

  • Python中3种内建数据结构:列表、元组和字典

    Python中有3种内建的数据结构:列表.元组和字典.参考简明Python教程 1. 列表 list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目.假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了.只不过在你的购物表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分割. 列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表.一旦你创建了一个列表,你可以添加.删除或是搜索列表中的项目.由于你可以增加或删除项目,

  • Python入门篇之列表和元组

    列表和元组的主要区别在于,列表可以修改,元组则不能.一般情况下,在几乎所有的情况下列表都可以代替元组 例如:使用序列可以表示数据库中一个人的信息(姓名,年龄) 复制代码 代码如下: >>> edward=['Edward Gumby',42] 序列还可以包含其他序列 复制代码 代码如下: >>> edward=['Edward Gumby',42] >>> john=['John Smith',50] >>> database=[ed

  • python列表与元组详解实例

    在这章中引入了数据结构的概念.数据结构是通过某种方式组织在一起的数据元素的集合.在python中,最基本的数据结构就是序列.序列中的每个元素被分配一个序号,即元素的位置,也被称为索引.注意:第一个索引是0.1.序列概览python有6种内建的序列:列表,元组,字符串,Unicode字符串,buffer对象和xrange对象. 这里重点介绍列表和元组.列表和元组主要区别在于,列表可以修改,元组不可修改.一般来说,在几乎所有情况下列表都可以代替元组.在需要操作一组数值的时候,序列很好用: 复制代码

随机推荐