Python 中的数据类型

数字

整数 int

第 1 行使用 import 语句导入了 math 模块
第 2 行调用了 math 模块中的 factorial 函数，用于求阶乘。"math. " 这种调用方式称为点语法
第 3 行计算了一个十进制数转为字符串之后的长度，即这个整数的位数。str 函数将数值转变为字符串，len 函数获取字符串的长度

Python 中可以用 0b 或 0B 为前缀表示二进制数，以 0o，0x 为前缀分别表示八进制、十六进制数

对于较大整数，Python 支持用下划线分隔数的表示方法

使用 type 函数，以变量名或值为参数可以获得其类型

使用 id 函数，可获得其多对应的内存地址

浮点数 float

Python 中可表示的浮点数的范围是有限的，这个范围受制于操作系统的字长。当计算的结果超出 float 所能表示的最大范围时，程序会报告 OverflowError ，即溢出错误。
不要用 “==” 测试两个浮点数是否相等

复数 complex

Python 支持负数的表示和计算：a + bj

可以使用 complex 函数组合实部和虚部得到复数，通过 real 属性和 imag 属性获得复数的实部和虚部

布尔值 True, False

布尔型变量总共包含两个，即 True 和 False，分别表示真、假

不同布尔值之间可以进行逻辑运算，Python 中用 not、and 和 or 表示非运算、与运算和或运算

空值 None

空值 None 是 Python里一个特殊的值，表示空或没有，也是类型 NoneType 的唯一值

None 并不等同于 0 或者空的字符串" "

字符串

字符串的运算（+，*）和成员检查（in，not）

Python 支持字符串的 + 和 * 运算，+ 运算表示连接两个字符串，而 * 运算表示将字符串延展若干倍

in、not in 进行成员检查

len、max 和 min 函数

• len 函数：获取字符串的长度
• 字符串可以比较大小
• max：返回字符串中的最大字符
• min：返回最小字符

对字符串元素的索引

使用 s1[ index ] 方式可以索引字符串中的元素：

• 索引是整数类型，可以是整数数字，也可以是整数类型的变量
• 索引的起点是 0，字符串最左侧元素为 s1[0]，最右侧索引为“字符串的长度减一”，即 len(s1) - 1
• 索引可以是负整数，s[-1] 表示最右侧元素

字符串是“不可变的”，其中的元素只能读取，不能修改

Python 中可变和不可变

• 不可变是指变量的内容不可修改，可变是指变量的内容可以修改
• 所有的简单变量、字符串、元组等都是不可变的，列表、字典是可变的

对字符串元素的切片

语法格式：s[ start: end: step ]

• s 为字符串的变量名，start 表示切片的起始位置，end 表示切片的截至位置，step 表示切片的步长，如果省略，默认为 1
• 当 step 为正值时，如果 start 省略，表示从最左侧开始；如果 end 省略，表示到最右侧结束
• 当 step 为负值时，切片由右向左进行，如果 start 省略，表示从最右侧开始；如果 end 省略，表示从最左侧结束
• 切片的结果中包含 start所在位置的元素但不包含end 所在位置的元素

step 省略时，默认为 1：

step 不为 1 时：

对字符串进行遍历

将字符串 s1 的每个元素打印输出，中间用逗号隔开
方法一：

方法二：直接遍历（建议使用）

字符串方法

• upper 一般称为方法，而不称为函数，因为 upper 方法属于 str 类
• 方法的调用使用点语法，即“对象.方法()”的形式，可以把对象理解为操作的主语，方法理解为操作的行为，即谓语
• 由于字符串是不可变对象，调用 s1.upper() 并不会修改 s1 的值，而是返回了一个新值
• upper 方法返回调用对象的大写表示
• lower 方法返回调用对象的小写表示
• capitalize 方法返回调用对象的首字母大写其余小写表示

联合 join 和分割 split 方法

join 方法通过连接符将多个字符串拼接为一个整体
split 方法将一个字符串拆解为多个单体

列表

认识列表

• 列表是可变类型，它可以存储各种类型的元素
• 由 [] 封装若干个元素，元素之间用逗号分割，这些元素可以是整数、浮点数、字符串、其他列表、其他结构的对象

列表是一种有序序列：

• 列表中的元素可以用整数值进行索引，索引的起点是 0
• 列表的切片访问方式和字符串相同，基本特征是左闭右开
• 列表适用 +，+= 运算符，表示列表对象的连接
• 列表适用 *，*= 运算符，表示列表对象的延展
• 列表是可迭代对象，可以使用 for 循环遍历列表对象
• 列表可以比较，方式和字符串的比较类似，逐个元素进行比较

创建列表，主要有以下两种方式：
一是描述法，即直接用定界符 [] 把若干元素封装起来

li1 = []
li2 = [1,2,4]

二是构造函数法，即使用 list 函数将其他类型对象转换为列表

li3 = list()
li4 = list("apple")
li5 = list(range(5))

作为可变对象的列表

列表作为可变类型，其元素可以修改

列表的运算和成员检查

列表支持 +、+=、*、*= 操作，分别表示连接和延展
列表支持 in、not in 成员检查

列表的增操作

• append 方法，可在列表的末尾添加 1 个元素
• insert 方法，可在列表的指定位置添加 1 个元素
• extend 方法，可以把一个列表的元素合并到当前列表的尾部

append 方法通常以元素为参数，而 extend 方法通常以列表为参数，但 extend 方法扩展的是列表中的元素。对于 append 方法，如果以列表为参数，是把参数作为整体添加到调用者之后

列表的删操作

• remove 方法，可删除列表中指定的值，当存在多个值时，只删除第一个，当要删除的值不存在时报错
• pop 方法，可删除指定位置的元素，参数为 index。没有参数时，默认删除最后一个元素
• clear 方法，可清除列表中的所有对象，使变量变为空的列表，无参数
• 使用 del 语句删除指定的元素或者整个列表

列表的改操作

• 修改列表，通过索引的方法定位元素，然后重新赋值
  冒泡排序法：

def bubbleSort(li):
	length = len(li)
	for i in range(0, length - 1):
		for j in range(0, length - 1 -i):
			if li[j] > li[j+1]:
				li[j], li[j+1] = li[j+1], li[j]

改进：加入判断排序是否已完成的标志位，一旦为 True，退出函数

def bubbleSort(li):
	length = len(li)
	for i in range(0, length - 1):
		Swap = False
		for j in range(0, length - 1 -i):
			if li[j] > li[j+1]:
				li[j], li[j+1] = li[j+1], li[j]
				Swap = True
			if not Swap:
				return -1

列表的方法

• count 方法可以获取指定元素出现的次数
• index 方法可以获取指定元素首次出现的位置
• sort 方法对列表进行排序，操作完成之后，列表本身被修改。若要保持原列表不变，同时得到排序完成之后的新列表，可以使用 sorted 函数

遍历列表

方式一：使用 len 函数和 range 函数

a = [1,6,2,5]
for i in range(len(a)):
	print(a[i])

方式二：

for i in a:
	print(i)

列表的复制

赋值操作不执行内存拷贝，仅贴标签：

切片方式 [:] 实施浅层次拷贝：


列表的 copy 方法执行浅拷贝：

copy.copy 函数执行浅拷贝
copy.deepcopy 函数执行深拷贝

• 在深拷贝模式下，原先的列表以及其中的子列表被连根拔起，完全复制，后续再次修改原列表时，对拷贝得到的列表并无影响
• 浅拷贝只拷贝列表内部的简单对象，对于列表内部的结构依然采用引用方式，节省内存开销。而深拷贝将原对象全部拷贝，深拷贝转换后的对象和原对象毫无关联
• 赋值模式下为贴标签，copy.deepcopy 函数执行深拷贝。其他模式，包括切片 [:] 、copy 方法、copy.copy 函数均执行浅拷贝

列表推导式

列表推导式是替代复杂循环的一种简洁语法形式
语法格式：

[expression for var in some_container]
[expression for var in some_container if <condition>]

例如：构建 1~10 的平方的列表
循环方式：

li = []
for i in range(1,11):
	li.append(i**2)
print(li)

列表推导式方式：

[x ** 2 for x in range(1,11)]

• 构造嵌套列表推导式时要注意两个 for 循环的顺序，应该遵循由外而内的写法

元组

• 元组是不可变类型，可以用来存储在计算中元素无须修改的对象
• 从形式上，元组使用 () 将元素括起来，元素之间用逗号分隔
• 元组中的元素可以是单一的类型，如全为整数，或全为字符串，也可以是混杂的类型
• 创建元组时可以通过 () 包含逗号分隔的若干元素得到元组，省略 () 也可以得到元组
  
• 可以使用 tuple 函数将序列转换为元组
  
• 由于元组的不可变性，修改元祖元素的值会产生 TypeError
  
• 可以用 + 表示元组的连接，* 表示元祖的延展
• 可以用 del 语句删除一个元组，del 的作用是撕掉标签
• 元组也是可迭代对象，可以用 for 循环遍历
• 元组的 count 方法、index 方法和列表类似

生成器表达式

语法格式：

(expression for var in some_container)
(expression for var in some_container if <condition>)

1~10 的平方的生成器表达式：

生成器的特点：

• 生成器保存的是算法，因此不会占据过多内存
• 生成器中包含着元素，只在被访问时才呈现，这种特性称为惰性生成
• 生成器中的元素一旦被访问，即被消耗，不能被再次访问

字典

字典通过“键值对”来存储数据，在存储和读取数据时，都根据对键的 hash 运算取得存储的地址，实现了快速的内存访问。字典中的键值必须唯一，而值则不必。

从形式上，字典使用 { } 将元素括起，键值对之间用逗号分隔，键和值之间用冒号分隔

字典的这种 key-value 存储方式，在存入值的时候，也要根据 key 计算 value 的存放位置，读的时候才能根据 key 快速的得到 value。把 key 翻译成地址的过程称为 hash，又叫哈希、散列

• 字典中的键必须唯一，必须是不可变对象。可使用数字、字符串或元组作为键。列表是可变对象，不能作为键
• 字典中的值可以是任意数据类型
• 字典中的项不存在顺序，当遍历字典时，依次取得的项的顺序未必和创建时一致

字典的创建

采用 { } 定界描述的方法，或采用 dict 函数构造的方法

dict 函数可以把形如字典形式的列表或元组转换为字典

zip 函数将两个列表打包为包含元组的 zip 对象，zip 对象是惰性生成的迭代器

字典的 fromkeys(iterable[ ,v]) 方法使用给定的键的容器建立新字典，若不给定值则默认为None

字典的访问

字典元素的访问方式是通过键 dict_name[key]

字典的 keys 方法返回字典的键列表，values 方法返回字典的值列表，items 方法返回字典的键值对列表

字典的 get(key, default = None) 方法访问字典中对应的键里的值，如不存在该键返回 default 的值

setdefault(key, default = None) 方法和 get 类似，不同之处在于，如该键不存在，则添加该键到字典中并将值设为 default 的值

字典的编辑

通过索引方式更新数据：

update() 方法更新，既包括相同键的更新，也包括新键值对的添加

pop(k[,v]) 方法删除指定的键值对，若键存在，则返回对应的值，若不存在，则返回 v
popitem 方法随机删除一个键值对
clear 方法清除字典的数据
del 语句删除指定的字典或指定的键

• 和列表相比，字典具有查找和插入速度快的特点，不会随着 Key 的增多而显著变慢，但字典要占用大量的内存，以空间换时间

例：统计一段字符串中各个字符出现的次数

sentence = "where there is a will, there is a way."
d = {}
for c in sentence:
#方式1
	if c not in d:	#in 操作符判断是否存在
		d[c] = 1
	else:
	d[c] = d[c] + 1
#方式2
	d[c] = d.get(c,0) + 1	#使用了默认值的 get 方法
print(d)

例：菲波那切数列改进
使用字典保存历史记录，并且在函数查询时首先从字典中查找，从而加快函数返回速度

ex = {1:1, 2:1}    #设置初始的全局字典
def fib(n):
	if n in ex:    #在 ex 中查找
		return ex[n]
	else:
	rst = fib(n - 1) + fib(n - 2)
	ex[n] = rst	   #更新字典
	return rst

集合

认识集合

• 集合是无序的，用 { } 定界。集合元素之间用逗号分隔，但是集合的元素不是键值对，而仅仅是键，可以将集合理解为没有值的字典
• 集合的值不能重复，集合的元素只能是不可变对象
• 可以使用 s1 = set() 创建空集合，但是不能使用 s2 = { }，因为 { } 表示空字典
  
• 可以用 set 函数将已有对象转变为集合：
  

集合的运算

和数学中集合的概念一样，Python 中的集合支持并、交、差、对称差等运算

集合的方法

• add 方法添加元素
• 更新集合 s 的方法：
  s.update(t1,t2,…,tn)：利用并集
  s.intersection_update(t1,t2,…,tn)：利用交集
  s.difference_update(t1,t2,…,tn)：利用差集
  s.symmetric_difference_update(t)：利用对称差更新 s (s = s ^t)
• remove 方法和 discard 方法可以删除集合中指定的值。当要删除的元素在集合中存在时，两个方法效果相同。当要删除的元素在集合中不存在时，remove 方法报错，而 discard 方法无操作
• pop 方法删除任意一个元素
• clear 方法清除集合中的所有元素，但容器还在
• del 语句可删除整个集合