python+类,python中如何定义和调用类详解

python+类,python中如何定义和调用类详解详细介绍

本文目录一览： python中什么叫类

python中什么叫类?可以视为种类或者类型的同义词。所有的对象都属于某一个类，称为类的实例。例如：鸟就是"鸟类"的实例。这就是一个有很多子类的一般（抽象）类：看到的鸟可能属于子类"百灵鸟"。可以将"鸟类"想象成所有鸟的集合，而"百灵鸟类"是其中的一个子集。当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的子类，所以"百灵鸟类"是"鸟类"的子类，"鸟类"是"百灵鸟类"的超类定义子类只是个定义更多方法的过程.创建类>>> class Person: def setName(self,name): self.name=name def getName(self): return self.name def greet(self): print "Hello,world! I'm %s" % self.name >>> foo=Person()>>> bar=Person()>>> foo.setName('Nsds')>>> bar.setName('Ysdy')>>> foo.greet()Hello,world! I'm Nsds>>> bar.greet()Hello,world! I'm Ysdy在调用foo的setName和greet函数时，foo自动将自己作为第一个参数传入函数中，因此命名为self。没有self的话，成员方法就没法访问他们要对其特性进行操作的对象本身了特性是可以外部访问的：>>> foo.name'Nsds'>>> bar.name='Yoda'>>> bar.greet()Hello,world! I'm Yoda 特性、函数、方法self参数事实上正是方法和函数的区别。方法将它们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供。所以可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了：（特性是对象内部的变量，对象的状态由它的特性来描述，对象的方法可以改变它的特性，可以直接从对象外部访问特性）>>> class Class: def method(self): print 'I have a self!' >>> def function(): print "I don't...">>> s=Class()>>> s.method()I have a self!>>> s.method=function>>> s.method()I don't...变量birdsong引用绑定方法bird.sing上，还是对self参数的访问（仍旧绑定到类的相同实例上）>>> class Bird: song='Squaawk' def sing(self): print self.song >>> bird=Bird()>>> bird.sing()Squaawk>>> birdsong=bird.sing>>> birdsong()Squaawk在名称前加上双下划线，可以让方法或者特性变为私有（从外部无法访问）>>> class Secretive: def __inaccessible(self): print "Bet you can't see me..." def accessible(self): print "The secret message is:" self.__inaccessible() >>> s=Secretive()>>> s.__inacessible()Traceback (most recent call last): File "

", line 1, in

s.__inacessible()AttributeError: 'Secretive' object has no attribute '__inacessible'>>> s.accessible()The secret message is:Bet you can't see me... 在类的内部定义中，所有以双下划线开的名字都被"翻译"成前面加上单下划线和类名的形式>>> Secretive._Secretive__inaccessible

>>> s._Secretive__inaccessible()Bet you can't see me...类的命名空间 定义类时，所有位于class语句中的代码都在特殊的命名空间中执行---类的命名空间。这个命名空间可由类内所有成员访问。类的定义其实就是执行代码块>>> =+=1 >>> m1=>>>>>>1>>> m1.members=2>>>2>>> m2=>>>>>>2>>>>>>3>>>2>>> 新members值被写到了m1的特性中，屏蔽了类范围内的变量超类>>> class Filter: def init(self): self.blocked=[] def filter(self,sequence): return [x for x in sequence if x not in self.blocked] >>> class SPAMFilter(Filter): def init(self): self.blocked=['SPAM'] >>> f=Filter()>>> f.init()>>> f.filter([1,2,3])[1, 2, 3]>>> s=SPAMFilter()>>> s.init()>>> s.filter(['SPAM','SPAM','egg','name','ff'])['egg', 'name', 'ff']继承，超类>>> class Filter: def init(self): self.blockes=[] def filter(self,sequence): return [x for x in sequence if x not in self.blocked] >>> class S(Filter): def init(self): self.blocked=['s'] >>> f=Filter()>>> f.init()>>> f.filter([1,2,3])多个超类先继承的类中的方法会重写后继承的类中的方法>>> class C(): def calculate(self,expression): self.value=eval(expression) >>> class Talker(): def talk(self): print 'Hi,my value is',self.value >>> class TalkingCalculator(C,Talker): pass>>> tc=TalkingCalculator()>>> tc.calculate('1+2*3')>>> tc.talk()Hi,my value is 7 相关推荐：《Python教程》

python类的定义

在面向对象程序设计，类（英语：class）是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法。
类的更严格的定义是由某种特定的元数据所组成的内聚的包。它描述了一些对象的行为规则，而这些对象就被称为该类的实例。类有接口和结构。接口描述了如何通过方法与类及其实例互操作，而结构描述了一个实例中数据如何划分为多个属性。类是与某个层
[1]的对象的最具体的类型。类还可以有运行时表示形式（元对象），它为操作与类相关的元数据提供了运行时支持。
支持类的编程语言在支持与类相关的各种特性方面都多多少少有一些微妙的差异。大多数都支持不同形式的类继承。许多语言还支持提供封装性的特性，比如访问修饰符。类的出现，为面向对象编程的三个最重要的特性（封装性，继承性，多态性），提供了实现的手段。
在现实世界中，经常有属于同一个类的对象。例如，某辆自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们创建一个蓝图。对象的软件蓝图称为类。
类是定义同一类所有对象的变量和方法的蓝图或原型。例如，可以创建一个定义包含当前档位等实例变量的自行车类。这个类也定义和提供了实例方法（变档、刹车）的实现。
实例变量的值由类的每个实例提供。因此，当创建自行车类以后，必须在使用之前对它进行实例化。当创建类的实例时，就创建了这种类型的一个对象，然后系统为类定义的实例变量分配内存。然后可以调用对象的实例方法实现一些功能。相同类的实例共享相同的实例方法。
除了实例变量和方法，类也可以定义类变量和类方法。可以从类的实例中或者直接从类中访问类变量和方法。类方法只能操作类变量 - 不必访问实例变量或实例方法。
系统在第一次在程序中遇到一个类时为这个类创建它的所有类变量的拷贝 - 这个类的所有实例共享它的类变量。
对象和类的说明其实很相似。实际上，类和对象之间的差别经常是一些困惑的起源。在现实世界中很明显，类不是它描述的对象 - 自行车的蓝图不是自行车。但是在软件中就有点难区分类和对象。这部分是由于软件对象只是现实世界的电子模型或抽象概念。但是也由于很多人用“对象”指类和它们的实例这两者。

python中class代表什么

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
在面向对象程序设计，类（英语：class）是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法。类的更严格的定义是由某种特定的元数据所组成的内聚的包。
class就是类定义。就是把数据及其上的操作封装的单元。支持面向对象的语言都有这个概念。比如c++，java之类的。
通常classMeta可以放在外面。不过，这样它就不能直接访问父类的一些属性了。所以在python里class如果放在另一个class里面，通常并不是为了隐藏这个class，并不是让别人看不到它。而因为它需要父类里的一些属性。需要共享。
类Class：用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。类定义完成时（正常退出），就创建了一个类对象。

python里class是什么

在面向对象的程序设计过程中有两个重要概念：类（class）和对象（object，也被称为实例，instance），其中类是某一批对象的抽象，可以把类理解成某种概念；对象才是一个具体存在的实体。从这个意义上看，日常所说的人，其实都是人的对象，而不是人类。Python 定义类的简单语法如下：class 类名： 执行语句... 零个到多个类变量... 零个到多个方法...类名只要是一个合法的标识符即可，但这仅仅满足的是 Python 的语法要求：如果从程序的可读性方面来看，Python 的类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。从上面定义来看，Python 的类定义有点像函数定义，都是以冒号（:）作为类体的开始，以统一缩进的部分作为类体的。区别只是函数定义使用 def 关键字，而类定义则使用 class 关键字。Python 的类定义由类头（指 class 关键字和类名部分）和统一缩进的类体构成，在类体中最主要的两个成员就是类变量和方法。如果不为类定义任何类变量和方法，那么这个类就相当于一个空类，如果空类不需要其他可执行语句，则可使用 pass 语句作为占位符。例如，如下类定义是允许的：class Empty: pass通常来说，空类没有太大的实际意义。类中各成员之间的定义顺序没有任何影响，各成员之间可以相互调用。Python 类所包含的最重要的两个成员就是变量和方法，其中类变量属于类本身，用于定义该类本身所包含的状态数据：而实例变量则属于该类的对象，用于定义对象所包含的状态数据：方法则用于定义该类的对象的行为或功能实现。Python 是一门动态语言，因此它的类所包含的类变量可以动态增加或删除（程序在类体中为新变量赋值就是增加类变量），程序也可在任何地方为已有的类增加变量；程序可通过 del 语句删除己有类的类变量。类似的是，Python 对象的实例变量也可以动态增加或删除（只要对新实例变量赋值就是增加实例变量），因此程序可以在任何地方为己有的对象增加实例变量；程序可通过 del 语句删除已有对象的实例变量。在类中定义的方法默认是实例方法，定义实例方法的方法与定义函数的方法基本相同，只是实例方法的第一个参数会被绑定到方法的调用者（该类的实例），因此实例方法至少应该定义一个参数，该参数通常会被命名为 self。注意：实例方法的第一个参数并不一定要叫 self，其实完全可以叫任意参数名，只是约定俗成地把该参数命名为 self，这样具有最好的可读性。在实例方法中有一个特别的方法：__init__，这个方法被称为构造方法。构造方法用于构造该类的对象，Python 通过调用构造方法返回该类的对象（无须使用 new）。Python 中很多这种以双下划线开头、双下划线结尾的方法，都具有特殊的意义，本教程后面还会详细介绍这些特殊的方法。构造方法是一个类创建对象的根本途径，因此 Python 还提供了一个功能：如果开发者没有为该类定义任何构造方法，那么 Python 会自动为该类定义一个只包含一个 self 参数的默认的构造方法。下面程序将定义一个 Person 类：class Person : '这是一个学习Python定义的一个Person类' # 下面定义了一个类变量 hair = 'black' def __init__(self, name = 'Charlie', age=8): # 下面为Person对象增加2个实例变量 self.name = name self.age = age # 下面定义了一个say方法 def say(self, content): print(content)上面的 Person 类代码定义了一个构造方法，该构造方法只是方法名比较特殊：__init__，该方法的第一个参数同样是 self，被绑定到构造方法初始化的对象。

python中如何定义类

什么是类？用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。什么是方法？类中的函数即为方法如何定义一个类？定义类，语法格式如下：class ClassName:

. . .

python中使用class关键字来定义类，类的命名规则是每个单词的首字母都要大写。类对象类对象支持两种操作：属性引用和实例化。属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:class MyClass: """一个简单的类实例""" i = 12345 def f(self): return 'hello world' # 实例化类x = MyClass() # 访问类的属性和方法print("MyClass 类的属性 i 为：", x.i)print("MyClass 类的方法 f 输出为：", x.f())以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。执行以上程序输出结果为：MyClass 类的属性 i 为： 12345MyClass 类的方法 f 输出为： hello world类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：def __init__(self): self.data = []类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass，对应的 __init__() 方法就会被调用:x = MyClass()当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:class Complex: def __init__(self, realpart, imagpart): self.r = realpart self.i = imagpartx = Complex(3.0, -4.5)print(x.r, x.i) # 输出结果：3.0 -4.5

python中如何定义和调用类详解

类的方法的定义1.def fun_name(self,...); Pass2.其中的参数self代表类的实例，在调用方法时由系统自动提供3.方法定义时必须指明self参数类的方法的调用与普通的函数调用类似1.类的内部调用：self.

(参数列表)。2.在类的外部调用：

.

(参数列表)。注意：以上两种调用方法中，提供的参数列表中都不用包括self。演示一个类：wash.pyclass Washer: def init(self): self.water = 0 self.scour = 0 def add_water(self,water): print('Add water:',water) self.water = water def add_scour(self,scour): self.scour = scour print('Add scour:',self.scour) def start_wash(self): print('Start wash...') if name == 'main': w = Washer() w.add_water(10) w.add_scour(2) w.start_wash()程序的运行结果为：修改程序如图所示：washa.pyclass Washer: def init(self): self.water = 10 self.scour = 2 def set_water(self,water): self.water = water def set_scour(self,scour): self.scour = scour def add_water(self): print('Add water:',self.water) def add_scour(self): print('Add scour:',self.scour) def start_wash(self): self.add_water() self.add_scour() print('Start wash...') if name == 'main': w = Washer() w.set_water(20) w.set_scour(4) w.start_wash()程序的运行结果为：类内方法相互调用1.在一个类的内部方法之间是可以相应调用的2.调用方法同上面所述的在类的内部调用方法构造方法及其作用1.构造方法就是前面课程提到和使用的_init_()方法。2.构造方法的作用就是在类实例化时初始化实例。3._init_()方法就是类实例化的第一步自动调用的函数。4.注意其方法名是固定的，但其参数同普通方法一样，至少应带有self参数。5.初始化实例包括：定义和初始化实例属性：或调用类的一些方法。6.构造方法可以带有除self外的其它各种参数（关键字参数、默认参数、用元组收集参数、用字典收集关键字参数等）；可以达到实例化类时，为相应的属性传入指定的值。程序演示：washb.pyclass Washer: def init(self,water=10,scour=2): self.water = water self.scour = scour def set_water(self,water): self.water = water def set_scour(self,scour): self.scour = scour def add_water(self): print('Add water:',self.water) def add_scour(self): print('Add scour:',self.scour) def start_wash(self): self.add_water() self.add_scour() print('Start wash...') if name == 'main': # w = Washer() # w.start_wash() wb = Washer(100,10) wb.set_water(50) wb.set_scour(5) wb.start_wash()程序的运行结果为：【相关推荐】1. python类继承讲解2. 解析Python类的动态修改的实例代码3. 详解python类实例分析4. 详解详细介绍l了Python类的继承5. python类方法与对象方法介绍

python中关于类与实例如何绑定属性与方法的代码实例

最近在学习python，纯粹是自己的兴趣爱好，然而并没有系统地看python编程书籍，觉得上面描述过于繁琐，在网站找了一些学习的网站，下面这篇文章主要给大家介绍了关于python中类和实例时如何绑定属性与方法的相关资料，需要的朋友可以参考下。前言python类与实例的方法的调用中觉得云里雾里，思考之后将自己的想法记录下，一来加深自己理解，巩固自己记忆，而来帮助一些想要学习python的朋友理解这门抽象的语言，由于Python是动态语言，类以及根据类创建的实例可以任意绑定属性以及方法，下面分别介绍。1.类绑定属性类绑定属性可以直接在class中定义属性，这种属性是类属。 class Student(object): name = 'Student'这个属性虽然归类所有，但类的所有实例都可以访问到。class Student(object): name = 'Student's = Student() # 创建实例sprint(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性print(Student.name) # 打印类的name属性StudentStudent此时如果修改s.name的值，会有如下结果：s.name = 'xiaoming' # 给实例绑定name属性print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问xiaomingStudent接下来删除s.name属性：del s.name # 如果删除实例的name属性print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了Student由此可见相同名称的实例属性将覆盖类属性，删除实例属性后，实例将向上访问到类属性。2.实例绑定属性实例绑定属性的方法有两种，一是通过类的self变量，二是直接给实例赋值。class Student(object): def __init__(self, name): self.name = names = Student('Bob')#方法一 通过类的self变量绑定属性s.score = 90#方法二 直接赋值3.类绑定方法类绑定方法分两种，第一种形如类绑定属性，例程如下：Class Student(object): passa=Student()#创建实例def set_score(self,score): self.score=scoreStudent.set_score=set_score#类绑定方法a.set_score(99)#调用方法a.score99#输出第二种是使用MethodType给类绑定方法：Class Student(object): passa=Student()#创建实例def set_score(self,score): self.score=scorefrom types import MethodTypeStudent.set_score = MethodType(set_score, Student)a.set_score(99)#调用方法a.score99#输出这种方法有一个需要注意的地方，如果继续创建一个实例b：b=Student()b.set_score(60)b.scorea.score60会发现a的属性score值也变成60。这里个人的理解是这里的score并不是同上一种方法一样直接绑定在类，而是类似于像列表一样的共享引用的关系，即实例a和b都引用这个score作为自己的属性，而当其被修改时，所有引用它的实例的对应属性都将一同发生变化。4.实例绑定方法第一种通过给类绑定方法，可以使实例调用，如上所示。第二种是使用MethodType给单个实例绑定方法。Class Student(object): passa=Student()#创建实例def set_score(self,score): self.score=scorefrom types import MethodTypea.set_score = MethodType(set_score, a)a.set_score(99)#调用方法a.score99#输出注意这种方式只对实例a起作用，如果需要类Studnet的所有实例均可调用，那么直接给类Student绑定方法即可。总结

python如何调用类方法

python中的类用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。要想调用类中的方法，首先要定义一个类，python中定义类使用class关键字class Person(): def __init__(self,name,age):#__init__()方法为类的构造方法 self.name = name self.age = age def detail(self):(通过self调用被封装的内容) print(self.name) print(self.age)obj1 = Person('santos',18)obj1.detail() #python将obj1传给self参数python调用类中的方法有两种方式：通过对象直接调用和通过self间接调用。

简单介绍Python中的几种数据类型

大体上把Python中的数据类型分为如下几类：Number（数字） 包括int,long,float,complex String（字符串） 例如：hello,"hello",hello List（列表） 例如：[1,2,3],[1,2,3,[1,2,3],4] Dictionary（字典） 例如：{1:"nihao",2:"hello"} Tuple（元组） 例如：(1,2,3,abc) Bool（布尔） 包括True、False 由于Python中认为所有的东西都是对象，所以Python不用像其它一些高级语言那样主动声明一个变量的类型。例如我要给一个变量i赋值100，python的实现 ：i=100 C#的实现：int i = 100; 下面一一简单介绍这几种数据类型数字类型int和long之所以要把int和long放在一起的原因是python3.x之后已经不区分int和long,统一用int。python2.x还是区分的。下面我以Python2.7为例：>>> i = 10 >>> type(i) >>> i=10000000000 >>> type(i) 那么为什么10就是int,10000000000就是long呢，当然这就和int的最大值有关了，int类型的最大值为231-1，即2147483647，也可以用sys.maxint。>>> 2**31-1 2147483647L >>> sys.maxint 2147483647 为什么用上面的方法求的值就是long型的呢（数字后面加‘L'表示是long型），因为2**31的值为2147483648,这个值是一个long型，用一个long型减去1，结果还是一个long,但实际上int型的最大值就是2147483647>>> type(2147483647) >>> type(2147483648) float类型float类型和其它语言的float基本一致，浮点数，说白了，就是带小数点的数，精度与机器相关。例如：>>> i = 10000.1212 >>> type(i) complex：复数类型，具体含义及用法可自行查看相关文档。字符串类型字符串的声明有三种方式：单引号、双引号和三引号（包括三个单引号或三个双引号）。例如：>>> str1 = 'hello world' >>> str2 = "hello world" >>> str3 = '''hello world''' >>> str4 = """hello world""" >>> print str1 hello world >>> print str2 hello world >>> print str3 hello world >>> print str4 hello world Python中的字符串有两种数据类型：str类型和unicode类型。str类型采用的ASCII编码，也就是说它无法表示中文。unicode类型采用unicode编码，能够表示任意字符，包括中文及其它语言。并且python中不存在像c语言中的char类型，就算是单个字符也是字符串类型。字符串默认采用的ASCII编码，如果要显示声明为unicode类型的话，需要在字符串前面加上'u'或者'U'。例如：>>> str1 = "hello" >>> print str1 hello >>> str2 = u"中国" >>> print str2 中国 由于项目中经常出现对字符串的操作，而且由于字符串编码问题出现的问题很多，下面，来说一下关于字符串的编码问题。在与python打交道的过程中经常会碰到ASCII、Unicode和UTF-8三种编码。具体的介绍请参见这篇文章。我简单的理解就是，ASCII编码适用英文字符，Unicode适用于非英文字符（例如中文、韩文等），而utf-8则是一种储存和传送的格式，是对Uncode字符的再编码（以8位为单位编码）。例如：u = u'汉' print repr(u) # u'u6c49' s = u.encode('UTF-8') print repr(s) # 'xe6xb1x89' u2 = s.decode('UTF-8') print repr(u2) # u'u6c49' 解释：声明unicode字符串”汉“，它的unicode编码为”u6c49“，经过utf-8编码转换后，它的编码变成”xe6xb1x89“。对于编码的经验总结：1.在python文件头声明编码格式 ；#-*- coding: utf-8 -*- 2.将字符串统一声明为unicode类型，即在字符串前加u或者U;3.对于文件读写的操作，建议适用codecs.open()代替内置的open()，遵循一个原则，用哪种格式写，就用哪种格式读；假设在一个以ANSI格式保存的文本文件中有“中国汉字”几个字，如果直接用以下代码，并且要在GUI上或者在一个IDE中打印出来（例如在sublime text中，或者在pydev中打印），就会出现乱码或者异常，因为codecs会依据文本本身的编码格式读取内容：f = codecs.open("d:/test.txt") content = f.read() f.close() print content 改用如下方法即可（只对中文起作用）：# -*- coding: utf-8 -*- import codecs f = codecs.open("d:/test.txt") content = f.read() f.close() if isinstance(content,unicode): print content.encode('utf-8') print "utf-8" else: print content.decode('gbk').encode('utf-8') 列表类型列表是一种可修改的集合类型，其元素可以是数字、string等基本类型，也可以是列表、元组、字典等集合对象，甚至可以是自定义的类型。其定义方式如下：>>> nums = [1,2,3,4] >>> type(nums) >>> print nums [1, 2, 3, 4] >>> strs = ["hello","world"] >>> print strs ['hello', 'world'] >>> lst = [1,"hello",False,nums,strs] >>> type(lst) >>> print lst [1, 'hello', False, [1, 2, 3, 4], ['hello', 'world']] 用索引的方式访问列表元素，索引从0开始,支持负数索引，-1为最后一个.>>> lst = [1,2,3,4,5] >>> print lst[0] 1 >>> print lst[-1] 5 >>> print lst[-2] 4 支持分片操作，可访问一个区间内的元素，支持不同的步长，可利用分片进行数据插入与复制操作nums = [1,2,3,4,5] print nums[0:3] #[1, 2, 3] #前三个元素 print nums[3:] #[4, 5] #后两个元素 print nums[-3:] #[3, 4, 5] #后三个元素 不支持nums[-3:0] numsclone = nums[:] print numsclone #[1, 2, 3, 4, 5] 复制操作 print nums[0:4:2] #[1, 3] 步长为2 nums[3:3] = ["three","four"] #[1, 2, 3, 'three', 'four', 4, 5] 在3和4之间插入 nums[3:5] = [] #[1, 2, 3, 4, 5] 将第4和第5个元素替换为[] 即删除["three","four"] 支持加法和乘法操作lst1 = ["hello","world"] lst2 = ['good','time'] print lst1+lst2 #['hello', 'world', 'good', 'time'] print lst1*5 #['hello', 'world', 'hello', 'world', 'hello', 'world', 'hello', 'world', 'hello', 'world'] 列表所支持的方法，可以用如下方式查看列表支持的公共方法：>>> [x for x in dir([]) if not x.startswith("__")] ['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] def compare(x,y): return 1 if x>y else -1 #【append】 在列表末尾插入元素 lst = [1,2,3,4,5] lst.append(6) print lst #[1, 2, 3, 4, 5, 6] lst.append("hello") print lst #[1, 2, 3, 4, 5, 6] #【pop】 删除一个元素，并返回此元素的值 支持索引 默认为最后一个 x = lst.pop() print x,lst #hello [1, 2, 3, 4, 5, 6] #默认删除最后一个元素 x = lst.pop(0) print x,lst #1 [2, 3, 4, 5, 6] 删除第一个元素 #【count】 返回一个元素出现的次数 print lst.count(2) #1 #【extend】 扩展列表 此方法与“+”操作的不同在于此方法改变原有列表，而“+”操作会产生一个新列表 lstextend = ["hello","world"] lst.extend(lstextend) print lst #[2, 3, 4, 5, 6, 'hello', 'world'] 在lst的基础上扩展了lstextend进来 #【index】 返回某个值第一次出现的索引位置，如果未找到会抛出异常 print lst.index("hello") #5 #print lst.index("kitty") #ValueError: 'kitty' is not in list 出现异常 #【remove】 移除列表中的某个元素，如果待移除的项不存在，会抛出异常 无返回值 lst.remove("hello") print lst #[2, 3, 4, 5, 6, 'world'] "hello" 被移除 #lst.remove("kitty") #ValueError: list.remove(x): x not in list #【reverse】 意为反转 没错 就是将列表元素倒序排列,无返回值 print lst #[2, 3, 4, 5, 6, 'world'] lst.reverse() print lst #[2, 3, 4, 5, 6, 'world'] #【sort】 排序 print lst #由于上面的反转 目前排序为 ['world', 6, 5, 4, 3, 2] lst.sort() print lst #排序后 [2, 3, 4, 5, 6, 'world'] nums = [10,5,4,2,3] print nums #[10,5,4,2,3] nums.sort(compare) print nums #[2, 3, 4, 5, 10] 列表转换为迭代器。所谓的迭代器就是具有next方法（这个方法在调用时不需要任何参数）的对象。在调用next方法时，迭代器会返回它的下一个值。如果next方法被调用，但迭代器没有值可以返回，就会引发一个StopIteration异常。迭代器相对于列表的优势在于，使用迭代器不必一次性将列表加入内存，而可以依次访问列表的数据。依然用上面的方法查看迭代器的公共方法：lst = [1,2,3,4,5] lstiter = iter(lst) print [x for x in dir(numiter) if not x.startswith("__")] >>>['next'] 没错，只有next一个方法，对于一个迭代器，可以这样操作：lst = [1,2,3,4,5] lstiter = iter(lst) for i in range(len(lst)): print lstiter.next() #依次打印 1 2 3 4 5 元组类型元组类型和列表一样，也是一种序列，与列表不同的是，元组是不可修改的。元组的声明如下：lst = (0,1,2,2,2) lst1=("hello",) lst2 = ("hello") print type(lst1) # 只有一个元素的情况下后面要加逗号 否则就是str类型 print type(lst2) # 字典类型字典类型是一种键值对的集合，类似于C#中的Dictionary或js中的json对象。其初始化方法如下：dict1 = {} print type(dict1) # 声明一个空字典 dict2 = {"name":"kitty","age":18} #直接声明字典类型 dict3 = dict([("name","kitty"),("age",18)]) #利用dict函数将列表转换成字典 dict4 = dict(name='kitty',age=18) #利用dict函数通过关键字参数转换为字典 dict5 = {}.fromkeys(["name","age"]) #利用fromkeys函数将key值列表生成字典，对应的值为None {'age': None, 'name': None} 字典基本的操作方法：#【添加元素】 dict1 = {} dict1["mykey"] = "hello world" #直接给一个不存在的键值对赋值 即时添加新元素 dict1[('my','key')] = "this key is a tuple" #字典的键可以是任何一中不可变类型，例如数字、字符串、元组等 #【键值对个数】 print len(dict1) #【检查是否含有键】 print "mykey" in dict1 #True 检查是否含有键为mykey的键值对 print "hello" in dict1 #False #【删除】 del dict1["mykey"] #删除键为mykey的键值对 继续利用上面的方法查看字典的所有公共方法：>>> [x for x in dir({}) if not x.startswith("__")] ['clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues'] dict.clear() 删除字典中所有元素 dict.copy() 返回字典(浅复制)的一个副本 dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value，如果字典中不存在此键，则返回default 的值(注意，参数default 的默认值为None) dict.has_key(key) 如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2版本引入in 和not in 后，此方法几乎已废弃不用了，但仍提供一个 可工作的接口。 dict.items() 返回一个包含字典中(键, 值)对元组的列表 dict.keys() 返回一个包含字典中键的列表 dict.values() 返回一个包含字典中所有值的列表 dict.iter() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代器，而不是一个列表。 dict.pop(key[, default]) 和方法get()相似，如果字典中key 键存在，删除并返回dict[key]，如果key 键不存在，且没有给出default 的值，引发KeyError 异常。 dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。 dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。 布尔类型布尔类型即True和False,和其它语言中的布尔类型基本一致。下面列出典型的布尔值print bool(0) #False print bool(1) #True print bool(-1) #True print bool([]) #False print bool(()) #False print bool({}) #False print bool('') #False print bool(None) #False

如何在Python中使用static,class,abstract方法

Python使用函数默认值实现函数静态变量的方法，具体方法如下：Python函数默认值Python函数默认值的使用可以在函数调用时写代码提供方便，很多时候我们只要使用默认值就可以了。
类是具有相同属性和方法的一组对象的集合。在Python中，对象是类的实例，类是对象的抽象。定义类定义类的语法和定义函数的语法类似，定义函数使用的关键字是def，而定义类使用的关键字是class。
抽象方法是基类中定义的方法，但却没有任何实现。在java中，可以把方法申明成一个接口。
·通过用C等语言编写扩展来提升Python应用程序的性能，或者通过使用多线程增强1/0相关的应用程序的能力；·学习Python中有关数据库的API，以及如何在Python中使用各种不同的数据库系统，包括MySQL、Postgres和SQLite。
类成员方法无法访问实例变量但是可以访问类变量使用的区别：由于静态方法无法访问类属性，实例属性，相当于一个相对独立的方法，跟类其实并没有什么关系。这样说来，静态方法就是在类的作用域里的函数而已。