面向对象基础
review
1.捕获异常
try:
代码块1
except 异常类型1:
代码块11
except 异常类型2:
代码块2
finally:
代码块3
2.抛出异常
raise 异常类型
3.模块的使用
import 模块名 as 新模块名
from 模块名 import 变量1, 变量2 as 新变量2,...
from 模块名 import *
from package.cat import eat
from package import cat
4.hashlib加密特点
a.相同数据通过相同算法产生密文(摘要)是一样的
b.密文(摘要)不能逆向解密成原文
c.不管原数据的大小是多少，采用相同的算法产生的密文(摘要)的长度是一样的
import package
import hashlib
def digest(obj):
hash = hashlib.md5()
if type(obj) == str:
hash.update(obj.encode())
else:
hash.update(obj)
return hash.hexdigest()
class Rect:
def __init__(self, length, width):
self.length = length
self.width = width
self._area = length * width
@property
def area(self):
self._area = self.length * self.width
return self._area
@area.setter
def area(self, value):
raise ValueError
# r1.area = 200
def main():
r1 = Rect(10, 20)
print(r1.area)
r1.length = 5
print(r1.area)
# eat()
# cat.eat()
package.cat_eat()
print(digest('余婷'))
with open('luffy.jpg', 'rb') as f:
print(digest(f.read()))
if __name__ == '__main__':
main()
编程思想
编程思想: 面向过程编程(穷人思想)、函数式编程(小资)、面向对象编程(富豪)
面向过程编程 - 算法和逻辑
函数式编程 - 函数
面向对象编程 - 类和对象
====面向过程===
1. 求1+2+3+...+100
sum1 = 0
for x in range(101):
sum1 += x
print(sum1)
1. 求1+2+3+...+888
sum1 = 0
for x in range(889):
sum1 += x
print(sum1)
====函数式编程===
# 1. 求1+2+3+...+100
# print(sum(range(101)))
def sum1(n):
sum = 0
for x in range(n+1):
sum += x
return sum
print(sum1(100))
# 1. 求1+2+3+...+888
# print(sum(range(889)))
print(sum1(888))
print(sum1(10000))
=======面向对象=======
# 1. 求1+2+3+...+100
class Math:
def sum(self, n):
sum1 = 0
for x in range(n+1):
sum1 += x
return sum1
def product(self, n):
sum1 = 1
for x in range(1, n+1):
sum1 *= x
return sum1
ma = Math()
print(ma.sum(100))
print(ma.product(10))
类和对象
1.什么是类，什么是对象
类就是拥有相同属性、相同功能的对象的集合 (抽象的)
对象就是类的实例(具体的)
如果人是类, 余婷就是人的对象；张旭也是人的对象
如果水杯是类, 我桌上的这个黑色杯子就是对象
如果车是类, 具体的某一辆车就是对象
2.类的声明 - 确定这个类共同的属性和功能是什么
1)语法:
class 类名:
类的说明文档
类的内容
2)说明
class - 关键字
类名 - 要求: 标识符, 不能是关键字
规范: a.首字母大写，采用驼峰式命名规范 b.见名知义 c.不能使用系统提供的函数名或者类名
类的说明文档 - 和函数说明文档一样
类的内容 - 主要包含属性和方法(方法就是声明在类中函数)
class Person:
"""人类:
属性 -
方法 -
"""
def func0(self):
pass
def eat(self, food):
print('人吃%s' % food)
@classmethod
def func1(cls):
pass
@staticmethod
def func2():
pass
3.声明对象
1)语法:
对象 = 类()
"""
p1 = Person() # p1中存储的就是Person类的对象
p2 = Person() # 同一个类可以创建多个对象
p3 = p1 # p1和p3指向同一个对象
对象方法
1.对象方法
类中方法分为: 对象方法、类方法和静态方法
1)对象方法
a.怎么声明: 直接声明(声明前不需要加装饰器)在类中的函数就是对象方法
b.特点: 自带self参数; 用对象调用对象方法的时候self不用传参, 系统会自动将当前对象传给self。
self可以做到谁调用就指向谁
c.怎么调用: 以'对象.对象方法()'的形式来调用 - 通过对象来调用对象方法
class Person:
def eat(self, food='米饭'):
print('self:', self)
print('人在吃{}!'.format(food))
p1 = Person()
p2 = Person()
print('p1:', p1)
print('p2:', p2)
p2.eat()
p1.eat('包子')
# Person.eat('abc') # 不要用类去调用对象方法
构造方法
1.构造函数 - 函数名和类名一样，用来创建类的对象的函数
python中声明类的时候，系统会自动为这个类创建一个构造函数, 函数的作用是创建对象
构造方法的执行过程: a.在内存中开辟空间创建对象 b.用创建好的对象去调用init方法
c.返回对象在内存中的地址
2.init方法
声明在类中用来对对象进行初始化的方法；(当对象一创建出来，这个方法就会被自动调用)
注意: 创建对象的时候构造方法需不需要传参，需要传几个参数，看这个类的init方法
class Dog:
def __init__(self, name='', age=0):
print('init:', self)
print('初始化方法', name, age)
dog1 = Dog('大黄', 20)
print(dog1)
# dog2 = Dog('财财', 18)
dog3 = Dog(name='a', age=10)
# 构造方法的伪方法
def Dog():
对象 = 开辟空间创建对象
对象.__init__()
return 对象
"""
# def __init__():
# print('init')
#
# def Dog(*args, **kwargs):
# __init__(*args, **kwargs)
#
# Dog()
属性
1.类中的属性
属性就是声明在类中的变量
类中的属性分为: 字段、对象属性
1)字段
a.怎么声明: 声明在类的里面函数的外面的变量就是字段
b.怎么使用: 通过类去使用(以'类.字段'的形式使用)
c.什么时候用: 属性的值不会因为对象不同而不同，这样的属性就声明成类的字段
class Person:
# num就是字段
num = 100
def func1(self):
a = 10
print(Person.num)
pass
def func2(self):
pass
# 使用类的字段
print(Person.num)
Person.num = 200
print(Person.num)
p1 = Person()
p1.func1()
2)对象属性(重要)
a.怎么声明: 以'self.属性名=值'的形式声明在init方法中
b.怎么使用: 通过对象去使用
c.什么时候用: 属性的值可能会因为对象不同而不一样，这样的属性就声明成对象属性
class Student:
def __init__(self):
# 这儿的name、age、gender、study_id就是对象属性
self.name = '张三'
self.age = 0
self.gender = '男'
self.study_id = 'stu001'
stu1 = Student()
# stu1.age = 18
print(stu1.name, stu1.age, stu1.gender, stu1.study_id)
stu2 = Student()
# stu2.name = '小明'
print(stu2.name, stu2.age, stu2.gender, stu2.study_id)
class Student2:
def __init__(self, name1, study_id, gender='男'):
# 这儿的name、age、gender、study_id就是对象属性
self.name = name1
self.age = 18
self.gender = gender
self.study_id = study_id
stu3 = Student2('小明', '001')
print(stu3.name, stu3.age, stu3.study_id, stu3.gender)
stu4 = Student2('小花', '002', '女')
print(stu4.name, stu4.age, stu4.study_id, stu4.gender)
练习: 声明一个Dog类，
1)拥有属性：名字、年龄、性别和品种；
要求创建对象的时候名字、品种必须赋值，年龄和性别可以赋值也可以不赋值
2)拥有两个对象方法，一个用来打印狗的信息(显示信息的方法)
一个叫唤的方法:以'XXX:汪汪汪汪'的格式打印叫唤信息
class Dog:
def __init__(self, name, breed, age=3, gender='公狗'):
self.name = name
self.age = age
self.gender = gender
self.breed = breed
def print_message(self):
print(self.name, self.age, self.gender, self.breed)
def call_out(self):
print('%s: 汪汪汪！' % self.name)
dog1 = Dog('大黄', '土狗')
dog2 = Dog('旺财', '中华田园犬', gender='母狗')
dog2.print_message()
dog1.call_out()
dog2.call_out()
对象属性的增删改查
python中类的对象的对象属性支持增删改查
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
p1 = Person('小明', 18, '男')
p2 = Person('小红', 20, '女')
1.查(获取属性的值)
方法一: 对象.属性
方法二: getattr(对象, 属性名:str) / getattr(对象, 属性名:str, 默认值)
方法三: 对象.getattribute(属性名)
print(p1.name)
print(getattr(p1, 'name'))
print(p1.__getattribute__('name'))
# value = input('属性名:')
# print(getattr(p1, value))
# print(p1.height) # AttributeError: 'Person' object has no attribute 'height'
print(getattr(p1, 'height', 180))
2.增/改
方法一: 对象.属性 = 值
方法二: setattr(对象,属性名,值)
属性存在是修改
p1.name = '明明'
print(p1.name)
setattr(p1, 'age', 38)
print(p1.age)
# 属性不存在就添加
p1.weight = 190
print(p1.weight)
setattr(p1, 'face', 60)
print(p1.face)
3.删
方法一: del 对象.属性
方法二: delattr(对象, 属性名)
del p1.name
# print(p1.name) # AttributeError: 'Person' object has no attribute 'name'
delattr(p1, 'age')
# print(p1.age) # AttributeError: 'Person' object has no attribute 'age'
4.slots魔法
通过给slots字段赋值来约束当前类的对象有哪些对象属性
class Dog:
__slots__ = ('name', 'age', 'gender', 'height', 'weight')
def __init__(self, name, age):
self.name = name
self.age = age
dog1 = Dog('大黄', 3)
# dog1.namee = '黄黄'
dog1.gender = '公'
print(dog1.gender)
