A Byte of Python的读后感10篇

　　《A Byte of Python》是一本由Swaroop C H著作，Lulu Marketplace出版的平装图书，本书定价：USD 27.98，页数：149，文章吧小编精心整理的一些读者的读后感，希望对大家能有帮助。

　　《A Byte of Python》读后感(一)：网页版书的严重问题：双下划线显示有误

　　但是这本书有一个严重的问题：

　　这本书中的双下划线都都被解析成 <em> 斜体了！

　　在 18.2 章节 special methods 中最为显著。

　　函数的名字应该是 __str__ 的，都变成斜体 str 了……

　　看的时候也似懂非懂的，看了另一本入门书才发现。

　　tw，推荐另一本也很好懂的入门书《与孩子一起学编程》： https://read.douban.com/ebook/1003628/

　　《A Byte of Python》读后感(二)：绝佳的Python入门小书！

　　ython本来就比较容易学习，在众多编程语言中有着动态语言特有的高抽象性，而且语法接近自然语言，不会让人产生很大的距离感。

　　现在，越来越多的人把Python作为自己步入计算机程序设计殿堂的入门语言，也有越来越多的人逃离了其它语言，投入了Python的怀抱，期许更加轻松愉快地编程。

　　而《A Byte of Python》则是入门Python的绝佳Tutorial，从书的目录便可以了解到作者Swaroop C H清晰的行文思路，以及对Python高超的驾驭能力。

　　由于小项目的需求，要用Python写一些JSON处理的脚本以及抓取一些数据，动起手来，方知“书到用时终觉浅”，马上又捡起了《A Byte of Python》，作为身边的参考书，边学边写。不过这次阅读了英文原版，作者维护在github上的页面是https://github.com/swaroopch/byte_of_python，关于本书的页面是swaroopch.com/notes/python/，可以直接免费下载最新的PDF版本。

　　ython的常量和变量，操作符和表达式，控制流，数据结构，函数，模块，标准库，I/O，异常处理，OOP编程，作者在有限地篇幅内，抓住要点并举出实例，十分恰当地呈现在读者面前。而在第18章，作者又给出读过本书之后的学习方向和方法！第19章，又说到自由/开源软件，给读者提供了开源世界的线索。

　　整本PDF才124页，短小精悍，不过绝对称得上是“Python的绝佳入门小书！”。

　　《A Byte of Python》读后感(三)：通俗易懂，适合初学者

　　优点

　　1. 讲解很详细，很基础，适合入门,对编译器也做了简单的介绍

　　2. 对__name__属性的讲解比较详细，而其它书则没怎么讲到这块知识

　　3. 有涉及类、继承的知识，对于没有java基础的我来说，讲解很通俗，但本书也只是蜻蜓点水提了一些知识，若想深入学习，还得多看其他的书籍

　　4. 简单介绍了sys,os等常用模块。

　　缺点

　　1. 使用的python版本太老，书中是用的'python 2.4版本'，而截至到2014年11月，python的最新版本为2.7版本的。2.4版本的

　　输入整数的公式还是int(raw_input('请输入一个整数： '))而2.7版本的用input()可以替代2.4版本的int(raw_input())

　　总结：

　　1. 对于零基础或者基础少的人，真的是一本很好的书，强烈推荐。

　　2. 关于类、继承 和 try..exception还不是很懂，代码运行错误，也无法找出原因，以后在回顾。

　　《A Byte of Python》读后感(四)：python入门第一本书

　　和简单的一本书，和Learning Python一起可以作为入门书籍。

　　比LP简单，中文版网上可以看到。

　　花两天时间，你就可以写python了。

　　先看这本，再看Learning Python。

　　LP是一本600多页的“巨著”啊

　　《A Byte of Python》读后感(五)：A Bite of python

　　这本书是我最近在读的一本书，非常喜欢。主要是因为它够简单，我可以较容易的理解。书名也很有个性，a byte，是的，全书也只是一个简单的tutorial而已。但是相对于那本长的离谱，很不实用的learning python，这本书的简洁是很大的优势。因此可以相对容易的开始入门，而不是被那么厚的纸堆吓倒，因此我给这本书一个新的名字：a bite of python，咬一口python，很容易。

　　从第一个hello world程序开始，全书控制流、函数、模块、数据结构（list、tuple、dict）、类和对象、输入输出（io）、异常处理、标准库（i.e. sys, os, time, etc）等内容。

　　不过，上手最重要。看完了，我开始看我的合作者给我写的程序，发现依然还有很多细节不明了。看来入门归入门，真刀真枪的使用，还是要再实践中检验。 经验是：每天都写，日积月累。

　　《A Byte of Python》读后感(六)：A Byte of Python笔记附github代码地址

　　书中的代码都整理在github上了.详见：https://github.com/Everfighting/A-Byte-of-Python.git --------------------------- 章节内容简单介绍： - Python介绍 脚本语言；简单、易学、免费、开源、可移植性好、面向对象、可扩展、丰富的库等等 - Python安装 linux系统：判断是否安装 python -v Windows系统： 下载软件安装即可 挑选合适的编辑器。 #符号右面的内容都是注释 Linux系统下运行：chmod a+x helloworld.py echo $PATH 来显示PATH变量 help()帮助了解命令含义 q退出 - 基本概念 数：整数、长整数、浮点数和复数。 字符串:""",转义符，Unicode字符。 变量 标识符命名：大小写敏感、字母数字下划线（开头不能有数字） 逻辑行用；隔开，清晰理解。 - 运算符和表达式 位运算 左移、右移、位与、位或、位异或 运算符优先级 - 控制流 if、while、for、break、continue -函数 形参与实参。调用函数时，实参值赋给形参。 局部变量：函数内部定义的变量与外部完全没有关系。产生效果的区域成为局部作用域。 全局变量：定义全局变量。在函数内部使用global语句。（不推荐） 默认参数值：def func(a, b=5)是有效的，但是def func(a=5, b)是 无效的。 关键参数：我们可以只给我们想要的那些参数赋值。 return语句：没有返回值的return语句等价于return None。 None是Python中表示没有任何东西的特殊类型。 文档字符串：方便程序的阅读理解。 - 模块 sys模块：sys模块包含了与Python解释器和它的环境有关的函数。 .pyc文件: 字节编译的文件 ，这些文件以.pyc作为扩展名。 from..import语句: from sys import argv语句。 模块的name：获取模块的名称。 main为当前程序。 制造你自己的模块：记住这个模块应该被放置在我们输入它的程序的同一个目录中，或者在sys.path所列目录之一。 dir()：内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。 - 数据结构 列表：len(list)、list.append、list.sort、del list［0］ 元组：元组和字符串一样是不可变的，即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。 字典：它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。 赋值：d［key］= value 删除：del d［key］ 迭代出每一项：for name,address in ab.items(): 序列：列表、元组、字符串都属于序列。 序列的两个特点：索引操作符和切片操作符。 引用：当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 引用 那个对象，而不是表示这个对象本身！ 字符串方法: in操作符用来检验一个给定字符串是否为另一个字符串的一部分。 find方法用来找出给定字符串在另一个字符串中的位置，或者返回-1以表示找不到子字符串。 str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字符串。 - 面向对象编程 self:类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是 在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本 身，按照惯例它的名称是self。 init方法: init方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化 。 类与对象的方法：类的变量 由一个类的所有对象（实例）共享使用。对象的变量 由类的每个对象/实例拥有。 继承：基本类的init方法专门使用self变量调用。 - 输入输出 模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）。 使用file类的write方法来写文件，最后我们用close关闭这个文件。 使用readline方法读文件的每一行。 存储与去存储没看懂。 - 异常 用try..except语句来处理异常。 用raise来引发异常。 try...finally异常发生后有语句仍然执行。 - python标准库 sys模块os模块。 - 更多python内容 init(self, ...) 、del(self)、 str(self)、 lt(self, other) 、getitem(self, key) 、len(self) 列表生成式 单语句块 lambda语句 exec语句用来执行储存在字符串或文件中的Python语句： >>> exec 'print "Hello World" eval语句用来计算存储在字符串中的有效Python表达式。 >>> eval('2*3') assert语句用来声明某个条件是真的。当assert语句失败的时候，会引发一个AssertionError。 repr函数：显示机器能读懂的固定格式。

　　《A Byte of Python》读后感(七)：简单的入门书

　　总的来说入门没问题，看完之后至少可以看懂别人写的代码，自己要写一些高级点的程序的话还需要再找一些资料。

　　看完后python给我的感觉就像读英文，一看就能大概知道一条语句要做什么，而且比C++、Java这种大型语言简单、灵活，用起来比较方便。

　　下面是我看书过程中的一些笔记：

　　* 基础：

　　*

　　* 语句控制块

　　*

　　*

　　* if-elif-else，注意在每个关键字语句最后加冒号：如

　　*

　　*

　　* if guess == number:

　　rint 'Congratulations, you guessed it.' # New block starts here

　　* while同样需要最后冒号，同时while结束后可加else，效果与不加相同：如

　　*

　　* while running:

　　guess = int(raw_input('Enter an integer : '))

　　else:

　　rint 'The while loop is over.'

　　rint 'Done'

　　* for语句和一般的C++和Java不同，使用的是for ... in ...的形式，同样是用冒号：结束，可以加else，如：

　　*

　　* for i in range(1, 5):

　　rint i

　　else:

　　rint 'The for loop is over'

　　* break语句跟其他语言相同，用户终止循环，但有个不同的地方，循环被终止后else语句块的语句将不被执行

　　* 函数

　　*

　　* 函数定义：“def 函数名(参数列表) :”，其中参数列表是值传递，不是引用传递

　　* 可使用global说明使用一个函数外定义的变量，但尽量避免这么做，如：

　　*

　　* def func():

　　global x

　　rint 'x is', x

　　* 默认参数：参数名=默认值，默认参数需要在参数列表的末尾，调用函数时如果没有参数也需要带空括号，如：

　　*

　　* def say(message, times = 1):

　　rint message * times

　　* 关键参数：改变函数调用的传参顺序，通过形参名字进行赋值，可以和默认参数结合使用，只改变部分想改变的默认参数值，如：

　　*

　　* def func(a, b=5, c=10):

　　rint 'a is', a, 'and b is', b, 'and c is', c

　　func(3, 7)

　　func(25, c=24)

　　* 没有return语句的函数默认return None，None是python表示没有任何东西的特殊类型

　　* pass表示python的空语句块，如：

　　*

　　* def someFunction():

　　ass

　　* 文档字符串DocStrings：每个函数、类、模块最好都有文档字符串描述他们的功能，通过"对象.__doc__"可以获得他们的文档字符串。文档字符串的惯例：1. 多行字符串，通过'''表示；2. 首行以大写字母开始，句号结束；3. 第二行为空行；4. 第三行开始是详细描述。如：

　　*

　　* def printMax(x, y):

　　'''Prints the maximum of two numbers.

　　The two values must be integers.'''

　　x = int(x) # convert to integers, if possible

　　y = int(y)

　　if x > y:

　　rint x, 'is maximum'

　　else:

　　rint y, 'is maximum'

　　rintMax(3, 5)

　　rint printMax.__doc__

　　* 模块

　　*

　　* sys模块：模块以.py为后缀，通过import输入使用模块，包含python解释器和环境的有关参数，在第一次输入模块的时候初始化，其中argv属性表示命令行的参数，path属性表示输入模块的目录名列表

　　* 字节编译文件.pyc：输入.py后缀的模块需要翻译成中间字节编译文件的过程，比较耗时，.pyc文件是字节编译文件，速度快

　　* from ... import语句：和C++的using namespace类似，引入import模块里的一些常用名字，方便使用，而不用每次都通过类似sys.argv的方式，直接使用argv。不过尽量少这样用，减少名字冲突

　　* 模块的__name__：默认没设置时，一个模块可以直接运行主体代码，也可以在导入其他模块时运行主体代码。通过设置__name__的值为__main__可以让一个模块作为一个单独功能直接运行，而在被引入其他模块时不运行，如：

　　*

　　* if __name__ == '__main__':

　　rint 'This program is being run by itself'

　　else:

　　rint 'I am being imported from another module'

　　* 如果直接./testmodule.py，则显示This program is being run by itself，如果通过其他python文件import testmodule，则显示I am being imported from another module

　　* dir()：用于列出所使用模块的属性列表，包括函数、类、变量，如果为其没有提供参数，则返回当前模块的属性列表

　　* del：类似于C++中的delete，用于删除一个变量/名称，删除后就不能再用这个变量/名称

　　* 数据结构

　　*

　　* 列表：用[]存储，可以通过添加、删除、排序修改列表，可以通过len(列表)取得长度、通过数组下标方式访问（从0开始），如：

　　*

　　* shoplist = ['apple', 'mango', 'carrot', 'banana']

　　rint 'I have', len(shoplist),'items to purchase.'

　　rint 'These items are:', # Notice the comma at end of the line

　　for item in shoplist:

　　rint item,

　　rint 'nI also have to buy rice.'

　　hoplist.append('rice')

　　rint 'My shopping list is now', shoplist

　　rint 'I will sort my list now'

　　hoplist.sort()

　　rint 'Sorted shopping list is', shoplist

　　rint 'The first item I will buy is', shoplist[0]

　　olditem = shoplist[0]

　　del shoplist[0]

　　rint 'I bought the', olditem

　　rint 'My shopping list is now', shoplist

　　* 元组：和列表类似，用()存储，可以通过数组下标方式访问（从0开始），但元组值不可改变。而且如果元组只有一个元素时，需要在元素后面加一个逗号,以区分表达式中一个带圆括号的对象。元组内的元素保持原来的身份，即如果在元组内添加的元素是一个元组，则根据下标访问到时返回的还是一个元组，如：

　　*

　　* zoo = ('wolf', 'elephant', 'penguin')

　　rint 'Number of animals in the zoo is', len(zoo)

　　ew_zoo = ('monkey', 'dolphin', zoo)

　　rint 'Number of animals in the new zoo is', len(new_zoo)

　　rint 'All animals in new zoo are', new_zoo #此时返回结果是('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))

　　rint 'Animals brought from old zoo are', new_zoo[2]

　　rint 'Last animal brought from old zoo is', new_zoo[2][2]

　　* 元组一般用于打印语句，如：

　　*

　　* age = 22

　　ame = 'Swaroop'

　　rint '%s is %d years old' % (name, age)

　　rint 'Why is %s playing with that python？' % name

　　* 字典：相当于Map，一种key-value形式，其中key的必须是不可变的对象，value可以变也可以不变，，通过下标访问法传入key值进行访问，可以通过items()返回字典的key-value对，用in关键字或者has_key()方法判断一个key是否在字典中，如：

　　*

　　* ab = { 'Swaroop' : 'swaroopch@byteofpython.info',

　　'Larry' : 'larry@wall.org',

　　'Matsumoto' : 'matz@ruby-lang.org',

　　'Spammer' : 'spammer@hotmail.com'

　　}

　　rint "Swaroop's address is %s" % ab['Swaroop']

　　ab['Guido'] = 'guido@python.org' #增加一项

　　del ab['Spammer']

　　rint 'nThere are %d contacts in the address-bookn' % len(ab)

　　for name, address in ab.items():

　　rint 'Contact %s at %s' % (name, address)

　　if 'Guido' in ab: # OR ab.has_key('Guido')

　　rint "nGuido's address is %s" % ab['Guido']

　　* 序列：列表、元组、字符串都是序列，序列的好处就是可以用相同的方式访问序列的内容（数组下标），都可以切片：类似于[0:2]之类的冒号分割的数字，用于获取序列中的一个子集，其中数字可以没有，但冒号必须有，第二个数字不在子集范围内，缺省第一个数字表示从序列头开始，缺省第二个数字表示到序列结尾。如：

　　*

　　* shoplist = ['apple', 'mango', 'carrot', 'banana']

　　rint 'Item 0 is', shoplist[0]

　　rint 'Item -1 is', shoplist[-1]

　　rint 'Item 1 to 3 is', shoplist[1:3]

　　rint 'Item 2 to end is', shoplist[2:]

　　rint 'Item 1 to -1 is', shoplist[1:-1]

　　rint 'Item start to end is', shoplist[:]

　　* 引用：相当于C++中的指针或者引用，如果创建一个变量时只是赋予一个变量，该变量只是一个引用，两个变量指向是同一个内存空间，要实现深度复制必须使用切片，即“变量名[:]”

　　* 一些字符串方法：in、startswith、find、join，其中前三个用于判定是否存在某一子串，join用于使用该字符串来连接一个列表以形成一个大的字符串，如：

　　*

　　* delimiter = '_*_'

　　mylist = ['Brazil', 'Russia', 'India', 'China']

　　rint delimiter.join(mylist) #结果为： Brazil_*_Russia_*_India_*_China

　　* 一个简单的应用示例python程序：备份重要文件

　　*

　　* 通过使用（import）os模块的system方法调用linux的命令，其返回值与shell命令类似，0表示成功执行，1表示执行失败，据说不推荐直接使用system方法，可能os模块有linux系统每个shell命令对应的名字标识。如：

　　*

　　* zip_command = "zip -qr '%s' %s" % (target, ' '.join(source))

　　# Run the backup

　　if os.system(zip_command) == 0:

　　rint 'Successful backup to', target

　　else:

　　rint 'Backup FAILED'

　　* os模块的path方法用于路径操作，mkdir方法用于创建文件夹，sep表示路径分隔符（linux为/，windows为，mac为:），如：

　　*

　　* if not os.path.exists(today):

　　os.mkdir(today) # make directory

　　rint 'Successfully created directory', today

　　# The name of the zip file

　　target = today + os.sep + now + '.zip'

　　* raw_input用于获取用户界面输入如：

　　*

　　* comment = raw_input('Enter a comment --> ')

　　* 面向对象编程

　　*

　　* 类由关键词“class 类名”定义

　　* self：类的方法必须有一个self参数，且位于第一个，但在调用时不需要为这个参数赋值，这个参数执行对象本身，如：

　　*

　　* class Person:

　　def sayHi(self):

　　rint 'Hello, how are you？'

　　= Person()

　　.sayHi()

　　* 创建类对象：“对象名=类名(参数列表)”，如：

　　*

　　* class Person:

　　ass # An empty block

　　= Person()

　　rint p

　　* __init__：类似于C++、Java中的构造函数，如：

　　*

　　* class Person:

　　def __init__(self, name):

　　elf.name = name

　　def sayHi(self):

　　rint 'Hello, my name is', self.name

　　= Person('Swaroop')

　　.sayHi()

　　* __del__：类似于C++的析构函数，在对象消逝的时候被调用，如果要显示删除一个对象，使用del语句

　　* 类变量和对象变量：类似于C++和Java的static变量，类变量由“类名.类变量名”表示，对象变量由“self.对象变量名”表示，如：

　　*

　　* class Person:

　　'''Represents a person.'''

　　opulation = 0

　　def __init__(self, name):

　　'''Initializes the person's data.'''

　　elf.name = name #对象变量

　　rint '(Initializing %s)' % self.name

　　# When this person is created, he/she

　　# adds to the population

　　erson.population += 1 #类变量

　　* 继承：通过在类名后面加一个元组，元组的元素为要继承的父类；python不会自动初始化父类，需要在子类的__init__中调用父类的__init__方法，且通过父类名调用，需要传入self参数；子类中调用的父类的方法也类似，使用父类名调用，传入self参数，如：

　　*

　　* class SchoolMember:

　　'''Represents any school member.'''

　　def __init__(self, name, age):

　　elf.name = name

　　elf.age = age

　　rint '(Initialized SchoolMember: %s)' % self.name

　　def tell(self):

　　'''Tell my details.'''

　　rint 'Name:"%s" Age:"%s"' % (self.name, self.age),

　　class Teacher(SchoolMember):

　　'''Represents a teacher.'''

　　def __init__(self, name, age, salary):

　　choolMember.__init__(self, name, age)

　　elf.salary = salary

　　rint '(Initialized Teacher: %s)' % self.name

　　def tell(self):

　　choolMember.tell(self)

　　rint 'Salary: "%d"' % self.salary

　　* 输入/输出

　　*

　　* 文件：file方法打开文件，模式有r,w,a，默认为r，有read,readline,write方法，如：

　　*

　　* f = file('poem.txt', 'w') # open for 'w'riting

　　f.write(poem) # write text to file

　　f.close() # close the file

　　f = file('poem.txt')

　　# if no mode is specified, 'r'ead mode is assumed by default

　　while True:

　　line = f.readline()

　　if len(line) == 0: # Zero length indicates EOF

　　reak

　　rint line,

　　# Notice comma to avoid automatic newline added by Python

　　f.close() # close the file

　　* pickle：相当于Java的序列化，用于存储一个对象到文件中，有pickle和cPickle两个模块，cPickle是C语言实现的，比pickle快1000倍。通过dump存储一个对象到文件，通过load把一个对象从文件中读取出来。import ... as ...可以对模块起别名，在程序中使用别名相当于使用这个模块，类似于C++中的宏定义。如：

　　*

　　* import cPickle as p

　　hoplistfile = 'shoplist.data'

　　hoplist = ['apple', 'mango', 'carrot']

　　f = file(shoplistfile, 'w')

　　.dump(shoplist, f) # dump the object to a file

　　f.close()

　　del shoplist # remove the shoplist

　　f = file(shoplistfile)

　　toredlist = p.load(f)

　　rint storedlist

　　* 异常

　　*

　　* try ... except ... [else ...]：类似于Java的try...catch...，except可以跟元组，元组是可能发生的异常类型，如果except后没有跟内容，则捕获所有异常。和while、for语句类似，try...except后还可以跟else从句，当没有异常发生时，else从句执行。如：

　　*

　　* try:

　　= raw_input('Enter something --> ')

　　except EOFError:

　　rint 'nWhy did you do an EOF on me？'

　　ys.exit() # exit the program

　　* 创建自己的异常：和Java的异常处理机制相同，用户可以定义自己的异常，只需继承Error或者Exception类即可，通过raise抛出异常对象，在except中获取使用这个对象，except格式：“except 异常类型, 对象名”，Python2.6之后应写作“except 异常类型 as 对象名”，显然比原来那个版本易理解多了，如：

　　*

　　* class ShortInputException(Exception):

　　'''A user-defined exception class.'''

　　def __init__(self, length, atleast):

　　Exception.__init__(self)

　　elf.length = length

　　elf.atleast = atleast

　　try:

　　= raw_input('Enter something --> ')

　　if len(s) < 3:

　　raise ShortInputException(len(s), 3)

　　# Other work can continue as usual here

　　except EOFError:

　　rint 'nWhy did you do an EOF on me？'

　　except ShortInputException, x:

　　rint 'ShortInputException: The input was of length %d,

　　was expecting at least %d' % (x.length, x.atleast)

　　* finally：与Java类似，无论异常发生与否都会执行的代码块，与else不同，else的代码块只有不发生异常时才会执行，据说2.5版本以前的不支持except和finally一起使用，2.5之后才支持，系统装的是2.6版本的python解释器，没试过不行的例子。示例：

　　*

　　* import time

　　try:

　　f = file('poem.txt')

　　while True: # our usual file-reading idiom

　　line = f.readline()

　　if len(line) == 0:

　　reak

　　time.sleep(2)

　　rint line,

　　finally:

　　f.close()

　　rint 'Cleaning up...closed the file'

　　* Python标准库

　　*

　　* sys模块：argv、exit()、version、version_info、等

　　* os模块：使用这个模块可以使程序与操作系统无关，常用：sep（分隔符）、getcwd()（当前工作目录）、listdir()（获取指定目录下的所有文件和目录名）、remove()（删除一个文件）、system()（用来执行shell命令）、linesep（系统平台的换行符，如windows的rn，linux的n，mac的r）、path.split()（分割目录名和文件名）、path.isfile()、path.isdir()

　　* 更多模块的内容需要通过help去学习

　　* Python的奇淫技巧

　　*

　　* 特殊方法：__init__(self,...), __del__(self), __str__(self), __lt__(self, other), __getitem__(self, key), __len__(self)，可以像C++一样进行运算符重载

　　* 列表处理：可以通过一个列表生成另外一个列表，如：

　　*

　　* listone = [2, 3, 4]

　　listtwo = [2*i for i in listone if i > 2]

　　rint listtwo

　　* 函数接收元组和词典：分布通过定义形参为*和**前缀实现，可以应用于可变数量的参数，如：

　　*

　　* def test(name, *argv):

　　rint name

　　for item in argv:

　　rint item,

　　test('adu', 1,2,3)

　　* def test(**argv):

　　for item,value in argv.items():

　　rint 'key=%s, value=%s' % (item, value)

　　test(a=1,b=3)

　　* lambda表达式：如：

　　*

　　* def make_repeater(n):

　　return lambda s: s*n

　　twice = make_repeater(2)

　　rint twice('word') #结果为wordword

　　* exec和eval语句：exec用来执行存储在字符串中的python代码，eval用来计算存储在字符串中的python表达式，如：

　　*

　　* exec 'print "Hello World"'

　　* eval('2*3')

　　* assert语句：和C++中的类似，用来确认一个表达式是正确的，否则会抛出AssertionError

　　* repr语句：与反单引号相同，用于获取对象的规范字符串表示，即对象的可打印形式，可通过定义类的__repr__方法来控制，如：

　　*

　　* i=['item']

　　rint `i` #结果为['item']

　　rint repr(i) #结果为['item']

　　《A Byte of Python》读后感(八)：2017新版中译本

　　https://bop.molun.net

　　《A Byte of Python》是一本由 Swaroop C H 编写，旨在于介绍如何使用 Python 语言进行编程的自由图书。它以教材与指南的形式为入门者介绍 Python 语言。如果你对电脑知识的了解仅限于如何保存文本文件的话，那这本书就是为你准备的。

　　2005 年，沈洁元将本书的 1.20 版引进中国，并完成了全本翻译，将本书的译名定为《简明 Python 教程》。2017年，漠伦基于原书 4.0 版重新翻译，制作了本版全新译本，并沿用同样的译名。

　　本版译本定义为 4.03c 版。最后修订于 2017 年 3 月 19 日。

　　看完很不满意。。。太简明了。。

　　《A Byte of Python》读后感(九)：在GitBook上找到了Python3的译本,分享给大家

　　大家可以去GitBook网站上去搜书名,然后可以找到该书python3.5版本的英文版,想要中文版的话可以往下滚动,下面会有志愿者翻译的中文版,方便大家学习.

　　------------------------------------------------------分割线---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

　　居然有最少字数限制.......那我还是直接贴出网址好了,方便大家.

　　简明 Python 教程

　　《A Byte of Python》读后感(十)：简单浅显，适合初学者，也只适合初学者

　　不废话，rt。希望不要浪费大家时间。

　　Table of Contents

　　1. Welcome

　　2. Dedication

　　3. Preface

　　4. Introduction

　　5. Installation

　　6. First Steps

　　7. Basics

　　8. Operators and Expressions

　　9. Control Flow

　　10. Functions

　　11. Modules

　　12. Data Structures

　　13. Problem Solving

　　14. Object Oriented Programming

　　15. Input and Output

　　16. Exceptions

　　17. More

　　18. Appendix: FLOSS

　　19. Appendix: Colophon

　　20. Appendix: Revision History

　　21. Translations

　　22. Translation Howto