精华内容
下载资源
问答
  • HeadFirstPython

    2018-01-04 16:34:33
    head first python head first python head first python
  • headfirstpython

    2017-12-30 09:51:00
    pdf版《A Byte of Python》是一本由 Swaroop C H 编写,旨在于介绍如何使用 Python 语言进行编程的自由图书。它以教材与指南的形式为入门者介绍 Python 语言。如果你对电脑知识的了解仅限于如何保存文本文件的话,那...
  • headfirst_python高清版,在完晚上找了好多版本 这个最高清最新分享给大家
  • HeadFirstPython-源码

    2021-03-09 16:25:10
    HeadFirstPython
  • HeadFirstPython第二版

    2019-07-22 16:17:56
    资源名称:Head First Python 第二版资源截图: 资源太大,传百度网盘了,链接在附件中,有需要的同学自取。
  • headfirstpython_code.rar

    2021-11-16 15:05:45
    配套Head First Python(第2版) 使用,省去敲代码的时间,可以直接进行拷贝、练习,加快学习速度。
  • HeadFirstPython >> Open the ipynb files # :-) 这是我从python编程中学到的有趣的东西。 希望对您有帮助。
  • headfirstpython书里的代码,和django by example书里的代码。
  • Head First Python第二版 英文版 很好的python入门教程
  • 深入浅出python-中文版,想要清晰版本的下载这个资源, 这个资源很清晰
  • 1、str.strip(),是返回为字符串。 str.split(),返回的是列表list readline()返回的是字符串。 readlines()返回的是字符串列表...os.chdir('D:/pythontest/HeadFirstPython/chapter5/'); james=[]; julie=[]; mikey=

    1、str.strip(),是返回为字符串。

    str.split(),返回的是列表list

    readline()返回的是字符串。

    readlines()返回的是字符串列表list。



    任务:生成每个选手的3次最快时间。并且,当然你的输出中不该有任何重复的时间。



    自己写的代码如下:

    import os
    os.chdir('D:/pythontest/HeadFirstPython/chapter5/');
    james=[];
    julie=[];
    mikey=[];
    sarah=[];
    try:
        with open("james.txt") as james_data,open("julie.txt") as julie_data,open("mikey.txt") as mikey_data,open("sarah.txt") as sarah_data:
            
            for each_line in james_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        time_=each_line.split(",");
                        
                        james.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in julie_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        time_=each_line.split(",");
                        
                        julie.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in mikey_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        time_=each_line.split(",");
                       
                        mikey.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in sarah_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        time_=each_line.split(",");
                        
                        sarah.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
    except IOError as err:
        print("File error"+str(err));
    print(james);
    print(julie);
    print(mikey);
    print(sarah);

    实验结果为:


    修改后:for each_line in james_data:#each_line为2-34,3:21,2.34,2.45,3.01,2:01,2:01,3:10,2-22
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        james=each_line.split(",");#split()返回的就是列表。
                        
                        #james.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;

    import os
    os.chdir('D:/pythontest/HeadFirstPython/chapter5/');
    james=[];
    julie=[];
    mikey=[];
    sarah=[];
    try:
        with open("james.txt") as james_data,open("julie.txt") as julie_data,open("mikey.txt") as mikey_data,open("sarah.txt") as sarah_data:
            
            for each_line in james_data:#each_line为2-34,3:21,2.34,2.45,3.01,2:01,2:01,3:10,2-22
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        james=each_line.split(",");#split()返回的就是列表。
                        
                        #james.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in julie_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        julie=each_line.split(",");
                        
                        #julie.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in mikey_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        mikey=each_line.split(",");
                       
                        #mikey.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
            for each_line in sarah_data:
                if not each_line.find(",")==-1:
                    try:
                        each_line=each_line.strip();
                        sarah=each_line.split(",");
                        
                        #sarah.append(time_);
                    except ValueError as err:
                        print("Context of file is:"+str(err));
                else:
                    continue;
    except IOError as err:
        print("File error"+str(err));
    print(james);
    print(julie);
    print(mikey);
    print(sarah);

    实验结果为:


    书给的代码:

    依次打开各个数据文件,从文件读取数据行,由数据行创建一个列表。

    import os
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    james=[];#下面4个列表的声明,可以不预先定义,并设为空列表。
    julie=[];
    mikey=[];
    sarah=[];
    try:
        with open("james.txt") as jaf,open ("julie.txt") as juf,open("mikey.txt")as mif,open("sarah.txt") as saf:
            data=jaf.readline();#读取数据行
            james=data.strip().split(',');#将数据转换为一个列表。
            data=juf.readline();
            julie=data.strip().split(',');
            data=mif.readline();
            mikey=data.strip().split(',');
            data=saf.readline();
            sarah=data.strip().split(',');
    except IOError as err:
        print("File error"+str(err));
    print(james);
    print(julie);
    print(mikey);
    print(sarah);
    

    实验结果为:


    2、排序有两种方式:

    原地排序:按你指定的顺序排列数据,然后用排序后的数据替换原来的数据。原来的顺序会丢失。对于列表,sort()方法会提供原地排序。

    复制排序:指按你指定的顺序排列数据,然后返回原数据的一个有序副本。原数据的顺序依然保留,只是对一个副本排序。在Python中,sorted()支持复制排序。


    知识:函数串链是从右往左读;方法串链是从左往右读。

    函数串链:允许对数据应用一系列函数,每个函数会取得数据,对他完成某个操作,然后把转换后的数据继续向下传递到下一个函数。

    从文件读入的数据会作为文本传入程序。

    使用“in”操作符检查字符串是否包含一个短横线或冒号。

    3、对时间数据进行的处理

    sanitize1.py代码如下:

    import os
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    def sanitize(time_string):
            if '-' in time_string:
                splitter='-';
                
            elif ':' in time_string:
                splitter=':';
            else:
                return(time_string);
            (mins,secs)=time_string.split(splitter);
            
            return (mins+'.'+secs);

    等同于:

    import os
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    def sanitize(time_string):#time_string是列表中的元素
            if time_string.find('-')!=-1:
                (mins,secs)=time_string.split('-',1);
                
            elif time_string.find(':')!=-1:
                (mins,secs)=time_string.split(':',1);
            else:
                return(time_string);
            
            return (mins+'.'+secs);


    read.py代码如下:(对数据处理,并且输出排序后的列表):

    import os
    import sanitize1
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    james1=[];
    julie1=[];
    mikey1=[];
    sarah1=[];
    try:
        with open("james.txt") as jaf,open ("julie.txt") as juf,open("mikey.txt")as mif,open("sarah.txt") as saf:
            data=jaf.readline();#读取数据行
            james=data.strip().split(',');#将数据转换为一个列表。
            data=juf.readline();
            julie=data.strip().split(',');
            data=mif.readline();
            mikey=data.strip().split(',');
            data=saf.readline();
            sarah=data.strip().split(',');
    except IOError as err:
        print("File error"+str(err));
    for time_string in james:
        time_string=sanitize1.sanitize(time_string);
        james1.append(time_string);
    for time_string in julie:
        time_string=sanitize1.sanitize(time_string);
        julie1.append(time_string);
    for time_string in mikey:
        time_string=sanitize1.sanitize(time_string);
        mikey1.append(time_string);
    for time_string in sarah:
        time_string=sanitize1.sanitize(time_string);
        sarah1.append(time_string);
    print(sorted(james1));
    print(sorted(julie1));
    print(sorted(mikey1));
    print(sorted(sarah1));
    运行结果为:

    到此为止:以上代码的缺点就是,重复的代码太多。改善可以用列表推导(设计列表推导是为了减少将一个列表转为另一个列表时所需编写的代码量)。
    4、


    等价于下面的列表推导:




    利用列表推导:代码如下:

    import os
    import sanitize
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    
    try:
        with open("james.txt") as jaf,open ("julie.txt") as juf,open("mikey.txt")as mif,open("sarah.txt") as saf:
            data=jaf.readline();#读取数据行
            james=data.strip().split(',');#将数据转换为一个列表。
            data=juf.readline();
            julie=data.strip().split(',');
            data=mif.readline();
            mikey=data.strip().split(',');
            data=saf.readline();
            sarah=data.strip().split(',');
    except IOError as err:
        print("File error"+str(err));
    
    james1=[sanitize.sanitize(time_string) for time_string in james];
    
    julie1=[sanitize.sanitize(time_string) for time_string in julie];
    
    mikey1=[sanitize.sanitize(time_string) for time_string in mikey];
    
    sarah1=[sanitize.sanitize(time_string) for time_string in sarah];
    
    print(sorted(james1));
    print(sorted(julie1));
    print(sorted(mikey1));
    print(sorted(sarah1));

    运行结果为:


    5、迭代删除重复项


    任务:生成每个选手的3次最快时间。并且,当然你的输出中不该有任何重复的时间。

    代码如下:

    import os
    import sanitize
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    
    try:
        with open("james.txt") as jaf,open ("julie.txt") as juf,open("mikey.txt")as mif,open("sarah.txt") as saf:
            data=jaf.readline();#读取数据行
            james=data.strip().split(',');#将数据转换为一个列表。
            data=juf.readline();
            julie=data.strip().split(',');
            data=mif.readline();
            mikey=data.strip().split(',');
            data=saf.readline();
            sarah=data.strip().split(',');
    except IOError as err:
        print("File error"+str(err));
    james=sorted([sanitize.sanitize(time_string) for time_string in james]);
    julie=sorted([sanitize.sanitize(time_string) for time_string in julie]);
    mikey=sorted([sanitize.sanitize(time_string) for time_string in mikey]);
    sarah=sorted([sanitize.sanitize(time_string) for time_string in sarah]);
    unique_james=[];
    unique_julie=[];
    unique_mikey=[];
    unique_sarah=[];
    for each_item in james:
        if each_item not in unique_james:
            unique_james.append(each_item);
            #unique_james.sort(reverse=True);
    for each_item in julie:
        if each_item not in unique_julie:
            unique_julie.append(each_item);
            #unique_julie.sort(reverse=True);
    for each_item in mikey:
        if each_item not in unique_mikey:
            unique_mikey.append(each_item);
            #unique_mikey.sort(reverse=True);
    for each_item in sarah:
        if each_item not in unique_sarah:
            unique_sarah.append(each_item);
            #unique_sarah.sort(reverse=True);
    print(unique_james[0:3]);
    print(unique_julie[0:3]);
    print(unique_mikey[0:3]);
    print(unique_sarah[0:3]);
    实验结果为:

    6、用集合删除重复项;

    Python中集合最突出的特性是集合中的数据项是无序的,而且不允许重复。如果试图向一个集合增加一个数据项,而该集合中已经包含有这个数据项,Python就会将其忽略。

    工厂函数:工厂函数用于创建某种类型 的新的数据项。在真实世界中,工厂会生产产品,这个概念因此而得名。

    set()是工厂函数的一个例子;set()BIF创建一个空集合,可以一步完成集合的创建和填充,可在大括号之间提供一个数据列表,或者指定一个现有列表作为set()BIF的参数。
    改善5、中的代码如下:

    print(sorted(set(james))[0:3]);
    print(sorted(set(julie))[0:3]);
    print(sorted(set(mikey))[0:3]);
    print(sorted(set(sarah))[0:3]);
    或者用列表推导:

    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in james])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in julie])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in mikey])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in sarah])))[0:3]);

    等价于:

    unique_james=[];
    unique_julie=[];
    unique_mikey=[];
    unique_sarah=[];
    for each_item in james:
        if each_item not in unique_james:
            unique_james.append(each_item);
            #unique_james.sort(reverse=True);
    for each_item in julie:
        if each_item not in unique_julie:
            unique_julie.append(each_item);
            #unique_julie.sort(reverse=True);
    for each_item in mikey:
        if each_item not in unique_mikey:
            unique_mikey.append(each_item);
            #unique_mikey.sort(reverse=True);
    for each_item in sarah:
        if each_item not in unique_sarah:
            unique_sarah.append(each_item);
            #unique_sarah.sort(reverse=True);
    print(unique_james[0:3]);
    print(unique_julie[0:3]);
    print(unique_mikey[0:3]);
    print(unique_sarah[0:3]);

    7、总结:

    最佳代码:(结合集合、sorted()、列表推导)

    read.py中的代码如下:

    import os
    import sanitize
    import get_coach_data1
    os.chdir("D:/pythontest/HeadFirstPython/chapter5");
    
    try:
        james=get_coach_data1.get_coach_data('james.txt');
        julie=get_coach_data1.get_coach_data('julie.txt');
        mikey=get_coach_data1.get_coach_data('mikey.txt');
        sarah=get_coach_data1.get_coach_data('sarah.txt');  
        
    except IOError as err:
        print("File error"+str(err));
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in james])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in julie])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in mikey])))[0:3]);
    print(sorted(set(sorted([sanitize.sanitize(time_string) for time_string in sarah])))[0:3]);

    get_coach_data1.py中的代码为:

    def get_coach_data(filename):
        try:
            with open(filename) as f:
                data=f.readline();
            return(data.strip().split(','));
        except IOError as ioerr:
                   print('File error:'+str(ioerr));
                   return(None);


    展开全文
  • Python资料打包,内含: 1. Python核心编程第2版中英文版,课后习题答案,以及书中源码 2. Head First Python中文版
  • 你想过可以通过一本书就学会Python吗?《Head First Python(中文版)》超越枯燥的语法和甩法手册,通过一种独特的方法教你学习这种语言。你会迅速掌握Python的基础知识,然后转向持久存储、异常处理、Web开发、SQLite...
  • 这里要吐槽一下HeadFirstPython,这书可以让初学者容易看进去,但是实在太表面,学过编程的人看,会觉得太浅。 另外,因为这本书用的是Python3版本,所以网上查资料的时候应该查python3,如果只查python可能会查...

    目标:学习读取文本文件,学习Python中的异常机制,使程序更健壮,容错性更好。

    一、打开并读取文本文件

    使用Python的open() BIF来打开文件,Python在使用完文件后要关闭文件。

    the_file = open('sketch.txt')
    #文件读取代码
    the_file.close() #关闭文件

    本章会用到一个文本文件做实例,这个文件可以在这里下载到。

    通过os模块中的,os.getcwd()获取当前工作目录,通过os.chdir('目录')改变当前工作目录。

    可使用文件对象的readline()函数读取文本文件的一行,这里注意读取时会将换行符也一起读取,所以在使用print输出时要使用end=""参数,否则会多输出一行。也可以使用for...in循环来读取文本文件的每一行。使用文件对象的方法seek(0)来讲读写文件指针移动到文件起始位置。使用tell()方法可获得读写指针当前位置。

    #读取文件实例
    >>> data=open('D:\PythonProject\FirstHeadPython\chapter3\sketch.txt') 
    #如果不使用绝对路径,可以用os.chdir(目录)改变当前工作目录到sketch.txt文件所在目录后在打开文件。
    >>> data.readline()
    "Man: Is this the right room for an argument?\n"  #readline()获得的字符串末尾有\n
    >>> print(data.readline(),end='')
    Other Man: I've told you once.  #如果上面的print语句没有使用end=''参数的话,下面会多出一个空行。
    >>> data.seek(0)  #返回文件起始位置
    0
    >>> for each_line in data:  #循环获取文件所有行
            print(each_line,end="")
    
    Man: Is this the right room for an argument?
    Other Man: I've told you once.
    
    ..........中间太长省略..................
    
    (pause)
    Other Man: No it isn't!
    Man: Yes it is!
    >>> data.close()  #关闭文件。

    二、字符串处理函数

    当需要查看一个方法的使用帮助时,可以在python shell中使用内置函数help(对象.方法)来找到帮助。

      1、字符串的split()方法分隔字符串,可以多重复值。

    oneline="Man: Is this the right room :for an argument?\n"
    (role,line_spoken)=oneline.split(":",1) 
    #将oneline根据符号:进行分割,然后分别赋值给role和line_spoken,而且只分割一次,第二个“:”号会被忽略。

     当进行多重赋值时,变量列表的数量要确保和返回结果数量一致,无论多或者少都会出错。

     2、字符串对象的去除两边空字符的方法,lstrip()去除左边空字符,rstrip()去除右边空空字符,strip()去除两边空字符。注意:这里空字符包括了空格、制表符、回车、换行等。如果需要定制去除哪些字符,可以使用参数,例如:strip(" \n"),这里\符号前面有个空格,表示去除字符串两边的空格和换行字符。这时候如果字符串开头或末尾有制表符\t,就会当做正常字符处理。

    3、在字符串中查找子串位置方法find(子串),返回-1表示没有包含子串,如果找到子串就返回子串第一个字符在字符串中的位置(从0开始)。

    三、Python中的布尔表达式符号

    == 等于、!=不等于、>大于、<小于、<=小于等于、>=大于等于

    四、异常处理机制

    try:
        #可能会有运行时错误的代码
    except[ 错误类型1]:
        #错误处理代码
    [except[ 错误类型2]:
        #错误2处理代码    ]
    else:
        #如果没有捕获错误时代码

    如果错误处理可以忽略,那么错误处理代码可以用pass语句。个人认为pass语句能不用就不用,在实际工作中,如果某处可能有异常发生异常,那么你至少在错误处理代码部分做个日志记录。除非你知道某个语句一定会有异常,但是这个异常不需要处理,也没有记录的意义,那么这时候才用pass

    一个实例,是参考了其他资料的,HeadFirstPython里的例子实在是太简单,要到后面章节才会进一步展开,感觉太散先提前放过来。

    try:  
        x = int(input('input x:'))  
        y = int(input('input y:'))  
        print('x/y = ',x/y)  
    except ZeroDivisionError: #捕捉除0异常  
        print("ZeroDivision")  
    except (TypeError,ValueError) as e: #捕捉多个异常  
        print(e)  
    except: #捕捉其余类型异常  
        print("it's still wrong")  
    else:  #没有异常时执行  
        print('it work well')  
    finally: #不管是否有异常都会执行  
        print("Cleaning up")

    这里要吐槽一下HeadFirstPython,这书可以让初学者容易看进去,但是实在太表面,学过编程的人看,会觉得太浅。

    另外,因为这本书用的是Python3版本,所以网上查资料的时候应该查python3,如果只查python可能会查到python2的内容,python2和python3有些地方是不同的。

    转载于:https://my.oschina.net/u/2357619/blog/644163

    展开全文
  • os.chdir("D:/pythontest/HeadFirstPython/chapter7/chapter7/yatestuff/"); from string import Template '''从标准库的"string"模块导入"Template"类,他支持简单的字符串替换模板。''' def start_response...

    1、







    1、建立模型:


    代码如下:

    import pickle
    import os
    from chapter6 import  Athlete
    from chapter6 import get_coach_data#from 模块 import 类/方法
    
    
    def put_to_store(file_list):
        all_athletes={};
        for each_file in file_list:
            ath=get_coach_data(each_file);
            all_athletes[ath.name]=ath;
        try:
            with open('athlete.pickle','wb') as athf:
                pickle.dump(all_athletes,athf);#将对象obj保存到文件file中去
        except IOError as ioerr:
            print('File error(put_and_store):'+str(ioerr))
        return (all_athletes);
    
    
    
    def get_from_store():
        all_athletes={};
        try:
            with open('athlete.pickle','rb') as athf:
                all_athletes=pickle.load(athf);
        except IOError as ioerr:
            print('File error (get_from_store):'+str(ioerr));
        return (all_athletes);
    
    
    os.chdir("D:/pythontest/HeadFirstPython/chapter6/");    
    the_files=['sarah2.txt','james2.txt','mikey2.txt','julie2.txt'];
    data=put_to_store(the_files);
    print(data);
    for each_athlete in data:
        print(data[each_athlete].name+' '+data[each_athlete].dob);
    
        
    print("\n可以对比一下,put_to_store()和get_from_store()方法"   );
    data_copy=get_from_store();
    for each_athlete in data_copy:
        #注意,字符串必须跟字符串连接,不能是字符串+链表,必须将链表转换成字符串才可以
        print(data_copy[each_athlete].name+' '+data_copy[each_athlete].dob+' '+str(data_copy[each_athlete].times));
    
    
    


    其中chapter6.py代码为:

    import os
    
    import sanitize1
    os.chdir("D:/pythontest/HeadFirstPython/chapter6");
    class Athlete:
        def __init__(self,a_name,a_dob=None,a_times=[]):
            self.name=a_name;
            self.dob=a_dob;
            self.times=a_times;
        def top3(self):
            return (sorted(set([sanitize1.sanitize(t) for t in self.times]))[0:3]);
        def add_time(self,time_value):
            self.times.append(time_value);
        def add_times(self,list_of_times):
            self.times.extend(list_of_times);
            
    def get_coach_data(filename):
        try:
            with open(filename) as f:
                data=f.readline();
                templ=data.strip().split(',')
                                                                                 
                return (Athlete(templ.pop(0),templ.pop(0),templ));
                
        except IOError as ioerr:
                   print('File error:'+str(ioerr));
                   return(None);    
    '''try:
        james=get_coach_data('james2.txt');
        julie=get_coach_data('julie2.txt');
        mikey=get_coach_data('mikey2.txt');
        sarah=get_coach_data('sarah2.txt');  
    
        vera=Athlete('vera Vi');
        vera.add_time('1.31');
        print(vera.top3());
        vera.add_times(['2.22','1-21','2:22']);
        print(vera.top3());
        
        print(james.name+"'s fastest times are:"+str(james.top3()));
        print(julie.name+"'s fastest times are:"+str(julie.top3()));
        print(mikey.name+"'s fastest times are:"+str(mikey.top3()));
        print(sarah.name+"'s fastest times are:"+str(sarah.top3()));
    except IOError as err:
        print("File error"+str(err));'''
    运行结果为:



    2、建立视图:
    视图代码,会创建Web应用的用户界面。在web上,用户界面用web的标记技术HTML来创建。

    代码如下:

    import os
    os.chdir("D:/pythontest/HeadFirstPython/chapter7/chapter7/yatestuff/");
    
    from string import Template
    '''从标准库的"string"模块导入"Template"类,他支持简单的字符串替换模板。'''
    
    
    def start_response(resp="text/html"):#指示所传来的信息的MIME类型,一个很重要的一点那就是第一行代码:Content- type:text/html\r\n\r\n,这行被发送回浏览器,指明浏览器显示的文本类型。
        return('Content-type: ' + resp + '\n\n')
        '''这个函数需要一个(可选的)字符串作为参数,用它来创建一个CGI"content-type:"行,参数缺省值是”text/html"。'''
    
    os.chdir("D:/pythontest/HeadFirstPython/chapter7/chapter7/");    
    def include_header(the_title):
        with open('templates/header.html') as headf:
            head_text = headf.read()
        header = Template(head_text)
        return(header.substitute(title=the_title))
        '''打开模板文件(HTML),读入文件,换入所提供的"标题"。这个函数需要一个字符串作为参数,用在HTML页面最前面的标题中。页面本身存储在一个单独的文件"templates/header.html"中,
           可以根据需要替换标题'''
    
    
    
    def include_footer(the_links):
        with open('templates/footer.html') as footf:
            foot_text = footf.read()
        link_string = ''
        for key in the_links:
            link_string += '<a href="' + the_links[key] + '">' + key + '</a>    '
        footer = Template(foot_text)
        return(footer.substitute(links=link_string))
        '''打开模板文件(HTML),读入文件,换入"the links"中提供的HTML链接字典,将链接字典转换为一个字符串,然后再换入模板。
           HTML在字符串中加入空格的一种强制做法是  与“include_header"函数相似,这个函数使用一个字符串作为参数,
           来穿件一个HTML页面的尾部。页面本身存储在一个单独的文件“templates/footer.html"中,参数用于动态地创建一组HTML链接
           标记。从这些标记的使用来看,参数应当是一个字典。'''
    
    
    
    def start_form(the_url, form_type="POST"):
        return('<form action="' + the_url + '" method="' + form_type + '">')
        '''这个函数返回表单最前面的HTML,允许调用者指定URL(表单数据将发送到这个UPL),还可以指定所要使用的方法。action是你form表单提交的地址,这个地址可以是请求后台的地址,比如请求Servlet, Struts 或者 Spring MVC 的,也可以是你跳转页面的地址,比如某个html、jsp等'''
    
    
    
    def end_form(submit_msg="Submit"):
        return('<p></p><input type=submit value="' + submit_msg + '"></form>')
        '''这个函数返回表单末尾的HTML标记,同时还允许调用者定制表单"submit"(提交)按钮的文本。'''
        
    
    
    def radio_button(rb_name, rb_value):
        return('<input type="radio" name="' + rb_name +
                                 '" value="' + rb_value + '"> ' + rb_value + '<br />')
        '''给定一个单选钮名和值,创建一个HTML单选钮(通常包括在一个HTML表单中)。注意:两个参数都是必要的。'''
    
    
    
    def u_list(items):
        u_string = '<ul>'
        for item in items:
            u_string += '<li>' + item + '</li>'
        u_string += '</ul>'
        return(u_string)
        '''一个简单的for循环就可以达到目的。给定一个项列表,这个函数会把该列表转换为一个HTML无序列表。一个简单的for循环
            就可以完成全部工作,每次迭代会向ul元素增加一个li元素。'''
    
    
    
    def header(header_text, header_level=2):
        return('<h' + str(header_level) + '>' + header_text +
               '</h' + str(header_level) + '>')
        '''创建并返回一个HTML标题标记(H1、H2、H3等),默认为2级标题。“header_text"参数是必要的。'''
    
    
    
    def para(para_text):
        return('<p>' + para_text + '</p>')
        '''用HTML段落标记包围一个文本段(一个字符串)。'''


    3、控制器代码:



    CGI(Common Gateway Interface)是一个Internet标准,允许Web服务器运行一个服务器端程序,称为CGI脚本。

    基本原理:

    CGI:通用网关接口(Common Gateway Interface)是一个Web服务器主机提供信息服务的标准接口。通过CGI接口,Web服务器就能够获取客户端提交的

    信息,转交给服务器端的CGI程序进行处理,最后返回结果给客户端。组成CGI通信系统的是两部分:一部分是html页面,就是在用户端浏览器上显示的页

    面。另一部分则是运行在服务器上的Cgi程序。

    服务器和客户端之间的通信,是客户端的浏览器和服务器端的http服务器之间的HTTP通信,我们只需要知道浏览器请求执行服务器上哪个CGI程序就可以了,

    其他不必深究细节,因为这些过程不需要程序员去操作。

     服务器和CGI程序之间的通讯才是我们关注的。一般情况下,服务器和CGI程序之间是通过标准输入输出来进行数据传递的,而这个过程需要环境变量的

    协作方可实现。

    补充:

    (1)<form action="www.baidu.com" method="post">
    action 是链接,method 是方法。form是表单,里面的内容是要提交出去的。action可以理解成url,也就是当你内容填好以后点了提交按钮提交出去后转向的页面。类似论坛账号注册完以后,会转向论坛首页。method是方法,有get和post两种,各有所长。就是内容填好后提交需要一个方法,是获取你的内容还是传递你的内容。

    (2)CGI擅长根据需要动态地生成HTML。CGI的输入来自web服务器,输出也会送到web服务器。

    Web服务器生成动态内容,是由CGI脚本来实现的。所以,这个动态内容需要依托编写CGI脚本来实现。

    Web服务器执行这些CGI脚本对Web请求做出响应。

    Web服务器(支持CGI):就是为了提供HTML和运行CGI的。

    所有Web应用都要在Web服务器上运行

    (3)post请求:使用post方式时,数据放在data或者body中,不能放在url中,放在url中将被忽略。

    get请求:使用get方式时,请求数据直接放在url中。


    已有的网页:

    index.html

    <html>
    <head>
    <title>Welcome to Coach Kelly's Website</title>
    <link type="text/css" rel="stylesheet" href="coach.css" />
    </head>
    <body>
    <img src="images/coach-head.jpg">
    <h1>Welcome to Coach Kelly's Website.</h1>
    <p>
    For now, all that you'll find here is my athlete's <a href="cgi-bin/generate_list.py">timing data</a>. Enjoy!
    </p>
    <p>
    <!--加粗字体--->
    <strong>See you on the track!</strong>
    </p>
    </body>
    </html>
    


    header.html:

    <html>
    <head>
    <title>$title</title>
    <link type="text/css" rel="stylesheet" href="/coach.css" />
    </head>
    <body>
    <h1>$title</h1>

    footer.html:

    <p>
    $links
    </p>
    </body>
    </html>


    以下的程序均放到cgi-bin文件夹下:

    athletelist.py代码如下:

    class AthleteList(list):
    
        def __init__(self, a_name, a_dob=None, a_times=[]):
            list.__init__([])
            self.name = a_name
            self.dob = a_dob
            self.extend(a_times)
    
        @staticmethod
        def sanitize(time_string):
            if '-' in time_string:
                splitter = '-'
            elif ':' in time_string:
                splitter = ':'
            else:
                return(time_string)
            (mins, secs) = time_string.split(splitter)
            return(mins + '.' + secs)
    	
    	'''top3()方法被重新指定为一个类属性,@property修饰符允许访问“top3()"返回的数据时把它看作是个类属性。'''
    	
        @property
        def top3(self):
            return(sorted(set([self.sanitize(t) for t in self]))[0:3])
    
        @property
        def clean_data(self):
            return(sorted(set([self.sanitize(t) for t in self])))

    athletemodel.py代码如下:

    import pickle
    
    from athletelist import AthleteList
    
    def get_coach_data(filename):
        try:
            with open(filename) as f:
                data = f.readline()
            templ = data.strip().split(',')
            return(AthleteList(templ.pop(0), templ.pop(0), templ))
        except IOError as ioerr:
            print('File error (get_coach_data): ' + str(ioerr))
            return(None)
    
    def put_to_store(files_list):
        all_athletes = {}
        for each_file in files_list:
            ath = get_coach_data(each_file)
            all_athletes[ath.name] = ath
        try:
            with open('athletes.pickle', 'wb') as athf:
                pickle.dump(all_athletes, athf)
        except IOError as ioerr:
            print('File error (put_and_store): ' + str(ioerr))
        return(all_athletes)
    
    def get_from_store():
        all_athletes = {}
        try:
            with open('athletes.pickle', 'rb') as athf:
                all_athletes = pickle.load(athf)
        except IOError as ioerr:
            print('File error (get_from_store): ' + str(ioerr))
        return(all_athletes)
    

    还有 yate.py文件中的代码;


    Python提供了它自己的web服务器,这个web服务器包含在http.server库模块中。一个支持CGI的web服务器,名为simple_httpd.py

    #导入Http服务器和CGI模块,用Python构建一个web服务器必须有这5行代码。
    from http.server import HTTPServer, CGIHTTPRequestHandler
    #指定一个端口
    port = 8080
    #创建一个Http服务器
    httpd = HTTPServer(('', port), CGIHTTPRequestHandler)
    #显示一个友好的消息,并启动服务器
    print("Starting simple_httpd on port: " + str(httpd.server_port))
    httpd.serve_forever()

    generate_list.py(即跳转的第二个页面,是由该CGI程序动态生成的结果)

    #! /usr/local/bin/python3
    '''导入你需要的模块,你已经见过“athletemodel"和”yate“。
       利用glob模块可以向操作系统查询一个文件名列表。'''
    import glob
    
    import athletemodel
    import yate
    
    data_files = glob.glob("data/*.txt")
    athletes = athletemodel.put_to_store(data_files)#使用该方法由数据文件列表创建一个选手字典。
    
    print(yate.start_response())#总是从一个content-type行开始。
    print(yate.include_header("Coach Kelly's List of Athletes"))#网页题目;开始生成web页面,提供一个合适的标题。
    '''form是表单,里面的内容是要提交出去的,action可以理解为URL,也就是当你内容填好以后点了提交按钮提交出去后转向的页面。
       即,开始生成表单,提供要链接的服务器端程序的名(要执行的CGI脚本的名称)。'''
    print(yate.start_form("generate_timing_data.py"))
    print(yate.para("Select an athlete from the list to work with:"))
    #为各个选手分别生成一个单选按钮。
    for each_athlete in athletes:
        print(yate.radio_button("which_athlete", athletes[each_athlete].name))
    #生成表单的最后创建一个定制的“提交”按钮。
    print(yate.end_form("Select"))
    #在生成的HTML页面最下面增加一个链接,指向主页。
    print(yate.include_footer({"Home": "/index.html"}))
    
    generate_timing_data.py(第三个页面,展示所选选手的最快三个的时间。)

    #! /usr/local/bin/python3
    #导入CGI库
    import cgi
    '''在CGI脚本最前面增加这两行代码,启用Python的CGI跟踪技术。'''
    import cgitb
    cgitb.enable()
    
    import athletemodel
    import yate
    #还原所有运动员的文件pickle了的数据字典,从模型得到数据
    athletes = athletemodel.get_from_store()
    
    
    '''你在处理哪个选手的数据?'''
    #获取所有表单数据并放到一个字典中。
    form_data = cgi.FieldStorage()
    #从表单数据访问一个指定的数据
    athlete_name = form_data['which_athlete'].value
    
    print(yate.start_response())
    print(yate.include_header("Coach Kelly's Timing Data"))    
    print(yate.header("Athlete: " + athlete_name + ", DOB: " +
                          athletes[athlete_name].dob + "."))
    print(yate.para("The top times for this athlete are:"))
    '''由于使用了@property修饰符,在类用户看来top3()方法就像是一个属性。所以,不应该这样调用top3()方法:yate.u_list(athletes[athlete_name].top3());
    	要把top3()方法看作是一个类属性,应当这样调用:'''
    print(yate.u_list(athletes[athlete_name].top3)
    print(yate.include_footer({"Home": "/index.html",
                               "Select another athlete": "generate_list.py"}))
    
    


    4、测试驱动


    首先把cmd终端目录切换到服务器脚本所在的目录下,然后用python.exe启动服务器,命令中必须写python应用程序所在的绝对路径  再写要执行的服务器py文件。

    你的web服务器开始工作,它会把它处理的所有web请求记录下来(显示在屏幕上)。

    如:






    总结:

    1、@property------------这是一个修饰符,可以使类方法表现得像是一个类属性;

    2、web术语:

    2.1、web应用-------在web上运行的一个程序;

    2.2、web请求-------从web浏览器发送到web服务器;

    2.3、web响应-------从web服务器发送到web浏览器,作为对web请求的响应。

    2.4、CGI-------------通用网关接口(common gateway interface),允许web服务器运行一个服务器端程序。

    3、模型--视图--控制器(mode-view-controller)模式允许你采用一种可维护的方式设计和构建一个web应用。

    4、模型存储web应用的数据。

    5、视图显示web应用的用户界面。

    6、控制器将所有代码与编程逻辑“粘合”在一起。

    7、标准库string模块包括一个名为Template的类,它支持简单的字符串的替换。

    8、标准库http.server模块可以用来在Python中建立一个简单的web服务器。

    8、标准CGI模块对编写CGI脚本提供了支持。

    10、标准库glob模块非常适合处理文件名列表。

    11、CGI代码中可以使用cgitb.enable()打开CGI跟踪。

    12、可以使用cgi.FieldStorage()访问作为web请求一部分发送给Web服务器的数据,数据将作为一个Python字典。

    展开全文
  • HeadFirstPython-初识python

    2019-09-27 04:44:01
    HeadFirstPython-初识python 下面我们来看一下实例: 在书中,作者给我们展示了一个电影清单。在这里我们要学习列表的基本操作方法。 cast = ["Cless","plain","Jones","Idle"] 针对这个列表的实例,我们能做哪些...

    HeadFirstPython-初识python

    下面我们来看一下实例:
    在书中,作者给我们展示了一个电影清单。在这里我们要学习列表的基本操作方法。

    cast = ["Cless","plain","Jones","Idle"]

    针对这个列表的实例,我们能做哪些操作?

    打印出这个实例:

    In [28]: print(cast)
    ['Cless', 'plain', 'Jones', 'Idle']

    向这个实例添加一个新的数据项

    In [29]: cast.append("iamappend")

    In [30]: print(cast)
    ['Cless', 'plain', 'Jones', 'Idle', 'iamappend']

    从这个实例中弹出最后一个数据项
    In [31]: cast.pop()
    Out[31]: 'iamappend'

    In [32]: print(cast)
    ['Cless', 'plain', 'Jones', 'Idle']

    从这个实例中移除指定的数据项。比如我要移除plain
    In [33]: cast.remove("plain")

    In [34]: print(cast)
    ['Cless', 'Jones', 'Idle']

    现在数据项比以前少了,我再插入到指定的位置上。
    In [35]: cast.insert(1,"plain")

    In [36]: cast
    Out[36]: ['Cless', 'plain', 'Jones', 'Idle']

    如何合并列表?
    In [37]: newa = ["Gmail","baidu","sina"]

    In [38]: print(newa)
    ['Gmail', 'baidu', 'sina']

    In [39]: cast.extend(newa)

    In [40]: cast
    Out[40]: ['Cless', 'plain', 'Jones', 'Idle', 'Gmail', 'baidu', 'sina']

    以上只是简单的描述了一个如何对列表做一个操作。

    下一节: 向列表增加更多的数据。
    在书13页中,第一题:
    原题:
    movies = ["The Holy Grail","The Life of Brain","The Meaning of Life"]
    将其变成:
    movies = ["The Holy Grail",1975,"The Life of Brain",1979,"The Meaning of Life",1983]

    操作方法1.直接在进行人工插入
    In [42]: movies = ["The Holy Grail","The Life of Brain","The Meaning of Life"]

    In [43]: movies.insert(1,1975)

    In [44]: movies.insert(3,1979)

    In [45]: movies.insert(5,1983)

    这里可以直接使用 movies.append(1983) 因为这是最后一个了

    In [46]: print(movies)
    ['The Holy Grail', 1975, 'The Life of Brain', 1979, 'The Meaning of Life', 1983]

    操作方法2.就是直接新建列表
    In [47]: movies = ['The Holy Grail', 1975, 'The Life of Brain', 1979, 'The Meaning of Life', 1983]

    In [48]: print(movies)
    ['The Holy Grail', 1975, 'The Life of Brain', 1979, 'The Meaning of Life', 1983]

    下一节 处理列表数据

    简单的迭代
    fav_movies = ["The Holy Grail","The Life of Brian"]

    In [54]: for each_fclick in fav_movies:
    ....: print(each_fclick)
    ....:
    The Holy Grail
    The Life of Brian

    基本的迭代都是由for 或者while进行操作。
    两者的区别:
    while必须要使用状态信息,需要使用计数标识。否则有可能死循环下去。下面例子中 count就是作为计数标识符存在
    In [57]: while count < len(movies):
    ....: print(movies[count])
    ....: count=count+1
    ....:
    The Holy Grail
    1975
    The Life of Brain
    1979
    The Meaning of Life
    1983

    使用for作迭代时,python解释器将你考虑状态信息。

    下一节,在列表中存储列表

    很长的一个列表了
    In [62]: movies = ["The Holy Grail",1975,"Terry Jone & Terry Gillam",91,
    ["Graham chapman",["Michael Palin","Jone Cleese","Terry Gillam","Eric Idle","Terry Jone"]]]

    In [63]: print(movies)
    ['The Holy Grail', 1975, 'Terry Jone & Terry Gillam', 91, ['Graham chapman', ['Michael Palin', 'Jone Cleese', 'Terry Gillam', 'Eric Idle', 'Terry Jone']]]

    这么多层的列表肯定不是人工写的,使用Python如何来实现这么多层的列表呢
    In [74]: a = ["aaa","ccc"]

    In [75]: b = ["aaa111","ccc111"]

    In [76]: a.append(b) #如果是用a.extend的话,就是把两个列表进行合并了

    In [77]: a
    Out[77]: ['aaa', 'ccc', ['aaa111', 'ccc111']]

    多列表嵌套的迭代问题
    In [65]: for each_item in movies:
    ....: print(each_item)
    ....:
    The Holy Grail
    1975
    Terry Jone & Terry Gillam
    91
    ['Graham chapman', ['Michael Palin', 'Jone Cleese', 'Terry Gillam', 'Eric Idle', 'Terry Jone']]

    使用简单的for循环无法做打打出第一个数据项

    做一个迭代并且加上元素的类型判断
    In [66]: for each_item in movies:
    ....: if isinstance(each_item,list):
    ....: for each1_item in each_item:
    ....: if isinstance(each1_item,list):
    ....: for each2_item in each1_item:
    ....: print(each2_item)
    ....: else:
    ....: print(each1_item)
    ....: else:
    ....: print(each_item)
    ....:
    The Holy Grail
    1975
    Terry Jone & Terry Gillam
    91
    Graham chapman
    Michael Palin
    Jone Cleese
    Terry Gillam
    Eric Idle
    Terry Jone

    上面的一个例子中,代码有得用的存在,随着列表的嵌套越来越多层的时候,这个循环是有问题。
    下面使用一个函数进行简化操作:

    In [69]: def print_lol(the_list):
    ....: for each_item in the_list:
    ....: if isinstance(each_item,list):
    ....: print_lol(each_item) #重点在这一行上
    ....: else:
    ....: print(each_item)
    ....:

    In [73]: print_lol(movies)
    The Holy Grail
    1975
    Terry Jone & Terry Gillam
    91
    Graham chapman
    Michael Palin
    Jone Cleese
    Terry Gillam
    Eric Idle
    Terry Jone

    这里有一段按照书上指导写的函数

    def print_lol(the_list,indent=False,level=0):
    """
    模块参数说明:
    indent是一个用于控制是否缩进,默认值为False,启用值为Ture.
    level是一个用于控制缩进的级别,默认为0
    """
    for each_item in the_list:
    if isinstance(each_item,list):
    print_lol(each_item,indent,level+1)
    else:
    if indent:
    "这条语句表示一旦indent为Ture的时候,表示缩进已经打开"
    #for tab_stop in range(level):
    #print "\t",
    print "\t" *level , #这种方式也是可以的,可以连这个循环都不用做
    "在python 2.x里这使用这种方式。在python 3.x里使用其他方式"
    print(each_item)

    转载于:https://www.cnblogs.com/start0cheng/p/3558516.html

    展开全文
  • #!/usr/bin/env python #coding=utf-8 """ 这一章主要是讲如何将数据进行持久化。使用pickle对数据进行腌制。 在对数据进行腌制之前,...我用的是Python2.7 在某些语法上与HeadFirstPython原书有些不一样。 """ imp...
  • data = open('/Users/chenbaocheng/Desktop/HeadFirstPython/chapter3/sketch.txt') for each_item in data:  try:  "这里面写需要保护的代码内容"  (role,line_spoken) = each_item.split(':',1)  print role, ...
  • os.chdir("D:/pythontest/HeadFirstPython/chapter3/"); man=[]; other=[]; try: data=open('sketch.txt'); for each_line in data: try: (role,line_spoken)=each_line.split(':',1); line_spoken=line_spoken...
  • HeadFirstPython第二章

    2018-06-26 07:34:58
    函数模块
  • 1、 实现下面的效果: 代码如下: import os os.chdir("D:/pythontest/HeadFirstPython/chapter6"); def sanitize(time_string): if '-' in time_string: splitter='-'; el
  • 打开文件读取文件 with open(&amp;quot;james.txt&amp;quot;) as james: jam = james.readline().strip().split(&amp;quot;,&amp;quot;) with open(&amp;quot;julie.txt&...,
  • HeadfirstPython---3文件与异常4持久存储

    千次阅读 2018-07-10 12:47:38
    文件读写 import os print(os.getcwd()) data = open(&quot;1.txt&quot;) print(data.readline(),end='')#遇到空格结束 print(data.readline(),end='') print(&quot;... print(e...
  • HeadFirstPython第一章

    2015-06-23 20:55:45
    Python的过人之处 安装Python 显示Python的版本,Python -V,如果没有-V则进入Python解释器,quit()退出解释器。 启动IDLE编辑器会显示>>>三个大于号,BIF内置函数,print()将信息显示到屏幕上。...
  • 简单列表 Python的变量标识符没有类型 列表就像数组 animals = [&amp;amp;quot;cat&amp;amp;quot;,&amp;amp;quot;dog&amp;amp;quot;,&amp;amp;quot;tiger&...print(le
  • sanitize已经定义过了,james2的内容如下:不知道这个错误原因是什么,还请各位赐教,新手学习,以后怕是都要多问问大家了

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 207
精华内容 82
关键字:

headfirstpython

python 订阅