[置顶] Python联系笔记2[列表,元组,集合,字典,函数,文件操作,模块,类]
2017-07-14 18:52
1166 查看
列表
1.定义
#定义一个空列表
>>>list = []
#定义一个包含元素的列表,元素可以是任意类型,包括数值类型,列表,字符串等均可。
2.索引
#下标是从0开始计算
#list[0]读取的是列表的第1个元素;
#list[-1]读取的是列表的倒数第1个元素;
>>>list = ['HnSoi',22,'male',['Hsw','HanSongwei']]
>>>list[3][0]
>>>Hsw
3.切片
>>>list[x:y:z]
#x->代表从哪个索引开始切片;
#y->代表切片到哪个位置,并且不包含第y个索引;
#z->代表切片的步长;
4.添加
>>>list.append('Hello')
>>>list
>>>['HnSoi',22,'male',['Hsw','HanSongwei'],'Hello']
>>>list.insert(0,'Hi')
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello']
>>>list.extend(Xi)
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i']
>>>list.extend(['xi','Ha'])
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
5.修改
>>>list[0]='HaHa'
>>>list
>>>['HaHa','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
6.查看
#查看列表元素下标
>>>list.index('HnSoi')
>>>1
#查看列表元素出现次数
>>>list.count('HnSoi')
>>>1
7.删除
#删除列表元素
>>>list.remove('HnSoi')
>>>list
>>>['HaHa',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
>>>list.remove(list[1])
>>>list
>>>['HaHa','male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
#弹出列表最后一个元素
>>>list.pop()
>>>'Ha'
>>>list
>>>['HaHa','male',['Hsw','HanSongwei'],'Hello','X','i','Xi']
#弹出下标为零的元素
<
1c140
p>>>>list.pop(0)
>>>'HaHa'
>>>list
>>>['male',['Hsw','HanSongwei'],'Hello','X','i','Xi']
##当元素全部弹出后执行list.pop()报错
#删除列表
>>>del(list)
##列表实现出入栈##
#!/bin/env python
#coding:utf-8
HnSoi = []
def push():
item = raw_input("New item: ")
HnSoi.append(item)
def pop():
if len(HnSoi) == 0:
print "This is an empty stack !"
else:
print "%s pop from stack" %HnSoi.pop()
def view():
print HnSoi
def showmenu():
pro = '''
请输入: '''
while True:
choice = raw_input(pro).lower()
if choice == 'u':
push()
elif choice == 'o':
pop()
elif choice == 'v':
view()
elif choice == 'q':
print "退出"
break
else:
print "请输入 u/U o/O v/V q/Q :"
print '''
^欢迎使用^
您可以输入以下符号执行相应功能
U/u - 入栈 O/o - 出栈
V/v - 查看 Q/q - 退出
'''
showmenu()
元组
1.定义
#定义空元组
>>>tuple = ()
#定义单个值的元组
>>>tuple = ('HnSoi')
#一般的元组
>>>tuple = ('HnSoi', 22, 'male')
2.特性
#不能对元组的值任意更改
#可修改特例,可修改元组中的列表
>>>tuple = (1,2,3,[4,5])
>>>tuple[3][0]=10
>>>tuple
>>>(1,2,3,[10,5])
#对元组分别赋值,引申对多个变量也可通过元组方式分别赋值
>>>tuple = ('HnSoi', 22, 'male')
>>>name,age,gender=tuple
>>>print name,age,gender
>>>HnSoi 22 male
#3.索引,切片等操作同列表
集合
1.定义
#集合是一个有序的,不重复的数据组合。
>>>set={1,8,45,5,56,2,2,8}
>>>set
>>>{1,2,5,8,45,56}
2.集合关系
>>>list_1={1,2,3,4,5}
>>>list_2={1,2,3,6,8}
#交集:
>>>list_1.intersection(list_2)
>>>{1, 2, 3}
#并集:
>>>list_1.union(list_2)
>>>{1, 2, 3, 4, 5, 6, 8}
#差集:
>>>list_1.difference(list_2)
>>>{4, 5}
>>>list_2.difference(list_1)
>>>{6, 8}
#对等差分
>>>list_1.symmetric_difference(list_2)
>>>{4, 5, 6, 8}
#子集
>>>list_1.issubset(list_2)
>>>False
#父集
>>>list_1.issuperset(list_2)
>>>False
#有无交集
>>>list_1.isdisjoint(list_2)
>>>False
#交集:
>>>list_1 & list_2
#并集:
>>>list_1 | list_2
#差集:
>>>list_1 - list_2
>>>list_2 - list_1
#对等差分
>>>list_1 ^ list_2
3.添加
#在集合中添加一项
>>>s={1,2,3}
>>>s.add(10)
>>>s
>>>{1, 2, 3, 10}
#在集合中添加多项,跟的参数应该是可迭代类型
>>>s.update([1,3,4])
>>>s
>>>{1, 2, 3, 4, 10}
4.删除
#删除集合中指定的元素
>>>s.remove(10)
>>>s
>>>{1, 2, 3, 4}
#随机删除集合中的某个元素,并返回删除的元素
>>>s.pop()
#清空集合的所有元素
>>>s.clear()
#检测某元素是否为集合s的成员,返回布尔值
>>>1 in s
>>>True
>>>5 in s
>>>False
字典
1.定义
#字典是python中唯一的映射类型,key-value(哈希表),字典对象是可变的,但key必须用不可变对象
#简单字典创建
>>>dic = {'name':'HnSoi','age':'22','gender':'male'}
#内建方法:fromkeys
>>>dic = {}.fromkeys(('username','password'),'westos')
>>>dic
>>>{'password': 'westos', 'username': 'westos'}
>>>dic = {}.fromkeys(('username','password'))
>>>dic
>>>{'password': None, 'username': None}
2.访问
#直接通过key访问
>>>dic['name']
>>>'HnSoi'
#循环遍历访问
>>>for key in dic:
...: print dic[key]
...:
HnSoi
22
male
3.添加(无序)
>>>dic['Hobby']=HiPHop
>>>dic
>>>dic = {'age':'22','gender':'male','Hobby':'HipHop','name':'HnSoi'}
4.删除
#根据key值删除字典的元素
>>>dic.pop(key)
#随机删除字典元素,返回(key,value)
>>>dic.popitem()
#删除字典中的所有元素
>>>dic.clear()
#删除字典本身
>>>del dic
5.调用
#如果key存在于字典中,返回对应value值
>>>dic.get(key)
#返回字典的所有key值
>>>dic.keys()
#字典中是否存在某个key值
>>>dic.has_keys(key)
6.更新
#新的key-value添加,重复key更新value
>>>dic={'haha':'123','xixi':'456'}
>>>dic1={'lala':'789','haha':'321'}
>>>dic.update(dic1)
>>>dic
>>>{'haha':'321','xixi':'456','lala':'789'}
##字符串,列表,元组,集合,字典对比##
#此处的有序和无序是指元素内部的存放顺序,与元素的放入顺序无关
字符串:'', "", """ """, ''' '''
不可变数据类型
有序
列表: []
可变数据类型
有序序列
元组: ()
不可变数据类型
有序序列
集合: {x,y,...}
可变数据类型
无序
字典: {'name':'HnSoi'}
可变数据类型
无序
#列表去重
>>>list=['a','b','c','c','d','d','e','f']
>>>set(list)
>>>{'a', 'b', 'c', 'd', 'e', 'f'}
>>>list=['a','b','c','c','d','d','e','f']
>>>{}.fromkeys(list).keys()
>>>['a', 'b', 'c', 'd', 'e', 'f']
函数
#函数在执行过程中一旦遇到return,函数就执行完毕,并将结果返回。
#函数在执行过程中没有遇到return时,返回值None.
#如果要定义一个什么也不做的空函数时,可以用pass语句,作为一个占位符,让代码先运行起来。
def world():
pass
print hello()
#函数的参数检查
def my_abs(x):
if not isinstance(x,(int,float)):
print "请输入整形或浮点型"
return abs(x)
print my_abs()
#函数返回多个值,实质上是返回一个元组tuple,返回时元组可以省略括号,
#函数调用接收返回值时,按照位置赋值给变量
def func(x,y):
if not isinstance(x,int) or not isinstance(y,int):
print 'Error Type'
avg = sum((x,y))/2
maxnum = max(x,y)
return "平均值:[%d],\t最大值:[%d]," %(avg, maxnum)
print func(2,10)
#默认参数,必选参数同时存在函数中存在时,一定要将必选参数放在默认参数前面;
#设置默认参数时,把变化大的参数放前面,变化小的参数放后面,变化小的参数可以设置为默认参数。
def power(x,n=2):
return x**n
print power(3,3)
print power(3)
#可变参数/位置参数
#定义函数时,形参可以为*args,使函数可以接收多个参数,接收的数据类型为元组;
#如果想将一个列表或者元组传入函数,也可通过*li 或 *t,将参数传入函数里。
def fun(*args):
print type(args)
return max(args),min(args)
li = 1,5,3,8,23,6
print fun(*li)
#关键字参数允许你传入 0 个或任意个含参数名的参数;
#这些关键字参数在函数内部自动组装为一个 dict;
#关键字参数用**kwargs
def enroll(name, age=22, **kwargs):
print 'name:' + name
print 'age:%d' % age
for k, w in kwargs.items():
print '%s : %s' % (k, w)
dic = {'myclass':'运维',"gender":'male'}
enroll('HnSoi', **dic)
参数定义的顺序:必选参数 > 默认参数 > 可变参数 > 关键字参数
#局部变量&全局变量
b = 2 # 全局变量,在整个代码中生效
def a():
global b # 强制将局部变量转换成全局变量
b=1 # 局部变量,只在函数内生效
print b
a()
print b
列表生成式
#实现操作 [1x1, 2x2, 3x3, ..., 7x7]
print [ i*i for i in range(1,8)]
# 1~20,所有偶数的平方
print [ i*i for i in range(0,20,2)]
print [ i*i for i in range(0,20) if i %2 == 0]
#生成‘ABC’与‘123’的全排列
print [ i+j for i in '123' for j in 'ABC']
#生成字典的的内容,格式为‘key=value’,返回其列表格式
print [ k+'='+v for k,v in dic.items()]
#将list中所有的字符串变为小写字母
print [i.lower() for i in list if isinstance(i, str)]
生成器
1.判断数据类型是否为可迭代数据类型
>>>from collections import Iterable
>>>isinstance('hello',Iterable)
>>>True
>>>isinstance([1,2],Iterable)
>>>True
>>>isinstance(1,Iterable)
>>>False
>>>isinstance({1,2},Iterable)
>>>True
>>>isinstance({"name":"HnSoi"},Iterable)
>>>True
>>>isinstance((1,2,3),Iterable)
>>>True
2.枚举方法,显示为索引-元素
dic = [
('Name','Hansongwei'),
('Age',22),
('Class','TG1414')
]
for i,v in enumerate(dic):
print i,v
3.在for循环里引用两个变量
dic = [
('Name','Hansongwei'),
('Age',22),
('Class','TG1414')
]
for k,v in dic:
print k,v
4.生成器generator
l = [i for i in range(1000)] # 列表生成式
g = (i for i in range(1000)) # 生成器
#1). 列表生成式受到内存的限制,列表容量是有限的;
#2). 列表生成式如果只需要前几个元素,浪费内存空间。
#3). 访问生成式:
#- for循环
for i in g:
print i
#- g.next()方法
g.next()
5.手动实现生成器
#定义一函数fib,实现斐波那契数列(Fibonicci):
def fib(max):
n,a,b = 0,0,1
while n < max:
print b
a, b = b, a+b
n += 1
num = input('Please input n: ')
if num <= 0:
print '请输入正数:'
else:
print '斐波那契数列: '
fib(num)
#通过yield实现单线程的并发运算
import time
def consumer(name):
print '%s 准备吃饭了' %name
while True:
people = yield
print ('[%s]做好了,被[%s]吃了') %(people,name)
def producer(name):
c1 = consumer('老李')
c1.next()
print '晚餐制作中...'
for i in ['意面','皮萨']:
time.sleep(2)
print '[%s]做好了晚餐' %name
c1.send(i)
producer('HnSoi')
高阶函数
1.定义
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
2.map函数
#map() 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回。
list=range(1,9)
def PF(x):
return x*x
print map(PF,list)
#把这list列表中的所有数字转为字符串;([1,2,3]---['1','2','3'])
>>>list = [1,2,3]
>>>str()
>>>map(str,list)
>>>['1', '2', '3']
3.reduce函数
#reduce 把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算。
>>>def fun(x,y):
...: return x,y
...:
>>>reduce(fun,range(1,4))
#写出把 str 转换为 int 的函数(eg:'12345'--12345)
def char_int(x):
return {'1':1,'2':2,'3':3,'4':4,'5':5}[x]
def fun(x,y):
return x*10+y
print reduce(fun,map(char_int,'12345'))
4.filter函数
#filter() 也接收一个函数和一个序列。
#和 map() 不同的是,filter() 把传入的函数依次作用于每个元素,然后根据返回值是 True还是 False 决定保留还是丢弃该元素。
#删除列表中的偶数,只保留奇数
def is_odd(n)
return n % 2 == 1
filter(is_odd,range(10))
5.sorted函数
#排序也是在程序中经常用到的算法。
#无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。
#通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
>>>t=(18,24,3,1,13)
>>>sorted(t)
>>>[1,3,13,18,24]
#逆序排序
>>>def reversed_cmp(x,y):
...: if x>y:
...: return -1
...: elif x<y:
...: return 1
...: else
...: return 0
...:
>>>sorted(t,reversed_cmp)
>>>[24,18,13,3,1]
#字符串排序
>>>list = ['Hansongwei','baixudong','jinzhe','hansongwei']
>>>sorted(list)
>>>['Hansongwei', 'baixudong', 'hansongwei', 'jinzhe']
>>>'jinzhe' > 'hansongwei'
>>>True
#忽略大小写排序
>>>def ignore_case_cmp(x,y):
...: lower1 = x.lower()
...: lower2 = y.lower()
...: if lower1 < lower2:
...: return -1
...: elif lower1 > lower2:
...: return 1
...: else:
...: return 0
...:
>>>sorted(list,ignore_case_cmp)
6.函数作为返回值
#例1,调用wrap_sum()时,返回的并不是求和结果,而是求和函数
# 调用函数 f 时,才真正计算求和的结果
def wrap_sum(*args):
def my_sum(): # (1,2,3,4)
sum_num = 0
for i in args:
if not isinstance(i,(int,float)):
print 'Error Type'
sum_num = sum_num + i
return sum_num
return my_sum
f1 = wrap_sum(1,2,3,6)
print f1()
#例2,预计输出1,4,9 实际输出9,9,9
def count():
fs = []
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3 = count()
print f1()
print f2()
print f3()
#例2解决方案,再嵌套一个函数
def count():
fs = []
for i in range(1,4): # i=1
def f(j):
def g():
return j*j
return g
fs.append(f(i)) # fs.append(f(1)) fs=[]
return fs
f1,f2,f3 = count()
print f1()
print f2()
print f3()
7.匿名函数
匿名函数的优势:
1). 匿名函数不需要函数名,可以避免函数名的冲突;
2). 匿名函数可以跳过给函数分配栈空间;
#输出[1,2,3,...,10]的平方列表[1,4,9,...,100]
#方法1:
def pow1(x):
return x*x
print map(pow1,range(1,11))
#方法2:
print map(lambda x:x*x, range(1,11))
#匿名函数可以赋值给一个变量,需要运行时,变量名()
f = lambda :1
print f()
#匿名函数传递必选参数和默认参数
f = lambda x,y=2:x**y
print f(2,3)
print f(2)
#匿名函数传递可变参数
f = lambda *x:map(lambda x:x+x,x)
print f(1,2,3,4)
#匿名函数传递关键字参数
f = lambda **kwargs:kwargs.items()
print f(name="HnSoi",age=22)
#利用匿名函数和字典重新编辑计算器的代码
from __future__ import division
x = input('num1:')
oper = raw_input('operator:')
y = input('num2:')
d = {
"+": lambda x, y: x + y,
"-": lambda x, y: x - y,
"*": lambda x, y: x * y,
"/": lambda x, y: x / y
}
if oper not in d.keys():
print 'input +,-,*,/'
print d[oper](x,y)
8.装饰器
#用来装饰函数的一个函数
import time
def timmer(func):
def deco():
start_time = time.time()
func()
stop_time = time.time()
return stop_time-start_time
return deco
@timmer
def hello():
print 'hello....'
time.sleep(2)
print hello()
#实例1:理解函数即变量
def hello():
print 'hello.....'
hello1()
hello()
def hello1():
print 'hello1...'
#Error:global name 'hello1' is not defined
#实例2:添加功能,装饰函数:1). 不修改函数的源代码;2). 函数的调用方式没有改变
import time
def timmer(func):
def dec():
start_time = time.time()
func()
stop_time = time.time()
return "%s run %f s"%(func.__name__ ,stop_time-start_time)
return dec
@timmer #hello=timmer(hello),语法糖
def hello():
print 'hello....'
time.sleep(2)
print hello()
文件操作
r:可以读取文件内容,不可以写入,如果文件不存在则报错
r+:可读写,依次覆盖源文件内容,如果文件不存在则报错
w:可以写入文件内容,不可以读取,如果文件不存在则创建,并覆盖源文件内容
w+:可读写,打开文件时直接删除源文件内容,如果文件不存在则创建
a:写入,文件末尾追加,文件不存在则创建
a+:读写,文件追加,文件不存在则创建
#以写'w'的方式打开文件:
f = open('filename','w')
f.write('hello') #会删除源文件内容,重新写入‘hello’到文件中
#以读'r'的方式打开文件
f = open('filename') #=> f=open('filename','r')
print f.read()
f.close()
#将hello文件中所有的hello替换成‘westos’,并另存为一文件
f = open('hello','r')
f1 = open('hello','a+')
str1 = f.read()
str2 = str1.repalce('hello','westos')
f1.write(str2)
f.close()
f1.close()
模块&包
1.什么是模块?
所有以.py结尾的都可以认为是一个模块,逻辑上组织python代码(函数,变量,类)
2.导入模块的几种方式
- import cacl
调用方式:直接导入cacl模块,使用其方法:cacl.add(1,3)
cacl = {cacl里面的所有代码进行解释}
cacl.path
- from cacl import add
调用方式:导入cacl模块里面的add方法:add(1,2)
只把add解释执行放入当前py文件中
- from cacl import add as myadd
myadd = add
调用方式:如果当前py代码包含add方法,但仍然想要使用cacl模块中的add函数,
可以对该函数进行重命名;
#创建并编写cacl.py
#!/bin/env python
#coding:utf-8
from __future__ import division
def add(x,y):
return x+y
def sub(x,y):
return x-y
def multi(x,y):
return x*y
def divi(x,y):
return x/y
#调用cacl.py(模块)
from cacl import sub #调用cacl(模块)的sub函数
from cacl import add as myadd #调用cacl(模块)的add函数并重命名为myadd
def add(x,y)
return x+y+1
print sub(5,1)
print add(2,3)
print myadd(2,3)
3.添加路径,让路径搜索时导入相应的自定义模块
import sys
print sys.path
sys.path.append('模块路径')
sys.path.insert(0,'模块路径')
#可以在任意目录下调用自定义模块
4.包
#创建包的步骤:
-创建一目录为包名;
-在该文件夹下创建__init__.py文件存放包的信息,该文件可以为空;
-根据需要存放脚本文件,已编译的扩展及子包;
-可以用import,import as,from import等语句导入模块和包;
#作用域:
在一个模块中,我们可能会定义很多函数和变量,但有的函数和变量我们希望给别人使用,有的函数和变量我们希望仅仅在模块内部使用。
在 Python 中,是通过 _ 前缀来实现。
比如__author__ , __name__就是特殊变量的,__func__,__fun为私有函数,不能直接引用。
面向对象编程
1.基础概念
类:
在 Python 中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)。
OOP首选思考的不是程序的执行流程,而是某个数据类型应该被视为一个对象,这个对象拥有的属性(Property)。
方法:
给对象发消息实际上就是调用对象对应的关联函数,我们称之为对象的方法(Method)。
2.实例
#MP.cy
import time
import ku
def menu():
print '''
------------------欢迎来到西部开源------------------
1:我是老板 2:我是讲师
3:我是学员 4:退出
'''
operation = raw_input('请输入您的操作:')
if operation == '1':
boss()
elif operation == '2':
teacher()
elif operation == '3':
student()
elif operation == '4':
exit()
else:
print '输入错误'
menu()
def boss():
school1 = ku.School('西部开源', '电子二路', '老李不老!')
print '''
1.招生 2.招聘讲师 3.基本信息 4.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
school1.recruit_student()
time.sleep(2)
print '招生结束'
del school1
boss()
elif choice == '2':
school1.invite()
time.sleep(2)
print '讲师招聘结束'
del school1
boss()
elif choice == '3':
school1.info()
del school1
boss()
elif choice == '4':
del school1
menu()
else:
print '输入错误'
del school1
boss()
del school1
def teacher():
teacher1 = ku.Teacher('老李', 30, 'male', 'linux', '2800')
print '''
1.讲课 2.讲师信息 3.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
teacher1.teach()
time.sleep(5)
print '整理好今天讲的内容,可以走了'
del teacher1
teacher()
elif choice == '2':
teacher1.get_Message()
del teacher1
teacher()
elif choice == '3':
del teacher1
menu()
else:
print '输入错误'
del teacher1
teacher()
def student():
student1 = ku.Student('HnSoi', 22, 'male', '运维', '17')
print '''
1.听课 2.基本信息 3.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
student1.study()
time.sleep(3)
print '拷贝截图笔记,关机走人'
del student1
student()
elif choice == '2':
student1.get_Message()
del student1
student()
elif choice == '3':
del student1
menu()
else:
print '输入错误'
del student1
student()
menu()
#ku.py
class School(object):
#定义类
def __init__(self, name, place, motto):
#构造函数,后面跟需要传递的参数
self.__name = name
#self就是实例化的变量名,self.name是实例化属性,静态属性
self.__place = place
#以双下划线开头的变量名,成为私有变量或属性
self.__motto = motto
def Name(self, name):
#方法,与函数唯一的区别是self,动态属性
self.__name = name
def Place(self, place):
self.__place = place
def Motto(self, motto):
self.__motto = motto
def get_Name(self):
return self.__name
def get_Place(self):
return self.__place
def get_Motto(self):
return self.__motto
def info(self):
print '''
---------------------学校信息--------------------
校名:%s
地址:%s
校训:%s
'''%(self.__name, self.__place, self.__motto)
def recruit_student(self):
print '%s正在招生'%self.get_Name()
def invite(self):
print '%s正在招聘讲师'%self.get_Name()
def __del__(self):
#数据库断开
pass
class People(object):
def __init__(self, name, age, sex):
self.__name = name
self.__age = age
self.__sex = sex
def Name(self, name):
self.__name = name
def Age(self, age):
self.__age = age
def Sex(self, sex):
self.__sex = sex
def get_Name(self):
return self.__name
def get_Age(self):
return self.__age
def get_Sex(self):
return self.__sex
def info(self):
print '''
姓名: %s
年龄: %s
性别: %s'''%(self.__name, self.__age, self.__sex)
def __del__(self):
pass
#继承,对于Student来说,People就是它的父类,对于People来说,Student就是他的子类
#继承最大的好处是子类获得了父类的全部功能。
#继承的另一个好处:多态。子类的覆盖了父类的方法。
class Student(People):
def __init__(self, name, age, sex, Class, ID):
super(Student, self).__init__(name, age, sex)
self.__class = Class
self.__id = ID
def set_Class(self, clazz):
self.__clazz = clazz
def set_ID(self, ID):
self.__id = ID
def get_Class(self):
return self.__clazz
def get_ID(self):
return self.__id
def study(self):
print "%s正在听课"%(self.Name())
def get_Message(self):
self.info()
print '''
班级: %s
学号: %s
'''%(self.__class, self.__id)
def __del__(self):
pass
class Teacher(People):
def __init__(self, name, age, sex, course, money):
super(Teacher, self).__init__(name, age, sex)
self.__course = course
self.__money = money
def Course(self, course):
self.__course = course
def Money(self, money):
self.__money = money
def get_Course(self):
return self.__course
def get_Money(self):
return self.__money
def teach(self):
print "%s正在讲授%s课程"%(self.get_Name(), self.__course)
def get_Message(self):
self.info()
print '''
科目: %s
工资: %s
'''%(self.__course, self.__money)
def __del__(self):
pass
#继承策略:广度优先策略(效率高)
#
深度优先: C一直找父类的方法,如果没有找到相应的方法,再去找和C在同一层的类
class A: # 新式类(object)和经典类
def hello(self):
print 'in the A.......'
class B(A):
def hello(self):
print 'in the B.......'
#pass
class C(A):
pass
# def hello(self):
# print 'in the C.......'
class D(C,B):
pass
# def hello(self):
# print 'in the D.......'
d = D()
d.hello()
1.定义
#定义一个空列表
>>>list = []
#定义一个包含元素的列表,元素可以是任意类型,包括数值类型,列表,字符串等均可。
2.索引
#下标是从0开始计算
#list[0]读取的是列表的第1个元素;
#list[-1]读取的是列表的倒数第1个元素;
>>>list = ['HnSoi',22,'male',['Hsw','HanSongwei']]
>>>list[3][0]
>>>Hsw
3.切片
>>>list[x:y:z]
#x->代表从哪个索引开始切片;
#y->代表切片到哪个位置,并且不包含第y个索引;
#z->代表切片的步长;
4.添加
>>>list.append('Hello')
>>>list
>>>['HnSoi',22,'male',['Hsw','HanSongwei'],'Hello']
>>>list.insert(0,'Hi')
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello']
>>>list.extend(Xi)
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i']
>>>list.extend(['xi','Ha'])
>>>list
>>>['Hi','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
5.修改
>>>list[0]='HaHa'
>>>list
>>>['HaHa','HnSoi',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
6.查看
#查看列表元素下标
>>>list.index('HnSoi')
>>>1
#查看列表元素出现次数
>>>list.count('HnSoi')
>>>1
7.删除
#删除列表元素
>>>list.remove('HnSoi')
>>>list
>>>['HaHa',22,'male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
>>>list.remove(list[1])
>>>list
>>>['HaHa','male',['Hsw','HanSongwei'],'Hello','X','i','Xi','Ha']
#弹出列表最后一个元素
>>>list.pop()
>>>'Ha'
>>>list
>>>['HaHa','male',['Hsw','HanSongwei'],'Hello','X','i','Xi']
#弹出下标为零的元素
<
1c140
p>>>>list.pop(0)
>>>'HaHa'
>>>list
>>>['male',['Hsw','HanSongwei'],'Hello','X','i','Xi']
##当元素全部弹出后执行list.pop()报错
#删除列表
>>>del(list)
##列表实现出入栈##
#!/bin/env python
#coding:utf-8
HnSoi = []
def push():
item = raw_input("New item: ")
HnSoi.append(item)
def pop():
if len(HnSoi) == 0:
print "This is an empty stack !"
else:
print "%s pop from stack" %HnSoi.pop()
def view():
print HnSoi
def showmenu():
pro = '''
请输入: '''
while True:
choice = raw_input(pro).lower()
if choice == 'u':
push()
elif choice == 'o':
pop()
elif choice == 'v':
view()
elif choice == 'q':
print "退出"
break
else:
print "请输入 u/U o/O v/V q/Q :"
print '''
^欢迎使用^
您可以输入以下符号执行相应功能
U/u - 入栈 O/o - 出栈
V/v - 查看 Q/q - 退出
'''
showmenu()
元组
1.定义
#定义空元组
>>>tuple = ()
#定义单个值的元组
>>>tuple = ('HnSoi')
#一般的元组
>>>tuple = ('HnSoi', 22, 'male')
2.特性
#不能对元组的值任意更改
#可修改特例,可修改元组中的列表
>>>tuple = (1,2,3,[4,5])
>>>tuple[3][0]=10
>>>tuple
>>>(1,2,3,[10,5])
#对元组分别赋值,引申对多个变量也可通过元组方式分别赋值
>>>tuple = ('HnSoi', 22, 'male')
>>>name,age,gender=tuple
>>>print name,age,gender
>>>HnSoi 22 male
#3.索引,切片等操作同列表
集合
1.定义
#集合是一个有序的,不重复的数据组合。
>>>set={1,8,45,5,56,2,2,8}
>>>set
>>>{1,2,5,8,45,56}
2.集合关系
>>>list_1={1,2,3,4,5}
>>>list_2={1,2,3,6,8}
#交集:
>>>list_1.intersection(list_2)
>>>{1, 2, 3}
#并集:
>>>list_1.union(list_2)
>>>{1, 2, 3, 4, 5, 6, 8}
#差集:
>>>list_1.difference(list_2)
>>>{4, 5}
>>>list_2.difference(list_1)
>>>{6, 8}
#对等差分
>>>list_1.symmetric_difference(list_2)
>>>{4, 5, 6, 8}
#子集
>>>list_1.issubset(list_2)
>>>False
#父集
>>>list_1.issuperset(list_2)
>>>False
#有无交集
>>>list_1.isdisjoint(list_2)
>>>False
#交集:
>>>list_1 & list_2
#并集:
>>>list_1 | list_2
#差集:
>>>list_1 - list_2
>>>list_2 - list_1
#对等差分
>>>list_1 ^ list_2
3.添加
#在集合中添加一项
>>>s={1,2,3}
>>>s.add(10)
>>>s
>>>{1, 2, 3, 10}
#在集合中添加多项,跟的参数应该是可迭代类型
>>>s.update([1,3,4])
>>>s
>>>{1, 2, 3, 4, 10}
4.删除
#删除集合中指定的元素
>>>s.remove(10)
>>>s
>>>{1, 2, 3, 4}
#随机删除集合中的某个元素,并返回删除的元素
>>>s.pop()
#清空集合的所有元素
>>>s.clear()
#检测某元素是否为集合s的成员,返回布尔值
>>>1 in s
>>>True
>>>5 in s
>>>False
字典
1.定义
#字典是python中唯一的映射类型,key-value(哈希表),字典对象是可变的,但key必须用不可变对象
#简单字典创建
>>>dic = {'name':'HnSoi','age':'22','gender':'male'}
#内建方法:fromkeys
>>>dic = {}.fromkeys(('username','password'),'westos')
>>>dic
>>>{'password': 'westos', 'username': 'westos'}
>>>dic = {}.fromkeys(('username','password'))
>>>dic
>>>{'password': None, 'username': None}
2.访问
#直接通过key访问
>>>dic['name']
>>>'HnSoi'
#循环遍历访问
>>>for key in dic:
...: print dic[key]
...:
HnSoi
22
male
3.添加(无序)
>>>dic['Hobby']=HiPHop
>>>dic
>>>dic = {'age':'22','gender':'male','Hobby':'HipHop','name':'HnSoi'}
4.删除
#根据key值删除字典的元素
>>>dic.pop(key)
#随机删除字典元素,返回(key,value)
>>>dic.popitem()
#删除字典中的所有元素
>>>dic.clear()
#删除字典本身
>>>del dic
5.调用
#如果key存在于字典中,返回对应value值
>>>dic.get(key)
#返回字典的所有key值
>>>dic.keys()
#字典中是否存在某个key值
>>>dic.has_keys(key)
6.更新
#新的key-value添加,重复key更新value
>>>dic={'haha':'123','xixi':'456'}
>>>dic1={'lala':'789','haha':'321'}
>>>dic.update(dic1)
>>>dic
>>>{'haha':'321','xixi':'456','lala':'789'}
##字符串,列表,元组,集合,字典对比##
#此处的有序和无序是指元素内部的存放顺序,与元素的放入顺序无关
字符串:'', "", """ """, ''' '''
不可变数据类型
有序
列表: []
可变数据类型
有序序列
元组: ()
不可变数据类型
有序序列
集合: {x,y,...}
可变数据类型
无序
字典: {'name':'HnSoi'}
可变数据类型
无序
#列表去重
>>>list=['a','b','c','c','d','d','e','f']
>>>set(list)
>>>{'a', 'b', 'c', 'd', 'e', 'f'}
>>>list=['a','b','c','c','d','d','e','f']
>>>{}.fromkeys(list).keys()
>>>['a', 'b', 'c', 'd', 'e', 'f']
函数
#函数在执行过程中一旦遇到return,函数就执行完毕,并将结果返回。
#函数在执行过程中没有遇到return时,返回值None.
#如果要定义一个什么也不做的空函数时,可以用pass语句,作为一个占位符,让代码先运行起来。
def world():
pass
print hello()
#函数的参数检查
def my_abs(x):
if not isinstance(x,(int,float)):
print "请输入整形或浮点型"
return abs(x)
print my_abs()
#函数返回多个值,实质上是返回一个元组tuple,返回时元组可以省略括号,
#函数调用接收返回值时,按照位置赋值给变量
def func(x,y):
if not isinstance(x,int) or not isinstance(y,int):
print 'Error Type'
avg = sum((x,y))/2
maxnum = max(x,y)
return "平均值:[%d],\t最大值:[%d]," %(avg, maxnum)
print func(2,10)
#默认参数,必选参数同时存在函数中存在时,一定要将必选参数放在默认参数前面;
#设置默认参数时,把变化大的参数放前面,变化小的参数放后面,变化小的参数可以设置为默认参数。
def power(x,n=2):
return x**n
print power(3,3)
print power(3)
#可变参数/位置参数
#定义函数时,形参可以为*args,使函数可以接收多个参数,接收的数据类型为元组;
#如果想将一个列表或者元组传入函数,也可通过*li 或 *t,将参数传入函数里。
def fun(*args):
print type(args)
return max(args),min(args)
li = 1,5,3,8,23,6
print fun(*li)
#关键字参数允许你传入 0 个或任意个含参数名的参数;
#这些关键字参数在函数内部自动组装为一个 dict;
#关键字参数用**kwargs
def enroll(name, age=22, **kwargs):
print 'name:' + name
print 'age:%d' % age
for k, w in kwargs.items():
print '%s : %s' % (k, w)
dic = {'myclass':'运维',"gender":'male'}
enroll('HnSoi', **dic)
参数定义的顺序:必选参数 > 默认参数 > 可变参数 > 关键字参数
#局部变量&全局变量
b = 2 # 全局变量,在整个代码中生效
def a():
global b # 强制将局部变量转换成全局变量
b=1 # 局部变量,只在函数内生效
print b
a()
print b
列表生成式
#实现操作 [1x1, 2x2, 3x3, ..., 7x7]
print [ i*i for i in range(1,8)]
# 1~20,所有偶数的平方
print [ i*i for i in range(0,20,2)]
print [ i*i for i in range(0,20) if i %2 == 0]
#生成‘ABC’与‘123’的全排列
print [ i+j for i in '123' for j in 'ABC']
#生成字典的的内容,格式为‘key=value’,返回其列表格式
print [ k+'='+v for k,v in dic.items()]
#将list中所有的字符串变为小写字母
print [i.lower() for i in list if isinstance(i, str)]
生成器
1.判断数据类型是否为可迭代数据类型
>>>from collections import Iterable
>>>isinstance('hello',Iterable)
>>>True
>>>isinstance([1,2],Iterable)
>>>True
>>>isinstance(1,Iterable)
>>>False
>>>isinstance({1,2},Iterable)
>>>True
>>>isinstance({"name":"HnSoi"},Iterable)
>>>True
>>>isinstance((1,2,3),Iterable)
>>>True
2.枚举方法,显示为索引-元素
dic = [
('Name','Hansongwei'),
('Age',22),
('Class','TG1414')
]
for i,v in enumerate(dic):
print i,v
3.在for循环里引用两个变量
dic = [
('Name','Hansongwei'),
('Age',22),
('Class','TG1414')
]
for k,v in dic:
print k,v
4.生成器generator
l = [i for i in range(1000)] # 列表生成式
g = (i for i in range(1000)) # 生成器
#1). 列表生成式受到内存的限制,列表容量是有限的;
#2). 列表生成式如果只需要前几个元素,浪费内存空间。
#3). 访问生成式:
#- for循环
for i in g:
print i
#- g.next()方法
g.next()
5.手动实现生成器
#定义一函数fib,实现斐波那契数列(Fibonicci):
def fib(max):
n,a,b = 0,0,1
while n < max:
print b
a, b = b, a+b
n += 1
num = input('Please input n: ')
if num <= 0:
print '请输入正数:'
else:
print '斐波那契数列: '
fib(num)
#通过yield实现单线程的并发运算
import time
def consumer(name):
print '%s 准备吃饭了' %name
while True:
people = yield
print ('[%s]做好了,被[%s]吃了') %(people,name)
def producer(name):
c1 = consumer('老李')
c1.next()
print '晚餐制作中...'
for i in ['意面','皮萨']:
time.sleep(2)
print '[%s]做好了晚餐' %name
c1.send(i)
producer('HnSoi')
高阶函数
1.定义
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
2.map函数
#map() 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回。
list=range(1,9)
def PF(x):
return x*x
print map(PF,list)
#把这list列表中的所有数字转为字符串;([1,2,3]---['1','2','3'])
>>>list = [1,2,3]
>>>str()
>>>map(str,list)
>>>['1', '2', '3']
3.reduce函数
#reduce 把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算。
>>>def fun(x,y):
...: return x,y
...:
>>>reduce(fun,range(1,4))
#写出把 str 转换为 int 的函数(eg:'12345'--12345)
def char_int(x):
return {'1':1,'2':2,'3':3,'4':4,'5':5}[x]
def fun(x,y):
return x*10+y
print reduce(fun,map(char_int,'12345'))
4.filter函数
#filter() 也接收一个函数和一个序列。
#和 map() 不同的是,filter() 把传入的函数依次作用于每个元素,然后根据返回值是 True还是 False 决定保留还是丢弃该元素。
#删除列表中的偶数,只保留奇数
def is_odd(n)
return n % 2 == 1
filter(is_odd,range(10))
5.sorted函数
#排序也是在程序中经常用到的算法。
#无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。
#通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
>>>t=(18,24,3,1,13)
>>>sorted(t)
>>>[1,3,13,18,24]
#逆序排序
>>>def reversed_cmp(x,y):
...: if x>y:
...: return -1
...: elif x<y:
...: return 1
...: else
...: return 0
...:
>>>sorted(t,reversed_cmp)
>>>[24,18,13,3,1]
#字符串排序
>>>list = ['Hansongwei','baixudong','jinzhe','hansongwei']
>>>sorted(list)
>>>['Hansongwei', 'baixudong', 'hansongwei', 'jinzhe']
>>>'jinzhe' > 'hansongwei'
>>>True
#忽略大小写排序
>>>def ignore_case_cmp(x,y):
...: lower1 = x.lower()
...: lower2 = y.lower()
...: if lower1 < lower2:
...: return -1
...: elif lower1 > lower2:
...: return 1
...: else:
...: return 0
...:
>>>sorted(list,ignore_case_cmp)
6.函数作为返回值
#例1,调用wrap_sum()时,返回的并不是求和结果,而是求和函数
# 调用函数 f 时,才真正计算求和的结果
def wrap_sum(*args):
def my_sum(): # (1,2,3,4)
sum_num = 0
for i in args:
if not isinstance(i,(int,float)):
print 'Error Type'
sum_num = sum_num + i
return sum_num
return my_sum
f1 = wrap_sum(1,2,3,6)
print f1()
#例2,预计输出1,4,9 实际输出9,9,9
def count():
fs = []
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3 = count()
print f1()
print f2()
print f3()
#例2解决方案,再嵌套一个函数
def count():
fs = []
for i in range(1,4): # i=1
def f(j):
def g():
return j*j
return g
fs.append(f(i)) # fs.append(f(1)) fs=[]
return fs
f1,f2,f3 = count()
print f1()
print f2()
print f3()
7.匿名函数
匿名函数的优势:
1). 匿名函数不需要函数名,可以避免函数名的冲突;
2). 匿名函数可以跳过给函数分配栈空间;
#输出[1,2,3,...,10]的平方列表[1,4,9,...,100]
#方法1:
def pow1(x):
return x*x
print map(pow1,range(1,11))
#方法2:
print map(lambda x:x*x, range(1,11))
#匿名函数可以赋值给一个变量,需要运行时,变量名()
f = lambda :1
print f()
#匿名函数传递必选参数和默认参数
f = lambda x,y=2:x**y
print f(2,3)
print f(2)
#匿名函数传递可变参数
f = lambda *x:map(lambda x:x+x,x)
print f(1,2,3,4)
#匿名函数传递关键字参数
f = lambda **kwargs:kwargs.items()
print f(name="HnSoi",age=22)
#利用匿名函数和字典重新编辑计算器的代码
from __future__ import division
x = input('num1:')
oper = raw_input('operator:')
y = input('num2:')
d = {
"+": lambda x, y: x + y,
"-": lambda x, y: x - y,
"*": lambda x, y: x * y,
"/": lambda x, y: x / y
}
if oper not in d.keys():
print 'input +,-,*,/'
print d[oper](x,y)
8.装饰器
#用来装饰函数的一个函数
import time
def timmer(func):
def deco():
start_time = time.time()
func()
stop_time = time.time()
return stop_time-start_time
return deco
@timmer
def hello():
print 'hello....'
time.sleep(2)
print hello()
#实例1:理解函数即变量
def hello():
print 'hello.....'
hello1()
hello()
def hello1():
print 'hello1...'
#Error:global name 'hello1' is not defined
#实例2:添加功能,装饰函数:1). 不修改函数的源代码;2). 函数的调用方式没有改变
import time
def timmer(func):
def dec():
start_time = time.time()
func()
stop_time = time.time()
return "%s run %f s"%(func.__name__ ,stop_time-start_time)
return dec
@timmer #hello=timmer(hello),语法糖
def hello():
print 'hello....'
time.sleep(2)
print hello()
文件操作
r:可以读取文件内容,不可以写入,如果文件不存在则报错
r+:可读写,依次覆盖源文件内容,如果文件不存在则报错
w:可以写入文件内容,不可以读取,如果文件不存在则创建,并覆盖源文件内容
w+:可读写,打开文件时直接删除源文件内容,如果文件不存在则创建
a:写入,文件末尾追加,文件不存在则创建
a+:读写,文件追加,文件不存在则创建
#以写'w'的方式打开文件:
f = open('filename','w')
f.write('hello') #会删除源文件内容,重新写入‘hello’到文件中
#以读'r'的方式打开文件
f = open('filename') #=> f=open('filename','r')
print f.read()
f.close()
#将hello文件中所有的hello替换成‘westos’,并另存为一文件
f = open('hello','r')
f1 = open('hello','a+')
str1 = f.read()
str2 = str1.repalce('hello','westos')
f1.write(str2)
f.close()
f1.close()
模块&包
1.什么是模块?
所有以.py结尾的都可以认为是一个模块,逻辑上组织python代码(函数,变量,类)
2.导入模块的几种方式
- import cacl
调用方式:直接导入cacl模块,使用其方法:cacl.add(1,3)
cacl = {cacl里面的所有代码进行解释}
cacl.path
- from cacl import add
调用方式:导入cacl模块里面的add方法:add(1,2)
只把add解释执行放入当前py文件中
- from cacl import add as myadd
myadd = add
调用方式:如果当前py代码包含add方法,但仍然想要使用cacl模块中的add函数,
可以对该函数进行重命名;
#创建并编写cacl.py
#!/bin/env python
#coding:utf-8
from __future__ import division
def add(x,y):
return x+y
def sub(x,y):
return x-y
def multi(x,y):
return x*y
def divi(x,y):
return x/y
#调用cacl.py(模块)
from cacl import sub #调用cacl(模块)的sub函数
from cacl import add as myadd #调用cacl(模块)的add函数并重命名为myadd
def add(x,y)
return x+y+1
print sub(5,1)
print add(2,3)
print myadd(2,3)
3.添加路径,让路径搜索时导入相应的自定义模块
import sys
print sys.path
sys.path.append('模块路径')
sys.path.insert(0,'模块路径')
#可以在任意目录下调用自定义模块
4.包
#创建包的步骤:
-创建一目录为包名;
-在该文件夹下创建__init__.py文件存放包的信息,该文件可以为空;
-根据需要存放脚本文件,已编译的扩展及子包;
-可以用import,import as,from import等语句导入模块和包;
#作用域:
在一个模块中,我们可能会定义很多函数和变量,但有的函数和变量我们希望给别人使用,有的函数和变量我们希望仅仅在模块内部使用。
在 Python 中,是通过 _ 前缀来实现。
比如__author__ , __name__就是特殊变量的,__func__,__fun为私有函数,不能直接引用。
面向对象编程
1.基础概念
类:
在 Python 中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)。
OOP首选思考的不是程序的执行流程,而是某个数据类型应该被视为一个对象,这个对象拥有的属性(Property)。
方法:
给对象发消息实际上就是调用对象对应的关联函数,我们称之为对象的方法(Method)。
2.实例
#MP.cy
import time
import ku
def menu():
print '''
------------------欢迎来到西部开源------------------
1:我是老板 2:我是讲师
3:我是学员 4:退出
'''
operation = raw_input('请输入您的操作:')
if operation == '1':
boss()
elif operation == '2':
teacher()
elif operation == '3':
student()
elif operation == '4':
exit()
else:
print '输入错误'
menu()
def boss():
school1 = ku.School('西部开源', '电子二路', '老李不老!')
print '''
1.招生 2.招聘讲师 3.基本信息 4.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
school1.recruit_student()
time.sleep(2)
print '招生结束'
del school1
boss()
elif choice == '2':
school1.invite()
time.sleep(2)
print '讲师招聘结束'
del school1
boss()
elif choice == '3':
school1.info()
del school1
boss()
elif choice == '4':
del school1
menu()
else:
print '输入错误'
del school1
boss()
del school1
def teacher():
teacher1 = ku.Teacher('老李', 30, 'male', 'linux', '2800')
print '''
1.讲课 2.讲师信息 3.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
teacher1.teach()
time.sleep(5)
print '整理好今天讲的内容,可以走了'
del teacher1
teacher()
elif choice == '2':
teacher1.get_Message()
del teacher1
teacher()
elif choice == '3':
del teacher1
menu()
else:
print '输入错误'
del teacher1
teacher()
def student():
student1 = ku.Student('HnSoi', 22, 'male', '运维', '17')
print '''
1.听课 2.基本信息 3.返回
'''
choice = raw_input('请输入您的操作:')
if choice == '1':
student1.study()
time.sleep(3)
print '拷贝截图笔记,关机走人'
del student1
student()
elif choice == '2':
student1.get_Message()
del student1
student()
elif choice == '3':
del student1
menu()
else:
print '输入错误'
del student1
student()
menu()
#ku.py
class School(object):
#定义类
def __init__(self, name, place, motto):
#构造函数,后面跟需要传递的参数
self.__name = name
#self就是实例化的变量名,self.name是实例化属性,静态属性
self.__place = place
#以双下划线开头的变量名,成为私有变量或属性
self.__motto = motto
def Name(self, name):
#方法,与函数唯一的区别是self,动态属性
self.__name = name
def Place(self, place):
self.__place = place
def Motto(self, motto):
self.__motto = motto
def get_Name(self):
return self.__name
def get_Place(self):
return self.__place
def get_Motto(self):
return self.__motto
def info(self):
print '''
---------------------学校信息--------------------
校名:%s
地址:%s
校训:%s
'''%(self.__name, self.__place, self.__motto)
def recruit_student(self):
print '%s正在招生'%self.get_Name()
def invite(self):
print '%s正在招聘讲师'%self.get_Name()
def __del__(self):
#数据库断开
pass
class People(object):
def __init__(self, name, age, sex):
self.__name = name
self.__age = age
self.__sex = sex
def Name(self, name):
self.__name = name
def Age(self, age):
self.__age = age
def Sex(self, sex):
self.__sex = sex
def get_Name(self):
return self.__name
def get_Age(self):
return self.__age
def get_Sex(self):
return self.__sex
def info(self):
print '''
姓名: %s
年龄: %s
性别: %s'''%(self.__name, self.__age, self.__sex)
def __del__(self):
pass
#继承,对于Student来说,People就是它的父类,对于People来说,Student就是他的子类
#继承最大的好处是子类获得了父类的全部功能。
#继承的另一个好处:多态。子类的覆盖了父类的方法。
class Student(People):
def __init__(self, name, age, sex, Class, ID):
super(Student, self).__init__(name, age, sex)
self.__class = Class
self.__id = ID
def set_Class(self, clazz):
self.__clazz = clazz
def set_ID(self, ID):
self.__id = ID
def get_Class(self):
return self.__clazz
def get_ID(self):
return self.__id
def study(self):
print "%s正在听课"%(self.Name())
def get_Message(self):
self.info()
print '''
班级: %s
学号: %s
'''%(self.__class, self.__id)
def __del__(self):
pass
class Teacher(People):
def __init__(self, name, age, sex, course, money):
super(Teacher, self).__init__(name, age, sex)
self.__course = course
self.__money = money
def Course(self, course):
self.__course = course
def Money(self, money):
self.__money = money
def get_Course(self):
return self.__course
def get_Money(self):
return self.__money
def teach(self):
print "%s正在讲授%s课程"%(self.get_Name(), self.__course)
def get_Message(self):
self.info()
print '''
科目: %s
工资: %s
'''%(self.__course, self.__money)
def __del__(self):
pass
#继承策略:广度优先策略(效率高)
#
深度优先: C一直找父类的方法,如果没有找到相应的方法,再去找和C在同一层的类
class A: # 新式类(object)和经典类
def hello(self):
print 'in the A.......'
class B(A):
def hello(self):
print 'in the B.......'
#pass
class C(A):
pass
# def hello(self):
# print 'in the C.......'
class D(C,B):
pass
# def hello(self):
# print 'in the D.......'
d = D()
d.hello()
相关文章推荐
- python学习-1-列表,元组,字典,集合,文件操作
- python学习-1-列表,元组,字典,集合,文件操作
- Python笔记第2章,文件,字符串,列表,元组,字典,集合的使用
- python基础 第一天 (列表操作、字典操作,集合操作,文件操作)
- Python学习笔记二:列表、字典、元组、集合 简介
- Python3学习笔记05-字典、文件输入输出、模块、函数参数传递
- Python基础操作 列表 字典结构 集合 循环 判断 复制操作 函数
- python3的列表、元组、集合、字典操作
- 笔记--python列表及元组以及关于列表操作的函数使用
- 【python学习笔记】Python数据结构(列表,元组,字典,集合)
- python学习笔记2—python文件类型、变量、数值、字符串、元组、列表、字典
- Python学习笔记ucas(lecture2)数据结构(字符串、列表、元组、字典、集合)
- python---实战3统计特定时间次数(文件操作、替换、列表、排序、去重、元组、集合)
- Python基础:列表,元组,字典,集合相关基本操作
- python笔记2 (列表,元组,字典,集合)
- python笔记之元组、列表、字典和文件
- python---实战5筛选特定数据的长度、最多(字典、元组、列表、文件操作、替换)
- Dive Into Python 学习记录1-函数/模块导入/字典/列表/元组/字符串分割、连接、格式化/映射list/
- Python学习笔记3-Python元组、数组、字典集合的操作
- Python 学习笔记 -- 变量、元组、列表、字典和集合