title: “python数据类型及其常用方法”
date: 2020-04-21T10:15:44+08:00

可变数据类型:允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象.如 **list,dict,set **

不可变数据类型:不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象。如 **Number,String， Tuple **

list常用方法

增

append()

# append用于在列表末尾追加新的对象
# list.append(obj)
a = [1,2,3]
print(a.append('4'))
# the result ： [1, 2, 3, '4']

extend()

# extend方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b)
print(a)                          
# the result ：[1, 2, 3, 4, 5, 6]

insert()

# insert方法用于将对象插入到列表中
# list.insert(index, obj)
a = [1,2,3]
a.insert(0,'aa')  
print(a)
# the result : ['aa', 1, 2, 3]

删

pop()

# pop方法会移除列表中的一个元素（默认是最后一个），并且(返回)该元素的值,若索引溢出会报错
# list.pop([index=-1])
a = [1,2,3]
print(a.pop())
	# the result : 3
print(a)
	# the result : [1,2]

remove()

# remove方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa']
a.remove('aa')  
print(a)
# the result ： ['bb', 'cc', 'aa']

改

reverse()

# reverse方法将列表中的元素反向存放
a = ['a','b','c']
a.reverse()                         
print(a)
# the result ： ['c', 'b', 'a']

sort()

# sort方法用于在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列
# list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对			象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
    
def takeSecond(elem):
    return elem[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond,reverse=True)
print (random)
# the result ： [(3, 4), (1, 3), (2, 2), (4, 1)]

查

count()

# count方法统计某个元素在列表中出现的次数
a = ['aa','bb','cc','aa','aa']
print(a.count('aa'))                 
# the result ： 3

index()

# index函数用于从列表中找出某个值第一个匹配项的索引位置,匹配范围内没有则报错,需要注意的是end值为左闭右开区间
# list.index(x[, start[, end]])
a = [1,2,3,1]
print(a.index(1))
print(a.index(3,1,3))
# the result ： 0
# the result ： 2

enumerate()

# 带索引的遍历
# enumerate(sequence, [start=0])
# sequence -- 一个序列、迭代器或其他可迭代对象。
# start -- 下标起始位置,可选参数,默认为0。
li = [11,22,33]
for k,v in enumerate(li):
    print(k,v)
    	# 0 11
		# 1 22
        # 2 33
print(list(enumerate(li,8)))
	#[(8, 11), (9, 22), (10, 33)]

Dict常用方法

增

fromkeys()

#dict.fromkeys(seq[, value])
seq = ('Google', 'Runoob', 'Taobao')
dict = dict.fromkeys(seq,1)
print(dict)
	# {'Google': 1, 'Runoob': 1, 'Taobao': 1}

zip()

# 将两个列表组合成字典
keys = ['a', 'b']
values = [1, 2]
print(dict(zip(keys,values)))                                     
	# {'a': 1, 'b': 2}

相反,zip()作用于字典,会创建一个**只能访问一次的迭代器 **

可以思考–怎样在数据字典中执行一些计算操作(比如求最小值、最大值、排序等等)？

#考虑下面的股票名和价格映射字典：
prices = {'ACME': 45.23,'AAPL': 612.78,'IBM': 205.55,'HPQ': 37.20,'FB': 10.75}
#为了对字典值执行计算操作,通常需要使用zip()函数先将键和值反转过来.
#下面是查找最小和最大股票价格和股票值的代码：
min_price = min(zip(prices.values(), prices.keys()))
    # min_price is (10.75, 'FB')
max_price = max(zip(prices.values(), prices.keys()))
    # max_price is (612.78, 'AAPL')
#类似的，可以使用zip() 和sorted() 函数来排列字典数据：
prices_sorted = sorted(zip(prices.values(), prices.keys()))
# prices_sorted is [(10.75, 'FB'), (37.2, 'HPQ'),(45.23, 'ACME'), (205.55, 'IBM'),(612.78, 'AAPL')]
执行这些计算的时候，需要注意的是zip() 函数创建的是一个只能访问一次的迭代器。比如，下面的代码就会产生错误：
prices_and_names = zip(prices.values(), prices.keys())
print(min(prices_and_names)) # OK
print(max(prices_and_names)) # ValueError: max() arg is an empty sequence
#字典值相同，键不同，比较值的大小
prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }
min(zip(prices.values(), prices.keys()))
	#(45.23, 'AAA')
max(zip(prices.values(), prices.keys()))
    #(45.23, 'ZZZ')

删

clear()

# clear方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回None）
d = {'name':"tom"}
d.clear()
print(d)                                   
	#the result : {}

改

pop()

# 删除字典给定键 key 及对应的值，返回值为被删除的值
d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v)
	# 8777
print(d)
	# {'Jack': 8888, 'Fly': 6666}

update()

# update方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666}
a = {'Tom':110,'Test':119}
d.update(a)
print(d)                                       
	#the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}

查

get()

# get方法是个更宽松的访问字典的方法，如果试图访问字典中不存在的项时不会报错,仅会返回：None
d = {'Tom':8777,'Jack':8888,'Fly':6666}
print(d.get('Tom'))                              
	#the result :8777
print(d.get('not_exist'))                       
	#the result:None

item()

# dict.items()返回可遍历的(键, 值) 元组数组。
dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com'}
print (dict.items())
	# dict_items([('Google', 'www.google.com'), ('Runoob', 'www.runoob.com')])

由此引出遍历字典的三种方法

for k,v in d.items():
    print(k,v)
for k in d.values():
    print(k)
for k in d.keys():
    print(k)

set常用方法

list_1 = [1,2,3,4,5,1,2]

list_2 = [4,5,6,7,8]

去重

print(set(list_1))
	# {1, 2, 3, 4, 5}
print(list_1)
	# [1, 2, 3, 4, 5, 1, 2]

交集

print(set(list_1).intersection(set(list_2)))                    
	# {4, 5}

并集

print(set(list_1).union(set(list_2)))
	# {1, 2, 3, 4, 5, 6, 7, 8}

差集

# 在list_1中有在list_2中没有
print(set(list_1).difference(set(list_2)))
	# {1, 2, 3}

str常用方法(不可变)

find(),rfind()

# find方法可以在一个较长的字符串中查找子串，他返回子串所在位置的最左端索引，如果没有找到则返回-1
a = 'abcdefghijk'
print(a.find('abc'))
	#the result ： 0
print(a.find('abc',10,100))                           
	#the result ： -1  指定查找的起始和结束查找位置
# rfind方法类似,是从后往前找

join()

# 返回一个字符串,是split方法的逆方法，用来连接序列中的元素，并且需要被连接的元素都必须是字符串。
a = ['1','2','3']
print('+'.join(a))                                    
	#the result ： 1+2+3

split()

# split是join的逆方法，用来将字符串分割成序列
print('1+2+3+4'.split('+'))                          
	#the result ： ['1', '2', '3', '4']

strip()

# strip 方法返回去除首位空格（不包括内部）的字符串
print("   test   test    ".strip())                  
	#the result ：“test   test”

replace()

# replace方法返回某字符串所有匹配项均被替换之后得到字符串
print("This is a test".replace('is','is_test'))     
	#the result ： This_test is_test a test