[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]

a=[[1,2],[3,4],[5,6]]
x=[ one for lista in a for one in lista]
print(x)

x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果

x="abc"
y='def'
z=['d','e','f']
print(x.join(z))
print(y.join(z))

输出结果是：

dabceabcf
ddefedeff

python中交换两个数值

a,b=1,3
b,a=a,b
print(a,b)
#3 1

写一个单列模式

# -*- coding:utf-8 -*-
class SingleInstance(object):
    __instance=None
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance=object.__new__(cls)
        else:
            return cls.__instance

保留两位小数

# -*- coding:utf-8 -*-
a="%.03f"%1.3335
print(a)
print(round(float(a),2))

可变数据类型的理解

# -*- coding:utf-8 -*-
def func(k,v,dic={}):
    dic[k]=v
    print(dic)
func("one",1)
func("two",2)
func("three",3,{})

输出结果

{'one': 1}
{'one': 1, 'two': 2}
{'three': 3}

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

前端优化：

1、减少http请求、例如制作精灵图

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

后端优化：

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

2、异步方式，如果有耗时操作，可以采用异步，比如celery

3、代码优化，避免循环和判断次数太多，如果多个if else判断，优先判断最有可能先发生的情况

数据库优化：

1、如有条件，数据可以存放于redis，读取速度快

2、建立索引、外键等

数据库引擎

InnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。

MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比 较低，也可以使用。

MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表。

python中copy和deepcopy区别

浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制

深拷贝：外围和内部元素都进行了拷贝对象本身，而不是引用。也就是，把对象复制一遍，并且该对象中引用的其他对象我也复制。

不可变对象类型，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。

一句话就是，不可变类型，不管是深拷贝还是浅拷贝，地址值和拷贝后的值都是一样的。

a=(1,2,3)
print("=====第一种=号浅拷贝=====")
b=a
print(a)
print(b)
print(id(a))
print(id(b))
print("=====另一种copy浅拷贝===")
b=copy.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))
print("=====深拷贝=====")
b=copy.deepcopy(a)
print(a)
print(b)
print(id(a))
print(id(b))
# 结果如下：
=====浅拷贝=====
(1, 2, 3)
(1, 2, 3)
2814522335952
2814522335952
=====另一种浅拷贝===
(1, 2, 3)
(1, 2, 3)
2814522335952
2814522335952
=====深拷贝=====
(1, 2, 3)
(1, 2, 3)
2814522335952
2814522335952

可变对象的深浅拷贝

a=[1,2,3]
print("=====第一种=号浅拷贝=====")
b=a
print(a)
print(b)
print(id(a))
print(id(b))
print("=====另一种copy浅拷贝===")
b=copy.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))
print("=====深拷贝=====")
b=copy.deepcopy(a)
print(a)
print(b)
print(id(a))
print(id(b))
#结果如下：
=====浅拷贝=====
[1, 2, 3]
[1, 2, 3]
2007696321544
2007696321544
=====另一种copy浅拷贝===
[1, 2, 3]
[1, 2, 3]
2007696321544
2007695909960
=====深拷贝=====
[1, 2, 3]
[1, 2, 3]
2007696321544
2007696319560

1、复制不可变数据类型，不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。 2、复制的值是可变对象（列表和字典）

浅拷贝copy有两种情况：

第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表）， 改变原来的值 中的复杂子对象的值 ，会影响浅复制的值。

深拷贝deepcopy：完全复制独立，包括内层列表和字典

# -*- coding:utf-8 -*-
a=[1,2,3,4,5,6]
b=a.copy()
b[0]=23
print(a)
print(b)
'''
[1, 2, 3, 4, 5, 6]
[23, 2, 3, 4, 5, 6]
'''

# -*- coding:utf-8 -*-
a=[1,2,3,4,5,6,[12,34]]
b=a.copy()
b[6][0]=1
print(a)
print(b)
'''
[1, 2, 3, 4, 5, 6, [1, 34]]
[1, 2, 3, 4, 5, 6, [1, 34]]
'''

最常用的魔法方法

init:对象初始化方法

new:创建对象时候执行的方法，单列模式会用到

str:当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

del:删除对象执行的方法

首尾空格去除

aa="   dasfsad "
print(aa.strip())

列表嵌套字典的排序，分别根据年龄和姓名排序并且列表嵌套列表排序，年龄数字相同怎么办？

foo = [{"name":"zs","age":19},{"name":"ll","age":54},

        {"name":"wa","age":17},{"name":"df","age":17}]
print(sorted(foo,reverse=True,key=lambda x:(x['age'],x['name'])))

根据键对字典排序 思路2

foo = {"name":"zs","age":19,"sex":"femel","city":'bj'}
foo_tuple=zip(foo.keys(),foo.values())
print(foo_tuple)
foo_list=[one for one in foo_tuple]
print(foo_list)
print(sorted(foo_list,key=lambda x:x[0]))
res=sorted(foo_list,key=lambda x:x[0])
new_dict={one[0]:one[1] for one in res}
print(new_dict)

###根据键对字典排序 思路3

foo = {"name":"zs","age":19,"sex":"femel","city":'bj'}
print(sorted(foo.items(),key=lambda x:x[0]))
res=sorted(foo.items(),key=lambda x:x[0])
new_dict={one[0]:one[1] for one in res}
print(new_dict)