常用函数

  • issubclass

作用：检测一个类是否是另一个类的子类，格式：issubclass(子类,父类)，返回值：布尔值。

1
2
3
4
5
6
7
class Father(object):
  pass
class Son(Father):
  pass
result = issubclass(Son,object)
print(result)
注意事项：只要存在于继承关系中 就成立
  • isinstance()

作用：检测一个对象是否是指定类的实例，格式：isinstance(对象,类)，返回值：布尔值。

1
2
3
4
5
6
7
class Monkey:
  pass
class Human:
  pass
ren = Human()
result = isinstance(ren,(Monkey,Human))
print(result)
  • hasattr()

作用：检测类/对象是否包含指定名称的成员，格式：hasattr(对象,成员名称)，返回值：布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Human:
  #成员属性
  age = 1
  sex = 'man'
  #成员方法
  def cry(self):
      print('555555')
#对类进行成员检测
result = hasattr(Human,'smile')
print(result)
#实例化对象
ren = Human()
result = hasattr(ren,'age')
print(result)
#注意：可以检测类也可以检测对象，只要可以访问就算存在
  • getattr()

作用：获取类.对象的成员值，格式：getattr(对象,成员名称,默认值)，返回值：不确定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Monkey:
  #属性
  age = 10
  sex = '雄'
  color = 'golden'
  #方法
  def say(self):
      print('叽叽叽叽~')

#实例化对象
houzi = Monkey()
#获取猴子的颜色
#print(houzi.color)#语法方式
#result = getattr(houzi,'color')#函数方式
#print(result)

#获取不存在的成员
#print(houzi.name)
result = getattr(houzi,'name','小猴子~')
print(result)
  • setattr()

作用：设置类/对象的成员值, 格式：setattr(对象,成员名称,设置的值)，返回值：无。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Monkey:
  #属性
  age = 10
  sex = '雄'
  color = 'golden'
  #方法
  def say(self):
      print('叽叽叽叽~')

#实例化对象
houzi = Monkey()
print(houzi.__dict__)
#设置对象成员
#houzi.name = '小悟空'#语法方式
#houzi.color = '黑色'

setattr(houzi,'weight','100斤')#函数方式
print(houzi.__dict__)
  • delatter()

作用：删除类.对象的成员,格式：delattr(对象,成员名称)，返回值：无。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Monkey:
  #属性
  age = 10
  sex = '雄'
  color = 'golden'


  #方法
  def __init__(self):
      self.name = 'xwk'
      self.height = 100

  def say(self):
      print('叽叽叽叽~')
#实例化对象
houzi = Monkey()
print(houzi.__dict__)
#del houzi.name #语法方式
delattr(houzi,'height')
print(houzi.__dict__)
  • dir()

作用：获取对象可以访问的所有成员的列表

  • property()

作用：设置描述符操作的函数

1
2
3
4
5
6
7
<左对齐  ^  居中对齐  >右对齐

#str1 = '我的女朋友是{0:#<10}'
#str1 = '我的女朋友是{0:#^10}'
str1 = '我的女朋友是{0:#>10}'
result = str1.format('小红')
print(result)

内置成员与方法

  • 内置成员
1
2
3
4
5
__dict__:获取类/对象的所属成员组成的集合
__doc__:获取类的文档信息
__name__:获取类名称的字符串
__module__:获取当前类所在的文件的名称，当前文件显示为__main__
__bases__:获取当前类的父类列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#声明一个类
class Animal:
  pass
#声明一个类
class Action:
  pass
#声明一个类
class Human(Animal,Action):
  '''
  这是类的文档
  成员    信息
  成员    信息
  成员    信息~
  成员    信息
  '''
  #成员属性
  sex = 1
  age = 18
  color = 'yellow'
  #成员方法
  def smile(self):
      print('哈哈哈哈哈')
  def cry(self):
      print('呜呜呜呜~~')

#实例化对象
ren = Human()
#__dict__
#print(Human.__dict__)
#print(ren.__dict__)

#__doc__
#print(Human.__doc__)

#__name__
#print(Human.__name__)

#__module__
#print(Human.__module__)

#__bases__
print(Human.__bases__)
  • 成员方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
对象方法：该方法中会直接传入当前对象
  调用方式：对象.成员方法()
  特征：会将当前对象传入方法中

类方法:在方法中会直接传入当前类
  调用方式：类.成员方法()
  特征：会将当前类传入方法中

绑定类的方法:在方法中不会传入类或者对象的方法
  调用方式：类.成员方法()
  特征：不会传入类或者对象

静态方法：与类喝对象无关，但是存在于类结构中的方法
  调用方式：类.成员方法（） 或者对象.成员方法（）
  特征：类或者对象都可以调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#声明一个类
class Human:
  #成员方法
  #吃方法  ->对象方法
  def eat(self):
      print(self)
      print('这是一个对象方法')

  #喝方法  ->类方法
  @classmethod
  def drink(cls):
      print(cls)
      print('这是一个类方法')

  #玩方法 -> 绑定类的方法
  def play():
      print('绑定类的方法')

  #乐方法 - > 静态方法
  @staticmethod
  def happy():
      print('这是一个静态方法')

#实例化对象 调用方法
ren = Human()
#调用对象方法
#ren.eat()

#调用类方法
#Human.drink()

#调用绑定类的方法
#Human.play()

#调用静态方法
#Human.happy()
#ren.happy()