您的位置:首页 > 编程语言 > Python开发

[置顶] 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()
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐