Day17笔记

# python基础
# 各种运算 赋值 比较 逻辑运算 数学运算 身份运算
# 编码 ascii gbk unicode utf-8
# 流程控制 ： 判断和循环
　　　　 if elif else
　　　　 while else
　　　　 for else
# 基础数据类型
　　　　 数字类型 bool int float complex
　　　　 序列类型 str list tuple
　　　　 散列类型 dict set
# 文件操作
　　　　r w a 字符
　　　　 rb wb ab 字节
　　　　 文件指针（光标）：seek,tell
　　　　 import os
　　　　 os.remove('')
　　　　 os.rename('old','new')
# 函数
　　自定义函数
　　　　 函数的定义
　　　　 函数的参数
　　　　 函数的返回值
　　　　 函数的调用
　　 作用域和命名空间 global nonlocal
　　 闭包和装饰器 ： 装饰器是闭包的应用
　　 内置函数
　　 匿名函数
　　 生成器函数 - 迭代器 生成器表达式 各种推导式
　　 递归函数 - 二分查找

----------------***********--------------------

1.面向对象

例子：

# 参加工作
# 游戏公司
# 人狗大战
# 角色 的属性固定下来
# 人 ：昵称、性别、血、攻击力
# 狗 ：名字、品种、血、攻击力

def Person(name,sex,hp,ad):
    # 人模子
    self = {'name': name, 'sex':sex, 'hp': hp, 'ad': ad}
    def attack(dog): # 闭包
        # 人攻击狗
        print('%s攻击%s' % (self['name'], dog['name']))
        # 狗掉血，狗的血量-人的攻击力
        dog['hp'] -= self['ad']
    self['attack'] = attack
    return self

def Dog(name,kind,hp,ad):
    # 狗模子
    self = {'name': name, 'kind':kind, 'hp': hp, 'ad': ad}
    def bite(person):
        print('%s咬了%s' % (self['name'], person['name']))
        # 人掉血，人的血量-狗的攻击力
        person['hp'] -= self['ad']
        if person['hp'] <= 0: print('game over,%s win' % self['name'])
    def bite2():pass
    self['bite'] = bite
    self['bite2'] = bite2
    return self

# 人 规范了属性的个数 简化了创造任务的代码
alex = Person('a_sb','不详',1,5)
boss_jin =Person('金老板','女',2,50)

# 狗
chen = Dog('旺财','teddy',50,20)
alex['attack'](chen)
print(chen['hp'])

# 面向对象编程
# 类的概念 ： 具有相同属性和技能的一类事物

# 对象 ： 就是对一个类的具体的描述

# 使用面向对象的好处：
　　 使得代码之间的角色关系更加明确
　　 增强了代码的可扩展性
　　 规范了对象的属性和技能
# 面向对象的特点：结局的不确定性

 

3.语法 

 

    class Person:

     静态变量 = 123

     role = 'person' # 静态属性

     def f1(self):     # 动态属性 方法（函数）  默认带一个参数self
         print(1234567)

# 查看静态变量的第一种方式
 print(Person.__dict__)   # 内置的双下方法
 print(Person.__dict__['静态变量'])
 
Person.__dict__['静态变量'] = 456  # 这样是无法更改的，会报错
 
print(Person.__dict__['静态变量'])

# 查看静态变量的第二种方式
 print(Person.静态变量)   # 123 值
 print(Person.role)
 
Person.静态变量 = 456  # 这样可以更改
print(Person.静态变量) 

del Person.静态变量
 print(Person.__dict__)

# 类名
    # 引用静态变量
        # 1.类名.__dict__['静态变量名'] 可以查看，但是不能删改
        # 2.类名.静态变量名 直接就可以访问,可以删改
                # 删除一个静态变量 del 类名.静态变量名
    # 引用动态变量
        # 1.类名.方法名  查看这个方法的内存地址
        # 1.类名.方法名(实参)  调用了这个方法，必须传一个实参，这个实参传给了self
    # 创造一个对象 - 实例化
        # 产生一个实例（对象）的过程
        # 对象 = 类名()
 alex = Person()   # 创造一个对象
# alex 是对象、实例
# Person是类
# 对象 = 类名()

class Person:
    role = 'person'   # 静态属性
    def __init__(self,name,sex,hp,ad):
        self.name = name     # 对象属性 属性
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self):
        print('%s发起了一次攻击'%self.name)

alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',20,50)

alex.attack()      # Person.attack(alex)
boss_jin.attack()  # Person.attack(boss_jin)



 alex = Person('a_sb','不详',1,5)
 alex.__dict__['name'] = 'alex'
 print(alex.name)
 alex.name = 'a_sb'
 print(alex.name)
 boss_jin = Person('金老板','女',20,50)
 print(boss_jin.name)

# 实例化的过程：
    # 1.创造一个实例,将会作为一个实际参数  # python
    # 2.自动触发一个__init__的方法，并且把实例以参数的形式传递给__init__方法中的self形参
    # 3.执行完__init__方法之后，会将self自动返回给alex
# __init__方法 ：初始化方法，给一个对象添加一些基础属性的方法，一般情况下是针对self的赋值
# 对象
    # 在类的内部 self是本类的一个对象
    # 在类的外部，每一个对象都对应着一个名字，这个对象指向一个对象的内存空间
    # 属性的调用：
        # 对象名.属性名               第一种调用方法
        # 对象名.__dict__['属性名']   第二种调用方法
    # 方法的调用 ：
        # 类名.方法名(对象名)  # 那么方法中的self参数就指向这个对象
        # 对象名.方法名()      # 这样写 相当于  方法中的self参数直接指向这个对象