基础的普及吧,模块专栏

作者:计算机知识

 

 

 

 

上次文化回看:

本文适应人群:C# or Python3 基础加强

小说汇总:

代码裤子:

代码裤子:

代码裤子:

多图旧排版:

在线编制程序:

在线编制程序:

在线编制程序:

VSCode设置python三的费用条件(linux下暗中认可是python2)

在线预览:http://github.lesschina.com/python/base/module/模块专项论题.html

在线预览:http://github.lesschina.com/python/base/ext/基础拓展.html

在线预览:http://github.lesschina.com/python/base/ext/基础衍生.html

应接建议更轻易的语法~(文章中案例有三个福利哦,三个是调理,一个是人造智能[ 密码:fqif])

教员休假度蜜月去了,那学期也到了尾声,小明同学感到本人学的相当好的,在四处逛游的进度中看见了小潘的微机,然后惊到了!

毕竟期末考试甘休了,聪明的小明同学以往当然是开心的过暑假了,左边手3头瓜,右边手一本书~正在给老乡小张同学进行他商量多日的知识点

立马快期末考试了,老师蜜月也回到了,于是有了一场跨季度的复习讲课了:

先说下感到,python的编制程序有一些JavaScript的痛感(比如:'和“一时候不区分),又以为像海外版的易语言,整个经过像读书同样,举个例子一个因素不在列表之中==> for item not in lists。使用它做个大点的等级次序必就要先鲜明好编程风格,不然能令人夭折的。先不追究,后边会几次三番深究。。。(Python贰自家就不讲了,官方推荐应用Python3

In [1]:

一.NetCore装饰器方式¶

装饰器此次从C#千帆竞发引进,上次刚讲迭代器模式,这次把装饰器模式也带一波(纯Python方向的能够选用性跳过,也能够当扩充)

事实上通俗讲就是,给原来对象动态的丰硕局地附加的职分(终归动不动就改类你让其余调用的人怎么办?也不符合开放封闭原则是吧~)

举个大致的事例:()

BaseComponent.cs

/// <summary>
/// 组件的抽象父类
/// </summary>
public abstract class BaseComponent
{
    /// <summary>
    /// 定义一个登录的抽象方法
    /// 其他方法,这边省略
    /// </summary>
    public abstract string Login();
}

LoginComponent.cs

/// <summary>
/// 默认登录组件(账号 密码)
/// 其他方法省略
/// 友情提醒一下,抽象类里面可以定义非抽象方法
/// </summary>
public class LoginComponent : BaseComponent
{
    public override string Login()
    {
        return "默认账号密码登录";
    }
}

暗中同意调用:

static void Main(string[] args)
{
    var obj = new LoginComponent();
    var str = obj.Login();
    Console.WriteLine(str);
}

只要那时候平台须求加上微信第贰方登六,咋做?一般都以用一连来化解,其实还足以因而灵活的装饰器来化解:(好处能够团结体会)

先定义3个通用装饰器(不必然针对登入,注册等等只要在BaseComponent中的都能用)

/// <summary>
/// 装饰器
/// </summary>
public class BaseDecorator : BaseComponent
{
    protected BaseComponent _component;
    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="obj">登录组件对象</param>
    protected BaseDecorator(BaseComponent obj)
    {
        this._component = obj;
    }
    public override string Login()
    {
        string str = string.Empty;
        if (_component != null) str = _component.Login();
        return str;
    }
}

方今依附供给拉长微信登陆:(符合开放封闭原则)

/// <summary>
/// 默认登录组件(账号 密码)
/// 其他方法省略
/// </summary>
public class WeChatLoginDecorator : BaseDecorator
{
    public WeChatLoginDecorator(BaseComponent obj) : base(obj)
    {
    }
    /// <summary>
    /// 添加微信第三方登录
    /// </summary>
    /// <returns></returns>
    public string WeChatLogin()
    {
        return "add WeChatLogin";
    }
}

调用:(原有系统该怎么用就怎么用,新系统能够动用装饰器来增多新职能)

static void Main(string[] args)
{
    #region 登录模块V2
    // 实例化登录装饰器
    var loginDecorator = new WeChatLoginDecorator(new LoginComponent());
    // 原有的登录方法
    var str1 = loginDecorator.Login();
    // 现在新增的登录方法
    var str2 = loginDecorator.WeChatLogin();
    Console.WriteLine($"{str1}n{str2}");
    #endregion
}

结果:

默认账号密码登录
add WeChatLogin

如若再进入QQ和微博报到的效用就再加多多个V3本子的装饰器,承袭当时V贰版本的登陆就可以(版本迭代非常福利)

/// <summary>
/// 默认登录组件(账号 密码)
/// 其他方法省略
/// </summary>
public class LoginDecoratorV3 : WeChatLoginDecorator
{
    public LoginDecoratorV3(BaseComponent obj) : base(obj)
    {
    }

    /// <summary>
    /// 添加QQ登录
    /// </summary>
    /// <returns></returns>
    public string QQLogin()
    {
        return "add QQLogin";
    }

    /// <summary>
    /// 添加新浪登录
    /// </summary>
    /// <returns></returns>
    public string SinaLogin()
    {
        return "add SinaLogin";
    }
}

调用:

static void Main(string[] args)
{
    #region 登录模块V3
    // 实例化登录装饰器
    var loginDecoratorV3 = new LoginDecoratorV3(new LoginComponent());
    // 原有的登录方法
    var v1 = loginDecoratorV3.Login();
    // 第二个版本迭代中的微信登录
    var v2 = loginDecoratorV3.WeChatLogin();
    // 新增的QQ和新浪登录
    var qqLogin = loginDecoratorV3.QQLogin();
    var sinaLogin = loginDecoratorV3.SinaLogin();
    Console.WriteLine($"{v1}n{v2}n{qqLogin}n{sinaLogin}");
    #endregion
}

结果:

默认账号密码登录
add WeChatLogin
add QQLogin
add SinaLogin

实则还应该有为数十分多用处,比方原本系统缓存那块当时设想不到,以后并发来了,已经上线了,原有代码又不太敢大幅度修改,那时候装饰器就很便利的给有个别意义加多点缓存、测试、日记等等1连串功用(AOP里面好多这种概念)

实则景况说的已经很精晓了,其余的大团结寻觅一下啊

 

壹.Python基础语法增加基础的普及吧,模块专栏。¶

 

# 导入matplotlib的pyplot模块
import matplotlib.pyplot as plt

x_list=list(range(1,11))
y_list=[y*2 1 for y in x_list]

print(x_list)
print(y_list)

2.Python装饰器¶

那Python怎么落到实处装饰器呢?小胖问道。

小明屁颠屁颠的跑过去说道,通过闭包咯~(闭包假若忘了,能够回顾一下)

①.1.if 断定标准有关¶

None、""、0、[]、{} ==> 假

1、" "、[None,""]、{"":None} ==> 真

小明可安心乐意了,后天被打击的突变,这几天老师回来了,又有什么不可大发神威了,于是当先提交demo:

In [1]:

# None
if None:
    print(True)
else:
    print(False)

 

False

In [2]:

# 0为False
if 0:
    print(True)
else:
    print(False)

 

False

In [3]:

# 空字符串
if "":
    print(True)
else:
    print(False)

 

False

In [4]:

# 空列表为False
if []:
    print(True)
else:
    print(False)

 

False

In [5]:

# 空字典为False
if {}:
    print(True)
else:
    print(False)

 

False

In [6]:

# 1为True
if 1:
    print(True)
else:
    print(False)

 

True

In [7]:

# 含空格
if " ":
    print(True)
else:
    print(False)

 

True

In [8]:

if [None,""]:
    print(True)
else:
    print(False)

 

True

In [9]:

if {"":None}:
    print(True)
else:
    print(False)

 

True

 

师资微带笑容的看了小多美滋(Karicare)眼,然后紧接着讲if的扩大

壹.命名规则¶

Python官方是援引使用_来间隔单词,但一般开辟人士皆以以各自己作主语言的命名来定义的,这些就各人喜欢了,不过团队自然要统一。

取名规则:总的原则便是 见名知意,一般都是 驼峰命名法,纯Python的话推荐用 _连年单词

扩充:Python关键词能够谐和打字与印刷一下:

In [1]:

import keyword
print(keyword.kwlist)

 

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

 

二.一.装饰器引进¶

来看3个选用场景,从前老版本系统因为并发非常的小,没考虑到缓存

def get_data():
    print("直接数据库读取数据")

def main():
    get_data()

if __name__ == '__main__':
    main()

在不修改原有代码的前提下如何是好?大家参照C#和Java写下如下代码:

In [1]:

# 添加一个闭包
def cache(func):
    def decorator():
        print("给功能添加了缓存")
        if True:
            pass
        else:
            func()# 如果缓存失效则读取数据库获取新的数据
    return decorator

def get_data():
    print("直接数据库读取数据")

def main():
    f1 = cache(get_data)
    f1()
    print(type(f1))

if __name__ == '__main__':
    main()

 

给功能添加了缓存
<class 'function'>

 

小张问道:“怎么也那样费劲啊,C#的要命我就有一点点晕了,怎么Python也这么呀?”f1 = cache(get_data) f1()

小明哈哈一笑道:“人生苦短,小编用Python~那句话可不是随意说着玩的,来来来,看看Python的语法糖”:

In [2]:

def cache(func):
    def wrapper():
        print("给功能添加了缓存")
        if True:
            pass
        else:
            func()  # 如果缓存失效则读取数据库获取新的数据
    return wrapper

@cache
def get_data():
    print("直接数据库读取数据")

def main():
    get_data()

if __name__ == '__main__':
    main()

 

给功能添加了缓存

 

其实

@cache
def get_data()

等价于

# 把f1改成函数名字罢了。可以这么理解:get_data重写指向了一个新函数
get_data = cache(get_data)

小张同学瞪了瞪眼睛,努力纪念着在此之前的知识点,然后搜索枯肠:“那不是大家事先讲的性格装饰器呢?而且好便宜啊,那完全符合开放封闭原则啊!“

class Student(object):
    def __init__(self, name, age):
        # 一般需要用到的属性都直接放在__init__里面了
        self.name = name
        self.age = age

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("age must > 0")

    def show(self):
        print("name:%s,age:%s" % (self.name, self.age))

小明也愣了愣,说道:”也对哦,你不说自家都忘了,大家学习面向对象叁大特色的时候常常用呢,怪不得这么熟谙呢“

随着又嘀咕了一句:”小编怎么不知底开放封闭原则...“

小张戏弄道:”那你都不知晓?对扩大开放,对已经落实的代码封闭嘛~“

In [3]:

# 需要注意一点
def cache(func):
    print("装饰器开始装饰")
    def wrapper():
            print("给功能添加了缓存")
            if True:
                pass
            else:
                func()  # 如果缓存失效则读取数据库获取新的数据
    return wrapper

@cache # 当你写这个的时候,装饰器就开始装饰了,闭包里面的功能是你调用的时候执行
def get_data():
    print("直接数据库读取数据")

 

装饰器开始装饰

 

壹.贰.安慕希表明符¶

eg:max = a if a > b else b

In [10]:

a, b = 1, 2

max = a if a > b else b

print(max)

 

2

In [11]:

a, b, c = 1, 3, 2

max = a if a > b else b
max = max if max > c else c

print(max)

 

3

In [12]:

# 上面的那个还有一种简写(不推荐)
a, b, c = 1, 3, 2

max = (a if a > b else b) if (a if a > b else b) > c else c

print(max)

 

3

 

1.1.标识符¶

标示符由字母、下划线和数字组合,且数字不能够开首(那几个大致都同样)注意:标记符是分别轻重缓急写的

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

2.二.几个装饰器¶

小明赶紧扯开话题,”咳咳,大家接下去大家随后讲装饰器"

小张问道,像上面10分第③方登陆的案例,想增加少增添少,Python怎么做吧?

小美素佳儿(Friso)笑而过~

今日项目又升高了,供给每一次调用都要打字与印刷一下日记消息,方便以后纠错,小张先用自个儿的接头打下了这段代码,然后像小明请教:

In [4]:

def log(func):
    def wrapper():
        print("输出日记信息")
        cache(func)()
    return wrapper

def cache(func):
    def wrapper():
        print("给功能添加了缓存")
        if True:
            pass
        else:
            func()  # 如果缓存失效则读取数据库获取新的数据
    return wrapper

@log
def get_data():
    print("直接数据库读取数据")

def main():
    get_data()

if __name__ == '__main__':
    main()

 

输出日记信息
给功能添加了缓存

 

小明刚喜欢的喝着口口可乐呢,看到代码后1比很大心喷了小张壹脸,然后难堪的说道:“Python又不是不得不装饰二个装饰器,来探望自家的代码”:

In [5]:

def log(func):
    print("开始装饰Log模块")
    def wrapper():
        print("输出日记信息")
        func()
    return wrapper

def cache(func):
    print("开始装饰Cache模块")
    def wrapper():
        print("给功能添加了缓存")
        if True:
            pass
        else:
            func()  # 如果缓存失效则读取数据库获取新的数据
    return wrapper

@log
@cache
def get_data():
    print("直接数据库读取数据")

def main():
    get_data()

if __name__ == '__main__':
    main()

 

开始装饰Cache模块
开始装饰Log模块
输出日记信息
给功能添加了缓存

 

小张耐心的看完了代码,然后说道:“咦,作者发觉它装潢的时候是从下往上点缀,实践的时候是从上往下哎呀?推行的时候程序本来就是从上往下,根据道理应该是从上往下装饰啊?”

小明神秘的说道:“你猜啊~你能够把它精晓为寄快递和拆特快专递

小张开心的跳起来了:

装饰器:装快递,先包装里面包车型客车物料,然后再加个盒子。施行李装运饰器:拆快递,先拆外面包车型地铁包装再拆里面包车型客车~几乎妙不可言啊

1.二.字符串和编码¶

Python3.x本子中,字符串是以Unicode编码的

对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码调换为相应的字符

小潘对那块全部研究,把小明按在桌子上然后超过提交demo:

In [13]:

ord('D')

Out[13]:

68

In [14]:

ord('毒')

Out[14]:

27602

In [15]:

chr(68)

Out[15]:

'D'

In [16]:

chr(27602)

Out[16]:

'毒'

In [17]:

print(ord('A'))
print(ord('Z'))

print(ord('a'))
print(ord('z'))

 

65
90
97
122

 

教员补充批注道:

编码:encode() 解码:decode()

url相关的能够用:

urllib.parse.quote() and urllib.parse.unquote()

urllib.parse.urlencode() 能够直接对贰个key-value进行url编码

In [18]:

# encode() and decode()
name="毒逆天"

name_encode=name.encode("utf-8")

print(name_encode)

print(name_encode.decode("utf-8"))

 

b'xe6xafx92xe9x80x86xe5xa4xa9'
毒逆天

In [19]:

# 需要导入urlib.parse

import urllib.parse

In [20]:

test_str="淡定"

# 对字符串进行url编码和解码
test_str_enode = urllib.parse.quote(test_str)

print(test_str_enode)

# urllib.parse.quote() 解码
print(urllib.parse.unquote(test_str_enode))

 

淡定
淡定

In [21]:

# urlencode 可以直接对一个key-value进行编码

test_dict={"name":"毒逆天","age":23}

encode_str = urllib.parse.urlencode(test_dict)

print(encode_str)
print(urllib.parse.unquote(encode_str))

 

name=毒逆天&age=23
name=毒逆天&age=23

 

1.2.Python¶

In [2]:

# Python标识符区分大小写的案例
temp="xxx"
tEmp="==="
print(temp tEmp)

 

xxx===

 

In [2]:

2.三.带参装饰器¶

小明继续讲述他四哥的血泪历史:

急需时刻在变,系统接纳限制更广了,为了不砸场子,抠门的业主说了算每年多花伍W在本领研究开发的硬件帮忙上,那下子本事部老娱心悦目了,想想在此从前前端只好通过CDN和HTTP请求来缓存,后端只可以依据页面缓存和数据库缓存就心塞,于是快速新扩充1台Redis的云服务器。为了以往和前几日缓存代码得变一变了,内需补助钦定的缓存数据库:(若是还是不是保证外人搞的老项目,你如此玩有限支撑被打死,开采的时候老老实实的厂子形式搞起)

带参数的装饰器一般都以用来记录logo日记相比多,本身费用知道debug格局,生产钦点except情势等等

In [6]:

# 可以理解为,在原来的外面套了一层
def cache(cache_name):
    def decorator(func):
        def wrapper():
            if cache_name == "redis":
                print("给功能添加了Redis缓存")
            elif cache_name == "memcache":
                pass
            else:
                func()
        return wrapper
    return decorator

@cache("redis") # 相当于是:get_data = cache(”redis“)(get_data)
def get_data():
    print("直接数据库读取数据")

def main():
    get_data()

if __name__ == '__main__':
    main()

 

给功能添加了Redis缓存

 

小张很开心,然后练了练手,然后攻讦小明道(英文名:míng dào):”你是不是藏了花招!“

代码如下:

In [7]:

def log(func):
    def inner():
        print("%s log_info..." % func.__name__)
        func()
    return inner

@log
def login_in(name_str, pass_str):
    return "欢迎登录:%s" % (name_str)

@log
def login_out():
    print("已经退出登录")

@log
def get_data(id):
    print("%s:data xxx" % id)

def main():
    login_out()
    get_data(1)
    print(login_in("小明", "xxx"))

if __name__ == '__main__':
    main()

 

login_out log_info...
已经退出登录

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-dcb695819107> in <module>()
     23 
     24 if __name__ == '__main__':
---> 25main()

<ipython-input-7-dcb695819107> in main()
     19 def main():
     20     login_out()
---> 21get_data(1)
     22     print(login_in("小明", "xxx"))
     23 

TypeError: inner() takes 0 positional arguments but 1 was given

 

一.3.值剖断和地点决断¶

小明不乐意了,你个小潘总是抢笔者的风头,看完标题就刷刷的在黑板上写下了之类知识点:

is 是相比多个引用是还是不是对准了同多少个目的id()赢得的地方同样则如出1辙)

== 是相比三个对象的值是还是不是等于

在事先讲Dict的时候提了刹那间可变和不可变类型:https://www.cnblogs.com/dotnetcrazy/p/9155310.html#伍.贰.增添和修改

Func里面又系统的说了一下:https://www.cnblogs.com/dotnetcrazy/p/9175950.html#4.伍.可变类型和不足变类型

对于可变不可变类别就不去复述了,上面再来多少个案例看看 值判断位置剖断的概念

In [22]:

################ 可变类型 ################ 

In [23]:

a=[1,2,3]
b=[1,2,3]

# id不一样,那is肯定不一样了
print(id(a))
print(id(b))

 

139727165899464
139727165725256

In [24]:

# a和b是否指向同一个地址
a is b

Out[24]:

False

In [25]:

# a和b的值是否相同
a == b

Out[25]:

True

In [26]:

################ 开始变化了 ################ 

In [27]:

# 让a指向b的地址
a=b

# a和b的id一样了
print(id(a))
print(id(b))

 

139727165725256
139727165725256

In [28]:

# a和b是否指向同一个地址
a is b

Out[28]:

True

In [29]:

# a和b的值是否相同
a == b

Out[29]:

True

In [30]:

################ 不可变类型 ################ 

In [31]:

a=1
b=1

# id一样
print(id(a))
print(id(b))

 

94592578394656
94592578394656

In [32]:

a is b

Out[32]:

True

In [33]:

a == b

Out[33]:

True

In [34]:

# 但是你要注意,不是所有不可变类型都这样的

f1=1.2
f2=1.2

# 声明两个相同值的浮点型变量,查看它们的id,发现它们并不是指向同个内存地址(这点和int类型不同)
print(id(f1))
print(id(f2))

 

139727217917024
139727217917096

In [35]:

# 这个就不一样了
# 这方面涉及Python内存管理机制,Python对int类型和较短的字符串进行了缓存
# 无论声明多少个值相同的变量,实际上都指向同个内存地址,其他的就没这福利咯~

f1 is f2

Out[35]:

False

In [36]:

f1 == f2

Out[36]:

True

 

1.3.CSharp¶

In [3]:

%%script csharp
//CSharp标识符区分大小写的案例
var temp = "xxx";
var tEmp = "===";
Console.WriteLine(temp   tEmp);

 

xxx===

 

# 画图
plt.plot(x_list,y_list)
# 设置X,Y的坐标区间(可以不设置,用默认显示方式)
plt.axis([0,10,0,25])
# 显示图片
plt.show()

本文由bwin必赢发布,转载请注明来源

关键词: 56net亚洲必赢