Python3——内置数据结构:list 、tuple
内置数据结构（变量类型）
- list
- set （详见 python-数据类型）
- dict （详见 python-数据类型）
- tuple
list（列表）
- 一组有顺序的数字的组合
- 创建列表
- 空列表
l1=[] #创建一个空列表
print(type(l1))
print(l1)
l2=[100] #创建一个带值得列表
print(type(l2))
print(l2)
l3=[2,5,5,8,1,3] #创建带多个值得列表
print(type(l3))
print(l3)
l4=list() #创建一个空列表
print(type(l4))
print(l4)
运行结果：
<class 'list'>
[]
<class 'list'>
[100]
<class 'list'>
[2, 5, 5, 8, 1, 3]
<class 'list'>
[]
Process finished with exit code 0
列表常用操作1
- 访问
- 使用下标操作（索引）
- 列表的位置是从0开始的（规定列表最后一个下标为 -1）
- 分片操作
- 对列表进行任意一段的截取
- list [ : ] (截取范围是从冒号前到冒号后，但是冒号后的数字取不到）
（冒号前后可以为空，前为空表示从位置0开始，后为空表示截止最大数加一，即截取到最后一个数据） - list [ : : ] （第二个冒号表示增长幅度，默认增长幅度为1，即一个一个增长，如果此数为负值，则表示顺序为从右往左）
#下标访问列表
l=[2,3,5,4,1,6]
print(l)
print(l[4]) #提取下标数字
print(l[2:4]) #提取从下标二到下标三
print(l[ :5]) #提取从第一个到下标四
print(l[2:]) #提取从下标二到最后一个
print(l[ : :2]) #从第一个到最后一个间隔为2
print(l[-2:-5]) #下面显示为空是因为分片默认顺序是从左往右，正常情况下冒号左边的数要小于右边的数
print(l[-5:-2])
print(l[-2:-5:-1]) #如果非要这么写，则需要吧步长写为负数，但是截取的结果也是颠倒的
运行结果：
[2, 3, 5, 4, 1, 6]
1 #提取下标数字
[5, 4] #提取从下标二到下标三
[2, 3, 5, 4, 1] #提取从第一个到下标四
[5, 4, 1, 6] #提取从下标二到最后一个
[2, 5, 1] #从第一个到最后一个间隔为2
[]
[3, 5, 4]
[1, 4, 5]
Process finished with exit code 0
分片操作是生成一个新的list
- 内置函数id，负责显示一个变量或者数据的唯一确定编号
l=[2,5,3,8,4,6]
ll=l[:]
l[1]=100
#l 和 ll 不是同一个列表
print(id(l))
print(id(ll))
print(l)
print(ll)
运行结果：
287737405960
287737406024
[2, 100, 3, 8, 4, 6]
[2, 5, 3, 8, 4, 6]
Process finished with exit code 0
list（列表）操作2
- del 删除命令
- del一个变量后，此变量将无法在使用
#del案例
l=[2,5,3,8,4,6]
print(id(l))
del l[2]
print(id(l))
print(l)
运行结果：
770037604872
770037604872 #运行del函数后不会形成一个新的list，仍然是原来那个
[2, 5, 8, 4, 6]
Process finished with exit code 0
- 列表相加
- 使用加号连接两个列表
#列表相加案例
a=[1,2,3,4]
b=[5,6,8]
c=['a', 'b', 'c']
d=a+b+c
print(d)
运行结果：
[1, 2, 3, 4, 5, 6, 8, 'a', 'b', 'c']
Process finished with exit code 0
- 列表数乘
- 列表直接跟整数相乘，相当于把n个列表连在一起
#列表数乘案例
a=[1,2,3,4]
b=a*3
print(b)
运行结果：
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Process finished with exit code 0
- 成员资格运算
- 就是判断一个元素是否在list中
a=[1,2,3,4]
b=3
c=b in a
print(c)
运行结果：
True
- 列表的遍历
- for
- while （一般不用while访问列表）
#列表遍历案例：
a=[1,2,3,4]
for i in a:
print(i)
b=['i love sunyue']
for i in b:
print(i)
print("#"*20)
#以下是while用法
l=len(a)
n=0 #n表示列表的下标
while n<l:
print(a[n])
n += 1
运行结果：
1
2
3
4
i love sunyue
####################
1
2
3
4
Process finished with exit code 0
- 双层列表循环
#a为嵌套列表，又称双层列表
a=[["one",1],["two",2],["three",3]]
for k,v in a:
print(k,"---",v)
运行结果：
one --- 1
two --- 2
three --- 3
Process finished with exit code 0
列表内涵：list content
- 通过简单方法创建列表
#用for创建
a=[x for x in range(1,6 )]
b=[i for i in a] #对于a中得每一个元素，逐个放入到b中
print(b)
c=[i*10 for i in a] #将a中得每一个元素乘10 ，再逐个放入到c中
print(c)
d=[m for m in a if m % 2 ==0] #过滤：将a中得偶数提取出来放到d中
print(d)
f=[m+n for m in a for n in b] #相当于两个for循环嵌套，且同样可以使用条件表达式
print(f)
运行结果：
[1, 2, 3, 4, 5]
[10, 20, 30, 40, 50]
[2, 4]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10]
Process finished with exit code 0
- 一些题外话
#传值和传址的区别
#对于简单的数值，采用传值操作，即在函数内对参数的操作不影响外面的变量
#对于复杂变量，采用的是传地址操作，此时函数内的和外面的数据是同一份，不管在哪里更改都会影响其内容
def a(n):
n[2]=300
print (n)
return None
def b(n):
n += 100
print (n)
return None
an=[1,2,3,4,5,6,7]
bn=9
print(an)
a(an) #传址，会对其中的数值进行修改
print(an)
print(bn)
b(bn) #传值，只会改变传过来的数据，但不会改变原始数据
print (bn)
运行结果：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
9
109
9
关于列表的函数
len（）: 表示列表的长度
cmp（list1，list2）:比较两个列表的元素
max（）: 表示列表中的最大值（同理还有min）
list（）：将其他形式的数据转换为list（前提是可以转换）
zip()：将序列中的元素按照顺序进行配对组成一个元组，然后将这些元组放到新的序列当中。
- zip()函数返回的是zip类型，需要用list()函数进行转换
names = ['吴承恩', '罗贯中', '施耐庵', '曹雪芹']
books = ['西游记', '三国演义', '水浒传', '红楼梦']
times = ['1501年-1582年', '1330年—1400年', '1296年—1370年', '1715年-1763年']
books_info = zip(names, books, times)
print(list(books_info))
# 输出：[('吴承恩', '西游记', '1501年-1582年'), ('罗贯中', '三国演义', '1330年—1400年'), ('施耐庵', '水浒传', '1296年—1370年'), ('曹雪芹', '红楼梦', '1715年-1763年')]
append（）: 表示插入一个内容，在末尾追加
sort（）：将列表元素排序
index（x）：返回第一次出现x元素的索引值
a = [i for i in range(1,5)]
print(a)
a.append(100)
print(a)
运行结果：
[1,2,3,4]
[1,2,3,4,100]
insert（）: 表示指定位置插入
括号中需要定义两个值，一个表示位置下标，一个表示插入值
insert（index，data）插入的值是index的前面
a = [i for i in range(1,5)]
print(a)
a.insert(2,50)
print(a)
运行结果：
[1, 2, 3, 4]
[1, 2, 50, 3, 4]
del 删除：它是根据索引(元素所在位置)来删除
str=[1,2,3,4,5,2,6]
del str[1] #删除下标为1的元素
print(str)
[1, 3, 4, 5, 2, 6]
str=[0,1,2,3,4,5,6]
del str[2:4] #删除从第2个元素开始，到第4个为止的元素(但是不包括尾部元素)
print(str)
[0, 1, 4, 5, 6]
pop（）：从队尾拿出一个元素，即吧最后一个元素取出来，括号里也可以输入指定下标
remove（x）:在列表中删除第一次出现的元素x
clear():清空
#列表的删除实例
a = [i for i in range(1,10)]
print(a)
print(id(a))
#pop删除实例
last_del=a.pop() #通常pop用于赋值
print("提取出来的值为：",last_del)
print(a)
print(id(a)) #id一样，说明是同一个列表
b = a.pop(6)
print("提取出来下标为6的值为：",b)
print(a)
print(id(a))
#remove删除实例
a.remove(2) #删除a中数值为2的元素
print(a)
print(id(a)) #id一样，说明是同一个列表
#clear清空实例
a.clear() #清空一个列表
print(a)
print(id(a)) #id一样，说明是同一个列表
运行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
722993177096
提取出来的值为： 9
[1, 2, 3, 4, 5, 6, 7, 8]
722993177096
提取出来下标为6的值为： 7
[1, 2, 3, 4, 5, 6, 8]
722993177096
[1, 3, 4, 5, 6, 8]
722993177096
[]
722993177096
reverse 翻转列表内容
#列表的翻转实例
a = [i for i in range (1,10)]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a)) #id一样，说明是同一个列表
运行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
292435288584
[9, 8, 7, 6, 5, 4, 3, 2, 1]
292435288584
extend 扩展列表，将两个列表中的一个直接拼接到另一个的后面
#列表的扩展实例
a = [i for i in range (1,10)]
b = [i for i in range (10,15)]
print(a)
print(id(a))
a.extend(b)
print(a)
print(id(a))
运行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
62002192904
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
62002192904
count 查找列表中指定值或者元素的个数
#列表的count实例
a = [1,2,5,3,5,4,5,1,2,1]
print(a)
print(id(a))
n= int(input("请输入数字：")) #input输入的是字符，需要转换为int类型
b = a.count(n)
print("列表中{}的个数为：".format(n),b)
运行结果：
[1, 2, 5, 3, 5, 4, 5, 1, 2, 1]
637753188872
请输入数字：5
列表中5的个数为： 3
copy 拷贝， 浅拷贝
a = [1,2,3,4,5]
print(a)
b = a #list类型，简单赋值操作，是传地址
b[3] = 77
print("更改b的值后a的值为：",a)
print("a的ID地址为：",id(a))
print("更改b的值后b的值为：",b)
print("b的ID地址为：",id(b))
print("*"*20)
#拷贝实例
b = a.copy()
print("a的值为：",a)
print("a的ID地址为：",id(a))
print("b的值为：",b)
print("b的ID地址为：",id(b)) #copy之后ID地址发生改变
print("*"*20)
b[3] = 88
print("更改b的值后a的值为：",a)
print("更改b的值后b的值为：",b)
运行结果：
[1, 2, 3, 4, 5]
更改b的值后a的值为： [1, 2, 3, 77, 5]
a的ID地址为： 33841672
更改b的值后b的值为： [1, 2, 3, 77, 5]
b的ID地址为： 33841672
********************
a的值为： [1, 2, 3, 77, 5]
a的ID地址为： 33841672
b的值为： [1, 2, 3, 77, 5]
b的ID地址为： 34328264
********************
更改b的值后a的值为： [1, 2, 3, 77, 5]
更改b的值后b的值为： [1, 2, 3, 88, 5]
- 深拷贝和浅拷贝的区别
- 深拷贝需要特定的工具
a0 = [10,20,30]
a = [1,2,3,a0]
b = a.copy()
print(id(a[3]))
print(id(b[3])) #拷贝以后b中a0的地址没有发生变化
a[3][2] = 666
#浅拷贝，只拷贝一层内容
#也就是说，b拷贝的是a，而b中的a0还是指向原地址，所以改变b中a0的值后，a中a0的值也发生改变
print(a)
print(b)
运行结果：
4809224
4809224
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]
元组-tuple
- 元组可以看成是一个不可更改的list
- tuple写在一个小括号里，元素之间用逗号隔开。
- 元组的元素不可变，但是可以包含可变对象，如list。
- 元组可以用作字典的键，也可以作为集合的元素，但是列表就不可以，包含列表的元组也不可以。
元组创建
#创建空元组
t = ()
print(type(t))
<class 'tuple'>
#创建一个只有一个值的元组
t = (1,)
print(type(t))
print(t)
<class 'tuple'>
(1,)
t = 1,
print(type(t))
print(t)
<class 'tuple'>
(1,)
# 创建多个值得元组
t = 1,2,3,4,5
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4, 5)
#使用其他结构创建
l = [1,2,3,4]
t = tuple(l)
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4)
元组的特性
- 是序列表，有序
- 元组数据值可以访问，不能修改
- 元组数据可以是任意类型
- 总之，list所有特性，除了可修改，元组都具有。 也就意味着，list具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等都一模一样
生成器表达式
gen = (2**i for i in range(8)) #创建一个生成器对象
#生成器使用一次后就用完了，之后再次使用就是空的
print(gen)
print((gen)) #转换为列表
print(tuple(gen))
gen = (2**i for i in range(8))
print(next(gen)) #使用next（）函数访问下一个元素
print(next(gen))
for item in gen: #使用for循环访问剩下的所有元素
print(item,end = ' ')
gen的输出结果为： <generator object <genexpr> at 0x000001D43FF88E48>
list(gen)的输出结果为： [1, 2, 4, 8, 16, 32, 64, 128]
tuple(gen)的输出结果为： ()
第一次结果为： 1
第二次结果为： 2
剩余所有结果为：
4 8 16 32 64 128