python数据类型

---

python作为一门面向对象编程语言，其所提供的所有数据类型都是对象，对于python中的对象，也即可以理解为java中所提供的引用类型，不同于Java，python并不兼容cpp中的基础数据类型。python中的数据声明无需像cpp或是java一样显示给出，类似于cpp中的auto自动类型判断，python中声明的变量的类型通过其赋值来决定。同时，python作为一门若类型的语言，即是说变量在使用一种数据类型初始化后可以在后续的操作中通过赋值改变为其余数据类型，即python中变量的数据类型是可变的。

---

int - 整型

1. 整型，不同于cpp或是java，python中提供的整型也是对象。python中的整型自动支持大数运算，无需考虑溢出问题。
2. example

   a = 10 #　自动识别为整型int
   b = 100
   c = a + b
   # [-5,256]的整型放在数据池中，对于这个范围内被赋值相同的变量而言，实际指向同一个数据存储空间
   m = 25
   n = 25
   print(id(m)==id(n)) # 将返回true，id用于获取变量的存储地址
   m = 1000
   n = 1000
   print(id(m)==id(n)) # 将返回false
   d = int(5) # int用于将参数强制类型转换为整型
   e = int(input()) # 用于将从键盘输入的字符串转换为整型
   

---

float - 浮点型

1. 浮点型，python中并不提供诸如cpp或是Java中的double（双精度浮点类型）。
2. example

   a = 3.14 # 将自动类型推断为float
   b = float(4.48) # float用于将参数强制类型转换为float
   c = float(input()) # 将从标准输入到的字符串强制数据类型转换为float
   f = a + b
   d = float("inf") # 赋值为无穷大
   e = float("-inf") 3 赋值为无穷小
   

---

str - 字符串

1. 字符串。
2. example

   s = "this is a piece of string." # 双引号中的内容被自动推断为字符串
   ss = 'this is a piece of string, too.' # 单引号中的内容被自动推断为字符串
   sss = """this
   is 
   multiple
   strings.""" # 三引号中的内容为跨越多行的字符串
   s2 = str("this is string.") # str用于将参数强制数据类型转换为字符串
   s3 = input() # 从标准输入获取的数据默认为字符串
   

---

bool - 布尔型

1. 布尔类型。
2. example

   a = True # 保留字True作为python中bool真值
   b = False  #　保留字False作为python中假值
   c = bool(1) # 非零元素通过bool强制数据类型转换为True 
   d = bool(0) # 零值通过bool强制数据类型转换为False
   e = bool(100) # True
   f = bool(2+3) # 计算表达式的值后根据其是否为零再根据上述规则转换为True或False
   

---

list - 列表

1. 列表，python中最常用的数据类型之一。
2. example

   # 1. 声明
   #　中括号中的元素被推断为列表
   lis = [1,2,3,4,5]
   #　列表中的元素类型可以不统一
   lis = [1, 2.34, "string", [12,2]]
   # 声明空列表
   lis = []
   # 通过字符串方法生成列表，默认分隔符为空格，可以指定分隔符
   lis = "this,is,a,string.".split(',')
   lis = "male: this is:dialog.".split(':', 1) # 第二个参数指定最大分割次数
   # 通过list工厂函数声明列表
   lis = list("this is string.") # 字符串作为列表，分割单位为单个列表
   lis = list(range(1,10)) # range生成一个可迭代等差数列
   
   # 2. 使用
   lis = [1,2,3,4,5]
   # 追加元素
   lis.append(1)
   # 索引元素
   lis[0] # 获取第一个元素
   lis[-1] # 获取从后往前数第一个元素
   # 通过值移除元素
   lis.remove(1) # 将元素1从列表中移除
   # 通过索引移除元素
   def lis[2] # 移除第三个元素
   # 获取列表元素个数
   size = len(lis)
   # 切片，用于获取列表中的某个片段
   lis[2:3] # 获取从第二个元素到第四个元素
   lis[:] # 获取整个列表的复制
   lis[:5] # 获取从第一个元素到第六个元素
   lis[4:] # 获取从第五个元素到最后一个元素
   lis[1:5:2] # 获取从第一个元素到第五个元素，步长为二
   lis[::-1] # 获取从整个列表的复制，步长为-1，即获取列表的逆序
   # 移除部分列表元素
   lis[1:3] = [] # 移除从第二个元素到第四个元素
   del lis[1:3] # 同上
   # 插入元素
   lis.insert(0,4) # 在第一个元素位置插入元素4
   # 列表拼接
   lis.extend([1,2]) #　将列表与[1,2]追加合并
   lis + [1,2,3] # 将列表与[1,2,3]拼接合并
   

---

tuple - 元组

1. 元组，理解为受限制的列表。
2. example

   # 声明
   tp = 1,2,3 # 逗号分隔自动类型推断为元组
   tp1 = (1,2,3) # 通常使用（）包括元组，注意括号并非元组的标志
   tp2 = tuple((1,2,3)) # tuple工厂函数将可迭代参数强制类型转换为元组，注意tuple仅需一个参数，故内层括号不可省略
   tp3 = tuple() # 声明空元组
   
   # 使用
   tp = 1,1,2,3
   tp.count(1) # 获取元素在元组中的个数
   tp.index(2) # 获取参数在元组中当前的索引
   

---

set - 可变集合

1. 可变集合，特点为集合中的元素不重复，且元素自动有序，访问集合元素不可以使用下标索引。
2. example

   # 声明
   st = {1,2,3,1} # 大括号中逗号分隔的单元素数据被类型推断为集合，重复元素将被忽略
   st1 = set([1,2,3,4,3,2]) # set将可迭代对象参数强制数据类型转换为集合
   st2 = set() # 声明空集合，直接使用空的大括号将声明为空字典而非集合
   
   # 使用
   st = {1,2,3,3}
   st.copy() # 获取集合的复制
   st.clear() # 清空集合
   st.add(5) # 像集合中添加元素
   st.pop() # 弹出第一个元素
   st.remove(5) # 删除元素
   # 集合的专有运算不在此处给出
   

---

dict - 字典

1. 字典，类比Java中的HashMap，即映射或是键值对。

   # 声明
   dc = {'first':'a','second':'b','third':'c'} # 大括号中使用逗号分隔的键值对数据被类型推断为字典
   dc2 = dict(((1,'a'),(2,'b'))) # 使用dict声明字典，这里参数是一个元组，元组元素同样是二值对应元组，其中第一个值将被作为键，第二个值将被作为值
   dc5 = dict(first=1,second=2) # 通过关键字传参构造列表，参数名作为键，参数值作为值，注意参数名不能使用引号
   keys = [1,2,3,4,5] # 通过键列表和值列表得到对应字典
   values = ['a','b','c','d','e']
   dc3 = dict(zip(keys,values)) # zip将两个等长列表l1,l2对应封装为((l1[0],l2[0]),(l1[1],l2[1])...)的形式的可迭代对象
   dc4 = dict.fromkeys([1,2,3,4]) # 使用dict.fromkeys构造指定键、默认值的字典，默认值可统一指定，默认为None
   
   # 使用
   dc = {'first':'a','second':'b','third':'c'}
   dc['first'] # 字典可以通过键索引到值，但不可使用下标，如dc[1]
   dc.get('first', "not found") # .get通过键获取值，与上一种方式的区别在当给出键不存在时，上一种会抛出异常，.get会返回指定的第二个参数，默认为None
   dc['first'] = 'aaa' # 通过键重新赋值
   dc['other'] = '...' # 对不存在的键赋值将执行新增键值对操作
   dc.update(first='aba') # 更新元素，键存在则更新，键不存在则新增
   dc.copy() # 获取字典的拷贝
   dc.keys() # 获取所有键，返回一个可迭代对象
   dc.values() # 获取所有值，返回一个可迭代对象
   dc.items() # 获取所有键值对的可迭代对象
   
   for key in dc: # 直接对字典迭代，将迭代所有键
      print(key) # 输出键
      print(dc[key]) # 输出键对应的值
      
   for key, value in dc.items(): # 直接对键值对进行迭代
      print(key) # 输出键
      print(value) # 输出值
       
   # 可以使用frozenset创建不可变集合
   a = {1,2,3,4}
   b = frozenset(a)
   

---

None

类比cpp中的nullptr和java中的null，python中提供的None表示无值，或者该对象不引用任何实际数据空间。

a = None

---

深浅拷贝问题

同java中的引用类型对象类似，python的对象之间赋值会存在深浅拷贝的问题。

# 对于所有引用类型同理，这里以列表为例
lis = [1,2,3]
lis2 = lis # 此时lis2与lis为绝对相等，即二者指向同一数据空间，对其中任意值的更改都会导致数据本身被修改
lis[0] = 100
print(lis2[0]) # 将输出100
print(id(lis)==id(lis2)) # 将返回True
lis3 = lis.copy() # 此时lis3与lis为数值相等，二者指向的是不同的数据空间，对于其一的更改不会影响到另一者
print(id(lis)==id(lis3)) # 将返回False
lis4 = lis[:] # 全切片等价于lis.copy()