python spider

import re
'''
string="libohao"
pat="hao"
rst=re.search(pat,string)
print(rst)
'''
string='''raosjdaodj
baidu
'''
pat="\n"
rst=re.search(pat,string)
#print(rst)
#\n \t

'''
通用字符作为原子
\w 字母数字下划线
\W 除上
\d 十进制数字
\s 空白字符
'''
string1='''asdasda123132'''
pat="\w\w\d\d"
rst=re.search(pat,string1)
#print(rst)

#原子表
pat="as[abcd]"
rst=re.search(pat,string1)
#print(rst)

pat="as[^d]"
rst=re.search(pat,string1)
#print(rst)

#元字符
'''
除换行符以外的任意一个字符
^开始位置
$匹配结束
* 0\1\多次
? 0/1次
+ 1/多次
{n} n次
{n,} 至少n次
{n,m} 至少n次,至多m次
| 模式选择符或
()模式单元

'''
string1='''asdadasda123132'''

pat="asd+"
pat="^asd......."
pat="asd.*"
pat="da{2}"
rst=re.search(pat,string1)
#print(rst)


#模式修正符
'''
| 匹配时忽略大小写
M多行匹配
L本地化识别匹配
U Unicode
S 让匹配包括换行符
'''

string="python"
pat="Pyt"
rst=re.search(pat,string,re.I)
#print(rst)

'''贪婪模式
懒惰模式

'''
string="poythonyhjskjsa"
pat1="p.*y"#贪婪模式
pat2="p.*?y"#懒惰模式
rst1=re.search(pat1,string,re.I)
rst2=re.search(pat2,string,re.I)
#print(rst1)
#print(rst2)

'''
正则表达式函数
re.mathch()
re.search()
re.sub()
'''


string="poythonyhjskjsa"
pat="p.*y"
pat="o.*y"#match 必须从头开始
rst=re.match(pat,string,re.I)
#print(rst)

#全局匹配函数格式re.compile(正则表达式)

string="poythonyhjskjsapoythonpoythonpoythonpoython"
pat="p.*?y"
rst=re.compile(pat).findall(string)
#print(rst)

#com cn
string="http://www.baidu.com"
pat="http[s]?://[a-zA-Z*.]+[com|cn]+"
rst=re.compile(pat).findall(string)
#print(rst)


#匹配电话号码
string="asdsd1234-1234567sad123-12345678"
pat="\d{4}-\d{7}|\d{3}-\d{8}"
rst=re.compile(pat).findall(string)
#print(rst)
















'''
#url基础
import urllib.request  as r
#urlretrieve(网页,本地存储地址) 直接下载网页到本地
#r.urlretrieve("https://blog.csdn.net/weixin_43870649/article/details/101419805","D:\\Desktop\\python爬虫\\download1.html")
#urlcleanup
r.urlcleanup()
#info
file=r.urlopen("https://read.douban.com/provider/all/")
#print(file.info())
#getcode返回当前爬取页面的状态
print(file.getcode())
#geturl
print(file.geturl())
'''
'''
#超时设置
import urllib.request as r
for i in range(0,100):
    file=r.urlopen("http://www.baodu.com",timeout=0.2)
    try:
        print(len(file.read()))
    except Exception as err:
        print(str(err))
'''
'''
#自动模拟http请求
#get请求
import urllib.request as r
import re
keyword="李博浩"
keyword=r.quote(keyword)
for i in range(1,1000):
    url="http://www.baidu.com/s?wd="+keyword+"&pn="+str((i-1)*10)
    file=r.urlopen(url).read().decode('utf-8')
    pat1="title:'(.*?)',"
    pat2='"title":"(.*?)"'
    rst1=re.compile(pat1).findall(file)
    rst2=re.compile(pat2).findall(file)
    for j in range(0,len(rst1)):
        print(rst1[j])
    for j in range(0,len(rst2)):
        print(rst2[j])
    
'''
'''
#post请求
import urllib.request as r
import urllib.parse as p
import re
posturl="http://39.105.30.139:8081/f7/loginadmin.action"
postdata=p.urlencode({
    "a_id":"17",
    "a_pwd":"11111111",
}).encode("utf-8")
for i in range(0,50):
    try:
        req=r.Request(posturl,postdata)
        rst=r.urlopen(req).read().decode("utf-8")
        if(re.search("论坛登录成功",rst)!="NONE"):
            print("论坛登录成功")
    except Exception as err:
            print(str(err))

'''









### 拓扑排序在有向无环图中的实现 #### 使用DFS实现拓扑排序 对于有向无环图(DAG),通过深度优先搜索(DFS)来执行拓扑排序是一种常见的方式。当访问某个节点时,会递归地先访问其所有未被访问过的邻居节点,在回溯过程中记录下当前节点。 ```cpp void DFSVisit(const Graph& G, int u, vector<bool>& visited, list<int>& topoOrder) { visited[u] = true; for (int v : adjacencyList[u]) { if (!visited[v]) DFSVisit(G, v, visited, topoOrder); } // 记录顶点顺序(逆序) topoOrder.push_front(u + 1); } list<int> TopologicalSort_DFS(const Graph& G) { vector<bool> visited(G.n, false); list<int> topoOrder; for (int i = 0; i < G.n; ++i) { if (!visited[i]) DFSVisit(G, i, visited, topoOrder); } return topoOrder; } ``` 这种方法利用了栈结构特性——最后进入的元素最先出来(LIFO),因此可以在每次完成子树遍历之后立即将根结点加入到结果列表中[^1]。 #### 使用BFS实现拓扑排序(Kahn算法) 广度优先搜索(BFS)也可以用来做拓扑排序,这通常被称为Kahn算法。该方法基于入度的概念:只有那些没有任何前置条件的任务才能被执行。具体来说就是找到所有入度为零的节点作为起始点,并将其移除后更新其他节点的入度值,重复此操作直至处理完所有的节点为止。 ```cpp vector<int> TopologicalSort_BFS(const Graph& G) { queue<int> q; vector<int> indegree(G.n, 0); // 初始化各节点的入度 for (auto adjVertices : adjacencyList) for (int dest : adjVertices) indegree[dest]++; // 将所有入度为0的节点放入队列 for (size_t i = 0; i < indegree.size(); ++i) if (indegree[i] == 0) q.push(i); vector<int> result; while (!q.empty()) { int currentVertex = q.front(); q.pop(); result.push_back(currentVertex + 1); for (int neighbor : adjacencyList[currentVertex]) { --indegree[neighbor]; if (indegree[neighbor] == 0) q.push(neighbor); } } // 如果存在环,则无法完全排序 if (result.size() != G.n) throw runtime_error("Graph has at least one cycle"); return result; } ``` 这里采用了一个先进先出(FIFO)的数据结构`queue`,每当遇到一个新的入度降为0的节点就立即处理它并继续寻找新的候选者[^2]. #### 方法比较 两种方式各有优劣: - **时间复杂度**:两者都是O(V+E),其中V表示顶点数量,E代表边的数量. - **空间消耗**:由于都需要额外的空间存储已访问状态以及最终的结果序列,BFS可能还需要更多的辅助数组用于保存各个节点的入度信息。 - **适用场景**: - 当希望按照自然逻辑顺序构建解决方案时可以选择DFS版本; - 对于大规模稀疏网络而言,Khan's Algorithm即BFS更易于理解和实现,而且更容易扩展以支持动态变化的情况.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值