Python自学笔记——视频课程来自小甲鱼零基础入门学习python

Python自学笔记

细枝末节

/ 浮点除

// 地板除

字符串

apitalize()	把字符串的第一个字符改为大写
casefold()	把整个字符串的所有字符改为小写
center(width)	将字符串居中，并使用空格填充至长度 width 的新字符串
count(sub[, start[, end]])	返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
encode(encoding=‘utf-8’, errors=‘strict’)	以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]])	检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
expandtabs([tabsize=8])	把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
find(sub[, start[, end]])	检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
index(sub[, start[, end]])	跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdecimal()	如果字符串只包含十进制数字则返回 True，否则返回 False。
isdigit()	如果字符串只包含数字则返回 True，否则返回 False。
islower()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace()	如果字符串中只包含空格，则返回 True，否则返回 False。
istitle()	如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。
isupper()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。
join(sub)	以字符串作为分隔符，插入到 sub 中所有的字符之间。
ljust(width)	返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。
lower()	转换字符串中所有大写字符为小写。
lstrip()	去掉字符串左边的所有空格
partition(sub)	找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 (‘原字符串’, ‘’, ‘’)
replace(old, new[, count])	把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。
rfind(sub[, start[, end]])	类似于 find() 方法，不过是从右边开始查找。
rindex(sub[, start[, end]])	类似于 index() 方法，不过是从右边开始。
rjust(width)	返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。
rpartition(sub)	类似于 partition() 方法，不过是从右边开始查找。
rstrip()	删除字符串末尾的空格。
split(sep=None, maxsplit=-1)	不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。
splitlines(([keepends]))	在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。。
startswith(prefix[, start[, end]])	检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。
strip([chars])	删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。
swapcase()	翻转字符串中的大小写。
title()	返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。
translate(table)	根据 table 的规则（可以由 str.maketrans(‘a’, ‘b’) 定制）转换字符串中的字符。
upper()	转换字符串中的所有小写字符为大写。
zfill(width)	返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。

lambda 匿名函数

之前定义的函数为

def f(x,y):
    return x*y

可以使用lambda函数进行调用

g=lambda x,y:x+y

其中前面为形参，后面为具体操作

filter函数

过滤出执行中得到为真的部分

原型如下

fliter(function or None,iterable)

举例说明，得到0-9中的偶数，代码如下

list(filter(lambda x : (x+1)%2,range(10)))

map()函数

map函数是根据指定函数对指定序列做映射，在开发中使用map函数也是有效提高程序运行效率的办法之一

list(map(lambda x : x*2,range(10)))

运行结果为

[0,2,4,6,8,10,12,14,16,18]

for循环

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

语法结构如下

for iterating_var in sequence:
    statements(s)

举例说明

for letter in "Python":
    print"当前字母",letter

迭代

举例说明：利用迭代求正整数的阶乘

def factorial(n):
    result=n
    for i in range(1,n):
        result*=i
    return result
number=int(input("请输入一个正整数："))
result=factorial(number)
print('%d的阶乘是：%d'%(number,result))

对比体会利用递归求正整数的阶乘

def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
        
  
number=int(input("请输入一个正整数："))
result=factorial(number)
print('%d的阶乘是：%d'%(number,result))

汉诺塔

利用迭代的思想去完成汉诺塔路径的指示

思路：将三个柱子定义为x,y,z三个柱子。将n-1个盘子移动到y上，将第n个柱子移动到z盘子上。从此迭代下去

def hanoi(n,x,y,z):
    if n==1:
        print(x, '-->' ,z)
    else:
        hanoi(n-1,x,z,y)#将前n-1个盘子从x移动到y上
        print(x, '-->' ,z)#将最底层的最后一个盘子从x移动到上
        hanoi(n-1,y,x,z)#将y上的n-1个盘子移动到z上
n=int(input('请输入汉诺塔的层数：'))
hanoi(n,'X','Y','Z')

字典和索引

字典由键和对应值成对组成。每个键与值用冒号隔开（:），每对用逗号分割，整体放在花括号中（{}）。

键必须独一无二，但值则不必。

值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。字典也被称作关联数组或哈希表

dict1={'李宁':'一切皆有可能','耐克':'Just do it','阿迪达斯':'Nothing is impossible'}
print('李宁的口号是：',dict1['李宁'])

使用help(dict)查询用法后发现，其中的参数只能有一个，使用下面的代码举例子

其中最外层括号为函数自带的括号，中间的括号的作用是把里面变成一个整体，因为函数原型的参数只有一个

dict1=dict((('H',72),('B',66),('Y',89)))

常用于字典中的函数

dict.fromkeys()

快速生成字典。

对比体会以下代码的区别

>>> dict.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict.fromkeys((1,2,3),'number')
{1: 'number', 2: 'number', 3: 'number'}
>>> dict.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

dict.keys()#获取字典的关键字
dict.values()#获取键值
dict.Items()#获取完整的对象

当试图访问字典中村在的元素时

print()#会报错
get()#会返回None

快速查找是否在字典中使用

in
not in

清空字典

dict.clear()#推荐使用这个方法，而不是采用将其变为空字典。这种方法会清楚所有的被赋值的其他字典

浅拷贝

使用浅拷贝跟踪地址会不同；如果使用赋值，地址也会相同

dict.copy()

弹出

pop()#弹出值
popitem()#弹出项 

更新

a.update(b)#将b的项加到a中

集合

集合具有唯一性，无序性

创建方法：直接把一堆元素用{}括起来；使用set()工厂函数

不可变集合

frozenset()#内容不可变

文件

使用with语句打开文件

if __name__ == "__main__":
    with open("test.txt") as f:
        lines = f.readlines()
    print f

在执行到print f时会自动关闭文件

常用函数

f.close()        					#关闭文件
f.read(size=-1)						#从文件中读取size个字符，当未给定size或给定负值时，读取剩余的     								 所有字符，然后作为字符串返回
f.readline()						#以写入模式打开，如果文件存在，则在末尾追加写入
f.write(str)						#将字符串str写入文件
f.writelines(seq)					#向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
f.seek(offset,from)					#在文件中移动文件指针，从from(0代表起始位置，-1代表当前位置，2									 代表文件末尾)偏移offset个字节
f.tell()							#返回当前在文件中的位置

os

函数名	使用方法
basename(path)	去掉目录路径，单独返回文件名
dirname(path)	去掉文件名，单独返回目录路径
join(path1[, path2[, …]])	将path1, path2各部分组合成一个路径名
split(path)	分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在
splitext(path)	分离文件名与扩展名，返回(f_name, f_extension)元组
getsize(file)	返回指定文件的尺寸，单位是字节
getatime(file)	返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getctime(file)	返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getmtime(file)	返回指定文件最新的修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
以下为函数返回 True 或 False
exists(path)	判断指定路径（目录或文件）是否存在
isabs(path)	判断指定路径是否为绝对路径
isdir(path)	判断指定路径是否存在且是一个目录
isfile(path)	判断指定路径是否存在且是一个文件
islink(path)	判断指定路径是否存在且是一个符号链接
ismount(path)	判断指定路径是否存在且是一个挂载点
samefile(path1, paht2)	判断path1和path2两个路径是否指向同一个文件

pickle模块——永久存放

关键语句

pickle.dump()
pickle.load()

>>> import pickle
>>> my_list1=[123,3.14,'DYY',[125]]
>>> pickle_file=open('my_list','wb')
>>> pickle.dump(my_list,pickle_file)
>>> pickle.dump(my_list1,pickle_file)
>>> pickle_file.close()
>>> pickle_file=open('my_list','rb')
>>> my_list2=pickle.load(pickle_file)
>>> print(my_list2)
[123, 3.14, 'DYY', [125]]
>>> pickle_file.close()

异常总结

AssertionError	断言语句（assert）失败
AttributeError	尝试访问未知的对象属性
EOFError	用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError	浮点计算错误
GeneratorExit	generator.close()方法被调用的时候
ImportError	导入模块失败的时候
IndexError	索引超出序列的范围
KeyError	字典中查找一个不存在的关键字
KeyboardInterrupt	用户输入中断键（Ctrl+c）
MemoryError	内存溢出（可通过删除对象释放内存）
NameError	尝试访问一个不存在的变量
NotImplementedError	尚未实现的方法
OSError	操作系统产生的异常（例如打开一个不存在的文件）
OverflowError	数值运算超出最大限制
ReferenceError	弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError	一般的运行时错误
StopIteration	迭代器没有更多的值
SyntaxError	Python的语法错误
IndentationError	缩进错误
TabError	Tab和空格混合使用
SystemError	Python编译器系统错误
SystemExit	Python编译器进程被关闭
TypeError	不同类型间的无效操作
UnboundLocalError	访问一个未初始化的本地变量（NameError的子类）
UnicodeError	Unicode相关的错误（ValueError的子类）
UnicodeEncodeError	Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError	Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError	Unicode转换时的错误（UnicodeError的子类）
ValueError	传入无效的参数
ZeroDivisionError	除数为零

easygui

msgbox

msgbox(msg=’(Your message goes here)’, title=’ ', ok_button=‘OK’, image=None, root=None)

msgbox() 显示一个消息和提供一个"OK"按钮，你可以指定任意的消息和标题，你甚至可以重写"OK"按钮的内容。 以下是 msgbox() 的实例函数:

import easygui as g
title=g.msgbox(msg='hello world',title='标题',ok_button='加油')

ccbox

ccbox(msg=‘Shall I continue?’, title=’ ', choices=(‘Continue’, ‘Cancel’), image=None)

ccbox() 提供一个选择：Continue 或者 Cancel，并相应的返回 1（选中Continue）或者 0（选中Cancel）。注意 ccbox() 是返回整型的 1 或 0，不是布尔类型的 True 或 False。但你仍然可以这么写：

import sys
import easygui as g
if g.ccbox('亲爱的还玩吗？',choices=('还要玩！','算了吧')):
    g.msgbox('还是不玩了，快睡觉吧！')
else:
    sys.exit(0)

buttombox

buttonbox(msg=’’, title=’ ', choices=(‘Button1’, ‘Button2’, ‘Button3’), image=None, root=None)

可以使用 buttonbox() 定义自己的一组按钮，buttonbox() 会显示一组你定义好的按钮。

当用户点击任意一个按钮的时候，buttonbox() 返回按钮的文本内容。如果用户取消取消或者关闭窗口，那么会返回默认选项（第一个选项）。请看例子：

import easygui as g
g.buttonbox(msg='你喜欢下面哪种水果？',title='水果',choices=('西瓜','苹果','香蕉'))

在buttonbox()中显示图片

当你调用一个 buttonbox 函数（例如 msgbox(), ynbox(), indexbox() 等等）的时候，

你还可以为关键字参数 image 赋值，这是设置一个 .gif 格式的图像（注意仅支持 GIF 格式哦）：

import easygui as g
g.buttonbox(msg='你喜欢下面哪种水果？',image='截图.gif',choices=('西瓜','苹果','香蕉'))

indexbox

indexbox(msg=‘Shall I continue?’, title=’ ', choices=(‘Yes’, ‘No’), image=None)

基本跟上面一样，区别就是当用户选择第一个按钮的时候返回序列号0，选择第二个按钮时候返回序列号1。

boolbox

boolbox(msg=‘Shall I continue?’, title=’ ', choices=(‘Yes’, ‘No’), image=None)

如果第一个按钮被选中则返回 1，否则返回 0。

choicebox()

choicebox(msg=‘Pick something.’, title=’ ', choices=())

按钮组件方便提供用户一个简单的按钮选项，但如果有很多选项，或者选项的内容特别长的话，更好的策略是为它们提供一个可选择的列表。

choicebox() 为用户提供了一个可选择的列表，使用序列（元祖或列表）作为选项，这些选项显示前会按照不区分大小写的方法排好序。

另外还可以使用键盘来选择其中一个选项（比较纠结，但一点儿都不重要）：

• 例如当按下键盘上的"g"键，将会选中的第一个以"g"开头的选项。
• 再次按下"g"键，则会选中下一个以"g"开头的选项。
• 在选中最后一个以"g"开头的选项的时候，再次按下"g"键将重新回到在列表的开头的第一个以"g"开头的选项。
• 如果选项中没有以"g"开头的，则会选中字符排序在"g"之前（“f”）的那个字符开头的选项。
• 如果选项中没有字符的排序在"g"之前的，那么在列表中第一个元素将会被选中。

import easygui as g

msg = "选择你喜欢的一种业余生活"
title = ""
choicess_list = ["看书","游泳","骑自行车","玩游戏"]
reply = g.choicebox(msg,choices=chist)

mutchoicebox

*multchoicebox(msg=‘Pick as many items as you like.’, title=’ ', choices=(), *kwargs)

multchoicebox() 函数也是提供一个可选择的列表，与 choicebox() 不同的是，multchoicebox() 支持用户选择 0 个，1 个或者同时选择多个选项。
multchoicebox() 函数也是使用序列（元祖或列表）作为选项，这些选项显示前会按照不区分大小写的方法排好序。

import easygui as g
g.multchoicebox(msg="请选择你爱吃哪些水果?",title="",choices=("西瓜","香蕉","苹果","梨"))

enterbox

enterbox(msg=‘Enter something.’, title=’ ‘, default=’’, strip=True, image=None, root=None)

enterbox() 为用户提供一个最简单的输入框，返回值为用户输入的字符串。

默认返回的值会自动去除首尾的空格，如果需要保留首尾空格的话请设置参数 strip=False。

import easygui as g
g.enterbox(msg="请说出此时你的心里话",title="心里悄悄话")

interbox

*integerbox(msg=’’, title=’ ‘, default=’’, lowerbound=0, upperbound=99, image=None, root=None, *invalidKeywordArguments)

integerbox() 为用户提供一个简单的输入框，用户只能输入范围内（lowerbound参数设置最小值，upperbound参数设置最大值）的整型数值，否则会要求用户重新输入。

import easygui as g
g.integerbox(msg="请输入您的得分",title="分数统计",lowerbound=0,upperbound=100)

mulenterbox

multenterbox(msg=‘Fill in values for the fields.’, title=’ ', fields=(), values=())

multenterbox() 为用户提供多个简单的输入框，要注意以下几点：

• 如果用户输入的值比选项少的话，则返回列表中的值用空字符串填充用户为输入的选项。
• 如果用户输入的值比选项多的话，则返回的列表中的值将截断为选项的数量。
• 如果用户取消操作，则返回域中的列表的值或者None值

 1import easygui as g
 2 
 3 msg = "请填写一下信息(其中带*号的项为必填项)"
 4 title = "账号中心"
 5 fieldNames = ["*用户名","*真实姓名","固定电话","*手机号码","QQ","*Email"]
 6 fieldValues = []
 7 fieldValues = g.multenterbox(msg,title,fieldNames)
 8 #print(fieldValues)
 9 while True:
10     if fieldValues == None :
11         break
12     errmsg = ""
13     for i in range(len(fieldNames)):
14         option = fieldNames[i].strip()
15         if fieldValues[i].strip() == "" and option[0] == "*":
16             errmsg += ("【%s】为必填项   " %fieldNames[i])
17     if errmsg == "":
18         break
19     fieldValues = g.multenterbox(errmsg,title,fieldNames,fieldValues)
20 print("您填写的资料如下:%s" %str(fieldValues))

passwordbox

passwordbox(msg=‘Enter your password.’, title=’ ‘, default=’’, image=None, root=None)

passwordbox() 跟 enterbox() 样式一样，不同的是用户输入的内容用"*"显示出来，返回用户输入的字符串：

1 import easygui as g
2 g.passwordbox(msg="请输入您的密码")

multpasswordbox

multpasswordbox(msg=‘Fill in values for the fields.’, title=’ ', fields=(), values=())

multpasswordbox() 跟 multenterbox() 使用相同的接口，但当它显示的时候，最后一个输入框显示为密码的形式（"*"）

1 import easygui as g
2 msg = "请输入用户名和密码"
3 title = "用户登录接口"
4 user_info = []
5 user_info = g.multpasswordbox(msg,title,("用户名","密码"))
6 print(user_info)

面向对象的编程（OOP）

self的使用

class Ball:
    def setName(self,name):
        self.name=name
    def kick(self):
        print("我叫%s"%self.name)
a=Ball()
a.setName('A')
a.kick()

魔法构造方法

class Ball:
    def __init__(self,name):
        self.name=name
    def kick(self):
        print("我叫%s"%self.name)
a=Ball('A')
a.kick()

公有和私有

在python中定义私有变量只需要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会变成私有

>>> class Person:
	__name='gui'

使用以下访问将报错

p=Person()
p.__name

其实加密是把原来的变成了_类名__变量名的形式

两种访问方式

class Person:
    __name='gui'
    def getNmae(self):
        retunr self.name

或

p._Person__name

继承

>>> class Parent:
	def hello(self):
		print('正在调用父类')
>>> class Child(Parent):
	pass				#为了保证语句正确，其实为空语句
>>> p=Parent()
>>> p.hello()
正在调用父类
>>> c=Child()
>>> c.hello()
正在调用父类

如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性

>>> class Child(Parent):
	def hello(self):
		print('正在调用子类')
>>> c=Child()
>>> c.hello()
正在调用子类

实战举例

import random as r
class Fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)
    def move(self):
        self.x-=1
        print('我的位置是：',self.x,self.y)
class Goldfish(Fish):#子类继承父类
    pass
class Carp(Fish):
    pass
class Shark(Fish):
    def __init__(self):#重写了move函数，所以现在这个代码无法执行shark的move
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('吃货的梦想就是天天有的吃')
            self.hungry=False
        else:
            print('我太饱了吃撑了')

执行实例

>>> fish=Fish()
>>> fish.move()
我的位置是： 1 6
>>> fish.move()
我的位置是： 0 6
>>> goldfish=Goldfish()
>>> goldfish.move()
我的位置是： 8 7
>>> goldfish.move()
我的位置是： 7 7
>>> shark=Shark()
>>> shark.eat()
吃货的梦想就是天天有的吃
>>> shark.eat()
我太饱了吃撑了
>>> shark.move()
Traceback (most recent call last):
  File "", line 1, in <module>
    shark.move()
  File "C:\Users\24972\Desktop\py联系.py", line 7, in move
    self.x-=1
AttributeError: 'Shark' object has no attribute 'x'

为了解决子类覆盖父类的问题，有以下两种方法

—调用未绑定的父类方法

—使用super()函数

方法一（不推荐）

import random as r
class Fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)
    def move(self):
        self.x-=1
        print('我的位置是：',self.x,self.y)
class Goldfish(Fish):
    pass
class Carp(Fish):
    pass
class Shark(Fish):
    def __init__(self):
        Fish.__init__(self)#注意这里其实是给的子类的对象
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('吃货的梦想就是天天有的吃')
            self.hungry=False
        else:
            print('我太饱了吃撑了')f

方法二（推荐）

import random as r
class Fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)
    def move(self):
        self.x-=1
        print('我的位置是：',self.x,self.y)
class Goldfish(Fish):
    pass
class Carp(Fish):
    pass
class Shark(Fish):
    def __init__(self):
        super().__init__()#引入super()函数 不需要具体的父类的名字
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('吃货的梦想就是天天有的吃')
            self.hungry=False
        else:
            print('我太饱了吃撑了')

多重继承

class Base1:
    def fool1(self):
        print('我是fool1')
class Base2:
    def fool2(self):
        print('我是fool2')
class C(Base1,Base2):
    pass
c=C()
c.fool1()
c.fool2()

组合

class Turtle:
    def __init__(self,x):
        self.num=x
class Fish:
    def __init__(self,x):
        self.num=x
class Pool:
    def __init__(self,x,y):
        self.turtle=Turtle(x)
        self.fish=Fish(y)
    def print_num(self):
        print('鱼塘里面一共有乌龟 %d 只，鱼 %d 条'%(self.turtle.num,self.fish.num))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ATTKu5Cg-1581593760724)(C:\Users\24972\Desktop\类.jpg)]

C不会受a,b,c的改变而改变，C的改变会影响a,b,c，如果a,b,c提前改变，那么C的改变不会影响之前的改变

构造和析构

class CapStr(str):
    def __new__(cls,string):
        string=string.upper()
        return str.__new__(cls,string)  #s使用__new__()需要返回一个实例对象

魔法方法	含义
	基本的魔法方法
_new_(cls[, …])	1. new 是在一个对象实例化的时候所调用的第一个方法 2. 它的第一个参数是这个类，其他的参数是用来直接传递给 init 方法 3. new 决定是否要使用该 init 方法，因为 new 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 new 没有返回实例对象，则 init 不会被调用 4. new 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
_init_(self[, …])	构造器，当一个实例被创建的时候调用的初始化方法
_del_(self)	析构器，当一个实例被销毁的时候调用的方法
_call_(self[, args…])	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.call(a, b)
_len_(self)	定义当被 len() 调用时的行为
_repr_(self)	定义当被 repr() 调用时的行为
_str_(self)	定义当被 str() 调用时的行为
_bytes_(self)	定义当被 bytes() 调用时的行为
_hash_(self)	定义当被 hash() 调用时的行为
_bool_(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
_format_(self, format_spec)	定义当被 format() 调用时的行为
	有关属性
_getattr_(self, name)	定义当用户试图获取一个不存在的属性时的行为
_getattribute_(self, name)	定义当该类的属性被访问时的行为
_setattr_(self, name, value)	定义当一个属性被设置时的行为
_delattr_(self, name)	定义当一个属性被删除时的行为
_dir_(self)	定义当 dir() 被调用时的行为
_get_(self, instance, owner)	定义当描述符的值被取得时的行为
_set_(self, instance, value)	定义当描述符的值被改变时的行为
_delete_(self, instance)	定义当描述符的值被删除时的行为
	比较操作符
_lt_(self, other)	定义小于号的行为：x < y 调用 x.lt(y)
_le_(self, other)	定义小于等于号的行为：x <= y 调用 x.le(y)
_eq_(self, other)	定义等于号的行为：x == y 调用 x.eq(y)
_ne_(self, other)	定义不等号的行为：x != y 调用 x.ne(y)
_gt_(self, other)	定义大于号的行为：x > y 调用 x.gt(y)
_ge_(self, other)	定义大于等于号的行为：x >= y 调用 x.ge(y)
	算数运算符
_add_(self, other)	定义加法的行为：+
_sub_(self, other)	定义减法的行为：-
_mul_(self, other)	定义乘法的行为：*
_truediv_(self, other)	定义真除法的行为：/
_floordiv_(self, other)	定义整数除法的行为：//
_mod_(self, other)	定义取模算法的行为：%
_divmod_(self, other)	定义当被 divmod() 调用时的行为
_pow_(self, other[, modulo])	定义当被 power() 调用或 ** 运算时的行为
_lshift_(self, other)	定义按位左移位的行为：<<
_rshift_(self, other)	定义按位右移位的行为：>>
_and_(self, other)	定义按位与操作的行为：&
_xor_(self, other)	定义按位异或操作的行为：^
_or_(self, other)	定义按位或操作的行为：|
	反运算
_radd_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rsub_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rmul_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rtruediv_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rfloordiv_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rmod_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rdivmod_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rpow_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rlshift_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rrshift_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rand_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rxor_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_ror_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
	增量赋值运算
_iadd_(self, other)	定义赋值加法的行为：+=
_isub_(self, other)	定义赋值减法的行为：-=
_imul_(self, other)	定义赋值乘法的行为：*=
_itruediv_(self, other)	定义赋值真除法的行为：/=
_ifloordiv_(self, other)	定义赋值整数除法的行为：//=
_imod_(self, other)	定义赋值取模算法的行为：%=
_ipow_(self, other[, modulo])	定义赋值幂运算的行为：**=
_ilshift_(self, other)	定义赋值按位左移位的行为：<<=
_irshift_(self, other)	定义赋值按位右移位的行为：>>=
_iand_(self, other)	定义赋值按位与操作的行为：&=
_ixor_(self, other)	定义赋值按位异或操作的行为：^=
_ior_(self, other)	定义赋值按位或操作的行为：|=
	一元操作符
_pos_(self)	定义正号的行为：+x
_neg_(self)	定义负号的行为：-x
_abs_(self)	定义当被 abs() 调用时的行为
_invert_(self)	定义按位求反的行为：~x
	类型转换
_complex_(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
_int_(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
_float_(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
_round_(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
_index_(self)	1. 当对象是被应用在切片表达式中时，实现整形强制转换 2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 index 3. 如果 index 被定义，则 int 也需要被定义，且返回相同的值
	上下文管理（with 语句）
_enter_(self)	1. 定义当使用 with 语句时的初始化行为 2. enter 的返回值被 with 语句的目标或者 as 后的名字绑定
_exit_(self, exc_type, exc_value, traceback)	1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么 2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
	容器类型
_len_(self)	定义当被 len() 调用时的行为（返回容器中元素的个数）
_getitem_(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
_setitem_(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
_delitem_(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
_iter_(self)	定义当迭代容器中的元素的行为
_reversed_(self)	定义当被 reversed() 调用时的行为
_contains_(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为

time模块

索引值（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	（例如：2015）
1	tm_mon（月）	1 ~ 12
2	tm_mday（日）	1 ~ 31
3	tm_hour（时）	0 ~ 23
4	tm_min（分）	0 ~ 59
5	tm_sec（秒）	0 ~ 61（见下方注1）
6	tm_wday（星期几）	0 ~ 6（0 表示星期一）
7	tm_yday（一年中的第几天）	1 ~ 366
8	tm_isdst（是否为夏令时）	0， 1， -1（-1 代表夏令时）

注1：范围真的是 0 ~ 61（你没有看错哦^_）；60 代表闰秒，61 是基于历史原因保留。

time.localtime([secs])

接收时间辍（1970 纪元年后经过的浮点秒数）并返回当地时间下的时间元组 t（t.tm_isdst 可取 0 或 1，取决于当地当时是不是夏令时）

倒计时功能

_str_()函数

不知道大家再写程序是，打印一个实例化对象时，打印的其实时一个对象的地址。而通过__str__()函数就可以帮助我们打印对象中具体的属性值，或者你想得到的东西。

因为再python中调用print()打印实例化对象时会调用__str__()如果__str__()中有返回值，就会打印其中的返回值。

方法：_repr_()

显示属性

import time as t
class MyTimer():
    def __init__(self):
        self.unit=['年','月','日','小时','分钟','秒']
        self.prompt='未开始计时'
        self.begin=0
        self.end=0
    def __str__(self):
        return self.prompt
    __repr__=__str__
    def start(self):
        self.begin=t.localtime()
        self.prompt='提示：请先调用stop()停止计时'
        print('计时开始')
    def stop(self):
        if not self.begin:
            print('提示：请先调用start()开始计时')
        else:
            self.end=t.localtime()
            self._calc()
            print('计时结束')
    def _calc(self):
        self.lasted=[]
        self.prompt='总共运行了'
        for index in range(6):
            self.lasted.append(self.end[index]-self.begin[index])
            if self.lasted[index]:
                self.prompt+=(str(self.lasted[index])+self.unit[index])
        
        self.begin=0
        self.end=0

_getattr_(self,name)	定义当用户试图获取一个不存在的属性时的行为 需要返回值
_getattribute_(self,name)	定义当该类的属性被访问时候的行为
_setattr_(self,name,value)	定义当一个属性被设置时的行为
_delattr_(self,name)	定义当一个属性被删除时的行为

新手的魔法方法迭代陷阱

class Rectangle:
    def __init__(self,width=0,height=0):
        self.width=width
        self.height=height

    def __setattr__(self,name,value):
        if name=='square':
            self.width=value
            self.height=value
        else:
            self,name=value #由于将value赋值给了name，会回到上一步，然后从此进行死循环
    def getArea(self):
        return self.width*self.height

解决方法

调用基类的方式去获得

class Rectangle:
    def __init__(self,width=0,height=0):
        self.width=width
        self.height=height

    def __setattr__(self,name,value):
        if name=='square':
            self.width=value
            self.height=value
        else:
           super().__setattr__(name,value)
    def getArea(self):
        return self.width*self.height
 

或者采用字典的魔法方法

class Rectangle:
    def __init__(self,width=0,height=0):
        self.width=width
        self.height=height

    def __setattr__(self,name,value):
        if name=='square':
            self.width=value
            self.height=value
        else:
            self.__dict__[name]=value
    def getArea(self):
        return self.width*self.height

描述符

定义：将某种特殊类型的类的实例指派给另一个类的属性

函数名	用途
__get____(self,instance,owner)	用于访问属性，它返回属性的值
__set__(self,instance,value)	将在属性分配操作中调用，不返回任何内容
__delete__(self,instance)	控制删除操作，不返回任何内容

>>> class MyDecriptor:
	def __get__(self,instance,owner):
		print('getting',self,instance,owner)
	def __set__(self,instance,value):
		print('set',self,instance,value)
	def __delete__(self,instance):
		print('deltering',self,instance)

		
>>> class Test:
	x=MyDecriptor()

>>> test=Test()
>>> test.x
getting <__main__.MyDecriptor object at 0x000001F4C155B8B0> <__main__.Test object at 0x000001F4C155B910> <class '__main__.Test'>
>>> test
<__main__.Test object at 0x000001F4C155B910>
>>> Test
<class '__main__.Test'>
>>> test.x='x'
set <__main__.MyDecriptor object at 0x000001F4C155B8B0> <__main__.Test object at 0x000001F4C155B910> x
>>> del test.x
deltering <__main__.MyDecriptor object at 0x000001F4C155B8B0> <__main__.Test object at 0x000001F4C155B910>