Dave Python 练习二

转载
mb61c186c579369 2022-01-05 17:04:02
#coding=gbk

################Part 1: 语法和语句##################
#Python 语句中有一些基本规则和特殊字符：
#井号(#)表示之后的字符为 Python 注释
#换行 (\n) 是标准的行分隔符（通常一个语句一行）
#反斜线 ( \ ) 继续上一行
#分号 ( ; )将两个语句连接在一行中
#冒号 ( : ) 将代码块的头和体分开
#语句（代码块）用缩进块的方式体现
#不同的缩进深度分隔不同的代码块
#Python 文件以模块的形式组织

#Python 语句，一般使用换行分隔，也就是说一行一个语句。一行过长的语句可以使用反斜杠( \ ) 分解成几行
#if(10>1)and\
#(10>5):
#    print('this is true!')
#-->this is true!

#注意：有两种例外情况一个语句不使用反斜线也可以跨行。在使用闭合操作符时，单一语句可以跨多行，
#例如：在含有小括号、中括号、花括号时可以多行书写。另外就是三引号包括下的字符串也可以跨行书写

#print('''the import thing in life is to have a great 
#aim and the determination to attaion it!''')
#-->the import thing in life is to have a great 
#aim and the determination to attaion it!

#myStr='''the import thing in life is to have a great 
#aim and the determination to attaion it!'''
#print(myStr)
#-->the import thing in life is to have a great 
#aim and the determination to attaion it!

#多个语句构成代码组(:)：
#缩进相同的一组语句构成一个代码块，我们称之代码组。像if、while、def 和class 这样
#的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
#我们将首行及后面的代码组称为一个子句(clause)。

#代码组由不同的缩进分隔
#Python 使用缩进来分隔代码组。代码的层次关系是通过同样深度的空格或制表符缩进体现的。
#同一代码组的代码行必须严格左对齐（左边有同样多的空格或同样多的制表符），
#如果不严格遵守这个规则，同一组的代码就可能被当成另一个组，甚至会导致语法错误。

#核心风格：缩进四个空格宽度，避免使用制表符
#避免使用制表符是因为不同的文本编辑器中制表符代表的空白宽度不一，如果你的代码要跨平台应用，或者会被不同的编辑器读写，建议不要使用制表符

#同一行书写多个语句(;)
#分号( ; )允许你将多个语句写在同一行上，语句之间用分号隔开，而这些语句也不能在这行开始一个新的代码块。
#同一行上书写多个语句会大大降低代码的可读性，Python 虽然允许但不提倡这么做。


#模块
#每一个Python 脚本文件都可以被当成是一个模块。模块以磁盘文件的形式存在。当一个模
#块变得过大，并且驱动了太多功能的话，就应该考虑拆一些代码出来另外建一个模块。模块里
#的代码可以是一段直接执行的脚本，也可以是一堆类似库函数的代码，从而可以被别的模块导
#入(import)调用。模块可以包含直接运行的代码块、类定义、函数定义或这几者的组合。


################Part 2: 变量赋值 ##################

#赋值并不是直接将一个值赋给一个变量，在Python 语言中，对象是通过引用传递的。在赋值时，不管这个对象是新创建的，还是一个已经存在的，都是将该对象的引用（并不是值）赋值给变量。

#从Python 2.0 开始， 等号可以和一个算术运算符组合在一起， 将计算结果重新赋值给左边的变量，这被称为增量赋值。
#x=x+1
#-->x+=1

#+= -= *= /= %= **= <<= >>= &= ^= |=
#Python 不支持类似 x++ 或 --x 这样的前置/后置自增/自减运算。

#多重赋值
#x=y=z=1
#print(x,y,z)
#-->1 1 1
#一个值为1 的整数对象被创建，该对象的同一个引用被赋值给 x、y 和z

#“多元”赋值
#x,y,z=1,2,'Dave come from anqing!'
#print(x,y,z)
#-->1 2 Dave come from anqing!

#交换2个变量的值
#x,y=1,2
#print('first:',x,y)
#x,y=y,x
#print('second:',x,y)
#-->
#first: 1 2
#second: 2 1


################Part 3: 标识符 ##################
#标识符是电脑语言中允许作为名字的有效字符串集合。其中，有一部分是关键字，构成语
#言的标识符。这样的标识符是不能做它用的标识符的，否则会引起语法错误（SyntaxError 异常）。

#Python 还有称为built-in 标识符集合，虽然它们不是保留字，但是不推荐使用这些特别的名字.

#合法的Python 标识符
#Python 标识符字符串规则和其他大部分用C 编写的高级语言相似：
#    第一个字符必须是字母或下划线（_）
#    剩下的字符可以是字母和数字或下划线
#    大小写敏感
#标识符不能以数字开头；除了下划线，其他的符号都不允许使用.

#内建
#Python 还有可以在任何一级代码使用的“内建”的名字集合，这些名字可以由解释器设置或使用。虽然built-in 不是关键字，但是应该把它当作“系统保留字”，
#不做他用。然而，有些情况要求覆盖（也就是：重定义，替换）它们。Python 不支持重载标识符，所以任何时刻都只有一个名字绑定。
#built-in 是__builtins__模块的成员，在程序开始或在交互解释器中给出>>>提示之前，由解释器自动导入的。
#把它们看成适用在任何一级Python 代码的全局变量。

#专用下划线标识符
#Python 用下划线作为变量前缀和后缀指定特殊变量。Python 中下划线的特殊用法总结：
#    _xxx 不用'from module import *'导入
#    __xxx__系统定义名字
#    __xxx 类中的私有变量名

#核心风格：避免用下划线作为变量名的开始
#因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避
#免用下划线作为变量名的开始。一般来讲，变量名_xxx 被看作是“私有的”，在模块或类外不
#可以使用。当变量是私有的时候，用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对
#Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

#文档
#Python 还提供了一个机制，可以通过__doc__特别变量，动态获得文档字串。在模块，类
#声明，或函数声明中第一个没有赋值的字符串可以用属性obj.__doc__来进行访问，其中obj
#是一个模块，类，或函数的名字。这在运行时刻也可以运行。

#模块结构和布局
#用模块来合理组织你的Python 代码是简单又自然的方法。你应该建立一种统一且容易阅读
#的结构，并将它应用到每一个文件中去。下面就是一种非常合理的布局：
# (1) 起始行(Unix)
# (2) 模块文档
# (3) 模块导入
# (4) 变量定义
# (5) 类定义
# (6) 函数定义
# (7) 主程序

#(1) 起始行
#通常只有在类Unix 环境下才使用起始行，有起始行就能够仅输入脚本名字来执行脚本，无需直接调用解释器。
#(2)模块文档
#简要介绍模块的功能及重要全局变量的含义，模块外可通过 module.__doc__ 访问这些内容。
#(3)模块导入
#导入当前模块的代码需要的所有模块；每个模块仅导入一次（当前模块被加载时）；函数
#内部的模块导入代码不会被执行， 除非该函数正在执行。
#(4)变量定义
#这里定义的变量为全局变量，本模块中的所有函数都可直接使用。从好的编程风格角度说，
#除非必须，否则就要尽量使用局部变量代替全局变量，如果坚持这样做，你的代码就不但容易
#维护，而且还可以提高性能并节省内存。
#(5)类定义语句
#所有的类都需要在这里定义。当模块被导入时class 语句会被执行, 类也就会被定义。类的文档变量是class.__doc__。
#(6)函数定义语句
#此处定义的函数可以通过module.function()在外部被访问到，当模块被导入时 def 语句
#会被执行， 函数也就都会定义好，函数的文档变量是function.__doc__。
#(7) 主程序
#无论这个模块是被别的模块导入还是作为脚本直接执行，都会执行这部分代码。通常这里不会有太多功能性代码，而是根据执行的模式调用不同的函数。

#推荐代码风格：主程序调用main()函数
#if __name__==main():
#    dave()
#    
#检查 __name__ 变量的值然后再执行相应的调用。主程序中的代码通常包括变量赋值， 类定义和函数定义，
#随后检查__name__来决定是否调用另一个函数（通常调用main()函数）来完成该模块的功能。主程序通常都是做这些事。
#不管用什么名字，强调一点那就是：这儿是放置测试代码的好地方。

#很多项目都是一个主程序，由它导入所有需要的模块。所以请记住，绝大部分的模块创建
#的目的是为了被别人调用而不是作为独立执行的脚本。我们也很可能创建一个Python 库风格的
#模块，这种模块的创建目的就是为了被其他模块调用。总之，只有一个模块，也就是包含主程
#序的模块会被直接执行，或由用户通过命令行执行，或作为批处理执行， 或由Unix cron 任务
#定时执行，或通过Web 服务器调用，或通过GUI 执行。

#注意：所有的模块都有能力来执行代码。最高级别的Python 语句－－也就是说， 那些没有缩进的代码行在模块被导入时就会执行， 不管是不是真的需要执行。
#由于有这样一个“特性”，比较安全的写代码的方式就是除了那些真正需要执行的代码以外， 几乎所有的功能代码都在函数当中。再说一遍， 通常只有主程序模块中有大量的顶级可执行代码，
#所有其它被导入的模块只应该有很少的顶级执行代码，所有的功能代码都应该封装在函数或类当中。


#核心笔记：__name__ 指示模块应如何被加载
#由于主程序代码无论模块是被导入还是被直接执行都会运行， 我们必须知道模块如何决定运行方向。
#一个应用程序可能需要导入另一个应用程序的一个模块，以便重用一些有用的代码。这种情况下，你只想访问那些位于其
#它应用程序中的代码，而不是想运行那个应用程序。
#因此一个问题出现了，“Python 是否有一种方法能在运行时检测该模块是被导入还是被直接执行呢？” 答案： __name__ 系统变量。
#
#如果模块是被导入， __name__ 的值为模块名字
#如果模块是被直接执行， __name__ 的值为 '__main__'


################Part 4: 内存管理 ##################

#变量定义
#大多数编译型语言，变量在使用前必须先声明，其中的 C 语言更加苛刻：变量声明必须位于代码块最开始，且在任何其他语句之前。
#在Python 中，无需此类显式变量声明语句，变量在第一次被赋值时自动声明。和其他大多数语言一样，变量只有被创建和赋值后才能被使用。


#动态类型
#Python 中不但变量名无需事先声明，而且也无需类型声明。Python 语言中，对象的类型和内存占用都是运行时确定的。
#尽管代码被编译成字节码，Python 仍然是一种解释型语言。在创建－－也就是赋值时，解释器会根据语法和右侧的操作数来决定新对象的类型。
#在对象创建后，一个该对象的应用会被赋值给左侧的变量。

#内存分配
#作为一个负责任的程序员，我们知道在为变量分配内存时，是在借用系统资源，在用完之后， 应该释放借用的系统资源。
#Python 解释器承担了内存管理的复杂任务， 这大大简化了应用程序的编写。你只需要关心你要解决的问题，至于底层的事情放心交给Python 解释器去做就行了。


#引用计数
#要保持追踪内存中的对象， Python 使用了引用计数这一简单技术。也就是说Python 内部
#记录着所有使用中的对象各有多少引用。一个内部跟踪变量，称为一个引用计数器。至于每个对象各有多少个引用， 简称引用计数。
#当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的
#引用计数变为0 时， 它被垃圾回收。（严格来说这不是100%正确，不过现阶段你可以就这么认为）

#增加引用计数
#当对象被创建并（将其引用）赋值给变量时，该对象的引用计数就被设置为1。
#x = 3.14
#y = x
#语句 x=3.14 创建了一个浮点数对象并将其引用赋值给 x。 x 是第一个引用， 因此，该
#对象的引用计数被设置为1。语句 y=x 创建了一个指向同一对象的别名 y（参阅图3－2）。事
#实上并没有为Y 创建一个新对象， 而是该对象的引用计数增加了1 次（变成了2）。这是对象
#引用计数增加的方式之一。还有一些其它的方式也能增加对象的引用计数， 比如该对象作为参
#数被函数调用或这个对象被加入到某个容器对象当中时。

#总之，对象的引用计数在
#对象被创建
#x = 3.14
#或另外的别名被创建
#y = x
#或被作为参数传递给函数（新的本地引用）
#foobar(x)
#或成为容器对象的一个元素
#myList = [123, x, 'xyz']

#减少引用计数
#当对象的引用被销毁时，引用计数会减小。最明显的例子就是当引用离开其作用范围时，
#这种情况最经常出现在函数运行结束时，所有局部变量都被自动销毁，对象的引用计数也就随
#之减少。当变量被赋值给另外一个对象时，原对象的引用计数也会自动减1：

#foo = 'xyz'
#bar = foo
#foo = 123
#当字符串对象"xyz"被创建并赋值给foo 时， 它的引用计数是1. 当增加了一个别名 bar时， 引用计数变成了2. 
#不过当foo 被重新赋值给整数对象123 时， xyz 对象的引用计数自动减1，又重新变成了1.

#其它造成对象的引用计数减少的方式包括使用 del 语句删除一个变量（参阅下一节）， 或
#者当一个对象被移出一个窗口对象时（或该容器对象本身的引用计数变成了0 时）。 
#总结一下，一个对象的引用计数在以下情况会减少：

#一个本地引用离开了其作用范围。比如 foobar()(参见上一下例子）函数结束时。
#对象的别名被显式的销毁。
#del y # or del x
#对象的一个别名被赋值给其它的对象
#x = 123
#对象被从一个窗口对象中移除
#myList.remove(x)
#窗口对象本身被销毁
#del myList # or goes out-of-scope


#del 语句
#Del 语句会删除对象的一个引用，它的语法是：
#del obj1[, obj2[,... objN]]
#例如，在上例中执行del y 会产生两个结果：
#    从现在的名字空间中删除 y
#    x 的引用计数减一
#引申一步， 执行 del x 会删除该对象的最后一个引用， 也就是该对象的引用计数会减为
#0， 这会导致该对象从此“无法访问”或“无法抵达”。 从此刻起， 该对象就成为垃圾回收
#机制的回收对象。 注意任何追踪或调试程序会给一个对象增加一个额外的引用， 这会推迟该
#对象被回收的时间。


#垃圾收集
#不再被使用的内存会被一种称为垃圾收集的机制释放。象上面说的， 虽然解释器跟踪对象
#的引用计数， 但垃圾收集器负责释放内存。垃圾收集器是一块独立代码， 它用来寻找引用计
#数为0 的对象。它也负责检查那些虽然引用计数大于0 但也应该被销毁的对象。 特定情形会导
#致循环引用。
#一个循环引用发生在当你有至少两个对象互相引用时， 也就是说所有的引用都消失时， 这
#些引用仍然存在， 这说明只靠引用计数是不够的。Python 的垃圾收集器实际上是一个引用计
#数器和一个循环垃圾收集器。 当一个对象的引用计数变为0，解释器会暂停，释放掉这个对象
#和仅有这个对象可访问（可到达）的其它对象。作为引用计数的补充， 垃圾收集器也会留心被
#分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下
#来， 试图清理所有未引用的循环。




#核心技巧：使用局部变量替换模块变量
#如： 
#import os
#ls = os.linesep
#
#类似 os.linesep 这样的名字需要解释器做两次查询：
#（1）查找os 以确认它是一个模块，
#（2）在这个模块中查找 linesep 变量。
#因为模块也是全局变量， 我们多消耗了系统资源。如果你在一个函数中类似这样频繁使用一个属性，
#建议你为该属性取一个本地变量别名。 变量查找速度将会快很多－－在查找全局变量之前， 总是先查找本地变量。 
#这也是一个让你的程序跑的更快的技巧： 将经常用到的模块属性替换为一个本地引用。代码跑得更快，而也不用
#老是敲那么长的变量名了。