数据容器——列表list

什么是数据容器?

python 中的数据容器:
一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素,每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
数据容器根据特点的不同,如:
·是否支持重复元素
·是否可以修改
·是否有序
分为5类,分别是:类表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict).

列表(list)

什么是列表?

列表内的每一个数据,称之为元素。
以[]作为标识
列表内每一个元素之间用,隔开
元素的数据类型没有任何限制,甚至元素也可以是列表,这样就定义了嵌套列表。
#基本语法:
# 定义列表字面量
#[元素1, 元素2, 元素3,元素4]

# 定义列表变量
# 变量名称=[元素1, 元素2, 元素3,元素4...]
name_list = ["yhz", "lr", "xmy", 666, True]
print(name_list) #print语句输入列表
print(type(name_list))

# 定义空列表
# 变量名称=[]
# 变量名称=list()
o_list = []
o_list = list()
print(o_list)
print(type(o_list))

# 定义一个嵌套的列表
my_list1 = ["小小",True,888] # 注意:列表可以一次存储多个数据,且可以为不同的数据类型
my_list2= ["小小", [4,5,6],True,888] # 注意:列表可以一次存储多个数据,且可以为不同的数据类型,还可嵌套列表。
my_list3= [[4,5,6],[7,5,3]] # 注意:列表可以一次存储多个数据,且可以为不同的数据类型,还可嵌套列表。
print(my_list1)
print(type(my_list1))
print(my_list2)
print(type(my_list2))
print(my_list3)
print(type(my_list3))
my_list1 = ["小小",True,888] # 注意:列表可以一次存储多个数据,且可以为不同的数据类型
my_list2= ["小小", [4,5,6],True,888] # 注意:列表可以一次存储多个数据,且可以为不同的数据类型,还可嵌套列表。
my_list3= [[4,5,6],[7,5,3]] # 双层嵌套列表
print(my_list1)
print(type(my_list1))
print(my_list2)
print(type(my_list2))
print(my_list3)
print(type(my_list3))

'''
运行结果:三个变量的类型都是列表(list)
['小小', True, 888]
<class 'list'>  
['小小', [4, 5, 6], True, 888]
<class 'list'>
[[4, 5, 6], [7, 5, 3]]
<class 'list'> '''

列表的下标索引

# 03 列表的下标索引
'''
我们如何从列表中取出特定位置的数据呢?可以使用下标索引
列表的每一个元素,都有顺序编号,我们称之为下标索引。列表[下标]即可取出。嵌套列表同样支持下标索引。
从前向后,从 0 开始,依次递增,0,1,2,3…;
从后向前,从 -1 开始,依次递减,-1,-2,-3…。
# 语法:列表[下标索引]
# 语法:列表[下标索引]
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[0])  # 运行结果:
print(name_list[1])  # 运行结果:
print(name_list[2])  # 运行结果:
print(name_list[3])  # 运行结果:

# 从前向后,从 0 开始,依次递增,0,1,2,3…;
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[0])  # 运行结果:Tom
print(name_list[1])  # 运行结果:Jony
print(name_list[2])  # 运行结果:Rose
print(name_list[3])  # 运行结果:Moore
#print(name_list[4])  # 运行结果:IndexError: list index out of range 超出下标的允许范围了。

# 从后向前,从 -1 开始,依次递减,-1,-2,-3…。
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[-1])  # 运行结果:Moore
print(name_list[-2])  # 运行结果:Rose
print(name_list[-3])  # 运行结果:Jony
print(name_list[-4])  # 运行结果:Tom

# 列表是嵌套的列表,同样支持下标索引,需要写2层下标索引,⚠️一定要记得编号从0开始
my_list=[[1,4,6],[7,9,10]]
print(my_list[0][0])  # 运行结果:1
print(my_list[0][1])  # 运行结果:4
print(my_list[0][2])  # 运行结果:6
print(my_list[1][0])  # 运行结果:7
print(my_list[1][1])  # 运行结果:9
print(my_list[1][2])  # 运行结果:10

列表的常用操作(方法)

列表除了可以:

·定义

·使用下标索引获取值

还可以提供其他功能:  

·插入元素

·删除元素

·清空列表

·修改元素

·统计元素个数 等等功能,这些功能我们都称之为:列表的方法

函数VS方法:
'''函数 vs. 方法
函数是一个封装的代码单元,可以提供特定功能。
而在 Python 中,如果将函数定义为 class(类)的成员,那么函数就会被称为:方法。'''
# 函数
def add(x, y):
  return x + y

# 方法
class Student:
  def add(self, x, y): # def 定义在class函数的里面
    return x + y
# 方法和函数功能一样,有传入参数,有返回值,只是方法的使用格式不同。
# 函数的使用:num = add(1, 2)
# 方法的使用:
student = Student() # 首先获得class的类对象—student
num = student.add(1, 2)  # 通过“·”,引出后面的功能

1、列表的查询功能(方法)
功能:查找某指定元素在列表的下标,如果找不到,报错ValueError。
语法:列表.index(元素)
index就是列表对象(变量)内置的方法(函数)。
# 定义一个列表
mylist=["it","is,","king"]
index=mylist.index("it")
print(f"it在列表中的下标索引值是:{index}") # 运行结果:it在列表中的下标索引值是:0
#index=mylist.index("hello")
#print(f"it在列表中的下标索引值是:{index}") # 报错;ValueError: 'hello' is not in list
2、修改功能

功能:修改特定位置(索引)的元素值,可对指定下标的值进行重新赋值。
语法:列表[下标] = 值
可以使用上述语法,直接对指定下标(正向、反向下标均可)的值进行:重新赋值(修改)
# 正向下标
my_list=[1,2,3]
my_list[0]=6 # 指定列表下标为0中,发现其元素值为1,修改为6
print(my_list)  # 运行结果中:[6, 2, 3]

# 正向下标
my_list=[1,2,3]
my_list[-3]=9 # 把列表中的-3下标对应的元素值,修改为9
print(my_list)  # 运行结果中:[9, 2, 3]
3、插入功能
功能:在指定下标,位置后面插入指定元素。
语法:列表.insert(下标, 元素),在指定的下标位置,插入指定的元素。
my_list_1=[1,2,3]
my_list_1.insert(1,"love") 
print(f"插入数据后:{my_list_1}") # 运行结果:插入数据后:[1, 'love', 2, 3]
3、追加元素
功能:将指定元素追加到列表尾部。
语法:
列表.append(元素)(追加一个);
列表.extend(其他数据容器)(将其他数据容器中的内容取出,依次追加到列表尾部)

my_list_2=[1,2,3,4]
my_list_2.append("78")
print(f"列表,追加尾部数据后,变为:{my_list_2}")  # 运行结果:列表,追加尾部数据后,变为:[1, 2, 3, 4, '78']
my_list_3=[1,2,3,4]
my_list_3.append([7,7,7])
my_list_4=[1,2,3,4]
my_list_4.extend([5,5,5,]) # extend 追加一批元素
print(f"列表,追加尾部数据后,变为:{my_list_3}")  #列表,追加尾部数据后,变为:[1, 2, 3, 4, [7, 7, 7]]
print(f"列表,追加尾部数据后,变为:{my_list_4}")  #列表,追加尾部数据后,变为:[1, 2, 3, 4, 5, 5, 5]

4、删除元素
语法:del 列表[下标],列表.pop(下标)(取出元素并从列表中删除),列表.remove(元素)(删除某元素在列表中的第一个匹配项)
# 使用del关键字
mylist=["let's","go","ahead"]
del mylist[0]
print(f"列表删除元素后的结果是:{mylist}") # 列表删除元素后的结果是:['go', 'ahead']
# 使用列表.pop(下标),方法,取出的元素可以重新定义变量保存。
mylist=["let's","go","ahead"]
element=mylist.pop(1)
print(f"通过pop方法,取出元素后,列表结果是:{mylist},取出元素是:{element}") # 通过pop方法,取出元素后,列表结果是:["let's", 'ahead'],取出元素是:go


# 删除某元素在列表中的第一个匹配项
#语法:列表.remove(元素) #⚠️,这里是直接删除元素,且只删除重复元素中排序第一位的
my_list=["it","is","dog","it","is","cat",]
my_list.remove("it")
print(my_list) # 结果:['is', 'dog', 'it', 'is', 'cat']
# 如果想把第二个‘it“删除,那就需要再调用一次
my_list.remove("it")
print(my_list) # 结果:['is', 'dog', 'is', 'cat']


5、清空列表内容
语法:列表.clear()
my_list=[1,6,12,77]
my_list.clear()
print(f"列表被清空后的结果是:{my_list}") # 列表被清空后的结果是:[]
6、统计功能
·语法:列表.count(元素)

统计某一个元素在列表中的数量。

my_list=[1,1,1,2,2,4,5,7]
my_list.count(1)
print(f"列表中元素1一共有多少:{my_list.count(1)}个") # 列表中元素1一共有多少:3个
·语法:len(列表)

⚠️:len不是列表的一个方法,这是一个函数。统计列表中,一共有多少个元素。通过len(列表),可以得到一个int数字,表示列表内元素的数量

my_list=[1,1,1,2,2,4,5,7]
count=len(my_list)
print(f"列表中一共有多少元素:{len(my_list)}个") # 列表中一共有多少元素:8个
print(count,"个") # 运行结果:8 个

练习案例:常用功能练习

有一个列表,内容是[21,25,21,23,22,20],记录一批学生的年龄
请通过列表的功能(方法),对其进行以下操作:
1、定义这个列表,并用变量接受它;
2、追加一个数字31,到列表的尾部;
3、追加一个新列表[29,33,30],到列表的尾部
4、取出第一个元素(应该是:21);
5、取出最后一个元素(应该是:30);
6、查找元素31,在列表中的下标位置
# 定义学生年龄的列表
age_list=[21,25,21,23,22,20]
print(age_list)
# 追加一个数字31,到列表的尾部
age_list.append(31)
print(age_list)
# 追加一个新列表[29,33,30],到列表的尾部
age_list.extend([29,33,30,])
print(age_list)
# 取出第一个元素(应该是:21)
num1=age_list[0]
print(f"从列表中取出来的第一个元素,应该是21,实际是:{num1}")
# 取出最后一个元素(应该是:30)
num1=age_list[-1]
print(f"从列表中取出来的第一个元素,应该是30,实际是:{num1}")
# 查找元素31,在列表中的下标位置
index=age_list.index(31)
print(f"元素31在列表的下标位置是:{index}")
print(f"最后列表的内容是:{age_list}")

'''
练习案例运行结果:
[21, 25, 21, 23, 22, 20]
[21, 25, 21, 23, 22, 20, 31]
[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
从列表中取出来的第一个元素,应该是21,实际是:21
从列表中取出来的第一个元素,应该是30,实际是:30
元素31在列表的下标位置是:6
最后列表的内容是:[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

进程已结束,退出代码为 0 
'''

列表的遍历

—while循环

既然数据容器可以存储多个元素,那么,就会有需求从容器内依次取出元素进行操作。将容器内的元素按着顺序依次取出的行为,叫做:遍历、迭代。
· 如何遍历列表的元素呢?
可以使用前面学过的while循环
· 如何在循环中取出列表的元素呢?
使用列表[下标]的方式取出
·循环条件如何控制?
1、定义一个变量表示下标,从0开始;
2、循环条件为:下标值<列表的元素数量

# 演示list列表的循环,使用while和for循环2种方式
def list_while_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list=["明日","清梦","压星河"]
    # 循环控制变量通过下标索引来控制,默认为0
    # 每一次循环将下标索引变量+1
    # 循环条件:下标索引变量<列表的元素熟练

    # 定义一个变量来标记列表的下标
    index=0   # 初始值为0
    while index<len(my_list):
          # 通过index变量,获取对应下标的元素
          element=my_list[index]
          print(f"列表的元素:{element}")
          # ⚠️:将循环变量index,每一次循环都要+1
          index+=1
# 调用函数
list_while_func()
'''
运行结果:
列表的元素:明日
列表的元素:清梦
列表的元素:压星河
'''

—for循环

for循环更加适合对列表等数据容器进行遍历
语法:
for 临时变量 in 数据容器:
    对临时变量进行处理

表示,从容器内,依次取出元素并赋值到临时变量上。
每一次的循环中,我们可以对临时变量(元素)进行处理。

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list=[1,2,3,4,5,6]
    # for 临时变量 in 数据容器:
    for element in my_list:
        print(f"列表的元素有:{element}")
# 调用函数
list_for_func()

'''
运行结果:
列表的元素有:1
列表的元素有:2
列表的元素有:3
列表的元素有:4
列表的元素有:5
列表的元素有:6
'''

while循环和for循环的对比

·在循环控制上:
  ·while循环可以自定循环条件,并执行控制
  ·for循环不可以自定循环条件,只可以一个个从容器内取出数据
·在无限循环上:
  ·while循环可以通过条件控制做到无限循环
  ·for循环理论上不可以,因为被遍历的容器容量不是无限的
·在使用场景上:
  ·while循环适用于任何想要循环的场景
  ·for循环适用于,遍历数据容器的场景或简单的固定次数循环场景

练习案例:取出列表内的偶数

定义一个列表,内容是[1,2,3,4,5,6,7,8,9,10]
·遍历列表,取出列表内的偶数,并存入一个新的列表对象中
·分别使用while循环和for循环操作

提示;
1、通过if判断来确认偶数
2、通过列表的append方法,来增加元素。
# while循环
my_list = [1,2,3,4,5,6,7,8,9,10]
new_list = []
i = 0
while i < len(my_list): # 下标小于列表总数时,开始循环
    if my_list[i] % 2 == 0:  # % 表示取余数
        """
        当my_list[0]的对应元素是1,1%2的余数是1;
        当my_list[1]的对应元素是2,2%2的余数是0;添加到new_list中
        当my_list[2]的对应元素是3,3%2的余数是1;
        当my_list[3]的对应元素是4,4%2的余数是0;添加到new_list中
        当my_list[4]的对应元素是5,5%2的余数是1;
        当my_list[5]的对应元素是6,6%2的余数是0;添加到new_list中
        当my_list[6]的对应元素是7,7%2的余数是1;
        当my_list[7]的对应元素是8,8%2的余数是0;添加到new_list中
        当my_list[8]的对应元素是9,9%2的余数是1;
        当my_list[9]的对应元素是10,10%2的余数是0;添加到new_list中
        ......
        """
        new_list.append(my_list[i]) #  列表.append(元素),在尾部追加元素
    i += 1
print(f"通过while循环,从列表{my_list}中取出偶数,组成新的列表{new_list}")

# for循环
new_list_2=[]
for i in my_list:
    if i % 2 == 0:
        new_list_2.append(i)
print(f"通过for循环,从列表{my_list}中取出偶数,组成新的列表{new_list_2}")


"""
运行结果:
通过while循环,从列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数,组成新的列表[2, 4, 6, 8, 10]
通过for循环,从列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数,组成新的列表[2, 4, 6, 8, 10]

进程已结束,退出代码为 0
"""

  • 30
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值