ThridWeek_FirstDay

## 封装和解构

一、封装：
在程序设计中，封装(Encapsulation)是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。

二、为什么要封装：
封装数据的主要原因是：保护隐私(把不想别人知道的东西封装起来)

封装方法的主要原因：隔离复杂度

提示：在编程语言里，对外提供的接口(接口可以理解为一个入口)，就是函数，称为接口函数，这与接口的概念还不太一样，接口代表一组接口函数的集合体。

三、封装的两个层面
1、第一个层面的封装：什么都不用做，创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装。

2、类中把某些属性和方法隐藏起来(或者说定义为私有的)，只在类的内部使用、外部无法访问，或者留下少量接口(函数)供外部访问。

封装：
1、将多个值使用逗号分割，组合在一起
2、本质上，返回一个元组，省略小括号

model:

t1 = (1,2) #定义为元组
t2 = 1,2 #将1和2封装成元组

In [5]: t1 = (1,2)

In [6]: type(t1)
Out[6]: tuple

In [7]: t2 = 1,2

In [8]: type(t2)
Out[8]: tuple
model:
a = 4
b = 5
temp = a
a = b
b = temp
等价于
a,b = b,a
等号右边使用了封装，左边使用了解构

解构：
1、把线性的元素解开，并顺序的赋给其它变量
2、左边接纳的变量数要和右边解开的元素个数一致

model：
In [9]: lst = [3,5]

In [10]: first,second = lst

In [11]: print(first,second)
3 5

解构例子：
a,b = 1,2
a,b = (1,2)
a,b = [1,2]
a,b = {1,2}
a,b = {‘a’:19,’b’:20} #非线性解构也可以解构

In [14]: a,*b = { 1,2,3,4,5}

In [15]: a
Out[15]: 1

In [16]: b
Out[16]: [2, 3, 4, 5]

In [17]: [a,b] = (1,2)

In [18]: a
Out[18]: 1

In [19]: b
Out[19]: 2

Python3的解构：
1、使用*变量名接收，但不可单独使用
2、被*变量名收集后组成一个列表

model：
In [25]: lst = list(range(1,101,2))
In [26]: head,*middle,tail = lst
In [28]: *body,tail = lst

In [29]: head,*tail = lst

丢弃变量：
1、这事一个惯例，是一个不成文的约定，不是标准
2、如果不关心一个变量，就可以改变变量的名字为_
3、_是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确知道这个数据需要使用

model：
In [30]: lst = [9,8,7,20]

In [31]: first,*second = lst

In [32]: head,*_,tail = lst

In [33]: print(head,tail,first)
9 20 9
# _是合法的标识符，看到下划线就知道这个变量就是不想被使用

model：
In [34]: lst = [9,8,7,20]

In [35]: first,*second = lst

In [36]: _,*_,tail =lst

In [37]: print(_,tail,_)
[8, 7] 20 [8, 7]

## 总结：
1、_这个变量本身无任何语义，没有任何可读性，所以不是用来给人使用的
2、Python中很多库，都使用这个变量，使用十分广泛。请不要在不明确变量作用域的情况下，使用_导致和库中_冲突
# 集set

约定：
1、set翻译为集合，或者说集
2、collection翻译为集合类型，是一个大概念

set：
可变的、无序的、不重复的元素集合

详细介绍：
Python的set是一个无序不重复元素集，基本功能包括关系测试和消除重复元素，集合对象还支持并、交、差、对称差等。
set支持x in set、len(set)、和for x in set。作为一个无序的集合，sets不记录元素位置或插入点。因此，sets不支持indexing,slicing，或者其它类序列(sequence-like)的操作。

set定义 初始化
set()-> new empty set object
set(iterable)->new set object

s1 = set()
s2 = set(range(5)
s3 = set(list(range(10)))
s5 = {9,10,11} #set
s6 = {(1,2),3,’a’}

注：s4 = {},这样定义的话，s4的类型则为dict字典

set的元素：
1、set的元素要求必须可以hash
2、目前学过的不可hash的类型有列表(list)、set
3、元素不可以索引
4、set可以迭代

基本操作：
一、增加
add(elem)
1、增加一个元素到set中
2、如果元素存在，什么都不做

model：
In [50]: a = [1,2,3,4,5]

In [51]: a_set = set(a)

In [52]: a
Out[52]: [1, 2, 3, 4, 5]

In [53]: type(a)
Out[53]: list

In [54]: a_set
Out[54]: {1, 2, 3, 4, 5}

In [55]: a_set.add(‘Eric’)

In [56]: a_set
Out[56]: {1, 2, 3, 4, 5, ‘Eric’}

备注：一次只能添加一个元素，否则会报错

2、update(*others)
合并其他元素到set集合中来
参数others必须是可迭代对象就地修改

In [58]: b = [9,8,6,5,1]

In [59]: b_set = set(b)

In [60]: b_set
Out[60]: {1, 5, 6, 8, 9}

In [61]: b_set.update(’88’,’Eric’,’dashen’)

In [62]: b_set
Out[62]: {1, ‘d’, 5, 6, ‘h’, 8, 9, ‘E’, ‘r’, ‘c’, ‘8’, ‘s’, ‘a’, ‘n’, ‘e’, ‘i’}

删除：
remove
从set中移除一个元素
元素不存在，抛出KeyError异常
In [65]: b_set.remove(‘E’)

In [66]: b_set.remove(‘c’)

In [67]: b_set.remove(‘i’)

In [68]: b_set.remove(‘r’)

备注：一次只能删除一个元素
discard(elem)
从set中移除一个元素
元素不存在，什么都不做

In [1]: a = [1,2,3,4,5]

In [2]: a_set = set(a)

In [3]: a_set.discard(5)

In [4]: a_set.discard(6)
In [6]: a_set
Out[6]: {1, 2, 3, 4}

有的话删除后并返回一个None，没有的话，不抱错，也只会返回一个None

pop() ->item
移除并返回任意的元素
空集返回KeyError异常

In [1]: a_set = {1,2,3}

In [2]: a_set.pop()
Out[2]: 1

In [3]: a_set.pop()
Out[3]: 2

In [4]: a_set.pop()
Out[4]: 3

In [5]: a_set.pop()
—————————————————– ———————-
KeyError Traceback (most recent call last)
<ipython-input-5-e21c77f61fc4> in <module>()
—-> 1 a_set.pop()

KeyError: ‘pop from an empty set’

clear()：
移除所有元素

set修改、查询

修改：
要么删除，要么插入新的元素

查询：
非线性结构，无序无法索引

遍历：
可以迭代所有元素

成员运算符：
in和not in判断元素是否在set中
效率是最高的

set和线性结构：
1、线性结构的查询时间复杂度是O(n)，即随着数据规模的增大而增加
2、set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1),查询时间和数据规模无关

可hash：
数值型int、float、complex
布尔型True、False
字符串string、bytes
tuple
None
以上都是不可变类型，成为可哈希类型，hashable

set的元素必须是可以hash的

集合：
基本概念
全集：
所有元素的集合。例如实数集，所有实数组成的集合就是全集。

字集subset和超集superset
一个集合A所有元素都在另一个集合B内，A是B的字集，B是A的超集

真子集和真超集：
A是B的子集，且A不等于B，A就是B的真子集，B是A的真超集

并集:
多个集合合并的结果

交集：
多个集合的公共部分

差集：
集合中除去和其他集合公共部分