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循环来做，在一句话里就可以搞定。