编程语言中最长见的几种数据类型，字典，列表，等。同样在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) #
print(li_counts)
li_counts_two = li_count.count(111)
print(li_counts_two) #
- 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) #
- 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) #
- 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) #
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) #
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']