day15ClassAndObject
01loginAndRegister
1.持久化的数据：所有已经注册过的账号
2.设计文件：files/userInfo.txt
方案1：{用户名1: 密码1, 用户名2: 密码2,…} 后期新加入昵称、绑定手机号等需重新构建 无拓展性
方法2：[{‘username’: 用户名1, ‘pw’: 密码1}, {‘username’:用户名2, ‘pw’: 密码2}, …]
def read_file(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as f:
return f.read()
except FileNotFoundError:
return None
def register():
# 1. 提示用户输入账号和密码
username = input('请输入账号:')
password = input('请输入密码:')
# 2. 判断账号是否已经注册过
# 1)获取所有已经注册过的账号
result = read_file('files/userInfo.txt')
if result:
all_user = eval(result)
else:
all_user = []
# 2)判断输入账号是否在已经注册过的账号中
for user in all_user:
if user['username'] == username:
print('注册失败！该账号已存在！')
return
# 3. 完成注册
all_user.append({'username': username, 'pw': password})
with open('files/userInfo.txt', 'w', encoding='utf-8') as f:
f.write(str(all_user))
print('注册成功！')
def login():
# 1. 输入账号和密码
username = input('请输入账号:')
password = input('请输入密码:')
# 2. 判断是否登录成功
# 1)获取已经注册过的用户信息
result = read_file('files/userInfo.txt')
if not result:
print('登录失败！该账号不存在！')
return False
# 2)判断用户名是否已经注册并且输入的密码和保存密码是否一致
all_user = eval(result)
for user in all_user:
if user['username'] == username:
if user['pw'] == password:
print('登录成功！')
return True
else:
print('登录失败！密码错误!')
return False
print('登录失败！该账号不存在！')
return False
def main_page():
page = read_file('files/mainPage.txt')
while True:
# 1. 打印主页内容
print(page)
# 2. 给出选择
value = input('请选择(1~3):')
# 3. 根据不同的选择程序做出不同的反应
if value == '1':
result = login()
if result:
break
elif value == '2':
register()
else:
exit() # 退出程序
# return
print(read_file('files/succeed.txt'))
if __name__ == '__main__':
main_page()
02codeMind
根据面对问题不同人呈现出来的思维模式不同，可以将编程思维分为三种：
- 面向过程编程(穷人思想) - 遇到问题马上先到是解决这个问题的具体逻辑和步骤
- 函数式编程(小资思想) - 遇到问题马上想到有没有一个已经存在的函数可以解决这个问题，如果没有就造一个 (一个函数只具备一个功能) - 函数
- 面向对象编程(富豪思想) - 遇到问题马上想到有没有一个具有这个功能的对象，如果没有就造对象 (一个对象可以同时具有多个功能) - 类和对象
1. 面向过程编程(穷人思想)
1*2*3*4....10
sum = 1
for i in range(1,11):
sum1 *= x
print(sum1)
2. 函数式编程(小资思想)
from functools import reduce
03classAndObject
1.什么是类？什么是对象？
类就是拥有相同功能或者相同属性的对象的集合。(类是抽象的概念)
对象就是类的实例。
如果人是类，余婷是对象，骆昊是另一个对象
车是类，骆老师家的车就是对象
斗地主游戏是类 一局游戏是对象
2. 定义类 - 创建类
(1) 定义类：用代码来描述你的这个类是拥有哪些相同功能(用函数)和哪些相同属性(用变量)的对象的集合。
(2) 语法：
class 类名:
类的说明文档
类的内容(包含方法和属性)
(3) 说明:
a. class - 关键字；固定写法
b. 类名 - 由程序员自己命名
两个要求：是标识符；不是关键字
规范：见名知意；不使用系统的函数名、类名和模块名；采用驼峰式命名(大驼峰)
c. 说明文档 - 本质就是一个多行注释
d. 类的内容 - 包含定义在类中的函数(方法)和定义在类中的变量(属性)
方法包括：对象方法、类方法、静态方法
属性包括：类属性、对象属性
# user_name - PEP8
# userName - 小驼峰
# UserName - 大驼峰
class Dog:
"""这是狗"""
pass
# 3.创建对象
"""
对象是通过类来创建的。
语法：
类名()
"""
dog1 = Dog()
dog2 = Dog()
print(dog1)
print(dog2)
04Method
1.什么是方法
定义在类中函数就是方法
2，不同的方法的使用
(1) 对象方法
a.怎么定义：直接定义在类中的函数就是对象方法
b.怎么调用：以 ‘对象.xxx()’ 的形式来调用
c.特点：自带参数self，调用函数的时候self不需要传参，系统自动将当前对象传给self(谁调用self指向谁)
(2) 类方法
a.怎么定义：定义函数前添加装饰器 @classmethod
b.怎么调用：以 ’类名.xxx()‘ 的形式来调用
c.特点：自带参数cls，调用函数的时候cls不需要传参，系统会自动将单签类传给cls
(3) 静态方法
a.怎么定义：定义函数前添加装饰器 @staticmethod
b.怎么调用：以 ’类名.xxx()‘ 的形式来调用
c.特点：没有特点
class A:
# func1是对象方法
def func1(self):
# self = a1
print(f'self:{self}')
print('对象方法')
def func2(self, a, b=2):
print(f'对象方法2, a:{a}, b:{b}')
# func3是类方法
@classmethod
def func3(cls):
print(f'cls:{cls}')
print('类方法')
# func4是静态方法
@staticmethod
def func4():
print('静态方法')
a1 = A()
a2 = A()
print(f'a1:{a1}')
print(f'a2:{a2}')
# 通过对象调用对象方法
a2.func1()
a1.func2(100)
a1.func2(100,200)
a1.func2(b=1000,a=200)
print("--------------------通过对象调用对象方法---------------------")
# 通过类调用类方法
print(f'A:{A}')
A.func3()
print("--------------------通过类调用类方法---------------------")
# 通过类调用静态方法
A.func4()
print("--------------------通过类调用静态方法---------------------")
05initMethod
1.魔法方法(初始化方法)
(1) 魔法方法的特点：
a.函数名__开头，并且以__结尾
b.魔法方法不需要程序员自己调用，系统会在特定情况下自动调用
(2) 两个常见的魔法方法
a.__init__：
如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它 (__init__中有内容时调用才有数据)
创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定
b.__repr__:
如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回作为打印结果进行打印。
在类中添加__repr__方法的时候，这个方法的返回值必须是字符串。
class A:
def __init__(self):
print("init方法被调用")
a1 = A()
a2 = A()
print(a1)
class B:
def __init__(self, m, n):
print(f'm:{m}, n:{n}')
def __repr__(self):
return f'<B的对象 在{id(self)}>'
b1 =B(10, 20)
b2 =B(m = 100, n = 200)
print("--------------------------")
print(b1)
06attribute
1.类中的属性分为：类属性、对象属性
1) 类属性
a.怎么定义：直接在类中定义的变量就是属性
b.怎么使用：以 ’类名.xxx()‘ 的方式使用
c.什么时候用：如果属性值不会因为对象不同而不一样，就定义成类属性
2) 对象属性
a.怎么定义：以 ’self.属性名 = 属性值‘ 的形式定义在__init__方法中
b.怎么使用：以 ’对象.xxx()‘ 的方式使用
c.什么时候用：如果属性值会因为对象不同而不一样，就定义成对象属性
class A:
# a、name就是类属性
a = 10
name = '张三'
# x和n是对象属性
def __init__(self):
self.x = 10
self.n = 'hello'
# 通过类使用类属性
print(A.a)
print(A.name)
# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)
class Dog:
def __init__(self, name, breed, age=3, gender='公'):
self.name = name
self.age = age
self.gender = gender
self.breed = breed
# dog1 = Dog()
# dog1.name = '小黑'
# dog2 = Dog()
# dog2.name = '土豆'
dog1 = Dog('小黑', '土狗')
dog2 = Dog('土豆', '泰迪')
print(dog1.name, dog2.name)
class Circle:
pi = 3.1415926
def __init__(self, r=0):
self.r = r
# 如果对象方法中需要用到对象属性，由self来提供
def area(self):
return Circle.pi * self.r ** 2
c1 = Circle(10)
print(c1.area())
c1.r = 20
print(c1.area())
07inherit
1.继承
继承： 让子类直接拥有父类的属性和方法
子类 - 继承者
父类 - 被继承的类
2. 继承语法
语法：
class 类名(父类1, 父类2, 父类3,…):
类的说明文档
类的内容
注意：定义类的时候没有写父类，那么这个类会默认继承 object(基类)
class A:
m = 100
def __init__(self):
self.n = 200
def func1(self):
print('对象方法')
@classmethod
def func2(cls):
print('类方法')
@staticmethod
def func3():
print('静态方法')
class B(A):
# 添加新的类属性
x = 'hello'
# 添加新的对象属性
def __init__(self):
super().__init__() # 调用当前类的父类的__init__
# super(B, self).__init__()
self.p = 1000
# 添加新的方法
def func11(self):
print('对象方法2')
@classmethod
def func22(cls):
print('类方法2')
@staticmethod
def func33():
print('静态方法2')
b1 = B()
# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()
B.func3()
# 使用B中的内容
print(B.x)
b1.func11()
B.func22()
B.func33()
print(b1.p)
478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
