Python学习之旅—Day06(字符串+字典+列表重点方法)

Posted 2020-10-05

前言：

        本篇博客主要针对字符串，字典和列表中的一些容易忽略的重点方法进行整理，以期进一步夯实大家的基础。

---

【001】字符串方法——isspace(）方法

 isspace()方法主要检测字符串是否只由空格组成。我们通过如下的实际例子来查看该方法：

str1 = "  "
print(str1.isspace())

str2 = "cisco   123"
print(str2.isspace())

str3 = " #"
print(str2.isspace())

可以看到isspace()方法仅仅检测字符串是否只由空格组成，否则都返回False。

【002】我们知道值为False的类型有如下结果：0，‘ ‘,Fasle,None,[],{}.那么空集合是否是False的，我们一起来验证下。

这里要注意空集合是使用set()来表示，和空列表，空字典不同。

【003】集合set()中的方法——add方法

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
names.add(‘龙哥‘)
print(names)
# 打印结果：{‘老狗‘, ‘小江‘, ‘成绩‘, ‘海角‘, ‘小高‘, ‘龙哥‘}
由于集合set()中的值不可能重复，由于这里‘龙哥‘已经在集合中存在，所以这里仍然打印的是原来集合中的元素。

【004】差集，这里主要关注difference方法，注意该方法是集合set的独有方法，列表和字典没有该方法，要不然会报错。举例如下：

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
boys = [‘小高‘,‘海娇‘,‘小狗‘]
val = names.difference(boys) 
print(val)

# 该方法主要寻找集合names中存在，列表boys中不存在的数据，打印结果如下：
{‘龙哥‘, ‘小江‘, ‘成绩‘, ‘海角‘, ‘老狗‘}，可以看到结果仍然为一个集合。如果我们想查找列表boys中存在，但是集合names中不存在的数据呢？
val1 = boys.difference(name)
我们发现会报错，原因是列表list并没有该方法:AttributeError: ‘list‘ object has no attribute ‘difference‘

【005】求交集——主要考察intersection方法

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
boys = {‘小高‘,‘海娇‘,‘小狗‘}

val = names.intersection(boys)
print(val)
#打印结果：{‘小高‘}

【006】求并集—主要考察union方法

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}boys = {‘小高‘,‘海娇‘,‘小狗‘}val = names.union(boys)print(val)
#打印结果：{‘小江‘, ‘龙哥‘, ‘成绩‘, ‘海娇‘, ‘海角‘, ‘小高‘, ‘老狗‘, ‘小狗‘}

【007】判断是否无交集——isdisjoint，有交集返回False,无交集返回True 。继续看如下的例子：

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
boys = {‘海娇‘,‘小狗‘}
val = names.isdisjoint(boys)
print(val)

#由于names和boys没有交集，所有打印True.

我们继续来看下面的例子：

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
boys = {‘海娇‘, ‘老狗‘}
val = names.isdisjoint(boys)
print(val)
#由于names和boys有交集，所有打印False.

【008】子集与父集：issubset和issuperset.

names = {‘龙哥‘,‘海角‘,‘老狗‘,‘成绩‘,‘小江‘,‘小高‘}
boys = {‘龙哥‘,‘老狗‘}
# 判断boys是否是names的子集，打印结果为True
val = boys.issubset(names)
print(val)

# 判断names是否是boys的父集，打印为True

val = names.issuperset(boys)
print(val)

【009】删除集合元素——这里重点关注pop()方法，remove()方法，discard()方法

 【01】pop()方法:从集合s中任意选择一个元素删除，并将这个值返回，但是不能制定删除的值。举例如下：

s6 = {"hello", "python", "hi", "you"}
print(s6)
a = s6.pop()
print(a)  # 打印 hello
print(s6) # 打印 {‘you‘, ‘hi‘, ‘python‘}

 

【02】remove()方法:删除集合s中的指定元素，如果指定的元素在集合s中不存在，那么会报错！看如下的例子：

s6 = {"hello", "python", "hi", "you"}
print(s6)
a = s6.remove("hello")
print(a)  # 打印None
print(s6) # 打印{‘python‘, ‘you‘, ‘hi‘}
从打印结果中，我们可以分析出remove方法是直接针对集合S进行操作，它删除元素时不会返回任何值，如果使用一个值进行接收，会返回None
另外如果我们删除集合中国不存在的元素，会报错，如下：

s6 = {"hello", "python", "hi", "you"}
print(s6)
a = s6.remove("spark")
print(s6) 
报错：KeyError: ‘spark‘

【03】discard()方法：该方法也可以删除指定元素，如果该元素存在则删除，若不存在则什么也不做。一起来看如下的例子：

s6 = {"hello", "python", "hi", "you"}
print(s6)
a = s6.discard("python")
print(a)  # 打印结果为None
print(s6) # 打印结果为 {‘you‘, ‘hello‘, ‘hi‘}

从上面分析可知，discard()方法和remove()方法类似，也可以实现指定元素的删除，并且是直接针对原始集合进行操作。如果指定删除的元素不存在怎么办？

s6 = {"hello", "python", "hi", "you"}
print(s6)
a = s6.discard("spark")
print(a)  # 打印结果为None
print(s6) # {‘you‘, ‘python‘, ‘hi‘, ‘hello‘}
#通过打印结果分析可知，当制定删除的元素不存在时，discard()方法什么也不做。所以在实际中还是推荐使用该方法。

【010】说完集合的删除元素，下面我们来讨论如何往集合中添加元素，主要有2个方法，一个是add方法，该方法表示往集合中添加一项，另一个是update方法，该方法的参数接收一个可迭代对象，表示将该对象里面的所有元素逐个添加到集合中，我们一起来看下面的例子：

s = {"hello", "python", "hi", "you"}
print(s)
# 打印 {‘python‘, ‘hello‘, ‘you‘, ‘hi‘}
s.add("spark")
print(s)
# 打印 {‘python‘, ‘hello‘, ‘spark‘, ‘you‘, ‘hi‘}
通过结果分析可知，add()方法一次只能接收一个参数，然后直接将该元素添加到集合中。下面我们来看看update()方法的使用：

s = {"hello", "python", "hi", "you"}
s.update("spark", "hadoop")
print(s)
#打印结果如下：{‘o‘, ‘a‘, ‘s‘, ‘hello‘, ‘k‘, ‘hi‘, ‘python‘, ‘you‘, ‘r‘, ‘d‘, ‘h‘, ‘p‘}
从结果分析可知：update()方法将"spark"和"hadoop"看作是一个可迭代的对象，然后依次迭代对象里面的元素，并将元素添加到集合中。
所以我们看到结果是一个一个的字母，相当于循环遍历字符串"spark"和"hadoop"，然后将里面的元素添加到集合中。我们再来看下面的例子：

s = {"hello", "python", "hi", "you"}
y = {"spark", "hadoop"}
s.update(y)
print(s)
#通过结果分析可知，update后面是一个集合y,就是一个可迭代的对象，因此我们直接将集合y中的元素添加至集合s中。下面我们来尝试下将
列表中的元素添加进集合s中：

s = {"hello", "python", "hi", "you"}
li = ["spark", "hadoop", 123, 456,123,123,(123,456)]
s.update(li)
print(s)
#打印结果：{‘hi‘, 456, ‘spark‘, ‘hadoop‘, ‘you‘, (123, 456), ‘python‘, 123, ‘hello‘}

从上面的结果分析可知，update可以直接将一个列表中的元素批量添加进集合S中，而列表中可以嵌套元组，但是不能再嵌套列表或者集合，否则会报错：TypeError: unhashable type: ‘set‘，TypeError: unhashable type: ‘list‘.示例如下：

s = {"hello", "python", "hi", "you"}
li = ["spark", "hadoop", 123, 456,123,123,(123,456), {123, 456}]
s.update(li)
print(s)
报错：TypeError: unhashable type: ‘set‘
如果在列表中嵌套列表：

s = {"hello", "python", "hi", "you"}
li = ["spark", "hadoop", 123, 456,123,123,(123,456), [123, 456]]
s.update(li)
print(s)
报错：TypeError: unhashable type: ‘list‘

【011】对称差集方法：symmetric_difference()方法和symmetric_difference_update()方法 

所谓对称差集即是给定两个集合s1,s2;然后选取两个集合的差集，可以这么理解：设定在s1中存在而s2中不存在的元素集合为s3,设定在s2中存在但是在s1中不存在的元素集合为s4,所谓对称差集即为s3和s4的并集。我们一起来看下面的例子：

s1 = {‘spark‘, ‘hadoop‘, ‘hive‘, ‘kafka‘}
s2 = {‘hadoop‘, ‘python‘, ‘spark‘, ‘cisco123‘}
s3 = s1.symmetric_difference(s2)
s4 = s2.symmetric_difference(s1)
print(s3)  # 打印结果：{‘python‘, ‘hive‘, ‘kafka‘, ‘cisco123‘}
print(s4)  # 打印结果{‘hive‘, ‘python‘, ‘cisco123‘, ‘kafka‘}

下面我们再来关注symmetric_difference_update()方法，我们一起来看看如下的例子：

s1 = {‘spark‘, ‘hadoop‘, ‘hive‘, ‘kafka‘, "es", "ccnp"}
s2 = {‘hadoop‘, ‘python‘, ‘spark‘, ‘cisco123‘, "elk"}
s1.symmetric_difference_update(s2)
print(s1)  # 打印结果如下：{‘es‘, ‘kafka‘, ‘cisco123‘, ‘ccnp‘, ‘hive‘, ‘elk‘, ‘python‘}
print(s2)  # 打印结果如下：{‘elk‘, ‘spark‘, ‘hadoop‘, ‘python‘, ‘cisco123‘}

---

 

在讨论完毕集合set中的主要功能后，下面我们一起来看看字典中的重要功能。

【001】首先我们一起来探讨下字典中key的数据类型，如下，可以为整形，字符串，布尔型，以及元组，说白了key的数据类型为不可变类型，可变类型包括字典，列表和集合

dic = {
    ‘k1‘: ‘v1‘,
    2: ‘v1‘,
    False: ‘v1‘,
    (11, 22,33): ‘v1‘,
}

【002】Python 字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。格式为：dict.get(key, default=None)

key -- 字典中要查找的键，default -- 如果指定键的值不存在时，返回该默认值值。

dic = {‘Name‘: ‘Zara‘, ‘Age‘: 27}

print ("Value : %s" %  dic.get(‘Age‘))
print ("Value : %s" %  dic.get(‘Sex‘, "Never"))

相比于在很多场合下使用dic[key]，该方法虽然也可以直接返回字典对应的值，但是如果key不存在，会直接报错，所以推荐大家使用get()方法。

===============================================================================================================

     本篇博客主要是在学习函数的基础上进行相关知识点的查漏补缺，后期将结合一些具体的习题来针对性地巩固这些知识！希望对大家有帮助，从下一篇博客开始，我将结合自己学习函数的经历重点梳理函数参数，闭包，装饰器等重点知识，希望能够对大家有帮助。