类的定义

class Student:

#定义类属性(类似于java的静态成员变量)

country = "China"

#构造函数

def __init__(self,name,score):#self代表对象本身，类似于java中的this

#声明成员变量

self._name = name#如果是一个_代表是私有变量(实际上仍然可以访问)，两个下划线的时候__，编译器会自动更改变量名

self._score = score

#setter方法

def setName(self,name):

self._name = nameame

def setScore(self,score):

if score>0 and score <100:

self._score = score

#getter方法

def getName(self):

return self._name

def getScore(self):

return self._score

创建对象

stu = Student('kehao',80)

print(type(stu))

print(stu.getName())

stu.setScore(-10)

print(stu.getScore())

stu.setScore(90)

print(stu.getScore())

print(Student.country)

print(stu.country)

kehao

80

90

China

China

继承和多态

class Animal:

def run(self):

print('Animal is running...')

def sleep(self):

print('Sleeping')

class Dog(Animal):

#重载

def run(self):

print('Dog is running...')

def eat(self):

print('Eatting meats')

class Cat(Animal):

#重载

def run(self):

print('Cat is running...')

dog = Dog()

dog.run()

dog.sleep()

cat = Cat()

cat.run()

cat.sleep()

Dog is running...

Sleeping

Cat is running...

Sleeping

def run(animal):

animal.run()

animalList = [cat ,dog]

for animal in animalList:

run(animal)

Cat is running...

Dog is running...

一些常用的函数

isinstance(a, A)这个函数是看a是不是A的实例，子类对象对于父类也是返回True

type(a)返回a的类型

dir(a)获得a的所有方法和属性

getattr(obj,a,b):获取obj的a属性，如果没有则返回默认值b

setattr(obj,a,b):设置obj的a属性为b

hasattr(obj,a):判断obj是否有a 属性

print(isinstance(cat,Animal))#判断一个

print(isinstance('a',(int,float)))#判断多个

print(isinstance('a',(int,float,str)))

True

False

True

print(type(cat))

print(type(cat) == Cat)

#types里面有很多常量值

import types

if type(run) == types.FunctionType:

print('run is a function')

if type(abs) == types.BuiltinFunctionType:

print('abs is builtin function')

if type(lambda x:x*x) == types.LambdaType:

print("it's a lambda type")

if type((x for x in range(10)))==types.GeneratorType:

print("it is generate type")

True

run is a function

abs is builtin function

it's a lambda type

it is generate type

dir(stu) #返回一个列表，列表里是一个对象所有的属性和方法

['__class__',

'__delattr__',

'__dict__',

'__dir__',

'__doc__',

'__eq__',

'__format__',

'__ge__',

'__getattribute__',

'__gt__',

'__hash__',

'__init__',

'__init_subclass__',

'__le__',

'__lt__',

'__module__',

'__ne__',

'__new__',

'__reduce__',

'__reduce_ex__',

'__repr__',

'__setattr__',

'__sizeof__',

'__str__',

'__subclasshook__',

'__weakref__',

'_name',

'_score',

'getName',

'getScore',

'setName',

'setScore']

限制实例的属性

使用__slots__

__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

class Student(object):

__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

s = Student() # 创建新的实例

s.name = 'Michael' # 绑定属性'name'

s.age = 25 # 绑定属性'age'

s.score = 99 # 绑定属性'score'

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

in

----> 1 s.score = 99 # 绑定属性'score'

AttributeError: 'Student' object has no attribute 'score'

@property装饰器

负责把一个方法变成属性调用

getter和setter方法都为属性名

将getter方法上标注@property装饰器

将setter方法上标注函数名.setter装饰器

class Student1(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

s = Student1()

s.score = 60 # OK，实际转化为s.set_score(60)

s.score # OK，实际转化为s.get_score()

60

s.score = 9999#报错是因为上面的函数抛出了错误

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in

----> 1 s.score = 9999#报错是因为上面的函数抛出了错误

in score(self, value)

10 raise ValueError('score must be an integer!')

11 if value < 0 or value > 100:

---> 12 raise ValueError('score must between 0 ~ 100!')

13 self._score = value

ValueError: score must between 0 ~ 100!

多重继承

class A:

def showItself(self):

print('A')

class B:

def showItself(self):

print('B')

class AB(A,B):

pass

class BA(B,A):

pass

如果父类函数名相同 优先调用左边的

ab = AB()

ba = BA()

ab.showItself()

ba.showItself()

A

B

调用被覆盖了的其他方法

方法1：

class AB2(A,B):

def showItself_B(self):

B.showItself(self)

ab2 =AB2()

ab2.showItself()

ab2.showItself_B()

A

B

方法2：

class AB3(A,B):

def showItself_B(self):

super(A,self).showItself()

ab3 = AB3()

ab3.showItself_B()

B

这个有点令人迷惑，为什么super(A,self).showItself()调用的却不是A的方法，而且A的父类是object，更没有这个方法

实际上这个是按照顺序来选择的，默认的super()调用的是第一个A，然后下一个是B

再python2中这个搜索顺序是深度优先搜索，而在python3中这个顺序是广度优先搜索

class A1(A):

def showItself(self):

print('A1')

class A2(A):

def showItself(self):

print('A2')

class A12(A1,A2):

def showItself(self):

super().showItself()

super(A1,self).showItself()

super(A2,self).showItself()

a12 = A12()

a12.showItself()

A1

A2

A

特殊方法

__str__和__repr__

用于当使用print的时候就会调用__str__方法去获取字符串

用于当使用交互模式直接输出变量的时候就会调用__repr__方法去获取字符串

class Astr1:

def __repr__(self):

return "这是__repr__方法的调用"

class Astr2:

def __str__(self):

return "这是__str__方法的调用"

print(Astr1())

print(Astr2())

这是__repr__方法的调用

这是__str__方法的调用

Astr1()

这是__repr__方法的调用

Astr2()

__iter__和__next__

当对象需要使用for循环的时候，必须要去实现__iter__方法，返回一个迭代对象

然后迭代对象的__next__方法会被调用

class A_iter:

a = 0

def __iter__(self):

return self

def __next__(self):

A_iter.a+=1

if A_iter.a>10:

raise StopIteration()##终止循环

return A_iter.a

a_iter = A_iter()

for i in a_iter:

print(i,end=" ")

1 2 3 4 5 6 7 8 9 10

__getitem__

__getitem__是用于取序列元素的

一般要分为数字和切片，分别处理

class A_getitem:

def __getitem__(self,n):

if isinstance(n,int):#索引为数字

return n

if isinstance(n,slice):#索引为切片

return [x for x in range(n.start,n.stop)]

a = A_getitem()

print(a[100])

print(a[10:20])

100

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

__getattr__

用于返回未定义的参数

__getattribute__与 __getattr__的区别

当每次调用属性时，python会无条件进入__getattribute__中，不论属性存在与否

而__getattr__只会在找不到属性的时候调用

class A_attr:

def __getattribute__(self,attr):

return attr

a = A_attr()

print(a.name)

name

__call__

将对象本身视为一个方法，调用的就是__call__

class A_call:

def __call__(self):

print('__call__方法被调用')

a = A_call()

a()

__call__方法被调用

判断对象是否能被作为函数调用使用callable()函数

print(callable("123"))

print(callable(a))

False

True

枚举类型

#导入枚举的包

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

Month.Jan

本文地址：https://blog.csdn.net/qq754772661/article/details/107065325

希望与广大网友互动？？

点此进行留言吧！