python常见数据类型

字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串烦人过程其实很简单，只需为变量分配一个值即可。例如：

var = 'Hello World!'

如果要访问上述字符串该如何访问？在python中访问子字符串，最简单的方法可以使用方括号来截取字符串。例如:

var = 'Hello World!'

print "var[0]: ", var1[0]

　执行结果

var1[0]:  H

常用字符串的方法

摘一些重要的字符串方法
 print(st.count('l'))       #str代表关键字，如 "  "  的格式，下同
 print(st.center(50,'#'))   #  居中
 print(st.startswith('he')) #  判断是否以某个内容开头
 print(st.find('t'))
 print(st.format(name='alex',age=37))  # 格式化输出的另一种方式   待定：?:{}
 print('My tLtle'.lower())  #将大写变小写
 print('My tLtle'.upper())  #小写变大写
 print('	My tLtle
'.strip()) #清空换行符和空格等
 print('My title title'.replace('itle','lesson',1)) #改变元素
 print('My title title'.split('i',1)) #以i为分隔符分割一次，以列表形式输出　

字符串的格式化输出

　　占位符

1. %s—string
2. %d—digital
3. %f —float

例如

name = input('name:')
age = input('age:')
salary = input('salary:')
job = input('job:')

if salary.isdigit():#判断像不像整数
    salary = int(salary)#如果像，装换成整数
else:
    exit('must is digit')#退出程序
msg = '''
    ------info is %s------
    name: %s
    age: %s
    salary: %s
    job: %s
    ---------end----------
'''%(name,name,age,salary,job)
print(msg)

输出结果

name:ll
age:22
salary:3000
job:IT

    ------info is ll------
    name: ll
    age: 22
    salary: 3000
    job: IT　

Python isdigit()方法

Python isdigit() 方法检测字符串是否只由数字组成。

语法

str.isdigit()

返回值中不带任何参数，返回结果为 True 和 False 两种情况

实例　

str = "123456"; #输入由数字组成的字符串
print str.isdigit();

str = "this is string example....wow!!!"; #输入字符串
print str.isdigit();

结果

True
False

列表

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

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型。

首先我们创建一个列表

list1 = [1, 2, 3, 4, 5 ]
list2 = ["a", "b", "c", "d","e"]
和字符串一样，列表的索引也是从0开始，从左往右一次类推

在列表中我们可以进行增删改查等操作运算

首先我们定义一个简单列表，并进行访问

>>> list = ['a','b','c','d','e']
>>> list[1]   
'b'
注：这里的 1 就是列表list的下表，访问列表list就是通过访问列表中的下表来进行寻址

上述只是寻找一个元素，如果我们要查找列表中多个元素，这就需要用到切片的功能。例如：

>>> list = ['a','b','c','d','e']
>>> list[1:3] #取下标1至下标3之间的元素，包括1，不包括3，既包左不包右
['b', 'c']
>>> list[1:] #取下标从1开始到最后一个结束之间的元素
['b', 'c', 'd', 'e']
>>> list[:]  #不加下标，默认从0开始到最后一个结束
['a', 'b', 'c', 'd', 'e']
>>> list[1:-1] #取下标1开始到倒数第二个元素结束
['b', 'c', 'd']
>>> list[1::2] #取下标从1开始到最后一个结束，期间每隔2个元素取值，默认相隔1。
['b', 'd']
>>>

添加

append

>>> list = ['a','b','c','d','e']
>>> list
['a', 'b', 'c', 'd', 'e']
>>> list.append('F') #添加元素添加到该列表的最后一个位置
>>> list
['a', 'b', 'c', 'd', 'e', 'F']

insert 

可以指定添加的元素的起始位置

>>> list = ['a','b','c','d','e']
>>> list
['a', 'b', 'c', 'd', 'e']
>>> list.insert(2,"F") #表示强从从b后面插入。
>>> list
['a', 'b', 'F', 'c', 'd', 'e']
>>>

修改

>>> list = ['a','b','c','d','e']
>>> list
['a', 'b', 'c', 'd', 'e']
>>> list[3] = "C"
>>> list
['a', 'b', 'c', 'C', 'e']#可以发现3位置的元素从d换成了C
>>>

删除　

del

>>> list = ['a','b','c','d','e']
>>> del list[1] #指定下标时，表示删除列表中该下标位置的元素
>>> list
['a', 'c', 'd', 'e']
>>> del list #如果什么都没有写，则表示删除该列表
>>> list
<class 'list'>

remove

>>> list = ['a','b','c','d','e']
>>> list.remove('a') #元素删除指定
>>> list
['b', 'c', 'd', 'e']

pop

>>> list = ['a','b','c','d','e']
>>> list.pop() #不指定，默认删除该列表的最后一个元素
'e'
>>> list
['a', 'b', 'c', 'd']
>>> list.pop(1) #也可指定下标，删除该下标对应的元素
'b'
>>> list
['a', 'c', 'd']
>>>　

扩展

>>> list = ['a','b','c','d','e']
>>> list1 = [1,2,3]
>>> list.extend(list1)
>>> list
['a', 'b', 'c', 'd', 'e', 1, 2, 3]
>>>

统计

>>> list=[1,1,1,2,3,4,5,6]
>>> list.count(1)
3
注：取该列表中的相同元素出现的次数

index

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

>>> list = ['a','b','c']
>>> list.index('b')
1
>>>

元组　

• Python的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号，列表使用方括号。
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
• 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

如下:

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

元组只包含一个数据时，需要在元素后面加逗号隔开

tup1 = (50,);

访问元组

元组可以使用下标索引来访问元组中的值，如下实例

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );

print ("tup1[0]: ")
print ("tup2[1:5]: ")

输出结果　

 physics
 (2, 3, 4, 5)　

字典

特性：

• dict是无序的
• key必须是唯一的,所以在字典里没有重复的数据

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

dic = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

字典的访问

把相应的键放入熟悉的方括弧，如下实例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
print ("dict['Name']: ")
print ("dict['Age']: ")

输出结果

dict['Name']:  Zara
dict['Age']:  7

注：如果字典里没有访问的键值，则会访问出错。

增

 dic = {'name':'flash','age':'22','job':'IT','slasry':'8000'}
dic["hobby"] = "girl"

　输出结果　

{'age': '22', 'slasry': '8000', 'hobby': 'girl', 'name': 'flash', 'job': 'IT'}

删除

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

>>> dic = {"name":"flash","age":22,"job":"job"}
>>> dic.pop("name") #指定字典中的键删除对应的值
'flash'
>>> dic
{'age': 22, 'job': 'job'}


>>> dic = {"name":"flash","age":22,"job":"job"}
>>> del dic["name"]
>>> dic
{'age': 22, 'job': 'job'}
>>>


>>> dic = {"name":"flash","age":22,"job":"job"}
>>> dic.popitem()   #随机删除
('age', 22)
>>> dic
{'name': 'flash', 'job': 'job'}

>>> dic = {"name":"flash","age":22,"job":"job"}
>>> dic.clear() #清除字典中的所有元素
>>> dic
{}
>>>

查找

>>> dic = {"name":"flash","age":22,"job":"job"}
>>> "name" in dic  #判断键是否在字典中，如果在，返回True，否则返回False
True
>>> dic.get("name") #查找
'flash'
>>> dic["name"] #方法同get，不同的是此方法如果不在该字典中，就会报错
'flash'

字典的嵌套使用

 mune = {
    "北京":{"昌平":["沙河","辛庄"]},
    "河南":{"郑州":["二七","金河"]},

 }

输出结果

print(mune["北京"]["昌平"][1])  
辛庄

常见操作类型

>>> dic = {"name":"flash","age":22,"job":"job"}
>>> dic.values() #查找值
dict_values([22, 'flash', 'job'])

>>> dic.keys() #查找键
dict_keys(['age', 'name', 'job'])

>>> dic.setdefault("hobby","girl")#如果字典中没有相应的键值，就会添加进去，反之，则不会改变
'girl'
>>> dic
{'hobby': 'girl', 'age': 22, 'name': 'flash', 'job': 'job'}
>>> dic.setdefault("name","ll"
... )
'flash'
>>> dic
{'hobby': 'girl', 'age': 22, 'name': 'flash', 'job': 'job'}
>>>
>>> dic = {"name":"flash","age":22,"job":"job"}
>>> dic1 = {"hobby":"girl"}
>>> dic.update(dic1)  #将字典dic1中的元素更新到字典dic中
>>> dic
{'hobby': 'girl', 'age': 22, 'name': 'flash', 'job': 'job'}
>>>
>>> dic.items()
dict_items([('hobby', 'girl'), ('age', 22), ('name', 'flash'), ('job', 'job')])
>>>

集合

集合是一个无序，不重复的组合。主要功能有去重和功能测试。

具体用法如下

a = set([1,2,3,4])
b = set([3,4,5,6])
#差集
print(a.difference(b)) #取a 中有b 没有的数据{1, 2}
print(b.difference(a)) #取b中有a 没有的数据{5, 6}
print(a - b)
print(b - a)
#反向差集合
print(a.symmetric_difference(b)) #{1, 2, 5, 6}

#并集
print(a.union(b)) #{1, 2, 3, 4, 5, 6}
print(a | b)
#交集
print(a.intersection(b)) #{3, 4}
print(a & b)
#父集，子集
print(a.issuperset(b))#False
print(a > b )
print(a.issubset(b))#False
print(a < b)
a = set([1,2,3,4])
#添加
b = a.add(5)
b = a.update([4,8,6])
#删除
b = a.remove("1")#删除指定一项
b = a.pop()#随机删除一项
del a
print(1 in a)#判断数据在不在集合a中,在返回True，不在返回False
print(1 not in a)#同in 相反

附：另外常见数据类型

•  整数（integer）
  • 分为整型和长整型，在python2中区分，在python3中统一叫做整型
• 复数（complex）
• 浮点数（float）
• 布尔
  • 只有两种状态：真(True)和假(False)
• 字符串

  不可变类型：列表，字典

　可变类型：元组，整型，字符串