Python学习笔记（二）

目录

1.列表元素的排序

2.列表生成式

3.字典的概念

4.字典的创建

5.获取字典中元素

6.字典的常用操作

7.获取字典视图的三个方法

8.字典元素的遍历

9.字典生成式

10.元组的概念

11.元组的创建

12.元组：不可变序列

13.元组的遍历

---

1.列表元素的排序

• 调用sort()方法，默认升序，指定reverse=True进行降序排序

lst=[20,80,60,40]
lst.sort()
print(lst)      #[20,40,60,80],即在原列表基础上更改，id不变

#指定reverse参数，进行降序排序
lst.sort(reverse=True)
print(lst)      #[80,60,40,20],降序排序

• 调用内置函数sorted()，默认升序，指定reverse=True进行降序排序，原列表不发生改变

lst=[20,80,60,40]
new_lst=sorted(lst)     #产生一个新的列表对象
print(new_lst)          #[20,40,60,80],id改变

#指定reverse参数，进行降序排序
new_lst=sorted(lst,reverse=True)
print(new_lst)          #[80,60,40,20],降序排序

2.列表生成式

lst=[i for i in range(10)]
print(lst)                    #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

lst=[i*i for i in range(10)]
print(lst)                    #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

lst=[i for i in range(2,11,2)]
print(lst)                    #[2, 4, 6, 8, 10]

3.字典的概念

• 以键值对的方式存储数据，字典是一个无序的序列（列表是有序的），因为在往字典中存数据时，是要经过hash函数的，第1个存的数据不一定放在第一个位置上
• 根据key查找value所在的位置
• key不允许重复，value可以重复
• 字典中的key是不可变对象
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

4.字典的创建

• 使用花括号（最常用）

scores={'张三':100,'李四':98,'王五':45}     #张三、李四、王五是键，100、98、45是值

• 使用内置函数dict()

dict(name='jack',age=20)       #name、age是键，jack、20是值

5.获取字典中元素

• [key]获取

scores['张三']

• get(key)获取

scores.get('张三')

• 二者区别：[]：如果字典中不存在指定的key，抛出keyError异常；get()：若不存在指定key，不会抛出keyError异常，而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

scores={'张三':100,'李四':98,'王五':45}
print(scores['张三'])           #100
print(scores.get('张三'))       #100

#当指定的键不存在时
#print(scores['张七'])        #抛出KeyError异常
#print(scores.get('张七'))      #None

#通过参数设置默认的value，以便指定的key不存在时返回
print(scores.get('张七',99))    #99

6.字典的常用操作

• 判断key是否存在：in、not in

scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)            #True
print('张三' not in scores)        #False

• 字典元素的删除：del、clear()

del scores['张三']       #删除指定的key-value对
scores.clear()           #清空字典中所有的元素

• 字典元素的新增

scores['Jack']=90

7.获取字典视图的三个方法

• keys()：获取字典中所有key

scores={'张三':100,'李四':98,'王五':45}
keys=scores.keys()
print(keys)                   #dict_keys(['张三', '李四', '王五'])
print(list(keys))             #将所有键组成的视图转成列表，['张三', '李四', '王五']

• values()：获取字典中所有的value

scores={'张三':100,'李四':98,'王五':45}
values=scores.values()
print(values)                   #dict_values([100, 98, 45])
print(list(values))             #将所有值组成的视图转成列表，[100, 98, 45]

• items()：获取字典中所有key-value对

scores={'张三':100,'李四':98,'王五':45}
items=scores.items()
print(items)                   #dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(list(items))             #将所有键值对组成的视图转成列表，[('张三', 100), ('李四', 98), ('王五', 45)]，列表中每一个元素为一个元组

8.字典元素的遍历

scores={'张三':100,'李四':98,'王五':45}
for item in scores:
    print(item,scores[item])        #item获取到的是字典中的键

9.字典生成式

• 内置函数zip()：用于将可迭代的对象作为参数，将对象中对应的元素打包成元组，然后返回由这些元组组成的列表

items=['Fruits','Books','Others']
prices=[96,78,85]
d={item.upper():price for item,price in zip(items,prices)}
print(d)        #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
#备注：若两个列表元素个数不相等，在打包的过程中，会以元素少的列表为基准

10.元组的概念

• python内置的数据结构之一，是一个不可变序列，没有增、删、改操作（Python中共两个不可变序列，另一个是字符串，改变的话会生成新的对象，id改变了，地址更改了）

11.元组的创建

#直接小括号
t=('Python','hello',90)
#也可以省略小括号
t='Python','hello',90
#使用内置函数tuple()
t=tuple(('Python','hello',90))
#只包含一个元组的元素需要使用逗号和小括号,都不能省，否则会当做本身类型
t=(10,)    #不加逗号的话，会被认为是int类型

#空元组的创建
t=()
t=tuple()

12.元组：不可变序列

t=(10,[20,30],9)
print(t)                           #(10, [20, 30], 9)
print(t[0],type(t[0]))             #10 <class 'int'>
print(t[1],type(t[1]))             #[20, 30] <class 'list'>
print(t[2],type(t[2]))             #9 <class 'int'>

#在该元组中t[1]是一个列表，是可变序列，所以可以为列表中新增元素，对象地址不会改变
t[1].append(40) 
print(t)                           #(10, [20, 30, 40], 9)

13.元组的遍历

t=('Python','hello',90)
#索引获取
print(t[0])       #要遍历的话得先知道元组元素个数，否则会越界
#for -in遍历
for item in t:
    print(item)