Dive Into Python的笔记(22)

按有用程度 按页码先后 最新笔记

第159页

impost

8.8. 挂起。 (更多)

8.8. 挂起。 (收起)

2011-04-04 09:42:09 回应

收藏
推荐
Further Reading

vvoody

Chapter 2: PEP 257 -- Docstring Conventions http://www.python.org/dev/peps/pep-0257/ Python Objects http://effbot.org/zone/python-objects.htm http://docs.python.org/reference/datamodel.html#objects Indentation http://docs.python.org/reference/lexical_analysis.html#indentation PEP 8 -- Style Guide for Python Code Import http://docs.python.org/reference/simple_stmts.html#import D... (更多)

Chapter 2:
PEP 257 -- Docstring Conventions http://www.python.org/dev/peps/pep-0257/
Python Objects http://effbot.org/zone/python-objects.htm http://docs.python.org/reference/datamodel.html#objects
Indentation http://docs.python.org/reference/lexical_analysis.html#indentation PEP 8 -- Style Guide for Python Code
Import http://docs.python.org/reference/simple_stmts.html#import
Dictionaries http://www.greenteapress.com/thinkpython/thinkCSpy/html/chap10.html "To sort a dictionary" (Python recipe) http://code.activestate.com/recipes/52306-to-sort-a-dictionary/
Chapter 5
import http://effbot.org/zone/import-confusion.htm http://docs.python.org/tutorial/modules.html (收起)

2012-04-22 21:05:40 回应

收藏
推荐
第25页

Jin (豆瓣：发现生活)
与 C 一样, Python 使用 == 做比较, 使用 = 做赋值。与 C 不一样, Python 不支持行内赋值, 所以不会出现想要进行比较却意外地出现赋值的情况。 Google一下『行内赋值』的意思，原来是这样的意思：在 Python 中 /代码内容已省略/ 而在 c 中 /代码内容已省略/ 来源：http://wenda.tianya.cn/wenda/thread?tid=5a46d97ea3876239&hl;=zh-CN (更多)
与 C 一样, Python 使用 == 做比较, 使用 = 做赋值。与 C 不一样, Python 不支持行内赋值, 所以不会出现想要进行比较却意外地出现赋值的情况。
Google一下『行内赋值』的意思，原来是这样的意思：
在 Python 中
```
if c=1:   #这样的语句是语法错误的
```
而在 c 中
```
if (c=1)   //会执行 c=1 的赋值行为。
```
来源：http://wenda.tianya.cn/wenda/thread?tid=5a46d97ea3876239&hl=zh-CN (收起)
2012-03-22 10:24:47 5回应

收藏
推荐
18.2. Using the timeit Module

gfreezy

>>> import timeit >>> t = timeit.Timer("soundex.soundex('Pilgrim')", ... "import soundex") >>> t.timeit() 8.21683733547 >>> t.repeat(3, 2000000) [16.48319309109, 16.46128984923, 16.44203948912] 1.The timeit module defines one class, Timer, which takes two arguments. Both arguments are strings. The first argu... (更多)

>>> import timeit >>> t = timeit.Timer("soundex.soundex('Pilgrim')", ... "import soundex") >>> t.timeit() 8.21683733547 >>> t.repeat(3, 2000000) [16.48319309109, 16.46128984923, 16.44203948912] 1.The timeit module defines one class, Timer, which takes two arguments. Both arguments are strings. The first argument is the statement you wish to time; in this case, you are timing a call to the Soundex function within the soundex with an argument of 'Pilgrim'. The second argument to the Timer class is the import statement that sets up the environment for the statement. Internally, timeit sets up an isolated virtual environment, manually executes the setup statement (importing the soundex module), then manually compiles and executes the timed statement (calling the Soundex function). 2.Once you have the Timer object, the easiest thing to do is call timeit(), which calls your function 1 million times and returns the number of seconds it took to do it. 3.The other major method of the Timer object is repeat(), which takes two optional arguments. The first argument is the number of times to repeat the entire test, and the second argument is the number of times to call the timed statement within each test. Both arguments are optional, and they default to 3 and 1000000 respectively. The repeat() method returns a list of the times each test cycle took, in seconds.
(收起)

2012-02-21 21:09:53 回应

收藏
推荐

Standard input, output, and error

/代码内容已省略/ (更多)

Example 10.11. Printing to stderr
>>> print 'entering function'
entering function
>>> import sys
>>> print >> sys.stderr, 'entering function' 
entering function

(收起)

2012-02-21 20:39:07 回应

第十一讲：exceptions、Debug

白乌鸦 (Understand yourself)

分类：可处理和不可处理作用：人机交互，人录入错误则抛出异常可分阶段处理错误 exception 和 assert 的区别 assert（断言）：当满足限制条件时，才会执行codes用来告诉用户，你应该输出什么 assert距离 >>> mylist = ['item'] >>> assert len(mylist)>=1 >>> mylist.pop() >>> 'item' >>> assert len(mylist)>=1 >>> 抛出Asse... (更多)

分类：可处理和不可处理
作用：人机交互，人录入错误则抛出异常
可分阶段处理错误
exception 和 assert 的区别
assert（断言）：当满足限制条件时，才会执行codes用来告诉用户，你应该输出什么
assert距离
>>> mylist = ['item']
>>> assert len(mylist)>=1
>>> mylist.pop()
>>> 'item'
>>> assert len(mylist)>=1
>>> 抛出AssetionError
debug：
☆Validation is process，验证是一个过程，它会揭露问题，增强信心
☆Debugging查明为何程序运行错误，或运行太慢
☆defnisive programming 防御性程序设计
测试分类：单元测试（优先进行），集成测试
认识：
1，最好的debug方法:Print and reading codes
2，不要随机地在codes中寻找bugs，系统化寻找bug方法：Be systematiic
3，debug就是一个搜索的过程
debug时，问自己的问题：
1,How could it have produced this result ?
2, It is part or fanily ?
3,How to fix it
4,用二分法查找bug☆☆
找bug的顺序：
1，参数顺序bug、拼写错误、忘记初始化
2，混淆了对象和值
3，赋值错误，赋值了一个指针而非对象本身
4，函数运行后，实参发生改变
建议：
1，记录你修改后的错误☆☆☆
2，重新思考你的错误
3，不要相信注释（comments）
4，求助于旁观者
5，卡住的时候休息一会儿
6，欲速则不达
7，代码段不要总在变长
8，保存旧版本 (收起)

2011-12-08 14:07:02 回应

收藏
推荐
第一讲：介绍

白乌鸦 (Understand yourself)

思想一：program即通过之流程表示程序语言分类：低级——高级（指离底层的距离）特定——广泛（指用途）解释型（更便于调试）——编译型 python的静态语义中只有部分能检测出bug，它是高级、广泛、解释型语言知识分类：陈述型、过程型 (更多)

思想一：program即通过之流程表示程序
语言分类：低级——高级（指离底层的距离）
特定——广泛（指用途）
解释型（更便于调试）——编译型
python的静态语义中只有部分能检测出bug，它是高级、广泛、解释型语言
知识分类：陈述型、过程型 (收起)

2011-12-08 13:39:38 回应

收藏
推荐
第十七讲：简单的业务分析

白乌鸦 (Understand yourself)
1，分析业务，用不严格的描述得到严格的statement 2，创造计算模型 3，处理和开发随机性问题，Dealing with & eploiting randomness stochastic 4，理解大规模数据，Making sense of data 5，检测程序答案 /代码内容已省略/ (更多)
1，分析业务，用不严格的描述得到严格的statement
2，创造计算模型
3，处理和开发随机性问题，Dealing with & eploiting randomness stochastic
4，理解大规模数据，Making sense of data
5，检测程序答案
```
def move(num):
    import random
    import math

    left = 0
    front = 0

    for i in range(num):
        ran = random.random()*4
        if ran>=0 and ran<1:
            left = left + 1
        elif ran>=1 and ran<2:
            left = left - 1
        elif ran>=2 and ran<3:
            front = front + 1
        else:
            front = front - 1


    if left >= 0:
        print 'left:'+ str(left)
    else:
        print 'right:'+ str(-left)

    if front >= 0:
        print 'front:'+ str(front)
    else:
        print 'back:'+ str(-front)

    lon = math.sqrt(front**2 + left**2)
    print lon
```
(收起)
2011-12-08 13:26:45 回应

收藏
推荐
第十六讲：class及运算符重载

白乌鸦 (Understand yourself)
__init__：初始化 __str__(self)：print（对象自身）后的打印值 __cmp__(sekf,other)：和其他对象比较，描述比较内容；对象比较大小后输出1,0，-1 __eq__：和其它对象判别相等隐藏数据！！只用特定的函数去访问数据创建一个人的模拟：！！一定要记得在类方法中加上self 子类：可以隐藏和重载父类函数 /代码内容已省略/ (更多)
__init__：初始化
__str__(self)：print（对象自身）后的打印值
__cmp__(sekf,other)：和其他对象比较，描述比较内容；对象比较大小后输出1,0，-1
__eq__：和其它对象判别相等
隐藏数据！！只用特定的函数去访问数据
创建一个人的模拟：

！！一定要记得在类方法中加上self
子类：可以隐藏和重载父类函数
```
class Person(object):
    #从object类继承
    def __init__(self, family_name, first_name):
        self.family_name = family_name
        self.first_name = first_name
    def familyName(self):
        return self.family_name
    def firstName(self):
        return self.first_name
    def __cmp__(sekf, other):
        return cmp((self.family_name, self.first_name),
                   (other.family_name, other.first_name))
    def __str__(self):
        return "I'm a people. My name is "&(self.first_name, self.family_name)

    def say(self, toWhom, something):
        return self.first_name + ' ' + self.family_name+ ' says to '+ toWhom.first_name + ' ' + toWhom.family_name + ' : ' + something
    def sing(self, toWhom, something):
        return self.say(toWhom, something + ' tra la la')

class MITPerson(Person):
    def sing(self):
        pass
    def god(self):
        return 'Oh, my god'
```
(收起)
2011-12-08 13:24:39 回应

收藏
推荐

第十五讲：面向对象

白乌鸦 (Understand yourself)

不要用对象中的预定义方法之外的途径获取值！！！！！ /代码内容已省略/ (更多)

不要用对象中的预定义方法之外的途径获取值！！！！！

# MIT600《计算机科学及编程导论》（2008年秋季）样码
# 第十五讲
# 翻译制作：ocourse.org
# 课程讨论版：http://ocourse.org/bbs/forum.php?mod=forumdisplay&fid=29
# by yoeo24

import math

## 点作为列表

def addPoints(p1,p2):
    r = []
    r.append(p1[0]+p2[0])
    r.append(p1[1]+p2[1])
    return r

p = [1,2]
q = [3,1]
r = addPoints(p,q)
print r

## 点作为类

class cartesianPoint:
    pass

cp1 = cartesianPoint()
cp2 = cartesianPoint()
cp1.x = 1.0
cp1.y = 2.0
cp2.x = 1.0
cp2.y = 3.0

def samePoint(p1,p2):
    return (p1.x == p2.x) and (p1.y == p2.y)

def printPoint(p):
    print '(' + str(p.x) + ', ' + str(p.y) + ')'

class polarPoint:
    pass

pp1 = polarPoint()
pp2 = polarPoint()
pp1.radius = 1.0
pp1.angle = 0
pp2.radius = 2.0
pp2.angle = math.pi / 4.0

class cPoint:
    def __init__(self,x,y):
        self.x = x
        self.y = y
        self.radius = math.sqrt(self.x*self.x + self.y*self.y)
        self.angle = math.atan2(self.y,self.x)
    def cartesian(self):
        return (self.x, self.y)
    def polar(self):
        return (self.radius, self.angle)
    def __str__(self):
        return '(' + str(self.x) + ', ' + str(self.y) + ')'
    def __cmp__(self,other):
        return (self.x > other.x) and (self.y > other.y)

class pPoint:
    def __init__(self,r,a):
        self.radius = r
        self.angle = a
        self.x = r * math.cos(a)
        self.y = r * math.sin(a)
    def cartesian(self):
        return (self.x, self.y)
    def polar(self):
        return (self.radius, self.angle)
    def __str__(self):
        return '(' + str(self.x) + ', ' + str(self.y) + ')'
    def __cmp__(self,other):
        return (self.x > other.x) and (self.y > other.y)

class Segment:
    def __init__(self,start,end):
        self.start = start
        self.end = end
    def length(self):
        return math.sqrt( (self.start.x - self.end.x)**2 + (self.start.y - self.end.y)**2)


p1 = cPoint(3.0, 4.0)
p2 = cPoint(5.0, 7.0)
s1 = Segment(p1,p2)
print s1.length()

(收起)

2011-12-08 13:23:59 回应

<前页 1 2 3 后页>

笔记是你写在书页留白边上的内容；是你阅读中的批注、摘抄及随感。

笔记必须是自己所写，不欢迎转载。摘抄原文的部分应该进行特殊标明。

>Dive Into Python