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())
还没有评论,来说两句吧...