python 基本数据类型的使用

python的基本数据类型的使用

列表(list)的定义和使用:

//用中括号初始化，使用同数组差不多
li = [1,2,3,4,5]
list 包含的操作函数有:(都是直接在列表中操作的)
list.append(object)                                      在列表的尾部添加元素，可以是任何数据类型
li.extend(iterable)                                      在列表的尾部添加另外一个列表
li.inert(index, object)                                  按照索引号在指定位置添加元素
li.remove(value)                                         移除列表中第一次出现的value
li.sort(cmp=None, key=None, reverse=false)               默认是正向排序，排序顺序是:数字->大写字母->小写字母reverse=True实现反向排序, cmp(x,y)是带两个参数的比较函数，返回值为-1, 0, -1。 key是带一个参数的函数，用来为每个元素提取比较，
li.count(value)                                          统计value在列表中的出现字数
li.index(value, start, stop) 显示value在列表中的索引位置，start-stop表示需要查询的区间，默认是整个列表                             
li.pop(index)                                            删除index索引位置的元素，默认是最后一个，返回值为删除的元素
li.reverse()                                             反向列表中的元素

list.mro()                                               mro函数是类的默认功能，返回类的基类以及基类的基类(return a type's method resolution order)

li.sort(cmp=None, key=None, reverse=False)的具体使用方法:(下面的 reverse 默认是 False,你也可以更改为 True)
hunman = [('pig', 12), ('cat', 2), ('dog', 45)];         设置一个元素为元组的列表
human.sort(cmp = lambda x, y : cmp(x[1], y[1]))          比较元组中的第二个元素进行排序，每次需要比较两个元素
human.sort(key = lambda x : x[0])                        比较元组中的地一个一个元素
/////////////////////////////////////////////////////
列表按照索引的方式读取元素， 正向以 0 开始，反向读取以 -1开始，列表也可以进行分片 list[start:stop] 前闭后开,start 默认是 0， stop默认是最后的位置
list 支持 +， +=， *， *= 操作符
在python3 添加了一个 
list.clear()                                              列表清空函数
list.copy()                                               列表拷贝函数 (help(list.cophy)函数说是浅拷贝，可是为什么我感觉不是呢)

元组(tuple)的定义和使用(元组是不可变的列表，一旦定义就不能增加和删除元组元素)：

//用() 小括号定义
tup = (1, 2, 3)
tuple包含的函数操作:
tup.count(value)                                          统计并返回元素value的数量
tup.index(value, start, stop)                             显示value在元组中的索引位置，start-stop表示要查询的区间，默认是整个元组

//////////////////////////////////////////////
t = (1, )                                                 创建拥有一个元素的元组，需要添加一个逗号哦
元组和列表一样按照索引的方式读取元素，正向以0开始，反向以 -1开始，元组也可以进行分片 tuple[start:stop]前闭后开，start默认是0， stop默认是最后的位置
tuple 支持 +， +=， *， *= 操作。 

字典(dict)的定义和使用:(字典定义了键 - 值之间一一对应的关系，字典类元素之间是无序的)

//用{}花括号定义r
d = {'A':1, 'Cat':'animal'}
d['tree'] = 'plant'                         添加新的元素(一个元素就是一个建值对)
dict包含的函数操作
d.clear()                                   清空字典中的所有元素
d.copy()                                    拷贝返回整个字典
d.fromkeys(d, v)                            返回d字典的键给新的字典，v表示默认的值，没有指定的话就是 None
d.get(k, v)                                 如果 k 是d的键 的话，返回d[k]对应的值，否则返回 v
d.has_key(k)                                如果k是 字典d 的键的话返回True, 否则返回False
d.items()                                   将键-值对以元组的方式组成列表返回
it = d.iteritems()                          返回一个迭代器对象it，it.next()以元组的方式返回键-值对
it = d.iterkeys()                           返回一个指向字典的键的迭代器
it = d.itervalues()                         返回一个指向字典的值的迭代器
d.keys()                                    将字典的键以列表的方式返回
d.pop(key)                                  返回字典的key的值，并删除当前的键-值对
d.popitem()                                 以元组的方式返回键值对并删除当前的键值对
d.setdefault(k, v)                          如果键不在字典k中的话，设置k 对应的值为 v并返回v，如果k在字典中的话返回k对应的值
d.update(Dict)                              用字典Dict更新字典d，没有键的话添加，有的话覆盖
d.values()                                  字典将值以列表的方式返回
d.viewitems()                               将键值对以元组列表的方式返回，类型为dict_item([(),(),()])
d.viewkeys()                                将键对以列表的方式返回，类型为dict_item([])
d.viewvalues()                              将键对以列表的方式返回，类型为dict_item([])
/////////////////////////////////////////////////////////////////
字典的读取只能以字典索引的方式显示
del d[key]                                  用del可以将字典的键值对删除

字符串(str)的定义和使用:(字符串有众多的处理函数)

//用''/""单引号或者双引号定义
s = "This is s string"
 str 包含的函数操作:
str.capitalize()                            返回一个字符串的拷贝
str.center(width[, fillchar])               返回一个长度为 width的字符串，如果width大于str的长度，将str的内容放在中间，两边用 fillchar填充，默认是space;否则返回str
str.count(sub[, start[, end]])              统计sub的数量，start-stop设置查询区间，sub可以是字符串或者字符
str.decode([encoding[, errors]])            encoding设置解码方式，默认是unicode编码
str.encode([encoding[, errors]])            encoding设置编码方式，默认是unicode编码(str.decode('utf-16').encode('utf-8')    按照 utf-16 解码后再以 utf-8 编码)
str.endswith(suffix[, start[, end]])        判断是否以 suffix(字符或者字符串) 结束, 是返回 True, 不是返回 False
str.expandtabs([tabsize])                   将 \t 替换为 spaces 返回新的字符串，tabsize设置\t占的字符
str.find(sub [, start[, end]])              返回sub首次出现的位置，失败返回 -1
str.format(*args, **kwargs)                 格式化字符串的输出:"Th{} is {} te{}".format('is', 'a', 'test') -> This is a test; "Th{1} is {0} te{2}".format('a', 'is', 'st')
                                                                  'A:{0[A]:d};B:{0[B]:d};C:{0[C]:d}'.format({'A':11,'B':12,'C':13})
str.index(sub [, start[, end]])             像str..find()，不过在错误的时候返回 ValueError(值错误)->string not found
str.isalnum()                               判断是不是全为字母或者数字(a-z,A-Z,0-9),是返回True,不是返回False
str.isalpha()                               判断是不是全是字母(A-Z,a-z),返回True/False
str.isdigit()                               判断是不是全为数字(0-9)，   返回True/False
str.islower()                               判断是不是都是小写字符
str.isspace()                               判断是不是都是space\tab.
str.istitle()                               判断是不是标题，就是字符串的每个单词的首字母是不是大写
str.isupper()                               判断是不是所有字符都为大写
str.join(iterable)                          将列表/元组通过 字符串str链接: '-'.join()
str.ljust(width [, fillchar])               类似于 str.center()只不过字符串是在新的字符串的左边
str.lower()                                 将字符串中的大写字母转换我小写字母并返回
str.lstrip([chars])                         去除 空格 (whitespace) 并左对齐，例如:'      This is a test'.lstrip() -> 'This is a test'; 'This is a test'.lstrip('Th')->'is is a test'
str.partition(seq)                          将str 按照 seq 分割为(head, seq, tail),例子: 'This is a test'.partition('is') -> ('Th','is',' is a test')
str.replace(old, new[, count])              将字符串 str中 的 old 替换为 new，替换次数不超过 count
str.rfind(sub [, start[, end]])             和 find一样，只不过是从右边查找
str.rindex(sub [, start[, end]])            和index一样，只不过是从右边查找
str.rjust(width [, fillchar])               类似于center()只不过字符串是在新的字符串的右边
str.rparition(seq)                          类似于str.rparition()只是从左边查找
str.rsplit(seq[, maxsplit])                 对str按照 seq 进行分割，分割次数不超过 maxsplit 次
str.rstrip([chars])                         类似于 lstrip() 只不过是右对齐
str.split(seq[, maxsplit])                  对字符串 str 按照 seq 进行分割，最对不超过 maxsplit次
str.splitlines()                            按照行进行分割，例如: "This\nis\na\ntest".splitlines() -> ['This', 'is', 's', 'test']
str.strip([chars])                          对str进行 lstrip 和 rstrip
str.swapcase()                              对str进行大小写字母的转换
str.title()                                 将字符串转换为标题的格式，就是对每个单词的第一个字母进行大写的转换
str.translate(table[, deletechars])         使用方式:(from string import maketrans; 'This is a test!'.translate(maketrans('this','1234')))  -> T234 34 a 1e41
                                            就是将字符进行替换
s.upper()                                   将字符串转换为大写
s.zfill(width)                              设置新的字符串的宽度为 width，用 0 在左边填充