Python Learning Journal：Day2
列表
创建
方式一：[ ]：list1 = ['变量1', '变量2']
方式二：内置函数：list2 = list(['变量1', '变量2'])
方法三：列表生成式
特点
重复存取元素、动态分配内存
查询
获取指定元素的索引：index()
index('变量')
index('变量', start, stop) 指定位置之间进行查找 [ start, stop ]
查询不存在，抛出ValueError
获取单个元素：list1[]
list1[索引] list[0]、list[2]
获取多个元素：list1[start:stop:step]
切片操作 list1[start: stop: step]
切片的结果：切片部分的拷贝
# 步长step为正数
list1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list1[1: 6: 2]) # [20, 40, 60]
print(list1[1: 6]) # 默认步长为1 [20, 30, 40, 50, 60]
print(list1[1: 6:]) # 默认步长为1 [20, 30, 40, 50, 60]
print(list1[: 6: 2]) # 默认从第0个开始 [10, 30, 50]
print(list1[1:: 2]) # 默认到最后一个元素 [20, 40, 60, 80]
# 步长step为负数
print(list1[::-1]) # 从最后一个元素开始，第0个元素结束 [80, 70, 60, 50, 40, 30, 20, 10]
print(list1[7:: -2]) # [80, 60, 40, 20]
判断指定元素在列表中是否存在
元素 in 列表名 元素 not in 列表名
列表元素的遍历
for 迭代变量 in 列表名 : 操作
添加：append、extend、insert
append()方法：列表末尾添加一个元素
extend()方法：列表末尾添加至少一个元素(存放于列表中)
insert(索引, 元素)方法：列表任意位置添加一个元素
切片：列表任意位置添加至少一个元素(切片位置后元素消失)
list1 = [10, 20, 30]
list1.append(40) # [10, 20, 30, 40]
list2 = ['hello', 'world']
list1.append(list2) # [10, 20, 30, 40, ['hello', 'world']]
list1.extend(list2) # [10, 20, 30, 40, ['hello', 'world'], 'hello', 'world']
list1.insert(1, 90) # [10, 90, 20, 30, 40, ['hello', 'world'], 'hello', 'world']
list1[1:] = list2 # 切片：[10, 'hello', 'world']
删除：remove、pop、clear、del
remove(元素) 方法：移除一个元素、重复元素删第一个
pop(索引) 方法：移除索引处元素 pop()：移除最后一个元素
切片：删除多个、产生新的列表对象
list1 = [10, 20, 30, 40, 50]
new_list = list1[1:3] # 产生新的列表对象 [20, 30]
list1[1:3] = [] # 不产生新的列表对象 [10, 40, 50]
clear()方法：清空列表元素
list1.clear() # []
del 列表名：删除列表
del list1
print(list1) # NameError: name 'list1' is not defined
修改：=
指定索引的元素、指定切片的元素
list1 = [10, 20, 30]
list1[1] = 40 # [10, 40, 30]
list1[1:3] = [50, 60]
print(list1) # [10, 50, 60]
排序：sort、sorted
sort()方法：列表中元素升序排序、在原列表上操作
sorted()函数：默认列表中元素升序排序、产生新的列表对象，原列表不改变
list1 = [90, 50, 100, 10]
list1.sort() # [10, 50, 90, 100]
list1.sort(reverse=True) # [100, 90, 50, 10]
new_list = sorted(list1) # [10, 50, 90, 100]---new_list [90, 50, 100, 10]---list1
new_list = sorted(list1, reverse=True) # [100, 90, 50, 10]---new_list [90, 50, 100, 10]---list1
列表生成式
生成列表的公式、列表中元素有一定规律
语法格式：[ 表示列表元素的表达式 for 自定义变量 in 可迭代对象 ]
list1 = [i*i for i in range(1, 4)] # [1, 4, 9]
list2 = [2*i for i in range(1, 6)] # [2, 4, 6, 8, 10]
list3 = [i+'a' for i in 'Python'] # ['Pa', 'ya', 'ta', 'ha', 'oa', 'na']
字典
特点
以键值对的方式存储数据：字典名 = { key1 : value1, key2 : value2, key3 : value3}，key不可以重复，value可以重复
- 字典是一个无序的序列 ( 第一个放进去的键不一定在第一个位置上 )
- 存储时经hash(key) 函数 计算value的存储位置—>键是不可变序列(字符串、字典、元组)
- 不能在指定位置插入元素
- 字典中的key必须是不可变对象（字符串、整数），即不可以用列表list做key
创建
方法一：{ }
方法二：内置函数dict()
方法三：字典生成式
score1 = {'张三': 100, '李四': 99, '王五': 95}
score2 = dict(name='jack', age=20)
score3 = {}
print(score1) # {'张三': 100, '李四': 99, '王五': 95}
print(score2) # {'name': 'jack', 'age': 20}
print(score3) # 空字典：{}
常用操作
获取字典中元素的值：[ ]、get
方式一：[ ]：若不存在会报错
方式二：内置函数get()：若不存在，会输出默认值
scores = {'张三': 100, '李四': 99, '王五': 95}
print(scores['张三']) # 100
print(scores.get('张三')) # 100
print(scores['陈柳']) # 报错：KeyError: '陈柳'
print(scores.get('陈柳')) # None(不会报错，但输出None)
print(scores.get('马奇', 99)) # 99(查找指定键不存在时，提供默认值99)
key的判断：in not in
in 和 not in
print('张三' in scores) # True
print('张三' not in scores) # False
删除：del、clear
del()函数：删除指定键值对
clear()方法：清空字典的元素
del scores['张三']
print(scores) # {'李四': 99, '王五': 95}
scores.clear()
print(scores) # {}
添加、修改：=
添加
scores = {'张三': 100, '李四': 99, '王五': 95}
scores['陈柳'] = 96
print(scores) # {'张三': 100, '李四': 99, '王五': 95, '陈柳': 96}
修改
scores['张三'] = 99
print(scores) # {'张三': 99, '李四': 99, '王五': 95, '陈柳': 96}
获取字典视图
keys()：获取字典中所有key
values()：获取字典中所有value
items()：获取字典中所有key、value对
scores = {'张三': 100, '李四': 99, '王五': 95}
keys = scores.keys()
print(type(keys)) # 类型：dict_keys
print(list(keys)) # ['张三', '李四', '王五']
values = scores.values()
print(type(values)) # 类型：dict_values
print(list(values)) # [100, 99, 95]
items = scores.items()
print(type(items)) # 类型：dict_items
print(items) # dict_items([('张三', 100), ('李四', 99), ('王五', 95)])
print(list(items)) # 转换之后的列表元素由元组构成 [('张三', 100), ('李四', 99), ('王五', 95)]
字典元素的遍历
for item in scores: 操作
scores = {'张三': 100, '李四': 99, '王五': 95}
for item in scores:
print(item, scores[item], scores.get(item))
输出
张三 100 100
李四 99 99
王五 95 95
字典生成式：zip
需求：有两个列表items = [‘Fruits’, ‘Books’, ‘Others’]、prices = [98, 95, 89]，需要变成{‘Fruits’: 98, ‘Books’: 95, ‘Others’: 89}的形式
内置函数：zip()
形式：{item: price for item, price in zip(items, prices) }
{表示字典key的表达式 ：表示字典value的表达式 for 自定义表示key的变量 ，自定义表示value的变量 in zip(可迭代对象，可迭代对象)
items = ['Fruits', 'Books', 'Others']
prices = [98, 95, 89]
dic = {item: price for item, price in zip(items, prices)}
print(dic) # {'Fruits': 98, 'Books': 95, 'Others': 89}
元组
可变序列：列表、字典：可对序列进行增删改操作，对象id地址不会发生变化
不可变序列：字符串、元素：没有增删改操作，即使字符串可通过+进行拼接，但拼接后对象id地址发生了变化
创建
方法一：( )：t = ('Python', 'hello', 90) 可省略括号
方法二：内置函数tuple()：t = tuple(('Python', 'hello', 90))
若只包含一个元素需要使用逗号和小括号：t = (98, )
空元组：t = ()
为什么设计成不可变序列
多任务环境下，同时操作对象不需要加锁
注意注意：
t = (10, [20, 30], 40)
print(t)
print(type(t))
print(t[0], type(t[0]), id(t[0]))
print(t[1], type(t[1]), id(t[1]))
print(t[2], type(t[2]), id(t[2]))
t[1].append(60)
print(t[0], type(t[0]), id(t[0]))
print(t[1], type(t[1]), id(t[1]))
print(t[2], type(t[2]), id(t[2]))
输出
(10, [20, 30], 40)
<class 'tuple'>
10 <class 'int'> 140704896492208
[20, 30] <class 'list'> 2499558265288
40 <class 'int'> 140704896493168
10 <class 'int'> 140704896492208
[20, 30, 60] <class 'list'> 2499558265288
40 <class 'int'> 140704896493168
遍历
方法一：循环遍历：for item in t: print(item)
方法二：t[索引]
集合
可变类型序列
集合是没有value的字典，底层数据结构也采用了hash表，无序
不可重复
创建
方法一：{ }
方法二：内置函数set( )
s1 = {2, 2, 5, 7, 8, 9} # {2, 5, 7, 8, 9}
s2 = set(range(6)) # {0, 1, 2, 3, 4, 5}
s3 = set([3, 5, 3, 6]) # {3, 5, 6}
s4 = set((2, 3, 6, 6)) # {2, 3, 6}
s5 = set('Python') # {'n', 'h', 'o', 'y', 'P', 't'}
s6 = set() # 空集合：set()
常用操作
判断
in 和 not in
添加
add()方法：一次添加一个元素
update()方法：一次至少添加一个元素(存放于列表、元组、集合中)
s = {10, 20, 30, 40}
s.add(60) # {40, 10, 20, 60, 30}
s.update({200, 400, 300}) # {40, 200, 10, 300, 400, 20, 60, 30}
s.update([1, 2]) # {1, 2, 40, 200, 10, 300, 400, 20, 60, 30}
s.update((3, 4)) # {1, 2, 3, 4, 40, 200, 10, 300, 400, 20, 60, 30}
删除
remove()方法：移除一个元素，元素不存在则报错KeyError
discard()方法：移除一个元素，元素不存在不会报错
pop()方法：没有参数，随机移除一个元素
clear()方法：删除整个集合
s.remove(1) # {2, 3, 4, 40, 200, 10, 300, 400, 20, 60, 30}
s.remove(999) # 报错：KeyError: 999
s.discard(999) # 虽然没有999，但不报错
s.pop() # 随机删除了2：{3, 4, 40, 200, 10, 300, 400, 20, 60, 30}
s.clear() # set()
集合间的关系
集合是否相等：== 或 != 与集合中元素顺序无关
s1 = {10, 20, 30, 40}
s2 = {20, 40, 10, 30}
print(s1 == s2) # True
print(s1 != s2) # False
一个集合是否是另一个集合的子集：issubset()方法
s3 = {10, 20}
print(s3.issubset(s1)) # True---s3是s1的子集
一个集合是否是另一个集合的超集：issuperset()方法
s4 = {10, 20, 30, 40, 50}
print(s4.issuperset(s1)) # True
两个集合是否没有交集：isdisjoint()方法
s5 = {60}
print(s5.isdisjoint(s1)) # True--没有交集
集合的数学操作
求交集：intersection()方法：s1.intersection(s2) 或者 s1 & s2
求并集：union()方法：s1.union(s2) 或者 s1 | s2
求差集：difference()方法：s1.difference(s2) 或者 s1-s2
求对称差集：symmetric_difference()方法：s1.symmetric_difference(s2) 两个集合中不共有的元素构成的集合
集合生成式
公式：{表示集合元素的表达式 for 自定义变量 in 可迭代对象}
s = {i*i for i in range(6)}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
