网站导航
> 技术文档 > 小杰python（seven day finally）——历经千帆，归来仍是少年。

小杰python（seven day finally）——历经千帆，归来仍是少年。

网友: 技术文档 2025-07-26 20:30:00

1.python语言—解释型语言

语言发展：

机器语言（0，1）---汇编语言---高级语言（C 面向过程）---面向对象（python）

（1）.面向过程

分析解决问题的步骤，然后逐步实现

例：小白买电脑

        网上查资料

        根据自己预算和需求定电脑型号 华硕天选

        去线下门店实地考察

        找业务员砍价，要赠品， 付款

（2）.面向对象

找出问题，把任务分配出去，交给别人完成，我只求最终结果

例：小白买电脑

        找一个靠谱的电脑高手

        给钱交易

2.面向对象的技术点

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 方法：类中定义的函数。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 局部变量：定义在方法中的变量，只作用于当前实例的类。
  • 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
  • 实例化：创建一个类的实例，类的具体对象。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

（1）类的使用

        类的创建

格式：

class 类名：

        def__init__(self,属性种类)：

                内容

        def 行为函数名(self):

                内容

demo：

class Car: \"\"\" 记录一些好看的车 \"\"\" num = 0 def __init__(self, color, price): self.color = color self.price = price Car.num += 1

num变量是一个类变量，他的值会在类的所有实例之间共享

self:是一个参数，表示实例化对象，存储的是地址

Car.num访问__init__函数也叫类的构造函数

        访问方法

用内置函数调用的方式（.）

demo:

class Car: \"\"\" 记录一些好看的车 \"\"\" num = 0 def __init__(self, color, price): self.color = color self.price = price def jie(self): print(f\'{self.color}型很漂亮，售价{self.price}万元\')# 创建了Car类的第一个对象xmi = Car(\"gray\", 21)xmi.jie()# 输出：gray型很漂亮，售价21万元

        类属性的增删改

1.直接赋值增改

2.内置函数增删改

hasattr：判断属性是否存在

getattr: 获取属性值

setattr: 修改属性值；如果属性不存在，会创建新属性

delattr:删除属性

# 创建了Car类的第一个对象xmi = Car(\"gray\", 21)# 调用类中的方法xmi.its()# 添加typ属性xmi.typ = \'SUV\'# 修改colors属性xmi.color = \'green\'# 删除price属性del xmi.price# hasattr：判断属性是否存在# print(hasattr(xmi, \"typ\"))# getattr: 获取属性值# print(getattr(xmi, \"color\"))# setattr: 修改属性值；如果属性不存在，会创建新属性setattr(xmi, \"color\", \"yellow\")print(getattr(xmi, \"color\"))setattr(xmi, \"co\", \"yel\")# delattr:删除属性delattr(xmi, \"co\")print(getattr(xmi, \"co\"))

（2）python内置类属性

python 3.n,中所有的类都有一个共同父类，叫object类(顶级父类)

        内置类属性
  • __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
  • __doc__ :类的文档字符串()
  • __name__: 类名
  • __module__: 类定义所在的模块（类的全名是\'__main__.className\'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
  • __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组
print(\"类名：\", Dog.__name__)print(\"类的文档字符串\", Dog.__doc__)print(\"类定义所在的模块\", Dog.__module__)print(\"类的所有父类构成元素\", Dog.__bases__)print(\"类的属性\", Dog.__dict__)

        类的继承

        面向对象的编程带来的一个好处是代码的重用，实现的方法之一是类的继承

        类可以被继承，也可以继承别的类，被继承的类为父类，继承的类叫子类；继承过程中，子类会继承父类所有的属性和行为，一个父类可以有多个子类，一个子类可以有多个父类。

单继承：一个类只有一个父类

class 子类名(父类):

class Da: \'\'\' 定义父类 \'\'\' num = 1 def __init__(self): print(\'调用父类的构造函数\') def house(self): print(\'父类有3个窝\') def NewNum(self,n): Da.num = n print(f\'父类现在有{Da.num}\')class Xiao(Da): \'\'\' 定义子类 \'\'\' def __init__(self): # 没这个就会调用父类的 print(\'调用子类的构造函数\') def basin(self): print(\'子类有两个盆\')xb = Xiao() # 子类实例化xb.house() # 调用父类的方法xb.basin()xb.NewNum(5) # 调用父类的方法 - 设置、获取属性值\'\'\'调用子类的构造函数父类有3个窝子类有两个盆父类现在有5\'\'\'
多继承：一个类有多个父类

如果子类和多个父类有相同的属性或方法，顺序：

子类 > 从左向右第一个父类 > 从左向右第二个父类

demo：

class A: def na(self): print(\'A\') def hobby(self): print(\'跑步\')class B: def na(self): print(\'B\') def play(self): print(\'够级\')class C(A, B): passc = C()c.na() # A 首先继承第一个父类c.hobby() # 跑步print(issubclass(C, A)) # Tureprint(issubclass(A, C)) # False# 判断第一个参数（C）是不是第二个参数(A)的子类print(isinstance(c, A)) # Ture# c是A，B，C的实例化对象

issubclass( ) 判断第一个参数是否是第二个参数的子类

isinstance( ) 判断第一个参数是否是第二个参数的实例化对象

        方法重写

父类中的方法不能满足子类的需求，可以在子类中重写父类的方法

不继承A

class A: def __init__(self, x, y): self.x = x self.y = y def addxy(self): print(self.x + self. y)# B 类 x y z求和class B(A): def __init__(self, x, y, z): self.x = x self.y = y self.z = z def addxy(self): print(self.x + self.y + self.z)

直接调用A的init函数，获取x y的参数值

class A: def __init__(self, x, y): self.x = x self.y = y def addxy(self): return self.x + self. y# B 类 x y z求和class B(A): def __init__(self, x, y, z): A.__init__(self, x, y) self.z = z def addxy(self): return A.addxy(self) + self.zb = B(2, 3, 4)print(b.addxy())
        基础重载方法

方法, 描述 & 简单的调用

__init__ ( self [,args...] ) 构造函数 简单的调用方法: obj = className(args)

__del__( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj

__repr__( self ) 转化为供解释器（开发者）读取的形式 简单的调用方法 : repr(obj)

__str__( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)

__cmp__ ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)        ，python3版本之后不支持

class Cat: def __init__(self, name, age): self.name = name self.age = age print(\'构造函数\') def __del__(self): print(\'析构函数\') # def __repr__(self): # return f\'名{self.name},{self.age}\' # # def __str__(self): # return f\'名{self.name},{self.age}\' def __lt__(self, other): print(self) print(other) return self.age < other.agehh = Cat(\'huahua\', 1)bb = Cat(\'baby\', 5)# print(\'12:\')# print(repr(hh))# print(str(hh))print(hh < bb) # print(hh.lessth(bb))print(\'175\', hh)print(\'176\', bb)\'\'\'# 注释前构造函数构造函数12:名huahua,1名huahua,1名huahua,1名baby,5True175 名huahua,1176 名baby,5析构函数析构函数\'\'\'\'\'\'# 注释后构造函数构造函数True175 176 析构函数析构函数\'\'\'
        运算符的重载

python3.n之后，不支持cmp方法，__ls__小于 __gt__大于 le

使用特定的符号实行操作。

__lt__ 小于

__gt__ 大于

__le__ 小于或等于

__ge__ 大于或等于

__add__ +

__sub__ -

__mul__ *

__ truediv__ /

3.多态

不同的对象对同一个方法做出不同的响应，用来设计更灵活的代码，提高代码的重复使用。

len（）

字符串：计算字符串长度

列表、元组：计算元素个数

类的继承中用的方法重写就是一种实现多态的方法

python中，鸭子模型，一只鸟走起来像鸭子、行为也像鸭子，那么这只鸟可以被称为鸭子；没有这种类型的对象，但是有另一种类型的对象，和需要的对象有同一种行为，可以把其当成没有的对象来用。

demo：

class Cat: def say(self): print(\'miao~~\')class Dog: def say(self): print(\'wang~~\')class Duck: def say(self): print(\'ga~~\')cat = Cat()dog = Dog()duck = Duck()def fun(obj): obj.say()fun(cat) # miao~~fun(dog) # wang~~fun(duck) # ga~~

4.异常处理机制

AttributeError

访问对象没有的属性

ValueError

TypeError

IndexError

try,except,else,finally等关键字组合成不同的异常处理方法。

格式：

try:

        # 可能发生异常的代码

except：

        # 异常发生后执行的代码

else:

        # 没有异常，执行此代码

finally:

        # 不管是否捕获到异常，最后都执行此代码

demo：

s1 = \"sajd\"try: print(s1 + 3)# except TypeError: # 具体查找类型错误# except Exception: # 查找任意类型错误except Exception as e: # 查找任意类型错误，并且输出（e）错误类型 print(\"捕获到异常\") print(e)# else:# print(\"没有异常\")# finally:# print(\"最终执行此代码\")print(\"hello world\")# 输出：捕获到异常can only concatenate str (not \"int\") to strhello world
        迭代器（补充）

迭代是python中访问集合中的元素的一种方式，迭代器是一个可以记住遍历位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有元素被访问完结束，迭代器只能往前

迭代器两个基本方法：iter()        next()

demo：

l1 = [1, 3, 5, 6, 8]l2 = iter(l1) # 创建一个迭代器print(next(l2)) # 1print(next(l2)) # 3for i in l2: print(i) # 5 6 8
        生成器

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

每次使用 yield 语句生产一个值后，函数都将暂停执行，等待被重新唤醒。

yield 语句相比于 return 语句，差别就在于 yield 语句返回的是可迭代对象，而 return 返回的为不可迭代对象。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句

网络标签：

相关问题