basic knowledge note of core python programming

Python核心编程之基础知识笔记

列表和元组

       可以将列表和元组当成普通的数组,它能保存任意数量任意类型的Python对象,和数组一样,通过从0开始的数字索引访问元素,但是列表和元组可以存储不同类型的对象。

       列表和元组有几处重要的区别:

l  列表元素用中括号[ ]包裹,元素的个数及值可以改变;

l  元组元素用小括号( )包裹,不可以更改;

l  元组可以看成是只读的列表

错误和异常

       要给你的代码添加错误检测及异常处理,只要将它们封装在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

 

class FooClass(object):#

    ”’my very first class : FooClass”’

    version = 1.0

   

    def __init__(self,nm=’John Doe’):#

        ”’constructor”’

        self.name = nm

        print ‘created a class instance for’,nm

   

    def showname(self):#

        ”’display instance attribute and class name”’

        print ‘your name is’,self.name

        print ‘my name is’,self.__class__.__name__

       

    def showver(self):#

        ”’display class attribute”’

        print self.version

       

    def addMe2Me(self,x):#

        ”’apply + operation to argument”’

        return x + x

   

fool = FooClass()

 

fool.showname()

fool.showver()

print fool.addMe2Me(10.3)

 

fool1 = FooClass(‘leo’)

       在上面的这个类中,我们定义了一个静态变量version,它将被所有实例以及四个方法共享,其中__init__方法有个特殊的名字,所有名字开始以及结束都有两个下划线的方法都是特殊方法

       当一个类实例被创建时,__init__方法会自动执行,在类实例创建完毕后执行,类似构建函数,__init__可以被当成构建函数,不过不像其他语言中的构建函数,它并不创建实例仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象的必要的初始化工作

       类中的self是类实例自身的引用。

 

python:目录与文件操作

os.listdir(dirname):列出dirname下的目录和文件
os.getcwd()
:获得当前工作目录
os.curdir:
返回但前目录(‘.’)
os.chdir(dirname):#
改变工作目录到
dirname

os.path.isdir(name):#判断name是不是一个目录,name不是目录就返回false
os.path.isfile(name):#
判断name是不是一个文件,不存在name也返回
false
os.path.exists(name):#
判断是否存在文件或目录
name
os.path.getsize(name):#
获得文件大小,如果name是目录返回
0L
os.path.abspath(name):#
获得绝对路径

os.path.normpath(path):#
规范path字符串形式
os.path.split(name):#
分割文件名与目录(事实上,如果你完全使用目录,它也会将最后一个目录作为文件名而分离,同时它不会判断文件或目录是否存在)
os.path.splitext():#
分离文件名与扩展名
os.path.join(path,name):#
连接目录与文件名或目录
os.path.basename(path):#
返回文件名
os.path.dirname(path):#
返回文件路径

>>> import os
>>> os.getcwd()
‘C:\\Python25’

>>> os.chdir(r’C:\temp’)
>>> os.getcwd()
‘C:\\temp’

>>> os.listdir(‘.’)
[‘temp.txt’, ‘test.py’, ‘testdir’, ‘tt’]
>>> os.listdir(os.curdir)
[‘temp.txt’, ‘test.py’, ‘testdir’, ‘tt’]

>>> os.path.getsize(‘test.py’)
38L
>>> os.path.isdir(‘tt’)
True
>>> os.path.getsize(‘tt’)
0L

>>> os.path.abspath(‘tt’)
‘c:\\temp\\tt’
>>> os.path.abspath(‘test.py’)
‘c:\\temp\\test.py’
>>> os.path.abspath(‘.’)
‘c:\\temp’
>>>
>>> os.path.split(r’.\tt’)
(‘.’, ‘tt’)
>>> os.path.split(r’c:\temp\test.py’)
(‘c:\\temp’, ‘test.py’)
>>> os.path.split(r’c:\temp\test.dpy’)
(‘c:\\temp’, ‘test.dpy’


>>> os.path.splitext(r’c:\temp\test.py’)
(‘c:\\temp\\test’, ‘.py’)
>>> os.path.splitext(r’c:\temp\tst.py’)
(‘c:\\temp\\tst’, ‘.py’)
>>>
>>> os.path.basename(r’c:\temp\tst.py’)
‘tst.py’
>>> os.path.dirname(r’c:\temp\tst.py’)
‘c:\\temp’

打开文件和进行写操作

f=open(‘test.txt’,’w’)
f.write(‘hello’)
f.writelines([‘hi’,’haha’])#
多行输入
f.close()
#append data
f=open(‘test.txt’,’a’)
f.write(‘hello’)
f.writelines([‘hi’,’haha’])
f.close()
#
连续写入后会自动关闭
open(‘test.txt’,’a’).write(‘11111\r\n’)
#
result里的元素依次填到open函数里去
result={‘hello’,’u’}
exec open(‘test.txt’) in result
#
selected = []                  # temp list to hold matches
fp = open(‘test.txt’)
for line in fp.readlines():#    # Py2.2 -> “for line in fp:”
     selected.append(line)
del line                       # Cleanup transient variable
#
open(‘test.txt’).readlines()
file
python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,filefile的方法和属性。下面先来看如何创建一个file对象:

     * file(name[, mode[, buffering]])

file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。
mode
是打开的模式,可选的值为r w a U,分别代表读(默认) 添加支持各种换行符的模式。用wa模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清 空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如 unix中是一个\n,而在windows中是‘\r\n’,用U模式打开文件,就是支持所有的换行模式,也就说‘\r’ ‘\n’ ‘\r\n’都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用\n代替。在模式 字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。
buffering
如果为0表示不进行缓冲;如果为1表示进行行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。

file对象有自己的属性和方法。先来看看file的属性。

     * closed #标记文件是否已经关闭,由close()改写
     * encoding #
文件编码
     * mode #
打开模式
     * name #
文件名
     * newlines #
文件中用到的换行模式,是一个tuple
     * softspace #boolean
型,一般为0,据说用于
print

file的读写方法:

     * F.read([size]) #size为读取的长度,以byte为单位
     * F.readline([size])
       #
读一行,如果定义了size,有可能返回的只是一行的一部分
     * F.readlines([size])
       #
把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。
     * F.write(str)
       #
str写到文件中,write()并不会在str后加上一个换行符
     * F.writelines(seq)
       #
seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。

file的其他方法:

     * F.close() 
       #
关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
     * F.flush() 
       #
把缓冲区的内容写入硬盘

     * F.fileno()
       #
返回一个长整型的文件标签
     * F.isatty()
       #
文件是否是一个终端设备文件(unix系统中的)

     * F.tell() 
       #
返回文件操作标记的当前位置,以文件的开头为原点
     * F.next()
       #
返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
     * F.seek(offset[,whence])
       #
将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了, whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以aa+的模式打开,每次进 行写操作时,文件操作标记会自动返回到文件末尾。
     * F.truncate([size])
       #
把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0
把文件补到相应的大小,也可能是以一些随机的内容加上去

变量赋值

python 中的变量名有些类似于C++中的指针的概念.

python 中的赋值操作改变的并不是内存中变量的值, 而是变量名指向的变量.

>>> var = 3
>>> tmp = var
>>> var
3
>>> tmp
3
>>> id(var)
10417272
>>> id(tmp)
10417272
>>> id(3)
10417272

 

>>> var = 4
>>> id(var)
10417260
>>> id(4)
10417260
>>> id(tmp)
10417272

>>> tmp
3

>>> var
4
>>>

上边的例子指出, 当执行 “var = 3” , python会在内存中分配一块空间, “3”赋值给这块空间.

然后, 将变量名 “var” 关联到分配的内存.

当执行 “var = 4” , python 会再分配一块内存并存入“4”, 然后将变量名 “var” 关联到“4” 所在内存.

此时“3”所在的内存并没有变化.

 

对应的操作是:

>>> var = 3

分配内存编号10417272, 存入“3”

“var” 关联到 10417272

>>> var = 4

分配内存编号10417260, 存入“4”

“var” 关联到 10417260

>>> tmp
3

>>> id(tmp)
10417272

此时10417272中的内容没有破坏, 仍然是“3”, 并且“tmp”仍然指向10417272

 

事实上,当没有任何变量名指向一个内存中的变量市, python将释放该内存变量 

python之模块结构和布局

python编码的合理布局

1)起始行

2)模块文档

3)模块导入

4)变量定义

5)类定义

6)函数定义

7)主程序

 

#!/usr/bin/env python

 

”’ this is a test module”’

 

import sys

import os

 

debug = True

 

class FooClass(object):

    ”’Foo class”’

    pass

 

def test():

    ”’test function”’

    foo = FooClass()

   

    if debug:

        print ‘ran test()’

   

if __name__ == ‘__main__’:

    test()

clip_image001

 

python中的__name__在运行时检测该模块是被导入还是被直接执行。

如果模块是被导入,__name__的值为模块名字

如果模块是被直接执行,__name__的值为‘__main__’