python字典类型做数据处理_Python-数据类型总结

一、介绍

按存储空间的占用分(从低到高):

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按可变不可变区分：

1、可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典

2、不可变类型：value一旦改变，id也改变，则称为不可变类型(id变，意味着创建了新的内存空间)

进制：

1个二进制位是计算机里的最小表示单元

1个字节是计算机里最小的存储单位

二进制位=bit = 8bits

8bits = 1Byte = 1字节

1024Bytes = 1KB = 1KB

1024KB = 1MB = 100万字节 = 100万字符 = 1兆

1024MB = 1GB = 一部高清电影短片， 1080p 20分钟，

1024GB= 1TB

1024TB = 1PB

二、数字类型

整型int：

定义：age=10 #age=int(10)

用于标识：年龄，等级，身份证号，qq号，个数

在32位机器上，整数的位数为32位，范围为-231～231-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，范围为-263～263-1，即-9223372036854775808～9223372036854775807

浮点型float：

定义：salary=3.1 #salary=float(3.1)

用于标识：工资，身高，体重

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意：从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，在长整数数据后面不加字母L也不会导致严重后果了。在Python3里不再有long类型了，全都是int。

复数型complex：

>>> x=1-2j

>>> x.real

长整形

在python2中(python3中没有长整形的概念)：

三、bool 布尔

布尔值，一个True：真，一个False：假

计算机俗称电脑，即我们编写程序让计算机运行时，应该是让计算机无限接近人脑，或者说人脑能干什么，计算机就应该能干什么，人脑的主要作用是数据运行与逻辑运算，此处的布尔类型就模拟人的逻辑运行，即判断一个条件成立时，用True标识，不成立则用False标识

所有数据类型都自带布尔值

1、None，0，空(空字符串，空列表，空字典等)三种情况下布尔值为False

2、其余均为真

四、字符串-string

概念

在python中，加了引号的字符就是字符串类型，python并没有字符类型。

作用：名字，性别，国籍，地址等描述信息

定义：在单引号双引号三引号内，由一串字符组成

多引号：作用就是多行字符串必须用多引号。

字符串相加其实就是简单拼接

注意1：字符串相加的效率不高，字符串+字符串，而是申请一个全新的内存空间存入2个字符串，相当字符串与字符串的空间被复制了一次。

注意2：只能字符串加字符串，不能字符串加其他类型。

常用功能

转换格式：

.str() #将非字符串表示为字符串

移除空白：

.strip() #把字符串开头和结尾的空格及/n，括号里可以指定清除内容

.rstrip() #清除末尾空白

.lstrip() #清除开头空白

拼接：

“+”拼接 #次数少适用

print(xx.join([“”，“内容”])) #xx 可以为特殊字符、空格,节省内存空间

空白：

/t #添加制表符

/n #换行符

分割：

“hello world”.split(“l”，x) #x为最大分割数

rsplit # 从右开始切分

查找：

xx.find(“x”,3) #返回找到的第一个值的索引，找不到返回-1

xx.rfind(“x”) #返回从右往左找到的第一个值的索引

xx.count(‘x’,2,8) #统计字符串2到8之间的x, 不指定范围则查找所有

长度：

xx.index(“x”) #返回内容长度，查找不到会报错

替换：

(“x”.replace(“y”)) #不会改变列表，只打印当前

显示位置：

xx.center(50,’-’) #向左间隔50，后面为填充

xx.ljust(50,’-’) #向右对齐

xx.zfill (50) #大于字符串长度的时候补0

格式化输出：

print(“hello %s”%s) #占位符:%s字符串,%d整型,%f浮点型

xx.format(30) #进行赋值

print("hello {name}, his age is {age}".format({"name":"egon","age":1000}))

#键值对位置变动不影响使用。建议改方法

print("hello {0}, his age is {1}".format(34,"alex")) #0和1必须按顺序来

print("HELLO\n wor\nld\n".splitlines())

print("HELLO\n wor\nld\n".split("\n")) #和上面的区别是最后一个为空

判断：

xx.isalnum() #a-z、A-Z、0-9

xx.isdecimal() #判断是不是一个正整数

xx.isdigit() #判断bytes和unicode类型，常用于判断数字

xx.isnumeric() #识别罗马数字

xx.isalpha() #判断是不是字母,返回True和False

xx.isidentifier () #判断是不是一个合法关键字

xx.islower() #检测字符串是否由小写字母

xx.isupper() #判断是不是大写

xx.isspace() #判断若是空格则为真

type(‘xxxx’) is str #判断是不是字符串，命令行下

xx.isinstance(‘xxxx’,str) #判断变量类型

注意：最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景,如果要判断中文数字或罗马数字,则需要用到isnumeric

字母格式：

xx.endswith(‘x’) #以x为结尾区分大写，返回真假值

xx.capitalize() #第一个大写

xx.title() #每个单词首字母大写

xx.casefold() #全变成小写，支持拉丁文等

xx.lower() #全变成小写，只支持英文，常用方法

xx.upper() #全变成大写

设置t的长度：

print("HELLOtworld".expandtabs(30))

转义符：

‘let\‘xx’

r“\xxx” #r显示输出内容

占位符，如：%s、%d

%s字符串占位符：可以接收字符串，也可接收数字

print('My name is %s,my age is %s' %('egon',18))

%d数字占位符：只能接收数字，否则会报错。

%f浮点数：

五、运算符

计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算。

算数运算

比较运算

赋值运算

位运算

逻辑运算

三者的优先级：or

and注解：

在Python 中，and 和 or 执行布尔逻辑演算，如你所期待的一样，但是它们并不返回布尔值；而是，返回它们实际进行比较的值之一。

在布尔上下文中从左到右演算表达式的值，如果布尔上下文中的所有值都为真，那么 and 返回最后一个值。

如果布尔上下文中的某个值为假，则 and 返回第一个假值

or注解：

使用 or 时，在布尔上下文中从左到右演算值，就像 and 一样。如果有一个值为真，or 立刻返回该值

如果所有的值都为假，or 返回最后一个假值

注意 or 在布尔上下文中会一直进行表达式演算直到找到第一个真值，然后就会忽略剩余的比较值

and-or结合使用：

结合了前面的两种语法，推理即可。

为加强程序可读性，最好与括号连用，例如：(1 and 'x') or 'y'

成员运算

身份运算

#is比较的是id，而==比较的是值

运算符优先级

六、列表-list

在[]内用逗号分隔，可以存放n个任意类型的值，适用于存储在程序运行期间可能变化的数据集

可赋值：数据、字符串、列表、字典

常用操作：索引、切片、追加、删除、长度、切片、循环、包含

属于可迭代对象：能够进行for循环

函数

cmp(list1, list2) # 用于比较两个列表的元素

如果比较的元素是同类型的,则比较其值,返回结果。

如果两个元素不是同一种类型,则检查它们是否是数字。元素相同返回0.

len(list) #返回列表元素个数

max(list) #返回列表元素中的最大值

min(list) #返回列表元素中的最小值

list(seq) #用于将元组转换为列表。

number = list(range(2,21,2))

#打印1-21列表中的偶数

number = list(range(1,1000))

#打印1-1000之间的数值并以列表的形式输出

number = list(range(1,21,2))

#打印1-21列表中的奇数

summation = sum(number)

#求列表总和

for number in range(1,21) # 循环列表

打印1-20的数字，range最后一个范围值不打印

方法

list.append(obj) #将元素添加到末尾，该方法无返回值，但是会修改原来的列表

list.insert(index, obj) #用于将指定对象插入列表的指定位置

index--对象 obj 需要插入的索引位置。obj--要插入列表中的对象

list.pop(obj=list[-1]) #用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

obj -- 可选参数，要移除列表元素的对象

list.remove(obj) # 用于移除列表中某个值的第一个匹配项

obj--列表中要移除的对象。按元素的值删除，只删除第一个重复的值

del dine_together[2] #按位置删除，需知道索引,删除后消失

dine_together.clear() #清空列表

list[index]= NewValue # 更改元素

list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值

print(set(index)) # 去重复内容，并重新排序

list.reverse() #反转，用于列表倒序，永久修改，再次调用可恢复原始

print(sorted(list)) #显示临时排序，不影响原始排序

print(sorted(list,reverse=True)) #临时排序反方向

list.sort([func]) # func -- 可选参数

#对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数

list.sort() #永久排序,按字母顺序

list.sort(reverse=True) #反方向排序。是按ASCII表的顺序也是字母顺序

list.index(obj) #用于从列表中找出某个值第一个匹配项的索引位置

list.index(ind1：ind2) #获取从ind1到ind2直接的元素

list*expr # 列表重复expr次

type(a) #type()是查看数据类型的方法

for i in l: # 遍历

切片：

print(list[1:4]) #取下标1至4之间内容不包括4,[]内必须有下标。

print(list[:4]) #从列表开头开始提取，把0省略

print(list[-4:]) #从末尾提取

list[::-1] # 可以视为翻转操作

list[::2] # 隔一个取一个元素

七、元组-tuple

存多个值，对比列表来说，元组不可变(是可以当做字典的key的)，主要是用来读。修改、删除元组变量，必须修改时需重新赋值

作用：协同作业时不能随意更改，更改需要list(xx)转成列表

常用操作：索引、切片、循环、长度、包含

dir：显示所有方法，只读.明确的表示 元组里存储的数据是不应该被修改的；

list( tuple元组) 变成列表，tuple(list列表) 变成元组

函数

cmp(tuple1, tuple2) # 比较两个元组元素

len(tuple) # 计算元组元素个数

max(tuple) # 返回元组中元素最大值。

min(tuple) # 返回元组中元素最小值。

tuple(list) # 将列表转换为元组。

索引：

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组

注意：因为括号()既可以表示tuple，又可以表示数学公式中的小括号。

所以，如果元组只有1个元素，就必须加一个逗号，防止被当作括号运算

八、字典-dict

用于标识：存储多个值的情况，每个值都有唯一一个对应的key，可以更为方便高效地取值。字典是无序的特性。

定义：key必须是不可变类型，value可以是任意类型

常用操作：索引、新增、删除、(键、值、键值对)、循环、长度

函数：

cmp(dict1, dict2) # 比较两个字典元素

如果两个字典的元素相同返回0，如果字典dict1大于字典dict2返回1，如果字典dict1小于字典dict2返回-1

len(dict) # 返回字典的元素个数，即键的总数。dict -要计算元素个数的字典

str(dict) # 将值转化为适于人阅读的形式，以可打印的字符串表示

type(dict) # 返回输入的变量类型，如果变量是字典就返回字典类型

方法：

dict.clear() # 删除字典内所有元素

dict.copy() # 返回一个字典的浅复制

dict.fromkeys(seq[, val])

#创建一个新字典，以序列 seq 中元素做字典的键，value为字典所有键对应的初始值，该方法返回列表。

seq -- 字典键值列表。

value -- 可选参数, 设置键序列(seq)的值

dict.get(key,default=None) # 返回指定键的值，如果值不在字典中返回默认值None

key -- 字典中要查找的键。

default -- 如果指定键的值不存在时，返回该默认值值

dict.has_key(key) # 如果键在字典里返回true，否则返回false

dict.items() # 返回可遍历的健值对(键, 值)列表，元组数组

dict.keys() # 以列表返回一个字典所有的键

keys方法也可以确定这个键在不在字典中

dict.setdefault(key, default=None)

# 和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值.

default -- 键不存时，设置的默认键值

dict.update(dict2) # 把字典dict2的键/值对更新到dict里

dict.values() # 以列表返回字典中的所有值,不包含任何键

pop(key[,default])

# 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

key: 要删除的键值

default: 如果没有 key，返回 default 值

popitem() # 随机返回并删除字典中的一对键和值

sorted() #按顺序遍历字典中所有的键，按照字母顺序排序

#for i in sorted(list.keys())

案例

九、集合-set

集合-set

可以包含多个元素，用逗号分割，集合的元素遵循三个原则：

1、每个元素必须是不可变类型(可hash，可作为字典的key)

2、没有重复的元素

3、无序

名词解释：

交集 两个都有

差集 在列表a里有，b里没有

并集 把两个列表里的元素合并在一起去重，天然去重

作用：关系测试(无序的)，交集、差集、并集(合并去重复)

集合符号简化

1、交集：.intersection() # &可以替代

2、差集：.different() #只打印.之前集合的，—可以替代

3、对称差集：.symmetric_difference() #互相的差异都打印，^可以替代

4、并集：.union() #合并，| 可以替代

5、父集:>,>=

6、子集:

常用操作

增：

dict.update() #把()中的合并到.之前的集合中,会改变集合

dict.add() #在集合中添加元素

dict.append() #用于在列表末尾添加新的对象

dict.difference_update() 把差集去除来存到.前的集合中

删：

dict.clear() #删除字典内所有元素

dict.discard() #删除 元素不存在不会报错

dict.popitem() #随机返回并删除字典中的一对键和值

dict.pop(key[,default])

#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

输出、判断：

dict.values() #以列表返回字典中的所有值

dict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值

dict.copy() #返回一个字典的浅复制

dict.items() #以列表返回可遍历的(键, 值) 元组数组

dict.has_key(key) #如果键在字典dict里返回true，否则返回false

dict.issubset() #判断()里的是否为.前的子集

dict.issuperset() #超集、父集，可以用表示

dict.isdisjoint() #两个集合没有交集返回为true

特殊常用

dict.discard () #元素不存在会报错

cmp(dict1, dict2) #比较两个字典元素

len(dict) #计算字典元素个数，即键的总数。

str(dict) #输出字典可打印的字符串表示。

type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。