python学习笔记2—python文件
python学习笔记2——Python文件类型、变量、数值、字符串、元组、列表、字典
一、Python文件类型
1、源代码
python源代码文件以.py为扩展名，由pyton程序解释，不需要编译
[root@localhost day01]# vim 1.py
#!/usr/bin/python
print 'hello world!'
[root@localhost day01]# python 1.py
hello world!2、字节代码
Python源码文件经过编译后生成的扩展名为‘pyc’的文件
编译方法：
import py_compile
py_compile.compile('hello.py')
[amos@AAC-DMP-03 amos]$ vim 2.py
#!/usr/bin/pyton
import py_compile
py_compile.compile('./1.py')
[root@localhost day01]# vim 2.py
#!/usr/bin/python
import py_compile
py_compile.compile('1.py')
[root@localhost day01]# python 2.py
[root@localhost day01]# ls
1.py 1.pyc 2.py
[root@localhost day01]# python 1.pyc
hello world!3、优化代码
经过优化的源码文件，扩展名为“pyo”
-python -O -m py_compile hello.py
[root@localhost day01]# python -O -m py_compile 1.py
[root@localhost day01]# ll
total 16
-rw-r--r--. 1 root root 41 Feb 21 17:55 1.py
-rw-r--r--. 1 root root 113 Feb 21 17:56 1.pyc
-rw-r--r--. 1 root root 113 Feb 21 18:15 1.pyo
-rw-r--r--. 1 root root 67 Feb 21 17:56 2.py
[root@localhost day01]# python 1.pyo
hello world!二、Python变量
变量是计算机内存中的一块区域，变量可以存储规定范围内的值，而且值可以改变。
python下变量是对一个数据的引用
python是指向内存的另外一块区域，而C语言是对内存的一块区域的值重新赋值
变量的命名
变量名由字母、数字、下划线组成
不能以数字开头
不可以使用关键字
-a a1 _a
变量的赋值
是变量的申明和定义的过程
a = 1
id(a) //发现从新赋值a之后，变量a在内存中的地址从7601952变化为16579968
[root@localhost day01]# ipython
Python 2.6.6 (r266:84292, Jul 23 2015, 15:22:56)
Type "copyright", "credits" or "license" for more infORMation.
IPython 1.2.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.
In [1]: a=123
In [2]: print a
123
In [3]: id(a)
Out[3]: 7601952
In [4]: id(a)
Out[4]: 7601952
In [5]: a = 456
In [6]: id(a)
Out[6]: 16579968三、Python中的运算符与表达式
Python的运算符包括
赋值运算符 x = 3，y = 'abcd' *= /= %= x+=2 x=x+2 x-=2 x=x-2
算数运算符 + - * / % // **
关系运算符 > < >= <= == != 返回结果是bool值true或者false
逻辑运算符 and逻辑与：true and false or逻辑或false or true not逻辑非not true
定义变量不需要申明字符类型
In [17]: x=2
In [18]: type(x)
Out[18]: int
In [19]: x='david'
In [20]: type(x)
Out[20]: str算数运算符真是简洁明了4.00 // 3=1.0表示取整，3**2=9 表示3的平方
In [29]: 'a' +'b'
Out[29]: 'ab'
In [30]: 3-4
Out[30]: -1
In [31]: 3*2
Out[31]: 6
In [32]: 4/3
Out[32]: 1
In [33]: 4.0 /3
Out[33]: 1.3333333333333333
In [34]: 4.0 // 3
Out[34]: 1.0
In [35]: 4.00 // 3
Out[35]: 1.0
In [36]: 4%3
Out[36]: 1
In [37]: 2**3
Out[37]: 8
In [38]: 3**2
Out[38]: 9关系运算符
In [39]: 1>2
Out[39]: False
In [40]: 1<9
Out[40]: True
In [41]: 1!=9
Out[41]: True逻辑运算符
In [42]: 1==1 and 2>1
Out[42]: True
In [43]: 1==1 and 2<1
Out[43]: False
In [44]: 1==1 or 2<1
Out[44]: True
In [45]: not 1==2
Out[45]: TrueLambda(从上到下，优先级越来越高，同行右侧优先级更高）
逻辑运算：or
逻辑运算： and
逻辑运算：not
成员测试：in，not in
同一性测试：is，is not
比较：<，<=，>，=>，!=，==
按位或：|
按位异或：^
按位与： &
移位：<<,>>
加法与减法:+,-
乘法与除法和取余：*，/，%
正负号:+x,-x
按位翻转：~x
指数：**
例子：写一个四则运算器
要求从键盘读取数字
[root@localhost day01]# vim 3.py
#!/usr/bin/python
num1=input('Please input a number')
num2=input('Please input a number')
print "%s+%s=%s" %(num1,num2,num1+num2)
print "%s-%s=%s" %(num1,num2,num1-num2)
print "%s*%s=%s" %(num1,num2,num1*num2)
print "%s/%s=%s" %(num1,num2,num1/num2)
[root@localhost day01]# python 3.py
Please input a number2
Please input a number3
2+3=5
2-3=-1
2*3=6
2/3=0input()与raw_input()去别：
input() 接受数字和字符串
raw_input()全部解析为字符串
In [47]: input ("Please input: ")
Please input: 123
Out[47]: 123
In [48]: input ("Please input: ")
Please input: abc #这里报错，input输入字符串必须加'abc'引号，否则识别不了
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-48-ae0272fccd43> in <module>()
----> 1 input ("Please input: ")
<string> in <module>()
NameError: name 'abc' is not defined
In [49]: input ("Please input: ")
Please input: 'abc'
Out[49]: 'abc'
In [50]: input ("Please input: ")
Please input: 6789
Out[50]: 6789
In [51]: raw_input ("Please input: ")
Please input: sdfsahfha
Out[51]: 'sdfsahfha'
In [52]: 234
Out[52]: 234
In [53]: raw_input ("Please input: ")
Please input: 3242
Out[53]: '3242'
In [54]: raw_input ("Please input: ")
Please input: abc
Out[54]: 'abc'四、Python数据类型
数值 ×××int 长×××long 浮点型float（3e+4=3*10^4=30000.0）复数4-3.14j In [4]: type(3.14j)Out[4]:complex ，complex表示复数类型
序列 包括：字符串、列表、元祖，主要操作是索引操作符和切片操作符，
索引操作符让我从序列中抓取一个特定项目，
切片操作符让我们能够获取序列的一个切片，即获取一部分
序列的基本操作：
1、len() 求序列的长度
2、+ 连接2个序列
3、* 重复序列元素
4、in 判断元素是否在序列中
5、max() 返回最大值
6、min（） 返回最小值
7、com(x,y)比较两个序列是否相等
字符串 引号表示‘’，三种方法定义字符串，str='this is a string' str="s is a string"
str='''this is a string''' 三重引号（docstring）能定义字符串外，还可以用作注释\'
元组 小括号表示（）元组是不可变类型数据，元祖和列表十分相识，但是元组和字符串一样，
值不可变，不能重新赋值，元组可以存一系列的值，可以索引和切片
元组在用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变
创建元组： t= ('a',123,'12',('df',2))
In [5]: t
Out[5]: ('a', 123, '12', ('df', 2))
列表 列表是可变类型的数据
列表是处理一组有序项目的数据结构，即可在列表中存储一个序列的项目
创建列表:
list1=[]
list2=list()
list3=['a',1,2]
列表操作：取值，切片和索引
添加： list.append()
删除list元素，list3.remove(value) 删除list3的元素value，
value=1，‘a’，list3[0]都可以，只要是这个value的值是list3的子集就可以
删除list：del list1
修改：list[]=x
查找：var in list
字典 字典是python中的唯一的映射类型（哈希表）
字典对象是可变的，但字典的键必须使用不可变对象，一个字典中可以使用不同类型的键值
字典的使用方法：
key() values() items()
创建字典：
dic={ }
dic=dict() #工厂函数创建字典
help(dict)
dict((['a',1],['b',2]))
dict(a=1,b=2) #添加选项，传参数
dict([('a',10),('b',20)]) #可迭代的对象，内部是列表或元组被传入字典
fromekeys(),字典元素有相同的值，默认为None
访问字典：
dic
dic1["a"] #a是key
dic1.items()# 返回时一个列表，把字典张的key和value变成一个元组里面的两个元素，保存到一个列表
字符串的切片操作：
In [42]: a='abcde'
In [43]: a
Out[43]: 'abcde'
In [44]: a[0]
Out[44]: 'a'
In [45]: a[1]
Out[45]: 'b'
In [46]: a[4]
Out[46]: 'e'
In [47]: a[-1]
Out[47]: 'e'
In [48]: a[0]+a[1]
Out[48]: 'ab'
In [49]: a[0:2] #取值下标注0和1，不包括最后一个2
Out[49]: 'ab'
In [50]: a[:2]
Out[50]: 'ab'
In [51]: a[1:2]
Out[51]: 'b'
In [52]: a[1:]
Out[52]: 'bcde'
In [53]: a[:]
Out[53]: 'abcde'
In [54]: a[-1]
Out[54]: 'e'
In [55]: a[:-1] #从头开始，不包括最后一个-1对应的e
Out[55]: 'abcd'
In [56]: a[::1]
Out[56]: 'abcde'
In [57]: a[::2]#步进值为2
Out[57]: 'ace'
In [58]: a[::-1]#步进值-1，从后向前取值
Out[58]: 'edcba'
In [59]: a[::-2]
Out[59]: 'eca'
In [61]: a
Out[61]: 'abcde'
In [60]: a[-4:-2]
Out[60]: 'bc'
In [62]: a[-2:-4:-1] 从右到左，-2 d -3c -4b不取值，-1表示从右到左
Out[62]: 'dc'
#字符串格式化，我们用%实现，%s表示是字符类型，%.2f 表示只显示小数点后面2位，%x表示十六进制，%o表示八进制，%f默认显示小数点6位
>>> a=1.23456
>>> print "a=%s" % a
a=1.23456
>>> print "a=%.2f" % a
a=1.23
>>> print "a=%.8f" % a
a=1.23456000
#find
>>> s
'aminglinux'
>>> s.find('a')
0
>>> s.find('i')
2
#说明，find可以返回字符或子符串在整个字符串中的位置，如果有多个，只显示第一个字符或者字符串的首字符所在位置。如果不匹配，则返回-1.
>>> s1="My domain is www.aminglinux.com"
>>> s1.find('is')
10
>>> s1.find('iss')
-1
#另外，也可以在小括号里面指定两个参数，用来指定查找字符串的起始点和结束点。如果只写一个参数，则结束点就是字符串结尾。
>>> s1.find('www',2)
13
>>> s1.find('www',2,12)
-1
#说明，在字符串的2至12个中去查找是否有'www'字符串，结果是-1，因为'www'是从13开始的
#lower返回字符串的小写形式
>>> a='AmingLinux'
>>> a.lower()
'aminglinux'
#replace，替换指定字符串
>>> b='aminglinux.net'
>>> b.replace('net','com')
'aminglinux.com'
#join在字符串或者序列中定义一个连接符，把所有元素连起来，说明，f为连接符号，这样就可以在所有字符串中间用+连接起来。另外列表或元组也是可以做到的。
>>> name='aming'
>>> f='+'
>>> f.join(name)
'a+m+i+n+g'
>>> l=['a','b','c']
>>> f=':'
>>> f.join(l)
'a:b:c'
>>> l=('a','b','c')
>>> f='++'
>>> f.join(l)
'a++b++c'
#split，和join正好相反，使用指定分隔符切割字符串
>>> c='1+2+3+4+5'
>>> c.split('+')
['1', '2', '3', '4', '5']
它返回的是一个列表。
#strip，去掉字符串两边多余的空白字符，有时候我们输入一个字符串经常会无意中多加一个或多个空格，这个方法就起到作用了。
>>> e=' aaaa bbb '
>>> e
' aaaa bbb '
>>> e.strip()
'aaaa bbb'序列操作：
In [74]: a=12 #12*2=24，因为a的值是×××12
In [75]: a*2
Out[75]: 24
In [72]: a='12345' *符号表示重复序列元素，因为a是字符串
In [73]: a*2
Out[73]: '1234512345'
In [77]: '#'*50
Out[77]: '##################################################'
In [78]: a=123
In [79]: a+4
Out[79]: 127
In [82]: a = 'abc'
In [83]: a in a 'a' in 'abc' 判断元素是否在序列中
Out[83]: True
In [85]: 'f' in a
Out[85]: False
In [86]: 'f' not in a
Out[86]: True
In [104]: 'a' in 'abc'
Out[104]: True
In [107]: a in 'abcde'
Out[107]: True
In [105]: a in 'abc' 注意：'a'表示字符a，a表示字符串abc，abc 不是abd的子集，abc是abcde子集
Out[105]: True
In [106]: a in 'abd'
Out[106]: False
In [90]: a
Out[90]: 'abc'
In [91]: max(a) #返回最大值
Out[91]: 'c'
In [92]: min(a) #返回最小值
Out[92]: 'a'
#com(x,y)比较两个序列是否相等
In [94]: help(cmp) #查看cmp比较命令
Help on built-in function cmp in module __builtin__:
cmp(...)
cmp(x, y) -> integer
Return negative if x<y, zero if x==y, positive if x>y.
In [96]: cmp(a,'abc')
Out[96]: 0 #返回0表示 a='abc'
In [97]: cmp(a,'abcd') #返回-1表示 a<'abcd'
Out[97]: -1
In [98]: cmp(a,'ab') #返回1表示 a>'ab'
Out[98]: 1元组定义（通常用于接收函数的返回值）、元组的拆分
In [6]: tuple3=tuple()
In [7]: type(tuple3)
Out[7]: tuple
In [107]: t=('a',1,(1,))
In [108]: t
Out[108]: ('a', 1, (1,))
In [116]: type(t)
Out[116]: tuple
In [118]: t1=(1) #默认定义（1）为int，（1，）定义为元组tuple
In [119]: type(t1)
Out[119]: int
In [120]: t2=(1,)
In [121]: type(t2)
Out[121]: tuple
In [122]: t3=(1,t2)
In [123]: t3
Out[123]: (1, (1,))
#元组的拆分，接收元组的值
In [127]: t4=(a,'b','c') #a表示变量a
In [128]: t4
Out[128]: ('abcd', 'b', 'c')
In [129]: first,second,third=t4
In [130]: first
Out[130]: 'abcd'
In [131]: second
Out[131]: 'b'
In [132]: third
Out[132]: 'c'
In [142]: t4.count('abcd') #a='abcd' 返回abcd这个字符串出现的次数1
Out[142]: 1
In [144]: t4.count(a)
Out[144]: 1
In [143]: t4.count('a')
Out[143]: 0
In [31]: t4=(a,'b','c','b') #返回d这个字符串出现的次数2
In [32]: t4.count('b')
Out[32]: 2
Out[155]: ('abcd', 'b', 'c', 'b')
In [156]: t4.index('b') #显示第一个b的位置
Out[156]: 1
In [157]: t4.index('c')
Out[157]: 2列表
In [2]: list1=[] #定义空列表
In [3]: type(list1)
Out[3]: list
In [4]: list2=list() #定义空列表
In [5]: type(list2)
Out[5]: list
In [6]: list2
Out[6]: []
In [7]: list3=['a',1,(1,),['hello','python']]#定义列表，内容可以×××、字符串、元组、列表
In [8]: list3
Out[8]: ['a', 1, (1,), ['hello', 'python']]
In [9]: len(list3)
Out[9]: 4
In [10]: list3[0]
Out[10]: 'a'
In [11]: list3[0]='b' #列表的值可以改变，重新赋值
In [12]: list3[0]
Out[12]: 'b'
In [13]: list3
Out[13]: ['b', 1, (1,), ['hello', 'python']]
In [14]: list2
Out[14]: []
In [15]: list2.append('linux') #使用list.append('value')添加list的值
In [17]: list2
Out[17]: ['linux']
In [18]: list3+list2 #可以让两个list相加，组合成一个大列表
Out[18]: ['b', 1, (1,), ['hello', 'python'], 'linux']
In [19]: (list3+list2)*2 #重复列表
Out[19]:
['b',
1,
(1,),
['hello', 'python'],
'linux',
'b',
1,
(1,),
['hello', 'python'],
'linux']
In [20]: list3
Out[20]: ['b', 1, (1,), ['hello', 'python']]
In [21]: del list3[-1] #del list3[-1] 删除list3中的最后一个元素
In [22]: list3
Out[22]: ['b', 1, (1,)]
In [23]: list2
Out[23]: ['linux']
In [24]: del list2 #del list2直接删除list2
In [25]: list2 #list2被删除，list2查看，已经不存在
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-25-db9b7629a516> in <module>()
----> 1 list2
NameError: name 'list2' is not defined
In [28]: list3
Out[28]: ['b', 1, (1,)]
In [29]: list3.append(1)
In [30]: list3
Out[30]: ['b', 1, (1,), 1]
In [31]: list3.remove(1) #使用list3.remove()删除第一次出现的1，从左向右
In [32]: list3
Out[32]: ['b', (1,), 1]
In [38]: 'a' in list3 #使用'a' in list3判断是否包含字符a，不包含是false，包含为true
Out[38]: False
In [39]: 'b' in list3
Out[39]: True
In [43]: help(list.insert)
insert(...)
L.insert(index, object) -- insert object before index
In [45]: list1=list()
In [46]: list1
Out[46]: []
In [47]: list3.insert(1,list1) #在list3的位置1处插入列表list1=[]
In [48]: list3
Out[48]: ['b', [], (1,), 1, 1]
In [55]: list3.sort() #list3.sort()排序
In [56]: list3
Out[56]: [1, 1, [], 'b', (1,)]
In [57]: list3.reverse() #list3.reverse()反转
In [58]: list3
Out[58]: [(1,), 'b', [], 1, 1]
In [60]: list3
Out[60]: [(1,), 'b', [], 1, 1]
In [61]: list3.pop() #list3.pop()默认删除最后一个
Out[61]: 1
In [62]: list3
Out[62]: [(1,), 'b', [], 1]
In [63]: list3.pop(2) #list3.pop(2)删除第二个元素
Out[63]: []
In [64]: list3
Out[64]: [(1,), 'b', 1]
In [58]: list2
Out[58]: [2, '67', (1,), 'ab32']
In [60]: list0
Out[60]: [2, 3]
In [61]: list0.remove(list2[0]) 等价于list0.remove（2）这里list2[0]=2，删除元素2
In [62]: list0
Out[62]: [3]
In [63]: list0.remove(3)
In [64]: list0
Out[64]: []
In [66]: help(list3.extend) #L.extend(iterable)是可迭代的
extend(...)
L.extend(iterable) -- extend list by appending elements from the iterable
In [67]: list3
Out[67]: [(1,), 'b', 1]
In [68]: range(5)
Out[68]: [0, 1, 2, 3, 4]
In [69]: list3.extend(range(5)) #将可迭代的range(5)的值添加到list3中
In [70]: list3
Out[70]: [(1,), 'b', 1, 0, 1, 2, 3, 4]
In [71]: list3.extend(range(2)) #将可迭代range(2)的值添加到list3中
In [72]: list3
Out[72]: [(1,), 'b', 1, 0, 1, 2, 3, 4, 0, 1]
In [73]: list3.extend('abcd') #'abcd’被分开成可迭代的值添加到list3中
In [74]: list3
Out[74]: [(1,), 'b', 1, 0, 1, 2, 3, 4, 0, 1, 'a', 'b', 'c', 'd']
In [75]: list3.extend(('t1','t2'))#把元组中元素迭代到list3中
In [76]: list3
Out[76]: [(1,), 'b', 1, 0, 1, 2, 3, 4, 0, 1, 'a', 'b', 'c', 'd', 't1', 't2'] #字典定义
In [14]: dic ={'a':1,1:123}
In [15]: dic
Out[15]: {1: 123, 'a': 1}
In [16]: dic1={'a':1,1:123,('a','b'):'hello'}#定义key使用了元组('a','b')是ok的，因为元组不可变
In [17]: dic1
Out[17]: {1: 123, 'a': 1, ('a', 'b'): 'hello'}
In [18]: dic1={'a':1,1:123,['a','b']:'hello'}#定义key使用了list['a','b']是error的，因为list可变
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-18-8dfb0113bd5a> in <module>()
----> 1 dic1={'a':1,1:123,['a','b']:'hello'}
TypeError: unhashable type: 'list'
#字典的方法
In [25]: dic
Out[25]: {1: 123, 'a': 1}
In [26]: dic.keys()
Out[26]: ['a', 1]
In [27]: dic.values()
Out[27]: [1, 123]
In [29]: dic.
dic.clear dic.get dic.iteritems dic.keys dic.setdefault
dic.copy dic.has_key dic.iterkeys dic.pop dic.update
dic.fromkeys dic.items dic.itervalues dic.popitem dic.values
In [29]: help(dic.get)
Help on built-in function get:
get(...)
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
In [30]: dic.get('a') #取字典中key='a'的值，返回值为no
Out[30]: 1
In [41]: dic.get('b','no') #取字典中key='b'的值，找不到就返回no
Out[41]: 'no'
In [33]: dic['a']=2 #将key=‘a’的值（value）修改为2
In [34]: dic
Out[34]: {1: 123, 'a': 2}
#判断key是不是在字典中
In [43]: 'a' in dic
Out[43]: True
In [44]: 'b' in dic
Out[44]: False
#dic.item将字典变为一个大的列表，且列表内一对key value变为一个元组，且是元组的两个元素
In [49]: dic1
Out[49]: {1: 123, 'a': 1, ('a', 'b'): 'linux'}
In [50]: dic1.items()
Out[50]: [('a', 1), (1, 123), (('a', 'b'), 'linux')]
In [49]: dic1
Out[49]: {1: 123, 'a': 1, ('a', 'b'): 'linux'}
In [51]: dic2=dic1.copy() #dic.copy()拷贝一个字典
In [52]: dic2
Out[52]: {1: 123, 'a': 1, ('a', 'b'): 'linux'}
In [53]: dic2.clear() #清空dic2
In [54]: dic2
Out[54]: {}
#使用dic.pop（key），返回value，然后在字典中删除该key-value
In [60]: dic1
Out[60]: {1: 123, 'a': 1, ('a', 'b'): 'linux'}
In [61]: dic1.pop(1)
Out[61]: 123
In [62]: dic1
Out[62]: {'a': 1, ('a', 'b'): 'linux'}
In [64]: dic1.pop('abc','none') #如果没有abc，则返回none
Out[64]: 'none'
#dic.update()方法，更新一个字典到另一个字典，或者将一个（k v）更新到字典
In [67]: help(dic.update)
Help on built-in function update:
update(...)
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k] #这是讲字典E的值赋值给字典D
If E lacks .keys() method, does: for (k, v) in E: D[k] = v #这里是将（k,v）格式的元组，添加到字典D中
In either case, this is followed by: for k in F: D[k] = F[k]
In [68]: dic
Out[68]: {'a': 2}
In [69]: dic1={1:1,2:2}
In [70]: dic.update(dic1) #将字典dic1得值更新到dic中
In [71]: dic
Out[71]: {1: 1, 2: 2, 'a': 2}
#创建字典
In [81]: dic={} #创建空字典
In [82]: dic=dict() #创建空字典
In [83]: dic
Out[83]: {}
In [86]: list1=['name','age']
In [87]: list2=['tom','20']
In [88]: zip(list1,list2) #合并列表
Out[88]: [('name', 'tom'), ('age', '20')]
In [89]: dict(zip(list1,list2)) #创建字典
Out[89]: {'age': '20', 'name': 'tom'}
In [90]: dict([('name', 'tom'), ('age', '20')]) #创建字典，因为是可迭代的对象，这种方法也可以
Out[90]: {'age': '20', 'name': 'tom'}
In [93]: dit5=dict(a=10,b=20) #创建字典
#dic.fromkeys()方法，S是一个序列，[,v]是一个可选的值，可以为空也可以为value(v)，默认为空
In [98]: help(dic.fromkeys)
Help on built-in function fromkeys:
fromkeys(...)
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
In [99]: dic.fromkeys('abc') #创建一个字典，序列S='abc'值为空
Out[99]: {'a': None, 'b': None, 'c': None}
In [100]: dic.fromkeys(range(5),100) #创建一个字典，S range(5),value=100
Out[100]: {0: 100, 1: 100, 2: 100, 3: 100, 4: 100}
#dic1.item()返回一个列表，把字典中的key和value变成一个元组里面的两个元素，然后保存到一个列表中
In [112]: dic1
Out[112]: {1: 1, 2: 2}
In [113]: dic1.items()
Out[113]: [(1, 1), (2, 2)]
#使用for循环访问字典dic
In [119]: for k in dic1:print k,dic1[k]
1 1
2 2
In [120]: for k in dic1:print "%s,%s" %(k,dic1[k])
1,1
2,2
In [117]: for k,v in dic1.items():print k,v
1 1
2 2
#定义二维字典
In [129]: people={'zhangsan':{'number':1,'weight':60},'lisi':{'number':2,'weight':70}}
In [130]: people
Out[130]: {'lisi': {'number': 2, 'weight': 70}, 'zhangsan': {'number': 1, 'weight': 60}}
In [131]: people['zhangsan']
Out[131]: {'number': 1, 'weight': 60}
In [132]: people['zhangsan']['weight']
Out[132]: 60
#字典的deepcopy 拷贝
>>> a={1:'abc', 2:'def'}
>>> b=a.copy()
>>> b
{1: 'abc', 2: 'def'}
>>> b[1]='a'
>>> b
{1: 'a', 2: 'def'}
>>> a
{1: 'abc', 2: 'def'}
#当b修改一个键的值，a是不会发生影响的，但是有一种情况，是会跟着变的：
>>> a={1:'abc', 2:['d','e','f']}
>>> b=a.copy()
>>> b
{1: 'abc', 2: ['d', 'e', 'f']}
>>> b[2].remove('e')
>>> b
{1: 'abc', 2: ['d', 'f']}
>>> a
{1: 'abc', 2: ['d', 'f']}
#所以，这时候就需要用另外一种方法deepcopy
>>> from copy import deepcopy
>>> a={1:'abc', 2:['d','e','f']}
>>> c=deepcopy(a)
>>> c
{1: 'abc', 2: ['d', 'e', 'f']}
>>> c[2].remove('d')
>>> c
{1: 'abc', 2: ['e', 'f']}
>>> a
{1: 'abc', 2: ['d', 'e', 'f']}
#has_key 可以检查字典中是否存在指定的键
>>> a
{1: 'abc', 2: ['d', 'e', 'f']}
>>> a.has_key(3)
False
>>> a.has_key(2)
True
#popitem 随机获取一对键值对，并且将该键值对移除
>>> a={1:'a', 2:'b', 3:'c'}
>>> a.popitem()
(1, 'a')
>>> a.popitem()
(2, 'b')
>>> a.popitem()
(3, 'c')
>>> a
{}
#练习，将输入的name、age、gender打印出来
[root@localhost ~]# vim 4.py
#/usr/bin/python
info = {}
name = raw_input("Please input name")
age = raw_input("Please input age")
gender = raw_input("Please input (M/F)")
info['name'] = name
info['age'] = age
info['gender'] = gender
for k,v in info.items():
print "%s:%s" %(k,v)
[root@localhost ~]# python 4.py
Please input namedavid
Please input age25
Please input (M/F)M
gender:M
age:25
name:david表达式是将不同的数据（包括变量、函数）用运算符好号按照一定的规则连接起来的一种式子
赋值运算符
相关文章