# 1.一行代码求1~100之和
'''利用sum()函数求和'''
a=sum(range(1,101))
print(a) # 5050
# 2.在函数内部修改全局变量
'''利用global'''
a=5
def do():
global a
a=1
print(a) # 5
do()
print(a) # 1
# 3.列出5个python标准库
'''sys,re,csv,urllib,urllib2,functools,os,time,math'''
# 4.字典如何删除键以及合并两个字典
''' 删除用del，合并更新用update'''
dic1={'a':1,'b':2,'c':3}
dic2={'a':7,'b':8,'d':9}
del dic1['a']
print(dic1) # {'b': 2, 'c': 3}
dic1.update(dic2)
print(dic1) # {'b': 8, 'c': 3, 'a': 7, 'd': 9}
# 5.GIL
'''
GIL是python的全局解释器锁，导致一个进程单一时刻只能有一个线程运行。如果该线程
执行完毕或者遇到耗时操作，则释放GIL，其他线程获取GIL后继续运行，属于线程并发。多进程由于每个进程都可
以分配到资源，所以多进程可以实现多线程并行，但是多进程系统资源开销大。
'''
# 6.python实现列表去重
list1=[1,2,2,3,3]
list1=[set(list1)]
print(list1) # [{1, 2, 3}]
# 7.*args和**kwargs
''' *args指可变参数，**kwargs指关键字参数，二者均是不定长的'''
# 8.python2和python3的range(100)区别
'''python2中range返回列表，而python3中range相当于python2中xrange，返回可迭代对象，节省内存'''
# 9.什么样的语言可以使用装饰器
'''函数可以作为参数传递的语言，可以使用装饰器'''
# 10.python內建的数据类型
'''
python3中有6个标准的数据类型，分别是
Number(int),String(str),Tuple(tuple),List(list),Dictionary(dict),Set(set)
其中有3个可变类型list,dict,set，
3个不可变类型int,str,tuple
'''
# 11.简述面向对象中__init__和__new__的区别
'''
__init__是对象初始化方法，创建对象后立即调用，默认参数self指对象本身,可接受参数，不需要返回值。
__new__是类初始化函数，默认参数cls指类本身，此参数由python解释器在实例化时自动识别。
__new__必须要有返回值，返回实例化出来的实例，可以通过super()return父类__new__出来的实例。
__init__的默认参数self，就是__new__返回的实例。
'''
# 12.with方法打开文件帮我们做了什么
'''
with帮我们实现了上下文管理，打开文件后不必手动close文件即可自行执行。
其实是实现了__enter__()和__exit__()方法，即上下文管理器需要的方法。
'''
# 13.列表[1,2,3,4,5]，使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取大于10的数，输出[16,25]
a=[1,2,3,4,5]
b=map(lambda x:x**2,a)
c=[x for x in b if x>10]
print(c) # [16, 25]
# 14.python生成随机整数，随机小数，0-1直接小数方法
import random
import numpy
a=random.randint(1,100)
b=numpy.random.randn() # 利用numpy生成随机小数
c=random.random()
print(a,b,c)
# 15.python避免转义的原始字符串
a='a\t'
b=r'a\t'
print(a,b)
# 16.正则匹配文本内容
import re
a='<div class="name">中国</div>'
b=re.findall(r'>(.*?)<',a)
print(b)
# 17.断言示例
a=1
assert a,'error a'
b=0
# assert b,'error b'
# 18.数据表student中name字段有重复，去除重复行，写出sql语句
sql='select distinct name from student'
# 查询字段类型
sql="select column_name,data_type from information_schema.columns \
where table_name='tbl_name' and column_name='col_name'"
# 更改字段类型
sql="alter table tbl_name alter column col_name nvarchar(200)"
# 查询具有重复值的列数据
sql="select name,COUNT(name) \
FROM tbl_name \
group by name having COUNT(name)>1"
# 查询表中字段P的所有重复数据
sql="select * from tbl_name where col_name in \
(select col_name from tbl_name group by col_name having count(col_name) > 1)"
# 查询多列重复数据
sql="select m.* from tbl_name m,\
(select id,col_name from tbl_name group by id,col_name having COUNT(1)>1)as m1 \
where m.id=m1.id and m.col_name=m1.col_name"
# 删除多列重复并保留最小sn的数据
sql="select * from tbl_name where sn not in \
(select temp.mid from(select MIN(sn) as mid from tbl_name m group by m.col_name1,m.col_name2) as temp)"
# 19.10个常用Linux命令
'''
ls(查看目录中文件),pwd(显示工作路径),cd(切换路径),touch(修改时间戳),rm(删除),mkdir(新建目录),tree(目录树),
cp(拷贝),mv(重命名、移动),cat(从首字节开始正向查看内容),more(查看长文件内容),grep(查找),echo(查看)
'''
# 20.python2和python3的区别
'''
1.python2是print x,python3是print(x)
2.python2中range和xrange，python3是range
3.python2中ansii编码，python3是Unicode编码
4.python2中reduce，python3中需要functools.reduce
5.python2中raw_input,python3是input
6.python2中str是字节序列，Unicode是字符串序列，python3中str是字符串序列，byte是字节序列
'''
# 21.s='ajidjiajfadsfsdf'，去重并从小到大排序输出
s='ajidjiajfadsfsdf'
s=sorted(list(set(s)))
print(s) # ['a', 'd', 'f', 'i', 'j', 's']
# 22.字典根据键升序排列
dic1={'a':1,'c':3,'b':2}
list1 = sorted(dic1.items(),key=lambda x:x[0])
dic2={}
for x in list1:
dic2[x[0]]=x[1]
print(dic2) # {'a': 1, 'b': 2, 'c': 3}
# 23.利用collections库中的Counter方法统计词频
s='a,b,a,c,d,f,b,c,d,c,c,a'
from collections import Counter
a=Counter(s)
print(a) # Counter({',': 11, 'c': 4, 'a': 3, 'b': 2, 'd': 2, 'f': 1})
# 24.字符串正则过滤s="not 404 found 张三 99 李四"，输出"张三 李四"
s="not 404 found 张三 99 李四"
import re
a=re.sub(r'[a-zA-Z0-9]','',s).strip().replace(' ',' ')
print(a)
# 25.filter方法过滤得到列表中的奇数
s=[1,2,3,4,5]
a=list(filter(lambda x:x%2!=0,s))
print(a)
# 26.列表推导式求奇数
s=[1,2,3,4,5]
a=[x for x in s if x%2!=0]
print(a)
# 27.正则re.compile作用
'''编译正则表达式对象，可重复使用，提高运行效率'''
# 28.a=(1,),b=(1),c=("1")分别是什么数据
'''a是tuple，b是int，c是str'''
a=(1,)
b=(1)
c=("1")
print(type(a),type(b),type(c)) # <class 'tuple'> <class 'int'> <class 'str'>
# 29. python删除文件和Linux删除文件命令
'''
os.remove(name)
rm name
'''
# 30.使用datetime模块打印当前时间戳
import datetime
a=datetime.datetime.now().strftime('%Y-%m-%d %H:%M::%S')
print(a) # 2018-08-17 15:27::31
# 31.数据库优化查询方法
'''外键，索引，联合查询，选择特定字段'''
# 32.构造自定义异常代码
def test():
try:
a=0
# assert a,'a不能为0'
if a==0:
raise Exception('a不能为0')
except Exception as e:
print(e)
test() # a不能为0
# 33.简述django的orm模型
'''
orm意为对象关系映射，实现了数据模型和数据库的解耦，通过简单的配置即可轻松更换数据库，而不需要修改代码。
本质上orm会根据对接的数据库引擎翻译成对应的sql语句，使用无需考虑数据库语句，简化了数据库的操作。
'''
# 34.一行代码展开[[1,2],[3,4],[5,6]]为[1,2,3,4,5,6]
'''采用嵌套列表解析式'''
s=[[1,2],[3,4],[5,6]]
a=[x for y in s for x in y]
print(a) # [1, 2, 3, 4, 5, 6]
'''采用numpy的flatten方法'''
import numpy
b=numpy.array(s).flatten().tolist()
print(b) # [1, 2, 3, 4, 5, 6]
# 35.x='abc',y='def',z=['d','e','f'],分别求出x.join(y)和x.join(z)的结果
'''join()括号里是可迭代对象，x插入可迭代对象之间，形成字符串'''
x='abc'
y='def'
z=['d','e','f']
a,b=x.join(y),x.join(z)
print(a,b) # dabceabcf dabceabcf
# 36.异常模块try...except...else...finally的相关意义
'''
try执行语句，except捕获异常，else没有捕获到异常执行，finally不管是否捕获到异常最终都要执行
'''
# 37.将a='hello',b='你好'转换为byte类型
a=b'hello'
b='你好'.encode()
print(a,b) # b'hello' b'\xe4\xbd\xa0\xe5\xa5\xbd'
# 38.提高python运行效率的方法
'''
1.使用生成器，可以节省内存
2.循环优化，避免更多重复代码执行
3.核心模块用cython pypy等
4.多进程，多线程，协程
5.多个if-else判断，把可能性大的放在前面
'''
# 39.简述mysql和redis的区别
'''
mysql是关系型数据库，数据保持在磁盘中，检索会有IO操作，访问速度相对较慢
redis是内存型非关系数据库，数据保存在内存中，速度快。
'''
# 40.如何调bug
'''
1.细节上错误，可以通过print，assert，raise等检测异常。
2.涉及第三方框架或者包的使用问题，查询官方文档或者技术博客。
3.解决bug的过程要做记录
'''
# 41. 不使用sort对列表进行升序排序
s=[2,3,5,4,1,2]
from functools import reduce
a=[]
while len(s)>1:
t=reduce(lambda x,y:min(x,y),s)
a.append(t)
s.remove(t)
a.extend(s)
print(a) # [1, 2, 2, 3, 4, 5]
# 42.写一个单例模式
'''写一个单例模式，最后类的实例id值都是一个'''
class Singleton():
__instance = None
def __new__(cls, name, num):
# 如果类属性__instance值为None，则创建一个对象，并且赋值为此对象的引用，保证下次调用此方法时能够知道此前
# 已经创建过对象了，这样就保证了只有1个对象实例
if not cls.__instance:
cls.__instance=super().__new__(cls,name,num)
return cls.__instance
a=Singleton('a',1)
b=Singleton('b',2)
print(id(a),id(b)) # 39428168 39428168
a.num=3 # 改变了a实例的num属性，则b实例的num属性也会随之而变。
print(b.num) # 3
# 43.保留两位小数
a='%.2f'%1.234
# 还可以用round方法
b=round(1.234,2)
print(a,b) # 1.23 1.23
# 44.三个方法的打印结果
'''字典类型是可变数据类型，指向一个地址，新增键值对地址不变'''
def fn(k,v,dic={}):
dic[k]=v
print(dic)
fn('a',1) # {'a': 1}
fn('b',2) # {'a': 1, 'b': 2}
fn('c',3,{}) # {'c': 3}
# 45.常见状态码
'''
200 ok,正常请求处理完毕
204，请求成功，但是没有实体返回
301，永久重定向
302，临时重定向
400，请求报文语法或者参数错误
403，禁止请求
404，无法找到资源
500，服务器故障或web应用故障
503，服务器超载或停机维护
'''
# 46.分别从前端、后端、数据库阐述web项目的性能优化
'''
1.前端优化
减少http请求，css放在页面上部，js放在页面底部
2.后端优化
缓存读写次数高、变化少的数据，如首页信息。程序读取数据先从缓存中读取，如果读取不到再去磁盘数据库读取，
并将数据写入缓存
异步，队列
代码优化，避免循环次数太多，if else判断优先可能
3.数据库优化
有条件可以将数据放入redis
建立索引，外键
'''
# 47.同源策略
'''同时满足三点要求，协议相同，域名相同，端口相同，不满足任何一个，就会出现“跨域”'''
# 48.简述cookie和session
'''
1.cookie在客户端(浏览器)，session在服务器端
2.cookie存有session id，session运行依赖session id识别
3.禁用cookie，session也会失效。
4.session过期时间由开发人员指定
5.cookie安全性不如session
'''
# 49.简述多线程和多进程
'''
1.进程
a)进程是操作系统分配资源和调度的基本单位，进程之间互相独立。
b)进程稳定性好，一个进程崩溃不影响其他进程，资源开销大，开启数量有限。
2.线程
a)线程是cpu进行调度的基本单位，线程是进程的一部分，是比进程粒度更小的能相对独立运行的基本单位。
b)一个进程可以有多个线程，多个线程共享一个进程的资源，一个线程崩溃了会影响其他线程。
c)如果IO操作密集，多线程可以提高效率
3.应用
IO密集采用多线程，cpu密集采用多进程
'''
# 50.copy和deepcopy区别
'''
当赋值不可变数据类型，以下几种拷贝方式都是同样结果,id值都是相同的
当赋值为可变类型，可变类型再嵌套可变类型，只有deepcopy是完全拷贝独立的
'''
import copy
x=[1,'a',[2,3]]
# x='abc'
b=x
c=x[:]
d=copy.copy(x)
e=copy.deepcopy(x)
x[0]=10
x[2].append(4)
print(x,b,c,d,e) # [10, 'a', [2, 3, 4]] [10, 'a', [2, 3, 4]] [1, 'a', [2, 3, 4]] [1, 'a', [2, 3, 4]] [1, 'a', [2, 3]]
# 51.简介几个魔方方法
'''
1.__init__对象初始化方法
2.__new__创建对象初始化方法
3.__iter__实现可迭代方法
4.__str__print返回数据方法
5.__del__删除对象执行的方法
'''
# 51.使用lambda函数对列表排序，正数升序，负数降序
s=[1,3,5,2,4,-1,-2,-5,-3,-4]
a=sorted(s,key=lambda x:(x>0,abs(x))) # 先按是否大于0排序，再按照绝对值排序
print(a) # [-1, -2, -3, -4, -5, 1, 2, 3, 4, 5]
# 52.列表嵌套字典的排序，分别根据年龄和姓名排序
x=[{'name':'a','age':10},{'name':'b','age':2}]
a=sorted(x,key=lambda x:x['name'])
b=sorted(x,key=lambda x:x['age'])
print(a,b) # [{'name': 'a', 'age': 10}, {'name': 'b', 'age': 2}] [{'name': 'b', 'age': 2}, {'name': 'a', 'age': 10}]
# 53.列表嵌套元组，分别按字母和数字排序
x=[('a',2),('b',1)]
a=sorted(x,key=lambda x:x[1])
print(a) # [('b', 1), ('a', 2)]
# 54.列表嵌套列表，数字相同
x=[['a',2],['b',1],['c',2]]
a=sorted(x,key=lambda x:(x[1],x[0])) # 添加参数，先按数字排序，再按字母排序
print(a) # [['b', 1], ['a', 2], ['c', 2]]
# 56.根据字符串长度排序
s=['a','abcd','abc','ab']
a=sorted(s,key=lambda x:len(x)) #sorted采用lambda函数排序
s.sort(key=len) #sort采用len方法排序
print(a,s) # ['a', 'ab', 'abc', 'abcd'] ['a', 'ab', 'abc', 'abcd']
# 57.举例说明sql注入和解决办法
'''
当以字符串格式化书写的时候，如果用户输入"params;sql"则sql语句会被执行，
解决方式可以采用参数化传入,正则过滤传入参数，检查非法字符
'''
sql1='a' # 正常sql
sql2="' or 1==1 --'" #sql注入
sql="select * from demo where name='{0}' and pass='{1}'".format(sql2,'')
print(sql) # select * from demo where name='' or 1==1 --'' and pass=''
# 58.MyISAM和InnoDB引擎区别
'''
1.InnoDB支持事务，MyISAM不支持。事务是一种高级处理方式，对应出错的增删改可以进行回滚还原
2.MyISAM适合查询及插入为主的应用，InnoDB适合频繁修改和涉及到安全性较高的应用
3.InnoDB支持外键，MyISAM不支持
4.对于自增字段，InnoDB必须包含只有该字段的索引，MyISAM表中可以和其它字段建立联合索引
5.清空表时，InnoDB是一行行删除，效率低，MyISAM则会重建表
'''
# 59.垃圾回收机制
'''
python垃圾回收以引用计数为主，标记-清除和分代清除为辅的机制，后者主要是为了处理循环计数引用的问题。
当1个变量保存了对象的引用时，该对象的引用计数就会+1，当使用del删除对象时，引用计数会-1，
当引用计数为0时，对象被删除。
'''
# 60.int('1.4')和int(1.4)
# int('1.4') #会报错
int(1.4)
# 61.列举3条以上PEP8规范
'''
1.每一级缩进使用4个空格
2.行最大字符数79
3.顶层函数和类的定义，前后空两行
4.类内方法定义空1行
5.不同的库import导入要分开行，from-import不必
6.三引号注释文档字符串
7.行内注释和代码要两个空格分割，注释由#和一个空格开始
'''
# 62.正则匹配中文
import re
pattern=re.compile(r'[\u4e00-\u9fa5]+')
s='哈哈wo的'
a=pattern.findall(s)
print(a) # ['哈哈', '的']
# 63.乐观锁和悲观锁
'''
悲观锁认为每次取数据的时候都会被别人修改，使用每次拿数据都会加锁。
传统关系型数据库用到了很多这种锁机制，如行锁，表锁，读锁，写锁等，都是在操作之前加把锁。
乐观锁认为每次拿数据时候别人不会修改，所以拿数据不加锁。
在更新的时候会判断在此期间别人有没有更新这个数据，可以使用版本号等机制。乐观锁适用于多读的类型，可以提高吞吐量。
'''
# 64.列表、集合的交并补操作
x=[1,2,3]
y=[2,3,4]
a=[k for k in x if k in y] # 列表解析式求交集
b=list(set(x).intersection(set(y))) # 集合求交集
c=list(set(x).union(set(y))) # 集合求并集
d=list(set(x).difference(set(y))) # 集合求补集/差集
print(a,b,c,d) # [2, 3] [2, 3] [1, 2, 3, 4] [1]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
