w1234567465的博客

x.draw();为什么java可以rust不可以:Rust:Rust 强调所有权和内存安全。在 Rust 中，特征（traits）并不直接表示具体的类型，而是用于定义行为。因此，不能直接将特征作为参数类型，而需要使用特征对象（如 &dyn Trait 或 Box），以确保明确的所有权和生命周期管理。Java:Java 使用引用类型（如接口）来实现多态性。接口可以直接作为方法参数，因为 Java 的垃圾回收机制自动管理内存，而不需要显式处理所有权。

一、JVM结构：二、概念*1.虚拟机栈：存储局部变量。局部变量存储的是所引用对象在堆内的首地址。例：基本数据类型，对象引用，执行完后，自动释放。*2. 堆：存放对象实例，数组以及对象的实例都要在堆上分配。*3. 方法区：已被虚拟机加载的类信息、常量、静态变量，即时编译器编译后的代码。*4.垃圾收集器：当对象实例没有被引用后，自动回收实例。三、局部变量于成员变量的区分/** * 属性：成员变量 VS局部变量 * 1.相同点 * 1.1定义变量的格式相同。 *

场景：数据库连接成功，查询失败。例如：原因：属性名 的引号错误应更改为：`

是什么：是一个标签。就像超市购物架上很多瓶子，每个瓶子装的是什么，有标签。设计背景：集合容器类在声明阶段不能确定这个容器到底存的是声明类型的对象，所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的。因此此时把元素设计成一个参数，这个类型参数叫做泛型。Collection,List,ArryaList这个就是类型参数，即泛型。概念：1、在定义类、接口时候通过一个

死锁1 、定义：两个或者两个以上的进程在执行过程中，因为争夺资源而造成一种互相等待的现象，如果没有外力干涉，他们无法再执行下去。互相持有各自锁子（资源）的时候，又互相试图得到对方的锁2、原因：①系统资源不足②进程运行推进顺序不合适③资源分配不当3、示例import java.util.Objects;import java.util.concurrent.TimeUnit;/** * @ClassName com.chuzuwu.lock * @Time 21:06 * @Aut

根据谁先出顺序固定，变得是进入的顺序，可记忆栈队列名称。from queue import Queue,LifoQueue#队列a=Queue(maxsize=2)a.put(1)a.put(2)print(a.full())print(a.empty())print(a.get())TrueFalse1#栈a=LifoQueue(maxsize=2)a.put(1)a.put(2)print(a.full())print(a.empty())print(a.get

isinstance(a,b):如果a是b的实例或者a是b子类的实例，返回真否则返回 假insubtance(a,b)如果a是b的子类返回真否则返回 假```class A: passa=A()print(isinstance(a,A))class B(A): passb=B()print(isinstance(b,A))print(issubclass(B,A))print(issubclass(A,B))TrueTrueTrueFalseProc

推导:1.作用：在一行代码中实现对可迭代对象的转换或过滤（排除）。2.返回：返回的对象是列表，集合，字典或者可以一次性用掉的生成器表达式3.优点：推导通过高度优化的C代码实现，在遍历大量元素时列表推导比for循环快很多。4.语法：变量名 = [表达式 for 变量 in 列表 if 条件in…]变量名 = {表达式 for 变量 in 集合/字典 if 条件in…}一、列表的推导：1.把一个给定字符串列表专场成为整数列表运用推导input_string = ['1','2','6']o

如果列表中放的是同类对象，并想对对象操作，如果要用sort排序，那么富方法时一种方式。富方法：用于比较对象二设置的标准六个方法: lt、gt、le、ge、eq和ne (前后分别加下划线)分别表示：小于、大于、小于等于、大于等于、等于和不等于，对应的操作运算符为:<、>、<=、>=、==和!=class People: def __init__(self,name,age,sort_num): self.name=name self

在迭代过程中记录特定实例的数量，例如记录候选人票数。from collections import Counter计数器Counter对象：实质是一个加强版的字典，键存储的时对象所包含的项目，值为该项目所出现的数量。常用方法：most_common():返回(key.count)元组组成的列表并按照计数排序。from collections import Counterresponses=[1,1,2,3,5,1,1,1,1,1,2,2,3]print(#因为返回的时列表，所以Counter(

发现没有输出的输入其实学习效果不太好，所以试图输出点东西，试图串联起来，所以有些细节不是特别讲究。欢迎指正类是对象的抽象，对象是类的实例化。1.创建类：class <类命>:创建个最简单类class MyFriendClass: pass #下面没有进一步行为上面那个类似乎美什么可做的了，但是它允许我们创建这个类的实例对象。a=MyFriendClass()b=MyFriendClass()print(a)<__main__.MyFriendClass obj

模块：一个py类型文件。包：一个目录下模块的集合。包的名字就是目录的名字。组织模块：如何告诉包的名字是目录的名字呢？在目录下添加一个 init.py文件例如：一个名字为1的python包，其中包含01和02两个模块，init.py文件用来告诉包的名字是目录的名字**导入：模块导入：一、同一目录下的py文件可以直接导入例:在02模块中import 01#导入01模块a=01.apple()#实例一个01模块钟apple类from 01 import applea=apple(

有yield的函数为生成器，生成器有next私有函数，这也是它可以循环迭代的原因，（继续）调用当前函数，，用next调用实际与for,while是一样都是迭代。yield有return功能，1.遇见yield就像遇到return一样返回，终止函数的运行，2.当作生成器def C(): print('今天天气不错') while True: a=yield 10 print('a:',a)p=C() #实例化一个迭代器类型的对象print(p) #p是给

多重继承多重继承概念多重继承容易引发的问题问题的解救额方法多重继承就是子类继承多个父类，原则非常简单。混入：一个类的存在，是为了被其他类继承并添加额外的功能，不是一个单独存在的超类。多重继承最简单有效的方式就是混入。例：C继承A和B，A和B继承0如果它们分别调用各自的方法，那么便没有影响，如果调用继承自各自超类的方法，那么输出就会和预期不符合例：class BaseClass: num_base_calls =0 def call_me(self): p

class EvenOnly(list): def append(self, integer): if not isinstance(integer.int): raise TypeError("only integers can be added") if not integer % 2: raise ValueError("Only even numbers can be added") super(

抽象基类(ABCs),：目的：事先定义这个类能满足的需求。概念：定义一组必须被类的鸭子类型实例实现的方法和属性抽象基类部分或全部方法和属性不用实现特点：所以如果不实现抽象了的的方法属性，对象无法实例化。所有为抽象属性方法提供具体实现的类都是抽象基类的子类分类：内置的，大多数存在于colletions模块https://www.cnblogs.com/dianel/p/10787693.html自定义的抽象基类https://blog.youkuaiyun.com/qq_35371031/

python有枚举类和枚举函数。1.enumerate：枚举函数语法enumerate(可迭代对象，序号开始的值（默认为0）)返回一系列元组，元组第一个值为像0123…的值，第二个元素为原对象。a=('小明','小黑','小红')for index,value in enumerate(a): print('序号为{0},值为{1}'.format(index,value))b=list(enumerate(a))print(b)序号为0,值为小明序号为1,值为小黑序号为2

概念：线程：系统级别的，它们由操作系统调度cpu.协程：程序级别的，由程序根据需求自己调度。函数：又称为子程序，是所偶语言中都是层级调用在一个线程中由很多函数，又称为子程序，在子程序执行过程中可以终端去执行别的子程序，而别的子程序又可以终端回来继续执行之前的子程序这个过程叫做协程。也就是说在同一线程内一段代码在执行过程中断然跳转执行别的代码，接着在之前中断的地方继续开始执行。子程序正常调用def A(): print('1') print('2') print('3')

在理想状态下，代码才能返回正确的结果。在以前，只有严格检查每个函数的输入才能确保它们是合理的才行。通常，特殊的返回值表明错误状态。例如，通过返回一个负值表示无法计算得到正值。不同的数字代表不同的错误，所有调用这一函数的代码必须明确地检查所有的错误状态并且执行对应的动作。很多程序没有这么做，那么程序就崩溃了。在对象的实际中，情况就不同了。异常：本质上是一个对象。有很多不同的异常类，并且我们可以定义自己的异常类。特殊的错误对象只有在合理的时候处理，当发生异常时，所有本该发生的事都没有发生，除非是在遇到异

空对象实例化于空类，类又有自定义的类和内置类。内置类的空对象：内置类删除线格式 ：object类，数值，迭代，序列，映射，集合特点：不能往内置类型的空对象里添加属性原因：节省内存，当允许一个对象拥有任意属性时候，需要消耗一定的系统国内存来准总每个对象有那些属性，用于保存属性的名字和值。创建内置类的对象a=object()b=set()b.x=1a.x=1print(a.x,b.x)"无法从外部往类内部添加属性"Traceback (most recent call last):

扩展内置对象向内置类型添加新功能是继承关系的有趣应用。在上一篇中，我们将联系人添加到所有联系人的列表中。如果想要根据名字搜索这么列表，怎么实现呢？我们可以为Contact类添加一个搜索方法，但是这个方法似乎应该属于列表本身，因此我们可以通过继承关系做。创建一个新的ContactList类，继承内置的list，在这个新的类里面添加一个方法。最后在Contact类中实例化这个子类。class ContactList(list): def search(self,name): "

字符串为不可变的Unicode字符集合，但是，这并不是数据真的存储格式。例如，如果从文件或者套接字中获取字符穿，它们不会是Unicode。实际上它们是内置的bytes类型，字节就是不可变的字节序列，是计算过程中最底层的存储形式。字节没有任何具体表示，一个字节序列可能存储的是编码得到的此付出，也可能是图像中的像素。编码方式不同得到的就不同。许多I./O操作只能与bytes打交道，即便字节对象指向文本数据也如此。因此就需要bytes和Uicode之间的转换。目的：让字节和文本可以相互映射1.byte

异常类的名字通常说明了发生异常的类型，定义自己的异常类：class 类命(Exception):…Exception的初始化方法设计成可以接受任意参数并将他们作为元组保存在args属性中因此不需要重写初始化方法的args属性class NumErorr(CalcErorr): def __init__(self,numA,numB): self.numA=numA self.numB=numB def __str__(self): return f"本计算器只接

多态：由于子类不同，同一个方法名产生的行为不同。例如：多媒体，想让它实现一行为，但是不知道是什么类型的多媒体。现在有MP3等设备，都有各自运行行为play这个方法，他们继承了多媒体这个类，然后编写属于自己的play方法于是，实现了不同子类的同一方法名的不同行为。class AudioFile: "定义一个多媒体类" def __init__(self,filename): if not filename.endswith(self.ext): "这

既然抛出异常后，不处理掉以后的代码便不能运行，那是我们不想看到的，所有，要有异常的处理。try:… 所有可能抛出异常的代码except:… 所有用于处理异常的代码没有异常处理时候，print(“1”）无法输出def no_return(): print("I am about to raise an exception") raise Exception("This is always raised") print("This line will never execut

注意：将函数当作对象调用时候，只需要写函数名，当用作函数调用时候，函数名后需要加括号。def women(): print("我是女人")women.like='变美'#为函数对象添加属性def men(): print('我是男人')men.like='变帅'def people(a): print('描述特征\n',end='') print(a.like) #调用对象的属性 print(a.__name__) print(a._.

普通实现def fibonf(n): a=b=1 c=[] for i in range(n): c.append(a) a,b=b,a+b return cprint(fibonf(10))[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]生成器def fibon(n): a=b=1 for i in range(n): yield a a,b=b,a+b

在编程的世界里，重复的代码被认为是邪恶的，我们不应该在不同的地方写多份相同或类似的代码。继承能创建两个或多个类之间的“是一个”关系，将共有的逻辑抽象到超类，并在子类中空值具体的细节。基本的继承严格说，我们所有创建的类都使用了继承关系，所有的python类都是特殊的object类的子类。这个类提供的所有方法都已双下划线开头，只在内部使用，如果不明确地从其他类继承，这个类iang自动继承object。class MyFriend(object): pass 例：class Co

面向对象中，行为和数据是严格区分的，但是，python是刻意模糊属性与行为，所有更具有灵活性。在JAVA中，属性的值更通常要从方法赋予的，但是，在python中却没有这么要求，因为python所有的属性方法严格来说都是公开的。正因为如此，尽管就像JAVA那种风格写代码，python也提供了用属性方式去添加行为（操作方法）的关键字，propertyproperty(访问函数，设置函数，删除函数，该属性文档字符串)"既然要写出类似于java风格，那么就再相应属性方法用半私有符号"class man:

1.集合：可以保存任何可求哈希值的对象关于hashi的理解2.特点：具有数学上的特性，元素具有唯一性，由于储存的是希哈所以内部排序无序性。例如：创建一个歌手的的列表a=[("夜曲","周杰伦"),("依然爱你","王力宏"),("浮夸","陈奕迅"),("光辉岁月","beyong"),("稻香","周杰伦")]b=set()for song,artist in a: b.add(artist)c=list(b)print(b)print(c){'周杰伦', '王力宏',

不同集合的参数目的：多重继承中，当用super方法时候，控制不同集合的参数。要解决的：1.将基类的参数列表设计出接受任意关键字参数，而且这些参数对于子类的实现是可以选择的。2. 确保能够接受不需要的参数并将其传递给自己的super方法，以防它们在后续继承顺序的方法中会调用。3.kwargs语法：收集任何传递给方法没有显明在列表中的关键字参数。这些参数将被存在处在一个名为kwargs的字典中。当我们用kwargs语法调用另外一个方法（例如：super().init)时，会将字典分解之后作为正常关机

封装面向对象编程有四大概念：封装、抽象、多态和继承包含两个概念。第一个概念:是在面向对象编程中，对象将属性和方法放在一个地方。第二个概念:指的是隐藏类的内部数据，以避免客户端（client）代码（即 类外部的代码）直接进行访问。但是，python提供的是非强制性的指南和最佳实践，不相信那些将来会对你造成妨碍的强制性规范。严格的说，类的所有方法和属性都是对外公开的。如果想要说明某个方法属性不应该公开使用可以使用以下：1.可以在它的文档字符串中表明这个方法应该用于每部。2.在属性或方法前加一个下

#计算一句话中各个字母出现的频数，三种方式def frequency(sentence): f={} for i in sentence: t=f.setdefault(i,0) "两种情况，一种返回字典，一种返回值" f[i]=t+1 "字典和字典还能相加？" return fa='aba'b=frequency(a)print(b)from collections import defaultdict

yield相当于return中断了数据的传输，那么如何将赋值号右边为yield的变量赋值了，用到了send方法。def foo(): print('starting...') while True: res = yield 4 print('res',res)g = foo()print(next(g)).print('*'*20)print(g.send(10)) #将10传输给res，然后继续执行，直到遇到终止starting...4

上一次我们用属性来给属性添加方法（name属性给name属性添加写入于读取方法），是在最后用了property关键字，现在同样有一个等价的方式，把来给属性创建方法，那就是运用装饰器。可读性可能更好。“用装饰器”class man: @property def foo(self)： return self._name "实现取出属性的值的方法名上修饰器名用property" @foo.setter def foo(self,name):

初始化对象以上一篇的point类为例子，如果没有为类的属性x,y传入值时候，调用:p1的属性x，y会引起错误。所以，为了修复这一错误，需要为其指定一些默认值。python同时拥有构造函数和初始化方法，其中初始化方法是最常用的。初始化（初始化对象）方法名：init构造函数（创建对象）名：new例如：class Point: def __init__(self,x,y): """ def __init__(self,x=3,y=5): 如果想让参数x,y的值输入不是必须的，就

重写与super如果想继承联系人的朋友类的初始化方法中添加一个phone的默认值怎么办呢？则需要用到重写（任何方法都可以重写），在子类中，方法名相同，参数不同即可。pythonclass ContactList(list): def search(self,name): "返回所有符合名字的类" matching_contacts=[] for contact in self: if name in contact.name

过去谈到过钻石型继承问题，前面讨论的继承是实例属性方法间的继承，因此用super()可以解决那么如果是静态方法呢？class A: def __init__(self,a="",**kwargs): super().__init__(**kwargs) self.a=a def display(self): "父类super().display'()不用写" print("a={}".format(self.a))

如果不添加 __repr__方法，输出实例化对象时候为 ：类名+object at+内存地址如下列： class People: def __init__(self,name,age,sort_num): self.name=name self.age=age self.sort_name=sort_num a=People("张三",1,True)print(a)<__main__.People object a

a='hello {}.you are {}.\n'print(a.format('小明','handsome')) #把'小明'和'handsome'按照顺序替换a中字符串的{}d='hello {0}.you are {1},name is {0}.\n'#{0}表示索引format后括号里的第一个字符串print(d.format('小明','handsome'))b=''c='{name},{t}'#关键字参数，表示索引format后括号中第一个变量名为name的值print(.