Python入门

1. 字符串的方法及注释
2. os、os.path模块中关于文件、目录的函数使用方法
3. python标准异常总结
4. python魔法方法大全
5. python time模块详解

变量私有

在python中定义私有变量只需要在变量名或函数名前面加上“__”就可以了。
调用时，x._类名.变量名

输出

输出：
	print("12345")
------------------------------------------------------------------------------------
输出变量：
	s=123
	print(s)
------------------------------------------------------------------------------------

输入

输入一个数字
	n = input()
------------------------------------------------------------------------------------
输入3个数字
	a, b, n = map(int, input().split())
------------------------------------------------------------------------------------
输入n个数字
	s = list(map(int, input().split()))
------------------------------------------------------------------------------------
输入一段字符
	s = input()
------------------------------------------------------------------------------------
输入n段字符，以空格为分界
	s=list(input().split())
	

分支语句

if  判断条件:
	成立语句
elif 判断条件:
	成立语句
else:
	成立语句
------------------------------------------------------------------------------------
if 3 > 5:
	print("3 > 5")
elif 3 == 5:
	print("3 = 5")
else"
	print("3 < 5")
------------------------------------------------------------------------------------
a = 5
a = (3 if 3 < 5 else 7)
此时a = 3
a = (3 if 3 > 5 else 7)
此时a = 7

且、或、非

1.且：and
	返回值为bool类型
	两边同时成立返回True,否则返回False
	3 < 5 and 5 > 3   :True
	3 < 5 and 5 < 3   :False
	3 > 5 and 5 < 3   :False
------------------------------------------------------------------------------------
2.或：or
	返回值为bool类型
	两边最少有一边成立返回True,否则返回False
	3 < 5 or 5 > 3   :True
	3 < 5 or 5 < 3   :True
	3 > 5 or 5 < 3   :False
------------------------------------------------------------------------------------
3.非：not
	返回值为bool类型
	变真为假，变假为真
	3 < 5    :True
	not 3 < 5    :False

循环

while循环
1.
	while 循环条件:
		条件成立时循环体
------------------------------------------------------------------------------------
2.
	while 循环条件:
		条件成立时循环体
	else:
		条件不成立时执行、只执行一次（指条件不成立时，若使用break跳出循环体依然不会执行该语句）
------------------------------------------------------------------------------------


for循环

1.
	for 变量 in 可迭代对象:
		条件成立时循环体
------------------------------------------------------------------------------------	
2.
	for 变量 in 可迭代对象:
		条件成立时循环体
	else:
		条件不成立时执行、只执行一次（指条件不成立时，若使用break跳出循环体依然不会执行该语句）
------------------------------------------------------------------------------------	
3.
	可迭代对象：不可以直接写整数，例如:
	a = 0
	for i in 10:
		a += i
	不成立，需要使用range
	a = 0
	for i in range(10):
		a += i
	此时a = 45, 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
------------------------------------------------------------------------------------
4.
	a = 0
	for i in range(1, 10):
		a += i
	意为从1开始循环到9，i每次+1
	此时a = 45, 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
------------------------------------------------------------------------------------
5.
	a = 0
	for i in range(1, 10, 2):
		a += i
	意为从1开始循环到9，i每次+2
	此时a = 25, 1 + 3 + 5 + 7 + 9
------------------------------------------------------------------------------------
6.
	a = 0
	for i in range(10, 1, -1):
		a += i
	意为从10开始循环到2，i每次-1
	此时a = 54, 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2
------------------------------------------------------------------------------------
7.
	a = 0
	for i in range(10, 1, -2):
		a += i
	意为从10开始循环到2，i每次-2
	此时a = 30, 10 + 8 + 6 + 4 + 2
	
	易错点：for后面需要加一个:

列表

1.创建列表
	s = [1, 2, 3, 4, 5, "12345"]
	s = [] ：空列表
------------------------------------------------------------------------------------
2.列表遍历全部
	for i in s:
		print(i)
------------------------------------------------------------------------------------
3.通过下标查看列表元素
	print(s[2])
------------------------------------------------------------------------------------
4.获取列表长度
	length = len(s)
------------------------------------------------------------------------------------
4.查看列表最后一个元素
	print(s[len(s) - 1])
	print(s[-1])
------------------------------------------------------------------------------------
5.查看列表第一个元素
	print(s[0])
	print(s[-len(s)])
------------------------------------------------------------------------------------
6。列表遍历部分
	print(s[0:3])：遍历a[0]、s[1]、s[2]
	print(s[3:6])：遍历a[3]、s[4]、s[5]
	print(s[:3])：从头开始遍历到s[2]
	print(s[3:])：从s[3]开始遍历到末尾
	print(s[:])：遍历所有
	print(s[0:6:2])：从s[0]开始遍历到s[5]步长为2
	print(s[::2]):从头开始遍历到末尾步长为2
	print(s[::-2]):从末尾开始遍历到头步长为2
------------------------------------------------------------------------------------
7.列表的增加
	s.append("456789") ：在列表的末尾增加一个元素
	s.extend(["456","789","1011"]) ：在列表的末尾添加另一个列表
	s.[len(s):] = [5,6,7,"454"] ：在列表的末尾添加另一个列表
	s.insert(1,2) : 在下标为1的位置添加一个值为2的元素
------------------------------------------------------------------------------------
8.列表的删除
	s.remove("2") ： 删除列表中值为2的元素,如果有多个只删除第一个，如果没有则报错
	s.pop() ：删除最后一个元素
	s.pop(2)  ：按下标删除列表中的元素
	del s[下标] :按下标删除列表中的元素
	s.clear() ：删除全部
	del s ：删除全部
------------------------------------------------------------------------------------
9.列表的复制
	s *= 2
------------------------------------------------------------------------------------
10.判断元素是否在列表内
	2 in s  ：返回值为True
	"s1234" in s  ：返回值为False
	"s1234" not in s  ：返回值为True
------------------------------------------------------------------------------------
11.判断列表是否在列表内
	s = [123,456,[789,1234,5678],78910]
	s1 = [789,1234,5678]
	s1 in s
	返回值为True
	
	1234 in s ：返回值为False
	1234 in s[2] ：返回值为True
	
	s[2][0] ：返回值为789
	类似于不等长的二维数组
------------------------------------------------------------------------------------
12.常用内置函数
	s = [123,123,456,789]
	s.count(123) ：返回值为2
		查询123出现在s列表内的次数
	s.index(123) ：返回值为0
		查询123首次出现在s列表内的位置
	s.index(789,0,4) ：返回值为3
		查询789首次出现在列表内下标为[0,4)内的位置
		前闭后开
	s.reverse() 
		将s翻转
	s.sort()
		排序，默认从小到大
	s.sort(reverse = True)
		排序，从大到小
------------------------------------------------------------------------------------
13.列表的拷贝
	s1 = [1,2,3]
	s2 = s1[:]
	!!!!!!!!!千万不能直接用s2 = s1
	s2 = s1[:] ：创建一个新的列表，让s2->这个列表
	s2 = s1 ：创建一个s2指向s1的那个列表。

元组

元组内的元素无法更改！！

1.元组的创建
	s = (1,2,3,4,5,6,7)
	s = 1,2,3,4,5,6,7
	s = () ：空元组
	s = (1,) ：一个元素的元组
	s = 1,   ：一个元素的元组
	#  s = (1)创建的不是元组而是数字
	#  8 * (8) = 64
	#  8 * (8,) = (8, 8, 8, 8, 8, 8, 8, 8)
------------------------------------------------------------------------------------
2.元素的访问
	s[0]  ；返回值为1
------------------------------------------------------------------------------------
3.对一段元素进行访问
	s[:2] ：返回值为(1,2)
------------------------------------------------------------------------------------
4.元组拷贝
	s1 = s[:]
------------------------------------------------------------------------------------
5.元组元素的增加
	s = (1,2,3,4,5,6)
	s = s[:2] + (7,) + s[2:]
	此时s = (1,2,7,3,4,5,6)
------------------------------------------------------------------------------------
6.元组的删除
	s = (1,2,3,4,5,6)
	s = s[:2] + s[3:]
	此时s =(1,2,3,4,5,6)

函数

不能直接在函数体内修改全局变量的值！
全局变量a = 5
在函数体内写a = 6,此时这句话的意思是，创建一个局部变量，变量名为a，值为6，不会对全局变量a造成任何影响。

如果需要修改，则需要使用关键字global
例如：
count = 5
def myFun():
	global count
	count = 10
print(count)#此时输出5，因为未调用函数
myFun()
print(count)#此时输出10
------------------------------------------------------------------------------------

1.函数的创建：
	def func():
		print("嘿嘿嘿")
------------------------------------------------------------------------------------
2.函数的调用:
	func()
------------------------------------------------------------------------------------
3.带参数的函数的创建：
	def func(x,y):
		print(x)
		print(y)
4.带参数函数的调用：
	func("xxx",5)
------------------------------------------------------------------------------------
5.带返回值函数的创建：
	def func(x,y):
		return x + y
6.带返回值函数的调用：
	func("xxx","yyy")
------------------------------------------------------------------------------------
7.带默认值的函数的创建：
	def func(x = 5,y = 6)
		print(x + y)
8.带默认值的函数的调用：
	可以不写实参
	func()
	也可以写
	func(5,7)
	还可以写一部分
	func(y = 4)
	如果fun(4)这样调用，那4会覆盖x的值，y的值不变

	例：gcd
	def gcd(a, b):
		return a if b == 0 else gcd(b, a % b)
	gcd(5,25)
	#输出5
	gcd(6,9)
	#输出3
------------------------------------------------------------------------------------
9.函数文档
	在函数体内，使用单引号''包裹，用于注释文档，例如：
	def gcd(a, b):
		'用于计算最大公约数的函数'
		return a if b == 0 else gcd(b, a % b)
------------------------------------------------------------------------------------
10.函数文档的调用
	gcd.__doc__
	help(gcd)
	只能显示第一条函数文档。
------------------------------------------------------------------------------------
11.关键字参数（在调用的时候写定义函数时的函数名）
	def fun(a,b):
		print(a,b)
		
	fun(6, 5)
	#输出6， 5
	
	fun(b = 6, a = 5)
	#输出5 6
------------------------------------------------------------------------------------
12.收集参数
	def test(*s):
		print("参数的长度是:",len(s))
		print("第二个参数时:",s[1])
	test(1,2,3,4,5,6,7)
	#输出为:
	#参数的长度是: 7
	#第二个参数时: 2
------------------------------------------------------------------------------------
13.函数内同时有收集参数和普通参数
	def test(*s, a):
		print("参数的长度是:",len(s))
		print("第二个参数时:",s[1])
		print(a)
	test(1,2,3,5,6,a = 4),调用时必须使用关键字，否则会按收集参数算
	为了不出错，可以在创建函数时给参数一个默认值
------------------------------------------------------------------------------------
14.内嵌函数
	def fun1():
		print("fun()1正在被调用")
		def fun2():
			print("fun()2正在被调用")
		fun2()
	fun1()
	只有在调用fun1()之后才可以进行fun2()的调用
------------------------------------------------------------------------------------
	15.闭包
	如果在一个内部函数里，对在外部作用域（但是不是全局变量）的变量进行引用，那么内部函数就会被认为是闭包
	def fun1(x):
		def fun2(y):
			return x * y
		return fun2#没有括号
	fun1(8)(5)
	#结果为40
	i = fun1(8)
	
	def fun1():
		x = 5
		def fun2():
			nonlocal x#设置它不是一个局部变量，否贼会在fun2()内创建一个局部变量导致出错
			x *= x
			return x
		return fun2()
------------------------------------------------------------------------------------
16.匿名函数
	原函数:
	def com(x):
		return 2 * x + 1
	使用lambda:
	lambda x : 2 * x + 1
	使用方法g = lambda x : 2 * x + 1
	g(5)
	结果为11
	冒号左面是参数，右面是返回值
------------------------------------------------------------------------------------
17.过滤函数filter
	list(filter(none, [1, 0, False, True]))
	结果为[1,True]
	将所有结果为False的值过滤掉，
	两个参数，第一个参数可以是函数也可以是none，第二个参数是一个可迭代对象。
	
	例：过滤掉偶数
	def odd(x):
		if x % 2 == 0:
			return False
		else:
			return True
	a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
	a = list(filter(odd,a))
	结果为[1, 3, 5, 7, 9]
	a也会变成[1, 3, 5, 7, 9]
	
	a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
	a = list(filter(lambda x : x % 2,a))
	结果为[1, 3, 5, 7, 9]
	a也会变成[1, 3, 5, 7, 9]

字典dict

1.字典的创建
	dict1 = {}
	dict1 = {'a' : 1, 'b' : 'bi', 1 : 'one'}
	print(dict1['a'])#输出结果为1
	dict2 = dict(a = 1, b = 'bi')
------------------------------------------------------------------------------------
2.字典的修改
	dict2['a'] = 2
	对字典内不存在的键进行修改
	dict2['c'] = 5
	
	使用字典对字典进行修改
	dict1 = { 2 : 'one', 1 : 2}
	dict2 = { 2 : 'two'}
	dict1.update(dict2)
	print(dict1)
	结果为：{2: 'two'}
------------------------------------------------------------------------------------
3.字典元素的添加
	dict1 = {}
	dict1 = dict1.fromkeys((1, 2, 3))
	结果为:{1: None, 2: None, 3: None}
	
	dict1 = dict1.fromkeys((1, 2, 3),'Number')
	结果为:{1: 'Number', 2: 'Number', 3: 'Number'}
	
	dict1 = dict1.fromkeys((1, 3),'数字')
	结果为:{1: '数字', 3: '数字'}
	
	dict1 = dict1.fromkeys(range(10), '赞')
	结果为:{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞', 9: '赞'}
	
	dict1 ={1 : 'one', 2 : 'two'}
	dict1.setdefault(10)
	结果为:dict1 ={1 : 'one', 2 : 'two', 10 : 'None'}

dict.setdefault(11,'ten')
结果为:dict1 ={1 : 'one', 2 : 'two', 10 : 'None', 11 : 'ten'}
------------------------------------------------------------------------------------
4.字典元素的打印
	访问某一个键值
	print(dict[1])#1不是下标
	print(dict['a'])
	#缺点，当访问字典内不存在的键的时候，会报错
	print(dict.get('a'))
	#此时，若字典内不存在‘a’则会返回None，否则返回该键的值
	print(dict.get('a','没有!'))
	#此时，若字典内不存在‘a’则会返回'没有'!，否则返回该键的值
------------------------------------------------------------------------------------
	打印dict1的所有键:
	for i in dict1.keys():
		print(i,end = " ")
	结果为:0 1 2 3 4 5 6 7 8 9 
	
	打印dict1的所以值:
	for i in dict1.values():
		print(i,end = " ")
	结果为:赞 赞 赞 赞 赞 赞 赞 赞 赞 赞 
	
	同时打印键和值
	for i in dict1.items():
		print(i)
	结果为：
	(0, '赞')
	(1, '赞')
	(2, '赞')
	(3, '赞')
	(4, '赞')
	(5, '赞')
	(6, '赞')
	(7, '赞')
	(8, '赞')
	(9, '赞')
------------------------------------------------------------------------------------
5.判断键是否存在于字典内
	dict1 ={1 : 'one', 2 : 'two'}
	
	1 in dict1	: 返回值为 True
	3 in dict1	: 返回值为 False
------------------------------------------------------------------------------------
6.字典的清空
	dict1 = {1 : 'one', 2 : 'two'}
	dict1.clear()
	不建议使用dict1 = {}
	dict1 = {1 : 'one', 2 : 'two'}
	dict2 = dict1
	此时，会相当于一个指针的名字是dict2指向这个字典，当进行dict1 = {}之后，访问dict2的时候无法访问到元素
------------------------------------------------------------------------------------
7.字典的拷贝
	同样不能使用dict2 = dict1
	dict1 = {1 : 'one', 2 : 'two'}
	dict2 = dict1.copy()
------------------------------------------------------------------------------------
8.字典的弹出
	dict1 = {1 : 'one', 2 : 'two'}
	dict1.pop(1)

集合set

1.集合的创建
	num = {1, 2, 3, 4, 5}
	此时num是一个集合
	当用花括号包裹时，且里面元素都是数字，且没有映射关系时，这就是一个集合。
	
	也可以通过set1 = set([1, 2, 3, 4, 5, 5])来创建一个集合
	
	集合中的元素具有唯一性。
	num = {1, 2, 3, 4, 5, 5, 4, 3, 2}
	此时，集合内元素为{1, 2, 3, 4, 5}
	
	练习：去除list中的重复元素
	num1 = [1, 2, 3, 4, 5, 5, 0]
	num1 = list(set(num1))
	结果为[0, 1, 2, 3, 4, 5]
	#set会自动进行排序
------------------------------------------------------------------------------------
2.集合的访问
	num1 = {0, 1, 2, 3, 4, 5}
	查询某元素是否存在于集合中.
	1 in num1: 返回值为True
	6 in num1: 返回值为False

遍历集合内所有元素
	num1 = {6, 12, 24, 3, 48, 5}
	for i in num1:
		print(i, end = " ")
	结果为 : 3 5 6 12 48 24 
------------------------------------------------------------------------------------
3.添加元素到集合内
	num1 = {0, 1, 2, 3, 4, 5}
	num1.add(6)
	此时：
	num1 = {0, 1, 2, 3, 4, 5, 6}
------------------------------------------------------------------------------------
4.从集合内删除元素
	num1 = {0, 1, 2, 3, 4, 5}
	num1.remove(4)//不是下标
	此时：
	num1 = {0, 1, 2, 3, 5}
	如果元素4不存在，会报错
------------------------------------------------------------------------------------
5.不可变集合（使用关键字frozen）
	num3 = frozenset([1,2,3,4,5])
	可以正常遍历，无法增加修改删除

文件

1.文件的打开
	asas.txt里面的内容为"abc啊defgh"
	f = open('D:\\aaa\\asas.txt','读取方法')
	读取方法默认为只读'r',
	向空文件夹内写入，需要写'w'，会覆盖掉原文件夹内所有内容
------------------------------------------------------------------------------------
2.文件的读取
	s = f.read()
	读取全部字节，读取后指针会在最后，不能重复读取
	s = f.read(size = -1)
	当size < 0的时候读取全部字符，否则读取size个字符
	例：s = f.read(5)
	此时s内的内容为:"abc啊d"
	
	x = f.tell()
	显示当前指针所在位置，读取了5个字符，但是有一个中文，一个中文两个字节，所以x的值为6
	
	f.seek(offset, from)
	在文件中移动文件指针，从from(0代表文件起始位置，1代表当前位置，2代表文件末尾)偏移offset个字节
	例如当前字节为9
	
	
	f.seek(1, 0)
	此时使用s = read()，
	s的值为: "bc啊defgh"
	
	f.readline()只读取一行
	
	显示所有
	for i in f:
		print(i)
------------------------------------------------------------------------------------
3.文字的写入#写入到空文件夹内
	x = f.write('hasasasas')
	返回值为写入了多少个字符，此处x = 9

异常

例：当文件名不存在或其他原因导致无法打开文件时
try:
	f = open('asas.txt')
	print(f.read())
	f.close()
except OSError as reason:
#OSError是错误类型  reason是变量名，用于输出
	print('文件出错，出错的原因是' + str(reason))
------------------------------------------------------------------------------------
一个try可以对应多个except，except后面可以直接加冒号，还可以写多个异常except (OSError, TypeError):

系统一但检测出异常，就不会继续向下运行
------------------------------------------------------------------------------------
try:
	语句
except:
	错误
finally:
	无论如何都会被执行的语句，可以用来关闭文件，防止内存出现问题
------------------------------------------------------------------------------------
with open('asas.txt','w') as f:
	会自动关闭文件 

类

使用class关键字，类名必须大写
	class Person:
		#方法
		def man(self):
			print('男人')
		def woman(self):
			print('女人')
	经查阅发现：Python在类中定义方法的时候，方法会被传进一个参数，即当前对象的地址，所以一般在类中定义方法的时候，必须在方法中至少定义一个参数。
	一般情况下我们将其命名为"self"，但是实例方法的第一个参数不一定要叫self，其实完全可以叫任意参数名.
	比如：a,b,c等等，只是约定俗成的把该参数命名为self，因为这样使代码具有更好的可读性。
	
	如果类中什么都没有，则需要写pass
	class Ss:
		pass
------------------------------------------------------------------------------------
类的继承
	class MyList(list):
	代表MyList这个类继承了list类里面的方法。
------------------------------------------------------------------------------------
多态
	不同对象对同一方法相应不同的行动
	class A:
		def fun(self):
			print('我是小A...')
	class B:
		def fun(self):
			print('我是小b...')
	
	a = A()
	b = B()
	a.fun()		#结果为 : 我是小a...
	b.fun()		#结果为 : 我是小b...
	对不同的对象，调用相同的方法，产生不同的结果
------------------------------------------------------------------------------------
继承、多态的例子：
	class Ball:
		def setPro(self, pro):
			self.pro = pro
	
	class Basketball(Ball):
		def sport(self):
			print('我是%s, 谁打我!' % self.pro)
	
	class Football(Ball):
		def sport(self):
			print('我是%s, 谁踢我!' % self.pro)
	
	b = Basketball()
	f = Football()
	b.setPro('篮球')
	f.setPro('足球')
	b.sport()		#结果为：我是篮球, 谁打我!
	f.sport()		#结果为：我是足球, 谁踢我!
	
	一个父类名字为球类，球类内有一个设置球的名字的方法。
	两个子类名字分别为足球类和篮球类，继承了球类设置名字的方法，并有自己的一个运动方法
	
	方法的重写：若子类中有和父类同名的方法或属性，则会自动覆盖父类对应的方法或属性
	若重写时有需要用到的方法，例如：
	class F:
		def __init__(self):
			self.a = 1;
	class S(F):
		def __init__(self):
			super().__init__()
			self.b = 1
	重写init方法的同时，父类方法中的self.a就不存在了，但是若是想在子类方法中继续使用它，则需要添加super().__init__()。（会自动找到父类）
------------------------------------------------------------------------------------
多重继承：
	class F1:
		def f1(self):
			print('111')
	
	class F2:
		def f2(self):
			print('222')
	
	class S(F1, F2):
		pass
	
	此时，可以同通过
	s = S()
	s.f1()	#结果为111
	s.f2()	#结果为222
------------------------------------------------------------------------------------
组合：
	class A:
		def __init__(self, x):
			self.num = x
			
	class B:
		def __init__(self, x):
			self.num = x
	
	class C:
		def __init__(self, x, y):
			self.x = A(x)
			self.y = B(y)
			#通过这里来调用A类和B类
		def print_num(self):
			print('A的数量为 %d ,B的数量为 %d! ' %(self.x.num,self.y.num))
	
	c = C(1, 10)
	c.print_num()
	结果为: A的数量为 1 ,B的数量为 10! 
------------------------------------------------------------------------------------
属性的名字和方法相同时，属性会覆盖方法！

类和对象一些相关的BIF

1.判断一个类是否是另一个类的子类
	issubclass(class1,class2)
	class A:
		pass
	class B(A):
		pass
	issubclass(B, A)
	返回值为True
	
	比较宽松，一个类被认为是自身的子类
	issubclass(B, B)
	返回值也是True
	
	issubclass(B, object)
	返回值也是True,object是所有类的父类
------------------------------------------------------------------------------------
2.判断一个实例对象是否属于一个类
	isinstance(实例对象，类)
	class A:
		pass
	class B(A):
		pass
	
	b1 = B()
	isinstance(b1, B)
	返回值是True
	isinstance(b1, A)
	返回值也是True，因为B是A的子类
------------------------------------------------------------------------------------
3.判断一个属性名是否在类中
	hasattr(类，属性名)
	class C:
		def __init__(self,x = 0)
			self.x = x
	c1 = C()
	hasattr(c1,'x')
	返回值为True,属性名需要被引号（''）所包裹作为字符串传入，否则会报错
------------------------------------------------------------------------------------
4.返回类中的某个属性值
	getatter(类，属性名,[可选可不选]若不存在则返回。。。)
	class C:
		def __init__(self,x = 0)
			self.x = x
	c1 = C()
	getattr(c1, 'x')	返回值为0
	getattr(c1, 'y')	会报错，因为没有写找不到了怎么办
	getatter(c1, 'y', '您错访问的属性不存在')	返回“您所访问的属性不存在”
------------------------------------------------------------------------------------
5.设置类中的某个属性值
	setattr(类名，属性名，值)
	class C:
		def __init__(self,x = 0)
			self.x = x
	c1 = C()
	setatter(c1, 'x', 5)
	如果属性不存在于类中，则创建一个新的属性并完成赋值
------------------------------------------------------------------------------------
6.删除类中的属性
	delattr(类名，属性名)
	class C:
		def __init__(self,x = 0)
			self.x = x
	c1 = C()
	delatter(c1, 'x')
	若属性名不存在，则报错

魔术方法

魔法方法总是被双下划线包围，例如__init__
------------------------------------------------------------------------------------
默认方法,初始化方法 __init__
	def __init__(self):
初始化时使用，相当于JAVA中的实例化类的get和set操作
------------------------------------------------------------------------------------
new方法
	当一个class内的方法不可变的时候，可以使用new方法进行重写，然后重启传回去
	class CapStr(str):
		def __new__(cls, string):
			string = string.upper()
			return str.__new__(cls. string)
	
	a = CapStr('abcde')
	a
此时a的结果为'ABCDE'
------------------------------------------------------------------------------------
del方法，删除实例化类时的操作
	class C:
		def __init__(self):
			print('被调用1')
		def __del__(self):
			print('被调用2')
	c1 = C()	#输出'被调用1'
	c2 = c1
	c3 = c2
	del c1	#无输出
	del c3	#无输出
	del c2	#输出'被调用2'
此时__del__不会被调用，因为还有实例化类c2的存在，当删除掉所有的实例化类的时候，才会调用__del__
------------------------------------------------------------------------------------
算术方法，以int为例：
	__add__
	__sum__
	__mul__
等等，可以对算术方法进行重载
例1：
	class New_int(int):
		def __add__(self, other):
			return int.__sub__(self, other)
		def __sub__(self, other):
			return int.__add__(self, other)
	a = New_int(4)
	b = New_int(5)
	a + b	#结果为：-1
	a - b	#结果为: 9
例2：
	class Try_int(int):
		def __add__(self, other):
			return int(self) + int(self) + int(other)
		def __sub__(self, other):
			return int(self) - int(other) - int(other)
	a = Try_int(10)
	b = Try_int(2)
	a+b		#结果为22
	a-b		#结果为6
	如果不加int进行强转的话会造成无限循环。