python-基础 列表 集合 字典 文件处理

目录

  1. 列表、元组操作
  2. 字典操作
  3. 集合操作
  4. 文件操作

1.列表、元组操作

 列表是最常用的数据类型之一,通过列表可以对数据实现最方便的存储、修改等操作

定义列表

names = ["张三","李四","王麻子"]

通过下标取列表中的数据.下标按0开始计算

names = ["张三","李四","王麻子"]
print(names[0])
张三
print(names[1])
李四
print(names[2])
王麻子
注意:也可以倒着取
print(names[-3])
张三
print(names[-2])
李四
print(names[-1])
王麻子

切片:取多个元素(顾头不顾尾.不取尾)

names = ["张三","李四","王麻子","疯子","傻子"]
print(names[0:2])
[‘张三‘, ‘李四‘]
print(names[:3])
[‘张三‘, ‘李四‘, ‘王麻子‘]
print(names[1:])
[‘李四‘, ‘王麻子‘, ‘疯子‘, ‘傻子‘]
print(names[0::2])
[‘张三‘, ‘王麻子‘, ‘傻子‘]
print(names[::2])
[‘张三‘, ‘王麻子‘, ‘傻子‘]

追加(在最后一位增加)

names = ["张三","李四","王麻子","疯子","傻子"]
names.append("SB")
print(names)<br>[‘张三‘, ‘李四‘, ‘王麻子‘, ‘疯子‘, ‘傻子‘, ‘SB‘]

插入(随便在什么地方插入)

names = ["张三","李四","王麻子","疯子","傻子"]
names.insert(2,"老寒腿")
names.insert(5,"大脚")
print(names)
[‘张三‘, ‘李四‘, ‘老寒腿‘, ‘王麻子‘, ‘疯子‘, ‘大脚‘, ‘傻子‘, ‘SB‘]

修改

names = ["张三","李四","王麻子","疯子","傻子"]
names[2] = ("麻子")
print(names)
[‘张三‘, ‘李四‘, ‘麻子‘, ‘疯子‘, ‘傻子‘]

删除

#指定删除下标对应的
names = ["张三","李四","王麻子","疯子","傻子"]
del  names[4]
print(names)
[‘张三‘, ‘李四‘, ‘王麻子‘, ‘疯子‘]

#使用remove删除时只能删除第一个出现的
names = ["张三","李四","李四","王麻子","疯子","傻子"]
names.remove("李四")
print(names)
[‘张三‘, ‘李四‘, ‘王麻子‘, ‘疯子‘, ‘傻子‘]

#使用pop删除时删除列表中的最后一个值
names = ["张三","李四","李四","王麻子","疯子","傻子"]
names.pop()
print(names)
[‘张三‘, ‘李四‘, ‘李四‘, ‘王麻子‘, ‘疯子‘]

拷贝(此处的拷贝是浅拷贝.意思是只拷贝第一层)

names = ["张三","李四","李四","王麻子","疯子","傻子"]
names_copy = names.copy()
print(names_copy)
[‘张三‘, ‘李四‘, ‘李四‘, ‘王麻子‘, ‘疯子‘, ‘傻子‘]

统计

names = ["张三","李四","李四","王麻子","疯子","傻子"]
print("李四出现次数:",names.count("李四"))
李四出现次数: 2

排序

names = ["张三","李四","李四","王麻子","疯子","傻子","3","2"]
names.sort()
print(names)
[‘2‘, ‘3‘, ‘傻子‘, ‘张三‘, ‘李四‘, ‘李四‘, ‘王麻子‘, ‘疯子‘]
#3.0里不同数据类型不能放在一起排序了

获取下标

names = ["张三","李四","李四","王麻子","疯子","傻子","1","3","2"]
print("李四的下标是:",names.index("李四"))
李四的下标是: 1    <br>#只返回找到的第一个下标

2.字典操作

字典一种key - value的数据类型。

K怎么定义调用的时候就得怎么调用。
key 定义规则:1.不可变:数字,字符串,元组(可变:列表,字典)。K 唯一(如果K定义重复那么取的时候只取最后一次出现的)v 定义规则:任意类型字典:定义符号(),与列表完全一致,唯一不同的是元组内元素不可变语法:
dic = {name:"Yuhl",age=18,QQ=2878****}
特性:无序
     Key必须唯一.

增加

dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
dic["Phone"] = "110"
print(dic)               #增加

{‘Phone‘: ‘110‘, ‘age‘: ‘18‘, ‘QQ‘: ‘2878****‘, ‘name‘: ‘Yuhl‘}

dic00 = {"name":{"Yuhl":{"age","QQ"},"QQ":"111"},"age":18}
dic00.setdefault("gender","zhang") #增加,随机
print(dic00)

修改

dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
dic ["name"] = "Yuhonglin"
print(dic)                           注意:K值无法进行修改.只能修改value
{‘QQ‘: ‘2878****‘, ‘age‘: ‘18‘, ‘name‘: ‘Yuhonglin‘}

dic00 = {"name":{"Yuhl":{"age","QQ"},"QQ":"111"},"age":18}
dic00.update(name="YUHONGLIN",gender="name")     #修改和新增
print(dic00)
{‘age‘: 18, ‘gender‘: ‘name‘, ‘name‘: ‘YUHONGLIN‘}

删除

#删除
dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
del dic["name"]
print(dic)

{‘QQ‘: ‘2878****‘, ‘age‘: ‘18‘}
#标准删除
dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
dic.pop("name")
print(dic)

{‘age‘: ‘18‘, ‘QQ‘: ‘2878****‘}
#随机删除
dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
dic.popitem()
print(dic)  多试几次有效果

查找

dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
print("打印结果是:",dic.get("name"))       #获取

打印结果是:Yuhl
dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
print("打印结果是:",dic["name"])           #与之前的一样

打印结果是:Yuhl
dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
print("打印结果是:","stu1102" in dic)

打印结果是:False                            #在字典中有返回True否则返回False

dic = {"name":"Yuhl","age":"18","QQ":"2878****"}
print("打印结果是:",dic["stu1105"])         #如果一个key不存在会报错. get不会直接返回None

其他方法:

dic00 = {"name":"Yuhl","age":18}
dic00.clear()         #清空
print(dic00)
答应出来的信息是:{}

dic00 = {"name":{"Yuhl":{"age","QQ"},"QQ":"111"},"age":18}
dic000002= dic00.fromkeys(["a","b"],1)        #快速生成字典
print(dic000002)

自动生成的字典是: {‘b‘: 1, ‘a‘: 1}  

dic00 = {"name":{"Yuhl":{"age","QQ"},"QQ":"111"},"age":18}
for k,v in dic00.items():
    print(k,v)                  #列表打印
    print(k[0],v)              #列表打印

dic000 = {"name":"Yuhl","age":18,"QQanddianhua":[110,133]}
dic00new = dic000.copy()                 #拷贝.浅拷贝
print(dic00new,"\n",dic000)

dic00 = {"name":{"Yuhl":{"age","QQ"},"QQ":"111"},"age":18}  
dic00["QQanddianhua"]="11222","111111"        #拷贝
print("\n",dic00)
{‘age‘: 18, ‘QQanddianhua‘: (‘11222‘, ‘111111‘), ‘name‘: {‘QQ‘: ‘111‘, ‘Yuhl‘: {‘age‘, ‘QQ‘}}}

3、集合

作用:去重复 和 关系运算(集合分别有:交集、差集、并集)其他方法:

#交集

python_set = {"alex","lhf","zhangsan","lisi","wangmazi"}
linux_set = {"alex","lhf","Yuhl","dsd"}
print(python_set&linux_set)             #求两个集合里面出现相同的数
print(python_set.intersection(linux_set))
print(python_set&linux_set)
print(python_set.intersection(linux_set))
  :{‘lhf‘, ‘alex‘}
  :{‘lhf‘, ‘alex‘}
  :{‘lhf‘, ‘alex‘}
  :{‘lhf‘, ‘alex‘}
python_set = {"alex","lhf","zhangsan","lisi","wangmazi"}
linux_set = {"alex","lhf","Yuhl","dsd"}<br>
#并集
print(python_set|linux_set)     #去重复
print(python_set.union(linux_set)) #去重复
  :{‘lhf‘, ‘Yuhl‘, ‘dsd‘, ‘alex‘, ‘wangmazi‘, ‘lisi‘, ‘zhangsan‘}
  :{‘lhf‘, ‘Yuhl‘, ‘dsd‘, ‘alex‘, ‘wangmazi‘, ‘lisi‘, ‘zhangsan‘}

# #差集
python_set = {"alex","lhf","zhangsan","lisi","wangmazi"}
linux_set = {"alex","lhf","Yuhl","dsd"}
print(python_set-linux_set) #去掉重复的
print(python_set.difference(linux_set))
print(linux_set-python_set) #去掉重复的
print(linux_set.difference(python_set))
{‘lisi‘, ‘zhangsan‘, ‘wangmazi‘}
{‘dsd‘, ‘Yuhl‘}

#并集
python_set = {"alex","lhf","zhangsan","lisi","wangmazi"}
linux_set = {"alex","lhf","Yuhl","dsd"}
print(python_set|linux_set)        #去重复(将两个重复数据打印出来.合并在一起)
print(python_set.union(linux_set)) #去重复(将两个重复数据打印出来.合并在一起)

#d对称差集
python_set = {"alex","lhf","zhangsan","lisi","wangmazi"}
linux_set = {"alex","lhf","Yuhl","dsd"}
print(python_set^linux_set)#把共有的地方去掉就是对称差集
print(python_set.symmetric_difference(linux_set))
 :{‘lisi‘, ‘dsd‘, ‘zhangsan‘, ‘wangmazi‘, ‘Yuhl‘}
 :{‘lisi‘, ‘dsd‘, ‘zhangsan‘, ‘wangmazi‘, ‘Yuhl‘}

s1 = {1,2,3,4,5}
s2 = {2,3}
#子集
print(s1 <= s2) #s2是s1的子集
print(s1.issubset(s2))

#父集
print(s2 <= s1) #s1是s2的父集
print(s1.issuperset(s2))

s3 = set(["he","l","1","1",1,2,3])
print(s3)

其他方法:

#更新
s1 = {1,2,3}
s2 ={"YHL"}
s1.update(‘e‘)          #插入
s1.update((1,2,3,4,5))   #去重进行写入
s1.update("hello")
s1.update(s2)
print(s1)

#增加
s1 = {1,2,3}
s1.add("Hello")     #整个加入
print(s1)

#删除
s3 = {1,2,3,4,5,6,7,8,9,10}
s3.pop()
print(s3)           #随机删除
s3.remove(10)       #指定删除  如果没有会报错
print(s3)
s3.discard("a")        #不报错的删除  没有也不会报错.有不会报错
print(s3,"------")

4.文件处理

  

 

时间: 2024-10-24 00:50:43

python-基础 列表 集合 字典 文件处理的相关文章

python基础(集合、文件操作)

集合: 集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的.以下是集合最重要的两点: 去重,把一个列表变成集合,就自动去重了. 关系测试,测试两组数据之前的交集.差集.并集等关系. 1,集合的创建. set1 = set({1,2,'barry'}) set2 = {1,2,'barry'} print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'} 2,集合的增. set1 = {'

python基础&mdash;&mdash;列表、字典

Python核心数据类型--列表 列表是一个任意类型的对象的位置相关的有序集合,它没有固定的大小.大小可变的,通过偏移量进行赋值以及其他各种列表的方法进行调用,能够修改列表.其他更多的功能可以查阅python的标准手册,或者运行help(list)或dir(list)查看list方法的完整清单. 任意对象的有序集合:从功能上看,列表是收集其他对象的地方,同时列表所包含的每一项都保持了从左到右的位置顺序. 通过偏移读取:可以通过列表对象的偏移对其进行索引,从而读取对象的某一部分内容.由于列表的每一

python基础_集合、文件操作

集合 集合是一个无序的且数据不会重复.有去重.关系测试的作用 list = ["11","22","33","44","55"] list = set(list) print(list,type(list)) 结果为: {'33', '11', '22', '55', '44'} <class 'set'> 关系测试list1 = set(["11","22&quo

python基础(集合,文件操作)

一.集合(set) 集合:1.无序的,不重复的 2.他里面的元素必须是可哈希的. int str bool () ,但是它本身是不可哈希的.   3.集合不能更改里面的元素   4.集合可以求交集,并集,差集,反交集等. 1.集合的创建 set1 = set({1,2,'alex'}) set2 = set1 print(set1,set2) # 输出结果:{1, 2, 'alex'} {1, 2, 'alex'} 2.集合的增(2种方式) 1.set1.add()(直接增加) set1 = {

Python 列表\集合\ 字典推导式、生成器表达式

Python 列表\集合?字典推导式.生成器表达式 列表推导式 循环模式 l1 = [i for i in range(1,11)] l2 = [i ** 2 for i in range(100)] l3 = [f'python{i}' for i in range(50)] 筛选模式: l1 = [i for i in range(1,31) if i % 3 == 0] 嵌套循环: names = [['tom','billy','jefferson'],['wesley','steven

萌新向Python数据分析及数据挖掘 第一章 Python基础 第十节 文件和异常

第一章 Python基础 第十节 文件和异常 从文件中读取数据 读取文件.文件路径   1 filename = 'pi_digits.txt' #文件名取个代号 2 #读取整个文件 3 with open(filename) as file_object: 4 contents = file_object.read()# 给内容取个代号 5 print(contents.rstrip()) 6 #逐行读取 7 with open(filename) as file_object: 8 for

Python基础知识(五)------字典

Python基础知识(四)------字典 字典 一丶什么是字典 ? dict关键字 , 以 {} 表示, 以key:value形式保存数据 ,每个逗号分隔 ? 键: 必须是可哈希,(不可变的数据类型),必须是唯一的 ? 值: 任意数据类型 特点: ? 查询的效率非常高,通过key来查找元素 ? 内部使用key来计算一个内存地址(暂时), hash算法,key必须是不可变的数据类型(key 必须是可哈希的数据类型),key必须是不可变的数据类型 ? 字典是无序的, python3.6版本以上,默

Python基础(8)--文件

文件可以通过调用open或file来打开,open通常比file更通用,因为file几乎都是为面向对象程序设计量身打造 本文地址:http://www.cnblogs.com/archimedes/p/python-file.html,转载请注明源地址. 打开文件 打开文件程序会调用内置的open函数,首先是外部名,接着就是处理模式. 常见的文件运算: 在任何情况下,Python程序中的文本文件采用字符串的形式,读取文本时会返回字符串形式的文本 从文件中读取的数据回到脚本时是一个字符串,所以如果

python中列表 元组 字典 集合的区别

列表 元组 字典 集合的区别是python面试中最常见的一个问题.这个问题虽然很基础,但确实能反映出面试者的基础水平. (1)列表 什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单.比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单.由于我们买一种东西可能不止一次,所以清单中是允许有重复项的.如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的.pyt