全栈12期的崛起之捡点儿有用的说说

1.流程控制之如果你没听说过流程控制的话那么我告诉你就是ifelseforwhile这种控制代码走向的语句它是基础中的战斗机学会它们就基本学会了Python

2.函数之三大器生成器迭代器装饰器闭包各种动态参数列表生成器推导式

3.模块之根本搞不懂的re带你走出阴影的logging工作中可能常用某某及某某某

4.面向对象之其实能用到的东西就这么一点儿有什么可难得别总把它想的那么复杂其实它就是一种思想和编程方式不用面向对象一样可以写出好程序但是不会面向对象一定找不到好工作!

Every Body Let's Go !

 

一.流程控制

一.1.如果没有如果最终是什么结果 之 if else

if #如果
else #否则

if True #如果成立
    print("OK") 
else #否则
    print("不OK")

if 1 > 2: #如果
    print("what?")
elif 2==2: #否则如果
    print("Oh Yeah!")
else #否则
    print("Oh my baby")

本节结束,谢谢大家

 

一.2.般若波罗蜜哇又升仙了咦为什么要说又呢 之 for

for item in "今天你特别好看": #每次item从"你今天特别好看"中拿出来一个字
    print(item)
else: #可有可无,for正常结束之后走这段儿代码
    print("个屁啊!")

for index,item in enumerate(["你","今","天","真","二"]): # index,是下标哦,item是列表中的每一个元素
    print(index,item)

本节结束,再次谢谢大家

 

一.3.跟着我左手右手一个慢动作,右手左手慢动作重播 之 while

while True : #如果 while 条件 为真时,继续执行之后的代码
    print("Are you OK?")

for item in "123456789":
    if item == "5":
        print("确认过眼神,我遇到对的5")
        continue  # 遇到continue 之后的代码就不在继续了
    print(item)    

for item in "123456789":
    if item == "5":
        print("又是熟悉的5")
        break    # 遇到break 直接结束循环

    print(item)

本节以及本章~结束,Thank you !!!! Are you ok??? Hello Thank you ,Thank you very much !

是的,所谓流程控制就是这些小东西

 

二.函数

二.1.你那么聪明根本都不需要看这个章节 之 def args kwargs

def func(参数1,参数2):  # def 用来定义函数及函数名,参数1和参数2就是定义时的形参,也就是将来调用函数时必须要传入的参数
    变量1 = 参数1+参数2
    return 变量1

#我们定义参数的时候,无法确定函数中会有多少参数时,需要可变长参数,也就是动态参数的参与处理 这里我们的*args 和 **kwargs 就起了作用

*args 就是 将未定义且多余的 位置参数记录在内,偷偷的告诉你,args是个元祖,里面记录着你个函数传递的多余位置参数

**kwargs 就是 将多余的关键字参数记录在内,我用嘹亮且带有磁性的声音,偷偷告诉你,kwargs 其实是个dict哦,里面大概就是{"name":"Dragon","age":1+1+1+1+1+1+18}

def args_func(a,b,*args):  # args 里面保存着除了ab之外的所有多余参数
    print(args) # 这回知道是元祖了吧
    for i in args:
        print(i)

args_func(1,2,3,4,5,6)  # 这里调用的时候1,2分别传递给a,b,那么3456就会保存在args里面哦

def kwargs_func(a, b, **kwargs):  # kwargs 里面保存着除了ab之外其他关键字传入参的参数
    print(kwargs)  # 这回知道是字典了吧
    for k, v in kwargs:
        print(k, v)


kwargs_func(1, 2, c=3, d=4, e=5)  # 这里调用的时候,12分别传递给a,b 那么c=3,d=4,e=5 就会保存在**kwargs里面哦

def args_kwargs_func(*args, **kwargs):  # 这里一定要注意*args 要在 **kwargs之前
    print(args)
    print(kwargs)


args_kwargs_func(1, 2, a=1, b=2)  # 12存入args a=1,b=2 存入kwargs,这里要注意的是关键字传参之后,不可以在位置传参了

本节结束,忘记它吧

 

二.2.你可以开启一个while "我没学懂"  模式  之  闭包函数

def close_func(a):  # 外部函数
    
    def inner():  # 内部函数
        b = a + 1  # 这里的a 是外部函数的参数 , 也就是说内部函数引用 外部函数的参数 就是闭包函数
        return b
    
    return inner()  # 注意啊,这里要返回内部函数的实行结果,也就是说,在外部函数中执行内部函数 就是闭包函数

def close_func(a):  # 外部函数
    def inner():  # 内部函数
        b = a + 1  # 这里的a 是外部函数的参数 , 也就是说内部函数引用 外部函数的参数 就是闭包函数
        return b

    if isinstance(a, int):
        res = inner()
    else:
        res = "请输入一个int类型"
    return res  # 注意啊,这里要返回内部函数的实行结果,也就是说,在外部函数中执行内部函数 就是闭包函数

print(close_func("123"))

本节结束,趁着热乎劲儿,赶紧往下看,算我求求你

 

二.3.break 上面的 再次 while "我没学会" 模式 之 装饰器 (while true : 这里是重点,这里是重点,这里是重点)

概念:装饰器是什么

装饰器 就是 不改变函数的调用方式,为函数添加功能

# 现在我们有一个函数,返回当前系统时间
import datetime

def see_time():
    return datetime.datetime.now()

print(see_time())

# 2018-05-31 18:48:34.151397

#那么问题来了,我想看到的结果是 "当前系统时间为:2018-05-31 18:48:34.151397" 但是函数已经写定了,我们又没有权限修改怎么办?

为了能够的到"当前系统时间为:2018-05-31 18:52:11.550643" 并且不能更改函数本身,怎么办呢?

装饰器这个时候就起到作用了,已知: see_time 会返回 "2018-05-31 18:52:11.550643"系统时间 ,在它之间 加上 "当前系统时间为:" 就可以了对吧

我们用装饰器来试一下,顺便讲解一下装饰器:

def os_time(func):  # 2.那么现在的func 就是 see_time 了 如果func加了()的话是不是就运行了呀,所以func现在是一个等待被运行的函数
    def add_str():  # 5.如果上面你都看明白了,这里你就根本不会发愁了.add_str+()运行
        time_str = func() # 6. 这里就是我们刚才传入的函数 see_time 记不记得? 不一样的是这里加了()运行了函数,time_str 的结果就是当前的系统时间
        time_str = "当前系统时间为:" + str(time_str)# 7. 在系统时间的前面加上字符串

        return time_str  # 8. 返回拼接好的字符串 OK 搞定了

    return add_str  # 3. 哎?为什么不运行我们的func(see_time)呢,却返回了一个内部函数,寻找4来获得答案吧

import datetime

@os_time  # 1.这里相当有意思,@os_time 相当于 os_time(see_time) , 函数see_time 被当成参数传递给了os_time
def see_time():
    return datetime.datetime.now()

print(see_time())  # 4.这里我们运行的时候实际上是 os_time(see_time) 的返回结果:add_str这个函数,没明白的话,从1开始循环再看一次

# 当前系统时间为:2018-05-31 18:56:59.871307
#成功了

装饰器部分是有那么一点儿不好理解,但是它在日后工作中是很重要的,即使你不日,那也很重要

本节结束,重点之一,请务必搞懂

 

二.4.其实就是一大堆东西一个一个往出拿  之  迭代器

说到迭代器 捎带手 提一嘴 可迭代对象:  str  list  tuple  dict  set

什么是可迭代对象呢,就是可以被 for item in xx 这个xx 就是可迭代对象 怎么来判断是不是可以被 xx 呢, 不是,可以迭代迭代呢,__iter__方法,只要有,就是可迭代对象,给我记住

迭代器与可迭代对象的区别在于 迭代器有一个  __next__()  方法

可迭代对象,通过调用__iter__()方法,得到一个迭代器,迭代器里面的元素,拿出来一次就没了,生成器也是一样哦

l = [1,2,3,4,5]
t = (1,2,3)

print(l,l.__iter__())
print(t,t.__iter__())

#[1, 2, 3, 4, 5] <list_iterator object at 0x037BDBB0>
#(1, 2, 3) <tuple_iterator object at 0x037BD190>

 

二.5.其实就是一大堆东西一个一个往出拿  之  生成器

生成器 我们可以理解为 自己写的迭代器

所谓生成器 就是 一个函数 里面 有一个 关键字 yield 

我们来看一段代码:

def gener():  #这就是我们的生成器
    print("第一次")
    yield 1
    print("第二次")
    yield 2
    print("第三次")
    yield 3

g = gener()  # 生成器加括号得到我们的生成器对象 <generator object gener at 0x0545B390>
print(g)

for i in range(3): # 我分别从g这个生成器对象中,__next__()了三次,每一次,都是yield 的结果
    print(g.__next__()) 

def gener():  #这就是我们的生成器
    print("第一次")
    yield 1
    print("第二次")
    yield 2
    print("第三次")
    yield 3

g = gener()# 生成器加括号得到我们的生成器对象 <generator object gener at 0x0545B390>
print(g)

for i in g:
    print(i)

#由此见得,生成器其实也是一个可迭代对象吧

def gener():
    for i in range(3):
        a = yield i  # yield 神奇的地方来了, 它悄悄的返回了 i 并且等待着接收一个值传递给 a
        print(a)
        if a == "ok":
            return

g = gener()

# for i in g:
#     print(i) # 0 1 2

g.__next__()  # 如果第一次使用send的时候一定要传递一个None 否则会出错的,因为代码还没有走到yield 所以没有容器等你传值
#使用next方法,可以让代码停留在yield上面
# g.send("第一次send")
g.send("ok") # StopIteration 停止迭代 因为遇到了 return
g.send("第二次send")

yield关键字,很关键,很多开源的大项目解决并发问题,用的都是yield

本节结束,想赚更多的工资 12K 以上的话,yield 一定要弄明白哦

 

二.6.推导而不是推倒 之 推导式

推导式举两个怀柔大板栗:

列表推导式:很(yao)重(xue)要(hui)

li = [i for i in range(10)]  # 简单的列表推导式,就是在列表内写一个for循环对吧
print(li)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

lis = [i for i in range(10) if i % 2 == 0]  # 这是带if 条件的列表推导式
print(lis)  # [0, 2, 4, 6, 8]

生成器推导式 : 也(te)很(bie)重要

gener = (i for i in range(10))  # 简单的生成器推导式,就是在元组内写一个for循环对吧
print(gener)  # <generator object <genexpr> at 0x04F9B3C0>

geners = (i for i in range(10) if i % 2 == 0)  # 这是带if 条件的生成器推导式
print(geners)  # <generator object <genexpr> at 0x04F9B3F0>

从上述来看,列表推导式和生成器推导式只是[] 与 () 的区别

但是实际上,生成器推导式的效率非常高,但可控性很差,比如不直观,用一次就没了

相对而言列表推导式的效率比较低,但是可控性强,可以反复利用,而且数据显示很直观

本节及本章结束,内容较多,希望大家,都(bi)能(xu)学会

 

三.模块

三.1.任何项目,任何,注意任何项目都得用 之 logging 模块

刚刚接触logging模块的你,你说啥?哦,啊?

就让我来重新给你引入一次logging模块的应用吧,没时间解释了, Fuck Car !!!

import logging  # 导入我们的logging模块

# 我们写一条日志进去,其实里面有好多好多好多好多东西,比如写日志的时间,哪个函数写的日志,哪个级别的日志,当然还有我们的message信息
# 一大堆东西一起装进去,才算是一条日志哦

my_log = logging.getLogger("my_log")  # 创建一个我们log容器 名字叫my_log
my_log.setLevel(logging.DEBUG)  # 我们这个my_log容器 可以存放DEBUG及其以下界别的日志

# 容器已经有了,但是我们还没有显示信息的地方(比如在控制台,比如在文件),那么我们就来建立一个显示信息的地方
sh = logging.StreamHandler()  # StreamHandler 这就是流处理器,也就是咱们的控制台, sh 等于 我们实例化了一个控制台
sh.setLevel(logging.DEBUG)  # 这个sh控制台 只能显示Debug及其以下级别的日志信息

# OK我们得到了 控制台打印 信息了  , 但是 日志里面那么多信息,要拿出来什么呢?
# 就拿这些好了,时间+日志级别+message,用 时间 - 日志级别 : message 这种格式输出
my_log_fmt = logging.Formatter("%(asctime)s - %(levelname)s : %(message)s")  # 格式化 打印字符串
#如果不进行格式化处理的话,你直接输出日志的话,只能获得日志的message信息

# 只有在sh 这个控制台上输出的时候 使用 my_log_fmt 这种样式
sh.setFormatter(my_log_fmt)

# 让我们的my_log 通过sh 进行日志输出处理
my_log.addHandler(sh)

#debug输出
my_log.debug("我来啦")
#error输出
my_log.error("我来啦")
#info输出
my_log.info("我来啦")
#warning输出
my_log.warning("我来啦")

import logging  # 导入我们的logging模块

# 我们写一条日志进去,其实里面有好多好多好多好多东西,比如写日志的时间,哪个函数写的日志,哪个级别的日志,当然还有我们的message信息
# 一大堆东西一起装进去,才算是一条日志哦

my_log = logging.getLogger("my_log")  # 创建一个我们log容器 名字叫my_log
my_log.setLevel(logging.DEBUG)  # 我们这个my_log容器 可以存放DEBUG及其以下界别的日志

# 容器已经有了,但是我们还没有显示信息的地方(比如在控制台,比如在文件),那么我们就来建立一个显示信息的地方
sh = logging.StreamHandler()  # StreamHandler 这就是流处理器,也就是咱们的控制台, sh 等于 我们实例化了一个控制台
sh.setLevel(logging.DEBUG)  # 这个sh控制台 只能显示Debug及其以下级别的日志信息

fh = logging.FileHandler("mylog.log")  # 这里我们建立一个文件处理日志的地方
fh.setLevel(logging.DEBUG) # fh 的日志输出级别


# OK我们得到了 控制台打印 信息了  , 但是 日志里面那么多信息,要拿出来什么呢?
# 就拿这些好了,时间+日志级别+message,用 时间 - 日志级别 : message 这种格式输出
my_log_fmt = logging.Formatter("%(asctime)s - %(levelname)s : %(message)s")  # 格式化 打印字符串
#如果不进行格式化处理的话,你直接输出日志的话,只能获得日志的message信息

# 只有在sh 这个控制台上输出的时候 使用 my_log_fmt 这种样式
sh.setFormatter(my_log_fmt)

# 只有在fh 这个文件上输出的时候 使用my_log_fmt 这种样式 样式可以在定制一个新的,这里我们就用同一个了
fh.setFormatter(my_log_fmt)

# 让我们的my_log 通过sh 控制台进行日志输出处理
my_log.addHandler(sh)

# 让我们的my_log 通过fh 文件进行日志输出处理
my_log.addHandler(fh)


#debug输出
my_log.debug("我来啦")
#error输出
my_log.error("我来啦")
#info输出
my_log.info("我来啦")
#warning输出
my_log.warning("我来啦")

本节结束,关于logging的打印问题,是初学者最头疼的,想学如果为一个项目导入日志模块的留言或者举手,或者大声的喊:"我要!"

 

三.2.锻炼逻辑思维弄得自己脑瓜子爆炸 之 re 模块

看到 re 我就脑瓜发热 对 re的汉语拼音 就是 热

re是正则匹配模块,根据你的条件要求,一点一点儿的将你的字符串匹配出来

记住两个常用的方法就好了

findall

import re
# 正则表达式 + 字符串
print(re.findall('\w','hello python 123'))
#['h', 'e', 'l', 'l', 'o', 'p', 'y', 't', 'h', 'o', 'n', '1', '2', '3']
print(re.findall('\w+','hello python 123'))
#['hello', 'python', '123']
print(re.findall('\d',"hello python 123"))
# ['1', '2', '3']
print(re.findall('\d+',"hello python 123"))
#["123"]

search

import re
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group())

#<h1>hello</h1>

正则:

大家如果觉得re模块很难的话,尽可能去掌握吧,因为对文件字符串筛选的话,只有re模块了

如果做爬虫的re模块也要会的,不过到时候你们学到爬虫的时候,需要不需要用re就不知道了,我只能帮你到这里了

本节结束,对不起大家,re 模块太头(e)疼(xin)了

 

三.3.除非你不是人类 之 time 模块

其实我就是告诉大家这个模块很常用,记住里面的几个方法就好

import time

print(time.time())  # 显示当前时间戳
time.sleep(1)  # 当前进程停顿 1 秒
print(time.ctime(1527774418.3636074)) # 时间戳转日期

#其他的方法大家可以试试,已经不是很重要了

这里给大家补充一个模块

import datetime
print(datetime.datetime.now())  # 这个就是拿到一个你能看得懂的时间字符串

 

三.4.不停的猜 猜 猜 又卜了一卦 之 random 模块

random 是随机模块,这里面的随机性太大了,老狠了

import random

# random
print(random.random())  # 0-1之间的小数
# randint
print(random.randint(0, 100))  # 0-100之间的整数
# choice
print(random.choice([1, 2, 3, 4, 5, 6]))  # 从可迭代对象中随机抽取一个
# sample
print(random.sample([1, 2, 3, 4, 5, 6], 3))  # 从可迭代对象中随机抽取3个

 

三.5.兄弟就靠你了 之 os 模块

 os 模块其实是集成了很多操作系统的方法,比如创建文件夹,拼接路径,删除文件,创建文件等等

import os
os.path.join("a","b") # 组合路径 a/b
os.system("ls") # 执行系统命令
os.sep() # 获取当前操作系统的路径分隔符 
os.path.dirname(__file__) # 获取当前文件的所在目录

 

三.6.只能前进不能后退的不归路 之 hashlib 模块

 乖,我咱们就说一个md5,其他的使用方法都一样啦

import hashlib
str = "abc".encode("utf8")
md = hashlib.md5(str) # 实例化一个MD5的摘要对象,并且给他一个utf8编码的bytes
print(md.hexdigest()) # 900150983cd24fb0d6963f7d28e17f72

需要带一嘴,md5只是单向的算法,一旦加密则不可逆

 

三.7.字符串字符串字符串 之 json 模块

 只要你是个说得上名的数据类型,我全给你弄成字符串,就问你服不服

import json

# 我们做一个字典
dic = {
    "name": "Dragon",
    "age": 20,
    "hobby": ["摩托车", "骑车"],
    "other": {
        "say": "hello",
        "see": "beautiful girl",
    }
}
json_dic = json.dumps(dic)  # json序列化

print(type(json_dic), json_dic)

# <class 'str'> {"name": "Dragon", "age": 20, "hobby": ["\u6469\u6258\u8f66", "\u9a91\u8f66"], "other": {"say": "hello", "see": "beautiful girl"}}

loads_dic = json.loads(json_dic) # json 反序列化

print(type(loads_dic), loads_dic)

# <class 'dict'> {'name': 'Dragon', 'age': 20, 'hobby': ['摩托车', '骑车'], 'other': {'say': 'hello', 'see': 'beautiful girl'}}

json 用于数据传输上,非常的爽

 

四.面向对象

1.面向对象的小概念

什么是面向对象,其实就是把某物抽象出来,再实例化的过程就叫面向对象

举个小例子,桌子是木头那么桌子可以归为木头类,板凳是木头可以归为木头类,那么生活中有无数的木头类的东西,都可以使用木头类

木头类中有什么属性呢?怕火,漂浮,可塑性等等

那么用木头做的桌子板凳是不是也可以漂浮啊,是不是也怕火啊,是不是也能把桌子凳子重新改良塑性啊

桌子用来摆放物品,凳子用来坐人,桌子也可以坐人但是不稳,凳子也可以摆放物品但是不稳

笼统的说,大家其实都知道这个概念,但是怎么用呢?

 

2.Class 与 def func 与 属性

类有属性,比如说木头怕火,就是木头的属性

class wool:
    fire = "燃烧了"
    water = "漂浮了"


zhuozi = wool()  # 实例化了一个桌子

print(zhuozi.fire)  # 看看桌子遇到火会怎么样
print(zhuozi.water)  # 看看桌子遇到水会怎么样

用木头做了一张桌子,桌子可以摆放物品.摆放物品就是方法

木头是不能摆放物品的,但是桌子可以,桌子是木头实例化出来的对象,并且还有了自己的方法

 

3.继承 派生 继承顺序 重载

继承 派生

class wool:
    fire = "燃烧了"
    water = "漂浮了"

class diske(wool): # diske 继承了wool ,那么diske就是 wool的派生类,也就是所谓的子类,wool就是diske的父类也叫超类
    name = "桌子"
    def baifang(self,obj):
        return f"{self.name}摆放了{obj}"

zhuozi = diske() # 实例化diske

print(zhuozi.name)
print(zhuozi.fire) # diske 是 wool  的子类 也同样继承了wool 中的fire属性
print(zhuozi.water) #diske 是 wool  的子类 也同样继承了wool 中的water属性

zhuozi.name = "Dragon的桌子" # 为diske中独有的属性name赋值
print(zhuozi.baifang("杯子")) # 执行摆放的方法

继承顺序

在Python中的面向对象很特殊,它有一个新玩儿法,就是多重继承,我一个类可以继承很多很多的类,换言之,一个儿子有一群爸爸(他的妈妈真的太幸福了)

class Wool:
    fire = "燃烧了"
    water = "漂浮了"

class Tools: # 我们有创建了一个工具类
    fire = "灭火" # 工具类遇到了火就要给他灭了
    def user(self):
        return "工具开始使用了"


class Diske(Tools,Wool,): # diske 既是Tools的子类也是Wool的子类,可以调用两个类里面的属性和方法
    name = "桌子"
    def baifang(self,obj):
        return f"{self.name}摆放了{obj}"

zhuozi = Diske() # 实例化diske

print(zhuozi.name)
print(zhuozi.fire) # 这里的fire的属性决定权在与谁是Diske的第一个含有fire属性的父类
print(zhuozi.water) 

zhuozi.name = "Dragon的桌子" # 为diske中独有的属性name赋值
print(zhuozi.baifang("杯子")) # 执行摆放的方法

 

4.多态(pep8,)

一个事物的多种形态

我们做个糖炒栗子

class Animal:
    def talk(self):
        return ".........."


class Dog(Animal):
    def talk(self):
        return "汪汪汪"


class People(Animal):
    def talk(self):
        return "Hello"


class TuBoShu(Animal):
    def talk(self):
        return "啊~!!!!!!!!!!"


class WuGui(Animal):
    pass


wu_pei_qi = People()
dog = Dog()
tu_bo_shu = TuBoShu()
wu_gui = WuGui()

print(wu_pei_qi.talk())
print(dog.talk())
print(tu_bo_shu.talk())
print(wu_gui.talk())


#看起来像,那么就是的概念

 

5.封装 __a

__变量 这样的话无法直接调用

def __方法名 这样的话,只能在对象内部调用无法通过实例化的对象调用

class MyFlies:
    __file_name = "mylog.log"
    def __open_file(self):
        with open(self.__file_name,"rb") as f:
            return f.read()

    def look_file(self):
        return self.__open_file()


new_file = MyFlies()

print(new_file.look_file())

 

6.classmethod  staticmethod

classmethod 类调用

staticmethod 只是定义在类里面的一个方法,类对象都可调用

class MyFlies:

    __file_name="mylog.log"

    @classmethod
    def open_file(cls,filename):
        print(cls.__file_name)
        with open(filename,"rb") as f:
            return f.read()

    @staticmethod
    def look_file(filename):
        print("根本不知道__file_name的存在")
        with open(filename,"rb") as f:
            return f.read()

    def self_open_file(self,filename):
        print(self.__file_name)
        with open(filename, "rb") as f:
            return f.read()


new_file = MyFlies()


print(new_file.look_file("mylog.log"))
print(new_file.open_file("mylog.log"))
print(new_file.self_open_file("mylog.log"))
print(MyFlies.open_file("mylog.log"))
print(MyFlies.look_file("mylog.log"))

 

7.反射 hashattr getattr setattr delattr

class DragonFire:
    name="123"
    age = 20

    def tall(self):
        return "aaaaaaa"

    def walk(self):
        return "wwwwww"


df = DragonFire()

print(hasattr(df,"tall"))
print(hasattr(df,"say"))

print(getattr(df,"walk",""))
print(getattr(df,"say","not func"))

setattr(df,"gender","Man")
print(df.gender)
print(df.__dict__)

delattr(df,"gender")
print(df.__dict__)

 

8.__方法概念

 

 

1.__setattr getattr delattr getattrbute__

2.__setitem

3.__init

4.__new

5.__str

6.__doc

7.__del

8.__call