python小课堂（一）

1 常量和表达式

在print()中可以执行一些计算：

print(4+1)
print(5*6)
print(8/4)

【提示】

   1：print 是一个 Python 内置的 函数, 这个稍后详细介绍. 
   2：可以使用 + - * / ( ) 等运算符进行算术运算. 先算乘除, 后算加减.
   3：运算符和数字之间, 可以没有空格, 也可以有多个空格. 但是一般习惯上写一个空格(比较美观).
   4：a+b 在编程语言中可以算为表达式，而算式的运算结果, 称为 表达式的返回值
   5：其中 1 , 2 , 3 这种称为 字面值常量, + - * / 这种称为 运算符 或者 操作符.

2 变量和类型

2.1 变量是什么

就是为了在运算过程中保存数据，并且在此基础上进行改进，在这个时候就是要用到变量

示例：

给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的方差  
PS: 方差的计算过程: 取每一项, 减去平均值, 计算平方, 再求和, 最后除以 (项数 - 1)

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

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)

【变量】
avg, total, result 均为变量.

符号简介：
【**】 平方、+ 加法、/ 除法、

储存的大小：

2.2 变量语法

(1) 定义变量
~创建变量的语句非常简单, 其中a 为变量名. 当我们创建很多个变量的时候, 就可以用名字来进行区分.= 为赋值运算符, 表示把 = 右侧的数据放到 = 左侧的空间中.

~硬性规则(务必遵守)
~变量名由数字字母下划线构成.
~数字不能开头.
~变量名不能和 “关键字” 重复.
~变量名大小写敏感. num 和 Num 是两个不同的变量名.

a=1
b=2
c=3

————————————————————————————————————
(2)软性规则(建议遵守)
~变量名使用有描述性的单词来表示, 尽量表达出变量的作用.
~a = 10。
~一个变量名可以由多个单词构成, 长一点没关系, 但是含义要清晰.
~当变量名包含多个单词的时候, 建议使用 “驼峰命名法”. 形如 totalCount , personInfo 这种, 除
了首个单词外, 剩余单词首字母大写.

totalCount=0//命名习惯虽然可以不用但是,尽量还是要用的

(3)使用变量
变量读取

读取
a=200
print(a)
修改
a=100
print(a)

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

a=10
b=a

3 变量的类型

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

【注意】: 和 C++ / Java 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的.

a=10 像是C++auto自动推导
b="hello" string类型
c=2.2 float类型
d=True  布尔类型

现在先了解，具体的类型问题在下面得到解决:

(1) 整数

a = 10
print(type(a)) 打印类型type关键字

【提示】:
在c++中整形是有着大小限制的，有最大值或最小值
而在python中整形没有大小限制,不存在最大最小.也就是说只要内存足够大, 理论上就可以表示无限大小的数据.

(2)浮点数

b=1.1
print(type(b)) 

【注意】: 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型. 但是实际上
Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数.

(3)字符串类型

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

【注意】: 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型. 但是实际上
Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数.

 可以使用len(关键字)来计算字符长度

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

可以字符串相加

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

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

(4) 布尔

布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假).

a = True
print(type(a))
b = False
print(type(b))

【注意】：在写布尔是True，False首字母要大写

(5) 其他
除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型 等等. 我们后续再介绍.

3.1 动态类型特性

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

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

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

动态类型特性的利弊

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

4 注释

4.1注释是什么

1：注释是一种特殊的代码, 它不会影响到程序的执行, 但是能够起到解释说明的作用, 能够帮助程序猿理解程
序代码的执行逻辑.
2：写代码是一件比较烧脑的事情, 读代码同样也非常烧脑. 相比于一板一眼的代码, 一些口语化的
描述能更好的帮助程序猿理解程序.

# 计算 4 个数字 67.5, 89.0, 12.9, 32.2 的方差
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)

形如上述代码, 如果没有注释, 直接阅读, 是不容易 get 到代码的含义是计算方差. 但是通过加了一行注释
解释一下, 就让人一目了然了.

注释语法
(1) 注释行
想要注释，一般都是用#。

#变量a的值为10
a=10
#变量b的值与a的值相等为10
b=a=10

(2) 文档字符串
使用三引号引起来的称为 “文档字符串”, 也可以视为是一种注释.
可以包含多行内容,
一般放在 文件/函数/类 的开头.
“”" 或者 ‘’’ 均可 (等价).

"""
内容
"""

5 输入输出

<首先要与用户交互>
   
程序需要和用户进行交互.：

1：用户把信息传递给程序的过程, 称为 "输入".

2: 程序把结果展示给用户的过程, 称为 "输出".

输入、输出：如图所示

5.1 print的介绍

1、print()括号中不仅能输入整型、浮点、字符串，还能输出布尔类型

print(10)
print("hello")
print(1.2)
print(True)

2、如果想要在print()括号中输出变量的数据时，则我们就要用到 f“内容”的格式数据变量用{}引出

a=10
b=1.1
c="hello world"
d=False
print(f"整型{a}、浮点{b}、字符串{c}、布尔{d}")

5.2 input

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

注意:
input 的参数相当于一个 "提示信息", 也可以没有.
input 的返回值就是用户输入的内容. 是字符串类型.
num = 0
num = input('请输入一个整数: ')
print(f'你输入的整数是 {num}')

（2）input输出的元素都是字符串

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

所以为了应对这种情况就应该转换成为我们想要的元素:

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

针对以上知识点进行练习:

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

6 运算符

6.1 算术运算符

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

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

print(10/0)

退出失败

注意2: 整数 / 整数 结果可能是小数. 而不会截断
相比于C++,java 整数/整数=整数
而python 整数/整数=小数或整数,整数和小数都有可能

print(2/3)

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

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

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

print(7/2)#去整数3

6.2 关系运算符

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

<= 是 “小于等于”
“>”= 是 “大于等于”
== 是 “等于”
!= 是 “不等于”

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

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

注意:
直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同).
字符串比较大小, 规则是 “字典序”

【提示】
对于浮点数来说, 不要使用 == 判定相等.

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

6.3 逻辑运算符

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

and 并且. 两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)–与C++的&&相似
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)

一种特殊写法

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

6.4赋值运算符

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

链式赋值

a=b=10

多元赋值

a,b=1,2

代码实例: 交换两个变量
基础写法：

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

更新：

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

(2) 复合赋值运算符

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

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

注意: 像 C++ / Java 中, 存在 ++ – 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用,
则直接使用 += 1 或者 -= 1

自测练习
(1) [多选] 以下关于变量之间加法运算的说法, 正确的是:
A. Python 中的字符串之间够能相加.
B. Python 中的字符串可以和整数相加.
C. Python 中的整数可以和浮点数相加.
D. Python 中的整数可以和布尔值相加.

ACD

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

D

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

B