Python
目录
- Python3API
- python 2.7 与3.5 的差别
- 当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行
#!/usr/bin/env python3 # -*- coding: utf-8 -*- #第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释； #第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。 #申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：
基本语法
- 指数运算符
**， 位运算符与C一致,左移和右移 N 位等同于无溢出检查的 2 的 N 次幂运算：2**N - Python 3中
3 / 2 = 1.5 3 // 2 = 1 3 / 2.0 = 1.5 3 // 2.0 = 1.0（//是地板除，而/和数学中的/是一样的） - 不支持
--和++, - python注释的三种方法：
#号注释单行- 三个单引号或三个双引号注释语句块
" " " - 井号加两个百分号画出语句块分界线
#%%
- 逻辑运算符是
andornot, 而不是&&，||，! True和Flase- 由于Python中的变量存放的是对象引用，所以对于不可变对象而言，尽管对象本身不可变，但变量的对象引用是可变的。不可变的对象的特征没有变，依然是不可变对象，变的只是创建了新对象，改变了变量的对象引用。对于可变对象其对象的内容是可以变化的。当对象的内容发生变化时，变量的对象引用是不会变化的。
- 可变类型 列表， 字典（list，dictionary）
- 不可变类型 数字、字符串、元组（int，string，float，tuple）
- 序列：字符串、列表和元组：下标是从0开始的与C一样
- seq[ind] 获得下标为 ind 的元素
- seq[ind1:ind2] 获得下标从 ind1 到 ind2 间的元素集合
- seq * expr 序列重复 expr 次
- seq1 + seq2 连接序列 seq1 和 seq2
- obj in seq 判断 obj 元素是否包含在 seq 中
- obj not in seq 判断 obj 元素是否不包含在 seq 中
- 代码块缩进对齐：代码块通过缩进对齐表达代码逻辑而不是使用大括号，因为没有了额外的字符，程序的可读性更高。而且缩进完全能够清楚地表达一个语句属于哪个代码块。当然，代码块也可以只有一个语句组成。
- 引用计数：要保持追踪内存中的对象， Python 使用了引用计数这一简单技术。也就是说 Python 内部 记录着所有使用中的对象各有多少引用。你可以将它想像成扑克牌游戏“黑杰克”或“21 点”。 一个内部跟踪变量，称为一个引用计数器。至于每个对象各有多少个引用， 简称引用计数。当 对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的 引用计数变为 0 时， 它被垃圾回收。（严格来说这不是 100%正确，不过现阶段你可以就这么认为）
- Python 不支持方法或函数重载
- Python 的普通整数相当于标准整数类型，不需要类似 C 语言中的 int, short, long 这三 种整数类型。事实上 Python 的整数实现等同于 C 语言的长整数。 由于 Python 的整型与长整型 密切融合， 用户几乎不需要担心什么。 你仅需要使用一种类型， 就是 Python 的整型。即便 数值超出整型的表达范围， 比如两个很大的数相乘， Python 会自动的返回一个长整数给你而 不会报错。
- 深拷贝–创建一个新的容器对象, 包含原有对象元素（引用）全新拷贝的引用–需要
copy.deepcopy()函数。copy 模块中有且只有两个函数可用copy()进行浅拷贝操作,而deepcopy()进行深拷贝操作. python支持assert语句
字符串：
Python 中字符串被定义为引号之间的字符集合。Python 支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可以用来包含特殊字符。使用索引运算符( [ ] )和切片运算符( [ : ] )可以得到子字符串。字符串有其特有的索引规则：第一个字符的索引是 0，最后一个字符的索引是 －1加号( + )用于字符串连接运算，星号( * )则用于字符串重复。
- 格式话字符串：只适用于字符串类型，非常类似于 C 语言里面的 printf()函数的字符串格式化。例子如下：
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000) 'Hi, Michael, you have $1000000.' - 如果字符串内部既包含’又包含"怎么办？可以用转义字符\来标识，比如：
'I\'m \"OK\"!'表示的字符串内容是：I'm "OK"!也可以通过三引号解决。 - 三引号：虽然你可以用单引号或者双引号来定义字符串，但是如果你需要包含诸如换行符这样的特 殊字符时，单引号或者双引号就不是那么方便了。 Python 的三引号就是为了解决这个问题的， 它允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
- Python 把硬编码的字符串叫做字面上的字符串,默认所有字面上的字符串都用 ASCII 编码， 可以通过在字符串前面加一 个’u’前缀的方式声明 Unicode 字符串，这个’u’前缀告诉 Python 后面的字符串要编码成 Unicode 字符串。
>>> u"Hello World" # Unicode string
列表[]和元组()
- 列表和元组有几处重要的区别。列表元素用中括号[ ]包裹，元素的个数及元素的值可以改变。元组元素用小括号( )包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。通过切片运算( [ ] 和 [ : ] )可以得到子集
- 列表：
- 可以用 append()方法来追加元素到列表中
- 要删除列表中的元素,如果你确切的知道要删除元素的素引可以用 del 语句, 否则可以用 remove()方法.
motorcycles = ['honda', 'yamaha', 'fantast'] del motorcycles[0] motorcycles.remove('honda') motorcycles.pop(0) # motorcycles.pop() 删除的是'fantast'
- 元组：
- 元组是跟列表非常相近的另一种容器类型.元组和列表看起来不同的一点是元组用的是圆括号而列表用的是方括号。而功能上,元组和列表相比有一个很重要的区别,元组是一种不可变类型
- 删除一个单独的元组元素是不可能的,当然,把不需要的元素丢弃后, 重新组成一个元组是没有问题的。跟数字和字符串一样,元组也是不可变类型,就是说你不能更新或者改变元组的元素。
- 虽然元组对象本身是不可变的，但这并不意味着元组包含的可变对象也不可变了。比如元组中有一个元素是列表，则我们可以改变这个列表的值。
字典{}
- 类似于哈希表，由键- 值(key-value)对构成。字典元素用大括号({ })包裹， 例：
d = {'Michael' : 95, 'Bob' : 75, 'Tracy' : 85} >>> d['Michael'] 95 - 遍历一个字典的语句为
for eachKey in myDict.keys()可以缩写为for eachKey in myDict。另外, Python 还引进了三个新的内建字典方法来定义迭代:myDict.iterkeys()(通过 keys 迭 代),myDict.itervalues()(通过 values 迭代), 以及myDicit.iteritems()(通过 key/value 对 来 迭 代 ) - 更新字典：
dict2['name'] = 'venus'# 若有则更新已有条目，若没有则增加新条目。dict.update(dict2)将字典 dict2 的键-值对添加到字典 dict -
如何删除字典元素和字典：
```python del dict2['name'] # 删除键为“name”的条目` dict2.clear() # 删除 dict2 中所有的条目` del dict2 # 删除整个 dict2 字典` dict2.pop('name') # 删除并返回键为“name”的条目` ```
集合
- 集合(sets)有两种不同的类型，可变集合(set) 和 不可变集合(frozenset)
- 集合被创建的唯一方法 - 用集合的工厂方法 set() 和 frozenset()。
-
s = set('cheeseshop') # >>> s set(['c', 'e', 'h', 'o', 'p', 's']) t = frozenset('bookshop') # >>> t frozenset(['b', 'h', 'k', 'o', 'p', 's']) >>> s.add('z') # set(['c', 'e', 'h', 'o', 'p', 's', 'z']) >>> s.update('pypi') # set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y', 'z']) >>> s.remove('z') # set(['c', 'e', 'i', 'h', 'o', 'p', 's', 'y']) >>> s -= set('pypi') # set(['c', 'e', 'h', 'o', 's'])
条件和循环：
if elif elsepass语句 ：什么也不做- 你可以在 while 和 for 循环中使用 else 语句.在循环中使用时, else 子句只在循环完成后执行（ break 语句也会跳过 else 块，因为break说明循环没有执行完）.
- 条件表达式（即“三元运算符”） 例：
smaller = x if x < y else y - **for 语句 **, 它提供了 Python 中最强大的循环结构. 它可以遍历序列成员, 可以用在列表解析和生成器表达式中, 它会自动地调用迭代器的next() 方法, 捕获 StopIteration 异常并结束循环(所有这一切都是在内部发生的)
- range() ,该函数会创建一个数值列表：
- range() 的完整语法
range(start, end, step =1) - range() 还有两种简略的语法格式:
range(end) (0到end-1) range(start, end) - xrange() 类似 range() , 不过当你有一个很大的范围列表时, xrange() 可能更为适合, 因为 它不会在内存里创建列表的完整拷贝. 它只被用在 for 循环中, 在 for 循环外使用它没有意义。它的性能远高出 range(), 因为它不生成整个列表
- 与序列相关的内建函数
sorted(), reversed(), enumerate(), zip()例：for album in sorted(nameList) - for 循环迭代不同的序列对象（字符串, 列表, 以及元组）
nameList = ['Walter', "Nicole", 'Steven', 'Henry']- 通过序列项迭代：
for eachName in nameList： - 通过序列索引迭代：
for nameIndex in range(len(nameList))： - 使用项和索引迭代：
for i, eachLee in enumerate(nameList):
- 通过序列项迭代：
- 用于迭代器类型
- 迭代器：
- 对一个对象调用 iter() 就可以得到它的迭代器. 它的语法如下:
iter(obj) 或 iter(func, sentinel )如果你传递一个参数给 iter() , 它会检查你传递的是不是一个序列, 如果是, 那么很简单: 根据索引从 0 一直迭代到序列结束。如 果 是 传 递 两 个 参 数 给 iter() , 它 会 重 复 地 调 用 func , 直 到 迭 代 器 的 下 个 值 等 于 sentinel . -
mytuple = ("apple", "banana", "cherry") myit = iter(mytuple) print(next(myit)) print(next(myit)) print(next(myit)) - 字典的迭代器会遍历它的键(keys). 语句
for eachKey in myDict.keys()可以缩写为for eachKey in myDict。另外, Python 还引进了三个新的内建字典方法来定义迭代:myDict.iterkeys()(通过 keys 迭 代),myDict.itervalues()(通过 values 迭代), 以及myDicit.iteritems()(通过 key/value 对 来 迭 代 ) - 文件对象生成的迭代器会自动调用
readline()方法. 这样, 循环就可以访问文本文件的所有 行 . 程 序 员 可 以 使 用 更 简 单 的for eachLine in myFile替 换for eachLine in myFile.readlines() - 列表解析：
- 语法:
[expr for iter_var in iterable]，列表解析还提供了一个扩展版本的语法:[expr for iter_var in iterable if cond_expr]例：squared = [x ** 2 for x in range(4)], sqdEvens = [x ** 2 for x in range(8) if not x % 2]
- 语法:
- 生成器表达式：它是列表解析的一个扩展。它与列表解析非常相似，而且它们的基本语法基本相同; 不过它并不真正创建数字列表, 而是返回一个生成器，这个生成器在每次计算出一个条目后，把这 个条目“产生” (yield)出来. 生成器表达式使用了"延迟计算"(lazy evaluation), 所以它在使用 内存上更有效. 我们来看看它和列表解析到底有多相似: 列表解析:
[expr for iter_var in iterable if cond_expr]
生成器表达式:(expr for iter_var in iterable if cond_expr)生成器并不会让列表解析废弃, 它只是一个内存使用更友好的结构。
模块和包
- Python 中一个以 .py 结尾的文件就是一个模块，模块中定义了变量、函数等来实现一些类似的功能。Python 有很多自带的模块（标准库）和第三方模块，一个模块可以被其他模块引用，实现了代码的复用性。如果你知道你需要导入的模块是什么, 而它的路径不在搜索路径里, 那么只需要调用列表的 append() 方法即可, 就像这样:
sys.path.append('/home/wesc/py/lib')- 导入模块四种方法
import module1,module2 from 模块名 import 函数名 类名 from 模块名 import 函数名 as 函数别名 import 模块名 as 函数别名
- 导入模块四种方法
- 包是存放模块的文件夹，包中包含
__init__.py和其他模块，__init__.py可为空也可定义属性和方法，在 Python3.3 之前的版本，一个文件夹中只有包含__init__.py，其他程序才能从该文件夹引入相应的模块、函数等，之后的版本没有__init__.py也能正常导入，简单来说就是 Python3.3 之前的版本，__init__.py是包的标识，是必须要有的，之后的版本可以没有。- 导入包的方法:
import 包名.模块名 from 包名 import 模块名 import 包名(注意__init__.py函数的内容)
- 导入包的方法:
函数
- 函数参数传递机制
- 不管什么类型的参数(除列表、字典等可变对象外)，在 Python 函数中对参数直接使用“=”符号赋值是没用的，直接使用“=”符号赋值并不能改变参数。
- 如果需要让函数修改某些数据，则可以通过把这些数据包装成列表、字典等可变对象，然后把列表、字典等可变对象作为参数传入函数，在函数中通过列表、字典的方法修改它们，这样才能改变这些数据。如果只想将引用的副本传入，则可以通过
function_name(list_name[:])实现
- 函数注解
用def add(x:int, y:int) -> int: return x + y: 类型的形式指定函数的参数类型，用-> 类型的形式指定函数的返回值类型。Python 解释器并不会因为这些注解而提供额外的校验，没有任何的类型检查工作。也就是说，这些类型注解加不加，对你的代码来说没有任何影响。但这么做的好处是：让别的程序员看得更明白； 让 IDE 了解类型，从而提供更准确的代码提示、补全和语法检查（包括类型检查，可以看到 str 和 float 类型的参数被高亮提示） - 可变参数列表
def arithmetic_mean(*args): sum = 0 for x in args: sum += x return sum print(arithmetic_mean(45,32,89,78)) print(arithmetic_mean(45,32)) print(arithmetic_mean(45)) print(arithmetic_mean())
错误和异常：
- try 语句有两种主要形式: try-except 和 try-finally . 这两个语句是互斥的, 也就是说你 只能使用其中的一种. 一个 try 语句可以对应一个或多个 except 子句, 但只能对应一个 finally 子句, 或是一个 try-except-finally 复合语句. 你可以使用 try-except 语句检测和处理异常. 你也可以添加一个可选的 else 子句处理没有探测到异常的时执行的代码. 而 try-finally 只允许检测异常并做一些必要的清除工作(无论发生错误与否), 没有任何异常处理设施. 正如你想像的,复合语句两者都可以做到。
- 最 常 见 的 try-except 语 句 语 法 如 下 所 示 . 它 由 try 块 和 except 块 (try_suite 和 except_suite )组成, 也可以有一个可选的错误原因.
try: try_suite # watch for exceptions here 监控这里的异常 except Exception[, reason]: except_suite # exception-handling code 异常处理代码 - finally子句是无论异常是否发生,是否捕捉都会执行的一段代码.你可以将 finally 仅仅配合 try 一起使用,也可以和 try-except(else 也是可选的)一起使用
- else 子句在 try 范围中没有异常被检测到时,执行 else 子句
try: # try-except-else-finally:厨房一锅端try_suite except Exception1: suite_for_Exception1 except (Exception2, Exception3, Exception4): suite_for_Exceptions_2_3_and_4 except Exception5, Argument5: suite_for_Exception5_plus_argument except (Exception6, Exception7), Argument67: suite_for_Exceptions6_and_7_plus_argument except: suite_for_all_other_exceptions else: no_exceptions_detected_suite finally: always_execute_suite
类和对象
- None, Python 的 Null 对象 ：Python 有一个特殊的类型，被称作 Null 对象或者 NoneType，它只有一个值，那就是 None。 它不支持任何运算也没有任何内建方法。如果非常熟悉 C 语言，和 None 类型最接近的 C 类型就 是 void，None 类型的值和 C 的 NULL 值非常相似（其他类似的对象和值包括 Perl 的 undef 和 Java 的 void 类型与 null 值）。 None 没有什么有用的属性，它的布尔值总是 False
- 新式类和经典类声明的最大不同在于： 所有新式类必须继承至少一个父类。如果你的类没有继承任何其他父类，object 将作为默认的父类。如果你没有指定一个父类，或者如果所子类化的基本类没有父类，你这样就是创建了一个经典 类。很多 Python 类都还是经典类。即使经典类已经过时了，在以后的 Python 版本中，仍然可以使用它们。不过我们强烈推荐你尽可能使用新式类
__new__()“构造器”方法：为何我们认为__new__()比__init__()更像构造器呢？这是因为__new__()必须返回一个合法 的实例，这样解释器在调用init()时，就可以把这个实例作为 self 传给它。调用父类的__new__()来创建对象，正像其它语言中使用 new 关键字一样。__del__()"解构器"方法：由于 Python 具有 垃圾对象回收机制（靠引用计数)，这个函数要直到该实例对象所有的引用都被清除掉后才会执行。调用del x不表示调用了x.__del__()------前面也看到，它仅仅是减少 x 的引用计数- 如何定义类：
class ClassName(base_class[es]): "optional documentation string" static_member_declarations method_declarations - 创建一个类（类定义）：
class AddrBookEntry(object): # 类定义 """address book entry class""" def __init__(self, nm, ph): # 定义构造器 self.name = nm #设置 name self.phone = ph #设置 phone print 'Created instance for:', self.name def updatePhone(self, newph): #定义方法 self.phone = newph print 'Updated phone# for:', self.name - 创建实例（实例化）
>>> john = AddrBookEntry('John Doe', '408-555-1212') # 为 John Doe 创建实例。 - 创建子类：除了与父类或基类的关系外，子类与通常的类没有什 么区别，也像一般类一样进行实例化。注意下面，子类声明中提到了父类。python支持多继承
class EmplAddrBookEntry(AddrBookEntry): # class子类名（父类名）父类名可有多个` """Employee Address Book Entry class""" # 员工地址本类 def __init__(self, nm, ph, id, em): # 调用父类构造函数，或者写为super(EmplAddrBookEntry,self).__init__(nm, ph) AddrBookEntry.__init__(self, nm, ph) self.empid = id self.email = em def updateEmail(self, newem): self.email = newem print 'Updated e-mail address for:', self.name- 如果需要，每个子类最好定义它自己的构造器，不然，基类的构造器会被调用。然而，如果子类重写基类的构造器，基类的构造器就不会被自动调用了－－这样，基类的构造器就必须显式写出才会被执行。这里我们要显式传递 self 实例对象给基类构造器，因为我们不是在其实例中调用那个方 法而是在一个子类实例中调用那个方法。因为我们不是通过实例来调用它，这种未绑定的方法调用 需要传递一个适当的实例(self)给方法。
- 类的数据属性：即静态变量，或者是静态数据。它们表示这些数据是与它们所属的类对象绑定的，不依赖于任何类实例。如果你是一位Java 或 C++程序员，这种类型的数据相当于在一个变量声明前加上 static 关键字。 静态成员通常仅用来跟踪与类相关的值。大多数情况下，你会考虑用实例属性，而不是类属性。
- 实例属性：能够在“运行时”创建实例属性，是 Python 类的优秀特性之一，从 C++或 Java 转过来的人会被 小小的震惊一下，因为 C++或 Java 中所有属性在使用前都必须明确定义/声明。python就相当于不用提前声明，直接在创建实例时创建即可。
- 实例属性 vs类属性： 你可采用类来访问类属性，如果实例没有同名的属性的话，你也可以用实例来访问, 修改类属性需要使用类名，而不是实例名。假定类C中有一个类数据属性version且声明了一个实例c, 如果尝试在实例中设定或更新类属性会创建一个实例属性 c.version，后者会阻止对类属性 C.versioin 的访问，因为第一个访问的就是 c.version，这样可以对实例有效地“遮蔽”类属性C.version，直到 c.version 被清除掉
- 方法：为与 OOP 惯例保持一致， Python 严格要求，没有实例，方法是不能被调用的。这种限制即 Python所描述的绑定概念(binding)，在此，方法必须绑定（到一个实例） 才能直接被调用。非绑定的方法 可能可以被调用，但实例对象一定要明确给出，才能确保调用成功。然而，不管是否绑定，方法都是它所在的类的固有属性，即使它们几乎总是通过实例来调用的。
- 首先，方法仅仅是类内部定义的函数。(这意味着方法是类属性而不是实例属性)。 其次，方法只有在其所属的类拥有实例时，才能被调用。当存在一个实例时，方法才被认为是绑定到那个实例了。没有实例时方法就是未绑定的。 最后，任何一个方法定义中的第一个参数都是变量 self，它表示调用此方法的实例对象
- self 变量用于在类实例方法中引用方法所绑定的实例。因为方法的实例在任何方法调用中总是 作为第一个参数传递的，self 被选中用来代表实例。你必须在方法声明中放上self(你可能已经注意到了这点), 但可以在方法中不使用实例(self)。如果你的方法中没有用到self , 那么请考虑创建 一个常规函数，除非你有特别的原因。毕竟，你的方法代码没有使用实例，没有与类关联其功能.
- Python 实例方法、类方法和静态方法
- 静态方法和C++、Java这些语言中的是一样的。它们仅是类中的函数(不需要实例)。
- 通常的方法需要一个实例(self)作为第一个参数，并且对于（绑定的）方法调用来说，self 是自动传递给这个方法的。而对于类方法而言，需要类而不是实例作为第一个参数，它是由解释器传给方法。类不需要特别地命名, 类似 self，不过很多人使用
cls作为变量名字。类方法的形参是这个类名而非实例（类名可以任意取），类方法也是对这个类（不是实例）进行操作（如获得类的名字cls.__name__） - 定义静态方法只需在定义函数（def xxx）之前一行加@staticmethod ， 类方法是加@classmethod
- 继承：
- 当从一个带构造器
__init()__的类派生，如果你不去覆盖__init__()，它将会被继承并自动调用。但如果你在子类中覆盖了__init__()，子类被实例化时， 基类的__init__()就不会被自动调用，如果想在子类构造函数中调用基类的构造函数，则可通过基类名直接调用或者通过super(C, self).__init__()调用 其中C为子类名 - 方法覆盖，如果在子类中定义一个与父类中某个函数同名的方法，则在子类中，该方法就被覆盖。如果仍需要调用父类的方法，则必须通过
父类名.funcName(子类实例名，funcName的其它参数)来调用 - 继承就是全部继承过来
- 当从一个带构造器
- 私有化：
- python目前的私有机制其实是伪私有，python的类是没有权限控制的，所有变量都是可以被外部调用的
-
#python为了实现类似私有变量的特征，python内部采用了一种叫 Name Mangling（名字改编）的技术，在python中定义私有变量只需要在变量名或者函数名前加上“__”两个下划线，那么这个函数或者变量就变成私有的了。 >>>class People: __name = "小二" #这样就变成私有的啦~ #用点操作符也访问不了哦~ #（3）上面的代码块就是在外部将变量名隐藏起来了，理论上如果要访问就要从内部进行，如下： >>>class People: def __init__(self,name): self.__name = name def getName(self): return self.__name >>>p = People("小二") P.__name#这里会报错！！！ >>> p.getName() '小二'#成功！ #强调一下！私有变量是不能直接通过：p.__name直接访问滴，而是必须在类内部通过方法返回私有变量的哦~ #（4）那么双下划线开头的实例变量（私有变量）是不是一定不能从外部访问呢？当然不是。不能直接访问__name是因为Python解# 释器对外把__name变量改成了_People__name这个样子 #所以，我们仍然可以通过 使用_类名__变量名 来访问__name变量（注意这里的下划线）~ >>>p._People__name '小二' #成功！ - 如果你不想让某个模块属性被 “from module import *” 导入 , 那么你可以给你不想导入的属性名称加上一个下划线( _ )。 不过如果你导入了整个模块或是你显式地导入某个属性(例如
import foo._bar), 这个隐藏数据的方法就不起作用了。
文件输入输出
-
f = open(filename, 'r') allLines = f .readlines() f.close() for eachLine in allLines: print (eachLine) # suppress print’s NEWLINE - file.write(str) 向文件写入字符串 file.writelines(seq) 向文件写入字符串序列 seq ; seq 应该是一个返回字符串的 可迭代对象
其它
Python多模块全局变量引用和修改
int 与 byte 互转
inta = 10
bytea = inta.to_bytes(4, byteorder='big', signed=False)
inta = int.from_bytes(bytea, byteorder='big', signed=False)
from import和import的区别
- from import 会执行可以执行的, 等于把想要的部分放入当前文件执行一遍(复制一份)
- 当多个程序需要同时导入一个模块并且都是访问时,使用import 可以节省内存空间
- 当多个程序需要同时导入一个模块当其中一个需要修改模块,那么修改的模块的程序应该使用from来导入模块.
- import 模块：导入一个模块；注：相当于导入的是一个文件夹，是个相对路径。
- from…import：导入了一个模块中的一个函数；注：相当于导入的是一个文件夹中的文件，是个绝对路径。
参考资料
- 《python 核心编程》
- 《effective python 》
扫一扫
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
