Python之基础篇

# 引用
# 通过id访问内存地址
a = 1
b = a
id(a) # 4506634176
id(b) # 4506634176

# 列表
my_list = [1, 2, 3]
id(my_list) # 4330354760

my_list2 = [1, 2, 3]
id(my_list2) # 4330354824

# 集合
my_dict = {'name':'ww', 'age':18}
id(my_dict) # 4329891952

my_dict2 = {'name':'ww', 'age':18}
id(my_dict2) # 4330352216

# 字典
my_set = {1, 2, 'ww'}
id(my_set) # 4329889576

my_set2 = {1, 2, 'ww'}
id(my_set2) # 4330319208

# 字符串
my_str = 'hello'
id(my_str) # 4330358240

my_str2 = 'hello'
id(my_str2) # 4330358240

# 数字
my_num = 1
id(my_num) # 4297644416

my_num2 = 1
id(my_num2) # 4297644416

# 元祖
my_tuple = (1, 2, 3)
id(my_tuple) # 4329967760

my_tuple2 = (1, 2, 3)
id(my_tuple2) # 4329967760

# 1.缺省参数
# 定义时，参数就有值
# 缺省参数必须在必选参数的后面
def sum(a, b = 1):
    return a + b
sum(20) # 21

# 2.位置传参和关键字传参
def sum(a, b = 1):
    return a + b
sum(b = 2, a = 20) # 22

# 3.不定长参数
# 封装成tuple 
def sum(*args):
    count = 0
    for num in args:
        count += num
    return count
sum(1, 2, 3, 4)

# 封装成dict
def show(**kwargs):
    for key, value in kwargs.items():
        print(key, value)
show(a = 1, c = 2, b = 3, d = 4)

# 4.不定长关键字参数的使用
def show(**kwargs):
    print(kwargs)

def show_msg(**kwargs):
    show(**kwargs)
show_msg(a = 1, b = 2)

# 5.不定长位置参数的高级使用
def show(*kwargs):
    print(kwargs)

def show_msg(*kwargs):
    show(*kwargs)
show_msg(1, 2)

# 1.递归函数
# 特性：传递+回归
# 阶乘
def calc_num(num):
    if num == 1:
        return 1
    else:
        return num * calc_num(num - 1)
calc_num(6)

# 获取递归次数，默认1000次
import sys
sys.getrecursionlimit() # 1000

sys.setrecursionlimit(1200)

# 2.匿名函数
# 简化代码 lambda关键字
(lambda x,y:x+y)(1,2)

# 乘法
func = (lambda x,y:x*y)
func(2, 3)

# 是否偶数
is_odd = lambda num:True if num % 2 == 0 else False
is_odd(1)

# 字典列表排序
my_list = [{'name':'ww', 'age':18},{'name':'zl', 'age':16}]
# 简写
my_list.sort(key=lambda item:item['age'])
# 全写
def get_value(item):
    return item['age']
my_list.sort(key=get_value)

# 3.偏函数
import functools
def show(a, b, c=1):
    return a + b + c
# 定义偏函数
show2 = functools.partial(show, b = 4)
show2(2) # 7 2+4+1

# 可以对内部函数使用偏函数
int2 = functools.partial(int, base = 2)
int2("11") # 3 十进制转二进制

# 4.返回函数
# 函数嵌套
# 返回函数是高级函数的一种

def show():
    def draw():
        print('--draw--')
    return draw
draw = show()
draw()

# 定义返回函数
def calc(operation):
    if operation == '+':
        return (lambda x,y:x+y)
    elif operation == '-':
        return(lambda x,y:x-y)
    else:
        pass

# 调用返回函数        
add = calc('+')
reduce = calc('-')
add(1, 2) # 3
reduce(1, 2) # -1

# 5.高阶函数
# 函数的参数是另一个函数，返回一个函数，就是高阶函数
def add(a, b):
    return a+b
def reduce(a, b):
    return a-b
def calc(a, b, add):
    return add(a, b)
    
calc(1, 2, add) # 3
calc(1, 2, reduce) # -1

# 6.闭包
# 闭包也是一个高阶函数
# 闭包应用场景：根据参数生成不同的返回函数
def hello(msg, count):
    def return_msg():
        result = msg * count
        return result
    return return_msg
    
new_func1 = hello('A', 2)
new_func2 = hello('B', 2)

new_func1()
new_func2()

# 本质上是一个函数，可以给原函数的功能进行扩展
def show():
    print('AAA')
    
def decorator(func):
    # 定义
    def inner():
        print('---', end='  ')
        # 调用show
        func()
    return inner

# 重新给show赋值
show = decorator(show)
show() # '--- AAA'

# 1.装饰器
def decorator(func):
    # 定义
    def inner():
        print('---', end='  ')
        # 调用show
        func()
    return inner

# 重新给show赋值
# 语法糖修饰(修饰show函数，给show函数增加新的功能)
@decorator
def show():
    print('AAA')

show() # '--- AAA'

# 2.装饰器修饰带有参数的函数
def decorator(func):
    def inner(a, b):
        print('计算结果如下')
        return func(a, b)
    return inner

@decorator
def sum(a, b):
    return a + b
sum(1, 5)

# 3.通用的装饰器
装饰器可以修饰任何函数

def decorator(func):
    def inner(*args, **kwargs):
        print('计算结果如下')
        return func(*args, *kwargs)
    return inner
    
@decorator
def sum1(a, b):
    return a + b
sum1(1, 5)

@decorator
def sum2(a, b, c):
    return a + b + c
sum2(1, 5, 10)

# 4.带有参数的的装饰器
def get_decorator(char):
    def decorator(func):
        def inner():
            print(char)
            print('---', end='  ')
            func()
        return inner
    return decorator

@get_decorator('AAA')
def show():
    print('OK')

show() # 'AAA --- OK'

# 1.模块的介绍
# 一个py文件就是一个模块
# 模块里面可以定义类，定义函数，定义全局对象，实现某些功能

# 2.内置模块
# python自带的模块
# 举例：datetime 、sys、os、time、html、random

# 循环两次
for i in range(2)

# 从99递减到0
for i in range(99, 0, -1)

# 查询一个对象
dir(obj)

# 间隔1秒执行
time.sleep(1)

# 生成1~60之间的随机数
random.randint(1, 60)

# 一个对象是否在另一个对象
for cha in 'Hello'

# 一个对象的大小
len('Hello')

# 3.自定义模块
# 定义一个全局变量
# first_module.py：
g_num = 10
def show():
    pass
class Teacher():
    pass

# 导入
import first_module
first_module.num
first_module.show()
first_module.Teacher()

# 查看当前主模块
__name__

if __name__ == '__main__':
    pass

# 4.模块的导入
# 1.直接导入
# import 导入模块名

import first_module

# 2.部分导入
# from 模块名 import 功能代码

from first_module import show

# 3.限制导入特定的功能
# first_module.py里面
__all__ = ['g_num']

# from 模块名 import *
import first_module
first_module.show() # 报错

# 4.给import模块名设置别名
import first_module as first
first.show()

from first_module import show as show_msg

# 5.模块导入的注意点
# 这种导入需要保证当前模块不要定义导入的功能代码
from first_module import show
def show():
    pass
show() # 覆盖了功能代码

import first_module
first_module.show()

# 自定义模块名不要和系统模块名重复

# 查看模块搜索的顺序
import sys
sys.path

# 6.包
# 文件夹里面有__init__.py的文件
# 包是管理模块的，模块是整理功能代码

# 7.包的导入
# 和模块导入类似

# 导入第一个模块
import first_package.first_module
from first_package import first_module

# 设置模块别名
import first_package.first_module  as first

first.show()

# 直接导入包，不会自动导入对应模块，
# 需去__init__.py里面指定导入的模块。
# first_package里面的__init__.py，设置
__all__ = ['first_module']
import  first_module

import first_package
first_module.show()

# 1.类的定义
# 类：属性（特征）和方法（行为）
# python3默认继承object

# 旧式类的创建方式
class Teacher():
    country = None
    def show(self):
        pass
teacher = Teacher()
teacher.show()
teacher.country

# 继承的类
Teacher.__bases__

# 2.新式类的创建方式
# 为了兼容不同的python版本，建议使用该方式创建类
class Teacher(object):
    country = None
    def show(self):
        pass

# 3.动态添加对象的属性，获取属性值
# 创建对象
teacher = Teacher()

# 动态添加的属性
teacher.name = None

# 获取属性值
teacher.country

# 调用方法
teacher.show()

# 含__xxx__的方法
# 1.__new__魔法方法
# 创建对象是自动调用两个方法，先__new__，再__init__
class Teacher(object):
    def __new__(cls):
        print('创建一个对象')
        return object.__new__(cls)
    def __init__(self):
        print('初始化')
        
# 2.__init__魔法方法
# 对象初始化时__init__会被调用

class Teacher(object):
    # init方法里面添加参数，self表示当前对象
    def __init__(self, country):
        self.country = country
    def show(self):
        pass
        
# 3.__del__魔法方法
# 对象释放时回自动调用
class Teacher(object):
    def __init__(self, country):
        self.country = country
    def __del__(self):
        print('对象销毁了', self)

teacher = Teacher('小明')
# 退出程序时
exit() # 对象销毁了 <__main__.Teacher object at 0x101ac5e80>

# 销毁对象
del teacher

# 4.__str__魔法方法
# 使用print对象时__str__会被调用

class Teacher(object):
    def __init__(self, country):
        self.country = country
    def __str__(self):
        return '出生地：%s'%(self.country)
    def show(self):
        pass
 
teacher = Teacher('成都')
print(teacher) # 出生地：成都

# 5.__slots__魔法方法
# 创建对象时不能再添加其他属性
class Person(object):
    # 对象固定属性
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
p = Person('小明', 18)
p.sex = '男'

# 1.单继承
# 类的三大特征：继承、封装、多态
# 继承好处：子类可以复用父类的属性和方法
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def show(self):
        print(self.name, self.age)

class Student(Person):
    pass

xiao_ming = Student('小明', 18)
xiao_ming.show()
xiao_wei = Student('小伟', 16)
xiao_wei.show()

# 2.多继承
# 多个父类，方法会遵循mro法则
# 类的继承顺序决定方法的调用顺序

class A(object):
    def show(self):
        print('A类')
class B(object):
    def show(self):
        print('B类')
class C(A, B):
    pass
c = C()
c.show() 

C.mro() # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

# 3.子类重写父类的方法
class Person(object):
    def run(self):
        print('跑起来')
class Student(Person):
    def __init__(self, name):
        self.name = name
    def run(self):
        print('%s跑起来了'% self.name)

stu = Student('小明')
stu.run()

# 4.使用类名调用父类的方法
class Animal(object):
    def show(self):
        print('动物')
        
class Dog(Animal):
    def show(self):
        # self指定类的继承链，获取Dog的下一个类Animal
        super(Dog, self).show()
        print(self.__class__.mro())
dog = Dog()
dog.show()

# 5.多继承super的使用
class A(object):
    def show(self):
        print('A类')
class B(object):
    def show(self):
        print('B类')
class C(A, B):
    def show(self):
        super(C, self).show()
        print('C类')
c = C()
c.show()  # A类 C类

# 6.重写方法里使用super
class A(object):
    def show(self):
        print('A类')
class B(object):
    def show(self):
        print('B类')
    def f():
        pass
class C(A, B):
    def show(self):
        # 方法重写
        super(A, self).show()
    
c = C()
c.show() # A类  super(C, self).show()
c.show() # B类  super(A, self).show()

# 7.私有属性和私有方法
class Person(object):
    def __init__(self, name, age):
        # 公有属性
        self.name = name
        # 私有属性
        self.__age = age
    
    # 公有方法
    def show(self):
        print(self.name, self.age)
        
    # 私有方法
    def __show(self):
        pass

class Student(Person):
    pass

person = Person('小明', 18)
person.__dict__ # 对象中的所有属性
Person.__dict__ # 对象中的所有方法

# 约定俗成（以__开头的就是私有的）
# 子类继承父类，不能直接使用父类的私有属性和方法

# 8.类属性和实例属性
class Person(object):
    # 类属性
    type = '黑人'
    def __init__(self):
        # 实例属性
        self.name = '人'

# 查看类属性和方法
Person.__dict__

# 对象可以访问类属性但是不可以修改类属性

# 9.对象方法、类方法、静态方法
# cls当前类 self当前对象

class Person(object):
    # 对象方法
    def show(self):
        pass
    # 类方法
    @classmethod
    def show_self(cls):
        pass
    # 静态方法
    @staticmethod
    def showmsg():
        pass

# python本质上没有多态（假象）（约定俗成）
# 多态：关注的是同一个方法，但会出现不同形式

class Text(object):
    def show(self):
        print('显示文字')
        
class Image(object):
    def show(self):
        print('显示图片')

class Video(object):
    def show(self):
        print('显示视频')

# 显示数据的方法
def show_data(object):
    object.show()

image = Image()
text = Text()
video = Video()

show_data(image)
show_data(text)
show_data(video)

# 1.异常的介绍
# python解释器去执行代码时出错
name = ''
name + 10


# 2.异常捕获
try:
    name = ''
    name + 10
except Exception as e:
    print(e)
    
try:
    pass
except Exception as e:
    pass
else:
    pass
finally:
    pass

# 3.自定义异常类
class NumberException(Exception):
    def __init__(self):
        pass
    def __str__(self):
        return '不是数字，所以异常'

# 抛异常
raise NumberException()

# 抛系统异常
raise NameError('系统异常') 

# 常用设计模式
# 不管创建多少次对象，都是一个对象
class Teacher(object):
    __instance = None
    def __new__(cls):
        if cls.__instance == None:
            print('创建一个对象')
            cls.__instance = object.__new__(cls)
        return cls.__instance
    def __init__(self):
        print('初始化')

# 创建一个对象
teacher = Teacher()

# 再创建一个对象
teacher2 = Teacher()

# 内存地址都一样

# 1.可迭代对象
# 使用for循环遍历取值的对象：列表，元祖，字典，集合，字符串，range

# 判断是否是可迭代对象
from collections import Iterable
isinstance([1, 2], Iterable)

isinstance(value, type)

# 可迭代对象有一个__iter__方法

# 2.迭代器
# 用的不是很多
# 作用：根据数据的位置获取下一个位置的值
占用内存少

from collections import Iterable

class MyIterable(object):
    def __init__(self):
        self.mylist = [4, 5, 9]
        self.current_index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current_index < len(self.mylist):
            res = self.mylist[self.current_index]
            self.current_index += 1
            return res
        else:
            raise StopIteration

# 创建迭代器
my_iterable = MyIterable()
isinstance(my_iterable, Iterable)
next(my_iterable)

# 3.生成器
# 生成器：特殊的迭代器，可以通过next函数和for取值
# 占用内存相当少

# 值只能向后取值，不能向前取值

# 使用生成器的表达式
next( [x for x in range(4)] ) # 'list' object is not an iterator
next( (x for x in range(4)) )

def show():
    for x in range(4):
        # 代码遇到yield会暂停，然后把结果返回过去
        # 下次启动生成器会暂停该位置
        # yield特点：可以返回多次值，return只能返回一次
        yield x
g = show()
next(g)