Python编程常见问题

形参和实参之间有什么区别？¶

形参 是指出现在函数定义中的名称，而 实参 则是在调用函数时实际传入的值。 形参定义了一个函数能接受何种类型的实参。 例如，对于以下函数定义:

deffunc(foo,bar=None,**kwargs):
pass

foo, bar 和 kwargs 是 func 的形参。 但是，在调用 func 时，例如：

func(42,bar=314,extra=somevar)

实际的值 42, 314 和 somevar 则是实参。

为什么更改列表 'y' 也会更改列表 'x'？¶

如果你编写的代码就像下面一样：

>>> x=[]
>>> y=x
>>> y.append(10)
>>> y
[10]
>>> x
[10]

你可能想知道为什么追加一个元素也改变了x。

产生这种结果有两个因素：

1. 变量只是指向具体对象的名称。 执行 y=x 并不会为列表创建一个副本 —— 它只是创建了一个新变量 y 指向 x 所指向的同一对象。 这意味着只存在一个对象（列表），x 和 y 都是对它的引用。

2. 列表属于 mutable 对象，这意味着你可以改变它的内容。

在调用 append() 之后，这个可变对象的内容由 [] 变为 [10]。 由于两个变量都指向同一对象，因此使用任何一个名称所访问到的都是修改后的值 [10]。

如果我们改为将不可变对象赋值给 x:

>>> x=5# ints are immutable
>>> y=x
>>> x=x+1# 5 can't be mutated, we are creating a new object here
>>> x
6
>>> y
5

我们可以看到在此情况下 x 和 y 就不再相等了。 这是因为整数是 immutable 对象，当我们执行 x=x+1 时我们并不是改变了 5 这个对象的值；而是创建了一个新的对象 (整数 6) 并将其赋值给 x (也就是改变了 x 所指向的对象)。 在赋值之后我们就有了两个对象 (整数 6 和 5) 以及分别指向它们的两个变量 (x 现在指向 6 而 y 仍然指向 5)。

某些操作 (例如 y.append(10) 和 y.sort()) 是改变原对象，而看上去相似的另一些操作 (例如 y=y+[10] 和 sorted(y)) 则是创建新对象。 通常在 Python 中 (以及在标准库的所有代码中) 会改变原对象的方法将返回 None 以帮助避免混淆这两种不同类型的操作。 因此如果你错误地使用了 y.sort() 并期望它将返回一个经过排序的 y 的副本，你得到的结果将会是 None，这将导致你的程序产生一个容易诊断的错误。

但是，还存在一类操作，不同的类型执行相同的操作会有不同的行为：那就是增强赋值运算符。 例如，+= 会原地改变列表，但不会改变元组或整数 (a_list+=[1,2,3] 与 a_list.extend([1,2,3]) 一样都会改变 a_list，而 some_tuple+=(1,2,3) 和 some_int+=1 则会创建新的对象)。

换而言之：

• 如果我们有一个可变对象 (list, dict, set 等等)，我们可以使用某些特定的操作来改变它，所有指向它的变量都会显示它的改变。

• 如果我们有一个不可变对象 (str, int, tuple 等等)，所有指向它的变量都将显示相同样的值，但凡是会改变这个值的操作将总是返回一个新对象。

如果你想知道两个变量是否指向相同的对象，你可以使用 is 运算符，或内置函数 id()。

如何编写带输出参数的函数（通过引用调用）？¶

请记住在 Python 中参数是通过赋值来传递的。 由于赋值只是创建了对象的引用，因此在调用者和被调用者的参数名称之间没有别名，所以本身是没有按引用调用的。 你可以通过多种方式实现所需的效果。

1. 通过返回一个结果元组:

   deffunc2(a,b):
   a='new-value'# a and b are local names
   b=b+1# assigned to new objects
   returna,b# return new values
   x,y='old-value',99
   x,y=func2(x,y)
   print(x,y)# output: new-value 100
   

   这几乎总是最清晰明了的解决方案。

2. 通过使用全局变量。 这种方式不是线程安全的，而且也不受推荐。

3. 通过传递一个可变 (即可原地修改的) 对象:

   deffunc1(a):
   a[0]='new-value'# 'a' references a mutable list
   a[1]=a[1]+1# changes a shared object
   args=['old-value',99]
   func1(args)
   print(args[0],args[1])# output: new-value 100
   

4. 通过传递一个会被改变的字典:

   deffunc3(args):
   args['a']='new-value'# args is a mutable dictionary
   args['b']=args['b']+1# change it in-place
   args={'a':'old-value','b':99}
   func3(args)
   print(args['a'],args['b'])
   

5. 或者在一个类实例中捆绑值:

   classcallByRef:
   def__init__(self,**args):
   for(key,value)inargs.items():
   setattr(self,key,value)
   deffunc4(args):
   args.a='new-value'# args is a mutable callByRef
   args.b=args.b+1# change object in-place
   args=callByRef(a='old-value',b=99)
   func4(args)
   print(args.a,args.b)
   

   几乎没有任何适当理由将问题如此复杂化。

你的最佳选择是返回一个包含多个结果的元组。

如何在Python中创建高阶函数？¶

你有两种选择：使用嵌套作用域，或者使用可调用对象。 例如，假设你想要定义 linear(a,b) 使其返回一个函数 f(x) 来设计 a*x+b 的值。 可以使用以下嵌套作用域:

deflinear(a,b):
defresult(x):
returna*x+b
returnresult

或使用一个可调用对象:

classlinear:
def__init__(self,a,b):
self.a,self.b=a,b
def__call__(self,x):
returnself.a*x+self.b

在两种情况下，:

taxes=linear(0.3,2)

都会给出一个可调用对象，使得 taxes(10e6)==0.3*10e6+2.

可调用对象方式的缺点是速度略慢且生成的代码略长。 但是，请注意一组可调用对象能够通过继承来共享签名:

classexponential(linear):
# __init__ inherited
def__call__(self,x):
returnself.a*(x**self.b)

对象可以封装多个方法的状态:

classcounter:
value=0
defset(self,x):
self.value=x
defup(self):
self.value=self.value+1
defdown(self):
self.value=self.value-1
count=counter()
inc,dec,reset=count.up,count.down,count.set

这里 inc(), dec() 和 reset() 将表现为共享同一计数变量的多个函数。

如何在Python中复制对象？¶

一般来说，通常情况下请尝试 copy.copy() 或 copy.deepcopy()。 不是所有对象都可以复制，但多数都是可以的。

某些对象可以方便地复制。 例如字典具有 copy() 方法:

newdict=olddict.copy()

序列可以通过切片来复制:

new_l=l[:]

>>> classA:
... pass
...
>>> B=A
>>> a=B()
>>> b=a
>>> print(b)
<__main__.A object at 0x16D07CC>
>>> print(a)
<__main__.A object at 0x16D07CC>

>>> "a"in"b","a"
(False, 'a')

("a"in"b"),"a"

"a"in("b","a")

[on_true]if[expression]else[on_false]
x,y=50,25
small=xifx<yelsey

[expression]and[on_true]or[on_false]

fromfunctoolsimportreduce
# Primes < 1000
print(list(filter(None,map(lambday:y*reduce(lambdax,y:x*y!=0,
map(lambdax,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))))
# First 10 Fibonacci numbers
print(list(map(lambdax,f=lambdax,f:(f(x-1,f)+f(x-2,f))ifx>1else1:
f(x,f),range(10))))
# Mandelbrot set
print((lambdaRu,Ro,Iu,Io,IM,Sx,Sy:reduce(lambdax,y:x+y,map(lambday,
Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambdayc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
Sx=Sx,Sy=Sy:reduce(lambdax,y:x+y,map(lambdax,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
i=i,Sx=Sx,F=lambdaxc,yc,x,y,k,f=lambdaxc,yc,x,y,k,f:(k<=0)or(x*x+y*y
>=4.0)or1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
))))(-2.1,0.7,-1.2,1.2,30,80,24))
#    \___ ___/  \___ ___/  |   |   |__ lines on screen
#        V          V      |   |______ columns on screen
#        |          |      |__________ maximum of "iterations"
#        |          |_________________ range on y axis
#        |____________________________ range on x axis

>>> help(pow)
Help on built-in function pow in module builtins:
pow(x, y, z=None, /)
   Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
   Some types, such as ints, are able to use a more efficient algorithm when
   invoked using the three argument form.

>>> pow(x=3,y=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow() takes no keyword arguments

>>> a=0o10
>>> a
8

>>> a=0xa5
>>> a
165
>>> b=0XB2
>>> b
178

i==(i//j)*j+(i%j)

>>> importio
>>> s="Hello, world"
>>> sio=io.StringIO(s)
>>> sio.getvalue()
'Hello, world'
>>> sio.seek(7)
7
>>> sio.write("there!")
6
>>> sio.getvalue()
'Hello, there!'
>>> importarray
>>> a=array.array('u',s)
>>> print(a)
array('u', 'Hello, world')
>>> a[0]='y'
>>> print(a)
array('u', 'yello, world')
>>> a.tounicode()
'yello, world'

>>> lines=("line 1 \r\n"
... "\r\n"
... "\r\n")
>>> lines.rstrip("\n\r")
'line 1 '

chunks=[]
forsinmy_strings:
chunks.append(s)
result=''.join(chunks)

result=bytearray()
forbinmy_bytes_objects:
result+=b

forxinreversed(sequence):
...# do something with x ...

forxinsequence[::-1]:
...# do something with x ...

ifmylist:
mylist.sort()
last=mylist[-1]
foriinrange(len(mylist)-2,-1,-1):
iflast==mylist[i]:
delmylist[i]
else:
last=mylist[i]

mylist=list(set(mylist))

["this",1,"is","an","array"]

lisp_list=("like",("this",("example",None)))

>>> A=[[None]*2]*3

>>> A
[[None, None], [None, None], [None, None]]

>>> A[0][0]=5
>>> A
[[5, None], [5, None], [5, None]]

A=[None]*3
foriinrange(3):
A[i]=[None]*2

w,h=2,3
A=[[None]*wforiinrange(h)]

result=[obj.method()forobjinmylist]

>>> a_tuple=(1,2)
>>> a_tuple[0]+=1
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

>>> result=a_tuple[0]+1
>>> a_tuple[0]=result
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

>>> a_tuple=(['foo'],'bar')
>>> a_tuple[0]+=['item']
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

>>> a_tuple[0]
['foo', 'item']

>>> a_list=[]
>>> a_list+=[1]
>>> a_list
[1]

>>> result=a_list.__iadd__([1])
>>> a_list=result

>>> result=a_tuple[0].__iadd__(['item'])
>>> a_tuple[0]=result
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

Isorted=L[:]
Isorted.sort(key=lambdas:int(s[10:15]))

>>> list1=["what","I'm","sorting","by"]
>>> list2=["something","else","to","sort"]
>>> pairs=zip(list1,list2)
>>> pairs=sorted(pairs)
>>> pairs
[("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
>>> result=[x[1]forxinpairs]
>>> result
['else', 'sort', 'to', 'something']

>>> result=[]
>>> forpinpairs:result.append(p[1])

classC:
defmeth(self,arg):
returnarg*2+self.attribute

defsearch(obj):
ifisinstance(obj,Mailbox):
...# code to search a mailbox
elifisinstance(obj,Document):
...# code to search a document
elif...

classMailbox:
defsearch(self):
...# code to search a mailbox
classDocument:
defsearch(self):
...# code to search a document
obj.search()

classUpperOut:
def__init__(self,outfile):
self._outfile=outfile
defwrite(self,s):
self._outfile.write(s.upper())
def__getattr__(self,name):
returngetattr(self._outfile,name)

classX:
...
def__setattr__(self,name,value):
self.__dict__[name]=value
...

classDerived(Base):
defmeth(self):
super(Derived,self).meth()

BaseAlias=<realbaseclass>
classDerived(BaseAlias):
defmeth(self):
BaseAlias.meth(self)
...

classC:
count=0# number of times C.__init__ called
def__init__(self):
C.count=C.count+1
defgetcount(self):
returnC.count# or return self.count

C.count=314

classC:
@staticmethod
defstatic(arg1,arg2,arg3):
# No 'self' parameter!
...

defgetcount():
returnC.count

classC{
C(){cout<<"No arguments\n";}
C(inti){cout<<"Argument is "<<i<<"\n";}
}

classC:
def__init__(self,i=None):
ifiisNone:
print("No arguments")
else:
print("Argument is",i)

def__init__(self,*args):
...

>>> id(1000)
13901272
>>> id(2000)
13901272

>>> a=1000;b=2000
>>> id(a)
13901272
>>> id(b)
13891296

>>> importpy_compile
>>> py_compile.compile('foo.py')

python-mcompileall.

defmain():
print('Running test...')
...
if__name__=='__main__':
main()

frombarimportbar_var
foo_var=1

fromfooimportfoo_var
bar_var=2

z=importlib.import_module('x.y.z')

importimportlib
importmodname
importlib.reload(modname)

frommodnameimportsome_objects

>>> importimportlib
>>> importcls
>>> c=cls.C()# Create an instance of C
>>> importlib.reload(cls)
<module 'cls' from 'cls.py'>
>>> isinstance(c,cls.C)# isinstance is false?!?
False

>>> hex(id(c.__class__))
'0x7352a0'
>>> hex(id(cls.C))
'0x4198d0'