python学习笔记（二） 列表、元组、字典、set

参考博客：总结的十分详细（https://blog.csdn.net/E_I_D_/article/details/82026638）

 

1、列表 list

列表是一种容器

列表是可以被改变的序列

列表是由一系列特定元素组成的，元素与元素之间可能没有任何的关联关系，但他们有先后顺序的关系

1.1创建空列表的字面值表达式

1） []       # 创建一个空列表
2） L = []   # L 变量绑定一个新创建的空列表

1.2 创建非空字面值得表达式：

L= [1,2,3,4]    # L绑定一个新创建的且含有四个元素的列表
L= [1,'a',3.14,'你好']  # 同上

 

1.3列表的构造函数 list

1） list()   生成一个空的列表  等同于[]
2） list(iterable)   用可迭代对象创建一个列表
示例：
L = list()          # L=[]
L = list("hello")   # L = ['h','w','l','l','o']  # 字符串为可迭代对象
L = list(range(5))  # L = [0,1,2,3,4]            # range()函数返回可迭代对象

 1.4列表的运算：

1)算术运算：     + += * *= （运算规则于字符串的运算规则相同）
+：用于拼接列表，生成新的列表
    z = [1,2,3] + [4,5,6]   : z = [1,2,3,4,5,6]
+=：用原列表与右侧可迭代对象追加来修改原列表
    语法：
    列表变量 += 可迭代对象
    示例：x = [1,2,3]+=[4,5,6] :x =  [1,2,3,4,5,6]

+=：列表是可改变的变量，改变原来的列表对象，但是不改变列表地址，并不会创建新的列表
*：生成重复的列表
    x=[1]   x*2=[1,1]
*=：生成重复的列表，并改变对变量的绑定
    x=[1]   x*=3   x=[1,1,1]

 

1.5列表的 in / not in 运算符

1)判断一个值是否存在于列表中，如果存在返回True,否则返回 False
2)同字符串的 in 运算符 用于检查一个值是否存在于列表中，如果存在返回True, 否则返回False
示例:
----------------------------
x = [1, 'Two', 3, '四']
3 in x       # 返回 True
'3' in x     # 返回 False
10 in x      # False
10 not in x  # True
--------------------- 

1.6列表的索引操作

1)语法: 列表[整数表达式]
2)用法: 与字符串索引的用法相同(分为正向索引和反向索引)
示例:
----------------------------
x = [1,3,5,7]
print(x[1])   # 3　　
print(x[-1])  # 7

1.7 列表的索引赋值: 
列表是可变的，可以通过索引赋值改变列表中的元素

1）语法:  列表[整数表达式] = 表达式
2）作用:  改变列表中索引的绑定关系
示例:
----------------------------
x = [1, 2, 3, 4]    
x[2] = 3.14  # 改变了第三个元素的值
此时： x = [1,2,3.14,4]
--------------------- 

 

2、元组：

元组是不可改变的序列。但同列表一样的是：元组可以存放任意类型的元素 
元组一但创建将不可改变

#定义只有一个元素的元组
#元组一旦初始化就不能再修改
tuple = (1,)
print(tuple)
print(type(tuple))

#元组元素访问
tuple1=(1,2,3,4,5)
print(tuple1[0])

#修改元组
tuple2=(1,2,3,4,[5,6,7])
#tuple2[0]=100 元组创建后不能再修改
tuple2[-1][0] = 500  #元素为list时可变，改变元素为list的信息
print(tuple2)

#删除元组
tuple3=(1,2,3)
del tuple3

#元组的操作
t7=(1,2,3)
t8=(4,5,6)
t9=t7 + t8
print(t9)

#判断元素是否在元组中
t11=(1,2,3)
print(4 in t11)

#元组截取
#格式：元组名【开始下标：结束下标】
t12=(1,2,3,4,5,6,7,8,9)
print(t12[3:7])

#二维元组:元素为一维元组的元素
t13=((1,2,3),(4,5,6),(7,8,9))
print(t13[1][1])

#元组的方法
#len()返回元组中元素的个数
t14=(1,2,3,4,5)
print(len(t14))

#将列表转为元组
#list=[1,2,3]
#t15 = tuple(list)
#print(t15)

#元组遍历
for i in (1,2,3,4,5):
    print(i)

 

3、字典：

1)字典是一种可变的容器，可以存储任意类型的数据
2)字典中的每个数据都是用'键'(key)进行索引的，而不像序列可以用索引下标进行索引
3)字典中的数据没有先后顺序关系,字典的存储是无序的
4)字典中的数据以键-值对(key-value)对形式进行映射存储
5)字典的键不能重复,且只能用不可变类型作为字典的键
 

3.1字典的字面值表示方法：

以{} 括起来,以冒号(:) 分隔键-值对,各键值对用逗号分隔开


如：dict1 = {"tom":60,"lilei":70}

概述：使用键值（key-value）存储，具有极快的查找速度

字典是无序的

key的特性：
1、字典中的key必须唯一；
2、key必须是不可变的对象；
3、字符串、整数等都是不可变得，可以作为key；
4、list是可变的，不能作为key；

使用字典，学生姓名为key，学生成绩为值
'''

dict1 = {"tom":60,"lilei":70}

#元素的访问
#获取：字典名[key]
print(dict1["lilei"])
#print(dict1["sunck"]) #没有数据
ret=print(dict1.get("sunck"))
if ret == None:
    print("没有")
else:
    print("有")

#添加
dict1["hanmeimei"] = 99
#一个key对应一个value,多次复制只会修改值
dict1["lilei"] = 80
print(dict1)

#删除
dict1.pop("tom")
print(dict1)

#遍历
for key in dict1:
    print(key,dict1[key])

for value in dict1.values():
    print(value)

print(dict1.items())
for k,v in dict1.items():
    print(k,v)

for i,v2 in enumerate(dict1):
    print(i,v2)

 

#字典和list比较
#1、查找和插入速度快，不会随key-value的增加而变慢
#2、需要占用大量内存，内存浪费多


#list
#1、查找和插入的速度会随着数据量增大减慢
#2、内存占用小

可以用于字典的函数：

len(x)  返回字典的键值对个数
max(x)  返回字典键的最大值
min(x)  返回字典键的最小值
sum(x)  返回字典所有键的和
any(x)  真值测试,只对键进行测试
all(x)  真值测试,全部键为真值.结果才为True
------------------------------------------
示例:
------------------------------------------
d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
len(d)  # 4
max(d)  # 8
min(d)  # 0
sum(d)  # 16
any(d)  # True
all(d)  # False

 字典的方法

方法名         说明
D.clear()     清空字典
D.pop(key)    移除键,同时返回此键对应的值
D.copy()      返回字典D的副本(浅拷贝)
D.update(D2)  将字典D2合并到D中,如果键相同,则此键的值取D2的值为为新值
D.get(key, default=None)    返回键key所对应的值,如果没有此键,则返回Default的值
D.keys()      返回可迭代的dict_keys集合对象
D.values()    返回可迭代的dict_value集合对象
D.items()     返回可迭代的dict_item对象
------------------------------------------
示例:
------------------------------------------
d = {1: 'One', 2: "Two"}
d2 = {2: '二', 3: '三'}
d3 = d.copy()   # 复制
d3.pop(1)       # d3 = {2: "Two"}
d.update(d2)    # d = {1: 'One', 2: '二', 3: '三'}
d = {1: 'One', 2: '二', 3: '三'}
for k in d.keys():
print(k)        # 1 2 3
for v in d.values():
print(v)        # 'One' '二' '三'
for t in d.items():
print(t)        # (1, 'One') (2, '二') (3, '三')
--------------------- 

 

4、set

set 类似dict，是一组key的集合，不存储value
本质：无序和无重复的元素的集
#重复元素在set中会自动被过滤

#创建
#创建需要一个list或者tuple

s1=set([1,2,3,4,5,4,5])
print(s1)

s2=set((1,2,3,3,2,1))
print(s2)

#删除
s6 = set([1,2,3,4,5])
s6.remove(3)
print(s6)


#遍历
s7=set([1,2,3,4,5])
for i in s7:
    print(i)
#set没有索引 #print(s7[3])

for index, data in enumerate(s7):
    print(index,data)

s8 = set([1,2,3])
s9 = set([2,3,4])
#交集
a1 = s8 & s9
print(a1)
print(type(a1))

#并集
a2 = s8 | s9
print(a2)
print(type(a2))