7-Python基础编程之数据类型操作——列表和元组

列表

概念

有序的可变的元素集合

定义

普通生成

普通列表：

[元素1, 元素2…]
nums=[1,2,3,4,5]

嵌套列表：
列表中的元素还可以是列表；可以存放不同的数据类型

[1, 2, 3, ‘sx’, True, [‘a’, ‘b’, ‘c’]]

names = [1, 2, 3, 'sx', True, ['a', 'b', 'c']]
print(names, type(names))

输出：
[1, 2, 3, ‘sx’, True, [‘a’, ‘b’, ‘c’]] <class ‘list’>

列表生成式

指的是快速生成list
利用range()循环，参数为开始；结束；步长

nums = range(1,100,1)
print(nums)

输出:
range(1, 100, 1)

注意：为什么输出的不是[1…99]；这是因为在python3中为了防止创建的列表没有被使用而占内存，先暂存为range(1, 100, 1)此输出形式。

列表推导式

指的是映射解析，一对一的变更；或过滤，从多到少
平方操作

# 
nums=[1,2,3,4,5]
resultList=[]
for num in nums:
    result=num**2
    resultList.append(result)
print(resultList)

输出：
[1, 4, 9, 16, 25]

利用[表达式 for 变量 in 列表]，则对于列表推导式可以写成：

nums=[1,2,3,4,5]
resultList=[num**2 for num in nums]
print(resultList)

筛选奇数

# 筛选奇数
nums=[1,2,3,4,5]
resultList=[]
for num in nums:
    if num%2!=0:
        resultList.append(num)
print(resultList)

输出：
[1, 3, 5]

利用[表达式 for 变量 in 列表 if 条件]，对于列表推导式可以写成：

nums=[1,2,3,4,5]
resultList=[num for num in nums if num%2 !=0]
print(resultList)

操作

增加

nums=[1,2,3,4]
print(nums)
nums.append(5) # 利用append()指令进行添加，但只加到最后
print(nums)
nums.insert(2,2.5) # 利用insert()指令进行插入，参数为：位置；插入元素
print(nums)
nums2=['a','b','c']
nums.extend(nums2) # 利用extend()指令进行拼接
print(nums)
print(nums*3) # 利用直接对列表相乘，使得列表变为原来的三遍
print(nums+nums2) # 利用加法直接进行拼接

# 注意：但+和extend拼接不同的是，+不改变源列表且只能和列表类型相加，但是extend会改变；而且会将后面迭代对象分解开相加
print(nums)
nums3='qwer'
nums2.extend(nums3)
print(nums2)

输出：

删除

nums=[1,2,3,4,5]
del nums[1] # del删除指定元素；还可以删除整个变量（del nums）其输出为未定义
print(nums)
nums=[1,2,3,4,5]
re=nums.pop() # pop移除并返回指定索引元素（默认为-1）
print(re, nums)
nums=[1,2,3,4,3,5]
nums.remove(3) # remove移除指定元素（参数指定的不是索引而是删除的元素），从左往右删除
print(nums)

# 若想删除多个是不能需要遍历（因为我们遍历的移除会导致列表变动和但指针不会重新移动所以可能会有漏）
nums=[1,2,3,4,3,5,3,3]
for num in nums:
    if num==3:
        nums.remove(num)
print(nums)

输出：

修改

# 当我们想操作列表中某个元素时，一定是通过索引，来操作指定元素
nums=[1,2,3,4,5]
nums[2]=6
print(nums)

输出：
[1, 2, 6, 4, 5]

查找

# 利用索引获取单个元素
nums=[1,2,5,3,4,4,6,5,5,55]
print(nums[5])
print(nums[-1])

# 获取对应元素索引
idx=nums.index(5)
print(idx)
idx=nums.index(5,3) # 可以通过设定选定区间来查找对应区间的元素索引
print(idx)

# 获取指定元素个数 
c=nums.count(5)
print(c)

# 切片获取多个元素
pic1=nums[::] # 获取全部
pic2=nums[2:6:] # 获取索引为2到5的
pic3=nums[2:6:2] # 获取索引为2到5的，步长为2
pic4=nums[::-1] # 反转整个列表
print(pic1)
print(pic2)
print(pic3)
print(pic4)

输出：

遍历

# 根据元素进行遍历+打印索引值
nums=['a','b','c','g']
currentIndex=0
for n in nums:
    print(n)
    print(nums.index(n, currentIndex))
    currentIndex+=1

输出：

# 根据索引进行遍历
# 通过造索引列表，遍历整个索引列表，查找指定的值
values=['a','b','c','g']
indexs=range(len(values)) # 创建的索引列表，根据列表长度
for index in indexs:
    print(index, values[index])

输出：

通过枚举法的遍历，首先先了解下什么是枚举

枚举函数，指的是生成的一个新的对象，函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个案引序列，同时列出数据下标和数据的方法。

# 通过枚举法：enumerate(sequenge, [start=0])，sequence指的是序列对象，start是起始位置
values=['a','b','c','g']
print(enumerate(values)) # 枚举对象
print(list(enumerate(values))) # 查看打印，发现是索引＋值的列表形式
for idx, val in enumerate(values):
    print(idx, val)# 我们遍历出来

输出：

迭代器进行遍历

首先了解下什么是迭代，它是指访问集合元素的一种方式，按照某种顺字逐个访问集合中的每一项
判断依据是能做用于for in 或是用 isinstance(obj, collections.abc.Iterable)判断

# 通过迭代进行遍历 isinstance(obj, collections.Iterable)
import collections
values=['a','b','c','g']
#print(help(collections))
res=isinstance(values, collections.abc.Iterable)
print(res)

输出：True

什么是迭代器？
迭代器是可以记录遍历位置的对象；从第一个元素开始，往后通过next()函数进行遍历；只能往后,不能往前
判定依据为能否作用于：next()函数或isinstance(obj, collections.Iterator)

# 迭代器
import collections
values=['a','b','c','g']
res=isinstance(values, collections.abc.Iterator)
print(res)

输出：False

# 设置迭代器
values=['a','b','c','g']
i=iter(values) # 设置为迭代器
print(i)
res=isinstance(i, collections.abc.Iterator)
print(res)

输出：

那为什么会产生用迭代器呢？因为迭代器具有以下优点：

1. 仅仅在迭代到某个元素时才处理该元素，在此之前元素可以不存在，在此之后元素可以被销毁，这就表明了他适合用于遍历一些巨大或者无限的集合中去，比如斐波那契数列（下一个数为前两个数之和的数列）.
2. 提供了一个统一的访问集合的接口，可以把所有的可选代对象，转换成选代器进行使用（就是说对于列表、元组、字符串等不同类型的也能写出统一的遍历代码）

其使用就是使用next()的函数，从选代器中取出下一个对象，从第1个元素开始；但在python当中是直接可以用for in的，其内部会自动调用迭代器next()；并且迭代器对象一般不能多次迭代的

l=['a','b','c','g']
it = iter(l)
print(next(it))
print(next(it))
print(next(it))
print(next(it))

输出：

其等于

l=['a','b','c','g']
it = iter(l)
for i in it:
    print(i)
print('---------')
for i in it:
    print(i)

输出：

判断和比较

# 判断
l=['a','b','c','g']
print('a' in l)
print('a' not in l)

输出：

比较就是 > < ==这些符号

排序

# 排序
# sorted(itrearble,key=None, reverse=False) 可迭代对象；排序关键字；控制升降序（默认为升）

s='adifojrbgkjnsd'
result=sorted(s) # 升序
print(result)

result2=sorted(s, reverse=True) # 降序
print(result2)

n=[1,5,9,8,5,6,4]
result3=sorted(n) # 数字排序
print(result3)

s=[("sz", 18), ("sz2", 16), ("sz1", 17), ("sz3", 15)]
result4=sorted(s) # 按照元组的第一个元素排序的
print(result4)
#按照第二个元素排序呢？
def getKey(x): # 写一个函数返回元素的第二位置数
    return x[1]
result5=sorted(s, key=getKey)
print(result5)

输出：

# 对于sorted操作我们不会改变原列表
# 我们使用sort操作会改变原列表其只能操作列表
# list.sort(itrearble,key=None, reverse=False) 可迭代对象；排序关键字；控制升降序（默认为升）
n=[1,5,9,8,5,6,4]
n.sort()
print(n)

s=[("sz", 18), ("sz2", 16), ("sz1", 17), ("sz3", 15)]
s.sort()
print(s)

#按照第二个元素排序呢？
s2=[("sz", 18), ("sz2", 16), ("sz1", 17), ("sz3", 15)]
def getKey(x): # 写一个函数返回元素的第二位置数
    return x[1]
s2.sort(key=getKey)
print(s2)

输出：

乱序和反转

# 乱序
import random
l=[1,2,3,4,5,6]
res1 = random.shuffle(l) # 改变的是原列表
print(res1, l)

# 反转
l=[1,2,3,4,5,6]
res2 = l.reverse() # 改变的也是原列表
print(res2, l)

l=[1,2,3,4,5,6]
res = l[::-1] # 不改变院列表的反转
print(res, l)

输出：

元组

概念

有序的不可变的元素集合，和列表的区别就是元组元素不可被修改。

定义

# 单个元素
t1=(1,)
print(t1, type(t1))
# 多个元素
t2=(1,2,3,4)
print(t2, type(t2))
# 多个对象，以逗号隔开
t3 = 1,2,3,'abc'
print(t3, type(t3))
# 列表转化元组
l=[1,2,3,4,5,6]
t4=tuple(l) # 转化操作
print(t4, type(t4))
t5=(1,2,('a',1))
print(t5, type(t5))

输出：

操作

因为不可变性，其增、删、改是不允许的

查询

t=(1,2,3,4)
# 索引查找
print(t[0])
print(t[0:2]) # 其也是可以进行切片的
print(t[::-1]) # 反转元组

输出：

获取

操作跟列表差不多

t=(1,2,3,4,8,2,3,9,2)
print(t.count(2)) # 统计元组指定元素个数
print(t.index(2)) # 获取指定元素对应的索引
print(len(t)) # 统计元素个数
print(max(t)) # 统计最大值
print(min(t)) # 统计最小值

输出：

判定和比较

# 判断
t=(1,2,3,4,8,2,3,9,2)
print(1 in t)
print(10 not in t)

输出：

比较还是 > < == !=

拼接

完全和列表一样的，但不改变元组本身

t=(1,2,3,4)
tt=(1,2)
print(t*2)
print(t+tt)

输出：

拆包

a=1
b=2
s=(a,b)
b,a=s
print(a,b,s)

输出：