Python进阶和高阶学习(持续更新)

Python 面向对象

创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:
class ClassName:
'类的帮助信息'   #类文档字符串
 class_suite  #类体

class Employee:
    '所有员工的基类'
    # 类变量
    empCount = 0
    # 构造函数（方法）
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1


# 这两个是实例方法 创建实例 实例数量
    def displayCount(self):
        # empCount变量是一个类变量，他的这个值在这个类的所有实例之间共享
        # 你可以在内部类或外部类使用Employee.empCount访问。
        
        print("Total Employee %d" % Employee.empCount)

    def displayEmployee(self):
        print("Name :",self.name, ",Salary:",self.salary)

# self代表类的实例，而非类
# 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test: #定义一个叫Test的类
    def prt(self):#定义了一个实例方法 prt，它有一个参数 self，代表类的实例本身
        print(self)#打印出当前实例对象的内存地址，即 self 的值。
        print(self.__class__)#打印出当前实例所属的类对象，即 Test 类的类对象。

t = Test() #调用实例方法
t.prt()#解析输出

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

t = Test() #调用实例方法
t.prt()#解析输出

创建实例对象

以前学java一般用关键字new,但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。

emp1 = Employee("jfh",2000)
# 二
emp2 = Employee("jgj",3000)

访问属性

   # 访问属性 使用点号 . 来访问对象的属性。使用如下类的名称访问类变量:
    emp1.displayEmployee()
    emp2.displayEmployee()
    print("Total Employee %d" % Employee.empCount)

# 增删改 类的属性
emp1.age = 7
emp1.age = 8
del emp1.age

Python内置类属性

__dict__ 类的属性
__doc__ 类的文档字符串
__name__ 类名
__module__ 类的定义所在模块
 __bases__ 类的所有父类构成元素

class Employee:
    empCount = 0
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1
    def displayEmployee(self):
        print("Total Employee %d" % Employee.empCount)
    def displayEmployee(self):
        print("Name : ", self.name,  ", Salary: ", self.salary)
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__)

python对象销毁(垃圾回收)

python使用了引用技术这一简单技术来跟踪和回收垃圾

在 Python 内部记录着所有使用中的对象各有多少引用

一个内部跟踪变量，称为一个引用计数器

当对象被创建时，就创建了一个引用计数，当这个对象不再需要的时候，也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收

垃圾回收机制 不仅针对引用计数为0的对象,同时也可以处理循环引用的情况

循环引用指:两个对象互相引用,但是没有其他变量

这种情况下仅使用引用计数是不够的

Python 的垃圾收集器:实际上就是一个引用计数器和一个循环垃圾收集器

作为引用计数器的补充,垃圾收集器也会留心被分配的总量很大(即未通过引用计数销毁的那些)的对象

在这种情况下,解释器会暂停下来,试图清理所有未引用的循环

a = 40 #创建对象
b = a #增加引用  <40> 的计数
c = [b] # 增加引用 <40> 的计数

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

# 析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：
# 通常你需要在单独的文件中定义一个类
#类定义
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,"销毁")
# 对象创建和引用
#创建一个 Point 类的实例 pt1。
# 调用 __init__ 方法初始化对象。
pt1 = Point()
pt2 = pt1
pt3 = pt1

#打印对象的内存的地址
print(id(pt1),id(pt2),id(pt3))
# 删除对象引用
del pt1
del pt2
del pt3

类的继承

python中继承中的一些特点：

1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。

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):
        print("调用子类构造方法")

    def childMethod(self):
        print('调用子类方法')

c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

# 类的方法 类的私有方法
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.__secretCount)


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

Python正则表达式

import re 是用于导入 Python 的正则表达式（regular expression）模块。

具体看这篇：

Python 正则表达式 | 菜鸟教程 (runoob.com)

re.match函数

匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

匹配成功re.search方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

检索和替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。

# 正则表达式
import re
# span()在起始位置匹配
print(re.match('www','www.runoob.com').span())
# 不在起始位置匹配
print(re.match('com','www.runoobcom'))

import re #导入python的正则表达式
line = "hjvnvhjgvsjc"
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))
else:
    print("no match")