一、Python介绍

    Python是一种解释型、面向对象、动态数据类型的高级程序设计语言，Python由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年，像Perl语言一样, Python 源代码同样遵循 GPL(GNU General Public License)协议。
    ython的3.0版本，常被称为Python 3000，或简称Py3k，相对于Python的早期版本，这是一个较大的升级，为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下兼容。

Python安装：

下载Python安装程序:
https://www.python.org/ftp/python/2.7.14/python-2.7.14rc1.amd64.msi
在下载python的时候，一定要下载对应自己系统的版本

Pip

和yum、apt-get一样，自动从服务器中安装python库
在linux系统中自带了python，但是没有pip程序，ubuntu可以使用sudo apt install python-pip或python3-pip（yum install pip）

编辑器

sublime text
pycharm

中文乱码解决

python脚本乱码，在python脚本最前面加上

#coding:utf-8

调整windows命令行乱码

chcp 65001

二、标识缩进

注释

python中单行注释采用 # 开头
python 中多行注释使用三个单引号(''')或三个双引号(""")
在编写python程序的时候，最好编写注释，方便修改代码，排错

标识(变量)

标识(变量)命名规则

1.在 Python 里，标识符由字母、数字、下划线组成
2.在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头
3.Python 中的标识符是区分大小写的
4.以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入
5.以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数

6.命名时不能与保留标识符重名

Python保留标识符：
and  exec  not  assert  finally  or  break  for  pass  class  from  print  continue  global  raise  def  if  return  del  import  elif  in  while  else  is  with  except  lambda  yield

标识缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断，python 最具特色的就是用缩进(空格)来写模块，缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
Python语句中一般以新行作为为语句的结束符，但是我们可以使用斜杠（\）将一行的语句分为多行显示
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，不同行不需要写分号

三、输入输出

输出

print
        输出内容
print,
        输出内容并且不换行
print type()
        输出数据类型

输入

raw_input
        python中使用此函数接收命令行输入的内容(交互)

四、数据类型

numbers（数字）

Int（有符号整型）
a=100
float（浮点型）
b=1.29
long（长整型[也可以代表八进制和十六进制]）
c=111111111111111111111111
complex（复数）
d=1+2j

string（字符串）

定义

单行：str="sadasd"

多行：
str1='''
12
34
'''

下标

    从左到右索引默认0开始的，最大范围是字符串长度少1
    从右到左索引默认-1开始的，最大范围是字符串开头

切片

    通过变量名字来进行数据切割（取出字符串的数值）
    print str[0:3:2]
    第一个数是从哪个下标开始，第二个数是在哪个下标结束，第三个数是步长(隔几个数取一个)

增删改查

增(拼接字符串)
使用+进行拼接
注意：无法拼接不同类型，比如字符串和数字，需要使用str函数将数字强制转换为字符串，或者使用格式化
删
del ， 推荐使用切片操作

改
    .前的str为字符串名
    str.strip()
        去除两边空格,如果指定字符就是去除指定字符
    str.lstrip()
        去除左边的空格,如果指定字符就是去除指定字符
    str.rstrip()
        去除右边的空格,如果指定字符就是去除指定字符

查
    .前的str为字符串名
    str.find()
        从开头查找到字符串的下标，找到返回第一次出现的位置，没找到返回-1
    str.rfind()
        从结尾查找到字符串的下标，找到返回第一次出现的位置(从开头数)，没找到返回-1

转义符

格式化

特定格式符格式化

Python 支持格式化字符串的输出，尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符%s的字符串中

格式化符号：
            

使用：

插入单个
        print "萨达萨达%s" %"阿达"
插入多个
        print "这是%s%d" %(str4,555)
可使用变量，也可直接输入

format()格式化函数格式化

Python2.6开始，新增了一种格式化字符串的函数str.format(), 它增强了字符串格式化的功能，基本语法是通过(}和:来代替以前的%，format函数可以接受不限个参数，位置可以不按顺序。

使用：
1.不设置指定位置，按默认顺序
    print "阿达外网{}{}".format("22","asdas")
2.指定位置(0开始)
     print "阿达外网{1}{0}".format("22","asdas")
可使用变量，也可直接输入

list（列表）

介绍

 List（列表） 是 Python 中使用最频繁的数据类型
列表可以完成大多数集合类的数据结构实现，它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型

a = ['fff', 2434, ['erwr', 242 ] ]

切片

截取从第一个指定位置到另一指定位置中间的值

sublist = list1[0:3]
print sublist

截取指定位置的值

print list1[2]

列表增删改查

增：
append()
在list1后面追加元素

list1.append(1)
print list1

insert()
在list1指定位置后追加元素

list1.insert(1,'b')
print list1

extend()
在list1后面追加另一个一个数组

list2=[5,5]
list1.extend(list2)
print list1

删：
del list1[]
删除指定位置的值

del list1[0]
print list1

list1.pop()
删除最后一个值

list1.pop()
print list1

list1.remove()
删除第一个指定的值

list1.remove(1)
print list1

改：=
直接对应位置赋值

list1[2]=10
print list1

查
in
判断元素是否在列表内

print 9 in list1
print 2 in list1

tuple（元组）

介绍

元组是另一个数据类型，类似于List（列表），元组用"()"标识，内部元素用逗号隔开，但是元组不能二次赋值，相当于只读列表
除了修改数据，其他使用同列表list

dictionary（字典）

介绍

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型，列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
字典用"{ }"标识，字典由索引(key)和它对应的值value组成

dict = {"name":"lp","age":"24"}

字典键要求
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

增加值

dict = {"name":"lp","age":"24"}
dict["a"]="bbb"

五、运算符

算术运算符

以下假设变量: a=10, b=20:
    +
        两个对象相加
        a+b输出结果30
    -
        得到负数或是一个数减去另一个数
        a- b输出结果-10
    *
        两个数相乘或是返回一个被重复若千次的字符串
        a* b输出结果200
    /
        x除以y
        b/a输出结果2
    %
        返回除法的余数
        b%a输出结果0
    **
        返回x的y次幂
        a**b为10的20次方，输出结果1000000000000000000
    //
        取整除-返回商的整数部分
        9//2输出结果4 , 9.0//2.0 输出结果4.0

比较运算符

以下假设变量a为10,变量b为20:
    ==
        等于-比较对象是否相等
        (a == b)返回False
    !=
        不等于-比较两个对象是否不相等
        (a != b)返回true
    <>
        不等于-比较两个对象是否不相等
        (a <> b)返回true， 这个运算符类似!=
    >
        大于-返回x是否大于y
        (a> b)返回False
    <
        小于-返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。
        (a < b)返回true
    >=
        大于等于-返回x是否大于等于y
        (a>= b)返回False
    <=
        小于等于-返回x是否小于等于y
        (a <= b)返回true

赋值运算符

以下假设变量a为10，变量b为20:
    =
        简单的赋值运算符
        c=a+b将a+ b的运算结果赋值为C
    ==
        C +=a等效于C=C+ a
        加法赋值运算符
    _=
        减法赋值运算符
        c-=a等效于c=c-a
    *=
        乘法赋值运算符
        C*=a等效于c=C*a
    /=
        除法赋;值运算符
        c/=a等效于C=C/ a
    %=
        取模赋值运算符
        C%=a等效于C=C%a
    **=
        幂赋值运算符
        C**=a等效于c=C**a
    //=
        取整除赋值运算符
        c//=a等效于C=C// a

位运算符

    &
        按位与运算符:参与运算的两个值，如果两个相应位都为1，则该位的结果为1,否则为0 
        (a & b)输出结果12，二进制解释: 0000 1100
    |
        按位或运算符:只要对应的二个二进位有一个为1时，结果位就为1
        (a | b)输出结果61，二进制解释: 0011 1101
    ^
        按位异或运算符:当两对应的二进位相异时，结果为1
        (a ^ b)输出结果49，二进制解释: 0011 0001
    ~
        按位取反运算符:对数据的每个二进制位取反,即把1变为0，把0变为1，~x 类似于-x-1
        (~a ) 输出结果-61，二进制解释: 1100 0011,在一个有符号二进制数的补码形式。
    <<
        左移动运算符:运算数的各二进位全部左移若干位，由"<<"右边的 数指定移动的位数，高位丢弃，低位补0。
        a << 2输出结果240,二进制解释: 1111 0000
    >>
        右移动运算符:把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数
        a >> 2输出结果15，二进制解释: 0000 1111

逻辑运算符

以下假设变量a为10，变量b为20:
    and
    x and y
        布尔"与”-如果x为False, x and y返回False,否则它返回y的计算值。
        (a and b)返回20
    or
    x or y
        布尔"或"-如果x是非0，它返回x的值，否则它返回y的计算值。
        (a or b)返回10
    not
    not x
        布尔"非" -如果x为True,返回False，如果x为False,它返回True。
         not(a and b)返回False

成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组
    in
        如果在指定的序列中找到值返回True,否则返回False
            x在y序列中，如果x在y序列中返回True
    not in
        如果在指定的序列中没有找到值返回True,否则返回False
            x不在y序列中，如果X不在y序列中返回True

六、流程控制

条件语句

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块

用法

if 判断条件:
    执行语句……
elif 判断条件:
    执行语句……
else:
    执行语句……

循环语句

程序在一般情况下是按顺序执行的，编程语言提供了各种控制结构，允许更复杂的执行路径，循环语句允许我们执行一个语句或语句组多次

While循环

while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。

用法

基本
while 判断条件:
    执行语句……
python中while可以和else一起使用
while 判断条件:
    执行语句……
else:
    执行语句……

for循环

Python for循环可以遍历任何序列的项目，如一个列表，一个字符串或者一个元组，字典

用法

for x in range(1,100,2):
    print x

注：range(1,100,2)  1到100，隔2取一个数（可随意替换为列表，字符串等）

循环控制

continue是跳过本次循环，继续下一个循环
pass是python中一个特殊的功能，pass是空语句，是为了保持程序结构的完整性(占位)

for x in range(1,99):
    pass

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。break语句用在while和for循环中

七、函数

介绍

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段，能提高应用的模块性和代码的重复利用率
Python里提供了许多内建函数，比如print()，并且我们也可以自己创建函数，也就是用户自定义函数

自定义函数

定义规则

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
函数内容以冒号起始，并且缩进
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的return相当于返回 None

调用

直接输入函数名加参数进行调用

def cj(num1,num2):
    '''功能：两个数相乘'''
    return num1*num2
print cj(2,3)

参数

必备参数
    函数里定义的参数个数就是调用时必须输入的必备参数(个数一致)

关键字参数
    在传参时按定义时的参数名来指定参数的值
    注意一但开始使用这种方式定义参数，后面的参数都必须使用此方式

默认参数
    定义函数时，直接将参数定义一个默认值，此时如果不指定此参数，参数就是默认值，如果指定就是指定的值
    注意如果定义了默认参数，那么之后的参数都必须是默认参数

不定长参数
    使用*加参数，此时参数的个数不定，用户可随意输入，输入后值存储在以此参数名命名的元组中
    注意，不定长参数可与其他参数混用，需要将其他参数写到前面

lambda函数

python使用lambda来创建匿名函数（单行函数）

介绍

    lambda只是一个表达式， 函数体比def简单很多。
    lambda的主体是一个表达式， 而不是一个代码块， 仅仅能在lambda表达式中封装有限的逻辑进去
    lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
    虽然lambda函数看起来只能写 一行，却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率

语法

lambda函数的语法只包含一个语句，如下:

sum=lambda x,y:x+y
print sum(1,2)

八、类

面向对象技术简介

    类(Class): 用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实例
    类变量: 类变量在整个实例化的对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用
    数据成员: 类变量或者实例变量盱处理类及其实例对象的相关的数据
    方法重写: 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override) ，也称为方法的重写
    实例变量:定义在方法中的变量，只作用于当前实例的类
    继承:即一个派生类(derived class) 继承基类(base class) 的字段和方法，继承也允许把一个派生类的对象作为一个基类对象对待
    实例化: 创建一个类的实例，类的具体对象
    方法: 类中定义的函数
    对象: 通过类定义的数据结构实例,对象包括两个数据成员(类变量和实例变量)和方法

创建与调用

使用class语句来创建一个新类，class之 后为类的名称并以冒号结尾

例

#coding:utf-8
class lei:
    name=None;age=None      #定义属性为空
    def info(self):                       #定义方法，类里方法第一个参数必须是self，传参时从第二个开始
        '''打印一个人的属性'''
        print self.name,"-",self.age        #使用self调用属性
P1=lei()                                 #定义对象
P1.name="xr";P1.age=25     #给P1定义属性
P1.info()                                #调用类里的info方法

构造函数

在给对象定义属性时可以使用构造函数def __init__(self):一次定义

使用

#coding:utf-8
class lei:
    name=None;age=None      #定义属性为空
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):              #定义方法，类里方法必须有self参数
        '''打印一个人的属性'''
        print self.name,"-",self.age     #使用self调用属性
P1=lei("lpxr","20")         #定义对象并对属性赋值
P1.info()                         #调用类里的info方法

继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制，继承完全可以理解成类之间的类型和子类型关系。

在python中继承中的一些特点:

在继承中基类的构造(__init__()方法) 不会被自动调用，它需要在其派生类的构造中亲自专门调用。

在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找(先在本类中查找调用的方法，找不到才去基类中找)

继承后可以新加方法，也可以对原方法进行重写，直接对继承过来的方法重新定义即可重写

语法：（xzq2继承xzq）

class xzq2(xzq):

例子：

#coding:utf-8
class xzq:
    """下载器，需要有下载方法和数据储存方法"""
    data=[]
    def xz(self,url):
        """数据下载方法"""
        #通过url将数据储存在内存中
        result=url
        self.data.append(result)
    def cc(self):
        """数据储存方法"""
        print self.data,"已存储"
d1 = xzq()
d1.xz("www.baudu.com")
d1.cc()

class xzq2 (xzq):
    def xz(self,url):
        '''新下载器'''
        print "新的下载方法"
        result=url
        self.data.append(result)
d2=xzq2()
d2.xz("iii")
d2.cc()

九、文件操作

文件打开

python中使用 open 函数来打开文件，打开后才可以执行读写等操作

file = open ("文件路径","模式")

模式：

r：以只读方式打开文件，文件的指针将会放在文件的开头，这是默认模式。
rb：以二进制格式打开一个文件用于只读。 文件指针将会放在文件的开头。这是默认模式。
r+：打开一个文件用于读写。文件指针将会放在文件的开头。
rb+：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w：打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+：打开个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a：打开一-个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+：打开一一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

文件读取

首先打开文件，file为打开的文件的句柄

file.read([size])

从文件读取指定的字节数，如果未给定或为负则读取所有

file.readline([size])

读取整行，包括 "\n" 字符，写一次读一行，加上逗号就没有换行符

结合循环读取所有

while 1:
    str=file.readline().strip()
    if str:
        print str
    else:
        break

file.readlines([sizehint])

读取所有行并以列表形式返回

文件写入

首先打开文件，file为打开的文件的句柄

file.write("\n内容")

将字符串写入文件，没有返回值

十、异常处理

异常

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行

一般情况下，在Python无法正常处理程序时就会发生一个异常，异常是Python对象，表示一个错误，当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行

异常处理

捕捉异常可以使用try/except语句，try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果不想在异常发生时结束你的程序，只需在try里捕获它，让之后的程序继续执行

使用

#coding:utf-8
try:
    file=open("1.txt","r")
    file.write(54)
except:
    print "文件打印失败"
print 555

针对不同类型异常进行分别处理

例如对IOError类型和NameError类型的异常进行分别处理

#coding:utf-8
try:
    file=open("1.txt","r")
    print 1 / 0
    print sd
    file.write(54)
except IOError:
    print "IOError:文件打印失败"
except NameError:
    print "NameError:语法错误"
except:
    print "其他错误等待处理"
print 555

python模块

介绍

    Python模块(Module). 是一个Python 文件，以.py结尾，包含了Python 对象定义和Python语句
    模块让你能够有逻辑地组织你的Python 代码段
    把相关的代码分配到一个模块里能让你的代码更好用，更易懂
    模块能定义函数，类和变量，模块里也能包含可执行的代码

urllib/urllib2

提供了一系列用于操作UPL的功能

re

正则表达式模块

beautiful soup

数据提取模块

threading

多线程模块

threadpool

线程池模块

socket

套接字模块

............具体使用模块编写脚本的方法见本人其他文章