python基础速过

已于 2024-03-19 20:26:46 修改
阅读量356 收藏 10
点赞数 5
文章标签： python
于 2024-03-18 22:09:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrs_haze/article/details/136816946
版权
一、变量命名： 不能以数字开头，由字母、数字、下划线组成。不能起关键字、保留字、内置函数。
dir(__builtins__)  # 内置函数

import keyword   #关键字
print(keyword.kwlist)
 二、变量类型
type() #查看变量类型

整数型int、 浮点型float、布尔型bool、复数complex

三、 单引号、双引号、三引号

单引号、双引号不支持换行，三引号支持换行（一般用来多行注释）

四、字符串的拼接
# 使用 + 拼接
'2024' + '年' + '10' + '月' + '20' + '日'

# %s
'%s年%s月%s日'%(str1,str2,str3)

# join
'-'.join([str1,str2,str3])

# format
'{}年{}月{}日'.format(str1,str2,str3)
'{1}年{2}月{0}日'.format(str1,str2,str3)

# f''
f'{str1}年{str2}月{str3}日'
五、常见的数值模块
import decimal  #导入，高精度模块必须用字符串导入
decimal.Decimal('2.2') - decimal.Decimal('2')

import math #导入数学模块
math.pow(2,3) #x的y次方
math.sqrt(9)  #开平方
math.fabs(-1) #绝对值
math.pi    #圆周率
 六、条件语句
#非逻辑  not  取反

#三者之间的优先级  not>and>or

#逻辑短路  and  or

# 三目运算
print('大于5' if a>5 else '不大于5')

#for循环  计数循环
#'python'可迭代对象
for i in 'python':
    print(i)

#range()内置函数
#当range函数里面只写一个参数时，默认从0开始
#当range函数里面写了两个参数时，[开始  结束)  左闭右开
#当range函数里面写了三个参数时，开始  结束  步长
for i in range(5,11,3):
    print(i)
七、列表
#1.索引值从0开始  索引取值超过索引长度会报错
#2.负索引从列表的尾部开始往前取，负索引从-1开始

#3.切片 遵循左闭右开
# 从左往右切割，步数为正数
# 从右往左切割，步数为负数
li = [1,2,3,5,4,2]
li[2:5:3]


#4.增删改查
#查  根据元素查找元素的索引值
index()

#增   追加   加在最后
append() 

#指定位置插入元素
insert(下标,元素)

#批量添加  添加时要加[ ]
extend()
 
pop()  #默认删除最后一个元素  加下标删除对应元素
remove()   #根据元素名称删除元素
del     #批量删除
clear()   #清空所有元素

#改    直接赋值语句进行修改


#5.其他方法
copy()  #复制
sort() #排序   同类型才能排序 
reverse()  #反向   
sort(reverse=True)  #反向排序
sorted()   # 临时排序
sorted(li,reverse=True)   # 临时反向排序
count()   #计数
八、元组（tuple）

是不可变序列，用小括号定义元组，一旦生成就不可增删改。

可切片、index()查、count()计数、拆包

#初始化一个元组
tuple = ()

#元组里面保存一个数的两种写法
tuple = 2，
tuple = (2,)

#拆包
tuple=(1,2,3,4,5,6)
a,b,*c=tuple
#单个打印的： print(c) 这里不带星号
print(a,b,*c)

#装包:就是讲多个值进行组合,打包为一个容器类型的过程
a=1
b=2
c=3,4,5,6
print(a,b,c)
九、字符串
replace()  #替换
str1.replace('l','c',1)  # 数字代表替换的个数  只能从前往后替换
upper()  #大写
lower()  # 小写
capitalize()   #首字母大写
title()   #标题形式   每一个单词的首字母都会大写
strip()  #去掉字符串两边的空格

#切割   
split()  #默认以空格进行切割  默认不限制次数 -1
    #添加参数   指定切割符
    #还能添加数字   表示限定次数

#拼接  
join()


#查找   
index()  #默认找到第一个元素的位置
             #后面也可以指定元素开始查找的位置
             #如果找不到元素，就会报错
find()  #  如果找不到元素，就会返回-1


#其他方法
isalpha()  #判断是否全是字母
isdigit()  #判断是否全是数字
islower()  #判断是否全是小写
isupper()  #判断是否全是大写


#字符串的转义
# \n   换行*
# \t   水平制表符   实现对齐*
# \b   往前退一格   相当于退格键
# \a   系统提示音
# \0   产生一个空格
# \    取消字符串的转义
# r    统一取消字符串的转义*


#编码和解码  什么形式编码就要以什么形式解码，不然就会出现乱码
encode('utf-8') # 编码
decode()  #解码  默认解码格式就是utf-8
十、字典

无顺序，无法索引取值，只能通过键名一一对应。

#定义字典的方式
dic = {}
dic = {'x':1,'y':2,'z':3}   #常规的定义方式
dic = dict(a=1,b=2,c=3)  #利用dict函数
#增删改查
#查   根据键名取值  如果键不存在则会报错
get() #查找键对应的值  如果不存在则返回None

#增   setdefault(键名，键值)    "无则增，有则查"

#改   根据键修改值   赋值语句
      #update()   "无则增，有则改"
dic.update({'d':9，'x':'ww'})

#keys()得到所有的键
#values()得到所有的值
#items()得到所有的项（键值对）


#删  pop(键名) 根据键名删除数据
     #popitem()   只在3.6之后按添加进去的顺序删除
     #clear()   一键清空
十一、集合 set 散列
#定义集合{}   集合里面的数据都是单一的，没有重复
#集合里面的值具有唯一性，会自动去重，并且也是无序的
#不能索引取值

#交集 &   两个集合里面相同的元素   空集合set()
#并集 |   两个集合的元素合并在一起
#差集 -   前面的集合减去后面的集合中相同的元素


isdisjoint() #判断两个集合是否没有交集
issubset() #判断前面的集合是否被包含于后面的集合
issuperset() #判断前面的集合是否包含后面的集合
十二、身份运算符

is 判断两者之间内存地址是否一致

python当中存在内存池  范围在[-5,256]

范围内的内存地址一致，范围外的内存地址不一致

is not  取反
 

十三、成员运算符

in 判断元素是否属于对象里面的成员
not in  取反
不管是序列类型还是散列类型都可以用成员运算符
数值类型不行，也数值类型本身就是一个值

 

十四、  is not 和！=区别 ， is和== 的区别

 is  判断地址是否相等，两个变量是否指向同一内存地址
==  判断两个变量的值是否相等

>>> a = 300
>>> b = 300
>>> a is not b
True
>>> a != b
False
# is、 is not
#python当中存在内存池  范围在[-5,256]，范围内的内存地址一致，范围外的内存地址不一致

 

十五、函数（驼峰命名法）
#return 返回值
#return后面的语句不会执行
#把返回的值通过一个变量去接收
#无返回值，则返回None


#函数参数(必备参数，默认参数，不定长参数)
#必备参数一定要传入值



#在这个函数里面有两个参数，一个是x，一个是y
#x,y叫做必备参数
#y=100中y叫做默认参数
#args,kwargs不是规定写法，但是这是规范写法
#args是不定长参数，数据放在元组里面
#kwargs是不定长参数，数据放在字典里面,dict()函数
def func(x,y=100,*args,**kwargs):
    print(x)
    print(y)
    print(args)
    print(kwargs)
**********************
>>> func(1)
1
100
()
{}
**********************
>>> func(1,1000,20,4,1,3,a=1,b=3,c=9)
1
1000
(20, 4, 1, 3)
{'a': 1, 'b': 3, 'c': 9}
************************
>>> func(1,1000000,1000,100000,100000000,1000000,100000)
1
1000000
(1000, 100000, 100000000, 1000000, 100000)
{}
  • 函数作用域
#在函数外部定义的变量，全局变量
#在函数内部定义的变量，局部变量
#函数不会改变传入的不可变对象的值

#结果报错：赋值前引用了局部变量x
x = 100
def func():
    x = x + 1
    print(x)
  • 声明全局变量
x = 100
def func():
    global x
    x = 200
    print(x)

print(x)
func()
print(x)
#运行：100 200 200
  • 声明局部变量
#内层函数不能修改外层函数变量的值
#两个变量都是局部变量
#nonlocal声明局部变量，告诉系统你要对外层函数的变量作修改
def func():
    x = 100
    def func1():
        nonlocal x
        x = x + 1
        print(x)
    return func1()
  • 闭包
#内层函数使用外层函数中的变量
#外层函数的返回值是内层函数的函数体
def func():
    lv = 5
    #增加血量
    def func1():
        nonlocal lv
        lv += 1
        print(lv)
    #减少血量
    def func2():
        nonlocal lv
        lv -= 1
        print(lv)
    return func1,func2
#闭包案例2
# 定义内部函数：
def outer(num):
    # 2.定义内部函数，在内部函数中使用外部函数的变量
    def inner(num1):
        print(num + num1)
 
    # 3.外部函数返回内部函数的地址
    return inner  # 函数名字就是函数地址
 
 
if __name__ == '__main__':
    # 创建闭包实例
    func = outer(100)  # 此时func相当于是inner
    # 调用闭包
    func(10)  # 此时调用inner函数，保存的num值为100
# 可以创建多个闭包实例，不同的闭包实例之间，不会相互影响
 十六、文件
  • 文件的基本操作

        open函数打开文件
        默认以只读（r）打开，只能打开已经存在的文件
         w 只写形式打开，如果文件不存在，则会创建文件
        相对路径：从当前文件出发
        ./代表同级目录    ../代表上一级目录
        绝对路径：从磁盘位置出发
        open(r'C:\Users\Desktop\test.py','w')

  • 文件的写入
##以只写形式打开文件，每次打开文件都会清空文件之前的内容
##  a 追加形式打开文件，不会覆盖文件之前的内容
##f代表txt文件
f = open('test.txt','a')
f.write('\nhello world!')   #写入单个内容
f.writelines(['\nthis','\nis','\npython'])   #写入多个内容
f.flush()   #flush刷新，保存数据
f.close()  #关闭文件，自动保存
  • 文件的读取
f = open('test.txt','r')
#read()  不写值的情况下，读取文件的全部内容
#在写值的情况下，读取一定长度的内容
##print(f.read(10))
print(f.readlines())
f.close()
  • 文件可读可写
#r+  会替换原先的数据
#a+  不会替换原先的数据，以追加的方式加入内容
f= open('test.txt','a+')
f.write('\nhello world4')
f.write('\nhello world5')
f.write('\nhello world6')
print(f.tell())   #查看当前文件指针的位置
f.seek(0)   #把文件指针移到文件开头
print(f.read())
f.close()
  • 二进制
f = open('test.txt','ab+')  #追加写入二进制文件
f.write(b'\nhello world7')
f.seek(0)
print(f.read())
f.close()
  • 自动关闭文件 with open上下文管理器
#as是把打开的文件取名为f
with open('test.txt','a+') as f:
    f.seek(0)
    print(f.read())
  • 文件流 临时假文件

读文件：.read() 和 .getvalue()区别

import io
#生成字符串临时假文件
str_io = io.StringIO()
str_io.write('my name is anyan')
##str_io.seek(0)
##print(str_io.read())
#getvalue()方法获取文件内容，并且不需要重新定义光标的位置
print(str_io.getvalue())
str_io.close()

#二进制临时假文件
b_io = io.BytesIO()
b_io.write(b'hello world')
print(b_io.getvalue())
b_io.close()
  • 和操作系统交互的os模块
import os
os.getcwd() #获取当前文件的路径
os.chdir()#切换路径
os.listdir() #查看路径下的文件和子目录


os.mkdir('abc')  # 创建文件夹
os.rmdir('abc')   #删除文件夹
os.makedirs(r'aaa\bbb\ccc')  # 创建多层目录
os.removedirs(r'aaa\bbb\ccc')  #删除多层目录
os.system('cmd')  #打开cmd
os.system('python')  #打开cmd,并执行python的命令
os.walk()   #遍历文件夹
os.remove()  #移除文件
os.rename()   #文件重命名
os.path()   #对于文件路径的操作  可以和join实现路径的拼接
十七、模块导入

#模块导入   在Python里面，模块指的就是一个py文件
#在导入模式时,会先把模块里面的内容全部执行一遍

import datetime   #全部导入

from datetime import datetime   #部分导入

from datetime import datetime as dt  #通过as取别名
十八、类
#name  age   变量->类的属性
# eat        函数->类的方法
class Person:

    #__init__初始化方法，在实例化时会自动调用
    #self代表实例本身
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(f'{self.name}吃饭')

    #析构函数，当删除实例s时，就会调用此方法
    #通过del关键字来删除对象
    # del dou5
    def __del__(self):
        print(f'{self.name}被析构了')
        
dou5 = Person('xiaobai',18,'男')
十九、继承
class Person:
    name = 'xiaobai'
    age = 18
    sex = '男'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    
    def __del__(self):
        print(f'{self.name}被析构了')
        
    def eat(self):
        print(f'{self.name}吃饭')

#创建的四川类，继承了Person类
#继承Person类也就是拥有这个类里面的属性和方法
#Person是SiChuan和GuangDong这两个类的父类

#eat()方法是重用   重新去定义父类的方法
class SiChuan(Person):
    def eat(self):
        Person.eat(self) #方法一
        print('四川人爱吃麻辣烫')
    
    def play(self):
        print('四川人爱打麻将')
    
class GuangDong(Person):
    def eat(self):
        #super代表使用父类的方法,推荐使用
        super().eat()

        print('广东人爱吃肠粉')
    
    def play(self):
        print('广东人爱喝茶')

*****************************************************
>>> dou5 = SiChuan('heihei',12,'nan')
>>> dou5.play()
四川人爱打麻将
>>> dou5.eat()
heihei吃饭
四川人爱吃麻辣烫
>>> dou6 = GuangDong('bb',3,'girl')
>>> dou6.play()
广东人爱喝茶
>>> dou6.eat()
bb吃饭
广东人爱吃肠粉
>>> del dou6
bb被析构了
>>> del dou5
heihei被析构了
二十、多继承 就近继承
class Person:
    name = 'xiaobai'
    age = 18
    sex = '男'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    
    def __del__(self):
        print(f'{self.name}被析构了')
        
    def eat(self):
        print(f'{self.name}吃饭')

class SiChuan(Person):
    def eat(self):
        Person.eat(self) #方法一
        print('四川人爱吃麻辣烫')
    
    def play(self):
        print('四川人爱打麻将')
    
class GuangDong(Person):
    def eat(self):
        #super代表使用父类的方法,推荐使用
        super().eat()
        print('广东人爱吃肠粉')
    
    def play(self):
        print('广东人爱喝茶')

class HunXue(SiChuan,GuangDong):
    pass

hunxue = HunXue('混血',1,'女')

#HunXue.__base__  查看继承的第一个类
#HunXue.__bases__   查看类继承的所有类
#HunXue.mro()  查看继承顺序
#多继承案例2

class base:
    def eat(self):
        print('base')


class A(base):
    def eat(self):
        super().eat()
        print('A')


class B(base):
    def eat(self):
        super().eat()
        print('B')


class C(A,B):
    def eat(self):
        super().eat()
        print('C')
if '__main__':
    cc = C()
    cc.eat()
二十一、面向对象高级 常用的内置函数
#hasattr(anyan,'name')  判断实例对象有没有属性
#getattr(anyan,'name')  获取实例对象对应的属性值
#setattr(anyan,'sex','女')  设置实例对象的属性及属性值  ‘无则增，有则改’
#delattr(anyan,'sex')  删除是实例对象的属性
#issubclass()  判断前面的类是不是后面类的子类
#isinstance()  判断前面的实例是不是后面的实例或者判断类型

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

ddd = Person('低保',18)


class Hunan(Person):
    pass
a = getattr(ddd,'name') if hasattr(ddd,'name') else setattr(ddd,'name','低保')
二十二、属性调用过程
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #重写  引用没有定义的属性不会报错
    def __getattr__(self,item):
        print(f'{item}属性不存在')

ddd = Person('低保',18)
二十三、魔法方法  http://t.csdnimg.cn/uE31x
  1. 让类创建的对象在系统中只有唯一的一个实例
  2. 每一次执行 类名() 返回的对象，内存地址是相同的

 

1）使用类名()创建对象时，Python解释器做的2件事：
  1. 使用 类名() 创建对象时，Python解释器首先会调用__new__方法为对象分配空间
  2. Python的解释器获得对象的引用后，将引用作为第一个参数，传递给__init__方法

 

2）重写__new__方法的代码非常固定：
  1. 重写__new__方法一定要返回分配了空间return super().__new__(cls)
  2. 否则Python的解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法

 3） 让初始化只执行一次

class MusicPlayer(object):
    # 记录第一个被创建对象的引用
    instance = None
    # 记录是否执行初始化动作
    init_flag = False
 
    def __new__(cls, *args, **kwargs):
 
        # 1. 判断类属性是否是一个空对象，没有是空对象，说明第一个对象还没被创建
        if cls.instance is None:
            # 2. 调用父类的方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)
 
        # 3. 返回类属性保存的对象引用
        return cls.instance
 
    def __init__(self):
 
        # 1. 判断是否执行过初始化动作
        if MusicPlayer.init_flag:
            return
        # 2. 如果没有被执行过，再执行初始化动作
        print("初始化方法执行")
 
        # 3. 修改类属性init_flag的值为True
        MusicPlayer.init_flag = True
 
 
# 创建多个对象，对比地址是否相同
player1 = MusicPlayer()
print(player1)
 
player2 = MusicPlayer()
print(player2)

 

二十四、序列协议
class IndexTuple:
    #*args接收传进来的值
    def __init__(self,*args):
       self.values = tuple([i for i in args])
       self.index = tuple(enumerate(self.values))


    def __len__(self):
        return len(self.values)

    #key代表索引
    def __getitem__(self,key):
        return self.index[key][1]
        
    def __repr__(self):
        return str(self.values)

AdaminaWhisper
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《Python基础教程》内容总览篇
weixin_43178406的博客
08-26 13万+
大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。个人精心开设的《Python基础课程》专栏订阅量接近900，帮助不少同学解决了Bug。
Python语法速查手册
禅与计算机程序设计艺术
07-30 1912
Python是一种高级编程语言，它的强大功能也使它成为数据科学、Web开发、游戏编程等领域的一流工具。但由于其高门槛，并非所有人都可以快速上手，因此，我整理了一些基础知识和Python语法，帮助大家快速熟悉Python编程。本文适合刚入门的初学者学习，希望通过阅读本文，能够掌握Python语法和相关用法，提升编程能力，加快自己的职业生涯。Python是一种解释型、面向对象、动态数据类型的高级编程语言。它具有简洁、易读、明确的代码风格，在代码量不大的情况下，Python通常被认为比其他语言更容易学习。
python基础知识速查表
qq_45298339的博客
05-05 1257
##这是我自己学习过程中总结的文章是复制过来的可读性差，需要word文档的私信我##### Python基础知识 Python入门 1.注释的分类 单⾏：# 注释内容 ，快捷键ctrl+/ 多⾏： """ 注释内容 """ 或 ''' 注释内容 ''' 2.定义变量： 变量名 = 值 标识符：数字、字⺟、下划线组成 不能数字开头 不能使⽤内置关键字 严格区分⼤⼩写 3.bug工具： 打断点，调试 4.数据类型 ： 整型：int 浮点型：float 字符...
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 111万+
Python 入门必备知识，你都掌握了吗？
Python基础语法
qq_45443475的博客
05-06 1608
示例：%5d：表示将整数的宽度控制5位，如数字11 会变成【空格】【空格】【空格】11。（1）单行注释：以#号开头 起辅助说明的作用，#号和注释内容一般建议以一个空格隔开，（2）多行注释：以 一对三个双引号 引起来（"""注释内容"""）m：控制宽度，要求是数字（很少使用），设置宽度小于数字自身，不生效。m.n的形式（m和.n均可省略）：如%5d、%5.2f、%.2f。（3）三引号：name = """tangbb"""（2）字符串：%s、整数：%d、浮点数：%f。（1）概念：在程序运行时，记录数据用的。
Python基础手册
爱测乐园
11-05 4389
python基础
python速查手册 模块卷_Python速查手册·基础卷（全彩版）
weixin_31493101的博客
02-21 919
本书通过“语法参考”“快用锦囊”“应用场景”3个主要版块，全面细致地讲解Python中提供的内置函数、基本语句、常用开发技能等内容。全书共16章，包括输入输出、格式化处理、基本语句、字符串操作、列表、元组、字典、集合、数学运算与数字处理、数据类型转换、迭代、序列操作、对象操作、反射操作、编译执行、装饰器等，在附录中介绍了Python中运算符的应用。全书包含245个语法参考、595个快用锦囊和57个...
python基础
weixin_43904081的博客
06-21 776
Python入门
【Python】python基础之搭建环境
2301_79585673的博客
09-05 951
python
python3速查表_干货 | 28张相见恨晚的速查表（Cheat Sheet）——Python篇
weixin_39919165的博客
11-30 748
干货 | 28张相见恨晚的速查表(Cheat Sheet)——Python篇
Python基础知识大全.pdf
05-05
Python 基础知识大全 Python 是一种广泛使用的高级编程语言，具有灵活、简洁、易学易用等特点。本文档旨在总结 Python 的基础知识，作为 Python 初学者或需要快速查询 Python 基础知识的开发者的查询手册。 目录 ...
Python速查表.zip
09-02
【Python速查表】 在编程领域，Python是一种广泛使用的高级编程语言，以其简洁、易读的语法和强大的功能而受到开发者们的青睐。Python速查表是程序员日常开发中不可或缺的工具，它通常包含了语言的关键特性、常用...
python基础知识 速查表
05-04
这份“Python基础知识速查表”是学习和巩固Python知识的重要工具，涵盖了从基础语法到常用库函数的诸多方面。以下是对这份文档可能包含内容的详细说明： 1. **基本语法**： - 变量与数据类型：包括整型（int）、...
Python基础知识大全速查.docx
05-05
Python 基础知识大全速查 Python 是一种广泛使用的高级编程语言，易于学习和使用。作为初学 Python 的人，了解 Python 的基础知识是非常重要的。本文将从基础知识入手，详细介绍 Python 的基础概念和语法。 注释...
python基础语法合集68页.pdf
05-08
在实际编程中，了解这些基础知识是学习Python的第一步，它们构成了Python语法的核心，为后续的进阶学习和实际项目开发打下坚实基础。无论是初学者还是有经验的程序员，熟悉并掌握这些基本概念和用法都是至关重要的。
全网最详细Gradio教程系列5——Gradio Client: python
最新发布
shao918516的博客
07-26 737
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
随机数种子的作用
帆的博客
07-23 1258
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
安卓手机部署大模型实战
奇舞周刊
07-25 516
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1564
Java实现拼图小游戏
Python基础速查表
09-15
Python基础速查表提供了Python编程的基础知识点，包括关键字、数据结构、复杂数据类型、类、函数、面向对象编程等内容。此外，它还包含了一些常见的面试问题以及Numpy和机器学习的内容。通过查阅这个速查表，你可以快速回顾和查找Python编程的基础知识。以下是一些相关问题： 相关问题: 1. 这个速查表是否包含常见的Python库和模块？ 2. 是否有其他类似的速查表可供参考？ 3. 你能否提供一个链接或资源来获取这个Python基础速查表？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值