python学习 之 第一章 （简单例子与常用数据类型）

第一章 简单例子与常用数据类型

1.    程序入门必见的hello 程序

使用的IDE3.4 软件的编程，代码简单如下：

print(“hello aiyq195”)

执行的结果如下：

Python 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600 64 bit (AMD64)] on win32

Type "copyright", "credits" or "license()" for more information.

Python 3.4.4(v3.4.4:737efcadf5a6,2015年12月20日,20:20:57)(MSC v。在win32 1600 64位(AMD64)]输入“版权”、“信用”或“许可证()”的更多信息。

>>> print("hello aiyq195")

hello aiyq195

 

上面这个就简单的一句话，就可以显示出你要打印出的内容；

它不像c语言，需要定义什么头文件，也不需要定义什么主函数来，就这么简单的一句，print（“回显数据”）;而且句子后面也不用分号去分开；

就OK了；

 

1.1  输出函数 print()

在python 3 版本中，你可以在print 后面不跟（）。直接跟上你要输出的内容，但是在python中，你就需要在后面跟上()，但是，在python 2 你输入()也是没错的，所以，最好的就是直接跟上（）

例子：

Python 3.4版本：

>>> print("hello aiyq195")

hello aiyq195

>>> print "hello aiyq195"

SyntaxError: Missing parentheses in call to 'print'

 

Python 2.7版本：

aiyq195@aiyq195-virtual-machine:~$ python

Python 2.7.3 (default, Sep 26 2012, 21:53:58)

[GCC 4.7.2] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> print "hello world"

hello world

>>> print ("hello world")

hello world

看上面的内容就明白了，用print函数时，为了防止因为版本问题，直接使用print() 更好点；

 

1.2  输入函数 input()

input() 函数，是让用户可以输入自己想要输入的数据：

>>> name = input("what is your name? ")

what is your name?

aiyq195

>>> name

'aiyq195'

>>> cr = input("enter a number! ")

enter a number!

7

>>> cr

'7'

其中，还有一些内容，就是关于python 2 的版本中，还有一个输入函数raw_input()，其中的差距，看下面的内容：

http://www.cnblogs.com/aiyq195/p/6511139.html

 

但是，上面的两个函数，使用哪个，就需要自己在考虑在那个版本下执行了！

 

2.    常见的类型

Python 中类型很多，杂七杂八的类型，其中包括了：

a)         字符

b)         字符串

c)         布尔类型

d)         整数

e)         数字

f)          浮点数

g)         列表

h)         元组

i)           字典

j)           日期

在python中，没有声明这一个说法，他是直接定义，赋值成什么，他就是什么类型了；

下面开始简单整理一下上面的几种类型：

2.1      字符与字符串

如何在python中定义字符串

2.1.1 使用单引号（’）

使用单引号只能代表一些简单的字符串，如果其中含有一些特殊的符号时，会出现错误，如：

>>> str = 'nihao aiyq195'

>>> str

'nihao aiyq195'

>>> str = 'let's go'

SyntaxError: invalid syntax

2.1.2 使用双引号（”）

>>> str = "let's go"

>>> str

"let's go"

2.1.3 使用多引号（”””）

使用多引号，可以表示多行的字符串，也就是说，如果你想同时，显示多行的数据，那你就需要使用多引号来标注，如：

>>> str = """nihao aiyq195,

what is you ages!"

"""

>>> str

'nihao aiyq195, what is you ages!" '

其中的 就是代表的换行符！

2.1.4 字符串的函数

find 方法

find 方法可以在一个较长的字符串中查找子串，它返回子串所在位置的最左端索引，如果没有找到则返回-1。

>>> cr = "nihao aiyq195"

>>> cr.find("aiyq")

6

>>> list(cr)

['n', 'i', 'h', 'a', 'o', ' ', 'a', 'i', 'y', 'q', '1', '9', '5']

>>> cr[6:10]

'aiyq'

>>> cr

'nihao aiyq195'

>>> cr.find("nia")

-1

Join 方法

Join方法是非常重要的字符串方法，它是split方法的逆方法，用来连接序列中的元素；

但是，它有一个问题，就是它只能连接字符串，如果是数字不行；

>>> lis1 = ['1','2']

>>> lis2 = ['3','5']

>>> lis1.join(lis2)

Traceback (most recent call last):

  File "<pyshell#50>", line 1, in <module>

    lis1.join(lis2)

AttributeError: 'list' object has no attribute 'join'

>>> cr = "aiyq "

>>> cr1 = "185"

>>> cr.join(cr1)

'1aiyq 8aiyq 5'

>>> cr

'aiyq '

>>> cr1

'185'

>>> cr.join(cr1)

'1aiyq 8aiyq 5'

>>> cr2 = '+'

>>> cr2.join(cr)

'a+i+y+q+ '

其实，通过上面的内容，会发现，join是一个拼接字符的方法；

你如果想要实现一个字符来拼接另外一个字符串，可以使用它；

split方法

它是跟上面的join方法的相反方法，也就是说他是用来将字符串分隔成序列。

>>> cr

'aiyq195 aiyq195 aiyq195'

>>> cr.split('5')

['aiyq19', ' aiyq19', ' aiyq19', '']

>>> cr.split(' ')

['aiyq195', 'aiyq195', 'aiyq195']

lower 方法

lower方法返回字符串的小写字母：

>>> cr = "AIYQ195"

>>> cr.lower()

'aiyq195'

title 方法

title 方法会让你的字符串变成标题模式，会让你的子串头一个字母大写；

>>> cr.title()

'Aiyq195'

replace 方法

replace 方法返回某字符串的所有匹配项均被替换之后得到字符串；

>>> cr.replace('YQ','YQ ')

'AIYQ 195'

>>> cr = "aiyq195 aiyq195 aiyq195"

>>> cr.replace('yq','yq ')

'aiyq 195 aiyq 195 aiyq 195'

从上面可以看出，上面的内容是替换的全部符合要求的内容；

translate方法

translate 方法跟 replace 方法一样，可以替代字符串中的某些部分，但是和前者不同的是，translate方法只处理单个字符。他的优势在于可以同时进行多个替换，有些时候比replace效率高的多。

strip 方法

最常用的方法，去字符串两边的空格；

>>> cr = "  nihao  "

>>> cr.strip()

'nihao

2.2 布尔类型

布尔类型，就只包括两个值，一个为真 True,一个为假 False；

而且需要注意，上面两个单词，必须拼写正确，否则，他也是错误的；

例子如下：

>>> bool = 1

>>> bool

1

注意：不是你定义一个变量名为bool，你就是一个布尔值了；

>>> bool = false

Traceback (most recent call last):

  File "<pyshell#45>", line 1, in <module>

    bool = false

NameError: name 'false' is not defined

>>> bool = False

>>> bool

False

>>> bool = true

Traceback (most recent call last):

  File "<pyshell#48>", line 1, in <module>

    bool = true

NameError: name 'true' is not defined

>>> bool = True

>>> bool

True

注意：只有正确的拼写False，才能使用这个类型值；

2.3 整数、浮点数、数字

整数

>>> int = 20

>>> print(int)

20

浮点数

>>> float = 1.2

>>> print(float)

1.2

数字：

其实就是上面的综合，就是整数与浮点数。

其中涉及到数字的内容就有点多了：

2.3.1 数字类型转换

int( x ) 将x转换为一个整数

float( x ) 将x转换到一个浮点数

complex( real [,imag] ) 创建一个复数

str( x ) 将对象x转换为字符串

repr( x ) 将对象x转换为表达式字符串

eval( str ) 用来计算在字符串中的有效Python表达式,并返回一个对象

tuple( s ) 将序列s转换为一个元组

list( s ) 将序列s转换为一个列表

chr( x ) 将一个整数转换为一个字符

unichr( x ) 将一个整数转换为Unicode字符

ord( x ) 将一个字符转换为它的整数值

hex( x ) 将一个整数转换为一个十六进制字符串

oct( x ) 将一个整数转换为一个八进制字符串

2.3.2 数字函数

abs(x)    返回数字的绝对值，如abs(-10) 返回 10

ceil(x)    返回数字的上入整数，如math.ceil(4.1) 返回 5

cmp(x, y)  如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

exp(x)    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x)    返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4

log(x)    如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...)    返回给定参数的最大值，参数可以为序列。

min(x1, x2,...)    返回给定参数的最小值，参数可以为序列。

modf(x)    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x, y) x**y 运算后的值。

round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

sqrt(x)    返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

2.4 列表

列表，就是可以像一个链条一样的数据，他是一个连续的数据链；

2.4.1 初始化列表

list = [‘pyu’,’aiyq’,’wgj’,’yb’,2342,3432]

nums = [1,2,34,5,6,7,8,9]

2.4.2 元素

因为列表一般是一个包含多个数据的一个集合，所以，他的内部包含的每一个数据单元，我们给它起了一个名字，就叫做元素。

就如同我们将一个班级按照个子从低到高排序后的名字，放入了一个花名册中；

则这个花名册就是一个列表，则这个班级中的每个名字就是这个列表的元素；

如下：

>>> classlist = ['zhangsan','lisi','wangwu','zhaoliu','qianqi']

'zhangsan'其中的‘zhangsan’就代表了一个元素；

2.4.2 索引

因为列表是有序的，所以，就有了索引这个关键字；

索引，就是一个从0开始的指向值；

还拿班级那个例子，我们按照大小个子排的序；

排在第一位的我们算他的代号为0，后续加1，一直到n，

这样我们就知道了班级的人员个数就是（n+1）；

这样，我们就可以拿这个数字来代表我们的列表中的一个元素；

这时，classlist[0] 就能代表一个元素，‘zhangsan’

>>> classlist = ['zhangsan','lisi','wangwu','zhaoliu','qianqi']

>>> classlist[0]

'zhangsan'

2.4.3 更新列表元素

>>> classlist[0] = 'aiyq195'

>>> classlist[0]

'aiyq195'

2.4.4 删除列表元素

>>> classlist

['aiyq195', 'lisi', 'wangwu', 'zhaoliu', 'qianqi']

>>> del classlist[0]

>>> classlist

['lisi', 'wangwu', 'zhaoliu', 'qianqi']

del 命令可以删除列表元素，而且这时，你删除的列表原来的位置后的元素会将索引都会往前提一位，也就是说，这时候，原来的n[1] 变成了n[0]。

>>> classlist[0]

'lisi'

2.4.5 对整个列表的操作

针对列表的操作，简单的介绍下+ 和 * 两个操作符；

其中 + 号操作符，会将两个列表内的数据相加，串到一起；

例子如下：

>>> nums = [1,2,3,4,5,6,7]

>>> classlist

['lisi', 'wangwu', 'zhaoliu', 'qianqi']

>>> nums + classlist

[1, 2, 3, 4, 5, 6, 7, 'lisi', 'wangwu', 'zhaoliu', 'qianqi']

>>> classlist + nums

['lisi', 'wangwu', 'zhaoliu', 'qianqi', 1, 2, 3, 4, 5, 6, 7]

>>> nr = nums + classlist

>>> nr

[1, 2, 3, 4, 5, 6, 7, 'lisi', 'wangwu', 'zhaoliu', 'qianqi']

上面的数据说明了，两个列表可以直接使用 + 号，让列表按照顺序组成一个新的列表；而且列表内的数据，不会因为新建而重新排序；

而 * 号操作符，是相当于个乘号，将你列表中的元素按照原来的顺序，翻几倍的个数，

它不会跟元素有什么关联，它只会将你元素个数变化，

就如同你的列表nums，它就7个元素，当我们使用 * 号操作符了；它的元素个数就会变成21个了；

>>> len(nums)

7

>>> len(nums*3)

21

>>> nums * 3

[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]

>>> nr * 2

[1, 2, 3, 4, 5, 6, 7, 'lisi', 'wangwu', 'zhaoliu', 'qianqi', 1, 2, 3, 4, 5, 6, 7, 'lisi', 'wangwu', 'zhaoliu', 'qianqi']

>>> nums * r

Traceback (most recent call last):

  File "<pyshell#78>", line 1, in <module>

    nums * r

NameError: name 'r' is not defined

注意，这个　* 操作符后续跟的只能是数字，不能是字符；

2.4.6 判断数据是否存在该列表中

In 关键字，可以让我们判断一个列表中的元素是否包括我们想要的数据；

如：

>>> lisi in classlist

Traceback (most recent call last):

  File "<pyshell#82>", line 1, in <module>

    li in classlist

NameError: name 'li' is not defined

>>> 'lisi' in classlist

True

>>> classlist

['lisi', 'wangwu', 'zhaoliu', 'qianqi']

>>> 'aiyq195' in classlist

False

这时候，返回的就是一个布尔值了，如果存在，就返回True，否则返回False；

而且，你也的确认你输入的数据是否真的跟你的列表元素一样，才能查询成功；

2.4.7 列表截取(也就是分片)

列表的截取，就是你将列表内的部分数据取出来；

>>> nums

[1, 2, 3, 4, 5, 6, 7]

>>> nums[2]

3

>>> nums[2:4]

[3, 4]

>>> nums[2:6]

[3, 4, 5, 6]

>>> nums[-1]

7

>>> nums[-1:-4]

[]

>>> nums[-1:4]

[]

>>> nums[-2]

6

>>> nums[-4:-1]

[4, 5, 6]

上面的内容说明了一些内容，列表的截取，需要的是，你将里面的内容，按照索引将其截取；

就是，你想截取那几个元素区间，你就将其开始索引值到结束索引值，用：号连接到一起，就可以获取到你想要的区间列表元素值。

2.4.8 列表常用函数与方法

list.append(obj) 在列表末尾添加新的对象

>>> tup1

[1, 2, 3]

>>> tup1.append(3)

>>> tup1

[1, 2, 3, 3]

 

list.count(obj) 统计某个元素在列表中出现的次数

>>> tup1.count(3)

2

 

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

 

>>> tup1

[1, 2, 3, 3]

>>> tup2

[1, 2, 3]

>>> tup2.extend(tup1)

>>> tup2

[1, 2, 3, 1, 2, 3, 3]

 

list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始

list.insert(index, obj) 将对象插入列表

>>> nums.insert(0,9)

>>> nums

[9, 1, 2, 3, 4, 5, 6, 7]

>>> nums.insert(0,8)

>>> nums

[8, 9, 1, 2, 3, 4, 5, 6, 7]

 

list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

 

list.remove(obj) 移除列表中某个值的第一个匹配项

>>> tup2

[3, 3, 3, 2, 2, 1, 1]

>>> tup2.remove(2)

>>> tup2

[3, 3, 3, 2, 1, 1]

list.reverse() 反向列表中元素，倒转

>>> tup2.reverse()

>>> tup2

[3, 3, 3, 2, 2, 1, 1]

list.sort([func]) 对原列表进行排序

>>> tup2

[1, 2, 3, 1, 2, 3, 3]

>>> tup2.sort()

>>> tup2

[1, 1, 2, 2, 3, 3, 3]

 

上面函数的调用过程：

>>> tup1 = [1,2,3]

>>> tup2 = [1,2,3]

列表的比较：

>>> tup1 == tup2

True

列表的长度：

>>> len(tup1)

3

列表与元组的互相替换，list 列表，tuple 元组

>>> tuple(tup2)

(3, 3, 3, 2, 1, 1)

>>> list(tup2)

[3, 3, 3, 2, 1, 1]

2.5元组（tuple）

Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，例如：

tup1 = ('physics', 'chemistry', 1997, 2000)

tup2 = (1, 2, 3, 4, 5 )

tup3 = "a", "b", "c", "d"

创建空元组，例如：tup = ();

元组中只有一个元素时，需要在元素后面添加逗号，例如：tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

2.5.1 访问元组

如同列表一样，元祖也是由各个元素组成，需要查看那个元素，我们也是使用元组的索引来查看；

查看单个元素

>>> tup2 = (1, 2, 3, 4, 5 )

>>> tup2[2]

3

         查看元组区间元素

 >>> tup2[0:4]

(1, 2, 3, 4)

2.5.2 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:
>>> tup1 = (12,32,43)

>>> tup2 = ('abc','efg')

>>> tup1[0] = 100

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

>>> tup3 = tup1 + tup2

>>> tup3

(12, 32, 43, 'abc', 'efg')

2.5.3 删除元组

元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:

>>> del tup3[3]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object doesn't support item deletion

>>> del tup3

>>> tup3

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'tup3' is not defined

2.5.4 元组运算符

元组运算符跟列表的一样，也是有 + 与 * ，还有一个关键字in；判断元素是否存在元组中；

>>> tup1 = (1,2,3)

>>> tup2 = (3,4,5)

>>> tup1 + tup2

(1, 2, 3, 3, 4, 5)

>>> tup1 * r

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'r' is not defined

>>> tup1 * 2

(1, 2, 3, 1, 2, 3)

>>> 2 in tup1

True

>>> 2 in tup2

False

2.5.5 元组关联函数

cmp(tuple1, tuple2) 比较两个元组元素。

len(tuple) 计算元组元素个数。

max(tuple) 返回元组中元素最大值。

min(tuple) 返回元组中元素最小值。

>>> min(list)

1

tuple(seq) 将列表转换为元组。

>>> list = [1,2,3]

>>> tuple(list)

(1, 2, 3)

2.6 字典

2.6.1 字典简介

字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};

也可如此创建字典：

dict1 = { 'abc': 456 };

dict2 = { 'abc': 123, 98.6: 37 };

每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

2.6.2 访问字典

>>> dict = {'aiyq195':195,'wangguojun',176,'yubin',179}

  File "<stdin>", line 1

    dict = {'aiyq195':195,'wangguojun',176,'yubin',179}

                                      ^

SyntaxError: invalid syntax

>>> dict = {'aiyq195':195 ,'wangguojun':179,'yubin':180}

>>> dict[0]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 0

>>> dict

{'aiyq195': 195, 'wangguojun': 179, 'yubin': 180}

>>> dict['aiyq195']

195

>>> dict[195]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 195

从上面可以看出，字典的查看方式，他没有索引，所以，无法想列表跟元组那样使用索引查看元素，

而且他只能使用键（key）去查看字典内的元素；

2.6.3 修改字典

>>> dict

{'aiyq195': 195, 'wangguojun': 179, 'yubin': 180}

>>> dict['aiyq195'] = 200

>>> dict

{'aiyq195': 200, 'wangguojun': 179, 'yubin': 180}

>>> dict['caidongxu'] = 180

>>> dict

{'aiyq195': 200, 'wangguojun': 179, 'yubin': 180, 'caidongxu': 180}

通过上面的例子，可以查看到如何修改字典内的元素，也包括了如果你修改的键不存在，它会直接新增该元素；

2.6.4 删除字典

>>> del dict['caidongxu']

>>> dict

{'aiyq195': 200, 'wangguojun': 179, 'yubin': 180}

>>> dict.clear

<built-in method clear of dict object at 0xb691968c>

>>> dict

{'aiyq195': 200, 'wangguojun': 179, 'yubin': 180}

>>> dict.clear()

>>> dict

{}

>>> del dict

>>> dict

<type 'dict'>

通过上面可以知道：

del dict['name']; # 删除键是'name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典

2.6.5 字典函数

clear 方法

clear方法清除字典中所有的元素，这是个原地操作，没有返回值（或者说返回值为None），

>>> dic1 = { 'name':'aiyq195','age':28,'sex':'men'}

>>> dic1.clear

<built-in method clear of dict object at 0x000000000358C888>

>>> dic1.clear()

>>> dic1

{}

从上面可以看出，clear是一个函数，我们需要使用clear() 才能调用到它，

然后它会直接将内部的元素给清空，但是并没有删除掉字典；

len 方法

len(dict) 计算字典元素个数，即键的总数。

>>> len(dic2)

0

str 方法

str(dict) 输出字典可打印的字符串表示。

>>> str(dict)

"{'aiyq195': 200, 'wangguojun': 179, 'yubin': 180}"

type 方法

type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

>>> type(dict)

<type 'dict'>

copy 方法

copy() 返回一个字典的浅复制

也就是使用copy方法后，会返回一个具有想听键-值的新字典。

>>> dic1 = { 'name':'aiyq195','age':28,'sex':'men'}

>>> dic2 = dic1.copy()

>>> dic2

{'name': 'aiyq195', 'age': 28, 'sex': 'men'}

>>> dic1

{'name': 'aiyq195', 'sex': 'men', 'age': 28}

>>> dic2['name'] = 'aiyq'

>>> dic2

{'name': 'aiyq', 'age': 28, 'sex': 'men'}

>>> dic1

{'name': 'aiyq195', 'sex': 'men', 'age': 28}

>>> dic2.clear()

>>> dic2

{}

>>> dic1

{'name': 'aiyq195', 'sex': 'men', 'age': 28}

上面的内容显示的是数据不变的；就是你删除了复制的副本的时候，但是下面的内容

>>> dic1 = {'name':'aiyq195','fr': ['one','two'] }

>>> dic1

{'name': 'aiyq195', 'fr': ['one', 'two']}

>>> dic2 = dic1.copy()

>>> dic2

{'name': 'aiyq195', 'fr': ['one', 'two']}

>>> dic2['fr'].remove('two')

>>> dic1

{'name': 'aiyq195', 'fr': ['one']}

>>> dic2

{'name': 'aiyq195', 'fr': ['one']}

上面的内容说明了有些内容，你修改了，它是没有变化的，但是有些修改了他是会改变的；

所以，我们需要判断，如果我们这里想要一个不会改变的复制，就需要使用deepcopy方法；

>>> dic2 = dic1.copy()

>>> dic1

{'name': 'aiyq195', 'fr': ['one']}

>>> dic2

{'name': 'aiyq195', 'fr': ['one']}

>>> from copy import deepcopy

>>> dic1

{'name': 'aiyq195', 'fr': ['one']}

>>> dic3 = deepcopy(dic1)

>>> dic3

{'name': 'aiyq195', 'fr': ['one']}

>>> dic2['fr'].append('two')

>>> dic1

{'name': 'aiyq195', 'fr': ['one', 'two']}

>>> dic2

{'name': 'aiyq195', 'fr': ['one', 'two']}

>>> dic3

{'name': 'aiyq195', 'fr': ['one']}

items 方法

dict.items() 以列表返回可遍历的(键, 值) 元组数组

>>> dict.items()

[('aiyq195', 200), ('wangguojun', 179), ('yubin', 180)]

>>> dict.has_key('aiyq195')

True

keys 方法

dict.keys() 以列表返回一个字典所有的键

>>> dict.keys()

['aiyq195', 'wangguojun', 'yubin']

get 方法

dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

>>> d = {}

>>> type(d)

<class 'dict'>

>>> d.get('name')

>>> print d.get('name')

SyntaxError: invalid syntax

>>> print( d.get('name') )

None

>>> print(d['name'])

Traceback (most recent call last):

  File "<pyshell#12>", line 1, in <module>

    print(d['name'])

KeyError: 'name'

如果你直接使用字典的子项，你会发现出错，但是你使用get 方法后，会发现，如果没有该元素，它会返回None，而不是直接报错，所以，get是你做校验时，可以考虑的选择；

dict.fromkeys 方法

fromkeys方法使用给定的键简历新的字典，每个键都对应一个默认的值None；

>>> dict.fromkeys(['name','age'])

{'name': None, 'age': None}

当然，也可以使用一个自己定义的默认值；

格式如下：

>>> dict.fromkeys(['name','age'],'(aiyq195)')

{'name': '(aiyq195)', 'age': '(aiyq195)'}

radiansdict.has_key(key) 如果键在字典dict里返回true，否则返回false

还有一些，可以自行查看一下：

radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里

radiansdict.values() 以列表返回字典中的所有值