二、python的数据类型
python也是弱类型的编程语言。在python2系列中数据类型（数字，布尔，列表，字符串，字典，元组、类），但是在python3系列中又多了一个集合数据类型。
1、数字（Number）
这相当于java中的数值类型(byte,short,int,long,float,double)。
1.1 Python2支持四种不同的数字类型：
- int（有符号整型）
- long（长整型[也可以代表八进制和十六进制]）
- float（浮点型）
- complex（复数）
注意：长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
下面代码：
num1=-0x19323L
print 'python2的长整型：' , num1
num2=1234498989237L
print 'python2的长整型：',num2
num3=0xDEFABCECBDAECBFBAEl
print 'python2的长整型：',num3
num4=32.3e+18
print 'python2的浮点数：' ,num4
num5 = 9.322e-36j
print 'python2的复数：',num5
num6=complex(4,56)
print 'python2的复数：',num6
num7=23l + 34j
print 'python2的复数：',num7
结果：
python2的长整型： -103203
python2的长整型： 1234498989237
python2的长整型： 4113244760468049623982
python2的浮点数： 3.23e+19
python2的复数： 9.322e-36j
python2的复数： (4+56j)
python2的复数： (23+34j)
1.2 Python3 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
# 这是int num1 = 123 num2 = -123445678123430 print (num1,num2) # 这是浮点型 num3 = 32.3 num4 = 23.12345678 print (num3,num4) # 这是复数型 num5 = complex(234,67) num6 = 34-3.5j num7 = -.6545+0J print(num5,num6,num7)
结果如下：
123 -123445678123430
32.3 23.12345678
(234+67j) (34-3.5j) (-0.6545+0j)
1.3 数值类型的类型转换
1.3.1 python2系列的类型转换
| 函数 | 描述 |
|---|---|
| int(x [,base]) | 将x转换为一个整数 |
| long(x [,base] ) | 将x转换为一个长整数 |
| float(x) | 将x转换到一个浮点数 |
1.3.2 python3系列的类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
2、字符串String
python的字符串类型包括java中的字符char和字符串类型String。用单引号或者双引号括起来。
字符串或串(String)是由数字、字母、下划线组成的一串字符。
它是编程语言中表示文本的数据类型。
Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串。
2.1 访问字符串的值
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
加号（+）是字符串连接运算符，星号（*）是重复操作。
#创建字符串
str = 'hello python!'
print ('输出完整字符串',str) # 输出完整字符串
print ('输出字符串中的第一个字符',str[0]) # 输出字符串中的第一个字符
print ('输出字符串中第三个至第五个之间的字符串',str[2:5]) # 输出字符串中第三个至第五个之间的字符串
print ('输出从第三个字符开始的字符串',str[2:])# 输出从第三个字符开始的字符串
print ('输出从第三个字符之前的字符串',str[:2])# 输出从第三个字符之后的字符串
print (str * 2) # 输出字符串两次
print (str + "TEST") # 输出连接的字符串
print('倒数第2个字符',str[-2])
print('输出倒数第二个字符之后的字符',str[-2:])
print('输出倒数第二个字符之前的字符',str[:-2])
结果：
输出完整字符串 hello python!
输出字符串中的第一个字符 h
输出字符串中第三个至第五个之间的字符串 llo
输出从第三个字符开始的字符串 llo python!
输出从第三个字符之前的字符串 he
hello python!hello python!
hello python!TEST
倒数第2个字符 n
输出倒数第二个字符之后的字符 n!
输出倒数第二个字符之前的字符 hello pytho
2.2 转义字符
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
2.3Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | >>>a + b 'HelloPython' |
| * | 重复输出字符串 | >>>a * 2 'HelloHello' |
| [] | 通过索引获取字符串中字符 | >>>a[1] 'e' |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] 'ell' |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>"H" in a True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >>>"M" not in a True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | >>>print r'\n' \n >>> print R'\n' \n |
a = "Hello"
b = "Python"
print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]
if( "H" in a) :
print "H 在变量 a 中"
else :
print "H 不在变量 a 中"
if( "M" not in a) :
print "M 不在变量 a 中"
else :
print "M 在变量 a 中"
print r'\n'
print R'\n'
以上程序执行结果为：
a + b 输出结果： HelloPython a * 2 输出结果： HelloHello a[1] 输出结果： e a[1:4] 输出结果： ell H 在变量 a 中 M 不在变量 a 中 \n \n
2.4Python字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
以上实例输出结果：
我叫 小明 今年 10 岁!
python字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
2.5 Python 的字符串内建函数
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize() |
| 2 | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
| 6 | endswith(suffix, beg=0, end=len(string)) |
| 7 | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| 11 | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 | 如果字符串只包含数字则返回 True 否则返回 False.. |
| 13 | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | 如果字符串中只包含空格，则返回 True，否则返回 False. |
| 16 | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | 返回字符串长度 |
| 20 | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | 转换字符串中所有大写字符为小写. |
| 22 | 截掉字符串左边的空格 |
| 23 | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | 返回字符串 str 中最大的字母。 |
| 25 | 返回字符串 str 中最小的字母。 |
| 26 | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | 删除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串 |
| 32 | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | 在字符串上执行 lstrip()和 rstrip() |
| 35 | 将字符串中大写转换为小写，小写转换为大写 |
| 36 | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | 转换字符串中的小写字母为大写 |
| 39 | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
3、列表（List）
类似与java中的数组，里面可以存储数字和字符串，并且一个列表中可以存储不同数据类型的值。索引值从0开始。
3.1 列表的声明和赋值
list_name=[value1,value2,value3...]
lis = [123,34.2,complex(23,45),'hello world!'] print(lis)
print(lis[1])#打印列表中第2个元素 print(lis[0:2])#打印前3个元素 print(lis[:2])#打印前3个元素 print(lis[1:])#打印从第2个开始后面的元素
结果：
[123, 34.2, (23+45j), 'hello world!']
34.2
[123, 34.2]
[123, 34.2]
[34.2, (23+45j), 'hello world!']
3.2 更新列表的值
对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项。
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
print('添加前列表的值:',list)
# 用append()方法添加列表元素
list.append(123)
print('添加后列表的值:',list)
结果：
第三个元素为 : 1997
更新后的第三个元素为 : 2001
添加前列表的值: ['Google', 'Runoob', 2001, 2000]
添加后列表的值: ['Google', 'Runoob', 2001, 2000, 123]
3.3删除列表的元素
可以使用 del 语句来删除列表的的元素。
list = ['Google', 'Runoob', 1997, 2000]
print (list)
del list[2]
print ("删除第三个元素 : ", list)
del list
print ('删除列表：',list )
结果：
删除第三个元素 : ['Google', 'Runoob', 2000]
删除列表： <class 'list'>
3.4嵌套列表
使用嵌套列表即在列表里创建其它列表。参照多维数组，
a = [123,'hello python!',56,1] n = [2,3,4,'帅哥，美女'] b = [a,n] print(b) print(b[0]) print(b[1][3])
结果
[[123, 'hello python!', 56, 1], [2, 3, 4, '帅哥，美女']]
[123, 'hello python!', 56, 1]
帅哥，美女
3.5列表的函数或方法
| 序号 | 函数 |
|---|---|
| 1 | len(list) 列表元素个数 |
| 2 | max(list) 返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq) 将元组转换为列表 |
Python包含以下方法:
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort([func]) 对原列表进行排序 |
| 10 | list.clear() 清空列表 |
| 11 | list.copy() 复制列表 |
4、元组（tuple）
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
4.1创建元组
tuple_name=(val1,val2,val3,val3……)
创建空元组
tuple_name=()
创建只有一个值的元组,必须有逗号
tuple_name=(val1,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
tuple1=()
tuple2=(2,)
tuple3=(2)
tuple4=('hello','world','python','java',12390)
print('空元组：',tuple1)
print('只有一个值的元组：',tuple2)
print('只有一个值错误的声明不带逗号：',tuple3)
print("元组tuple4", tuple4)
print('tuple4中第四个元素java:',tuple4[3])#元组可以使用下标索引来访问元组中的值
print('tuple4前四个元素：',tuple4[:4])
print("tuple4后四位元素tuple[-4:]：",tuple[-4:])
print('tuple4第2个到第四个之间的元素：',tuple4[1:4])
结果：
空元组： ()
只有一个值的元组： (2,)
只有一个值错误的声明不带逗号： 2
元组tuple4 ('hello', 'world', 'python', 'java', 12390)
tuple4中第四个元素java: java
tuple4前四个元素： ('hello', 'world', 'python', 'java')
tuple4后四位元素tuple[-4:]： ('hello', 'world', 'python', '2017-8-7')
tuple4第2个到第四个之间的元素： ('world', 'python', 'java')
4.2修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
tuple4=('hello','world','python','java',12390)
tuple5=(12,56,78,'hadoop')
tuple6= tuple4+tuple5
print('用+拼接',tuple6)
tuple7= tuple4*3
print('重复元组',tuple7)
结果如下：
用+拼接 ('hello', 'world', 'python', 'java', 12390, 12, 56, 78, 'hadoop')
重复元组 ('hello', 'world', 'python', 'java', 12390, 'hello', 'world', 'python', 'java', 12390, 'hello', 'world', 'python', 'java', 12390)
4.3 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
tuple4=('hello','world','python','java',12390)
print(tuple4)
del tuple4
print('删除后的元组：')
结果如下：
('hello', 'world', 'python', 'java', 12390)
删除后的元组：
4.4 无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组。
print 'abc', -4.24e93, 18+6.6j, 'xyz'; x, y = 1, 2; print "Value of x , y : ", x,y;
以上实例运行结果：
abc -4.24e+93 (18+6.6j) xyz Value of x , y : 1 2
4.5元组的内置函数
Python元组包含了以下内置函数
| 序号 | 方法及描述 |
|---|---|
| 1 | cmp(tuple1, tuple2) 比较两个元组元素。 |
| 2 | len(tuple) 计算元组元素个数。 |
| 3 | max(tuple) 返回元组中元素最大值。 |
| 4 | min(tuple) 返回元组中元素最小值。 |
| 5 | tuple(seq) 将列表转换为元组。 |
5、字典（dictionary）
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 }; dict2 = { 'abc': 123, 98.6: 37 };
5.1访问字典里的值
把相应的键放入熟悉的方括弧
tuple4=('hello','world','python','java',12390)
tuple5=(12,56,78,'hadoop')
tuple = (1,2,3,4,'ok','hello','world','python','2017-8-7')
list = ['hello','world','python','2017-8-7',123]
str = 'sderfsdffsdfdsa'
dic2={'stri':str,'lis':list}
dic={'stri':str,'lis':list,'tuple4':tuple4,'tup':tuple,'t':tuple5,'x':123,'y':True,'dic2':dic2}
print('dic',dic)
print('''dic['stri']:''',dic['stri'])
print('''dic['t']:''',dic['t'])
结果如下：
dic {'stri': 'sderfsdffsdfdsa', 'lis': ['hello', 'world', 'python', '2017-8-7', 123], 'tuple4': ('hello', 'world', 'python', 'java', 12390), 'tup': (1, 2, 3, 4, 'ok', 'hello', 'world', 'python', '2017-8-7'), 't': (12, 56, 78, 'hadoop'), 'x': 123, 'y': True, 'dic2': {'stri': 'sderfsdffsdfdsa', 'lis': ['hello', 'world', 'python', '2017-8-7', 123]}}
dic['stri']: sderfsdffsdfdsa
dic['t']: (12, 56, 78, 'hadoop')
如果用字典里没有的键访问数据，会输出错误
KeyError：
5.2 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值。
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
以上实例输出结果：
dict['Age']: 8 dict['School']: DPS School
5.3删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令。
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name']; # 删除键是'Name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
但这会引发一个异常，因为用del后字典不再存在：
dict['Age']:
Traceback (most recent call last):
File "test.py", line 8, in <module>
print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable
5.4 字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。
5.5字典的内置函数
Python字典包含了以下内置函数：
| 序号 | 函数及描述 |
|---|---|
| 1 | cmp(dict1, dict2) 比较两个字典元素。 |
| 2 | len(dict) 计算字典元素个数，即键的总数。 |
| 3 | str(dict) 输出字典可打印的字符串表示。 |
| 4 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear() 删除字典内所有元素 |
| 2 | dict.copy() 返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq[, val])) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.has_key(key) 如果键在字典dict里返回true，否则返回false |
| 6 | dict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | dict.keys() 以列表返回一个字典所有的键 |
| 8 | dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | dict.values() 以列表返回字典中的所有值 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 随机返回并删除字典中的一对键和值。 |
6、集合（set）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else : print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
以上实例输出结果：
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
6181
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
