第二章-Python基础(下)(2.3-2.5)
第二章 - Python基础（下）
2.3 基础语法-标准数据类型
2.3.1 变量
通俗来说：变量是程序在运行过程中，临时在内存中存储数据。
1、声明变量
在Python中声明变量的时候需要加上变量的数据类型，例如C++中：
[类型名] [变量名]
int a = 1;
我命定义了一个int类型的变量，并给这个变量赋值1。
而在Python中我们不需要声明变量类型，可以直接赋值，当变量被赋值的数据类型是什么，则变量的类型就是什么。
a1 = 'python'
所以在这里a1的数据类型为字符串。
2、 变量的命名规则
在Python中使用变量时，需要遵守一些规则和指南。违反这些规则将引发错误，而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。
-
变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
-
变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message 可行，但变量名greeting message会引发错误。
-
不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词。
-
变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length 比length_of_persons_name好。
-
慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。要创建良好的变量名，需要经过一定的实践，在程序复杂而有趣时尤其如此。随着你编写的。
程序越来越多，并开始阅读别人编写的代码，将越来越善于创建有意义的变量名。
注意：就目前而言，应使用小写的Python变量名。在变量名中使用大写字母虽然不会导致错误， 但避免使用大写字母是个不错的主意。
变量命名方式推荐
变量的命名一定要通俗易懂，具有可描述性。
可以使用驼峰式、下划线
# 驼峰式
NewList = [1,2,3,4,5]
# 下划线
new_list = [1,2,3,4,5]
3、变量的赋值
在Python中使用 = 来对变量进行赋值。
name = "张三"
多元赋值
name1, name2, name3 = "张三","李四","王五"
print(name1, name2, name3)
# 张三 李四 王五
这样赋值需要注意其顺序，Python是按照顺序赋值的，如果顺序不一样，变量赋的值也就不一样。
如果想要多个变量赋同一个值的话 - 链式赋值
name1 = name2 = name3 = "张三"
print(name1, name2, name3)
# 张三 张三 张三
或者
name1 = "张三"
name2 = name1
name3 = name2
print(name1, name2, name3)
# 张三 张三 张三
当然在这过程中变量赋值的地址还是同一个的并不是创建了三个内存空间。
4、 变量的保存
在Python中变量的保存并不是把值直接给到变量，而是在内存中创建一个内存地址，这个内存地址取一个名称。那么对应的值，Python也是在内存中创建一个内存空间来保存值，而变量名的在内存中保存的就是值的内存地址。
这里我们可以使用id()函数来查看地址。当然在我们每次运行的时候Python会重新分配地址，所以每一次运行的内存地址是不一样的。
a = 123
print(id(a)) # 94404061954336
当我们再给变量a赋另外一个值的时候内存地址会不一样。
a = 123
print(id(a))
a = 456
print(id(a))
这个时候并不是把内存地址删了或者是更改了，而是在内存中又重新创建了一个456的内存空间，变量a保存的地址为456的内存地址了。
但是123的内存空间并没删除消失。当我们再创建一个变量赋123的时候地址会跟之前的一样。
a = 123
print(id(a))
a = 456
print(id(a))
b = 123
print(id(b))
2.3.2 常量
常量的值是不能改变的，一般从其字面形式即可判别是否为常量。在其他语言中常量包括数值型常量、字符型常量等。但在Python中这些统一做了处理，在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量。
2.3.3 标准数据类型
在Python中有六个标准数据类型
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
在这六个标准数据类型中
- 不可变数据：Number（数字）、String（字符串）、Tuple（元组）
- 可变数据：List（列表）、Set（集合）、Dictionary（字典）
可变数据和不可变数据是相对于引用地址来说的，不可变数据类型不允许变量的值发生变化，如果改变了的变量的值，相当于新建了一个对象，而对于相同的值的对象，内部会有一个引用计数来记录有多少个变量引用了这个对象。可变数据类型允许变量的值发生变化。对变量进行修改操作只会改变变量的值，不会新建对象，变量引用的地址也不会发生变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
简单地讲，可变数据和不可变数据的“变”是相对于引用地址来说的，不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。
2.3.4 类型的判断
在Python中我们可以使用 type() 函数来查看一个变量的类型，例如：
a1 =1
print(type(a1)) # <type 'int'>
a2= "hello python"
print(type(a2)) # <type 'str'>
a3= [1,2,3]
print(type(a3)) # <type 'list'>
当我们要比对一个变量或对象是否是某一个类型的时候我们可以使用isinstance()来进行判断， isinstance()的返回结果也只有两个True、False。
a = 1
print(type(a))
print(isinstance(a,int)) # True
2.4 运算符
什么是运算符呢？运算符其实就是我们小学中学的加、减、乘、除、大于、小于、等于等等，如果说我们要算1+1等于多少，但是由于计算机并不懂运算，所以我们就需要运算符来告诉计算机完成什么样的运算。
在计算机中并不只有算数运算符和比较运算符，还支持一下的运算符：
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 运算符优先级
2.4.1 算数运算符
| 运算符 | 描述 | 使用 |
|---|---|---|
| + | 加法（两个对象相加） | a+b |
| - | 减法（一个数减去另外一个数或者得到负数） | a-b/-a |
| * | 乘法（两个数相乘，可以乘以字符串则返回重复出现若干次字符串） | a*b |
| / | 除法（一个数除以另外一个数） | a/b |
| % | 取模（返回除法的余数） | a%b |
| ** | 幂（返回一个数的几次幂） | a**b |
| // | 去整除（返回商的整数部分） | a//b |
接下来我们实例用一下算数运算符
a = 16
b = 5
c = 0
c = a + b
print ("a+b 的值为：", c)
c = a - b
print ("a-b 的值为：", c)
c = a * b
print ("a*b 的值为：", c)
c = a / b
print ("a/b 的值为：", c)
c = a % b
print ("a%b 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("a**b 的值为：", c)
a = 10
b = 5
c = a//b
print ("a//b 的值为：", c)
2.4.2 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于（比较对象是否相等） | (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) 返回 True。 |
注意：所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意：True和False的首字母为大写。
a = 21
b = 10
c = 0
if ( a == b ):
print ("a 等于 b")
else:
print ("a 不等于 b")
if ( a != b ):
print ("a 不等于 b")
else:
print ("a 等于 b")
if ( a < b ):
print ("a 小于 b")
else:
print ("a 大于等于 b")
if ( a > b ):
print ("a 大于 b")
else:
print ("a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("a 小于等于 b")
else:
print ("a 大于 b")
if ( a >= b ):
print ("a 大于等于 b")
else:
print ("a 小于 b")
2.4.3 赋值运算符
在Python中赋值运算符为 = 号，把 = 右面的值赋值给左边的变量，但是Python中没有自增（++）自减（--）.
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | 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 = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为：", c)
c += a
print ("2 - c 的值为：", c)
c *= a
print ("3 - c 的值为：", c)
c /= a
print ("4 - c 的值为：", c)
c = 2
c %= a
print ("5 - c 的值为：", c)
c **= a
print ("6 - c 的值为：", c)
c //= a
print ("7 - c 的值为：", c)
2.4.4 位运算符
按位运算符是把数字看作二进制来进行计算的。
下表中变量 a 为 60，b 为 13。
| 按位与运算（a&b） | 按位或运算(a|b) | 按位异或（a^b） | |
|---|---|---|---|
| a（60）的二进制表示 | 0011 1100 | 0011 1100 | 0011 1100 |
| b（13）的二进制表示 | 0000 1101 | 0000 1101 | 0000 1101 |
| 运算结果 | 0000 1100 | 0011 1101 | 0011 0001 |
| 结果的十进制表示 | 12 | 61 | 49 |
| 按位取反（~a） | 左移（a<<2） | 右移(a>>2) | |
|---|---|---|---|
| a（60）的二进制表示 | 0011 1100 | 0011 1100 | 0011 1100 |
| 运算结果 | 1100 0011 | 1111 0000 | 0000 1111 |
| 运算结果的十进制表示 | -61 | 240 | 15 |
注：关于原码，补码和反码：
原码：假设机器字长为n，原码就是用一个n位的二进制数，其中最高位为符号位：正数是0，负数是1。剩下的表示概数的绝对值，位数如果不够就用0补全。
反码：在原码的基础上，符号位不变其他位取反，也就是就是0变1，1变0。
补码：在反码的基础上加1。
PS：正数的原、反、补码都一样，0的原码跟反码都有两个，因为这里0被分为+0和-0。
按位取反和反码有一定的相似之处但又不尽相同（反码符号位不取反）。
在计算机中，是以补码的形式存放数据的。1100 0011刚好对应-61。
-61的原码-> 1011 1101->反码->1100 0010->补码->1100 0011
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为 1,则该位的结果为 1,否则为 0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为 1。 | (a |
| ^ | 按位异或运算符：当两对应的二进位相异（不同）时，结果为 1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把 1 变为 0，把 0 变为 1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补 0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
以下实例演示了 Python 所有位运算符的操作：
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值为：", c)
c = a | b; # 61 = 0011 1101
print ("2 - c 的值为：", c)
c = a ^ b; # 49 = 0011 0001
print ("3 - c 的值为：", c)
c = ~a; # -61 = 1100 0011
print ("4 - c 的值为：", c)
c = a << 2; # 240 = 1111 0000
print ("5 - c 的值为：", c)
c = a >> 2; # 15 = 0000 1111
print ("6 - c 的值为：", c)
2.4.5 逻辑运算符
Python 语言支持逻辑运算符，以下假设变量 a 为 10, b 为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" (如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。) |
(a and b) 返回 20。 |
| or | x or y | 布尔"或" ( 如果 x 是 True，它返回 x的值，否则它返回 y 的计算值。) |
(a or b) 返回 10。 |
| not | not x | 布尔"非" ( 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。) |
not(a and b) 返回 False |
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")
2.4.6 成员运算符
除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
以下实例演示了 Python 所有成员运算符的操作：
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中")
else:
print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")
2.4.7 身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) == id(y) ,如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y , 如果 id(x) != id(y). is not 返回结果 True |
以下实例演示了 Python 所有身份运算符的操作：
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识")
else:
print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识")
else:
print ("2 - a 和 b 没有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的标识")
else:
print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识")
else:
print ("4 - a 和 b 有相同的标识")
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
2.4.8 运算符优先级
以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：
| 运算符 | 描述 |
|---|---|
| (expressions...), [expressions...], {key: value...}, |
圆括号的表达式 |
| x[index], x[index:index], x(arguments...), x.attribute | 读取，切片，调用，属性引用 |
| await x | await 表达式 |
| ** | 乘方(指数) |
| +x, -x, ~x | 正，负，按位非 NO |
| *, @, /, //, % | 乘，矩阵乘，除，整除，取余 |
| +, - | 加和减 |
| <<, >> | 移位 |
| & | 按位与 AND |
| ^ | 按位异或 XOR |
| | | 按位或 OR |
| in,not in, is,is not, <, <=, >, >=, !=, == | 比较运算，包括成员检测和标识号检测 |
| not x | 逻辑非 NOT |
| and | 逻辑与 AND |
| or | 逻辑或 OR |
| if -- else | 条件表达式 |
| lambda | lambda 表达式 |
| := | 赋值表达式 |
以下实例演示了 Python 所有运算符优先级的操作：
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为：", e)
and 拥有更高优先级:
x = True
y = False
z = False
if x or y and z:
print("yes")
else:
print("no")
以上实例先计算 y and z 并返回 False ，然后 x or False 返回 True，输出结果：yes
2.5 输入输出
2.5.1 输入（input()）输出（print()）
当我们需要向计算机输入一些东西的时候我们该如果实现，在Python中有 input() 函数可以直接输入，并且还可以在函数中直接打上提示符。
注意： 在Python中input()输入的内容全部都是字符串(str)数据类型，当我们想输入数字(int)类型或者其他数据类型的时候我们可以使用数据类型转换。例如：age应该是数字所以我们就可以在input()外面加上强制类型转化int()。
当我们输入完成想要打印出我们的输入的信息时我们可以使用 print() 函数。
# 输入一个张三的信息，name：张三，age：18，sex：男
name = input("请输入姓名：")
age = int(input("请输入年龄："))
sex = input("请输入性别：")
print(name)
print(age)
print(sex)
注意： 在Python中print函数是自带换行的，当我们需要一句末尾不换行可以使用end=''，下面我们来看看print的可设置参数。
print(*objects, sep=' ', end='\n', file=sys.stdout)
参数的具体含义如下：
objects --表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。
sep – 用来间隔多个对象 sep = ''可以用来设置什么符号来间隔。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符，如果不想换行可以声明都不要写end=''。
file – 要写入的文件对象。
2.5.2 格式化输出
当我们想要把信息编成一句话输出的时候，我们就需要用到格式化输出。
1、占位符
占位符是我们在一个输出语句中使用%来作为占下一个位置。
# 输入一个张三的信息，name：张三，age：18，sex：男
name = input("请输入姓名：")
age = int(input("请输入年龄："))
sex = input("请输入性别：")
print("姓名：%s，年龄：%d，性别：%s。"%(name,age,sex))
在上面程序中 %s 就是代表字符串占位符，还有%d是数字占位符。
注意： 在一个语句中我们如果想要输出%该怎么办，当然在输出语句中或者其他形式的\n，这个时候我么又该怎么办。
在编写程序的时候我么可以通过两个`%`来完成转义`%%`，我们如果想不转义可以在字符串引号前面加上`r`。
# 输入一个张三的信息，name：张三，age：18，sex：男
name = input("请输入姓名：")
age = int(input("请输入年龄："))
sex = input("请输入性别：")
print("姓名：%s，年龄：%d，性别：%s。全国有%%80的人叫%s"%(name,age,sex,name))
print(r"姓名：%s，年龄：%d，性别：%s。\全国有%%80的人叫%s"%(name,age,sex,name))
详细的转义字符见数据类型字符串章节
2.5.3 format格式化输出
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
print("姓名：{}，年龄： {}".format("张三", 18)) # 不设置指定位置，按默认顺序
print（"姓名：{0}，年龄： {1}".format("张三", 18)） # 设置指定位置
print（"姓名：{0}，年龄： {1}，{1}".format("张三", 18)） # 设置指定位置
也可以设置参数：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print("姓名：{name}, 年龄 {age}".format(name="张三", age = 18))
# 通过字典设置参数
site = {"name": "张三", "age": 18}
print("姓名：{name}, 年龄 {age}".format(**site))
# 通过列表索引设置参数
my_list = ['张三', 18]
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
也可以向 str.format() 传入对象：
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
输出结果为：
value 为: 6
数字格式化
下表展示了 str.format() 格式化数字的多种方法：
print("{:.2f}".format(3.1415926))
3.14
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} |
3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} |
+3.14 | 带符号保留小数点后两位 |
| -1 | {:-.2f} |
-1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} |
3 | 不带小数 |
| 5 | {:0>2d} |
05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} |
5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} |
10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} |
1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} |
25.00% | 百分比格式 |
| 1000000000 | {:.2e} |
1.00e+09 | 指数记法 |
| 13 | {:>10d} |
13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} |
13 | 左对齐 (宽度为10) |
| 13 | {:^10d} |
13 | 中间对齐 (宽度为10) |
| 11 | '{:b}'.format(11) |
1011 |
进制 |
^ , < , > 分别是居中、左对齐、右对齐，后面带宽度，:号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {} 来转义大括号，如下实例：
print ("{} 对应的位置是 {{0}}".format("张三"))
输出结果为：
张三 对应的位置是 {0}
