虽然都通过了，但是脑子里没有这个概念，不清楚安装的软件包具体是做什么用的，没有一个清晰的认识
项目骨架也完成了，没有错误，模糊了解了下做新项目骨架，需要修改哪些东西和内容，使其他文件能正确连接，还是半懂状态，只是模模糊糊有个概念。
之前放了一个python里的代码及作用，功能解释，现在更新一下：
| 序号 | 符号 | 名字 | 作用 | 备注 |
| 1 | Notepad++ | 代码编辑器 | ||
| 2 | PowerShell | window7里面类似cmd的命令工具，比cmd功能更强大 | ||
| 3 | 在终端创建一个目录 | new-item -path c:/ -name 123 -type directory | 在c盘创建一个名叫123的文件夹 | |
| 4 | .py | python文件格式 | 用来存储python代码 | |
| 5 | SyntaxError | 语法错误 | ||
| 6 | ^ | 插入符 | 用来指示出错的位置，CTRL+6 | |
| 7 | # -*- coding: utf-8 -*- | 使用utf-8编码格式 | 防止出现ASCII编码错误，或者其他编码格式的错误 | 中国地区默认使用此编码格式 |
| 8 | # | octothorpe，井字符 | 提示软件，忽略符号后面那一行的内容，多用来写注释 | |
| 9 | IDLE | python自带的调试模块 | ||
| 10 | invalid syntax | 无效语法 | ||
| 11 | + | 加号 | 做加法运算 | |
| 12 | - | 减号 | 做减法运算 | |
| 13 | / | 除号 | 做除法运算 | 1、python2.0版本默认是整除模式，7/4=1，小数点后忽略，可加浮点数来保留小数点后面的数字 2、python3.0版本默认是普通算法，不再整除，7/4=1.75 |
| 14 | // | 地板除 | 地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商 既小数点后的值不保留 | 9//2 = 4 而 9.0//2.0 = 4.0 |
| 15 | * | 乘号 | 做乘法运算 | **是幂次方的意思 |
| 16 | % | 百分比 | 做取余运算，如4%2等同于4除以2还剩余0，所以4%2=0 | x除以y还剩余j，j的值就是% |
| 17 | < | 小于 | 一般用于条件判断，正确返回True，错误返回False | |
| 18 | > | 大于 | 一般用于条件判断，正确返回True，错误返回False | |
| 19 | <= | 小于等于 | 一般用于条件判断，正确返回True，错误返回False | |
| 20 | >= | 大于等于 | 一般用于条件判断，正确返回True，错误返回False | |
| 21 | TRUE | 真 | 逻辑术语 | |
| 22 | FALSE | 假 | 逻辑术语 | |
| 23 | and | 与 | 逻辑术语 | |
| 24 | or | 或 | 逻辑术语 | |
| 25 | not | 非 | 逻辑术语 | |
| 26 | !=或<> | 不等于 | 逻辑术语 | |
| 27 | float | 浮点数格式 | floating point number，有小数点的数，如2.0，1.25等 | |
| 28 | PEMDAS | 运算优先级 | 括号Parentheses > 指数Exponents > 乘Multiplication > 除Division > 加Addition > 减Subtraction | |
| 29 | variable | 变量 | 指代某个东西的名字，可以是数字，字母，下划线， 变量名要以字母开头 | |
| 30 | _ | 下划线 | 在变量里通常用作假想的空格，用来隔开单词 | |
| 31 | int | 整数格式 | ||
| 32 | = | 单等号 | 用来取名，将右边的值赋给左边的变量名 | |
| 33 | == | 双等号 | 检查左右两边是否相等 | |
| 34 | += | 递增 | 如a+=b等同于a=a+b | |
| 35 | -= | 递减 | 如a-=b等同于a=a-b | |
| 36 | *= | 递乘 | 如a*=b等同于a=a*b | |
| 37 | /= | 递除 | 如a/=b等同于a=a/b | |
| 38 | //= | 递地板除 | 地板除，并分配一个值，执行地板除对操作和赋值给左操作数 c //= a 相当于 c = c // a | |
| 39 | %= | 递取余 | 如a%=b等同于a=a%b | |
| 40 | **= | 递幂 | 如a**=b等同于a=a**b | |
| 41 | format string | 格式化字符串 | 用引号把文本引用起来 | |
| 42 | %s | 输出一个字符串 | print（"I‘m %s father." % your） 输出显示为：I'm your father. | %s这类符号属于格式控制工具，它们告诉python把右边的变量带到字符串中，并且把变量的值放到%s所在的位置 |
| 43 | %c | 输出一个字符 | ASCII编码格式 | |
| 44 | %f或%F | 输出数字 | 以小数形式输出(小数部分自然截断) | |
| 45 | %d或%i | 输出整数 | 有符号的10进制整数 | |
| 46 | %u | 输出整数 | 无符号的10进制整数 | |
| 47 | %r | 输出实际情况的形式 | 不管什么都显示出来，显示过程不做修改 | %r 打印出来的是程序员写在脚本里的东西， %s 打印的是作为用户应该看到的东西 |
| 48 | %% | 输出一个“%”号 | ||
| 49 | %o | 无符号的8进制整数 | ||
| 50 | %x | 无符号的16进制整数 | ||
| 51 | %X | 无符号的16进制大写整数 | ||
| 52 | %e | 输出浮点数 | 科学计数法 | |
| 53 | %E | 输出浮点数 | 科学计数法，E代替e | |
| 54 | %g | 输出浮点数 | 根据值的大小，用%e 或者 %f 显示 | |
| 55 | %G | 类似 %g | ||
| 56 | %p | 指针 | 用16进制打印值的内存地址 | |
| 57 | %n | 存储输出的字符的数量，放进参数列表的下一个变量中 | ||
| 58 | round（） | 四舍五入 | ||
| 59 | \n | 换行符 | 换行 | |
| 60 | \ | 反斜杠 | 用来转义，可以将难以打印的字符放到字符串，比如“\\”打印一个\ | |
| 61 | \t | 水平制表符 | ||
| 62 | \v | 垂直制表符 | ||
| 63 | \\ | 双反斜杠 | 输出一个“\”,也可以用来做代码的换行符，表示下面的代码和上面的代码是一行的 | Python同样支持多行写一条语句，Python使用“\\”作为换行符。在实践中，一条语句写在多行也是非常常见的 【例】把SQL语句作为参数传递给函数，由于SQL的语句一般非常长，为了阅读方便，因此需要换行书写 # 字符串的换行 # 写法一 sql = "select id,name \\ from dept \\ where name = 'A'" print sql |
| 64 | \' | 单引号 | 输出一个单引号 | |
| 65 | \" | 双引号 | 输出一个双引号 | |
| 66 | \a | 响铃符 | ||
| 67 | \b | 退格符 | ||
| 68 | \f | 进纸符 | ||
| 69 | \N{name} | unicode数据库的字符名，其中name是它的名字，仅适用于unicode | ||
| 70 | \r | 回车符 | ||
| 71 | \uxxxx | 值为16位16进制值xxxx的字符，仅适用于unicode | ||
| 72 | \Uxxxxxxxx | 值为32位16进制值xxxxxxxx的字符，仅适用于unicode | ||
| 73 | \ooo | 值为8进制值的ooo字符 | ||
| 74 | \xhh | 值为16进制数hh的字符 | ||
| 75 | break | 中断循环 | 函数语句，常用于循环函数内 | |
| 76 | input | 输入命令 | input（），提取在括号里的内容 | 2.0版本还有一个raw_print， 3.0版本统一用input |
| 77 | 输出命令 | print（），输出括号里的内容 | 2.0版本用print xxx， 3.0版本用print（xxx） | |
| 78 | open | 打开命令 | open（），打开括号里的文件 | |
| 79 | file | 是file类的构造函数,参数和内置的open()函数相同,在打开文件时更推荐使用open(),所以更多用于测试文件类型的测试:isinstance(f,file) | ||
| 80 | os | os模块 | Python os模块包含普遍的操作系统功能 | |
| 81 | os.name | os模块 | 输出字符串指示正在使用的平台。如果是window 则用'nt'表示，对于Linux/Unix用户，它是'posix' | |
| 82 | os.getcwd() | os模块 | 函数得到当前工作目录，即当前Python脚本工作的目录路径 | |
| 83 | os.listdir() | os模块 | 返回指定目录下的所有文件和目录名 | 比如： >>> os.listdir(os.getcwd()) ['Django', 'DLLs', 'Doc', 'include', 'Lib', 'libs', 'LICENSE.txt', 'MySQL-python-wininst.log', 'NEWS.txt', 'PIL-wininst.log', 'python.exe', 'pythonw.exe', 'README.txt', 'RemoveMySQL-python.exe', 'RemovePIL.exe', 'Removesetuptools.exe', 'Scripts', 'setuptools-wininst.log', 'tcl', 'Tools', 'w9xpopen.exe'] >>> |
| 84 | os.remove() | os模块 | 删除一个文件 | |
| 85 | os.system() | os模块 | 运行shell命令 | 如下： >>> os.system('dir') 0 >>> os.system('cmd') #启动dos |
| 86 | os.sep | os模块 | 可以取代操作系统特定的路径分割符 | |
| 87 | os.linesep | os模块 | 字符串给出当前平台使用的行终止符 | 如下： >>> os.linesep '\r\n' #Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。 >>> os.sep '\\' #Windows >>> |
| 88 | os.path.split() | os模块 | 函数返回一个路径的目录名和文件名 | 如下： >>>os.path.split('C:\\Python25\\abc.txt') ('C:\\Python25', 'abc.txt') |
| 89 | os.path.isfile() os.path.isdir() | os模块 | 函数分别检验给出的路径是一个文件还是目录 | 如下： >>> os.path.isdir(os.getcwd()) True >>> os.path.isfile('a.txt') False |
| 90 | os.path.exists() | os模块 | 函数用来检验给出的路径是否真地存在 | 如下： >>> os.path.exists('C:\\Python25\\abc.txt') False >>> os.path.exists('C:\\Python25') True >>> |
| 91 | os.path.abspath() | os模块 | 获得绝对路径 | |
| 92 | os.path.normpath(path) | os模块 | 规范path字符串形式 | |
| 93 | os.path.getsize(name) | os模块 | 获得文件大小，如果name是目录返回0L | |
| 94 | os.path.splitext() | os模块 | 分离文件名与扩展名 | 如下： >>> os.path.splitext('a.txt') ('a', '.txt') |
| 95 | os.path.join(path,name) | os模块 | 连接目录与文件名或目录 | 如下： >>> os.path.join('c:\\Python','a.txt') 'c:\\Python\\a.txt' >>> os.path.join('c:\\Python','f1') 'c:\\Python\\f1' >>> |
| 96 | os.path.basename(path) | os模块 | 返回文件名 | 如下： >>> os.path.basename('a.txt') 'a.txt' >>> os.path.basename('c:\\Python\\a.txt') 'a.txt' >>> |
| 97 | os.path.dirname(path) | os模块 | 返回文件路径 | 如下： >>>os.path.dirname('c:\\Python\\a.txt') 'c:\\Python' |
| 98 | sys | sys模块 | sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分 | |
| 99 | argv | sys模块 | 在解释器启动后, argv 列表包含了传递给脚本的所有参数, 列表的第一个元素为脚本自身的名称. | |
| 100 | sys.platform | sys模块 | 返回当前平台出现如： "win32" "linux2" 等 | |
| 101 | .read() | 读取文件 | 如print（txt.read（））,可以把读取的结果赋值给变量 | read命令之后，默认会关闭文件 |
| 102 | .close | 关闭文件 | 在open，read，write文件后，都要执行close关闭文件 | |
| 103 | .readline() | 读取一行 | ||
| 104 | .truncate() | 清空文件里的内容 | ||
| 105 | .write() | 写入文件 | 把括号里的内容写入到文件里 | |
| 106 | .seek（0） | 指针 | 括号为0表示指针回到文件开头的位置，括号内的数值可以自己设定 | |
| 107 | "w" | 写入模式 | 给open命令附加使用，如open(txt,'w'),打开txt文件进入写入模式 | open命令对于文件的写入操作态度是安全第一，所以只有特别指定之后，才会进入操作模式 |
| 108 | “r“ | 读取模式 | 给open命令附加使用，如open(txt,'r'),打开txt文件进入读取模式 | open函数默认读取模式 |
| 109 | ”a“ | 追加模式 | 给open命令附加使用，如open(txt,'a'),打开txt文件进入追加写入模式 | |
| 110 | ”w+" | 读写模式 | ||
| 111 | "r+" | 读写模式 | ||
| 112 | "a+" | 读写追加模式 | ||
| 113 | exists（） | 确认文件是否存在 | 将括号里的文件名作为字符串参数，确认文件是否存在，存在返回True，反之False | 需要先用import调用出来 |
| 114 | import | 调用命令 | 通常和from配合使用，比如from sys import argv，从sys的模块中调用argv函数 | |
| 115 | len() | 获取长度 | 以数的形式返回括号里的字符串长度 如果括号里是列表，则返回列表的元素个数 | |
| 116 | def | 定义或者建立函数 | 格式如下：def 函数名（参数）： 函数取名方式同变量取名方式， 参数可以单个或者多个，也可以为none，用逗号隔开， 结尾用冒号，然后开始下一行缩进 | |
| 117 | return | 返回函数值 | 用于定义函数内容的最后，作用是将变量设置为“一个函数的值” 在def函数结束的时候，return函数可以把def函数的结果赋给变量 | def add(x,y): print(x+y) return x+y |
| 118 | split() | 分割字符 | 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串 split()方法语法： str.split(str="", num=string.count(str)). 参数 str -- 分隔符，默认为空格。 num -- 分割次数。 返回值 返回分割后的字符串列表。 | str = "Line1-abcdef \nLine2-abc \nLine4-abcd"; print str.split( ); print str.split(' ', 1 ); 以上实例输出结果如下： ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] ['Line1-abcdef', '\nLine2-abc \nLine4-abcd'] |
| 119 | sorted() | 排序命令 | 默认是升序排列 | >>> sorted([5, 2, 3, 1, 4]) [1, 2, 3, 4, 5] |
| 120 | pop() | 列表删除,移除字典数据 | 删除指定给定键所对应的值，返回这个值并从字典中把它移除。 一般删除对象方法会直接将元素删除，而pop()方法在删除指定对象时，会返回要删除元素的值。可以理解为一个提示作用，提示你删除的是哪一个元素. 注意字典pop()方法与列表pop()方法作用完全不同。 | 字典pop（）删除： >>> x = {'a':1,'b':2} >>> x.pop('a') 1 >>> x {'b': 2} 列表pop（）删除： list.pop(index=-1) pop()括号内参数是，要删除对象的索引。如果为空则默认为-1最后一项 >>> x = [1,2,3,4] >>> x.pop() 4 >>>x [1,2,3] |
| 121 | if | 条件语句 | if语句为代码创建了一个分支，如果这个布尔值为真，就运行接下来的代码，反之跳过，最后一定要跟else语句 | |
| 122 | elif | 条件语句 | 条件子句，可多个存在，用来增加判断语句的条件判断 | else和elif语句也可以叫做子句，因为它们不能独立使用，两者都是出现在if、for、while语句内部的。else子句可以增加一种选择；而elif子句则是需要检查更多条件时会被使用，与if和else一同使用，elif是else if 的简写。 |
| 123 | else | 条件语句 | if判断为假时，执行else的代码 | 一个if语句中可以包含多个elif语句，但结尾只能有一个else语句 python中，可以在while和for循环中使用else子句，它只是在循环结束之后才会被执行，如果同时使用了break语句那么else子句块会被跳过。所以注意else子句和break语句不能同时使用！ |
| 124 | append | 添加元素 | 向列表的尾部添加一个新的元素。只接受一个参数 | append()用法示例： mylist = [1,2,0,'abc'] mylist.append(4) mylist [1, 2, 0, 'abc', 4] |
| 125 | extend | 添加元素 | 只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中 | extend()用法示例： mylist [1, 2, 0, 'abc', 4, 'haha'] mylist.extend(['lulu']) mylist [1, 2, 0, 'abc', 4, 'haha', 'lulu'] |
| 126 | range | 循环显示 | 循环显示括号里的元素，但不包含最后一个数 | range(0,6) 0 1 2 3 4 5 |
| 127 | while | 循环函数 | 检查一个布尔值的真假，执行完后再调回while的位置重新执行，直到while的值为False为止 | number = 233 running = True print('在1-300以内猜一个数字，猜对发车') while running: quess=int(input('输入一个数字:')) if quess == number: print('恭喜你，猜对了！') print('但是没有奖品。') running = False elif quess < number: print('你写的数太小了。') else: print('你写的数太大了。') print('游戏结束') input('press <enter>') |
| 128 | ordinal number | 序数 | 表示事物的次序，从1开始 | |
| 129 | cardinal number | 基数 | 表示可以任意抓去的数，从0开始 | |
| 130 | exit | 中断程序 | exit(0)表示正常中断程序，exit(1)表示发生错误 | |
| 131 | global | 全局声明 | global x ，该语句可以全局声明变量x的值， #而一般的变量的值仅在函数内部被声明， #在函数外部是不被承认的。 | def x(a):#注意括号里的a print('a=',a) a=2 print('函数内a的值被改变为',a) a=50 x(a)#注意括号里的a print('函数外的a值是',a) #下面是加global的效果 def x():#注意括号里没有a global a print('a=',a) a=2 print('函数内a的值被改变为',a) a=50 x()#注意括号里没有a print('函数外的a值是',a) |
| 132 | with...as… | 调用后再关闭 | 这个语法是用来代替传统的try...finally语法的。 基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。 紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法 | def opened(name): f = open(name) try: yield f finally: f.close() with opened('/tmp/a.txt') as f: for line in f.readlines(): print(line) |
| 133 | assert | 声明某个条件是真 | 如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这种情形下的理想语句。 当assert语句失败的时候，会引发一AssertionError。 | >>> mylist = ['item'] >>> assert len(mylist) >= 1 >>> mylist.pop() 'item' >>> assert len(mylist) >= 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError |
| 134 | pass | 什么也不做 | 1、空语句 do nothing 2、保证格式完整 3、保证语义完整 | if a>1: pass #我这里先不做任何处理，直接跳过，但是如果不写pass，就会语法错误 |
| 135 | yield | 生产 | yield可以用来为一个函数返回值塞数据，yield的代码叠代能力不但能打断函数执行还能记下断点处的数据，下次next书接上回，这正是递归函数需要的 | def fab(max): a,b = 0,1 while a < max: yield a a, b = b, a+b for i in fab(20): print i,",", ... 0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 ,… |
| 136 | except | 处理异常 | 使用try和except语句来捕获异常 在Python中，异常也是对象，可对它进行操作。所有异常都是基类 Exception的成员。所有异常都从基类Exception继承，而且都在exceptions模块中定义。Python自动将所有异常名称放在内建命名空间中，所以程序不必导入exceptions模块即可使用异常。一旦引发而且没有捕捉SystemExit异常，程序执行就会终止。如果交互式会话遇到一个未被捕捉的SystemExit异常，会话就会终止 | try...except用于处理问题语句，捕获可能出现的异常。try子句中的代码块放置可能出现异常的语句，except子句中的代码块处理异常。 演示try...except语句捕获IOError异常 try： file("hello.txt", "r") #如果文件不存在，引发异常 print "读文件" except IOError: #捕获IO异常 print "文件不存在" except： #其它异常 print "程序异常" |
| 137 | class | 某种类型集合的描述 | class 类名[(父类名)]:[成员函数及成员变量]，类名为这个类的名称，而父类名为可选，但定义父类名后，子类则拥有父类的相应属性和方法 | # 例：类的概念 class 人类: 名字 = '未命名' # 成员变量 def 说话(内容): # 成员函数 print 内容 # 成员变量赋初始值 某人 = 人类() # 定义一个人类对象某人 某人.名字 = "路人甲" 某人.说话 ('大家好') # 路人甲说话 >>> 大家好！ # 输出 |
| 138 | exec | 执行储存 | exec语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子。 >>> exec 'print "Hello World"' Hello World | 注意例子中exec语句的用法和eval_r(), execfile()是不一样的. exec是一个语句(就象print或while), 而eval_r()和execfile()则是内建函数. |
| 139 | in | 在…里… | 常和其他语句组合使用，如for..in…， 单独使用为条件判断，计算结果为true，如果它在指定找到变量的顺序，否则false x在y中，在这里产生一个1，如果x是序列y的成员 | >>> a=[1,2,3] >>> a [1, 2, 3] >>> d=[1,2,3] >>> d [1, 2, 3] >>> a in d False >>> d=[[1,2,3],1,2,3] >>> d [[1, 2, 3], 1, 2, 3] >>> a in d True |
| 140 | not in | 不在…里 | 计算结果为true，如果它不找到在指定的变量顺序，否则为false x不在y中，这里产生结果不为1，如果x不是序列y的成员 | |
| 141 | raise | 手工引发一个异常 | 当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。 | try: s = None if s is None: print "s 是空对象" raise NameError #如果引发NameError异常，后面的代码将不能执行 print len(s) except TypeError: print "空对象没有长度" |
| 142 | countinue | 跳出循环 | continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。continue语句使用在用在while和for循环中 | Python使用 continue 语句跳出循环，而break跳出整个循环 |
| 143 | finally | 异常处理 | 有finally关键字的时候,Python遇到错误在向你甩出错误之前还会留一口气先执行完finally里面的语句 | try块里的代码不管有没异常 finally块的语句都会执行 try: f = open('我为什么是一个文件.txt', 'w') print(f.write('我存在了！')) sum = 1 + '1' #异常来了后面的语句就不会执行了 f就没释放 f.close() except (OSError, TypeError): print('出错了T_T') finally: f.close() #放在这里是保证这句话不过有没异常都会执行 f就会释放 |
| 144 | is | 判断归属 | Python中的对象包含三要素：id、type、value 其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值 is判断的是a对象是否就是b对象，是通过id来判断的 ==判断的是a对象的值是否和b对象的值相等，是通过value来判断的 计算结果为true，如果操作符两侧的变量指向相同的对象，否则为false x是y，这里结果是1，如果id（x）的值为id（y） | >>> a = 1 >>> b = 1.0 >>> a is b False >>> a == b True >>> id(a) 12777000 >>> id(b) 14986000 >>> a = 1 >>> b = 1 >>> a is b True >>> a == b True >>> id(a) 12777000 >>> id(b) 12777000 |
| 145 | is not | 计算结果为false，如果两侧的变量操作符指向相同的对象，否则为true x不为y，这里结果不是1，当id（x）不等于id（y） | ||
| 146 | for | 循环控制语句 | for语句是python中的循环控制语句。可用来遍历某一对象，还具有一个附带的可选的else块，主要用于处理for语句中包含的break语句 如果for循环未被break终止，则执行else块中的语句。 break 在需要时终止for循环 continue 跳过位于其后的语句，开始下一轮循环 | for语句的格式如下： >>>for <> in <对象集合>： ... if <条件>: ... break ... if <条件>: ... continue ... <其他语句> ...else: ... <> ... |
| 147 | lambda | 匿名函数 | lambda函数也叫匿名函数，即函数没有具体的名称,而用def创建的方法是有名称的 lambda [arg1[,arg2,arg3....argN]]:expression lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象 lambda函数只是创建简单的函数对象，是一个函数的单行版本，但是这种语句由于性能的原因，调用的时候绕过函数的栈分配 lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量 lambda它只是一个表达式，而def则是一个语句。lambda表达式运行起来像一个函数，当被调用时创建一个框架对象 | def add(x,y):return x+y add2 = lambda x,y:x+y print add2(1,2) #3 def sum(x,y=10):return x+y sum2 = lambda x,y=10:x+y print sum2(1) #11 print sum2(1,100) #101 1、对于单行函数，使用lambda可以省去定义函数的过程，让代码更加精简。 2、在非多次调用的函数的情况下，lambda表达式即用既得，提高性能 注意：如果for..in..if能做的，最好不要选择lambda |
| 148 | try | 处理 | python的try语句有两种风格 一：种是处理异常（try/except/else） 二：种是无论是否发生异常都将执行最后的代码（try/finally） | try语句子句形式表 except: 捕获所有异常 except name: 只捕获特定的异常 except name,value: 捕获异常和它的附加数据（将异常的信息保存到value，） except (name1,name2): 捕获任何列出的异常 else: 如果没有异常 finally: 总是执行 |
| 149 | try…except…else | 处理异常 | try/except/else风格 try: <语句> #运行别的代码 except <名字>： <语句> #如果在try部份引发了'name'异常 except <名字>，<数据>: <语句> #如果引发了'name'异常，获得附加的数据 else: <语句> #如果没有异常发生 | try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。 1、如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。 2、如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。 3、如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。 |
| 150 | try…finally | 处理结束后总是执行finally的语句 | try/finally风格 try: <语句> finally: <语句> #退出try时总会执行 | python总会执行finally子句，无论try子句执行时是否发一异常。 1、如果没有发生异常，python运行try子句，然后是finally子句，然后继续。 2、如果在try子句发生了异常，python就会回来执行finally子句，然后把异常递交给上层try，控制流不会通过整个try语句。 当你想无论是否发生异常都确保执行某些代码时，try/finally是有用的。 这个在打开文件的时候有用 finally总是在最后close()文件 |
| 151 | () | 元组 | tuple（元祖）用小括号 元祖也是一种有序列表，和list非常类似，不同点是tuple一旦定义了就不可修改，在一定意义上这也提高了代码的安全性，查询方法和list一样，使用的时候能用tuple的就用tuple。 在定义只有一个元素的元祖时加入"逗号"以免产生和数学运算的歧义 | 可变的tuple 当元祖内部放一个列表的时候，这个元祖中的列表的值就可以变化了，实际上tuple并没有改变，变的是内部list的值 |
| 152 | [] | 数组，列表 | list（列表）用方括号 列表是Python的一种内置数据类型，list是一种有序的集合，可以随时添加和删除其中的元素。 获取list中的元素用角标获取，角标可以使用正角标，也可以使用负角标，越界时抛出IndexErro list中的元素的数据类型也可以不一样（就像Java一样），也可以在list内放另外一个list，这样也就形成了一个多维集合 | 只能使用数来获取列表的元素 list的方法 len(list) #获取lest长度 append() #末尾追加元素 L.insert(index,var) L.pop(var) #返回最后一个元素，并从list中删除之 L.remove(var) #删除第一次出现的该元素 L.count(var) #该元素在列表中出现的个数 L.index(var) #该元素的位置,无则抛异常 L.extend(list) #追加list，即合并list到L上 L.sort() #排序 L.reverse() #倒序 list 操作符:,+,*，关键字del a[1:] #片段操作符，用于子list的提取 [1,2]+[3,4] #为[1,2,3,4]。同extend() [2]*4 #为[2,2,2,2] del L[1] #删除指定下标的元素 del L[1:3] #删除指定下标范围的元素 list的复制 L1 = L #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的 L1 = L[:] #L1为L的克隆，即另一个拷贝 |
| 153 | {} | 字典 | Dictionary (字典) : 用{}来定义 dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'} 每一个元素是pair，包含key、value两部分。key是Integer或string类型，value 是任意类型。 键是唯一的，字典只认最后一个赋的键值 | D.get(key, 0) #同dict[key]，多了个没有则返回缺省值，0。[]没有则抛异常 D.has_key(key) #有该键返回TRUE，否则FALSE D.keys() #返回字典键的列表 D.values() D.items() D.update(dict2) #增加合并字典 D.popitem() #得到一个pair，并从字典中删除它。已空则抛异常 D.clear() #清空字典，同del dict D.copy() #拷贝字典 D.cmp(dict1,dict2) #比较字典，(优先级为元素个数、键大小、键值大小) #第一个大返回1，小返回-1，一样返回0 dictionary的复制 dict1 = dict #别名 dict2=dict.copy() #克隆，即另一个拷贝 |
| 154 | @ | 函数修饰符 | 修饰符必须出现在函数定义前一行，不允许和函数定义在同一行。也就是说＠A def f(): 是非法的。只可以在模块或类定义层内对函数进行修饰，不允许修修饰一个类。一个修饰符就是一个函数，它将被修饰的函数做为参数，并返回修饰后的同名函数或其它可调用的东西 | def spamrun(fn): def sayspam(*args): print "spam,spam,spam" return sayspam @spamrun def useful(a,b): print a**2+b**2 useful(3,4) 结果： spam，spam，spam |
| 155 | ： | 冒号 | 函数，循环，if条件，类定义等后面有block，block要缩进，因此这些语句后面要加上冒号，这是python的语法 | python的冒号和java、c中的{}是一样的 block是一组语句 |
| 156 | ； | 分号 | 在C、Java等语言的语法中规定，必须以分号作为语句结束的标识。Python也支持分号，同样用于一条语句的结束标识。但在Python中分号的作用已经不像C、Java中那么重要了，Python中的分号可以省略，主要通过换行来识别语句的结束。 | 如果要在一行中书写多条句，就必须使用分号分隔每个语句，否则Python无法识别语句之间的间隔 注意分号不是Python推荐使用的符号，Python倾向于使用换行符作为每条语句的分隔，简单直白是Python语法的特点。通常一行只写一条语句，这样便于阅读和理解程序。一行写多条语句的方式是不好的习惯 Python同样支持多行写一条语句，Python使用“\\”作为换行符。在实践中，一条语句写在多行也是非常常见的 |
| 157 | & | 二进制和复制操作了一下，结果，如果它存在于两个操作数 | a = 0011 1100 b = 0000 1101 (a & b) = 12 即 0000 1100 | |
| 158 | | | 二进制或复制操作了一个比特，如果它存在一个操作数中 | a = 0011 1100 b = 0000 1101 (a | b) = 61 即 0011 1101 | |
| 159 | ^ | 二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特 | a = 0011 1100 b = 0000 1101 (a ^ b) = 49 即 0011 0001 | |
| 160 | ~ | 二进制的补运算符是一元的，并有“翻转”位的效果 | a = 0011 1100 (~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数 | |
| 161 | << | 二进位向左移位运算符。左操作数的值左移由右操作数指定的位数 | a = 0011 1100 a << 2 = 240 即 1111 0000 | |
| 162 | >> | 二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动 | a = 0011 1100 a >> 2 = 15 即 0000 1111 | |
| 163 | . | 句点 | 处理句点后的命令 | 如：f.readline（）#读取f文件的一行内容 |
| 164 | dir | 返回某个类型的所有可用方法 | 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。 参数object：对象、变量、类型 | >>> dir(str) 或 dir("") ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> dir(list) 或 dir([]) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] |
| 165 | del | 删除 | del用于list列表操作，删除一个或者连续几个元素 | >>> a = [-1, 3, 'aa', 85] # 定义一个list >>> a [-1, 3, 'aa', 85] >>> del a[0] # 删除第0个元素 >>> a [3, 'aa', 85] >>> del a[2:4] # 删除从第2个元素开始，到第4个为止的元素。包括头不包括尾 >>> a [3, 'aa'] >>> del a # 删除整个list >>> a Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'a' is not defined |
| 166 | item | 遍历字典 | item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回 | person={'name':'lizhong','age':'26','city':'BeiJing','blog':'www.jb51.net'} for key,value in person.items(): print 'key=',key,'，value=',value |
| 167 | get | get相当于一条if...else...语句,参数k在字典中，字典将返回list[k]; 如果参数k不在字典中则返回参数d,如果K在字典中则返回k对应的value值 | l = {5:2,3:4} print l.get(3,0)返回的值是4 Print l.get(1,0)返回值是0 | |
| 168 | __new__ | __new__(cls, *args, **kwargs) 创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身 | ||
| 169 | __init__ | 初始化实例的值.这些值一般要供其他方法调用 __init__(self, *args, **kwargs) 创建完对象后调用，对当前对象的实例的一些初始化，无返回值,即在调用__new__之后，根据返回的实例初始化；注意，这里的第一个参数是self即对象本身【注意和new的区别】 | class O(object): def __init__(self, *args, **kwargs): print "init" super(O, self).__init__(*args, **kwargs) def __new__(cls, *args, **kwargs): print "new", cls return super(O, cls).__new__(cls, *args, **kwargs) def __call__(self, *args, **kwargs): print "call" oo = O() print "________" oo() | |
| 170 | __call__ | __call__(self, *args, **kwargs) 如果类实现了这个方法，相当于把这个类型的对象当作函数来使用，相当于重载了括号运算符 | ||
| 171 | __main__ | 模块，xxx.py文件本身 | 函数名main，也可以是其他任意的，你所设置的名字 被直接执行时，对应的模块名就是__main__了 可以在 if __name__ == “__main__”: 中添加你自己想要的，用于测试模块，演示模块用法等代码。 作为模块，被别的Python程序导入（import）时，模块名就是本身文件名xxx了 | python代码，是可以直接一行行写出来，然后去运行，是可以的。但是这只是针对我们的小程序来说的 更多的Python代码，是写成更加通用的，可以被调用的，可以重复利用的，模块的形式； 所以都是写在对应的函数里面的。 而作为模块，就是上面的解释中的： 模块第一次被导出（import）后，系统会自动为其创建一个域名空间（namespace）； （模块，都是有自己的名字的）此处的脚本的主模块的名字，始终都叫做__main__ |
| 172 | __name__ | 表示模块，类等的名字 | 如果是放在Modules模块中，就表示是模块的名字 如果是放在Classs类中，就表示类的名字 | |
| 173 | object | 对象 | 对象(object)的变量由类的每个对象所拥有, 每个对象都包含自己的一份拷贝, 不会影响其他对象 | 2.x 里 object 是一个较新基类 3.x里object已经做为所有东西的基类了 |
| 174 | class | 类 | 类(class)的变量是所有对象共享使用, 只有一个拷贝, 所有对象修改, 都可以被其他对象所见 | |
| 175 | instance | 实例 | 让python创建一个时得到的东西 | |
| 176 | self | 在类的函数里，self指代被访问的对象或者实例的一个变量 | ||
| 177 | inheritance | 继承 | 指一个类可以继承另一个类的特性，和父子关系类似 | |
| 178 | composition | 组合 | 指一个类可以将别的类作为它的部件构建起来，有点像车子和车轮的关系 | |
| 179 | attribute | 属性 | 类的一个属性，它来自于组合，而且通常是一个变量 | |
| 180 | is-a | 是什么 | 用来描述继承关系，如Salmon is-a Fish 鲑鱼是一种鱼 | |
| 181 | has-a | 有什么 | 用来描述某个东西是由另外一些东西组成的，或者某个东西有某个特征，如Salmon has-a mouth 鲑鱼有一张嘴 | |
| 182 | class x(y) | 创建一个叫x的类，它是y的一种 | ||
| 183 | class x(object): def __init__(self,J): | 创建一个叫x的类，它是对象的一种 类x有一个__init__接收self和J作为参数 self为变量或者对象本身，J是输入的参数值 | 附近标黄色的这几个函数，里面的x,y,m,j,k,q, 都是可以任意填入的参数 | |
| 184 | class x(object): def M(self,J): | 类x有一个函数名字为M，它接收self和J作为参数 | ||
| 185 | foo = x() | 将foo设为类x的一个实例 | ||
| 186 | foo.M(J) | 从foo中找到函数M，并使用self和J参数调用它 | ||
| 187 | foo.K = Q | 从foo中获取K属性，并将其设为Q | ||
| 188 | urlopen() | 创建一个类文件对象为指定的 url 来读取 urlopen返回一个类文件对象，他提供了如下方法： 参数 url 表示远程数据的路径，一般是 http 或者 ftp 路径。 参数 data 表示以 get 或者 post 方式提交到 url 的数据。 参数 proxies 表示用于代理的设置。 read() , readline() , readlines()，fileno()和close()：这些方法的使用与文件对象完全一样。 info()：返回一个httplib.HTTPMessage 对象，表示远程服务器返回的头信息。 getcode()：返回Http状态码，如果是http请求，200表示请求成功完成;404表示网址未找到。 geturl()：返回请求的url地址。 | 创建一个表示远程url的类文件对象，然后像本地文件一样操作这个类文件对象来获取远程数据。参数url表示远程数据的路径，一般是网址;参数data表示以post方式提交到url的数据(玩过web的人应该知道提交数据的两种方式：post与get。如果你不清楚，也不必太在意，一般情况下很少用到这个参数);参数proxies用于设置代理(这里不详细讲怎么使用代理，感兴趣的看客可以去翻阅Python手册urllib模块) | |
| 189 | strip() | 声明：s为字符串，rm为要删除的字符序列 s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符 s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符 s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符 | 1. 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ') >>> a = ' 123' >>> a.strip() '123' >>> a='\t\tabc' 'abc' >>> a = 'sdff\r\n' >>> a.strip() 'sdff' 2.这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉 >>> a = '123abc' >>> a.strip('21') '3abc' 结果是一样的 >>> a.strip('12') '3abc' | |
| 190 | capitalize() | 返回字符串的一个副本，只有它的第一个字母大写。对于8位的字符串，这个方法与语言环境相关。 | str = "this is string example....wow!!!"; print "str.capitalize() : ", str.capitalize() str.capitalize() : This is string example....wow!!! | |
| 191 | count() | 返回子串在指定范围内出现的次数 str.count(sub, start=0,end=len(string)) | str = "this is string example....wow!!!" sub = "i" print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40) sub = "wow" print "str.count(sub) : ", str.count(sub) 结果显示 str.count(sub, 4, 40) : 2 str.count(sub, 4, 40) : 1 | |
| 192 | endswith() | endswith() 判断在指定范围内，是否以子串结束 | str = "this is string example....wow!!!" suffix = "wow!!!" print str.endswith(suffix) print str.endswith(suffix,20) suffix = "is" print str.endswith(suffix, 2, 4) print str.endswith(suffix, 2, 6) 显示结果 True True True False | |
| 193 | index() | index()返回子串在指定范围内首次出现的位置，未查到抛出异常 str.index(str, beg=0end=len(string)) | str = "this is string example....wow!!!" str = "exam" print str.index(str) print str.index(str, 10) print str.index(str, 40) 显示结果 15 15 Traceback (most recent call last): File "test.py", line 8, in print str.index(str, 40); ValueError: substring not found | |
| 194 | isalnum() | isalnum()判断字符串是否全是字母和数字（要么全是字母，要么全是数字，要么全是数字和字母） | str = "this2009"#这里不能有空格 print str.isalnum() str = "this is string example....wow!!!" print str.isalnum() 结果显示 True False | |
| 195 | isalpha() | isalpha()方法判断字符串内容全是字母 | str = "this"#这里不能有空格和数字 print str.isalpha() str = "this is string example....wow!!!" print str.isalpha() 结果显示 True False | |
| 196 | isdecimal() isnumeric() | isdecimal()和isnumeric()判断字符串是否全是数字，该字符串必须是unicode object | str = u"this2009" print str.isdecimal() str = u"23443434" print str.isdecimal() 显示结果 False True | |
| 197 | isdigit() | isdigit()判断字符串全部为数字 | str = "123456"#只能有数字 print str.isdigit() str = "this is string example....wow!!!" print str.isdigit() 显示结果 True False | |
| 198 | islower() isupper() | islower()判断字符串中所有的字母是否都是小写 isupper()判断字符串中所有的字母是否都是大写 | str = "THIS is string example....wow!!!" print str.islower() str = "this is string example....wow!!!" print str.islower() 结果显示 False True | |
| 199 | isspace() | isspace()判断字符串是否全是空白符 | str = " \t\n" print str.isspace() str = "This is string example....wow!!!" print str.isspace() 结果显示 True False | |
| 200 | istitle() | istitle()判断字符串中，每个单词的首字母是否都是大写 | str = "This Is String Example...Wow!!!" print str.istitle() str = "This is string example....wow!!!" print str.istitle() 结果显示 True False | |
| 201 | join() | join()通过特殊字符把字符串连接起来 | str = "-" seq = ("a", "b", "c") print str.join( seq ) 结果显示 a-b-c | |
| 202 | len(str) | len(str) 计算字符串的长度。 | ||
| 203 | str.lower() | str.lower()把所有的大写字母转成小写。 | ||
| 204 | str.upper() | str.upper()把所有的小写字母转成大写。 | ||
| 205 | swapcase() | swapcase() 方法是把字符串中的小写转成大写，大写转成小写 | ||
| 206 | lstrip() | lstrip()去除掉字符串左边规定的字符，默认是空格 | str = " this is string example....wow!!! " print str.lstrip() str = "88888888this is string example....wow!!!8888888" print str.lstrip('8') 结果显示 this is string example....wow!!! this is string example....wow!!!8888888 | |
| 207 | rstrip() | rstrip()去除掉字符串右边规定的字符，默认是空格 | ||
| 208 | strip() | strip()去除掉两边规定的字符，默认是空格 | ||
| 209 | max() | max()返回字符串中最大的字母，字母由小到大分别是从A到Z | str = "this is really a string example....wow!!!" print "Max character: " + max(str) str = "this is a string example....wow!!!" print "Max character: " + max(str) 结果显示 Max character: y Max character: x | |
| 210 | replace() | replace()用新字符替换旧字符 str.replace(old,new,[max]) max表示替换的个数 | str = "this is string example....wow!!! this is really string" print str.replace("is", "was") print str.replace("is", "was", 3) 结果显示 thwas was string example....wow!!! thwas was really string thwas was string example....wow!!! thwas is really string | |
| 211 | find() | find() 返回子串在指定范围内首次出现的位置，未查到返回-1 str.find(str, beg=0,end=len(string)) | str1 = "this is string example....wow!!!" str2 = "exam" print str1.find(str2) print str1.find(str2, 10) print str1.find(str2, 40) 结果显示 15 15 -1 | |
| 212 | rfind() | rfind()返回指定指定范围内，子串最后出现的索引，找不到返回-1 str.rfind(str, beg=0end=len(string)) | str = "this is really a string example....wow!!!" str1 = "is" print str.rfind(str1) print str.rfind(str1, 0, 10) print str.rfind(str1, 10, 0) 结果显示 5 5 -1 | |
| 213 | rjust() | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串 str.rjust(width,[fillchar]) | str = "this is string example....wow!!!" print str.rjust(50, '0') 结果显示 000000000000000000this is string example....wow!!! | |
| 214 | zfill() | zfill()用“0”进行填充 str.zfill(width) | str = "this is string example....wow!!!" print str.zfill(40) print str.zfill(50) 结果显示 00000000this is string example....wow!!! 000000000000000000this is string example....wow!!! | |
| 215 | title() | title() 把字符串中每个单词的首字母大写 str.title() | str = "this is string example....wow!!!" print str.title() 结果显示 This Is String Example....Wow! | |
| 216 | maketrans() | maketrans()看例子吧：例子中实际上是把对应的字母替换成数字 str.maketrans(intab, outtab]) | from string import maketrans intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!" print str.translate(trantab) 结果显示 th3s 3s str3ng 2x1mpl2....w4w!!! | |
| 217 | translate() | 根据参数table给出的表转换字符串的字符, 要过滤掉的字符放到 del 参数中 str.translate(table,[deletechars]) | from string import maketrans intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!"; print str.translate(trantab, 'xm'); 结果显示 th3s 3s str3ng 21pl2....w4w!!! | |
| 218 | convert() | 类型转换 | 在python的开发过程中，难免会遇到类型转换，这里给出常见的类型转换demo： int(x [,base ]) 将x转换为一个整数 long(x [,base ]) 将x转换为一个长整数 float(x ) 将x转换到一个浮点数 complex(real [,imag ]) 创建一个复数 str(x ) 将对象 x 转换为字符串 repr(x ) 将对象 x 转换为表达式字符串 eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s ) 将序列 s 转换为一个元组 list(s ) 将序列 s 转换为一个列表 chr(x ) 将一个整数转换为一个字符 unichr(x ) 将一个整数转换为Unicode字符 ord(x ) 将一个字符转换为它的整数值 hex(x ) 将一个整数转换为一个十六进制字符串 oct(x ) 将一个整数转换为一个八进制字符串 | |
| 219 | random | random模块用于生成随机数 | random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0 | |
| 220 | random.uniform | random.uniform的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b，则 b <= n <= a。 | printrandom.uniform(10,20) printrandom.uniform(20,10) #----结果（不同机器上的结果不一样） #18.7356606526 #12.5798298022 | |
| 221 | random.randint() | random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b | printrandom.randint(12,20)#生成的随机数n:12<=n<=20 printrandom.randint(20,20)#结果永远是20 #printrandom.randint(20,10)#该语句是错误的。下限必须小于上限。 | |
| 222 | random.randrange | random.randrange的函数原型为：random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中获取一个随机数。如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效 | ||
| 223 | random.choice | random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence | printrandom.choice("学习Python") printrandom.choice(["JGood","is","a","handsome","boy"]) printrandom.choice(("Tuple","List","Dict")) | |
| 224 | random.shuffle | random.shuffle的函数原型为：random.shuffle(x[, random])，用于将一个列表中的元素打乱 | p=["Python","is","powerful","simple","andsoon..."] random.shuffle(p) printp #----结果（不同机器上的结果可能不一样。） #['powerful','simple','is','Python','andsoon...'] | |
| 225 | random.sample | random.sample的函数原型为：random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列 | list=[1,2,3,4,5,6,7,8,9,10] slice=random.sample(list,5)#从list中随机获取5个元素，作为一个片断返回 printslice printlist#原有序列并没有改变 | |
| 226 | super | 解决多重继承问题 | super(子类名,self).父类函数名() super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。总之前人留下的经验就是：保持一致性。要不全部用类名调用父类，要不就全部用 super，不要一半一半 | class FooParent(object): def __init__(self): self.parent = 'I\'m the parent.' print 'Parent' def bar(self,message): print message,'from Parent' class FooChild(FooParent): def __init__(self): super(FooChild,self).__init__() print 'Child' def bar(self,message): super(FooChild, self).bar(message) print 'Child bar fuction' print self.parent if __name__ == '__main__': fooChild = FooChild() fooChild.bar('HelloWorld') |
| 227 | assert() | 一般是用来做条件测试用的,用于判断两个值知否相等，如果不等抛出异常 1、assert语句用来声明某个条件是真的。 2、如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这种情形下的理想语句。 3、当assert语句失败的时候，会引发一AssertionError | >>> mylist = ['item'] >>> assert len(mylist) >= 1 >>> mylist.pop() 'item' >>> assert len(mylist) >= 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError | |
| 228 | ||||
| 229 | ||||
| 230 | ||||
| 231 | ||||
| 232 | ||||
| 233 | ||||
| 234 | ||||
| 235 | ||||
| 236 | ||||
| 237 | ||||
| 238 | ||||
| 239 | ||||
| 240 | ||||
| 241 | ||||
| 242 | ||||
| 243 |
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
