# coding:utf-8

def word_amount(sentence):
    """计算句子的单词数量
    
    计算句子中的单词数量，并返回结果字典
    :param sentence: 句子对象
    :return: 计算结果字典
    """

# 使用split()方法切割句子

​    split_list = sentence.split()
​    dict_result = {}

# 遍历列表，判断每个值是否在新字典的键中，如果存在则键值加一，不存在设为1

​    for word_name in split_list:
​        if word_name not in dict_result.keys():
​            dict_result[word_name] = 1
​        else:
​            dict_result[word_name] += 1

​    return dict_result

if __name__ == '__main__':
    sentence = "I can because i think i can"
    dict_result = word_amount(sentence)
    print(dict_result)评论区 @Felix 有更优的解法，非常感谢：sentence = "I can because i think i can"

# count()用来统计字符串中word出现的次数，count(sub, start=None, end=None)有三个参数，依次是待统计字符，字符索引开头，索引结尾

result = {word: sentence.split().count(word) for word in set(sentence.split())}

print(result)评论区 Carno 



from collections import Counter
sentence = "I can because i think i can"
# Counter是一个简单的计数器，可以数组中统计字符出现的个数：
counts = Counter(sentence.split())
print(counts)  # Counter({'can': 2, 'i': 2, 'I': 1, 'because': 1, 'think': 1})

# Python方法
import os

os.remove("demo.txt")

# linux方法
rm demo.txt

# coding:utf-8


def judge_value(num_value):
    """自定义异常函数

    自定义异常函数，用于抛出大于一定值的异常
    :param num_value:用于判断的值
    :return:异常信息
    """
    if num_value > 10:
        # raise用于抛出自定义异常，格式为：raise 异常类型(异常注明)
        # 一旦触发则不再执行raise之后的代码
        raise ValueError("数量不能大于10")
    else:
        return "200"


if __name__ == '__main__':
    judge_value(10)

# coding:utf-8

def read_filedata(file_name):
    """读取文件数据
    
     读取指定文件中的所有数据，返回数据或者异常信息
    :param file_name: 文件路径
    :return: 文件数据或者异常信息
    """
    file_obj = ""
    try:
        # 需要检测的异常代码片段
        file_obj = open(file_name, "r")
        result_data = file_obj.read()
    except IOError, e:
        # 发生“IOError”异常进行处理的代码片段
        file_obj = "文件不存在："+str(e)
    else:
        # 没有引发“IOError”异常执行的代码片段
        # 返回读取到的数据
        return result_data
    finally:
        # 不管有没有引发错误都会执行的代码片段
        # isinstance()用于判断一个数据类型
        if isinstance(file_obj, str):
            return file_obj
        elif isinstance(file_obj, file):
            file_obj.close()
        else:
            return "未知错误，请检查您的代码..."


if __name__ == '__main__':
    result = read_filedata("abc.txt")
    print(result)

print("")    # py3

print ""     # py2
print("")

# coding:utf-8


def create_iterator(list_param):
    """创建迭代器

    使用生成器推导式创建一个迭代器，并返回迭代器
    :param list_parm: 迭代对象
    :return: 迭代器
    """
    # 将列表推导式的“[]”改为“()”即为生成器推导式，众所周知，生成器返回一个迭代器对象
    return (value for value in list_param)


if __name__ == '__main__':
    # 遍历迭代器
    for i in create_iterator([1, 2, 3]):
        print(i)
    # 使用__doc__输出函数中的文档字符串属性
    print(create_iterator.__doc__)
    # 使用__dir__输出函数中的所有属性和方法
    print(create_iterator.__dir__())

# coding:utf-8


def list_to_str(param_list: list, connect_str: str=" ") -> str:
    """列表转字符串

    使用join方法将列表转为字符串并返回
    :param param_list: 列表
    :param connect_str: 需要插入的字符，默认为一个空格
    :return:转换成功的字符串
    """
    demo_tuple: tuple = (1, 2)
    demo_dict: dict = {"1": 1}
    return connect_str.join(param_list)


if __name__ == '__main__':
    result = list_to_str(["Hello", "world"])
    print(result)

pip install mypy

"""
双引号多行注释
"""

'''
单引号多行注释
'''

# 数值型--int、float、complex
# 布尔型--bool
# 字符串--str
# 列表--list
# 元组--tuple
# 字典--dict

demo_list = [1, 2, 3]
print(id(demo_list))        # 4874760
demo_list.append(4)
print(id(demo_list))        # 4874760

demo_tuple = (1, 2, 3)
print(id(demo_tuple))       # 65021344
# demo_tuple.append(4)      # 不可变类型不能对值进行修改
demo_tuple = (1, 2, 3, 4)   # 重新对变量赋值，变量和数据类型需要区分，变量!=数据，变量只是数据的载体
print(id(demo_tuple))       # 42116344

#!/usr/bin/python3
# coding:utf-8


def first_capital(change_sentence: str)->str:
    """句子所有单词首字母大写

    将句子的首字母大写并返回
    :param change_sentence: 需要转换的句子
    :return: 返回转换后的字符串
    """
    # 将句子使用split切割为list数组
    split_list = change_sentence.split()
    # 遍历列表长度值
    for i in range(len(split_list)):
        # 使用capitalize()函数将每个单词首字母转为大写
        split_list[i] = split_list[i].capitalize()
        # 也可以使用 upper() 方法，upper()可以把所有的小写字母转为大写，lower()是转小写
        # split_list[i] = split_list[i][0].upper() + split_list[i][1:]
    # 使用join将列表转为字符串
    split_list = " ".join(split_list)
    return split_list


if __name__ == '__main__':
    change_sentence = "hello world"
    print(first_capital("hello world"))
    # 有需要的同学可以使用匿名函数、列表推导式和map方法一行写出以上代码
    print(" ".join(list(map(lambda word: word.capitalize(), change_sentence.split()))))

#!/usr/bin/python3

demo_str = "123456"
print(demo_str.isdigit())                       # 输出True
demo_str = "this is string example....wow!!!"
print(demo_str.isdigit())                       # 输出False

#!/usr/bin/python3
from functools import reduce

# 第一种方法，使用字符串切片
demo_str = "ilovechina"
print(demo_str[::-1])

# 第二种方法，使用列表的reverse方法
list_str = list(demo_str)
list_str.reverse()
print("".join(list_str))

# 第三种方法：reduce累加方法
# 具体步骤是将前两个字母初始化添加到lambda函数中，得到的结果在与下一个字母做累加直到结束
# 第一次：l + i = li
# 第二次：o + li = oli
# 第三次：v + oli = voli
# ...
# 第九次：a + nihcevoli = anihcevoli
print(reduce(lambda x, y: y+x, demo_str))


# 使用栈，先进后出
def stack_demo(demo_str):
    # 模拟全部入栈
    list_stack = list(demo_str)
    result_str = ""
    while len(list_stack) > 0:
        # 模拟出栈
        result_str += list_stack.pop()
    return result_str

print(stack_demo(demo_str))

# 遍历循环：略

#!/usr/bin/python3

demo_str = " adabdw "

# 去除两端空格使用：strip()
print(demo_str.strip())

# 去除右端空格使用：rstrip()
print(demo_str.rstrip())

# 去除左端空格使用：lstrip()
print(demo_str.lstrip())

# replace替换
print(demo_str.replace(" ", ""))

# 正则
import re
print(re.sub(" ", "", demo_str))

#!/usr/bin/python3

demo_str = "123456"
print(demo_str[-2:])

#!/usr/bin/python3
import chardet

demo_str = "demo string".encode("gbk")
demo_str = demo_str.decode('gbk').encode('utf-8')
print(demo_str)
# chardet.detect()可以检测编码格式
print(chardet.detect(demo_str))

#!/usr/bin/python3
import re

demo_str = "info：xiaoZhang 33 shandong"
# compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象
# 由题可知需要去除出字母数字之外的字符，故使用"\W"做匹配
pattern = re.compile(r'\W')
# re.split()方法按照能够匹配的子串将字符串分割后返回列表
print(pattern.split(demo_str))

#!/usr/bin/python3
import re

a = "你好 中国 "
print(a.rstrip())

#!/usr/bin/python3
import re

demo_str = "HELLO WORLD"
# 转小写使用lower() 转大写使用upper()
print(demo_str.lower())

str1 = 'python'
str2 = "python" 

str3 = 'We all know that \'A\' and \'B\' are two capital letters.'

str4 = "We all know that 'A' and 'B' are two capital letters."

str5 = 'The teacher said: "Practice makes perfect" is a very famous proverb.'

str1 = """List of name:
Hello
World
 """
print(str1)
# 使用三引号定于多行字符类型比使用双引号要友好许多

#!/usr/bin/python3
import pandas

# 第一种方法，使用set集合，先转为集合再转回列表
AList = [1, 2, 3, 1, 2]
result_list = list(set(AList))
print(result_list)

# 第二种，使用dict.fromkeys，该函数有两个参数，第一个是字典的键，第二个是对应值(默认为空str)，用于创建一个字典类型
AList = [1, 2, 3, 1, 2]
result_list = list(dict.fromkeys(AList))
print(result_list)

# 第三种，遍历列表进行判断
AList = [1, 2, 3, 1, 2]
result_list = []
for i in AList:
    if i not in result_list:
        result_list.append(i)
    else:
        continue
print(result_list)

# 第四种，使用pandas.unique()方法，
AList = [1, 2, 3, 1, 2]
result_list = pandas.unique(AList).tolist()
print(result_list)

#!/usr/bin/python3


demo_str = "1,2,3"
result_list = demo_str.split(",")
print(result_list)

#!/usr/bin/python3


list_A = [1, 2, 3, 4, 5]
list_B = [4, 5, 6, 7, 8]

# 找相同
same_list = [i for i in list_A if i in list_B]
print(same_list)

# 找不同
different_list = [i for i in list_A if i not in list_B]
print(different_list)

#!/usr/bin/python3

question_list = [[1, 2], [3, 4], [5, 6]]
# 使用列表推导式嵌套的时候，注意前后的调用关系，前推导式的值需要在后面书写才能生效
# 需要输出的值放到推导式的最前面，生成输出值的推导式在最后面
print([list_int for inside_list in question_list for list_int in inside_list])

#!/usr/bin/python3

list_a = [1, 5, 7, 9]
list_b = [2, 2, 6, 8]

# 第一种方法：使用运算符“+”
combine_list = list_a + list_b
print(combine_list)

# 第二种方法：使用运算符extend()方法
list_a.extend(list_b)
print(list_a)

# 第三种方法：使用append
list_a = [1, 5, 7, 9]
for i in list_b:
    list_a.append(i)
print(list_a)

#!/usr/bin/python3
import random

demo_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
# 使用random.shuffle打乱一个list数组
random.shuffle(demo_list)
print(demo_list)

#!/usr/bin/python3

demo_dic = {"a": 1, "b": 2, "c": 3}
# pop方法删除指定的键值对，并返回删除的值
pop_str = demo_dic.pop("a")
print(demo_dic)
print(pop_str)

# del不会返回相应的值，只是将其删除
del demo_dic["b"]
print(demo_dic)

#!/usr/bin/python3

d1 = [
    {'name': 'alice', 'age': 38},
    {'name': 'bob', 'age': 18},
    {'name': 'ctrl', 'age': 28}
]
# 强大的sort方法，满足大多数排序算法，列表排序优先考虑sort！
"""
list.sort( key=None, reverse=False)
key -- 主要是用来进行比较的元素，只有一个参数，
具体的函数的参数就是取自于可迭代对象中，指定可
迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
"""
d1.sort(key=lambda x: x['age'])
print(d1)

#!/usr/bin/python3

a = {"A": 1, "B": 2}
b = {"C": 3, "D": 4}
# 使用update方法
a.update(b)
print(a)

# 补充clear方法，清空字典中的键值对
a.clear()
print(a)

#!/usr/bin/python3

# 生成一个以姓名为键的字典，值为"student"
student_dic = {name: "student" for name in ["Robin", "Bob", "Jams"]}
print(student_dic)   # {'Robin': 'student', 'Bob': 'student', 'Jams': 'student'}  

# 将一个字典中的姓名首字母转为大写
name_dic = {1: "robin", 2: "bob", 3: "jams"}
# items() 以列表返回可遍历的(键, 值) 元组数组。
# dict_items([(1, 'robin'), (2, 'bob'), (3, 'jams')])
result_dic = {k: v.capitalize() for k, v in name_dic.items()}
print(result_dic)    # {1: 'Robin', 2: 'Bob', 3: 'Jams'}

#!/usr/bin/python3

tuple_key = ("a", "b")
tuple_val = (1, 2)
result_dic = dict(zip(tuple_key,tuple_val))
print(result_dic)

#!/usr/bin/python3

demo_dic = {"A": 1, "B": 2}
# 使用字典推导式交换位置
result_dic = {v: k for k, v in demo_dic.items()}
print(result_dic)

#!/usr/bin/python3

demo_list = [1,2,3]
# 列表转元祖使用tuple()
result_tup = tuple(demo_list)
print(type(result_tup))             # <class 'tuple'>
print(result_tup)                   # (1, 2, 3)
# 元祖转列表使用list()
result_list = list(result_tup)  
print(type(result_list))            # <class 'list'>
print(result_list)                  # [1, 2, 3]

#!/usr/bin/python3
import itertools


def fbnq(num):
    """斐波那契生成器

    :param num: 生产数量
    :return: 斐波那契迭代器
    """
    a, b = 1, 1
    for _ in range(num):
        a, b = b, a+b
        yield a


if __name__ == '__main__':
    gener = fbnq(20)
    print(gener)
    # 不能直接对生成器和迭代器进行切片
    # print(fbnq(20)[2])
    # 可以使用itertools.islice()对迭代器进行切片
    # itertools是一个很强大的内置模块，有需要可以了解一下
    gener_clip = itertools.islice(gener, 10, 20)
    for i in gener_clip:
        print(i)

(i for i in range(3))    # 方括号改为尖括号即可

#!/usr/bin/python3

a.encode()
b.encode()

a = (1, 2, 3, [4, 5, 6, 7], 8)
a[2] = 2             # TypeError: 'tuple' object does not support item assignment

a = (1, 2, 3, [4, 5, 6, 7], 8)
a[3][0] = 2               # (1, 2, 3, [2, 5, 6, 7], 8)

a, b = b, a

#!/usr/bin/python3
from datetime import datetime
import json
from json import JSONEncoder


class DatetimeEncoder(JSONEncoder):
    """扩展JSONEncoder类中的default方法

    判断传入的类型是否是datetime类型，如果
    是则转为str字符，否则不是返回父类的值
    """
    def default(self, o):
        if isinstance(o, datetime):
            return o.strftime('%Y-%m-%d %H:%M:%S')
        else:
            return super(DatetimeEncoder, self).default(o)


if __name__ == '__main__':
    dict_demo = {'name': 'alex', 'data': datetime.now()}
    print(json.dumps(dict_demo, cls=DatetimeEncoder))

#!/usr/bin/python3
import json

dict_demo = {"name": "旭东"}
# 使用dumps的默认参数ensure_ascii
print(json.dumps(dict_demo, ensure_ascii=False))

#!/usr/bin/python3


def read_file(file_name):
    """读文件

    读取文件并返回文件数据
    :param file_name: 文件名
    :return: 文件的所有数据
    """
    with open(file_name, "r") as F:
        return F.read()


def write_filw(file_name, file_data):
    """写文件

    将数据写入到指定文件中
    :param file_name: 文件名
    :param file_data: 需要写入的数据
    :return:
    """
    with open(file_name, "w") as F:
        F.write(file_data)


def letter_sort(letter_str, reverse_flag=False):
    """字母排序

    使用sorted排序算法
    :param letter_str: 排序字母字符串
    :param reverse_flag: 排序顺序，False为正序，True为反序
    :return: 排序后的新字符串
    """
    return "".join(sorted(letter_str, reverse=reverse_flag))


if __name__ == '__main__':
    test1_data = read_file("test1.txt")
    test2_data = read_file("test2.txt")
    new_data = letter_sort(test1_data + test2_data)
    write_filw("new.txt", new_data)

#!/usr/bin/python3
from datetime import datetime
from datetime import timedelta


def date_calculation(now_date, offset):
    """获取日期函数

    获取几天前或者几天后的日期
    :param now_date: 当前日期
    :param offset:  日期偏移量，负数为前
    :return:  结果日期
    """
    # 格式转换
    now_date = datetime.strptime(now_date, "%Y%m%d").date()
    # 计算偏移
    offset_date = timedelta(days=offset)
    return (now_date + offset_date).strftime("%Y%m%d")


if __name__ == '__main__':
    result_day = date_calculation("20190918", 30)
    print(result_day)

#!/usr/bin/python3


def out_func(n):
    """闭包函数
    
    :param n: 整数参数n
    :return: 内层函数
    """
    def in_func(num):
        return n*num
    return in_func


if __name__ == '__main__':
    demo = out_func(3)
    print(demo(4))

def strappend(num):        # 函数作用、参数意义不明，需要加注释
    str='frist'            # 不能使用关键字"str"作为变量名
    for i in range(num):   # 遍历得到的元素"i"意义不明，无注释
        str+=str(i)        # 变量名和关键字在这个时候重名，必定报错，没有了str()方法
    return str

# 修改后
def str_append(append_cound: int) -> str:
    """字符串修改
    
    遍历append_cound，将遍历的值转为str类型并添加到字符串中
    :param append_cound: 遍历次数
    :return: 最终修改得到的新字符串
    """
    append_str = "frist"
    # 遍历获取到“times”次数int类型
    for times in range(append_cound):
        append_str += str(times)
    return append_str


if __name__ == '__main__':
    print(str_append(4))

print([num for num in range(1,101) if num % 2 == 0])

import threading

# 来一个用于线程锁的with使用
num = 0  # 全局变量多个线程可以读写，传递数据
thread_lock = threading.Lock()  # 创建一个锁


class Mythread(threading.Thread):
    def run(self):
        global num
        with thread_lock:               # with Lock的作用相当于自动获取和释放锁(资源)
            for i in range(1000000):    # 锁定期间，其他线程不可以运行
                num += 1
        print(num)

#!/usr/bin/python3

import json

dict_demo = {"a": 1, "b": 2}
# 序列化：使用json.dumps()将python类型转为json字符串
json_demo = json.dumps(dict_demo)
print(type(json_demo))
# 使用json.dump()将python数据序列化到指定文件中
with open("demo.json", "w") as file_obj:
    json.dump(dict_demo, file_obj)

# 反序列化：使用json.loads()将json字符类型转为python类型
dict_demo = json.loads(json_demo)
print(type(dict_demo))
# 使用json.load()将json字符类型从文件中读出来
with open("demo.json", "r") as file_obj:
    file_date = json.load(file_obj)
    print(file_date)

#!/usr/bin/python3
import re


def capital_count(file_name):
    """计算文件中的大写字母数量
    
    读取文件并计算文件数据的大写字母数量，返回大写字母数量
    :param file_name: 文件名
    :return: 文件中的大写字母数量
    """
    # 定义大写字母数量变量
    upper_count = 0
    # 打开文件对象，读取文件数据
    with open(file_name, "r") as file_obj:
        file_data = file_obj.read()
    # 删除掉除字母之外的所有字符
    file_data = re.sub("[^a-zA-Z]", "", file_data)
    print(file_data)
    # 遍历所有字母，使用isupper()判断是否是大写字母，并且计数
    for i in file_data:
        if i.isupper():
            upper_count += 1
    return upper_count


if __name__ == '__main__':
    print(capital_count("test1.txt"))
.

#!/usr/bin/python3

import pymongo

# 连接本地数据库
db_client = pymongo.MongoClient("mongodb://localhost:27017/")
# 切换到testdb测试数据库
test_db = db_client["testdb"]
# 切换到“sites”文档
sites_obj = test_db["sites"]
# find_one() 方法来查询集合中的一条数据
first_data = sites_obj.find_one()
print(first_data)

#!/usr/bin/python3

import redis
# 创建连接对象
connec_obj = redis.Redis(host='localhost', port=6379, db=0)
# 设置一个键值
connec_obj.set('test', '1')
# 读取一个键值
connec_obj.get('test')   # ->> '1'

#!/usr/bin/python3

import pymysql

# 打开数据库连接
db = pymysql.connect("localhost", "testuser", "test123", "TESTDB", charset='utf8' )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# 使用execute方法执行SQL语句
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取一条数据
data = cursor.fetchone()

# 关闭数据库连接
db.close()

#!/usr/bin/python3
# coding=utf-8

import time
import redis


class RedisLock(object):
    def __init__(self, key):
        # 连接数据库，创建连接对象
        self.rdcon = redis.Redis(host='', port=6379, password="", db=1)
        # 设置锁的值
        self._lock = 0
        # 分布式锁的键
        self.lock_key = "%s_dynamic_test" % key

    @staticmethod
    def get_lock(cls, timeout=10):
        """获取redis分布式锁

        设置分布式锁，判断锁是否超时
        :param cls: 锁的类对象
        :param timeout: 锁超时时间
        :return:
        """
        while cls._lock != 1:
            # 设置锁的过期时间
            timestamp = time.time() + timeout + 1
            # 设置redis分布式锁键值
            cls._lock = cls.rdcon.setnx(cls.lock_key, timestamp)
            # 判断锁的值是否为1，或者当前时间大于锁预期释放的时间，如果成立则退出循环，释放锁
            if cls._lock == 1 or (
                    time.time() > cls.rdcon.get(cls.lock_key) and
                    time.time() > cls.rdcon.getset(cls.lock_key, timestamp)):
                print("get lock")
                break
            else:
                time.sleep(0.3)

    @staticmethod
    def release(cls):
        """释放锁

        :param cls: 锁的类对象
        :return:
        """
        # 判断当前时间是否大于锁最大释放时间
        if time.time() < cls.rdcon.get(cls.lock_key):
            print("release lock")
            cls.rdcon.delete(cls.lock_key)


def deco(cls):
    """分布式锁装饰器

    :param cls: 分布式锁类对象
    :return: 外层函数
    """
    def _deco(func):
        def __deco(*args, **kwargs):
            print("before %s called [%s]." % (func.__name__, cls))
            cls.get_lock(cls)
            try:
                return func(*args, **kwargs)
            finally:
                cls.release(cls)

        return __deco

    return _deco


@deco(RedisLock("demoLock"))
def myfunc():
    print("myfunc() called.")
    # 设置20s模拟超过锁释放时间就自动释放锁的操作
    time.sleep(20)


if __name__ == "__main__":
    myfunc()

#!/usr/bin/python3
# coding=utf-8
import pymongo
from pymongo import ASCENDING, DESCENDING
# 连接数据库，创建连接对象
myclient = pymongo.MongoClient(mongodbUrl)
# 切换数据库
mydb = myclient[dbName]
# 创建索引，create_index()创建索引，可以有多个约束条件，值为1则升序，-1是降序
mydb.create_index([("date", DESCENDING), ("author", ASCENDING)])

#!/usr/bin/python3
# coding=utf-8


class Entity(object):
    def __init__(self, size, x, y):
        self.x, self.y = x, y
        self.size = size

    def __call__(self, x, y):
        # 改变实例属性
        self.x, self.y = x, y

        
if __name__ == '__main__':
    # 创建实例
    demo_obj = Entity(1, 2, 3)
    # 实例可以像函数那样执行，并传入x y值，修改对象的x y
    demo_obj(4, 5)

#!/usr/bin/python3
# coding=utf-8
from types import FunctionType
from types import  MethodType


class DemoClass(object):
    def __init__(self):
        pass

    def run_method(self):
        pass


def demo_func():
    pass


if __name__ == '__main__':
    demo_obj = DemoClass()
    print(demo_obj.run_method)
    # out:<bound method DemoClass.run_method of <__main__.DemoClass object at 0x000000000277F588>>
    print(demo_func)
    # out:<function demo_func at 0x000000000248C1E0>
    print(DemoClass.run_method)
    # <function DemoClass.run_method at 0x0000000002924400>
    print(isinstance(demo_obj.run_method, FunctionType))   # False
    print(isinstance(demo_obj.run_method, MethodType))     # True

class A():
    name = 'python'
    def func(self):
        return 'A()类的方法func()'


if __name__ == '__main__':
    print(hasattr(A, 'name'))           # True
    print(hasattr(A, 'age'))            # False

class A():
    name = 'python'
    def func(self):
        return 'Hello world'


if __name__ == '__main__':
    print(getattr(A, "name"))       # "python"
    print(getattr(A, "age"))        # Error:class A has no attribute 'age'
    print(getattr(A, "age", 18))    # 18
    print(getattr(A, "func")        # <unbound method A.func>
    print(getattr(A(), "func")()    # 'Hello world',获取到的方法需要实例化后才能调用，类方法则不需要

class A():
    name = 'python'
    def func(self):
        return 'Hello world'


if __name__ == '__main__':
    setattr(A, 'name', 'java')
    print(getattr(A, 'name'))             # java
    setattr(A, 'age', 20)
    print(getattr(A, "age")               # age

demo_obj = range(1,11)    # 创建一个未知类型的对象
print(type(demo_dbj))     # 使用type()判断对象类型

#!/usr/bin/python3


def demo_func(parm):
    """输出整数或者列表改变后的值
    
    :param parm: 整数或者列表
    :return: 
    """
    if isinstance(parm, int):
        parm += 1
    elif isinstance(parm, list):
        parm.append(1)
    print(parm)


if __name__ == '__main__':
    # 定义整数类型
    int_parm = 1
    # 函数内整数值修改（不可变类型不能修改值，其实这里是变量另外赋值）
    demo_func(int_parm)   # 输出为2
    # 输出整数值，查看对象的值是否被修改
    print(int_parm)       # 输出为1，值未改变，说明传值
    # 定义列表类型
    list_patm = [1,2,3]
    # 函数修改列表
    demo_func(list_patm)   # 输出[1, 2, 3, 1]
    # 查看函数外部列表是否发生改变
    print(list_patm)       # 输出[1, 2, 3, 1]，列表发生改变，说明传址

list(filter(lambda x: x % 2 == 1, (i for i in a)))   # py3需要使用list()转为list

import json
import ujson
def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads

monkey_patch_json()
print 'main.py',json.__name__
import sub

#!/usr/bin/python3
import re
html_str = '<html><h1><div>a="张明 98 分"</div></html>'
result_str = re.sub(r'\d{1, 2}', "100", html_str)
print(result_str)

#!/usr/bin/python3
import re

demo_str = "abcdacsdn"
print("原始字符串  " + demo_str)

# 非贪婪匹配
non_greedy = "a.*?d"
print("非贪婪匹配 = " + non_greedy)
pattern = re.compile(non_greedy)
restult_list = re.findall(pattern , demo_str)
print("非贪婪匹配")
print(restult_list)

# 贪婪匹配
greedy = "a.*d"
print("贪婪匹配 = " + greedy)
pattern = re.compile(greedy)
restult_list = re.findall(pattern , demo_str)
print("贪婪匹配结果")
print(restult_list)

#!/usr/bin/python3
import re
text = input("Please input your Email address：\n")
# 匹配任意的邮箱，@前是19位的字符数字下换线组合
if re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}$',text):
    print('Email address is Right!')
else:
    print('Please reset your right Email address!')

enumerate(sequence, [start=0])

#!/usr/bin/python3
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

#!/usr/bin/python3
from pathlib import Path

# 1.查看路径
# 使用cmd()方法输出当前的工作目录
now_path = Path.cwd()
# 使用home()输出用户的主目录
home_path = Path.home()
print("当前工作目录", now_path, type(now_path))
print("home目录", home_path, type(home_path))

# 2. 路径拼接
# 将字符串转为Pathlib.Path类型
dir_path = Path(r"D:\code\web\flaskweb")
print(dir_path, type(dir_path))
# 使用 "/" 直接拼接路径
dir_path = Path(r"D:\code\web") / "flaskweb"
print(dir_path, type(dir_path))

# 3.读写文件
# 使用基础的open()函数
demo_file = Path.cwd() / 'test.md'
with open(demo_file, mode='r') as fid:
    file_data = fid.read()
print(file_data)

# 使用pathlib的open()方法
demo_file = Path.cwd() / 'test.md'
# 这样写的好处就是open里面我们不需要再去传入路径了，
# 直接指定文件读写模式即可。实际上这里的open方法，
# 底层也是调用了os.open的方法。使用哪种方式看个人的喜好。
with demo_file.open("r") as fid:
    file_data = fid.read()
print(file_data)

# 也可以不使用with open的形式即可以进行读写
# .read_text(): 找到对应的路径然后打开文件，读成str格式。等同open操作文件的"r"格式。
# .read_bytes(): 读取字节流的方式。等同open操作文件的"rb"格式。
# .write_text(): 文件的写的操作，等同open操作文件的"w"格式。
# .write_bytes(): 文件的写的操作，等同open操作文件的"wb"格式

# 4.使用resolve可以通过传入文件名，来返回文件的完整路径
py_path =Path("demo.py")
# 需要注意的是"demo.py"文件要和我当前的程序文件在同一级目录。
print(py_path.resolve())

# 输出类的解析继承关系顺序：类名.__mro__
DemoClass.__mro__

#!/usr/bin/python3
class A(object):
    def f(self):
        print("A.f")


class B(A):
    def f(self):
        print("B.f")


class C(A):
    def f(self):
        print("C.f")


class D(B, C):
    def f(self):
        # super().f()    # 此时按照mro调用顺序可知调用的是B类的方法
        # 要想调用C类的方法，查看mro之后使用super调用C的上一类
        super(B, self).f()
        # super(a_type, obj), 其中第一个实参a_type是个类对象，第二个实参obj是个实例对象
        # 再次科普：self是实例对象本身，而不是类本身

 
if __name__ == '__main__':
    print(D.__mro__)
    # (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
    d = D()
    d.f()

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

# 答主很喜欢用filder和lambda的组合
print(list(filter(lambda x: x % 2 == 1, range(1, 101))))

list_demo = [3, 5, -4, -1, 0, -2, -6]
# sorted和lambda也是很好的组合，这里的abs是绝对值函数
print(sorted(list_demo, key=lambda x: abs(x)))

#!/usr/bin/python3
def get_y(a, b):
    return lambda x: a*x + b

y1 = get_y(3, 1)
print(y1(1))  # 结果为4

#!/usr/bin/python3
class A(object):
    def f(self):
        print("A.f")


if __name__ == '__main__':
    print(dir())
    # ['A', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
    print(dir(A))
    # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'f']

def demo_func(*args, **kwargs):
    # arg是一个元祖类型
    print(args[1])
    # kwargs是一个字典类型
    print(kwargs.keys())


if __name__ == '__main__':
    # 直接传参，但关键字类型必须为str
    demo_func(1, 2, 3, a=1, b=2)
    # 使用*和**进行解包
    demo_func(*(1, 2, 3), **{"a": 1, "b": 2})

demo_list = [1, 3, 4, 2, 7, 5]
# sorted是一个函数，返回一个新的list
result_list = sorted(demo_list)
print(result_list)
# sort是实例方法，直接作用在list本身，没有返回新的list
demo_list.sort()
print(demo_list)

# pprint用于输出一个整齐美观Python数据的结构
import pprint

demo_list = [str(i)*20 for i in range(10)]
# indent是指句首缩进
pp_object = pprint.PrettyPrinter(indent=4)
pp_object.pprint(demo_list)  # 整齐输出
print(demo_list)             # 只输出一行

print(int(0b1010))  #10

print(bin(0xf))  #0b1111

print(oct(8))  #0o10

print(hex(16))  #0x10

print(hex(15))  #0xf

a, b, = 1, 2

def binary_Search(search_list: list, search_num: int):
    """二分查找

    利用二分法找到list数组中的值
    :param search_list: 目标list
    :param search_num: 待查询值
    :return:
    """
    # 最小的下标
    min_index = 0
    # 最大的下标
    max_index = len(search_list) - 1
    # 当前索引下标
    now_index = 0
    while True:
        # 中间的下标每次向下取整
        mid_index = (min_index + max_index) // 2
        if search_num > search_list[mid_index]:
            # 小于需要的猜的数，则将最小下标变为中间的，因为中间的已经猜过，所以要加1
            min_index = mid_index + 1
        elif search_num == search_list[mid_index]:
            print("找到数据", "索引是{}".format(mid_index))
            print("一共查找{}次".format(now_index))
            break
        else:
            # 大于需要的猜的数，则将最大下标变为中间的，因为中间的已经猜过，所以要减1
            max_index = mid_index - 1
        # 索引值加一
        now_index += 1


if __name__ == "__main__":
    list1 = [i for i in range(0, 1000)]
    num = 0
    binary_Search(list1, num)

class SingleCase(object):
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance


if __name__ == '__main__':
    a = SingleCase()
    b = SingleCase()

#!/usr/bin/python3

def fbnq(num):
    """斐波那契生成器

    :param num: 生产数量
    :return: 斐波那契迭代器
    """
    a, b = 1, 1
    for _ in range(num):
        a, b = b, a+b
        yield a


if __name__ == '__main__':
    gener = fbnq(20)
    print(gener)
    for i in gener:
        print(i)

#!/usr/bin/python3
from collections import Counter
result = Counter([1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4])
print(result)
# Counter({2: 4, 4: 4, 3: 3, 1: 1})

def bubble_sort(parm_list):
    """冒泡排序

    冒泡排序思路：判断前后两个值的大小，若前大于后则调换两个值位置
    每一轮循环都可以将最大值放到末尾，所以需要迭代次数为数组的大小
    因为每次都将最大值放到最后，所以内层迭代就不需要全部检测一遍
    :param parm_list:
    :return:
    """
    for n in range(len(parm_list)):
        for now_index in range(len(parm_list)-n-1):
            if parm_list[now_index] > parm_list[now_index + 1]:
                parm_list[now_index], parm_list[now_index + 1] = \
                    parm_list[now_index + 1], parm_list[now_index]
    print(parm_list)


if __name__ == '__main__':
    bubble_sort([1, 2, 3, 7, 5, 4, 6])

def quick_sort(parm_list):
    """快排

    每次选取第一个值为基准值，再把列表中比基准值大的组成新列表，小的组成另一个新列表
    再次对两个新列表进行操作，直到新列表为空
    :param parm_list: 参数列表
    :return:
    """
    if not parm_list:
        return []
    else:
        pivot = parm_list[0]
        # 利用递归每次找出大于和小于基准值得两个新列表
        lesser = quick_sort([x for x in parm_list[1:] if x < pivot])
        greater = quick_sort([x for x in parm_list[1:] if x >= pivot])
        # 最后将排列好的值相加
        return lesser + [pivot] + greater


if __name__ == '__main__':
    demo_list = [4, 23, 5, 6, 43, 14, 9, -23, 2, 6, 123, 12, 3, 3, 3, 3, 1]
    print(quick_sort(demo_list))

def topology_sort(relation_parm):
    """简单拓扑排序

    简单实现拓扑排序算法，不考虑时间复杂度
    :param relation_parm: 拓扑关系字典参数
    :return: 排序后结果
    """
    in_degrees = dict((u, 0) for u in relation_parm)            # 初始化所有顶点入度为0，转为字典类型
    vertex_num = len(in_degrees)                                # 字典键值个数
    for key in relation_parm:                                   # 遍历关系参数字典，求出每个顶点的入度值
        for value in relation_parm[key]:                        # 遍历每个键的值，将关系其他顶点的键值+1到in_degrees字典中
            in_degrees[value] += 1                              # 计算每个顶点的入度
    zero_list = [u for u in in_degrees if in_degrees[u] == 0]   # 筛选入度为0的顶点
    result_list = []                                            # 创建结果空列表
    while zero_list:                                            # 循环判断列表为空
        last_zero = zero_list.pop()                             # 删除最后一个入度为0的对象
        result_list.append(last_zero)                           # 结构列表添加刚删除的对象
        for zero_value in relation_parm[last_zero]:             # 遍历以入度为0作为键的字典值
            in_degrees[zero_value] -= 1                         # 和last_zero有关系的键值-1
            if in_degrees[zero_value] == 0:                     # 判断-1过后的键值是否为0
                zero_list.append(zero_value)                    # 再次筛选入度为0的顶点
    if len(result_list) != vertex_num:                          # 如果循环结束后结果列表对象个数不等于原始键个数，说明存在环
        print("there's a circle.")
    else:
        return result_list


if __name__ == '__main__':
    relation_dict = {
        'a': 'bcd',
        'b': '',
        'c': 'be',
        'd': 'e',
        'e': '',
        'f': 'de'
    }
    print(topology_sort(relation_dict))

from lxml import etree

text = '''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a>
     </ul>
 </div>
'''
# 获取 html 内容 元素，转为etree类型
htmlEmt = etree.HTML(text)
print(type(htmlEmt))
# 将内容元素转换为字符串
result = etree.tostring(htmlEmt)
# utf-8 格式输出，lxml有自动修正html的功能
print(result.decode("utf-8"))
# 获取所有的 <li> 标签
result = htmlEmt.xpath('//li')
print(result)
# 获取标签数量
print(len(result))
result = htmlEmt.xpath('//li/@class')
print(result)
# 获取 <li> 标签下 href 为 link1.html 的 <a> 标签
result = htmlEmt.xpath('//li/a[@href="link1.html"]')
print(result)
print(result[0].text)
# 获取最后一个 <li> 的 <a> 的 href
result = htmlEmt.xpath('//li[last()]/a/@href')
print(result)
# 获取倒数第二个元素的内容
result = htmlEmt.xpath('//li[last()-1]/a')
print(result[0].text)
# 获取 class 为 item-0 的标签名
result = htmlEmt.xpath('//*[@class="item-0"]')
print(result[0].tag)