# 定义类
class 类名:
def 方法名(self,name):
print(name)
return 123
def 方法名(self,name):
print(name)
return 123
def 方法名(self,name):
print(name)
return 123
# 调用类中的方法
# 1.创建该类的对象
obj = 类名()
# 2.通过对象调用方法
result = obj.方法名(‘alec‘)
print(result)
# 例子
# 定义一个类：Account
class Account:
# 方法
def login(self):
print(‘登录‘)
def logout(self,name,*args,**kwargs):
return name
# 调用类中的方法
# 1.创建对象
x = Account() # 创建了一个Account类的对象
# 2.使用对象调用类中的方法
x.login()
# 3.使用其中的函数也可以传值，不管有没有传参第一位必须是self
date = x.logout(‘alec‘)
print(date)
应用场景：遇到很多函数，需要给函数进行归类和划分。【统一名词：封装】
存储一些值，以后方便自己使用
调用时实例化对象，相当于创建了一个独立的内存
对象是同一个对象，但是内存中参数的值是相对独立存在的
class Person:
def show(self):
print(self.name)
p1 = Person()
p1.name = ‘liyazhou‘
p1.show() #liyanzhou
p2 = Person()
p2.name = ‘liyanan‘
p2.show() #liyanan
#示例：
class File:
def read(self):
with open(self.Path, mode=‘r‘, encoding=‘utf-8‘) as f:
data = f.read()
return data
def write(self, content):
with open(self.Path, mode=‘a‘, encoding=‘utf-8‘) as f:
f.write(content)
# # 实例化了一个File类的对象obj1
obj1 = File()
# # 在对象中写了一个xxxxx = ‘test.log‘
obj1.Path = "test.log"
# # 通过对象调用类中的read方法，read方法中的self就是obj。
# # obj1.read()
manager1 = obj1.read()
print(manager1)
# # 实例化了一个File类的对象
obj2 = File()
obj2.Path = "logss.txt"
manager2 = obj2.read()
print(manager2)
# # 调用写的方法
obj3 = File()
obj3.Path = "logss.txt"
obj3.write(‘alec255‘)
第三种方法：类里加__init__()这种方法
class Person:
def __init__(self,n,a,g):
self.name = n
self.age = a
self.gender = g
def show(self):
temp = "我是%s,年龄：%s,性别：%s"%(self.name,self.age,self.gender)
print(temp)
# 类 () 实例化对象，自动执行此类中的 __init__方法。
# 可以把参数写进 __init__方法中，调用实例化对象时传参
p1 = Person(‘李亚楠‘,22,‘男‘)
p1.show()
p2 = Person(‘亚洲‘,20,‘男‘)
p2.show()
如果写代码时，函数比较多比较乱：
class File:
def __init__(self,path):
self.file_path = path
def read(self):
print(self.file_path)
def write(self,content):
print(self.file_path)
def delete(self):
print(self.file_path)
def update(self):
print(self.file_path)
p1 = File(‘log.txt‘)
p1.read()
p2 = File(‘xxxxxx.txt‘)
p2.read()
# 1. 循环让用户输入：用户名/密码/邮箱。 输入完成后再进行数据打印。
# ########## 列表的写法
USER_LIST = []
while True:
user = input(‘请输入用户名：‘)
pwd = input(‘请输入密码：‘)
email = input(‘请输入邮箱：‘)
temp = {‘username‘:user,‘password‘:pwd,‘email‘:email}
USER_LIST.append(temp)
for item in USER_LIST:
temp = "我的名字：%s,密码：%s,邮箱%s" %(item[‘username‘],item[‘password‘],item[‘email‘],)
print(temp)
# ########## 面向对象写法
class Person:
def __init__(self,user,pwd,email):
self.username = user
self.password = pwd
self.email = email
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
user = input(‘请输入用户名：‘)
pwd = input(‘请输入密码：‘)
email = input(‘请输入邮箱：‘)
p = Person(user,pwd,email)
USER_LIST.append(p)
for item in USER_LIST:
temp = "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
print(temp)
# ########## 面向对象写法
class Person:
def __init__(self,user,pwd,email):
self.username = user
self.password = pwd
self.email = email
def info(self):
return "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
user = input(‘请输入用户名：‘)
pwd = input(‘请输入密码：‘)
email = input(‘请输入邮箱：‘)
p = Person(user,pwd,email)
USER_LIST.append(p)
for item in USER_LIST:
msg = item.info()
print(msg)
子类（派生类）与父类（基类）：子类对象调用方法时优先用子类中的对象，如果没有就去父类中找
父类中的方法调用时无法去子类找
# 父类（基类）
class Base:
def f1(self):
pass
# 子类（派生类）
class Foo(Base):
def f2(self):
pass
# 创建了一个子类的对象
obj = Foo()
# 执行对象.方法时，优先在自己的类中找，如果没有就去父类中找
obj.f2()
obj.f1()
# 创建一个父类对象
man = Base()
# 父类执行对象.方法时，只能在自己的类中找，不能去子类中找
man.f1()
man.f2() #执行这个时会报错，因为父类不能去子类找
问题：什么时候才能用到继承？
继承练习题：
# 示例一：
class Base:
def f1(self):
print(‘base.f1‘)
class Foo(Base):
def f2(self):
print(‘Foo.f2‘)
obj = Foo()
obj.f1() #base.f1
obj.f2() #Foo.f2
# 示例二：
class Base:
def f1(self):
print(‘base.f1‘)
class Foo(Base):
def f2(self):
self.f1()
print(‘Foo.f2‘)
obj = Foo()
obj.f2() #‘base.f1‘,‘Foo.f2‘
# 示例三：
class Base:
def f1(self):
print(‘base.f1‘)
class Foo(Base):
def f2(self):
self.f1()
print(‘Foo.f2‘)
def f1(self):
print(‘Foo.f1‘)
obj = Foo()
obj.f2() #‘Foo.f1‘,‘Foo.f2‘
# 示例四：
class Base:
def f1(self):
self.f2()
print(‘base.f1‘)
def f2(self):
print(‘base.f2‘)
class Foo(Base):
def f2(self):
print(‘foo.f2‘)
obj = Foo()
obj.f1() #‘foo.f2‘,‘base.f1‘
多继承关系，从左往右找
多继承是python的特性，其他语言很少有(JAVA / PHP都没有多继承关系)
def func(arg):
v = arg[-1] #此函数中arg可以传入任何值，但调用时只有str / list / dict / tuple / set这些有下标位
print(v)
面试题：什么是鸭子模型
对于一个函数而言，python对于参数的类型不会限制，那么传入参数时就可以是各种类型，在函数中如果有例如：arg.send方法，那么就是对于传入类型的一个限制（类型必须有send方法）
这就是鸭子模型，类似于上述的函数我们认为只要能呱呱叫的就是鸭子（只要有send方法，就是我们想要的类型）
1.面向对象的三大特性：封装 / 继承 / 多态
封装
# 把同一类的方法封装进一个类中
class File:
def read(self):
pass
def write(self):
pass
# 把一些数据封禁到对象中，方便以后获取
class Person:
def __init__(self.name,age):
self.name = name
self.age = age
P = Person(‘yanan‘,22)
继承
class Base:
pass
class Foo(Base):
pass
多态
# 鸭子模型
def func(arg): # 多种类型可以传参，很多事物
arg.send() # 必须具有send方法，呱呱叫
2.格式和关键词
class 类：
def __init__(self,x):
self.x = x
def 方法(self,name):
print(self.x,name)
# 实例化一个类的对象
v1 = 类(666) #类加括号，自动执行其中__init__方法，并传参进去666
v1.方法(‘yanan‘)
三个词：
3.什么时候用面向对象？
python笔记(17)--初识面向对象和三大特性（封装/继承/多态）
原文：https://www.cnblogs.com/lynlearnde/p/12912249.html