python13_day4

上周复习

1，python基础

2，基本数据类型

3，函数式编程

函数式编程、三元运行、内置函数、文件处理

  • 容易出问题的点

    函数默认返回值为none，对于列表字典，传入引用。


    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    #函数没有返回值的时候返回none

    li = [11,22,33,44]

    def f2(arg):

        arg.append(li)

    ret = f2(li)

    print(ret)

    -----

    none

    #字典，列表等传值传引用

    li = [11,22,33,44]

    def f2(arg):

        arg.append(55)

    f2(li)

    print(li)

    -----

    [11, 22, 33, 44, 55]
  • 所有为False值

    所有空的  s=[],dict{},0,none,""

内置函数下

1，chr和ord:完成ASCI码和字符间的转换


1

2

3

4

5

6

7

8

9

r = chr(65)

print(r)

n = ord("a")

print(n)

-------

A

97

随机数小程序


1

2

3

4

5

6

7

8

9

10

11

12

#注意这里取得是A-Z(65-90)实际这里的应该用65-91，取头舍尾

import random

i = random.randrange(65, 91)

c = chr(i)

print(c)

------

L

#ord的使用

print(ord(‘a‘))

---

97

六随机验证码程序


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import random

li = []

for i in range(6):

    r = random.randrange(0, 5)

    if r == 1 or r == 4:

        num = random.randrange(0,10)

        li.append(str(num))

    else:

        temp =random.randrange(65,91)

        c = chr(temp)

        li.append(c)

result = "".join(li)

print(result)

------

FSVAW8

2，compile(),eval(),exec()

compile:将字符串编译成python代码。

eval：只能执行表达式，且有返回值。

exec：执行python代码，但是无返回值。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

s = "print(123)"

# 将字符串编译成python代码

r = compile(s, "<string>", "exec")

print(r)

exec(s)

s = "8*8"

ret = eval(s)

print(ret)

# exec无返回值

print(exec("7+9+8"))

# 执行表达式，并且获取结果

ret = eval("7+9+8")

print(ret)

-----

<code object <module> at 0x0000000000CF36F0, file "<string>", line 1>

123

64

None

24

3，dir:列出一个类给出了哪些功能（help）


1

2

3

4

print(dir(dict))

------

[‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘]

4，divmod:对一个数取余，且将结果的商和余数存入元组

eg：某网站有156条记录，要求每页显示10行，工多少页。


1

2

3

4

5

6

7

8

9

10

r = divmod(156, 10)

print(r)

print(r[0])

print(r[1])

# 下面简写

n1, n2 = divmod(156, 10)

------

(15, 6)

15

6

5，enumerat：列举，枚举

  • enumerate()是python的内置函数
  • enumerate在字典上是枚举、列举的意思
  • 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
  • enumerate多用于在for循环中得到计数
  • 例如对于一个seq，得到：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

# 上述方法有些累赘，利用enumerate()会更加直接和优美

list1 = ["这", "是", "一个", "测试"]

for index, item in enumerate(list1):

    print (index, item)

----------

0 这

1 是

2 一个

3 测试

#同样可以指定起始位置（注意起始位置）

list1 = ["这", "是", "一个", "测试"]

for index, item in enumerate(list1, 1):

    print(index, item)

----------

1 这

2 是

3 一个

4 测试

#统计文件行数的两种方式

count1 = len(open(‘db‘, ‘r‘).readlines())

print(count1)

count = 0

for index, line in enumerate(open(‘db‘,‘r‘)):

    count += 1

print(count)

----------

5

5

6，isinstance：判断对象是某个类的实例（bool值）。

 对象和类的关系：对象是类的实例

eg：s="alex"对象，他的类是字符串str。对象和类内部关联，在使用这个对象的时候就会调用换个对象类的方法。


1

2

3

4

5

6

7

8

9

s = "alex" # 对象，"alex" => str

s = [11,11,11]

# 用于判断，对象是否是某个类的实例

r = isinstance(s, list)

print(r)

-------

TRUE

7，filter：ret=filter（f2，li）（返回li中满足筛选条件f2的值，这里f2返回True元素才合法）

li：必须为可迭代的对象。f2：为执行条件。

  • filter（函数，可迭代对象）

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

# 传统方式实现

def f1(args):

    result = []

    for item in args:

        if item > 22:

            result.append(item)

    return result

  

li = [11, 22, 33, 44, 55]

ret = f1(li)

print(ret)

-------

[33, 44, 55]

 

#使用filter实现一

# print(filter(f2,li))

# filter内部，循环第二个参数

# result = []

# for item in 第二个参数:

#     r = 第一个参数(item)

#     if r :

#         result(item)

# return result

# filter ，循环循环第二个参数，让每个循环元素执行 函数，如果函数返回值True，表示元素合法

def f2(a):

    if a>22:

        return True

li = [11, 22, 33, 44, 55]

ret = filter(f2, li)

print(list(ret))

-----

[33, 44, 55]

#lambda表达式实现

f1 = lambda a: a > 30 #表达式返回bool值，通过bool值的结果来判断元素是否合法

ret = f1(10)

print(ret)

li = [11, 22, 33, 44, 55]

result = filter(lambda a: a > 33, li)

print(list(result))

------

False

[44, 55]
  • map：批量执行某一操作，返回值

    map(函数，可迭代的对象(可以for循环的东西))


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

#方式一，批量执行

li = [11, 22, 33, 44, 55]

def f2(a):

    return a + 100

 

result = map(f2, li)

print(list(result))

#方式二：lambda表达式

result = map(lambda a: a + 200, li)

print(list(result))

------

[111, 122, 133, 144, 155]

[211, 222, 233, 244, 255]

# filter  # 函数返回True，将元素添加到结果中

# map     # 将函数返回值添加到结果中

8,globals（）:所有的全局变量

locals（）：所有的局部变量

hash（）：生成哈希表，更虎字典key的保存

hex（）：将十进制转换16进制

9，len（） 查看字符串有多少个字节或者字符

  python2：只能按照字节看

python3：按照字节和字符都能看

10,callable:判断函数值能不能被执行，返回bool值


1

2

3

4

5

6

7

8

9

10

11

12

def f1():

    pass

# f1()

f2 = 123

# f2()

print(callable(f1))

print(callable(f2))

-----

True

False

11.max,min,sum 求最大值、最小值和求和


1

2

3

4

5

6

7

8

li = [11,22,33,44,55]

print(max(li))

print(min(li))

print(sum(li))

------

55

11

165

12.bin,oct,int,min 分别可以做二进制、八进制、十进制、十六进制的转换。  


1

2

3

4

5

6

7

8

9

10

a = 100

print(bin(a))

print(oct(a))

print(int(a))

print(hex(a))

-----

0b1100100

0o144

100

0x64

13. pow(2,10)表示的十次方


1

2

3

print(pow(2,10))

---

1024

14，reverse：反转

   round：四舍五入

   sorted：排序

    zip：把两个序列合起来变成一个元组


1

2

3

4

5

6

7

8

li = [11,2,44,223]

print(list(reversed(li)))

li.reverse()

print(li)

-----

[223, 44, 2, 11]

[223, 44, 2, 11]

1

2

3

print(round(1.8))

-----

2

1

2

3

4

5

l = [11,2,44,223]

lo = sorted(l)

print(lo)

------

[2, 11, 44, 223]

1

2

3

4

5

6

l1 = [11,2,44,223]

l2 = [22,2,44,223]

r = zip(l1,l2)

print(list(r))

------

[(11, 22), (2, 2), (44, 44), (223, 223)]

第三周作业 解析

raw_input 获取的用户输入是字符串


1

2

3

4

5

6

input_str = raw_input("请输入内容：")

#如：

#用户输入：123   则 input_str = "123"

#用户输入：hello 则 input_str = "hello"

#用户输入：{"k1":123, "k2": "wupeiqi"}   则 input_str = ‘ {"k1":123, "k2": "wupeiqi"} ‘

################# raw_input 获取到的输入都是字符串、字符串、字符串 !!!!!!! #################

因为raw_input 获取的是字符串，所以用户输入的 ‘ {"k1":123, "k2": "wupeiqi"} ‘ 不具有字典的特性，也就不能使用 dic[‘key‘] 来获取值

如果想要将用户输入的内容转换下格式，


1

2

‘{"k1":123, "k2": "wupeiqi"}‘       字符串转换成字典类型

"[11,22,33,44]"                     字符串转换成列表类型

################# 当当当当，python的json模块可以搞搞搞 !!!!!!! #################

json模块

json模块的作用之一：根据字符串书写格式，将字符串自动转换成相应格式


1

2

3

4

5

6

7

8

import json

inp_str = "[11,22,33,44]"

inp_list = json.loads(inp_str) # 根据字符串书写格式，将字符串自动转换成 列表类型

 

 

inp_str = ‘ {"k1":123, "k2": "wupeiqi"} ‘  # 正确的输入      切记，内部必须是 双引号 ！！！

#inp_str = " {‘k1‘:123, ‘k2‘: ‘wupeiqi‘}"   # 错误的输入

inp_dict = json.loads(inp_str) # 根据字符串书写格式，将字符串自动转换成 字典类型

学习json有什么用呢？本次作业可以用上哦！！！！！！！

作业实例：（谁要是再不清楚作业，看我下周带皮鞭去抽他...）

需求：

老板现在给你任务，公司有haproxy配置文件，希望通过python程序可以对ha配置文件进行增删改，不再是以往的打开文件进行直接操作了。

现有ha配置文件如下：

 现有ha配置文件

PS：以下只是实例，有好的想法也是可以的！


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

输出：

    1、获取ha记录

    2、增加ha记录

    3、删除ha记录

num = raw_input(‘请输入操作序号：‘)

如果用户输入的 1：

    read = raw_input(‘请输入backend：‘)     如输入：www.oldboy.org

    讲配置文件 backend www.oldboy.org 节点下的所有记录获取到，并输入到终端

如果用户输入的 2：

    read = raw_input(‘请输入要新加的记录：‘) 如： {"backend": "test.oldboy.org","record":{"server": "100.1.7.9","weight": 20,"maxconn": 30}}

    # 讲read字符串转换成 字典类型

    read_dict = json.loads(read)

    backend_title = read_dict[‘backend‘]

    # 去配置文件中找到指定的节点：

    # backend test.oldboy.org

    # 如果已经存在，

        # 则在此节点下添加根据用输入构造出的记录，例如：

            server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

    # 如果不存在，

        # 则添加backend节点和记录，例如：

    backend test.oldboy.org

        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

    # （可选）可以再对节点下记录进行判断是否已经存在

如果用户输入的 3：

    read = raw_input(‘请输入要删除的记录：‘) 如： {"backend": "test.oldboy.org","record":{"server": "100.1.7.9","weight": 20,"maxconn": 30}}

    # 讲read字符串转换成 字典类型

    read_dict = json.loads(read)

    backend_title = read_dict[‘backend‘]

    #去配置文件中找到指定的节点，并在删除指定记录，如：

    backend test.oldboy.org

         server 100.1.7.10 100.1.7.10 weight 20 maxconn 3000

         server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000   # 删除掉

    # （可选）如果backend下所有的记录都已经被删除，那么将当前 backend test.oldboy.org 也删除掉。

装饰器

软件开发的开放封闭原则：如果用户新增需求，对于原有的类和函数内部不要改，外部来修改功能。

装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

格式：@+函数名，放在要装饰的函数前面：自动执行wrapper函数，将foo函数作为参数传给wrapper


1

2

3

4

5

6

7

8

9

10

11

def wrapper(func):

    def result():

        print(‘before‘)

        func()

        print(‘after‘)

    return result

@wrapper

def foo():

    print(‘foo‘)

执行步骤：

  • 用户调用foo函数的时候，先执行wrapper函数。
  • 然后将foo函数整体作为一个参数传入给func这个形式参数。
  • 执行result函数。（1，打印before；2，执行func（），就是调用foo函数；3，打印after。）
  • 给出result函数的返回值。

1，准备知识

  • 如果一个函数返回值，则返回none
  • 把一个函数作为参数传入另外一个函数，则调用形式参数就是执行原函数
  • 如果一个函数那个过程中遇到return语句结束。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    def f1():

        print(123)

    def f1():

        print(456)

    f1()

    def f1():

        print(‘123‘)

    def f2(xxx):

        xxx()

    f2(f1)

    -----

    456

    123

2，装饰器参数（万能参数）

  •  使用这个样的装饰器可以接受万能参数，在函数调用的时候，只要传入了对应的参数均可行
  • ?注意装饰器中内部函数inner要接受原函数的返回值，保证原函数不受不受影响。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

def outer(func):

    def inner(*args, **kwargs):

        print(‘before‘)

        r = func(*args, **kwargs)

        print(‘after‘)

        return r

    return inner

# @ + 函数名

# 功能：

#     1. 自动执行outer函数并且将其下面的函数名f1当作参数传递

#     2. 将outer函数的返回值，重复赋值给 f1

@outer

def f1(arg):

    print(arg)

    return "砍你"

@outer

def f2(a1, a2):

    print("F2")

#

@outer

def f3():

    print("F3")

3，装饰器的主要应用（权限控制）

这段代码很好地控制了登陆权限，在每个需要登录的功能外部，通过装饰器，控制登陆状态。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

LOGIN_USER = {"is_login": False }

 

def outer(func):

    def inner(*args, **kwargs):

        if LOGIN_USER[‘is_login‘]:

            r = func()

            return r

        else:

            print("请登录")

    return inner

 

def outer1(func):

    def inner(*args, **kwargs):

        if LOGIN_USER[‘is_login‘] and LOGIN_USER[‘user_type‘] == 2:

            r = func()

            return r

        else:

            print("请登录,或者权限不够")

    return inner

 

@outer1

def order():

    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])

@outer

def changepwd():

    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])

@outer

def manager():

    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])

def login(user, pwd):

    if user == "alex" and pwd == "123":

        LOGIN_USER[‘is_login‘] = True

        LOGIN_USER[‘current_user‘] = user

        manager()

def main():

    while True:

        inp = input("1,后台管理；2,登录")

        if inp == ‘1‘:

            manager()

        elif inp == ‘2‘:

            username = input("请输入用户名")

            pwd = input("请输入密码")

            login(username, pwd)

main()


来自为知笔记(Wiz)

时间： 2024-10-09 12:46:15

python13_day4的相关文章