PPJ回忆录(Python,PHP,Javascript)

#我是单行注释
"我也是单行注释"
"""
我是多行注释
使用未赋值的字符串做注释
"""
                

>>> def foo():
...     '''
... i am foo
... void foo(void);
...     '''
...     pass
... 

>>> print foo.__doc__

i am foo
void foo(void);
	
                

for i in xrange(100):
    pass
                

for($i = 0; $i < 100; $i++);
                

for(var i = 0; i < 100; i++);
                

>>> (2.0).is_integer()
True
                

>>> (1).toString()
"1"
                

>>> '12' == 12
False
>>> "test" + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
                

php > var_dump('12' == 12);
bool(true)
php > var_dump('12' === 12);
bool(false)
                

>>> "12" == 12
true
>>> "12" === 12
false
                

#长整型直接量需要在后面加字符"L"
long1 = -0xFFFFFL
long2 = 312432L
                

#import sys
#最大的标准整型
print sys.maxint
                

0377 == 255 //0开头
                

True, False = False, True
                    

• None
• False
• 数字0,0L,0.0,0j
• 空序列 '',(),[]
• 空hash {}
• 对于一个对象,如果定义了__nonzero__或__len__方法,
  如果方法返回0或者False,这对象被认为是false

• false
• 整型 0
• 浮点 0.0
• 字符串""和"0"
• array() 空数组
• new StdClass() 空对象
• null
• 没有任何标记的SimpleXML对象

• false
• undefined
• null
• 空字符串""
• NaN
• 无穷和负无穷
• 数字0 和 0.0

print '''
test
test
'''
print """
test
test
"""
                

$a = 'var 1';
$b = 'var b';
$str = >>>EOD
Example of string
spanning multiple lines
using heredoc syntax.
a = ${a}
b = ${b}
EOD;
                

>>> r'abc\"def\t'
'abc\\"def\\t'
                

\0  C里的'\0'
\a  响铃
\b  退格
\t  
\n
\v  纵向制表
\f  换页
\r
\e  ESC
\"
\'
\\
\XX 八进制字符
\xXX 十六进制字符
\ 连字符
                

\n
\r
\t
\v
\f
\\
\$
\"
\XXX 八进制字符
\xXX 十六进制字符
                

\r
\"
\'
\\
\xXX 十六进制字符
\xXXXX 十六进制unicode字符
                

c = 'a' + 'b'
                

$c = 'a' . 'b';
                

var c = 'a' + 'b';
                

>>> 'abc'[0]
'a'
                

php > $a = 'abc';
//推荐写法
php > echo $a[0];
a
php > echo $a{0};
a
                

>>> 'abc'.charAt(0);
"a"
//ECMAScript 5也有定义下标的语法，你可以用最新的firefox测试
>>> 'abc'[0]
"a"
                

>>> len("中文")
6
>>> len(u"中文")
2

                

echo strlen('中文');
//6
echo mb_strlen('中文', 'UTF-8');
//2
                

>>> '中文'.length
2
                

#默认会当作10进制处理
>>> int('012')
12
#指定做8进制解析
>>> int('012', 8)
10

                

php > echo '012' - 0;
12
php > echo (integer)'012';
12
php > echo intval('012');
12
php > echo intval('012', 8);
10
                

>>> '012' - 0
12
>>> parseInt('012')
10
//打印10, JS竟然替我们做了一个艰难的决定。。。
>>> parseInt('012', 10)
12
                

>>> cstr = '普通字符串'
>>> ustr = u'unicode字符串'
>>> len(cstr)
15
>>> len(ustr)
10
>>> cstr[0]
'\xe6'
>>> ustr[8]
u'\u7b26'
                

ustr = u'我是unicode字符串'
#编码成utf8编码的str型字符串
utfstr = ustr.encode('utf-8')
#编码成gb2312编码的str型字符串
gbstr = ustr.encode('gb2312')
#将gb2312编码的str型字符串解码成unicode型的ustr2
ustr2 = gbstr.decode('gb2312')
                

#str和unicode型字符串做连接操作会将str强制转换成unicode
>>> u'a' + 'b'
u'ab'
#相当于执行了u'a' + 'b'.decode(sys.getdefaultencoding())
#sys.getdefaultencoding()用于获取默认编码
#如果被格式化的参数中有unicode串,则其他参数也要强制转换到unicode
>>> '%s%s' % (u'a', 'b')
u'ab'
>>> '%s%s' % (u'a', '中文')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode 
byte 0xe4 in position 0: ordinal not in range(128)
>>> sys.getdefaultencoding()
'ascii'
#出错原因在于'中文'.decode('ascii')
#通过ascii解码'中文'两个字是不可能的
                

alert('中文'.charCodeAt(0));
//不论utf8或gb2312编码的环境中都将打印20013
                

php > $a = array();
php > $a[0] = 'test';
php > $a[1] = 'test2';
php > $a['1'] = 'test3';
php > echo $a[1];
test3
php > echo $a['1'];
test3

                

>>> a = ['动','感','超','人'];
["动", "感", "超", "人"]
>>> b = {'0':'动','1':'感','2':'超','3':'人'};
Object { 0="动", 1="感", more...}
>>> a[2]
"超"
>>> b[2]
"超"
>>> a['2']
"超"
>>> b['2']
"超"
                

#列表直接量
#列表也可以存储混合类型的数据
>>> a = [1,2,3,"4"]
>>> a
[1, 2, 3, '4']
#通过工厂函数初始化
>>> a = list((1,2,3,4,5))
>>> a
[1, 2, 3, 4, 5]

>>> len(a)
5
>>> a.append('addon')
>>> len(a)
6

#字典直接量
#字典的key可以是任意可hash的不可变类型
>>> b = {'k1':'i am k1',100:'i am 100'}
>>> b
{'k1': 'i am k1', 100: 'i am 100'}

#通过工厂初始化
>>> d = dict(a = 1, b = 2)
>>> d
{'a': 1, 'b': 2}

>>> a[100]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> b['c']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
#访问不存在的索引，或者键值，python将会抛出异常
                

php > $a = array('k1'=>1,'k2'=>2,30=>3,40=>4);
php > echo count($a);
4
php > var_dump($a);
array(4) {
  ["k1"]=>
  int(1)
  ["k2"]=>
  int(2)
  [30]=>
  int(3)
  [40]=>
  int(4)
}
php > $a = array(0=>1,30=>3,40=>4);
//说明数组的长度并不是最大的索引值,foreach遍历更安全
php > echo count($a);
3
php > echo $a[100];
PHP Notice:  Undefined offset: 100 in php shell code on line 1
PHP Stack trace:
PHP   1. {main}() php shell code:0
//访问不存在的key只会有Notice产生,生产环境中一般会配置将Notice忽略

                

//直接量
>>> a = [1,2,3,4];
[1, 2, 3, 4]
//调用构造函数
>>> a = new Array();
[]
>>> a[99] = 'i am 100';
"i am 100"
>>> a.length
100
>>> a['k1'] = 'i am k1';
"i am k1"
>>> a.length
100
>>> delete a[99]
true
>>> a.length
100
//说明JS中数组的长度只跟赋值过的最大索引值有关
>>> a[0]
undefined
>>> a[100]
undefined
//所有未赋值的索引调用都将返回undefined
                

function foo()
{
    var i; //变量声明
    i = 0;
    j = 0;//变量可以不声明，但是j将变成一个全局变量
}
                

try:
    print xxxx
except NameError,ex:
    print 'xxxx is undefined'
                

php > var_dump(isset($xxxxx));
bool(false)
                

if (typeof xxxx != 'undefined')
                

>>> L1 = ['list em']
>>> L2 = L1
>>> L2.append('add another')
>>> L1
['list em', 'add another']
>>> L2
['list em', 'add another']
                

>>> a = (b = 'c')
  File "<stdin>", line 1
    a = (b = 'c')
           ^
SyntaxError: invalid syntax
                

php > $a = array('i am a string');
php > $b = $a;
//创建了新变量$b并copy $a的值给它
php > $b[] = 'add another';
php > var_dump($a);
array(1) {
  [0]=>
  string(13) "i am a string"
}
php > var_dump($b);
array(2) {
  [0]=>
  string(13) "i am a string"
  [1]=>
  string(11) "add another"
}
                

//Human的实例在对象编程部分,小穿越一下
$hm = new Human('han meimei');
$hm2 = $hm;
$hm2->name = 'li lei';
echo $hm->name;
                

li lei
                

php > $a = 'i am a';
php > $b = &$a;
//这个操作并不是变量赋值，而是创建变量a的引用
php > $b = 'i am b';
//$b和$a是等效的
php > echo $a;
i am b
                

>>> a = [1,2,3]
[1, 2, 3]
>>> b = a
[1, 2, 3]
>>> b.push(4)
4
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]
                

(x, y, z) = (1, 2, 3)
                

list($x, $y, $z) = array(1, 2, 3);
                

>>> isinstance(3,int)
True
>>> isinstance('abc',str)
True
>>> isinstance([1,2],list)
True
                

php > var_dump(is_integer(3));
bool(true)
php > var_dump(is_string('abc'));
bool(true)
php > var_dump(is_array(array(1,2)));
bool(true)
                

>>> typeof 3 == 'number'
true
>>> typeof 'abc' == 'string'
true
>>> typeof []
"object"
//对于数组来说 typeof 会返回 object,所以不能用此方法判断
//所以要采取下面这种方式
>>> Object.prototype.toString.call([1,2]) === '[object Array]'
true
                

>>> type(3)
<type 'int'>
>>> type('abc')
<type 'str'>
>>> type([1,2])
<type 'list'>

                

php > echo gettype(3);
integer
php > echo gettype('abc');
string
php > echo gettype(array(1,2));
array
                

>>> '%s is not %d' % ('a', 5)
'a is not 5'

                

php > printf("%s is not %d", 'a', 5); 
a is not 5
                

a = 'global var'
#python中可以直接通过作用域搜索访问到全局变量
def foo1():
    print a
    #这里你并没有改变全局变量a，而是定义了一个局部变量a
    a = 'modify global var'
def foo2():
    #可以明确声明一个全局变量
    global a
    #修改全局变量
    a = 'modify global var'
    
                

$a = 'global var';
function foo()
{
//如果一个变量没有在函数内定义PHP并不会去搜索全局作用域
//如果需要访问全局变量，必须用global声明一个全局变量
    global $a;
    echo $a;
//通过全局变量数组访问
    echo $GLOBALS['a'];
}
                

var a = 'global var';
function foo()
{
//JS中通过作用域链搜索也可以直接访问全局变量
    alert(a);
//也可以直接修改全局变量,这是也为什么未声明变量的赋值会创建全局变量的原因
    a = 'modify global var';
}
                

$ tree ./
./
├── d
│   ├── hello.py
│   └── __init__.py
├── foo.py
└── test.py

1 directory, 4 files

$ cat foo.py 
#!/usr/bin/env python
name = 'my name is foo'

def print_name():
    print name

$ cat d/hello.py 
#!/usr/bin/env python

def echo():
    print 'i am hello.py'

$ cat test.py 
#!/usr/bin/env python
import foo
import d.hello as hello
print foo.name
foo.print_name()
hello.echo()


$ python test.py 
my name is foo
my name is foo
i am hello.py

                

$ cat test.php 
<?php
namespace Hello;
function hi(){echo "i am hello\n";}
namespace Hello\World;
function hi(){echo "i am hello World\n";}
namespace Test;
\Hello\hi();
\Hello\World\hi();
use \Hello\World as HelloWorld;
HelloWorld\hi();
?>
$ php test.php 
i am hello
i am hello World
i am hello World

                

var com = {foo:{}};

(function(ns)
{
    function privSayHi()
    {
        alert('hi'); 
    }

    ns.hi = function()
    {
        privSayHi();    
    };
})(com.foo);

function test()
{
    var hi = com.foo.hi;
    //相当于 import com.foo.hi as hi
    hi();
}

test();

                

#python 2.5 or later
smaller = x if x < y else y
                

$smaller = $x < $y ? $x : $y;
                

var smaller = x < y ? x : y;
                

for i in xrange(len(arr)):
    print arr[i]
#python 使用for in来遍历可迭代对象
                    

//php没有for in 但是有foreach来遍历迭代
foreach($arr as $i => $v)
    echo $v;
                    

for (var x in [1,2,3])
    alert(x);
                    

//通过在break后面跟一个数字，可以跳出指定层次的循环
foreach($a as $v)
    foreach($v as $vv)
        break 2;
                    

outerloop:
for (var i = 0; i < 100; ++i)
    for (var j = 0; j < 100; ++j)
        break outerloop;
                    

gstr = 'global string'
gls = ['global list',1,2]

def m_str(v):
    #这里仅仅是是改变变量名副本v的引用关系，不影响gstr
    v = 'modify global string'

#可以理解为
# v = gstr  使变量名v指向gstr 
# v = 'modify global string'  改变变量名v的引用
# gstr不受影响

#Python的赋值方式使它的传引用现在看来像是传值

def m_hs(v):
    #变量名v未改变，改变的是v引用的list型
    变量的第一个元素的引用关系
    v[0] = 'modify global list'

#可以理解为
# v = gls  python的赋值为赋引用所以不会创建gls的副本
# v[0] = 'modify global list' 

m_str(gstr)
m_hs(gls)
print gstr
print gls
                

global string
['modify global list', (1, 2)]
                  

<?php
$a = array('i am global str');
function foo($b)
{
    $b[] = 'add another';
}

//理解为
//$b = $a
//普通赋值会创建新的变量$b,$a不受影响

function foo2(&$b)
{
    $b[] = 'add another';
}
//理解为
//$b = &$a;
//$b是一个引用型变量名,和变量名$a是等效的
//$b[] = 'add another'; 

foo($a);
var_dump($a);
foo2($a);
var_dump($a);
?>

                

array(1) {
  [0]=>
  string(15) "i am global str"
}
array(2) {
  [0]=>
  string(15) "i am global str"
  [1]=>
  string(11) "add another"
}
                

//Human的例子见对象编程部分
$hm = new Human('han meimei');
function cname($hm)
{
    $hm->name = 'li lei';
}
cname($hm);
print $hm->name;
                

li lei
                

<?php
$a = 'i am a';
function test(&$b)
{
    $b = 'i am b'; 
}
test($a);
var_dump($a);
?>
                

string(6) "i am b"
                

var sa = 'i am a string';
var aa = [1,2,3,4];
function foo(a)
{
    a = 'i am another string';
}

//可以理解为
//var a = sa;
//a = 'i am another string';
//a的赋值只是改变了变量名a的引用到'i am another string';
//sa不受影响

function foo2(b)
{
    b[0] = 'test'; 
}

//可以理解为
//var b = aa;  
//赋值为赋引用,b现在指向aa
//b[0] = 'test';

foo(sa);
foo2(aa);
console.log(sa);
console.log(aa);
                

i am a string
["test", 2, 3, 4]
                

>>> def foo():
...     def foo2():
...             print 'i am foo2'
...     foo2()
... 
>>> foo()
i am foo2
>>> foo2()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'foo2' is not defined

                

<?php
function test()
{
    function foo()
    {
        echo 'i am foo'; 
    }

    foo();
}

test();
?>
                

i am foo
                

<?php
function foo(){echo 'i am foo';}
function test()
{
    function foo()
    {
        echo 'i am foo too'; 
    }

    foo();
}

test();
?>
                

PHP Fatal error:  Cannot redeclare foo() (pr
eviously declared in /tmp/test.php:2) in /tm
p/test.php on line 5
PHP Stack trace:
PHP   1. {main}() /tmp/test.php:0
PHP   2. test() /tmp/test.php:13
                

<?php
function test()
{
    $hi = 'i am test';

    function foo()
    {
        echo $hi;
    }

    foo();
}

test();
?>
                

PHP Notice:  Undefined variable: hi in /tmp/test.php on line 8
PHP Stack trace:
PHP   1. {main}() /tmp/test.php:0
PHP   2. test() /tmp/test.php:14
PHP   3. foo() /tmp/test.php:11
                

>>> def foo():
...     pass
... 
>>> print foo()
None

                    

php > function test(){}
php > var_dump(test());
NULL
php > var_dump(test() === null);
bool(true)
                    

>>> function test(){};
undefined
>>> test();
undefined
                    

>>> def foo(a, b):
...     print a,b
... 
>>> foo('a', 'b')
a b
#python还有一种指定参数名的灵活调用方式
#可以不用按照顺序传参
>>> foo(b='b', a='a')
a b
#python会严格检查传参数目
>>> foo('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 2 arg
uments (1 given)

                

php > function foo($a, $b){echo $a . $b;}
php > foo('a', 'b');
ab
//PHP也会检查参数个数，出错时产生Warning
php > foo('a');
PHP Warning:  Missing argument 2 for foo(), called
in php shell code on line 1 and defined in php she
ll code on line 1
PHP Stack trace:
PHP   1. {main}() php shell code:0
PHP   2. foo() php shell code:1
PHP Notice:  Undefined variable: b in php shell co
de on line 1
PHP Stack trace:
PHP   1. {main}() php shell code:0
PHP   2. foo() php shell code:1
a
                    

>>> function foo(a,b){console.log(a + b);}
>>> foo('a', 'b');
ab
//JS对参数个数完全不做检查
>>> foo('a');
aundefined
>>> foo('a', 'b', 'c');
ab
                    

>>> def foo(a, b ='b'):
...     print a,b
... 
>>> foo('a')
a b

                    

php > function foo($a, $b='b'){echo $a . $b;}
php > foo('a');
ab
                    

>>> def foo(a, b, *m):
...     print a,b,''.join(m)
... 
>>> foo('a','b','c','d')
a b cd
                    

>>> def foo(a, b, **m):
...     for k in m.keys():
...             print k,m[k]
... 
>>> foo('a','b',c='c',d='d')
c c
d d
                    

<?php
function foo()
{
    $numargs = func_num_args();
    echo "Number of arguments: $numargs<br />\n";
    if ($numargs >= 2) {
        echo "Second argument is: " . func_get_arg(1) . "<br />\n";
    }
    $arg_list = func_get_args();
    for ($i = 0; $i < $numargs; $i++) {
        echo "Argument $i is: " . $arg_list[$i] . "<br />\n";
    }
}

foo(1, 2, 3);
?>
                    

Number of arguments: 3<br />
Second argument is: 2<br />
Argument 0 is: 1<br />
Argument 1 is: 2<br />
Argument 2 is: 3<br />
                

>>> function foo(){for(var i = 0;i < arguments.length;i++) console.log(arguments[i]);}
>>> foo('a','b','c');
a
b
c
                    

foo()
def foo():
    print 'i am foo'
                

Traceback (most recent call last):
  File "test.py", line 2, in 
    foo()
NameError: name 'foo' is not defined
                

<?php
foo();
function foo()
{
    echo 'i am foo';
}
?>
                

i am foo
                

foo();
function foo() 
{
   console.log('i am foo');
} 
                

i am foo
                

>>> def foo():
...     print 'i am foo'
... 
>>> a = [1,2,foo]
>>> a[2]()
i am foo

                    

php > function foo($a){echo 'i am ' . $a;}
php > call_user_func('foo', 'test');
i am test
php > $a = 'foo';
php > $a('test');
i am test
                    

>>> function foo(){console.log('i am foo');}
>>> window['foo']();
i am foo
>>> a = foo;
foo()
>>> a();
i am foo
                    

>>> def counter():
...     c = [0]
...     def add():
...             c[0] += 1
...             return c[0]
...     return add
... 
>>> c = counter()
>>> c()
1
>>> c()
2
>>> c()
3
                    

<?php
function counter()
{
    $c = 0;
    return function() use (&$c)
    {
        return ++$c; 
    };
}
$c = counter();
var_dump($c());
var_dump($c());
var_dump($c());
?>
                    

int(1)
int(2)
int(3)
                    

function counter()
{
    var c = 0;
    return function()
    {
        return ++c;
    };
}
var c = counter();
console.log(c());
console.log(c());
console.log(c());
                    

1
2
3
                    

class Human(object):
    def __init__(self, name):
        self.name = name 
    def say(self, msg):
        print '%s:%s' % (self.name, msg)

hm = Human('li lei')
hm.say('hi han meimei~')
                    

li lei:hi han meimei~
                    

<?php
class Human
{
    function __construct($name)
    {
        $this->name = $name; 
    }

    function say($msg)
    {
        printf('%s:%s', $this->name, $msg); 
    }
}

$hm = new Human('li lei');
$hm->say('hi han meimei~');
?>

                    

li lei:hi han meimei~
                

function Human(name)
{
    this.name = name; 
}

Human.prototype = {
    say:function(msg) 
    {
        console.log(this.name + ':' + msg);   
    }
};

var hm = new Human('li lei');
hm.say('hi han meimei~');
                

li lei:hi han meimei~
                

hm = Girl('han meimei')
print isinstance(hm, Girl)
print isinstance(hm, Human)
                

True
True
                

$hm = new Girl('han meimei'); 
var_dump(is_a($hm, 'Girl'));
var_dump(is_a($hm, 'Human'));
                

bool(true)
bool(true)
                

var hm = new Girl('han meimei');
console.log(hm instanceof Girl);
console.log(hm instanceof Human);
                

true
true
                

class Human(object):
    def __init__(self, name):
        self.__name = name 
    def say(self, msg):
        print "%s:%s" % (self.__name, msg)
                

class Human
{
    private $name = '';
    function __construct($name)
    {
        $this->name = $name; 
    }

    function say($msg)
    {
        echo sprintf('%s:%s', $this->name, $msg); 
    }
}
                

function Human(name)
{
    this.name = function(v) 
    {
        if (typeof v == 'string') name = v; 
        return name;
    };
}

Human.prototype = {
    say:function(msg) 
    {
        console.log(this.name() + ':' + msg);   
    }
};
                

class Human(object):
    def __init__(self, name):
        self.name = name 
    def say(self, msg):
        print "%s:%s" % (self.name, msg)
    @staticmethod
    def get_name(hm):
       return hm.name 

hm = Human('li lei')
print Human.get_name(hm)
                

class Human
{
    function __construct($name)
    {
        $this->name = $name; 
    }

    function say($msg)
    {
        echo sprintf('%s:%s', $this->name, $msg); 
    }

    static function get_name($hm)
    {
        return $hm->name; 
    }
}

$hm = new Human('han meimei');
echo Human::get_name($hm);
                

Human.get_name = function(hm)
{
    return hm.name;
};
                

class Girl(Human):
    def __init__(self, name):
        super(Girl, self).__init__(name)
        self.sex = 'girl'

hm = Girl('han meimei')
hm.say('hi li lei~')
                    

han meimei:hi li lei~
                    

class Girl extends Human
{
    function __construct($name)
    {
        parent::__construct($name); 
        $this->sex = 'girl';
    }
}

$hm = new Human('han meimei');
$hm->say('hi li lei~');
                    

han meimei:hi li lei~
                    

function Girl(name)
{
    Human.call(this, name); 
    this.sex = 'girl';
}

Girl.prototype = new Human();

var hm = new Girl('han meimei');
hm.say('hi li lei~');
                    

han meimei:hi li lei~
                    

class foo(P1, P2):
    pass
                

print issubclass(Girl, Girl)
print issubclass(Girl, Human)
print issubclass(Girl, object)
                

True
True
True
                

//PHP中没有一个所有类的根类，所以这里再多定义一层
//PHP通过类的实例来判断继承关系
class YoungGirl extends Girl{}
$hm = new YoungGirl('han meimei');
var_dump(is_subclass_of($hm, 'YoungGirl'));
var_dump(is_subclass_of($hm, 'Girl'));
var_dump(is_subclass_of($hm, 'Human'));
                

bool(false)
bool(true)
bool(true)
                

//仅适用于例子中的继承方式
console.log(Girl.prototype instanceof Girl);
console.log(Girl.prototype instanceof Human);
console.log(Girl.prototype instanceof Object);
                

false
true
true
                

interface fooInterface
{
    function sayHi();
}

class foo implements fooInterface
{
    function sayHi(){ echo 'hi';}
}
                

__init__ 构造函数
__del__  析构函数
__str__  用于str()
__unicode__ 用于unicode()
__nonzero__ 用于布尔转换
__len__ 用于len()
__cmp__ 对象比较
__getattr__ 获取不存在的属性时调用
....
                

__construct 构造函数 
__destruct 析构函数
__call 调用不存在的方法时调用 
__get 获取不存在的属性时调用 
__set 设置不存在的属性时调用
__toString 转换成字符串时调用
....
                

toString 将对象转换为字符串时调用
valueOf 将对象转换为数字时调用