本系列博文基于廖雪峰老师的官网Python教程，笔者在大学期间已经阅读过廖老师的Python教程，教程相当不错，官网链接： 廖雪峰官方网站.请需要系统学习Python的小伙伴到廖老师官网学习，笔者的编程环境是Anaconda+Pycharm，Python版本：Python3.
1.定制类
# 1.__str__
class Employee(object):
def __init__(self, name):
self.name = name
print("打印一个实例：", Employee("Willard."))
# 使用__str__
class Employee(object):
def __init__(self, name):
self.name = name
def __str__(self):
return "Employee object (name:%s)" % self.name
print("使用__str__打印一个实例：", Employee("Willard"))
# 结果输出：
# 打印一个实例： <__main__.Employee object at 0x000001F057CEFBA8>
# 使用__str__打印一个实例： Employee object (name:Willard)
# 2.__iter__
# 一个类如果想被用于for...in循环，先实现一个__iter__方法，
# 该方法返回一个迭代对象，然后不断调用该对象的__next__()方法拿到下一个值，
# 直到遇到StopIteration错误时退出循环；
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1
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
print("Fib实例作用于for循环！")
for n in Fib():
print(n,end = " ")
# 结果输出：
# Fib实例作用于for循环！
# 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025
# 3.__getitem__
# 实现像list可以按照下标取出元素
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()
print("Fib[0]的值为：", f[0])
print("Fib[100]的值为：", f[100])
# 结果输出：
# Fib[0]的值为： 1
# Fib[100]的值为： 573147844013817084101
# 判断__getitem__()传入的参数是int还是slice切片
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice):
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
f = Fib()
print("f[0:5]的值为：", f[0:5])
print("f[100:150]的值为：", f[100:102])
# 结果输出：
# f[0:5]的值为： [1, 1, 2, 3, 5]
# f[100:150]的值为： [573147844013817084101, 927372692193078999176]
# 4.__getattr__
# 当调用类的方法或属性时，如果不存在，则报错
class Employee(object):
def __init__(self, name):
self.name = name
employee1 = Employee("Willard")
print("employee1.name的值为：", employee1.name)
# print("employee1.salary的值为：", employee1.salary) # 会报错
# 写一个__getattr__()方法，动态返回一个属性
class Employee(object):
def __init__(self, name):
self.name = name
def __getattr__(self, attr):
if attr == "salary":
return 20000
employee2 = Employee("LinWenYu")
print("employee2.salary的值为：", employee2.salary)
# 结果输出：
# employee1.name的值为： Willard
# employee2.salary的值为： 20000
# 5.__call__
# a.一个对象实例可以有自己的属性和方法，当调用实例方法时，使用instance.method()调用；
# b.直接在实例本身调用，只需要定义一个__call__()方法，就可以直接对实例进行调用；
class Employee(object):
def __init__(self, name, salary):
self.name = name
self.salary = salary
def __call__(self):
print("This Employee's name is %s.\nThe salary of %s is %d." % (self.name, self.name, self.salary))
employee = Employee("LinWenYu", 20000)
employee()
# 结果输出：
# This Employee's name is LinWenYu.
# The salary of LinWenYu is 20000.
2.使用枚举类
# 定义常量其中一个方法：用大写变量通过整数定义
JAN = 1
FEB = 2
MAR = 3
# ...
NOV = 11
DEC = 12
# 为这样的枚举类型定义一个class类型，每个常量是class的一个唯一实例
from enum import Enum
Month = Enum("Month", ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"))
# 使用Month.Jan引用常量
for name, member in Month.__members__.items():
print(name, "=>", member, ",", member.value)
# 结果输出：
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12
# 更精确控制枚举类型，从Enum派生出自定义类
from enum import Enum, unique
# unique装饰器，检查保证没有重复值
@unique
class Weekday(Enum):
Sun = 0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
# 访问枚举类型
day1 = Weekday.Mon
print("The value of Day1：", day1)
print("The value of Day1：", Weekday(1))
print("The value of Day2：", Weekday.Tue)
print("The value of Day2：", Weekday["Tue"])
print("The value of Weekday.Wed is：", Weekday.Wed.value)
print("------------------------------------------------")
# 遍历
for name, member in Weekday.__members__.items():
print(name, "=>", member)
print(name, ".value", "=>", member.value, "\n")
# 结果输出：
The value of Day1： Weekday.Mon
The value of Day1： Weekday.Mon
The value of Day2： Weekday.Tue
The value of Day2： Weekday.Tue
The value of Weekday.Wed is： 3
------------------------------------------------
Sun => Weekday.Sun
Sun .value => 0
Mon => Weekday.Mon
Mon .value => 1
Tue => Weekday.Tue
Tue .value => 2
Wed => Weekday.Wed
Wed .value => 3
Thu => Weekday.Thu
Thu .value => 4
Fri => Weekday.Fri
Fri .value => 5
Sat => Weekday.Sat
Sat .value => 6
3.使用元类
# 1.type()
# 定义一个welcome.py模块
"""
class Welcome(object):
def welcome(self, welcomeString = "FUXI Technology."):
print("Welcome to %s" % welcomeString)
"""
from welcome import Welcome
w = Welcome()
w.welcome()
print("Welcome的类型为：", type(Welcome))
print("w的类型为：", type(w))
print("-------------------------------------")
# 通过type()函数创建Welcome类
# 通过type()函数创建对象
# 参数1：class的名称；
# 参数2：继承的父类集合，只有一个父类的时候，需要在单元素后添加逗号；
# 参数3：class的方法名称和函数绑定，把函数fn绑定到方法名welcome上；
def fn(self, welcomeString = "FUXI Technology."):
print("Welcome to %s" % welcomeString)
Welcome = type("Welcome", (object,), dict(welcome = fn)) # 创建Welcome类
w = Welcome()
w.welcome()
print("Welcome的类型：", type(Welcome))
print("w的类型：", type(w))
# 结果输出：
Welcome to FUXI Technology.
Welcome的类型为： <class 'type'>
w的类型为： <class 'welcome.Welcome'>
-------------------------------------
Welcome to FUXI Technology.
Welcome的类型： <class 'type'>
w的类型： <class '__main__.Welcome'>
# 2.metaclass：元类
# 先定义metaclass，然后创建类，最后创建实例
# metaclass是类的模板，必须从type类型派生；
# __new__()方法接收到的参数：
# 1.当前准备创建的类的对象；
# 2.类的名字；
# 3.类继承的父类集合；
# 4.类的方法集合；
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs["add"] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
# 定义类
class MyList(list, metaclass = ListMetaclass):
pass
# 测试MyList是否可以调用add()方法
L = MyList()
L.add(1)
print("L.add(1)：", L)
# 结果输出：
# L.add(1)： [1]
