Python_Day_03 list,dic,tuple方法总结

　　编程语言中最长见的几种数据类型，字典，列表，等。同样在Python中也有这些数据类型，只是有些表现形式不同。同时在Python中又多了一种叫做元组（tuple）的东西。

　　list(列表)

初始化列表

li = list([1,2,3,4])

还可以直接创建

li_dir = [42,534,4654,64]

append(self, p_object) 在列表最后加上一个元素,默认是加上None

li_append = list([1,2,3,4])
li_append.append(43)
print(li_append) # [1, 2, 3, 4, 43]

clear(self) 清空数组

li_clear = list([1,2,3,4])
li_clear.clear()
print(li_clear) # []

copy(self) 浅拷贝（跟深拷贝有什么区别暂时还未研究）

li_copy = list([11,22,33])
li_copy_copy = li_copy.copy()
print(li_copy_copy) #[11, 22, 33]

count(self, value 返回某个值在列表中的个数,必须传入某个需要统计的值,否则会报错

li_count = list([111,222,333,444,111])
li_counts = li_count.count(11) # 0
print(li_counts)
li_counts_two = li_count.count(111)
print(li_counts_two) # 2

extend(self, iterable) 相当于扩展,扩展的参数必须同样是列表或者元组,同时是在原列表的基础上扩展,并且扩展的数据是在列表最后

li_extend = list([111,222,333,444,111])
# 当扩展的参数是元组时,如果元组元素最后不加 ',' 那么就会扩展失败,报错
li_extend.extend((12,))
print(li_extend) # [111, 222, 333, 444, 111, 12]
li_extend.extend([12,124,3,4,534,5,5])
print(li_extend) # [111, 222, 333, 444, 111, 12, 12, 124, 3, 4, 534, 5, 5]

index(self, value, start=None, stop=None) 根据值 来查找某个元素在列表中的下标

li_index = list([111,222,333,444,111])
# 默认从查找整个列表,并且当查找到第一个存在的值就会返回,不会继续查找后面的列表元素,如果不存在某个元素就会报错
li_index_index = li_index.index(111,0,4)
print(li_index_index) # 0

insert(self, index, p_object) 在指定下标下插入指定元素

li_insert = list([111,222,333,444,111])
li_insert.insert(3,'Python')
print(li_insert) # [111, 222, 333, 'Python', 444, 111]

pop(self, index=None) 弹出指定下标元素,同时可以定义一个变量来接收弹出的元素.默认弹出最后一个,如果列表为空,或者下标超出列表最大下标就会报错

li_pop = list([12,4234,3,534,64536])
li_receive = li_pop.pop(3)
print(li_pop) # [12, 4234, 3, 64536]
print(li_receive) # 534

remove(self, value) 根据值来删除列表中元素,如果删除的值在列表中有多个,只会删除第一个出现的值,如果删除的值不存在会报错

li_remove = list([11,23213,11,232323242])
li_remove.remove(11)
print(li_remove) # [23213, 11, 232323242]

reverse(self) 翻转列表

li_reverse = list([11,23213,11,232323242,'fdsa','rt433',13423])
li_reverse.reverse()
print(li_reverse) # [13423, 'rt433', 'fdsa', 232323242, 11, 23213, 11]

sort(self, key=None, reverse=False) 排序（这个暂时研究的也不是很多）

li_sort = list([4, 6, 2, 1, 7, 9])
li_sort.sort()
print(li_sort) # [1, 2, 4, 6, 7, 9]
# 排序的同时保留副本
li_sort_y = li_sort[ : ]
li_sort_y.sort()
print(li_sort_y) # [1, 2, 4, 6, 7, 9],同时保留了li_sort

　　tuple(元组)

　　方法比较简单,但是在创建的时候一定要注意 最后要加上 ',' 只有查找动能,没有增,删,改

tup = tuple((12,3242,3,4435,43,45,6,12))

count(self, value) 在元组中查找某个值出现的数量

tup = tuple((12,3242,3,4435,43,45,6,12))
tup_count = tup.count(1) # 0
print(tup_count)

index(self, value, start=None, stop=None) 在元组中根据某个值,查找下标,默认是整个数组,同时可以自定义查找范围,如果多次重复出现,只会查找第一个

tup = tuple((12,3242,3,4435,43,45,6,12))
tup_index = tup.index(12)
print(tup_index) # 0

　　dict(字典)

　　在字典中键是不可以重复的,如果重复,最先出现的会被覆盖

dic = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
print(dic) # {'k1': 'v4', 'k2': 'v2', 'k3': 'v3'}

clear(self) 清空字典中所有元素

dic_clear = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_clear.clear()
print(dic_clear) # {}

copy(self) 浅拷贝（类似于数组，也还是没深入研究）

dic_copy = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_copy_copy = dic_copy.copy()
print(dic_copy_copy) # {'k1': 'v4', 'k3': 'v3', 'k2': 'v2'}

fromkeys(*args, **kwargs) 为一个数组中赋值为同样的值。

dic_keys = dict.fromkeys([1,232,423,43,43],['da','fsda']) # {232: ['da', 'fsda'], 1: ['da', 'fsda'], 43: ['da', 'fsda'], 423: ['da', 'fsda']}
dic_keyss = dict.fromkeys([1,232,423,43,43],'da')
print(dic_keyss) # {232: 'da', 1: 'da', 43: 'da', 423: 'da'}

get(self, k, d=None) 返回根据某个键返回的值,如果不存在返回指定值,同时可以自定义默认值

dic_get = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_get_get = dic_get.get('k1','rookieJX')
print(dic_get_get) # v4
dic_get_get2 = dic_get.get('k','rookieJX')
print(dic_get_get2) # rookieJX

items(self 返回所有元素（所有键值对）

dic_items = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_items.items()
print(dic_items) # {'k3': 'v3', 'k2': 'v2', 'k1': 'v4'} 注意,这里的返回的动态的,顺序是不断变化的

keys(self 返回所有的键

dic_keys = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_keys_receive = dic_keys.keys()
print(dic_keys_receive) # (['k1', 'k3', 'k2']) 注意,这里返回的是另外一个列表,多以还需要额外的定义列表来接收返回值

pop(self, k, d=None) 由于字典是无序的,所以好像用处不是非常多;如果键值不存在,又没有默认值

dic_pop = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_res = dic_pop.pop('k10',100)
print(dic_pop) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2'} 不会改变原来字典,需要重新定义来接受数据
print(dic_res) # 100 如果没有指定弹出键值对,那么久返回我们指定值,默认为None
dic = dic_pop.pop('k1',100) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2'} 不会改变原来字典,需要重新定义一个字典来接收
print(dic_pop) # {'k2': 'v2', 'k3': 'v3'}
print(dic) # v4

popitem(self) 弹出某个对象,因为是无序的,所以现在是真的蛋疼了

dic_popitem = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_popitem.popitem() # {'k1': 'v4', 'k3': 'v3'} 删除的对象还不一定
print(dic_popitem)

setdefault(self, k, d=None) 类似于get

dic_default = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_default_get = dic_get.setdefault('k1','rookieJX')
print(dic_default_get) # v4
dic_default_get2 = dic_default.get('k','rookieJX')
print(dic_default_get2) # rookieJX

update(self, E=None, **F) 字典dict2的键/值对更新到dict里,貌似跟extend差不多的好像,但是是不会产生新的字典

dic_update = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_other = {'k10':'v4'}
dic_update.update(dic_other)
print(dic_update) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2', 'k10': 'v4'}

values(self) 所有的值

dic_values =  {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_values_values = dic_values.values()
print(dic_values_values) # ['v2', 'v4', 'v3']