python基础学习（四）

time模块

sleep()

用法：time.sleep(secs) secs表示多少秒，填入数字

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

时间戳

time()

用法：time.time()
生成当前的时间戳，默认格式为10位整数的浮点数

localtime()

用法：time.localtime(时间戳)
根据时间戳生成当前时区的时间元组

strftime()

用法：time.strftime(‘%Y-%m-%d %H:%M:%S’,时间元祖)
根据时间元组生成时间格式化字符串

import time
start = time.time() # 生成时间戳
start_yuan = time.localtime(start)# 把时间戳转成时间元祖
start_time = time.strftime('%Y-%m-%d %H:%M:%S',start_yuan) # 格式化日期
print(start_time)
#生成目前时间
#输出结果2019-06-21 14:56:44

python内置的查询代码运行速度

%timeit

方法：%timeit + 函数

import timeit
def pySum():
    a = list(range(10000))
    b = list(range(10000))
    c = []
    for i in range(len(a)):
        c.append(a[i]**2 + b[i]**2)
        return c

%timeit pySum()

（1ms=1000µs）

random模块

random()

生成随机小数
用法：random.random()

import random  # 调用random模块

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

randint()

生成随机整数
用法:random.randint(),括号里面填入一个范围整数

import random 
#调用random模块
a = random.randint(1,100)
# 随机生成1-100范围内（含1和100）的一个整数，并赋值给变量a
print(a)

choice()

随机返回列表，字典，元组或字符串的元素，（可能会重复）
用法：random.choice( seq )
seq可以是一个列表，字典，元组或字符串。

import random
punches = ['石头','剪刀','布']
computer_choice = random.choice(punches)
print(computer_choice)

sample()

随机从字符串/列表/字典等对象中抽取选取多个不重复的元素
用法：random.sample(seq, n)
需要传递两个参数，第一个参数是一个序列（列表、字符串、元组），第二个参数是随机选取的元素个数

import random
num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
choice = random.sample(num, 5) 
print(choice)

shuffle()

随机洗牌，比如打乱列表顺序
用法：random.shuffle(列表)

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

函数

函数是组织好的、可以重复使用的、用来实现单一功能的代码
定义函数的语法：

def 函数名(参数1,参数2....参数n):
    函数体
    return 语句

#函数名：最好是取体现函数功能的名字，一般用小写字母和单下划线、数字等组合
def greet(name):
#参数：根据函数功能，括号里可以有多个参数，也可以不带参数，命名规则与函数名相同#规范：括号是英文括号，后面的冒号不能丢
    print(name+'早上好')
    #函数体：函数体就是体现函数功能的语句，要缩进，一般是四个空格
    return 

def face(name):
    return name + '的脸蛋'
def body(name):
    return name + '的身材'
def main(dream_face,dream_body):
    return'我的梦中情人：' + face(dream_face + '+' + body(dream_body))
print(main('李若彤','林志玲'))
#dream_face='李若彤' face('李若彤') 返回'李若彤的脸蛋'

return语句
1.如果不是立即要对函数返回值做操作，那么可以使用return语句保留返回值。
2.需要多吃调用函数时，可以再定义一个主函数main(),调用非主函数的返回值。
3.python的函数返回值可以是多个，多个返回值的数据类型是元祖(tuple)。
4.没有return语句的函数会默认返回None值。
5.一旦函数内部遇到return语句，就会停止执行并返回结果。

变量作用域

x=99   #全局变量x  
def num():
    x=88 #局部变量x 
    print(x)

num() 
#打印局部变量x,输出88

print(x) 
#打印全局变量x，输出99

global语句

将局部变量变成全局变量

def egg():    
    global quantity
#global语句将变量quantity声明为全局变量
    quantity = 108

egg()
print(quantity) #输出108

nonlocal语句

将函数变量变成全局变量

def egg():    
    quantity = 108
    def agg():
        nonlocal quantity
        quantity = 10
        print(quantity) #输出10
    agg()
egg()

类和对象

类

类是一个函数包，用class语句来定义一个类.
在类中被定义的函数被称为类的方法
用法：类名.函数名()
在类中被定义的变量被称为类的属性
用法：类名.变量名

class 智能机器人():
    胸围 = 33
    腰围 = 44
    臀围 = 55
    def 打招呼():
        print('主人你好！')
    def 卖萌():
        print('主人，求抱抱！')
    def 生气():
        print('主人，我要报警了！')

print('把类的属性打印出来：')
print(智能机器人.胸围)
print(智能机器人.腰围)
print(智能机器人.腰围)

智能机器人.打招呼()
智能机器人.卖萌()
智能机器人.生气()
输出：
把类的属性打印出来：
33
44
44
主人你好！
主人，求抱抱！
主人，我要报警了！

```[正确案例]```
class 类A():
    变量1 = 100
    变量2 = 200

    def 函数1(): #[不需要]使用类属性
        print('我不需要使用类属性')

    @classmethod
    def 函数2(cls): #[需要]使用类属性
        print(cls.变量1)
        print(cls.变量2)

类A.函数1()
类A.函数2()

直接使用类：

class 类A():
    变量1 = 100
    变量2 = 200

    @classmethod
    def 函数1(cls):
        print(cls.变量1)
        print(cls.变量2)
类A.函数1()

实例化后再使用：

class 类A():
    变量1 = 'abc'

    def 函数1(self):
        print('已经完成了实例化！')
        print('类属性的值是：' + self.变量1)

a = 类A() #实例化
a.函数1() #实例化后再使用

b = 类A() #可以实例化多个不同的实例
b.函数1() #实例化后再使用

重写主类的方法：

class 类():
    def 原始函数(self):
        print('我是原始函数！')

def 新函数(self):
    print('我是重写后的新函数！')

a = 类() #实例化
a.原始函数()

# 用新函数代替原始函数，也就是【重写类方法】
类.原始函数 = 新函数

# 现在原始函数已经被替换了
a.原始函数()

总结：实例的属性和方法
1.修改类属性和类方法，将会影响所有实例
2.修改某个实例的属性，只会影响这个实例自身
3.不能修改实例的方法
初始化函数：
__init__实例化后就可以立即调用

class 乘法表():
    def __init__(self,n):
        self.n = n

    def 打印(self):
        for i in range(1,self.n + 1):
            for x in range(1,i+1):
                print('%d X %d = %d' %(i,x,i*x),end = ' ')
            print(' ')
三三乘法表 = 乘法表(3)
三三乘法表.打印()

类的继承

用法：class 新类（旧类）

class 父类():
    def __init__(self,参数)：
        self.变量 = 参数

    def 打印属性(self):
        print('变量的值是：')
        print(self.变量)

class 子类(父类)：
    pass #pass语句代表“什么都不做”

子类实例 = 子类(2)
子类实例.打印属性()

子类能覆盖任意父类方法，包括初始化函数__init__
多重继承：
用法：class 子类（父类1.父类2……）

子类引用父类属性-super()

父类：
class Person:
    attr = '666'
子类：
class YellowPeople(Person):
    def print_some(self):
        print(super().attr)

 h = YellowPeople()
 h.print_some()
 #输出666

个人总结，希望对你有帮助。