Python学习笔记《Python核心编程》第2章 快速入门

Guido van Rossum于1989年底创建python；

Python源文件通常用.py扩展名。Python是按照字节编译的，其结果就是可以生成一种近似机器语言的中间形式。  官网：http://python.org，可以下载相关软件；

输出：

1、print语句：程序输出 print ‘hello World’；

2、下划线 _ 在解释器中表示最后一个表达式的值；

3、print语句与字符串操作符（%）结合使用，可实现字符串替换功能：     

print “%s is number %d!” % ("Python",1); # %s表示由一个字符串来替换，d%表示由一个整型来替换，f% 表示浮点型来替换

输入：

1、raw_input() 内建函数，读取标准输入并读取数据赋值给只定变量；

     >>> user = raw_input("请输入你的名字：")

     >>> print user;

注：内建函数help(),获取一个函数的帮助，如：help(raw_input)

2、input()只接受数字类型输入；

注释：

     1、 从 # 开始，直到一行结束都是注释。

     2、 文档字符串特别注释，在模块、类或者函数的起始添加一个字符串，起在线文档功能

      def foo():

            "this is a doc string."

             return True

操作符：

     +    -    *    /    //    %    **

     python 有两种除法，单斜杠为传统除法（取比商小的最大整数），双斜杠用作浮点除法(对结果四舍五入) 

     双星号（**） 表示乘方操作；

     操作符优先级从高到低为 ** *or/ +-

     比较操作符： <    <=    >    >=    ==    != or <>   逻辑操作符  and    or    not

      >>>  2 < 4 and 2==4

      False

      >>> 2 > 4 or 2 < 4

      True

      >>> 3 < 4 < 5     #Python 支持这样的表达式相当与  3<4 and 4 < 5

      True

变量和赋值：

     1、变量命名规则：以字母或者_开头，其它字符可以是数字、字母、下划线，命名大小写敏感

     2、不需要预先申明变量的类型。

     3、Python 不支持自增1和自减1操作符。

数字：

     有符号整型  长整型   布尔值    浮点值    复数

     int    0101  84   -234   0x80    014   -345    -0x92

     long  238948349L   -841401  oxDASLDKJFLJ

     bool   True     False

     float    3.1415926     4.2E-10     -90.      6.022e23      -1.89e-19

     complex    6.23+1.5j        -1.23-875j     0+1j 

字符串：

     1、用引号包裹，支持单引号（‘’）或者双引号（“”），三引号（三个连续的单引号或者双引号）可以用来包含特殊格式的字符；

     2、使用索引操作符（[]）和切片操作符（[:]）可以得到子字符串，第一个字符索引为0，最后一个字符索引是-1。

     3、加号 + 用于字符串连接运算，星号（*）用于字符串重复；

     >>> pystr = 'python'

     >>> iscool = 'is cool'

     >>> pystr[0]        #'p'

     >>> pystr[2:5]     #'tho'   不包含后面一位

     >>> iscool[-1]      # '!'

     >>> pyshr + iscool   # ‘python is cool!’

     >>> pyshtr *2         #pythonpython

列表 和 元组

      列表元素用中括号（[]）包裹，元素的个数及元素的值可以改变。元组元素用小括号（()）包裹，不可以更改，元组是只读列表，通过切片运算（[]和[:]） 可以得到子集

      >>>  aList = [1,2,3,4]

      >>>  aList[0]    #   1

      >>>  aTuple =  ('a','b','c','d')

      >>> aTuple[:3]     # ('a','b','c')

 

字典

     字典是python中的映射数据类型，由键-值对构成，字典元素用大括号（{}）包裹,类似javascript  中的对象。

      >>>  aDict = {'host':'earth'}     # create dict

      >>>  aDict['port'] =  80            # add to dict

      >>>  aDict                               # {'host':'earth','port':80}

      >>>  aDict.keys()                     #  ['host','port']

      >>>  aDict.values()                   #  ['earth',80]

      >>>  for key in aDict:

                    print key,aDict[key]     #  'host'  'earth'   \n    port    80

代码块及缩进：

      python 通过缩进对齐来表达代码逻辑，而不是大括号。

if 语句 ( python 中的条件表达式不需要用括号括起来 )。结构如下：

     if  expression:
         if_suite

if x < 0:
     print "x 小于 0"

if ... else ... 语句：

if  expression:
    if_suite
else:
    else_suite

if ... elif ... else  语句：

     if expression1:
          is_suite
     elif expression2:
          elif_suite
     else:
          else_suite

while 循环：（while_suite会被连续不断地循环执行，知道表达式的值变成0或者False）

     while expression:

            while_suite

for 循环和range() 内建函数

      python 中的 for 循环与传统的for循环不一样，更像foreach迭代。接受可迭代对象作为其参数，每次迭代其中一个元素。

      for item in ['e-mail','net-surfing','homework','chat']:

           print item 

输出：  e-mail

          net-surfing

          homework

          chat

注： print语句默认会给每一行添加一个换行符。只要在print语句的最后加一个逗号（，），就可以改变它的这种行为（会在元素之间自动添加一个空格,print空语句也会输出一个换行符）。也可以将所有的数据放到一处输出------只需要将数据放在格式化操作符右侧的元组或字典中。如：

      who = 'wolf'

      what = 'ao!'

      print 'we are the',who,'who say',what,what,what,what

      >>>   we are the wolf who say ao! ao! ao! ao!

      print 'we are this %s who say %s' % (who,(what +' ')*4)

      >>>   we are the wolf who say ao! ao! ao! ao!

 也可以让for循环更像传统循环，如下：

      for eachNum in [0,1,2]:

           print eachNum,          # 0  1  2

range()内建函数可以生成计数列表。它接受一个数值范围，生成一个列表：

      for eachNum in range(3):

           print  eachNum,        # 0  1  2

也可以用for迭代一个字符串：  

     foo = 'abcd'

     for c in foo:

           print c,        # a  b  c  d

range()函数经常和len()函数一起用于字符串索引。         

           foo = 'abcd'

           for i in range(len(foo)):

                   print foo[i],'%d' % i,            # a(0)   b(1)    c(2)    d(3)

enumerate() 函数：索引与元素同时循环：        

 for i,ch in enmumerate(foo):

              print ch, '(%d)' % i,                  # a(0)   b(1)    c(2)    d(3)

 

列表解析----可以在一行中使用一个for循环将所有值放到一个列表当中：

      squared = [x**2 for x in range(4)]   #求x的平方
      print squared,         #0  1  4  9
      sqdEvens = [x**2 for x in range(8) if not x % 2]     #  求x平方中能够被2整除的
      print  sqdEens,       # 0  4  16  36 

文件和内建函数open()、 file()

    如何打开文件

    handle = open(file_name,access_mode = 'r')

    file_name 变量为文件的字符串名字，access_mode 打开模式，'r' 表示读取，'w'表示写入，'a'表示添加，'+'表示读写，'b'表示二进制访问。默认值为'r',如果open成功，返回一个对象句柄，后续的操作必须通过此文件句柄进行，如：readlines() 和 close()。

      filename = raw_input("输入文件名：")
      fobj = open(filename,'r')

      for eachLine in fobj:

            print eachLine,

      fobj.close()

错误和异常try-except语句：try之后为管理的代码，except之后的代码组为处理错误的代码

try:

     filename = raw_input('enter file name:')

     fobj = open(filename,'r')

     for eachLine in fobj:

          print eachLine,

     fobj.close()

except IOError,e:

     print 'file open error:',e

函数，python函数使用小括号（()）调用。在调用之前必须先定义，函数没有return语句则返回None对象。python 是通过引用调用的，意味着函数内对参数的改变会影响到原始对象。

定义函数：

      def function_name([arguments]):

            "optional documentation string"

            function_suite

简单例子：

      def addMe2Me(x):

           "apply + operation to argument"

           return (x+x)

函数调用：  addMe2Me(4.25)          #8.5

                addMe2Me('python')    #pythonpython

                addMe2Me([-1,'abc'])   #[-1,'abc',-1,'abc']

函数默认参数：    

 def foo(debug = True):

          'determine if in debug mode with default argument'

          if debug:

             print 'in debug mode'

 类：

 类的定义-----class关键字定义类，可以提供一个父类或者说基类，如果没有合适的基类，那就使用object作为基类。class行之后是可选的文档字符串、静态成员定义及方法定义。

      class ClassName(base_class[es]):

           "optionl documentation string"

           static_member_declarations

           methiod_declarations

class Fooclass(object):

    """my very first class:Fooclass"""

    version = 0.1    #类的静态变量，被以下4个方法共享——__init__()、showname()、showver()、addMe2Me()。

    def __init__(self,nm='John Doe'):     #名字开始和结束都有两个下划线的方法是特殊方法，__init__()方法在类实例被创建时自动执行，类似构造函数，执行初始化工作

        """constructor"""

        self.name = nm    #类实例的属性   self 是类实例的引用，如javascript中的this

        print 'Created a class instance for',nm

    def showname(self):

        """显示实例属性和类名"""

        print 'Your name is',self.name

        print 'My name is', self.__class__.__name__

    def showver(self):

         """显示类的静态属性"""

         print self.version          # 0.1

    def addMe2Me(self,x):

        """参数相加"""

        return x + x

创建类实例

foo1 = FooClass()    # 不需要用new来创建，和调用函数拥有一样的语法。

foo1.showver()

print foo1.addMe2Me(5)

self.__class__.__name__   表示实例化他的类的名字，self.__class__ 引用实际的类

python模块：包含可执行代码、函数和类、或者这些东西的组合。

导入模块:    import module_name

导入模块后可以通过句点来访问函数和变量：

import sys

sys.stdout.write('hello world!')

实用的函数

dir([obj])     #显示对象的属性，如果没有提供参数，则显示全局变量的名字

help([obj])   #显示对象的文档字符串帮助，没提供参数则会进入交互式帮助

int(obj)       #将一个对象转换为整型

len(obj)       #返回对象的长度

open(fn,mode)      #以mode方式打开一个文件名为fn的文件

range([start,]stop[,step])     #返回一个整数列表，起始值为start，结束值为stop-1，star默认值为0，step默认值为1

raw_input(str)       #等待用户输入一个字符串，可以提供一个可选的参数用作提示信息。

str(obj)                #将一个对象转换为字符串

type(obj)              #返回对象的类型（返回值本省是一type对象！）