Python 第二周

集合相关

# 集合的创建
set1 = set()
dict1 = dict()
tuple1 = tuple()
str1 = str()
int1 = int('10')
list1 = list()

# 数字/字符串/元组
set2 = {12, 'str', (1,)}

list2 = ['张三', '张三', '李四', '王五']  # 有重复元素的 列表
set2 = set(list2)  # 去重
print(set2)
list2 = list(set2)
print(list2)  # 去重后转换回来

# 集合的新增  add(元素)
set2.add('赵六')
print(set2)

# pop() 随机删除一个元素  remove(指定元素)  删除指定元素，如果不存在报错   discard(指定元素) 删除指定元素，如果不存在None
# clear() 清空集合

# 集合关系

# & 交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}

print(s1 & s2)  # {2, 3}

# | 并集
print(s1 | s2)

# - 差集
print(s1 - s2, s2 - s1)  # 结果不一样

# ^ 对称差集   找出两个集合中除了共有元素之外的所有元素
print(s1 ^ s2)

# 子集
s2 = {1, 2, 3, 4}
s1 < s2  # 子集
s2 > s1  # 超集

一、函数相关知识点

函数定义
定义函数，也就是创建一个函数，可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现。

1. 函数定义

1.1语法格式

def 函数名(参数列表):
   //实现特定功能的多行代码
    [return [返回值]]

1.2 参数的含义

    函数名：其实就是一个符合 Python 语法的标识符，但不建议读者使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能（如上面的 my_len，即表示我们自定义的 len() 函数）。形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。[return [返回值] ]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。

1.3 注意事项

    在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。另外，如果想定义

2. 函数参数

2.1 必选参数

# 必选参数：顾名思义，就是函数必须有的入参； 
def ice_box2(a, b):  # a 容器  b 动物
    print("把%s门打开" % a)
    print("把%s装进去" % b)
    print("把%s门关上" % a)

# 位置参数
ice_box2('汽车', '长颈鹿')  # 根据位置 传入 数据

# 关键参数 使用形参赋值的方式传递参数。 不考虑顺序
ice_box2(b="长颈鹿", a="汽车")

2.2 默认参数

# 默认参数：在函数定义时给定一个初始值，在函数调用时可以不传这个参数，采用默认参数的值；下例中的y就是默认参数；
def ice_box3(brand, anim, animList=[]):  # animList 默认参数
    print("把%s冰箱门打开" % brand)
    print("把%s装进去" % anim)
    print("把%s冰箱门关上" % brand)
    if len(animList) == 0:
        print("没有可装的动物了")
    else:
        print("继续装入")
# 注意：设置默认参数时，必选参数在前，默认参数在后！

2.3 可选(不定长)参数

# 可选参数：顾名思义，函数参数的个数是可变的，例如下面的args就是可变参数。
def eat_and_drink(a, b, *args):  # a 早餐  b午餐   args零食
    print(a, b)
    print("零食", args)  # args = ('方便面', '辣条', '瓜子')

2.4 关键字参数

# 关键字参数：可选参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def eat_and_drink2(a, b, *args, action="吃", **kwargs):
    print("eat_and_drink2 我要 %s " % action, "a=%s" % a, "b=%s" % b)
    print("eat_and_drink2 我要 %s " % action, "args=", args)
    print("eat_and_drink2 我要 %s " % action, "kwargs=", kwargs)
    print("eat_and_drink2 %s 饱了" % action)

eat_and_drink2('豆浆', '太钢汽水', '冰红茶', action="喝", sx="和子饭", bj="豆汁")
# 无返回值的函数  类型是None
print(eat_and_drink2('豆浆', '太钢汽水', '冰红茶', action="喝", sx="和子饭", bj="豆汁"))

2.5 函数嵌套

def func1():
    print("fun1执行")


def func2():
    func1()
    print("fun2执行")

2.6 总结

函数参数的用法是非常灵活的，既可以简单调用，也可以传入复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。

3. 函数作用域

3.1作用域指的是变量的有效范围

通常，函数内部的变量无法被函数外部访问，但内部可以访问；类内部的变量无法被外部访问，但类的内部可以。通俗来讲，就是内部代码可以访问外部变量，而外部代码通常无法访问内部变量。

3.2全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，被叫做局部变量
定义在函数外的拥有全局作用域的变量，被称为全局变量。（类、模块等同理）# 所谓的局部变量是相对的。局部变量也有可能是更小范围内的变量的外部变量。

# 实例
a = 1               # 全局变量
def func():
    b = 2           # 局部变量
    print(a)        # 可访问全局变量a,无法访问它内部的c
    def inner():
        c = 3       # 更局部的变量
    print(a)    # 可以访问全局变量a
    print(b)    # b对于inner函数来说，就是外部变量
    print(c)

global关键字
global：指定当前变量使用外部的全局变量 尽量不要这样操作

4 函数进阶

4.2闭包

# 闭包的由来，想让一个变量提供给其他函数去使用，不用修改
def func():
    name = "我初始化一次，不可被修改，常驻内存"
    def inner():
        print(name) # name是func中的一个局部变量，inner方法还在引用，所以内存会保留下来
    return inner

test1 = func()  # 1 func()   2 将返回的inner 赋值给 test1
# test2 = func
test1()
test1()
test1()
test1()

4.2装饰器

# 装饰器
def modify_phone(function_name):
    print('-----装饰手机1------')
    def inner():
        print('加装手机壳')
        return function_name()
    return inner

def modify_phone2(function_name):
    print('-----装饰手机2------')
    def inner():
        print('贴钢化膜')
        return function_name()
    return inner

def modify_phone3(function_name):
    print('-----装饰手机3------')
    def inner():
        print('蓝牙耳机')
        return function_name()
    return inner

@modify_phone    #  由上而下  多装饰器 外层函数由下而上  内层函数由上而下
@modify_phone2
@modify_phone3
def phone():
    print('装饰手机')

result = phone()  # 先执行装饰器的函数 最后执行phone()


# 带参数的装饰器
def func4(arg1,arg2):
    def modify_phone(function_name):
        print(arg1)
        def inner():
            print(arg2)
            return function_name()
        return inneruytygbh
    return modify_phone

@func4('第二次装饰','钢化膜')
@func4('第一次装饰','手机壳')
def phone():
    print('装饰手机')

4.3常用的内建函数

eval(): 将字符串作为 代码表达式执行， 返回结果
exec(): 执行动态语句
map():  将可迭代的对象 转换位新的可迭代对象
filter(): 对序列进行过滤，返回值为True的元素
zip(): 将多个可迭代的对象打包成一个元组
len(): 返回序列的长度
sorted(): 对可迭代对象进行排序
min(): 返回可迭代对象中的最小的值
max(): 返回可迭代对象中的最大值、
sum(): 求和， 元素必须是数字类型
reversed(): 返回逆序的可迭代对象
range(): 快速生成一个数字序列

4.4 迭代器

iter() 调用迭代器 next() 取数据
iter() 和 next() 都存在迭代器。 iter() 只有一个存在可迭代对象

5. 面向对象

 OOP  面向对象编程

# 面向过程 1，把冰箱门打开  2. 把大象装进去 3. 关上冰箱门
# 面向对象  大象装进冰箱

class 类名:  类名使用大驼峰命名  Person   AsianPerson
    def 函数名(self,[形式参数]):
        self.属性 = 值
        函数体

    def __init__(self,[形式参数]): # 构造函数
        self.属性 = 值

# 面向对象 三大特征 封装 继承 多态
封装
将属性和方法书写到类的里面的操作即为封装
封装可以为属性和方法添加私有权限
继承
子类默认继承父类的所有属性和方法
子类可以重写父类属性和方法
多态
传入不同的对象，产生不同的结果

使用规则

# 对象语法
  对象名 = 类名()
  self: 指的是调用该函数的对象本身
# 类外面获取对象属性
  对象名.属性名
# 类里面获取对象属性
  self.属性名

内置函数（魔法）

1. __init__()方法的作用：初始化对象时自动调用。
2. 带参数的__init__()
思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
3.__str__()
当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。
class IceBox():
    def __init__(self, width, height):
        self.width = width
        self.height = height

   def __str__(self):
        return '这是海尔冰箱的说明书'
haier1 = IceBox(10, 20)
# 这是海尔洗衣机的说明书
print(haier1)

5.1封装

封装实例代码

class Box:
    def __init__(self,name):  # 构造方法   name是形参
        self.name = name
        self.animList = []  # 装动物的空间

    def open_door(self):
        print('%s门打开' % self.name)

    def push(self,anim):
        self.animList.append(anim)

    def close_door(self):
        print('%s门关闭' % self.name)

    def __str__(self):  # 打印对象描述信息
        return self.name+'装了'+str(len(self.animList))+'只动物'

box = Box('冰箱')   # Box 的 __init__方法执行
box.open_door()
box.push('大象')
box.close_door()
print(box)       # __str__方法执行

box2 = Box('笼子')
box2.open_door()
box2.push('雪豹')
box2.push('老虎')
box2.close_door()
print(box2)

5.2 继承

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：

# 父类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 子类B
class B(A):
    pass

result = B()
result.info_print()  # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

5.3 单继承实例

class Animal:
    def __init__(self):
        print('我是一个动物，会动。 初始化完成')

    def action(self):
        print("这是动物的行为")


class Dog(Animal):  # 单继承
    def __init__(self):
        super().__init__()
        super().action()
        print('我是一只狗。 初始化完成')

super()调用父类方法

5.4 多继承

class Train:
    def __init__(self):
        print('训练类 初始化完成')

    def work(self):
        print('训练做一些社会工作')

class GoldDog(Dog,Train):  # 继承顺序， 后边的类中不能出现前面类中的方法名
    def __init__(self):
        super().__init__()  # 同名方法就近原则
        print('金毛 初始化完成')

    def daoMang(self):
        print('导盲任务')

goldDog = GoldDog()
goldDog.work()
goldDog.swim()
goldDog.daoMang()

# 尽量使用单继承，多继承中的类方法名尽量不要重复。

5.5多态

多态 对父类的方法进行重写

class LocalDog(Dog):
    def __init__(self):
        super().__init__()  #  非必须调用父类方法
        print('中华田园犬初始化完成')

    def swim(self):  # 重写swim 方法
        super().swim()
        print('游的不太好')

localDog = LocalDog()
localDog.swim()

5.6 抽象类

抽象类（python本身不支持） 指定一个类规范写法

from abc import ABCMeta,abstractmethod
 
class PaymentAbc(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money): pass

    @abstractmethod
    def func(self): pass

class AliPay(PaymentAbc):
    def pay(self,money):
        print('这里用支付宝付了 %s 块钱' % money )

    def func(self): # 支付宝中的其他方法，例如 查余额， 转账
        print('查余额/转账')


class WxPay(PaymentAbc):
    def pay(self, money):
        print('这里用微信支付了 %s 块钱' % money)

    def func(self):  # 支付宝中的其他方法，例如 查余额， 转账
        print('查余额/转账')