python基础_4
day04_python基础
今日内容:
- 面向对象的基本概念 (了解)
- python的类相关内容 (掌握)
- pandas基本介绍 (了解)
- pandas的安装操作(参考安装即可)
- pandas的中相关数据结构(掌握)
1. 面向对象基本概念
Python是同时支持面向对象和面向过程的编程语言！
- 面向过程:
传统的面向过程的编程思想总结起来就八个字——自顶向下，逐步细化！
→ 将要实现的功能描述为一个从开始到结束按部就班的连续的“步骤”
→ 依次逐步完成这些步骤，如果某一个步骤的难度较大，又可以将该步骤再次细化为若干个子步骤，以此类推，一直到结尾并得到我们想要的结果
程序的主体是函数，一个函数就是一个封装起来的模块，可以实现特定的功能，程序的各个子步骤也往往就是通过相关的函数来完成的！从而实现代码的重用与模块化编程
举个栗子：大家以来传智教育报名学习这件事情，可以分成哪些步骤？开始 → 学员提出报名，提供相关材料 → 学生缴纳学费，获得缴费凭证 → 教师凭借学生缴费凭证进行分配班级 → 班级增加学生信息 → 结束,所谓的面向过程，就是将上面分析好了的步骤，依次执行就行了！- 面向对象:
所谓的面向对象，就是在编程的时候尽可能的去模拟现实世界！
在现实世界中，任何一个操作或者业务逻辑的实现都需要一个实体来完成！实体就是动作的支配者，没有实体，也就没有动作发生！
思考：上面的整个报名过程，都有哪些动词？
提出、提供、缴纳、获得、分配、增加
有动词就一定有实现这个动作的实体！
所谓的模拟现实世界，就是使计算机的编程语言在解决相关业务逻辑的时候，与真实的业务逻辑的发生保持一致，需要使任何一个动作的发生都存在一个支配给该动作的一个实体（主体），因为在现实世界中，任何一个功能的实现都可以看做是一个一个的实体在发挥其各自的“功能”（能力）并在内部进行协调有序的调用过程！面向对象的三大特性：封装、继承、多态
- ① 封装 将属性和方法书写到类的里面的操作即为封装，封装可以为属性和方法添加私有权限。
- ② 继承 子类默认继承父类的所有属性和方法，与此同时子类也可以重写父类属性和方法。
- ③ 多态 多态是同一类事物具有的多种形态。不同的对象调用同一个接口（方法），表现出不同的状态，称为多态。
2. 类
2.1 类的基本定义
在python中也是构建类的, python3中支持经典类和新式类
- 经典类: 不由任意内置类型派生出的类, 称之为经典类
class 类名:
代码
......- 新式类:
class 类名():
代码
...... 这就是一个类，只不过里面什么都没有！其中，类名不区分大小写，遵守一般的标识符的命名规则（以字母、数字和下划线构成，并且不能以数字开头），一般为了和方法名相区分，类名的首字母一般大写！（大驼峰法）
案例: 定义一个 '人' 类
class Person():
def eat(self):
print('我喜欢吃零食')
def drink(self):
print('我喜欢喝果汁')实例化类:
格式:
对象名 = 类名()案例: 实例化Person类, 生成p1对象
# 创建对象
p1 = Person()
# <__main__.Person object at 0x1013ecf50>
print(p1)
# p1对象调用实例方法
p1.eat()
p1.drink()self 关键词: 在类中，有一个特殊关键字self，其指向类实例化对象本身。
# 1. 定义类
class Person():
def eat(self):
print('我喜欢吃零食')
# <__main__.Person object at 0x1058bced0>
print(self)
# 2. 创建对象
p1 = Person()
# <__main__.Person object at 0x1058bced0>
print(p1)
p1.eat()
p2 = Person()
# <__main__.Person object at 0x1058bcf50>
print(p2)
注意：打印对象和self得到的结果是一致的，都是当前对象的内存中存储地址。2.2 类的添加和获取对象属性
属性即是特征，比如：人的姓名、年龄、身高、体重…都是对象的属性。
对象属性既可以在类外面添加和获取，也能在类里面添加和获取。
- 类外部添加对象属性:
格式:
对象名.属性名 = 值
操作: 在类里面获取属性 self.属性名
# 1. 定义类
class Person():
def print_info(self):
# 类里面获取实例属性
print(f'姓名：{self.name}')
print(f'年龄：{self.age}')
print(f'地址：{self.address}')
# 2. 创建对象
p1 = Person()
# 3. 添加属性
p1.name = '老王'
p1.age = 18
p1.address = '北京'
p1.print_info()属性不需要提前设置, 在赋值的时候, 如果没有自己的进行添加, 如果有, 就会覆盖掉
2.3 魔术方法
在Python中，__xxx__()的函数叫做魔法方法，指的是具有特殊功能的函数。
- init() 方法 其作用：实例化对象时，连带其中的参数，会一并传给init函数自动并执行它。init()函数的参数列表会在开头多出一项，它永远指代新建的那个实例对象，Python语法要求这个参数必须要有，名称为self。
class Person():
# 定义初始化功能的函数
def __init__(self, name, age, address):
# 添加实例属性
self.name = name
self.age = age
self.address = address
def print_info(self):
# 类里面调用实例属性
print(f'姓名：{self.name}, 年龄：{self.age}，地址：{self.address}')
p1 = Person('老王', 18, '北京')
p1.print_info()
p2 = Person('老李', 20, '深圳')
p2.print_info()
注意事项:
① __init__()方法，在创建一个对象时默认被调用，不需要手动调用
② __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象
引用传递过去。- str() 方法 当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了
__str__方法，那么就会打印从在这个方法中 return 的数据。
class Person():
# 定义初始化功能的函数
def __init__(self, name, age, address):
# 添加实例属性
self.name = name
self.age = age
self.address = address
def __str__(self):
""" 返回一个对象的描述信息 """
return f'姓名：{self.name}，年龄：{self.age}，地址：{self.address}'
p1 = Person('老王', 18, '北京')
print(p1)- del()方法 当删除对象时，python解释器也会默认调用del()方法。
class Person():
# 定义初始化功能的函数
def __init__(self, name, age, address):
# 添加实例属性
self.name = name
self.age = age
self.address = address
def __del__(self):
print(f'{self}对象已经被删除')
p1 = Person('老王', 18, '北京')
# <__main__.Person object at 0x101af8f90>对象已经被删除
del p12.4 私有属性和私有方法
在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。
设置私有属性和私有方法的方式非常简单：在属性名和方法名 前面 加上两个下划线 "__" 即可。
- 案例1：私有属性和私有方法设置方式
class Girl():
def __init__(self):
self.name = '小美'
self.__age = 18
def __showinfo(self):
print('姓名：%s，年龄：%d' % (self.name, self.__age))
girl = Girl()
print(girl.name)
# 外界不能直接访问私有属性和私有方法
print(girl.__age)
girl.__showinfo()- 外部获取与设置私有属性值: 在Python中，一般定义函数名' get_xx '用来获取私有属性，定义' set_xx '用来修改私有属性值。
class Girl():
def __init__(self):
self.name = '小美'
self.__age = 18
def get_age(self):
return self.__age
def set_age(self, age):
self.__age = age
girl = Girl()
girl.set_age(19)
print(girl.get_age())2.5 类的单继承
基本语法:
# 父类B
class B(object):
pass
# 子类A
class A(B):
pass在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
概念说明:
继承：一个类从另一个已有的类获得其成员的相关特性，就叫作继承！
派生：从一个已有的类产生一个新的类，称为派生！
很显然，继承和派生其实就是从不同的方向来描述的相同的概念而已，本质上是一样的！
父类：也叫作基类，就是指已有被继承的类！
子类：也叫作派生类或扩展类
扩展：在子类中增加一些自己特有的特性，就叫作扩展，没有扩展，继承也就没有意义了！
单继承：一个类只能继承自一个其他的类，不能继承多个类，单继承也是大多数面向对象语言的特性！
多继承：一个类同时继承了多个父类， （C++、Python等语言都支持多继承）案例:
class Animal(object):
def eat(self):
print('吃...')
def sleep(self):
print('睡...')
def call(self):
print('叫...')
class Dog(Animal):
pass
class Cat(Animal):
pass
…重写父类属性和方法
# 演示 python类的继承操作
# 1- 单继承:
class Animal(object):
def __init__(self,name,age):
self.name = name
self.age = age
def sleep(self):
print("动物都是要睡觉的")
def eat(self):
print("动物都是要吃饭的")
class Dog(Animal):
def __init__(self,name,age,address):
super().__init__(name,age)
self.address = address
def eat(self):
# 希望在调用当前方法的时候, 先调用父类的方法
super().eat()
print("狗爱吃骨头")
class Cat(Animal):
def eat(self):
print("猫爱吃鱼")
# 构建子类对象
d1 = Dog('小爱',3,'昌平区')
d1.eat()
d1.sleep()
print(d1.address)
c1 = Cat('小猫',5)
c1.eat()发现, 调用的, 默认调用的是当前重写后的函数, 如果想调用之前的, 需要使用super()来处理
class Animal():
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('吃...')
def sleep(self):
print('睡...')
def call(self):
print('叫...')
…
class Dog(Animal):
def __init__(self, name, age, sex):
super().__init__(name, age)
self.sex = sex
def __str__(self):
return f'{self.name}，今年{self.age}岁了，我会汪汪叫...'
class Cat(Animal):
def __init__(self, name, age, sex):
super().__init__(name, age)
self.sex = sex
def __str__(self):
return f'{self.name}，今年{self.age}岁了，我会喵喵叫...'
…2.6 类的多继承
多继承：一个类同时继承了多个父类，并且同时具有所有父类的属性和方法例如：孩子会继承父亲 和 母亲的方法。
class Father(object):
pass
class Mother(object):
pass
class Child(Father, Mother):
pass2.7 多态体现
类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Animal 派生出 Cat和 Dog，并都写了一个 call() 方法，如下示例：
class Animal(object):
def __init__(self, name, age):
self.name = name
self.age = age
def call(self):
print(self.name, '会叫')
class Cat(Animal):
def __init__(self, name, age, sex):
super(Cat, self).__init__(name, age)
self.sex = sex
def call(self):
print(self.name, '会“喵喵”叫')
class Dog(Animal):
def __init__(self, name, age, sex):
super(Dog, self).__init__(name, age)
self.sex = sex
def call(self):
print(self.name, '会“汪汪”叫')
接下来, 定义一个do函数, 接收一个变量 'all', 如下:
def do(all):
all.call()
A = Animal('小黑',4)
C = Cat('喵喵', 2, '男')
D = Dog('旺财', 5, '女')
for x in (A,C,D):
do(x) 这种行为称为多态。也就是说，方法调用将作用在 all 的实际类型上。C 是 Cat 类型，它实际上拥有自己的 call() 方法以及从 Animal 继承的 call 方法，但调用 C .call() 总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。传递给函数 do(all) 的参数 all 不一定是 Animal 或 Animal 的子类型。任何数据类型的实例都可以，只要它有一个 call() 的方法即可。其他类不继承于 Animal，具备 call 方法也可以使用 do 函数。这就是动态语言，动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。
从表面上看 是一个弱类型的软件, 没有类型的约束, 但是实际上底层是一种强类型的语言, 所以底层确实再走多态方案
python语言: 强类型动态语言例子:
2.8 静态方法
静态方法需要用修饰器 "@staticmethod" 来标识，告诉解释器这是一个静态方法。
通过类名.调用 静态方法
class Game:
@staticmethod
def menu():
print('------')
print('开始[1]')
print('暂停[2]')
print('退出[3]')
Game.menu()