IPython封装解构和集合

IPython

Shell命令

!command 执行shell命令

!ls -l , !touch a.txt file = !ls -l | grep py

魔术方法

使用%开头的，IPython内置的特殊方法

%magic 格式

%开头是line magic

%% 开头是cell magic，notebook的cell

%alias 定义一个系统命令的别名

alias ll ls -l

%timeit statement

-n  一个循环loop执行语句多少次

-r  循环执行多少吃loop，取最好的结果

%%timeit setup——code

封装和结构

封装

将多个值用逗号分割，组合在一起

本质，返回一个元组，只是省略了小括号

Python特有语法，被很多语言学习借鉴

t1 = （1,2）#定义元组

t1 = 1,2 将1和2封装成元组

Type（t1）

Type（t2）

举例：a = 4    b = 5  

temp = a  a = b b = tmp

a , b = b , a

右边使用了封装，左边使用了解构

解构

把线性的结构元素解开，并顺序的赋给其他变量

左边接纳的数量要和右边解开的元素个数一致

举例：

lst = [3,5]

First,second = lst

Print(first,second)

Python3的解构

使用*变量名接收 ，但不能单独使用

被*变量名 收集后组成一个列表

head，*mid，tail = “asdfghjkl”

丢弃变量

这是一个惯例，是一个不成文的约定，不是标准

如果不关心一个变量，就可以定义为改变量的名字

_是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成_就是不要使用，除非你明确的知道这个数据需要使用

举例：

lst = [9,8,7,20]

Frist,*second = lst

Head，*_,tail = lst

Print(head,tail)

#_是合法的标识符，看到下滑线就知道这个变量就是不想被使用

例子:aa = [1,[2,3,4],5]

_,bb,_,=aa

_,_,cc=bb

cc

例子

lst = [1,[2,3,4],5]

a,(b,c,d),e = lst

print(a,b,c,e)

_,(*_,val),*_ = lst

print(val)

例子

key,_,val = “JAVA_HOME=/usr/bin”.partition(“=”)

print(key)

print(val)

集set

约定：set翻译为集合。collection翻译为集合类型，是一个大概念

可变的，无序的，不重复的元素集合

set{}  —->  字典  set（） 集合

Set的元素

Set的元素要求必须可以hash

目前学过的不可hash的类型有lsit，set

元素不可索引

Set可以迭代

Set增加

add（elem）

增加一个元素到set中

如果一个元素存在，什么都不做

Update（*others）

合并其他元素到set集合中来

参数others必须是可迭代对象

就地修改（数字分开）

Remove（elem）

从set中移除一个元素

元素不存在，就抛出keyerror异常

Discard（elem）

从set中移除一个元素

元素不存在，什么都不做

Pop（） —> item

移除并返回任意的元素

空集返回keyerror异常

Clear（）

移除所有元素

Set修改查询

修改

要么删除，要么加入新的元素

查询

非线性结构，无法索引

遍历

可以迭代所有元素

成员运算符

In 和 not in判断元素否在set中

Set和线性结构

线性结构的查询时间复杂度是O（n），即随着数据规模的增而增加耗时

Set，dict等结构，内部使用hash值作为key，时间复杂可以做到O（1），查询时间和数据规模无关

可hash：数值型int，float，complex

布尔型True ，False

字符串string，bytes

Tuple   None

以上都是不可变类型，成为可hash类型，hashable

集合

基本概念

全集：所有元素的集合。例如实数数列，所有实数组成的集合就是全集

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

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

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

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

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

Union（*other）：多个集合合并后的新的集合

| 运算符重载等同于union

Update（*others）：多个集合合并就地修改

|= 等同update

交集:AB集合的公共部分

Intersection（*others）：返回和多个集合的交集

& ：等同于intersection

Intersection_update（*others）：获取多个集合的交集 就地修改

&=  等同于Intersection_update

差集：集合A和B，有所有属于A且不属于B的元素组成的集合

Difference（*others）：返回多个集合的差集

一：等同于difference

Difference_update（*others）：-=：获取和多个集合的差集并就地修改

集合运算

对称差集：集合A和B，有所有不属于A和B的交集元素组成的集合记做（A-B）U B-A(

Symmetric_difference（others）：返回和另一个集合的差集:^

Symmetri_difference_update（others）：获取和另一个集合的差集并就地修改

^= 等同于symmetri_difference_update

例子

a = {‘A’,’B’,’C’}  #我的好友

b = {‘C’,’B’,’D’}  #他的好友

a & b

a = {1,2,3,4}  #群里

b = {4}        #我

a & b

a = {‘A,B,C’}   #权限

b = {‘C,B,D’}   #我有的权限

a & b == a

a = {‘A’,’B’,’C’,’D’,’E’}   #总任务

b = {‘A’,’B’,’C’}          #已经完成

a – b

#随机产生2组10个数字的列表，

#每个数字取值范围[10,20]

#一共有多少个不同的数字

#不重复的数字有几个

#重复的数字有几个

（1）import random

lst = set()

lat = set()

for i in range(10):

    a=random.randint(10,20)

    lst.add(str(a))

    b=random.randint(10,20)

    lat.add(str(b))

print(len(lst.union(lat)))

print(len(lst.symmetric_difference(lat)),(lst.symmetric_difference(lat)))

print(len(lst.intersection(lat)),(lst.intersection(lat)))

（2）a = [1,9,7,5,6,7,8,8,2,6]

b = [1,9,0,5,6,4,8,3,2,3]

s1 = set(a)

s2 = set(b)

print(s1)

print(s2)

print(s1.union(s2))

print(s1.symmetric_difference(s2))

print(s1.intersection(s2))