很不错——篇

宝藏文档：https://www.cnblogs.com/xiaobaibailongma

1、编程篇

一、排序

ls=[3,2,5,1]
# 方法一：
def bubble(ls):
    for i in range(0,len(ls)):
        for j in range(i+1,len(ls)):
            if ls[i]>ls[j]:
                ls[i],ls[j]=ls[j],ls[i]
    return ls
# print(bubble(ls))
# 方法二：
print(sorted(ls,reverse=True))

 二、求最大值、最小值

ls=[3,2,5,1,5]
# 方法一
# print(max(ls))
# 方法二
max_val=0
for i in ls:
    if i>max_val:
        max_val=i
print(max_val)

 三、去重

ls=[3,2,3,5,1,5,5]
# 方法一：
# print(set(ls))
# 方法二：
ls2=[]
for i in ls:
    if i not in ls2:
        ls2.append(i)
print(ls2)

 四、统计出现的次数

ls=[3,2,3,5,1,5,5]
# 方法一：
d={}
for i in ls:
    d[i]=ls.count(i)
print(d)
方法二：
ls2=list(set(ls))
for i in ls2:
ls.count(i)

 五、倒序

str="tom"
str2=''
c = list(str)
# 方法一
 5.  print(d[::-1])

# 方法二  7 for i in range(len(c)):  8 str2+=c.pop()  9 # 方法三 10 leng=len(str) 11 leng2=len(str)-1 12 for i in range(leng): 13 str2+=c[leng2-i]

 

 六、递归

p = r"D:\测试用例"

import os
def getFile(path):
    p = os.listdir(path)
    for i in p:
        f = os.path.join(path,i)
        if os.path.isdir(f):
            getFile(f)
        else:
            print(f)
getFile(p)

七、装饰器

带参数的装饰器

def outer2(val):
    def outer(fun):
        def inner(*args,**kwargs):
            if val==1:
                print("decoration1..")
            if val==2:
                print("decoration2..")
            fun(*args,**kwargs)
        return inner
    return outer

@outer2(2)
def one():
    print('ok...')
one()

 八、字典排序

d = {"1":"tom","3":"Lily","2":"Jim"}
# 方法一：
c = sorted(d.items(),key=lambda x:x[0])
# print(c)
# 方法二：
keys = [i for i in d.keys()]
skeys = sorted(keys)
vals=[]
for i in skeys:
  for k,v in d.items():
    if i==k:
      vals.append(v)
# cc = map(lambda x,y:{x:y},skeys,vals)

d={}
for i in range(len(ls)):
    d[ls[i]]=ls2[i]
print(d)

 _{九、最长的公共前缀}

ls=["floght","floor","floy","flower"]
min_lenght = len(ls[0]) 
for i in ls:
  if min_lenght>len(i):
    min_lenght=len(i)
ls2=[]
str2=''
for i in range(min_lenght):
  for u in ls:
    ls2.append(u[i])
    if ls2.count(u[i])==min_lenght:
      str2+=u[i]
  ls2=[]
print(str2)

 

 十、递归求和

def get_sum(num):
  if num<=1:
    return 1
  return num+get_sum(num-1)
print(get_sum(100))

十、递归树 

menu_items = [
    {'id': 1, 'name': '一级菜单', 'status': 1, 'parent_id': 0},
    {'id': 2, 'name': '二级菜单', 'status': 1, 'parent_id': 1},
    {'id': 3, 'name': '三级菜单', 'status': 1, 'parent_id': 2},
    # 其他菜单项...
]

def build_menu(menu_items, parent_id=0):
    menu = []
    for item in menu_items:
        if item['parent_id'] == parent_id:
            child_menu = build_menu(menu_items, item['id'])
            cc = child_menu
            menu.append({
                'name': item['name'],
                'child': child_menu
            })
    return menu
print(build_menu(menu_items))

 

十一、找出连续的值

ls=[1,2,3,5,6,8]
ls2=[]
ls3=[]
for i in ls:
  ls2.append(i)
  if i+1 not in ls:
    if ls2[0]==ls2[-1]:
      ls3.append(ls2[0])
    else:
      ls3.append([ls2[0],ls2[-1]])
    ls2=[]
print(ls3)

 

 十二、LRU 算法

https://www.jb51.net/article/249285.htm?tdsourcetag=s_pcqq_aiomsg
https://www.jianshu.com/p/e41ec08e4aa6

from collections import OrderedDict
class LRUCache:
    def __init__(self,size):
        self.size = size
        self.dic = OrderedDict()
    def set(self,key,val):
        if key in self.dic:
            self.dic.pop(key)
        if self.size == len(self.dic):
            self.dic.popitem(last=False)
        self.dic.update({key:val})
    def get(self,key):
        val = self.dic.get(key)
        self.dic.pop(key)
        self.dic.update({key: val})
        return val

r = LRUCache(3)
r.set("1", "1")
r.set("2", "2")
r.set("1", "3")
# r.set("1", "4")
# r.set("1", "5")
print(r.dic)
r.get("1")
print(r.dic)
# r.set("4", "4")
# print(r.dic)

 from collections import OrderedDict

class LRUCache:
    def __init__(self,size):
        self.size = size
        self.dic = OrderedDict()
    def set(self,key,val):
        if key in self.dic:
            self.dic.pop(key)
        if self.size == len(self.dic):
            self.dic.popitem(last=False)
        self.dic.update({key:val})
    def get(self,key):
        val = self.dic.get(key)
        self.dic.pop(key)
        self.dic.update({key: val})
        return val

r = LRUCache(3)
r.set("1", "1")
r.set("2", "2")
r.set("1", "3")
# r.set("1", "4")
# r.set("1", "5")
print(r.dic)
r.get("1")
print(r.dic)
# r.set("4", "4")
# print(r.dic)

2、linux

1、展示所有upd\tcp

lsof -i

2、占用端口80

lsof -i:80

3、查看进程所占的端口号

lsof -i -P | grep influxd

4、一行命令杀死占用端口80 的

lsof -i:80|awk '{print $2}'|xargs kill

5、一行命令杀死进程名称为python的

ps aux | grep python | awk '{print $2}' | xargs kill

6、查看100行到200行的日志

head -n 200 filname | tail -n 100

7、查看5行到6行的日志

head -n 6 filname | tail -n 1

8、查看后100行的含有关键字的日志

head -n 100 filname | grep "关键字"

9、查看一级目录文件大小，取前三

du -h --max-depth=1 | sort -hr | head -n 3 展示隐藏的文件

du -sh * 不展示隐藏文件

du -sh * | sort -hr | head -n 3

-s：不展示子文件大小，只展示一级目录大小

-h：文件大小展示的可读性

 

9、压测，服务器的内存使用情况

free -h 

 10、压缩

解压：tar -xvf file 

压缩：tar -cvf xx.tar file

11、grep 

grep -n ‘关键字’ file 显示行号

grep -r '关键字' files 递归文件夹搜索关键字

grep -i '关键字' file 忽略大小写

grep -v '关键字' 反向查

12、内存方面

查看系统整体CPU占用情况（查看系统整体负载情况）
w
 15:33:44 up 10 days,  7:24, 18 users,  load average: 4.72, 3.16, 2.77
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts/0    192.168.66.44    09:38    7:04  42:42m  0.00s tmux a -t wql3

load average：平均负载值，依次是1分钟cpu活动数、5分钟cpu活动数、15分钟cpu活动数
w这个命令与uptime 相似
vmstat
procs -----------memory----------         ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache          si   so    bi    bo   in   cs us sy id wa st
 0  0      0 522159360 2063216 15877368    0    0     0     10    0    0  2  1 97  0  0

io中的bi，读磁盘所占的CPU；bo，写磁盘所占的CPU
cpu中的wa，是I/O等待占用的内存

动态监控资源占用情况
top
Tasks: 2667 total,   8 running, 1796 sleeping,   0 stopped,  16 zombie(僵尸)
%Cpu(s):  4.1 us,  0.2 sy,  0.0 ni, 95.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 79118905+total, 51437747+free, 25886304+used, 17948536 buff/cache
KiB Swap: 23449596 total, 23449596 free,        0 used. 52883257+avail Mem

   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
175832 kfin-st+  20   0 1488616 420452  26228 S  68.6  0.1   5:56.89 celery

S：进程状态，S:interruptible sleep R:running D:uninterruptible sleep T:stoped Z:zombie

查询内存使用情况
free -g -t -s 5 (g是以G单位展示，t是汇总，s是秒，每5秒刷新一次)
             total        used        free      shared  buff/cache   available
Mem:            754         254         482           0          17         496
Swap:            22           0          22
Total:          776         254         505

iostat

(base) moli@Finance:~$ iostat

Linux 5.4.0-150-generic (Finance) 2024年12月24日 _x86_64_ (192 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle

           2.51    0.00    0.99    0.00    0.00   96.50

Device             tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn

nvme0n1          16.59         3.63       280.25    4430710  342366388

sda              19.35        10.62       354.00   12971892  432464552

sdc              22.96        10.90       453.38   13320432  553870636

sdd              25.24        10.46       504.84   12777256  616738072

sdb              21.55        11.99       419.92   14648648  512998684

 查看cpu 核数：lscpu\cpuinfo

 磁盘方面

du ：检查磁盘空间使用量

df：列出文件系统的整体磁盘使用量

 

3、sql

1、delete、truncate、drop 区别

delete 删除表内容，可以回滚

truncate 删除表内容，不可以回滚

drop 删除表结构 不可以回滚

 

2、mysql 的书写顺序

select * from tableA inner join tableB on tableA.id=tableB.id where id=12 group by name having id>2 order by id desc limit 2

 

3、mysql 的执行顺序

from on join where group by having select distict order by limit

 

4、测试用例

等价类、边界值、判定表

判定表的案例

 测试case 设计万能公式

1、功能，状态迁移

2、界面UI

3、性能，分库分表

4、易用性

5、兼容性

6、弱网络

7、中断

8、安装卸载，版本号测试

接口测试（思路：功能、性能、安全、兼容、弱网）
功能：入参，出参：入参数据的合法性，包括，数据的类型，int,string；选填必填；文件数据的长度、大小、类型；分页；排序；入数据校验、出参的正确性校验
性能：响应时间、并发
安全：html、js、敏感信息加密、鉴权
异常：中断、弱网、数据库故障、幂等
兼容：新老数据兼容
其他：单接口、串联接口

优惠券
功能：满减、打折；扣减为0为负；使用前后结果校验；小数点；过期；叠加使用；使用顺序
性能：弱网、幂等

输入框
功能：点击输入框下拉加载默认数据，按时间倒序；搜索历史数据；模糊（前、中、后）、精确搜索；输入内容的最小最大字符限制；分页；排序；无效搜索：特殊字符；为空搜索
性能：响应时间
安全：js注入%%、鉴权
兼容：浏览器、分辨率的兼容
异常：中断、弱网、鉴权、数据库故障

5、性能指标

吞吐量：单位时间内处理的请求数量：衡量网络的

tps:每秒处理事物的能力：衡量服务器的

CPU利用率，小于80

响应时间

6、性能测试，服务器关注的点

1、cpu

top 实时查看cpu占用情况；

free -h -t 物理内存、交换内存使用情况

 

2、cpu负载

w、uptime 可以检测cpu每1分钟、5分钟、15分钟的平均负载

 

3、磁盘

df -h 磁盘空间使用情况

 

4、磁盘IO

• 磁盘读写速率、I/O 操作次数、磁盘利用率、平均队列长度、等待 I/O 的时间。

Iostat tps 每秒I/O 操作次数，每秒读多少kb，每秒写多少kb

iostat -dx 是IO分开的指标，每秒I操作次数，每秒O 操作次数；I的等待时间，O的等待时间；平均队列长度；磁盘利用率

 

大杂烩命令：vmstat

1、进程：r需要cpu运行的进程数；b被阻塞的进程数

2、内存：swpd 交换内存；free 物理内存；buff/cache 缓存

3、交换内存：si磁盘交换到内存的数量；so内存交换到磁盘的数量

4、io：读取与写入的数据块

5、system：in：每秒的中断数；cs：每秒的上下文切换次数

6、cpu：us：用户态 CPU 时间百分比；sy：系统态 CPU 时间百分比；id：空闲 CPU 时间百分比；wa：等待 I/O 的 CPU 时间百分比；st：被虚拟机偷走的 CPU 时间百分比

7、中间件

中间件

 

8、其他

1. CI/CD
   1. 我们公司的 CI/CD（持续集成/持续交付）流程基于 GitLab+TC来实现。
   2. CI 的流程，静态检查代码风格、安全漏洞
   3. CD的流程，测试环境测试，线上环境灰度发布，然后全量发布
2. charles 
   1. 断点：breakport，修改请求和响应的数据
   2. 弱网：throttle
   3. 重定向：map remote
3. unnit与pytest 的区别
   1. 都用于接口测试
   2. unnit 是python 自带的，pytest是python 的第三方包
   3. pytest 写法更加简洁，插件丰富，报告好看
4. selenium 的工作流程
   1. 类似于请求与响应的过程。
   2. 脚本相当于客户端
   3. 浏览器驱动相当于服务端
   4. 客户端向浏览器驱动发送HTTP请求
   5. 浏览器驱动让浏览器调用原生API 
   6. 浏览器反馈操作结果给浏览器驱动
   7. 浏览器驱动给客户端返回结果