python-day3

已经是第三天的python学习了，知识点越来越多了。。希望自己能好好掌握！！！

先来点评下上次的作业，老实说 ，我自己也不是很满意，比前一次的成绩是有所退步的，究其原因，是多方面的，主要因素有两点

1.思维上的混乱，感觉面对作业，不能很好的把手上的知识点捏合起来

2.还没有很好的对Python的语言形式进行领会，总感觉像在写shell脚本一样

下面来看下新的一天的知识点

一.set集合

Python中的set()是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

 定义方式：

定义
s1 = set(["#1","#2","#3"])
print(s1)
s2 = set(["#1","#3","#4"])
print(s2)
输出结果：{'#2', '#1', '#3'}   {'#4', '#1', '#3'}

 set集合的定义方法

差集：
s3 = s2.symmetric_difference(s1)
print(s3)
输出结果：{'#4', '#2'}

 set的symmetic_difference方法，通过比较，将两个集合的差集进行一个输出

交集：
s4 = s1.intersection(s2)
print(s4)
输出结果：{'#3', '#1'}

 set的intersection方法，通过比较，将两个集合的交集进行一个输出

pop删除：
s6 = s1.pop()
print(s6)
输出结果：#2

 set的pop方法，随机从集合中删除一个元素，并且打印出来

remove删除
s7 = s2.remove("#1")
print(s7)
输出结果：None

 set的remove方法，删除指定的一个元素，结果不会打印

集合清理
s8 = s1.clear()
print(s8)
输出结果:None

 set的clear方法，将指定的集合整个清空

增加
s1 = set(["#1","#2","#3"])
s1.add('#4')
print(s1)
输出结果：{'#2', '#4', '#3', '#1'}

 通过add方法，给集合添加指定的元素

二.计数器Counter

Counter是隶属于模块collections中，所以在使用这个功能的时候，需要先申明模块

import collections

在python中，有很大一部分功能，是由模块来提供的，这个时候，就需要进行模块的申明

定义：
obj = collections.Counter('abcdabcdddccbadcadcbda')
print(obj)
输出结果:Counter({'d': 7, 'c': 6, 'a': 5, 'b': 4})

 可以看到，我们输入了一串字符串，然后通过collections.Counter的方法进行了处理，最后输出了一个字典，key值就是我们输入的字符串，而value则是这些字符串出现的次数，顺序是从出现次数最多的字符开始

统计出现次数最多的字符
obj1 = obj.most_common(1)
print(obj1)
输出结果：[('d', 7)]

 将输入的一组字符串中，出现次数最多的字符和次数进行一个打印

将value值进行打印
for v in obj.elements():
    print(v)
输出结果： d d d d d d d c c c c c c a a a a a b b b b

 elements方法，通过for循环，将整个字符串按照出现次数的大小，依次全部打印出来

将items进行打印
for k,v in obj.items():
    print(k,v)
输出结果： a5 b4 d7 c6

 通过for循环，将items全部打印出来

增加
obj = collections.Counter([1,2,2,3,3,3,4,4,4,4])
print(obj)
obj.update([5,5,5,5,5,5,5,5,5,4,4,4,4,4,4])
print(obj)
输出结果   Counter({4: 4, 3: 3, 2: 2, 1: 1})     Counter({4: 10, 5: 9, 3: 3, 2: 2, 1: 1})

 通过update，可以对当前的计数器进行一个扩充

删除
obj = collections.Counter([1,2,2,3,3,3,4,4,4,4])
print(obj)
obj.subtract([1,2,3,4,5,1,1,1])
print(obj)
输出结果:   Counter({4: 4, 3: 3, 2: 2, 1: 1})     Counter({4: 3, 3: 2, 2: 1, 5: -1, 1: -3})

 通过subtract方法，可以将输入的数字从原有的计数器中删除，并且可以显示为负数

三.有序字典OrderedDict

一般的字典都是无需排列的，而通过collections中的OrderedDict模块，则可以生成有序的字典，方便进行处理

有序字典的定义
import collections
obj = collections.OrderedDict()
obj['k1'] = 1
obj['k2'] = 2
obj['k3'] = 3
print(obj)
输出结果：OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])

 通过直接赋值的方式，将字典的key值和value值赋予给了有序字典

将第一个字典元素移至末尾
obj.move_to_end('k1')
print(obj)
输出结果：OrderedDict([('k2', 2), ('k3', 3), ('k1', 1)])

 move_to_end的操作方法，将字典的以一个items移动到最后一个位置

移除一个item
obj.popitem()
print(obj)
输出结果：OrderedDict([('k2', 2), ('k3', 3)])

 popitem的方法，默认会将字典最后一个item移除

pop移除
ret = obj.pop('k2')
print(ret)
输出结果：2

有序字典的pop方法，会根据给定的key值，将对应的value删除，同时打印删除的值

更新字典
obj.update({'k2':'v2','k1':'v1','k3':'v3'})
print(obj)
输出结果：OrderedDict([('k3', 'v3'), ('k2', 'v2'), ('k1', 'v1')])

 update方法，对字典进行更新，没有的item会自动添加上，有的key值，则更新对应的value值

四.默认字典defaultdict

collections模块中的默认字典defaultdict，会默认定义好key值，只需要将value值进行赋值就可以得到字典

默认字典的定义
import collections
obj = collections.defaultdict(list)
values=[11,22,33,44,55,66,77,88,99]
obj['k1'].append(1)
print(obj)
输出结果：defaultdict(<class 'list'>, {'k1': [1]})

 可以看到这里只用列表定义了value，而无需定义key值，输出的结果会自动包含key值

列子：
import collections
obj = collections.defaultdict(list)
values=[11,22,33,44,55,66,77,88,99]
for i in values:
    if i >=66:
        obj['k1'].append(i)
    else:
        obj['k2'].append(i)
print(obj)
输出结果：defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55], 'k1': [1, 66, 77, 88, 99]})

 这个例子就是默认字典的一个使用的场景，只需要通过一个简单的for语音和2个判断，就可以将一组数字的字符串进行大小的区分，并将其添加到字典中

五.可命名元祖namedtuple

collections模块中的namedtuple方法，可以对元祖的元素进行命名，这样在需要的时候就可以通过命名直接进行调用

可命名元祖的定义
import collections
s1 = collections.namedtuple('s1',['x','y','z'])
obj = s1(11,22,33)
print(obj)
输出结果：s1(x=11, y=22, z=33)

 通过namedtuple方法，将s1中的3个元素分别对应了x,y,z

分别输出
print(obj.x)
print(obj.y)
print(obj.z)
输出结果：11 22 33

 分别通过命名后的x,y,z来输出对应的11,22,33

六.双向队列

双向的队列，顾名思义，就是队列的两端都是可以输入和输出的队列方式

双向队列的定义
import collections
d = collections.deque()
d.append('1')
d.appendleft('10')
d.appendleft('1')
print(d)
输出结果：deque(['1', '10', '1'])

 双向队列的添加方式有，append（右添加），appendleft（左添加）两种形式

统计字符出现的次数
r = d.count('1')
print(r)
输出结果：2

 通过count方法，可以统计队列中某个字符出现的次数

队列的右扩充
d.extend(['a','b','c','d'])
print(d)
输出结果：deque(['1', '10', '1', 'a', 'b', 'c', 'd'])

 extend是队列的右扩充方法

队列的左扩充
d.extendleft(['aa','bb','cc','dd'])
print(d)
输出结果：deque(['dd', 'cc', 'bb', 'aa', '1', '10', '1', 'a', 'b', 'c', 'd'])

 队列的左扩充，可以看到扩充的方法是从右到左依次添加到原队列中去的

将字符移动到队列的前端
d.rotate(8)
print(d)
输出结果：deque(['aa', '1', '10', '1', 'a', 'b', 'c', 'd', 'dd', 'cc', 'bb'])

 从队列的末端选定8个字符，移动到队列的前端

七.单向队列

只能从一个方向进行队列的添加，左进右出

定义和统计
import queue
q = queue.Queue()
q.put('111')
q.put('222')
q.put('333')
print(q.qsize())
输出结果：3

 单向队列的方法并不是在collections模块中，而是在queue模块中，通过put的方法，将需要的字符添加到队列中去，qsize的方法，可以统计队列中字符的个数

八.深浅拷贝

copy的方法是分为深拷贝和浅拷贝两种方法，简单的来说

copy方法一  ‘=’
import copy
n1 = {'k1':'wu','k2':123,'k3':['Zero_zhang',456]}
n2 = n1
print(id(n1))
print(id(n2))
输出结果 1826067723848 1826067723848

 ‘=’ 的拷贝方式，可以看到2个的ID号是一模一样滴

copy的方法二，浅copy
n3 =copy.copy(n1)
print(id(n3))
print(id(n3['k3']))
print(id(n1['k3']))
输出结果：1826067682760   1826067177032  1826067177032

 copy的方法浅拷贝，可以看到作为k3的value的列表，其ID号是不改变的

copy方法三，深拷贝
n4 = copy.deepcopy(n1)
print(id(n4))
print(id(n4['k3']))
print(id(n1['k3']))
输出结果：1826067208328   1826067177416  1826067177032

  copy的方法深拷贝，可以看到作为k3的value的列表，其ID号也会改变的

例子：
import copy
dic = {
    'cpu':[80,],
    'mem':[80,],
    'disk':[80,]
}
print(dic)
new_dic = copy.deepcopy(dic)
new_dic['cpu'][0] = 50
print(dic)
print(new_dic)
输出结果：{'cpu': [80], 'mem': [80], 'disk': [80]}   {'cpu': [80], 'mem': [80], 'disk': [80]}  {'cpu': [50], 'mem': [80], 'disk': [80]}

 从例子中可以看到，开始的是一个字典，然后使用了深拷贝

九.函数

函数值python中灰常灰常重要的一个功能，下面来看一下

函数初步
def mail():
    n = 123
    n += 1
    print(n)
    return 123
f = mail()
print(f)
输出结果  124 123

函数是通过def来定义的，可以看到，编译器在执行的，通过def和缩进来判断函数的语句并且不会执行，然后的return是一个返回值，当函数运行到有return值的时候，函数就会自动跳出，并且打印出return值

return的用法
def show():
    print(1)
    return True
    print(2)
print(show())
输出结果：1  True

return的用法，当函数运行到return值的时候，函数会自行跳出，并且会打印出return值，所以整个例子中，2这个值是永远不会被打印出来的

 

#多个参数
def show(a1,a2):
    print(a1)
    print(a2)
show(1,2)
输出结果：1 2

 可以看到，函数是可以传递多个参数的

#默认参数
def show(a1,a2=999):
    print(a1)
    print(a2)
show(1)
输出结果：1  999

 函数可以传递默认参数，但是要注意默认参数必须放在最后输入

#指定参数
def show(a1,a2):
    print(a1,a2)
show(a2=123,a1=2)
输出结果：2 123

 指定参数，在函数被执行的时候，可以指定参数的输出

#动态元祖
def show(*arg):
    print(arg,type(arg))
show(1,2,3,4,5,6,7)
输出结果：(1, 2, 3, 4, 5, 6, 7) <class 'tuple'>

 用*arg来定义元祖，在被调用的时候将输入的值转化为元祖

#动态字典
def show(**arg):
    print(arg,type(arg))
show(n1=78,uu=123,bb=99)
输出结果：{'n1': 78, 'uu': 123, 'bb': 99} <class 'dict'>

 用**arg来定义字典，在被调用的时候将输入的值转化为字典

#动态元祖和字典
def show(*args,**kwargs):
    print(args,kwargs,type(args),type(kwargs))
show(11,22,33,44,n1=988,zero=6666)
输出结果：(11, 22, 33, 44) {'n1': 988, 'zero': 6666} <class 'tuple'> <class 'dict'>

 同时使用*arg和**arg参数，就可以将元祖和字典同时带入到函数的输出结果中去

赋值的两种方式
def show(*args,**kwargs):
    print(args,kwargs)
l = (1,2,3,4)
d = {'k1':'v1'}
show(l,d)
输出结果：((1, 2, 3, 4), {'k1': 'v1'}) {}
show(*l,**d)
输出结果：(1, 2, 3, 4) {'k1': 'v1'}

 可以看到，第一种函数的输出结果，是将l和d都作为了元祖的一个元素了，这个显然不是我们想要的，所以要采用第二种的输入方式*l和**d，直接告诉python我们需要这样的一个输出的结果

 

字符串的初始化之一
s1 = "{0} is {1}"
l = ['zero','superman']
ret = s1.format(*l)
print(ret)
输出结果：zero is superman

 这个是字符串的初始化的方法之一

字符串的初始化之二
s1 = "{a} is {b}"
ret = s1.format(a='zero',b='superman')
print(ret)
输出结果：zero is superman
d = {'a':'v1','b':'v2'}
ret = s1.format(**d)
print(ret)
输出结果：v1 is v2

 字符串的初始化的方法之二

十.lambda

#lambda 简单函数的表达式
func = lambda a:a+1
ret = func(99)
print(ret)
输出结果：100

 使用lambda的方法，可以帮助我们比较容易的编写一些简单的函数

十一.邮件发送

import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail(user):
    ret = 123
    try:
         msg = MIMEText('mail','Zero','utf-8')
         msg['From'] = formataddr(["Zero_zhang",'[email protected]'])
         msg['To'] = formataddr(["Zero_zhang",user])
         msg['Subject'] = 'title'

         server = smtplib.SMTP('smtp.shanghaihz.com.cn',25)
         server.login('[email protected]','******')
         server.sendmail('[email protected]',[user,], msg.as_string())
         server.quit()
    except Exception:
        ret = 456
    return ret

ret = mail('[email protected]')
print(ret)

 这个是武Sir举的一个关于函数的应用例子，发送邮件的，里面用到了模块，主要还是函数的调用。这样可以让我们很方便的实现

十二.内置函数

 内置函数较多，这里就列出几个比较常用的

#绝对值
abs()
#所有为真
all()
#任一为真为真
any()

 

#ascii
ret = ascii(78)
print(ret)
输出结果：78

 ascii的使用方法

#二进制
ret = bin(8)
print(ret)
输出结果：0b1000

 二进制的输出

#布尔值
ret = bool(8)
print(ret)
输出结果：True

 布尔值的输出

#字节数组
ret = bytearray('78',encoding='utf-8')
print(ret)
输出结果：bytearray(b'78')

字节组的输出

#是否可执行/调用
f =lambda x:x+1
f(5)
print(callable(f))
输出结果：True

 可执行/调用的方法

#random 随机
import random
print(random.random())
print(random.randint(1,99))
输出结果：0.9942568027247575    90

 随机的调用方式，第一个为随机的，第二个限制了取值的范围

#enumerate()
l = ["li",'zhang','wang']
for i,item in enumerate(l,1):
    print(i,item)
输出结果：1 li  2 zhang  3 wang

 输出的方式带有序列号

#eval()
print(eval('6*8'))
输出结果：48

 直接将数字的运算结果输出到

#filter,map
l = [1,2,3,4,5,6,7,8]
new_l = map(lambda x:x+100,l)
new_l =list(new_l)
print(new_l)
输出结果：[101, 102, 103, 104, 105, 106, 107, 108]

 map方式，通过遍历的方式，将列表中字符循环的进行处理

l = [1,2,3,4,5,6,7,8]
def func(x):
    return x+100
new_l = map(func,l)
print(list(new_l))
输出结果：[101, 102, 103, 104, 105, 106, 107, 108]

 通过函数的方式，将列表中字符循环的进行处理

l = [1,2,3,4,5,6,7,8]
def func(x):
    if x >3:
        return True
    else:
        return False
n = list(filter(func,l))
print(n)
输出结果：[4, 5, 6, 7, 8]

 过滤器的使用

#max() min()
print(max(11,22,33,44))
print(min(11,22,33,44))

 输出一组字符串中的最大和最小

#oct()8进制
#pow()幂
#round 四舍五入

 

#zip 结组
x = [1,2,3]
y = [4,5,6]
z = [7,8,9]
zippd =zip(x,y,z)
print(list(zippd))
输出结果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

 将几组列表中的，根据下标一一对应起来，组成新的列表