学习笔记-Python基础6-列表元祖字典集合-列表、元祖

list列表：一组有顺序的数据的组合

l1 = [] #创建一个空列表
print(type(l1),l1) #type内置函数，负责打印变量类型，输出：<class 'list'> []
l2 = [1,2,3] #创建一个带值列表
print(type(l2),l2) #type内置函数，负责打印变量类型，输出：<class 'list'> [1,2,3]
l3 = list() #创建一个空列表的另外一种方法
print(type(l3),l3) #type内置函数，负责打印变量类型，输出：<class 'list'> []

#列表的常用操作：1、访问：用下标（索引）访问，其下标从0开始
l = [1,2,3]
print(l[2]) #输出：3
#列表的常用操作：2、分片：列表[开始下标:结束下标]，取的值不包含结束下标对应的值（list分片操作是生产了一个新的list）
l = [1,2,3]
print(l[:]) #左右下标都不写，表示截取列表全部值，输出：[1, 2, 3]

print(l[0:2]) #输出：[1, 2, 3]
print(l[1:]) #输出：[2, 3]
print(l[::2]) #输出：[1, 3]，第三个参数为分片操作里控制每次增长的幅度

　print(l[:10]) #输出：[1, 2, 3]，下标超出列表范围，超出部分忽略不考虑

　print(l[-3:2]) #输出：[1, 2]，下标起始为负值，则按0开始

　#下标、增长幅度都可以为负值

　#下标为负数，表明列表内顺序按从右往左，开始的下标为-1（也就是数组的最后一个下标），然后-2，依次类推

　#分片默认左边的下标大于右边的下标，如果想改成右边大于左边，则需要把增长幅度改为负值，但需要注意截取出来的值的顺序是倒着排的（为list正反颠倒提供了方法：print(l[::-1])）

　print(l[-2:-3]) #输出：[]
　print(l[-2:-1]) #输出：[2]

　print(l[-1:-3:-1]) #输出：[3,2]

 内置函数id，负责显示一个变量或者数据的唯一确定编号，相当于这份数据在内存中的位置：

　#猜想如果a和b指向同一份数据，修改a的值就会同时修改b的值，但是显示结果并不是

　　a = 100
　　b = 200
　　c = a
　　print(id(a),id(c),id(b)) #输出：1506506912 1506506912 1506510112

　　a = 101
　　print(id(a),id(c)) #输出：1506506944 1506506912

　　

　　l = [1,2,3,4]
　　ll = l[:]
　　print(l,ll) #[1, 2, 3, 4] [1, 2, 3, 4]

　　l[0] = 99
　　print(l,ll) #[99, 2, 3, 4] [1, 2, 3, 4]

　　lll = ll
　　ll[0] = 33
　　print(ll,lll) #[33, 2, 3, 4] [33, 2, 3, 4]

#删除命令：del，下面例子列表中数值删除不会生成新的列表
a = [1,2,3]
print(a,id(a)) #[1, 2, 3] 84212168

del a[2] print(a,id(a)) #[1, 2] 84212168

　del a
　print(a) #NameError: name 'a' is not defined，因为删除掉a后，再打印a，a就是未定义

　#列表想加

　a = [1,2,3]

　b = ["a", "b"]
　c= a + b
　print(c) #[1, 2, 3, 'a', 'b']

　#列表乘法　

　a = [1,2,3]

　print(a * 3) #[1, 2, 3, 1, 2, 3, 1, 2, 3]，相当于把n个a列表想加

　b = 8
　print(b in a) #False，成员资格判断，b在不在a里面

　print(b not in a) #True

#列表遍历
a = [1, 2, 3, 4, 5]
#for in 方法
for i in a: # in后面跟的是可迭代的变量
    print(i)
#while方法
length = len(a)
indx = 0
while indx < length:
    print(a[indx])
    indx += 1
a = [["one",1,"我"], ["two",2,"萌"]]
#双层列表，或者叫嵌套列表
for i in a:
    for k in i:
        print(k) #one 
 1 
 我 
 two 
 2 
 萌
for k,v,w in a:
    print(k,v,w) #one 1 我 
 two 2 萌，k,v,w个数应该跟解包出来的变量个数一致
#c++,java写法
a = [1, 2, 3, 4, 5]
for i in range(0,len(a)):
    print(a[i])
    i += 1

#列表内涵:list content
#列表生成式
a = [1, 2, 3, 4]
b = [i for i in a] #用list a创建一个list b（把a里面的每个值拿出来，依次赋值给i）
print(b) #[1, 2, 3, 4]
b = [i * 10 for i in a] #list a中每个元素乘以10，放入新列表b
print(b) #[10, 20, 30, 40]
a = [x for x in range(1,35)]
b = [m for m in a if m % 2 == 0]
print(b) #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]

a = [i for i in range(1,4)]
b = [i for i in range(100,400) if i % 100 == 0]
c = [m+n for m in a for n in b if m+n < 250] #列表生成嵌套，也可以添加条件表达式，此例为：m和每个n相加，只要结果大于250的
print(c) #[101, 201, 102, 202, 103, 203]
for m in a:
    for n in b:
        print(m+n,end=" ") #101 201 301 102 202 302 103 203 303 
print()

#列表常用函数
#len()，求长度
a = [i for i in range(1,100)]
print(len(a)) #99
#max()，求最大值
b = ["aaa","b","cccc"]
print(max(a),max(b)) #99 cccc

#min()，求最小值
print(min(a),min(b)) #1 aaa

#list()，将其他格式数据转成list。注意要求被转换的数据为可迭代的
a = "我 是 你"
print(list(a)) #['我', ' ', '是', ' ', '你']
print(list(range(1,4))) #[1, 2, 3]

#列表操作方法
#1、末尾追加
a = [ i for i in range(1,5)]
a.append(100)
print(a)
#2、插入（insert(index,data)）在当前下标index的前面插入
a.insert(2,666)
print(a)
#3、pop（弹出最后一个值，一般同时进行赋值操作）
last_ele = a.pop()
print(last_ele)
print(a)
#4、del删除，可以删除整个列表，也可以删除指定下标的元素
del a[2]
print(a)
#5、remove,删除指定值的元素，最好再删除前先判断有没有这个值，或者是用try...excepty语句
print(id(a))
if 1 in a: 
    a.remove(1)
print(a)
print(id(a))
#6、clear清空列表内的数据，但列表还在
a.clear()
print(a)
#针对于列表清空操作，如果不需要列表所在内存地址保持不变，可以使用a = list()或者a = []操作
#7、reverse()翻转，原地翻转
a = [i for i in range(1,4)]
a.reverse()
print(a)
#8、extend，扩展列表，把一个列表直接拼接到一个列表上
a = [1, 2, 3]
b = [4, 5]
print(id(a))
a.extend(b)
print(a)
print(id(a))
#9、count()查找列表内指定值出现的次数
a = [1, 2, 1]
a.append(1)
a.insert(2,1)
print(a)
print(a.count(1))
print("*" * 10)
#10、copy()浅拷贝，可以解决list在变量间赋值操作出现指向同一地址
a = [1, 2, 3]
b = a.copy()
print(b)
#深拷贝和浅拷贝区别，比如嵌套列表，浅拷贝只拷贝一层
a = [1, 2, 3, [10, 20, 30]]
b = a.copy()
print(id(a),id(b))
print(id(a[3]),id(b[3]))
'''
输出的内容如下：

[1, 2, 3, 4, 100]
[1, 2, 666, 3, 4, 100]
100
[1, 2, 666, 3, 4]
[1, 2, 3, 4]
80992712
[2, 3, 4]
80992712
[]
[3, 2, 1]
81120008
[1, 2, 3, 4, 5]
81120008
[1, 2, 1, 1, 1]
4
**********
[1, 2, 3]
81112840 81112712
80992712 80992712
'''

元祖tuple：可以看成是一个不可更改内部值的list

#元祖
t = ()
print(type(t))
#创建只有一个值的元祖的两种方法
t = (1,)
t = 1,
#创建多个值的元祖的两种方法
t = (1, 2, 3)
t = 1, 2, 3
#list转成tuple
l = [1, 2, 3]
t = tuple(l)
print(t,type(t))
#元祖特性
#1、有序；2、元祖的数据可以访问，但不可修改；3、元祖数据可以是任意类型；总之，list拥有的特性，除了修改数据外，元祖都具有，也就是说list具有的操作，比如索引、切片、序列相加或乘、成员资格等，它都一模一样
t = (1, 2, 3, 4, 5)
#索引操作
print(t[2])
#元祖切片，切片下标可以超出范围，但索引不行，会报错
t1 = t[1::2]
print(t1,id(t1))
print(t,id(t))
print(t[::-1])
#元祖相加
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(id(t1))
t1 = t1 + t2
print(t1,id(t1))
#元祖相乘
t= (1, 2, 3)
t = t * 3
print(t)
#成员检测
t= (1, 2, 3)
print(2 in t)
#遍历，一般用fo1
t = [1, 2, 3]
for i in t:
    print(i, end=" ")
print()
#遍历，双层元祖遍历
t = ((1,2,3),("a", "b", "c"))
for k, v, n in t:
    print(k, "--", v, "--", n)
'''
<class 'tuple'>
(1, 2, 3) <class 'tuple'>
3
(2, 4) 79007304
(1, 2, 3, 4, 5) 80323952
(5, 4, 3, 2, 1)
80466352
(1, 2, 3, 4, 5, 6) 55361448
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
1 2 3 
1 -- 2 -- 3
a -- b -- c
'''

#一、python内置函数中适用于元祖的函数，基本和list通用
#1、len()获取元祖长度
t = (1, 2, 3, 4, 5, 5, 1)
print(len(t))
#2、max()、min()最大最小
print(max(t),min(t))
#3、tuple()创建或转换成元祖
l = [1, 2, 3]
t = tuple(l)
print(t)
t = tuple()
print(t)
#二、元祖的方法，基本和list一样（不包含list可以修改值的方法）
#1、count，计算指定值出现的次数
t = (1, 2, 3, 1, 1,)
print(t.count(1))
#2、index，返回指定元素的索引，如果指定元素有多个值，则只返回第一个的索引
print(t.index(1))
#三、元祖变量交换法
#两个变量交换值
a = 1
b = 3
#java会这么写：
c = a
a = b #a交换结束
b = c
print(a,b)
#python这么写
a, b = b, a
print(a,b)
'''
打印如下：

7
5 1
(1, 2, 3)
()
3
0
3 1
1 3
'''