文件操做，函数初始到起步，推倒式，迭代器，生成器

文件操做

只读

使用open()来打开一个文件,获取到文件句柄,而后经过文件句柄就能够进行操做

打开方式的不一样可以执行的操做会有相应的差别

打开文件的方式:

r,w,a r+,w+,a+ rb,wb,ab

r模式 只读操做只能进行读取

f=open('文件名称',mode='操做方式',encoding='编码类型')
f.read()  读取
f.close() 关闭文件
f.readline()读行
f.redlines()逐行读取

open中第一个参数放入的是要打开的文件名字,第二个参数是要对这个文件进行什么样的操做,第三参数使用谁让你买编码方式打开文件汇总的内容.

f能够写成任意变量,被称为文件句柄,文件操做符,或者文件操做对象等,open是python调用的操做系统的功能,windows的默认编码方式为gbk,Linux默认编码为utf-8,因此文件用什么编码保存的,就用什么方法打开,mode为打开方式,常见的有r,w,a,r+,a+,w+,rb,wb,ab等 默认不写是r,流程就是打开文件,产生一个文件句柄,对文件句柄进行相应操做,关闭文件.

rb模式:只读字节

f=open('文件名字',mode='rb) #注意在rb,wb,ab,模式不能写encoding

s=f.read()

print(s)

获得的是字节bytes类型

rb做用:在读取分文本的文件的时候,好比读取图像,MP3视频等,就会须要用到rb,由于这种数据是没有办法直接写出来的

用于本身的传输和储存.

相对路径和绝对路径

相对路径:就是在同一级里找,同一个文件夹下,直接写文件名就能够

绝对路径:在电脑磁盘进行查找文件的路径,至关于不知道在哪而后去别的地方找,一直找到文件名

转义

有时候你输入路径的时候

C:\user\ner   #这个\n会成为换行符,防止被转义就须要
    #两种方法能够防止转义
    1.C:\\user\\ner  #双斜杠
    2.r'C:\user\ner  #前面加r

覆盖写 w

写文件的时候要养成好习惯 写完就刷新 flush()

f=open("文件",mode='w',encoding='utf-8')

f.write("内容")

f.flush()

f.close()

当使用w模式的时候,打开文件就会把文件先清空,而后再写入.注意在覆盖写的时候,在打开文件的时候就会把文件清空,

w操做不能够进行进行读取

wb模式,不能够打开文件的编辑,可是写文件的时候必须将字符串转换成utf-8的bytes数据

f=open("文件",mode='wb') 注意必定要不能写encoding

msg='你好'.encode(utf-8)

f.write(msg)

f.flush() #刷新

f.close()

追加a,ab,a+

都是在文件末尾添加,追加,不论光标位置

a,w模式若是文件不存在,都会建立一个新的文件

f=open('内容',mode='a',encoding='utf-8')

msg=f.write("这糖化了之后")

读写模式 r+

读写顾名思义,必定是先读后写,由于光标默认是在前面,当读完了之后,光标读到最后,再进行写

r+模式

f=open("文件名称",mode='r+',encoding='utf-8')
s=f.read()
f.write("针棒")
f.flush()
f.close()
print(s)
#正常的读取,写在结尾

r+模式的坑

在进行读写操做后,若是读取了内容不管多少,光标显示的是多少,再写入或者操做文件的时候都是在结尾进行操做的.

写读模式 W+

f=open("文件名",mode='w+',encoding='utf-8')

先把内容清空,而后写入,而后再读取,可是读取内容是空的,不经常使用

f=open("文件名",mode='w+',encoding='utf-8')
f.write("xiaogui")
s=f.read()
f.flush()
f.close()
print(s)
读取不到内容,和覆盖写同样,都会清空再写内容

追加读 a+

f=open("文件名",mode='a+',encoding='utf-8')
f.write('内容')
f.flush()
s=f.read()
f.close()
print(s)
a+模式下,不管是先读仍是后读都是读不到数据的

其余操做

seek()是移动光标的位置,移动单位是byte字节,全部若是是utf-8的中文部分要是三的倍数

一般用seek都是移动到开头挥着结尾

移动到开头 seek(0,0)

移动到结尾seek(0,2)

移动到当前位置 seek(0,1)

移动一个字:seek(3) 移动光标是按照字节进行移动的

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0,0)将光标移动到开头
s=f.read()  读取内容,此时光标读取完之后移动到结尾
print(s)
f.seek(0)  再次移动到开头
f.seek(0,2)  移动光标到结尾
s1=f.read()   由于光标移动到结尾 因此什么也没读取到
print(s1)
f.seek(0)  将光标移动到开头 
f.write("战鼓啊")写入信息,如今光标在9  由于中文的utf-8编码一个中文三字节,3*3=9
f.flush()
f.close()
f.tell()   查看光标位置

tell 查看光标位置:

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0)移动光标到开头
s=f.read()  读取内容,光标移动到结尾 
print(s)
f.seek(0)    开头
f.write("美滋滋")  三个字 9个字节 
f.tell()  查看光标位置 9

修改文件

文件修改,只能将文件中的内容读取到内存中,将信息修改完毕后删除源文件,将新文件的名字改为旧文件的名字

1. 弊端操做,一次将全部内容就行读取,内存溢出

import os
with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\    #读
open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:      #写
    s=f1.read()
    new_s=s.replace("冰糖葫芦","大白梨")
    f2.write(new_s)
os.remove('文件路径') #删除原文件
os.remove("新文件笔记","旧文件名") #重命名新文件

1. 解决方案:一行一行读取和操做

import os
with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\   #旧 读
open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:     #新 改
    for line in f1:
        new_line=line.replace("大白梨","冰糖葫芦")
        f2.write(new_line)
os.remove("小娃娃")  #删除源文件
os.remove("新文件","源文件")  #重命名新文件

1. 读行 f.readline() 读一行 自动换行
2. print(f.readline() .strip()) 读多行 去除换行符
3. print(f.readslines()) 一行一行的读取,存放在列表中
4. 利用for 循环进行一行一行的获取

函数初始

函数

用函数来实现len
s=[1,2,3,4,5]
count=0
for i in s:
    count+=1
print(count)

一、函数的定义：将可重复使用的，实现某种功能的代码段组织在一块儿
二、函数的语法：
def 函数名(参数)：
函数体
return
2.一、函数名是一个变量，所以命名规则需遵照变量命名规则

三、函数的调用
函数名()
四、函数的返回值
return 可空、None、单个、多个的话 以tuple返回给调用者
五、函数的参数：
函数定义时声明的变量的叫形参
一、位置参数
二、默认参数
函数调用时传给函数的叫实参
一、位置参数
定义多少个，调用时也必须传多少个
二、关键字参数
三、混合参数

函数的调用

使用函数名加括号就能够调用函数了当写到函数名加括号,这个函数体就会被执行

def len():
    s=[1,2,3,4,5]
    count=0
    for i in s:
        count+=1
    print(count)
len()   #函数的调用

函数的返回值

def func():
    print("1")
func()
func()
func()   #屡次调用

这样就能够屡次调用函数

函数的返回值return

def func():
    print(1)
    return
func()
return 吧这个结果返回给了调用者 由于return后面没有跟东西 因此默认返回None,而且return之后后续代码再也不执行,函数的返回值有多个结果的时候就是返回一个元祖,调用者也能够经过解构得到多个变量,返回给函数的调用者,没有return也是默认返回None

总结return

1. 遇到return,此函数结束,return代码不会执行
2. return默认是返回None,后面多个返回值是一个元组形式

位置参数需在关键字参数以前

1. 函数的参数

   参数是函数括号里的内容,函数在调用的时候回指定一个具体的变量的值,就是参数
   def 函数名(参数):
    函数体
   
   def func(chat):    #形参
       print('打开+chat')
   func(chat)          #实参
   在调用的时候给chat一个值再执行函数体

   2.形参与实参

   • 形参,写在函数声明的位置交形参,形式上的完整,表示这个函数须要xxx
   • 实参:写在函数的调用的时候给函数传递的值,加实参,实际执行的时候给函数传递的信息,表示给函数xxx
   • 传参:从调用函数的时候讲值传递到定义函数的过程叫作传参

   3.参数的分类

   def func(a,b,c=1):   #形参 a,b是关键字参数,c是默认参数  排序就是位置>关键字>默认
       prin(a)
       print(b)  
       print(c)     #形参就是变量名 实参就是指 传参就是把值赋值给形参
       func(a=2,b=3)   #实参

   def func(a,b):
    print(a+b)
   s=func(1,2)
   print(s)

   1. 总结参数:位置参数,关键字参数,混合参数 位置参数必须在关键字参数前面
      • 位置参数,按照位置来赋值
      • 关键字参数,经过关键字来查找参数
      • 默认值参数:有默认值参数一般用默认的值,下面的实参若是给默认值参数赋值,那就会改变成实参赋予的值

用while循环实现for的本质;

s=[1,2,3,4,5]
n=s.__iter__()  #迭代器
while True:
    try:
        print(n.__next__())
    except StopIteration:
        break

动态参数,名称空间,函数嵌套

函数的动态参数

1. *args是万能的位置函数,接收任意多个 args能够变,程序猿统一用args 定义函数时"*"叫聚合,在参数位置用*表示接受任意参数,默认值参数放在动态位置参数后面,这样不会覆盖默认参数的值
2. 顺序就是
   • 位置顺序 : 位置参数>动态位置参数>
   • def song(*args) 这个里面的*\叫作聚合,聚合得到的结果是个元组
   • print(a,b,*args)这个里面的叫作打打散,打散能够得到各个元素.
   • 动态接收参数的时候注意:动态参数必须在位置参数后面
   • 形参的顺序:位置参数>动态参数>默认参数

3.**kwargs 得到的是一个dict字典,接受的关键字参数 *kwargs这个星是能够取这个字典的键 **kwargs万能传参(动态关键字参数)

参数的优先级:位置参数>动态位置参数args>默认参数>kwargs动态关键字参数

1. 万能传参:动态位置参数,动态关键字参数
2. def song(*args,**kwargs):
3. 位置参数>动态位置参数

函数的注释

def func(a,b):
    '''
    逻辑判断...
    :param a:str
    :param b:int
    return:bool
    '''
    print(a,b)
   
def func(user,password):
    '''
    密码加密
    :param user:用户名 str
    :param password:密码 str
    :return:加密的密码 MDS
    '''
    print(user,password)
 
print(func.__doc__)
print(func2.__doc__)
print(func.__name__)

名称空间

print(b)
a=10
def func():
    b=20
    print(b)
   
内置空间:print input len  这是python自带的内置空间
全局空间:当前py文件须要开辟的孔家存放在全局空间
局部空间:函数中开辟的空间都是局部空间
  
加载顺序:
    内置空间>全局空间>局部空间
取值顺序:
    局部空间>全局空间>内置空间(还找不到就会犯错)
    
做用域:
    全局做用域:内置空间+全局空间
    局部做用域:局部空间

函数的嵌套

def song():
    print(1)
    def fan():
        print(2)
    return fan()
song()
1,2
____________________
def song():
    a=1
    def jia():
        b=2
        print(b)
        print(a)
        def fan():
            pring(b)
        return fan()
    return jia
song()
2 1 2
____________
def func():
    a=1
    foo()
    pring(a)
def foo():
    b=2
    print(b)
func()
    def a():
        a=1
        c=()
        print(c)
def b():
    b=2
    print(b)
def c():
    c=3
    print(a)
def run():
    a()
    
run()
____________________

def func():
    a=1
    def b():
        print(a)
def foo():
    b=1
    def z():
        print(func)
        print(b)
    ret=z()
    func()
    return ret
def run():
    foo()
print(run())
func 的内存地址 1 还有None
________________________
def func(a):
    foo(a)
def foo(e):
    b(e)
def b(c):
    print(c)
func(15)
15 
______________________
a=10
def func():
    a=10+1
    print(a)
func()
11 别被迷惑
________________
def f1():
    a=10
    print(a)
    def f2():
        a=15
        print(a)
        def f3():
            global a 
            a += 1
            print(a)
        print(a)
        f3()
    print(a)
    f2()
    print(a)
f1()
10 15 11 15 10 10 
__________________
a=10
def f1():
    a=10
    def f2():
        a=15
        def f3():
            global a
            a += 1
            print(a)
        print(a)
        f3()
    print(a)
    f2()
print(a)
f1()
10 10 15 11 
—————————————————————
a=100
def func():
    global a
    a=28
print(a)
func()
print(a)
100 28 
____________
a=10 
def func1():
    a=20
    def func2():
        nonlocal a
        a=30
        print(a)
     func2()
     print(a)
func1()
30 30
___________________
a=1
def fun_1():
    a=2
    def fun_2():
        nonlocal a
        a=3
        def fun_3():
            a=4
            print(a)
        print(a)
        fun_3
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)
1 2 3 3 3 1
#注意看这个没有被调用的函数
_______________________

global nonlocal

global:修改全局空间的变量对应的值

nonlocal:在外层的函数中修改局部空间变量值,彻底不涉及全局空间,只修改上一级离他最近的一层,最近的上一层没有继续往上走,知道找到最外层函数

三元运算符

三元运算符:变量条件成立的结果 条件的判断 条件不成立的结果

return a if a>b else b 
a = 10
b = 20
c = a if a> b else b
变量名 = 条件成立的结果 条件 条件不成立的结果

enumerate 枚举

自动排序

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它能够同时得到索引和值。

enumerate(可迭代对象,1) 1决定从几开始计数

li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
    print(i)
    (1, 'alex')
    (2, '引脚')
    (3, '女神')
    (4, '太白')
for index,name in enumerate(li,1):
    print(index,name)
    1 alex
    2 引脚
    3 女神
    4 太白
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　
    100 alex
    101 引脚
    102 女神
    103 太白

函数名的第一类使用对象,f格式化.递归,迭代器

函数名第一类对象及使用

第一类对象的特殊性:

能够当作值赋值给变量

def func():
    print("呵呵")
print(func)
a=func
a()  #函数调用 func()
a=func 那么 a+()就能够调用这个函数,吧这个函数赋值给一个变量,

当作元素存放在容器中

def func():
    print(func)
func()
lst=[func,func,func]
print(lst)
这个列表的每个元素都是函数func里面的内存地址

函数名能够看成函数的参数

def func():
    print(1)
def func1(fn):
    print(2)
    fn()          #执行传递过来的fn
    print("666")
func1(func)        #吧函数func当成参数传递给func1的参数fn

能够看成函数的返回值

def func():
    print(1)
    def fun():
        print("看我")
    return fun
fun=func()
fun()
1, 看我

f格式化

f-strings 是python3.6开始加入的格式化输出的新写法,这个格式化输出比以前的%s或者format高并且更加简化

结果F/f+str的形式,在字符换中想要替换的位置用{}占位,与format相似,可是这个能够直接识别

name=1
age=2
s=f'姓名:{name},性别:{age}'
print(s)
能够加任意表达式
print(f'{2*3}')   #6   直接运算结果
name='song'
print(f'所有大写:{name.upper()}')  SONG

字典也能够
teacher={'song':'jiafan'}
print(d"the teacher is {teacher['name']})  #大括号里查询字典键就能够导员元素
      
列表
lst=['song','jiafan']
      s=f'姓名:{lst[0]},年龄:{lst[1]}
      print(s)
     
也能够插入表达式
def func(a,b):
      return a+b
a=1
b=2
print(f'和+{func(a+b)}')

多行F
      name='1'
      age=2
      sex=1
      print(f'姓名{name}\
      性别{sex}\
      年龄{age}')

其余细节

print(f'{{{g}}}') 两个大括号 打印出啦就是一个大括号 四个就是俩 大括号里面不能出现标点符号 !,:{};

迭代器

可迭代对象定义:有不少私有方法,支持__iter__()方法的就是可迭代对象

迭代器:支持__iter__()方法和__next__()方法的就是迭代器

1. 查看对象内部的方法 一种是看源码 一种是经过dir()去判断里面到底有哪些方法

s=123
print(dir(s))
dir会返回一个列表,这个列表含有该对象的整型的全部方法名咱们就能够判断是否是可迭代对象了
print('__iter__()'in dir(s))   False 不支持

可迭代对象的优势:能够直观的查看里面的数据,

缺点:占内存,可迭代对象不能迭代取值,出去索引,key之外

for 循环也是在底层作了一个小小的转化才能够迭代取值,将可迭代对象转化成一个迭代器

迭代器

1. 迭代器的定义:**在python中，内部含有__Iter__方法而且含有__next__方法的对象就是迭代器。**

2. 能够经过判断next方法和iter方法来判断哪些是迭代器,哪些是可迭代对象 文件句柄就是一个迭代器剩下的list tuple dict str set 都是可迭代对象

3. 可迭代对象如何转化成迭代器

   lst=[1,2,3,4,5]
   s=lst.__iter__()
   s=iter(lst)
   print(s)

4. 迭代器的取值:可迭代对象是不能够一直迭代取值的(出去索引,切片以及key)可是转化成迭代器就能够了他是利用__next__()取值的

   lst=[1,2,3,4]
   s=lst.__iter__()
   print(s)     #内存地址
   s1=s.__next__()
   print(s1)     #迭代器取得是值
   s1=s.__next__()
   print(s1)  
   迭代器是经过next取值的一个next取对应的一个值,若是迭代器里面的值取完了还有next那就StopIteration报错

5. while模拟for循环内部机制

   for循环对象必定是可迭代对象,可是不意味着可迭代对象就能够取值,由于for循环内部机制是:将可迭代对象转换成迭代器,而后用next进行取值,最后利用异常处理处理StopIteration抛出的异常

   s=[1,2,3,4,5]
   s1=s.__iter__()    #将可迭代对象转化成迭代器
   while True:   利用while循环,next进行取值
       try:      利用异常处理终止循环
           print(s1.__next__())
       except StopIteration:
           break

6. 迭代器优势:省内存,迭代器在内存只能怪至关于只占一个数据的空间,由于每次取值上一条数据会在内存释放,加载当前的此条数据

   惰性机制:next一次,取一个值毫不过多取值

7. 迭代器的缺点:

   不能质管的查看里面的数据

   取值是不走回头路,只能一直向下取值

8. 可迭代对象和迭代器的对比

   可迭代对象操做灵活,私有方法比较多,好比什么增删改查,比较直观,可是占用内存,并且不能直接经过循环迭代取值的这么一个数据集

   应用:若是你侧重于对于数据能够灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择

   迭代器:是一个很是节省内存的,能够记录取值位置,能够直接经过for循环加next方法取值,可是不直观,操做方法比较单一的数据集

   应用:当你的内存空间比较紧凑的时候,数据量过大的时候,将数据集设置为迭代器是一个不错的选择,

递归:知足两个条件

1. 自身调用自身
2. 有明确的终止条件

生成器,推导式,内置函数一

1.生成器

1. python里面三种方式来建立生成器

   • 经过生成器函数
   • 经过生成器推导式
   • python内置函数或者模块提供,python提供的生成器函数
2. 把return换成yield就是生成器

def func():
    print(111)
    yield "222"
g=func()          #这个时候函数不会执行,而是获取到生成器
print(g.__next__()) #这个时候函数才会执行
                    #而且yield会将func生产出来的数据222给了g.__next__()
    结果
    111
    222

1. return和yield都是返回

2. yield会记录执行位置

3. return能够写多个,可是只会执行一次,能够终止函数,并给函数的调用者返回值知识

4. yield能够写多个会记录执行位置,还能够返回屡次,不会终止函数,next会把这个yield对应的内容

   def func():
       yield "hehe"
       yield "hehe"
       yield "hehe"
   g=func()
   ret=g.__next__()
   print(ret)
   ret1=g.__next__()
   print(ret1)
   ret2=g.__next__()
   print(ret2)
       #必须一一对应 要不会报错 一个yield对应一个next

   5.yield能够在函数内部将for while 循环进行临时暂停

   6.next()==__next__() iter()==__iter__() python2和python3中都有next() python2只有next()方法 推荐next()

send()方法(了解)

send和next的区别

相同点:send和next()均可以让生成器对应的yield向下执行一次,均可以获取到yield生成的值

不一样: 第一次获取yield值只能是用next不能用send(能够用send(None))send能够给上一个yield值传递值

yield from

python3提供一种能够直接把可迭代对象中的每个数据做为生成器的结果进行返回

yield将可迭代对象元素逐个返回

def func():
    lst=[1,2,3,4,5]
    yield lst
g=func()
print(g)        #返回func内存地址
print(next(g))  #只是返回一个列表


def func():
    lst=[1,2,5,3,4]
    yield from lst    
g=func()
print(g)      #内存地址
print(next(g))#  返回的是一个列表的元素   多了也会报错

def func():
    lst=[1,2,3,4,5]
    lst1=[9,8,7,6,5]
    yield from lst1    #先执行这个lst1列表的元素
    yield from lst     #挨个返回后再执行lst的元素
g=func()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

2.推导式

1. 列表推导式

向列表中添加1~10
print([i for i in range(10)])
简洁 推导这个从0-9十个数的打印
lst=[]
for i in range(10):
    lst.append(i)
print(lst)

1. 列表推导式分为两种模式:

   • 循环模式:[变量(加工的变量)for 变量 in iterable ]
   • 筛选模式:[变量(加工的变量)for 变量 in iterable if条件]

   3.循环模式

   lst=[i*i for i  in range(10) ]  十之内数字的全部整数平方
   这个i*i就是加工的变量
   lst=[f'python{i}期'for i in range(10)]
   print(lst)
   从python0期到python9期
   f'python{i}期'就是加工的变量

   3.筛选模式

   筛选模式就是在上面基础上添加一个条件判断,而后将知足条件的添加到列表中

   把lst=[1,2,3,4,5,6,7,8]这个列表中的大于三的留下来
   lst=[1,2,3,4,5,6,7,8]
   print([i for i in lst if i>3])
   
   把列表元素长度小于三的筛选掉 把剩下的所有大写
   l = ['wusir', 'laonanhai', 'aa', 'b', 'taibai']
   print([i.upper() for i in l if len(i)>3])

   找到嵌套列表中名字含有两个‘e’的全部名字（有难度）
   names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
            ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
   
   print([name for lst in names for name in lst if name.count('e') >= 2])  
   # 注意遍历顺序，这是实现的关键

   4.生成器表达式

   生成器表达式和列表推导式的语法如出一辙,只是把[]换成()就好了

   好比八十之内的全部丨的平方放到一个生成器表达式中
   s=(i**2 for i in range(10))
   print(s)
   获得是内存地址
   #生成器表达式也能够进行筛选
   获取1-100能被三整除的数
   s=(i for i in range(100) if i%3==0)
   for i in s:
       print(i)

   生成器表达式和列表推导式的区别:

   1. 列表推导式比较消耗内存,全部数据一次性加载到内存.而生成器表达式遵循迭代器协议,逐个产生元素
   2. 获得的值不同,列表推导式获得的是一个列表,生成器表达式获取的是一个生成器.
   3. 列表推导式一目了然生成器表达式知识一个内存地址.

   生成器的惰性机制:生成器只有在访问的时候才取值,找他要才给你值,不要就不会执行

   字典推导式:

   lst=[1,2,3]
   lst1=["nihao","hello","hey"]
   dic={lst[i]:lst[i] for i in range(len(lst))}
   print(dic)

   集合推导式;生成一个集合,集合特色无序不重复 因此结婚推导式自然去重

   print({i for i in [-13,-13,2,2,3] })

3.内置函数一

s = """for i in range(10):    print(i)"""s1 = """def func():    print(123)func()"""print(eval(s))print(exec(s1))  # 牛逼 不能用print(hash("asdfas"))print(help(list))help(dict)def func():    passprint(callable(func))  # 查看是否可调用print(float(2))     # 浮点数print(complex(56))  # 复数print(oct(15))        # 八进制print(hex(15))        # 十六进制print(divmod(5,2))     # (2, 1) 2商 1余print(round(5.3234,2))     # 四舍五入 -- 默认是整数,能够指定保留小数位print(pow(2,3))            # 幂print(pow(2,3,4))          # 幂,余s = "alex"print(bytes(s,encoding="utf-8"))print(ord("你"))    # 当前编码print(chr(20320))s = "C:\u3000"print(repr(s))print("\u3000你好")lst = [1,2,3,False,4,5,6,7]print(all(lst))   # 判断元素是否都为真  类似andprint(any(lst))     # 判断元素是否有真    类似orname = 1def func():    a = 123    # print(locals())    # print(globals())func()print(globals())   # 全局空间中的变量print(locals())   # 查看当前空间的变量

这些是不经常使用的内置函数,了解便可