python基础3----函数与类

模块

time模块——时间

import time   #调用time模块
time.sleep(secs)   
#使用time模块下面的sleep()函数，括号里填的是间隔的秒数（seconds，简称secs）
#time.sleep(1.5)就表示停留1.5秒再运行后续代码

random模块——随机生成数字

random.randint(a,b)

• 生成一个指定范围[a,b]内的整数

import random  # 调用random模块

a = random.random()  # 随机从0-1之间（包括0不包括1）抽取一个小数
print(a)

a = random.randint(0,100)  # 随机从0-100（包括0和100）之间抽取一个数字
print(a)

a = random.choice('abcdefg')  # 随机从字符串，列表等对象中抽取一个元素（可能会重复）
print(a)

a = random.sample('abcdefg', 3) # 随机从字符串，列表等对象中抽取多个不重复的元素
print(a)

items = [1, 2, 3, 4, 5, 6]  # “随机洗牌”，比如打乱列表
random.shuffle(items)
print(items)

**random.choice()**函数

• random.choice(sequence)：从序列中获取一个随机元素

random.random()

• 生成一个0到1的随机浮点数

random.uniform(a,b)

• 生成一个指定范围(a,b)内的随机浮点数

random.randrange(start, stop, step)

• 从指定范围内，按指定基数递增的集合中 获取一个随机数

random.shuffle(AB)

• 用于将一个列表中的元素打乱

random.sample(sequence, k)

• 从指定序列中随机获取指定长度的片断

函数

定义函数

def 函数名(参数):
	函数体
	return 语句

# 函数名：1. 名字最好能体现函数的功能，一般用小写字母和单下划线、数字等组合
#      2. 不可与内置函数重名（内置函数不需要定义即可直接使用）
def math(x):
# 参数：根据函数功能，括号里可以有多个参数，也可以不带参数，命名规则与函数名相同
# 规范：括号是英文括号，后面的冒号不能丢
    y = 3*x + 5
# 函数体：函数的执行过程，体现函数功能的语句，要缩进，一般是四个空格
    return y
# return语句：后面可以接多种数据类型，如果函数不需要返回值的话，可以省略

调用函数

def math(x):
    y = x ** 2 + x
    return y
a = math(20)#调用函数
b = math(30)
print(a)
print(b)

参数类型

默认参数

def  menu(appetizer, course, dessert = '绿豆沙'):
    print('一份开胃菜：' + appetizer)
    print('一份主食：' + course)
    print('一份甜品：' + dessert)

menu('话梅花生','牛肉拉面')
#因为已经默认将'绿豆沙'传递给dessert，调用时无须再传递。
print('------------------')
#如果采用下面这种形式传递，就不需要理会参数位置
menu(course = '牛肉拉面', appetizer = '话梅花生')
print('------------------')
menu('话梅花生','牛肉拉面','银耳羹')
print('------------------')
menu('话梅花生','牛肉拉面','银耳羹')

不定长参数

• 格式：def 函数名（*参数）
• 参数返回值是元组类型
• 不定长参数可以接收任意数量的值

def menu(*barbeque):
    for i in barbeque:
        print('一份烤串：' + i)

menu('烤香肠', '烤肉丸') #括号里的这几个值都会传递给参数barbeque       
menu('烤鸡翅', '烤茄子', '烤玉米')
# 不定长参数可以接收任意数量的值

try…except…语句

try:
	#尝试执行下列代码
	...
except ***:
	#除非发生报错，***是报错类型，移到报错执行下列代码
	...
	

try:    age = int(input('请输入一个整数：'))except ValueError:    print('要输入整数噢')

python异常标准

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

类与对象

• 类:比如整数、字符串、浮点数等，不同的数据类型就属于不同的类
• 类有自己的属性和方法
• 类名要大写
• 实例:类的个例就叫做实例
• 对象*:对象等于类和实例的集合：即类可以看作是对象，实例也可以看作是对象，比如列表list是个类对象，[1,2]是个实例对象，它们都是对象。

类的创建

class 类名:
	赋值语句#类的属性创建
	def 方法名(self):#类中定义的函数叫方法
		执行过程

class Computer:#
	screen = True## 用赋值语句，创建类的属性
	def start(self):
		print('电脑正在开机中...')

类的调用

调用语法

实例名.属性
实例名.方法（）

class Computer:
    screen = True
    def start(self):
        print('电脑正在开机中……')
my_computer = Computer()#类的实例化
print(my_computer.screen)#调用属性属性
my_computer.start()#调用类中的方法（传参不用管self）

self

• self会接收实例化过程中传入的数据，当实例对象创建后，实例便会代替 self，在代码中运行。

• self的作用相当于先给实例占了个位置，等到实例创建好就“功成身退，退位让贤”。

在方法内调用类的属性

self.属性名

#通过self.属性名
class Chinese:

    name = '吴枫'  # 类属性name

    def say(self):     
        print(self.name + '是中国人')#调用类中的属性

person = Chinese()   # 创建Chinese的实例person
person.say()         # 调用实例方法
#实例person会像参数一样传给self，替换掉self，第六行的self.name等价于person.name

在类方法调用其他方法

self.方法名（）

#self.方法名（）
class Chinese:
    def greeting(self):
        print('很高兴遇见你')
    def say(self):
        self.greeting() 
        print('我来自中国')
person = Chinese()
# 创建实例person
person.say()
# 调用say()方法

初始化方法

#格式__init__(self)

• 当每个实例对象创建时，该方法内的代码无须调用就会自动运行

# 阅读代码后直接运行    
class Chinese:

    def __init__(self): 
        print('很高兴遇见你，我是初始化方法')

person = Chinese()

• 利用这个特性，在编写习惯上，我们会在初始化方法内部完成类属性的创建，为类属性设置初始值，这样类中的其他方法就能直接、随时调用

class Chinese:

    def __init__(self, name, birth, region):
        self.name = name   # self.name = '吴枫' 
        self.birth = birth  # self.birth = '广东'
        self.region = region  # self.region = '深圳'
        #self.不能丢

    def born(self):
        print('{}出生在{}'.format(self.name,self.birth))

    def live(self):
        print('{}居住在{}'.format(self.name,self.region) )    

person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数
person.born()
person.live()
print(person.birth)#输出方法内的参数

面向对象编程：类的创建和调用

面向过程编程：函数的创建和调用

类的继承和定制

类的继承

• 让子类拥有了父类拥有的所有属性和方法
• A类为B的子类，B为A的父类

语法

• class 子类名（父类名）

class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  
# 通过继承，Chinese类有的，Cantonese类也有
    pass
# 验证子类可以继承父类的属性和方法，进而传递给子类创建的实例
yewen = Cantonese()  
# 子类创建的实例，从子类那间接得到了父类的所有属性和方法
print(yewen.eye)  
# 子类创建的实例，可调用父类的属性
yewen.eat()  
# 子类创建的实例，可调用父类的方法

• class Chinese:在运行时相当于class Chinese(object):。而object，是所有类的父类

验证类

• 函数isinstance(实例，类名)

# 阅读完代码再运行。
class Chinese:
    pass

class Cantonese(Chinese):
    pass
gonger = Chinese()
# 宫二，电影《一代宗师》女主，生于东北
yewen = Cantonese()
# 叶问，电影《一代宗师》男主，生于广东
print('\n验证1：子类创建的实例同时也属于父类')
print(isinstance(gonger,Chinese))  
print(isinstance(yewen,Chinese))  

print('\n验证2：父类创建的实例不属于子类。')
print(isinstance(gonger,Cantonese))

print('\n验证3：类创建的实例都属于根类。')
print(isinstance(gonger,object))  
print(isinstance(yewen,object))

类的多层继承

• 继承不仅可以发生在两个层级之间（即父类-子类），还可以有父类的父类、父类的父类的父类……

class A(B)
class C(B)

类的多重继承

• 语法为class A(B,C,D)
• 一个类，可以同时继承多个类，**语法为class A(B,C,D)**:。假设我们将“出生在江苏，定居在广东的人”设为一个类Yuesu，那么，它的创建语句则为class Yuesu(Yue,Su)
• 就近原则：越靠近子类（即越靠左）的父类，越亲近，越优先考虑。子类调用属性和方法时，会先在靠左的父类里找，找不到才往右找。

class Su:
    born_city = 'Jiangsu'
    wearing = 'thick'  # 穿得较厚

    def diet(self):
        print('我们爱吃甜。')

class Yue:
    settle_city = 'Guangdong'
    wearing = 'thin'  # 穿得较薄

    def diet(self):
        print('我们吃得清淡。')

class Yuesu(Yue,Su):
    pass

xiaoming = Yuesu()
print(xiaoming.wearing)
print(xiaoming.born_city)
xiaoming.diet()

类的定制

类的定制，不仅可以让子类拥有新的功能，还能让它有权修改继承到的代码

• 新增代码

class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  # 类的继承
    native_place = 'guangdong'  # 类的定制

    def dialect(self):  # 类的定制
        print('我们会讲广东话。')

yewen = Cantonese()
print(yewen.eye)
# 父类的属性能用
print(yewen.native_place)
# 子类的定制属性也能用
yewen.eat()
# 父类的方法能用
yewen.dialect()
# 子类的定制方法也能用

• 重写代码

class Chinese:

    def land_area(self,area):
        print('我们居住的地方，陆地面积是%d万平方公里左右。'% area)

class Cantonese(Chinese):
    # 间接对方法进行重写
    def land_area(self, area, rate = 0.0188):
        Chinese.land_area(self, area * rate)
        # 直接继承父类方法，再调整参数。

gonger = Chinese()
yewen = Cantonese()
gonger.land_area(960)
yewen.land_area(960)