http://blog.csdn.net/pipisorry/article/details/50708616
python对象属性
Python一切皆对象(object)，每个对象都可能有多个属性(attribute)。Python的属性有一套统一的管理方案。
属性的__dict__系统
对象的属性可能来自于其类定义，叫做类属性(class attribute)。类属性可能来自类定义自身，也可能根据类定义继承来的。一个对象的属性还可能是该对象实例定义的，叫做对象属性(object attribute)。
对象的属性储存在对象的__dict__属性中。__dict__为一个词典，键为属性名，对应的值为属性本身。
[Python深入03 对象的属性]
python自省和反射
自省表示给予你某种能力来进行像“手工类型检查”的工作,它也被称为反射。这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么
能力,这样的功能不是很好吗?
如果 Python 不支持某种形式的自省功能,dir()和 type()内建函数,将很难正常工作。请密切关注这些调用,还有那些特殊属性,像__dict__,__name__及__doc__。
[Python自省（反射）指南]
皮皮blog


Python属性property
Python中有个很赞的概念，叫做property，它使得面向对象的编程更加简单。
深入挖掘property
在Python中，property()是一个内置函数，用于创建和返回一个property对象。该函数的签名为：
property(fget=None, fset=None, fdel=None, doc=None)
这里，fget是一个获取属性值的函数，fset是一个设置属性值的函数，fdel是一个删除属性的函数，doc是一个字符串（类似于注释）。
Property对象有三个方法
getter(), setter()和delete()，用来在对象创建后设置fget，fset和fdel。
temperature = property(get_temperature,set_temperature)可以被分解为：
# make empty property
temperature = property()
# assign fget
temperature = temperature.getter(get_temperature)
# assign fset
temperature = temperature.setter(set_temperature)
它们之间是相互等价的。
作为decorator实现
熟悉Python中装饰器decorator的程序员能够认识到上述结构可以作为decorator实现。
我们可以更进一步，不去定义名字get_temperature和set_temperature，因为他们不是必须的，并且污染类的命名空间。
为此，我们在定义getter函数和setter函数时重用名字temperature。
class Celsius:
    def __init__(self, temperature = 0):
        self._temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32
 
    @property
    def temperature(self):
        print("Getting value")
        return self._temperature
 
    @temperature.setter
    def temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value
上边的两种生成property的实现方式，都很简单，推荐使用。
[Python 中的 property 属性]
皮皮blog


property使用实例
假设有天你决定创建一个类，用来存储摄氏温度。当然这个类也需要实现一个将摄氏温度转换为华氏温度的方法。一种实现的方式如下：
class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature
    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32
我们可以用这个类产生一个对象，然后按照我们期望的方式改变该对象的温度属性：
>>> man = Celsius()
>>> man.temperature = 37
>>> man.temperature
>>> man.to_fahrenheit()
98.60000000000001
赋值或获取任何对象的属性
每当我们赋值或获取任何对象的属性时，例如上面展示的温度，Python都会从对象的__dict__字典中搜索它。
>>> man.__dict__
{'temperature': 37}
因此，man.temperature在其内部就变成了man.__dict__['temperature']
实例修改：建议温度不能低于-273摄氏度
现在，让我们进一步假设我们的类在客户中很受欢迎，他们开始在其程序中使用这个类。他们对该类生成的对象做了各种操作。有一天，一个受信任的客户来找我们，建议温度不能低于-273摄氏度。
使用Getters和Setters
对于上边的约束，一个很容易想到的解决方案是隐藏其温度属性（使其私有化），并且定义新的用于操作温度属性的getter和setter接口。
我们定义了两个新方法get_temperature()和set_temperature()，此外属性temperature也被替换为了_temperature。
class Celsius:
    def __init__(self, temperature = 0):
        self.set_temperature(temperature)
    def to_fahrenheit(self):
        return (self.get_temperature() * 1.8) + 32
    # new update
    def get_temperature(self):
        return self._temperature
    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        self._temperature = value
问题：
1. 最前边的下划线（_）用于指示Python中的私有变量。但是Python中实际上是没有私有变量的。有一些简单的被遵循的规范。Python本身不会应用任何限制。
>>> c._temperature = -300
>>> c.get_temperature()
-300
2. 最大问题：先前类的客户都必须更改他们的代码
上述更新的最大问题是，所有在他们的程序中使用了我们先前类的客户都必须更改他们的代码：obj.temperature改为obj.get_temperature()，所有的赋值语句也必须更改。更新是不向后兼容地。
Property的使用
对于上边的问题，Python式的解决方式是使用property。
class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature
 
    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32
 
    def get_temperature(self):
        print("Getting value")
        return self._temperature
 
    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value
 
    temperature = property(get_temperature,set_temperature)
我们在get_temperature()和set_temperature()的内部增加了一个print()函数，用来清楚地观察它们是否正在执行。
代码的最后一行，创建了一个property对象temperature。简单地说，property将一些代码（get_temperature和set_temperature）附加到成员属性（temperature）的访问入口。任何获取temperature值的代码都会自动调用get_temperature()，而不是去字典表（__dict__）中进行查找。
>>> c = Celsius()
Setting value
从上边的代码中我们可以看到，即使当我们创建一个对象时，__init__()方法被调用，有一行代码self.temperature = temperature。这个任务会自动调用set_temperature()方法。
>>> c.temperature
Getting value
同样的，对于属性的任何访问，例如c.temperature，也会自动调用get_temperature()方法。
>>> c.temperature = 37
Setting value
 
>>> c.to_fahrenheit()
Getting value
98.60000000000001
我们可以看到，通过使用property，我们在不需要客户代码做任何修改的情况下，修改了我们的类，并实现了值约束。因此我们的实现是向后兼容的。
最后需要注意的是，实际温度值存储在私有变量_temperature中。属性temperature是一个property对象，是用来为这个私有变量提供接口的。
皮皮blog
from:http://blog.csdn.net/pipisorry/article/details/50708616
ref: python类实例计数最优方法

文章目录
面向对象编程(OOP)
类名
对象
属性
方法
对象、属性、方法的堆、栈
一个类创建多个对象,以及内存图展示
代码
图解
两个引用指向一个对象
代码
图解
方法是对象如何调用

面向对象编程(OOP)
Object Oriented Programming


C 面向过程编程

ps : 抓药的例子,要的是抓药的过程
C++ 半面向对象,半面向过程
JAVA 面向对象编程

ps : 抓药的例子,只是看抓药的结果
类名
具有相同特点(属性)和行为(动作)的集合的总称.


比如人类 动物类 房间类 手机类等
对象
 是某一类的具体体现,实例,所存在的


将类的抽象概念具体化.


人类的对象: 张三,李四等


植物类的对象 : 路边的梧桐,杨树
属性
是一类事物的特点/特征.


人类 : 有五官,有四肢,肤色等


植物类的属性 : 树干,树叶,树根,花,果实


手机的属性 : 价格,重量,颜色,形状
方法
一类事物都可以进行的动作/行为.


人类 : 吃饭,睡觉,学习等

对象、属性、方法的堆、栈
```

1)方法执行进栈
2)new动作会在堆内存开启空间,创建对象,分配地址值
3)调用方法方法会进栈,执行后方法会弹栈


```java
package com.zhiyou100.oop;
	/*
	 * 学生类:
	 * 属性 : 姓名 年龄 学号 学校
	 * 方法 : 学习 吃饭 睡觉
	 */
public class Student {
	/*
	 * 属性的写法:
	 * [访问修饰符] 数据类型 变量名;
	 * []内的代码,public可写可不写; 
	 */
	public String name;
	public Integer age;
	public String stuNo;
	public String schoolName;
	/*
	 * [访问修饰符] 返回值类型 方法名([参数1],[参数2],...){
	 * 		方法内的执行语句;
	 * 		...
	 * }
	 * 访问修饰符 : 控制访问权限
	 * 返回值类型 : 该方法执行后返回的结果的数据类型
	 * 			基本数据类型 / 引用数据类型 / 
	 * 	    void : 返回为空,方法执行后不返回任何数据
	 *  
	 * ---
	 * 如果方法需要返回数据,
	 * 		1) 那就需要返回类型处写上返回的数据类型
	 * 		2) 在方法体的最后使用 return 值的 ; 的格式将值明确的显示返回
	 * 		3) return 后不执行任何的代码;
	 *      4) return 只能有一个值
	 * 方法名 : 见名知意,驼峰原则
	 * () 参数列表 :
	 * 		1) 形式参数 : 该方法执行可能用到的数据
	 *		2) 形式参数的写法 : 数据类型 变量名;
	 *		3) 列表内可以写多个参数,也可以不写
	 *		4) 当方法参数列表有参数时,在调用时(让方法执行时)
	 *         就必须给方法的参数赋值
	 */
	public static void main(String[] args) {
		
	}
	
	/*
	 * 游戏
	 */
	public String youXi(){
		return "赢了";
	}
	/*
	 * 学习 
	 */
	public String study(String book,String pen){
		System.out.println("学习" + book + "用的" + pen);
		return "赢了";
	}
	/*
	 * 吃 
	 */
	public void eat(){
		System.out.println("吃");
	}
	/*
	 * 睡觉 
	 */
	public void sleep(String peopleName){
		System.out.println(peopleName + "在睡觉");
	}
	
}


package com.zhiyou100.oop;
/*
 * @autor lxf
 * 测试类 
 */
public class TestOOP {

	public static void main(String[] args) {
		/* 
		 * 通过类 创建 对象 <==> 实例化
		 * 类型 对象名 = new 类名();
		 * ---------------
		 * 数据类型 变量名 = 值;
		 * ---------------
		 * 对象属性取值:
		 * 数据类型 变量名 = 对象名.属性名;
		 * 
		 * 对象属性赋值:
		 *  对象名.属性名 = 值;
		 *  
		 * 调用对象的方法
		 * 1) 方法有参数,调用时候必须传入实参
		 * 		实参与形参的个数,顺序,数据类型要保持一致
		 * 2) 方法无参数,不能给定参数
		 * 3) 方法无返回值,一定不能接收返回值
		 * 4) 方法有返回值,可以接收,也可以不接收
		 * 	A : 无返回值
		 * 		A1 无返回值无参数
		 * 			对象名.方法名();
		 * 		A2 无返回值有参数
		 * 			对象名.方法名(实参);
		 * 	B : 有返回值
		 * 		B1 有返回值无参数
		 * 			[数据类型 变量名 = (括号里的可写可不写)] 对象名.方法名();
		 * 		B2 有返回值有参数
		 * 		    [数据类型 变量名 = (括号里的可写可不写)] 对象名.方法名(实参);
		 */
		// 创建对象
		Student student = new Student();
		// 获得属性值
		Integer age = student.age;
		String name = student.name;
		String schoolName = student.schoolName;
		String stuNo = student.stuNo;
		System.out.println("name : " + name);
		System.out.println("age : " + age);
		System.out.println("schoolName : " + schoolName);
		System.out.println("stuNo : " + stuNo);
		// 属性赋值
		student.name = "张三";
		student.age = 123;
		student.schoolName = "清华大学";
		student.stuNo = "20171892";
		System.out.println("name : " + student.name);
		System.out.println("age : " + student.age);
		System.out.println("schoolName : " + student.schoolName);
		System.out.println("stuNo : " + student.stuNo);
		// A1 无返回值无参数
		student.eat();
		// A2 无返回值有参数
		student.sleep("张安");
		// B1 有返回值无参数
		String result = student.youXi();
		System.out.println("玩游戏结果 : " + result);
		// B2 有返回值有参数
		String result1 = student.study("<java从入门到成才>", "钢笔");
		System.out.println(result1);
	}

}

一个类创建多个对象,以及内存图展示
代码
package com.zhiyou100.oop;

public class TestOOP2 {

	public static void main(String[] args) {
		/*
		 * 一个类可以创建多个对象,每个对象都有自己的属性和方法
		 */
		Student s1 = new Student();
		Student s2 = new Student();
		Student s3 = new Student();
		Student s4 = new Student();
		s1.name = "zhangsan";
		//结果为空
		System.out.println(s2.name);
	}

}


图解

两个引用指向一个对象
代码
package com.zhiyou100.oop;

public class TestOOP3 {
	public static void main(String[] args) {
		/*
		 * 两个引用指向一个对象
		 * s1 是对象名,也是变量,也可以叫做引用
		 * s1引用的是内存中堆中的对象的地址值
		 * Student s2 = s1;
		 * 将引用赋值给s2.
		 * s1 和 s2 操作的是内存中的同一个对象
		 */
		Student s1 = new Student();
		Student s2 = s1;
		s1.name = "刘备";
		System.out.println(s2.name);

	
	}
}

图解

方法是对象如何调用
package com.zhiyou100.oop;

public class TestOOP4 {

	public static void main(String[] args) {
		Student student = new Student();
		Student s1 = test1(student);
		System.out.println(s1);
	}
	
	public static Student test1(Student s){
		return s;
	}

}

理解javascript对象的数据属性和访问器属性


理解javascript对象的数据属性和访问器属性
1.何为属性？
2.数据属性
2.访问器属性
小结：





1.何为属性？

属性就是与对象相关的值，而数据属性和访问器属性，就是属性的属性，用于描述属性的行为特性。



2.数据属性

数据属性（property）用于实现JavaScript引擎，是属性(property)的内部值，它包含一个数据值的位置。有如下4种行为特性。

[[Configurable]]：能否被delete删除属性重新定义
[[Enumerable]]：能否被for-in枚举
[[Writable]]：能否修改属性值
[[Value]]：数据的数据值 
 

// 一个名叫奥巴马的狗狗 

var dog = { 

name: 'Obama' 

} 
 

此处有一个名为name的属性，其值是‘Obama’，即[[Value]]的值就是‘Obama’，任何修改name属性的操作，都能在[[value]]上显示出来。 

通过Object.getOwnPropertyDescriptor()方法，我们可以查看属性name的默认数据属性。
Object.getOwnPropertyDescriptor(dog, 'name')



那么，如何修改默认属性的值呢？ 

使用Object.defineProperty()可以修改默认属性。包含三个参数：属性所在对象，属性名称，描述符对象。



// 将狗狗的名字改成川普
Object.defineProperty(dog, 'name', {
    writable: false,
    value: 'Trump'
})



由于修改了默认属性name的描述符对象writable的值为false，故无法修改属性值。其他描述符类似。



2.访问器属性

访问器属性主要由setter和getter函数组成，包含如下4个特性：

[[Configurable]]：能否被delete删除属性重新定义。默认值：true
[[Enumerable]]：能否被for-in枚举。默认值：true
[[Get]]：读取属性值。默认值：undefined
[[Set]]：写入属性值。默认值：undefined 

详解如下：
var dog = {
    _age: 2,
    weight: 10
}

Object.defineProperty(dog, 'age', {
    get: function () {
        return this._age
    },
    set: function (newVal) {
        this._age = newVal
        this.weight += 1
    }
})


_age属性前面的下划线是一种常用的记号，是一种只能通过对象方法访问的属性。

小结：

1.Object.defineProperty()方法可以为全局对象定义属性，该全局对象的所有实例，都可使用该属性，是不是很方便！ 

2.set方法可以监听对象属性值得变化，如此，双向数据绑定就能够使用js实现了。

js如何判断一个对象{}是否为空对象，没有任何属性

前段时间用js写了一个类似"AngularJS"用于数据绑定的东西，功能是比较简单了，

通常应该传进来的是一个ArrayList JSON对象数组，

但有时候通过AJAX方法调用返回的是一个JSON对象，而不是数组！

为了兼容这种情况使用了以下代码：





[javascript] view
 plain copy


 


if (typeof model.rows === "object" && !(model.rows instanceof Array)){  

    model.rows = [model.rows];  

  

}  
这段代码在后来使用过程中发现了一个Bug，就是当



[javascript] view
 plain copy


 


model.rows = {};  
时，依然把它当作一个有效的对象来处理，进行数据绑定，可想而知，所有数据都是空的。



解决方案：

那么怎么解决这个问题呢？

第一习惯首先是搜索一下，但得到的结果都是DOM相关的，差强人意！

这时想起之前写过遍历JS对象属性的方法，这里可以用上了！

代码如下：





[javascript] view
 plain copy


 


if (typeof model.rows === "object" && !(model.rows instanceof Array)){  

    var hasProp = false;  

    for (var prop in model.rows){  

        hasProp = true;  

        break;  

    }  

    if (hasProp){  

        model.rows = [model.rows];  

    }else{  

        throw "model.rows is empty object";  

        return false;  

    }  

}  
代码很简单，就不写注释了。

jQuery中的实现方法

JavaScript判断object/json
 是否为空，可以使用jQuery的isEmptyObject()方法。


此方法如下






[javascript] view
 plain copy


 


function isEmptyObject(e) {  

    var t;  

    for (t in e)  

        return !1;  

    return !0  

}  
调用







[javascript] view
 plain copy


 


console.log($.isEmptyObject({"re": 2}));    //false  

   

console.log(isEmptyObject());           //true  

console.log(isEmptyObject({}));         //true  

console.log(isEmptyObject(null));       //true  

console.log(isEmptyObject(23));         //true  

console.log(isEmptyObject({"te": 2}));      //false  

结束语



jQuery的isEmptyObject()方法实现的代码即简单又简洁，但最关键的是我们要理解原理。