14python学习 集合与函数

字符串
数字
列表
元祖
字典


可变，不可变         
可变：可以改变变量的内容，但是变量的地址不改变     
  列表 ，字典
不可变：改变变量的内容，但是地址改变了，是新建了一个地址对应原变量，或者变量不可改变
字符串，数字，元祖，


访问顺序
1.顺序访问：字符串，列表，元祖
2.直接访问：数字
3映射：字典


存放元素个数：
容器类型：列表，元祖，字典
原子：数字，字符串


 

集合       set

1.不同元素组成

2.无序的

3.集合中元素必须是不可变类型

s=set('hello')
print(s)

s=set(['alex','alex','sb'])
print(s)

集合内置方法，函数调用
s={1,2,3,4,5,6}

添加元素
s.add('s')
s.add('3')
s.add(3)
print(s)
清空元素

s.clear()
print(s)
拷贝
s1=s.copy()

随机删元素
s.pop()

指定删除元素
s.remove('sb')
s.remove('hellol') #删除元素不存在会报错
s.discard('sbbbb')#删除元素不存在不会报错
print(s)

列表转换成集合    内部自动for循环
python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)             #可以简单的去重，但是顺序不保证
l_s=set(linux_l)

#集合使用测试  找列表内共有的

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']


python_and_linux_l=[]
for p_name in python_l:
    if p_name in linux_l:
        python_and_linux_l.append(p_name)


print(python_and_linux_l)

#求交集
print(p_s,l_s)
print(p_s.intersection(l_s))     #也可以写成以下形式
print(p_s&l_s)
#求并集
print(p_s.union(l_s))
print(p_s|l_s)
#差集
print('差集',p_s-l_s)           #不影响原来的集合
print(p_s.difference(l_s))
print('差集',l_s-p_s)
print(l_s.difference(p_s))

交叉补集
print('交叉补集',p_s.symmetric_difference(l_s))
print('交叉补集',p_s^l_s)

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
print('差集',p_s-l_s)
p_s=p_s-l_s
p_s.difference_update(l_s)             #将求得的差集更新赋值给p_s
print(p_s)

如果两个集合的交集是空集返回True
s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2))

#s父集，子集关系判断

s1={1,2}s2={1,2,3}print(s1.issubset(s2))#s1 是s2 的子集print(s2.issubset(s1))#Falseprint(s2.issuperset(s1))#s1 是s2 的父集

s1={1,2}
s2={1,2,3}
s1.update(s2) #更新多个值，会导致s1改变       

s1.update((3,4))
s1.update([3,5])    #可以传元祖，列表等可迭代的数据类型

s1.add(1) #只能更新一个值
s1.union(s2) #不更新，s1不变，只能能取到并

print(s1)


s=frozenset('hello')
print(s)
names=['alex','alex','wupeiqi']

names=list(set(names))     #简单去重复，但是顺序不能保证
print(names)

字符串格式化

 # 字符串拼接  %代表标识，s是字符串类型 %s是万能的都可以接收

msg='i am %s my hobby is %s' % ('lhf','alex')             
print(msg)

msg='i am %s my hobby is %s' % ('lhf',1)
msg='i am %s my hobby is %s' % ('lhf',[1,2])
print(msg)
name='lhf'
age=19
msg='i am %s my hobby is %s' % (name,age)
print(msg)

#打印浮点数  小数点后几位
tpl = "percent %.2f" % 99.976234444444444444
print(tpl)

#打印百分比
tpl = 'percent %.2f %%' % 99.976234444444444444
print(tpl)

对应更新  字符串格式化 1. 百分号   2. format()  %在wupeiqi的博客里面有对应用法百分号
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
print(tpl)

msg='i am %(name)+60s my hobby is alex' %{'name':'lhf'}
print(msg)

msg='i am \033[43;1m%(name)+60s\033[0m my hobby is alex' %{'name':'lhf'}
print(msg)


print('root','x','0','0',sep=':')

对应的format 字符串格式化用法

    记住里边常用的就行了
http://www.cnblogs.com/wupeiqi/articles/5484747.html   更具体 ，还有其他的还没有写完整，自己练习

tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
传一个字典，要加**  ，key名对应的value值放到tp1中             传的是列表要加一个*，对应位置替换
 tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})

tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {:s}, age {:d}".format("seven", 18) #["seven", 18]

l=["seven", 18]
tpl = "i am {:s}, age {:d}".format('seven',18)
print(tpl)

tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%},{}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(tpl)
:b  代表二进制
:o  八进制
:d   整型
:x   十六进制 小写abcd
:X    大写ABCD
:%    显示成百分比

函数相关内容

对于函数的输入*args 和 **kwargs   实参输入的时候还是有点不明白

第七篇 python基础之函数，递归，内置函数
 http://www.cnblogs.com/linhaifeng/articles/6113086.html#_label1

def test(x):
    '''
    2*x+1
    :param x:整形数字
    :return: 返回计算结果
    '''
    y=2*x+1
    return y           #return只能有一个，遇到第一个就结束函数调用

def test():       #无输入
    '''
    2*x+1
    :param x:整形数字
    :return: 返回计算结果
    '''
    x=3
    y=2*x+1
    return y
a=test()
print(a)

  无论是函数名还是变量名，因为程序是逐步执行，如果重复了，后边的会覆盖前边的函数或者变量

while True：
if cpu利用率 > 90 %:
    # 发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

if 硬盘使用空间 > 90 %:
    # 发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

if 内存占用 > 80 %:
    # 发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接


def 发送邮件(内容)
    # 发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接


总结使用函数的好处：

1.代码重用

2.保持一致性，易维护

3.可扩展性
while True：

if cpu利用率 > 90 %:
    发送邮件('CPU报警')

if 硬盘使用空间 > 90 %:
    发送邮件('硬盘报警')

if 内存占用 > 80 %:
    发送邮件('内存报警')

#函数
#过程：就是没有返回值的函数


没写返回值，是过程  但是也会自动返回None
def test01():
    msg = 'test01'
    print(msg)

# 有返回值是函数
def test02():
    msg = 'test02'
    print(msg)
    return msg

def test03():
    msg = 'test03'
    print(msg)
    return 1,2,3,4,'a',['alex'],{'name':'alex'},None

def test04():
    msg = 'test03'
    print(msg)
    return {'name':'alex'}
t1=test01()
t2=test02()
t3=test03()
t4=test04()
print(t1)
print(t2)
print(t3)
print(t4)

输出是
test01
test02
test03
test03
None
test02
(1, 2, 3, 4, 'a', ['alex'], {'name': 'alex'}, None)   #实际上返回的是一个元祖
{'name': 'alex'}      # 返回一个字典
总结：

   返回值数=0:返回None

   返回值数=1:返回object

   返回值数>1:返回tuple

四 函数参数
1.形参变量只有在被调用时才分配内存单元，
在调用结束时，即刻释放所分配的内存单元。
因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，
在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
因此应预先用赋值，输入等办法使参数获得确定值


def calc(x,y): #x=2,y=3     x，y 形参
    res=x**y        #次方
    return x
    return y
res=calc(2,3)          2， 3 是实参
# print(x)     #是不行的，只有在调用函数时候才有内存空间，调用函数完成后就释放内存了，不存在了，相当于局部变量吧
# print(y)
print(res)
# a=10
# b=10
# calc(a,b)        #a，b 是实参


def test(x,y,z):#x=1,y=2,z=3
    print(x)
    print(y)
    print(z)

位置参数，必须一一对应，缺一不行多一也不行
test(1,2,3)

关键字参数，无须一一对应，缺一不行多一也不行
test(y=1,x=3,z=4)   #不用在意顺序

位置参数必须在关键字参数左边
test(1,y=2,3)#报错
test(1,3,y=2)#报错
test(1,3,z=2)
test(1,3,z=2,y=4)#报错
test(z=2,1,3)#报错


def handle(x,type='mysql'):
    print(x)
    print(type)
handle('hello')        #type已经定义好了是'mysql'
handle('hello',type='sqlite')      #这里是将'sqlite'更新到type中覆盖原来的
handle('hello','sqlite')              #不写type='sqlite'   ， 'sqlite' 变成了位置参数

def install(func1=False,func2=True,func3=True):    #如果不手动去勾选，就会有默认的安装内容
    pass
参数组：非固定长度的参数**字典{}  *接收列表[]
def test(x,*args):
    print(x)
    print(args)

按照位置参数来传
test(1)
test(1,2,3,4,5)           #输出 1       (2, 3, 4, 5)   会把 2345送到arg中当成元祖来处理
test(1,{'name':'alex'})  # 输出  1  ({'name': 'alex'},) 把字典{'name':'alex'}当成元祖的一个元素
test(1,['x','y','z'])    # (['x', 'y', 'z'],) 把列表['x','y','z'] 当成元祖的第一个元素整体
test(1,*['x','y','z'])   #('x', 'y', 'z')        'x', 'y', 'z'分别成为元祖的一部分
test(1,*('x','y','z'))   # ('x', 'y', 'z')           应该是内部fori in  循环了

关键字参数要另一种方式处理
test(1,y=2,z=3)       #错误，*args是接收列表，但传的y=2 ，是key对应value的形式，
                      # 一个*args只是处理位置参数处理成一个列表的形式


def test(x,**kwargs):       #  *args     **kwargs   最好固定这么写
    print(x)
    print(kwargs)
test(1,y=2,z=3)             # 1    {'y': 2, 'z': 3}    返回的是字典的形式
test(1,1,2,2,2,2,2,y=2,z=3)        #错误 位置参数，必须一一对应，缺一不行多一也不行
test(1,y=2,z=3,z=3)            #会报错 ：一个参数不能传两个值
test(1,{1:'s',2:'k'})           #错

def test(x,*args,**kwargs):   #固定位置  能接收任意长度的参数了
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))        #字典取值要用get（）

test(1,1,2,1,1,11,1,x=1,y=2,z=3)  #报错     x重复了

test(1,1,2,1,1,11,1,y=2,z=3)
输出
1
(1, 2, 1, 1, 11, 1) 1       #  给kwargs构成元祖
{'y': 2, 'z': 3} 2           # kwargs构成字典

test(1,*[1,2,3],**{'y':1})      #直接输入列表和字典         输出对应的都是元祖和字典吗？
输出
1
(1, 2, 3) 3
{'y': 1} 1