python 入门基础3(元祖，字典，集合)

## 元组 tuple

1 常用的操作方法+内置方法

#优先掌握的操作：

#1 按照索引取值（正方向）：只能取：

t1 = (11, 22, 33, ‘sea‘, [1, 66, 77, 100])
print(t1[4][1])

t1 = (11, 22, 33, ‘sea‘, [1, 66, 77, 100])

# 取值print(t1[2])

#切片 （顾头不顾尾，步长）

print(t1[0:3])print(t1[0:4],3)

#长度 len()

print(len(t1))

# 成员运算 in ， not in

print(‘xxx‘ in t1)

print(‘xxx‘ not in t1)

## 循环

for i in t1:    print(i)

#### 需要掌握的操作：

t = (‘a‘, 2, 3, 4, 5, 6, 1, 11)print(t.index(‘a‘))print(t.count(1))

### 字典dict

# 补充：

# 不可变类型=》可hash类型

# 可变类型 =》不可以hash类型

#一：基本使用dict

# 1 用途：记录多个值，每一个值都对应的key用来描述value的作用

# 2 定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型

dic={0:‘aaa‘,1:‘bbb‘,2:‘cccc‘}  # dic=dict({0:‘aaa‘,1:‘bbb‘,2:‘cccc‘})
print(dic,type(dic))
print(dic[0])

dic={[1,2]:‘aaa‘}
dic={(1,2):‘aaa‘}
print(dic[(1,2)])

# 用法一：

d = dict(a=1,b=2,c=3)
print(d)

{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

# 用法二：

userinfo = [
    [‘name‘,‘qqq‘],
    [‘age‘, 88],
    [‘sex‘,‘male‘]
]
d = {}
for k,v in userinfo:

    print(k,v)
    d[k] = v
print(d)

#优先掌握的操作：

#1、按key存取值：可存可取

dic={‘name‘:‘egon‘}
print(dic[‘name‘])
dic[‘name‘]=‘EGON‘
print(dic)
dic[‘age‘]=18
print(dic)

#2、长度len

dic={‘name‘:‘egon‘,‘age‘:18,‘name‘:‘EGON‘,‘name‘:‘XXXX‘}
print(dic)
print(len(dic))

#3、成员运算in和not in:字典的成员运算判断的是key

###3、成员运算in和not in:字典的成员运算判断的是key

d3 = {‘name‘:‘egon‘,‘age‘:18,}

print(‘name‘ in d3)print(‘age‘ in d3)

#4 删除

dic = {‘name‘:‘egon‘, ‘age‘:18}

del dic[‘name‘]

print(dic)

res = dic.pop(‘age‘)print(res)

#5. 键keys(), 值 values，键值对 items， 注意 python2 与 python3 之间的区别

dic = {‘name‘:‘egon‘, ‘age‘:88}
print(dic.keys())

l = []
for k in dic.keys():
    l.append(k)
print(l)

print(list(dic.keys()))

print(dic.values())

print(dic.items())  返回结果；

[‘name‘, ‘age‘]
[‘name‘, ‘age‘]
dict_values([‘egon‘, 88])
dict_items([(‘name‘, ‘egon‘), (‘age‘, 88)])

#6、循环

dic = {‘name‘:‘egon‘, ‘age‘:18, ‘sex‘:‘male‘}
for k in dic.keys():
    print(k, dic[k])

for k in dic:
    print(k, dic[k])

for v in dic.values():
    print(v)

for k,v in dic.items():
    print(k, v)

返回结果：

name egon
age 18
sex male
name egon
age 18
sex male
egon
18
male
name egon
age 18
sex male

###8 dict.get()

print(dic.get(‘name‘))

print(dic.get(‘xxx‘)) ### 如果K 不存在，返回 None

# 需要掌握的操作：

# setdefault: 有则不动/返回原值,无则添加/返回新值 dic2 = { ‘name‘:‘egon‘, ‘age‘:18print(dic2.setdefault(‘name‘,‘ooo‘)) 返回：egon

dic2 = { ‘name‘:‘egon‘, ‘age‘:18}print(dic2.setdefault(‘name‘,‘ooo‘)) #返回：egonprint(dic2.setdefault(‘sex‘,‘male‘)) #返回：male

## 集合set

pythons=[‘李二丫‘,‘张金蛋‘,‘李银弹‘,‘赵铜蛋‘,‘张锡蛋‘,‘alex‘,‘oldboy‘]

linuxs=[‘lxx‘,‘egon‘,‘张金蛋‘,‘张锡蛋‘,‘alex‘,‘陈独秀‘]

l=[]

for stu in pythons:

if stu in linuxs:

l.append(stu)

print(l)

#一：基本使用:set

# 1 用途: 关系运算,去重

# 2 定义方式: 在{}内用逗号分开个的多个值

# 集合的三大特性:

# 2.1 每一个值都必须是不可变类型

# 2.2 元素不能重复

# 2.3 集合内元素无序

s={1,3.1,‘aa‘,(1,23),} # s=set({1,3.1,‘aa‘,(1,23),})

print(s,type(s))

s={1,1,1,1,1,1,1,1,1,2,3}

print(s)

s={‘a‘,‘b‘,‘c‘}

s[0]

s=set(‘hello‘)

print(s)

print(set([‘a‘,‘b‘,‘c‘,[1,2]]))

# 3 常用操作+内置的方法

pythons={‘李二丫‘,‘张金蛋‘,‘李银弹‘,‘赵铜蛋‘,‘张锡蛋‘,‘alex‘,‘oldboy‘}

linuxs={‘lxx‘,‘egon‘,‘张金蛋‘,‘张锡蛋‘,‘alex‘,‘陈独秀‘}

# 取及报名python课程又报名linux课程的学员:交集

print(pythons & linuxs)

print(pythons.intersection(linuxs))

# 取所有报名老男孩课程的学员:并集

print(pythons | linuxs)

print(pythons.union(linuxs))

# 取只报名python课程的学员: 差集

print(pythons - linuxs)

print(pythons.difference(linuxs))

# 取只报名linux课程的学员: 差集

print(linuxs - pythons)

print(linuxs.difference(pythons))

# 取没有同时报名两门课程的学员:对称差集

print(pythons ^ linuxs)

print(pythons.symmetric_difference(linuxs))

# 是否相等

s1={1,2,3}

s2={3,1,2}

print(s1 == s2)

# 父集:一个集合是包含另外一个集合

s1={1,2,3}

s2={1,2}

print(s1 >= s2)

print(s1.issuperset(s2))

s1={1,2,3}

s2={1,2,4}

print(s1 >= s2)

# 子集

s1={1,2,3}

s2={1,2}

print(s2 <= s1)

print(s2.issubset(s1))

# 需要掌握操作

s1={1,2,3}

s1.update({3,4,5})

print(s1)

s1={1,2,3}

res=s1.pop()

print(res)

s1={1,2,3}

res=s1.remove(3) #单纯的删除,返回值为None

print(s1)

s1={1,2,3}

s1.add(4)

print(s1)

s1={1,2,3}

s2={1,2}

s1.difference_update(s2) #s1=s1.difference(s2)

print(s1)

s1={1,2,3}

res=s1.discard(3) ##单纯的删除,返回值为None

print(s1)

print(res)

s1.remove(444444) #删除的元素不存在则报错

s1.discard(444444) #删除的元素不存在不会报错

s1={1,2,3}

s2={1,2,4}

print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s1={1,2,3}

s2={4,5,6}

print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

#二：该类型总结

# 1 存多个值

# 2 无序

# 3 set可变

s={1,2,3}

print(id(s))

s.add(4)

print(id(s))

# 集合去重

# 局限性

#1、无法保证原数据类型的顺序

#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重

names=[‘alex‘,‘egon‘,‘alex‘,‘alex‘,‘egon‘,‘lxx‘]

s=set(names)

print(s)

l=list(s)

print(l)

stus_info=[

{‘name‘:‘egon‘,‘age‘:18},

{‘name‘:‘alex‘,‘age‘:73},

{‘name‘:‘oldboy‘,‘age‘:84},

{‘name‘: ‘egon‘, ‘age‘: 18},

{‘name‘: ‘oldboy‘, ‘age‘: 84},

]

# set(stus_info) # 报错

l=[]

for info in stus_info:

if info not in l:

l.append(info)

# print(l)

stus_info=l

print(stus_info)

原文地址：https://www.cnblogs.com/chendaodeng/p/11134931.html

时间： 2024-10-10 07:43:20

python 入门基础3(元祖，字典，集合)的相关文章

python学习day-3 列表元祖字典

一.列表list a.基础 1. li = [1, 12, 9, "age", ["石振文", ["19", 10], "庞麦郎"], "alex", True] 中括号括起来:,分割每个元素:列表中的元素可以是数字,字符串,列表,布尔值......:列表可以嵌套 (他就是个集合,内部放置任何东西) 2.可以进行索引,切片取值 li = [1, 12, 9, "age", ["

元祖元祖的定义和特性定义:列表已经介绍过,现在介绍一种与类表相似的类型,叫做元祖,只不过把[]改成(). 特性: 1.可以存放多个指 2.不可变 3.按照从左往右的顺序定义元祖的元素,下标从0开始依次顺序访问,有序元祖的创建与常用类型 1 # 创建 2 >>> we = (11, 22, 33, 44, 55) 3 >>> we 4 (11, 22, 33, 44, 55) 5 >>> type(we) 6 <class 'tuple'&g

python开发基础：元祖操作

一,元祖操作 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 # 为何要有元组,存放多个值,元组不可变,更多的是用来做查询 5 # 1.元组() 6 # 元组跟列表一样,但是不能增删改,能查.元组又叫只读列表 7 # 2个方法一个 count 一个 index 8 9 # t=(1,[1,3],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2))) 10 # print(type(t)) 11 12 # #元

what's the python之基本运算符及字符串、列表、元祖、集合、字典的内置方法

计算机可以进行的运算有很多种,运算按种类可分为算数运算.比较运算.逻辑运算.赋值运算.成员运算.身份运算.字符串和列表的算数运算只能用+和*,字典没有顺序,所以不能进行算数运算和比较运算.比较运算中==比较的是值,is比较的是id.比较运算只能在同种类型下进行比较.字符串的比较是按照顺序依次进行比较.逻辑运算的顺序先后为要用括号来表示. 基本运算符如下: 算术运算以下假设a=10,b=20 比较运算以下假设a=10,b=20 赋值运算逻辑运算成员运算身份运算 what's the 内

字符串数字列表元祖字典的不同分类and集合的概念

可变不可变 1.可变:列表字典 2.不可变:字符串数字元祖访问顺序: 1.顺序访问:字符串列表元祖 2.映射:字典 3.直接访问:数字存放元素个数: 容器类型:列表元祖字典原子:数字字符串 id(变量名)可以查出储存的位置 s={1,2,3,3,9,8,8} print(id(s)) 41383080 集合(set): 1.不同元素组成 2.无序 3.集合中元素必须是不可变类型例如: s={1,2,3,3,9,8,8} print(type(s)) 输出 <class '

Python入门基础学习三

Python入门基础学习三数据类型 Python区分整型和浮点型依靠的是小数点,有小数点就是浮点型. e记法:e就是10的意思,是一种科学的计数法,15000=1.5e4 布尔类型是一种特殊的整形,true就相当于1,false相当于0,可以用来计算类型转换转换:整数:int();字符串:str();浮点数:float() 转换例子:(图9) 如果用内置函数当变量名,比如str=123,一旦被赋值,再使用这个函数会被报错. type()函数可以明确告诉我们变量类型. isinstance

Python学习路线引导-Python入门基础

一.学习目标和建议学习周期 1.学习目标:完成Python入门基础,为数据分析事或者软件测试工程师知识体系中Python编程的入门知识. 2.学习阶段:2020.1.13-2020.2.23六周,建议每周学习时长15小时,整个学习时长90小时. 二.推荐教程廖雪峰教程:https://www.liaoxuefeng.com/wiki/1016959663602400 学习笔记:<Python入门学习笔记-精灵>-部分示例代码源自廖雪峰教程,可参照其教程,理解其知识点,在数据分析与软件测试创新

1.6小白学python入门基础-----元祖，字典，集合

今日课程内容一,元祖二.字典三.集合一.元祖 1.1元祖的定义: 元祖使用()元素用逗号隔开的一系列元素. #ti=(1,0) #t3=tuple((1,2)) #t4=()#空元素 #t5=(1,)#一个元素 1.2元祖的特性: 1.有序存储,可以存储多个数据 2.不可变(注意:内部可以包含对象,可变对象依旧可变) 1.3元祖的常用操作: 1.因为有序存储所以可以通过索引取值 2.切片 3.len(item元素的个数) 1.4内置方法: #print(t.count)#表示该数据集合可

python 第三章元祖，字典，集合，while循环

元祖 Python的元组与列表类似,不同之处在于元组的元素不能修改. 元组使用小括号,列表使用方括号. 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可. 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 tup = (1,2,3,4,"hello","word") 5 print(type(tup)) 创建空元组 1 tup = () 元组中只包含一个元素时,需要在元素后面添加逗号 1 tup =