什么！你还在学列表和元组？！这一篇文章就够了！之Python基础篇-列表与元组

列表定义

• 列表的格式：列表名=[元素1 , 元素2 , 元素3 , ... ...]
• 空列表的定义：my_list = []（常用）    或    my_list = list()
• 列表中的元素不需要具有相同的类型。

#定义列表list1，且列表中的元素不具有相同的类型
>>> list1=['xiaoming','m',201,54,'13458714']
>>> type(list1)
<class 'list'>
 
#创建空列表my_list
#方法一（常用）
>>> my_list=[]
>>> type(my_list)
<class 'list'>
#方法二
>>> my_list=list()
>>> type(my_list)
<class 'list'>

• 补充：列表内存地址占用

list = []
print(id(list))  #通过id方法查看列表地址  此时输出 1352129433856
#我们再定义一个列表与上面列表名称相同
list = []
print(id(list))  # 此时输出结果为 1352129435712

#以上可以看出 当列表为空，再次定义相同列表，列表并不会覆盖，而是占用两个地址

#------------------------------------------------------
list = []
print(id(list))  # 此时输出  2637067112704


list = [2,3]  #对我们的列表进行复制 
print(id(list))  # 此时输出 2637067114560
#那如果我们替换列表中的元素呢？
list[0] = 1 #将列表中的 2 改为 1
print(id(list)) # 此时输出  2637067114560  通俗来讲就是你的列表栈地址未变，改变的是栈内的堆，因此列表的内存地址不会改变


#因此可以看出更改列表元素并不会更改列表地址

列表索引与遍历

list1=['xiaoming','m',20,50,'123456',20]

#下标从零开始依次往后推移


#既然有了下标索引，我们就可以进行遍历了

# 遍历数组所有元素
for i in list1:
    print(i,end=' ')  # 输出结果为 xiaoming m 20 50 123456 20 

#也可以根据下表进行遍历
length = len(list1)  #获取列表长度
for i in range(lenth)
    print (list1[i],end=' ') # 输出结果为 xiaoming m 20 50 123456 20 

列表常用操作方法

3.列表增删改查
ls6 = [11, 22]
# 添加数据
ls6.append(33)  # 末尾追加
print(ls6)  # [11, 22, 33]
# 指定索引插入数据
ls6.insert(1, 'hello')
print(ls6)  # [11, 'hello', 22, 33]
ls6.extend(['a', 'b'])  # 合并另外一个列表
print(ls6)  # [11, 'hello', 22, 33, 'a', 'b']

# 查询数据
print(ls6[2])  # 根据索引查询数据
print(ls6.index('hello'))  # 1   根据数据查询索引
print(ls6.index(22, 1, 5))  # 2  指定区间内根据数据查询索引
ls6.append(22)
print(ls6)  # [11, 'hello', 22, 33, 'a', 'b', 22]
print(ls6.count(22))  # 2, 统计数据在列表中的个数

# 修改数据
ls6[3]=True   # 根据索引修改
print(ls6)  # [11, 'hello', 22, True, 'a', 'b', 22]

# 删除数据
del ls6[2]  # 根据索引删除数据
print(ls6)  # [11, 'hello', True, 'a', 'b', 22]
ls6.remove(True)  # 删除指定数据
print(ls6)   # [11, 'hello', 'a', 'b', 22]
ls6.pop()  # 末尾删除
print(ls6)  # [11, 'hello', 'a', 'b']
ls6.pop(2)  # 根据索引删除数据
print(ls6)   # [11, 'hello', 'b']
# ls6.clear()   # 清空数据
# print(ls6)  # []
# del ls6  # 删除变量
# print(ls6)

# 4.其他方法
ls7=ls6.copy()  # 拷贝一个新的列表
print(ls7) # [11, 'hello', 'b']
ls7.reverse() # 列表翻转
print(ls7)  # ['b', 'hello', 11]
ls8=[10,45,20,32,65]
ls8.sort(reverse=False) # 默认 reverse是False 升序
print(ls8)  # [10, 20, 32, 45, 65]
ls8.sort(reverse=True)
print(ls8)  # [65, 45, 32, 20, 10]  降序\

5.列表的切片

"""
  切片:ls[start:stop:step]
  start：开始切片的位置,默认值0，可省略不写
  stop：结束切片的位置,默认值是列表长度，可省略不写
  step：步长，默认值为1，可以省略不写
"""
# 切片获取数据
print(ls[1:5])  # ['2', '3', '4', '5']
print(ls[:3])  # ['1', '2', '3']  获取前3个元素
print(ls[5:])  # ['6', '7', '8']  获取下标5以后得数据

print(ls[1:5:2])  # ['2', '4']  下标跳2个
print(ls[5:1:-1])  # ['6', '5', '4', '3']
# 切片翻转
print(ls[::-1])  # ['8', '7', '6', '5', '4', '3', '2', '1']
s = 'hello'
print(s[1:4])  # ell

# ['1', '2', '3', '4', '5', '6', '7', '8']
# 切片替换
# ls[2:4]=['a','b','c']   # 步长为1，可将截取的内容替换
# print(ls)  # ['1', '2', 'a', 'b', 'c', '5', '6', '7', '8']
print(ls[1:6:2])  # ['2', '4', '6']
ls[1:6:2] = ['a', 'b', 'c']  # 步长不为1，只能同位置替换
print(ls)  # ['1', 'a', '3', 'b', '5', 'c', '7', '8']

# 列表乘法
print(['a', 'b'] * 3)  # ['a', 'b', 'a', 'b', 'a', 'b']
# 列表加法
print(['a', 'b'] + [11, 22])  # ['a', 'b', 11, 22]
# 列表成员运算
print('a' in ['a', 'b'])  # True
print('a' not in ['a', 'b'])  # False


#通过一个简单的小案例来应用切片操作
month = 3
day = 0
if month in [1, 3, 5, 7, 8, 10, 12]:
    day = 31
elif month in [4, 6, 9, 11]:
    day = 30
elif month == 2:
    day = 29
print(day)  # 31

元组定义

• 元组名 = ( 元素1 , 元素2 , ... ... )

#当定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来
>>> tup1 = ('Edge', 'Runoob', 2024, 2000)  


>>> tup1=()
>>> type(tup1)   #创建空元组
<class 'tuple'>
 
>>> tup2=(50)
>>> type(tup2)   #不加逗号，类型为整型
<class 'int'>
 
>>> tup3=(50,)   #加上逗号，类型为元组
>>> type(tup3)
<class 'tuple'>


#在Python中，很多人认为元组创建需要使用（），其实不然，真正决定元组的形式是逗号。
>>> tup='','b',1,2
>>> type(tup)
<class 'tuple'>

元组遍历

# 5.遍历
list9 = (10, 'a', 20, 'b', 5)

for item in list9:
    print(item, end='\t')
print()

for i in range(len(list9)):
    print(list9[i], end='\t')
print()

for key, val in enumerate(list9):
    print(key, val)

元组常用操作方法

"""
  列表,有序(索引)可重复，可更新
  元组,有序(索引)可重复，不可更新
"""
# 1.创建
tuple1 = (10, 20, 'a', True)
tuple2 = ()
tuple3 = tuple()
tuple4 = (10,)
print(tuple1)
print(tuple4)
# 2.类型转换
tuple5 = tuple('hello')  # str->tuple
str5 = str(tuple5)  # tuple->str
tuple6 = tuple(['a', 10, 20])  # list->tuple
list6 = list(tuple6)  # list->tuple
print(tuple5)
print(str5, type(str5))
print(tuple6)  # ('a', 10, 20)
print(list6)  # ['a', 10, 20]
# 3.增删改(不可更新)   查
list7 = (10, 5, 20, 5)
# 查询
print(list7[1])  # 根据下标获取元素
print(list7.index(10))  # 根据元素获取下标
print(list7.count(5))  # 查询元素在元组中的个数
# 4.通用操作
# 内置函数
print(max(list7))
print(min(list7))
print(sum(list7))
print(len(list7))

元组与列表切片

# 切片
list8 = (10, 'a', 20, 'b', 5)
print(list8[1:3])
# 加法和乘法
print((1, 2) + ('a', 'b'))  # (1, 2, 'a', 'b')
print(('a', 'b') * 2)  # ('a', 'b', 'a', 'b')
# 成员运算
print(1 in (1, 2))  # True

列表与元组差异

• 列表,有序(索引)可重复，可更新
• 元组,有序(索引)可重复，不可更新
• 你可能会有疑问为什么列表包含方法包含元组方法，相对于元组来说列表更好使用，为什么还有元组呢？
• 对于计算机来说，调用由于元组方法少于列表，调用元组运算量会少于列表，因此这就是元组方法没有列表多还存在的意义