python整理-day4

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也需要跟着有参数才可以执行

当有多个参数的时候，就可以用**来处理