python---基础补给

近来懒惰，身体和心情都不是最佳，所以偷了很久的懒~，山竹过后的广州，大家都在努力，生活在继续，所以不如多吸食一会儿python，比你优秀的人还在努力，这就是义无反顾向前的动力，今天将python的数据类型做了一部分整理，发现脑阔是真的属于不用会生锈系列，一起再啃一遍儿吧。。。

一、数据类型：

我们在python 里接触到的数据类型有string,int,float,bool,byte,list,set,dict,tuple,collections.iterator,colooections.iterable 等 ，我能想到的大概就是这些了，一一来做复习吧。

1-str:常用到的内置函数有：ord--获取ASCII字符的值；chr--根据ASCII 码值获得对应的字符

举例：随机产生n位由数字和字母组成的验证码

import random

def randomStr(startChar,endChar):
    return chr(random.randint(ord(startChar),ord(endChar))

def newverifycode(len):
    vcode = []
    for i in range(len):
        s_ =raandom.randint(1,3)
        chars = ('0','9') if s_ == 1 else ('A','Z') if s_ ==2 else ('a','z')
        vcode.append(randomStr(*chars))
    return ''.join(vcode)
print(newverifycode(4))

2-int:整型，相关的进制转换有：bin;oct;hex

举例：

int('100',base=2)-->2进制的100，输出为4

int('0x16,base=16)-->16进制的16，输出为22

int('0b10',2)-->2进制的10，输出为2

bin(10)-->将10转成2进制，输出为1010

oct(100)-->100转成8进制，输出为0o144

hex(1900)-->16进制转化，输出为0x76c

3-float:浮点型，在这里不做过多追究，常用的几点记得就好。

4-bool：布尔型

常见的字符是False的有：空列表，空元组，空字典，空集合，None,空‘’

举例：

    a = (3>2 and True)+1 输出结果为2，若是只执行3>2,则返回True

any() 和all()的区别

常见按位运算符：按位与或非，异或。

    按位与：& 同时为1才为1，否则为0，

    按位或：| 有一个真则为真

    非（按位取反）：—

   按位异或：^ 两者相同都为0时，反之为1

 

5-byte:字节

使用场景：IO操作（文件及网络读写及管道Pipe）和编码解码。

文件读写模式：rb,r+,wb,w+,a,a+,read(),write()

网络读写：socket.send(),socket.recv() #发送，接收

举例：b'abc'

字符串转成字节：''.encode('utf-8')

字节转成字符串：b.decode('utf-8')

6-list:列表

常见使用：append,pop,remove,extend(合并),sort,count,copy,

空列表不可以作为函数参数的默认值，不然会是的期望输出值产生错误。

copy:copy.copy以及copy.deepcopy,两者区别：

浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间;

深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

列表推导式：print([i for i in range(10)]),输出结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

举例：

一行代码同级列表的偶数+3的所有和。

al = [1,2,3,4,5,6]
print(sum([i for i in al if i%2==0 ]))

一行代码转成列表

al = [[1,2],[3.4],[5,6]]
print([i for item in al for i in item])

7-set:集合

举例：给定字符串，快速去重

s = 'abcdeabc'
''.join(list(set(s)))

8-dict:字典

常见：keys,values,items,pop(key),popitem,update({}),setdefault(key,value),clear

可以作为key的类型：str,int,tuple

字典生成式：{key:value for key in range(20) for value in range (20,41)}

举例：

一行代码实现字典的key,value互换

d = {'name':'xianyu','age':'10'}
d1 = {value:key for key ,value in d.items()}
print(d1)

删除字典的key

del d['key']
value = d.pop('key')

合并两个字典

d1.update(d2)

 

9-tuple:元组，使用中括号

10-collections.Iterator:

迭代器：访问集合元素的一种方式，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问结束，他只能往前，不能后退。

# iter()或重写对象的__iter__()函数
# net到左后可能会抛出StopIteration 异常

next():生成器（最常用fib）yield和range

def fib(n):
    index = 0
    a,b = 0,1
    while index < n :
        yield b #将函数转成生成器
        a,b = b,a+b

注意，在一直next(),到最后的时候可能会抛出StopIteration异常。

 

11-collection.Iterable：可迭代对象

      常见类型：str,list,tuple,set,dict,generator,Iterator

二、函数设计

主要分为：包，功能，封装参数，高阶函数，回调函数，装饰函数，生成器函数

包：根据功能函数，__init__.py（单例模式）

功能：根据业务需求而定

封装函数：普通参数，不定长参数*args(是元组),关键字参数**kwargs（是字典）

*args 和**kwargs 的区别：

在函数调用中使用”*”，我们需要元组;在函数调用中使用”**”，我们需要一个字典

*args传入的参数不需要赋值命名,并且构成元组类型的结构，我们称这种参数为元组参数

**kwargs需要以命名关键字的实参作为传入，且构成字典类型的结构，并且可用key关键字值找到对应的参数内容，我们称这种参数为字典参数

高阶函数：map;filter;reduce;lambda表达式

回调函数：在异步任务中使用（任务在执行的时间未知，在任务完成后，可以由回调函数机制，将数据回传给调用方法）

# 回调函数的应用(threading模块和urllib模块)
from urllib import request
from threading import Thread, current_thread
from uuid import uuid4

def save(url, data):
    print('--save--', url)
    # 保存文件中
    
    with open(str(uuid4()).replace('-', '')+'.html', 'wb') as f:
        f.write(data)
        
    print(current_thread().name, '--线程完成任务---')
    

def download(url, callback=None):
    resp = request.urlopen(url)
    print(url, '--请求成功--')
    callback(url, resp.read())
    

def main():
    url = 'http://www.baidu.com'
    # 异步处理
    Thread(target=download, args=(url, save)).start()  # 创建线程并启动
    
    print('--主线程完成任务---')
    
main()
---------------------------------------------------------------------------------
#结果：
--主线程完成任务---
http://www.baidu.com --请求成功--
--save-- http://www.baidu.com
Thread-13 --线程完成任务---

装饰函数：普通装饰函数及装饰器类与__call__

具有__call__的对象为可调用对象，函数是可调用对象，但可调用对象不一定阿哥势函数。

import time

# 装饰函数（有参、无参）
# 实现一个运行时间的装饰函数（无参）
def runtime(func):
    print('---需要返回包装函数---')
    def wrapper(*args, **kwargs):
        print('--开始执行闭包函数--')
        # 执行函数前，开始计时
        start_time = time.time()
        result = func(*args,**kwargs)
        
        # 计算func函数对象运行的时间
        used_seconds = round(time.time()-start_time,4)  # 四舍五入，取4位小数部分
        
        print(func.__name__, '用时: %f 秒' % used_seconds )
        
        return result
    return wrapper  # 返回包装函数

@runtime
def get(url):
    download(url, save)
    
get('http://www.hao123.com')

装饰器类：带参和不带参

 

user_right = 7
# 装饰器类(有参、 无参)
class QXWrapper:  
    def __init__(self,func):
        self.func = func
        
    def __call__(self, *args, **kwargs):
        # 判断当前用户是否具有查询是查询
        if user_right & 8 == 8:
            result = self.func(*args, **kwargs)
            return result
        else:
            print('--当前用户没有查询权限-')
            

class QX_CHECK:  
    def __init__(self, qxName):
        self.qxName = qxName
        
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            # 判断当前用户是否具有查询是查询
            right = rights.get(self.qxName)
            if right:
                if user_right & right == right:
                    result = func(*args, **kwargs)
                    return result
                else:
                    print('--当前用户没有 %s -' % self.qxName)
            else:
                print('---%s 权限是不存在 ---' % self.qxName )
        return wrapper
    

@QX_CHECK('DELETE')  # 装饰类（有参）
def deleteOrder(order_number):
    print('正在删除订单号：', order_number)

deleteOrder(101)    

生成器函数：generator

前面已经做过介绍，利用range和yield

yield:产出或接受，必须先next()