标签：boy python 30 笔记 file each girl txt os

笔记纲要

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名字标签而已。原元组由于标签没有了，则会被自动回收。

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

函数	注释
capitalize()	把字符串的第一个字符改成大写
手机	$12
导管	$1

内容来源于：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)

标签：boy,python,30,笔记,file,each,girl,txt,os
来源： https://blog.csdn.net/iron____/article/details/121432482

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。