import pymsql

try:
    conn = pymsql.connect(host="localhost",db='test',user="ceshi",pwsswd="ceshi",port='3306',charset='utf-8')
    # 建立游标
    cur = conn.cursor()
    cur.excute("select * from t_user")
    # 获取所有数据，同时还有fetchone(只获取一条)、fetchmany(num)(获取num条数据)
    # 获取数据返回多个元组
    data = cur.fetchall()
    for d in data:
        print('姓名：'+d[0],'年龄：'+str(d[1]),'联系方式：'+d[2])
    # 关闭游标
    cur.close()
    # 释放数据库连接
    conn.close()
except:
    print("连接数据库失败")

import pymongo

url = 'mongodb://localhost:27017'
db_name = 'test'
mc = pymongo.MongoClient(url)
mydb = mc[db_name]
# 连接collection
col = mydb['temp001']

'''
创建mongo索引
如果不指定名称，系统会使用默认名称'index'
创建唯一索引需要加上unique=True
1:表示正序排序；-1：表示倒叙排序
'''
col.create_index('{"name":1,"mobile":1}',name='test_index')

from datetime import datetime
def get_time(func):
    def wrapper(*args,**kwargs):
        now_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        print('现在的时间是：'+ now_time)
        return func(*args,**kwargs)
    return wrapper

@get_time
def printHello():
    print('hello world!')

printHello()

'''
__doc__: 类（实例）.__doc__ 类或实例的描述信息(注释)
__module__: 类（实例）.__module__ 表示对象属于哪个模块
__dict__：查看类或实例的所有属性，结果为字典
__class__: 表示当前操作对象的类
__str__：打印对象时显示
__call__：类(实例)加小括号调用时执行

'''

# __call__使用案例
class Reader():

    def __init__(self,name,nationality):

        self.name = name

        self.nationality = nationality
    
    # 可以传参数

    def __call__(self,age):

        print('Reader: %s    Nationality: %s   Age: %s' % (self.name, self.nationality,age))


    
    
r = Reader('张三','ada')
r(20)

# 使用instance
from types import MethodType,FunctionType

def func1():
    pass

class TestClass():
    def func2(self):
        pass
    
tc = TestClass()

print(isinstance(func1,FunctionType))
print(isinstance(tc.func2,MethodType))

'''
普通方法: 第一个参数self，表示对象本身，只能访问实例属性，不能访问类属性，实例名.方法名()调用
类方法：第一个参数cls，表示类本身，只能访问类属性，不能访问实例属性，不需要实例化，直接【类名.方法名()】，可通过类对象或类对象实例访问
静态方法：名义上归类管，实际上与类无关，只是类下面一个单独的函数，可以不传参数，不需要实例化，直接【类名.方法名()】，可通过类对象或类对象实例访问
'''


class Fruits():
    p_name = 'xiaoguo'
    def __init__(self,f_name):
        self.f_name = f_name
    
    # 普通方法
    def say(self):
        print('我是普通方法，至少要有一个参数self')
        print("我爱吃%s" % self.f_name)
    
    # 类方法
    @classmethod
    def make(cls,f_name):
        print('我是类方法，至少要有一个参数cls')
        print('%s爱吃%s' %(cls.p_name,f_name))
        
    
    # 静态方法
    @staticmethod
    def other(f_name):
        print('我是静态方法，可以不传参数！')
        print('我也爱吃%s' %f_name)

f1 = Fruits('芒果')
f1.say()
print("="*30)
f2 = Fruits('苹果')
f2.make('香蕉')
Fruits.make('香蕉')
print("="*30)
f3 = Fruits('车厘子')
f3.other('车厘子')
Fruits.other('车厘子')

'''
接口的实现
'''


# 方法一：通过抽象类和抽象方法,抽象类只能被继承，不能被实例化
# 抽象类可以有普通函数和抽象函数，抽象函数需要被标识，且子类必须全部重写，否则会报错；普通函数在子类中也可以正常调用
from abc import ABCMeta,abstractmethod

class Interface(metaclass=ABCMeta):
    
    @abstractmethod
    def a(self):
        pass
    @abstractmethod
    def b(self):
        pass
    
    def c(self):
        pass
    
    
class Temp(Interface):
    def __init__(self):
        print('我是实现类')
    
    def a(self):
        print('我是方法A')
    
    def b(self):
        pass

t = Temp()
t.a()
t.b()
# c()是抽象类中的普通方法，子类也可以正常使用
t.c()
    
# 方法二：普通类(推荐)
class MyClass():
    def func_a(self):
        pass
    def func_b(self):
        pass

class Test(MyClass):
    
    def func_a(self):
        print("我是a")
    
    def func_b(self):
        print("我是b")

tt = Test()
tt.func_a()
tt.func_b()

class Test():
    def __init__(self,name):
        self.name = name
    
    def say(self):
        print("%s say:Heelo World" %self.name)
    
t = Test('zhangsan')
t.say()


# hasattr：判断对象中是否有属性或者方法，返回布尔值
print(hasattr(t,"name")) # True
print(hasattr(t,"say")) # True
print(hasattr(t,'abc')) # False


# getattr: 获取对象中变量或方法的内存地址
n = getattr(t,'name')
print(n) # 打印zhangsan
f = getattr(t,'say')
f()
abc = getattr(t,'abc','not found') # 第三个参数表示没有找到指定的属性或方法时，显示的内容
print(abc)


# setattr：给对象添加属性或方法
def abc(self):
    print("我是abc")
setattr(t,'abc',abc) # 添加方法
t.abc(t) # 额外添加的方法要手动传入对象

setattr(t,'age',18) # 添加属性
print(t.age)


# delattr：删除对象中的属性，注意！不能删除对象方法！
delattr(t,"age")
print(t.age) # 会报没有该属性的错

'''
定义：在运行时动态修改模块、类或函数，通常是添加功能或者修正缺陷
'''
class A():
    def func(self):
        print('hello')

def monkey(self):
    print("hello world")
A.func = monkey
a = A()
a.func()

# dir为Python内建函数
dir = 1 # Global
def test():
    dir = 2 # Enclosing
    def wrapper():
        dir = 3 #Local
        return dir
    return wrapper
print(test()()) # 输出3

res = 'true' if 2 < 1 else 'false'
print(res) # 打印'false'

res1 = lambda x: x if x > 0 else '404'
print(res1(-1)) # 打印404

l = ['姓名','班级','带班老师']
e = [i for i in enumerate(l)]
print(e)  # [(0, '姓名'), (1, '班级'), (2, '带班老师')]

from pathlib import Path

p = Path() # 输出'.'
p1 = Path('a','b','c','d') # 输出 a\b\c\d
print(p1.parts) # 返回路径中每一个部分 ('a', 'b', 'c', 'd')

p2 = p1 / 'e' # 操作符'/' 拼接
print(p2) # 输出a\b\c\d\e



data_folder = Path("source_data/text_files/") # 输出source_data\text_files
file_to_open = data_folder / "raw_data.txt"
with open(file_to_open,'rw+',encoding='utf-8') as f:
    print(f.read())

import sys
sys.setrecursionlimit(10000) # 设置最大递归深度为10000

l = [1,2,3]
print(isinstance(l,list))  # True