1.keep函数
2.彻底揭秘keep-alive
3.keep-alive的函数vue2和vue3的源码以及LRU算法
4.pandas数据去重：drop_duplicates与duplicated函数
5.oracle中的 keep 和 over 的区别
6.python题：随机密码生成。编写程序，源码源代在26个字母大小写和9个数字组成的函数列表中随机生成10个8位密码

keep函数

       函数名:keep

       功能:退出并保持驻留状态

       用法:void keep(int status, int size);

       程序例:

       注意:这是一个中断服务程序。不能在启用 Test Stack Overflow时编译并获得正常运行的源码源代可执行文件。由于 keep 函数的函数特性，计算段落数的源码源代c#变速 源码公式可能在某些情况下不适用。谨慎使用！函数驻留式(TSR)程序复杂，源码源代对此类程序不提供其他支持。函数有关更多信息，源码源代请参阅 MS-DOS 技术文档。函数

       #include

       中断处理程序:

       extern unsigned _heaplen = ; extern unsigned _stklen = ;

       void interrupt ( *oldhandler)(void);

       void interrupt handler(void)

       {

       unsigned int (far *screen)[];

       static int count;

       // 对于彩色屏幕，源码源代视频内存位于 0xB:。函数对于单色系统，源码源代请使用 0xB:

       screen = MK_FP(0xB,函数0);

       // 增加计数器，保持在0-9范围内

       count++; count %= ;

       // 将数字显示在屏幕上

       screen[0][] = count + '0' + ATTR;

       // 调用原始中断处理程序

       oldhandler();

       }

       主函数:

       oldhandler = getvect(INTR);

       setvect(INTR, handler);

       // _psp是程序在内存中的起始地址，堆栈顶部是程序的结束位置。通过结合使用 _SS 和 _SP，可以获取堆栈的结束位置。

       keep(0, (_SS + (_SP/) - _psp));

       返回值:return 0;

扩展资料

       keep是一个常用英语单词，既可以做及物动词也可以做不及物动词。常用释义为保持，保留如 keep a seat 等等。另外keep还是程序里的一个常用函数。

彻底揭秘keep-alive

       深入剖析keep-alive的shareuid权限源码实现与应用，本文将详细讲解其背后的原理和使用场景。keep-alive组件在Vue中用于缓存不活动的组件实例，而非销毁它们，从而在动态路由切换时保存组件的状态，提升性能。

       keep-alive的应用场景广泛，比如当用户在列表页面进行筛选后进入详情页面，再切换回列表页面时，希望筛选条件或选中状态保持不变。通过包裹列表组件于keep-alive内，可以避免组件重复渲染，优化用户体验和系统效率。

       使用keep-alive的关键是理解其几个核心属性和功能，包括`include`、`exclude`及`max`。`include`指定了需要缓存的组件白名单，`exclude`则定义了不应缓存的黑名单，而`max`则设定了缓存组件的上限，超过此限制时，系统将使用LRU策略替换旧缓存。

       深入源码，keep-alive组件内嵌于Vue生态体系中，它对外暴露了组件的基本生命周期钩子以及几个主要配置属性。抽象属性设置为`true`对于组件缓存机制至关重要，js源码调试其对组件的处理方式不同于其他普通组件。

       keep-alive的渲染机制与其他Vue组件存在差异。在初始化阶段，Vue实例与子组件建立父子关系时会考虑抽象属性的值。当组件设置为`abstract: true`时，即跳过了该组件实例的渲染过程，从而避免了实际DOM节点的生成。这一特性显著优化了缓存组件的性能表现。

       当组件从缓存中被激活或进入活跃状态时，patch阶段执行了一系列操作，如`createComponent`函数实现了缓存组件的重新挂载过程。通过`keep-alive`属性的管理，组件在切换和返回时能够保持状态的一致性，而组件的重用机制使得在不同的渲染上下文中实现高效状态转换成为可能。

       了解keep-alive的钩子函数机制对于其高效应用至关重要。`activated`与`deactivated`钩子分别对应组件状态变化的两种极端情况，其执行策略避免了不必要的渲染过程，进一步提高了应用性能和响应速度。

       综上所述，掌握keep-alive的原理与应用能够显著优化Vue应用的性能与用户体验。通过对组件状态的缓存和智能管理，减少不必要的DOM操作，从而实现高效响应和流畅界面。

keep-alive的门窗配色源码vue2和vue3的源码以及LRU算法

       0.LRU算法

       LRU（leastrecentlyused）根据数据的历史记录来淘汰数据，重点在于保护最近被访问/使用过的数据，淘汰现阶段最久未被访问的数据

       LRU的主体思想在于：如果数据最近被访问过,那么将来被访问的几率也更高

       经典的LRU实现一般采用双向链表+Hash表。借助Hash表来通过key快速映射到对应的链表节点，然后进行插入和删除操作。这样既解决了hash表无固定顺序的缺点，又解决了链表查找慢的缺点。

       但实际上在js中无需这样实现，可以参考文章第三部分。先看vue的keep-alive实现。

1.keep-alive

       keep-alive是vue中的内置组件，使用KeepAlive后，被包裹的组件在经过第一次渲染后的vnode会被缓存起来，然后再下一次再次渲染该组件的时候，直接从缓存中拿到对应的vnode进行渲染，并不需要再走一次组件初始化，render和patch等一系列流程，减少了script的执行时间，性能更好。

       使用原则：当我们在某些场景下不需要让页面重新加载时我们可以使用keepalive

       当我们从首页–>列表页–>商详页–>再返回，这时候列表页应该是需要keep-alive

       从首页–>列表页–>商详页–>返回到列表页(需要缓存)–>返回到首页(需要缓存)–>再次进入列表页(不需要缓存)，这时候可以按需来控制页面的keep-alive

       在路由中设置keepAlive属性判断是否需要缓存。

2.vue2的实现

       实现原理：通过keep-alive组件插槽，获取第一个子节点。根据include、指数宝源码exclude判断是否需要缓存，通过组件的key，判断是否命中缓存。利用LRU算法，更新缓存以及对应的keys数组。根据max控制缓存的最大组件数量。

       先看vue2的实现：

exportdefault{ name:'keep-alive',abstract:true,props:{ include:patternTypes,exclude:patternTypes,max:[String,Number]},created(){ this.cache=Object.create(null)this.keys=[]},destroyed(){ for(constkeyinthis.cache){ pruneCacheEntry(this.cache,key,this.keys)}},mounted(){ this.$watch('include',val=>{ pruneCache(this,name=>matches(val,name))})this.$watch('exclude',val=>{ pruneCache(this,name=>!matches(val,name))})},render(){ constslot=this.$slots.defaultconstvnode:VNode=getFirstComponentChild(slot)constcomponentOptions:?VNodeComponentOptions=vnode&&vnode.componentOptionsif(componentOptions){ //checkpatternconstname:?string=getComponentName(componentOptions)const{ include,exclude}=thisif(//notincluded(include&&(!name||!matches(include,name)))||//excluded(exclude&&name&&matches(exclude,name))){ returnvnode}const{ cache,keys}=thisconstkey:?string=vnode.key==null?componentOptions.Ctor.cid+(componentOptions.tag?`::${ componentOptions.tag}`:''):vnode.keyif(cache[key]){ vnode.componentInstance=cache[key].componentInstance//makecurrentkeyfreshestremove(keys,key)keys.push(key)}else{ cache[key]=vnodekeys.push(key)//pruneoldestentryif(this.max&&keys.length>parseInt(this.max)){ pruneCacheEntry(cache,keys[0],keys,this._vnode)}}vnode.data.keepAlive=true}returnvnode||(slot&&slot[0])}}

       可以看到<keep-alive>组件的实现也是一个对象，注意它有一个属性abstract为true，是一个抽象组件，它在组件实例建立父子关系的时候会被忽略，发生在initLifecycle的过程中：

//忽略抽象组件letparent=options.parentif(parent&&!options.abstract){ while(parent.$options.abstract&&parent.$parent){ parent=parent.$parent}parent.$children.push(vm)}vm.$parent=parent

       然后在?created?钩子里定义了?this.cache?和?this.keys，用来缓存已经创建过的?vnode。

       <keep-alive>直接实现了render函数，执行<keep-alive>组件渲染的时候，就会执行到这个render函数，接下来我们分析一下它的实现。

       首先通过插槽获取第一个子元素的vnode：

constslot=this.$slots.defaultconstvnode:VNode=getFirstComponentChild(slot)

       <keep-alive>只处理第一个子元素，所以一般和它搭配使用的有component动态组件或者是router-view。

       然后又判断了当前组件的名称和include、exclude（白名单、黑名单）的关系：

//checkpatternconstname:?string=getComponentName(componentOptions)const{ include,exclude}=thisif(//notincluded(include&&(!name||!matches(include,name)))||//excluded(exclude&&name&&matches(exclude,name))){ returnvnode}functionmatches(pattern:string|RegExp|Array<string>,name:string):boolean{ if(Array.isArray(pattern)){ returnpattern.indexOf(name)>-1}elseif(typeofpattern==='string'){ returnpattern.split(',').indexOf(name)>-1}elseif(isRegExp(pattern)){ returnpattern.test(name)}returnfalse}

       组件名如果不满足条件，那么就直接返回这个组件的vnode，否则的话走下一步缓存：

const{ cache,keys}=thisconstkey:?string=vnode.key==null?componentOptions.Ctor.cid+(componentOptions.tag?`::${ componentOptions.tag}`:''):vnode.keyif(cache[key]){ vnode.componentInstance=cache[key].componentInstance//makecurrentkeyfreshestremove(keys,key)keys.push(key)}else{ cache[key]=vnodekeys.push(key)//pruneoldestentryif(this.max&&keys.length>parseInt(this.max)){ pruneCacheEntry(cache,keys[0],keys,this._vnode)}}

       如果命中缓存，则直接从缓存中拿vnode的组件实例，并且重新调整了key的顺序放在了最后一个；否则把vnode设置进缓存，如果配置了max并且缓存的长度超过了this.max，还要从缓存中删除第一个。

       这里的实现有一个问题：判断是否超过最大容量应该放在put操作前。为什么呢？我们设置一个缓存队列，都已经满了你还塞进来？最好先删一个才能塞进来新的。

       继续看删除缓存的实现：

functionpruneCacheEntry(cache:VNodeCache,key:string,keys:Array<string>,current?:VNode){ constcached=cache[key]if(cached&&(!current||cached.tag!==current.tag)){ cached.componentInstance.$destroy()}cache[key]=nullremove(keys,key)}

       除了从缓存中删除外，还要判断如果要删除的缓存的组件tag不是当前渲染组件tag，则执行删除缓存的组件实例的$destroy方法。

       ————————————

       可以发现，vue实现LRU算法是通过Array+Object，数组用来记录缓存顺序，Object用来模仿Map的功能进行vnode的缓存（created钩子里定义的this.cache和this.keys）

2.vue3的实现

       vue3实现思路基本和vue2类似，这里不再赘述。主要看LRU算法的实现。

       vue3通过set+map实现LRU算法：

constcache:Cache=newMap()constkeys:Keys=newSet()

       并且在判断是否超过缓存容量时的实现比较巧妙：

if(max&&keys.size>parseInt(maxasstring,)){ pruneCacheEntry(keys.values().next().value)}

       这里巧妙的利用Set是可迭代对象的特点，通过keys.value()获得包含keys中所有key的可迭代对象，并通过next().value获得第一个元素，然后进行删除。

3.借助vue3的思路实现LRU算法

       Leetcode题目——LRU缓存

varLRUCache=function(capacity){ this.map=newMap();this.capacity=capacity;};LRUCache.prototype.get=function(key){ if(this.map.has(key)){ letvalue=this.map.get(key);//删除后，再set，相当于更新到map最后一位this.map.delete(key);this.map.set(key,value);returnvalue;}return-1;};LRUCache.prototype.put=function(key,value){ //如果已经存在，那就要更新，即先删了再进行后面的setif(this.map.has(key)){ this.map.delete(key);}else{ //如果map中不存在，要先判断是否超过最大容量if(this.map.size===this.capacity){ this.map.delete(this.map.keys().next().value);}}this.map.set(key,value);};

       这里我们直接通过Map来就可以直接实现了。

       而keep-alive的实现因为缓存的内容是vnode，直接操作Map中缓存的位置代价较大，而采用Set/Array来记录缓存的key来模拟缓存顺序。

       参考：

       LRU缓存-keep-alive实现原理

       带你手撸LRU算法

       Vue.js技术揭秘

原文;/post/

pandas数据去重：drop_duplicates与duplicated函数

       在Pandas中，处理数据去重是常见的任务。主要有两个方法，即drop_duplicates()和duplicated()函数，它们各自有不同的用途和参数设置。

       首先，drop_duplicates()函数主要用于直接从DataFrame中删除重复的行。这个函数接受一个可选参数，即subset，用于指定哪些列进行去重，如果未指定，则默认对所有列进行检查。另一个参数keep，可选值有'first'（保留第一个出现的重复值）、'last'（保留最后一个出现的重复值）或'False'（删除所有重复值）。例如：

       python

       df.drop_duplicates(subset='column_name', keep='first')

       另一方面，duplicated()函数则是一个返回布尔值系列的函数，它会告诉我们在给定的列或组合中哪些行是重复的。这个函数没有直接删除重复行的功能，但可以与DataFrame的loc或query方法结合使用，进行进一步的数据筛选或处理。例如：

       python

       duplicates = df.duplicated(subset='column_name')

       df[duplicates == False]

       通过理解并灵活运用这两个函数，我们可以有效地处理数据中的重复值问题，确保数据的准确性和一致性。在实际操作中，可以根据具体需求选择合适的去重策略。

       以上内容由文章同步助手整理。

oracle中的 keep 和 over 的区别

       keep就是个关键字，指明后面的括号里是按照指定规则排名的top 1或bottom1,因为是dense_rank排名，所以可能有重复的，外面用min/max那么只返回一个值，比如用sum可能汇总多个相同值。ver指定分区，如果没有over则是对所有行应用一次分析函数，因此结果就一行，有over并且指定了分区，那么分析函数的计算范围就在此分区内，对此分区每一行都使用分析函数，分区内的每一行的分析函数值是一样的，而且最终返回的行和总行数相同。或有over里面没有分区则是对每一行应用分析函数，计算范围是所有行，因此所有行返回的分析函数值都一样。

       å½“然还可以与group by结合，那就很复杂了，也很常见，反正这个函数就是求top1或bottom1的。

python题：随机密码生成。编写程序，在个字母大小写和9个数字组成的列表中随机生成个8位密码

       keep_words=['and','as','assert','break','class','continue',

       'def','del','elif','else','except','finally',

       'for','from','global','if','import','in','is',

       'lambda','nonlocal','not','or','pass','raise',

       'return','try','while','time','with','yield','True',

       'False','None']

       def upper_word(fname_tem,num,keep):

       file_tem=open('{ }.py'.format(format(fname_tem)),'r',encoding='utf-8')

       file_new=open('{ }_changed.py'.format(format(fname_tem)),'w',encoding='utf-8')

       #逐行读取，逐行处理，逐行写入

       for line in file_tem:

       for word in keep_words:

       if word in line:

       num=num+1

       keep['编号%s'%str(num)]=word

       line=line.replace(word,'编号%s'%str(num))

       else:

       continue

       line=line.upper()

       for key in keep.keys():

       if key in line:

       line=line.replace(key,keep[key])

       file_new.write(line)

       file_tem.close()

       file_new.close()

       def main():

       num=

       keep={ }

       fname_tem=input('请输入Python源代码文件名：')

       upper_word(fname_tem,num,keep)

       main()

扩展资料：

       定义和用法

       &lt;input&gt;标签用于搜集用户信息。

       根据不同的type属性值，输入字段拥有很多种形式。输入字段可以是文本字段、复选框、掩码后的文本控件、单选按钮、按钮等等。

       input()函数直接接受且不改变输入数据的类型，但是需要注意的是使用input()在输入字符串时需要添加引号，否则会报错。

       &lt;2&gt;.end=''标明在end后面传递一个空字符串，这样print函数不会在字符串末尾添加一个换行符，而是添加一个空字符串，也就是说，它的意思是末尾不换行，加空格。

       HTML与XHTML之间的差异

       在HTML中，&lt;input&gt;标签没有结束标签。

       在XHTML中，&lt;input&gt;标签必须被正确地关闭。

通过源码理解http层和tcp层的keep-alive

       理解HTTP层与TCP层的keep-alive机制是提升网络通信效率的关键。本文将通过源码解析，深入探讨如何在HTTP与TCP层实现keep-alive功能。

       1.

       HTTP层的keep-alive

       以nginx为例，解析HTTP报文时，若客户端发送了connection:keep-alive头，则nginx将维持此连接。配置中设定的过期时间与请求数限制，通过解析头信息与设置全局变量实现。

       在解析HTTP头后，通过查找配置中的对应处理函数，进一步处理长连接。当处理完一个HTTP请求时，NGINX将连接状态标记为长连接，并设置相应标志。当连接达到配置的时间或请求数限制时，NGINX将关闭连接，释放资源。

       2.

       TCP层的keep-alive

       TCP层提供的keep-alive功能更为全面，通过Linux内核配置进行调整。默认配置与阈值设定共同作用于keep-alive功能。

       通过setsockopt函数可动态设置TCP层的keep-alive参数，实现不同场景下的keep-alive策略。超时处理通过系统内核函数完成，确保在长时间无数据传输时，能够及时释放资源，避免占用系统连接。

       总结：HTTP层与TCP层的keep-alive机制通过不同方式实现长连接的维护与管理，有效提高了网络通信的效率与资源利用率。深入理解其源码实现，有助于在实际应用中更灵活地配置与优化网络连接策略。