python基本数据类型

Posted 2020-09-08

python基本数据类型

    

1、字符串

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

    %        格式字符串

内置函数

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的逆方法

2、列表

列表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 深度复制

3、元组

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

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

元组与字符串类似，下标索引从0开始，可以进行截取，组合等

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

内置函数

count(...)

    返回元组成员个数

index(...)

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

cmp(tuple1, tuple2)   

    比较两个元组元素。

len(tuple)    

    计算元组元素个数

max(tuple)    

    返回元组中元素最大值

min(tuple)  

    返回元组中元素最小值

tuple(seq)  

    将列表转换为元组

4、字典

字典(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.键必须是唯一的，但值则不必

特点：

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

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

3、字典中的键必须是唯一的，而值可以不唯一

创建字典

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(...)

itervalues(...)

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)                   将一个整数转换为一个字符