python开发之路3

一、三元运算

>>> def big(a, b):
...     return a if a > b else b
...
>>> big(6, 8)
8
>>> big(8, 6)
8

三元运算可以减少代码量，使用的固定格式为 a if 条件 else b  如果if后的条件成立则返回a，否则返回b。

二、基本数据类型之set()

set()是一个无序不重复的元素集合，基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。sets 支持 x in set（测试）, len(set)（计算长度）,和 for x in set（遍历）。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing（索引）, slicing（切片）, 或其它类序列（sequence-like）的操作。这里有个例子：

'''集合的两种创建方式'''
>>> se = set([11, 22, 55, 66])
>>> se
set([66, 11, 22, 55])
>>> se2 = {11, 22, 55, 66}
>>> se2
set([66, 11, 22, 55])


'''set的无序性'''
>>> l = [11, 22, 55, 66]#列表
>>> l.pop()
66
>>> l
[11, 22, 55]
#pop在列表中默认删除最后一个元素，是因为列表是有序的，支持索引和切片。
>>> se = {11, 22, 55, 66}#集合
>>> se.pop()
66
>>> se.pop()
11
>>> se
set([22, 55])
#可以看出集合中使用pop删除的元素是随机的，原因是set是一个无序的元素集合，不支持索引与切片操作。


'''set的不重复性'''
>>> l = [11, 22, 55, 66, 22, 11]
>>> l
[11, 22, 55, 66, 22, 11]
>>> se = {11, 22, 55, 66, 22, 11}
>>> se
set([66, 11, 22, 55])

set()的交集、并集、差集、对称差集。

>>> x = set((11, 22, 33, 66))
>>> y = set([11, 22, 55, 88])
>>> x
set([33, 66, 11, 22])
>>> y
set([88, 11, 22, 55])
>>> x & y#交集
set([11, 22])
>>> x | y#并集
set([33, 66, 11, 22, 55, 88])
>>> x - y#差集，在x中但不在y中的所有元素
set([33, 66])
>>> x ^ y#对称差集，在x或y中但不同时在两者中
set([33, 66, 55, 88])

set()的基本方法，x = set([11, 22, 66, 88])，y = set([22, 33, 66, 99])

1、set中求交集、并集、差集、对称差集的函数

x = set([11, 22, 66, 88])
y = set([22, 33, 66, 99])
x.intersection(y)#返回集合x与y的交集，等效于x & y
x.intersection_update(y)#取集合x与y的交集，并更新到集合x中，原集合x中的元素被清空。

x.union(y)#返回x与y的并集，等效于x | y

x.difference(y)#返回x与y的差集，等效于x - y
x.difference_update(y)#取x与y的差集，并更新到集合x中，原集合x中的元素被清空。

x.symmetric_difference(y)#返回对称差集，等效于x ^ y
x.symmetric_difference_update(y)#取对称差集，并更新到集合x中，原集合x中的元素被清空。

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.intersection(y)#返回集合x与y的交集
set([66, 22])
>>> x.intersection_update(y)#取集合x与y的交集，并更新到集合x中
>>> x
set([66, 22])
>>> y
set([33, 66, 99, 22])

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.union(y)#返回x与y的并集
set([33, 66, 99, 11, 22, 88])

>>> x
set([88, 66, 11, 22])
>>> y
set([33, 66, 99, 22])
>>> x.difference(y)#返回x与y的差集
set([88, 11])
>>> x.difference_update(y)#取x与y的差集，并更新到集合x中
>>> x
set([88, 11])
>>> y
set([33, 66, 99, 22])

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.symmetric_difference(y)#返回对称差集
set([33, 99, 11, 88])
>>> x.symmetric_difference_update(y)#取对称差集，并更新到集合x中
>>> x
set([33, 99, 11, 88])
>>> y
set([33, 66, 99, 22])

2、set()中测试的函数

x = set([11, 22, 66, 88])
y = set([22, 33, 66, 99])
x.isdisjoint(y)#判断x与y是否有交集，没有返回True，否则返回False
x.issubset(y)#判断x是不是y的子集，如果是返回True，否则返回False
x.issuperset(y)#判断x是不是y的父集，如果是返回True，否则返回False

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.isdisjoint(y)
False #x与y有交集
>>> x.issubset(y)
False #x不是y的子集，相当于y不是x的父集
>>> x.issuperset(y)
False #x不是y的父集，相当于y不是x的子集

>>> a = set([11, 22])
>>> b = set([11, 22, 66, 99])
>>> a.isdisjoint(b)
False #a与b有交集
>>> a.issubset(b)
True #a是b的子集，相当于b是a的父集
>>> b.issuperset(a)
True #b是a的父集，相当于a是b的子集

 3、set()中的增加、删除函数

x = set([11, 22, 66, 88])
y = set([22, 33, 66, 99])
'''增加'''
x.add(object)#向集合x中增加元素
x.update(y)#更新集合x，将y中的所有元素添加到集合x中
'''删除'''
x.pop()#随机删除集合x中的任意一个元素
x.remove(object)#删除集合x中的指定元素，若没有则报错
x.discard(object)#删除集合x中的指定元素，没有不报错

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.add(666)
>>> x
set([88, 66, 11, 666, 22])

>>> x = set([11, 22, 66, 88])
>>> y = set([22, 33, 66, 99])
>>> x.update(y)
>>> x
set([33, 66, 99, 11, 22, 88])

>>> x.pop()#pop随机删除一元素
88
>>> x
set([66, 11, 666, 22])
>>> x.remove(66)
>>> x.remove(99)#集合x中并没有元素99，remove报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 99
>>> x.discard(11)
>>> x.discard(99)#集合x中并没有元素99，discard不报错
>>> x
set([666, 22])

 4、其它

x = set([11, 22, 66, 88])
x.clear()#清楚集合x中的所有元素
x.copy()#集合x的浅拷贝

>>> x = set([11, 22, 66, 88])
>>> x
set([88, 66, 11, 22])
>>> x.clear()
>>> x
set([])

>>> x = set([11, 22, 66, 88])
>>> y = x.copy()
>>> y
set([88, 66, 11, 22])
>>> x
set([88, 66, 11, 22])
>>> id(x)
43219880L
>>> id(y)
43218088L

 三、深浅拷贝

import copy
copy.copy()#浅拷贝
copy.deepcopy()#深拷贝

1、针对于数字、字符串的赋值、浅拷贝、深拷贝，id永远指向同一内存地址

>>> import copy
>>> a = 666
>>> b = a #赋值
>>> c = copy.copy(a) #浅拷贝
>>> d = copy.deepcopy(a) #深拷贝
>>> id(a)
44849496L
>>> id(b)
44849496L
>>> id(c)
44849496L
>>> id(d)
44849496L

2、 其它类型数据，列表、元组、字典的赋值、深浅拷贝

>>> l = [11, 22, (666, 999), {'name': 'alex', 'age': 18}]
>>> l2 = l #赋值
>>> l3 = copy.copy(l) #浅拷贝
>>> l4 = copy.deepcopy(l) #深拷贝
>>> id(l)
44785864L
>>> id(l2) #赋值后内存地址不变
44785864L
>>> id(l3) #浅拷贝第一层内存地址改变，拷贝了第一层
44788360L
>>> id(l4) #深拷贝第一层内存地址改变，拷贝了第一层
44725192L

>>> id(l[3])
44762248L
>>> id(l2[3]) #赋值后内存地址不变
44762248L
>>> id(l3[3]) #浅拷贝，第二层内存地址不变，只拷贝了第一层
44762248L
>>> id(l4[3]) #深拷贝，第二层内存地址改变，拷贝了第一层，第二层
44763880L

>>> id(l[3]['name'])
45128120L
>>> id(l2[3]['name']) #赋值后内存地址不变
45128120L
>>> id(l3[3]['name']) #浅拷贝，第三层内存地址不变，只拷贝了第一层
45128120L
>>> id(l4[3]['name']) #深拷贝，第三层内存地址不变，只拷贝了第一层，第二层
45128120L
>>>

四、函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

1、函数定义规则

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2、函数的参数

def func():
    print('这是一个无参函数')
    return 'success'
ret = func()
print(ret)

# -*- coding:utf-8 -*-
def func(x, n):
'''计算x的n次幂'''
    ret = x**n
    return ret
ret = func(2, 3)
print(ret)

3、参数类型

def func(name):
    return name
ret = func('alex')
print(ret)

def func(x, n=2):#默认参数n=2，默认参数只能放在参数最后。
    ret = x**n
    return ret
ret1 = func(2)#使用默认参数，计算2**3
print(ret1)
ret2 = func(2, 3)#使用传入参数，计算2**3
print(ret2)

def func(*n): #加上*号，表示传入参数不定长
    l = []
    for i in n:
        l.append(i**2)
    return l
ret1 = func(1,2,3,4,5)
print(ret1)

'''给定一可迭代序列，根据序列名传参'''
num = (6, 7, 8, 9, 10)
ret2 = func(*num) #在变量名前加上*号
print(ret2)

def func(**kwargs): #加上**表示传入不定长字典
    return kwargs
ret1 = func(name = 'alex', age = 18) #传入参数必须是这种类字典的表示形式
print(ret1)
'''给定一字典，根据字典变量名传参'''
d = {'name': 'eric', 'age': 22}
ret2 = func(**d) #在变量名前加上**
print(ret2)

def func(*args, **kwargs):
    return args, kwargs
ret1 = func(11, 22, 666, name = 'alex', age = 18)
print(ret1)

l = (33, 55, 999)
d = {'name': 'eric', 'age': 22}
ret2 = func(*l, **d)
print(ret2)

4、变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

5、全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2; # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total;
 
#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ", total

#打印结果
'''
函数内是局部变量 : 30
函数外是全局变量 : 0
'''

6、global定义全局变量

#!/usr/bin/python
# -*- coding: UTF-8 -*-

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   global total #定义变量total为全局变量
   total = arg1 + arg2; # total在这里是全局变量.
   print "函数内也是全局变量 : ", total
   return total;
 
#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ", total 


#打印结果
'''
函数内也是全局变量 : 30
函数外是全局变量 : 30
'''

7、扩展：发送邮件

 # -*- coding:utf-8 -*-
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail():
    falg = True
    try:
        msg = MIMEText('邮件内容', 'plain', 'utf-8')
        msg['From'] = formataddr(['taoleilei', '18381672842@163.com'])
        msg['To'] = formataddr(['走人', '1214360171@qq.com'])
        msg['Subject'] = '主题'

        server = smtplib.SMTP('smtp.163.com', 25)
        server.login('18381672842@163.com','邮箱密码')
        server.sendmail('18381672842@163.com', ['1214360171@qq.com',], msg.as_string())
        server.quit()
    except Exception:
        falg = False
    return falg
falg = mail()
print(falg)

 作业：http://www.cnblogs.com/taoleilei/articles/5469358.html