没有合适的资源?快使用搜索试试~ 我知道了~
温馨提示
试读
40页
最全BATPython⾯试题及答案 最全BATPython⾯试题及答案 Python语⾔特性 1 Python的函数参数传递 看两个如下例⼦,分析运⾏结果: 代码⼀: a = 1 def fun(a): a = 2 fun(a) print(a) # 1 代码⼆: a = [] def fun(a): a.append(1) fun(a) print(a) # [1] 所有的变量都可以理解是内存中⼀个对象的"引⽤",或者,也可以看似c中void*的感觉。 这⾥记住的是类型是属于对象的,⽽不是变量。⽽对 象有两种,"可更改"(mutable)与"不可更改"(immutable)对象。在python中,strings, tuples, 和numbers是不可更改的对象,⽽ list,dict等则是可以修改的对象。(这就是这个问题的重点) 当⼀个引⽤传递给函数的时候,函数⾃动复制⼀份引⽤,这个函数⾥的引⽤和外边的引⽤没 有半⽑关系了.所以第⼀个例⼦⾥函数把引⽤指向了⼀个不可变对象,当函数返回的时候,外⾯的引⽤没半⽑感觉.⽽第⼆个例⼦就不⼀样了,函数内的 引⽤指向的是可变对象,对它的操作就和定
资源推荐
资源详情
资源评论
最全BATPython⾯试题及答案最全BATPython⾯试题及答案
Python语⾔特性
1 Python的函数参数传递
看两个如下例⼦,分析运⾏结果: 代码⼀:
a = 1 def fun(a): a = 2 fun(a) print(a) # 1
代码⼆:
a = [] def fun(a): a.append(1) fun(a) print(a) # [1]
所有的变量都可以理解是内存中⼀个对象的“引⽤”,或者,也可以看似c中void*的感觉。 这⾥记住的是类型是属于对象的,⽽不是变量。⽽对
象有两种,“可更改”(mutable)与“不可更改”(immutable)对象。在python中,strings, tuples, 和numbers是不可更改的对象,⽽
list,dict等则是可以修改的对象。(这就是这个问题的重点) 当⼀个引⽤传递给函数的时候,函数⾃动复制⼀份引⽤,这个函数⾥的引⽤和外边的引⽤没
有半⽑关系了.所以第⼀个例⼦⾥函数把引⽤指向了⼀个不可变对象,当函数返回的时候,外⾯的引⽤没半⽑感觉.⽽第⼆个例⼦就不⼀样了,函数内的
引⽤指向的是可变对象,对它的操作就和定位了指针地址⼀样,在内存⾥进⾏修改.
2 Python中的元类(metaclass)
元类就是⽤来创建类的“东西”。你创建类就是为了创建类的实例对象,但是我们已经学习到了Python中的类也是对象。好吧,元类就是⽤来创
建这些类(对象)的,元类就是类的类 这个⾮常的不常⽤,详情请看:《深刻理解Python中的元类(metaclass)》
3 @staticmethod和@classmethod
Python其实有3个⽅法,即静态⽅法(staticmethod),类⽅法(classmethod)和实例⽅法,如下:
class A(object): def foo(self,x): print "executing foo(%s,%s)"%(self,x)
@classmethod
def class_foo(cls,x):
print( "executing class_foo(%s,%s)"%(cls,x))
@staticmethod
def static_foo(x):
print ("executing static_foo(%s)"%x)
a=A() 这⾥先理解下函数参数⾥⾯的self和cls.这个self和cls是对类或者实例的绑定.对于实例⽅法,我们知道在类⾥每次定义⽅法的时候都需要绑定
这个实例,就是foo(self, x),为什么要这么做呢?因为实例⽅法的调⽤离不开实例,我们需要把实例⾃⼰传给函数,调⽤的时候是这样的a.foo(x)(其实是
foo(a, x)).类⽅法⼀样,只不过它传递的是类⽽不是实例,A.class_foo(x).注意这⾥的self和cls可以替换别的参数,但是python的约定是这俩,还是不
要改的好. 对于静态⽅法其实和普通的⽅法⼀样,不需要对谁进⾏绑定,唯⼀的区别是调⽤的时候需要使⽤a.static_foo(x)或者A.static_foo(x)来调
⽤. \ 实例⽅法 类⽅法 静态⽅法 a = A() a.foo(x) a.class_foo(x) a.static_foo(x) A 不可⽤ A.class_foo(x) A.static_foo(x)
4 类变量和实例变量
class Person:
name="aaa"
p1=Person() p2=Person() p1.name="bbb" print(p1.name) # bbb print(p2.name) # aaa print(Person.name) # aaa 类变量就是供类使
⽤的变量,实例变量就是供实例使⽤的. 这⾥p1.name="bbb"是实例调⽤了类变量,这其实和上⾯第⼀个问题⼀样,就是函数传参的问题,p1.name⼀
开始是指向的类变量name="aaa",但是在实例的作⽤域⾥把类变量的引⽤改变了,就变成了⼀个实例变量,self.name不再引⽤Person的类变量
name了. 可以看看下⾯的例⼦:
class Person:
name=[]
p1=Person() p2=Person() p1.name.append(1) print(p1.name) # [1] print(p2.name) # [1] print(Person.name) # [1]
5 Python⾃省
这个也是python彪悍的特性. ⾃省就是⾯向对象的语⾔所写的程序在运⾏时,所能知道对象的类型.简单⼀句就是运⾏时能够获得对象的类型.⽐如
type(),dir(),getattr(),hasattr(),isinstance().
6 字典推导式
可能你见过列表推导时,却没有见过字典推导式,在2.7中才加⼊的: d = {key: value for (key, value) in iterable}
7 Python中单下划线和双下划线
1 >>> class MyClass():
2 ... def __init__(self):
3 ... self.__superprivate = "Hello"
4 ... self._semiprivate = ", world!"
5 ...
6 >>> mc = MyClass()
7 >>> print(mc.__superprivate)
8 Traceback (most recent call last):
9 File "<stdin>", line 1, in <module>
10 AttributeError: myClass instance has no attribute '__superprivate'
11 >>> print(mc._semiprivate)
12 , world!
13 >>> print mc.__dict__
14 {'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}
8 字符串格式化:%和.format
.format在许多⽅⾯看起来更便利.对于%最烦⼈的是它⽆法同时传递⼀个变量和元组.你可能会想下⾯的代码不会有什么问题: Python: "hi there
%s" % name 但是,如果name恰好是(1,2,3),它将会抛出⼀个TypeError异常.为了保证它总是正确的,你必须这样做: "hi there %s" % (name,) #
提供⼀个单元素的数组⽽不是⼀个参数
9 迭代器和⽣成器
在Python中,这种⼀边循环⼀边计算的机制,称为⽣成器:generator。 可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器:
Iterator。
10 * args and ** kwargs
⽤args和**kwargs只是为了⽅便并没有强制使⽤它们. 当你不确定你的函数⾥将要传递多少参数时你可以⽤args.例如,它可以传递任意数量的参数:
1 >>> def print_everything(*args):
2 for count, thing in enumerate(args):
3 ... print '{0}. {1}'.format(count, thing)
4 ..
5 >>> print_everything('apple', 'banana', 'cabbage')
6 0. apple
7 1. banana
8 2. cabbage
相似的 ** kwargs允许你使⽤没有事先定义的参数名:
1 >>> def table_things(**kwargs):
2 ... for name, value in kwargs.items():
3 ... print '{0} = {1}'.format(name, value)
4 ...
5 >>> table_things(apple = 'fruit', cabbage = 'vegetable')
6 cabbage = vegetable
7 apple = fruit
你也可以混着⽤.命名参数⾸先获得参数值然后所有的其他参数都传递给*args和**kwargs.命名参数在列表的最前端.例如:
1 def table_things(titlestring, ** kwargs)
args和** kwargs可以同时在函数的定义中,但是args必须在**kwargs前⾯. 当调⽤函数时你也可以⽤和**语法.例如:
1 >>> def print_three_things(a, b, c):
2 ... print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
3 ...
4 >>> mylist = ['aardvark', 'baboon', 'cat']
5 >>> print_three_things(*mylist)
6
7 a = aardvark, b = baboon, c = cat
11 ⾯向切⾯编程AOP和装饰器
12 鸭⼦类型
“当看到⼀只鸟⾛起来像鸭⼦、游泳起来像鸭⼦、叫起来也像鸭⼦,那么这只鸟就可以被称为鸭⼦。” 我们并不关⼼对象是什么类型,到底是不
是鸭⼦,只关⼼⾏为。 ⽐如在python中,有很多file-like的东西,⽐如StringIO,GzipFile,socket。它们有很多相同的⽅法,我们把它们当作⽂件
使⽤。 ⼜⽐如list.extend()⽅法中,我们并不关⼼它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/⽣成器等. 鸭
⼦类型在动态语⾔中经常使⽤,⾮常灵活,使得python不想java那样专门去弄⼀⼤堆的设计模式。
13 Python中重载
可变参数类型。
可变参数个数。 另外,⼀个基本的设计原则是,仅仅当两个函数除了参数类型和参数个数不同以外,其功能是完全相同的,此时才使⽤函数重
载,如果两个函数的功能其实不同,那么不应当使⽤重载,⽽应当使⽤⼀个名字不同的函数。 好吧,那么对于情况 1 ,函数功能相同,但是参数
类型不同,python 如何处理?答案是根本不需要处理,因为 python 可以接受任何类型的参数,如果函数的功能相同,那么不同的参数类型在
python 中很可能是相同的代码,没有必要做成两个不同函数。 那么对于情况 2 ,函数功能相同,但参数个数不同,python 如何处理?⼤家知
道,答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同,那么那些缺少的参数终归是需要⽤的。 好
了,鉴于情况 1 跟 情况 2 都有了解决⽅案,python ⾃然就不需要函数重载了。
14 新式类和旧式类
15 __new__和__init__的区别;
这个__new__确实很少见到,先做了解吧.
1. __new__是⼀个静态⽅法,⽽__init__是⼀个实例⽅法.
2. __new__⽅法会返回⼀个创建的实例,⽽__init__什么都不返回.
3. 只有在__new__返回⼀个cls的实例时后⾯的__init__才能被调⽤.
4. 当创建⼀个新实例时调⽤__new__,初始化⼀个实例时⽤__init__.
ps: __metaclass__是创建类时起作⽤.所以我们可以分别使⽤__metaclass__,__new__和__init__来分别在类创建,实例创建和实例初始化的时候做
⼀些⼩⼿脚.
16 单例模式
这个绝对常考啊.绝对要记住1~2个⽅法,当时⾯试官是让⼿写的.
1 使⽤__new__⽅法
class Singleton(object):
def __new__(cls, *args, **kw):
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kw)
return cls._instance
class MyClass(Singleton):
a = 1
2 共享属性
创建实例时把所有实例的__dict__指向同⼀个字典,这样它们具有相同的属性和⽅法.
1 class Borg(object):
2 _state = {}
3 def __new__(cls, *args, **kw):
4 ob = super(Borg, cls).__new__(cls, *args, **kw)
5 ob.__dict__ = cls._state
6 return ob
7
8 class MyClass2(Borg):
9 a = 1
3 装饰器版本
1 def singleton(cls, *args, **kw):
2 instances = {}
3 def getinstance():
4 if cls not in instances:
5 instances[cls] = cls(*args, **kw)
6 return instances[cls]
7 return getinstance
8
9 @singleton
10 class MyClass:
4 import⽅法
作为python的模块是天然的单例模式
# mysingleton.py
class My_Singleton(object):
def foo(self):
pass
剩余39页未读,继续阅读
资源评论
小虾仁芜湖
- 粉丝: 86
- 资源: 9357
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功