Python 基础知识之数值类型、各类运算符及运算符优先级

1.数值类型

1.1 整数类型：int

表示的数值没有小数部分，包含正整数、负整数和0

1.2. 浮点型：float

小数
浮点数可以使用内置函数round()限定运算结果需要保留的小数位数
round()函数：

round()函数是Python中用于四舍五入的内置函数。它接受一个数字作为参数，并返回该数字四舍五入后的值。round()函数的基本用法如下：
   round(number)：将number四舍五入到最接近的整数。
   round(number, ndigits)：将number四舍五入到小数点后ndigits位。
例如：
   round(3.14159) 返回 3，因为3.14159四舍五入到最接近的整数是3.
   round(3.14159, 2) 返回 3.14，因为3.14159四舍五入到小数点后两位是3.14.
round()函数在处理中间值（如0.5）时的行为可能会因Python版本而异。在Python 3中，round()函数采用银行家舍入法（也称为四舍六入五成双），即当需要舍入的数字正好是中间值时，会舍入到最近的偶数。例如：
   round(2.5) 返回 2，因为2.5四舍五入到最近的偶数是2.
   round(3.5) 返回 4，因为3.5四舍五入到最近的偶数是4.
 这种舍入方式可以减少在大量计算中由于舍入误差积累导致的问题.

 a=3.12+6
 print(a)
 print(round(a,2))
 结果：
 9.120000000000001
 9.12

1.3. 布尔型：bool （重点）通常用于判断

有固定写法，一个为True（真），一个为False（假）
注意：True和False必须严格区分大小写
print(type(true)) #报错
布尔值可以当作整型对待，True相当于整数1，False相当于整数0
- print(True + False) #结果 1+0=1
- print(True + 1) #结果 1+1=2
非0的整数的布尔值都是True
非空的字符串的布尔值都是True

示例：
x=True
print(x)
print(type(x))
print(x+10) #1+10
print(False+10) # 0+10
print("----------------------")
print(bool(18),bool(18.8)) #测试一下整数18的布尔值
print(bool(0),bool(0.0)) #
#非0的整数的布尔值都是True
print(bool('北京欢迎您'))
print(bool(''))
# 非空字符串的布尔值都是True
print(bool(False))
print(bool(None))
-----------------------
结果：
True
<class 'bool'>
11
10
----------------------
True True
False False
True
False
False
False

1.4. 复数型：complex

固定写法： z=a+bj #a是实部，b是虚部，j是虚数单位
print(type(2 + 3j))
ma = 1+2i
- print(ma) #报错，j是固定的叙述单位，不能随意改变
ma = 1 + 2j
ma2 = 2 + 3j
print(ma + ma2) #=（1+2）+（2j+3j）#实部于实部相加，虚部与虚部相加

1.5.字符串类型

字符串又称为不可变字符序列,索引，切片
连续的字符序列，可以表示计算机所能识别的所有字符
字符串的界定符：单引号，双引号，三引号
具体操作见：https://www.cnblogs.com/kyle-7Qc/p/18538243

type()函数，查看变量的数据类型

案例：
   num1 = 2
   num2 = "Hello Python"
   num3 = 2.2
   print(type(num1))
   print(type(num2))
   print(type(num3))
效果：
   <class 'int'>
   <class 'str'>
   <class 'float'>

1.6. 数值类型之间的转换

示例：
	x=10
	y=3
	z=x/y
	print(z,type(z))  #隐形
	print(round(z))
	print(round(z,3))
	# float 类型转换int类型，只保留整数部分
        c=5.99
        print(int (c)) #浮点数转化为整数，采用截断处理，小数点后面直接砍掉
	print('float类型转成int类型：',int(3.14))
	print('float类型转成int类型：',int(3.9))
	print('float类型转成int类型：',int(-3.14))
	print('float类型转成int类型：',int(-3.9))
	#将int转换为float类型
	print('int类型转成float类型：',float(10))
	#将str转成int类型
	print(int("100")+int("200"))
	#将字符串转成int或float时报错情况
	# print(int('18a'))  #ValueError: invalid literal for int() with base 10: '18a'    18a不是十进制数
	# print(int('3.14'))  #ValueError: invalid literal for int() with base 10: '3.14'  3.14不是整数
	# print(float('45a,987')) # ValueError: could not convert string to float: '45a,987'  a没办法转

结果：
	3.3333333333333335 <class 'float'>
	3
	3.333
	float类型转成int类型： 3
	float类型转成int类型： 3
	float类型转成int类型： -3
	float类型转成int类型： -3
	int类型转成float类型： 10.0
	300

2.运算符

2.1. 算术运算符

运算符	描述
+	加
-	减
*	乘
/	除（商一定是浮点数，且除数不能为0）
//	取整数（取商的整数部分向下取整）
%	取余数
**	幂

案例

print(1+1) 加，结果：2
print(1*2) 乘，结果：2
print(2/1) 除，结果：2.0 #注意：使用算术运算符/，商一定是浮点数，且除数不能为0
print(3//2)取整除，结果：1
print(3%2) 取余， 结果：1
print(3**2) 幂，结果：9

#使用算术运算符，有浮点数的话，结果也用浮点数表示

`幂运算`
print(-5 ** 2)  -25
print(5 ** -2)  0.04
# 幂运算符比左侧的一元操作符优先级高，比右侧的一元操作符优先级低

练习

1.键盘输入一个四位整数，分别输出它的个位，十位，百位，千位上的数

<一>、int型
a=eval(input('请输入一个四位整数：'))
print(a,type(a))
print('个位数字是：',a%10)
print('十位数字是：',a%100//10)
print('百位数字是：',a//100%10)
print('千位数字是：',a//1000)

结果：
	请输入一个四位整数：1234
	1234 <class 'int'>
	个位数字是： 4
	十位数字是： 3
	百位数字是： 2
	千位数字是： 1
---------------------------------------------
<二>、字符串索引
a=input('请输入一个四位整数：')
print(a,type(a))
print('个位数字是：',a[3])
print('十位数字是：',a[2])
print('百位数字是：',a[1])
print('千位数字是：',a[0])

结果：
	请输入一个四位整数：1234
	1234 <class 'str'>
	个位数字是： 4
	十位数字是： 3
	百位数字是： 2
	千位数字是： 1

1. 数值类型转换

<一>、eval函数
f=eval(input('父亲身高：'))
m=eval(input('母亲身高：'))
s = (f+m) * 0.54

print(s)
-----------------------------------
<二>、类型转换
f=input('父亲身高：')
m=input('母亲身高：')
s = (float(f) + float(m)) * 0.54

print(s)

结果：
父亲身高：183.5
母亲身高：165.5
188.46

2.2. 赋值运算符

运算符	描述	实例
=	简单赋值运算符
+=	加法赋值运算符	c+=a等效于c=c+a
-=	减法赋值运算符	c-=a等效于c=c-a
*=	乘法赋值运算符	c * =a等效于c=c*a
/=	乘法赋值运算符	c/* =a等效于c=c/a
%=	取模赋值运算符	c%=a等效于c=c%a
**=	幂赋值运算符	c =a等效于c=ca
//=	取整除赋值运算符	c// =a等效于c=c//a

赋值运算符必须连着写，否则会报错
print(10+=3) #报语法错误，纯数字不符合，赋值运算符是针对已存在的变量的

# python支持链式赋值
a=b=c=d=100
print(a,b,c,d)
结果：100 100 100 100
# python支持系列解包赋值
a,b=10,20
print(a,b)
结果：10 20
# 通过解包赋值交换两个变量的值
a,b=10,20
print(a,b)
print('---------------')
a,b=b,a
print(a,b)
结果：
10 20
---------------
20 10
--------------------------
a=20
b=30
c=40
a,b,c=b,c,a
print(a,b,c)
结果：30 40 20

2.3. 比较运算符

比较两个表达式的大小，其结果为布尔类型的数据，即True或False。
比较运算符可用于任意类型的数据，但参与比较的两种类型的数据要相互兼容，即能进行隐式转换。例如:整数、浮点和布尔这三种类型是相互兼容的。

示例：
	a='Hello'
	b='Hello'
	print(a==b)

	a='World'
	print(a>b) 
# 比较字符串的大小，即逐一比较字符Unicode编码的大小，如果两个字符串的第1个字符不能比较出大小，则比较两个字符串的第2个字符，直到比较有了结果才结束比较
	a=[]
	b=[2,1]
	print(a>b)
# 比较列表大小，即逐一比较其中元素的大小，如果两个列表中的第1个元素不能比较出大小，则比较两个列表中的第2个元素，直到比较有了结果才结束比较。注意，在两个列表中元素类型要兼容
	a=['2']
	print(a>b) #TypeError: '>' not supported between instances of 'str' and 'int'  TypeError:在“str”和“int”的实例之间不支持“>”
结果：
	True
	True
	False

2.4. 逻辑运算符

逻辑运算符用于对布尔型变量进行运算，其结果也是布尔型。

(0 and 1): and 运算符需要两边都是True才返回右边的值。 print(3 and 4) 
# print((not 1) or (0 and 1) or (3 and 4) or (5 and 6) or (7 and 8 and 9) )

示例：

	a=1
	b=0
	def f1():    #定义一个函数f1()，
		print('--进入函数f1--') 
		return  True 
	print(a>b or f1())   #表达式(a>b)为True，结果确定为True，f1()函数不会被调用
	print(a<b or f1())   #表达式(a<b)为False，结果不确定，f1()函数会被调用
	print(a<b and f1())  #表达式(a<b)为False，结果确定为False，f1()函数不会被调用
	print(a>b and f1())  #表达式(a>b)为True，结果不确定f1()函数会被调用

结果：
	True
	--进入函数f1--
	True
	False
	--进入函数f1--
	True