Python 编程基础概念

声明：本文作为自己的学习笔记，欢迎大家于本人学习交流，转载请注明出处
本文参考

尚学堂 Python 400 集

如果本文有侵犯您的知识产权和版权问题，请通知本人，本人会立即做出处理并删除文章

电子邮件：louhergetup@163.com >

代码测试所用版本： Python 3.8.2

1 Python程序的构成

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

1.1 使用\行连接符

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

【操作】

2 对象

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

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

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

【操作】

>>> a=3
>>> a
3
>>> id(3)
140725773457120
>>> type(3)
<class 'int'>
>>> id(a)
140725773457120
>>> type(a)
<class 'int'>
>>> print(a)
3
>>> b="我爱你"
>>> id(b)
2317423148944
>>> type(b)
<class 'str'>
>>> print(b)
我爱你
>>> 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3 引用

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

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

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

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

4 标识符

标识符：用于变量、函数、类、模块等的名称。 标识符有如下特定的规则：

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

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

>>> help()
>help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not                 
help> quit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.1 Python标识符命名规则

5 变量和简单赋值语句

5.1 变量的声明和赋值

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

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

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

>>> my_name
Traceback (most recent call last):
  File "", line 1, in <module>
    my_name
NameError: name 'my_name' is not defined
1
2
3
4
5

5.2 删除变量和垃圾回收机制

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

>>> a=123
>>> del a
>>> a
Traceback (most recent call last):
  File "", line 1, in <module>
    a
NameError: name 'a' is not defined
1
2
3
4
5
6
7

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

5.3 链式赋值

链式赋值用于同一个对象赋值给多个变量。

x=y=123  #相当于：x=123; y=123 （x，y 都指向123）
1

5.4 系列解包赋值

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

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

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

>>> a,b=10,20
>>> a
10
>>> a,b=b,a
>>> a
20
>>> print(a,b)
20 10
1
2
3
4
5
6
7
8

5.5 常量

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

>>> MAX_SPEED = 120
>>> print(MAX_SPEED)
120
>>> MAX_SPEED = 140   #实际是可以改的。只能逻辑上不做修改。
>>> print(MAX_SPEED)
140
1
2
3
4
5
6

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

每个对象都有类型，python中最基本的内置数据类型：

1. 整型
   整数，2345,10,50
2. 浮点型
   小数，3.14或者科学计数法314e-2
3. 布尔型
   表示真假，仅包含：True、False
4. 字符串型
   由字符组成的序列。 “abc”

6.1 基本运算符

【操作】使用divmod()函数同时得到商和余数：

>>> divmod(10,5)
(2, 0)
1
2

6.2 整数

Python中，除10进制，还有其他三种进制：

1. 0b或0B，二进制 0 1
2. 0o或0O，八进制 0 1 2 3 4 5 6 7
3. 0x或0X，十六进制0 1 2 3 4 5 6 7 8 9 a b c d e f

【操作】测试不同进制

>>> 0B101
5
>>> 0o10
8
>>> 0o9
SyntaxError: invalid digit '9' in octal literal
>>> 0xf
15
>>> 0x255
597
>>> 0xff
255
1
2
3
4
5
6
7
8
9
10
11
12

使用int()实现类型转换：

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

【操作】测试int()实现类型转换

>>> int(3.14)
3
>>> int(3.9)
3
>>> int(True)
1
>>> int(False)
0
>>> int(23456)
23456
>>> int("23456")
23456
>>> int("23456abc")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("23456abc")
ValueError: invalid literal for int() with base 10: '23456abc'
>>> int("456.78")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

>>> a = 3 +4.1
>>> a
7.1
>>> type(a)
<class 'float'>
1
2
3
4
5

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

>>> googol = 10**100
>>> googol
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
1
2
3

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

6.3 浮点数

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

6.4 类型转换和四舍五入

1. 类似于int()，我们也可以使用float()将其他类型转化成浮点数。
2. round(value)可以返回四舍五入的值
   注：但不会改变原有值(对象)，而是产生新的值(对象)

>>> float(3)       #不会改变原有值(对象)，而是产生新的值(对象)
3.0
>>> float("3.14")
3.14
>>> int(3.94)      #不会改变原有值(对象)，而是产生新的值(对象)
3
>>> round(3.54)    #不会改变原有值(对象)，而是产生新的值(对象)
4
>>> round(3.14)
3
>>> round(4.5)     #注意，奇入偶不入
4
1
2
3
4
5
6
7
8
9
10
11
12

6.5 增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。
a = a + 1 等价于： a +=1
注：但不会改变原有值(对象)，而是产生新的值(对象)，原有值(对象)被垃圾回收机制回收

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

6.6 时间的表示

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

python中可以通过time.time() 获得当前时刻，返回的值是以秒为单位，带微秒（1/1000毫秒）精度的浮点值。
【操作】时间测试

>>> import time
>>> a = int(time.time())
>>> a
1649681519
>>> totalMinutes=a//60
>>> totalMinutes
27494691
>>> totalHours = totalMinutes//60
>>> totalHours
458244
>>> totalDays = totalHours//24
>>> totalDays
19093
>>> totalYears = totalDays//365
>>> totalYears
52

# 浮点整除之后还是浮点
>>> b = time.time()
>>> b
1649682427.537643
>>> totalMinutes=b//60
>>> totalMinutes
27494707.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果

6.7 布尔值

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

>>> a = True
>>> b = 3
>>> a+b
4
1
2
3
4

6.8 比较运算符

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

6.9 逻辑运算符

【操作】测试逻辑运算符

>>> a = True
>>> b= False
>>> a or 30
True
>>> b or 30
30
>>> a or 30/0
True
>>> a and 30
30
>>> b and 30
False
>>> not a
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6.10 同一运算符

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

is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个，即比较对象的地址。
== 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。
【操作】测试同一运算符

>>> a=1000
>>> b=1000
>>> a==b
True
>>> a is b
False
>>> id(a)
1470855474032
>>> id(b)
1470856284720
1
2
3
4
5
6
7
8
9
10

6.11 整数缓存问题

Python仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在Pycharm或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。
【操作】测试整数缓存问题

>>> c=10
>>> d=10
>>> c is d
True
>>> id(c)
140726384842688
>>> id(d)
140726384842688
1
2
3
4
5
6
7
8

文件中测试

a = -6
b = -6
print(a is b)

a = -5
b = -5
print(a is b)

a = 10000000000000000001
b = 10000000000000000001
print(a is b)

1
2
3
4
5
6
7
8
9
10
11
12

运行结果

True #与高淇老师测试结果不同，老师是False
True
True
1
2
3

注意

1. is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2. == 比较的是两个对象的内容是否相等，值是否相等；
3. 小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；
4. is 运算符比 == 效率高，在变量和None进行比较时，应该使用 is。
   【操作】文件中测试 is 和 == 区别

x = y = [4,5,6]
z = [4,5,6]
print(x==y)
print(x is y)
print(x==z)
print(x is z)
print(id(x))
print(id(y))
print(id(z))
1
2
3
4
5
6
7
8
9

运行结果

True
True
True
False
2119646246336
2119646246336
2119607451328
1
2
3
4
5
6
7

6.12 其他运算符

【操作】测试

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

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

2. 位操作

>>> a = 0b11001
>>> b = 0b01000
>>> a
25
>>> b
8
>>> c = a|b    #或，位都为0则为0 ，否则为1
>>> c
25
>>> bin(c)     #bin()可以将数字转成二进制表示
'0b11001'
>>> bin(a&b)   #与，位都为1则为1 ，否则为0
'0b1000'
>>> bin(a^b)   #异或，位相同为0，不同为1
'0b10001
>>> a = 3
>>> a<<2     #左移1位相当于乘以2.左移2位，相当于乘以4
12
>>> a = 8
>>> a>>1      #右移1位相当于除以2.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 加法操作

>>> [10,20,30]+[5,10,100]    #类似于字符串拼接
[10, 20, 30, 5, 10, 100]
1
2

4. 乘法操作

>>> [10,20,30]*3    #类似于字符串复制，乘法本质上就是复制
[10, 20, 30, 10, 20, 30, 10, 20, 30]
1
2

6.13 复合赋值运算符

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

6.14 运算符优先级问题

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符