小知识
辅助知识学习
Class: IT
Created: October 30, 2022 7:14 PM
Reviewed: No
Type: Section
-
SQL
1.1CREATE DATABASE abc; 1.1CREATE TABLE user (id INT(6) UNSIGNED PRIMARY KEY AUTO_INCREMENT, name VARCHAR(20) NOT NULL, passwd VARCHAR(20) NOT NULL, job VARCHAR(20) NOT NULL); /*属性 NOT NULL - 每一行都必须含有值（不能为空），null 值是不允许的。 DEFAULT value - 设置默认值 UNSIGNED - 使用无符号数值类型，0 及正数 AUTO_INCREMENT - 设置 MySQL 字段的值在新增记录时每次自动增长 1 PRIMARY KEY - 设置数据表中每条记录的唯一标识。 通常列的 PRIMARY KEY 设置为 ID 数值，与 AUTO_INCREMENT 一起使用。 */ 2.1DROP DATABASE database; 2.2DROP TABLE table_name; 3.1ALTER TABLE table_name DROP COLUMN column_name; 3.2ALTER TABLE table_name ADD COLUMN column_name; 3.3ALTER TABLE table_name CHANGE COLUMN column_name; 3.4ALTER TABLE table_name RENAME TO new_name; 4.1INSERT INTO database.table (`key`) VALUES ('value'); 5.1UPDATE table SET val = new_val; -
HTML/XML
URI统一资源标志符: URL 统一资源定位符
URN 统一资源名称
onclick="return function()“
根据function的返回值，进行下一步操作，当返回值为true时，进行下一步操作，当返回值为false时，不进行操作。
<a href="url" οnclick="return add_onclick()">Open 中
如果函数 add_onclick() 返回 true, 那么 页面就会打开 url，
-
HTTP/HTTPS(base on Tcp/IP)
200 yes 301 永久重定向 404 找不到资源 500 服务器内部错误 1)GET/POST 通过URL去在服务器取东西/向服务器发送东西
request 向服务器发送请求，服务器返回一个结果 foward 服务器内部发生重定向 redirect 服务器接受到请求后发送一个状态给客户，客户请求一个新的url url 统一资源定位器 2)User-Agent
3)Referer
4）X-Forwarded-for:your_ip
-
js
1)输出
<script> windows.alert(1) document.write(1) document.getElementById(1).innerHTML='1' console.error(1) console.log(1) document.getElementById(id).attribute=新属性值 document.getElementById(id).style.property=新样式 document.getElementById(id).action=function(){} document.getElementByTagName() 返回一个HTMLcollocation 操作和数组类似，其中有length属性 document.querySelectorAll(selector) 返回一个NodeList 操作和数组类似，其中有length属性 </script>2)循环和变量
for (x in list){ } 或者 for (i=0;i<6;i++){ } = 赋值 ==等式 检查值 ===恒等式 检查值和类型 undefined != null x.indexOf(a) x中a的位置 未用var声明就视为全局变量 可重复声明 let 声明为该{}内的块局域变量 不可重复声明 element.action() eg. e1.click()3)正则
var r1=/正则表达式/g r1.exec(str1)返回匹配的字符串 search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。 replace() 方法用于在字符串中用一些字符串替换另一些字符串，或替换一个与正则表达式匹配的子串。4）表单
document.forms['form_name']['key_of_form'].value html元素.checkValidity() 如果 input 元素中的数据是合法的返回 true，否则返回 false。 setCustomValidity() 设置 input 元素的 validationMessage 属性，用于自定义错误提示信息的方法。5）对象和函数
var object1={ name:'name1' show_name:function(){ return this.name } } function（）{} void function(){}无返回值 timeout(fun,ms毫秒)启动子线程在ms毫秒后启动6）创建元素
var e1= document.createElement('a') var t1 = document.createTextNode(text)文本节点 e1.appendChild(t1)给a元素添加文本 e1.href="xxxx" parent.appendChild(e1） 把e1所代表的a元素追加到html中parent所代表的元素中 parent.insertBefore(child1,e1) 把e1所代表的a元素添加到html中parent所代表的元素中的child1前 parent.removeChild(e1) parent.replaceChile(e1,new_e1)7)jQuery
引入js 单独写一行
开始书写
$(document).ready(function(){//jquery代码}); $(function(){//jquery代码}); 基本语法$(selector).action(); $(selector).action(function(){});发生事件后执行-
selector
$(”*”) 选所有
$(”p”) 选择p元素
$(”#3”) 选择id为3的元素
$(”.nihao”) 选择class=nihao的元素
$(”ul li ”) 选择ul里的li元素
$(”[href=’xx’]”) 选择属性为href=’xx’的元素
$(”a[href=’x’]”) 选择href=’x’的a元素
$(":button") 选取 type="button" 的 元素 和
-
action
-
响应事件
hide(speed,callback) show(speed,callback) toggle(speed,callback)点一下消失再点一下显示
fadeIn(speed,callback) fadeOut(speed,callback) fadeToggle(speed,callback) fadeTo(speed,callback,opbcaity)
slideDown(speed,callback) slideUp(speed,callback)
animate({args},speed,,callback) 例如
$("button").click(function(){
$("div").animate({
left:'250px',
opacity:'0.5',
height:'150px',
width:'150px'
});
});将button移动并改变大小stop(stopAll,goToEnd)
可选的 stopAll 参数规定是否应该清除动画队列。默认是 false，即仅停止活动的动画，允许任何排入队列的动画向后执行。
可选的 goToEnd 参数规定是否立即完成当前动画。默认是 false
-
捕获和修改元素
$(selector).html()整个标签 .val()表单键的值 .text()文本 .attr()属性\括号内有东西就是修改
$(selector).append() 追加prepend()开头加入 可以是文本或者整个标签添加多个时可以用，分隔
$(selector).after() before() 可以是文本或者js dom创建的元素或者jQuery创建的元素
$(selector).remove(selector) empty()
$(selector).addcss() removecss()
-
技巧
方法链
$("#p1").css("color","red").slideUp(2000).slideDown(2000);
$("#p1").css("color","red")
.slideUp(2000)
.slideDown(2000);遍历
.parent() .parents() $(selector1).parentUtil(selector2)返回在selector1和selector2之间的
.child() .find()//寻找在其下面的
sbilings() next() nextAll() nextUtil() prev() prevAll() prevUtil()
-
jQuery和Ajax
1）$(selector).load(URL,callback);
url eg.”demo_test.txt” txt里面可能写的html “demo_test.txt selector”如果是html就选择selector符合的callback=function(responseTxt,statusTxt,xhr){}
- responseTxt - 包含调用成功时的结果内容
- statusTXT - 包含调用的状态 success 和error
- xhr - 包含 XMLHttpRequest 对象 其中.status即是http状态码 .statusTxt就是上面的statusTxt
2）
$.get(URL,callback); $.get( URL [, data ] [, callback ] [, dataType ] )； //data {key:value} dataType默认是html，xml，json //callback funtion(data,status){} $.post(URL[,data][,callback][,dataType]) $.ajax({key1:value,key2,value}) $.ajaxSetUp({key:value})//预处理在用此函数后需要$.ajax()启动 $(selector).getScript(url,function(response,status){}) $(selector).getJSON(url,data,function(response,status){}) ajax的key:value对如下async 布尔值，表示请求是否异步处理。默认是 true。 beforeSend(xhr) 发送请求前运行的函数。 cache 布尔值，表示浏览器是否缓存被请求页面。默认是 true。 complete(xhr,status) 请求完成时运行的函数（在请求成功或失败之后均调用，即在 success 和 error 函数之后）。 contentType 发送数据到服务器时所使用的内容类型。默认是："application/x-www-form-urlencoded"。 context 为所有 AJAX 相关的回调函数规定 "this" 值。 data 规定要发送到服务器的数据。 dataFilter(data,type) 用于处理 XMLHttpRequest 原始响应数据的函数。 dataType 预期的服务器响应的数据类型。 error(xhr,status,error) 如果请求失败要运行的函数。error:function(xhr,status,error){} success(result,status) 请求成功要运行的函数。success:function(xhr,status,error){} global 布尔值，规定是否为请求触发全局 AJAX 事件处理程序。默认是 true。 ifModified 布尔值，规定是否仅在最后一次请求以来响应发生改变时才请求成功。默认是 false。 jsonp 在一个 jsonp 中重写回调函数的字符串。 jsonpCallback 在一个 jsonp 中规定回调函数的名称。 password 规定在 HTTP 访问认证请求中使用的密码。 processData 布尔值，规定通过请求发送的数据是否转换为查询字符串。默认是 true。 scriptCharset 规定请求的字符集。 success(result,status,xhr) 当请求成功时运行的函数。 timeout 设置本地的请求超时时间（以毫秒计）。 traditional 布尔值，规定是否使用参数序列化的传统样式。 type 规定请求的类型（GET 或 POST）。 url 规定发送请求的 URL。默认是当前页面。 username 规定在 HTTP 访问认证请求中使用的用户名。 xhr 用于创建 XMLHttpRequest 对象的函数。
8)Vue.js(Vue2)
-
调用
<script src="vue.js"></script> <script src="cbn_url"></script> -
一些框架网站
https://element-plus.org/zh-CN/#/zh-CN
https://next.antdv.com/components/overview-cn
-
基本语法
<body> <div id="app">{{ key 或者表达式 }} <p>....</p> </div> </body> <script> var name = new Vue{ el:"#app", data:{key:value}, method:{func_name:function(){}} //methods在重新渲染的时候，函数总会重新调用执行。 computed:{func_name:function(){}} //computed是基于它的依赖缓存，性能会好。 components:{components_name:com_class_name} //var com_class_name={template:html} } </script> -
控制结构
<p v-if="expr"></p> <p v-else-if="expr"></p> <p v-else></p> <p v-for=" val in vals"></p> <p v-for="n in 10"></p> -
自定义组件
导入
import Component from "xx.vue" export default{ component:{ Component} }Vue.component(component_name,{ props:['key'],//将component_name组件传给template props:{key:type}, template:html, data:function(){return{key:val}}, method:function{}, })\(on事件监听，\)emit事件触发 如
-
例子1
<div id="app"> <div id="counter-event-example"> <p>{{ total }}</p> <button-counter v-on:increment="incrementTotal"></button-counter> ***点击后到template 最初定义 触发increment就调用incrementTotal*** <button-counter v-on:increment="incrementTotal"></button-counter> </div> </div> <script> Vue.component('button-counter', { template: '<button v-on:click="incrementHandler">{{ counter }}</button>', ***调用incrementHandler*** data: function () { return { counter: 0 } }, methods: { incrementHandler: function () { this.counter += 1 this.$emit('increment') ***触发事件increment,到v-on:increment*** } }, }) new Vue({ el: '#counter-event-example', data: { total: 0 }, methods: { incrementTotal: function () { this.total += 1 } } }) </script> -
如果要custom-input使用v-model
Vue.component('custom-input', { props: ['key'], template: ` <input v-bind:value="key" v-on:input="$emit('input', $event.target.value)" > ` })
-
-
属性
v-bind: === : v-on: === @ <p v-bind:attr="attrname"></p> <p v-bind:attr="{attrname:key}"></P> <p v-bind:attr="[key1,key2}"></P> 在Vue的data内需要key1:attrname1和key2:attrname2 key2可以覆盖key1 <p v-bind:attr="[basekey jugde?yeskey:nokey]"></P> <p v-on:action=""></p> <p v-html="key"></p> <input v-model="key"> === <input v-bind:value="key" v-on:input="key = $event.target.value"> v-model 用来在input、select、textarea、checkbox、radio 等表单控件元素上创建双向数据绑定， 根据表单上的值，自动更新绑定的元素的值。- 修饰符
-
v-on.action.description事件修饰符
.prevent- 阻止默认事件.stop- 阻止冒泡.capture- 阻止捕获.self- 只监听触发该元素的事件.once- 只触发一次.left- 左键事件.right- 右键事件.middle- 中间滚轮事件
-
v-on.keyup.key=”func”
简写@keyup.key=”func”
一些按键的别名
.enter.tab.delete(捕获 "删除" 和 "退格" 键).esc.space.up.down.left.right.ctrl.alt.shift.meta
-
v-model.description
- .lazy惰性更新
- .number改成int类型
- trim首尾去空
-
- 修饰符
-
-
PHP
1)单行注释//多行注释/* */
2)输出echo xxx; echo ‘ss’.’ss’;
3）变量声明$var
4）class- >attribute 调用属性
5）Get：$a = $_GET[’key’];
6)Post: $b = $_POST[’KEY’]
7）数据库
-
database_operatio数据库查语句
<?php $servername = "localhost"; $username = "root"; $password = "root"; $dbname = "haha";//数据库库名 //创建连接 $conn = new mysqli($servername,$username,$password,$dbname); //检测链接 if($conn->connect_error){ die("连接失败".$conn->connect_error); } /* //数据库查语句 //准备一条数据库语句 $sql = "SELECT * FROM table1 WHERE id < 3"; //执行sql语句并且返回给变量 $result = $conn->query($sql); //判断$result里是否有东西 if($result->num_rows>0){ //输出数据 while($row = $result->fetch_assoc()){ echo $row['id'].'-----'.$row['username'].'------'.$row['job'].'<br/>'; } }else{ echo "0结果"; } */ /* //数据库增语句 $sql = "INSERT INTO table1 (username,password,job) VALUES('user5','mima55','cfo')"; if($conn->query($sql)===TRUE){ echo "新记录插入成功"; }else{ echo "插入失败".$conn->error; } */ /* //数据库修改语句 $sql = "UPDATE table1 SET password='mima598' WHERE username='user5'"; if($conn->query($sql)===TRUE){ echo "修改成功"; }else{ echo "修改失败".$conn->error; } */ /* //数据库删除语句 $sql = "DELETE FROM table1 WHERE username='user5'"; if($conn->query($sql)===TRUE){ echo "删除成功"; }else{ echo "删除失败".$conn->error; } */ $conn->close(); ?> ------------------------ <html> <head> <title>我是网页</title> </head> <body> <?php $servername = "localhost"; $username = "root"; $password = "root"; $dbname = "haha";//数据库库名 //创建连接 $conn = new mysqli($servername,$username,$password,$dbname); //检测链接 if($conn->connect_error){ die("连接失败".$conn->connect_error); } //数据库查语句 //准备一条数据库语句 $sql = "SELECT * FROM table1 WHERE id < 4;"; //执行sql语句并且返回给变量 $result = $conn->query($sql); //判断$result里是否有东西 if($result->num_rows>0){ //输出数据 echo "<table border='1'>"; echo "<tr><th>id</th> <th>username</th> <th>job</th></tr>"; while($row = $result->fetch_assoc()){ echo "<tr>"; echo "<td>".$row['id']."</td>"; echo "<td>".$row['username']."</td>"; echo "<td>".$row['job']."</td>"; echo "</tr>"; } echo "</table>"; } $conn->close(); ?> </body> </html>
8)re
preg_replace(“/ re_expr /如果这里有e即/e 是表明这个是可执行”,’\1’,str)
\1 == $1 指前面re表达式的（）里的分组
-
thinkphp
默认报错 页面错误！请稍后再试～
伪造session 把phpsession改为jspsession
route.php 伪造路由
-
route.php
Route::get('hello/:name', 'index/hello');
-
controller
-
-
-
PYTHON
-
函数参数趣事
1）函数默认参数可变 即是 函数内默认参数从第一个函数定义运行变为对此函数的全局变量 如
def demo(a,li=[]): li.append(a) print(li) demo('s') demo("ss") output>>['s'] >>['s','ss']def demo(a,li[12]): li.append(a) print(li) demo('sa') demo('ssssss') demo('s',[23]) demo('ssss') demo('ss') ouput>>[12, 'sa'] >>[12, 'sa', 'ssssss'] >>[23, 's'] >>[12, 'sa', 'ssssss', 'ssss'] >>[12, 'sa', 'ssssss', 'ssss', 'ss'] -
函数名趣事
函数一定义，函数名就变成函数地址名（实际上就是一个变量，所以可以被包含在列表中），函数名加括号func（）就是调用
-
闭包趣事
1）判断是不是闭包func.closure if return cell is yes
def outer(a): b=10 def inner(): print(a+b) return inner f=outer(10) f()2)装饰器
def description(func): def inner(*args,**kwargs): #和被修饰函数保持一致 ... return inner @description def func(*args,**kwargs): pass def outer(*args,**kwargs): def outer2(func): def inner(*args,**kwargs): ... return inner return outer2 @outer(*args,**kwargs) def func(*args,**kwargs): #这两二个*args,**kwargs没有关系 pass @f1 @f2 def func()... 先启动装饰器f1运行到调用func时停止给f2运行最后f2运行到func执行 之后f2继续运行结束f1继续运行结束 -
迭代器&生成器趣事和推导式技巧
1）迭代器
it = it.__iter___() it.__next__() #如果没有了就报错于是有 try:..except:...#自动迭代方法2）生成器
def func(): code_block1... yield xxx code_block2.. func（） res = func.__next__()运行到第一个yield 并返回值 或者 i等同于调用__next__() for i in func（）: #此时i和res值一样 传入参数 xx=func() 必须先让func定义一下send需要 content =yield 1 xx.__next__() xx.__send__(val)发送val并执行一次__next__()3）推导式
-
多线程
1）变量共享
2)锁
Lock 一个锁眼一个钥匙 ==一次只能被一个线程获取一次
RLock 多个锁眼一个钥匙== 一次只能被一个线程获取多次
Semaphore(n)多个钥匙 可以被n个线程获取
Event
默认False 此时Event.wait()阻塞 True时 Event.wait()可以继续执行
Event.set() →true Event.clear() →false
Condition(threading.Lock())
condition.acquire() condition.wait()等待notify!!!!!! notify只能在一个线程获得锁后使用 即要对线程1的wait交流线程2需要先acquire后才能使用notify
notify（n）让n个线程执行
notify_all()
Timer( time ,func or class)
3)线程池
with ThreadExecutePool(max_workers=n) as pool: future = pool.submit(xxx) future.done() future.result() future.add_done_callback(func) def func(future): xxx pool.map(xxx,(xx1,xx2))#()是数据有多少个就启动多少个线程和xx函数有关 -
协程
async def fun(): pass async main(): await fun()#协程调用fun task = asyncio.create_task(fun()) await task #调用task task.result()#返回fun的返回结果 task.done()#task是否完成 await asyncio.gather(fun1(),fun2())#并发执行 await asyncio.wait([fun1()]) -
flask
-
fastapi
1）请求
from fastapi import FastApi,Form,Query,Header from pydantic import BaseModel import uvicorn class PostModel(BaseModel): key1:type = default_value app = FastApi(openapi_url=None,redoc_url=None,docs_url=None) @app.get('/{name}')# http://website/name async def xxx(name:type = default_value): return xxx @app.get('/name/')# http://website/name/?id=1 async def xxx(id:type = default_value): return xxx @app.get('/name/')# http://website/name/?id=1 async def xxx(id:type = Query(default,min_length=n,max_length=m,regex=re): return xxx #regex = 正则表达式符合才获得 @app.get('/name/') # http://website/name/?id=1&id=2&id=3 async def xxx(id:list[str]=Query(None)): return xxx#id = [1,2,3] @app.get('/name/') # http://website/name/ async def xxx(user_agent=Header(None)): return xxx#获得http头的user-agent只有get可以 @app.get('/name/',response_model=PostModel) #里面参数 response_model_exclude_unset=True不去包含默认值 #response_model_exclude={"key"} 不去包含key # http://website/name/?key1=value1 async def xxx(key1:type = default_value): return a_dict#一个字典而且必须和PostModel一致 是必须返回的 @app.post('/haha') #POST里面id=1&name=2 async def xxx(post_model:PostModel = Form()) uvicorn.run(app="filename:app",host=,port=,reload=,)2）错误
@app.route("/name",status_code=404) async def show_name(xx):xxx #数据正常执行只是状态码为404 from starlette.exception import HTTPException arise HTTPException{ status_code:404, details:'', header={"X-ERROR":"wrong"} } from fastapi.responses import JSONResponse,RedirectResponse from fastapi import Request class MyException(Exception): def __init__(self,name): self.name = name @app.exception.handler(MyException) async def exception(request:Request,exc:MyException): return JSONResponse({ 'status_code':404, 'message':f"you have an error with{exc.name}" }) from starlette.exceptions import HTTPException as StarletteHTTPException @app.exception_handler(StarletteHTTPException) def handler(request,exc): return RedirectResponse('/errorpage') @app.get('/errorpage') def show_error(): return "404 not found!"3）返回网页和访问静态资源
from starlette.responses import HTMLResponse from starlette.staticfiles import StaticFiles @app.get('/name') async def name(): return HTMLResponse(content=html_content) #当输入http://website/static/xx.jpg时 #到dictionary后的路径的文件夹去找xx。jpg app.mount('/static',StaticFiles(directory='static'),name='static') from fastapi.middleware.cors import CORSMiddleware origins = [allow_domain1] app.add_middlerware(CORSMiddleware, #允许可以调用的域名 allow_origins=origins， allow_credentials=True， #可 是post 和get allow_method=['*'], # 可 是一堆header allow_header=['*'])
4)其他
from fastapi import BackgroundTasks def xxx(arg1,arg2):... @app.get('/url') async def something(args,background_tasks=BackgroudTasks): #启动后台任务 backgroud_tasks.add_task(xxx,arg1,arg2) #Jinja2前端代码 from fastapi.templating import Jinja2Templates templates = Jinaja2Templates(dictionary = 'templates') @app.get('/{name}',response_class = HTMLResponse) async def show(request:Request,name:str): #xx.html 在 templates/xx.html return templates.TemplateResponse('xx.html',{'request':request,'name':name}) Jinja2 #变量 {{var}} {% code %} {%for n in l%}{%endfor%} {# 注释#} -
-
爬虫
-
xpath
-
re
-
selenium
1)webdriver 输入网址必须全称
-
requests-html
-
代理
proxies = {“TYPE”:”IP:PORT”}
TYPE: HTTP,HTTPS,SOCKET4,SOCKET5
-
-
公网
windows+iis+asp/aspx(asp.net)+access/mssql
windows+apache+php+mysql= wamp（一般使用软件进行集成化搭建）
linux+apache/nginx+php+mysql = lamp/lnmp（有可能使用宝塔或者其他面板搭建）
linux+tomcat+java(jsp)+oracle/mysql
linux+nginx+python(django/flask)+mysql
域环境 Internet——DMZ（停火区，防火墙常在区域）———-内网
1）基本组成
DC domain controller安装了AD活动目录（记录了域的信息）
基本上需要AD服务和dns服务
成员（有server web服务） 客户机（非server系统）
2）分类：单域 父域 子域 多域（树状）多域形成域林
3）权限
域本地组 多域用户访问单域资源
全局组 单域用户访问多域资源（eg.BOSS）
通用组 多域用户访问多域资源（eg.讨论）
-
服务器搭建
python 一键启动
-
Linux
history 查看历史命令
-
文件
d r-x r-x r-x 13 root root 0 Nov 3 11:22 sys
A B C D E
d 文件夹 b区块文件 c字符设备文件 s套接字文件 p 管道文 | 链接
r=read=4 w=write=2 x=execute=1
chmod [权限编号] [目标文件] 修改文件权限
chmod 755 -R [文件夹] 把文件夹和文件夹所有东西都赋值为755
touch [文件名] 新建文件
nano [文本文件] 编辑文件
vi [文本文件] 使用vi去编辑文件
A=所有者权限
B=所有者所在组的权限
C=其他人权限
cp [被复制的人] [复制的位置] 复制文件
mv [被剪切的人] [目标位置] 剪切文件
rm [目标] 删除
rm -rf [目标] 全部删除
(rm -rf /* 危险命令！！)
find [要在哪个地方查找] -name [查找的文件名] 找东西
/dev/null垃圾桶 /dev/tcp/ip/port 文件打开时就打开了socket
-
进程
kill -1重启-9杀死-15正常停止
ps 查看进程
ps -ef 查看所有进程
ps -ef | grep lib 查看进程名字包含lib关键词的进程
top 查看进程
ctrl+c结束
-
输入输出
0标准输入1标准正确输出2标准错误输出
echo $?上个程序的返回码
&>覆盖重定向&>>追加重定向
&>将1和2都重定向到对应流
echo haha 1>yes.out 2>no.out正确输入到yes.out否则输入到no.out
cat hahha 1>&2 2>no.out
分两部分执行 1>&2和2>no.out前后输出流不关联
1>&2正确不显示因为命令执行后系统进入1的输出流可是1的输出流导向了2,也就是标准正确输出没有东西了
同理2>&1错误不显示因为命令执行后系统进入2的输出流可是2的输出流导向了1,也就是标准错误输出没有东西了
cat >1.txt <<EOF直到输入EOF停止
-
查看电脑信息
uname 查看操作系统
uname -a 查看详细版本号
-
防火墙
systemctl stop firewalld
service iptables start/stop
chkconfig iptables on/off
-
-
C/C++
1)变量声明
/*这是一个外部文件*/ #include<stdio.h> extern int x; int add(){return x;} /*这是主函数*/ #include<stdio.h> static int x;/*全局变量*/ int main(){int x = 10; a=add(); return 0;} 此处调用时在外部文件发现extern于是回到主文件去寻找它 可变参数 #include<stdarg.h> va_list valist; va_start(valist,nums); va_arg(valist,type); va_end(valist);2)枚举
enum NAME{xxx=1,xxx1,xx2}; enum NAME name; name=xxx; /* reslut is 1*/ name=xxx1; /* reslut is 2*/3)位域
struct 位域结构名 { type name:width; };4）文件读取
FILE * fp; char str[32]; fp = fopen("xx.txt","r+"); fprintf(fp,"sssss"); fscanf(fp,"%s",str); fputs("ssss",fp); fgets(str,255,fp);//一行 rewind(fp);//return to the head ftell(fp);//tell how long far away from head fseek(position);//goto this position5)宏
#define #undefine #ifdefine #ifndefine #if #elif #else #endif #error #pragam 在宏中可以用#将参数变为字符串 #define show(a) printf("111"#a); int main() { show(nihao); return 0; //outputs is 111nihao } 而##是粘连符比如token##n n=34 即变量token34 #define getone(a,b) (a+b>10?a:b)//返回结果 int main() { int a = 0; a = getone(10,20); printf("%d\n",a);//10 return 0; }6)动态分配内存
char *str; //动态 str = (char *)calloc(200,sizeof(char)); free(str); //直接给空间 str = (char *)malloc(200*sizeof(char)); realloc(str,new_size);//重新分配大小7)命令行
int main(int argc,int *argv[]) argc //参数个数:len(argv) argv[0]//程序名称
Vmare
1）vmx损坏
重新装虚拟机然后使用已有磁盘
汇编
- x86
- x64
- amd64,arm64
-
AI
- 基础知识
- 基本的数据格式
1）图像(batch_size,feature_dim,width,length)
灰度feature_dim 为1 RGB feature-dim 为3
2）文本（batch_size,max_n,feature）
max_n一次存最大的词数，feature词向量的特征常常为300
一般情况embedding这个表用别人训练好的
当然如果使用专业性强的比如生物相关名词重新训练
- 基本层
dense or linear → activation(AX+B)
resnet 残差 Xoutput = Xinput+layer(Xinput) 输出输入不一样做投影
- 卷积层（CNN）
原始输入 32*32*3 H0 =32 W0=32
卷积层10个卷积核 5*5*3 CH0=5 CW0=5步长S为1 填充P为1
输出30*30*10 H1 W1
$$
H1=(H0-CH0+2P)/S +1
$$
$$
W1 = (W0-CW0+2P)/S+1
$$
感受野 input 7*7 每个卷积核3*3
conv1 5*5 它的一个格子能看到input的3*3 感受野3*3
conv2 3*3 它的格子能看到 conv1的3*3即input的3*3的3*3
一共7*7我们可知道有重叠最终感受野7*7
于是我们可以将感受野设为定值
从而是用多个小卷积核换成一个大卷积核
最终参数变少
2）CNN处理词向量
```python
构造一个ModuleList里面有1*词向量长度一直到最大次数*词向量长度
1*vocab_size - ---> max_vocab*vocab_size
输入卷积层前（batch_size,max_vocab,vocab_size）处理
unsqueeze(out1,1)在标号1的添加一个维度
(batch_size,1,max_vocab,vocat_size)这才能被卷积读取
然后进行压缩
先对结果处理返回原本状态
squeeze(3)把之前额外增加的一个维度干掉
F.maxpool1d(out,out.size(2)).squeeze(2)
将第三列的即最后那个获得的特征结果压缩成一个
（batch_size，feature_dim,feature_n=1）
在去除额外的一维度，获得结果out1
最后用torch.cat把压缩结果out1连接在一起
第二个参数指明按列连接
```
- LSTM（RNN）
基本公式
双向传播的必要性
比如我今天____一整天
如果只有正向 有可能把瞬时动作eg.开门填入
而我们知道不可能开门一整天就需要反向传播去纠正
返回维度为神经维度*2(正向加反向)
- 公式推导
- GAN（对抗生成)
- OCR
- CTPN
- CRNN
首先用CNN提取特征，其中文字识别主要
靠一个一个检查框所以保持宽度一定
因此后面部分层maxpool2d 用的（1x2or 2x1看数据了）把宽传入所以高必须变为1（batch,maps_dim,heigth,width）
在传入LSTM应为（batch,width,maps_dim）对应把特征图个数当做词向量
（batch，seq_len,word_vector）
转换后可能会得到 hhheeelllloo
用CTC 算法转换为hello
- 注意力机制（Transformer）
- 相关性计算
给一个目标query （例如想要的是鱼）
输入信息key 指每个重要点（例如一幅画中的船，树，鱼）
attentionvalue是进行相关性加权计算的结果
输入信息，对各个信息与query做相关性打分，使用softmax normal化得出各个key的相关值，把这些值与key加权求平均值得到最终结果。
相关性打分函数
其中双线性模型中Wq权重矩阵可以在网络中被训练
- self-attention
对于两个词Thinking Machines
k1是从x1提出来的关键点
q,k,v其中q由query矩阵的线性变换
k,v 由老的一层矩阵线性变换
- Multi-head attention
多个self-attention
```python
import torch
import torch.nn as nn
class MultiheadSelfAttention(nn.Module):
def __init__(self, d_model, num_heads):
dmoadel 输入向量的维度
super().__init__()
#保证多个注意力可以完全分割维度
assert d_model % num_heads == 0
self.d_model = d_model
self.num_heads = num_heads
单个注意力的范围
self.head_dim = d_model // num_heads
self.query_projection = nn.Linear(d_model, d_model)
self.key_projection = nn.Linear(d_model, d_model)
self.value_projection = nn.Linear(d_model, d_model)
self.output_projection = nn.Linear(d_model, d_model)
def split_heads(self, x):
batch_size, seq_len, d_model = x.size()
x = x.view(batch_size, seq_len, self.num_heads, self.head_dim)
x = x.transpose(1, 2)
return x
def forward(self, x,m):
batch_size, seq_len, d_model = x.size()
# Project inputs to queries, keys, and values
queries = self.query_projection(x)
keys = self.key_projection(m)
values = self.value_projection(m)
# Split heads
queries = self.split_heads(queries)
keys = self.split_heads(keys)
values = self.split_heads(values)
# Calculate scaled dot-product attention
scores = torch.matmul(queries, keys.transpose(-1, -2)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))
attn_weights = nn.functional.softmax(scores, dim=-1)
attn_output = torch.matmul(attn_weights, values)
# Concatenate heads and project to output
# merge the n_heads parts into a single tensor
attn_output = attn_output.permute(0, 2, 1, 3).contiguous()
**原本的形状(batch_size, n_heads, seq_len, head_dim)变成(batch_size, seq_len, n_heads, head_dim)**
attn_output = attn_output.view(attn_output.size(0), attn_output.size(1), -1)
# apply a linear transformation to the output
out = self.out_linear(attn_output)
return attn_output
```
- Tansformer
- encoder
有两个子层 multi
- ViT（vision transformer）
将一个224x224分成16x16
- BERT和GPT
1）自监督
BERT denoising(完形填空)
GPT language modeling 已有一个句子预测下一个词
-
- 防止过拟合和过度调整
1. 增加数据集的大小，可以减少模型在数据集中的记忆，从而减少过拟合的风险。
2. 使用数据增强技术，例如翻转、旋转、裁剪等，可以增加训练集的多样性，有助于减少过拟合。
3. 使用正则化技术，例如L1正则化、L2正则化、dropout等，可以限制模型的复杂度，有助于减少过拟合。
4. 采用早停法，即在训练过程中定期评估模型在验证集上的表现，当模型在验证集上的表现不再提高时，停止训练。
5. 使用集成学习技术，例如投票、平均等，可以结合多个模型的预测结果，有助于减少过拟合。
6. 采用学习率调度器，在训练过程中动态调整学习率，可以防止过度调整。
7. 选择合适的模型结构和超参数，例如网络层数、节点数、学习率、正则化强度等，可以在保持一定的模型表现的同时，避免过度拟合和过度调整。
PyTorch
1)基础操作
```c
one = torch.ones(3,4)有12个
two = one.view(-1,6) two size is （2，,6）因为2*6=3*4个数一致
tensor.numpy()
torch.from_numpy(numpy1)
tensor(array,requires_gard=True)可以反向求导不用variable包装
tensor.fill_(val)将其对所有的内容赋值为val
其中某些操作保障随机生成（可能是在模型内）的值在某段情况下保持一致
np.random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed_all(1)
```
2）基本流程
<aside>
💡 一般有隐藏层用nn.Module,其他nn.fountional
<aside>
💡 1）model.train()用于训练 2）model.eval（） 用于评估 with torch.no_grad（）:
</aside>
</aside>
```python
class LanguageModel(nn.Module):
#定义了所有的层数
def __init__(self,hidden_dim,vocab_size):
super().__init__()
self.fc = nn.Linear(hidden_dim, vocab_size)
#实现模型的功能，实现各个层之间的连接关系的核心
def forward(self, x, hidden):
x = self.fc(x)
return x
model = LanguageModel(vocab_size, embedding_dim, hidden_dim, num_layers)
# Adam优化器：RMSProp的升级版本，梯度滑动平均和偏差纠正
optimizer = optim.Adam(model.parameters())
# CrossEntropyLoss交叉熵损失函数
criterion = nn.CrossEntropyLoss()
# Train the model
train(model, optimizer, criterion, data, num_epochs=10)
def train(model, optimizer, criterion, data, num_epochs):
model.train()
for epoch in range(num_epochs):
total_loss = 0
for i, (inputs, targets) in enumerate(data):
#清除以前的梯度
optimizer.zero_grad()
#训练，等同调用model.forward
outputs= model(inputs, hidden)
loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))
#反向传播，计算当前梯度
loss.backward(retain_graph=True)
#retain_graph保证之后如果有第二个loss时不会提前清零
一般最后一个loss不加retain_graph
#根据梯度更新当前网络参数
optimizer.step()
total_loss += loss.item()
print(f"Epoch {epoch + 1}/{num_epochs}, Loss: {total_loss / len(data)}")
```
3）模型保存/使用gpu
```c
torch.save(model.state_dict(),"model.pkl")
model.load_state_dict(torch.load("model.pkl"))
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
input = input_data.to(device)
____________________关于验证时无法使用numpy的方法
在验证时将数据label.data.cpu()
转化为CPU的类型即numpy可以处理
```
4)数据处理
```python
from torch.utils.data import DataLoader,Dataset
x_train = numpy.random.randn((3,4))
y_train = numpy.random.randn((3,4))
train_ds = Dataset(x_train,y_train)
train_dl = DataLoader(train_ds,batch_size= 50,shuffle=True)
```
5）tensorboardx
```python
from tensorboardX import SummaryWriter
writer = SummaryWriter(log_dir='')
writer.add_scalar("loss",loss,step)
```
6）学习率调度器
```python
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma, last_epoch=-1)
按给定间隔(step_size)调整学习率，将学习率乘以给定因子(gamma)。可以通过last_epoch参数指定从哪个epoch开始调整。
torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)
按给定的milestones（一个list）调整学习率，将学习率乘以给定因子(gamma)。可以通过last_epoch参数指定从哪个epoch开始调整。
torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)
按指数衰减调整学习率，每个epoch将学习率乘以给定因子(gamma)。可以通过last_epoch参数指定从哪个epoch开始调整。
torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)
按余弦退火调整学习率，将学习率从初始值退火到最小值(eta_min)。T_max指定退火周期，即在T_max个epoch内学习率从初始值下降到最小值。
torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
在验证集上监测指标，当指标不再改善时，按给定因子(factor)调整学习率。patience指定在多少个epoch内指标没有改善时，调整学习率。cooldown指定在调整学习率之后，暂停多少个epoch再继续监测指标。
torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=2000, step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-1)
循环调整学习率，学习率在base_lr和max_lr之间循环变化。step_size_up指定学习率上升的步数，step_size_down指定学习率下降的步数。mode可以是'triangular'或'cosine'，指定学习率变化的模式。gamma指定每个周期结束时，学习率变化的因子。cycle_momentum指定是否循环调整动量参数。
```
7)其他
```python
nn.ModuleList将list中的层并行操作求和结果
返回个数*特征图
```
分布式训练
```python
单机器多GPU
init_process_group(backend="gloo")
dataloader的sampler=DistributedSample（dataset）
里面的rank 用os.environ["LOCAL_RANK"]访问
destroy_process_group()
torchrun --standalone --nproc_per_node=gpu
多机器
os.environ["RANK"]
torch --nproc_per_node=gpu --nnodes=[节点总个数]
--node_rank=0
--rdzv_id=456 进程组id可以随机不过全部必须保持一致
--rdzv_backend=c10d 进程间通信方式
--rdzv_endpoint=ip:port
各个节点的总通讯员ip地址也就是把所有数据汇给它，
所有全部保持这个ip一致
```
- pandas
1）`pandas.get_dummies(array)`
将array里面非数字进行one_hot编码
array.drop[key]将数据里的key标签的去掉
from sklearn import preprocessing
`preprocessing.StandardScaler.fit_transform(array)`
标准化处理数据
- sklearn
- Metric
accuracy_store(pre,res) 一维度的
classification_report(pre,res,target_names=names)
-
VR/AR
ARFoundation
ARKIT ARCore
-
渗透工具
-
scapy
show_interfaces()输出无返回
summary（）包的摘要
1）包定义/一般表示包装 底层/更高层
IP(dst=”ip”)/ICMP()
IP(dst=”ip”，ttl)/fuzz(TCP()) Fuzz随便填充
IP src=源ip dst=目标ip ttl=最多经过路由数一般为64 ICMP type：ICMP消息类型，例如Echo Request（类型码为8）、Echo Reply（类型码为0）、Destination Unreachable（类型码为3）Time Exceeded（类型码为11） id：ICMP标识符（1-65535） seq：ICMP序列号（1-65535） TCP sport源端口 dport目标端口 flags S=SYN SA=SYN+ACK A=ACK R=RST PA=PUSH+ACK FA = FIN+ACK UA = URG+ACK window= TCP窗口大小指的是接收方设备用于接收数据的缓冲区大小 seq序列号 ETHER src源MAC地址 dst目标MAC地址 ARP op ARP操作类型，可以是who_has （ARP请求）或is_at （ARP响应） pdst目标ip psrc源ip hwdst目标MAC hwsrc源MAC hwtype硬件类型 ptype协议类型 - 一些硬件类型和协议类型
0x0001：以太网（Ethernet）0x0006：IEEE 802 网络（Token Ring）0x0007：SLIP（串行线路互联协议）0x0008：ATM0x0011：FDDI（光纤分布式数据接口）0x0030：IEEE 802.11 网络（无线局域网）0x0031：Bluetooth0x00FF：通用（全网广播）0x0100：令牌桥0x0101：令牌环0x0137：IP over FC（Fibre Channel 网络上的 IP 协议）0x0180：令牌快速（令牌传输速率高于 16 Mb/s 的 Token Ring）0x0806：ARP0x8035：RARP0x809B：AppleTalk0x80F3：AARP0x8100：VLAN Tagged Frame（VLAN 标签帧）0x86DD：IPv60x8600：IPv40x880B：PPP（Point-to-Point Protocol）0x880C：GSMP（GSM PLMN 协议）0x880E：802.1x0x8863：PPPoE Discovery Stage（PPPoE 探测阶段）0x8864：PPPoE Session Stage（PPPoE 会话阶段）0x888E：802.1X PAE（Port Access Entity）
2）行为
参数 iface=网卡
send只发 sendp直接对网络接口发送
sr，sr1，srp发和接受一般用sr1 有timeout参数verbose=True(显示详细信息)
(1)sr返回
(send_packets, recv_packets)(received_packet, (src_ip, dst_ip, iface_name))
(2)sr1直接返回rcv
(3)srp发送以太网包→(send_packets, recv_packets) (received_packet, (src_mac, dst_mac, iface_name))
rcv.sprintf(”%IP.src%”)
-
信息搜集
python-whois
whois.whois(domain)
socket.gethostbyname(domain)
rcv.haslayer(”TCP’)
rcv[”TCP”].flags == “0x12”
- URG：0x20
- ACK：0x10
- PSH：0x08
- RST：0x04
- SYN：0x02
- FIN：0x01
-
banner
rcv.payload
或者
s = sock.sock() s.connect((ip,port)) s.send("".encode()) data = s.recv(1024) s.close() -
嗅探
sniff（prn，iface,filter,count）
prn一个回调函数输入参数为一个包
iface网卡 filterBFP网络过滤器 count抓几个包
-
BFP
用and or 连接
src net 网段192.168.1.0/24
src host ip dst host ip ether src ether dst
src port ip dst host port portrange
tcp http udp https
ttl ip_proto
tcp[13] 标志位 tcp[13] & 0x12 != 0 示只要SYN位和SYN/ACK位中至少有一个被设置，就认为该TCP报文是SYN+ACK类型的
tcp[13] == 0x12
tcp payload “content”
less [int] greater [int] len[int] 包长度判断
-
-
arp欺骗
单向Ether（）/ARP（pdst=victim_ip,psrc=gateway_ip）
双向
Ether(dst=gateway_MAC，src=hack_MAC)/ARP(op=2,pdst=gateway_ip,hwdst=gateway_mac,psrc=victim_ip,hwsrc=hack_mac)
同理
- 一些硬件类型和协议类型
-
浙公网安备 33010602011771号