python知识杂记

快来打我* 2022-05-26 02:43 439阅读 0赞

### 1.字符集问题 ###

windows下面尽量用\#coding:gbk  
Linux下面尽量用\#coding:utf-8

### 2.什么是序列 ###

序列是指有序和无序的数据结构  
包括：字符串，列表，元组，字典，集合

### 3.编程规范 ###

命名规范：  
类定义用驼峰式 TestCase  
其他用小写字符加下划线 test\_case  
常量全部用大写

注释的两种方式：  
单行注释用\#  
类和对象的docstring用”“” “”“

import顺序：  
标准库，第三方库，自定义库  
不同类型的库中间空一行

空行：  
类与函数之间空两行  
函数与函数之间空一行  
函数中，逻辑代码段之间空一行

### 4.库、包、模块的概念 ###

库：python的一个项目  
包：包含\_\_init\_\_.py文件的文件夹  
模块：以.py为结尾的文件

py2中，包里面必须有\_\_init\_\_.py文件，否则解释器无法识别这个包，也就是包下面的.py文件，外部无法调用。

### 5.import导入模块搜索顺序 ###

import导入的时候，针对模块名，首先搜索当前目录，然后查找标准库，最后查找第三方库。

### 6.\_\_init\_\_.py文件的作用 ###

python中\_\_init\_\_.py文件的作用：Python中每个模块的包下面都有一个\_\_init\_\_.py文件，有了这个文件，我们才能导入这个包下面的module。

### 7.如何设置环境变量 ###

windows环境：我的电脑-属性-高级系统设置-高级-环境变量，修改PATH，添加;$PYTHON\_INSTALL\_DIR(自己改)  
Linux环境：export PATH=…….

### 8.第三方库安装位置 $PYTHON\_INSTALL\_DIR\\Lib\\site-packages ###

### 9.查看内建函数：dir(**builtins**) ###

### 10.type和isinstance()函数 ###

Python在定义变量的时候不用指明具体的的类型，解释器会在运行的时候会自动检查变量的类型，并根据需要进行隐式的类型转化。  
因为Python是动态语言，所以一般情况下是不推荐进行类型转化的。  
比如”+”操作时，如果加号两边是数据就进行加法操作，如果两边是字符串就进行字符串连接操作，如果两边是列表就进行合并操作，甚至可以进行复数的运算。解释器会在运行时根据两边的变量的类型调用不同的内部方法。当加号两边的变量类型不一样的时候，又不能进行类型转化，就会抛出TypeError的异常。

但是在实际的开发中，为了提高代码的健壮性，我们还是需要进行类型检查的。而进行类型检查首先想到的就是用type()，比如使用type判断一个int类型。

对于内建的基本类型来说，使用tpye来检查是没有问题的。  
可是当应用到其他场合的时候，type就显得不可靠了。比如：

class A():
        pass
    
    class B():
        pass
    
    a = A()
    b = B()
    
    print(type(a) is type(b))
    代码的输出结果： True

此例中type的判断显然是有问题的。  
这个时候我们就需要使用isinstance来进行类型检查。

isinstance(object, classinfo)

object表示实例，classinfo可以是直接或间接类名、基本类型或者有它们组成的元组。

>>> isinstance(2, float)
    False
    >>> isinstance('a', (str, unicode))
    True
    >>> isinstance((2, 3), (str, list, tuple))
    True

可以参考此博文：[https://www.jianshu.com/p/7ef549503c93][https_www.jianshu.com_p_7ef549503c93]

### 11.字典这个序列，以key作为序列中的每一项 ###

>>> list({
        1:2,3:4})
    [1, 3]

### 12.函数返回值的问题 ###

def test():
        print('lijingkuan')
    
    print(test())

返回值为

lijingkuan
    None

为什么呢？  
原因是：  
字符串’lijingkuan’是test()函数打印的，而None是print()函数打印的，  
None是test()函数的返回值。

修改一下

def test():
        print('lijingkuan')
        return 123
    
    print(test())

则输出结果变为

lijingkuan
    123

如果不想打印那个None，就直接执行test()就行了，不要print。

### 13.raw\_input函数 ###

接受用户输入，返回**字符串**  
— 重要，返回的是字符串，不是数字或者其他类型

### 14.list可以用来存储任何类型的对象，不强制要求类型相同，是有序的。 ###

15.type和isinstance的区别？？？

### 16.list的高阶特性   增删改查、排序 ###

增：  
append，extend，insert  
append和extend的区别？  
append是往列表中添加一个值，extend是增加一个序列。  
列表a+b会生成一个新的列表，原来的a和b不会变化。  
一般写作 c=a+b  
a.extend(b)会修改列表a，与a+b有区别。  
a.append（b），会将b当成一个值去对待，而不是当成一个列表。  
例如:

a=[1,2,3],b=[4,5,6]
    a.extend(b) = [1,2,3,4,5,6]
    a.append(b)=[1,2,3,[4,5,6]]

因此：  
append往列表中添加元素，该元素可以是任何形式的数据结构或对象，添加的对象作为列表中的一个元素，放到最后一位。  
extend用于在列表末尾一次性追加另一个序列中的多个值，不是把对象整个添加，而是拿出每一项来添加。

>>> a=[1,2,3]
    >>> b="abc"       
    >>> a.extend(b)
    >>> a
    [1, 2, 3, 'a', 'b', 'c'] --字符串也是序列
    >>> c={
       'f':1,7:9}
    >>> a.extend(c)
    >>> a
    [1, 2, 3, 'a', 'b', 'c', 'f', 7]  
    -- 字典也是序列
    -- 当字典作为一个序列的时候，那么序列的每一项指的是字典的key，不包括value。

insert：往列表中添加元素，两个参数，第一个参数表示insert的位置，第二个参数表示insert的参数的value。

删：  
remove，pop

>>> a
    [1, 2, 3, 'a', 'b', 'c', 'f', 7]
    >>>
    >>>
    >>> a.remove(2)
    >>> a
    [1, 3, 'a', 'b', 'c', 'f', 7]
    >>>
    >>> a.pop(2)
    'a'
    >>> a
    [1, 3, 'b', 'c', 'f', 7]

remove删除的是具体的value，没有返回值。  
pop删除的是索引对应的value，并将删除的元素返回。  
如果pop（）不加参数，删除的是最后一个元素。  
pop（0），删除第一个元素

堆栈：坑，先进后出，通过pop（）实现  
队列：通道，先进先出，通过pop（0）实现

改：  
通过赋值去完成（通过索引定位）：  
a\[2\]=5

查：  
1.通过索引  
2.通过index去进行查询  
3.获取某个值在列表中的位置

>>> a
    [1, 3, 'b', 'c', 'f', 7]
    >>> a[1]
    3
    >>> a.index('f')
    4

排序：  
sort，sorted  
sort改变列表，sorted不改变列表  
sort是列表的方法，对列表中value重新排序，sorted是内建函数，对序列进行排序，输出排序后的序列。

>>> a=[6,2,1,3,9,8]
    >>> sorted(a)
    [1, 2, 3, 6, 8, 9]
    >>> a
    [6, 2, 1, 3, 9, 8]
    >>> a.sort()
    >>> a
    [1, 2, 3, 6, 8, 9]

### 17.list两种遍历方式（非常重要） ###

1.  for item in \_list
2.  for index,item in enumerate(\_list)

>>> a=[5,2,1]
    >>> for index,item in enumerate(a):
    ...     print(index,item)
    ...
    0 5
    1 2
    2 1

### 18.列表推导式 ###

格式1：【输出 for xx in 序列 if 条件表达式】  
一句话完成列表遍历，在循环中把满足某些条件的取出来。  
求1-100内能同时除尽2和3的整数

--列出10以内的偶数
    >>> [x for x in range(0,11) if x%2==0]
    [0, 2, 4, 6, 8, 10]
    
    --求1-100内能同时除尽2和3的整数
    >>> [x for x in range(1,101) if （x%2==0 and x%3==0）]
    [6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

格式2：【输出 if 条件 else 表达式 for xx in 序列】  
一句话完成列表编列，在循环中把满足和不满足某些条件的取出来做处理。

--将10以内的奇数平方，偶数减半
    >>> [i*i if i%2==1 else int(i/2) for i in range(1,11)]
    [1, 1, 9, 2, 25, 3, 49, 4, 81, 5]

18.\_\_pycache\_\_文件夹存储之前执行过的.py文件生成的pyc文件，如果下次执行.py文件时发现.py文件未作修改，则直接去**pycache**里面执行pyc文件，优化python的执行效率。

19.python3中的range相当于python2中的xrange。

20.input和raw\_input的区别？

### 21.列表的切片问题 ###

列表的切片是前闭后开的，即a\[1:4\]，包含1，不包含4。（索引是从0开始的）

### 22.字符串split()函数 ###

split() 方法语法：

str.split(str="", num=string.count(str)).
    
    参数
    str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
    num -- 分割次数。
    
    返回值
    返回分割后的字符串列表。

split()和split(’ ‘)执行结果的差别  
split()将空格，换行符，制表符等作为分隔符，而split(’ ‘)只是将空格作为分隔符。

### 23.字符串比较，in 的用法 ###

两种情况：  
字符串情况下最小单位为字符

s = "abc 123"
    ret = "ab" in s
    print (ret)

数组情况下最小单位是每个字符串

li = ["tom","rose","jack"]
    ret = "to" not in li
    print (ret)

### 24.字典 ###

用大括号包括，用逗号分隔每个键值对，键值对之间用冒号连接  
键是不可改变的数据结构（不是随便一个类型的数据都可以当键的），值可以是任意的对象  
a=\{\}  
a=dict()

使用：  
普通查询，参数校验：  
字典的访问是通过key去取value  
a=\{1:2,’haha’:e\}  
a\[‘haha’\] 如果没有这个key，执行会报错，可用于参数校验  
a.get(‘haha’) 如果没有这个key，返回值为null  
注意两者的区别。

增加、修改  
直接赋值，setdefault，update  
a\[‘test’\]=’diyige’ 既可以增加，又可以修改  
a.setdefault() 增加一个新的key value，如果key存在，则value不更新  
a.update（k,v）效果跟直接赋值一样

setdefault()用法：

语法
    setdefault()方法语法：
    
    dict.setdefault(key, default=None)
    参数
    key -- 查找的键值。
    default -- 键不存在时，设置的默认键值。
    返回值
    如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。

删除：  
pop(key)  
删除指定给定键所对应的值，返回这个值并从字典中把它移除。注意字典pop()方法与列表pop()方法作用完全不同。

字典的遍历：两种（三种）  
（1）for item in \_dict:  
print item  
输出的是key，不输出value，因为遍历的时候是吧字典当序列遍历

（2）for k,v in a.items():  
print(k,v)

(3) for item in a.values() –只遍历values，基本用不到

### 25.列表中的字符串过滤问题 ###

**startwith（）**

描述
    Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。
    如果参数 beg 和 end 指定值，则在指定范围内检查。
    
    语法
    startswith()方法语法：
    
    str.startswith(str, beg=0,end=len(string));
    参数
    str -- 检测的字符串。
    strbeg -- 可选参数用于设置字符串检测的起始位置。
    strend -- 可选参数用于设置字符串检测的结束位置。
    返回值
    如果检测到字符串则返回True，否则返回False。

**內建函数：filter(function\_name,sequence)**  
将sequence中的每一项作为参数传递给function，即function(item)  
在python2中，将符合条件的（执行结果为True），返回list ,tuple或者dict（需要验证，是否只返回列表），视sequence的类型而定，循环遍历取出。  
在python3中，将执行结果为True的item，返回一个filter的对象，使用循环遍历取结果。

### 26.元组 ###

列表是\[\],元组是（），都是有序的，元组创建之后无法修改，而列表是可以修改的。  
**元组的表示是逗号‘，’不是括号（）**，也就是说，不是加了()就是元组，而是要有，逗号，具体解释的举例如下：

>>> a=(1,2,3)
    >>> type(a)
    <class 'tuple'>
    >>>
    >>> a= 1,2,3
    >>> type(a)
    <class 'tuple'>
    
    >>> a=(1)
    >>> b=(1,)
    >>> type(a)
    <class 'int'>
    >>> type(b)
    <class 'tuple'>
    >>> c=1,
    >>> type(c)
    <class 'tuple'>

元组和列表一样，通过下标访问。

**元组的使用场景：**  
1.函数返回多项  
return a,b  
2.if a in b(b是一个元组)  
或者if a in (‘test1’,’hello’,’gaga’,)  
– 参考前面提到过的 in 的使用

### 27.集合 set ###

描述元素种类的一种无序序列，内建函数set  
1.没有重复项  
2.无序

>>> a='hello'
    >>> set(a)
    {
       'e', 'l', 'o', 'h'}
    >>> a=set({
       1:2,4:5})
    >>> a
    {
       1, 4}

**集合和列表的转换**  
集合的一些运算，其他的序列可能没有，普通列表可能需要使用集合的特征进行运算，比如求两个列表的交集，差集，并集等等

>>> a=[1,2,3,4,5,6,7]
    >>> b=[5,7,9]
    >>>
    >>> set(a) & set(b)
    {
       5, 7}
    >>>
    >>> set(a) | set(b)
    {
       1, 2, 3, 4, 5, 6, 7, 9}
    >>>
    >>> set(a) - set(b)
    {
       1, 2, 3, 4, 6}

应用：比如IP去重  
set作为序列遍历  
for item in set：

### 28.函数 ###

排名问题

### 29.字符串前面加 ‘r’ 的作用 ###

打开文件时open(r’d:\\hello\\hello.txt’)  
不加r会报错，因为系统认为\\是转义符

### 30.函数 ###

def func\_name(paras):  
return

参数有几种？  
普通参数 ，默认参数， 可变长参数

\* args代表元组，会把所有没有指定key的参数，把这一类参数放到一个元组中  
\* \* kwargs代表字典，会把所有指定key的参数，放到字典中

>>> def test_args(*args, **kwargs):
    ...     print(args,kwargs)
    ...
    >>> test_args(5,c=8)
    (5,) {
       'c': 8}
    >>> test_args(5,8,c=8,d=9)
    (5, 8) {
       'c': 8, 'd': 9}
    
    >>> def test_args(*args, **kwargs):
    ...     return args,kwargs
    ...
    >>> test_args(5,8,c=8,d=9)
    ((5, 8), {
       'c': 8, 'd': 9})
    --上面的返回结果中多了最外边的两个括号，原因是return返回的是元组（元组的应用之一）

### 31.深拷贝 ###

循环遍历中的删除问题  
将列表中字符串的项删除

_list = [1,'aa','123','test',8,9,7]
    
    def filter_str(item):
        if isinstance(item,str):
            return False
        else:
            return True
    #    return not isinstance(item,str):
    ret = []
    rst = filter(filter_str, _list)
    for item in rst:
        ret.append(item)
    
    print(ret)

深度拷贝（补充代码在github上deep\_copy.py）

### 32.嵌套函数 & 匿名函数 ###

可编程参数 -> 函数式编程 -> 嵌套函数 -> 闭包 -> 装饰器

def test(m,n)：
        return m+n
    
    def func(func_name, *args, **kwargs):
        ret = func_name(*args, **kwargs):
        return ret+1
    
    print(test(8,9))
    print(func(test,8,9))

嵌套函数（子函数）：函数体里面包含另一个函数的完整定义  
应用场景：一个函数中有一小段逻辑被多次调用  
闭包，装饰器

子函数能够调用父函数的局部变量，父函数无法调用子函数的局部变量  
参考github中qiantao\*.py

**匿名函数(lambda函数)：**  
定义：lambda跟一个或多个参数，跟着冒号，接着是一个表达式。  
lambda是一个关键字，lambda冒号前边是参数，后边返回结果  
形式：lambda x,y:x+y  
应用场景：  
函数式编程中，函数名本应由对应的实现逻辑，对于简单的逻辑，可以用一个lambda来表示。  
更多的应用，是和一些内建函数进行搭配，比如filter，map，sorted  
举例：  
排名问题（下） 参考github上paiming.py

>>> func_name = lambda x,y : x+y
    >>> func_name
    <function <lambda> at 0x0000000001D31E18>  --注意：返回的是函数名
    >>> func_name(1,2)
    3
    >>>
    效果和下面的相同
    def add(x, y):
        return x,y
    add(1,2)
    相同点，区别是什么？
    相同点：
    完成的作用相似
    区别：
    lambda返回的是一个函数名
    正常函数返回的是结果

### 33.内建函数 map   map(function, sequence) ###

定义：对sequence中的item依次执行function(item)，将执行结果返回一个map迭代对象，可以通过list放入列表中

举例：输出1到15的所有数的平方  
参考github中pingfang.py

### 34.函数式编程 ###

定义：对别的函数进行封装，运算，操作的函数  
学习目的：  
（1）需要对别的函数进行封装  
（2）看源码（看别人的代码）  
参数：  
（1）支持传别的函数名  
（2）任意参数\*args ,\*\*kwargs  
应用场景：  
（1）对一件事进行封装  
（2）闭包、装饰器（以后讲）  
标识：参数是其他函数的函数名  
典型的使用了函数式编程的内建函数：sorted，map，filter

### 35.解释器加载脚本顺序 ###

执行脚本中的某个函数，例如run（），可以使用以下两种写法，区别是什么？
    （1）
    if __name__ == "__main__":
        run()
    
    （2）
    run()

参看下面的脚本：

#coding:gbk
    #python解释器加载文件的顺序
    
    var1 = 1
    var2 = 2
    
    def test():
        print("执行test")
    
    def test1():
        print("执行test1")
    
    print(var1)
    test1()
    
    if __name__ == '__main__':
        print(var2)
        test()
    
    我原本以为会先执行main函数，再执行脚本中其他的函数，输出
    2
    执行test
    1
    执行test1
    
    但实际执行结果是，先执行前面的代码，最后执行的main，输出
    1
    执行test1
    2
    执行test

结论：  
**程序代码入口，并不是程序开始执行时第一个执行的。**在其他语言中也是同样的道理。  
顺序：  
（1）加载import模块  
（2）加载全局变量，全局对象  
（3）加载函数名（注册函数名，不执行函数体）。如果有函数执行的话，就直接执行。  
（4）if **name** == ‘**main**‘:

因为：  
全局变量：存放在内存的静态区域（对于你的整个代码可见）  
局部变量：存放在内存的栈中，函数执行完即销毁

### 35.全局变量global，局部变量 ###

全局变量：位置在全局区域的变量  
局部变量：在函数内的变量

函数的作用域：  
L （Local） 局部作用域  
G （Global） 全局作用域

以 L –> G 的规则查找，即：在局部找不到，便会去局部外的局部找，在找不到就会去全局找。

var = 12
    
    def change_var():
    #    global var
        var = 13
        return var
    
    print(change_var())
    print(var)
    
    输出结果：
    把global注释掉，输出 13,12
    不注释global，输出13,13
    可以通过在代码中添加print（id（var））来看看，各个变量var的地址是否相同

（1）如果函数中的变量与全局变量重名的话，解释器会把函数内的变量当成局部变量，重名归重名，但不是同一个变量  
（2）如果想修改全局变量，需要通过关键字global去声明这个变量，这样就可以在函数中修改全局变量，一旦在函数中加了global，则这个函数中，这个名字的变量都是用的全局变量

结论：自己定义的函数变量，不要跟全局变量重名

### 36.内建函数eval，是把字符串当做命令去执行 ###

参考博客：[https://www.cnblogs.com/dadadechengzi/p/6149930.html][https_www.cnblogs.com_dadadechengzi_p_6149930.html]  
博客中有更多示例

内建函数eval，是把字符串当做命令去执行  
将字符串str当成有效的表达式来求值并返回计算结果  
**函数定义：**

eval(expression, globals=None, locals=None)

参数  
expression：是一个参与计算的python表达式  
globals： – 变量作用域，全局命名空间，是可选的参数，如果设置属性不为None的话，就必须是dictionary对象了  
locals也：– 变量作用域，局部命名空间，是一个可选的对象，如果设置属性不为None的话，可以是任何map对象了

返回值  
返回表达式计算结果。

eval(expression, globals=None, locals=None) — 官方文档中的解释是，将字符串str当成有效的表达式来求值并返回计算结果。globals和locals参数是可选的，如果提供了globals参数，那么它必须是dictionary类型；如果提供了locals参数，那么它可以是任意的map对象。

python是用命名空间来记录变量的轨迹的，命名空间是一个dictionary，键是变量名，值是变量值。  
当一行代码要使用变量 x 的值时，Python 会到所有可用的名字空间去查找变量，按照如下顺序:  
1）局部名字空间 - 特指当前函数或类的方法。如果函数定义了一个局部变量 x, 或一个参数 x，Python 将使用它，然后停止搜索。  
2）全局名字空间 - 特指当前的模块。如果模块定义了一个名为 x 的变量，函数或类，Python 将使用它然后停止搜索。  
3）内置名字空间 - 对每个模块都是全局的。作为最后的尝试，Python 将假设 x 是内置函数或变量。  
python的全局名字空间存储在一个叫globals()的dict对象中；局部名字空间存储在一个叫locals()的dict对象中。我们可以用print (locals())来查看该函数体内的所有变量名和变量值。

example:

a=1
    g={
       'a':20}
    eval("a+1",g)   -- 这里的g，就是全局名字空间中的dict，g={
       'a':20}
    -- 返回21
    
    
    #test eval() and locals()
    x = 1
    y = 1
    num1 = eval("x+y")
    print (num1)
    
    def g():    
        x = 2    
        y = 2  
        num3 = eval("x+y")    
        print (num3)        
        num2 = eval("x+y",globals())   
        #num2 = eval("x+y",globals(),locals())    
        print (num2)
    
    g()
    
    print locals()["x"]
    print locals()["y"] 
    print globals()["x"]
    print globals()["y"]
    
    num1的值是2；num3的值也很好理解，是4；
    num2的值呢？由于提供了globals()参数，那么首先应当找全局的x和y值，也就是都为1，那么显而易见，num2的值也是2。
    如果注释掉该句，执行下面一句呢？根据第3)点可知，结果为4

**eval函数的妙用：**  
eval函数就是实现list、dict、tuple与str之间的转化  
str函数把list，dict，tuple转为为字符串

**字符串转换成列表**

>>> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
    >>> print(type(a))
    <type 'str'>
    >>> b = eval(a)
    >>> type(b)
    <type 'list'>
    >>> print(b)
    [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
    >>>

**字符串转换成字典**

>>> a = "{1: 'a', 2: 'b'}"
    >>> print(type(a))
    <type 'str'>
    >>> b = eval(a)
    >>> print(type(b))
    <type 'dict'>
    >>> print(b)
    {
       1: 'a', 2: 'b'}
    >>>

**字符串转换成元组**

>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
    >>> print(type(a))
    <type 'str'>
    >>> b=eval(a)
    >>> print(type(b))
    <type 'tuple'>
    >>> print(b)
    ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
    >>>

### 37.类的初步认识 ###

class ClassName（FatherClass）：
        def __init__(self, class_args1):
            self.class_args1 = class_args1
    
       def class_func(self):
           return

类实例 ==类对象  
类参数写在\_\_init\_\_里（而不是写在类名后面的括号里，与其他语言不同）类后面的括号中写的是类继承的父类  
类里面所有的函数第一个参数要写成self（不要问为什么，照做就是了），凡是有self的函数，都是类实例函数  
self其实是类实例对象

### 38.初始化 def \_\_init\_\_(self): ###

格式：

def __init__(self, a):
            print（111）
            self.a =a

当类初始化的时候，比如 a = A（‘ss’）  
这个操作会打印出111，因为这个操作会执行**init**()函数

作用：类传参的地方，例如a，调用的时候要传入参数  
用法：类实例属性（例如self.a）在类的整个范围内都可以使用

初始化实例对象的时候会执行\_\_init\_\_函数

### 39.类属性 && 类实例属性 ###

类属性，不需要初始化实例对象就可以使用  
类实例属性，在\_\_init\_\_（）函数的列表中，需要有了实例对象之后才能调用

在程序加载过程中，类属性和类定义，函数一样，会被加载（注册），类实例属性不会，类实例方法会注册，但不执行函数体。

类属性的位置：在\_\_init\_\_函数的前面  
类属性使用场景：  
类似于其他语言中的静态参数，参看41

### 40.继承 ###

参考github脚本class\_inherint.py

### 41.类属性的应用场景 ###

参考 db\_conn\_class\_property.py

### 42.访问控制 public， protected，private ###

在Java，C++，以及PHP中都有对应的关键字，public，protected，private，但是在Python中却没有这些关键字来声明类成员的访问作用域。

在Python中是通过一套命名体系来识别成约的访问范围的  
protected： \_ 函数名开头是一个下划线  
private： \_\_ 函数名开头是两个下划线

在python中所有的以字母开头的成语名称被python命名体系自动识别为public，单个下划线开头的成员被识别为protected，最后双下划线开头的成员被识别为private。

另外，Python不支持诸如C++, Java的根据参数类型与数目的不同而进行的重载(overload)，即只以函数名字做为函数身份的判断，不会依据参数。而且如果出现多个同名函数（不论参数是否数目相同），则以最后一个为准（即后出现的函数将之前的同名函数覆盖）。

参考 protected\_private.py

### 43, python中的self其实就是类实例对象本身 ###

参考 self.py

### 44.单例 ###

监控程序，每次都要建立一个新的数据库连接，监控频繁情况下，需要创建很多很多连接，这个问题如何解决：  
（1）使用前面提到的类属性  
（2）初始化一个类对象，放到全局对象位置，其他想使用类的地方直接使用此对象  
（3）单例（专业处理连接多的问题）  
（4）数据库连接池

单例模式，在类被执行的才连接，不想类属性或者全局类对象一样，程序加载的时候就连接  
是一个函数封装  
通过装饰器的方式调用

场景：通过单例解决mysql等服务连接过多的问题

思路：  
先判断实例是否已经初始化  
如果已经初始化了对象，直接使用初始化的对象  
如果没有，则初始化

参考singleton.py

### 45.闭包 ###

闭包就是你调用了一个函数a，这个函数a返回了一个子函数名字b给你，这个返回的函数b就叫做闭包。

def a()：
    
        def b():
            return 1
    
       return b

所以，通俗的讲，闭包就是，返回子函数名  
作用：使用子函数之外的父函数的变量  
参考 bibao.py

闭包到底是干嘛的？一般用来做装饰器

### 46.装饰器 ###

闭包+函数式编程 = 装饰器

例子参看第五课 6-装饰器.avi

### 47.python中执行shell指令 ###

执行状态（执行成功或失败）和执行结果：code，result  
os.system() 返回code，result输出在console中

>>> 
    >>> import os
    >>> ret = os.system("free -m")
                 total       used       free     shared    buffers     cached
    Mem:         70619       9497      61122          0        212       1510
    -/+ buffers/cache:       7774      62845
    Swap:         4095          0       4095
    >>> print(ret)
    0
    
    
    import commands
    ret = commands.getoutput(shell指令或者脚本)
    code,ret = commands.getstatusoutput(shell指令或者脚本)
    命令不同，返回值的数量不同

py3中，将commands模块融合在了subprocess模块中

### 48.线程 ###

线程能否杀死？正常情况下是不能的。  
线程安全问题如何解决？锁。  
多线程使用锁的话，多线程是不是就成了串行了？只是某一时刻或某一部分串行  
线程的作用是什么？异步、并发

Threading模块

需要掌握老师提供的脚本

t = threading.Thread(target=func\_name,args=\[\])  
t.start

target是需要多线程执行的函数，args是函数的参数

原生调用的内部原理：  
start触发，run是真正执行的  
默认是等待子线程退出，主线程才退出（进程在执行完所有代码时，子线程还未执行完，进程要等待子线程执行完再退出）  
如果setDaemon（True），则不等待（要在子线程start之前设置，否则会报错：RuntimeError: cannot set daemon status of active thread）

主线程退出后，子线程就没了

#不带参数
    import time
    import threading
    
    def sleep():
        time.sleep(5)
        print('5 second')
        return 'money'
    
    t = threading.Thread(target=sleep)
    #t.setDaemen(True)
    t.start()
    
    
    #带参数
    import time
    import threading
    
    def sleep(n):
        time.sleep(n)
        print('sleep %s second' % n)
        return 'money'
    
    t = threading.Thread(target=sleep, args=[3])
    # t = threading.Thread(target=sleep, args=(3,)) 元组必须加逗号
    t.start()
    
    
    #如何获得线程中的返回值？
    #一般很难获得线程中结果，但是如果工作中需要获得结果，怎么办？
    #这种需求很少
    #1.写入数据库
    #2.
    
    # 原生线程的两个缺点：
    #1.传参不得劲儿（用列表还好，用元组容易出错（单个参数没加逗号））
    #2.函数的返回值无法获取

join  
使得线程阻塞到函数执行完成后，主线程才继续进行  
后者传入一个参数，表明阻塞时间，超过该时间之后，就不阻塞了，可以继续执行（不用等线程执行完成）  
参考thread\_join。py  
使用场景是在多线程中，多个线程join，总执行时间，是几个线程中执行时间最长的线程的执行时间。

锁：

from threading import lock
    
    lock = Lock()
    lock.acquire()
    lock.release()

线程池：

from concurent.futures import ThreadPoolExecutor
    t = ThreadPoolExecutor(num)
    t.submit(func_name)

### 49.队列 ###

队列的作用：  
异步：点赞业务（对于实时性要求不是很高，并且对数据库操作）  
系统解耦：订单系统，发货系统  
缓冲流量：秒杀

在python中使用队列  
py2.7 Queue  
py3.x queue

创建：queue.Queue(maxsize)
    往队列中存放元素：put(obj)
    取元素：get() 按顺序取，所以不需要参数
    enpty()
    
    import Queue
    import time
    
    q = Queue.Queue()
    
    for i in range(10):
        q.put(i)
    
    while not q.empty():
        print(q.get())
        time.sleep(0.5)

### 50.异常处理 ###

（1）异常抛错机制  
– 程序运行异常，解释器会首先看当前的执行环境（函数或类）有没有捕获这个异常，有没有try。  
– 当函数里没有找到的话，它会将异常传递给上层的调用函数，看看那里有没有处理。  
– 如果在最外层（全局‘main’）还是没有找到的话，解释器就会退出，同时打印出traceback信息在标准错误里。  
注：当异常发生的时候  
– 代码异常，当前执行流终止，退出  
– 异常信息会打印在标准错误里

怎么样才能不让用户看到报错栈信息，自己又能捕获到报错栈信息呢？可以通过如下形式

import traceback
    print(str(traceback.format_exc())) --可以存储到一个变量里面，记录在日志里

（2）异常信息的组成  
Traceback信息 + 出错类型 + 出错原因

（3）捕获异常的场景  
– 允许代码发生某种类型的异常不需要终止代码，可以捕获异常，继续往下走。  
– 建立数据库连接或者其他的组件连接，使用完不管代码是否异常，都要关闭连接  
– 线程中，代码要进行异常捕获  
– 脚本：入口函数处  
– 需要捕获异常信息用于展示：代码发生异常的时候，需要将异常信息汇报给上层系统，例如代码部署脚本，部署上百个机器，不可能通过登录机器去查找报错

（4）捕获异常的5种方式  
– try 。。。 except 。。。 最常用的一种  
– try… except Exception as e: …print(e) 打印信息不全，只打印报错信息  
– try … except 特定的异常 print  
– try…except … finally …  
–  
（5）异常错误类型

### 51.正则表达式 ###

[https_www.jianshu.com_p_7ef549503c93]: https://www.jianshu.com/p/7ef549503c93
[https_www.cnblogs.com_dadadechengzi_p_6149930.html]: https://www.cnblogs.com/dadadechengzi/p/6149930.html