Python全栈开发知识点总结

变量

# 概念: 把程序运行过程中产生的中间值保存在内存.方便后面使用.
# 命名规范:
1. 用数字.字母.下划线组成
2. 不能用数字开头. 更不能是纯数字
3. 不能使用python的关键字
4. 不要用中文
5. 不要太长   # 前端除外
6. 要有意义
7. 区分大小写
8. 推荐使用驼峰或者下划线
  每个单词的首字母大写(大驼峰,小驼峰是第一个单词的首字母小写,其余的首字母大写.)
  用下划线分隔每个单词

格式化输出

%s 字符串占位符(但是所有的数据类型都可以使用)
%d 数字占位符(只能int类型使用)
f"{变量}"  

name = input("请输入你的名字:")
address = input("请输入你来自哪里:")
wife = input("请输入你的老婆:")
notlike = input("请输入你不喜欢的明星:")

# 需要掌握的内容===============
# 格式化输出  %s
print("我叫%s, 我来自%s, 我老婆是%s, 我不喜欢%s" % (name, address, wife, notlike))
# 新版本的格式化输出 f"{变量}" 
print(f"我叫{name}, 我来自{address}, 我老婆是{wife}, 我不喜欢{notlike}")
# 坑, 如果这句话使用了格式化输出. % 就是占位, 如果想显示正常的%   %% 转义
print("我叫%s, 我已经度过了30%的人生了" % "俞洪敏") # 报错 not enough arguments for format string
print("我叫%s, 我已经度过了30%%的人生了" % "俞洪敏")

 

注意:
　　在字符串中如果使⽤了%s这样的占位符,那么所有的%都将变成占位符,我们需要使用%%来表示字符串中的%.

　　   如果你的字符串中没有使用过%s,%d占位.,那么不需要考虑这么多, 该%就%.没毛病老铁.

print("我叫%s, 今年22岁了, 学习python2%%了" % '王尼玛') # 有%占位符 
print("我叫王尼玛, 今年22岁, 已经凉了100%了") # 没有占位符

 

# 格式化输出  format
s12 = "我叫%s, 今年%d岁了, 我喜欢%s" % ('sylar', 18, '周杰伦') # 之前的写法 
print(s12)
s12 = "我叫{}, 今年{}岁了, 我喜欢{}".format("周杰伦", 28, "周润发") # 按位置格式化 
print(s12)
s12 = "我叫{0}, 今年{2}岁了, 我喜欢{1}".format("周杰伦", "周润发", 28) # 指定位置 
print(s12)
s12 = "我叫{name}, 今年{age}岁了, 我喜欢{singer}".format(name="周杰伦", singer="周润发", age=28) # 指定关键字
print(s12)

  

逻辑运算符

1,  优先级关系为   () > not > and > or 

2,  x or y , x为真，值就是x，x为假，值是y;

    x and y,  x为真，值是y,  x为假，值是x。 

#逻辑运算符 初级
'''
and : 并且. 左右两端同时为真. 结果才能是真
or : 或者. 左右两端有一个是真. 结果就是真
not : 非. 非真即假, 非假即真  不真-> 假  不假 -> 真
混合运算顺序: () => not => and => or  当出现相同的优先级的时候 从左往右算

'''
print(3 > 2 and 4 < 6 and 5 > 7) # False
print(5 < 6 or 7 > 8 or 9 < 6 or 3 > 2)  # True
print(not 5 < 6)  # False
print(3 > 2 or 5 < 7 and 6 > 8 or 7 < 5)  # True
print(3 > 4 or 4 < 3 and 1 == 1)  # False
print(1 < 2 and 3 < 4 or 1 > 2)  # True
print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1) # True
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) # False
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # False
print((not 2 > 1 and 3 < 4) or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # False


#逻辑运算符 进阶
'''
优先级依然是:() > not > and > or
当出现 x or y的时候, 判断x是否是0 如果x==0 then y 否则返回x
当出现 x and y 的时候, 和or相反(or 要非0,and要0)
把False 当成0,True 当成1来看
'''
# 当出现 x or y的时候, 判断x是否是0 如果x==0 then y 否则返回x
print(1 or 2) # 1
print(0 or 2) # 2
print(3 or 0) # 3
print(4 or 0) # 4
print(0 or 3 or 0 or 2 or 0 or 5 or 0 or 188)  # 3

# 当出现 x and y 的时候, 和or相反
print(1 and 2) # 2
print(0 and 3) # 0
print(3 and 0) # 0
print(4 and 0) # 0
print(9 and 3 and 4 and 1 and 4 and 8)  # 8
print(1 and 2 or 3) # 应付面试  2
print(1 and 2 > 4)  # False

# False 当成0来看
print(False and 1)  # False
print(3 > 5 or 5 < 6 and 7)  # 7
print(4 > 5 or 7 and 8 < 6 or 3 and 4)  # 4
print(4>5 or (7 and 8<6) or (3 and 4)) #优先级顺序依旧存在  4

 

编码 

# 初识编码   ascii ==> gbk ==> unicode ==> utf-8
    1. ascii   8bit  1byte(字节)  256个码位 只用到了7bit, 用到了前128个 最前面的一位是0
    2. 中国人自己对计算机编码进行统计. 自己设计. 对ascii进行扩展 ANSI 16bit -> 清华同方 -> gbk
        GBK 放的是中文编码. 16bit  2byte 兼容ascii
    3. 对所有编码进行统一. unicode. 万国码.  32bit. 4byte. 够用了但是很浪费
    4. utf-8 可变长度的unicode
        英文: 1byte
        欧洲文字: 2byte
        中文: 3byte

''' 
# 记住结论就好啦!
1. ascii   8bit   1byte  包含了 英文, 数字, 特殊字符, 特殊操作符
2. gbk     16bit  2byte 主要包含的: 中文, 日文, 韩文, 繁体中文
3. unicode 32bit  4byte 万国码
4. utf-8
    英文: 8bit 1byte
    欧洲: 16bit 2byte
    中文: 24bit 3byte
'''

小数据池 

小数据池只针対:整数(-5~256),字符串,布尓値.其他的数据类型不存在驻留机制

 

is和==

==判断左右两端的值是否相等 ==>住户
is判断左右两端内容的内存地址是否一致. ==>门牌号

 

 

动态传参

1.形参: 在函数声明的位置写的变量
    1. 位置参数
    2. 默认值参数
    3. 动态传参
        *   聚合. 接收位置参数的动态传参
        **  聚合. 接收关键字参数的动态传参
    形参的顺序:
        位置 > *args > 默认值 > **kwargs

2.实参: 函数调用的地方写的具体的值
    1. 位置参数
    2. 关键字参数
    3. 混合参数:  位置 > 关键字
        *  把列表, 字符串, 元组打散成位置参数(实参传入多个列表的话,每个列表的前面都要加*)
        ** 把字典打散成关键字参数

def chi(*food):
    print("我要吃", food)  # 我要吃 ('⼤大⽶米饭', '⼩小⽶米饭')
    print(type(food))  # <class 'tuple'>

chi("⼤大⽶米饭", "⼩小⽶米饭")  #多个参数传递进去. 收到的内容是元组tuple
chi(*["⼤大⽶米饭", "⼩小⽶米饭"])  # *[列表] ==>打散成位置参数,等效于上面的调用



def he(**drink):
    print("我要喝", drink)  # 我要喝 {'a': '⼤大⽶米饭', 'b': '⼩小⽶米饭'}
    print(type(drink))  # <class 'dict'>

he(a="⼤大⽶米饭", b="⼩小⽶米饭")  #多个参数传递进去. 收到的内容是字典dict
he(**{"a":"⼤大⽶米饭", "b":"⼩小⽶米饭"})  # **[字典] ==>打散成关键字参数,等效于上面的调用




def func(*args, **kwargs):
    print(args, kwargs)

func("麻花藤" ,"马晕" ,wtf="胡辣汤")  # ('麻花藤', '马晕') {'wtf': '胡辣汤'}

 

闭包 迭代器

闭包 -> 函数的嵌套
    内层函数对外层函数(非全局)中的变量的使用
​
    好处:
        1. 保护变量不被侵害(#函数内部的变量都可以,因为在函数外部是无法调用函数内部的)
        2. 让一个变量常驻内存(#变量被使用就不会被垃圾回收机制回收)
​
    如何通过代码查看一个闭包
    函数名.__closure__: 有东西就是闭包. 没东西就不是闭包
​
迭代器 -> 固定的思路. for循环
    一个数据类型中包含了__iter__函数表示这个数据是可迭代的
    dir(数据): 返回这个数据可以执行的所有操作
​
    判断迭代器和可迭代对象的方案(野路子)
    __iter__            可迭代的(# dir(对象)包含__iter__ )
    __iter__  __next__  迭代器(# dir(对象)包含__iter__和 __next__)
​
    判断迭代器和可迭代对象的方案(官方)
    from collections import Iterable, Iterator
    isinstance(对象, Iterable) 是否是可迭代的
    isinstance(对象, Iterator) 是否是迭代器
​
    △使用while循环+迭代器来模拟for循环(#必须掌握):
    lst= ['a','b','c']
    # 拿迭代器
    it = lst.__iter__() # 获取到迭代器
    while 1:# 循环
        try:# 尝试
            print(it.__next__()) # 拿数据
        except StopIteration:# 出了错误, 意味着数据拿完了
            break# 结束循环
​
    迭代器特征:
        1. 省内存(生成器)
        2. 惰性机制
        3. 只能向前. 不能后退
​
    作用:统一了各种数据类型的遍历

生成器

# 各种推导式
列表推导式  [结果 for循环 for循环 if]  # 注意:多个for循环嵌套的话是按照正常写代码的for循环的顺序,前面的就是写在外层的for循环
字典推导式 {结果(k:v) for循环 if}
集合推导式 {结果(k) for循环 if}
生成器表达式 (结果 for循环 if)
​
生成器(函数)的特点:
  节省内存:生成器本身就是代码,几乎不占用内存
  惰性机制:没人要值就不会执行去拿值(# 要值的方式:gen.__next__(),gen.send('传值'),for i in gen,list(gen))
  只能向前,不能反复

# 生成器经典题
def add(a, b): # 相加
    return a + b

def test(): # 生成器函数 0  1   2  3
    for i in range(4):
        yield i

g = test()  # 创建生成器

for n in [2, 10]:
    g = (add(n, i) for i in g)

print(list(g))
# 结果:[20,21,22,23]
# 解题思路:惰性机制(#有人要值才执行);生成器记录的是代码(#只有在执行的时候才会带入变量的值)
# 1,拆分for循环
n = 2
g = (add(n, i) for i in g)
n = 10
g = (add(n, i) for i in g)
# 2,将g = test()代入,并层层带入
n = 2
g = (add(n, i) for i in test())
n = 10
g = (add(n, i) for i in (add(n, i) for i in test()))
# 3,拿值的时候带入变量的值去执行
print(list(g))  # 拿值list==>for==>__next__()
# 此时的
g = (add(n, i) for i in (add(n, i) for i in test()))
# 代入变量的值
# n = 10
# test()的取值范围是[0,1,2,3]
# 所以
# list(g) == [(add(10, i) for i in (add(10, i) for i in [0,1,2,3]))]==10*2+[0,1,2,3]
#         == [(add(10, i) for i in [10,11,12,13]]
#         == [20,21,22,23]


# 小结规律:
# test()的取值范围是初始范围
# 要拿值时候的n的值是要带入的值
# for循环决定循环的次数,循环几次就累加几次,也就是要加几个n的值


###############################################################################################

# 改变1
def add(a, b): # 相加
    return a + b

def test(): # 生成器函数 0  1   2  3
    for i in range(4):
        yield i

g = test()  # 创建生成器

for n in [2, 10]:
    g = (add(n, i) for i in g)
n = 5

print(list(g))
# 结果:[10,11,12,13]
# 解题思路同上,最终拿到
# g = (add(n, i) for i in (add(n, i) for i in test()))
# 而此时n=5,带入得到 5*2+[0,1,2,3]=[10,11,12,13]

#########################################################################################

# 改变2
def add(a, b): # 相加
    return a + b

def test(): # 生成器函数 0  1   2  3
    for i in range(4):
        yield i

g = test()  # 创建生成器

for n in [2, 10, 5]:
    g = (add(n, i) for i in g)


print(list(g))
# 结果:[15,16,17,18]
# 解题思路同上,最终拿到
n = 2
g = (add(n, i) for i in g)
n = 10
g = (add(n, i) for i in g)
n = 5
g = (add(n, i) for i in g)


# 层层代入得到:
n = 2
g = (add(n, i) for i in test())
n = 10
g = (add(n, i) for i in (add(n, i) for i in test()))
n = 5
g = (add(n, i) for i in (add(n, i) for i in (add(n, i) for i in test())))
# 代入数据得到:
list(g) =  (add(5, i) for i in (add(5, i) for i in (add(5, i) for i in [0,1,2,3])))=5*3+[0,1,2,3]=[15,16,17,18]

#区别生成器表达式和列表生成式:

    def add(a, b):
        return a + b
    
    
    def test():
        # print("123")
        for i in range(4):#[0,1,2,3]
            yield i
    
    g = test()
    
    for n in [2, 10, 5]:
        # 第一种:生成器表达式
        # g = (add(n, i) for i in g)  # [15, 16, 17, 18]在生成器表达式内部的生成器或者生成器表达式是不会执行的,直到外部的生成器有人找它要值
        # 第二种:列表生成式,是会直接带入执行的
        g = [add(n, i) for i in g]  # [17, 18, 19, 20]
    #第一种:
    # 对for循环进行等价替换,全部代入n=5
    # g1 = (add(5, i) for i in g)  #g = test()= [0,1,2,3]
    # g2 = (add(5, i) for i in g1)
    # g3 = (add(5, i) for i in g2)
    #第二种:
    # 对for循环进行等价替换,分别代入n=2,10,5
    # g1 = (add(2, i) for i in g)  #g = test()= [0,1,2,3]
    # g2 = (add(10, i) for i in g1)
    # g3 = (add(5, i) for i in g2)
    
    
    
    print(list(g))