最新消息:首页公告!

【Python】列表和元组

浏览 共有条评论 关键词:Python
后台-系统设置-扩展变量-手机广告位-手机广告位-内容广告位一
概念
变量就是内存空间,用来表示/存储数据
如果表示的数据少,直接定义几个变量就行了

num1
num2
num3


但有时候要表示的数据比较多

Python 中,列表和元组就是一种可以用一个变量来表示很多数据的机制(类似其他语言中的数组)

列表和元组,大部分功能都是差不多的,但是有一个功能有非常明显的区别:

列表是可变的,创建好了之后,随时可以改
元组是不可变的,创建好了之后改不了,若想改,只能丢弃旧的,再创建一个新的

列表就是买散装辣条,装好了袋子之后,随时可以把袋子打开,再往里多加辣条或者拿出去一些辣条
元组就是买包装辣条,厂家生产好了辣条之后,一包就是固定的这么多,不能变动了
【Python】列表和元组

创建列表
直接使用字面值来创建
a = [1, 2, 3, 4]
print(type(a))
print(a)

"""
运行结果
<class 'list'>
[1, 2, 3, 4]
"""


[]就代表一个空的列表
可以在 [] 中指定列表的初始值,
使用 list() 来创建
b = list()
print(type(b))

"""
运行结果
<class 'list'>
"""


C++/Java 中要求一个数组里只能存放相同的变量,但在 Python 中没有类型要求

a = [1, 'hello', True, [1, 2, 3]]  
print(a)

"""
运行结果
[1, 'hello', True, [1, 2, 3]]
"""


访问下标
通过下标访问的方式,来获取列表中的元素
把 [] 放到一个列表变量的后面,同时 [] 中写上一个整数,此时他就是下标访问运算符。[] 中间写的这个证书,就称为“下标”或者“索引”

a = [1, 2, 3, 4]
print(a[2])

"""
运行结果
3
"""


Python 中的下标,是从 0 开始计数的
通过下标来修改列表元素
a = [1, 2, 3, 4]
a[2] = 100
print(a)

"""
运行结果
[1, 2, 100, 4]
"""


这是列表的功能,如果是元组的话,就只能读,不能改
由于下标是从 0 开始计算的,那么对于列表来说,下标的有效范围是 0~长度-1。当我们的下标超出有效范围的时候,尝试访问就会报错 `

获取列表长度
a = [1, 2, 3, 4]
print(len(a))

"""
运行结果
4
"""


len 可以穿字符串、列表、元组、字典、自定义得嘞…(动态类型)
下标可以写成负数
a = [1, 2, 3, 4]
print(a[lem(a)-1])
print(a[-1])

"""
运行结果
3
3
"""


-1 就等价与 len(a) - 1
切片操作
切片操作是一个比较高效的操作,进行切片的时候,只是取出原有列表中的一个部分,并不涉及到“数据的拷贝”。假设有一个很大的列表进行切片,切片的范围也很大,即使如此,切片操作仍然非常高效

切片操作中,[] 中有两个数字,表示了一段区间

a = [1, 2, 3, 4]
print(a[1:3])

"""
运行结果
[2, 3]
"""


1 表示开始区间的下标;3 表示结束区间的下标
包含 1,不包含 3,[1, 3)
省略后边界
a = [1, 2, 3, 4]
print(a[1:])

"""
运行结果
[2, 3, 4]
"""


从 a[1] 开始,一直读取到整个列表结束
省略前边界
a = [1, 2, 3, 4]
print(a[:2])

"""
运行结果
[1, 2]
"""


从列表的 a[0] 开始读,一直读到结束的后边界
省略前后边界
a = [1, 2, 3, 4]
print(a[:])

"""
运行结果
[1, 2, 3, 4]
"""


省略前后边界就是打印整个列表
带有步长的切片
切片操作,还可以指定“步长”,range

a = [1, 2, 3, 4 ,5 , 6, 7 ,8]
print(a[::1])
print(a[::2])

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


多加一个 :,再多加一个数字,这个数字就是步长
这里表示:每隔两个元素,取一个列表元素
步长也可以设置为负数,当步长为负数时,意思是从后往前来取元素
遍历列表元素
“遍历” 指的是把元素一个一个的取出来,再分别进行处理

使用 for 循环
a = [1, 2, 3, 4, 5]  
for elem in a:  
    print(elem)


在这个遍历过程中,循环里面的逻辑不一定是打印,还可以是别的
elem 代表列表里的每个元素
for in 后面的这个东西,要求是一个可迭代对象
列表就是一个可迭代对象
使用 for 循环访问下标的方式
a = [1, 2, 3, 4, 5]
for i range(0, len(a)):
    print(a[i])


相比于上面的方式,这里不仅可以打印,还可以进行修改
使用 while 循环
a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):
    print(a[i])
    i += 1


新增元素
在末尾新增
使用 append 往列表末尾新增一个元素

a = [1, 2, 3, 4, 5]  
a.append(77)  
a.append('hello')  
print(a)

"""
运行结果
[1, 2, 3, 4, 5, 77, 'hello']
"""


此处的 append 是搭配列表对象 a 一起使用的,而不是作为一个独立的函数
type、print、input、len… 都是独立的函数
这种要搭配对象来使用的函数(function)也叫做方法(method)
在 Python 中,对象就可以视为“变量”
在任意位置新增
可以使用 insert 方法,让列表的任意位置来新增元素

a = [1, 2, 3, 4, 5]
a.insert(1, 'hello')
print(a)

"""
运行结果
[1, 'hello', 2, 3, 4, 5]
"""


在 a[1] 的位置新增 ’ hello ’ 字符串
如果输入的 index 超过列表的长度,那就直接放在末尾
查找元素
判定元素是否存在
a = [1, 2, 3, 4]
print(1 in a)
print(10 in a)
print(1 not in a)
print(10 not in a)

"""
运行结果
True
False
False
True
"""


使用 in 来判定某个元素是否在列表中存在
使用 not in 来判断某个元素在列表中是否不存在
判定元素的位置
a = [1, 2, 3, 4]
print(a.index(2))

"""
运行结果
1
"""


使用 index 方法,来判定当前元素在列表中的位置,得到一个下标
找不到的时候就会直接报出异常
删除元素
删除列表末尾元素
a = [1, 2, 3, 4]  
a.pop()  
print(a)

"""
运行结果
[1, 2, 3]
"""


使用 pop 方法,删除列表中最末尾的元素
删除任意位置元素
a = [1, 2, 3, 4]  
a.pop(1)  
print(a)

"""
运行结果
[1, 3, 4]
"""


使用 pop 方法删除任意位置元素,pop 参数可以传一个下标过去
按照值进行删除
不需要知道下标是什么,只需要知道要删除的值是什么就可以了

a = ['aa', 'bb', 'cc', 'dd']  
a.remove('cc')  
print(a)

"""
运行结果
['aa', 'bb', 'dd']
"""


列表拼接
使用“+”拼接
使用 + 能够把两个列表拼接在一起

a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
c = a + b  
d = b + a
print(c)     
print(d)

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



使用 + 拼接列表的时候,只是针对当前列表的内容生成了一个更大的新的列表
原有列表的内容是不变的
使用 extend 进行拼接
a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
c = a.extend(b)  
print(a)  
print(b)  
print(c)
"""
运行结果
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8]
None
"""


这个拼接是把最后一个列表的内容拼接到前一个列表里面
None 是一个特殊的变量值,表示什么都没有
extend 方法,其实是没有返回值的,拿一个变量来接收一个没有返回值的方法的返回值
谁使用 extend 方法,就拼在谁的后面
使用“+=”拼接
a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
a += b 
print(a)  
print(b)  
"""
运行结果
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8]
"""


和 extend 的效果是类似的
但执行过程是不一样的
a += b 等价于 a = a + b;又创建了一个大列表,然后将小的装进去,再将大列表的值赋给 a 里面,最后将 a 的旧值释放
a.extend(b) 则是直接把 b 的内容拼到了 a 的后面,更高效,省去了数据拷贝和释放的过程
关于元组
创建元组
a = ()
b = tuple()
print(type(a))
print(type(b))

"""
运行结果
<class 'tuple'>
<class 'tuple'>
"""


创建元组时指定初始值
a = (1, 2, 3, 4)
print(a)

"""
运行结果
(1, 2, 3, 4)
"""


元组中的元素可以使任意类型
a = (1, 2, 'hello', True, [])
print(a)

"""
运行结果
(1, 2, 'hello', True, [])
"""


通过下标进行访问
a = (1, 2, 3, 4, 5)
print(a[1])
print(a[-1])

"""
运行结果
2
5
"""


下标也是从 0 开始,len-1 结束
当访问的下标超过 len - 1,会报错
切片
通过切片来获取元组中的一个部分

a = (1, 2, 3, 4)
print(a[1:3])


这里的操作和列表是一摸一样的
遍历元组
a = (1, 2, 3, 4)
for elem in a:
    print(elem)


和前面列表操作一样
查找元素
a = (1, 2, 3, 4, 5)
print(3 in a)
print(22 in a)


和列表的操作一样
拼接元组
a = (1, 2, 3)
b = (4, 5, 6)
print(a + b)


和列表的操作一样
为什么要有元组
在协同开发的时候,一个程序员 A 实现一些功能,提供给程序员 B 使用。A 写好一些函数,让 B 去调用
期间函数肯定要传参
B 在传参的时候就可能会纠结一个问题“我把我的参数传过去了,A 的函数里面是否会把我的参数的内容给改了呢”,如果使用元组作为参数,就可以避免这样的纠结

元组不可修改==>不可变对象

不可变对象,是可以哈希的
 

转载请注明:可思数据 » 【Python】列表和元组

后台-系统设置-扩展变量-手机广告位-手机广告位-内容广告位二
留言与评论(共有 条评论)
昵称:
匿名发表 登录账号
                 
   
验证码:
后台-系统设置-扩展变量-手机广告位-手机广告位-内容广告位三