python学习 day18
面向对象初识
### 面向过程:
# 例1:
s1 = '字符zifu' count = 0 for i in s1: count += 1 # 例2: l1 = [1, 2, 3, 4] count = 0 for j in l1: count += 1
### 函数
def func(s): count = 0 for i in s: count += 1 return count
### 函数
1 # auth: 2 def login(): 3 pass 4 def regisgter(): 5 pass 6 7 # account: 8 def func1(): 9 pass 10 def func2(): 11 pass 12 13 # shoppingcar: 14 def shopping(username,money): 15 pass 16 def check_paidgoods(username,money): 17 pass 18 def check_unpaidgoods(username,money): 19 pass 20 def save(username,money): 21 pass
### 面向对象:面向对象是一类相似功能函数的集合体。
1,第一个优点: 更清晰化,更规范化。
2,面向对象,必须要站在上帝的角度,去考虑问题。类,其实就是一个公共模板;对象,就从具体的模板实例化出来。
# auto class LoginHandler: def login(self): pass def regisgter(self): pass # account class Account: def func1(self): pass def func2(self): pass # 购物车 class ShoppingCar: def shopping(username,money): pass def check_paidgoods(username,money): pass def check_unpaidgoods(username,money): pass def save(username,money): pass
# 面向对象的结构 ''' class 类名(): 变量 函数(方法) '''
例:
class Human: """ 此类主要是构建人类 """ mind = '会思想' # 静态属性 属性 静态变量 静态字段 language = '使用文字' # dic = {} # l1 = []
def __init__(self,name,sex,age,hobby): # 方法 函数 动态属性 # print(self,name,sex,age,hobby) # print(666) self.n = name self.s = sex self.a = age self.h = hobby def work(self): print(self) print('人类会工作') def tools(self): # self.color = 'blue' print('人类都会使用工具')
### 类名
1)类名操作类中的静态属性
第一种:# 查,“ 类名.__dict__ ”(Human.__dict__)查看类中所有内容时使用。
print(Human.__dict__) # 查看类中所有内容 ''' {'__module__': '__main__', '__doc__': '\n 此类主要是构建人类\n ', 'mind': '有思想', 'language': '实用语言',
'__init__': <function Human.__init__ at 0x0000024F6ABCD9D8>, 'work': <function Human.work at 0x0000024F6ABCDA60>,
'tools': <function Human.tools at 0x0000024F6ABCDAE8>, '__dict__': <attribute '__dict__' of 'Human' objects>,
'__weakref__': <attribute '__weakref__' of 'Human' objects>} ''' print(Human.__dict__['mind']) # 查看 静态变量 mind 中的内容 # 有思想 Human.__dict__['mind'] = '无脑' # 无法对类中内容进行更改,否则报错 print(Human.__dict__)
第二种:万能的 “ . ” 可以增删改查类中的静态属性。
Human.walk = '直立行走' ### 增 # 增加了 walk=‘直立行走’ 的属性 print(Human.walk) del Human.mind ### 删 # 将 mind = ‘有思想’ 属性删除
Human.mind = '思维zhang' ### 改 print(Human.mind) # mind = ‘有思想’ 改为了 mind = ‘思维zhang’ print(Human.mind) ### 查 # mind = ‘思维zhang’
2)类名操作类中的方法(除去特殊方法:静态方法,类方法之外,一般不会通过类名执行类中的方法)。
方法: “ 类名.方法名(参数) ” <---> Human.work(1231)
Human.work(1231) # 1222 # 人类会工作 Human.tools(111)
# 人类都会使用工具
### 对象
---- “ 类名()” 这是一个实例化过程,就会产生一个对象。
例:obj = Human() 产生了一个实例化对象 obj
obj = Human # 实例化一个过程
实例化一个对象需要经历的3件事情(即 实例化一个对象的过程):
1)产生一个空的对象空间。
print(obj) # <__main__.Human object at 0x0000019BC6A0F828>
2)自动执行类中的 __init__ 方法并且将这个空的对象空间传给 self 。
print(obj)
3)在 __init__ 中通过self给这个空间添加属性。
obj = Human('小胖','男',20,'女') # 实例化对象
# 对象 操作 对象空间 的属性
1)" obj.__dict__ " 查询对象中所有的属性
print(obj.__dict__) # {'n': '小胖', 's': '男', 'a': 20, 'h': '女'}
2)通过万能的 " . " 的方式操作对象中的单个属性。
obj.job = 'IT' # 增 del obj.n # 删 obj.s = '女' # 改 print(obj.s) print(obj.__dict__) # 查
3)对象可以查询类中的属性。
print(obj.mind) # 查询 mind = “会思想” print(obj.language) # 查询 language = “使用语言”
print(obj.a) # 查询 a = 20
obj.a = 666 print(obj.a) # 改 a = 666
4)对象可以执行类中的方法。
对象执行类中的所有方法(除去3个特殊方法)Python解释器都会将对象空间主动传给方法的第一个参数self。
print(obj) # <__main__.Human object at 0x00000284476FBCF8> obj.work() # <__main__.Human object at 0x00000284476FBCF8> # 人类会工作
self:类中方法的第一个形参 约定俗成 写 self 便于统一,self 接受的就是 对象空间。
1 class Human: 2 """ 3 此类主要是构建人类 4 """ 5 mind = '会思想' # 静态属性 属性 静态变量 静态字段 6 language = '使用文字' 7 # dic = {} 8 # l1 = [] 9 def __init__(self,name,sex,age,hobby): # 方法 函数 动态属性 10 # print(self,name,sex,age,hobby) 11 # print(666) 12 self.n = name 13 self.s = sex 14 self.a = age 15 self.h = hobby 16 17 def work(self): 18 print(self) 19 print('人类会工作') 20 21 def tools(self): 22 # self.color = 'blue' 23 print('人类会使用工具') 24 print('猩猩会使用工具') 25 print('猴子会使用工具')
obj = Human('小胖', '男', 20, '女') print(obj.__dict__) # {'n': '小胖', 's': '男', 'a': 20, 'h': '女'} obj.tools()
# 人类会使用工具
# 猩猩会使用工具
# 猴子会使用工具
print(obj.__dict__) # {'n': '小胖', 's': '男', 'a': 20, 'h': '女'}
self = [1,2,3] self.append(666) obj = self print(obj, self) # [1, 2, 3, 666] [1, 2, 3, 666] self.append(777) obj.append(888) print(obj, self) # [1, 2, 3, 666, 777, 888] [1, 2, 3, 666, 777, 888]
# 多个对象
# 多个对象 # xiaopang = Human('小胖','男',20,'美女') # xiangye = Human('相爷','男',18,'肥女') # print(xiangye,xiaopang) # print(xiaopang.__dict__) # print(xiangye.__dict__)
内容总结:
# 内容回顾: 面向对象:将一些相似功能的函数集合到一起。 类:具有相同属性和功能的一类事物。 对象:类的具体体现。 1.将一些相似功能的函数集合到一起 2.站在上帝的角度考虑问题,类就是一个公共模板。 类的结构: class Person: mind = "有思想" # 静态属性 静态字段 def __init__(self, name, age) self.n = name self.a = age def work(self): # 动态属性 方法 print('能工作') 类名: 1,Person.mind # 万能的‘ . ’ 2,Person.__dict__ 查询类中所有内容 3,Person.work(111) # 不建议这样做 对象: Person() # 产生一个对象 obj = Person('barry', 20) 1)在内存中开辟一个空的对象空间 2)自动执行 __init__ 方法,先把对象空间传给self,后面参数依次传入 3)执行 __init__ 代码,将封装好属性的对象空间返回给了obj 1,查询对象的属性: obj.__dict__ 2,查询对象单独的属性: obj.name 3,查询类中的属性: obj.mind 4,查询执行类中的方法: obj.work() Person.work(obj)