python基础（二）

python基础（二）

6. 数字类型

Python 中存在四种不同的数字（Number）类型，整数（int）、浮点数（float）、布尔类型（bool）和复数（complex）。

6.1 整数（int）

整数（int）是完整的数字，正数或负数，没有小数，长度不限。默认用十进制表示，同时也支持二进制，八进制，十六进制表示方式。比如：

3
-3

6.2 浮点数（float）

Python 的浮点数（float）也就是数学中的小数。比如：

3.14
2.5
-0.3

6.3 布尔（bool）

Python 中提供了 bool 类型来表示真（对）或假（错），并分别用 关键字 Ture（真或对）或 False（假或错）来表示，在 Python中，是明确区分大小写的，即首字母一定要大写，不然解释器会报错。比如：

print(True)
print(False)

执行以上代码，输出结果为：

True
False

bool 类型只有 Ture 和 False 两个实例，且 bool 值可以当作整数来代替，即 True 代表整数1，False 代表整数 0，并可以参与运算，但在项目开发中不能这样用：

print(5 > 4)
print(5 < 4)
print(True+1)
print(False+1)

执行以上代码，输出结果为：

True
False
2
1

6.4 复数（complex）

复数由实数部分和虚数部分组成，可以用 a+bj 或者 complex(a, b)表示，复数的实部 a 和虚部 b 都是浮点型。

（1）方式一：a+bj

1+4j
-8j

（2）方式二：complex(a, b)

complex(1, 4)
complex(0, -8)

7. 数据类型转换

数据类型转换是将自身数据类型转化成新的数据类型，并拥有新数据类型相关操作的过程。

7.1 用type()函数查看数据类型

有时你可能想知道某个程序中的变量类型，也许这个类型从代码中并不明显，或者你从一个代码无法访问的源头得到了这个信息。每当你想查看一个变量的类型时，你可以使用 type() 函数，语法格式为 type(object)，其中 object 为需要查看数据类型的目标数据，不需要用引号引起来。

（1）识别字符串（str），比如：

name1 = "Li Ming"
print(type(name1))

name2 = "123456"
print(type(name2))

执行以上代码，输出结果为：

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

用 type() 函数检查 “Li Ming” 显示它的类型是 str；用 type() 函数检查 “123456”，这个变量再次持有 str 的类型，尽管我们看到了数字，但它是一个被双引号引起来的数字字符串，而不是实际的数字类型。

（2）识别整数（int），浮点数（float） ，布尔类型（bool）和复数（complex），比如：

name1 = 123456
print(type(name1))

name2 = 1.23456
print(type(name2))

print(type(5 > 4))
print(type(4 > 5))

print(type(1+4j))
print(type(complex(4, 5)))

执行以上代码，输出结果为：

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'bool'>
<class 'complex'>
<class 'complex'>

7.2 隐式类型转化

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预，比如：

print(type(1+0.1))

执行以上代码，输出结果为：

<class 'float'>

我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

7.3 显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。
（1）int() 函数

int() 函数用于将一个字符串或数字转换为整型。语法格式为 int(x, base=10)，x 为字符串或数字，base 为进制数，默认十进制。

① 不输入参数时，输出结果为 0：

print(int())
print(int(3))           
print(int(3.6)) 

执行以上代码，输出结果为：

0
3
3

② 若 x 为纯数字，则不能有 base 参数，否则报错，比如：

print(int(3, 10))

执行以上代码，输出结果为：

Traceback (most recent call last):
  File "", line 1, in <module>
    print(int(3, 10))
TypeError: int() can't convert non-string with explicit base

如果是带参数 base 的话，x 要以字符串的形式进行输入，比如：

print(int("3", 10))

执行以上代码，输出结果为：

3 

（2）float() 函数

float() 函数用于将整数和字符串转换成浮点数。语法格式为 float(x)，其中 x 为整数或字符串。比如：

print(float(3))             # 整数
print(float(3.0))           # 小数
print(float(-3.0))          # 小数
print(float("3"))           # 字符串
print(float("3.0"))         # 字符串

执行以上代码，输出结果为：

3.0
3.0
-3.0
3.0
3.0

（3）str() 函数

str() 函数用于将参数转换成字符串类型，即适于人阅读的形式。比如：

print(str(1))
print(str("1"))

执行以上代码，输出结果为：

1
1

8. 输入

Python 中 input 函数用于提示并获取终端用户输入内容，一般获取的输入内容为字符串类型。 input 函数的语法格式为 input(tips)，其中 tips 为提示信息，一般用引号引起来提示输出。运行代码之后可自定义输入目标数据，返回结果为字符串 str 类型。比如：

a = input("请输入账号：")
print("您输入的账号为：%s" % a)
print("您输入的账号类型为：", type(a))

执行以上代码，输出结果为：

请输入账号：abcdefg
您输入的账号为：abcdefg
您输入的账号类型为： <class 'str'>

9. 运算符

Python 运算符主要包括算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符和身份运算符。

9.1 算术运算符

算术运算符包括：加（+）、减（-）、乘（*）、除（/）、取模（%）、幂（**）和取整除（//）。以下假设变量 a=10，变量 b=21：

运算符	含义	描述	实例
+	加	两个对象相加	a + b 输出结果 31
-	减	得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘	两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除	x 除以 y	b / a 输出结果 2.1
%	取模	返回除法的余数	b % a 输出结果 1
**	幂	返回 x 的 y 次幂	b % a 输出结果 1
//	取整除	往小的方向取整数	b // a 输出结果 2

9.2 比较运算符

比较运算符包括：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。以下假设变量 a 为10，变量 b 为20：

运算符	含义	描述	实例
==	等于	比较对象是否相等	a == b 返回 False
!=	不等于	比较两个对象是否不相等	a != b 返回 True
>	大于	返回 x 是否大于 y	a > b 返回 False
<	小于	返回 x 是否小于 y	a < b 返回 True
>=	大于等于	返回 x 是否大于等于 y	a >= b 返回 False
<=	小于等于	返回 x 是否小于等于 y	a <= b 返回 False

9.3 赋值运算符

赋值运算符包括：简单的赋值运算符（=）、加法赋值运算符（+=）、减法赋值运算符（-=）、乘法赋值运算符（*=）、除法赋值运算符（/=）、取模赋值运算符（%=）、幂赋值运算符（**=）和取整除赋值运算符（//=）。

运算符	含义	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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 = c // a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
比如：

a = 2
b = 11

c = a + b
print(c)

c += a
print(c)

c -= a
print(c)

c *= a
print(c)

c /= a
print(c)

c %= a
print(c)

c **= a
print(c)

c //= a
print(c)

执行以上代码，输出结果为：

13
15
13
26
13.0
1.0
1.0
0.0

9.4 位运算符

按位运算符是把数字看作二进制来进行计算。

（1）位运算符的规则

程序中的数在计算机内存中都是以二进制的形式存在的，位运算就是直接对整数在内存中对应的二进制位进行操作。比如，a 为 60，b 为 13，它们的二进制格式如下：

a = 0011 1100
b = 0000 1101

运算符	含义	描述	实例
&	按位与运算符	参与运算的两个值,如果两个相应位都为 1，则该位的结果为 1，否则为 0	(a & b) 输出结果 12 ，二进制解释：0000 1100
I	按位或运算符	只要对应的二个二进位有一个为 1 时，结果位就为 1	(a I b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	当两对应的二进位相异时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释：0011 0001
~	按位取反运算符	对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符	把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111
（2）二进制与十进制之间的转换方法

① 十进制转二进制

Ⅰ 十进制正整数转换为二进制

采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为0时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。比如：

Ⅱ 十进制负整数转换为二进制整数

先是将对应的正整数转换成二进制后，对二进制取反，然后对结果再加 1。比如：

Ⅲ 十进制小数转换为二进制

对小数点以后的数乘以 2，有一个结果吧，取结果的整数部分（不是 1 就是 0 喽），然后再用小数部分再乘以 2，再取结果的整数部分……以此类推，直到小数部分为 0 或者位数已经够了就 OK 了。然后把取的整数部分按先后次序排列就 OK 了，就构成了二进制小数部分的序列。比如：

② 二进制转十进制
Ⅰ 二进制正整数转换为十进制

首先将二进制数补齐位数，首位如果是 0 就代表是正整数，如果首位是 1 则代表是负整数。

先看首位是 0 的正整数，补齐位数以后，将二进制中的位数分别将下边对应的值相乘，然后相加得到的就为十进制

Ⅱ 二进制负整数转换为十进制

若二进制补足位数后首位为 1 时，就需要先取反再换算：比如，11101011，首位为 1，那么就先取反：-00010100，然后算一下 10100 对应的十进制为20，所以对应的十进制为-20：

Ⅲ 二进制小数转换为十进制

例如 0.1101 转换为十进制的方法：将二进制中的四位数分别于下边对应的值相乘后相加得到的值即为换算后的十进制。
（3）补码与源码

现在计算机普遍使用补码表示负数，但是如果任意给出一个二进制数字，无法分辨它是源码还是补码。如果确认是补码，求源码的方式是：补码取反再加 1。补码的第一位符号位决定了源码的正负，第一位为 0 源码为正，第一位为 1 源码为负。

比如，在求解 ~60 时，60 按位取反后得到 1100 0011，其第一位为1，源码为负值，取反后为 0011 1100，再加 1 得 0011 1101，其值为 61，再加上负号即为 -61。

（4）位运算符在 Python 中的应用

在进行十进制位运算时，无需转换为二进制，只要使用位运算符，Python 就会按照二进制来进行计算。比如：

a = 60
b = 13
print(a & b)
print(a | b)
print(a ^ b)
print(~a)
print(a << 2)
print(a >> 2)

执行以上代码，输出结果为：

12
61
49
-61
240
15

9.5 逻辑运算符

Python 语言支持逻辑运算符：

运算符	含义	逻辑表达式	描述
and	布尔“与”	x and y	同真为真，一假则假
or	布尔“或”	x or y	同假才假，一真即真
not	布尔“非”	x not y	非真即假，非假即真

在 Python 中，整数0代表假，整数 1 代表真。除此之外，Python 也把任意的空数据结构视为假，把任何非空数据结构视为真。真和假的概念是 Python 中每个对象的固有属性，一般来说：① 数字如果非零，则为真；② 其他对象如果非空，则为真。Python 还有一个特殊对象：None，它总被认为是假。

比如：

a = 10
b = 20

if a and b:
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if a and b:
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")

if a or b:
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")

if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")

执行以上代码，输出结果为：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

9.6 成员运算符

Python 支持成员运算符：

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	如果在指定的序列中没有找到值返回 True，否则返回 False

比如：

a = 1
b = 2
list = [2, 3, 4, 5]

if a in list:
    print("a在列表中")
else:
    print("a不在列表中")

if b not in list:
    print("b不在列表中")
else:
    print("b在列表中")

执行以上代码，输出结果为：

a不在列表中
b在列表中

9.7 身份运算符

（1）身份运算符是 Python 用来判断的两个对象的存储单元是否相同的一种运算符号，身份运算符只有 is 和 is not 两个运算符，返回的结果都是 True 或者 False：

运算符	描述	实例
is	判断两个标识符是不是引用自一个对象	x is y， 如果引用的是同一个对象则返回 True，否则返回 False
is not	是判断两个标识符是不是引用自不同对象	x is not y，如果引用的不是同一个对象则返回结果 True，否则返回 False

比如：

a = 1
b = 2
c = a
print(a is b)
print(a is c)
print(a is not b)
print(a is not c)

执行以上代码，输出结果为：

False
True
True
False

再比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a)
print(b)
print(a is b)
print(a is c)

执行以上代码，输出结果为：

[0, 1, 2]
[0, 1, 2]
False
True

通过这个结果我们发现，a 和 b 引用的对象是不一致的，所以 a is b 输出的结果是 False，因为变量 b 是需要计算的，虽然计算之后得到的列表跟 a 一模一样，但是计算之前的过程每个元素是要存储的，变量 a 当中的元素都是数字，计算机是直接存储结果的，而变量 b 当中的每个元素都是表达式，表达式的储存跟单个元素的储存是不一致的，列表、元组都是如此。

（2）is 与 == 的区别

is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。比如：

a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a is b)
print(a is c)
print(b is c)
print(a is b is c)
print(a == b == c)

执行以上代码，输出结果为：

False
True
False
False
True

9.8 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级：

优先级	运算符	描述	结合性
19	()	小括号	无
18	x[i]	索引运算符	左
17	x.attribute	属性访问	左
16	**	乘方（指数）	右
15	~	按位取反	右
14	+, -	正号，负号	右
13	*, /, %, //	乘，除，取模，取整除	左
12	+, -	加号，减号	左
11	>>, <<	右移动运算符，左移动运算符	左
10	&	按位与运算符	右
9	^	按位异或运算符	左
8	I	按位或运算符	左
7	==, !=, <=, <, >, >=	等于，不等于，小于等于，小于，大于等于，大于	左
6	is, is not	身份运算符	左
5	in, not in	成员运算符	左
4	not	逻辑运算符非	右
3	and	逻辑运算符与	左
2	or	逻辑运算符或	左
1	exp1, exp2	逗号运算符	左

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。例如对于表达式对于 100 / 25 * 16，/ 和 * 的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/ 和 * 都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。

10. 行与缩进

Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，一般用 Tab 健进行操作。比如：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
    print("False")  

执行以上代码，输出结果为：

Answer
True

以下代码最后一行语句和同一代码块语句缩进数的空格数不一致，会导致运行错误：

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
  print("False")    # 缩进不一致，会导致运行错误

执行以上代码，输出结果为：

 File ".py", line 6
    print ("False")
                   ^
IndentationError: unindent does not match any outer indentation level