1.列表的方法

• append(obj) 在列表末尾添加新的对象。
• insert(arg1,arg2) 像列表指定位置插入一个元素 ，参数1:要插入的位置为这个元素的后面 ， 参数2:要插入的元素 。
• extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列 。
• del 用来删除列表中一个元素或者整个列表 。
• pop() 根据索引删除并返回指定元素，当没有指定删除元素指定值则默认删除最后一个。
• remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
• reverse() 翻转列表，将列表反转 。
• sort(key=None,reverse=True) 用来对列表中的元素进行排序 reverse：True反序；False 正序 。

# append(obj) 在列表末尾添加新的对象
li = [1,2]
li.append(3)
print(li)	# 输出为[1, 2, 3]
li.append([4,5]) 
print(li)	#输出为[1, 2, 3, [4, 5]]# insert(index, obj) 将对象插入列表  
li = [1,2,3]
li.insert(2,"amy")
print(li)	# 输出为[1, 2, 'amy', 3]# extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
li = [1,2,3]
li.extend([4,5])
print(li)	# 输出为[1, 2, 3, 4, 5]
li.extend("67")
print(li)	# 输出为[1, 2, 3, 4, 5, '6', '7']# del  用来删除列表中一个元素或者整个列表 
li = [1,2,3,4]
print(li)
del li[0]        #（删除列表li2中第一个元素）
print(li)	  # 输出为：[1, 2, 3, 4][2, 3, 4]# pop()    根据索引删除并返回指定元素，当没有指定删除元素指定值则默认删除最后一个
li = [1,2,3,4]
print(li.pop(0))  # 输出为1
print(li)	# 输出为[2, 3, 4]# remove() 删除指定元素
li = [1,2,3,4]
li.remove(1)
print(li)	# 输出为[2, 3, 4]# reverse() 翻转列表，将列表反转 
li = list("1234")
li.reverse()
print(li)	# 输出为['4', '3', '2', '1']# sort() 排序，默认升序
li = [6,5,8,16,4,12]
li.sort()
print(li)	#输出为[4, 5, 6, 8, 12, 16]
li.sort(reverse=True)
print(li)	# 输出为[16, 12, 8, 6, 5, 4]

2.遍历列表

2.1for循环

通过for循环来遍历列表.

# 语法
for 变量 in 序列(遍历的规则):代码块li = [1,2,3,4]
for i in li:	# 遍历列表print(1)	# 输出为1；1；1；1
# 输出四次 1，因为列表中有四个元素所以循环四次。print(i)	# 输出为1；2；3；4
# 遍历列表将列表中的值赋给变量i，然后输出变量i

注意: for循环的代码块会执行多次,序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量,所以我们可以通过变量来获取列表中的元素。

2.2range(start, stop[, step])

参数说明·
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop，左闭右开。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

r1 = range(5)
print(r1)		# 输出为range(0, 5)
print(list(r1))		# 输出为[0, 1, 2, 3, 4]r2 = range(0,5)
print(r2)		# 输出为range(0, 5)
print(list(r2)) 	# 输出为[0, 1, 2, 3, 4]r3 = range(0,5,1)
print(r3)		# 输出为range(0, 5)
print(list(r3)) 	# 输出为[0, 1, 2, 3, 4]

3.元组

• 元组表现形式tuple
• 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)，不能进行添加、修改、删除元素的操作。
• 使用()创建元素。
• 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略 。
• 元组解包指将元组当中的每一个元素都赋值给一个变量。

# 创建元组用圆括号（）创建，表现形式为tuple
t = (1,2)
print(type(t))	# 输出为<class 'tuple'># 元组不是空元组至少有一个 逗号(,)  当元组不是空元组时括号可以省略 。
t = 1,2
print(t)	# 输出为(1, 2)
print(type(t))	# 输出为<class 'tuple'># 元组解包指将元组当中的每一个元素都赋值给一个变量。
t = (1,2,3,4,5)
a,b,c,d,e = t
print('a=',a,'b=',b,'c=',c,'d=',d,'e=',e)
# 输出为a= 1 b= 2 c= 3 d= 4 e= 5
a,b,c = t	# 当变量与元组中元素个数不符合则报错
a,b,*c = t	# 利用*号则将元组中剩余的元素全部赋值给变量c，返回一个列表
# 输出为a= 1 b= 2 c= [3, 4, 5]
a,*b,c = t # 利用*号则将元组中剩余的元素全部赋值给变量b，返回一个列表
# 输出为a= 1 b= [2, 3, 4] c= 5

4.字典

4.1字典基础

• 字典属于一种新的数据结构称为映射(mapping)
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反，存储数据的性能差，但是查询数据的性能好。
• 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素，这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值。
• 字典我们也称之为键值对(key-value)结构
• 创建字典的语法 {key:value}
• 字典的键是不能重复的，如果出现重复的后面的值会替换前面的值。
• 字典是可变序列。

# 语法
dict = {'key1':value1,'key2':value2...}

4.2字典的使用

• dict()函数来创建字典
• len()字典中键值对的个数
• in 检查字典中是否包含指定的键
• not in 检查字典中是否不包含指定的键
• get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
• update() 将其他字典的key-value添加到当前的字典当中
• del 删除字典中的key-value
• popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
• pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
• clear 清空字典

# dict()函数来创建字典（三种方式）
dic = {'name':'amy','age':18,'adder':'湖南'}
print(dic)	# 输出为{'name': 'amy', 'age': 18, 'adder': '湖南'}
dic = dict(name='amy',age=18,adder='湖南')
print(dic)	# 输出为{'name': 'amy', 'age': 18, 'adder': '湖南'}
dic = dict([('name','age',),('amy',18,)])	# 将包含有双子值序列的序列转换为字典
# 双值序列，序列中有两个值[1,2],[4,5],'ab'
# 子序列，如果序列中的元素也是序列，我们称这个元素为子序列[(1,2,4),[4,5]]
print(dic)	# 输出为{'name': 'age', 'amy': 18}# len()字典中键值对的个数
dic = {'name':'amy','age':18,'adder':'湖南'}
print(len(dic))	# 输出为3# in 检查字典中是否包含指定的键
print('name' in dic) # 输出为Ture# get(key[,default]) 根据键来获取字典的值
dic = {'name':'amy','age':18,'adder':'湖南'}
print(dic['age'])	# 输出为18，如果键字典中没有则报错，而在get中不会报错
print(dic.get('age'))	# 输出为18
print(dic.get('age','有')) # 输出为18
print(dic.get('sex')) # 输出为None,字典中没有这个键，没有指定default所以返回为默认值None
print(dic.get('sex','没有'))# 输出为没有,字典中没有这个键，指定default所以返回为指定值#  将字典进行添加键值对key-value
dic = {'name':'amy','age':18,'adder':'湖南'}
dic['age'] = '20'
print(dic)	# 输出为{'name':'amy','age':20,'adder':'湖南'},修改字典中value值，赋值时如果字典中没有key，则向字典中添加这个key-value 
dic.setdefault('age',25)
print(dic) # 输出为{'name':'amy','age':20,'adder':'湖南'},如果key已经存在与字典中，则不会对字典有任何操作，字典不变
dic.setdefault('sex','女')
print(dic) # 输出为{'name':'amy','age':20,'adder':'湖南'，'sex'：'女'},如果key不存在与字典中，则向字典中添加这个key并设置value。
r = dic.setdefault('sex','女')
print(r)  # 输出为女，具有返回值#  update() 将其他字典的key-value添加到当前的字典当中
d1 = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6}
d1.update(d2)	# 将字典d2添加到字典d1中
print(d1)	# 输出为{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}，如果添加过程中有重复的则会进行覆盖# del 删除字典中的key-value
d1 = {'a':1,'b':2,'c':3}
del d1['a']	# 删除键a的值
print(d1)	# 输出为{'b': 2, 'c': 3}# popitem() 删除字典最后的一个key-value 这个方法是有返回值的
d1 = {'a':1,'b':2,'c':3}
d1.popitem()	# 删除字典中最后一个键值对
print(d1)	# 输出为{'a': 1, 'b': 2}
r = d1.popitem()
print(r)# 输出为（'c'，3）# 具有返回值，返回值是一个元组，元组中有两个元素分别是删除的键值对。# pop(key[,default]) 根据key删除自定中的value
d1 = {'a':1,'b':2,'c':3}
s = d1.pop('a') # 具有返回值
print(d1)	# 输出为{'b':2,'c':3}
print(s)	# 输出为（'a'，1）# 具有返回值，返回值是一个元组，元组中有两个元素分别是删除的键值对。
#如果key不存在与字典中，则输出的是指定值，不指定则会报错
s = d1.pop('w','没有这个值') # 具有返回值
print(s) # 输出为 没有这个值# clear 清空字典
d1 = {'a':1,'b':2,'c':3}
d1.clear	# 清空字典
print(d1)	# 输出为{}

4.3copye()

copy() 方法用来对字典进行浅复制，复制完后修改其中一个字典对另一个字典没影响，是两个对象。
注意: 浅复制只会复制字典本身，如果字典中还有个字典是不会进行复制的.

d1 = {'a':1,'b':2,'c':3}
d2 = d1.copy()
print('d1=',d1)	# 输出为d1 = {'a':1,'b':2,'c':3}
print('d2=',d2)	# 输出为d2 = {'a':1,'b':2,'c':3}
d1['a'] = 4
print('d1=',d1) # 输出为d1 = {'a':4,'b':2,'c':3}
print('d2=',d2) # 输出为d2 = {'a':1,'b':2,'c':3}

5.总结