一、类

class 类名:（使用大驼峰命名）
    def 方法名(self):
    	代码1
    	代码2
    	...
    # 其他方法...

示例：

class Car:
    def run(self):
        print("汽车能跑起来...")
# 当仅定义了后,执行程序没有效果

# 1.创建对象
# 对象名 = 类名()
car = Car()
# 2.调用方法
# 对象名.方法名()
car.run()   # 不需要给self传递值

输出：汽车能跑起来...

二、self关键字

# 定义类
class Student:
    pass

# 创建对象
student = Student()

三、if __name__ == "__main__":

这是一个常见的 Python 代码结构，用于确保以下的代码仅在当前脚本作为主程序运行时执行，而不是在被其他脚本导入时执行
 

四、对象

创建对象语法： 对象名=类名（）
调用方法语法： 对象名.方法名（）

示例：

# 定义类
class Car:
      def run(self):
            print("Car is running...")

# 创建对象
car = Car()
car.run()

输出：Car is running...

五、类外面访问属性

添加属性 对象名.属性名=值
获取属性 对象名.属性名

示例：

# 添加属性 对象名.属性名=值
# 获取属性 对象名.属性名

class Car:
    pass

if __name__ == '__main__':
    car = Car()
    car.color = 'red'
    car.number = '1'

    print(car.color)
    print(car.number)

输出：red
          1

六、类内部获取属性

self.属性

示例：

class Car:
    def run(self):
        print("汽车能跑起来")
    def show(self):
        print(f"车的颜色：{self.color}")
        print(f"车的品牌：{self.brand}")
car = Car()
car.color = "黑色"
car.brand = "BWM"

car.show()

输出：车的颜色：黑色
          车的品牌：BWM

七、无参`__init__()`方法、

class 类名:
	def __init__(self):
        代码
        ...

示例：

class Car:
    def __init__(self):
        self.color = "red"
        self.number = "2"

if __name__ == '__main__':
    car = Car()
    print(car.color)
    print(car.number)

输出：red
           2

八、有参`__init__()`方法

class 类名:
	def __init__(self, 参数1, 参数2,...):
        代码
        ...

示例：

class Car:
    def __init__(self,color,price):
        self.color = color
        self.price = price
        print("init方法执行了")

if __name__ == '__main__':
    car = Car("红色",23000)
    print(car.color)
    print(car.price)

输出：init方法执行了
           红色
           23000

九、继承基础 定义类的几种语法

（1）【类名】

（2）【类名()】

（3）【类名(object)】

方式1语法：

```
class 类名:
	代码
	...
```

方式2语法：

```
class 类名():
	代码
	...
```

方式3语法：

```
class 类名(object):   # 推荐
	代码
	...
```

# 1.类名
# class Teacher:
class Teacher:
    pass


# 2.类名()
class Student():  # 删除()
    pass


# 3.类名(object)
class Phone(object):   # 标准
    pass

示例：

（1）Father类有一个性别属性，默认为男，同时，Father跑步速度快；
（2）如果Son类也想要拥有这些属性和方法，该怎么做呢？
（3）执行程序，观察程序效果。

class Father(object):
    def __init__(self):
        self.sex = '男'

    def run(self):
        print("runing fast...")

class Son(Father):
    pass

if __name__ == '__main__':
    son = Son()
    son.run()

输出：runing fast...

十、单继承

class 子类名(父类名):
    代码
    ...

示例：

class Master(object):
    def __init__(self):
        print("master初始化")
    def make_pancake(self):
        print("煎饼果子")

class Tudi(Master):
    def __init__(self):
        print("徒弟初始化")
    pass
if __name__ == '__main__':
    t = Tudi()
    t.make_pancake()

输出：徒弟初始化
           煎饼果子

十一、多继承

class 子类名(父类名1, 父类名2, ...):
    代码
    ...

示例：

class Master(object):

    def make_pancake(self):
        print("master的绝活")

class Shool(object):
    def make_pancake(self):
        print("新西方煎饼技术")

class Tudi(Master,Shool): # 谁在前面 就会输出谁
    pass

if __name__ == '__main__':
    t = Tudi()
    t.make_pancake()

输出：master的绝活

十二、重写父类

class 父类名(object):
    def 方法A(self):
    	代码
    	...
class 子类名(父类名):
    def 方法A(self):
    	代码
    	...

示例：

class Master(object):
    def make_cake(self):
        print("123")

class Tudi(Master):
    def make_cake(self):
        print("456")

tudi = Tudi()
tudi.make_cake()

输出：456

十三、调用父类方法

调父类 使用super关键字
super().方法名([参数1, 参数2, ...])

示例：

class School(object):
    def make_pancake(self):
        print("新西方煎饼技术")

class Tudi(School):
    def __init__(self):
        print("煎饼果子新品牌")
        super().make_pancake()
        self.peifang = "煎饼果子臭豆腐"
        self.brand = "煎饼果子品牌"
    def make_pancake(self):
        print("徒弟的煎饼技术")

if __name__ == '__main__':
    tu = Tudi()
    tu.make_pancake()


 # super().make_pancake()调用了父类

输出：煎饼果子新品牌
           新西方煎饼技术
           徒弟的煎饼技术

十四、多层继承

甲 传授给 乙 传授给 丙

示例：

class Master(object):
    def make_pancake(self):
        print("煎饼技术哪家强？")

class Tudi(Master):
    pass
    # def make_pancake(self):
    #    print("我只会做煎饼果子")

class Tusun(Tudi):
    pass
if __name__ == '__main__':
    tu = Tusun()
    tu.make_pancake()

输出：煎饼技术哪家强？

十五、私有属性

self.__属性名

class 类名(xxx):
	# 设置私有属性值[set]
    def set_私有属性名(self,参数):
        self.私有属性 = 参数

    # 获取私有属性值[get]
    def get_私有属性名(self):
        return self.私有属性

需要有return才可以 继承 没有return 就获取不了父类的私有属性

示例：

class Master(object):
    def __init__(self):
        self.__money = 99743

    def get_money(self):
        return self.__money

class Tudi(Master):
    pass
if __name__ == '__main__':
    t = Tudi()
    #print(t.money)
    print(t.get_money())

输出：99743

十六、类方法

定义类方法 语法：

class 类名(object):
    @classmethod
    def 类方法名(cls):
        ...

调用类方法，语法：

类名.类方法名()

示例：

class Dog(object):
    @classmethod
    def eat(cls):
        print("dog like to eat meat")

Dog.eat()

输出：dog like to eat meat

十七、静态方法

定义静态方法，语法：

class 类名(object):
    @staticmethod
    def 静态方法名():
        ...

调用静态方法，语法：

类名.静态方法名()

示例：

class Game(object):
    @staticmethod
    def show_menu():
        print("你好")

Game.show_menu()

输出：你好

十八、综合案例

import random
# 1. 设计一个 Game 类 (类名)
class Game(object):
# 2. 属性:
# 	• 定义一个 top_score 类属性 -> 记录游戏的历史最高分
    top_score = 0
# 	• 定义一个 player_name 实例属性 -> 记录当前游戏的玩家姓名
    def __init__(self,player_name):
        self.player_name = player_name
# 3. 方法:
# 	• 静态方法 show_help() -> 直接打印  这是游戏帮助信息
    @staticmethod
    def show_help():
        print("这是游戏帮助信息")
# 	• 类方法 show_top_score() -> 显示历史最高分
    @classmethod
    def show_top_score(cls):
        print("历史最高分")
# 	• 实例方法 start_game() -> 开始当前玩家的游戏
    def start_game(self):
#         -   3.1 输出 玩家 xxx 开始游戏
        print(f"玩家{self.player_name}开始游戏")
#         -   3.2 使用随机数,生成 10 - 100 之间的随机数字作为本次游戏的得分
        score = random.randint(10,100)
#         -   3.3 打印 玩家 xxx 本次游戏得分 xxx
        print(f"玩家{self.player_name} 本次游戏得分{score}")
#         -   3.4 判断本次游戏得分和最高分之间的关系
        if score > Game.top_score:
            Game.top_score = score
            print(f"恭喜 {self.player_name}，获得了新纪录")
# 4. 主程序步骤: __main__
if __name__ == "__main__":
#     1 查看帮助信息
    Game.show_help()
#     2 查看历史最高分
    Game.show_top_score()
#     3 创建游戏对象，开始游戏
    g1 = Game("小米")
    g2 = Game("小慧")

    g1.start_game()
    g2.start_game()

【自测一下 随机生成】

十九、深浅拷贝

综合案例：

import copy

m = [1, 2, 3]
n = [10, 20]
datas = [m, n]

# 浅拷贝
result1 = copy.copy(datas)

m.append(30)
print(result1)
print(datas)
print("-----深浅拷贝交换------")
# 深拷贝
result2 = copy.deepcopy(datas)
m.append(50)
print(result2)
print(datas)

输出：

[[1, 2, 3, 30], [10, 20]]
[[1, 2, 3, 30], [10, 20]]
-----深浅拷贝交换------
[[1, 2, 3, 30], [10, 20]]
[[1, 2, 3, 30, 50], [10, 20]]

案例2：

import copy
list1 = [11, 22, 33, [44, 55]]
list2 = copy.deepcopy(list1)
list1[3][0] = 440
print(list1) #[11,22,33,[440,55]]
print(list2) #[11,22,33,[44,55]]

结论 ：浅拷贝 只能拷贝数据最外一层数据，无法拷贝里面引用的数据 所以进行更改的时候 里面会更改
      深拷贝 每一层都会拷贝 所以不会根据外面的变化而变化

二十、函数名当作参数传递

def 函数名A():
	代码
	...

def function(num):
	代码
	num()  # 调用函数
	...
	
function(函数名A)   # 把函数名当作参数传递

二十一、闭包

定义闭包语法：

# 外部函数
def 外部函数名(外部参数):
    # 内部函数
    def 内部函数名(内部参数):
        ...[使用]
        代码
    return 内部函数名      # 闭包

调用闭包语法：

变量名 = 外部函数名([外部参数列表])
变量名([内部参数列表])

要构成闭包，需要满足3个条件：

（1）有嵌套：外部函数中嵌套了一个内部函数
（2）有引用：内部函数中使用了外部函数的变量或参数
（3）有返回：需要把内部函数名返回给外部函数

案例：

def outer(x):
    def inner(y):
        print("两数之和的结果", x + y)
    return inner

if __name__ == '__main__':
    func = outer(10)
    print(func)
    func(20)

输出：

<function outer.<locals>.inner at 0x7f6e16a920d0>
两数之和的结果 30

二十二、装饰器入门

定义装饰器：

def outer([外面参数列表]):
	def inner([内部参数列表]):
		新增额外功能代码
		....
		...[引用]
	return inner

使用装饰器的标准语法：

 语法糖
@outer
def 函数名():
	代码
	...


语法糖 加装饰器@outer的作用 就是想要引用上面的值

示例：

def outer(func):
    def inner():

        if True:
            print("用户登录...")
        func()
    return inner
@outer
def comment():
    print("发表评论")
comment()

输出：用户登录...
           发表评论

二十三、函数分类

对于函数的使用，可以根据有无参数、有无返回值来进行分类。分为：

（1）无参无返回值的函数

（2）有参无返回值的函数

（3）无参有返回值的函数

（4）有参有返回值的函数

无参无返回值的函数的语法：

```
# 定义
def 函数名():
	代码
	...
	
# 调用
函数名()
```

有参无返回值的函数的语法：

```
# 定义
def 函数名(参数1, 参数2, ...):
	代码
	...
	
# 调用
函数名(值1, 值2, ...)

无参有返回值的函数的语法：

```
# 定义
def 函数名():
	代码
	...
	return 值
	
# 调用
变量名 = 函数名()

有参有返回值的函数的语法：

```
# 定义
def 函数名(参数1, 参数2, ...):
	代码
	...
	return 值
	
# 调用
变量名 = 函数名(值1, 值2, ...)

二十四、装饰 无参无返回值的函数

# def outer(func):
#     def inner():
#         新增额外功能代码
#         ....
#         ...[引用]
#     return inner

示例：

def outer(func):
	def inner():
		print("正在努力计算中")
		func()
	return inner
@outer
def get_sum():
	a = 10
	b = 23
	sum = a + b
	print(f"两数之和为：{sum}")
get_sum()

输出：正在努力计算中
           两数之和为：33

二十五、装饰 有参无返回值的函数

# def outer(func):
#     def inner(参数1, 参数2, ...):
#         新增额外功能代码
#         ....
#         ...[引用]
#     return inner

示例：

def outer(func):
    def inner(x,y):
        print("正在努力计算")
        func(x,y)
    return inner

@outer
def get_sum(a,b):
    sum = a + b
    print(f"两数之和为：{sum}")
get_sum(10,20)

输出：正在努力计算
           两数之和为：30

二十六、装饰 无参有返回值的函数

# def outer(func):
#     def inner():
#         新增额外功能代码
#         ....
#         ...[引用]
#         return 值  # 要返回值
#     return inner

示例：

def outer(func):
    def inner():
        print("正在努力计算")
        result = func()
        return result
    return inner

@outer
def get_sum():
    a = 19
    b = 23
    sum = a + b
    return sum
print(get_sum())

输出：正在努力计算
           42

二十七、装饰 有参有返回值的函数

---

# def outer(func):
#     def inner(参数1, 参数2, ...):
#         新增额外功能代码
#         ....
#         ...[引用]
#         return 值  # 要返回值
#     return inner

示例：

def outer(func):
    def inner(x,y):
        print("正在努力计算")
        result = func(x,y)
        return result
    return inner

@outer
def get_sum(a, b):
    sum = a + b
    return sum
print(f"两数之和为：{get_sum(10,48)}")

输出：正在努力计算
           两数之和为：58

装饰器总结：

（1）当被装饰的原有函数有参有返回值时，定义的装饰器类型应该在内部函数中要有参数，也要有返回值；

（2）当要构成装饰器的条件时，需要满足：有嵌套、有引用、有返回、有额外功能；