什么是模块？什么是包
sys.path默认会添加一个当前执行的文件所在的目录
模块不能被重复导入，不能循环引用
from...import
import
只有import后面的名字会出现在全局命名空间里
__name__
直接执行一个文件的时候，打印的是这个文件里的变量名__name__
都是字符串__main__
引用一个模块，这个模块里的变量名__name__
都是模块名
包
从包中导入模块
from import 精确到模块
import 文件夹...模块 精确到模块
导入包 相当于执行了这个包的__init__文件
如果需要在导入包之后使用模块中的内容，需要自己在__init__文件中做一些导入操作
导入有两种方式
绝对导入 如果被导入的包和文件相对位置改变了，绝对导入的路径会失效
相对导入 用到了相对导入的文件不能直接执行
面向对象
人狗大战
角色： 人 狗
人：
名字
性别
血量 hp
攻击力 ad
狗
名字
品种
血量
攻击力
def Person(name,sex,hp,ad):
创造了一个模子
约束了一个人必须拥有的属性
规范了这些属性的名字
简化了用户的操作
person={
'name':name,
'sex':sex,
'hp':hp,
'ad':ad
}
def attack(dog):
狗掉血，是人的攻击力
print('%s攻击了%s' % (person['name'],dog['name']))
dog['hp']-=person['ad']
print('%s掉了%s 点血，%s剩余血量%s' % (dog['name'],person['ad'],dog['name'],dog['hp']))
person['attack']=attack
return person
def Dog(name,kind,hp,ad):
dog={
'name':name,
'kind':kind,
'hp':hp,
'ad':ad
}
def bite(person):
print('%s咬了%s' % (dog['name'],person['name']))
person['hp']-=dog['ad']
print('%s掉了%s 点血，%s剩余血量%s' % (person['name'],dog['ad'],person['name'],person['hp']))
dog['bite']=bite #d2 将bite 赋值给dog['bite']
return dog # d3 将dog 返回给函数的调用者 taibai= Dog('哮天犬','teddy',100,50)
alex=Person('alex',None,10,1)
egon=Person('egon',None,20,2)
taibai=Dog('哮天犬','teddy',100,50) #d1 调用def Dog(name,kind,hp,ad): #d4 taibai =dog
alex['attack'](taibai)
taibai['bite'](alex) #d5 taibai['bite'](alex)=bite(alex)
面向对象的思路
不着急直接去计算/操作代码获取结果
从一个大问题中，到要描述的角色
将角色的属性和行为抽象出来
形成一个模子
后期用到角色的时候，都围绕这个模子来操作
类 一类抽象的事物，是描述一类事物有哪些的属性或者行为，但是不具体---模子
实例=对象 就是一个依托于类的规范存在的，被赋予了具体属性的实际存在的物体
实例化 由一个类产生一个对象/实例的过程
桌子 类
实例/对象
创造一个函数 用 def
创造一个类 用 class
class Person :
Country='China' #静态属性
def __init__(self,name,sex,hp,ad):
print('self--->',self)#self---> <__main__.Person object at 0x0000021153B5AE48>
def func(self):
print('执行了func函数')
obj=Person('alex',None,10,1) #对象=类名()
print('obj-->',obj)#obj--> <__main__.Person object at 0x0000021153B5AE48> self 和obj公用一个内存空间
Person 是一个类名
Person 中可以放两个东西：
静态属性 变量
动态属性(方法) 函数，自带一个叫做self的形参
类名可以做两件事情
查看静态属性和动态属性
print(Person.Country) #变量的值
print(Person.func) #打印的是函数的地址
Person.func(0) #Person调用方法：self 也是一个需要传的参数，Person.func(0)调用了func函数
print(Person.__dict__)#将Person类中的变量用字典的方法打印出来
创造一个对象object 对象=类名()
首先要创造一个对象
会自动触发__init__,将创造出来的对象的地址传给self
执行init中的代码
将self指向的地址在返回给调用者
面向对象思路写人狗大战
class Person:
def __init__(self,name,sex,hp,ad):
self.user=name
self.sex=sex
self.hp=hp
self.ad=ad
def attack(self,dog):
print('%s攻击了%s' % (self.user,dog.user))
dog.hp-=self.ad
print('%s掉了%s血，当前血量为%s' % (dog.user,self.ad,dog.hp))
class Dog:
def __init__(self,name,kind,hp,ad):
self.user=name
self.kind=kind
self.hp=hp
self.ad=ad
def bite(self,person):
print('%s攻击了%s' % (self.user,person.user))
person.hp-=self.ad
if person.hp>0:
print('%s掉了%s血，当前血量为%s' % (person.user,self.ad,person.hp))
else:
print('%s血量为0，%s胜利，gime over'% (person.user,self.user))
alex=Person('alex',None,10,1) #实例化
egon=Person('alex',None,20,2) #实例化
taibai=Dog('哮天犬','teddy',100,20) #实例化
alex.attack(taibai) #<==>Person.attack(alex,taibai)
taibai.bite(alex) #<==>Dog.bite(taibai,alex)
Person Dog 类
alex egon taibai 对象 实例
对象名可以调用静态属性
对象名可以调用方法
class Person:
Country='China'
def __init__(self,name):
self.name=name
def attack(self):
print('attack')
类
静态属性
动态属性 ： 特殊的__init__方法，attack 方法
对象
对象属性 name
class Person:
Country='China'
def __init__(self,name):
self.name=name
alex=Person('alex')
egon=Person('egon')
alex.Country='印度' #往alex的对象内存中存了一个印度
print(alex.Country) #印度
print(egon.Country) #China
print(Person.Country) #China
class Person:
Country=['China']
def __init__(self,name):
self.name=name
alex=Person('alex')
egon=Person('egon')
alex.Country[0]='印度'#将默认参数Country=['China']改为Country=['印度']
print(Person.Country) #['印度']
print(egon.Country) #['印度']
首先，静态变量之所以出现：所有的对象都共享的值
调整静态变量的值，直接用类名去调整是最准确的
对象对一个静态变量重新赋值的过程
实际上是在对象所在的内存空间中添加了一个同名属性而已
方法并没有真正存储在对象的空间中
之所以能找到，是因为每个对象在创建之初都有以一个执行类的指针
类名
查看,修改静态属性
实例化
对象名
查看对象的属性
调用方法
对象使用名字的特点: 先用自己的,自己没有的话用类的
