Python基础知识：对象模型、变量、数字、运算符、内置函数、模块

Python对象模型

在Python中处理的一切都是对象，对象包括内置对象和非内置对象。

内置对象（数字、字符串、列表、内置函数等）可以直接使用，非内置对象（正弦函数、随机数生成函数等）需要导入模块才能使用。

以下为Python中部分常见的内置对象。

对象类型	类型名称	示例	说明
数字	int、float、complex	123、3.14、3+4j	数字大小没有限制，支持整型、浮点型、复数的表示
字符串	str	‘abcd’、r"abc"	使用单引号、双引号、三引号作为界定符，
列表	list	[1,2,3]	放在一对方括号中，元素可以是任意类型
字典	dict	{1:‘apple’, 2:‘boy’, 3:‘dog’}	放在一对大括号中，元素形式为“键:值”
元组	tuple	(1,2,3)、(1,)	放在一对括号中，元素不可变，只有一个元素的话后面的逗号不能省略
集合	set、frozenset	{1,2,3}	放在一对大括号中，元素不允许重复，set可变，frozenset不可变

另外，函数（使用def定义）、类（使用class定义）、模块（类型为module）等变成单元也是Python的内置对象。

Python变量

Python属于强类型和动态类型的编程语言，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量，解释器会根据赋值或运算来自动推断变量类型，变量的类型也是可以随时变化的。

>>> x=123
>>> print(type(x))
<class 'int'>
>>> x="abc"
>>> print(type(x))
<class 'str'>
>>> x=[1,2,3]
>>> print(type(x))
<class 'list'>

Python采用基于值内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只保存一份，多个变量指向同一个值的内存空间首地址，提高内存利用率。

具体表现为：

1. 如果多个变量的整数值相等且介于[-5, 256]区间内，那么这些变量共用同一个值的内存空间；

2. 区间[-5, 256]之外的整数，同一个程序中或交互模式下同一个语句中的同值、不同名变量会共用同一个内存空间，不同程序或交互模式下不同语句不遵守上条约定。

# 多个变量相等且介于[-5,256]区间
>>> a=1
>>> b=1
>>> id(a)==id(b)
True

# 区间[-5, 256]之外的整数在不同语句
>>> c=1234
>>> d=1234
>>> id(c)==id(d)
False

# 区间[-5, 256]之外的整数在相同语句
>>> e,f=300,300
>>> id(e)==id(f)
True

Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。Python中有自动管理内存功能，会跟踪所有的值，并自动删除不再使用或者引用次数为0的值。

数字

Python中的数字类型可以表示任意大的数值，数值类型主要有整数、浮点数和复数。

整数类型中包括十进制整数、二进制整数（以0b开头表示）、八进制整数（以0o开头表示）、十六进制整数（以0x开头表示）。

浮点数即小数，如 .5、2.0、3.14、2e2、3e-4 等。

复数由实部和虚部构成，使用 j 或 J 表示虚部，如 1+2j、1j、-2j 等。

>>> a=1+2j
>>> a.real        #查看实部
1.0
>>> a.imag        #查看虚部
2.0
>>> a.conjugate() #返回共轭复数
(1-2j)

Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性。

>>> x=1_000_000
>>> print(x)
1000000
>>> y=12_3.4_5
>>> print(y)
123.45

常见运算符

1. 算术运算符

运算符	说明
+	算术加法，列表、元组、字符串合并
-	算术减法，集合差集
*	算数乘法，序列重复
/	真除
//	整除，向下取整
%	求余数，字符串格式化
**	幂运算

# +运算符
>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> "abc"+"def"
'abcdef'

# *运算符
>>> "x"*10
'xxxxxxxxxx'
>>> (1,2,3)*2
(1, 2, 3, 1, 2, 3)

2. 赋值运算符

运算符	说明
=	赋值
:=	海象运算符，可在表达式内部为变量赋值
+=、-=、*= …	运算后进行赋值，Python不支持++和–运算符

>>> i=1
>>> i++    #语法错误
SyntaxError: incomplete input
>>> ++i    #等同于+(+3)，正正得正
1
>>> i--    #语法错误
SyntaxError: incomplete input
>>> --i    #等同于-(-3)，负负得正
1

3. 逻辑运算符

运算符	表达式
and	逻辑与
or	逻辑或
not	逻辑非

4. 测试运算符

运算符	表达式
in、not in	成员测试，表达式x in y的值当且仅当y中包含元素x时才会为True
is、is not	对象实体同一性测试，测试两个对象是否为同一个对象的引用

# 成员测试
>>> 1 in [1,2,3]
True
>>> 'a' in {1:'a', 2:'b'}
False
>>> "abc" in "abcdefg"
True

# 对象实体同一性测试
>>> 1 is 1
True
>>> x=[1000,1000]
>>> x[0] is x[1]
True
>>> a={1,2}
>>> b={1,2}
>>> a is b
False

除了上述运算符以外，还有常见的位运算符、集合运算符、比较运算符等等。

部分内置函数

函数	说明
all(iterable, /)	如果可迭代对象中所有元素都等价于True则返回True，否则返回False
any(iterable, /)	只要可迭代对象iterable中存在等价于True的元素就返回True，否则返回False
dir(obj)	返回指定对象或模块obj的成员列表，如果不带参数则返回包含当前作用域内所有可用对象名字的列表
enumerate(iterable, start=0)	枚举可迭代对象iterable中的元素，返回包含元素形式为(start, iterable[0]), (start+1, iterable[1]), (start+2, iterable[2]), …的迭代器对象，start表示编号的起始值，默认为0
filter(function or None, iterable)	使用function函数描述的规则对iterable中的元素进行过滤，返回filter对象，其中包含序列iterable中使得函数function返回值等价于True的那些元素
help(obj)	返回对象obj的帮助信息
input(prompt=None, /)	输出参数prompt的内容作为提示信息，接收键盘输入的内容，以字符串形式返回
len(obj, /)	返回可迭代对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象，不适用于具有惰性求值特点的生成器对象和map、zip等迭代器对象
map(func, *iterables)	返回包含若干函数值的map对象，函数func的参数分别来自于iterables指定的一个或多个迭代对象。
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)	基本输出函数，可以输出一个或多个值，sep参数表示相邻数据之间的分隔符，end参数用来指定输出完所有值后的结束符
range([start ,] stop [, step])	返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,stop)内以step为步长的整数，start默认为0，step默认为1
zip(*iterables)	组合多个可迭代对象中对应位置上的元素，返回zip对象，其中每个元素为(seq1[i], seq2[i], …)形式的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个

注：表中函数参数的斜线表示该位置之前的所有参数必须为位置参数，形参前面加一个星号表示可以接收任意多个按位置传递的实参。

函数调用时的两种参数：

• 位置参数：调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。

• 关键字参数：调用函数的时候使用的是键值对的方式，key=values。

# 用range()函数产生数字1~10，并用列表输出
>>> list(range(1,10))
[1,2,3,4,5,6,7,8,9,10]

# 使用filter()函数过滤出奇数
>>> def checkOdd(x):
    if(x%2==1):
        return true;
    else:
        return False;

>>> L=[12,5,8,7,21,16,51]
>>> list(filter(checkOdd,L))
[5,7,21,51]

# 演示zip()函数的作用
>>> list(zip('ABCD','abcdefg','12345'))
[('A', 'a', '1'), ('B', 'b', '2'), ('C', 'c', '3'), ('D', 'd', '4')]

# 使用enumerate()函数枚举’abcd‘的值
>>> list(enumerate('abcd'))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

模块的导入

在Python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。可以使用import sys,sys.modules.items()显示所有预加载模块的相关信息。

1. import 模块名 [as 别名]

# 产生10个1-10之间的随机数
>>> import random
>>> L=[random.randint(1,100) for i in range(10)]
>>> print(L)
[38, 45, 48, 21, 19, 86, 11, 92, 55, 99]

导入模块后就可以使用模块中的类、函数、对象等，不过在使用时要加上“ 模块名.”这个前缀。

2. from 模块名 import 对象名 [as 别名]

# 求正弦值
>>> from math import sin
>>> sin(1)
0.8414709848078965

使用这种方法可以减少查询次数，提高访问速度，不需要使用模块名作为前缀。

Python概念层级

1. 表达式：创建、处理对象

2. 语句：包含表达式（赋值、模块、条件判断语句等）

3. 逻辑单元：函数或者类，由语句构成

4. 模块：.py代码文件组成模块

5. 包：定义一组有关系的文件，或者模块（包是文件夹，模块是其中的文件，且文件夹中包含一个_init_.py文件）

6. 程序：若干个包+若干个文件