安全矩阵

 找回密码
 立即注册
搜索
查看: 1132|回复: 94

李佳瑞学习日记

[复制链接]

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
发表于 2020-2-20 23:27:22 | 显示全部楼层 |阅读模式
今天学习了节点文档读写的方法,document.open方法用于新建一个文档,供write方法写入内容。它实际把当前文档的内容删除,然后重新写入内容;document.close用于关闭open方法所建立的文档,一旦关闭,write方法就无法写入内容,如果再调用write方法相当于再一次调用open
学习了如何查找节点,一般通过标签的id来获取元素节点对象。
Var node = document.getElementByld(“标签id”)
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title></title>
  <script type="text/javascript">
   window.onload = function(){
    var odiv = document.getElementById('box');
    odiv.onclick = function(){
     alert('点击');
     //读写操作
     document.open();
     document.write('hello');
    }
   }
  </script>
  <style type="text/css">
   #box{
    width: 100px;
    height: 100px;
    background-color:red ;
   }
  </style>
</head>
<body>
  <div id="box">
   1234
  </div>
</body>
</html>



回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-22 00:17:26 | 显示全部楼层
Python线程
在学习线程的过程中首先要了解什么是多任务,多任务指的是在同一时间内执行多个任务,每个任务可以理解成生活中我们做的每件事情。
1、在很多场景中事情是同时进行的,比如在跑步时听音乐,在开车时,手和脚同时控制汽车。
2、操作系统可同时进行多个任务。打个比方,一边购物,一边聊天,一边听歌,一边写文档。
并发:指的是任务数多于CPU核数,通过操作系统的和各种任务调度算法,实现多个任务一起执行
并行:指的是任务书小于CPU核数,即任务真的可以一起执行
了解完这些既可以看线程了,线程就是在程序运行过程中,执行代码的一个分支,每个运行的程序至少都有一个线程
单线程执行多任务代码如下:
#任务一看电影,任务二,吃饭
#任务一看电影,任务二,吃饭
def film():
    for i in range(5):
        print('看电影')
def ret():
    for i in range(4):
        print('吃饭')
if __name__ == '__main__':
    film()
    ret()
多线程执行代码如下:
#多线程执行多任务
import threading
def film():
    for i in range(3):
        print('看电影')
def eat():
    for i in range(2):
        print('吃零食')
if __name__ == '__main__':
    #创建子线程
#Thread(target= 任务名:即函数名)
    film_thread = threading.Thread(target=film)
    eat_thread = threading.Thread(target=eat)
#启动任务
film_thread.start()
eat_thread.start()
若想用传参格式如下:
Thread(args=实参1,实参2,...)
Thread(kwargs={键值对1,键值对2,...}

除了单线程和多线程还有自定义线程,我们线自定义一个类没然后通过这个类形成自定义线程:
#自定义线程
import threading
#自定义类
class MyThread(threading.Thread):
    def work1(self):
        print('工作1')
    def work2(self):
        print('工作2')
    def run(self):
        self.work1()
        self.work2()
if __name__ == '__main__':
    #自定义子线程
    sub_thread = MyThread()
    sub_thread.start()
线程是可以共享全局变量的,多线程同时对全局变量进行操作
需求:需要将数据全部写入后再读取。代码如下:
#共享全局变量
import threading

my_list = []
#添加数据
def write_data():
    for i in range(5):
        my_list.append(i)
        print('写数据',my_list)
#读取数据
def read_data():
    print('读数据',my_list)

if __name__ == '__main__':
    #创建子线程
    write_thread = threading.Thread(target=write_data)
    read_thread = threading.Thread(target=read_data)
    #启动
    write_thread.start()
    read_thread.start()
线程同步也是必不可少的,但是为什么我们要学线程同步呢,有以下几个原因:
1、多线程执行多个任务,而多个任务会同时访问同一个全局变量,会出现资源竞争问题
2、同一时间,只有一个线程访问这个全局变量
3、保证了数据的安全
线程同步指的是等当前这个子线程执行结束以后,后面的子线程才会执行。格式为:线程名称.join()
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-23 23:42:59 | 显示全部楼层
今天学的是python中线程的互斥锁和死锁
首先互斥锁的作用是对共享数据进行锁定,保证同一时刻只能有一个线程去操作
代码如下:
#互斥锁
import threading
#创建锁
lock = threading.Lock()
num = 0
def work1():
    #上锁
    lock.acquire()
    global num
    for i in range(5):
        num +=1
    print(num)
    lock.release()
def work2():
    global num
    for i in range(10):
        num +=1
    print(num)
if __name__ == '__main__':
    #创建子线程
     work1_thread = threading.Thread(target=work1)
     work2_thread = threading.Thread(target=work2)
#启动
     work1_thread.start()
     work2_thread.start()
死锁(造成死锁的原因是上完锁没有解锁)与互斥锁不同,死锁一旦发生就会造成应用的停止响应,因此我们需要解决这个问题
代码如下:
#死锁
import threading
#创建锁对象
lock = threading.Lock()
#获取数据
def get_value(index):
    my_list = list('abcde')
    #上锁
    lock.acquire()
    if index >= len(my_list):
        lock.release()
        return
    #获取数据
    value = my_list[index]
    print(value)
    lock.release()


if __name__ == '__main__':


#创建十个子线程来获取数据
    for i in range(7):
        sub_thread = threading.Thread(target=get_value,args=(i,))
        sub_thread.start()
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-24 22:49:39 | 显示全部楼层
今天学习了进程,与学习线程的方法相似,先了解它的定义,可以通俗理解一个运行的程序或者软件进程是操作系统分配资源的基本单位。现实生活中的公司可以理解成一个进程,公司提供办公资源,真正干活的是员工,员工可以理解成线程。它与线程有些相似:
#多进程操作多任务
import multiprocessing

#任务1
def film(num):
    for i in range(num):
        print('看电影')
#任务2
def eat(num):
    for i in range(num):
        print('吃零食')
if __name__ == '__main__':
#创建两个子进程
film_process = multiprocessing.Process(target=film,args=(5,))
eat_process = multiprocessing.Process(target=eat,kwargs={'num':4})
#启动
film_process.start()
eat_process.start
但是他们之间还是有所不同的,进程之间不能共享全局变量。创建子进程其实是对主进程进行拷贝,进程之间互相独立,访问的全局变量不是同一个。
例子:#进程间不共享全局变量
import multiprocessing
#定义全局变量
my_list = []
#写数据
def write_data():
    for i in range(5):
        my_list.append(i)
        print('写数据',my_list)

#读数据
def read_data():
    print('读数据',my_list)
if __name__ == '__main__':
     write_process = multiprocessing.Process(target=write_data)
     read_process = multiprocessing.Process(target=read_data)
     write_process.start()
     #进程同步
     write_process.join()
     print('我已经写完数据课,你可一开始读了')
     read_process.start()
由上面得代码课已看出,由于全局变量不是一个,所以无法共享
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-25 23:45:57 | 显示全部楼层
今天学的是进程间的通信和进程池
进程间的通信主要是为了实现同一个软件不同的进程之间的数据共享
代码如下:
#进程间的通信

import multiprocessing

if __name__ == '__main__':
    #创建消息队列对象
    #Queue(n)代表保存信息的数量(容量)
    #Queue()代表保存信息的数量无上限
    queue = multiprocessing.Queue()


    #添加消息
    #格式:消息对象名.put()或者对象名.put_nowait()
    #向队列中添加数据,如果有容量,就会直接添加,如果没有,则会等待,进入阻塞状态
    queue.put(9)
    queue.put(1.25)
    queue.put('i love you ')
    #获取消息
    #格式 对象名.get()
    print(queue.get())
    print(queue.get())
    print(queue.get())
进程池,池子里放的是进程,进程池会根据任务执行情况自动创建进程,而且尽量少创建进程,合理利用进程池中的进程完成任务
进程池同步与异步执行任务与生活中的同步与异步正好相反
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-27 00:04:30 | 显示全部楼层
今天看了一下网络协议。
首先了解了浏览器访问服务器的过程,根据我查的资料,可归纳为一下几点:
1、用户输入网址
2、浏览器请求DNS服务器,获取域名对应的IP地址
如:114.114.114.114(国内:联通、移动、电信)
8.8.8.8(国外,谷歌公司)
3、请求连接该IP地址服务器
4、发送资源请求(HTTP协议)
5、Web服务器接收到请求,并且解析请求,判断用户意图
6、获取用户想要的资源
7、将资源返回给web服务器程序
8、Web服务器将该资源数据通过网络发送给浏览器
9、浏览器解析请求的数据并且完成网页数据的显示
URL有三大组成部分:协议部分、域名部分、资源路径部分(URL通俗地理解就是请求资源在网络中的地址)
例如:httPs://www.baidu.com/index.html
https://  是协议头
www.baidu.com 是域名
/Index.html 是资源路径

HTTP协议就是超文本传输协议,通俗理解就是浏览器和web服务器传输数据格式的协议,它基于TCP协议,发送数据之前需要建立好数据连接。

HTTP的工作模式是一次请求模式和一次响应模式
以下是浏览器控制台如何使用:


首先,我们通过开发者工具查看一下请求报文的格式,下面以www.baidu.com 中的报文格式为例进行分析
```python
-----请求行------
GET / HTTP/1.1
# 请求方式 get post
# / 请求资源路径(/ 等价于 /index.html)
# http 协议的版本

-----请求头------
Host: www.baidu.com :端口  
主机的域名或者ip地址(如果不写默认80端口(http协议),443(https协议))

Connection: keep-alive
连接方式:长连接,close代表短链接

Cache-Control: max-age=0
本地浏览器没有缓存策略

Upgrade-Insecure-Requests: 1
以后浏览器升级为https,也是兼容的

User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
告诉服务器安装当前浏览器的电脑信息

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
# 浏览器告诉服务器,支持接受什么数据类型

Accept-Encoding: gzip, deflate, br

告知服务器,支持解压缩的类型

Accept-Language: zh-CN,zh;q=0.9
告知服务器,支持的语言类型
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-27 21:52:24 | 显示全部楼层
之前粗略的看了Python中的面向对象编程内容,今天又详细地学了一下,其中以创建类、实例化类、类属性、特殊方法内建属性、静态变量属性、实例变量属性、方法属性、静态方法、类方法等内容为主。
创建类
Python 类使用 class 关键字来创建。简单的类的声明可以是关键字后紧跟类名:
class ClassName(bases):
    'class documentation string' #'类文档字符串'
    class_suite #类体
实例化
通过类名后跟一对圆括号实例化一个类
mc = MyClass() # instantiate class 初始化类
‘int()'构造器
def __int__(self):
    pass
类属性
特殊数据内建属性
C.name 类C的名字(字符串)
C.doc 类C的文档字符串
C.bases 类C的所有父类构成的元组
C.dict 类C的属性
C.module 类C定义所在的模块(1.5 版本新增)
C.class 实例C对应的类(仅新式类中)
特殊方法内建属性
dir():获得类属性或者实例属性名字列表.在这里插入代码片
静态变量属性
直接在class作用域定义
class C(object):
    foo = 100
实例变量属性
python实例属性是动态创建。设置实例的属性可以在实例创建后任意时间进行,也可以在能够访问实例的代码中进行。构造
器init()是设置这些属性的关键点之一。
def __init__(self, name, data):
        self.name = name
        self.data = "123'
注意:self指向自身实例的引用
方法属性
分为实例方法和类方法.实例方法只属于一个实例;而类方法即属于类所有,也属于实例所有.
实例方法
class MyClass(object):
    def myNoActionMethod(self):
    pass
静态方法
静态方法是类级别的方法,不需要实例化类就可以直接调用.有两种方法定义
●装饰器(常用)
@staticmethod  
    def foo():
        print 'call static method'
内建函数
def foo():
        print 'call static method'
    foo = staticmethod(foo) #静态方法
类方法
静态方法是类级别的方法, 与静态方法不同的是,它必须显示传入cls类参数;而且如果还需要调用类中其他的静态方法,或者类方法的函数, 要定义成类方法. 与静态方法类似,也有两种方法定义.
●装饰器(常用)
@classmethod   
    def bar(cls):
        print 'call class method and access static varible(staticVar): ', cls.staticVar
●内建函数
def bar(cls):
        print 'call class method and access static varible(staticVar): ', cls.staticVar
    bar = classmethod(bar)  #类方法
以一下实例介绍:
#!/usr/bin/python
#coding=utf-8
class Target(): #定义类Target
    'This is Target definition' #定义__doc__属性

    staticVar = 'v1.0'  #定义静态变量

    def __init__(self, name = 'default', data = 0): #定义构造函数
        self.name = name    #实例变量
        self.data = data    #实例变量
        print "init instance"

    def main():
        print "this is a test function"

    '''
    可以用装饰器定义静态方法
    @staticmethod  
    def foo():
        print 'call static method'
    '''
    def foo():
        print 'call static method'
    foo = staticmethod(foo) #静态方法

    '''
    可以用装饰器定义类方法
    @classmethod   
    def bar(cls):
        print 'call class method and access static varible(staticVar): ', cls.staticVar
    '''
    def bar(cls):
        print 'call class method and access static varible(staticVar): ', cls.staticVar
    bar = classmethod(bar)  #类方法

    #只有调用本模块的时候main()方法才生效
    if __name__ == '__main__':
        main()

#实例化
target = Target('aaa', 123)
print 'name is: ', target.name
print 'data is: ', target.data

#打印__doc__属性
print 'target.__doc__ is: ', target.__doc__

#打印类__dict__属性
print 'Target.__dict__ is: ', Target.__dict__

#打印静态变量
print 'staticVar is: ', Target.staticVar

#打印内建函数dir()
print 'dir() is: ', dir(Target)

#调用静态方法
Target.foo()

#调用类方法
Target.bar()
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
输出结果:
his is a test function
init instance
name is:  aaa
data is:  123
target.__doc__ is:  This is Target definition
Target.__dict__ is:  {'__module__': '__main__', 'foo': <staticmethod object at 0x7f3fd9310cc8>, 'bar': <classmethod object at 0x7f3fd9310d38>, 'staticVar': 'v1.0', 'main': <function main at 0x7f3fd930e758>, '__doc__': 'This is Target definition', '__init__': <function __init__ at 0x7f3fd930e6e0>}
staticVar is:  v1.0
dir() is:  ['__doc__', '__init__', '__module__', 'bar', 'foo', 'main', 'staticVar']
call static method
call class method and access static varible(staticVar):  v1.0
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-2-29 00:04:30 | 显示全部楼层
今天主要写一下element节点地操作
Element(元素)节点-属性
1、element.attributes
该属性返回一个类似数组地对象,其中包含了当前元素节点的所有属性节点对象,是元素节点的特有属性
var mdiv= document.getElementById("mdiv");
var attributes = mdiv.attributes;
attributes[0].nodeValue; //访问第一个属性值
2、盒子模型相关属性
(1)、Element.clientHeight(返回属性内部可见高度)和Element.clientWidth(返回属性内部可见宽度)
(2)对于有滚动条的元素来说,他们等于滚动条围起来的区域大小。这两个属性的值包括Padding、但不包括滚动条、边框和margin
(3)计算公式
clientHeight (或clientWidth)= height(width)+Padding-滚动条(如果存在)


黄色和白色区域就是可视区域
对于整张网页来说,当前可见高度/宽度要从document.documentElement对象上获取
Var rootElement = document.documentElement;
Console.log(rootElement.clientHeight);
注意:日过元素显示设为display:inline,它的clientLeft属性一律为零,不管书否存在左边框
Element.scrollHeight(返回内部总高度),Element.scrollWidth(返回内部总宽度)

回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-3-1 00:15:25 | 显示全部楼层
今天主要介绍一下文本节点        Text节点
Text节点表示HTML或XML文档中的一系列纯文本。而纯文本出现在HTML和XML的元素属性中,所以text节点通常作为element节点和atter节点的子节点出现,而且文本节点是没有子节点的。
Text 节点的获取方式
1、使用元素节点的firstchild来获取
2、使用document.createTextNode(‘文本内容’)
   创建好之后要添加到容器中
3、使用构造函数直接创建,空格也会被当作文本节点

Text节点的属性
1、Data
这个属性和nodeValue属性返回值一样。用于改变和读取文本内容。

2、Length
这个属性返回文本节点的文本长度,空格也算一个字符。
3、nextElementSibling和previousElementSibling
这两个方法获取文本节点隔壁的节点对象。

Text节点的方法

除此之外,我们还能通过JavaScript来操作css
Style属性会返回的对象中包含的属性和css中的属性一一对应,但是名字会发生变化,变化规则是css属性的短横线去掉,并且将横线后的第一哥字母大写。如果css属性是js关键字,那么需要加上css。例如:float会改成cssFloat(属性值都是字符串)
回复

使用道具 举报

7

主题

102

帖子

404

积分

中级会员

Rank: 3Rank: 3

积分
404
 楼主| 发表于 2020-3-1 23:53:43 | 显示全部楼层
今天主要是对Python中的匿名函数和map()函数、reduce()函数、filter()函数这四三大封装函数(遍历处理),以及它们的使用案例。  最后那些是函数用法功能的比较。
匿名函数
匿名函数,它们的作用是用来提供一个简短的函数。
print(lambda x:x+1)  #打印匿名函数的内存地址
func1 = lambda x:x+1  #调用匿名函数第1步
func2 = lambda x,y:x*y  #两个参数的匿名函数
print(func1(10))        #调用匿名函数第2步
print(func2(4,130))   #需要传入两个参数以符合x,y
name = '鸣人'
func3 = lambda x:x + '——羊村村长'
print(func3(name))
12345678
运行结果:
<function  at 0x02C07B70>
鸣人——羊村村长
map()函数

函数嵌套——把函数当做一个参数传给另外一个函数

def foo(n):
        print(n)
def bar(name):
        print("my name is %s"%name)  #使用了百分号类的字符串拼接
foo(bar('小沈阳'))
#会先传入“小沈阳”执行bar(),并输出,
#再将bar()的返回值,即None传入foo()中,并输出形参
运行结果:
my name is 小沈阳
None

低级函数封装

num_1 = [1,2,3,4,5]
def map_test(array):
        ret = []
        for i in array:  #把列表中的所有元素都乘2
                ret.append(i*2)
        return ret  #可以返回一个列表
ret = map_test(num_1)  #执行封装函数
print(ret)
12345678
运行结果:
[2, 4, 6, 8, 10]

高级封装函数——最接近map()函数的本质

num_1 = [1,2,3,4,5]
def cut_one(x):  #定义一个做减1运算的函数
        return x-1
def add_one(x):   #定义一个做加1运算的函数
        return x+1
def map_test(func,array):  #定义一个做全部遍历的函数,并执行相关操作的函数
        ret=[]
        for i in array:
                res=func(i)   #add_one
                ret.append(res)
        return ret
print(map_test(add_one,num_1))   #加1
print(map_test(cut_one,num_1))   #减1
12345678910111213
运行结果:
[2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]

map()函数+匿名函数——终极用法
传入一个函数和一个列表到封装函数中,好处是可以根据需求传入各种定义的函数,将列表中所有的元素做处理

#第一个参数是一个函数,第二个参数是一个可迭代对象(可循环的)
num_1 = [1,2,3,4,5]
res = map(lambda x:x+1,num_1)  #每个数都加1
print(list(res))  #打印的时候必须输出列表
msg='yourself'
print(list(map(lambda x:x.upper(),msg)))  #将所有字符都变大写
#map()函数返回的是内存地址,需要list列表化或者tuple元组化才可以打印出对应的值
1234567
运行结果:
[2, 3, 4, 5, 6]
[‘Y’, ‘O’, ‘U’, ‘R’, ‘S’, ‘E’, ‘L’, ‘F’]
很明显,map()函数是做批量处理用的
reduce()函数

初级reduce()——简单的单函数

num = [1,2,3,4,5,6,100]
def reduce_test(array):
    res = 0
    for n in array:  #将num中的元素都累加起来
        res += n
    return res
print(reduce_test(num))
运行结果:121

进阶reduce()——函数嵌套

num = [1,2,3,4,5,100]
def reduce_test(func,array,init=None):  #某参数=None则为非必须参数
    if init == None:
        res = array.pop(0)
        #用户没有输入值,则将第一个值赋值给res,并且删除第一个值,实现每乘完一个就取出一个
    else:
        res = init  #用户输入了一个值
    for n in array:  #将num中的元素都累乘起来
        res = func(res,n)  #传入的两个参数是需要相乘的两个数,每次都传入了func相乘后都更新res的值
    return res
print(reduce_test(lambda x,y:x*y, num, 2))
#该匿名函数接收两个参数对x,y两个参数做相乘处理
123456789101112
运行结果:
24000

reduce()函数——终极reduce
注意:该函数使用前需要从functools库中导入。即:
from functools import reduce

from functools import reduce
num = [1,2,3,4,5,100]
print(reduce(lambda x,y:x*y, num, 2))
#reduce函数必须导入functools模块,且第三个参数是非必须参数,为初始值
运行结果:
24000
很明显,reduce()函数做整合用的。
filter()函数
这个函数在2020年2月28日的一篇文章里已经专门介绍了,这里就不做详细分析,只拿出最后的用法。
people_onepiece=[
    {'name':'路飞','age':19},  #列表中有5个字典,每个字典都有2个键值对
    {'name':'娜美','age':20},
    {'name':'山治','age':22},
    {'name':'乔巴','age':12},
    {'name':'乌索普','age':21}
    ]
print(list(filter(lambda n:n['age']<=20,people_onepiece)))
#传入的参数是一个判断年龄的匿名函数,一个列表
#如果年龄小于20岁,则将该字典保留下来
运行结果:
[{‘name’: ‘路飞’, ‘age’: 19}, {‘name’: ‘娜美’, ‘age’: 20}, {‘name’: ‘乔巴’, ‘age’: 12}]
很明显,filter()函数是做筛选用的
map()函数,filter()函数,reduce()三大批量处理函数总结:
map函数是将一个列表中所有的元素都处理了一遍(最终返回的还是一个完整列表,位置和顺序都不变)
filter函数是将一个列表中所有的元素筛选了一遍,判断每个元素得到的布尔值(最终返回的是被筛选过的元素组成的一个列表)
reduce函数是把一个完整的列表都整合出另一个数据,或累加结果,或累乘结果(最终返回的是一个元素)

map函数
每个元素都会变

filter函数
保留符合条件的元素

reduce函数
整合出新元素
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|安全矩阵

GMT+8, 2020-5-26 18:45 , Processed in 0.014582 second(s), 19 queries .

Powered by Discuz! X4.0

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表