Python基础(篇二)

四. 列表

为什么需要列表

• 变量可以存储一个元素，而列表是一个“大容器"可以存储N多个元素，程序可以方便地对这些数据进行整体操作

• 列表相当于其它语言中的数组

• 列表示意图

  

1. 列表的创建与删除

1. 列表的创建

   • 列表需要使用中括号[],元素之间使用英文的逗号进行分隔

     lst = ['hello','python']
     

   • 列表的创建方式

     //使用中括号
     lst = ['hello','python']
     //使用内置函数list()
     lst2 = list(['hello','python'])
     

2. 列表的特点

   • 列表元素按顺序有序排序

   • 索引映射唯一个数据

     索引正序是从0开始

     索引倒叙从-1开始

   • 列表可以存储重复数据

   • 任意数据类型混存

   • 根据需要动态分配和回收内存

2. 列表的查询操作

1. 获取列表中指定元素的索引 index()
   • 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
   • 如果查询的元素在列表中不存在，则会抛出ValueError
   • 还可以在指定的start和stop之间进行查找

2. 获取列表中的单个元素

   • 正向索引从0到N-1举例: Ist[0]
   • 逆向索引从-N到-1举例:Ist[-N]
   • 指定索引不存，抛出IndexError

3. 查询多个元素

lst = list(range(1,10))
print("原列表",lst)
lst1 = lst[0:2:1] #lst[start:stop:step] 从索引0开始，到索引stop结束，不包含stop 步长为step 产生一个新的列表
print(lst1)
lst2 = lst[2:8:2]
print(lst2)

"""如果步长step为负数，则从最后一个元素开始切片"""
lst3 = lst[::-1] #排序修改为倒排
print(lst3)
lst4 = lst[5:1:-1] #从索引为5的元素开始倒排切片，到索引为1的元素，不包含索引为1的元素
print(lst4)

3. 列表元素的增删改操作

1. 增加操作

   | 方法/其他 | 操作描述 |
   | --------- | -------------------------------- |
   | append() | 在列表的末尾添加一个元素 |
   | extend() | 在列表的末尾至少添加一个元素 |
   | insert() | 在列表的任意位置添加一个元素 |
   | 切片 | 在列表的任意位置添加至少一个元素 |

lst.append(20) #向列表的末尾添加一个元素
lst.append(30) #向列表的末尾添加一个元素
print(lst)
lst.extend([50,60]) #向列表的末尾至少添加一个元素,添加的是列表
print(lst)
lst.insert(3,50)  #向列表任意位置添加元素  第一个参数是索引 第二个是元素
print(lst)
lst.insert(-1,55)
print(lst)
temp = lst[5:10:2] 
print(temp)

1. 删除操作

lst = [10,20,30,50,410,10,20,35,5,40]
lst.remove(10) #删除指定元素。如果有重复的，则删除第一个
print(lst)
# lst.remove(222) #如果删除的元素不存在，则抛出ValueError异常
lst.pop(2) #删除指定索引位置的元素
print(lst)
lst.pop(-1)
print(lst)
lst.pop() #如果不指定索引，则会删除列表最后一个元素
print(lst)

print(id(lst))
lst = lst[1:3] #会产生新的列表对象
lst[1:3]=[]  #不产生新的列表对象
print(lst)
print(id(lst))

lst.clear() #清除列表中得元素
del lst #删除列表

1. 修改操作

类似java的数组赋值操作

4. 列表元素的排序

1. 调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序
2. 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变

lst = [10,50,30,20,40]
lst.sort() #升序排序
print(lst)
print(id(lst))
lst.reverse()  #降序排序
lst.sort(reverse=True) #降序排序
lst.sort(reverse=False) #升序排序
print(lst)
print(id(lst))
"""以上排序方法不会产生新的列表对象"""

lst1 = [10,50,30,20,40]
result = sorted(lst1,reverse=True)  #使用内置方法排序，会产生一个新的列表对象
print(lst1)
print(result)

5. 列表推导式

lst = [i for i in range(1,10)]  #自定义生成列表
print(lst)

lst = [i*i for i in range(1,10)]   #自定义生成列表
print(lst)

五.字典

1. 什么是字典(java中的map)

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据,字典是一个无序的序列

2. 字典的原理

元素存入字典得时候，会将key进行hash运算，将得到得hash值存入字典。

取值得时候，通过计算key的hash值，去字典中查询

3.字典的创建和删除

1. 创建

   //使用花括号
   scores = {"name":"张三","age":20}
   //使用内置函数dict()
   dict(name="张三",age=20)
   

2. 删除

   scores.pop(key) //删除指定键
   scores.clear() //清空整个字典
   

4.字典的查询操作

1. 使用[] ：scores['name']
2. 使用get()方法: scores.get('name')

[] 和get()的区别：

• []如果字典中不存在指定的key，抛出keyError异常
• get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

mymap = {"userName":"张三","userAge":20,"height":175.5}
print(mymap.get("userName"))
# print(mymap["userName1"]) #如果键不存在，则会抛出KeyError异常
user = dict(name="二狗",age=2)
print(user.get("name"),user.get("age"))
print(user.get("asdad"))  #如果键不存在，则会返回none
print(user.get("nima","默认值")) #如果键不存在，则会返回默认值

5.字典元素的增删改操作

mymap = {"userName":"张三","userAge":20,"height":175.5}
print(mymap)
print("userName" in mymap)
del mymap["userName"]  #删除指定key
print(mymap)
mymap["userName"] = "李二狗"
print(mymap)
mymap.clear() #清除字典
print(mymap)

常用操作

mymap = {"userName":"张三","userAge":20,"height":175.5}
print(mymap.keys())   #获取字典中的所有key
print(mymap.values())  #获取字典中的所有value
print(mymap.items())   #获取字典中的所有key-value
lst = list(mymap.items())
print(lst)

遍历字典

for item in mymap:   #遍历字典，item是字典的key值
    print(item,"-",mymap.get(item))

字典的特点

• ·字典中的所有元素都是一个key-value对, key不允许重复，value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
• 字典也可以根据需要动态地伸缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

6.字典推导式

userFiles = ["userName","age","height"]
userVals = ["张三",25,175.5]
d = {key.upper():val for key,val in zip(userFiles,userVals)}  #字典推导
print(d)