面向对象练习题

# 1. 简述编写类和执行类中的方法流程

class Bar:
    pass

obj = Bar()

class Foo:

    def __init__(self, name):  # 构造方法: 完成对象内容的初始化
        self.name = name
        self.age = 233

obj = Foo('Canaan')

# 2. 简述面向对象的三大特性
# 封装(属性和方法)——将相关的功能(类的方法)和共同的参数(类的属性)封装到一个类中
# 继承(为了提高代码的重用性)
# 多态

# 3. 改写函数方法

def func(a1):
    print(a1)

class Function:

    def __init__(self, a1):
        self.a1 = a1

    def func(self):
        print(self.a1)

obj = Function(a1)
obj.func()

# 4. 方法和函数的区别？
# (定义)类中的是方法，(执行)必须先实例化对象，再通过对象去调用，(传参)python会默认传一个self(实例化对象本身)参数
# 函数

# 5. 什么是构造方法

class Foo:

    def __init__(self, name):
        self.name = name

# 6. self只的是一个实例的对象本身

# 7. 以下代码的结果

class Foo:

    def func(self):
        print("foo.func")

obj = Foo()
result = obj.func()  # foo.func
print(result)  # None(方法没有返回值，默认返回None)


# 8. 定义一个类，其中有计算周长和面积的方法(圆的半径通过参数传递到构造方法)
import math
class Circle:

    # 接收参数初始化一个对象，构造方法封装的值不一定需要参数传递
    def __init__(self, r):
        self.r = r
    
    # 计算周常
    def girth(self):
        return 2 * math.pi * self.r
    
    # 计算面积
    def area(self):
        return math.pi * self.r * self.r

# 9. 面向对象为什么要有继承？
# 提高代码的复用性，如果两个类有重复的属性和方法，就放到基类里

# 10. python多继承时，查找成员的顺序是什么规则？
# 先找自己，没有从左往右找父类

# 11. 查看代码写结果
class Base1:

    def f1(self):
        print("Base1.f1")
    
    def f2(self):
        print("Base1.f2")

    def f3(self):
        print("Base1.f3")  # Base1.f3
        self.f1()  # Base1.f1

class Base2:

    def f1(self):
        print("Base2.f1")
    
class Foo(Base1, Base2):
    
    def f0(self):
        print("foo.f0")
        self.f3

obj = Foo()
obj.f0()  # foo.f0


class Base:

    def f1(self):
        print("base.f1")
    
    def f3(self):
        print("base.f3")

class Foo(Base):

    def f1(self):
        print("foo.f1")
    
    def f2(self):
        print("foo.f2")

obj = Base()
obj.f2()  # 报错(父类不能调用子类的方法)

# 15. 补充代码实现

class UserInfo:

    def __init__(self, user, pwd, email):
        self.user = user
        self.pwd = pwd
        self.email = email
    
user_list = []
while True:
    user = input("请输入用户名： ")
    pwd = input("请输入密码： ")
    email = input("请输入邮箱： ")
    user_obj = UserInfo(user, pwd, email)
    user_list.append(user_obj)
    if len(user_list) > 2:
        break

for item in user_list:
    s = "我叫{name}, 邮箱是{email}".format(name=item.user, email=item.email)
    print(s)

# 16. 补充代码实现：用户注册和用户登录
class User:

    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
    

class Account:

    def __init__(self):
        self.user_list = []  # 用户列表，数据格式: [User对象, User对象, User对象]
    
    def login(self):
        # 用户登录，用户输入用户名和密码并去user_list中检查是否合法
        i = 3

        user = input("请输入用户名: ")
        pwd = input("请输入密码: ")

        flag = False
        for item in self.user_list:
            if user == item.name and pwd == item.pwd:
                flag = True
                break
        
        if flag == True:
            print("登录成功")
        else:
            print("登录失败")

    def register(self):
        # 用户注册，动态的创建User对象，并添加到user_list中
        i = 0
         while i < 3:
            i = i + 1
            user = input("请输入用户名: ")
            pwd = input("请出入密码: ")
            user_obj = User(user, pwd)
            self.user_list.append(user_obj)

            
    def run(self):
        # 主程序，进行两次用户注册，再执行用户登录(3次重试机会)
        self.register()
        self.login()


if __name__ == "__main__":
    obj = Account()
    obj.run()

# 1. 简述编写类和执行类中的方法流程

class Bar:
    pass

obj = Bar()

class Foo:

    def __init__(self, name):  # 构造方法: 完成对象内容的初始化
        self.name = name
        self.age = 233

obj = Foo('Canaan')

# 2. 简述面向对象的三大特性
# 封装(属性和方法)——将相关的功能(类的方法)和共同的参数(类的属性)封装到一个类中
# 继承(为了提高代码的重用性)
# 多态

# 3. 改写函数方法

def func(a1):
    print(a1)

class Function:

    def __init__(self, a1):
        self.a1 = a1

    def func(self):
        print(self.a1)

obj = Function(a1)
obj.func()

# 4. 方法和函数的区别？
# (定义)类中的是方法，(执行)必须先实例化对象，再通过对象去调用，(传参)python会默认传一个self(实例化对象本身)参数
# 函数

# 5. 什么是构造方法

class Foo:

    def __init__(self, name):
        self.name = name

# 6. self只的是一个实例的对象本身

# 7. 以下代码的结果

class Foo:

    def func(self):
        print("foo.func")

obj = Foo()
result = obj.func()  # foo.func
print(result)  # None(方法没有返回值，默认返回None)


# 8. 定义一个类，其中有计算周长和面积的方法(圆的半径通过参数传递到构造方法)
import math
class Circle:

    # 接收参数初始化一个对象，构造方法封装的值不一定需要参数传递
    def __init__(self, r):
        self.r = r
    
    # 计算周常
    def girth(self):
        return 2 * math.pi * self.r
    
    # 计算面积
    def area(self):
        return math.pi * self.r * self.r

# 9. 面向对象为什么要有继承？
# 提高代码的复用性，如果两个类有重复的属性和方法，就放到基类里

# 10. python多继承时，查找成员的顺序是什么规则？
# 先找自己，没有从左往右找父类

# 11. 查看代码写结果
class Base1:

    def f1(self):
        print("Base1.f1")
    
    def f2(self):
        print("Base1.f2")

    def f3(self):
        print("Base1.f3")  # Base1.f3
        self.f1()  # Base1.f1

class Base2:

    def f1(self):
        print("Base2.f1")
    
class Foo(Base1, Base2):
    
    def f0(self):
        print("foo.f0")
        self.f3

obj = Foo()
obj.f0()  # foo.f0


class Base:

    def f1(self):
        print("base.f1")
    
    def f3(self):
        print("base.f3")

class Foo(Base):

    def f1(self):
        print("foo.f1")
    
    def f2(self):
        print("foo.f2")

obj = Base()
obj.f2()  # 报错(父类不能调用子类的方法)