python类总结
python基础总结
聊一聊Python中的类
什么是Python的类，很多人肯定会随手打出
class Student(object):
def __init__(self):
pass
jack = Student()
Helen = Student()
完事了，但其实不然，Python的类还是有很多值得考虑和记录的地方
基础向
如上所说，我们先来理一理Python类的基础，首先既然说到类，我们就离不开对象这个概念，Python是一门解释型动态语言，在Python中处处皆对象。既然有了对象，我们当然要具有生产这些对象的模板，我们把它称为类。在Python中，Class简称是抽象类的统称，比如上方的Student就是一个抽象的概念，他是一个模板。那么jack和Helen则是他的实例。于是面向对象中，类(Class)和实例(Instance)的概念就出来了，记住类只是一个抽象的概念，是模板。而实例则是由这些模板生产出来的实例。
继承最基础的类
看到现在我们应该有一个概念，也就是说我们创造一个类，我们可以使用他创造出多个实例。那么多个类，就可以创造出多个多个实例。那么其实这些类都继承自一个最基础的类object，在Python2.4-3中根据是否继承object类来区分新式类和经典类，但是在python3中，已经默认继承Object类了,所以你完全可以这样写
class Student:
def __init__(self):
pass
类的内存与实例
既然类是创建实例的模板，那么必须有存放类的内存的地方
class Student(object):
def __init__(self):
pass
if __name__ == "__main__":
print(Student)
print(Student())
a = Student()
print(a)
输出的结果如下
PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo1.py
<class '__main__.st'>
__init__
<__main__.st object at 0x000001BB998EFB88>
__init__
<__main__.st object at 0x000001BB998EFB88>
输出的流程
# st返回的是 <class '__main__.st'> 类的对象名
# print(st())时 st()创建了一个实例，python会为他创建一个实例，赋值给st() 然后再由print输出，因此会先执行__init__初始化,即先输出"__init__",再输出类的实例
# a = st() 创建一个实例a,会执行__init__ 后再输出 类的实例
# 输出类的实例内容包括 <__main__.st object at 0x00000141C826FE08> 创建实例的类的对象名 和 实例的存储地址
类的属性和方法
既然都说了处处皆对象，那么对象也可以是千变万化的，正如jack和helen也一定存在着不同的地方，这些他们所具有的相同或不同的内容我们称之为属性，为了方便我们将固有属性都放在类的中，使用__init__在构造函数的初始化阶段定义属性
class Student(object):
def __init__(self,name,age):
# 因人而异的属性
self.name = name
self.age = age
# 固有的属性
self.type = "People"
if __name__ == "__main__":
jack = Student("jack",12)
Helen = Student("Helen",18)
print(jack.name)
print(Helen.name)
# 输出固有属性
print(jack.type)
print(Helen.type)
# 随着年龄的增增长，属性也会随之变大
Helen.age = Helen.age + 1
jack.age +=1
print(jack.age)
print(Helen.age)
# Helen比较自私，他有别人没有的属性
Helen.HasCar = "Helen has one car "
print(Helen.HasCar)
输出内容
PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo2.py
jack
Helen
People
People
13
19
Helen has one car
记住，实例与实例之间的属性是相互独立的。
私有属性
Helen是一个女孩子，他很珍惜她的年龄，因此他不希望自己的年龄是会增大的，于是他想要将年龄这个属性据为己有，变成私有的属性。于是他在age的开头加上了双下划线__ 变成了__age，私有的(private)，当你在外部想要去改变的时候，你会发现报错了。
class Student(object):
def __init__(self,name,age):
# 因人而异的属性
self.name = name
self.__age = age
if __name__ == "__main__":
jack = Student("jack",12)
Helen = Student("Helen",18)
print(jack.age)
jack.age +=1
print(jack.age)
输出的结果
PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/3.py
Traceback (most recent call last):
File "e:/app/3.py", line 17, in <module>
print(jack.age)
AttributeError: 'Student' object has no attribute 'age'
其实加了双下划线也不是一定不能访问，我们可以使用_Student__age去获取
当然年龄这些东西他是改变不了的，我们想办法去得到这些，于是我们要添加对应的方法
class Student(object):
def __init__(self,name,age):
# 因人而异的属性
self.name = name
self.__age = age
def get_age(self):
return self.__age
def __set_age(self,age):
self.__age = age
if __name__ == "__main__":
jack = Student("jack",12)
Helen = Student("Helen",18)
print(Helen.get_age())
Helen._Student__set_age(19)
print(Helen.get_age())
除了属性之外，类还可以包含方法，同样的我们通用(固有)的类的方法也会放进类中
class Student(object):
def __init__(self,name,age):
# 因人而异的属性
self.name = name
self.age = age
def say(self,msg):
print(msg+", my name is "+ self.name)
if __name__ == "__main__":
jack = Student("jack",12)
Helen = Student("Helen",18)
jack.say("hello")
输出内容为
PS E:\app> & C:/Users/alpaca/AppData/Local/Programs/Python/Python37/python.exe e:/app/demo4.py
hello, my name is jack
类里面的所有方法都是以self为第一个参数，就指向创建的类本身，在调用时不需要传入任何的值
类的继承
在上面我们讲到过 所有的类都继承自object这个基础类。同样的，在类与类之间也可以互相继承，有了这个，在之前我们实现过的helen拥有汽车的事就不用遮遮掩掩的了，他完全可以自己再继承一个类
class Student(object):
def __init__(self,name,age):
# 因人而异的属性
self.name = name
self.age = age
# 固定的属性
self.type = "People"
class Man_HasCar(Student):
def HasCar(self):
print(self.name+" has one car ")
if __name__ == "__main__":
jack = Student("jack",12)
Helen = Man_HasCar("Helen","18")
Helen.HasCar()
获取对象的类型
type()
使用type()来判断对象类型
isinstance()
使用isinstance来判断某一个实例是否是某个类的实例，层级迭代也算，即假设B的实例是b,B的父类是A，print(instance(b,A)) = true
基本类型也可以用isinstance来判断 isinstance('a',str)
print(instance(b,A)) # true
isinstance('a',str) # True
isinstance([1, 2, 3], (list, tuple)) # True
dir()
如果要获取一个对象的所有属性和方法，可以使用dir函数,他返回一个包含字符串的list,比如获取一个str对象的方法
dir("ABC")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
再这之中含双下划线的都是一些魔法方法，比如返回字符的长度，当然我们也可以使用len()去获取，但实际仍然就是调用了__len__这个方法
print("ABC".__len__())
print(len("ABC"))
class return_len_string(object):
# 重写__len__
def __len__(self):
return 100
rls = return_len_string()
print(len(rls))
# 返回100
获取对象属性
python准备了getattr()、setattr()、hasattr()，可以直接操作一个对象的属性
# 获得属性
getattr(cls,'name')
# 设置属性
setattr(cls,'name','Helen')
# 判断某个类是否具有某个属性
hasattr(cls,'name')
特殊的属性__slot__
我们知道由于Python是动态类的语言，再我们创建完一个类之后，并创建了他的实例，那么这个实例可以添加和绑定任何属性和方法，如果我们要限制实例的属性该怎么办，为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
"""实际执行效果"""
>>> class Student(object):
... __slots__ = ('name', 'age')
...
>>> s = Student()
>>> s.name = 'digg'
>>> s.age = '19'
>>> s.score = 99
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
>>>
另外__slot__只对当前类有效，对继承类无效
__str__ ，__repr__
该魔法方法自定义返回内容
class tt(object):
def __str__(self):
return "自定义"
def __repr__(self):
return "自定义"
# 或者
__repr__ = __str__
class ss(object):
pass
if __name__ == "__main__":
print(tt())
print(ss())
__repr__其实和__str__差不多,大多数情况下使用str就差不多了
__iter__ 和 __next__
如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__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
# 测试
for n in Fib():
print(n)
枚举类
元类
staticmethod classmethod使用方法与区别
一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。
这有利于组织代码，把某些应该属于某个类的函数给放到那个类里去，同时有利于命名空间的整洁。
既然@staticmethod和@classmethod都可以直接类名.方法名()来调用，那他们有什么区别呢
从它们的使用上来看,
- @staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
- @classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
- @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。
- 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。
- 普通对象方法至少需要一个self参数，代表类对象实例
类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 - 对于类方法，可以通过类来调用，就像Test.foo()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像Test().foo()，这里Test()，写成这样之后它就是类的一个实例了。
- 静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少
如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
而@classmethod因为持有cls参数(当然，也可以用“self” 代替，个人认为是为了和类的self区分才用cls的)，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。
例子
class cs(object):
def speak(self,name):
print("can you speak english? %s"%name)
@staticmethod
def say(name):
print("my name is %s "%(name))
@classmethod
def run(cls,name):
print("running now, %s"%(name))
if __name__ == "__main__":
cs.say("hzj")
cs.run("hzj")
聊一聊Python中的装饰器
https://blog.csdn.net/zhouchen1998/article/details/82933893
装饰器就是把几个函数共同的功能放在一起
Python 拥有丰富强大的功能和表达特性，其中之一便是装饰器，装饰器能够在不改变函数、方法、类本身的情况下丰富他们的功能。
应用场景:比如QQ会员吧，对于普通的会员我们使用的是func，但是对于VIP会员则是func_vip的方法，但是func与func_vip大部分功能的重叠性很高，没有必要重写一个func_vip方法，只需要丰富一下func就可以使用了，这时候我们就可以使用装饰器
前提
1.函数可以作为变量
def func(name):
print("my name is %s"%name)
func_other = func()
func_other("hzj")
2.将函数传递给函数
def func1(name):
return name
def func2(func):
print(func)
func2(func1("hzj"))
3.无参函数嵌套函数
def func_wrap():
def prt_func():
return 'hello,world'
return prt_func
hlowld = func_wrap()
print(hlowld())
4.有参函数嵌套函数
def func_wrap():
def prt_func(name):
return 'hello,'+name
return prt_func
hlo = func_wrap()
print(hlo('crossin'))
5.函数参数嵌套函数
def func(name):
return "hello %s"%(name)
def top_func(func):
def sec_func(name):
return "hello %s"%(func(name))
return sec_func
tt = top_func(func)
print(tt("hzj"))
讲一下装饰器
其实装饰器就是一种将函数当做参数的使用方法，具体如何使用我们来看一下，首先我们来看一下最普通的函数
# 最简单的函数
def general():
return "i am general func"
if __name__ == "__main__":
print(general())
# 带参数的最简单的参数
def general_params(name):
return "i am general %s"%name
if __name__ == "__main__":
print(general())
print(general_params("func"))
接下来是函数传递，在python中参数可以作为变量在函数与函数之间传递
# 函数作为变量
def bottom():
return "i ma bottom func"
b = bottom
print(b())
# -----------------
# 函数之间传递
# 函数作为变量传递
def bottom():
return "i am bottom func"
def top(func):
return "%s,ok!i know!"%(func())
t = top(bottom)
print(t)
接下来是函数的嵌套
# 不带参嵌套
def outer():
def inner():
return "ok!"
return inner
out = outer()
print(out())
# 带参嵌套
def outer(name):
def inner(name):
return "ok!%s"%name
return inner
out = outer("a")
print(out("b"))
# 结果ok!b
装饰器
# 首先定义一个普通的函数
def print_text(name):
return 'hello,'+ name
# 再定义一个嵌套函数，分别以函数和普通的字符串作为参数
def add_tag(func):
def prt_func(name):
return '<p>{0}</p>'.format(func(name))
return prt_func
# 将函数作为参数传递给 add_tag
hlo = add_tag(print_text)
# 将 'crossin' 作为参数传递给 hlo
print(hlo('crossin'))
# 结果 : <p>hello,crossin</p>
可以写成这样
def add_tag(func):
def prt_func(name):
return '<p>{0}</p>'.format(func(name))
return prt_func
@add_tag
def print_text(name):
return 'hello,'+ name
print_text('crossin')
来源
在Python这门语言中，存在着很多的魔法方法，除了这篇文章所介绍的__new__ init __call__以外还存在着其他的魔法方法
任何事物都有一个从创建，被使用，再到消亡的过程，在程序语言面向对象编程模型中，对象也有相似的命运：创建、初始化、使用、垃圾回收，不同的阶段由不同的方法（角色）负责执行。
定义一个类时，大家用得最多的就是 init 方法，而 new 和 call 使用得比较少，这篇文章试图帮助大家把这3个方法的正确使用方式和应用场景分别解释一下。
关于 Python 新式类和老式类在这篇文章不做过多讨论，因为老式类是 Python2 中的概念，现在基本没人再会去用老式类，老式类必须显示地继承 object，而 Python3 中，只有新式类，默认继承了 object，无需显示指定，本文代码都是基于 Python3 来讨论。
__init__方法
__init__方法负责对象的初始化,既然是面向对象的语言，存在对象，当然也存在对象的属性，而init就是用来初始化对象属性的模仿方法，时间为系统执行该方法前，其实该对象已经存在了，要不然初始化什么东西呢？先看例子
class A:
def __init__(self, *args, **kwargs):
print("__init__")
super(A,self).__init__()
def __new__(cls):
print("__new__")
print(cls)
return super(A,cls).__new__(cls)
if __name__ == "__main__":
A()
# -----------------
# result:
__new__
<class '__main__.A'>
__init__
也就是说__new__比__init__先执行，大致的执行流程为__new__接受一个cls,即当前类的并生成一个实例给init中的self,再由init初始化结构，另外__init__中除了self外，其他参数个数要与__new__相同
class B:
def __init__(self, *args, **kwargs):
print("init", args, kwargs)
def __new__(cls, *args, **kwargs):
print("new", args, kwargs)
print(cls)
self = super().__new__(cls)
print(self)
return super().__new__(cls)
if __name__=="main":
B()
__new__方法
其实在上面已经大致的能够知道__new__的用处了，即在初始化机构之前，返回一个类的对象实例给__init__.
一般我们不会去重写该方法，除非你确切知道怎么做，什么时候你会去关心它呢，它作为构造函数用于创建对象，是一个工厂函数，专用于生产实例对象。著名的设计模式之一，单例模式，就可以通过此方法来实现。
单例模式,在当前博客的图书馆一栏，设计模式中有讲到
__call__方法
__call__其实与callback回调函数有关，也就是可回调对象，说简单一点，该魔法方法是在当前类被调用时触发的
class C:
def __init__(self):
print("__init__")
def __call__(self):
print("__call__")
if __name__=="main":
c = C()
c()
# -----------
# result:
__init__
__call__
