leemingx / pythonlearning

python入门和进阶

pythonLearning

python入门和进阶

pythonlearning's Issues

python学习笔记20180621

第三章 使用字符串
3.1 基本字符串操作
所有标准的序列操作（索引、分片、乘法、判断成员资格、求长度、取最小值和最大值）对字符串同样使用。
3.2 字符串格式化：精简版
（1）字符串格式化使用字符串格式化操作符——%；
（2）%左侧放置一个字符串，右侧放置希望被格式化的值；
（3）可以使用一个值（字符串、数字），也可以使用多个值的元组或者字典。一般使用元组。
（4）如果要格式化实数（浮点数），可以使用f说明转换说明符的类型，同时提供所需要的精度：一个句点再加上希望保留的小数位数。
***模板字符串
string模块提供另外一种格式化的方法：模板字符串。
substitute这个模板方法会用传递进来的关键字参数foo替换字符串的$foo。
如果替换的字段是单词的一部分，参数名需要用{ }括起来，从而准确地指明结尾；
当需要插入美元符号的时候，用$$；
除了关键字参数，还可以使用字典变量提供值/名称对；
3.3 字符串格式化：完整版
3.3.1 简单转换
简单转换只需要写出转换类型，使用起来很简单；
3.3.2 字段宽度和精度
（1）转换说明符可以包括字段宽度和精度。字段宽度是转换后的值所保留的最小字符个数，精度（对于数字转换来说）则是结果中应该包含的小数位数，或者（对于字符串转换来说）是转换后的值所能包含的最大字符个数；
（2）这两个参数都是整数（首先是字段宽度，然后是精度），通过点号（.）分隔。虽然两个都是可选的参数，但如果只给出精度，就必须包含点号。
3.3.3 符号、对齐和0填充
（1）在宽度和精度之前还可以放置一个标志，可以是0、+、-或者空格。
（2）0表示数字会用0进行填充，-表示左对齐，+表示标识出正负号。
3.4 字符串方法
（1）find：find方法可以在一个较长的字符串中查找子串。它返回子串所在位置最左端的索引，没找到则返回-1；
（2）join：join方法是非常重要的字符串方法，它是split方法的逆方法，用来连接序列中的元素。另外，被连接的序列中的元素都必须是字符串。
（3）lower：lower方法返回字符串的小写字母版；
（4）replace：replace方法返回某字符串的所有匹配项均被替换之后得到的字符串；
（5）split：这是一个非常重要的字符串方法，它是join的逆方法，用来将字符串分割成序列。
（6）strip：strip方法返回去除【两侧】（不包括内部）空格的字符串；
（7）translate：translate和replace功能类似，不过它只处理单个字符。优点是同时可以进行多次替换。

第四章 字典：当索引不好用时
Python唯一的内建的映射类型，无序，但都存储在一个特定的键中，键可以是字符，数字，或者是元组。
4.1 字典的使用
某些情况下，字典比列表更加适用，比如：
1）表征游戏棋盘的状态，每个键都是由坐标值组成的元组；
2）存储文件修改次数，用文件名作为键；
3）数字电话/地址簿；

4.2 创建和使用字典
字典由多个键及与其对应的值构成的对组成（也把键/值对称为项）。每个键和它的值之间用冒号（：）隔开，项之间用（，）隔开，而整个字典是由一对大括号括起来。空字典（不包括任何项）由两个大括号组成，像这样：{ }。
***字典中的键是唯一的（其他类型的映射也是如此），而值并不唯一。
4.2.1 dict函数
可以用dict函数，通过其他 映射（比如其他字典）或者（键，值）这样的序列对建立字典。
dict函数也可以通过关键字参数来创建字典。
4.2.2 基本字典操作
****字典与列表的一些重要区别:
1）字典中的键数据类型，可以使整型，浮点型，字符型，或字典型；
2）字典赋值，可以给空字典赋值，即超过索引外赋值，这点是列表不具备的；
3）k in d:查找的是键 v in l: 查找的是值(查找效率字典比列表高效，数据越多，效果越明显)
第一点：字典中的键可以为任何不可变的类型，这是字典最强大的功能，适用范围很广:
第二点：同样很重要，比如说,字典可以在空字典中建，列表就不行:
4.2.3 字典的格式化字符串
***字典的格式化字符串:(键)，如果键在字典中存在，那么就能打印出来，这一功能在模板系统中非常有用。
4.2.4 字典方法
（1）clear：clear方法清除字典中所有的项。这是原地操作（类似于list.sort），所以无返回值（或者说返回None）。
（2）copy：copy方法返回一个具有相同键-值对的新字典（这个方法实现的是浅复制，因为值本身就是相同的，而不是副本）；
（3）fromkeys：该方法使用给定的键建立新的字典，每个键默认对应的值为None；
（4）get：get方法是个更宽松的访问字典项的方法。一般来说，若试图访问字典中不存在的项时会出错。
（5）has_key：该方法可以检查字典中是否含有给出的键。表达式d.has_key（k）相当于表达式k in d
（6）items和iteritems：items方法将所有的字典项以列表方式返回，这些列表项中的每一项都来自于（键和值）。但是项在返回时并没有特殊的顺序。
（7）keys和iterkeys：keys方法将字典中的键以列表形式返回，而iterkeys则返回针对键的迭代器；
（8）pop：pop方法用来获得对应于给定键的值，然后将这个键-值对从字典中移除；
（9）popitem：popitem方法类似于list.pop，后者会弹出列表的最后一个元素。但不同的是，popitem弹出随机的项，因为字典并没有最后的元素或者其他有关顺序的概念；
（10）setdefault：类似于get方法，就是能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值；
（11）update：update方法可以利用一个字典项更新另外一个字典；
（12）values和itervalues：values方法以列表的形式返回字典中的值（itervalues返回值的迭代器）。与返回键的列表不同的是，返回值的列表中可以包含重复的元素；

python学习笔记20180619

第一章 基础知识
1.4 数字和表达式
（1）除法
python只执行普通除法的2种方法：（1）要么用实数（包含小数点的数）而不是整数进行运算；（2）可以让python改变除法的执行方式。
***可在程序前加或直接在解释器里执行它：>>> from future import division，也可使用命令开关-Qnew；举例：>>> 1/2 0.5
此时实现整除的操作符为：双斜线 >>> 1//2 0
即使是浮点数，也会执行整除：>>> 1.0/2.0 0.0
（2）取余运算符：取余运算符对浮点数同样适用。
（3）幂（乘方）运算符：幂运算符比取反（一元减运算符）的优先级要高。
1.4.1 长整数
**需处理非常大的数（2 147 483 647和 -2 147 483 648之外），可用长整形数：普通数结尾加L；
1.4.2 十六进制和八进制
（1）十六进制如下写（0x是十六进制数前要加的，以此来识别它）：>>>0xAF 175
（2）八进制如下写(0是八进制识别的前缀)：>>> 010 8
***十六进制和八进制数的首位数字都是0；
1.5 变量
***变量代表或者引用某值的名字；
***在使用变量之前，需要对其赋值，就可以在表达式中使用变量；
***变量名可以包括字母、数字和下划线（_）;
***变量名不能以数字开头；
1.6 语句
***语句是做某事，而不是表达式代表的某事；（表达式就是做某件事情，而语句就是做某件事情）
***两类语句：print语句和赋值语句；
1.8 函数
***内建函数（很多模块中也有函数）：
（1）pow函数：乘方；
（2）abs函数：可以得到函数的绝对值；
（3）round函数：会把浮点数四舍五入为最接近的整数值；
（4）floor函数：向下取整函数（不能直接使用，需要使用特殊的命令import来导入模块）；
（5）int函数：取整数函数，将浮点数转化为整数；
（6）long函数：将字符串和数字转为长整型数；
（7）float函数：将字符串和数字转换为浮点数；

python 学习笔记20180625-20180630

第六章 抽象

1. 抽象定义：抽象是隐藏多余细节的艺术。定义处理细节的函数可以让程序更抽象；
   抽象理解：抽象是面向对象语言的一个特点，将很多事物的共性问题拿出来，然后封装起来，这样可以减少代码量，同时让调用变得很简单。
2. 函数定义：函数使用def语句定义。它们是由语句块组成，可以从外部世界获取值（参数），也可以返回一个或者多个值作为运算的结果
   def feb(num) 使用def关键字，在函数开头写下字符串，会作为函数的一部分进行存储，又称文档字符串，可以通过 num._doc_访问
   ***函数不返回任何参数，对外表现为默认值None；
   *在函数内赋值不会影响外部，不会改变参数；
   def hello(greeting='Hello',name = 'world') 参数设置默认值，参数名和值要严格对应
   def printParams(params)
   3.参数：函数从参数中得到需要的信息，也就是函数调用时设定的变量。python中有两类参数：位置参数和关键字参数。参数在给定默认值时时可逆的。
   字符串（以及数字和元组）是不可变的，即在函数内为参数赋值不会改变外部任何变量的值。
   （1）关键字参数
   例子：
   def hello(name, greeting):
   print '%s, %s' % (greeting, name)
   hello(greeting='hello', name='world')
   （2）参数默认值
   def hello(name="world", greeting="hello"):
   print '%s, %s' % (greeting, name)
   hello(greeting='greeting')
   （3）可变参数
   通过参数前加“”，表示可变参数，结果会变为元组。
   通过参数前加“”，表示可变关键字参数，结果会变为字典。
   例子：
   def print_params(x, y, z=3, *pospar, **keypar):
   print x, y, z
   print pospar
   print keypar
   print_params(1, 2, 4, 5, 6, 7, foo=9, bar=10)
   // 结果
   1 2 4
   (5, 6, 7)
   {'foo': 9, 'bar': 10}

（4）反转过程
例子：
def addTest(x, y): return x+y

params=(1, 2)
print addTest(*params)
3

4. 作用域：变量存储在作用域（也叫做命名空间）中。python中有两类主要的作用域——全局作用域和局部作用域。global()['name'] 在和局部变量重名时，调用全局变量
   global name 声明操作的是全局变量
   def fun1(num1)
   def fun2(num2)
   return num1*num2
   return fun2
   fun1(3)(4) 函数嵌套，闭包。
   filter(isNum,seq) 基于一个返回布尔值的函数对列表元素进行过滤
   程序案例：
   x = 1
   def change_global():
   global x
   x = x + 1
   change_global()
   print x
   5.递归：函数可以调用自身，如果它这么做了叫做递归。一切用递归实现的功能都可以用循环实现，但是有些时候递归函数更易读。
   6.函数式编程：python有一些进行函数型编程的机制。包括lambda表达式以及map/filter和reduce函数。

map(func,seq[,seq,.....]) 对序列中的每个元素应用函数；
filter（func,seq) 返回其函数为真的元素的列表；
reduce(func,seq[,initial]) 等同于func(func(func(seq[0],seq[1],seq[2],.....)
sum(seq) 返回seq 中所有元素之和
apply(func[,args[,kwargs]]) 调用函数，可以提供参数

python学习笔记20180705

错误和异常
Python有两种错误很容易辨认：语法错误和异常。
1、语法错误：Python 的语法错误或者称之为解析错；
2、异常：即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
3、异常处理
以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")
try语句按照如下方式工作；
首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
4、抛出异常
Python 使用 raise 语句抛出一个指定的异常。
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
5、用户自定义异常
可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
6、定义清理行为
try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。
7、预定义的清理行为
一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

python学习笔记20180620

1.11 字符串
1.11.1 单引号字符串和转义引号
（1）单双引号没区别；（2）使用反斜线（\）对字符串中的引号进行转义；
1.11.2 拼接字符串
拼接：如同加法运算一样；
1.11.3 字符串表示，str和repr
（1）str可以转换值为字符串；
（2）repr，以Python表达式形式表示值；
（3）可以比较str(10000L)和repr(10000L)；
（4）反引号效果跟repr一样，但是不推荐使用，因为3以上不支持。
*****str、repr和反引号是将python值转换为字符串的3种方法，函数str让字符串更易于阅读，而repr（和反引号）则把结果字符串转换为合法的python表达式。
1.11.4 input 和raw_input的比较
（1）input会假设用户输入的是合法的Python表达式（与repr相反）；
（2）raw_input会把所有的输入当初原始数据(raw_data)；
如： 对于name = input("name:")，只能输入"hcbbt"，而直接hcbbt不带双引号会报错。
1.11.5 长字符串、原始字符串和Unicode
（1）长字符串：如果字符串要跨多行，可以用三个引号'''(或""")代替普通引号。
这里和用\加回车跨行的区别是，用\加回车输出会把各个行凑一行，而三个引号则一样跨行；
（2）原始字符串：在引号前面加上r可以使用原始字符串，字符串里面无法再转移；
（3）Unicode字符串：在字符串前使用u前缀；

第二章 列表和元组*
2.1 序列概览
（1）列表和元组的主要区别在于：列表可以修改，元组则不能；
（2）一般来说，在几乎所有的情况下列表都可以替代元组。（除非使用元组作为字典的键。）
2.2 通用序列操作
操作包括：索引、分片、加、乘以及检查某个元素是否属于序列的成员（成员资格）
2.2.1 索引
（1）序列中的所有元素都是有编号的--从0开始递增。这些元素可以通过编号分别访问。
*** 字符串就是一个由字符组成的序列。 ；
***字符串字面值能够直接使用索引，如'Hello'[1] = 'e'；
（2）如果一个函数调用返回一个序列，那么可以直接对返回结果进行索引操作；
（3） 索引可以为负数。
2.2.2 分片
（1）分片操作的实现需要提供两个索引作为边界，第1个索引的元素是包含在分片内的，而第2个则不包含在分片内；
（2）可显式设置步长（不能为0）。
2.2.3 序列相加
（1）使用加号；
（2）两种相同类型的序列才能进行连接操作；
2.2.4 乘法（重复n次）
空列表：[ ]，空值：None。 初始化：[None] * 10
2.2.5 成员资格
关键字in，返回值True/False；
2.2.6 长度、最小值和最大值
len(nums)：长度；max(nums)：最大值；min(nums)：最小值；
2.3 列表：python的“苦力”
2.3.1 lsit函数
string->list: list(str)
list->string: ''.join(somelist)
***list函数适用于所有类型的序列，而不只是字符串；
2.3.2 基本的列表操作
（1）元素赋值：使用索引标记来为某个 特定的、位置明确的元素赋值；
（2）删除元素：del names[2]；
（3）分片赋值：可以使用与原序列不等长的序列将分片替换。长插短，短插长都可以。
如：name = list('Perl') name[1:]=list('ython')，此时''.join(name)='Python'
也可以通过分片删除元素：name[1:2] = [ ]，'y'就被删掉了。
2.3.3 列表方法
对象.方法(参数)
（1）append：在列表后追加新对象；
（2）count：统计某个元素在列表中出现的次数；
（3）extend：可以在列表的末尾一次性追加另一个序列中的多个值。（修改了前面的列表）（a.append(b)等价于分片赋值a[len(a):] = b）
（4）index：从列表中找出某个值第一个匹配项的索引位置。（不存在会引发异常）
（5）insert：用于将对象插入到列表中。a.insert(3,'test')在下标为3的位置插入'test'。
（6）pop：会移除列表中的一个元素（默认是最后一个），并且返回该元素的值。
（7）remove：移除列表中某个值的第一个匹配项。（第一次出现的值）
（8）reverse：将列表中的元素反向存放。（不会返回列表，而是返回迭代器。可使用list(reserved(x))返回列表）
（9）sort：用于在原位置对列表进行排序。（返回了空值）（可用sorted()函数返回列表）
关于sort高级排序：
内建函数cmp(x,y)在x < y时返回负数，在x > y时返回正数，如果x = y则返回0。
sort默认用的是cmp，我们可以直接写比较函数并调用。如a.sort(cmp2)
sort方法有另外两个可选的参数--键函数key（如key=len）和布尔值reverse（True即反向，False正向，默认False）。
2.4 元组：不可变的序列
（1）元组和字符串都不能修改；
（2）空元组可以用没有包含内容的两个圆括号来表示。
2.4.1 tuple函数
***** 以一个序列或字符串作为参数并把它转换为元组
2.4.2 基本元组操作
****除了无法修改之外和列表差不多；
2.4.3 那么，意义何在
*****元组可以在映射（和集合的成员）中当作键使用--而列表则不行。

python学习笔记20180622

第五章 条件、循环和其他语句
5.1 print 和import的更多信息
对于很多应用程序来说，使用logging模块记日志比print语句更合适。
在python3.0中，print不再是语句，而是函数（功能基本不变）。
5.1.1 逗号输出
（1）print可以打印多个表达式：只需用逗号将其隔开（同时输出文本和变量值，却又不希望使用字符串格式化）；
（2）print的参数并不能像我们预期那样构成一个元组；
5.1.2 把某件事作为另一件事导入
模块导入函数：
（1）import someodule；（2）from someodule import somefunction;
（3）from someodule import somefunction,anotherfunction,yetanotherfunction;
（4）from someodule import*
5.2 赋值魔法
5.2.1 序列解包
（1）多个赋值操作可以同时进行；
（2）
5.2.2 链式赋值
链式赋值是将同一个值赋给多个变量的捷径
5.2.3 增量赋值
x=x+1 可以写成 x+=1，对于*、/、%等标准运算符都适用。
对于其他数据类型也适用（只要二元运算符本身适用于这些数据类型即可）；
增量赋值可以让代码更加紧凑和简练，很多情况下会更易于阅读；
5.3 语句块：缩排的乐趣
语句块并非一种语句；
语句块是在条件为真（条件语句）时执行或者执行多次 （循环语句）的一组语句。在代码前放置空格来缩进语句即可创建语句块。
***使用tab字符也可以缩进语句块。python将一个tap字符解释为到下一个tab字符位置的移动，而一个tab字符位置为8个空格，但是标注且推荐的方式是只用空格，尤其是在每个缩进需要4个空格的时候。
块中的每行都应该缩进同样的量。
5.4 条件和条件语句
5.4.1 这就是布尔变量的作用
真值 （也叫作布尔值）
5.4.2 条件执行和if语句
真值可以联合使用。
如果条件（在if和冒号之间的表达式）判定为真，那么后面的语句块就会被执行。如果条件为假，语句块就不会被执行。
5.4.3 else字句
5.4.4 elif字句
如果需要检查多个条件，就可以使用elif，它是“else if”的缩写，也是if 和else子句的联合使用—也就是具有条件的else子句。
5.4.5 嵌套代码块
if 语句里面可以嵌套使用if 语句。
5.4.6 更复杂的条件
（1）比较运算符：用在条件中的最基本的运算符就是比较运算符；
（2）相等运算符：如果想要知道两个东西是否相等，应该使用相等运算符，即两个等号==；
（3）is：同一性运算符；
***避免将is运算符用于比较类似数值和字符串这类不可变值。由于python内部操作这些对象的方式的原因，使用is与运算符的结果是不可预测的；
（4）in：成员资格运算符（它可以像其他比较运算符一样在条件语句中使用）；
（5）字符串和序列比较：字符串可以按照字母顺序排列进行比较；
（6）布尔运算符：and运算符就是所谓的布尔运算符。它连接两个布尔值，并且在两者都为真时返回真，否则返回假。与它同类的还有两个运算符，or和not。使用这3个运算符就可以随意结合真值；
5.4.7 断言
5.5 循环
5.5.1 while循环
5.5.2 for循环
while语句非常灵活。它可以用来任何条件为真的情况下重复执行一个代码块。一般情况下这样就够用了，但是有些时候还得量体裁衣。比如要为一个集合（序列和其他可迭代对象）的每个元素都执行一个代码块；
****可迭代对象是指可以按次序迭代的对象（也就是用于for循环中的）。
***如果能使用for循环，就尽量不用while循环；
5.5.3 循环遍历字典元素
一个字典的for语句就能循环字典的所有键，就像处理序列一样；
***字典元素的顺序通常是没有定义的。换言之，迭代的时候，字典中的键和值都能保证被处理，但是处理顺序不确定。如果顺序重要的话，可以 将键值保存在单独的列表中。例如在迭代前进行排序；
5.5.4 一些迭代工具
（1）并行迭代：程序可以同时迭代两个序列。
（2）编号迭代：有些时候想要迭代序列中的对象，同时还要获取当前对象的索引。例如，在一个字符串列表中替换所有包含‘xxx的字符串。
（3）翻转和排序迭代：reversed和sorted作用于任何序列可迭代对象上，不是原地修改对象，而是返回翻转或排序后的版本；
5.5.5 跳出循环
一般来说，循环会一直执行到条件为假，或者到序列元素用完时，但是有些时候可能会提前中断一个循环，进行新的迭代，或者仅仅就是想结束循环；
（1）break：结束（跳出）循环可以使用break语句。
（2）continue：continue语句比break语句用的要少得多。它会让当前的迭代结束，跳到下一轮循环的开始。它最基本的意思是“跳过剩余的循环体”，但是不结束循环“。当循环体很大而且很复杂的时候，会很有用，有些时候因为一些原因可能会跳过它—这个时候可以使用continue语句；
（3）while True/break习语：python中的while和for循环非常灵活，但一旦使用while语句就会遇到一个需要更多功能的问题。如果需要用户在提示符下输入单词时做一些事情，并且在用户不输入单词后结束循环；
5.5.6 循环中的else字句
当在循环内使用break语句时，通常是因为找到了某物或者因为某事发生了。在跳出时做一些事情是很简单的（比如print n）,但是有些时候想要在没有跳出之前做些事情。可以使用布尔变量，在循环前将其设定为False，跳出后设定为True,然后再使用if 语句查看循环是否跳出了。
5.6 列表推导式——轻量级循环
列表推导式是利用其它列表创建新列表（类似于数学术语中的集合推导式）的一种方法。它的工作方式类似于for循环；
***使用普通的圆括号而不是方括号不会得到“元组推导式”。
5.7 三人行
pass del 和exec
5.7.1 什么都没有发生
5.7.2 使用del删除
一般来说，python会删除那些不再使用的对象（因为使用者不会再通过任何变量或者数据结构引用它们）
5.7.3 使用exec和eval执行和求值字符串
1、exec
2、eval
eval(用于求值）是类似于exec的内建函数。exec语句会执行一系列PYTHON语句，而eval会计算python表达式（以字符串形式书写），并且返回结果值，（exec语句并不返回任何对象），因为它本身就是语句
跟exec一样，eval也可以使用命名空间。尽管表达式几乎不像语句那样为变量重新赋值（事实上，可以给eval语句提供两个命名空间，一个全局的一个局部的。全局的必须是字典，局部的可以是任何形式的映射）；

python学习笔记20180702

第七章 更加抽象
要点：
（1）多态：可以对不同类的对象使用同样的操作，根据对象（或类）类型的不同而表现出不同的行为；
（2）封装：对外部世界隐藏对象的工作细节，是对全局作用域中其他区域隐藏多余信息的原则；
（3）继承：以普通的类为基础建立专门的类对象；
（4）使用新式类：metaclass=type，python3后不存在旧式类；
（5）self参数事实上正是方法和函数的区别。方法（更专业一点可以称为绑定方法）将它们的第一个参数绑定到所属的实例上；
（6）python并不直接支持私有方式，而要靠程序员自己把握在外部进行特性修改的时机。为了让方法或者特性变为私有（从外部无法访问），只要在它的名字前面加上双下划线即可。类的内部定义中，所有以双下划线开始的名字都被翻译成前面加单下划线和类名的形式。前面有下划线的名字都不会被带星号的import语句导入；
（7）所有位于class语句中的代码都在特殊的命名空间中执行——类命名空间，这个命名空间可由类内所有成员访问；
（8）类作用域内的变量可以被所有实例访问（类似static）；
（9）issubclass函数：查看一个类是否是另一个类的子类；
（10）__bases__特性：查看已知类的基类；
（11）isinstance函数：检查一个对象是否是一个类的实例，使用isinstance并不是个好习惯，使用多态会更好一些；
（12）__class__特性：查看一个对象属于哪个类，新式类可以使用type（s）查看实例的类；
（13）多重继承：非常有用的工具，但除非特别熟悉多重继承，否则应该尽量避免使用。如果一个方法从多个超类继承，那么必须要注意一下超类的顺序——先继承的类中的方法会重写后继承的类中的方法（使其不可访问）。

python学习笔记20180703

面向对象概述
1、面向对象：一种认识世界、分析世界的方法论。将万事万物抽象为类。
2、类class：类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合；
用计算机语言来描述类，就是属性和方法的集合。
3、对象instance、object：对象是类的具象，是一个实体；
对于我们每个人这个个体，都是抽象概念人类的不同的实体。
举例：你吃鱼
你，就是对象；鱼，也是对象；吃就是动作；
你就是具体的人，是具体的对象。你属于人类，人类是个抽象的概念，是无数具体的个体的抽象。
鱼，也是具体的对象，就是你吃的这一条具体的鱼。这条鱼属于鱼类，是无数的鱼抽象出来的概念。
吃是动作，也是操作，也是方法，这个吃是你的动作，也就是人类具有的方法。如果反过来，鱼吃人。吃就是鱼类的动作了。
吃，这个动作，很多动物都具有的动作，人类和鱼类都属于动物类，而动物类是抽象的概念，是动物都有吃的动作，但是吃法不同而已。
你驾驶车，这个车也是车类的具体对象（实例），驾驶这个动作是鱼类不具有的，是人类具有的方法。
***属性，它是对象状态的抽象，用数据结构来描述。
***操作，它是对象行为的抽象，用操作名称和实现该操作的方法来描述。(说到底就是函数）
每个人都有名字、身高、体重等信息，这些信息是个人的属性，但是，这些信息不能保存在人类中，因为它是抽象的概念，不能保留具体的值。
而人类的实例，是具体的人，他可以存储这些具体的属性，而且可以不同人有不同的属性。

哲学：
一切皆对象；
对象是数据和操作的封装；
对象是独立的，但是对象之间可以相互作用；
目前OOP（面向对象编程）是最接近人类认知的编程范式；

***面向对象三要素：
1、封装
（1）组装：将数据和操作组装到一起；
（2）隐藏数据：对外只暴露一些接口，通过接口访问对象。比如驾驶员使用汽车，不需要了解汽车的构造细节，只需要知道使用什么部件怎么驾驶就行，踩了油门就能跑，可以不了解后面的机动原理。
2、继承：
（1）多复用，继承来的就不用自己写了；
（2）多继承少修改，OCP（open-closed Principle）,使用继承来改变，来体现个性。
3、多态（较难理解）
面向对象编程最灵活的地方，动态绑定。（python本身就是多态）

人类就是封装；
人类继承自动物类，孩子继承父母特征，分为单一继承、多继承；
多态，继承自动物类的人类、猫类的操作“吃”不同。

面向对象基础-类的定义：
Python的类
定义：class ClassName:
语句块
（1）必须使用class关键字；（2）类名必须是用大驼峰命名(首字母必须要求大写）；（3）类定义完成后，就产生了一个类对象，绑定到了ClassName上；
举例：
class MyClass:
"""A example class""'
x='abc' #类属性
def foo(self): #类属性foo，也是方法
return 'My Class'
print (MyClass.x)
print (MyClass.foo)
print (MyClass.doc)

***类对象及类属性
（1）类对象，类的定义就会产生一个类对象；
（2）类的属性，类定义中的变量和类中定义的方法都是类的属性；
（3）类变量，x是类MyClass的变量
.........