python_day3

一、set的基本操作

>>> s1=set("abc123abc")
>>> s1                #把字符串转化为set,去重
set(['a', 'c', 'b', '1', '3', '2'])
 
>>> t1=set([3,4,5,6]) #创建set方式一
>>> t2={1,2,3,6,7,8}  #创建set方式二

>>> t1|t2             #并集
set([1, 2, 3, 4, 5, 6, 7, 8])

>>> t1&t2             #交集(t1和t2中都存在的元素)
set([3, 6])

>>> t1-t2             #差集(t1中存在并且t2中不存在的元素)
set([4, 5])

>>> t2-t1             #差集(t2中存在并且t1中不存在的元素)
set([8, 1, 2, 7])

>>> t1^t2 
set([1, 2, 4, 5, 7, 8])

>>> t2^t1             #对称差(t1和t2的并集减去交集)
set([1, 2, 4, 5, 7, 8])
 

二、set的函数操作

t1={1,2,4,5}
t2={1,2,3,6,7,8}
s3=t1.difference(t2)#t2 - (t1,t2的交集)

t2.difference_update(t1) #t2 - (t1,t2的交集) ,修改原来的对象

t2.discard('k')#删除指定的元素

t2.intersection(t1)#交集

t2.intersection_update()#t1,t2的交集赋给t2

t3=set([1,2,3])
t4=set([1,2,3,4,5])
t3.issubset(t4#t3的每一个元素在t4存在就返回True,否则False
t4.issuperset(t3) #t3的每一个元素在t4存在就返回True,否则False

a1={1,2}
b1={3,4}
a1.isdisjoint(b1)#如果a1,b1没有交集返回True,否则返回False

t2.symmetric_difference(1)#返回t2和t1不重复的元素

t2.symmetric_difference_update()#返回t2和t1不重复的元素,修改原来的对象

t2.union()#t1,t2的并集

t2.clear()#删除t2的所有元素

t2.pop()#从左边删除第一个元素

t2.remove(8)#删除指定的元素

三、collections计数器

collections继承dict类，主要用于统计，使用方法基本与dict一样

>>> import collections

>>> str1=collections.Counter('abcdadc') #字符出现的次数
>>> str1
Counter({'a': 2, 'c': 2, 'd': 2, 'b': 1})

>>> list(str1) #转化为列表
['a', 'c', 'b', 'd']

>>> str1.most_common(1)#访问几个元素
[('a', 2)]

>>> del  str1['a']#删除指定的key
>>> str1['b'] #访问字典指定的key
1
>>> str1.values() #打印字典的value
[2, 1, 2]

>>> sum(str1.values()) #统计出现的次数求和
5
>>> str1.items()
[('c', 2), ('b', 1), ('d', 2)] #把key,value转化为列表

四、有序字典

collections继承dict类,字典是有序的

>>> import collections  #导入模块
>>> dict1=collections.OrderedDict() #使用这个方法创建有序字典
>>> dict1['k1']='v1' 
>>> dict1['k2']='v2'
>>> dict1['k3']='v3'
>>> print(dict1)  　　　　　　　　　　#可以看到字典是有序的
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
>>> dict1.move_to_end('k1')　　　　 #把指定的键值放到最后
>>> print(dict1)
OrderedDict([('k2', 'v2'), ('k3', 'v3'), ('k1', 'v1')])
>>> print(dict1.popitem())　　　　  #删除字典最后面的键值,有返回值
('k1', 'v1')
>>> print(dict1)
OrderedDict([('k2', 'v2'), ('k3', 'v3')])
>>>

 五、默认字典

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

import collections
list1=[11,22,33,44,55,66,77,88,99]
new_dict=collections.defaultdict(list)#设置字典的value数据类型为列表
for i in list1:
    if i>66:
        new_dict['k1'].append(i)
    else:
        new_dict['k2'].append(i)
print(new_dict.items())
dict_items([('k2', [11, 22, 33, 44, 55, 66]), ('k1', [77, 88, 99])])

六、可命名元祖

>>> import collections 

>>> test_tuple=collections.namedtuple('test_tuple',['a','b','c'])
>>> obj=test_tuple(11,22,33)
>>> print(obj.a)
11
>>> print(obj.b)
22
>>> print(obj.c)
33

七、字典的深浅拷贝的区别

#1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。 
#2. copy.deepcopy 深拷贝 拷贝对象及其子对象 
#3.赋值，全部对象的引用



import  copy
a=[11,22,33,['a','b']]  #原始对象
b=a                     #赋值,引用对象
c=copy.copy(a)          #浅拷贝
d=copy.deepcopy(a)      #深拷贝
a[3].append('c')
a.append(44)

print('b=',b)           #对象的全部引用,所以值完全相同
print('c=',c)           #浅拷贝，只拷贝第一层，从第二层开始的元素都是引用的原始对象
print('d=',d)           #深拷贝的元素都是全新的对象,不会因为原始对象而改变

  b= [11, 22, 33, ['a', 'b', 'c'], 44]  #赋值,与对象a的值完全一样
  c= [11, 22, 33, ['a', 'b', 'c']]　　　 #浅拷贝,第二层的元素与对象a的值完全一样
  d= [11, 22, 33, ['a', 'b']]　　　　　　 #深拷贝,值没有变化

 八、file模块

打开文件的模式:

• r:只读
• w:只写，如果文件之前内容会被覆盖
• a:追加，往文件末尾追加

"+"表示可以同时读写某个文件：

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

文件操作：

fs=open('c:\\123.txt','w')    #打开文件123.txt,如果没有则创建
fs.write('hello,world')       #写入数据
#fs.writelines(str1)          #将一个字符串列表写入文件
fs.flush()                    #把内存中的数据刷新到硬盘
fs.close()                    #关闭文件句柄


fs=open('c:\\123.txt','r+')   #写读模式打开文件
data=fs.read()                #读取内容

#data=fs.readline()           #仅读取一行数据

#data=fs.readlines()          #读取所有内容根据换行符保持为列表
#data=fs.xreadlines()         #逐行读取文件

print(data)
fs.close()


fs=open('c:\\123.txt','a+')
fs.seek(5)                   #指定文件中指针位置
fs.tell()                    #获取当前文件中指针位置
fs.truncate()                #截取文件开头到当前指针位置的内容
fs.close()
            
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
 with open('test.log','r') as f:

 九、函数

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 函数式编程最重要的是增强代码的重用性和可读性

函数的定义和使用

def 函数名(参数):

      ...

      函数体

      ...　　

 下来来定义一个简单的函数：

def main(n):
    n+=1
    return n
result=(main(10))
print(result)

函数的有三中不同的参数：

• 普通参数
• 默认参数
• 动态参数

#传普通参数
def main(name):
    return name
result=main('xym')
print(result)


#默认参数
def main(name,age=18):
    return "%s %d"%(name,age)
result=main('xym')
result=main('xym',20) #默认参数需要放在参数列表最后

print(result)

#动态参数一：传列表
def func1(*li):
    print(li)

#执行方式一
func1([1,2,3,4,5])
#执行方式二
li=[1,2,3,4,5]
func1(*li)

#动态参数二：传字典
def func2(**args):
    print(args['x']+args['y'])
li={'x':1,'y':2}
func2(**li)

def func(*args, **kwargs):
    print args
    print kwargs



#发邮件实例:

import smtplib
def mail()
    flag=True
    try:
        from email.mime.text import MIMEText
        from email.utils import formataddr
        msg = MIMEText('邮件内容', 'plain', 'utf-8')
        msg['From'] = formataddr(["xym",'xxxx@126.com'])
        msg['To'] = formataddr(["xx",'xxx@qq.com'])
        msg['Subject'] = "主题"
        server = smtplib.SMTP("smtp.126.com", 25)
        server.login("xxxxy@126.com", "邮箱密码")
        server.sendmail('xxxx@126.com', ['xxxxx@qq.com',], msg.as_string())
        flag=True
    except Exception:
        flag=False
    server.quit()

mail()

if flag:
    print('send mail ok')
else:
    print('send mail faild')

 十、lambda表达式

#lambda表达式不支持if条件的运算
myfunc=lambda x:x+1
print(myfunc(5))

>>> list(map(lambda x:x+1,range(10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> [x for x in range(5) if x %2 ==0]
[0, 2, 4]

>>> list(filter((lambda x:x%2==0),range(5)))
[0, 2, 4]

>>> [x ** 2 for x in range(10) if x %2==0]
[0, 4, 16, 36, 64]

>>> list(map((lambda x:x**2),filter((lambda x:x%2==0),range(10))))
[0, 4, 16, 36, 64]

>>> list(map((lambda line:line.strip()),open('c:\haproxy.cfg')))

十一、内置函数

print(abs(-1))#返回绝对值,把负数转为正数
print(all([-1,3]))#如果所有元素为真返回True,如果其中只要有一个为假返回False
print(bool(''))# "",[],{},None 都是False,其他为True
print(any(["",[],{},None,123]))#只要有一个元素为真就返回True
print(bin(5))#二进制
abc='123'
callable(abc)#不可执行,返回为False
callable(type)#可执行，返回为True
str1=ord('a')#转换为编码
print(chr(str1))#解码
dir(type)#返回keys
divmod(9,2)#返回商和余数

system_type=['windows','linux','unix']
for i,item in enumerate(system_type,1):
    print(i,item)
#显示序列+元素
print(eval('3*5'))#支持字符串计算

# li=[1,2,3,4,5]
# new_list=map(lambda x:x+20,li) #map(函数,参数)
# print(list(new_list))
float(3)#转为浮点数
format(5)#数字转字符




def fun1(n):
    if n>5:
        return True
    else:
        return False
li=[10,20,5,30]
nums=filter(fun1,li) #filter(函数,参数)  支持条件过滤
print(list(nums))



print(hex(20))#0x 16进制
max(2,6)#返回最大值
min(1,8)#返回最小值