全栈python总结_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个 最前面的一位是02. 中国人自己对计算机编码进行统计. 自己设计. 对ascii进行扩展 ANSI 16bit -> 清华同方 ->gbk

GBK 放的是中文编码. 16bit 2byte 兼容ascii3. 对所有编码进行统一. 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)) #

chi("⼤大⽶米饭", "⼩小⽶米饭") #多个参数传递进去. 收到的内容是元组tuple

chi(*["⼤大⽶米饭", "⼩小⽶米饭"]) #*[列表] ==>打散成位置参数,等效于上面的调用

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

print(type(drink)) #

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 +bdef test(): #生成器函数 0 1 2 3

for i in range(4):yieldi

g= test() #创建生成器

for n in [2, 10]:

g= (add(n, i) for i ing)print(list(g))#结果:[20,21,22,23]#解题思路:惰性机制(#有人要值才执行);生成器记录的是代码(#只有在执行的时候才会带入变量的值)#1,拆分for循环

n = 2g= (add(n, i) for i ing)

n= 10g= (add(n, i) for i ing)#2,将g = test()代入,并层层带入

n = 2g= (add(n, i) for i intest())

n= 10g= (add(n, i) for i in (add(n, i) for i intest()))#3,拿值的时候带入变量的值去执行

print(list(g)) #拿值list==>for==>__next__()#此时的

g = (add(n, i) for i in (add(n, i) for i intest()))#代入变量的值#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 +bdef test(): #生成器函数 0 1 2 3

for i in range(4):yieldi

g= test() #创建生成器

for n in [2, 10]:

g= (add(n, i) for i ing)

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 +bdef test(): #生成器函数 0 1 2 3

for i in range(4):yieldi

g= test() #创建生成器

for n in [2, 10, 5]:

g= (add(n, i) for i ing)print(list(g))

# 结果:[15,16,17,18]#解题思路同上,最终拿到

n = 2g= (add(n, i) for i ing)

n= 10g= (add(n, i) for i ing)

n= 5g= (add(n, i) for i ing)#层层代入得到:

n = 2g= (add(n, i) for i intest())

n= 10g= (add(n, i) for i in (add(n, i) for i intest()))

n= 5g= (add(n, i) for i in (add(n, i) for i in (add(n, i) for i intest())))#代入数据得到:

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]

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

defadd(a, b):return a +bdeftest():#print("123")

for i in range(4):#[0,1,2,3]

yieldi

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))