python面向对象

import json
data={'usename':['李华','张思'],'sex':'male','age':15}
json_dic2=json.dumps(data,sortt_key=True,indent=2,separators=(',',':'),ensure_ascii=False)

import osos.makdirs('glance/api')
import osos.makdirs('glance/cmd')
import osos.makdirs('glance/db')
l=[]
l.apend(open('glance/_init_.py','w'))
l.apend(open('glance/api/_init_.py','w'))
l.apend(open('glance/api/policy.py','w'))
l.apend(open('glance/api/versios.py','w'))
l.apend(open('glance/cmd/_init_.py','w'))
l.apend(open('glance/cmd/manage.py','w'))
l.apend(open('glance/db/models.py','w'))
map(lambda f:f.close,l)
import policy
import glance

#文件夹 解决一类问题的模块放在同一个文件夹里 包
import glance.api.policy as policy
policy.get()
from glance.api import policy#import后面不能带点
policy.get()
import sys
sys.path.insert(0,'C:\\Adiminster\\PycharmProjects\\s9\\day21\\dir')
print(sys.path)
from glance.api import policy
policy.get()
#精确到方法
from glance.api.policy import get
get()
from  .. import glance
#相对路径 可以随意移动包 只要能找到包的位置，就可以使用包里的模块 包里的模块如果想使用其他模块的内容只能使用相对路径，使用了相对路径就不能在包内直接执行了
from .api import *
from .cmd import *
#直接文件作为模块导入  相对路径 只能在外部使用
#项目名称下的Bin文件 列目录下要写个开始文件start.py
from core import core

if __name__=='__main__':
    core.main()

core文件下当所有的.py文件main shopping() pay()
import os
import sys
print(os.payh.dirname(os.getcwd()))
sys.path.append(os.payh.dirname(os.getcwd()))
from core import core
if __name__=='__main__':
    core.main()#固定格式 所有基于文件夹导入
userInfo="lujing"
# db里面方登陆认证的userInfo文件  alex_json  egon_json
# lib里面放自己写的包货哦这模块
# log执行程序过程的执行过程记录
#异常处理
#逻辑错误  不包含 语法错误
try:#我们需要处理的代码
    ret=int(input('number>>>'))
    print(ret*'*')
except ValueError:#后面跟一个错误类型 当代码发生错误且错误类型符合的时候 就会执行except中的代码 except可以是多分支的
    print('您输入的内容有误，请重新输入')
except Exception:
    print('nicuole,laotie')
else:
    print('______没有异常的时候执行else中的代码______')
finally:
    print('*&***8')
    f.close()
def func():
    try:
        print('dakaiyigewenjian')
        for line in f:
            int(line)
    except
#处理所有错误类型的：Exception
 #有了万能的处理机制仍然需要把能预测到的问题单独处理
 #单独处理的所有内容都应该写在万能异常之前
 #else:没有异常的时候执行else中的代码
 #finally:不管代码是否异常都执行
    #finall和return相遇了依然会执行
    #函数里做异常处理用用 不管是否异常做收尾工作
 def func():
     try:
         f=open('file','w')
         return True
     except:
         return False
     finally:
         print('执行了finally')
         f.close()
print(func())

#人狗大战
def Person(name,blood,aggr,sex):
    person={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person

def Dog(name,blood,aggr,kind):
    dog={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog
#人的技能 打
def attack(person,dog):
    dog['blood']-=person['aggr']
    print('%被打了，掉了%的血'%(dog['name'],person['aggr']))

#狗的技能  咬
def bite(dog,person):
    person['blood']-=dog['aggr']
    print('%被打了，掉了%的血' % ( person['aggr'],dog['name']))


alex=Person('狗剩而',100,1,'不详')
nezha=Person('娜扎',200,2,'bux')
jin=Dog('jinlaobam',1000,100,'teddy')
#函数定义了一类事物 直到调用了函数，赋值之后才有了真实的对象
bite(jin,alex)
def Person(name,blood,aggr,sex):
    # 人的技能 打
    def attack(person, dog):
        dog['blood'] -= person['aggr']
        print('%被打了，掉了%的血' % (dog['name'], person['aggr']))
    person={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'sex':sex,
        'attack':attack #函数名 攻击技能
    }
    return person
# def Dog(name,blood,aggr,kind):
#     # 狗的技能  咬
#     def bite(dog, person):
#         person['blood'] -= dog['aggr']
#         print('%被打了，掉了%的血' % (person['aggr'], dog['name']))
#     dog={
#         'name':name,
#         'blood':blood,
#         'aggr':aggr,
#         'kind':kind,
#         'bite':bite
#     }
#     return dog
def Person(name,blood,aggr,sex):
    person={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'sex':sex
    }

    # 人的技能 打
    def attack(person, dog):
        dog['blood'] -= person['aggr']
        print('%被打了，掉了%的血' % (dog['name'], person['aggr']))
        person['attack']=attack
    return person
def Dog(name,blood,aggr,kind):#闭包
    dog={#1字典
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }

    # 狗的技能  咬
    def bite(dog, person):#2函数
        person['blood'] -= dog['aggr']
        print('%被打了，掉了%的血' % (person['aggr'], dog['name']))
    dog['bite']=bite#3往字典里写入函数
    return dog
jin['bite'](alex)
alex['attack'](jin)
#面向对象编程
#所谓的模子 就是 类 抽象的 能知道有什么属性 有什么技能 但不能知道属性的具体值
#对象 有具体的值 ，属性和技能都是根据类规范的
#自定义类
class 类名：
   属性='a'
类名.属性
类名的作用 就是操作属性 查看属性
class Person:
    country='china'#类属性 静态属性 创造了一个只要是这个类一定有的属性
    def __init__(self,*args):#初始化方法 self是对象 必须穿的参数 内置的双下划线init方法 只要一调用这个类就是调用这个方法 self相当于一个空字典
       self.name=args[0]
       self.hp=args[1]
       self.aggr=args[2]
       self.sex=args[3]
       print(args)

    def walk(self,n):#方法，一般情况下必须传self参数，且写在第一个
                     # 后面还可以传其它参数
        print('%走了邹走，走了%s步'%(self,name,n))
print(Person.country)#类名 可以查看类中的属性，不需要实例化就可以查看
#类名可以实例化方法
alex=Person('狗狗',100,1,'不详')#返回值alex是个对象
print(alex.name)
alex.walk(5)
print(Person.__dict__)
print(Person.__dict__['country'])
print(alex.__dict__)
print(alex.__dict__['name'])
alex.name='baby'
alex.__dict__['name']='baby'
alex.age=83
print(alex.__dict__)
print(alex.name)
#对象=类名（）
#过程：
   #类名（）首先会创造一个对象
   #调用init方法 类名括号里的参数会被这里接收
   #执行init方法
   #返回self
#对象做的事 ：查看属性值  调用方法
#__dict__对于对象的增删改查操作可以通过字典的语法进行
#类名做的事： 实例化  调用方法只不过自己传递self参数
# 调用类中的属性：调用静态属性
class Dog:
    def __init__(self,name,blood,aggr,kind):
       self.name=name
       self.hp=blood
       self.aggr=aggr
       self.kind=kind


    # 狗的技能  咬
    def bite(self, person):#2函数
       #狗咬人，人掉血
       person.blood-=self.aggr


class Person:
    def __init__(self,name,blood,aggr,sex):
       self.name=name
       self.hp=blood
       self.aggr=aggr
       self.sex=sex

    def attack(self):
        pass


alex=Person('狗剩而',100,1,'不详')
nezha=Person('娜扎',200,2,'bux')
jin=Dog('jinlaobam',1000,100,'teddy')
jin.bite(alex)
print(alex.blood)
class Person:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def shangshan(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
    def drive(self):
        print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.sex))
    def favor(self):
        print('%s,%s岁,%s,最爱保时捷'%(self.name,self.age,self.sex))

ming=Person('小明','10','男')
ming.shangshan()
ming.drive()
ming.favor()

class Circle:
    def __init__(self,r):
        self.r=r
    def area(self):
        return pi*(self.r**2)
    def perimeter(self):
        return 2*pi*self.r

c1=Circle(5)
c1.area()
c1.perimeter()
print(c1.area(),c1.perimeter())