python 8---12

第八章

Python基础-文件操作

一.只读

.txt 编码：utf-8，gbk，gb2312… 模式：只读，只写，追加，写读，读写…

使用Python来读写文件是非常简单的操作,我们使用open()来打开一个文件,获取到文件句柄,然后通过文件句柄就可以进行各种各样的操作了

根据打开方式的不同能够执行的操作会有相应的差异.

打开文件的方式:

r, w, a

r+, w+, a+

rb, wb, ab

r+b,w+b,a+b

1.1 r 模式

只读操作 , 听名字应该也知道只能进行读不能进行别的操作

f = open('美女模特空姐护士联系方式.txt',mode='r',encoding='utf-8')
content = f.read()
print(content)
f.close()

 
结果:
标题很好

​ open 中第一个参数放入的是要打开的文件名字, 第二个参数是要对这个文件进行的操作, 第三参数是用什么编码方式打开文件中的内容

f 可写成任意变量等，它被称作：文件句柄，文件操作符，或者文件操作对象等。 open 是Python调用的操作系统（windows,linux,等）的功能，而windows的默认编码方式为gbk，linux默认编码方式为utf-8，所以你的文件用什么编码保存的，就用什么方法打开，一般都是用utf-8。 mode为打开方式：常见的有r,w,a,r+,w+,a+.rb,wb,ab,等，默认不写是r。 流程就是打开文件，产生一个文件句柄， 对文件句柄进行相应操作，关闭文件。

1.2 rb 模式

r只读, rb 只读字节的模式

f = open('护士少妇萝莉',mode='rb')
content = f.read()
print(content)
f.close()

 
结果:
b'\xe6\xa0\x87\xe9\xa2\x98\xe5\xbe\x88\xe5\xa5\xbd'

rb 读出来的数据是bytes类型, 在rb模式下, 不能encoding字符集

rb的作用: 在读取非文本文件的时候, 比如要读取 mp3, 图像, 视频等信息的时候就需要用到rb,因为这种数据是没办法直接显示出来的

这个字节的模式是用于传输和存储

好了,我们动手试一试.读文件吧,你们如果是在windows系统中用记事本创建的文件,在打开的时候会有问题,

是因为windows系统中记事本中写的内容编码是GBK我们要不将文件中编码改成utf-8 要不在open中第三个参数 中修改成utf-8

二.路径

2.1 相对路劲

以上代码中文件名使用的是相对路劲,什么是相对路劲呢???

就是相对于某个文件来说,进行路劲查找,以上代码是 相对于运行的文件.

如果相对还是太理解,来看下这列子:

你朋友要来找你,知道你在那个楼那一层但是不知道那个一个屋,现在你朋友来到这个楼里相对他知道的这一层然后开始找你在那个房间

这种操作就是相对路劲,例子中是通过这个楼中的这一层开始寻找,也就是相对于这个楼的某一层

2.2 绝对路径

绝对路径 是 从咱们电脑的磁盘开始查找,例如想要知道你的家乡是哪的,你身份证上写的住址就是绝对路径

绝对路径：从根目录下开始一直到文件名。
相对路径：同一个文件夹下面的文件，直接写文件名就可以。

我们在使用绝对路径的时候 因为有这样程序是不能识别的,

解决方法:

open('C:\Users\Meet')  #这样程序是不识别的

解决方法一:
open('C:\\Users\\Meet') #这样就成功的将 \进行转义   两个\\代表一个\

解决方法二:
open(r'C:\Users\Meet') #这样相比上边的还要省事,在字符串的前面加个小r也是 转义 的意思

我更推荐大家使用相对路劲,因为我把这个程序的整个文件发给你的时候,就可以运行,如果使用绝对路径还需要额外的拷贝外部文件给你

三.读操作

3.1 read()

read() 是将文件中所有的内容都读取

f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
msg = f.read()
f.close()
print(msg)

结果:
高圆圆
刘亦菲
张柏芝
杨紫
王菲

read() 可以指定我们想要读取的内容数量

f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
msg = f.read(3)  #读取三个字符
msg1 = f.read()  #后边在读就会继续向后读取

f.close()
print(msg)
print(msg1)

结果: 
高圆圆

刘亦菲
张柏芝
杨紫
王菲

r 模式这样读取的就是文字, 如果使用rb模式读取出来的就是字节

f = open('path1/小娃娃.txt',mode='rb')
msg = f.read(3)
msg1 = f.read()
f.close()
print(msg)
print(msg1)


结果:
b'\xe9\xab\x98'
b'\xe5\x9c\x86\xe5\x9c\x86\r\n\xe5\x88\x98\xe4\xba\xa6\xe8\x8f\xb2\r\n\xe5\xbc\xa0\xe6\x9f\x8f\xe8\x8a\x9d\r\n\xe6\x9d\xa8\xe7\xb4\xab\r\n\xe7\x8e\x8b\xe8\x8f\xb2'

read() 的弊端就是当文件很大的时候,将文件中的内容全部读取,存放在内存中这样会导致内存奔溃

3.2 readline()

readline() 读取每次只读取一行,注意点:readline()读取出来的数据在后面都有一个\n

f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
msg1 = f.readline()
msg2 = f.readline()
msg3 = f.readline()
msg4 = f.readline()
f.close()
print(msg1)
print(msg2)
print(msg3)
print(msg4)

结果:
高圆圆

刘亦菲

张柏芝

杨紫

结果这里每个一内容中间都有一个空行 是因为咱们读取的内容后边都带有一个\n print()的时候会将这个\n执行

f = open('path1/小娃娃.txt',mode='r',encoding='utf-8')
msg1 = f.readline().strip()
msg2 = f.readline().strip()
msg3 = f.readline().strip()
msg4 = f.readline().strip()
f.close()
print(msg1)
print(msg2)
print(msg3)
print(msg4)

结果:
高圆圆
刘亦菲
张柏芝
杨紫

解决这个问题只需要在我们读取出来的文件后边加一个 strip() 就OK了

3.3 readlines()

readlines() 将每一行 形成一个元素，放到一个列表中，将所以的内容全部读出来，如果文件很大，占内存，容易崩盘。

f = open('log',encoding='utf-8')
print(f.readlines())
f.close()
# 结果['666666\n', 'fkja l;\n', 'fdkslfaj\n', 'dfsflj\n', 'df;asdlf\n', '\n', ]

如果有个较大的文件我们进行读取不推荐使用以下方法:

f = open('../path1/弟子规',mode='r',encoding='utf-8')  # 此处的../是返回到父目录
print(f.read()) #这样就是将文件一次性全部读取到内存中,内存容易奔溃

推荐使用的是这种方法:

f = open('../path1/弟子规',mode='r',encoding='utf-8')
for line in f:
    print(line)      #这种方式就是在一行一行的进行读取,它就执行了下边的功能

print(f.readline())
print(f.readline())
print(f.readline())
print(f.readline())
f.close()

注意点:读完的文件句柄一定要关闭

四.写模式

4.1 覆盖写

在写文件的时候我们要养成一个写完文件就刷新的习惯. 刷新 flush()

f = open('../path1/小娃娃.txt',mode='w',encoding='utf-8')
f.write('太白很白')
f.flush()
f.close()

结果:
当我选择使用w模式的时候,在打开文件的时候就就会把文件中的所有内容都清空,然后在操作

注意点: 如果文件不存在使用 w模式会创建文件,文件存在w模式是 覆盖写,在打开文件时会把文件中所有的内容清空.

f1 = open('../path1/小娃娃.txt',mode='r',encoding='utf-8')
msg = f1.read()
print(msg)

# 这个是先查看小娃娃文件中有哪些内容


f = open('../path1/小娃娃.txt',mode='w',encoding='utf-8')
f.write('太白很白')
f.flush()
f.close()
# 这个是对小娃娃文件进行覆盖写操作


f1 = open('../path1/小娃娃.txt',mode='r',encoding='utf-8')
msg = f1.read()
print(msg)

# 查看覆盖写后的内容

尝试读一读

f1 = open('../path1/小娃娃.txt',mode='w',encoding='utf-8')
msg = f1.read()
print(msg)

结果:
Traceback (most recent call last):
  File "D:/python_object/path2/test.py", line 563, in <module>
    msg = f1.read() 
io.UnsupportedOperation: not readable    #模式是w,不可以执行读操作

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

f = open('../path1/小娃娃.txt',mode='wb')
msg = '你好'.encode('utf-8')
f.write(msg)
f.flush()  # 刷新
f.close()

4.2 追加

只要是a 或者 ab, a+ 都是在文件的末尾写入,不论光标在任何位置.

在追加模式下, 我们写入的内容后追加在文件的末尾

a模式 如果文件不存在就会创建一个新文件

f1 = open('../path1/小娃娃.txt',mode='a',encoding='utf-8')
msg = f1.write('这支烟灭了以后')

abb这个模式,自己试一下 没有什么太大的差别

五.读写模式

对于读写模式, 必须是先读后写, 因为光标默认在 开头位置,当读完了以后再进行写入. 我们以后使用频率最高的模式就是r+

5.1 r+模式

看下正确的操作:

f1 = open('../path1/小娃娃.txt',mode='r+',encoding='utf-8')
msg = f1.read()
f1.write('这支烟灭了以后')
f1.flush()
f1.close()
print(msg)
结果:
正常的读取之后,写在结尾

看下错误的操作:

f1 = open('../path1/小娃娃.txt',mode='r+',encoding='utf-8')
f1.write('小鬼')
msg = f1.read()
f1.flush()
f1.close()
print(msg)

结果:
这样写会把小鬼写在开头,并且读出来的是小鬼之后的内容

r+模式一定要记住是先读后写

5.2 r+ 模式坑

深坑请注意: 在r+模式下. 如果读取了内容. 不论读取内容多少. 光标显示的是多少. 再写入或者操作

文件的时候都是在结尾进行的操作.

六.写读模式

先将所有的内容清空,然后写入.最后读取.但是读取的内容是空的,不常用

f1 = open('../path1/小娃娃.txt',mode='w+',encoding='utf-8')
f1.write('小鬼')
msg = f1.read()
f1.flush()
f1.close()
print(msg)

有人说,先读在写不就行了.w+模式下 其实和w模式一样,把文件清空了,在写的内容.所以很少人用

追加读(a+, a+b)

a+模式下,不论是先读还是后读,都是读不到数据的

f = open('../path1/小娃娃.txt',mode='a+',encoding='utf-8')
f.write('阿刁')
f.flush()
msg = f.read()
f.close()
print(msg)

还有几个带b的模式,其实就是对字节的一些操作,就不多叙述了.

七.其他相关操作

7.1 seek()

seek(n)光标移动到n位置,注意: **移动单位是byte,**所有如果是utf-8的中文部分要是3的倍数

通常我们使用seek都是移动到开头或者结尾

移动到开头: seek(0,0) 可以看做成seek(0)

seek(6)这种如果是单数并且不是0的就是按照字节来移动光标

移动到结尾:seek(0,2) seek的第二个参数表示的是从哪个位置进行偏移,默认是0,表示开头,1表示当前位置,2表示结尾

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0) # 光标移动到开头
content = f.read() # 读取内容, 此时光标移动到结尾
print(content)
f.seek(0) # 再次将光标移动到开头
f.seek(0, 2) # 将光标移动到结尾
content2 = f.read() # 读取内容. 什么都没有
print(content2)
f.seek(0) # 移动到开头
f.write("张国荣") # 写入信息. 此时光标在9 中文3 * 3个 = 9
f.flush()
f.close()　
tell()

7.2 tell()

使用 tell() 可以帮我们获取当前光标在什么位置

f = open("小娃娃", mode="r+", encoding="utf-8")
f.seek(0) # 光标移动到开头
content = f.read() # 读取内容, 此时光标移动到结尾
print(content)
f.seek(0) # 再次将光标移动到开头
f.seek(0, 2) # 将光标移动到结尾
content2 = f.read() # 读取内容. 什么都没有
print(content2)
f.seek(0) # 移动到开头
f.write("张国荣") # 写入信息. 此时光标在9 中⽂文3 * 3个 = 9
print(f.tell()) # 光标位置9
f.flush()
f.close()

7.3 修改文件

文件修改:只能将文件中的内容读取到内存中,将信息修改完毕, 然后将源文件删除, 将新文件的名字改成老文件 的名字.

import os
with open("../path1/小娃娃", mode="r", encoding="utf-8") as f1,\
open("../path1/小娃娃_new", mode="w", encoding="UTF-8") as f2:
    content = f1.read()
    new_content = content.replace("冰糖葫芦", "⼤白梨")
    f2.write(new_content)
os.remove("../path1/小娃娃") # 删除源文件
os.rename("../path1/小娃娃_new", "小娃娃") # 重命名新文件

弊端: ⼀次将所有内容进行读取. 内存溢出. 解决方案: 一行一行的读取和操作

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

第九章

Python 初始函数

一.函数介绍

现在我们自己来实现一个len,但是不能使用len

a = "alexdsb"
count = 0
for i in a:
    count += 1
print(count)

二.函数定义

def 是python中关键字主要用来定义函数的

len这个是函数的名字

()这个括号是个神奇的东西,咱们后边会详细盘它

冒号是表示咱们这个语句写完了

函数体就是有4个空格的缩进

def len():
  a = "alexdsb"
  count = 0
  for i in a:
      count += 1
  print(count)

我们来看一下函数的定义在内存空间发生了什么:

​ 内存开辟了一个空间, 但是里边存放是代码.

三.函数的调用

使用函数名加小括号就可以调用了

写法:函数名() 这个时候函数的函数体会被执行

def len():
  a = "alexdsb"
  count = 0
  for i in a:
      count += 1
  print(count)

len()  # 函数的调用

当我们调用执行的时候,才会执行func这个空间里的代码,执行的时候在开辟空间,这次是在func里边开辟的空间

现在就实现了求一次长度,我想要多求几次我就只需要

len()
len()
len()

直接调用定义好的函数就可以了 大家都练习一下

当 执行完函数后, 函数里开辟的空间就销毁了,

如果想用函数里的值就需要从函数中传递出来

四. 函数的返回值

 def yue():
    print("掏出手机")
    print("打开默默")
    print("约一个妹子")  
yue()

使用return来返回结果

def yue():
    print("约你")
    print("约我")
    print("约他")
    return   
yue()

返回值返回给了函数调用者

yue () 就是函数的调用者 那就是返回给它

def yue():
    print("约你")
    print("约我")
    print("约他")
    return   
ret = yue()
print(ret)

返回的结果是None, 想想我们有的时候操作列表的方法 打印的结果就是None, 我们所有用的字符串, 列表的方法都是函数.

函数中遇到return, 此函数就立马结束了. 不在继续执行

def yue():
    print("约你")
    print("约我")
    print("约他")
    return
      print("大家一起约")
yue()

我们现在给return后边写一个返回值,我们试试返回个东西

def yue():
    print("约你")
    print("约我")
    print("约他")
    return  "美女一枚"   
yue()

我们现在返回了一个字符串,我们来看一下

def yue():
    print("约你")
    print("约我")
    print("约他")
    return '美女一枚'
girl =  yue()
print(girl)

结果:
约你
约我
约他
美女一枚

肯定好多朋友还是不明白上边怎么就打印美女一枚了,莫慌看下图:

1.定义了一个函数yue
2.调用函数
3.执行函数里的约你
4.执行函数里的约我
5.执行函数里的约他
6.返回给调用者一个字符串,这个调用者就是yue()
7.将返回的字符串通过一个等号赋值给白变量girl
8.打印变量girl的值

函数的返回值可以有多个结果:

def yue():   
    print("约你")   
    print("约我")   
    print("约他")   
    return "美女一枚", "萝莉一枚"
girl = yue()
print(type(girl))   # tuple

当函数的返回值是多个的时候,返回的就是一个元组

4.1 总结

1.遇到 return,此函数结束,return下面的代码将不会在执行

2.return 返回值

关于返回值:

如果return什么都不写 或者干脆就没写return, 返回的结果就是None

如果return后面写了一个值,返回给调用者这个值

如果return后面写了多个结果, 返回给调用者一个tuple(元祖),

​ 调用者可以直接使用解构获取多个变量

​ 参数,也就是函数括号里的内容 函数在调用的时候指定一个具体的变量的值 就是参数.

写法如下:

def 函数名(参数):

    函数体

def yue(chat):

    print("拿出⼿手机")

    print("打开"+chat)

    print("找个漂亮的妹⼦子")

    print("约不约")

yue("陌陌")
yue("微信")
yue("探探")

结果:
拿出手机
打开陌陌
找个漂亮的妹⼦
约不约


拿出⼿机
打开微信
找个漂亮的妹⼦
约不约


拿出手机
打开探探
找个漂亮的妹⼦
约不约　

搞定了. 我们在调用yue的时候给chat一个值. 然后再执行函数体.

如果我们再定函数的时候写了形参,在调用函数的时候没有传递值,调用的时候右边括号会发黄,所以我们必须要传递参数,参数要一一对应,不能多不能少.

5.1 参数

1.形参

写在函数声明的位置的变量叫形参, 形式上的一个完整. 表示这个函数需要xxx

2.实参

在函数调用的时候给函数传递的值. 加实参,实际执行的时候给函数传递的信息.表示给函数xxx

3.传参

从调用函数的时候将值传递到定义函数的过程叫做传参

def yue(chat):    # chat  形参   

    print("拿出手机")   

    print("打开"+chat)   

    print("找个漂亮的妹子")   

    print("约不约")



yue("陌陌")     # "陌陌"在这里就是实参

len("字符串")    # "字符串"在这里就是实参

print("麻花藤")    # "麻花藤"就是实参

5.2 参数的分类

5.2.1 位置参数

约到现在,有没有想过这么一个问题,啥样的都约么? 哪里的都约么? 不一定吧.比如我现在在北京,我很寂寞,我喜欢小姐姐

alex 在泰国,很寂寞 人妖就行了 .需求是不一样的 而我们现在的函数没有这些功能 那怎么办呢? 很简单 多来几个参数就好了

def yue(chat,addr,age):    # chat  形参

    print("拿出手机")

    print("打开"+chat)

    print("找个" + addr +"附近漂亮的" + str(age) + "岁妹子")

    print("约不约")



yue("陌陌","北京",18)    # 实参

结果:

拿出手机

打开陌陌

找个北京附近漂亮的18岁妹子

约不约

上述代码分析: 在访问yue()的时候,我们按照位置的顺序分别把"陌陌",“北京”,18赋值给了chat,addr,age,在传参过程中.系统会按照位置把实参赋值到形参.

形参就是一个变量名, 实参就是值 传参就是在赋值

def func(addr,age):
    addr = "北京"
  age = 18      # 从实参到形参的过程中,函数体内部帮我做了变量的赋值
  print(addr)
  print(age)

func("北京",18)

练习

编写函数,给函数传递两个参数a,b a,b相加 返回a参数和b参数相加的和

def f(a,b):
    c = a+b
    return c

num_sum = f(5,8)
print(num_sum)
结果: 13

编写函数,给函数传递两个参数a,b 比较a,b的大小 返回a,b中最大的那个数

def f(a,b):

    if a>b:

        return a

    else:

        return b

num_sum = f(5,8)

print(num_sum)
结果:8

比较大小的这个写法有点麻烦,我们在这里学一个三元运算符

def f(a,b):
    c = a if a > b else b  #当a>b就把a赋值给c,否则就把b赋值给c
    return c
msg = f(5,7)
print(msg)
结果:
7

5.2.2 关键字参数

位置参数好不好呢? 如果是少量的参数还算OK, 没有问题. 但是如果函数在定义的时候参数非常多怎么办? 程序员必须记住, 我有哪些参数, 而且还有记住每个参数的位置, 否则函数就不能正常调用了. 那则么办呢? python提出了一种叫做关键字参数. 我们不需要记住每个参数的位置. 只要记住每个参数的名字就可以了

def yue(chat, address, age):

    print("拿出手机")

    print("打开"+chat)

    print("找个"+address+"附近漂亮的"+str(age)+"岁妹子")

    print("约不约")



yue(chat="微信", age=18, address="北京")       # 关键字参数.

结果:

拿出手机

打开微信

找个北京附近漂亮的18岁妹子

约不约

搞定, 这样就不需要记住繁琐的参数位置了.

5.2.3 混合参数

可以把上面两种参数混合着使用. 也就是说在调用函数的时候即可以给出位置参数, 也可以指定关键字参数.

# 混合参数 
yue("微信", age=18, address="上海")    # 正确.第一个位置赋值给chat, 后面的参数开始指定关键字.

yue(age="18", "微信", address="广州")  # 错误, 最开始使用了关键字参数, 那么后面的 微信的位置就串了, 容易出现混乱

注意: 在使用混合参数的时候, 关键字参数必须在位置参数后面

5.2.4 总结

综上: 在实参的⾓角度来看. 分为三种:

1. 位置参数
2. 关键字参数
3. 混合参数, 位置参数必须在关键字参数前面

位置参数:

位置参数,按照位置来赋值,到目前为止,我们编写的函数都是这种

def yue(chat, address, age):   

    print("拿出手机")   

    print("打开"+chat)   

    print("找个"+address+"附近漂亮的"+str(age)+"岁妹子")   

    print("约不约")

默认值参数:

在函数声明的时候, 就可以给出函数参数的默认值. 在调用的时候可以 给出具体的值, 也可以不给值, 使⽤用默认值. 比如, 我们录入咱们班学生的基本信息. 通过调查发现. 我们班大部分学生都是男生. 这个时 候就可以给出⼀一个sex='男’的默认值.

def stu_info(name, age, sex='男'):   

    print("录入学生信息")

    print(name, age, sex)   

    print("录入完毕")



stu_info("张强", 18)

注意:必须先声明在位置参数,才能声明关键字参数

综上:在形参的角度来看

1. 位置参数
2. 默认值参数(大多数传进来的参数都是一样的, 一般用默认参数

第十章

Python 函数进阶

一. 函数参数-动态参数

形参的第三种 : 动态参数

参数

在参数位置用*表示接受任意参数

def eat(*args):

    print('我想吃',args)

eat('大米饭','中米饭','小米饭')  # 收到的结果是一个tuple元祖

动态接收参数的时候要注意: 动态参数必须在位置参数后面

def eat(*args,a,b):

    print('我想吃',args,a,b)

eat('大米饭','中米饭','小米饭')

结果:

TypeError: eat() missing 2 required keyword-only arguments: 'a' and 'b'
# eat函数在调用的时候发现缺少俩个位置参数没有进行传递

通过上述代码发现一个问题就是,我们明明给了多个参数,为什么还会提示参数未传递呢?

原因就是因为这个在搞鬼 把所有的位置参数都给接受了,所有会报错.我们尝试着把a,b放在的前面试试

def eat(a,b,*args):

    print('我想吃',args,a,b)

eat('大米饭','中米饭','小米饭')

结果:

我想吃 ('小米饭',) 大米饭 中米饭

动态接收参数的时候要注意:动态参数必须在位置参数后面

那默认值参数呢?

def eat(a,b,c='白菜',*args):

    print('我想吃',a,b,c,args)

eat('豆腐','粉条','猪肉','大葱')

结果:

我想吃 豆腐 粉条 猪肉 ('大葱',)  # 我们定义好的白菜没有生效,被猪肉给覆盖了

我们发现默认值参数写在动态参数前面,默认值的参数是不会生效的

def eat(a,b,*args,c='白菜'):

    print('我想吃',a,b,args,c)

eat('猪肉','粉条','豆腐','大葱')

结果:

我想吃 猪肉 粉条 ('豆腐', '大葱') 白菜  # 这样默认参数就生效了

这个时候如果你不给出关键字传参,那么你的默认值是永远都生效的

注意: 形参的顺序: 位置参数 , 动态参数 , 默认参数

1.2 动态接收关键字参数

在python中可以动态的位置参数,但是*这种情况只能接收位置参数无法接收关键字参数,在python中使用**来接收动态关键字参数

def func(**kwargs):
    print(kwargs)     
func(a=1, b=2, c=3)
结果:
{'a': 1, 'b': 2, 'c': 3}

动态关键字参数最后获取的是一个dict字典形式

顺序的问题, 在函数调用的时候, 如果先给出关键字参数, 则整个参数列表会报错.

def func(a,b,c,d):
    print(a,b,c,d)
func(1,2,c=3,4)
结果:
  File "D:/python_object/path2/test.py", line 806
    func(1,2,c=3,4)              ^
SyntaxError: positional argument follows keyword argument

关键参数必须要放在位置参数后边,由于实参是这个顺序,所以形参接收的时候也是这个顺序.也就是说位置参数必须在关键字参数前面.动态接收关键字参数也要在后面

最终顺序:

位置参数 > *args(动态位置参数) > 默认值参数 > **kwargs(动态默认参数)

这四种参数可以任意的使用

如果想接收所有的参数:

def func(*args,**kwargs):
    print(args,kwargs)
func(1,23,5,a=1,b=6)

动态参数还可以这样传参:

lst = [1,4,7]
# 方法一
def func(*args):
    print(args)
func(lst[0],lst[1],lst[2])
# 方法二
def func(*args):
    print(args)
func(*lst)  
# 在实参的位置上用*将lst(可迭代对象)按照顺序打散
# 在形参的位置上用*把收到的参数组合成一个元祖

字典也可以进行打散,不过需要**

dic = {'a':1,'b':2}
def func(**kwargs):
    print(kwargs)
func(**dic)

二. 函数的注释

def eat(food,drink):

    '''
    这里描述这个函数是做什么的.例如这函数eat就是吃
    :param food:  food这个参数是什么意思
    :param drink: drink这个参数是什么意思
    :return:  执行完这个函数想要返回给调用者什么东西
    '''
    print(food,drink)
eat('麻辣烫','肯德基')

在外部查看函数的注释 函数名.*doc*

print(eat.__doc__)  #函数名.__doc__
结果:
    这里描述这个函数是做什么的.例如这函数eat就是吃
    :param food:  food这个参数是什么意思
    :param drink: drink这个参数是什么意思
    :return:  执行完这个函数想要返回给调用者什么东西

三 .名称空间

在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.

def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经..

我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就 是存储在这片空间中的.

命名空间分类:

1. 全局命名空间–> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间
2. 局部命名空间–> 在函数中声明的变量会放在局部命名空间
3. 内置命名空间–> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

加载顺序:

1. 内置命名空间
2. 全局命名空间
3. 局部命名空间(函数被执行的时候)

取值顺序:

1. 局部命名空间
2. 全局命名空间
3. 内置命名空间

a = 10
def func():  
    a = 20   
    print(a)

func()  # 20

作用域: 作用域就是作用范围, 按照生效范围来看分为 全局作用域 和 局部作用域

全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循 从上到下逐⾏执行).

局部作用域: 在函数内部可以使用.

作⽤域命名空间:

1. 全局作⽤用域: 全局命名空间 + 内置命名空间
2. 局部作⽤用域: 局部命名空间

我们可以通过globals()函数来查看全局作⽤用域中的内容,也可以通过locals()来查看局部作⽤用域中的变量量和函数信息

a = 10
def func():   
    a = 40   
    b = 20   
    print("哈哈")   
    print(a, b)        
    print(globals())    # 打印全局作用域中的内容   
    print(locals())     # 打印局部作用域中的内容
func()

四. 函数的嵌套

1. 只要遇见了()就是函数的调用. 如果没有()就不是函数的调用
2. 函数的执行顺序

def fun1():   
    print(111)  
def fun2():   
    print(222)   
    fun1()   
fun2()
print(111)

def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)

五 .gloabal、nonlocal

首先在全局声明一个变量, 然后再局部调用这个变量, 并改变这 个变量的值

a = 100
def func():   
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a   
    a = 28   
print(a)
func()
print(a)

global表示. 不再使用局部作用域中的内容了. 而改用全局作用域中的变量

5.1 global 宗旨

在函数内部修改全局的变量,如果全局中不存在就创建一个变量

lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():   
    lst.append("⻢云")   
    # 对于可变数据类型可以直接进⾏访问
　　 print(lst)
func()
print(lst)

5.2 nonlocal宗旨

nonlocal 只修改上一层变量,如果上一层中没有变量就往上找一层,只会找到函数的最外层,不会找到全局进行修改

a = 10
def func1():   
    a = 20   
    def func2():
        nonlocal a       
        a = 30       
        print(a)  
    func2()   
    print(a)
func1()


结果:
加了nonlocal
30
30

不加nonlocal
30
20

再看, 如果嵌套了很多层, 会是一种什么效果:

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)

这样的程序如果能分析明白. 那么作用域, global, nonlocal就没问题了

第十一章

一. 函数名的运用

函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量

1.1.函数名的内存地址

def func():   
    print("呵呵")
print(func)

结果: <function func at 0x1101e4ea0>

1.2 函数名可以 赋值给其他变量

def func():   
    print("呵呵")
    print(func)
a = func    # 把函数当成一个值赋值给另一个变量

a()     # 函数调用 func()

1.3. 函数名可以当做 容器类的元素

def func1():   
    print("呵呵")
def func2():   
    print("呵呵")
def func3():   
    print("呵呵")
def func4():  
     print("呵呵")
lst = [func1, func2, func3]
for i in lst:  
     i()

1.4.函数名可以当做 函数的参数

def func():   
    print("吃了么")
def func2(fn):   
    print("我是func2")   
    fn()    # 执行传递过来的fn   
    print("我是func2")
func2(func)     # 把函数func当成参数传递给func2的参数fn.

1.5. 函数名可以作为函数的返回值

def func_1():   
    print("这里是函数1")   
    def func_2():       
        print("这里是函数2")   
    print("这里是函数1")   
    return func_2
fn = func_1()  
# 执行函数1.  函数1返回的是函数2, 这时fn指向的就是上面函数2
fn()    # 执行func_2函数

二. f-string 字符串格式化

f-strings 是python3.6开始加入标准库的格式化输出新的写法，这个格式化输出比之前的%s 或者 format 效率高并且更加简化，非常的好用 。

2.1 简单举例

他的结构就是F(f)+ str的形式，在字符串中想替换的位置用{}展位，与format类似，但是用在字符串后面写入替换的内容，而他可以直接识别。碉堡了。

name = '宝元'
age = 18
sex = '男'
msg = F'姓名：{name},性别：{age}，年龄：{sex}'  # 大写字母也可以
msg = f'姓名：{name},性别：{age}，年龄：{sex}'  
print(msg)
'''
输出结果：
姓名：宝元,性别：18，年龄：男
'''

2.2 任意表达式

他可以加任意的表达式，非常方便：

print(f'{3*21}')  # 63

name = 'barry'
print(f"全部大写：{name.upper()}")  # 全部大写：BARRY

# 字典也可以
teacher = {'name': '宝元', 'age': 18}
msg = f"The teacher is {teacher['name']}, aged {teacher['age']}"
print(msg)  # The comedian is 宝元, aged 18

# 列表也行
l1 = ['宝元', 18]
msg = f'姓名：{l1[0]},年龄：{l1[1]}.'
print(msg)  # 姓名：宝元,年龄：18.

2.3 也可以插入表达式

可以用函数完成相应的功能，然后将返回值返回到字符串相应的位置

def sum_a_b(a,b):
    return a + b
a = 1
b = 2
print('求和的结果为' + f'{sum_a_b(a,b)}')

2.4 多行f

xname = 'barry'
age = 18
ajd = 'handsome'

# speaker = f'''Hi {name}.
# You are {age} years old.
# You are a {ajd} guy!'''

speaker = f'Hi {name}.'\
          f'You are {age} years old.'\
          f'You are a {ajd} guy!'
print(speaker)

2.5 其他细节

print(f"{{73}}")  # {73}
print(f"{{{73}}}")  # {73}
print(f"{{{{73}}}}")  # {{73}}
m = 21
# ! , : { } ;这些标点不能出现在{} 这里面。
# print(f'{;12}')  # 报错
# 所以使用lambda 表达式会出现一些问题。
# 解决方式：可将lambda嵌套在圆括号里面解决此问题。
x = 5
print(f'{(lambda x: x*2) (x)}')  # 10

三 .迭代器

3.1 可迭代对象

3.1.1 可迭代对象定义

什么是对象？

​ Python中一切皆对象，之前我们讲过的一个变量，一个列表，一个字符串，文件句柄，函数名等等都可称作一个对象，

​ 其实一个对象就是一个实例，就是一个实实在在的东西。

那么什么叫迭代？

​ 更新迭代 ，迭代就是一个重复的过程，但是不能是单纯的重复（如果只是单纯的重复那么他与循环没有什么区别）每次重复都是基于上一次的结果而来。比如 你使用过得app，微信，抖音等，隔一段时间就会基于上一次做一些更新，那么这就是迭代。

​ 可迭代对象 从字面意思来说就是一个可以重复取值的实实在在的东西。

str list tuple dic set range 文件句柄等，那么int，bool这些为什么不能称为可迭代对象呢？虽然在字面意思这些看着不符合，但是我们要有一定的判断标准或者规则去判断该对象是不是可迭代对象。

在python中，但凡内部含有iter方法的对象，都是可迭代对象。

3.1.2 查看对象内部方法

该对象内部含有什么方法除了看源码还有什么其他的解决方式么？当然有了， 可以通过dir() 去判断一个对象具有什么方法

s1 = 'alex'
print(dir(s1))

dir() 会返回一个列表，这个列表中含有该对象的以字符串的形式所有方法名。这样我们就可以判断python中的一个对象是不是可迭代对象了：

s1 = 'alex'
i = 100
print('__iter__' in dir(i))  # False
print('__iter__' in dir(s1))  # True

3.1.3 小结：

从字面意思来说：可迭代对象就是一个可以重复取值的实实在在的东西。

从专业角度来说：但凡内部含有__iter__方法的对象，都是可迭代对象。

​ 可迭代对象可以通过判断该对象是否有__iter__方法来判断。

可迭代对象的优点：

​ 可以直观的查看里面的数据。

可迭代对象的缺点：

1.占用内存。

2.可迭代对象不能迭代取值（除去索引，key以外）。

那么这个缺点有人就提出质疑了，即使抛去索引,key以外，这些我可以通过for循环进行取值呀！对，他们都可以通过for循环进行取值，其实for循环在底层做了一个小小的转化，就是先将可迭代对象转化成迭代器，然后在进行取值的。那么接下来，我们就看看迭代器是个什么鬼。

3.2 迭代器

3.2.1 迭代器的定义

从字面意思来说迭代器，是一个可以迭代取值的工具，器：在这里当做工具比较合适。

从专业角度来说：迭代器是这样的对象：实现了无参数的__next__方法，返回序列中的下一个元素，如果没有元素了，那么抛出StopIteration异常.python中的迭代器还实现了__iter__方法，因此迭代器也可以迭代。 出自《流畅的python》

那么对于上面的解释有一些超前，和难以理解，不用过于纠结，我们简单来说：在python中，内部含有__Iter__方法并且含有__next__方法的对象就是迭代器。

3.2.2 如何判断该对象是否是迭代器

ok，那么我们有了这个定义，我们就可以判断一些对象是不是迭代器或者可迭代对象了了，请判断这些对象：str list tuple dict set range 文件句柄 哪个是迭代器，哪个是可迭代对象：

o1 = 'alex'
o2 = [1, 2, 3]
o3 = (1, 2, 3)
o4 = {'name': '太白','age': 18}
o5 = {1, 2, 3}
f = open('file',encoding='utf-8', mode='w')
print('__iter__' in dir(o1))  # True
print('__iter__' in dir(o2))  # True
print('__iter__' in dir(o3))  # True
print('__iter__' in dir(o4))  # True
print('__iter__' in dir(o5))  # True
print('__iter__' in dir(f))  # True

print('__next__' in dir(o1))  # False
print('__next__' in dir(o2))  # False
print('__next__' in dir(o3))  # False
print('__next__' in dir(o4))  # False
print('__next__' in dir(o5))  # False
print('__next__' in dir(f))  # True
f.close()

通过以上代码可以验证，之前我们学过的这些对象，只有文件句柄是迭代器，剩下的那些数据类型都是可迭代对象。

3.2.3 可迭代对象如何转化成迭代器：

l1 = [1, 2, 3, 4, 5, 6]
obj = l1.__iter__()
# <list_iterator object at 0x000002057FE1A3C8>
# 或
obj = iter(l1)
print(obj)
# <list_iterator object at 0x102cc67f0>

3.2.4 迭代器取值：

可迭代对象是不可以一直迭代取值的（除去用索引，切片以及Key），但是转化成迭代器就可以了，迭代器是利用__next__()进行取值：

l1 = [1, 2, 3,]
obj = l1.__iter__()  # 或者 iter(l1)
# print(obj)  # <list_iterator object at 0x000002057FE1A3C8>
ret = obj.__next__()
print(ret)
ret = obj.__next__()
print(ret)
ret = obj.__next__()
print(ret)
ret = obj.__next__()  # StopIteration
print(ret)
# 迭代器利用next取值：一个next取对应的一个值，如果迭代器里面的值取完了，还要next，
# 那么就报StopIteration的错误。

3.2.5 while 模拟 for 的内部循环机制：

​ for循环的循环对象一定要是可迭代对象，但是这不意味着可迭代对象就可以取值，因为for循环的内部机制是： 将可迭代对象转换成迭代器，然后利用next进行取值，最后利用异常处理处理StopIteration抛出的异常。

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

3.2.6 小结：

​ 迭代器就是可以迭代取值的工具。

从专业角度来说：在python中，内部含有__Iter__方法 并且 含有__next__方法的 对象就是迭代器。

迭代器的优点：

节省内存。 迭代器在内存中相当于只占一个数据的空间： 因为每次取值都上一条数据会在内存释放，加载当前的此条数据。

惰性机制。 next 一次，取一个值，绝不过多取值。

有一个迭代器模式可以很好的解释上面这两条： 迭代是数据处理的基石。 扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式。

迭代器的缺点：

​ 不能直观的查看里面的数据。

​ 取值时不走回头路，只能一直向下取值。

l1 = [1, 2, 3, 4, 5, 6]
obj = iter(l1)

for i in range(2):
    print(next(obj))

for i in range(2):
    print(next(obj))

3.3 可迭代对象与迭代器对比

​ 我们今天比较深入的了解了可迭代对象与迭代器，接下来我们说一下这两者之间比较与应用：

可迭代对象：

​ 是一个私有的方法比较多，操作灵活（比如列表，字典的增删改查，字符串的常用操作方法等）,比较直观，但是占用内存，而且不能直接通过循环迭代取值的这么一个数据集。

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

迭代器：

​ 是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。

应用：当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。（可参考为什么python把文件句柄设置成迭代器）。

第十二章

一.生成器

1.1 初识生成器

生成器的本质就是迭代器， 在python社区中，大多数时候都把迭代器和生成器是做同一个概念。

唯一的不同就是：迭代器都是Python给你提供的已经写好的工具或者通过数据转化得来的，（比如文件句柄，iter([1,2,3])。

生成器是需要我们自己用python代码构建的工具。最大的区别也就如此了。

1.2 生成器的构建方式

在python中有三种方式来创建生成器：

1. 通过生成器函数

2. 通过生成器推导式

3. python内置函数 或者模块提供 （其实1,3两种本质上差不多，都是通过函数的形式生成，只不过1是自己写的生成器函数，3是python提供的生成器函数而已）

1.3 生成器函数

我们先来研究 通过生成器函数构建生成器。

首先,我们先看一个很简单的函数:

def func():
    print(11)
    return 22
ret = func()
print(ret)
# 运行结果:
11
22

将函数中的 return换成yield，这样 func就不是函数了，而是一个生成器函数

def func():
    print(11)
    yield 22

def func():
    print(11)
    yield 22
ret = func()
print(ret)

# 运行结果:
<generator object func at 0x000001A575163888>

​ 为什么在函数中添加了yield在调用函数的时候就发现结果不是我们预想的结果呢,

是因为当我们调用函数的时候函数体里的代码会进行执行当执行到yield的关键字的时候,发现我们是想声明一个生成器.程序就会返回一个生成器给咱们

​ 生成器的本质就是迭代器.

迭代器如何取值，生成器就如何取值。所以我们可以直接执行next()来执行以下生成器

def func():
     print("111")
     yield 222
gener = func() # 这个时候函数不会执⾏. ⽽是获取到⽣成器
ret = gener.__next__() # 这个时候函数才会执⾏
print(ret)  # 并且yield会将func生产出来的数据 222 给了 ret。  
结果:
111
222

并且我的生成器函数中可以写多个yield。

def func():

    print("111")

    yield 222

    print("333")

    yield 444

gener = func()

ret = gener.__next__()

print(ret)

ret2 = gener.__next__()

print(ret2)

ret3 = gener.__next__()

# 最后⼀个yield执⾏完毕. 再次__next__()程序报错
print(ret3)

当程序运行完最后一个yield,那么后面继续运行next()程序会报错，

一个yield对应一个next，next超过yield数量，就会报错，与迭代器一样。

yield与return的区别：

return 一般在函数中只设置一个，他的作用是 终止函数，并且给函数的执行者返回值。

yield 在生成器函数中可设置多个，他并 不会终止函数，next 会获取对应 yield生成的元素。

举例：

我们来看一下这个需求：老男孩向楼下卖包子的老板订购了10000个包子.包子铺老板非常实在，一下就全部都做出来了

def eat():
    lst = []
    for i in range(1,10000):
        lst.append('包子'+str(i))
    return lst
e = eat()
print(e)

这样做没有问题，但是我们由于学生没有那么多，只吃了2000个左右，剩下的8000个，就只能占着一定的空间，放在一边了。如果包子铺老板效率够高，我吃一个包子，你做一个包子，那么这就不会占用太多空间存储了，完美。

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)
e = eat()
for i in range(200):
    next(e)

这两者的区别:

第一种是直接把包子全部做出来，占用内存。

第二种是吃一个生产一个，非常的节省内存，而且还可以保留上次的位置。

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)
e = eat()
for i in range(200):
    next(e)
for i in range(300):
    next(e)
# 多次next包子的号码是按照顺序记录的。

1.4 send 方法（了解,不讲）

接下来我们再来认识一个新的东西,send方法

# next只能获取yield生成的值，但是不能传递值。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')
dog = gen('alex')
next(dog)
next(dog)
next(dog)
# 而使用send这个方法是可以的。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield 222
        print(f'{name} start to eat {food}')
dog = gen('alex')
next(dog)  # 第一次必须用next让指针停留在第一个yield后面
# 与next一样，可以获取到yield的值
ret = dog.send('骨头')
print(ret)
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')

dog = gen('alex')
next(dog)
# 还可以给上一个yield发送值
dog.send('骨头')
dog.send('狗粮')
dog.send('香肠')

send和next()区别:

相同点：

send 和 next()都可以让生成器对应的yield向下执行一次。

都可以获取到yield生成的值。

不同点：

第一次获取yield值只能用next不能用send（可以用send(None)）。

send可以给上一个yield置传递值。

1.5 yield from

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

# 对比yield 与 yield from 
def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield lst
g = func()
print(g)
print(next(g))  # 只是返回一个列表
def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield from lst
g = func()
print(g)
# 他会将这个可迭代对象(列表)的每个元素当成迭代器的每个结果进行返回。
print(next(g))
print(next(g))
print(next(g))
print(next(g))
'''
yield from ['卫龙','老冰棍','北冰洋','牛羊配'] 
等同于：
    yield '卫龙'
    yield '老冰棍'
    yield '北冰洋'
    yield '牛羊配'

1.6 yield from 小坑

def func():
    lst1 = ['卫龙', '老冰棍', '北冰洋', '牛羊配']
    lst2 = ['馒头', '花卷', '豆包', '大饼']
    yield from lst1
    yield from lst2
g = func()
for i in g:
    print(i)

返回的结果是将第一个列表的元素全部返回后,在返回第二个列表

二. 推导式

​ 列表推导式,生成器表达式以及其他推导式，我认为推导式就是构建比较有规律的列表,生成器，字典等一种简便的方式。

2.1 列表推导式

这里让学生自己做一下，首先我们先看一下这样的代码,给出一个列表,通过循环,想列表中添加1~10:

li = []
for i in range(10):
    li.append(i)
print(li)

那么按照上面的要求我们用列表推导式写一下：

ls = [i for i in range(10)]
print(ls)

列表推导式进行一个分类：

列表推导式分为两种模式：

1.循环模式： [变量(加工的变量) for 变量 in iterable]

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

当然还有多层循环的，这个我们一会就会讲到，那么我们先来看循环模式。

2.1.1 循环模式

刚才我们看到的就是循环模式，那么有同学会问到，什么叫’ 加工的变量’? 这个也比较简单，接下来我们做几道题：

1. 将10以内所有整数的平方写入列表。

l1 = [i*i for i in range(1,11)]
print(l1)

1. 100以内所有的偶数写入列表.

l1 = [i for i in range(2,101,2)]
print(l1)

1. 从python1期到python24期写入列表lst

lst = [f'python{i}' % i for i in range(1,25)]

print(lst)

上面那个格式化输出的变量f’python{i}’，就是加工的变量。

上面做的那三个就是循环模式，比较简单，接下来我们研究筛选模式。

2.1.2 筛选模式

筛选模式就是在上面的基础上加上一个判断条件，将满足条件的变量留到列表中。

带着同学们做一个题：

将这个列表中大于3的元素留下来。

l1 = [4, 3, 2, 6, 5, 5, 7, 8] 
print([i for i in l1 if i > 3])

通过我给大家的演示，大家做几道题：

1. 三十以内可以被三整除的数。

   multiples = [i for i in range(30) if i % 3 is 0]
   print(multiples)
   

2. 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

   l = ['wusir', 'laonanhai', 'aa', 'b', 'taibai']
   # print([i.upper() for i in l if len(i) > 3])
   

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])  
   # 注意遍历顺序，这是实现的关键
   

​ 列表推导式基本上讲完了，当然今天会做一些有关列表推导式的题，让大家更加深入的了解。

2.1.3 生成器表达式

生成器表达式 和 列表推导式的语法上一模一样,只是把[]换成()就行了。比如将十以内所有数的平方放到一个生成器表达式中

gen = (i**2 for i in range(10))
print(gen)
# 结果: <generator object <genexpr> at 0x0000026046CAEBF8>

生成器表达式也可以进行筛选

# 获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
    print(num)

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

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

无论是生成器表达式，还是列表推导式，他只是Python给你提供了一个相对简单的构造方式，因为使用推导式非常简单，所以大多数都会为之着迷，这个一定要慎重，推导式只能构建相对复杂的并且有规律的对象，对于没有什么规律，而且嵌套层数比较多（for循环超过三层）这样就不建议大家用推导式构建。

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

2.1.4 其他相关的推导式（了解）

字典推导式

根据名字应该也能猜到, 推到出来的是字典

lst1 = ['jay','jj','meet']
lst2 = ['周杰伦','林俊杰','郭宝元']
dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic)

集合推导式

集合 推导式可以帮我们直接生成一个集合,

集合的特点; 无序,不重复 所以集合推导式自带去重功能

lst = [1,2,3,-1,-3,-7,9]
s = {abs(i) for i in lst}
print(s)

三. 内置函数Ⅰ

函数就是以功能为导向， 一个函数封装一个功能，

Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，

到目前为止python给我们提供的内置函数一共是68个，

内置函数进行分类：

eval：执行字符串类型的代码，并返回最终结果。

eval('2 + 2')  # 4
n=81
eval("n + 4")  # 85
eval('print(666)')  # 666

exec:执行字符串类型的代码。

s = '''
for i in [1,2,3]:
    print(i)
'''
exec(s)

以上两个内置函数很强大 工作中禁止使用

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('alex'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

'''
-2996001552409009098
-4637515981888139739
1
2528502973977326415
'''

help：函数用于查看函数 或 模块用途的详细说明。

print(help(list))
print(help(str.split))

callable：函数用于检查一个对象是否是可调用的。如果返回True，仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'
def func():
    pass
print(callable(name))  # False
print(callable(func))  # True

int：函数用于将一个字符串或数字转换为整型。

print(int())  # 0
print(int('12'))  # 12
print(int(3.6))  # 3
print(int('0100',base=2))  # 将2进制的 0100 转化成十进制。结果为 4

float：函数用于将整数和字符串转换成浮点数。

complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。

print(float(3))  # 3.0
print(complex(1,2))  # (1+2j)

bin：将十进制转换成二进制并返回。

oct：将十进制转化成八进制字符串并返回。

hex：将十进制转化成十六进制字符串并返回。

print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
print(hex(10),type(hex(10)))  # 0xa <class 'str'>

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round：保留浮点数的小数位数，默认保留整数。

pow：求xy次幂。（三个参数为xy的结果对z取余）

print(divmod(7,2))  # (3, 1)
print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326
print(pow(2,3))  # 两个参数为2**3次幂
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

bytes：用于不同编码之间的转化。

# s = '你好'
# bs = s.encode('utf-8')
# print(bs)
# s1 = bs.decode('utf-8')
# print(s1)
# bs = bytes(s,encoding='utf-8')
# print(bs)
# b = '你好'.encode('gbk')
# b1 = b.decode('gbk')
# print(b1.encode('utf-8'))

ord: 输入字符找当前字符编码的位置

chr: 输入当前编码的位置数字找出其对应的字符

# ord 输入字符找该字符编码的位置
# print(ord('a'))
# print(ord('中'))

# chr 输入位置数字找出其对应的字符
# print(chr(97))
# print(chr(20013))

repr: 返回一个对象的string形式（原形毕露）。

# %r  原封不动的写出来
# name = 'taibai'
# print('我叫%r'%name)

# repr 原形毕露
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')

all：可迭代对象中，全都是True才是True

any：可迭代对象中，有一个True 就是True

# all  可迭代对象中，全都是True才是True
# any  可迭代对象中，有一个True 就是True
# print(all([1,2,True,0]))
# print(any([1,'',0]))

= ‘’’
for i in [1,2,3]:
print(i)
‘’’
exec(s)

以上两个内置函数很强大 工作中禁止使用

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(12322))
print(hash(‘123’))
print(hash(‘arg’))
print(hash(‘alex’))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

‘’’
-2996001552409009098
-4637515981888139739
1
2528502973977326415
‘’’

help：函数用于查看函数 或 模块用途的详细说明。

print(help(list))
print(help(str.split))

callable：函数用于检查一个对象是否是可调用的。如果返回True，仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = ‘alex’
def func():
pass
print(callable(name)) # False
print(callable(func)) # True

int：函数用于将一个字符串或数字转换为整型。

print(int()) # 0
print(int(‘12’)) # 12
print(int(3.6)) # 3
print(int(‘0100’,base=2)) # 将2进制的 0100 转化成十进制。结果为 4

float：函数用于将整数和字符串转换成浮点数。

complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。

print(float(3)) # 3.0
print(complex(1,2)) # (1+2j)

bin：将十进制转换成二进制并返回。

oct：将十进制转化成八进制字符串并返回。

hex：将十进制转化成十六进制字符串并返回。

print(bin(10),type(bin(10))) # 0b1010 <class ‘str’>
print(oct(10),type(oct(10))) # 0o12 <class ‘str’>
print(hex(10),type(hex(10))) # 0xa <class ‘str’>

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round：保留浮点数的小数位数，默认保留整数。

pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(divmod(7,2)) # (3, 1)
print(round(7/3,2)) # 2.33
print(round(7/3)) # 2
print(round(3.32567,3)) # 3.326
print(pow(2,3)) # 两个参数为23次幂
print(pow(2,3,3)) # 三个参数为23次幂，对3取余。

bytes：用于不同编码之间的转化。

s = ‘你好’

bs = s.encode(‘utf-8’)

print(bs)

s1 = bs.decode(‘utf-8’)

print(s1)

bs = bytes(s,encoding=‘utf-8’)

print(bs)

b = ‘你好’.encode(‘gbk’)

b1 = b.decode(‘gbk’)

print(b1.encode(‘utf-8’))

ord: 输入字符找当前字符编码的位置

chr: 输入当前编码的位置数字找出其对应的字符

ord 输入字符找该字符编码的位置

print(ord(‘a’))

print(ord(‘中’))

chr 输入位置数字找出其对应的字符

print(chr(97))

print(chr(20013))

repr: 返回一个对象的string形式（原形毕露）。

%r 原封不动的写出来

name = ‘taibai’

print(‘我叫%r’%name)

repr 原形毕露

print(repr(’{“name”:“alex”}’))
print(’{“name”:“alex”}’)

all：可迭代对象中，全都是True才是True

any：可迭代对象中，有一个True 就是True

all 可迭代对象中，全都是True才是True

any 可迭代对象中，有一个True 就是True

print(all([1,2,True,0]))

print(any([1,’’,0]))

来源：CSDN

作者：weixin_45523107

链接：https://blog.csdn.net/weixin_45523107/article/details/103780623