Python 知识点大杂烩

• Jpython是Java语言开发的Python解析器，PyPy是使用Python语言开发的Python解析，IronPython是.net平台上实现的Python解析器。CPython使用C语言开发的解析器，也是默认的Python解析。
• Python3中已经删除的raw_input函数。使用input函数用以获取用户输入。
• id函数用以查询对象的ID.
• 对Python变量的掌握，变量区别大小写，不用事先声明类型，但使用前必须赋值。
• Python数值对象中的无穷数的掌握，inf加减任何数结果都是inf。
• Python中range对象默认起止参数的理解。range(5)返回对象中包含0,1,2,3,4，而不是1，2，3，4，5。
• x = 3==3, 5

考察了对Python中赋值及表达式的运用。x=3先进行赋值，再进行比较后得到True，后边的逗号使用该句的返回值变成一个tuple，5为普通数字。

• 对Python迭代器的理解。for循环即是对可迭代对象持续进行next调用直到结束。
• Python中可变对象与不可变对象的理解 。不可变对象是指不可以被其引用所改变的对象。可变对象是指可以被其引用所改变的对象。
• Python中三元表达式的掌握

a=15

True if a!=5 else False

• Python标识符不能以数字开始。
• 可变数据类型（列表）的使用，以及列表的索引赋值的使用。set本身是无序且不重复的，因此，它不能够通过索引及切片进行访问。
• Python中运算符的顺序理解，**优先级高于*。
• Python函数中return关键词的使用，无return时，函数依旧会返回一个类型为NoneType的对象None。
• Python中在定义函数时，括号内的参数成为形参，形参的特点是形参就是变量名。而实参是指在调用函数时，括号内的参数成为实参，实参的特点是实参就是变量值
• 无论是类变量还是实例变量，通常都设计为私有变量，然后通过指定的方法作为接口供外部访问，这样能保证数据的封装性。
• 查看局部变量使用locals()，可以使用sys库中的getrefcount方法用于查看，一个对象被引用多少次。正则表达式基本知识点。s代表space
• sorted本身是一个高阶函数，参数key接收传入函数及参数，并进行重新排序。默认升序
• 复数之间无法比较,（3 > 2 > 2）是两次比较。数字和字符串无法直接进行比较。。字符串可以进行比较，按ASCII编码的大小进行比较。可以使用ord函数查看。
• 表示复数的语法是real + image j ，虚部必须后缀j，且必须是小写，复数对象之间无法进行比较
• 对函数式编程思想的理解，函数是第一等公民first class,是指它享有与变量同等的地位，高阶函数可以接收入另一个函数作为其输入参数，也可以被return，函数式编程中，变量可以指向函数
• set的初始化可以是set(),也可以是{}，但frozenset的初始化参数只有一个。
• 正则表达式需要好好复习：http://www.runoob.com/python/python-reg-expressions.html
• 100000000L Python2中的长整形变量的初始化及表示，在3中被取消了，因为赋值会出现。
• 排序算法中初始数据集的排列顺序对算法的性能无影响的是堆排序
• heapq是Python自带的完全二叉树结构的类型，queue是Python自带队列类型，deque是双端队列，Python中List自带的append和pop方法，实现上就是一个的Stack。
• 迭代器和生成器都是Python中特有的概念，迭代器可以看作是一个特殊的对象，每次调用该对象时会返回自身的下一个元素。 一个可迭代的对象必须是定义了__iter__()方法的对象（如列表，元组等），而一个迭代器必须是定义了__iter__()方法和next()方法的对象。生成器实现了迭代器协议，但生成器是边计算边生成达到节省内存及计算资源
• 在Python中不允许前向引用，即在函数定义之前，不允许调用该函数。

函数的嵌套

1 python支持嵌套函数； 

2 内层函数可以访问外层函数中定义的变量，但不能重新赋值（rebind）； 

3 内层函数的local namespace不包含外层函数定义的变量

Python中的self

在Python中的类Class的代码中，常看到函数中的第一个参数，都是self。以及Class中的函数里面，访问对应的变量（读取或者写入），以及调用对应的函数时，都是

①self.valueName

valueName：表示self对象，即实例的变量。与其他的，Class的变量，全局的变量，局部的变量，是相对应的。

②self.function()的形式。

function：表示是调用的是self对象，即实例的函数。与其他的全局的函数，是相对应的。

Python中为何要有self

在类的代码（函数）中，需要访问当前的实例中的变量和函数的，即，访问Instance中的：

对应的变量（property)：Instance.ProperyNam，去读取之前的值和写入新的值

调用对应函数（function）：Instance.function()，即执行对应的动作

> 而需要访问实例的变量和调用实例的函数，当然需要对应的实例Instance对象本身

-> 而Python中就规定好了，函数的第一个参数，就必须是实例对象本身，并且建议，约定俗成，把其名字写为self

-> 所以，我们需要self（需要用到self）

while i < len(nums):#for i in range(len(nums)): Python一大坑，循环中对循环变量的修改并不会改变i的迭代

 

reshape = r*[[0]*c]

第一个“*”是（浅）拷贝了同一个引用，每个对象指向同一块内容, 应该使用：

reshape = [[0]*c for _ in range(r)]

 

• sys是python中的系统模块，sys.path.apped是增加python模块的搜索路径。
• append方法会将一个对象作为一个元素添加到列表对象的最右侧。与之相对的是extend方法：extend方法会将一个可迭代对象中的每个元素，依次添加到列表对象的最右侧。
• list对象+号操作符的使用，以及len的使用。+号用于连接两个列表对象，返回一个新列表中包含两个列表中的每个元素。
• tuple对象的理解。tuple对象一经建立，便无法再对其进行添加，删除等操作。tuple可以认为是只读的list
• 函数对象的理解，lambda是匿名函数，因此它的type和普通函数一样，也是function。
• Python中变量作用域的掌握。当在函数中使用global关键字时，即代表使用的是全局变量。这时对该变量的变更，即便是函数结束后，也会存在。
• 函数调用的掌握。调用函数时使用()小括号，返回的是函数执行后的结果。即使是只有pass语句，没有return，函数依旧会返回一个None对象。
• 对高阶函数map的使用，map函数的工作流程是接收一个处理函数，和一个可迭代对象。然后将可迭代对象中的元素一个一个传递给处理函数去处理，由处理函数负责对元素进行映射后返回。
• 对高阶函数filter的使用，filter函数的工作流程是接收一个处理函数，和一个可迭代对象。然后将可迭代对象中的元素一个一个传递给处理函数去处理，由处理函数负责对元素进行处理后，选择返回是True,或False，然后将所有可迭代对象中位置为True的元素进行返回。
• 对对象中__dict__的掌握。 __dict__除了能返回的是一个字典，key为对象的属性，value为属性的值。还可以对对象直接新增属性。
• 对类中__doc__，及字符串切片访问的掌握。 __doc__是Python中类的用法属性，通常为在类及函数定义时的第一行字符串，作为文档共使用者使用.__doc__进行调用。返回值是字符串类型。
• 对Python函数中的定长参数及不定长定位参数的掌握。 param1参数在本例中对应的传入参数apples,而后边的'bananas', 'cherry', 'kiwi'均被打包进param2中，因为在函数定义时param2的前边有*号表示这是一个不定长定位参数,会将后边的不定长个定位参数打包为一个tuple。
• 对 Python 函数中的定位参数，不定长定位参数的掌握。本题中将 nums 这个含有 4 个元素的列表对象作为参数传递给 myfoo 函数。但 myfoo 函数声明时接收 4 个参数，个数是匹配的。这时在 nums 前边加入*号，代表将 nums 列表对象进行解包后传参。另外需注意的是定位参数的位置这个重要的特性。

def myfoo(x,y,z,a):
    return x + z 
nums = [1,2,3,4] 
myfoo(*nums)

• 对BIFs中getattr及setattr的掌握。 setattr可以对一个对象动态添加属性，而getattr负责读取某类的指定属性的值。
• 对深度拷贝的掌握。 深度拷贝是将原对象中所有的值完全复制一份存放在内存中(包括可变数据类型对象)。这样遇到原对象即使是更改，也不会影响其值。
• 对浅拷贝的掌握。 当使用切片[:]访问，工厂函数（如list/dir/set），copy模块中的copy()函数均引起浅拷贝。 对列表进行浅拷贝后，当修改的元素为可变对象时，修改操作会修改原列表。
• 类初始化对象的掌握。 __new__ 用来创建实例，在返回的实例上执行__init__，如果不返回实例那么__init__将不会执行 __init__ 用来初始化实例，设置类及实例属性，调用方法等操作。
• 使用字符串的join函数对列表的进行分割，及文本换行符的掌握。 字符串有join函数 print ("\n".join(names))
• 使用字典对象的key值使用的掌握。 字典中key，可以是字符串，数字等不可变类型，它们都是hashable的。而字典，列表等可变类型是不能够作为key值的，会直接报错。
• 使用字典对象的key值在使用整型与浮点型时使用. 使用confusion[1.0]与使用confusion[1]没有区别。
• 使用对pickle序列化对象的掌握。 将一个对象序列化保存至一个文件中，并将其从文件中恢复后，其属性值会恢复至当时序列它的状态，并会覆盖同名对象。
• 使用对不可变对象的掌握。 字符串型对象可以通过索引或切片进行访问，但无法进行赋值。

url='julyedu.ai' 

url[-3:-1]='.com' 报异常！！！

• 对基本数据类型，以及Python标识符命名规范的掌握。 list在Python中是内置的函数，用以进行初始化列表或进行强制转换，本题中一开始定义了一个变量就叫list，这样就会使得对list函数的引用被替换，相应操作都无法进行。 因此list是一个不合理的标识符。

list=[1,2,3] 
list.append(4)+ list('abc')

• 对Python中模块类型的掌握 __builtins__是python内置模块，其中包括了非常多非常有用的函数，也被叫做Python自带电池。__builtins__本身是一个模块module
• 对Python中元组类型的掌握。 元组可以理解为不可变更的列表，一旦初始化后，无法对其进行添加，修改，删除。但这里的不可修改针对是不可变数据，而对于可变数据类型，如本题的列表，依旧可以被修改。因此B选项正确，且不会有异常报错。

t1=(1,2,3,[1,2,3])

t1[-1][-1]=4

t1

• 对复数类型的掌握。 Python中的复数类型由实部与虚数组合构成。并且两个虚数对象无法进行比较。
• 对类中默认方法权限的考察。 在Python类的，私有方法和变量的定义需要在其名称前加_ _，如果没有_ _进行标识，默认均为公有方法。
• 对类中成员属性的定义的掌握。 在Python类中，公有/私有变量是通过_ _进行区别，而在方法之外的变量均为类变量，实例变量均在方法中进行定义且以self.开始
• 对Python常见错误返回值的掌握。Python是弱类型语言，可以不用声明类型直接进行赋值，但无法直接去使用一个还未赋值（对象）的变量。否则会报NameError。
• 对Python常见错误处理语句的掌握。 try..catch ；assert；with均可对异常进行捕获，但if elif是用于逻辑判断，不适宜进行异常捕获。
• 对Python变量作用域及哪些对象会引入作用域的考察。 在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域。Python的变量名解析机制也称为 LEGB 法则：本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）
• 对Python中类的实例方法的掌握。 类中任何实例方法，第一个参数都必须是self,用以指向该实例本身。cls为类方法中的第一个参数。@staticmethod为类中静态方法，@classmethod类方法定义前的装饰器
• dict([['one',1],['two',2]])的返回是

>>> dict([['one',1],['two',2]])

{'one': 1, 'two': 2}

对从列表出初始化字典对象的运用。一个列表对象包含的每个列表对象为新字典对象的item，每个元素的第0，1个元素分别对应item为key,value.

• 对list对象相关运算的掌握。list对象仅能与list对象进行相加。与其它类型对象相加均会报出如unsupported operand type(s) for +: 'int' and 'list'的错误。

>>> l1=[1,2,3]

>>> 1+l1 Traceback (most recent call last): File "<pyshell#13>", line 1, in <module> 1+l1

TypeError: unsupported operand type(s) for +: 'int' and 'list'

>>>

• 对Python中取余数运算符的掌握，/为除法，//为取整（Python3中）。Python中没有mod关键字进行运算。
• 对Python中BIF exec的掌握，exec意为执行，即执行一个声明。Python中的语句分别表达式与声明，声明statement是对变量进行赋值，函数，类的定义等操作，一般不返回信息。而表达式Expression则是对执行某具体代码，对象求值的操作，一般会返回信息。 exec主要用于是执行字符串中的Python声明。

>>> exec('l1=[1,2,3]')

>>> l1 [1, 2, 3]

• 对Python中BIF eval的掌握，eval意为求值，即对一个对象进行求值。Python中的语句分别表达式与声明，声明statement是对变量进行赋值，函数，类的定义等操作，一般不返回信息。而表达式Expression则是对执行某具体代码，对象求值的操作，一般会返回信息。 eval主要用于是执行字符串中的Python表达式。但该题中给eval的是一个声明（赋值），因此报错

>>> eval('l1=[5,7,9]')

Traceback (most recent call last): File "<pyshell#0>", line 1, in <module> eval('l1=[5,7,9]') File "<string>", line 1 l1=[5,7,9]

• 对Python中range对象参数初始化的理解，同时也考察了对切片访问的掌握。参数中的两个冒号分割了三个参数，开始，终点（不含），步长。
• 对Python类中魔法函数的使用，类中重写__str__魔术方法就能够在对象被print(对象名)时返回特定信息。__init__是用初始化对象时触发，__cmp__用于对象的比较时触发，__repr__和__str__这两个方法都是用于显示的，当我们想在不同环境下支持不同的显示，例如终端用户显示使用__str_，实际上__str__只是覆盖了__repr__以得到更友好的用户显示。

主题是魔术方法。 什么是魔术方法?他们是面向对象的Python的一切。他们是可以给你的类增加”magic”的特殊方法。他们总是被双下划线所包围(e.g. __init__ 或者 __lt__)。然而他们的文档却远没有提供应该有的内容。Python中所有的魔术方法均在Python官方文档中有相应描述，但是对于他们的描述比较混乱而且组织比较松散。很难找到有一个例子(也许他们原本打算的很好，在开始语言参考中有描述很详细，然而随之而来的确是枯燥的语法描述等等)。

• 对字符串格式化输出的掌握。%f是浮点数的占位符，小数点后代表保留的小数，小数点前代表保留的整数位，D项中的0代表用0填充空余的位数。

要将 3.1415926 变成 00003.14 如何进行格式化输出? "%08.2f"% 3.1415629

• 对逻辑运算符or的掌握，or为或，取两个表达式中为True的返回。如果两个表达均为True,则取最左边。

表达式'x' or 'y' or []的返回值为 'x'

• 当在命令行中以python my.py v1 v2形式运行python脚本时,通过 from sys import argv 如何获得v2 的参数值?argv[2]

sys模块中argv负责接收命令行传入的参数，其中argv[0]为文件名，argv[1]为第一个参数，依次类推。

>>> a=lambda x,y=2:x+y

>>> a(5)

7

>>> a=lambda *x:x

>>> a(7,'月')

(7, '月')

>>> {}.fromkeys((1,2),3)

{1: 3, 2: 3}

• 对Python类中方法装饰器的使用。@property装饰器将方法变为属性，@staticmethod将方法变为静态方法，@classmethod是将方法变为类方法
• fromkeys是字典对象提供的方法，用于创建一个新字典，以第一个参数中的元素做字典的键，第二个参数为字典所有键对应的初始值。
• 对Python标准库的了解，dbm是Python提供的数据库管理库，可满足对键值配对持久化的要求。OrderedDict是有序字典，namedtuple创建一个只读的的对象，拥有可以被访问的属性。defaultdict较于普通字典对象可以指定key对应的value的类型，并总有默认value对应key.
• 对Stackless Python的掌握（Python中重要的多线程模块），Stackless并非以库的形式和Python整合，Stackless提供的并发建模工具，比目前其它大多数传统编程语言所提供的工具都更加易用： 不仅用于Python自身，也包括Java、C++，以及其它语言。
• Python在导入时的重命名关键就是as，例如我们常常用import numpy as np或import tensorflow as tf。使用as关键字一方面避免重名，另一方面也可以简化库的调用。
• Scrapy是Python进行网络抓取的第三方库，scrapy中可以用Xpath；scrapy中可以用正则；scrapy中可以用BeautifulSoup；三项均为在Scarpy中可以使用的HTML解析方式。“scrapy必须重写中间件”是错误的，因为Scrapy中，middlewares的重写不是必要的。
• Scrapy是Python进行网络抓取的第三方库，Scrapy框架中组件包括，Scrapy引擎，下载器，爬虫，调度器，Item Pipeline以及中间件。不包括沟通隧道（connect）。

>>> b = 2*a/ 4
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    b = 2*a/ 4
NameError: name 'a' is not defined
>>> a = "one"
>>> b = 2*a/ 4
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    b = 2*a/ 4
TypeError: unsupported operand type(s) for /: 'str' and 'int'

 

• 解释型语言的程序代码由相应语言的解释器“翻译”成目标代码(机器语言)后执行，因此效率比较低，而且不能生成可独立执行的可执行文件，应用程序不能脱离其解释器而运行。
• Requests库中的get和post用于不同方式请求网络资源,head方法用于查看返回头部信息
• 对Python中字符串对象提供的相应函数的掌握，strip()常用于去掉字符串两侧空格或指定字符。lstrip是只去除左边空格,rstrip是只去除右边空格
• 对Python3中字符串编码的掌握，Python 2下中文常会碰到各种编码问题，而Python3字符默认编码为utf-8，每一个字符(包括标点)的长度都被计算为1
• 对Python3中字符串打印时的常用换行功能的掌握。使用\换行:是在Python代码过长需要换行时使用。转义符和空格都无法换行。在字符串中添加\n才能让字符串被打印时换行。
• 对Python3函数中的参数可变的理解与掌握，Python3中的数据类型分为可变与不可变类型，函数的传入参数也是一样。如果传入的参数类型是可变类型，如果在函数体中被改变，则原参数也会被改变。
• Python数据抓取工作中对HTTP相应知识的掌握。100 继续客户端当继续发送请求 102 继续处理 201 (SC_CREATED)表示服务器在请求的响应中建立了新文档；应在定位头信息中给出它的URL。202请求被接受，但处理未完成.
• Python数据抓取工作中对HTTP相应知识的掌握。ContentType属性指定响应的 HTTP内容类型。content-Type用于定义网络文件的类型和网页的编码，决定文件接收方将以什么形式、什么编码读取这个文件，如果未指定 ContentType，默认为TEXT/HTML。

>>> a_var = 'global value'
>>> def outer():
    a_var = 'enclosed value'
    def inner():
        a_var = 'local value'
        print(a_var)
    inner()

    
>>> outer()
local value	

• 不能创建一个字典的语句：

>>> dict3 = {[1,2,3]: "uestc"}
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    dict3 = {[1,2,3]: "uestc"}
TypeError: unhashable type: 'list'

字典类型 dict 的键值必须是不可变的，元祖不可变，可以被哈希

>>> dict4 = {(1,2,3): "uestc"}
>>> dict4
{(1, 2, 3): 'uestc'}

• Python 中的 tuple 结构为 “不可变序列”，用小括号表示。为了区别数学中表示优先级的小括号，当 tuple 中只含一个元素时，需要在元素后加上逗号。

详情可参考文档中的解释：

• Using a trailing comma for a singleton tuple:a,or(a,)
• 字符串前加 r 是指该字符串为raw string 不要对该字符串进行转义
• 字符串前加 b： 意为以 bytes 字节形式表示
• 字符串前加 u：Unicode编码的书写方式 a = u’中文’
• 通常情况下，UTF-8 编码下，汉字占 3 个字节，英文占 1 个字节。（1 个字节 = 8 bit）
• Python 中字符串的前导 r 代表原始字符串标识符，该字符串中的特殊符号不会被转义，适用于正则表达式中繁杂的特殊符号表示。

最典型的例子，如要输出字符串 \n，由于反斜杠的转义，因此一般的输出语句为：

1	print "\\n"

这里的 \\ 将被转义为 \ 。而采用原始字符串输出时，则不会对字符串进行转义：

1	print r"\n"

• 新式类：class 类（object基类）

继承类：class 子类（父类1[,父类2，父类3]）#在继承元组中列了一个以上的类，那么它就被称作"多重继承" 

sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

issubclass() 函数用于判断参数是否是类型参数的子类。

class A(object):#新式类，相当于A继承object基类
pass
class B(A):#B类继承A类
pass
b = B()#实例化

• 下列对象的布尔值都是False：

NONE;
False(布尔类型)
所有的值为零的数
0（整型）
0.0（浮点型）
0L(长整型)
0.0+0.0j(复数)
""(空字符串)
[](空列表)
()(空元组)
{}(空字典)

xrange() 函数用法与 range 完全相同，
        所不同的是生成的不是一个数组，而是一个生成器。
0的任何次方的值都为1
所以答案为:
                0**0=1 , 1**1=1, 2**2=4

Python2 与 Python3 均不支持复数比较大小，Python2 中会抛出以下错误：

TypeError: no ordering relation is defined for complex numbers

Python3 中会抛出以下错误：

TypeError: '>' not supported between instances of 'complex' and 'complex'

数字类型的比较可参考：

Python2 Numeric Types

Python3 Numeric Types

Python2 与 Python3 均支持连续比较，相当于 3>2 and 2>2，后一个判断式为假，因此整个表达式都为假。可参考官方文档：

Python2 Comparisons

Python3 Comparisons

Python2 支持数字与字符串之间的比较，而 Python3 则不支持，会报以下错误：

TypeError: '>' not supported between instances of 'int' and 'str'

• tuple 的比较是从两者的第一个元素的 ASCII 码开始，直至两个元素不相等为止，若前面元素都相等，则元素个数多的 tuple 较大。

1 2 3 4

(1,9) < (2,3) # True (8,9) < (1,2,3) # False (1,2,3) == (1,2,3) # True (3,2) < ('a','b') # True

1、__name__这个系统变量显示了当前模块执行过程中的名称，如果当前程序运行在这个模块中，__name__ 的名称就是__main__如果不是，则为这个模块的名称。 

2、__main__一般作为函数的入口，类似于C语言，尤其在大型工程中，常常有if __name__ == "__main__":来表明整个工程开始运行的入口。

https://blog.youkuaiyun.com/iamoldpan/article/details/78077983

• 在 Python 中万物皆为对象，函数也不例外，函数作为对象可以赋值给一个变量、可以作为元素添加到集合对象中、可作为参数值传递给其它函数，还可以当做函数的返回值，这些特性就是第一类对象所特有的。

详情请参考：

https://www.cnblogs.com/smallmars/p/6936871.html

• python中主要存在四种命名方式：

1、object #公用方法

2、_object #半保护

                 #被看作是“protect”，意思是只有类对象和子类对象自己能访问到这些变量，

                  在模块或类外不可以使用，不能用’from module import *’导入。

                #__object 是为了避免与子类的方法名称冲突， 对于该标识符描述的方法，父

                  类的方法不能轻易地被子类的方法覆盖，他们的名字实际上是

                  _classname__methodname。

3、_ _ object  #全私有，全保护

                       #私有成员“private”，意思是只有类对象自己能访问，连子类对象也不能访

                          问到这个数据，不能用’from module import *’导入。

4、_ _ object_ _     #内建方法，用户不要这样定义

当args与位置参数和默认参数混用的情况下：（注意三者的顺序）

示例一、（三者顺序是:位置参数、默认参数、*args）

1 2 3

def foo(x,y=1,*args):      pass foo (1,2,3,4,5) // 其中的x为1，y=1的值被2替换，3,4,5都给args，即args=(3,4,5)

示例二、（三者顺序是:位置参数、*args、默认参数）

1 2 3

def foo(x,*args,y=1):      pass foo (1,2,3,4,5) // 其中的x为1，2,3,4,5都给args，即args=(2,3,4,5),y始终为1

**kwargs：（表示的就是形参中按照关键字传值把多余的传值以字典的方式呈现）

关于**kwargs与位置参数、*args、默认参数混着用的问题：（注意顺序）

位置参数、*args、**kwargs三者的顺序必须是位置参数、*args、**kwargs，不然就会报错：

示例：

1 2 3 4

def foo(x,*args，**kwargs):      pass foo (1,2,3,4,y=5,a=6,b=7) // 其中的x为1，2,3,4都给args，即args=(2,3,4),y=5,a=6,b=7以字典形式传给kwargs, 即kwargs={'y':5,'a':6,'b':7}

Python3参数顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

 

@dec 装饰器，先执行dec(), 并将 @dec 下面的 函数 作为dec()的参数。 （装饰器的作用：为已经存在的对象添加额外的功能）

• __init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。
• __new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例，是个静态方法。

即，__new__在__init__之前被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。

• 线程由操作系统控制，协程由程序自身控制；协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。
• 协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
• sys.argv是传递给python脚本的命令行参数【字符串】列表 ，argv[0]为该脚本自身路径，其余为命令行参数
• 字符串编译的过程：gbk==>unicode==>utf16==>url解码 ；字符串解码顺序为：url解码==>utf16==>unicode==>gbk
• 元组特性：1.有序（所以可索引可切片）

                          2.不可修改

>>> a = (1, 2, 3)
>>> a[1:-1]
(2,)

Python多进程

参考回答：

方式一: os.fork()

方式二:使用multiprocessing模块:创建Process的实例，传入任务执行函数作为参数

方式三:使用multiprocessing模块:派生Process的子类，重写run方法

方式四:使用进程池Pool