python的列表和元祖详解

列表类型 list

“”“列表特征: 可获取,可修改,有序”“”

列表 list:
列表可以存多个数据，且数据可以是不同数据类型，但工作之中，一个列表一般存相同的数据类型
可以对列表进行增删查改操作

列表是可变类型

1.定义一个空列表

listvar = []
print( listvar , type(listvar))

#定义普通列表

listvar = [98,6.9,True,12-90j,"赵万里"]

2.获取列表中的元素

#正向索引   0     1      2         3          4
listvar =      [98, 6.9, True, 12-90j, "赵万里"]
#逆向索引  -5    -4     -3      -2          -1

res = listvar[2]
res = listvar[-2]
print(res)

service = ['http','ssh','ftp']

print(service[1])    ##输出第二个元素，ssh
print(service[-1])   ##输出最后一个元素，ftp

#len 获取容器类型数据中元素个数
length = len(listvar)
res = listvar[length-1]
print(res)

3 列表切片：

列表的切片操作
完整的切片表达式使用2个冒号分隔的3个参数[start : stop : step]
第一个数字表示切片开始的位置（默认为0），第二个数字表示切片截至（但不包含）位置（默认为列表长度），第三个数字表示切片的步长（默认为1），当步长省略时可以省略最后一个冒号。
语法 => 列表[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到列表的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
(5)[:]或[::] 截取所有列表

print(service[1:]) ##打印第一个元素之后的内容
print(service[:-1]) ##打印最后一个元素之前的内容
print(service[::-1]) ##倒序输出

lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]

(1)[开始索引:] 从开始索引截取到列表的最后

res =lst[2:]
print(res)

(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)

res =lst[:3]
print(res)

(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)

res = lst[3:5]
print(res)

(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值

#正向截取

res = lst[::5]
print(res) # 0 5 10
#逆向截取
res = lst[::-3] # -1 -4 -7
print(res)

(5)[:]或[::] 截取所有列表

res = lst[:]
res = lst[::]
print(res)

(6)列表的获取 (同元组)

#0  1  2
lst = [10,20,30]
#-3  -2 -1
print(lst[-1])

重复：

print(service * 3) ##输出三遍

连接：

service1 = ['nfs','samba']
print(service + service1)

成员操作赋:

print(‘nfs’ in service) ##判断是否存在
输出结果为 true或false

迭代:[for循环遍历]

for i in service:
    print(i)       ##遍历输出每个元素

列表里嵌套列表

service2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]

对其索引：print(service2[2][1]) ##第三个元素中的第二个元素 tony
对其切片：print(service2[:][1]) ##第二个元素 [1,2,3]

4 列表的增删改查

1.增加

往列表里增加元素:

1.print(service + [‘firewalld’]) ##用连接的方式

列表不能通过索引添加元素

2.service.append(‘firewalld’) print(service) ##append:追加一个元素到列表结尾

name_list = ["张三", "李四", "王五"]

name_list.append("赵刚")

print(name_list)

['张三', '李四', '王五', '赵刚']

在原内存中修改，修改前后内存地址不变

这个提示，在两行之间加上任意语句即可取消

3.extend:拉伸 逐一追加多个元素到列表中 service.extend([‘mysql’,‘firewalld’]) 插入的数据得是可迭代数据（容器类型数据，range对象，迭代器）extend没有返回值

name_list.extend("赵刚")

['张三', '李四', '王五', '赵', '刚']  将追加的元素分开追加到列表结尾

name_list.extend(["花蛤", "景浩"])

['张三', '李四', '王五', '花蛤', '景浩']

4.service.insert(1,‘samba’) ###在指定索引位置插入元素 ##在第二个元素的位置插入samba作为第二个元素,原元素后移，相当于在指定元素前面插入元素

name_list.insert(2, “景浩”)
[‘张三’, ‘李四’, ‘景浩’, ‘王五’]
insert就是在指定元素前面插入数据，正索引，在索引位置插入数据，负索引，在索引位置前面插入数据

2.删除

1.service.pop() ##默认弹出最后一个元素
a = service.pop(0) ##弹出第1个元素 ###可以将其赋值

2.service.remove(‘ssh’) ##指定删除对象的名字 ##直接删除，该方法没有返回值，不能将其赋值 ##不能是指定序号，只能指定要删除的对象
如果有多个相同元素，默认删除第一个
有索引的情况下，推荐使用pop，效率高于remove

name_list.remove("王五")
print(name_list)
['张三', '李四']

用序号删报错

3. del service ##删除列表
   

del name_list  ##直接删除整个列表
print(name_list)

NameError: name 'name_list' is not defined

也可以删除指定下标的数据
del name_list[1]

一次删除多个：删除指定下标范围，左闭右开

删除完列表个别元素，列表下标重新排列
如下，删除下标0的元素后，原下标1的元素成为下标0

4.clear() 清空列表

name_list.clear()
print(name_list)
[]

5.remove 删除指定数据：

teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
teachers.remove('H')

print(teachers)
['A', 'B', 'C', 'D', 'E', 'F', 'G']

不存在，删除报错

删除前可做个判断：

3.修改

前提是该索引处有数据

1.service[0] = ‘mysql’ ##通过索引 重新赋值，就是修改

2.service[:2] = [‘samba’,‘iscsi’] ##通过切片给前两个元素重新赋值

4.查看：
查看出现的次数

service.count('ssh')

修改多个值，如果使用切片进行修改,要求数据必须是Iterable可迭代性数据

带有步长的方式修改，相当于把相关下表位置的值给一次性改了，但要修改的字段要与步长选出的数据个数一致

5.排序

sort 排序 默认升序 没有返回值
对字符串排序不区分大小写

names = ['alice','Bob','coco','Harry']
names.sort()

names ###按照ASCLL排序 ###先排序首字母为大写的，再排序首字母是小写的
字符串排序，遵从ASCII码 从第一个字母开始，第一个相同按第二个，以此类推

name.sort(key=None, reverse=True(降序)  reverse=False(升序 默认))

names.sort(key=str.lower)   ###对字符串排序不区分大小写，相当于将所有元素转换为小写，再排序
names.sort(key=str.upper)   ###相当于将所有元素转换为大写，再排序

name_list.sort(reverse=True)
print(name_list)

name_list.sort(reverse=False)

print(name_list)

str1 = [1, 2, 3, 5, 6, 33, 65, 22, 11]
str1.sort()
print(str1)
[1, 2, 3, 5, 6, 11, 22, 33, 65]

str1.sort(reverse=True) 降序排序

简单的升序排序是非常容易的。只需要调用sorted()方法。
它返回一个新的list，新的list的元素基于小于运算符(lt)来排序。

复制代码代码如下:

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

你也可以使用list.sort()方法来排序，此时list本身将被修改。
通常此方法不如sorted()方便，但是如果你不需要保留原来的list，sort方法将更有效。

另一个不同就是list.sort()方法仅被定义在list中，相反地sorted()方法对所有的可迭代序列都有效，返回一个排序后的列表

我们需要对List进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序
方法2.用内建函数sorted进行排序（从python 2.4开始）

sort函数定义：sort(cmp=None, key=None, reverse=False)

sorted函数定义：sorted(iterable, cmp=None, key=None, reverse=False)

参数解析：

iterable：是可迭代类型;
cmp：用于比较的函数（大于时返回1，小于时返回-1，等于时返回0），
比较什么由key决定,有默认值，迭代集合中的一项;
key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 或者 reverse = False，有默认值。

注：sort( )函数与sorted( )函数最大的区别是， sort( )函数时对已存在的列表进行操作，
调用其没有返回值；而sorted( )函数是返回一个新的list,不在原来的list上进行操作，
调用其返回一个排好序的list。

示例1：

list1 = [9, 1, 3, 45, 54]

list2 = sorted(list1)

print(list2)


[1, 3, 9, 45, 54]

#是否可以对中文排序(了解 无规律可循)

lst = ["王文","蔡徐坤"]
lst.sort()
print(lst)

中文可以排序，根据相应字符集，来排序

5列表元素查找

index()返回指定数据所在位置的下标,如果有相同元素，返回第一次元素出现的下标

语法：
列表序列.index(数据, 开始位置下标,结束位置下标)

开始位置和结束位置不写表示全局查找

list1 = ['天河', '越秀', '荔湾']

print(list1.index("荔湾", 0, 3))

输出2

如果查找的数据不存在就报错，后面可以通过try except 来抑制这个报错

元祖元素查找同理

鼠标放在方法上，按住ctrl 键，可以点进去查看系统方法的具体使用方法

len(),返回列表长度，即列表中数据的个数

print(list1.__len__())
print(len(list1))

3
3

count()返回列表中数据出现次数

数据不存在返回0，列表中的count不能指定查找范围

判断某个数据是否存在于列表中
in: 存在返回True,不存在返回False not in与之相反

print("天河" in list1)

修改列表：
直接将指定下标的值重新赋值：

name_list[0] = "景浩"
print(name_list)
['景浩', '李四', '王五']

reverse() 逆置列表，将列表中的数据顺序颠倒, 返回空，执行后，直接把原列表反转了。与切片逆序功能类似

name_list.reverse()
print(name_list)
['王五', '李四', '张三']

列表复制：

name_list2 = name_list.copy()
print(name_list2)

name_list = ['张三', '李四', '景浩', '王五']


列表遍历while循环：
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

张三
李四
景浩
王五

列表遍历for循环：

for i in name_list:
    print(i)

张三
李四
景浩
王五

for循环比较简洁

列表嵌套：
大列表里面包含小列表，小列表称为子列表

name_list3 = ['张三', ['黄丹', '刘飞'], '李四', '景浩', '王五']

print(name_list3[1][1])

刘飞

for i in name_list3:
    print(i)

张三
[‘黄丹’, ‘刘飞’]
李四
景浩
王五

随机分配办公室：

import random

teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
offices = [[], [], []]

for name in teachers:
    num = random.randint(0, 2)
    offices[num].append(name)

print(offices)

i = 1
for office in offices:
    print(f'办公室{i}的人数是{len(office)},老师的名字是:')
    for name in office:
        print(name)
    i += 1

元祖

一个元祖可以存多个数据，元祖内的数据不可以修改
t1 = (‘景浩’, ‘耀东’, ‘梅江’)

#注意点
“”“逗号才是区分是否是元组的标识符”“”
元祖内如果只有一个数据，后面也要加逗号，否则数据类型为该数据的数据类型

t2 = (3)
print(type(t2))

<class 'int'>

t2 = (3,)
print(type(t2))

<class 'tuple'>

1 定义空元祖

2 元祖不支持修改，只支持查找操作

按下标查找

print(t1[0])

index：
返回下标，不存在的话就报错
print(t1.index(‘耀东’))

1

count:
统计某个数据出现的次数

len:
统计元祖中的元素个数

强行修改元祖，会出现报错

t1[2] = ‘王五’
TypeError: ‘tuple’ object does not support item assignment

3 创建一个新的元组

tup3 = tup1 + tup2;
print tup3;
#以上实例输出结果：
#(12, 34.56, ‘abc’, ‘xyz’)

4 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = (‘physics’, ‘chemistry’, 1997, 2000);
del tup;

如果元祖里面有列表元素，则可以修改列表那一项的数据。即元祖中的元素有可变类型，则可以修改该元素中的值

t1 = (‘景浩’, ‘耀东’, ‘梅江’, [1, 2, 3])

t1[3][1] = ‘王五’

print(t1)

(‘景浩’, ‘耀东’, ‘梅江’, [1, ‘王五’, 3])

工作中有不能修改的数据，定义成元祖

修改元祖中可变类型字典中的元素值