编程思想 - 不同程序员在遇到问题的时候解决问题的思维模式
1.面向过程编程(穷人思想) - 基本的语法和逻辑
2.函数式编程（小资思想） - 掌握函数（遇到问题先想想有没有一个已经存在的函数具备解决在这个问题的能力，如果有直接调用，没有
就创建一个这样的函数）
3.面向对象编程（富豪思想） - 类、对象（变量、函数）
# 求nums中所有的元素的和 nums=[10,29,34,5] print(sum(nums))6.1 类和对象
1.什么是类、什么是对象
类就是拥有相同功能和相同属性的对象的集合 - 抽象的概念
对象就是类的实例（类具体的表现）
人是类，具体的一个人就是它的对象，比如：余婷、骆昊
电脑是类，我的桌上这台电脑
杯子是类，我桌上这三个杯子都是它的对象
list是类, [10,20]是列表的对象
类就是类型、类别
2.定义类（创建类） - 用代码描述这个类是拥有哪些相同功能和哪些相同属性的对象的集合
功能 - 函数
属性 - 保存数据的变量（能够用数据表现出来）
语法:
class 类名:
类的说明文档
类的内容
说明：
1）class - 关键字固定写法
2）类名 - 由程序员自己命名（两个要求和三个规范：要求：是标识符，不是关键字；三个规范：见名知义、采用驼峰式命名并且首字
母大写（类名大写开头；驼峰式 - 从第二个单词开始单词首字母大写））
3）: - 固定写法
4）类的说明文档 - 多行注释
5）类的内容 - 相同功能和相同属性；
由方法（对象方法、类方法、静态方法）和属性（对象属性、类属性）组成
方法 - 定义在类中的函数
属性 - 定义在类中的变量
class Person:
"""人类"""
num=21 #num是属性
def eat(self): #eat是方法
print('吃饭')
3.创建对象
语法：类名() - 创建指定类对应的一个对象，并且将对象返回
p1=Person()
p2=Person()
print(p1) #<__main__.Person object at 0x000001C765AC2E80>
if __name__ == '__main__': #main是模块名
pass
6.2类的方法
1.方法 - 定义在类中的函数，用来描述具备的功能
类中的方法有三种：对象方法、类方法、静态方法
1）对象方法
a.怎么定义：将函数直接定义在类中
b.怎么调用：通过对象来调用 - 对象.xxx（都是在类的外面调用，不能在类的里面调用）
c.特点：自带参数self，通过对象调用对象方法的是参数self不需要传参，系统自动将当前对象传给self
（self,谁调用指向谁）
d.什么时候用：如果实现函数的功能需要用到对象属性就使用对象方法
2）类方法
a.怎么定义：定义函数前加装饰器’@classmethod’
b.怎么调用：通过类来调用 - 类名.xxx
c.特点：自带参数cls，调用的时候不需要传参，系统自动将当前类传给cls
d.什么时候用：如果实现函数的功能不需要对象属性需要类就是用类方法
3）静态方法
a.怎么定义：定义函数前加装饰器’@staticmethod’
b.怎么调用：通过类来调用 - 类名.xxx
c.特点：没有特点
d.什么时候用：实现函数功能，既不需要对象属性也不需要类，就用静态方法
class A:
def func1(self): #自带的self
print('对象方法')
print(self) #<__main__.A object at 0x000001D555BA3DF0>
#self就是a的值
def func11(self,x,y): # 自带的self,需要自己传参
print('对象方法')
@classmethod
def func2(cls): #cls当前类
print('类方法')
@staticmethod
def func3():
print('静态方法')
a = A()
a.func1() #通过对象调用对象方法
a.func11(100,200)
print(a) #<__main__.A object at 0x0000018E824B3DF0>
A.func2() #通过类调用类方法
A.func3() #通过类调用静态方法
4）初始化方法
1.魔法方法
方法名'__'开头并且以'__'结尾的自带的方法，就是魔法
所有的魔法方法都会在特定的情况下被自带调用
常用的魔法方法：__init__方法、__repr__方法
# 1）__repr__ - 打印对象的时候会自动调用对象对应的类中的__repr__方法，来定制打印规则(函数的返回值（必须是字符串）是什么对象的打印结果就是什么)
# 返回值必须是字符串
class A:
def __repr__(self):
return 'abc'
a=A()
print(a)
# 2）__init__ - 创建类的对象的时候会自动调用类中的__init方法
class B:
def __init__(self):
print('init方法')
b=B()
class C:
# 在类添加__init__方法的时候，除了方法和方法类型不能动，可以随意添加参数和随意添加函数体
def __new__(cls, *args, **kwargs): #创建对象之前调用
pass #怎么出来
def __init__(self,x,y): #在创建对象后被调用
print('aaa',x,y) #已经出来了
# 创建类的对象的时候需不需要参数，需要几个参数，有类中__init__方法决定
c=C(10,20) #需要给self后面的传参
6.3 属性(增删改查)
1.属性：对象属性和类属性
1）类属性（很少，如：圆周率）
a.怎么创建:在类中直接定义一个变量，这个变量就是类属性
b.怎么使用：通过类来使用 - 类.xxx
c.什么时候用：当属性值不会因为对象不同而不一样的时候就使用类属性
2)对象属性（99%都是）
a.怎么创建：以’self.属性名=值’的形式定义在类的__init__方法
b.怎么使用：：通过对象来使用 - 对象.属性名
c.什么时候用：当属性值会因为对象不同而不一样的时候就使用对象属性
class A:
# x是类属性
x=100
# name和age是对象属性
def __init__(self):
self.name='小明'
self.age=21
A.x=200
print(A.x) #200 使用和修改类属性的值
a=A()
a.age=18
print(a.name,a.age) #小明 18 使用和修改对象属性
练习：定义一个圆的类，拥有属性：半径和圆周率，拥有的方法：求周长和求面积
class Circle:
pi=3.14
def __init__(self):
self.radius=2
# 类中实现函数功能的时候如果需要的数据是属性，不需要提供额外的参数
def pe(self):
# 如果需要类属性直接用类来提供
# 如果需要对象属性用self提供
return Circle.pi * self.radius * 2
def area(self):
return self.radius ** 2 * Circle.pi
c1=Circle()
c2=Circle()
c2.radius=3
print(c1.pe(),c2.pe())
2.对象属性赋初始值的方式
class Person:
def __init__(self,name,gender='男'):
self.name=name #使用没有默认值的参数来赋值
self.age=1 #赋固定的值（很少用）
self.gender=gender #使用有默认值的参数来赋值
def __repr__(self):
# return f'name:{self.name},age:{self.age},gender{self.gender}'
# return str(self.__dict__) #打印所有{'name': '小明', 'age': 1, 'gender': '男'}
# return f'<{str(self.__dict__)[1:-1]}>' #<'name': '小明', 'age': 1, 'gender': '男'>
return str(self.__dict__)[1:-1]
p1=Person('小明')
print(p1)
print(p1.name,p1.age,p1.gender)
p2=Person('小红','女')
print(p2.name,p2.age,p2.gender)
练习：创建一个矩形类(根据生活拓展)
class Rectangle:
def __init__(self,long,wide):
self.long=long
self.wide=wide
def are(self):
return self.long*self.wide
def c(self):
return (self.long+self.wide)*2
def __repr__(self):
# return str(self.__dict__)
return f'<{str(self.__dict__)[1:-1]}>'
r1=Rectangle(2,10)
print(r1.c(),r1.are())
print(r1)
3.在面向对象编程的时候可以直接使用对象来代替字典
class Student:
def __init__(self,name,age=18,score=0):
self.name=name
self.age=age
self.score=score
def __repr__(self):
return str(self.__dict__)
stu1=Student('小明',score=100)
stu2=Student('小红',score=99)
print(stu1,stu2)
4.对象的对象属性支持增删改查
1)查 - 获取属性值
a. 对象.属性 - 获取指定属性的值,属性不存在的时候报错！！！
b. getattr(对象,属性名) - 获取指定属性的值,属性不存在报错！！！
c. getattr(对象,属性名,默认值) - 获取指定属性的值，属性不存在直接返回默认值
print(stu1.name) print(getattr(stu1,'name')) #attr可以动态
2）增改
a. 对象.属性=值 - 当属性存在的时候修改指定属性的值，当属性不存在的时候给属性添加属性
b. setattr(对象,属性名,值) - 当属性存在的时候修改指定属性的值，当属性不存在的时候给属性添加属性
print(stu1) #{'name': '小明', 'age': 18, 'score': 100}
stu1.age=12 #修改
print(stu1) #{'name': '小明', 'age': 12, 'score': 100}
stu1.gender='男' #添加
print(stu1) #{'name': '小明', 'age': 12, 'score': 100, 'gender': '男'}
setattr(stu1,'studentid','001')
print(stu1)#{'name': '小明', 'age': 12, 'score': 100, 'gender': '男', 'studentid': '001'}
setattr(stu1,'studentid','002')
print(stu1)#{'name': '小明', 'age': 12, 'score': 100, 'gender': '男', 'studentid': '002'}
# attr相关函数可以动态操作对象属性
# value=input('请输入：')
# print(getattr(stu1,value))
3)删
a. del 对象.属性d
b. delattr(对象,属性名)
del stu1.age
print(stu1) #{'name': '小明', 'score': 100, 'gender': '男', 'studentid': '002'}
delattr(stu1,'studentid')
print(stu1) #{'name': '小明', 'score': 100, 'gender': '男'}
4）判断是否存在 hasattr(对象,属性名)
print(hasattr(stu1, 'name')) #Trued6.4 继承
1.继承 - 让子类直接拥有父类的属性和方法
父类就是一个大的类，子类是这个大的类下面的一个小的分类
2.继承的语法
class 类名（父类）:
类的说明文档
类的内容
注意：定义类的时候如果没有写父类，这个类默认继承object（基类）
# class Person: == class Person(object):
class A:
a=100
def __init__(self):
self.b=10
self.c=20
def func1(self):
print('对象方法')
@classmethod
def func2(cls):
print('类方法')
@staticmethod
def func3():
print('静态方法')
class B(A):
pass
print(B.a) #100
x=B()
print(x.b) #10
x.func1() #对象方法
B.func2() #类方法
B.func3() #静态方法
3.在子类中添加内容
子类在拥有父类的属性和方法的同时，往往需要由属于自己特有的属性和方法
1）添加类属性和方法
直接在子类中定义新的类属性和方法
2）添加对象属性，在添加的新的对象属性前添加super().init()
class C(A):
m=11 #新的属性
def __init__(self):
super().__init__() #调用当前类的父类的__init__()
self.name='小明'
def func4(self):
print('c的对象方法')
@classmethod
def func5(cls):
print('c的类方法')
@staticmethod
def func6():
print('c的静态方法')
def func1(self): #重名的先调自己的
print('c的对象方法2')
print(C.a,C.m) #100 11
y=C()
y.func1() #c的对象方法2
print(y.name) #小明
print(y.b,y.c) #10 20
今日作业
-
定义一个狗类和一个人类：
狗拥有属性：姓名、性别和品种 拥有方法：叫唤
人类拥有属性：姓名、年龄、狗 拥有方法：遛狗
class Dog: def __init__(self,name,gender,breed): self.dod_name=name self.dog_gender=gender self.dog_breed=breed def cry_out(self): return '叫唤' def __repr__(self): return str(self.__dict__) a=Dog('蓝蓝','male','中国蓝犬') print(a) print(a.cry_out()) class Person(Dog): def __init__(self,name,age): self.name=name self.age=age def walk_dog(self): return '遛狗' def __repr__(self): return str(self.__dict__) p=Person('小蓝',21) print(p) print(p.walk_dog()) -
定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积
class Rectangle: def __init__(self,length,wight): self.length=length self.wight=wight def c(self): return (self.wight+self.length)*2 def area(self): return self.wight*self.length r=Rectangle(10,20) print(r.c(),r.area()) -
定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离
class Td: def __init__(self,x,y): self.xlable=x self.ylable=y def distance(self): return (self.xlable**2+self.ylable**2)**0.5 t=Td(10,10) print(t.distance()) -
定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切
class Circle(): pi=3.14 def __init__(self,r,center:tuple,r1,center1:tuple): self.r=r self.center=center self.r1=r1 self.center1=center1 def c(self): return f'当前圆的周长为：{Circle.pi*self.r*2}' def area(self): return f'当前圆的面积为：{self.r**2*Circle.pi}' def contact(self): return ((self.center1[0]-self.center[0])**2+(self.center1[-1]-self.center[-1])**2)**0.5 == self.r1+self.r d=Circle(2,(1,0),1,(3,0)) print(d.c(),d.area()) print(d.contact()) -
定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度
class Segment: def __init__(self,first1,top): self.first=first1 self.top=top def get_len(self): return self.first - self.top if self.first >= self.top else self.top - self.first s=Segment(10,20) print(s.get_len()) -
写一个斗地主游戏类（根据生活经验添加类的内容）
import random class Poke(): flowr=['黑桃','方片','梅花','红桃'] num=['2','3','4','5','6','7','8','9','10','J','Q','K','A'] kings={'big':'大王','small':'小王'} poker=[] player1=[] player2=[] player3=[] dipai=[] def __init__(self): for m in self.flowr: for n in self.num: self.poker.append(m+n+' ') self.poker.append(self.kings['big']+' ') self.poker.append(self.kings['small']+' ') def w(self): for i in range(54): index=random.randint(0,53) self.poker[index],self.poker[i]=self.poker[i],self.poker[index] def a(self): for i in range(17): self.player1.append(self.poker.pop(0)) self.player2.append(self.poker.pop(0)) self.player3.append(self.poker.pop(0)) self.dipai=tuple(self.poker) def s(self): for i in self.player1: print(i,end='') print() print('玩家1') for i in self.player2: print(i,end='') print() print('玩家2') for i in self.player3: print(i,end='') print() print('玩家3') for i in self.dipai: print(i,end='') print() print('底牌') p=Poke() p.w() p.a() p.s()
