python中返回上级目录

case 1

假设现在需要遍历列表，且要用到其位置索引进行相应数据操作，通常会习惯写成如下形式

data = [1, 4, 5, 7, 9]
for i in range(len(data)):
    if data[i] % 2:
        data[i] = 0
print(data)

>>> [0, 4, 0, 0, 0]

但更好的方式是使用Python的内置枚举函数enumerate，可以直接获取到相应值及其索引

data = [1, 4, 5, 7, 9]
for idx, num in enumerate(data):
    if num % 2:
        data[idx] = 0
print(data)

>>> [0, 4, 0, 0, 0]

case 2

下一个，如果需要对列表进行增删改操作，比如这个例子

case2 = [9, 8, 8, 3, 3, 1]

for i in case2:
    if i % 2 == 0:
        case2.remove(i)
print(case2)

>>> [9,8,3,3,1]

在上一期中说过这样的操作是错误的，或许你意识到了列表是可变对象，直接对他操作会出问题，但还是喜欢写成如下形式

case2 = [9, 8, 8, 3, 3, 1]
out = []

for i in case2:
    if i % 2 != 0:
        out.append(i)
print(out)

>>> [9,3,3,1]

但通常列表推导式是更简单更快的方式

case2 = [9, 8, 8, 3, 3, 1]
out = [x for x in case2 if x % 2 != 0]
print(out)

>>> [9,3,3,1]

case 3

如果你需要对可迭代对象进行排序，比如列表、元组、字典，首先以列表为例子，可以直接使用内置函数sorted完成任务

data = [-1, -10, 0, 9, 5]
new_data = sorted(data)
print(new_data)

>>> [-10, -1, 0, 5, 9]

如果想使用降序，可以将参数reverse设置为True

data = [-1, -10, 0, 9, 5]
new_data = sorted(data, reverse=True)
print(new_data)

>>> [9, 5, 0, -1, -10]

同样的适用于元组，但注意此时输出类型变成了列表

data = (-1, -10, 0, 9, 5)
new_data = sorted(data, reverse=True)
print(new_data)

>>> [9, 5, 0, -1, -10]

如果需要对复杂的可迭代对象进行排序，比如列表中的元素为字典类型，在这个例子中，需要按age大小对列表进行排序，那么可以在参数key这使用匿名函数lambda

data = [
    {"name" : "jia", "age" : 18},
    {"name" : "yi", "age" : 60},
    {"name" : "bing", "age" : 20}
]
new_data = sorted(data, key=lambda x: x["age"])
print(new_data)

>>> [{'name': 'jia', 'age': 18}, {'name': 'bing', 'age': 20}, {'name': 'yi', 'age': 60}]

case 4

下一个知识点，现在有一个包含多个值的列表，但存在重复值，如果需要去重，最简单的做法是将我们的list转为set，会自动进行重复值的删除

data = [1, 1, 2, 3, 3, 4, 5, 5, 7] 
new_data = set(data)
print(new_data)

>>> {1, 2, 3, 4, 5, 7}

关于集合set，常见的用法是在两组数据中进行运算，如，求交集

data_1 = {'Mathematics', 'Chinese', 'English', 'Physics', 'Chemistry', 'Biology'}
data_2 = {'Mathematics', 'Chinese', 'English', 'Politics', 'Geography', 'History'}
print(data_1 & data_2)

>>> {'English', 'Chinese', 'Mathematics'}

求并集

data_1 = {'Mathematics', 'Chinese', 'English', 'Physics', 'Chemistry', 'Biology'}
data_2 = {'Mathematics', 'Chinese', 'English', 'Politics', 'Geography', 'History'}
print(data_1 | data_2)

>>> {'Geography', 'English', 'History', 'Mathematics', 'Politics', 'Physics', 'Chemistry', 'Chinese', 'Biology'}

求差集

data_1 = {'Mathematics', 'Chinese', 'English', 'Physics', 'Chemistry', 'Biology'}
data_2 = {'Mathematics', 'Chinese', 'English', 'Politics', 'Geography', 'History'}
print(data_1 - data_2)

>>> {'Biology', 'Chemistry', 'Physics'}

求不同时包含于两集合中的数据

data_1 = {'Mathematics', 'Chinese', 'English', 'Physics', 'Chemistry', 'Biology'}
data_2 = {'Mathematics', 'Chinese', 'English', 'Politics', 'Geography', 'History'}
print(data_1 ^ data_2)

>>> {'Geography', 'Politics', 'Chemistry', 'Physics', 'Biology', 'History'}

case 5

下一个，当我们有一个包含很多数据的列表，如果执行如sum等操作，可能会出现内存问题

data = [i for i in range(10000)]
print(sum(data))

>>> 49995000

但是如果将中括号改成小括号，即变成生成器，将提升效率

data = (i for i in range(10000))
print(sum(data))

>>> 49995000

为方便对比，我们导入Python标准库sys进行演示，可以看到生成器的方式将大大节省空间

import sys

data_1 = [i for i in range(10000)]
print(sys.getsizeof(data_1), "bytes")

data_2 = (i for i in range(10000))
print(sys.getsizeof(data_2), "bytes")

>>> 87624 bytes
>>> 120 bytes

case 6

下一个，定义一个拥有不同键值对的字典，正常情况下当你获取字典中不存在的键时会报错

data = {"name" : "sds", "age" : "18"}
uid = data["uid"]
print(uid)

>>> Traceback (most recent call last):
  File "f:/case/main.py", line 2, in <module>
    uid = data["uid"]
KeyError: 'uid'

而你在工程文件中经常会注意到使用get方法，避免因键不存在而引起的程序崩溃，若索引不到，将返回在第二个位置定义的参数

data = {"name" : "sds", "age" : "18"}
uid = data.get("uid", "6688")
print(uid)

>>> 6688

类似的还有setdefault，如果键不存在于字典中，将会添加键并将值设为默认值，这些非常实用

data = {"name" : "sds", "age" : "18"}
uid = data.setdefault("uid", "6688")
print(uid)
print(data)

>>> 6688
>>> {'name': 'sds', 'age': '18', 'uid': '6688'}

case 7

下一个，也是我比较喜欢的，如果想完成字符串中某位置插入某对象的格式化操作，f-Strings将会是一个不错的方式

name = "sds"
data = f"Hi {name}"
print(name)

>>> Hi sds

还可以在大括号内进行运算，这是Python3.6开始支持的新的格式化操作，相比以前更简洁方便。

i = 9
data = f"{i} * {i} = {i * i}"
print(data)

>>> 9 * 9 = 81

case 8

下一个，定义一个列表，里面存放字符串对象，如果想实现拼接，由于字符串是不可变对象，很多人会定义空字符串进行遍历拼接，但，对于大型字符串可能会导致特别慢

data = ["Hi", "my", "data"]
newdata = ''
for i in data:
    newdata += i + " "
print(newdata)

>>> Hi my data

更优的方案是使用join，实现将列表中内容进行全部拼接

data = ["Hi", "my", "data"]
newdata = " ".join(data)
print(newdata)

>>> Hi my data

join前引号中的内容将作为分隔符，例如将其换成逗号将输出如下内容

data = ["Hi", "my", "data"]
newdata = ",".join(data)
print(newdata)

>>> Hi,my,data

case 9

下一个，如果想合并两个字典，无需遍历对比判断键，只需使用如下语法即可达到目的

data_1 = {"name" : "sds", "age" : "18"}
data_2 = {"name" : "sds", "uid" : "6688"}
out_data = {**data_1, **data_2}
print(out_data)

>>> {'name': 'sds', 'age': '18', 'uid': '6688'}

case 10

下一个，如果需要在if中将某对象与多个其他对象进行对比判断，你可能会进行如下定义

data = "a"
if data == "a" or data == "b" or data == "c":
    print("HHH")

>>> HHH

但是当对比对象增加时，很不方便，且可能存在拼写错误，所以通常会使用如下方式，也是我个人喜欢用的方法

datas = ["a", "b", "c"]
data = "a"
if data in datas:
    print("HHH")

>>> HHH

以上就是本期全部内容，觉得帮到了你的话就给个三联关注吧~