python学习笔记1---class
Python 的 Class 比较特别,和我们习惯的静态语言类型定义有很大区别。
1. 使用一个名为 __init__ 的方法来完成初始化。
2. 使用一个名为 __del__ 的方法来完成类似析购操作。
3. 所有的实例方法都拥有一个 self 参数来传递当前实例,类似于 this。
4. 可以使用 __class__ 来访问类型成员
def __init__(self):
print "initialize."
def Foo(self):
print id(self)
>>>>>> a = MyClass()
initialize.
>>>>>> a.Foo()
14412576
>>>>>> id(a)
14412576
Class 有一些特殊的属性,便于我们获得一些额外的信息。
"""This is MyClass's Docoment"""
def __init__(self):
self.i = 1234
>>>>>> MyClass.__doc__ # 类型帮助信息
"This is MyClass's Docoment""This is MyClass's Docoment"
>>>>>> MyClass.__name__ # 类型名称
'MyClass'
>>>>>> MyClass.__module__ # 类型所在模块
'__main__'
>>>>>> MyClass.__bases__ # 类型所继承的基类(Python 支持多继承)
(<type 'object'>,)
>>>>>> MyClass.__dict__ # 类型字典,存储所有类型成员信息
<dictproxy object at 0x00DC1AD0>
>>>>>> #以下是实例拥有的属性
>>>>>> MyClass().__class__ # 实例的类型
<class '__main__.MyClass'>
>>>>>> MyClass().__module__ # 实例类型所在模块
'__main__'
>>>>>> MyClass().__dict__ # 对象字典,存储所有实例成员信息
{'i': 1234}
>>>>>>
继承
Python 支持多继承,但有几点需要注意:
1. 基类 __init__ / __del__ 需显示调用。
2. 继承方法的调用和基类声明顺序有关。
def __init__(self):
print "Base1"
def test(self):
print "Base1 test"
>>>>>> class Base2:
def __init__(self):
print "Base2"
def test(self):
print "Base2 test"
>>>>>> class MyClass(Base2,Base1):
def __init__(self):
Base1.__init__(self)
Base2.__init__(self)
print "MyClass"
>>>>>> a = MyClass()
Base1
Base2
MyClass
>>>>>> a.test()
Base2 test
>>>>>> # 下面把 Base1 放在前面
>>>>>> class MyClass(Base1,Base2):
def __init__(self):
Base1.__init__(self)
Base2.__init__(self)
print "MyClass"
>>>>>> a = MyClass()
Base1
Base2
MyClass
>>>>>> a.test()
Base1 test
>>>>>>
成员
Python Class 同样包含类型和实例两种成员。
i = 123 # 类成员
def __init__(self):
self.i = 100 # 实例成员
>>>>>> print Class1.i
123
>>>>>> print Class1().i
100
>>>>>>
有几个很 "特殊" 的 "规则" 需要注意。
(1) 我们可以通过实例引用访问类型成员。因此下面的例子中 self.i 实际指向 Class1.i,直到我们为实例新增了一个成员 i。
>>>>>> class Class1:
i = 123
def __init__(self):
print self.i
print hex(id(self.i))
>>>>>> hex(id(Class1.i)) # 显示 Class1.i 的地址
'0xab5860'
>>>>>> a = Class1() # 创建 Class1 实例,我们会发现 self.i 实际指向 Class1.i
123
0xab5860
>>>>>> Class1.__dict__ # 显示 Class1 成员
{'i': 123, '__module__': '__main__', '__doc__': None, '__init__': <function __init__ at 0x012911B0>}
>>>>>> a.__dict__ # 显示实例成员
{}
>>>>>> a.i = 100 # 为实例新增加一个成员i
>>>>>> hex(id(a.i)) # 显示新成员i的地址
'0xab5974'
>>>>>> a.__dict__ # 显示实例成员
{'i': 100}
>>>>>>
(2) 调用类型内部方法,需要省略 self 参数。
def __init__(self):
self.__test("Hello Python")
def __test(self, s):
print s
>>>>>> Class1()
Hello Python
<__main__.Class1 instance at 0x00DC3800>
>>>>>>
我们可以在成员名称前添加 "__" 使其成为私有成员。
__i = 123
def __init__(self):
self.__x = 0
def __test(self):
print id(self)
>>>>>> Class1.i
Traceback (most recent call last):
File "", line 1, in <module>
Class1.i
AttributeError: class Class1 has no attribute 'i'
>>>>>> Class1().__x
Traceback (most recent call last):
File "", line 1, in <module>
Class1().__x
AttributeError: Class1 instance has no attribute '__x'
>>>>>> Class1().__test()
Traceback (most recent call last):
File "", line 1, in <module>
Class1().__test()
AttributeError: Class1 instance has no attribute '__test'
>>>>>>
事实上这只是一种规则,并不是编译器上的限制。我们依然可以用特殊的语法来访问私有成员。
123
>>>>>> a = Class1()
>>>>>> a._Class1__x
0
>>>>>> a._Class1__test()
14432256
>>>>>>
除了静态(类型)字段,我们还可以定义静态方法。
@staticmethod
def test():
print "In Static method"
>>>>>> Class1.test()
In Static method
>>>>>>
从设计的角度,或许更希望用属性(property)来代替字段(field)。
def __init__(self):
self.__i = 1234
def getI(self): return self.__i
def setI(self, value): self.__i = value
def delI(self): del self.__i
I = property(getI, setI, delI, "Property I")
>>>>>> a = Class1()
>>>>>> a.I
1234
>>>>>> a.I = 1000
>>>>>> a.I
1000
如果只是 readonly property,还可以用另外一种方式。
def __init__(self):
self.__i = 1234
@property
def I(self):
return self.__i
>>>>>> a = Class1()
>>>>>> a.I
1234
用 __getitem__ 和 __setitem__ 可以实现 C# 索引器的功能。
def __init__(self):
self.__x = ["a", "b", "c"]
def __getitem__(self, key):
return self.__x[key]
def __setitem__(self, key, value):
self.__x[key] = value
>>>>>> a = Class1()
>>>>>> a[1]
'b'
>>>>>> a[1] = "xxx"
>>>>>> a[1]
'xxx'
>>>>>>
Python-类变量,成员变量,静态变量,类方法,静态方法,实例方法,普通函数
#coding:utf-8class class_name(object):class_var = 'I am a class variable' #类变量def __init__(self):self.instance_var = 'I am a instance varibale' #成员变量(实例变量)def instance_method(self, formal_parameter):local_var_in_function = formal_parameter #实例方法局部变量self.local_var_also_in_function = formal_parameter #实例方法局部变量def ordinary_function(formal_parameter):print "I am an ordinary function, I can't vist class var and intance var"print self.instance_var #报错,因此普通函数无法访问成员函数print clacc_var#报错,因此普通函数无法访问类变量 @classmethoddef class_method(cls, formal_parameter): #类方法print 'I am class method, I can visit class var and instance var'print 'I am class method, I am modifying the instance var'cls.instance_var = formal_parameterprint cls.instance_varprint 'I am class method, I am modifying the class var'class_var = formal_parameterprint class_var@staticmethoddef static_method(formal_parameter):print 'I am static method, I am the Adopted son(干儿子) for this class!!'print "I can't modify anything in the class "#print class_var#print self.instance_varprint 'Get a class instance' class_instance = class_name() print '\r' print "My name is class_instance, I can call class_method, " \"statics_method, instance_method and instance_method, but I can't call ordinary_function" print "I can show you:" print '\r' class_instance.class_method('class method is calling!!') print '\r' class_instance.static_method('static method in calling!!') print '\r' class_instance.instance_method('instance method is calling!!') print '\r' print 'class var is calling!!' print class_instance.class_var print '\r' print 'instance var is calling!!' print class_instance.instance_var print '\r' print 'Get a class!!' print '\r' print 'My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function' print "I can show you:" print '\r' class_name.class_method('class method is calling!!') print '\r' class_name.static_method('static method in calling!!') print '\r' #class_name.instance_method("instance method can't be calling!!") print '\r' print 'class var is calling!!' print class_name.class_var print '\r' print 'instance var is calling!!' print class_name.instance_var print 'END!!'Result:
Get a class instance
My name is class_instance, I can call class_method, statics_method, instance_method and instance_method, but I can't call ordinary_function
I can show you:
I am class method, I can visit class var and instance var
I am class method, I am modifying the instance var
class method is calling!!
I am class method, I am modifying the class var
class method is calling!!
I am static method, I am the Adopted son(干儿子) for this class!!
I can't modify anything in the class
class var is calling!!
I am a class variable
instance var is calling!!
I am a instance varibale
Get a class!!
My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function
I can show you:
I am class method, I can visit class var and instance var
I am class method, I am modifying the instance var
class method is calling!!
I am class method, I am modifying the class var
class method is calling!!
I am static method, I am the Adopted son(干儿子) for this class!!
I can't modify anything in the class
class var is calling!!
I am a class variable
instance var is calling!!
class method is calling!!
END!!
类变量:
类定义内部定义的变量(愚见,可以认为类内部没有self开头定义的变量,可以认为是类变量)
e.g. class_name中的class_var = 'I am a class variable' #类变量
成员变量:
类定义内部__init__函数内以self开头定义的变量
e.g. self.instance_var = 'I am a instance varibale' #成员变量(实例变量)
静态变量:
因为Python是动态语言,不存在完全静态的变量,这个概念查阅相关资料后认为指的就是类内部定义的类变量(欢迎指正)
类方法:
类内部定义的以@classmethod装饰的函数是类方法,类方法的调用关系可以通过print后的表述得知。
e.g. @classmethoddef class_method(cls, formal_parameter): #类方法print 'I am class method, I can visit class var and instance var'print 'I am class method, I am modifying the instance var'cls.instance_var = formal_parameterprint cls.instance_varprint 'I am class method, I am modifying the class var'class_var = formal_parameterprint class_var
静态方法:
类内部定义的以@staticmethod装饰的函数,类方法的调用关系可以通过print后的表述得知。
e.g.@staticmethoddef static_method(formal_parameter):print 'I am static method, I am the Adopted son(干儿子) for this class!!'print "I can't modify anything in the class "#print class_var#print self.instance_var
实例方法:
类内部定义的没有装饰器且第一个参数为self的函数,类方法的调用关系可以通过print后的表述得知。
e.g.def instance_method(self, formal_parameter):local_var_in_function = formal_parameter #实例方法局部变量self.local_var_also_in_function = formal_parameter #实例方法局部变量
普通函数:
类内部定义的既没有装饰器,也没有参数self的函数,类方法的调用关系可以通过print后的表述得知。
e.g. def ordinary_function(formal_parameter):print "I am an ordinary function, I can't vist class var and intance var"print self.instance_var #报错,因此普通函数无法访问成员函数print clacc_var#报错,因此普通函数无法访问类变量
1.变量
_xxx
,单下划线开头的变量,标明是一个受保护(protected)的变量,原则上不允许直接访问,但外部类还是可以访问到这个变量。这只是程序员之间的一个约定,用于警告说明这是一个私有变量,外部类不要去访问它。class Student(object): def __init__(self, name):self._name = name >>> sd = Student('Tom') >>> sd._name 'Tom'
__xxx
,双下划线开头的,表示的是私有类型(private)的变量。只能是允许这个类本身进行访问了, 连子类也不可以,用于命名一个类属性(类变量),调用时名字被改变(在类Student内部,__name
变成_Student__name
,如self._Student__name
)
双下划线开头的实例变量是不是一定不能从外部访问呢?其实也不是。仍然可以通过_Student__name
来访问__name
变量:
class Student(object):def __init__(self, name):self.__name = name
>>> sd = Student('Tom')
>>> sd.__name
Traceback (most recent call last):File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
>>> sd._Student__name
'Tom'
__xxx__
,以双下划线开头,并且以双下划线结尾的,是内置变量,内置变量是可以直接访问的,不是 private 变量,如__init__
,__import__
或是__file__
。所以,不要自己定义这类变量。xxx_
,单下划线结尾的变量一般只是为了避免与 Python 关键字的命名冲突。USER_CONSTANT
,大写加下划线,对于不会发生改变的全局变量,使用大写加下划线。
2.函数和方法
总体而言应该使用,小写和下划线。但有些比较老的库使用的是混合大小写,即首单词小写,之后每个单词第一个字母大写,其余小写。但现在,小写和下划线已成为规范。
私有方法 : 小写和一个前导下划线
def _secrete(self): print "don't test me."
这里和私有变量一样,并不是真正的私有访问权限。同时也应该注意一般函数不要使用两个前导下划线(当遇到两个前导下划线时,Python 的名称改编特性将发挥作用)。特殊函数后面会提及。
特殊方法 : 小写和两个前导下划线,两个后置下划线
def __add__(self, other): return int.__add__(other)
这种风格只应用于特殊函数,比如操作符重载等。
函数参数 : 小写和下划线,缺省值等号两边无空格
def connect(self, user=None): self._user = user
一、实例方法
实例方法就是类的实例能够使用的方法。如下:
class Foo:
def __init__(self, name):
self.name = name
def hi(self):
print self.name
if __name__ == '__main__':
foo01 = Foo('letian')
foo01.hi()
print type(Foo)
print type(foo01)
print id(foo01)
print id(Foo)
运行结果为:
letian
<type 'classobj'>
<type 'instance'>
40124704
31323448[code]
可以看到,Foo的type为classobj(类对象,python中定义的类本身也是对象),foo01的type为instance(实例)。而hi()是实例方法,所以foo01.hi()会输出'letian'。实例方法的第一个参数默认为self,代指实例。self不是一个关键字,而是约定的写法。init()是生成实例时默认调用的实例方法。将Foo的定义改为以下形式:
[code]class Foo:
def __init__(this, name):
this.name = name
def hi(here):
print here.name
运行依然正确。 内置函数id用来查看对象的标识符,下面是其doc内容:
>>> print id.__doc__
id(object) -> integer
Return the identity of an object. This is guaranteed to be unique among
simultaneously existing objects. (Hint: it's the object's memory address.)
二、静态方法
静态方法是一种普通函数,就位于类定义的命名空间中,它不会对任何实例类型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法:
class Foo:
def __init__(self, name):
self.name = name
def hi(self):
print self.name
@staticmethod
def add(a, b):
print a + b
if __name__ == '__main__':
foo01 = Foo('letian')
foo01.hi()
foo01.add(1,2)
Foo.add(1, 2)
运行结果如下:
letian
3
3
注意,很多编程语言不允许实例调用静态方法。
三、类方法
类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义,其第一个参数是类,约定写为cls。类对象和实例都可以调用类方法:
class Foo:
name = 'letian '
@classmethod
def hi(cls, x):
print cls.name * x
if __name__ == '__main__':
foo01 = Foo()
foo01.hi(2)
Foo.hi(3)
运行结果如下:
letian letian
letian letian letian
注意,很多其他的编程语言不允许实例调用类方法。
四、super
super用来执行父类中的函数,例如:
class Foo(object):
def hi(self):
print 'hi,Foo'
class Foo2(Foo):
def hi(self):
super(Foo2, self).hi()
if __name__ == '__main__':
foo2 = Foo2()
foo2.hi()
运行结果:
hi,Foo
注意,Foo类必须继承某个类(并且这个继承链开始于object类),否则会报错。如果改成下面的形式:
class Foo:
def hi(self):
print 'hi,Foo'
class Foo2(Foo):
def hi(self):
super(Foo2, self).hi()
if __name__ == '__main__':
foo2 = Foo2()
foo2.hi()
运行时报错如下:
......
TypeError: must be type, not classobj
关于super,具体请见http://docs.python.org/2/library/functions.html?highlight=super#super以及super.doc。
五、类变量和实例变量
类变量定义在类的定义之后,实例变量则是以为self.开头。例如:
class Foo(object):
val = 0
def __init__(self):
self.val = 1
if __name__ == '__main__':
foo = Foo()
print foo.val
print Foo.val
运行结果为:
1
0
实例也能够访问类变量,如下:
class Foo(object):
val = 0
def __init__(self):
pass
if __name__ == '__main__':
foo = Foo()
print foo.val
print Foo.val
运行结果如下:
0
0
另外,可以通过以下方式访问类变量:
class Foo(object):
val = 3
def __init__(self):
print self.__class__.val
if __name__ == '__main__':
foo = Foo()
运行结果:
3
还可以这样:
class Foo(object):
val = 3
def __init__(self):
pass
@classmethod
def echo(cls):
print cls.val
if __name__ == '__main__':
Foo.echo()
运行结果:
3
六、如何调用父类的构造函数
子类(派生类)并不会自动调用父类(基类)的init方法,例如:
class Foo(object):
def __init__(self):
self.val = 1
class Foo2(Foo):
def __init__(self):
print self.val
if __name__ == '__main__':
foo2 = Foo2()
运行时报错。
调用父类的init方法有两种,第一种:
class Foo(object):
def __init__(self):
self.val = 1
class Foo2(Foo):
def __init__(self):
Foo.__init__(self)
print self.val
if __name__ == '__main__':
foo2 = Foo2()
第二种:
class Foo(object):
def __init__(self):
self.val = 1
class Foo2(Foo):
def __init__(self):
super(Foo2,self).__init__()
print self.val
if __name__ == '__main__':
foo2 = Foo2()
这两种方法的运行结果均为:
1
不过这两种方法是有区别的。
python学习笔记1---class相关推荐
- [python教程入门学习]python学习笔记(CMD执行文件并传入参数)
本文章向大家介绍python学习笔记(CMD执行文件并传入参数),主要包括python学习笔记(CMD执行文件并传入参数)使用实例.应用技巧.基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋 ...
- python学习笔记之编写readConfig读写配置文件
python学习笔记之编写readConfig读写配置文件_weixin_34055910的博客-CSDN博客
- Python学习笔记(十一)
Python学习笔记(十一): 生成器,迭代器回顾 模块 作业-计算器 1. 生成器,迭代器回顾 1. 列表生成式:[x for x in range(10)] 2. 生成器 (generator o ...
- Python学习笔记一简介及安装配置
Python学习笔记一 参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e54 ...
- python学习笔记目录
人生苦短,我学python学习笔记目录: week1 python入门week2 python基础week3 python进阶week4 python模块week5 python高阶week6 数据结 ...
- Python学习笔记(二):标准流与重定向
Python学习笔记(二):标准流与重定向 - SamWei - 博客园 Python学习笔记(二):标准流与重定向 Posted on 2012-02-19 22:36 SamWei 阅读(176) ...
- python 学习笔记 12 -- 写一个脚本获取城市天气信息
近期在玩树莓派,前面写过一篇在树莓派上使用1602液晶显示屏,那么可以显示后最重要的就是显示什么的问题了. 最easy想到的就是显示时间啊,CPU利用率啊.IP地址之类的.那么我认为呢,假设可以显示当 ...
- python基本语法语句-python学习笔记:基本语法
原标题:python学习笔记:基本语法 缩进:必须使用4个空格来表示每级缩进,支持Tab字符 if语句,经常与else, elif(相当于else if) 配合使用. for语句,迭代器,依次处理迭代 ...
- 廖Python学习笔记一
1. 廖Python学习笔记 大的分类 如函数 用二级标题,下面的用三级 如输入输出 1.1.1. 输入输出 1.1.1.1. 输出 用 print() 在括号里加上字符串,就可以向屏幕上输出指定的文 ...
- Python学习笔记(六)
1. IO编程 1.1 文件读写 1.2 StringIO和BytesIO 1.3 操作文件和目录 1.4 序列化 2. 进程和线程 2.1 多进程 2.2 多线程 2.3 ThreadLocal 2 ...
最新文章
- 深度学习与计算机视觉系列(9)_串一串神经网络之动手实现小例子
- Linux 并发服务器雏形总结
- java分装_Java ——Number Math 类 装箱 拆箱 代码块
- spark.yarn.archive 的正确设置方法
- Redis与Jedis排序
- 华为交换机S3700清空配置方法
- json php 数组读写,PHP如何将数据写入JSON?
- 如何使用Cisdem Video Converter在Mac上将大型 AVI 转换为 MP4
- 开发人员需要了解的渐进式Web应用程序
- matlab根据给定3点画圆弧_圆弧齿廓面齿轮齿顶尖化研究
- 【动态规划】P1220:区间dp:关路灯
- java ssh 启动时间_java ssh项目启动异常说明
- libaio.so.1 is needed by MySQL-server-5.5.48-1.linux2.6.i386
- 小程序软件有必要申请软件著作权登记么?
- 基于Python的家谱信息管理系统
- 散户通过a股量化数据接口实现自动化实盘交易主要方式有哪些?
- [Zer0pts2020]easy strcmp 分析与加法
- filezilla下载文件,如何使用filezilla下载文件
- 简单的内网穿透接入互联网无需公网IP
- mysql 时间格式转换年月日时分秒