python-数据类型-列表

最新推荐文章于 2023-11-10 19:46:23 发布

半吊子的Arron

最新推荐文章于 2023-11-10 19:46:23 发布

阅读量648

点赞数

分类专栏： python 文章标签： python Powered by 金山文档

本文链接：https://blog.csdn.net/qq_41663420/article/details/129524200

版权

python 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

创建列表

首先，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。

其次，list 是可变对象哦

使用 [ ] 直接创建列表

使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

listname = [element1 , element2 , element3 , ... , elementn]
emptylist = [ ]
emptylist = [1,]

使用 list() 函数创建列表

除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。

#将字符串转换成列表
list1 = list("hello")
print(list1)

#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)

#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

#创建空列表
print(list())

['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]

访问列表中的值

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的格式为：

列表的索引可以是正数，也可以是负数。

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
 
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

使用切片访问列表元素的格式为：

listname[start : end : step]
其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

url = list("http://c.biancheng.net/shell/")
#使用索引访问列表中的某个元素
print(url[3])  #使用正数索引
print(url[-4])  #使用负数索引
#使用切片访问列表中的一组元素
print(url[9: 18])  #使用正数切片
print(url[9: 18: 3])  #指定步长
print(url[-6: -1])  #使用负数切片

运行结果：
p
e
['b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g']
['b', 'n', 'e']
['s', 'h', 'e', 'l', 'l']

增加列表元素

append()方法添加元素

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：

添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

listname.append(obj)
其中，listname 表示要添加元素的列表；

l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)
#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)
#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)

['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]

extend()方法添加元素：

extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

l = ['Python', 'C++', 'Java']

#追加元素
l.extend('C')
print(l)

#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)

#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)

['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']

insert()方法插入元素

在列表中间某个位置插入元素

listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)

#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)

#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)

#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://c.biancheng.net")
print(l)

['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://c.biancheng.net', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']

修改列表元素

修改单个元素

nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26  #使用正数索引
nums[-3] = -66.2  #使用负数索引
print(nums)

[40, 36, -26, 2, -66.2, 100, 7]

修改一组元素

切片赋值

nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)

[40, 45.25, -77, -52.5, 36, 100, 7]

对空切片（slice）赋值，就相当于插入一组新的元素：

nums =[40,36,89,2,36,100,7]
#在4个位置插入元素
nums[4:4]=[-77,-52.5,999]
print(nums)

[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]

注意

使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：

nums[4: 4] = -77

使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素

s = list("Hello")
s[2:4] = "XYZ"
print(s)

['H', 'e', 'X', 'Y', 'Z', 'o']

切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同

nums = [40, 36, 89, 2, 36, 100, 7]
#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)

[40, 0.025, 89, -99, 36, 20.5, 7]

查找列表元素

index() 方法

listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。

start 和 end 参数用来指定检索范围：

start 和 end 可以都不写，此时会检索整个列表；

如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；

如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]

#检索列表中的所有元素
print( nums.index(2) )
#检索3~7之间的元素
print( nums.index(100, 3, 7) )
#检索4之后的元素
print( nums.index(7, 4) )
#检索一个不存在的元素
print( nums.index(55) )

3
5
6
Traceback (most recent call last):
    File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
        print( nums.index(55) )
ValueError: 55 is not in list

count()方法

count() 方法用来统计某个元素在列表中出现的次数

如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

listname.count(obj)

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]

#统计元素出现的次数
print("36出现了%d次" % nums.count(36))

#判断一个元素是否存在
if nums.count(100):
    print("列表中存在100这个元素")
else:
    print("列表中不存在100这个元素")

36出现了3次
列表中存在100这个元素

删除列表元素

del 删除

del 可以删除列表中的单个元素

listname 表示列表名称，index 表示元素的索引值。

intlist = [1, 45, 8, 34]
print(intlist)
del intlist[2]
print(intlist)

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
#使用正数索引
del lang[2]
print(lang)
#使用负数索引
del lang[-2]
print(lang)

del 也可以删除中间一段连续的元素

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[1: 4]
print(lang)

lang.extend(["SQL", "C#", "Go"])
del lang[-5: -2]
print(lang)

['Python', 'Ruby', 'MATLAB']
['Python', 'C#', 'Go']

pop()：根据索引值删除元素

用来删除列表中指定索引处的元素，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作

nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)

[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]

remove()：根据元素值进行删除

remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

nums = [40, 36, 89, 2, 36, 100, 7]
#第一次删除36
nums.remove(36)
print(nums)
#第二次删除36
nums.remove(36)
print(nums)
#删除78
nums.remove(78)
print(nums)

[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
    File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
        nums.remove(78)
ValueError: list.remove(x): x not in list

clear()：删除列表所有元素

clear() 用来删除列表的所有元素，也即清空列表

url = list("http://c.biancheng.net/python/")
url.clear()
print(url)

列表函数与方法：

min(list)：list -- 要返回最小值的列表。

#!/usr/bin/python

list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]

print "min value element : ", min(list1);
print "min value element : ", min(list2);

以上实例输出结果如下：
min value element :  123
min value element :  200

max(list)：返回列表元素中的最大值。

#!/usr/bin/python

list1, list2 = ['123', 'xyz', 'zara', 'abc'], [456, 700, 200]

print "Max value element : ", max(list1);
print "Max value element : ", max(list2);

Max value element :  zara
Max value element :  700

len(list) ：要计算元素个数的列表

#!/usr/bin/python

list1, list2 = [123, 'xyz', 'zara'], [456, 'abc']

print "First list length : ", len(list1);
print "Second list length : ", len(list2);
以上实例输出结果如下：

First list length :  3
Second lsit length :  2

在Python 3中, 使用operator模块来实现同样的功能. 无论是在交互模式还是在文本模式下, 要使用operator模块都需要先导入该模块:

operator 中有很多方法 https://docs.python.org/zh-cn/3/library/operator.html

a = [1, 2]
b = [1, 3]
import operator

print(operator.eq(a, b))
print(operator.add(a, b))

排序 sort（）和 sorted（）

sort（）

list.sort(cmp=None, key=None, reverse=False)

cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
aList = ['123', 'Google', 'Runoob', 'Taobao', 'Facebook'];
 
aList.sort();
print("List : ")
print(aList)

List : 
['123', 'Facebook', 'Google', 'Runoob', 'Taobao']

》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉

# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
 
# 输出结果
print('降序输出:')
print( vowels )

['u', 'o', 'i', 'e', 'a']


》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉》〉
# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takeSecond)
 
# 输出类别
print('排序列表：')
print(random)

[(4, 1), (2, 2), (1, 3), (3, 4)]

sorted（）

sorted([5,2,3,1,4])
 [1, 2, 3, 4, 5]

你也可以使用 list.sort() 方法，它会直接修改原列表（并返回 None 以避免混淆），通常来说它不如 sorted() 方便 ——— 但如果你不需要原列表，它会更有效率。

>>> a=[5,2,3,1,4]
>>> a.sort()
>>> a[1, 2, 3, 4, 5]

另外一个区别是， list.sort() 方法只是为列表定义的，而 sorted() 函数可以接受任何可迭代对象。

>>> sorted({1:'D',2:'B',3:'B',4:'E',5:'A'})
[1, 2, 3, 4, 5]

官方文档：

https://docs.python.org/zh-cn/3/howto/sorting.html