# 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))