python语法笔记

sublime Text2 快捷键：

快捷键	含义
command + B	运行
command + `	控制台
command + /	注释
command + alt + /	块注释
command + +	字体放大
command + -	字体缩小

---

python笔记

字符串方法	含义
title()	字符串每个单词首字母大写
strip()	删除字符串开头和结尾的空白

---

目录

• 函数
  
  • 传递任意数量的实参
  • 使用任意数量的关键字实参
  • 模块导入
• 类
  
  • 继承
  • 将实例用作属性
• 文件和异常
• 测试代码
  
  • 测试函数
  • 测试类

函数

传递任意数量的实参

#----形参名*toppings中的星号让python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中----

def make_pizza(*toppings):
    print toppings

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

输出：

('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

注意：若函数接受不同类型的实参，则*toppings应放在最后（与形参默认值类似）。

---

使用任意数量的关键字实参

#--形参**user_info中的两个星号让python创建一个名为user_info的空字典，并将收到的所有名称——值对都封装到这个字典中--

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile('albert', 'einstein', location='princeton', field='physics')
print user_profile

输出：
{'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton'}

---

模块导入

模块 是扩展名为.py的文件

#module_name.py
def function_0():
    pass

def function_1():
    pass

def function_2():
    pass
···

导入整个模块：

• import module_name
  调用函数使用句点：module_name.function_name()

给模块指定别名：import module_name as mn

导入特定的函数：（这个语法调用函数时无需使用句点）

• 导入模块的一个函数：from module_name import function_name
• 导入模块的多个函数：from module_name import function_0, function_1, function_2
• 导入模块的所有函数：from module_name import *（不推荐，函数名可能重复）

给函数指定别名：from module_name import function_name as fn
别名好处：导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长

---

类

继承

子类构造函数继承语法：

class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        return self.name +" is "+ str(self.age) + " years old."

class Dog(Animal):
    def __init__(self, name, age):
        super(Dog, self).__init__(name, age) #----python2.7亲测可用

# class Cat(Animal):
#   def __init__(self, name, age):
#       super().__init__(name, age)  #python3语法，未测试         

class Mouse(Animal):
    def __init__(self, name, age):
        Animal.__init__(self, name, age)    #----python2.7亲测可用

my_dog = Dog("Willie", "5")
# my_cat = Cat("Lucy", "3")
my_mouse = Mouse("Qiqi", "1")

print my_dog.show()
# print my_cat.show()
print my_mouse.show()

运行结果：

Willie is 5 years old.
Qiqi is 1 years old.

---

将实例用作属性

当给类添加的细节越来越多，属性和方法清单及文件越来越长时，可以将类的一部分作为一个独立的类提取出来，将大型类拆分成多个协同工作的小类。

例如，不断给子类Dog添加细节时，可以将该类中特有的属性和方法提取出来，放到另一个名为Behave的类中，并将Behave实例用作Dog类的一个属性：

animal.py

#coding:utf-8
class Animal(object):                       #父类
    def __init__(self, name, age):          #父类构造方法
        self.name = name                    #父类属性
        self.age = age

    def show(self):                         #父类方法
        return self.name +" is "+ str(self.age) + " years old."

#----------------将实例用作属性-----------------
class Behave(object):
    def __init__(self, skill = "run"):      #此处必须给出默认值，否则创建实例会报错
        self.skill = skill                  #子类特有属性

    def update_skill(self, arg):            #子类特有方法
        self.skill = arg

    def print_skill(self):
        print "My skill is " + self.skill + "."

class Dog(Animal):                          #子类
    def __init__(self, name, age):          #子类构造方法
        super(Dog, self).__init__(name, age)#继承
        self.behave = Behave()              #将实例用作属性

    def show(self):                         #重写父类方法
        return "重写："+ self.name +" is "+ str(self.age) + " years old."

#---------------------------------------------
my_dog = Dog("Willie", "5")                 #根据类创建实例
print my_dog.show()
my_dog.behave.print_skill()

my_dog.behave.skill = "swimming"            #修改属性的默认值（访问属性）
my_dog.behave.print_skill()

my_dog.behave.update_skill("jumping")       #修改属性的默认值（调用方法）
my_dog.behave.print_skill()

运行结果：

重写：Willie is 5 years old.
My skill is run.
My skill is swimming.
My skill is jumping.

---

文件和异常

方法	含义
json.dump()	存储数据
json.load()	读取数据

test.py

#coding:utf-8
import json

def get_stored_username():
    filename = 'username.json'
    try:                                        #异常判断
        with open(filename) as file_object:     #关键字with：在不再需要访问文件后将其关闭
            username = json.load(file_object)   #json.load()：读取数据
    except IOError:                             #如果异常则执行except语句块
        return None
    else:                                       #如果没有异常则执行else语句块
        return username
    finally:                                    #无论是否异常都会执行finally语句块
        pass

def get_new_username():
    username = raw_input("Please input your name: ")
    filename = 'username.json'
    with open(filename, 'w') as file_object:    #以写入模式('w')打开文件，默认为只读模式('r')        
        json.dump(username, file_object)        #json.dump()：存储数据
    return username

def greet_user():
    username = get_stored_username()
    if username:
        print "Welcome back " + username + "!"
    else:
        username = get_new_username()
        print "We'll remember you when you come back, " + username + "!"

greet_user()

---

测试代码

python在unittest.TestCase类中常用的断言方法：

方法	用途
assertEqual(a,b)	核实a == b
assertNotEqual(a,b)	核实a != b
assertTrue(x)	核实x 为True
assertFalse(x)	核实x 为False
assertIn(item,list)	核实 item在 list中
assertNotIn(item,list)	核实 item不在 list中

---

测试函数

例如，测试上文test.py文件的get_stored_username函数：
test_test.py

#coding:utf-8
import unittest                                                 #导入模块unittest
from test import get_stored_username                            #导入要测试的函数

class UsernameTestCase(unittest.TestCase):                      #创建继承unittest.TestCase的类
    def test_get_stored_username1(self):                        #编写方法测试
        username = ["Lucy","fjhkhjkg"]
        self.assertNotIn(username[0], get_stored_username())    #调用断言方法

    def test_get_stored_username2(self):
        username = ["Lucy","fjhkhjkg"]
        self.assertIn(username[1], get_stored_username())

unittest.main()                       

运行结果：

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

---

测试类

setUp()方法：
unittest.TestCase类包含的setUp()方法，让我们只需创建一次实例，在每个测试方法中都可使用，避免在每个测试方法中都创建一次实例。

例如，测试上文animal.py文件的Animal类（该例只编写了一个测试方法）：
test_animal.py

#coding:utf-8
import unittest                                         #导入模块unittest
from animal import Animal                               #导入要测试的类

class AnimalTestCase(unittest.TestCase):                #创建继承unittest.TestCase的类
    def setUp(self):                                    #方法setUp()
        self.animal = Animal("Willie", "5")             #创建一次实例，测试方法都可使用

    def test_animal1(self):                             #编写方法测试
        message = "Willie is 5 years old."
        self.assertEqual(message, self.animal.show())   #调用断言方法

unittest.main()

运行结果：

.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK