Python复习

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

Python复习

Pycharm快捷键

  1. 光标放在一个方法上，Ctrl+ Q 出现帮助窗口，显示具体信息

  2. Shift+F10 运行

  3. TODO注释 在 # 注释的**#空格**之后增加TODO ，

    示例：# TODO （小王）显示欢迎界面

  4. 修改变量名：右键点击一个变量名->Refactor->Rename->在红框中修改变量名即可改变所有

    或Shift+F6

  5. Ctrl+/ 给选中内容注释

基础知识

  1. 模块名也是标识符，起名以字母或下划线开头。

  2. Pyc文件：C是编译过的意思，是由Python解释器将模块的源码转换为字节码。

  3. 列表

    #1.创建列表
name_list = ['zhangsan','lisi','wangwu']
#2.列表提供的方法
#append、count、insert、reverse、clear、extend、pop、sort、copy、index、remove
#3.index方法查找元素不在列表中，则报错
print(name_list.index("wangwu")) #打印输出2
#4.增加数据 append\insert\extend
name_list.append("王小二") #这样列表末尾有了"王小二"
name_list.insert(0,"王小四") #在指定索引位置插入，列表开头增加“王小四”
name.extend(["可可","爱爱"])#列表最后增加一个整体
#5.删除
name_list.remove("wangwu") #删除指定内容的数据
name_list.pop()#删除列表最后一个数据
name_list.pop(1) #删除索引为1的数据 可以指定索引
name_list.clear() #清空列表
del list[索引] #删除列表指定索引的元素，推荐使用pop、remove
#6.列表长度
len(name_list) 
#7.count方法统计某元素的出现次数
count = name_lsit.count("张三")
#8.排序
列表.sort() #升序排序
列表.sort(reverse = True) #降序排序
#逆序(反转)
列表.reverse()

  4. 元组

    元素不能更改

    #1.用()定义，元素不能更改
empty_tuple = () #定义空元组,之后不能再增加内容
info_tuple = ("zhangsan",18,"李四")
#2.用[]索引
info_tuple[0] #取第一个元素
#3.定义只包含一个元素的元组
single_tuple = ("zhang"，) #如果只有一个元素的元组，需要增加一个括号，否则不是元组类型
#4.元组的常用方法 count、index
print(info_tuple.index("zhangsan"))#输出0
print(info_tuple.count("zhangsan")) #输出1，因为出现一次
len(info_tuple) #输出3，统计元组中元素个数
#5.元组的循环遍历
for my_info in info_tuple:
    print(my_info)
#6.列表与元组之间的相互转换
list(元组) #可以把元组转化为列表
tuple(列表) #可以把列表转化为元组

    元组的应用场景
    （1）函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据

    （2）格式化字符串，格式化字符串后边的()本质上是一个元组

    info_tuple=('小明',18,1.80)
print("%s 年龄是 %d 身高是 %.2f"%info_tuple)

    （3）让列表不可以被修改，以保护数据安全

  5. 字符串

    一串字符

    str1 = "hello hello py"
print(str1)
#1.取值
print(str1[0]) #打印h
#2.遍历
for char in str1:
    print(char)
#3.统计长度 len
len(str1)
#4.统计某一个小字符串出现次数
print(str1.count("llo")) #2
print(str1.count("abc")) #0 没出现为0
#5.某一个子字符串出现的位置
print(str1.index("llo")) #打印2 #注意，如果不存在则报错
#6.诸多方法 
print(str1.isspace()) #判断是否空白
 #判断是否只包含数字
str1.isdecimal() #只有数字则返回True
 #查找和替换
str1.startswith("hello") #判断是否以..开头，大小写不同
str1.endswith("hello") #判断以..结束
str1.find("llo") #查找指定字符串的位置，如果不存在则返回-1但不报错，而index方法如果指定字符串不存在则报错
str1.replace("py","python") #将py替换为python
#replace方法执行完成会返回一个新的字符串，不会修改原有字符串
#7.文本对齐
str1.center(width,fillchar) #参数传宽度和填充字符
str1.rjust() #右对齐
str1.ljust()#左对齐
#8.去除空白字符
str1.lstrip() #去掉前面的空白字符
str1.rstrip() #去掉后边的空白字符
str1.strip() #去掉前后的空白字符
#9.拆分和链接
str1.split(str="",num)#以str为分隔符号拆分str1,如果num有指定值，则仅仅分隔num+1个子字符串，str默认包含'\t\r\n'和空格
string.join(seq) #以string为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串
#10.切片
字符串[开始索引：结束索引：步长]
str1[::-1] #逆序切片

  6. 字典

    是无序的数据集合，使用print输出时，和定义顺序一般不同

    #1.定义字典变量,键可以使用任意值，但
xiaoming = {"name":"小明"，
            "age":10}
#2.取值 使用[]
print(xiaoming["name"]) #如果键值不存在会报错
#3.增加、修改，如果key不存在则增加，存在则修改
xiaoming["age"] = 18 
#4.删除 pop
xiaoming.pop("name") #删除key为name的键值对
 #指定的key不存在则报错
#5.统计字典中键值对的数量 len()
len(xiaoming)
#6.合并字典 update
temp_dict = {"height":1.75}
xiaoming.update(temp_dict) 
 #如果被合并的字典中包含已经存在的键值对，会覆盖原来的键值对
#7.清空字典  clear()方法
xiaoming.claer()
#8.循环遍历
 #变量k是每次循环中，获取到的键值对应的key
for k in xiaoming:
    print("%s-%s"%(k,xiaoming[k]))

    应用场景：使用多个键值对，存储描述一个物理的相关信息

    将多个字典放在一个列表中，在循环体内部针对每一个字典进行相同的处理

  7. 元组、列表、字符串、字典的公共方法

    
#1.len()计算容器中元素个数
len(str1)
#2.删除
del(str1[0]) #可删除元素或变量
#3.
max(str1) #返回最大字符
min(str1) #最小字符 
#使用max和min时，对于字典类型，针对key值进行比较
#4.比较,元组、字符串、列表可以比较大小，注意字典不能比较大小
[1,1]<[2,2]
"11"<"222"
(11,)<(22,)
#5.字符串、列表、元组 都可以切片
(1,2,2,3)[1:3] #取第一二个元素 
#6.*，+
(1,2)*2 #得到(1,2,1,2)
[1,2]*2 #[1,2,1,2] 字符串同理 但字典不行
[1,2]+[3,4] #生成一个新列表[1,2,3,4]，字符串、元组同理
#7.成员运算符 in和not in
"a" in "abcd" #True
"d" not in "abd" # True
1 not in [0,1] #True
"a" in {"a":"dd"} #True 查看key

  8. 完整的for

    for 变量 in 集合：
	循环体代码
else:
    没有通过break退出循环，循环结束后会执行这里的代码

  9. 引用的概念

在Python中，变量和数据是分开存储的

函数的参数传递以及返回值都是靠引用传递的

  1. 可变和不可变类型

    可变类型：内存中的数据可以被修改（列表、字典），通过方法（pop,append等）不会影响数据的地址

    不可变类型：内存中的数据不允许被修改（数字、字符串、元组）

    注意：字典的key只能使用不可变类型的数据

  2. 哈希(hash) 一种算法，提取数据的特征码，返回一个整数

  3. 局部变量和全局变量

    • 局部变量：函数内部使用

    • 全局变量：函数外部定义，所有函数内部都可以使用这个变量

      （为了方便与局部区分，命名可以增加g_）

  4. 在函数内部如何修改全局变量？

    在函数内部加关键字 global 声明变量

  5. 函数的返回值

    如果返回多个结果，使用元组，可以省略小括号

    return a,b ,c 即可，注意返回的类型仍然是一个元组

    接收返回值的时候，可以使用多个变量分别接收

  6. 如果函数传递的参数是可变类型，在函数内部使用方法修改了数据的内容，同样会影响到外部的数据

  7. 缺省参数

    定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数。

    使用最常见的值作为默认值

    缺省参数放参数列表的末尾

  8. 多值参数

    一个函数能够处理的参数个数是不确定的，这个时候，可以使用多值参数

    • 参数名前增加一个*可以接收元组

    • 参数名前增加两个*可以接收字典

      一般在给多值参数命名时，习惯使用以下两个名字：

      *args --存放元组参数，前面有一个星号

      **kwargs --存放字典参数，前面有两个星号

      def demo(num, *num, **person):
    print(num)
    print(nums)
    print(person)

demo(1,2,3,4,5,name = '小明',age = 18)
#输出结果为 
1
(2,3,4,5)
{'age':18,'name':'小明'}

  9. 拆包

    元组前加一个星号，字典前使用两个星号，简化元组变量和字典变量的传递

  10. 函数的递归

    一定要有递归的出口

面向对象

  1. 类和对象

    类是一群有相同特征或行为的食物的统称

    对象是由类创建的一个具体对象

  2. IPythn中，dir 内置函数，使用dir传入标识符数据，可以查看对象内的所有属性和方法

  3. 定义类

#类名，大驼峰命名法
class 类名：
	def 方法1(self,参数列表):
        pass
    def 方法2(self，参数列表):
        pass

创建对象： 对象变量 = 类名()

  1. 引用概念！！

在面向对象中，使用类创建对象后，变量引用了新建的对象，使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由那个一个类创建的对象，以及在内存中的地址

提示：计算机中，通常使用十六进表示内存地址

  1. self

    哪一个对象调用的方法，方法内的self就是哪一个对象的引用

    可以通过self.访问对象的属性

    也可通过self.调用其他的对象方法

  2. 初始化方法

    当使用 类名() 创建对象时，会自动执行以下内容

    • 为对象在内存中 分配空间 – 创建方法

    • 为对象的属性 设置初始值 – 初始化方法(init)

      这个初始化方法就是 __init__ 方法，__init__是对象的内置方法
__init__ 方法是专门用来定义一个类具有哪些属性的方法

  3. 在初始化方法内部定义属性

    #在 __init__ 方法内部使用 self.属性名 = 属性的初始值 就可以 定义属性
#定义属性之后，再使用Cat类创建对象，都会拥有该属性
class Cat:
    def __init__(self):
        print("这是一个初始化方法")
    	self.name = 'Tom'
    def eat(self):
        print("%s 要吃鱼"% self.name)
# 使用类名()创建对象的时候，会自动调用初始化方法__init__
tom = Cat()
tom.eat()

  4. 改造初始化方法

    #如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
#1.把希望设置的属性值，定义成__init__方法的参数 
#2.在方法内部使用self.属性 = 形参接收外部传递的参数
#3.在创建对象时，使用类名(属性1，属性2...)调用
class Cat:
    def __init__(self,new_name):
        print("这是一个初始化方法")
    	self.name = new_name
    def eat(self):
        print("%s 要吃鱼"% self.name)
# 使用类名()创建对象的时候，会自动调用初始化方法__init__
tom = Cat("Tom")
lazy_cat = Cat("大懒猫")
lazy_cat.cat()

  5. 内置方法和属性

    #__del__方法
#__str__方法
class Cat:
    def __init__(self):
        self.name = new_name
        print("%s 来了"%self.name)
    def __del__(self):
        print("%s 我去了" % self.name)
     
    def __str__(self): #增加str方法，则打印对象名时不打印类名和地址了
        #必须返回一个字符串,当然可以不使用格式化
        return "我是小猫[%s]"%self.name

  6. 私有属性和私有方法

    实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到

    私有属性 就是 对象 不希望公开的 属性

    私有方法 就是 对象 不希望公开的 方法

    定义方式：

    在定义属性或方法时，在属性名或方法名前增加两个下划线，定义的就是私有属性或方法

    #实际上，Python没有真正意义的私有
在给属性、方法命名时，实际是对名称 做了一些特殊处理，是的外界无法访问到
处理方式：在名称 签名加上 _类名__名称
#举例
__age是私有属性，Woman是类名，如果要外部访问
print(xiaofang._Woman__age)
__secret()是私有方法，如果要调用
xiaofang._Woman__secret()
# 但最好不要使用此方法去访问对象隐私

  7. 单继承

子类拥有父类的所有**方法**和**属性**，子类继承自父类，可以直接享受父类中已经封装的方法
    - 方法的重写

  子类拥有父类的所有**方法**和**属性**，当父类的方法实现不能满足子类需求时，在子类中可对方法进行重写，在使用子类对象调用方法时，会调用重写的方法。

  重写父类方法有两种情况：1）覆盖父类的方法  2）对父类方法进行拓展

  1）覆盖父类的方法

  父类的方法实现和子类的方法实现完全不同，可以用覆盖的方式，f在子类中第一了一个和父类同名的方法并且实现

  2）对父类方法进行拓展

  如果子类的方法实现中包含父类的方法实现，就可以使用给扩展的方式

   		在子类中重写父类的方法，在需要的卫视使用super().父类方法来调用父类方法的执行；代码其他位置针对子类的需求，编写子类特有的代码实现

```python
class 类名(父类名):
    子类特有属性和方法
```



  ```python
  class Dog(Animal):
      def bark(self):
          print("汪汪叫")
  class XiaoTianQuan(Dog):
      def fly(self):
          print("我会飞")
      def bark(self):
          #1.针对子类特有的需求，编写代码
          print("神一样。。")
          
          #2.使用super(). 调用原本在父类中封装的方法
          super().bark()
          
          #3.增加其他子类代码
          pass
  ```
  1. 父类的私有属性和私有方法
```python
class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200 #私有属性
    def __test(self):
        print("私有方法 %d %d"%(self.num1, self.__num2))
        
class B(A):
    pass
# 创建一个子类对象
b = B()
print(b.test) #会报错，不能访问父类私有属性
#子类方法中也不能访问父类私有属性，不能调用私有方法
```

子类对象不能再自己的方法内部，直接访问父类的私有属性或私有方法

子类对象可以通过父类的共有方法**间接访问**到私有属性或私有方法
  1. 多继承
```python
class A:
    def test(self):
        print("test")
class B:
    def demo(self):
        print("demo")     
class C(A,B):#同时具有多个父类的属性和方法
    pass

c = C() 
c.test()
c.demo()  
```

使用多继承的注意事项：

```python
class A:
    def test(self):
        print("Atest")
    def demo(self):
        print("Ademo")      
class B:
    def test(self):
        print("B--test")
    def demo(self):
        print("b--demo")     
class C(A,B):#同时具有多个父类的属性和方法,
    pass

c = C() 
c.test() #如果有同名方法，与继承的父类的顺序有关，有同名方法最好不要多继承
c.demo()  
````

如何判断子类调用方法的顺序？[父类方法有同名，最好不要继承]

```python
print(C.__mro__) 
#子类名,可以看到查找方法的顺序
```
  1. 多态
以继承和重写父类方法为前提，增加代码的灵活度
  1. 类属性
#类是一个特殊的对象

```python
#类属性  给类对象中定义的属性，记录与类这个模板相关的特征
class Tool(object):
    # 使用赋值语句定义类属性，记录所有工具对象的数量
    count = 0
    
    def __init__(self,name):
        self.name = name
        
        #让类属性的值+1
        Tool.count += 1
#1.创建工具对象
tool1 = Tool("斧头")

#2.输出工具对象的总数
print(Tool.count)
```
  1. 类方法和静态方法
```python
@classmethod
def 类方法名(cls):
    pass
# 类方法需要用 修饰器@classmethod 来表示，告诉解释器这是一个类方法
# 类方法的第一个参数应该是cls
# 由那个类调用的方法，方法体内的cls就是哪个类的引用
#这个参数和实例方法的第一个参数是self类似
cls.类属性

#静态方法
@staticmethod
def 函数名():
    pass
```

    • 实例方法–方法内部需要访问实例属性

      实例方法：内部可以使用类名.访问类属性

    • 类方法 --方法内部 只 需要访问类属性

    • 静态方法–方法内部，不需要访问 实例属性和类属性

  2. 单例设计模式

    __new__方法
使用类名()创建对象时，Python解释器首先会调用__new__方法为对象分配空间
__new__是由一个object基类提供的内置的静态方法，主要作用由两个： 
1）在内存中为对象分配空间
2）返回对象的引用
Python解释器获得对象的引用后，将引用作为第一个参数，传递给__init__方法
重写__new__方法的代码非常固定！

#以下非单例设计模式
class MusicPlayer(object):
    def __new__(cls,*args,**kwargs):
        #1. 创建对象时，new方法会被自动调用
        print("创建对象，分配空间")
        
        #2.为对象分配空间
        instance = super().__new__(cls) #调用父类方法
        #3.返回对象的引用
        return instance #必须返回父类方法调用new方法的结果
    def __init__(self):
        print("播放器初始化")
#创建播放器对象
player = MusicPlayer()
print(player1)

    对于单例设计模式，创建多个对象，内存地址相同

    单例—让类创建的对象，在系统中只有唯一的一个实例

    class MusicPlayer(object):
    # 记录第一个被创建对象的引用
    instance = None
    def __new__(cls,*args,**kwargs):
        #1.判断类属性是否是空对象
        if cls.instance is None:
            #2.调用父类的方法，为第一个对象分配空间
        	cls.instance = super().__new__(cls) #调用父类方法
        #3.返回类属性保存的对象引用
        return cls.instance #必须返回父类方法调用new方法的结果
    
#创建播放器对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
#代码执行结果得到的两个实例的地址是相同的

  3. 异常

```python
try:
    pass #不能确定执行的代码
except:
    pass #对于错误的处理代码

```
  1. 包
一个包含多个模块的特殊目录，目录下有——init——.py文件。包名的命名方式和变量名一只，小写字母+下划线

要在外界使用包中的木块，需要在--init--.py中指定**对外界提供的模块列表**

```python
#在__init__.py中指定对外界提供的模块的格式
from . import 函数名
```

  1. 文件

    #open 打开文件，并且返回文件的操作对象
#read 将文件内容读取到内存 
## f = open("文件名"，"访问方式")访问方式(r只读，w只写，a追加；r+读写；w+读写，如果文件存在会被覆盖，不存在则创建新文件；a+ 读写方式打开文件) 
#write 将指定内容写入文件
#close 关闭文件
#1. 打开 - 文件名需要注意大小写
file = open("README ")#文件名
# 2. 读取文件内容
text = file.read()
print(text)
#.3.关闭文件
file.close()

    文件指针：标记从那个位置开始读取数据，当执行了read方法后，文件指针会移动到读取内容的末尾，默认情况下会移动到文件末尾

  2. 按行读取文件内容

    readline方法(读取大文件，一次性读入太占用内存，一行行读可能更好）

    #1.打开
file = open("README")
while True:
	text = file.readline()#读取一行，指针移动到下一行
    #判断是否读取到内容
    if not text:
        break
	print(text)
#3.关闭
flie.close()

  3. 例子–复制文件

    # 复制小文件
#.1 打开
file_read = open("README")
file_write = open("README复件","w")
# 2.读、写
text = file_read.read()
file_write.write(text)
# 3.关闭
file_read.close()
filr_write.close()


# 复制大文件
#.1 打开
file_read = open("README")
file_write = open("README复件","w")
# 2.读、写
while True:
	text = file_read.readline()
    if not text: #判断是否读取到内容
        break 
	file_write.write(text)
# 3.关闭
file_read.close()
filr_write.close()

  4. 文件/目录的常用管理模块

    os模块

    import os 
os.rename("hello.text","new.text") #重命名
os.remove(文件名) #删除文件
os.lisdir(目录名) #目录列表
os.mkdie(目录名) #创建目录
os.rmdir(目录名) #删除目录

  5. eval函数

将字符串当成有效的表达式来求值并计算结果

```python
#例1
eval("1+1") #输出2
#例2
input_str = input("请输入一个算术题")
print(input_str) #上句输计算题 会计算  
#不要使用例二这种方式，用户可通过输入使用os模块操作
```
煦煦向前
关注
.split()和.split(‘:‘)[0].split(‘,‘)详解
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
12-03 1880
split() 方法用于把一个字符串分割成字符串数组。 2 .split(‘:’)[0].split(‘,’) lrepochs=“10,12,14:2” 即，分隔符前面的字符串下标[0],后面的下标[1]，以此类推 应用实例
python大一知识点,Python复习知识点（一）
weixin_35804557的博客
03-26 4639
. python简介Python是一种解释型语言Python使用缩进对齐组织代码执行，所以没有缩进的代码，都会在载入时自动执行数据类型：整形 int 无限大浮点型 float 小数复数 complex 由实数和虚数组成Python中有6个标准的数据类型：Number(数字)String(字...
Python学习：split()方法以及关于str.split()[0]等形式内容的详细讲解
热门推荐
do_you_ac_today的博客
05-18 1万+
str.split(str="", num=string.count(str)). 参数： str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。 num – 分割次数。默认为 -1, 即分隔所有。 返回值： Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串 返回分割后的字符串列表。 代码示例： 输入 str = "Line1-abcdef \nLine2-abc \nLine4-abcd"; pr.
【一句一句讲代码】pytorch深度学习第一天：Dataset类
qq_52446584的博客
01-21 4765
来自于b站《PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】》本篇内容主要是对代码中的一些小知识点进行归纳总结，因为博主本人也是pytorch甚至python新手，一点一点查资料比较费劲，希望对大家（尤其是我的小宝贝）有所帮助。
split(" ")[3].split(":")[0];
qq_41815950的博客
01-17 6688
例： new Date().toString().split(" “)[3].split(”
python复习题库
qq_45746940的博客
12-27 298
https://blog.csdn.net/qq_43925089/article/details/106533251
用python复习小学知识
m0_74859128的博客
11-22 299
学习九九乘法表
【python复习笔记】
一名在读学生
08-02 876
python复习笔记
Python复习总结
喝醉的咕咕鸟
11-09 606
⼀. 解释器的作⽤ Python解释器作⽤：运⾏⽂件。 Python解释器种类： CPython，C语⾔开发的解释器[官⽅]，应⽤⼴泛的解释器。 IPython，基于CPython的⼀种交互式解释器。 PyPy，基于Python语⾔开发的解释器。 Jython，运⾏在Java平台的解释器，直接把Python代码编译成Java字节码执⾏。 IronPython，运⾏在微软.Net平台上的Python解释器，可...
Python复习要点.pdf
02-29
复习要点 、Python基础知识 版本问题 输入/输出：input() 格式化输出 、基础数据类型 、运算符 、表达式：合法性 、序列： 、程序结构 if for 循环、while循环，break、continue 、函数 ...
Python复习笔记
04-27
Python爬虫笔记，python基础知识，以TXT文件呈现 一、概述 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。 Python为我们提供了非常完善的基础代码库，...
2021上python复习提纲（jsj）.doc
07-10
以下是一些根据提供的复习提纲整理的关键知识点： 1. **变量与数据类型**：Python中的变量不需要预先声明，可以直接赋值使用，且变量类型是动态的。变量区分大小写，支持整型(int)、浮点型(float)、布尔型(bool)等...
python复习题资料
01-04
Python复习题资料 Python是一个功能强大且灵活的编程语言，广泛应用于数据分析、机器学习、Web开发等领域。下面是根据提供的练习题资料，总结出的相关知识点。 面向对象编程 在Python中，面向对象编程（OOP）是一...
资料二级Python复习资料资料二级Python复习资料
09-05
资料二级Python复习资料资料二级Python复习资料提取方式是百度网盘分享地址
【工具】Windows｜两款开源桌面窗口管理小工具Deskpins和WindowTop
qq_46106285的博客
09-21 859
写这篇的初衷是怕自己忘了这两个工具的名字。
简单题101. 对称二叉树 （python）20240922
Sep21m_wyy的博客
09-22 302
【代码】简单题101. 对称二叉树 （python）20240922。
ubuntu安装libtorch
最新发布
meng_152634的博客
09-25 549
nouveau是由第三方为NVIDIA显卡开发的一个开源3D驱动，ubuntu默认集成了nouveau驱动，安装NVIDIA驱动前必须禁用系统自带的显卡驱动nouveau，否则安装NVIDIA驱动时会报错。，一定要确定好安装的CUDA版本是否支持显卡的算力，否则安装成功也无法使用GPU加速。如果cmake版本低于3.18，会出现下面的报错，这是由于低于3.18的cmake不支持CUDA17的编译，需要更新cmake版本。因为安装的CUDA版本为12.1，这里选择最新版的CUDNN 9.4.0进行安装。
python获取滑块验证码需要滑动的距离
qq_62975494的博客
09-20 554
我们发现图片是base64格式通过API直接发送。
python复习资料黑马
01-20
黑马程序员出品的Python复习资料是非常值得推荐的。他们的资料不仅包含了基础知识的讲解，还有丰富的案例和项目实战，能够帮助学习者更好地理解和掌握Python编程语言。 这些复习资料涵盖了Python的基本语法、数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值