2.数据类型

数据类型分类

Python 中有多种数据类型，分为基本数据类型和复合数据类型。

基本数据类型（原生数据类型）：

整数（int）：表示整数，例如：-5、0、100。
浮点数（float）：表示浮点数，例如：3.14、-0.001。
复数（complex）：表示复数，例如：3 + 4j。
布尔值（bool）：表示布尔值，即 True 或 False。
字符串（str）：表示文本字符串，例如：'hello'、"world"。

复合数据类型：

列表（list）：有序的、可变的集合，用方括号 [] 表示。
元组（tuple）：有序的、不可变的集合，用圆括号 () 表示。
字典（dict）：无序的键值对集合，用花括号 {} 表示。
集合（set）：无序的、不重复的元素集合，用花括号 {} 表示。
字节串（bytes）：表示二进制数据，例如：b'hello'。
字节数组（bytearray）：与字节串类似，但是可变。
空值（NoneType）：表示空值，即 None。

数字（num）

细分为整数（int）与浮点数（float）两种。

四则运算：+， -， *， /
乘方： * *
整除： 5 // 2 = 2
取余：5 % 2 = 1
自运算： a += 1
（四则与乘方均可类似自运算）以及一些细节：
运算两数中只要有一个浮点数，结果就是浮点数；
整数相除，即使能除尽，结果也是浮点数；
Python 内部的机制解决了整数溢出的问题，不用担心。

布尔（bool）与逻辑

首字母大写 True / False.

逻辑运算符：与 A and B，或 A or B，非 not A
逻辑关系符：等于 ==，不等于 !=. 其他不赘述。
几种逻辑判断例子：

变量 x	x = []	x = 0	x = 2
bool(x)	False	False	True
if x: …	False	False	True
if x is None: …	False	False	False

序列（sequence）

序列主要包括字符串（str）、列表（list）与元祖（tuple）三类。

序列索引规则：
- 索引从0开始，到 N-1 结束。
- 切片：切片的索引是左闭右开的。
  - seq[0:2]（从 0 到 1）
  - seq[2:]（从 2 到尾）
  - seq[:3] （从头到 2）
  - seq[:]（全部）
  - seq[:10:2]（从头到9，每两个取一个）
  - seq[::2]（全部，每两个取一个）
- 索引允许负数：seq(-1) 与 seq(N - 1) 等同，seq(-3:-1)与 seq(N-3:N-1) 等同。
序列通用函数：
- len()：返回序列长度。
- +/* ：加号用于连接两个序列，乘号重复排列若干次再连接。
- seq1 in seq2：如果 seq1 这个片段可以在 seq2 中被找到，返回 True.
- index：在 seq1 in seq2 为 True 时使用，seq2.index(seq1) 表示 seq1 首次出现于 seq2 中的位置。
- max()/min()：返回序列中的最值。如果不是数字，则按 ASCII 码顺序返回。
- cmp(seq1, seq2)：比较大小。结果为负，则表示 seq1 较小。

字符串（str）

写于一对双引号或单引号内。用 str() 可以强制转换为字符串。

转义：反斜杠。如果强制不解释字符串，在左引号前加字母 r 即可： r"c:\new".
分割与连接：**.split() 与 **.join()，
''.join(list) ：可以将列表转换成字符串

s = " I love Python"  # 首位是空格
lst = s.split(' ')
lst1 = '-'.join(lst)

print(lst, '\n', lst1)
['', 'I', 'love', 'Python'] 
 -I-love-Python

#將列表轉換成字符串
list = [1, 2, 3, 4, 5]
print(''.join(list))
#將字符串轉換成列表
str = 'abcde'
list1 = list(str)
print(list1)
['a', 'b', 'c', 'd', 'e']

a='123 4'
b = list(a)
print(b)
['1', '2', '3', ' ', '4']

紧切：strip() 去掉字符串首尾两端的空格。方法 lstrip()/rstrip() 则只切除首端/尾端的空格。

s.strip()
'I love Python'

大小写转换：如下几个方法：
- 首字母大写：s.title()
- 全大写：s.upper()
- 全小写：s.lower()
- 句首大写：s.capitalize()
格式化：字符串格式化是一种实用功能。通过 .format() 成员函数完成。

'I like {} and {}'.format('Python', 'you')
'I like Python and you'
'{0} + {2} = {1}'.format (10, 20, 'Python ')  # 按顺序引用
'10 + Python  = 20'
'{0} * {1} = {0}'.format (10, 'Python ')  # 编号反复引用
'10 * Python  = 10'

格式化控制码：

控制码	含义	控制码	含义
:s	字符串	:c	单个字符
:b/o/x/d	二、八、十六、十进制数	:e/f	科学计数法/浮点数
一些复杂控制的例子：

例子	含义	例子	含义
:.2f/:+.2f	两位小数/带符号两位小数	: .2f	正数前补空格的两位小数
:,	逗号分隔符	:.2%	百分比两位小数
:.2e	科学计数法两位小数	:^4d	总宽四位居中对齐
`:>4d/<4d`	总宽四位左/右对齐	`:0>4d`	总宽四位左侧补零
举例：

"{:0>7.2f} is an odd number".format(123.4)  # 总宽 7 位小数点后 2 位，左侧补零
'0123.40 is an odd number'

其他实用的字符串函数：

str.replace(old, new[, times])：将字符串中前 times 个 old 子串替换为 new。Times 不指定时默认替换全部。
str.isdigit()：判断字符串是否每一位都是数字，返回 True 或者 False。字符串中正则表达式的内容参见本文附录。
str.split()：将str转化为list。

 a="1.2.3.4"  #以英文的句点为分隔符，得到list
b="1234"
print(a.split())
print(b.split())
['1.2.3.4']
['1234']

列表（list）

中括号式的结构。list() 用于强制转换类型。

lst = [1, 2, 3]
# 【反转】：其中第二种方式会更改现有的列表
lst1 = list(reversed(lst))
lst.reverse()
print(lst1, lst)
[3, 2, 1] [3, 2, 1]
# 【追加】：元素 append()，另一个列表：extend()
lst.append(4)
print(lst)
[3, 2, 1, 4]
lst.extend(lst1)
print(lst)
[3, 2, 1, 4, 3, 2, 1]
# 【插入】：lst.insert(idx, obj) 会在 lst[idx] 处插入 obj，然后依次后移原有项
lst.insert(1, 100)
print(lst)
[3, 100, 2, 1, 4, 3, 2, 1]
# 【删除】：lst.remove(obj) 会删除首个匹配值，若无匹配会报错；
#  lst.pop(idx) 会返回 lst[idx]，并将其删除。如果不指定 idx，默认为列表尾
lst.remove(2)
print(lst)
[3, 100, 1, 4, 3, 2, 1]
tmp = lst.pop()
print(lst, "\n", tmp)
[3, 100, 1, 4, 3, 2] 
 1
del lst[0]   #按照索引刪除第一個元素
[100, 1, 4, 3, 2] 
# 【搜索】：使用序列通用函数即可。用 count(obj) 可以计算频数。
# 【排序】：sort() 方法。如果指定 reverse 参数，可降序排序。
lst.sort(reverse=True)
print(lst)
[100, 4, 3, 3, 2, 1]
# 【清空】：clear()
lst.clear()  #同等效果：del a[:]
print(lst)
[]

列表比较

列表比较需要引入 operator 模块的 eq 方法

import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
operator.eq(a,b):  False
operator.eq(c,b):  True

列表方法：

方法	作用
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表的index位置
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.clear()	清空列表
list.copy()	复制列表

嵌套列表解析

matrix = [
     [1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 10, 11, 12],
]

#将3X4的矩阵列表转换为4X3列表
[[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

#相同效果
b = []
for x in range(4):
    a = []
    for row in matrix:
        a.append(row[x])
    b.append(a)
print(b)

元组（tuple）

圆括号式的结构，是一种不可变序列，不可修改元素，但可以進行进行连接组合。

a = (1, 'string ', [1 ,2])
print(a)
(1, 'string ', [1, 2])
tup3 = "a", "b", "c", "d"   #  不需要括号也可以

#不可修改，否則報錯：TypeError: 'tuple' object does not support item assignment
tup[0] = 'g'     # 不支持修改元素

#定義一個元素元組，需要在元素后面添加逗号
tuple1 = (1,)
type(tuple1)
<type 'tuple'>

#创建空元组
up1 = ()

#不加逗号，类型为整型
tuple2 = (1)
type(tuple2)
<type 'int'>

# 创建一个新的元组
tup3 = tup1 + tup2

#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('physics', 'chemistry', 1997, 2000)
del tup
print tup   #元组被删除后，输出变量会有异常信息，NameError: name 'tup' is not defined

#重新赋值的元组 tup，绑定到新的对象
tup = (1,2,3)
tup = (1,2,3,4)   # 對象變了 内存地址不一样

元组运算符

len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

访问元组

元组是序列，可以使用索引訪問

tup1[1:5]

元组内置函数

tuple(seq)：将列表转换为元组。

字典（dict）

字典是一种类哈希表的数据结构，内部无序，通过键值对（key: value）的形式存储数据。几种字典初始化的方式：

# 小字典直接赋值
d1 = {"name": "wklchris", "gender": "male"}
# 利用字典增加键值对的方法
d2 = {}
d2['name'] = 'wklchris'
# 一个值赋给多个键
d3 = {}.fromkeys(("name", "gender"), "NA")
# 强制格式转换
d4 = dict(name="wklchris", gender="male")

print(d1, d2, d3, d4, sep="\n")
{'name': 'wklchris', 'gender': 'male'}
{'name': 'wklchris'}
{'name': 'NA', 'gender': 'NA'}
{'name': 'wklchris', 'gender': 'male'}

字典的操作方法：

len(d1)
2
# 【复制】：
dd = d1.copy()
dd is d1
False
# 【查找键名称】：
"name" in dd
True
# 【删除键值对】
del(dd["name"])
# 【get】
dd.get("name", "Nothing")  # 如果键不存在，返回“Nothing”
'Nothing'
# 【setdefault】
dd.setdefault("name", "wklchris")  # 如果键不存在，就新建该键，并赋值
'wklchris'
print(dd)
{'name': 'wklchris', 'gender': 'male'}
# 【输出键值】：
list(dd.items())
[('name', 'wklchris'), ('gender', 'male')]
list(dd.keys())
['name', 'gender']
list(dd.values())
['wklchris', 'male']
# 【弹出键值对】：pop(key) / popitem(key)
# 其中，后者会随机弹出一个键值对
tmp = dd.pop("gender")
print(dd, tmp)
{'name': 'wklchris'} male
# 【更新】：update(ref_dict) 以 ref_dict 为准，更新当前字典
d4 = {"name": "Test", "Age": 3}
dd.update(d4)
print(dd)
{'name': 'Test', 'Age': 3}

集合（set）

本文只讨论可变集合，关于不可变集合的内容，参考 help(frozenset)。

集合是一种无序的数据存储方式，且内部元素具有唯一性。集合与字典一样都可以用花括号的形式创立。但在书写 a= 时，Python 会将其识别为字典类型。

增添：add() / update()
删除：remove() / discard()，区别在于后者搜索无结果会报错。
从属：a.issubset(b) 集合 a 是否是 b 的子集；a.issuperset(b) 集合 a 是否是 b 的父集。a == b 两集合是否全等。
集合运算：集合运算不会改变参与运算的集合本身。
- 并集： a | b 或者 a.union(b)
- 交集： a & b 或者 a.intersection(b)
- 补集： a - b 或者 a.difference(b) 注意：在字符串强制转换为集合时，必要时使用中括号先转为列表（否则字符串会被拆分为单个字符后再进行转换）。例如：

ss = {"a", "b", "c"}
ss | set("de")
{'a', 'b', 'c', 'd', 'e'}
ss | set(["de"])
{'a', 'b', 'c', 'de'}

#集合也支持推导式：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

数据类型分类​

基本数据类型（原生数据类型）：​

复合数据类型：​

数字（num）​

布尔（bool）与逻辑​

序列（sequence）​

字符串（str）​

列表（list）​

列表比较​

列表方法：​

嵌套列表解析​

元组（tuple）​

元组运算符​

访问元组​

元组内置函数​

字典（dict）​

集合（set）​