（刚过了元旦，开启14年新篇章。。。今天看到一句话：一个程序员除了熟练掌握一门静态语言外至少需掌握一门脚本语言，还好我看到的不算迟，一直想学python,就从现在开始吧~）

首先，罗列一下python的解释

【1】Python是一个面向对象开发语言，大部分情况下被用来作脚本的开发，所以也有一大部分的人说他是脚本语言
【2】Python的优点：

       高质量
       高效率————不用像C C++静态语言一样，进行编译连接，直接可以运行
       可移植————适用于各种平台linux windows Mac Unix android等，可直接将这个平台的程序拷贝到另一个平台运行
       很多可用的组件
【3】Python的缺点：因为他不会编译生成二进制文件，也就是计算机底层文件，所以运行速度较之C C++稍逊色
【4】Python可以用来干什么？
              可以说Python无所不能，涉及领域有网页、游戏、图像、人工智能等

好了，正式拉开学习帷幕：

【备注：我是用《Python学习手册》第四版学习的，同时参考http://blog.csdn.net/ithomer/article/details/8907268#python文章进行学习的，下面的页码是书中页码，为了方便我下次看时能找得到地方；EX:/ex:表示举例；Tips:表示一个标记】

1.P95 用input()来使程序暂停
2.P124 类型：
       1）数字：
       Python支持类型扩展  例如计算2的100次方时，在C++中没有一个类型可以容下这个结果1267650600228229401496703205376，而python会自动提供较大的精度，以适用于较大数值
       可以引入math模块，import math,就像包含了一个数学库一样，你可以使用模块中的常量方法等   例如 PI  sqrt(9)
       2)字符串：'spam’
       所支持的方法：len();
                                   []索引           //可以正向也可以反向索引         ex:s = 'spam',s[0]——'s',s[-1]——s[len(s)-1]等于'm'
                                   分片操作(抽离操作)：slice  s[1:3] 从字符串偏移量为1的位置开始到但不包括偏移量为3的位置的字符提取出来组成一个新字符串并返回，即返回‘pa’ex2:s[1]  'pam'  s[-1] 'spa'
                                  +合并：s+'aaa'   'spamaaa'
                                  *n      ：重复n遍   s*3  'spamspamspam'
              ___________________________________

以上方法均为序列式类型变量通用方法，下面几个是字符串特定方法,注意所有对字符串进行的操作都不会改变原字符串，而是返回一个新字符串
              len()
              find()
              replace('pa','XYZ')
              split(',')   将一个字符串以','分割开来 ex: line = 'aaa,bbb,ccc';line.split(',');返回一个数组['aaa','bbb','ccc']
              upper(s)     将字符串s变大写
              ......还有多如牛毛的方法来操作字符串，具体请看帮助 dir(line) 可以看到字符串所支持的方法，help(line.upper) 可看到字符串upper方法的帮助  注：line为字符串类型变量P129
             Tips： python支持将三个引号（单引号 双引号都可以）内的多行字符合并在一起，并为每一行末添加一个'\n' 
                ex： s = """aaaaa
                  '''bbb"bb
                  "ccc"""
                  printf(s) 输出'\naaaaa\n\'\'\'bbb\"bb\n\"ccc'
        3)序列：类似于数组，但区别是不限类型（即一个序列中可存放一种以上不同类型元素），且大小像vector一样可动态变化
         除了上面字符串支持的基本序列操作，它还支持其他操作：
         L = ['aaa',123,1.2]
         L.append('www')     ['aaa',123,1.2,'www']  增加元素
         L.pop(2)            ['aaa',123,'www']      删除元素    TIPS :不同于字符串，这些操作都会改变原对象，
         L = [4,3,0,9]
         L.sort()            [0,3,4,9]
         L.reverse()
         利用序列可以描述矩阵 ：array = [[1,2,3],[4,5,6],[7,8,9]]
         Tips1:array   输出整个矩阵     array[0]  输出0行  array[0][1]输出元素2
         Tips2:>>> col2 = [row[1] for row in array]
                    >>> print(col2)
                    [2, 5, 8]
                    >>> col2 = [row[1]+1 for row in array]   //对所取出的第一列元素值都+1
                    >>> print(col2)
                   [3, 6, 9]
                   >>> print(array)
                   [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  //发现并没有改变原矩阵
   Tips3:  >>> X = [array[i][i] for i in [0,1,2]]
                >>> print(X)
                [1, 5, 9]
               //利用循环变量
                EX：>>> X = [c*2 for c in 'spam']
                        >>> print(X)
                         ['ss', 'pp', 'aa', 'mm']
  Tips：range(n)可以生成n个元素的序列，这个表的元素都是整数，从0开始，下一个元素比前一个大1， 直到函数中所写的上限 （不包括该上限本身）
             EX:>>> M=range(5)
             >>> M
             [0, 1, 2, 3, 4]
 4)字典：类似于map，不拘泥于类型   {键：值}
                >>> M ={'name':'wyy','year':21,'sex':'Female'}
                >>> print(M)
               {'sex': 'Female', 'name': 'wyy', 'year': 21}
              ※字典中的元素是无序的，你不能通过下标来获取元素，而只能通过key

    >>> M['name']
    'wyy'
    EX:  按键值排序  字典不支持sort函数，我们得这样用for循环输出某序元素
     >>> M = {'a':1,'b':3,'c':4}//一个字典
     >>> print(M)
    {'a': 1, 'c': 4, 'b': 3}//打印出的结果并不是按照我们输入的顺序而来，键是无序的
     >>> l = list(M)//取出字典的键成为一个序列
     >>> l
    ['a', 'c', 'b']
    >>> l.sort()//対键进行排序
     >>> print(l)
   ['a', 'b', 'c']
   >>> for key in l:
   print(key,'=>',M[key])//按序列l的顺序循环输出字典

 
   ('a', '=>', 1)
   ('b', '=>', 3)
   ('c', '=>', 4)

   ※字典支持用新key进行扩展,但不允许对没有的值进行访问
     EX: >>> M = {'a':1,'b':2,'c':3}
   >>> M
   {'a': 1, 'c': 3, 'b': 2}
   >>> M['e'] = 4
   >>> M
   {'a': 1, 'c': 3, 'b': 2, 'e': 4}
 ※Tips循环遍历字典  for key in M:
      print M[key]
 ※字典支持的其他方法
  M.keys()    返回所有键
  M.values()  返回所有值
  M.items()   返回所有的元素
  M.clear()   清空字典 
  len(M)       多少对    
 5）元组————元组中的内容不可变是const

--------------------------------------------------------------------------------------------

【备注：以下内容是学习http://blog.csdn.net/ithomer/article/details/8907268#python所写下的笔记】
1.函数的定义：
   def function_name(a,b,c):
    statement
    return something  # return不是必须的
   
    EX：
>>> a = 1
>>> b= 2
>>> def func(a,b):
 return a+b

>>>
>>> print(func(3,4))
7
  基本数据类型的参数：值传递

  表作为参数：指针传递
  return 可以返回多个值   EX： >>> def func(a,b):
                                                        c = a+b
                                                        return a,b,c

                                                       >>> print func(2,3)
                                                      (2, 3, 5)
2.Python中类的定义：
   EX：

class Bird(object):
 have_feather = True
 way_to_birth = 'agg'
 //定义方法
 >>> class Bird(object):
 def move(self,dx,dy):                                       //这里的self相当于this指针，在函数定义时要写出，但是在调用时不用写出
  pos = [0,0]
  pos[0] = pos[0]+dx
  pos[1] = pos[1] + dy
  return pos

 

 
 //定义对象
 mBird = Bird()
// 引用属性：

print mBird.have_feather
 //引用方法
 >>> mBird.move(3,4)
 [3, 4]
 //继承：

  class Chicken(Bird):
   can_fly = False
 >>> mChicken = Chicken()
  >>> print(mChicken.can_fly)

 

3.入门教程9
  最好不要通过类方法修改类属性，因为如果一修改，所有对象的这个属性都会被修改，这个属性就相当于C++中static属性 所有对象只有一份，但不包括mutable类型的变量，EX：数字，字符串，因为这些类型会为每个对象复制一份，就像你写了一个函数，对这个外部变量进行修改，实质上是没有修改原变量只是修改其副本
  EX:

 >>> class Base(object):
 Age = 0
 List= ["yellow","Red"]
 
 >>> a1 = Base()
 >>> a2 = Base()
 >>> a1.Age = 3//修改类属性Age
 >>> a1.Age
 3             //a1的Age属性变化
 >>> a2.Age
 0             //a2没变化     因为数字类型是mutable的，每一个对象会复制出一份
 //修改不可变类型变量
 >>> a1.List[0] = "Blue"
 >>> a1.List
 ['Blue', 'Red']//改变
 >>> a2.List
 ['Blue', 'Red']//改变

4.入门教程9 类的构造函数

  __init__(self,parameter):
        EX:>>> class Base(object):
 Age = 0
 List= ["yellow","Red"]
 def __init__(self,keys):
  print("my key :",keys)

  
 >>> a = Base(4)
 ('my key :', 4)//__init__方法在创建对象时自动被调用

5.入门教程9             对象的私有属性，属于对象本身，每个对象式独立的  self.attribution
 

EX:>>> class Base(object):
 def __init__(self,keys):
  self.key = keys
 def func(self):
  for i in range(len(self.key))://Tips:注意这里list的遍历
   self.key[i] = self.key[i]+1//改变每个对象的key,

   
 >>> a = Base([1,2,3,4])
 >>> a.func()
 >>> a.key
 [2, 3, 4, 5]
 >>> b = Base([7,8,9,0])
 >>> b.func()
 >>> b.key
 [8, 9, 10, 1]  //各对象不一样

 
 再次强调对象属性与类属性的区别
6.进阶02      文件的输入与输出
 ※创建文件对象   f.open(文件名，模式)  模式简单包含“r”只读 “W”写入 a追加至末尾？？？至今仍有疑问，python同时读写怎么有异常，没弄懂（说是跟一个+号就支持读写同步）
 ※文件读取 
 str = f.read(N)  读取N字节
 str = f.readline() 读取一行
 str = f.readlines()读取所有   将读取结果存入一个序列
 EX: f = open("D:\\TTT.txt","r")
  >>> content = f.readlines()
  >>> content
  ['54321\n', '67890\n', '09876']
7.进阶3 模块module  
 引入模块 import script1  (script1是另一个python文件script.py) 相当于C++中引入另一个库文件#include  <*.h>  完了可以使用库中的方法变量
 不同的是Python中使用模块中的属性时要写成script.attribution 
 EX： //script1.py
  def laugh():
      print("hahahaha")
          //script2.py
           import script1

  for i in range(2):
      script1.laugh()//引用模块script1的属性laugh()
     搜索模块路径：
     当前文件夹 -> 操作系统环境变量PYTHONPATH设置路径 ——> 标准库的安装路径
     
     Tips:如果好几个模块都是一个作用可以将它们放在同一个文件夹下（如：D:\\Test）,通过
     import D:\\Test.script1引入
           注意：在此文件夹下必须有一个__init__.py文件，以提醒python这个文件夹是一个模块包，（该文件是一个空文件而已）
8.进阶4 函数参数传递
 1）位置传递      与函数定义时参数的位置一一对应传入参数
 2）关键字传递  调用函数时在参数列表对参数进行赋值  
   EX：>>> def func(a,b,c):
    print a
    print b
    print c

 
             >>> func(a = 0,c =9,b = 8)
    0
    8
    9
 3）参数默认值
 4）包裹位置与包裹关键字     适用于某个功能的函数，你无法确定他具体传入几个参数，有时只传一个，有时传两个以上
     包裹位置：传参数时只传入具体值   用序列接收
      EX：>>> def func(*list):  //※为了标识list是一个序列，收集了很多参数，给list前加*
    for i in range(len(list)):
    print (list[i])

  
       >>> func(1,2,3,4,5,6)
    1
    2
    3
    4
    5
    6
  包裹关键字：传参数时传入对参数列表的赋值  用字典接收
    EX：>>> def func(**map):  //※为了标识map是字典，用**进行标识
    print type(map)
    print map

 
       >>> func(a=1,b=0,c="hello")
    <type 'dict'>
    {'a': 1, 'c': 'hello', 'b': 0}
 5）解包裹     用于传递参数，就是将要传递的参数封装在了list或字典中，用解包裹的形式传递给函数进行函数调用
   EX:>>> def func(a,b,c):
    print a,b,c
    >>> m=[1,2,3]
    >>> func(*m)//解包裹
    1 2 3
   Tips：如果m的元素数大于参数列表的个数  就会报错
   同理，也有下面样子：
   >>> dict={'a':1,'b':2,'c':3}
   >>> func(**dict) //解包裹
   1 2 3

 

未完，待续........

 

                                                                                   【热爱工作，热爱生活】