1.is 与 == 的区别
1 Python中万物皆对象，每个对象都包含3个属性：id,type,value. 2 1.id就是对象地址，可以通过内置函数id()查看对象引用的地址。 3 2.type就是对象类型，可以通过内置函数type()查看对象的类型. 4 3.value就是对象的值。 5 6 is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同； 7 ==比较操作符：用来比较两个对象是否相等，value做为判断因素
2.类中的@classmethod、@staticmethod和@property的用法和效果。
@classmethod、@staticmethod 介绍
1 python中，一般方法的调用，是用类的实例对象来调用，但是使用@classmethod ,@staticmethod 时，直接用类名来调用。 2 用处：把一些功能与某个类相近的函数处理，可以写在类中，用这两个方法装饰，以便达到组织代码，使得代码相关性清晰的效果。 3 4 两者的区别： 5 @staticmethod 就跟使用函数一样，不需要表示自身对象的self和自身类的cls参数； 6 @classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。 7 因为@classmethod 传入了cls参数，代指当前的这个类，就可以调用当前类的属性，方法，实例化对象等，个人觉得这个与类的关系更加紧密一些。 8 9 class A(object): 10 bar = 1 11 def foo(self): 12 print 'foo' 13 14 @staticmethod 15 def static_foo(): 16 print 'static_foo' 17 print A.bar 18 19 @classmethod 20 def class_foo(cls): 21 print 'class_foo' 22 print cls.bar # 这里直接调用了类的属性 23 cls().foo() # 调用了类的foo方法 24 25 A.static_foo() 26 A.class_foo()
======================== @property 的用法 ============================
@@property 即是python内置的一个装饰器，用于把一个方法变成属性方式调用，
property() 方法的语法: class property([fget[, fset[, fdel[, doc]]]])
- fget -- 获取属性值的函数
- fset -- 设置属性值的函数
- fdel -- 删除属性值函数
- doc -- 属性描述信息
举个栗子：定义一个可控属性值 x
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
c = C()
c.x 将触发 getter;
c.x = value 将触发 setter ;
del c.x 触发 deleter。
3.python的反射(自省)
1 大白话就是： 2 利用字符串的形式去对象(模块)中操作(寻找/检查/删除/设置)成员。 3 4 用法一：模块中 5 在模块中找到某个方法、或者属性， 6 假如同一个文件中的两个py文件，a.py,b.py,我们在b中需要检查a模块中，是否有text函数，如果有则可以执行。 7 8 import a 9 10 if hasattr(a ,'text'): #判断有没有这个函数，字符串形式 11 fuc = getattr(a,'text') #获得这个方法 12 fuc() #会调用 a.py文件里面的方法 text这个函数，并执行 13 else: 14 print('404')
用法二：在对象中寻找是否有方法，或者属性
class A():
def hello():
print('你好！')
a = A()
if hasattr(a,'hello'):
func = getattr(a,'hello') # 拿到指定的方法
func() # 执行
else:
print('404')
4.python的各种推导式
1 1.列表推导式： 2 是Python中的一种“语法糖”，也就是说列表生成式应该是Python提供的一种生成列表的简洁形式，应用列表生成式可以快速生成一个新的list。它最主要的应用场景是：根据已存在的可迭代对象推导出一个新的list。 3 4 --过滤出一个指定的数字列表中值大于20的元素： 5 L = [2,3,4,5,8,9,34,33,23] 6 li = [x for x in L if x > 20] 7 8 --将一个字典转换成由一组元组组成的列表，元组的格式为(key, value) 9 D = {'Tom': 15, 'Jerry': 18, 'Peter': 13} 10 li = [(k, v) for k, v in D.items()] 11 12 --使用()生成generator 13 将俩表推导式的[]改成()即可得到生成器。 14 15 2.字典推导式 16 --字典推导和列表推导的使用方法是类似的，只不中括号该改成大括号 17 --示例：快速更换key和value 18 19 mcase = {'a': 10, 'b': 34} 20 mcase_frequency = {v: k for k, v in mcase.items()} 21 22 23 3.集合推导式： 24 跟列表推导式也是类似的。 唯一的区别在于它使用大括号{} 25 squared = {x**2 for x in [1, 1, 2]}
5.函数中的*args,**kwargs
1 用于函数的形式参数，当我们定义函数的时候，不确定参数的个数时用， 2 *args.可以传递任意数量的位置参数: 以元组形式存储 3 **kwargs可以传递任意数量的关键字参数： 以字典形式存储 4 *args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面；
6.单例模式
1 1.为什么要用单例模式： 2 --性能方面：当每个实例都会占用资源，而且实例初始化会影响性能，这个时候就可以考虑使用单例模式，它给我们带来的好处是只有一个实例占用资源，并且只需初始化一次。 3 4 --数据的同步。在一个对象中封装要使用的数据，在各个地方调用数据时，数据不会出现错乱的情况，以达到数据同步的效果。 5 6 2.单例实现的4种方法： 7 详情地址：http://www.cnblogs.com/fengqing89/p/8440840.html 8 --模块方式 9 --实用类 10 --基于__new__方法实现（推荐使用，方便） 11 --基于metaclass方式实现
7.lambda函数
1 通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。 2 3 与filter，map，reduce函数的连用 4 li = [2, 18, 9, 22, 17, 24, 8, 12, 27] 5 6 filter(lambda x: x % 3 == 0, li) # 返回值[18, 9, 24, 12, 27] 7 8 map(lambda x: x * 2 + 10, li) # 返回值[14, 46, 28, 54, 44, 58, 26, 34, 64] 9 10 reduce(lambda x, y: x + y, foo) # 返回值139
reduce 函数
示例：
def f(x, y): return x + y reduce(f,[1,2,3,4,5]) # python3中从全局空间移除了，
执行步骤是：
1.
先计算头两个元素：f(1, 2)，结果为3； 2.
再把结果和第3个元素计算：f(3, 3)，结果为6，最后没有更多的数字是，返回结果，
8.可变对象和不可变对象 (看内存地址，id(变量))
1 在python中，可变对象指对象创建之后，值发生改变时，内存地址不会发生改变；dict，list, 2 3 不可变对象指，当值发生改变时，内存地址也发生改变。str, int, tuple, float 4 5 示例： 6 def test(a=[]): 7 a.append(1) 8 a=['egon','alex'] 9 test(a) 10 print(a) # ['egon', 'alex', 1] 11 test(a) 12 print(a) # ['egon', 'alex', 1, 1] 调用第二次的时候，会改变这个列表的值
9.祛除一个列表中的重复内容，原顺序不变
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"])
10.List = [-2, 1, 3, -6]，如何实现以绝对值大小从小到大将 List 中内容排序。
1 li.sort(key=abs,reverse=False) #按照内置函数abs,是否降序：False 2 3 li = [1, -2, 3, -6] # 改变了原来的li
(1) 列表的sort方法和 sorted的区别是什么？
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] res = sorted(students,key=lambda s:s[2],reverse=False) # print(students) # [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] # 原来的列表还是没变 print(res) # [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] # 返回新的结果