引言
提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python 对面向对象的支持。
在讨论Python的OOP之前，先看几个OOP术语的定义：
?类：对具有相同数据和方法的一组对象的描述或定义。
?对象：对象是一个类的实例。
?实例(instance)：一个对象的实例化实现。
?标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。
?实例属性（instance attribute）：一个对象就是一组属性的集合。
?实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。
?类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化
?类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。
1.Python中的类与对象
Python中定义类的方式比较简单：
class类名：
类变量
def __init__(self,paramers):
def函数(self,...)
其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self
作为第一个参数。
举例：
class MyFirstTestClass:
classSpec="itis a test class"
def__init__(self,word):
print"say "+word
defhello(self,name):
print"hello "+name
在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。
class MethodTest():
count= 0
defaddCount(self):
MethodTest.count+=1
print"I am an instance method,my count is"+str(MethodTest.count),self @staticmethod
defstaticMethodAdd():
MethodTest.count+=1
print"I am a static methond,my count is"+str(MethodTest.count) @classmethod
defclassMethodAdd(cls):
MethodTest.count+=1
print"I am a class method,my count is"+str(MethodTest.count),cls
a=MethodTest()
a.addCount()
'''Iam an instance method,my count is 1 <__main__.MethodTest instanceat
0x011EC990>
'''
a.staticMethodAdd();#Iam a static methond,my count is2
MethodTest.staticMethodAdd() ;#Iam a static methond,my count is3
a.classMethodAdd() ;#Iam a class method,my count is4 __main__.MethodTest MethodTest.classMethodAdd();#Iam a class method,my count is5 __main__.MethodTest MethodTest.addCount()
'''Traceback(most recent call last):
File"
MethodTest.addCount()
TypeError:unbound method addCount() must be called with MethodTest instance asfirst argument (got nothing instead)
'''
从上面的例子来看，静态方法和类方法基本上区别不大，特别是有Java编程基础的人会简单的认为静态方法和类方法就是一回事，可是在Python中事实是这样的吗？看下面的例子：
MethodTest.classMethodAdd();#Iam a class method,my count is5 __main__.MethodTest class subMethodTest(MethodTest):
pass
b=subMethodTest()
b.staticMethodAdd() ;#Iam a static methond,my count is6
b.classMethodAdd() ;#Iam a class method,my count is7 __main__.subMethodTest a.classMethodAdd() ;#Iam a class method,my count is8 __main__.MethodTest
如果父类中定义有静态方法a(),在子类中没有覆盖该方法的话，Sub.a()仍然指的是父类的a（）方法。而如果a()是类方法的情况下，Sub.a()指向的是子类。@staticmethod只适用于不想定义全局函数的情况。
看看两者的具体定义：
@staticmethod function is nothing morethan a function defined inside a class. It is callable withoutinstantiating the class first. It’s definition is immutable viainheritance.
@classmethod function also callablewithout instantiating the class, but its definition follows Subclass, not Parent class, via inheritance. That’s because the firstargument for @classmethod function must always be cls (class).
?封装和访问控制
与Java不同，Python的访问控制相对简单，没有public，private，protected等属性，python认为用户在访问对象的属性的时候是明确自己在做什么的，因此认为私有数据不是
必须的，但是如果你必须实现数据隐藏，也是可以的，具体方法就是在变量名前加双下划线。如__privatedata=0，定义私有方法则是在方法名称前加上__下划线。但即使对于隐藏的数据，也是有一定的方法可以访问的。方法就是__className__attrName。Python对于私有变量会进行Namemangling是Python中为了方便定义私有的变量和方法，防止和继承类以及其他外部的变量或者方法冲突而采取的一种机制。在python中通过__spam定义的私有变量为最终
被翻译成_classname__spam，其中classname为类名，当类名是以_开头的时候则不会发生
Namemangling。Namemangling 存在的一个问题是当字符串长度超过255的时候则会发生截断。class PrivateTest:
__myownedata=12
def__myownmethod(self):
print"can you see me?"
defsayhi(self):
print"say hi"
class subPrivateTest(PrivateTest):
pass
subPrivateTest.__myownedata
Traceback(most recent call last):
File"
subPrivateTest.__myownedata
AttributeError:class subPrivateTest has no attribute '__myownedata' subPrivateTest._PrivateTest__myownedata
?构造函数和析构函数
Python的构造函数有两种，__init__和__new__,__init__的调用不会返回任何值，在继承
关系中，为了保证父类实例正确的初始化，最好显示的调用父类的__init__方法。与__init__不同，__new__实际是个类方法，以cls作为第一个参数。
如果类中同时定义了__init__和__new__方法，则在创建对象的时候会优先使用__new__.
class A(object):
def __init__(self):
print("in init")
def __new__(self):
print("in new")
A()
如果__new__需要返回对象，则会默认调用__init__方法。利用new创建一个类的对象的最
常用的方法为：super(currentclass,cls).__new__(cls[, ...])
class A(object):
def __new__(cls):
Object = super(A,cls).__new__(cls)
print "in New"
return Object
def __init__(self):
print "in init"
class B(A):
def __init__(self):
print "in B's init"
B()
__new__构造函数会可变类的定制的时候非常有用，后面的小节中会体现。
Python由于具有垃圾回收机制，通常不需要用户显示的去调用析构函数，即使调用，实例也不会立即释放，而是到该实例对象所有的引用都被清除掉后才会执行。
class P:
def__del__(self):
print"deleted"
class S(P):
def__init__(self):
print'initialized'
def__del__(self):
P.__del__(self)
print"child deleted"
a=S() #initialized
b=a
c=a
id(a),id(b),id(c) #(18765704,18765704, 18765704)
del a
del b
del c #deleted #childdeleted
绑定与非绑定
在前面的例子中我们讨论过类的实例方法必须通过实例调用，如果直接通过类去访问会抛出异常，这种通过实例来访问方法就叫绑定，调用的时候不需要显示传入self参数，而调用非绑定方法
需要显示传入self参数，比如当子类继承父类定义构造函数的时候，需要显示调用父类的构造
函数，但此时该方法并未与任何实例绑定，调用的时候需要使用superclassName.__init_(self)。静态方法可以直接被类或类实例调用。它没有常规方法那样的特殊行为（绑定、非绑定、默认的第一个参数规则等等）。完全可以将静态方法当成一个用属性引用方式调用的普通函数来看待。任何时候定义静态方法都不是必须的（静态方法能实现的功能都可以通过定义一个普通函数来实现）
3. Python中的继承
继承
Python同时支持单继承与多继承，继承的基本语法为class新类名（父类1，父类2,..）,当只有一个父类时为单继承，当存在多个父类时为多继承。子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。在传统类中，如果子类和父类中同名的方法或者属性，在查找的时候基本遵循自左到右，深度优先的原则。如下列：
>>>class A:
defsayhi(self):
print'I am A hi'
>>>class B:
defsayhi(self):
print'I am B Hi'
>>>class C(A,B):
pass
>>>d=C()
>>>d.sayhi()
Iam A hi
>>>B.sayhi(d)
Iam B Hi
如果想调用父类B的sayhi方法则需要使用B.sayhi(d).而在python引入新式类后，在继承关系中，方法和属性的搜索有所改变，使用C3算法。具体将在MRO中详细讨论。
关于继承的构造函数：
1. 如果子类没有定义自己的构造函数，父类的构造函数会被默认调用，但是此时如果
要实例化子类的对象，则只能传入父类的构造函数对应的参数，否则会出错classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
https://www.doczj.com/doc/3e2549494.html,= nm
self.phone= ph
print'Created instance for:', https://www.doczj.com/doc/3e2549494.html,
defupdatePhone(self, newph):
self.phone = newph
print'Updated phone# for:', https://www.doczj.com/doc/3e2549494.html,
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
defupdateEmail(self, newem):
self.email= newem
print'Updated e-mail address for:', https://www.doczj.com/doc/3e2549494.html,
john= EmplAddrBookEntry('John Doe', '408-555-1212')
https://www.doczj.com/doc/3e2549494.html,
2. 如果子类定义了自己的构造函数，而没有显示调用父类的构造函数，则父类的属性
不会被初始化
classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
https://www.doczj.com/doc/3e2549494.html,= nm
self.phone= ph
print'Created instance for:', https://www.doczj.com/doc/3e2549494.html,
defupdatePhone(self, newph):
self.phone = newph
print'Updated phone# for:', https://www.doczj.com/doc/3e2549494.html,
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
def__init__(self, nm, ph, id, em):
#AddrBookEntry.__init__(self, nm,ph)
self.empid= id
self.email= em
defupdateEmail(self, newem):
self.email= newem
print'Updated e-mail address for:', https://www.doczj.com/doc/3e2549494.html,
john= EmplAddrBookEntry('John Doe', '408-555-1212',42, 'john@spam.doe') printjohn.email
printjohn.empid
输出：
john@spam.doe
42
Traceback(most recent call last):
https://www.doczj.com/doc/3e2549494.html,
AttributeError:'EmplAddrBookEntry' object has no attribute 'name'
3. 如果子类定义了自己的构造函数，显示调用父类，子类和父类的属性都会被初始化classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
https://www.doczj.com/doc/3e2549494.html,= nm
self.phone= ph
print'Created instance for:', https://www.doczj.com/doc/3e2549494.html,
defupdatePhone(self, newph):
self.phone = newph
print'Updated phone# for:', https://www.doczj.com/doc/3e2549494.html,
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
def__init__(self, nm, ph, id, em):
AddrBookEntry.__init__(self, nm,ph)
self.empid= id
self.email= em
defupdateEmail(self, newem):
self.email= newem
print'Updated e-mail address for:', https://www.doczj.com/doc/3e2549494.html,
john= EmplAddrBookEntry('John Doe', '408-555-1212',42, 'john@spam.doe') printjohn.email
printjohn.empid
https://www.doczj.com/doc/3e2549494.html,
MRO
MRO：即methodresolutionorder.简单的说就是python针对多继承查找一个属性或者方法的一种算法。在引入新型类之前，MRO比较简单，采取自左到右，深度优先的原则。比如有如下关系的类和属性：
要查找对象x的attr属性，其根据自左到右，深度优先的原则，其搜索顺序为D,B,A,C,位于树结构底层的节点具有较高的level，当从高的level向低的level查找的时候遇到第一个属性则不再继续查找，因此上面的例子x的属性值为1.
>>> classA: attr=1
>>> classB(A):pass
>>> classC(A):attr=2
>>> classD(B,C):pass
>>> x=D()
>>> printx.attr
1
>>>
但按照多继承的理解，level高的属性应该覆盖了level低的属性，D同时继承于B,C，而C 是A的子类，那么D的实例的属性值理应为attr=2而不是1，产生这个问题的主要原因是在继承关系中产生了菱形，针对经典类的MRO算法有一定的局限性，特别是在python2.2中加入了新型类后，由于object是所有对象之母，很容易形成菱形。因此python2.2采用改进的C3MRO算法进行搜索。
算法描述：
假设https://www.doczj.com/doc/3e2549494.html,表示类节点[C1,C2,https://www.doczj.com/doc/3e2549494.html,)；
head=C1；
tail=https://www.doczj.com/doc/3e2549494.html,
C+(C1 https://www.doczj.com/doc/3e2549494.html,)=C https://www.doczj.com/doc/3e2549494.html,
若c继承于B1，B2..BN,那么在节点C的搜索顺序L[C]=C加上其所有父节点的搜索顺序和各个父节点的列表之和，也即
L[C(B1, ... , BN)]= C + merge(L[B1], ... ,L[BN], B1 ... BN)
其中merge的计算方法为:
如果B1不在其它列表的tail中，则将其并入C的搜索列表中，同时将其从merge列表中移除，否则跳过改节点，继续B2.。。如此重复知道merge为空。
如果C是object对象或者没有其他的父节点，则L[object]= object.。
对于单继承，则L[C(B)]= C + merge(L[B],B) = C + L[B]
假设有如下继承关系：
则：
L[O]= O
L[D]= D O
L[E]= E O
L[F]= F O
L[B]= B + merge(DO, EO, DE)
= B+D+merge(O,EO,E)
=B+D+merge(O,EO,E)
=B+D+E+merge(O,O)
=B D E O
L[A]= A + merge(BDEO,CDFO,BC)
=A + B + merge(DEO,CDFO,C)
=A + B + C + merge(DEO,DFO)
=A + B + C + D + merge(EO,FO)
=A + B + C + D + E + merge(O,FO)
=A + B + C + D + E + F + merge(O,O)
=A B C D E F O
针对上面的计算方法，利用Python的mro函数也可以说明该搜索顺序：
>>>class F(object):pass
>>>class E(object):pass
>>>class D(object):pass
>>>class C(D,F):pass
>>>class B(D,E):pass
>>>class A(B,C): pass
>>>A.mro()
[
>>>B.mro()
[
>>>
对于C3的MRO算法也可以简单的理解为：深度优先，从左到右遍历基类，先遍历高level的，再遍历低level的，如果任何类在搜索中是重复的，只有最后一个出现的位置被保留，其余会从MROlist中删除。也就是说类的共同的祖先只有在其所有的子类都已经被check之后才会check。对于A，其搜索顺序应该是AB (D) (O) C D (O) E (O) F O
当然即使C3的MRO，也有其无法处理的情况，看下面的例子：
>>>class X(object):pass
>>>class Y(object):pass
>>>class A(X,Y):pass
>>>class B(Y,X):pass
>>>class C(A,B):
pass
Traceback(most recent call last):
File"
classC(A,B):
TypeError:Error when calling the metaclass bases
Cannotcreate a consistent method resolution
order(MRO) for bases X, Y
4.自省与反射
对于熟悉Java的人来说，自省和反射并不是一个陌生的概念，自省可以查看内存中以对象形式
存在的其它模块和函数，获取它们的信息，并对它们进行操作。用这种方法，你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。Python提供了一些内置函数，可以方便的或者对象本省的信息。
dir([object])：查看对象的属性和函数列表。如果对象是个模块，则返回模块的所有属性，如果
object是一个类对象，返回类和其父类的所有属性。
>>>class dirTest(object):
value='1'
defsayhi(self):
https://www.doczj.com/doc/3e2549494.html,='cat'
print"hi"
>>>dir(dirTest)
['__class__','__delattr__', '__dict__', '__doc__',
'__format__','__getattribute__', '__hash__', '__init__', '__module__',
'__new__','__reduce__', '__reduce_ex__', '__repr__', '__setattr__','__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'sayhi','value']
>>>
dir不带参数时，显示调用者的局部变量，作用在模块上时候，显示模块的__dict__内容，显示在类上，显示类和基类的__dict__内容
issubclass(sub,sup):判断一个类是另一个类的子类或子孙类
isinstance(obj1,obj2):在判定一个对象是否是另一个给定类的实例
callable()是一个布尔函数，确定一个对象是否可以通过函数操作符(())来调用。如果函数可
调用便返回True，否则便是False.
模块inspect:
inspect模块提供了一系列自省函数，它可以获取模块，类，方法，函数，traceback，帧对象，代码对象的信息。常用的方法getmembers，ismodule，getcallargs，isclass等，更多详细信息参见https://www.doczj.com/doc/3e2549494.html,/library/inspect.html
>>>import inspect
>>>inspect.isbuildin(abs)
>>>inspect.isbuiltin(abs)
True
>>>inspect.ismodule(inspect)
True
5.新型类与元类
对于新型类来说，其默认的元类为type，而对于传统的类，其默认类型为types.ClassType >>>class Classic: pass
>>>class Newstyle(object): pass
>>>print type(Classic)
>>>print type(Newstyle)
比如>>>class TypeTestClass:
pass
>>>TypeTestClass =type('TypeTestClass',(),{})
>>>print TypeTestClass
>>>print TypeTestClass()
<__main__.TypeTestClassobject at 0x011F3A30>
>>>
新型类是在Python2.2中引入的，其在语法和行为上基本和经典类兼容，主要差别在于所有的新式类必须继承至少一个父类，Object是所有类之母，如果类没有继承任何其他父类，则object将作为默认的父类，新型类还支持从内置类型如list,dict, file等创建子类。
新型类的实例在具有传统类实例的特性，但在__init__的基础上加入的新的构造函数
__new__，同时支持静态方法@staticmethod和类方法@classmethod.(上面的章节已经阐述)，同时增加了Property和__slot__，__getattribute_ _等属性，。Python对Property的定义如下Aproperty is an attribute that is defined by get/set methods.其对应的内建函数有四个参数：property(fget=None,fset=None, fdel=None,doc=None)，其中fget,fset,fdel必须有一个方法被申明，否则进行对应的操作会产生AttributeError异常。如果只需要定义只读属性，则只需要实现fget方法，而不实现fset方法即可。
10. >>>class PropertyTest(object):
11. def__setProperty(self,value):
12. self.__property=value
13. print"setting property"
14. def__getProperty(self):
15. print"getting property"
16. returnself.__property
17. def__delProperty(self):
18. print"del proerty"
19. delself.__property
20. TestProperty=property(fget=__getProperty,fset=__setProperty,fdel=__delPropert
y,doc="propertytest")
21.
22.
23. >>>
24. >>>p=PropertyTest()
25. >>>p.TestProperty=1
26. settingproperty
27. >>>
28. >>>p.TestProperty
29. gettingproperty
30. 1
31. >>>del p.TestProperty
32. delproerty
Property提供灵活的机制来读取、编写或计算私有字段的值。可以像使用公共数据成员一样使用属性，但实际上它们是称作“访问器”的特殊方法。这使得可以轻松访问数据，此外还有助于提高方法的安全性和灵活性。
__slots__类属性：
在Python中可以用__dict__属性来跟踪所有实例属性，而事实上__dict__会占用大量的内存，从Python2.2开始可以用类变量__slots__代替__dict__.,它是一个由具有合法标识的实例属性构成的集合。在定义了__slots__属性的类中不会在存在__dict__，因此可以节约内存，同时它能防止动态增加实例属性，从某种程度上讲更为安全。
>>>class SlotTest(object):
__slots__=('name','age')
>>>class Test(object):
pass
>>>s=SlotTest()
>>>https://www.doczj.com/doc/3e2549494.html,="carol"
>>>s.age="12"
>>>s.score="64"
Traceback(most recent call last):
File"
s.score="64"
AttributeError:'SlotTest' object has no attribute 'score'
>>>
>>>dir(s)
['__class__','__delattr__', '__doc__', '__format__', '__getattribute__','__hash__', '__init__', '__module__', '__new__', '__reduce__','__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__','__slots__', '__str__', '__subclasshook__', 'age', 'name']
>>>
>>>s1=test()
>>>s1.score="65"
>>>dir(s1)
['__class__','__delattr__', '__dict__', '__doc__', '__format__','__getattribute__', '__hash__', '__init__', '__module__', '__new__','__reduce__', '__reduce_ex__', '__repr__',
'__setattr__','__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'score']
>>>
元类：
对于万物皆是对象的Python，对于定义类的一段代码其本身也是对象，那么这个类对象的类型就是元类，它用来描述类的类。在元类用于创建类的时候，解释器先查找__metaclass__属性，该属性的值便是类的元类，如果没有找到该属性的定义，则会查找其父类的
__metaclass__.如果仍然没有找到，对于新型类则会以type(object)作为其元类，如果当前模块有全局变量名为metaclass，则将其值作为其元类，而对于传统的类，其元类类型为types.ClassType.
可以有多种方法来创建一个元类，如利用type函数，类工厂模式，或者设置__metaclass__属性等
1利用传统工厂函数返回类：
>>>def class_creator(func):
classinternal:pass
setattr(internal,func.__name__,func)
returninternal
>>>def alive(self):print 'Hi,I am here'
>>>ChildClass = class_creator(alive)
>>>cc=ChildClass()
>>>cc.alive()
Hi,Iam here
>>>
2通过type创建类
>>>def __init__(self):
self.message='metaclass test'
>>>def alive(self):
printself.message
>>>attrs={'__init__':__init__,'alive':alive}
>>>bases=()
>>>
>>>ClassTep=type('MetaTestClass',bases,attrs)
>>>
>>>t=ClassTep()
>>>t.alive()
metaclasstest
>>>
3设置__metaclass__属性：只要在类定义中把__metaclass__设置为任意有着与type相同参数的可调用对象，就能够提供自定义的元类。通常继承type
>>>class Meta(type):
def__init__(cls,name,bases,attrs):
print"I am a meta class templete,Class will be created by me"
super(Meta,cls).__init__(name,bases,attrs)
defWelcome(cls): print "welcome",cls.__name__
>>>class MetaTest(object):
__metaclass__=Meta
defsayhi(self):
print"Hi"
Iam a meta class templete,Class will be created by me
>>>MetaTest.Welcome()
welcomeMetaTest
>>>MetaTest().sayhi()
Hi
4利用new模块中的类工厂：
new.classobj(name,baseclasses, dict)
Thisfunction returns a new class object, with name name, derived frombaseclasses (which should be a tuple of classes) and with namespacedict.
>>>from new import classobj
>>>metatest=classobj('Meta',(object,),{'Hello':lambda self:'hello'})
>>>metatest().Hello()
'hello'
>>>
在元类中也可以定义类方法，一般叫做元方法，元方法和普通的类方法在使用上存在一定的区别，元方法能够被元类或者元类对象（类）直接调用，但不能没类的实例调用，而类方法可以被类或者类的实例直接调用。
>>>class Meta(type):
def__init__(cls,name,bases,attrs):
super(Meta,cls).__init__(name,bases,attrs)
defWelcome(cls): print "welcome",cls.__name__#元方法
>>>class MetaTest(object):
__metaclass__=Meta
defsayhi(self):
print"Hi"
defgetName(cls):#类方法
print"what is your name"
>>>d=MetaTest()
>>>Meta.Welcome(MetaTest)
welcomeMetaTest
>>>MetaTest.Welcome()
welcomeMetaTest
>>>d.getName()
whatis your name
>>>MetaTest.getName(d)
whatis your name
>>>d.Welcome()
Traceback(most recent call last):
File"
d.Welcome()
AttributeError:'MetaTest' object has no attribute 'Welcome'
>>>
在继承关系中，元类和普通的超类存在一定的区别，元类属性的可用性是不会传递的，也就是说，元类的属性是对它的实例是可用的，但是对它的实例的实例是不可用的。
>>>class SuperC(object):
attr='name','age'
>>>class Child(SuperC):
pass
>>>Child.attr
('name','age')
>>>
>>>a=Child()
>>>a.attr
('name','age')
>>>
>>>class SuperMeta(type):
attr=('name','age')
>>>class ChildMeta(object):
__metaclass__=SuperMeta
>>>class Child2Meta(ChildMeta):pass
>>>SuperMeta.attr
('name','age')
>>>ChildMeta.attr
('name','age')
>>>Child2Meta.attr
('name','age')
>>>b=Child2Meta()
>>>b.attr
Traceback(most recent call last):
File"
b.attr
AttributeError:'Child2Meta' object has no attribute 'attr'
在元类的多继承中，通常会产生冲突，比如A，B都是带有元类的类，C多继承于A和B 时会产生冲突。如下例：
>>>class MetaA(type):pass
>>>class MetaB(type):pass
>>>class A(object):
__metaclass__=MetaA
>>>class B(object):
__metaclass__=MetaB
>>>class C(A,B):pass
Traceback(most recent call last):
File"
classC(A,B):pass
TypeError:Error when calling the metaclass bases
metaclassconflict: the metaclass of a derived class must be a (non-strict)subclass of the metaclasses of all its bases
>>>
解决冲突的方法从利用type重新定义一个中间的元类。
AB=type("AB",(MetaA,MetaB),{})
classC(A,B):__metaclass__=AB
print 句子也能够跟上多个字符串，用逗号“ ,”离隔，就能够连成一串输出： print 'The quick brown fox', 'jumps over', 'the lazy dog' 在 Python 中，等号 =是赋值句子，能够把恣意数据类型赋值给变量，同一个变量能够重复赋值，并且能够是不同类型的变量。变量自身类型不固定 的言语称之为动态言语，与之对应的是静态言语。 静态言语在界说变量时有必要指定变量类型，假如赋值的时分类型不匹配，就会报错。 假如字符串自身包含 '怎么办？比方咱们要表明字符串 I'm OK ，这时，能够用 " " 括起来表明。相似的，假如字符串包含 "，咱们就能够用 ' '括起来表示：假如字符串既包含 '又包含 "怎么办？这个时分，就需求对字符串的某些特别字符进行“转义”，Python 字符串用进行转义。 \n 表示换行 \t 表示一个制表符 \\ 表示\ 字符本身 假如一个字符串包含许多需求转义的字符，对每一个字符都进行转义会很费事。为了防止这种状况，咱们能够在字符串前面加个前缀 r，表明这是 一个raw 字符串，里面的字符就不需要转义了。如，r'\(~_~)/ \(~_~)/' 。如果要表示多行字符串，可以用'''...''' 表示 如果中文字符串在Python 环境下遇到UnicodeDecodeError ，这是因为.py 文件保存的格式有问题。可以在第一行添加注释# -*- coding: utf-8 -*- print u' 中文' 在 Python 中，布尔类型还能够与其他数据类型做 and 、or 和 not 运算 直接用[ ] 把list 的所有元素都括起来，就是一个list 对象。通常，我们会把list 赋值给一个变量，这样，就可以通过变量来引用list 索引从 0 开端，也便是说，榜首个元素的索引是 0，第二个元素的索引是 1 ，以此类推。 因此，要打印第一名同学的名字，用L[0] 添加list 的append() 方法或者insert() 方法 定位删去 L.pop()() 对 list 中的某一个索引赋值，就能够直接用新的元素替换掉本来的元素， list 包含的元素个数坚持不变。 缩进请严厉依照 Python 的习气写法： 4 个空格，不要运用 Tab，更不要混合 Tab 和空格，不然很简单形成由于缩进引起的语法过错。 if age >= 18:要防止嵌套结构的 if ... else ... ，咱们能够用 if ... 多个 elif ... else ... 的结构，一次写完一切的规矩 奇数加和for a in L: sum+=a x += 2 偶数不要if x%2==0: Continue dict 的榜首个特点是查找速度快，不管 dict 有 10 个元素仍是 10 万个元素，查找速度都相同。而 list 的查找速度跟着元素增加而逐步下降。 d={} d.get(x) 可以取到d{} 中key 后面的value 个数len(s) s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)]) for name,score in s: print name,':',score s.remove():s.add() 比较函数cmp(x,y)
本文基于《byteofpython》电子书及网络材料而写，电子书本身已很精简，因此不必长篇累牍，旨在抛砖引玉。“【】”内表示补充说明。 python与脚本语言 首先我们知道，脚本与脚本解释器这两个概念是统一的、密不可分的。 脚本本质上就是文本文件（如用ASCII码所写的），这种文本文件用文本编辑器打开与普通的文本文件没有区别，只不过扩展名不是“.txt”，python脚本的扩展名通常是“.py”。什么样的文本文件是脚本呢？答案是：针对特定脚本解释器的语法规则所编写的，供脚本解释器来使用的文本文件。计算机仅有脚本还是不能工作（它只是文本文件），我们需要一种工具软件，用来把脚本中的代码解释成计算机指令，同时让计算机立即执行这些指令，这种工具就是脚本解释器。很显然，使用不同语法规则编写的脚本应使用不同的解释器来解释执行，因为每种脚本实际上是专为其解释器而写的，是按照解释器能识别的语法规则而写的。如果你想通过脚本使计算机工作，就要在系统中安装一种脚本解释器，然后根据这种解释器规定的语法规则编写脚本，最后启动解释器来执行这个脚本。python是众多“脚本解释器+语法规则”的一种，类似还有bash、perl、javascript等等。 比较C与python 1.代码层面看C与python 所谓不同编程语言，在代码层面来看，主要不同之处在于它们的语法规则，掌握了一种编程语言的语法规则，你就可以写出一种代码。我们写C语言代码，就是按照C语言规定的语法规则来定义变量、函数、数据结构等。同样地，遵照python的语法规则就可以编写python代码，这与写C代码没什么不同。 2.代码的存在形式 C语言中有源文件、目标文件、可执行文件这些概念，python中只有脚本及解释器。所谓的脚本、程序或者软件都是指保存代码的文本文件（虽然为了加快python模块导入时的速度，解释器会生成一种扩展名为”.pyc”的文件，它们只是用来保存中间状态的）。由于脚本既是可运行程序又是代码，可读性强、修改程序方便（不必编译，修改即可执行）是脚本的两大优点。 3.从代码到执行 C语言写好之后，我们根据目标CPU指令集来选择特定的工具链（如编译、链接工具），用它将C代码最终编译为目标CPU可直接执行的二进制文件，然后将这个二进制文件装载到内存中，执行时再将内存中程序入口地址传递给CPU，进而逐条执行程序中的指令。这是使用C语言编码，到最终计算机执行指令的过程。 使用python语言编码之后的步骤与此不同：python代码不需要被编译为可执行文件，它需要通过python解释器来控制计算机工作。就是说，系统中必须事先安装好了python解释器，
竭诚为您提供优质文档/双击可除 python学习心得 篇一：python学习经验分享 数据类型 print 输出，可以多个输出，用逗号分隔a=20printa,type(a) 20 type() 内置函数type()，用来查询变量的类型 a=20printtype(a) 基本数据类型? ? ? ?a=10int整数a=1.3float浮点数a=True真值 (True/False)a=hello!字符串 注：对于字符串来说，也可以用双引号 补充
计算结果为布尔类型 输出 补充 计算结果为浮点型 输出 序列 包括以下两种 ? ?tuple（定值表；也有翻译为元组）list(表) tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更一个序列作为另一个序列的元素 空序列 元素的引用 序列元素的下标从0开始 由于list的元素可变更，可以对list的某个元素赋值如果对tuple做赋值操作，会出错 范围引用 基本样式[下限:上限:步长] 在范围引用的时候，如果写明上限，那么这个上限本身不包括在内 尾部元素引用
如果s1[0:-1],那么最后一个元素不会被引用（再一次，不包括上限元素本身） 输出 字符串是元组 字符串是一种特殊的元素，因此可以执行元组的相关操作 输出 tuple中元素不可变，list中元素可变，但是如果tuple 中包含一个list，那么此list中的元素是可变的 输出 步进-1 表示分片将会从右至左进行而不是通常的从左至右 分片s以反转的顺序获取元素，即结果是偏移为4，3，2的元素 篇二：python学习报告 1、python学习报告学习目标 1.了解python的特性及用处。 2.熟悉python的基本语法。 3.能编写简单的python程序。 2、python的简单介绍 1.与perl一样，python也是一种解释语言，它完全采用面向对象的方式，语言结构介于c语言和perl语言之间。
Python将纳入高考内容、小学生教材开始接触Python、Python列入全国计算机等级考试…… 全民学Python的话题铺天盖地，中国的Python学习者是全球第一，人才如此泛滥，甚至以 后孩子都会，学习它还能体现自身高价值？ 30年前学英语的人凤毛麟角，但是现在，当英语成为了国际通用语言，学英语的人地位下降 了吗？仍然有大把人才靠英语的才能，过上令人羡慕的生活。 所以，不论竞争者多少，建立自己强有力的竞争力才是关键。现在学Python的人越多，正代 表着它成为编程届的国际通用语言大有可能。 短时间掌握一门技能是现在社会的需求。节奏越来越快，现在不是大鱼吃小鱼，而是快鱼吃 慢鱼的时代。人的时间比机器的时间值钱，而机器可以堆。 从大公司角度而言： 国内基于Python创业成功的案例不在少数，豆瓣、知乎、果壳，全栈都是 Python，大家对Python自然有信心。并且从这几家公司出来的程序员与 CTO，创业的话一般都会选择Python，雪球定会越滚越大。 从小公司角度而言： 现在创业公司越来越多，用Python出项目快，开发成本小，雇佣的员工数量也可以保持在可 控范围。 自学Python 学会基础，就从爬虫开始 现在大家学习Python，两个特别重要的方向就是爬虫和Web。利用 Python 爬虫我们可以进 行房地产、招聘等行业市场调研和商业分析、作为机器学习、数据挖掘的原始数据、爬取优 质的资源：图片、文本、视频等。 但是如果想学Python，我们会发现，画面是这样的：教你用Scrapy框架爬取xx，教你用Django框架爬取xx……这些框架，其实就是第三方公司推出的开源库。用库你可以很方便的爬取信息，但是问题也来了：
Python总结 目录 Python总结 (1) 前言 (2) （一）如何学习Python (2) （二）一些Python免费课程推荐 (4) （三）Python爬虫需要哪些知识？ (5) （四）Python爬虫进阶 (8) （五）Python爬虫面试指南 (11) （六）推荐一些不错的Python博客 (13) （七）Python如何进阶 (14) （八）Python爬虫入门 (16) （九）Python开发微信公众号 (20) （十）Python面试概念和代码 (24) （十一）Python书籍 (34)
前言 知乎：路人甲 微博：玩数据的路人甲 微信公众号：一个程序员的日常 在知乎分享已经有一年多了，之前一直有朋友说我的回答能整理成书籍了，一直偷懒没做，最近有空仔细整理了知乎上的回答和文章另外也添加了一些新的内容，完成了几本小小的电子书，这一本是有关于Python方面的。 还有另外几本包括我的一些数据分析方面的读书笔记、增长黑客的读书笔记、机器学习十大算法等等内容。将会在我的微信公众号：一个程序员的日常进行更新，同时也可以关注我的知乎账号：路人甲及时关注我的最新分享用数据讲故事。（一）如何学习Python 学习Python大致可以分为以下几个阶段： 1.刚上手的时候肯定是先过一遍Python最基本的知识，比如说：变量、数据结构、语法等，基础过的很快，基本上1~2周时间就能过完了，我当时是在这儿看的基础：Python 简介| 菜鸟教程
2.看完基础后，就是做一些小项目巩固基础，比方说：做一个终端计算器，如果实在找不到什么练手项目，可以在Codecademy - learn to code, interactively, for free上面进行练习。 3. 如果时间充裕的话可以买一本讲Python基础的书籍比如《Python编程》，阅读这些书籍，在巩固一遍基础的同时你会发现自己诸多没有学习到的边边角角，这一步是对自己基础知识的补充。 4.Python库是Python的精华所在，可以说Python库组成并且造就了Python，Python库是Python开发者的利器，所以学习Python库就显得尤为重要：The Python Standard Library，Python库很多，如果你没有时间全部看完，不妨学习一遍常用的Python库：Python常用库整理- 知乎专栏 5.Python库是开发者利器，用这些库你可以做很多很多东西，最常见的网络爬虫、自然语言处理、图像识别等等，这些领域都有很强大的Python库做支持，所以当你学了Python库之后，一定要第一时间进行练习。如何寻找自己需要的Python库呢？推荐我之前的一个回答：如何找到适合需求的Python 库?
python入门重点知识总结 1. 数据类型： 下标为负值： 注意事项： 练习list列表结构 1def reverseWords(input): 2 inputWords=input.split(" "); 3 inputWords=inputWords[‐1::‐1] 4 output=' '.join(inputWords) 5 return output 6if __name__ == "__main__": 7 input='I like runobb' 8 rw=reverseWords(input); 9 print(rw) 结果：
常用函数 示例 1a=[66.25,333,1,333,1234.5] 2print(a.count(333),a.count('x')) 3a.insert(2,‐1) 4a.append(333) 5print(a) 6a.remove(333) 7print(a) 8a.reverse(); 9print(a) 10a.sort() 11print(a) 结果：
list可当做栈使用 1stack=[3,4,5] 2stack.append(6) 3print(stack) 4stack.pop() 5print(stack) 结果 list当做队列使用 1from _collections import deque 2queue=deque(["Eric","John","Michael"]) 3queue.append("Terry") 4print(queue) 5queue.popleft() 6print(queue) 结果 列表推导式可操作for或者if语句 1vec=[2,4,6] 2result=[3*x for x in vec] 3print(result) 结果 1vec=[2,4,6] 2print([3*x for x in vec if x>3])
引言 提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python 对面向对象的支持。 在讨论Python的OOP之前，先看几个OOP术语的定义： ?类：对具有相同数据和方法的一组对象的描述或定义。 ?对象：对象是一个类的实例。 ?实例(instance)：一个对象的实例化实现。 ?标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。 ?实例属性（instance attribute）：一个对象就是一组属性的集合。 ?实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。 ?类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化 ?类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。 1.Python中的类与对象 Python中定义类的方式比较简单： class类名： 类变量 def __init__(self,paramers): def函数(self,...) 其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self 作为第一个参数。 举例： class MyFirstTestClass: classSpec="itis a test class" def__init__(self,word): print"say "+word defhello(self,name): print"hello "+name 在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。 class MethodTest(): count= 0
如何快速学会Python_心得体会 一、什么是Python Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。 二、Python的职位发展有哪些 Python全栈开发工程师(10k-20K)Python运维开发工程师(15k-20K)Python高级开发工程师(15k-30K)Python大数据工程师(15K-30K)Python机器学习工程师(15k-30K)Python架构师(20k-40k) 目前应用最多的：全栈开发、数据分析、运维开发，今天我们就以这三个重点的岗位来做一下自学Python的规划，希望你在学之前就能有结果的来走得更远。 三、该如何学好Python 1、明确目标 其实很多人在学习Python之前很少想这个，因为很多人说：现在Python很火呀，所以我才需要学。这个其实跟你自己没有什么关系，例如：你曾经想做一个网站不会开发，现在可以做了，现在Python很火并且你也要学来找工作，未来Python很火，我具备了Python 的技能会不错。 所以我们首先要明确自己的目标，确定学习的决心，坚持自己的选择。 2、明确学习规划 ①.目前市场需求主流的岗位里，你得选择一个其中你目前看来可以学，并且最敢兴趣学习的方向; ②.在方向选择好后，对照招聘网站：拉勾、智联、Boss直聘等网站的岗位要求，进行学习内容的统计与大概的记录; ③.分模块的计划你学习这个模块的时间和完成的大概目标; ④.列出你可能出现的学习误差与为之准备的应对方案; 其实任何学习重要的不是有什么资料，核心是如何学，学多久，有没有时间限制，最关键的一点是在起步阶段，开始属于激情期，激情在前面释放越多，后面的持续力就很弱，好了这就是关于学习计划。 废话不多说，那我们来看看一个普适性的学习Python的流程; 1天——下载并安装好学习环境：到网站上下载一个python3.0以上的版本。我建议初学者，不要下载具有IDE功能的集成开发环境，比如Eclipse插件等。 1周——下载一些python的学习文档，比如《简明Python教程》，《笨办法学Python》等等。通过学习语法，掌握python中的关键字语法，函数语法，数学表达式、变量、数据结构、语法等等等 1. 了解Python是什么，都能做些什么? 2. 知道什么是变量、算法、解释器 3. Python基本数据类型 4. 列表和元组的操作方法 5. 字符串操作方法 6. 基本的字典操作方法 7.任何知识它的基础知识都是有些枯燥的，现在我们就可以动手来做一些逻辑层面的东西了。掌握if、else、elif、while、for、continue、break和列表推导式等这些语句的使用，还有程序中的异常处理。 2周——看完基础后，就是做一些小项目巩固基础，python具备很好的交
0、命令行常用命令 命令行（Windows下叫“命令提示符”，Mac下叫“终端”）里的常用命令。打开命令行，我们会看到每行前面都有诸如 C:\Documents and Settings\Crossin> 或者 MyMacBook:~ crossin$ 之类的。 这个提示符表示了当前命令行所在目录。 第一个常用的命令是： dir （windows环境下） ls （mac环境下） dir和ls的作用差不多，都是显示出当前目录下的文件和文件夹。 第二个常用命令是： cd 目录名 通过dir或ls了解当前目录的结构之后，可以通过“cd 目录名”的方式，进入到当前目录下的子目录里。 如果要跳回到上级目录，可以用命令： cd .. 另外，Windows下如果要写换盘符，需要输入 盘符: 比如从c盘切换到d盘C:\Documents and Settings\Crossin>d: 有了以上两个命令，就可以在文件目录的迷宫里游荡了。虽然没可视化的目录下的操作那么直观，但是会显得你更像个程序员。。。 于是乎，再说个高阶玩法：现在你可以不用idle那套东西了，随便找个顺手的文本软件，把你的代码写好，保存好，最好是保存成py文件。然后在命令行下进入到py文件保存的目录，使用命令：python 程序保存的文件名 就可以运行你写的程序了。 一、关于分号“；” 在C、Java等语言的语法中规定，必须以分号作为语句结束的标识。Python也支持分号，同样用于一条语句的结束标识。但在Python中分号的作用已经不像C、Java中那么重要了，Python中的分号可以省略，主要通过换行来识别语句的结束。 例如，以下两行代码是等价的：
一、变量 方法UPPer()将字符串全部大写 方法IOWer()将字符串全部小写 方法rstrip()删除字符串末尾空白 方法IStriP()剔除字符串开头空白 方法StriP()剔除字符串两端空白 方法str()转换成字符串类型 二、列表 1、列表是有序集合，索引从0 开始，倒序从-1 开始，用[]来表示，用逗号分隔其中的元素。 2、append()方法在列表末尾增加元素 3、insert()方法可在列表的任意位置添加新元素，需要制定新元素的索引和值例如： mm=[ ‘11 ,'22','33'] Mm.insert(0, '00') 输出mm ：[‘00 ,'11 ,'2 2 ,'3 3 '] 4、使用deI 语句删除元素知道元素位置，通过del mm[0] 删除第一个元素 5、使用pop()方法删除列表末尾的元素，并可以接着使用他的值 例如：ss=mm.pop() 输出mm：[‘11,'22'] Ss=00 6、使用pop()方法也可以删除列表任何位置的元素，需要在()中指定要删除的元素索引即可。例如：ss=mm.pop(0) 输出mm：[‘11,'22'] Ss=00 7、根据值删除元素，使用方法remove() 例如：ss=mm.remove( ‘33') 输出mm：[‘11,'22'] Ss=33 &方法sort()对列表进行永久性排序--按字母顺序排序 9、方法sort()传递参数reverse=True,即sort(reverse=True)对列表进行永久性排序--按字母相反顺序排序 10、使用函数SOrted()对列表进行临时排序，不影响原始排列顺序 11、方法SOrted()传递参数reverse=True, 即卩sort(reverse=True)对列表进行临时排序-按字母相反顺序排序 12、倒着打印列表，可使用方法reverse(),反转列表元素的排列顺序(不是按字母相反顺序 排列) 13、函数len()可快速获悉列表长度 三、创建数字列表 1、使用函数range()可以轻松的生成一系列数字例如：for value in rang(1,5): Print(value) 输出的是 1 2 3 4
openstack编程：python基础知识总结 阅读本文可以带着下面问题： 1.python的注释符号是什么？ 2.python输出该如何写？ 3.什么是内建函数？ 4.python的运算符都包含哪些？ 5.Python字符串该如何表示？ 6.列表和元组怎么表示？ 7.if语句该如何表示？ 8.while语句如何表示？ 9.如何捕获异常？ 10.函数如何表示？ 11.Python的源文件名是什么？ 12.常用函数都有哪些？ 总结一 1.程序输出: 和C中printf很像: 1.>>> print "%s is number %d." % ("Python", 1) 2.Python is number 1. 复制代码 将输出重定向到系统标准错误: 1.>>> import sys 2.>>> print >> sys.stderr, 'fatal error.' 3.fatal error. 复制代码 将输出重定向到一个文件: 1.>>> logfile = open('./out.log', 'a') 2.>>> print >> logfile, 'hello world' 3.>>> logfile.close() 复制代码 2.程序输入和内建函数raw_input(): 1.>>> user = raw_input('Enter your name:')
2.Enter your name:chenjianfei 3.>>> passwd = raw_input('Enter your password:') 4.Enter your password:123456 复制代码 内建函数int()可将数字字符串转化为int: 1.>>> num = raw_input('Input a num:') 2.Input a num:100 3.>>> print '2*num = %d' % num*2 4.Traceback (most recent call last): 5. File "
目录 Python总结......................................... 错误!未定义书签。 前言............................................ 错误!未定义书签。 （一）如何学习Python............................ 错误!未定义书签。 （二）一些Python免费课程推荐................... 错误!未定义书签。 （三）Python爬虫需要哪些知识？.................. 错误!未定义书签。 （四）Python爬虫进阶............................ 错误!未定义书签。 （五）Python爬虫面试指南........................ 错误!未定义书签。 （六）推荐一些不错的Python博客................. 错误!未定义书签。 （七）Python如何进阶............................ 错误!未定义书签。 （八）Python爬虫入门............................ 错误!未定义书签。 （九）Python开发微信公众号...................... 错误!未定义书签。 （十）Python面试概念和代码...................... 错误!未定义书签。 （十一）Python书籍.............................. 错误!未定义书签。
前言 知乎：路人甲 微博：玩数据的路人甲 微信公众号：一个程序员的日常 在知乎分享已经有一年多了，之前一直有朋友说我的回答能整理成书籍了，一直偷懒没做，最近有空仔细整理了知乎上的回答和文章另外也添加了一些新的内 容，完成了几本小小的电子书，这一本是有关于Python方面的。 还有另外几本包括我的一些数据分析方面的读书笔记、增长黑客的读书笔记、机器学习十大算法等等内容。将会在我的微信公众号：一个程序员的日常进行更新，同时也可以关注我的知乎账号：路人甲及时关注我的最新分享用数据讲故事。 （一）如何学习Python 学习Python大致可以分为以下几个阶段： 1.刚上手的时候肯定是先过一遍Python最基本的知识，比如说：变量、数据结构、语法等，基础过的很快，基本上1~2周时间就能过完了，我当时是在这儿看 的基础：Python 简介 | 菜鸟教程 2.看完基础后，就是做一些小项目巩固基础，比方说：做一个终端计算器，如果 实在找不到什么练手项目，可以在Codecademy - learn to code, interactively, for free上面进行练习。 3. 如果时间充裕的话可以买一本讲Python基础的书籍比如《Python编程》，阅读这些书籍，在巩固一遍基础的同时你会发现自己诸多没有学习到的边边角 角，这一步是对自己基础知识的补充。 库是Python的精华所在，可以说Python库组成并且造就了Python，Python库是Python开发者的利器，所以学习Python库就显得尤为重要：The Python Standard Library，Python库很多，如果你没有时间全部看完，不妨学习一遍 常用的Python库：Python常用库整理 - 知乎专栏
0、命令行常用命令 命令行（ Windows 下叫“命令提示符”，Mac 下叫“终端”）里的常用命令。打开命令行，我们 会看到每行前面都有诸如 C:\Documents and Settings\Crossin> 或者 MyMacBook:~ crossin$ 之类的。 这个提示符表示了当前命令行所在目录。 第一个常用的命令是： dir （ windows 环境下） ls （ mac 环境下） dir 和 ls 的作用差不多，都是显示出当前目录下的文件和文件夹。 第二个常用命令是： cd 目录名 通过 dir 或 ls 了解当前目录的结构之后，可以通过“cd目录名”的方式，进入 到当前目录下的子目录里。 如果要跳回到上级目录，可以用命令： cd .. 另外， Windows 下如果要写换盘符，需要输入 盘符 : 比如从 c 盘切换到 d 盘 C:\Documents and Settings\Crossin>d: 有了以上两个命令，就可以在文件目录的迷宫里游荡了。虽然没可视化的目录下 的操作那么直观，但是会显得你更像个程序员。。。 于是乎，再说个高阶玩法：现在你可以不用 idle 那套东西了，随便找个顺手的文 本软件，把你的代码写好，保存好，最好是保存成 py 文件。然后在命令行下进入 到 py 文件保存的目录，使用命令： python 程序保存的文件名 就可以运行你写的程序了。 一、关于分号“；” 在 C、Java 等语言的语法中规定，必须以分号作为语句结束的标识。 样用于一条语句的结束标识。但在Python 中分号的作用已经不像 Python 也支持分号，同C、Java 中那么重 要了， Python 中的分号可以省略，主要通过换行来识别语句的结束。
Python 知识点整理 第一部分 算法 一、 概念 算法就是解决问题的方法和步骤，即解题步骤。 二、 算法的描述方法 （一） 自然语言：直接用语言叙述解题步骤。 （二） 流程图 1. 符号 2. 三大结构的流程图框架 （1） 顺序结构 （2） 分支结构 （3） 循环结构 直角矩形 运算过程（赋值等） 平行四边形 输入、输出 菱形 判断条件 箭头 程序的执行方向 圆角矩形 开始、结束
第二部分编程 一、变量 1.变量名可以包含的字符有：小写字母（a-z），大写字母（A-Z），数字（0-9）， 下划线（_） 注意：不能以数字开头！ 不能使用Python保留的关键字（彩色）！ 下划线开头的名字有特殊含义！ 2.变量的数据类型和数值都可以通过赋值运算改变。 二、数据类型 1.布尔型：表示真假的类型，取值仅包含True和False。 2.整型：整数。（496、5、10000000、95……） 把变量a转换成整数型：a=int（a） 3.浮点型：小数或用科学计数法表示的数字。 3.14159、5.91、1.0e8（1乘10的8次方，也可以写作100000000.0） 把变量a转换成浮点型：a=float（a） 4.字符串型：字符组成的序列。 ‘ab c d’、“ab c d”、’’’ ab c d’’’…… 把变量a转换成字符串型：a=str（a） 三、赋值运算（=） 用法：将等式右边赋值给等式左边。 a=7（将7赋值给a） b=a（将a赋值给b） 四、常见数值运算 1.加法（+） 2.减法（-） 3.乘法（*） 4.浮点除法（/）
5.整数除法（//） 6.求余数（%） 常用于判断是否能整除：余数为零，即可以整除。 7.幂指数（**） 3的4次方： 8.开平方 import math math.sqrt（） 括号内为开平方的数值或变量。 9.变量a在原有数值上增加1（a+=1，即a=a+1） “-=”、“*=”、“/=”等运算符号组合的意义同理。 五、字符串运算 1.拼接（+） 2.复制 3.转义符 （1）换行符（\n） （2）制表符（\t）：对齐文本 （3）引号（\’ 或\”）：表示单、双引号，在字符串被相同引号包裹时使用
python学习报告 Python 1、 Python 学习报告 学习目标 1. 了解python的特性及用处。 2. 熟悉python的基本语法。 3. 能编写简单的python程序。 2、 Python的简单介绍 1. 与 Perl 一样， Python 也是一种解释语言，它完全采用面向对象的方式，语言结构介于 C 语 言和 Perl 语言之间。虽然它被视作一种高极语言，但它的内置解释器的功能却非常基本，仅有几种功能、操作符和关键词便构成了整个程序语言。它的优势可不仅如此，它还能通过一系列的模块进行扩充。它既比 Perl 和 VB 语句更快更好，又比 C 和 C++ 语言更有扩充性。 3、 python环境的搭建 1. python安装 1 由于python3.x与python2.x是不兼容。而目前的使用主流还是phthon。所以我学习使用的是python 2.4.3版本。该版本
已经有Centos系统自带。 2 如没有安装python，可以自行下载安装。下载地址://https://www.doczj.com/doc/3e2549494.html,/getit/。 2. Python编辑器安装：yum install python-tools。 3. 安装完idle后，直接在终端输入idle即可运行。 熟悉python 1. python的数学计算 1 打开终端，并输入idle打开python编辑器 2 python的特点之一是支持数学运算，只要输入正确的算式，就能得到答案。 3 python的变量无须声明，可以直接使用。例1) >>> 1*5 5 例2) >>> a = 5 >>> b=3 >>> a-b 2 2. hello word 的编写 1 编写一个简单的hello word程序 2 输出字符串可以用print，同时要给字符串加上单引号或者双引号。例1) >>> print \ hello word 1 4、 Python 例2) >>> print 'ok' ok
Python基础 一、Python中数据类型 在Python中，能够直接处理的数据类型有以下几种： 一、整数 Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。 计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。 二、浮点数 浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，^9和^8是相等的。浮点数可以用数学写法，如，，，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，^9就是，或者，可以写成，等等。 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。 三、字符串 字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。 四、布尔值 布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。 布尔值可以用and、or和not运算。 and运算是与运算，只有所有都为True，and运算结果才是True。 or运算是或运算，只要其中有一个为True，or 运算结果就是True。 not运算是非运算，它是一个单目运算符，把True 变成False，False 变成True。 五、空值 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。 此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到 打印输出 print语句可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：>>> print 'hello, world'
Python初步学习总结 【Help】- 【InstallNewSoftware】。 在弹出的对话框中，点击Add按钮，添加新的安装源。 在Location处填写安装源的网址（https://www.doczj.com/doc/3e2549494.html,/updates），并为之取一个名字填写在Name处，比如我这里写的是PyDev。 确定后可以看到一个Pending过程，然后得到如下图所示的插件：勾选后，点击Next进行安装。 不过，由于网络的原因，这种方法安装PyDev极有可能失败，提示网络连接错误等。 离线安装在解决方法是直接将下载的离线包解压，得到plugins和features文件夹，放到Eclipse的dropins目录下。 重启Eclipse，PyDev插件即可安装成功。 4.PyDev插件配置安装好PyDev插件后，还并不能正常使用，还需要配置Python的解释器。 打开Eclipse，选择 【Window】- 【Preferences】，找到 【PyDev】，选择其中的 【Interpreter–Python】。 点击[new]，然后找到安装的python目录，然后选择python.就行，剩下的就会自动帮你加载完成。
如果对于需要开发MonkeyRunner的就需要按照下面的步骤去对于Jython的解释器进行配置。 通过上面的工具安装完成之后就能够进行开发了。 2.语法学习1.可以通过下面的这个网站进行学习：2.还可以在其官网上面看原始的资料进行学习https://https://www.doczj.com/doc/3e2549494.html,/doc/ 3.开发体验1.在开发MonkeyRunner的时候，需要额外的添加一些lib库。 添加步骤如下：2.在开发MonkeyRunner的过程中需要对于所使用的jar包熟悉。 所以通过反编译工具对于jar包包含的类和方法进行查看。 工具：方法：1.解压这个工具2.执行jd-gui.3.添加 【File】---》 【Openfile】添加你要查看的jar包就行。 3.开发工程需要对于页面的控件ID进行查询，可以使用androidsdk中的monitor.bat工具。 1.将手机连接PC，adb端口可用，有的机器查看需要root权限。 2.点击这个工具，双击执行，然后将连接的手机调整到需要查看的界面下。 3.打开之后就是如下的界面，按照下面的步骤进行操作。 4.其中这个工具还可以看到其他的关于界面的一些布局信息。
print语句也可以跟上多个字符串,用逗号“,”隔开,就可以连成一串输出:print 'The quick brown fox', 'jumps over', 'the lazy dog' 在Python中,等号=就是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以就是不同类型得变量。变量本身类型不固定得语言称之为动态语言,与之对应得就是静态语言。 静态语言在定义变量时必须指定变量类型,如果赋值得时候类型不匹配,就会报错。 如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ,这时,可以用" "括起来表示。类似得,如果字符串包含",我们就可以用' '括起来表示:如果字符串既包含'又包含"怎么办？这个时候,就需要对字符串得某些特殊字符进行“转义”,Python字符串用\进行转义。 \n 表示换行 \t 表示一个制表符 \\ 表示\ 字符本身 如果一个字符串包含很多需要转义得字符,对每一个字符都进行转义会很麻烦。为了避免这种情况,我们可以在字符串前面加个前缀 r,表示这就是一个 raw 字符串,里面得字符就不需要转义了。如,r'\(~_~)/ \(~_~)/'。如果要表示多行字符串,可以用'''、、、'''表示 如果中文字符串在Python环境下遇到UnicodeDecodeError,这就是因为、py文件保存得格式有问题。可以在第一行添加注释# -*- coding: utf-8 -*- print u'中文' 在Python中,布尔类型还可以与其她数据类型做and、or与not运算 直接用 [ ] 把list得所有元素都括起来,就就是一个list对象。通常,我们会把list赋值给一个变量,这样,就可以通过变量来引用list 索引从0 开始,也就就是说,第一个元素得索引就是0,第二个元素得索引就是1,以此类推。 因此,要打印第一名同学得名字,用L[0] 添加 list 得 append() 方法或者insert()方法 定位删除L、pop() 对list中得某一个索引赋值,就可以直接用新得元素替换掉原来得元素,list包含得元素个数保持不变。 缩进请严格按照Python得习惯写法:4个空格,不要使用Tab,更不要混合Tab与空格,否则很容易造成因为缩进引起得语法错误。if age >= 18: 要避免嵌套结构得if 、、、else 、、、,我们可以用 if 、、、多个elif 、、、else 、、、得结构,一次写完所有得规则 奇数加与for a in L: sum+=a x += 2 偶数不要if x%2==0: Continue dict得第一个特点就是查找速度快,无论dict有10个元素还就是10万个元素,查找速度都一样。而list得查找速度随着元素增加而逐渐下降。d={} d、get(x)可以取到d{}中key后面得value 个数len(s) s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)]) for name,score in s: print name,':',score s、remove():s、add() 比较函数cmp(x,y) 如果想让一个函数能接受任意个参数,我们就可以定义一个可变参数: def fn(*args): print args 可变参数得名字前面有个* 号,我们可以传入0个、1个或多个参数给可变参数 r、append(L[i]) 向r添加 对这种经常取指定索引范围得操作,用循环十分繁琐,因此,Python提供了切片(Slice)操作符,能大大简化这种操作。 对应上面得问题,取前3个元素,用一行代码就可以完成切片: >>> L[0:3]