第九课笔记:排序算法

网络大亨 发表了文章 0 个评论 1278 次浏览 2018-05-02 08:40 来自相关话题

http://note.youdao.com/noteshare?id=10cb6263c1ca53d51e8a6918932fa8e7&sub=D7669991F0AA407795D461A7EB09D81A
http://note.youdao.com/noteshare?id=10cb6263c1ca53d51e8a6918932fa8e7&sub=D7669991F0AA407795D461A7EB09D81A

第九课 - 冒泡排序,选择排序,快速排序和归并排序

小龙兔 发表了文章 0 个评论 1477 次浏览 2018-05-01 14:53 来自相关话题

# 冒泡排序 **原理** (1)循环遍历列表,每次循环找出本次循环最大的元素排在后面 (2)需要使用嵌套循环实现,外层循环控制总循数,内层循环负责每层的循环比较 ![](http://wenda.chi ...查看全部
# 冒泡排序
**原理**
(1)循环遍历列表,每次循环找出本次循环最大的元素排在后面
(2)需要使用嵌套循环实现,外层循环控制总循数,内层循环负责每层的循环比较
![](http://wenda.chinahadoop.cn/uploads/questions/20180501/b33d35a9f6473eeeb386050977548b63.png)

**算法:**
* 第一轮循环5次 = 循环列表的长度6 - 1,即元素之间比较次数;找出最大元素
* 第二轮循环4次 = 循环列表的长度6 - 找出的最大值个数1 - 1;依次类推。
* 第n轮循环n次 = 循环列表长度 m - 找出的最大值个数 j - 1
* n = 列表元素个数 - 1

**算法实现:**
```
# 排序的总轮数=列表元素个数 - 1
# 每轮元素互相比较的次数 = 列表元素个数 - 已经排好序的元素个数 - 1

#data_list:待排序列表
def bubble_sort(data_list):
num = len(data_list) #列表元素个数
for i in range(0,num -1):#排序的总轮数
print("第{}轮:".format(i))
for j in range(0,num-i-1):
if data_list[j] > data_list[j+1]:#前后两个元素比较
data_list[j],data_list[j+1] = data_list[j+1],data_list[j]
print(data_list)

```
# 选择排序
**原理**
(1)将待排序列表看成是未排序和已排序两部分
(2)每次从未排序列表中找出最小值放到已排序列表末尾
![](http://wenda.chinahadoop.cn/uploads/questions/20180501/8f7a8d9c9be02b419db780e451054a4d.png)

**算法实现**
```
#data_list:待排序列表
def select_sort(data_list):
list_len = len(data_list) #待排序元素个数
for i in range(0,list_len-1):#控制排序比较总轮数
tmp_min_index = i
for j in range(i+1,list_len):
if data_list[tmp_min_index] > data_list[j]:
tmp_min_index = j
if i != tmp_min_index:
data_list[i],data_list[tmp_min_index] = data_list[tmp_min_index],data_list[i]

print(data_list)
```

# 快速排序
**原理**
(1)一次排序按照一个基准值将待排序的列表分隔成两部分,基准值左边是比基准值小的元素,基准值右边是比基准值大的元素
(2)按照上一步的方法对基准值左右两部分数据分别进行快速排序
![](http://wenda.chinahadoop.cn/uploads/questions/20180501/c0a200d7c999ab49df14a6f560b74241.png)
**算法实现**
![](http://wenda.chinahadoop.cn/uploads/questions/20180501/494c95ba9ed27af9c85cc15c80698ac2.png)


# 归并排序
**原理**
先递归分解序列,再排序合并序列
![](http://wenda.chinahadoop.cn/uploads/questions/20180501/6c8b4242386e7c76e4032ba8db27cdf4.png)
**算法**
(1)拆分到不能分为止
(2)合并的过程中进行排序
**算法实现**
```
def merge_sort(data_list):
if len(data_list)<=1:
return data_list
#根据列表长度确定拆分的中间位置
mid_index = len(data_list) // 2
# left_list = data_list[:mid_index] #使用切片实现对列表的切分
# right_list = data_list[mid_index:]
left_list = merge_sort(data_list[:mid_index])
right_list = merge_sort(data_list[mid_index:])
return merge(left_list,right_list)

def merge(left_list,right_list):
l_index = 0
r_index = 0
merge_list = []
while l_index < len(left_list) and r_index < len(right_list):
if left_list[l_index] < right_list[r_index]:
merge_list.append(left_list[l_index])
l_index += 1
else:
merge_list.append(right_list[r_index])
r_index += 1

merge_list += left_list[l_index:]
merge_list += right_list[r_index:]
return merge_list
```
**排序算法调用输出:**
```
list = [28,32,14,12,53,42]
#冒泡排序
bubble_sort(list)
#选择排序
select_sort(list)
#快速排序
quick_sort(list,0,len(list)-1)
#归并排序
new_list = merge_sort(list)
print("--------排序结果--------")
print(new_list)
```

第九课 排序算法

Haley_Hu 发表了文章 0 个评论 1304 次浏览 2018-05-01 13:36 来自相关话题

链接:​http://note.youdao.com/noteshare?id=94f40a9af374e5fe78031221c2454d66&sub=5918C610330B4E38AA64BA2D6C833022​   脑图如 ...查看全部
链接:​http://note.youdao.com/noteshare?id=94f40a9af374e5fe78031221c2454d66&sub=5918C610330B4E38AA64BA2D6C833022​
 
脑图如下:

排序算法.png

 

第九课 排序算法

辣椒晶晶 发表了文章 0 个评论 1317 次浏览 2018-04-30 20:28 来自相关话题

这部分内容我比较熟,本周也才给学生们讲了排序算法,不过我讲的是比较交换法、选择法、冒泡法、插入法排序和希尔排序,所以这次笔记内容更多的是排序算法编写及调用,算法思想要好好悟哦。 ...查看全部
这部分内容我比较熟,本周也才给学生们讲了排序算法,不过我讲的是比较交换法、选择法、冒泡法、插入法排序和希尔排序,所以这次笔记内容更多的是排序算法编写及调用,算法思想要好好悟哦。

IMG_1572(20180430-202408).jpg


IMG_1573(20180430-202417).jpg


IMG_1574(20180430-202427).jpg

 

第八课:正则表达式

青峰 发表了文章 0 个评论 1305 次浏览 2018-04-28 19:01 来自相关话题

烦请移步到以下链接: https://note.youdao.com/share/?id=65a6c900f599938a2c66a4f730721018&type=note#/  
烦请移步到以下链接:
https://note.youdao.com/share/?id=65a6c900f599938a2c66a4f730721018&type=note#/
 

第八课笔记:正则表达式

网络大亨 发表了文章 0 个评论 1329 次浏览 2018-04-28 13:50 来自相关话题

http://note.youdao.com/noteshare?id=42b8a9c54ea22990d93e91f3fff7bcc0&sub=B51F555CDDAD47798CC40C44C970B568
http://note.youdao.com/noteshare?id=42b8a9c54ea22990d93e91f3fff7bcc0&sub=B51F555CDDAD47798CC40C44C970B568

第八课 正则表达式

辣椒晶晶 发表了文章 0 个评论 1232 次浏览 2018-04-27 22:26 来自相关话题

     这节课内容很多,例子很多,可是悲催的是刚听到兴趣正浓的时候停电了……差点气的把桌子掀了。课和笔记都是周五补的,唉,虽然很少遇见停电,但还是希望周六别停电。 ...查看全部
     这节课内容很多,例子很多,可是悲催的是刚听到兴趣正浓的时候停电了……差点气的把桌子掀了。课和笔记都是周五补的,唉,虽然很少遇见停电,但还是希望周六别停电。
IMG_1557(20180427-222236).jpg


IMG_1558(20180427-222244).jpg


IMG_1559(20180427-222252).jpg


IMG_1560(20180427-222300).jpg


IMG_1561(20180427-222307).jpg

 

第八课 - 正则表达式

小龙兔 发表了文章 0 个评论 1357 次浏览 2018-04-27 15:20 来自相关话题

# 概述 正则表达式是一个特殊的字符序列,它常常用于检查是否与某种模式匹配。第八节课主要从以下几方面介绍了Python正则表达式的用法。 (1)re模块的使用 (2)字符匹配、数量表示、边界表示 (3)正则表达式 ...查看全部
# 概述
正则表达式是一个特殊的字符序列,它常常用于检查是否与某种模式匹配。第八节课主要从以下几方面介绍了Python正则表达式的用法。
(1)re模块的使用
(2)字符匹配、数量表示、边界表示
(3)正则表达式的高级用法
(4)贪婪与非贪婪模式

# re模块
(一)match(正则表达式,待匹配字符串)
(1)采用从左向右逐项匹配,从起始位置起。
(2)用于正则匹配检查,如果“待匹配字符串”能够匹配“正则表达式”,则match方法返回匹配对象,否则返回None
```
import re #导入re模块

#从起始位置开始匹配
rs = re.match("chinahadoop", "chinahadoop.cn")
print(rs.group())

#不从起始位置开始匹配
rs = re.match("cn", "chinahadoop.cn")
```
运行结果:
```
chinahadoop
None
```

(二)group()方法 :用来返回字符串的匹配部分

# 字符匹配、数量表示、边界表示
**(一)单字符匹配**
![](http://wenda.chinahadoop.cn/uploads/questions/20180427/d6e50502f8547f691c4db264e512b86f.png)
(1). 匹配除"\n"之外的任意单个字符
```
import re

rs = re.match(".", "a")
print(rs.group())

rs = re.match("...", "abc") #多个字符
print(rs.group())

rs = re.match(".", "\n")
print(rs)
```
运行结果:
```
a
abc
None
```

(2)\s:匹配任意空白字符,如空格,制表符“\t”,换行符“\n”
```
import re
rs = re.match("\s", "\t")
print(rs)
rs = re.match("\s", "\n")
print(rs)
rs = re.match("\s", " ")
print(rs)
```
(3)\S:匹配任意非空字符;和\s模式相反
```
rs = re.match("\S", "\t")
print(rs)
rs = re.match("\S", "abc") #匹配单个字符,从起始位置
print(rs.group())
```
运行结果:
```
None
a
```
(4)[]: 匹配[ ]中列举的字符
```
rs = re.match("[Hh]", "hello")
print(rs.group())
rs = re.match("[Hh]", "Hello")
print(rs.group())

rs = re.match("[0123456789]", "32")
print(rs.group())
rs = re.match("[0-9]", "3")
print(rs.group())
```
运行返回结果:
```
h
H
3
3
```
其他单字符匹配用法不一一列举。
**(二)数量表示**
![](http://wenda.chinahadoop.cn/uploads/questions/20180427/46a3adb3096c9ce3c51abf90d6d9c103.png)
(1)* 出现次数 n >= 0
```
import re

rs = re.match("1\d*", "1234567") #起始是1,后面数字[0-9]出现任意次
print(rs.group())

rs = re.match("1\d*", "1234567abc") #起始是1,后面数字[0-9]出现任意次
print(rs.group())
```
运行结果:
```
1234567
1234567
```
(2)+ 出现次数n >=1
```
rs = re.match("\d+", "abc")
print(rs)
rs = re.match("\d+", "1abc")
print(rs.group())
```
运行结果:
```
None
1
```
(3){m}, {m,} 和 {m, n}
```
#{m} : 一个字符出现m次
rs = re.match("\d{3}", "123abc")
print(rs.group())

#{m,} :一个字符至少出现m次
rs = re.match("\d{1,}", "123467abc") #等价于+至少一次
print(rs.group())

#{m,n} :一个字符出现m到n次
rs = re.match("\d{0,1}", "1abc") #等价于?至多一次
print(rs.group())
```
运行结果:
```
123
123467
1
```
(4)\转义字符
```
str1 = "hello\\world"
print(str1)

str2 = "hello\\\\world"
print(str2)
str3 = r"hello\\world" #原生字符:r"str"
print(str3)
rs = re.match("\w{5}\\\\\\\\\w{5}",str3)
print(rs.group())
rs = re.match(r"\w{5}\\\\\w{5}",str3)
print(rs.group())
```
运行结果:
```
hello\world
hello\\world
hello\\world
hello\\world
hello\\world
```
**(三)边界表示**
(1)字符串与单词边界:$结尾
```
rs = re.match("\w{3,10}@163.com","hello_124@163mcom")
print(rs.group())

rs = re.match("\w{3,10}@163\.com$","hello_124@163.com")
print(rs.group())
```
运行结果:
```
hello_124@163mcom
hello_124@163.com
```
注意:第一个邮箱匹配实际是我们不期望的。但是它仍然被匹配成功,是因为字符**. **被当成单字符匹配了。所以我们需要加上转义字符,让**. **被当成正常字符。
(2)匹配分组:()分组,索引可由自己制定,比如?P
```
html_str = "python"
rs = re.match(r"<.+><.+>.+",html_str)
print(rs.group())
html_str2 = "python</head>"
rs = re.match(r"<.+><.+>.+",html_str2) #wrong to match
print(rs.group())
rs = re.match(r"<(.+)><(.+)>.+",html_str) #\2 and \1 is an index
print(rs.group())
rs = re.match(r"<(?P.+)><(?P.+)>.+",html_str)
print(rs.group())
```
运行结果:
```
python
python</head>
python
python
```
# 正则表达式的高级用法:
**search(), findall(), finditer(), and sub()方法**
```
#search
rs = re.search("car","haha car carbal abcar carbal")
print(rs.group())

#findall : return a list
rs = re.findall("car","haha car carbal abcar carbal")
print(rs)

mail_str = "zhangsan:helloworld@163.com,li:123456@qq.cn"
list = re.findall(r"(\w{3,20}@(163|qq)\.(com|cn))",mail_str)
print(list)

#finditer
itor = re.finditer(r"\w{3,20}@(163|qq)\.(com|cn)",mail_str)
for it in itor:
print(it.group())

#sub :java 被python替换。sub()方法的第二个参数还可以是一个函数。
str = "java python c cpp java"
rs = re.sub(r"java","python",str)
print(rs)
```
运行结果:
```
car
['car', 'car', 'car', 'car']
[('helloworld@163.com', '163', 'com'), ('123456@qq.cn', 'qq', 'cn')]
helloworld@163.com
123456@qq.cn
python python c cpp python
```
# 贪婪与非贪婪模式
(1)贪婪模式:尽可能的匹配更多的字符
(2)非贪婪模式:与贪婪模式相反
```
rs = re.findall(r"hello\d*","hello12345")
print(rs)

rs = re.findall(r"hello\d*?","hello12345")
print(rs)
```
运行结果:
```
['hello12345']
['hello']
```
作业链接:
http://wenda.chinahadoop.cn/article/702

第八课

Haley_Hu 发表了文章 1 个评论 1242 次浏览 2018-04-26 13:38 来自相关话题

请看链接:http://note.youdao.com/noteshare?id=2e9ada558be161b74f17c6586dd1a66a&sub=1E96072C759C43679D87F9137511DFC4​   如果 ...查看全部
请看链接:http://note.youdao.com/noteshare?id=2e9ada558be161b74f17c6586dd1a66a&sub=1E96072C759C43679D87F9137511DFC4​
 
如果有错,请帮忙指出,谢谢~
 

正则表达式.png

 

第七课:面向对象之类属性和类方法,错误和异常,模块

青峰 发表了文章 0 个评论 1274 次浏览 2018-04-24 19:02 来自相关话题

还请移步到以下链接: https://note.youdao.com/share/?id=d76a308b87825bf829b55acf8fc4f824&type=note#/
还请移步到以下链接:
https://note.youdao.com/share/?id=d76a308b87825bf829b55acf8fc4f824&type=note#/

第七课笔记:面向对象(下)与异常处理

网络大亨 发表了文章 0 个评论 944 次浏览 2018-04-24 15:50 来自相关话题

http://note.youdao.com/noteshare?id=54a7ccb8201964af2227c69b487cb580&sub=238AC5AE86014F42B3512D4F3C752CCA
http://note.youdao.com/noteshare?id=54a7ccb8201964af2227c69b487cb580&sub=238AC5AE86014F42B3512D4F3C752CCA

第七课:面向对象(下)、异常处理、包和模块

小龙兔 发表了文章 0 个评论 1046 次浏览 2018-04-23 21:29 来自相关话题

# 概述: 上一节主要介绍了面向对象的一些基本概念:类,类的组成元素“方法和属性”,类的特性“继承,多态和封装”。这一节课分为三部分: (一)类属性、类方法及调用、静态方法及调用和单例类 (二)异常处理 (三) ...查看全部
# 概述:
上一节主要介绍了面向对象的一些基本概念:类,类的组成元素“方法和属性”,类的特性“继承,多态和封装”。这一节课分为三部分:
(一)类属性、类方法及调用、静态方法及调用和单例类
(二)异常处理
(三)包和模块

# 第一部分:类方法、静态方法和单例类
**类属性**
(1)类属性区别于实例的属性,类属性属于类对象,被实例对象所共享
(2)查找属性规则:先实例对象的实例属性;后类对象的类(?)属性
(3)通过实例对象不能修改类属性的值;如果修改的属性在实例中不存在,则动态添加实例属性
```
class Person:
sum_num = 0

def __init__(self):
Person.sum_num += 1 #修改类属性值,每创建一个实例对象,类属性值加1

#实例对象p1和类对象的类属性值一致
p1 = Person("zhangsan")
print(p1.sum_num, Person.sum_num)


#通过实例对象不能修改类属性值,如果修改的属性在实例总不存在,则动态添加实例属性
p1.sum_num = 100
print(p1.sum_num, Person.sum_num)


```
**类方法及调用**

(1)使用@classmethod修饰的方法,第一个参数是cls
(2)类方法操作类属性;实例方法操作实例对象属性
(3)调用方式:类名.类方法();实例对象.类方法() #不推荐用此方法调用类方法
```
class Date(object):

def __init__(self, day=0, month=0, year=0):
self.day = day
self.month = month
self.year = year

#类方法
@classmethod
def from_string(cls, date_as_string):
day, month, year = map(int, date_as_string.split('-'))
date1 = cls(day, month, year)
return date1
```
**静态方法及调用**

(1)使用@staticmethod修饰的方法,不需要传入任何参数
(2)应用在跟类和对象没有关系的一些功能上。尽量少用静态方法。
```
#静态方法
@staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split('-'))
return day <= 31 and month <= 12 and year <= 3999
```
**单例类**
(1)__new__(cls)是超类object类内置的方法。参数cls是类对象
(2)用户创建对象,返回创建对象的引用。
```
#通过id(cls)可以查看类对象以及实例对象的地址
class DataBaseObj(object):
def __init__(self): #对象初始化
print("-------init 构造函数-------")

def __new__(cls): #构造对象
print("cls_id:" id(cls))
return object.__new__(cls) #返回对象的引用
```
(3)在整个程序系统中,只有一个实例对象。概念等同设计模式中的singleton模式。
```
class SingleInstance:
__instance = None
def __init__(self):
print("-----init-----")

def __new__(cls):
if cls.__instance == None:
cls.__instance = object.__new__(cls)
return cls.__instance

s1 = SingleInstance()
print(id(s1))
s2 = SingleInstance()
print(id(s2))
```

# 第二部分:异常处理
(1)捕获异常
```
try:
逻辑代码
except ExceptionType as err:
异常处理
```
(2)捕获多个异常
```
try:
逻辑代码
except (ExceptionType1, ExceptionType2, ...) as err:
异常处理
```
(3)捕获所有可能发生的异常
```
try:
逻辑代码
except Exception as err:
异常处理
```
(4)finally
```
try:
逻辑代码
except Exception as err:
异常处理
finally:
代码块 (无论是否有异常发生,代码都会执行到这里)
```
(4)异常处理的意义:
* 防止某个业务产生异常而影响到整个程序中的其他业务
* 异常处理的本质不是解决异常,而是将出现异常时的不良影响降到最低

# 第三部分:包和模块
**(一)Python项目结构:**
(1)1个项目:n个包
(2)一个包:n个模块
(3)模块的名字:以.py为扩展名命名的文件
**(二)引入模块的方法:**
(1)导入一个模块:import model_name 或者 import module_name.model_name
(2)导入多个模块:import model_name1, model_name2, ...
(3)导入某个模块中的函数:from model_name import fun1, fun2
**(三)import model_name Vs from model_name import fun**
(1)前者是导入一模块,如果想引用模块的内容(class, method,variables...)必须用全名,即 [module_name].[attr_name]。
(2)后者是导入某一指定对象(class, 其它对象...), 然后就可以直接用这些对象,不需要加上[module_name], 即[attr_name]。
**(四)特别用法:**
(1)如果你只想导入一个包里面的某个模块被其他包所使用,你可以在__init__.py文件里添加一句:__all__ = ["model_name"]
(2)批量导入:from package import *;(1)对(2)起约束作用。

第七课 面向对象(下)和异常处理

辣椒晶晶 发表了文章 0 个评论 945 次浏览 2018-04-23 15:16 来自相关话题

       因为周六晚上带孩子上辅导班,这次课是周日补的,笔记也是补的,左边是示例,右边知识点;上了这么七次课,感觉学到了很多学校课堂学不到的东西,就是对待一个项目的设计思想,给老师点赞,给小象点赞。 ...查看全部
       因为周六晚上带孩子上辅导班,这次课是周日补的,笔记也是补的,左边是示例,右边知识点;上了这么七次课,感觉学到了很多学校课堂学不到的东西,就是对待一个项目的设计思想,给老师点赞,给小象点赞。
IMG_1525(20180423-151023).jpg


IMG_1526(20180423-151030).jpg


IMG_1527(20180423-151041).jpg


IMG_1528(20180423-151047).jpg


IMG_1529(20180423-151055).jpg


IMG_1530(20180423-151101).jpg

第七课

Haley_Hu 发表了文章 0 个评论 822 次浏览 2018-04-23 00:09 来自相关话题

链接:http://note.youdao.com/noteshare?id=357ffee26f16ea2c689b339c04e96473&sub=5819543B285043559BEDB3E2BFC7266E​ 如有错误,请指出,谢谢!! ...查看全部
链接:http://note.youdao.com/noteshare?id=357ffee26f16ea2c689b339c04e96473&sub=5819543B285043559BEDB3E2BFC7266E​
如有错误,请指出,谢谢!!
下面是脑图:
类.png


包和模块_(1).png


异常处理.png

 

第六课笔记 面向对象(中)

网络大亨 发表了文章 0 个评论 905 次浏览 2018-04-21 14:26 来自相关话题

http://note.youdao.com/noteshare?id=07aaabda23011aea363f4a2cbabbd226&sub=A474040CAA144650B758C16534F2643C
http://note.youdao.com/noteshare?id=07aaabda23011aea363f4a2cbabbd226&sub=A474040CAA144650B758C16534F2643C

第六课(类)

Haley_Hu 发表了文章 0 个评论 953 次浏览 2018-04-19 12:21 来自相关话题

以下是链接:http://note.youdao.com/noteshare?id=7d680c6cf8ba8acf82c2cfca8e8f3e01&sub=43A0E392DA7C4DCD910AD10ADDC94C2D​ 如果错误,请指出,谢 ...查看全部
以下是链接:http://note.youdao.com/noteshare?id=7d680c6cf8ba8acf82c2cfca8e8f3e01&sub=43A0E392DA7C4DCD910AD10ADDC94C2D​
如果错误,请指出,谢谢!
 
下面是脑图
类.png

 

第六课 - 面向对象编程

小龙兔 发表了文章 0 个评论 1062 次浏览 2018-04-18 21:40 来自相关话题

# 面向对象编程 **面向对象编程**,简称OOP:是一种解决软件服用的设计和编程方法。这种方法把软件系统中相似的逻辑操作、数据、状态等以类的形式描述出来,通过对象实例在软件系统中复用,从而提高软件开发效率。 # 类和对象 ...查看全部
# 面向对象编程
**面向对象编程**,简称OOP:是一种解决软件服用的设计和编程方法。这种方法把软件系统中相似的逻辑操作、数据、状态等以类的形式描述出来,通过对象实例在软件系统中复用,从而提高软件开发效率。

# 类和对象
**定义和关系**
**类**:一个事物的抽象,定义了一类事物的属性和行为。类具有继承,多态,封装等特性。
```
class 类名: #类命名规则遵守“大驼峰”
#默认要传入一个self参数,第一个参数必须是sel
def 方法名(self [, 参数列表]):
```
**对象**:通过类创建的一个具体事物,也就是类的实例,它具有状态和行为,可以做具体的事情。
```
对象变量名 = 类名()
```
**两者关系**:类相当于创建对象的模板,根据类可以创建一个或者多个对象实例。

# 类的方法
**类的构造方法**
_ _init_ _构造方法:用于对象创建时初始化
调用时间:在对象被实例化时被程序自动调用
程序不显示定义init方法,则程序默认调用一个无参init方法
对象创建过程示意图:
![](http://wenda.chinahadoop.cn/uploads/questions/20180418/5e7396ca7507bf70bf4f0b71a76ca407.png)

**类的私有方法**
只能在类内部调用,在类的外部无法调用
私有方法:在方法名前添加两个下划线,私有属性如是
类内部调用私有方法要使用**self.private_method()**的方式调用
```
class Comrade:
#私有方法
def __send_message(self):
print("消息已经向上级汇报")

def answer_secret(self, secret):
if secret == "芝麻开门":
print("接头成功!")
self.__send_message()#调用私有方法
else:
print("接头失败!")
comrade = Comrade()
comrade.answer_secret("芝麻开门")
```
**类的访问权限**
```
#设置对象属性
def __init__(self, gender, variety, name):
self.gender = gender
self.variety = variety
self.name = name
```
修改对象属性有两种形式:
* 直接对属性值进行赋值
* 通过方法对属性值进行修改。这是推荐方式。可以达到对数据进行封装。


# 类的特性一:继承和多重继承
**继承**
定义:在程序中,子类从父类继承,但是子类又可以提供除父类外自身独有的方法和属性。比如猫和狗都是动物,动物如果是父类的话,那么猫和狗就是动物的子类。父类通常是抽象出带有一些共性的特征和方法的类。
```
#父类Animal
class Animal:
def eat():
print("eat")
#Dog
class Dog(Animal):
def shout()
print("汪汪汪")
wangcai = Dog()
#调用父类的eat
wangcai.eat()
#调用自身成员方法
wangcai.shout()
```
**继承注意事项**
* 子类的非有属性、方法,会被子类继承
* 子类中方法的查找:先子类方法 =》后父类方法
* 子类可以继承祖先类的非私有属性和方法
* 在子类中调用父类的方法:ClassName.Method(self)

**多重继承**
定义:一个类可以从多个父类继承。
多继承的定义方式:
```python
class AI:
#人脸识别
def face_recongnition(self):
print("人脸识别")
def data_handle(self):
print("AI数据处理")

class BigData:
def data_analysis(self):
print("数据分析")
def data_handle(self):
print("BigData数据处理")

class Python(BigData, AI): #多重继承,Python从BigData和AI两个类继承
def operation(self):
print("自动化运维")
```
对于多重继承,子类调用查找同名方法的顺序:
* 取决于小括号内继承父类从左到右的顺序查找。
* 可以通过类的方法 _ _mro_ _来查看查找顺序。

# 类的特性二:多态
定义:一个抽象类有多个子类,不同的类表现出不同的形态。比如狗和猫,他们都会叫,但是叫的声音是不同的。
子类对父类允许访问的方法的实现过程进行重新编写
在子类中定义与父类同名的方法。子类可以根据需要,定义合适的方法实现逻辑。

# 综合例子: 继承和多态
```
class Animal:
def __init__(self):
print("---animal构造方法---")

def __private_method(self):
print("私有方法")
def eat(self):
print("----吃----")
def drink(self):
print("----喝----")
def run(self):
print("----跑----")

class Dog(Animal):
def __init__(self):
print("dog构造方法")
#父类方法重写
def run(self): #多态
print("摇着尾巴跑")
def hand(self):
Animal.run(self) #在子类中调用父类
print("------握手-----")

class GoldenDog(Dog):
def guid(self):
print("我能导航!")
```

第六课 面向对象(中)

辣椒晶晶 发表了文章 0 个评论 790 次浏览 2018-04-18 21:33 来自相关话题

这次课程信息量巨大,知识点不多,个个都是精华。依旧左边示例,右边知识点。 ...查看全部
这次课程信息量巨大,知识点不多,个个都是精华。依旧左边示例,右边知识点。

IMG_1480(20180418-212850).jpg


IMG_1481(20180418-212857).jpg


IMG_1482(20180418-212904).jpg


IMG_1483(20180418-212911).jpg

 

第五课:日期和时间、文件、Json和CSV处理、OOP

青峰 发表了文章 0 个评论 906 次浏览 2018-04-17 18:42 来自相关话题

烦请移步到以下地址查看: https://note.youdao.com/share/?id=dc2818372347e9d8568e593a0a63bedf&type=note#/
烦请移步到以下地址查看:
https://note.youdao.com/share/?id=dc2818372347e9d8568e593a0a63bedf&type=note#/

第五课笔记 文件操作、面向对象(上)

网络大亨 发表了文章 1 个评论 977 次浏览 2018-04-17 14:12 来自相关话题

http://note.youdao.com/noteshare?id=c59e51a3c2b6fc2cfdc88b2e32e7a5da&sub=2BFD5E9D5C3845F1A900AFBA0B75E2C2
http://note.youdao.com/noteshare?id=c59e51a3c2b6fc2cfdc88b2e32e7a5da&sub=2BFD5E9D5C3845F1A900AFBA0B75E2C2
更多话题 >>

热门话题

Python

1452 个问题, 125 人关注

自然语言处理

269 个问题, 23 人关注

机器学习

2801 个问题, 359 人关注

数据分析

188 个问题, 137 人关注

计算机视觉

243 个问题, 35 人关注

更多用户 >>

热门用户

新青年1025YD

2 个问题, 0 次赞同

Ktouchsdf

2 个问题, 0 次赞同

韩6051db7c2433c

1 个问题, 0 次赞同

秋名山coder

2 个问题, 0 次赞同

带带王贝贝erc

1 个问题, 0 次赞同