python学习_day4--面向对象(封装、继承、多态)、闭包、异常、文件、随机数

最新推荐文章于 2023-08-06 16:28:00 发布

带你飞(｀⌒´メ)

最新推荐文章于 2023-08-06 16:28:00 发布

阅读量663

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/weixin_45800653/article/details/121407884

版权

python 专栏收录该内容

40 篇文章 6 订阅

订阅专栏

文章目录

一、封装
二、继承
三、多继承
四、多态
五、闭包
六、装饰器
七、异常
八、文件
九、随机数

一、封装

# 封装
# 通过在属性 方法前增加两个下划线---实现私有的机制
class Person1:
    def __init__(self,name="zz",age=20):
        self.__name=name
        self.age=age
    def show_info(self):
        print("姓名是{}，年龄是{}".format(self.__name,self.age))
p1=Person1()
print(p1.age)

# 可以输出类中所有的属性，包括私有属性
print(p1.__dict__) # {'_Person1__name': 'zz', 'age': 20}
# 对象名.__类名__私有属性---可以访问，python中的私有不是绝对的私有
print(p1._Person1__name) # zz

二、继承

"""
继承：提高代码重用率
子类：继承的
父类：被继承的、基类、超类
所有的类都继承自object类
查看继承的父类的格式：类名.__bases__
"""
import math

class Animal:
    def eat(self):
        print("吃------")

    def sleep(self):
        print("睡---")

class Dog(Animal):  # 要继承的父类名字
    def bite(self):
        print("可能会咬人-----")

class Cat(Animal):
    def climb_tree(self):
        print("爬树------")

d1 = Dog()
d1.eat() # 吃------

print("DOG的父类", Dog.__base__) # DOG的父类 <class '__main__.Animal'>
print("Animal的父类", Animal.__base__) # Animal的父类 <class 'object'>

# 形状类
# 圆类、正方形类----只需传一个参数
class Shape:
    def __init__(self, p):
        self.p = p

    def area(self):
        pass

class Circle(Shape):
    def area(self):
        print("圆的面积是", math.pi * self.p ** 2)

class Square(Shape):
    def area(self):
        print("正方形的面积是", self.p ** 2)

c1 = Circle(1)
c1.area() # 圆的面积是 3.141592653589793

s1 = Square(2)
s1.area() # 正方形的面积是 4

# 加一个矩形 rect w，h---需传两个参数
# t1 = (2, 3)
# w,h = t1
# print(w, h, type(w))
# 因为矩形要接收两个值，所以*p
#------方法一-----
class Shape:
    def __init__(self, *p):
        self.p = p

    def area(self):
        pass

class Circle(Shape):
    def area(self):
        print("self.p----",self.p,self.p[0])
        tmp=self.p
        print(tmp,type(tmp)) # (1,) <class 'tuple'>
        print("圆的面积是", math.pi * self.p[0] ** 2)

class Square(Shape):
    def area(self):
        print("正方形的面积是", self.p[0] ** 2)

class Rect(Shape):
    def area(self):
        w,h=self.p
        print("矩形形的面积是",w*h)

c1 = Circle(1)
c1.area()

s1 = Square(2)
s1.area()

r1 = Rect(6,2)
r1.area()

#------方法二-----利用super
class Shape:
    def __init__(self, p):
        self.p = p

    def area(self):
        pass

class Circle(Shape):
    def area(self):
        print("圆的面积是", math.pi * self.p ** 2)

class Square(Shape):
    def area(self):
        print("正方形的面积是", self.p ** 2)

class Rect(Shape):
    def __init__(self, w, h):
        # super(Rect, self).__init__(w)---之前python版本的写法
        super().__init__(w) # 调用了父类的初始化
        # self.p = w-----或者不用父类的参数初始化，都从新自己定义
        self.p1 = h # 自己再定义一个参数

    def area(self):
        print("矩形形的面积是", self.p * self.p1)

r1 = Rect(2, 3)
r1.area()

# super的应用
class Student:
    def task(self):
        print("上课")
        print("写作业")

class Monitor(Student):
    def task(self):
        super(Monitor, self).task()
        print("收作业")

m1 = Monitor()
m1.task()

三、多继承

class A:
    def run(self):
        print("A在运行")

class B:
    def run(self):
        print("B在运行")

class C(A, B):  # 顺序代表了继承先后顺序
    pass

c1 = C()
c1.run()

print("继承顺序", C.__mro__)
"""
A在运行
继承顺序 (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
"""

四、多态

"""
def fun(父类类名):

fun(子类1对象)---调用自己里边的方法
fun(子类2对象)
"""
class Pay:
    def pay(self):
        pass

class AliPay(Pay):
    def pay(self):
        print("支付宝支付")

class AppPay(Pay):
    def pay(self):
        print("APP store 支付")

def consumptio(Pay):
    Pay.pay()

ali = AliPay()
consumptio(ali)

app = AppPay()
consumptio(app)

class WeixinPay:
    def pay(self):
        print("微信支付----")

wxpay = WeixinPay()
consumptio(wxpay)

五、闭包

"""
在python中创建一个闭包一般有3个要求:
1.闭包函数必须有内嵌函数。
2.内嵌函数必须要引用外层函数的变量。
3.闭包函数返回内嵌函数的地址(函数名称)
"""
import time

def outer():
    name = "张三"

    def inner():
        # print(name)
        print("哈哈哈")

    return inner

f = outer()  # ---返回为内嵌函数的地址
f()

# 查看该函数是否为闭包
print(f.__closure__)  # 返回地址，表示为闭包； 返回None  不是闭包

六、装饰器

# 装饰器
# 在不改变原函数参数，以及调用的方式。对原函数进行扩展

测试函数的耗时

# 方式1
def fun():
    print("hahahah")
    time.sleep(5)
start = time.time()
fun()
end = time.time()
print("运行时长", end-start) # 运行时长 5.0119194984436035

# 方式2：在函数定义内部增加计时代码块
def fun():
    print("hahahah")
    time.sleep(5)

def timer(fun):
    def inner():
        start = time.time()
        fun()
        end = time.time()
        print("运行时间", end - start)
    return inner
fun=timer(fun)
fun() # 运行时间 5.010054111480713

# 方式3：语法糖
# 扩展代码在前
def timer(fun):
    def inner():
        start = time.time()
        print("函数前的扩展")
        fun()
        print("函数后的扩展")
        end = time.time()
        print("运行时间", end - start)
    return inner

@timer  # 语法糖
def fun():
    print("hahahah")
    time.sleep(5)

fun() # 运行时间 5.000531435012817

在这里插入图片描述

# 多个装饰器
def wraper1(fun):
    def inner():
        print("before 1----------")
        fun()
        print("After 1----------")
    return inner

def wraper2(fun):
    def inner():
        print("before 2----------")
        fun()
        print("After 2----------")
    return inner

@wraper2
@wraper1
def f():
    print("基本的函数")
   
f()

七、异常

"""
异常 语法正确的情况下，程序运行错误
"""
try:
    print(1 / 1)
    l1 = [1, 2, 3, 4]
    print(l1[0])
    print(b)
except ZeroDivisionError:
    print("除0错误")
except IndexError:
    print("索引越界")
except:
    print("其他错误")
finally:
    print("无论是否有异常都会输出")

# raise自己定义异常
name = input("enter your name：")
try:
    if len(name) < 3:
        raise Exception("长度过短")
    else:
        print("姓名是", name)
except:
    print("重新输入")

八、文件

"""
文本文件：txt
二进制文件
打开文件 open
读写文件 read/write
关闭文件 close
"""

"""
file 文件路径，
mode 打开文件的模式。是读还是写？默认r (read)
encoding
"""
f = open("day4_2多继承.py", mode='r', encoding="utf-8")
content = f.read()
print(content)

# 写文件
# 当模式为w,如果文件存在，会将文件原内容覆盖掉。
# 如果文件不存在，会创建文件
f = open("新文件.txt", mode='w')
f.write(content)
f.close()

# 如果不希望内容被覆盖掉 模式修改为追加 mode='a'
f = open("新文件.txt", mode='a')
f.write("当模式为w,如果文件存在，会将文件原内容覆盖掉")
f.close()

f = open("新文件.txt", mode='r', encoding="ANSI")
# content = f.read(3)   # 读取文件所有内容，可以指定数字，只读3个字母
# content = f.readline()  # 每次读取一行
content = f.readlines()  # 读取全部内容，每一行作为列表的一个元素
print(content)
f.close()

# 遍历读取的文件
for tmp in open("新文件.txt", mode='r', encoding="ANSI").readlines():
    print(tmp)

# with方式操作文件，可以不用关闭文件，会自动关闭
# 推荐用with方式操作文件
with open("新文件.txt", mode='r') as f:
    for line in f.readlines():
        line = line.strip("\n").replace("? ?", " ") # 文件里有些? ?，可以替换一下删掉
        # 去掉文件本身的空行
        if line == "":
            continue
        print(line)
        # time.sleep(0.1)

import os

# mkdir 只能创建一级路径
# os.mkdir("file/dir1/dir2/") × 不可以
with open("file/文本文件.txt", mode='w') as fw:
    fw.write("让我们荡起双桨 小船儿推开波浪bai 海面倒映着美丽的白塔")

import os
# makedirs 创建多级目录:建议使用
# os.makedirs("file/dir1/dir2/") √
with open("file/dir1/dir2/文本文件.txt", mode='w') as fw:
    fw.write("让我们荡起双桨 小船儿推开波浪bai 海面倒映着美丽的白塔")

import os
# 给一个路径，给一个路径名：相加操作得到完整路径
# os.makedirs("file/dir1/dir2/", exist_ok=True)如果文件存在会无法再创建报错，所以使用exist_ok进行判断
path = "file/dir1/dir2"
file_name = "文本文件.txt"
full_path = path + file_name
print("路径合并后", full_path)
with open(full_path, mode='w') as fw:
    fw.write("让我们荡起双桨 小船儿推开波浪bai 海面倒映着美丽的白塔")

# 因为上面的路径拼接方式，最后一级路径可能没有/，所以就会与文件名合起来组成文件名
# 路径拼接推荐使用方式：会自动给路径后加/，防止错乱
path = "file/dir1/dir2"
file_name = "文本文件.txt"
full_path = os.path.join(path, file_name)
print("路径合并后2", full_path)

# 获取某路径下所有文件
# 将当前路径下所有的文件组织成列表的形式
# 就是没有访问更深级的目录，只返回了当前能看的文件和文件夹的名字
path = "D:\python_code\python\day4"
print(os.listdir(path))

九、随机数

在这里插入图片描述要是运行出现上图问题，大概是编译器的问题，在py文件最上边加上# encoding:utf-8即可，如果没问题就不用加了

import random
import string

l1 = ["石头", "剪刀", "布", 4]
# random.choice 从具体的值中随机挑值出来
print(random.choice(l1))

import string
import random

# join：将列表中的元素 按照一定的形式连接 为 一个字符串
code = [1, "a", "A", "c"]
code = [str(tmp) for tmp in code]
# 将列表中的元素 按照一定的形式连接 为 一个字符串
res = "_".join(code) # 引号里边就是按什么方式连接
print(res) # 1_a_A_c

# 练习：生成验证码（共4位数，包含字母和数字）
random_sample=''.join(random.sample(string.ascii_letters+string.digits,4))
print(random_sample)