【汇总】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 = '[e-mail]',
            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])