1.Python基础
2.基本数据类型：str，dict，list，int
s="wzc" =>str
3.函数式编程
函数定义
内置函数
文件处理
注意：
li=[11,22,33,44]
def fi(arg):
arg.append(55)
fi(li)
print(li)
li=fi(li)
print(li)
结果：
[11, 22, 33, 44, 55] None
这里需要说明的是，函数默认返回的是None，所以我们在使用的时候需要通过参数引用
4.其他
三元运算
lambda表达式
s="哈哈"
bytes(s,encoding=utf-8)
False:[],{},(),None,0,""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
def f1():
pass
print(callable(f1))
结果：
True
中文说明：检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
注意：类是可调用的，而类的实例实现了__call__()方法才可调用。
版本：该函数在python2.x版本中都可用。但是在python3.0版本中被移除，而在python3.2以后版本中被重新添加。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
a=chr(65)
print(a)
b=ord("B")
print(b)
结果：
A 66
可以找到ascii码,也可以反向找出,数字转化为字母，字母转化为数字，这里面需要依赖ascii码的对应关系
产生随机数
andom.randrange这就是随机数字的范围.如果和chr相结合，就会有随机字母了，但是需要注意，acsii是有范围的，65-90就是大写字母的范围
这里面的范围，是1<=i<5的，所以在输入的时候需要后面一个加一位
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
import random
li=[]
num=0
for i in range(6):
r=random.randrange(0,5)
if r == 2 or r == 4:
c=random.randrange(0,9)
b=str(c)
li.append(b)
else:
c=random.randrange(65,91)
b=chr(c)
li.append(b)
num=0
re="".join(li)
print(re)
结果：
RVXWKA
这种是产生数字和英文相结合的随机验证码
1.读取文件内容open，str到内存
2.python，把字符串=》编译=》特殊代码
3.执行代码
Compile,就是用来编译代码的
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
s='print("123")'#将字符串编译成Python代码
r=compile(s,"string","exec")#这里的exec和下面的没有关系
print(r)
exec(r)#执行Python代码
结果：
<code object <module> at 0x0000000000D16C90, file "string", line 1> 123
Single:把上面的代码，编译成单行的Python程序
eval：编译成表达式
exec：编译成一模一样的模式
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
r1=exec("7+8+9")
print(r1)
r2=eval("7+8+9")#Eval:通过这个功能，可以将字符串，转化为表达式，并且去执行以下
print(r2)
结果：
None 24
Exec:要比eval更牛逼，exec能执行所有Python代码和字符串，而eval只能执行表达式
但是eval比exec多一个功能就是，eval有返回值，而exec没有
快速查看对象提供了哪些功能
print(dir(list))
分页功能
#!/usr/bin/env python # -*- coding: utf-8 -*- # Author:wzc r=divmod(99,10) print(r)
结果：
(9, 9)
分页功能就是通过计算得到商，同时可以得到余数。返回的是一个元祖
对象是类的实例
对象"wzc","www"他们的类就是"str"
对象[11,22,33],["w","z","c"]他们的类就是list
以此类推dict的类大家也就知道了
#!/usr/bin/env python # -*- coding: utf-8 -*- # Author:wzc a=["a","b"] r=isinstance(a,list) print(r)
结果：
True
Isinstance,判断对象是否是某个类的实例
这个和type 的区别，是isinstance是可以往上找，在基类里面会用到，而type不可以
filter(函数，可迭代的对象)
列表，元祖，字典，都是可迭代的对象
#!/usr/bin/env python # -*- coding: utf-8 -*- # Author:wzc li=[11,22,33,44,] def f1(arg): if arg > 22: return True ret=filter(f1,li) print(list(ret))
结果：
[33, 44]
在filter的内部，首先会去循环第二个参数，然后在每一次循环的内部执行第一个参数
#filter内部，循环第二个参数 #result=[] #for item in 第二个参数 # r=第一个参数(item) # if r: # result(item) #return result #filter循环函数第二个参数，让每个循环元素执行函数，如果函数返回Ture，表示元素合法
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
li=[11,22,33,44,]
def f1(arg):
if arg > 22:
return True
ret=filter(f1,li)
print(list(ret))
li=[11,22,33,44,]
ret1=filter(lambda a:a>33,li)
print(list(ret1))
ret=map(lambda a:a+100,li)
print(list(ret))
结果：
[33, 44] [44] [111, 122, 133, 144]
这样就可以通过lambda表达式也可以实现相同的功能
map(函数，可迭代的对象（可以for循环的东西）)
filter：函数返回Ture，并将元素添加到结果中
map：将函数返回值添加到结果中
frozenset():不可变集合
globals():所有的全局变量
locals():所有的局部变量
#!/usr/bin/env python # -*- coding: utf-8 -*- # Author:wzc s='wzcceqwediojdfiosjdjkfnjkwdhuiahjcnzkxcnx' print(hash(s))
结果：
1627539398160567879
在存储的时候，更多的是存一个hash值，其他语言也基本这样
#!/usr/bin/env python # -*- coding: utf-8 -*- # Author:wzc s="哈哈" print(len(s)) b=bytes(s,encoding="utf-8") print(len(b))
结果：
2 6
Python3是按照字符，Python2是按照字节,python3即可以通过字符，也可以通过字节来查看
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
s='{"k1":"v1"}'#里面必须是双引号，单引号不行
print(type(s),s)
import json
n=json.loads(s)#将一个字符串转换成Python基本数据类型{},[]
print(type(n),n)
结果：
<class 'str'> {"k1":"v1"}
<class 'dict'> {'k1': 'v1'}
要通过json转换的话，里面的元素必须用双引号，单引号不行
Max()：最大
Min()：最小
Sum()：求和
memoryview（）：和内存地址相关的一个类
object（）：一个类，所有类的副类
pow():求方，等同2**10==pow(2,10)
reverse():翻转，list.reverse()==reverse(list)
round():四舍五入
slice():取间隔，s="12345",print([0:2:2])功能相同
sorted():排序，list.sort()=sorted(list)
需要掌握的内置函数
装饰器:从外部装饰一个函数
开放封闭原则
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
# def f1():
# print("F1")
# def f2(xxx):
# xxx()
# f2(f1)
def outer(func):
def inter(*args, **kwargs):
print("before")
r=func(*args, **kwargs)
print("after")
return r
return inter
@outer
def f1(arg):
print(arg)
return "haha"
r=f1("heihei")
print(r)
print("#")
@outer
def f2(a1,a2):
print(a1,a2)
f2(11,12)
结果：
before heihei after haha # before 11 12 after
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
def f1():
print("F1")
def f2(xxx):
xxx()
f2(f1)
结果：
F1
函数是可以当做参数来做调用的，这里面的f1是执行的
def outer(func):
def inter():
print("before")
func()
print("after")
return inter
@outer
def f1():
print("F1")
f1()
结果：
before F1 after
@+函数
功能：
1、自动执行outer函数，并将其下面的函数名f1当做参数传递
2、将outer函数的返回值重新赋值给f1
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author:wzc
def outer(func):
def inter(*args, **kwargs):
print("before")
r=func(*args, **kwargs)
print("after")
return r
return inter
@outer
def f1(arg):
print(arg)
return "haha"
r=f1("heihei")
print(r)
print("#")
@outer
def f2(a1,a2):
print(a1,a2)
f2(11,12)
结果：
before heihei after haha # before 11 12 after
当fi有参数的时候，装饰器outer也需要跟着有参数才可以执行
当有多个参数的时候，就可以用**来处理