Python（Day3）

基础篇+实战项目

1、python之set集合

特点：访问速度快，原生解决重复问题

.add()  增加（不会重复）
.clear()  清空set所有数据
.difference()  比对不同，删掉原有集合中相同的内容，生成新的集合
.difference_update()  传入参数后把原先重复有的元素移除，更新（修改）了自己
.intersection()  取交集，新创建一个set
.intersection_updaate() 取交集，修改原来的set
.isdisjoint()  如果没有交集返回true
.issubset()  是否是子集
.issuperset()  是否是父集
.pop()  移除集合中的一个元素并且赋值
.remove() 移除集合中指定元素，无返回值
.discard()  移除元素
.symmetric_difference()  差集，创建新对象
.symmetric_difference_update()  差集，改变原来
.union()  并集
.update()  更新

例：

要求：求要更新的数据，要删除的数据，要增加的数据

#数据库中原有
old_dict = {
    "#1":{'hostname': 'c1', 'cpu_count': 2, 'men_capicity': 80},
    "#1":{'hostname': 'c1', 'cpu_count': 2, 'men_capicity': 80},
    "#1":{'hostname': 'c1', 'cpu_count': 2, 'men_capicity': 80}
}
#更新的数据
new_dict = {
    "#1":{'hostname': 'c1', 'cpu_count': 2, 'men_capicity': 80},
    "#3":{'hostname': 'c1', 'cpu_count': 2, 'men_capicity': 80},
    "#4":{'hostname': 'c2', 'cpu_count': 2, 'men_capicity': 80}
}

#交集：要更新的数据
#差集：得到要删除和要添加的

old = set(old_dict.keys())
new = set(new_dict.keys())

update_set = old.intersection(new)

delete_set = old.symmetric_difference(update_set)

add_set = new.symmetric_difference(update_set)

print(update_set)
print(delete_set)
print(add_set)

2、python之计数器Counter

Counter:是对字典类型的补充，用于追踪值出现的次数

.update()  更新字典元素，再计数
.subtract()  删除字典元素，再计数

例1：
import collections
obj = collections.Counter('aabbccddeeffjj')
print(obj)
ret = obj.most_common(4)  #拿到前四位
print(ret)
等价于：
for item in obj.elements():    
    print(item)     #打印出里边的元素

for k,v in obj.items():
    print(k,v)      #打印出元素和对应的次数

例2：
import collections #引用collection
obj = collections.Counter(['11','22','33'])
print(obj)
obj.update(['abcd','11','11'])
print(obj)
obj.subtract(['abcd','11','11'])
print(obj)

#结果： Counter({'11': 1, '22': 1, '33': 1})
 Counter({'11': 3, '22': 1, '33': 1, 'abcd': 1})
 Counter({'11': 1, '22': 1, '33': 1, 'abcd': 0})

3、python之有序字典OrderedDict

.move_to_end()  把指定的值拿到最后
.pop()  
.popitem()
.setdefault()

例：
import collections #引用collection
dic = collections.OrderedDict()     #有序排列
# dic = dict()    #会无序排列
dic['k1'] = 'v1'
dic['k2'] = 'v2'
dic['k3'] = 'v3'
# dic['k4'] = None
# dic.setdefault('k4','66')   #若原先有赋值，则无用；若没赋值，则以参数为值
# print(dic)
# dic.move_to_end('k1')
# print(dic)
# dic.popitem()   #拿走后进先出的元素
# print(dic)
# dic.pop('k2')   #拿走指定的元素
# print(dic)
#dic.update({'k1':'v111','k10':'v10'})   #更新功能
#print(dic)

4、python之默认字典defaulteDict

例：
from collections import defaultdict

values = [11,22,33,44,55,66,77,88,99]
my_dict = defaultdict(list)

for value in values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict)

5、python之可命名namedtuple

import collections
MytupleClass = collections.namedtuple('Mytuple',['x','y','z'])  #创建类
obj = MytupleClass(11,22,33)
print(obj.x)
print(obj.y)
print(obj.z)

6、python之双向队列deque

例：
import collections
d = collections.deque()
d.append('1')
d.appendleft('10')
d.appendleft('11')
print(d)
r = d.count('1')
print(r)
d.extend(['yy','uu','xx'])  #向右拓展
d.extendleft(['jj','bb'])   #向左拓展
print(d)
x = d.index('jj')
print(x)
d.rotate(5)     #循环5次拿最后一个元素插到第一个
print(d)

7、python之单项队列queue.Queue

例：
import queue
# q = queue.Queue
# q.put('123')
# q.put('678')
# # print(q.qsize())
# print(q.get())

8、python深浅拷贝原理

import copy

# copy.copy()     #浅拷贝
# copy.deepcopy()     #深拷贝

#①字符串，数字
a1 = 123123
a2 = 123123
print(id(a1))
print(id(a2))
a3 = copy.copy(a1)  #浅拷贝
print(id(a1))
print(id(a3))
a4 = copy.deepcopy(a2)
print(id(a2))
print(id(a4))       #深拷贝

#②列表、元组、字典等
n1 = {'k1':'wu','k2':123,'k3':['alex',456]}
n2 = n1
# print(id(n1))   #地址一样
# print(id(n2))   #地址一样
n3 = copy.copy(n1)
# print(id(n1))   #地址不同
# print(id(n3))   #地址不同
# print(id(n1['k3']))     #地址相同
# print(id(n3['k3']))     #地址相同

n4 = copy.deepcopy(n2)
print(id(n2))       #地址不同
print(id(n4))       #地址不同
print(id(n2['k3']))     #地址不同
print(id(n4['k3']))     #地址不同

总结：浅拷贝只是拷贝了一层，而深拷贝是有多少层就拷贝多少层

实例应用：

dic = {
    'cpu':[80,],
    'mem':[80,],
    'disk':[80,]
}
# print('before',dic)
# new_dic = copy.copy(dic)
# new_dic['cpu'][0] = 50
# print(dic)  #同时也改变了（浅拷贝）
# print(new_dic)

new_dic = copy.deepcopy(dic)
new_dic['cpu'][0] = 50
print(dic)  #原先的不变（深拷贝）
print(new_dic)

***************************************************
***************************************************
9、python之函数

9.1： 函数的定义和使用

关键字：def

例:
def mail():
    n = 123
    n += 1
    print(n)
mail()
f=mail
f()

9.2：函数的返回值

关键字：return

9.3：函数的参数
例：
#无参数函数
def show(arg):
    print(arg)
show('kkkk')

#两个参数
def show(arg,xxx):
    print(arg,xxx)
show('abc','def')

#默认参数（必须放在最后）
def show(a1,a2=999):
    print(a1,a2)
show(1111,8888)     #实际参数会将默认参数冲掉

#指定参数
def show(a1,a2):
    print(a1,a2)
show(a2=999,a1=333)

9.4：函数的动态参数
例：
# def show(arg):
#     print(arg)
# show([11,22,33,44])     #可以是列表、元组
#
# n = [11,22,33,44]
# show(n)

# def show(*arg):
#     print(arg,type(arg))
#
# show(1,22,333,44,55)    #（*）python自动将其转化为元组类型了

# def show(**arg):
#     print(arg,type(arg))
# show(n1 = 81,n2 = 96,n3 = 66)      #（**）python自动将其转化为字典类型了

#def show(*args,**kargs):
#    print(args,type(args))
#    print(kargs,type(kargs))
#show(11,22,33,n1 = 88,n2 = 'tom')       #先（*）再（**），传入参数要注意，python自动将其分类

def show(*args,**kargs):
    print(args,type(args))
    print(kargs,type(kargs))
l = [11,22,33]  #也可以这样赋值
d = {'n1':88,'alex':'sb'}
show(*l,**d) #注意*号

9.5：使用动态函数实现字符串的格式化

原格式化：
s1 = '{0} is {1}'
result = s1.format('alex','2b')
print(result)

动态参数格式化：
# s1 = '{0} is {1}'
# l = ['alex','sb']   #通过列表形式
# result = s1.format(*l)  #注意*
# print(result)

s1 = '{name} is {actor}'
d = {'name':'alex','actor':'sb'}
# result = s1.format(name='alex',actor='sb')
result = s1.format(**d)
print(result)

10、python之lambda表达式
函数名 = lambda 形式参数1，形式参数2：函数体
例：
def func(a):
    b = a+1
    return b
result = func(4)
print(result)

#lambda表达式 （创建形式参数，并且return）
func = lambda a: a+1
ret = func(99)
print(ret)

11、python之内置函数

abs()  绝对值
all()  （判断列表、元组、字典）返回一个True（有值\不为0\不为空）False（NULL\0\空）
any()  有一个真的就返回True
ascii() 
bin()   将参数返回二进制数
bool()　布尔值
bytearray()  返回字节数
chr() 将数字转ASCLL码
ord() 将ASCLL码转为数字
dir() 当前变量的所有Key
enumerate()
eval() 计算参数的乘积

map(func, seq1[, seq2,…])
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
Python函数编程中的map()函数是将func作用于seq中的每一个元素，并将所有的调用的结果作为一个list返回。如果func为None，作用同zip()。

filter() 用于过滤序列
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

frozenset() 冻结set集合
globals() 全局变量
hex()  转换为十六进制
max()  取最大值
min()  取最小值
oct()  转八进制
range()  建一个区间
reverse() 反转
supper() 执行父类
zip()  将每个列表的元素一一对应并创建一个新的列表

12、文件操作

open函数：
r:只读 r+:可读写文件
w:只写 w+:写读文件
a:追加 a+:追加

.tell() 查看当前指针的位置
.seek() 指定当前指针的位置
.truncate() 当前指针位置切开，去除后边的部分

例：
f = open('test.log','r',encoding='utf-8')

# print(f.tell())
# f.read(2)   #参数按照字符来拿的
# print(f.tell())     #按照字节来计算
# f.close()
# # print(ret)

# f.seek(2)
# ret = f.read()
# f.close()
# print(ret)