day07-面向对象编程

最新推荐文章于 2024-07-30 21:09:58 发布
最新推荐文章于 2024-07-30 21:09:58 发布
阅读量83 收藏
点赞数
分类专栏： python自动化运维-py27 文章标签： python json 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41383195/article/details/125969796
版权

今日内容

序列化模块

json模块

json是一种通用的数据传输格式,本质就是一个字符串.
序列化(dump/dumps)和反序列化(load/loads)

import json
dic = {'北京':{'朝阳':{},'海淀':{}}}
text= json.dumps(dic,ensure_ascii=False)   # 序列化的过程 把字典/其它数据类型转换成字符串 
# 如果字典中有中文,希望写入文件的数据也显示为中文,就需要添加参数ensure_ascii=False
print(text)
with open('city',mode = 'w',encoding='utf-8') as f:
    f.write(text)

with open('city',encoding='utf-8') as f:
    str_d = f.read()
    print(str_d)
    dic = json.loads(str_d)
print(dic)

//和文件操作时dump和load方法可简化步骤
import json
lst = ['alex',1,2,3]
with open('file','w',encoding='utf-8') as f:
    json.dump(lst,f)

import json
with open('file',encoding='utf-8') as f:
    ret = json.load(f)
    print(ret)

pickle模块

pickle和json的区别
pickle 支持python中的几乎所有数据类型,但是只能python一种语言中使用
json   支持所有的语言,但只支持有限的数据类型

import pickle
dic = {'北京':{'朝阳','昌平'},('天津','河北'):[1,2,3]}
ret = pickle.dumps(dic)
print(ret)
d = pickle.loads(ret)
print(d)

with open('pickle_file','wb') as f:
    pickle.dump(dic,f)
with open('pickle_file', 'rb') as f:
    ret = pickle.load(f)
    print(ret)

面向对象

初识面向对象

什么是类?       一系列具有相同属性和相似方法的事物的抽象
什么是对象?     一个带有具体属性值的类的实例
什么是实例化?   通过类创造对象的过程

面向对象语法

class Person:   # Person是类
    def __init__(self,name,hp,ad,sex,job):
       self.username = name
       self.hp = hp
       self.ad = ad
       self.sex = sex
       self.job = job

alex = Person('alex',100,5,'不详','乞丐')   # alex是对象 这是实例化的过程

class Person:
    def __init__(self,name,hp,ad,sex,job):
       self.username = name
       self.hp = hp
       self.ad = ad
       self.sex = sex
       self.job = job

class Dog:
    def __init__(self,name,kind,hp,ad):   # 初始化方法
      self.name = name
      self.kind = kind
      self.hp = hp
      self.ad = ad
    def bite(self,person):
        person.hp -= self.ad
        print('%s咬了%s,%s掉了%s点血'%(self.name,person.username,person.username,self.ad))    
        # 谁在类的外部调用了这个方法,方法中的第一个self参数就是谁
alex = Person('alex',100,5,'不详','乞丐')
旺财 = Dog('旺财','teddy',2000,300)
二饼 = Dog('二饼','哈士奇',10000,500)
二饼.bite(alex)     # Dog.bite(二饼,alex)
print(alex.hp)





class  Fruits:
    discount = 0.8  # 折扣  # 类变量 静态变量
    def __init__(self,name,price):  # 实例方法 初始化方法
        self.name = name    # 实例变量 属性
        self.pri = price
        self.price = Fruits.discount * self.pri
    def attack(self):pass   # 自定义实例方法
    def bite(self):pass     # 自定义实例方法
apple = Fruits('苹果',5)
banana = Fruits('香蕉',7)
栗子 = Fruits('栗子',4)
李子 = Fruits('李子',10)
pear = Fruits('梨',2)
print(apple.price)
print(李子.price)
print(apple.pri * Fruits.discount)
print(pear.pri * Fruits.discount)

# 类名一共有三个作用:
#     可以调用类中的变量 Fruits.discount
#     实例化创建一个对象 Fruits('苹果',5)
#     调用一个方法(现在不常用):类名.方法名()

# 对象名
#     查看对象的属性 对象名.属性
#     调用对象的方法 对象名.方法名()

# 类和对象和实例和实例化
#     什么是类 ? Dog Person Fruits
#     什么是对象 ? alex 二饼 旺财 苹果 李子
#     什么是实例 ? 对象就是实例
#     实例化 是一个动词 类创造实例的过程叫做实例化
#         对象 = 类名() 实例化





class A:
#     静态变量 = '值'
    def __init__(self,属性):
        self.属性名 = 属性

    def show(self):
        print('展示一下所有的属性')

a = A('参数')   # 对象a\
print(a.静态变量) # 对象可以引用类的命名空间中的内容 包括方法和静态变量

# 类的命名空间中
#     静态变量
#     方法
# 对象的命名空间中
#     对象指针
#     实例变量/对象的属性

class Person:
    sum = 0   # 全家人的工资总和为0
    def __init__(self):
        self.salary = 1000

# 一家人
father = Person()
mother = Person()
mother.age = 18
print(mother.age)
# print(mother.sum)
# print(mother.salary)
Person.sum += mother.salary    # 用对象修改静态变量只要用到赋值,相当于在自己的空间中新建
print('-->',mother.sum)
print('person -->',Person.sum)

Person.sum += father.salary
print('-->',father.sum)
print('-->',mother.sum)
print('person -->',Person.sum)


例题:
写一个类 ,统计一共实例化了多少个变量?
class Person:
    count = 0
    def __init__(self):
        Person.count +=1

alex = Person()
print(alex.count,Person.count)
wusir = Person()
print(alex.count)
print(wusir.count)
print(Person.count)  # 2


class A:
    num = 0
    def __init__(self):
        self.num += 1

a1 = A()
a2 = A()
a3 = A()
print(A.num)   # 0
print(a1.num,a2.num,a3.num)  # 1


class A:
    lst = []
    def __init__(self):
        self.lst.append(1)

a1 = A()
a2 = A()
a3 = A()
print(A.lst)
print(a1.lst)
print(a2.lst)
print(a3.lst)

class A:
    lst = []
    def __init__(self):
        self.lst = [1]

a1 = A()
a2 = A()
a3 = A()
print(A.lst)
print(a1.lst)
print(a2.lst)
print(a3.lst)

class A:
    lst = [0]
    def __init__(self):
        self.lst[0] += 1

a1 = A()   # [1]
print(A.lst)
a2 = A()   # [2]
print(A.lst)
a3 = A()   # [3]
print(A.lst)
print(a1.lst)
print(a2.lst)
print(a3.lst)

# 操作静态变量的时候
# 如果是查看用类或者对象都可以
# 如果是修改 只用类名进行修改
# 不要在对象的空间中创建一个和类变量同名的实例变量

class Student:
    '''
    这是一个学生类,描述了学生的选课和查看分数的行为
    '''
    def __init__(self,id,name,sex,phone):
        self.id = id
        self.name = name
        self.sex = sex
        self.phone = phone
        self.course_lst = []

    def choose_course(self):
        print('选择课程')

    def show_score(self):
        print('查看分数')

print(Student.__dict__)   # __dict__ 内置的属性 可以查看类或者对象的命名空间中存储了什么
老王 = Student(1,'老王','male','110119120999')
print(老王.__dict__)

组合

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return self.r**2*pi
    def perimeter(self):
        return 2*self.r*pi

# 圆环类型
    # 属性 :大圆半径 小圆半径
    # 实现计算面积
    # 计算周长
class Ring:
    def __init__(self,outer_r,inner_r):
        c1 = Circle(outer_r)
        c2 = Circle(inner_r)
        self.outer = c1    # 如果一个属性和一个对象联系在一起 组合
        self.inner = c2
    def area(self):
        return self.outer.area() - self.inner.area()
    def perimeter(self):
        return self.outer.perimeter() + self.inner.perimeter()
# r1 = Ring(10,5)
# print(r1.area())
# print(r1.perimeter())


class Ring:
    def __init__(self,outer_r,inner_r):
        self.outer_r = outer_r
        self.inner_r = inner_r
    def area(self):
        o_area = self.outer_r**2 * 3.14
        i_area = self.inner_r**2 * 3.14
        return o_area - i_area
    def perimeter(self):
        return self.outer_r*2*3.14 + self.inner_r*2*3.14

组合练习

# 学生 : 姓名 性别 年龄 所学习的课程
class Student:
    def __init__(self,name,sex,age,course):
        self.name = name
        self.sex = sex
        self.age = age
        self.course = course
class Course:
    def __init__(self,cname,period,price):
        self.name = cname
        self.period = period
        self.price = price

php = Course('php','5 months',18000)
python = Course('python','6 months',19800)
go = Course('go','5 months',8999)
tang = Student('汤青松','不详',80,python)
print(python.price)
print(tang.course.price)

wang = Student('老王','不详',80,'php')
tang.course = python
wang.course = python

print(tang.course.price)
print(wang.course.price)
python.price = 21800
print(tang.course.price)
print(wang.course.price)


class Student:
    def __init__(self,name,sex,age,course_price,course_period,course_name):
        self.name = name
        self.sex = sex
        self.age = age
        self.course_price = course_price
        self.course_period = course_period
        self.course_name = course_name

tang = Student('汤青松','不详',80,19800,'5 months','python')
wang = Student('老王','不详',80,19800,'5 months','python')
print(tang.course_name)
print(wang.course_name)
wang.course_price = 21800
tang.course_price = 21800

class A:
    def __init__(self,name):
        self.name = name

a = A('alex Li')
# a是对象,是A的对象
a.name # 是对象a的属性
# a.name是个字符串'alex Li'
# 'alex Li'是str的对象
'alex Li'.split(' ')
a.name.split(' ')

继承

class Animal:
    def __init__(self,hp,ad,name):
        self.hp = hp
        self.ad = ad
        self.name = name
    def eat(self):
        print('%s执行我啦'%self.name)
        self.hp += 5

class Person(Animal):
    def __init__(self,name,hp,ad,sex,job):
        self.sex = sex    # 人特有的
        self.job = job    # 人特有的
        Animal.__init__(self, hp, ad, name)
    def attack(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s,%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

class Dog(Animal):
    def __init__(self,name,kind,hp,ad):   # 初始化方法
        Animal.__init__(self,hp,ad,name)
        self.kind = kind  # kind是狗特有的
    def bite(self,person):
        person.hp -= self.ad
        print('%s咬了%s,%s掉了%s点血'%(self.name,person.name,person.name,self.ad))

二饼 = Dog('二饼','哈士奇',3000,150)
print(二饼.__dict__)
alex = Person('alex',100,5,'不详','乞丐')
print(alex.__dict__)


# A和B类都需要调用相同的方法
# 创建父类C,把相同的方法放到C类中
# A和B继承C A(C)  B(C)
# A的对象和B的对象就可以直接调用C中的方法了

# A和B中有相同的方法,一部分功能相同,还有不同的部分
# 创建父类C, 把相同的部分放到C类的方法中
# 在A\B中保留不同的部分,
# 然后分别在A\B中调用C类的方法即可



# 序列化
    # json
        # json类型 : '{"key":[1,2,3]}'
        # 所有语言通用的\支持的数据类型有限
        # 序列化的结果是字符串 : 可视化
        # json不支持多次dump
    # pickle
        # python自己用\支持python中几乎所有的数据类型
        # 结果是二进制 :看不懂的
        # pickle天生支持多次dump和load
# 面向对象
    # 类 class 类型
        # 类变量
        # 实例方法 __init__ attack bite
        # 类指针 - 指向父类
    # 对象
        # 对象指针
        # 实例变量 self.name slef.age
    # 组合
        # 一个对象作为一个属性
        # self.course = python
    # 继承
        # class Foo:pass
        # class Son(Foo):pass
        # Son是子类\派生类  Foo是父类\超类\基类
        # 继承的特点:
            # 如果多个类都用到了相同的方法\属性
            # 我们应该把这些共用的方法抽象到他们的父类中去
            # 减少代码的冗余
        # 先写子类的功能,发现重复才创建父类
        # 子类自己没有某一个方法或者属性的时候用父类的
            # 如果自己有 还像用父类的 在子类中直接调用父类的方法就可以了

super 语法

class Course:
    course_lst = []
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

class Role:
    def __init__(self,name):
        self.name = name
    def show_course(self):
        for item in Course.course_lst:
            print(item.name,item.period,item.price)

class Student(Role):
    def __init__(self,name):
        # Role.__init__(self,name)
        # super(Student, self).__init__(name)
        super().__init__(name)   # super也可以帮助我们找到父类
        self.courses = []

class Manager(Role):pass

python = Course('python','6 months',19800)
linux = Course('linux','5 months',17800)
Course.course_lst = [python,linux]   # 所有的可选课程

m = Student('alex')
print(m.name)
m.show_course()

多继承

class A:
    pass
    def func(self):
        print('in A')

class C(A):
    pass
    # def func(self):
    #     print('in C')

class B(A):
    pass
    # def func(self):
    #     print('in B')

class D(B):
    pass
    # def func(self):
    #     print('in D')
class E(C):
    pass
    # def func(self):
    #     print('in E')

class F(D,E):
    pass
    # def func(self):
    #     print('in F')
# f = F()
# f.func()
print(F.mro())  # 查看多继承中的继承顺序
# 顺序 遵循C3算法

# 重新认识super
# class D:
#     def func(self):print('D')
# class C(D):
#     def func(self):
#         super().func()
#         print('C')
# class B(D):
#     def func(self):
#         super().func()
#         print('B')
# class A(B,C):
#     def func(self):
#         super().func()
#         print('A')

# a = A()
# a.func()

# b = B()
# b.func()


# 在单继承中 super的作用就是找父类
# 在多继承中 super是找mro顺序的下一个类

object

# object类
# 在python3.x的所有类都是object的子类
# 所以对于一些内置的方法会写在object类中
# 如果子类不定义,在调用的时候最终会调用object类中的方法
# 就不会让程序出现不必要的错误了
# __init__方法就是其中的一个例子

# 所有继承了object类的类 ---- 新式类
# 在python2中 不继承object类的都是 经典类

# class A(object):
#     pass    # 新式类

# class A:
#     pass   # 经典类 :在多继承中遵循深度优先
             # 经典类中没有super和mro方法

# 把面向对象的基础知识掌握之后才来深入的了解复杂的继承关系

# 所有的py3中 的类都继承object 是新式类
# 在继承中 遵循 广度优先的 C3算法
# 也可以使用mro来查看继承顺序
# super这个方法 可以帮助我们查找到mro顺序中的下一个类

封装

# 三大特定 : 继承 封装 多态
# 封装
# 人狗大战
    # 规范的创建对象
        # 创建的所有人的属性名都能一致
        # 把所有的方法装进一个角色中
# 广义上的封装 : 把方法和变量都封装在类中
              # 在类的外部就不能直接调用了
# 狭义上的封装 : 在类的外部干脆不能调用了

class Student:
    def __init__(self,name):
        self.__name = name  # 把name这个属性私有化了
    def get_name(self):
        return self.__name
    def set_name(self,value):
        if type(value) is str:
            self.__name = value
老王 = Student('老王')
print(老王.get_name())
老王.set_name(1010101010100010)
print(老王.get_name())
print(老王.__name)


class Person:
    def __init__(self,username,password):
        self.username = username
        self.__password = password

p = Person('alex','alex3714')
print(p.username)

class A:
    __val = []
    def __init__(self):
        print(A.__val)
A()
print(A.__val)

class A:
    def func(self):
        self.__aaa()
    def __aaa(self):
        print('aaa')

a = A()
a.func()

# 在类的内部 ,实例变量(对象属性)可以变成私有的,类变量可以变成私有的,实例方法也可以变成私有的
# 一旦变成私有的就只能在类的内部使用,而不能在类的外部使用了

# 私有化到底是怎么做到的 :只是在类内部使用的时候对名字进行了包装 变成了_类名xxxx
# class B:
#     __abc = 123  # _类名xxxx
#     print(__abc) # 使用 都会由这个类进行一个变形 _类名xxxx
# print(B.__dict__)
# print(B.__abc)

# 私有的变量不能被继承
class A:
    def __func(self):   # _A__func
        print('in A')

class B(A):
    def wahaha(self):
        self.__func()   # _B__func

b = B()
b.wahaha()

# 毕业练习题
class A:
    def __init__(self):
        self.__func()    # self._A__func
    def __func(self):   # _A__func
        print('in A')

class B(A):
    def __func(self):   # _B__func
        print('in B')

b = B()

# 在哪个类中调用方法,就在这个私有方法之前加上这个类中的变形
# 和self本身是谁的对象都没有关系

面向对象的装饰器

class Student:
    def __init__(self,name,birth):
        self.name = name
        self.birth = birth

    @property     # 将一个方法伪装成属性
    def age(self):
        import time
        return time.localtime().tm_year - self.birth
alex = Student('alex',1930)
print(alex.age)   # 名词




class Circle:
    def __init__(self,r):
        self.r = r

    @property
    def area(self):
        return 3.14*self.r**2

    @property
    def perimeter(self):
        return 2*3.14*self.r

c = Circle(10)
print(c.area)
print(c.perimeter)

classmethod和staticmethod

class Student:
    def __init__(self,name):
        self.name = name
    @staticmethod     # 声名login方法是一个静态方法 ,不必传任何默认的参数
    def login(flag):
        print('登录程序',flag)
        username = input('>>>')
        stu = Student(username)
        return stu
# 要想调用login 必须先有对象
# 要想创建对象 必须用户先输入名字
# 得调用登录之后才开始input

# 不必实例化就可以调用的login方法 不需要传递对象作为参数,就定义这个方法为静态方法
obj = Student.login(flag = True)  # 用类名可以直接调用这个方法了
print(obj.__dict__)

class Manager:
    def __init__(self,name):
        self.name = name
    @classmethod     # 装饰当前这个方法为一个类方法,默认传参数cls,表示当前所在的类名
    def login(cls):
        username = input('>>>')
        stu = cls(username)
        return stu

obj = Manager.login()  # 用类名可以直接调用这个方法了
print(obj.__dict__)


class A:
    def func(self):  pass  # 实例方法 self作为默认参数,需要用对象来调用

    @classmethod
    def func1(cls):  pass  # 类方法 cls作为默认参数,可以用类名来调用

    @staticmethod
    def func1():  pass  # 静态方法方法 没有默认参数,可以用用类名来调用

内置方法

# 凡是数据类型 都会或多或少带有一些 双下方法
#  __xxxx__ 魔术方法 内置方法
# 调用的时候总是不好好调用

# 'abc'.split('b')  # 正经调用str类型的split方法
# ret = 'abc'.__add__('efg')
# print(ret)
# print('abc' + 'edf')

# __str__
class Course:
    course_lst = []
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price
    def __str__(self):
        return '%s,%s,%s'%(self.name,self.period,self.price)
# python = Course('python','6 months',19800)
# linux = Course('linux','5 months',17800)
# Course.course_lst = [python,linux]
# for course in Course.course_lst:
#     print(course)  # 打印一个对象总是打印内存地址,这个数据对我们来说没有用
    # 打印这个对象的时候查看这个对象的相关信息
    # print(obj) 打印一个对象 总是调用obj.__str__(),打印的是这个方法的返回值

__new__
class A(object):
    def __new__(cls, *args, **kwargs): # 构造方法 开辟空间 构造对象的方法
        obj  = object.__new__(cls)
        return obj

    def __init__(self):       # 初始化方法
        print('init : ',self)
        self.name = 'alex'

# 1.创建一块空间 : __new__
# 2.调用init
# A()

# 算法导论 - 微观
# 23个设计模式 - 宏观

# java语言

# 单例模式 - 只创建一个实例
# class A:
#     pass
#
# a1 = A()
# a2 = A()
# print(a1)
# print(a2)

class Singleton:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

    def __init__(self,name):
        self.name = name

obj1 = Singleton('alex')
obj2 = Singleton('wusir')
print(obj1.name,obj2.name)

# 什么是单例模式?
# 怎么实现
    # 用new实现
    # new做什么用 在什么时候执行

反射

# 什么是反射 
    # 通过字符串使用变量(包括 类 函数 方法 各种变量)
# 如果有一个变量名 是字符串数据类型的 你能获取到这个变量的值么?
class Student:
    def __init__(self):
        self.name = 'alex'
        self.age = 80
        self.gender = 'male'

    def show_info(self):
        print('%s,%s'%(self.name,self.age))
stu = Student()
content = input('>>>')b
if hasattr(stu,content):
    name = getattr(stu,content)   # stu.show_info  name=showinfo的地址
    if callable(name):
        name()
    else:
        print(name)
if content == 'name':
    print(stu.name)
elif content == 'age':
    print(stu.age)
elif content == 'gender':
    print(stu.gender)

# 对象的反射
    # hasattr(对象,'属性名') 判断对象是否有这个属性,有返回True
    # getattr(对象,'属性名') 返回对象中属性名对应的值
# 反射属性
    # val = getattr(对象,'属性名')
        # val就是属性的值
# 反射方法
    # val = getattr('对象','方法名')
        # val就是方法的地址
        # val() ==> 调用方法

# 类的反射
class A:
    role = 'China'
print(getattr(A,'role'))  # 用类获取类的变量

# 模块的反射
import time
print(time.time())
print(getattr(time,'time')())

# 反射
    a.b ===== getattr(a,'b')

name = 'alex'
age = 84
def func(*args):
    print('wahaha')
class Student:pass


import sys
print(getattr(sys.modules[__name__],'name'))
print(getattr(sys.modules[__name__],'age'))
getattr(sys.modules[__name__],'func')(1,2,3)
print(getattr(sys.modules[__name__],'Student'))

反射的作用

class Studnet:
    opt_lst = [('查看可选课程', 'show_courses'),
               ('选择课程', 'choose_course'), ('查看已选课程', 'show_selected_course')
        , ('退出', 'quit')]
    def __init__(self,name):
        self.name = name
        self.courses = []
    def show_courses(self):
        print('查看一共有多少门课程')

    def choose_course(self):
        print('选择课程')

    def show_selected_course(self):
        print('查看已经选择的课程')

    def quit(self):
        print('退出')

stu = Studnet('alex')
for index,opt in enumerate(Studnet.opt_lst,1):
    print(index,opt[0])
num = int(input('请输入您要选择的操作序号:'))
if hasattr(stu,Studnet.opt_lst[num-1][1]):
    getattr(stu,Studnet.opt_lst[num-1][1])()

# 选课系统
    # 改进 反射
    # classmethod/staticmethod装饰器

模块和包

# 模块
# 什么是模块?
    # py文件
    # 自定义模块 把多行代码拆成多个文件 使得代码更加严谨清楚

# 导入模块的话
    # from 模块 import 变量
    # import 模块
        # 模块.变量访问变量的值
# 导入包
    # from 包.包.包 import 模块
        # 模块.xxx直接获取值
    # import 包.包.模块
        # 包.包.模块,xxx获取值
# 无论是导入模块还是包,必须要保证被导入的模块和包所在路径在sys.path的列表中

logging模块

# import logging
# fh = logging.FileHandler(filename='xxx.log',encoding='utf-8')
# fh1 = logging.FileHandler(filename='xxx2.log',encoding='utf-8')
# sh = logging.StreamHandler()
# logging.basicConfig(level=logging.INFO,
#                     handlers=[fh,sh,fh1],
#                     datefmt='%Y-%m-%d %H:%M:%S',
#                     format='%(asctime)s - %(name)s[%(lineno)d] - %(levelname)s -%(module)s:  %(message)s')
# logging.debug('debug message')      # 情况越轻
# logging.info('info message')        # 信息类的日志
# logging.warning('warning message')
# logging.error('error message')
# logging.critical('critical message')

# logging日志分为5个等级
# 默认只显示warning等级以上的信息
import logging
from logging import handlers
sh = logging.StreamHandler()
rh = handlers.RotatingFileHandler('myapp.log', maxBytes=1024,backupCount=5)
fh = handlers.TimedRotatingFileHandler(filename='myapp2.log', when='s', interval=5, encoding='utf-8')
logging.basicConfig(level=logging.INFO,
                    handlers=[rh,fh,sh],
                    datefmt='%Y-%m-%d %H:%M:%S',
                    format='%(asctime)s - %(name)s[%(lineno)d] - %(levelname)s -%(module)s:  %(message)s')
while True:
    logging.WARNING('')

异常处理

opt_lst = [1,2,3,4]
try:
    num  = int(input('请输入序号 :'))
    print(opt_lst[num-1])
except ValueError:
    print('请输入一个数字')
except IndexError:
    print('请输入1-4之间的数字')
金火水木土
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自学Python day6--------面向对象编程（类和实例）
hident的博客
02-25 3121
自学Python day6——–面向对象编程（类和实例）1.类和实例 面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。以Student类为例：class Student(object): passclass之后是类名，通常以大写字母开头，之
day07-面向对象1
08-04
1.4 封装【概念与实现】封装是面向对象编程的核心特性之一，它将数据和操作数据的方法绑定在一起，作为一个相互依赖的整体——对象。封装的目的是隐藏对象的属性和实现细节，仅对外提供公共访问方式。实现封装的步骤...
Day08 - 面向对象编程基础
Laic Zhang的博客
04-28 1200
Day08 - 面向对象编程基础 活在当下的程序员应该都听过“面向对象编程”一词，也经常有人问能不能用一句话解释下什么是“面向对象编程”，我们先来看看比较正式的说法。 把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）...
day07-Java面向对象基础
ZHUSHANGLIN的博客
05-22 1058
首先每一部电影，都包含这部电影的相关信息，比如：电影的编号（id）、电影的名称（name）、电影的价格（price）、电影的分数（score）、电影的导演（director）、电影的主演（actor）、电影的简介（info）。为了去描述每一部电影，有哪些信息，我们可以设计一个电影类（Movie），电影类仅仅只是为了封装电影的信息，所以按照JavaBean类的标准写法来写就行。return id;
day05-面向对象内存原理和数组
qq_74289024的博客
05-12 950
1.new 对象会创建堆内存2.声明变量 只创建栈内存3.多个变量可以指向一个对象4.局部变量存在栈内存，用完就消失，作用范围仅限方法或者局部{}范围5.成员变量会存在堆内存，随着对象消失才消失，作用范围类范围是面向对象三大特征之一（封装，继承，多态是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的eg:相当于把水放在一个水杯中,只能通过水杯出水口喝水。外界是无法拿到水,只能通过一个公共的出口取水。构造方法是一种特殊的方法作用：创建对象。
自学Python day6--------面向对象编程（访问限制）
hident的博客
02-25 399
自学Python day6——–面向对象编程（访问限制）通过Student()创建的实例对象可以通过直接调用变量的方法来操作内部的数据，这样就隐藏了内部的复杂逻辑，而且从Studen的类定义，外部代码哎是可以自由的修改一个实例的属性比如：Jim = Student('Jim',77) Jim.score 77 Jim.score = 55 Jim.score 55若想要内部的属性不被外部的实例访问，
day08-面向对象-类和对象
12-12
本资源摘要信息涵盖了面向对象编程的基础知识点，包括类和对象的概念、面向对象编程的特点、类和对象的关系、面向对象编程的三个基本特征、面向对象和面向过程的比较等。 一、类和对象的概念 在面向对象编程中，类...
day11-面向对象-static&继承
12-12
在Java中，`static`关键字是面向对象编程中的一个重要特性，它与继承一起构成了Java的基础知识。 一、static关键字 1. 静态变量（类变量） `static`关键字用于声明类变量，这些变量在类的所有实例之间共享。这...
day12-面向对象-static&继承
12-12
接下来，我们讨论继承，这是面向对象编程的另一个关键特性。继承允许一个类（子类）从另一个类（父类）那里获取属性和方法。这样做可以实现代码复用，让子类专注于添加其特有的功能，而不是重复父类已有的功能。在...
day09-面向对象-封装&构造方法
12-12
面向对象是编程语言中一种重要的思想，特别是在Java中得到了广泛的应用。本节主要讲解了面向对象的两个核心概念：封装和构造方法。 首先，我们来深入理解一下成员变量和局部变量的区别： 成员变量，也称为类变量，...
【Python】pandas：排序、重复值、缺省值处理、合并、分组
yannan20190313的博客
07-30 509
【Python】pandas：排序（sort_index,sort_values,nsmallest,nlargest）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 994
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1093
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 268
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
十个好用到爆炸的Python技巧
最新发布
qq_36807888的博客
07-30 514
生成器表达式与列表推导式类似，但它创建的是一个迭代器，而不是一个完整的列表。zip(names, ages) 创建一个迭代器，该迭代器生成由 names 和 ages 列表中对应位置的元素组成的元组。defaultdict(int) 创建一个字典，如果访问的键不存在，则默认值为 0 (int 类型的默认值)。惰性求值: 元素是在需要时才计算的，而不是预先计算好存储在内存中，这在处理包含复杂计算的序列时非常有用。wrapper 函数是装饰器函数内部定义的函数，它调用被装饰的函数，并将结果转换为大写。
安卓手机部署大模型实战
奇舞周刊
07-25 1138
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
Python面试题：如何使用WebSocket实现实时Web应用
bigorsmallorlarge的专栏
07-30 293
通过上述步骤，你可以使用 Django Channels 和 WebSocket 创建一个简单的实时 Web 应用。Django Channels 提供了强大的功能，使得在 Django 中实现实时功能变得更加容易。你可以在此基础上扩展，添加更多功能和复杂的逻辑。
Python(C++)大尺度分层边值时变图统计推理并行算法
跨学科知识视角展现
07-29 937
:dart:分层结构制定生成模型 | :dart:贝叶斯模型选择程序 | :dart:分层结构图的信息性 | :dart:分层模型适应实值边协变量的网络 | :dart:分层模型适应时变网络，划分层对应于检测变化点 | :dart:定义两种版本随机块模型：:pen:具有边缘协变量模型概率分布，分层图总似然 | :pen:独立分层模型分层图数学似然计算 | :dart:推理算法：大图形尺度并行计算算法，过滤暂时被遮蔽的节点和边
Python入门知识点 10--闭包与装饰器
@网工小赵的博客
07-30 639
什么情况下会用到装饰器特性:在不修改源代码的基础上,给函数加功能。
Java面向对象编程思想详解
面向对象思想是 Java 编程语言的核心思想之一，它是描述现实世界中对象的交互和关系的编程范式。面向对象思想的三个基本特征是封装、继承和多态。 封装 封装是面向对象思想的第一个特征，它是指将类的属性封装起来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值