【10月更文挑战第8天】

1.列表---list

1. 索引的使用

当我们有一个数据的时候，我们怎么将这个数据存储到程序呢？

我们定义一个变量，将数据存储在变量中

那么如果有100个数据呢？要定义100个变量吗？

我们是可以用列表这个东西进行多个数据的存放

列表的定义：[ ]

空列表：[ ]

列表：[元素1，元素2，元素3 ]

列表中的内容叫做元素，元素与元素之间要用逗号进行分隔

#编辑模式
li=[]#空列表
print(type(li))
#交互模式
<class 'list'>#列表的意思

存放多个数据的列表：

li=[1234,'abcd',12.45]
print(type(li))

那么我们现在如何从这个列表里面拿取我们想要的元素呢？

我们可以通过列表的索引来取得对应位置上的值

使用方式：列表序列[索引]

注意：

1.索引值是从0开始的

2.负索引值就是从列表尾部往前数

3.索引取值超过长度就会报错

这个索引在C/C++中就是下标

列表对应C/C++就是数组

索引值的使用方式：

#编辑模式
li=[1234,'abcd',12.45]
print(type(li))

print(li[0])
print(li[1])
print(li[2])
#交互模式
<class 'list'>
1234
abcd
12.45

除了正索引我们还有负索引

负索引是怎么使用的呢？

我们是从右往左开始进行的

如果使用负索引的话，最右边的下标是-1

然后从左到右一次减小1位

负索引的使用：

#编辑模式：
li=[1234,'abcd',12.45]
print(type(li))
print("正索引")
print(li[0])
print(li[1])
print(li[2])

print("负索引")
print(li[-1])
print(li[-2])
print(li[-3])
#交互模式
正索引
1234
abcd
12.45
负索引
12.45
abcd
1234

正索引：从左往右（从0开始，依次变大）

负索引：从右往左（-1开始，依次减小）

对于这个列表中的12.45我们是有两种方式进行获取的

li[2] li[-1] 这两种表达都是指向12.45

正索引一般是拿比较靠前的元素的数据

负索引一般是拿比较靠后的元素的数据

通过len(序列)我们能查看序列的元素个数

index获取列表中对应元素的索引值

但是对于数组多的元素我们能不能通过代码的方式找到我么想要的那个元素的索引值呢？

我们可以通过index来寻找对应元素的索引值

index的使用方式：

#编辑模式
li=[1234,'abcd',12.45]
print(li.index("abcd"))
print(li.index(12.45))
#交互模式
1
2

通过这种方式能返回对应元素的索引值

这么我们就能在一个数组中进行元素的寻找了

返回的是列表中我们想要查找的元素的索引值

列表的切片--获取列表中一定范围的元素

通过上面的方法我们能进行一个元素的寻找

但是假如我们想一次拿多个元素怎么办呢？还是按照这样一个一个进行查找吗？

其实列表式可以根据一个范围来取值的，这称为切片

使用方式：列表名[开始索引：结束索引：步长]

开始索引默认值是0

结束索引默认值到最后一个元素

步长默认为1

注意：

1.切片是两个范围之间取值，且后面的数取不到

2.切片时范围超过也没有关系

3.切片时还可以指定步长，不指定时，步长默认为1

我们定义了结束索引值，我们取到的值是不包含结束索引值指向的元素的

[开始索引值，结束索引值)

因为这个开始索引值和结束索引值存在默认值

那么我们可以是不写这两个的，我们光写个结束索引值就行了

但是一开始的开始索引值和结束索引值之间的冒号不能省略了

切片获取列表中某个范围的元素：

#从列表中获取多个元素，我们通过切片

li=[1,2,3,4,5,6,7,8,9]

print(li[0:3:1])
#[1, 2, 3]
#我们这里只获取了1，1，2这三个元素，没有获取到4
#但是4的索引值是3啊
#为什么我们没有获取到呢？

#因为我们在取这个范围的元素的时候，我们是不包含这个结束索引指向的元素的

print(li[:3])

#步长的使用
#现在我们想获取1 3 5 7 9
#我们是可以通过步长进行获取的
print(li[:8:2])

#[1, 3, 5, 7]

#但是我们这里仅仅获取到了7，并没有拿到结束索引值指向的9
print(li[:9:2])

#[1, 3, 5, 7, 9]

#但是我们将这个结束索引值进行增加我们就拿到了最后的那个值9

#这里的步长就是元素与元素之间的间隔大小，我们这里的是2

#我们使用切片的时候结束索引超出了是没问题的
#但是我们直接使用索引的话，索引超出了范围是会报错的


print(li[::2])
#我们这里的话不写开头和结尾的索引值的话，我们也是能拿到这个列表中满足步长为2的元素的
#[1, 3, 5, 7, 9]

我们使用切片的时候结束索引超出了是没问题的

但是我们直接使用索引的话，索引超出了范围是会报错的

我们使用默认开始索引和结束索引我们也是能获取到这个列表中满足步长的元素的

对于获取一个范围没有规律的元素的方法：

#现在我们想获取1 3 4 6
#这种就没有什么规律了，那么我们怎么进行获取呢？
#但是分开看的话，1和3分隔2，4和6分隔2
#我们可以使用加号进行拼接，列表+列表是拼接，字符串+字符串是拼接
print(li[0:3:2])#通过这个我们能拿到[1, 3]
print(li[3:6:2])#通过这个我们拿到了[4, 6]

#那么我们现在如何进行拼接操作呢？
print(li[0:3:2]+li[3:6:2])#因为列表+列表是拼接，那么我们将两个获取到的直接进行相加

对于我们获取一个范围内分布有规律的元素我们可以设置步长

但是我们获取一个范围内排布没有规律的元素

我们可以将这个范围进行分割，分割为多个小范围列表，然后进行拼接，就能得到我们想要的列表了

列表的方法

列表的方法包括增删查改

列表的增

对于列表的增，我们存在三种方法：append extend insert

append的中文就是追加的意思

就是在列表的末尾进行元素的追加

entend就是扩展

insert就是插入的意思，在某一个地方进行元素的插入

1.append的使用方法

列表.append()

append的使用方法---追加：

li=['苹果']
#append直接在列表的尾部进行元素的插入的    就是追加
li.append("香蕉")
print(li)
#['苹果', '香蕉']
li.append("西瓜")
print(li)
['苹果', '香蕉', '西瓜']

insert的使用方法

列表.insert(插入位置的索引值，要插入的元素)----进行元素的插入，插队

insert的使用方法---插入到给定的索引值对应的元素的前面：

#现在我想将桃子查到香蕉的前面
li.insert(1,"桃子")
print(li)
#['苹果', '桃子', '香蕉', '西瓜']
#这里的元素索引就是我们要插入的位置的后面的那个元素的索引
#我们使用insert将元素插入到我们想要的元素的前面

extend(序列类型)

不能是数字或者是浮点数

extend的作用是将序列拆开，一个内容为一个元素进行添加

主要是将一个我们指定的队列追加到这个队列后面去

extend的使用方法：

li.extend("飞机")
print(li)
#['苹果', '桃子', '香蕉', '西瓜', '飞', '机']
#我们这里的飞机从一个元素变成了两个元素

#其实extend的作用是将序列拆开，一个内容为一个元素进行添加
#而且我们这里非要在里面添加序列类型
#不能是数字，一定要是序列类型
#序列类型是可以迭代的，但是整型是不可以的
#li.extend(12)，这种写法就会报错

#extend后面能添加的序列类型有：字符串、列表、元组
#数字整型浮点型是不能写入括号的


li.extend(li)
print(li)
#['苹果', '桃子', '香蕉', '西瓜', '飞', '机', '苹果', '桃子', '香蕉', '西瓜', '飞', '机']

列表的改

列表[索引]=新值

将列表中对应的索引对应的值进行新的赋值

列表元素的修改：

li=['苹果', '桃子', '香蕉', '西']
#现在我们想将西这个字符进行修改，修改为“西瓜”
li[-1]="西瓜"
print(li)
#['苹果', '桃子', '香蕉', '西瓜']

print(li.index("西瓜"))

列表的查

列表名.index("要查找的数据")

使用index进行元素的索引的查找：

#如果我们现在想将桃子改成飞机，但是我们不知道桃子在哪里
#我们使用index进行查找
print(li.index("桃子"))
li[li.index("桃子")]="飞机"
print(li)

#1   桃子的索引值
#['苹果', '飞机', '香蕉', '西瓜']

通过索引值我们能找到元素

通过列表的切片操作我们能找到一定范围的元素

通过我们的index我们能找到对应元素的索引值

列表的删

1.列表.pop(索引)

删除列表中指定索引的值

我们根据对应的索引值将这个元素进行删除

列表.pop(对应元素的索引值）：

#将4删除（如果存在多个的话我们只能删除最前面的）
li=[1,2,3,4,5,1,2,3,4,5]
li.pop(li.index(4))
print(li)
#[1, 2, 3, 1, 2, 3, 4, 5]
li.pop()
print(li)#我们这里没有指定索引，那么就是删除最后一个
#[1, 2, 3, 1, 2, 3, 4,]

我们不指定索引值的话，那么默认就是将最后一个元素删除掉

2.列表.remove(元素)

删除列表中指定的值（如果存在多个的话我们是只能删除最前面的这个值，不能你全部删除掉）

列表.remove(对应的元素)：

li=[1,2,3,4,5,1,2,3,4,5]
li.remove(5)
print(li)
#[1, 2, 3, 4, 1, 2, 3, 4, 5]

3.del 序列

直接将序列从内存中删除掉

如果我们再想找到这个序列的话是找不到了

也是无法打印的，就说我们未定义

del li
print(li)
'''
Traceback (most recent call last):
  File "C:\Users\27890\Desktop\序列类型（列表、元组）.py", line 158, in <module>
    print(li)
NameError: name 'li' is not defined
'''

4.列表的清空操作

列表.clear()---直接清空列表中的元素，得到一个空列表

clear的使用：

li1=[1,2,3,4,5,1,2,3,4,5]
li1.clear()
print(li1)
#[]

列表的嵌套---二维列表

二维列表元素的获取：

li=[[12,"小明"],[13,"小红"],[15,"凯子"]]
for i in li:#这个循环后面的序列
    print(i)#每次打印列表中的一个元素

#我们现在想要获取小明怎么写代码呢？
print(li[0][1])
#小明

列表中还存在多个列表就是列表的嵌套

列表中的一些适用的方法：

1.列表.index()----查找某个元素的索引值

2.列表.count()----计算列表中某个元素的个数

li=['苹果', '飞机', '香蕉', '西瓜']
print(li.count("西瓜"))
#1

3.len(序列)----计算出某个列表的元素的个数

li=['苹果', '飞机', '香蕉', '西瓜']

print(len(li))
#4

下面的两个找最大最小值的函数一定要保证序列的里面的元素是一样的

4.max(序列)---获取序列中的最大值

5.min(序列)---获取序列中的最小值

li2=[1,5,6,8,9,1,20,56]

print(max(li2))
print(min(li2))
#56
#1

6.reverse---倒序

列表.reverse()

li=[1, 1, 4, 5, 5, 5, 6, 8, 46]
li.reverse()
print(li)
#[46, 8, 6, 5, 5, 5, 4, 1, 1]

7.sort列表的排序功能

要确保列表中的类型都是同一个类型，不是一个类型的数据怎么比？比不了的

默认的是从小到大的排序---升序

li=[1,5,6,8,4,1,5,46,5]
li.sort()
print(li)
#[1, 1, 4, 5, 5, 5, 6, 8, 46]

如果想要降序的操作话，只需要两步

第一步就是将数组进行排序--默认是升序

然后我们使用reverse进行列表的元素的颠倒，然后就得到了降序的列表

但是我们还有一种方式更快捷

列表.sort(reverse=True/False)

我们可以对reverse的调整，调整为这个列表倒不倒序

因为sort的排序是从小到大的

所以reverse的值默认是False

那么我们就需要将reverse改成True

在sort中对reverse进行调整实现倒序：

li=[1, 1, 4, 5, 5, 5, 6, 8, 46]
li.sort(reverse=True)
print(li)
#[46, 8, 6, 5, 5, 5, 4, 1, 1]

当sort里面的reverse为True的时候就是我同意你去倒序了

8.sorted

这个是临时排序

我们的sort是永久排序，在列表上直接进行修改，对列表产生实质的永久的影响

我们这里也是可以设置这个reverse参数

不设置的话就是False

这个sorted是不会在原列表上进行修改的

是会生成一个新的列表

这个新的列表就是基于原列表的修改的列表

li=[46, 8, 6, 5, 5, 5, 4, 1, 1]
li3=sorted(li,reverse=False)#这里默认是升序的
print(li3)

临时排序默认打印出来的也是升序的列表

临时排序sorted不会对排序的列表直接进行修改，而且生成一个新的列表

永久排序sort会对排序的列表直接进行修改

两种排序默认都是从小到大，升序

如果想要变成降序的话，我们需要将reverse的参数进行修改，将默认的False改成True

对于这些函数来说

max min sum len 都是在括号内写序列的

其他的就是在函数前面加上函数名+.然后就能进行调用了