ChuannBlog

3.6 内置函数

内置的模块附带的函数：
内置函数

作用域相关0/2

locals() 打印局部作用域中的名字当函数很长的时候查看有哪些变量在函数中
globals() 打印全局作用域中的名字

str类型代码的执行2/3

eval(string) /eval(expression, globals=None, locals=None)
将字符串转换成python代码, 返回代码执行的结果

eval('print(*tuple(x**2 if x%2 == 0 else x**3 for x in range(1, 10)))')

while True:
    cmd = input('>>>').strip()
    eval(cmd)

本函数是用来动态地执行一个表达式的字符串，或者compile函数编译出来的代码对象。参数expression是一个表达式字符串，或者表示编译出来代码对象的名称；参数globals是全局命名空间，可以指定执行表达式时的全局作用域的范围，比如指定某些模块可以使用。如果本参数缺省，就使用当前调用这个函数的当前全局命名空间；参数locals是局部作用域命名空间，是用来指定执行表达式时访问的局部命名空间。如果全局命名空间参数出现，但缺省内置模块，那么会自动拷贝这个模块到全局命名空间，意味着无论怎么设置，都可以使用内置模块。如果两个命名空间，都使用缺省方式，就会使用调用这个函数时的命名空间来查找相应的变量。
为什么要使用这个函数呢？这个函数的原因，应该就是动态语言与编译语言的差别之处，因为在编译语言里要动态地产生代码，基本上是不可能的，但动态语言是可以，意味着软件已经部署到服务器上了，但只要作很少的更改，只好直接修改这部分的代码，就可立即实现变化，不用整个软件重新加载。另外一个，这个功能可以用来机器学习里，比如根据用户使用这个软件频率，以及方式，可动态地修改代码，适应用户的变化。想到这里，是不是具有生命力的能力，可以自我更新代码，实现改良式进步，如果做破坏性的动作，其实就是一个病毒。

#eval()  
  
print(eval('1 + 1'))  
  
#全局命名空间为空，使用局部命名空间  
def make_fn(code):  
    import math  
    ALLOWED_LOCALS = {v:getattr(math, v)  
        for v in filter(lambda x:  x.startswith('_'), dir(math))  
    }  
    return eval('lambda x: %s' % code, None, ALLOWED_LOCALS)  
      
f = make_fn('x + 1')  
print(f(2))  
  
#使用全局命名空间  
def make_fng(code):  
   import math  
   ALLOWED = {v:getattr(math, v)  
      for v in filter(lambda x: not x.startswith('_'), dir(math))  
   }  
   ALLOWED['__builtins__'] = None  
   return eval('lambda x: %s' % code, ALLOWED, {})  
     
f = make_fng('cos(x)')  
print(f(9))  
  
f = make_fng('cos(x*x)')  
print(f(9)) 

exec(string)
将字符串转换成python代码，不返回代码的执行结果
compile(str1, str2, mode=str3)
com = compile(“1+2+3”, ‘’, mode=’eval’)
- mode 有eval, exec, single
  - single模式能不用就不用，容易造成内存混乱，

未分类 7/11

input()

print(self, *args, sep=’ ‘, end=’\n’, file=None)

*args
sep 指定分隔符，默认为空格
end 指定结束符，默认为换行符
file 指定输出文件，默认为屏幕（终端），常用于写入日志

  # 进度条
  import time
  import sys
  for i in range(0, 101, 2):
      time.sleep(0.1)
      char_num = i//2      # 打印多少个
      per_str = '\r%s%% : %s' % (i, '*'*char_num)
      print(per_str, end='', file=sys.stdout, flush=True)

type(obj)
返回目标的类型，用于类型判断
id(obj)
返回目标的内存地址
hash(obj)
对不可变数据类型、函数名进行哈希
字典的对key的寻址就是将key值进行哈希算法得出数字得到内存地址
open(file, mode=’r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True)
- mode 有r,w,a和用于组合的b,+
  - 读写模式：不读的时候写的位置从头开始，读了之后则追加，指定光标则在指定光标读写
- encoding指定读文件的编码格式
import 用于导入模块
help([obj]) 不指定对象则进入help模式，q退出
指定对象则进入对象的说明

callable()
只返回True或者False，表示是否可调用

  def f():
      def g():
          return lambda x:x+1
      return g
	
  print(callable(f))
  print(callable(f()))
  print(callable(f()()))
  print(callable(f()()(1)))

dir([obj])
不指定对象则显示所有参数
指定对象则显示指定对象的参数

print(dir(list))
print(dir(tuple))
print(set(dir(list))-set(dir(tuple)))
print(set(dir(int))-set(dir(float)))
print(set(dir(dir))-set(dir(dir)))
print(set(dir(dir))-set(dir()))

基础数据类型相关 24/38

数字相关10/14

数据类型3/4

bool
int
float
complex
进制转换0/3
bin
oct
hex
数学运算7/7
min()
max()
sum() 接收序列类型然后求和
abs()
divmod() 返回（除，余）
pow()
round()
数据结构相关14/24

序列相关7/13

列表和元组2/2
list()
tuple()
相关内置函数2/2
reversed(obj) 反转序列，返回一个迭代器，需要强转才可以使用
slice()

l = [1, 2, 3, 4, 5, 6, 7, 8, 10]
print(l[slice(2, 3)])
print(l[slice(2, 3)])
print(l[2:3])

字符串3/9

str()
repr()
- 用%r进行格式化输出 print(repr(‘1234’)) print(repr(1234))
bytes() bytes(obj, encoding=’utf-8’)
- bytearray() 可以将字符串编码后得到的编码序列化，进行修改，且不改变字符串地址
- memoryview()
format()
print(format(‘test’, ‘<20’)) print(format(‘test’, ‘>20’)) print(format(‘test’, ‘^20’))
ord()
ascii
chr
数据集合3/3
dict()
set()
frozenset() 冻结集合，和集合的关系与列表和元组的关系类似
相关内置函数5/8
len()
sorted()
enumerate()
filter()
map()
all(seq) 判断序列里是否都是True，
any(seq) 判断序列里是否有True，
zip()

文件

函数 open() 返回文件对象，通常的用法需要两个参数：open(filename, mode, encoding=’utf-8’)。
filename之前的r表示rawstring：原生字符串，示意后续的字符串全都无特殊意义。

>>> f = open('workfile', 'w')
>>> open(r'D:\python\aaa.py')

open:
1. 会像操作系统发起系统调用，系统会打开一个文件
2. 在python主程序中会产生一个值指向操作系统打开的那个文件，我们可以把该值赋值给一个变量
回收资源：
1. f.close(),关闭操作系统打开的文件，即回收操作系统的资源
2. def f没必要做，python程序会在运行完毕之后自动清理与该程序相关的所有内存空间

第一个参数是一个含有文件名的字符串。第二个参数也是一个字符串，含有描述如何使用该文件的几个字符。

mode
- ‘r’ 时表示只是读取文件；光标在文件开头
- ‘w’ 表示只是写入文件（清空同名文件）；光标在文件开头
- ‘a’ 表示打开文件进行追加，写入到文件中的任何数据将自动添加到末尾。
- ‘r+’ 表示打开文件进行读取和写入。
- ‘a+’ 追加可读，
- ‘w+’ 可写可读，（鸡肋），打开文件时文件清空
  
  通常，文件以文本打开，这意味着，你从文件读出和向文件写入的字符串会被特定的编码方式（默认是UTF-8）编码。模式后面的 ‘b’ 以二进制模式打开文件：数据会以字节对象的形式读出和写入。这种模式应该用于所有不包含文本的文件。
  在文本模式下，读取时默认会将平台有关的行结束符（Unix上是 \n , Windows上是 \r\n）转换为 \n。在文本模式下写入时，默认会将出现的 \n 转换成平台有关的行结束符。这种暗地里的修改对 ASCII 文本文件没有问题，但会损坏 JPEG 或 EXE 这样的二进制文件中的数据。使用二进制模式读写此类文件时要特别小心。

文件对象方法

f.read([size])
该方法读取若干数量的数据并以字符串形式返回其内容，size 是可选的数值，指定字符串长度。如果没有指定 size 或者指定为负数，就会读取并返回整个文件。当文件大小为当前机器内存两倍时，就会产生问题。反之，会尽可能按比较大的 size 读取和返回数据。如果到了文件末尾，f.read() 会返回一个空字符串（’‘）:
```
  >>> f.read()
  'This is the entire file.\n'
  >>> f.read()
  ''
```
f.readline()
从文件中读取单独一行，字符串结尾会自动加上一个换行符（ \n ），只有当文件最后一行没有以换行符结尾时，这一操作才会被忽略。这样返回值就不会有混淆，如果 f.readline() 返回一个空字符串，那就表示到达了文件末尾，如果是一个空行，就会描述为 ‘\n’，一个只包含换行符的字符串:
```
  >>> f.readline()
  'This is the first line of the file.\n'
  >>> f.readline()
  'Second line of the file\n'
  >>> f.readline()
  ''
```

循环遍历文件对象
你可以循环遍历文件对象来读取文件中的每一行。这是一种内存高效、快速，并且代码简介的方式:

  >>> for line in f:
  ...     print(line, end='')
  ...
  This is the first line of the file.
  Second line of the file

f.readlines()&list(f)
把文件中的所有行读到一个列表中
f.write(string)
将 string 的内容写入文件，并返回写入字符的长度:
```
  >>> f.write('This is a test\n')
  15
```
想要写入其他非字符串内容，首先要将它转换为字符串:
```
  >>> value = ('the answer', 42)
  >>> s = str(value)
  >>> f.write(s)
  18
```
f.tell()
返回一个整数，代表文件对象在文件中的指针位置，该数值计量了自文件开头到指针处的比特数。需要改变文件对象指针话话，使用 f.seek(offset,from_what)。指针在该操作中从指定的引用位置移动 offset 比特，引用位置由 from_what 参数指定。 from_what 值为 0 表示自文件起始处开始，1 表示自当前文件指针位置开始，2 表示自文件末尾开始。from_what 可以忽略，其默认值为零，此时从文件头开始:
```
  >>> f = open('workfile', 'rb+')
  >>> f.write(b'0123456789abcdef')
  16
  >>> f.seek(5)     # Go to the 6th byte in the file
  5
  >>> f.read(1)
  b'5'
  >>> f.seek(-3, 2) # Go to the 3rd byte before the end
  13
  >>> f.read(1)
  b'd'
```
在文本文件中（没有以 b 模式打开），只允许从文件头开始寻找（有个例外是用 seek(0, 2) 寻找文件的最末尾处）而且合法的偏移值只能是 f.tell() 返回的值或者是零。其它任何偏移值都会产生未定义的行为。
f.close
当你使用完一个文件时，调用 f.close() 方法就可以关闭它并释放其占用的所有系统资源。在调用 f.close() 方法后，试图再次使用文件对象将会自动失败。
```
  >>> f.close()
  >>> f.read()
  Traceback (most recent call last):
    File "<stdin>", line 1, in ?
  ValueError: I/O operation on closed file
```
with：上下文管理
用关键字 with 处理文件对象是个好习惯。它的先进之处在于文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写:
```
  >>> with open('workfile', 'r') as f:
  ...     read_data = f.read()
  >>> f.closed
  True
```
其他方法
文件对象还有一些不太常用的附加方法，比如 isatty() 和 truncate() 在库参考手册中有文件对象的完整指南。
文件的修改

写一个新文件，重命名新文件替换原来的文件
```
import os
with open('a123', 'rb') as r_f, open('a123_swap', 'wb') as w_f:
  for line in r_f:
      w_f.write(line)
os.remove('a123')
os.rename('a123_swap', 'a123')
```

ChuannBlog

3.6 内置函数

作用域相关0/2

str类型代码的执行2/3

未分类 7/11

基础数据类型相关 24/38

数字相关10/14

数据类型3/4

进制转换0/3

数学运算7/7

数据结构相关14/24

序列相关7/13

列表和元组2/2

相关内置函数2/2

字符串3/9

数据集合3/3

相关内置函数5/8

文件

文件对象方法

文件的修改