94被浏览4776分享邀请回答261 条评论分享收藏感谢收起182 条评论分享收藏感谢收起查看更多回答一 上节课拾遗
　　　字符串 判断 &：&&hello& in "asdasfhelloasdfsadf"
　　　列表元素判断："li" in ['li', 'ok']
　　　字典key判断：key in dic.keys()
2 基本的数据类型
其实就是执行类的 __init__
__init__(self,args,base=10)
a. 创建方式 两种
# 根据int类，创建了一个对象
n2 = int(123) # 根据int类，创建了一个对象 类的实例化就是对象
b. int内部优化
1、n1 和 n2 的内存地址相同
2、按理说 n1 和 n2 的内存地址不相同
但是Python内部做了优化，
-5 ~ 257 以内的数，按照 2 的方式写时，都是指向同一个内存
除此以外的数，都是n1 和 n2 的内存地址不相同
python源码可以改取值范围
n1 = 123123
n2 = 123123
3、id查看对象的内存地址
i1 = id(n1)
i1 = id(123)
c. int长度限制
-2**31 ~ 2 **31 -1
-2**63 ~ 2**63 - 1
　　　　　　　数字后有L 代表长整型
python 2.2之后，超过int的最大长度后，会自动转换成long类型，long类型无长度限制
python 3之后，int自己就无长度限制了
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("刘建佐")
3.5 ==》 字符
（utf-8 中 规定1个汉字3个字节，但是3版本中 1个汉字就是一个字符，不是字节。所以这里len是3）
3.5 ==》 字符
（3 版本中 循环汉字字符串不是字节，而是按照字符来进行循环的）
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个汉字
-》 2字节 1个汉字
print(bytes_list) # 默认每一个字节都是16进制表示
for b in bytes_list:
# 默认每一个字节都是10进制表示
3、10进制的数字 ==》 2进制
bin(10进制的数字)
d、 bytes和str的转换
将字节转换成字符串 bytes方法
a = "李露"
# 将字符串转换成字节
b1 = bytes(a, encoding='utf-8')
b2 = bytes(a, encoding='gbk')
# 将字节转换成字符串
newa1 = str(b1, encoding="utf-8")
print(newa1)
newa2 = str(b2, encoding='gbk')
print(newa2)
###########
# 创建字符串
# 转换成字符串，字节，编码
m = bytes()
# 创建字节
# 转换成字节，字符串，要编程什么编码类型的字节
python进制转换
hex 可以 十进制转16进制
二进制转16进制
结果都是字符串
&&& hex(0b10)
&&& hex(10)
bin 可以十进制转2进制
16进制转2进制
结果都是字符串
&&& bin(10)
&&& bin(0x2)
int 可以16进制转换十进制 2进制转换十进制
&&& int(0xe)
&&& int(0b100)
可变元素的&集合&
-----------
str -& 创建字符串，或者将其他的转换成字符串
------------------------------------------
list -& 创建列表，将其他元素转换成列表
a. 创建和转换
li = [11,22,33,4]
li = list()
li = list([11,22,33,4])
注：放可迭代的 凡是可以for循环的都可以迭代。
字符串 元组 字典 列表本身 都可以迭代
s1 = "李露"
# for，字符 ==& 可迭代
l1 = list(s1) # for循环，将循环的每一个元素，当做列表的元素
# ["李", "露"]
　　　　　　　　　# 元组 转换成列表
# 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]
　　　　　　　enumerate
　　　　　　
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. 特有方法
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(dic)
a = {"k1": 123}
a = dict()
li = [11,22,33]
new_dict = dict(enumerate(li))
print(new_dict)
2、字典内部功能
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也会修改
n['k1'] = 3
# 而单独修改key的value的话，只有 这个key的value改了，而其他的key对应的value都不变
n = dict.fromkeys()
#默认逗号后面不给的话，key对应的value都是None
二 集合 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.
def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. 清楚内容"""
def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. 浅拷贝
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.)
def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set.
从当前集合中删除和B中相同的元素"""
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. 移除指定元素，不存在不保错
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.)
def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another.
取交集并更更新到A中 """
def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection.
如果没有交集，返回True，否则返回False"""
def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set.
是否是子序列"""
def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. 是否是父序列"""
def pop(self, *args, **kwargs): # real signature unknown
Remove and return an arbitrary set element.
Raises KeyError if the set is empty. 移除元素
def remove(self, *args, **kwargs): # real signature unknown
Remove a it must be a member.
If the element is not a member, raise a KeyError. 移除指定元素，不存在保错
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.)
def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. 对称交集，并更新到a中 """
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.)
def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. 更新 """
set 集合class
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
a={1:2,4:5}
b.add(111111)
n = {11,22,33}
b = {22,66}
# 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])
#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)
是否是子集
不是返回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)
#remove 删除集合元素 如果元素不存在 报错
#n.remove(99)
z = {11,22,33}
z.intersection(p)
#取交集并更新到z中
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
old_dict = {
new_dict = {
# b = set(old_dict.keys())
# print(b)
old_dict.keys():
for n in new_dict:
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]
old_dict[i]=new_dict[i]
print(old_dict)
set集合练习
&&& 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)
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
交集应用场景：比如两个班级都叫alex或者两个班级都是100分的 或者两个班级中都大于多少分的
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
set([8, 9, 10, 6, 7])
set([8, 9, 10, 6, 7])
把两个里面对方都没有的打印出来
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
set([0, 1, 2, 3, 4, 5, 12])
set([6, 7, 8, 9, 10, 11, 12])
a.add集合中添加一项，同样的去重不同样的增加
&&& a.add(0)
&&& a.add(22)
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22])
a.update集合添加多项
&&& a.update([23,34,35])
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23])
添加一个集合到另一个集合
&&& a.update(b)
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)
&&& len(b)
&&& b in a
&&& a in a
&&& import tab
&&& b.issubset(a)
#测试b中的每一个元素都在a中
&&& a.issubset(b)
&&& 3 in a
&&& b.issuperset(a)
&&& a.issuperset(b)
#测试b中的每个元素都在a中
set集合练习
练习：寻找差异
# 数据库中原有
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)
old_dict.keys():
for n in new_dict:
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]
old_dict[i]=new_dict[i]
print(old_dict)
set集合练习题答案 寻找差异&
三、三元运算符
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 = "i am alex age 10"
print(id(n1))
# ## 赋值 ##
print(id(n2))
# ## 浅拷贝 ##
n2 = copy.copy(n1)
print(id(n2))
# ## 深拷贝 ##
n3 = copy.deepcopy(n1)
print(id(n3))
二、其他基本数据类型
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
赋值，只是创建一个变量，该变量指向原来内存地址，如：
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
浅拷贝，在内存中只额外创建第一层数据
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化） &最底层数据要满足第一条赋值变量的条件
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)
在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：
while True：
&&&&if cpu利用率 & 90%:
&&&&&&&&#发送邮件提醒
&&&&&&&&连接邮箱服务器
&&&&&&&&发送邮件
&&&&&&&&关闭连接
&&&&if 硬盘使用空间 & 90%:
&&&&&&&&#发送邮件提醒
&&&&&&&&连接邮箱服务器
&&&&&&&&发送邮件
&&&&&&&&关闭连接
&&&&if 内存占用 & 80%:
&&&&&&&&#发送邮件提醒
&&&&&&&&连接邮箱服务器
&&&&&&&&发送邮件
&&&&&&&&关闭连接
一看上述代码，if条件语句下的内容可以被提取出来公用，如下：
def 发送邮件(内容)
&&&&#发送邮件提醒
&&&&连接邮箱服务器
&&&&发送邮件
&&&&关闭连接
while True：
&&&&if cpu利用率 & 90%:
&&&&&&&&发送邮件('CPU报警')
&&&&if 硬盘使用空间 & 90%:
&&&&&&&&发送邮件('硬盘报警')
&&&&if 内存占用 & 80%:
对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发&更快更好更强...&
& &函数式编程最重要的是增强代码的重用性和可读性
2、定义和使用
1 def 函数名(参数):
4 &&&&函数体
6 &&&&返回值
函数的定义主要有如下要点：
def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。 注意是返回给函数调用者
&2.1 返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
以上要点中，比较重要有参数和返回值：
n5 返回值 返回给其调用者
再返回给上一层调用者。
如果 n4 n3 n2 n1 都不加return 则返回nonedef n5():
return n5()
return n4()
return n3()
ret1 = n1()
print(ret1)
1 def 发送短信():
3 &&&&发送短信的代码...
5 &&&&if 发送成功:
6 &&&&&&&&return True
7 &&&&else:
8 &&&&&&&&return False
11 while True:
12 &&&&&&&
13 &&&&# 每次执行发送短信函数，都会将返回值自动赋值给result
14 &&&&# 之后，可以根据result来写日志，或重发等操作
16 &&&&result = 发送短信()
17 &&&&if result == False:
18 &&&&&&&&记录日志，短信发送失败...
2.2 、参数
为什么要有参数？
1 def CPU报警邮件()
#发送邮件提醒
连接邮箱服务器
7 def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
13 def 内存报警邮件()
#发送邮件提醒
连接邮箱服务器
19 while True：
if cpu利用率 & 90%:
CPU报警邮件（）
if 硬盘使用空间 & 90%:
硬盘报警邮件（）
if 内存占用 & 80%:
内存报警邮件（）
30 无参数实现
1 def 发送邮件(邮件内容)
#发送邮件提醒
连接邮箱服务器
9 while True：
if cpu利用率 & 90%:
发送邮件("CPU报警了。")
if 硬盘使用空间 & 90%:
发送邮件("硬盘报警了。")
if 内存占用 & 80%:
发送邮件("内存报警了。")
20 有参数实现
2.2.1 & 函数参数种类
函数的有三中不同的参数：
1 # ######### 定义函数 #########
3 # name 叫做函数func的形式参数，简称：形参
4 def func(name):
print name
7 # ######### 执行函数 #########
'wupeiqi' 叫做函数func的实际参数，简称：实参
9 func('wupeiqi')
11 普通参数
1 def func(name, age = 18):
print "%s:%s" %(name,age)
5 # 指定参数
6 func('wupeiqi', 19)
7 # 使用默认参数
8 func('alex')
10 注：默认参数需要放在参数列表最后
12 默认参数
动态参数1 &： *args & 意指可以传入多个元素以逗号分割
1 def func(*args):
print args
6 # 执行方式一
7 func(11,33,4,4454,5)
9 # 执行方式二
10 li = [11,2,2,3,3,4,54]
11 func(*li)
13 动态参数
如果 元素参数是一个列表呢？我们把列表传入输出的一个元素是列表，但是我们想把列表的每个元素当一个参数。调用的时候加*
1 #!/usr/bin/env python
2 # _*_ coding:utf-8 _*_
3 __author__ = 'liujianzuo'
4 a=[1,3,4]
5 def fuc(*args):
#print(args)
return args
8 ret=fuc(a)
9 print(ret)
12 C:\Python35\python3.exe E:/py_test/s4/s5.py
13 ([1, 3, 4],)
17 #!/usr/bin/env python
18 # _*_ coding:utf-8 _*_
19 __author__ = 'liujianzuo'
20 a=[1,3,4]
21 def fuc(*args):
#print(args)
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):
print args
6 # 执行方式一
7 func(name＝'wupeiqi',age=18)
9 # 执行方式二
10 li = {'name':'wupeiqi', age:18, 'gender':'male'}
11 func(**li)
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):
#print(args)
return args
8 ret=fuc(**a)
9 print(ret)
11 C:\Python35\python3.exe E:/py_test/s4/s5.py
12 {'k1': 2, 'k2': 3}
动态参数3 ： *args **kwargs
1 def func(*args, **kwargs):
print args
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):
#print(args)
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
msg = MIMEText(text, 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",''])
msg['To'] = formataddr(["走人",''])
msg['Subject'] = subject
server = smtplib.SMTP("", 25)
server.login("", "WW.3945.59")
server.sendmail('', [p,], msg.as_string())
server.quit()
ret = False
return ret
r1=email("","python test email +===","subject==pyhon")
print("发生成功")
print("发送失败")
&函数变量： 局部变量 与全局变量
函数外的变量定义的全局变量，在函数内部修改不了，因为，函数内部需要global一下否则在函数内部只能是局部变量，只是变量名跟全局变量相同而已
＃!/usr/bin/env python
#_*_coding:utf-8_*_
def fun():
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&
File "E:/py_test/s13_xml/log_mokuai.py", line 7, in fun
UnboundLocalError: local variable 'num' referenced before assignment
这里执行函数是改变不了函数的num的，因为函数的num是局部变量，只是跟全局变量num相同而已。 需要global一下
def fun():
global num
print(num)
C:\Python35\python3.exe E:/py_test/s13_xml/log_mokuai.py
全局变量与局部变量区别
liujianzuo@python:~/py_training/seminar6/day3$ cat sayHi1.py
#程序全局变量
def sayHi(name):
#函数局部变量
'''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!
注释全局变量
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!
Traceback (most recent call last):
&&File "sayHi1.py", line 9, in &module&
&&&&print 'age:',age
NameError: name 'age' is not defined
更改方法;让局部变全局 &global更改局部变全部 不建议使用
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!
注释局部变量
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_*_
4 普通参数：单个是单个，多个是多个，有多少个，调用的时候就要传几个
称为形式参数
5 默认参数：只能放在 普通参数后面，不能放到前面 ，不给值的话，就用默认的值
6 指定参数：调用函数的时候传的实际参数
赋值给指定的参数名
7 动态参数：*args *kwargs
当然不一定非要叫args 规范而已。 即调用的时候 传列表 key value
10 # a = "al11"
11 # a=input("pls in put :")
12 # alp=0
13 # num=0
14 # spa=0
15 # other=0
16 # for i in a:
if i.isalpha():
elif i.isdigit():
elif i.isspace():
25 # print("alpha:%s num : %s space: %s other:%s" % (alp,num,spa,other))
28 # def djs(*args):
print(args)
return len(args[0])
31 # ret=djs([1,2,3])
32 # # ret=djs("alex")
33 # print(ret)
37 # li = ["1","2","3"]
38 # def y(*args):
if len(args[0]) & 2:
ret1=args[0][0:2]
return ret1
43 # ret=y(li)
44 # print(ret)
49 tu = (1,2,3)
50 def m(*args):
for n in args[0]:
if args[0].index(n) % 2 == 1:
nu.append(n)
return ret
58 print(m(tu))
61 # dic = {"k1": "v1v1", "k2": [11,22,33,44]}
62 # def x(**kwargs):
for i in kwargs.values():
if len(i) &2:
ret = li.append(i[0:2])
70 # ret1 = x(**dic)
71 # print(ret1)
　　知识点 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
ret =False
return "str
have no empty", ret
elif type(args) is list:
if all(args):
return "list
have no empty", ret
return "list have empty", ret
elif type(args) is tuple:
args=list(args)
if all(args):
ret = True
return "tuple have no empty", ret
ret = False
return "tuple have
empty", ret
def func(arg1, arg2,time1):
if arg1 == 0:
arg1, arg2
arg3 = arg1 + arg2
if time1 == 11:
func(arg2, arg3,time1)
ret=func(0, 1 , 3)
print(ret)
阅读(...) 评论() &