Python—day3

1、字符串在C里边就是字符数组

　　Python里边一切事物都是对象，对象则是类创建的

　　

 2、set集合

　　set是一个无序且不能重复的元素集合

　　#!/usr/bin/env python
# encoding: utf-8
#set对象不能有重复
s1 = set()
s1.add('alex')
print(s1)
s1.add('alex')
print(s1)
s1.add('shidong')
print(s1)
s1.clear()
print(s1)

s2 = set(['shi','shidong','sd','shi'])
print(s2)

结果：

{'alex'}
{'alex'}
{'shidong', 'alex'}
set()
{'shi', 'shidong', 'sd'

 

　　set中可以有添加列表

s2 = set(['shi','shidong','sd','shi'])
print(s2)

difference函数生成新的集合

s2 = set(['shi','shidong','sd','shi'])

s3 = s2.difference('shi','shidong')

print(s3)

结果：

{'sd'}

 

#def:difference_update ，删除传入参数，并改变原来的set()集合，
#但是s2.difference_update 集合并没有内容
s2 = set(['shi','shidong','sd','shi'])
s4 = s2.difference_update(['shidong','sd'])
print(s2)
print(s4)
#discard  移除元素  intersection  取交集，新创建一个set
#symmetric_difference()   取到两个集合的差集，遍历两个集合，把两个集合的差集合并成一个集合
#isdisjoint  如果没有交集返回True
#issubset  是否是子集
#issuperset 是否是父集
#remove   只移除元素，需要加参数，并且没有返回值
#pop    移除一个元素，也可以把移除的元素赋值到新的集合中
s2 = set(['shi','shidong','sd','shi'])
ret = s2.pop()
print(s2)
print(ret)

3、collections系列

 一、计数器（counter）

　　Counter 是对字典类型的补充，用于追踪值的出现次数

　　ps:具备字典的所有功能 + 自己的功能

1、c = Counter('abcdfasdfdsfa')

2、print c

3、输出： Counter({'a':5, 'b':4,'c':3,'d':2,'e':1})

　　　Counter方法：查找对象的前几位：

　　　　例如：

　　　　#!/usr/bin/env python
　　　　# encoding: utf-8
　　　　import collections
　　　　obj = collections.Counter('shidong')
　　　　ret = obj.most_common(4)      #most_common ：显示对象的前四位
　　　　print(ret)

　　　　#elements 方法：用来循环对象中的内容
for item in obj.elements():
print(item)
#循环并取出对象中的健值以及values
for k,v in obj.items():
print((k,v))

#update 方法：增加元素
obj = collections.Counter(['11','22','22','33'])
print(obj)
obj.update(['eric','11','11'])
print(obj)
#删除元素substract()
obj.subtract(['eric','11'])
print(obj)

 

二、有序字典（orderedDict）

orderdDict是对字典类型的补充，他记住了字典元素添加的顺序

　　#有序字典OrderedDict()
dic = collections.OrderedDict()
dic['k1'] = 'v1'
dic['k2'] = 'v2'
dic['k3'] = 'v3'
print(dic)

#把某个键跟值拿到最后
dic.move_to_end('k2')
print(dic)

#按照顺序拿:拿最后一个健值，按照后进先出执行：popitem()
dic.popitem()
print(dic)
#自己指定去拿那个pop(),而且能够返回值
dic.pop('k1')
print(dic)
ret = dic.pop('k3')
print(ret)

#setdefault 设置默认值
#update()方法,不存在则增加值，存在则更改值
#字典默认输出的时候只输出key
dic.update({'k1':'v111','k2':'v10','k3':'22'})
print(dic)

 

三、默认字典（defaultdict）

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

 四、队列（deque）

#!/usr/bin/env python
# encoding: utf-8
#Python提供了两种队列：一种是双向队列一种是单项队列（先进先出FIFO）
#栈就相当于弹匣，后进先出
import collections
d = collections.deque()
d.append('1')
#在左侧插入
d.appendleft('10')
d.appendleft('1')
d.appendleft('5')
print(d)
#查看某个元素的个数count方法
print(d.count('1'))
#扩展extend(向右侧扩展)
d.extend(['yy','uu','ii'])
print(d)
#扩展extendleft（像左侧扩展）
d.extendleft(['shi','dong'])
print(d)
#删除某个值remove
d.remove('shi')
print(d)
#反转reverse
d.reverse()
print(d)
#rotate(英文意思：旋转，轮换，使轮流)，功能：做到首尾连接
#最后一个元素能够连接到第一个元素,从右边的数据拿到左边轮
#插入
d.rotate()
print(d)
d.rotate(3)
print(d)

五、拷贝 ——深浅拷贝
数字、字符串用的是同样的内存地址，复制操作不会改变内存地址
其余拷贝会改变内存地址，，浅拷贝只拷贝第一次，不会拷贝多层，
深拷贝会全部拷贝。

六、单项队列（先进先出）
#单项队列在queue模块中
import queue
#创建单项队列
q = queue.Queue()
#往里边插入一条数据
#qsize()方法：拿到队列的个数
q.put('shi')
q.put('123')
print(q.qsize())
#从里边拿数据
print(q.get())

七、函数
在学习函数之前，一直遵循：面向对象编程，即：根据业务逻辑从上到下实现功能，其往往用一段代码来实现指定功能，
开发过程中最常用的功能就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：
　　while True:
　　　　if cpu利用率 > 90%:
　　　　　　#发送邮件提醒
　　　　　　连接 邮件服务器
　　　　　　发送邮件
　　　　　　关闭连接
　　　　　if 硬盘使用空间 > 90%
　　　　　　#发送邮件提醒
　　　　　　连接邮件
　　　　　　关闭连接
　　　　　　if 内存占用 > 80%
　　　　　　#发送邮件提醒
　　　　　　连接邮件
　　　　　　关闭连接
　　定义函数：
　　def name():
try方法：(首先执行try方法中的代码，如果代码错误则执行except中的代码)
try:
　　...
except Exception:
　　...

函数发送邮件示例：

#!/usr/bin/env python
# encoding: utf-8
#函数：自定义函数 函数格式
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail():
    ret = 123
    try:
        msg = MIMEText('收到即为成功','plain','utf-8')
        msg['From'] = formataddr(["史冬",'sd880413@sina.cn'])
        msg['To'] = formataddr(["sd", '980653381@qq.com'])
        msg['Subject'] = "测试函数邮件"

        server = smtplib.SMTP("smtp.sina.cn",25)
        server.login("sd880413@sina.cn","shidong00")
        server.sendmail('sd880413@sina.cn',['980653381@qq.com',],msg.as_string())
        server.quit()
    except Exception:
        ret = 456
    return ret

ret = mail()

if ret:
    print("发送成功！！")
else:
    print("发送失败！！")


如果一个函数中没有return，那么函数会返回None
return放在函数和方法中，一遇到return值，那么return后的代码则不会执行：return——1、中断函数操作2、返回函数值

#!/usr/bin/env python
# encoding: utf-8
#无参数
#show():  -->show()

# 一个参数
# def show(arg):
#     print(arg)
# show('kkkk')

#两个参数
# def show(arg,xxx):
#     print(arg,xxx)
# show('kkkk','777')
#默认参数,给形参加上一个数值，如果在调用的时候不指定参数，那么就会返回
#形参的指定值,默认参数必须放在最后。
# def show(a1,a2=888):
#     print(a1,a2)
# show(33)
# show(22,44)

#指定参数：
# def show(a1,a2):
#     print(a1,a2)
# show(a2=23,a1=111)

#动态参数：参数也可以是列表，一颗星代表把所有的参数自动转换成一个元组
#两个星代表把传入的所有参数全都转换成一个字典
#一颗星：
# def show(*arg):
#     print(arg,type(arg))
# show(1,2,3,3,4,5,7,)

#两颗星
# def show(**arg):
#     print(arg,type(arg))
# show(a1=88,uu=213)

#一星、两星共用
def show(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))
show(1,2,3,3,2,111,n=2,a=5)
结果：
(1, 2, 3, 3, 2, 111) <class 'tuple'>
{'a': 5, 'n': 2} <class 'dict'>

示例：
  #一星、两星共用
def show(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))
#show(1,2,3,3,2,111,n=2,a=5)
l = [11,22,33,44]
d = {'n1':88,'alex':'sb'}
#如果直接添加参数，那么可能会被系统默认为是元组或者列表，
#字典也会加入到一星的动态参数中，如果想要对应加入，如：字典要
#放到两星参数中，则采用如下方法
show(*l,**d)
结果：
(11, 22, 33, 44) <class 'tuple'>
{'n1': 88, 'alex': 'sb'} <class 'dict'>

 使用动态参数实现字符串格式化：

#字符串格式化，并传入动态参数
s1 = "{0} is the best {1}"
resul = s1.format('shidong','man')
print(resul)

结果：
shidong is the best man

或者 如：

#字符串格式化，并传入动态参数
s1 = "{0} is the best {1}"
l1 = ['shidong','winner']
#resul = s1.format('shidong','man')
resul = s1.format(*l1)
print(resul)

结果：
shidong is the best winner

或者 如：

s1 = "{name} is {acter}"
result = s1.format(name = 'shidong',acter = 'successful')
print(result)
结果：
shidong is successful
如果是参数是字典，需要加两星

s1 = "{name} is {acter}"
d = {'name':'shidong','acter':'successful'}
result = s1.format(**d)
print(result)
结果：
shidong is successful

八、lambda表达式：简单函数的简单表示

例如：
lambda表达式：
func = lambda a :a + 1
#创建形式参数a
#函数内容，a + 1 并把结果return
ret = func(98)
print(ret)
结果：
99

九、内置函数

这些内置函数不需要导入任何模块就能使用。

abs():绝对值：
a = -1
ret = abs(a)
print(ret)

all():判断元素，如果所有都为真才为真，如果为空或者None也为假
查看真假用bool
例如：

any():只要里边有真的就为真

ascii() :可以得到一个返回值

 ascii(8) 相当于int.__repr__()

bin():表示二进制

>>>bin(10)

‘0b1010’

bool():布尔

bytearray():把传入的字符串、列表转换成字节数组

一个汉字需要占用3个字节

ret = bytearray('史冬',encoding='utf-8')
print(ret)

结果：bytearray(b'xe5x8fxb2xe5x86xac')

 callable():函数 查看函数儿能否被调用，是否可执行

例如：

func = lambda a : a + 1
print(func(2))
print(callable(func))

结果：
3
True
chr()  和ord()  两个要经常一起用，一个是把数字转换成ASCII码，一个是把ASCII转换成数字

chr():把数字转换成字符，ord()把字符转换成数字
import random
a = random.randint(97,120)
b = chr(a)
print(a,b)

compile():编译用到的

enumerate():函数会添加一个序列用来记录序列，例如：

li = ["alex","shidong","xian"]
for i,item  in enumerate(li,1):
    print(i,item)
结果：
1 alex
2 shidong
3 xian
eval（）函数:可以用于计算Excel表格中的运算，例如：

a = eval('6*8')
print(a)

结果：
48

map：

map示例：map左边有多少然后经过条件后，右边相对应的过滤出来，例如：

li = [11,22,33,44,]
new_li = map(lambda x : x + 100,li)
l = list(new_li)
print(l)
结果：
[111, 122, 133, 144]

filter()函数：起到过滤作用

def func(x):
    if x > 33:
        return True
    else:
        return False

li = [11,22,33,44,]

ret = filter(func,li)
print(list(ret))

float()函数：把一个数转换成float类型
frozenset()函数：冻结集合
globals()函数：当前的全局变量
oct()函数：八进制
hex()函数：十六进制
例如：
hex(10)
结果：0xa

locals()函数：局部变量
max()函数：拿到最大值
例如：

print(max(11,22,3,34,534456345,))

结果：534456345
open()函数：打开文件
range()函数：拿到区间值
round()函数：四舍五入
zip()函数：两个对象的元素对应起来
例如：

x = [1,2,3,4,]
y = [2,3,4,5,]
ziped = zip(x,y)
wo = list(ziped)
print(wo)

结果：
[(1, 2), (2, 3), (3, 4), (4, 5)]

read():可以读取几个字节，例如：

#!/usr/bin/env python
# encoding: utf-8
f = open('test.log','r',encoding='utf-8')
#f.write('hello world!!!')
ret = f.read(2)
print(ret)
f.close()

readable():是否可读
readline():仅读取一行
seek():指定文件中指针位置
seekable():指针是否可操作
tell():获取指针位置  （）指的是字节）
例如：

#!/usr/bin/env python
# encoding: utf-8
f = open('test.log','r',encoding='utf-8')
#print(f.tell())
#ret = f.read(2)#按照字符来拿
#print(f.tell())#tell按照字节执行
f.seek(1)#让指针跳到哪儿
ret = f.read()#不加参数全部读出来，加参数指定读取字符
#print(f.tell())
f.close()
print(ret)

truncate()函数：读取指针前面的数，删除指针后面的数，然后保存源文件