一些概念总结

is 与 == 的区别

Python中万物皆对象，每个对象都包含3个属性：id,type,value.
1.id就是对象地址，可以通过内置函数id()查看对象引用的地址。
2.type就是对象类型，可以通过内置函数type()查看对象的类型.
3.value就是对象的值。

is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同；
==比较操作符：用来比较两个对象是否相等，value做为判断因素

类中的@classmethod、@staticmethod和@property的用法和效果。

@classmethod、@staticmethod 介绍
python中，一般方法的调用，是用类的实例对象来调用，但是使用@classmethod ,@staticmethod 时，直接用类名来调用。
用处：把一些功能与某个类相近的函数处理，可以写在类中，用这两个方法装饰，以便达到组织代码，使得代码相关性清晰的效果。

两者的区别：
@staticmethod 就跟使用函数一样，不需要表示自身对象的self和自身类的cls参数；
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
因为@classmethod 传入了cls参数，代指当前的这个类，就可以调用当前类的属性，方法，实例化对象等，个人觉得这个与类的关系更加紧密一些。

@property 的用法
@@property 即是python内置的一个装饰器，用于把一个方法变成属性方式调用，
property() 方法的语法: class property([fget[, fset[, fdel[, doc]]]])
- fget -- 获取属性值的函数
- fset -- 设置属性值的函数
- fdel -- 删除属性值函数
- doc -- 属性描述信息

python的反射

利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）

函数中的*args，**kwargs

用于函数的形式参数，当我们定义函数的时候，不确定参数的个数时用，

*args.可以传递任意数量的位置参数        --   以元组形式存储

**kwargs可以传递任意数量的关键字参数       --  以字典形式存储

*args和**kwargs可以同时在函数的定义中，但是*args必须在**kwargs前面。

单例模式

为什么要用单例模式

性能方面：当每个实例都会占用资源，而且实例初始化会影响性能，这个时候就可以考虑使用单例模式，它给我们带来的好处是只有一个实例占用资源，并且只需初始化一次。

数据的同步。在一个对急中封装要使用的数据，在各个地方调用数据时，数据不会出现错乱的情况，以达到数据同步的效果。

单例实现的四种方法

- 模块方式

 

 

 

lambda函数

通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。

与filter，map，reduce函数的连用

li = [2, 18, 9, 22, 17, 24, 8, 12, 27]
filter(lambda x: x % 3 == 0, li)  # 返回值[18, 9, 24, 12, 27]
map(lambda x: x * 2 + 10, li)    # 返回值[14, 46, 28, 54, 44, 58, 26, 34, 64]
reduce(lambda x, y: x + y, foo)  # 返回值139

可变对象和不可变对象（看内存地址，id（变量））

在python中，可变对象指对象创建之后，值发生改变时，内存地址不会发生改变:dict，list

不可变对象指，当值发生改变时，内存地址也发生改变。str，int，tuple，float

去除一个列表中重复的内容，原顺序不变

a = ['a','b','b','c','c','d']
b = list(set(a))
b.sort(key=a.index)    # 按照index索引来
或者
c = sorted(set(a),key=a.index)

一个列表里套着字典，以字典的某个k的值排序

l=[{"a":1","b":2},{"a":1","b":8},{"a":1","b":5},{"a":1","b":3}] 

以"a"的值排序
sorted(l,key=lamdba k:k["a"])

List=[-2，1，3，-6]，如何实现以绝对值大小从小到大将 List中内容排序。

li.sort(key=abs,reverse=False)  #按照内置函数abs,是否降序：False

li = [1, -2, 3, -6]  # 改变了原来的li

列表的sort方法和sorted的区别是什么？

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

python是如何进行内存管理的？

python的内存管理，主要涉及到以下的3个方面：
1.python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。

2.那什么是垃圾回收机制呢？
1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。
　　当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。

3.Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的 malloc。
另外Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

解释python脚本程序_name__变量及其作用

我们编写模块的时候，是为了给自己或者别人在适当的时候进行调用的，但是我们在编写模块时，也是需要测试的，会写一些测试代码，但是我们想在别人调用时，测试代码不起作用。

为了解决这一问题，python提供了一个系统变量：__name__

__name__有2个取值：当模块是被调用执行的，取值为模块的名字。当模块是直接执行的，则该变量取值为：__main__

一般的用法：

    def addFunc(a,b):  
        return a+b  
      
    if __name__ == '__main__':  
        print('结果:',addFunc(1,1))  

mysql表中的数据越来越大，请给出优化的简易的优化方案

我们一般的步骤是找问题，再优化：

优化sql的一般步骤（找问题）
    1.通过show status了解各种sql的执行频率
    2.定位执行效率低的sql语句
    3.通过explain分析效率低的sql
    4.通过show profile分析sql
    5.通过trace分析优化器如何选择执行计划
    6.确定问题，采取措施优化

问题优化：
    1.优化你的sql和索引；
    2.加缓存，memcached,redis；
    3.就做主从复制或主主复制，读写分离，可以在应用层做，效率高，也可以用三方工具，第三方工具推荐360的atlas,其它的要么效率不高，要么没人维护；
    4.mysql自带分区表，对你的应用是透明的，无需更改代码,但是sql语句是需要针对分区表做优化的，
　　　　sql条件中要带上分区条件的列，从而使查询定位到少量的分区上，否则就会扫描全部分区，另外分区表还有一些坑，在这里就不多说了；
    5.先做垂直拆分，其实就是根据你模块的耦合度，将一个大的系统分为多个小的系统，也就是分布式系统；
    6.水平切分，针对数据量大的表，这一步最麻烦，最能考验技术水平，要选择一个合理的sharding key,为了有好的查询效率，表结构也要改动，做一定的冗余，应用也要改，
　　　　sql中尽量带sharding key，将数据定位到限定的表上去查，而不是扫描全部的表

简述python的GIL锁

python代码的执行由解释器主循环来控制(虚拟机)，python在设计之初，就决定每次在解释器主循环中，同一时刻，只有一个线程。
对python解释器的访问，就是有GIL(全局解释器锁)来控制，正是这把锁，控制了同一时刻，只有一个线程在解释器中。

在多线程环境中，Python 解释器按以下方式执行：
1. 设置GIL
2. 切换到一个线程去运行
3. 运行：
    a. 指定数量的字节码指令，或者
    b. 线程主动让出控制（可以调用time.sleep(0)）
4. 把线程设置为睡眠状态
5. 解锁GIL
6. 再次重复以上所有步骤 

锁住全局解释器使得比较容易的实现对多线程的支持，但也损失了多处理器主机的并行计算能力。
但是，不论标准的，还是第三方的扩展模块，都被设计成在进行密集计算任务时，释放GIL。
还有，就是在做I/O操作时，GIL总是会被释放。对所有面向I/O 的程序来说，GIL 会在这个I/O 调用之前被释放，以允许其它的线程在这个线程等待I/O 的时候运行。
如果是纯计算的程序，没有 I/O 操作，解释器会每隔一定时间就释放这把锁，让别的线程有机会执行（这个次数可以通过 sys.setcheckinterval 来调整）。
I/O 密集型的Python 程序比计算密集型的程序更能充分利用多线程环境的好处。

多进程开发中，join和daemon的区别

一个程序至少有一个主线程，主线程启动子线程后，它们之间并没有隶属关系。主线程和子线程执行是并行的，相互独立。
　主线程执行完毕后默认不等子线程执行结束就接着往下走了，如果有其他程序就会运行另外的程序，如果没有就等待子线程执行完成后结束程序。

主线程创建一个子线程后，如果子线程调用join()方法，主线程会在调用的地方等待，直到该子线程运行完成才会接着往下执行。

setDaemon()方法：在主线程中创建子线程，该子线程调用setDaemon方法后成为主线程的守护线程。这种情况下如果主线程执行结束，那么不管子线程是否完成，一并和主线程退出。
这里基本和join()方法相反。此外，还有个要特别注意的：必须在start() 方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。

迭代器与生成器的理解。

讨论迭代器与生成器
1.在python中一切皆对象，如果一个对象，含有__iter__方法，则这个对象就是可迭代对象；

2.如果一个对象拥有__next__方法，其是迭代器。

3.定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。

4.具有yield关键字的函数都是生成器，yield可以理解为return，返回后面的值给调用者。
　　不同的是return返回后，函数会释放，而生成器则不会。在直接调用next方法或用for语句进行下一次迭代时，生成器会从yield下一句开始执行，直至遇到下一个yield。

mysql有哪些存储引擎，优化mysql数据库的方式有哪些？

MySQL5.5以后默认使用InnoDB存储引擎，其中InnoDB和BDB提供事务安全表，其它存储引擎都是非事务安全表。
1.MyISAM
它不支持事务，也不支持外键，尤其是访问速度快，对事务完整性没有要求或者以SELECT、INSERT为主的应用基本都可以使用这个引擎来创建表。

2.InnoDB
InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是对比MyISAM的存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。

3.MEMORY
memory使用存在内存中的内容来创建表。每个MEMORY表实际对应一个磁盘文件，格式是.frm。MEMORY类型的表访问非常快，因为它到数据是放在内存中的，
并且默认使用HASH索引，但是一旦服务器关闭，表中的数据就会丢失，但表还会继续存在。

4.MERGE
　　merge存储引擎是一组MyISAM表的组合，这些MyISAM表结构必须完全相同，MERGE表中并没有数据，对MERGE类型的表可以进行查询、更新、删除的操作，这些操作实际上是对内部的MyISAM表进行操作

python中如何动态的获取和设置对象的属性

其实就是Python的自省
    dir([obj]):
    调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。
    hasattr(obj, attr): 
    这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
    getattr(obj, attr): 
    调用这个方法将返回obj中名为attr值的属性的值，例如如果attr为’bar’，则返回obj.bar。
    setattr(obj, attr, val):
    调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为’bar’，则相当于obj.bar = val。 

python中如何拷贝一个对象

在Python中,无论是对象赋值，作为为参数传递,作为函数返回值,都是引用传递的.如果需要拷贝对象，需要使用标准库中的copy模块（import copy）。

1.浅拷贝 ：

    使用copy.copy,它可以进行对象的浅拷贝(shallow copy),它复制了对象,但对于对象中的元素,依然使用引用（换句话说修改拷贝对象元素，则被拷贝对象元素也被修改）

2.深拷贝 ：

    使用copy.deepcopy，它可以进行深拷贝，不仅拷贝了对象，同时也拷贝了对象中的元素，获得了全新的对象，与被拷贝对象完全独立，但这需要牺牲一定的时间和空间。