阅读在 IBM Lotus Notes 和 Domino 中编写快速查找代码的 11 个技巧。作者考察了 Lotus Notes 和 Domino 中的 @DbLookup @Formula 并描述了一些新技巧，供开发人员在编写新应用程序或对现有应用程序进行性能问题的故障检修时使用。



 
本文将考察 @DbLookup，它可能是 IBM Lotus Notes 和 Domino 中最流行的 @Formula。现在的 Lotus Notes/Domino 应用程序开发人员可能无法想像在不使用此公式的情况下创建应用程序，而超过 15 年的性能测试和客户故障检修已经表明：在应用程序的一个表单中，常常会以多种形式使用此公式数十次。
 
但是同样的经验表明：性能问题往往也与这些 @DbLookup 公式有关。我们已经看到，复杂的企业应用程序由于使用了这些公式，从而导致了无法接受的低性能而陷入实际的停顿。
 
本文将描述 11 个技巧，使用这些技巧能保证加快几乎任何应用程序的运行速度。这些技巧的范围广泛，包括从简单的一行代码到 @DbLookup 公式处理方法的根本性改变，但是所有这些技巧都已久经考验。
 
本文假设您具有 Lotus Notes/Domino 开发的一些知识，因此诸如 @DbLookup 公式的一些基本参数等内容，将不再赘述。 
 
本文将使用各种示例说明每个技巧的价值。为简单起见，我们使用一个 Help Desk 应用程序，它包含一个 Contact 表单和一个 Ticket 表单。此应用程序的基本工作流程是：客户调用，创建 Ticket 文档，接下来，获得客户的公司和名称信息后从下拉列表中选择适当的公司名称和联系人名称。还要选择适当的调用类别（例如 Product Help、Sales 等等）。下面给出一些例子，在这几种情况下使用 @DbLookup 公式会将非常有用：
 
从一个包含所有公司的列表中选择公司名称 
从一个包含该公司所有联系人的列表中选择客户名称 
从一个预先确定的或动态的问题类别列表中选择问题类别 
 
捕获错误
 
我们都不希望进行错误捕获，但是事与愿违。在 @DbLookup 公式中（本文中 @DbLookup 既指 @DbLookup 又指 @DbColumn 公式），错误往往更加难以处理，因为公式常常不仅取决于用户输入的键，还取决于其返回的数据。就是说公式可能在某一天能够工作，而在另一天就不能用了 —— 对开发人员来说这一直是个难题。
 
例如，假设公司名称在不同的 Contact 文档中有三四种不同的写法（比如 LSDevelopment Corporation 和 LS Development Corporation）。如果接下来要查找该公司的所有联系人名称，但是键入了 “LSDevelopment Company”（比方说），则找不到任何匹配的名称。
 
有多种方法可用于更精确的输入键（比如下拉列表），但是为了便于讨论，假设即使使用严格的开发技术，@DbLookup 也返回了一个错误。
 
错误检查的基本方法是编写如清单 1 所示的代码：
 


清单 1. 错误检查

 
 
v := @DbLookup(“Notes”; “”; “(Lookup-ContactsByCompany)”; CompanyName; 
“ContactName”);
@If(@IsError(v); “The program cannot find any contacts for this 
company”; v)
 
 

 
这段代码用于执行查找并检查错误条件。如果存在错误，则返回一个文本字符串，告诉用户存在一个问题；否则，则返回查找得到的值。
 
这虽然与性能无关，但却是很多应用程序都存在的一个基本问题，因此不能忽略。可将其看作一个附加的技巧。
 

 
 

 
    

回页首
 
 



 
使查找频率最小化
 
考虑下面的查找公式代码：
 
@If(@IsError(@DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1); “There are no 
company names”; @DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1)) 
这是一个很常见的错误，因为查找执行了两次，从性能角度来说这就是个问题。您可能认为第一个查找很好地缓存了查找结果，因此第二个查找就不会执行，但事实并非如此。第二个查找比第一个执行得快，因为后者（确实）缓存了查找结果，而前者原样执行。因为没有功能上的原因要求像那样编写公式代码，所以您应编写如下代码作为替代：
 
v := @DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1);
@If(@IsError(v); “There are no company names”; v) 
另一种导致执行不必要的查找的错误是：比如，一个 computed 字段在以下情形时计算查找公式：
 
第一次创建文档 
按下各种按钮以编辑模式刷新文档 
保存文档 
在稍后的日期以读模式打开文档 
在稍后的日期以编辑模式打开文档 
在稍后的日期保存文档 
 
最常见的是：希望只在第一次创建查找时执行查找。在这种情况下，将字段设置为 Computed When Composed 以防止再次计算。
 
在其他情况下，您可能希望每次以编辑模式打开文档时都执行查找。此时，按如下内容重写公式：
 
@If(@IsDocBeingEdited; “”; @Return(FieldName));
v := @DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1);
@If(@IsError(v); “There are no company names”; v)  
在这种情况下，FieldName 是此公式所在字段的名称。如果不是以编辑模式加载文档，则公式将只是保持该值并停止执行（参见图 1）。否则，将像以前一样执行 @DbColumn。
 


图 1. 关键字公式


 

 

 
 

 
    

回页首
 
 




 
正确地使用缓存
 
另一个常见错误是误解了 NoCache 参数的用法。通常，错误的推理是：认为数据越重要就越应该使用 NoCache。事实上，正确的思路应该是：执行查找的频率与数据变化的频率有关。 
 
例如，如果要查找的数据的变化频率很低，比如，一个月变化一次，则很难想象查找公式中需要使用 NoCache。在示例中我们假设创建了一些供 Ticket 文档引用的类别。该列表可能由应用程序的所有者维护，每隔数月（也许是发布新产品或输入新公司时）才执行一次更新。
 
另一方面，假设 Ticket 文档查找发出调用的客户名称。如果此客户一小时内发出两次调用，则我们会因为在第二个 ticket 上的查找中得不到客户名称而非常不方便，这是由于名称列表被缓存在了前一个查找中。在此类应用程序中，我们常常会看见 Help Desk 职员整天开着数据库，因此当天将缓存的查找长时间缓存起来比较方便。
 

 
 

 
    

回页首
 
 



 
避开下拉列表陷阱
 
多年以来，表单中出现的所有严重的性能问题中，下拉列表显得尤为突出，有以下两个方面的原因：下拉列表通常查找大列表，下拉列表在读模式下也进行计算。
 
您可在自己的应用程序上执行一个简单的测试。以读模式打开一个其中的表单执行速度较慢的文档。打开文档时，仔细观察屏幕，找出其停顿的地方并做上标记。这执行起来可能不太容易处理，因为您只有一秒钟的操作时间，然后屏幕就跳转了，但是如果能找人帮忙的话，则可由其中一人调用字段标签，同时由另一个人记下这些标签。然后在 IBM Lotus Domino Designer 中打开表单并查看那些标记下的内容。最可能的情况是，您将发现标记所在之处是使用了 @DbLookup 公式的下拉列表。这是怎么回事？
 
以读模式打开文档时，将检验所有的 @DbLookup 公式。因为文档处于读模式下，所以并不会返回实际的检验值，但它们仍然会执行完该过程，而该过程很耗时。对于下拉列表，情况将更加糟糕，因为关键字字段由用户选择的值填充，以防该用户切换到编辑模式。您可能认为可以等到用户切换至编辑模式，然后让用户做出选择，但 Lotus Notes 中并不是这样运作的。有趣的是，Web 浏览器中下拉列表却正是像那样运作，即使在相同的表单上运行也是如此。
 
一个很好用的清理下拉列表的技巧是：将三种不同的特性结合使用以防止执行不必要的查找。这些特性操作起来都很容易，但您必须将三者结合使用。
 
首先，在下拉列表字段的公式中，使用以下公式：
 
@If(@IsDocBeingEdited; “”; @Return(FieldName));
v := @DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1);
@If(@IsError(v); “There are no company names”; v) 
这与 “使查找频率最小化” 中描述的内容相似，并且在文档处于读模式时它可防止关键字下拉列表执行查找。如果用户以编辑模式打开文档，则下拉列表当然会正常地计算。现在我们必须确保用户从读模式转换到编辑模式时将会计算查找。为此，将继续执行下面两个步骤。
 
在下拉字段的属性中，启用 “Refresh choices on document refresh” 属性（参见图 2）。如果用户从读模式转换到编辑模式，则此属性可让关键字下拉公式在强制刷新文档时重新计算。
 


图 2. 下拉字段的属性


 

 
 
 
最后，在表单的 Postmodechange 事件中（参见图 3），包含以下代码，以便在用户从读模式转换到编辑模式时强制执行刷新：
 
If source.EditMode Then Call source.Refresh 




图 3. Postmodechange 事件


 

 

 
 

 
    

回页首
 
 




 
使用按钮和选择列表代替下拉列表
 
在某些情况下，有很多很大且使用非常频繁的下拉列表，此时惟一合理的解决方案是：在主表单上停止使用这些下拉列表。正确的思路应该是思考以下问题：
 
文档在使用期限内会被读取多少次？ 
文档会被编辑多少次？ 
在文档的编辑次数中，需执行多少次这样的查找？ 
 
答案常常类似于：“文档通常被读取 10 次，但只被编辑一、两次。在这些编辑次数中，这些下拉列表只被使用一次。”当然，答案总是随所使用文档的不同而变化，但这些却是些值得思考的好问题。如果需要频繁地编辑文档，但很少需要执行查找，则前一部分将不能满足，因为每次用户处于编辑模式时下拉列表都将重新计算，即使这些列表实际只需使用不超过一次时也是如此。在这种情况下，可考虑使用按钮，可能需要与选择列表结合使用。
 
使用按钮的优点在于：可让您从字段中删除查找公式。字段将不再是一个下拉列表，而是成为了一个常规的文本字段，可能是 Computed when Composed 字段，带有 FieldName 公式（下面的例子中使用的是 ProblemCategory 公式）。为避免混淆将在读模式下隐藏按钮，但是在编辑模式下单击按钮时，它将使用清单 2 所示的公式：
 


清单 2. 按钮的公式

 
 
tlist := @DbColumn("Notes"; ""; "(Lookup-Categories)"; 1);
list := @Unique(@Explode(tlist; "~"));
@If(@IsError(list); @Return(@Prompt([Ok]; "Error"; "The program was unable to lookup the 
Problem Categories.")); "");

dv := @If(ProblemCategory = ""; @Subset(list; 1); ProblemCategory);
v := @Prompt([OkCancelListMult]; "Problem Category"; "Choose one or more problem 
categories for this ticket."; dv; list);

FIELD ProblemCategory := v;
 
 

 
通过使用 @Picklist 而不是 @Prompt 和 @DbLookup，可进一步使性能流线化。其缺点在于会减少对弹出窗口布局和底层数据的控制。例如，查看清单 3 所示的代码。
 


清单 3. 使用 @Picklist

 
 
v := @PickList( [CUSTOM] ; “” ; “(Lookup-Categories)” ; “Problem Category” ; 
“Choose one or more categories from the list.” ; 1 )
result := @If(@IsError(v); “The program was unable to lookup the Problem Categories”; v);
FIELD ProblemCategory := result;
 
 



 
 

 
    

回页首
 
 



 
使用布局区域（或弹出窗口）代替下拉列表
 
由于前一部分对查找的大小和频率进行了探讨，因此似乎已经找到了应用程序的正确处理方法，但是如果得不到所需的控制又该如何，答案是考虑使用对话框。可使用 @Formula 语言或 LotusScript 弹出一个对话框，并且可在一个对话框中使用多个查找。当表单拥有多个相关的查找时，这常常是一个很好的解决方案。例如，当用户选择公司后，该用户接下来应得到一张该公司联系人的列表，也许还有一个下拉列表，包含了该联系人的开放 tickets 的主题行。在此情况下，您可能希望拥有一个按钮（如前一部分中那样），但是要和清单 4 所示的代码结合使用。
 


清单 4. 使用对话框

 
 
Dim w as NotesUIWorkspace
flag = w.DialogBox ( "(Dialog-CompanyLookup)", True, True, False, True, 
False, False,
"Company Name", doc, False, False, False )
 
 

 
这里不会对每个参数做详细介绍，但清单 5 显示了开发者帮助参考。
 


清单 5. 帮助参考

 
 
flag = notesUIWorkspace.DialogBox( form$ , [autoHorzFit] , [autoVertFit] , 
[noCancel] , 
[noNewFields] , [noFieldUpdate] , [readOnly] , [title$] , [notesDocument] , 
[sizeToTable] ,
[noOkCancel] , [okCancelAtBottom] )
 
 

 
在 Dialog-CompanyLookup 表单中，现在可插入布局区域并放入所有的下拉字段，而不用考虑 @IsDocBeingEdited。用户单击按钮，弹出对话框时需要等待执行这些查找。
 
使用对话框的另外几点想法：
 
有时候创建一个临时的 Notes 文档会很有帮助，您不用保存该文档，但它可作为先前代码示例中的 [notesdocument] 参数。这让您能使用 LotusScript 执行更精细的查找，从而创建对话框中的列表。例如，也许您希望只引用最后三个月中联系过的公司。 
在对话框表单中执行验证检查，因此直到验证完用户数据，用户才能回到主文档，这样处理可能比较方便。这可以减少用户必须返回到对话框的烦恼。 
可添加图形、帮助文本和更多其他东西，使对话框比一个简单的下拉列表或 @Prompt 框更具吸引力且具有更多功能。 
如果将应用程序移植到 Web 上，则可以很轻松地使用 JavaScript 弹出窗口替换对话框。布局区域本身不能在浏览器上显示，但是您可以使用 <div> 标记或表来模拟布局（<div> 标记是一种 HTML 代码，用于在页面上任何位置放置一段内容）。 
最后，还可以使用嵌套的表和 [sizeToTable] 参数使其在 Notes 客户机中更具吸引力。此表单将更加易于移植到 Web 上。 
 

 
 

 
    

回页首
 
 



 
使用 @Eval 清理代码
 
我们有时会看见大段的 @Formula 代码，里面充满了使用 @DbLookup 公式的 @If 语句。这些代码维护起来会很麻烦，而为避免不必要的查找以及执行适当的错误检查就更加困难（参见 “捕获错误” 部分）。使用 @Eval 可让您避免这类问题，如清单 6 所示。
 


清单 6. 使用 @Eval

 
 
companyLookup := {@DbColumn(“Notes”; “”; “(Lookup-Companies)”; 1);};
contactLookup := {@DbLookup(“Notes”; “”; “(Lookup-ContactsByCompany)”; 
CompanyName; “ContactName”);};

@If(someCondition = 1; @Eval(companyLookup); @Eval(contactLookup))
 
 

 
这段代码可防止在 @If 语句之前执行查找。换句话说，您可以提前设置所有的查找，给它们提供适当的变量名称，然后在需要时使用 @Eval 调用这些查找。
 

 
 

 
    

回页首
 
 



 
使用一个查找获取多个字段
 
如果您发现为获取不同的数据点要多次查找同一文档，则可考虑将该数据与查找视图中的一列连接起来。例如，假设我们需要从一个文档中获取下列数据点：
 
ContactName 
ContactPhone 
ContactAddress1 
ContactAddress2 
ContactCity 
ContactState 
ContactZip 
 
为此，我们可通过使用七个字段（每个字段都执行查找）来实现。ContactName 字段公式将类似于清单 7 所示的代码。 
 


清单 7. ContactName 字段公式

 
 
v := @DbLookup(“Notes”; “”; “(Lookup-ContactsByCompany)”; CompanyName; 
“ContactName”);
@If(@IsError(v); @Return(“The program could not locate that 
document.”); v);
 
 

 
而 ContactPhone 字段公式将类似于清单 8 所示的代码。
 


清单 8. ContactPhone 字段公式

 
 
v := @DbLookup(“Notes”; “”; “(Lookup-ContactsByCompany)”; CompanyName; “
ContactPhone”);
@If(@IsError(v); @Return(“The program could not locate that 
document.”); v);
 
 

 
七个字段中的每一个都以此类推。
 
但是如果可以执行一个而不是七个查找的话，您就可获得更好的性能，即使假定在同一视图中对同一文档执行七个查找时也是如此。有一种方法可达到此目的：设置查找视图，使其包含具有清单 9 所示公式的另外一列。 
 


清单 9. 设置查找视图使其包含另外一列

 
 
@If(ContactName = “”; “NA”; ContactName) + “~” + 
@If(ContactPhone = “”; “NA”; ContactPhone) + “~” +  
@If(ContactAddress1 = “”; “NA”; ContactAddress1) + “~” + 
@If(ContactAddress2 = “”; “NA”; ContactAddress2) + “~” + 
@If(ContactCity = “”; “NA”; ContactCity) + “~” + 
@If(ContactState = “”; “NA”; ContactState) + “~” + 
@If(ContactZip = “”; “NA”; ContactZip); 
 
 

 
现在在表单中设置一个隐藏字段 —— 不妨称之为 BigLookup —— 并将清单 10 所示的公式放入 BigLookup 中：
 


清单 10. 查找 ContactsByCompany

 
 
v := @DbLookup(“Notes”; “”; “(Lookup-ContactsByCompany)”; 
CompanyName; 2);
@If(@IsError(v); @Return(“The program could not locate that 
document.”); v);
 
 

 
现在对于 ContactName 字段，其公式可能如清单 11 所示。
 


清单 11. 查找 ContactName

 
 
tv := @Explode(BigLookup; “~”);

v := tv[1];

@If(@IsError(v); @Return(“The program could not locate that document.”); v = “NA”; “”; v);
 
 

 
而对于 ContactPhone，查看清单 12 所示的代码。
 


清单 12. 查找 ContactPhone

 
 
tv := @Explode(BigLookup; “~”);

v := tv[2];

@If(@IsError(v); @Return(“The program could not locate that document.”); 
v = “NA”; “”; v);
 
 

 
七个字段中的每一个都以此类推。
 
关于此技术的两点注意：
 
在视图列公式中我们将 “NA” 替代为 “”，如果不这样做的话，@Explode 会破坏所有的空白值并生成一个少于七个值的列表，这将会出现问题。 
在每个字段公式中将 “” 替代为 “NA”，但错误消息的处理完全取决于您的判断。 
 

 
 

 
    

回页首
 
 



 
制作更快的查找视图
 
任意种类查找视图的性能，不论使用的是 @Formula 语言还是 LotusScript，都取决于该视图的大小和运行速度。我们已经汇编了一些可用于优化查找视图性能的技巧。
 
制作专用的查找视图
 
在生产环境中索引（刷新）一个很典型的视图大约会花费 100 ms。也就是说，每 15 分钟服务器将花费不到十分之一秒的时间来更新每个查找视图。当然，这些时间是近似值，而且每个应用程序和服务器之间差别很大，但是对此数据的多年研究让我们相信：即使添加几个查找视图对性能的影响也不大。添加专用的查找视图可让您在用户等待查找完成时使视图性能流线化。
 
使视图设计流线化
 
如果视图只用于从某些文档查找数据，则可将以下内容从视图设计中消除：
 
所有有趣的字体和颜色。 
所有的动作栏按钮。 
视图事件中的任何 LotusScript 代码。 
对 Profile 文档的任何引用。 
无关的列。如果要从这些列返回数据，则保留该列；反之则消除该列。 
视图列的多个排序选项。例如，如果用户从不访问视图，则无需对其按升序或降序排序；它所做的只是增加了视图的大小。 
用于限制 @DbLookup 返回的选择列表的读者名称字段。这些字段对性能有很大的影响。 
 
还可将类别转换成排序列，后者提供了相同的查找功能但可使视图更快地进行索引。
 
使数据流线化
 
除使设计最小化外，还可以考虑如何使视图中的数据最小化。下面有一些建议：
 
如果可以的话，尽可能地将数据归档。用于企业的设计考虑通常要胜过本文介绍的这些，但常常可将数据归档到另一个 Notes 数据库中，用户可在只读基础上访问该数据库（比如）。这样做可加快主数据库中的很多函数的运行速度，当然也限制了视图中的数据，使其运行得更快。 
仔细地优化视图选择公式以便只显示实际需要的数据。 
确保没有选择某些不显示但仍需包含到视图索引中的响应文档。选择公式 SELECT Form = “Main” | @IsResponseDoc 可能不经意地做到了这一点。反过来，使用 @DocDescendants 确保只包含显示的响应文档。 
作为删除不必要数据的示例，我们看到了一些客户应用程序，其中的查找视图只需使用过去 30 天的数据，但数据库却必须将数据保存很长的时间，如两年。在该视图中使用时间敏感或日期敏感的公式显然不合适（太慢），但是使用周代理在文档中设置标记也许可行，使用该代理只标记那些已创建超过 30 天的文档。现在选择公式可以只引用该标记即可排除大量的文档，而不排除这些文档就会降低视图的运行速度。 
消除任何没有用于查找的数据显示。 
 
使用 “Generate unique keys in index” 消除重复条目
 
这是一个很好的技巧，可以极大地减小某些视图的大小。如果查找得到了大量的重复值，而这些值后来又被使用 @Unique（或等效的 LotusScript）消除，则可使用此特性。在这种情况下，启用 “Generate unique keys in index” 选项可使视图索引只显示找到的文本字符串的第一个实例（参见图 4）。
 
但是如果排序列引用了多值字段，则使用此选项时要格外小心。在这种情况下，如果 Domino 服务器是 6.x 版本，则可能要使用 @Implode(MultiValueField; “~”)，然后让查找公式使用 @Unique(@Explode(@DbColumn(); “~”)) 以获取真实的惟一值集。如果使用的是 Lotus Domino 7，则没什么关系，因为服务器能智能地显示所有的惟一值。请注意：视图使用此特性时索引速度会稍慢一些，因为刷新视图时服务器可能要做比平时更多的工作。除非该特性能极大地减少视图中显示的文档数量，否则不要使用它。在很多应用程序中，使用此特性可使视图的大小减小到原来的 1/100，在这种情况下该特性可谓居功至伟。
 


图 4. View Properties 对话框


 

 

 
 

 
    

回页首
 
 




 
使用 Profile 文档
 
如果您拥有一些不是由多个用户更新且更新不频繁的列表，则检索这些值的一个快速方法是将其存储在 Profile 文档中。不管您是在 Profile 文档中手动更新列表，还是在常规文档中手动更新列表然后将其移植到 Profile 文档中，与缓存视图相比，用户都可更有效地缓存 Profile 文档，因此可以更快速地执行重复查找。
 
但是，如果用户正在更新列表，则使用 Profile 文档可能就不适当了，因为多个更新之间可能相互重写，然后导致复制/保存冲突。
 

 
 

 
    

回页首
 
 



 
使用查找数据库
 
大型应用程序常常可使用单独的查找数据库，可能是依据以下理论：要查找的数据非常多，因此从主数据库中获取数据和所需的视图比较方便。虽然这种说法具有一定的概念逻辑，但在现实中这样做往往会得不偿失。下面是一些技巧，可用于确定什么时候将查找数据存放在单独的数据库中，以及什么时候将数据存放在主数据库中更合适：
 
如果多个应用程序访问相同的列表，则使用单独的数据库存放这些列表比较合适。 
如果要查找大量的数据并且这些数据需要使用多个表单，则从主用户数据库中获取数据比较合适。 
另一方面，如果查找数据使用单个表单，并且只有几百个文档，则对主数据库的影响几乎可以忽略不计。基于维护和性能上的优点，因此在这种情况下我们鼓励您将查找保存在主数据库中。 
 
所有这些情况中有一个例外就是，可能某些时候性能非常重要并且多个数据库访问几个简短的列表。在这种情况下，可能需要将这些列表保存在单独的查找数据库中，但是又通过 LotusScript 代理（或 Lotus Enterprise Integrator）将其移植到每个主数据库中。这样维护起来可能有些麻烦，但是可得到最好的性能。
 

 
 

 
    

回页首
 
 



 
结束语
 
我们希望这些技巧能在您编写下一个应用程序或对现有应用程序中的性能问题进行故障检修时为您提供一些可用的新工具。动态查找是大多数应用程序中的一个重要部分，因此，使用它们以使其性能影响最小化是确保拥有可顺利运行多年的高质量程序的最佳方法。
  

 
文章目录
 
前言
第一章
一、填空题
二、判断题
三、选择题
四、简答题
  
第二章
一、填空题
二、判断题
三、选择题
四、简答题
  
第三章
一、填空题
二、判断题
三、选择题
四、简答题
  
第四章
一、单选题
二、判断题
三、填空题
四、程序分析题
  
第五章
一、选择题
二、判断题
三、填空题
四、简答题
五、程序分析题
  
第六章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
  
第七章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
  
第八章
一、单选题
二、判断题
三、填空题
四、简答题
  
第九章
一、单选题
二、判断题
三、填空题
四、简答题
  
第十章
一、单选题
二、判断题
三、填空题
四、简答题
  
第十一章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
  
第十二章
一、选择题
二、判断题
三、填空题
四、简答题
  
END

 
 
前言
 
本文整理了填空、选择、判断等一些课后习题答案，具体的编程题可以见:Python快速编程入门课后程序题答案。
 
第一章
 
一、填空题
 
Python是一种面向对象的高级语言。
Python可以在多种平台运行，这体现了Python语言的可移植特性。
Python源代码被解释器转换后的格式为字节码。
Python 3.x 默认使用的编码是UTF-8。
 
二、判断题
 
Python是开源的，它可以被一直到许多平台上。(√)
Python的优点之一是具有伪代码的本质。(√)
Python可以开发Web程序，也可以管理操作系统。(√)
Mac系统自带Python开发环境。(√)
Python自带的shell，其性能优于IPython。(×)
我们编写的Python代码在运行过程中，会被编译成二进制代码。(×)
Python程序被解释器转换后的文件格式后缀名为.pyc。(√)
Python 3.x 版本的代码完全兼容 Python 2.x。(×)
PyCharm是开发Python的集成开发环境。(√)
代码print(3,4)是Python 2.x的输出格式。(×)
 
三、选择题
 
 
下列选项中，不属于Python语言特点的是(C)。
 A.简单易学 B.开源 C.面对过程 D.可移植性
 
 
下列领域中，使用Python可以实现的是(ABCD)。(多选)
 A.Web开发 B.操作系统管理 C.科学计算 D.游戏
 
 
下列关于Python 2.x和Python 3.x的说法，正确的是(B)。
 A.Python 3.x使用print语句输出数据
 B.Python 3.x默认使用的编码是UTF-8
 C.Python 2.x和Python 3.x使用//进行除法运算的结果不一致
 D.Python 3.x版本的异常可以直接被抛出
 
 
下列关于Python的说法中，错误的是(C)。
 A.Python是从ABC发展起来的
 B.Python是一门高级的计算机语言
 C.Python是一门只面向对象的语言
 D.Python是一种代表简单主义思想的语言
 
 
下列关于IPython的说法，错误的是(D)。
 A.IPython集成了交互式Python的很多有点
 B.IPython的性能远远优于标准的Python的shell
 C.IPython支持变量自动补全，自动收缩
 D.与标准的Python相比，IPython缺少内置的功能和函数
 
 
四、简答题
 
 
简述Python的特点。
 •简单易学
 •开源
 •高级语言
 •可移植性
 •解释性
 •面向对象
 •可扩展性
 •丰富的库
 •规范的代码
 
 
简述Python的应用领域(至少3个)。
 •web应用开发
 •操作系统管理、服务器运维的自动化脚本
 •科学计算
 •桌面软件
 •服务器软件（网络软件）
 •游戏
 •构思实现，产品早期原型和迭代
 
 
简述Python 2.x和Python 3.x的区别。
 (1)、在python2.x中，输出数据使用的是print语句。但是在python3.x中， print语句没有了，取而代之的是print()函数
 (2)、python2有ASCII Str()类型，unicode()是单独的，不是byte类型。在python3.x版本的源代码中，默认使用的是UTF-8编码，从而可以很好的支持中文字符。
 (3)、在python 2.x中，使用运算符/进行除法运算，整数相除的结果是一个整数，浮点数除法会保留小数点的部分得到一个浮点数的结果。在python 3.x中使用运算符/进行除法，整数之间的相除，结果也会是浮点数。
 (4)、相比python2.x版本，python3.x版本在异常方面有很多改变:
   •在python2.x版本，所有类型的对象都是直接被抛出的，但是，在python3.x版本中，只有继承自BaseException的对象才可以被抛出。
   •在python2.x版本中，捕获异常的语法是except exc，var。在python3.x版本中，引入了as关键字，捕获异常的语法变更为except exc as var。
   •在python2.x版本中，处理异常使用raise Exception(args)。在python3.x版本中，处理异常使用raiseException, args。
   •python3.x取消了异常类的序列行为和.message属性。
 (5)、在Python 3.x中，表示八进制字面量的方式只有一种，并且必须写0o1000这样的方式，原来01000的方式不能使用了。
 (6)、Python 2.x中不等于有两种写法 != 和 <>；但是，Python 3.x中去掉了<>, 只有!=一种写法
 (7)、python3.x去除了long类型，现在只有一种整型int，但它的行为就像是python2.x版本的long。
 
 
简述Python程序的执行原理。
 Python程序的执行原理如图所示:
 
 Python解释器将源代码转换为字节码，然后把编译好的字节码转发到Python虚拟机(PVM)中进行执行。
 
 
简述IPython的特点。
 •IPython具有卓越的Python shell，其性能远远优于标准Python的shell。
 •IPython支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数。
 •IPython提供了基于控制台命令环境的定制功能，可以十分轻松地将交互式Python shell包含在各种Python应用中，甚至可以当作系统级shell来使用。
 
 
第二章
 
一、填空题
 
在Python中，int表示的数据类型是整型。
布尔类型的值包括True和False。
Python的浮点数占8个字节。
如果要在计算机中表示浮点数$1.2\times 10^5$，则表示方法为1.2e5。
00001000>>2的结果是00000010。
若a=20，那么bin(a)的值为0b10100。
如果想测试变量的类型，可以使用type()来实现。
若a=1，b=2，那么(a or b)的值为1。
若a=10，b=20，那么(a and b)结果为20。
4.34E5表示的是4.34×10^5。
 
二、判断题
 
Python使用符号#表示单行注释。(√)
标识符可以以数字开头。(×)
type()方法可以查看变量的数据类型。(√)
Python中的代码块使用缩进来表示。(√)
Python中的多行语句可以使用反斜杠来实现。(×)
Python中标识符不区分大小写。(×)
Python中的标识符不能使用关键字。(√)
使用help()命令可以进入帮助系统。(√)
Python中的成员运算符用于判断制定序列中是否包含某个值。(√)
比较运算符用于比较两个数，其返回的结果智能是True或False。(√)
 
三、选择题
 
 
下列选项中，(D)的布尔值不是Flase。
 A.None
 B.0
 C.()
 D.1
 
 
假设a=9，b=2，那么下列运算中，错误的是(D)。
 A.a+b的值是11
 B.a//b的值是4
 C.a%b的值是1
 D.a**b的值是18
 
 
下列标识符中，合法的是(AD)。
 A.helloWorld
 B.2ndObj
 C.hello#world
 D._helloworld
 
 
下列符号中，表示Python中单行注释的是(A)。
 A.#
 B.//
 C.<!-- -->
 D."“"
 
 
下列选项中，符合Python命名规范的标识符是(C)。
 A.user-Passwd
 B.if
 C._name
 D.setup.exe
 
 
下列选项中，Python不支持的数据类型有(B)。
 A.int
 B.char
 C.float
 D.dicitionary
 
 
下列表达式中，返回 True 的是(B)。
 A.a=2 b=2 a=b
 B.3>2>1
 C.True and False
 D.2!=2
 
 
下列语句中，哪个在 Python 中是非法的?(B)。
 A.x = y = z = 1
 B.x = (y = z + 1) 
 C.x, y = y, x
 D.x += y
 
 
下列关于 Python 中的复数，说法错误的是(C)。
 A.表示复数的语法是 real + image j
 B.实部和虚部都是浮点数
 C.虚部必须后缀 j，且必须是小写
 D.一个复数必须有表示虚部的实数和 j
 
 
下列选项中，幂运算的符号为(D)。
 A.*
 B.++
 C.%
 D.**
 
 
四、简答题
 
简述Python中标识符的命名规则。
 •标识符由字母、下划线和数字组成，且数字不能开头。
 •python中的标识符是区分大小写的。
 •python中的标识符不能使用关键字。
简述Python中的数字类型。
 int(整型)、long(长整型)、float(浮点数)、complex(复数)
 
第三章
 
一、填空题
 
在循环体中使用break语句可以跳出循环体。
elif语句是else语句和if语句的组合。
在循环体中可以使用continue语句跳过本次循环后面的代码，重新开始下一次循环。
如果希望循环是无限的，我们可以通过设置条件表达式永远为True来实现无限循环。
Python中的pass表示的是空语句。
 
二、判断题
 
elif可以单独使用。(×)
pass语句的出现是为了保持进程结构的完整性。(√)
在Python中没有switch-case语句。(√)
每个if条件后面都要使用冒号。(√)
循环语句可以嵌套使用。(√)
 
三、选择题
 
下列选项中，会输出1，2，3三个数字的是(BC)。
 
A.
for i in range(3):
    print(i)
 
B.
for i in range(3):
    print(i + 1)
 
C.
a_list = [0,1,2]
for i in a_list:
    print(i + 1)
 
D.
i = 1
while i < 3:
    print(i)
    i = i + 1
 
阅读下面的代码：
 
sum = 0
for i in range(100):
    if(i%10):
        continue
    sum = sum + i
print(sum)
 
  上述程序的执行结果是(C)。
     A.5050 B.4950 C.450 D.45
 
已知x=10,y=20,z=30:以下语句执行后x,y,z的值是(C)。
 
if x < y:
    z=x
    x=y
    y=z
 
    A.10,20,30
     B.10,20,20
     C.20,10,10
     D.20,10,30
 
有一个函数关系如下所示：
 
x
y
x<0
x-1
x=0
x
x>0
x+1
下面程序段中，能正确表示上面关系的是(C)。
 
A.
y = x + 1
if x >= 0
    if x == 0:
        y = x
    else:
        y = x - 1;
 
B.
y = x - 1
if x != 0:
    if x > 0:
        y = x + 1
    else:
        y = x
 
C.
if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x
else:
    y = x + 1
 
D.
y = x
if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x + 1
 
下列Python语句正确的是(D)。
 A.min=x if x<y else y
 B.max=x>y?x:y
 C.if(x>y) print x
 D.while True:pass
 
四、简答题
 
简述Python中pass语句的作用。
 Python中的pass是空语句，它的出现是为了保持程序结构的完整性。
 pass不做任何事情，一般用做占位语句。
简述break和continue的区别。
 break语句用于结束整个循环；
 continue的作用是用来结束本次循环，紧接着执行下一次的循环。
 
第四章
 
一、单选题
 
 
当需要在字符串中使用特殊字符的时候，Python使用(A)作为转义字符。
 A.\
 B./
 C.#
 D.%
 
 
下列数据中不属于字符串的是(D)。
 A.‘ab’
 B.’’‘perfect’’’
 C.“52wo”
 D.abc
 
 
使用(B)符号对浮点类型的数据进行格式化。
 A.%c
 B.%f
 C.%d
 D.%s
 
 
字符串’Hi,Andy’中，字符’A’对应的下标位置为(C)。
 A.1
 B.2
 C.3
 D.4
 
 
下列方法中，能够返回某个子串在字符串中出现次数的是(C)。
 A.length
 B.index
 C.count
 D.find
 
 
下列方法中，能够让所有单词的首字母变成大写的方法是(B)。
 A.capitalize
 B.title
 C.upper
 D.ljust
 
 
字符串的strip方法的作用是(A)。
 A.删除字符串头尾指定的字符 B.删除字符串末尾的指定字符
 C.删除字符串头部的指定字符 D.通过指定分隔符对字符串切片
 
 
二、判断题
 
无论使用单引号或者双引号包含字符，使用print输出的结果都一样。(√)
无论input接收任何的数据，都会以字符串的方式进行保存。(√)
Python中只有一个字母的字符串属于字符类型。(×)
使用下标可以访问字符串中的每个字符。(√)
Python中字符串的下表是从1开始的。(×)
切片选区的区间范围是从起始位开始的，到结束位结束。(×)
如果index方法没有在字符串中找到子串，则会返回-1。(×)
 
三、填空题
 
字符串是一种表示文本数据的类型。
像双引号这样的特殊符号，需要对它进行转义输出。
Python3提供了input函数从标准输入(如键盘)读入一行文本。
切片指的是对操作的对象截取其中的一部分。
切片选取的区间是左闭右开型的，不包含结束位的值。
 
四、程序分析题
 
阅读下面的程序，分析代码是否可以编译通过。如果编译通过，请列出运行的结果，否则说明编译失败的原因。
 
代码一:
 
num_one = input("请输入一个整数：")
num_two = input("请输入一个整数：")
if num_one % num_two == 0:
    print("验证码正确")
 
  答：不能编译通过。因为num1和num2属于字符串类型，不能执行取余操作。
 
代码二:
 
name = 'Steve Jobs'
print(name[6])
 
  结果为：J
 
代码三:
 
string_example = 'hello world itheima'
index = string_example.index("itheima",0,10)
print(index)
 
  答：由于没有在字符串中找到子串，index方法默认会抛出ValueError异常。
 
代码四:
 
string_example = "  hello world  "
print(string_example.strip())
 
  结果为：Hello World (默认删除两头的空格)
 
代码五:
 
string_example = "Hello" + 'Python'
print(string_example)
 
  结果为：HelloPython
 
第五章
 
一、选择题
 
 
关于列表的说法，描述有错误的是(D)。
 A.list是一个有序集合，没有固定大小
 B.list可以存放任意类型的元素
 C.使用list时，其下标可以是负数
 D.list是不可变的数据类型
 
 
以下程序的输出结果是(B)。(提示：ord(“a”)==97)
 
 
list_demo=[1,2,3,4,5,'a','b']
print(list_demo[1],list_demo[5])
 
    A.1 5
     B.2 a
     C.1 97
     D.2 97
 
执行下面的操作后，list_two的值为(C)。
 
list_one=[4,5,6]
list_two=list_one
list_one[2]=3
 
    A.[4,5,6]
     B.[4,3,6]
     C.[4,5,3]
     D.A,B,C都不正确
 
阅读下面的程序：
 
list_demo=[1,2,1,3]
nums=set(list_demo)
for i in nums:
      print(i,end="")
 
  程序执行的结果为(D)。
     A.1213
     B.213
     C.321
     D.123
 
 
下列选项中，正确定义了一个字典的是(D)。
 A.a=[‘a’,1,‘b’,2,‘c’,3]
 B.b=(‘a’,1,‘b’,2,‘c’,3)
 C.c={‘a’,1,‘b’,2,‘c’,3}
 D.d={‘a’:1,‘b’:2,‘c’:3}
 
 
下列选项中，不能使用下标运算的是(C)。
 A.列表
 B.元组
 C.集合
 D.字符串
 
 
下列程序执行后输出的结果为(A)。
 
 
x = 'abc'
y = x
y = 100
print(x)
 
    A.abc
     B.100
     C.97,98,99
     D.以上三项均是错误的
 
 
下列删除列表中最后一个元素的函数是(B)。
 A. del B. pop C. remove C. cut
 
 
下列函数中，用于返回元祖中元素最小值的是(C)。
 A. len B. max C. min D.tuple
 
 
二、判断题
 
列表的索引是从0开始的。(√)
通过insert方法可以在制定位置插入元素。(√)
使用下标能修改列表的元素。(√)
列表的嵌套指的是一个列表的元素是另一个列表。(√)
通过下标索引可以修改和访问元祖的元素。(×)
字典中的值只能够是字符串类型。(×)
在字典中，可以使用count方法计算键值对的个数。(×)
 
三、填空题
 
Python序列类型包括字符串、列表和元组三种，字典是Python中唯一的映射类型。
Python中的可变数据类型有字典和列表。
在列表中查找元素时可以使用not in和in运算符。
如果要从小到大的排列列表的元素，可以使用sort方法实现。
元组使用圆括号存放元素，列表使用的是方括号。
 
四、简答题
 
请简述元组、列表和字典的区别。
 (1)、外形：列表是中括号括起来的数据；元组是圆括号括起来的数据；字典是花括号括起来的数据
 (2)、存储结构：列表可以存储多个不同类型的数据，以逗号分隔；元组同样能存储多个不同类型的数据，以逗号分隔；字典能存储多个键值对，以逗号分隔，键是唯一的，值是任何类型的。
 (3)、访问方式：列表可以通过下标索引访问元素，索引从0开始；元组可以通过下标索引访问值，索引从0开始；字典通过键来访问值。
 (4)、是否可变类型：列表是可变类型，元组是不可变类型，字典是可变类型。
 
五、程序分析题
 
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。
 
代码一:
 
tup = ('a','b','c')
tup[3] = 'd'
print(tup)
 
  答：程序运行错误，元组不能使用下标增加元素。
 
代码二:
 
dict_demo={'a':1,'b':2,'c':3}
print(dict_demo['a'])
 
  结果为：1
 
代码三:
 
list_demo=[10,23,66,26,35,1,76,88,58]
list_demo.reverse()
print(list_demo[3])
list_demo.sort()
print(list_demo[3])
 
  结果为：
   1
   26
 
第六章
 
一、单选题
 
阅读下面的程序：
 
def func():
    print(x)
    x=100
func()
 
  执行上述语句后，输出的结果为(C)。
     A.0 B.100 C.程序出现异常 D.程序编译失败
 
 
下面关于函数的说法，错误的是(C)。
 A.函数可以减少代码的重复，使得程序更加模块化
 B.在不同的函数中可以使用相同名字的变量
 C.调用函数时，传入参数的顺序和函数定义时的顺序必须相同
 D.函数体中如果没有return语句，也会返回一个None值
 
 
下列有关函数的说法中，正确的是(C)。
 A.函数的定义必须在程序的开头
 B.函数定义后，其中的程序就可以自动执行
 C.函数定义后需要调用才会执行
 D.函数体与关键字def必须左对齐
 
 
下列函数调用使用的参数传递方式是(A)。
 
 
result = sum(num1, num2, num3)
 
    A.位置绑定 B.关键字绑定 C.变量类型绑定 D.变量名称绑定
 
 
使用(C)关键字创建自定义函数。
 A. function B. func C.def D.procedure
 
 
使用(D)关键字声明匿名函数。
 A. function B. func C.def D.lambda
 
 
二、判断题
 
函数的名称可以随意命名。(×)
不带return的函数代表返回None。(√)
默认情况下，参数值和参数名是跟函数声明定义的顺序匹配的。(√)
函数定义完成后，系统会自动执行其内部的功能。(×)
函数体以冒号起始，并且是缩进格式的。(√)
带有默认值的参数一定位于参数列表的末尾。(√)
局部变量的作用域是整个程序，任何时候使用都有效。(×)
匿名函数就是没有名字的函数。(√)
 
三、填空题
 
函数可以有多个参数，参数之间使用逗号分隔。
使用return语句可以返回函数值并退出函数。
通过return结束函数，从而选择性地返回一个值给调用方。
函数能处理比声明时更多的参数，它们是不定长参数。
在函数里面调用另外一个函数，这就是函数嵌套调用。
在函数的内部定义的变量称作局部变量。
全局变量定义在函数外，可以在整个程序范围内访问。
如果想在函数中修改全部变量，需要在变量的前面加上global关键字。
 
四、简答题
 
请简述局部变量和全局变量的区别。
 局部变量：
 (1)、函数内部定义的变量；
 (2)、作用域是函数的内部。
 全局变量：
 (1)、函数外部定义的变量；
 (2)、作用域是整个程序。
请简要说明函数定义的规则。
 (1)、以def关键字开头，后面接函数标识符名称和圆括号；
 (2)、给函数起名字的时候，规则跟变量的名字是一样的；
 (3)、任何传入参数和自变量必须放在圆括号中间；
 (4)、函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明；
 (5)、函数内容以冒号起始，并且缩进；
 (6)、return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
 
五、程序分析题
 
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。
 
代码一:
 
def func():
    x = 200
x = 100
func()
print(x)
 
  结果为：100
 
代码二:
 
def func():
    global x
    x = 200
x = 100
func()
print(x)
 
  结果为：200
 
代码三:
 
def func():
    x = 200
    def func2():
        print(x)
    func2()
x = 100
func()
print(x)
 
  结果为：
   200
   100
 
第七章
 
一、单选题
 
 
关于装饰器，下列说法错误的是(B)。
 A.装饰器是一个包裹函数
 B.装饰器智能有一个参数
 C.通过在函数定义的面前加上@符号阿和装饰器名，使得装饰器函数生效
 D.如果装饰器带有参数，则必须在装饰函数的外层再嵌套一层函数
 
 
下列函数中，用于使用函数对制定序列进行过滤的是(C)。
 A.map函数 B.select函数 C.filter函数 D.reduce函数
 
 
下列选项中，不能作为filter函数参数的是(D)。
 A.列表 B.元组 C.字符串 D.整数
 
 
阅读下面一段程序：
 
 
def foo():
    a = 1
    def bar():
        a = a + 1
        return a
    return bar
print(foo()())
 
  上述程序执行的结果为(A)。
     A.程序出现异常
     B.2
     C.1
     D.没有输出结果
 
二、判断题
 
闭包是内部函数对外部作用域的变量进行引用。(×)
当外部函数执行结束，其内部闭包引用的变量一定会立即释放。(×)
装饰器是一个变量。(×)
装饰器函数至少要接收一个函数。(√)
装饰器既能装饰带参数的函数，也能自己带参数。(√)
如果map函数传入的两个序列个数不同，那么个数多的序列会把多余的元素删除。(×)
map函数只能传递一个序列。(×)
map传入函数的参数个数必须跟序列的个数一样。(√)
filter传入的函数可以为None。(√)
filter函数智能对序列执行过滤操作。(×)
filter函数的返回值为字符串，它的序列类型一定是字符串。(√)
 
三、填空题
 
内部函数引用了外部函数作用域的变量，那么内部函数叫作闭包。
装饰器本质上是一个函数。
装饰器函数需要接收一个参数，这个参数表示被修饰的函数。
在函数定义的前面添加装饰器名和@符号，实现对函数的包装。
支持参数的装饰器函数需要再多一层内嵌函数。
map函数会根据提供的函数对制定的序列做映射。
map的两个序列的元素个数不一致，那么元素少的序列会以None补齐。
filter函数会对制定序列执行过滤操作。
filter传入的函数的返回值是布尔值。
reduce传入的是带有两个参数的函数，该函数不能为None。
 
四、简答题
 
 
请简述闭包满足的三个条件。
 (1)、存在于嵌套关系的函数中；
 (2)、嵌套的内部函数引用了外部函数的变量；
 (3)、嵌套的外部函数会将内部函数名作为返回值返回。
 
 
请简述装饰器的应用场景。
 (1)、引入日志；
 (2)、函数执行时间统计；
 (3)、执行函数前预备处理；
 (4)、执行函数后清理功能；
 (5)、权限校验；
 (6)、缓存。
 
 
请简述map、filter、reduce函数的作用。
 (1)、map函数会根据提供的函数对指定的序列做映射。
 (2)、filter函数会对指定序列执行过滤操作。
 (3)、reduce函数会对参数序列中的元素进行累积。
 
 
五、程序分析题
 
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。
 
代码一:
 
def funX():
     x = 5
     def funY():
          nonlocal x
          x += 1
          return x
     return funY
a = funX()
print(a())
print(a())
print(a())
 
  结果为：
   6
   7
   8
 
代码二:
 
def funX():
    x = 5
    def funY():
        nonlocal x
        x += 1
        return x
    return funY
return funY
a = funX
print(a()())
print(a()())
print(a()())
 
  结果为：
   6
   6
   6
 
第八章
 
一、单选题
 
 
打开一个已有文件，然后在文件末尾添加信息，正确的打开方式为(C)。
 A.‘r’ B.‘w’ C.‘a’ D.‘w+’
 
 
假设文件不存在，如果使用open方法打开文件会报错，那么该文件的打开方式是下列哪种模式?(A)
 A.‘r’ B.‘w’ C.‘a’ D.‘w+’
 
 
假设file是文本文件对象，下列选项中，哪个用于读取一行内容?(C)
 A.file.read() B.file.read(200)
 C.file.readline() D.file.readlines()
 
 
下列方法中，用于向文件中写出内容的是(B)。
 A.open B.write C.close D.read
 
 
下列荣方法中，用于获取当前目录的是(D)。
 A.open B.write C.Getcwd D.read
 
 
下列语句打开文件的位置应该在(D)。
 
 
f = open('itheima.txt','w')
 
    A.C盘根目录下
     B.D盘根目录下
     C.Python安装目录下
     D.与源文件在相同的目录下
 
若文本文件abc.txt中的内容如下：
 
abcdef
 
  阅读下面的程序：
 
file=open("abc.txt","r")
s=file.readline()
s1=list(s)
print(s1)
 
  上述程序执行的结果为(C)。
     A.[‘abcdef’]
     B.[‘abcdef\n’]
     C.[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’]
     D.[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,’\n’]
 
二、判断题
 
文件打开的默认方式是只读。(√)
打开一个可读写的文件，如果文件存在会被覆盖。(√)
使用write方法写入文件时，数据会追加到文件的末尾。(√)
实际开发中，文件或者文件夹操作都要用到os模块。(√)
read方法只能一次性读取文件中的所有数据。(×)
 
三、填空题
 
打开文件对文件进行读写，操作完成后应该调用close()方法关闭文件，以释放资源。
seek方法用于移动指针到制定位置，该方法中offset参数表示要偏移的字节数。
使用readlines方法把整个文件中的内容进行一次性读取，返回的是一个列表。
os模块中的mkdir方法用于创建文件夹。
在读写文件的过程中，tell方法可以获取当前的读写位置。
 
四、简答题
 
请简述文本文件和二进制文件的区别。
 文本文件存储的是常规字符串，由若干文本行组成，通常每行以换行符“\n”结尾。二进制文件把对象内容以字节串进行存储，无法用记事本或其他普通字处理软件直接进行编辑，无法被人类直接阅读和理解，需要使用专门的软件进行解码后读取、显示、修改或执行。
请简述读取文件的几种方法和区别。
 (1)、使用read(size)方法可以指定读取的字节数，或者读取整个文件；
 (2)、使用readlines方法可以把整个文件的内容进行一次性读取；
 (3)、使用readline方法一行一行读数据。
 
第九章
 
一、单选题
 
下列程序运行以后，会产生如下(B)异常。
 
a
 
    A.SyntaxError B.NameError C.IndexError D.KeyError
 
 
下列选项中，(C)是唯一不再运行时发生的异常。
 A.ZeroDivisionError B.NameError C.SyntaxError D.KeyError
 
 
当try语句中没有任何错误信息时，一定不会执行(D)语句。
 A.try B.else C.finaly D.except
 
 
在完整的异常语句中，语句出现的顺序正确的是(D)。
 A.try---->except----->else---->finally
 B.try---->else---->except----->finally
 C.try---->except----->finally—>else
 D.try----->else---->else----->except
 
 
下列选项中，用于触发异常的是(A)。
 A.try B.catch C.raise D.except
 
 
关于抛出异常的说法中，描述错误的是(C)。
 A.当raise指定异常的类名时，会隐式地创建异常类的实例
 B.显式地创建异常类实例，可以使用raise直接引发
 C.不带参数的raise语句，只能引发刚刚发生过的异常
 D.使用raise抛出异常时，无法指定描述信息
 
 
关于抛出异常的说法中，描述错误的是(D)。
 A.当raise指定异常的类名时，会隐式地创建异常类的实例
 B.显式地创建异常类实例，可以使用raise直接引发
 C.不带参数的raise语句，只能引发刚刚发生过的异常
 D.使用raise抛出异常时，无法指定描述信息
 
 
二、判断题
 
默认情况下，系统检测到错误后会终止程序。(√)
在使用异常时必须先导入exceptions模块。(×)
一个try语句只能对应一个except子句。(×)
如果except子句没有指明任何异常类型，则表示捕捉所有的异常。(√)
无论程序是否捕捉到异常，一定会执行finally语句。(√)
所有的except子句一定在else和finally的前面。(√)
 
三、填空题
 
Python中所有的异常类都是Exception子类。
当使用序列中不存在的索引时，会引发IndexError异常。
一个try语句智能对应一个finally子句。
当约束条件不满足时，assert语句会触发AssertionError异常。
如果在没有except的try语句中使用else语句，会引发语法错误。
 
四、简答题
 
请简述什么是异常。
 在Python中，程序在执行的过程中产生的错误称为异常，比如列表索引越界、打开不存在的文件等。
处理异常有哪些方式？
 try、except、else、finally语句。
 
第十章
 
一、单选题
 
 
下列关键字中，用来引入模块的是(C)。
 A.include B.from C.import D.continue
 
 
关于引入模块的方式，错误的是(D)。
 A.import math
 B.from fib import fibnacci
 C.form math import *
 D.from * import fib
 
 
关于__name__的说法，下列描述错误的是(A)。
 A.它是Python提供的一个方法
 B.每个模块内部都有一个__name__属性
 C.当它的值为’__main__‘时，表示模块自身在运行
 D.当它的值不为’__main__'时，表示模块被引用
 
 
二、判断题
 
Python解释器会优先查看默认的路径搜索模块的位置。(×)
每个Python文件就是一个模块。(√)
当__name__属性的值为__main__时，代表该模块自身在运行。(√)
包目录下必须有一个__init__py文件。(√)
外部模块都提供了自动安装的文件，直接双击安装就行。(×)
 
三、填空题
 
要调用random模块的randint函数，书写形式为random. randint。
每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
每个模块都有一个__name__属性，使程序块智能在模块自身运行时执行。
为了更好地组织模块，通常会把多个模块放在一个包中。
当程序中需要引入外部模块时，需要从外面下载并安装。
如果要搜索模块的路径，可以使用sys模块的path变量。
 
四、简答题
 
解释Python脚本程序的"__name__"的作用。
 每个Python脚本在运行时都有一个“__name__”属性。如果脚本作为模块被导入，则其“__name__”属性的值被自动设置为模块名；如果脚本独立运行，则其“__name__”属性值被自动设置为“__name__”属性。利用“__name__”属性即可控制Python程序的运行方式。
请简述Python解释器搜索模块位置的顺序。
 (1)、搜索当前目录，如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
 (2)、如果都找不到。Python会继续查看默认路径。
请简述模块的概念。
 在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块。
请简述导入模块的方法。
 在Python中用关键字import来引入某个模块：
 (1)、导入模块，使用“import 模块”引入；
 (2)、导入模块中的某个函数，使用“from 模块名 import 函数名”引入；
 (3)、导入模块的全部内容，使用“from 模块 import *”。
 
第十一章
 
一、单选题
 
 
关于面向过程和面向对象，下列说法错误的是(B)。
 A.面向过程和面向对象都是解决问题的一种思路
 B.面向过程是基于面向对象的
 C.面向过程强调的是解决问题的步骤
 D.面向对象强调的是解决问题的对象
 
 
关于类和对象的关系，下列描述正确的是(D)。
 A.类和面向对象的核心
 B.类是现实中事物的个体
 C.对象是根据类创建的，并且一个类只能对应一个对象
 D.对象描述的是现实的个体，它是类的实例
 
 
构造方法的作用是(C)。
 A.一般成员方法 B.类的初始化
 C.对象的初始化 D.对象的建立
 
 
构造方法是类的一个特殊方法，Python中它的名称为(C)。
 A.与类同名 B._construct C._init_ D. init
 
 
Python类中包含一个特殊的变量(A)，它表示当前对象自身，可以访问类的成员。
 A.self B.me C.this D.与类同名
 
 
下列选项中，符合类的命名规范的是(A)。
 A.HolidayResort
 B.Holiday Resort
 C.hoildayResort
 D.hoilidayresort
 
 
Python中用于释放类占用资源的方法是(B)。
 A.__init__
 B.__del__
 C._del
 D.delete
 
 
二、判断题
 
面向对象是基于面向过程的。(×)
通过类可以创建对象，有且只有一个对象实例。(×)
方法和杉树的格式是完全一样的。(×)
创建类的对象时，系统会自动调用构造方法进行初始化。(√)
创建完对象后，其属性的初始值是固定的，外界无法进行修改。(×)
使用del语句删除对象，可以手动释放它所占用的资源。(√)
 
三、填空题
 
在Python中，可以使用class关键字来声明一个类。
面向对象需要把问题划分多个独立的对象，然后调用其方法解决问题。
类的方法中必须有一个self参数，位于参数列表的开头。
Python提供了名称为__init__的构造方法，实现让类的对象完成初始化。
如果想修改属性的默认值，可以在构造方法中使用参数设置。
 
四、简答题
 
请简述self在类中的意义。
 不用实例化对象就能够在本类中访问自身的属性或方法。
类是由哪三个部分组成的？
 类名，属性，方法。
请简述构造方法和析构方法的作用。
 分别用于初始化对象的属性和释放类所占用的资源。
 
五、程序分析题
 
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。
 
代码一:
 
class Person:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return "我的名字是" + self.name
person = Person("小明")
print(person)
 
  结果为：我的名字是小明
 
代码二:
 
class Person:
    def __del__(self):
        print("--del--")
person = Person()
del person
print("--end--")
 
  结果为：
   --del–
   --end–
 
第十二章
 
一、选择题
 
 
Python中定义私有属性的方法是(D)。
 A. 使用private关键字 B.使用public关键字
 C.使用__XX__定义属性名 D.使用__XX定义属性名
 
 
下列选项中，不属于面向对象程序设计的三个特征的是(A)。
 A.抽象 B.封装 C. 继承 D.多态
 
 
以下C类继承A类和B类的格式中，正确的是(C)。
 A. class C A,B: B. class C（A:B） C.class C（A,B） D.class C A and B:
 
 
下列选项中，与class Person等价的是(C)。
 A. class Person（Object） B. class Person（Animal）
 C. class Person（object） D. class Person: object
 
 
下列关于类属性和示例属性的说法，描述正确的是(B)。
 A.类属性既可以显示定义，又能在方法中定义
 B.公有类属性可以通过类和类的实例访问
 C.通过类可以获取实例属性的值
 D.类的实例只能获取实例属性的值
 
 
下列选项中，用于标识为静态方法的是(C)。
 A.@classmethood B.@instancemethod
 C.@staticmethod D.@privatemethod
 
 
下列方法中，不可以使用类名访问的是(A)。
 A.实例方法 B.类方法 C.静态方法 D.以上3项都不符合
 
 
二、判断题
 
Python中没有任何关键字区分公有属性和私有属性。(√)
继承会在原有类的基础上产生新的类，这个新类就是父类。(×)
带有两个下划线的方法一定是私有方法。(√)
子类能继承父类的一切属性和方法。(×)
子类通过重写继承的方法，覆盖掉跟父类同名的方法。(√)
如果类属性和实例属性重名，对象有限访问类属性的值。(×)
使用类名获取到的值一定是类属性的值。(√)
静态方法中一定不能访问实例属性的值。(√)
 
三、填空题
 
如果属性名的前面加上了两个下划线，就表明它是私有属性。
在现有类基础上构建新类，新的类称作子类，现有的类称作父类。
父类的私有属性和方法是不能被子类继承的，更不能被子类访问。
Python语言既支持单继承，也支持多继承。
子类想按照自己的方式实现方法，需要重写从父类继承的方法。
子类通过super()可以成功地访问父类的成员。
位于类内部、方法外部的方法是类方法。
类方法是类拥有的方法，使用修饰器@classmethod来标识。
 
四、简答题
 
 
请简述如何保护类的属性。
 (1)、把属性定义为私有属性，即在属性名的前面加上两个下划线；
 (2)、添加用于设置或者获取属性值的两个方法供外界调用。
 
 
什么是继承？
 类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类的属性和方法。
 
 
请简述私有属性无法访问的原理。
 当在一个类的内部定义了私有方法或者私有属性的时候，Python在运行的过程中，把属性或者方法的名字进行了修改，即在属性或者方法名称的前面加上“_类名”，导致原有的方法无法访问到。
 
 
什么是多态？
 在Python中，多态是指在不考虑对象类型的情况下使用对象。
 
 
请简述实例方法、类方法和静态方法的区别。
 (1)、类方法需要使用@classmethod进行标识，该方法可以访问类属性，无法访问实例属性，可以通过类实例和类进行调用。
 (2)、静态方法使用@staticmethod进行标识，该方法无法访问实例属性和类属性，起到类似于函数的作用，使用类或者类实例进行调用。
 (3)、实例方法直接在类中使用def进行定义，可以访问其实例属性和类属性，使用类实例进行调用。
 (4)、如果要修改实例属性的值，就直接使用实例方法；如果要修改类属性的值，就直接使用类方法；如果是辅助功能，比如打印菜单，这时可以考虑使用静态方法，可以在不创建对象的前提下使用。
 
 
请简述Python中以下划线开头的变量名的特点。
 在Python中，以下划线开头的变量名有着特殊的含义，尤其是在类的定义中。用下划线作为变量前缀和后缀来表示类的特殊成员：
 (1)、_xx：这样的对象叫做保护变量，不能用from module import *导入，只有类对象和子类对象能够访问这些变量。
 (2)、__xx__：系统定义的特殊成员名字。
 (3)、__xx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员，但在对象外部可以通过“对象名.__类名__ xx”这样特殊的方式来访问。Python中没有纯粹的C++意义上的私有成员。
 
 
END
 
如果本文有什么写的不对的地方或有什么更好地建议和想法，欢迎在下方评论留言或私信我，大家一起进步学习！

这里以11g官方文档为例：




 

  今天来说说怎么快速的从官方文档中得到自己需要的知识。
 
 

  

 
 

  

 
 

  在线官方文档地址：
 
 

  http://docs.oracle.com/en/
 
 

  几乎囊括了 
  oracle
  各种产品的文档（
  oracle db12c
  的文档还没更新上来）
 
 

  

 
 

  离线下载地址：
 
 

  www.oracle.com
 
 

  这个不多说了
 
 

  

 
 

  以
  11g
  官方网文档为例：
 
 

  

 
 

  Getting started 页面：
 
 

  这里包括一些最基础的文档链接。
 
 

  

 
 

  

 
 

  

 
 

  

 
 

  Concept
  ，里面包括了
  Oracle
  数据库里面的一些基本概念和原理。比如说数据库的逻辑结构、物理结构、实例的构成、优化器、事务等知识都有描述。
 
 

  PDF
  短短
  460 
  页，楼主全部打印出来加实验一共看了半年…英语差伤不起啊。
 
 

  

 
 

  Reference
  ，里面包括了动态性能视图、数据字典、初始化参数等信息。如果有参数不知道什么意思，或者
   
  v$
  视图中的字段信息有些模糊，都可以从这里找到相应的描述。（
   
  HTML
  点进去之后最下面有个
  index
  ，
   
  ctrl+f
  查找比较快）还包含一些其他的比如说数据库的硬性限制、等待事件的名称、后台进程的描述等。
 
 

  

 
 

  SQL language Reference 
  ，这个文档中包括
   
  Oracle
  数据库中
  SQL
   
  语句的语法（
   
  plsql
  不包含在内）。比如说
  create table
  语法、函数、表达式都在这里有描述。如果你有什么
   
  sql
  语句的语法不知道怎么写，可以点开这个文档。
 
 

  

 
 

  Administrator’s Guide 
  ，这个文档中包含的内容就多了，几乎各种管理
   
  Oracle
  数据库的场景都在这里有描述。各种管理表、索引、表空间、
   
  redo
  等都可以在这里找到（在线传输表空间也在此文档中有描述）
 
 

  

 
 

  Performance tuning guide 
  ，里面包含优化相关的内容，介绍了优化的方法、数据库实例以及
   
  sql
  的优化。优化器相关的详细内容在这里有说明。
 
 

  

 
 

  

 
 

  

 
 

  

 
 

  Database Administration页面：
 
 

  

 
 

  主要的是 Administrator’s Guide已经在上面有所描述，这里列举了几个比较重要的文档。
 
 

  

 
 

  Net Services Reference 
  ，文档中说明了几个关于监听的重要文件说明，
   
  tnsnames.ora
  、
  listener.ora
   
  、
  sqlnet.ora
  等。有监听相关的疑问可以在这个文档中找到答案。
 
 

  

 
 

  Backup and Recovery User's Guide 
  ，文档中描述了
   
  rman
  的各种用法。（里面有一章节是写使用
   
  rman
  进行数据传输的，有兴趣大家可以看一下）
 
 

  

 
 

  Backup and Recovery Reference 
  ，主要描述了
   
  rman
  的语法。
 
 

  

 
 

  

 
 

  

 
 

   Application Development页面
 
 

  

 
 

  

 
 

  PL/SQL Packages and Types Reference 
  ，这个文档中包括各种
   
  oracle
  自建的包和函数的功能、参数描述。如果有不了解的包可以在这里找到，比如说常用的关于
   
  dbms_stats
  包的信息，包里面函数以及存储过程的作用、参数的说明、使用的范例就可以在这文档中找到。
 
 

  

 
 

  PL/SQL Language Reference 
  ，这个文档中说了
   
  plsql
  编程的基础概念、语法等东西。如果想要学习
   
  plsql
  编程，可以从这个文档看起。
 
 

  

 
 

  SQLJ Developer's Guide ，
  SQLJ
  ，在
   
  pub
  上听到了这个东西。具体还没深入了解，但是感觉还是比较先进好用的，当
   
  plsql
  没有办法完成任务的时候，可以使用
   
  java
  存储过程来解决，比如说想要获取主机目录下的文件列表。
   
  SQLJ
  提供了
  plsql
   
  和
  java
  集成的简便方法。提供一个比较简单的例子，可以在
   
  java
  存储过程中输入下面的代码：
 
 
  

      

       

           

            

                

                 for(int i = 0; i < list.length; i++)
                
                

                  17      {
                
                

                  18          element = list[i];
                
                

                  19          #sql { INSERT INTO DIR_LIST (FILENAME)
                
                

                  20                 VALUES (:element) };
                
                

                  21      }
                
            

              
            
           
       

         
       
      
 
 

  

 
 

  Workspace Manager Developer's Guide 
  ，里面写了关于
   
  oracle
  中
  workspace manager
   
  版本化的一些东西。
 
 

  

 
 

  

 
 

  installing and upgrading 页面：
 
 

  

 
 

  需要安装 oracle数据库的时候可以进Installing and upgrading链接里面，各种操作系统的安装文档都在这里。（建议部署环境的时候还是过一遍这里面的文档，网上的文章因为环境的差异可能在现有的硬件基础上出现这样那样的问题。看官方文档的方式是最快的部署方法）
 
 

  

 
 

  

 
 

  Grid Computing页面：
 
 

  

 
 

  包括 oracle grid infrastructure集群软件的各种文档。
 
 

  

 
 

  Automatic Storage Management Administrator's Guide ，
  asm
  的相关文档，有关于
   
  asm
  的疑问可以在这个文档中找到。
 
 

  

 
 

  Real Application Clusters Administration and Deployment Guide 
  ，包括
  RAC
  环境下的数据库管理和维护的内容。
 
 

  

 
 

  Clusterware Administration and Deployment Guide 
  ，主要写了集群软件的各种工具和命令。
 
 

  

 
 

  

 
 

  

 
 

  High Availability页面：
 
 

  

 
 

  里面包括各种高可用技术的文档。
 
 

  

 
 

  Data Guard Broker和Data Guard Concepts and Administration 
  ，不用说了这是关于
   
  Dataguard
  的文档。
 
 

  

 
 

  12c
  里面
  goldengate 
  全面接管 
  stream
  任务。有兴趣的也可以看看。
 
 

  

 
 

  

 
 

  Data Warehousing and Business Intelligence 页面：
 
 

  

 
 

  数据仓库和商业智能的相关技术。
 
 

  

 
 

  VLDB and Partitioning Guide ，
  very large database
   
  …
   
  partition
  和
  parallel
   
  相关的内容竟然在这里。
 
 

  

 
 

  Utilities
  ，不知道怎么用
  imp
  、
   
  expdp
  、
  sql*loader
   
  、外部表、
   
  dbv
  、
  adrci
   
  、
  logminer
  ，来这吧。
 
 

  

 
 

  

 
 

  

 
 

  Unstructured Data and Content Management 页面：
 
 

  

 
 

  非结构化数据相关。比如说 object type、xmltype 、oracle text等。
 
 

  

 
 

  SecureFiles and Large Objects Developer's Guide 
  ，讲了一些关于
   
  11g
  中存储
  lob
   
  字段使用的
   
  secure file
  技术的相关内容。
 
 

  

 
 

  

 
 

  Text Application Developer's Guide 和Text Reference
  ，全文索引相关的东西了。
 
 

  

 
 

  

 
 

  

 
 

  

 
 

  就写到这里吧，欢迎大家补充。
 
 

  

 
 

  

 
 

  

 
 

  如需转载，请注明出处：
 
 

  http://blog.csdn.net/renfengjun/article/details/18730615
 
 

    
 

在使用计算机软件的过程中，笔者经常会忘记之前下载的软件注册表之类奇奇怪怪的东西保存在什么位置了，又忘记了创建桌面快捷方式，这时该怎么办呢？
 
首先，我们看看常见的Windows+R命令，比如我想搜索Adobe，我们看一下搜索结果：
 
 由于我们不知道具体的文件名，因此无法通过该方式找到需要的文件。
 
那在文件资源管理器里面查询怎么样呢？我们直接在C盘中查询，看一下结果：
 
 这样确实可以查到一大串的结果，但是实在是好慢啊，对于笔者这样没有耐心的人来说实在是一种折磨。那么，我们可不可以写一个程序实现自动查询呢？
 
答案当然是肯定的。
 
代码如下：
 
import os

path = 'C:'
filename = 'Adobe'
result = []

# 将查询结果直接输出
def find_file():
    i = 0
    for root, lists, files in os.walk(path):
        for file in files:
            if filename in file:
                i = i + 1
                write = os.path.join(root, file)
                print('%d %s' % (i, write))
                result.append(write)

# 将查询结果保存在文本文档中
def find_file_and_putin_txt():
    i = 0
    open('E:\Python\\find_file.txt', mode='w').close()
    for root, lists, files in os.walk(path):
        for file in files:
            if filename in file:
                i = i + 1
                write = os.path.join(root, file)

                file_txt = open('C:\User\\find_file.txt', mode='a+')
                file_txt.write('%d %s \n' % (i, write))
                result.append(write)


if __name__ == '__main__':
    find_file()
    find_file_and_putin_txt()
 
我们运行这个程序，很快，就可以找到所有名称包含Adobe的文件了。