Python-数据类型总结

1、介绍

按存储空间的占用分（从低到高）:
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，须要存索引相关信息，不可变
列表：有序，须要存索引相关信息，可变，须要处理数据的增删改
字典：无序，须要存key与value映射的相关信息，可变，须要处理数据的增删改

按可变不可变区分：
一、可变类型：在id不变的状况下，value能够变，则称为可变类型，如列表，字典
二、不可变类型：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

2、数字类型

整型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中没有长整形的概念）：

3、bool 布尔

布尔值，一个True：真，一个False：假
计算机俗称电脑，即咱们编写程序让计算机运行时，应该是让计算机无限接近人脑，或者说人脑能干什么，计算机就应该能干什么，人脑的主要做用是数据运行与逻辑运算，此处的布尔类型就模拟人的逻辑运行，即判断一个条件成立时，用True标识，不成立则用False标识
全部数据类型都自带布尔值
一、None，0，空（空字符串，空列表，空字典等）三种状况下布尔值为False
二、其他均为真

4、字符串-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浮点数：


5、运算符

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

算数运算

比较运算

赋值运算

位运算

逻辑运算

三者的优先级：or<and<not，同一优先级默认从左往右计算

and注解：
在Python 中，and 和 or 执行布尔逻辑演算，如你所期待的同样，可是它们并不返回布尔值；而是，返回它们实际进行比较的值之一。
在布尔上下文中从左到右演算表达式的值，若是布尔上下文中的全部值都为真，那么 and 返回最后一个值。
若是布尔上下文中的某个值为假，则 and 返回第一个假值

or注解：
使用 or 时，在布尔上下文中从左到右演算值，就像 and 同样。若是有一个值为真，or 马上返回该值
若是全部的值都为假，or 返回最后一个假值
注意 or 在布尔上下文中会一直进行表达式演算直到找到第一个真值，而后就会忽略剩余的比较值

and-or结合使用：
结合了前面的两种语法，推理便可。
为增强程序可读性，最好与括号连用，例如：（1 and 'x'） or 'y'

成员运算

身份运算

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

运算符优先级

6、列表-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]     # 隔一个取一个元素

7、元组-tuple

存多个值，对比列表来讲，元组不可变（是能够当作字典的key的），主要是用来读。修改、删除元组变量，必须修改时需从新赋值
做用：协同做业时不能随意更改，更改须要list（xx）转成列表
经常使用操做：索引、切片、循环、长度、包含
dir：显示全部方法，只读.明确的表示 元组里存储的数据是不该该被修改的；
list( tuple元组) 变成列表，tuple(list列表) 变成元组

函数

cmp(tuple1, tuple2) # 比较两个元组元素
len(tuple)  # 计算元组元素个数
max(tuple)  # 返回元组中元素最大值。
min(tuple)  # 返回元组中元素最小值。
tuple(list)  # 将列表转换为元组。

索引：

元组运算符

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

注意：由于括号()既能够表示tuple，又能够表示数学公式中的小括号。
   因此，若是元组只有1个元素，就必须加一个逗号，防止被看成括号运算

8、字典-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())

案例

9、集合-set

集合-set
能够包含多个元素，用逗号分割，集合的元素遵循三个原则：
一、每一个元素必须是不可变类型(可hash，可做为字典的key)
二、没有重复的元素
三、无序

名词解释：
交集 两个都有
差集 在列表a里有，b里没有
并集 把两个列表里的元素合并在一块儿去重，自然去重
做用：关系测试（无序的），交集、差集、并集（合并去重复）

集合符号简化

一、交集：.intersection（）    # &能够替代
二、差集：.different（）       #只打印.以前集合的，—能够替代
三、对称差集：.symmetric_difference()     #互相的差别都打印，^能够替代
四、并集：.union（）           #合并，| 能够替代
五、父集:>,>=
六、子集:<,<=

经常使用操做
增：

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)     #返回输入的变量类型，若是变量是字典就返回字典类型。