Python学习笔记(2)

小咪咪 2022-07-14 09:28 293阅读 0赞



20、在Python类定义的方法通常有三种：实例方法、类方法以及静态方法。

  1.    a、 这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod，那么通过cls引用的必定是类对象的属性和方法；
  3.     b、而静态方法不需要默认的任何参数，跟一般普通函数类似，定义的时候使用@staticmethod，静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过对象来引用。
  5.     c、而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。

21、创建实例对象

  1. 要创建一个类的实例，可以使用类的名称，并通过\_\_init\_\_方法接受参数。   
  4. "创建 Employee 类的第一个对象"  
  7. emp1 = Employee("Zara", 2000)  
  10. "创建 Employee 类的第一个对象"
  12. emp2 = Employee("Manni", 5000)

22、访问属性

  1. 使用点(.)来访问对象的属性。使用如下类的名称访问类变量：   
  4. emp1.displayEmployee()  
  10. 可以添加、删除、修改类的属性，如下所示：  
  13.     emp1.age = 7       \#添加一个’age'属性  
  16.     emp1.age = 8       \#修改 ’age'属性   
  19.     del  emp1.ag        \#添加一个’age'属性   
  25.     getattr(obj, name, default) ：访问对象的属性。   
  28.     hasattr(obj, name)：检查是否存在一个属性。   
  31.     setattr(obj, name， vlaue)：设置一个属性，如果属性不存在，会创建一个新属性。   
  34.     delattr(obj, name)：删除属性。

23、Python内置类属性

  1.     \_\_dict\_\_：类的属性（包含一个字典，由类的数据属性组成）   
  4.     \_\_doc\_\_：类的文档字符串   
  7.     \_\_name\_\_：类名   
  10.     \_\_module\_\_：类定义所在的模块（类的全名是'\_\_main\_\_.className'，如果类位于一个导入模块mymod中，那么className.\_\_module\_\_等于mymod）   
  13.     \_\_bases\_\_：类的所有父类构成元素（包含了以下个由所有父类组成的元组）

24、Python对象销毁（垃圾回收）

  1.     a、在Python内部记录着所有使用中的对象各有多少引用；   
  4.         一个内部跟踪变量，称为一个引用计数器。
  6.     b、当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，这个对象的引用计数变为0时，它被垃圾回收，但是回收不是“立即”的，由解释器在适当的时机，将垃圾对象占用的内存空间回收。

25、类的继承

  1.     面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。  
  4.     继承语法：   
  7.         class 派生类名（基类名）：//...基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。   
  10.     在Python中继承中的一些特点：   
  13.         1)、在继承中基类的构造（\_\_init\_\_()方法）不会被自动调用，它需要在其派生类的构造函数中亲自专门调用；   
  16.         2)、在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量，区别在于基类中调用普通函数时并不需要带上self参数；   
  19.         3)、Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找，如果在继承元组中列了一个以上的类，那么它就被称作“多重继承”

26、调用子类方法

  1.     序号     方法                                        描述                                                      简单调用   
  4.     1           \_\_init\_\_(self, \[, args ... \])        构造函数                                               obj=class(args)   
  7.     2           \_\_del\_\_(self)                          析构函数，删除一个对象                     dell obj
  9.     3           \_\_repr\_\_(self)                        转化为供解释器读取的形式                  repr(obj)
  11.     4           \_\_str\_\_(self)                          用于将值转化为适于人阅读的形式       str(obj)
  13.     5          \_\_cmp\_\_(self, x)                    对象比较                                                 cmp(obj, x)

27、运算符重载

  1.     class Vector:  
  4.             def \_\_init\_\_(self, a, b):   
  7.                 self.a = a   
  10.                 self.b = b   
  13.             def \_\_str\_\_(self):   
  16.                 return 'Vector (%d, %d)' % (self.a, self.b)   
  19.             def \_\_add\_\_(self, other):   
  22.                 return Vector(self.a + other.a, self.b + other.b)   
  25.     v1 = Vector(2, 10)   
  28.     v2 = Vector(5, -2)   
  31.     print v1+v2     输出：Vector(7, 8)

28、类的私有属性

  1.     \_\_private\_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.\_\_private\_attr类的方法  
  4.     在类的内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数

29、类的私有方法

  1.     \_\_private\_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用self.\_\_private\_method

30、模块

  1.     模块让你能够有逻辑的组织python代码段，把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块也是python对象，具有随机的名字属性用来绑定或引用。简单的说，模块就是一个保存了python代码的文件，模块能定义函数、类和变量，模块里也能包含可执行的代码。

31、import语句

  1.     想使用python源文件，只需要在另一个源文件里执行import语句，可以自动防止重复import，形如：import  module1, module2 ...   
  4.     当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

32、from … import语句

  1.     python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：form  module  import  name1\[, name2\[, ... nameN\]\]
  3.     例如：需要导入fib的fibonacci函数，使用如下语句：form  fib  import  fibonacci （这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表）

33、form … import*语句

  1.     把一个模块的所有内容全部导入到当前的命名空间也是可行的，只需要使用如下声明：form  modname  import \*  （这种声明不该被过多的使用）。

34、定位模块

  1.     当导入一个模块，python解析器对模块位置的搜索顺序是：当前目录；如果不在当前目录，python则搜索在shell变量PYTHONPATH下的每个目录；如果都找不到，python会观看默认路径，Linux下默认路径一般为/usr/local/lib/python；模块搜索路径存储在system模块的sys.path变量中，变量里包含当前目录，PYTHONPATH和由安装过程决定默认目录。

35、PYTHONPATH变量

  1.     作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。

36、命名空间和作用域

  1.     a、变量是拥有匹配对象的名字（标识符），命名空间是一个包含了变量名称（键）和它们各自相应的对象（值）的字典。一个python表达式可以访问局部命名空间和全局命名空间里的变量，同名隐藏的原则同C/C++。   
  4.     b、每个函数都有自己命名空间，类的方法的作用域规则和通常函数一样，默认任何在函数内赋值的变量都是局部的。因此，如果要给全局变量在一个函数里赋值，必须使用global语句。   
  7.     c、global varName的表达式会告诉python，varName是一个全局变量，这样python就不会再局部命名空间里寻找这个变量了。

37、dir()函数

  1.     dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字，返回的列表容纳了在一个模块里定义的所有模块，变量和函数。

import math

content = dir(math)

print (content)

输出如下：

  1. \['\_\_doc\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh','degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fm

od’, ‘frexp’, ‘fsum’, ‘gamma’, ‘gcd’, ‘hypot’, ‘inf’, ‘isclose’, ‘isfinite’, ‘isinf’, ‘isnan’, ‘ldexp’, ‘lgamma’, ‘log’, ‘log10’, ‘log1p’, ‘log2’, ‘modf’, ‘nan’, ‘pi’, ‘pow’, ‘radians’, ‘sin’, ‘sinh’, ‘sqrt’, ‘tan’, ‘tanh’, ‘trunc’]

38、globals()和locals()函数

  1.     根据调用地方不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字；如果在函数内部调用locals()，返回的是所有能在函数里访问的命名；如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字；两个函数的返回类型都是字典，所以名字能用keys()函数摘取。

39、python中的包

  1.     包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的python的应用环境，考虑一个Phone目录下的pots.py文件。这个文件有如下源代码：
  3.     \#pots.py
  5.     \#coding=utf-8   
  8.     \#!/usr/bin/python   
  11.     def Pots()   
  14.             print "I'm Pots Phone"
  16.     同样的，我们有另外两个保存了不同函数的文件：   
  19.         Phone/Isdn.py    含有函数Isdn()
  21.         Phone/G3.py()
  23.     现在，在phone目录下创建file init.py   
  26.         Phone/\_\_init\_\_.py
  28.     此文件可为空   
  31.         from Phone.pots import post
  33.     或者当你导入phone时，为了能够使用所有函数，你需要在\_\_init\_\_.py里使用显式的导入语句：如下：   
  36.         from Pots import Pots   
  39.         from Isdn import Isdn   
  42.         from G3 import G3   
  45.     当你把这些代码添加到init.py之后，导入phone包的时候这些类就全都是可用的了。   
  48.         \#Now import your Phone Package
  50.         import Phone
  52.         Phone.Pots()   
  55.         Phone.Isdn()   
  58.         Phone.G3()   
  61.     以上实例输出结果：   
  64.         I'm Pots Phone   
  67.         I'm 3G Phone   
  70.         I'm Isdn Phone

40、模块发布

  1.     1)、mymodule目录结构体如下：   
  4.             |—setup.py   
  7.             |—suba   
  10.             |        |—aa.py   
  13.             |        |—bb.py   
  16.             |        |—\_\_init\_\_.py   
  19.             |   
  22.             |—subb   
  25.                     |—cc.py   
  28.                     |—dd.py   
  31.                     |—\_\_init\_\_.py   
  34.     2)、编写setup.py，py\_modules需要指明所需要包含的py文件   
  37.             from distuils.core import setup   
  40.             set(name="xwp", version="1.0", description="xwp's module", author="hanbo", py\_modules=\['suba.aa', 'suba.bb', 'subb.cc', 'subb.dd'\])
  42.     3)、构建模块   
  45.             python setup.py build   
  48.             构建后目录结构   
  51.             |—build   
  54.             |        |—lib.linux-i686-2.7   
  57.             |                |—suba   
  60.             |                |        |—aa.py   
  63.             |                |        |—bb.py
  65.             |                |        |—\_\_init\_\_.py
  67.             |                |   
  70.             |                |—subb   
  73.             |                        |—cc.py   
  76.             |                        |—dd.py   
  79.             |                        |—\_\_init\_\_.py   
  82.             |   
  85.             |—setup.py   
  88.             |         
  90.             |—suba
  92.             |        |—aa.py   
  95.             |        |—bb.py   
  98.             |        |—\_\_init\_\_.py   
  101.             |   
  104.             |—subb   
  107.                     |—cc.py   
  110.                     |—dd.py   
  113.                     |—\_\_init\_\_.py
  115.     4)、生产发布压缩包   
  118.             python setup.py sdist   
  121.             打包后，生成最终发布压缩包xwp-1.0.tar.gz，目录结构   
  124.             |—build   
  127.             |        |—lib.linux-i686-2.7   
  130.             |                |—suba   
  133.             |                |        |—aa.py   
  136.             |                |        |—bb.py
  138.             |                |        |—\_\_init\_\_.py
  140.             |                |   
  143.             |                |—subb   
  146.             |                        |—cc.py   
  149.             |                        |—dd.py   
  152.             |                        |—\_\_init\_\_.py   
  155.             |   
  158.             |—dist   
  161.             |        |—xwp-1.0.tar.gz   
  164.             |   
  167.             |—MANIFEST   
  170.             |   
  173.             |—setup.py   
  176.             |         
  178.             |—suba
  180.             |        |—aa.py   
  183.             |        |—bb.py   
  186.             |        |—\_\_init\_\_.py   
  189.             |   
  192.             |—subb   
  195.                     |—cc.py   
  198.                     |—dd.py   
  201.                     |—\_\_init\_\_.py

41、文件操作

  1. 1)、打印到屏幕
  3.         最简单的输出方法是用print语句，可以给它传递零个或多个用逗号隔开的表达式，或者占位符 
  5. 2)、读取键盘输入
  7.         python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘，如下：
  9.             raw\_input()：从标准输入读取一行，并返回一个字符串（去掉结尾的换行符）
  11.             input()：和raw\_input()基本可以互换，但是它会假设你的输入是一个有效的python表达式，并返回运算结果。
  13. 3)、打开文件   
  16.         open()：打开一个文件，创建一个file对象。  
  19.         file\_object=open(file\_name \[, access\_mode\]\[, buffering\])   
  22.         参数如下：   
  25.             file\_name：是一个包含了要访问的文件名称的字符串；   
  28.             access\_mode：决定了打开文件的模式（只读、写入、追加等）；   
  31.             buffering：缓冲区的大小（为0：就是不会有寄存；为1：访问文件时会寄存行；大于1：寄存区的缓冲大小。如果取负值，寄存区的缓冲区大小则为系统默认）   
  34. 4)、file对象属性   
  37.         一个文件被打开后，有一个file对象，可以得到有关该文件的各种信息。  
  40.         属性                  描述   
  43.         file.closed        返回true如果文件已被关闭，否则返回false   
  46.         file.mode         返回被打开文件的访问权限   
  49.         file.name         返回文件的名称   
  52.         file.softspace  如果用print输出后，必须跟一个空格符，则返回false，否则返回true   
  55. 5)、文件关闭
  57.         close()：刷新缓冲区里任何还没有写入的信息，并关闭该文件，这之后便不能再进行写入。当一个文件对象的引用被重新指定给另一个文件时，python会关闭之前的文件，用close()方法关闭文件是一个很好的习惯。
  59. 6)、write()：将任何字符产写入一个打开的文件。python字符串可以是二进制数据，而不是仅仅是文字。write方法不再字符串的结尾添加换行符'\\n'。   
  62. 7)、read()：从一个打开的文件中读取一个字符串，python字符串可以是二进制，而不仅仅是文字。  
  65. 8)、文件位置
  67.         seek()：告诉你文件内的当前位置，就是下次读写会发生在文件开头多少字节之后。
  69.         seek(offset \[, from\])改变当前文件的位置，offset变量表示要移动的字节数。from变量指定开始移动字节的参考位置，如果from被设为0，这意味着将文件的开头作为移动字节的参考位置，如果设为1，则使用当前的位置作为参考位置，如果它被设为2，那么该文件的末尾将作为参考位置。   
  72. 9)、重命名   
  75.         rename()：需要两个参数，当前文件名和新文件名。（使用需要导入os模块）
  77. 10)、删除文件   
  80.         remove()：需要提供要删除的文件名作为参数。（使用需要导入os模块）

发表评论

表情：
评论列表 （有 0 条评论，293人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python学习笔记(2)

     20、在Python类定义的方法通常有三种：实例方法、类方法以及静态方法。        a、 这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的

    小咪咪小咪咪/ 0 赞/ 294 阅读