Python学习笔记

1. 索引和分片

1.1 字符串、列表和元组

字符串、列表、元组都可以通过[]进行索引和分片，其中，第一个元素的索引为0。而且在索引和分片中可以使用负数，此时，-1表示最后一个元素，-2表示倒数第二个元素，一次类推。

需注意的是，list、tuple的分片操作的结果仍是list、tuple，即使结果中只有一个元素，而list、tuple的索引操作的结果为元素类型，如下：

      alist = [1, 2, 3, 4, 5]

      print alist[0], alist[0:1]

      atuple = (1, 2, 3, 4, 5)

      print atuple[0], atuple[0:1]

      运行结果为：

      1 [1]

1 (1,)

而对于字符串，因为其元素也为字符串类型（python中没有字符类型），所以索引和分片的结果的类型是一样的。如下：

1 1

1.2 字典

      字典不是通过位置进行索引的，而是通过“键”进行索引的，索引的结果为对应的值。如下：

      adic = {1:'beijing', 2:'shanghai', 3:'tianjin'}

for i in range(1,4):

          print adic[i]

      输出的结果为：

      beijing

shanghai

tianjin

注意：因为字典是无序的，所以字典不能通过位置进行索引，而且字典也没有分片操作。

2. .py文件中输出中文

      在python的命令行（python.exe）或者自带的shell中可以不加处理地输出中文。在.py文件中输出中文，须在文件的第一行加：#-*- coding:cp936 -*-，意思是文件代码使用cp936编码标准进行保存。

因为windows的命令行（cmd.exe）采用的是cp936编码标准，所以采用cp936标准可以在windows的命令行中直接输出中文。也可以采用其他的编码标准，比如文件的第一行可以为 #-*- coding:uft-8 -*-，此时，在windows命令行中正确地输出中文需进行其他处理，如下：

s = ‘汉字’

print s.decode(‘utf-8’).encode(‘cp936’)

3. 关于python的注释

      除用字符#添加注释外，还可以通过定义字符串的方式来添加注释（实际上是定义了没有名字的字符串），如下：

      for i in range(1, 5+1): # comment

           ‘comment-1’

           “comment-2”

           ‘’’comment-3’’’

           “””comment-4”””

           print i

      需要注意的是，第二种添加注释的方法实际上是定义了不被引用的字符串，所以可适用的情况有限。

4. 传递引用or传值

      Python中，传递整数类型时是传值，传递列表类型时是传递引用，如下：

      i1 = 123

i2 = i1

i2 = 100

print i1, i2

结果为 123 100

list1 = range(6)

print list1

list2 = list1

list2.reverse()

print list1, list2

      结果为：

      [0, 1, 2, 3, 4, 5]

[5, 4, 3, 2, 1, 0] [5, 4, 3, 2, 1, 0]

5. 类

5.1 对象的初始化相关

      类可以直接修改类中的属性，这将会影响该类的未赋值且未用__init__方法初始化的对象，而不会影响该类的已赋值的对象或者用__init__方法初始化的对象。如下：

      class Stu_t:

    name = 'null'

    id = 0

 

stu1 = Stu_t()

stu2 = Stu_t()

print stu1.name, stu2.name

 

# 类Stu_t修改属性name，将影响未赋值的对象stu1，stu2

Stu_t.name = 'empty'

print stu1.name, stu2.name

 

stu1.name = 'Alice'

 

print Stu_t.name, stu1.name, stu2.name

 

# 类Stu_t修改属性name，将影响未赋值的对象stu2 但不影响已赋值的对象stu1

Stu_t.name = 'null'

print Stu_t.name, stu1.name, stu2.name

 

以上程序的输出为：

null null

empty empty

empty Alice empty

null Alice null

示例二如下：

class Stu_t:

    name = 'null'

    id = 0

    def __init__(self, name, id):

        self.name = name;

        self.id = id

    def Print(self):

        print self.name, self.id

stu1 =  Stu_t('Alice', 11)

stu1.Print()

Stu_t.name = 'empty' #修改类的属性不会影响 stu1 的属性值

Stu_t.id = 100

stu1.Print()

程序输出为：

Alice 11

Alice 11

5.2 类的属性与方法

      在类的内部访问类中定义的属性和方法时，前面需要带self.前缀。需要注意，在类内部访问类中定义的方法时，不需要显式地传递self参数。如下：

class Stu_t:

    __name = ''

    __age = 0

    msg = ''

    def __init__(self, name, age, msg):

       self.__name = name

       self.__age = age

          self.msg = msg

    def __CheckAge(self):

       if self.__age > 30:

           return 1

       else:

           return 0

    def Print(self):

       if self.__CheckAge(): #调用类的其他方法时，不需显式地传递self参数

           print self.__name, '"over 30"', self.msg

       else:

           print self.__name, self.__age, self.msg

stu1 = Stu_t('Alice', 24, "Good student!")

stu2 = Stu_t('Bob', 35, "Good teacher!")

stu1.Print()

stu2.Print()

5.2 继承

派生类可以继承基类的共有属性和共有方法，但是不能继承基类的私有属性和私有方法。派生类访问基类的共有属性和共有方法的方式与访问自己的属性和方法的方式一致，即在基类的共有属性和共有方法前面需带.self前缀，而且，调用基类的共有方法时，无需显式传递self参数。

5.3 重定义基类的方法

      在类的继承中，派生类可以重定义基类的方法。在派生类中访问基类中被重定义的形式为：<基类名>.<方法名>(self, ....)，需要注意，此时需要显式传递self参数。如下：

class Stu_t:

    __name = 'null'

    __age = 0

    def __init__(self, name, age):

        self.__name = name

        self.__age = age

    def Print(self):

        print self.__name, self.__age,

 

class Master_t(Stu_t):

    __tutor = 'null'

    ''' 调用基类的__init__方法时，显式地传递self参数'''

    def __init__(self, name, age, tutor):

        self.__tutor = tutor

        Stu_t.__init__(self, name, age)

    ''' 调用基类的Print方法时，显式地传递self参数'''

    def Print(self):

        Stu_t.Print(self)

        print self.__tutor

       

aMaster = Master_t('Alice', 24, 'Bob')

aMaster.Print()

程序输出为：

      Alice 24 Bob

6. raise语句

      raise引发异常有三种形式：

           raise <异常名>

           raise <异常名>, <附加数据>

           raise <对象>

      <异常名>通常为字符串，如下：

try:

    assert 0, 'This is a test'

except AssertionError, inst:

    print inst

else:

    print 'No exception'

 

print '----------------------------'

try:

    raise 'MyExcep'

except 'MyExcep':

    print 'Catching "MyExcep"'

else:

    print 'Catching no exceptions'

 

try:

    raise 'MyExcep', 'This is user-defined exception'

except 'MyExcep', excepInfo:

    print 'Catching "MyExcep":', excepInfo

else:

    print 'Catching no exceptions'

      但是，抛出字符串类型的异常是不推荐的。

raise <对象> 中<对象>可以任何类的对象，不一定是异常类（Exception）的派生类，如下：

class MyExcep_t:

    def __init__(self, info):

        self.info = info

    def __str__(self):

        return self.info

    def Print(self):

        print "I am instance of class MyExcep_t"

 

try:

      ''' raise语句将构造MyExcep_t类型的对象, 'excep #1' 是构造函数的参数 '''

raise MyExcep_t, 'excep #1'，

''' inst 即raise抛出的对象 '''

except MyExcep_t, inst:

    print inst

    inst.Print()

else:

    print 'Catching no exception'

 

try:

      ''' 同样，也是构造MyExcep_t类型的对象，然后抛出 '''

raise MyExcep_t('excep #2')

''' inst 即raise抛出的对象 '''

except MyExcep_t, inst:

    print inst

    inst.Print()

else:

    print 'Catching no exception'

 

7. 线程

7.1 使用threading模块的Thread类创建线程

      使用threading模块的Thread类创建线程有两种方法，可以派生Thread类，或者通过Thread的构造函数直接创建特定的线程对象，如下：

# -*- coding: cp936 -*-

import time

from threading import Thread

''' 通过继承Thread定义自己的线程类 '''

class MyThread(Thread):

    def __init__(self, name):

        ''' 调用基类的构造函数 '''

        Thread.__init__(self)

        self.name = name

    ''' 重定义基类的run()方法，即线程函数 '''

    def run(self):

        for i in range(3):

            time.sleep(2)

            print self.getName()

           

t1 = MyThread('Thread#1')

t1.start() # 启动线程

 

''' 定义自己的线程函数 '''

def Run(*arg):

    print 'Run():', arg

''' 构造特定的线程对象 '''

t2 = Thread(target = Run, args = (1, 2, 3))

t2.run() # 启动线程