python 基础笔记

liwya

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