Python Learning(八)-面向对象

最新推荐文章于 2024-04-30 11:11:45 发布
最新推荐文章于 2024-04-30 11:11:45 发布
阅读量181 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zax_java/article/details/111208230
版权

Python 基础八-面向对象

八 面向对象

对象(Object)

什么是对象?

  • 对象是内存中专门用来存储数据的一块区域

  • 对象中可以存放各种数据

  • 对象由三部分组成(id,type,value)

面向对象(oop)

  • Python是一门面向对象的编程语言
  • Python中的所有操作,都是通过对象来进行的
  • 对应的是面向过程的编程语言,指的是将程序的逻辑分解为一步步的抽象来完成程序
  • 面向过程编写的代码往往只适用于一个功能,不方便扩展,可复用性低
  • 面向对象的编程语言关注的是对象而不是过程,一切都是对象
类(class)
  • 我们目前学习的对象都是Python的内置对象
  • 自定义对象(class)
  • 类,简单理解他就是一个图纸,程序中需要根据类创建对象
  • 我们称对象是类的instance实例
  • 如果多个对象是通过一个类创建的,那么我们称这些对象是一类对象
  • 自定义的类都需要使用大写字母开头,大驼峰命名法

定义一个简单的类

类创建语法:

class 类名([父类]):

​ 代码块

class MyClass():
    pass
mc=MyClass()
print(MyClass)
print(isinstance(mc,MyClass))
# __main__.MyClass
# True
mc =MyClass() #mc 就是MyClass的实例
mc_2=MyClass()

实际上类也是一个对象,就是用来创建对象的对象,可以看下每个类的type

使用类创建对象的流程 mc=MyClass()

1. 创建一个变量mc
2. 在内存中创建一个新的对象
3. 分配地址,type就等于MyClass
4. 将对象的id赋值给变量mc

现在我们通过MyClass创建的对象什么都没有,相当于一个空盒子,可以像对象中添加变量称为属性

属性语法:

对象.属性=属性值

mc.name=‘tom’

类的定义
  • 类和对象是对现实生活中的内容抽象
  • 实际上所有的事物都有俩部分构成
    1. 数据(属性)
    2. 行为(方法)
class Person:
	name='tom'
	def sayHello():
		print('Hello')
p1=Person()
p2=Person()


print(p1.name,p2.name)
p1.sayHello()
# TypeError: sayHello() takes no arguments (1 given)

属性和方法都定义在类对象中,为什么实例可以访问到类中的属性和方法

  • 属性和方法的查找流程

    1. 当我们调用一个对象的属性时,解析器会先在当前对象中寻找是否含有该属性
    2. 如果有则直接返回当前的对象的属性值
    3. 如果没有则去当前对象的类对象中去寻找,如果有则返回类对象的属性值(就是type对应的类对象)

  • 所以共有的属性和方法应该存在类对象中,实例独有的属性和方法需要自定义

    比如:人共有的吃饭/睡觉等方法是共有的,名字是自定义的

方法调用和函数调用的区别:

如果是函数的调用传几个参数就是几个参数,如果是方法的调用默认至少有一个参数.

注意:方法调用时,第一个参数由解析器自动传递,所以定义方法时,至少要定义一个形参

这里第一个参数,就是调用方法的对象本身,如果p1调的,则第一个参数就是p1对象,p2调的则第一个参数就是p2对象,一般我们都会将这个参数命名为self

class Person:
	name='tom'
	def sayHello(self):
		print(self)
p1=Person()
p1.sayHello()
print(p1)
p2=Person()
p2.sayHello()
print(p2)
#<__main__.Person instance at 0x7f688ec60638>
#<__main__.Person instance at 0x7f688ec60638>
#<__main__.Person instance at 0x7f688ec60680>
#<__main__.Person instance at 0x7f688ec60680>
对象的初始化

在类中可以定义一些特殊的方法(魔术方法),以_开头_结尾的方法

特殊方法不需要我们自己调用,会在类对象创建的时候自动调用,这样可以避免必要属性不传导致的错误.

创建对象的流程 :

  1. 创建一个变量
  2. 在内存中创建一个对象
  3. _init_(self)方法执行
  4. 将对象的id赋值给变量
一个标准类的流程
class Person:
	def __init__(self,name):
		self.name=name
	def sayHello(self):
		print('i am '+ self.name)
p1=Person('tom')
p1.sayHello()
print(p1.name)
p2=Person('jack')
p2.sayHello()
print(p2.name)
# i am tom
# tom
# i am jack
# jack

类的基本结构

class类名([父类]):

​ 公共的属性

​ #对象的初始化方法

​ def _init_(self,…):

​ …

​ def method(self):

​ …

目前对象的属性可以随意修改,非常不安全,不论对错例如:只需要p.name=…就行,所以引入封装

封装

封装是面向对象的三大特性之一

封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法

如何隐藏对象中的一个属性?

  1. 修改对象的属性名为外部知道的名字

  2. getter and setter

  3. getter setter 方法其实也可以有妙用 比如get方法 用户获取商品价格的时候计算PU UV

    set方法 用户修改密码的时候给出提醒

  4. 使用getter方法可以表示一些计算的属性 比如计算长方形的面积

  5. 可以使用__双下划线开头的属性,这个是隐藏属性只能在类的内部访问,(相当于java中的private),无法通过对象访问

  6. 其实隐藏属性只不过是Python自动为属性修改了一个名字,__属性实际上是改为了,_类命_属性名

  7. 一般情况下我们使用_单下划线开头属性表示私有属性,没有特殊需要不要修改私有属性(只是不希望你改)

    class Person:
	def __init__(self,name):
		self._name=name
	def get_name(self):
		return self._name
	def set_name(self,name):
		self._name=name

p=Person('hetao')
print(p.get_name())


class Person:
	def __init__(self,name,age,price):
		self.hidden_name=name
		self.hidden_age=age
		self.hidden_price=price
	def get_name(self):
		return self.hidden_name
	def set_name(self,name):
		self.hidden_name=name
	def get_age(self):
		return self.hidden_age
	def set_age(self,age):
		if age>0:
			self.hidden_age=age
	def get_price(self):
		return self.hidden_price
	def set_price(self,price):
		self.hidden_price=price
	def sayHello(self):
		print('i am '+ self.hidden_name)
p=Person('hetao',2,'1800')
print(p.get_price())
p.set_price(2000)
print(p.get_price())
# 1800
# 2000
装饰器

property装饰器,用来将一个get方法,装换为对象的属性

添加为property装饰器以后,我们就可以像调用属性一样使用get方法

使用property装饰的方法,必须和属性名是一样的 @属性名.setter(注意:有setter必须有getter)

class Person:
	def __init__(self,name):
		self._name=name
	@property
	def name(self):
		print('get is running')
		return self._name

	@name.setter
	def name(self,name):
		print('set is running')
		self._name=name

p=Person('hetao')
print(p.name)
p.name='tom'
print(p.name)
# get is running
# hetao
# set is running
# get is running
# tom
继承

在定义类的同时,可以在括号中指定当前类的父类,子类可以继承父类中所有的属性和方法

class Animal:
	def run(self):
		print('running funny')
	def sleep(self):
		print('sleeping deeply')

class Dog(Animal):
	def bark(self):
		print('wang wang wang')

d=Dog()
d.run()
print(issubclass(Dog,Animal))
print(isinstance(d,Animal))
# running funny
# True
# True

如果在创建类时省略了父类,默认父类为Object,Object是所有类的父类,所有的类都继承Object

如果子类的方法和父类方法重复,这个时候调用谁?

重写
class Animal:
	def run(self):
		print('running funny')
	def sleep(self):
		print('sleeping deeply')

class Dog(Animal):
	def run(self):
		print('dog is running')
	def bark(self):
		print('wang wang wang')

d=Dog()
d.run()
# dog is running

调用一个对象的方法时,如果有调用当前对象的方法,没有的话调用父类中去寻找,直到Object

父类中所有的方法都会被子类继承,包括特殊方法,如果不初始化父类中的属性会报错,所有希望直接调用父类中的init方法来初始化父类中的属性super()

super()

通过super()返回对象调用父类方法时,不需要传递self(python3中)

class Animal(object):
	def __init__(self,name,age):
		self._name=name
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age
class Dog(Animal):
	def __init__(self,name,age):
		super(Dog,self).__init__(name,age)
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age


d=Dog('tom',18)
# python2

class Animal:
	def __init__(self,name,age):
		self._name=name
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age
class Dog(Animal):
	def __init__(self,name,age):
		super( ).__init__(name)
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age


d=Dog('tom',18)
# python3

类名.__bases__这个属性可以用来获取当前类的所有父类

class A(object):
	def test(self):
		print('a')
class B(object):
	def test(self):
		print('b')
class C(A,B):
	def test(self):
		print('c')
print(C.__bases__)
#(<class '__main__.A'>, <class '__main__.B'>)

如果多个父类中有重名的方法,会先调前面的

class A(object):
	def test(self):
		print('a')
class B(object):
	def test(self):
		print('b')
class C(B,A):
	pass
c=C()
c.test() 
# b

没有特殊情况下我们一般不会用多重继承

比如

		object 2
    A 1				B 3
    
    		c 4
    		
    		D 5
	class D(A,B,C):
		pass
	d=D()
	d.test()这个时候的调用顺序如上
	# 先找第一个父类A,如果A中没有找A的父类Object,Object没有找B,b没有找b的父类(因为Object已经找过不再找了,然后是c,c找不到找c的父类(因为abObject都找过不再找),然后是找d)
	# 所以多重继承太过复杂
多态

多态从字面理解是多种形态

java中的多态指的是父类的应用对应子类的对象,这样更加灵活使用

Animal animal =new Cat();

在Python中调用不同的子类将会产生不同的行为,而无需知道这种子类实际上是什么,这是多态重要的应用场景

多态的具体好处可以用一句话来概括: 一个接口,多种实现

  • 增加了程序的灵活性,不论对象如何变化,使用者都是通过同一种形式去调用
  • 增加了程序的额外可扩展性
多态和多态性(鸭子类型)

多态指的是一类事物的多种形态,比如animal类可以有多种子类(猫/狗/猪等)

多态性指的具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名,调用不同内容的函数

比如len()函数可以传递列表,元组等

任意定义一个函数只要有__len__方法也可以使用len()函数

class A(object):
	def __len__(self):
		return 10

c=A()
print(len(c))
# 10

面向对象的三大特征

  • 封装

    确保了对象中的数据安全

  • 继承

    保证了对象的可扩展性

  • 多态

    保证了程序的灵活性

类中的属性和方法
类属性
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
a=A()
print(a.count)
A.count=100
print(A.count)
# 0
# 100
  • 类属性,可以直接在类中定义的属性是类属性
  • 类属性可以通过类或类的实例访问
  • 但是类属性只能通过类对象来修改,无法通过实例对象来修改
实例属性
  • 通过实例对象添加的属性属于实力属性
  • 实例属性只能通过实例对象来访问和修改,类对象无法访问修改
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
a=A()
a.name='jack'
print(a.name)
# jack
实例方法
  • 在类中定义,以self为第一个参数的方法都是实例方法
  • 实例方法在调用的时候,Python会将调用对象作为self传入
  • 实例方法可以通过实例和类调用,通过类调用时候不会传self,此时必须手动传递self
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	def test(self):
		print('test')
a=A()
a.test()
A.test(a)
# test
# test
类方法
  • 在类的内部,@classmethod 来修饰的方法属于类方法
  • 类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象
  • 类方法和实例方法的区别 实例方法的参数是self,而类方法的第一个参数是cls
  • 类方法可以通过类去调用,也可以通过实例调用,没有区别
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	@classmethod
	def test(cls):
		print('test')

A.test()
# test
静态方法
  • 在类中使用@staticmethod 来修饰的方法属于静态方法
  • 静态方法不需要指定任何的默认参数,静态方法可以通过类和实例去调用
  • 静态方法,基本上是一个和当前类无关的方法,只是保存到当前类中的函数
  • 静态方法一般都是一些工具方法
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	@staticmethod
	def test():
		print('test')
a=A()
a.test()
A.test()
# test
# test
垃圾回收

在程序中没有被引用的对象就是垃圾,垃圾回收就是将垃圾对象从内存中进行删除(Python中有自动的垃圾回收机制)

class A(object):
	def __init__(self):
		self.name='tom'
a=A()
print(a.name)
a=None # 将a设置为None 此时没有任何变量使用A()对象进行引用,就是变成了垃圾 程序结束的时候也会触发垃圾回收

class A(object):
	def __init__(self):
		self.name='tom'
	def __del__(self): # 这是个魔术方法,当对象没有引用的时候会自动调用这个方法
		print('i was deleted')
a=A()
print(a.name)
a=None
# tom
# i was deleted
特殊方法(魔术方法)
  • 特殊方法都是双下划线开头和结尾的
  • 特殊方法一般不需要手动调用,在特殊的情况下自动执行
__str()__

可以指定对象转换为字符串的结果

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
    def __str__(self):
		return 'Person [name=%s,age=%d]'%(self.name,slef.age)
p1=Person('TOM',18)
p2=Person('jack',16)

#1 .print(p1) # 当我们在打印对象的时候,实际上是调用了对象中的特殊方法__str__
# <__main__.Person object at 0x7f08d587b410> 
# 2 .print(p1)# Person [name='tom',age=18]
__repr__

直接在交互模式中输出的结果

例如

>>> a='hello'
>>> print(a)
hello # 调用的str
>>> a
'hello' # 调用的repr
>>>
__gt__

大于比较

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def __gt__(self,other):
		return self.age>other.age
p1=Person('TOM',18)
p2=Person('jack',16)

print(p1>p2)
# True
  • lt <
  • le <=
  • eq =
  • ne !=
  • gt >
  • ge >=
__len__

__bool__ 本来是判断对象是否为空

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def __gt__(self,other):
		return self.age>other.age
p1=Person('TOM',18)
p2=Person('jack',16)
p1=None
print(bool(p1)) # false

可以通过bool来指定对像转为布尔值的条件

还有许多的魔法方法都可以改比如加减乘除,都是多态的表现

模块
创建模块

模块化,指的是将一个完整的程序分解为一个一个小的模块,通过将模块组合,搭建出一个完整的程序

在Python中一个py文件就是一个模块,创建模块就是创建py文件

注意:模块名要符合合格的标识符的规范

如何在其它模块中引入外部模块

  1. import模块名 (模块名,就是Python文件的名字,不需要py后缀)

    • import test_module

    • 模块可以引入同一个模块多次,但是模块的实例只会创建一个

  2. import 模块名 as 模块别名

    • import test_module as test
    • print(test)
    • import 可以在程序的任意位置调用，一般都写在开头
    • 没一个模块都有一个__name__属性可以查看当前模块的文件名
    • 注意__name__属性为__main__的模块是主模块，一个程序中只会有一个主模块，就是通过python执行的模块
使用模块

访问模块中的属性：模块名．变量名

#bb.py
a=10
b=20
# aa.py
import bb
print(bb.a)
＃　10

访问模块中的函数：模块名．函数名

访问模块中的类：　模块名．类

也可以引入模块中的部分内容

语法：from 模块名　import 变量，变量…

  • from m import Person,test
  • from m import * #一般不会轻易使用　会和主模块冲突

也可以为引入的变量使用别名

语法：from 模块名　import 变量　as 别名

  • from m import test2 as new_test2

添加了_的变量只能在模块内部访问，相当与私有变量，通过import *引入时不会看见　但import m 可以

*规定某些代码，只有当当前模块是主模块的时候才执行，而当前代码被其它模块引入的时候不需要执行

if __name__=='__main__':
    pass
包　package

  • 包也是一个模块，当我们模块中代码过多时，或者一个模块需要被分解成多个模块时，就需要使用到包

  • 普通的模块就是一个py文件，包就相当于一个文件夹

  • 包中必须要有一个__init__.py

from hello import a,b
print(a.xxx)
print(b.xxx)

包的好处就是可以把功能相似的代码放到一块

__pycache__

模块缓存文件,py在执行前,需要被解析器转为机器码,然后再执行,所以我们在使用模块(包)时,需要将模块的代码转为机器码然后再交由计算机执行,而为了提高程序运行性能,Python会在编译一次过后,将代码保存到一个缓存文件中,下次加载这个包时,不再重新编译,加载缓存缓存中的.

python标准库

开箱即用(在官方文档中global module index中可以找到全局的索引库)

为了实现开箱即用,Python中提供了一个模块的标准库,标准库是Python安装自带的

sys模块,提供了一些变量和函数,可以获取到Python的解析器

pprint模块,提供了我们一个方法pprint()该方法可以用来对打印的数据做简单的格式化

import sys
import pprint
print(sys.argv)# 获取在命令行执行这个py脚本的参数
print(sys.modules) # 返回所有引入的模块,是一个字典,key是模块名字 value是模块对象
pprint.pprint(sys.modules) # 返回pretty(漂亮)的print语句
pprint.pprint(sys.path) # 他是一个列表,列表中保存的是模块的搜索路径(这个是pprint的路径) 
print(sys.platform) #表示当前Python运行的操作系统环境
sys.exit('gg')# 用来退出程序

os模块,让我们对操作系统进行访问

import pprint
import os

pprint.pprint(os.environ)# 返回的是系统的环境变量是个字典
os.system('ls') # 可以直接执行Linux命令
zax_java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Learning-Python-by-building-games:Packt发行的《通过构建游戏来学习Python》
05-27
通过构建游戏学习Python ... 在后面的章节中，您将通过修改蛇游戏以及探索GUI编程来构建使用Python的turtle模块的用户界面，来深入了解面向对象的编程。 本书涵盖以下激动人心的功能： 通过了解Pyt
python-learning.zip
06-20
08.面向对象编程基础.md 09.面向对急进阶.md 10.图形用户界面和游戏开发.md 11.文件和异常.md 12.字符串和正则表达式.md 13.进程和线程.md 14.网络编程入门和网络应用开发.md 15.图像和办公文档处理.md 16-20.Python...
第十四章:面向对象 - 类的简介
maihailunP1的博客
09-16 187
01 - 面向对象 - 面向对象举例 所谓面向对象的编程语言,简单理解就是语言中所有的操作都是 通过对象来完成的 面向过程就是将程序的逻辑分解成一个一个的步骤 通过对每个步骤的抽象来完成程序 ‘’’ 孩子吃西瓜 1.妈妈穿衣服穿鞋出门 2.妈妈骑电动车 3.妈妈到超市门口放好电动车 4.妈妈买西瓜 5.妈妈结账 6.妈妈骑电动车回家 7.到家孩子吃西瓜 ‘’’ 这种方式编写的代码往往只适用于一个功...
面向对象编程一 类的基本介绍
yuyejisi的博客
05-03 216
面向对象编程介绍：（如果可以把对象归类的时候，使用面向对象编程） 面向对象编程：Object Oriented Programming，简称OOP，是一种程序设计思想。 需要注意的是，与之对应的是面向过程编程思想。实际上，能够使用面向对象编程思想实现的程序，也都能通过面向过程完成。只是看哪种思想更适合当前开发需求。 面向过程与面向对象区别： √ 面向过程：根据业务逻辑从上到下写代码 √ 面向对象：将数据与函数绑定到一起，进行封装。减少重复代码的重写过程 面向对象概念及术语： 类、对象、实例化实例变量、类变量
python-面向对象：三大特性&高级特性
Gong_yz的博客
06-09 811
面向对象：是按人们认识客观世界的系统思维方式，把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
Python-面向过程编程、面向对象编程
Ma_JunSSR的博客
12-14 976
1、面向过程编程 以五子棋为例（面向过程的思路）： 面向对象的思路： 2、面向对象编程 1）简介 2）对象和类 #类(class) class Cat: #属性:一般是名词，比如name,age,gender..... name = 'name' kind = 'kind' #方法：一般是动词，比如create,delete,run..... def eat(self): print('cat like eating fish ....'
Python-----定义类对象和创建实例对象
热门推荐
CN_SHzhaoyujie的博客
09-29 1万+
如何定义类对象 定义类对象的语法格式： class 类名(object) # 属性和方法其中， 类名由一个或多个单词组合而成，一般来说建议每个单词的首字母大写且其余字母全部小写，例如： SomeClass。 (object)表示该类对象继承自Python内置的类对象object，Python中所有的类对象都继承自一个统一的基类：object class S...
Building-Machine-Learning-Systems-With-Python-Second-Edition:Packt Publishing使用Python构建机器学习系统
05-28
使用Python构建机器学习系统和用Python构建机器学习系统》一书的源代码。 该书由Packt Publishing...相关的Python书籍和视频[Python地理空间开发-第二版]（ ） [精通面向对象的Python]（ ） [Python网络编程手册]（ ）
Python中的面向对象编程Object-Oriented Programming in Python
11-15
本书提出了一种平衡而灵活的方法，可以将面向对象的原理纳入使用Python的入门课程中。
python-anomaly-detection:一种使用半监督学习在Python中实现异常检测的面向对象方法
05-14
编写此Python3笔记本是为了熟悉Python中的面向对象。 它显示了如何使用多元高斯表示训练数据来实现异常检测器类。 假定训练数据未标记。 假定被标记的第二个数据集用于交叉验证，即找到可能的最佳阈值，以将观察结果...
Day25-Java基础之常用类1
m0_46053885的博客
04-27 928
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 898
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
AttributeError: module ‘numpy‘ has no attribute ‘float‘.的解决方法
最新发布
chen_znn的博客
04-30 340
本文记录了AttributeError: module 'numpy' has no attribute 'float'.的解决方法
Python 二叉树的创建与遍历
youyouxiong的博客
04-24 451
在Python中创建二叉树并进行遍历，我们首先需要定义一个二叉树节点类，然后创建二叉树，最后实现几种基本的遍历方法：前序、中序、后序和层序遍历。以下是具体的实现步骤： 2. 创建二叉树 创建二叉树通常是由用户根据需要输入节点值来构建，或者通过特定的算法生成。这里我们手动创建一个简单的二叉树： 3. 实现二叉树的遍历 前序遍历 (Preorder Traversal) 访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。 中序遍历 (Inorder Traversal) 递归地遍历左子
PySide6 GUI 学习笔记——使用资源文件
Humbunklung的专栏
04-27 558
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
python中的元类
weixin_40756114的博客
04-25 923
上面说了类是类的实例的模板，所以你看类的__new__被定义为一个绑定的类方法，类本身是作为方法的第一个参数，一般命名为cls，一般情况下，__new__不需要其他的参数，__new__根据cls来产生一个实例，__new__返回产生的实例，也有tuple等少数例外__new__需要额外的参数，绝大多数情况是不需要的。正如类是类的实例的工厂，元类则是类的工厂。不过这两种关系还是有所不同，类是类的实例的模版，但元类不是类的模版，元类更像一个纯粹的类的组装工厂。
笔记：Python 注释（练习题）
欢迎来到我的CSDN博客！在这里，我将分享关于技术、学习和生活的各种笔记和心得体会。无论你是正在学习编程、探索新技术，还是对生活中的点滴有所感悟，我都希望我的博客能够给你带来启发和帮助。
04-27 880
欢迎来到Python注释练习！在这个练习中，我们将探讨Python中注释的重要性和使用方法。注释在代码中扮演着关键的角色，不仅可以提高代码的可读性，还可以帮助其他人理解你的代码逻辑。通过这些练习，你将学习如何正确地编写注释，以及如何使用注释来解释代码的功能、逻辑和设计。无论你是新手还是有经验的Python开发人员，都可以从这些练习中受益。通过实践，你将更加熟悉Python注释的最佳实践，并且能够将其应用到自己的项目中。让我们开始吧！
在win上运行linux qt的项目
关注工业机器人应用
04-26 211
效果明显， 只是没有UR的远程VNC，不影响运行效果。
learning python 5th
01-01
书中涵盖了Python的数据类型、函数、模块、面向对象编程等重要内容，而且还介绍了Python在数据分析、人工智能、网络编程等领域的应用。这本书的知识点全面，适合初学者系统学习，也适合有一定经验的程序员进阶学习。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值