单词 | 解释 | 备注 |
---|---|---|
global | adj全球的,全球性的,有关全球大局的; 全面的,整体的,全局的; 球形的,球状的,球面的,球体的; [计] 全程的; | 定义全局变量 |
if expression: do this |
---|
number = int(input("Enter a number: ")) if number < 100: print("The number is less than 100") else: print("The number is greater than 100") |
---|
x = int(input("Please enter an integer: ")) if x < 0: x = 0 print('Negative changed to zero') elif x == 0: print('Zero') elif x == 1: print('Single') else: print('More') |
---|
while condition: statement1 statement2 |
---|
通过 for 语句我们可以使用 for 循环。Python 里的 for 循环与 C 语言中的不同。这里的 for 循环遍历任何序列(比如列表和字符串)中的每一个元素。下面给出示例:
a = ['JinBang1993', 'is', 'powerful'] for x in a: print(x) JinBang1993 is powerful |
---|
>>> a[0] 1 >>> a[4] 'Fedora' |
---|
>>> a.insert(0, 1) # 在列表索引 0 位置添加元素 1 >>> a [1, 23, 45, 1, -3434, 43624356, 234, 45] >>> a.insert(0, 111) # 在列表索引 0 位置添加元素 111 >>> a [111, 1, 23, 45, 1, -3434, 43624356, 234, 45] |
---|
>>> divmod(15,2) (7, 1) >>> x, y = divmod(15,2) >>> x 7 >>> y 1 |
---|
>>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'} >>> data {'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'} >>> data['kart_'] 'Debian' |
---|
试图索引一个不存在的键将会抛出一个 keyError 错误。我们可以使用 dict.get(key, default) 来索引键,如果键不存在,那么返回指定的 default 值。
>>> data['foo'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'foo' >>> data.get('foo', 0) 0 |
---|
如果你想要在遍历列表(或任何序列类型)的同时获得元素索引值,你可以使用 enumerate()。
>>> for i, j in enumerate(['a', 'b', 'c']): ... print(i, j) ... 0 a 1 b 2 c |
---|
你也许需要同时遍历两个序列类型,你可以使用 zip() 函数。
>>> a = ['Pradeepto', 'Kushal'] >>> b = ['OpenSUSE', 'Fedora'] >>> for x, y in zip(a, b): ... print("{} uses {}".format(x, y)) ... Pradeepto uses OpenSUSE Kushal uses Fedora |
---|
方法 title() 返回字符串的标题版本,即单词首字母大写其余字母小写
方法 upper() 返回字符串全部大写的版本,反之 lower() 返回字符串的全部小写版本。
方法 swapcase() 返回字符串大小写交换后的版本 :)
方法 isalnum() 检查所有字符是否为字母数字,包含空格也会返回false
方法 isalpha() 检查字符串之中是否只有字母,包含空格也会返回false
>>> s = "1234" >>> s.isdigit() # 检查字符串是否所有字符为数字 True >>> s = "ShiYanLou is coming" >>> s.islower() # 检查字符串是否所有字符为小写 False >>> s = "Shiyanlou Is Coming" >>> s.istitle() # To 检查字符串是否为标题样式 True >>> s = "CHINA" >>> s.isupper() # 检查字符串是否所有字符为大写 True |
---|
我们可以使用 split() 分割任意字符串,split() 允许有一个参数,用来指定字符串以什么字符分隔(默认为 " "),它返回一个包含所有分割后的字符串的列表。
方法 join() 使用指定字符连接多个字符串,它需要一个包含字符串元素的列表作为输入然后连接列表内的字符串元素
字符串有几个进行剥离操作的方法。最简单的一个是 strip(chars),用来剥离字符串首尾中指定的字符,它允许有一个字符串参数,这个参数为剥离哪些字符提供依据。不指定参数则默认剥离掉首尾的空格和换行符
你可以使用 lstrip(chars) 或 rstrip(chars) 只对字符串左或右剥离
find() 能帮助你找到第一个匹配的子字符串,没有找到则返回 -1。
>>> s = "faulty for a reason" >>> s.find("for") 7 >>> s.find("fora") -1 >>> s.startswith("fa") # 检查字符串是否以 fa 开头 True >>> s.endswith("reason") # 检查字符串是否以 reason 结尾 True |
---|
定义一个函数
def functionname(params): statement1 statement2 |
---|
让我们编写一个函数,它将接受两个整数作为输入,然后返回总和。
>>> def sum(a, b): ... return a + b |
---|
map 是一个在 Python 里非常有用的高阶函数。它接受一个函数和一个序列(迭代器)作为输入,然后对序列(迭代器)的每一个值应用这个函数,返回一个序列(迭代器),其包含应用函数后的结果。
>>> lst = [1, 2, 3, 4, 5] >>> def square(num): ... "返回所给数字的平方." ... return num * num ... >>> print(list(map(square, lst))) [1, 4, 9, 16, 25] |
---|
我们使用 open() 函数打开文件。它需要两个参数,第一个参数是文件路径或文件名,第二个是文件的打开模式(默认的模式为只读模式,也就是说如果你不提供任何模式,open() 函数将会以只读模式打开文件)。模式通常是下面这样的:
"r" | 以只读模式打开,你只能读取文件但不能编辑/删除文件的任何内容 |
---|---|
"w" | 以写入模式打开,如果文件存在将会删除里面的所有内容,然后打开这个文件进行写 |
"a" | 以追加模式打开,写入到文件中的任何数据将自动添加到末尾 |
close()方法完成文件按关闭
始终确保你显式关闭每个打开的文件,一旦它的工作完成你没有任何理由保持打开文件。因为程序能打开的文件数量是有上限的。如果你超出了这个限制,没有任何可靠的方法恢复,因此程序可能会崩溃。每个打开的文件关联的数据结构(文件描述符/句柄/文件锁...)都要消耗一些主存资源。因此如果许多打开的文件没用了你可以结束大量的内存浪费,并且文件打开时始终存在数据损坏或丢失的可能性。
使用read()方法一次性读取整个文件,如果你再一次调用 read(),它会返回空字符串因为它已经读取完整个文件
read(size) 有一个可选的参数 size,用于指定字符串长度。如果没有指定 size 或者指定为负数,就会读取并返回整个文件。当文件大小为当前机器内存两倍时,就会产生问题。反之,会尽可能按比较大的 size 读取和返回数据。
使用 readlines() 方法读取所有行到一个列表中。
你可以循环遍历文件对象来读取文件中的每一行。
>>> fobj = open('sample.txt') >>> for x in fobj: ... print(x, end = '') ... I love Python I love shiyanlou >>> fobj.close() |
---|
文件写入
让我们通过 write() 方法打开一个文件然后我们随便写入一些文本。
>>> fobj = open("ircnicks.txt", 'w') >>> fobj.write('powerpork\n') >>> fobj.write('indrag\n') >>> fobj.write('mishti\n') >>> fobj.write('sankarshan') >>> fobj.close() |
---|
在实际情况中,我们应该尝试使用 with 语句处理文件对象,它会在文件用完后会自动关闭,就算发生异常也没关系。它是 try-finally 块的简写:
>>> with open('sample.txt') as fobj: ... for line in fobj: ... print(line, end = '') ... I love Python I love shiyanlou |
---|
#!/usr/bin/env python3 import sys if len(sys.argv) < 3: print("Wrong parameter") print("./copyfile.py file1 file2") sys.exit(1) f1 = open(sys.argv[1]) s = f1.read() f1.close() f2 = open(sys.argv[2], 'w') f2.write(s) f2.close() |
---|
你可以看到我们在这里使用了一个新模块 sys。sys.argv 包含所有命令行参数。这个程序的功能完全可以使用 shell 的 cp 命令替代:在 cp 后首先输入被拷贝的文件的文件名,然后输入新文件名。
sys.argv 的第一个值是命令自身的名字
使用try…except块来处理异常。基本的语法如下
try: statements to be inside try clause statement2 statement3 ... except ExceptionName: statements to evaluated in case of ExceptionName happens |
---|
它以如下方式工作:
l首先,执行 try 子句 (在 try 和 except 关键字之间的部分)。
l如果没有异常发生,except 子句 在 try 语句执行完毕后就被忽略了。
l如果在 try 子句执行过程中发生了异常,那么该子句其余的部分就会被忽略。
l如果异常匹配于 except 关键字后面指定的异常类型,就执行对应的 except 子句。然后继续执行 try 语句之后的代码。
l如果发生了一个异常,在 except 子句中没有与之匹配的分支,它就会传递到上一级 try 语句中。
l如果最终仍找不到对应的处理语句,它就成为一个 未处理异常,终止程序运行,显示提示信息。
使用 raise 语句抛出一个异常。
>>> raise ValueError("A value error happened.") Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: A value error happened. |
---|
try 语句还有另一个可选的 finally 子句,目的在于定义在任何情况下都一定要执行的功能
不管有没有发生异常,finally 子句 在程序离开 try 后都一定会被执行。当 try 语句中发生了未被 except 捕获的异常(或者它发生在 except 或 else 子句中),在 finally 子句执行完后它会被重新抛出。
在真实场景的应用程序中,finally 子句用于释放外部资源(文件或网络连接之类的),无论它们的使用过程中是否出错。
Python的错误其实也是class,所有的错误类型都继承自BaseException
,所以在使用except
时需要注意的是,它不但捕获该类型的错误,还把其子类也“一网打尽”。
如果不捕获错误,自然可以让Python解释器来打印出错误堆栈,但程序也被结束了。既然我们能捕获错误,就可以把错误堆栈打印出来,然后分析错误原因,同时,让程序继续执行下去。
Python内置的logging
模块可以非常容易地记录错误信息:
模块是代码的归类,能定义函数、类和变量,把相关的代码分配到一个模块里,能让你的代码更好用,更易懂、也更简洁。模块在java中叫做类库。
模块可以是单个.py文件,也可以是一个文件夹(里面存放n多个.py文件)。
l内置模块:如os和sys是两个非常常见的和操作系统交互的模块;file是文件操作相关的模块;比较常用的一些模块如:logging、time/datetime、json/pickle
l自定义模块:自己写的py文件或者文件夹(可含多个py文件)
l第三方模块:如requests、math等
class Student(object): pass |
---|
class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类。
定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的:
>>> bart = Student() >>> bart <__main__.Student object at 0x10a67a590> >>> Student <class '__main__.Student'> |
---|
如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在python中,实例的变量名如果以__开头,就变成了一个私有变量(private),内有内部可以访问,外部不可以访问。
可以通过给属性增加相应的get、set方法来访问和修改属性的值,通过定义方法来访问或修改属性的值,可以在方法中对参数来做检查,避免传入无效的参数
【注意】
在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__、__score__这样的变量名。
有些时候,你会看到以一个下划线开头的实例变量名,比如_name,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。
对于静态语言(例如Java)来说,如果需要传入Animal类型(假如调用的事Animal的run方法),则传入的对象必须是Animal类型或者它的子类,否则,将无法调用run()方法。
对于Python这样的动态语言来说,则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了:
这就是动态语言的“鸭子类型”,它并不要求严格的继承体系,一个对象只要“看起来像鸭子,走起路来像鸭子”,那它就可以被看做是鸭子。
Python的“file-like object“就是一种鸭子类型。对真正的文件对象,它有一个read()方法,返回其内容。但是,许多对象,只要有read()方法,都被视为“file-like object“。许多函数接收的参数就是“file-like object“,你不一定要传入真正的文件对象,完全可以传入任何实现了read()方法的对象。
继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。
动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。
当我们拿到一个对象的引用时,如何知道这个对象是什么类型、有哪些方法呢?
首先,我们来判断对象类型,使用type()
函数:
基本类型都可以用type()
判断:
>>> type(
123)
<
class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>
如果一个变量指向函数或者类,也可以用type()
判断:
>>> type(abs)
<
class 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>
但是type()
函数返回的是什么类型呢?它返回对应的Class类型。如果我们要在if
语句中判断,就需要比较两个变量的type类型是否相同:
>>> type(
123)==type(
456)
True
>>> type(
123)==int
True
>>> type(
'abc')==type(
'123')
True
>>> type(
'abc')==str
True
>>> type(
'abc')==type(
123)
False
判断基本数据类型可以直接写int
,str
等,但如果要判断一个对象是否是函数怎么办?可以使用types
模块中定义的常量:
>>> import types
>>> def fn():
... pass
...
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(
lambda x: x)==types.LambdaType
True
>>> type((x
for x
in range(
10)))==types.GeneratorType
True
对于class的继承关系来说,使用type()
就很不方便。我们要判断class的类型,可以使用isinstance()
函数。
我们回顾上次的例子,如果继承关系是:
object -> Animal -> Dog -> Husky
那么,isinstance()
就可以告诉我们,一个对象是否是某种类型。先创建3种类型的对象:
>>> a = Animal()
>>> d = Dog()
>>> h = Husky()
然后,判断:
>>> isinstance(h, Husky)
True
没有问题,因为h
变量指向的就是Husky对象。
再判断:
>>> isinstance(h, Dog)
True
h
虽然自身是Husky类型,但由于Husky是从Dog继承下来的,所以,h
也还是Dog类型。换句话说,isinstance()
判断的是一个对象是否是该类型本身,或者位于该类型的父继承链上。
因此,我们可以确信,h
还是Animal类型:
>>> isinstance(h, Animal)
True
同理,实际类型是Dog的d
也是Animal类型:
>>> isinstance(d, Dog)
and isinstance(d, Animal)
True
但是,d
不是Husky类型:
>>> isinstance(d, Husky)
False
能用type()
判断的基本类型也可以用isinstance()
判断:
>>> isinstance(
'a', str)
True
>>> isinstance(
123, int)
True
>>> isinstance(
b'a', bytes)
True
并且还可以判断一个变量是否是某些类型中的一种,比如下面的代码就可以判断是否是list或者tuple:
>>> isinstance([
1,
2,
3], (
list, tuple))
True
>>> isinstance((
1,
2,
3), (
list, tuple))
True
总是优先使用isinstance()判断类型,可以将指定类型及其子类“一网打尽”。
如果要获得一个对象的所有属性和方法,可以使用dir()
函数,它返回一个包含字符串的list,比如,获得一个str对象的所有属性和方法:
>>> dir(
'ABC')
[
'__add__',
'__class__',...,
'__subclasshook__',
'capitalize',
'casefold',...,
'zfill']
类似__xxx__
的属性和方法在Python中都是有特殊用途的,比如__len__
方法返回长度。在Python中,如果你调用len()
函数试图获取一个对象的长度,实际上,在len()
函数内部,它自动去调用该对象的__len__()
方法,所以,下面的代码是等价的:
>>> len(
'ABC')
3
>>> 'ABC'.__len__()
3
我们自己写的类,如果也想用len(myObj)
的话,就自己写一个__len__()
方法:
>>> class MyDog(object):
... def __len__(self):
... return 100
...
>>> dog = MyDog()
>>> len(dog)
100
剩下的都是普通属性或方法,比如lower()
返回小写的字符串:
>>> 'ABC'.lower()
'abc'
仅仅把属性和方法列出来是不够的,配合getattr()
、setattr()
以及hasattr()
,我们可以直接操作一个对象的状态:
>>> class MyObject(object):
... def __init__(self):
... self.x =
9
... def power(self):
... return self.x * self.x
...
>>> obj = MyObject()
紧接着,可以测试该对象的属性:
>>> hasattr(obj,
'x')
# 有属性'x'吗?
True
>>> obj.x
9
>>> hasattr(obj,
'y')
# 有属性'y'吗?
False
>>> setattr(obj,
'y',
19)
# 设置一个属性'y'
>>> hasattr(obj,
'y')
# 有属性'y'吗?
True
>>> getattr(obj,
'y')
# 获取属性'y'
19
>>> obj.y
# 获取属性'y'
19
如果试图获取不存在的属性,会抛出AttributeError的错误:
>>> getattr(obj, 'z') # 获取属性'z'
Traceback (most recent call last):
File
"
<stdin>", line 1, in
<module>
AttributeError: 'MyObject' object has no attribute 'z'
可以传入一个default参数,如果属性不存在,就返回默认值:
>>> getattr(obj,
'z',
404)
# 获取属性'z',如果不存在,返回默认值404
404
也可以获得对象的方法:
>>> hasattr(obj,
'power')
# 有属性'power'吗?
True
>>> getattr(obj,
'power')
# 获取属性'power'
<bound method MyObject.power of <__main__.MyObject object at
0x10077a6a0>>
>>> fn = getattr(obj,
'power')
# 获取属性'power'并赋值到变量fn
>>> fn
# fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at
0x10077a6a0>>
>>> fn()
# 调用fn()与调用obj.power()是一样的
81
通过内置的一系列函数,我们可以对任意一个Python对象进行剖析,拿到其内部的数据。要注意的是,只有在不知道对象信息的时候,我们才会去获取对象信息。如果可以直接写:
sum = obj.x + obj.y
就不要写:
sum = getattr(obj, 'x') + getattr(obj, 'y')
一个正确的用法的例子如下:
def readImage(fp):
if hasattr(fp,
'read'):
return readData(fp)
return None
假设我们希望从文件流fp中读取图像,我们首先要判断该fp对象是否存在read方法,如果存在,则该对象是一个流,如果不存在,则无法读取。hasattr()
就派上了用场。
请注意,在Python这类动态语言中,根据鸭子类型,有read()
方法,不代表该fp对象就是一个文件流,它也可能是网络流,也可能是内存中的一个字节流,但只要read()
方法返回的是有效的图像数据,就不影响读取图像的功能。
由于Python是动态语言,根据类创建的实例可以任意绑定属性。
给实例绑定属性的方法是通过实例变量,或者通过self变量:
class Student(object):
def __init__(self, name):
self.name = name
s = Student('Bob')
s.score = 90
但是,如果Student类本身需要绑定一个属性呢?可以直接在class中定义属性,这种属性是类属性,归Student类所有:
class Student(object):
name = 'Student'
当我们定义了一个类属性后,这个属性虽然归类所有,但类的所有实例都可以访问到。来测试一下:
>>> class Student(object):
... name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失,用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了
Student
从上面的例子可以看出,在编写程序的时候,千万不要对实例属性和类属性使用相同的名字,因为相同名称的实例属性将屏蔽掉类属性,但是当你删除实例属性后,再使用相同的名称,访问到的将是类属性。
正常情况下,当我们定义了一个class,创建了一个class的实例后,我们可以给该实例绑定任何属性和方法,这就是动态语言的灵活性。先定义class:
class Student(object):
pass
然后,尝试给实例绑定一个属性:
>>> s = Student()
>>> s.name = 'Michael' # 动态给实例绑定一个属性
>>> print(s.name)
Michael
还可以尝试给实例绑定一个方法:
>>> def set_age(self, age): # 定义一个函数作为实例方法
... self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25
但是,给一个实例绑定的方法,对另一个实例是不起作用的:
>>> s2 = Student() # 创建新的实例
>>> s2.set_age(25) # 尝试调用方法
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
为了给所有实例都绑定方法,可以给class绑定方法:
>>> def set_score(self, score):
... self.score = score
...
>>> Student.set_score = set_score
给class绑定方法后,所有实例均可调用:
>>> s.set_score(100)
>>> s.score
100
>>> s2.set_score(99)
>>> s2.score
99
通常情况下,上面的set_score
方法可以直接定义在class中,但动态绑定允许我们在程序运行的过程中动态给class加上功能,这在静态语言中很难实现。
但是,如果我们想要限制实例的属性怎么办?比如,只允许对Student实例添加name
和age
属性。
为了达到限制的目的,Python允许在定义class的时候,定义一个特殊的__slots__
变量,来限制该class实例能添加的属性:
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
然后,我们试试:
>>> s = Student() # 创建新的实例
>>> s.name = 'Michael' # 绑定属性'name'
>>> s.age = 25 # 绑定属性'age'
>>> s.score = 99 # 绑定属性'score'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
由于'score'没有被放到__slots__中,所以不能绑定score属性,试图绑定score将得到AttributeError的错误。
使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的:
>>> class GraduateStudent(Student):
... pass
...
>>> g = GraduateStudent()
>>> g.score = 9999
除非在子类中也定义__slots__
,这样,子类实例允许定义的属性就是自身的__slots__
加上父类的__slots__
。
在绑定属性时,如果我们直接把属性暴露出去,虽然写起来很简单,但是,没办法检查参数,导致可以把成绩随便改:
s = Student()
s.score = 9999
这显然不合逻辑。为了限制score的范围,可以通过一个set_score()
方法来设置成绩,再通过一个get_score()
来获取成绩,这样,在set_score()
方法里,就可以检查参数:
class Student(object):
def get_score(self):
return self._score
def set_score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
现在,对任意的Student实例进行操作,就不能随心所欲地设置score了:
>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
但是,上面的调用方法又略显复杂,没有直接用属性这么直接简单。
有没有既能检查参数,又可以用类似属性这样简单的方式来访问类的变量呢?对于追求完美的Python程序员来说,这是必须要做到的!
还记得装饰器(decorator)可以给函数动态加上功能吗?对于类的方法,装饰器一样起作用。Python内置的@property
装饰器就是负责把一个方法变成属性调用的:
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score
= value
@property
的实现比较复杂,我们先考察如何使用。把一个getter方法变成属性,只需要加上@property
就可以了,此时,@property
本身又创建了另一个装饰器@score.setter
,负责把一个setter方法变成属性赋值,于是,我们就拥有一个可控的属性操作:
>>> s = Student()
>>> s.score = 60 # OK,实际转化为s.set_score(60)
>>> s.score # OK,实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
注意到这个神奇的@property
,我们在对实例属性操作的时候,就知道该属性很可能不是直接暴露的,而是通过getter和setter方法来实现的。
还可以定义只读属性,只定义getter方法,不定义setter方法就是一个只读属性:
class Student(object):
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2015 - self._birth
上面的birth
是可读写属性,而age
就是一个只读属性,因为age
可以根据birth
和当前时间计算出来。
@property
广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序运行时就减少了出错的可能性。
在设计类的继承关系时,通常,主线都是单一继承下来的,但是,如果需要“混入”额外的功能,通过多重继承就可以实现,这种设计通常称之为MixIn。
MixIn的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个MixIn的功能,而不是设计多层次的复杂的继承关系。
Python自带的很多库也使用了MixIn。举个例子,Python自带了TCPServer
和UDPServer
这两类网络服务,而要同时服务多个用户就必须使用多进程或多线程模型,这两种模型由ForkingMixIn
和ThreadingMixIn
提供。通过组合,我们就可以创造出合适的服务来。
比如,编写一个多进程模式的TCP服务,定义如下:
class MyTCPServer(TCPServer, ForkingMixIn):
pass
编写一个多线程模式的UDP服务,定义如下:
class MyUDPServer(UDPServer, ThreadingMixIn):
pass
如果你打算搞一个更先进的协程模型,可以编写一个CoroutineMixIn
:
class MyTCPServer(TCPServer, CoroutineMixIn):
pass
这样一来,我们不需要复杂而庞大的继承链,只要选择组合不同的类的功能,就可以快速构造出所需的子类。
由于Python允许使用多重继承,因此,MixIn就是一种常见的设计。
只允许单一继承的语言(如Java)不能使用MixIn的设计。
看到类似__slots__
这种形如__xxx__
的变量或者函数名就要注意,这些在Python中是有特殊用途的。
__slots__
我们已经知道怎么用了,__len__()
方法我们也知道是为了能让class作用于len()
函数。
除此之外,Python的class中还有许多这样有特殊用途的函数,可以帮助我们定制类。
我们先定义一个Student
类,打印一个实例:
>>> class Student(object):
... def __init__(self, name):
... self.name = name
...
>>> print(Student(
'Michael'))
<__main__.Student object at
0x109afb190>
打印出一堆<__main__.Student object at 0x109afb190>
,不好看。
怎么才能打印得好看呢?只需要定义好__str__()
方法,返回一个好看的字符串就可以了:
>>> class Student(object):
... def __init__(self, name):
... self.name = name
... def __str__(self):
... return 'Student object (name: %s)' % self.name
...
>>> print(Student(
'Michael'))
Student object (name: Michael)
这样打印出来的实例,不但好看,而且容易看出实例内部重要的数据。
但是细心的朋友会发现直接敲变量不用print
,打印出来的实例还是不好看:
>>> s = Student('Michael')
>>> s
<__main__.Student object at 0x109afb310>
这是因为直接显示变量调用的不是__str__()
,而是__repr__()
,两者的区别是__str__()
返回用户看到的字符串,而__repr__()
返回程序开发者看到的字符串,也就是说,__repr__()
是为调试服务的。
解决办法是再定义一个__repr__()
。但是通常__str__()
和__repr__()
代码都是一样的,所以,有个偷懒的写法:
class Student(object):
def __init__(self, name):
self.name
= name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__
= __str__
如果一个类想被用于for ... in
循环,类似list或tuple那样,就必须实现一个__iter__()
方法,该方法返回一个迭代对象,然后,Python的for循环就会不断调用该迭代对象的__next__()
方法拿到循环的下一个值,直到遇到StopIteration
错误时退出循环。
我们以斐波那契数列为例,写一个Fib类,可以作用于for循环:
class Fib(object):
def __init__(self):
self.a,
self.b =
0,
1 # 初始化两个计数器a,b
def __iter__(self):
return self
# 实例本身就是迭代对象,故返回自己
def __next__(self):
self.a,
self.b = self.b, self.a + self.b
# 计算下一个值
if self.a >
100000:
# 退出循环的条件
raise StopIteration()
return self.a
# 返回下一个值
现在,试试把Fib实例作用于for循环:
>>> for n
in Fib():
... print(n)
...
1
1
2
3
5
...
46368
75025
Fib实例虽然能作用于for循环,看起来和list有点像,但是,把它当成list来使用还是不行,比如,取第5个元素:
>>> Fib()[5]
Traceback (most recent call last):
File
"
<stdin>", line 1, in
<module>
TypeError: 'Fib' object does not support indexing
要表现得像list那样按照下标取出元素,需要实现__getitem__()
方法:
class Fib(object):
def __getitem__(self, n):
a,
b =
1,
1
for x
in range(n):
a,
b = b, a + b
return a
现在,就可以按下标访问数列的任意一项了:
>>> f = Fib()
>>> f[
0]
1
>>> f[
1]
1
>>> f[
2]
2
>>> f[
3]
3
>>> f[
10]
89
>>> f[
100]
573147844013817084101
但是list有个神奇的切片方法:
>>>
list(
range(100))
[5:10]
[5, 6, 7, 8, 9]
对于Fib却报错。原因是__getitem__()
传入的参数可能是一个int,也可能是一个切片对象slice
,所以要做判断:
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int):
# n是索引
a,
b =
1,
1
for x
in range(n):
a,
b = b, a + b
return a
if isinstance(n, slice):
# n是切片
start
= n.start
stop
= n.stop
if start
is None:
start
=
0
a,
b =
1,
1
L
= []
for x
in range(stop):
if x >= start:
L.append(a)
a,
b = b, a + b
return L
现在试试Fib的切片:
>>> f = Fib()
>>> f[
0:
5]
[
1,
1,
2,
3,
5]
>>> f[:
10]
[
1,
1,
2,
3,
5,
8,
13,
21,
34,
55]
但是没有对step参数作处理:
>>>
f[:10:2]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
也没有对负数作处理,所以,要正确实现一个__getitem__()
还是有很多工作要做的。
此外,如果把对象看成dict
,__getitem__()
的参数也可能是一个可以作key的object,例如str
。
与之对应的是__setitem__()
方法,把对象视作list或dict来对集合赋值。最后,还有一个__delitem__()
方法,用于删除某个元素。
总之,通过上面的方法,我们自己定义的类表现得和Python自带的list、tuple、dict没什么区别,这完全归功于动态语言的“鸭子类型”,不需要强制继承某个接口。
正常情况下,当我们调用类的方法或属性时,如果不存在,就会报错。比如定义Student
类:
class Student(object):
def __init__(self):
self.name
=
'Michael'
调用name
属性,没问题,但是,调用不存在的score
属性,就有问题了:
>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
...
AttributeError:
'Student' object has no attribute
'score'
错误信息很清楚地告诉我们,没有找到score
这个attribute。
要避免这个错误,除了可以加上一个score
属性外,Python还有另一个机制,那就是写一个__getattr__()
方法,动态返回一个属性。修改如下:
class Student(object):
def __init__(self):
self.name
=
'Michael'
def __getattr__(self, attr):
if attr==
'score':
return 99
当调用不存在的属性时,比如score
,Python解释器会试图调用__getattr__(self, 'score')
来尝试获得属性,这样,我们就有机会返回score
的值:
>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99
返回函数也是完全可以的:
class Student(object):
def __getattr__(self, attr):
if attr==
'age':
return lambda:
25
只是调用方式要变为:
>>> s.age()
25
注意,只有在没有找到属性的情况下,才调用__getattr__
,已有的属性,比如name
,不会在__getattr__
中查找。
此外,注意到任意调用如s.abc
都会返回None
,这是因为我们定义的__getattr__
默认返回就是None
。要让class只响应特定的几个属性,我们就要按照约定,抛出AttributeError
的错误:
class Student(object):
def __getattr__(self, attr):
if attr==
'age':
return lambda:
25
raise AttributeError(
'\'Student\' object has no attribute \'%s\'' % attr)
这实际上可以把一个类的所有属性和方法调用全部动态化处理了,不需要任何特殊手段。
这种完全动态调用的特性有什么实际作用呢?作用就是,可以针对完全动态的情况作调用。
举个例子:
现在很多网站都搞REST API,比如新浪微博、豆瓣啥的,调用API的URL类似:
http://api.server/user/friends
http://api.server/user/timeline/list
如果要写SDK,给每个URL对应的API都写一个方法,那得累死,而且,API一旦改动,SDK也要改。
利用完全动态的__getattr__
,我们可以写出一个链式调用:
class Chain(object):
def __init__(self, path=''):
self._path
= path
def __getattr__(self, path):
return Chain(
'%s/%s' % (self._path, path))
def __str__(self):
return self._path
__repr__
= __str__
试试:
>>> Chain().status.user.timeline.
list
'/status/user/timeline/list'
这样,无论API怎么变,SDK都可以根据URL实现完全动态的调用,而且,不随API的增加而改变!
还有些REST API会把参数放到URL中,比如GitHub的API:
GET /users/
:user/repos
调用时,需要把:user
替换为实际用户名。如果我们能写出这样的链式调用:
Chain().users('michael').repos
就可以非常方便地调用API了。有兴趣的童鞋可以试试写出来。
一个对象实例可以有自己的属性和方法,当我们调用实例方法时,我们用instance.method()
来调用。能不能直接在实例本身上调用呢?在Python中,答案是肯定的。
任何类,只需要定义一个__call__()
方法,就可以直接对实例进行调用。请看示例:
class Student(object):
def __init__(self, name):
self.name
= name
def __call__(self):
print(
'My name is %s.' % self.name)
调用方式如下:
>>> s = Student(
'Michael')
>>> s()
# self参数不要传入
My name
is Michael.
__call__()
还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样,所以你完全可以把对象看成函数,把函数看成对象,因为这两者之间本来就没啥根本的区别。
如果你把对象看成函数,那么函数本身其实也可以在运行期动态创建出来,因为类的实例都是运行期创建出来的,这么一来,我们就模糊了对象和函数的界限。
那么,怎么判断一个变量是对象还是函数呢?其实,更多的时候,我们需要判断一个对象是否能被调用,能被调用的对象就是一个Callable
对象,比如函数和我们上面定义的带有__call__()
的类实例:
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([
1,
2,
3])
False
>>> callable(
None)
False
>>> callable(
'str')
False
通过callable()
函数,我们就可以判断一个对象是否是“可调用”对象。
Python的class允许定义许多定制方法,可以让我们非常方便地生成特定的类。
本节介绍的是最常用的几个定制方法,还有很多可定制的方法,请参考Python的官方文档
当我们需要定义常量时,一个办法是用大写变量通过整数来定义,例如月份:
JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12
好处是简单,缺点是类型是int
,并且仍然是变量。
更好的方法是为这样的枚举类型定义一个class类型,然后,每个常量都是class的一个唯一实例。Python提供了Enum
类来实现这个功能:
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
这样我们就获得了Month
类型的枚举类,可以直接使用Month.Jan
来引用一个常量,或者枚举它的所有成员:
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
value
属性则是自动赋给成员的int
常量,默认从1
开始计数。
如果需要更精确地控制枚举类型,可以从Enum
派生出自定义类:
from enum import Enum, unique
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被设定为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
@unique
装饰器可以帮助我们检查保证没有重复值。
访问这些枚举类型可以有若干种方法:
>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
... print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat
可见,既可以用成员名称引用枚举常量,又可以直接根据value的值获得枚举常量。
把Student
的gender
属性改造为枚举类型,可以避免使用字符串:
窗体顶端
# -*- coding: utf-8 -*-
from enum import Enum, unique
# 测试:
bart = Student('Bart', Gender.Male)
if bart.gender == Gender.Male:
print('测试通过!')
else:
print('测试失败!')
动态语言和静态语言最大的不同,就是函数和类的定义,不是编译时定义的,而是运行时动态创建的。
比方说我们要定义一个Hello
的class,就写一个hello.py
模块:
class Hello(object):
def hello(self, name='world'):
print(
'Hello, %s.' % name)
当Python解释器载入hello
模块时,就会依次执行该模块的所有语句,执行结果就是动态创建出一个Hello
的class对象,测试如下:
>>> from hello
import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<
class 'type'>
>>> print(type(h))
<class 'hello.Hello'>
type()
函数可以查看一个类型或变量的类型,Hello
是一个class,它的类型就是type
,而h
是一个实例,它的类型就是class Hello
。
我们说class的定义是运行时动态创建的,而创建class的方法就是使用type()
函数。
type()
函数既可以返回一个对象的类型,又可以创建出新的类型,比如,我们可以通过type()
函数创建出Hello
类,而无需通过class Hello(object)...
的定义:
>>> def fn(self, name=
'world'): # 先定义函数
...
print(
'Hello, %s.' % name)
...
>>> Hello = type(
'Hello', (object,), dict(hello=fn)) # 创建Hello
class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello'>
要创建一个class对象,type()
函数依次传入3个参数:
lclass的名称;
l继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
lclass的方法名称与函数绑定,这里我们把函数fn
绑定到方法名hello
上。
通过type()
函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()
函数创建出class。
正常情况下,我们都用class Xxx...
来定义类,但是,type()
函数也允许我们动态创建出类来,也就是说,动态语言本身支持运行期动态创建类,这和静态语言有非常大的不同,要在静态语言运行期创建类,必须构造源代码字符串再调用编译器,或者借助一些工具生成字节码实现,本质上都是动态编译,会非常复杂。
除了使用type()
动态创建类以外,要控制类的创建行为,还可以使用metaclass。
metaclass,直译为元类,简单的解释就是:
当我们定义了类以后,就可以根据这个类创建出实例,所以:先定义类,然后创建实例。
但是如果我们想创建出类呢?那就必须根据metaclass创建出类,所以:先定义metaclass,然后创建类。
连接起来就是:先定义metaclass,就可以创建类,最后创建实例。
所以,metaclass允许你创建类或者修改类。换句话说,你可以把类看成是metaclass创建出来的“实例”。
metaclass是Python面向对象里最难理解,也是最难使用的魔术代码。正常情况下,你不会碰到需要使用metaclass的情况,所以,以下内容看不懂也没关系,因为基本上你不会用到。
我们先看一个简单的例子,这个metaclass可以给我们自定义的MyList增加一个add
方法:
定义ListMetaclass
,按照默认习惯,metaclass的类名总是以Metaclass结尾,以便清楚地表示这是一个metaclass:
# metaclass是类的模板,所以必须从`type`类型派生:
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs[
'add'] =
lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
有了ListMetaclass,我们在定义类的时候还要指示使用ListMetaclass来定制类,传入关键字参数metaclass
:
class MyList(list, metaclass=ListMetaclass):
pass
当我们传入关键字参数metaclass
时,魔术就生效了,它指示Python解释器在创建MyList
时,要通过ListMetaclass.__new__()
来创建,在此,我们可以修改类的定义,比如,加上新的方法,然后,返回修改后的定义。
__new__()
方法接收到的参数依次是:
1.当前准备创建的类的对象;
2.类的名字;
3.类继承的父类集合;
4.类的方法集合。
测试一下MyList
是否可以调用add()
方法:
>>> L = MyList()
>>> L.add(
1)
>> L
[
1]
而普通的list
没有add()
方法:
>>> L2 = list()
>>> L2.add(1)
Traceback (most recent call last):
File
"
<stdin>", line 1, in
<module>
AttributeError: 'list' object has no attribute 'add'
动态修改有什么意义?直接在MyList
定义中写上add()
方法不是更简单吗?正常情况下,确实应该直接写,通过metaclass修改纯属变态。
但是,总会遇到需要通过metaclass修改类定义的。ORM就是一个典型的例子。
ORM全称“Object Relational Mapping”,即对象-关系映射,就是把关系数据库的一行映射为一个对象,也就是一个类对应一个表,这样,写代码更简单,不用直接操作SQL语句。
要编写一个ORM框架,所有的类都只能动态定义,因为只有使用者才能根据表的结构定义出对应的类来。
让我们来尝试编写一个ORM框架。
编写底层模块的第一步,就是先把调用接口写出来。比如,使用者如果使用这个ORM框架,想定义一个User
类来操作对应的数据库表User
,我们期待他写出这样的代码:
class User(Model):
# 定义类的属性到列的映射:
id
= IntegerField(
'id')
name
= StringField(
'username')
email
= StringField(
'email')
password
= StringField(
'password')
# 创建一个实例:
u = User(id=
12345, name=
'Michael', email=
'test@orm.org', password=
'my-pwd')
# 保存到数据库:
u.save()
其中,父类Model
和属性类型StringField
、IntegerField
是由ORM框架提供的,剩下的魔术方法比如save()
全部由metaclass自动完成。虽然metaclass的编写会比较复杂,但ORM的使用者用起来却异常简单。
现在,我们就按上面的接口来实现该ORM。
首先来定义Field
类,它负责保存数据库表的字段名和字段类型:
class Field(object):
def __init__(self, name, column_type):
self.name
= name
self.column_type
= column_type
def __str__(self):
return '<%s:%s>' % (self.__class__.__name__, self.name)
在Field
的基础上,进一步定义各种类型的Field
,比如StringField
,IntegerField
等等:
class StringField(Field):
def __init__(self, name):
super(StringField,
self).__init__(name,
'varchar(100)')
class IntegerField(Field):
def __init__(self, name):
super(IntegerField,
self).__init__(name,
'bigint')
下一步,就是编写最复杂的ModelMetaclass
了:
class ModelMetaclass(type):
def __new__(cls, name, bases, attrs):
if name==
'Model':
return type.__new__(cls, name, bases, attrs)
print(
'Found model: %s' % name)
mappings
= dict()
for k, v
in attrs.items():
if isinstance(v, Field):
print(
'Found mapping: %s ==> %s' % (k, v))
mappings[k]
= v
for k
in mappings.keys():
attrs.pop(k)
attrs[
'__mappings__'] = mappings
# 保存属性和列的映射关系
attrs[
'__table__'] = name
# 假设表名和类名一致
return type.__new__(cls, name, bases, attrs)
以及基类Model
:
class Model(dict, metaclass=ModelMetaclass):
def __init__(self, **kw):
super(Model,
self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(
r"'Model' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key]
= value
def save(self):
fields
= []
params
= []
args
= []
for k, v
in self.__mappings__.items():
fields.append(v.name)
params.append(
'?')
args.append(getattr(self,
k,
None))
sql
=
'insert into %s (%s) values (%s)' % (self.__table__,
','.join(fields),
','.join(params))
print(
'SQL: %s' % sql)
print(
'ARGS: %s' % str(args))
当用户定义一个class User(Model)
时,Python解释器首先在当前类User
的定义中查找metaclass
,如果没有找到,就继续在父类Model
中查找metaclass
,找到了,就使用Model
中定义的metaclass
的ModelMetaclass
来创建User
类,也就是说,metaclass可以隐式地继承到子类,但子类自己却感觉不到。
在ModelMetaclass
中,一共做了几件事情:
1.排除掉对Model
类的修改;
2.在当前类(比如User
)中查找定义的类的所有属性,如果找到一个Field属性,就把它保存到一个__mappings__
的dict中,同时从类属性中删除该Field属性,否则,容易造成运行时错误(实例的属性会遮盖类的同名属性);
3.把表名保存到__table__
中,这里简化为表名默认为类名。
在Model
类中,就可以定义各种操作数据库的方法,比如save()
,delete()
,find()
,update
等等。
我们实现了save()
方法,把一个实例保存到数据库中。因为有表名,属性到字段的映射和属性值的集合,就可以构造出INSERT
语句。
编写代码试试:
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()
输出如下:
Found model: User
Found mapping: email ==>
<StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:uid>
Found mapping: name ==> <StringField:username>
SQL: insert into User (password,email,username,id) values (?,?,?,?)
ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]
可以看到,save()
方法已经打印出了可执行的SQL语句,以及参数列表,只需要真正连接到数据库,执行该SQL语句,就可以完成真正的功能。
不到100行代码,我们就通过metaclass实现了一个精简的ORM框架,是不是非常简单?
metaclass是Python中非常具有魔术性的对象,它可以改变类创建时的行为。这种强大的功能使用起来务必小心。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。