猫说

python数据类型

2021/04/24 Python

详细记录一下python的数据类型

1、数字类型 Number

数字类型有四种：

  1. 整型 int
  2. 长整型 long int
  3. 浮点型 float
  4. 复数 complex numbers)

数字类型可以进行类型转换

# 将x转换为一个整数  
int(x)

# 转换为长整数
long(x)

# 转换为浮点数
float(x)

# 创建一个复数
complex(r, i)

# 转换为整数
ord(x)

# 16进制
hex(x)

# 8进制
oct(x)

# 将一个整数转换为Unicode字符  
unichr(x)

# 将一个整数转换为一个字符  
chr(x)

1.1 python中运算

Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。

  • Python math 模块提供了许多对浮点数的数学运算函数。
  • Python cmath 模块包含了一些用于复数运算的函数。
  • cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
# 使用必须先引入

import math

1.2 相关函数

选择一些常用的，具体看文档

  1. abs(x)：返回数字的绝对值
  2. floor(x)：返回向下取整的数
  3. round(x [,n])：返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
  4. pow(x, y)：x**y 运算后的值。
  5. random()：随机生成下一个实数，它在[0,1)范围内。
  6. choice(seq)：从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
  7. 三角函数系列的函数
  8. pi：圆周率
  9. e：常量e，自然常数

2、字符串 String

字符串是很常见的数据类型

一些常用的字符串方法

  1. string.count(str, beg=0, end=len(string)): 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
  2. string.decode()：以 encoding 指定的编码格式解码 string
  3. string.encode()：以 encoding 指定的编码格式编码 string
  4. string.find()：检测 str 是否包含在 string 中
  5. string.format()：格式化字符串
  6. string.index()：跟find()方法一样，只不过如果str不在 string中会报一个异常.
  7. string.isspace()：如果 string 中只包含空格，则返回 True，否则返回 False.
  8. string.isnumeric()：如果 string 中只包含数字字符，则返回 True，否则返回 False
  9. string.isupper()：如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
  10. string.join(seq)：以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
  11. string.lower()：转换 string 中所有大写字符为小写.
  12. string.upper()：转换 string 中的小写字母为大写
  13. string.lstrip()：截掉 string 左边的空格
  14. string.replace(str1, str2)：把 string 中的 str1 替换成 str2
  15. string.rstrip()：删除 string 字符串末尾的空格.
  16. string.strip(): 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
  17. string.split(): 分割字符串
  18. string.format(): 字符串格式化
  19. string.center(n,’-‘): 把字符串放中间，两边用- 补齐

字符串前面的一些关键符号r,b,u,f

  1. r：的作用是去除转义字符.str= r'input\n'
  2. b：后面字符串是bytes 类型。 b'<h1>Hello World!</h1>'
  3. u：字符串以 Unicode 格式 进行编码,一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码。
  4. f：f开头表示在字符串内支持大括号内的python 表达式 print(f'{name} done in {time.time() - t0:.2f} s')

二进制转换时候

'汉字'.encode('utf-8')

# 等于下面
bytes('汉字', encoding='utf-8')

# 纯英文  前面加`b`就可以表示是二进制数据
b'wihadh12ih3123'

3、列表类型 List

列表是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 [8, 9]]
 
print("list1[0]: ", list1[0])          # ('list1[0]: ', 'physics')

# 取出多个
print("list2[1:5]: ", list2[1:5])      # ('list2[1:5]: ', [2, 3, 4, 5])  

# 后面拿
print(list1[-1])                       # 2000

# 删除
del list1[0]

# 追加
list1.append('222')

# 插入
list1.insert(1, 'insert')

# 删除特定的一项
list1.remove(1997)

# 扩展 将2追加到1后面
list1.extend(list2)

# 统计某一项出现的次数
list2.count(1)

# 排序 默认从小到大  相反的话list2.sort(reverse=Ture)
list2.sort()     

# 翻转
list2.reverse()

# 根据给定的值获取索引
list2.index(2)

# 移除一个值
list2.pop()

列表的函数：

  1. cmp(list1, list2) : 比较两个列表的元素
  2. len(list) : 列表元素的个数
  3. max(list) : 列表里的最大值
  4. min(list) : 列表里的最小值
  5. list(seq) : 将元祖转换为列表

用列表模拟队列、堆栈


# 队列 FIFO
l.append('first')
l.pop(0)

# LIFO
l.append('secound')
l.pop()

4、元组 Tuple

Python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，列表使用方括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组不可变是指：元组每一项对应的内存地址不可变，如果存放的是引用类型的数据，比如列表类型或者字典类型，修改这些类型的值不会修改内存地址就可以改变。


# 创建元组
tup1 = (1,2,3,4,5,6)

# 元组中只有一个元素的时候，需要在后面加个’，‘
tup2 = (8,)

# 访问元组中的值
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]

# 元组不能修改，可以通过两个元组拼接成一个新元组
tup1 = [1,2,3]
tup2 = [4,5,6]
tup3 = tup1 + tup2

# 删除元组，元组不能修改，但是可以直接全部删除
del tup1

# 如果存的是可变类型的值
tup1 = [1, [2, 3, 4], {'a': 1, 'b': 2}]
tup1[1][0] = 'aawdaw'
print(tup1) # [1, ['aawdaw', 3, 4], {'a': 1, 'b': 2}]

元组内置函数

  1. cmp(tup1, tup2): 比较两个元组元素
  2. len(tup)：计算元组长度
  3. max(tup)：返回元组中元素最大值
  4. min(tup)：返回元组中元素最小值
  5. tuple(sqp)： 将列表转换为元组

5、字典类型 Dictionary

字典是另一种可变容器模型，且可存储任意类型对象, 类似于js里的对象，字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中。

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

dic = {
  'a': 10,
  'b': 20, 
  7: 777
}

# 使用方法创建个空字典
d = dict()

# 访问的话使用key访问
# dic['a']
print(dic[7])

# 不可修改key，可以修改value
dic['a'] = '111'

# 可以新增key
dic['c'] = 333

# 删除或删除某一项
del dic['c']
del dic

# 获取长度
len(dic)

# 转换成字符串
str(dic)

# 输出类型
type(dic)

# 转换为字典
dict(x=1, y = 2)

字典的内置方法

  1. dic.clear(): 清空字典
  2. dic.copy()：浅拷贝一份
  3. dic.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
  4. dic.get(key, default=None)：根据key返回对应的val，如果不存在返回默认值
  5. dic.items(): 返回一个迭代器，以列表返回可遍历的(键, 值) 元组数组
  6. dic.keys()：返回一个迭代器，返回所有的key
  7. dic.update(dic2): 将第二个的键值对更新到第一个里面
  8. dic.values()：返回一个迭代器，返回所有的val
  9. dic.popitem(): 随机返回并删除字典中的最后一对键和值。

6、集合类型 Set

集合（set）是一个无序的不重复元素序列。

可以存放多个值，但主要用于：去重、关系运算。

集合的定义：用{}内用逗号分隔开多个元素，并且满足一下3个条件

  1. 集合内元素必须为不可变类型
  2. 集合内元素无序
  3. 集合内元素不重复
s = {1,2}  # s = set({1,2})

需要注意的是：空的{}代表了字典，如果要定义空集合的话，使用set()

集合的常用方法

  1. add(): 添加元素
  2. clear(): 清空集合
  3. copy(): 拷贝一个集合
  4. discard(): 删除集合中指定的元素，如果不存在不报错
  5. remove(): 删除集合中指定的元素，如果不存在则报错
  6. update(): 给集合添加元素
  7. pop(): 随机移除元素
  8. difference(): 返回多个集合的差集
  9. intersection(): 返回集合的交集
  10. union(): 返回集合的并集
  11. issuperset(): 判断该方法的参数集合是否为指定集合的子集
  12. issubset(): 判断指定集合是否为该方法参数集合的子集。

6.1 集合的关系运算

# 取交集
dic1 = {'a', 'b', 'c'}
dic2 = {'a', 'b', 'd', 'e', 'f'}
res = dic1 & dic2
print(res) # set(['a', 'b'])

## 使用集合的内置方法实现
print(dic1.intersection(dic2))


# 取并集
dic1 = {'a', 'b', 'c'}
dic2 = {'a', 'b', 'd', 'e', 'f'}
res = dic1 | dic2
print(res) # set(['a', 'c', 'b', 'e', 'd', 'f'])

## 使用集合的内置方法实现
print(dic1.union(dic2))

# 取差集 有前后顺序的问题
res = dic1 - dic2
res2 = dic2 - dic1
print(res) # set(['c'])
print(res2) # set(['e', 'd', 'f'])

## 使用集合的内置方法实现
print(dic1.difference(dic2))

# 对称差集
dic1 = {'a', 'b', 'c'}
dic2 = {'a', 'b', 'd', 'e', 'f'}
res = dic1 ^ dic2
print(res) # set(['c', 'e', 'd', 'f'])

## 使用集合的内置方法实现
print(dic1.symmetric_difference(dic2))

# 父子集：一个集合完全包含另一个集合, 相等的话互为父子 
dic1 = {'a', 'b'}
dic2 = {'a', 'b', 'd', 'e', 'f'}
print(dic1 > dic2) # false
print(dic1 < dic2) # true  dic2是dic1的爹

## 使用集合的内置方法实现
print(dic1.issuperset(dic2))  # >
print(dic1.issubset(dic2))  # <

6.2 去重

集合的去重有局限性

  1. 只能针对不可变类型去重
  2. 无法保证原来的顺序

去重可以使用如下方案

l = [
  {'name': 'c', 'age': 18},
  {'name': 'd', 'age': 18},
  {'name': 'd', 'age': 18},
  {'name': 'e', 'age': 18},
  {'name': 'c', 'age': 18},
]

new_l = []

for i in l:
  if i not in new_l:
    new_l.append(i)

print(new_l)  # [{'age': 18, 'name': 'c'}, {'age': 18, 'name': 'd'}, {'age': 18, 'name': 'e'}]

7、数据类型总结

把数据类型按不同的方向区分

7.1 按存储个数区分

  • 只能存一个值可称为标量/原子类型：数字、字符串
  • 可以存多个值容器类型：列表、元组、字典

7.2 按访问方式区分

  • 直接访问只能通过变量名访问整个值：数字
  • 顺序访问可以用索引访问，又称为序列类型：字符串、列表、元组
  • key访问可以使用key访问，又称为映射类型：字典

7.3 按可变不可变区分

  • 可变类型：列表、字典
  • 不可变类型：数字、字符串、元组

Search

    Table of Contents