python有序的数据类型_Python基础之数据类型

一、字符串

定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，' '或" "中间包含的内容称之为字符串

特性：

1.只能存放一个值

2.不可变

3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

补充：

1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'lthf'

2.unicode字符串与r连用必需在r前面，如name＝ur'lthf'

字符串的创建：

"hello world"

字符串常用操作：

1、移除空白：

name = " michael,egon,jack"

print(name.strip()) #去掉行头和尾部的空格

"michael,egon,jack" #输出结果

2、分割：

name = "michael,egon,jack"

print(name.split(",")) #分割，以","为分隔符把一个字符串分割成列表

['michael', 'egon', 'jack'] #输出结果

3、长度：

name = "michael,egon,jack"

print(len(name)) #统计字符串的长度

17 #输出结果

4、索引：

name = "michael,egon,jack"

print(name.index("a")) #索引

4 #输出结果，找到第一个对应的值的下标返回值

5、切片：

name = "michael,egon,jack"

print(name[0:7]) #取出第一个名字，就是在[]里以":"分割左右分别写出元素对应的下标，默认从左往右取。记住“顾头不顾尾”

michael #输出结果

print(name[8:12]) #取出第二个名字

egon #输出结果

print(name[-4:]) #取出最后一个名字，从后面往前面数元素的下标，有几个元素，就写-(几个) 注意：要记住“顾头不顾尾”

jack #输出结果

6、步长：

string[start:end:step]的序列切片中，第一个“:”隔离了 起始索引 和 结束索引，第二个“：”隔离了 结束索引 和 步长

step为正，则从左到右切片，如果start > end，则为空

step为负，则从右到左切片，如果start < end，则为空

start和end非同时为空，前者表示最开始的一个位，后者表示一直到最后一个，同时为空的时候，表示取所有。至于方向，还是取决于step的值。

可以总结一句规律：step为正表示从左到右切片，反之为从右到左，然后根据index依次切片。

name = "michael,egon,jack"

print(name[::3]) #取所有，step为3

mhlg,c #输出结果

print(name[12:3:-3]) #取索引3---12的元素，从右到左切片step为3 注意：记住“顾头不顾尾”

,gl #输出结果

二、列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

特性：

1.可存放多个值

2.可修改指定索引位置对应的值，可变3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

列表的创建：

list_test=[’afg‘,12,'ok']

或

list_test=list('abc')

或

list_test=list([’afg‘,12,'ok'])

列表的常用操作：

1、索引：

names = ["michael","egon","jack","alex","tom"]

print(names.index("jack")) #检索“jack”的下标值

2 #输出结果

2、切片：

names = ["michael","egon","jack","alex","tom"]

print(names[0:4])#通过下标找出列表中的元素0---3给切出来

['michael', 'egon', 'jack', 'alex'] #输出结果

3、追加：

names = ["michael","egon","jack","alex","tom"]

names.append("rose") #追加内容

print(names) #输出列表names

['michael', 'egon', 'jack', 'alex', 'tom', 'rose'] #输出结果，最后一个位追加的内容

还有一种追加的方式：insert() 函数用于将指定对象插入列表的指定位置。

注意：该方法没有返回值，但会在列表指定位置插入对象。

names = ["michael","egon","jack","alex","tom"]

names.insert(2,"jerry") #可以在指定位置添加元素，因为没有返回值，所以此时不用打印输出

print(names) #打印输出结果

['michael', 'egon', 'jerry', 'alex', 'jack', 'tom'] #输出结果

4、删除：

第一种方法：pop() 函数用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值。

names = ["michael","egon","jack","alex","tom"]

print(names.pop(3)) #删除，指定删除下标位为3的元素

alex #输出结果

print(names.pop()) #默认删除最后一个

tom #输出结果

第二种方法：remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

names = ["michael","egon","jack","alex","tom","egon"]

print(names.remove("egon")) #删除egon，匹配列表中第一个对应的元素，后面的不会影响

None #输出结果

print(names.remove("rose")) #删除rose，因为列表没有这个元素，so，会报错“rose”没在列表中

print(names) #输出删除后的names的值

['michael', 'jack', 'alex', 'tom', 'egon'] #输出的结果

第三种方法：使用 del 语句来删除列表的的元素。

names = ["michael","egon","jack","alex","tom",'egon']

del names[3:5] #实际删除下标位3到5的元素，注意：最后一个5删不了，记住“顾头不顾尾”

['michael', 'egon', 'jack', 'egon'] #输出结果

del names[-3:] #删除倒数第三至最后一个

['michael', 'egon', 'jack'] #输出结果

还有一种 clear() 函数用于清空列表，该方法没有返回值，类似于del list[:]。

names = ["michael","egon","alex","jack","tom"]

names.clear() #清空列表names

print("清空后的列表:",names) #输出打印结果

清空后的列表: [] #注意：此时列表names里的元素被清空了，但是列表names还是存在的

5、长度：

len() 方法返回列表元素个数。

names = ["michael","egon","jack","alex","tom"]

print(len(names)) #统计列表的元素个数

5 #输出结果

6、循环：

第一种：这个迭代names,并且每次迭代取names的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]

for i in names:

print(i)

michael #以下这几个都是列表里的值

egon

jack

alex

tom

第二种：这个也是类似,只是每次迭代取索引的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]

for i in range(len(names)):

print(i,names[i])

0 michael

1 egon

2 jack

3 alex

4 tom

总结：这两种用起来区别不大,用第一个的话是用不到索引的时候用,后面这个是用到索引的时候用,其他的实际用那个看个人需求了。

7、包含：在python中可以通过in和not in关键字来判读一个list中是否包含一个元素。

names = ["michael","egon","jack","alex","tom"]

if "michael" in names: #判断“michael”是否在names列表里

print("%s in the names"%("michael")) #在的话，打印输出结果

if "rose" not in names: #判断“rose”是否在names列表里

print("%s is not in the names"%("rose")) #不在的话，打印输出结果

michael in the names #输出结果

rose is not in the names #输出结果

三、元组

定义：与列表类似，只不过［］改成()。

特性：

1、可存放多个值

2、不可变

3、按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的创建： (注意：元组中只包含一个元素时，需要在元素后面添加逗号)

ages = (11, 22, 33, 44, 55)

或

ages = tuple((11, 22, 33, 44, 55))

print(ages)

(11, 22, 33, 44, 55) #输出结果

a = (11,) #只有一个元素的时候，后面要加“,”标识

print(a)

(11,) #输出结果

元组常用操作：

1、索引：

ages = (11,22,33,"a","b","c")

print(ages.index("a")) #索引"a"元素的下标

3 #输出结果

2、切片：

ages = (11,22,33,"a","b","c") #注意：在取值的时候一定要记住“顾头不顾尾”

print(ages[:3]) #取元组的最开始到下标索引为2的元素

(11, 22, 33) #输出结果

print(ages[2:4]) #取下标索引为2到3的元素

(33, 'a') #输出结果

print(ages[-3:]) #取元组的后三个元素

('a', 'b', 'c') #输出结果

print(ages[-3:-1]) #取从元组的倒数第三个元素开始取到倒数第一个(不包含最后一个)

('a', 'b') #输出结果

3、循环：

同上列表的循环

4、长度

len() 方法返回元组元素个数。

ages = (11,22,33,"a","b","c")

print(len(ages)) #统计元组元素的个数

6 #输出结果

5、包含：(同列表一样)

ages = (11,22,33,"a","b","c")

if 22 in ages: #判断22是否在names列表里

print("%s in the ages"%(22)) #在的话，打印输出结果

if "e" not in ages: #判断“e”是否在names列表里

print("%s is not in the names"%("e")) #不在的话，打印输出结果

22 in the ages #输出结果

e is not in the names #输出结果

6、删除：

ages = (11,22,33,"a","b","c")

del ages #删除元组

print(ages) #打印输出元组

NameError: name 'ages' is not defined #输出报错，此元组不存在

四、字典

定义：字典是另一种可变容器模型，且可存储任意类型对象。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

｛key1:value1,key2:value2｝,key-value结构，key必须可hash

特性：

1.可存放多个值

2.可修改指定key对应的值，可变

3.无序

字典的创建：

person = {"name": "michael", 'age': 18}

person = dict(name='michael', age=18)

person = dict({"name": "michael", 'age': 18})

person = dict((['name','michael'],['age',18]))

{}.fromkeys(seq,100) #不指定100默认为None

注意：

dic = {}.fromkeys(["k1","k2"],11) #创建字典dic

{'k1': 11, 'k2': 11} #输出结果

字典的常用操作：

len(d)返回d中项(键-值对)的数量；

d[k]返回关联到k上的值；

d[k]=v将值v关联到键k上；

del d[k]删除键为k的项；

k in d检查d中是否有含键为k的项。

1、clear

clear方法清除字典中所有的项，这是个原地操作，无返回值(或者说返回none)。

dic = {"k1":"v1","k2":"v2","k3":"v3"}

dic.clear() #清空字典

print(dic) #打印输出

{} #输出结果

2、cope

copy方法返回一个具有相同键-值对的新字典(这个方法实现的是浅复制，因为值本身是相同的，而不是副本)

在副本中替换值时，原始字典不受影响，但是如果修改了某个值，原始字典会改变。

>>> x = {'a':1,'b':[2,3,4]}

>>> y = x.copy()

>>> y['a'] = 5 #替换key对应value值

>>> y['b'].remove(3) #修改了“b”对应的value值

>>> y

{'a':5,'b':[2,4]} #被修改的字典

>>> x

{'a':1,'b':[2,4]} #原字典输出的结果，替换的值没变，修改的变了

避免这个问题的方法是使用深度复制-deepcopy()，复制其包含所有的值。

>>> x = {'a':1,'b':[2,3,4]}

>>> y = x.copy()

>>> z = x.deepcopy() #x深cope成z

>>> x['a'].append(5) #对原文件进行操作

>>> y

{'a':1,5,'b':[2,3.4]} #浅cope的值发生了改变

>>> z

{'a':1,'b':[2,3,4]} #深cope的值没有发生改变

3、get：

get方法是个更宽松的访问字典项的方法。当使用get访问一个不存在的键时，会得到None值。还可以自定义“默认”值，替换None。

>>> d = {}

>>> print d.get('name') #默认为None

None

>>> d.get("name",'N/A') #自定义为'N/A'

'N/A'

>>> d[''name] = 'Eric' #给字典d赋值

>>> d.get('name') #当键存在，输出键对应的值

'Eric' #输出结果

4、has_key

has_key方法可以检查字典中是否含有给出的键。d.has_key(k)

>>> d = {}

>>> d.has_key('name')

False

5、items和iteritems

items方法将所有的字典项以列表方式返回，但是列表中的每一项(键,值)返回时并没有特殊的顺序。

iteritems方法的作用大致相同，但是会返回一个迭代器对象而不是列表：

>>> d = {'a':1,'b':2,'c':3}

>>>d.items

[('a',1),('b',2),('c',3)]

>>> it = d.iteritems()

>>> it

>>> list(it)

[('a',1),('b',2),('c',3)]

6、pop

pop方法用来获得对应给定键的值，然后将这个键-值对从字典中移除。

>>> d = {'a':1,'b':2,'c':3}

>>> d.pop('a') #删除a及对应的值

>>> d

{'b':2,'c':3} #输出结果

7、popitem

popitem方法会弹出随机项，并没有顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效了。

>>> d = {'a':1,'b':2,'c':3}

>>> d.popitem() #随机删除一个键、值

>>> d

{'a':1,'c':3} #输出结果

8、setdefault

setdefault方法在某种程度上类似于get方法，就是能够获得与给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值。

>>> d = {}

>>> d.setdefault('name','N/A')

'N/A'

>>> d

{'name': 'N/A'}

>>> d.setdefault('name',A)

'N/A'

9、update

update方法可以利用一个字典项更新另一个字典。提供的字典项会被添加到旧的字典中，若有相同的键则会进行覆盖。

>>> d = {'a':1,'b':2,'c':3}

>>> x = {'a':5,'d':6}

>>> d.update(x)

>>> d

{'a': 5, 'c': 3, 'b': 2, 'd': 6} #遇到相同的键会覆盖对应的value的值

10、values

values方法以列表的形式返回字典中的值(itervalues返回值的迭代器)，与返回键的列表不同的是，返回值列表中可以包含重复的元素。

>>> d = {}

>>> d[1]=1

>>> d[2]=2

>>> d[3]=3

>>> d[4]=1

>>> d

{1: 1, 2: 2, 3: 3, 4: 1}

>>> d.values()

[1, 2, 3, 1] #值可以重复

五、集合

定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key

基本功能：是进行成员关系测试和删除重复元素。

特性：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合分类：可变集合、不可变集合

可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素

不可变集合(frozenset)：与上面恰恰相反

集合的创建：

由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建

{1,2,3,1}

或

定义可变集合set

>>> set_test=set('hello')

>>> set_test

{'l', 'o', 'e', 'h'}

改为不可变集合frozenset

>>> f_set_test=frozenset(set_test)

>>> f_set_test

frozenset({'l', 'e', 'h', 'o'})

访问集合：

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})

print("Tom" in student) #判断“Tom”是否在集合student中

True #真，在集合student里

print("Egon" in student) #判断“Egon”是否在集合student中

False #假，不在集合student里

for i in student: #循环输出集合student中的所有元素

print(i) #以下是输出结果

Mary

Jim

Tom

Jack

Rose

集合常用操作：关系运算

1、in 和 not in：

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})

print(student) # 输出集合，重复的元素被自动去掉

{'Mary', 'Rose', 'Tom', 'Jim', 'Jack'} #输出结果

# 成员测试

if('Rose' in student) :

print('Rose 在集合中')

else :

print('Rose 不在集合中')

2、等于(==)和不等于(!=):

a = {1,2,3}

b = {1,2,3,4,5}

print(a == b)

False

print(a != b)

True

3、大于(>)与小于(=)于小于等于(<=)：注意：小于(用函数表示 .issubset()) 大于(用函数表示 .issuperset())

a = {1,2,3}

b = {1,2,3,4,5}

print(a <= b) #判断a小于或等于b

True

print(a < b) #判断a小于b

print(a.issubset(b)) #a是b的子集

print(b.issuperset(a)) #b是a的超集

True

print(a >= b) #判断a大于或等于b

False

print(a > b) #判断a大于b

False

4、交集：intersection()，简写符(&)

a = {1,2,3}

b = {1,2,3,4,5}

print(a.intersection(b)) #交集

print(a & b) #交集的简写

{1, 2, 3} #输出a与b的交集

5、并集：union()，简写符( | )

a = {1,2,3}

b = {1,2,3,4,5}

print(a.union(b)) #并集 两个合在一起

print(a | b) #并集的简写

{1, 2, 3, 4, 5} #输出a与b的并集

6、差集：difference()，简写符(-)

a = {1,2,3}

b = {1,2,3,4,5}

print(a.difference(b)) #差集 a相对于b不一样的打印出a有b没有的

print(a - b) #差集的简写

set() #因为a不包含b，so，为空

print(b.difference(a)) #差集 b相对于a不一样的打印出b有a没有的

print(b - a) #差集的简写

{4, 5} #打印出相差的部分

7、对称差分：symmetric_difference()，简写符(^)

a = {1,2,3,6,7}

b = {1,2,3,4,5}

print(a.symmetric_difference(b)) #对称差分 把a和b中不在的都打印出来

print(a ^ b) #对称差分的简写

{4, 5, 6, 7} #输出结果

注意：集合之间and,or

a = {1,2,3,6,7}

b = {1,2,3,4,5}

print(a and b) #取b的值

{1, 2, 3, 4, 5}

print(a or b) #取a的值

{1, 2, 3, 6, 7}

8、子集和超集： .issubset()  和  .issuperset()

a = {1,2,3}

b = {1,2,3,4,5}

print(a.issubset(b)) #a是b的子集 ，是真为True，反之亦然。

True

print(a.issuperset(b)) #b是a的超集， 是假为False，反之亦然。

False

集合更新：

可使用以下内建方法来更新：注意：只有可变集合才能更新。

a.add()

a.update()

a.remove()

a.discard()

a.pop()

a = {1,2,3,6,7}

a.add(8) #在集合a里添加一个元素“8”

print(a) #打印输出

{1, 2, 3, 6, 7, 8} #输出结果

a = {1,2,3,6,7}

c = {6,,7,8,9}

a.update(c) #更新a集合，将c集合的元素添加到a中，注意：集合是天然去重的。

print(a)

{1, 2, 3, 6, 7, 8, 9}

a = {1,2,3,6,7}

a.remove(6) #移除集合a中的元素“6”，如果被移除的元素不存在时，会报错。

print(a)

{1, 2, 3, 7}

a = {1,2,3,6,7}

a.discard(9) #删除指定元素，但是如果要删除的不在集合里不会报错。

print(a)

{1, 2, 3, 7}

a = {1,2,3,6,7}

print(a.pop()) #随机删除

1 #随机删除的结果