最近清理磁盘，发现以前自己的一些学习痕迹，当时留下的汇编代码现在看反而自己有点懵，所以，学习的一些心得是，不是你到底学了多少，一定是记住了多少，想想以前花了大量时间研究学习的都忘记，心里很不是滋味。为了不让它消失，也算对自己学习的一些回报就把它收录了进来，供大家参考。

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

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>


void inversion(int *p);//逆序
void sersion(int *p,int len);//冒泡排序

typedef	struct List //list模型
{
	int data;
	struct List *next;
}*PNODE,NODE;

// 创建列表
PNODE create_list();
//遍历
void traverse_list(PNODE phead);
//判断是否为空
bool is_empty(PNODE phead);
//长度or是否饱和
int length_list(PNODE);
//插入
bool insert_list(PNODE, int, int);
//删除
bool delete_list(PNODE, int, int*);
//排序
void sort_list(PNODE);

tcp

1
2

import socket
server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

服务端

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
44
45
46
47
48
49

# 绑定IP地址和端口
address = ("", 8000)
server_sock.bind(address)
# 让服务端的socket开启监听，等待客户端的连接请求
# listen中的参数表示已经建立链接和半链接的总数
# 如果当前已建立链接数和半链接数已达到设定值，那么新客户端不会立即connect成功，而是等待服务器能够处理时
server_sock.listen(128)


# 为了解决服务器socket可能的2MSL延迟问题，我们可以为服务器socket设置SO_REUSEADDR选项
'''
# 使用setsockopt()方法设置socket的选项参数
# SOL_SOCKET = Set Option Level _ SOCKET 设置选项级别为socket级
# SO_REUSEADDR = Socket Option _ REUSEADDR 设置socket的选项参数为重用地址功能
# 1 表示开启此选项功能，即开启重用地址功能
server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

server_sock.set
'''








# 使用accept方法接收客户端的连接请求
# 如果有新的客户端来连接服务器，那么就产生一个新的套接字专门为这个客户端服务
# client_sock用来为这个客户端服务，与客户端形成一对一的连接
# 而server_sock就可以省下来专门等待其他新客户端的连接请求
# client_addr是请求连接的客户端的地址信息，为元祖，包含用户的IP和端口
client_sock, client_addr = server_sock.accept()

# recv()方法可以接收客户端发送过来的数据，指明最大收取1024个字节的数据
recv_data = client_sock.recv(1024)

# python3中收到的数据为bytes类型
# recv_data.decode()将bytes类型转为str类型


# send()方法向客户端发送数据，要求发送bytes类型的数据
client_sock.send("thank you!\n".encode())

# 关闭与客户端连接的socket
client_sock.close()

# 关闭服务端的监听socket
server_sock.close()

tcp

TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。

tcp通信需要经过创建连接、数据传送、终止连接三个步骤。

TCP特点

1.面向连接

• 通信双方必须先建立连接才能进行数据的传输，双方都必须为该连接分配必要的系统内核资源，以管理连接的状态和连接上的传输.

• 双方间的数据传输都可以通过这一个连接进行。

• 完成数据交换后，双方必须断开此连接，以释放系统资源

2.基于数据流（字节流）

upd

UDP是一种面向无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

套接字

网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。

tcp的三次握手

http://img3.imgtn.bdimg.com/it/u=877665853,860765078&fm=214&gp=0.jpg

1. 客户端发送一个带SYN标志的TCP报文到服务器。SYN位表示连接请求。序号是1000（随机数，此处1000），这个序号在网络通讯中用作临时的地址，每发一个数据字节，这个序号要加1，这样在接收端可以根据序号排出数据包的正确顺序，也可以发现丢包的情况。mss表示最大段尺寸，如果一个段太大，封装成帧后超过了链路层的最大帧长度，就必须在IP层分片，为了避免这种情况，客户端声明自己的最大段尺寸，建议服务器端发来的段不要超过这个长度。

2. 服务器端回应客户端,同时带ACK标志和SYN标志。它表示对刚才客户端SYN的回应；同时又发送SYN给客户端，询问客户端是否准备好进行数据通讯。服务器发出段2，也带有SYN位，同时置ACK位表示确认，确认序号是1001，表示“我接收到序号1000及其以前所有的段，请你下次发送序号为1001的段”，也就是应答了客户端的连接请求，同时也给客户端发出一个连接请求SYN，序号是8000（实际也是一个随机数，此处以8000为例），同时声明最大尺寸为1024。

3. 客户端对服务器的连接请求进行应答，确认ack序号是8001
4. 在建立连接的同时，双方协商了一些信息，例如双方发送序号的初始值、最大段尺寸等.在TCP通讯中，如果一方收到另一方发来的段，读出其中的目的端口号，发现本机并没有任何进程使用这个端口，就会应答一个包含RST位的段给另一方。例如，服务器并没有任何进程使用8080端口，我们却用telnet客户端去连接它，服务器收到客户端发来的SYN段就会应答一个RST段，客户端的telnet程序收到RST段后报告错误Connection refused。
   阅读全文 »

numpy中函数

min()用法

<求指定维度的最小值，默认求所有值的最小值>

• min(): 无参，返回所有中的最小值

• min(0):  等价于 axis=0, 每列的最小值

• min(1): 等价于 axis=1,每行的最小值

max()用法

<求指定维度的最大值，默认求所有值的最大值>

• max(): 无参，所有中的最大值
• max(0):每列的最大值
• max(1):每行的最小值
  阅读全文 »

Selenium是一个Web的自动化测试工具

1

pip install selenium

PhantomJS 是一个基于Webkit的“无界面”(headless)浏览器，它会把网站加载到内存并执行页面上的 JavaScript
< PhantomJS 是一个功能完善(虽然无界面)的浏览器而非一个 Python 库，所以它不需要像 Python 的其他库一样安装，但我们可以通过Selenium调用PhantomJS来直接使用 >

1
2
3
4
5
6
7
8
9
10
11

# WebDriver 有点儿像可以加载网站的浏览器
from selenium import webdriver

# 调用环境变量指定的PhantomJS浏览器创建浏览器对象
driver = webdriver.PhantomJS()
# get方法会一直等到页面被完全加载
driver.get(url)
<!----------more----------->
#查看页面快照
driver.save_screenshot("abc.png")
driver.quit()

元素的选取

find_element_by_id()

1
2
3

for example:
# <div id="coolestWidgetEvah">...</div>
element = driver.find_element_by_id("coolestWidgetEvah")

find_elements_by_name()

1
2
3

for example:
# <input name="cheese" type="text"/>
cheese = driver.find_element_by_name("cheese")

find_elements_by_xpath()

1
2
3
4

for example:
# <input type="text" name="example" />
# <INPUT type="text" name="other" />
inputs = driver.find_elements_by_xpath("//input")

find_elements_by_link_text()

1
2
3

for example:
# <a href="http://www.google.com/search?q=cheese">cheese</a>
cheese = driver.find_element_by_link_text("cheese")

find_elements_by_partial_link_text()

1
2
3

for example:
# <a href="http://www.google.com/search?q=cheese">search for cheese</a>>
cheese = driver.find_element_by_partial_link_text("cheese")

find_elements_by_tag_name()

1
2
3

for example:
# <iframe src="..."></iframe>
frame = driver.find_element_by_tag_name("iframe")

find_elements_by_class_name()

1
2
3
4

for example:

<div class="cheese"><span>Cheddar</span></div><div class="cheese"><span>Gouda</span></div>
cheeses = driver.find_elements_by_class_name("cheese")

find_elements_by_css_selector()

1
2
3

for example:
# <div id="food"><span class="dairy">milk</span><span class="dairy aged">cheese</span></div>
cheese = driver.find_element_by_css_selector("#food span.dairy.aged")

鼠标动作链

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

#导入 ActionChains 类
from selenium.webdriver import ActionChains

# 鼠标移动到 ac 位置
ac = driver.find_element_by_xpath('element')
ActionChains(driver).move_to_element(ac).perform()


# 在 ac 位置单击
ac = driver.find_element_by_xpath("elementA")
ActionChains(driver).move_to_element(ac).click(ac).perform()

# 在 ac 位置双击
ac = driver.find_element_by_xpath("elementB")
ActionChains(driver).move_to_element(ac).double_click(ac).perform()

# 在 ac 位置右击
ac = driver.find_element_by_xpath("elementC")
ActionChains(driver).move_to_element(ac).context_click(ac).perform()

# 在 ac 位置左键单击不放
ac = driver.find_element_by_xpath('elementF')
ActionChains(driver).move_to_element(ac).click_and_hold(ac).perform()

# 将 ac1 拖拽到 ac2 位置
ac1 = driver.find_element_by_xpath('elementD')
ac2 = driver.find_element_by_xpath('elementE')
ActionChains(driver).drag_and_drop(ac1, ac2).perform()

下拉框

1
2
3
4
5
6
7
8
9
10
11
12

# 导入 Select 类
from selenium.webdriver.support.ui import Select

# 找到 name 的选项卡
select = Select(driver.find_element_by_name('status'))

# 
select.select_by_index(索引)
select.select_by_value(属性值)
select.select_by_visible_text(文本的值)
# 全部取消选择
select.deselect_all()

页面切换

1
2

driver.switch_to.window("this is window name").click()
driver.switch_to_window(driver.window_handles[index])

页面前进和后退

1
2

driver.forward()     #前进
driver.back()        # 后退

执行js

1

driver.execute_script(js)

隐式等待

1
2
3
4

from selenium import webdriver

driver = webdriver.Chrome()
driver.implicitly_wait(10)

显示等待

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

title_is
title_contains
presence_of_element_located
visibility_of_element_located
visibility_of
presence_of_all_elements_located
text_to_be_present_in_element
text_to_be_present_in_element_value
frame_to_be_available_and_switch_to_it
invisibility_of_element_located
element_to_be_clickable – it is Displayed and Enabled.
staleness_of
element_to_be_selected
element_located_to_be_selected
element_selection_state_to_be
element_located_selection_state_to_be
alert_is_present

常见时间复杂度之间的关系

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

排序算法的稳定性

稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。

冒泡排序

冒泡排序算法的运作如下：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

   1 2 3 4 5 6

   def bubble_sort(alist): for j in range(len(alist)-1,0,-1): # j表示每次遍历需要比较的次数，是逐渐减小的 for i in range(j): if alist[i] > alist[i+1]: alist[i], alist[i+1] = alist[i+1], alist[i]

时间复杂度

• 最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
• 最坏时间复杂度：O(n2)
• 稳定性：稳定
  阅读全文 »

1xx:信息

100 Continue

服务器仅接收到部分请求，但是一旦服务器并没有拒绝该请求，客户端应该继续发送其余的请求。

101 Switching Protocols

服务器转换协议：服务器将遵从客户的请求转换到另外一种协议。

2xx:成功

200 OK

请求成功（其后是对GET和POST请求的应答文档
）

201 Created

请求被创建完成，同时新的资源被创建。

202 Accepted

供处理的请求已被接受，但是处理未完成。

203 Non-authoritative Information

文档已经正常地返回，但一些应答头可能不正确，因为使用的是文档的拷贝。