数据分析 NO.9 python进阶深入

python进阶深入
1.生成器：创建生成器最简单的方法就是用圆括号()代替方括号 []
把列表生成式的 [ ] 变成（）
生成器只能调用一次，不占用资源。用完就释放出来。

for i in g:
   print(i)

也可以调用Next函数直到计算出最后一个元素位置,但是这种方法很明显不适用，并且最后会抛出StopIteration的错误。

斐波那契数列：除第一个和第二个数外，任意一个数都可由前两个数相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, …
return返回的是具体的数值
yield返回的是一个生成器
递归的思路代码：

def fib(n_position):
    if n_position == 1 or n_position ==2:
        return 1
    return fib(n_position - 1 ) + fib(n_position -2)

2.迭代器：
可用于for循环的对象统称为可迭代对象：Iterable。包括之前学的list,tuple等数据结构以及生成器。 但是生成器不仅可以被for循环调用， 还可以使用next函数获取元素，可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator

isinstance（g,Iterator） 判断g 是不是后面类似返回True or False

3.装饰器：
用于拓展原来函数功能的一种函数，目的是在不改变原函数名(或类名)的情况下，给函数增加新的功能。
这个函数的特殊之处在于它的返回值也是一个函数，这个函数是内嵌“原“”函数的函数。

import time
def timer(f):
    def wrapper():
        start = time.time()
        f(x)
        end = time.time()
        last_time = end -start
        print("持续了%s"%last_time)
    return wrapper

@timer
def yanchi(x):
    print("开始休息")
    time.sleep(x)
    print("休息完毕")

这里的timer函数就是最原始的装饰器，它的参数是一个函数，然后返回值也是一个函数。
其中作为参数的这个函数f(x)就在返回函数wrapper()的内部执行。然后在函数f(x)前面加上@timer,
yanchi()函数就相当于被注入了计时功能，现在只要调用yanchi()，它就已经变身为“新的功能更多”的函数了,
（不需要重复执行原函数）。

无固定参数的装饰器：

import time

def deco(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        execution_time_ = (end_time - start_time)*1000
        print("time is %d ms" %execution_time)
    return wrapper


@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))

@deco
def f2(a,b,c):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b+c))


if __name__ == '__main__':
    f2(3,4,5)
    f(3,4)

装饰器是可以叠加的，多个装饰器装饰一个函数，其装饰器的调用顺序与使用 @ 语法糖声明的顺序相反。

4.函数式编程
高阶函数：
函数名也是变量，
既然变量可以指向函数，函数可以接受变量，那么一个函数就可以接受另一个函数作为传入参数,拿来使用

def add(x,y,z):
    return z(x) + z(y)
add([1,2,3,4],[4,3,1,5,6],len)

5.map/reduce
map接受两个参数，一个是函数，一个是Iterable，函数作用在序列的每一个元素上，并把结果作为Iterable返回

x=[1,2,3,4,5,6,7,8,9,10]
map(lambda s:s*s，x)
list（map(lambda s:s*s，x)）

reduce也是把函数作用与序列上，但是这个函数必须接受两个参数，reduce把计算结果继续与下一个元素做累积计算

from functools import reduce
reduce(lambda a,b:a*b,x)

6.filter函数：
filter也是把函数作用在序列元素上，但是该函数返回的结果必须是布尔型，filter根据true或者false进行元素的保留和删除

x = [1,3,6,7,2,19,20,33,29,10,49]
list(filter(lambda s : s%2 ==0,x))

7.匿名函数 Lambda

f=lambda s:s*2
x=[1,2,3,4]
map(f,x)

f=lambda a,b:(a+b)*2 
x=[1,2,3]
y=[2,3,4]
list(map(f,x,y))

8.面向对象
类里面一般包含属性和方法，你可以简单理解为属性为静态，方法是动态的。比如人(PERSON)这个类，嘴、手、腿就是类的属性，跑步、吃饭等就是累的方法。

我们可以把在创建实例时我们认为必须绑定的属性强制填写进去，这里通过 init 方法完成。init 方法的第一个参数永远是self,代表了实例本身。有了该方法之后，在创建的实例的时候必须强制指定属性值，否则会报错。该方法也可以理解为初始化的一个动作，在创建实例的时候初始化该实例的一些属性！
前后都是两个下划线
下面的S是的大写，如果是多个单词组合，每个单词第一个字母大写（编写规范）

class Student:
     def __init__(self,student_id,address,score):
           self.staudent_id = staudent_id 
           self.address = address
           self.score = score
           self.name = student_name
           self.gender = "female"
    def getId(self):
          print(self.student_id)
   #创建实例
  student = Student(1020202,"北京",98,"xiaoming")  
  必须把（）里面参数填满  

class Student:
    
    kind = "Chinese" # Shared by all instances
    
    def __init__(self,id,address,score):
        self.id = id 
        self.address = address
        self.score = score
    
    def getId(self):
        print(self.id)
        print(self.kind)
        
    def judge_age(self,age):
        if age < 18:
            return "未成年"
        elif age < 30:
            print("Student: {0}".format(self.id))
            return "年轻人"
        elif age < 60:
            return "中年人"
        else:
            return "老年人"
        
S1 = Student(12324,"上海市",100)
S2 =  Student(3245,"上海市",90)
# print(S1.kind)
# S1.judge_age(22)

上述程序中，kind是被所有的实例共享，只要是实例拥有的都要用self一下。

调用属性和方法都是通过 .

继承和多态：
面向对象编程语言连都会有继承的概念，我们可以定义一个class类，然后再定义它的子类,这个子类继承了上面的类，被继承的类称作父类

class HighSchool(Student):
    pass

Highschool类集成了Student类，student类就是父类。
继承的好处就是子类可以享用父类的全部方法和属性。虽然HighSchool什么也没定义，但是可以直接使用Student的方法

子类也可以由自己的初始化方法，一定要用 super().init(name, id) 去初始化父类
函数super()将返回当前类继承的父类，即 Student ，然后调用init()方法

class Student():
    
    def __init__(self,name,id):
        self.name = name
        self.id = id
    
    def student(self):
        print("Student score!")
        
    def get_name_id(self):
        print(self.name +":" +self.id)


class HighSchool(Student):
    
    def __init__(self,name,id,score):
        super().__init__(name,id)
        self.score=score
    pass

如果在父类和子类的方法重复了，会首先使用我子类自己的方法
大佬博客可参考：链接

9.Collections类
9.1 deque：
deque 和list的用法比较类似，它是队列与栈的实现，可以对序列数据进行两端的操作。deque支持在O(1)的时间复杂度上对序列进行两端的append或者pop。list也可以实现同样的操作，但是它的复杂度是O(N)
O（N）复杂度

# 类似于列表实现
from collections import deque
a = deque(['a','b','c','d'])

a.append("e")
# a
a.pop()

# 两端操作
#a.popleft()
a.appendleft("a")
#反转
a.rotate()

对首端进行操作的话，用deque_a.appendleft("a")

9.2 counter

from collections import Counter
a = list('absgctsgabfxtdrafabstxrsg')
c = Counter(a)

# 查看TOPN的元素
c.most_common(5)

关于OrderedDict
本身不是对key或者value的大小进行排序，而是对存储的时候，人为定义好的插入的顺序进行保存。

from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))


# # dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))


# # dictionary sorted by length of the key string
OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))

od = OrderedDict(sorted(d.items(), key=lambda t: t[0]))

t[0]:key
t[1]:value

od.popitem(last = False)
False 去掉左端第一个，是True的话就是末尾

10.字符串处理
s.strip() 去掉首位两端的空格 延伸：.lstrip(),.rstrip()
s.find() s.find(“e”)返回e的索引位置，如果没有就会返回-1
s.find(“H”,1) 后面的1是启始位置，其实只要找的到了，是不影响索引位置。
s.startwith(“H”,1) 判断后面的索引位置开始的首字母是否是"H"，返回True or False
s.endwith()
s.lower()
s.upper()

s.split(“,”) 切割，返回的一个列表。

map(lambda t : t.strip()   ,  s.strip().upper().split(","))

11.格式化

for i in range(100):
    t = str(i)      
    print("这是我打印的第 %s 个数字"%t)

a = 'chengdu'
b = '35℃'
print("%s的温度是%s"%(a,b))

下面这个看起来更简洁

a = "shanghai"
b = 39

print("今天 {0} 的气温是 {1}".format(a,b))     根据索引的位置选

python 3.6版本后可以用：
f’名字是：{a}，温度是：{b}’

print(f"{a}的温度是{b}")

city = input("选择你所在的城市")
temp = input("输入平均的温度")
print(f"{city}的平均温度是{temp}℃".format(city,temp))

数字的精度输出：自我感觉就像C语言的float类型的输出

>>> '{:.4f}'.format(1/3)
'0.3333'
>>> '{:4f}'.format(100)
'100.000000'

数字的进制输出

'18的二进制：{:b}'.format(18)
'18的二进制：10010'
>>> '18的八进制：{:o}'.format(18)
'18的八进制：22'
>>> '18的十六进制：{:x}'.format(18)
'18的十六进制：12'

"{:02x}".format(20) #16进制选择2位，不足两位前面补0

12.datetime

from datetime import datetime
print(datetime.now())

strptime(,)

# 字符串与时间的转换
s = '20170901'
s1 = datetime.strptime(s,'%Y%m%d')

s = "2019/05/03"
s2 = datetime.strptime(s,'%Y/%m/%d')

返回结果：

strftime(“%Y-%m-%d-%H”)
#将时间格式转化为字符串

timedelta
** timedelta **

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

from datetime import datetime.timedelta
s2 - s1

返回结果是609天，datetime用作减可以直接减

加的话是

s2+timedelta(3)

减可以是

s2-timedelta(3)  或 s2+timedelta(-3)

s2  + timedelta(hours = 10) + timedelta(weeks = 1)

s1.date() 只获取到日的节点

from datetime import datetime
s="2019-5-9"
s_test=datetime.strptime(s,"%Y-%m-%d")
s_test.day

13. I/O
    读文件需要使用 open()函数，其参数为文件名与标识符：

f = open("file",'r')
data = f.read()
f.close()

读了文件一定要关闭文件。
可以使用with关键词进行整合：

with open("helloWorld.py",'r') as handle:
    data = handle.readlines()

read(）所有数据读取进来
readlines(）一行一行读出来，

list(map(lambda s : s.strip(),data))

编码问题：添加encoding=

f = open("file",'r',encoding = 'gbk') # utf-8

数据写入：
写文件和读文件几乎一致，唯一的区别是标识符需要改为"w"。
第一个实参也是要打开的文件的名称； 第二个实参（‘w’）告诉Python，我们要以写入模式打开这个文件。打开文件时，可指定读取模 式（‘r’）、 写入模式（‘w’）、 **附加模式（‘a’）**或让你能够读取和写入文件的模式（‘r+’）。如果 你省略了模式实参， Python将以默认的只读模式打开文件

with open("test2.txt",'w') as handle:
    handle.write("hello world")

如果你要写入的文件不存在，函数open()将自动创建它。然而，以写入（‘w’）模式打开文 件时千万要小心，因为如果指定的文件已经存在， Python将在返回文件对象前清空该文件。

with open("test.txt",'a') as handle:
    handle.write("Today is Nice!\n")
    handle.write("We are happy!!\n")

如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式 打开文件时， Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。 如果指定的文件不存在， Python将为你创建一个空文件。

要写入多行的话。需要自己添加换号符 “\n”

动态执行代码的方法：参考于添加链接描述
核心在于 exec() 方法，它是内置的，用途是执行储存在字符串或文件中的代码段

>>> list1 = ['A', 'B', 'C', 'D']
>>> for i in list1:
>>>     exec(f"{i} = []")
>>> A

14.ZIP()函数
一.zip()函数的定义:
从参数中的多个迭代器取元素组合成一个新的迭代器
返回：一个zip对象，其内部元素为元组；可以转化成列表或元组
传入参数：元组、列表、字典等迭代器
二.zip()的用法
（1）当zip()函数中只有一个参数时，zip(iterable)从迭代器中依次取一个元组，组成一个元组。

# python 3
# zip()函数单个参数
In [1]: list1 = [1, 2, 3, 4]
In [2]: tuple1 = zip(list1)
In [3]: type(tuple1)
Out[3]: zip
In [4]: list(tuple1)
Out[4]: [(1,), (2,), (3,), (4,)]

（2）0当zip()函数有两个参数时，zip(a,b)函数分别从a和b中取一个元素组成元组，再次将组成的元组组合成一个新的迭代器。a与b的维数相同时，正常组合对应位置的元素。当a与b行或列数不同时，取两者中的最小的行列数。

# zip()函数有两个参数
In [5]: m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [6]: n = [[1, 1, 1], [2, 2, 3], [3, 3, 3]]
In [7]: p = [[1, 1, 1], [2, 2, 2]]
In [8]: list(zip(m,n))
Out[8]: [([1, 2, 3], [1, 1, 1]), ([4, 5, 6], [2, 2, 3]), ([7, 8, 9], [3, 3, 3])]
In [9]: list(zip(m,p))
Out[9]: [([1, 2, 3], [1, 1, 1]), ([4, 5, 6], [2, 2, 2])]

三.zip(iterables)函数
zip()函数是zip()函数的逆过程，将zip对象变成原先组合前的数据

In [24]: m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [25]: n = [[1, 1, 1], [2, 2, 3], [3, 3, 3]]
In [26]: print(*zip(m, n))
([1, 2, 3], [1, 1, 1]) ([4, 5, 6], [2, 2, 3]) ([7, 8, 9], [3, 3, 3])
In [27]: m2, n2 = zip(*zip(m,n))
In [28]: m == list(m2) and n == list(n2)
Out[28]: True

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]