【汇总】python基础

http://www.iteye.com/topic/1092772  Python基础实用技巧

http://pythonmap.iteye.com/category/247013  Python学习笔记-HeadFirstPython

 

http://www.oschina.net/p/pythonwin
http://www.oschina.net/p/idle
http://idle.thomaslauer.com/IdleDownload.html

 

 

http://greybeard.iteye.com/category/188408  python个人系统学习笔记

 

 

 

此笔记为原创，参考教材为中国电力出版社的《Head First Python》
全书用例为Python3.

一、Python安装(Head First Python采用Python3)：
    环境win7，Python版本3.2.3
    1、官网www.python.org下载Python3最新版本
    2、安装过程不表
    3、安装完成首在命令行中通过查看版本确定安装成功
        window:D:\python32\python -V　　linux:python3 -V

二、IDLE:
    1、IDLE是Python拿一送一的Python IDE(Python的集成开发环境)
    2、IDLE虽说简陋，可对于菜鸟级别的新手足够用了。自带shell，编辑器有代码提示(按下Tab)、代码着色。据说好些大牛平时也用。
    3、IDLE的shell中有代码回退（Alt-p)、代码前进(Alt-n)功能。

 

 

 

第一个习题：列表的数据处理

 cast = [ 'Cleese' ,  'Palin' ,  'Jones' ,  'Idle' ]  #创建列表并赋值给变量，变量无需声明（list-Python数据类型之一）
 print (cast)  #输出cast变量值（print()-Python BIF）
 print (len(cast))  #输出cast变量值长度（len()-Python BIF）
 print (cast[ 1 ])  #输出被赋值给cast变量的列表中的第2个元素
 cast.append('Gilliam' )  #向cast中追加一个元素(append方法是列表自带方法)
 cast.pop() #删除列表中最后一个元素，并return最后一个元素
 cast.extend(['Gilliam' ,  'Chapman' ])  #向列表末尾追加另一个列表，另一个列表中元素作为目标列表中新元素
 cast.remove('Chapman' )  #删除列表中指定元素
 cast.insert(0 ,  'Chapman' )  #向列表中指定位置（此处为第一个元素前）插入一个元素

 

 '' '''列表的迭代'''

 movies = ['movie1' ,  'movie2' ,  'movie3' ]  #创建列表并赋值给movies

 '' '''for循环是处理列表内个元素的最常用方法
 each_movie为目标标示符；movies为列表；print()代码块为列表元素处理代码'''
 for  each_movie  in  movies:
     print (each_movie）

 '' '''while循环是编写迭代代码的另一种备选方法
 count 为一个计数标示符，用来表示列表状态信息'''
 count = 0
 while  count < len(movies):
     print (movie[count])
     count += 1

 

 movie = [ 'The Holy Grail' ,  1975 ,  'director' ,  91 ,
 ['starring' ,
 ['actor1' ,  'actor2' ,  'actor3' ]]]  #列表内元素可以是各种数据类型，可嵌套

 '' '''使用if条件语句和for循环语句输出列表中嵌套的列表，本方法之判断嵌套的第一层列表'''
 for  each_item  in  movie:
     if  isinstance (each_item, list):  #isinstance()为判断条件，返回true or false；isinstance()为BIF，根据参数判断数据类型
         for  each_item_deep1  in  each_item:
             print (each_item_deep1)
     else :
         print (each_item)

 

 '' '''创建一个递归函数解决多层嵌套列表的输出
 pring_lol为函数名
 the_list为参数'''

 movie = ['The Holy Grail' ,  1975 ,  'director' ,  91 ,
 ['starring' ,
 ['actor1' ,  'actor2' ,  'actor3' ]]]

 def  print_lol(the_list):
     for  each_item  in  the_list:
         if  isinstance(each_item, list):
             print_lol(each_item)
         else :
             print (each_item)

 pirint_lol(movie) #函数调用

零碎：

    1、Python内置函数成为：BIF(built-in functions)，print()函数便是其中之一

 

 

 

 

============================== 2 模块和包

 

 

2.1 模块

mymodule.py

#!/usr/bin/python

def sayHi():
    print("hi")

version = "0.1"

 

 

t.py

#!/usr/bin/python


import nester.mymodule

mymodule.sayHi()
print(mymodule.version)

 

 

 

 

2.2 包

新建文件夹nester

 

vim nester.py
#!/usr/bin/python

def say_hi():
    print("hi")

 

新建'setup.py'，用于发布

vim setup.py

#!/usr/bin/python
from distutils.core import setup


setup(name = 'nester',
            version = '1.0.0',
            py_modules = ['nester'],
            author = 'pythonmap',
            author_email = '[email protected]',
            url = 'pythonmap.iteye.com',
            description = 'A simple printer of nested lists')

 

 

构建此distribution：
    终端中输入：python setup.py sdist
安装distribution：
    终端中输入：python setup.py install
查看发布后的nester文件夹结构变化
发布后即可在其他模块中导入使用

 

 

 

# python setup.py sdist
running sdist
running check
reading manifest file 'MANIFEST'
creating nester-1.0.0
making hard links in nester-1.0.0...
hard linking setup.py -> nester-1.0.0
Creating tar archive
removing 'nester-1.0.0' (and everything under it)
# python setup.py install
running install
running build
running build_py
copying nester.py -> build/lib
running install_lib
copying build/lib/nester.py -> /usr/local/python312/lib/python3.1/site-packages
byte-compiling /usr/local/python312/lib/python3.1/site-packages/nester.py to nester.pyc
running install_egg_info
Removing /usr/local/python312/lib/python3.1/site-packages/nester-1.0.0-py3.1.egg-info
Writing /usr/local/python312/lib/python3.1/site-packages/nester-1.0.0-py3.1.egg-info

 

 

在任意目录下

vim t.py

#!/usr/bin/python


import nester

nester.say_hi()

 

 

 

 

======================3.Python第三课-初探文件与异常

从文件读取数据：

常用方式：使用open() BIF和for循环读取基于行的文件内容。

open()使用的基本流程：

 data = open(filename):  #打开
 print (data.read())  #处理
 data.close() #关闭

 

 

 

#!/usr/bin/python
import os
if os.path.exists('t.txt'):
    data = open('t.txt')
    print(data.read())
    data.close()
else:
    print('The file is missing')

 

 

 

#!/usr/bin/python

'' '''打开一个名为't.txt'的文件.

把读取到得每行数据利用':'分割处理为讲话者和讲话内容后输出 '''

 

t.txt

1:11
2
3:33

 

import os
if os.path.exists('t.txt'):
    data = open('t.txt')

    for each_line in data:             
        if each_line.find(':') != -1:
            (role, line_spoken) = each_line.split(':', 1)        
            print(role + ' said: ' + line_spoken)            

    data.close()         
else:
    print('The file is missing')

 

 

输出：

1 said: 11

3 said: 33

 

碎碎念：
1、字符串的find ()内置方法，用来检索参数位置，返回指针值，如果未检索到返回-1.
2、字符串的split ()内置方法，用来以sep参数为基准分割字符串，返回分割后的列表。
3、获取方法、函数的使用帮助信息，可以先导入该方法所在模块，然后help之。内置函数直接help之。

Python代码  

 s =  '2.33'
 help(s.split)

 import  os
 help(os.path.exists)

 help(open)

 

处理异常：

异常处理：为使代码逻辑更加清晰，先尝试运行代码，然后处理可能会发生的错误。

基本的异常处理：

 try :
     #尝试执行的代码
 except :
     #用于恢复错误的代码

改进Demo:

 try :
     data = open('sketch.txt' )

     for  each_line  in  data:
         try :
             (role, line_spoken) = each_line.split(':' ,  1 )
             print (role +  ' said: '  + line_spoken)
         except  ValueError:  #处理try代码块内特定错误类型的异常
             pass

     data.close() #关闭文件
 except :  #处理try代码块内所有错误类型的异常
     print ( 'The file is missing' )

碎碎念：
看了看下一章，貌似有些对文件和异常处理的补充内容。这节课还是初窥。

 

 

=================4.Python第四课-深入文件与异常（数据持久化）

 

 

 

 

1、创建文件，并将需要持久化得数据写入文件中。

 '' '''将上课demo中的谈话内容（conversations）按角色（role）的不同，分别存入两个文本文件中'''

 man = [] #分别定义两个list 用来存储两个role的conversations
 other = []

 try :
     data = open('sketch.txt' )
     try :
         for  each_line  in  data:
             (role, line_spoken) = each_line.split(':' ,  1 )
             line_spoken = line_spoken.strip()
             if  role ==  'man' :  #通过判断role来确定要存入的list
                 man.append(line_spoken)
             else :
                 other.append(line_spoken)
     except  ValueError:
         pass
     data.close() #别忘了完成文件操作关闭数据文件对象
 except  IOError:
     print ( 'The file is missing!' )

 try :
     man_file = open('man_data.txt' ,  'w' )  #数据文件对象中的文件参数如果不存在，并且相应目录有相应权限，open()会自动创建文件
     other_file = open('other_data.txt' ,  'w' )  # 'w'为文件数据对象的'写'模式

     print (man, file = man_file)  #print()函数中的file参数为写入的文件名
     print (other, file = other_file)

     man_file.close() #别忘了完成文件操作关闭数据文件对象
     other_file.close()
 except  IOError:
     print ( 'File Error!' )

2、改进上面代码中的异常处理逻辑和代码：

上面代码中的异常处理方式依旧是不完善的，想想看，如果在man_file.close()语句之前，代码发生了错误，那么数据文件对象是不会被关闭掉的。

改进代码：

 man = []
 other = []

 try :
     data = open('sketch.txt' )
     try :
         for  each_line  in  data:
             (role, line_spoken) = each_line.split(':' ,  1 )
             line_spoken = line_spoken.strip()
             if  role ==  'man' :
                 man.append(line_spoken)
             else :
                 other.append(line_spoken)
     except  ValueError:
         pass
     data.close()
 except  IOError as ioerr:  #将IOError异常对象赋予ioerr变量
     print ( 'File Error :'  + str(ioerr))  #将ioerr转换为字符串类型

 try :
     man_file = open('man_data.txt' ,  'w' )
     other_file = open('other_data.txt' ,  'w' )

     print (man, file = man_file)
     print (other, file = other_file)
 except  IOError as ioerr:
     print ( 'File Error: '  + str(ioerr))
 finally :  #无论try代码块或者except代码块中的语句是否被执行，finally代码块中的语句
     if   'man_file'   in  locals():  #判断数据文件对象是否存在，loclas() BIF返回作用域中所有变量的字典
         man_file.close()
     if   'man_file'   in  locals():
         man_file.close()

3、Python中 文件处理的语法糖：

利用with语句，可以将文件处理的代码简化，无需考虑关闭文件，裁剪掉文件异常处理语句中的finally语句。
作用一：简化语法，减少工作量。
作用二：通过逻辑抽象，减少码农脑细胞死亡速度和出错概率。

对以上代码第二段之改进：

 try :
     with open('man_data.txt' ,  'w' ) as man_file:
         print (man, file = man_file)
     with open('other_data.txt' ,  'w' ) as other_file:
         print (other, file = other_file)
 except  IOError as ioerr:
     print ( 'File Error: '  + str(ioerr))

OR

 try :
     with open('man_data.txt' ,  'w' ) as man_file, open( 'other_data.txt' ,  'w' ) as other_file:
         print (man, file = man_file)
         print (other, file = other_file)
 except  IOError as ioerr:
     print ( 'File Error: '  + str(ioerr))

 

 

 

 

 

=====================5.将写入文件的列表格式化

 

可当我们试着把保存数据的文件读取出来会怎样呢？

    try: 
        with open('man.txt', 'r') as fman: 
            print(fman.readline()) 
    except IOError as err: 
        print(str(err)) 


执行时，返回一大...串儿字符串。里边包含了man.txt文件中的所有数据。
这种未被格式化的存储方式基本上是没什么用的！除非你把整个文件当一个字符串读出来，然后再去想各种办法解析...


2、把即将写入文本文件的数据格式化：

# vim /tmp/sketch.txt

man:man1
other:other2
man:man2
other:other2
other:other3

 

当然我们可以写出新的代码来实现数据格式化。
可第二课中我们曾经创建过一个nester模块，里边的print_lol函数就是用来格式化列表的。为什么不把它改造一个直接拿来使用呢？不要重复造轮子嘛...OOP吧！

改造print_lol函数

在nester目录中
vim /tmp/nester/nester.py

#!/usr/bin/python

import sys

def print_lol(the_list, level=0, d='\t', indent=False, file_name =sys.stdout):

    for each_item in the_list:
        if isinstance(each_item, list):
            print_lol(each_item, level+1, file_name)
        else:
            if indent:
                for tab_stop in range(level):
                    print(d, end = '', file = file_name)
        print(each_item, file = file_name)

 

 

#cd /tmp/nester

#python setup.py sdist

#python setup.py instal l

改造写入文件的代码块：
# vim /tmp/t.py

#!/usr/bin/python


import nester

man = []
other = []

try:
    data = open('sketch.txt')
    try:
        for each_line in data:
            (role, line_spoken) = each_line.split(':', 1)
            line_spoken = line_spoken.strip()
            if role == 'man':
                man.append(line_spoken)
            else:
                other.append(line_spoken)
    except ValueError:
        pass
    data.close()
except IOError as ioerr:
    print('File Error :' + str(ioerr))

try:
    with open('man_data.txt', 'w') as man_file, open('other_data.txt', 'w') as other_file:
        nester.print_lol(man, file_name = man_file)
        nester.print_lol(other, file_name = other_file)
except IOError as ioerr:
    print('File Error: ' + str(ioerr))


如此便可以利用现有的print_lol函数，实现把格式化后的列表写入文本文件。

 

 

 

 

#cat man_data.txt

man1
man2

#cat other_data.txt
other2
other2
other3

 

 

 

==========================6.持久化相关的另一个模块pickle

 

 

第五课中我们利用nester模块中的print_lol函数对写入文本文件的列表进行了格式化，确保数据的可用性。
可如果我们需要写入其他的数据格式呢？难道要对每一种数据格式都创建一个格式化方法？
要累死程序猿吗？码农也是人啊！

Gudio还有有人情味儿的，python的标准库中有一个pickle模块可以解决这个问题！


使用pickle模块持久化数据

pickle模块可以保存各种数据类型的原始状态，我们不必再为数据写入文件前的格式化而担心了！

 

# vim /tmp/sketch.txt

man:man1
other:other2
man:man2
other:other2
other:other3

将第四课中的代码做如下修改： t.py

 '' '''使用pickle模块持久化各种数据类型的数据'''

 import  pickle

 man = []
 other = []

 try :
     data = open('sketch.txt' )
     try :
         for  each_line  in  data:
             (role, line_spoken) = each_line.split(':' ,  1 )
             line_spoken = line_spoken.strip()
             if  role ==  'man' :
                 man.append(line_spoken)
             else :
                 other.append(line_spoken)
     except  ValueError:
         pass
     data.close()
 except  IOError as ioerr:
     print ( 'File Error :'  + str(ioerr))

 try :
     with open('man_data.txt' ,  'wb' ) as man_file, open( 'other_data.txt' ,  'wb' ) as other_file:  #由于pickle以二进制模式存储数据，所以我们需要'wb'参数来以二进制方式操作文件
         pickle.dump(man, file = man_file) #dump是pickle中的一个方法，用来写入数据
         pickle.dump(other, file = other_file)
 except  IOError as ioerr:
     print ( 'File Error: '  + str(ioerr))
 except  pickle.PickleError as perr:
     print ( 'Pickling Error: '  + str(perr))  #pickle的异常

这样，我们使用pickle对处理完毕。接下来取出数据看看，是否如我们所愿。 tt.py

 import  pickle

 man_data = []

 try :
     with open('man_file.txt' ,  'rb' ) as fman:  #用二进制方式打开文件
         man_data = pickle.load(fman) #pickle中的load方法用于从文件对象中取出数据
 except  IOError as ioerr:
     print ( 'File Error: '  + str(ioerr))
 except  pickle.PickleError as perr:
     print ( 'Pickling Error: '  + str(perr))

 print (man_data)

接下来我们可以看到输出到控制台的列表了！

 

 

 

# python t.py
# python tt.py
['man1', 'man2']

 

 

=======================7.提取书中所提供的文本文件中的时间，并且把其中前三个最短时间输出出来。

 

http://pythonmap.iteye.com/blog/1679400

 

 

python中还有一个数据类型——集合。集合跟列表不同点在于集合是无需的，集合内的元素是不能重复的，如果重复，将自动忽略。
所以利用集合的“元素不可重复”的特性来改进一下上边的代码：

 

 

# vim sketch.txt

2-34,3:21,2.34,2.45,3.01,2:01,2:01,3:10,2-22

 

times中有重复的记录，需要在get_top3中把重复的值处理掉

调用sanitize函数以格式化每个time值

 

 

# vim t.py

#!/usr/bin/python

#格式化a.b
def sanitize(time):
    if ':' in time:
        splitter = ':'
        (mins, secs) = time.split(splitter)
    elif '-' in time:
        splitter = '-'
        (mins, secs) = time.split(splitter)
    else:
        return(time)
    return(mins + '.' + secs)

 

#读取内容
def get_times(file_name):
    times = []
    try:
        with open(file_name) as fdata:
            data = fdata.readline()
            data_list = data.strip().split(',')
            for each_time in data_list:
                clean_time = sanitize (each_time)
                times.append(clean_time)
        return(times)
    except IOError as ioerr:
        print('IO Error: ' + str(ioerr))


#排序从小到大
def get_top3(times_list):
    stimes = set (times_list)
    sorted_times = sorted (stimes)
    return(sorted_times[0:3])


times = get_times('sketch.txt')
print(get_top3(times))

 

输出

['2.01', '2.22', '2.34']

 

 

 

或者

def get_times(file_name): 
    try: 
        with open(file_name) as fdata: 
            data = fdata.readline() 
            data_list = data.strip().split(',') 
            times = [sanitize(each_time) for each_time in data_list] #使用列表推导来取代for迭代中列表的append方法 
        return(times) 
    except IOError as ioerr: 
        print('IO Error: ' + str(ioerr))

 

或者

def get_top3(times_list): 
    sorted_times = sorted(times_list) 
    clean_stimes =[] 
    for each_time in sorted_times: #迭代排序后的每一个列表值 
        if not each_time in clean_stimes: #判断此值是否已存在于clean_stimes列表中 
            clean_stimes.append(each_time) 
    return(clean_stimes[0:3])