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]: True
Lambda(从上到下,优先级越来越高,同行右侧优先级更高)
逻辑运算: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=0
input()与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)in () ----> 1 input ("Please input: ") in () 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 xy. 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)in () ----> 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)in () ----> 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
表达式是将不同的数据(包括变量、函数)用运算符好号按照一定的规则连接起来的一种式子
赋值运算符