一、python生成/迭代器
yiled生成数据
python迭代器, 访问数据(通过next一次一次去取)
二、反射
通过字符串的形式，导入模块
通过字符串的形式，到模块中，寻找指定的函数，并执行
实质：以字符串的形式，到对象中，操作（更改，删除等）其方法（或叫做操作成员）
__import__ 用于以字符串的形式寻找对象
getattr() 用于以字符串的形式去某个对象中寻找东西（函数，变量等）
hasattr() 用于以字符串的形式去某个对象中判断东西（函数，变量等）是否存在，存在返回True
setattr(模块名，变量名，变量值) 用于以字符串的形式去某个对象中添加东西（函数，变量等）（仅仅在内存中操作，源文件内容不变）
delattr() 用于以字符串的形式去某个对象中删除东西（函数，变量等）（仅仅在内存中操作，源文件内容不变）
自定义模块：
|
1
2
3
4
5
6
7
8
9
|
#!/bin/env python
# -*- coding:utf-8 -*-
# 自定义模块，名称：lianxi
name
=
'shaw'
def
s1():
return
's1 函数'
def
s2():
return
's2 函数'
|
导入模块并执行：（方法-）
|
1
2
3
4
5
6
7
8
|
#!/bin/env python
# -*- coding:utf-8 -*-
import
lianxi as lx
ret
=
lx.s1()
print
(ret)
###### 结果 ########
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lianxi2.py
s1 函数
|
导入模块并执行：（方法二）通过字符串的形式，导入模块
|
1
2
3
4
5
6
7
8
9
10
|
#!/bin/env python
# -*- coding:utf-8 -*-
shuru
=
input
(
'请输入模块名称：'
)
lx
=
__import__
(shuru)
# 相当于：import lianxi as lx
ret
=
lx.s1()
print
(ret)
###### 结果 ########
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lianxi2.py
请输入模块名称：lianxi
s1 函数
|
导入模块并执行：（方法三：反射）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/bin/env python
# -*- coding:utf-8 -*-
shuru
=
input
(
'请输入模块名称：'
)
# 导入多级模块方法
# __import__('time.time'，fromlist=True) 相当于from time import time
lx
=
__import__
(shuru)
hansh
=
input
(
'请输入函数名：'
)
target_func
=
getattr
(lx,hansh)
# 到模块中找到函数名,相当于上面的 lx.s1
ret
=
target_func()
# 执行函数
print
(ret)
######## 结果 ########
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lianxi2.py
请输入模块名称：lianxi
请输入函数名：s1
s1 函数
|
函数中找到东西
|
1
2
3
4
5
6
7
|
#!/bin/env python
# -*- coding:utf-8 -*-
shuru
=
input
(
'请输入模块名称：'
)
lx
=
__import__
(shuru)
hansh
=
input
(
'请输入函数名：'
)
target_func
=
getattr
(lx,
'name'
，
None
)
# 到模块中找到变量,’None’用于如果没找到，返回的值（防止报错）
print
(target_func )
|
反射的应用：web框架路由系统
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#!/bin/env python
# -*- coding:utf-8 -*-
def
login():
return
'login'
def
logout():
return
'logout'
######## index ########
#!/bin/env python
# -*- coding:utf-8 -*-
from
exam.lib
import
acc
url
=
input
(
'请输入url:'
)
ret
=
url.split(
'/'
)[
-
1
]
if
hasattr
(acc,ret):
r
=
getattr
(acc,ret)
s
=
r()
print
(s)
else
:
print
(
'404'
)
|
三、面向对象基础
初始面向对象
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class
shaw:
def
f1(
self
):
return
'f1'
def
f2(
self
, args):
return
args
obj
=
shaw()
ret
=
obj.f2(
'hah'
)
print
(ret)
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lianxi.py
hah
|
1、面向对象不是所有情况都适用
2、面向对象编程过程：
a．定义类
b．根据类创建对象（创建一个类的实例）(操作这一步时，实质是执行了该类的__init__方法)
c．适用对象执行类中方法
3、self 为形式参数，由python内部自动传递
obj = shaw()
obj.f2(‘haha’)
参数传递流程为：
self==obj,args==’hah’
即self就为创建的对(实例)
4．面向对象特性一：封装
|
1
2
3
4
5
6
7
8
9
10
11
|
class
shaw:
def f1(self):
return
self.args # self.args ==>obj.args 称为普通字段，存在于对象中
def f2(self):
return
self.args
# obj.args =
'www.cnblogs.com/opsedu'
这是封装的一种方式
obj = shaw()
obj.args =
'www.cnblogs.com/opsedu'
# 通过对象封装参数,不用每个方法中都写具体参数
ret = obj.f1()
print(ret)
|
主流的封装方式：通过构造函数(方法)封装：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class
shaw:
def
__init__(
self
):
self
.args
=
'www.cnblogs.com/opsedu'
def
f1(
self
):
return
self
.args
obj
=
shaw()
ret
=
obj.f1()
print
(ret)
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lianxi.py
www.cnblogs.com
/
opsedu
|
注意：
解释器销毁对象的时候，自动调用__del__(析构方法)
封装适用场景，当同一类型的方法，具有相同参数时，直接封装到对象即可
5．面向对象特性二：继承
当派生类和基类中，同时存在某个方法，优先使用派生类方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#!/bin/env python
# -*- coding:utf-8 -*-
class
shengwu:
def
chifan(
self
):
print
(
self
.name
+
'吃饭'
)
def
paobu(
self
):
print
(
self
.name
+
'不爱跑步'
)
class
renlei(shengwu):
def
__init__(
self
, name):
self
.name
=
name
def
paobu(
self
):
print
(
self
.name
+
'爱跑步'
)
ret
=
renlei(
'李林'
)
ret.paobu()
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lx3.py
李林爱跑步
|
Python类可以同时继承多个类(c#/java不可以)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#!/bin/env python
# -*- coding:utf-8 -*-
class
shengwu:
def
chifan(
self
):
print
(
self
.name
+
'吃饭'
)
def
paobu(
self
):
print
(
self
.name
+
'不爱跑步'
)
# relei类
class
renlei:
def
chuanyi(
self
):
print
(
self
.name
+
'穿衣服'
)
def
paobu(
self
):
print
(
self
.name
+
'不想跑步'
)
# boy类
class
boy(shengwu, renlei):
# 继承多个类，继承优先级，从左到右（）
def
__init__(
self
, name):
self
.name
=
name
def
paobu(
self
):
print
(
self
.name
+
'爱跑步'
)
ret
=
boy(
'李林'
)
ret.chifan()
ret.chuanyi()
ret.paobu()
######## 结果 ########
C:\Python35\python.exe H:
/
PyCharm
/
Python
/
PY_learn
/
lx3.py
李林吃饭
李林穿衣服
李林爱跑步
|
执行父类的构造方法：
548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
