如：&p style='……'&
&p ……&p标签里面有任何东西
全部替换成&p&最后结果只出现&p&标签，里有任何属性的都去除这个正则怎么写？
--------------------------------------
codepreg_replace('#&p[^&]*&#i','&p&',$html);&&蒲公英是怎样传播种子的&&(三年级作文)
柔眸流光丶余
为您推荐：
其他类似问题
扫描下载二维码这一章，有点抽象，看着有点蛋疼！双下划线__future__或单下划线有特殊含义，在Python中，这些名字的集合称为魔法方法:最重要的是__init__和一些处理访问对象的方法,这些方法允许你创建自己的序列或者是映射.------准备工作:将__metaclass__=type放在模块的最开始位置，以确保类时最新式的。考虑下面两个类class NewStyle(object):
more_code_hereclass OldStyle:
more_code_here如果文件以__metclass__=type开始，那么这个类都是新式类------构造方法:和普通方法的不同在于:当一个对象被创建后，会立即调用构造方法。因此，之前章节的&&&f = FooBar()&&&f.init()等同于&&&f = FooBar()&&& class FooBar:def __init__(self):self.var = 42&&& f = FooBar()&&& f.var42#如果有默认参数呢？&&& class Foobar:def __init__(self,value=42):self.var = value&&& f = Foobar()
#无参的话，使用默认值&&& f.var42&&& f1 = Foobar(44)
#有参的话，使用新参数&&& f1.var44在Python中__init__是使用最多的一个.Python中有个魔法方法__del__，析构方法，她在对象要被垃圾回收之前调用.但是发生调用的具体时间是不可知的。所以建立尽力避免使用__del__函数.------重写一般方法和特殊构造方法:&&& class A:...
def hello(self):...
print 'Hello,World!'...&&& class B(A): pass...&&& class C(B): pass...#看看他们的工作机制#c是C类的实例，当c调用hello()，首先找自己类有没有，没有话，去超类B中找，如果还没有话，就去超类的超类去找。还没有的话，就报错。&&& c = C()&&& c.hello()Hello,World!如果重写B类，hello的方法呢?&&& class A:...
def hello(self):...
print &Hello,I am A!&...&&& class B(A):...
def hello(self):...
print &Hello,I am B!&...&&& b = B()&&& b.hello()Hello,I am B!重写是继承机制中的一个重要内容，对于构造方法尤其重要。构造方法用来初始化新创建对象的状态，大多数子类不仅要拥有自己的初始化代码，还要拥有超类的初始化代码。虽然重写的机制对于所有方法来说都是一样的，但是当处理构造方法比重写普通方法时，更可能遇到特别的问题：如果一个类的构造方法被重写，那么就需要调用超类的构造方法，否则对象不会被正确初始化。看下面的例子class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print &Ahaha...&
self.hungry = False
print &No, Thanks!&该类定义鸟的基本功能吃，吃饱了就不再吃输出结果:&&& b = Bird()&&& b.eat()Ahaha...&&& b.eat()No, Thanks!下面一个子类SingBird,class SingBird(Bird):
def __init__(self):
self.sound = 'squawk'
def sing(self):
print self.sound输出结果:&&& s = SingBird()&&& s.sing()squawkSingBird是Bird的子类，但如果调用Bird类的eat()方法时,&&& s.eat()Traceback (most recent call last):
File &&pyshell#5&&, line 1, in &module&
File &D:/Learn/Python/Person.py&, line 42, in eat
if self.hungry:AttributeError: SingBird instance has no attribute 'hungry'代码错误很清晰,SingBird中初始化代码被重写，但没有任何初始化hungry的代码------调用未绑定的超类构造方法:class SingBird(Bird):
def __init__(self):
Bird.__init__(self)
#增加这行代码就搞定
self.sound = 'squawk'
def sing(self):
print self.sound&&& sb = SingBird()&&& sb.sing()squawk&&& sb.eat()Ahaha...&&& sb.eat()No, Thanks!------使用super函数:__metaclass__=typeclass Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print &Ahaha...&
self.hungry = False
print &No, Thanks!&class SingBird(Bird):
def __init__(self):
super(SingBird,self).__init__()
self.sound = 'squawk'
def sing(self):
print self.soundNote:1. __metaclass__=type 必不可少，否则报错如下:&&& sb = SingBird()Traceback (most recent call last):
File &&pyshell#5&&, line 1, in &module&
sb = SingBird()
File &D:/Learn/Python/Person.py&, line 51, in __init__
super(SingBird,self).__init__()TypeError: must be type, not classobj2.&super(SingBird,self).__init__() &多了这么一句输出结果:&&& sb = SingBird()&&& sb.sing()squawk&&& sb.eat()Ahaha...&&& sb.eat()No, Thanks!------基本的序列和映射规则:序列和映射是对象的集合，为了实现他们的基本行为，如果对象是不可变的，那么就需要两个魔法方法，如果对象时可变的，那么就需要四个魔法方法__len__(self):返回集合中所含项目的数量__getitem__(self,key):返回与所给的键对应的值__setitem__(self,key,value):按一定的方法存储和key相关的value__delitem__(self,key):删除对象相关的键实践一下，创建一个无穷序列def checkIndex(key):
if not isinstance(key,(int,long)):
raise TypeError
raise IndexErrorclass ArithmeticSequence:
def __init__(self,start=0,step=1):
self.start
self.changed = {}
def __getitem__(self,key):
checkIndex(key)
return self.changed[key]
except KeyError:
return self.start + key*self.step
def __setitem__(self,key,value):
checkIndex(key)
self.changed[key] = value输出结果&&& s[100]201&&& s = ArithmeticSequence(1,2)&&& s[4]9&&& s[10]21&&& del s[4]Traceback (most recent call last):
File &&pyshell#10&&, line 1, in &module&
del s[4]AttributeError: ArithmeticSequence instance has no attribute '__delitem__'&&& s['four']Traceback (most recent call last):
File &&pyshell#11&&, line 1, in &module&
s['four']
File &D:/Learn/Python/Person.py&, line 71, in __getitem__
checkIndex(key)
File &D:/Learn/Python/Person.py&, line 62, in checkIndex
raise TypeErrorTypeError&&& s[-4]Traceback (most recent call last):
File &&pyshell#12&&, line 1, in &module&
File &D:/Learn/Python/Person.py&, line 71, in __getitem__
checkIndex(key)
File &D:/Learn/Python/Person.py&, line 64, in checkIndex
raise IndexErrorIndexError------子类化列表，字典和字符串三个关于序列和映射规则(UserList,UserString,UserDict),如果希望实现一个和内建列表行为相似的序列，可以使用子类list，看看下面的例子，带有访问计数的列表class CounterList(list):
def __init__(self,*args):
super(CounterList,self).__init__(*args)
self.counter = 0
def __getitem__(self,index):
self.counter +=1
return super(CounterList,self).__getitem__(index)#下面是她如何使用的一些例子&&& c = CounterList(range(10))&&& c[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&&& c.reverse()&&& c[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]&&& del c[3:6]&&& c[9, 8, 7, 3, 2, 1, 0]&&& c.counter0&&& c[4]+c[2]9&&& c.counter2#其他跟list性能一样，但有个counter特性，每次执行加法后会自增。------属性:class Rectangle:
def __init__(self):
self.width
self.height = 0
def setSize(self,size):
self.width,self.height = size
def getSize(self):
return self.width,self.height&&& r= Rectangle()&&& r.width = 10&&& r.height= 5&&& r.getSize()(10, 5)&&& r.setSize((150,100))&&& r.width150------property函数:__metaclass__=typeclass Rectangle:
def __init__(self):
self.width
self.height = 0
def setSize(self,size):
self.width,self.height = size
def getSize(self):
return self.width,self.height
size = property(getSize,setSize)在这个新版的Rectangle中，property函数创建了一个属性，其中访问器函数被用做参数(先是取值，然后是赋值)，这个属性命为size，这样一来，就不用担心是如何实现的，可以用同样的方式处理width,height和size.&&& r = Rectangle()&&& r.width = 10&&& r.height= 20&&& r.size(10, 20)&&& r.size = 100,200&&& r.width100property函数可以用0,1,2,3或4个参数来调用。如果没有参数，产生的属性即不可读，也不可写。如果只使用一个参数调用，产生的属性是只读的第3个参数。名字分别叫:fget,fset,fdel,doc__------静态方法和类成员方法静态方法和类成员方法分别在创建时被装入Staticmethod类型和Classmethod类型的对象中。静态方法的定义没有self参数，且可能被类本身直接调用。类方法在定义时需要名为cls的类似于self的参数，类成员方法可以直接用类的具体对象调用。但cls参数是自动被绑定类的。看下例子:class MyClass:
def smeth():
print 'This is a stacie method'
smeth = staticmethod(smeth)
def cmeth(cls):
print 'This is a class method of', cls
cmeth = classmethod(cmeth)#用@来替代__metaclass__ = typeclass MyClass:
@staticmethod
def smeth():
print 'This is a stacie method'
@classmethod
def cmeth(cls):
print 'This is a class method of', cls#定义好了方法后，可以这样调用。&&& MyClass.smeth()This is a stacie method&&& MyClass.cmeth()This is a class method of &class '__main__.MyClass'&------__getattr__,__setattr__为了访问特性的时候可以执行代码，必须使用一些魔法方法。下面四种方法提供了需要的功能。__getattrbute__(self,name): 当特性name被访问时，自动被调用__getattr__(self,name):当特性name被访问，且对象没有相应的特性时被自动调用__setattr__(self,name,value):当试图给特性name赋值时会被自动调用__delattr__(self,name): 当试图删除特性name时被自动调用。class Rectangle:
def __init__(self):
self.width
self.height = 0
def __setattr__(self,name,value):
if name == 'size':
self.width,self.height = value
self.__dict__[name] = value
def __getattr__(self,name):
if name == 'size':
return self.width,self.height
raise AttributeError------迭代器:主要讨论特殊的方法:__iter__这个迭代器规则的基础.__iter__方法返回一个迭代器，所谓迭代器就是具有next方法的对象。如果next被调用，却没有值可以返回，则会返回StopIteration的异常.为什么要用迭代器而不用列表呢？如果值很多，列表一次性获得，会占用太多的内存。而迭代则可以一个一个获取。还有为什么要用迭代器的原因：迭代器更通用，更简单，更优雅。class Fibs:
def __init__(self):
self.a = 0
self.b = 1
def next(self):
self.a,self.b = self.b,self.a + self.b
return self.a
def __iter__(self):
return self首先是实现了__iter__方法，这个方法实际上返回迭代器本身。很多情况下，__iter__会放到for循环中使用的对象中.首先产生一个Fibs对象&&& fibs = Fibs()其次可在for循环中使用该对象-比如去查找在斐波那契数列中比1000大的数中的最小的数:&&& for f in fibs:if f&1000:print fbreak1597Note: 内建函数iter可以从可迭代的对象中获得迭代器.&&& it = iter([1,2,3])&&& it.next()1&&& it.next()2除此之外，它也可以从函数或者其他可调用对象中获取可迭代对象.------从迭代器中得到序列:除了再迭代器和可迭代对象上进行迭代外，还能把它们转换为序列。在大部分能使用序列的情况下，能使用迭代器替换。一个很有用的例子是使用list构造方法显式地将迭代器转化为列表class TestIter:
def next(self):
self.value +=1
if self.value & 10 :
raise StopIteration
return self.value
def __iter__(self):输出结果:&&& ti = TestIter()&&& ti&__main__.TestIter instance at 0xA81A08&&&& list(ti)[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]------生成器: 是Python新引入的概念，由于历史原因，它也叫简单生成器。它和迭代器可能是近几年来引入的最强大的两个特性。生成器可以帮助程序员写出非常优雅的代码，当然编写任何程序也不可以不使用。生成器是一种用普通的函数语法定义的迭代器。------创建生成器:nested = [[1,2],[3,4],[5]]如果像这么个例子，怎么样用将数字一一打印出来。def flatten(nested):
for sublist in nested:
for element in sublist:
yield element#如何包含yield的语句，称为生成器&&& nested = [[1],[2,3],[4,5,6]]&&& flatten(nested)&generator object flatten at 0x35A0&&&& for num in flatten(nested):
print num 123456------递归生成器:上一个例子创建的生成器只能处理两层嵌套，使用了两个for循环。如果要处理任意层的嵌套怎么办？就应该更灵活，现在就到了递归生成器登场的时候了。def flatten(nested):
for sublist in nested:
for element in flatten(sublist):
yield element
except TypeError:
yield nested两种情况: 基本情况和需要递归的情况1. 如果只是元素，函数被告知展开一个元素，这种情况下，for循环会引发一个TypeError异常，生成器会产生一个元素.2. 如果是一个列表，那么就要进行特殊处理。程序必须遍历所有子列表，并对它们调用flatten，然后使用另一个for循环来产生被展开的子列表中的所有元素，很神奇吧。&&& nested = [[[[1,2],3],4],5]&&& list(flatten(nested))[1, 2, 3, 4, 5]如果是字符串对象，那么它就是一个序列，不会引发TypeError，如果你不想对这样的对象进行迭代。为了处理这种情况，则必须在生成器的开始处添加一个检查语句。试着将传入的对象和一个字符串拼接，看看会不会出现TypeError，这是检查一个对象是不是类似于字符串的最简单，最快速的方法。下面加入检查语句的生成器。&&& nested=['a',[[[1,2],3],4],5]&&& list(flatten(nested))['a', 1, 2, 3, 4, 5]------通用生成器:生成器是一个包含yield关键字的函数。当它被调用时，在函数体中的代码不会被执行，而会返回一个迭代器。每次请求一个值，就会执行生成器中的代码，知道遇到一个yield或者return语句。yield意味着应该生成一个值。return语句意味着生成器要停止执行。换句话说，生成器由两部分组成:生成器的函数和生成器的迭代器。生成器的函数是用def语句定义，包含yield部分，生成器的迭代器是这个函数返回的部分。&&& def simple_generator():yield 1&&& simple_generator&function simple_generator at 0xAFB0B8&&&& simple_generator()&generator object simple_generator at 0xC8EE8&&&& ------生成器方法:&&& def repeater(value):
while True:
new = (yield value)
if new is not None: value = new输出结果:&&& r = repeater(42)&&& r.next()42&&& r.next()42&&& r.send('Hello,World!')'Hello,World!'#next()方法，send()方法，throw()方法，close()方法------模拟生成器:如何使用普通的函数模拟生成器首先将下面语句放在程序的开始处result = []然后将下面这种形式的代码:yield some_expression用下面的语句替换:result.append(some_expression)最后在函数的末尾，添加下面的语句:&return result下面是flatten生成器用普通的函数重写的版本def flatten(nested):
result = []
try: nested + ''
except TypeError: pass
else: raise TypeError
for sublist in nested:
for element in flatten(sublist):
result.append(element)
except TypeError:
result.append(nested)
return result输出结果:&&& n = [[[[[['HaHa...'],1],2],3],4],5]&&& flatten(n)['HaHa...', 1, 2, 3, 4, 5]------本章新函数iter(obj) & & & & & & & & & & & & & &从一个可迭代的对象得到迭代器property(fget,fset,fdel,doc) & & & & 返回一个属性，所有参数都是可选的super(class,obj) & & & & & & & & & & 返回一个类的超类的绑定实例第05章 | 条件、循环和其他语句
print& 和& import
#如果要打印多个语句，用，分割
&&& print &Name is:&,&Sherry.&,&Age is:&,40 Name is: Sherry. Age is: 40
&&& print (1,2,3) & #如果要打印元祖 (1, 2, 3) &&& print 1,2,3 & & #print语句会在每个元素间插入一个空格 1 2 3
#如果想同时输出文本和变量，却又不希望用格式化的方法，那么就非常有用了。
&&& greeting & = 'Hello,' &&& salutation = 'Mr' &&& name & & & = 'Smith.' &&& print greeting, salutation, name Hello, Mr Smith.
#如果''中不加入逗号,要如何实现呢
&&& print greeting + ',', salutation, name
#如果在结尾处加上,下一句会接着上一句打印 print 'Hello,', print 'World!' 输出结果: Hello,World!
Note:& 1. 在很多应用程序中用logging模块记日志比print更合适 2. 在Python3.0上，print时函数，所以要用print('Hello,World!')这种方式.
#导入某个模块import somemodule#从某个模块中导入某个函数from somemodule import somefunc#从某个模块中导入多个函数from somemodule import func1, func2,func3#从某个模块中导入所有函数from somemodule import *#如两个模块都有一个函数openmodule1.open()module2.open()#加as子句提供别名功能&&& import math as foobar&&& foobar.sqrt(4)2.0#也可以在函数后面加as语句，为函数提供别名&&& from math import sqrt as foobar&&& foobar(4)2.0#如果两个模块同时又某个函数，可以分别提供别名:from module1 import open as open1from module2 import open as open2 ------
序列解包 &&& x,y,z=1,2,3#多个赋值&&& x,y,z(1, 2, 3)&&& x,y=y,x#两个交换&&& x,y,z(2, 1, 3)上述操作就叫序列解包:将多个值的序列解开，然后放到变量的序列中&&& values = 1,2,3&&& values(1, 2, 3)&&& x,y,z = values&&& x1当函数或方法返回元祖时，这个特性尤其有用，假如想获取或删除某个字典中的任意键值，可以用popitem()，但要如果获取键/值呢？可以存放在两个变量中.&&& d={'name':'Sherry','age':40}&&& key,value=d.popitem()&&& key'age'&&& value40解包元素的数量必须和变量个数一致，否则要报错:&&& x,y,z=1,2Traceback (most recent call last):File &&stdin&&, line 1, in ?ValueError: need more than 2 values to unpack&&& x,y,z=1,2,3,4Traceback (most recent call last):File &&stdin&&, line 1, in ?ValueError: too many values to unpackNote:Python3.0中有个特性，允许两边数量不一致&&& a,b,rest*=[1,2,3,4]&&&b12&&&rest & #多余的元素都收集到了rest[3,4]
链式赋值: 将同一值赋给多个变量的捷径 x = y = func() 和下面的语句效果是一样的 y = func() x = y 但上面的语句和下面的语句不一定是等价的. x = func() y = func()
增量赋值 x = x+1; &也可以 x +=1,对于其他的操作符-,*,/,%都适用 一般来说+=这样执行的要优于前者
&&& x = 1&&& x +=1&&& x *=2&&& x4#对于其他数据类型也适用&&& s = 'She'&&& s +='rry'&&& s *=2&&& s'SherrySherry'Note: 增量赋值让代码更加紧揍，简练，更加易读
是条件为真的，一组语句块 :标示语句块的开始 块的语句都是缩进的 等量缩进 可以用Tab进行缩进，但Python强烈建议用4个空格做为缩进
布尔变量的作用 下面的值在布尔表达式中，会被python解释器看成为假(False)
False& 0& None& && [] () {}&换句话说，False和None,及所有的数字类型0(整型，浮点型)所有的空序列(字符串,列表，元祖)，空字典这点非常有用&&& False == 0True&&& TrueTrue&&& FalseFalse&&& True == 1True&&& True + False +4243#在这里True==1,False==0#所以条件判断的时候， if True: &或 if 1: 都可以作为判断的条件#True,False是布尔值，bool函数可以用来转换为布尔值&&& bool('I think, therefor i am.')True&&& bool(42)True&&& bool('')False&&& bool(0)False#因为所有值都可以用作布尔值，所以Python不需要转换，会自动转换。&&& if bool(42): & #所以像这样其实是没有必要的... & print &Hello,World!&...Hello,World!
条件执行及if语句: #大多教程，大多说法，条件真假的区别
&&& name=raw_input('Enter your name:')Enter your name:ni hao Jerry&&& if name.endswith('Jerry'): #条件为真，语句执行，为假，语句不执行... print &Hi,Jerry!&...Hi,Jerry!#也有人认为这是&有些东西&和&没有东西&的区别
条件为真执行if语句块，否则执行else语句块
&&& name=raw_input(&What's your name:&)What's your name:John smith&&& if name.startswith('John'):... print 'Hi, John!'... else:... print 'Hi, Strange.'...Hi, John!------
elif: 如果要检查多个条件，则要用到elif
&&& num=input('Enter a number:')Enter a number:1&&& if num & 0:... print &num is a postive&... elif num & 0:... print &num is a negative.&... else:... print &num is zero.&...num is a postiveNote: int(raw_input())来代替input
嵌套代码块 if语句嵌套使用if语句
# cat hello1.py#!/usr/bin/env pythonname = raw_input('What is your name:')if name.endswith('John'): if name.startswith('Mr.'):
print 'Hello,Mr.John.' elif name.startswith('Mrs.'):
print 'Hello,Mrs.John.' else:
print 'Hello,John.'else: print &Hello,Strange.&# ./hello1.pyWhat is your name:JohnHello,John.------
更复杂的条件
1.比较运算符 Note:& 1. x && y 表示 x != y. 不建议使用此运算符. 2. 不同类型比较，Python版本不同，可能出问题。尽量避免 3. 比较对象的时候可以用内建的函数cmp()
2. 相等运算符:
&&& 'foo' == 'foo'True&&& 'foo' == 'bar'False&&& 'foo' = 'foo'SyntaxError: can't assign to literal== 表示相等= &赋值
3. is 同一性运算符号:
&&& x = y = [1,2,3]&&& z = [1,2,3]&&& x == yTrue&&& x == zTrue&&& x is yTrue&&& x is zFalse&&& id(x);id(y);id(z)846856#is 是判断同一性，而不是相等性。#值相等，但确不是同一个对象，如果还不明白的话，可以看下面的例子&&& x = [1,2,3]&&& y = [2,4]&&& x is not yTrue&&& del x[2]&&& y[1]=1&&& y.reverse()&&& y[1, 2]&&& x is y#显然两个列表不等同 False总结 ：用==来判断两个对象的值是否相等
& & & &用is来判断两个对象是否是同一对象
WARN :避免将is用于比较数值或字符串这些不可变值。
& & &由于Python内部操作这些对象方式的原因，使用is运算符其结果是不可测的。
in 成员关系运算符
&&& name=raw_input(r'Enter your name:')Enter your name:Jerry&&& if 'J' in name:... print &Your name contains 'J'&... else:... print &Your name not contains'J'&...Your name contains 'J'------
5. 字符串和序列比较
&&& 'alpha'&'beta'True#如果顺序比较凌乱的话,用upper(),或者lower()先来转化，再比较&&& 'JErrY'.upper() == 'jerrY'.upper()True&&& [1,2]&[2,1]True&&& [2,[1,4]]&[2,[1,5]]True6. 布尔运算符
如果要写个小程序:写1到10之间的数并比较
number=input('Enter a number between 1 and 10:')if number &=10:if number &= 1:print 'Correct.'else:print 'Wrong.'else:print 'Wrong.'上面的方法就有重复行，因此要合并下:number=input('Enter a number between 1 and 10:')if number&=10 and number&=1:print &Correct&else:print &Wrong.&Note: 或者这样写 &if 1&= number &= 10:
and ,or, not 三个布尔运算符，可以随意组合真值
if ((crash&price) or customer_has_good_credit) and not out_of_stock:give_goods()短路逻辑及条件表达式
x and y: 前面条件为真才会继续后面的判断 x or &y: 前面为真，返回x的值，否则返回y的值 作用: 主要避免了无用执行代码，可以作为一种技巧，假如用户应该输入用户名， 但用户可以选择不输入，这时可以使用默认值'&unknown&'，使if语句更加简洁
&&& name=raw_input('Enter your name:') or '&unknown&'Enter your name:&&& print name&unknown&------
端言: assert if not condition: crash program 为什么需要出现此种代码，这是因为与其让程序在晚些时候崩溃，不如在错误条件出现 时就直接让它崩溃，一般来说，你可以要求条件必须为真 (例如,在检查函数参数的属性时，或者作为初期测试和调试过程中的辅助条件).
&&& age = 10&&& assert 0& age &100&&& age = -1&&& assert 0& age &100Traceback (most recent call last):File &&stdin&&, line 1, in ?AssertionError如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert语句就有欧诺个了。它可以在程序中置入检查点。条件后可以添加字符串，用来解释断言:&&& age = -1&&& assert 0& age &100, 'The age must between 1-100'Traceback (most recent call last):File &&stdin&&, line 1, in ?AssertionError: The age must between 1-100------
循环: 如果要打印1-100,不可能 print 1 print 2 ...... print 100 & 这里就要用到循环 While循环
&&& x = 1&&& while x&=100:... print x... x +=1name = ''while not name:# name,空则为假,not name: 则为真。name = raw_input('Enter your name:')print 'Hello,%s!' % name# 如果再次输入空值,程序会要求你重新输入# 如果输入姓名有空格，则可以while not name.strip():来除掉空格;
while 循环很灵活，只要条件为真就会一直执行.但如果是一个集合(序列和其他可迭代对象) 每个元素都执行一个代码块，就要考虑用到for循环. Note: 可迭代对象指可以按次序迭代的对象
&&& words = ['My','name','is','Mrs','Alice']&&& for word in words:... print word...MynameisMrsAlice或者&&& numbers = [1,2,3,4,5,6,7,8,9]&&& for number in numbers:... print number,...1 2 3 4 5 6 7 8 9或者&&& for number in range(10):... print number,...0 1 2 3 4 5 6 7 8 9xrange: 类似于range,返回个迭代对象,在巨大序列时会更高效，一般情况，不必过多关注注意:如果能用for循环的话，就尽量不用while循环
循环遍历字典元素
&&& for key in d:... print key, 'corresponds to', d[key]...y corresponds to 2x corresponds to 1z corresponds to 3或者&&& d = {'x':1,'y':2,'z':3}&&& d.items()[('y', 2), ('x', 1), ('z', 3)]&&& for key,value in d.items():... print key,'corresponds to',value...y corresponds to 2x corresponds to 1z corresponds to 3Note: 字典是无序的,如果顺序很重要的话，可以讲键值保留在单独的列表中;例如在迭代前排序.
一些迭代工具: Python内建函数或itertools模块 并行迭代:
&&& name = ['Jerry','Wendy','Alice']&&& age= [40,30,20]&&& for i in range(len(name)):... print name[i],'is', age[i],'years old.'...Jerry is 40 years old.Wendy is 30 years old.Alice is 20 years old.#或者用序列包的方式来迭代&&& name = ['Jerry','Wendy','Alice']&&& age= [40,30,20]&&& for name,age in zip(name,age):#循环中解包元祖... print name,'is',age,'years old.'...Jerry is 40 years old.Wendy is 30 years old.Alice is 20 years old.#zip可以合并不等长队列，以最小为准备.&&& zip(range(5),xrange(100000))[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]Note:不推荐用range来代替xrange,&&& zip(range(5),xrange()) #遍历所有的数字，速度很慢[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]&&& zip(range(5),range())#速度很快[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]------
翻转和排序迭代
&&& sorted([3,6,4,3,8])[3, 3, 4, 6, 8]&&& sorted('A B C D')[' ', ' ', ' ', 'A', 'B', 'C', 'D']&&& reversed('A B C D')&reversed object at 0xD8EF28&&&& list(reversed('A B C D'))['D', ' ', 'C', ' ', 'B', ' ', 'A']&&& ''.join(reversed('A B C D'))'D C B A'------
Break: 结束循环
假设寻找100以内最大平方数,找到了则break循环
&&& for n in range(99,0,-1):root = sqrt(n)if root == int(root):print rootbreak9.0range(99,0,-1)步长为-1,反向迭代.&&& range(0,10,2) #步长为2[0, 2, 4, 6, 8]&&& range(10,0,-2)#步长为-2,反向迭代[10, 8, 6, 4, 2]continue:结束当前的循环，返回下一次迭代的开始:
最基本的意思: 跳过剩余的循环体，但是不结束循环.
for x in seq:if condition1: continueif condition2: continuedo something()do anotherthing()------word='dummy'while word: word=raw_input('Enter your name:') print 'word is:', word[root@nas2ds1 python]# ./while.pyEnter your name:Jerryword is: JerryEnter your name:Tomword is: Tom上面一段代码赋了一个哑值(未使用的值),这是程序应该完善的地方word=raw_input('Enter word here:')while word:print 'Word is:',wordword=raw_input('Enter your name:')#这样做的好处是:哑值不见了，而且输入一个空值会跳出循环,while True/breakwhile True:word=raw_input('Enter word:')if not word:breakprint 'word is:', word尽量避免在代码中多次使用while True/break,会降低代码的可读性。但while True/break,的确是非常有用。
-----------
循环中的else子句:
from math import sqrtfor n in range(99,81,-1): root = sqrt(n) if root == int(root):
breakelse: print &Don't find it.&--------
列表推导式-轻量级循环
列表推导式--利用其它列表来创造新的列表
&&& [x*2 for x in range(5)][0, 2, 4, 6, 8]&&& [x*x for x in range(5)][0, 1, 4, 9, 16]&&& [x*x for x in range(10) if x%3==0][0, 9, 36, 81]#增加更多for语句的部分&&& [(x,y) for x in range(2) for y in range(4)][(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3)]#可以用下面双重循环来遍历，但无疑上面代码要简洁些&&& for x in range(2):... for y in range(4):... result.append([x,y])...&&& result[[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3]]#也可以用if子句来联合,比如说找出boys,girls中首字母相同的单词:&&& boys= ['tom','bob']&&& girls = ['alice','bernice']&&& [b+'+'+g for b in boys for g in girls if b[0]==g[0]]['bob+bernice']Note:()得不到元祖推导式，只有[]才可以.
pass:如果程序上面都不用做，pass就要用上，某种程度,pass是调试程序或防止程序用的
if name='Alice'print &Welcome Alice.&elif name='Bob'#还没完elif name='Jerry'print 'Access deny.'这个时候中间就要用到pass，否则程序在判断name='Bob'会报错if name='Alice'print &Welcome Alice.&elif name='Bob' #还没完passelif name='Jerry'print 'Access deny.'Note:注释和pass联合使用的替代方案是插入字符串，对于那些没有完成的函数和类，这个方法尤其有用，
因为它们扮演文档字符串的角色.
print '''The function part still not completed, needed to add something here:'''del:
#d1,和d2绑定在同一个字典里，如果d1设置为None，字典通过d2还是可用的，如果d2也设置为None，那么字典
就漂在内存，没法获取和使用她。直到删除那个字典:
&&& d1 = {'name':'John','age':40}&&& d2 = d1&&& d1 = None&&& d2{'age': 40, 'name': 'John'}&&& d1&&& d2 = None#移除一个对象，同时移除那个名字本身&&& x = 1&&& del x&&& xTraceback (most recent call last):File &&stdin&&, line 1, in ?NameError: name 'x' is not defined# x, y 指向同一个列表，删除的只是x名称，本身的值并没有删除&&& x = ['hello','world']&&& y = x&&& y[1] = 'python'&&& x['hello', 'python']&&& del x&&& y['hello', 'python']比如说:&&& x = y = 1&&& del x&&& y1&&& del x,y#如果要删除多个值，可以这样#当然也可以重写函数默认的del函数来删除对象
使用exec和eval执行和求值字符串
#类似于shell中的exec和eval
&&& exec &print 'Hello,world!'&Hello,world!# python3.0中,exec是函数不是语句
eval(用于求值)
&&& eval(raw_input('Enter arithmetic expression:'))Enter arithmetic expression:6+18*242#eval(raw_input()) == input&&& input('Enter arithmetic expression:')Enter arithmetic expression:6+18*242#python3.0 中已经用input来替代raw_input()
本章新函数
chr(n) & & & & 当传入序号为n时，返回n所代表的包含一个字符的字符串
eval(source[,global[,local]]) 将字符串作为表达式计算，并返回值
emumerate(seq) 产生用于迭代的(索引，值)对
ord(c) & & & & 返回单字符的值
range() & & & &返回整数的列表
reversed(seq) & 产生seq的反向版本，用于迭代
xrange() & & & &创造xrange对象，用于迭代
zip(seq1,seq2) &创造用于并行迭代的新序列