在这里插入图片描述

Python基础指令上

常量和表达式
变量和类型
- 1. 什么是变量
- 2. 变量的语法
- - 2.1 定义变量
  - 2.2 使用变量
- 3. 变量的类型
- 4. 为什么要有这么多类型
- 5. 动态类型特性
注释
输入输出
- 1. 程序与用户的交互
- 2. 通过控制台输出
- 3. 通过控制台输入
运算符
- 1. 算术运算符
- 2. 关系运算符
- 3. 逻辑运算符
- 4. 赋值运算符
条件语句
缩进和代码块
空语句 pass
循环语句
- 1. while循环
- 2. for 循环

常量和表达式

print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)

运行结果

0
7
1.6666666666666665

print 是一个 Python 内置的函数
可以使用 + - * / ( ) 等运算符进行算术运算. 先算乘除, 后算加减.
运算符和数字之间, 可以没有空格, 也可以有多个空格. 但是一般习惯上写一个空格

形如1 + 2 - 3这样是算式, 在编程语言中称为表达式, 算式的运算结果, 称为表达式的返回值
其中1 , 2 , 3这种称为字面值常量, + - * / 这种称为运算符或者操作符

注意: 熟悉 C / C++ 的同学可能认为, 2 / 3 结果为 0 (小数部分被截断), 但是在 Python 中得到的结果则是一个小数,更符合日常使用的直觉

变量和类型

1. 什么是变量

在Python中，变量是用于存储数据值的标识符。这些标识符可以是字母、数字和下划线的组合，但必须遵循一些命名规则，比如变量名不能以数字开头，不能包含空格，等等。Python中的变量是动态类型的，这意味着你不需要提前声明变量的数据类型，Python会根据赋给变量的值自动确定其类型。

以下是一个简单的Python变量示例：

x = 10  # 创建一个整数类型的变量x并赋值为10
name = "John"  # 创建一个字符串类型的变量name并赋值为"John"
is_student = True  # 创建一个布尔类型的变量is_student并赋值为True
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2 #创建一个浮点数类型的变量total并赋值为四个小数的方差

与C语言相比，Python中的变量有一些显著的区别：

动态类型：在C语言中，你需要在声明变量时明确指定其数据类型，而在Python中，变量的数据类型由赋给它的值自动确定。这使得Python更加灵活和简洁。
无需声明：在C语言中，你必须在使用变量之前显式声明它，而Python中不需要。你可以直接给一个变量赋值，Python会自动创建它。
不需要分号：在C语言中，语句通常以分号结束，而Python使用缩进来表示代码块，不需要分号。
更高级的数据类型：Python具有许多内置的高级数据类型，如列表、字典、集合和元组，这些数据类型使得在Python中处理复杂数据结构更加方便。
垃圾回收：Python具有自动内存管理和垃圾回收机制，不需要手动管理内存分配和释放。

总的来说，Python相对于C语言来说更加简洁和易于学习，但在某些情况下可能会牺牲一些性能。在选择编程语言时，需要根据项目需求和性能要求来进行权衡。

注意:
x,name,is_student,total均为变量.
** 在 Python 中表示乘方运算. ** 2 即为求平方

2. 变量的语法

2.1 定义变量

a = 10

创建变量的语句非常简单, 其中

a 为变量名. 当我们创建很多个变量的时候, 就可以用名字来进行区分.
= 为赋值运算符, 表示把 = 右侧的数据放到 = 左侧的空间中

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

硬性规则(务必遵守)

变量名由数字字母下划线构成.

数字不能开头.

变量名不能和 “关键字” 重复.

变量名大小写敏感. num 和 Num 是两个不同的变量名.

软性规则(建议遵守)

变量名使用有描述性的单词来表示, 尽量表达出变量的作用.

一个变量名可以由多个单词构成, 长一点没关系, 但是含义要清晰.

当变量名包含多个单词的时候, 建议使用 “驼峰命名法”. 形如 totalCount , personInfo 这种, 除了首个单词外, 剩余单词首字母大写.

数学上, 变量通常使用 x, y, z 这种简单的英文字母或者拉丁字母表示. 但是在编程中不建议这样使用.原因是编程中, 一个程序里通常会同时创建出很多个变量. 如果只是使用单个字母表示, 在变量多了的时候, 就很难记住哪个变量是干啥的, 从而给维护程序带来了一定的困难. 因此我们更建议使用带有明确描述性的名字, 来表示变量的用途.

2.2 使用变量

读取变量的值

a = 10
print(a)

修改变量的值

a = 20
print(a)

在 Python 中, 修改变量也是使用 = 运算, 看起来和定义变量没有明显区别.
当然, 也可以用一个变量的值赋给另外一个变量

a = 10
b = 20
a = b
print(a)
print(b)

3. 变量的类型

Python的整数类型（int）、浮点数类型（float）、字符串类型（str）和逻辑值（bool）与C语言中的相应类型有一些区别：

整数类型（int）：
- Python中的整数类型是动态的，不需要指定类型，Python会根据赋给变量的值自动确定其类型。
- Python的整数类型可以表示任意大小的整数，没有固定的范围限制，这称为“无限精度整数”（arbitrary-precision integers）。
- 在C语言中，整数类型的大小取决于编译器和平台，通常有固定的位数和范围。
在Python中，整数类型可以表示非常大的整数，而不需要担心溢出问题。例如：
```
x = 1234567890123456789012345678901234567890
print(x)
print(type(x))
```
这个数字在C语言中可能会导致溢出或精度问题，但在Python中没有问题。
```
1234567890123456789012345678901234567890
<class 'int'>
```
浮点数类型（float）：
- Python中的浮点数类型也是动态的，不需要显式指定类型。
- Python使用双精度浮点数标准（IEEE 754），通常支持15到17位的十进制精度。
- 在C语言中，浮点数类型的大小和精度取决于编译器和平台，可以是单精度或双精度浮点数。
Python的浮点数类型具有双精度精度，可以表示小数值，例如：
```
y = 3.14159265358979323846
print(y)
print(type(y))
```
这个浮点数在Python中有足够的精度来表示π的近似值。在C语言中，浮点数精度取决于编译器和平台，可能不够精确。
```
3.141592653589793
<class 'float'>
```
字符串类型（str）：
- Python的字符串类型是Unicode字符串，这意味着它可以表示世界上大多数字符集的字符，包括ASCII字符和非ASCII字符。
- Python的字符串是不可变的，这意味着一旦创建，就不能修改它们的内容。
- 在C语言中，字符串通常是字符数组，使用null终止，而且可以被修改。
Python的字符串类型可以包含各种字符，包括Unicode字符。这使得在处理不同字符集的文本数据时非常方便，例如：
```
name = "李雷"
print(name)
print(type(name))
```
这是一个包含中文字符的字符串，Python可以轻松地处理它。在C语言中，处理Unicode字符可能会更加复杂，需要使用宽字符或Unicode转换函数。
```
李雷
<class 'str'>
```

总的来说，Python中的整数和浮点数类型具有更大的灵活性和精度，而字符串类型具有更好的Unicode支持和不可变性。这些差异使Python在处理各种数据类型时更加方便，但也需要在性能方面进行权衡，因为C语言通常在处理底层数据时更加高效。根据具体需求，可以选择使用不同的语言和数据类型。

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

可以使用 len 函数来获取字符串的长度

a = 'hello'
print(len(a))

输出5

可以使用 + 针对两个字符串进行拼接

a = 'hello
b = 'world'
print(a + b)

输出helloworld

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

逻辑值（bool）:
- Python中的布尔类型有两个值：True（真）和False（假）。
- 布尔类型通常用于条件判断，例如在if语句中。
- Python的布尔类型是大小写敏感的，必须使用大写字母开头的True和False，小写的true和false不是布尔值。

is_true = True
is_false = Falseif is_true:print("这是True")if not is_false:print("这是False")
print(type(is_true))
print(type(is_false))

输出

这是True
这是False
<class 'bool'>
<class 'bool'>

其他

除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型等等. 我们后面单独介绍

4. 为什么要有这么多类型

类型决定了数据在内存中占据多大空间.
例如 float 类型在内存中占据 8 个字节.

计算机里面使用二进制来表示数据. 也就是每个位只能表示 0 或者 1.
1 个二进制位, 就称为是一个 “比特”, 8 个二进制位, 就称为一个 “字节” (Byte)
一个 float 变量在内存中占据 8 个字节空间, 也就是 64 个二进制位，我的电脑有 16GB 的内存空间, 也就是一共有 1024 * 1024 * 1024 * 8 这么多的二进制位.

类型其实约定了能对这个变量做什么样的操作.
例如 int / float 类型的变量, 可以进行 + - * / 等操作
而 str 类型的变量, 只能进行 + (并且行为是字符串拼接), 不能进行 - * / , 但是还能使用 len 等其他操作.

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

5. 动态类型特性

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

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

输出:

<class 'int'>
<class 'str'>

在程序执行过程中, a 的类型刚开始是 int, 后面变成了 str
C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 “静态类型”
动态类型特性是一把双刃剑

对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型).
对于大型程序, 则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解)

注释

在Python中，有两种主要类型的注释：单行注释和多行注释。注释用于在代码中添加说明或注解，不会被解释器执行。

单行注释： 单行注释以井号 # 开头，后面的内容被视为注释，直到行尾结束。单行注释通常用于添加对代码的简短说明。

示例：

# 这是一个单行注释
x = 5  # 这是赋值语句，将5赋给变量x

多行注释： Python中没有像C或C++那样的块注释，但你可以使用三重引号 ''' 或 """ 来创建多行字符串，并将其放在代码中来实现多行注释的效果。虽然这实际上是创建了一个字符串，但如果不将其分配给变量，它将被视为注释。

示例：

'''
这是一个
多行注释
它实际上是一个多行字符串，但没有分配给变量
'''
print("Hello, World!")

或者使用双重引号：

"""
这也是一个
多行注释
"""
print("Hello, World!")

请注意，多行字符串虽然可以用于多行注释，但通常情况下，开发者更倾向于使用单行注释和函数/类/方法的文档字符串（docstring）来添加注释和文档说明。

示例：

def add(x, y):"""这是一个函数的文档字符串它用于计算两个数字的和"""return x + y

这样的文档字符串可以使用help()函数查看，也有工具可以生成文档。在实际开发中，文档字符串对于代码的可读性和维护性非常有帮助。

注释的规范

内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
积极向上: 注释中不要包含负能量(例如领导 SB 等). 据说上过新闻被开了,手动滑稽

输入输出

1. 程序与用户的交互

程序需要和用户进行交互

用户把信息传递给程序的过程, 称为 “输入”.
程序把结果展示给用户的过程, 称为 “输出”.

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

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

在这里插入图片描述
windows 自带的 cmd 程序, 也可以视为是控制台

在这里插入图片描述

输入输出的最常见方法是图形化界面

Python 当然也可以用来开发图形化界面的程序. 但是图形化程序开发本身是一个大话题,我们后面再做详细介绍

2. 通过控制台输出

比如输出一个其他类型的变量

a = 10
print(a)
b = True
print(b)

输出

10
True

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

示例: 输出 num = 10

num = 10
print(f'num = {num}')

使用 f 作为前缀的字符串, 称为 f-string
里面可以使用{ }来内嵌一个其他的变量/表达式

3. 通过控制台输入

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

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

输入后输出

请输入一个整数: 2
你输入的整数是 2

input 的参数相当于一个 “提示信息”, 也可以没有.
input 的返回值就是用户输入的内容. 是字符串类型

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

输入后输出

请输入第一个整数: 20
请输入第二个整数: 23
a + b = 2023

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

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

输入后输出

请输入第一个整数: 20
请输入第二个整数: 23
a + b = 43

通过 int( ) 把变量转成了 int 类型.
类似的, 使用 float( ), bool( ), str( ) 等可以完成对应的类型转换

代码示例: 输入 4 个小数, 求 4 个小数的平均值

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}')

输入后输出

请输入第一个数字: 21.2
请输入第二个数字: 20.3
请输入第三个数字: 21.4
请输入第四个数字: 21.5
平均值: 21.1

代码示例: 利用海伦公式计算三角形面积

import math
a=float(input("输入直角三角形第一条边"))
b=float(input("输入直角三角形第二条边"))
c=float(input("输入直角三角形第三条边"))
#计算海伦公式中p的值,即半周长
p=(a+b+c)/2
s=math.sqrt(p*(p-a)*(p-b)*(p-c))
print(s)

输入后输出

输入直角三角形第一条边3
输入直角三角形第二条边4
输入直角三角形第三条边5
6.0

运算符

1. 算术运算符

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

和其他语言一样 / 中不能用 0 作为除数. 否则会抛出异常

print(10 / 0)

输出

Traceback (most recent call last):File "C:\Users\xzq20\PycharmProjects\pythonProject1\hello.py", line 1, in <module>print(10 / 0)~~~^~~
ZeroDivisionError: division by zero

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

整数 / 整数 结果可能是小数. 而不会截断

print(1 / 2)

输出

0.5

% 不是 “百分数”, 而是求余数

print(7 % 2)

输出

** 是求乘方. 不光能算整数次方, 还能算小数次方

print(4 ** 2)
print(4 ** 0.5)

输出

16
2.0

// 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)

print(7 // 2)
print(-7 // 2)

输出

3
-4

2. 关系运算符

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

其中

<= 是 “小于等于”

>= 是 “大于等于”

== 是 “等于”

!= 是 “不等于”

如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False

a = 10
b = 20
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

输出

True
True
False
False
False
True

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

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

输出

True
True
False
False
False
True

直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / C++ 不同).
字符串比较大小, 规则是 “字典序” (相当于C++中的map应用)

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

print(0.1 + 0.2 == 0.3)

输出

False

浮点数在计算机中的表示并不是精确的! 在计算过程中, 就容易出现非常小的误差

print(0.1)
print(0.2)
print(0.3)
print(0.1 + 0.2)

输出

0.1
0.2
0.3
0.30000000000000004

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

不止是 Python 如此, 主流编程语言都是如此. 这个是 IEEE754 标准规定的浮点数格式所引入的问题,这个在我之前的C语言博客中有提到

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

a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)

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

3. 逻辑运算符

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

and 并且:两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)
or 或者: 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)
not 逻辑取反: 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True

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)

输出

True
False
False
True
False
True

一种特殊写法

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

短路求值

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

对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行.
对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行

print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

输出

False
True

4. 赋值运算符

= 的使用

= 表示赋值. 这个我们已经用过很多次了. 注意和 == 区分.
= 除了基本的用法之外, 还可以同时针对多个变量进行赋值

链式赋值

a = b = 10

多元赋值

a, b = 10, 20

代码实例: 交换两个变量

基础写法（类似C的写法)

a = 10
b = 20
tmp = a
a = b
b = tmp

基于多元赋值

a = 10
b = 20
a, b = b, a

复合赋值运算符

Python 还有一些复合赋值运算符. 例如 += -= *= /= %=
其中 a += 1 等价于 a = a + 1 . 其他复合赋值运算符也是同理

a = 10
a = a + 1
print(a)
b = 10
b += 1
print(b)

注意:

像 C / C++ 中, 存在 ++ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用,则直接使用 += 1 或者 -= 1
++ -- 最大的问题就是容易分不清前置和后置的区别. 这一点 Python 语法在设计的时候就进行了规避, 避免出现这种不直观, 并且容易混淆的语法.

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

条件语句

Python 中使用 if else 关键字表示条件语句

if

if expression:do_something1do_something2
next_something

如果 expression 值为 True, 则执行 do_something1, do_something2, next_something
如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2

if - else

if expression:do_something1
else:do_something2

如果 expression 值为 True, 则执行 do_something1
如果 expression 值为 False, 则执行 do_something2

if - elif - else

if expression1:do_something1
elif expression2:do_something2
else:do_something3

如果 expression1 值为 True, 则执行 do_something1

如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2

如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3

注意: Python中的条件语句写法, 和很多编程语言不太一样

if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.
if / else 命中条件后要执行的 “语句块”, 使用缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }
对于多条件分支, 不是写作 else if, 而是 elif.

缩进和代码块

代码块指的是一组放在一起执行的代码.
在 Python 中使用缩进表示代码块. 不同级别的缩进, 程序的执行效果是不同的

代码1

a = input("请输入一个整数: ")
if a == "1":print("hello")print("world")

代码2

a = input("请输入一个整数: ")
if a == "1":print("hello")
print("world")

区别

在代码1 中, print(“world”) 有一级缩进, 这个语句属于 if 内的代码块, 意味着条件成立, 才执行, 条件不成立, 则不执行.
在代码2 中, print(“world”) 没有缩进, 这个语句是 if 外部的代码, 不属于 if 内部的代码块. 意味着条件无论是否成立, 都会执行. 另外, 代码块内部还可以嵌套代码块

a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == "1":if b == "2":print("hello")print("world")
print("python")

在这个代码中

print(“hello”) 具有两级缩进, 属于 if b == “2” 条件成立的代码块
print(“world”) 具有一级缩进, 属于 if a == “1” 条件成立的代码块
print(“python”) 没有缩进, 无论上述两个条件是否成立, 该语句都会执行

基于缩进的方式表示代码块, 带来的好处就是强制要求程序员要写明确的缩进, 来明确代码之间的相对关系. 如果缩进书写的不对, 则直接报错.像 C++ / Java 这些语言, 即使完全不写缩进, 语法也不会报错. 代码可读性就比较差. 同时, 带来的坏处就是, 如果缩进层次比较多, 就容易分不清楚某个语句属于哪个层级

if a == 1:if b == 2:if c == 3:if d == 4:if e == 5:if f == 6:if g == 7:print("hello")print("1")print("2")

因此, 就有了 “写 Python 需要自备游标卡尺” 这个梗

空语句 pass

示例: 输入一个数字, 如果数字为 1, 则打印 hello

a = int(input("请输入一个整数:"))
if a == 1:print("hello")

也可以等价写成

a = int(input("请输入一个整数:"))
if a != 1:pass
else:print("hello")

其中 pass 表示空语句, 并不会对程序的执行有任何影响, 只是占个位置, 保持 Python 语法格式符合要求

但不能写成

a = int(input("请输入一个整数:"))
if a != 1:else:print("hello")

不符合 Python 语法, 会直接报错

循环语句

1. while循环

基本语法格式

while 条件:循环体

条件为真, 则执行循环体代码.
条件为假, 则结束循环.

示例: 求 1! + 2! + 3! + 4! + 5!

num = 1
sum = 0
while num <= 5:factorResult = 1i = 1while i <= num:factorResult *= ii += 1sum += factorResultnum += 1
print(sum)

这个程序用到了两重循环，也就是在循环语句中也可以套循环

2. for 循环

基本语法格式

for 循环变量 in 可迭代对象:循环体

注意:

python 的 for 和其他语言不同, 没有 “初始化语句”, “循环条件判定语句”, “循环变量更新语句”, 而是更加简单
所谓的 “可迭代对象”, 指的是 “内部包含多个元素, 能一个一个把元素取出来的特殊变量”

示例1: 打印 1-10

for i in range(1, 11):print(i)

使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]

示例2: 打印 2, 4, 6, 8, 10

for i in range(2, 12, 2):print(i)

通过 range 的第三个参数, 可以指定迭代时候的 “步长”. 也就是一次让循环变量加几

示例3: 打印 10-1

for i in range(10, 0, -1):print(i)

range 的步长也可以设定成负数

示例3: 求 1 - 100 的和

sum = 0
for i in range(1, 101):sum += i
print(sum)

continnue和break的用法和C语言类似，这里不做讲解

Python基础指令(上)

Python基础指令上

常量和表达式

变量和类型

1. 什么是变量

2. 变量的语法

2.1 定义变量

2.2 使用变量

3. 变量的类型

4. 为什么要有这么多类型

5. 动态类型特性

注释

输入输出

1. 程序与用户的交互

2. 通过控制台输出

3. 通过控制台输入

运算符

1. 算术运算符

2. 关系运算符

3. 逻辑运算符

4. 赋值运算符

条件语句

缩进和代码块

空语句 pass

循环语句

1. while循环

2. for 循环

相关文章