列表
n [14]: li_1 = ['as','se','cd','er','vg']
In [15]: li_1[3]
Out[15]: 'er'
In [16]: li_2 = [['one','two','three'],[1,2,3]]
In [17]: li_2[1][1]
Out[17]: 2
In [18]:
In [18]:
In [18]:
In [18]:
In [18]:
In [18]: li_2[0][1]
Out[18]: 'two'
li_f = ['append','insert','extend','remove','pop','index','count','sorted']
取值第一个
In [10]: li_f[0]
Out[10]: 'append'
倒数第一个
In [11]: li_f[-1]
Out[11]: 'sorted'
# 获取多层列表的元素
In [19]: nesting_li = [['one', 'two', 'three'], [1, 2, 3]]
In [20]: nesting_li[0][1]
Out[20]: 'two'
In [21]: nesting_li[1][1]
Out[21]: 2
切片
In [23]: li_f[0:1]
Out[23]: ['append']
In [24]: li_f[2:]
Out[24]: ['extend', 'remove', 'pop', 'index', 'count', 'sorted']
In [25]: li_f[:2]
Out[25]: ['append', 'insert']
==============================================================
In [26]: li_f[:] 全取
Out[26]: ['append', 'insert', 'extend', 'remove', 'pop', 'index', 'count', 'sorted']
In [27]: li_f[::2] 正去 步长2
Out[27]: ['append', 'extend', 'pop', 'count']
In [83]: li
Out[83]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [84]: li[0:11:2]
Out[84]: [0, 2, 4, 6, 8, 10]
In [85]: li[1:11:2]
Out[85]: [1, 3, 5, 7, 9]
In [86]: li[::-1] 倒着取值 试试[::-2]
Out[86]: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
======================================================
In [87]: a = slice(0,11,2)
In [88]:b= slice(1,11,2)
In [89]: c= slice(None,None,-1)
In [91]: li[a]
Out[91]: [0, 2, 4, 6, 8, 10]
In [92]: li[b]
Out[92]: [1, 3, 5, 7, 9]
In [93]: li[c]
Out[93]: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
===========================================================================
obj = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
in 判断元素是否存在于列表中。
示例：10 in obj
len() 方法是序列类型函数，可以统计序列类型的数据结构的长度。
示例: len(obj)
obj.append('a') 追加 向列表的最后位置，添加一个元素，接收一个参数
obj.insert(0,'b') 向原列表的指定位置插入一个元素，接收两个参数，
第一个是索引号，第二个是要插入的元素。
obj.extend() 可以把一个序列类型中的每个元素追加到原列表中，
接收的参数是一个序列类型的数据。
obj.extend(['qf','yangge'])
obj.remove('a') 移除列表中某个指定的元素，没有返回值，并且假如有
多个相同值的元素存在，每次只会移除排在最前面的那个元素。
obj.pop() 从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。
obj.pop() 删除列表中的最后一个元素，并返回
obj.pop(2) 删除列表中索引号为 2 的元素，并返回
obj.index('qf') 返回指定元素的索引号。
obj.count('qf') 是列表的内置方法，可以统计出相同值的元素在列表中总共
出现都少次。
obj.sort() 是列表的内置方法，对列表中元素进行排序。
默认是升序， 这个改变列表自身。
还可以接收一个 reverse (反转) 参数，
其值可以是 True 和 False。 False 是升序，True 是降序。
需要是同一种数据类型，比如都是字符串，或都是整型
示例：
In [82]: l5
Out[82]: [2, 4, 23, 34, 100]
In [83]: l5.sort(reverse=True)
In [84]: l5
Out[84]: [100, 34, 23, 4, 2]
li = [2,10,3,7]
sorted(li) 是 python 的内置函数，接受一个参数，
参数可以是任意序列类型的数据，但是元素的类型必须相同
比如是含有都是 str 的列表，或者是含有都是 int 的列表
它会返回一个新的类别，原列表不变。
===============================================================
obj = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
in 判断元素是否存在于列表中。
示例：10 in obj
len() 方法是序列类型函数，可以统计序列类型的数据结构的长度。
示例: len(obj)
obj.append('a') 追加 向列表的最后位置，添加一个元素，接收一个参数
obj.insert(0,'b') 向原列表的指定位置插入一个元素，接收两个参数，
第一个是索引号，第二个是要插入的元素。
obj.extend() 可以把一个序列类型中的每个元素追加到原列表中，
接收的参数是一个序列类型的数据。
obj.extend(['qf','yangge'])
obj.remove('a') 移除列表中某个指定的元素，没有返回值，并且假如有
多个相同值的元素存在，每次只会移除排在最前面的那个元素。
obj.pop() 从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。
obj.pop() 删除列表中的最后一个元素，并返回
obj.pop(2) 删除列表中索引号为 2 的元素，并返回
obj.index('qf') 返回指定元素的索引号。
obj.count('qf') 是列表的内置方法，可以统计出相同值的元素在列表中总共
出现都少次。
obj.sort() 是列表的内置方法，对列表中元素进行排序。
默认是升序， 这个改变列表自身。
还可以接收一个 reverse (反转) 参数，
其值可以是 True 和 False。 False 是升序，True 是降序。
需要是同一种数据类型，比如都是字符串，或都是整型
示例：
In [82]: l5
Out[82]: [2, 4, 23, 34, 100]
In [83]: l5.sort(reverse=True)
In [84]: l5
Out[84]: [100, 34, 23, 4, 2]
li = [2,10,3,7]
sorted(li) 是 python 的内置函数，接受一个参数，
参数可以是任意序列类型的数据，但是元素的类型必须相同
比如是含有都是 str 的列表，或者是含有都是 int 的列表
它会返回一个新的类别，原列表不变。
**引用赋值**
In [192]: a
Out[192]: ['6', '5', '3', '1', '1']
In [193]: b = a
In [194]: b
Out[194]: ['6', '5', '3', '1', '1']
In [195]: a[-2]=2
In [196]: a
Out[196]: ['6', '5', '3', 2, '1']
In [197]: b
Out[197]: ['6', '5', '3', 2, '1']
In [118]: b[1:3]='a'
In [119]: b
Out[119]: ['6', 'a', 2, '1']
======================================================================
5 深浅拷贝
In [110]: zu = ['name',['money',100.00]]
In [111]: m = list(zu)
In [112]: x = zu.copy() =========浅拷贝
In [113]: m[1][1] = 20.00
In [114]: x
Out[114]: ['name', ['money', 20.0]]
zu m x 同属于一个文本内容源-----该一则全变
-------------------------------------------------------------------------------------------
In [115]: import copy # Python 的语法，导入 copy 模块
In [116]: q = copy.deepcopy(zu) =======深拷贝
In [117]: w= copy.deepcopy(zu)
In [118]: w[1][1] = 50.00
In [119]: q
Out[119]: ['name', ['money', 20.0]]
In [120]: w
Out[120]: ['name', ['money', 50.0]] zu q w 各一个源
================================================
# 列表推导式
In [3]: num_list = [n for n in range(1,7)]
In [4]: num_list
Out[4]: [1, 2, 3, 4, 5, 6]
# 添加有表达式的列表推导式
In [5]: num_list = [n - 1 for n in range(1,7)]
In [6]: num_list
Out[6]: [0, 1, 2, 3, 4, 5]
# 有条件判断的一般传统的方法
In [7]: a_list = []
In [8]: for n in range(1,6):
...: if n % 2 == 1:
...: a_list.append(n)
...:
In [9]: a_list
Out[9]: [1, 3, 5]
# 使用有条件判断的列表推导式
In [10]: a_list = [n for n in range(1,6) if n % 2 == 1]
In [11]: a_list
Out[11]: [1, 3, 5]
元组
In [168]: w= (3)
In [169]: w1 = 3,
In [170]: type(w)
Out[170]: int --------------------- 整数
In [171]: type(w1)
Out[171]: tuple ------------------元组
------------------------------------------------------------------------------------------------------------
tuple() # 可以对其他序列类型的数据进行转换
In [173]: s1 = 'car' ---------字符串
In [174]: li = [1,2,3]
In [175]: tuple(s1)
Out[175]: ('c', 'a', 'r')
In [176]: tuple(li) -----------------整数
Out[176]: (1, 2, 3)
In [177]: dl = [1,2,3,['a','b']]
In [178]: tuple(dl)
Out[178]: (1, 2, 3, ['a', 'b'])
--------------------------------------------------------------------------------------------------------------
In [33]: t1 = (1, 2, 3, ['a', 'b'])
In [34]: t1[3][0]=0
In [35]: t1
Out[35]: (1, 2, 3, [0, 'b'])
元组解包：
In [199]:a,b= 1,2
In [200]: a,b =b,a
In [201]: one
Out[201]: 2
In [202]: two
Out[202]: 1
============================================================================
三 dict 字典
1 映射类型数据结构介绍
在字典存放的每个元素都是以一对儿键值对。
在 Python 中 字典通常被称为 dict，键 称为 key，值称为 value
字典中不可以存在相同的 key，但是 value 可以。
空典
In [7]: d1 = {}
In [8]: type(d1)
Out[8]: dict
----------------------------------------------------------------------------------------------
In [28]: d2 = {'yangge': '杨哥', 'qf': '千锋'}
In [29]: d2
Out[29]: {'qf': '千锋', 'yangge': '杨哥'} ------------------------无序排列
==dict() 函数接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。==
In [14]: w1= [('a','1'),('b','2'),('c','3')]
In [15]:x3 = dict(w1)
In [17]: w2= ['a1','b2','c3']
In [18]: x4 = dict(w2)
In [21]: x3 is x4
Out[21]: False
In [22]: x3 == x4
Out[22]: True
***************************************************************************************************
**利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量**
In [36]: en = 'Monday','Tuesday','Thursday',
In [37]: ch = '星期一','星期二','星期三'
In [38]: zip(en,ch)
Out[38]:
In [39]: type(zip(en,ch))
Out[39]: zip
In [40]: list((en,ch))
Out[40]: [('Monday', 'Tuesday', 'Thursday'), ('星期一', '星期二', '星期三')]
In [41]: dict(zip(en,ch))
Out[41]: {'Monday': '星期一', 'Thursday': '星期三', 'Tuesday': '星期二'}
=======================================================================
3 哪些数据可以作为字典的 kye
key 通常是 字符串
它可以是 Python 中任意不可变类型
比如：
布尔型 True 1 False 0
整型 100 200
浮点型 1.0 3.415
元组 1， （1，2，3）
字符串 'host_name'
key
在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。
所以 key 必须是可哈希的。
判断一个对象是否可哈希 hash()
返回一个整数，就是可哈希，反之会抛出 TypeError 异常
------------------------------------------------------------------------------------------------------
获取 key 对应的 value
t= {'a': 1, 'b': 2}
t['a'] # key 必须存在，不存在，抛出异常
t.get('a') # 获取到 'a' 对应的值(value)
t.get('c') # key 不存在字典中，则返回 None(没有)
t.get('c', '5') # key 不存在，返回指定的 value
------------------------------------------------------------------------------------------------------------------------------
g = {"name": 'yangge', 'age': 18}
na = g['name']
print(na) =========== 'yangge'
naa = g['age'] ================18
age =g.get('age') ==================18
print(age)
age2 = g.get('asdf')
print(type(age2),age2)
age3 = g.get('adaf', '')
print(type(age3),age3)
age4 = g.get('adaf', 28)
print(type(age4),age4)
============================================================================================
5 获取字典所有的 key
t = {"name": 'yangge', 'age': 18}
d_keys = t.keys()
print(d_keys) =======dict_keys(['name', 'age'])
print(list(d_keys)) ==== ['name', 'age']
========================================================
6 获取字典所有的 value
info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))
7 一次性获取字典的 key 和 value
info_dict = {"name": 'yangge', 'age': 18}
item = info_dict.items()
print(item) ===== dict_items([('name', 'yangge'), ('age', 18)])
print(list(item)) ======[('name', 'yangge'), ('age', 18)]
8 赋值和更新字典
In [50]: d5 = {}
In [51]: d5['a'] = 1
In [52]: d5['b'] = 2
In [53]: d5
Out[53]: {'a': 1, 'b': 2}
In [54]: d5['li'] = [1,3,5]
In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
**字典同样支持引用赋值**
In [68]: dic5 = {'a': 1, 'b': 2, 'li': [1, 3, 5]}
In [69]: dic6 = dic5
In [70]: dic6 is dic5
Out[70]: True
In [71]: dic7 = dic5.copy()
In [73]: dic7 is dic5
Out[73]: False
In [74]: dic7 == dic5 # 双等号 是用来判断 等号两边的对象的值是否相等
Out[74]: True
update()
是用于把一个已经存在的字典中的键值对，添加到当前操作的字典中方法。
In [59]: dict5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
In [60]: dict6 = {'a': 2,'d': 2,'e': 5}
In [61]: dict5.update(dict6)
In [62]: dict5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5, 'li': [1, 3, 5]}
==注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 方式的更新==
9 判断 key成员
In [63]: 'a' in dict5 # 默认就是判断 ‘a’ 是否存在于字典中的 keys()
Out[63]: True
In [63]: 'a' in dict5.keys()
Out[63]: True
In [75]: 'a' not in dict5.keys()
Out[75]: False
10 删除和清空字典
删除指定的键值对
dict_obj = {'a': 1}
del dict_obj['a'] # 从字典中删除指定 key 的键值对
del dict_obj # 删除字典本身，字典自身就不存在于内存中了
**清空**
dict_obj={}
dict_obj.clear() # 字典本身还在内存中，只是内容没了
pop()
从字典中删除指定 key 的键值对，并返回这个 key 对应的值
In [49]: dic6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
In [50]: li = dic6.pop('li')
In [51]: print(li)
Out [51]: [1, 3, 5]
网友评论