#!/usr/bin/python
# -*- coding: UTF-8 -*-

def printBreakLine():
	print("-------------------------")

class Employee:
	'所有员工的基类, self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。'
	empCount = 0
	species = "Human"
 
	def __init__(self, name, salary):
		self.name = name
		self.salary = salary
		Employee.empCount += 1

	def displayCount(self):
		print("Total Employee: %d" % Employee.empCount)
 
	def displayEmployee(self):
		print("Name : ", self.name,  ", Salary: ", self.salary)

	# self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:
	def prt(self):
		print(self)
		print(self.__class__)

	# A class method is shared among all instances
	# They are called with the calling class as the first argument
	@classmethod
	def get_species(cls):
		return cls.species

	# A static method is called without a class or instance reference
	@staticmethod
	def grunt():
		return "*grunt*"

	# A property is just like a getter.
	# It turns the method age() into an read-only attribute
	# of the same name.
	@property
	def age(self):
		return self._age

	# This allows the property to be set
	@age.setter
	def age(self, age):
		self._age = age

	# This allows the property to be deleted
	@age.deleter
	def age(self):
		del self._age
 
emp1 = Employee("Michael", 1000)
emp1.prt() 
emp1.displayCount()
emp1.displayEmployee()
print("Total count of employees: ", emp1.empCount)

# 可以添加，删除，修改类的属性，如下所示：
emp1.age = 7  # 添加一个 'age' 属性
print("emp1's age is: ", emp1.age)
emp1.age = 8  # 修改 'age' 属性
print("Now emp1's age is: ", emp1.age)
hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age')    # 删除属性 'age'
# del emp1.age  # 删除 'age' 属性

# __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
# __doc__ :类的文档字符串
# __name__: 类名
# __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
# __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)

printBreakLine()

# python对象销毁(垃圾回收),  
#   这个对象的引用计数变为0 时， 它被垃圾回收。
#   但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收
a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数

printBreakLine()

class Point:
	def __init__( self, x=0, y=0):
		self.x = x
		self.y = y
	def __del__(self):
		class_name = self.__class__.__name__
		print(class_name, "销毁")
 
pt1 = Point()
pt2 = pt1
pt3 = pt1
print(id(pt1), id(pt2), id(pt3)) # 打印对象的id
del pt1
del pt2
del pt3

printBreakLine()

# 继承语法 class 派生类名（基类名）
# 在python中继承中的一些特点：
# 	1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
# 	2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
# 	3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
#    （先在本类中查找调用的方法，找不到才去基类中找）。

class Parent:        # 定义父类
	parentAttr = 100
	def __init__(self):
		print("调用父类构造方法")
 
	def parentMethod(self):
		print('调用父类方法')

	def setAttr(self, attr):
		Parent.parentAttr = attr

	def getAttr(self):
		print("父类属性 :", Parent.parentAttr)
 
class Child(Parent): # 定义子类
	def __init__(self):
		Parent.__init__(self) # 调用父类构造方法
		print("调用子类构造方法")

	def childMethod(self):
		print('调用子类方法 child method')
 
c = Child()          # 实例化子类, 同时调用父类及子类的建构方法
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法
c.getAttr()          # 再次调用父类的方法

printBreakLine()

# 多类继承
#####################################
# class A:        # 定义类 A
# .....
# class B:         # 定义类 B
# .....
# class C(A, B):   # 继承类 A 和 B
# .....

# issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
# isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。


# 方法重写: 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

class Parent1:        # 定义父类
	def myMethod(self):
		print('调用父类方法')
 
class Child1(Parent1): # 定义子类
	def myMethod(self):
		print('调用子类方法')
 
c = Child1()          # 子类实例
c.myMethod()         # 子类调用重写方法

printBreakLine()

# 运算符重载：
# 1	__init__ ( self [,args...] ) 构造函数
# 		简单的调用方法: obj = className(args)
# 2	__del__( self ) 析构方法, 删除一个对象
# 		简单的调用方法 : dell obj
# 3	__repr__( self ) 转化为供解释器读取的形式
# 		简单的调用方法 : repr(obj)
# 4	__str__( self ) 用于将值转化为适于人阅读的形式
# 		简单的调用方法 : str(obj)
# 5	__cmp__ ( self, x ) 对象比较
# 		简单的调用方法 : cmp(obj, x)
class Vector:
	def __init__(self, a, b):
		self.a = a
		self.b = b
 
	def __str__(self):
		return 'Vector (%d, %d)' % (self.a, self.b)
 
	def __add__(self,other):
		return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print(v1)
print(v2)
print(v1 + v2)

printBreakLine()

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
# print(counter.__secretCount  # 报错，实例不能访问私有变量)

# Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码
print(counter._JustCounter__secretCount )

# 单下划线、双下划线、头尾双下划线说明：
# __foo__: 定义的是特列方法，类似 __init__() 之类的。
# _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
# __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

printBreakLine()

# Regular expression: 
# re.match(pattern, string, flags=0)
# re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配


line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) (.*)', line, re.M|re.I)
 
if matchObj:
   print("matchObj.group()  : ", matchObj.group())
   print("matchObj.group(1) : ", matchObj.group(1))
   print("matchObj.group(2) : ", matchObj.group(2)) # .*? 后面多个问号，代表非贪婪模式，只匹配符合条件的最少字符
   print("matchObj.group(3) : ", matchObj.group(3))
else:
   print("No match!!")

printBreakLine()
# re.match与re.search的区别
# re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())         # 不在起始位置匹配


line = "Cats are smarter than dogs"
searchObj = re.search( r'(.*) are (.*?) (.*)', line, re.M|re.I)
 
if searchObj:
   print("searchObj.group()  : ", searchObj.group())
   print("searchObj.group(1) : ", searchObj.group(1))
   print("searchObj.group(2) : ", searchObj.group(2)) # .*? 后面多个问号，代表非贪婪模式，只匹配符合条件的最少字符
   print("searchObj.group(3) : ", searchObj.group(3))
else:
   print("No search result!!")

printBreakLine()
# re.sub(pattern, repl, string, count=0, flags=0)
# 	pattern : 正则中的模式字符串。
# 	repl : 替换的字符串，*也可为一个函数*。
# 	string : 要被查找替换的原始字符串。
# 	count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)
 
# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)
printBreakLine()