#1、一行代码实现1--100之和
'''
#print(sum(range(1,101)))
#注意：range(n,m) 能取n,但是不能取m
'''
#2、如何在一个函数内部修改全局变量
'''
a = 1
def change():
global a
a = 2
print(a)
change()
print(a)
注意：用global关键字修改全局变量
'''
#3、列出5个python标准库
"""
1.os 和操作相关的函数
2.sys 用于命令行参数
3.math 数学运算
4.datetime 处理日期时间
5.re 正则
"""
#4、字典如何删除键和合并两个字典
'''
dic1 = {"name":"allen","age":20,"gender":"male"}
dic2 = {"age":22}
删除键"gender"
del dic1["gender"]
print(dic1)
并两个字典
dic1.update(dic2)
print(dic1)
'''
#5.谈下python的GIL
#谈下多线程
#谈下多进程
'''
1.GIL是什么？
GIL是python的全局解释器锁。
2.用来干什么的？
举个例子：假如一个进程当中有多个线程在执行，当一个线程运行程序的时候
会霸占python解释器，相当于加了一把锁，GIL。使得该进程内的其他
线程无法运行，等到该线程运行完才可以运行。
3.有特殊情况吗？
如果该线程运行过程中遇到了耗时操作，则解释器解开，使其他线程
运行。所以在多线程中，线程的运行是有先后顺序的，不是同时运行。
4.补充：多进程
多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个
python解释器，所以多进程可以实现多个进程的同时运行。缺点是
进程系统资源开销大。
'''
#6、python实现列表去重的方法
'''
list1 = [1,2,3,2,1]
s = list(set(list1))
print(s)
注意：set内不能有重复
'''
#7、fun(*args,**kwargs)中的*args,**kwargs什么意思？
'''
都是用来接收函数的参数的
*args:接收非键值对形式的可变数量的参数列表给函数
*kwargs:接不定长度的键值对形式的参数给函数
'''
#8、python2和python3的range（100）的区别
'''
python2 返回的是列表
python3 返回的是迭代器
'''
#9、一句话解释什么样的语言能够用装饰器?
'''
函数能作为参数传递的语言能使用装饰器
# 时间装饰器
def cal_time(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
# print("%s running time: %s secs." % (func.__name__, start_time - end_time))
print("%s 函数执行时间是: %s 秒" % (func.__name__, start_time - end_time))
return result
return wrapper
'''
#10、python内建数据类型有哪些
'''
int
bool
str
list
dict
tuple
'''
#11、简述面向对象中__new__和__init__区别
'''
__init__是初始化方法，创建对象后，就立刻被默认调用了，可接收参数
__init__有一个参数self
__init__不需要返回值
__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别
__new__必须要有返回值，返回实例化出来的实例，
如果__new__创建的是当前类的实例，会自动调用__init__函数
class Dog:
def __init__(self,name,age):
self.name = name
self.age = age
def run(self):
print('我家的%s,今年%s了,现在在奔跑'%(self.name,self.age))
if __name__ == '__main__':
dog = Dog('软糖',4)
dog.run()
'''
#12、简述with方法打开处理文件帮我我们做了什么？
'''
帮我们做finally中f.close()
'''
#13、列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]
'''
list1 = [1,2,3,4,5]
print(list(map(lambda x: x**2 ,list1 ))) #[1, 4, 9, 16, 25]
list2 = list(map(lambda x: x**2 ,list1 ))
list3 = [i for i in list2 if i>10] #[16, 25]
print(list3)
'''
#14、python中生成随机整数、随机小数、0--1之间小数方法
'''
#随机整数
import random
r1 = random.randint(5,15)
print(r1)
#生成5个随机小数
import numpy as np
r2 = np.random.randn(5)
print(r2)
#0--1之间小数方法
r3 = random.random()
print(r3)
#random.random()不能传递值
'''
#15.避免转义给字符串加哪个字母表示原始字符串？
'''
r , 表示需要原始字符串，不转义特殊字符
'''
#16、<div class="nam">中国</div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的
'''
import re
str1 = """<div class="nam">中国</div>"""
ret = re.findall('<div class=".*">(.*?)</div>',str1)
print(ret)
'''
#17、python中断言方法举例
"""
a = 2
assert(a > 1)
print('ok') #ok
b = 2
assert(b > 3)
print('ok')
"""
#18、数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句
#select distinct name from student
#10个Linux常用命令
'''
ls cd pwd ps rm mkdir gzip grep du df touch mv more tail
'''
#20、python2和python3区别？列举5个
'''
1.python2 range(1,5) 返回的是列表，python3 返回的是迭代器
2.python2 使用print 既可以用小括号，也可以空格
python3必须使用小括号
3.python2中使用ascii编码，python3使用utf-8编码
4.python2中如果显示正常中文，引入coding声明，python3不需要
5.python2中是raw_imput函数，python3中是input函数
6.python2中unicode表示字符串序列，str表示字节序列
python3中str表示字符串序列，byte表示字节序列
'''
import time
#21、列出python中可变数据类型和不可变数据类型，并简述原理
'''
不可变数据类型：int型、字符串型str和元组tuple
不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，内存中会有新地址，
而对于相同的值的对象，在内存中则只有一个地址
总结：变量的值不变，则内存地址不变
a = 1
b = 1
print(id(a)) 140703722169168
print(id(b)) 140703722169168
-------------
可变数据类型：列表list和字典dict；
允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，
只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化
不过对于相同的值的不同对象，在内存中都有自己的地址
总结：变量名不变，则内存地址不变
a = [1,2]
b = [1,2]
print(id(a)) 1194884883080
print(id(b)) 1194884883144
'''
#22、s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"
'''
s = "ajldjlajfdljfddd"
s = set(s)
s = list(s)
s.sort(reverse=False)
s = "".join(s)
#s = str(s) #['a', 'd', 'f', 'j', 'l']
print(s) #adfjl
注意：
1.字符串去重用set方法
2.去重之后，必须转化为列表，是因为sort函数只能接收list类型的数据
3.sort方法没有返回值，不要用变量接收
4.sort之后，用 "".join() 变成字符串
5.从小到大排列：reverse=False
'''
#23、用lambda函数实现两个数相乘
'''
ret = lambda a,b:a*b
print(ret(3,4))
'''
#24、字典根据键从小到大排序
'''
sort 与 sorted 区别：
sort 是应用在 list 上的方法，属于列表的成员方法
sorted 可以对所有可迭代的对象进行排序操作
list 的 sort 方法返回的是对已经存在的列表进行操作，
内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)
sort(cmp=None, key=None, reverse=False)
sorted(iterable, cmp=None, key=None, reverse=False)
reverse：True反序；False 正序
print(dic.items()) #[('name', 'zs'), ('age', 18), ('city', '深圳'), ('tel', '1362626627')]
dic={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
lis = sorted(dic.items(),key=lambda d:d[0],reverse=False)
print(lis)
'''
#25、利用collections库的Counter方法统计字符串每个单词出现的次数
# "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
'''
from collections import Counter
s = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
s = Counter(s)
print(s)
'''
#26、字符串a = "not 404 found 张三 99 深圳"，每个词中间是空格，
# 用正则过滤掉英文和数字，最终输出"张三 深圳"
'''
思路：
1.先用正则找出不符合要求的数据
2.再根据原始的数据，遍历两个列表，把其中共同的部分删掉
import re
a = "not 404 found 张三 99 深圳"
b = a.split(" ")
ret = re.findall('d+|[a-zA-Z]+',a)
for i in ret: #['not', '404', 'found', '99']
if i in b: #['not', '404', 'found', '张三', '99', '深圳']
b.remove(i)
bb = " ".join(b)
print(ret)
print(bb)
--------------------
匹配小数的代码
import re
aa = "not 404 55.66 found 张三 99 深圳"
bb = aa.split(" ")
ret = re.findall('d+.?d*|[a-zA-Z]+',aa)
for i in ret:
if i in bb:
bb.remove(i)
cc = " ".join(bb)
print(ret)
print(cc)
'''
#27.filter方法求出列表所有奇数并构造新列表，
# a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
'''
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = list(filter(lambda x:x%2==1,a))
print(a) #filter(lambda x:x%2==1,a)
'''
#28、列表推导式求列表所有奇数并构造新列表，
# a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
'''
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret = [i for i in a if i%2==1]
print(ret)
'''
#29、正则re.complie作用
'''
re.compile是将正则表达式编译成一个对象，加快速度，并重复使用
text = "apple's price is $9.94,orange's price is $12.5"
#先编译号提取的内容
r_obj = re.compile('d+.?d*')
#直接传入编译内容和文本即可
ret = re.search(r_obj,text)
print(ret.group())
ret2 = re.findall(r_obj,text)
print(ret2)
'''
#30、a=（1，）b=(1)，c=("1") 分别是什么类型的数据？
'''
a=(1,)
b=(1)
c=("1")
print(type(a)) #typle
print(type(b)) #int
print(type(c)) #str
'''
#31、两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]
'''
l1 = [1,5,7,9]
l2 = [2,2,6,8]
l1.extend(l2)
l1.sort(reverse=False)
print(l1) #[1, 2, 2, 5, 6, 7, 8, 9]
'''
#32、用python删除文件和用linux命令删除文件方法
'''
python：os.remove(文件名)
linux: rm 文件名
'''
#33、log日志中，我们需要用时间戳记录error,warning等的发生时间，
# 请用datetime模块打印当前时间戳 “2018-04-01 11:38:54”
'''
import datetime
a = str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print(a) #2019-04-16 17:27:33
#如果加上星期的话：
a = str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+ ' 星期' + str(datetime.datetime.now().isoweekday())
print(a)
'''
#34、数据库优化查询方法
'''
外键，索引，联合查询，选择特定字段等等
'''
#35.请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行
'''
pychart、matplotlib
'''
#36、写一段自定义异常代码
'''
def foo():
try:
for i in range(6):
if i > 3:
raise Exception("数字大于3了")
print(i)
except Exception as e:
print(e)
if __name__ == '__main__':
foo()
'''
#37.正则表达式匹配中，（.*）和（.*?）匹配区别？
'''
（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配
'''
#38.简述Django的orm
'''
ORM，全拼Object-Relation Mapping，意为对象-关系映射
实现了数据模型与数据库的解耦，通过简单的配置就可以轻松更换数据库，
而不需要修改代码只需要面向对象编程,orm操作本质上会根据对接的数据库引擎，
翻译成对应的sql语句,所有使用Django开发的项目无需关心程序底层使用的
是MySQL、Oracle、sqlite....，如果数据库迁移，只需要更换
Django的数据库引擎即可
'''
#39、[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
'''
l = [[1,2],[3,4],[5,6]]
ll = [j for i in l for j in i]
print(ll)
'''
#40、x="abc",y="def",z=["d","e","f"],
# 分别求出x.join(y)和x.join(z)返回的结果
'''
x="abc"
y="def"
z=["d","e","f"]
m = x.join(y)
print(m) #dabceabcf
n = x.join(z)
print(n) #dabceabcf
'''
import time
#41、举例说明异常模块中try except else finally的相关意义
'''
try..except..else没有捕获到异常，执行else语句
try..except..finally不管是否捕获到异常，都执行finally语句
'''
#42、python中交换两个数值
'''
a=1
b=2
a,b = b,a
print(a) #2
print(b) #1
'''
#43、举例说明zip（）函数用法
'''
zip()函数在运算时，会以一个或多个序列（可迭代对象）做为参数，
返回一个元组的列表。同时将这些序列中并排的元素配对。
zip()参数可以接受任何类型的序列
a = [1,2]
b = [3,4]
ret = [i for i in zip(a,b)]
print(ret) #[(1, 3), (2, 4)]
A = "ab"
B = "xyz"
ret2 = [i for i in zip(A,B)]
print(ret2) #[('a', 'x'), ('b', 'y')]
'''
#44、a="张明 98分"，用re.sub，将98替换为100
'''
import re
a="张明 98分"
a = re.sub('d+','100',a)
print(a)
'''
#45、写5条常用sql语句
'''
#select * from 表名
#show databases
#show tables
#update 表名 set 字段 where id=6
#delete from 表名 where id=6
'''
#46、a="hello"和b="你好"编码成bytes类型
'''
a=b"hello"
b="你好".encode()
print(a,b)
print(type(a),type(b))
英文字母直接加上b即可
中文用encode()
'''
#47.[1,2,3]+[4,5,6]的结果是多少？
'''
a = [1,2,3]
b = [4,5,6]
c = a + b
print(c) #[1, 2, 3, 4, 5, 6]
两个列表相加，等价于extend
'''
#48、提高python运行效率的方法
'''
1、使用生成器，因为可以节约大量内存
2、循环代码优化，避免过多重复代码的执行
3、核心模块用Cython PyPy等，提高效率
4、多进程、多线程、协程
5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，
这样可以减少程序判断的次数，提高效率
'''
#49、简述mysql和redis区别
"""
redis： 内存型非关系数据库，数据保存在内存中，速度快
mysql：关系型数据库，数据保存在磁盘中，检索的话，
会有一定的Io操作，访问速度相对慢
"""
#50、遇到bug如何处理
'''
1.通过print（）打印,分段检测程序是否有问题
2.如果涉及一些第三方框架，会去查官方文档
3、对于bug的管理与归类总结
4、导包问题、
'''
#51、正则匹配，匹配日期2018-03-20
'''
url='https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462'
import re
ret1 = re.findall('d{4}-d{2}-d+',url)
print(ret1)
ret2 = re.findall('dateRange=(.*?)%7C(.*?)&date',url)
print(ret2)
'''
#52、list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]
'''
list=[2,3,5,4,9,6]
def buble_sort(data_list):
for i in range(len(data_list)-1):
exchange = False
for j in range(len(data_list)-1-i):
if data_list[j] > data_list[j+1]:
data_list[j],data_list[j+1] = data_list[j+1],data_list[j]
if not exchange:
break
if __name__ == '__main__':
data_list = list
buble_sort(data_list)
print(data_list) #[2, 3, 4, 5, 6, 9]
'''
#53、写一个单列模式
'''
还没有搞设计模式
'''
#54、保留两位小数
'''
待解决
'''
#55、求三个方法打印结果
#56、列出常见的状态码和意义
'''
200 OK
请求正常处理完毕
303 See Other
临时重定向，期望使用GET定向获取
403 Forbidden
请求资源被拒绝
404 Not Found
无法找到请求资源（服务器无理由拒绝）
500 Internal Server Error
服务器故障或Web应用故障
'''
#57、分别从前端、后端、数据库阐述web项目的性能优化
'''
前端优化：
1、减少http请求、例如制作精灵图
2、html和CSS放在页面上部，javascript放在页面下面，因为js加载比HTML和Css加载慢，所以要优先加载html和css,以防页面显示不全，性能差，也影响用户体验差
后端优化：
1、缓存存储读写次数高，变化少的数据，比如网站首页的信息、商品的信息等。应用程序读取数据时，一般是先从缓存中读取，如果读取不到或数据已失效，再访问磁盘数据库，并将数据再次写入缓存。
2、异步方式，如果有耗时操作，可以采用异步，比如celery
3、代码优化，避免循环和判断次数太多，如果多个if else判断，优先判断最有可能先发生的情况
数据库优化：
1、如有条件，数据可以存放于redis，读取速度快
2、建立索引、外键等
'''
#58、使用pop和del删除字典中的"name"字段，dic={"name":"zs","age":18}
'''
dic = {"name":"zs","age":18}
del dic["name"]
print(dic) #{'age': 18}
v = dic.pop("name")
print(v) #zs
print(dic) #{'age': 18}
'''
#59、列出常见MYSQL数据存储引擎
'''
InnoDB：
支持事务处理，支持外键,支持崩溃修复能力和并发控制。
如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），
那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，
因为支持事务的提交（commit）和回滚（rollback）。
MyISAM：
插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，
那么选择MyISAM能实现处理高效率。
如果应用的完整性、并发性要求比 较低，也可以使用。
MEMORY：
所有的数据都在内存中，数据的处理速度快，但是安全性不高。
如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。
它对表的大小有要求，不能建立太大的表。
所以，这类数据库只使用在相对较小的数据库表。
'''
#60、计算代码运行结果，zip函数历史文章已经说了，
# 得出[("a",1),("b",2)，("c",3),("d",4),("e",5)]
'''
A = zip(("a","b","c","d","e"),(1,2,3,4,5))
A0 = dict(A) #A0 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
A1 = range(10)
A2 = [i for i in A1 if i in A0] # []
A3 = [A0[s] for s in A0] # [1, 2, 3, 4, 5]
print("A0",A0)
print(list(zip(("a","b","c","d","e"),(1,2,3,4,5))))
print(A2)
print(A3)
ret1 = dict([["name","zs"],["age",18]])
print(ret1)
ret2 = dict([("name","zs"),("age",18)])
print(ret2)
'''