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，执行一个功能，自身进行变化
|
1
2
3
4
5
6
|
字典：列表一句变字典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条件的三元运算
|
1
2
3
4
5
6
7
8
|
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)
人的思维，观点是一直都会进化的。如果现在的思维，观点看法；和十年前的一模一样的话。那就可以说，你这十年是白活的。
浙公网安备 33010602011771号