如果对您有一丁点的帮助，劳烦动动手指点个赞，您的支持和鼓励是搬砖人不断创作的动力！
1.对象
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'>
示意图：
2.引用
在Python中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。
变量通过地址引用了“对象”。
变量位于：栈内存（压栈出栈等细节，后续再介绍）。
对象位于：堆内存。
·Python是动态类型语言
变量不需要显式声明类型。根据变量引用的对象，Python解释器自动确定数据类型。
·Python是强类型语言
每个对象都有数据类型，只支持该类型支持的操作。
3.标识符
基本用法
标识符：用于变量、函数、类、模块等的名称。 标识符有如下特定的规则：
1 .区分大小写。如：sxt和SXT是不同的
2 .第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
3 .不能使用关键字。比如：if、or、while等。
4 .以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类
的构造函数。
【操作】使用Python帮助系统查看关键字
>>>help()
>>>help>keywords
>>>False def if raise
>>>None del import return
>>>True elif in try
>>>and else is while
>>>as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass
注：无需刻意去背关键字，后面都会学习。
Python标识符命名规则
开发中，我们通常约定俗称遵守如下规则：
| 类型 | 规则 | 例子 |
|---|---|---|
| 模块和包名 | 全小写字母，尽量简单。若多个单词之间用下划线 | math,os,sys |
| 函数名 | 全小写字母，多个单词之间用下划线隔开 | phone,my_name |
| 类名 | 首字母大写，采用驼峰原则。多个单词时，每个单词第一个字母大写，其余部分小写 | MyPhone、MyClass、Phone |
| 常量名 | 全大写字母，多个单词使用下划线隔开 | SPEED、MAX_SPEED |
4.变量和简单赋值语句
变量的声明和赋值
变量的声明和赋值用于将一个变量绑定到一个对象上，格式如下：
变量名 = 表达式
最简单的表达式就是字面量。比如：a= 123 。运行过程中，解释器先运行右边的表达式，
生成一个代表表达式运算结果的对象；然后，将这个对象地址赋值给左边的变量。
【操作】 变量在使用前必须先被初始化（先被赋值）
>>>my_name
>>>Traceback(mostrecentcalllast):
>>>File"<pyshell# 17 >",line 1 ,in<module>
>>>my_name
>>>NameError:name'my_name'isnotdefined
变量my_name在被使用前未做赋值，因此报错：’my_name’is not defined。
删除变量和垃圾回收机制
可以通过del语句删除不在使用的变量。
【操作 55 】删除变量示例
>>>a= 123
>>>dela
>>>x
>>>Traceback(mostrecentcalllast):
>>>File"<pyshell# 20 >",line 1 ,in<module>
>>>x
>>>NameError:name'x'isnotdefined
如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。
链式赋值
链式赋值用于同一个对象赋值给多个变量。
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)
>>>21
常量
Python不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规
则，以及在程序的逻辑上不对常量的值作出修改。
>>>MAX_SPEED= 120
>>>print(MAX_SPEED)
>>>120
>>>MAX_SPEED= 140 #实际是可以改的。只能逻辑上不做修改。
>>>print(MAX_SPEED)
>>>140
5.最基本内置数据类型和运算符
每个对象都有类型，python中最基本的内置数据类型：
1 .整型
整数， 2345 , 10 , 50
2 .浮点型
小数， 3. 14 或者科学计数法 314 e- 2
3 .布尔型
表示真假，仅包含：True、False
4 .字符串型
由字符组成的序列。 “abc”,”sxt”,“Python学堂”,”码农翻身”
数字和基本运算符
Python支持整数(如： 50 , 520 )和浮点数(如： 3. 14 , 10. 0 , 1. 23 e 2 )，我们可以对数字做如下
运算。
| 运算符 | 说明 | 示例 | 结果 |
|---|---|---|---|
| + | 加法 | 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(mostrecentcalllast):
File"<pyshell# 37 >",line 1 ,in<module>
3 / 0
ZeroDivisionError:divisionbyzero
>>>divmod( 10 , 5 )
( 2 , 0 )
>>>divmod( 10 , 3 )
( 3 , 1 )
除数为 0 ，会产生异常：
>>> 3 / 0
Traceback(mostrecentcalllast):
File"<pyshell# 31 >",line 1 ,in<module>
3 / 0
ZeroDivisionError:divisionbyzero
使用divmod()函数同时得到商和余数：
>>>divmod( 13 , 3 )
>>>( 4 , 1 )
divmod()是一个函数，我们以后会详细介绍。他返回的是一个元组(后续将会学习)。
整数
Python中，除 10 进制，还有其他三种进制：
· 0 b或 0 B，二进制 0 1
· 0 o或 0 O，八进制 0 1 2 3 4 5 6 7
· 0 x或 0 X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f
这三种进制可以非常方便的进行“位运算”操作。位运算知识后续将会介绍。
【操作】测试不同进制
>>> 12
>>> 12
>>> 0 b 101
>>> 5
>>> 0 o 19
>>> SyntaxError:invalidsyntax
>>> 0 o 10
>>> 8
>>> 0 xff
>>> 255
>>> 0 xf
>>> 15
>>> 0 x 10
>>> 16
使用int()实现类型转换：
1 .浮点数直接舍去小数部分。如：int( 9. 9 )结果是： 9
2 .布尔值True转为 1 ，False转为 0 。 如：int(True)结果是 1
3 .字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。
>>>int(" 456 ")
>>>456
>>>int(" 456 abc")
>>>Traceback(mostrecentcalllast):
>>>File"<pyshell# 41 >",line 1 ,in<module>
>>>int(" 456 abc")
>>>ValueError:invalidliteralforint()withbase 10 :' 456 abc'
>>>int(" 456. 78 ")
>>>Traceback(mostrecentcalllast):
>>>File"<pyshell# 42 >",line 1 ,in<module>
int(" 456. 78 ")
ValueError:invalidliteralforint()withbase 10 :' 456. 78 '
>>>
自动转型：
整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如： 2 + 8. 0 的结果是 10. 0
整数可以有多大？
Python 2 中，int是 32 位，可以存储从- 2147483648 到 2147483647 的整数（约±
21 亿）。Long类型是 64 位，可以存储：- 2 ^ 63 - - 2 ^ 63 - 1 之间的数值。
Python 3 中，int可以存储任意大小的整数，long被取消。我们甚至可以存储下面的
值：
>>>googol= 10 ** 100
>>>googol
>>>1000000000000000000000000000000000000000000000000
>>>0000000000000000000000000000000000000000000000000
>>>000
Googol也是Google最初的名字，这也是Google最初的含义。
Python 3 中可以做超大数的计算，而不会造成“整数溢出”，这也是Python特别适
合科学运算的特点。
浮点数
浮点数，称为float。
浮点数用
a * b^10
形式的科学计数法表示。比如： 3. 14 ，表示成： 314 E- 2 或者 314 e- 2 。
这些数字在内存中也是按照科学计数法存储。
类型转换和四舍五入
- 类似于int()，我们也可以使用float()将其他类型转化成浮点数。
- 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如： 2 + 8. 0 的结果是 10. 0
- 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 。
>>>importtime
>>>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
【操作】定义多点坐标_绘出折线_并计算起始点和终点距离
源码
importturtle
importmath
#定义多个点的坐标
x 1 ,y 1 = 100 , 100
x 2 ,y 2 = 100 ,- 100
x 3 ,y 3 =- 100 ,- 100
x 4 ,y 4 =- 100 , 100
#绘制折线
turtle.penup()
turtle.goto(x 1 ,y 1 )
turtle.pendown()
turtle.goto(x 2 ,y 2 )
turtle.goto(x 3 ,y 3 )
turtle.goto(x 4 ,y 4 )
#计算起始点和终点的距离
distance=math.sqrt((x 1 - x 4 )** 2 +(y 1 - y 4 )** 2 )
turtle.write(distance)
运行结果：
布尔值
Python 2 中没有布尔值，直接用数字 0 表示False,用数字 1 表示True。
Python 3 中，把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
>>>aisb
False
>>>id(a)
46764560
>>>id(b)
46765216
>>>c= 10
>>>d= 10
>>>cisd
True
>>>id(c)
1388831648
>>>id(d)
1388831648
基本运算符
我们在前面讲解了“+”、“-”、“*”、“/”、“//”、“%”等运算符，这里我们继续
讲解一些其他运算符，并进行学习和测试。
| 运算符 | 说明 |
|---|---|
| and, or , not | 布尔与、布尔或、布尔非 |
| is , is not | 同一性判断，判断是否为同一个对象 |
| <,<=,>,>=,!=,== | 比较值是否相当，可以连用 |
| | ^ & | 按位或，按位异或、按位与 |
| <<,>> | 移位 |
| ~ | 按位翻转 |
| +,-,*,/,//,% | 加，减，乘，浮点除、整数除、取余 |
| ** | 幂运算 |
1 .比较运算符可以连用，并且含义和我们日常使用完全一致。
>>>a= 4
>>> 3 <a< 10 #关系运算符可以连用
True
2 .位操作
>>>a= 0 b 11001
>>>b= 0 b 01000
>>>c=a|b
>>>bin(c) #bin()可以将数字转成二进制表示
' 0 b 11001 '
>>>bin(c&b)
' 0 b 1000 '
>>>bin(c^b)
' 0 b 10001 '
>>>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 ) 数字相乘 3 * 2 ==> 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=a|b |
| ^= | 按位异或赋值 | a^=b | a=a^=b |
注：与C和JAVA不一样，Python不支持自增(++)和自减(–)
运算符优先级问题
如下优先级，从高到低。
| 运算符 | 描述 |
|---|---|
| ** | 指数(最高优先级) |
| ~ | 按位翻转 |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位’AND’ |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。
1 .乘除优先加减
2 .位运算和算术运算>比较运算符>赋值运算符>逻辑运算符
欢迎扫描微信添加，技术交流+资源分享
ID: Txtechcom
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
