一、 什么是数据结构

在计算机科学中，数据结构（英语：data structure）是计算机中存储、组织数据的方式。

1. Python 中核心数据结构分类

• 序列类型： 字符串、列表、元组
• 泛映射类型： 字典
• 集合： set()

在 Python中列表、元组、字典、集合都称为容器。

2. 序列类型数据结构共有的特点：

• 序列类型中的元素都有对应的位置，这个位置叫偏移量或者索引

千锋云计算

---

---

二、列表

1. 列表的特性介绍

• 列表内的元素是可变的。
  -> 列表的元素可以是 Python 的任何类型的数据和对象

  如：字符串、列表、元组、字典、集合、函数、类
  

• 列表中的具有相同值的元素允许出现多次

[1, 2, 1, 1, 1, 1, 3, 3, 2]

2. 创建列表

image.png

嵌套的列表

列表中可包含 python 中任何类型的元素(对象)，当然也可以包括一个或多个列表

li = [['one', 'two', 'three'], [1, 2, 3]]

3.列表的基本操作

3.1 取值

没有嵌套的列表

li_f = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']

li_f[0]   # insert

嵌套的列表

l2 = [['one', 'two', 'three'], [1, 2, 3]]

l2[0][1]  # two

3.2 切片

同字符串的切片一样,详情参考字符串的切片

几点简单示例

li_f = [ 'insert', 'append','extend', 'remove', 'pop', 'sort', 'sorted']

# 获取全部元素
li_f[:]

# 反转
li_f[::-1]

3.3 必会方法

# 先定义一个列表
li = [5, 4, 3, 2, 1, 0]

len()
方法是一个内置函数，可以统计序列类型的数据结构的长度。

n = len(li)
print(n)

in
判断元素是否存在于列表中。

if 5 in li:
    print('我存在')

append()
向列表的最后位置，添加一个元素，只接收一个参数。

li.append('a')
print(li)

insert()
向原列表的指定位置插入一个元素，接收两个参数，
第一个是索引号，第二个是要插入的元素。

li.insert(0, 'b')
print(li)

extend()
可以把一个序列类型中的每个元素追加到原列表中，接收的参数是一个序列类型的数据（字符串，列表）。

l2 = ['qf','yangge']
li.extend(l2)
print(li)

remove()
移除列表中某个指定的元素，没有返回值，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素

obj.remove('a') 。

pop()

从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。

 # 删除列表中的最后一个元素
li.pop() 

 # 删除列表中第二个索引号对应的元素，并且返回这个元素，用变量名`n` 接收。  
n = li.pop(2)   

index 返回指定元素的索引号。

idx = li.index(4) 
print(idx)

*count() 是列表的内置方法，可以统计出相同值的元素在列表中总共
出现都少次.

num = obj.count(4)
print(num)

sort()
是列表的内置方法，对列表中元素进行排序。
默认是升序， 这个改变列表自身。

还可以接收一个 reverse (反转) 参数, 其值可以是 True 和 False。
False 是升序，True 是降序。需要是同一种数据类型，比如都是字符串，或都是整型。

示例：

l5 = [2, 4, 23, 34, 100]

l5.sort(reverse=True)

print(l5)
# 输出：
[100, 34, 23, 4, 2] 

sorted()
是 python 的内置函数，接受一个参数，参数可以是任意序列类型的数据，但是元素的类型必须相同.
比如是含有都是 str 的列表，或者是含有都是 int 的列表
它会返回一个新的类别，原列表不变。

li = [2,10,3,7]
l10 = sorted(li)  
print(li)
print(l10)   

4. 通过索引和切片修改列表

索引号

In [11]: int_number = [1,2,3,4,5]
    
In [12]: int_number[2]=20
    
In [13]: int_number
Out[13]: [1, 2, 20, 4, 5]

切片

li = [1, 2, 3, 4, 5]
li[1:3] = [0]
print(li)

5. 引用赋值

In [192]: a
Out[192]: ['6', '5', '3', '1', '1']

In [193]: b = a

In [194]: b
Out[194]: ['6', '5', '3', '1', '1']

In [195]: a[-2]=2

可以看到，这种用等号将一个列表赋值给多个变量时，使用其中任意一个变量对列表的操作，结果都会同步到其他变量的值。

在这种现象中，就像前面学到的变量的赋值，变量和列表本身之间的关系称作，变量对列表对象的引用，并没有创建一个新的列表。

解决方法

• 使用以下任意一种方法,都可以将原列表的值赋值给一个新的列表

1. 列表的内置函数 obj.copy()
2. 序列类型函数 list(obj)
3. 列表切片

以上方法得到的列表可赋值给一个新的变量， 这变量各自有自己的列表对象，互相之间不会影响

6. 深浅拷贝

In [110]: base_count = ['name',['money',100.00]]

In [111]: xmen = list(base_count)

In [112]: xpan = base_count.copy()

In [113]: xmen[1][1] = 20.00

In [114]: xpan
Out[114]: ['name', ['money', 20.0]]

点我可视化你的代码

千锋云计算 千锋云计算

解决办法

# 导入模块
import copy 

base_count = ['name',['money',100.00]]

# 利用模块中的 copy 方法创建一个全新的对象
xmen_new = copy.deepcopy(base_count)

# 利用模块中的 copy 方法创建另一个全新的对象
xpan_new = copy.deepcopy(base_count)

# 改变其中一个对象中的值
xpan_new[1][1] = 50.00

# 分别打印两个对象
print(xmen_new)

print(xpan_new)

---

---

三、元组

1 元组特性介绍

• 元组和列表一样，也是一种序列。
• 唯一的不同是，元组是相对不可变的。

2 高效创建元组

t1 = ()    # 创建 空 元素的元组

• 你以为这就完了？

  单一元素元组怎么搞？

In [168]: v_tp = (3)

In [169]: only_tp = 3,

In [170]: type(v_tp)

Out[170]: int

In [171]: type(only_tp)
Out[171]: tuple

创建非空元素的元组是用逗号，而不是用小括号

tuple()
可以对其他序列类型的数据转换为元组。

In [173]: s1 = 'car'

In [174]: li = [1,2,3]

In [175]: tuple(s1)
Out[175]: ('c', 'a', 'r')

In [176]: tuple(li)
Out[176]: (1, 2, 3)

In [177]: dl = [1,2,3,['a','b']]

In [178]: tuple(dl)
Out[178]: (1, 2, 3, ['a', 'b'])

In [33]: t1 = (1, 2, 3, ['a', 'b'])
In [34]: t1[3][0]=0
In [35]: t1
Out[35]: (1, 2, 3, [0, 'b'])

3 使用元组的理由

给我一个理由

1. 占用内存空间小
2. 元组内的值不会被意外的修改
3. 可作为字典的键
4. 函数的参数是以元组形式传递的
5. 命名元组有时候可以代替类的对象(面向对象的时候讲)

---

---

四、 字典

1 映射类型数据结构介绍

• 在字典存放的每个元素都是以一对儿键值对。
• 在 Python 中 字典通常被称为 dict，键 称为 key，值称为 value
• 字典中不可以存在相同的 key，但是 value 可以。

2 高效创建字典

空字典

In [7]: d1 = {}

In [8]: type(d1)
Out[8]: dict

字典中元素是无序的

In [1]: d2 = {'shark': '鲨鱼', 'qf': '千锋'}

In [2]: d2
Out[2]: {'qf': '千锋', 'shark': '鲨鱼'}

3. dict() 转换为字典

接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。

In [14]: d_tpl = [('a','1'),('b','2'),('c','3')]  

In [15]: dict3 = dict(d_tpl)

In [17]: d_tpl2 = ['a1','b2','c3']

In [18]: dict4 = dict(d_tpl2)

In [21]: dict3 is dict4  
Out[21]: False  

In [22]: dict3 == dict4  
Out[22]: True

4. zip() 并行迭代

​ zip() 函数可以对多个序列进行并行迭代

en =['a', 'b', 'c', 'd']

nums = ['1', '2', '3', '4']

for word, num in zip(en, nums):
    print(word, num)

利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量。

In [36]: en = 'a','b','c',

In [37]: nums = '1' , '2', '3'

In [38]: zip(en, nums)
Out[38]: <zip at 0x1052c7f08>

In [39]: type(zip(en, nums))
Out[39]: zip

In [40]: list(zip(en, nums))
Out[40]: 
    
In [41]: dict(zip(en, nums))
Out[41]: 

5. 哪些数据可以作为字典的 kye

key 通常是 字符串

它可以是 Python 中任意不可变类型

比如：

• 布尔型 True 1 False 0
• 整型 100 200
• 浮点型 1.0 3.415
• 元组 （1,） （1, 2, 3）
• 字符串 'host_name'

关于字典的 key

在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。

所以 key 必须是可哈希的。

判断一个对象是否可哈希，可以使用 hash() 函数

返回一个整数，就是可哈希，反之会抛出 TypeError 异常

hash(1)
hash('name')
hash((1,2,3))

# 列表是可变的数据类型，所有不可以被 hash，当然也就不能作为 字典的 key
hash([1,2,3])

6. 获取 key 对应的 value

dict_obj = {'a': 1, 'b': 2}
dict_obj['a']        # key 必须存在，不存在，抛出异常    

dict_obj.get('a')    # 获取到 'a' 对应的值(value)

dict_obj.get('c')    # key 不存在字典中，则返回 None

dict_obj.get('c', '5')  # key 不存在，返回指定的 value

示例

info_dict = {"name": 'yangge', 'age': 18}
na = info_dict['name']
print(na)

naa = info_dict['dd']

age = info_dict.get('age')
print(age)

age2 = info_dict.get('asdf')
print(type(age2),age2)

age3 = info_dict.get('adaf', '')
print(type(age3),age3)

age4 = info_dict.get('adaf', 28)
print(type(age4),age4)

7. 获取字典所有的 key

dict_obj.keys()

info_dict = {"name": 'yangge', 'age': 18}
d_keys = info_dict.keys()
print(d_keys)
print(list(d_keys))

8. 获取字典所有的 value

dict_obj.values()

info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))

9. 同时获取字典的 key 和 value

dict_obj.items()

info_dict = {"name": 'yangge', 'age': 18}
item = info_dict.items()
print(item)
print(list(item))

10. 使用 = 修改或更新字典

=

可以使用 等号 对字典的 key 进行直接赋值操作。

假如 key 不存在与字典中，这个 key 和 对应值也会被创建到字典中。

In [50]: d5 = {}

In [51]: d5['a'] = 1

In [52]: d5['b'] = 2

In [53]: d5
Out[53]: {'a': 1, 'b': 2}

In [54]: d5['li'] = [1,3,5]

In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}

字典同样支持引用赋值

In [68]: d5 = {'a': 1, 'b': 2, 'li': [1, 3, 5]} 

In [69]: d6 = d5

In [70]: d6 is d5
Out[70]: True

In [71]: d7 = d5.copy()

In [73]: d7 is d5
Out[73]: False

In [74]: d7 == d5   # 双等号 是用来判断 等号两边的对象的值是否相等
Out[74]: True

10. 使用 update() 更新字典

把一个已经存在的字典中的键值对，添加到另一个字典中。

In [59]: d5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}

In [60]: d6 = {'a': 2,'d': 2,'e': 5}

In [61]: d5.update(d6)

In [62]: d5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5, 'li': [1, 3, 5]}

注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 号方式的更新.

python3.5+

x = {'a': 1, 'b': 2}
y = {'c': 1, 'd': 2}

z = {**x,**y}

print(z)

## 11. 成员判断

**`in`**

```python
In [63]: 'a' in d5   # 默认就是判断 ‘a’ 是否存在于字典中的 keys()
Out[63]: True

In [63]: 'a' in d5.keys()
Out[63]: True

In [75]: 'a' not in d5.keys()
Out[75]: False

12. 删除和清空字典

删除指定的键值对

dict_obj = {'a': 1}
del  dict_obj['a']  # 从字典中删除指定 key 的键值对
del  dict_obj       # 删除字典本身，字典自身就不存在于内存中了

清空

dict_obj={}

dict_obj.clear()    # 字典本身还在内存中，只是内容没了

pop()

从字典中删除指定 key 的键值对，并返回这个 key 对应的值

In [49]: d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}

In [50]: li = d6.pop('li')
    
In [51]: print(li)
Out [51]: [1, 3, 5]

13. 用字典实现 switch … case 语句

Python 中没有 switch … case 语句，这个问题Python之父龟叔表示这个语法过去没有，现在没有，以后也不会有。因为Python简洁的语法完全可以用 if … elif 实现。如果有太多的分支判断，还可以使用字典来代替。

arg = 1

if arg == 0:
    print('zero')
elif arg == 1:
    print('one')
elif arg == 2:
    print("two")
else:
    print("nothing")

---

建议使用下面的代码实现

data = {
    0: "zero",
    1: "one",
    2: "two",
}
data.get(arg, "nothing")

13. 扩展知识： setdefault 处理缺失的键

dict_obj.setdefatult(‘key’, ‘value’) 
# key 不存在，设置 key: value 到字典中,并且返回设置后的键值对的 value；
# key 存在, 返回对应的 value，原字典不变。

---

分类统计实例

data = [
        ("ip", "192.168.1.100"),
        ("ip", "192.168.1.200"),
        ("port", 22),
        ("user", "yangge"),
        ("user", "shark")
    ]

bad

groups = {}
for (key, value) in data:
    # 判断 key 是否在于字典中
    if key in groups.keys():
        # key 存在字典中，则把 value 添加到 key 对应的 value 中
        # value 是一个列表，是在下面定义的
        groups[key].append(value)
    else:
        # key 不存在字典中，把键值对添加到此字典中
        # 此时，key 对应的 value 是一个列表类型
        groups[key] = [value]

print(groups)

good

groups = {}
for (key, value) in data:
    groups.setdefault(key, []).append(value)
    # li = groups.setdefault(key, [])

setdefault 的作用是：

1. 如果 key 存在于字典中，那么直接返回对应的值，等效于 get 方法
2. 如果 key 不存在字典中，则会设置此键值对，key 的 value 就是 setdefault 中的第二个参数，之后再返回该值。

你以为结束了？ 扩展知识

思考

下面字典的最终结果是 ？

{True: 'yes', 1: 'no', 1.0: 'maybe'}

['no', 'yes'][True]

当一个新的值与字典的键关联的时候，python的字典不会更新键对象本身

In [66]: y = {1.0: 'no'}

In [67]: y[True] = 'yes'

In [68]: y
Out[68]: {1.0: 'yes'}
    
# 如果键被认为是相同的，那么为什么要花时间更新原来的？

Python字典中的键 是否相同（只有相同才会覆盖）取决于两个条件：

1、两者的值是否相等（比较__eq__()方法)

2、比较两者的哈希值是否相同（比较___hash__()hash方法）

In [69]: (hash(True), hash(1), hash(1.0))
Out[69]: (1, 1, 1)

---

---

五、集合

1 集合特性介绍

在 python 中集合看起来像是只有 key 的字典

{'disk','cpu','memory','motherboard'}

在 python 解释器中表现为 set

集合内的元素不允许重复

2 高效创建集合和转换

set()

In [96]: s1 = set()

In [97]: s1
Out[97]: set()

转换

In [99]: set('disk')
Out[99]: {'d', 'i', 'k', 's'}

In [100]: set(['disk','cpu','memory'])
Out[100]: {'cpu', 'disk', 'memory'}

In [101]: set(('disk','cpu','memory'))
Out[101]: {'cpu', 'disk', 'memory'}

In [102]: set({'disk': '560G','cpu': '4'})
Out[102]: {'cpu', 'disk'}

3 集合的简单操作

a.添加元素

In [11]: s2 = {12,3,4,5,6,}

In [12]: s2.add('n')

In [13]: s2
Out[13]: {12, 3, 4, 5, 6, 'n'}

b. 指定删除某个元素

In [15]: s2.remove('n')

In [16]: s2
Out[16]: {4, 5, 6, 12}

c. 随机干掉一个

In [14]: s2.pop()
Out[14]: 3

4 集合运算

a. & 交集

获取两个集合都有的元素

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.55", "192.168.1.51"}

In [57]: s1 & s2
Out[57]: {'192.168.1.51'}

b. |并集

把两个集合的元素合并在一起，产生一个新的集合

In [60]: s1 | s2
Out[60]: {'192.168.1.45', '192.168.1.51', '192.168.1.55'}

c. -差集

返回第一个集合中独有的元素。
就是只保留在第一个集合中出现并且不在第二个集合中出现的元素。

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.55", "192.168.1.51"}

In [61]: s1 - s2
Out[61]: {'192.168.1.45'}

In [62]: s2 - s1
Out[62]: {'192.168.1.55'}

^异或运算

获取两个集合的分别独有的元素，组合为一个新的集合对象。

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.55", "192.168.1.51"}

In [63]: s1 ^ s2
Out[63]: {'192.168.1.45', '192.168.1.55'}

大型数据结构应用场景

host_info = []

host_info.append(
    {'192.168.1.11':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],
'memory':['16','4','2'],
'disk':['1T','2T']}}
)

host_info.append({'192.168.1.12':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],
'memory':['16','4','2'],
'disk':['1T','2T']}})

取到 "1T"

print(host_info[0])
print(host_info[0].get('192.168.1.11').get('disk')[0])

---

---

作业联系

源数据

5497 click_sum:3 percent:100.0%
4826 click_sum:1 percent:0.0%
6522 click_sum:201 percent:51.24%
6367 click_sum:712 percent:1.83%
6368 click_sum:1462 percent:4.79%
5346 click_sum:733 percent:6.68%
3812 click_sum:29 percent:0.0%
4841 click_sum:851 percent:0.0%
5873 click_sum:217 percent:28.57%
6316 click_sum:4 percent:0.0%
6900 click_sum:28 percent:7.14%
7416 click_sum:6 percent:0.0%
6989 click_sum:50 percent:0.0%
6990 click_sum:21 percent:0.0%
4944 click_sum:15 percent:100.0%
6485 click_sum:88 percent:0.0%
7039 click_sum:28 percent:92.86%
2432 click_sum:153 percent:5.88%
6018 click_sum:4 percent:0.0%
6024 click_sum:28 percent:100.0%
1930 click_sum:175 percent:6.29%
2444 click_sum:3725 percent:7.54%
2451 click_sum:3505 percent:0.23%
7060 click_sum:111 percent:51.35%
3989 click_sum:715 percent:41.54%
6039 click_sum:42 percent:0.0%
2457 click_sum:13 percent:46.15%
5530 click_sum:64 percent:0.0%
7582 click_sum:124 percent:0.81%
7071 click_sum:8 percent:0.0%
5537 click_sum:5 percent:100.0%
4763 click_sum:1 percent:100.0%
5540 click_sum:186 percent:0.54%
5033 click_sum:2337 percent:73.47%
4522 click_sum:1668 percent:0.54%
4523 click_sum:62 percent:1.61%
7084 click_sum:432 percent:1.85%
6063 click_sum:247 percent:0.0%
5553 click_sum:68 percent:0.0%
6583 click_sum:13 percent:100.0%
6127 click_sum:22 percent:0.0%
6057 click_sum:6 percent:0.0%
6138 click_sum:15 percent:6.67%
4607 click_sum:10 percent:0.0%
6652 click_sum:8 percent:0.0%
4010 click_sum:1 percent:100.0%
3583 click_sum:2239 percent:36.8%
4446"in_offer_id":107466987-"in_affiliate_id":4631-"result_code":1604
1649"in_offer_id":98399105-"in_affiliate_id":5988-"result_code":1607
800"in_offer_id":106901072-"in_affiliate_id":4666-"result_code":1604
594"in_offer_id":106351217-"in_affiliate_id":7373-"result_code":1604
531"in_offer_id":107466987-"in_affiliate_id":3882-"result_code":1606
393"in_offer_id":108314256-"in_affiliate_id":5411-"result_code":1601
356"in_offer_id":108230131-"in_affiliate_id":5033-"result_code":1601
291"in_offer_id":108230207-"in_affiliate_id":5033-"result_code":1604
284"in_offer_id":108923434-"in_affiliate_id":3583-"result_code":1604
210"in_offer_id":108231457-"in_affiliate_id":5033-"result_code":1800

目标数据模板

7545 click_sum:149 percent:97.32%
4773 click_sum:277 percent:86.28%
5411 click_sum:466 percent:84.55%
2902 click_sum:147 percent:80.95%
5988 click_sum:2041 percent:80.84%
5033 click_sum:2337 percent:73.47%
5580 click_sum:250 percent:55.2%
7115 click_sum:346 percent:54.34%
4666 click_sum:1526 percent:54.26%

要求说明

找到 click_sum 的值大于 100 且 percent 的值大于 30% 的数据，并且
按照 percent 的值 进行由大到小进行排序打印出来

代码

# click_num的值大于100且percent的值大于30，然后从大到到小排序
import traceback

# 读取文件内容
with open('source.txt', 'r') as f:
    # 得到源数据并且成为列表
    content_list = f.read().split('\n')

lines = []

# 循环源数据列表
for line in content_list:
    # 判断是我们要的数据
    if 'click_sum' in line:

        # 拿到我们需要比较的两个数据部分
        # click_sum:149 和 percent:97.32%
        _, click_sum, percent = line.split()

        # 分割得到具体数据
        sum = click_sum.split(':')[-1]
        per = percent.replace('%', '').split(':')[-1]
        try:
            # 类型转换
            sum = int(sum)
            per = float(per)

            # 判断 click_num的值大于100且percent的值大于30 的数据行
            if sum > 100 and per > 30:

                # 把符合条件的数据和需要比对的数据放在一个列表中添加到中列表中
                # # [[54.26, '4666 click_sum:1526 percent:54.26%']]
                lines.append([per, line])
        except Exception as e:
            # 假如有异常就打印出如下信息
            print("获取到的数据不是数字类型的，无法装换比较")
            print(traceback.format_exc())



# print(lines)

# 最终的数据
# [[54.26, '4666 click_sum:1526 percent:54.26%'], [37.57, '6212 click_sum:173 percent:37.57%'], [52.04, '6214 click_sum:294 percent:52.04%'], [40.33, '3671 click_sum:362 percent:40.33%'], [86.28, '4773 click_sum:277 percent:86.28%'], [53.87, '7373 click_sum:1214 percent:53.87%'], [51.24, '6522 click_sum:201 percent:51.24%'], [84.55, '5411 click_sum:466 percent:84.55%'], [40.74, '3882 click_sum:1318 percent:40.74%'], [80.95, '2902 click_sum:147 percent:80.95%'], [80.84, '5988 click_sum:2041 percent:80.84%'], [97.32, '7545 click_sum:149 percent:97.32%'], [51.35, '7060 click_sum:111 percent:51.35%'], [41.54, '3989 click_sum:715 percent:41.54%'], [73.47, '5033 click_sum:2337 percent:73.47%'], [34.17, '7113 click_sum:120 percent:34.17%'], [54.34, '7115 click_sum:346 percent:54.34%'], [55.2, '5580 click_sum:250 percent:55.2%'], [36.8, '3583 click_sum:2239 percent:36.8%']]

# 排序
"""
lambda item: item[0]  是一个匿名函数
利用 [54.26, '4666 click_sum:1526 percent:54.26%'] 的第一元素进行比较

# 给 sort 函数传入参数 reverse=True， 进行有大到下排序 
"""
lines.sort(key=lambda item: item[0], reverse=True)
# print(lines)
# [[97.32, '7545 click_sum:149 percent:97.32%'], [86.28, '4773 click_sum:277 percent:86.28%'], [84.55, '5411 click_sum:466 percent:84.55%'], [80.95, '2902 click_sum:147 percent:80.95%'], [80.84, '5988 click_sum:2041 percent:80.84%'], [73.47, '5033 click_sum:2337 percent:73.47%'], [55.2, '5580 click_sum:250 percent:55.2%'], [54.34, '7115 click_sum:346 percent:54.34%'], [54.26, '4666 click_sum:1526 percent:54.26%'], [53.87, '7373 click_sum:1214 percent:53.87%'], [52.04, '6214 click_sum:294 percent:52.04%'], [51.35, '7060 click_sum:111 percent:51.35%'], [51.24, '6522 click_sum:201 percent:51.24%'], [41.54, '3989 click_sum:715 percent:41.54%'], [40.74, '3882 click_sum:1318 percent:40.74%'], [40.33, '3671 click_sum:362 percent:40.33%'], [37.57, '6212 click_sum:173 percent:37.57%'], [36.8, '3583 click_sum:2239 percent:36.8%'], [34.17, '7113 click_sum:120 percent:34.17%']]

for line in lines:
    print(line[-1])