Python4 字典
特点: 键值对，键与值之间用：分割，项之间用,分割，整个字典用大括号括起来，空字典由两个大括号组成；
字典中的键是唯一的，而值并不唯一。
字典的键不一定为整型数据，也可以是其他不可变类型，比如浮点型，实型，字符串或者元组
自动添加：即使那个键起初在字典中并不存在，但也可以为它分配一个值，自动添加新的项，
成员资格：表达式k in d(d为字典)查找的是键，而不是值，表达式v in l(l为列表)则用来查找值，而不是索引。In [1]: phonebook = {'Alice':'123','Beth':'567'}4.1 可以用dict函数，将其他键值序列等建立字典.
In [2]: items = [('name','lambert'),('age','20')]
In [3]: d = dict(items)
In [4]: d
Out[4]: {'age': '20', 'name': 'lambert'}In [8]: ll = dict(name='lambert',age='20')
In [9]: ll
Out[9]: {'age': '20', 'name': 'lambert'}4.2字典的基本操作
len(d)返回d中项的数量
d[name]返回name对应的值
d[name]=newvalue 将newvalue关联到键name上
del d[name] 删除键为name的项；
name in d 检查d中是否含有键为k的项
4.5字典的格式化字符串
In [24]: phonebook = {'Alice':'123','Beth':'567'}
In [25]: "Alice's phone number is %(Alice)s." %phonebook
Out[25]: "Alice's phone number is 123."4.6字典的常用方法
clear方法清楚字典中所有项
copy方法返回一个具有相同键值对的新字典，俗称浅复制，只是在原来字典上做个链接，不是副本，可以“替换”新复制字典的值,但是如果“修改”了某个值，原字典也将改变；
deepcopy方法复制字典所包含的所有值，俗称深复制，里面的值随便改；
fromkeys方法是用给定的键建立新的字典，而键对应的值为None;
get方法更轻松的访问字典项，但是如果访问字典中不存在的项时会出错；
has_key方法可以检查字典中是否含有给出的键，表达式d.has_key(k)相当于表达式k in d.
items方法将所有的字典项以列表方式返回，这些列表项中的每一项都来自于（键，值）。但是返回时并没有特殊的顺序；
iteritems方法的作用跟items大致相同，但是会返回一个迭代器对象而不是列表，某些情况下很高效；
In [1]: d = {'FirstName':'Lambert','LastName':'Lee','Age':20}
In [2]: d.items()
Out[2]: [('LastName', 'Lee'), ('Age', 20), ('FirstName', 'Lambert')]
In [3]: d.iteritems()
Out[3]: <dictionary-itemiterator at 0x2df9208>
In [4]: ll=d.iteritems()
In [6]: print ll
<dictionary-itemiterator object at 0x2eedc00>
In [7]: list(ll)
Out[7]: [('LastName', 'Lee'), ('Age', 20), ('FirstName', 'Lambert')]keys方法将字典中的键以列表形式返回，而iterkeys则返回针对键的迭代器；
pop方法用来获得对应于给定键的值，然后将这个键值对从字典中移除；
popitem方法随机弹出字典中的项；
setdefault方法在某种程度上类似于get方法，能够获得给定键对应的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值；
update方法可以利用一个字典项更新另一个字典；
values方法以列表的形式返回字典中的值
itervalues返回值的迭代器；
Python5 条件，循环和其他语句
赋值的方法：
5.1序列解包: 将多个值得序列揭开，然后放到变量的序列中；
In [14]: values = 1,2,3
In [15]: values
Out[15]: (1, 2, 3)
In [16]: x,y,z=values
In [17]: x
Out[17]: 15.2链式赋值：是将同一个值赋给多个变量。如下；
In [18]: q=w=e=1
In [19]: q
Out[19]: 1
In [20]: w
Out[20]: 15.3增量赋值：将表达式运算符放置在赋值运算符=的左边.如下；
In [21]: x =2
In [22]: x +=3
In [23]: x
Out[23]: 5
In [24]: x *=2
In [25]: x
Out[25]: 105.4语句块：并非一种语句，实在条件为真（条件语句）时执行或者执行执行多次（循环语句）的一组语句，在代码前放置空格来缩进语句即可创建语句块；
False None 0 "" () {} [] 这些类型在解释器解析时都为假，其他的一切都为真值，包括特殊值True.标准的真值为True和False。或者为1和0.
5.5 if语句
If 条件1 ：
if 条件2 ：
print 结果2
elif 条件3 ：
print 结果3
else:
print 结果4
else：
print 结果5附加：如果要确保程序中的某个条件为真才能让程序正常工作的话，assert语句就很有用了；
In [36]: age = -1
In [37]: assert 0<age<100, 'TMD,This is age,age not negative.'
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-37-26492895f2fc> in <module>()
----> 1 assert 0<age<100, 'TMD,This is age,age not negative'
AssertionError: TMD,This is age,age not negative.5.6while循环 和shell一样，当条件为真时，重复执行；
x=1
while x <=100:
print x
x +=15.7 for循环 和shell一样，给出一个列表，一次按顺序执行.
In [43]: numbers = [1,2,3,4]
In [44]: for num in numbers:
print num
....:
1
2
3
45.8 常用的一些迭代工具
5.8.1 并行迭代:程序可以同时迭代两个序列。
In [13]: name = ['lambert','kangkang','kevin']
In [14]: age = [20,18,25]
In [15]: for i in range(len(name)):
print name[i],'is',age[i],"years old"
....:
lambert is 20 years old
kangkang is 18 years old
kevin is 25 years old
5.8.2内建的zip函数可以用来进行并行迭代；
In [16]: name = ['lambert','kangkang','kevin']
In [17]: age = [20,18,25]
In [18]: zip(name,age)
Out[18]: [('lambert', 20), ('kangkang', 18), ('kevin', 25)]5.8.3编号迭代：有些时候想要迭代序列中的对象，同时还要获取当前对象的索引
5.8.4翻转和排序迭代
reversed和sorted函数
In [57]: sorted([34,234,3,9])
Out[57]: [3, 9, 34, 234]
In [61]: list(reversed('Hello,world'))
Out[61]: ['d', 'l', 'r', 'o', 'w', ',', 'o', 'l', 'l', 'e', 'H']5.9跳出循环
break 直接跳出程序
continue语句比break语句用得要少很多，它会让当前的迭代结束，跳到下一轮循环的开始，基本的意思是“跳过剩余的循环体，但是不结束循环”
当循环体很大而且很复杂的时候，这会很有用。
5.10列表推导式---轻量级循环：是利用其他列表创建新列表，它的工作方式类似于for循环
例如：
In [31]: [x*x for x in range(10) if x % 3 == 0]
Out[31]: [0, 9, 36, 81]
In [32]: [(x,y) for x in range(3) for y in range(3)]
Out[32]: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]5.11 pass程序可以让程序什么都不做，对于没有完成的函数和类，这种方法很有用
5.12有些时候可能会需要动态地创造python代码，然后将其作为语句执行或作为表达式计算；
常见的方法有
exec eval
Python6 函数
1.创建函数；
函数是可以调用的（可以包含参数，也就是放在圆括号中的值），它执行某种行为并且返回一个值。
一般来说，内建的callable函数可以
用来判断函数是否可以调用；
In [8]: import math
In [9]: x = 1
In [10]: y = math.sqrt
In [11]: callable(x)
Out[11]: False
In [12]: callable(y)
Out[12]: True值从哪里来
函数被定义后，所操作的值是从哪里来的呢?
def语句中函数名后面的变量通常叫做函数的形式参数，而调用函数时提供的值是实际参数，或者称为参数
关键字参数：主要作用在于可以明确每个函数的作用，可以给函数提供默认值
In [48]: def fuck(greeting='hello',name='world'):
print '%s,%s!' %(greeting,name)
....:
In [49]: fuck()
hello,world!
In [50]: fuck('greeting')
greeting,world!
In [51]: fuck('greeting','universe')
greeting,universe!
In [52]: fuck(name='lambert')
hello,lambert!2.收集参数
*号可以收集任意多个位置参数，如果不提供位置参数，那么collect就是一个空元组；
In [56]: def collect(title,*params):
print title
print params
....:
In [57]: collect('collect:',1,2,3)
collect:
(1, 2, 3)
**可以收集关键字参数，
In [58]: def collect(**params):
print params
....:
In [59]: print collect(x=1,y=2,z=3)
{'y': 2, 'x': 1, 'z': 3}收集位置参数和关键字参数可以联合起来用；
3.反转过程：就是函数手机的逆过程
In [61]: def add(x,y): return x+y
In [62]: params = (1,2)
In [63]: add(*params)
Out[63]: 3
In [1]: def story(**kwds):
...: return 'Once upon a time,there was a '\
...: '%(job)s called %(name)s.' % kwds
...:
In [2]: print story(job='king',name='gumby')
Once upon a time,there was a king called gumby.
In [15]: def power(x,y,*others):
if others:
print 'Received redundant parameters:',others
return pow(x,y)
....:
In [16]: power(2,3)
Out[16]: 8
In [17]: params = (5,)*2 //params=(5, 5)
In [18]: power(*params)
Out[18]: 3125
In [19]: power(3,3,'Hello,World')
Received redundant parameters: ('Hello,World',)
Out[19]: 273.作用域
函数内部的变量被称为局部变量，与全局变量是相反的概念，函数可以使用全局变量，但是使用全局变量或者
参数名字和药访问的全局变量相同的话，就不能直接访问了，全局变量会被局部变量屏蔽，当然如果确实需要的话
可以使用globals函数获取全局变量值，它可以返回全局变量的字典（locals返回局部变量的字典），
In [64]: def combine(parameter):
....: print parameter + globals()['parameter']
....:
In [65]: parameter = 'berry'
In [66]: combine('Shrub')
Shrubberry如果在函数内部将值赋予一个变量，它会自动成为局部变量，除非告诉python将其生命为全局变量。
In [67]: x = 1
In [68]: def cg():
....: global x
....: x = x+1
....:
In [69]: cg()
In [70]: x
Out[70]: 2嵌套作用域，说白了是一个函数镶嵌另一个函数
递归：python中是函数自身调用自己,也叫做无穷递归，类似于while true循环，
阶乘
n*(n-1)*(n-2)*....*1
In [100]: def fac(n):
result = n
for i in range(1,n):
result *= i
return result
.....:
In [101]: fac(2)
Out[101]: 2
In [102]: fac(3)
Out[102]: 6
In [103]: fac(5)
Out[103]: 120
In [104]: def factor(n):
.....: if n == 1:
.....: return 1
.....: else:
.....: return n * factor(n-1)
.....:
In [105]: factor(3)
Out[105]: 6
In [106]: factor(5)
Out[106]: 120面向对象的过程，好处；
多态：意味着就算不知道变量所引用的对象类型是什么，还可以对它进行操作，而它也会根据对象或类的类型的不同而表现出不同的行为，
可以让对用户不知道是什么类的对象进行方法调用
封装：是对全局作用域中其他区域隐藏多余信息的规则，即不用关心对象是如何构建的而直接进行使用，
继承：一个类继承另一个类的方法。
类和类型
类是什么？ 类是一种对象，比如说鸟，鸟就是鸟类的实例，百灵鸟类是鸟类的子类，鸟类是百灵鸟类的超累，引用类的最好方法是将类实例化出来
在面向对象程序设计中，子类的关系是隐式的，因为一个类的定义取决于它所支持的方法，类的所有实例都会包含这种方法，
In [8]: class person:
def setname(self,name): //函数的第一个参数为self时，调用自身
self.name = name
def getname(self):
return self.name
def greet(self):
print "Hello,world! I'm %s." %self.name
...:
In [9]: foo = person()
In [10]: foo.setname('lambert')
In [11]: foo.greet()
Hello,world! I'm lambert.
In [11]: foo.getname()
Out[11]: 'lambert'所谓python的私有方式，意思是类里面定义的函数，不能从外部直接访问，只需要在函数的名字前面加上双下划线即可：
In [27]: class server:
def __inaccess(self):
print "I cant access from outside"
def outaccess(self):
print "I can access from outside"
self.__inaccess()
....:
In [28]: aa = server()
In [29]: aa.__inaccess()
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-29-0824a0ef3322> in <module>()
----> 1 aa.__inaccess()
AttributeError: server instance has no attribute '__inaccess'
In [30]: aa.outaccess()
I can access from outside
I cant access from outside
当然也可以访问从外部，
In [31]: aa._server__inaccess()
I cant access from outside类的命名空间
转载于:https://blog.51cto.com/leejung/1610052
扫一扫
1460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
