拷贝，集合，函数，enumerate，内置函数

1.拷贝

字符串和数字、赋值 id一样

import copy   #提供拷贝功能
copy.copy() #原来的和现在的一起修改，不用修改时用浅copy，节省内存，复制最外层
copy.deepcopy() #只修改现在的，复制所有，除最内层

2.集合

1）.无序且不重复的集合
2）.访问速度快
3）.天生解决重复问题

s=set()  #创建空集合专用
s={,,,}

s1=set(['alex','eric','tony'])  #转换：可以是元组、列表、字符串

s1.add('alll')                  #增加元素，原集合
s1.update()          #可增加多个元素

s2=s1.difference(['alex','eric'])#生成新的集合,删除相同元素，不改变原集合A-(AnB)

print(s2)
s1.difference_update(['alex','eric'])    #删除相同元素，修改原集合
s.discard()  #移除指定元素

s2.pop()  #.随机删除一个元素2.把元素赋值给ret，有返回值
print(s2)
s1.remove('alll') #移除指定的，
print(s1)

old=set(old_dict.keys())
new=set(new_dict.keys())
updata_set=old.intersection(new)   #取交集，并更新自己AnB
ret=old.isdisjoint(new) #有交集是False，没交集是True
old.issubset(new) #是否是子集
old.issuperset(new)  #是否是父集
old.union(new)  #取并集

deleat_set= old.symmetric_difference(updata_set)   # 并-交，拿出所有不一样的 AuB-AnB

add_set=new.symmetric_difference(updata_set)       #并-交，

3.三元运算

用于简单的if语句

# r= if True else False   # r=值1 if 条件 else 值2
# print(r)

4.函数的返回值

def mail(user):
    ret=True
    try:
        n=m #失败
    except Exception:
        ret=user
    return ret    #成功返回123，失败返回456 #返回值，结束子程序
ret=mail('xxx')
print(ret)

返回给mail（）

4.1两个参数

def show(rr,yy=):  #默认参数yy=  #默认参数必须放在最后
    print(rr,yy)
show(,)  ##指定参数show(yy=,)

4.2动态参数

#动态参数  *arg 多个参数，默认输出是元组
#        **arg 多个参数，默认输出是字典  show(n1=,n2=)   传参数要有key value
# *arg,**arg      show(,,,n1=,n2=)前几个放进元组，后几个放进字典1.一个星在前，两个星放后面2.执行时按顺序
#                l=[,,]  d={'n1':,'n2':'hh'}     show(*l,**d)
#动态参数实现字符串格式化
'''
s1='{0} is {1}'
l=['kk','ll']
result=s1.format(*l)
'''
'''
s1='{name} is {acter}'
l={'name':'kk','ll':'hh'}
result=s1.format(**l)
'''

4.3函数传参数

#函数传参，传引用。java，c#在形参前加ref或out，不加相当于再创建一份值

def fun(args):
    args.append(123)

li=[11,22]
fun(li)
print(li)

5.练习

5.1集合

# 数据库中原有
old_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': , 'mem_capicity':  },
    "#2":{ 'hostname':'c1', 'cpu_count': , 'mem_capicity':  }
    "#3":{ 'hostname':'c1', 'cpu_count': , 'mem_capicity':  }
}

# cmdb 新汇报的数据
new_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': , 'mem_capicity': },
    "#3":{ 'hostname':'c1', 'cpu_count': , 'mem_capicity':  }
    "#4":{ 'hostname':'c2', 'cpu_count': , 'mem_capicity':  }
}
m=[]
n=[]
for i in old_dict:
    m.append(i)
for i in new_dict:
    n.append(i)

old_set=set(m)
new_set=set(n)
#更新
updata_set=old_set.intersection(new_dict)   #取交集
#删除
del_set=old_set.symmetric_difference(updata_set)
#新建
new=new_set.symmetric_difference(updata_set)

5.2简述普通参数、指定参数、默认参数、动态参数的区别

# 、简述普通参数、指定参数、默认参数、动态参数的区别
# 普通参数:分为形参和实参
# 指定参数 ：在实参中指定参数的值
# 默认参数：在形参中定义参数的默认值
# 动态参数：可接收任意数量，任意类型的参数
'''
def func(*args):
    print args

# 执行方式一
func(,,,,)

# 执行方式二
li = [,,,,,,]
func(*li)
'''
'''
def func(**kwargs):
    print args

# 执行方式一
func(name＝'wupeiqi',age=)

# 执行方式二
li = {'name':'wupeiqi', age:, 'gender':'male'}
func(**li)
'''
'''
#动态参数  *arg 多个参数，默认输出是元组
#        **arg 多个参数，默认输出是字典  show(n1=,n2=)   传参数要有key value
# *arg,**arg      show(,,,n1=,n2=)前几个放进元组，后几个放进字典1.一个星在前，两个星放后面2.执行时按顺序
#                l=[,,]  d={'n1':,'n2':'hh'}     show(*l,**d)
'''

5.3写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

a='123ssdf  *_'
digital=
alphabet=
space=
others=
for i in a:
    if i.isdigit():
        digital+=
    elif i.isalpha():
        alphabet+=
    elif i.isspace():
        space+=
    else:
        others+=
print('digital=%d,alphabet=%d,space=%d,others=%d'%(digital,alphabet,space,others))

5.4写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。

def str_len():
    a=raw_input('请输入字符串')
    if len(a)>5:
        print('长度大于5')
    else:
        print('长度不大于5')
def list_len():
    a=raw_input('请输入列表')
    if len(a)>5:
        print('长度大于5')
    else:
        print('长度不大于5')
def tuple_len():
    a=raw_input('请输入字符串')
    if len(a)>5:
        print('长度大于5')
    else:
        print('长度不大于5')
'''　　

5.5写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

def a():
    b=raw_input('请输入字符串或列表或元组：')
    if all(b)==True:
        print('无空内容')
    else:
        print('有空内容')

5.6写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def a():
    b=[1,2,3,4]
    if len(b)>2:
        c=b[:2]
        return c

5.7写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

def a():
    b=[1,2,3,4,5,6]
    c=[]
    i=1
    while i<=len(b):
        c.append(b[i])
        i+=2

5.8写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def dir_updata():
    dic={"k1": "v1v1", "k2": [11,22,33,44],}
    for i,j in dic.items():
        if len(j)>2:
            dic[i]=j[:2]
    return dic

print(dir_updata())

5.9写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def fun(k):
    # while b[k]<30:
    while k<9:
        a=b[k]+b[k+1]
        b.append(a)
        fun(k+1)
        return b
b=[0,1,]
print(fun(0))
print(b[9])

6.lambda 表达式

func=lambda a:a+1   #冒号前是参数，后面表达式，作为return值
ret=func(99)
print(ret)

7.字节和字符串的转换

 b=bytes(a,encoding='utf-8') #字符串转成字节
# c=str(b,encoding='utf-8') #字节转字符串
#一般字符串操作形成新的内容，列表，字典一般对自身进行操作
'''
for i in '刘讲座':
    zijie=bytes(i,encoding='utf-8')  #1.转化为字节，并制定编码方式
    print(zijie)
    for j in zijie:      #16进制字节经for循环会转化为10进制
        print(j)
        print(bin(j))   #bin 10进制转2进制

8.enumerate可把列表转字典

相当于给列表加一列元素
# new_dic=dic(enumerate(li,1))

9.内置函数（不需要导入模块）

9.1  abs()

#绝对值

9.2  all([1,2,3,4])

#所有值是真才是真#假：0 None、空字符串、空列表、空字典、空元组是否为真

 #用bool查看是否为真

  any()  #一个为真就为真

9.3进制转换

bin()#二进制
hex()#10进制转16进制
oct()#10进制转8进制

#其他进制转10进制
i=int('0b11',base=2)
i=int('0o11',base=8)
i=int('0x11',base=16)

9.4  callable，是否可执行

f=lambda x:x+1
callable(f)==True#是否可执行

9.5

chr()#数字转ascii里的字符
ord()#ascii字符转数字

9.6 random随机数

import random
random.randint(1,99)#输出1到99的随机数
随机验证码：1.随机数2.chr
random.randrange(65,91) #大写字母
random.randrange(97,123) #小写字母
#产生验证码

import  random

temp=''
for i in range(6):
    num=random.randrange(0,4) #每一位数字、小写、大写字母产生的概率（不依赖位数i）
    if num==3:                          #数字产生的概率
        rad1=random.randrange(0,10)
        temp+=str(rad1)
    elif num==1:                        #小写字母产生的概率
        rad2=random.randrange(97,123)
        c1=chr(rad2)
        temp+=c1
    else:                                 #大写字母产生的概率
        rad2=random.randrange(65,91)
        c1=chr(rad2)
        temp+=c1
print(temp)

9.7  divmod

r=divmod（10/3）返回商和余数（3,1）

9.8  eval、exec

eval('6*8')#计算字符串等式    #有返回值
exec('for i in range(10):print(i)')  3执行代码无返回值

9.9  filter #过滤筛选，符合条件留下

f1=lambda x:x>22
ret=filter(f1,[11,22,33,44])   #参数：函数，可迭代的对象
for i in ret:
    print(i)

9.10    map #筛选，得结果，对所有数操作并返回值

ret=map(lambda x:x+1 if x%2==0 else x,[11,22,33,44])
for i in ret:
    print(i)

9.11  round、sum、sorted

# round()#四舍五入
# sum()#求和
# sorted()#数字和字符串不能混合比较，数字从小到大排，字母按ascii码排

9.12  判断对象的类型  isinstance

li=[1,2]
r=isinstance(li,list)
print(r)