python常见数据类型及操作方法

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

巴特西

python常见数据类型及操作方法

list常用方法

增

append()

extend()

insert()

删

pop()

remove()

改

reverse()

sort()

查

count()

index()

enumerate()

Dict常用方法

增

fromkeys()

zip()

删

clear()

改

pop()

update()

查

get()

item()

set常用方法

去重

交集

并集

差集

str常用方法(不可变)

find(),rfind()

join()

split()

strip()

replace()

最新文章

热门文章