12 on 中二青年

【Python】异常处理

Thu, 08 Aug 2019 00:00:00 +0000

Python异常处理 »>思维导图****> »博客园

什么是异常处理？

程序在运行过程中出现了不可预知的错误

并且该错误没有对应的处理机制，那么就会以异常的形式表现出来

造成的影响就是整个程序无法正常运行

异常的结构

1.异常的类型：NAMEERROR

2.异常的信息：name ‘abc’ is not defined

3.异常的位置：Traceback (most recent call last): File “路径”, line 1, in abc

异常的种类：

1.语法错误
是你程序立刻就能解决的，这种错误是不能被容忍的，语法上的错误，发现之后应该立刻解决

2.逻辑错误
这种错误是可以被容忍的，因为一眼看不出来，针对逻辑上的错误，可以采用异常处理机制进行捕获

常见的错误类型

NameError 名字错误

SyntaxError 语法错误

KeyError 健不存在

valueError 值错误

IndexError 索引错误

TypeError 类型错误

异常处理

在你认为可能出现bug的代码块上方try一下

try:
	可能出错的代码
except 出错的类型 as e:  # 将报错信息赋值给变量e
	出错之后的处理机制

注意try内部的代码块越少越好

try后可跟多种except异常类型的捕获，但是不会连续连续捕获，因为有一个错误发生之后，会立刻停止代码的运行，执行该类型错误的except语句

try:
    name
    l = [1,2,3]
    l[111]
    d = {'name':'jason'}
    d['password']
except NameError:
    print('NameError')
except IndexError:
    print('indexerror')
except KeyError:
    print('keyerror')

Exception 所有异常的基类，所有异常类型都被捕获

【Python】反射/元类

Tue, 30 Jul 2019 00:00:00 +0000

Python反射/元类) »>思维导图****> »博客园****

反射reflect

什么是反射, 其实是反省,自省的意思

反射指的是一个对象应该具备,可以检测,修改,增加自身属性的能力

反射就是通过字符串操作属性

涉及的四个函数,这四个函数就是普通的内置函数没有双下划綫,与print等等没有区别

hasattr  getattr setattr delattr 

p = Person("jack",18,"man")

# if hasattr(p,"name"): # 1.判断某个对象是否存在某个属性
#     print(getattr(p,"names",None)) # 2.从对象中取出属性,第三个值位默认值 当属性不存在是返回默认值

# 3.为对象添加新的属性
setattr(p,"id","123")
print(p.id)

# 4.从对象中删除属性
delattr(p,"id")
print(p.id)

使用场景:反射其实就是对属性的增删改查,但是如果直接使用内置的dict来操作,语法繁琐,不好理解

另外一个最主要的问题是,如果对象不是我自己写的是另一方提供的,我就必须判断这个对象是否满足的要求,也就是是否我需要的属性和方法

框架代码

"""
反射被称为框架的基石,为什么
因为框架的设计者,不可能提前知道你的对象到底是怎么设计的
所以你提供给框架的对象 必须通过判断验证之后才能正常使用
判断验证就是反射要做的事情,
当然通过__dict__也是可以实现的, 其实这些方法也就是对__dict__的操作进行了封装
需求:要实现一个用于处理用户的终端指令的小框架
框架就是已经实现了最基础的构架,就是所有项目都一样的部分
"""

import plugins

# 框架已经实现的部分
def run(plugin):
    while True:
        cmd = input("请输入指令:")
        if cmd == "exit":
            break
        # 因为无法确定框架使用者是否传入正确的对象所以需要使用反射来检测
        # 判断对象是否具备处理这个指令的方法
        if hasattr(plugin,cmd):
            # 取出对应方法方法
            func = getattr(plugin,cmd)
            func() # 执行方法处理指令
        else:
            print("该指令不受支持...")
    print("see you la la!")


# 创建一个插件对象 调用框架来使用它
# wincmd = plugins.WinCMD()
# 框架之外的部分就有自定义对象来完成
linux = plugins.LinuxCMD()
run(linux)

插件部分

【Python】多态

Mon, 29 Jul 2019 00:00:00 +0000

Python多态 »>思维导图****> »博客园********

多态

概念：一种事物具备多种不同的形态

例如：水“固态”、“液态”、“气态”

官方解释 ：多个不同类的对象可以响应同一个方法，产生不同的结果

首先强调多态不是一种特殊的语法，而是一种状态、特性(即多个不同对象可以响应同一个方法，产生不同结果)

好处：对于使用者而言，大大的降低了使用难度

实现多态 ：接口、抽象类、鸭子类型都可以写出具备多态的代码，最简单的就是鸭子类型

案例

"""
要管理 鸡 鸭 鹅
如何能够最方便的 管理,就是我说同一句话,他们都能理解
既它们拥有相同的方法

"""
class JI:
    def bark(self):
        print("哥哥哥")

    def spawn(self):
        print("下鸡蛋..")

class Duck:
    def bark(self):
        print("嘎嘎嘎")

    def spawn(self):
        print("下鸭蛋")

class E:
    def bark(self):
        print("饿饿饿....")

    def spawn(self):
        print("下鹅蛋..")

j = JI()
y = Duck()
e = E()

def mange(obj):
    obj.spawn()


mange(j)
mange(y)
mange(e)


# python中到处都有多态  
a = 10
b = "10"
c = [10]

print(type(a))
print(type(b))
print(type(c))

isinstance

【Python】封装

Sat, 27 Jul 2019 00:00:00 +0000

Python封装 »>思维导图****> »博客园****

封装

什么是封装？

就是将复杂的丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口

对外隐藏内部实现细节,并提供访问的接口

什么时候应该封装？

当有一些数据不希望外界可以直接修改时

当有一些函数不希望给外界使用时

为什么需要封装？

1.为了保证关键数据的安全性

2.对外部隐藏实现细节,隔离复杂度

语法

class Person:
    def __init__(self,id_number,name,age)
    
	self.__id_number = id_number
        self.name = name
        self.age = age
   
p = Person("1111111111111","jack",29)
p.id_number = "222"

被封装的内容的特点:

1.外界不能直接访问

2.内部依然可以使用

权限

学习了封装后就可以控制属性的权限

在python只要两种权限

1.公开的.默认就是公开的

2.私有的,只能由当前类自己使用

在外界访问私有的内容

属性虽然被封装了,但是还是需要使用的,在外界如何访问

通过定义方法类完成对私有属性的修改和访问

"""
这是一个下载器类,需要提供一个缓存大小这样的属性
缓存大小不能超过内存限制
"""
class Downloader:
    def __init__(self,filename,url,buffer_size):
        self.filename = filename
        self.url = url
        self.__buffer_size= buffer_size
    def start_download(self):
        if self.__buffer_size <= 1024*1024:
            print("开始下载....")
            print("当前缓冲器大小",self.__buffer_size)
        else:
            print("内存炸了! ")
    def set_buffer_size(self,size):
        #可以在方法中添加额外的逻辑
        if not type(size) == int:
            print("大哥 缓冲器必须是整型")
        else:
            print("缓冲区大小修改成功!")
            self.__buffer_size = size
    def get_buffer_size(self):
        return self.__buffer_size
d = Downloader("葫芦娃","http://www.baicu.com",1024*1024)
# 通过函数取修改内部封装的属性
d.set_buffer_size(1024*512)
# 通过函数访问内部封装的属性
print(d.get_buffer_size())
d.start_download()

这样一来我们可以在外界修改这个关键数据时,做一些限制

【Python】继承

Thu, 25 Jul 2019 00:00:00 +0000

Python继承 ****> »思维导图************************> »博客园********

什么是继承？

继承是一种关系,描述两个对象之间,什么是什么的关系
例如麦兜,佩奇,猪刚鬣 都是猪啊,
在程序中,继承描述的是类和类之间的关系  
例如a继承了b, a就能直接使用b已经存在的方法和属性
a称之为子类,b称之为父类,也称之为基类

为什么要使用继承

继承的一方可以直接使用被继承一方已经有的东西
其目的是为了重用已经有的代码,提高重用性

如何使用继承

语法

class 类名称(父类的名称):
    类的内容 
    
#在python中 一个子类可以同时继承多个父类

抽象

不具体,不清晰,很模糊,看不懂  
将多个子类中相同的部分,进行抽取,形成一个新的类,这个过程也称之为抽象的过程
正确的使用继承:
	1.先抽象在继承
	2.继承一个已经现存的类,扩展或是修改原始的功能

属性的查找顺序

class A:
    text = "haha"

class B(A):
    text = "heihei"
    pass

b = B()
b.text = "xixi"

print(b.text)

对象自己的 - > 所在类中 -> 找父类 - >父类的父类 ->Object

派生

当一个子类中出现了与父类中不同的内容时,这个子类就称之为派生类
通常子类都会写一些新的代码,不可能和父类完全一样 , 既通常都是派生类,
所以派生类指的就是子类

覆盖

【Python】面向对象

Wed, 24 Jul 2019 00:00:00 +0000

Python面向对象 »>思维导图****> »博客园

面向对象编程思想OOP

什么是面向对象

[os-copy]

面向对象是一种编程思想，是前辈们总结出的经验，指导程序员如何编写出更好的程序，核心是对象，程序就是一系列对象的集合，程序员负责调度控制这些对象来交互着完成任务

案例1 把大象装进冰箱？
面向过程:
1.打开冰箱
2.装入大象
3.关闭冰箱
面向对象:
找个具备装大象的技能的对象

在面向对象中程序员的角度发生改变，从具体的操作者变成了指挥者
强调：对象不是凭空产生的，需要我们自己设计

案例2 西天取经
如来有一堆破书要传出去,他没有自己干,
而是找了五个对象帮他去干, 如来只要负责控制调度的对象即可,

如果某个对象发生变化,也不会影响其他的对象 , 扩展性

案例3 曹操吟诗
喝酒吃肉,人生真爽
喝酒吃肉,人生几何
对酒当歌,人生几何

[/os-copy]

面向对象三大优点

[os-copy]

1.扩展性

2.灵活性

3.重用性

[/os-copy]

缺点

[os-copy]

1.程序的复杂度提高了

2.无法准确预知结果

[/os-copy]

使用场景：

对扩展性要求较高，通常是直接面向用户的，例如：QQ，微信

面向过程编程思想

[os-copy]

关注的核心是过程,过程是就是一步一步的执行步骤,既先干啥在干啥

优点:逻辑清晰 , 复杂问题简单化,流程化

缺点: 扩展性差,可维护性差

使用场景:对扩展性要求较低的程序例如:系统内核,git,计算器

记住:不是所有程序都要面向对象,得分析具体需求

[/os-copy]

类和对象

类：即类型，类别，是一种抽象概念，是一系列具备相同特征和相同行的对象的集合

对象：就是具体存在的某个事物，具备自己的特征和行为，对象就是特征和技能的结合体

类和对象的关系

[os-copy]

类包含一系列对象，对象属于某个类

在生活中是先有对象再有类，而在程序中是先有类才能有对象,我们必须先告诉计算机这类的对象有什么特征有什么行为

总结出一个结论:在使用面向对象编程时,第一步就是思考需要什么样的对象,对象具备什么样的特征和行为,从而根据这些信息总结出需要的类型

[/os-copy]

创建类和对象

定义类的语法

【Python】深浅拷贝/hashlib/logging/openpyxl模块

Fri, 19 Jul 2019 00:00:00 +0000

深浅拷贝/hashlib/logging/openpyxl模块 »>思维导图> »博客园

模块与包

模块

"""
三种来源
    1.内置的
    2.第三方的
    3.自定义的
四种表示形式
    1.py文件(******)
    2.共享库
    3.文件夹(一系列模块的结合体)(******)
    4.C++编译的连接到python内置的
"""

导入模块

"""
先产生一个执行文件的名称空间
    1.创建模块文件的名称空间
    2.执行模块文件中的代码 将产生的名字放入模块的名称空间中
    3.在执行文件中拿到一个指向模块名称空间的名字
"""

什么是包

"""
什么是包?
    它是一系列模块文件的结合体,表示形式就是一个文件夹
    该文件夹内部通常会有一个__init__.py文件
    包的本质还是一个模块
"""

导入包

先产生一个执行文件的名称空间
    1.创建包下面的__init__.py文件的名称空间
    2.执行包下面的__init__.py文件中的代码 将产生的名字放入包下面的__init__.py文件名称空间中
    3.在执行文件中拿到一个指向包下面的__init__.py文件名称空间的名字
在导入语句中 .号的左边肯定是一个包(文件夹)

当你作为包的设计者来说

1.当模块的功能特别多的情况下 应该分文件管理
2.每个模块之间为了避免后期模块改名的问题 你可以使用相对导入(包里面的文件都应该是被导入的模块)
# 研究模块与包 还可以站另外两个角度分析不同的问题
# 1.模块的开发者
# 2.模块的使用者

研究模块与包还可以站另外两个角度分析不同的问题

1.站在包的开发者
如果使用绝对路径来管理的自己的模块 那么它只需要永远以包的路径为基准依次导入模块
2.站在包的使用者
你必须得将包所在的那个文件夹路径添加到system

注意

python2如果要导入包 包下面必须要有__init__.py文件
python3如果要导入包 包下面没有__init__.py文件也不会报错
当你在删程序不必要的文件的时候 千万不要随意删除__init__.py文件

相对导入与绝对导入

【Python】时间/序列化/sys/os模块

Thu, 18 Jul 2019 00:00:00 +0000

Python****时间/序列化/sys/os模块 »>思维导图****> »博客园****************

collections模块

collections模块在内置的数据类型，比如：int、str、list、dict等基础之上额外提供了几种数据类型。
1.namedtuple(): 生成可以使用名字来访问元素内容的tuple子类
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典

****具名元组(namedtuple)

tuple是一个不可变的集合，namedtuple是一个函数，她用来构建一个自定义的tuple对象，
并且规定了tuple元素的个数，可通过属性而不是索引来引用tuple的某个元素。
我们可以通过namedtuple很方便的自定义一个数据类型，它具有tuple 的不变属性又可以根据属性来引用。

****想表示空间坐标点x为1， y为2，z为5的坐标

from collections import namedtuple
point = namedtuple('坐标',['x','y','z'])  # 第二个参数既可以传可迭代对象
point1 = namedtuple('坐标','x y z')  # 也可以传字符串 但是字符串之间以空格隔开
p = point(1,2,5)
p1 = point1(2,3,6)print(p,p.x,p.y,p.z)  # 坐标(x=1, y=2, z=5) 1 2 5print(p1,p1.x,p1.y,p1.z)  # 坐标(x=2, y=3, z=6) 2 3 6

想表示一张黑桃A的扑克牌

card = namedtuple('扑克牌','color number')
card1 = namedtuple('扑克牌',['color','number'])
A = card('♠','A')
B = card1('♠','A')print(A.color,A.number,A)  # ♠ A 扑克牌(color='♠', number='A')print(B.color,B.number,B)  # ♠ A 扑克牌(color='♠', number='A')

想表示一个城市

【Python】正则表达式与re模块

Wed, 17 Jul 2019 00:00:00 +0000

Python正则表达式与re模块************> »转到****思维导图************************************> »转到********博客园****

正则表达式与re模块的关系

1.正则表达式是一门独立的技术，任何语言均可使用

2.python中要想使用正则表达式需要通过re模块

正则表达式应用场景
推荐书籍：正则指引

1.爬虫

2.数据分析

字符组概念

在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示(一个字符组每次只能匹配一个字符)

小例子

匹配0-9数字([0123456789]也支持简写[0-9])(如果想匹配横杠,转义即可)
匹配A-Z字母(依据上面的简写规则[A-Z])
匹配a-z字母(依据上面的简写规则[a-z])
ps:这种上面到上面的范围必须是从小到大[a-Z]不行，[A-z]可以(但是内部有几个特殊符号)，因为内部对应的asicc码A在所有字母里面最小，z在所有字母里面最大

正则	待匹配字符	匹配结果	说明
[0123456789]	8	True	在一个字符组里枚举合法的所有字符，字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
[0123456789]	a	False	由于字符组中没有"a"字符，所以不能匹配

[0-9]| 7| True| 也可以用-表示范围,[0-9]就和[0123456789]是一个意思

[a-z]| s| True| 同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示

[A-Z]| B| True| [A-Z]就表示所有的大写字母

[0-9a-fA-f]| e| True| 可以匹配数字，大小写形式的a～f，用来验证十六进制字符

字符

元字符
| 匹配内容

【Python】模块

Tue, 16 Jul 2019 00:00:00 +0000

Python模块******> »转到**思维导图********************> »转到博客园************

1.什么是模块？

1模块就是一系列工能的结合体
2模块的三种来源：
    1.内置的(python解释器自带)
    2.第三方的(别人写的)
    3.自定义的(你自己写的)
3模块的四种表现形式
    1.使用python编写的py文件(也就意味着py文件也可以称之为模块:一个py文件也可以称之为一个模块)
    2.已被编译为共享库或DLL的C或C++扩展(了解)
    3.包好一组模块的包：把一系列模块组织到一起的文件夹(文件夹下有一个__init__.py文件，该文件夹称之为包) 包:一系列py文件的结合体
    4.使用C编写并链接到python解释器的内置模块

2.为什么要用模块**？**

1.从文件级别组织程序，更方便管理。
当多个文件中都需要使用相同的方法的时候 可以将该公共的方法写到一个py文件中，其他的文件以模块的形式导过去直接调用即可
2.拿来主义，提升开发效率

3如何使用模块？

1.import的使用
    模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行
2.在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果
    1.首先创建一个执行文件(run.py)的名称空间，执行模块文件
在模块中定义的函数和方法若是使用到了global时访问的就是这个名称空间
    2.运行模块文件(md.py)中的代码将产生的名字与值存放到执行文件(run.py)的名称空间中
        在新创建的命名空间中执行模块中包含的代码
    3.在执行文件中产生一个执行指向名称空间的名字(md)
        创建名字来引用该命名空间
3from...import...句式缺点:
    1.访问模块中的名字不需要加模块名前缀
    2.在访问模块中的名字可能会与当前执行文件中的名字冲突
4补充知识点：
    __name__
        当文件被当做执行文件执行的时候__name__打印的结果是__main__
        当文件被当做模块导入的时候__name__打印的结果是模块名(没有后缀)
    __all__
        __all__可以指定当所在py文件被当做模块导入的时候,可以限制导入者能够拿到的名字个数
    from md1 import *
        一次性将md1模块中的名字全部加载过来 不推荐使用 并且你根本不知道到底有哪些名字可以用
    异常有两大类
        1.语法结构错误:需要你当场修改 异常捕获没法完成
        2.逻辑错误:异常捕获可以处理

4.循环导入

1.如果出现循环导入问题 那么一定是你的程序设计的不合理。循环导入问题应该在程序设计阶段就应该避免。
2.解决循环导入问题的方式
    1.方式1：将循环导入的句式写在文件最下方()
    2.方式2：函数内导入模块

5.模块的查找顺序

1.先从内存中找
2.再从内置中找
3.最后环境变量(sys.path)中找
    一定要分清楚谁是执行文件谁是被导入文件sys.path返回的是一个大列表,里面放了一对文件路径,第一个路径永远是执行文件所在的文件夹注意:py文件名不应该与模块名(内置的,第三方)冲突

6.绝对导入与相对导入

1绝对导入
    绝对导入必须依据执行文件所在的文件夹路径为准
    绝对导入无论在执行文件中还是被导入文件都适用
2相对导入
    .代表的当前路径
    ..代表的上一级路径
    ...代表的是上上一级路径
    注意相对导入不能再执行文件中使用
    相对导入只能在被导入的模块中使用,使用相对导入就不需要考虑执行文件到底是谁，只需要知道模块与模块之间路径关系

7.软件开发规范

【Python】迭代器/生成器

Mon, 15 Jul 2019 00:00:00 +0000

Python迭代器/生成器******> »转到**思维导图****> »转到博客园****

1.迭代

1.1什么是迭代：

更新换代(重复)的过程，每次迭代都必须基于上一次的结果

1.2什么是迭代器：

迭代取值的工具

1.3为什么要有迭代器：

迭代器提供了一种不依赖于索引取值的方式
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

1.4什么是可迭代对象：

可迭代对象指的是内置有__iter__方法的对象，即obj.iter

1.5什么是迭代器对象：

可迭代对象执行obj.iter()得到的结果就是迭代器对象。而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象。

1.6注意：

迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

需要迭代取值的数据类型：字符串str、列表list、元组tuple、字典dict、集合set、文件对象

文件对象执行内置的__iter__之后还是本身没有任何变化，文件对象本身就是迭代器对象

针对双下线开头双下划线结尾的方法，推荐读:双下+方法名

2.迭代器取值：

迭代器取值调用__next__

迭代器对象无论执行多少次__iter__方法得到的还是迭代器对象本身

2.1异常报错StopIteration：取完了

2.2异常处理：

while True: 
    try: 
        print(iter_d.__next__()) 
    except StopIteration: 
        print('老母猪生不动了')
    break

2.3迭代器取值的特点：只能往后依次取，不能后退

2.4迭代器取值的优点：

1.不依赖于索引取值

2.内存中永远只占一份空间,不会导致内存溢出

2.5迭代器取值的缺点：

1.不能够获取指定的元素

2.取完之后会报StopIteration错

3.for循环的本质

1.将in后面的对象调用__iter__转换成迭代器对象

2.调用__next__迭代取值

3.内部有异常捕获StopIteration,当__next__报这个错自动结束循环

4.生成器

只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

生成器就是迭代器，可以用__next__方法取值

yield后面跟的值就是调用迭代器__next__方法你能得到的值

yield既可以返回一个值也可以返回多个值，并且多个值也是按照元组的形式返回

可以用.send给yield左边的变量传参，但必须先将代码运行至yield才能为期传值

yeild

1.帮你提供了一种自定义生成器方式

2.会帮你将函数的运行状态暂停住

3.可以返回值

yeid与return异同:

相同点：都可以返回值,并且都可以返回多个

不同点：yield可以返回多次值,而return只能返回一次函数立即结束，yield还可以接受外部传入的值

5.生成器表达式

例如：res = (i for i in range(1,10) if i != 4)

【Python】函数

Fri, 12 Jul 2019 00:00:00 +0000

Python函数 »>转到思维导图****> »转到博客园

递归函数

函数在调用阶段直接或间接的又调用自身

如果一个函数在内部调用自身本身，这个函数就是递归函数。

举例

# 举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：
# fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
# 所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。
# 于是，fact(n)用递归的方式写出来就是：
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
# 如果我们计算fact(5)，可以根据函数定义看到计算过程如下：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

扩展 import sys

【Python】装饰器

Fri, 12 Jul 2019 00:00:00 +0000

Python装饰器> »转到****思维导图********> »转到博客园

闭包函数

1.定义在函数内部的函数

2.内部函数内部函数引用了外部函数名称空间作用域的名字

只要满足以上两点都叫做闭包函数

def func():
    name = jason'  # 先在内部找name没有再往上层找 有了就停止查找
    def inner():
        print(name)  # 现在内部找name没有再往上层找
    return inner
f = func()  # f获取到的是inner的内存地址
f()  # 相当于执行 inner()
# 函数在定义阶段名字的查找孙旭就已经固定死了，不会因为函数调用位置的变化而变化

给函数传参的两种方式

1.直接传参

def index(name):
    print(name)

2.闭包

def outter(name):
    # name = 'jason'
    def index():
        print(name)
    return index

装饰器

器：就是一个工具

装饰：就是给被装饰对象添加新的功能

开放封闭原则：

开放：对扩展开放

封闭：对修改封闭

装饰器(可调用对象)必须遵循的两个原则：

1.不改变被装饰对象的源代码

2.不改变被装饰对象(可调用对象)调用方法

可调用：callable

def new():
    print('这是原始函数')

def outter(func):
    def inner():
        print('这是内部函数，这里可以加新功能')
        func()  # 这里的func是你想调用的最原始的函数的内存地址,加上()直接调用
        print('这是内部函数，这里可以加新功能')
    return inner  # 这里不加括号 返回的是inner函数的内存地址
new = outter(new)  # 括号内的new指向的是最原始的new函数的内存地址，前面的new获取的是outter函数的返回值，返回值我们自定义了返回 inner函数的内存地址
# 总结：前面的new获取的是inner的内存地址，后面括号内的new指向的就是最原始的new的内存地址
new()

扩展：import time

【Python】名称空间与作用域/函数的嵌套

Wed, 10 Jul 2019 00:00:00 +0000

Python名称空间与作用域/函数的嵌套** »>转到**思维导图********> »转到****博客园

命名关键字参数

在函数定义阶段，写在*和**可变长参数之间的形参

在给命名关键字参数传值的时候，只能用关键字为期传值

在定义阶段给你感觉好像是z是默认值参数，放在了m这个位置参数的前面了，应该报错

其实z和m都是命名关键字参数，不是默认值参数和位置参数

def func(x,y=1,*args,z=3,m,**kwargs):
    print(x,y)
    print(args)
    print(z,m)
    print(kwargs)
func(1,2,1,2,3,4,5,6,7,78,8,9,0,z=69,m=999,o=666999,l = 999666)

函数对象

函数是第一类对象：函数名指向的值可以被当中的参数传递

1.函数名可以被传递

name = 'jason'
x = name
print(x)
print(id(x))
def func():
    print('from func')
# print(func)
print(id(func))
f = func

func()
print(f)
f()  # 其实指向的也是函数func指向函数体代码的内存地址

2.函数名可以被党组参数传递给其他函数

def func():
    print('from func')

def index(args):
    print(args)
    args()
    print('from index')
# index(1)
index(func)

3.函数名可以被当做函数的返回值

def index():
    print('index')


def func():
    print('func')
    return index
res = func()
print(res)
res()

4.函数名可以被当做容器类型的参数

【Python】函数

Tue, 09 Jul 2019 00:00:00 +0000

Python函数 > »转到思维导图********> »转到博客园****************

函数的返回值

函数内要想返回给调用者值必须用关键字return

不写return:函数默认返回None

def func():
    print('hahaha')
res = func()
print(res)

只写return:return除了可以返回值之外，还可以直接结束整个函数的运行

只写return 返回的也是None(None就表示什么都没有)

只写return 返回的也是None(None就表示什么都没有)
def func():
    l = ['jason','egon','tank']
    while True:
        for i in l:
            if i == 'egon':  # 当i为egon的时候 直接结束函数运行
                # break
                return
                # print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
            print(i)
res = func()
print(res)

写return None:跟上面的只写return是一样的

def func():
    return None
res = func()
print(res)

写return返回一个值:这个值可以是python任意数据类型

def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'jason'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())

写return返回多个值:return会自动将多个值以元组的形式返回给调用者

【Python】文件操作/函数前戏

Mon, 08 Jul 2019 00:00:00 +0000

Python文件操作/函数前戏 »>转到思维导图********> »转到博客园****

文件操作模式补充

"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
a+， 写读【可读，可写】

文件内光标移动

一: read(3)：
1. 文件打开方式为文本模式时，代表读取3个字符
2. 文件打开方式为b模式时，代表读取3个字节
二: 其余的文件内光标移动都是以字节为单位如seek，tell，truncate
注意：
1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的
2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果

检测文件内容

with open(r'test01.txt','rb') as f:
    # 先将光标移动到文件末尾
    f.seek(0,2)
    while True:
        res = f.readline()
        # 查看光标移动了多少位 bytes
        # print(f.tell())
        if res:
            print("新增的文件内容:%s"%res.decode('utf-8'))
            # 说明有人操作当前文件
        # else:
        #     # 说明文件没有被任何人操作
        #     print('暂无其他人操作该文件')

截断文件

with open(r'test','a',encoding='utf-8') as f:
    f.truncate(6)  # 接收的字节的长度 整型
    # 保留0~6字节数 后面的全部删除(截断)

修改文件

【Python】字符编码/文件操作

Fri, 05 Jul 2019 00:00:00 +0000

Python字符编码/文件操作 »>转到思维导图****> »转到博客园****

字符编码

# 字符编码针对的是文字。
# 字符编码只跟文本文件有关。
# 文本编辑器的输入和输出是两个过程。
# 字符编码表就是字符与数字的对应关系

ASCII码表 用八位二进制表示一个英文字符

GBK 用2Bytes表示一个中文字符，还是用1Bytes表示一个英文字母。最多能表示65535个字符

Unicode万国码 统一用2Bytes表示所有的字符
    1.浪费存储空间
    2.IO次数增加，程序运行效率降低(致命)
    
# 当内存中的unicode编码格式数据存到硬盘的时候，会按照utf-8编码

# 会将unicode的英文字符由原来的2Bytes变成1Bytes
# 会将unicode中文字符由原来的2Bytes变成3Bytes
# 现在的计算机内存都是unicode，硬盘都是utf-8

unicode的两个特点
    1.用户在输入的时候，无论输什么字符都能够兼容万国字符
    2.其他国家编码的数据由硬盘读到内存的时候unicode与其他各个国家的编码都有对应关系
    
# 数据由内存保存到硬盘
    内存中的unicode格式二进制数字 >>>编码(encode)>>>utf-8格式的二进制数据
# 硬盘中的数据由硬盘读到内存
    硬盘中的utf-8格式的二进制数据>>>解码(decode)>>>内存中unicode格式的二进制数据
    
# 保证不乱码在于文本文件以什么编码编的就以什么编码解

# python2将py文件按照文本文件读入解释器中默认使用ASCII码
# python3将py文件按照文本文件读入解释器中默认使用utf-8

# 文件头 # coding:utf-8 因为所有的编码都支持英文字符,所以文件头才能够正常生效
# python3中字符串默认就是unicode编码格式的二进制数
# pycharm终端用的是utf-8格式，windows终端采用的是gbk格式。

encode() # 将unicode编码成可以存储和传输的utf-8的二进制数据
# bytes类型  字节串类型  你就把它当成二进制数据即可
decode()  # 将硬盘中的utf-8格式的二进制数据解码成unicode格式的二进制数据

x = '上'
res1 = x.encode('gbk')  # 将unicode编码成可以存储和传输的utf-8的二进制数据
print(res1)  # b'\xe4\xb8\x8a'
# bytes类型  字节串类型  你就把它当成二进制数据即可
res2 = res1.decode('gbk')  # 将硬盘中的utf-8格式的二进制数据解码成unicode格式的二进制数据
print(res2)


# 补充:
# 你a他
# 1Bytes|1Bytes|1Bytes|1Bytes|1Bytes|1Bytes|1Bytes
# 1+7bit|1+7bit|1+7bit|1+7bit|1+7bit|1+7bit|1+7bit

文件处理

【Python】列表/字典/元组/集合

Thu, 04 Jul 2019 00:00:00 +0000

Python列表/字典/元组/集合 »>转到思维导图********> »转到博客园****

列表list

count()用来统计列表某个元素的个数

>>> l = [1,2,3,4,5,6,7]
>>> res = l.count(8)
>>> print(res)
0

clear()用来清除列表元素

>>> res = l.clear()
>>> print(res)
None
>>> print(l)
[]

reverse()用来将列表反转

>>> l = [1,2,3,4,5,6,7]
>>> print(id(l))
2271674158920
>>> l.reverse()
>>> print(l)
[7, 6, 5, 4, 3, 2, 1]
>>> print(id(l))
2271674158920

sort()按升序将列表元素排序

>>> l.sort()
>>> print(l)
[1, 2, 3, 4, 5, 6, 7]
>>> print(id(l))
2271674158920

队列：先进先出

【Python】数据类型

Wed, 03 Jul 2019 00:00:00 +0000

Python数据类型 »>转到思维导图> »转到博客园****

整型(int)

用途：记录QQ号、手机号、身份证号等

定义：age = 18

常用操作+内置的方法

int只能转存数字的字符串，小数点都不行

进制转换

>>> print(int('1100',2))  # 二进制转十进制  0,1
12
>>> print(int('14',8))  # 八进制转十进制  0-7
12
>>> print(int('c',16))  # 十六进制转十进制 0-9 A-F
12
# int可以传第一个参数，表示的是第一个参数到底是什么进制  然后转成十进制

>>> print(bin(12))  # 10进制转二进制
0b1100  # 0b1100  0b表示后面的数字是二进制数
>>> print(oct(12))  # 10进制转八进制
0o14  # 0o14  0o表示后面的数字是八进制数
>>> print(hex(12))  # 10进制转16进制
0xc  # 0xc  0x表示后面的数字是十六进制数

有序：但凡有索引的数据都是有序的

不可变：值改变的情况下，id一定变

浮点型(float)

用途：记录薪资、身高、体重等

定义：

salary = 1.1 # salary = float(1.1)

>>> res = float('1.11')
>>> print(type(res))
<class 'float'>

有序：但凡有索引的数据都是有序的

【Python】流程控制

Tue, 02 Jul 2019 00:00:00 +0000

Python流程控制 »>转到思维导图****> »转到博客园********

if判断

判断失误的对错，真假，是否可行

固定语法

if 条件:
    代码1
    代码2
    代码3
    代码4
    ...

python的缩进表示代码的归属

同一缩进的代码，称之为代码块

补充：布尔值位False数据由哪些：0,None,’ ‘,[ ],{ }

布尔值也可以直接用来判断

变量名也可以用来判断，因为变量名指向的值对应的就是True或False

else 语法 # 不能单独使用，必须和if，while，for配合使用

if 条件:
    代码1
    代码2
    代码3
    代码4
    ...
else:  # 不能单独使用，必须和if，while，for配合使用
    代码1
    代码2
    代码3
    代码4
    ...

if elif else 语法 ：同一级别配合使用的时候，只会指向一个代码块

if 条件:
    代码1
    代码2
    代码3
    代码4
    ...
elif 条件:
    代码1
    代码2
    代码3
    代码4
    ...
else:  # 不能单独使用，必须和if，while，for配合使用
    代码1
    代码2
    代码3
    代码4
    ...

走了if就不会走elif else，走了elif就不会走else，if看到没走，走了else说明if elif都没走，都不满足if elif的条件

【Python】输入输出/数据类型/运算符

Mon, 01 Jul 2019 00:00:00 +0000

Python输入输出/数据类型/运算符 »>转到思维导图********> »转到博客园********

Python的注释

单行注释# 和多行注释’’’ ’’''

输入

python3中的input全部存成字符串类型
python2中需要认为告诉input输入的什么数据类型

name = input(‘please input»>:’) please input»>:jason Traceback (most recent call last): File “", line 1, in File “", line 1, in NameError: name ‘jason’ is not defined name = input(‘please input»>:’) please input»>:’egon’ name ’egon’ type(name) <type ‘str’> name = input(‘please input»>:’) please input»>:[1,2,3,4] name [1, 2, 3, 4] type(name) <type ’list’>
raw_input()会统一存为字符串

name1 = raw_input(’»»»»»»»»»:’)

:jason name1 ‘jason’ type(name1) <type ‘str’> name1 = raw_input(’»»»»»»»»»:’) :[1,2,3,4,5] name1 ‘[1,2,3,4,5]’ type(name1) <type ‘str’>

【Python】计算机发展史/变量/垃圾回收机制

Fri, 28 Jun 2019 00:00:00 +0000

Python计算机发展史/变量/垃圾回收机制 »>转到思维导图********> »转到博客园********

****编程语言发展史

机器语言

站在奴隶主的角度说奴隶主的话

1.编译型(类似于谷歌翻译)

2.解释型(类似于同声传译)

PS:一次翻译之后，就可以拿着翻译之后的结果多次运行

汇编语言

用简单的英文标签来表示二进制数，直接操作硬件

优点：开发效率高于机器语言

缺点：执行效率较机器语言低

高级语言

站在奴隶主的角度说奴隶主的话

1.编译型(类似于谷歌翻译)

一次翻译之后，就可以拿着翻译之后的结果多次运行

编译的过程需要用到编译器

优点：执行效率高

缺点：开发效率低

2.解释型(类似于同声传译)

一行一行的翻译(读一行翻译一行)

解释的过程需要用到解释器

优点：开发效率高

缺点：执行效率低

PS:

学习难度：高级语言»>汇编语言»>机器语言

执行效率：机器语言»>汇编语言»>高级语言

开发效率：机器语言»>汇编语言»>高级语言

Python

python是解释型语言

1.胶水语言

2.调包侠

python解释器，环境变量配置，多版本共存

在IT行业不要贸然尝试用最新版本的软件！！！

第一个Python程序

1.交互式

优点：输入内容立刻就有对应的返回结果

缺点：无法永久保存数据

2.命令行(文件形式)

优点：可以永久保存数据

缺点：暂时来看运行该文件有点麻烦

PS：文件后缀名

仅仅是给人看的

你所认为的不同的文件后缀有不同的功能那是程序员自己写的

python文件默认的后缀名就是.py结尾

运行一个py文件需要走的步骤(*)

1.将python解释器代码从硬盘督导内存(就等价于双击了word图标)

2.将你写好的py文件由应哦按读到内存(就等价于你双击了一个word文档)

3.解释器解释读取py文件中的内容，解释成计算机能够识别的语句(如果是一个普通文本文件，仅仅只会将文件内容展示到屏幕上给用户查看，不会检测翻译文件内容)

PS:Pyhon解释器与普通文本编辑器前面两步是一毛一样的，仅仅第三步不一样(一个是解释语法，一个是文本展示)

变量

1.什么是变量

量：衡量/记录事物的状态/特征

变：状态/特征是可以变化的

2.为什么要有变量？

帮助你记录保存事物的某种状态或特征

3.变量的定义

1.只能包含数字，字母，下划线

2.数字不能开头

3.关键字不能作为变量名

变量必须先定义后调用(使用)，变量名不要加引号

4.变量额三要素

1. id():返回的是一串数字

2. type():返回的是该变量对应的主句的类型

3. value:该变量指向的内存当中数据的值

【Python】计算机组成原理/编程语言

Thu, 27 Jun 2019 00:00:00 +0000

Python是一门编程语言 »>转到思维导图****** »>转到**博客园****

编程

1.什么是编程

编写程序，谁来编写，人来编写。

将自己的思维逻辑和想法通过计算机能够识别的语言写下，告诉计算机按照你的思维逻辑去帮你干活。

编程的最终结果就是一丢文件。

2.为什么要编程

让计算机能够按照你的思维逻辑去工作，解放人力！！！

语言

汉语，日语，英语，法语，德育

事物与事物之间沟通交流的媒介

操作系统：（windows,linux,unix…）

1.操作系统是帮你操作计算机硬件的，它帮你封装好了一系列操作硬件的方法。

2.程序员只需要按照操作系统提供的操作方法即可简介操作硬件。

3.一套完整的计算机系统由一下三部分组成

1.应用程序

2.操作系统（中间人）

3.计算机硬件

ps:

1.程序员开发的程序都叫做应用程序。

2.操作系统也是应用程序,但是它针对的是计算机硬件。

操作系统也是一款应用软件，但是它是针对计算机硬件的，将复杂丑陋的操作封装起来，暴露给用户简单快捷的操作接口，帮助你协调，管理，调度计算机各个硬件。

计算机五大组成部分

1.控制器

2.运算器

控制器+运算器=计算机中央处理器（CPU）

3.存储器：计算机存储系统

内存

基于电工作的，通电数据正常读取，一旦断电数据即可丢失。

优点：读取速度快

缺点：断电数据丢失

外存

优点：能够永久保存数据

缺点：读取速度慢

4.输入设备

键盘，鼠标，触摸屏

5.输出设备

显示器，音响，打印机

ps:

输入设备也称input

输出设备也称output

存储器也可以叫着IO设备

计算机三大核心组件

1.CPU ：大脑

2.内存：短期记忆

3.硬盘：永远不会消失的本子

计算机是基于电工作的，而电信号只有高低电频两种状态0和1，计算机里面存储的都是0101的二进制数据。

CPU工作流程：选取内存中读取命令，将命令解析翻译成自己能够对应上的操作步骤，控制硬件执命令。

简单指令集

复杂指令集

x86架构

CPU到内存中获取数据最多读32位

64位 32位

64位向下兼容32位的软件

而32位不能够兼容64的软件

存储器

寄存器 ：cpu下一步即将要用到的数据（容量小）

高速缓存 ：将经常需要用到的容量比较小的数据存储在高速缓存

内存：cpu获取数据的主力还是内存