python学习笔记[0]

（刚过了元旦，开启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

 

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

 

                                                                                   【热爱工作，热爱生活】