【Python基础：语法第一课】Python 基础语法详解：变量、类型、动态特性与运算符实战，构建完整的编程基础认知体系

艾莉丝努力练剑2025-11-29 10:17


🎬 个人主页 ：艾莉丝努力练剑
❄专栏传送门 ：《C语言》《数据结构与算法》《C/C++干货分享&学习过程记录》
《Linux操作系统编程详解》《笔试/面试常见算法：从基础到进阶》《Python干货分享》

⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平

🎬 艾莉丝的简介：

文章目录

  • [1 ~> 常量和表达式](#1 ~> 常量和表达式)
  • [2 ~> 变量和类型](#2 ~> 变量和类型)
    • [2.1 变量是什么](#2.1 变量是什么)
    • [2.2 变量的语法](#2.2 变量的语法)
      • [2.2.1 定义变量](#2.2.1 定义变量)
      • [2.2.2 使用变量](#2.2.2 使用变量)
    • [2.3 变量的类型：对于不同种类的变量作出区分](#2.3 变量的类型：对于不同种类的变量作出区分)
      • [2.3.1 整数](#2.3.1 整数)
      • [2.3.2 浮点数(小数)](#2.3.2 浮点数(小数))
      • [2.3.3 字符串](#2.3.3 字符串)
      • [2.3.4 布尔（真 / 假）](#2.3.4 布尔（真 / 假）)
      • [2.3.5 其他](#2.3.5 其他)
    • [2.4 变量类型带来的意义(不仅仅是分类)：为什么要有这么多类型?](#2.4 变量类型带来的意义(不仅仅是分类)：为什么要有这么多类型?)
  • [3 ~> 动态类型特性](#3 ~> 动态类型特性)
  • [4 ~> 注释](#4 ~> 注释)
    • [4.1 注释是什么？](#4.1 注释是什么？)
    • [4.2 注释的语法](#4.2 注释的语法)
      • [4.2.1 行注释](#4.2.1 行注释)
      • [4.2.2 文档字符串](#4.2.2 文档字符串)
    • [4.3 注释的规范](#4.3 注释的规范)
    • [4.4 花时间在注释上面值得吗？](#4.4 花时间在注释上面值得吗？)
  • [5 ~> 输入输出](#5 ~> 输入输出)
    • [5.1 和用户交互：控制台](#5.1 和用户交互：控制台)
    • [5.2 基于控制台输出](#5.2 基于控制台输出)
    • [5.3 从控制台输入](#5.3 从控制台输入)
  • [6 ~> 运算符](#6 ~> 运算符)
    • [6.1 算术运算符](#6.1 算术运算符)
      • [6.1.1 算术运算符的五个注意点](#6.1.1 算术运算符的五个注意点)
      • [6.1.2 完整流程](#6.1.2 完整流程)
    • [6.2 关系运算符](#6.2 关系运算符)
      • [6.2.1 关系运算符的三个注意点](#6.2.1 关系运算符的三个注意点)
      • [6.2.2 完整流程](#6.2.2 完整流程)
    • [6.3 逻辑运算符](#6.3 逻辑运算符)
      • [6.3.1 逻辑运算符的一些注意事项](#6.3.1 逻辑运算符的一些注意事项)
        • [6.3.1.1 一种特殊写法](#6.3.1.1 一种特殊写法)
        • [6.3.1.2 关于短路求值](#6.3.1.2 关于短路求值)
      • [6.3.2 完整流程](#6.3.2 完整流程)
    • [6.4 赋值运算符](#6.4 赋值运算符)
      • [6.4.1 = 的使用](#6.4.1 = 的使用)
        • [6.4.1.1 链式赋值](#6.4.1.1 链式赋值)
        • [6.4.1.2 多元赋值](#6.4.1.2 多元赋值)
        • [6.4.1.3 代码实例：交换两个变量](#6.4.1.3 代码实例：交换两个变量)
          • [6.4.1.3.1 基础写法](#6.4.1.3.1 基础写法)
          • [6.4.1.3.2 基于多元赋值](#6.4.1.3.2 基于多元赋值)
      • [6.4.2 复合赋值运算符](#6.4.2 复合赋值运算符)
      • [6.4.3 完整流程](#6.4.3 完整流程)
    • [6.5 其他](#6.5 其他)
  • [7 ~> Python基础：语法篇第一部分总结](#7 ~> Python基础：语法篇第一部分总结)
  • [8 ~> Python基础：语法篇第一部分自测小练习](#8 ~> Python基础：语法篇第一部分自测小练习)
    • [8.1 例题1](#8.1 例题1)
    • [8.2 例题2](#8.2 例题2)
    • [8.3 例题3](#8.3 例题3)
  • 结尾

1 ~> 常量和表达式

我们可以把Python当成一个计算器，来进行一些算术运算。

python 复制代码 
# 表达式
# 优先级：先乘除后加减
print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)

print是一个Python内置的函数，这个我们稍后会作详细介绍，先小小卖个关子！

我们可以**使用+ - * / ()等运算符进行算术运算**，先算乘除，后算加减。

运算符和数字之间，可以没有空格，也可以有多个空格，但是一般习惯上写一个空格（比较美观）------关于这点，美观重要吗？

代码的美观，是否重要呢？这是个看脸的世界！代码如果简洁美观，也让将来的自己看得懂。

print(1 + 2 / 3)的结果输出可以看到是：1.6666666666666665，在Python中，2 / 3 => 0.666666 而不是0！！！在C / Java中，整数除以整数的结果还是整数！并且会把小数部分直接舍弃！输出：1.6666666666666665，为什么最后不是667？？编程中，一般没有"四舍五入"这样的规则！在Python中是浮点数，IEEE754标准->在这套规则下，在内存中表示浮点数的时候，可能会存在微小的误差。

形如1 + 2 - 3称为表达式，这个表达式的运算结果称为表达式的返回值，1 2 3这样的数字，称为 字面量常量 ，+ - * /称为运算符运算符或者操作符。

注意：熟悉C / Java的uu可能会认为，2 / 3（在C/C++里面是整除）结果为0（小数部分被截断），但是在Python中得到的结果则是一个小数，其实Python这种更符合我们日常使用的直觉（单纯的除号）。

我们来看一个示例，说：给定四个分数，67.5，89.0，12.9，32.2，编写代码，求这四个分数的平均数。

python 复制代码 
print((67.5 + 89.0 + 12.9 + 32.2) / 4)      #优先级

Python没那么多弯弯绕绕，直接写完了，注意这里有一个优先级问题即可。

2 ~> 变量和类型

2.1 变量是什么

有时候, 我们需要进行的计算可能更复杂一些, 需要把一些计算的中间结果保存起来. 这个时候就需要用到 变量。

示例：给定四个分数，67.5，89.0，12.9，32.2，编写代码，求这四个分数的方差。

PS：方差的计算过程：取每一项，减去平均值，计算平方，再求和，最后除以 (项数 - 1）------

求方差：

  1. 计算平均值；
  2. 针对每个数字，分别计算数字和平均值的差值，再平方；
  3. 把上述的平方值相加；
  4. 除以(项数 - 1)。

1、计算平均值，用一个变量avg把平均值保存起来；

python 复制代码 
avg = ((67.5 + 89.0 + 12.9 + 32.2) / 4)

2、针对每个数字，分别计算数字和平均值的差值，再平方，再用另外一个变量total保存一下得到的结果，再要使用这个结果时只要用变量表示即可------变量起到的功能：可以视为一块用来存储数据的空间（想象成一个纸盒子），变量是存在内存上面的，我们下面还会再谈到这个话题，这里先提一嘴！

3、把上述的平方值相加；

python 复制代码 
total = ((67.5 - avg) **2 + (89.0 - avg) **2 + (12.9 - avg) **2 + (32.2 - avg) **2)

4、上述结果除以(项数 - 1)，注意：是除以项数 - 1，不是除以项数之后再 - 1！

python 复制代码 
result = total / 3
print(result)
#方差结果：1173.2866666666666

在这个代码中，就需要先计算这四个数字的平均值，然后再计算方差，这就需要把计算的平均值使用变量保存起来！

avg，total， result 均为变量，在Python中表示乘方运算2即为求平方。

就像计算器中的 M 键功能类似, 通过变量就可以保存计算过程中的中间结果------

只不过，计算器一般只能保存一个数据，而在 Python 代码中，可以创建任意多的变量，来随心所欲的保存很多很多的数据。

变量可以视为是一块能够容纳数据的空间 ，这个空间往往对应到 "内存" 这样的硬件设备上。

PS：我们可以把内存想像成是一个宿舍楼，这个宿舍楼上有很多的房间，每个房间都可以存放数据。

衡量内存的一个重要指标就是内存空间的大小，比如艾莉丝的电脑内存是16 + 16，32GB，这个数字越大，意味着内存的存储空间就越大，能够存放的数据（变量）就越多，1T、2T那个是硬盘大小哦！那个是长期存储数据（几年），内存是一断电数据就没有了。

2.2 变量的语法

2.2.1 定义变量

python 复制代码 
a = 10

创建变量的语句非常简单, 其中a 为变量名。当我们创建很多个变量的时候，就可以用名字来进行区分。

这里的 = 为赋值运算符，表示把 = 右侧的数据放到 = 左侧的空间中，表示数学上的"比较相等"。

像这样写就报错了------

python 复制代码 
a * a = 10

会报什么错呢？报这样的错------无法赋值给运算符。

注意：变量的名字要遵守一定规则！

有哪些规则呢？艾莉丝已经整理成了思维导图，一张图搞定！

数学上，变量通常使用 x、y、z 这种简单的英文字母或者拉丁字母表示，但是在编程中不建议这样使用。

为什么呢？原因是编程中，一个程序里通常会同时创建出很多个变量，如果只是使用单个字母表示，在变量多了的时候，就很难记住哪个变量是干啥的，从而给维护程序带来了一定的困难------因此我们更建议使用带有明确描述性的名字，来表示变量的用途。

那么取名字就是一个需要严格规范的事情了，既然是为了表示变量的用途，不能随随便便取个名字，具体命名规范见上图。

2.2.2 使用变量

如下图所示------

什么意思呢，直接看艾莉丝的演示------

python 复制代码 
# 变量的使用
a = 10
b = a
print(b)    #变量的读取

# 首次使用 = 对a进行设置值，这个过程是创建变量（初始化）
a = 20
print(a)    #后续再对a使用 = 操作相当于修改a的内容（赋值）

2.3 变量的类型：对于不同种类的变量作出区分

变量里面存储的不仅仅是数字，还可以存储其它种类的数据。为了区分不同种类的数据，我们引入了 "类型" 这样的概念。

注意：和 C++ / Java 等语言不同，Python 变量的类型不需要显式指定，而是在赋值的时候确定的（是的，就是这样）。

Python的设计哲学：解决一个问题，只通过一种方案------更加简洁直观，也降低了Python的学习成本。

2.3.1 整数

python 复制代码 
# 1.整数int(所有的整数都用int表示)
#初始化类型确定为int，全看赋了什么值，这里赋了10，就是int
a = 10        
print(type(a))
# Python中的变量的类型，不需要在定义变量的时候显式声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定
# 在Python，int能够表示的数据范围是"无穷"的
# Python的int是可以根据要表示的1那个数据的大小，自动扩容的
# Java的int最大就能表示到-21亿 ~ +21亿这个范围
# 因此Python这里就没有long这样的类型了，像byte，short这些类型在Python中也不存在

注意：type 和 print 类似，也是 python 内置的函数，我们 可以使用 type 来查看一个变量的类型。

注意：和 C++ / Java 等语言不同，Python 的 int 类型变量，表示的数据范围是没有上限的------它会根据数据的大小不断扩容，只要内存足够大，理论上就可以表示无限大小的数据。

2.3.2 浮点数(小数)

python 复制代码 
# 2.浮点数（小数）float（一个float表示所有的浮点数）
b = 0.5
print(type(b))
# 像C++和Java里面，float是四个字节的，也叫做"单精度浮点数"
# 字节：把一个二进制位称为一个bit，8个bit放在一起就称为是一个字节
# double是八个字节的，也叫做"双精度浮点数"
# Python中的float就是"双精度浮点数"，等同于C++ / Java里的double，不需要什么double了

注意：和 C++ / Java 等语言不同，Python 的小数（浮点数）只有 float 一种类型，没有 double 类型------但是实际上 Python 的 float 就相当于 C++ / Java 的 double，表示双精度浮点数。

PS：关于单精度浮点数和双精度浮点数的问题，我们此处不作过多讨论。

uu们只要知道：相比于单精度浮点数，双精度浮点数占用的内存空间更多，同时表示的数据精度更高 (大概精确到小数点后15 位) 。

2.3.3 字符串

python 复制代码 
# 3.字符串
# 像羊肉串一样把一块块羊肉串在一起似的，字符串是把一个个字符放到一起
# 英文字母，阿拉伯数字，标点符号，甚至汉字符号，都可以认为是"字符"，如a、8、+、-这些都是字符
# Python中要求使用引号把一系列的字符引起来就构成了字符串
# 引号使用'或者"都是可以的
c = 'hello'
print(type(c))

d = "hello"
print(type(d))
# 搞两种引号是有必要的!举个例子,有一段话:My name is "Alice Greyrat"
# 如果把这段话作为字符串
# e = "My name is "Alice Greyrat""    #中间这部分,Python不认识了
# 波浪线：三种颜色-->黄色是警告,你这个代码可能有点问题,但不影响运行;红色是可能会影响运行;绿色如下所示
e = 'My name is "Alice Greyrat"'     #绿色的波浪线:拼写检查,是不是常见的字符串,这个字符串Pycharm不认识
print(type(e))
# 因此，如果字符串里面包含了双引号，表示字符串就可以用单引号引起来;
# 反之,如果字符串里面包含了单引号，表示字符串就可以使用双引号引起来;
# 如果同时有单引号和双引号咋办?
# Python中还有一种字符串,使用三引号表示,使用'''或者"""
# f = 'My 'name' is "Alice Greyrat"'        #报错了
f = '''My 'name' is "Alice Greyrat"'''    #可见Python字符串的定义方式还是非常灵活的
print(type(f))

# 我们上述的引号，都是英文的引号，而不是中文的引号
# 利用单引号/双引号/双引号完成字符串内容的表示
# 以上我们创建的这几种引号都是等价的关系,具体在写代码的时候哪个方便用哪个,没有实际的影响

# 使用内置函数len(length)来查看字符串的长度(多长其实就是字符串里面包含了几个字符)
print(len(d))

# 字符串拼接
# 形如下面这样的代码，就是"字符串拼接",也就是把后面的字符串拼接到前一个字符串的末尾
# 得到了一个更大的字符串！（对于原来的a1,a2是没有影响的）
a1 = 'hello'
a2 = 'a1 + a2'
print(a1 + a2)  #字符串相加就是字符串的拼接运算
# 整数和浮点数的运算是算术运算
# 字符串的相加是特点含义,比如这里是把a2这个字符串的内容完全拼接在a1的后面

# 在Python中,我们不能把字符串和整数相加
# b1 = 'hello'
# b2 = 10
# print(b1 + b2)      #这里并没有报错
# 运行的时候报错了,TypeError: can only concatenate str (not "int") to str(我们不能拼接字符串和整数)

在Python中，报错，有两种情况：

1、语法错误：在程序运行之前，Python解释器，就能把错误识别出来；

2、运行错误：在程序运行之前，识别不了的，必须要执行到对应的代码，才能发现问题。

实际开发中，运行错误要比语法错误严重得多！产品万一已经发布给用户使用，人家运行出现错误了，就丸辣！这就像是相亲,刚见面就感觉对方不是自己的菜，直接结束了(语法报错)，和对象在一起前(相亲时)可能没发现有什么不合适的，在一起之后感觉对方有自己不能接受的一面(运行报错)。


使用 ' ' 或者 " " 引起来的，称为字符串，可以用来表示文本。

注意：在 Python 中，单引号构成的字符串和双引号构成的字符串，没有区别------ 'hello' 和 "hello" 是完全等价的。

我们可以使用内置函数len(length)来查看字符串的长度(多长其实就是字符串里面包含了几个字符)------

python 复制代码 
a = 'hello'
print(len(a))

字符串拼接：我们还可以使用 + 针对两个字符串进行拼接。

python 复制代码 
a = 'hello'
b = 'world'
print(a + b)

此处是两个字符串相加，不能拿字符串和整数/浮点数相加。

字符串作为开发中最常用到的数据类型，支持的操作方式也是非常丰富的，我们此处暂时不详细展开，留到后面介绍。

2.3.4 布尔（真 / 假）

布尔类型是一个特殊的类型，取值只有两种：True (真) 和 False (假)，注意是大写！！！

布尔类型也是数学上的一个概念！我们初中的时候就学过一个概念叫做 "命题" ，什么真命题假命题，进一步的就可以判定命题的真假！我们这里可以举几个例子------

打个比方，艾莉丝是个万粉博主，一眼假，假命题；比如，艾莉丝是剑士，真命题。

python 复制代码 
a = True
print(type(a))
b = False
print(type(b))

艾莉丝这里演示得再详细一点，配合注释，大家就能理解了！

python 复制代码 
# 4.布尔
# 布尔取值只有真和假,因此布尔类型主要用于逻辑判定
# 这里注意一下大小写问题,Python里面的真(True)假(False),C++/Java可能是true/false(小写的)
# 布尔值来源于"命题",真或者假
c1 = True
c2 = False
print(type(c1))
print(type(c2))
# 这里取c1/c2这种比较简单粗暴的变量名其实是迫不得已,因为这里没有实际应用场景
# 我们写代码尽量起一个好一点的名字
# 关于布尔类型,会在后面的条件/循环介绍

布尔类型在咱们后续进行逻辑判断的时候，是非常有用的。

2.3.5 其他

除了上述类型之外，Python 中还有 list、tuple、dict、自定义类型等等，我们后续再介绍！

2.4 变量类型带来的意义(不仅仅是分类)：为什么要有这么多类型?

1、类型决定了数据在内存中占据多大空间；

python 复制代码 
# 1.不同的类型,占用的内存空间是不同的,占几个字节
# 比如int默认是4个字节,动态扩容
# 比如float固定8个字节
# 比如bool一个字节就足够了
# 再比如str是一个变长的变量,主要看字符串包含的内容

2、类型其实约定了能对这个变量做什么样的操作。

python 复制代码 
# 2.不同的类型,对应能够进行的操作也是不同的
# int / float,可以进行+ - * /运算 ------- 不能使用len
# str 能+,但是不能-不能*也不能/     ------- 以使用len

例如 int / float 类型的变量，可以进行 + - * / 等操作，而 str 类型的变量，只能进行 + (并且行为是字符串拼接), 不能进行 - * /，但是还能使用 len 等其他操作。

总结：类型系统其实是在对变量进行 "归类"，相同类型的变量(数据) 往往具有类似的特性和使用规则。

3 ~> 动态类型特性

在Python中，一个变量是什么类型，是可以在"程序运行"过程中发生变化的.这个特性称为"动态类型"。

python 复制代码 
# 动态类型:指的是[程序运行过程中],变量的类型可能会发生改变。
a = 10
print(type(a))

a:int = 10
print(type(a))

a = 'hello'
print(type(a))

a:str = 'hello'
print(type(a))

a = True
print(type(a))

a:bool = True
print(type(a))

a的类型随着程序的运行，就发生改变，并不会因为":(声明)"而导致类型随着程序的运行不发生改变了，还是会改变的------即，变量声不声明并不会影响到我们的类型系统是静态的还是动态的，所以说在Python里面要不要给变量进行声明完全是一个锦上添花的做法~>方便程序员读代码，并不是一定要的。

再比如这个------

python 复制代码 
a = 10
print(type(a))
a = 'hello'
print(type(a))

在程序执行过程中，a 的类型刚开始是 int，后面变成了 str------

C++ / Java 这样的语言则不允许这样的操作，一个变量定义后类型就是固定的了，这种特性则称为 "静态类型"。

python 复制代码 
# 静态类型:[程序运行过程中],变量的类型始终不变
# C++ / Java
# Java 中的int a = 10;
# a这个变量在程序运行的整个过程中，始终都是int,如果尝试a = "hello"，编译阶段就会报错

# 一个编程语言,是否是动态类型,只是取决于运行时,类型是否发生改变,不取决于变量定义的时候是否声明类型

#Python作为一个动态类型的语言,在定义变量的时候,也是可以写类型的!具体示例见上

# 动态类型写法是比较灵活的--->提高了语言的表达能力
# 然而,在编程中,"灵活"这个词往往是"贬义"的,"灵活"意味着更容易出错!!!
# 编程中往往是反对灵活,更多希望有一些明确的规定,避免程序员放飞自我
# 就像斑马线一样
# 相比之下,静态类型的语言还是更好一些,尤其是在大型的程序中,多人协作开发中,能够减少不必要的沟通,提高效率
# 因此很多公司，在创业之初，喜欢使用Python来开发,产品规模小，也就是一两个程序猿，很快的就能搞出来
# 但是当项目达到一定的规模之后-->动态类型的劣势就逐渐体现了。
# 很多公司就会针对之前Python写的代码使用其他语言进行重构-->推导重写一遍,避免动态类型所产生的一些问题
# 很多创业公司都有过类似的经历,比如知乎/豆瓣/B站...
# 动态类型虽然有它的优势,但它的劣势也很明显,我们在实际开发中还是要结合具体情况来决定使用哪种类型
# Python是动态类型,我们要知道动态类型的劣势,尽量规避劣势

4 ~> 注释

4.1 注释是什么？

python 复制代码 
请在以下程序在求四个数字的方差~>注释(提高代码可读性)
python 复制代码 
avg = ((67.5 + 89.0 + 12.9 + 32.2) / 4)
total = ((67.5 - avg) **2 + (89.0 - avg) **2 + (12.9 - avg) **2 + (32.2 - avg) **2)
result = total / 3
print(result)       #(行注释)这也是注释

4.2 注释的语法

Python中有两种风格的注释------

4.2.1 行注释

使用 # 开头的行都是注释------

python 复制代码 
# 这是一行注释
python 复制代码 
#(行注释)这也是注释

4.2.2 文档字符串

使用三引号引起来的称为 "文档字符串"，也可以视为是一种注释。

python 复制代码 
# #开头的注释，一般是写在要注释的代码的上方;也有少数情况下是写在要注释代码的右侧的
# 很少会写在代码的下方,更不会写到代码的左侧(后面的代码直接变成注释的一部分了)

# """:使用三引号开头引起来的称为"文档字符串",也可以视为一种注释
# """和'''等价
""""         
这是一段文档字符串,它起到的作用和注释一样,也是解释说明的效果.
"""

4.3 注释的规范

python 复制代码 
# 如何写出比较好的注释:
# 1. 注释的内容得是准确的!起到误导作用的注释还不如不写!!!--->不是程序员故意要写的--->公司的项目要经常进行"迭代"
# 本来代码和注释都已经写好了,后来代码一更新,但是注释忘记同步更改了--->但凡要修改代码,务必要记得更新注释

# 2. 注释的篇幅要合理-->既不要太精简(看不懂),也不要长篇大论(别人没有耐心阅读下去)

# 3. 注释使用中文
# 如果是在中国公司,注释当然还是要写咱们得母语中文(很多程序员其实英文水平不好)啦!
# 如果是在外国公司(或者是中国公司对外的业务),这种可能会要求使用英文写注释
# PS:中国公司好?外国公司(外企)好?都有好有坏,不能一言以蔽之

# 4. 注释内容要积极向上,不要有负能量!
# 前几年有一个"事件",有个程序员在在线音乐播放器这个项目里面写了这样一行注释:针对穷比vip(签到做任务得的vip)执行以下逻辑...
# 最后这个程序员被要求全网道歉，所以说注释里面不要有负能量哦！

4.4 花时间在注释上面值得吗？

身为专业的程序员，多花一些心思在写注释上面是完全值得的，我们不光要关心代码本身能不能运行正确，还要关心代码的可读性好不好，容不容易被人理解。

5 ~> 输入输出

5.1 和用户交互：控制台

程序需要和用户进行交互。

输入输出的最基本的方法就是 控制台------用户通过控制台输入一些字符串，程序再通过控制台打印出一些字符串。

PyCharm 运行程序，下方弹出的窗口就可以视为是控制台------

Windows 自带的 cmd 程序，也可以视为是控制台------


输入输出的最常见方法是图形化界面，如我们平时用到的 QQ、浏览器、steam 等，都不需要用户输入命令，而只是通过鼠标点击窗口点击按钮的方式来操作。Python 当然也可以用来开发图形化界面的程序，是图形化程序开发本身是一个大话题，咱们博客里面暂时不作介绍。

python 复制代码 
# 控制台
# 这些对于机械的操作面板，就叫控制台，控制台上会有一些按钮，开关，操作杆...
# 后来有了计算机之后，控制台的概念也就延续下来了~
# 只不过计算机是通过键盘鼠标等进行操作，把操作结果显示到屏幕上
# 计算机里，就把用户能输入命令，向计算机安排工作(就像你的上司和你的关系,你的上司给你布置任务,你去完成,这里上司变成了用户)
# 计算机再把结果显示出来这样的程序，就称为[控制台]了
# 控制台是一种人和计算机交互的最基础方式
# 但是日常生活中却不常用，更常见的交互方式，图形化界面
# 图形化界面的程序编写起来并不容易,课堂上还是使用控制台的方式来进行交互

5.2 基于控制台输出

Python 使用 print 函数输出到控制台------

python 复制代码 
print('hello')

不仅能输出一个字符串，还可以输出一个其他类型的变量。

python 复制代码 
a = 10
print(a)
b = True
print(b)

更多的时候，我们希望能够输出的内容是混合了字符串和变量的。

示例：输出 num = 10。

python 复制代码 
num = 10
print(f'num = {num}')

注意：

使用 f 作为前缀的字符串, 称为 f-string；

里面可以使用 { } 来内嵌一个其他的变量/表达式。

Python 中还支持其他的格式化字符串的方法，我们目前暂时只了解这个最简单的即可。

python 复制代码 
# 基于控制台输出
# 如何批量注释代母：
# 1. 选中要注释的代码
# 2.使用ctrl +/ (取消也一样)
a = 10
print(a)

b = 'hello'
print(b)

c = True
print(c)

a = 10
# 希望使用 print 打印出 "a = 10"这样的内容
# 我们希望把数字和字符串混在一起来打印
# print("a = " + a)
# 报错:TypeError: can only concatenate str (not "int") to str

# 上面的想法可以用"格式化字符串"来实现
print(f"a = {a}")
# 这个语法叫做"格式化字符串"
# f-string,这里的f表示"format"
print(f"b = {a + 10}")
# 格式化字符串:最常用的方式-->之前不是说Python解决一个问题只有一种方式吗?为什么这里格式化又有多种方式?
# 其实这里和Python的发展有关系
# 像格式化打印字符串~很多编程语言都进行了各自的探索,但是这些打印或多或少都存在各自的一些问题:
# C的printf使用%d,%s这样的占位符(一旦把占位符写错,占位符和实际要打印的字符不匹配,后果是灾难性的)
# C++采用了 std::cout,使用<<(C++虽然避免了C语言中占位符写错的问题,但是整体的打印不够直观,可读性太差)
# Java采用了字符串拼接，允许字符串和其他类型的值进行拼接(缺少了一些必要的校验功能)
# 因此这些方法都有一些不太完美的地方
# Python最早支持的格式化字符串，也是效仿C的printf...并做出了改进
# Python 3.6版本才开始支持f-string(这是当下更好更先进地表示格式化字符串的方式)
# 所以,之所以Python提供了多种方式,也是语言发展的结果-->所有语言不是尽善尽美的,需要有一个不断进化发展的过程

5.3 从控制台输入

python 使用 input 函数，从控制台读取用户的输入。

python 复制代码 
num = 0
num = input('请输入一个整数: ')
print(f'你输入的整数是 {num}')

注意：

input 的参数相当于一个 "提示信息"，也可以没有；

input 的返回值就是用户输入的内容，是字符串类型。

python 复制代码 
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
print(f'a + b = {a + b}')

此处的结果是字符串拼接，不是算术运算，如果要想进行算术运算，需要先转换类型。

python 复制代码 
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')

通过 int( ) 把变量转成了 int 类型。

类似的，使用 float( )、bool( )、str( ) 等可以完成对应的类型转换。

代码示例：输入 4 个小数，求 4 个小数的平均值。

python 复制代码 
a = input('请输入第一个数字: ')
b = input('请输入第二个数字: ')
c = input('请输入第三个数字: ')
d = input('请输入第四个数字: ')
a = float(a)
b = float(b)
c = float(c)
d = float(d)
avg = (a + b + c + d) / 4
print(f'平均值: {avg}')

此处为了输入 4 个数字，执行了四次 input。

如果是读取任意多个数字怎么办呢? 此时就需要用到循环了，我们后面到循环部分再介绍。

python 复制代码 
# 从控制台输入
# 输入四个小数，求四个小树的平均值

# input 执行的时侯 就会等待用户输入！
# ---->这个等待可能是一个非常长的等待，完全就看用户啥时候去输入------
# 如果用户始终不输入，（不像和对象约会）就会一直在这里死等，不见不散！
# input返回的值，其实是一个str
# 如果只是单纯的拿到用户的输入，然后打印，此时就按照str打印即可
# 如果需要根据用户输入的内容进行算术计算，此时就需要先把读到的str -> int
# 可以使用int()
# 如果想把整数转成字符申？str()
# 如果想把字符串转成浮点数？float()
python 复制代码 
a = input("请输入第一个数字：")
b = input("请输入第二个数字：")
c = input("请输入第三个树字：")
d = input("请输入第四个数字：")

a = float(a)
b = float(b)
c = float(c)
d = float(d)

avg = (a + b + c + d) / 4
print(f"平均数是 {avg}")

6 ~> 运算符

python 复制代码 
# 运算符-->
# 算术运算符
# 关系运算符
# 逻辑运算符
# 赋值运算符

即------

6.1 算术运算符

像 + - * / % ** // 这种进行算术运算的运算符，称为 算术运算符。

6.1.1 算术运算符的五个注意点

注意1： / 中不能用 0 作为除数，否则会 抛出异常。

python 复制代码 
print(10 / 0)


异常 是编程语言中的一种常见机制，表示程序运行过程中，出现了一些 "意外情况"，导致程序不能继续往下执行了。

注意2： 整数 / 整数 结果可能是小数，而不会 截断。

python 复制代码 
print(1 / 2)

注意3： % 不是 "百分数"，而是求余数。

python 复制代码 
print(7 % 2)

关于求余数，可能有些uu容易蒙------其实这个是我们小学二年级数学就学过的：7 除以 2，商是 3，余数是 1。

注意4： ** 是求乘方------不光能算整数次方，还能算小数次方（开根）。

python 复制代码 
print(4 ** 2)
print(4 ** 0.5)

注意5： // 是取整除法 (也叫地板除)------整数除以整数，结果还是整数(舍弃小数部分，并向下取整，不是四舍五入！)

python 复制代码 
print(7 // 2)
print(-7 // 2)

6.1.2 完整流程

python 复制代码 
# 算术运算符

# + - * / % ** // --> 先算乘方，然后是乘除，最后算加减
# 如果运算过程中想修改默认的运算顺序，就需要加上()

result = (1 + 2) * 3
print(result)

# 除法的第一个问题：抛出异常
# 在Python中，0不能作为除数
# print(10 / 0)   # 报错：ZeroDivisionError: division by zero
# 这种运行时出现的错误也叫做"抛出异常"，如果程序运行过程中抛出异常，程序直接就终止了，异常后面的代码也就不会执行到了
# 计算机是铁憨憨~~当计算机遇到不合理的地方，就会直接躺在地上摆烂（不往下干活了）

# 除法的第二个问题：截断的问题-->整数 / 整数，如果除不尽，得到的就是小数，不会出现截断的情况
# 在Python中，整数除以整数，结果可能是小数
print(1 / 2)
# 输出：0.5

# print(10 / 0.0)
# 报错：ZeroDivisionError: float division by zero
# 有些缠程语言中，/ 整数 0也是会抛出异常，/ 浮点数 0会得到无穷大，而 Python 都认为是除0异常
# 除了 Python之外，大部分的编程语言，都是整数除以整数，结果还是整数

# %表示求余数
# 小学二年级数学的问题：7除以2，商是3,余数是1得到的余数。一定是小于除数的!!
print(7 % 3)

# **表示乘方运算，既能支持乘方，也能支持开方
# **进行乘方运算 --> 既能够支持整数次方，也支持小数次方，开方运算
# 2^0.5，这种就是根号2
print(4 ** 2)
print(4 ** 0.5)

# //：地板除法(取整除法)，会针对计算的结果进行"向下取整"
# 这个"向下取整"针对正数和负数，取整的方向不一样（本质都是向更小的取整）
print(7 // 2)
print(-7 // 2)

6.2 关系运算符

像 <、<=、>、>=、==、!=这一系列的运算符称为关系运算符，它们是在比较操作数之间的关系。

<= 是 "小于等于"，>= 是 "大于等于"；

== 是 "等于"，!= 是 "不等于"。

6.2.1 关系运算符的三个注意点

1、如果关系符合，则表达式返回 True；如果关系不符合，则表达式返回 False

python 复制代码 
a = 10
b = 20
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

2、关系运算符不光针对整数/浮点数进行比较，还能针对字符串进行比较

python 复制代码 
a = 'hello'
b = 'world'
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

注意： 直接使用 == 或者 != 即可对字符串内容判定相等 (这一点和 C / Java 不同)；字符串比较大小, 规则是 "字典序"。
关于 字典序： 想象一个英文词典，上面的单词都是按照字母顺序排列。如果首个字母相同, 就比较第二个字母(就比如著名单词 abandon)，我们认为一个单词在词典上越靠前，就越小；越靠后，就越大。

3、对于浮点数来说，不要使用 == 判定相等

python 复制代码 
print(0.1 + 0.2 == 0.3)

注意：浮点数在计算机中的表示并不是精确的！在计算过程中，就容易出现非常小的误差。

python 复制代码 
print(0.1)
print(0.2)
print(0.3)
print(0.1 + 0.2)

观察上图我们不难发现------

0.1 + 0.2 的结果并非是 0.3！而是带了个小尾巴。虽然这个尾巴非常小了，但是 == 是锱铢必较的, 仍然会导致 == 的结果为 False。

不止是 Python 如此，主流编程语言都是如此。 这个是IEEE754 标准规定的浮点数格式所引入的问题，此处我们不作过多讨论。

正确的比较方式： 不再严格比较相等了，而是判定差值小于允许的误差范围。

python 复制代码 
a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)

实际工程实践中，误差在所难免，只要保证误差在合理范围内即可。

6.2.2 完整流程

python 复制代码 
# 如何批量化注释:Ctrl + / --> 取消也是如此
# / 和 \注意区分（前者叫"斜杠"，后者叫""反斜杠）

# ---------------------------关系运算符1---------------------------

# 关系运算符就是在比较两个操作数之间的"大小""相等"这样的关系！
# <
# >
# <=
# >=
# ==    比较相等
# !=

# 1.关系运算符对应的表达式值是布尔类型~
# 表达式符合要求，为真。
# 不符合要求，为假.

# 2.关系运算不光可以针对数字进行比较，还能够比较字符串~
# 字典序-->在英文词典上，单词是按照一定的顺序来排列的
# 先看首字母在字母表上的顺序-->谁小，谁就排在前面：如果首字母相同，依次比较第二个字母，第三个字母...
# abandon（单词书上排在前面的，顺序：首字母abcd......）
# 字符串在词典上越靠前，就越小越靠后，就越大

# a = 10
# b = 20

# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)

# a = 'hello'
# b = 'world'
#
# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)

# 针对中文进行大小字节序比较，是没有意义的
# 至少按照默认的字典序来说，是没有意义的
# a = '你好'
# b = '世界'

# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)

# 在计算机里，表示中文，其实是用多个字节构成的一个比较大的数字来进行比较
# 在有些场景下，比如手机通讯录、微信通讯录（联系人名字按照拼音来进行排序）--->是另外的比较规则
# 至少Python默认是不支持的，需要使用第三方库，才能实现类似的效果

# 字符串之间好像不能直接使用 == 或者 != 来比较呀？！
# C ---> strcmp，如果直按使用 == 本质上在比较两个字符串首元素地址.
# Java ---> equals方法，如果直接使用==本质上在比较这两个字符串是否是同一个对象.
# 上面这两种这是一个小众的行为.
# 像Python直接使用 == 和 != 来比较字符串内容相同才是大部分编程语言遵守的规则

# ---------------------------关系运算符2---------------------------

# 浮点数比较大小的问题：
# 3. 针对浮点数来说使用 == 比较相等，存在一定的风险!
# 因为浮点数在内存中的存储和表示，是可能存在误差的!
# 这样的误差在进行算术运算的时候就可能被放大，从而导效 == 的判定出现误判！
# print(0.1 + 0.2 == 0.3)
# 结果：False，为什么是False呢？我们可以把计算过程都打印出来
# print(0.1)
# print(0.2)
# print(0.1 + 0.2)
# print(0.3)
# # 过程：
# # 0.1
# # 0.2
# # 0.30000000000000004
# # 0.3
# # 是不是发现了一些端倪？

# 正确的比较浮点数相等：作差，看差值是否小于预期的误差范围！
a = 0.1 + 0.2
b = 0.3

# Python中支持这种连续小于的写法，判定a - b既是小于0.000001又是大于-0.000001
# 这个代码是看 a - b 差是否是一个非常小的数字，是否是在误差范围之内
print(-0.000001 < (a - b) < 0.000001)

6.3 逻辑运算符

像 and or not 这一系列的运算符称为 逻辑运算符。

and 并且。两侧操作数均为 True，最终结果为 True，否则为 False(一假则假)

or 或者。两侧操作数均为False，最终结果为 False，否则为 True(一真则真)

not 逻辑取反。操作数本身为 True，则返回 False，本身为False，则返回 True。

此处说的 "并且" 和 "或者"，就是我们日常生活中使用的 "并且" 和 "或者"。

想象一下未来丈母娘问你要彩礼，什么叫做 "有房并且有车"，什么叫做 "有房或者有车"。

6.3.1 逻辑运算符的一些注意事项

python 复制代码 
a = 10
b = 20
c = 30
print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)
6.3.1.1 一种特殊写法

a < b and b < c 这个操作等价于 a < b < c------这个设定和大部分编程语言都不相同。

6.3.1.2 关于短路求值

和其他编程语言类似，Python也存在短路求值的规则。

对于and，如果左侧表达式为False，则整体一定为False，右侧表达式不再执行；

对于or，如果左侧表达式为True，则整体一定为True，右侧表达式不再执行。

python 复制代码 
print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

上述代码没有抛出异常，说明右侧的除以 0 操作没有真正执行。

6.3.2 完整流程

python 复制代码 
# 逻辑运算符

# 找女朋友，谈婚论嫁------要彩礼
# 要有房并且要有车（and：缺一不可）
# 要有房或者要有车（or：有一个就行，不能两个都没有

# and 并且    两侧操作数均为True，表达式的值为True，否则为 false（一假则假）
# or  或者    两侧操作数均为False,表达式的值为False，否则为 True（一真则真）
# not 逻辑取反 只有一个操作数.操作数为True，则返回False；操作数为False，则返回True

a = 10
b = 20
c = 30

# # 1. and
# # a < b < c等价于 a < b and b < c
# # print(a < b and b < c)
# print(a < b < c) # 带黄色波浪线，功能上没问题，但是有更好的写法：点击黄色灯泡
# print(a > b and b > c)
#
# # 2. or
# print(a < b or b < c)
# print(a < b or b > c)
# print(a < b or b < c)
#
# # 3. not
# print(not a < b)
# print(not a > b)

# 比如C++或者Java里，使用
# &&表示逻辑与   并目
# ||表示逻辑或   或者
# ！表示逻辑非   逻辑取反

# 逻辑运算符中的重要细节：短路求值（物理上的术语）
# 对于and操作来说：如果左侧表达式为False，那么整体的值一定是False，右侧表达式不必求值！
# 对于or操作来说：如果左侧表达式为True，那么整体的值一定是True，右侧表达式不必求值！

# 右侧就不再求值了，所以一旦右侧求值了，是能够看到代码出现异常的！
# 如果代码没有抛出异常，右侧没有求值！
print(a > b and 10 / 0 == 1)
# print(a < b and 10 / 0 == 1)    # 报错：ZeroDivisionError: division by zero
print(a < b or 10 / 0 == 1)

# 短路求值这种行为，大部分编程语言都有，C、C++、Java......

6.4 赋值运算符

6.4.1 = 的使用

= 表示赋值，这个我们已经用过很多次了，注意和 == 加以区分；

= 除了基本的用法之外，还可以同时针对多个变量进行赋值。

6.4.1.1 链式赋值
python 复制代码 
a = b = 10
6.4.1.2 多元赋值
python 复制代码 
a, b = 10, 20
6.4.1.3 代码实例：交换两个变量
6.4.1.3.1 基础写法
python 复制代码 
a = 10
b = 20
tmp = a
a = b
b = tmp
6.4.1.3.2 基于多元赋值
python 复制代码 
a = 10
b = 20
a, b = b, a

6.4.2 复合赋值运算符

Python还有一些复合赋值运算符，例如+=、-=、*=、/=、%=。

其中a += 1等价于a = a + 1，其他复合赋值运算符也同理。

python 复制代码 
a = 10
a = a + 1
print(a)
b = 10
b += 1
print(b)

注意：像 C++ / Java 中，存在 ++ -- 这样的自增/自减运算符。Python 中则不支持这种运算。

如果需要使用，则直接使用 += 1 或者 -= 1。

++、-- 最大的问题就是容易分不清前置和后置的区别。 在这一点上，Python 语法在设计的时候就进行了规避，避免出现这种不直观，并且容易混淆的语法。

6.4.3 完整流程

python 复制代码 
# ------------------------------赋值运算符（1）------------------------------
# = 表示赋值，意思就是把右侧的值填充到左侧的空间（这个空间得是一个变量）中！
# == 表示比较相等
a = 20

# 连续赋值：先把20赋值给b，再把b赋值给a，就相当于a = 20，b = 20-->我们称之为"链式赋值"
# 工作中不建议使用链式赋值，尽量一行代码只是包含一个操作（挤在同一行可读性也不太好）！
a = b = 20

# 多元赋值：能够帮我们解决一些特殊问题
# 比如可以完成两个变量的交换
a = 10
b = 20

# tmp = a
# a = b
# b = tmp
# print(a,b)

# 使用多元赋值，直接一步到位完成交换
a , b = b , a
print(a,b)

# 借助多元赋值，完成让一个函数返回多个值这样的操作

# ------------------------------赋值运算符（2）------------------------------
# 有一个读取变量的过程
# a = 0
# NameError: name 'a' is not defined（不认识a这个变量）

a = 0

a = a + 1
# 和上面等价
a += 1
# -=，*=，/=，**=，%=，//=

# C++ / Java中的a++、++a可以吗？
# ++a
# ++a：黄色波浪线，之所以没有语法报错，是因为Python解释器把+当成了正号
# 同理，--a也是不会报错，把-当成了负号，负负得正，最终的值仍然不变
# a++
# 但是后置++和后置--在语法上都是报错的！
# 使用a += 1已经很方便地完成自增了！
# SyntaxError: invalid syntax
# ++操作其实挺讨厌的-->
# 前置++（表达式返回自增之后的值）和后置++（表达式返回自增之前的值）的区别，对于初学者来说是非常不友好的！在初学C语言时也比较不友好
# Python中不支持++、--这样的自增自减操作！
# Python直接把前置++、后置++、前置--、后置--都给删了
print(a)

# 值得一提的是：前置++、后置++这是C语言开的头，但是现在C语言已经后悔了！
# -->Go语言------Golang------作者就是C语言之父，肯·汤姆逊，如今依然活跃
# Go语言：C的升级版本
# 在Golang里面废除了前置++，只保留了后置++，而且这个后置++不能取表达式的返回值
# Go虽然没有Python这么决绝，但还是能够降低大家的学习成本的

# 其他运算符
# 除了上述之外，Python中还有一些运算符：比如身份运算符（is,is not），成员运算符（in,not in），
# 位运算符（& | ~ ^ << >>)等。此处咱们暂时不介绍。

6.5 其他

除了上述之外，Python 中还有一些运算符，比如身份运算符 (is, is not)、成员运算符 (in, not in)、位运算符 ( & | ~ ^ << >>) 等。

此处我们不作过多介绍。

7 ~> Python基础：语法篇第一部分总结

python 复制代码 
# 总结
# 本章节中我们学习了Python中的最基础的语法部分
# 常量
# 变量
# 类型
# # 整数
# # 浮点数
# # 字符串
# # 布尔值
# 注释
# 输入输出
# 运算符
# # 算术运算符
# # 关系运算符
# # 逻辑运算符
# # 赋值运算符

当前我们的代码还只能进行一些简单的算术运算，下个章节中我们将学习Python中的逻辑判断，我们就可以写稍微复杂一点的程序了。

8 ~> Python基础：语法篇第一部分自测小练习

Python基础语法的第一部分到前面的【总结】那里就已经结束了，这是自测小练习，uu们可以检验一下，看看前面的基础怎么样。

8.1 例题1

python 复制代码 
#（1）[多选]以下关于变量之间加法运算的说法，正确的是：
# A. Python 中的字符串之间够能相加.
# B. Python中的字符串可以和整数相加.
# C. Python中的整数可以和浮点数相加.
# D. Python中的整数可以和布尔值相加.

正确选项： ACD

题目解析------

python 复制代码 
# 题目解析：
# D. 如果把布尔类型的值和整数进行算术运算，此时就会把True当做1，把False当做0-->虽然也能跑，但是这样的操作，是没有意义的！！！
# 也就是说：布尔类型只是单纯地表示真和假，他和数字之间并没有一个明确的联系
# True和False约定一个1一个-1也可以，约定别的也可以，只是在Python解释器这里True是1、False是-1
# 这只是语言作者一拍脑门想出来的，C/C++也是有类似的行为，
# 但是Java这里的做法是更合理的！！！--->如果出现整数和布尔混合运算，直接编译报错。

8.2 例题2

python 复制代码 
#(2）[单选]以下关于类型的说法，正确的是：
# A. Python中既有字符串类型，也有字符类型.
# B. Python中既有float,也有double.
# C. Python中既有int,也有long.
# D. Python中的整数表示范围无上限.

正确选项： D

题目解析------

python 复制代码 
# A. Python中只有字符串类型，没有字符类型！'a'这算是长度为1的字符串！正是因为Python中没有字符类型，
# 所以"和'都能表示字符串；C++，Java有单独的字符类型，单引号表示字符，双引号表示字符串
# B. Python中只有float
# C. Python只有int-->根据表示数据的大小自动进行扩容，换言之：只要内存空间足够大，就可以表示足够大的数据

8.3 例题3

python 复制代码 
#(3) [单选]以下Python代码,合法的是
# A. int a = 10
# B. a = 10;
# C. a = true
# D. a = 'aaa' + 10

正确选项： B

题目解析------

python 复制代码 
# 题目解析：
# A. int a = 10      # 不科学，这是典型的C/C++和Java的做法，在Python里面创建变量不需要指定类型
# 在Python中如果非要加上类型，这里的表示也是错误的，在Python中是像下面这样加上：来指定类型的-->
a:int = 10

a = 10;     # 为了代码可读性，可读性比代码运行正确还是要重要一些的

# B. 在Python中，一个语句写完了之后，可以加上分号，也可以不加
# 通常情况下都是不加的，如果加了，也不算错！！
# 如果把多个语句写到同一行了，这个时候语句之间，务必要加上分号的（这种写法并不推荐），如下面这种情况--->
# a = 10 print    # 务必要加上;

# C. a = true
# NameError: name 'true' is not defined. Did you mean: 'True'?很亲切地提示你

# D. 已经强调过很多次了，字符串和数字不能相加

结尾

uu们，本文的内容到这里就全部结束了，艾莉丝再次感谢您的阅读！

结语：希望对学习Python相关内容的uu有所帮助，不要忘记给博主"一键四连"哦！

往期回顾：

【Python基础】认识Python：手把手教你搭建 Python 环境｜附计算机基础图解

🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡 ૮₍ ˶ ˊ ᴥ ˋ˶₎ა

相关推荐
智能相对论1 小时前
10万人共同选择的背后，Rokid乐奇有自己的“破圈秘籍”
大数据·智能眼镜
人大博士的交易之路1 小时前
龙虎榜——20251128
大数据·数学建模·数据挖掘·数据分析·缠论·龙虎榜·道琼斯结构
gCode Teacher 格码致知2 小时前
Python基础教学:如何拼接字符串？-由Deepseek产生
python
还债大湿兄2 小时前
阿里通义千问调用图像大模型生成轮动漫风格 python调用
开发语言·前端·python
blank@l2 小时前
python测开小工具--日志查询分析工具
python·python接口自动化测试基础·python测试开发·日志查询分析·日志分析统计查询·软件测试工具·argparse模块
MobotStone2 小时前
数字沟通之道
人工智能·算法
Together_CZ2 小时前
Cambrian-S: Towards Spatial Supersensing in Video——迈向视频中的空间超感知
人工智能·机器学习·音视频·spatial·cambrian-s·迈向视频中的空间超感知·supersensing
hu_nil2 小时前
LLMOps-第十三周
python·vllm
空影星2 小时前
轻量日记神器RedNotebook，高效记录每一天
python·数据挖掘·数据分析·音视频
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Linux下V2Ray安装配置指南07Labelme从安装到标注：零基础完整指南08“我的电脑”图标没了怎么办 4种方法找回09Gemini 3.0 Pro Preview 实测报告10全球最强模型Grok4，国内已可免费使用！（附教程）