python全栈学习笔记（十）

 

 

 

 

 

 

 

 

 

一般情况下，在函数内部是可以调用全局变量的，但是不能修改全局变量

如果想在函数内定义全局变量，需要使用到关键字 global，而且这种方式需要先定义，再赋值。

建议定义全局变量全是大写字母，小写全是小写。

 

isinstance函数判断对象是不是某一类数据类型，返回bool值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def obj_len(arg):
    #如果是str、tuple、list
    #isinstance()
    if isinstance(arg,str) or isinstance(arg,list) or isinstance(arg,tuple):
        if len(arg) > 5:
            return True
        else:
            return False
    return None

temp = 123
ret = obj_len(temp)
print(ret)

结果：

None

关于函数的参数的内存地址：

在这里定义的函数里给args追加数字123，

当我们调用函数的时候，原本内存里的【11,22】是指向Li的，但是在调用函数的时候，把【11,22】临时指向了args（这里面其实是个引用的关系），当函数执行完以后，【11,22】又重新指向了Li，现在有两种方案：1、直接让【11,22】指向args，这样等函数执行完后，【11,22】再重新指向LI时已经变成【11,22,123】。

2、在内存里生成一个值一样的list【11,22】，让这个list指向args，这样函数执行完后Li引用的还是【11,22】

在C++、java这些语言里可以选择两个方案中的一种，但是python里只能是第一种

传参数的时候其实是传的这个值得引用，而不是传一个真实的值进去。

 

 

def func(args):
    args.append(123)

li = [11,22]
func(li)
print(li)

结果：

[11, 22, 123]

 

 

下面这种情况，输出的Li值还是【11,22，33,44】，

在没有执行arg =123之前，arg = Li = 【11,22,33,44】，arg引用的是LI的值

在 arg = XXX  如果XXX是真实的值，则内存会创建XXX值

在 arg = XXX  如果XXX是变量，则arg指向该变量的值         

因为函数里是把arg引用了另一个值123

 

 

在python里面，这里b = a【0:2】，在内存里面【11,22,33,44】是一个整体，b 不能直接引用其中的【1,2】，而是需要创建一个新list【11,22】再指向b。

 

b = a【0:2】 这里a【0:2】索引只负责找到值，而不在内存里生成对应的值，创建值得是= 赋值运算符

同理del a[0:2]  也是索引直接找到值，然后在原来的list里直接del删除

 

 

就算c获取到的是整个a的list的值，其id也是不一样的

 

a = [11,22,33,44]
b = a[0:2]
c = a[:]
print(id(a))
print(id(b))
print(id(c))
print(c)

结果：

9635520
9603792
9637440
[11, 22, 33, 44]

 

 

 

lambda表达式

对于简单的if---else可以使用三元表达式，对于简单的函数可以使用lambda表示

f1和f2相同，f3和f4相同

默认返回的是bool值

 

lambda隐藏了一个return，就算函数体里没有写return，它默认也是有的

 

 

 

内置函数

圈住的都是必须会的

 

 abs函数求绝对值：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
print(abs(-100))
print(abs(100))

结果：

100
100

all函数：循环参数，如果每个参数都为真，那么all的返回值为真：

all的参数接收一个可迭代对象

#!/usr/bin/env python
# -*- coding:utf-8 -*-
ret = [1,2,3,4,0]
ret2 = [2.3,4,5]
ret3 = [{},[],()]
print(all(ret),all(ret2),all(ret3))

结果：

False True False

any函数则区别于all函数，它只要参数里有个为真，则为真：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
ret = [1,2,3,4,0]
ret2 = [2.3,4,5]
ret3 = [{},[],(),1]
print(any(ret),any(ret2),any(ret3))

结果：

True True True

bin()可以把十进制转换成二进制的数  （我们看到的是以字节的方式表示出来）

int()可以把十进制转换成十进制的数   也可以把二/八/十六进制转换成十进制

oct() 可以把十进制转换成八进制

hex()可以把十进制转换成十六进制

 这几个函数我之前有讲过：：

#!/usr/bin/env python
# -*- coding:gbk -*-
# 二进制
r =bin(12)
print(r)
# 八进制
r1 = oct(12)
print(r1)
# 十进制
r2 = int(12)
print(r2)
# 十六进制
r3 = hex(12)
print(r3)

结果：

0b1100
0o14
12
0xc

 

 

bool函数接收一个参数，返回值为True 和False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
ret = [0]
ret2 = [{},()]
ret3 = []
ret4 = 0
print(bool(ret),bool(ret2),bool(ret3),bool(ret4))

结果：

True True False False

bytes() 把字符转换成字节，参数里需要指明字符的编码。

注意如果字符是文字：字符串的字节，以16进制表示，输出的字节通过for循环一个个打印出来，默认是10进制表示：

#!/usr/bin/env python
# -*- coding:gbk -*-
aa = '质量'
cc = bytes(aa,encoding='utf-8')
print(cc)
  for i in cc:
     print(i)

结果：

b'\xe8\xb4\xa8\xe9\x87\x8f'
232
180
168
233
135
143

 

但如果字符串内容是数字，字母，那默认输出是以就是字符，通过for打印出来的是十进制：

#!/usr/bin/env python
# -*- coding:gbk -*-
aa = 'abc123'

cc = bytes(aa,encoding='utf-8')
print(cc)
for i in cc:
    print(i)

结果：

b'abc123'
97
98
99
49
50
51

 

通过chr函数可以把一个数字转换成字符

通过ord函数把一个字符转换成数字

注意：只适用于ascii码

#!/usr/bin/env python
# -*- coding:gbk -*-
print(chr(97))
print(ord('b'))

结果：

a
98

 

divmod()函数，得到商和余数

用处：比如我们从数据库取出数据放到一个网页上，每个网页可以存放的条数是固定的，可以通过这个函数计算，只要有余数，就得多一页

#!/usr/bin/env python
# -*- coding:gbk -*-
a = 10/3
print(a)
c = divmod(10,3)
print(c)

结果：

3.3333333333333335
(3, 1)

 

不是什么数据都是可以执行的。callable可以检测是否可以指行

#!/usr/bin/env python
# -*- coding:gbk -*-
a = lambda :5 + 6
print(callable(a))
c = 19
print(callable(c))

结果：

True
False

compile是当python读取到字符串的时候，由它把字符串编译成可执行的代码：

 

eval可以直接把字符串转换进行计算：

#!/usr/bin/env python
# -*- coding:gbk -*-
a = '1+2+3+4'
print(eval(a))

结果：

10

 

如果字符串里面是类似下面的这种表达式，eval是不能执行的。可以使用exec函数，这个相当于把字符串里面的内容转换成了python的代码来执行，而且是直接执行：

#!/usr/bin/env python
# -*- coding:gbk -*-
exec('for i in range(1,11):print(i)')

结果：

1
2
3
4
5
6
7
8
9
10

 

 filter函数，通过筛选，把自己需要的选取出来：

fileter(函数，可迭代的对象)

 filter函数，通过筛选，把自己需要的选取出来:

 

map函数:

 

globals（）获取当前所有的全局变量

locals()获取当前所有的局部变量

 

hash通过他可以算出字符串的哈希值，一般用在dict上的key，如果key过长，会把key计算成哈希值，以达到key不占用过多的内存和快速读取的目的:

 

isinstance判断是什么数据类型:

 

next（）函数可以从可迭代的对象（生成器、迭代器）里面一个一个的取出数据:

 

 

max和min分别取最大值和最小值:

 

pow接收两个参数  指数和幂，相当于2**100:

 

round（）四舍五入

 

zip函数，

 

__import__可以给导入的模块起个别名

一般情况下导入模块后使用模块里的函数是这样的：

import random

random.randrange()

 

 

 sorted函数是排序用的，在python里只有同类型的数据才能排序:

 

字符串里有数字、字母、文字的情况下排序，数字优先，字母次之，最后文字

默认从小到大排序:

 

 

open文件操作

open函数，该函数用于文件处理

 

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

• r ，只读模式【默认】
• w，只写模式【不可读；不存在则创建；存在则清空内容；】
• x， 只写模式【不可读；不存在则创建，存在则报错】
• a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+， 读写【可读，可写】
• w+，写读【可读，可写】（先清空，在写的之后，就可以读了）
• x+ ，写读【可读，可写】
• a+， 写读【不可读，可写】

 "b"表示以字节的方式操作

• rb  或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+b

 注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

 

默认模式是只读r

 

一、打开文件

二、操作文件

三、关闭文件

open(文件名、模式、编码)

在windows里创建的文件使用的是gbk编码，需要指定编码，才能读取文件里的中文（python3才需要这样操作）

 

 

 

硬盘本质上存储数据是以bit二进制的方式，但是我们读取硬盘的数据的最小单位是Byte字节，

我们使用open 里的r（只读）模式读取数据的时候，python会帮我们把数据直接转换成字符串，大家都知道相同的数据使用不同的编码读取，结果是不一样的。

在只读模式中，对于编码会以系统的默认编码读取，比如windows的默认编码是gbk，linux高版本的是utf-8，py3的默认编码是utf-8，所以在py3里面读取windows的文件，是会报错的，除非能够指定编码encoding=‘utf-8’

 

open如果要以字节方式打开的话，不用加encoding进行编码

 

 

第一种输出和写入都是字符串类型

第二种输出和写入都是字节类型（使用socket时用到）

 

这里重复对一个open文件read，由于每读一次，指针就会向后偏移（可以使用tell方法查看指针），所以第二次就没读到，要想读到可以使用seek方法把指针拨回原来位置，f.seek(0)

 

 

 

open的读写都是通过指针来指向的，read方法可以指定指针位置，write就不行了，直接从最后面追加

 

这样读就是只读三个字符（在模式是r的情况下），如果模式是rb，则3表三个字节

 

data = f.read(3)

 

 

 

 

这几个是open的常用方法，需要记住:

 

一般情况下，我们open一个文件，最后还需要close文件

但是我们可以通过with关键字，比如下面，这个是固定搭配，open后面接参数，as 后面的f代指的就是open的文件，通过这种格式可以不用close文件

 

一般情况下，我们open一个文件，最后还需要close文件

但是我们可以通过with关键字，比如下面，这个是固定搭配，open后面接参数，as 后面的f代指的就是open的文件，通过这种格式可以不用close文件

 

 

 

 

内容小结：