python和php的基本数据类型
PHP所支持的数据类型：
四种标量类型：
string（字符串）
integer（整型）
float（浮点型，也作 double ）
boolean（布尔型）
两种复合类型：
array（数组）
object（对象）
两种特殊类型：
resource（资源）
NULL（空）
python所支持的数据类型：
字符串、整型、浮点型、布尔类型
列表、元组、集合、字典
None 空
在python中所以并没有把对象当做一种特殊的数据类型。
我们关注复合类型的赋值字符串和复合类型的赋值引用以及基本方法。
python创建赋值与引用
字符串(序列介绍)
是 Python 中最常用的数据类型。是不可变序列。我们可以使用引号来创建字符串
var1 = 'Hello World!’
var1 = str()
赋值的时候有单引号、双引号和三引号的区别：
单引号和双引号都一样。注意如果字符串里有相同的字符时要使用\进行转义
举例：
1) print 'hello'
2) print "hello"
1和2，结果都是hello
3) print 'hell\'o'
4) print "hell'o"
3和4，结果都是hell'o
5) print 'hell"o'
6) print "hell\"o"
5和6，结果都是hell”o
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。这类似与php的单引号。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
‘’'
说引用之前先说，Python字符串支持的运算符。
可以看出python字符串可以像一个字符列表来使用。（Python有6个序列（有序）的内置类型，包含字符串、列表、元组等。但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。）
索引与切片
0第一个元素，-1最后一个元素，
-len第一个元 素，len-1最后一个元素
var1[0]: H
var2[1:5]: ytho
var1[:] :hello
var1[:5]
var1[:5:1] 设置步长，步长可以是负值，从右向左取。
序列相加 两种相同类型的序列才能进行连接操作。
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello, ' + 'world!'
'Hello, world!'
乘法
用数字 x 乘以一个序列会生成新的序列，而在新的序列中，原来的序列将被重复 x 次。
>>> 'python' * 5
‘pythonpythonpythonpythonpython'
成员资格
为了检查一个值是否在序列中，可以使用 in 运算符。
[python] view plaincopy在CODE上查看代码片派生到我的代码片
>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
长度、最小值和最大值
len函数返回序列中所包含元素的数量、min函数和max函数则分别返回序列中最大和最小的元素。
[python] view plaincopy在COD
E上查看代码片派生到我的代码片
>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2
字符串、列表、元组都支持解包
a = [1,2,3,4]
b,c,d,e = a
字符串、列表、元组都支持for in
for item in sequence:
pass
这样遍历取不到item的序号i，所有就有了下面的遍历方法：
for index in range(len(sequence)):
process(sequence[index])
其实，如果你了解内置的enumerate函数，还可以这样写：
for index, item in enumerate(sequence):
process(index, item)
列表
的赋值和访问。可变有序序列。每个值有自己的数字index
创建与赋值
a = []
a = list()
b = [1,2,3,4]
b = [ <expr1> for k in L if <expr2> ]
使用索引进行修改值，不可访问超范围索引。a[2] = 1
使用append函数进行增加新元素 a.append(‘123’)
访问
使用索引和分片都可以。
元组
是不可变序列。
tuple_name = ()
tuple_name = tuple()
如果创建的元组只有一个元素，那么该元素后面的逗号是不可忽略的
>>>(4)
4
>>>(4,)
(4,)
使用索引和分片都可以访问当元素。
字典
是哈希表，本身是无序的。是Python语言中唯一的映射类型，明显区别与序列类型。字典的key必须是可哈希的，简单的说就是不可变，数值，字符串，元组，frozenset之类的。。。而列表、字典、集合之类的就不行。
a = dict()
a = {}
a = dict(name=‘wangwei’,home=‘heze’)
a = {‘name’:’lily’,’home’:’ufo’}
a[‘name’]
a[‘name’] = ‘’lilei
a[‘habit’] = ‘pingpang’
遍历字典：
for key in dict:
for key,value in dict:
集合
类似与数学中集合的概念。不是那么的常用。它是python基本的数据类型。
由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建。参数为一个序列(字符串、元组、列表)，一个集合也能通过str(),tuple(),list()转换成序列。
由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。
集合分类：可变集合、不可变集合
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
集合是有一个特性，元素不重复。所以可以利用这个特性进行列表去重，并保持原来的顺序：
mailto = ['cc', 'bbbb', 'afa', 'sss', 'bbbb', 'cc', 'shafa']
addr_to = list(set(mailto))
addr_to.sort(key = mailto.index)
创建：
>>> li=['a','b','c','a']
2 >>> se =set(li)
3 >>> se
4 set(['a', 'c', ‘b’])
>>> s = set('beginman')
>>> s
set(['a', 'b', 'e', 'g', 'i', 'm', 'n'])
>>> t = frozenset('pythonman')
>>> t
frozenset(['a', 'h', 'm', 'o', 'n', 'p', 't', 'y'])
>>> type(s),type(t)
(<type 'set'>, <type ‘frozenset'>)
注意只有不可变的值（元组、字符串、数值）才可以作为集合的元素。
访问：
for x in li
x in li
x not in li
可变集合可使用以下内建方法来更新：
s.add(obj):添加对象obj
s.update(s1): 用s1中的成员修改s，s现在包含s1的成员
b.update(set([1,2,3,9])) 将b中不存在的加进去。
s.remove(obj):从集合s中删除obj，若obj不存在，则引发KeyError错误
s.discard(obj): 如果obj是s的成员，则删除obj
s.pop(): 删除集合s中任意一个对象，并返回
s.clear(): 删除集合s中所有元素
判断子集和超集(无论集合类型)
>>> b
set([0, 1, 2, 3, 4, 5, 7, 9, '1', '3', '5', '4'])
>>> c = set([1,2,3])
>>> c.issubset(b)
True
>>> b.issuperset(c)
True
>>>
-差补， s1-s2意思是在s1中，不在s2中。
^对称差分 在s1和s2中，但有不同时属于s1和s2
python基本方法函数
字符串
去空格及特殊符号 s.strip()
s.strip().lstrip().rstrip(‘,')
连接字符串 sStr1 += sStr2
查找子串 nPos = sStr1.index(sStr2)
# 找到则返回第一次出现的位置 找不到则抛出异常
sStr1 = 'strchr'
sStr2 = 's'
nPos = sStr1.index(sStr2)
print nPos
还有一个方法：
info.find(‘a’) 找到了返回位置 找不到返回-1
index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过与find不同的是，如果查找不到子串，会抛出异常，而不是返回-1
rindex rfind都是从最右开始算起
这两个方法应该都可以规定开始搜索的位置。
还有一个方法：
sStr1 = '12345678'
sStr2 = '456'
#sStr1 and chars both in sStr1 and sStr2
print len(sStr1 and sStr2)
比较字符串cmp(sStr1,sStr2)
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
这个函数不光用于字符串比较，整数。
字符串长度 len(sStr1)
大小写转换
S.lower() #小写
S.upper() #大写
S.swapcase() #大小写互换
S.capitalize() #首字母大写
String.capwords(S) #这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起
翻转字符串的方法sStr1[::-1]
分割字符串 s.split(‘,')
s = 'ab,cde,fgh,ijk'
print(s.split(','))
S.split([sep, [maxsplit]])
#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
S.rsplit([sep, [maxsplit]])
S.splitlines([keepends])
#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
连接字符串 delimiter.join(mylist)
delimiter = ','
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)
截取字符串 序列索引分片
str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取，具体啥意思没搞明白？
字符串在输出时的对齐
复制代码 代码如下:
S.ljust(width,[fillchar])
#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.center(width, [fillchar]) #中间对齐
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足
子串出现的次数 s.count(sub_s,start,end)
>>> 'wangwei'.count('w',0,9)
2
>>> 'wangwei'.count('w',1,9)
1
>>>
子串替换 s.replace(str1,str2,count)
S.replace(oldstr, newstr, [count])
#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
还有一种方法实现字符级别的映射：
intab = "abcd"
outtab = "1234"
str_trantab = str.maketrans(intab,outtab)
test_str = "csdn blog: http://blog.csdn.net/wirelessqa"
print (test_str.translate(str_trantab)) # 3s4n 2log: http://2log.3s4n.net/wirelessq1
字符串编解码 str.encode str.decode
首先要搞清楚，字符串在Python内部的表示是unicode编码.
因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
decode的作用是将其他编码的字符串转换成unicode编码，
如str1.decode('gb2312')，表示将gb2312编码的字符串转换成unicode编码。
encode的作用是将unicode编码转换成其他编码的字符串，
如str2.encode('gb2312')，表示将unicode编码的字符串转换成gb2312编码。
因此通常要对其编码方式是否为unicode进行判断：
isinstance(s, unicode) #用来判断是否为unicode
字符串测试判断
S.startswith(prefix[,start[,end]])
#是否以prefix开头
>>> a.startswith('w',0,9)
True
>>> a.startswith('w',1,9)
False
>>>
S.endswith(suffix[,start[,end]])
#以suffix结尾
S.isalnum() #是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isdigit() #是否全是数字，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的
字符串转整型、浮点、长整形
需要string模块
>>> string.atof("1.23")
1.23
>>> string.atof("1")
1.0
string.atoi(s,[base=num])将字符串转为整型数字,base 指定进制
>>> string.atoi("20")
20
>>> string.atoi("20",base=10)
20
>>> string.atoi("20",base=16)
32
>>> string.atoi("20",base=8)
16
>>> string.atoi("20",base=2)
Traceback (most recent call last):
File "", line 1, in <module>
File "/usr/lib64/python2.6/string.py", line 403, in atoi
return _int(s, base)
ValueError: invalid literal for int() with base 2: '20'
>>> string.atoi("101",base=2)
5
>>> string.atoi("101",base=6)
列表
list.append(obj)：在列表末尾添加新的对象
list.count(obj)：统计某个元素在列表中出现的次数
sum([1,2,3]) 列表求和
list.extend(seq)：在列表末尾追加一个列表
list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)：将对象插入列表
如果index超出了list的长度，则限制在最近一端
list.pop(位置)：删除列表中给定位置的一个元素（默认最后一个元素）
并且返回该元素的值
>>> a = [1,2,3,4]
>>> a.pop(0)
1
>>> a
[2, 3, 4]
list.remove(obj)：删除列表中特定元素
>>> a = [1,2,3,3,3,4]
>>> a.remove(3)
>>> a
[1, 2, 3, 3, 4]
del list1[0]删除列表中某个元素
del L[1:3] #删除指定下标范围的元素
list.reverse()：反向列表中元素
list.sort([func])：对原列表进行排序
sort方法还有两个可选参数：key和reverse
key在使用时必须提供一个排序过程总调用的函数,这个函数的返回值标示该项的大小：
reverse实现降序排序，需要提供一个布尔值：
实例1:正向排序
1
2
3
4
>>>L = [2,3,1,4]
>>>L.sort()
>>>L
>>>[1,2,3,4]
实例2:反向排序
1
2
3
4
>>>L = [2,3,1,4]
>>>L.sort(reverse=True)
>>>L
>>>[4,3,2,1]
实例4: 对第二个关键字排序
1
2
3
4
>>>L = [('b',6),('a',1),('c',3),('d',4)]
>>>L.sort(key=lambda x:x[1])
>>>L
>>>[('a', 1), ('c', 3), ('d', 4), ('b', 6)]
如果我们想用第二个关键字排过序后再用第一个关键字进行排序呢?有两种方法
实例8:
1
2
3
4
>>> L = [('d',2),('a',4),('b',3),('c',2)]
>>> L.sort(key=lambda x:(x[1],x[0]))
>>> L
>>>[('c', 2), ('d', 2), ('b', 3), ('a', 4)]
为什么实例8能够工作呢？原因在于tuple是的比较从左到右比较的，比较完第一个，如果相等，比较第二个。list也一样。字典的比较：首先是字典的大小，然后是键，最后是值。
list的复制
L1 = L #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的
L1 = L[:] #L1为L的克隆，即另一个拷贝。
字典
返回键值对的数目len()
>>> d = {'abc':1,'efg':2}
>>> len(d)
字典元素列表keys()、values() 、items()
keys()返回一个包含字典所有键的列表
values()返回一个包含字典所有值的列表
items()返回一个包含键值元组的列表
adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代器，而不是一个列表；
>>> d = {'name':'alex','sex':'man'}
>>> d.keys()
['name', 'sex']
>>> d.values()
['alex', 'man']
>>> d.items()
[('name', 'alex'), ('sex', ‘man')]
检查key是否在字典中
a、has_key()方法 形如：adict.has_key(‘name’) 有–>True，无–>False
b、in 、not in 形如：'name' in adict.keys() 有–>True，无–>False
获取字典value dict.get(key,default=None)
返回字典中key对应的value，若key不存在则返回default
>>> d = {'name':'alex','sex':'man'}
>>> d.get('name','not exists')
'alex'
>>> d.get('alex','not exists')
'not exists'
设置字典value dict.setdefault(key,default=None)
若key存在，忽略，若key不存在，则给字典添加key-value对
>>> d.setdefault('name','zhou')
'alex'
>>> d
{'name': 'alex', 'sex': 'man'}
>>> d.setdefault('haha','xixi')
'xixi'
>>> d
{'haha': 'xixi', 'name': 'alex', 'sex': 'man'}
字典合并 dict.update(dict2)
将字典dict2的键值对添加到dict
>>> d = {'name':'alex','sex':'man'}
>>> d1 = {'age':100,'address':'shenzhen'}
>>> d.update(d1)
>>> d
{'age': 100, 'address': 'shenzhen', 'name': 'alex', 'sex': ‘man'
如果有重复的，则以dict2为准
还有一个方法
dict(all_member, **member)
字典排序 sorted(dict)
>>> a = {1:'wangwei',3:'heihei',2:'xxxx'}
>>> sorted(a)
[1, 2, 3]
>>> a
{1: 'wangwei', 2: 'xxxx', 3: ‘heihei’}
删除字典项 del dict[‘name’] 或 dict.pop(‘name’)
del adict[key] 删除键key的项 / del adict 删除整个字典
adict.pop(key) 删除键key的项并返回key对应的 value值
清空字典 adict.clear()
字典浅复制 adict.copy() 返回一个字典浅拷贝的副本；
创建并返回一个新字典 adict.fromkeys(seq, val=None)
以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；
其他常用函数
php创建赋值与引用
字符串
可以使用双引号和单引号创建php字符串。
在PHP中，封闭在单引号内的值将照字面意义进行处理，即所见即所得，而封闭在双引号内的值则将被解释。换句话说，把变量和特殊字符(见表1)放在双引号内将导致打印出它们所表示的值，而不是它们的字面值。
使用上的几个规则：
1、如果修饰的字符串中含有变量(例$name);最大的区别是： 双引号会替换变量的值，而单引号会把它当做字符串输出。
{$a}
$a = 'flower';
echo "She received some $as";
// 无效；字母s会被当成有效的变量名组成元素，但是这里的变量是$a
所以{$a}s
{}中还可以放置：
echo "This square is {$square->width}00 centimeters broad.";
echo "This works: {$arr[4][3]}”;
$object->getName(): {${$object->getName()}}";
2、在单引号字符串中输出单引号，要使用\转义符。所以当要输出单引号时，要用双引号方便一些。反之在单引号字符串中输出双引号可以省去转义。
3、因为有效的HTML常常包括许多用双引号括住的属性，所以当利用PHP打印HTML时，使用单引号最容易。
字符串可以用'.' (点) 和.=操作符连接起来， 注意 '+' (加号) 操作符 没有 这个功能
数组
php数组是有序的。
$a = array();
$a = []
指定索引
$a = array(
‘a’ =>’name’,
‘b’ => ‘home’
)
$a = [
‘a’ =>’name’,
‘b’ => ‘home’
]
$a[‘d’] = ‘xxx’ 在数组存在时，追加或修改一个数据；在数组不存时，生成一个数组，并追加数据
自动创建索引(如果之前没数字或者数字字符，则从0开始，否则从上一次递加)
$a = array(‘name’,’home’)
$a =[‘name’,’home’]
$a[] = ‘habit’ 追加一个数据；在数组不存时，生成一个数组，并追加数据
1、不用初始化为为数组，可以直接赋值
2、取不到值的key不会报错，而是返回null
数组遍历：
<?php
$cars=array("Volvo","BMW","SAAB");
$arrlength=count($cars);
for($x=0;$x<$arrlength;$x++) {
echo $cars[$x];
echo "<br>";
}
?>
<?php
$age=array("Bill"=>"35","Steve"=>"37","Peter"=>"43");
foreach($age as $x=>$x_value) {
echo "Key=" . $x . ", Value=" . $x_value;
echo "<br>";
}
?>
php基本方法函数
字符串
子串在字符串中第一次出现的位置 strpos() 最后一次strripos()
<?php
echo strpos("You love php, I love php too!","php");
?>
还可以定义开始查找的位置。
echo strpos(‘wangwei','wang',1);
注释：strpos() 函数对大小写敏感。
stripos() - 查找字符串在另一字符串中第一次出现的位置（不区分大小写）
strripos() - 查找字符串在另一字符串中最后一次出现的位置（不区分大小写）
strrpos() - 查找字符串在另一字符串中最后一次出现的位置（区分大小写）
截取字符串 substr()
substr(string,start,length)
<?php
echo substr("Hello world",0,10)."<br>";
echo substr("Hello world",1,8)."<br>";
echo substr("Hello world",0,5)."<br>";
echo substr("Hello world",6,6)."<br>";
echo substr("Hello world",0,-1)."<br>";
echo substr("Hello world",-10,-2)."<br>";
echo substr("Hello world",0,-6)."<br>";
echo substr("Hello world”,-2-3)."<br>";
Hello worl
ello wor
Hello
world
Hello worl
ello wor
Hello
world
格式化字符串 sprintf()
sprintf("%.2f", $ad_detail[‘totaldisplaycostamount'])
<?php
$num1 = 123456789;
$num2 = -123456789;
$char = 50; // ASCII 字符 50 是 2
// 注释：格式值 "%%" 返回百分号
echo sprintf("%%b = %b",$num1)."<br>"; // 二进制数
echo sprintf("%%c = %c",$char)."<br>"; // ASCII 字符
echo sprintf("%%d = %d",$num1)."<br>"; // 带符号的十进制数
echo sprintf("%%d = %d",$num2)."<br>"; // 带符号的十进制数
echo sprintf("%%e = %e",$num1)."<br>"; // 科学计数法（小写）
echo sprintf("%%E = %E",$num1)."<br>"; // 科学计数法（大写）
echo sprintf("%%u = %u",$num1)."<br>"; // 不带符号的十进制数（正）
echo sprintf("%%u = %u",$num2)."<br>"; // 不带符号的十进制数（负）
echo sprintf("%%f = %f",$num1)."<br>"; // 浮点数（视本地设置）
echo sprintf("%%F = %F",$num1)."<br>"; // 浮点数（不视本地设置）
echo sprintf("%%g = %g",$num1)."<br>"; // 短于 %e 和 %f
echo sprintf("%%G = %G",$num1)."<br>"; // 短于 %E 和 %f
echo sprintf("%%o = %o",$num1)."<br>"; // 八进制数
echo sprintf("%%s = %s",$num1)."<br>"; // 字符串
echo sprintf("%%x = %x",$num1)."<br>"; // 十六进制数（小写）
echo sprintf("%%X = %X",$num1)."<br>"; // 十六进制数（大写）
echo sprintf("%%+d = %+d",$num1)."<br>"; // 符号说明符（正）
echo sprintf("%%+d = %+d",$num2)."<br>"; // 符号说明符（负）
字符串长度 strlen()
echo strlen("I love Shanghai!”);
字符串倒置 strrev()
echo strrev("I love Shanghai!");
比较两个字符串 不区分大小写 strcasecmp()
<?php
echo strcasecmp("Shanghai","SHANGHAI");
echo "<br>";
echo strcasecmp("Shanghai","sHANGHai");
?>
函数移除字符串两侧的空白字符或其他预定义字符 trim()
trim(string,charlist)
参数 描述
string 必需。规定要检查的字符串。
charlist
可选。规定从字符串中删除哪些字符。如果被省略，则移除以下所有字符：
"\0" - NULL
"\t" - 制表符
"\n" - 换行
"\x0B" - 垂直制表符
"\r" - 回车
" " - 空格
字符串替换 str_replace
把字符串 "Hello world!" 中的字符 "world" 替换为 "Shanghai"：
<?php
echo str_replace("world","Shanghai","Hello world!");
字符串大小写函数
strtolower() 函数把字符串转换为小写。
lcfirst() - 把字符串中的首字符转换为小写
strtoupper() - 把字符串转换为大写
ucfirst() - 把字符串中的首字符转换为大写
ucwords() - 把字符串中每个单词的首字符转换为大写
字符串重复 str_repeat
把字符串 "Shanghai " 重复 5 次：
<?php
echo str_repeat("Shanghai",5);
?>
随机打乱字符串中的所有字符。 str_shuffle() 函数
过滤html标签 strip_tags
可以在第二个参数中制定允许的标签
echo strip_tags("Hello <b><i>world!</i></b>”,”<b>");
转换html标签 防止xss注入
入库的时候不用，echo之前用，浏览器会自动将转换后的展示成原来的模样。
本函数将特殊字符转成 HTML 的字符串格式 ( &....; )。最常用到的场合可能就是处理客户留言的留言版了。
& (和) 转成 &
" (双引号) 转成 "
< (小于) 转成 <
> (大于) 转成 >
数组
元素个数 count()
$cars=array("Volvo","BMW","SAAB");
$arrlength=count($cars);
值是否在数组中 in_array()
$a = [1,2,3,4];
if(in_array(1,$a)){
echo 'yes';
}
值是否在数组中 在的话返回key array_search()
函数与 in_array() 一样，在数组中查找一个键值。如果找到了该值，匹配元素的键名会被返回
$a = [1,2,3,4,5,5,5,5];
echo array_search(5,$a);
key是否在数组中array_key_exists()
函数判断某个数组中是否存在指定的 key 如果该 key 存在，则返回 true，否则返回 false
<?php
$a=array("a"=>"Dog","b"=>"Cat");
if (array_key_exists("a",$a))
{
echo "Key exists!";
}
else
{
echo "Key does not exist!";
}
?>
判断变量类型是否为数组类型 is_array()
若变量为数组类型则返回 true，否则返回 false。
is_double() is_float() is_int() is_integer() is_long() is_object() is_real() is_bool is_string() is_numeric — 检测变量是否为数字或数字字符串 is_null
从数组中随机选出一个或多个元素 array_rand()
第二个参数用来确定要选出几个元素。如果选出的元素不止一个，则返回包含随机键名的数组，否则返回该元素的键名。
array_rand(array,number)
参数 描述
array 必需。规定输入的数组参数。
number 可选。默认是 1。规定返回多少个随机的元素。
例子 1
<?php
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
print_r(array_rand($a,1));
?>
输出：
b
函数返回包含数组中所有键名的一个新数组 可指定value array_keys()
<?php
$a=array("a"=>"Horse","b"=>"Cat","c"=>"Dog");
print_r(array_keys($a));
?>
输出：
Array ( [0] => a [1] => b [2] => c )
<?php
$a=array("a"=>"Horse","b"=>"Cat","c"=>"Dog");
print_r(array_keys($a,"Dog"));
?>
输出：
Array ( [0] => c)
函数返回一个包含给定数组中所有键值的数组，但不保留键名。 array_values()
<?php
$a=array("a"=>"Cat","b"=>"Dog","c"=>"Horse");
print_r(array_values($a));
?>
输出：
Array ( [0] => Cat [1] => Dog [2] => Horse )
array_diff() 函数返回两个数组的差集数组。
该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键值。
array_diff(array1,array2,array3…)
<?php
$a1=array(0=>"Cat",1=>"Dog",2=>"Horse");
$a2=array(3=>"Horse",4=>"Dog",5=>"Fish");
print_r(array_diff($a1,$a2));
?>
输出：
Array ( [0] => Cat )
array_diff_key
数组交集 array_intersect
<?php
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);
?>
以上例程会输出：
Array
(
[a] => green
[0] => red
)
array_intersect_key 不用值，用key
object转array $editor->toArray();
相当于
function object_to_array($obj){
$_arr = is_object($obj)? get_object_vars($obj) :$obj;
foreach ($_arr as $key => $val){
$val=(is_array($val)) || is_object($val) ? object_to_array($val) :$val;
$arr[$key] = $val;
}
return $arr;
返回数组元素字符串、字符串分割成数组implode()与explode()
implode(“X",$arr);
<?php
$str = "Hello world. I love Shanghai!";
print_r (explode(" “,$str));
数组合并 array_merge
<?php
$a1=array("a"=>"Horse","b"=>"Dog");
$a2=array("c"=>"Cow","b"=>"Cat");
print_r(array_merge($a1,$a2));
array_merge(array1,array2,array3…)
返回没有重复值的新数组 array_unique()
这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。
<?php
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>
上例将输出：
Array
(
[a] => green
[0] => red
[1] => blue
)
例子 2. array_unique() 和类型
<?php
$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);
?>
上例将输出：
array(2) {
[0] => int(4)
[2] => string(1) "3"
}
数组排序总结
sort() 函数用于对数组单元从低到高进行排序。
rsort() 函数用于对数组单元从高到低进行排序。
asort() 函数用于对数组单元从低到高进行排序并保持索引关系。
arsort() 函数用于对数组单元从高到低进行排序并保持索引关系。
ksort() 函数用于对数组单元按照键名从低到高进行排序。
krsort() 函数用于对数组单元按照键名从高到低进行排序。
自定义排序 usort（按值） uksort（按键）
uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
多维排序 array_multisort
数组按照键名对数组排序，为数组值保留原来的键 ksort()
<?php
$my_array = array("a" => "Dog", "b" => "Cat", "c" => "Horse");
ksort($my_array);
print_r($my_array);
?>
输出：
Array
(
[a] => Dog
[b] => Cat
[c] => Horse
)
数组按照键名对数组逆序，为数组值保留原来的键 krsort()
$my_array = array("a" => "Dog", "b" => "Cat", "c" => "Horse");
ksort($my_array);
print_r($my_array);
?>
输出：
Array
(
[c] => Horse
[b] => Cat
[a] => Dog
)
按值排序、多维数组排序(类似与order by 不如用一个usort灵活) array_multisort
1、按照值排序 可以一次排多个
$num1 = array(3, 5, 4, 3);
$num2 = array(27, 50, 44, 78);
array_multisort($num1, SORT_ASC, $num2, SORT_DESC);
print_r($num1);
print_r($num2);
result: Array ( [0] => 3 [1] => 3 [2] => 4 [3] => 5 ) Array ( [0] => 78 [1] => 27 [2] => 44 [3] => 50 )
2、多维排序
$arr = array(
'0' => array(
'num1' => 3,
'num2' => 27
),
'1' => array(
'num1' => 5,
'num2' => 50
),
'2' => array(
'num1' => 4,
'num2' => 44
),
'3' => array(
'num1' => 3,
'num2' => 78
)
);
foreach ( $arr as $key => $row ){
$num1[$key] = $row ['num1'];
$num2[$key] = $row ['num2'];
}
array_multisort($num1, SORT_ASC,$arr);
array_multisort($num1, SORT_ASC, $num2, SORT_DESC, $arr);
按照用户自己定义的函数进行排序 usort
usort(array,sorttype)
参数 描述
array 必需。规定要排序的数组。
function
必需。用户自定义的函数。
函数必须设计为返回 -1, 0, 或 1，并应该接受两个供比较的参数，同时以类似下面这样的方式来工作：
如果 a = b, 返回 0
如果 a > b, 返回 1
如果 a < b, 返回 -1
function my_sort($a, $b)
{
if ($a == $b) return 0;
return ($a > $b) ? -1 : 1;
}
$arr = array("Peter", "glenn","Cleveland","peter","cleveland", "Glenn");
usort($arr, "my_sort");
print_r ($arr);
数组截取 array_slice
<?php
$a=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
print_r(array_slice($a,1,2));
?>
输出：
Array ( [0] => Cat [1] => Horse )
数组截取与替换 array_splice
<?php
$a1=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
$a2=array(0=>"Tiger",1=>"Lion");
array_splice($a1,0,2,$a2);
print_r($a1);
?>
输出：
Array ( [0] => Tiger [1] => Lion [2] => Horse [3] => Bird )
数组键值倒转 array_flip()
array_flip() 函数返回一个反转后的数组，如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。
<?php
$a=array(0=>"Dog",1=>"Cat",2=>"Horse");print_r(array_flip($a));
?>
输出：
Array ( [Dog] => 0 [Cat] => 1 [Horse] => 2 )
数组中的最值 min max()
$a = max([1,2,3,4,5]);
多维数组返回指定列 array_column
$records = array(
array(
'id' => 2135,
'first_name' => 'John',
'last_name' => 'Doe',
),
array(
'id' => 3245,
'first_name' => 'Sally',
'last_name' => 'Smith',
),
array(
'id' => 5342,
'first_name' => 'Jane',
'last_name' => 'Jones',
),
array(
'id' => 5623,
'first_name' => 'Peter',
'last_name' => 'Doe',
)
);
$first_names = array_column($records, 'first_name');
print_r($first_names);
?>
以上例程会输出：
Array
(
[0] => John
[1] => Sally
[2] => Jane
[3] => Peter
)
$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);
?>
以上例程会输出：
Array
(
[2135] => Doe
[3245] => Smith
[5342] => Jones
[5623] => Doe
)
数组求和 array_sum()
将数组中的所有值的和以整数或浮点数的结果返回
数组求乘积 array_product()
以整数或浮点数返回一个数组中所有值的乘积
数组翻转 array_reverse
函数将原数组中的元素顺序翻转，创建新的数组并返回。如果第二个参数指定为 true，则元素的键名保持不变，否则键名将丢失。
<?php
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
print_r(array_reverse($a));
?>
输出：
Array ( [c] => Horse [b] => Cat [a] => Dog )
数组头部插入值 array_unshift
array_unshift() 函数在数组开头插入一个或多个元素。
被加上的元素作为一个整体添加，这些元素在数组中的顺序和在参数中的顺序一样。
该函数会返回数组中元素的个数。
语法
array_unshift(array,value1,value2,value3...)
<?php
$a=array("a"=>"Cat","b"=>"Dog");
array_unshift($a,"Horse");
print_r($a);
?>
输出：
Array ( [0] => Horse [a] => Cat [b] => Dog )
数组头部删除一个元素并返回 array_shift()
<?php
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
echo array_shift($a);
print_r ($a);
?>
输出：
Dog
Array ( [b] => Cat [c] => Horse )
函数删除数组中的最后一个元素 array_pop()
<?php
$a=array("Dog","Cat","Horse");
array_pop($a);
print_r($a);
?>
输出：
Array ( [0] => Dog [1] => Cat )
向数组中插入一个值 array_push
然后返回新数组的长度
如果用 array_push() 来给数组增加一个单元，还不如用 $array[] =，因为这样没有调用函数的额外负担。
注释：如果第一个参数不是数组，array_push() 将发出一条警告。这和 $var[] 的行为不同，后者会新建一个数组。
数组分成若干子数组 array_chunk
array_chunk() 函数把一个数组分割为新的数组块。
其中每个数组的单元数目由 size 参数决定。最后一个数组的单元数目可能会少几个。
可选参数 preserve_key 是一个布尔值，它指定新数组的元素是否有和原数组相同的键（用于关联数组），还是从 0 开始的新数字键（用于索引数组）。默认是分配新的键。
语法
array_chunk(array,size,preserve_key)
<?php
$a=array("a"=>"Cat","b"=>"Dog","c"=>"Horse","d"=>"Cow");
print_r(array_chunk($a,2,true));
?>
输出：
Array (
[0] => Array ( [a] => Cat [b] => Dog )
[1] => Array ( [c] => Horse [d] => Cow )
)
随机打乱数组 shuffle
shuffle() 函数把数组中的元素按随机顺序重新排列。
若成功，则返回 TRUE，否则返回 FALSE。
注释：本函数为数组中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。
$my_array = array("a" => "Dog", "b" => "Cat", "c" => "Horse");
shuffle($my_array);
print_r($my_array);
?>
输出：
Array ( [0] => Cat [1] => Horse [2] => Dog )
创建一个数组用一个数组的值作为其键名，另一个数组的值作为其值array_combine
<?php
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
填充数组到指定长度 array_pad
$input = array(12, 10, 9);
$result = array_pad($input, 5, 0);
// result is array(12, 10, 9, 0, 0)
填充数组 array_fill
array_fill() 用 value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始
<?php
$a = array_fill(5, 6, 'banana');
$b = array_fill(-2, 4, 'pear');
print_r($a);
print_r($b);
?>
以上例程会输出：
Array
(
[5] => banana
[6] => banana
[7] => banana
[8] => banana
[9] => banana
[10] => banana
)
Array
(
[-2] => pear
[0] => pear
[1] => pear
[2] => pear
)
填充数组(指定key) array_fill_keys
<?php
$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
?>
以上例程会输出：
Array
(
[foo] => banana
[5] => banana
[10] => banana
[bar] => banana
)
统计数组中值出现的次数 array_count_values
<?php
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
?>
以上例程会输出：
Array
(
[1] => 2
[hello] => 2
[world] => 1
)
自定义函数实现数组过滤 array_filter
<?php
function odd($var)
{
// returns whether the input integer is odd
return($var & 1);
}
function even($var)
{
// returns whether the input integer is even
return(!($var & 1));
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
echo "Odd :\n";
print_r(array_filter($array1, "odd"));
echo "Even:\n";
print_r(array_filter($array2, "even"));
?>
以上例程会输出：
Odd :
Array
(
[a] => 1
[c] => 3
[e] => 5
)
Even:
Array
(
[0] => 6
[2] => 8
[4] => 10
[6] => 12
)
自定义函数实现数组操作 array_map
<?php
function cube($n)
{
return($n * $n * $n);
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>
把数组中的值赋给一些变量 list()
其他常用函数
判断是否为空 empty()
PHP的empty()函数 判断值为否为空
格式：bool empty ( mixed var )
功能：检查一个变量是否为空
返回值：
若变量不存在则返回 TRUE
若变量存在且其值为""、0、"0"、NULL、、FALSE、array()、var $var; 以及没有任何属性的对象，则返回 TURE，不存在的（未被赋值）变量或者数组项也返回TRUE
否则返回false。
empty() 只能用于变量，传递任何其它参数都将造成Paser error而终止运行。
判断变量已定义 isset()
PHP的isset()函数 一般用来检测变量是否设置
若变量不存在则返回 FALSE
若变量存在且其值为NULL，也返回 FALSE
若变量存在且值不为NULL，则返回 TURE
使用 unset() 释放变量之后，它将不再是 isset()。
PHP函数isset()只能用于变量，传递任何其它参数都将造成解析错误。
判断常量是否定义过 defined()
首先，检测常量是否已设置可使用 defined() 函数。
向上舍入为最接近的整数。 ceil() 函数
返回不小于 x 的下一个整数，x 如果有小数部分则进一位。ceil() 返回的类型仍然是 float，因为 float 值的范围通常比 integer 要大。
例子
在本例中，我们将对不同的值应用 ceil() 函数：
<?php
echo(ceil(0.60);
echo(ceil(0.40);
echo(ceil(5);
echo(ceil(5.1);
echo(ceil(-5.1);
echo(ceil(-5.9));
?>
输出：
1
1
5
6
-5
-5
向下舍入为最接近的整数。 floor() 函数
返回不大于 x 的下一个整数，将 x 的小数部分舍去取整。floor() 返回的类型仍然是 float，因为 float 值的范围通常比 integer 要大。
<?php
echo(floor(0.60));
echo(floor(0.40));
echo(floor(5));
echo(floor(5.1));
echo(floor(-5.1));
echo(floor(-5.9))
?>
输出：
0
0
5
5
-6
-6
浮点数四舍五入 round()
<?php
echo(round(0.60));
echo(round(0.50));
echo(round(0.49));
echo(round(-4.40));
echo(round(-4.60));
?>
输出：
1
1
0
-4
-5
URL解析函数 parse_url
$url = '//www.example.com/path?googleguy=googley&a=b';
var_dump(parse_url($url));
array(3) {
["host"]=>
string(15) "www.example.com"
["path"]=>
string(5) "/path"
["query"]=>
string(17) "googleguy=googley"
}
注：当前请求存放在 $_SERVER[‘REQUEST_URI']
参数解析函数 parse_str
注释：如果未设置 array 参数，则由该函数设置的变量将覆盖已存在的同名变量。
<?php
parse_str("name=Bill&age=60");
echo $name."<br>";
echo $age;
?>
<?php
parse_str("name=Bill&age=60",$myArray);
print_r($myArray);
?>
生成 URL-encode 之后的请求字符串 http_build_query
$data = array(‘foo'=>'bar',
'baz'=>'boom',
'cow'=>'milk',
'php'=>'hypertext processor');
echo http_build_query($data) . “\n";
生成 URL请求字符串 http_build_query
<?php
$data = array('foo'=>'bar',
'baz'=>'boom',
'cow'=>'milk',
'php'=>'hypertext processor');
echo http_build_query($data) . “\n";
foo=bar&baz=boom&cow=milk&php=hypertext+processor
今天知道了一个大大的知识点！！！！！！
参数除了可以是字符串，还可以是一个数组，其实难怪，REQEUST不就是一个装着查询字符串的数组吗。那value页可以另一个数组。
$data = array('x'=>array(
'name' => 'wangwei',
),
);
echo http_build_query($data);
是这样的：
x%5Bname%5D=wangwei
构造一个访问：
http://beta.moirai.immomo.com:8580/liveroom/report/index?x%5Bname%5D=wangwei
（http://beta.moirai.immomo.com:8580/liveroom/report/index?x[name]=wangwei）
取REQUEST[‘x’]打出来是个数组 {‘name’:’wangwei’}
转整型浮点典型 intval() doubleval() floatval()
转字符串 strval()
函数返回随机整数 rand()
rand(min,max) 如果没有提供可选参数 min 和 max，rand() 返回 0 到 RAND_MAX 之间的伪随机整数。
mt_rand() 函数是非正式用来替换它的。该函数用了 Mersenne Twister 中已知的特性作为随机数发生器，它可以产生随机数值的平均速度比 libc 提供的 rand() 快四倍。
函数通过千位分组来格式化数字 number_format()
number_format(number,decimals,decimalpoint,separator)
参数 描述
number
必需。要格式化的数字。
如果未设置其他参数，则数字会被格式化为不带小数点且以逗号（,）作为千位分隔符。
decimals 可选。规定多少个小数。如果设置了该参数，则使用点号（.）作为小数点来格式化数字。
decimalpoint 可选。规定用作小数点的字符串。
separator
可选。规定用作千位分隔符的字符串。仅使用该参数的第一个字符。比如 "xxx" 仅输出 "x"。
注释：如果设置了该参数，那么所有其他参数都是必需的。
字符串并尝试将其解析为 Unix 时间戳 strtotime
其值相对于 now 参数给出的时间，如果没有提供此参数则用系统当前时间
echo strtotime("now"), "\n";
echo strtotime("10 September 2000"), "\n";
echo strtotime("+1 day"), "\n";
echo strtotime("+1 week"), "\n";
echo strtotime("+1 week 2 days 4 hours 2 seconds"), "\n";
echo strtotime("next Thursday"), "\n";
echo strtotime("last Monday"), “\n";
函数返回一个日期的 Unix 时间戳 mktime()
函数对于日期运算和验证非常有用。它可以自动校正越界的输入：
<?php
echo(date("M-d-Y",mktime(0,0,0,12,36,2001)));
echo(date("M-d-Y",mktime(0,0,0,14,1,2001)));
echo(date("M-d-Y",mktime(0,0,0,1,1,2001)));
echo(date("M-d-Y",mktime(0,0,0,1,1,99)));
?>
输出：
Jan-05-2002
Feb-01-2002
Jan-01-2001
Jan-01-1999
返回当前时间戳 time()
函数用于对日期或时间进行格式化 date()
date(format,timestamp)
date() 函数的格式参数是必需的，它们规定如何格式化日期或时间。
下面列出了一些常用于日期的字符：
d - 表示月里的某天（01-31）
m - 表示月（01-12）
Y - 表示年（四位数）
1 - 表示周里的某天
其他字符，比如 "/", "." 或 "-" 也可被插入字符中，以增加其他格式。
下面的例子用三种不同方法格式今天的日期：
实例
<?php
echo "今天是 " . date("Y/m/d") . "<br>";
echo "今天是 " . date("Y.m.d") . "<br>";
echo "今天是 " . date("Y-m-d") . "<br>";
echo "今天是 " . date("l");
?>
正则替换函数 preg_replace()
<?php
$weigeti='W3CSchool 在线教程网址：http://www.jb51.net/w3school/';
echo preg_replace('/W3CSchool/','w3c',$weigeti);
//大小写不同，输出【w3c 在线教程网址：http://www.jb51.net/w3school/】
echo preg_replace('/W3CSchool/i','w3c',$weigeti);
//忽略大小写，执行替换输出【w3c 在线教程网址：http://e.jb51.net/w3c/】
echo preg_replace('/网址/u','',$weigeti);
//强制 UTF-8中文，执行替换，输出【W3CSchool 在线教程：http://www.jb51.net/w3school/】
?>
还可以使用正则表达式队数组进行过滤
//preg_grep("正则","字符串") 与数组匹配后返回新数组
$phpddt = array("php点点通","php100","呵呵","hahaha","phpchina");
$item = preg_grep("/^php/",$phpddt);
print_r($item);
正则匹配函数 preg_match($preg,$a1,$result);
preg_match() 函数用于进行正则表达式匹配，成功返回 1 ，否则返回 0 。
preg_match() 匹配成功一次后就会停止匹配，如果要实现全部结果的匹配，则需使用 preg_match_all() 函数。
绝对值函数 abs()
判断是否存在
method_exists
property_exists
function_exists
class_exists
file_exists
基于微秒生成唯一id uniqid
uniqid(prefix,more_entropy)
参数 描述
prefix 可选。为 ID 规定前缀。如果两个脚本恰好在相同的微秒生成 ID，该参数很有用。
more_entropy 可选。规定位于返回值末尾的更多的熵。
由于基于系统时间，通过该函数生成的 ID 不是最佳的。如需生成绝对唯一的 ID
方法一：加随机因素进去，重复概率可以忽略
uniqid(rand(), true)
方法二：加入唯一因素进去
一般唯一id都会加入一些唯一表示符,比如机器的GUID,就可以吧mac地址,cpu型号等硬件信息加入guid这样生成的就能保证跟其他任何一台机器产生的GUID不会重复.
再比如如果要为每个用户生成一个唯一id的, 最好把用户ID信息放进来,这样可以保证每个用户生成的都是唯一的,而且同一个用户操作总是有先后的,也不可能生成重复的id.
echo uniqid();
?>
输出类似：
4415297e3af8c
调用函数或方法call_user_func和call_user_func_array
call_user_func函数类似于一种特别的调用函数的方法，使用方法如下：
<?php
function nowamagic($a,$b)
{
echo $a;
echo $b;
}
call_user_func('nowamagic', "111","222");
call_user_func('nowamagic', "333","444");
//显示 111 222 333 444
?>
调用类内部的方法比较奇怪，居然用的是array，不知道开发者是如何考虑的，当然省去了new，也挺有新意的：
<?php
class a {
function b($c)
{
echo $c;
}
}
call_user_func(array("a", "b"),"111");
call_user_func_array函数和call_user_func很相似，只不过是换了一种方式传递了参数，让参数的结构更清晰：
<?php
function a($b, $c)
{
echo $b;
echo $c;
}
call_user_func_array('a', array("111", "222"));
//显示 111 222
?>
call_user_func_array函数也可以调用类内部的方法的：
<?php
Class ClassA
{
function bc($b, $c) {
$bc = $b + $c;
echo $bc;
}
}
call_user_func_array(array('ClassA','bc'), array("111", "222"));
[(u'2015-12-01 08', u'not_recover', 2L), (u'2015-12-01 09', u'not_recover', 378L), (u'2015-12-01 09', u'recover', 3L), (u'2015-12-01 10', u'not_recover', 469L), (u'2015-12-01 10', u'recover', 9L), (u'2015-12-01 11', u'not_recover', 829L), (u'2015-12-01 11', u'recover', 8L), (u'2015-12-01 12', u'not_recover', 285L), (u'2015-12-01 12', u'recover', 1L), (u'2015-12-01 13', u'not_recover', 513L), (u'2015-12-01 13', u'recover', 5L), (u'2015-12-01 14', u'not_recover', 84L), (u'2015-12-01 14', u'recover', 1L), (u'2015-12-01 15', u'not_recover', 80L), (u'2015-12-01 16', u'not_recover', 185L), (u'2015-12-01 16', u'recover', 4L), (u'2015-12-01 17', u'not_recover', 494L), (u'2015-12-01 17', u'recover', 4L), (u'2015-12-01 18', u'not_recover', 383L), (u'2015-12-01 18', u'recover', 7L), (u'2015-12-01 19', u'not_recover', 70L), (u'2015-12-01 20', u'not_recover', 70L), (u'2015-12-01 21', u'not_recover', 464L), (u'2015-12-01 21', u'recover', 7L), (u'2015-12-01 22', u'not_recover', 240L), (u'2015-12-01 22', u'recover', 3L), (u'2015-12-02 09', u'not_recover', 375L), (u'2015-12-02 10', u'not_recover', 1003L), (u'2015-12-02 10', u'recover', 6L), (u'2015-12-02 11', u'not_recover', 430L), (u'2015-12-02 11', u'recover', 5L), (u'2015-12-02 12', u'not_recover', 91L), (u'2015-12-02 13', u'not_recover', 231L), (u'2015-12-02 13', u'recover', 4L), (u'2015-12-02 14', u'not_recover', 375L), (u'2015-12-02 14', u'recover', 5L), (u'2015-12-02 15', u'not_recover', 174L), (u'2015-12-02 15', u'recover', 2L), (u'2015-12-02 16', u'not_recover', 295L), (u'2015-12-02 16', u'recover', 1L), (u'2015-12-02 17', u'not_recover', 211L), (u'2015-12-02 17', u'recover', 1L), (u'2015-12-02 18', u'not_recover', 418L), (u'2015-12-02 18', u'recover', 5L), (u'2015-12-02 19', u'not_recover', 81L), (u'2015-12-02 19', u'recover', 1L), (u'2015-12-02 20', u'not_recover', 231L), (u'2015-12-02 20', u'recover', 3L), (u'2015-12-02 21', u'not_recover', 301L), (u'2015-12-02 21', u'recover', 4L), (u'2015-12-02 22', u'not_recover', 148L), (u'2015-12-02 22', u'recover', 3L), (u'2015-12-03 10', u'not_recover', 255L), (u'2015-12-03 11', u'not_recover', 223L), (u'2015-12-03 11', u'recover', 2L)]
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
