python 自学总结

本来的自学资源来自

http://woodpecker.org.cn/abyteofpython_cn/chinese/

1：在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。

2：Python即支持面向过程的编程也支持面向对象的编程。在 面向过程 的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在 面向对象 的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。

3：单引号、双引号、三引号、转义...............

4：变量

5：数据类型，创建自己的数据类型

6：Python把在程序中用到的任何东西都称为 对象
7：在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组

8：它告诉你， 你不能随意地开始新的语句块

9：运算符及其优先级

10：控制流 if、while、for

11：函数----定义def，调用

12：变量的作用范围

13：参数默认值

14：没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。例如，如果一个变量的值为None，可以表示它没有值。

15：如果你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的__doc__属性

16：模块------------引用模块----字节编译的pyc文件---模块引入的几种方式---自己的模块（包含函数和变量）----dir()函数的使用

17：数据结构----列表------元组

18：列表----是使用对象和类的一个例子。当你使用变量i并给它赋值的时候，比如赋整数5，你可以认为你创建了一个类（类型）int的对象（实例）i。事实上，你可以看一下help(int)以更好地理解这一点。 -----增加删除和遍历

19：元组----和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。new_zoo[2][2]

20：字典----键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }   -----增加删除和遍历

21：序列----列表、元组和字符串都是序列-----序列的两个主要特点是索引操作符和切片操作符

22：引用----当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 参考 那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。

23：:更多字符差操作方法-----startwith，in，find，join

-------实际问题的编程

--一个文件备份脚本的多个版本改进

one--two--three --four

--------python 面向对象的编程

1：到目前为止，在我们的程序中，我们都是根据操作数据的函数或语句块来设计程序的。这被称为 面向过程的 编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。这种方法称为 面向对象的 编程理念。在大多数时候你可以使用过程性编程，但是有些时候当你想要编写大型程序或是寻求一个更加合适的解决方案的时候，你就得使用面向对象的编程技术。

2：类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的 实例 。这类似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）。

3：域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

4：self-----假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。

5：定义类----定义类的函数-----定义对象----调用对象的函数

6：__init__方法-----在类的一个对象被建立时，马上运行。

7：__del__方法--它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。

8：__doc__方法-----我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。

9：类与对象——

类的变量 由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。通过一个例子会使这个易于理解。

10：继承---- B、C继承A-- A 类被称为  基本类  或  超类  。而B 和C 类被称为  导出类  或  子类  。

#!/usr/bin/env python
# Filename: inherit.py

class SchoolMember:
	'''Represents any school member.'''
	def __init__(self,name,age):
		self.name=name
		self.age=age
		print '(Initialized SchoolMember: %s)' %self.name
	
	def tell(self):
		'''Tell my details.'''
		print 'Name:"%s" Age:"%s"' %(self.name,self.age),

class Teacher(SchoolMember):
	'''Represents a teacher.'''
	def __init__(self,name,age,salary):
		SchoolMember.__init__(self,name,age)
		self.salary=salary
		print '(Initialized Teacher: %s)' %self.name
	
	def tell(self):
		SchoolMember.tell(self)
		print 'Salary: "%d"' %self.salary

class Student(SchoolMember):
	'''Represents a student.'''
	def __init__(self,name,age,marks):
		SchoolMember.__init__(self,name,age)
		self.marks=marks
		print '(Initialized Student: %s)' %self.name
	
	def tell(self):
		SchoolMember.tell(self)
		print 'Marks: "%d"' %self.marks

t=Teacher('Mrs. Shrividya',40,30000)
s=Student('Swaroop',22,75)

print # prints a blank line

members=[t,s]
for member in members:
	member.tell() # works for both Teachers and Students

--输出

$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"

------文件I /O

1：标准输出输出-----我们可以分别使用raw_input和print语句来完成这些功能，你也可以使用多种多样的str（字符串）类。例如，你能够使用rjust方法来得到一个按一定宽度右对齐的字符串。利用help(str)获得更多详情。

2：文件读写--你可以通过创建一个file类的对象来打开一个文件，分别使用file类的read、readline或write方法来恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后，当你完成对文件的操作的时候，你调用close方法来告诉Python我们完成了对文件的使用。

#!/usr/bin/env python
# Filename: using_file.py

poem='''\
Programming is fun
When the work is done
if you wanna make your work also fun:
	use Python!
'''

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
		break
	print line,
	# Notice comma to avoid automatic newline added by Python
f.close() # close the file

3： 模式可以为读模式（ 'r' ）、写模式（ 'w' ）或追加模式（ 'a' ）。事实上还有多得多的模式可以使用，你可以使用 help(file) 来了解它们的详情。

4：储存器---pickle/cPickle-----dump(存入文件)---load（从文件取出）

--异常处理

1：try..except

2：使用raise语句 引发 异常，引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类。

#!/usr/bin/env python
# Filename: raising.py

class ShortInputException(Exception):
	'''A user-defined exception class.'''
	def __init__(self,length,atleast):
		Exception.__init__(self)
		self.length=length
		self.atleast=atleast

try:
	s=raw_input('Enter something --> ')
	if len(s)<3:
		raise ShortInputException(len(s),3)
	# Other work can continue as usual here
except EOFError:
	print '\nWhy did you do an EOF on me?'
except ShortInputException,x:
	print 'ShortInputException: The input was of length %d, \
was expecting at least %d' %(x.length,x.atleast)
else:
	print 'No exception was raised.'

3：try..finally----- 假如你在读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件，该怎么做呢？这可以使用 finally 块来完成。注意，在一个 try 块下，你可以同时使用 except 从句和 finally 块。如果你要同时使用它们的话，需要把一个嵌入另外一个。

--python标准库

Python标准库是随Python附带安装的，它包含大量极其有用的模块。熟悉Python标准库是十分重要的，因为如果你熟悉这些库中的模块，那么你的大多数问题都可以简单快捷地使用它们来解决。

我们已经研究了一些这个库中的常用模块。你可以在Python附带安装的文档的“库参考”一节中了解Python标准库中所有模块的完整内容。

1：sys模块-----sys.argv

2：os模块

3：你应该利用Python标准文档去学习这两个模块以及其他模块的更多内容

--更多python内容

1：特殊方法

名称	说明
__init__(self,...)	这个方法在新建对象恰好要被返回使用之前被调用。
__del__(self)	恰好在对象要被删除之前调用。
__str__(self)	在我们对对象使用print语句或是使用str()的时候调用。
__lt__(self,other)	当使用 小于 运算符（<）的时候调用。类似地，对于所有的运算符（+，>等等）都有特殊的方法。
__getitem__(self,key)	使用x[key]索引操作符的时候调用。
__len__(self)	对序列对象使用内建的len()函数的时候调用。

2：列表综合

你有一个数的列表，而你想要得到一个对应的列表，使其中所有大于2的数都是原来的2倍。对于这种应用，列表综合是最理想的方法。

#!/usr/bin/env python
# Filename: list_comprehension.py

listone=[2,3,4]
listtwo=[2*i for i in listone if i>2]
print listtwo

输出

$ python list_comprehension.py
[6, 8]

3：在函数中接收元组和列表

当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。

>>> def powersum(power, *args):
...     '''Return the sum of each argument raised to specified power.'''
...     total = 0
...     for i in args:
...          total += pow(i, power)
...     return total
...
>>> powersum(2, 3, 4)
25

>>> powersum(2, 10)
100

由于在 args 变量前有 * 前缀，所有多余的函数参数都会作为一个元组存储在 args 中。如果使用的是 ** 前缀，多余的参数则会被认为是一个字典的键/值对。

3*3+4*4=25

4：lambda

lambda语句被用来创建新的函数对象，并且在运行时返回它们。

#!/usr/bin/python
# Filename: lambda.py

def make_repeater(n):
    return lambda s: s*n

twice = make_repeater(2)

print twice('word')
print twice(5)

输出

$ python lambda.py
wordword
10

这里，我们使用了make_repeater函数在运行时创建新的函数对象，并且返回它。lambda语句用来创建函数对象。本质上，lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个新建的函数返回。注意，即便是print语句也不能用在lambda形式中，只能使用表达式。

5：exec 和 eval 语句

exec语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子。

>>> exec 'print "Hello World"'
Hello World

eval 语句用来计算存储在字符串中的有效Python表达式。下面是一个简单的例子。

>>> eval('2*3')
6

6：assert 语句

7：repr 函数

repr函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。注意，在大多数时候有eval(repr(object)) == object。

>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"

基本上， repr 函数和反引号用来获取对象的可打印的表示形式。你可以通过定义类的 __repr__ 方法来控制你的对象在被 repr 函数调用的时候返回的内容。

--总结

到目前为止，我们确实已经学习了绝大多数你在实际中会使用的内容。这些已经足以让你去创建任何程序了。