01-类和对象
-
1.定义类（创建类）
-
定义类就是 用代码描述清楚你这个类拥有哪些相同功能和哪些相同属性的对象的集合。
-
功能 - 对应的是函数
-
保存数据的变量 （在类中叫属性）
-
语法：
class 类名:
类的说明文档
类的内容 -
说明
- class - 关键字
- 类名 - 自己命名
要求：是标识符，不是关键字
规范：见名知义；驼峰式命名（单词之间采用首字母大写） (studentName)+ 首字母大写;
不使用系统函数名、类名和模块名
StudentName - 没有下划线 - : - 固定写法
类的说明文档 - 本质就是多行注释
类的内容 - 包括属性和方法
属性分为：类属性（类的字段）和对象属性
方法分为：对象方法、类方法和静态方法 - 注：方法就是定义在类中的函数
class Student:
"""
学生类
"""
pass
- 2.定义对象（创建对象）
- 语法：类()
stu1 = Student()
stu2 = Student()
print(stu1) # <__main__.Student object at 0x000001D31BBCE688>
print(stu2) # <__main__.Student object at 0x00000214D017EA08>
02-对象
- 1.方法
- 定义在类中的函数就是方法
- 2.对象方法
- 怎么定义： 直接定义在类中的函数（定义函数前不用加装饰器）
- 怎么调用：用对象来调用 - 对象.函数名()
- 特点：自带参数self， 在调用的时候self不用传参，系统会自动将当前对象传给self（谁调用self指向谁）
class Person:
"""
人类
"""
def sleep(self,):
print('睡觉')
def eat(self,food):
print(f'吃{food}')
p = Person()
p.sleep()
p.eat('小龙虾')
03-构造方法和初始化方法
-
1.构造函数/构造方法
- 函数名和类名相同，并且是用来创建对象的方法就是构造方法
- Python的构造函数在创建类的时候由系统自动创建，只需再创建对象的自动调用
-
初始化方法：’_ _ init _ _’
- 定义类的时候可以根据需求在类中添加对象方法 ： init，
添加的时候要保证函数名是__init__,第一个参数是self.
除此以外我们可以随意添加参数和函数体 - 每次使用类创建对象的时候，系统会自动调用这个类中的__init__方法
- 调用构造方法创建对象的时候需不需要参数，需要几个参数，看__init__ 除了self的额外参数
- 魔法方法：类中，方法名由__开头且结尾就是魔法方法。
所有的魔法方法都是自动调用。
- 定义类的时候可以根据需求在类中添加对象方法 ： init，
class Dog:
def __init__(self): # 创建对象的时候会自动调用
print('__init__被调用')
# 下面这个函数的定义由系统自动完成
"""
def Dog():
新建好的对象 = 创建对象并且申请内存保存对象
新建好的对象.__init__()
return 新建好的对象
"""
dog1 = Dog()
dog2 = Dog()
class Cat:
def __init__(self,name,age):
print('猫：__init__被调用')
print(f'name:{name},age:{age}')
cat1 = Cat('小花',2)
cat2 = Cat(name='土豆',age=2)
cat3 = Cat('美女',age=1)
print('=========================================')
# 补充
def __init__(x,y):
print('自己的__init__被调用')
print(f'x:{x},y:{y}')
def Cat(*args,**kwargs):
__init__(*args,**kwargs)
c1 = Cat(10,20)
c2 = Cat(x = 20,y=200)
*x,y = 10,20,30,40
def func1(*nums):
pass
def func2(a,b,c):
print(f'a:{a},b:{b},c:{c}')
# func2(100,200,300)
# 解包
alist = (100,200,300)
func2(*alist) # a:100,b:200,c:300 # func2(100,200,300)
# * 元组，列表
# ** 字典
dict1 = {'a':10,'b':20,'c':30}
func2(**dict1) # a:10,b:20,c:30
04-属性
- 1.属性
- 属性是用来描述类的数据特征。属性的本质是保存数据的变量。
- 2.对象属性和类属性
- 1）类属性
- 怎么定义：直接定义在类中的变量就是类属性
- 怎么使用：通过类来使用，类.类属性
- 什么时候用：属性的值不会因为对象不同而不一样，这种属性就定义为类属性
- 2）对象属性
- 怎么定义：以’self.属性名 = 值’的形式定义在__init__方法中
- 怎么使用：通过对象来使用，对象.对象属性
- 什么时候用：属性的值会因为对象不同而不一样，这种属性就定义为对象属性
- 1）类属性
class Person:
num = 61 # num是类属性
def __init__(self): # 对象属性的定义
self.name = '小明'
self.age = 18
self.gender = '男'
print(Person.num) # 没有必要再创建对象去用
Person.num = 60
print(Person.num) # 60
class Circle:
pi = 3.1415926
p1 = Person()
print(p1.name,p1.age,p1.gender)
p1.name = '小胡'
print(p1.name)
- 3.对象属性赋初值的方式
- 方式1：赋一个固定值
- 方式2：没有默认值的参数赋值
- 方式3：使用有默认值的参数赋值
class Dog:
def __init__(self,name,color,breed = '土狗',gender='母'):
self.breed = breed # 有默认值的参数
self.name =name # 没有默认值的参数
self.gender =gender # 有默认值的参数
self.color = color # 没有默认值的参数
self.age = 1 # 赋固定的值
# __repr__方法在当前类的对象被打印的时候会被自动调用，这个方法的返回值（必须是字符串）是什么就打印什么。
#
def __repr__(self):
# return 'abc'
# return f'{self.name,self.breed,self.gender,self.color,self.age}'
# return str(self.__dict__)
return f'<{str(self.__dict__)[1:-1]}>'
dog1 = Dog('财财','黄色')
# print(dog1) # <__main__.Dog object at 0x000002BD0B20AA08>
# print(f'dog:{dog1}') # dog:abc
# print(f'dog:{dog1}') # dog:('财财', '土狗', '母', '黄色', 1)
# print(f'dog:{dog1}') # dog:{'breed': '土狗', 'name': '财财', 'gender': '母', 'color': '黄色', 'age': 1}
print(f'dog:{dog1}') # dog:<'breed': '土狗', 'name': '财财', 'gender': '母', 'color': '黄色', 'age': 1>
# 练习
# 练习：定义一个商品类，拥有属性：价格、名称、产地、类型、生产日期、保质期
# 要求：创建对象的时候价格、名称、生产日期必须赋值； 其他属性可以赋值也可以不赋值，产地默认温州、保质期默认1年、类型默认是食品
# 打印对象的时候打印商品基本信息
class Goods:
def __init__(self, price, name, productionDate, type = '食品',place='温州',guaranteePeriod = '1年'):
self.price = price
self.name = name
self.place = place
self.type = type
self.productionDate = productionDate
self.guaranteePeriod = guaranteePeriod
def __repr__(self):
return f'<{str(self.__dict__)[1:-1]}>'
good1 = Goods(100,'q','1990-01-01')
print(f'good:{good1}')
05-方法
- 1.对象方法
- 怎么定义：直接在类中定义函数（函数前不加装饰器）
- 怎么调用：对象.对象方法（）
- 特点：自带参数self,self不用传参，谁调用self就指向谁
- 什么时候用：如果实现函数的功能需要用到对象属性，就用对象方法
- 2.类方法
- 怎么定义：在定义函数前加装饰器@classmethod
- 怎么调用：类.类方法
- 特点：自带参数cls ，cls不用传参，系统将当前类传个cls(谁调用就指向谁)
- 什么时候用：实现函数的功能，在不需要对象属性的时候，需要类就用类方法
- 3.静态方法
- 怎么定义：在定义函数前加装饰器@staticmethod
- 怎么调用：类.静态方法
- 特点：无默认参数
- 什么时候用：实现函数的功能既不需要当前类的对象，也不需要当前类，就使用静态方法（例如a+b）
class Test:
def func1(self):
print('对象方法')
@classmethod
def func2(cls):
# cls = Test
print(f'cls{cls}')
print('类方法')
@staticmethod
def func3():
print('静态方法')
t1 =Test()
#调用对象方法
t1.func1() # 对象方法
#调用类方法
Test.func2() # cls<class '__main__.Test'> 类方法
print(f'Test:{Test}') # Test:<class '__main__.Test'>
Test.func3() # 静态方法
class Circle:
pi = 3.1415926
def __init__(self,radius):
self.radius = radius
def area(self):
return Circle.pi * self.radius ** 2
def perimeter(self):
return 2 * Circle.pi * self.radius
@classmethod
def set_pi(cls,value):
cls.pi = value
c1 = Circle(1)
c2 = Circle(10)
print(c1.area())
print(c2.area())
作业
-
定义一个狗类和一个人类：
狗拥有属性：姓名、性别和品种 拥有方法：叫唤
人类拥有属性：姓名、年龄、狗 拥有方法：遛狗
class Dog: def __init__(self,name,gender,breed): self.name = name self.gender = gender self.breed = breed def action(self,action): return self.name+ '在'+ action dog1 = Dog('小花','母狗','土狗') print(dog1.action('叫唤')) class Person: def __init__(self, name, age, animal): self.name = name self.age = age self.animal = animal def action(self, action): return self.name + '在' + action + self.animal person1 = Person('小张',18,dog1.name) print(person1.action('遛')) -
定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积
class Rectangle: def __init__(self,length, width): self.length = length self.width = width def perimeter(self): return 2*(self.length + self.width) def area(self): return self.length * self.width r1 = Rectangle(10,5) print(r1.perimeter()) print(r1.area()) -
定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离
import math class Point: def __init__(self,x, y): self.x = x self.y = y def distance(self,p): return math.sqrt((self.x - p.x)**2 + (self.y - p.y) **2) p1 = Point(3,4) p2 = Point(0,0) print(p1.distance(p2)) -
定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切
import math class Circle: pi = 3.1415926 def __init__(self,radius=1,center_x,center_y): self.radius = radius self.center_x = center_x self.center_y = center_y def area(self): return Circle.pi * self.radius ** 2 def perimeter(self): return 2 * Circle.pi * self.radius def exterior_contact(self,c): if (self.radius + c.radius) == math.sqrt((self.center_x - c.center_x)**2 + (self.center_y - c.center_y) **2): print('外切') else: print('False') c1 = Circle(1,0,0) print(c1.perimeter()) c2 = Circle(1,2,0) print(c2.area()) c1.exterior_contact(c2) -
定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度
import math class Line: def __init__(self, x1,y1,x2,y2): self.x1 = x1 self.y1 = y1 self.x2 = x2 self.y2 = y2 def length(self): return math.sqrt((self.x1 - self.x2) ** 2 + (self.y1 - self.y2) ** 2) l1 = Line(0,0,3,4) print(l1.length())
扫一扫
1271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
