2018年7月3日笔记

1.Python编程方式

面向过程：根据业务逻辑从上到下写代码
函数式：将某功能代码封装到函数中，日后便无需重复填写，仅调用函数即可
面对对象：对函数进行分类和封装，让开发"更好更快更强"。

2.面对对象概念

面对对象就不像面对过程那样按照功能划分模块了，它所关注的是软件系统有哪些参与者，把这些参与者称为对象，找出这些软件系统的参与者也就是对象之后，分析这些对象有哪些特征、哪些行为，以及对象之间的关系。所以说面对对象的开发核心是对象。

3.Python类与对象

3.1 什么是类
面对对象编程的2个非常重要的概念：类和对象
概念：类是用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实现。

3.2 什么是对象
万物皆对象，对象拥有自己的行为和特征。

3.3 类和对象的关系
类是对象的类型，对象是类的实例。类是抽象的概念，对象是一个你能够摸得着，够得到的实体。二者相辅相成，谁也离不开谁。

4. 类的声明和实例化

4.1 创建类
使用class语句来创建一个类，class之后为类的名称并以冒号结尾：

class ClassName:
    "类的帮助信息"
    class_suite

以上的ClassName由类成员、方法、数据属性组成。

示例：

class MyClass:
    "创建第一个类"
    name = "python"
    def funcA(self):
        return "Development"

4.2 实例化类
实例化类其他编程语言中一般用关键字new,但是在Python中没有这个关键字，类的实例化类似函数调用方式。
示例：

x = MyClass()

4.3 如何调用类的方法
可以使用点（.）来访问对象的属性。

class MyClass:
    "创建第一个类"
    name = "python"
    def funcA(self):
        return "Development"
        
#实例化类
a = MyCLass()
#用.的方法访问类的属性和方法
print(a.name) #访问属性
print(a.funcA()) #访问方法

4.4 构造函数

__init__()是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法，
方法的前面和后面都有两个下划线。这是为了避免Python默认方法和普通方法发生名称的冲突。
每当创建类的实例化对象的时候，__init__()方法会被默认被运行。
作用就是初始化已实例化的对象。

class MyClass:
    def __init__(self,name,age):
        self.name = name
        self.age = age
x = MyClass('xiaoming',20)
print(x.name,x.age)

上面一段代码的运行结果如下：

xiaoming 20

4.5 self
self代表类的实例，self在定义类的方法是必须的，虽然在调用时不必传入相应的参数。
类的方法和普通的函数只有一个特别的区别，他们必须有额外的第一个参数名称，按照惯例它的名字是self。self并不是python的关键字，你完全可以用其他单词取代他，只是按照惯例和标准的规定，推荐使用self。
示例：self.class则指向类。

class Test:
    def printClass(self):
        print(self)
        print(self.__class__)

x = Test()
x.printClass()

上面一段代码运行结果如下：

<__main__.Test object at 0x000001F21142C198>
<class '__main__.Test'>

小节：
（1）类就是一个模板，模板里可以包含多个参数，函数里可以实现一些功能
（2）对象则是根据模板创建的示例，通过实例对象可以执行类中的对象

5.类的属性和方法

5.1 操作类的属性
常见针对类的属性的一些方法：
1.可以使用实例化对象名+.来访问对象的属性
2.getattr(obj,name[,default]):
3.hasattr(obj,name)
4.setattr(obj,name,value)
注意：name需要加单引号，obj为实例化对象名称
示例：

class Test:
    a = 1
x = Test()
print(getattr(x,'a'))

上面一段代码的运行结果如下:

1

示例2

class People:
    def __init__(self,name,age,weight):
        self.name = name
        self.age = age
        self.__weight = weight

    def speak(self):
        print("%s 说：我今年 %d 岁" %(self.name,self.age))

x = People('小明',10,50)
x.speak()

上面一段代码的运行结果如下：

小明 说：我今年 10 岁

5.2 内置类属性

5.3 类的私有类型和私有方法
5.3.1 类的私有属性

__private_attrs:两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用self.__private_attrs。

5.3.2 类的方法
在类的内部，使用def的关键字可以为类定义为一个方法，与一般函数定义不同，类方法必须包含参数self,且第一个为参数
3.3.3 类的私有方法

__private_method:两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用self.__private_methods

练习

1.定义车类和人类

class People:
    def __init__(self,name,age,car):
        self.name = name
        self.age = age
        self.car = car

    def play(self):
        print("车来了，注意安全")

class Car:
    def __init__(self,brand,color,price):
        self.brand = brand
        self.color = color
        self.price = price

    def run(self):
        print("{}{}的汽车在飞驰,该车的价格为{}万".format(self.brand,self.color,self.price))

2.定义一个学生类

class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

    def get_course(self):
        return max(self.score)

s = Student('小明',20,[68,80,99])
print(s.get_name())
print(s.get_age())
print(s.get_course())

6.Python类的继承

类继承的概念：面对对象编程的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承的机制。继承可以完全理解为类之间的类型和子类型关系。在现实生活中，继承一般指的是子女继承父辈的财产。那么在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中可以描述为猫和狗都继承自动物。
子类继承父类示例：

class Animal():
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def eat(self):
        print("%s是一只%s,喜欢吃点心"%(self.name,self.sex))

class Dog(Animal):
    pass

class Cat(Animal):
    pass

dog = Dog("小黑","公狗")
dog.eat()
cat = Cat("小白","母猫")
cat.eat()

上面一段代码的运行结果如下：

小黑是一只公狗,喜欢吃点心
小白是一只母猫,喜欢吃点心

重写方法

class Animal():
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def eat(self):
        print("%s是一只%s,喜欢吃点心"%(self.name,self.sex))

class Dog(Animal):
    def __init__(self,name,sex):
        super().__init__(name,sex)

class Cat(Animal):
    def __init__(self,name,sex):
        super().__init__(name,sex)

dog = Dog("小黑","公狗")
dog.eat()
cat = Cat("小白","母猫")
cat.eat()

小结

继承中的一些特点:
1.python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，他才开始到基类中逐个查找。

7.Python面对对象特性

面对对象的三大特性：封装、继承、多态

作业

1.面条是食物的一种。编写一个名为Food的父类，一个名为noodle的子类。在子类中添加一个名为taste的属性，用于存储面条口味的列表，并编写一个显示所有口味的方法show_taste()。创建一个f实例，并调用这个方法。

class Food():
    def __init__(self, name, type):
        self.name = name
        self.type = type

class noodle(Food):
    def __init__(self,name,type):
        super().__init__(name,type)
        self.taste = ['酸','甜','苦','辣']
    def show_taste(self):
        print(self.taste)

f = noodle('牛肉面','面类')
f.show_taste()

2.定义一个扑克类，属性是颜色，数字。
定义一个手类，属性是扑克牌的颜色数字。
定义一个人类，属性是左手右手。类里定义一些方法，比如交换，展示。

class Poker():
    def __init__(self,color,number):
        self.color = color
        self.number = number
    def show(self):
        print("{}-{}".format(self.color,self.number))

class Hand():
    def __init__(self,poker):
        self.poker = poker

class People():a
    def __init__(self,left,right):
        self.left = left
        self.right = right
    def exchange(self):
        self.left,self.right=self.right,self.left
    def display(self):
        self.left.poker.show()
        self.right.poker.show()

p1 = Poker('梅花','K')
p2 = Poker('红桃','A')
left = Hand(p1)
right = Hand(p2)
p = People(left,right)
p.display()
p.exchange()
p.display()

上面一段代码的运行结果如下：

梅花-K
红桃-A
红桃-A
梅花-K