【python基础】——python的小知识点

脚本语言的第一行,目的就是指出,你想要你的这个文件中的代码用什么可执行程序去运行它,就这么简单。

#!/usr/bin/python : 是告诉操作系统执行这个脚本的时候,调用 /usr/bin 下的 python 解释器;

#!/usr/bin/env python(推荐): 这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候,首先会到 env 设置里查找 python 的安装路径,再调用对应路径下的解释器程序完成操作。

#!/usr/bin/python 相当于写死了python路径;

#!/usr/bin/env python 会去环境设置寻找 python 目录,推荐这种写法

 

① python 编码格式:

· Python中默认的编码格式是 ASCII 格式,在没修改编码格式时无法正确打印汉字,所以在读取中文时会报错。

· 解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了

1、所有文件的编码格式都由你当下使用的编辑器决定的!!在windows中编辑的文本放在浏览器解析显示的时候,有时乱码,有时又正常,这是由于windows中很多文本编辑器默认使用和操作系统一致的编码格式。
所以在文本存储前,一定要搞清楚我们用的是utf-8还是gbk!!!
而当你使用Python的 open( ) 函数时,是内存中的进程与磁盘的交互,而这个交互过程中的编码格式则是使用操作系统的默认编码(Linux为utf-8,windows为gbk)

2、相信学Python的同学们经常会听到,python3 的默认编码是utf-8。而有的时候,又有人说python3 的默认编码是unicode,那么是不是会有人跟我初学时候一样傻傻分不清楚这两者的关系呢?

  • 实际上unicode就是一个字符集,一个字符与数字一一对应的映射关系,因为它一律以2个字节编码(或者也有4个字节的,这里不讨论),所以占用空间会大一些,一般只用于内存中的编码使用。
  • 而 utf-8 是为了实现unicode 的传输和存储的。因为它可变长,存英文时候可以节省大量存储空间。传输时候也节省流量,所以更加 “ international ”~

所以说,上述两种说法没有歧义,进程在内存中的表现是“ unicode ”的编码;当python3编译器读取磁盘上的.py文件时,是默认使用“utf-8”的;当进程中出现open(), write() 这样的存储代码时,需要与磁盘进行存储交互时,则是默认使用操作系统的默认编码。

 

· python 编程尤其需要注意代码缩进(tab键),否则会出错

· 占位符 string %s long %d 浮点 %f 例如: print("字符串:%s,数值类型:%d,保留两位有效数值的浮点型:%.2f"%("字符串",10,12.22))

② python 变量组成:

· 在 Python 里,标识符由字母、数字、下划线组成。

· 在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。

· Python 中的标识符是区分大小写的。

· 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入;

· 以双下划线开头的 __foo 代表类的私有成员;以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数

③ python 数据类型

· python 基本数据类型 string number list dictionary tuple 五大数据类型

· 1.Number 支持 int long float complex 四种数据类型

· 2.String 可以根据下标截取字符串,下标从0开始 例如 : str[1,3]

· 3.list 用 [ ] 标识。根据下标取值 ,截取。两个列表可以相加等操作,list 是有序存储的

· 4.tuple 元组 用 ( ) 标识,与列表list 一样,唯一的区别是 元组不允许二次赋值

· 5.dictionary 字典,以key : value 键值对存储,不允许有重复的key,dictionary 是无序集合

· 6 可以使用isinstance(param,type) 来判断该变量是否是某一类型

④ 条件语句

· Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块

· python 中规定 任何非0 和非空(null)都为true,0 和 null 都为false

⑤ 循环语句

· while循环、for 循环:在循环中使用 break 跳出循环,continue 终止当前循环,继续下一次循环,pass没有实际意义,仅保持程序的完整性

⑥ 时间和日期

· Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间

· 获取当前时间戳:time.time()

· 获取时间元组:time.loacltime(time.time()),该结果返回的是一个时间元组,

· time.asctime(time.loacltime(time.time())) 返回 可视时间 如:Thu Apr 7 10:05:21 2016

· 时间格式化:time.strftime(format,t)

time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ==>2016-03-20 11:45:39 (标准的时间格式)

time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) ==> Sat Mar 28 22:24:24 2016

time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))==> 将 时间a 转换成时间戳

· calendar:此模块所有相关函数都是日历相关

⑦ python函数

· 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()

· 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数

· 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明

· 函数内容以冒号起始,并且缩进

·return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None

·例如:

def functionname(param):

"函数描述"

.....# function body

return

·函数调用 模块名.方法名(param)

·参数传递:

1.不可变类型参数 ,传递的是参数的值,并不影响参数本身

2.可变类型参数,类似于引用传递,会改变参数本身

·参数类型

1.必备参数 :必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

2.关键字参数 :使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值

3.默认参数:调用函数时,缺省参数的值如果没有传入,则被认为是默认值

4.不定长参数:函数比处理比声明时候更多的参数,不定长参数 需要在变量名前 加 * 该变量会存储所有未命名的变量 例如 : def functionName(arg1, *arg2) : 此时arg2 就是不定长参数

 

· 匿名函数

1. 匿名函数是由 lambda 来定义, lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去,lambda函数拥有自己的命名空间,且不能访问自有参数列

表之外或全局命名空间里的参数 例如 :lambda [arg1 [,arg2,.....argn]]:expression

· return语句

1.语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None

· 变量的作用域

1.全局变量:定义函数外的变量拥有全局作用域

2.局部变量:函数内部的变量拥有局部作用域

⑧ 模块

·Python 模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。使用 import 关键字引入其他模块 例如 : import test. 导入了test 模块

·from flib import [name ] 从从模块中导入一个指定的部分到当前命名空间中,from flib import * 把一个模块的所有内容全都导入到当前的命名空间

·python的搜索路径 当前目录 -->环境变量配置的目录下--->查看默认路径

·dir() 函数是一个排好序的字符串列表,内容是一个模块里定义过的名字,返回的是列表容纳了在一个模块里定义的所有模块,变量和函数 例如:dir(math) 返回math 中定义的模块 、变量 、函数

·globals() 和 locals() 函数

locals() 在函数内部调用,返回的是所有能在该函数里访问的命名

globals() 在函数内部调用,返回的是所有在该函数里能访问的全局名字

两个函数返回的都是dictionary类型,所以可以用keys() 来取值

· reload()函数,当模块背导入到一个脚本之后,模块顶层的代码只会执行一次,如果需要重新执行该代码需要调用reload() 函数

· python 的包: python的包是一个分层次的目录结构,它定义了一个由模块以及子包,和子包下的子包构成的应用环境

· 系统模块sys

import sys;导入系统模块

sys.argv 是一个 list,包含所有的命令行参数.

sys.stdout sys.stdin sys.stderr 分别表示标准输入输出,错误输出的文件对象.

sys.stdin.readline() 从标准输入读一行 sys.stdout.write("a") 屏幕输出a

sys.exit(exit_code) 退出程序

sys.modules 是一个dictionary,表示系统中所有可用的module

sys.platform 得到运行的操作系统环境

sys.path 是一个list,指明所有查找module,package的路径.

⑨ I/O模块

· 读取键入的值:input() 和 raw_input() 方法用于接受键盘输入的值,区别在于 input()可以接受一个python表达式并运算结果返回

· 文件读写

使用内置函数open(file_name [, access_mode][, buffering),file_name:你要打开的文件名称,access_mode:打开文件模式 默认为只读(r),buffering 为0时没有寄存,设置为1的时候要寄存,当

值大于1的时候,就是设置寄存缓冲区内存大小

· File 的属性

file.closed 如果为true 文件已关闭,false 文件未关闭

file.model 返回打开的文件访问的模式

file.name 返回文件名

file.softspace 如果以print方式输出后,必须跟一个空格,则返回false ,否则返回true

·File 的方法

flie.close() 刷新缓冲取内所有未写入的信息,并关闭该文件,后续不能在写入

file.write() 可以将任何字符串写入一个已经打开的文件,pyton可以写入 二进制数据,该方法不会在末尾添加“\n” 换行符

file.read()从一个打开的文件中读取一个字符串也可以是 二进制数据

file.tell() 返回在文件内当前的位置

file.flush()刷新文件内部缓冲,直接把内部缓冲区的数据立即写入文件,而不是被动的等待输出缓冲区写入

注意:在 write 内容后,直接 read 文件输出会为空,是因为指针已经在内容末尾,两种解决方案,一:先close文件,再open后在读取,二:可以设置指针回到文件开头的位置再读取read

seek(offset [,from]) Offset变量表示要移动的字节数 ,from 指定开始移动字节的开始位置 from =0 一文件开头作为偏移参考位置,如果为1 使用当前位置为偏移参考位置,如果为2一文件的

末尾作为偏移标准

os.rename(current_file_name,new_file_name)重命名,current_file_name 当前文件名,new_file_name 新的文件名称

os.remove(file_name) 删除文件 file_name :要删除的文件名称

os.mkdir(folder_name)创建文件夹

os.chdir(flie_path) 改变当前目录

os.getcwd()方法显示当前的工作目录。

os.rmdir() 删除目录,删除前它的所遇内容应该先被删除

 

⑩异常处理

第一种方式:

try:

#要执行的语句

except :

#异常处理

else :

#不出现异常的处理

第二种方式:

try :

#要执行的语句

finally

#无论是否出现异常都要执行的代码

raise/expect

#异常处理

raise 类似与java中throw 抛出异常

面向对象

Class :用来描述具有相同属性和方法的对象集合,它定义了该集合中每个对象所共有的属性个方法,对象是类的实例

例如:

class myClass:

 

def __init__(self,name,age):

#方法体

def function(self) :

#方法体

其中 __init__()该 方法比较特殊,类似于类的构造函数,在该类中所有的方法入参必须传入 self 代表类的实例,self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数。

 

访问类属性:

getattr(obj,name) 访问对象属性

hasattr(obj,name) 检查是否存在一个属性

setattr(obj,name,value) 设置一个属性,如果该属性不存在会创建一个新属性

delattr(obj,name) 删除属性

python 内置类属性

__dict__:类的属性,(包含一个字典,由类的数据属性组成)

__doc__:类的文档字符串

__name__:类名

__module__:类定义所在的模块

__bases__:类的所有父类构成元素

python 对象销毁

当对象被创建时,就会创建一个引用计数器,当引用计数器为0 的时候它被垃圾回收,但回收不是立即的,由解释器在适当的时机将垃圾对象占用的内存回收,

循环垃圾收集器配合引用计数器实现垃圾回收

类的继承

语法:class className (baseName)

特点:

在继承中基类的 __init__()方法不自动调用,它需要在派生的基类中亲自专门调用

在调用基类的方法时,需要加上基类的类名为前缀,且需要带上self参数变量,区别在类中调用普通函数的时候不需要参数self

python总是先在本类中查找调用的方法,如果在本类中找不到,才回去基类中逐个查找

如果继承元组中列了一个以上的类,那么他就叫做 "多重继承"

issubclass()判断一个类是另一个类的子类或者孙子类 ==> issubclass(sub,sup)

isinstance(obj ,class) 如果obj是calss的实例对象或者是class子类的实例对象则返回true

__两个下划线开头的属性是私有属性,不能在类外部直接访问或被使用

_ 一个下划线开头的变量是受保护的属性,只能本身或者其子类可以访问

__foo__头尾双下划线定义的是特殊方法,一般是系统定义的方法


11、Tips
11、Tips
 1)help('模块名'): 是看模块说明的

2) 查位置:
        import sys
        sys.modules['模块名']
 其实全都在 .../lib/

2) 查位置:
        import sys
        sys.modules['模块名']
 其实全都在 .../lib/
 
 
12、Python之%s%d%f
 
  1. string="hello"    
  2.     
  3. #%s打印时结果是hello    
  4. print "string=%s" % string      # output: string=hello    
  5.     
  6. #%2s意思是字符串长度为2,当原字符串的长度超过2时,按原长度打印,所以%2s的打印结果还是hello    
  7. print "string=%2s" % string     # output: string=hello    
  8.     
  9. #%7s意思是字符串长度为7,当原字符串的长度小于7时,在原字符串左侧补空格,    
  10. #所以%7s的打印结果是  hello    
  11. print "string=%7s" % string     # output: string=  hello    
  12.     
  13. #%-7s意思是字符串长度为7,当原字符串的长度小于7时,在原字符串右侧补空格,    
  14. #所以%-7s的打印结果是  hello    
  15. print "string=%-7s!" % string     # output: string=hello  !    
  16.     
  17. #%.2s意思是截取字符串的前2个字符,所以%.2s的打印结果是he    
  18. print "string=%.2s" % string    # output: string=he    
  19.     
  20. #%.7s意思是截取字符串的前7个字符,当原字符串长度小于7时,即是字符串本身,    
  21. #所以%.7s的打印结果是hello    
  22. print "string=%.7s" % string    # output: string=hello    
  23.     
  24. #%a.bs这种格式是上面两种格式的综合,首先根据小数点后面的数b截取字符串,    
  25. #当截取的字符串长度小于a时,还需要在其左侧补空格    
  26. print "string=%7.2s" % string   # output: string=     he    
  27. print "string=%2.7s" % string   # output: string=hello    
  28. print "string=%10.7s" % string  # output: string=     hello    
  29.     
  30. #还可以用%*.*s来表示精度,两个*的值分别在后面小括号的前两位数值指定    
  31. print "string=%*.*s" % (7,2,string)      # output: string=     he    
%d 整型
 
  1. num=14    
  2.     
  3. #%d打印时结果是14    
  4. print "num=%d" % num            # output: num=14    
  5.     
  6. #%1d意思是打印结果为1位整数,当整数的位数超过1位时,按整数原值打印,所以%1d的打印结果还是14    
  7. print "num=%1d" % num           # output: num=14    
  8.     
  9. #%3d意思是打印结果为3位整数,当整数的位数不够3位时,在整数左侧补空格,所以%3d的打印结果是 14    
  10. print "num=%3d" % num           # output: num= 14    
  11.     
  12. #%-3d意思是打印结果为3位整数,当整数的位数不够3位时,在整数右侧补空格,所以%3d的打印结果是14_    
  13. print "num=%-3d" % num          # output: num=14_    
  14.     
  15. #%05d意思是打印结果为5位整数,当整数的位数不够5位时,在整数左侧补0,所以%05d的打印结果是00014    
  16. print "num=%05d" % num          # output: num=00014    
  17.     
  18. #%.3d小数点后面的3意思是打印结果为3位整数,    
  19. #当整数的位数不够3位时,在整数左侧补0,所以%.3d的打印结果是014    
  20. print "num=%.3d" % num          # output: num=014    
  21.     
  22. #%.0003d小数点后面的0003和3一样,都表示3,意思是打印结果为3位整数,    
  23. #当整数的位数不够3位时,在整数左侧补0,所以%.3d的打印结果还是014    
  24. print "num=%.0003d" % num       # output: num=014    
  25.     
  26. #%5.3d是两种补齐方式的综合,当整数的位数不够3时,先在左侧补0,还是不够5位时,再在左侧补空格,    
  27. #规则就是补0优先,最终的长度选数值较大的那个,所以%5.3d的打印结果还是  014    
  28. print "num=%5.3d" % num         # output: num=  014    
  29.     
  30. #%05.3d是两种补齐方式的综合,当整数的位数不够3时,先在左侧补0,还是不够5位时,    
  31. #由于是05,再在左侧补0,最终的长度选数值较大的那个,所以%05.3d的打印结果还是00014    
  32. print "num=%05.3d" % num        # output: num=00014    
  33.     
  34. #还可以用%*.*d来表示精度,两个*的值分别在后面小括号的前两位数值指定    
  35. #如下,不过这种方式04就失去补0的功能,只能补空格,只有小数点后面的3才能补0    
  36. print "num=%*.*d" % (04,3,num)  # output: num= 014 

%f 浮点型

 
  1. import math    
  2.     
  3. #%a.bf,a表示浮点数的打印长度,b表示浮点数小数点后面的精度    
  4.     
  5. #只是%f时表示原值,默认是小数点后5位数    
  6. print "PI=%f" % math.pi             # output: PI=3.141593    
  7.     
  8. #只是%9f时,表示打印长度9位数,小数点也占一位,不够左侧补空格    
  9. print "PI=%9f" % math.pi            # output: PI=_3.141593    
  10.     
  11. #只有.没有后面的数字时,表示去掉小数输出整数,03表示不够3位数左侧补0    
  12. print "PI=%03.f" % math.pi          # output: PI=003    
  13.     
  14. #%6.3f表示小数点后面精确到3位,总长度6位数,包括小数点,不够左侧补空格    
  15. print "PI=%6.3f" % math.pi          # output: PI=_3.142    
  16.     
  17. #%-6.3f表示小数点后面精确到3位,总长度6位数,包括小数点,不够右侧补空格    
  18. print "PI=%-6.3f" % math.pi         # output: PI=3.142_    
  19.     
  20. #还可以用%*.*f来表示精度,两个*的值分别在后面小括号的前两位数值指定    
  21. #如下,不过这种方式06就失去补0的功能,只能补空格    
  22. print "PI=%*.*f" % (06,3,math.pi)   # output: PI=_3.142  
 

Python 标识符

在python里,标识符有字母、数字、下划线组成。

在python中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。

python中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头(_foo)的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用"from xxx import *"而导入;

以双下划线开头的(__foo)代表类的私有成员;以双下划线开头和结尾的(__foo__)代表python里特殊方法专用的标识,如__init__()代表类的构造函数。


Python保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数,或任何其他标识符名称。

所有Python的关键字只包含小写字母。

and exec not
assert finally or
break for pass
class from print
continue global raise
def if return
del import try
elif in while
else is with
except lambda yield

行和缩进

学习Python与其他语言最大的区别就是,Python的代码块不使用大括号({})来控制类,函数以及其他逻辑判断。python最具特色的就是用缩进来写模块。

缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。

 

if True:
    print "True"
else:
  print "False" True:
    print "True"
else:
  print "False"

 

 

 

 

多行语句

 

Python语句中一般以新行作为为语句的结束符。

但是我们可以使用斜杠( \)将一行的语句分为多行显示,如下所示:

total = item_one + \
        item_two + \
        item_three= item_one + \
        item_two + \
        item_three

语句中包含[], {} 或 () 括号就不需要使用多行连接符。如下实例:

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']= ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

Python 引号

Python 接收单引号(' ),双引号(" ),三引号(''' """) 来表示字符串,引号的开始与结束必须的相同类型的。

其中三引号可以由多行组成,编写多行文本的快捷语法,常用语文档字符串,在文件的特定地点,被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""= 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

Python注释

python中单行注释采用 # 开头。

python 中多行注释使用三个单引号(''')或三个双引号(""")。

 

 

 

 

Python空行

 

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

记住:空行也是程序代码的一部分。

同一行显示多条语句

Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:

 

#!/usr/bin/python

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

多个语句构成代码组

缩进相同的一组语句构成一个代码块,我们称之代码组。

像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例:

if expression : 
   suite 
elif expression :  
   suite  
else :  
   suite  expression : 
   suite 
elif expression :  
   suite  
else :  
   suite 

命令行参数

很多程序可以执行一些操作来查看一些基本信,Python可以使用-h参数查看各参数帮助信息:

$ python -h 
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... 
Options and arguments (and corresponding environment variables): 
-c cmd : program passed in as string (terminates option list) 
-d     : debug output from parser (also PYTHONDEBUG=x) 
-E     : ignore environment variables (such as PYTHONPATH) 
-h     : print this help message and exit 
 
[ etc. ] -h 
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... 
Options and arguments (and corresponding environment variables): 
-c cmd : program passed in as string (terminates option list) 
-d     : debug output from parser (also PYTHONDEBUG=x) 
-E     : ignore environment variables (such as PYTHONPATH) 
-h     : print this help message and exit 
 
[ etc. ] 
# _*_ coding: utf-8 _*_

"""类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算"""

#-- 寻求帮助:
    dir(obj)            # 简单的列出对象obj所包含的方法名称,返回一个字符串列表
    help(obj.func)      # 查询obj.func的具体介绍和用法
    
#-- 测试类型的三种方法,推荐第三种
    if type(L) == type([]):
        print("L is list")
    if type(L) == list:
        print("L is list")
    if isinstance(L, list):
        print("L is list")
        
#-- Python数据类型:哈希类型、不可哈希类型
    # 哈希类型,即在原地不能改变的变量类型,不可变类型。可利用hash函数查看其hash值,也可以作为字典的key
    "数字类型:int, float, decimal.Decimal, fractions.Fraction, complex"
    "字符串类型:str, bytes"
    "元组:tuple"
    "冻结集合:frozenset"
    "布尔类型:True, False"
    "None"
    # 不可hash类型:原地可变类型:list、dict和set。它们不可以作为字典的key。

#-- 数字常量
    1234, -1234, 0, 999999999                    # 整数
    1.23, 1., 3.14e-10, 4E210, 4.0e+210          # 浮点数
    0o177, 0x9ff, 0X9FF, 0b101010                # 八进制、十六进制、二进制数字
    3+4j, 3.0+4.0j, 3J                           # 复数常量,也可以用complex(real, image)来创建
    hex(I), oct(I), bin(I)                       # 将十进制数转化为十六进制、八进制、二进制表示的“字符串”
    int(string, base)                            # 将字符串转化为整数,base为进制数
    # 2.x中,有两种整数类型:一般整数(32位)和长整数(无穷精度)。可以用l或L结尾,迫使一般整数成为长整数
    float('inf'), float('-inf'), float('nan')    # 无穷大, 无穷小, 非数
    
#-- 数字的表达式操作符
    yield x                                      # 生成器函数发送协议
    lambda args: expression                      # 生成匿名函数
    x if y else z                                # 三元选择表达式
    x and y, x or y, not x                       # 逻辑与、逻辑或、逻辑非
    x in y, x not in y                           # 成员对象测试
    x is y, x is not y                           # 对象实体测试
    xy, x>=y, x==y, x!=y             # 大小比较,集合子集或超集值相等性操作符
    1 < a < 3                                    # Python中允许连续比较
    x|y, x&y, x^y                                # 位或、位与、位异或
    x<>y                                   # 位操作:x左移、右移y位
    +, -, *, /, //, %, **                        # 真除法、floor除法:返回不大于真除法结果的整数值、取余、幂运算
    -x, +x, ~x                                   # 一元减法、识别、按位求补(取反)
    x[i], x[i:j:k]                               # 索引、分片、调用
    int(3.14), float(3)                          # 强制类型转换
    
#-- 整数可以利用bit_length函数测试所占的位数
    a = 1;       a.bit_length()    # 1
    a = 1024;    a.bit_length()    # 11
    
#-- repr和str显示格式的区别
    """
    repr格式:默认的交互模式回显,产生的结果看起来它们就像是代码。
    str格式:打印语句,转化成一种对用户更加友好的格式。
    """
    
#-- 数字相关的模块
    # math模块
    # Decimal模块:小数模块
        import decimal
        from decimal import Decimal
        Decimal("0.01") + Decimal("0.02")        # 返回Decimal("0.03")
        decimal.getcontext().prec = 4            # 设置全局精度为4 即小数点后边4位
    # Fraction模块:分数模块
        from fractions import Fraction
        x = Fraction(4, 6)                       # 分数类型 4/6
        x = Fraction("0.25")                     # 分数类型 1/4 接收字符串类型的参数

#-- 集合set
    """
    set是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
    set支持union(联合), intersection(交), difference(差)和symmetric difference(对称差集)等数学运算。
    set支持x in set, len(set), for x in set。
    set不记录元素位置或者插入点, 因此不支持indexing, slicing, 或其它类序列的操作
    """
    s = set([3,5,9,10])                          # 创建一个数值集合,返回{3, 5, 9, 10}
    t = set("Hello")                             # 创建一个唯一字符的集合返回{}
    a = t | s;    t.union(s)                     # t 和 s的并集
    b = t & s;    t.intersection(s)              # t 和 s的交集
    c = t – s;    t.difference(s)                # 求差集(项在t中, 但不在s中)
    d = t ^ s;    t.symmetric_difference(s)      # 对称差集(项在t或s中, 但不会同时出现在二者中)
    t.add('x');   t.remove('H')                  # 增加/删除一个item
    s.update([10,37,42])                         # 利用[......]更新s集合
    x in s,  x not in s                          # 集合中是否存在某个值
    s.issubset(t);      s <= t                   # 测试是否 s 中的每一个元素都在 t 中
    s.issuperset(t);    s >= t                   # 测试是否 t 中的每一个元素都在 s 中 
    s.copy(); 
    s.discard(x);                                # 删除s中x
    s.clear()                                    # 清空s
    {x**2 for x in [1, 2, 3, 4]}                 # 集合解析,结果:{16, 1, 4, 9}
    {x for x in 'spam'}                          # 集合解析,结果:{'a', 'p', 's', 'm'}
    
#-- 集合frozenset,不可变对象
    """
    set是可变对象,即不存在hash值,不能作为字典的键值。同样的还有list等(tuple是可以作为字典key的)
    frozenset是不可变对象,即存在hash值,可作为字典的键值
    frozenset对象没有add、remove等方法,但有union/intersection/difference等方法
    """
    a = set([1, 2, 3])
    b = set()
    b.add(a)                     # error: set是不可哈希类型
    b.add(frozenset(a))          # ok,将set变为frozenset,可哈希

#-- 布尔类型bool
    type(True)                   # 返回
    isinstance(False, int)       # bool类型属于整型,所以返回True
    True == 1; True is 1         # 输出(True, False)
    
#-- 动态类型简介
    """
    变量名通过引用,指向对象。
    Python中的“类型”属于对象,而不是变量,每个对象都包含有头部信息,比如"类型标示符" "引用计数器"等
    """
    #共享引用及在原处修改:对于可变对象,要注意尽量不要共享引用!
    #共享引用和相等测试:
        L = [1], M = [1], L is M            # 返回False
        L = M = [1, 2, 3], L is M           # 返回True,共享引用
    #增强赋值和共享引用:普通+号会生成新的对象,而增强赋值+=会在原处修改
        L = M = [1, 2]
        L = L + [3, 4]                      # L = [1, 2, 3, 4], M = [1, 2]
        L += [3, 4]                         # L = [1, 2, 3, 4], M = [1, 2, 3, 4]

#-- 常见字符串常量和表达式
    S = ''                                  # 空字符串
    S = "spam’s"                            # 双引号和单引号相同
    S = "s\np\ta\x00m"                      # 转义字符
    S = """spam"""                          # 三重引号字符串,一般用于函数说明
    S = r'\temp'                            # Raw字符串,不会进行转义,抑制转义
    S = b'Spam'                             # Python3中的字节字符串
    S = u'spam'                             # Python2.6中的Unicode字符串
    s1+s2, s1*3, s[i], s[i:j], len(s)       # 字符串操作
    'a %s parrot' % 'kind'                  # 字符串格式化表达式
    'a {1} {0} parrot'.format('kind', 'red')# 字符串格式化方法
    for x in s: print(x)                    # 字符串迭代,成员关系
    [x*2 for x in s]                        # 字符串列表解析
    ','.join(['a', 'b', 'c'])               # 字符串输出,结果:a,b,c
    
#-- 内置str处理函数:
    str1 = "stringobject"
    str1.upper(); str1.lower(); str1.swapcase(); str1.capitalize(); str1.title()        # 全部大写,全部小写、大小写转换,首字母大写,每个单词的首字母都大写
    str1.ljust(width)                       # 获取固定长度,左对齐,右边不够用空格补齐
    str1.rjust(width)                       # 获取固定长度,右对齐,左边不够用空格补齐
    str1.center(width)                      # 获取固定长度,中间对齐,两边不够用空格补齐
    str1.zfill(width)                       # 获取固定长度,右对齐,左边不足用0补齐
    str1.find('t',start,end)                # 查找字符串,可以指定起始及结束位置搜索
    str1.rfind('t')                         # 从右边开始查找字符串
    str1.count('t')                         # 查找字符串出现的次数
    #上面所有方法都可用index代替,不同的是使用index查找不到会抛异常,而find返回-1
    str1.replace('old','new')               # 替换函数,替换old为new,参数中可以指定maxReplaceTimes,即替换指定次数的old为new
    str1.strip();                           # 默认删除空白符
    str1.strip('d');                        # 删除str1字符串中开头、结尾处,位于 d 删除序列的字符
    str1.lstrip();
    str1.lstrip('d');                       # 删除str1字符串中开头处,位于 d 删除序列的字符
    str1.rstrip();
    str1.rstrip('d')                        # 删除str1字符串中结尾处,位于 d 删除序列的字符
    str1.startswith('start')                # 是否以start开头
    str1.endswith('end')                    # 是否以end结尾
    str1.isalnum(); str1.isalpha(); str1.isdigit(); str1.islower(); str1.isupper()      # 判断字符串是否全为字符、数字、小写、大写

#-- 三重引号编写多行字符串块,并且在代码折行处嵌入换行字符\n
    mantra = """hello world
            hello python
            hello my friend"""
    # mantra为"""hello world \n hello python \n hello my friend"""
    
#-- 索引和分片:
    S[0], S[len(S)–1], S[-1]                # 索引
    S[1:3], S[1:], S[:-1], S[1:10:2]        # 分片,第三个参数指定步长,如`S[1:10:2]`是从1位到10位没隔2位获取一个字符。

#-- 字符串转换工具:
    int('42'), str(42)                      # 返回(42, '42')
    float('4.13'), str(4.13)                # 返回(4.13, '4.13')
    ord('s'), chr(115)                      # 返回(115, 's')
    int('1001', 2)                          # 将字符串作为二进制数字,转化为数字,返回9
    bin(13), oct(13), hex(13)               # 将整数转化为二进制/八进制/十六进制字符串,返回('0b1101', '015', '0xd')
    
#-- 另类字符串连接
    name = "wang" "hong"                    # 单行,name = "wanghong"
    name = "wang" \
            "hong"                          # 多行,name = "wanghong"

#-- Python中的字符串格式化实现1--字符串格式化表达式
    """
    基于C语言的'print'模型,并且在大多数的现有的语言中使用。
    通用结构:%[(name)][flag][width].[precision]typecode
    """
    "this is %d %s bird" % (1, 'dead')                          # 一般的格式化表达式
    "%s---%s---%s" % (42, 3.14, [1, 2, 3])                      # 字符串输出:'42---3.14---[1, 2, 3]'
    "%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234)         # 对齐方式及填充:"1234...  1234...1234  ...001234"
    x = 1.23456789
    "%e | %f | %g" % (x, x, x)                                  # 对齐方式:"1.234568e+00 | 1.234568 | 1.23457"
    "%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x)                 # 对齐方式:'  1.23*1.23  *001.23* +1.23'
    "%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"}    # 基于字典的格式化表达式
    "%(name)s is %(age)d" % vars()                              # vars()函数调用返回一个字典,包含了所有本函数调用时存在的变量
    
#-- Python中的字符串格式化实现2--字符串格式化调用方法
    # 普通调用
    "{0}, {1} and {2}".format('spam', 'ham', 'eggs')            # 基于位置的调用
    "{motto} and {pork}".format(motto = 'spam', pork = 'ham')   # 基于Key的调用
    "{motto} and {0}".format('ham', motto = 'spam')             # 混合调用
    # 添加键 属性 偏移量 (import sys)
    "my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'})                 # 基于位置的键和属性
    "{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'})   # 基于Key的键和属性
    "first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C'])                       # 基于位置的偏移量
    # 具体格式化
    "{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159)   # 输出'3.141590e+00, 3.142e+00, 3.14159'
    "{fieldname:format_spec}".format(......)
    # 说明:
    """
        fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
        format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
        fill        ::=                #填充字符
        align       ::=  "<" | ">" | "=" | "^"        #对齐方式
        sign        ::=  "+" | "-" | " "              #符号说明
        width       ::=  integer                      #字符串宽度
        precision   ::=  integer                      #浮点数精度
        type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
    """
    # 例子:
        '={0:10} = {1:10}'.format('spam', 123.456)    # 输出'=spam       =    123.456'
        '={0:>10}='.format('test')                    # 输出'=      test='
        '={0:<10}='.format('test')                    # 输出'=test      ='
        '={0:^10}='.format('test')                    # 输出'=   test   ='
        '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)   # 输出'FF, 377, 11111111'
        'My name is {0:{1}}.'.format('Fred', 8)       # 输出'My name is Fred    .'  动态指定参数

#-- 常用列表常量和操作
    L = [[1, 2], 'string', {}]                        # 嵌套列表
    L = list('spam')                                  # 列表初始化
    L = list(range(0, 4))                             # 列表初始化
    list(map(ord, 'spam'))                            # 列表解析
    len(L)                                            # 求列表长度
    L.count(value)                                    # 求列表中某个值的个数
    L.append(obj)                                     # 向列表的尾部添加数据,比如append(2),添加元素2
    L.insert(index, obj)                              # 向列表的指定index位置添加数据,index及其之后的数据后移
    L.extend(interable)                               # 通过添加iterable中的元素来扩展列表,比如extend([2]),添加元素2,注意和append的区别
    L.index(value, [start, [stop]])                   # 返回列表中值value的第一个索引
    L.pop([index])                                    # 删除并返回index处的元素,默认为删除并返回最后一个元素
    L.remove(value)                                   # 删除列表中的value值,只删除第一次出现的value的值
    L.reverse()                                       # 反转列表
    L.sort(cmp=None, key=None, reverse=False)         # 排序列表
    a = [1, 2, 3], b = a[10:]                         # 注意,这里不会引发IndexError异常,只会返回一个空的列表[]
    a = [], a += [1]                                  # 这里实在原有列表的基础上进行操作,即列表的id没有改变
    a = [], a = a + [1]                               # 这里最后的a要构建一个新的列表,即a的id发生了变化
     
#-- 用切片来删除序列的某一段
    a = [1, 2, 3, 4, 5, 6, 7]
    a[1:4] = []                                       # a = [1, 5, 6, 7]
    a = [0, 1, 2, 3, 4, 5, 6, 7]
    del a[::2]                                        # 去除偶数项(偶数索引的),a = [1, 3, 5, 7]
    
#-- 常用字典常量和操作
    D = {}
    D = {'spam':2, 'tol':{'ham':1}}                   # 嵌套字典
    D = dict.fromkeys(['s', 'd'], 8)                  # {'s': 8, 'd': 8}
    D = dict(name = 'tom', age = 12)                  # {'age': 12, 'name': 'tom'}
    D = dict([('name', 'tom'), ('age', 12)])          # {'age': 12, 'name': 'tom'}
    D = dict(zip(['name', 'age'], ['tom', 12]))       # {'age': 12, 'name': 'tom'}
    D.keys(); D.values(); D.items()                   # 字典键、值以及键值对
    D.get(key, default)                               # get函数
    D.update(D_other)                                 # 合并字典,如果存在相同的键值,D_other的数据会覆盖掉D的数据
    D.pop(key, [D])                                   # 删除字典中键值为key的项,返回键值为key的值,如果不存在,返回默认值D,否则异常
    D.popitem()                                       # pop字典中随机的一项(一个键值对)
    D.setdefault(k[, d])                              # 设置D中某一项的默认值。如果k存在,则返回D[k],否则设置D[k]=d,同时返回D[k]。
    del D                                             # 删除字典
    del D['key']                                      # 删除字典的某一项
    if key in D:   if key not in D:                   # 测试字典键是否存在
    # 字典注意事项:(1)对新索引赋值会添加一项(2)字典键不一定非得是字符串,也可以为任何的不可变对象
    # 不可变对象:调用对象自身的任意方法,也不会改变该对象自身的内容,这些方法会创建新的对象并返回。
    # 字符串、整数、tuple都是不可变对象,dict、set、list都是可变对象
    D[(1,2,3)] = 2                                    # tuple作为字典的key

#-- 字典解析
    D = {k:8 for k in ['s', 'd']}                     # {'s': 8, 'd': 8}
    D = {k:v for (k, v) in zip(['name', 'age'], ['tom', 12])}       # {'age': 12, 'name': tom}
    
#-- 字典的特殊方法__missing__:当查找找不到key时,会执行该方法
    class Dict(dict):
        def __missing__(self, key):
            self[key] = []
            return self[key]
    dct = dict()
    dct["foo"].append(1)    # 这有点类似于collections.defalutdict
    dct["foo"]              # [1]
    
#-- 元组和列表的唯一区别在于元组是不可变对象,列表是可变对象
    a = [1, 2, 3]           # a[1] = 0, OK
    a = (1, 2, 3)           # a[1] = 0, Error
    a = ([1, 2])            # a[0][1] = 0, OK
    a = [(1, 2)]            # a[0][1] = 0, Error
    
#-- 元组的特殊语法: 逗号和圆括号
    D = (12)                # 此时D为一个整数 即D = 12
    D = (12, )              # 此时D为一个元组 即D = (12, )
    
#-- 文件基本操作
    output = open(r'C:\spam', 'w')          # 打开输出文件,用于写
    input = open('data', 'r')               # 打开输入文件,用于读。打开的方式可以为'w', 'r', 'a', 'wb', 'rb', 'ab'等
    fp.read([size])                         # size为读取的长度,以byte为单位
    fp.readline([size])                     # 读一行,如果定义了size,有可能返回的只是一行的一部分
    fp.readlines([size])                    # 把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长。
    fp.readable()                           # 是否可读
    fp.write(str)                           # 把str写到文件中,write()并不会在str后加上一个换行符
    fp.writelines(seq)                      # 把seq的内容全部写到文件中(多行一次性写入)
    fp.writeable()                          # 是否可写
    fp.close()                              # 关闭文件。
    fp.flush()                              # 把缓冲区的内容写入硬盘
    fp.fileno()                             # 返回一个长整型的”文件标签“
    fp.isatty()                             # 文件是否是一个终端设备文件(unix系统中的)
    fp.tell()                               # 返回文件操作标记的当前位置,以文件的开头为原点
    fp.next()                               # 返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
    fp.seek(offset[,whence])                # 将文件打开操作标记移到offset的位置。whence为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。
    fp.seekable()                           # 是否可以seek
    fp.truncate([size])                     # 把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。
    for line in open('data'): 
        print(line)                         # 使用for语句,比较适用于打开比较大的文件
    open('f.txt', encoding = 'latin-1')     # Python3.x Unicode文本文件
    open('f.bin', 'rb')                     # Python3.x 二进制bytes文件
    # 文件对象还有相应的属性:buffer closed encoding errors line_buffering name newlines等
    
#-- 其他
    # Python中的真假值含义:1. 数字如果非零,则为真,0为假。 2. 其他对象如果非空,则为真
    # 通常意义下的类型分类:1. 数字、序列、映射。 2. 可变类型和不可变类型


"""语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句"""

#-- 赋值语句的形式
    spam = 'spam'                          # 基本形式
    spam, ham = 'spam', 'ham'              # 元组赋值形式
    [spam, ham] = ['s', 'h']               # 列表赋值形式
    a, b, c, d = 'abcd'                    # 序列赋值形式
    a, *b, c = 'spam'                      # 序列解包形式(Python3.x中才有)
    spam = ham = 'no'                      # 多目标赋值运算,涉及到共享引用
    spam += 42                             # 增强赋值,涉及到共享引用

#-- 序列赋值 序列解包
    [a, b, c] = (1, 2, 3)                  # a = 1, b = 2, c = 3
    a, b, c, d = "spam"                    # a = 's', b = 'p', c = 'a', d = 'm'
    a, b, c = range(3)                     # a = 0, b = 1, c = 2
    a, *b = [1, 2, 3, 4]                   # a = 1, b = [2, 3, 4]
    *a, b = [1, 2, 3, 4]                   # a = [1, 2, 3], b = 4
    a, *b, c = [1, 2, 3, 4]                # a = 1, b = [2, 3], c = 4
    # 带有*时 会优先匹配*之外的变量 如
    a, *b, c = [1, 2]                      # a = 1, c = 2, b = []

#-- print函数原型
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    # 流的重定向
    print('hello world')                   # 等于sys.stdout.write('hello world')
    temp = sys.stdout                      # 原有流的保存
    sys.stdout = open('log.log', 'a')      # 流的重定向
    print('hello world')                   # 写入到文件log.log
    sys.stdout.close()
    sys.stdout = temp                      # 原有流的复原
    
#-- Python中and或or总是返回对象(左边的对象或右边的对象) 且具有短路求值的特性
    1 or 2 or 3                            # 返回 1
    1 and 2 and 3                          # 返回 3

#-- if/else三元表达符(if语句在行内)
    A = 1 if X else 2
    A = 1 if X else (2 if Y else 3)
    # 也可以使用and-or语句(一条语句实现多个if-else)
    a = 6
    result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "big than 5")    # 返回"big than 20"

#-- Python的while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句
    while a > 1:
        anything
    else:
        anything
    # else语句会在循环结束后执行,除非在循环中执行了break,同样的还有for语句
    for i in range(5):
        anything
    else:
        anything

#-- for循环的元组赋值
    for (a, b) in [(1, 2), (3, 4)]:                   # 最简单的赋值
    for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:    # 自动解包赋值
    for ((a, b), c) in [((1, 2), 3), ("XY", 6)]:      # 自动解包 a = X, b = Y, c = 6
    for (a, *b) in [(1, 2, 3), (4, 5, 6)]:            # 自动解包赋值

#-- 列表解析语法
    M = [[1,2,3], [4,5,6], [7,8,9]]
    res = [sum(row) for row in M]                     # G = [6, 15, 24] 一般的列表解析 生成一个列表
    res = [c * 2 for c in 'spam']                     # ['ss', 'pp', 'aa', 'mm']
    res = [a * b for a in [1, 2] for b in [4, 5]]     # 多解析过程 返回[4, 5, 8, 10]
    res = [a for a in [1, 2, 3] if a < 2]             # 带判断条件的解析过程
    res = [a if a > 0 else 0 for a in [-1, 0, 1]]     # 带判断条件的高级解析过程
    # 两个列表同时解析:使用zip函数
    for teama, teamb in zip(["Packers", "49ers"], ["Ravens", "Patriots"]):
        print(teama + " vs. " + teamb)
    # 带索引的列表解析:使用enumerate函数
    for index, team in enumerate(["Packers", "49ers", "Ravens", "Patriots"]):
        print(index, team)                            # 输出0, Packers \n 1, 49ers \n ......
    
#-- 生成器表达式
    G = (sum(row) for row in M)                       # 使用小括号可以创建所需结果的生成器generator object
    next(G), next(G), next(G)                         # 输出(6, 15, 24)
    G = {sum(row) for row in M}                       # G = {6, 15, 24} 解析语法还可以生成集合和字典
    G = {i:sum(M[i]) for i in range(3)}               # G = {0: 6, 1: 15, 2: 24}

#-- 文档字符串:出现在Module的开端以及其中函数或类的开端 使用三重引号字符串
    """
    module document
    """
    def func():
        """
        function document
        """
        print()
    class Employee(object):
        """
        class document
        """
        print()
    print(func.__doc__)                # 输出函数文档字符串
    print(Employee.__doc__)            # 输出类的文档字符串
    
#-- 命名惯例:
    """
    以单一下划线开头的变量名(_X)不会被from module import*等语句导入
    前后有两个下划线的变量名(__X__)是系统定义的变量名,对解释器有特殊意义
    以两个下划线开头但不以下划线结尾的变量名(__X)是类的本地(私有)变量
    """

#-- 列表解析 in成员关系测试 map sorted zip enumerate内置函数等都使用了迭代协议
    'first line' in open('test.txt')   # in测试 返回True或False
    list(map(str.upper, open('t')))    # map内置函数
    sorted(iter([2, 5, 8, 3, 1]))      # sorted内置函数
    list(zip([1, 2], [3, 4]))          # zip内置函数 [(1, 3), (2, 4)]

#-- del语句: 手动删除某个变量
    del X

#-- 获取列表的子表的方法:
    x = [1,2,3,4,5,6]
    x[:3]                              # 前3个[1,2,3]
    x[1:5]                             # 中间4个[2,3,4,5]
    x[-3:]                             # 最后3个[4,5,6]
    x[::2]                             # 奇数项[1,3,5]
    x[1::2]                            # 偶数项[2,4,6]
    
#-- 手动迭代:iter和next
    L = [1, 2]
    I = iter(L)                        # I为L的迭代器
    I.next()                           # 返回1
    I.next()                           # 返回2
    I.next()                           # Error:StopIteration
    
#-- Python中的可迭代对象
    """
    1.range迭代器
    2.map、zip和filter迭代器
    3.字典视图迭代器:D.keys()), D.items()等
    4.文件类型
    """


"""函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则"""

#-- 函数相关的语句和表达式
    myfunc('spam')                     # 函数调用
    def myfunc():                      # 函数定义
    return None                        # 函数返回值
    global a                           # 全局变量
    nonlocal x                         # 在函数或其他作用域中使用外层(非全局)变量
    yield x                            # 生成器函数返回
    lambda                             # 匿名函数
    
#-- Python函数变量名解析:LEGB原则,即:
    """
    local(functin) --> encloseing function locals --> global(module) --> build-in(python)
    说明:以下边的函数maker为例 则相对于action而言 X为Local N为Encloseing
    """

#-- 嵌套函数举例:工厂函数
    def maker(N):
        def action(X):
            return X ** N
        return action
    f = maker(2)                       # pass 2 to N
    f(3)                               # 9, pass 3 to X

#-- 嵌套函数举例:lambda实例
    def maker(N):
        action = (lambda X: X**N)
        return action
    f = maker(2)                       # pass 2 to N
    f(3)                               # 9, pass 3 to X

#-- nonlocal和global语句的区别
    # nonlocal应用于一个嵌套的函数的作用域中的一个名称 例如:
    start = 100
    def tester(start):
        def nested(label):
            nonlocal start             # 指定start为tester函数内的local变量 而不是global变量start
            print(label, start)
            start += 3
        return nested
    # global为全局的变量 即def之外的变量
    def tester(start):
        def nested(label):
            global start               # 指定start为global变量start
            print(label, start)
            start += 3
        return nested    
    
#-- 函数参数,不可变参数通过“值”传递,可变参数通过“引用”传递
    def f(a, b, c): print(a, b, c)
    f(1, 2, 3)                         # 参数位置匹配
    f(1, c = 3, b = 2)                 # 参数关键字匹配
    def f(a, b=1, c=2): print(a, b, c)
    f(1)                               # 默认参数匹配
    f(1, 2)                            # 默认参数匹配
    f(a = 1, c = 3)                    # 关键字参数和默认参数的混合
    # Keyword-Only参数:出现在*args之后 必须用关键字进行匹配
    def keyOnly(a, *b, c): print('')   # c就为keyword-only匹配 必须使用关键字c = value匹配
    def keyOnly(a, *, b, c): ......    # b c为keyword-only匹配 必须使用关键字匹配
    def keyOnly(a, *, b = 1): ......   # b有默认值 或者省略 或者使用关键字参数b = value

#-- 可变参数匹配: * 和 **
    def f(*args): print(args)          # 在元组中收集不匹配的位置参数
    f(1, 2, 3)                         # 输出(1, 2, 3)
    def f(**args): print(args)         # 在字典中收集不匹配的关键字参数
    f(a = 1, b = 2)                    # 输出{'a':1, 'b':2}
    def f(a, *b, **c): print(a, b, c)  # 两者混合使用
    f(1, 2, 3, x=4, y=5)               # 输出1, (2, 3), {'x':4, 'y':5}
    
#-- 函数调用时的参数解包: * 和 ** 分别解包元组和字典
    func(1, *(2, 3))  <==>  func(1, 2, 3)
    func(1, **{'c':3, 'b':2})  <==>  func(1, b = 2, c = 3)
    func(1, *(2, 3), **{'c':3, 'b':2})  <==>  func(1, 2, 3, b = 2, c = 3)
    
#-- 函数属性:(自己定义的)函数可以添加属性
    def func():.....
    func.count = 1                     # 自定义函数添加属性
    print.count = 1                    # Error 内置函数不可以添加属性
    
#-- 函数注解: 编写在def头部行 主要用于说明参数范围、参数类型、返回值类型等
    def func(a:'spam', b:(1, 10), c:float) -> int :
        print(a, b, c)
    func.__annotations__               # {'c':, 'b':(1, 10), 'a':'spam', 'return':}
    # 编写注解的同时 还是可以使用函数默认值 并且注解的位置位于=号的前边
    def func(a:'spam'='a', b:(1, 10)=2, c:float=3) -> int :
        print(a, b, c)

#-- 匿名函数:lambda
    f = lambda x, y, z : x + y + z     # 普通匿名函数,使用方法f(1, 2, 3)
    f = lambda x = 1, y = 1: x + y     # 带默认参数的lambda函数
    def action(x):                     # 嵌套lambda函数
        return (lambda y : x + y)
    f = lambda: a if xxx() else b      # 无参数的lambda函数,使用方法f()

#-- lambda函数与map filter reduce函数的结合
    list(map((lambda x: x + 1), [1, 2, 3]))              # [2, 3, 4]
    list(filter((lambda x: x > 0), range(-4, 5)))        # [1, 2, 3, 4]
    functools.reduce((lambda x, y: x + y), [1, 2, 3])    # 6
    functools.reduce((lambda x, y: x * y), [2, 3, 4])    # 24
    
#-- 生成器函数:yield VS return
    def gensquare(N):
        for i in range(N):
            yield i** 2                # 状态挂起 可以恢复到此时的状态
    for i in gensquare(5):             # 使用方法
        print(i, end = ' ')            # [0, 1, 4, 9, 16]
    x = gensquare(2)                   # x是一个生成对象
    next(x)                            # 等同于x.__next__() 返回0
    next(x)                            # 等同于x.__next__() 返回1
    next(x)                            # 等同于x.__next__() 抛出异常StopIteration
    
#-- 生成器表达式:小括号进行列表解析
    G = (x ** 2 for x in range(3))     # 使用小括号可以创建所需结果的生成器generator object
    next(G), next(G), next(G)          # 和上述中的生成器函数的返回值一致
    #(1)生成器(生成器函数/生成器表达式)是单个迭代对象
    G = (x ** 2 for x in range(4))
    I1 = iter(G)                       # 这里实际上iter(G) = G
    next(I1)                           # 输出0
    next(G)                            # 输出1
    next(I1)                           # 输出4
    #(2)生成器不保留迭代后的结果
    gen = (i for i in range(4))
    2 in gen                           # 返回True
    3 in gen                           # 返回True
    1 in gen                           # 返回False,其实检测2的时候,1已经就不在生成器中了,即1已经被迭代过了,同理2、3也不在了

#-- 本地变量是静态检测的
    X = 22                             # 全局变量X的声明和定义
    def test():
        print(X)                       # 如果没有下一语句 则该句合法 打印全局变量X
        X = 88                         # 这一语句使得上一语句非法 因为它使得X变成了本地变量 上一句变成了打印一个未定义的本地变量(局部变量)
        if False:                      # 即使这样的语句 也会把print语句视为非法语句 因为:
            X = 88                     # Python会无视if语句而仍然声明了局部变量X
    def test():                        # 改进
        global X                       # 声明变量X为全局变量
        print(X)                       # 打印全局变量X
        X = 88                         # 改变全局变量X
        
#-- 函数的默认值是在函数定义的时候实例化的 而不是在调用的时候 例子:
    def foo(numbers=[]):               # 这里的[]是可变的
        numbers.append(9)    
        print(numbers)
    foo()                              # first time, like before, [9]
    foo()                              # second time, not like before, [9, 9]
    foo()                              # third time, not like before too, [9, 9, 9]
    # 改进:
    def foo(numbers=None):
        if numbers is None: numbers = []
        numbers.append(9)
        print(numbers)
    # 另外一个例子 参数的默认值为不可变的:
    def foo(count=0):                  # 这里的0是数字, 是不可变的
        count += 1
        print(count)
    foo()                              # 输出1
    foo()                              # 还是输出1
    foo(3)                             # 输出4
    foo()                              # 还是输出1
    

"""函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子"""

    """数学运算类"""
    abs(x)                              # 求绝对值,参数可以是整型,也可以是复数,若参数是复数,则返回复数的模
    complex([real[, imag]])             # 创建一个复数
    divmod(a, b)                        # 分别取商和余数,注意:整型、浮点型都可以
    float([x])                          # 将一个字符串或数转换为浮点数。如果无参数将返回0.0
    int([x[, base]])                    # 将一个字符串或浮点数转换为int类型,base表示进制
    long([x[, base]])                   # 将一个字符串或浮点数转换为long类型
    pow(x, y)                           # 返回x的y次幂
    range([start], stop[, step])        # 产生一个序列,默认从0开始
    round(x[, n])                       # 四舍五入
    sum(iterable[, start])              # 对集合求和
    oct(x)                              # 将一个数字转化为8进制字符串
    hex(x)                              # 将一个数字转换为16进制字符串
    chr(i)                              # 返回给定int类型对应的ASCII字符
    unichr(i)                           # 返回给定int类型的unicode
    ord(c)                              # 返回ASCII字符对应的整数
    bin(x)                              # 将整数x转换为二进制字符串
    bool([x])                           # 将x转换为Boolean类型
    
    """集合类操作"""
    basestring()                        # str和unicode的超类,不能直接调用,可以用作isinstance判断
    format(value [, format_spec])       # 格式化输出字符串,格式化的参数顺序从0开始,如“I am {0},I like {1}”
    enumerate(sequence[, start=0])      # 返回一个可枚举的对象,注意它有第二个参数
    iter(obj[, sentinel])               # 生成一个对象的迭代器,第二个参数表示分隔符
    max(iterable[, args...][key])       # 返回集合中的最大值
    min(iterable[, args...][key])       # 返回集合中的最小值
    dict([arg])                         # 创建数据字典
    list([iterable])                    # 将一个集合类转换为另外一个集合类
    set()                               # set对象实例化
    frozenset([iterable])               # 产生一个不可变的set
    tuple([iterable])                   # 生成一个tuple类型
    str([object])                       # 转换为string类型
    sorted(iterable[, cmp[, key[, reverse]]])             # 集合排序
        L = [('b',2),('a',1),('c',3),('d',4)]
        sorted(L, key=lambda x: x[1]), reverse=True)      # 使用Key参数和reverse参数
        sorted(L, key=lambda x: (x[0], x[1]))             # 使用key参数进行多条件排序,即如果x[0]相同,则比较x[1]

    """逻辑判断"""
    all(iterable)                       # 集合中的元素都为真的时候为真,特别的,若为空串返回为True
    any(iterable)                       # 集合中的元素有一个为真的时候为真,特别的,若为空串返回为False
    cmp(x, y)                           # 如果x < y ,返回负数;x == y, 返回0;x > y,返回正数

    """IO操作"""
    file(filename [, mode [, bufsize]]) # file类型的构造函数。
    input([prompt])                     # 获取用户输入,推荐使用raw_input,因为该函数将不会捕获用户的错误输入,意思是自行判断类型
    # 在 Built-in Functions 里有一句话是这样写的:Consider using the raw_input() function for general input from users.
    raw_input([prompt])                 # 设置输入,输入都是作为字符串处理
    open(name[, mode[, buffering]])     # 打开文件,与file有什么不同?推荐使用open
    
    """其他"""
    callable(object)                    # 检查对象object是否可调用
    classmethod(func)                   # 用来说明这个func是个类方法
    staticmethod(func)                  # 用来说明这个func为静态方法
    dir([object])                       # 不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
    help(obj)                           # 返回obj的帮助信息
    eval(expression)                    # 计算表达式expression的值,并返回
    exec(str)                           # 将str作为Python语句执行
    execfile(filename)                  # 用法类似exec(),不同的是execfile的参数filename为文件名,而exec的参数为字符串。
    filter(function, iterable)          # 构造一个序列,等价于[item for item in iterable if function(item)],function返回值为True或False的函数
        list(filter(bool, range(-3, 4)))# 返回[-3, -2, -1, 1, 2, 3], 没有0
    hasattr(object, name)               # 判断对象object是否包含名为name的特性
    getattr(object, name [, defalut])   # 获取一个类的属性
    setattr(object, name, value)        # 设置属性值
    delattr(object, name)               # 删除object对象名为name的属性
    globals()                           # 返回一个描述当前全局符号表的字典
    hash(object)                        # 如果对象object为哈希表类型,返回对象object的哈希值
    id(object)                          # 返回对象的唯一标识,一串数字
    isinstance(object, classinfo)       # 判断object是否是class的实例
        isinstance(1, int)              # 判断是不是int类型
        isinstance(1, (int, float))     # isinstance的第二个参数接受一个元组类型
    issubclass(class, classinfo)        # 判断class是否为classinfo的子类
    locals()                            # 返回当前的变量列表
    map(function, iterable, ...)        # 遍历每个元素,执行function操作
        list(map(abs, range(-3, 4)))    # 返回[3, 2, 1, 0, 1, 2, 3]
    next(iterator[, default])           # 类似于iterator.next()
    property([fget[, fset[, fdel[, doc]]]])           # 属性访问的包装类,设置后可以通过c.x=value等来访问setter和getter
    reduce(function, iterable[, initializer])         # 合并操作,从第一个开始是前两个参数,然后是前两个的结果与第三个合并进行处理,以此类推
        def add(x,y):return x + y 
        reduce(add, range(1, 11))                     # 返回55 (注:1+2+3+4+5+6+7+8+9+10 = 55)
        reduce(add, range(1, 11), 20)                 # 返回75
    reload(module)                      # 重新加载模块
    repr(object)                        # 将一个对象变幻为可打印的格式
    slice(start, stop[, step])          # 产生分片对象
    type(object)                        # 返回该object的类型
    vars([object])                      # 返回对象的变量名、变量值的字典
        a = Class();                    # Class为一个空类
        a.name = 'qi', a.age = 9
        vars(a)                         # {'name':'qi', 'age':9}
    zip([iterable, ...])                # 返回对应数组
        list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]
        a = [1, 2, 3],  b = ["a", "b", "c"]
        z = zip(a, b)                   # 压缩:[(1, "a"), (2, "b"), (3, "c")]
        zip(*z)                         # 解压缩:[(1, 2, 3), ("a", "b", "c")]
    unicode(string, encoding, errors)   # 将字符串string转化为unicode形式,string为encoded string。

    
"""模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle"""

#-- Python模块搜索路径:
    """
    (1)程序的主目录    (2)PYTHONPATH目录 (3)标准链接库目录 (4)任何.pth文件的内容
    """
    
#-- 查看全部的模块搜索路径
    import sys
    sys.path
    sys.argv                            # 获得脚本的参数
    sys.builtin_module_names            # 查找内建模块
    sys.platform                        # 返回当前平台 出现如: "win32" "linux" "darwin"等
    sys.modules                         # 查找已导入的模块
    sys.modules.keys()
    sys.stdout                          # stdout 和 stderr 都是类文件对象,但是它们都是只写的。它们都没有 read 方法,只有 write 方法
    sys.stdout.write("hello")
    sys.stderr
    sys.stdin   

#-- 模块的使用代码
    import module1, module2             # 导入module1 使用module1.printer()
    from module1 import printer         # 导入module1中的printer变量 使用printer()
    from module1 import *               # 导入module1中的全部变量 使用不必添加module1前缀

#-- 重载模块reload: 这是一个内置函数 而不是一条语句
    from imp import reload
    reload(module)
    
#-- 模块的包导入:使用点号(.)而不是路径(dir1\dir2)进行导入
    import dir1.dir2.mod                # d导入包(目录)dir1中的包dir2中的mod模块 此时dir1必须在Python可搜索路径中
    from dir1.dir2.mod import *         # from语法的包导入

#-- __init__.py包文件:每个导入的包中都应该包含这么一个文件
    """
    该文件可以为空
    首次进行包导入时 该文件会自动执行
    高级功能:在该文件中使用__all__列表来定义包(目录)以from*的形式导入时 需要导入什么
    """
    
#-- 包相对导入:使用点号(.) 只能使用from语句
    from . import spam                  # 导入当前目录下的spam模块(Python2: 当前目录下的模块, 直接导入即可)
    from .spam import name              # 导入当前目录下的spam模块的name属性(Python2: 当前目录下的模块, 直接导入即可,不用加.)
    from .. import spam                 # 导入当前目录的父目录下的spam模块
    
#-- 包相对导入与普通导入的区别
    from string import *                # 这里导入的string模块为sys.path路径上的 而不是本目录下的string模块(如果存在也不是)
    from .string import *               # 这里导入的string模块为本目录下的(不存在则导入失败) 而不是sys.path路径上的
    
#-- 模块数据隐藏:最小化from*的破坏
    _X                                  # 变量名前加下划线可以防止from*导入时该变量名被复制出去
    __all__ = ['x', 'x1', 'x2']         # 使用__all__列表指定from*时复制出去的变量名(变量名在列表中为字符串形式)

#-- 可以使用__name__进行模块的单元测试:当模块为顶层执行文件时值为'__main__' 当模块被导入时为模块名
    if __name__ == '__main__':
        doSomething
    # 模块属性中还有其他属性,例如:
    __doc__                             # 模块的说明文档
    __file__                            # 模块文件的文件名,包括全路径
    __name__                            # 主文件或者被导入文件
    __package__                         # 模块所在的包
        
#-- import语句from语句的as扩展
    import modulename as name
    from modulename import attrname as name
    
#-- 得到模块属性的几种方法 假设为了得到name属性的值
    M.name
    M.__dict__['name']
    sys.modules['M'].name
    getattr(M, 'name')
    

"""类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象"""

#-- 最普通的类
    class C1(C2, C3):
        spam = 42                       # 数据属性
        def __init__(self, name):       # 函数属性:构造函数
            self.name = name
        def __del__(self):              # 函数属性:析构函数
            print("goodbey ", self.name)    
    I1 = C1('bob')
    
#-- Python的类没有基于参数的函数重载
    class FirstClass(object):
        def test(self, string):
            print(string)
        def test(self):                 # 此时类中只有一个test函数 即后者test(self) 它覆盖掉前者带参数的test函数
            print("hello world")

#-- 子类扩展超类: 尽量调用超类的方法
    class Manager(Person):
        def giveRaise(self, percent, bonus = .10):
            self.pay = int(self.pay*(1 + percent + bonus))     # 不好的方式 复制粘贴超类代码
            Person.giveRaise(self, percent + bonus)            # 好的方式 尽量调用超类方法

#-- 类内省工具
    bob = Person('bob')
    bob.__class__                       # 
    bob.__class__.__name__              # 'Person'
    bob.__dict__                        # {'pay':0, 'name':'bob', 'job':'Manager'}
    
#-- 返回1中 数据属性spam是属于类 而不是对象
    I1 = C1('bob'); I2 = C2('tom')      # 此时I1和I2的spam都为42 但是都是返回的C1的spam属性
    C1.spam = 24                        # 此时I1和I2的spam都为24
    I1.spam = 3                         # 此时I1新增自有属性spam 值为3 I2和C1的spam还都为24
    
#-- 类方法调用的两种方式
    instance.method(arg...)
    class.method(instance, arg...)
    
#-- 抽象超类的实现方法
    # (1)某个函数中调用未定义的函数 子类中定义该函数
        def delegate(self):
            self.action()               # 本类中不定义action函数 所以使用delegate函数时就会出错
    # (2)定义action函数 但是返回异常
        def action(self):
            raise NotImplementedError("action must be defined")
    # (3)上述的两种方法还都可以定义实例对象 实际上可以利用@装饰器语法生成不能定义的抽象超类
        from abc import ABCMeta, abstractmethod
        class Super(metaclass = ABCMeta):
            @abstractmethod
            def action(self): pass
        x = Super()                     # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action
    
#-- # OOP和继承: "is-a"的关系
    class A(B):
        pass
    a = A()
    isinstance(a, B)                    # 返回True, A是B的子类 a也是B的一种
    # OOP和组合: "has-a"的关系
    pass
    # OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取
    # 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象
    class wrapper(object):
        def __init__(self, object):
            self.wrapped = object
        def __getattr(self, attrname):
            print('Trace: ', attrname)
            return getattr(self.wrapped, attrname)
    # 注:这里使用getattr(X, N)内置函数以变量名字符串N从包装对象X中取出属性 类似于X.__dict__[N]
    x = wrapper([1, 2, 3])
    x.append(4)                         # 返回 "Trace: append" [1, 2, 3, 4]
    x = wrapper({'a':1, 'b':2})
    list(x.keys())                      # 返回 "Trace: keys" ['a', 'b']

#-- 类的伪私有属性:使用__attr
    class C1(object):
        def __init__(self, name):
            self.__name = name          # 此时类的__name属性为伪私有属性 原理 它会自动变成self._C1__name = name
        def __str__(self):
            return 'self.name = %s' % self.__name
    I = C1('tom')
    print(I)                            # 返回 self.name = tom
    I.__name = 'jeey'                   # 这里无法访问 __name为伪私有属性
    I._C1__name = 'jeey'                # 这里可以修改成功 self.name = jeey
    
#-- 类方法是对象:无绑定类方法对象 / 绑定实例方法对象
    class Spam(object):
        def doit(self, message):
            print(message)
        def selfless(message)
            print(message)
    obj = Spam()
    x = obj.doit                        # 类的绑定方法对象 实例 + 函数
    x('hello world')
    x = Spam.doit                       # 类的无绑定方法对象 类名 + 函数
    x(obj, 'hello world')
    x = Spam.selfless                   # 类的无绑定方法函数 在3.0之前无效
    x('hello world')

#-- 获取对象信息: 属性和方法
    a = MyObject()
    dir(a)                              # 使用dir函数
    hasattr(a, 'x')                     # 测试是否有x属性或方法 即a.x是否已经存在
    setattr(a, 'y', 19)                 # 设置属性或方法 等同于a.y = 19
    getattr(a, 'z', 0)                  # 获取属性或方法 如果属性不存在 则返回默认值0
    #这里有个小技巧,setattr可以设置一个不能访问到的属性,即只能用getattr获取
    setattr(a, "can't touch", 100)      # 这里的属性名带有空格,不能直接访问
    getattr(a, "can't touch", 0)        # 但是可以用getattr获取

#-- 为类动态绑定属性或方法: MethodType方法
    # 一般创建了一个class的实例后, 可以给该实例绑定任何属性和方法, 这就是动态语言的灵活性
    class Student(object):
        pass
    s = Student()
    s.name = 'Michael'                  # 动态给实例绑定一个属性
    def set_age(self, age):             # 定义一个函数作为实例方法
        self.age = age
    from types import MethodType
    s.set_age = MethodType(set_age, s)  # 给实例绑定一个方法 类的其他实例不受此影响
    s.set_age(25)                       # 调用实例方法
    Student.set_age = MethodType(set_age, Student)    # 为类绑定一个方法 类的所有实例都拥有该方法

    
"""类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题"""
    
#-- 多重继承: "混合类", 搜索方式"从下到上 从左到右 广度优先"
    class A(B, C):
        pass

#-- 类的继承和子类的初始化
    # 1.子类定义了__init__方法时,若未显示调用基类__init__方法,python不会帮你调用。
    # 2.子类未定义__init__方法时,python会自动帮你调用首个基类的__init__方法,注意是首个。
    # 3.子类显示调用基类的初始化函数:
    class FooParent(object):
        def __init__(self, a):
            self.parent = 'I\'m the Parent.'
            print('Parent:a=' + str(a))
        def bar(self, message):
            print(message + ' from Parent')
    class FooChild(FooParent):
        def __init__(self, a):
            FooParent.__init__(self, a)
            print('Child:a=' + str(a))
        def bar(self, message):
            FooParent.bar(self, message)
            print(message + ' from Child')
    fooChild = FooChild(10)
    fooChild.bar('HelloWorld')
    
#-- #实例方法 / 静态方法 / 类方法
    class Methods(object):
        def imeth(self, x): print(self, x)      # 实例方法:传入的是实例和数据,操作的是实例的属性
        def smeth(x): print(x)                  # 静态方法:只传入数据 不传入实例,操作的是类的属性而不是实例的属性
        def cmeth(cls, x): print(cls, x)        # 类方法:传入的是类对象和数据
        smeth = staticmethod(smeth)             # 调用内置函数,也可以使用@staticmethod
        cmeth = classmethod(cmeth)              # 调用内置函数,也可以使用@classmethod
    obj = Methods()
    obj.imeth(1)                                # 实例方法调用 <__main__.Methods object...> 1
    Methods.imeth(obj, 2)                       # <__main__.Methods object...> 2
    Methods.smeth(3)                            # 静态方法调用 3
    obj.smeth(4)                                # 这里可以使用实例进行调用
    Methods.cmeth(5)                            # 类方法调用  5
    obj.cmeth(6)                                #  6
    
#-- 函数装饰器:是它后边的函数的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成
        @staticmethod
        def smeth(x): print(x)
    # 等同于:
        def smeth(x): print(x)
        smeth = staticmethod(smeth)
    # 同理
        @classmethod
        def cmeth(cls, x): print(x)
    # 等同于
        def cmeth(cls, x): print(x)
        cmeth = classmethod(cmeth)
    
#-- 类修饰器:是它后边的类的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成
        def decorator(aClass):.....
        @decorator
        class C(object):....
    # 等同于:
        class C(object):....
        C = decorator(C)

#-- 限制class属性: __slots__属性
    class Student(object):
        __slots__ = ('name', 'age')             # 限制Student及其实例只能拥有name和age属性
    # __slots__属性只对当前类起作用, 对其子类不起作用
    # __slots__属性能够节省内存
    # __slots__属性可以为列表list,或者元组tuple
    
#-- 类属性高级话题: @property
    # 假设定义了一个类:C,该类必须继承自object类,有一私有变量_x
    class C(object):
        def __init__(self):
            self.__x = None
    # 第一种使用属性的方法
        def getx(self):
            return self.__x
        def setx(self, value):
            self.__x = value
        def delx(self):
            del self.__x
        x = property(getx, setx, delx, '')
    # property函数原型为property(fget=None,fset=None,fdel=None,doc=None)
    # 使用
    c = C()
    c.x = 100                         # 自动调用setx方法
    y = c.x                           # 自动调用getx方法
    del c.x                           # 自动调用delx方法
    # 第二种方法使用属性的方法
        @property
        def x(self):
            return self.__x
        @x.setter
        def x(self, value):
           self.__x = value
        @x.deleter
        def x(self):
           del self.__x
    # 使用
    c = C()
    c.x = 100                         # 自动调用setter方法
    y = c.x                           # 自动调用x方法
    del c.x                           # 自动调用deleter方法
    
#-- 定制类: 重写类的方法
    # (1)__str__方法、__repr__方法: 定制类的输出字符串
    # (2)__iter__方法、next方法: 定制类的可迭代性
    class Fib(object):
        def __init__(self):
            self.a, self.b = 0, 1     # 初始化两个计数器a,b
        def __iter__(self):
            return self               # 实例本身就是迭代对象,故返回自己
        def next(self):
            self.a, self.b = self.b, self.a + self.b
            if self.a > 100000:       # 退出循环的条件
                raise StopIteration()
            return self.a             # 返回下一个值
    for n in Fib():
        print(n)                      # 使用
    # (3)__getitem__方法、__setitem__方法: 定制类的下标操作[] 或者切片操作slice
    class Indexer(object):
        def __init__(self):
            self.data = {}
        def __getitem__(self, n):             # 定义getitem方法
            print('getitem:', n)                
            return self.data[n]
        def __setitem__(self, key, value):    # 定义setitem方法
            print('setitem:key = {0}, value = {1}'.format(key, value))
            self.data[key] = value
    test = Indexer()
    test[0] = 1;   test[3] = '3'              # 调用setitem方法
    print(test[0])                            # 调用getitem方法
    # (4)__getattr__方法: 定制类的属性操作
    class Student(object):
        def __getattr__(self, attr):          # 定义当获取类的属性时的返回值
            if attr=='age':
                return 25                     # 当获取age属性时返回25
        raise AttributeError('object has no attribute: %s' % attr)
        # 注意: 只有当属性不存在时 才会调用该方法 且该方法默认返回None 需要在函数最后引发异常
    s = Student()
    s.age                                     # s中age属性不存在 故调用__getattr__方法 返回25
    # (5)__call__方法: 定制类的'可调用'性
    class Student(object):
        def __call__(self):                   # 也可以带参数
            print('Calling......')
    s = Student()
    s()                                       # s变成了可调用的 也可以带参数
    callable(s)                               # 测试s的可调用性 返回True
    #    (6)__len__方法:求类的长度
    def __len__(self):
        return len(self.data)
    
#-- 动态创建类type()
    # 一般创建类 需要在代码中提前定义
        class Hello(object):
            def hello(self, name='world'):
                print('Hello, %s.' % name)
        h = Hello()
        h.hello()                             # Hello, world
        type(Hello)                           # Hello是一个type类型 返回
        type(h)                               # h是一个Hello类型 返回
    # 动态类型语言中 类可以动态创建 type函数可用于创建新类型
        def fn(self, name='world'):           # 先定义函数
            print('Hello, %s.' % name)
        Hello = type('Hello', (object,), dict(hello=fn))    # 创建Hello类 type原型: type(name, bases, dict)
        h = Hello()                           # 此时的h和上边的h一致


"""异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关"""
    
#-- #捕获异常: 
        try:
        except:                               # 捕获所有的异常 等同于except Exception:
        except name:                          # 捕获指定的异常
        except name, value:                   # 捕获指定的异常和额外的数据(实例)
        except (name1, name2):
        except (name1, name2), value:
        except name4 as X:
        else:                                 # 如果没有发生异常
        finally:                              # 总会执行的部分
    # 引发异常: raise子句(raise IndexError)
        raise                       # raise instance of a class, raise IndexError()
        raise                          # make and raise instance of a class, raise IndexError
        raise                                 # reraise the most recent exception

#-- Python3.x中的异常链: raise exception from otherException
    except Exception as X:
        raise IndexError('Bad') from X
        
#-- assert子句: assert , 
    assert x < 0, 'x must be negative'
    
#-- with/as环境管理器:作为常见的try/finally用法模式的替代方案
    with expression [as variable], expression [as variable]:
    # 例子:
        with open('test.txt') as myfile:
            for line in myfile: print(line)
    # 等同于:
        myfile = open('test.txt')
        try:
            for line in myfile: print(line)
        finally:
            myfile.close()

#-- 用户自定义异常: class Bad(Exception):.....
    """
    Exception超类 / except基类即可捕获到其所有子类
    Exception超类有默认的打印消息和状态 当然也可以定制打印显示:
    """
    class MyBad(Exception):
        def __str__(self):
            return '定制的打印消息'
    try:
        MyBad()
    except MyBad as x:
        print(x)
    
#-- 用户定制异常数据
    class FormatError(Exception):
        def __init__(self, line ,file):
            self.line = line
            self.file = file
    try:
        raise FormatError(42, 'test.py')
    except FormatError as X:
        print('Error at ', X.file, X.line)
    # 用户定制异常行为(方法):以记录日志为例
    class FormatError(Exception):
        logfile = 'formaterror.txt'
        def __init__(self, line ,file):
            self.line = line
            self.file = file
        def logger(self):
            open(self.logfile, 'a').write('Error at ', self.file, self.line)
    try:
        raise FormatError(42, 'test.py')
    except FormatError as X:
        X.logger()

#-- 关于sys.exc_info:允许一个异常处理器获取对最近引发的异常的访问
    try:
        ......
    except:
        # 此时sys.exc_info()返回一个元组(type, value, traceback)
        # type:正在处理的异常的异常类型
        # value:引发的异常的实例
        # traceback:堆栈信息
        
#-- 异常层次
    BaseException
    +-- SystemExit
    +-- KeyboardInterrupt
    +-- GeneratorExit
    +-- Exception
        +-- StopIteration
        +-- ArithmeticError
        +-- AssertionError
        +-- AttributeError
        +-- BufferError
        +-- EOFError
        +-- ImportError
        +-- LookupError
        +-- MemoryError
        +-- NameError
        +-- OSError
        +-- ReferenceError
        +-- RuntimeError
        +-- SyntaxError
        +-- SystemError
        +-- TypeError
        +-- ValueError
        +-- Warning

    
"""Unicode和字节字符串---Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串"""

#-- Python的字符串类型
    """Python2.x"""
    # 1.str表示8位文本和二进制数据
    # 2.unicode表示宽字符Unicode文本
    """Python3.x"""
    # 1.str表示Unicode文本(8位或者更宽)
    # 2.bytes表示不可变的二进制数据
    # 3.bytearray是一种可变的bytes类型

#-- 字符编码方法
    """ASCII"""                   # 一个字节,只包含英文字符,0到127,共128个字符,利用函数可以进行字符和数字的相互转换
    ord('a')                      # 字符a的ASCII码为97,所以这里返回97
    chr(97)                       # 和上边的过程相反,返回字符'a'
    """Latin-1"""                 # 一个字节,包含特殊字符,0到255,共256个字符,相当于对ASCII码的扩展
    chr(196)                      # 返回一个特殊字符:Ä
    """Unicode"""                 # 宽字符,一个字符包含多个字节,一般用于亚洲的字符集,比如中文有好几万字
    """UTF-8"""                   # 可变字节数,小于128的字符表示为单个字节,128到0X7FF之间的代码转换为两个字节,0X7FF以上的代码转换为3或4个字节
    # 注意:可以看出来,ASCII码是Latin-1和UTF-8的一个子集
    # 注意:utf-8是unicode的一种实现方式,unicode、gbk、gb2312是编码字符集
    
#-- 查看Python中的字符串编码名称,查看系统的编码
    import encodings
    help(encoding)
    import sys
    sys.platform                  # 'win64'
    sys.getdefaultencoding()      # 'utf-8'
    sys.getdefaultencoding()      # 返回当前系统平台的编码类型
    sys.getsizeof(object)         # 返回object占有的bytes的大小
    
#-- 源文件字符集编码声明: 添加注释来指定想要的编码形式 从而改变默认值 注释必须出现在脚本的第一行或者第二行
    """说明:其实这里只会检查#和coding:utf-8,其余的字符都是为了美观加上的"""
    # _*_ coding: utf-8 _*_
    # coding = utf-8
    
#-- #编码: 字符串 --> 原始字节       #解码: 原始字节 --> 字符串

#-- Python3.x中的字符串应用
    s = '...'                     # 构建一个str对象,不可变对象
    b = b'...'                    # 构建一个bytes对象,不可变对象
    s[0], b[0]                    # 返回('.', 113)
    s[1:], b[1:]                  # 返回('..', b'..')
    B = B"""
        xxxx
        yyyy
        """
    # B = b'\nxxxx\nyyyy\n'
    # 编码,将str字符串转化为其raw bytes形式:
        str.encode(encoding = 'utf-8', errors = 'strict')
        bytes(str, encoding)
    # 编码例子:
        S = 'egg'
        S.encode()                    # b'egg'
        bytes(S, encoding = 'ascii')  # b'egg'
    # 解码,将raw bytes字符串转化为str形式:
        bytes.decode(encoding = 'utf-8', errors = 'strict')
        str(bytes_or_buffer[, encoding[, errors]])
    # 解码例子:
        B = b'spam'
        B.decode()                # 'spam'
        str(B)                    # "b'spam'",不带编码的str调用,结果为打印该bytes对象
        str(B, encoding = 'ascii')# 'spam',带编码的str调用,结果为转化该bytes对象
    
#-- Python2.x的编码问题
    u = u'汉'
    print repr(u)                 # u'\xba\xba'
    s = u.encode('UTF-8')
    print repr(s)                 # '\xc2\xba\xc2\xba'
    u2 = s.decode('UTF-8')
    print repr(u2)                # u'\xba\xba'
    # 对unicode进行解码是错误的
    s2 = u.decode('UTF-8')        # UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
    # 同样,对str进行编码也是错误的
    u2 = s.encode('UTF-8')        # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 0: ordinal not in range(128)

#-- bytes对象
    B = b'abc'
    B = bytes('abc', 'ascii')
    B = bytes([97, 98, 99])
    B = 'abc'.encode()
    # bytes对象的方法调用基本和str类型一致 但:B[0]返回的是ASCII码值97, 而不是b'a'
    
#-- #文本文件: 根据Unicode编码来解释文件内容,要么是平台的默认编码,要么是指定的编码类型
    # 二进制文件:表示字节值的整数的一个序列 open('bin.txt', 'rb')
    
#-- Unicode文件
    s = 'A\xc4B\xe8C'             # s = 'A?BèC'  len(s) = 5
    #手动编码
        l = s.encode('latin-1')   # l = b'A\xc4B\xe8C'  len(l) = 5
        u = s.encode('utf-8')     # u = b'A\xc3\x84B\xc3\xa8C'  len(u) = 7
    #文件输出编码
        open('latindata', 'w', encoding = 'latin-1').write(s)
        l = open('latindata', 'rb').read()                        # l = b'A\xc4B\xe8C'  len(l) = 5
        open('uft8data', 'w', encoding = 'utf-8').write(s)
        u = open('uft8data', 'rb').read()                         # u = b'A\xc3\x84B\xc3\xa8C'  len(u) = 7
    #文件输入编码
        s = open('latindata', 'r', encoding = 'latin-1').read()   # s = 'A?BèC'  len(s) = 5
        s = open('latindata', 'rb').read().decode('latin-1')      # s = 'A?BèC'  len(s) = 5
        s = open('utf8data', 'r', encoding = 'utf-8').read()      # s = 'A?BèC'  len(s) = 5
        s = open('utf8data', 'rb').read().decode('utf-8')         # s = 'A?BèC'  len(s) = 5
        

"""其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他"""

#-- Python实现任意深度的赋值 例如a[0] = 'value1'; a[1][2] = 'value2'; a[3][4][5] = 'value3'
    class MyDict(dict):
        def __setitem__(self, key, value):                 # 该函数不做任何改动 这里只是为了输出
            print('setitem:', key, value, self)
            super().__setitem__(key, value)
        def __getitem__(self, item):                       # 主要技巧在该函数
            print('getitem:', item, self)                  # 输出信息
            # 基本思路: a[1][2]赋值时 需要先取出a[1] 然后给a[1]的[2]赋值
            if item not in self:                           # 如果a[1]不存在 则需要新建一个dict 并使得a[1] = dict
                temp = MyDict()                            # 新建的dict: temp
                super().__setitem__(item, temp)            # 赋值a[1] = temp
                return temp                                # 返回temp 使得temp[2] = value有效
            return super().__getitem__(item)               # 如果a[1]存在 则直接返回a[1]
    # 例子:
        test = MyDict()
        test[0] = 'test'
        print(test[0])
        test[1][2] = 'test1'
        print(test[1][2])
        test[1][3] = 'test2'
        print(test[1][3])

#-- Python中的多维数组
    lists = [0] * 3                                        # 扩展list,结果为[0, 0, 0]
    lists = [[]] * 3                                       # 多维数组,结果为[[], [], []],但有问题,往下看
    lists[0].append(3)                                     # 期望看到的结果[[3], [], []],实际结果[[3], [3], [3]],原因:list*n操作,是浅拷贝,如何避免?往下看
    lists = [[] for i in range(3)]                         # 多维数组,结果为[[], [], []]
    lists[0].append(3)                                     # 结果为[[3], [], []]
    lists[1].append(6)                                     # 结果为[[3], [6], []]
    lists[2].append(9)                                     # 结果为[[3], [6], [9]]
    lists = [[[] for j in range(4)] for i in range(3)]     # 3行4列,且每一个元素为[]

 

 

你可能感兴趣的:(Python)