python基础3 集合 三元运算 深浅拷贝 函数
一 上节课拾遗
1 运算符
in
字符串 判断 ： “hello” in "asdasfhelloasdfsadf"
列表元素判断："li" in ['li', 'ok']
字典key判断：key in dic.keys()
2 基本的数据类型
类名（） 其实就是执行类的 __init__ int（） __init__(self,args,base=10) int a. 创建方式 两种 n1 = 123 # 根据int类，创建了一个对象 n2 = int(123) # 根据int类，创建了一个对象 类的实例化就是对象 b. int内部优化 1、n1 和 n2 的内存地址相同 n1 = 123 n2 = n1 2、按理说 n1 和 n2 的内存地址不相同 n1 = 123 n2 = 123 但是Python内部做了优化， -5 ~ 257 以内的数，按照 2 的方式写时，都是指向同一个内存 n1 = 123 n2 = 123 除此以外的数，都是n1 和 n2 的内存地址不相同 python源码可以改取值范围 n1 = 123123 n2 = 123123 3、id查看对象的内存地址 n1 = 123 i1 = id(n1) print(i1) 或者 i1 = id(123) print(i1) c. int长度限制 32 -2**31 ~ 2 **31 -1 64 -2**63 ~ 2**63 - 1 数字后有L 代表长整型 python 2.2之后，超过int的最大长度后，会自动转换成long类型，long类型无长度限制 python 3之后，int自己就无长度限制了 str， a. 创建方式 s1 = "alex" s1 = str('alex') s1 = str('alex') #传参 字节和编码 b. 特有功能 # 两端去除空格 # s1.strip() # 以 .. 开头 # s1.startswith() # 找子序列 "12","h" # s1.find() # 将字符串中的某子序列替换成 指定的值 # s1.replace() # 变大写 # s1.upper() # 是。。。吗？ # s1.isalpha() c. 公共功能 索引：只能取一个元素 切片：取多个元素 len： len("刘建佐") 3.5 ==》 字符 （utf-8 中 规定1个汉字3个字节，但是3版本中 1个汉字就是一个字符，不是字节。所以这里len是3） for： 3.5 ==》 字符 （3 版本中 循环汉字字符串不是字节，而是按照字符来进行循环的） 编码、for bytes方法：转换成字节 3版本python中 汉字字符串循环不是按照字节循环，而是按照字符循环。 name = "李露" for i in name: print(i) #循环打印每个汉字而不是字节 bytes_list = bytes(i, encoding='utf-8') #将汉字转成字节，编码是utf-8 print(bytes_list) for b in bytes_list: 1、3.5 for循环时候，循环的每一个元素是 “字符” 2、字符 =》 字节 bytes_list = bytes("字符串",encoding='utf-8') # utf-8 -> 3字节 1个汉字 # gbk -》 2字节 1个汉字 print(bytes_list) # 默认每一个字节都是16进制表示 for b in bytes_list: print(b) # 默认每一个字节都是10进制表示 3、10进制的数字 ==》 2进制 len id bin(10进制的数字) d、 bytes和str的转换 将字节转换成字符串 bytes方法 a = "李露" # 将字符串转换成字节 b1 = bytes(a, encoding='utf-8') print(b1) b2 = bytes(a, encoding='gbk') print(b2) # 将字节转换成字符串 newa1 = str(b1, encoding="utf-8") print(newa1) newa2 = str(b2, encoding='gbk') print(newa2) ########### x = str() # 创建字符串 # 转换成字符串，字节，编码 m = bytes() # 创建字节 # 转换成字节，字符串，要编程什么编码类型的字节 python进制转换 hex 可以 十进制转16进制 二进制转16进制 结果都是字符串 >>> hex(0b10) '0x2' >>> hex(10) '0xa' bin 可以十进制转2进制 16进制转2进制 结果都是字符串 >>> bin(10) '0b1010' >>> bin(0x2) '0b10' int 可以16进制转换十进制 2进制转换十进制 >>> int(0xe) 14 >>> int(0b100) 4 list 可变元素的“集合” ----------- str -> 创建字符串，或者将其他的转换成字符串 ------------------------------------------ list -> 创建列表，将其他元素转换成列表 a. 创建和转换 1、创建 li = [11,22,33,4] li = list() li = list([11,22,33,4]) 2、转换 注：放可迭代的 凡是可以for循环的都可以迭代。 字符串 元组 字典 列表本身 都可以迭代 s1 = "李露" # for，字符 ==> 可迭代 l1 = list(s1) # for循环，将循环的每一个元素，当做列表的元素 # ["李", "露"] print(l1) # 元组 转换成列表 # t2 = ("alex", "laonanhai", "seven") # l2 = list(t2) # print(l2) # 字典 转换成列表 # dic = {'k1': "alex", "k2": 'seven'} # l3 = list(dic.items()) # print(l3) # 字符串，元组，字典 =》 列表 b. 列表特有功能 # 追加 # li.append() # 清除 # li.clear() # 扩展自己，用另外一个可迭代的对象，扩充到自己内部 # str,list,dict,tuple # s = "李露" # li.extend(s) # print(li) # 翻转，自己内部元素翻转 # li.reverse() # 向指定位置插入指定元素 # li.insert(1, "X") c. 公共功能 li = ["alex", "eric", 'seven', 123] 索引：li[2] 切片：li[2:3] del enumerate for len join d. 多层列表 字典取值 li = ["alex", "eric", 'seven', 123] li = [ "alex" , 123, {"k1":"v1", "k2": {"vv": (11,22,123), "ii": 456}}] li[2] --> {"k1":"v1", "k2": {"vv": 123, "ii": 456}} li[2]['k2'] ==> {"vv": 123, "ii": 456} li[2]['k2']["vv"] ==> (11,22,123) li[2]['k2']["vv"][2] 元组 tuple 转换时候放可迭代的，即可以for循环取的类型。 比如 字符串 列表 字典都可以循环 a. 创建和转换 t = (11,22,33) t = tuple((11,22,33)) t = tuple([]) # 字符串，列表，字典 b. 特有方法 count index c. 嵌套（元素不可修改） 注：如果元素是列表或者字典则可以修改 t = (11,22,33) t = (11,22,["alex", {"k1": "v1"}]) e. 元组的特性，不可修改，谁不可被修改 #如果元素是列表或者字典可以修改 元组，儿子不能变 元组，儿子不能变，孙子，... 整理： 元组 字符串 特性总结 一般字符串，执行一个功能，生成一个新内容，原来内容不变 list,tuple,dict，执行一个功能，自身进行变化
字典： 列表一句变字典 li = [11,12,13] dic = dict(enumerate(li,10)) print(11) print(dic)
1、创建 a = {"k1": 123} a = dict() li = [11,22,33] new_dict = dict(enumerate(li)) print(new_dict) 2、字典内部功能 keys() # values() items() pop()
get() #获取字典的key对应的value，如果该key不存在，则返回None
fromkeys(seq,value=None) # 将有序的seq 作为字典的key，而value则为所有可以的公共值。共享其值 key() 3版本取的时候 要么将字典的key 用list类进行转换 要么for循环放到空列表里面
2 版本 print(dic.keys()) 直接返回 一个列表
3 版本 print(dic.keys()) 返回的是一个类
fromkeys(seq,value=None) 解释： 默认不写value的话，所有的值为None n = dict.fromkeys(['k1', 'k2'], []) #默认逗号后面不给的话，key对应的value都是None n['k1'].append(2) #我们修改逗号后面的空列表元素 打印 所有key的value也会修改 print(n) n['k1'] = 3 # 而单独修改key的value的话，只有 这个key的value改了，而其他的key对应的value都不变 print(n) n = dict.fromkeys() #默认逗号后面不给的话，key对应的value都是None print(n)
二 集合 set
set集合，是一个无序且不重复的元素集合
class set(object): """ set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements. """ def add(self, *args, **kwargs): # real signature unknown """ Add an element to a set，添加元素 This has no effect if the element is already present. """ pass def clear(self, *args, **kwargs): # real signature unknown """ Remove all elements from this set. 清楚内容""" pass def copy(self, *args, **kwargs): # real signature unknown """ Return a shallow copy of a set. 浅拷贝 """ pass def difference(self, *args, **kwargs): # real signature unknown """ Return the difference of two or more sets as a new set. A中存在，B中不存在 (i.e. all elements that are in this set but not the others.) """ pass def difference_update(self, *args, **kwargs): # real signature unknown """ Remove all elements of another set from this set. 从当前集合中删除和B中相同的元素""" pass def discard(self, *args, **kwargs): # real signature unknown """ Remove an element from a set if it is a member. If the element is not a member, do nothing. 移除指定元素，不存在不保错 """ pass def intersection(self, *args, **kwargs): # real signature unknown """ Return the intersection of two sets as a new set. 交集 (i.e. all elements that are in both sets.) """ pass def intersection_update(self, *args, **kwargs): # real signature unknown """ Update a set with the intersection of itself and another. 取交集并更更新到A中 """ pass def isdisjoint(self, *args, **kwargs): # real signature unknown """ Return True if two sets have a null intersection. 如果没有交集，返回True，否则返回False""" pass def issubset(self, *args, **kwargs): # real signature unknown """ Report whether another set contains this set. 是否是子序列""" pass def issuperset(self, *args, **kwargs): # real signature unknown """ Report whether this set contains another set. 是否是父序列""" pass def pop(self, *args, **kwargs): # real signature unknown """ Remove and return an arbitrary set element. Raises KeyError if the set is empty. 移除元素 """ pass def remove(self, *args, **kwargs): # real signature unknown """ Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError. 移除指定元素，不存在保错 """ pass def symmetric_difference(self, *args, **kwargs): # real signature unknown """ Return the symmetric difference of two sets as a new set. 对称交集 (i.e. all elements that are in exactly one of the sets.) """ pass def symmetric_difference_update(self, *args, **kwargs): # real signature unknown """ Update a set with the symmetric difference of itself and another. 对称交集，并更新到a中 """ pass def union(self, *args, **kwargs): # real signature unknown """ Return the union of sets as a new set. 并集 (i.e. all elements that are in either set.) """ pass def update(self, *args, **kwargs): # real signature unknown """ Update a set with the union of itself and others. 更新 """ pass
#!/usr/bin/env python # _*_ coding:utf-8 _*_ __author__ = 'liujianzuo' a={1:2,4:5} b=set(a) b.add(111111) b.clear() print(b) n = {11,22,33} b = {22,66} c = {11} # n中有的b中没有的赋值给新的变量 打印 new_n = n.difference(b) print(new_n) #n中有的 b中没有的 更新到n # n.difference_update(b) # print(n) # 将迭代的序列加入 n.update("al") n.update([1,3,4]) print(n) #n存在的b不存在的 b存在n不存在的 组合一起输出 ret=n.symmetric_difference(b) ret2 = n.symmetric_difference({11,22,33}) print(ret) print("=========") # n存在的b不存在的 b存在n不存在的 组合一起 更新到前面的集合 n.symmetric_difference_update(b) print(n) # 是否是子集 不是返回false 是的话True ret = n.issubset(c) # n是不是c的子 print(ret) ret1 = c.issubset(n) # c是不是n的子 print(ret1) ret2 = n.issuperset(c) # n是不是c的父 print(ret2) # pop discard remove 三个删除的区别 #pop 删除同时可以获取到该值 ret = n.pop() #由于集合是无序的，所以pop删除也是无序的 print(ret) # discard 删除集合元素，如果元素不存在 返回False 不报错 n.discard(11) print(n) #remove 删除集合元素 如果元素不存在 报错 #n.remove(99) z = {11,22,33} p = {44} z.intersection(p) #取交集并更新到z中 print(z) 集合 练习 #!/usr/bin/env python # _*_ coding:utf-8 _*_ __author__ = 'liujianzuo' old_dict = { "#1":11, "#2":11, "#3":11, } new_dict = { "#1":33, "#4":22, "#7":100, } # b = set(old_dict.keys()) # print(b) s1 =set() s2 =set() for i in old_dict.keys(): s1.add(i) for n in new_dict: s2.add(n) print(s1,s2) ret1 = s1.difference(s2) print("for deling ：",ret1) ret2 = s2.difference(s1) print("for adding:",ret2) # ret=s1.intersection(s2) # print(ret) for i in s1 : del old_dict[i] for i in s2: old_dict[i]=new_dict[i] print(old_dict)
交集 >>> a.append(10) >>> set(a) set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) >>> b =range(6) >>> a = set(a) >>> b =set(b) >>> a set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) >>> b set([0, 1, 2, 3, 4, 5]) 取交集 >>> a & b set([0, 1, 2, 3, 4, 5]) 交集应用场景：比如两个班级都叫alex或者两个班级都是100分的 或者两个班级中都大于多少分的 并集应用 >>> a | b set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) 差集 >>> a - b set([8, 9, 10, 6, 7]) 对称差集 >>> a - b set([8, 9, 10, 6, 7]) 把两个里面对方都没有的打印出来 A b 差集 a ^ b set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) >>> b set([0, 1, 2, 3, 4, 5, 12]) >>> a ^ b set([6, 7, 8, 9, 10, 11, 12]) a.add集合中添加一项，同样的去重不同样的增加 >>> a.add(0) >>> a.add(22) >>> a set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22]) a.update集合添加多项 >>> a.update([23,34,35]) >>> a set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23]) 添加一个集合到另一个集合 >>> a.update(b) >>> a set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23]) #b.issubset(a) a.issuperset(b) 测试b中的每一个元素都在a中 >>> len(a) 15 >>> len(b) 6 >>> b in a False >>> a in a False >>> import tab >>> b.issubset(a) #测试b中的每一个元素都在a中 True >>> a.issubset(b) False >>> 3 in a True >>> b.issuperset(a) False >>> a.issuperset(b) #测试b中的每个元素都在a中 True
练习：寻找差异
# 数据库中原有 old_dict = { "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } } # cmdb 新汇报的数据 new_dict = { "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 } }
需要删除：？需要新建：？需要更新：？
注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
#!/usr/bin/env python # _*_ coding:utf-8 _*_ __author__ = 'liujianzuo' # 数据库中原有 old_dict = { "#1":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 }, "#3":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 } } # cmdb 新汇报的数据 new_dict = { "#1":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':1, 'cpu_count': 2, 'mem_capicity': 80 }, "#4":{ 'hostname':2, 'cpu_count': 2, 'mem_capicity': 80 } } # b = set(old_dict.keys()) # print(b) s1 =set() s2 =set() for i in old_dict.keys(): s1.add(i) for n in new_dict: s2.add(n) new_jiaoji = s1.intersection(s2) print(new_jiaoji) for j in new_jiaoji: if old_dict[j] != new_dict[j]: print("need updating: { '%s': %s}"%(j,new_dict[j])) print(s1,s2) ret1 = s1.difference(s2) print("for deling ：",ret1) ret2 = s2.difference(s1) print("for adding:",ret2) # ret=s1.intersection(s2) # print(ret) for i in s1 : del old_dict[i] for i in s2: old_dict[i]=new_dict[i] print(old_dict)
三、三元运算符
python 的三元运算
变量名 = 变量1 if 条件判断成立 else 变量2
意指: 条件成立 变量名值为变量1 否则为变量2
name = "eric" if 1 == 1 else "alex" print("==",name)
lambda 带if条件的三元运算
l1 = [11,22,33,44,55] # for i in l1: # if i % 2 == 0: # m = map(lambda x:x+100,[i,]) # l1[l1.index(i)] = list(m)[0] # print(l1) k=map(lambda x:(x+100) if (x%2==0) else x,l1) print(list(k))
四 深浅拷贝
1 数字和字符串
对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。
import copy # ######### 数字、字符串 ######### n1 = 123 # n1 = "i am alex age 10" print(id(n1)) # ## 赋值 ## n2 = n1 print(id(n2)) # ## 浅拷贝 ## n2 = copy.copy(n1) print(id(n2)) # ## 深拷贝 ## n3 = copy.deepcopy(n1) print(id(n3))
二、其他基本数据类型
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
1、赋值
赋值，只是创建一个变量，该变量指向原来内存地址，如：
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1
2、浅拷贝
浅拷贝，在内存中只额外创建第一层数据
import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n3 = copy.copy(n1)
3、深拷贝
深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化） 最底层数据要满足第一条赋值变量的条件
import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n4 = copy.deepcopy(n1)
五 函数
1、背景
在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：
while True： if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
一看上述代码，if条件语句下的内容可以被提取出来公用，如下：
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90%: 发送邮件('CPU报警') if 硬盘使用空间 > 90%: 发送邮件('硬盘报警') if 内存占用 > 80%:
对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
2、定义和使用
1 def 函数名(参数): 2 3 ... 4 函数体 5 ... 6 返回值
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。 注意是返回给函数调用者
2.1 返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
以上要点中，比较重要有参数和返回值：
如下 n5 返回值 返回给其调用者 再返回给上一层调用者。 如果 n4 n3 n2 n1 都不加return 则返回none
def n5(): return 5 def n4(): return n5() def n3(): return n4() def n2(): return n3() def n1(): return n2() ret1 = n1() print(ret1)
1 def 发送短信(): 2 3 发送短信的代码... 4 5 if 发送成功: 6 return True 7 else: 8 return False 9 10 11 while True: 12 13 # 每次执行发送短信函数，都会将返回值自动赋值给result 14 # 之后，可以根据result来写日志，或重发等操作 15 16 result = 发送短信() 17 if result == False: 18 记录日志，短信发送失败...
2.2 、参数
为什么要有参数？
对比：
无参数
1 def CPU报警邮件() 2 #发送邮件提醒 3 连接邮箱服务器 4 发送邮件 5 关闭连接 6 7 def 硬盘报警邮件() 8 #发送邮件提醒 9 连接邮箱服务器 10 发送邮件 11 关闭连接 12 13 def 内存报警邮件() 14 #发送邮件提醒 15 连接邮箱服务器 16 发送邮件 17 关闭连接 18 19 while True： 20 21 if cpu利用率 > 90%: 22 CPU报警邮件（） 23 24 if 硬盘使用空间 > 90%: 25 硬盘报警邮件（） 26 27 if 内存占用 > 80%: 28 内存报警邮件（） 29 30 无参数实现
有参数
1 def 发送邮件(邮件内容) 2 3 #发送邮件提醒 4 连接邮箱服务器 5 发送邮件 6 关闭连接 7 8 9 while True： 10 11 if cpu利用率 > 90%: 12 发送邮件("CPU报警了。") 13 14 if 硬盘使用空间 > 90%: 15 发送邮件("硬盘报警了。") 16 17 if 内存占用 > 80%: 18 发送邮件("内存报警了。") 19 20 有参数实现
2.2.1 函数参数种类
函数的有三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
普通参数
1 # ######### 定义函数 ######### 2 3 # name 叫做函数func的形式参数，简称：形参 4 def func(name): 5 print name 6 7 # ######### 执行函数 ######### 8 # 'wupeiqi' 叫做函数func的实际参数，简称：实参 9 func('wupeiqi') 10 11 普通参数
默认参数
1 def func(name, age = 18): 2 3 print "%s:%s" %(name,age) 4 5 # 指定参数 6 func('wupeiqi', 19) 7 # 使用默认参数 8 func('alex') 9 10 注：默认参数需要放在参数列表最后 11 12 默认参数
动态参数1 ： *args 意指可以传入多个元素以逗号分割
1 def func(*args): 2 3 print args 4 5 6 # 执行方式一 7 func(11,33,4,4454,5) 8 9 # 执行方式二 10 li = [11,2,2,3,3,4,54] 11 func(*li) 12 13 动态参数
如果 元素参数是一个列表呢？我们把列表传入输出的一个元素是列表，但是我们想把列表的每个元素当一个参数。调用的时候加*
1 #!/usr/bin/env python 2 # _*_ coding:utf-8 _*_ 3 __author__ = 'liujianzuo' 4 a=[1,3,4] 5 def fuc(*args): 6 #print(args) 7 return args 8 ret=fuc(a) 9 print(ret) 10 11 结果： 12 C:\Python35\python3.exe E:/py_test/s4/s5.py 13 ([1, 3, 4],) 14 15 16 17 #!/usr/bin/env python 18 # _*_ coding:utf-8 _*_ 19 __author__ = 'liujianzuo' 20 a=[1,3,4] 21 def fuc(*args): 22 #print(args) 23 return args 24 ret=fuc(*a) 25 print(ret) 26 C:\Python35\python3.exe E:/py_test/s4/s5.py 27 (1, 3, 4)
动态参数2：*args 意指可以传入多个元素以key= value key的格式是按照变量名的命名规范为标准的
1 def func(**kwargs): 2 3 print args 4 5 6 # 执行方式一 7 func(name＝'wupeiqi',age=18) 8 9 # 执行方式二 10 li = {'name':'wupeiqi', age:18, 'gender':'male'} 11 func(**li) 12 13 动态参数2 ：**kwargs
如果 元素参数是一个字典呢？我们把列表传入输出的一个元素是字典，但是我们想把字典的每个key value当一个参数。调用的时候加** 只加*是key
1 #!/usr/bin/env python 2 # _*_ coding:utf-8 _*_ 3 __author__ = 'liujianzuo' 4 a={"k1":2,"k2":3} 5 def fuc(**args): 6 #print(args) 7 return args 8 ret=fuc(**a) 9 print(ret) 10 11 C:\Python35\python3.exe E:/py_test/s4/s5.py 12 {'k1': 2, 'k2': 3}
动态参数3 ： *args **kwargs
1 def func(*args, **kwargs): 2 3 print args 4 print kwargs
1 #!/usr/bin/env python 2 # _*_ coding:utf-8 _*_ 3 __author__ = 'liujianzuo' 4 a={"k1":2,"k2":3} 5 b=[1,2,3] 6 def fuc(*args,**kwargs): 7 #print(args) 8 return args,kwargs 9 ret=fuc(*b,**a) 10 print(ret)
C:\Python35\python3.exe E:/py_test/s4/s5.py
((1, 2, 3), {'k2': 3, 'k1': 2})
扩展：发送邮件实例
#!/usr/bin/env python # _*_ coding:utf-8 _*_ __author__ = 'liujianzuo' def email(p,text,subject): import smtplib from email.mime.text import MIMEText from email.utils import formataddr ret = True try: msg = MIMEText(text, 'plain', 'utf-8') msg['From'] = formataddr(["武沛齐",'wptawy@126.com']) msg['To'] = formataddr(["走人",'424662508@qq.com']) msg['Subject'] = subject server = smtplib.SMTP("smtp.126.com", 25) server.login("wptawy@126.com", "WW.3945.59") server.sendmail('wptawy@126.com', [p,], msg.as_string()) server.quit() except: ret = False return ret r1=email("1223995142@qq.com","python test email +===","subject==pyhon") if r1: print("发生成功") else: print("发送失败")
函数变量： 局部变量 与全局变量
函数外的变量定义的全局变量，在函数内部修改不了，因为，函数内部需要global一下否则在函数内部只能是局部变量，只是变量名跟全局变量相同而已
＃!/usr/bin/env python #_*_coding:utf-8_*_ num = 10 def fun(): num +=10 输出 C:\Python35\python3.exe E:/py_test/s13_xml/log_mokuai.py Traceback (most recent call last): File "E:/py_test/s13_xml/log_mokuai.py", line 10, in <module> fun() File "E:/py_test/s13_xml/log_mokuai.py", line 7, in fun num +=10 UnboundLocalError: local variable 'num' referenced before assignment 这里执行函数是改变不了函数的num的，因为函数的num是局部变量，只是跟全局变量num相同而已。 需要global一下 num = 10 def fun(): global num num += 10 print(num) fun() C:\Python35\python3.exe E:/py_test/s13_xml/log_mokuai.py 20
liujianzuo@python:~/py_training/seminar6/day3$ cat sayHi1.py age =28 #程序全局变量 def sayHi(name): age = 29 #函数局部变量 '''this is my first test function''' print "hello %s,how are you?,my age is %s!" %(name,age) sayHi('liujianzuo') print 'age:',age liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py hello liujianzuo,how are you?,my age is 29! age: 28
注释全局变量
#age =28
def sayHi(name):
age = 29
'''this is my first test function'''
print "hello %s,how are you?,my age is %s!" %(name,age)
sayHi('liujianzuo')
print 'age:',age
报错如下
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 29!
age:
Traceback (most recent call last):
File "sayHi1.py", line 9, in <module>
print 'age:',age
NameError: name 'age' is not defined
更改方法;让局部变全局 global更改局部变全部 不建议使用
#age =28
def sayHi(name):
global age
age = 29
'''this is my first test function'''
print "hello %s,how are you?,my age is %s!" %(name,age)
sayHi('liujianzuo')
print 'age:',age
执行
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 29!
age: 29
注释局部变量
age =28
def sayHi(name):
# age = 29
'''this is my first test function'''
print "hello %s,how are you?,my age is %s!" %(name,age)
sayHi('liujianzuo')
print 'age:',age
执行
liujianzuo@python:~/py_training/seminar6/day3$ python sayHi1.py
hello liujianzuo,how are you?,my age is 28!
age: 28
练习题
1、简述普通参数、指定参数、默认参数、动态参数的区别
2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}PS:字典中的value只能是字符串或列表8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。
1 #!/usr/in/env python 2 # _*_coding:utf-8_*_ 3 """ 4 普通参数：单个是单个，多个是多个，有多少个，调用的时候就要传几个 称为形式参数 5 默认参数：只能放在 普通参数后面，不能放到前面 ，不给值的话，就用默认的值 6 指定参数：调用函数的时候传的实际参数 赋值给指定的参数名 7 动态参数：*args *kwargs 当然不一定非要叫args 规范而已。 即调用的时候 传列表 key value 8 """ 9 10 # a = "al11ex seven ;" 11 # a=input("pls in put :") 12 # alp=0 13 # num=0 14 # spa=0 15 # other=0 16 # for i in a: 17 # if i.isalpha(): 18 # alp+=1 19 # elif i.isdigit(): 20 # num+=1 21 # elif i.isspace(): 22 # spa+=1 23 # else: 24 # other+=1 25 # print("alpha:%s num : %s space: %s other:%s" % (alp,num,spa,other)) 26 27 28 # def djs(*args): 29 # print(args) 30 # return len(args[0]) 31 # ret=djs([1,2,3]) 32 # # ret=djs("alex") 33 # print(ret) 34 35 36 # 5 37 # li = ["1","2","3"] 38 # def y(*args): 39 # 40 # if len(args[0]) > 2: 41 # ret1=args[0][0:2] 42 # return ret1 43 # ret=y(li) 44 # print(ret) 45 46 47 48 #6 49 tu = (1,2,3) 50 def m(*args): 51 nu = [] 52 53 for n in args[0]: 54 if args[0].index(n) % 2 == 1: 55 nu.append(n) 56 ret = nu 57 return ret 58 print(m(tu)) 59 60 # 7 61 # dic = {"k1": "v1v1", "k2": [11,22,33,44]} 62 # def x(**kwargs): 63 # li = [] 64 # for i in kwargs.values(): 65 # if len(i) >2: 66 # ret = li.append(i[0:2]) 67 # return li 68 # 69 # 70 # ret1 = x(**dic) 71 # print(ret1)
4
知识点 all（） 函数
all(iterable) 版本：该函数在python2.5版本首次出现，适用于2.5以上版本，包括python3，兼容python3版本。 说明：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；函数等价于：
#!/usr/bin/env python # _*_ coding:utf-8 _*_ __author__ = 'liujianzuo' # a={"k1":2,"k2":3} b=[1,2,3,""] print(all(b)) def dju(args): if type(args) is str: if len(b) == 0: ret = True return "str have no empty", ret else: ret =False return "str have no empty", ret elif type(args) is list: if all(args): ret=True return "list have no empty", ret else: ret=False return "list have empty", ret elif type(args) is tuple: args=list(args) if all(args): ret = True return "tuple have no empty", ret else: ret = False return "tuple have empty", ret r1=dju(b) print(r1)
8
def func(arg1, arg2,time1): if arg1 == 0: print arg1, arg2 arg3 = arg1 + arg2 time1+=1 if time1 == 11: return arg3 return func(arg2, arg3,time1) ret=func(0, 1 , 3) print(ret)
