一，对象与类
对象：
python中一切皆为对象，所谓对象：我自己就是一个对象，我玩的电脑就是对象，玩的手机就是对象。
我们通过描述属性（特征）和行为来描述一个对象的。
在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）
结论：对象=属性+方法
在python中，把具有相同属性和方法的对象归为一个类（class）
比如人类，动物，植物等等，这些都是类的概念。
类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
例如：”liuyao“ “yaoyao” “shabi” 都是根据不同的类进行创建的对象
一,整数
1.int型
具有的功能：
|
1
|
class
int
(
object
):
|
(1).返回表示该数字的时占用的最少位数
|
1
2
3
4
|
def
bit_length(
self
):
例:
>>>
bin
(
10
)
'0b1010'
#0b是二进制，1010是所占位数
|
(2).返回绝对值
|
1
2
3
4
5
6
7
|
def
__abs__(
self
):
例:
>>> absolute
=
-
10
>>> absolute.__abs__()
10
>>>
abs
(
-
10
)
10
|
(3).相除，得到商和余数组成的元组
|
1
2
3
4
5
6
|
def
__divmod__(
self
)
例：
>>> age
=
21
>>> sb
=
age.__divmod__(
6
)
>>>
print
(sb)
(
3
,
3
)
|
(4).int转换为浮点类型
(5).__cmp__(self, y)比较两个数大小 注：在3.x版本被
(6).__coerce__(self, y)强制生成一个元组 注：在3.x版本被取消
(7).数值相加
|
1
2
3
4
5
6
7
8
|
def
__add__(
self
,other)
例：
>>> num1
=
15
>>> num2
=
20
>>>
print
(num1
+
num2)
35
>>>
print
(num1.__add__(num2))
35
|
(8).布尔值
|
1
2
3
4
5
6
|
>>>
bool
=
0
>>>
print
(
bool
.__bool__())
False
>>>
bool
=
1
>>>
print
(
bool
.__bool__())
True
|
9. 判断是是否相等
|
1
2
3
4
|
>>> zhi1
=
10
>>> zhi2
=
11
>>>
print
(zhi1.__eq__(zhi2))
False
|
10. 返回浮点
|
1
2
3
|
>>> zhi
=
10
>>>
print
(zhi.__float__())
10.0
|
11. 地板除
|
1
2
3
4
|
>>> a=
10
>>> b=
3
>>> print(a.__floordiv__(b))
3
|
12. 大于等于
|
1
2
3
4
|
>>> a
=
20
>>> b
=
12
>>>
print
(a.__ge__(b))
True
|
13. 大于
|
1
2
|
>>>
print
(a.__gt__(b))
True
|
14.哈希
|
1
|
print
(num.__hash__())
|
15.__invert__ :取反
|
1
2
3
|
>>> a
=
45
>>>
print
(a.__invert__())
-
46
|
16.小于等于
|
1
2
3
4
|
>>> a
=
10
>>> b
=
20
>>>
print
(a.__lt__(b))
True
|
17. __lshift__ :左移位
|
1
2
3
4
|
>>> num1
=
10
>>> num2
=
10
>>>
print
(num1.__lshift__(num2))
10240
|
18.求模
|
1
2
3
4
|
>>> a
=
20
>>> b
=
11
>>>
print
(a.__mod__(b))
9
|
19.相乘
|
1
2
3
4
|
>>> a
=
10
>>> b
=
2
>>>
print
(a.__mul__(b))
20
|
20.取反
|
1
2
3
|
>>> a
=
21
>>>
print
(a.__neg__())
-
21
|
21.不等于
|
1
2
3
4
|
>>> a
=
20
>>> b
=
10
>>>
print
(a.__ne__(b))
True
|
22.取正数
|
1
2
3
4
5
6
|
>>> a
=
-
10
>>>
print
(a.__pos__())
-
10
>>> a
=
10
>>>
print
(a.__pos__())
10
|
23 乘方
|
1
2
3
|
>>> a
=
10
>>>
print
(a.__pow__(
10
))
10000000000
|
24.右加（以下前缀为r的都是右；前缀为l的都是左）
|
1
|
print
(a.__radd__(b))
|
25.右或
|
1
|
print
(a.__repr__())
|
26.右除以左，返回商和余数
|
1
|
print
(a.__repr__())
|
27.转换为解释器可读取的形式
|
1
|
print
(a.__repr__())
|
28.转换为字符串
|
1
2
3
|
>>> a
=
10
>>>
print
(a.__pow__(
10
))
10000000000
|
29.求差
|
1
2
3
|
>>>num=
10
>>>num2=
20
print(num.__sub__(num2))
|
2、long型
具有的功能：
|
1
|
class
long
(
object
):
|
同int型
3.float型
1.返回分子分母数构成的元祖
|
1
|
as_integer_ratio()
|
2.将十六进制数转换为浮点数
|
1
|
print
(
float
.fromhex(
'0x1.ffffp10'
))
|
3.将浮点数转换为十六进制数
|
1
|
print
(
2047.984375
.
hex
())
|
4.判断浮点数是不是整数
|
1
2
3
|
f1
=
10.2
f2
=
10.0
print
(f1.is_integer())
31print
(f2.is_integer())
|
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
二.字符串
具有的功能：
|
1
|
class
str
(
basestring
):
|
1.首字母变大写
|
1
2
3
4
5
|
def
capitalize(
self
):
例：
>>> name
=
'yaoyao'
>>>
print
(name.capitalize())
Yaoyao
|
2.内容居中
|
1
2
3
4
5
6
|
def
center(
self
, width, fillchar
=
None
):
""" 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
例：
>>> name
=
'liuyao'
>>>
print
(name.center(
20
,
'*'
))
*
*
*
*
*
*
*
liuyao
*
*
*
*
*
*
*
|
3.查询个数
|
1
2
3
4
5
6
7
|
count(
self
, sub, start
=
None
, end
=
None
)子序列个数 sub：要查询的子序列 start：开始位置 end：结束位置
例：
>>> cou
=
'asdfghjasdfgjqweryuzxcvbnm'
>>>
print
(cou.count(
'as'
))
2
>>>
print
(cou.count(
'as'
,
1
,
25
))
1
|
4.编码修改
|
1
2
3
4
5
6
|
encode(
self
, encoding
=
None
, errors
=
None
）编码，针对
unicode
encoding
=
'解码的格式'
例：
>>> name
=
'刘耀'
>>>
print
(name.encode(
'gbk'
))
b
'\xc1\xf5\xd2\xab'
>>>
|
5.endswith
|
1
2
3
4
5
6
7
|
endswith(
self
, suffix, start
=
None
, end
=
None
)是否以xxx结尾 suffix：填入结尾的字符串 start
=
在第几个字符开始 end
=
在第几个字符结束
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回
True
，否则返回
False
。可选参数
"start"
与
"end"
为检索字符串的开始与结束位置。
例：
>>> name
=
'asdfghjklo'
>>>
print
(name.endswith(
'lo'
,
0
,
6
))
False
>>>
|
6.expandtabs()
|
1
2
3
4
5
|
expandtabs() 方法把字符串中的 tab 符号(
'\t'
)转为空格，默认的空格数 tabsize 是
8
例：
>>> extab
=
'one\ttwo'
>>>
print
(extab.expandtabs())
one two
|
7.find
|
1
2
3
4
5
6
7
|
find(
self
, sub, start
=
None
, end
=
None
)寻找子序列位置，如果没找到，返回
-
1
例：
>>> name
=
'yaotwosiji'
>>>
print
(name.find(
'two'
,
1
,
8
))
3
>>>
print
(name.find(
'two'
,
1
,
3
))
-
1
|
8.casefold
|
1
2
|
casefold(
self
)大写转小写 注：
3.x
新增方法，
2.x
没有
例：
|
9.format格式化
|
1
2
3
4
5
6
|
format
(
*
args,
*
*
kwargs)字符串格式化
例:
>>> name
=
'liuyao'
>>> age
=
'21'
>>>
print
(
'姓名{0},年龄{1}'
.
format
(name,age))
姓名liuyao,年龄
21
|
10.index
|
1
2
3
4
5
6
7
8
9
|
index(
self
, sub, start
=
None
, end
=
None
)子序列位置，如果没找到，报错
例：
>>> name
=
'asdfghjklqwertyui'
>>>
print
(name.index(
'fg'
))
3
>>>
print
(name.index(
'fg'
,
1
,
3
))
Traceback (most recent call last):
File
"<stdin>"
, line
1
,
in
<module>
ValueError: substring
not
found
|
11.isalnum
|
1
2
3
4
5
6
7
8
|
isalnum(
self
)如果字符串至少有一个字符并且所有字符都是字母或数字则返回
True
,否则返回
False
例：
>>> zifu
=
'yao1995'
>>>
print
(zifu.isalnum())
True
>>> zifutab
=
'yao 1995'
>>>
print
(zifutab.isalnum())
False
|
12.isalpha
|
1
2
3
4
5
|
isalpha(
self
)如果字符串至少有一个字符并且所有字符都是字母则返回
True
,否则返回
False
例：
>>> zifutab
=
'yao'
>>>
print
(zifutab.isalpha())
True
|
13.isdigit
|
1
2
3
4
5
|
isdigit(
self
)如果字符串只包含数字则返回
True
否则返回
False
例：
>>> shuzi
=
'1995'
>>>
print
(shuzi.isdigit())
True
|
14.islower
|
1
2
3
4
5
|
islower(
self
)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回
True
，否则返回
False
例：
>>> zifu
=
'Liuyao'
>>>
print
(zifu.islower())
False
|
15.isspace
|
1
2
3
4
5
|
isspace(
self
)如果字符串中只包含空格，则返回
True
，否则返回
False
例：
>>> kongge
=
' '
>>>
print
(kongge.isspace())
True
|
16.istitle
|
1
2
3
4
5
|
istitle(
self
)如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回
True
，否则返回
False
例：
>>> zifu
=
'Liu Yao'
>>>
print
(zifu.istitle())
True
|
17.isupper
|
1
2
3
4
5
|
isupper(
self
)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回
True
，否则返回
False
例：
>>> zifu
=
'LIU YAO'
>>>
print
(zifu.isupper())
True
|
18.join
|
1
2
3
4
5
6
|
join(
self
, iterable)返回通过指定字符连接序列中元素后生成的新字符串
例：
>>> lj
=
'^'
>>> name
=
(
'y'
,
'a'
,
'o'
)
>>>
print
(lj.join(name))
y^a^o
|
19.ljust
|
1
2
|
ljust(
self
, width, fillchar
=
None
)返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
例：
|
20.lower
|
1
2
3
4
|
lower(
self
)返回将字符串中所有大写字符转换为小写后生成的字符串
>>> name
=
'LIUYAO'
>>>
print
(name.lower())
liuyao
|
21.lstrip
|
1
2
3
4
|
lstrip(
self
, chars
=
None
)返回截掉字符串左边的空格或指定字符后生成的新字符串
>>> name
=
'liuyaoliuyaoliuyao'
>>>
print
(name.lstrip(
'liu'
))
yaoliuyaoliuyao
|
22.partition
|
1
2
3
4
|
partition(
self
, sep)返回一个
3
元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
>>> who
=
'wo shi liuyao'
>>>
print
(who.partition(
'shi'
))
(
'wo '
,
'shi'
,
' liuyao'
)
|
23.replace
|
1
2
3
4
5
6
|
replace(
self
, old, new, count
=
None
)返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数
max
，则替换不超过
max
次
>>> str1
=
'ni shi wo shi shei shi'
>>>
print
(str1.replace(
'shi'
,
'ta'
))
ni ta wo ta shei ta
>>>
print
(str1.replace(
'shi'
,
'ta'
,
1
))
ni ta wo shi shei shi
|
24.split
|
1
2
3
4
5
6
|
split(
self
, sep
=
None
, maxsplit
=
None
)通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
>>> str1
=
'a1 b2 c3 d4'
>>>
print
(str1.split())
[
'a1'
,
'b2'
,
'c3'
,
'd4'
]
>>>
print
(str1.split(
' '
,
2
))
[
'a1'
,
'b2'
,
'c3 d4'
]
|
25.splitlines
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
splitlines(
self
, keepends
=
False
)按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行
>>> str1
=
'\na1b2 c3 d4'
>>> str1
=
'\na1b2\nc3\nd4\n'
>>>
print
(str1)
a1b2
c3
d4
>>>
print
(str1.splitlines())
['
', '
a1b2
', '
c3
', '
d4']
>>>
print
(str1.splitlines(
2
))
[
'\n'
,
'a1b2\n'
,
'c3\n'
,
'd4\n'
]
|
26.startswith
|
1
2
3
4
5
6
|
startswith(
self
, prefix, start
=
None
, end
=
None
)用于检查字符串是否是以指定子字符串开头，如果是则返回
True
，否则返回
False
。如果参数 beg 和 end 指定值，则在指定范围内检查
>>> name
=
'LIUyao'
>>>
print
(name.startswith(
'LI'
))
True
>>>
print
(name.startswith(
'ya'
))
False
|
27.swapcase
|
1
2
3
4
|
swapcase(
self
)用于对字符串的大小写字母进行转换
>>> name
=
'LIUyao'
>>>
print
(name.swapcase())
liuYAO
|
28.translate
|
1
|
translate(
self
, table, deletechars
=
None
)根据参数table给出的表(包含
256
个字符)转换字符串的字符, 要过滤掉的字符放到
del
参数中，table
-
-
翻译表，翻译表是通过maketrans方法转换而来，deletechars
-
-
字符串中要过滤的字符列表。
|
29.upper
|
1
2
3
4
|
upper(
self
)将字符串中的小写字母转为大写字母
>>> name
=
'yaoyao'
>>>
print
(name.upper())
YAOYAO
|
30.zfill
|
1
2
3
4
5
6
|
zfill(
self
, width)返回指定长度的字符串，width
-
-
指定字符串的长度。原字符串右对齐，前面填充
0
。
>>> str1
=
'a1 b2 c3 d4'
>>>
print
(str1.zfill(
10
))
a1 b2 c3 d4
>>>
print
(str1.zfill(
15
))
0000a1
b2 c3 d4
|
三.列表
具有以下方法：
1、追加
|
1
2
3
4
5
|
append(
self
, p_object)用于在列表末尾添加新的对象，obj
-
-
添加到列表末尾的对象，该方法无返回值，但是会修改原来的列表。
>>> lie
=
[
1
,
2
,
3
,
4
,
5
]
>>> lie.append(
6
)
>>>
print
(lie)
[
1
,
2
,
3
,
4
,
5
,
6
]
|
2、统计
|
1
2
3
4
|
count(
self
, value)用于统计某个元素在列表中出现的次数，value
-
-
列表中统计的对象，返回元素在列表中出现的次数。
>>> lie
=
[
1
,
2
,
3
,
4
,
5
,
1
,
2
,
3
]
>>>
print
(lie.count(
2
))
2
|
3、合并
|
1
2
3
4
5
6
7
8
|
extend(
self
, iterable)用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），seq
-
-
元素列表，该方法没有返回值，但会在已存在的列表中添加新的列表内容
>>> list1
[
1
,
2
,
3
,
4
,
5
]
>>> list2
[
'a'
,
'b'
,
'c'
,
'd'
,
'f'
]
>>> list1.extend(list2)
>>> list1
[
1
,
2
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
,
'f'
]
|
4、索引
|
1
2
3
4
5
|
index(
self
, value, start
=
None
, stop
=
None
)用于从列表中找出某个值第一个匹配项的索引位置，value
-
-
查找的对象，该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
>>> list1
[
1
,
2
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
,
'f'
]
>>>
print
(list1.index(
'a'
))
5
|
5、指定插入
|
1
2
3
4
5
6
|
insert(
self
, index, p_object)用于将指定对象插入列表，index
-
-
对象obj需要插入的索引位置，obj
-
-
要插入列表中的对象，该方法没有返回值，但会在列表指定位置插
>>> list1
[
1
,
2
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
]
>>> list1.insert(
2
,
'6'
)
>>> list1
[
1
,
2
,
'6'
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
]
|
6、删除最后一个元素
|
1
2
3
4
5
|
pop(
self
, index
=
None
)用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，index
-
-
可选参数，要移除列表元素的对象，该方法返回从列表中移除的元素对象。
>>> list1.pop()
'f'
>>> list1
[
1
,
2
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
]
|
7、指定删除
|
1
2
3
4
5
6
|
remove(
self
, value)用于移除列表中某个值的第一个匹配项，value
-
-
列表中要移除的对象，该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
>>> list1
[
1
,
2
,
'6'
,
3
,
4
,
5
,
'a'
,
'b'
,
'c'
,
'd'
]
>>> list1.remove(
5
)
>>> list1
[
1
,
2
,
'6'
,
3
,
4
,
'a'
,
'b'
,
'c'
,
'd'
]
|
8、反向存放
|
1
2
3
4
5
6
|
reverse(
self
)用于反向列表中元素，该方法没有返回值，但是会对列表的元素进行反向排序。
>>> list1
[
1
,
2
,
'6'
,
3
,
4
,
'a'
,
'b'
,
'c'
,
'd'
]
>>> list1.reverse()
>>> list1
[
'd'
,
'c'
,
'b'
,
'a'
,
4
,
3
,
'6'
,
2
,
1
]
|
9、排序
|
1
2
3
4
5
|
sort(
self
,
cmp
=
None
, key
=
None
, reverse
=
False
)用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数，该方法没有返回值，但是会对列表的对象进行排序。
>>> list1
=
[
1
,
2
,
3
,
4
,
5
,
7
,
8
,
6
,
5
]
>>> list1.sort()
>>> list1
[
1
,
2
,
3
,
4
,
5
,
5
,
6
,
7
,
8
]
|
10、反序
|
1
|
sorted
内建函数：对序列进行反序，并返回一个列表
|
四.元祖
元组的意义：
元组可以在映射中当作键使用；
元组作为很多内建函数和方法的返回值存在。
元组的元素是不能被修改，但元素的元素能可以被被修改的
具有以下方法：
1.统计
|
1
2
3
4
5
|
>>> boy
=
(
'kelin'
,
'yaoyao'
,
'liuyao'
,
'shabi'
)
>>>
type
(boy)
<
class
'tuple'
>
>>> boy.count(
'yaoyao'
)
1
|
2.索引
|
1
2
|
>>> boy.index(
'liuyao'
)
2
|
五.字典
当数据量达到上百万时，循环字典就不适合用dict.items()，因为首先会把一对对key和value转化为列表，然后在循环遍历输出，会增加内存使用。建议使用如下：
|
1
2
3
4
5
6
7
|
>>> a
=
{
1
:
'a'
,
2
:
'b'
}
>>>
for
k
in
aa:
print
(k,aa[k])
(
1
,
'a'
)
(
2
,
'b'
)
>>>
for
k
in
aa.keys():
print
(k,aa[k])
(
1
,
'a'
)
(
2
,
'b'
)
|
具有以下方法：
1、删除字典内所有元素
|
1
2
3
4
5
6
7
|
clear(
self
)用于删除字典内所有元素，该函数没有任何返回值。
>>> dic
=
{
'k1'
:
'v1'
,
'k2'
:
'v2'
}
>>> dic
{
'k2'
:
'v2'
,
'k1'
:
'v1'
}
>>> dic.clear()
>>> dic
{}
|
2、浅复制
|
1
2
3
4
5
|
copy(
self
)返回一个字典的浅复制。
>>> dic
=
{
'k1'
:
'v1'
,
'k1'
:
'v2'
}
>>> dic.copy()
{
'k1'
:
'v2'
}
>>>
|
3、get
|
1
2
3
4
5
|
get
(self, k, d=None)返回指定键的值，如果值不在字典中返回默认值，key -- 字典中要查找的键，
default
-- 如果指定键的值不存在时，返回该默认值值。
>>> dic = {
'k1'
:
'v1'
,
'k2'
:
'v2'
}
>>> dic.
get
(
'k1'
)
'v1'
>>>
|
4、has_key
|
1
|
has_key(
self
, k)用于判断键是否存在于字典中，如果键在字典
dict
里返回true，否则返回false，k
-
-
要在字典中查找的键。注：
3.x
已删除该函数
|
5、items
|
1
2
3
4
|
items(
self
)以列表返回可遍历的(键, 值) 元组数组。
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.items()
dict_items([(
'age'
,
'21'
), (
'name'
,
'yaoyao'
), (
'job'
,
'IT'
)])
|
6、iteritems
|
1
|
iteritems(
self
)项可迭代。注：
3.x
已删除该函数
|
7、iterkeys
|
1
|
iterkeys(
self
)key可迭代。注：
3.x
已删除该函数
|
8、itervalues
|
1
|
itervalues(
self
)value可迭代。注：
3.x
已删除该函数
|
9、keys
|
1
2
3
4
|
keys(
self
)以列表返回一个字典所有的键。
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.keys()
dict_keys([
'age'
,
'name'
,
'job'
])
|
10、删除键
|
1
2
3
4
5
6
|
pop(self, k, d=None)获取并在字典中移除，k -- 要在字典中查找的键。
>>> dic={
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.pop(
'job'
)
'IT'
>>> dic
{
'age'
:
'21'
,
'name'
:
'yaoyao'
}
|
11、popitem
|
1
2
3
4
5
6
|
popitem(
self
)获取并在字典中移除
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.popitem()
(
'age'
,
'21'
)
>>> dic
{
'name'
:
'yaoyao'
,
'job'
:
'IT'
}
|
12、setdefault
|
1
2
3
4
5
|
setdefault(
self
, k, d
=
None
)如果key不存在，则创建，如果存在，则返回已存在的值且不修改
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.setdefault(
'sex'
)
>>> dic
{
'sex'
:
None
,
'age'
:
'21'
,
'name'
:
'yaoyao'
,
'job'
:
'IT'
}
|
13、更新
|
1
2
3
4
5
6
|
update(
self
, E
=
None
,
*
*
F)更新
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic_1
=
{
'sex'
:
'man'
}
>>> dic.update(dic_1)
>>> dic
{
'sex'
:
'man'
,
'age'
:
'21'
,
'name'
:
'yaoyao'
,
'job'
:
'IT'
}
|
14、values
|
1
2
3
4
|
values(
self
)以列表返回字典中的所有值。
>>> dic
=
{
'name'
:
'yaoyao'
,
'age'
:
'21'
,
'job'
:
'IT'
}
>>> dic.values()
dict_values([
'21'
,
'yaoyao'
,
'IT'
])
|
15、viewitems
|
1
|
viewitems(
self
)所有项，只是将内容保存至view对象中。注：
3.x
已删除该函数
|
扫一扫
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
