python
1.更改类型的原因 基于值的自动内存管理模式。变量并不直接储存值，而是储存值的引用或者内存地址，因此可以随手更改类型
2. python列表中元素也是基于值的引用
3. 列表元素类型直接影响列表的操作 注意区分基本数据类型为元素的列表和其他数据类型为元素的列表，一个是值引用，一个是地址引用

列表创建\删除

---

创建

1. 使用 = 创建

 li = [1,2,3,4,5,6,67]
 #[1, 2, 3, 4, 5, 6, 67]

2. 使用list 函数:list(v) v可以为列表，元祖，字典，集合等可迭代的对象

    ll = list((12,34,56,7))
    print(ll,type(ll))
    #[12, 34, 56, 7] <class 'list'>

3. 使用字典创建列表时：默认使用字典的键来创建列表，

    dic = {"a":12,"b":23,"d":234}
    ld = list(dic)
    print(ld)
    #  ['a', 'b', 'd'] 默认使用键形成的列表
    ld = list(dic.values())
    print(ld)
    # [12, 23, 234]使用值形成的列表
    ld = list(dic.items())
    print(ld)
    # [('a', 12), ('b', 23), ('d', 234)]使用字典每一项形成的元素为元祖的列表
    ld = list(dic.keys())
    print(ld)
	# ['a', 'b', 'd'] 使用键形成的列表

4. 使用列表生成器生成的列表：

    lg = [ x for x in range(12)]
    print(lg,type(lg))
    #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] <class 'list'>

删除

1. del 并不是删除变量对应的值，只是删除了变量，并且解除了变量和值之间的绑定。之后有python编译器自动对值进行回收

	x = [1,2,3]
	del x
	print(x) #调用将会出错，x已经被解除了了关联

2. 值的回收 在程序中，值每次被引用之后，值计数器+1，引用值的变量被删除或者解除了绑定之后值计数器-1，当计数器的值为0 的时候，由垃圾回收器对值进行清除，如果要人工进行清理则需要gc模块的collect（） 进行清理操作

	import  sys
	import  gc
    x = 12123
    print(sys.getrefcount(12123))
    y = 12123
    print(sys.getrefcount(12123))
    z = 12123
    print(sys.getrefcount(12123))
    del x
    del  y
    print(sys.getrefcount(12123))
    print(gc.collect())
    #3
	#4
	#5
	#3
	#0

---

列表的访问

列表的基本访问：一般使用下标的方式进行访问：
a. 默认从0开始，列表的长度结束 lil[12]
b. 可以是负数，负数表示倒数开始计算索引，索引从-1开始，表示最后一个元素

---

1. append(x) 将x追加到当前列表的末尾

	ll = [1,2,3,4,5,6]
    ll.append(12)
    #[1, 2, 3, 4, 5, 6, 12]

2. extend(L) 将列表L元素追加至当前列表的末尾

    ll = [1,2,3,4,5,6]
    ll.extend([1,2,3,45])
    print(ll)
    #[1, 2, 3, 4, 5, 6, 12, 1, 2, 3, 45]

3. insert(index,x) 将x元素，插入到指定索引位置

	ll.insert(0,123456)
    print(ll)
    #[123456, 1, 2, 3, 4, 5, 6, 12, 1, 2, 3, 45]

4. remove(x) 列表中删除值为x的元素,只删除删除查找到的第一个数据,也可以使用： del 列表【索引】 来删除指定索引位置的数据

    ll.remove(1)
    print(ll)
	#[123456, 2, 3, 4, 5, 6, 12, 1, 2, 3, 45]

5. pop([index]) 删除列表中索引为index的元素，index可可选参数，如果index却是，那么将会删除当前列表中最后索引的元素

    ll.pop()
    print(ll)
    ll.pop(0)
    print(ll)
    #[123456, 2, 3, 4, 5, 6, 12, 1, 2, 3]
	#[2, 3, 4, 5, 6, 12, 1, 2, 3]

6. clear() 清空列表，清空列表内所有的元素，但是对象被保留下来，del则是删除对象，对象将不再能够被访问

    ll.clear()
    print(ll)
    #[]

7. index(x) 对象的访问

    ll.extend([1,2,1,3,4,5,6,7,8,9])
    print(ll.index(2))
    # 1

8. count(x) 返回x元素在列表中出现的次数，因为列表是有序的，所以元素值是可以重复的

    ll.extend([1,2,1,3,4,5,6,7,8,9])
    print(ll.count(1))
    # 2

9. reverse() 列表的反转，逆序

    ll.extend([1,2,1,3,4,5,6,7,8,9])
    ll.reverse()
    print(ll)
    # [9, 8, 7, 6, 5, 4, 3, 1, 2, 1]

10. sort() 列表的排序，reverse和sort都是针对当前列表本身的操作。如果要不改变本身而进行排序和反转，则应该使用sorted和reversed函数

    ll.extend([1,2,1,3,4,5,6,7,8,9])
    ll.sort()
    print(ll)
    #[1, 1, 2, 3, 4, 5, 6, 7, 8, 9]

11. copy() 列表的浅复制，由于是浅复制，所以如果是基本数据类型或者元组则没有问题，如果是其他类型的数据copy的时候只会把数据的地址进行复制，而不会对其进行进一步的拷贝操作

    lc = [1,2,3,4,5,6,[1,2,3,4],(1,2,3,4)]
    print(lc)
    lcc = lc.copy()
    print(lcc)
    lcc[6][1] = 20
    print(lcc)
    print(lc)
    #[1, 2, 3, 4, 5, 6, [1, 2, 3, 4], (1, 2, 3, 4)]
	#[1, 2, 3, 4, 5, 6, [1, 2, 3, 4], (1, 2, 3, 4)]
	#[1, 2, 3, 4, 5, 6, [1, 20, 3, 4], (1, 2, 3, 4)]
	#[1, 2, 3, 4, 5, 6, [1, 20, 3, 4], (1, 2, 3, 4)]

列表操作符

1. +、+=: +、 +=列表的追加，*列表的重复

 	ld = [10,20,30,40,50]
    ld = ld+[60]
    print(ld)
    ld += [70]
    print(ld)
    ld = ld * 2
    print(ld)
    ld *= 2
    print(ld)
    ld *= 0
    print(ld)
    '''
    [10, 20, 30, 40, 50, 60]
	[10, 20, 30, 40, 50, 60, 70]
	[10, 20, 30, 40, 50, 60, 70, 10, 20, 30, 40, 50, 60, 70]
	[10, 20, 30, 40, 50, 60, 70, 10, 20, 30, 40, 50, 60, 70, 10, 20, 30, 40, 50, 60, 70, 10, 20, 30, 40, 50, 60, 70]
	[]
'''

2. in 指定值是否在列表中

    ldd = [10,20,30]
    print(20 in ldd)
    #True

---