[Python知识库]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异常标准

类与对象

• 类:比如整数、字符串、浮点数等，不同的数据类型就属于不同的类
• 类有自己的属性和方法
• 类名要大写
• 实例:类的个例就叫做实例
• 对象*:对象等于类和实例的集合：即类可以看作是对象，实例也可以看作是对象，比如列表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)