先区分一下序列类型和散列类型:
序列类型:list、string、tuple,他们中的元素是有序的。
散列类型:set、dict,他们中的元素无序的。
序列类型有序,可以用索引。而散列类型中的元素是无序的,所以不能索引。
一、集合
(一).集合的特性:无序、唯一、可变。集合中的元素需要可哈希的,元素不可以是可变对象。
定义一个集合:
(1).工厂方法:se = set()
注意不要写成 se = () 这样变成元组了。
(2).直接定义:se = {1,2,3} 用大括号括起来。
大括号中要写入元素,不写元素就是一个空字典了。
(3).案例分析:
# 分析这两种定义,哪一个会报错? s1 = {1, ['a', 'b', 'c']} s2 = {1, ('a', 'b', 'c')}
第一种会报错。TypeError: unhashable type: 'list'
因为集合中的元素要符合不可变这个规则, 列表可变,不符合规则,报错了。
第二种,元组不可变,符合规则,所以解释器不会跟你叫劲。
至于什么是可哈希?往下翻……
(二).集合的运算
(1).检查成员:in / not in
语法:item in set_object -> bool
例:
>>>se = {1,2,'abc'} >>>"abc" in se True >>>5 in se False
not in 就是取反,不演示了
(2).交集:&
两个集合共同有的元素,取两个集合重复的元素。
例:
# 1.有两个列表 x = [1,2,3,'a','b','c'] y = ['a','b','c'] 找出x,y列表中,共有元素 x = [1, 2, 3, 'a', 'b', 'c'] y = ['a', 'b', 'c'] print(set(x) & set(y)) """ 列表没有交集"&"的功能,但是集合有。 那么先工厂一下,然后再交集。 运行结果: {'c', 'b', 'a'} # 集合无序,所以元素输出的顺序未必如自己预想的 """
为什么运行结果的顺序是乱的?因为集合无序的!
(3).并集:|(shift+回车上面那个)
取出不重复的值。字面意思理解,并集,并在一起了(相当于变成一个集合了,集合的特性之一:元素唯一)。
例:
>>>se1 = {1,2,3} >>>se2 = {4,2,3} >>>se1 | se2 {1,2,3,4}
(4).差集:-
剪掉两个集合中的重复部分。
>>>se1 = {1,2,3,4,5} >>>se2 = {4,5,6,7,8} >>>se1 - se2 {1,2,3}
(5).与非集:^(脱字符 shift+6)
取两个集合各自独有的元素。
>>>se1 = {1,2,3,4,5} >>>se1 = {4,5,6,7,8} >>>se1 ^ se2 {1,2,3,6,7,8}
(6).小技巧:如何去重元素:
a = [1,2,3,'a','b','c','a','b','a',3] #工厂一下,set() print(set(a)) #{1,2,3,'c','b','a'}
要记得集合的特性之一:唯一性,集合中的每个元素都是唯一的。仍旧工厂一下,就可以了。如果想要输出是列表,那么就再工厂一下。
(三).集合的常用方法
(1).set.add() 添加单个元素
(2).set.update(iterable) 批量更新,会去重。
二、字典
(一).字典的特性:key唯一、无序、可变。key是唯一的,需不可变对象,重复的话会覆盖值。key要符合变量命名规则!
定义一个字典:
(1).直接大括号:di = {} 是一个空字典
type(di)之后:<class 'dict'>
注意要与集合区别开来!
一般是直接把值写进去了。语法:di = {key1:value,key2:value,...} 键值对是冒号的形式
例:
>>>di = {'name':'mkcry','age':23} >>>di {'name':'mkcry','age':23}
(2).工厂方式:di = dict(key1=value,key2=value,...) 键值对用等号"="等起来
例:
>>>di = dict('name'='???','age'=88) SyntaxError:keyword can't be an expression >>>di = dict(name='???',age=88) >>>di {'name':'???','age':88}
工厂方式容易写错,记得工厂方式的key不要加引号!
(3).案例分析:
#分析这两种定义,哪一个会报错? di1 = {'a':'test',('a','b'):'test'} di2 = {'a':'test',('a','b'):'test'}
第二种会报错。TypeError: unhashable type: 'set'
key需要的是不可变的对象。第二种里有一个集合,集合的特性之一是可变,不符合key的规则,解释器跟你急了。
而第一种里是一个元组,元组不可变,没问题了。
(二).往字典里插入值
di = {} # 直接赋值一样 di["name"] = "quanquan616" """ get(key) 如果key不存在,不会报错。取到了会返回原有值。 get(key,value) 当key不存在的时候,会返回value的值,常用来提示。 """ di.get("sex", "没有这个键") """ 如果要插入值,可以这么做: di["name"] = di.get("name","")+"zyb" di["sex"] = di.get("sex","male") di["age"] = di.get("age",0)+30 di -> {'name': 'zyb', 'sex': 'male', 'age': 30} """ """ setdefault(key,value) 字面理解,设置默认。 key有的话会返回原有值,无此key才会设置。 如果此key已有,不会改变原有值,不会被更新 """ di.setdefault("name", "zyb") """ update(dict_object) 参数需要是一个字典对象。 有就改变,没有就添加进去。 """ di.update({"age": 35, "read": 15}) # fromkeys(iterable,value) 批量设置,所有的值都是一样的。不会改变原有字典 di.fromkeys("abc", 30) print(di) # {'name': 'quanquan616', 'age': 35, 'read': 15}
(三).对字典进行取值。字典是键值对存在,取值需要通过key来取值。
# 直接用键进行取值,Dict[key] print(di["name"]) # quanquan616 # get(key) 取到了就返回值,没有取到不会报错 print(di.get("name")) # quanquan616 # get()的另一种用法 di = {} di["name"] = di.get("name", "") + "zyb" print(di) # {'name': 'zyb'} # setdefault(key) 有就返回这个键的值。如果没有这个键,会创建,不指定值的话,会是None。不会因为指定了值而改变原有数据。 print(di.setdefault("name")) # quanquan616 # values() 取出所有的值,返回一个迭代器 print(di.values()) # dict_values(['quanquan616', 35, 15])
(四).字典小技巧
(1).对字典中的元素进行排序
di = {"in": 123, "to": 511, "she": 255, "i": 111} print(sorted(di.items(), key=lambda item: item[1], reverse=True)) # 运行结果:[('to', 511), ('she', 255), ('in', 123), ('i', 111)] """ di.items() 将字典转化为可迭代对象。Dict.items()将字典中的key-value元素,转化为了元组 # [('in', 123), ('to', 511), ('she', 255), ('i', 111)] key=lambda item: item[1] 取元素中的第二个元素作为比较的参数 """
注意此方法中,value的值只能是数值,如果出现字符串就会报错。(字符串和数值能直接做比较吗?)
三、运算符(部分简单的运算符之前已有摘录,不在这里重复了,遇到实际情况不会了直接google it)
(一).身份运算符:is / is not
两个对象,是否指向同一个id。(id和内存地址还是有区别的)
>>>a = 'jack' >>>b ='jack' >>>id(a) 32342752 >>>id(b) 32342752 >>> a is b True
注意区分"=="和"is":
==用来判断两个值是否相等,is是判断两个对象的id是否相同。
(二).逻辑运算符 not > and > or
>>>a = True;b = False >>>b and a or b False >>> a or b and a True >>> a or b and b True
四、哈希
hash(object)生成一个唯一的哈希值。
小技巧:这个内置函数,可以来判断一个对象是否是可变的。可生存哈希值的就是不可变对象。