python元组和文件

已于 2024-05-27 11:25:14 修改
阅读量175 收藏
点赞数
分类专栏： python学习 文章标签： python 开发语言 前端
于 2021-08-16 17:57:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Atopos__/article/details/119704406
版权

目录

元组:

 使用元组交换两个变量值

元组小结: 

字典:

字典语法:

 字典增加：

字典删除操作:

字典的查询：

字典的遍历：

文件访问模式:

打开文件(open):

 关闭文件close():

 读文件read():

 写文件write()

文件打开的另一种写法(推荐):

文件拷贝:

文件和目录操作:

元组:

  1. 元素tuple，使用的();
  2. 元素和列表非常相似，都可以存储多个数据，都可以存储任意类型的数据；
  3. 区别就是元组中的数据不能修改，列表中可以修改；
  4. 因为元组中的数据不能修改，所以只能查询方法，如index，count，支持下标和切片；
  5. 元组，主要用于传参和返回值。
# 元组可以从语法的层面来限制数据的意外修改
# 元组使用小括号来定义

my_tuple = (1, 2, 3)
print(my_tuple[0])

# 注意:元组中如果只有一个元素的话,需要在元素后面加逗号
my_tuple = (20,)
my_tuple = ((10,),)
print(my_tuple)
# 元组可以嵌套元组
my_tuple = ((1, 2), (10, 20))
print(my_tuple)

my_tuple = (1, 2, 3, 4)
for t in my_tuple:
    print(t)

#查询
pos = my_tuple.index(2)
print(pos)
#元组支持切片操作
my_tuple = (1,2,3,4)
print(my_tuple[1:])

 使用元组交换两个变量值

  1. 在定义元组的时候，小括号可以省略不写；
  2. 组包(pack)，将多个数据值组成元组的过程a = 1,2  # a = (1,2)；
  3. 拆包(解包unpack)，将容器中多个数据分别给到多个变量，需要保证容器中元素个数和变量个数保持一致。
a = 10
b = 20

#数据交换过程
c = b,a  #组包
print(c)  #(20, 10)
a,b = c  #拆包
print(a, b)  #20 10

#直接交换
a,b = b,a
print(a, b)

x,y,z = 'abc'
print(y)  #b

元组小结: 

  1. 元组一旦创建不可修改;
  2. 元组中只有一个元素时,需要在尾部额外添加一个逗号;
  3. 元组比列表更节省空间,因为列表可以添加元素,会导致列表一次性增加多余内存,元组不可以修改元素,因此占用内存固定;
  4. 元组是序列式容器,支持索引、切片操作.

字典:

        字典的查找效率比较高,但是比较占内存,字典以空间换时间.字典是非序列式容器,不支持索引、切片操作,字典的查询性能优于列表.

  1. 字典dict，使用{}表示；
  2. 字典是由键(key)值(value)对组成的，key:value；
  3. 一个键值对是一组数据，多个键值对之间使用逗号隔开；
  4. 在一个字典中，字段的键是不能重复的；
  5. 字典中的键主要使用字符串类型，可以是数字。
#1.类实例化的方式
my_dict1 = dict()
print(type(my_dict1),my_dict1)  #<class 'dict'> {}

#2.直接使用{}定义
#2.1 定义空字典
my_dict2 = {}
print(my_dict2)

#2.2 定义非空字典，姓名，年龄，身高，性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)

字典语法:

        字典是另一种可存储任意类型对象,字典的每个键值key=>value对用冒号(:)分隔,每个键值对之间用逗号(,)分割,整个字典包括在大括号{}中.

        键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一.

        格式:

my_dict = {key1:value1,key2:value2}
# 字典定义
def test01():
    my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
    print(my_dict['name'])
    print(my_dict[102])  # key 关键字,value 值
    my_dict['gender'] = '女'
    print(my_dict)

test01()

# 字典不支持索引,切片
def test02():
    my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
    print(my_dict[1])
    print(my_dict[1:])

# 获得字典的值
def test03():
    my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
    # 使用中括号这种访问字典中元素的方式,如果键不存在则报错.程序终止
    # print(my_dict['age1'])
    # 使用get方法,如果key不存在默认值返回None,也可以指定默认返回值,
    print(my_dict.get('age1', '默认返回值'))
# 添加和修改元素
def test04():
    my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
    # 如果key不存在则是新增元素
    my_dict['score'] = 90  # 添加新元素
    print(my_dict)
    # 如果key存在的话就是修改元素
    my_dict['name'] = 'AAA'
    print(my_dict)

 字典增加：

字典['键'] = 值

1.键存在，修改；

2.键不存在，添加。

#2.2 定义非空字典，姓名，年龄，身高，性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)

#3.将年龄改为20
my_dict3['age'] = 20
print(my_dict3)

#4.添加体重
my_dict3['weight'] = 65
print(my_dict3)

字典删除操作:

字典的删除是根据字典的键，删除键值对

字典.pop('键')

#2.2 定义非空字典，姓名，年龄，身高，性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)

#3.将年龄改为20
my_dict3['age'] = 20
print(my_dict3)

#4.添加体重
my_dict3['weight'] = 65
print(my_dict3)

#5.删除
my_dict3.pop('weight')
print(my_dict3)  #{'name': '小明', 'age': 20, 'height': 180, 'sex': '男'}
# 字典删除操作
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
del my_dict['aaa']
print(my_dict)
# 清空字典
my_dict.clear()
print(my_dict)

# del不仅能删除字典中的某个键值对,还能删除列表中的元素
# 1.删除某个变量
a = 10
del a
# print('a = ',a)

# 2.删除列表中的元素
my_list = [1,2,3]
del my_list[0]
print(my_list)

字典的查询：

根据字典的键，获取对应的值

方法一：字典['键']  #键不存在，会报错；

方法二：字典.get(键)  #键不存在，返回Nonem 

my_dict = {'name':'小明','age':20}

#获取name值
print(my_dict['name'])
print(my_dict.get('name'))

#获取sex
#print(my_dict['sex'])  #会报错，因为sex键不存在  KeyError: 'sex'
print(my_dict.get('sex'))  #None

字典的遍历：

字典存在键(key)，值(value)，遍历分为三种情况

1.遍历字典的键
#方式一:
for 变量 in 字典:
        print(变量)
#方式二:

for 变量 in 字典.keys():    #字典.keys()可以获取字典所有的键
        print(变量)
2.遍历字典的值(使用较多)
for 变量 in 字典.values():   #字典.values()可以获取字典中所有的值

        print(变量)

3.遍历字典的键和值

#变量1就是键,变量2就是值

for 变量1,变量2 in 字典.items():   #字典.items()获取的是字典的键值对

        print(变量1,变量2)

my_dict = {"name":"小明","age":18,"height":180,"sex":"男"}

for a in my_dict:
    print(a)

for b in my_dict.keys():
    print(b)

for c in my_dict.values():
    print(c)
    
for d in my_dict.items():
    print(d)
# 字典的遍历
#由于字典是非序列式列表,因此不能直接遍历,需要转换成列表再遍历
# keys方法可以获得所有的键列表
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
key_list = my_dict.keys()
print(list(key_list))

# keys方法获得所有的值列表
value_list = my_dict.values()
print(list(value_list))

# keys方法可以获得所有的键值对列表,每一个键值对都是一个元素
key_values_list = my_dict.items()
print(list(key_values_list))

for key_value in key_values_list:
    # print('key:',key_value[0],'value:',key_value[1])
    print(key_value)

使用while遍历字典:

# 使用while循环遍历字典
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
my_list = list(my_dict.items())
i = 0
while i < len(my_dict):
    print('key: ',my_list[i][0],'value:',my_list[i][1])
    i += 1

文件访问模式:

访问模式说明
r以只读方式打开文件,文件的指针将会放在文件的开头,这是默认模式.
w打开一个文件只用于写入,如果该文件已存在则将其覆盖,如果该文件不存在,创建新文件.
a打开一个文件用于追加.如果该文件已存在,文件指针将会放在文件的结尾.也就是说,新的内容将会被写入到已有内容之后.如果该文件不存在,创建新文件进行写入.
rb以二进制格式打开一个文件用于只读.文件指针将会放在文件的开头,这是默认模式.
wb以二进制格式打开一个文件只用于写入,如果该文件已存在则将其覆盖,如果该文件不存在,创建新文件.
ab以二进制格式打开一个文件用于追加,如果该文件已存在,文件指针将会放在文件的结尾,也就是说,新的内容将会被写入到已有内容之后,如果该文件不存在,创建新文件进行写入.

程序:hello world\n

Windows:hello world\r\n

Mac:hello world\r\

Linux:hello world\n

        打开文件用的文本模式,会进行换行符的转换;打开文件用的是二进制模式的话,不会进行换行符转换.文件本质上都是以二进制的方式存储在磁盘上的.

打开文件(open):

open(file, mode='r', encoding=None)
--file:表示要操作的文件的名字,可以使用相对路径和绝对路径
       --绝对路径,从根目录开始书写的路径 C:/  D:/
       --相对路径,从当前目录开始书写的路径 ./  ../
--mode:打开文件的方式
       -r,只读打开,read,如果文件不存在,会报错
       -w,只写打开,write,如果文件存在,会覆盖原文件
       -a,追加打开,append,在文件的末尾写入新的内容
--encoding:编码格式,指二进制数据和汉字转换的规则
       -utf-8(常用):将一个汉字转换为3个字节的二进制
       -gbk:将一个汉字转换为2个字节的二进制
返回值:文件对象,后续对文件的操作,都需要这个文件对象

# 文件打开模式
def test01():
    """读方式打开文件"""
    f = open('a.txt', 'r')
    content = f.read()
    print(content)
    f.close()


def test02():
    # w模式默认是会覆盖文件中的数据的
    # w模式如果发现文件不存在,则会新建文件
    f = open('a.txt', 'w')
    f.write('hello world!')
    f.close()

# 追加
def test03():
    f = open('a.txt', 'a')
    f.write('\nhello python')
    f.close()


# test01()
# test02()
test03()

 关闭文件close():

文件对象.close()  #关闭文件,如果是写文件,会自动保存,即将内存中的数据同步到硬盘中

 读文件read():

文件对象.read()

返回值:返回读取到的文件内容,类型是字符串

# 使用open函数打开一个文件
fa = open('a.txt', 'w')

my_content = 'hello world!第一次写入文件!'
fa.write(my_content)

# 关闭文件
fa.close()

# 2.读取文件数据
fb = open('b.txt', 'r', encoding='utf-8')
# read函数默认读取文件中所有数据
my_content = fb.read()
fb.close()
print(my_content)

# 写文件:write writelines
def test01():
    """1.write函数用法"""
    f = open('a.txt', 'w')
    # write函数一次写一行
    f.write('hello world!')
    # wrirelines一次可以写多行,参数是一个列表,列表每一个元素都是一行数据
    lines = ['aaa\n', 'bbb\n', 'ccc\n']
    f.writelines(lines)
    f.close()


def test02():
    """2.读操作"""
    f = open('a.txt', 'r')
    # read没有指定参数,则读取文件中的所有数据
    # read指定参数,则读取参数中指定个数的数据
    content = f.read()
    f.close()

    print(content)


def test03():
    """一次读取一行"""
    f = open('a.txt', 'r')
    content = f.readline()
    print(content)
    f.close()


def test04():
    """一次读取所有行"""
    f = open('a.txt', 'r')
    # content = f.readlines()
    # print(content)
    lines = f.readlines()
    print(lines)
    for line in lines:
        if line[-1] == '\n':
            print(line[:-1])
        else:
            print(line)

    f.close()


# test01()
# test02()
# test03()
test04()

 写文件write()

文件对象.write()

#参数:写入文件的内容,类型字符串

#返回值:写入文件中的字符数.字符串的长度一般不关注

#1.打开文件
f = open('a.txt','w',encoding='utf-8')
#2.写文件
f.write('好好学习/天天向上')
#3.关闭文件
f.close()

文件打开的另一种写法(推荐):

with open(file,mode,encoding) as 变量:  #变量就是文件对象
        pass
#使用这些写法打开文件,会自动进行关闭,不用手动书写关闭的代码
#出了with的缩进之后,文件就会自动关闭

with open('a.txt',encoding='utf-8') as f:
    buf = f.read()
    print(buf)

文件拷贝:

# 1.获得要拷贝的文件名
old_file_name = input('请输入您要拷贝的文件名:')
# 2.读取要拷贝的文件内容
new_file_name = old_file_name + '.bk'
# 3.打开新的文件
f_old = open(old_file_name,'rb')
f_new = open(new_file_name,'wb')
# 4. 将老文件内容写到新文件里面
old_file_content = f_old.read()
f_new.write(old_file_content)
# 5.关闭新老文件
f_old.close()
f_new.close()

文件和目录操作:

# 文件和目录操作
import os

def test01():
    """文件重命名"""
    os.rename('a.txt', 'cmt.txt')


def test02():
    """文件删除"""
    # 路径问题:如果只写文件名,默认只在当前目录下找文件,如果找不到就报错!
    os.remove(r'C:\USERS\30467\DESKTOP\A.TXT')


def test03():
    """创建和删除目录"""
    # os.mkdir(r'C:\USERS\30467\DESKTOP\cj')
    os.rmdir(r'C:\USERS\30467\DESKTOP\cj')


def test04():
    """获得指定目录下的文件列表"""
    content = os.listdir()
    print(content)


def test05():
    """获得和设置工作目录"""
    cwd = os.getcwd()  # cwd current working directory
    print(cwd)
    # 将默认的工作目录设置到我的桌面了
    os.chdir(r'C:\USERS\30467\DESKTOP')
    os.mkdir('aaa')


# test01()
# test02()
# test03()
# test04()
test05()

Atopos__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python文件读取写入元组_python元组，和文件进行操作
weixin_35286433的博客
01-14 1566
新手刚刚开始学习python，如有写错或者写的不好的地方，请大家多多指导!python元组相加a = (1,2)b = (3,4)a + b元组运用乘法(1,2) * 4#在这里边，元组不会被当成数字来计算，而是输出4次给字母类型的元组拍t = ('bb,','dd','aa','cc')tm = list(t)tm.sort() #然后输出tmt = tuple(tm)用for的方式运...
python文件读取写入元组_python文件和元组
weixin_36370242的博客
12-23 2188
python文件操作相较于java，Python里的文件操作简单了很多python 获取当前文件所在的文件夹：os.path.dirname(__file__)写了一个工具类，用来在当前文件夹下生成文件，这样方便classUtil():"""工具类"""@classmethoddefget_file_url(cls, file_name):"""获取当前文件夹的路径"""return os.pat...
Python的列表和元组使用详解
07-29
本篇文档中介绍了列表与元组的通用序列操作以及列表的基础操作，还有关于分片的详解（全中文注释适合初学者以及不太懂英语的看）
Python元组（tuple），字符串，读取文件。
w01k1y7的博客
04-09 680
名字 = '元素' 或 名字 = "元素" 或 名字 = '''元素'''(三个单引号)当元素内有单引号，双引号或三个单引号时，元素外侧不得用元素内部有的引号括起，否则会报错。for 名字 in = f.readlines()列表的元素是可以更改的，包括修改元素值，删除和插入元素；名字.replace('被替换的字符'，'替换的字符')而tuple一旦被创建，它的元素就不可更改了。格式：print（type（名字））名字.strip(想删除的首尾字符)名字 = f.read（）
Python核心数据类型——元组与文件
愤怒的懒洋洋的博客
06-14 1279
Python核心数据类型——元组与文件一、前言        在Python中，数据是以对象的形式存在的，通俗的来讲就是一切皆对象。Python对象主要包含以下几种类型数字；字符串；列表；字典；元组；文件；集合。（以上不是全部但是是主要的，后期会介绍像 函数，方法，类，模块这些也可以称作对象）本次我们介绍的是——元组和文件。二、核心数据类型——元组        元组是序列的一种，在python中...
python3学习笔记（字典）
october_autumn的博客
03-06 311
定义 1. 字典是无序对象的集合。 2. 字典用花括号{}定义。 3. 字典中键值(key => value)对用冒号:分隔，每个对中间用,分隔。 键key是索引 值value是数据 键必须是唯一的 键必须是不可变的，如字符串、数字或元组 值可以是任意类型对象 例如： people = { "name": "xiaoming", "age": 18, "male"...
python将元祖写入txt文档_python元组及文件
weixin_27427619的博客
02-10 2729
一、元组学习：() 空元组t1=(0,) 单个元素的元组t2=(0,'Ni',1.2,3) 四个元素的元组t2=0,'Ni',1.2,3 另一个四元素的元组t3=('abc',('def','ghi'))t1[i] 索引t3[i][j] 索引的索引t1[i:j] 分片len(t1) ...
python元组是有序还是无序_python-03 元组和字典
weixin_39592240的博客
12-08 9876
(一)、元组：元组是元素以逗号分隔，以小括号包围的有序的，不可修改的序列。tuple()(1,2,3,'a')#元组的定义ourTuple = tuple('abc')print(ourTuple)print("".join(ourTuple))#元组的索引元组索引与字符串基本一致ourTuple = tuple("0123456789")print(ourTuple)print(ourTuple...
python元组转化为json数据_如何将JSON数据转换为Python元组？
weixin_33946999的博客
02-09 1388
您可以先使用json.loads将json转换为dict，然后使用dict.items()将其转换为python元组。您可以使用Python中的json模块解析JSON文件。该模块解析json并将其放入字典中。然后，您可以像普通字典一样从中获取值。例如，如果您的json具有以下内容-示例{"id":"file","value":"File","popup":{"menuitem":[{"v...
Python元组及文件核心对象类型详解
09-20
本篇文章主要给大家详细讲述了Python核心对象类型之元组及文件的相关内容，对此有兴趣的学习下。
Python 元组tuple详解
08-02
1、本文主要讲解了一些关于元组的知识，包括创建元组、访问元组以及对元组内置函数和方法进行了一些整理，最后还有关于元组的知识汇总。 2、本文件是markdown文件，是本人辛辛苦苦整理出来的，一份耕耘一份收获。 3...
元组推导式代码python
08-24
在给定的文件中，我们可以看到一个简单的元组推导式示例： ```python randomnumber = (random.randint(10,100) for i in range(10)) ``` 这个示例使用了`random`模块的`randint`函数生成一个随机整数，然后将其作为...
Python核心数据类型demo——元组与文件
06-14
python核心数据类型-元组与文件demo,这是可以查看我的博客，借鉴学习博客地址为：https://blog.csdn.net/qq_25814003/article/details/80694354
python元组操作_python元组操作
weixin_39672194的博客
11-24 546
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！python元组相加a = (1,2)b = (3,4)a + b元组运用乘法(1,2) * 4#在这里边，元组不会被当成数字来计算，而是输出4次给字母类型的元组拍t = (bb,dd,aa,cc)tm = list(t)tm.sort()#然后输出tmt = tuple(tm)用f...
python学习笔记：元组（turple）、文件（file）及其他
我
08-19 3108
python学习笔记：元组（turple）、文件（file）及其他 一、元组（turple） 元组（turple）是由简单的对象构成的，十分类似于列表，不同的地方在于元组是不可在原处修改的，并且通常以圆括号与圆括号中的一系列项的形式展示出来。 元组（turple）的位置是有序的，可以通过偏移来访问，因此也就支持索引、分片与合并等操作。 元组（turple）具有固定的长度，在不生成一个拷贝的情况下...
每日一题——Python实现PAT乙级1042 字符统计（举一反三+思想解读+逐步优化）
weixin_44915521的博客
06-09 1124
这些编程思想和哲学理念在编写高效、健壮的代码时至关重要。通过理解和应用这些原则，我们不仅能够写出性能更好的代码，还能在不同情况下做出更加明智的设计决策。通过理解和应用这些哲学和编程思想，可以在不同场景中灵活运用，写出更加高效、健壮和灵活的代码。评估需求：根据实际需求选择最合适的数据结构和算法。避免冗余：尽量避免不必要的重复计算和操作。权衡利弊：在空间和时间之间找到最佳平衡点。灵活应变：根据输入数据的特性，灵活使用动态数据结构和提前决策策略。
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1330
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 395
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Python用元组读取文件的格式
05-31
在这个示例中，我们使用了Python的csv库来读取CSV文件。在每一行数据被读取后，将其转换为元组并打印出来。其中，`delimiter`参数指定了CSV文件中的分隔符，`quotechar`参数指定了CSV文件中的引号字符。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值