Python学习笔记04

面向对象

创建对象的语法： 对象名 = 类名称()

# 设计一个类
class Student:
    name = None
    age = None
    gender = None

    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")

# 创建一个对象
stu_1 = Student()

# 对象属性进行赋值
stu_1.name = "张三"
stu_1.age = 21
stu_1.gender = "男"

# 获取对象中记录的消息
print(stu_1.name)
print(stu_1.age)
print(stu_1.gender)

# 调用类中的方法
stu_1.say_hi()

注意：

1. 面向对象：基于模板（类）去创建实体（对象），使用对象完成功能开发
2. 使用类去封装属性，并基于类创建一个个对象来使用
   1. 创建类的语法：
      1. class 类名称:
         类的属性：即定义在类中的变量（成员变量）
         类的行为：即定义在类中的函数（成员方法）
   2. 成员方法的定义语法：
      2. def 方法名(self, 形参1, …, 形参n):
      方法体
      return 返回值
3. self关键字是成员方法定义的是时候必须填写的
   1. 它是用来表示类对象自身的意思
   2. 当我们使用类对象调用方法时，self会自动被python传入
   3. 在方法内部，想要访问成员变量，必须使用self
   4. 在参数列表中，传参的时候可以忽略它

构造方法

# __init__()方法

# 创建类
class Student:
    name = None
    age = None
    tel = None

    # 创建构造方法
    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")


# 创建类对象
s = Student('张三', 21, "15872341414")

注意：

1. 在创建类对象的时候，会自动执行
2. 在创建类对象的时候，将传入参数自动传递给构造方法方法使用
3. 构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值
4. 构造方法也是成员方法，需要在参数列表中提供：self关键字
5. 构造方法内定义成员变量，需要使用self关键字
6. 魔术方法：python内置的一些方法
   1. init：构造方法
   2. str：字符串方法：控制类转换为字符串的行为
   3. lt：直接对两个对象进行比较，同时完成大于或者小于两种比较
   4. le：直接对两个对象进行比较，同时完成大于等于或者小于等于两种比较
   5. eq：可以按照自己的想法来决定两个对象是否相等，不实现eq方法比较的是内存地址

封装

# 创建一个类
class Phone:
    # 私有成员
    __cpu = 0.5
    
    # 私有方法
    def __keep_cpu(self):
        print("让cpu以单核模式运行")
    
    # 公共方法
    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("可以使用5G")
        else:
            self.__keep_single_core()
            print("电力不足无法使用5G")

phone = Phone()
# phone.__current_voltage = 21
# phone.__keep_single_core
phone.call_by_5g()

注意：

1. 封装：将现实世界的事物在类中描述为成员变量和成员方法，即为封装
2. 私有成员：
   1. 类中的部分属性和行为不能对外公开
   2. 类对象无法访问私有成员，否则报错
   3. 类中的其他成员可以访问私有成员
3. 语法：
   1. 私有成员变量：变量名以两个下划线开头
   2. 私有成员方法：方法名以两个下划线开头

继承

# 父类
class Phone:
    IMEI = None
    producer = "HM"

    def call_by_4G(self):
        print("4G通话")

# 子类继承父类
class Phone2(Phone):
    face_id = "10001"

    def call_by_5G(self):
        print("新功能5G通话")

# 多继承
class Myphone(Phone, NFC, Rem):
    pass

注意：

1. 继承：一个类可以继承另外一个类的成员变量和成员方法
2. 单继承 \ 多继承：
   1. class 类名(父类名):
      类内容体
   2. class 类名(父类1, 父类2, …, 父类n):
      类内容提
3. 多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级
4. 先继承的保留，后继承的被覆盖
5. pass关键字：表示无内容，空的意思

复写

# 父类
class Phone:
    name = "华为"

    def change_name(self):
        print("华为厂商")

# 子类继承父类,并复写父类的属性和方法
class MyPhone(Phone):
    name = "荣耀"

    def change_name(self):
        print("荣耀厂商")
        # 方式一
        # print(f"父类厂商是:{Phone.name}")
        # Phone.change_name(self)
        # 方式二
        print(f"父类厂商是:{super().name}")
        super().change_name()

my = MyPhone()
my.change_name()

注意：

1. 复写：在子类中重新定义同名的属性和方法
2. 一旦复写父类成员之后，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类成员，需要特殊的调用方式
3. 直接调用父类成员：
   1. 父类名.成员变量
   2. 父类名.成员方法(self)
4. 使用super()调用父类成员
   1. super().成员变量
   2. super().成员方法()
5. 只可以在子类内部调用父类同名成员，子类的实体对象调用默认是调用子类复写的成员

类型注解

# 基础数据类型注解
var_1: int = 10
var_2: float = 3.1415926
var_3: bool = True
var_4: str = "itiheim"


# 类对象类型注解
class Student:
    pass
stu: Student = Student()


# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_set: set = {1, 2, 3}
my_dict: dict = {"itiheim": 123}
my_str: str = "itiheim"


# 容器类型详细注解
my_list: list[int] = [1, 2, 3, 4, 5]
my_tuple: tuple[str, int, bool] = ("hello", 123, True)
my_set: set[int] = {1, 2, 3}
my_dict: dict[str, int] = {"itiheim": 123}


# 对形参进行类型注解
def Student(a: int, b: int):
    return a + b


# 对返回值进行类型注解
def func(data: list) -> list:
    return data

注意：

1. 类型注解：在代码中设计数据交互的地方，提供数据类型的注解
2. 主要功能
   1. 帮助第三方工具对代码进行类型推断，协助做代码提示
   2. 帮助开发者自身对变量进行类型注解
3. 支持
   1. 变量的类型注解
   2. 函数形参列表和返回值的类型注解
4. 语法
   1. 变量:类型
   2. type: 类型
5. 元组类型设置类型详细注解，需要将每一个元素都标记出来
6. 字典类型设置类型详细注解，需要两个类型，第一个是key第二个是value
7. 一般无法直接看出变量类型时，会添加类型注解

多态

# 父类
class Animal:
    def speak(self):
        pass

# 子类A
class Dog(Animal):
    def speak(self):
        print("小狗,汪汪汪~~~")

# 子类B
class Cat(Animal):
    def speak(self):
        print("小猫,喵喵喵~~~")

# 函数形参声明父类对象
# 以父类做定义声明
# 以子类做实际工作
# 用同一种行为，获得不同状态
def make_noise(animal: Animal):
    animal.speak()

make_noise(Dog())
make_noise(Cat())

注意：

1. 多态：值同一种行为，使用不同的对象获得不同的状态
2. 抽象类（接口）：包含抽象方法的类，抽象方法指的是没有具体实现的方法
   1. 作用：多用于做顶层设计，以便子类具体实现
   2. 也是对子类的一种软性约束，要求子类必须复写父类的方法
3. 抽象类（接口）：父类来确定有哪些方法，由子类去实现具体方法
4. 含有抽象方法的类为抽象类
5. 抽象方法：方法体为pass的空实现，为抽象方法

python操作MySQL

# 导入链接数据库模块的包
import pymysql

# 创建链接对象
conn = pymysql.connect(
    host='localhost',   # 主机名
    user='root',        # 账户
    password='123456',  # 密码
    port=3306,          # 端口
    autocommit=True     # 自动提交sql语句

)

# 通过链接对象的select_db方法，选择数据库
conn.select_db("day")

# 获取游标对象，cursor
cur = conn.cursor()

# 使用游标对象的execute方法，执行sql语句
# 创建表
# cur.execute("""create table text(id int, name varchar(15), age int)""")

# 插入数据
# cur.execute("""insert into text(id, name, age) values (1, "张三", 21)""")
# cur.execute("""insert into text(id, name, age) values (2, "李四", 22)""")
# cur.execute("""insert into text(id, name, age) values (3, "王五", 23)""")

# 数据查询
cur.execute("""select * from text""")

# 通过游标对象的fetchall方法，获取查询结构返回的对象是元组类型
res: tuple = cur.fetchall()

# 使用for循环输出数据
for row in res:
    print(row)

# 通过链接对象的close方法，关闭数据库
conn.close()

注意：

1. 调用的顺序要注意
2. sql语句不要写错