标签：
set集合
集合是一个无序且不重复的元素组合，以大括号表示。使用详情：
>>> b=set(a) >>> type(b) <class ‘set‘> >>> print(b) {‘hello‘, 1, 3, ‘cc‘, ‘dx‘} >>> print(b) {‘hello‘, 1, 3, ‘cc‘, ‘dx‘} >>> b.add(‘world‘) #添加某元素，参数为元素本身 >>> print(b) {1, ‘world‘, ‘hello‘, 3, ‘cc‘, ‘dx‘}
使用说明：
s.add()添加某元素，参数为元素本身
s.clear() 清空集合
>>> b.clear() >>> print(b) set()
set集合的删除，有三个s.discard(),s.pop(),s.remove()
其中s.discard() 如果集合中无元素，不报错；有元素，就删除
s.pop() 随机删除集合中的某个元素，取到元素后返回元素的值，s.pop()不能加目标元素，故频率略低
s.remove() 删除目标元素，但集合中如无元素，会报错
del 不支持set集合的删除
栗子：
>>> b={‘hello‘, 1, 3, ‘cc‘, ‘dx‘}
>>> type(b)
<class ‘set‘>
>>> b.pop(‘dx‘)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)
>>> b.pop() #随机删除并取到返回值
‘hello‘
>>> print(b)
{1, 3, ‘cc‘, ‘dx‘}
>>> b.remove(‘cccc‘) #集合中无元素会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘cccc‘
>>> b.remove(‘cc‘)
>>> print(b)
{1, 3, ‘dx‘}
>>> b.discard(‘cccc‘)
>>> print(b)
{1, 3, ‘dx‘}
>>> b.discard(‘ccc‘) #集合中无论有无目标元素，均不报错
>>> b.discard(1)
>>> print(b)
{3, ‘dx‘}
>>>
s.difference(b) 取集合s中有，b中没有的元素，并返回由此元素组成的集合
s.interscetion(b) 交集，两s和b中的交集，返回s,b中都存在的元素组成的集合
new_dict={1:8,2:4,4:2}
old_dict={1:4,2:4,3:2}
new_s=set(new_dict)
old_s=set(old_dict)
print(new_s)
print(old_s)
in_s=new_s.intersection(old_s)
print(in_s)
s_del=new_s.difference(old_dict)
print(s_del)
结果：
{1, 2, 4}
{1, 2, 3}
{1, 2}
{4}
s.issubset(b) 判断s是否是b的子集
s.issuperset(b) 判断s是否是b的父集
栗子：
print(in_s.issubset(new_s)) print(new_s.issuperset(in_s)) 结果： True True
s.intersection_update(b) 取s和b的交集更新s,s成为新集合，集合为s和b的交集
>>> s={1,2,3,4,56,78}
>>> b={7,8,9,67,56,78}
>>> s.intersection_update(b)
>>> print(s)
{56, 78}
>>> print(b)
{67, 7, 8, 9, 78, 56}
>>>
s.difference_update(b) 取s和b的交集，s成为新集合，将交集从s中删除
>>> s={1,2,3,4,56,78}
>>> b={7,8,9,67,56,78}
>>> b.difference_update(s)
>>> print(b)
{67, 7, 8, 9}
>>> print(s)
{1, 2, 3, 4, 78, 56}
>>>
s.isdisjoint(b) 判断是否有交集，如果无交集，返回True
>>> print(b) {67, 7, 8, 9} >>> print(s) {1, 2, 3, 4, 78, 56} >>> s.isdisjoint(b) True >>>
s.symmetric_difference(b) 取差集，并创建一个新的集合
>>> s={1,2,3,4,56,78}
>>> b={7,8,9,67,56,78}
>>> s.symmetric_difference(b)
{1, 2, 67, 3, 4, 7, 8, 9}
>>>
s.symmetric_difference_update() 取差集，并将sf为差集本身赋值为差集本身
>>> s={1,2,3,4,56,78}
>>> b={7,8,9,67,56,78}>>> s.symmetric_difference_update(b)
>>> print(s)
{1, 2, 3, 4, 67, 7, 8, 9}
>>> print(b)
{67, 7, 8, 9, 78, 56}
>>>
s.union(b) 并集
>>> print(s) {1, 2, 3, 4, 67, 7, 8, 9} >>> print(b) {67, 7, 8, 9, 78, 56} >>> s.union(b) {1, 2, 3, 4, 67, 7, 8, 9, 78, 56} >>> print(s) {1, 2, 3, 4, 67, 7, 8, 9} >>> print(b) {67, 7, 8, 9, 78, 56} >>>
函数
1.作用域
if 1==1: name=‘cc‘ print(name)
结果：
cc
对于变量的作用域，执行声明并在内存中存在，该变量就可以在下面的代码中使用。
2.三元运算&三目运算
result = 值1 if 条件 else 值2
如果条件为为真，result=值1，如果条件为假，result=值2
python中的三元运算是以bool值求表达的，if...else...的简写。
name = ‘alex‘ if 1==1 else ‘sb‘ print(name)
结果：
alex
3.lambda
lambda表达式其实就是一个简单的函数：
def f1(a1): return a1+20 f2=lambda a1:a1+20 #同f1 f3=lambda a1,a2:a1+a2+20 #lambda表达式还可使用多个参数 res1=f1(10) res2=f2(10) print(res1) print(res2) print(f3(20,30))
结果：
30 30 70
4.函数
先上一个比较有意思的发送邮件的函数：
def sendmail(): try: import smtplib from email.mime.text import MIMEText from email.utils import formataddr msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘) msg[‘From‘] = formataddr(["武沛齐",‘wptawy@126.com‘]) msg[‘To‘] = formataddr(["走人",‘424662508@qq.com‘]) msg[‘Subject‘] = "主题" server = smtplib.SMTP("smtp.126.com", 25) server.login("wptawy@126.com", "WW.3945.5") server.sendmail(‘wptawy@126.com‘, [‘3628905@qq.com‘,], msg.as_string()) server.quit() except: # 发送失败 return "失败" else: # 发送成功 return "cc" ret = sendmail() print(ret) if ret == "cc": print(‘发送成功‘) else: print("发送失败")
上面函数中，try...except...else 语句，是用来处理python的异常的，然后用return的值判断发送的结果。
函数的调用：如果设定了return值，可将函数直接赋予一个变量，res=sendmail()即可；如果没有设置return值，直接执行sendmail()即可，当然这是使用习惯问题，想怎么用自己尝试吧：）
在函数中，使用return来中断函数，如果没有指定函数的return值，那么他的默认值是None.
def f1(): print(123) # 在函数中，一旦执行return，函数执行过程立即终止 return "111" print(456) r = f1() print(r)
执行结果为：
123 111 [Finished in 0.1s]
结果中并未打印456。
def f2(): print(123) r = f2() print(r)
结果：
123 None [Finished in 0.1s]
可见函数默认的return值为None
5.函数参数：
函数参数有多种，可分以下几种：
5.1 普通参数 特点：严格按照参数的顺序，将实际参数赋值给形式参数
5.2 默认参数 特点：必须放置在参数列表的最后
5.3 指定参数 特点：将实际参数赋值给指定的形式参数
5.4 动态参数
特点：1.*args，默认将传入的函数，全部放置在元组中，f1(*[11,22,33,44])
2.**args,默认将传入的函数，全部放置在字典中，f1(**{"kl":"v1", "k2":"v2"})
3.*args,多个参数，自动转化为tuple,普通方式都是放于元组中，成为其中一个参数，实际参数中前面加*，将其中的字符串或者列表中的每个元素挑选出来放在元组中
5.5 万能参数 特点：*args,**kwargs，而且顺序不能变，**kwargs必须在后面
普通参数、动态参数例子：
s1 = "i am {0}, age {1}".format("alex", 18) #普通参数 print(s1) s2 = "i am {0}, age {1}".format(*["alex", 18]) #动态参数 print(s2)
结果：
i am alex, age 18 i am alex, age 18 [Finished in 0.1s]
指定参数、动态参数例子：
s1 = "i am {name}, age {age}".format(name=‘alex‘, age=18) #指定参数 print(s1) dic = {‘name‘: ‘alex‘, "age": 18} s2 = "i am {name}, age {age}".format(**dic) #动态参数 print(s2) 结果： i am alex, age 18 i am alex, age 18 [Finished in 0.1s]
万能参数例子：
def f1(*args, **kwargs): print(args) print(kwargs) f1(k1="v1") 结果： () {‘k1‘: ‘v1‘} [Finished in 0.0s]
动态参数：
def f1(*args): print(args, type(args)) f1(11,22,33,44) li = [11,22,33,44] f1(*li) 结果： (11, 22, 33, 44) <class ‘tuple‘> (11, 22, 33, 44) <class ‘tuple‘> [Finished in 0.1s]
动态参数：
def f(*args): print(type(args),args) f(‘alex‘) f([1,1,2,3,4,]) f(‘alex‘,‘cc‘) f([1,2,4,6,8,],‘alex‘) f(*[12,4,6,7,],‘alex‘) 结果： <class ‘tuple‘> (‘alex‘,) <class ‘tuple‘> ([1, 1, 2, 3, 4],) <class ‘tuple‘> (‘alex‘, ‘cc‘) <class ‘tuple‘> ([1, 2, 4, 6, 8], ‘alex‘) <class ‘tuple‘> (12, 4, 6, 7, ‘alex‘)
s1=‘I am {0},age {1}‘.format(‘chengc‘,18) print(s1) s2=‘I am {0},age {1}‘.format(*[‘cc‘,32,]) print(s2) s3=‘I am {name},age {age}‘.format(name=‘cc‘,age=21) print(s3) s4=‘I am {name},age {age}‘.format(**{‘name‘:‘chengc‘,‘age‘:17}) print(s4) 结果： I am chengc,age 18 I am cc,age 32 I am cc,age 21 I am chengc,age 17
动态参数、指定参数：
def f1(**args): print(args, type(args)) f1(n1="alex", n2=18) dic = {‘k1‘: "v1", "k2":"v2"} f1(kk=dic) dic = {‘k1‘: "v1", "k2":"v2"} f1(**dic) 结果： {‘n1‘: ‘alex‘, ‘n2‘: 18} <class ‘dict‘> {‘kk‘: {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}} <class ‘dict‘> {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘} <class ‘dict‘> [Finished in 0.1s]
默认参数：
def send(ooxx,content,xx): print(ooxx,content,xx) return 0 send(‘water‘,‘sdsdf‘,‘ddd‘) 结果： water sdsdf ddd [Finished in 0.1s]
默认参数必须放在最后，默认参数也可被实际参数覆盖
def send(ooxx,content,xx=‘bye‘): print(ooxx,content,xx) return 0 send(‘water‘,‘sdsdf‘,‘exe‘) 结果： water sdsdf exe [Finished in 0.1s]
万能参数：
def f(*args,**kwargs): print(args) print(kwargs) f(12,4,5,6,k1=‘v1‘,k2=‘v2‘) #注意，k1 k2未带引号 结果： (12, 4, 5, 6) {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} [Finished in 0.1s]
6. 函数参数的传递
函数参数传递时用的是引用，举个栗子：
def f(a1): a1.append(9999) li=[12,3,4,5] f(li) print(li) 结果： #注意，已将li列表增加了9999元素， [12, 3, 4, 5, 9999]
参数引用栗子1：
NAME_LI=[1,2,3,4]
def f():
NAME_LI.append(‘chengc‘)
# global NAME_LI
# NAME_LI={‘k1‘:‘V1‘}
print(NAME_LI)
res=f()
print(res)
print(NAME_LI)
结果： #参数引用，已修改
[1, 2, 3, 4, ‘chengc‘]
None
[1, 2, 3, 4, ‘chengc‘]
上面的例子和参数的引用是一码事，栗子2：
def f(a1): a1.append(9999) name=[12,3,4,5] f(name) print(name) 结果： #注意这个改变了，但f()中为参数， [12, 3, 4, 5, 9999] [Finished in 0.1s]
跟下面的效果也一样，栗子3：
def f(name): name.append(9999) name=[12,3,4,5] f(name) print(name) 结果： [12, 3, 4, 5, 9999]
7. 函数的全局变量
全局变量，在所有函数中的的作用域都可读，全局变量一般用全部大写命名，比如NAME,AGE等。
在作用域中，如果想对全局变量重新赋值，需要用“global”关键字。
需要特殊注意的一点：如果全局变量的类型为列表字典等，可修改，但不可以重新赋值。（与global无关），栗子2里有。
栗子1：
NAME_LI=[1,2,3,4] def f(): global NAME_LI NAME_LI={‘k1‘:‘V1‘} print(NAME_LI) res=f() print(res) print(NAME_LI) 结果： {‘k1‘: ‘V1‘} None {‘k1‘: ‘V1‘}
说明：global可改全局变量
栗子2：
NAME_LI=[1,2,3,4] def f(): NAME_LI.append(‘chengc‘) NAME_LI={‘k1‘:‘V1‘} print(NAME_LI) res=f() print(res) print(NAME_LI) 结果： File "/Users/shane/PycharmProjects/Py_study/Base/S3/s3.py", line 42, in <module> res=f() File "/Users/shane/PycharmProjects/Py_study/Base/S3/s3.py", line 36, in f NAME_LI.append(‘chengc‘) UnboundLocalError: local variable ‘NAME_LI‘ referenced before assignment
报错了！说明：作用域中，既使用了全局变量，又想对全局变量重新赋值，是不被允许的。
8. 函数执行时，如果有多次同样函数名称的def，以最后一次定义的为准。
这个理解起来简单，都是按顺序执行的，所以就不列例子了。
标签：
原文地址：http://www.cnblogs.com/ccorz/p/5524417.html
