uuid

# uuid用来生成一个全局唯一的id模块
import uuid


# uuid3和uuid5是使用传入的字符串根据指定的算法算出来的，是固定的
print(uuid.uuid1())  # 32个长度，每个16个选择 16**32个选择
# print(uuid.uuid2())
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'zhangsan'))  # 生成固定的uuid
print(uuid.uuid5(uuid.NAMESPACE_DNS, 'zhangsan'))

print(uuid.uuid4())  # 使用的最多

使用第三方模块

# python 在查找模块的时候，在哪些路径下查找？

from flask import Flask
import sys


print(sys.path)

使用自定义模块

# 一个模块本质上就是一个py文件
# 自己定义一个模块，其实就是自己写一个py文件
# import 04-我的模块 如果一个文件想要当做一个模块被导入，文件名一定要遵守命名规范
# 由数字字母下划线组成，不能由数字开头
# 导入一个模块，就能使用这个模块里面的变量和方法
import my_module
# 使用 from <module_name> import *导入这个模块里"所有"的变量和函数
# 本质上是读取模块里的  __all__  属性，看这个属性里定义了哪些变量和函数
# 如果模块里没用定义 __all__ 才会导入所有不以 _ 开头的变量和函数

from demo import *


print(my_module.a)
my_module.test()
print(my_module.add(1, 2))

# 使用from demo import *
print(m)
test()

from hello import *

print(x)
print(y)
# print(_age)

# import hello
# print(hello._age)

# hello._bar()

包的使用

# 可以将多个具有相似或者有关联的多个模块放到一个文件夹里，便于统一管理
# 这个文件夹，我们就可以称之为包
# python 包里，会有一个__init__.py文件

from chat import recv_msg
from chat.send_msg import x
import json
import flask

import chat

print(recv_msg.y)
print(x)
print(chat.recv_msg.y)

面向过程

def add_info():
    pass


def del_info():
    pass


def modify_info():
    pass


def query_info():
    pass


def show_all():
    pass


def start():
    while True:
        print("""--------------------
        名片管理系统 v1.0
    1.添加名片
    2.删除名片
    3.修改名片
    4.查询名片
    5.显示所有名片
    6.退出系统
    --------------------""")
        operator = input('请要进行的操作(数字)')

        if operator == '1':
            add_info()
        elif operator == '2':
            del_info()
        elif operator == '3':
            modify_info()
        elif operator == '4':
            query_info()
        elif operator == '5':
            show_all()
        elif operator == '6':
            pass
        else:
            print('输入有误，请重新输入......')

if __name__ == '__main__':
    start()

面向对象的介绍

# 创建类：类名怎么定义？ 使用 class 来定义一个类
# class 类名:一般遵守大驼峰命名法，每一个单词的首字母都大写
# 1.class <类名>:
# 2.class<类名>(object):
class Student(object):       #关注这个类有哪些特征和行为
    # 在__init__方法里，以参数的形式定义特征，我们称之为属性
    def __init__(self, name, age, height):   # 在__init__方法里，以参数的形式定义属性
        self.name = name
        self.age = age
        self.height = height

    def __int__(self):
        pass

    # 行为定义为一个个函数
    def run(self):
        print('正在跑步')

    def eat(self):
        print('正在吃饭')

# Student() ==> 会自动调用__init__方法
# 使用Student类创建了两个实例对象 s1 s2
# s1和s2都会有name, age, height属性，同时都有run, eat方法
s1 = Student('小明', 18, 1.75)
s1.run()
s1.eat()
s2 = Student('小美', 17, 1.65)
s2.eat()

self语句的使用

class Student(object):
    # 这个属性直接定义到类里，是一个元组，用来规定对象可以存在的属性
    __slots__ = 'name'
    
    def __init__(self, x, y):
        self.name = x
        self.age = y

    def say_hello(self):
        print('大家好，我是', self.name)


# Student('张三', 18),具体做了些什么？
# 1.调用__new__方法,用来申请内存空间
# 2.调用__init__让self指向申请好的那段内存空间
# 让s1也指向创建好的这段内存空间


s1 = Student('张三', 18)
print('0x%X' % id(s1))

s2 = Student('jack', 21)
s2.say_hello()

# 直接使用等号给一个属性赋值
# 如果这个属性以前不存在，会给对象添加一个新的属性
# 如果这个属性以前存在，会修改这个属性对应的值
s1.city = '上海'
print(s1.city)
s1.name = 'jiaxi'
print(s1.name)

魔法方法

# 魔法方法，也叫魔术方法，是内里的特殊的一些方法
# 特点：
# 1.不需要手动调用，会在合适的时机自动调用
# 2.这些方法，都是__开始，使用__结束
# 3.方法名都是系统规定好的，在合适的时机自己调用
import time
import datetime

x = datetime.datetime(2020, 2, 24, 16, 17, 45, 200)
print(x)  #__str__方法  2020-02-24 16:17:45.000200
print(repr(x))  #__repr__方法  datetime.datetime(2020, 2, 24, 16, 17, 45, 200)

class Person(object):
    # 在创建对象时，会自动调用这个方法
    def __init__(self, name, age):
        print('__init__方法被调用了')
        self.name = name
        self.age = age

    def __del__(self):
        # 当对象被销毁时，会自动调用这个方法
        print('__del__方法被调用了')
    def __repr__(self):
        return 'hello'

    def __str__(self):
        return '姓名：{}， 年龄：{}'.format(self.name, self.age)

    def __call__(self, *args, **kwargs):
        # print('__call__方法被调用了')
        # args  是一个元组，保存(1,2)
        # kwargs  是一个字典{fn:lambda x, y: x+y}
        print('args={}, kwargs={}'.format(args, kwargs))
        test = kwargs['fn']
        return test(args[0], args[1])



p = Person('zhangsan', 18)

# del p
# time.sleep(4)
# print(p)  #如果不做任何修改，直接打印一个对象，是文件的__name__.类型以及内存地址
# <__main__.Person object at 0x000001E99C0B92E8>

# 当打印一个对象的时候，会调用这个对象的__str__或者__repr__方法
# 如果两个方法都写了，选择__str__
print(p)

# print(repr({'name': 'zhangsan', 'age': 18}))
print(repr(p))  # 调用内置函数repr会触发对象的__repr__方法
print(p.__repr__())  # 魔法方法，一般不手动调

n = p(1, 2, fn=lambda x, y: x + y)  # 对象名（） ==> 调用这个对象的p.__call__(1, 2)方法
print(n)

运算符相关魔法方法

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        print('__eq__方法被调用了，other=', other)
        # if self.name == other.name and self.age == other.age:
        #     return True
        # else:
        #     return False
        return self.name == other.name and self.age == other.age

# 1.调用__new__方法申请内存空间
p1 = Person('zhangsan', 18)


# 调用__new__方法申请内存空间
p2 = Person('zhangsan', 18)
p3 = Person('zhangsan', 23)

# p1和p2是同一个对象吗？
# 怎样比较两个对象是否是同一个对象？比较的是内存地址。
print('0x%X' % id(p1))  #0x25F0B3D9940
print('0x%X' % id(p2))  #0x25F0B3D9BE0

# is 身份运算符 可以用来判断两个对象是否是同一个对象
print(p1 is p2)

# __eq__如果不重写，默认比较依然是内存地址
print(p1 == p2)  #p1.__eq__(p2)
print(p1 == p3)


# is比较两个对象的内存弟子，==是通过__eq__结果确定
nums1 = [1, 2, 3]
nums2 = [1, 2, 3]
print(nums1 is nums2)
print(nums1 == nums2)