01-uuid模块
# uuid用来生成一个全局唯一的id
import uuid
print(uuid.uuid1()) # 32个长度 每一个字符有16个选择 16**32
# print(uuid.uuid2())
# uuid3和uuid5是使用传入的字符串根据指定的算法算出来的，是固定的
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'zhangsan')) # 生成固定的uuid
print(uuid.uuid5(uuid.NAMESPACE_DNS, 'zhangsan')) # 生成固定的uuid
print(uuid.uuid4()) # 使用的最多
02-使用第三方模块
# Python在查找模块的时候，在哪些路径下查找?
from flask import Flask
import sys
print(sys.path)
03-使用自定义模块
# 一个模块本质上就是一个py文件
# 自己定义一个模块，其实就是自己写一个py文件
# import 04-我的模块 如果一个py文件想要当做一个模块被导入，文件名一定要遵守命名规范
# 由数字、字母下划线组成，不能以数字开头
# 导入了一个模块，就能使用这个模块里变量和函数
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()
import demo
print(demo.n)
from hello import *
print(x)
print(y)
# print(_age)
import hello
# print(hello._age)
# hello._bar()
# print(hello.x)
# import datetime
# datetime._is_leap(2000)
04-包的使用
# 可以将多个具有相似或者有关联的多个模块放到一个文件夹里，便于统一管理
# 这个文件夹，我们就可以称之为包
# 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)
05-面向过程
def add_user():
pass
def del_user():
pass
def modify_user():
pass
def query_user():
pass
def show_all():
pass
def start():
while True:
print("""---------------------------
名片管理系统 V1.0
1:添加名片
2:删除名片
3:修改名片
4:查询名片
5:显示所有名片
6:退出系统
---------------------------""")
operator = input('请输入要进行的操作(数字)')
if operator == '1':
add_user()
elif operator == '2':
del_user()
elif operator == '3':
modify_user()
elif operator == '4':
query_user()
elif operator == '5':
show_all()
elif operator == '6':
pass
else:
print('输入有误,请重新输入......')
if __name__ == '__main__':
start()
06-面向对象的基本语法
# 小明今年 18 岁，身高 1.75，每天早上跑完步，会去 吃 东西
# 小美今年 17 岁，身高 1.65，小美不跑步，小美喜欢 吃 东西
# 定义类:类名怎么定义? 使用 class 来定义一个类
# class 类名:类名一般需要遵守大驼峰命名法，每一个单词的首字母都大写
# 1. class <类名>:
# 2. class <类名>(object):
class Student(object): # 关注这个类有哪些特征和行为
# 在 __init__ 方法里，以参数的形式定义特征，我们称之为属性
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
# 行为定义为一个个函数
def run(self):
print('正在跑步')
def eat(self):
print('正在吃东西')
# 使用 Student 类创建了两个实例对象 s1 s2
# s1和s2都会有name,age,height属性,同时都有run和eat方法
s1 = Student('小明', 18, 1.75) # Student() ==> 会自动调用 __init__ 方法
s2 = Student('小美丽', 17, 1.65)
# 根据业务逻辑，让不同的对象执行不同的行为
s1.run()
s1.eat()
s2.eat()
07-self语句的使用
class Student(object):
# 这个属性直接定义在类里，是一个元组，用来规定对象可以存在的属性
__slots__ = ('name', 'age', 'city')
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 指向创建好的内存空间，填充数据
# 3. 变量 s1 也指向创建好的内存空间
s = Student('张三', 18)
print(s.name)
s.say_hello()
# 没有属性，会报错
# print(s.height)
# 直接使用等号给一个属性赋值
# 如果这个属性以前不存在，会给对象添加一个新的属性
# 动态属性
s.city = '上海' # 给对象添加了一个city属性
print(s.city)
# 如果这个属性以前存在，会修改这个属性对应的值
s.name = 'jack'
print(s.name) # jack
08-魔术方法
# 魔法方法，也叫魔术方法，是内里的特殊的一些方法
# 特点:
# 1.不需要手动调用，会在合适的时机自动调用
# 2. 这些方法，都是使用 __ 开始，使用 __ 结束
# 3. 方法名都是系统规定好的，在合适的时机自己调用
# import datetime
#
# x = datetime.datetime(2020, 2, 24, 16, 17, 45, 200)
# print(x) # __str__ 方法
# print(repr(x)) # __repr__ 方法
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, 4, 5),kwargs = {'m':'good', 'n':'hehehe', 'p':'heiheihei'}
print('args={},kwargs={}'.format(args, kwargs))
p = Person('zhangsan', 18)
# 如果不做任何的修改，直接打印一个对象，是文件的 __name__.类型 内存地址
# print(p) # <__main__.Person object at 0x00000217467AEA08>
# 当打印一个对象的时候，会调用这个对象的 __str__ 或者 __repr__ 方法
# 如果两个方法都写了，选择 __str__
print(p)
# print(repr(p)) # 调用内置函数 repr 会触发对象的 __repr__ 方法
# print(p.__repr__()) # 魔法方法，一般不手动的调用
p(1, 2, 4, 5, m='good', n='hehehe', p='heiheihei') # 对象名() ==> 调用这个对象的 p.__call__() 方法
09-__eq__方法介绍
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
# return False
return self.name == other.name and self.age == other.age
p1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)
p3 = Person('zhangsan', 19)
# p1 和 p2 是同一个对象吗?
# 怎样比较两个对象是否是同一个对象?比较的是内存地址
print('0x%X' % id(p1)) # 0x20CE2A8EE88
print('0x%X' % id(p2)) # 0x20CE2A8EF08
# is 身份运算符 可以用来判断两个对象是否是同一个对象
print('p1 is p2', p1 is p2) # False
# __eq__ 如果不重写，默认比较依然是内存地址
print('p1 == p2', p1 == p2) # p1 == p2本质是调用 p1.__eq__(p2),获取这个方法的返回结果
print(p1 == p3)
# is 比较两个对象的内存地址
# == 会调用对象的 __eq__ 方法，获取这个方法的比较结果
# nums1 = [1, 2, 3]
# nums2 = [1, 2, 3]
# print(nums1 is nums2) # False
# print(nums1 == nums2) # True
10-一些demo
__all__ = ['m', 'test']
m = 'yes'
n = 100
def test():
print('我是demo模块里的test方法')
def foo():
print('我是demo模块里的foo方法')
def division(a, b):
return a / b
# __name__:当直接运行这个py文件的时候，值是__main__
# 如果这个py文件作为一个模块导入的时候，值是文件名
if __name__ == '__main__':
print('demo里的name是:', __name__)
print('测试一下division函数，结果是:', division(4, 2))
# 没有设置 __all__ 会读取除了以_开始的所有变量和函数
x = 'hello'
y = 1000
# 以一个下划线开始变量，建议只在本模块里使用，别的模块不要导入
_age = 19 # 使用from 模块名 import * 这种方式无法导入
_age += 1
def _bar():
print('我是hello里的bar函数，我只能hello文件内部使用')
del (_age, _bar, x)
a = 'hello'
def test():
print('我是my_module模块里的test函数')
def add(x, y):
return x + y
