常量和表达式

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中的变量有一些显著的区别：

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

1. 整数类型（int）：

   • Python中的整数类型是动态的，不需要指定类型，Python会根据赋给变量的值自动确定其类型。
   • Python的整数类型可以表示任意大小的整数，没有固定的范围限制，这称为“无限精度整数”（arbitrary-precision integers）。
   • 在C语言中，整数类型的大小取决于编译器和平台，通常有固定的位数和范围。

   在Python中，整数类型可以表示非常大的整数，而不需要担心溢出问题。例如：

   x = 1234567890123456789012345678901234567890
   print(x)
   print(type(x))
   

   这个数字在C语言中可能会导致溢出或精度问题，但在Python中没有问题。

   1234567890123456789012345678901234567890
   <class 'int'>
   

2. 浮点数类型（float）：

   • Python中的浮点数类型也是动态的，不需要显式指定类型。
   • Python使用双精度浮点数标准（IEEE 754），通常支持15到17位的十进制精度。
   • 在C语言中，浮点数类型的大小和精度取决于编译器和平台，可以是单精度或双精度浮点数。

   Python的浮点数类型具有双精度精度，可以表示小数值，例如：

   y = 3.14159265358979323846
   print(y)
   print(type(y))
   

   这个浮点数在Python中有足够的精度来表示π的近似值。在C语言中，浮点数精度取决于编译器和平台，可能不够精确。

   3.141592653589793
   <class 'float'>
   

3. 字符串类型（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

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

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

is_true = True
is_false = False

if is_true:
    print("这是True")

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

输出

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

5. 其他

除了上述类型之外, 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中，有两种主要类型的注释：单行注释和多行注释。注释用于在代码中添加说明或注解，不会被解释器执行。

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

示例：

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

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

示例：

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

或者使用双重引号：

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

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

示例：

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

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

注释的规范

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
4. 积极向上: 注释中不要包含负能量(例如 领导 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. 算术运算符

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

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

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

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

print(1 / 2)

输出

0.5

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

print(7 % 2)

输出

1

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

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

输出

16
2.0

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

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. 赋值运算符

1. = 的使用

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

链式赋值

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

2. 复合赋值运算符

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_something1
	do_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 = 1
	i = 1
	while i <= num:
		factorResult *= i
		i += 1
	sum += factorResult
	num += 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语言类似，这里不做讲解