¶ 类(class)与对象(object)

strs = '字符串'
ints = 1
floats = 2.3

print(type(strs)) # <class 'str'>
print(type(ints)) # <class 'int'>
print(type(floats)) # <class 'float'>

str1 = '我是字符串'
str2 = '1'
str3 = '2.3'
str4 = 'True'

listObject = [1,3,'列表实例里的第三个元素']  # 一个列表实例
listObject.append('我是列表实例利用类上的append方法添加进来的元素') # 调用列表类的内置方法append
print(listObject) # [1, 3, '列表实例里的第三个元素', '我是列表实例利用类上的append方法添加进来的元素']

class 首字母大写的类变量名:
  自定义属性名 = 属性值
  def 自定义方法名(self,参数1,可以没有参数2):
    方法函数体内容

# 创建一个男朋友类对象
class MyBoyfriend:
  sex = 'male'
  def caring(self):
    print('好了，不哭了~')
  
boyfriend = MyBoyfriend() # 调用类对象，得到男朋友实例对象。
print(type(MyBoyfriend)) # <class 'type'>
print(boyfriend) # <__main__.MyBoyfriend object at 0x109922400> MyBoyfriend类的是一个实例对象。后面的一串字符(0x109922400)表示这个对象的内存地址。
print(type(boyfriend)) # <class '__main__.MyBoyfriend'> 表示boyfriend类属于MyBoyfriend类。

实例变量名 = 类名() # 类名后+小括号调用

实例名.属性

实例名.方法(传参) # 参数不用考虑self

# 调用类的属性
print(boyfriend.sex) # 打印"male"

# 调用类的方法
boyfriend.caring() # 打印“好了，不哭了~”

# self
class SelfMean:
  content = '类SelfMean中的属性'
  def oneFn(self):
    print(self.content) # self在此指向实例化的对象"selfMean"
selfMean = SelfMean()
selfMean.oneFn() # 打印类中content的值 - "类SelfMean中的属性"

class SelfMean:
  content = '类SelfMean中的属性'
  def oneFn(self):
    print(content) # 不用self调用类属性，就会报错NameError: name 'content' is not defined
selfMean = SelfMean()
selfMean.oneFn()

selfMean = {
  'content': '类SelfMean中的属性',
  'oneFn': 一个函数体在这里~
}

class SelfMean:
  content = '类SelfMean中的属性'
  def oneFn(self):
    print(self.content) # 提前在类中使用了实例化对象的属性 content，等价于selfMean.content
    self.twoFn('哈哈哈哈哈~') # 提前在类中使用了实例化对象的方法 twoFn、并传参
  def twoFn(self, txt):
    print('实例化对象的第二个方法，打印内容：', txt)
selfMean = SelfMean()
selfMean.oneFn()

class SelfParams:
  content = '类SelfParams中的属性'
  def twoFn(self,name,sex,age,weight):
    print(self.content)
    print(name,sex,age,weight) # 2、依次打印传递过来的位置参数的值：小石头 female 19 91
selfParams = SelfParams()
selfParams.twoFn('小石头','female',19,91) # 1、调用方法时忽略self参数，依次按位置传递name,sex,age,weight的参数

# init
class InitTest:
  def __init__(self):
    a = 321
    b = 345

    print("初始化就会执行init里的代码: ", a+b)
initTest = InitTest()

# 运行后直接打印：初始化就会执行init里的代码:  666

class InitTest:
  def __init__(self):
    # 为类属性设置初始值，要写在__init__函数内部的最上方，否则会报错
    self.a = 321 # 注意self的存在。
    self.b = 345 # 同上

    # 定义完属性的初始值以后，才能在下变写__init__里边要处理的其他逻辑
    print("初始化就会执行__init__里的代码")
    self.plusAd()

  def plusAd(self):
    print(self.a + self.b) # 使用类属性

initTest = InitTest()
# 打印结果如下
# 初始化就会执行init里的代码
# 666

# 初始化方法接收参数
class InitParams:
  def __init__(self,aP,bP):
    self.a = aP
    self.b = bP

    print('初始化执行并设置属性、把参数aP和bP的值给了属性a和b')
    self.plusAd()

  def plusAd(self):
    print(self.a + self.b) # 其他方法也能用同一个属性

  def sub(self):
    print(self.a - self.b) # 其他方法也能用公用的属性

initParams1 = InitParams(12, 4) # __init__需要的参数在类调用时传递
# 打印结果：
# 初始化执行并设置属性、把参数aP和bP的值给了属性a和b
# 16
# 8

initParams2 = InitParams(30, 5) # __init__需要的参数在类调用时传递，可以多次调用，传不同的参数，进而得到不一样的结果
# 打印结果：
# 初始化执行并设置属性、把参数aP和bP的值给了属性a和b
# 35
# 25 

# 全局变量定义
globalA = 12
globalB = 20
globalCount = 0

# 加
def plus():
  global globalCount
  globalCount = globalA + globalB
  sub()

# 减
def sub():
  global globalCount
  globalCount = globalCount - globalA/2
  print(globalCount)

# 主流程
def main():
  plus()

# 启动流程
main()

# 面向对象
class Calculator:
  def __init__(self,a,b):
    # 公共属性定义
    self.globalA = a
    self.globalB = b
    self.globalCount = 0

  # 是加法方法，能做加法
  def plus(self):
    self.globalCount = self.globalA + self.globalB
    print(self.globalCount)

  # 是减法方法，能做减法
  def sub(self):
    self.globalCount = self.globalCount - self.globalA/2
    print(self.globalCount)

calculator = Calculator(12,20)
calculator.plus()
calculator.sub()