python面向对象

青旅半醒 2022-02-15 00:49 412阅读 0赞
  1. import json
  2. data={'usename':['李华','张思'],'sex':'male','age':15}
  3. json_dic2=json.dumps(data,sortt_key=True,indent=2,separators=(',',':'),ensure_ascii=False)
  4. import osos.makdirs('glance/api')
  5. import osos.makdirs('glance/cmd')
  6. import osos.makdirs('glance/db')
  7. l=[]
  8. l.apend(open('glance/_init_.py','w'))
  9. l.apend(open('glance/api/_init_.py','w'))
  10. l.apend(open('glance/api/policy.py','w'))
  11. l.apend(open('glance/api/versios.py','w'))
  12. l.apend(open('glance/cmd/_init_.py','w'))
  13. l.apend(open('glance/cmd/manage.py','w'))
  14. l.apend(open('glance/db/models.py','w'))
  15. map(lambda f:f.close,l)
  16. import policy
  17. import glance
  18. #文件夹 解决一类问题的模块放在同一个文件夹里 包
  19. import glance.api.policy as policy
  20. policy.get()
  21. from glance.api import policy#import后面不能带点
  22. policy.get()
  23. import sys
  24. sys.path.insert(0,'C:\\Adiminster\\PycharmProjects\\s9\\day21\\dir')
  25. print(sys.path)
  26. from glance.api import policy
  27. policy.get()
  28. #精确到方法
  29. from glance.api.policy import get
  30. get()
  31. from .. import glance
  32. #相对路径 可以随意移动包 只要能找到包的位置,就可以使用包里的模块 包里的模块如果想使用其他模块的内容只能使用相对路径,使用了相对路径就不能在包内直接执行了
  33. from .api import *
  34. from .cmd import *
  35. #直接文件作为模块导入 相对路径 只能在外部使用
  36. #项目名称下的Bin文件 列目录下要写个开始文件start.py
  37. from core import core
  38. if __name__=='__main__':
  39. core.main()
  40. core文件下当所有的.py文件main shopping() pay()
  41. import os
  42. import sys
  43. print(os.payh.dirname(os.getcwd()))
  44. sys.path.append(os.payh.dirname(os.getcwd()))
  45. from core import core
  46. if __name__=='__main__':
  47. core.main()#固定格式 所有基于文件夹导入
  48. userInfo="lujing"
  49. # db里面方登陆认证的userInfo文件 alex_json egon_json
  50. # lib里面放自己写的包货哦这模块
  51. # log执行程序过程的执行过程记录
  52. #异常处理
  53. #逻辑错误 不包含 语法错误
  54. try:#我们需要处理的代码
  55. ret=int(input('number>>>'))
  56. print(ret*'*')
  57. except ValueError:#后面跟一个错误类型 当代码发生错误且错误类型符合的时候 就会执行except中的代码 except可以是多分支的
  58. print('您输入的内容有误,请重新输入')
  59. except Exception:
  60. print('nicuole,laotie')
  61. else:
  62. print('______没有异常的时候执行else中的代码______')
  63. finally:
  64. print('*&***8')
  65. f.close()
  66. def func():
  67. try:
  68. print('dakaiyigewenjian')
  69. for line in f:
  70. int(line)
  71. except
  72. #处理所有错误类型的:Exception
  73. #有了万能的处理机制仍然需要把能预测到的问题单独处理
  74. #单独处理的所有内容都应该写在万能异常之前
  75. #else:没有异常的时候执行else中的代码
  76. #finally:不管代码是否异常都执行
  77. #finall和return相遇了依然会执行
  78. #函数里做异常处理用用 不管是否异常做收尾工作
  79. def func():
  80. try:
  81. f=open('file','w')
  82. return True
  83. except:
  84. return False
  85. finally:
  86. print('执行了finally')
  87. f.close()
  88. print(func())
  89. #人狗大战
  90. def Person(name,blood,aggr,sex):
  91. person={
  92. 'name':name,
  93. 'blood':blood,
  94. 'aggr':aggr,
  95. 'sex':sex
  96. }
  97. return person
  98. def Dog(name,blood,aggr,kind):
  99. dog={
  100. 'name':name,
  101. 'blood':blood,
  102. 'aggr':aggr,
  103. 'kind':kind
  104. }
  105. return dog
  106. #人的技能 打
  107. def attack(person,dog):
  108. dog['blood']-=person['aggr']
  109. print('%被打了,掉了%的血'%(dog['name'],person['aggr']))
  110. #狗的技能 咬
  111. def bite(dog,person):
  112. person['blood']-=dog['aggr']
  113. print('%被打了,掉了%的血' % ( person['aggr'],dog['name']))
  114. alex=Person('狗剩而',100,1,'不详')
  115. nezha=Person('娜扎',200,2,'bux')
  116. jin=Dog('jinlaobam',1000,100,'teddy')
  117. #函数定义了一类事物 直到调用了函数,赋值之后才有了真实的对象
  118. bite(jin,alex)
  119. def Person(name,blood,aggr,sex):
  120. # 人的技能 打
  121. def attack(person, dog):
  122. dog['blood'] -= person['aggr']
  123. print('%被打了,掉了%的血' % (dog['name'], person['aggr']))
  124. person={
  125. 'name':name,
  126. 'blood':blood,
  127. 'aggr':aggr,
  128. 'sex':sex,
  129. 'attack':attack #函数名 攻击技能
  130. }
  131. return person
  132. # def Dog(name,blood,aggr,kind):
  133. # # 狗的技能 咬
  134. # def bite(dog, person):
  135. # person['blood'] -= dog['aggr']
  136. # print('%被打了,掉了%的血' % (person['aggr'], dog['name']))
  137. # dog={
  138. # 'name':name,
  139. # 'blood':blood,
  140. # 'aggr':aggr,
  141. # 'kind':kind,
  142. # 'bite':bite
  143. # }
  144. # return dog
  145. def Person(name,blood,aggr,sex):
  146. person={
  147. 'name':name,
  148. 'blood':blood,
  149. 'aggr':aggr,
  150. 'sex':sex
  151. }
  152. # 人的技能 打
  153. def attack(person, dog):
  154. dog['blood'] -= person['aggr']
  155. print('%被打了,掉了%的血' % (dog['name'], person['aggr']))
  156. person['attack']=attack
  157. return person
  158. def Dog(name,blood,aggr,kind):#闭包
  159. dog={#1字典
  160. 'name':name,
  161. 'blood':blood,
  162. 'aggr':aggr,
  163. 'kind':kind
  164. }
  165. # 狗的技能 咬
  166. def bite(dog, person):#2函数
  167. person['blood'] -= dog['aggr']
  168. print('%被打了,掉了%的血' % (person['aggr'], dog['name']))
  169. dog['bite']=bite#3往字典里写入函数
  170. return dog
  171. jin['bite'](alex)
  172. alex['attack'](jin)
  173. #面向对象编程
  174. #所谓的模子 就是 类 抽象的 能知道有什么属性 有什么技能 但不能知道属性的具体值
  175. #对象 有具体的值 ,属性和技能都是根据类规范的
  176. #自定义类
  177. class 类名:
  178. 属性='a'
  179. 类名.属性
  180. 类名的作用 就是操作属性 查看属性
  181. class Person:
  182. country='china'#类属性 静态属性 创造了一个只要是这个类一定有的属性
  183. def __init__(self,*args):#初始化方法 self是对象 必须穿的参数 内置的双下划线init方法 只要一调用这个类就是调用这个方法 self相当于一个空字典
  184. self.name=args[0]
  185. self.hp=args[1]
  186. self.aggr=args[2]
  187. self.sex=args[3]
  188. print(args)
  189. def walk(self,n):#方法,一般情况下必须传self参数,且写在第一个
  190. # 后面还可以传其它参数
  191. print('%走了邹走,走了%s步'%(self,name,n))
  192. print(Person.country)#类名 可以查看类中的属性,不需要实例化就可以查看
  193. #类名可以实例化方法
  194. alex=Person('狗狗',100,1,'不详')#返回值alex是个对象
  195. print(alex.name)
  196. alex.walk(5)
  197. print(Person.__dict__)
  198. print(Person.__dict__['country'])
  199. print(alex.__dict__)
  200. print(alex.__dict__['name'])
  201. alex.name='baby'
  202. alex.__dict__['name']='baby'
  203. alex.age=83
  204. print(alex.__dict__)
  205. print(alex.name)
  206. #对象=类名()
  207. #过程:
  208. #类名()首先会创造一个对象
  209. #调用init方法 类名括号里的参数会被这里接收
  210. #执行init方法
  211. #返回self
  212. #对象做的事 :查看属性值 调用方法
  213. #__dict__对于对象的增删改查操作可以通过字典的语法进行
  214. #类名做的事: 实例化 调用方法只不过自己传递self参数
  215. # 调用类中的属性:调用静态属性
  216. class Dog:
  217. def __init__(self,name,blood,aggr,kind):
  218. self.name=name
  219. self.hp=blood
  220. self.aggr=aggr
  221. self.kind=kind
  222. # 狗的技能 咬
  223. def bite(self, person):#2函数
  224. #狗咬人,人掉血
  225. person.blood-=self.aggr
  226. class Person:
  227. def __init__(self,name,blood,aggr,sex):
  228. self.name=name
  229. self.hp=blood
  230. self.aggr=aggr
  231. self.sex=sex
  232. def attack(self):
  233. pass
  234. alex=Person('狗剩而',100,1,'不详')
  235. nezha=Person('娜扎',200,2,'bux')
  236. jin=Dog('jinlaobam',1000,100,'teddy')
  237. jin.bite(alex)
  238. print(alex.blood)
  239. class Person:
  240. def __init__(self,name,age,sex):
  241. self.name=name
  242. self.age=age
  243. self.sex=sex
  244. def shangshan(self):
  245. print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
  246. def drive(self):
  247. print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.sex))
  248. def favor(self):
  249. print('%s,%s岁,%s,最爱保时捷'%(self.name,self.age,self.sex))
  250. ming=Person('小明','10','男')
  251. ming.shangshan()
  252. ming.drive()
  253. ming.favor()
  254. class Circle:
  255. def __init__(self,r):
  256. self.r=r
  257. def area(self):
  258. return pi*(self.r**2)
  259. def perimeter(self):
  260. return 2*pi*self.r
  261. c1=Circle(5)
  262. c1.area()
  263. c1.perimeter()
  264. print(c1.area(),c1.perimeter())

发表评论

表情:
评论列表 (有 0 条评论,412人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Python面向对象

    Python 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对

    相关 Python 面向对象

    一、面向对象技术简介 类(Class): 用来描述具有相同的属性(变量)和方法(函数)的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的

    相关 python面向对象

    我们总是说python是一门面向对象的编程语言,那么,怎么来理解面向对象呢? 首先,要解决这个问题就要从根源出发,理解面向对象的定义。面向对象编程——Object Orien

    相关 Python面向对象

    Python面向对象 每次默认调用的方法是new,程序先调new再掉init init可以完成参数赋值等一些基本的初始化工作 init和new的参数要保持一致 创

    相关 python面向对象

    面向对象 面向对象概念 面向对象 是一种变成思想,是对现实世界中的事物进行抽象的方式。应用到代码编程设计中,是一种建立现实世界事物模型的方式。 面向对象和面向过程区别 面...