标签：__ 知识点 name python self 返回 基础 字符串 def

0、使用#注释，因为python是脚本语言
批量赋值
a,b=1,2 //a=1,b=2
批量赋值还可以使用序列进行赋值
a,b=[1,2] //a=1,b=2

1、在python中，"hello world"*3 //表示3个这个字符串，不会出现语法错误
"hello world"+3 //会出现语法错误，因为string和int之间不兼容

2、tmp=input("input a elem")
首先会输出字符串input a elem
然后会用户从键盘输入一个数据，并且将它传递给tmp

3、python靠tab键而不是{}作为代码块

4、条件语句
if a:
code ..
elif b:
code ..
else:
cpde ..
用tab键作为缩进，然后用冒号:作为进入if条件语句代码块的地方

5、内置函数
BIF(built-in function)

6、强制类型转换
tmp2=int(tmp)
将tmp转化为int类型，并且赋值给tmp2

7、dir(builtins)
显示所有内置函数
help(function)
显示函数的作用

8、字符串拼接
和java类似，都可以使用加号+，当然，甚至可以直接不使用加号+
和js差不多，字符串可以单引号和双引号，
当在字符串中有单引号时，此时为了不使用单引号，可以在外面使用双引号，这个做法和js一样
str="let's go"

9、原始字符串
在字符串的最前面加上一个r，那么字符串就会使用原来的字符串，而不会进行转义
str=r'abc\nagag'
print(str) //结果会输出abc\nagag,因为这里使用了原始字符串
str=r'abc\ngng' //会报错，原始字符串最后面不能接反斜杠
此时，如果要在str结尾加反斜杠，那么可以使用字符串拼接的功能
str=r'abc\nabc''\'

10、长字符串
当字符串输入的时候，需要换行，那么就使用三引号
str="""abc
def"""

11、bool类型
True
False
第一个为大写，后面小写

12、循环
while 条件 :
code ...

for循环
	for 目标 in 表达式:
		循环体
	str='gyy'
	for i in str:
		print(i,end=' ')	//这个print和Go语言的fmt.println差不多

13、逻辑操作符
and
or
not
逻辑运算符优先级最低not>and>or

14、random模块
randint(1,10) //返回一个1-10之间的随机的整数
需要先引入模块
import random
number=random.randint(1,10)

15、类型转换
int() //转化为整数，直接去掉小数部分
int(5.99)//5
float() //转化为小数
float(5)//5.0
str() //转化为字符串
str(5e19)//5e+19
获取变量类型
type() //返回变量类型
type(5.2) //class 'float'
isinstance(a,b) //a和b的类型一致就返回True否则返回False

16、连续赋值
a=b=c=d=10 //所有的都是10

17、除法
/表示精确除法
3/2=1.5
//表示整数除法
3//2=1
3.0//2=1.0

18、次方
**
32=9 //表示3的2次方
的算术优先级：
比左侧高，比右侧低
-32 //-9
3-2 //3的负2次方=1/9=0.11111111111111111111111111111

19、三元操作符
small=x if x<y else y
当x<y，就把x的值给small，否则把y的值给small

20、断言
assert
assert 3>4
当assert条件错误的时候，会抛出异常AssertionError

21、range()
range([start],stop,[step=1])
求一个范围内的数，包括start，不包括stop，start和step为可选参数
start的默认值是0，step的默认值是1
这个范围必须是整数
range(5)//默认开头为0，步长为1，所以值为0,1,2,3,4
range(2,6)//取开头，不要结尾2,3,4,5
range(2,10,2)//取开头，不要结尾，并且步长为2，所以值为2,4,6,8
可以和for循环连用
for i in range(5):
print(i)
//最终会打印0,1,2,3,4

22、列表
像数组，但是所有数据类型不需要相同
mix=[1,'aaa',12.2,[1,2,3]]
emp=[] //空列表
append()//添加元素
emp.append('bb') //向数组中加入元素'bbb'，一次只能加入一个元素
extend()//将一个列表用来扩展另一个列表
emp.extend(mix) //emp的值为['bbb',1,'aaa',12.2,[1,2,3]]
insert()//将元素插入指定位置
emp.insert(1,'kkk') //emp的值为['bbb','kkk',1,'aaa',12.2,[1,2,3]]
remove()//删除指定元素
rmp.remove('kkk') //删除'kkk'
del //删除
del emp[1] //删除单个元素
del emp //删除整个列表
pop()//弹出最后面的元素
emp.pop() //最上面的元素被弹出来了，函数返回值是弹出的元素
emp.pop(1) //弹出指定位置的元素
切片slice
emp[1:3] //函数返回值为emp中元素1和2，和range()方法一样，包括开始不包括结尾
emp[:] //省略参数表示从开头到结尾
count()//元素在列表中出现的位置
index()//返回元素出现在列表中位置
emp.index('a',1,4) //在1-4中出现'a'的位置
reverse()//反转元素的位置
sort()//列表元素排序
sort(func,key,revserse) //和c语言的sort差不多
23、列表操作
加号+
emp+mix //返回一个新的列表
*
emp*3 //返回一个乘以3的列表，和前面字符串打印的时候乘以数字一样
in
检测元素在数组中
not in
检测元素不在列表中
'aaa' in emp //True

24、元组
创建元组
gyy=(1,2,3,4)
gyy1=(1,)
gyy2=1,2,3 //创建元组，逗号是关键
gyy3=() //创建空元组
其他操作和列表差不多，但是不能更改数据
gyy[1]=3 //会报错，不能更改数据
3*(3,) //数字乘以一个元组，结果是重复这个元组3次，(3,3,3)
更新和删除元组
通过切片的方式更新元组
gyy=gyy[:2]+(0,)+gyy[2:] //将标签gyy贴到新元组中，新元组的值(1,2,0,3,4)
del gyy //删除整个元组
python和java一样，有自动回收的功能

25、字符串
和元组一样，不能被修改，如果要修改和元组的方式一样
字符串的常用方法
gyy='guyy'
capitalize() //第一个字符改为大写
casefold() //把整个字符串的所有字符改为小写
center(width) //将字符串居中，并且使用空格填充至长度width的新字符串
count(sub[[start],[end]]) //返回sub在字符串中出现的次数，start和end参数表示范围，可选
encode(encoding='utf-8',errors='strict') //以encoding指定的编码格式对字符串进行编码
endswith(sub[[start],[end]]) //检查字符串是否以sub结束，start和end是可选参数，是就返回True，不是就返回False
expandtabs([tabsize=8]) //将字符串中的\t转化为空格，默认一个\t转化为8个空格
find(sub[[start],[end]]) //检查sub是否在字符串中，如果在就返回索引值(第一个字符所在的位置)，如果不在就返回-1
index(sub[[start],[end]]) //和find方法一样，但是当sub不在字符串中的时候，会返回异常
isalnum() //如果字符串至少有一个字符，并且所有的字符都是字母或者数字(可以同时包含字母或者数字)，就返回True，否则返回False
isalpha() //如果字符串至少有一个字符，并且所有字符都是字母，则返回True，否则返回False
isdecimal() //如果字符串只包含十进制数字则返回True，否则返回False
isdigit() //如果字符串只包含数字则返回True，否则返回False
isspace() //只包含空格就返回True
istitle() //所有字符串都是标题化，所有单词都是大写开头，其余字母小写，则返回True
isupper() //所有字符都是大写，则返回True
join(sub) //将字符串插入到sub的所有字符之间
gyy='gyy'
gyy.join('123') //结果为1gyy2gyy3
ljust(width) //返回一个左对齐字符串，并且使用空格填充至width宽度
lower() //转换字符串中所有大写字符为小写
lstrip() //去掉字符串左边的所有空格
partition(sub[[start],[end]]) //找到子串sub，把字符串分成一个3元组(preSub,sub,folSub),如果字符串中不包含sub，则返回(‘原字符串’,'','')
replace(old,new[,count]) //把字符串中的old子串替换成new子字符串，如果count被指定了，那么替换的次数不超过count次
rfind(sub[[start],[end]]) //和find一样，只不过从右边开始查找
rindex()
rjust()
rpartition()
rstrip() //以上方法都是从右边开始查找
split(sep=None,maxsplit) //不带参数默认以空格作为分隔符分割字符串，如果maxsplit设置了，那么就仅仅分割maxsplit个子串，分割后的子串组成列表
splitlines(([keepends])) //按照\n分割，返回一个包含各行作为元素的列表，如果keepends参数指定了，则返回keepends行
startswith(prefix[[start],[end]]) //判断是不是以prefix开头
strip([chars]) //删除字符串前面和后面的所有的空格，chars指定删除的字符
swapcase() //反转字符串中的大小写
title() //将字符串标题化
translate(table) //根据table的规则，转换字符串中的字符，规则可以由str.maketrans('a','b')定制
gyy='aaaacccc'
gyy.translate(str.maketrans('c','b')) //将结果转化为aaaabbbb
upper() //转化字符串中的所有小写字符为大写
zfill(width) //返回长度为width的字符串，原字符串右对齐，前边用0填充

26、字符串格式化 format
'{0} aa {1} {2}'.format('oo','bb','cc') //结果为ooaabbcc
以指定key的方式格式化
'{a} aa {b} {c}'.format(a='oo',b='bb',c='cc') //结果为ooaabbcc
当混合使用的时候，不指定key的参数必须在指定key的参数之前，参照c++中的函数的默认参数的使用方法
'{0} aa {b} {c}'.format('oo',b='bb',c='cc')
'{a} aa {0} {c}'.format(a='oo','bb',c='cc') //会报错
在这里使用花括号{}对参数进行转义，直接打印参数，而不是使用\进行转义
'{{0}}'.format('abc') //这里不会将abc传入参数中，因为被转义，所以打印的结果是{0}
'{0:.1f}{1}'.format(21.321,'GB') //结果为21.3GB，这里只保留1位小数，因为.1f
'%c' %97 //将ascii码转化为字符，结果为a
'%c%c%c' % (97,98,99) //结果为abc，当有多个ascii码作为参数时，需要用小括号括起来

%s	格式化字符串
	'%s' % 'gyy'
%d	整数
%o	无符号八进制
%x或者%X	无符号十六进制
%f	浮点数，可以指定精度，默认6位
%e或者%E	科学计数法
%g或者%G	根据值的大小决定使用%f或者%e

格式化操作辅助命令
m.n	m是最小总宽度，n是小数点后面的位数，也就是说总位数少于m的时候，左端用0补齐
-	左对齐
+	在正数前面加上一个加号+
#	在八进制数前面显示'0'，在十六进制前面显示0x或者0X
	'%#o' % 10
		0o12
0	显示的数字前面填充0取代空格

27、序列
序列包括列表，元组，字符串
list()
gyy='abc'
list(gyy) //结果是['a','b','c'],将可迭代的对象转化为列表
tuple()
tuple(gyy) //结果是('a','b','c'),将可迭代的对象转化为元组
str()
转化为字符串
len() //返回长度
max() //返回最大的值
max(gyy) //返回c，注意他们的元素的类型必须是一样的
min() //返回最小值
sum() //求和
元素必须是数据类型才可以加，例如整数，浮点数
sum[iterable,[start]] //start是可选参数，默认值为0，返回的结果是序列的元素之和再加上start的值
sorted() //排序
reversed() //反转
返回的值是一个迭代器，需要使用list()或者tuple()等等函数转化为列表或者元组
enumerate() //将序列中每个元素变成一个元组，这个元组中包含的是位置和值
gyy=['a','b','c']
enumerate(gyy) //[(0,'a'),(1,'b'),(2,'c')]
zip() //合并两个序列，变成元组
a=[1,2,3,4,5]
b=[4,5,6,7,8,9]
list(zip(a,b)) //[(1,4),(2,5),(3,6),(4,7),(5,8)]
以上函数的参数都是一个序列

28、函数
def myfunc():
print('my first function')
def mysecfunc(params1,params2):
print(params1,params2)
return params1+params2
myfunc.doc //打印帮助文档
help(myfunc) //打印帮助文档

关键字参数	//和前面format类似
	def myfunc(name,words):
		print(name+'->'+words)
	调用参数的时候，如果使用了关键字参数，那么就可以转换传入参数的顺序
		myfunc(words='aa',name='gyy')		//结果同样是gyy->aa
默认参数
	def myfunc(name='gyy',words='aa'):
		print(name+'->'+words)
	使用方法和c++的默认参数使用一样
收集参数（可变参数）
	方法就是在参数前面加上一个星号*
		def func(*params):
			print('the length of the params:',len(params))
			print('the second params:',params[1])
		func(1,'aa',12)		//会打印'aa'
	当函数还有正常参数的时候，就需要使用关键字参数给函数传递正常的参数
		def func(*params,exp)
			code....
		func(1,2,3,exp=4)	//此时传递给exp的值就是4
当函数没有返回值的时候，会返回None
而且可以像Go一样返回多个值
在函数内修改全局变量的话，会在函数内部创建一个同名的局部变量，而全局变量不被改变
但是只要在函数内部在要先使用global关键字声明变量就可以不屏蔽外面了，也就是说可以在函数内部修改全局变量了
	count=5
	def func():
		global count
		count=10
	//此时全局变量已经被修改为了10

29、内嵌函数和闭包
一个最简单的例子
def fun1():
print('func1 is being called')
def func2():
print('func2 is being called')
func2()

当调用函数func1的时候，也会执行func1内部的函数func2
当出了函数func1，func2就不能使用了

闭包
	闭包主要就是返回一个函数对象
	一个简单的例子
		def func1(x):
			def func2(y)
				return x*y
			return func2
		i=func1(2)	//此时i的类型是一个函数，就是func2，只不过传入的x的值已经指定了，就是2
				//i的内容如下
				//	def func2(y):
						return 2*y
		i(5)		//此时返回的结果就是10

	另一个例子
		def func1():
			x=5
			def func2():
				x*=5
				return x
			return func2()
		func1()	//会报错，因为此时x相当于fucn2()的全局变量，在func2()中修改x的值的时候，python的机制就会屏蔽全局变量，所以此时x就相当于一个没有初始化的变量
			//但是，如果在func2()中，没有对x的值做出修改，那么是不会报错的
	
	改进
			//上面会报错。是因为x是因为在func1中，x的值被存入的地方是栈，而不是堆，所以会被屏蔽，如果是真正的全局变量，那么就是存在堆中，就不会被屏蔽了，就不会报错
			//所以在python2中的一个改进的方法是传入一个容器，因为容器是不会被存在栈中的
		def func1():
			x=[5]	//传入一个列表
			def func2():
				x[0]*=x[0]
				return x[0]
			return func2()	//因为传入的是容器，相当于传入的是一个地址，所以地址传递，所以能够修改值
	改进2
		在python3中的新方法
		使用nonlocal,使用方法和global关键字一样
		def func1():
			x=5
			def func2():
				nonlocal x	//声明x不是func2()中的一个新的局部变量
				x*=x
				return x
			return func2()

30、lambda表达式
如果使用函数实现功能
def func(x):
return 2x+1
可以使用lambda实现同样的功能
g=lambda x:2x+1 //这里返回的g是一个函数，其中冒号前面的x是传入lambda表达式的参数，冒号后面是返回的值
g(5) //得到结果11
如果lambda表示是具有多个参数，那么就逗号隔开
g=lambda x,y:x*y+1
g(4,4) //结果为17

31、两个使用的bif
filter() //过滤器
filter([func],iterable) //第一个参数可以是一个函数或者None，第二个参数是一个迭代器，比如序列
//当第一个参数为None的时候，就返回迭代器里面为True的值
// list(filter(None,[1,0,False,True])) //结果为[1,True]
//当第一个参数不是None，而是一个函数的时候，则将后面迭代器中的每一个元素传入这个函数，对于返回值为True的元素，则从filter中返回
def func(x):
return x%2
tmp=range(10)
list(filter(func,tmp)) //结果是[1,3,5,7,9]
//上述过程使用lambda表达式实现
list(filter(lambda x:x%2,range(10)))
map() //映射
map(func,iterable) //将迭代器中每一个元素都作为函数func的参数传入，并且得到计算结果，然后将结果输出
// list(map(lambda x:x*2,range(5))) //结果为[0,2,4,6,8]
这两个函数相当于js中的高阶函数

32、递归
python3的默认递归的深度是100层，可以通过以下方法修改深度。超过定义的最大深度，就会报错
import sys
sys.setrecursionlimit(1000) //此时设置的深度就是1000层

33、字典
由大括号指定
dict={'a':'aa','b':'bb','c':'cc'}
dict['b'] //结果为'bb'
dict2={} //创建空字典
其他创建方式
dict=dict((('1',1),('2',2))) //传进去的参数是元组，第二层括号的作用是将元组转化为map映射
dict=(1='q',2='a') //这样的情况下，键是不能够加引号的
dict[2]='b' //转换键值
dict[3]='f' //增加键值
formatkeys用法
dict={}
dict.formatkeys((1,2,3)) //{1:None,2:None,3:None}
dict.formatkeys((1,2,3),'num') //{1:'num',2:'num',3:'num'}
keys() //返回所有的键
values() //返回所有的值
items() //返回所有的键值对
get()
dict.get(key) //返回键的值，当键不存在的时候，返回None
dict.get(key,info) //当不存在键key的时候，返回信息info
clear() //清空字典
copy() //和直接等号不一样，直接等号只是增加了一个名字标签，copy()才是真正在内存中复制了字典
pop(key) //弹出键值对
popitem() //随机弹出一个键值对
setdefault()
dict.setdefault(6) //查找键6，如果不存在就向字典中加入键，对应的值为None
dict.setdefault(6,'f') //查找键6，如果不存在就增加键值对6:'f'
update()
dict.update(dict2) //用dict2去更新dict，如果键存在就更新值，否则插入键值对

34、集合set
创建集合的方法
1）将一堆元素用{}括起来 set1={1,2,3,4} //集合中元素是唯一的
2）使用工厂函数set(),传入的参数是一个序列 set1=set('abc') //结果是{'a','b','c'}
add() //添加元素
remove() //移除元素
frozenset() //定义不可变集合
参数是一个序列

35、文件
打开文件open(filename,operation)
'r' //以只读方式打开文件
'w' //以写入的方式打开文件，会覆盖已存在的文件以及内容
'x' //如果文件已经存在，使用这个模式打开文件会出现异常
'a' //以写入的方式打开文件，如果文件存在，则在末尾追加写入
'b' //以二进制模式打开文件
't' //以文本模式打开文件（默认的模式）
'+' //可读写模式打开文件（可添加到其他模式中使用）
'U' //通用换行符支持
f.close() //关闭文件
f.read(size=-1) //从文件读取size个字符，当未给定size或者size为负，那么读取剩余的所有字符，然后作为字符串返回
f.readline() //读取一行，遇到\n停止
f.write(str) //将字符串str写入文件，写入文件后，需要执行close()，才会真正写入到文件中，否则数据是保存在缓冲区里面的
f.writelines(seq) //向文件写入字符序列seq,seq是一个可以返回字符串的可迭代的对象
f.seek(offset,from) //移动文件指针，从from开始移动offset个位置，from为0表示从起始位置开始，1表示从当前位置开始，为2表示从文件末尾
f.tell() //返回文件指针的位置
f=open(filename)
for eachLine in f: //f是一个文件对象，可以用for循环取出所有内容
print(eachLine)

36、模块
模块是包含自定义函数和变量的文件，其后缀名是.py,模块可以被其他程序引入，然后使用这个模块中的函数等功能
os: 使得python程序不需要关注系统的底层实现
os模块下关于文件系统的常用的函数
getcwd() //返回当前工作目录
chdir(path) //改变工作目录
listdir(path='.') //列出指定目录下的所有文件
mkdir(path) //创建单层目录，如果目录已经存在，则抛出异常
makedirs(path) //递归创建多层目录，如果目录存在，则抛出异常
remove(path) //删除文件
rmdir(path) //删除单层目录，如果目录非空，则抛出异常
removedirs(path) //递归删除目录，从子目录到父目录逐层删除，遇到非空目录，则抛出异常
rename(old,new) //将文件old重命名为new
system(command) //运行系统的shell命令
walk(top) //遍历top路径下的所有的子目录，返回一个三元组：(路径,[包含目录],[包含文件])
os.curdir //当前目录.
os.pardir //父目录..
os.sep //路径分隔符，windows下'\'，linux下为'/'

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

37、pickle模块
这是一个令人惊叹的模块
它的作用是将一个类型的数据，例如序列等等转化为二进制数据，然后以二进制的形式写入文件，后面还可以读取二进制文件，并且将数据恢复为原来的数据类型
import pickle
pickFile=open('test','wb') //一定要加b,因为是将数据以二进制的形式写入文件
myList=['a',1,2,'b']
pickle.dump(myList,pickFile) //dump()函数将列表写入pickFile
pickFile.close()
pickFile=open('test','rb')
myList2=pick.load(pickFile) //load()将数据从文件读取出来，同样以二进制的形式
//myList2=['a',1,2,'b']

38、异常处理Exception
几个常用的异常
AssertionError //断言语句(assert)失败，当assert语句为假的时候抛出
AttributeError //尝试访问未知的对象属性，当访问的对象的属性不存在时，抛出这个异常
IndexError //索引超出序列范围
KeyError //字典中的键不存在map
NameError //访问一个不存在的变量
OSError //操作系统产生的异常(例如打开一个不存在的文件)
OverflowError //数值运算超出最大的限制
TypeError //类型不匹配
ZeroDivisionError //除数为0
捕获并且处理异常
try:
检测范围代码
except Exception[as reason]:
出现异常的后续处理代码
感觉这个和java的异常处理一样啊
reason是自定义的一个变量，里面包含了错误信息，可以先用str()转化为字符串然后打印
print(str(reason))
示例代码：
try:
sum=1+'1' //TypeError
f=open('te.txt') //OSError
except (TypeError,OSError) as reason: //同时捕获两个异常
print(str(reason))
//except TypeError as reason:
// print(str(reason))
//except OSError as reason:
// print(str(reason)) //分开捕获
try:
检测范围
except Exception [as reason]:
出现异常后处理的代码
finally:
无论如何都会执行的代码 //因为出现异常后，后面的代码就不会执行，而是直接调到捕获异常的代码的地方，然后退出程序，但是finally的代码就算出现了异常也会执行
raise //自己引出异常
raise gyy
//引出异常gyy

39、with语句
with语句的主要的作用就是可以自己关闭打开的文件
with open('test.txt','r') as f: //文件指针就是f

40、导入模块
import easygui as g //此时g就是模块easygui的别名

41、类class
类名以大写字母开头
class Gyy:
#distribution
name='gyy'
weight=100
#function
def run(self):
print('I'm runing')
//创建实例
person=Gyy()
person.run() //I'm runing

	class MyList(list):	//此时类MyList继承了list这个类,没有继承就不需要加小括号
		pass		//pass是一个占位符，表示不做任何事
示例代码
	class Ball:	
		def setName(self,name):
			self.name=name		//self就相当于c++,js中的this指针
		def kick(self):
			print(self.name)
	#实例化对象
		a=Ball()

可以通过重写构造方法然后传入参数，构造方法是__init__()
	class Ball:
		def __init__(self,name):	//还可以设置默认参数def __init__(self,name='ball a')
			self.name=name
		def kick(self):
			print(self.name)
	#实例化对象
		a=Ball('ball a')		

属性的私有化
	class Person:
		name='gyy'
		__age=18		//名字前面不加下划线就是公有变量，否则就是私有变量
事实上在python中只是将私有变量变了一个名字而已，传入正确的名字同样可以访问，正确的名字_ClassName_distributionName
	例如上面的_age属性：
		p=Person()
		p._Person_age		//18

42、继承
子类定义与父类相同的属性和方法会覆盖父类的属性和方法
当子类和父类的方法名相同，并且子类需要使用父类的方法，那么有两种方法可以实现
import random as r
class Fish:
def init(self)
self.x=r.randint(0,10)
self.y=r.randint(0,10)
class Shark(Fish):
def init(self):
Fish.init(self) //调用没有绑定父类的方法，因为传入的self参数是指向子类的
#另一种实现的方法，使用super()方法
#super().init()

多重继承
	class DeriverClassName(Base1,Base2,Base3):		//小括号中添加多个基类，就是多重继承
		...					

43、组合
就是将若干个类的实例化放到一个新的构造方法中，例如：
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 printNum(self):
print('there are %d turtles and %d fishes' % (self.turtle.num,self.fish.num))

44、类定义，类对象，实例对象

			|-------->实例对象
			|
类定义----->类对象--------------->实例对象
			|
			|-------->实例对象

如果属性名和方法名相同，属性会覆盖方法

45、一些相关的bif
issubclass(class,classinfo) //如果class是classinfo的子类，那么就返回true，并且一个类被认为是自身的子类
isinstance(object,classinfo) //检查实例对象object是不是类classinfo的实例对象，第二个参数可以是类的元组，只要其中一个元素满足条件，就返回true
hasattr(object,name) //检查name是不是对象object的属性，记得第二个参数一定要转化成字符串然后传进去
getattr(object,name[,default]) //返回对象object的属性name,记得要将name转换为字符串，default是一个可选参数，当属性不存在时，如果指定了default那么就返回deault否则就抛出异常
setattr(object,name,value) //给对象object的属性name设置一个值value，如果属性name不村子啊，那么就添加属性
delattr(object,name) //删除对象object中的属性name，如果属性不存在，那么就抛出异常
property(fget=None,fset=None,fdel=None,doc=NOne)
class C:
def init(self,size=10):
self.size=size
def getSize(self):
return self.size
def setSize(self,value):
self.size=value
def delSize(self):
del self.size
x=property(getSize,setSize,delSize)
c1=C()
c1.x //调用getSize()方法
c1.x=18 //调用setSize()方法
del c1.x //调用delSize方法

46、传说中的魔法方法
魔法方法被双下划线包围：
init
魔法方法是面向对象的Python的一切
init(self[,...]) //构造方法
new(cls[,...]) //在对象实例化之前被调用，第一个参数是class(类)
class CapStr(str): //new__是在__init__之前执行的，所以在这里重写__new__方法
def new(cls,string): //将字符串变为大写
string=string.upper()
return str.new(cls,string) //然后调用父类的__new
a=CapStr("Gyy") //结果a是GYY
del(self) //相当于一个析构器，当所有关于这个对象的引用都被del的时候，才会调用__del_)方法

__add__(self,other)		//定义了对象self的加法，和c++中的重写符号方法一样
		注意一个示例代码
			class TryInt(int):
				def __add__(self,other):
					return self+other
			a=TryInt(3)
			b=TryInt(5)
			a+b	//此时会无限递归的运行下去，因为一直调用的是TryInt类的方法，这个这个类的加法又是这两个对象相加
			
			//更改的方式
				def __add__(self,other):
					return int(self)+int(other)		//将对象a和b的类型由TryInt转化为int，所以就是调用int类的加法就不会无限递归了
__sub__(self,other)		//减法-
__mul__(self,other)		//乘法*
__truediv__(self,other)		//真除法/
__floordiv(self,other)		//整数除法//
__mod__(self,other)		//取余%
__divmod__(self,other)		//定义当被divmod()调用时的行为,例如divmod(a,b),返回的值为一个元组(a//b,a%b)
__pow__(self,other[,modulo])	//定义当被power()调用或者**运算时的行为
__lshift__(self,other)		//按位左移<<
__rshift__(self,other)		//按位右移>>
__and__(self,other)		//按位与&
__xor__(self,other)		//按位异或^
__or__(self,other)		//按位或|

上面的操作符函数都是正向操作的函数，在前面加一个r就反向操作符
__radd__(self,other)		//加法
__rsub__(self,other)             //减法-
    __rmul__(self,other)             //乘法*
    __rtruediv__(self,other)         //真除法/
    __rfloordiv(self,other)          //整数除法//
    __rmod__(self,other)             //取余%
    __rdivmod__(self,other)          //定义当被divmod()调用时的行为,例如divmod(a,b),返回的值为一个元组(a//b,a%b)
    __rpow__(self,other[,modulo])    //定义当被power()调用或者**运算时的行为
    __rlshift__(self,other)          //按位左移<<
    __rrshift__(self,other)          //按位右移>>
    __rand__(self,other)             //按位与&
    __rxor__(self,other)             //按位异或^
    __ror__(self,other)              //按位或|
	当操作符左边的数没有对应操作符的魔法函数的时候，就会调用右边操作数对应的反操作符函数
		class Nint(int):
			def __rsub__(self,other):
				return int.__sub__(self,other)
		a=Nint(5)	//a=5
		3-a		//结果是2
		因为3是一个数，不是由int(3)转化来的对象，所以它没有-对应的操作符函数__sub__(self,other)，所以会执行a的反操作符函数__rsub__(self,other)
		此时self=a,other=3
		所以上面的代码中int.__sub__(self,other)===5-3=2
在上面的魔法函数前面加上i，就是对应的增量运算符函数
例如__iadd__(self,other)		//对应了self+=other

一元操作符函数
__neg__(self)		//定义正号+
__pos__(self)		//负号-
__abs__(self)		//定义abs()调用时的行为
__invert__(self)	//定义按位求反的行为~x

__str__(self)		//这个方法可以在print()中使用时直接打印字符串
		class A:
			def __str__(self):
				return 'aaa'
		a=A()
		print(a)	//打印'aaa'
		class B:
			def __repr__(self):
				return 'bbb'
		b=B()
		b		//会直接打印'bbb'

47、时间模块
import time as t //这个模块记录了关于时间的方法

48、魔法函数访问对象属性
getattr(self,name) //定义当用户获取一个不存在的属性时的行为
getattribute(self,name) //定义当该类的属性被访问时的行为
setattr(self,name,value) //定义当一个属性被设置时的行为
delattr(self,name) //定义当一个属性被删除时的行为
示例代码
class C:
def getattribute(self,name):
print('getattribute')
return super().getattribute(name) //super()会自动找到当前类对应的基类，并且通过super()调用基类的方法的时候，不需要传入self参数
def getattr(self,name):
print('getattr')
def setattr(self,name,value):
print('setattr')
super().setattr(name,value) //同样通过super()调用基类的方法不需要传入self参数
def delattr(self,name):
print('delattr')
super().delattr(name)

		c=C()
		c.x		//输出getattribute
				//输出getattr
		c.x=1		//输出setattr
		c.x		//输出getattribute
				//输出1
		del c.x		//输出delattr

使用魔法方法有可能陷入无限循环，那么此时可以想办法调用基类的魔法方法或者使用__dict__属性
__dict__属性会返回一个字典，对应这个对象的所有的属性值
	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)
				//self.__dict__[name]=value	//因为此时感觉是给__dict__属性赋值，不是普通属性，所以不会调用__setattr__()??

49、描述符
描述符就是将某种特殊类型的类的实例指派给另一个类的属性
get(self,instance,owner) //用于访问属性，将返回它的属性值
set(self,instance,value) //将在属性分配操作中调用，不返回任何内容
delete(self,instance) //控制删除操作，不返回任何内容

自己实现property函数
	class Myproperty:
		def __init__(self,fget=None,fset=None,fdel=None):
			self.fget=fget
			self.fset=fset
			self.fdel=fdel
		def __get__(self,instance,owner):
			return self.fget(instance)
		def __set__(self,instance,value):
			self.fset(instance,value)
		def __delete__(self,instance):
			self.fdel(instance)

	class C:
		def __init__(self):
			self._x=None
		def getx(self):
			return self._x
		def setx(self,value):
			self._x=value
		def delx(self):
			del self._x

		x=Myproperty(getx,setx,delx)

	c=C()
	C.x='gyy'		//赋值了

天气示例代码
	class Celsius:
		def __init__(self,value=26):
			self.value=float(value)
		def __get__(self,instance,owner):
			return self.value
		def __set__(self,instance,value):
			self.value=float(value)			//instance指向的是Temperature这个类对象
	
	class Fahrenheit:
		def __get__(self,instance,owner):
			return instance.cel*1.8+32
		def __set__(self,instance,value):
			instance.cel=(float(value)-32)/1.8
	class Temperature:
		cel=Celsius()		//使用描述符
		fah=Fahrenheit()

50、容器
不可变容器
需要定义__len__()和__getitem__()方法
可变容器
需要定义__len()__,getitem(),setitem()和__delitem()方法

__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)时的行为
	定义容器示例代码
		首先一个字典的方法
			dict.fromkeys(seq[,value])	//将序列的元素作为字典的键，value为对应的初始值
	class CountList:
		def __init__(self,*args):		//*args表示为可变数量的参数
			self.value=[x for in args]	//此时self.value是一个列表
			self.count={}.fromkeys(range(len(self.value)),0)	
		def __len__(self):
			return len(self.value)
		def __getitem__(self,key):
			self.count[key]+=1
			return self.value[key]

51、迭代
每一次迭代就相当于每一次循环，并且每一次迭代得到的结果是下一次迭代的初始值
使用for in遍历字典得到的是它的键
iter()创建一个迭代器 对应的魔法方法__iter__()
next()获取迭代器中的值 对应的魔法方法__next__()
gyy='gyy'
it=iter(gyy)
next(it) //g
next(it) //y
next(it) //y

自己创建一个迭代器，就要实现上面两个魔法方法
	class Fibs:
		def __init__(self,a=0,b=1):
			self.a=a
			self.b=b
		def __iter__(self):
			return self
		def __next__(self):
			self.a,self.b=self.b,self.a+self.b
			return self.a
	fibs=Fibs()
	for each in fibs:
		if each < 20:
			print(each)
		else:
			break
以上就是两种方式遍历迭代器
	next(fibs)
	for each in fibs

52、生成器
和Go语言的生成器差不多，都是通过yield实现的
示例代码
def myGenerator():
yield 1
yield 2
myG=myGenerator()
next(myG) //输出1
next(myG) //输出2
或者使用for in
//for i in myGenerator():
print(i) //打印1,2

列表推导式
	a=[i for i in range(100) if ((not(i%2)) and (i%3))]	//加了这么多括号是为了好理解
	原式为：
	a=[i for i in range(100) if not(i%2) and i%3]
字典推导式
	b={i:i%2==0 for i in range}		//也就是说for循环前面的内容就是即将加入的元素
集合推导式
	c={i for i in [1,1,2,3,4,5,6,6]}	//结果{1,2,3,4,5,6}
生成器推导式
	e=(i for i in range(10))		//小括号不是元组推导式，而是生成器哦
	next(e)	//1
	next(e) //2
	next(e) //3

53、模块
直接看示例代码吧
在hello.py文件中
def hi():
print('hi,gyy')
在另一个文件test.py中
import hello //这里不要加后缀名.py
hello.hi() //就会打印hi,gyy

导入模块的方法
	1)import 模块名			//就和上面差不多
	2)from 模块名 import 函数名	
		在test.py文件中
		from hello import hi 	//如果有多个函数中间用逗号隔开		
		from hello import *	//使用*导入模块中所有的命名空间，包括变量名，函数名0
		hi()			//会打印hi,gyy
	3)import 模块名 as 新名字	//前面用过

模块就是程序，程序就是模块

54、if name'main'
示例
在hello.py文件中
def hi():
print('hi gyy')
if name'main' //在这个地方如果不加这个判断，那么当这个模块被导入其他包，它会在其他包中执行下面这个hi()函数，这个hi()函数在这个模块中执行是为了测试模块功能的
hi()

	在test.py文件中
	import hello from hi
	__name__=='main'
	hello.__name__=='hello'		//此时在hello.py那个文件中，它的__name__='hello',而不是'__main__',所以hello.py里面的hi()函数不会执行
	hi()	//打印hi gyy
	
搜索路径
	import sys
	sys.path		//python会在这个路径下面去查找模块
	sys.path是一个列表，所以当自己写的模块放到某个路径下面时，需要将绝对路径加入到这个列表中
	sys.path.append('/home/gyy')	//此后，python也会在这个路径下面找导入的模块

包(package)
	1)创建一个文件夹，然后将模块放入这个文件夹，文件夹的名字就是包的名字
	2)在文件夹中创建一个__init__.py的模块文件，内容可以为空
	导入包中的模块的方式
	import 包名.模块名
		import packageName.moduleName

55、装饰器
装饰器分为函数装饰器和类装饰器
函数装饰器 在不改变原来函数的功能的前提下，增加原来函数的功能
def useLogging(func):
def wrapper():
logging.warn("%s is running" % func.name)
return func() #把foo函数传进来时，执行func()就相当于执行foo()
return wrapper
#def foo():
# print("i am foo")

	@useLogging	#这个@useLogging === foo=useLogging(foo) 此时foo相当于wrapper
	def foo():
		print("i am foo")
	foo()	
如果foo函数需要参数的话：
	def useLogging(func):
                    def wrapper(*args,**kwargs):		//*args表示可变参数的数组，**kwargs表示可变参数的字典，当函数参数有默认值的时候使用，如def func(a=1)
                            logging.warn("%s is running" % func.__name__)
                            return func(*args,**kwargs)           #把foo函数传进来时，执行func()就相当于执行foo()
                    return wrapper
           
            @useLogging     #这个@useLogging === foo=useLogging(foo) 此时foo相当于wrapper
            def foo(*args,**kwargs):
                    print("i am foo")
            foo([],{})
装饰器本身带参数
	一般情况下，装饰器携带了唯一的参数，就是我们的业务函数，那么如果装饰器还需要其他参数：
	def useLogging(level):		#传入日志级别这个参数
		def decorator(func):	#真正的装饰器
			def wrapper(*args,**kwargs):
				if level=="warn":
					logging.warn("%s is running" % func.__name__)
				elif level=="info":
					logging.warn("%s is running" %s func.__name__)
				return func(*args,**kwargs)
			return wrapper
		return decorator		#这里就是返回真正的装饰器

	@useLogging("warn")	#返回decorator 也就是说@useLogging("warn")==@decorator
	def foo(name='foo'):
		print("i am %s" % name)

	foo()

类装饰器
	使用类装饰器主要是通过重写__call__(self)方法
	class Foo(object):
		def __init__(self,func):
			self._func=func
		def __call__(self):
			print("class decorator running")
			self._func()
			print("class decorator ending")
	@Foo		#因为函数也是一个对象，所以@Foo == bar=Foo(bar)一样的
	def bar():
		print("bar")
	bar()

此时使用装饰器，原函数bar的元信息docstring,__name__都变了，变成装饰器的元信息了
functools.wraps本身就是一个装饰器，它的作用是将原函数的元信息拷贝到装饰器的func函数中
	from functools import wraps
	def logged(func):
		@wraps(func)
		def withLogging(*agrs,**kwargs):
			...
		return withLogging
	@logged
	def f(x):
		...
	
一个函数还可以同时被多个装饰器定义
	@a
	@b
	@c
	def f()
		pass
	执行顺序为从里到外
		f=a(b(c(f)))

标签：__,知识点,name,python,self,返回,基础,字符串,def
来源： https://www.cnblogs.com/gyyyl/p/16609111.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。