110道题整理(1-60)

#一、一行代码实现1--100之和
'''
#print(sum(range(1,101)))
#注意：range(n,m) 能取n,可是不能取m
'''

#二、如何在一个函数内部修改全局变量
'''
a = 1
def change():
global a
a = 2
print(a)
change()
print(a)
注意：用global关键字修改全局变量
'''

#三、列出5个python标准库
"""
1.os 和操做相关的函数
2.sys 用于命令行参数
3.math 数学运算
4.datetime 处理日期时间
5.re 正则
"""

#四、字典如何删除键和合并两个字典
'''
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解释器，因此多进程能够实现多个进程的同时运行。缺点是
进程系统资源开销大。
'''

#六、python实现列表去重的方法
'''
list1 = [1,2,3,2,1]
s = list(set(list1))
print(s)
注意：set内不能有重复
'''

#七、fun(*args,**kwargs)中的*args,**kwargs什么意思？
'''
都是用来接收函数的参数的
*args:接收非键值对形式的可变数量的参数列表给函数
*kwargs:接不定长度的键值对形式的参数给函数
'''

#八、python2和python3的range（100）的区别
'''
python2 返回的是列表
python3 返回的是迭代器
'''

#九、一句话解释什么样的语言可以用装饰器?
'''
函数能做为参数传递的语言能使用装饰器

# 时间装饰器
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
'''

#十、python内建数据类型有哪些
'''
int
bool
str
list
dict
tuple
'''

#十一、简述面向对象中__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()
'''

#十二、简述with方法打开处理文件帮我咱们作了什么？
'''
帮咱们作finally中f.close()
'''

#1三、列表[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)
'''

#1四、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 , 表示须要原始字符串，不转义特殊字符
'''

#1六、<div class="nam">中国</div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不肯定的
'''
import re
str1 = """<div class="nam">中国</div>"""
ret = re.findall('<div class=".*">(.*?)</div>',str1)
print(ret)
'''

#1七、python中断言方法举例
"""
a = 2
assert(a > 1)
print('ok') #ok
b = 2
assert(b > 3)
print('ok')
"""

#1八、数据表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

#2一、列出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
'''

#2二、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
'''

#2三、用lambda函数实现两个数相乘
'''
ret = lambda a,b:a*b
print(ret(3,4))
'''

#2四、字典根据键从小到大排序
'''
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)
    
'''

#2五、利用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)
'''

#2六、字符串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)
'''

#2八、列表推导式求列表全部奇数并构造新列表，
# 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)
'''

#2九、正则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
'''

#3一、两个列表[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]

'''

#3二、用python删除文件和用linux命令删除文件方法
'''
python：os.remove(文件名)
linux:       rm  文件名
'''

#3三、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)
'''

#3四、数据库优化查询方法
'''
外键，索引，联合查询，选择特定字段等等
'''

#35.请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行
'''
pychart、matplotlib
'''

#3六、写一段自定义异常代码
'''
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的数据库引擎便可
'''

#3九、[[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

#4一、举例说明异常模块中try except else finally的相关意义
'''
try..except..else没有捕获到异常，执行else语句
try..except..finally不论是否捕获到异常，都执行finally语句

'''

#4二、python中交换两个数值
'''
a=1
b=2
a,b = b,a
print(a)    #2
print(b)    #1

'''

#4三、举例说明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')]

'''

#4四、a="张明 98分"，用re.sub，将98替换为100
'''
import re
a="张明 98分"
a = re.sub('\d+','100',a)
print(a)

'''

#4五、写5条经常使用sql语句
'''
#select * from 表名
#show databases
#show tables
#update 表名 set 字段 where id=6
#delete from 表名 where id=6
 
'''

#4六、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
'''

#4八、提升python运行效率的方法
'''
一、使用生成器，由于能够节约大量内存
二、循环代码优化，避免过多重复代码的执行
三、核心模块用Cython  PyPy等，提升效率
四、多进程、多线程、协程
五、多个if elif条件判断，能够把最有可能先发生的条件放到前面写，
这样能够减小程序判断的次数，提升效率

'''

#4九、简述mysql和redis区别
"""
redis： 内存型非关系数据库，数据保存在内存中，速度快
mysql：关系型数据库，数据保存在磁盘中，检索的话，
会有必定的Io操做，访问速度相对慢

"""

#50、遇到bug如何处理
'''
1.经过print（）打印,分段检测程序是否有问题
2.若是涉及一些第三方框架，会去查官方文档
三、对于bug的管理与归类总结
四、导包问题、

'''

#5一、正则匹配，匹配日期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)

'''

#5二、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]

'''

#5三、写一个单列模式
'''
尚未搞设计模式
'''

#5四、保留两位小数
'''
待解决

'''

#5五、求三个方法打印结果

#5六、列出常见的状态码和意义
'''
200 OK 
请求正常处理完毕

303 See Other 
临时重定向，指望使用GET定向获取

403 Forbidden 
请求资源被拒绝

404 Not Found 
没法找到请求资源（服务器无理由拒绝）

500 Internal Server Error 
服务器故障或Web应用故障

'''

#5七、分别从前端、后端、数据库阐述web项目的性能优化
'''
前端优化：

一、减小http请求、例如制做精灵图

二、html和CSS放在页面上部，javascript放在页面下面，由于js加载比HTML和Css加载慢，因此要优先加载html和css,以防页面显示不全，性能差，也影响用户体验差


后端优化：

一、缓存存储读写次数高，变化少的数据，好比网站首页的信息、商品的信息等。应用程序读取数据时，通常是先从缓存中读取，若是读取不到或数据已失效，再访问磁盘数据库，并将数据再次写入缓存。

二、异步方式，若是有耗时操做，能够采用异步，好比celery

三、代码优化，避免循环和判断次数太多，若是多个if else判断，优先判断最有可能先发生的状况



数据库优化：

一、若有条件，数据能够存放于redis，读取速度快

二、创建索引、外键等

'''

#5八、使用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}  

'''

#5九、列出常见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)

'''