疫情环境下的网络学习笔记 python 3.11

3.11

昨日回顾

  1. for循环

    • 在循环取值上比while循环更简单

      for x in 可迭代对象:

      只要包含多个值，就可以被for循环

    • for循环能干的事while都能干，for循环次数取决于迭代对象的值的个数，while循环次数取决于条件

    • for i in range()

      range(start,end,step)

      py2与py3重range的区别

    • break，else，continue

  2. 基本数据类型

    1. int
    2. float
    3. str

今日内容

  1. 列表
  2. 元组
  3. 字典

正课

列表

作用

按位置存放多个值，取的时候可以用索引

定义

在中括号内用逗号分开多个任意类型的值

L = [1,2,3,4,’qqq’]，实际上是用了 list()功能，返回一个列表，赋值给L

类型转换

list() ：但凡能够被for 循环遍历的类型都可以当作参数传给 list() 转换成列表：列表，字典，元组，字符串

dic = {
    'qqq':111,
    'www':None,
    'sss':[111,222,333]
}
name = 'deimos'
lis1 = list(dic)
lis2 = list(name)
print(lis1)
print(lis2)
#['qqq', 'www', 'sss']
#['d', 'e', 'i', 'm', 'o', 's']

list 底层相当于调用一个for 循环，遍历每一个元素，存入列表。所以 list9(dic) 取出的列表是字典的 key

字典是无序的，用 list 转换后，key的索引也是无序的，出现位置随。

内置方法

必须掌握的操作：读写

  1. 按照索引取值 list[index]

    L = [111,222,'deimos']

    1. 正向取 print(L[0])

    2. 反向取print(L[-1])

    3. 可以取也可以改

      L[0] = 444 索引存在则修改列表内索引对应的值，无论是取还是赋值，索引不存在则报错

  2. 往列表里面追加值 list.append()

    在列表最后添加一个值

  3. 往列表中插入值 llist.insert()

    list.insert(index,item)：把一个值放到指定的索引前面，index为int

    list3 = [11,22,33,44]
list3.insert(3,'w')
print(list3)

  4. 往列表后面添加列表 list.extend()

    传入参数：可迭代对象，必须传入一个可以被for循环的类型，将对象的每一个元素添加到列表中去

    相当于

    for item in 可迭代对象
	list.append(item)

    注意：这些方法都没有返回值，不能在print()中用 点 . 使用，与字符串中 .strip() 一类的方法不一样

  5. dle 删除

    del List：通用的删除方式，可以删除整个列表，也可以删除元素，没有返回值。

  6. pop 删除

    L.pop() ：不传入参数，默认删除最后一个元素

    L.pop(index) ：传入一个索引，返回了被删除的值

    list3 = [11,22,33,44]
print(list3.pop(1))  # 22
print(list3)  # [11, 33, 44]

  7. **remove 删除 **

    L.remove(‘item’)：输入指定的元素，删除指定的元素，没有返回值。如果输入的参数在列表中不存在，则报错

    按照需求选择删除的方法，想拿到被删除的值，就用pop，指定元素删除，用remove

  8. 切片 L[0:10:1]

    list[start:end:step]跟字符串一样，要头不要尾

    不传入参数，只传一个冒号：L[:]，默认步长为1，从0开头切到结尾

    切片等同于拷贝行为，相当于浅拷贝

    list4 = list3[:]
print(list3,id(list3))
print(list4,id(list4))
# [11, 22, 33, 44, 55] 2234423690240
# [11, 22, 33, 44, 55] 2234423690432
# 创建一个新列表，切片得到的元素继续指向原列表中的元素

    取反向步长：

    list1 = list[::-1]
# 反向输出列表

  9. 循环 for

其他操作

  1. list.count(item)

    统计个数，看列表中出现这个元素的次数

  2. list.index(item)

    在列表中找一个元素，返回找到的第一个元素位置，没有则报错

  3. list.clear()

    没有参数，清空列表，不返回值

  4. list.reverse()

    将列表倒过来

  5. list.sort(key = ,reverse = True/False)

    针对列表内全为数字，或全为字符串，排序列表，默认从小到大排序（升序），要降序排列，加一个参数rever = True：list.sort(reverse = True）

    该方法不返回值

    list3 = [11,-22,33,-44,55]
list4 = ['aaa','bbb','qqq']
list3.sort(reverse = True)
print(list3)
print(list4)
# [55, 33, 11, -22, -44]
# ['aaa', 'bbb', 'qqq']

字符串，列表排序的方法

  • 排序字符串的方法：从左到右对字符串依次比较，第一位与第一位比，按照ascii表上的位置判断结果，如第一位一样则比第二位，以此类推

    字母靠后，ASCII码大，Z < a < z

  • 排序列表的方法：同字符串比较的方法

    L1 = [111,22,'a']
L2 = [111,22,'c']
print(L1<L2)
# True

    第一个与第一个比，一样则第二个与第二个比，以此类推。两个列表同样位置的元素必须是同样的类型，否则报错

补充：队列，堆栈

  • 队列：first in first out

    先进先出，类似于扶梯，先上的一定先下

    入队：list.append()

    出队：list.pop(0)

  • 堆栈：last in first out

    后进先出，类似于上下电梯，后进的先出

    入队：list.append()

    出队：list.pop()

元组

作用

可以看作一个不可变的列表，按照索引存值，只用来读，不可改

定义

  • 在小括号()内用逗号分隔开多个任意类型的元素

  • tup = (1,44,’a’,[’aa’,’bb’,3])，相当于使用了tuple()方法，赋值给tup

  • 定义元组时若只有一个元素，必须加逗号

    tup1 = (‘aaa’,)

  • 元组不可变的意思是元组内索引及对应的内存地址不可变，而索引如果指向一个可变类型，则这个可变类型是可以改的

内存中使用列表，需要支持其读、写操作，使用元组，只需支持其读操作。所以同等数据量的情况下，元组比列表省空间

内置方法

  1. 索引取值
  2. 切片
  3. 长度 len()
  4. 成员运算
  5. 循环 for
  6. 查找索引 index(item)
  7. 计数 count(item)

字典

定义

在花括号{}内用逗号分隔开多个key：value，其中value可以是任何类型，key必须是不可变类型（元组也可以当key）

实际上底层调用的功能：dict()

  • d = {} 默认定义的是空字典，而不是空集合

造字典的方式

  • 直接定义

  • dict()+’ key = value’ 方式

    d = dict(a = 1, b = 2, c = 3)
print(d)
# {'a': 1, 'b': 2, 'c': 3}

  • 使用dict函数转换列表的数据类型

    现有一可迭代对象，想把它的每个子元素取出来，第一个当作key，第二个当作value

    可以使用for来做

    info = [
    ['name', 'deimos'],
    ('age', 18),
    ['sex', 'male']
]
d = {}
for key, value in info:
    d[key] = value
print(d)
# {'name': 'deimos', 'age': 18, 'sex': 'male'}

    或着使用dict直接定义

    res = dict(info)
print(res)

    dict传入的对象中，每个子容器（列表，元组）必须要有两个元素，第一个用于key，第二个用于value，否则报错

  • 快速初始化一个字典

    将列表中每个元素取出来，作为字典的key，value为none，造一个字典

    keys = ['a','b','c']
d = {}.formkeys(keys,None)

    底层使用for循环，相当于遍历对象每一个值，加上None，赋值给空字典

内置方法

优先掌握

  1. 按key存取值：可存可取

    d['key1'] = 222

    若key存在，则覆盖旧值，若不存在，则创建新值

    字典中key值不能重复，若重复，则下面的值会覆盖上面的值

  2. 求长度 len()
    重复的键值不会被计入个数

  3. 成员运算 in

    看某个key值是否在这个字典里

  4. 删除

    1. 通用删除 del

    2. dic.pop(key)

      根据key来删除，返回被删除key对应的value

    3. dic.popitem()

      随机删除一对键值，返回一个元组，元组中是刚刚删除的（key，value）

  5. dic.keys()

    列表得到全部的key

  6. dic.values()

    列表得到全部的value

  7. dic.items()

    拿到一个列表，列表中是一个个元组，元组中（key，value）形式存放键值

    python2中这几个方法得到鸡蛋，python3中得到下单的母鸡：

    • py2：生成一个真的列表
    • py3：生成一个可迭代对象，节省内存

其他内置方法

  1. dic.clear()：清除字典，变成一个空字典

  2. dic.copy()：浅拷贝

  3. dic.update(new_dic)：更新字典，传入参数是一个字典，对老字典中的值，有的则覆盖值，没有的则创建

  4. dic.get(key)：字典取值的方法，若字典中存在key，则返回value；若不存在则不反回值

    .get()方法，如果要取的key不存在也不会报错，容错性好

  5. dic.setdefault(key,value)：需求，对一个字典判断其是否存在这个key

    • 如果存在，就不变，返回原字典中key对应的value
    • 如果不存在，则将key，value加入原字典，返回字典中key原来对应的值

pass占位符，... 什么都不做，防止报错

总结

  • 有序or无序
  • 存一个值or存多个值
  • 可变or不可变
posted @ 2020-03-11 16:25  黑猫警长紧张  阅读(207)  评论(0)    收藏  举报