python 学习——面向对象编程

@python学习记录

概念

类

类：具有相同特征的对象，python里主要是字符串类（str）/整数类（int）/浮点数类（float)…，具体的整数7、字符串’world‘叫做实列。
类的共同点叫属性（what），如何使用称为方法(how),属性和方法需要人工创建
对象：类和实例的集合，既可以是类对象，也可以是实例对象。
类的创建需要有类名，首字母大写，属性（赋值语句），方法（类中自带的self函数），具体如下：

class Chinese:
	eyes='black'
    def instr(self):
        print('吃饭，选择用筷子')'

创建了中国人的类
类的实例化，就是在某个对象类下创建一个实例对象。比如刚才创建的中国人类，调用这个类创建一个具体实列，如下：

wang = Chinese
print(wang.eyes)
wang.instr()

结果
black
吃饭，选择用筷子
——————————

*** 在类的外部调用类属性必须先创建一个实例，在实例名.属性的格式调用，类的内部调用类属性用self.属性这样调用类后，实例参数传给self。

错误示范，运行会报错

class Chinese:

    name = '小王'  # 类属性name

    def say(self):
        print(name + '是中国人')
        # 打印出'小王是中国人'
person = Chinese()
person.say()

————————
正确示范

class Chinese:

    name = '小王'  # 类属性name

    def say(self):     
        print(self.name + '是中国人')

person = Chinese()   # 创建Chinese的实例person
person.say()         # 调用实例方法

如果想在类的方法内部调用其他方法时，我们也需要用到self来代表实例。

总结：
第一点：只要在类中用def创建方法时，就必须把第一个参数位置留给 self，并在调用方法时忽略它（不用给self传参）。
第二点：当在类的方法内部想调用类属性或其他方法时，就要采用self.属性名或self.方法名的格式。

特殊方法：初始化方法

作用：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。
格式如下：

def __init__(self)

class Chinese:
    def __init__ (self):
        self.mouth = 1  # self.不能丢
        self.eye = 2 #初始化方法内部创建类属性
    
    def body(self):
        print('我有%s张嘴巴' % self.mouth)
        print('我有%s只眼睛' % self.eye)#类的方创建

person = Chinese()#实例创建后自动调用方法
person.body()#调用方法

初始化方法同样可以接收其他参数，让传入的这些数据能作为属性在类的方法之间流转

class Chinese:
    def __init__(self,hometown):
        self.hometown=hometown
        print('where are you born?')
    
    def born(self):
        print('我出生在%s。' % self.hometown)

wufeng = Chinese('广东')
wufeng.born()

面向对象编程

面向过程编程：分析解决问题所需要的步骤，用各函数实现每个步骤，依次调用。
如下

import math

# 变量key代表循环运行程序的开关
key = 1

# 采集信息的函数
def myinput():
    choice = input('请选择计算类型：（1-工时计算，2-人力计算）')
    if choice == '1':
        size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
        number = int(input('请输入人力数量：（请输入整数）'))
        time = None
        return size,number,time
        # 这里返回的数据是一个元组
    if choice == '2':
        size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
        number = None
        time = float(input('请输入工时数量：（请输入小数）'))
        return size,number,time
        # 这里返回的是一个元组

# 完成计算的函数
def estimated(my_input):
    # 把元组中的数据取出来
    size = my_input[0]
    number = my_input[1]
    time = my_input[2]
    # 人力计算
    if (number == None) and (time != None):
        number = math.ceil(size * 80 / time)
        print('项目大小为%.1f个标准项目，如果需要在%.1f个工时完成，则需要人力数量为：%d人' %(size,time,number)) 
    # 工时计算
    elif (number != None) and (time == None):
        time = size * 80 / number
        print('项目大小为%.1f个标准项目，使用%d个人力完成，则需要工时数量为：%.1f个' %(size,number,time))  

# 询问是否继续的函数
def again():
    # 声明全局变量key，以便修改该变量
    global key
    a = input('是否继续计算？继续请输入y，输入其他键将结束程序。')
    if a != 'y':
        # 如果用户不输入'y'，则把key赋值为0
        key = 0  

# 主函数
def main():
    print('欢迎使用工作量计算小程序！')
    while key == 1:
        my_input = myinput()
        estimated(my_input)
        again()
    print('感谢使用工作量计算小程序！')

main()

面向对象的思维：程序是一组对象的组合，先创建类，定义属性（是什么）和方法（能做什么），接着以类为模板创建实例对象，用实例去调用类中定义好的属性和方法。
栗子：

import math

class Project:
    
    def __init__(self):
        self.key = 1

    def input(self):
        choice = input('请选择计算类型：（1-工时计算，2-人力计算）')
        if choice == '1':
            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
            self.number = int(input('请输入人力数量：（请输入整数）'))
            self.time = None
        if choice == '2':
            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
            self.number = None
            self.time = float(input('请输入工时数量：（请输入小数）'))

    def estimated(self):
        # 人力计算
        if (self.number == None) and (self.time != None):
            self.number = math.ceil(self.size * 80 / self.time)
            print('项目大小为%.1f个标准项目，如果需要在%.1f个工时完成，则需要人力数量为：%d人' %(self.size,self.time,self.number)) 
        # 工时计算
        elif (self.number != None) and (self.time == None):
            self.time = self.size * 80 / self.number
            print('项目大小为%.1f个标准项目，使用%d个人力完成，则需要工时数量为：%.1f个' %(self.size,self.number,self.time))  
    
    def again(self):
        a = input('是否继续计算？继续请输入y，输入其他键将结束程序。')
        if a != 'y':
            # 如果用户不输入'y'，则把key赋值为0
            self.key = 0  

    # 主函数
    def main(self):
        print('欢迎使用工作量计算小程序！')
        while self.key == 1:
            self.input()
            self.estimated()
            self.again()
        print('感谢使用工作量计算小程序！')
        
# 创建实例
project1 = Project()
project1.main()

class Greeting:
    def __init__(self,name_AI,me):
        self.name_AI = name_AI
        self.me = me
    def hi(self):
        print('Hello! %s,i am robots %s.' %(self.me,self.name_AI))
        
first = Greeting('wali','xu')
first.hi()

12关作业练习2

class Greeting:
    def __init__(self):
        self.name_AI = input('你想怎么称呼我？')
        self.me = input('我该怎么称呼您？')
        print('Hello! %s,i am robots %s.' %(self.me,self.name_AI))
       
        
    def say_wish(self):
        self.wish = input('your wish is ?')
        for i in range(3):
            print('%s 的愿望是%s'%(self.me,self.wish))
first = Greeting()
first.say_wish()

老师的参考代码

class Robot:
    def __init__(self):
        self.name = input('我现在刚诞生，还没有名字，帮我起一个吧。')
        self.master = input('对了，我要怎么称呼你呢？')
        print('你好%s，我叫%s。很开心，遇见你~'%(self.master,self.name))
    
    def say_wish(self):
        wish = input('告诉一个你的愿望吧：')
        print(self.master+'的愿望是：')
        # 这里也可以用字符串的格式化，不过，用循环语句的话，之后改复述次数会方便些。
        for i in range(3):
            print(wish)

robot1 = Robot()
robot1.say_wish()