> 前面的python3入门系列基本上也对python入了门，从这章起就开始介绍下python的爬虫教程，拿出来给大家分享；爬虫说的简单，就是去抓取网路的数据进行分析处理；这章主要入门，了解几个爬虫的小测试，以及对爬虫用到的工具介绍，比如集合，队列，正则表达式； ### 用python抓取指定页面： 代码如下： ~~~ import urllib.request url= "http://www.baidu.com" data = urllib.request.urlopen(url).read()# data = data.decode('UTF-8') print(data) ~~~ urllib.request.urlopen(url)[官方文档](https://docs.python.org/3/library/urllib.html)返回一个 http.client.HTTPResponse 对象, 这个对象又用到的read()方法;返回数据；这个函数返回一个 http.client.HTTPResponse 对象, 这个对象又有各种方法, 比如我们用到的read()方法； ### 查找可变网址： ~~~ import urllib import urllib.request data={} data['word']='one peace' url_values=urllib.parse.urlencode(data) url="http://www.baidu.com/s?" full_url=url+url_values a = urllib.request.urlopen(full_url) data=a.read() data=data.decode('UTF-8') print(data) ##打印出网址： a.geturl() ~~~ data是一个字典, 然后通过urllib.parse.urlencode()来将data转换为 ‘word=one+peace’的字符串, 最后和url合并为full_url ### python正则表达式介绍： ### 队列 介绍 在爬虫的程序中用到了广度优先级算法，该算法用到了数据结构，当然你用list也可以实现队列，但是效率不高。现在在此处介绍下： 在容器中有队列：collection.deque ~~~ #队列简单测试： from collections import deque queue=deque(["peace","rong","sisi"]) queue.append("nick") queue.append("pishi") print(queue.popleft()) print(queue.popleft()) print(queue) ~~~ ### 集合介绍： 在爬虫程序中, 为了不重复爬那些已经爬过的网站, 我们需要把爬过的页面的url放进集合中, 在每一次要爬某一个url之前, 先看看集合里面是否已经存在. 如果已经存在, 我们就跳过这个url; 如果不存在, 我们先把url放入集合中, 然后再去爬这个页面. Python 还 包 含 了 一 个 数 据 类 型—— set ( 集 合 ) 。 集 合 是 一 个 无 序 不 重 复 元素 的 集 。 基 本 功 能 包 括 关 系 测 试 和 消 除 重 复 元 素 。 集 合 对 象 还 支 持 union( 联 合),intersection(交),difference(差)和 sysmmetric difference(对称差集)等数学运算。 大括号或 set() 函数可以用来创建集合。 注意:想要创建空集合,你必须使用set() 而不是 {} 。{}用于创建空字典； 集合的创建演示如下： ~~~ a={"peace","peace","rong","rong","nick"} print(a) "peace" in a b=set(["peace","peace","rong","rong"]) print(b) #演示联合 print(a|b) #演示交 print(a&b) #演示差 print(a-b) #对称差集 print(a^b) #输出： {'peace', 'rong', 'nick'} {'peace', 'rong'} {'peace', 'rong', 'nick'} {'peace', 'rong'} {'nick'} {'nick'} ~~~ ### 正则表达式 在爬虫时收集回来的一般是字符流，我们要从中挑选出url就要求有简单的字符串处理能力，而用正则表达式可以轻松的完成这一任务； 正则表达式的步骤：1，正则表达式的编译 2，正则表达式匹配字符串 3，结果的处理 下图列出了正则表达式的语法：  在pytho中使用正则表达式，需要引入re模块；下面介绍下该模块中的一些方法； ### 1.compile和match re模块中compile用于生成pattern的对象，再通过调用pattern实例的match方法处理文本最终获得match实例；通过使用match获得信息； ~~~ import re # 将正则表达式编译成Pattern对象 pattern = re.compile(r'rlovep') # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None m = pattern.match('rlovep.com') if m: # 使用Match获得分组信息 print(m.group()) ### 输出 ### # rlovep ~~~ re.compile(strPattern[, flag]): 这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern’, re.I | re.M)与re.compile(‘(?im)pattern’)是等价的。 可选值有： re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同） M(MULTILINE): 多行模式，改变’^’和’$’的行为（参见上图） S(DOTALL): 点任意匹配模式，改变’.’的行为 L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。 Match: Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。 ~~~ 属性： string: 匹配时使用的文本。 re: 匹配时使用的Pattern对象。 pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。 lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。 lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。 方法： group([group1, …]): 获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。 groups([default]): 以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。 groupdict([default]): 返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。 start([group]): 返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。 end([group]): 返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。 span([group]): 返回(start(group), end(group))。 expand(template): 将匹配到的分组代入template中然后返回。template中可以使用\id或\g<id>、 \g<name>引用分组，但不能使用编号0。\id与\g<id>是等价的；但\10将被认为是第10个分组，如果你想表达 \1之后是字符'0'，只能使用\g<1>0。 ~~~ pattern: Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。 Pattern不能直接实例化，必须使用re.compile()进行构造。 ~~~ Pattern提供了几个可读属性用于获取表达式的相关信息： pattern: 编译时用的表达式字符串。 flags: 编译时用的匹配模式。数字形式。 groups: 表达式中分组的数量。 groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。 实例方法[ | re模块方法]： match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): 这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。 pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。 注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符'$'。 search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): 这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。 pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。 split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]): 按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。 findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]): 搜索string，以列表形式返回全部能匹配的子串。 finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]): 搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。 sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]): 使用repl替换string中每一个匹配的子串后返回替换后的字符串。 当repl是一个字符串时，可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。 当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。 count用于指定最多替换次数，不指定时全部替换。 subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]): 返回 (sub(repl, string[, count]), 替换次数)。 ~~~ ### 2.re.match(pattern, string, flags=0) 函数参数说明： | 参数 | 描述 | |-----|-----| | pattern | 匹配的正则表达式 | | string | 要匹配的字符串。 | | flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 | 匹配成功re.match方法返回一个匹配的对象，否则返回None。 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 | 匹配对象方法 | 描述 | |-----|-----| | group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 | | groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 | 演示如下： ~~~ #re.match. import re print(re.match("rlovep","rlovep.com"))##匹配rlovep print(re.match("rlovep","rlovep.com").span())##从开头匹配rlovep print(re.match("com","http://rlovep.com"))##不再起始位置不能匹配成功 ##输出： <_sre.SRE_Match object; span=(0, 6), match='rlovep'> (0, 6) None ~~~ 实例二：使用group ~~~ import re line = "This is my blog" #匹配含有is的字符串 matchObj = re.match( r'(.*) is (.*?) .*', line, re.M|re.I) #使用了组输出：当group不带参数是将整个匹配成功的输出 #当带参数为1时匹配的是最外层左边包括的第一个括号，一次类推； if matchObj: print ("matchObj.group() : ", matchObj.group())#匹配整个 print ("matchObj.group(1) : ", matchObj.group(1))#匹配的第一个括号 print ("matchObj.group(2) : ", matchObj.group(2))#匹配的第二个括号 else: print ("No match!!") #输出： matchObj.group() : This is my blog matchObj.group(1) : This matchObj.group(2) : my ~~~ ### 3re.search方法 re.search 扫描整个字符串并返回第一个成功的匹配。 函数语法： ~~~ re.search(pattern, string, flags=0) ~~~ 函数参数说明： | 参数 | 描述 | |-----|-----| | pattern | 匹配的正则表达式 | | string | 要匹配的字符串。 | | flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 | 匹配成功re.search方法返回一个匹配的对象，否则返回None。 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 | 匹配对象方法 | 描述 | |-----|-----| | group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 | | groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 | 实例一： ~~~ import re print(re.search("rlovep","rlovep.com").span()) print(re.search("com","http://rlovep.com").span()) #输出： import re print(re.search("rlovep","rlovep.com").span()) print(re.search("com","http://rlovep.com").span()) ~~~ 实例二： ~~~ import re line = "This is my blog" #匹配含有is的字符串 matchObj = re.search( r'(.*) is (.*?) .*', line, re.M|re.I) #使用了组输出：当group不带参数是将整个匹配成功的输出 #当带参数为1时匹配的是最外层左边包括的第一个括号，一次类推； if matchObj: print ("matchObj.group() : ", matchObj.group())#匹配整个 print ("matchObj.group(1) : ", matchObj.group(1))#匹配的第一个括号 print ("matchObj.group(2) : ", matchObj.group(2))#匹配的第二个括号 else: print ("No match!!") #输出： matchObj.group() : This is my blog matchObj.group(1) : This matchObj.group(2) : my ~~~ search和match区别： re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。 ### python爬虫小试牛刀 利用python抓取页面中所有的http协议的链接，并递归抓取子页面的链接。使用了集合和队列；此去爬的是我的网站，第一版很多bug； 代码如下： ~~~ import re import urllib.request import urllib from collections import deque #使用队列存放url queue = deque() #使用visited防止重复爬同一页面 visited = set() url = 'http://rlovep.com' # 入口页面, 可以换成别的 #入队最初的页面 queue.append(url) cnt = 0 while queue: url = queue.popleft() # 队首元素出队 visited |= {url} # 标记为已访问 print('已经抓取: ' + str(cnt) + ' 正在抓取 <--- ' + url) cnt += 1 try: #抓取页面 urlop = urllib.request.urlopen(url,timeout=10) except Exception: print("超时") continue #判断是否为html页面 if 'html' not in urlop.getheader('Content-Type'): continue # 避免程序异常中止, 用try..catch处理异常 try: #转换为utf-8码 data = urlop.read().decode('utf-8') except: continue # 正则表达式提取页面中所有队列, 并判断是否已经访问过, 然后加入待爬队列 linkre = re.compile("href=['\"]([^\"'>]*?)['\"].*?") for x in linkre.findall(data):##返回所有有匹配的列表 if 'http' in x and x not in visited:##判断是否为http协议链接，并判断是否抓取过 queue.append(x) print('加入队列 ---> ' + x) ~~~ 结果如下：  #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

> 在面向对象的语言中，类是最重要的一环，python自然拥有类这个机制。python的类机制，与C++，java的区别不是很大，类的大多数的重要特性都被沿用了，一样可以多态，抽象，封装； ### python3作用域： 在介绍类之前，首先介绍下一下关于python作用域的规则； 1.命名空间： 是从命名到对象的映射。当前命名空间主要是通过 Python 字典实现的,不过通常不关心具体的实现方式(除非出于性能考虑)； 以下有一些命名空间的例子: 内置命名(像 abs() 这样的函数,以及内置异常名)集,模块中的全局命名,函数调用中的局部命名。某种意义上讲对象的属性集也是一个命名空间。 关于命名空间需要了解的一件很重要的事就是不同命名空间中的命名没有任何联系,例如两个不同的模块可能都会定义一个名为 maximize 的函数而不会发生混淆–用户必须以模块名为前缀来引用它们。比如：math中有sin函数，可以通过math.sin调用； 2.作用域: 就是一个 Python 程序可以直接访问命名空间的正文区域。 这里的 直接访问 意思是一个对名称的错误引用会尝试在命名空间内查找。 一个例子： ~~~ def scope_test(): def do_local(): spam = "local spam"#局部变量 def do_nonlocal(): nonlocal spam spam = "nonlocal spam"#域变量，在整个函数域有效。 def do_global(): global spam spam = "global spam"# spam = "test spam"#全局变量，此处在函数域外有效； do_local() print("After local assignment:", spam) do_nonlocal() print("After nonlocal assignment:", spam) do_global() print("After global assignment:", spam) scope_test() print("In global scope:", spam)#全局变量作用域 ##输出： After local assignment: test spam After nonlocal assignment: nonlocal spam After global assignment: nonlocal spam In global scope: global spam ~~~ ### 类定义语法 类定义形式： ~~~ class className(superClass): <statement 1> ..... <statement N> ~~~ 类定义就像函数定义一样，要先执行才能生效。习惯上statement语句是函数定义，不过其他语句也可以。 进入类定义部分后会创建出一个新的命名空间，作为局部作用域，因此所有的赋值成为这个新命名空间的局部变量，特别时函数定义在此处绑定了新的名字 类定义完成时，就创建了一个类对象。也就是类名； ### 类对像： 类对象支持两种操作：属性应用和实例化. 属性应用使用:类名.属性；例如类定义如下： ~~~ class Myclass： "一个简单的类用于属性介绍" num=123 def fun(self): return 'hello world' ~~~ 那么我可以Myclass.num和Myclass.fun是有效的属性引用；分别返回一个整数，和一个方法对象； 类定义的实例化：类的实例话使用函数符号 ：类名（）； 例如：x=Myclass() 以上创建了一个新的类的实例，并将该对象赋值给了变量x。此去没有初始化； 很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 **init**() 的特殊方法,像下面这样: ~~~ def __init__(self): self.data = [] ~~~ 类定义了 **init**() 方法的话,类的实例化操作会自动为新创建的类实例调用**init**() 方法。所以在下例中,可以这样创建一个新的实例: x = MyClass() 当 然 , 出 于 弹 性 的 需 要 , **init**() 方 法 可 以 有 参 数 。 事 实 上 , 参 数 通 过**init**() 传递到类的实例化操作上。 ### 实例对象： 实例对象就是用来操作类的属性引用；有两种引用：数据和方法 数据：和java中的成员类似，其实就是变量；和局部变量一样，数据属性不需要声明，第一次使用他们时就会生成； 比如： ~~~ x=Myclass() #Myclass类中没有声明，可以直接使用； x.counter=1 ~~~ 方法：方法是属于一个类的函数，方法引用为：x.fun(); 也可以将方法引用赋值给变量这与函数赋值是一样的； xf=x.fun()#注意self参数，是对象实例化作为第一个参数传给变量的，不需要显示调用； ### 实例属性和类属性 1实例属性介绍： 给实例绑定属性的方法是通过实例变量，或者通过self变量： ~~~ class Student(object): def __init__(self, name): self.name = name s = Student('peace') s.score =40 ~~~ name和score都是实例属性； 2类属性： 可以直接在class中定义属性，这种属性是类属性，归类所有： ~~~ class student: name="peace" ~~~ name就是类属性，类的所有实例都可以访问到，并且是指向同一个对象； ### 继承： 没有继承就没有类，而python类的定义如下： ~~~ class className(superClass): <statement 1> ..... <statement N> ##其中className就是superclass的派生类。 ~~~ 实例介绍： ~~~ class Animal(object): def run(self): print('Animal is running...') class Dog(Animal): pass class Cat(Animal): pass ~~~ 1. 对于dog与cat来说，Animal就是它的父类。 1. 如果在子类中找不到请求调用的属性,就搜索基类。如果基类是由别的类派生而来,这个规则会递归的应用上去。现在Dog和Cat方法都可以调用run方法了。 1. 也可以增加方法： ~~~ class Dog(Animal): def see(self): print('see a dog') ~~~ 1. 多态(覆盖)： 派生类可以覆盖其基类的方法。因为方法调用同一个对象中的其它方法时没有特权,基类的方法调用同一个基类的方法时,可能实际上最终调用了派生类中的覆盖方 法。 ~~~ class Dog(Animal): def run(self): print('Dog is running...') class Cat(Animal): def run(self): print('Cat is running...') ~~~ 多态的好处: ~~~ def run_twice(animal): animal.run() animal.run() ##测试多态： >>> run_twice(Animal()) Animal is running... Animal is running... >>> run_twice(Dog()) Dog is running... Dog is running... ~~~ 对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则： 对扩展开放：允许新增Animal子类； 对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。 5.派生类的的实例化与普通类没有什么差别； Python 有两个用于继承的函数: ~~~ • 函数 isinstance() 用于检查实例类型: isinstance(obj, int) 只有在obj.__class__ 是 int 或其它从 int 继承的类型 • 函数 issubclass() 用于检查类继承: issubclass(bool, int) 为 True,因为 bool 是 int 的子类。但是, issubclass(unicode, str) 是 False因为 unicode 不是 str 的子类(它们只是共享一个通用祖先类 basestring)。 ~~~ ### 多重继承： python支持多重继承： ~~~ class className(superClass1，superClass1，superClass2.....): <statement 1> ..... <statement N> ##其中className就是superClass1，superClass1，superClass2.....的派生类。 ~~~ ### 私有变量： 只需要在数据或者方法前面加上__两个下划线就行，例如__spam。python独特的命名编码会将__spam替代为 _classname__spam 这样在外面就不能正常的 按照：类名.__spam进行调用了。但是写全的话替代为 类名. _classname__spam还是可以的，这时python的缺陷 ~~~ class Student(object): def __init__(self, name, score): self.__name = name self.__score = score def print_score(self): print('%s: %s' % (self.__name, self.__score)) ~~~ 对于外部代码来说，是无法从外部访问实例变量.__name和实例变量.__score了 ### 异常也是类： 可以自己定义异常的派生类，通过rasie进行抛出； 有两种抛出方式： 1.raise Classname（）定义的派生类； 2.raise 实例；由异常类实例话而来； 演示如下： ~~~ class B(Exception): pass class C(B): pass class D(C): pass for cls in [B, C, D]: try: raise cls() except D: print("D") except C: print("C") except B: print("B") ~~~ 要 注 意 的 是 如 果 异 常 子 句 的 顺 序 颠 倒 过 来 ( execpt B 在 最 前 ) , 它 就 会 打 印B,B,B–第一个匹配的异常被触发。 #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

> 之前介绍python的数据结构时，没有介绍set（集合）现在在这里稍微介绍下： ### set原理 Python 还 包 含 了 一 个 数 据 类 型—— set ( 集 合 ) 。 集 合 是 一 个 无 序 不 重 复 元素 的 集 。 基 本 功 能 包 括 关 系 测 试 和 消 除 重 复 元 素 。 集 合 对 象 还 支 持 union( 联 合),intersection(交),difference(差)和 sysmmetric difference(对称差集)等数学运算。 大括号或 set() 函数可以用来创建集合。 注意:想要创建空集合,你必须使用set() 而不是 {} 。{}用于创建空字典； 集合的创建演示如下： ~~~ a={"peace","peace","rong","rong","nick"} print(a) "peace" in a b=set(["peace","peace","rong","rong"]) print(b) #演示联合 print(a|b) #演示交 print(a&b) #演示差 print(a-b) #对称差集 print(a^b) #输出： {'peace', 'rong', 'nick'} {'peace', 'rong'} {'peace', 'rong', 'nick'} {'peace', 'rong'} {'nick'} {'nick'} ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

> 相信大家学习过其他语言，懂得函数的作用。简单的说函数最好的作用就是可以使程序变得懒惰。python作为后起之秀，当然也会拥有函数这个有用的东西； ### 创建函数 使用def语句即可创建函数，如创建一个用来生成指定边界的斐波那契数列的函数: ~~~ #!/usr/bin/env python3 def fib(n):#使fibonacci数列到达n '打印fibonacci数列到n' a,b=0,1 while a<n: print(a,end=' ') a,b=b,a+b fib(20) 0 1 1 2 3 5 8 13 ~~~ 关键字 def 引入了一个函数 定义 。在其后必须跟有函数名和包括形式参数的圆括号。函数体语句从下一行开始,必须是缩进的。 ### 有关事项详解： ### 文档化函数 函数体的第一行语句可以是可选的字符串文本,这个字符串是函数的文档字符串,或者称为 docstring 。使用如下方式可以查看： ~~~ print(fib.__doc__) 打印fibonacci数列到n ~~~ ### 参数的传递 函数 调用 会为函数局部变量生成一个新的符号表。 确切的说,所有函数中的变量赋值都是将值存储在局部符号表。 变量引用首先在局部符号表中查找,然后是包含函数的 局部符号表,然后是全局符号表,最后是内置名字表。 因此,全局变量不能在函数中直接赋值(除非用 global 语句命名),尽管他们可以被引用。 函数引用的实际参数在函数调用时引入局部符号表,因此,实参总是 传值调用 (这里的 值 总是一个对象 引用 ,而不是该对象的值)。 1 一个函数被另一个函数调用时, 一个新的局部符号表在调用过程中被创建。 ### 函数名可以赋予其他名字 函数名可以重命名： ~~~ f=fib f(100) 0 1 1 2 3 5 8 13 21 34 55 89 ~~~ 可能有人误会说fib（）函数没有返回值，千万注意这里使用的是函数名，没有使用函数调用；事实上fib（）确实返回了一个空值，未加return语句返回的时None；可以使用下方法查看： ~~~ print(fib(10)) 0 1 1 2 3 5 8 None ~~~ ### 深入理解python3函数定义 在python中，你也可以定义包含若干参数的函数，这里有三种可用的形式，可以混合使用： ### 默认参数值： 默认参数的定义方法如下： ~~~ def f(a,b,x=3,y=5): '测试默认参数' print(a,b,x,y) ~~~ 上面的函数中参数a和b是必要参数，而参数x和y是可选参数，有自己的默认值； 这个函数可以通过几种不同的方式调用： 只给出必要参数： f(1,2) 给出一个可选的参数： f(1,2,4) 给出所有参数： f(1,2,4,6) 注意： 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同,比如列表、字典或者大多数类的实例。例如,下面的函数在后续调用过程中会累积(前面) 传给它的参数: ~~~ def f(a, L=[]): L.append(a) return L print(f(1)) print(f(2)) print(f(3)) #输出 [1] [1, 2] [1, 2, 3] ~~~ 如果你不想让默认值在后续调用中累积,你可以像下面一样定义函数: ~~~ def f(a, L=None): if L is None: L = [] L.append(a) return L ~~~ ### 关键字参数: 有些时候函数的参数顺序是很难记忆的，为了让事情简单些，可以在调用时提供参数的名字： ~~~ def f(a,b,x=3,y=5): '测试关键字参数' print(a,b,x,y) #普通调用 f(1,2) #关键字调用 f(a=1,b=2,y=6) f(1,2,y=3) #输出 1 2 3 5 1 2 3 6 1 2 3 3 ~~~ 注意：当使用了关键字后必须一直使用不然会报错： 比如下： f(a=1,2) SyntaxError: non-keyword arg after keyword arg ### 可变参数列表： 可以让函数调用可变个数的参数，这些参数被包装进一个元组或者字典。 可变参数定义方式：只需在参数前面加上×号，参数被包装在元祖中 ~~~ def print_params(title,*params): print(title) print(params) ~~~ 可以和普通参数联合使用，×号收集的时其余的位置参数如： print_params(“peace”,23,170) 。如果不提供任何收集的元素，params时个空元祖：() 如： print_params(“pp”) 同样还可以处理关键字参数，定义如下:只需在关键字参数前面加上××号，被包装在字典中； ~~~ def print_params(title,**params): print(title) print(params) ~~~ 调用时必须注明关键字参数。可以这样调用： print_params(“peace”,age=23,high=170) print_params(“pp”) ### 参数列表的分拆 与可变参数刚好相反， 当你要传递的参数已经是一个列表,但要调用的函数却接受分开一个个的参数值。这时候你要把已有的列表拆开来 你可以在调用时加一个×操作符来自动把参数列表拆开：比如range（）： ~~~ >>> list(range(1,10)) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> args=[1,10] >>> list(range(*args)) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> ~~~ 以同样的方式,可以使用 **操作符分拆关键字参数为字典: ### Lambda 形 式 出于实际需要,有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了 Python。通过 lambda 关键字,可以创建短小的匿名函数。这里有一个函数返回它的两个参数的和: lambda a, b: a+b 。 Lambda 形式可以用于任何需要的函数对象。出于语法限制,它们只能有一个单独的表达式。语义上讲,它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义,lambda 形式可以从外部作用域引用变量: ~~~ def fun(n): '下面x是参数，x+n是返回值' return lambda x: x+n #f接收lambda返回的函数 f=fun(10) print(f(0)) print(f(10)) #输出： 10 20 ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

> 本节主要介绍python中循环语句的用法以及其他一些语句exec等，文章后面附有之前的文章； # 循环语句 if是值执行一次而循环时在条件满足情况下可以执行相同语句多次；使用循环可以轻松实现序列，词典等的迭代； ### while循环： 用来在任何条件为真的情况下重复执行一个代码快： while i>0: ~~~ 代码快 ~~~ 其他代码； 演示如下： ~~~ >>>i=10 >>> while i>0: ... print("i=",i) ... i-=1 ... i= 10 i= 9 i= 8 i= 7 i= 6 i= 5 i= 4 i= 3 i= 2 i= 1 >>> ~~~ ### for循环： 一般while循环已经满足我们要求了，但是有些时候还得去选择for循环更加有效；比如要为一个集合（序列和其他可迭代对像）的每个元素都执行一个代码快。这时候可以使用for语句； 基本形式： for <迭代数> in <对象集合>： ~~~ >>> name=("peace","rong","nick") >>> for i in name: ... print(i) ... peace rong nick >>> ~~~ ### 一些迭代工具 之前讲解字典时有讲过字典的迭代，现在介绍一下常用的迭代工具； ### 并行迭代 程序可以同时迭代两个序列 内建函数zip函数可以用来进行并行迭代，这里需要注意的是python2返回的是元祖列表，而python3中返回的是可迭代对象 ~~~ ##python2.7 >>> num = zip((1, 2), (3, 4)) >>> num [(1, 2), (3, 4)] #返回的是元祖列表； ##python3.4 >>> num=zip((1,2),(3,4)) >>> num <zip object at 0x7fc5b1e7ef08> >>> #返回的是一个对象，并且支持一次遍历。如果需要重新遍历得重新赋值一次； #但是都支持如下的遍历： >>> for i,j in num: ... print(i,j) ... 1 3 2 4 ~~~ 当然也可以按索引迭代： 有些时候需要访问序列中的对象，同时还想获取当前对象的索引，例如替换字符串可以使用下面的方法： ~~~ >>> strings=["peace","rong","nick"] >>> index=0 >>> for string in strings: ... if "on" in string: ... strings[index]="peace" ... index+=1 ... >>> strings ['peace', 'peace', 'nick'] >>> ~~~ ### 跳出循环： 1.break语句 与其他自然语言c等没有差别；就是结束循环； 2。continue语句： 同样它只是让当次迭代提前结束： 演示如下： ~~~ >>> num=[2,4,5,6,] >>> for i in num: ... if i==5: ... break ... print (i) ... 2 4 >>> for i in num: ... if i==5: ... continue ... print(i) ... 2 4 6 >>> ~~~ ### 循环中的else语句： else子句可以加在循环后，他仅在没有调用break语句时执行：还是刚在的例子： ~~~ >>> num=[2,4,5,6] >>> for i in num: ... if i==7: ... break ... else: ... print("not 7") ... not 7 #没有执行break打印7 ~~~ ### 列表推导式 列表推导式就是利用其他的列表创建新的列表；他的工作方式类似于for循环也很简单； 例如：创建由range（10）中每个x的平方组成； ~~~ >>> [x*x for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ~~~ 同样也可以加条件：比如创建只能被4整除的平方数： ~~~ >>> [x*x for x in range(10) if x%4==0] [0, 16, 64] >>> ~~~ 也可以增加更多的for： ~~~ >>> [[x*x,y*y] for x in range(10) for y in range(10) if x%4==0 if y%3==0] [[0, 0], [0, 9], [0, 36], [0, 81], [16, 0], [16, 9], [16, 36], [16, 81], [64, 0], [64, 9], [64, 36], [64, 81]] >>> ~~~ ### pass,del,exec介绍 ### python3中pass pass语句就是什么都不做，让程序往下执行：比如可以让if，for，while，等块什么都不做时，我们可以加上pass ~~~ >>> for i in range(10): ... File "<stdin>", line 2 ^ IndentationError: expected an indented block >>> for i in range(10): ... pass ... >>> #从上可以看到不加pass就出错了。因为python时不允许空块存在的； >>> x=11 >>> if x>12: ... print("x>12") ... else: ... #等下在写 ... pass ... >>> ~~~ ### python3中del del删除语句不仅会删除一个对象的引用，也会删除那个名字本省：演示如下 ~~~ >>> x=1 >>> del x >>> x Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'x' is not defined >>> #x这个名字已经不存在了 ~~~ 但是当两个引用指向同一个对象时，删掉的只是引用名： ~~~ #删掉y后x还是指向原来的对象； >>> x=[1,2] >>> y=x >>> y[1]=4 >>> x [1, 4] >>> del y >>> x [1, 4] >>> ~~~ ### python3中exec和eval 有些时候我们可能想要得到动态代码，然后将其作为语句执行或作为表达式计算； 例如执行一个字符串的语句是exec ~~~ >>>exec("print(1+3)") 4 ~~~ 当在字符串中定义变量时一定要小心；如果重名了就会发生不必要的错误；可以通过in来解决，起到了放置代码字符串命名空间的字典； 例如： ~~~ >>>from math import sin >>>scope={} >>>exec("sqrt=1") in scope >>>sqrt(4) 2 >>>scope['sqrt'] 1 ~~~ eval是类似于exec的内建函数，只不过是eval会计算表达式，并且返回结果；同样可以使用命名空间； 简单演示如下 ~~~ >>>eval(input("enter an expression:")) enter an expression:6+8*2 42 ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://www.cnblogs.com/onepeace/) > 本节主要介绍pythonif条件语句，以及用法。下面附有之前的文章； # 语句快介绍 语句快并非一种语句，是通过缩进形成的语句集合； 可以使用的缩进符：TAb建（相当于四个空格），4个空格，8个空格，可以成倍增加形成嵌套语句快； 一般来说使用四个空格是最规范的。 功能：语句快是在条件为真时执行（if）或执行多次（循环）的一组语句； ~~~ #伪代码 this is a line this is a condition: this is a block ..... there wo escaped the inner block ~~~ # 条件和条件语句 ### 布尔型介绍 假（false）：会被看做假的值： FALSE ,None ,0 ,‘ ’ (没有空格) ,“ ” (没有空格) ,（） ,[] ,{} 真（true）：其他的都会被判定为真： 测试如下： ~~~ #假 >>> bool(False) False >>> bool(None) False >>> bool('') False >>> bool("") False >>> bool() False >>> bool([]) False >>> bool(()) False >>> bool({}) False >>> #真 >>> bool(True) True >>> bool('ddd') True >>> bool(1) True >>> bool([1]) True >>> bool((1)) True >>> bool({1}) True >>> ~~~ ### 条件执行和if语句 ### if语句 if语句可以实现条件执行，如果条件判定为真，则后面的语句块执行，如果条件为假，语句块就不会被执行。 ~~~ #如果用户输入：0-9 就打印True >>> x=int(input("Please enter an integer in 0-9 ")) Please enter an integer in 0-9 6 if 0<x<9: print(True) True ~~~ ### else语句 else子句（之所以叫子句，是因为它不是独立的语句，而只能作为if语句的一部分）当条件不满足时执行； ~~~ #如果用户输入：0-9 就打印True,不在之类输出 False >>> x=int(input("Please enter an integer in 0-9 ")) Please enter an integer in 0-9 11 >>> if 0<x<9: ... print(True) ... else: ... print(False) ... False ~~~ ### elif语句 如果需要检查多个条件，就可以使用elif，它是“else if”的简写，也是if和else子句的联合使用——也就是具有条件的else子句。 ~~~ #如果用户输入在0-9：就打印in 0-9 ,否则如果输出大于9：就打印 >9，否则打印：<0 >>> x=int(input("Please enter an integer in 0-9 ")) Please enter an integer in 0-9 -1 >>> if 0<x<9: ... print("in 0-9") ... elif x>9: ... print(">9") ... else: ... print("<0") ... <0 >>> ~~~ ### 嵌套if语句 if语句里可以嵌套使用if语句： ~~~ x=int(input("Please enter an integer in 0-9 ")) if x>=0: if x>9: print("x>9") elif x==0: print("x==0") else: print('x<0') Please enter an integer in 0-9 0 x==0 ~~~ ### 更复杂的条件： ### 条件运算符一览： ~~~ #比较运算符 x==y x等于y x<y x小于y x>y x大于y x>=y x大于等于y x<=y x小于等于y x!=y x不等于y a<x<b x大于a小于b #同一性运算符 x is y x和y是同一个对象 x is not y x和y是不同的对象 #成员资格运算符 x in y x是y容器的成员 x not in y x不是y容器的成员 ~~~ 同一性运算符说明： 看以来和==一样实际是时不同的，只有两个绑定在相同的对象时才是真（当然当为数值变量时是和==相同的）： ~~~ #a与b不时指向同一对象 >>> a=[1,2] >>> b=[1,2] >>> a is b False #a与b指向同一对象 >>> a=b=[1,2] >>> a is b True ~~~ in成员资格运算符说明 ~~~ #成员在序列中返回真 >>> a=[1,2,3] >>> b=1 >>> c=4 >>> b in a True >>> c in a False >>> ~~~ ### 逻辑运算符： and ：x and y 返回的结果是决定表达式结果的值。如果 x 为真，则 y 决定结果，返回 y ；如果 x 为假，x 决定了结果为假，返回 x。 or ：x or y 跟 and 一样都是返回决定表达式结果的值。 not : 返回表达式结果的“相反的值”。如果表达式结果为真，则返回false；如果表达式结果为假，则返回true。 ~~~ >>> a=1 >>> b=2 >>> a and b 2 >>> a=1 >>> b=0 >>> a and b 0 >>> a or b 1 >>> not b True >>> ~~~ # 断言简介 if语句有个非常有用的近亲，其工作方式多少有点像下面这样（伪代码）： if not condition: crash program 这样做是因为与其让程序在晚些时候崩溃，不如在错误条件出现时直接让它崩溃。一般来说，你可以要求某些条件必须为真。语句中使用的关键字为assert。 如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert语句就有用了，可以在程序中置入检查点： 条件后可以添加字符串（用逗号把条件和字符串隔开），用来解释断言： ~~~ >>> age=-1 >>> assert 0<age<150,"The age must be realistic" Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: The age must be realistic >>> >>> age=10 >>> assert 0<age<150,"The age must be realistic" >>> ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://www.cnblogs.com/onepeace/) > 本节主要介绍赋值语句，以及几种特殊的赋值。下面附有之前的文章； # 简要介绍下赋值语句 在 python 中赋值语句总是建立对象的引用值，而不是复制对象。因此，python 变量更像是指针，而不是数据存储区域 Python 没有「变量」，我们平时所说的变量其实只是「标签」，是引用。 执行 values=[‘a’,’b’,’c’] 的时候，Python 做的事情是首先创建一个列表对象[‘a’,’b’,’c’]，然后给它贴上名为 values 的标签。如果随后又执行 values=[‘d’,’e’,’f’] 的话，Python 做的事情是创建另一个列表对象[‘d’,’e’,’f’]，然后把刚才那张名为 values 的标签从前面的[‘a’,’b’,’c’] 对象上撕下来，重新贴到 [‘d’,’e’,’f’] 这个对象上。 ### 直接赋值 语句格式：变量名称 = 对象 ~~~ >>> name='peace' >>> age=22 >>> print(name,age) peace 22 >>> ~~~ ### 序列解包 序列解包又称递归解包，将多个值的序列解开放到变量的序列中 ~~~ >>> value=1,2,3 >>> value (1, 2, 3) >>> x,y,z=value >>> x 1 >>> y 2 >>> z 3 >>> ##交换变量的值可以直接进行 >>> x,y=y,x >>> x 2 >>> y 1 >>> ~~~ 当函数返回的树序列时序列解包显得非常有用；比如如下： ~~~ #从字典中弹出任意一对儿键值对儿，并赋值给两个变量 >>> studentId={'peace':'201421014960','nick':'2014'} >>> key,value=studentId.popitem() >>> key 'nick' >>> value '2014' >>> ~~~ ### 连续赋值 同时将一个变量赋值给多个变量； ~~~ >>> peace=[1,2,3,4] >>> x=y=z=peace[2] >>> x 3 >>> y 3 >>> z 3 >>> ~~~ ### 表达式赋值 包括以下表达式赋值： +=:将右侧的值加到变量上的和，然后再赋值给变量； -=:将变量减去右侧的值得到的差，再赋值给变量； /=:用变量除以右侧值得到的商，再赋值给变量； %=:用变量取右侧值的余数，再赋值给变量； ~~~ >>> x=1 >>> x+=2 >>> x 3 >>> x*=2 >>> x 6 >>> x-=3 >>> x 3 >>> x/=3 >>> x 1.0 >>> x*=5 >>> x 5.0 >>> x%=3 >>> x 2.0 >>> ~~~ ### 引用和拷贝 ### 浅复制： 主要的浅复制方法： （1）没有限制条件的分片表达式（L[:]）能够复制序列，但此法只能浅层复制。 （2）字典 copy 方法，D.copy() 能够复制字典，但此法只能浅层复制 对于不可变对象和可变对象来说，浅复制都是复制的引用，只是因为复制不变对象和复制不变对象的引用是等效的（因为对象不可变，当改变时会新建对象重新赋值）。所以看起来浅复制只复制不可变对象（整数，实数，字符串等），对于可变对象，浅复制其实是创建了一个对于该对象的引用，也就是说只是给同一个对象贴上了另一个标签而已。 ~~~ #直接赋值的浅复制 >>> a=[1,2,3] >>> b=a >>> b[1]=1 >>> b [1, 1, 3] >>> a [1, 1, 3] >>> ##L[:] >>> a=[1,[2,3],3] >>> b=a[:] >>> a[0]=2 >>> a[1][1]=8 >>> a [2, [2, 8], 3] #b的第二个元素跟着改变了 >>> b [1, [2, 8], 3] >>> ~~~ ### 深度复制（拷贝） 主要的方法： 有些内置函数，例如 list，能够生成拷贝 list(L) copy 标准库模块能够生成完整拷贝：deepcopy 本质上是递归 copy ~~~ >>> import copy >>> a=[1,[2,3],3] >>> b=copy.deepcopy(a) >>> a[0]=2 >>> a[1][1]=8 >>> a [2, [2, 8], 3] >>> b [1, [2, 3], 3] >>> ~~~ 这里对引用和拷贝只是简单的介绍，后面讲到对象会继续深究 #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://www.cnblogs.com/onepeace/) > 本节主要介绍print,import和input,t函数，包括他们在python2.7和python3 的区别以及用法。下面附有之前的文章； # python3的print函数的变化 python3之前的print是简单的语句比如要打印hello world ~~~ >>> print 'hello world' hello world >>> ~~~ 而python3之后的版本中print已经变为了函数。比如要打印必须加上();如下： ~~~ #直接按语句打印会出现错误： peace@peace:~$ python Python 3.4.3 (default, Mar 26 2015, 22:03:40) [GCC 4.9.2] on linux Type "help", "copyright", "credits" or "license" for more information. >>> print 'hello world' File "<stdin>", line 1 print 'hello world' ^ SyntaxError: Missing parentheses in call to 'print' #应该用函数打印 >>> print ('hello world') hello world >>> ~~~ # print函数的功能 **注意（python3之前的print语句功能基本没有变）** ### 使用逗号输出： 使用print时，也可以在语句中添加多个表达式，每个表达式用逗 号分隔；在用逗号分隔输出时，print语句会在每个输出项后面自动添加一 个空格； 注意：不管时字符串还是其他类型都是转化为字符串进行打印 ~~~ >>> print('peace',22) peace 22 >>> print(1,2,3) 1 2 3 #输出元祖必须这样输出； >>> print((1,2,3)) (1, 2, 3) >>> #变量也是可以的 >>> name='peace' >>> print(name,22) peace 22 >>> #可以使用‘+’连接字符串 >>> print('hello'+','+'peace') hello,peace >>> #如果在结尾加上逗号，name接下来的语句会与前一行、打印在一行；（python3之前才有效） #建立douhao.py在里面输入 print 'peace', print 22 #在输入如下语句即可： peace@peace:~/workspace/python$ python2.7 douhao.py peace 22 ~~~ # import函数 ### 导入格式 将整个模块导入，格式为：import somemodule; 从某个模块中导入某个函数,格式为：from somemodule import somefunction; 从某个模块中导入多个函数,格式为：from somemodule import firstfunc, secondfunc, thirdfunc 将某个模块中的全部函数导入，格式为：from somemodule import * ### 两个模块同名函数解决办法 1导入模块使用模块名进行调用； ~~~ #导入模块 import module1 import module2 #调用同名函数的方法 module1.open() module2.open() ~~~ 2使用关键字as进行改名 ~~~ #导入函数，并给函数取相应的别名 from module1 import open as open1 from module2 import open as open2 ~~~ 3例子 ~~~ >>> from cmath import cos as s >>> from math import cos as c >>> s(30) (0.15425144988758405+0j) >>> c(30) 0.15425144988758405 >>> ~~~ # input函数 Python3中用input()取代了raw_input()，当然这仅仅是重命名，使用上并没有不同；python3之前的input()不再取用； input（）函数不管你输入什么返回的是字符串； ~~~ #与python3之前的raw_input()相同 >>> k=input('intput int ') intput int 12 >>> k '12' >>> ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://www.cnblogs.com/onepeace/) > 本节主要介绍字典，字典也成映射，时python中唯一内建的映射类型。更多详细请点击readmore。下面附有之前的文章； # 字典的介绍与作用 在元组和列表中，都是通过编号进行元素的访问，但有的时候我们按名字进行数据甚至数据结构的访问，在c++和java中有map的概念，也就是映射。同样在python中也提供了内置的映射类型–字典。映射其实就是一组键（key）和值（value）以及之间的映射函数。键可以是数字、字符串甚至是元组。 **字典类型与序列类型的区别：** 1.存取和访问数据的方式不同。 2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）； 3.映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同. 4.映射类型的键直接或间接地和存储数据值相关联。 5.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。 6.映射类型用键直接“映射”到值。 # 创建字典 简单地说字典就是用大括号包裹的键值对的集合。 **1可以通过一下方式创建：** 字典由多个键及与其对应的值构成的对组成。每个键和它的值之间用冒号（：）隔开，项之间用逗号（，）隔开，而整个字典是由一对大括号括起来。 字典中的键必须是唯一的，而值可以不唯一。 ~~~ >>> student_id={'peace':'201421014960','nick_peace':'201421014970','nicl_peace2':'201421014980'} >>> student_id {'peace': '201421014960', 'nicl_peace2': '201421014980', 'nick_peace': '201421014970'} >>> student_id['peace'] '201421014960' ~~~ **2可以通过dict函数创建** 用 dict 函数，通过其他映射（比如其他字典）或者（键，值）这样的序列对建立字典。 ~~~ #通过序列创建 >>> items=[('peace','201421014960'),('nick_peace','201421014970')] >>> student_id=dict(items) >>> student_id['nick_peace'] '201421014970' >>> #也可以通过关键字参数来创建 >>> student_id=dict(peace='201421014960',age=23) >>> student_id {'age': 23, 'peace': '201421014960'} >>> ~~~ # 字典基本操作 ##字典的基本行为在很多方面与序列类似： （1）len(d) 返回 d 中项（键-值对）的数量 （2）d[k] 返回关联到键 k 上的值 （3）d[k] = v 将值 v 关联到键 k 上 （4）del d[k] 删除键为 k 的项 （5）k in d 检查 d 中是否有含有键为 k 的项 ~~~ >>> student_id={'peace':'201421014960','nick_peace':'201421014970','nicl_peace2':'201421014980'} >>> len(student_id) 3 >>> student_id['nick_peace'] '201421014970' >>> student_id['nick_peace']=2014 >>> student_id {'peace': '201421014960', 'nicl_peace2': '201421014980', 'nick_peace': 2014} >>> del student_id['nick_peace'] >>> student_id {'peace': '201421014960', 'nicl_peace2': '201421014980'} >>> 'peace' in student_id True >>> 'nick_peace' in student_id False ~~~ ### 注意： 尽管字典和列表有很多特性相同，但也有下面一些重要的区别。 （1）键类型：字典的键不一定为整型数据（但也可能是），也可能是其他不可变类型，比如浮点型（实型）、字符串或者元组。 （2）自动添加：即使那个键起初在字典中并不存在，也可以为它分配一个值，这样字典就会建立新的项。 （3）成员资格：表达式 k in d (d 为字典) 查找的是键，而不是值。 例如： ~~~ >>> item=[] >>> item[1]=23 Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list assignment index out of range >>> item={} >>> item[1]=23 >>> item {1: 23} >>> ~~~ # 字典的格式化字符串 在每个转换（conversion specifier）中的 % 字符后面，可以加上用圆括号括起来的键，后面再跟上其他说明元素。 ~~~ >>> student_id={'peace':'201421014960','nick_peace':'201421014970','nicl_peace2':'201421014980'} >>> "peace's student id is %(peace)s." % student_id "peace's student id is 201421014960." >>> ~~~ 只要所有给出的键都能在字典中找到，就可以获得任意数量的转换说明符。这类字符串格式化在模板系统中非常有用： ~~~ >>> template = '''<html> ... ... <head><title>%(title)s</title></head> ... ... <body> ... ... <h1>%(title)s</h1> ... ... <p>%(text)s</p> ... ... </body>''' >>> data = {'title':'My Home Page', 'text':'Welcome to my home page!'} >>> print(template % data) <html> ... <head><title>My Home Page</title></head> ... <body> ... <h1>My Home Page</h1> ... <p>Welcome to my home page!</p> ... </body> >>> ~~~ # 字典方法 就像其他内建类型一样，字典也有方法，这些方法非常有用；下面对一些方法进行讲解 ### clear方法 clear 方法清除字典中所有的项。这是个原地操作，所以无返回值（或者说返回 None）。 ~~~ >>> student_id={'peace':'201421014960','nick_peace':'201421014970','nicl_peace2':'201421014980'} >>> student_id.clear() >>> student_id {} >>> ~~~ ### copy方法 copy 方法返回一个具有相同键-值对的新字典(这个方法实现的是浅复制（shallow copy），因为值本身就是相同的，而不是副本)。 ~~~ >>> student_id={'peace':'201421014960','nick_peace':'201421014970','pp':['p1','p2','p3']} >>> stucopy=student_id.copy() >>> stucopy['peace']='22222' >>> stucopy['pp'].remove('p2') >>> stucopy {'peace': '22222', 'nick_peace': '201421014970', 'pp': ['p1', 'p3']} >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p3'], 'nick_peace': '201421014970'} >>> ~~~ 上面，当在 y 中替换值的时候，x 不受影响，但是，如果修改了某个值（原地修改，而不是替换），x 也会改变，因为同样的值也存储在原字典中。 避免这个问题的一种方法就是使用深复制( deep copy)，复制其包含所有的值。可以使用 copy 模块的 deepcopy 函数来完成操作。 ~~~ >>> from copy import deepcopy >>> student_id={'peace':'201421014960','nick_peace':'201421014970','pp':['p1','p2','p3']} >>> stucopy=deepcopy(student_id) >>> stucopy['peace']='22222' >>> stucopy['pp'].remove('p2') >>> stucopy {'peace': '22222', 'nick_peace': '201421014970', 'pp': ['p1', 'p3']} >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} ~~~ ### fromkeys方法 fromkeys 方法使用给定的键建立新的字典，每个键默认对应的值为 None。 ~~~ #空字典建立 >>> {}.fromkeys(['peace','nixk']) {'peace': None, 'nixk': None} #直接在所有字典的类型 dict 上面调用方法 >>> dict.fromkeys(['peace','nixk']) {'peace': None, 'nixk': None} #不想使用None作为默认值，也可以自己提供默认值。 >>> dict.fromkeys(['peace','nixk'],'(handsome)') {'peace': '(handsome)', 'nixk': '(handsome)'} ~~~ ### get方法 get方法和的d[key]类似 ~~~ #当使用 get 访问一个不存在的键时，没有任何异常，而得到了 None 值。 >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> print(student_id['pp']) ['p1', 'p2', 'p3'] >>> print(student_id['pp1']) Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'pp1' >>> print(student_id.get('pp1')) None #可以定义“默认”返回值，替换 None： >>> print(student_id.get('pp1','N/A')) N/A #如果键存在，get用起来就像普通的字典查询一样。 >>> print(student_id.get('pp','N/A')) ['p1', 'p2', 'p3'] >>> ~~~ ### items方法 items 方法将所有的字典项以dict_items 方式返回，这些列表项中的每一项都来自于（键，值） ~~~ >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> student_id.items() dict_items([('peace', '201421014960'), ('pp', ['p1', 'p2', 'p3']), ('nick_peace', '201421014970')]) ~~~ ### keys方法 keys 方法将字典中的键以 dict_keys 形式返回。 ~~~ >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> student_id.keys() dict_keys(['peace', 'pp', 'nick_peace']) >>> ~~~ ### pop方法和popitem pop 方法用来获得对应于给定键的值，然后将这个键-值对从字典中移除。 ~~~ >>> student_id {'peace': '201421014960', 'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> student_id.pop('peace') '201421014960' >>> student_id {'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> ~~~ popitem 弹出随机的项和将这个键-值对从字典中移除。 ~~~ >>> student_id {'pp': ['p1', 'p2', 'p3'], 'nick_peace': '201421014970'} >>> student_id.popitem() ('pp', ['p1', 'p2', 'p3']) >>> student_id.popitem() ('nick_peace', '201421014970') >>> student_id {} >>> ~~~ ### setdefaut方法 setdefault 方法在某种程度上类似于 get 方法，就是能够获得与给定键相关联的值，除此之外，setdefault 还能在字典中不含有给定键的情况下设定相应的键值。当键不存在的时候，setdefault 返回默认值并且相应地更新字典。如果键存在，那么就返回与其相应的值，但不改变字典。 ~~~ >>> d = {} >>> d.setdefault('name', 'N/A') 'N/A' >>> d {'name': 'N/A'} >>> d['name'] = 'Gumby' >>> d.setdefault('name', 'N/A') 'Gumby' >>> d {'name': 'Gumby'} ~~~ ### update方法 update 方法可以利用一个字典项更新另一个字典。 ~~~ >>> d={'peace':'2222222',"pp":111} >>> x={'peace':'201421014960'} >>> d.update(x) >>> d {'peace': '201421014960', 'pp': 111} >>> ~~~ ### value方法 values 方法以 dict_values 的形式返回字典中的值。 ~~~ >>> d {'peace': '201421014960', 'pp': 111} >>> d.values() dict_values(['201421014960', 111]) >>> ~~~ # 字典的遍历 ### 遍历字典的值 for value in adict.values(): ~~~ >>> d {'1': 2, '3': 4, '5': 6} >>> for i in d.values():print(str(i)) ... 2 4 6 >>> ~~~ ### 遍历字典的键 for key in adict.keys(): ~~~ >>> d {'1': 2, '3': 4, '5': 6} >>> for i in d:print(str(i)) ... 1 3 5 >>> for i in d.keys():print(str(i)) ... 1 3 5 >>> ~~~ ### 遍历字典的项 for item，value in adict.items(): ~~~ >>> d {'1': 2, '3': 4, '5': 6} >>> for key,values in d.items():print(str(key)+","+str(values)) ... 1,2 3,4 5,6 >>> ~~~ 字典就讲到这里； #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://www.cnblogs.com/onepeace/) > 经过前面的介绍相信大家也对python有了一个初步的了解；本节主要介绍字符串，不管学习什么编语言字符串一定在其中扮演着重要的地位。本节主要讲解，字符串的定义以及怎么使用字符串； # 字符串简介 字符串是一种序列，用于表示和存储文本。python中字符串一旦声明，就不能改变。所以也称为字符串常量； python实际的三类字符串： 1.单双引号字符串： ~~~ >>> 'peace' 'peace' >>> "peace" 'peace' >>> ~~~ 2.三引号字符串和转义字符串，raw原始字符串: 三引号字符串是可以换行；raw原始字符串是不进行转义； ~~~ #三引号字符串 >>> '''peace ... peace ... peace''' 'peace\npeace\npeace' #转义字符串 >>> 'Im'peace' File "<stdin>", line 1 'Im'peace' ^ SyntaxError: invalid syntax >>> 'Im\'peace' "Im'peace" >>> #原始字符串 不进行转义： >>> print (r"c:\peace\n") c:\peace\n >>> print ("c:\peace\n") c:\peace ~~~ 3Unicode字符串： ~~~ >>> print(u'peace\u0020one') peace one >>> ~~~ # 基本字符串操作 前面将的所有标准序列操作（索引，分片，乘法，判断成员资格，求长度，取最大值和最小值）对字符串同样适合；但是字符串是不可变的，索引赋值和分片赋值是不允许的；如下： ~~~ >>> name="peace" >>> name[1]='q' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment >>> ~~~ # 字符串格式化 ### 1.%字符：标记转换符开始 字符串格式化转换类型：  演示如下： ~~~ #%s 格式化字符串： >>> format="I\'m,%s,%s?" >>> name=('One','peace') >>> print (format % name) I'm,One,peace? #%f格式化实数： >>> format="1.31400 with three decimals:%.3f" >>> print(format % 1.31400) 1.31400 with three decimals:1.314 >>> ~~~ ### 2.转换标志： -：左对齐 +：在转换值之前加上正负号 “ ”：正数之前保留空格 0：转换值若位数不够用0填充 .或者.*:输出精度 下面我有单精度符号数进行演示： 以上操作对其他类型也可以 ### 1.左对齐在%号加上-号即可； ~~~ >>> a=1.314520 >>> '%010.3f'%a '000001.315' >>> '%-010.3f'%a '1.315 ' >>> ~~~ ### 2.在输出前加上正负号：%后加上+ ~~~ >>> a=1.314520 >>> '%+f'%a '+1.314520' >>> ~~~ ### 3.正数之前保留空格：%后加上空格 ~~~ >>> a=1.314520 >>> b=-a >>> b -1.31452 >>> '%f'%b '-1.314520' >>> '% f'%a ' 1.314520' ~~~ ### 4.输出位数不够用0补充：%号后加上0 ~~~ >>> a=1.314520 >>> '%010f'%a '001.314520' >>> ~~~ ### 5.输出精度：%号后加上.或者.* 如果用*，此时精度数值会从元组参数中读出 ~~~ >>> a=1.314520 >>> '%.3f'%a '1.315' >>> '%.*f'%(3,a) '1.315' >>> ~~~ # 字符串方法： ### find方法 find方法可以在一个较长的字符串中查找子字符串。它返回子串所在位置的最左端索引。如果没有找到则返回-1。 ~~~ >>> name="my name is peace and is" #查找的是最左端的 >>> name.find('is') 8 #没有找到返回-1 >>> name.find('one') -1 #可以提供查找的起点，下面时从9开始查 >>> name.find('is',9) 21 #当然可以同时给出终点和起点 >>> name.find('is',10,11) -1 >>> ~~~ ### join方法和split方法 join方法是用来连接序列中的元素(注意必须都是字符串)，而split刚好相反，是用来将字符串分割成序列 ~~~ #如果seq=[1,2,5,6]就会报错 >>> seq=['1','2','5','6'] >>> adhere='-' >>> adhere.join(seq) '1-2-5-6' >>> adhere '-' >>> a=adhere.join(seq) >>> a '1-2-5-6' >>> a.split('-') ['1', '2', '5', '6'] >>> ~~~ ### lower方法 lower方法返回字符串的小写字母版。对于查找时非常有用的；见下面的例子： ~~~ >>> name='ONE Peace' >>> k=name.lower() >>> k 'one peace' >>> 'ONE Peace' in ['one peace','nick name'] False >>> 'ONE Peace'.lower() in ['one peace','nick name'] True >>> ~~~ ### replace方法和translate方法 replace方法返回某个字符串的所有匹配项均被替换之后得到的字符串。 translate方法和replace方法一样，可以替换字符串中的某些部分，但是和前者不同的是，translate方法只处理单个字符。它的优势在于可以同时进行多个替换，有些时候比replace效率高得多。在使用translate转换前，需要先完成一张转换表。转换表中是以某字符替换某字符的对应关系。有时表比较长，我们还是不要自己写了，直接用maketrans方法就行了。maketrans方法接收两个参数：两个等长的字符串，表示第一个字符串中的每个字符都用第二个字符串中相同位置的字符替换。 需要注意的是python3.0之前的版本maketrans函数在string中需要引入 ~~~ >>> st='is is is is is' >>> st2=st.replace('is','peace') >>> st2 'peace peace peace peace peace' >>> st='abcdefghijklm' >>> table=st.maketrans('bc','aa') >>> len(table) 2 >>> table {98: 97, 99: 97} >>> st.translate(table) 'aaadefghijklm' ~~~ ### strip方法 strip方法返回去除两侧（不包含内部）空格（或者是指定字符）的字符串 ~~~ >>> st=' aaaaa ' >>> st.strip() 'aaaaa' >>> st='***jjjj***' >>> st.strip('*') 'jjjj' >>> ~~~ 字符串入门就讲到这里； #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://home.cnblogs.com/u/onepeace/) > 前面一张主要学习了Python的安装，以及第一个程序helloword的编写，以及简单的输入和输出函数 ### 序列 这章主要介绍的是列表和元组,而列表和元组是序列的六种内型中的两种，主要区别。列表可以修改，而元组不能。而序列很好用比如要操作一组人的名字和年龄可以这样： ~~~ >>>peace=['peace one',23] >>>rong=['sisi',22] >>>data=[peace,rong] >>>data [['peace one',23],['sisi',22]] ~~~ 序列可以包含其他序列；比如data包含了peace和rong序列 ### 索引 1、序列名按序号索引 peace[1] 23 data[1][1] 22 2、字符串直接按序号索引还可对输入进行索引 ‘hello’[1] ‘e’ two=raw_input(‘year: ‘)[1] year: 2015 two ‘0’ ### 分片索引、 1跟按序号索引类似，可以使用分片操作来访问一定范围内的元素。分片通过冒号分隔开来实现； tag=’My name is one peace’ tag[11:20] ‘one peace’ 注意：第一个索引是分片的第一个元素索引，第二个索引是分片元素最后一个元素索引+1；哪怕像上面的+1索引不存在也没关系.同样制空最后一个索引也是可以的；如下： tag[-9: ] ‘one peace’ 2更大的步长，在两个索引后面再加一个冒号和步长； tag[1:11:2] ‘ynm s’ 注意：同样步长也可以为负数，不过为负数时，是从后往前输出。此时必须第一个索引再第二个索引的后面；比如： tag[11:1:-2] ‘os mn’ ### 序列运算 1相加又称连接 [1,2,3]+[3,4,6,] [1,2,3,4,5,6] 注意：两种相同类型才能进行连接操作；比如：[1,2]+’hello’会返回错误 2相乘用列表乘以数字x，得到的新的序列会重复被乘序列x次 [42]*5 [42,42,42,42,42] 3成员资格，检查一个值是否在序列当中，可以使用in运算。 ‘p’ in tag True ‘pe’ in tag True ‘px’ in tag False  4长度，最大值，最小值 #长度函数len len(tag) 20 #最大值函数max max([3,4,5]) 5 min([3,4,5]) 3 ### 列表 ### list函数 1,list函数，创建列表； str=list(‘hello’) str [‘h’,’e’,’l’,’l’,’o’] ### 列表操作 1改变列表，元素赋值 str[1]=’p’ str [‘h’,’p’,’l’,’l’,’o’]  2删除元素 使用del来删除 del str[1] str [‘h’,’l’,’l’,’o’]  3分片赋值。主要作用如下： #1，可以使用与原序列不等长的序列将分片替换 str[1: ]=list(‘peace’) str [‘h’,’p’,’e’,’a’,’c’,’e’] #2,可以不替换任可元素的情况下插入元素 str[1:1]=list(‘one’) str [‘h’,’o’,’n’,’e’,’p’,’e’,’a’,’c’,’e’] #3，当然也可以删除、 str[1:4]=list() str [‘h’,’p’,’e’,’a’,’c’,’e’] ### 列表方法 方法是一个与对象紧密相关的函数。直接对象.方法进行调用 列表有append（末尾追加），count（统计次数），extend（新列表追加），index（找到元素为知），insert（按序号插入） pop（按序号删除）remove（按值删除）reverse（元素翻转），sort（排序），sorted（获取排序后的结果），特殊排序： sort（cmp）通过比较类型排序，sort（key=len）通过建函数排序（此去是长度len），sort（reverse=True）通过True和false来判断是否翻转排序； 方法操作如下： ~~~ #append方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.append(list(" tiger")) >>> name ['s', 'c', 'o', 't', 't', [' ', 't', 'i', 'g', 'e', 'r']] >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.append("A","B") #添加多个元素即将报错 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: append() takes exactly one argument (2 given) >>> name.append("A") >>> name ['s', 'c', 'o', 't', 't', 'A'] #count方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.count('s') 1 >>> name.count("t") 2 >>> name.count("A") 0 >>> name.append(list("Python")) >>> name ['s', 'c', 'o', 't', 't', ['P', 'y', 't', 'h', 'o', 'n']] >>> name.count(['P', 'y', 't', 'h', 'o', 'n']) 1 #extend方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.extend(list(" tiger")) >>> name ['s', 'c', 'o', 't', 't', ' ', 't', 'i', 'g', 'e', 'r'] #index方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.index('t') ##第一个字母t的索引位置是3 3 >>> name.index('a') Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: list.index(x): x not in list >>> 'a' in name False >>> 'a' not in name True #insert方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.insert(2,'tiger') ##在索引为2的地方插入字符串tiger >>> name ['s', 'c', 'tiger', 'o', 't', 't'] #pop方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.pop() 't' >>> name ['s', 'c', 'o', 't'] >>> name.append("t") >>> name ['s', 'c', 'o', 't', 't'] #remove方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.remove("t") #去掉第一个t >>> name ['s', 'c', 'o', 't'] >>> name.remove("A") #不存在会报错 Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: list.remove(x): x not in list >>> "A" not in name True >>> name.remove("s","c") #一次只能移除一个元素 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: remove() takes exactly one argument (2 given) #reverse方法 >>> name = list("scott") >>> name ['s', 'c', 'o', 't', 't'] >>> name.reverse() >>> name ['t', 't', 'o', 'c', 's'] #sort方法 >>> result = [8,5,5,3,9] >>> result.sort() >>> result [3, 5, 5, 8, 9] #sorted方法 >>> result = [8,5,5,3,9] >>> result2 = sorted(result) >>> result [8, 5, 5, 3, 9] >>> result2 [3, 5, 5, 8, 9] ~~~ ### 元组 元组 元组与列表一样，也是一种序列，唯一不同的是元组不可以修改： ### 元组操作 ~~~ >>> 1,2,3 (1, 2, 3) >>> () () #对于单个元素必须加上逗号，加上逗号后就表示数字是元组了 >>> 42 42 >>> 42, (42,) >>> (42,) (42,) ~~~ ### 元组tuple函数 ~~~ >>> tuple([1,2,3]) (1, 2, 3) >>> tuple('abc') ('a', 'b', 'c') >>> tuple((1,2,3)) (1, 2, 3) ~~~ ### 列表与元组的相互转化 ~~~ >>> T=('cc','aa','dd','bb') >>> tmp=list(T) >>> tmp ['cc', 'aa', 'dd', 'bb'] >>> T=tuple(tmp) >>> T ('cc', 'aa', 'dd', 'bb') ~~~ #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

### 获得更多资料欢迎进入[我的网站](http://rlovep.com/)或者 [csdn](http://blog.csdn.net/peace1213)或者[博客园](http://home.cnblogs.com/u/onepeace/) > 最近将我的Python笔记整理下，希望能对他人有所帮助,这是第一课，安装入门篇； ### windows下安装Python 1、下载，从这里下载：[下载链接]（[http://python.org/download/](http://python.org/download/)） 2、下载windows版本，下载完成以后，双击打开，然后一步一步安装。 3、环境变量的添加：我是安装在“D:\Python33”， 所以右键“我的电脑”-》属性-》高级环境设置-》高级-》环境变量 在系统变量中找到Path ，点击编辑加入；D:\Python 4、现在直接可以在命令提示符cmd下输入Python了输入Python后显示你的版本号，以及进入了Python命令行下 5、当然也可以点击：开始菜单》》所有程序》》Python》》Python（command line） ### ubuntu下安装Python 1安装，有PPA可用（支持所有Ubuntu版本及衍生系统），打开终端，输入命令： sudo add-apt-repository ppa:fkrull/deadsnakes 2更新源 sudo apt-get update 3安装Python3.3 sudo apt-get install python3.3 4设置Python3.3为默认命令（ubuntu不是最新的） rm /usr/local/bin/python ln -s /usr/local/bin/python3.3 /usr/local/bin/python 5在终端输入Python，显示你的版本号，以及进入了Python命令行下 ### 第一个程序hello world ~~~ >>>print 'hello world' hello world ~~~ ### 基本操作 1、可以直接在Python交互模式下输入命令，同样也可以通过建立.py文件通过命令Python hello.py; 2、 name = raw_input(‘please enter your name:’)输入到name变量中 int（raw_input(‘please enter your name:’)）转化为整数；ord(‘A’)转化为整数， chr(65)转化为字符 3、以#开头的是注释； 4,有内建函数，和引入模块：import math。然后math.floor(32.9)或者from math import sqrt sqrt（9）=3直接调用； 5、当语句以冒号“:”结尾时，缩进的语句视为代码块 6、整数和浮点数是一样的；字符串只能用单引号或者双引号包括，当字符串内部包含单引号和双引号时用转义字符 \’表示，bool True False 操作：and（&） or（|） not（~）；Python还允许用r”表示”内部的字符串默认不转义 7、语句太长换行可以通过”’ ”’包含 ~~~ >>>print '''line1 line2 line3''' line1 line2 line3 ~~~ 8、None代表空值 9、变量本身类型不固定的语言称之为动态语言，比如 a=123 a=’aba’ Python是静态语言； 10、用Unicode时 通过 u’中文’ u’ABC’.encode(‘utf-8’)转化为utf-8的格式；len(u’ABC’)获得字符串长度；’abc’.decode(‘utf-8’)转化为Unicode； 11、你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。 12、print type（3.0）得到型号： #### 相关链接： [python3入门之类](http://rlovep.com/2015/09/23/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E7%B1%BB/) [python3入门之函数](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%87%BD%E6%95%B0/) [python3入门之循环](http://rlovep.com/2015/09/06/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%BE%AA%E7%8E%AF/) [python3之if语句](http://rlovep.com/2015/08/05/python3%E4%B9%8Bif%E8%AF%AD%E5%8F%A5/) [python3入门之赋值语句介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E8%B5%8B%E5%80%BC%E8%AF%AD%E5%8F%A5%E4%BB%8B%E7%BB%8D/) [python3入门之print，import，input介绍](http://rlovep.com/2015/08/03/python3%E5%85%A5%E9%97%A8%E4%B9%8Bprint%EF%BC%8Cimport%EF%BC%8Cinput%E4%BB%8B%E7%BB%8D/) [python3入门之set](http://www.cnblogs.com/onepeace/p/4791578.html) [python3入门之字典](http://rlovep.com/2015/07/29/python3%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E5%85%B8/) [python3入门之字符串](http://rlovep.com/2015/07/28/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AD%97%E7%AC%A6%E4%B8%B2/) [python3入门之列表和元组](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E5%88%97%E8%A1%A8%E5%92%8C%E5%85%83%E7%BB%84/) [python3入门之软件安装](http://rlovep.com/2015/07/14/python%E5%85%A5%E9%97%A8%E4%B9%8B%E8%BD%AF%E4%BB%B6%E5%AE%89%E8%A3%85/) [python3爬虫之入门和正则表达式](http://rlovep.com/2015/09/23/python3%E7%88%AC%E8%99%AB%E4%B9%8B%E5%85%A5%E9%97%A8%E5%92%8C%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/)

> 原文出处：[python3入门学习](http://blog.csdn.net/column/details/python-spider.html) 作者：[peace1213](http://blog.csdn.net/peace1213) **本系列文章经作者授权在看云整理发布，未经作者允许，请勿转载！** # python3入门学习 > 主要讲解python3入门学习，从最开始的软件安装开始逐步讲到类，以及后面的应用使用python进行爬虫。