python 基础笔记

1，去掉了C语言中的大括号，用空格来对齐语句块。（空格一般用2个或4个，但没有限制）

2，要在py文件代码中使用中文，需要在第一行加入下面的代码：

# -*- coding: utf-8 -*-

或者是：

#coding: utf-8

3，执行python文件的命令：>>>python first.py

4，注释用#号。

5，算数运算 1/2 结果是0，  1.0/2 结果是 0.5。两个操作数都是整数，按整除处理。

指数运算符是**，print 2**3，结果是8.

6，变量不需要声明类型。s="Hello”;s=5;s=5.0。同一变量可以被多次赋予不同类型的值。

7，输出语句print

# 直接输出字符串
print "Hello World"
# 直接输出多个字符串
print "Hello World","Python","Study"
# 字符串格式化输出
print "Let's talk about %s." % my_name
# 整数格式化输出
print "He's %d cm tall." % my_height
# 多个参数的输出
print "He's got %s eyes and %s hair." % (my_eyes, my_hair)

%r: String (converts any Python object using repr()).

%s: String (converts any Python object using str()).

8，print语句会自动换行，若不想换行需要在最后加一个逗号（python2.x）。

print "Hello",
print "World"

9，一行代码太长，可以在行末加‘\’反斜杠换行书写。

print end1 + end2 \
+ end3

10，\n代表换行。\是转义符，这个和C#是一致的。例如：\”可以转义双引号。

11，三个双引号中间可以放置多行语句块，并且不需要转义。

print """
There's something going on here.
With the three double-quotes.
We'll be able to type as much as we like.
Even 4 lines if we want,or 5,or 6.
"""

12，正确显示字符串中的特殊字符，可以使用\进行转义；也可以用三个引号的方式括起来，这就不需要转义了。

13，输入函数：

print "How old are you?",

age = raw_input()

等价于

age = raw_input("How old are you?")

还有一个input函数，要求输入一个python表达式，计算后会得到相应的类型。

而raw_input函数把输入都看作字符串。需要我们自己转型，int(raw_input())，这样就转成整型。

14，格式化字符串是%r，不是\r，我又犯错了。

15，获取Python 命令后面的参数，需要引入sys模块的argv。

from sys import argv

#参数赋值给下面3个变量，第一个是python文件名
pythonfile，firstArg，secondArg=argv

#或者将所有输入赋值给一个数组
allArgument=argv

16，打印文件内容是print fp.read(), 不是print fp，fp仅仅是一个文件句柄。

17，用%r进行格式化，变量为字符串的话，会在字符串两边加上单引号‘ 或双引号“。如果将字符串格式化输出到文件，还是用%s比较好。

18，函数申明用def。

# * 代表参数是不定的
def print_two(*args):
    arg1, arg2 = args
    print "arg1: %r arg2: %r" % (arg1, arg2)

# 一个参数
def print_one(arg1):
    print "arg1: %r" % arg1	

# 没有参数	
def print_none():
    print "I got nothing."

print_two("Zed","Shaw")
print_one("First!")
print_none()

19，函数可以返回多个变量，这一点确实是个亮点。

def secret_formula(started):
    jelly_beans = started * 500
    jars = jelly_beans / 1000
    crates = jars / 100
    return jelly_beans, jars, crates

start_point = 10000
beans, jars, crates = secret_formula(start_point)

20，引用模块的某个函数，比如ex25.py的openfile函数，如果引用的是import ex25，则调用的时候ex25.openfile，前面的ex25模块名不能少。如果用from ex25 import openfile 的方式的话，就可以不写ex25前缀。from ex25 import * ,可以导入ex25的所有函数，虽然和import ex25差不多，但是可以避免写前缀。

21，pop函数会删除对应索引的元素，即便是调用函数，数组的传递方式和c#一样，是引用传递，值依然会被删除掉。

22，多条件语句是 if … elif…else…

23，range(0,5) 返回的数组的值是[0,1,2,3,4]，不包含5.

24，for 语句 for i in range(0,4):    print i

25，while语句 while i<5: print i   i++

26，exit(0) 正常退出程序。 from sys import exit.

27，in 测试元素在某个集合中。

>>> lst = [1, 2, 3]
>>> 1 in lst
True
>>> myStr = "you are very good"
>>> "o" in myStr
True
>>> "are" in myStr
True
>>> "dd" in myStr
False
>>> 

28，两个正斜杠\\代表向下取整除。3//2.0 == 1.0

29，yield可以实现迭代，然后在for语句中使用，这个和C#是一样的。

# yield
def getOdd(max):
    i = 1 
    while i < max:
        if i % 2 == 1:
            yield i
        i += 1 # notation: python hasn't ++ operation

for odd in getOdd(10):
    print odd, ",",   

30，with语句，其实和C#的using语句是差不多的。

# with
# file object implements the __enter__ and __exit__ method
# so we can use directly
with open(r"E:\temp\py\test.txt") as f:
    print f.read()

# the follow line will get a closed file, becase
# file is closed in the __exit__ method 
print f 

可以自己写个类实现__enter__ 和 __exit__方法，注意__exit__必须带有四个参数。

31，try/catch/else/finally

# try/except/else/finally
def divideNum(a, b):
    try:
        num = a / b
        raise NameError("badName") # raise a error
    except ZeroDivisionError:
        print "Divide by Zero"   
    except NameError as e:
        print "message:%s" % e.message
    except:
        print "there is an error"
        raise # re-raise the error
    else:
        print "there is no error. num=%r" % num    
    finally:
        print "this is finally block"
   
print divideNum(10, 2) 
print divideNum(10, 0)

32，要在函数中使用模块中定义的变量,需要在函数中对模块中的变量用global关键字

def change():
    global x
    x = 2
    
x = 50
change()
print "x=%d" % x    

上面的结果是2。注意：如果只是访问x的值，不加global也是可以的，但不建议这么做，这不利于代码阅读。

如果本地变量和模块变量同名了，可以用内置函数globals来访问模块变量

def change(x):
    globals()['x'] = 2
    
x = 50
change(x)
print "x=%d" % x   

33，exec执行python语句，eval计算python表达式的值，结果是表达式运算后的类型。

# excute python statement 
exec("print 'abc'")
exec("a = 1 + 2")
print a
# compute python statement
n = eval("1 + 3")
# out put <type 'int'>
print type(n)

34，删除数组的一个元素用del语句。

lst = [1,2,3]
print lst
# delete the last element
del lst[2]
print lst
# delete all the element
del lst
# the follew line will be error
print lst

35，数组中可以存不同类型的值。lst=[‘one’,1,2,’zhang’]是合法的。

36，字典用大括号{}来声明.

# 声明一个字典
cities = {
    'CA': 'San Francisco',
    'MI': 'Detroit',
    'FL': 'Jacksonville'
}

# 设值，key不存在会自动添加
cities['NY'] = 'New York'
cities['OR'] = 'Portland'

# 取值
city = cities['TX'] 

# 用get方法取值，不存在会返回第二个参数的默认值
city = cities.get('TX', 'Does Not Exist')
    

37，字典中的key也可以是不同类型的值，这和强类型语言不一样（如C#要求key值必须是同一种类型）。

38，类的函数的第一个参数必须是self。

39，python支持多继承。super不等同于java或C#的this，使用super可以避免父类函数的重复调用，python采用MRO(Method resolution order)来决定函数的调用顺序。

class Animal(object):
    def __init__(self):
        print "Animal"
        super(Animal,self).__init__()

class Dog(Animal):
    def __init__(self):
        self.ear ="dogear"
        print "Dog"
        super(Dog,self).__init__()

class Bird(Animal):
    def __init__(self, swing):
        self.swing = swing
        print "Bird"
        super(Bird,self).__init__()
        
class FlyDog(Dog,Bird):
    def __init__(self):
        print "FlyDog"
        super(FlyDog,self).__init__() 
        
print "MRO:",[c.__name__ for c in FlyDog.__mro__]
# the next line will be error!
d = FlyDog()

上面的代码会出错，原因是mro的顺序是FlyDog→Dog→Bird→Animal→object，而调用Bird的__init__方法需要一个额外的参数swing，我们并没有传递这个参数，所以出错了。这里要记住，super不是调用父类，而是根据mro的顺序依次调用函数，mro保证了父类函数不被重复调用。

MRO: ['FlyDog', 'Dog', 'Bird', 'Animal', 'object']
FlyDog
Dog
Traceback (most recent call last):
  File "ex42.py", line 24, in <module>
    d = FlyDog()
  File "ex42.py", line 21, in __init__
    super(FlyDog,self).__init__()
  File "ex42.py", line 10, in __init__
    super(Dog,self).__init__()
TypeError: __init__() takes exactly 2 arguments (1 given)

40，doctest，这是python特有的测试方法，测试代码放在文档注释中，然后用内置的doctest进行测试。

def add(a, b):
    """
    >>> add(1, 2)
    3
    """
    return a + b

if __name__ == '__main__': 
    import doctest
    doctest.testmod()

1) 自己的python文件名不能是doctest.py，不能和内置的doctest冲突，否则出现：

'module' object has no attribute 'testmod' 错误

2） 文档注释中>>> 后面有一个空格，紧接着下面的一行是结果，可以在idle中运行结果后，copy到这里。

41，在idle中执行自定义的python文件（test.py）。需要这样做：

1) 确认下sys.path里有没有包含test.py所在目录的路径。

import sys
print sys.path

2）如果没有，可以这样添加

sys.path.append(r’E:\temp\py’)

3)然后就可以引入自己的模块，执行里面的函数了。

import test
test.add(1,2)

42，查看当前的工作目录，改变当前的工作目录命令是：

import os
os.getcwd() #得到当前的工作目录
os.chdir（r’新的工作目录’)

43，包管理工具pip。

pip是easy_inastall的替代者。可以用它来安装包，卸载包，以及更新包。

安装pip，到pip官网上下载get-pip.py文件，如下安装：

接下来就可以通过pip，安装其他的工具包了。

 #安装distribute包
pip install distribute

 #安装版本小于等于1.3的distribute包
pip install 'distribute<=1.3'

 #更新distribute包
pip install -U distribute

 #卸载distribute包
pip uninstall distribute

44，unittest工具nose。可以通过pip进行安装，pip install nose。

这个工具类似于Junit，安装完成后，会在C:\Program Files\Python27\Scripts下添加一个nosetests.exe文件。

只要在shell下切换到我们的工程目录，输入nosetest他就会自动去找带有【test】的文件夹，文件，然后运行其中的方法。

注意哦，方法名也必须含有test，可以是前缀或后缀，但中间用下划线_区分，不然不会被当作测试方法。

具体nose的用法，可以百度参看更多的内容。

45，元组（tuple），是不能修改的list，声明用小括号

    DIRECTIONS = ('north', 'south', 'west', 'east')
    VERBS = ('go', 'kill', 'eat')

46，TDD（测试驱动开发），在编写python代码时应该坚持这个原则。

47，查看nose提供了哪一些测试函数，可以借助pydoc（windows上安装完后，菜单中有一个Module docs的程序），启动后输入nose.tools，在搜索出的信息中，点击要查看的条目，就可以在网页中查看了。这个方法还可以查看python的其他一些标准模块的信息，图形化的很方便。

48，nose的测试用例。

def test_parse():
    word_list = lexicon.scan("princess go to the north")
    sentence = parser.parse_sentence(word_list)
    # 第一个参数是待比较的值，第二个是期待值，
    # 第三个是失败的时候报的msg（一般不用）
    assert_equal(sentence.subject,'princess', msg='error, princess is wrong!')
    assert_equal(sentence.verb, 'go')
    assert_equal(sentence.object, 'north')    

    # 异常测试
    word_list = lexicon.scan("abc")
    # 写法一，第一个参数是异常类型，第二参数是调用的方法
    #            第三个参数是方法的参数（可以是多个参数）
    assert_raises(ParserError, parser.parse_sentence, word_list)

    # 写法二，用with块捕捉特定的异常，结果放在context manager（cm）中
    # cm.exception可以取到异常，然后可以比较异常的自定义信息等
    with assert_raises(ParserError) as cm:
        parser.parse_sentence(word_list)
    the_exception = cm.exception
    assert_equal(the_exception.message, "Expected a none next.")   

49，模块方法提炼到类中，参数要多一个self，内部方法的调用也要用self调用，注意看前后区别：

    def sentence(word_list):
        subj = subject(word_list)
        verb = verb(word_list)
        obj = object(word_list)
        
        return Sentence(subj, verb, obj)
#↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
class A(object):
    def sentence(self, word_list):
        subj = self.subject(word_list)
        verb = self.verb(word_list)
        obj = self.object(word_list)
        
        return Sentence(subj, verb, obj)

50，实例方法，类方法，静态方法区别：

●类方法和静态方法都可以被类和类实例调用。类方法和静态方法需要用@classmethod，@staticmethod来标注。

●实例方法也可以被类调用，只要传入一个类实例作为参数就可以。

●实例方法的隐含参数是实例，类方法的隐含参数是类，静态方法没有隐含参数。

class A(object):
    clsName = 'zhang'
    
    def __init__(self, name):
        self.name = name
        
    def instanceMethod(self):
        print "instanceMethod", self.name, A.clsName    
        
    @classmethod
    def clsMethod(cls):
        print "clsMethod", cls.clsName
    
    @staticmethod    
    def staticMethod():
        print "staticMethod", A.clsName    

if __name__== "__main__":
    a = A('li')
    a.instanceMethod()   
    a.clsMethod() 
    a.staticMethod()    
    A.clsMethod()
    A.staticMethod()
    # 类也可以调用实例方法
    A.instanceMethod(a)

51，python中一切都是对象。数字，字符串，tuple是不可变的对象。list和dic是可变的对象。

这一点和c#是不一样的，既然python中万物都是对象，那就只能是引用传递，但由于不可变对象的存在，一旦试图去改变不可变对象，就会生成一个新的对象。

看看下面这段代码每个对象的id值吧（id相当于内存地址），这对于我们认识实例变量，类变量有一定的帮助。

>>> def add(x):	
	print id(x) # 这里的x和外面的n是指向同一个对象，但是是不同的变量
	x = x + 0 # x指向一个新的对象了
	print id(x)
	
>>> n = 7800
>>> id(n)
12497808
>>> add(n)
12497808
12497676
>>> 

52，数组在初始化时做简单的操作。

>>> lst = [s.strip("\'\"") for s in ("\"def\'","abc")]
>>> lst
['def', 'abc']

上面这种方式比较简洁，对于这种去掉前后的特殊字符的简单操作，完全没有必要去单写一个for循环来做，在一句话里就可以搞定。