openstack编程：python基础知识总结

阅读本文可以带着下面问题：
1.python的注释符号是什么？
2.python输出该如何写？
3.什么是内建函数？
4.python的运算符都包含哪些？
5.Python字符串该如何表示？
6.列表和元组怎么表示？
7.if语句该如何表示？
8.while语句如何表示？
9.如何捕获异常？
10.函数如何表示？
11.Python的源文件名是什么？
12.常用函数都有哪些？






总结一

1.程序输出:
和C中printf很像:

>>> print "%s is number %d." % ("Python", 1)  
Python is number 1.  
复制代码

将输出重定向到系统标准错误:

>>> import sys  
>>> print >> sys.stderr, 'fatal error.'  
fatal error.  
复制代码

将输出重定向到一个文件:

>>> logfile = open('./out.log', 'a')  
>>> print >> logfile, 'hello world'  
>>> logfile.close()  
复制代码

2.程序输入和内建函数raw_input():

>>> user = raw_input('Enter your name:')  
Enter your name:chenjianfei  
>>> passwd = raw_input('Enter your password:')  
Enter your password:123456  
复制代码

内建函数int()可将数字字符串转化为int:

>>> num = raw_input('Input a num:')  
Input a num:100  
>>> print '2*num = %d' % num*2  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: %d format: a number is required, not str  
>>> print '2*num = %d' % (int(num)*2)  
2*num = 200  
复制代码

从交互式解释器中获取帮助:

>>>help(raw_input)  
复制代码

3.注释

# 后面是注释

文档字符串注释:可以在模块,类,或者函数的开始添加一个字符串,起到在线文档的作用.

def foo():  
    "This is a doc string."  
    return True;  
复制代码

4.运算符
+ -
*
/ 传统除法(地板除)
// 浮点除法(四舍五入)
% 取余
** 乘方(优先级最高)

比较运算符:
< <= > >= == != <>

逻辑运算符:
and or not
注意下面是合法的:

>>> 3 < 4 < 5  
True  
>>> 3 < 4 and 4 < 5  
True  
复制代码

5.变量和赋值:
Python中变量名规则和C一样.python是动态类型语言,也就是说不需要预先声明变量的类型.变量的类型和值在赋值的被初始化.

>>> count = 0  
>>> miles = 10.5  
>>> name = 'bob'  
>>> kilometers = miles*1.609  
复制代码

增量赋值:
+= *= ...
python不支持++和--

6.数字
五种基本类型:
int 有符号整数:-234, 0x80, -0x80
long 长整数:-234L, 0x888L
bool 布尔类值:True(1), False(0)
float 浮点值:3.1415, -4.2E-10, 4.2e10
complex 复数:3+10j, -123-838.33J
从长远来看int和long将会无缝结合.在Python2.3以后再也不会报整型溢出的错误,结果会自动转化长整型.所有L后缀可有可无.

7.字符串:
Python使用成对的单引号或是双引号,三引号可以用来包含特殊字符.使用[]和[ : ]得到子字符串.[ index : count]
字符串有其特有的索引规则:第一个索引号是0,最后一个是-1.
加号(+)用来字符串连接运算.乘号(*)用于字符串的重复.

>>> pystr = 'Python'  
>>> iscool = 'is cool!'  
>>> pystr[0]  
'P'  
>>> pystr[2:5]  
'tho'  
>>> iscool  
'is cool!'  
>>> iscool[:2]  
'is'  
>>> iscool[3:]  
'cool!'  
>>> iscool[-1]  
'!'  
>>> pystr + iscool  
'Pythonis cool!'  
>>> pystr + ' ' + iscool  
'Python is cool!'  
>>> pystr * 2  
'PythonPython'  
>>> '-' * 20  
'--------------------'  
>>> pystr = '''''python  
... is cool'''  
>>> pystr  
'python \n is cool'  
>>> print pystr  
python   
... is cool  
>>>   
复制代码

8.列表和元组
列表元素用[]包裹,元组元素用()包裹.
列表元素的个数和元素的值都可以改变.
元组可以看成是只读的列表.通过切片运算([], [:])可以得到子集.
列表操作:

>>> aList = [1, 2, 3, 4]  
>>> aList  
[1, 2, 3, 4]  
>>> aList[0]  
1  
>>> aList[2:]  
[3, 4]  
>>> aList[:3]  
[1, 2, 3]  
>>> aList[1] = 5  
>>> aList  
[1, 5, 3, 4]  
复制代码

元组操作:

>>> aTuple = ('chenjianfei', 25, 170, 'hello')  
>>> aTuple  
('chenjianfei', 25, 170, 'hello')  
>>> aTuple[:3]  
('chenjianfei', 25, 170)  
>>> aTuple[1] = 3  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: 'tuple' object does not support item assignment  
复制代码

9.字典
字典是Python中的映射数据类型.类似Perl中的关联数组和哈希表,有(key-value)对构成.用大括号{}包括.

>>> aDict = {'host': 'localhost'}  
>>> aDict  
{'host': 'localhost'}  
>>> aDict['port'] = 8080  
>>> aDict  
{'host': 'localhost', 'port': 8080}  
>>> aDict.keys()  
['host', 'port']  
>>> aDict['host']  
'localhost'  
>>> for key in aDict:  
...     print key, aDict[key]  
...   
host localhost  
port 8080  
>>> aDict['host'] = 33  
>>> aDict  
{'host': 33, 'port': 8080}  
复制代码

10.代码块和缩进对齐
代码块通过缩进对齐表达代码逻辑而不是使用大括号。

11.if语句

if expression:  
    if_suite  
复制代码

如果expression的值是True或是非零，则代码组if_suite被执行。否则不执行。
代码组是Python中的术语，它由一条或是多条语句组成，表示一个子代码块。
if语句的形式还有两种：

if expression:  
    if_suite  
else:  
    else_suite  
  
if expression:  
    if_suite  
elif expression2:  
    elif_suite  
else:  
    else_suite  
复制代码

12.while语句

while expression:  
    while_suite  
复制代码

13.for语句和range()内建函数
Python中的for循环和传统的for循环（计数器循环）不一样，它更像shell中的foreach。

>>> for x in [1, 2, 3, 4]:  
...     print x  
...   
1  
2  
3  
4  
>>> for x in [1, 2, 3, 4]:  
...     print x,  
...   
1 2 3 4  
>>>   
复制代码

在print后面加逗号，表示打印之后不换行，只加一个空格。

>>> print 'We are the %s who say %s' % \  
... ('knights', ('Ni!' + ' ')*4)  
We are the knights who say Ni! Ni! Ni! Ni!   
>>>   
复制代码

range()内建函数：

>>> for x in range(3):  
...     print x  
...   
0  
1  
2  
>>>   
复制代码

对字符串来说：

>>> foo = 'abc'  
>>> for c in foo:  
...     print c  
...   
a  
b  
c  
复制代码

range()经常和len()函数一起用于字符串索引。在这里我们要显示每一个元素及其索引值：

>>> foo = 'abc'  
>>> for x in range(len(foo)):  
...     print foo[x], '(%d)' % x  
...   
a (0)  
b (1)  
c (2)  
>>>   
复制代码

enumerate()函数可以更好的实现这个功能：

>>> for i, ch in enumerate(foo):  
...     print ch, '(%d)' % i  
...   
a (0)  
b (1)  
c (2)  
复制代码

14.列表解析
你可以在一行中用一个for循环将所有值放到一个列表中：

>>> squared = [x **2 for x in range(4)]  
>>> for i in squared:  
...     print i  
...   
0  
1  
4  
9  
>>>   
复制代码

列表解析还能做更复杂的事，比如挑选出符合要求的值放入列表：

>>> sqd = [x ** 2 for x in range(8) if not x%2]  
>>> for i in sqd:  
...     print i  
...   
0  
4  
16  
36  
>>>   
复制代码

15.文件和内建函数open(),file()
如何打开文件：
handle = open(file_name, access_mode='r')
其中：file_name表示文件名称；access_mode可以是r（read），w（write），a（append）。还有一些特殊的，比如‘+’表示读写，‘b’表示二进制访问。如果未提供access_mode表示读取。
open成功之后，我们就可以通过handle去操作文件了。文件方法属性必须通过句点属性标识法访问：

>>> filename = raw_input('Enter the file name:')  
Enter the file name:tmp.txt  
>>> fileobj = open(filename, 'r')  
>>> for eachline in fileobj:  
...     print eachline,  
...   
1 hello  
2 world  
3 !  
>>> fileobj.close()  
复制代码

上面的例子适用于文件大小适中的文件。
file()内建函数的功能等于open().不过file()函数的名字更像一个工厂函数，类似于int()生成整数对象，dict()函数生成字典对象。


16.错误和异常：
编译时会检查语法错误，不过 Python 也允许在程序运行时检测错误。当检测到一个错误，Python 解释器就引发一个异常， 并显示异常的详细信息。程序员可以根据这些信息迅速定位问题并进行调试， 并找出处理错误的办法。
try-except语句：

try:  
    fileobj = open(filename, 'r')  
    for eachline in fileobj:  
        print eachline,  
    fileobj.close()  
except IOError, e:  
    print 'file open error:', e  
复制代码

我们也可以用raise语句故意引发一个异常。


17.函数

def func_name([arguments]):  
    "optional documentation string."  
    func_suite  
复制代码

例子：

>>> def addMe2Me(x):  
...     "apply + operation to argument"  
...     return (x+x)  
...   
>>> addMe2Me('abc')  
'abcabc'  
>>> addMe2Me(12)  
24  
>>> addMe2Me([10, 'chen'])  
[10, 'chen', 10, 'chen']  
>>>   
复制代码

默认参数：

>>> def foo(debug=True):  
...     "determine if in debug mode with default argument"  
...     if debug:  
...             print 'In debug mode.'  
...     print 'done'  
...   
>>> foo()  
In debug mode.  
done  
>>> foo(True)  
In debug mode.  
done  
>>> foo(False)  
done  
>>>   
复制代码

18.类class
Python并不强求你以面向对象的方式编程。定义类：

class ClassName(base_class[es]):  
    "optional documentation string"  
    static_member_declarations  
    method_declarations  
复制代码

base_class是可选的父类或是基类，可以是多个。class行之后是可选的文档字符串，静态成员定义，及方法定义。
例子：

class FooClass(object):   
    """my very first class: FooClass"""   
    version = 0.1 # class (data) attribute   
    def __init__(self, nm='John Doe'):   
        """constructor"""   
        self.name = nm # class instance (data) attribute   
        print 'Created a class instance for', nm   
    def showname(self):   
        """display instance attribute and class name"""   
        print 'Your name is', self.name   
        print 'My name is', self.__class__.__name__   
    def showver(self):   
        """display class(static) attribute"""   
        print self.version # references FooClass.version   
    def addMe2Me(self, x): # does not use 'self'   
        """apply + operation to argument"""   
        return x + x   
复制代码

在上面的例子中，我们定义了一个静态变量version，它将被所有的实例和四个方法共享。
当一个类实例被创建的时候，__init__()方法会自动执行，在类实例创建完毕后执行，类似于构建函数。__init__() 可以被当成构建函数， 不过不象其它语言中的构建函数， 它并不创建实例--它仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象的必要的初始化工作。通过创建自己的 __init__() 方法， 你可以覆盖默认的 __init__()方法（默认的方法什么也不做），从而能够修饰刚刚创建的对象。
如何创建类实例：

>>> foo1 = FooClass()  
Created a class instance for John Doe  
>>> foo1.showname()  
Your name is John Doe  
My name is FooClass  
>>>   
复制代码

19.模块
Python源文件的名字*.py，模块的名字就是不带.py后缀的文件名。一个模块创建之后，你可以在另一模块中使用import导入到这个模块来使用。
一旦import成功，就可以通过句点属性表示法访问。

import module_name  
module_name.variable  
module_name.func_name()  
复制代码

例子：

>>> import sys  
>>> sys.stdout.write("hello world.\n")  
hello world.  
>>> sys.platform  
'linux2'  
>>> sys.version  
'2.6.6 (r266:84292, Feb 22 2013, 00:00:18) \n[GCC 4.4.7 20120313 (Red Hat 4.4.7-3)]'  
>>>   
复制代码

PEP（Python Enhancement Proposal）Python增强提案。具体请看：http://www.python.org/dev/peps/

20.常用的函数
函数 描述
dir([obj]) 显示对象的属性，如果没有提供参数， 则显示全局变量的名字
help([obj]) 以一种整齐美观的形式 显示对象的文档字符串， 如果没有提供任何参数， 则会进入交互式帮助。
int(obj) 将一个对象转换为整数
len(obj) 返回对象的长度
open(fn, mode) 以 mode('r' = 读， 'w'= 写)方式打开一个文件名为 fn 的文件
range([[start,]stop[,step]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start 默认值为 0， step默认值为1。
raw_input(str) 等待用户输入一个字符串， 可以提供一个可选的参数 str 用作提示信息。
str(obj) 将一个对象转换为字符串
type(obj) 返回对象的类型（返回值本身是一个 type 对象！）




------------------------------------------------------------------------------------------------------------------





总结二

一.Python基础

python的注释是#，两行代码间的连接符是\

python的通过代码块和代码组来组成结构，代码块是缩进相同的代码，代码组是跟在while，if，def，class符号语句：后的语句不同的缩进深度区别不同的代码块，不同于C,C++等语言，不需要{}和;来实现代码的区分。

python的模块类似于java的package结构，通过import导入不同的模块，完成不同的功能。

import sys
复制代码

sys模块是python最基础的模块，类似java下的System模块。
python允许多重赋值如下

x,y,z=1,2,3
复制代码

python的标示符特别在于内建类型，类似全局变量的存在，在python解释器在开始导入，可重载，替换。（内建(__buildin__）)
特别要注意的是专用下划线标示符

_xxx        代表无法通过from module import *导入

__xxx__ 代表系统定义的名字，一般是内建类型

__xxx      代表类中的私用变量

编程风格一般缩进空格为4格

模块布局和实例程序

<pre name="code" class="python"># -*- coding: utf-8 -*- 
#可以输入中文了
'''这是一个测试模块'''
import sys#引入模块
import os#引入模块

debug = True#全局变量

class Fooclass(object):#基类是object,object就是__buildin__内建引入的全局变量
    '''本类的功能是xxx'''
    pass#注意什么都不写会报错，就算什么都不做，在python下也要写一个pass

def test():#后面是代码组
    '''test the fuction'''
    foo=Fooclass()#无需类型标识，自动识别，但是注意，这并不代表python下没有类型。
    
    if debug:
        print 'run_test()'

if __name__== '__main__':
    #__name__是python的保留属性，代表模块的名字，如果是__main__代表从本模块启动程序，否则一般情况下为模块的名字
    test()</pre>
复制代码

python的内存管理机制：
1.变量无需事先声明

2.变量无需指定类型

3.无需关心内存管理

4.del可直接释放资源

Python的垃圾收集器是一个引用计数器和循环垃圾收集器，创建并赋值变量，引用+1，del变量，引用-1


相关工具：

调试实现：pdb

记录器：logging模块


IDE：Eclipse+pydev

二.python object

标准类型:和其他语言的区别，多出来了Complex number复数,List列表，Tuple元组，Dictionary字典。

所有python最基础的类型就是type类型，python和java一样，都是对象。

print type(object)  
print type(type)  
复制代码

打印类型都是
<type 'type'>
<type 'type'>

type类型是其他类的元类，metaclass。

python的null值是None

python以栈帧的方式运行代码，保存上下文信息？python是C写的，应该就是写python是存储上下文的机制吧

python有一个特殊的语法，切片语法，多维sequence[start1:end1,start2:end2,...]，步进sequence[start:end:step]，类似如下

mylist=['123','456','789',['abc','def']]
print mylist[3:1:-1]
复制代码

输出[['abc', 'def'], '789']
python不支持的类型char/byte：长度为1的字符串表示，或8位整型
python不支持指针

python整型相当于C长整型，浮点数为双精度浮点数

三.python 数字操作

需要注意的有两点，python的地板除，//舍去小数点

乘方符号**,
四.python序列

python下的字符串，列表和元组都是序列

字符串：
成员关系符（in,not in）

连接关系符（+）

重复操作符（*）

切片操作符（[],[:],[::]），注意，切片操作符不会越界，怎么写都行。

字符串可直接索引

str1='abc'
str2='xyz'
str3=str1+str2 #连接符
str4=str1*3 #重复三个
str5=str5[1:3] #切片符
print str1 < str3 and str1=='abc'
print 'bc' in 'abcd'
复制代码

格式化字符串

print '%d' % 10 #类似于C语言  
复制代码

字符串模板实现

from string import Template  
s=Template('There are $(many) $(lang) Quotation Symbols'  
print s.subsititue(many=3,lang='python')  
复制代码

unicode字符

u'huang'

说明，'''huang''
注意：python不以‘\0’结尾

列表list，可添加append，可修改，，可构建堆栈，队列

注意：列表可嵌套
元组tuple，不可修改，但可连接数据

深拷贝，与浅拷贝

=是浅拷贝，只拷贝引用，copy拷贝对象

五.映射集合

字典类型

创建，访问，更新，清除dict元素

集合类型

六.条件和循环

range()和xrange()

if,while,for,break,pass语句

迭代器iter()

列表解析

[expr for iter_ver in iterable]

[x*3 for x in range(3)]

七.文件输入输出

八.异常

try:

    xxxx

except Exception,e：

    xxxx

else:

    xxxx(No exception)
finally:

    xxxx

with语法

with open('/etc/paswd','r') as f

    for eachline in f

        #....

触发异常

raise exception

断言

assert 1==1

九.函数式编程

python支持内嵌函数

# -*- coding: utf-8 -*- 
import sys

def function():
    '''innerfunction'''
    def inner_fuc():
        print 'innerfunc'
    print 'func'
    inner_fuc()

function()
复制代码

python支持装饰器

def deco(arg):
    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, arg))
            func()
            print("  after %s called [%s]." % (func.__name__, arg))
        return __deco
    return _deco
 
@deco("mymodule")
def myfunc():
    print(" myfunc() called.")
 
@deco("module2")
def myfunc2():
    print(" myfunc2() called.")
 
myfunc()
myfunc2()
复制代码

# -*- coding:gbk -*-
'''示例6: 对参数数量不确定的函数进行装饰，
参数用(*args, **kwargs)，自动适应变参和命名参数'''
 
def deco3(func):
    def _deco(*args, **kwargs):
        print("before %s called." % func.__name__)
        ret = func(*args, **kwargs)
        print("  after %s called. result: %s" % (func.__name__, ret))
        return ret
    return _deco
 
@deco
def myfunc4(a, b):
    print(" myfunc(%s,%s) called." % (a, b))
    return a+b
 
@deco
def myfunc5(a, b, c):
    print(" myfunc2(%s,%s,%s) called." % (a, b, c))
    return a+b+c
 
myfunc4(1, 2)
myfunc4(3, 4)
myfunc5(1, 2, 3)
myfunc5(3, 4, 5)
复制代码

注意python支持可变长参数，*arg是元组，**vargs是字典

匿名函数lambda

lambda x,y=2:x+y  
  
def add(x,y=2):  
  
    return x+y  
复制代码

闭包，封装函数

十.模块

十一.面向对象

对象，类，静态函数

元类

十二.执行环境

sys,os

学习了，不错。

学习了-------------------