Python学习笔记2020-02-26

学习第13天
昨天回顾了Day01的内容,今天回顾一下Day02的内容吧

Day02

• 变量
• 数据类型
• 标识符和关键字
• 输出语句
• 输入语句

a = '你好世界'  # 字符串类型
b = 34  # int(整数)类型
c = 3.14  # float(浮点数)类型
c = True  # bool(布尔)类型
#列表类型
names = ['1','2','3']
#字典类型
person = {'name':'1','age':'18'}
#元组类型
nums = (1,8,9,2,3,0)
#集合
x = {9,'hello','hi','good',True}

#------------------标识符和关键字-----------------------
# 标识符：变量，模块名，函数名，类名
# 标识符的命名规则:数字，字母，下划线，数字不能开头
# 严格区分大小写
# 不能使用关键字
# 关键字：在python语言里，有特殊含义的单词，例如if/for/none...
# 命名要见名知意
# 小驼峰userNameAndPassword
# 大驼峰PersonModel
# 下划线user_name_and_password
# 在python里的变量，函数和模块名用下划线连接；python里的类名使用大驼峰命名法

# ----------------- 输出语句-----------------------------------------
# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
# sep 参数用来表示输出时，每个值之间使用哪种字符作为分割，默认使用空格作为分隔符
# end 当执行玩一个print语句以后，接下来要输出的字符，默认\n表示换行
print('hello','good','yes','hi',sep='+',end='------------------')
print('大家好，我是渣渣辉')

#--------------------输入语句------------------
# 使用一个变量来接收input的值
user = input("请输入您的用户名：")
pwd = input("请输入您的密码：")
print(user, pwd)

Day13

首先来一段练习

class Person(object):
    __count = 0

    def __new__(cls, *args, **kwargs):
        cls.__count += 1
        x = object.__new__(cls)  # 申请内存,创建一个对象,并设置类型是Person类
        return x

    def __init__(self, name, age):
        # Person.__count += 1
        self.name = name
        self.age = age

    @classmethod
    def get_count(cls):
        return cls.__count


# 每次创建对象,都会调用__new__和__init__方法
# 调用__new__方法,用来申请内存
# 如果不重写__new__方法,他会自动找object的__new__
# object的__new__方法,默认实现是申请了一段内存,创建一个对象
p1 = Person('张三', 18)
p2 = Person('张四', 19)
p3 = Person('张五', 17)
p4 = Person('张六', 20)
# print(p1, p2, p3, p4)

print(Person.get_count())

这个练习主要是为了计算申请了多少个新的内存
最后打印的print(Person.get_count())是申请内存的个数

今天学到的新东西有

1.面向对象的三大特性

封装,继承,多态
封装是什么?
简单来说就是对一个个的语句进行打包
比如下面的都是语句

    a = 23  # 赋值语句
    a += 3  # 算数运算符表达式
    print('hello')
    print('world')

封装以后↓

def test():
    a = 23  # 赋值语句
    a += 3  # 算数运算符表达式
    print('hello')
    print('world')

对于函数来说,封装以后就是一个类

class Person(object):
   type = '人类'

   def __init__(self):
       pass

   def eat(self):
       pass

2.继承

首先,我们先创建一个父类

# 继承:类和类之间人为手动的建立父子关系,父类的属性和方法,子类可以使用
class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name + '正在睡觉')

接着我们再创建一个子类

class Dog(Animal):
    # def __init__(self, name, age):
    #     self.name = name
    #     self.age = age
    #
    # def sleep(self):
    #     print(self.name + '正在睡觉')

    def bark(self):
        print(self.name + '正在叫')

现在我们创建一个实例对象

# 子类可以使用父类的方法
# Dog()调用 __new__ 方法,再调用 __init__ 方法
# Dog里没有 __new__ 方法 ,会查看父类是否重写了 __new__ 方法
# 父类里也没有重写__new__方法,查找父类的父类--object

# 调用__init__方法,找父类的__init__
# d1 = Dog()  报错
d1 = Dog('柯基', 5)
print(d1.name)  # 父类里定义的属性,子类可以直接使用
d1.sleep()  # 父类的方法子类实例对象可以直接调用
d1.bark()

如果定义两个子类,两个子类之间没有任何关系,不能互相使用方法和变量
注意:

# 如果两个不同的父类有同名的方法
# 遵循先到先得方法
# 那个在前先用那个,用完以后就停止

私有属性和子类的关系

class Animal(object):
    __money = 100
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '正在吃东西')

    def __test(self):
        print('我是Animal类的私有方法__test()')


class Person(Animal):
    def __demo(self):
        print('我是Person里的私有方法__demo()')
p = Person('张三', 18)
# 私有属性和方法子类不能继承
# 一般来说,自己类定义的私有属性可以通过 对象名._类名__方法/变量
p._Person__demo()
#可以使用父类进行调用
print(p._Animal__money)
#但是子类不能调用
print(p._Person__money)

子类可以重写父类的方法,且不会影响到父类

# 继承特点:如果一个类A继承自类B,由类A创建出来的实例对象都能直接使用类B里定义的方法
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name + '正在睡觉')


class Student(Person):
    def __init__(self, name, age, school):
        # self.name = name
        # self.age = age
        # 子类在父类实现的基础上,又添加了自己的新功能
        # 调用父类方法的两种方式
        # 1.父类名.__init__(self,参数列表)
        # Person.__init__(self, name, age)
        # 2.使用super直接调用父类的方法.
        super(Student, self).__init__(name, age)
        self.school = school

    def study(self):
        print(self.name + '正在学习')

    def sleep(self):
        print(self.name + '正在课间休息时睡觉')


s = Student('jerry', 20)  # 调用了父类的__init__方法
s.sleep()  # 调用了父类的sleep方法
print(Student.__mro__)  # method resolution order
# 1.子类的实现和父类的实现完全不一样,子类可以选择重写父类的方法
# 2.子类在父类的基础上又有更多的实现
s1 = Student('jame', 4, '春天花花幼儿园')

3.多态

以一个例子开头

class Dog():
    def work(self):
        print('狗正在工作')


class PoliceDog(Dog):
    def work(self):
        print('警犬正在攻击敌人')


class BlindDog(Dog):
    def work(self):
        print('导盲犬正在领路')


class DrugDog(Dog):
    def work(self):
        print('缉毒犬正在搜毒')


class PetDog(Dog):
    pass


class Person(object):
    def __init__(self, name):
        self.name = name
        self.dog = None

    def work_with_dog(self):
        if self.dog is not None and isinstance(self.dog, Dog):
            self.dog.work()


p = Person('张三')

pd = PoliceDog()
p.dog = pd
p.work_with_dog()

bd = BlindDog()
p.dog = bd
p.work_with_dog()

dd = DrugDog()
p.dog = dd
p.work_with_dog()

pet_dog = PetDog()
p.dog = pet_dog
p.work_with_dog()

首先,我们先定义父类Dog(object)和Person(object)
接着,定义子类PoliceDog(Dog) , BlindDog(Dog) , DrugDog(Dog) , PetDog(Dog)
实例化一个人p = Person('张三')
实例化四只pd = PoliceDog() , bd = BlindDog() , dd = DrugDog() , pet_dog = PetDog()
在Person类中定义一个方法,调用dog中的work()
当p.dog = 实例化后的狗成功以后
直接使用p.work_with_dog()就可以使用对应dog中的work()方法了

---

今天暂时到这吧,明天要跑14KM,明晚继续

2月27日

附上一张跑步以后的照片~ ↗(> _ <) ↗加油

IMG_5175(20200227-091911).JPG