python的基本数据类型（标准类型）：

数字类型、字符类型、元祖和不可变集合是不可变类型，只能是重新创建对象，是可哈希的。

列表、字典和可变集合是可变类型，可以重新赋值，是不可哈希的。

------------------------------------

数字类型：是标量，直接访问

1.整型：int，short和int和long都是整型（长整型），bool类型也是int类型

2.浮点数：float，分数属于浮点数，float和double都是浮点数（双精度）

3.复数：complex,real+imagj ,实数和虚数部分都是float。

python也支持八进制（0）和十六进制(0x).

布尔值类型属于int类型只有两个值True、False。

__builtins__模块中的内建模块int中的内建函数：

int.bit_length()：一个int类型的二进制形式的最小位数。

int.from_bytes(bytes,byteorder, *, signed=False)

int.to_bytes(length,byteorder, *, signed=False)

__builtins__模块中的内建模块float中的内建函数：

float.as_integer_ratio()：返回一个整数对，这两个数相除等于float。

float.hex()：浮点数转换成十六进制表示。

float.fromhex(string)：将十六进制string转换成字符串。

------------------------------------

序列：sequence

成员有序排列，可以通过下标偏移量访问一个或多个成员。字符串、元祖、列表都是序列,序列下标从0开始。

序列类型操作符（字符串、元祖、列表都通用）：

seq[ind]:获取下标为ind的元素，

seq[ind1:ind2]：获取下标从ind1开始到ind2的元素，不包括ind2这个元素，

seq[ind1:ind2:step]:获取下标为[ind1,ind2)的元素，步长为step，

ind的取值范围[0,len(seq)-1]或[-len(seq),-1],ind2一定要大于ind1.

seq[::-1]:翻转一个序列。

seq*number：让seq重复number次。

seq1+seq2：将seq1和seq2连接起来。

objinsequence：判断一个元素是否属于一个序列。

objnotinsequence:判断一个元素是否不属于一个序列。

------------------------------------

字符串str：是标量，顺序访问

字符串的值不能改变，只能是重新赋值，创建一个新的字符串。

字符就是长度为1的字符串，通过下标和切片访问。

删除字符串：

strname= “”

delstrname

‘string‘所有的空格和制表符都按照原样输出,需要转义。

“string“和单引号一样。

‘’‘/”””strings’‘’/”””指定一个多行的字符串，需要转义。

R/r‘/“string’/”：自然字符串，表示‘‘或“”内部的所有内容原样输出。

U/u’/”string‘/”表示使用unicode编码。

用在‘‘/“”引用的字符串中间进行转义，如果是行末就是续行。

\n换行

\t制表符

字符编码：

ascii：早期的编码，StringType类型

unicode：新编码，UnicodeType类型

utf：unicodes或者ucs的转换格式

python中的pickle模块只支持ascii，不支持unicode。

内建变量__doc__：

用来显示说明字符串。

__builtins__模块中的内建模块str中的内建函数：

strname.capitalize()把字符串中第一个字符大写

strname.center(width)返回长度为width的新字符串，原字符串剧中，多余部分用空格填充。

strname.count(pattern,beg=0,end=len(string))返回pattern在strobj中beg和end范围内出现的次数。

strname.maketrans(x,y=None, z=None, /)

encode‘,‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘format_map‘, ‘index‘,‘isalnum‘, ‘isalpha‘, ‘isdecimal‘, ‘isdigit‘, ‘isidentifier‘,‘islower‘, ‘isnumeric‘, ‘isprintable‘, ‘isspace‘, ‘istitle‘,‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, partition‘, ‘replace‘,‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘,‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘,‘translate‘, ‘upper‘, ‘zfill‘

------------------------------------

元祖格式tuple：是容器，顺序访问

元祖是默认的组合类型，也就是可以省略小括号。

用（）括起来，用逗号，隔开。

tuplename=(‘val1‘,‘val2‘,...)

空元祖：tuplename（）

一个元素的元祖：tuplename（‘val1‘，)#需要一个，来区分字符串类型。

元祖是不可变得，不能对元祖元素重新赋值，只能重新赋值定义一个元祖。

dellistname #只能移除整个元祖

__builtins__模块中的内建模块tuple中的内建函数：

tuplename.count(value):获取value在元祖中出现的次数

tuplename.index(value[,start[, stop]])：返回指定范围内value的第一个索引。

------------------------------------

列表格式list：是容器，顺序访问

用[]括起来，用逗号，隔开。

listname=[‘s1‘,‘s2‘,...]

listname[n]= value #列表可以通过索引直接更新列表中的某个元素。

dellistname[n] #根据索引移除元素

dellistname #移除整个列表

直接打印listname是按照列表格式原样输出，列表是可变的。

__builtins__模块中的内建模块list中的内建函数：

listname.count(obj)：返回obj在列表中出现的次数

listname.index(value[,start [, stop]])：返回指定范围内value的第一个索引。

listname.append(‘item‘) #向列表追加元素

listname.remove(value) #移除列表中值为value的元素

listname.insert(index,obj):使得listname[index]=obj.

listname.reverse（）：将翻转后的结果重新赋值给列表

listname.sort():将排序后的结果重新赋值给列表

listname.extend(iterable):将iterable追加到listname后面。

listname.pop([index]):移除并且返回listname[index],默认是最后一个元素。

listname.clear（）：移除列表中的所有元素

listname.copy（）：赋值列表

------------------------------------

字典格式dict：是容器，映射访问

也叫哈希表（hash）。

使用{}括起来，用逗号，隔开，由键和键值组成。

keyname={key1:value1,key2:value2,...}

key是不可变的，value是可变的，可以对value重新赋值。

一个key不能对应多个value，而且key必须是可哈希的。

字典通过key作为下标访问字典元素。

keyname[key]=value#增加键值对或对键值key重新赋值。

deldictname[key] #删除键为key的键值对

deldictname #删除整个字典

__builtins_模块中的内建模块dict中的的内建函数：

dictname.clear（）：清空字典中的所有键值对

dictname.copy（）：复制一个字典

dictname.fromkeys（iterable[,value=http://www.mamicode.com/None]）:以可迭代对象作为字典的键，value作为初始的键值，返回这个新字典。

dictname.items（）：返回由字典中键值对组成的元祖组成的列表

dictname.keys（）：返回由字典中键组成的列表

dictname.values（）：返回由字典中键值组成的列表

dictname.get(key[,d=None])：返回key键对应的键值，否则返回d

dictname.pop（key,[,d]）：返回key键对应的键值，并删除这个键值对，如果key不存在需要指定默认返回值

dictname.popitem（）：以元祖的形式返回一个键值对，并删除这个键值对

dictname.setdefault(key[,d]=Node)：key存在就返回key的键值对，否则新增键值对key=d

dictname.update（[E,] **F）：

------------------------------------

集合：组合类型

1.可变集合set

2.不可变集合frozenset

set()/set(iterable):创建可变集合

frozenset()/frozenset(iterable)：创建不可变集合

objinset/frozenset：判断一个元素是否属于一个集合。

objnotinset/frozenset:判断一个元素是否不属于一个集合。

delset/frozenset :删除集合

集合操作符：

==/ !=等价/不等价

<<=子集

>>=超集

集合运算：

a| b并集

a& b交集

a- b相对补集,得到只属于a，不属于b的元素的集合，也就是a减去a和b的交集。

a^ b对称差分，得到只属于a和只属于b的元素的集合，也就是a和b的交集的补集。

可变集合和不可变集合混合运算，结果和左边的集合类型相同。

__builtins__模块中的内建模块set和内建模块frozenset的共同部分：

a.copy()：赋值集合a。

a.isdisjoint(b)：如果a和b交集为空返回True。

a.issubset（b）：如果a是b的子集返回True。

a.issuperset(b)：如果a是b的超集返回True。

a.union(b)：并集，返回a和b的并集。

a.intersection（b）：交集，返回a和b的交集。

a.difference(b)：相对补集，返回只属于a不属于b的元素。

a.symmetric_difference（b）：对称差分，返回是a或b的元素，但不是a和b交集中的元素的集合。

__builtins__模块中的内建模块set中的内建函数：只适用于可变集合：

set.update(b):将set和b的并集赋给set。

set.intersection_update(b)：将set和b的交集赋给set。

set.difference_update(b)：将set和b的相对补集赋set。

set.symmetric_difference_update（b）：将set和b的对称差分赋给set。

set.add(obj)：将obj追加到集合set中。

set.remove(obj)：将obj从集合set中删除，如果不存在引发KeyError错误。

set.discard(obj)：将obj从集合set中删除，如果不存在忽略。

set.clear()：清空集合

set.pop()：从集合set中弹出任意一个元素，返回这个值并从集合中它。

python数据类型