学习日记-20190604

发表于 |

构建事件树ETA的完整算法以及优化、Linux下查看端口占用情况、Selenium python官方文档再学习、Anytree-构建树的Python第三方库、treelib

构建事件树的完整算法以及优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public CESs generateCESwithEventTree(ESG4WSCModel esg4wscModel){
    //Step1-Handling refining ESG4WSCs
    for(Pair<Event,ESG4WSCModel> p : esg4wscModel.getRefiningEsgs()){
        // 递归调用
        refCESs = generateCESwithEventTree(p.ESG4WSCModel);
        CESsToReplace.append(p.Event,refCESs);
    }
    //Step2-Solving DTs
    for(DT dt : esg4wscModel.getDTs())
        solveDTAndAddEdges(dt,esg4wscModel);
    //Step3-Building the event tree
    // 贪婪算法
    EventTree tree = new EventTree();
    tree.setRoot(esg4wscModel.getEntryNode());//entry-'['
    // 用于广度优先搜索的队列
    queue.add(esg4wscModel.getEntryNode());
    while(queue.isNotEmpty()){
        event = queue.first();
        if(event.isNotVisited()){
            //expand tree
            event.setVisited(true);
            for(Event child : event.getSuccessors()){
                tree.addChild(event.child);
                queue.add(child);
            }
        }  
    }
    //Step4-Completing the tree
    for(Event e:tree.getLeafs())
        if(e != ']'){
            ES = esg4wscModel.getShortestPath(e,']');//from'e'to ']'
            tree.append(e,ES);
        }
    //依赖于Step3-4的信息，在这之间进行剪枝
    //Step5-Deriving CESs
    CESs = deriveCESs(tree);//each path from root to a leaf is a CES
    
    //Step6-Replacing refined events
    for(Pair<Event,CESs>p : CESsToReplace)
        CESs = replaceRefinedEvents(CESs,p.Event,p.CESs);
    return CESs;
}

ETA-原始的事件树建树算法（广度优先遍历）

ETA+P-将剪枝步应用在第5步之前

GETA-使用贪婪算法替代第3步

GETA+P-使用贪婪算法和剪枝步

与cpp（Chinese postman problem）算法对比

Linux下查看端口占用情况

1
netstat -ntpl

Selenium python官方文档再学习

https://selenium-python.readthedocs.io/page-objects.html

定位文件（locators.py）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding: utf-8 -*-
# @Time    : 2019/6/4 16:47
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
"""
其中一种做法是将定位器字符串与它们被使用的位置分开。 在此示例中，同一页面的定位器属于同一个类。
有种策略模式的感觉
"""
from selenium.webdriver.common.by import By
class MainPageLocators(object):
    """所有主页的定位器都应该放在这里"""
    GO_BUTTON = (By.ID,'submit')

class SearchResultsPageLocators(object):
    """所有搜索结果的定位器都应该放在这里"""
    pass

元素文件（element.py）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding: utf-8 -*-
# @Time    : 2019/6/4 16:52
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
from selenium.webdriver.support.ui import WebDriverWait

class BasePageElement(object):
    """BasePage会在每个页面对象类中进行初始化"""
    def __set__(self, instance, value):
        """将文本设置为提供的值"""
        driver = instance.driver
        WebDriverWait(driver,100).until(
            lambda driver:driver.find_element_by_name(self.locator))
        driver.find_element_by_name(self.locator).clear()
        driver.find_element_by_name(self.locator).send_keys(value)

    def __get__(self, instance, owner):
        """获取指定对象的文本"""
        driver = instance.driver
        WebDriverWait(driver,100).until(
            lambda driver:driver.find_element_by_name(self.locator))
        element = driver.find_element_by_name(self.locator)
        return element.get_attribute("value")

页面对象文件（page.py）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding: utf-8 -*-
# @Time    : 2019/6/4 16:46
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
from .element import BasePageElement
from .locators import MainPageLocators

class SearchTextElement(BasePageElement):
    locator = 'q'

class BasePage(object):

    def __init__(self,driver):
        self.driver = driver

class MainPage(BasePage):

    search_text_element = SearchTextElement()

    def is_title_matches(self):
        return "Python" in self.driver.title

    def click_go_button(self):
        element = self.driver.find_element(*MainPageLocators.GO_BUTTON)
        element.click()

class SearchResultsPage(BasePage):

    def is_results_found(self):
        return "No results found." not in self.driver.page_source

测试文件（test.py）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding: utf-8 -*-
# @Time    : 2019/6/4 17:24
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
import unittest
from selenium import webdriver
from . import page
class PythonOrgSearch(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get("http://www.python.org")

    def test_search_in_python_org(self):
        main_page = page.MainPage(self.driver)
        assert main_page.is_title_matches()
        main_page.search_text_element = "pycon"
        main_page.click_go_button()
        search_results_page = page.SearchResultsPage(self.driver)
        assert search_results_page.is_results_found()

    def tearDown(self):
        self.driver.close()

if __name__ == "__main__":
    unittest.main()

Anytree-构建树的Python第三方库

（原来了解过一个treelib，其实本质是一样的，但是感觉Anytree更易理解，而且可以直接画成dot图，方便可视化）

官方文档戳 https://anytree.readthedocs.io/en/latest/

建一棵树并控制台打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding: utf-8 -*-
# @Time    : 2019/6/5 15:26
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
from anytree import Node, RenderTree
udo = Node("Udo")
marc = Node("Marc", parent=udo)
lian = Node("Lian", parent=marc)
dan = Node("Dan", parent=udo)
jan = Node("Jan", parent=dan)
joe = Node("Joe", parent=dan)
for pre, fill, node in RenderTree(udo):
    print("%s%s" % (pre, node.name))
-----------------------------------------------------------------------------------------
Udo
├── Marc
│   └── Lian
└── Dan
    ├── Jan
    └── Joe

图可视化

udo.png

treelib建树，功能更强大，可以找路径啥的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# -*- coding: utf-8 -*-
# @Time    : 2019/4/11 20:13
# @Author  : zhengjiani
# @Software: PyCharm
# @Blog    ：https://zhengjiani.github.io/
from treelib import Node,Tree
node = Node()
tree = Tree()
tree.create_node("Harry","harry")#root node
tree.create_node("Jane","jane",parent="harry")
tree.create_node("Bill","bill",parent="harry")
tree.create_node("Diane", "diane", parent="jane")
tree.create_node("Mary", "mary", parent="diane")
tree.create_node("Mark", "mark", parent="jane")
tree.show()
#打印节点标签
print(','.join([tree[node].tag for node in tree.expand_tree(mode=Tree.DEPTH)]))
#过滤节点标签
print(','.join([tree[node].tag for node in tree.expand_tree(filter = lambda x:x.identifier != 'diane')]))
#获得某一节点的子树
sub_t = tree.subtree('diane')
sub_t.show()
#在原来的树上粘一棵新树
new_tree = Tree()
new_tree.create_node("n1",1)#root node
new_tree.create_node("n2",2,parent=1)
new_tree.create_node("n3",3,parent=1)
tree.paste('bill',new_tree)
tree.show()
#移去已经存在的节点,如果移去的是根节点，则子树也移了
tree.remove_node(1)
tree.show()
#移动节点改变父节点
tree.move_node('mary','harry')
tree.show()
#树的深度
print(tree.depth())
#获取节点标签
node = tree.get_node("bill")
tree.depth(node)

#保存树
#tree.save2file('tree.txt')