面试题_day0211

1.is 与 == 的区别

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

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

 

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

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

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

class A(object):  
    bar = 1  
    def foo(self):  
        print 'foo'  
 
    @staticmethod  
    def static_foo():  
        print 'static_foo'  
        print A.bar  
 
    @classmethod  
    def class_foo(cls):  
        print 'class_foo'  
        print cls.bar             # 这里直接调用了类的属性
        cls().foo()               # 调用了类的foo方法
  
A.static_foo()  
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的反射(自省)

大白话就是：
利用字符串的形式去对象(模块)中操作(寻找/检查/删除/设置)成员。

用法一：模块中
在模块中找到某个方法、或者属性，
假如同一个文件中的两个py文件，a.py,b.py,我们在b中需要检查a模块中，是否有text函数，如果有则可以执行。

import a

if hasattr(a ,'text'):  #判断有没有这个函数，字符串形式
    fuc = getattr(a,'text')  #获得这个方法  
       fuc()   #会调用 a.py文件里面的方法  text这个函数，并执行
    else:  
        print('404')  

用法二：在对象中寻找是否有方法，或者属性
class A():
　　def hello():
　　　　print('你好！')

a = A()

if hasattr(a,'hello'):
　　func = getattr(a,'hello')  # 拿到指定的方法
　　func()　　　　　　　　　　　　　# 执行
else:
　　print('404')

 

4.python的各种推导式

1.列表推导式：
是Python中的一种“语法糖”，也就是说列表生成式应该是Python提供的一种生成列表的简洁形式，应用列表生成式可以快速生成一个新的list。它最主要的应用场景是：根据已存在的可迭代对象推导出一个新的list。

--过滤出一个指定的数字列表中值大于20的元素：
L = [2,3,4,5,8,9,34,33,23]
li = [x for x in L if x > 20]

--将一个字典转换成由一组元组组成的列表，元组的格式为(key, value)
D = {'Tom': 15, 'Jerry': 18, 'Peter': 13}
li = [(k, v) for k, v in D.items()]

--使用()生成generator
将俩表推导式的[]改成()即可得到生成器。

2.字典推导式
--字典推导和列表推导的使用方法是类似的，只不中括号该改成大括号
--示例：快速更换key和value

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}


3.集合推导式：
跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}
squared = {x**2 for x in [1, 1, 2]}

 

5.函数中的*args,**kwargs

用于函数的形式参数，当我们定义函数的时候，不确定参数的个数时用，
*args.可以传递任意数量的位置参数:    以元组形式存储
**kwargs可以传递任意数量的关键字参数： 以字典形式存储
*args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面；

 

6.单例模式

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

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

2.单例实现的4种方法：
详情地址：http://www.cnblogs.com/fengqing89/p/8440840.html
--模块方式
--实用类
--基于__new__方法实现（推荐使用，方便）
--基于metaclass方式实现

 

7.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

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(变量))

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

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

示例：
def test(a=[]):
    a.append(1)
a=['egon','alex']
test(a)
print(a)     # ['egon', 'alex', 1]
test(a)
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 中内容排序。

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

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)]   # 返回新的结果