笔记纲要

1. BIF 就是 Built-in Functions，内置函数。为了方便程序员快速编写脚本程序（脚本就是要编程速度快快快！！！），Python 提供了非常丰富的内置函数，我们只需要直接调用即可，例如 print() 的功能是“打印到屏幕”，input() 的作用是接收用户输入。
2. 在 Python 或 IDLE 中，输入dir(builtins) 可以看到 Python 提供的内置方法列表（注意，builtins 前后是两个下划线哦）其中小写的就是 BIF。如果想具体查看某个BIF 的功能，比如 input()，可以在 shell 中输入 help(input)，就会得到这个 BIF 的功能描述。哦，答案应该是 68 个
3. •变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
   

4.
python中 \ 为除法， \\ 为整除 ，% 为取余

##member = [1,2,3,4]

member[0:2]表示从第1个元素开始拷贝，一共拷贝两个元素，即member[0]和member[1]

5.元组：

注：其并未对原元组进行修改，而是生成了一个新的元组，并贴上temp名字标签而已。原元组由于标签没有了，则会被自动回收。

注：元组不允许修改和删除。

内容来源于：https://blog.csdn.net/qq_45077896/article/details/90521891

d为十进制整数
-的意思是 左对齐


用0补充空位 ，一共那个10位数 ，整数
-代表左对齐

返回的是迭代器的对象
把这个0x。。。强制转换为列表

每一个列表的索引值+值 变成元组

016 序列！序列！

注：元组是不可以修改和删除的，所以不可以直接对元组使用sorted与reversed命令

tuple2 = (3.1 ,2.8 ,3.6)
#这里不就是元组嘛？？

def MyFirstFunction(name):
print(name + ‘我爱你’)
MyFirstFunction(‘niubi’)
’函数定义过程中的name是叫形参’
print(‘传递进来的’ + name + ‘叫做实参，因为Ta是具体的参数值！’)

局部变量–全局变量！

python里一定要对齐
而c语言里面，这个else是就近原则对应的if

ALT N 从IDLE打开后执行的第一条语句往下
ALT P 从IDLE打开后执行的第一条语句往下

#过滤函数filter可筛选出非零元素


注：lambda x:x%2用来判断是否为奇，x为奇则输出1，否则输出0；range(10)可生成0-9的10个整数，filter用来筛选非零元素；如果为偶数，则被筛选掉；如果为奇数，则保留，但输出的是rang(10)产生的原始数，因为lambda只是用来判断是否为奇偶

range生成的0-9给了x，x经过2倍运算后再赋值给x

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

025 字典：当索引不好用时

字典用 { } 元组用 （ ） 列表用 [ ] mapping 映射

iterables 参数

026 字典：当索引不好用时2

fromkey()方法用于创建并返回一个新的字典。它有两个参数，第一个参数是字典的键；第二个参数是可选的，是传入键的值。如果不提供，默认是None

>>> dict1 = {}
>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict2 = {}
>>> dict2.fromkeys((1,2,3),"Number")
{1: 'Number', 2: 'Number', 3: 'Number'}
>>> dict3 = {}
>>> dict3.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

访问字典的方法有key()、values()和items()
key()用于返回字典中的键，value()用于返回字典中所有的值，item()当然就是返回字典中所有的键值对（也就是项）

>>> dict1 = dict1.fromkeys(range(5),'赞')
>>> dict1.keys()
dict_keys([0, 1, 2, 3, 4])
>>> dict1.values()
dict_values(['赞', '赞', '赞', '赞', '赞'])
>>> dict1.items()
dict_items([(0, '赞'), (1, '赞'), (2, '赞'), (3, '赞'), (4, '赞')])

>>> dict1 =dict.fromkeys(range(5),'赞')
>>> for eachkey in dict1.keys():
	print(eachkey)
0
1
2
3
4

>>> for eachValue in dict1.values():
	print(eachValue)
赞
赞
赞
赞
赞
		

>>> for eachItem in dict1.items():
	print(eachItem)
(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')

>>> print(dict1[5])
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    print(dict1[5])
KeyError: 5
>>> print(dict1[4])
赞

get()方法提供了更宽松的方式去访问字典项，
当键不存在的时候，get()方法并不会报错，
只是默默第返回一个None，表示啥都没找到：
>>>dict1.get(5)
>>> print(dict1.get(5))
None

如果希望找不到数据时返回指定的值，可以在第二个参数设置对应的默认返回值：
>>> dict1.get(5,'木有')
'木有'
>>> dict1.get(4,'木有')
'赞'
>>> 4 in dict1
True
>>> 5 in dict1

clear()可清空一个字典

>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
>>> dict1.clear()
>>> dict1
{}

注意栈的索引
>>> a={'姓名':'2'}
>>> b=a
>>> b
{'姓名': '2'}
>>> a = {}
>>> a
{}
>>> b
{'姓名': '2'}

>>>a = b
>>>a
{'姓名':'2'}
>>>b
{'姓名':'2'}
>>>a.clear
>>>a
{}
>>>b
{}
>>> 

copy()方法是复制字典（全拷贝）
····赋值不是全拷贝

>>> a = {1:'one',2:'two',3:'three'}
>>> b = a.copy()
>>> c = a
>>> c
{1: 'one', 2: 'two', 3: 'three'}
>>> a
{1: 'one', 2: 'two', 3: 'three'}
>>> b
{1: 'one', 2: 'two', 3: 'three'}
>>> id(a)
2454888071104
>>> id(b)
2454887935360
>>> id(c)
2454888071104
赋值---地址是一样的   
赋值：贴了一个不同的标签在相同数据上

>>> c[4]='four'
>>> c
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> b
{1: 'one', 2: 'two', 3: 'three'}

pop()是给定键弹出对应的值，popitem()是随机弹出一个项
>>> a.pop(2)
'two'
>>> a
{1: 'four', 3: 'three'}
>>> a.popitem()
(1, 'four')
>>> a
{3: 'three'}

setdefault()方法与get()方法相似，但setdefault()在字典中找不到相应的键值时会自动添加
>>> a = {1:'one',2:'two',3:'three'}
>>> a.setdefault(2)
'two'
>>> a.setdefault(4)
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: None}

update()方法可以更新字典

>>> a = {1:'one','小白':None}

>>> b = {'小白':'狗'}
>>> a.update(b)
>>> a
{1: 'one', '小白': '狗'}

027 集合：在我的世界里，你就是唯一

字典的表亲–集合（在python3中，如果用大括号括起一堆数字但没有体现映射关系，那么就会认为这堆玩意儿就是个集合）

>>> num1 = {}
>>> type(num1)
<class 'dict'>
>>> num2 = {1,3,4}
>>> type(num2)
<class 'set'>      set 就是集合 


集合 唯一性--无序性
>>> num = {1,2,3,4,5,5,4,3,2,1}
>>> num
{1, 2, 3, 4, 5}

num2[2]  会报错，集合不支持索引

如何创建一个集合有两种方法：
1、直接把一堆元素用大括号括起来；
>>> set1 = {'小甲鱼','小鱿鱼','小甲鱼'}

2、使用set()工厂函数
>>> set2 = set(['小甲鱼','小鱿鱼','小甲鱼'])
>>> set1 == set2
True

课堂搞搞看

要求：去掉列表中重复的元素

[0, 1, 2, 3, 4, 5, 5, 3, 1]

方法一、

>>> list1 = [1,2,3,4,5,5,3,1,0]

>>> temp = list1[:]
>>> list1.clear()
>>> list1
[]
>>> for each in temp:
    if each not in list1:
        list1.append(each) #append()表示向列表中添加元素
        
方法二、
>>> list1 = list(set(list1))
>>> list1
[0, 1, 2, 3, 4, 5]
#set(list1)先将list1列表转变为集合， list(set(list1))再讲集合转变为列表

如何访问集合中的值

由于集合中的元素是无序的，所以并不能像序列那样用下标来进行访问，但是可以使用迭代把集合中的数据一个个读取出来

•可以使用for把集合中的数据一个个读取出来

>>> set1 = {1,2,3,4,5,4,3,2,1,0}
>>> for each in set1:
    print(each,end = ' ')

    
0 1 2 3 4 5 


•也可以通过in和not in判断一个元素是否在集合中已经存在

>>> 0 in set1
True
>>> 8 in set1
False

使用add()方法可以为集合添加元素，使用remove()方法可以删除集合中已知的元素：

>>> set1.add(6)
>>> set1
{0, 1, 2, 3, 4, 5, 6}
>>> set1.remove(5)
>>> set1
{0, 1, 2, 3, 4, 6}

不可变集合（把元素给froze冰冻起来）(像元组一样不能随意地增加或删除集合中的元素)

028 文件：因为懂你，所以永恒

>>> f = open("C:\\Users\Administrator\Desktop\讲座.txt",encoding ='utf-8')
>>> f
<_io.TextIOWrapper name='C:\\Users\\Administrator\\Desktop\\讲座.txt' mode='r' encoding='utf-8'>
>>> f.read
<built-in method read of _io.TextIOWrapper object at 0x0000023B92B56EE0>
>>> f.read()
'GFW、梯子、翻墙'
>>> f.read()
''
说明已经指向了文件的末尾，所以是end of file

>>>f=open("C:\\Users\Administrator\Desktop\讲座.txt",encoding ='utf-8')
>>> f.read(5)
'GFW、梯'
>>> f.tell()
9
一个英文、中午字符是2个字节+一个顿号
>>> f.seek(45,0)
45
>>> f.readline()
'ance\n'
>>> list(f)
	

>>> f.seek(0,0)
0
>>> lines = list(f)
>>> for eachLine in lines:
	print(eachLine)
	
等于

>>> f.seek(0,0)
0
>>> for eachLine in f :
	print(eachLine)

>>> f.write("I Love fishc.com")
Traceback (most recent call last):
  File "<pyshell#124>", line 1, in <module>
    f.write("I Love fishc.com")
io.UnsupportedOperation: not writable
#  io错误
>>> f = open('E:/test.txt','w')
>>> f.write("I Love fishc.com")
16
>>> f.close()
#关闭了就保存，不关闭就放在缓冲区

029 文件：一个任务

•任务：将文件（record.txt）中的数据进行分割并按照以下规律保存起来：

–小甲鱼的对话单独保存为boy_*.txt的文件（去掉“小甲鱼:”）

–小客服的对话单独保存为girl_*.txt的文件（去掉“小客服:”）

–文件中总共有三段对话，分别保存为boy_1.txt, girl_1.txt，boy_2.txt, girl_2.txt, boy_3.txt, gril_3.txt共6个文件（提示：文件中不同的对话间已经使用“==========”分割）

test1：

f = open("record.txt")

boy = []
girl = []
count = 1

for each_line in f:
    if each_line[:6] != '======':#判断是否连续读到六个=
        (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
        #将切得到的两部分内容依次存放在role与line_spoken中
        if role == '小甲鱼':
            boy.append(line_spoken)#将小甲鱼说的内容添加到列表boy中
        if role == '小客服':
            girl.append(line_spoken)#将小客服说的内容添加到列表girl中
    else:
        file_name_boy = 'boy_' + str(count) + '.txt'
        file_name_girl = 'girl_' + str(count) + '.txt'

        boy_file = open(file_name_boy,'w')#以w模式新建一个以file_name_boy命名的txt文件
        girl_file = open(file_name_girl,'w')#并贴上boy_file的标签

        boy_file.writelines(boy)#将列表boy中的内容写入到boy_file文件中
        girl_file.writelines(girl)

        boy_file.close()#关闭boy_file文件
        girl_file.close()

        boy = []#清空列表boy
        girl = []
        count += 1
		
file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'

boy_file = open(file_name_boy,'w')
girl_file = open(file_name_girl,'w')

boy_file.writelines(boy)
girl_file.writelines(girl)

boy_file.close()
girl_file.close()#记得关闭文件

test2：

def save_file(boy,girl,count):
    file_name_boy = 'boy_' + str(count) + '.txt'
    file_name_girl = 'girl_' + str(count) + '.txt'

    boy_file = open(file_name_boy,'w')
    girl_file = open(file_name_girl,'w')

    boy_file.writelines(boy)
    girl_file.writelines(girl)

    boy_file.close()
    girl_file.close()

def split_file(file_name):
    f = open(file_name)

    boy = []
    girl = []
    count = 1

    for each_line in f:
        if each_line[:6] != '======':
            (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
            #将切得到的两部分内容依次存放在role与line_spoken中
            if role == '小甲鱼':
                boy.append(line_spoken)
            if role == '小客服':
                girl.append(line_spoken)
        else:
            save_file(boy,girl,count)

            boy = []
            girl = []
            count += 1


    save_file(boy,girl,count)
    f.close()

split_file('record.txt')
str.split(str="", num=string.count(str)).

030 文件系统：介绍一个高大上的东西

模块是一个包含你定义的函数和变量的文件，后缀是.py，模块可以做到被别的程序所引入，以使用该模块中的函数等功能。

OS模块（Operating System操作系统）

对于文件系统的访问来说，Python一般是提供OS模块来实现就可以了，我们所知道常用的操作系统有：Windows，Mac OS，Linux，UNIX等，这些操作系统底层由于文件系统的访问工作原理不同，因此你可能就要针对不同的系统来考虑使用哪些文件系统模块…这样的做法是非常不友好且麻烦的，因为这样就意味着当你的程序运行环境一改变，你就要相应的去修改大量的代码来应付。但是我们的Python是跨平台的，所以Python就有了这个OS模块。

有了OS模块，我们不需要关心什么操作系统下使用什么模块，OS模块会帮你选择正确的模块并调用。

>>> import os
>>> os.getcwd()
'C:\\WINDOWS\\system32'
>>> os.chdir("E:\\")
>>> os.getcwd()
'E:\\'
>>> os.listdir()
['$RECYCLE.BIN', '248be78d-c1b4-49ce-8076-48127da1153e', 'cd', 'config.db', 'Config.Msi', 'DumpStack.log.tmp', 'LOL', 'MailMasterData', 'MinGW-w64', 'nginx-1.14.2',   'System Volume Information', 'systeminstalldiskconfig.ini',  '日常工具', '桌面文件', '火绒', '爱思', '破解软件', '迅雷']
>>> os.mkdir("E:\\A")
>>> os.mkdir("E:\\A\\B")

>>> os.mkdir("E:\\C\\B")
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    os.mkdir("E:\\C\\B")
FileNotFoundError: [WinError 3] 系统找不到指定的路径。: 'E:\\C\\B'

os模块中关于文件/目录常用的函数使用方法
函数名 --------------------- 使用方法
os模块中关于文件/目录常用的函数使用方法
os.path模块中关于路径常用的函数使用方法

动动手

1. 编写一个程序，统计当前目录下每个文件类型的文件数，程序实现如图：

import os
 
all_files = os.listdir(os.curdir) # 使用os.curdir表示当前目录更标准
type_dict = dict()
 
for each_file in all_files:
    if os.path.isdir(each_file):
        type_dict.setdefault('文件夹', 0)
        type_dict['文件夹'] += 1
    else:
        ext = os.path.splitext(each_file)[1]
        type_dict.setdefault(ext, 0)
        type_dict[ext] += 1
 
for each_type in type_dict.keys():
    print('该文件夹下共有类型为【%s】的文件 %d 个' % (each_type, type_dict[each_type]))

3. 编写一个程序，用户输入文件名以及开始搜索的路径，搜索该文件是否存在。如遇到文件夹，则进入文件夹继续搜索，程序实现如图：

import os
 
all_files = os.listdir(os.curdir) # 使用os.curdir表示当前目录更标准
file_dict = dict()
 
for each_file in all_files:
    if os.path.isfile(each_file):
        file_size = os.path.getsize(each_file)
        file_dict[each_file] = file_size
 
for each in file_dict.items():
    print('%s【%dBytes】' % (each[0], each[1]))

import os
 
def search_file(start_dir, target) :
    os.chdir(start_dir)
    
    for each_file in os.listdir(os.curdir) :
        if each_file == target :
            print(os.getcwd() + os.sep + each_file) # 使用os.sep是程序更标准
        if os.path.isdir(each_file) :
            search_file(each_file, target) # 递归调用
            os.chdir(os.pardir) # 递归调用后切记返回上一层目录
 
start_dir = input('请输入待查找的初始目录：')
target = input('请输入需要查找的目标文件：')
search_file(start_dir, target)

3. 编写一个程序，用户输入开始搜索的路径，查找该路径下（包含子文件夹内）所有的视频格式文件（要求查找mp4 rmvb, avi的格式即可），并把创建一个文件（vedioList.txt）存放所有找到的文件的路径，程序实现如图：

import os
 
def search_file(start_dir, target) :
    os.chdir(start_dir)
    
    for each_file in os.listdir(os.curdir) :
        ext = os.path.splitext(each_file)[1]
        if ext in target :
            vedio_list.append(os.getcwd() + os.sep + each_file + os.linesep) # 使用os.sep是程序更标准
        if os.path.isdir(each_file) :
            search_file(each_file, target) # 递归调用
            os.chdir(os.pardir) # 递归调用后切记返回上一层目录
 
start_dir = input('请输入待查找的初始目录：')
program_dir = os.getcwd()
 
target = ['.mp4', '.avi', '.rmvb']
vedio_list = []
 
search_file(start_dir, target)
 
f = open(program_dir + os.sep + 'vedioList.txt', 'w')
f.writelines(vedio_list)
f.close()

4. 编写一个程序，用户输入关键字，查找当前文件夹内（如果当前文件夹内包含文件夹，则进入文件夹继续搜索）所有含有该关键字的文本文件（.txt后缀），要求显示该文件所在的位置以及关键字在文件中的具体位置（第几行第几个字符），程序实现如图：
   

import os
 
def print_pos(key_dict):
    keys = key_dict.keys()
    keys = sorted(keys) # 由于字典是无序的，我们这里对行数进行排序
    for each_key in keys:
        print('关键字出现在第 %s 行，第 %s 个位置。' % (each_key, str(key_dict[each_key])))
 
 
def pos_in_line(line, key):
    pos = []
    begin = line.find(key)
    while begin != -1:
        pos.append(begin + 1) # 用户的角度是从1开始数
        begin = line.find(key, begin+1) # 从下一个位置继续查找
 
    return pos
 
 
def search_in_file(file_name, key):
    f = open(file_name)
    count = 0 # 记录行数
    key_dict = dict() # 字典，用户存放key所在具体行数对应具体位置
    
    for each_line in f:
        count += 1
        if key in each_line:
            pos = pos_in_line(each_line, key) # key在每行对应的位置
            key_dict[count] = pos
    
    f.close()
    return key_dict
 
 
def search_files(key, detail):    
    all_files = os.walk(os.getcwd())
    txt_files = []
 
    for i in all_files:
        for each_file in i[2]:
            if os.path.splitext(each_file)[1] == '.txt': # 根据后缀判断是否文本文件
                each_file = os.path.join(i[0], each_file)
                txt_files.append(each_file)
 
    for each_txt_file in txt_files:
        key_dict = search_in_file(each_txt_file, key)
        if key_dict:
            print('================================================================')
            print('在文件【%s】中找到关键字【%s】' % (each_txt_file, key))
            if detail in ['YES', 'Yes', 'yes']:
                print_pos(key_dict)
 
 
key = input('请将该脚本放于待查找的文件夹内，请输入关键字：')
detail = input('请问是否需要打印关键字【%s】在文件中的具体位置（YES/NO）：' % key)
search_files(key, detail)