面试题

# 1、执行Python脚本的两种方式:
pycharm解释器和Python直接执行
# 2、简述位和字节的关系？
8位是一个字节
# 3、简述ascii码、Unicode、utf-8、gbk出现的顺序和区别？
出现顺序是：1、ascii2、Unicode3、utf-84、gbk
区别：python2内容进行编码（默认ascii）,而python3对内容进行编码的默认为utf-8。

ascii:最多只能用8位来表示（一个字节），即：2**8 = 256（即pow(2,8)=256），所以，ASCII码最多只能表示256个符号。
unicode:万国码，任何一个字符==两个字节
utf-8:万国码的升级版,一个中文字符==三个字节,英文是一个字节,欧洲的是2个字节
gbk:国内版本,一个中文字符==2个字节,英文是一个字节
gbk转utf-8,则需通过媒介unicode

# 4、请写出"张达"分别用utf-8和gbk编码所占的位数？
utf：6，gbk：4
# 5、Python单行注释和多行注释？
单行用#，多行用""""""
# 6、声明变量的注意事项？
数字、字母、下划线、不能数字开头、不能用关键字
# 7、有变量nl = 5,使用int提供的方法得到该变量最少可以用多少个二进制位表示？
nl = 5
print(nl.bit_length())
# 8、布尔值分别是什么？
true和false
# 9、阅读代码请写出执行结果？
a = "zdxx"
b = a.capitalize()
print(b)
# 10、写代码，按要求实现每个功能
name = "zdxx"
# 移除name变量里面的空白
print(name.strip())
# 判断name变量对应的值是否以z开头？
print(name.startswith("z"))
# 判断name变量是否以d结尾？
print(name.endswith("d"))
# name变量中的d替换成s

print(a.replace("d","s"))

# name对应变量的值以d分割
print(name.split("d"))
# d分割之后得到的值是什么类型？
print(type(name.split("d")))
# name对应的变大写?
print(name.swapcase())
# name对应的变小写？
print(name.lower())
# 输出name的值得第二个字符？
print(name[2])
# 10、字符串是否可迭代对象？使用for循环每一个元素。可迭代对象 == 可以for循环
for i in name:
    print(i)
# 11、利用下划线将列表的每一个元素拼接或字符串
li = "zdxcvb"
print("_".join(li))
# 12、利用下划线将列表的每一个元素拼接或字符串
li = ["zs", "ls", "ww", "zl"]
print("_".join(li))
# 13、Python2中的range和Python3中的range的区别？
直接放到内存和通过循环创建
# 14、实现一个整数计算器
count = input("请输入内容：")
v1, v2 = count.split("+")
print(int(v1) + int(v2))
#17、敏感词过滤用replace
value = input("请输入内容：")
value1 = value.replace("BUG","很好")
print(value1)
#18、制作表格循环提示用户输入用户名、密码、邮箱
s = ""
while True:
    v1 = input("请输入用户名:")
    v2 = input("请输入密码:")
    v3 = input("请输入邮箱:")
    template = "{0}\t{1}\t{2}\n"
    v = template.format(v1,v2,v3)
    s = s + v
    if v1.upper() == "q":
        break
print(s.expandtabs(20))
19、使用for循环和range输出9*9乘法表

for i in range(0,10):
    for j in range(0,i + 1):
        s = i * j
        print("{} * {} = {}".format(i,j,s) ,end=" ")
    print(" ")
20、将[1,3,2,7,6,23,41,24,33,85,56]从小到大排序（冒泡法）

li = [1, 3, 2, 7, 6, 23, 41, 24, 33, 85, 56]
for i in range(len(li) - 1):  # i的范围0-9
    for j in range(i + 1, len(li)):  # j的范围1-10
        if li[i] > li[j]:  # 相邻的两个数比较
            li[i], li[j] = li[j], li[i]
print(li)

# 1、有两个列表
l1 = [11, 22, 33]
l2 = [22, 33, 44]
# 1.1获取相同内容的元素列表
for i in l1:
    if i in l2:
        print(i)
# 1.2获取l1中有l2中没有的元素列表
for i in l1:
    if i not in l2:
        print(i)
# 1.3获取l1和l2都不同的元素列表
for i in l1:
    if i not in l2:
        print(i)
# 1.4获取l2中有l1中没有的元素列表
for i in l2:
    if i not in l1:
        print(i)
# 2、有1,2,3,4,5,6,7,8个数字，能组成多少个互不重复的两位数？
count = 0
ls = [3, 5, 8, 9]
for i in range(0, len(ls)):
    for v in range(0, len(ls)):
        if i != v:
            count += 1
count = count - 8
print(count)
print("===================================================================end")
# 3、99乘法表
for i in range(1, 10):
    string = ""
    for j in range(1, i + 1):
        string += str(j) + " * " + str(i) + " = " + str(i * j) + "\t"
    print(string)
# 5、利用下划线将列表中的每个元素拼接成字符串
li = ["zd", "ls", "ww"]
print("_".join(li))
# 7、计算长度
lc = ["zs", "ls", "ww", "zl"]
print(len(lc))
print("============================================================end")
#8、元组里面增加元素
tu = (
    "zd",
    [
        11,
        22,
        {
            "k1":"v1",
            "k2":["age","name"],
            "k3":(11,22,33)},
        44
    ]
)
v = tu[1][2]["k2"].append("seven")
print(tu)
#9、找出列表中任意两个元素相加等于9的元素集合
nums = [2,7,11,15,1,8,7]
a = []
for i in nums:
    for j in nums:
        if i + j == 9:
            a.append((i,j))
print(a)

#1、列举布尔值为False的值：
0 False "" [] () {} None
#2、根据范围获取其中3和7整除的所有数的和并返回调用者
#3、符合条件的数字个数以及符合条件的数字的总和，如：def func(start,end):
def func(start,end,a = 0,b = 0):
    if start  == end:
        return a,b
    if start %3 == 0 and start %7 == 0:
        a += 1
        b += start
    ret = func(start + 1,end,a,b)
    return ret
ret = func(1,7)
print(ret)
#4、函数的默认返回值是None
#5、所有可以用递归解决的问题都可以用for循环解决
#6、简述break/continue/return的区别：
break是结束当前循环、continue是结束本次循环进入下一次循环、return是结束函数并返回结果默认为None
#7、函数传参数时是引用还是赋值值
#8、简述三元运算书写格式以及应用场景：
变量= 值一 if  条件成立 else 值二
#9、简述lambda表达式书写格式以及应用场景？
函数名 = lambda 形参：功能 不写函数名也可以
#10、使用set集合获取两个列表 l1 = [11,22,33] ,l2 = [22,33,44]中相同的集合
l1 = [11,22,33]
l2 = [22,33,44]
print(set(l1)&set(l2))
#11、定义函数统计一个字符串中大写字母、小写字母、数字的个数、并以字典为结果返回给调用者：
#12、简述函数的位置参数：按形参的位置传入加位置参数就是普通参数、关键字参数：传入实参是指定形参的值、默认参数：形参直接指定默认值的参数、可变长参数：*args,**kwargs一个只能
#接收没有位置参数的实参或传入的列表、元组、可以按关键字参数、和字典格式
#14、简述Python3中的range函数和Python2中的range函数由什么区别？3中的range不会产生值，只有用的时候才会产生、2中的range会直接生成列表、值已经生成
#15、
a = "aldboy %"
print(a)
b = "oldboy %d %%" %(12,)
print(b)
#16、简述对象和类的关系，如果值是类型，那这个值就是这个类的对象
def func(a1):
    return a1 + 100
func = lambda a1:a1 +200
ret = func(10)
print(ret)
#18、内置函数all和any和区别？
all如果是空返回TRUE，如果是非空，any只要有一个为真就行
#19、r是只读模式，默认utf-8，rb是以二进制格式打开，
#20、将字符串老男人转换成utf-8的字节类型？
s = "老男孩"
a= bytes(s,"utf-8")
s.encode("utf-8")
用户登录三次机会

count = 0
while count < 3:
    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    if user == "zd" and pwd == str(123):
        print("登录成功")
        break
    else:
        print("用户名或密码错误")
    count = count + 1
购物车作业

#输出商品列表，用户输入序号，显示用户选中的商品
"""
# 商品列表：
# goods = [
# {"name": "电脑", "price": 1999},
# {"name": "鼠标", "price": 10},
# {"name": "游艇", "price": 20},
# {"name": "美女", "price": 998}
# ]
# 要求:
# 1：页面显示 序号 + 商品名称 + 商品价格，如：
# 1 电脑 1999
# 2 鼠标 10
# ...
# 2：用户输入选择的商品序号，然后打印商品名称及商品价格
# 3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
# 4：用户输入Q或者q，退出程序。
"""
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998}
]                                                                            #1、首先把商品放在货架上
shopping_car = {}                                                            #15、接下来设置购物车空字典
print('欢迎光临大铁锤水果店！')                                              #2、接下来有个欢迎的语句
while True:                                                                  #23、加不断的循环
    money = input('让我看看你的钱输入Q或者q，退出程序：').strip()            #3、接下来定义钱并点strip下去除空白
    if money.isdigit() and int(money) > 0:                                       #4、接下来判断钱是数字还是字母是否大于0
        while True:                                                                 #20、再加下不断循环
            for i,k in enumerate(goods):                                         #5、接下来循环货架用到枚举、循环货架里面的所有商品以及价格
                print('序号{},商品{},价格{}'.format(i + 1,k['name'],k['price'])) #6、接下来用到字符串拼接、
            choose = input('请输入你要购买的商品序号：')                         #7、接下来设置买家购买的序号
            if choose.isdigit() and int(choose) < len(goods):                    #8、接下来判断输入的商品序号，
                num = input('你要购买的商品数量')                                #10、接下来设置输入的商品数量
                if num.isdigit():                                                #11、再接着判断数量是数字
                    if int(money) > goods[int(choose)]['price'] * int(num):      #12、接下来判断钱是否够购买东西
                        money = int(money) - goods[int(choose)]['price'] * int(num)  #13、这一步是剩余的钱等于总共的钱减去已经购买的商品价格乘以数量
                        if goods[int(choose)]['name'] in shopping_car:           #16、接下来判断购买的商品是否在购物车里面
                            shopping_car[goods[int(choose)]['name']] = shopping_car[goods[int(choose)]['name']] + int(num)#18、购买的商品名字等于
                        else:
                            shopping_car[goods[int(choose)]['name']] = int(num)  #17、否则回调不在的话选择的名字等于选择的数量
                        print('购物车中的商品有{},你的余额有{}'.format(shopping_car,money))#19、最后再告诉下购物车中的状况
                    else:
                        print('钱不够，回去')                                     #14、设置钱不够的结果
                        break #20、加下中断
            else:
                print('输入序号有误，请重新输入，')                               #9、回调出否则的结果
    if money.upper() == "Q":                                                      #21、如果是Q就退出
        break
    else:                                                                         #22、打印输入有误的
        print("输入有误：")

三级菜单作业

tag = True
while tag:
    print("leve1")
    choice = input("level1>>:").strip()
    if choice == "quit" : break
    if choice == "quit_all" : tag = False
    while tag:
        print("level2")
        choice = input("level2>>:").strip()
        if choice == "quit" : break
        if choice == "quit_all" : tag = False
        while tag:
            print("level3")
            choice = input("level3>>:").strip()
            if choice == "quit" : break
            if choice == "quit_all": tag = False
循环作业

#1、死循环
while 1 == 1:
    print("我写的代码每时每刻没BUG")
    break
#2、循环输出0到10不包含7
count = 0
while count < 11:
    if count == 7:
        pass
    else:
        print(count)
    count += 1
#3、输出1到100内所有奇数
count = 1
while count < 101:
    if count % 2 == 0:
        pass
    else:
        print(count)
    count = count + 1
#4、输出1到100内所有偶数
count = 1
while count < 101:
    if count % 2 == 0:
        print(count)
    else:
        pass
    count = count + 1
#5、输出1到100所有数的和
count = 1
s = 0
while count < 101:
    s = s + count
    count = count + 1
print(s)
#6、输出1-2+3-4+5...99所有数的和
count = 1
s = 0
while count < 100:
    if count % 2 == 0:
        s = s - count
    else:
        s = s + count
    count = count + 1
print(s)
7、机器码和字节码简单比较？
机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。
字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。
总结：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
8、python2与python3中long类型的区别？
python2中有long类型
python3中没有long类型，只有int类型
9、Python中的xrange和range的区别？

在python2 中
range(start,end,step)返回一个列表，返回的结果是可迭代对象，但不是迭代器。iter()转化为列表迭代器。

xrange()返回的是一个序列，他也是可迭代对象，但不是迭代器。可以通过iter()方法转化为范围迭代器。经过iter()函数之后，才能使用next（）函数取出其中的值。

python3
在python3 中没有xrange,只有range()。range（） 和python2 中的xrange()一样。

10、1,2,3,4,5能组成多少个互不相同且无重复的三位数？

l = [1,2,3,4,5]
def threeNum(l):
    lists = []
    for i in l:
        for j in l:
            for k in l:
                if i != j and i != k and j != k:
                    num = str(i) + str(j) + str(k)
                    lists.append(num)
    return set(lists)#用set去重
print(threeNum(l))
a = threeNum(l)
print("这是什么类型",type(a))
b = list(a)
print(len(b))
11、你最熟悉的网站是？
Python.org
18、平时喜欢看什么书？Python学习手册、核心编程、流畅的Python、selenium、pytest、unittest
19、a = (10,)　　#加逗号是元组、不加逗号是整型。
print(type(a))
a = ()　　　　 　#这是空元组

合并列表倒序
li1 = [3, 1, 2]
li2 = [9, 4, 10]
方法一
li1.extend(li2)
print(sorted(li1, reverse=True))
方法二
print(sorted(li1 + li2, reverse=True))

django和flask区别及简单使用？
Django 原生组件非常丰富 - 教科书式框架
Django.Model - ORM
Django.Form
Django.ModelForm
Django.Session Model
Admin CsrfToken
Django 加载项巨大 资源浪费
Flask Web框架 -
Flask 非常短小精悍 - 精简到只有一个 Session
Flask 第三方组件 非常全
Flask 第三方组件 - 运行稳定性相对较差
Django 适合大型 密集型
Flask 适合小型 API服务类项目
如果你想搞懂Python web开发WSGI协议原理以及实现过程、或者你想灵活定制组件，完全DIY你的应用、想实现微服务，那么建议你选择Flask。
如果你关注产品的最终交付、想快速开发一个大的应用系统（比如新闻类网站、商城、ERP等），那么建议你选择Django，你想得到的功能它都有，想不到的功能它也有

装饰器：
def wrapper(func):
    def innder(*args, **kwargs):
        print("1")
        func(*args, **kwargs)
        print("2")
    return innder
@wrapper
def index():
    print("is index")
index()

求1到50的和？

print(sum(range(1, 101)))
sql题

select * from xueke as a left join chengji as c on a.id = c.id

select sum(md) from gl_accvouch where iyperiod="201710" and cbill = "demo" and cdigets

select sum(md) from gl_accvouch where iyperiod = "201710" and cbill = "demo" group by code

select * from gl_accvouch where iyperiod = "201710" order by id

select conut(name) from user

select count(distinct id) from user

select * from user limit 5

select * from user limit 5,10

select * from user limit 5,-1

SELECT NAME FROM book ORDER BY price DESC LIMIT 3; -- 取出里面价格最高的三本书的书名

select name from book order by price desc limit 3

select * from gl_accvouch where iyperiod='201710'  and cbill='demo' and cdigest='zz' and dt_date is null--查dt_date票号发生日期数据是空的语句

select * from gl_accvouch where iyperiod = "201710" and da_date is null

select * form gl_accvouch where iyperiod = "201710" and da_date not is null

学生表(学生id，姓名，性别，学科id， 分数)
student（stu_id，name, sex, s_id，score）
查出学科id为1，分数在80分以上女孩的姓名？
select name from student where id = 1 and score > 80 and sex = "girl"
select a.name  from student as a left join subject as s on a.s_id = s.s_id where s.s_id = "1"  and a.score > 80 and a.sex = "girl"

学科表（学科id，学科名称，年级）
subject（s_id，s_name，grade）
找出一年级，数学成绩在80分以上的学生名字？（提示：两张表是有关联的）

select a.name  from student as a left join subject as s on a.stu_id = s.s_id
where s.grade = "一年级"  and s.s_name = "数学" and a.score> 80

列表去重：
方法一：利用集合去重，不推荐，因为顺序会乱
list1 = ["a", "a", "a", "b", "b", "c", "d", "d", "f"]
list1 = list(set(list1))  # 先将list1转化为set集合去重，再将集合转化为列表
print(list1)

方法二：定义临时空列表，遍历原始列表，保存不重复的元素，最后打印临时列表。
list2 = ["a", "a", "a", "b", "b", "c", "d", "d", "f"]
temp_list = []  # 定义一个临时空列表，用于保存临时数据。
for i in list2:  # 遍历原列表，判断如果元素不在临时列表，就追加进去，如果在，就不加。
    if i not in temp_list:
        temp_list.append(i)
print(temp_list)

方法三：双重循环，外层循环遍历列表，内存循环控制删除重复元素的次数。如果元素个数统计大于1，则执行删除。
list3 = ["a", "a", "a", "b", "b", "c", "d", "d", "f"]
list3.reverse()  # 先反转列表，从后往前删
for i in list3:  # 外层循环控制每次需要判定的元素
    for _ in range(list3.count(i)):  # 内层循环控制每次执行删除元素的次数，循环多次就彻底删除。
        if list3.count(i) > 1:
            list3.remove(i)  # 如果该元素个数大于1，则执行删除操作
list3.reverse()  # 最后再反转列表，保证第一次出现的元素顺位保留下来
print(list3)
方法一，顺序乱了，而且内存地址改变了。方法二，顺序没乱，但多申请了临时变量的内存地址。方法三，顺序没乱，内存地址也没变。
cat -n test.log |grep "debug"  得到关键日志的行号

error.log | grep -B 5 'nick' 显示nick及前5行

error.log | grep -A 5 'nick' 显示nick及后5行

error.log | grep -C 5 'nick' 显示file文件里匹配nick字串那行以及上下5行

error.log | grep -n -B10 -A10 5 'nick' 显示file文件里匹配nick字串前后10行

cat  all_info.log | grep "错误的关键信息提示" -C 10

查看日志中出现关键字 "错误的关键信息提示" 的前后10行内容

从第10行开始显示，显示10行到30行：cat filename | tail -n +10 | head -n 30
tail -n 10：显示最后10行
tail -n +10：从10行开始显示，显示10行以后的内容
head -n 10：显示前面10行

1.查看日志常用命令

    tail:  

       -n  是显示行号；相当于nl命令；例子如下：

            tail -100f test.log      实时监控100行日志

            tail  -n  10  test.log   查询日志尾部最后10行的日志;

            tail -n +10 test.log    查询10行之后的所有日志;

    head:  

        跟tail是相反的，tail是看后多少行日志；例子如下：

            head -n 10  test.log   查询日志文件中的头10行日志;

            head -n -10  test.log   查询日志文件除了最后10行的其他所有日志;

    cat： 

        tac是倒序查看，是cat单词反写；例子如下：

            cat -n test.log |grep "debug"   查询关键字的日志

2. 应用场景一：按行号查看---过滤出关键字附近的日志

     1）cat -n test.log |grep "debug"  得到关键日志的行号

     2）cat -n test.log |tail -n +92|head -n 20  选择关键字所在的中间一行. 然后查看这个关键字前10行和后10行的日志:

            tail -n +92表示查询92行之后的日志

            head -n 20 则表示在前面的查询结果里再查前20条记录

3. 应用场景二：根据日期查询日志

      sed -n '/2014-12-17 16:17:20/,/2014-12-17 16:17:36/p'  test.log

      特别说明:上面的两个日期必须是日志中打印出来的日志,否则无效；

                      先 grep '2014-12-17 16:17:20' test.log 来确定日志中是否有该 时间点

4.应用场景三：日志内容特别多，打印在屏幕上不方便查看

    (1)使用more和less命令,

           如： cat -n test.log |grep "debug" |more     这样就分页打印了,通过点击空格键翻页

    (2)使用 >xxx.txt 将其保存到文件中,到时可以拉下这个文件分析

            如：cat -n test.log |grep "debug"  >debug.txt

# 垃圾回收机制详解（了解）
# 1、引用计数
# x = 10  # 直接引用
# print(id(x))
# y = x
# z = x
#
# l = ['a', 'b', x]  # 间接引用
# print(id(l[2]))  #
#
# d = {'mmm': x}  # 间接引用
#
# print(id(d['mmm']))

# x=10
# l=['a','b',x] # l=['a'的内存地址,'b'的内存地址,10的内存地址]
#
# x=123
# print(l[2])
#
#
# x=10
# x=[10,]
#
# l=['a','b',10]

# 2、标记清除：用来解决循环引用带来的内存泄露问题
# 循环引用=>导致内存泄露
l1 = [111, ]
l2 = [222, ]
l1.append(l2)  # l1=[值111的内存地址，l2列表的内存地址]
l2.append(l1)  # l2=[值222的内存地址，l1列表的内存地址]
# print(id(l1[1]))
# print(id(l2))

# print(id(l2[1]))
# print(id(l1))

# print(l2)
# print(l1[1])

del l1
del l2

# 3、分代回收：用来降低引用计数的扫描频率，提升垃圾回收的效率

list1 = [
    'egon',
    'lxx',
    [1, 2]
]

# 1、二者分隔不开，list改list2也跟着该，因为指向的就是同一个地址
# list2=list1 # 这不叫copy
# list1[0]='EGON'
# print(list2)

# 2、需求：
# 1、拷贝一下原列表产生一个新的列表
# 2、想让两个列表完全独立开，并且针对的是改操作的独立而不是读操作


# 3、如何copy列表
# 3.1 浅copy:是把原列表第一层的内存地址不加区分完全copy一份给新列表
list1 = [
    'egon',
    'lxx',
    [1, 2]
]

list3 = list1.copy()
# print(list3) 结果：['egon', 'lxx', [1, 2]]
# print(id(list1))内存地址：42918536
# print(id(list3))内存地址：42939656

# print(id(list1[0]),id(list1[1]),id(list1[2])) 内存地址：34845392 41329584 34874312
# print(id(list3[0]),id(list3[1]),id(list3[2])) 内存地址：34845392 41329584 34874312

# 实验1：对于不可变类型的赋值，都是产生了新值，让原列表的索引指向新的
# 内存地址，并不会影响新列表
list1[0] = 'EGON'
list1[1] = 'LXX'
list1[2] = 123
print(list1)  # 结果：['EGON', 'LXX', 123]
print(list3)  # 结果：['egon', 'lxx', [1, 2]]

# 实验2：但对于可变类型，我们可以改变可变类型中包含的值，但内存地址不变
# 即原列表的索引指向仍然指向原来的内存地址，于是新列表也跟着一起受
# 影响，如下
list1[2][0] = 111
list1[2][1] = 222
print(list1)  # 结果：['egon', 'lxx', [111, 222]]
print(list3)  # 结果：['egon', 'lxx', [111, 222]]

# 综合实验1和实验2可以得出，要想copy得到的新列表与原列表的改操作完全独立开
# 必须有一种可以区分开可变类型与不可变类型的copy机制，这就是深copy

# 3.2 深copy
import copy

list1 = [
    'egon',
    'lxx',
    [1, 2]
]

list3 = copy.deepcopy(list1)
# print(id(list1))内存地址：42918536
# print(id(list3))内存地址：42939656
# print(list3)结果：['egon', 'lxx', [1, 2]]

#          不可变        不可变        可变
# print(id(list1[0]),id(list1[1]),id(list1[2]))内存地址：4497919088 4498367856 4498449216
# print(id(list3[0]),id(list3[1]),id(list3[2]))内存地址：4497919088 4498367856 4498595328
# print(id(list1[2][0]),id(list1[2][1]))内存地址：1507959904 1507959936
# print(id(list3[2][0]),id(list3[2][1]))内存地址：1507959904 1507959936

list1[0] = 'EGON'
list1[1] = 'LXX'
list1[2][0] = 111
list1[2][1] = 222
print(list1)  # 结果：['EGON', 'LXX', [111, 222]]
print(list3)  # 结果：['egon', 'lxx', [1, 2]]

# 1、队列：FIFO,先进先出
l = []
# 入队操作
l.append('first')
l.append('second')
l.append('third')
print(l)  # 结果：['first', 'second', 'third']

# 出队操作
print(l.pop(0))  # 结果：first
print(l.pop(0))  # 结果：second
print(l.pop(0))  # 结果：third

# 2、堆栈：LIFO,后进先出
l = []
# 入栈操作
l.append('first')
l.append('second')
l.append('third')

print(l)  # 结果['first', 'second', 'third']
# 出队操作
print(l.pop())  # 结果：third
print(l.pop())  # 结果：second
print(l.pop())  # 结果：first

# 算法：是高效解决问题的办法
# 算法之二分法
# 需求：有一个按照从小到大顺序排列的数字列表
#      需要从该数字列表中找到我们想要的那个一个数字
#      如何做更高效？？？
find_num = 10
nums = [-3, 4, 13, 10, -2, 7, 89]

# 方案一：整体遍历效率太低
for num in nums:
    if num == find_num:
        print('find it')
        break

# 方案二：二分法（伪代码如下）
# def binary_search(find_num,列表):
#     mid_val=找列表中间的值
#     if find_num > mid_val:
#         # 接下来的查找应该是在列表的右半部分
#         列表=列表切片右半部分
#         binary_search(find_num,列表)
#     elif find_num < mid_val:
#         # 接下来的查找应该是在列表的左半部分
#         列表=列表切片左半部分
#         binary_search(find_num,列表)
#     else:
#         print('find it')

nums = [-3, 4, 7, 10, 13, 21, 43, 77, 89]
find_num = 8
def binary_search(find_num, l):
    print(l)
    if len(l) == 0:
        print('找的值不存在')
        return
    mid_index = len(l) // 2
    if find_num > l[mid_index]:
        # 接下来的查找应该是在列表的右半部分
        l = l[mid_index + 1:]
        binary_search(find_num, l)
    elif find_num < l[mid_index]:
        # 接下来的查找应该是在列表的左半部分
        l = l[:mid_index]
        binary_search(find_num, l)
    else:
        print('find it')
binary_search(find_num, nums)

"""
结果：[-3, 4, 7, 10, 13, 21, 43, 77, 89]
[-3, 4, 7, 10]
[10]
[]
找的值不存在
"""

# 统计字符个数方法一：
a = "aaaabbbccd"
resoult = {}
for i in a:
    resoult[i] = a.count(i)
print(resoult)

# 统计字符个数方法二：
str_ = str(input('输入一个字符串:'))
print('字符统计结果：')
for i in set(str_):
    if i == ' ':
        continue
    s = str_.count(i)
    print(i, ':', s)

# 统计字符个数方法三：
str1_ = str(input("请输入一串字符:"))
dict_ = {}
for i in str1_:
    if i == ' ':
        continue
    dict_[i] = str1_.count(i)
print('字符统计结果:', dict_)

# 统计字符个数方法四：
from collections import Counter
str = "hello"
print(Counter(str))

# 给一个字符串，统计其中的数字、字母和其他类型字符的个数：
# 输入254h!%he
int_count = 0
str_count = 0
other_count = 0
a = input("please input a str：\n")
for i in a:
    # 判断是否为数字
    if i.isdigit():
        int_count += 1
    # 判断是否为字母
    elif i.isalnum():
        str_count += 1
    # 判断为其他字符
    else:
        other_count += 1
print("数字 = %d, 字母 = %d，其他 = %d" % (int_count, str_count, other_count))

# 字符串中5的个数
h1 = "dsafd5sfs5fdsfsdf"
print(h1.count("5"))

adb connect 127.0.0.1:62001

adb devices

adb install app APP路径地址

指定设备安装

adb -s 设备号 install apk安装包路径

指定设备卸载

adb -s 设备号 uninstall package包名

启动adb

adb start-server

停止adb

adb kill-server

列出手机中装的所有APP的包名

adb shell pm list packages

列出系统应用的所有包名

adb shell pm list packages -s

列出第三方应用包名（排除系统应用的）

adb shell pm list packages -3

清除应用数据及缓存

adb shell pm clear com.jd.app.reader

li = ["toBeAnnotation待标注", "annotation标注中", "toBeValidation待审核", "completed完成", "validation审核中", "toBeExamine1中汽待审核",
      "examine1中汽审核中", "toBeExamine2客户待审核", "examine2客户审核中"]
print(sorted(li, key=lambda i: i[-1]))
print(sorted(li, key=lambda i: i[-1], reverse=True))
print(sorted(li, key=lambda i: i[-2], reverse=True))
print(sorted(li, key=lambda i: i[-3], reverse=True))