第2章 (1) 编程基础概念

第2章(1) 编程基础概念

Python程序的构成

1.Python程序由模块组成。一个模块对应python源文件，一般后缀名是：.py。
2.模块由语句组成。运行Python程序时，按照模块中语句的顺序依次执行。
3.语句是Python程序的构造单元，用于创建对象、变量赋值、调用函数、控制语句等。

Python文件的创建和执行

前面使用的交互式环境，每次只能执行一条语句；为了编写多条语句实现复杂的逻辑，本章开始我们通过创建Python文件，并执行该文件。
在IDLE环境中，我们可以通过File-->new创建Python文件，并可以编辑该文件内容。我们也可以通过File-->save/save as保存文件。一般保存成扩展名为py的文件。
需要执行编辑好的文件，可以用快捷键F5或者点击Run-->Run module。

代码的组织和缩进

很多编程语言通过字符(例如：花括号{})、关键字(例如：begain/end)来划分代码块。同时，在配合代码的缩进增加可读性。“龟叔”设计Python语言时，直接通过缩进来组织代码块。“缩进”成为了Python语法强制的规定。
缩进时，几个空格都是允许的，但是数目必须统一。我们通常采用“四个空格”表示一个缩进。
同时，也要避免将“tab制表符”或者tab与空格混合的缩进风格。目前，常用的编辑器一般设置成：tab制表符就是4个空格。

Python官方推荐的PEP-8代码风格详细说明，有兴趣的同学可以参考：
https://www.python.org/dev/peps/pep-0008/

使用注释#

注释是程序中会被Python解释器忽略的一段文本。程序员可以通过注释记录任意想写的内容，通常是关于代码的说明。

Python中的注释只有单行注释，使用#开始直到行结束的部分。

a = [10,20,30] #生成一个列表对象，变量a引用了这个变量

使用\行连接符

一行程序长度是没有限制的，但是为了可读性更强，通常将一行比较长的程序分为多行。这是，我们可以使用\行连接符，把它放在行结束的地方。Python解释器仍然将它们解释为同一行。

点击查看代码

 a = [10,20,30,40,\
     50,60,70,\
     80,90,100]

对象

Python中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值）组成。

1.标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数id(obj)可返回对象obj的标识。
2.类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用type(obj)获得对象的所属类型。
3.值表示对象所存储的数据的信息。使用print(obj)可以直接打印出值。

对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

源码：

点击查看代码

>>> a = 3
>>> a
3
>>> id(3)
1531372336
>>> type(3)
<class 'int'>
>>> b = "我爱你"
>>> id(a)
1531372336
>>> type(a)
<class 'int'>
>>> print(a)
3
>>> id(b)
46806816
>>> type(b)
<class 'str'>

示意图：

引用

在Python中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。
变量通过地址引用了“对象”。

变量位于：栈内存（压栈出栈等细节，后续再介绍）。
对象位于：堆内存。

·Python是动态类型语言
变量不需要显式声明类型。根据变量引用的对象，Python解释器自动确定数据类型。

·Python是强类型语言
每个对象都有数据类型，只支持该类型支持的操作。

标识符

基本用法

标识符：用于变量、函数、类、模块等的名称。标识符有如下特定的规则：
1.区分大小写。如：sxt和SXT是不同的
2.第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
3.不能使用关键字。比如：if、or、while等。
4.以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类的构造函数。

【操作】使用Python帮助系统查看关键字

注：无需刻意去背关键字，后面都会学习。

Python标识符命名规则

开发中，我们通常约定俗称遵守如下规则：

类型	规则	例子
模块和包名	全小写字母，尽量简单。若多个单词之间用下划线	math, os, sys
函数名	全小写字母，多个单词之间用下划线隔开	phone, my_name
类名	首字母大写，采用驼峰原则。多个单词时，每个单词第一个字母大写，其余部分小写	MyPhone、MyClass、Phone
常量名	全大写字母，多个单词使用下划线隔开	SPEED、MAX_SPEED

变量和简单赋值语句

变量的声明和赋值

变量的声明和赋值用于将一个变量绑定到一个对象上，格式如下：
变量名 = 表达式

最简单的表达式就是字面量。比如：a = 123 。 运行过程中，解释器先运行右边的表达式，生成一个代表表达式运算结果的对象；然后，将这个对象地址赋值给左边的变量。

【操作】变量在使用前必须先被初始化（先被赋值）

my_name
Traceback (most recent call last):
File "<pyshell#17>", line 1, in
my_name
NameError: name 'my_name' is not defined

变量my_name在被使用前未做赋值，因此报错：’my_name’is not defined。

删除变量和垃圾回收机制

可以通过del语句删除不在使用的变量。

【操作55】删除变量示例

a=123
del a
x
Traceback (most recent call last):
File "<pyshell#20>", line 1, in
x
NameError: name 'x' is not defined

如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。

链式赋值

链式赋值用于同一个对象赋值给多个变量。
x=y=123 相当于：x=123; y=123

系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）

a,b,c=4,5,6 相当于：a=4;b=5;c=6

【操作】使用系列解包赋值实现变量交换

a,b=1,2
a,b=b,a
print(a,b)
2 1

常量

Python不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。

MAX_SPEED = 120
print(MAX_SPEED)
120
MAX_SPEED = 140 #实际是可以改的。只能逻辑上不做修改。
print(MAX_SPEED)
140

最基本内置数据类型和运算符

每个对象都有类型，python中最基本的内置数据类型：
1.整型
整数，2345,10,50
2.浮点型
小数，3.14或者科学计数法314e-2
3.布尔型
表示真假，仅包含：True、False
4.字符串型
由字符组成的序列。 “abc”,”sxt”,“尚学堂”,”百战程序员”

数字和基本运算符

Python支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加法	3+2	5
-	减法	30-5	25
*	乘法	3*6	18
/	浮点数除法	8/2	4.0
//	整数除法	7//2	3
%	模（取余）	7%4	3
**	幂	2**3	8

【操作】基本运算符的使用

a = 7/2
a
3.5
a = 7//2
a
3
a = 7%2
a
1
7%4
3
2**3
8
3/0
Traceback (most recent call last):
File "<pyshell#37>", line 1, in
3/0
ZeroDivisionError: division by zero
divmod(10,5)
(2, 0)
divmod(10,3)
(3, 1)

除数为0，会产生异常：

3/0
Traceback (most recent call last):
File "<pyshell#31>", line 1, in
3/0
ZeroDivisionError: division by zero

使用divmod()函数同时得到商和余数：

divmod(13,3)
(4, 1)

divmod()是一个函数，我们以后会详细介绍。他返回的是一个元组(后续将会学习)。

整数

Python中，除10进制，还有其他三种进制：
·0b或0B，二进制 0 1
·0o或0O，八进制 0 1 2 3 4 5 6 7
·0x或0X，十六进制0 1 2 3 4 5 6 7 8 9 a b c d e f

这三种进制可以非常方便的进行“位运算”操作。位运算知识后续将会介绍。
【操作】测试不同进制

12
12
0b101
5
0o19
SyntaxError: invalid syntax
0o10
8
0xff
255
0xf
15
0x10
16

使用int()实现类型转换：
1.浮点数直接舍去小数部分。如：int(9.9)结果是：9
2.布尔值True转为1，False转为0。 如：int(True)结果是1
3.字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

int("456")
456
int("456abc")
Traceback (most recent call last):
File "<pyshell#41>", line 1, in
int("456abc")
ValueError: invalid literal for int() with base 10: '456abc'
int("456.78")
Traceback (most recent call last):
File "<pyshell#42>", line 1, in
int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'

自动转型：
整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0的结果是10.0

整数可以有多大？
Python2中，int是32位，可以存储从-2147483648到2147483647的整数（约±21亿）。Long类型是64位，可以存储：-2^63--263-1之间的数值。
Python3中，int可以存储任意大小的整数，long被取消。我们甚至可以存储下面的值：

googol = 10**100
googol
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Googol也是Google最初的名字，这也是Google最初的含义。

Python3中可以做超大数的计算，而不会造成“整数溢出”，这也是Python特别适合科学运算的特点。

浮点数

浮点数，称为float。
浮点数用形式的科学计数法表示。比如：3.14，表示成：314E-2或者314e-2。
这些数字在内存中也是按照科学计数法存储。

类型转换和四舍五入

1. 类似于int()，我们也可以使用float()将其他类型转化成浮点数。
2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0的结果是10.0
3. round(value)可以返回四舍五入的值
   注：但不会改变原有值，而是产生新的值

增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。
a = a + 1 等价于： a +=1

增强型赋值运算符

运算符	例子	等价
+=	a += 2	a = a + 2
-=	a -= 2	a = a-2
*=	a *= 2	a = a * 2
/=	a /= 2	a = a / 2
//=	a //= 2	a = a//2
**=	a **= 2	a = a**2
%=	a %= 2	a = a % 2

注意：“+=”中间不能加空格！

时间的表示

计算机中时间的表示是从“1970年1月1日 00:00:00”开始，以毫秒（1/1000秒）进行计算。我们也把1970年这个时刻成为“unix时间点”。
这样，我们就把时间全部用数字来表示了。

python中可以通过time.time() 获得当前时刻，返回的值是以秒为单位，带微秒（1/1000毫秒）精度的浮点值。例如：1530167364.8566。

import time
b = int(time.time())
b
1530168754
totalMinutes = b/60
totalMinutes
25502812.566666666
totalMinutes = b//60
totalMinutes
25502812
totalHours = totalMinutes//60
totalHours
425046
totalDays = totalHours//24
totalDays
17710
totalYears = totalDays//365
totalYears
48

【操作】定义多点坐标_绘出折线_并计算起始点和终点距离
源码

点击查看代码

import turtle
import math
 
#定义多个点的坐标
x1,y1 = 100,100
x2,y2 = 100,-100
x3,y3 = -100,-100
x4,y4 = -100,100
 
#绘制折线
turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)
 
#计算起始点和终点的距离
distance = math.sqrt((x1-x4)**2 + (y1-y4)**2)
turtle.write(distance)

运行结果：

布尔值

Python2中没有布尔值，直接用数字0表示False,用数字1表示True。
Python3中，把True和False定义成了关键字，但他们的本质还是1和0，甚至可以和数字相加。

a = True
b = 3
a+b
4

比较运算符

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。
以下假设变量a为15，变量b为30：

运算符	描述	实例
==	等于 - 比较对象的值是否相等	(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。

逻辑运算符

运算符	格式	说明
or逻辑或	x or y	x为true，则不计算y，直接返回true x为false，则返回y｜
and 逻辑与	x and y	x 为 true，则返回 y 的值。 x 为false,则不计算 y，直接返回 false｜
not逻辑非	not x	x为true，返回false。x为false，返回true

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

运算符	描述
is	is是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
== 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。

整数缓存问题

Python仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在Pycharm或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。
·总结
1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2、== 比较的是两个对象的内容是否相等，值是否相等；
3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；
4、is 运算符比 == 效率高，在变量和None进行比较时，应该使用 is。

【操作】同一运算符测试

a = 1000
b = 1000
a == b
True
a is b
False
id(a)
46764560
id(b)
46765216
c = 10
d = 10
c is d
True
id(c)
1388831648
id(d)
1388831648

基本运算符

我们在前面讲解了“+”、“-”、“*”、“/”、“//”、“%”等运算符，这里我们继续讲解一些其他运算符，并进行学习和测试。

运算符	说明
and , or , not	布尔与、布尔或、布尔非
is , is not	同一性判断，判断是否为同一个对象
<,<=,>,>=,!=,==	比较值是否相当，可以连用
｜ ^ &	按位或，按位异或、按位与
<<, >>	移位
~	按位翻转
+,-,*,/,//,%	加，减，乘，浮点除、整数除、取余
**	幂运算

1.比较运算符可以连用，并且含义和我们日常使用完全一致。

a = 4
3<a<10 #关系运算符可以连用
True

2.位操作

a = 0b11001
b = 0b01000
c = a|b
bin(c) #bin()可以将数字转成二进制表示
'0b11001'
bin(c&b)
'0b1000'
bin(c^b)
'0b10001'
a = 3
a<<2 #左移1位相当于乘以2.左移2位，相当于乘以4
12
a = 8
a>>1 #右移1位相当于除以2.

3.加法操作
(1)数字相加 3+2 > 5
(2)字符串拼接 “3”+“2”> “32”
(3)列表、元组等合并 [10,20,30]+[5,10,100] ==>[10,20,30,5,10,100]
4.乘法操作
(1)数字相乘 32 ==> 6
(2)字符串复制 “sxt”3 ==> ”sxtsxtsxt”
(3)列表、元组等复制 [10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

运算符	描述	示例	等价于
+=	加法赋值 字符串拼接	sum += n a += “sxt”	sum = sum + n a = a + “sxt”
-=	减法赋值	num1 -= n	num = num - n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a/=b	a = a / b
//=	整数除赋值	a//=b	a = a//b
%=	取余赋值	a%=b	a = a % b
**=	幂运算赋值	a**=2	a = a**2
<<=	左移赋值	a<<=2	a = a<<2
>>=	右移赋值	a>>=2	a = a>>2
&=	按位与赋值	a&=b	a = a&b
｜=	按位或赋值	a	=b
^=	按位异或赋值	a^=b	a = a^b

注：与C和JAVA不一样，Python不支持自增(++)和自减(--)

运算符优先级问题

如下优先级，从高到低。

运算符	描述
**	指数 (最高优先级)
~	按位翻转
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ ｜	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。
1.乘除优先加减
2.位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

【操作】使用python表示数学式：