python基本数据类型汇总

python基本数据类型

    

1、字符串(string)

定义字符串：str1="abcdefgh" ; str2='jkdjs'

python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

若是你要实现从字符串中获取一段子字符串的话，可使用变量 [头下标:尾下标]，就能够截取相应的字符串，其中下标是从 0 开始算起，能够是正数或负数，下标能够为空表示取到头或尾。s = 'ilovepython',s[1:5]的结果是love

一、字符串运算符

    +字符串链接

    *重复输出字符串

    []经过索引获取字符串中字符  >>>a[1]

    [ : ]截取字符串中的一部分      >>>a[1:4]

    in  成员运算符 - 若是字符串中包含给定的字符返回 True

    not  in成员运算符 - 若是字符串中不包含给定的字符返回 True

    %       格式字符串

二、字符串格式化

print ('小明今年%s岁' % 10)

字符串格式化元组|字典

若是使用列表或者其余序列代替元组，序列会被解释成一个值.

'%s 今年%s岁' % ('小明','10')

字符串格式化字典

dict={"age":"11"}

print('年龄：%(age)'%dict)

高级格式化

一、字符宽度

  %10f ，字符不够字符最前端保留剩余宽度

二、字符串精度获取

   %.5s ,打印字符串前5个字符

三、符号、对齐、0填充

   A） 0填充： %010.2f ,结果：0000003.14

   

   B） -左对齐，+右对齐 ：%-10.2f |%+10.2f

   C) + 表示正数或负数都显示出数字前面的符号（-10|+10）.

三、内置方法

str.count(sub[, start[, end]])

    返回范围[ start，end ] 中子字符串子不重叠的次数。可选参数start和end解释为切片表示法

str.decode([encoding[,errors]])

    将字符串的编码版本做为字节对象返回。默认编码为'utf-8'

str.endswith(suffix[, start[, end]])

    返回True若是字符串以指定的后缀结尾，不然返回 False。 后缀也能够是一个元组的后缀来寻找

str.find(sub [sub,start [,end]]) 

    返回字符串中的最小索引，其中substring 子在切片中找到s[start:end]。可选参数start和end解释为切片表示法。若是没有找到sub返回-1

str.format(sub [,start [,end]])

    格式化字符串

str.isalnum(...)

    若是字符串中的全部字符都是字母数字且至少有一个字符，则返回true，不然返回false

str.isalpha(...)

    若是字符串中的全部字符都是字母而且至少有一个字符，则返回true，不然返回false

str.islower(...)

    若是字符串中全部包含字符为小写，而且至少有一个套接字符，则返回true，不然返回false

istitle(...)

    开头字母是否为大写

isupper(...)

    字符串是否为大写

str.join(...)

    返回一个字符串，它是可迭代 迭代中字符串的链接

str.ljust(...)

    返回字符串左对齐的长度宽度的字符串。填充使用指定的fillchar

lower(...)

    返回一个字符串的副本，全部包含字符转换为小写

lstrip(...)

    返回带有前导字符的字符串的副本。chars 参数是一个字符串，指定要删除的字符集。若是省略或None，chars参数默认为删除空格

str.partition（sep ）

    拆分sep的第一次出现的字符串，并返回包含分隔符以前的部分，分隔符自己和分隔符后面的部分的3元组。若是找不到分隔符，则返回包含字符串自己的3元组，后跟两个空字符串

rfind(...)

    从字符串的右侧开始查找

rindex(...)

    返回字符串的索引位置，从字符的右边开始

str.rjust(...)

    返回字符串右对齐的长度宽度的字符串。填充使用指定的fillchar

rstrip(...)

    删除字符串的右边空格

str.split（sep = None，maxsplit = -1 ） 

    返回字符串中的单词列表，使用sep做为分隔符字符串。若是给出了maxsplit，则最多会执行maxsplit拆分（所以，列表最多只能有maxsplit+1元素）。若是未指定maxsplit或-1，对拆分数量没有限制（进行全部可能的拆分）。

splitlines([ keepends ])   返回字符串中的行的列表，在行边界处断开。换行符不包括在结果列表中，除非keepends为true和true

str.strip（[ chars ] ） 

    返回字符串的前导和尾随字符删除的副本。chars参数是一个字符串，指定要删除的字符集。若是省略或None，chars参数默认为删除空格。该字符参数不是前缀或后缀; 相反，它的值的全部组合被剥离

upper(...)

    将字母转换为大写

title(...)

    首字母大写,其他小写

str.capitalize()

    首字母大写,其他字母小写

str.replace('','')

    若是字符串中只有空格字符，而且至少有一个字符，则返回true，不然返回false

str.isprintable()

    若是字符串中的全部字符均可打印或字符串为空，则返回true，不然返回false

str.zfill（width ）

    返回一个字符串的副本，填充ASCII '0'数字，以造成一个长度为width的字符串

str.join(...)

    在队列中添加元素，是split的逆方法

字符串汇总整理：

  通常字符串,执行一个功能，生成一个新内容，原来内容不变

list,tuple,dict执行一个功能，自身发生变化

2、列表(list)

列表list，是一种容器，能够包含任意有序集合，可变对象

支持异构:同一个对象中能够存数字，字符串多种数据类型

列表能够完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至能够包含列表（所谓嵌套），数据项不须要具备相同的类型

列表中的值得分割也能够用到变量[头下标:尾下标]，就能够截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标能够为空表示取到头或尾。

加号（+）是列表链接运算符，星号（*）是重复操做

成员关系判断:  in   not in

定义列表: alis=['a','c','b','a','e','r','t','q']

运算符：加号（+）是列表链接运算符，星号（*）是重复操做

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

Python有6个序列的内置类型，但最多见的是列表和元组。

序列均可以进行的操做包括索引，切片，加，乘，检查成员。

此外，Python已经内置肯定序列的长度以及肯定最大和最小的元素的方法。

一、列表函数

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

len(list)              列表元素个数

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

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

list(seq)            将元组转换为列表

二、内置函数

count(obj)

    统计某个元素在列表中出现的次数

extend(seq)

    在列表末尾一次性追加另外一个序列中的多个值（用新列表扩展原来的列表）

index(obj)

    index 索引 从列表中找出某个值第一个匹配项的索引位置

insert(index,obj)

    在某个索引后面追加 值，将对象插入列表

pop(...)

    根据索引查询list的值 若是不传参数 默认取list的最后一个值

remove(...)

    remove 删除 [删除指定的值remove(\'须要移除的值\') ]

reverse(...)

    反转，反向列表中元素

sort(...)

    排序

append(...)     

    append 追加 [追加在list列表的最后]

copy(...)

    复制，deepcopy 深度复制

4、元组(tuple)

元组是另外一个数据类型，相似于List（列表）。

元组用"()"标识。内部元素用逗号隔开。可是元组不能修改，至关于只读列表。

元组与字符串相似，下标索引从0开始，能够进行截取，组合等

元组是不容许更新的。而列表是容许更新的

一、内置函数

count(...)

    返回元组成员个数

index(...)

    返回某个成员在元组的偏移位置

cmp(tuple1, tuple2)   

    比较两个元组元素。

len(tuple)    

    计算元组元素个数

max(tuple)    

    返回元组中元素最大值

min(tuple)  

    返回元组中元素最小值

tuple(seq)  

    将列表转换为元组

4、字典(Dictionary)

字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。

二者之间的区别在于：字典当中的元素是经过键来存取的，而不是经过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

字典 dict:  [key:vlues] | ---{"x":"1","y":"2"}

工厂函数 dict:  dict(zip('x','y'),('1','2')) 

zip函数 将两个列表合并起来，成为一个元组的列表，当两个列表不同长的时候，多余的会被忽略

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

一、字典类型与序列类型的区别：

    1.存取和访问数据的方式不一样。

    2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；

    3.映射类型能够用其余对象类型做键（如：数字、字符串、元祖，通常用字符串做键），和序列类型的键不一样，映射类型的键直

    4.直接或间接地和存储数据值相关联。

    5.映射类型中的数据是无序排列的。这和序列类型是不同的，序列类型是以数值序排列的。

    6.映射类型用键直接“映射”到值。

    7.键必须是惟一的，但值则没必要

特色：

一、键与值用冒号“：”分开；

二、项与项用逗号“，”分开；

三、字典中的键必须是惟一的，而值能够不惟一

二、定义字典

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

三、访问字典里的值

print dict['Alice']

dict['Beth']

四、修改字典

dict['Age'] = 8

五、删除字典元素

del dict['Name']; # 删除键是'Name'的条目

dict.clear();     # 清空词典全部条目

del dict ;        # 删除词典

六、字典内置函数

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

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

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

type(variable)   返回输入的变量类型，若是变量是字典就返回字典类型

iter(dict)对字典中的键，值或项（表示为元组）返回一个迭代器 。(key, value)

七、内置函数

iteritems(...)       迭代字典对象

iterkeys(...)        迭代字典全部key

itervalues(...)     迭代字典全部value

keys(...)           返回字典全部的keys

pop(key [，default ])

    若是key在字典中，删除它并返回其值，不然返回 默认值。若是未给出默认值，而且键不在字典中，KeyError则引起a

popitem(...)

    从字典中删除并返回任意对。(key, value) \ popitem()对于在集合算法中常用的字典进行破坏性迭代是有用的。若是字典是空的，调用 popitem()引起一个KeyError。

values(...)

    返回字典全部的values

radiansdict.clear()                   

    删除字典内全部元素

radiansdict.copy()                     

    返回一个字典的浅复制

radiansdict.fromkeys()                 

    建立一个新字典，以序列seq中元素作字典的键，val为字典全部键对应的初始值

radiansdict.get(key, default=None)     

    返回指定键的值，若是值不在字典中返回default值

radiansdict.has_key(key)        

    若是键在字典dict里返回true，不然返回false

radiansdict.items()             

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

radiansdict.keys()              

    以列表返回一个字典全部的键

radiansdict.setdefault(key, default=None)    

    和get()相似, 但若是键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)        

    把字典dict2的键/值对更新到dict里

radiansdict.values()             

    以列表返回字典中的全部值

5、切片

    A、字符串切片

        str = 'Hello World!'

        print str           # 输出完整字符串

        print str[0]        # 输出字符串中的第一个字符

        print str[2:5]      # 输出字符串中第三个至第五个之间的字符串

        print str[2:]       # 输出从第三个字符开始的字符串

        print str * 2       # 输出字符串两次

        print str + "TEST"  # 输出链接的字符串

    B、列表切片        

        list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

        tinylist = [123, 'john']

        print list               # 输出完整列表

        print list[0]            # 输出列表的第一个元素

        print list[1:3]          # 输出第二个至第三个的元素 

        print list[2:]           # 输出从第三个开始至列表末尾的全部元素

        print tinylist * 2       # 输出列表两次

        print list + tinylist    # 打印组合的列表

    

    C、元组切片

        tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

        tinytuple = (123, 'john')

        print tuple               # 输出完整元组

        print tuple[0]            # 输出元组的第一个元素

        print tuple[1:3]          # 输出第二个至第三个的元素 

        print tuple[2:]           # 输出从第三个开始至列表末尾的全部元素

        print tinytuple * 2       # 输出元组两次

        print tuple + tinytuple   # 打印组合的元组

6、数据类型转换

    int(x [,base])           将x转换为一个整数

    long(x [,base] )         将x转换为一个长整数

    float(x)                 将x转换到一个浮点数

    complex(real [,imag])    建立一个复数

    str(x)                   将对象 x 转换为字符串

    tuple(s)                 将序列 s 转换为一个元组

    list(s)                  将序列 s 转换为一个列表

    set(s)                   转换为可变集合

    dict(d)                  建立一个字典。d 必须是一个序列 (key,value)元组。

    frozenset(s)             转换为不可变集合

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