python——自学入门

识python

python：面向对象（对象之间交互数据，各对象协同操作）， 解释性语言。简单，功能强大

功能：

学习路线：

初级：初识—语法—运算符、表达式—控制流—函数—模块—数据结构—面向对象—文件、异常处理—标准库

进阶：正则表达式、多线程、网络编程、客户端编程、图形界面编程

高级：网络编程、wxpython

特点：严格区分大小写

          简单，面向对象

      开源

       库非常丰富（标准库、）

       跨平台使用

       解释性语言（区别编译性语言c++，编译器编译为二进制，进入系统内存执行），通过解释器解释为字符码。

       高级语言

目录：lib：放模块，自定义模块也在这里。

一、windows下环境配置

1.进入 https://www.python.org/      点击downloads

3.。。的版本有新特性

2.。。的版本运行速度快。 现在多用其开发

安装都是next默认值

2.系统变量

用户变量：选择tmp（tmp和temp区别：tmp解决dos兼容性问题。两个一样，都可以选择 ）

系统变量：path：E:\python

3.集成开发环境  http://www.jetbrains.com/网站最下方（java语言开发）

用professional的版本

默认安装。快捷键（keymap）用eclipse的

4.java jdk环境（pycharm也是java开发）

二、osx系统下搭建python

1.下载集成开发环境pycharm  http://www.jetbrains.com/。

三、linux系统下搭建python

1.测试linux是否安装python。打开终端：输入python查看版本

2.下载集成开发环境pycharm  http://www.jetbrains.com/。

3.

四。python的helloworld

（1）cmd中编写 python

命令行下运行源文件的使用

（2）集成开发环境pycharm中编写

编辑器：python自带：IDLE。

                多行代码：ctrl+n弹出的窗口可以换行

                退出编辑模式：ctrl+z

                源码以.py结尾

        aptana

        pycharm

五、python基本语法

1.定义常量与变量、数与字符串

常量：程序运行中不可变。7，a，b，c，a=1。一旦绑定不可更改。

    定义常量用对象的方法创建

变量：程序运行中可改变。赋值：“=”

i=5

print i

i+=1

print i

i+=2

print i

i+=3

print i

输出：5    6    8    11

a=10

b=2

c=a+b

print(c)

//easy.语言很简单

数的类型： int：0、1、-1、1009、-290

               long（长整型）：87887l、-90990、

            float：2.778、3.277、8.88

            bool：true、false

            complex（复数型）：4+2j、-9+20j

        

字符串： 引号引起来的字符集。"hello"、'my python'

引号的使用（单双引号可以交叉使用）

        单引号：单引号里可以使用双引号，并且双引号可以输出，双引号中不能使用双引号       

         c1 = 'ok'

         print  c1

         c2= 'It is "ok"!'

         print  c2

         输出：ok

              It is "ok"!

    双引号：双引号中可以使用单引号

         c1 = "ok"

         print  c1

         c2= "It is 'ok'!"

         print  c2

         输出：ok

              It is ‘ok’!

       三引号：三个单引号，或者三个双引号，执行结果一样。且单双引号不可交叉使用。三引号包裹的字符串可以换行。

         c1 = '''I

         am

         a beautiful

         girl

         do you know?'''

         print  c1

        输出：I

               am

               a beautiful

               girl

               do you know?

            

转义符：主要用在字符串中

        "\":想输出：it's a dog

        a.print "it's a dog"

        b.print 'it\'s a dog'

        "\n":换行

            print "hello boy\nhello boy"

            输出：hello boy

                   hello boy

自然字符串：保留转义符的样式，原样输出，不进行任何处理，使用自然字符串，在引号前加r

         print  "hello caoge \n hello gezi"

         print  r"hello caoge\nhello gezi"

        输出：hello caoge

               hello gezi

               hello caoge\nhello gezi

 字符串的重复：输出“hello”20次， 可使用重复运算符“*”

         print  "hello" * 10

        输出：hellohellohellohellohellohellohellohellohellohello

子字符串：jikexueyuan中“ji”、“yu”都是“jikexueyuan”的子字符串。一个大字符串中，抽出连续字符串。 两种方法：索引运算法[](从0开始索引，返回一个字符)、切片运算法[a:b]（从a下标开始，到b-1下标。第一位的下标为0）

         c1= "jikexueyuan"

         c2=c1[ 0 ]

         c3=c1[ 7 ]

         c4=c1[: 3 ]    #从最左边一直到b-1

         c5=c1[ 3 :]    #从第3歌下标一直到最右边

         c6 =c1[ 3 : 7 ]

         print  c2

         print  c3

         print  c4

         print  c5

         print  c6

        输出：j

               y

               jik

               exueyuan

               exue

2.  判断语句

score  =  20

if  score >= 80 :

     print ( "很好" )

elif  score >= 60 :

     print ( "及格" )

elif  score >= 30 :

     print ( "不及格" )

else :

     print ( "很差" )

中文编码问题

开头加入 ：#coding:utf-8 或者 #coding=utf-8

3.   循环

for  i  in  range ( 0 , 10 ):

     print (i)                   

输出：0123456789

for  i  in  range ( 0 , 10 ):

     print ( "Item{0}" .format(i))

输出：Item0   Item1   Item2   Item3   Item4   Item5

      Item6   Item7   Item8   Item9

for  i  in  range ( 0 , 10 ):

     print ( "Item{0},{1}" .format(i, "hello python" ))

输出：Item0,hello python   Item1,hello python   Item2,hello python   Item3,hello python

      Item4,hello python   Item5,hello python   Item6,hello python   Item7,hello python

      Item8,hello python   Item9,hello python

4.定义函数

def  sayHello(): #小括号里可写传入参数

     print ( "hello world" )

sayHello() #执行函数

def  max(a,b): #带参数的函数

     if  a>b:

         return  a

     else :

         return  b

print (max( 2 , 3 ))

#5.定义函数

5.面向对象（定义类）

class  Hello: #定义类

     def  sayHello( self ): #定义方法

         print ( "Hello Python" )

h=Hello()

h.sayHello() #创建实例

输出：Hello Python

class  Hello: #定义类

     def  __init__ ( self ,name): #构造方法

         self ._name = name

     def  sayHello( self ): #定义方法

         print ( "Hello {0}" .format( self ._name))

h=Hello( "caoge" )

h.sayHello() #创建实例

输出：Hello caoge

class  Hello: #定义类

     def  __init__ ( self ,name): #构造方法

         self ._name = name

     def  sayHello( self ): #定义方法

         print ( "Hello {0}" .format( self ._name))

class  Hi(Hello): #继承自hello

     def  __init__ ( self , name):

        Hello. __init__ ( self ,name)

     def  sayHi( self ):

         print ( "Hi {0}" .format( self ._name))

h = Hello( "caoge" )

h.sayHello() #创建实例

h1 = Hi( "gezi" )

h1.sayHi()

输出：Hello caoge

       Hi gezi

    

    

6.引入python文本

loadlib.py

#import mylib

#h = mylib.Hello()

#h.sayHello()

from  mylib  import  Hello

h = Hello()

h.sayHello()

mylib.py

class  Hello:

     def  sayHello( self ):

         print ( "Hello everybody" )

运行：loadlib.py

输出：Hello everybody

web2py：python语言web的开发框架。一个完整的网络模板

六、python数据类型

 基本数据类型：数和字符串

 python没有数组的概念，只有列表和元组的概念

     列表：是存储一连串元素的容器。用[]表示，可以修改内容

         students =[ "小明" , "jone" , "向冲" , "mary" , "alice" ]

         #列表中的每一项是元素，元素是有顺序的，第一个元素下标为0

         print  students [ 2 ] #利用索引运算符选取元素

         #列表可以修改内容

         students[ 2 ]= "王八蛋"

         print  students[ 2 ]

         输出：向冲

                王八蛋

    

     元组：与列表类似

         区别：1.使用()包含元素，2.不能修改内容，只能读取内容

         students =( "小明" , "jone" , "向冲" , "mary" , "alice" )

         print  students [ 2 ]

         输出：向冲

        

集合：1.建立关系。2.消除重复元素

         格式：set(元素)

     #集合

     a= set ( "adfasfbsb" )

     b= set ( "affg" )

     x=a&b #交集

     print  x

     y=a|b #并集

     print  y

     z=a-b #差集 a中有，b没有

     print  z

     new = set (a) #去除重复元素：集合里的元素是唯一的，把字符串a变为一个集合赋值给new，输出new

     print  new

     输出：set(['a', 'f'])

            set(['a', 'b', 'd', 'g', 'f', 's'])

            set(['s', 'b', 'd'])

            set(['a', 's', 'b', 'd', 'f'])

        

字典：关联数组,通过":"进行关联。字典里面包含一整个事情，事情里面包含各方面的具体信息

        格式：zidian={'name':'caoge','home':'niaoshi','like':''book'}

         #字典

         k={ "名字" : "鸽子" , "籍贯" : "新疆" }

         print  k[ "籍贯" ]

         #添加字典内容,原子典不变

         k[ "星座" ]= "鱼鱼"

         print  k[ "名字" ]

         print  k[ "星座" ]

         print  k[ "籍贯" ]

         输出：新疆

                鸽子

                鱼鱼

                新疆

            

七、什么是标识符

标识符：起的名字叫做标识符。变量，常亮的名字就是标识符的一种。根据命名规则命名的可以使用的标识符叫做有效标识符。否则是无效标识符

命名规则：a、第一个字符只能是字母或是下划线

           b、其他部分可以是字母或者下划线或者数字

           c、标识符大小写敏感

         ssd_1 = 223

         print  ssd_1  输出：223

         1 ssd= 223

         print  1 ssd   输出：报错

         _1ssd= 223

         print  _1ssd 输出：223

        

python关键字：系统自带的有特定的含义的标识符。共28种

主要有：and、elif、global、or、else、pass、break、continue、import、class、return、for、while

八、python的对象

python的内置对象：数字、字符串、列表、元组、字典、集合等。一切皆为对象

详解pickle腌制

需要持久性存储的对象，并且不丢失对象的类型与数据。我们将这个对象进行序列化，存储在内存或第三方文件中，需要使用的时候再恢复为原来的数据。

序列化的过程：pickle腌制。恢复的过程：反的pickle腌制

     import  pickle   #导入pickle模块

     #dumps(object)将对象序列化

     lista=[ "xiangchong" , "shi" , "wangbadan" ]

     listb=pickle.dumps(lista)

     print  listb

     输出：(lp0

              S'xiangchong'

              p1

              aS'shi'

              p2

              aS'wangbadan'

              p3

              a.

    

     #loads(string)将对象的类型，数据原样恢复为原来的格式

     listc=pickle.loads(listb)

     print  listc

     输出：['xiangchong', 'shi', 'wangbadan']

    

     #dump(object,file)将对象序列化,存储在文件里

     group1=( "caoge" , "jiuxihuan" )

     f1= file ( '1.pk1' , 'wb' ) #wb:写入

     pickle.dump(group1,f1, True )

     f1.close()#关闭文件

     #load(object,file)恢复数据

     f2= file ( '1.pk1' , 'rb' )

     t=pickle.load(f2)

     print  t

     f2.close()

     输出：('caoge', 'jiuxihuan')

    

九、行与缩进

    逻辑行与物理行

    逻辑行：一段代码在意义上的行数

    物理行：实际看到的行数

         #三个物理行

         print  "abc"

         print  "123"

         print   "777"

         #1个物理行，3个逻辑行

         print  "abc" ; print  "123" ; print  "777"

         #1个逻辑行，3个物理行

         print  '''这里是

         曹歌的

         代码'''

    行中分号使用规则

        一个物理行中可以有多个逻辑行，用分号隔开。如果一个逻辑行占了物理行的最后，这个逻辑行可以省略分号

         #所有的逻辑行后均应使用分号

         print  "123" ; print  "111" ;

         print  "asd" ;

         #行末的分号可以省略

         print  "123" ; print  "111"

         print  "asd"

    行连接：一个逻辑行分为几个物理行写时，使用行连接，在行的最后加\

         print  "我们都是\

         好孩子"

        输出：我们都是好孩子

    缩进：逻辑行行首的空白有规定，不对时程序不能运行

    缩进要求：1、一般逻辑行行首没有空白

               2、if/while语句缩进方法

             #if语句

             a= 7

             if  a> 0 :

     print  "hello" #缩进一个tab字符

             #while缩进

             a= 0

             while  a< 7 :

      print  a

     a+= 1

            输出：hello

            0

            1

            2

            3

            4

            5

            

十、python运算符与表达式

    运算符：对一个数字或者多个数字进行操作，对一个或多个字符串进行操作。也叫运算符

    +、-、*、/、**（冥运算）、<、>、!=（不等于）、//（商的整数部分）、%（余数部分）、&、|、^、~、>>（右移）、<<（左移）、<=、>=、==、not、and、or

     #”+“两个对象相加

     a= 7 + 8

     print  a 输出：15

     b= "xiang" + "chong" #"+"是两个字符串的连接符号

     print  b 输出： xiangchong

    

     #“-”取一个数字的相反数，两个数字相减

     a=- 7 #取相反数

     print  a 输出：-7

     b=-(- 8 )

     print  b 输出：8

     c= 11 - 12

     print  c 输出：-1

     #两个数相乘、字符串重复

     a= 4 * 7

     print  a 输出：28

     b= "cao" * 3

     print  b 输出：caocaocao

#"/":两个数字相除

a= 7 / 2

print  a #除数或者被除数有一个是小数得到的结果就是小数，都是整数得到的结果就是整数输出：3

b= 7.0 / 2

print  b 输出：3.5

c= 7 / 2.0

print  c 输出：3.5

#"**":求幂运算

a= 2 ** 3 #2的三次幂，2*2*2

print  a 输出：8

#”<“小于号，返回一个bool值

a= 3 < 7

print  a 输出： True

     b= 3 < 3

print  b 输出： False

#">":大于号，返回一个bool值

a= 3 > 7

print  a 输出：False

b= 3 > 1

print  b 输出：True

#"!=":不等于，返回bool值

a= 2 != 3

print  a 输出：True

b= 2 != 2

print  b 输出：False

#"//":商的整数部分

a= 10 // 3

print  a 输出：3

#"%":取商的余数部分

b= 10 % 3

print  b 输出：1

a= 10 % 1 #没有余数的时候

print  a 输出：0

a= 10 // 3

b= 10 % 3

c= 3 *a+b #c为除数乘以商的整数部分加上余数，c为被除数

print  c 输出：10

#"&":按位的与运算。按位与是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算

a= 7 & 18 #与运算只有1,1为1

print  a 输出：2

'''将7转化为二进制：111；自动补齐8位：00000111；

将18转化为二进制10010，自动补齐为0010010

将00000111

..00010010按位与进行运算，得到00000010，将00000010转化为十进制，得到2'''

#"\":按位或运算，将数字转化为二进制后按位进行或运算

a= 7 | 18 #或运算只有0，0为0

print  a 输出：23

'''将7转化为二进制：111；自动补齐8位：00000111；

将18转化为二进制10010，自动补齐为0010010

将00000111

..00010010按位或进行运算，得到00010111，将00010111转化为十进制，得到23'''

#"^"按位异或，不相同为1，相同为0

a= 7 ^ 18

print  a 输出：21

'''将7转化为二进制：111；自动补齐8位：00000111；

将18转化为二进制10010，自动补齐为0010010

将00000111

..00010010按位或进行运算，得到00010101，将00010101转化为十进制，得到21'''

#"~":按位翻转.~x=-(x+1)

a=~ 18   #~18=-(18+1)

print  a 输出：-19

#"<<":左移

'''18左移，将他的二进制形式00010010左移，成为00100100（右边缺少默认补0）

，成为36，左移一个单位相当于乘2左移两位相当于乘4，三位相当于乘8，N个单位相当于乘2的N次幂'''

a= 18 << 1

print  a 输出：36

b = 3 << 3

print  b 输出：24

#“>>”：右移，右移是左移的逆运算，结果取商的整数部分

'''18左移，将他的二进制形式00010010左移，成为0001001（右边缺少默认补0）

，成为36，右移一个单位相当于除以2，右移两位相当于除以4，三位相当于除以8，N个单位相当于除以2的N次幂'''

a= 18 >> 1

print  a 输出：9

b= 18 >> 2

print  b 输出：4

#"<=":小于等于，比较运算，小于或等于，返回bool值

a= 3 <= 3

print  a 输出：True

b= 4 <= 3

print  b 输出：False

#">=":大于等于，比较运算，大于或等于，返回bool值

a= 1 >= 3

print  a 输出：False

False

b= 4 >= 3

print  b 输出：True

#"==":比较两个对象是否相等，返回bool值

a= 12 == 13

print  a 输出：False

b= "hello" == "hello"

print  b 输出：True

#"not":逻辑非，true的值非运算后为false

a= True

b= not  a

print  b 输出：False

c= False

print not  c 输出：True

#"and":逻辑与

'''

True and True==True

True and False==False

False and False==False'''

print  True  and  True 输出：True

#“or”：逻辑或

'''

True or True==True

True or False==True

False or False==False'''

print  True  or  False 输出：True

优先级：python的优先级有两种，程序的优先级和运算符的优先级

#优先级的作用，不同运算符优先级不同，优先执行某些运算符

a = 2 + 7 * 8

print  a #优先执行* 输出：

b= 9 > 7

print  b # 输出：

#优先级使用实战

#第一名：函数调用/寻址/下标

#第二名：幂运算**

a = 4 * 2 ** 3

print  a 输出：32

#第三名：翻转运算~

#第四名：正负号

print  2 + 4 *- 2 输出：-6

#第五名：*，/，%

print  2 + 4 * 2 / 4 输出：4

#第六名：+，-

print  3 << 2 + 1 输出：24

#第七名：<<，>>

#第八名：按位&，^，\

#第九名：比较运算符

a = 2 * 3 + 5 <= 5 + 1 * 2

     print  a 输出：False

#第十名：逻辑的与或非and，or，not

     #第十一名：lambda表达式

    

运算符使用规律：

#1，一般是左结合的

  print  4 + 5 + 5 * 6 + 6 输出：45

  #2,出现赋值的时候一般是右结合

  a = 5 + 5

  print  a 输出：10

优先级记忆方法：

函数寻址下标一

幂运算小二笑嘻嘻

全体单元第三位（连接一个对象的运算符~，-，+）

乘除求余四千里

乘除完了五加减

六娃玩耍左右移

七是按位或跟与

八仙生气要比敌

倒数第一逻辑或非与

实在不记得优先级时，用小括号。括号内的优先级最高

a =( 2 + 5 )* 6

print  a 输出：42

b=(( 2 + 5 )+ 5 )* 2

print  b 输出：24

表达式：值，变量和运算符中的一个或多个组成

#1字符串表达式

"hello"

#2.运算表达式

25 + 7

#3.变量，值组成

a= 67

#4.值，运算符，变量

a= "hello"

#表达式在单行命令中的使用,一输入会执行，但在多行命令行中不会执行，所以在本文件(源程序，又叫多行命令行)中不会执行，在IDLE中可执行

#值表达式：8，执行结果任是值

8

#变量表达式

a= "OK"

a= 7

#计算表达式：输出结果是计算后的值

7 + 8

#字符串表达式

"HELLO" #输出'HELLO'

#表达式在源程序中的使用

#表达式执行结果与print的区别，字符串执行结果有单引号，打印结果没有单引号，数字执行结果和打印结果都是数字

#表达式：输入"qq",输出'qq'

#print：输入：print "qq" 输出：qq

#表达式：输入：a=7 回车 输入：a,输出：7

#print：输入：print a 输出：7

十一、控制流

程序代码的执行是有顺序的，从上到下，跳转执行，分支执行，循环执行。控制语句能控制代码段的执行方式，不同功能的控制语句为控制流

    三种控制流： 顺序结构（通常情况），分支结构，循环结构

    分支结构if：判断执行哪个语句块

         #IF语句,分支结构，只满足一个分支.各分支尽量不要重复，并且尽量包含全部可能性

'''

if 是这样:

    执行该部分语句

elif 或者是这样:

    执行elif部分语句

else 以上情况都不是:

    执行这部分语句

'''

#一种情况的if

a= 8

if  a== 8 :

     print  "caoge"

if  a!= 8 :

     print  "hehe"

#两种情况的if

a= 8

if  a== 8 :

     print  "caoge"

else :

     print  "xiangchong"

#三种情况下的if

a= 8

if  a== 7 :

     print  "xiang"

elif  a> 7 :

     print  "cao"

else :

     print  "fenshou"

a= 80

b= 0

if  0 80 :

     print  "差"

elif  80 <=a<= 100 :

     print  "好"

#程序问题：1.b没有用到，消耗内存。2.80在两个分支里都有，不准确，输出是哪个条件在上面，，就输出哪个结果

循环结构while：控制一个语句循环执行

         #循环结构

'''

while 条件为真：

    循环执行“该部分语句

    该部分语句“

else：条件为假，执行该部分语句

    '''

#死循环

'''a=True

while a:

    print "wangbadan"

'''

#不会循环输出，else部分不循环输出，只有while部分循环输出

b= False

while  b:

     print  "xiangchong"

else :

     print  "caoge" 输出：caoge

#有嵌套的while语句

a= 1

while  a< 10 :

     if  a<= 5 :

         print  a

     else :

         print  "hello"

     a=a+ 1

else :

     print  "test"

输出：1

   2

   3

   4

   5

   hello

   hello

   hello

   hello

   test

    

    循环结构for：变量依次取集合里的元素，执行循环部分

         '''

for语句格式：

for i in 集合

    执行该部分

else：

    执行该部分

'''

for  i  in  [ 1 , 2 , 8 , 9 , 0 ]:

     print  i 输出：12890

#range函数，生成一个集合的序列,个数为7-1，步长默认为1

for  i  in  range ( 1 , 7 ):

     print  "hello" 输出：hellohellohellohellohellohello

a= range ( 2 , 5 )

print  a 输出：[2, 3, 4]

#range中第三个参数代表步长，生成集合为1，3，5，7，9

for  i  in  range ( 1 , 10 , 2 ):

     print  i 输出：13579

#带嵌套的for语句，优先执行里面的语句，外层只做控制

for  i  in  range ( 1 , 10 ):

     if  i% 2 == 0 :

         print  i

         print  "偶数"

     else :

         print  i

         print  "基数"

        输出：1

               基数

               2

               偶数

               3

               基数

               4

               偶数

               5

               基数

               6

               偶数

               7

               基数

               8

               偶数

               9

               基数

    break语句：循环语句中，打破循环，强制停止

             #break在while中

a= 1

while  a:

     print  a

    a=a+ 1

     if  a== 5 :

         break 输出：1234

#break在for中

for  i  in  range ( 5 , 9 ):

     print  i

     if  i> 8 :

         break 输出：5678

#break在双层循环中

a= 10

while  a<= 12 :

    a=a+ 1

     for  i  in  range ( 1 , 7 , 2 ):

         print  i

         if  i== 5 :

             break 输出：135135135

a= 10

while  a<= 12 :

    a=a+ 1

     for  i  in  range ( 1 , 7 ):

         print  i

         if  i== 5 :

             break

    if  a== 12 :

         break 输出：1234512345

    

continue语句：强制停止循环中的一次执行

     #continue

a= 1

while  a< 7 :

    a=a+ 1

     if  a== 3 :

         continue

    print  a 输出：24567

#for循环中的continue,a程序和b程序

for  i   in  range ( 1 , 7 ):

     if  i == 3 :

         continue

    print  i 输出：12456

for  i   in  range ( 1 , 7 ):

     print  i

     if  i == 3 :

         continue #没起作用，想控制语句要把xontinue放上面，不想控制放下面

    输出：123456

#continue在双层循环语句中,for循环先循环

a= 1

while  a< 7 :

    a=a+ 1

     if  a== 4 :

         continue

    for  i   in  range ( 7 , 10 ):

         if  i == 9 :

             continue

        print  i

输出：7878787878

#continue与break的区别

'''continue终止某一次循环

break直接结束循环'''

for  i   in  range ( 10 , 19 ):

     if  i == 15 :

         continue

    print  i

输出：1011121314161718

for  i   in  range ( 10 , 19 ):

     if  i == 15 :

         break

    print  i

输出：1011121314

十二、函数

    函数function：用来封装特定功能。包括系统自带函数（不用我们编写，自由度低，方便）和自定义函数（自由度高，需要我们编写功能，需要使用的时候调用函数）

        函数的功能：

             #1.实现去字符串长度的功能

a= "xinagchongshigewangbadantaoyanta"

print  len (a) 输出：32

#2.实现字符串的切割,赋值给b

a= "xiangchong"

b=a.split( "a" )

print  b 输出：['xi', 'ngchong']

#3.自定义的函数

def  a():

     print  "xiangchong" ; print  777

a()

     输出：xiangchong

          777

函数的定义：1.声明指定部分是函数

             2.定义这个函数所包含的功能

             def  函数名():

    函数内容；函数内容

def  function():

    a= 8

     print  a

    形参与实参

         参数：函数执行功能时所用到的数据

         print  len () #取数据的1函数中无参数，报错，函数无意义

         形式参数：发生在函数定义的过程中，一般代表参数的名称，不代表参数值，没有实际值

         def  function(a,b): #a,b是形式参数，代表第一个位置是a，第二个位置是b

     if  a>b:

         print  a

     else :

         print  b

function( 1 , 3 ) #1,3是实际参数，在函数的调用部分，a的位置实际值为1，b的位置实际值为3

#1传递给function中的a，3传递给funbtion中的b。一一对应传递

         实参：是在函数调用的过程中出现，一般具有实际参数

         传递方式：参数传递有使用顺序

         关键参数：一个函数中出现多个参数时，可以通过名字直接给参数直接赋值

             def  function(a= 1 ,b= 6 ,c= 7 ): #赋值传递，初始化

     print  a

     print  b

     print  c

function( 5 ) #自动赋值给最左边 输出：567

function( b = 7 , a = 8 ) #b与b对应，不考虑位置关系。关键参数 输出：877

function( 5 , c = 2 , b = 3 ) #默认5传递给第一个位置 输出：532

funvtion( b = 4 , c = 2 , a = 1 ) #按照关键词传递，不考虑位置 输出：142

    全局变量与局部变量

        作用域：变量的作用范围

         def  func():

     f = 8

#print f #会报错，显示f没有定义。原因：f在func函数内，作用域也在函数内

#print j  #会报错，j的作用域是定义j=9之后，以下的部分，函数部分在他的上面，所以报错

j= 9

print  j   #对了

        局部变量：变量的作用域在一定范围内，不是全局起作用。没有声明是全局变量的变量，默认是局部变量，只要在函数内部的变量就是局部变量

         def  func2( a ):

    i= 7 #局部变量只在局部起作用，只在函数里起作用

     print  i

i= 9 

func2(i)   # i=9传递给a，函数内部i=7，所以输出7

print  i  #没有调用函数，输出函数外面的结果

        输出：79

        

        全局变量：作用域为全局，需要全局声明

         def  func3():  #定义函数

     global  i  #声明全局变量,i的作用域在全局，函数外面也能用

     i= 7

     print  i  #局部变量

i= 9

func3()

print  i 输出：77

def  func3():  #定义函数

     global  i  #声明全局变量,i的作用域在全局，函数外面也能用

     i= 7

     print  i  #局部变量

func3()

i= 9 #i的值改变

print  i 输出：79

    函数的使用与返回值

        函数的调用：直接输入函数名，调用参数的时候，在括号里输入参数就行

         def  a():

     i = 1

a()

        函数的返回值：有的函数有，有的函数没有。返回可以一个值或多个值

             #函数的返回值是通过return实现的

def  test():

    i= 7

     return  i  #函数的整体值是I，使函数成为一个是值的函数，给函数赋予值

print  test() 输出：7

#多个返回值

def  test2(i,j):

    k=i*j

     return  (i,j,k)

x=test2( 4 , 5 ) #把4，5传递给i，j。x：以元组的形式存储多个元素

print  x 输出：(4, 5, 20)

def  test3(i,j):

    k=i*j

     return  (i,j,k)

y ,z,m=test3( 4 , 5 ) #分别存储

print  y 输出：4

    文档字符串：由于函数过多，造成分析困难，浪费时间的问题。解决办法：1.写说明文档，一个函数一个。2.使用文档字符串，每个函数开头写文档字符串

    1.紧挨冒号

    2.使用三引号

    3.第二行必须空开，第三行开始是具体功能的描述

    4.句末是句号，第一个字母必须大写

    使用方法：print d.___doc__,函数d的文档字符串

               help(d):输出帮助信息，输出文档字符串和参数信息

            

十三、模块

    模块：函数功能的扩展，实现一项或多项功能的程序块。模块里可以重用多个函数。实现的是一类功能。

        目录：lib：放模块，自定义模块也在这里。

    

        导入模块：导入模块后才能使用 ，关键字：import

             import  math #导入模块

             print  math.pi

        自带模块：标准库模块。有的与邮件，操作系统，系统功能等有关。其中标准库中与系统功能有关的模块叫sys模块

     #sys

import  sys

print  sys.version #版本信息

print  sys.executable #查看目录地址

print  sys.getwindowsversion() #返回win版本信息

print  sys.modules.keys() #返回导入模块列表的关键字

    字节编译：

        .pyc文件：机器识别二进制语言。所以python执行模块时有两种方式。1.现将模块里面的内容编译为二进制，这一过程叫字节编译，会产生.pyc二进制文件。2.直接执行模块对应的二进制语言程序，省略编译，执行速度快一些。

        字节编译与编译的区别：

            python的编译过程是在解释器中发生的，而编译型语言是指软件中就有一个独立的编译模块去编译程序。而python中的字节编译由解释器完成，所以python是解释型语言。

        两种.pyc文件的产生方式：执行一个模块时，如果有.pyc文件就执行文件。如果没有就进行字节编译，产生.pyc文件（运行一下import模块，就会产生文件或者在cmd中编译），执行它。

        

        .pyc文件的使用：1.加快模块运行速度、2.反编译等

        .pyc文件的查看：使用二进制文件阅读器Binary viewer等

    from...important：导入一个模块的一个方法，

         from  sys  import  version import  sys

         print  version print  sys.version #版本信息

    from...important*：导入一个模块的所有方法

    认识_name_属性

        主模块：函数中，一个函数调用其他函数，这个函数是主函数，没有调用其他函数的函数叫非主函数

                模块中，一个模块被其他模块调用，这个模块是非主模块，没有被调用模块，被直接使用的模块叫主模块。

                自己执行是主模块，被别人执行是非主模块。决定因素

                __name__属性的值是"__main__"就是主模块。帮助判断

        认识_name_属性：

             if  __name__== "__main__" :

     print  "主模块"

else :

     print  "不是主模块"

    自定义模块：自己定义的模块。

        创建:将文件保存在lib目录内，命名为ceshi.py。保证模块没有 逻辑和语法上的小错误：将模块内的形式参数参数初始化（i=0）或者声明变量类型（Int i）

         #coding:utf-8

i= 0 #初始化

j= 0 #初始化

#i,j形参，没有实际值，执行出错.只在模块外面赋值也会报错..解决办法：初始化，起码在逻辑上不会出错

def  add(i,j):

    k=i+j

     return  k

k=add(i,j)

print  k

    调用模块：    import  ceshi #生成.cpy文件

i= 1

j= 2

print  ceshi.add(i,j) 输出：3

    dir()函数：查看指定模块的功能列表

         import  sys

         print  dir (sys) #输出所有的功能，其他编辑器可以不加print 直接写dir(sys)

         print  sys.version #其他编辑器可以不加print

    dir()函数扩展：查看任意指定对象的功能列表

    空列表

    有元素的列表

    返回值一样，说明dir()只是返回属性和方法的列表，没有数据

    

十四、python数据结构

数据结构：一个或几个数据要组织起来有不同的组织方式（存储方式）。不同组织方式就是不同的结构。数据组织在一起的结构称为数据的结构。又为数据结构。

数据结构：列表，元组，字典，队列，栈，树等等。

python中数据的组织方式叫做python的数据结构

Python的内置数据结构：python定义好的，比如元组，列表等

python的扩展数据结构：python中没有直接定义，需要我们自己定义实现的组织方式：栈，队列。。。

#python的内置数据结构：元组，列表，字典

#三个物品，apple、orange、pear。存储起来

# 1.列表。按顺序分别存储到一个柜子中，这些物品可以取出来,发生改变。

[ "apple" , "orange" , "pear" ]

#2.元组，按顺序分别存储到一个柜子中，这些物品不可以取出来,不发生改变。

( "apple" , "orange" , "pear" )

# 3.字典。按顺序分别存储到一个柜子中，每个柜子有名称。

{ "sam" : "apple" , "jac" : "orange" , "mating" : "pear" }

数据结构和算法：

    数据结构是数据存储方式，是静态的

    算法：运算方法，是思维，是动态的。不同的运算方法是不同的算法

    数据结构是算法的基础，相同的数据结构1运用不同的算法有不同的效率

栈：一种数据结构，不是内置数据结构，属于扩展数据结构。

相当于一端开口一端封闭的容器。数据A进栈的过程叫做进栈。栈只能对栈顶的数据进行操作，栈顶到栈底的数据不能被操作，栈顶数据出栈后才能操作栈顶到栈底之间的数据

     #栈的实现

class  Stack(): #定义栈的类

     def  __init__ ( st ,size): #初始化，__init__:名称；st：主体；size：容量

         st .stack=[]; #基础属性：列表，列表里的数据可以随意修改

         st .size=size; #容量的参数赋值给栈

         st .top=- 1 ; #初始化栈顶，第一个进来的数字是0，那么最开始是栈顶的位置是-1

     def  push( st ,content): #入栈；st：主体；content：数据内容

         if  st .Full():

             print  "Stack is Full!"

         else :

             st .stack.append(content) #在栈里增加数据，append：增加内容

             st .top= st .top+ 1 #栈顶指针加一

     def  out( st ): #出栈操作

         if  st .Empty(): #判断空

             print  "Stack is Empty"

         else :

             st .top== st .top- 1

     def  Full( st ): #判断栈是否满了，满的时候栈顶指针跟栈的大小相等

         if  st .top== st .size:

             return  True

         else :

             return  False

     def  Empty( st ):

         if  st .top==- 1 : #栈顶为-1，栈空了

             print  True

         else :

             print  False

#栈的使用

q=Stack( 7 ) #给栈传递参数，初始化

q.Empty() #判断是否是空 输出：True

q.push( "Hello" ) #入栈

q.Empty() 输出：False

q.out() #出栈

q.Empty()

队列：两端都开通的容器；一段只能进行删除操作，另一端只能进行插入操作。

    进行插入操作的一段叫队尾，只能进；进行删除操作的叫队首，只能出

队尾进队首出。

     # 队列的实现

class  Queue():

     def  __init__ ( qu ,size): #初始化；qu：队列的主体；size：队列的容量

         qu .queue=[]; #列表里的元素可以修改，所以用队列作为主体

         qu .size=size

         qu .head=- 1

         qu .tail=- 1

     def  Empty( qu ):

         if  qu .head== qu .tail: #队尾队首指针重合

             return  True

         else :

             return  False

     def  Full( qu ):

         if  qu .tail- qu .head+ 1 == qu .size: #队首队尾指针的距离为容量

             return  True

         else :

             return  False

     def  enQueue( qu ,content):

         if  qu .Full():

             print  "Full"

         else :

             qu .queue.append(content) #数据放入队列

             qu .tail= qu .tail+ 1 #队尾指针加一

     def  outQueue( qu ):

         if  qu .Empty():

             print  "empty"

         else :

             qu .head= qu .head+ 1 #队尾指针不变，队尾指针加一

     #队列的使用

t=Queue( 7 )

t.Empty()

t.enQueue( "sfg" )

t.Empty()

十五、基本的正则表达式

    常用符号：点号，星号，问好，小括号

     .：匹配任意字符，换行符\n除外

     *：匹配前一个字符0次或无限次

     ？：匹配前一个字符0次或1次

     .*：贪心算法，吃尽可能的东西

     .*?:非贪心算法

     ():括号内的数据作为结果返回

         # 导入正则表达式的库文件 re

import  re

# 密码

secret_code= "hadkfexxIxxfasfjifa123xxlovexx23345sdfaxxyouxx8dfs"

#. 的使用

a= 'xz123'

b=re.findall( 'x.' ,a) #. 就是一个占位符，几个点就是几个符号

print  b 输出：['xz']

#* 的使用

a= 'xzx123'

b=re.findall( 'x*' ,a) #. 就是一个占位符，几个点就是几个符号

print  b 输出：['x', '', 'x', '', '', '', '']

#? 的使用

a= 'xzx123'

b=re.findall( 'x?' ,a) #. 就是一个占位符，几个点就是几个符号

print  b 输出：['x', '', '', '', '', '', '']

#.* 贪心算法

b=re.findall( 'xx.*' ,secret_code)

print  b 输出：['xxIxxfasfjifa123xxlovexx23345sdfaxxyouxx']

#.*? 非贪心算法

c=re.findall( 'xx.*?xx' ,secret_code)

print  c 输出：['xxIxx', 'xxlovexx', 'xxyouxx']

#(.*?)

d=re.findall( 'xx(.*?)xx' ,secret_code)

print  d 输出： ['I', 'love', 'you']

for  each  in  d:

     print  each 输出：I

                                   love

                                   you

    

    方法：findall，search，sub

     findall：匹配所有符合规律的内容，返回包含结果的列表。遍历整个文件

     Search：匹配并提取第一个符合规律的内容，返回一个正则表达式对象。找到所需，就不找了

     Sub：替换符合规律的内容，返回替换后的值

         s= '''aefadxxhelo

xxsdfdsdfxxwordxxsfds'''

e=re.findall( 'xx(.*?)xx' ,s)

print  e 输出：['sdfdsdf']

f=re.findall( 'xx(.*?)xx' ,s,re.S) #re.S 是为了包括换行符， s 是让点匹配任意字符包括新的一行在政策表达式的库文件中有介绍

print  f 输出：['helo\n', 'word']

# 对不 findall 与 search 的区别

s2= 'sdfxxIxxafxxlovexxdfdfgxxxiangxxfdg'

#group 代表匹配的括号有几个

g=re.search( 'xx(.*?)xxafxx(.*?)xx' ,s2).group( 2 )

print  g 输出：love

g2=re.findall( 'xx(.*?)xxafxx(.*?)xx' ,s2)

print  g2[ 0 ][ 1 ] 输出：love

#sub

s= '123sadfsfdg123'

output = re.sub( '123(.*?)123' , '123789123' ,s)

print  output 输出：123789123

output1 = re.sub( '123(.*?)123' , '123%d123' % 789 ,s)

print  output1 输出：123789123

    常用技巧：

     import re推荐使用

     from re import*

     from re import findall,search,sub,S

     不需要compile

     使用\d+匹配纯数字

         # 匹配纯数字

a= 'asdfasf1234sdfaf777sadgf'

b =re.findall( '(\d+)' ,a)

print  b 输出：['1234', '777']

    

     # 正则表达式应用

# 注意：先抓大，在抓小

import  re

old_url= 'http://www.jikexueyuan.com/course/android/?pageNum=2'

total_page= 20 # 假设有 20 页

f= open ( 'text.txt' , 'r' ) # 打开文件

html=f.read() # 读取文件，保存至 html

f.close()

# 爬取标题 , 确认标题只有一个，用 search

title=re.search( '' ,html,re.S).group( 1 )

print  title

# 爬取链接

links=re.findall( 'href="(.*?)"' ,html,re.S)

for  each  in  links:

     print  each

# 提取部分文字信息，先抓大，后小

# 抓取 ul 部分里的

text_fied=re.findall( '

(.*?)

' ,html,re.S)[ 0 ]

the_text=re.findall( '">(.*?)' ,text_fied,re.S)

for  every_text  in  the_text:

     print  every_text

# 实现翻页

for  i  in  range ( 2 ,total_page+ 1 ):

    new_link = re.sub( 'pageNum=\d+' , 'pageNum=%d' %i,old_url,re.S)

     print  new_link

页面代码；text.txt

    

        

    

    

        huanying

            

             

                 

1 笨笨

                  

2 软软

                  

3 向冲

                

            

        

    

     制作文本爬虫：

         目标网站： http://jikexueyuan.com

         目标内容：课程图片

         实现原理：1.保存网站源代码——手动获取：半自动爬虫，人肉爬虫

                   2.python读文件加载源代码

                   3.使用正则表达式提取图片网址

                   4.下载图片

     # 文本爬虫

     import  re

import  requests # 获取网页文件的利器

# 读取源文件

f= open ( 'textsource.txt' , 'r' )

html=f.read()

f.close()

# 匹配图片网址

pic_url=re.findall( 'img src="(.*?)" class="lessonimg"' ,html,re.S)

i= 0

for  each  in  pic_url:

     print  'now downloading:'  + each

    pic=requests.get(each)

    fp= open ( 'pic\\' + str (i)+ '.jpg' , 'wb' )

    fp.write(pic.content)

    fp.close()

    i+= 1

十六、单线程爬虫

爬取极客学院的课程库，爬取到的数据存储在文本文件中

requests的介绍，安装

requests：HTTP for Humans

  完美代替python的urllib2模块

  更多的自动化

  更友好的用户体验

  更完善的功能

安装：

win:pip install requests

linux:sudo pip install requests

第三方库安装技巧：少用easy_install，因为只能安装不能卸载

  多用pip方式安装

安装时撞墙怎么办：www.lfd.uci.edu/~gohlke/pythonlibs/

拥有所有python第三方库文件。找到requests，带有.whl的文件，下载。后缀改为zip，解压缩。将requests文件夹复制到Lib文件夹中

    

第一个网页爬虫

    request获取网页源代码

     直接获取网页源代码

             import  requests

# 获取 python 的首页源代码，输出的文字在页面查找，可以找到说明源代码获取成功

html=requests.get( 'http://tieba.baidu.com/f?ie=utf-8&kw=python' )

print  html.text

     修改http头获取源代码：反爬虫机制

             # 有些网站会检查访问的程序，需要修改 http 头文件

             import  requests

             #hea 的 User-Agent 是面具，是个字典 . 让网站以为是浏览器在访问，而不是爬虫

'''

获取 User-Agent ：

1. 网站页面：审核元素。 2. 选择 network ，里面是空的，刷新页面。

3. 随便点击一个内容，在 headers 栏目中的 Request headers 中有 User-Agent 的值

'''

hea={ 'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36' }

html=requests.get( 'http://jp.tingroom.com/yuedu/yd300p' , headers =hea)

html.encoding= 'utf-8'

print  html. text

    使用requests与正则表达式找要的内容

         import  requests

import  re

hea={ 'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36' }

html=requests.get( 'http://jp.tingroom.com/yuedu/yd300p' , headers =hea)

html.encoding= 'utf-8'

title=re.findall( '"color: #039;">(.*?)' ,html.text,re.S)

for  each  in  title:

     print  each

输出：300篇精选中日文对照阅读 289 挪威的森林（中日对照）第二章

   300篇精选中日文对照阅读 288  挪威的森林（中日对照）第一章

   300篇精选中日文对照阅读 287  藤野先生——名文选读

   300篇精选中日文对照阅读 286  夏目漱石 我是猫 第一章

   300篇精选中日文对照阅读 285 それお皿の絵柄よ

   300篇精选中日文对照阅读 284 つもり

等等。。。

            

向网页提交数据

    Get与Post（与服务器交互方式）：

     Get：从服务器上获取数据

     Post：向服务器传送数据

     Get：通过构造url中的参数来实现功能

     Post：将数据放在header提交数据

    分析目标网站： https://www.crowdfunder.com/browse/deals

        点击更多，网站浏览器网址不变：说明网站是异步加载（先把网页框架加载起来，其他的内容慢慢加载）。

        加载进来的内容在源代码中找不到，1.运用打开审核元素反的network，点击更多，headers会有信息出现。2.查看request Method的值，发现是post，表明向网站发送了请求，请求地址是Request URL：。3.再查看From Data的page：的值，就是加载的页数。

        说明，如果我们能构造一个From Data，就能向网页请求提交信息了。

    Requests的表单提交：

        核心方法：requests.post

        核心步骤：构造表单-提交表单-获取返回信息

import  re

import  requests

# url='https://www.crowdfunder.com/browse/deals/'

# html=requests.get(url).text

# print html

url =  'https://www.crowdfunder.com/browse/deals&template=false'

data = {

     'entities_only' : 'true' ,

     'page' : '2'

}

html_post = requests.post(url, data =data)

title = re.findall( '"card-title">(.*?)

' ,html_post.text,re.S)

for  each  in  title:

     print  each

    

    

极客学院的课程爬虫

    目标网站：http://www.jikexueyuan.com/course/

    目标内容：课程名称，课程介绍，课程时间，课程等级，学习人数

    设计知识：requests获取网页

              re.sub换页

              正则表达式匹配内容

    分析网站：1.换页时URL发生变化：http://www.jikexueyuan.com/course/?pageNum=2

          http://www.jikexueyuan.com/course/?pageNum=3

          。。。。。

              2.查看源代码

      3.爬取思路：先源码down下来，之后先正则表达式遍历整个页面，分别爬课程名称，课程介绍，课程时间，课程等级，学习人数。

         用for循环将信息一一对应。问题：个别标签为空。使用for循环时对应有问题。

        解决方法：先抓大，后抓小

     import  re

import  requests

# 因为 pycharm 默认编码是 gbk ；网页的默认编码是 utf-8. 编码不匹配，容易乱码，所以以下三行代码将编码器强制转换

import  sys

reload (sys)

sys.setdefaultencoding( "utf-8" )

class  spider( object ):

     def  __init__ ( self ):

         print  u' 开始爬取内容。。。 '

#getsource 用来获取网页源代码

     def  getsource( self ,url):

        html = requests.get(url)

         return  html.text

#changepage 用来生产不同页数的链接

     def  changepage( self ,url,total_page):

         # 当前的页数

         now_page =  int (re.search( 'pageNum=(\d+)' ,url,re.S).group( 1 ))

         # 定义一个列表

         page_group = []

         for  i  in  range (now_page,total_page+ 1 ):

            link = re.sub( 'pageNum=\d+' , 'pageNum=%s' %i,url,re.S)

            page_group.append(link)

         return  page_group # 将网址保存在  page_group 的列表中，然后返回列表

#geteveryclass 用来抓取每个课程块的信息

     def  geteveryclass( self ,source):

        everyclass = re.findall( '()' ,source,re.S)

         return  everyclass

#getinfo 用来从每个课程块中提取出我们需要的信息

     def  getinfo( self ,eachclass):

        info = {} # 定义字典

         info[ 'title' ] = re.search( 'target="_blank">(.*?)' ,eachclass,re.S).group( 1 )

        info[ 'content' ] = re.search( '

(.*?)

' ,eachclass,re.S).group( 1 )

         # 有两个 em 标签，因此获取到的第一个是时间，第二个是等级

         timeandlevel = re.findall( '(.*?)' ,eachclass,re.S)

        info[ 'classtime' ] = timeandlevel[ 0 ]

        info[ 'classlevel' ] = timeandlevel[ 1 ]

        info[ 'learnnum' ] = re.search( '"learn-number">(.*?)' ,eachclass,re.S).group( 1 )

         return  info

#saveinfo 用来保存结果到 info.txt 文件中

     def  saveinfo( self ,classinfo):

        f =  open ( 'info.txt' , 'a' ) #a ：追加的方式打开

         for  each  in  classinfo:

            f.writelines( 'title:'  + each[ 'title' ] +  '\n' )

            f.writelines( 'content:'  + each[ 'content' ] +  '\n' )

            f.writelines( 'classtime:'  + each[ 'classtime' ] +  '\n' )

            f.writelines( 'classlevel:'  + each[ 'classlevel' ] +  '\n' )

            f.writelines( 'learnnum:'  + each[ 'learnnum' ] + '\n\n' )

        f.close()

if  __name__ ==  '__main__' :

    classinfo = [] # 得到一个空列表，用来保存信息

     url =  'http://www.jikexueyuan.com/course/?pageNum=1'

     jikespider = spider()

    all_links = jikespider.changepage(url, 20 )

     for  link  in  all_links:

         print  u' 正在处理页面： '  + link

        html = jikespider.getsource(link)

         # 获取每一条课程

         everyclass = jikespider.geteveryclass(html)

         for  each  in  everyclass:

            info = jikespider.getinfo(each) #getinfo ：获取信息

             classinfo.append(info) #classinfo 这个列表里，保存了很多的字典

     jikespider.saveinfo(classinfo)

    输出：开始爬取内容。。。

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=1

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=2

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=3

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=4

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=5

    正在处理页面：http://www.jikexueyuan.com/course/?pageNum=6

    。。。。

    

十七、XPath与多线程爬虫

神器XPath：XML Path Language。一门语言，

   可以再xml文档中查找信息，提取信息，比正则表达式厉害，简单

   支持HTML，

   通过元素和属性进行导航

安装：安装lxml库，

      from lxml import etree

      Selector=etree.HTML

神器XPath的使用:

XPath与HTML结构：HTML:树状结构，逐层展开，逐层定位，寻找独立节点

获取网页元素的XPath：

            手动分析法

            chrome生成法

            copy值为：//*[@id="useful"]/li[1]

            *：只有一个id=useful，所以用*

            li[1]:第一条信息，去除[1]将以列表的形式返回

应用XPath提取内容

             from  lxml  import  etree

html =  '''

    

    

    

        

这是第一条信息

        

这是第二条信息

        

这是第三条信息

    

    

        

不需要的信息 1

        

不需要的信息 2

        

不需要的信息 3

    

    

         极客学院

        极客学院课程库 "> 点我打开课程库