python熟练篇

一、函数

1、定义函数

def 函数名（形式参数列表）：
函数体
return 返回值

def rect_area(width, height):  # 这个函数有返回值
    area = width * height
    return area


def print_area(width, height): # 这个函数没有返回值
    area = width * height
    print('{0}*{1}长方形的面积{2}'.format(width, height, area))

2、使用位置参数调用函数

在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式

def rect_area(width, height):  # (width, height)表示形参列表
    area = width * height
    return area


r_area = rect_area(320, 480) # (320, 480)表示实参列表，顺序与形参一致
print('{0}*{1}长方形的面积{2}'.format(320, 480, r_area))

3、使用关键字参数调用函数

在调用函数时可以采用‘关键字=实参’的形式，其中，关键字的名称就是定义函数时形参的名称。
优势：实参不再受形参的顺序限制

def rect_area(width, height):  # (width, height)表示形参列表
    area = width * height
    return area


r_area = rect_area(height=320, width=480)  # 实参不再受形参的顺序限制
print('{0}*{1}长方形的面积{2}'.format(320, 480, r_area))

4、参数的默认值

函数重载会增加代码量，所以在python中没有函数重载的概念，而是为函数的参数提供默认值实现的。
具体代码

def make_coffee(name='卡布奇诺'): # '卡布奇诺'是默认值
    return '制作一杯{0}咖啡'.format(name)

coffee1 = make_coffee('拿铁') # 提供参数'拿铁'
coffee2 = make_coffee() # 没有提供参数，使用默认值'卡布奇诺'

print(coffee1)
print(coffee2)

5、可变参数

python中的函数可以定义接收不确定数量的参数，这种参数被称为可变参数。可变参数有两种，即在参数前加*或**。

• 基于元组的可变参数（*可变参数）

def sum(*numbers):
    total = 0.0
    for number in numbers:
        total += number
    return total

print(sum(100.0,20.0,30.0)) # 输出150.0
print(sum(30.0,80.0)) # 输出110.0

• 基于字典的可变参数（**可变参数）

def show_info(**info):
    print('----show_info---')
    for key, value in info.items(): # 遍历字典
        print('{0} - {1}'.format(key, value))


show_info(name='Tony', age=18, sex=True)
show_info(student_name='Tony', student_no='10000')

6、函数中变量的作用域

模块里面有函数，函数里面有变量。
全局变量和局部变量
具体代码

x = 20

def print_value():
    global x#将x提升为全局变量
    x = 10
    print('函数中的x = {0}'.format(x))
print_value()
print('全局变量中的x ='+str(x))

7、函数类型

python中的任意一个函数都有数据类型，这种数据类型是function，被称为函数类型。
理解函数类型
1、一个函数可以作为另一个函数返回值使用。
2、一个函数可以作为另一个函数参数使用。

具体代码

# 定义加法函数
def add(a, b):
    return a + b
    
# 定义减法函数
def sub(a,b):
    return a - b

#定义平方函数
def square(a):
    return a*a

#定义计算函数
def calc(opr):
    if opr == '+':
        return add
    else:
        return sub

f1 = calc('+')#f1实际上是add函数
f2 = calc('-')#f2实际上是sub函数
print(type(f1))
print('10+5={0}'.format(f1(10,5)))
print('10-5={0}'.format(f2(10,5)))

8、过滤函数filter（）

filter（function，iterable）
具体代码

# 提供过滤条件函数
def f1(x):
    return x > 5#找出大于5的元素

data1 = [1,2,3,4,5,6]
filtered = filter(f1,data1) # 调用filter函数
data2 = list(filtered)#转换为列表
print(data2)

9、映射函数map（）

map（function，iterable）
具体代码

# 提供变换规则的函数
def f1(x):
    return x * 2#变换规则乘以2

data1 = [1,2,3,4,5,6]
mapped = map(f1,data1)
data2 = list(mapped)#转换为列表
print(data2)

10、lambda函数

在python中使用lambda关键字定义匿名函数
lambda关键字定义的函数也被称为lambda函数。
lambda参数列表：lambda体
具体代码

def calc(opr):
    if opr == '+':
        return lambda a,b:(a + b)
    else:
        return lambda a,b:(a - b)

f1 = calc('+')
f2 = calc('-')
print('10+5={}'.format(f1(10,5)))
print('10-5={0}'.format(f2(10,5)))

二、类与对象

1、面向对象

面向对象是一种编程思想，即按照真实世界的思维方式构建软件系统

2、定义类

class 类名[(父类）]:
类体

object是所有类的根类
class Car（object）：
#类体
pass

3、创建对象

object是所有类的根类
class Car（onject）：
#类体
pass
car = Car（）

4、类的成员

4.1成员变量

• 实例变量
  实例变量就是对象个体特有的“数据”，例如狗狗的名称和年龄等
  实际代码

class Dog:
    def __init__(self, name, age): # __init__()方法是构造方法，构造方法用来初始化实例变量，注意，init前后是两个下划线
        self.name = name # 创建和初始化实例变量name
        self.age = age # 创建和初始化实例变量age

d = Dog('球球', 2)
print('我们家狗狗名叫{0}, {1}岁了。'.format(d.name,d.age)) # d.name对实例变量通过'对象.实例变量'形式访问

• 类变量
  类变量是属于类的变量，不属于单个对象

class Account:
    interest_rate = 0.0568 # 类变量利率interest_rate

    def __init__(self, owner, amount):
        self.owner = owner # 创建并初始化实例变量owner
        self.amount = amount # 创建并初始化实例变量amount

account = Account('Tony', 800000.0)

print('账户名：{0}'.format(account.owner))
print('账户金额：{0}'.format(account.amount))
print(('利率：{0}'.format(Account.interest_rate)))

4.2构造方法
类中的_init_()方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是“构造方法”

class Dog:
    def __init__(self, name, age, sex = '雌性'):
        self.name = name # 创建和初始化实例变量name
        self.age = age # 创建和初始化实例变量age
        self.sex = sex # 创建和初始化实例变量sex

d1 = Dog('球球', 2)
d2 = Dog('哈哈', 1, '雄性')
d3 = Dog(name = '拖布',sex='雄性',age=3)

print('{0}:{1}岁{2}'.format(d1.name,d1.age,d1.sex)) # 输出:球球2岁雌性
print('{0}:{1}岁{2}'.format(d2.name,d2.age,d2.sex)) # 输出：哈哈1岁雄性
print('{0}:{1}岁{2}'.format(d3.name,d3.age,d3.sex)) # 输出：拖布3岁雄性

4.3成员方法

• 实例方法
  实例方法和实例变量一样，都是某个实例（或对象）个体特有的方法。
  具体代码

class Dog:
    # 构造方法
    def __init__(self, name, age, sex='雌性'):
        self.name = name
        self.age = age
        self.sex = sex
    #实例方法
    def run(self):
        print('{}在跑'.format(self.name))
        
    #实例方法
    def speak(self, sound):
        print('{}在叫，“{}”！'.format(self.name, sound))


dog = Dog('球球', 2)
dog.run()
dog.speak('旺 旺 旺')

• 类方法
  类方法与类变量相似，属于类，不属于个体实例
  涉及到装饰器的概念：装饰器就是在函数前面加一些说明和注释让它有一些特殊的含义，装饰器有很多由系统定义，也可以自定义。

class Account:
    interest_rate = 0.0568  # 类变量利率interest_rate

    def __init__(self, owner, amount):
        self.owner = owner  # 创建并初始化实例变量owner
        self.amount = amount  # 创建并初始化实例变量amount

    # 类方法
    @classmethod #系统定义的装饰器
    def interest_by(cls, amt): # cls当前类的类型
        return cls.interest_rate * amt


interest = Account.interest_by(12000.0)
print('计算利息：{0:.4f}'.format(interest))

5、封装性

封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。
在python语言中私有变量和属性的定义都可以实现封装

5.1私有变量
私有变量：为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为“私有变量”。
私有变量，则在变量前加上双下划线（__)

class Account:
    __interest_rate = 0.0568  # 类变量利率__interest_rate

    def __init__(self, owner, amount):
        self.owner = owner  # 创建并初始化公有实例变量owner
        self.__amount = amount  # 创建并初始化私有实例变量amount

    def desc(self):
        return "{0}金额：{1}利率：{2}。".format(self.owner, self.__amount, Account.__interest_rate)


account = Account('Tony', 800000.0)
account.desc()

print('账户名：{0}'.format(account.owner))
print('账户金额：{0}'.format(account.__amount))# 错误发生
print('利率：{0}'.format(account.__amount))# 错误发生

5.2私有方法
私有方法与私有变量的封装是相似的，在方法前加上双下划线（__)就是私有方法了

class Account:
    __interest_rate = 0.0568  # 类变量利率__interest_rate

    def __init__(self, owner, amount):
        self.owner = owner  # 创建并初始化公有实例变量owner
        self.__amount = amount  # 创建并初始化私有实例变量amount

    def __get_info(self):
        return "{0}金额：{1}利率：{2}。".format(self.owner, self.__amount, Account.__interest_rate)
    def desc(self):
        print(self.__get_info())


account = Account('Tony', 800000.0)
account.desc()
account.__get_info #发生错误

5.3使用属性
为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和（get）取值方法访问

class Dog:
    def __init__(self,name,age,sex='雄性'):
        self.name = name #创建和初始化实例变量name
        self.__age = age #创建和初始化私有变量__age

    #实例方法
    def run(self):
        print('{}在跑'.format(self.name))

    @property
    def age(self): #替代get_age(self):
        return self.__age

    @age.setter
    def age(self,age): # 替代set_age(self,age)
        self.__age = age

dog = Dog('球球',2)
print('狗狗年龄：{}'.format(dog.age))
dog.age = 3 #dog.set_age(3)
print('修改后狗狗年龄：{}'.format(dog.age))

6、继承性

1、继承性也是面向对象重要的基本特性之一。在现实世界中继承关系无处不在。
2、例如猫与动物之间的关系：猫是一种特殊动物，具有动物的全部特征和行为，即数据和操作。面向对象中动物是一般类，被称为‘父类’；猫是特殊类，被称为‘子类’。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。
6.1python中的继承

class Animal:
    def __init__(self, name):
        self.name = name  # 实例变量name

    def show_info(self):
        return '动物的名字：{0}'.format(self.name)

    def move(self):
        print('动一动....')


class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age  # 实例变量age


cat = Cat('Tom', 2)
cat.move()
print(cat.show_info())

6.2多继承
简单来说就是一个子类继承多个父类。

class Donkey:
    def __init__(self, name):
        self.name = name  # 实例变量name

    def show_info(self):
        return '驴的名字：{0}'.format(self.name)

    def run(self):
        print('驴跑。。。。')

    def roll(self):
        print('驴打滚。。。')


class Mule(Horse, Donkey):  # 骡子继承了马和驴
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age  # 实例变量age

m = Mule('骡宝莉', 1)
m.run()  # 继承父类Horse方法
m.roll()  # 继承父类Donkey方法
print(m.show_info())  # 继承父类Horse方法，输出的是：马：骡宝莉，1岁

6.3方法重写

class Donkey:
    def __init__(self, name):
        self.name = name  # 实例变量name

    def show_info(self):
        return '驴的名字：{0}'.format(self.name)

    def run(self):
        print('驴跑。。。。')

    def roll(self):
        print('驴打滚。。。')


class Mule(Horse, Donkey):  # 骡子继承了马和驴
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age  # 实例变量age

    def show_info(self): # 重写了show_info方法
        return '骡：{0}，{1}岁'.format(self.name,self.age)

m = Mule('骡宝莉', 1)
m.run()  # 继承父类Horse方法
m.roll()  # 继承父类Donkey方法
print(m.show_info())  # 继承父类Horse方法，重写之后，输出的是：骡：骡宝莉，1岁

7、多态性

1、‘多态’是指对象可以表现出多种形态。
2、例如，猫，狗，鸭子都属于动物，他们有‘叫‘和’动‘等行为。但是’叫的方式不同，动的方式也不同

8、继承与多态

继承与多态是密不可分的，没有继承就没有多态。
在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类的方法。

class Dog(Animal):
    def speak(self):
        print('小狗汪汪叫')

class Cat(Animal):
    def speak(self):
        print('小猫喵喵叫')

an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()
an3 = Animal()
an3.speak()

9、鸭子类型测试与多态

1、鸭子类型测试是指：若看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。
2、python支持鸭子类型测试，python解释器不检查发生多态的对象是否继承了同一个父类，只要他们有相同的行为（方法），他们之间就是多态的。

def start(obj):  # 接收obj对象具有speak方法
    obj.speak()


class Animal():
    def speak(self):
        print('动物叫，但是不知道是哪种动物叫')


class Dog():
    def speak(self):
        print('小狗汪汪叫')


class Cat():
    def speak(self):
        print('小猫喵喵叫')


class Car():
    def speak2(self):
        print('小汽车车滴滴叫')


start(Dog())
start(Car())#会报错

三、第一个异常----除零异常

1、异常捕获

多个except代码块
try:
<可能引发异常的语句>
except[异常类型]
<处理异常>
except[异常类型]
<处理异常>
except[异常类型]
<处理异常>
except：
处理异常

i = input('请输入数字')
n = 888
try:
    result = n / int(i)
    print(result)
    print('{}除以{}等于{}'.format(n, i, result))
except ZeroDivisionError:
    print('不能输入0')
except ValueError:
    print('输入的值不对')
except:
    print('不知道什么错误')

多重异常捕获
try-except语句嵌套，有因果关系的异常才可以嵌套

2、使用finally代码块

3、自定义异常类

语法
class ZhijieketangException(Exception):
def init(self,message):
super().init(message)

4、手动引发异常

到目前为止，我们接触到的异常都是由解释器引发的，我们也可以通过raise语句手动引发异常。

class ZhijieketangException(Exception):
    def __init__(self, message):
        super().__init__(message)


i = input('请输入数字：')
n = 8888
try:
    result = n / int(i)
    print(result)
    print('{}除以{}等于{}'.format(n, i, result))
except ZeroDivisionError as e:
    # print('不能除以0，异常：{}'.format(e))
    raise ZhijieketangException('不能除以0')
except ValueError as e:
    # print('输入的是无效数字，异常：{}'.format(e))
    raise ZhijieketangException('输入的是无效数字')

四、常用内置模块

1、数学计算模块-math

• 1.ceil（x）返回大于或等于x最小整数
• 2.floor（x）返回小于或等于x最大整数
• 3.sqrt（）返回x的平方根
• 4.pow（x，y）返回x的y次幂值
• 5.log（x[,base])返回以base为底的x对数，若省略底数base，则计算x自然对数
• 6.sin（x）返回x的三角正弦
• 7.degrees（x）将弧度x转为角度
• 8.radians（x）将角度转为弧度
  具体代码

import math

x = 2.5

print(math.ceil(x))

2、日期时间模块-datetime

• datetime类:包含时间和日期datetime.datetime(year,month,day,hour=0,minute=0,second=0,microsecon=0,tzinfo=None
  注意，前三个参数年月日不能省略
  datetime类的常用方法如下
  datetime.today（）:返回当前的本地日期和时间
  datetime.now(tz=None):返回指定时区的当前日期和时间，参数tz用于设置时区，如果参数tz为None或省略，则等同于today（）。
  datetime.fromtimestamp（timestamp，tz=None）：返回与UNIX

• date：只包含日期
  datetime.date(year,month,day)
  date类的常用方法如下：
  1、date.tody():返回当前的本地日期
  2、date.fromtimestamp(timestamp):返回与UNIX时间戳对应的本地日期

• time：只包含时间
  datetime.time(hour=0,minute=0,second=0,microsecon=0,tzinfo=None

• timedelta：计算时间跨度
  时间差值
  datetime.timedelta(days=0,second=0,microsecon=0,milliseconds=0,minutes=0,hours=0,weeks=0)
  ays=0天
  second=0秒
  microsecon=0微秒
  milliseconds=0,毫秒
  minutes=0,分钟
  hours=0,小时
  weeks=0周
  将日期时间与字符串相互转换
  1、将日期时间对象转换为字符串时，称之为日期时间格式化。在python中使用strtime（）方法进行日期时间的格式化，在datetime、date、和time三个类中都有一个实例方法strftime（format）。
  2、将字符串转换为日期时间对象的过程，叫做日期时间解析。在python中使用datetime.strptime(date_string,format)类方法进行日期时间解析。

• tzinfo：时区信息

3、正则表达式模块-re

正则表达式指预先定义到一个‘字符串模板’，通过这个‘字符串模板’可以匹配、查找和替换那些匹配‘字符串模板’的字符串。
字符串匹配
我们使用match（p，text）函数进行字符串匹配，其中的参数p时正则表达式，即字符串模板，text是要验证的字符串。如果匹配成功，则返回一个Match对象（匹配对象），否则返回None。

#正则表达式
p = r'\w+@baidu\.com'
#需要验证的字符串
email1 = '39812614@baidu.com'

m = re.match(p,email1)

print(m)

字符串查找
1、search（p,text):在text字符串中查找匹配的内容，如果找到，则返回第一个匹配的Mach对象，否则返回None。p是正则表达式。
2、findall（p，text）：在text字符串中查找所有匹配的内容，如果找到，则返回所有匹配的字符串列表。如果一个都没有匹配。则返回None。p表示正则表达式
字符串替换
re.sub(pattern,repl,string,cunt=0)
参数pattern是正则表达式；参数repl是用于替换的新字符串；参数string是即将被替换的旧字符串；参数count是要替换的最大数量，默认值为零，表示不限制替换数量
具体代码

import re
#正则表达式
p = r'\d+'#匹配数字（出现一次或多次）正则表达式
#需要验证的字符串
text = 'ab12cd34ef'

m = re.sub(p,' ',text)

print(m)

字符串分割

re.split(pattern,string,maxsplit=0)
参数pattern是正则表达式，参数string是要分割的字符串，参数maxsplit是最大分割次数；maxsplit是默认值为零，表示分割次数没有限制。
具体代码

#正则表达式
p = r'\d+'#匹配数字（出现一次或多次）正则表达式
#需要验证的字符串
text = 'ab12cd34ef'

m = re.split(p,text,maxsplit=1)

print(m)