set dict tuple 内置方法
今日内容 * 元祖及内置方法
* 字典及内置方法
* 集合及内置方法
* 字符编码 元祖tuple 与列表类似可以存多个值,但是不同的是元祖本身不能被修改 ```python
一:基本使用:tuple
1 用途:记录多个值,当多个值没有改的需求,此时用元组更合适 2 定义方式:在()内用逗号分隔开多个任意类型的值
t=(1,1.3,'xx',('a','b'),[1,2]) t=tuple((1,1.3,'xx',('a','b'),[1,2]))
print(t,type(t))
t1=tuple('hello')
print(t1) 3 常用操作+内置的方法
优先掌握的操作:
1、按索引取值(正向取+反向取):只能取
t=('egon',123,['a','b'])
print(id(t[0]))1
print(id(t[1]))
print(id(t[2])) t[2][0]='A'
print('='*50)
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
t[0]='EGON' t[2]='xxxx'
t[2][0]='A'
print(t) 2、切片(顾头不顾尾,步长)
t=(1,2,3,4,5)
print(t[0:3])
print(t) 3、长度 4、成员运算in和not in 5、循环
for item in ('a','b','c'):
print(item) 需要掌握的操作
t=('a','b','c','a')
print(t.count('a'))
print(t.index('a',1,10))
print(t.index('xxx',1,10)) 二:该类型总结
1 存多个值
2 有序
3 不可变
``` 字典dict ```python
6b 不可变类型=》可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)]) 用法一:
dic=dict(x=1,y=2,z=3)
print(dic) 用法二:
userinfo=[
['name','egon'],
['age',18],
['sex','male']
]
d={}
for k,v in userinfo: k,v=['name', 'egon']
print(k,v)
d[k]=v
print(d) d=dict(userinfo)
print(d) 3 常用操作+内置的方法
优先掌握的操作:
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
dic={'name':'egon','age':18,}
print(18 in dic)
print('age' in dic) 4、删除
dic={'name':'egon','age':18,}
通用
del dic['name']
print(dic)
del dic['xxx'] key不存在则报错 res=dic.pop('age') 删除key对应的value,并返回value
print(dic)
print(res)
dic.pop('xxx') key不存在则报错 res=dic.popitem()
print(dic)
print(res) 5、键keys(),值values(),键值对items() 注意python2与python3之间的区别
dic={'name':'egon','age':18,}
print(dic.keys())
l=[]
for k in dic.keys():
l.append(k)
print(l)
print(list(dic.keys()))
print(dic.values())
print(list(dic.values()))
print(dic.items())
print(list(dic.items())) 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) 8 dic.get()
dic={'name':'egon','age':18,'sex':'male'}
dic['xxx']
v=dic.get('name')
print(v) v=dic.get('xxx')
print(v) 需要掌握的操作 dic.fromkeys()的用法:
l=['name','age','sex']
dic={'name':None,'age':None,'sex':None}
dic={}
for k in l:
dic[k]=None
print(dic) dic=dic.fromkeys(l,None)
print(dic) old_dic={'name':'egon','age':18,'sex':'male'}
new_dic={'name':'EGON','x':1,'y':2}
old_dic.update(new_dic)
print(old_dic) setdefault:有则不动/返回原值,无则添加/返回新值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON') 字典中已经存在key则不修改,返回已经存在的key对应的value
print(dic)
print(res) res=dic.setdefault('sex','male') 字典不存在key则添加"sex":"male",返回新的value
print(dic)
print(res) 二:该类型总结
1 存多个值 2 无序 3 可变
dic={'x':1}
print(id(dic))
dic['x']=2
print(id(dic)) 练习1:
nums=[11,22,33,44,55,66,77,88,99,90]
dic={
'k1':[],
'k2':[]
}
for num in nums:
if num > 66:
dic['k1'].append(num)
else:
dic['k2'].append(num)
print(dic) 练习2:
s='hello alex alex say hello sb sb'
words=s.split()
dic={}
print(words)
for word in words:
if word in dic:
dic[word]+=1
else:
dic[word]=1
print(dic) s='hello alex alex say hello sb sb'
words=s.split()
dic={}
for word in words: word="hello"
dic.setdefault(word,words.count(word)) {'hello':2,"alex":2,"say":1,}
print(dic)
``` 集合set ```python
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': 'egon', 'age': 18},
{'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)
``` username=input().strip(?
if username == 'jason': print('goood job')
print(username)
print(username.rstrip('df'))
a=username.split('a',4)
print(a) leetcode 初探 两数之和 多种解法: class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode``
:rtype: ListNode
""" cur_1 = l1
cur_2 = l2
int_num1 = 0
int_num2 = 0
count_1 = 0
count_2 = 0
int_sum_of_two_linklist = 0
while cur_1 is not None or cur_2 is not None:
if cur_1 is not None:
int_num1 = 10 ** count_1 * cur_1.val + int_num1
count_1 += 1
cur_1 = cur_1.next
if cur_2 is not None:
int_num2 = 10 ** count_2 * cur_2.val + int_num2
count_2 += 1
cur_2 = cur_2.next
int_sum_of_two_linklist = int_num1 + int_num2
print(int_sum_of_two_linklist)
游标指向链表l1的头
pre = l1
cur = l1
while int_sum_of_two_linklist != 0:
if pre is not None:
pre.val = int_sum_of_two_linklist % 10
print(cur.val)
cur = pre
pre = pre.next
else:
node = ListNode(int_sum_of_two_linklist % 10)
print(node.val)
print(node.next)
cur.next = node
cur = cur.next
int_sum_of_two_linklist = int_sum_of_two_linklist / 10
return l1
class Solution:
def addTwoNumbers(self, l1, l2):
n1=[]
n2=[]
lv1=l1.val
lv2=l2.val
n1.append(l1.val)
n2.append(l2.val)
while l1.next and l2.next:
n1.append(l1.val)
n2.append(l2.val)
l1=l1.next
l2=l2.next else:
while l1.next !=None:
n1.append(l1.val)
l1=l1.next while l2.next !=None:
n2.append(l2.val)
l2=l2.next
n1=n1[::-1]
n2=n2[::-1]
class Solution:
def addTwoNumbers(self, l1, l2):
n1 = []
n2 = []
nl = [] while l1.next and l2.next:
n1.append(l1.val)
n2.append(l2.val)
l1 = l1.next
l2 = l2.next while l1.next != None:
n1.append(l1.val)
l1 = l1.next
while l2.next != None: n2.append(l2.val)
l2 = l2.next
if l1.next==0 and l2.next==0:
n1.append(l1.val)
n2.append(l2.val)
n1 = n1[::-1]
n2 = n2[::-1]
res1 = 0
res2 = 0
number1 = len(n1)
number2 = len(n2)
for i in n1:
if number1 >= 0:
res1 += i * 10 ** (len(n1) - number1)
number1 += -1
for i in n2:
if number2 >= 0:
res2 += i * 10 ** (len(n2) - number2)
number2 += -1 print(res1)
print(res2) res3 = list(str(res1 + res2))
res3 = res3[::-1]
for i in res3:
nl.append(int(i)) return 2.简单购物车,要求如下:
实现打印商品详细信息,用户输入商品名和购买个数,则将商品名,价格,购买个数加入购物列表,如果输入为空或其他非法输入则要求用户重新输入
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
小提示:打印的时候即需要拿到字典的key也需要拿到对应的value
key_name = input('请输入要购买的商品名称')
key_name_number = input('请输入要购买的个数')
while (key_name not in msg_dic ) or key_name ==0 : print('输入内容错误 ,请重新输入')
key_name=input('请输入要购买的商品名称')
key_name_number=input('请输入要购买的个数')
value=msg_dic[key_name]*key_name_number
print(key_name,key_name_number,'num value=%s'%value) 3.统计s='hello alex alex say hello sb sb'中每个单词的个数 s='hello alex alex say hello sb sb sb sbsbsbbs sb,sb , ' s=s.split()
结果如:{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
d1 = {} for i in s:
if i in d1:
d1[i] += 1
else:
d1[i] = 1 print(d1)
4.关系运算
有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
double=set(pythons and linuxs)
print(double)
all=set(pythons | linuxs)
print(all)
op=set(pythons-linuxs)
print(op)
no=set.difference(pythons,linuxs)
print(no) 5. 对列表
l=['a','b',1,'a','a'] x`内的元素完成去重得到新列表.
拔高:如果想去重并且想保持列表原来的顺序该如何做?
l1=[]
for i in l :
if i not in l1:
l1.append(i)
print(l1) 6.对如下列表中的元素去重(),得到新列表,且新列表一定要保持列表原来的顺序
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'egon','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
l1=[]
for i in l :
if i not in l1:
l1.append(i)
print(l1)
set dict tuple 内置方法的更多相关文章
- Python-数据类型内置方法(2)
目录 元组(tuple) 内置方法: 字典(dict) 内置方法: 优先掌握: 需要掌握 集合(set) 优先掌握 深浅拷贝 拷贝(赋值) 浅拷贝 深拷贝 总结 存值个数 有序 or 无序 可变 or ...
- Python基础部分:10、数据类型的内置方法和字符编码
目录 一.数据类型内置方法 1.字典dict内置方法 1.1.类型转换 2.字典必须要掌握的方法 2.1.取值方式 2.2.修改内部数据值 2.3.删除数据 2.4.统计字典中键值对个数 2.5.字典 ...
- [Python3] 017 字典的内置方法
目录 1. Python3 中如何查看 dict() 的内置方法 2. 少废话,上例子 (1) 清理大师 clear() (2) 拷贝君 copy() (3) get(key, default=Non ...
- python之数据类型的内置方法(set、tuple、dict)与简单认识垃圾回收机制
目录 字典的内置方法 类型转换 字典取值 修改值 计算字典长度 成员运算 删除元素 获取元素 更新字典 快速生成字典 setdefault()方法 元组的内置方法 类型转换 索引与切片操作 统计长度 ...
- 序列内置方法详解(string/list/tuple)
一.常用方法集合 1.1.string,字符串常用方法 以下举例是python2.7测试: 函数名称 作用 举例 str.capitalize() 字符串第一个字符如果是字母,则把字母替换为大写字母. ...
- 元组tuple类型内置方法
目录 元组tuple类型内置方法 用途 定义 常用操作+内置方法 优先掌握 存一个值or多个值 有序or无序 可变or不可变 元组tuple类型内置方法 元组是不可变的列表,在定义完成后后面就不可以进 ...
- 7.4 元组tuple类型内置方法
元组tuple 元组相当于不可变的列表,在定义完成后后面就不可以进行更改,因此元组只可取不可存 因为不可变,所以相对列表来说,他的功能也少了很多,所以,不难理解,他有个优点就是占用内存小. 作用:能够 ...
- python常用数据类型内置方法介绍
熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 下面介绍了python常用的集中数据类型及其方法,点开源代码,其中对主要方法都进行了中文注释. 一.整型 a = 100 a.xx ...
- s14 第4天 关于python3.0编码 函数式编程 装饰器 列表生成式 生成器 内置方法
python3 编码默认为unicode,unicode和utf-8都是默认支持中文的. 如果要python3的编码改为utf-8,则或者在一开始就声明全局使用utf-8 #_*_coding:utf ...
随机推荐
- vc程序设计--对键盘与鼠标的响应(1)
// WindowsProject2.cpp : 定义应用程序的入口点. // /** * 当按下CTRL键时输出信息:CTRL键被压下 * 当按下K键时输出信息:K键被压下 * 当按下CTRL+K键 ...
- 一、Redis 总结
官网 Redis 介绍 Redis 是一个开源的.支持网络.可基于内存亦可持久化的日志型.Key-Value 数据库,并提供多种语言的 API. Redis 是一个 key-value 存储系统.为了 ...
- Java-接口的本质
https://mp.weixin.qq.com/s/tEVw0j18rX2hxt-guXQJ-w 大道至简,本质往往是很朴素的. 本质: 类是主体,接口是主体之间交流沟通的规约. 位置:1. 主体站 ...
- 总结了一下css的部分基础知识点。---css学习笔记01
一. css基础 1. 什么是css 层叠样式表:层叠 2. css的三种使用方式 style 属性 --> <div style="css属性值"></d ...
- linux 最基本的命令
1.说一些你比较常用linux指令 1.1.ls/ll.cd.mkdir.rm-rf.cp.mv.ps -ef | grep xxx.kill.free-m.tar -xvf file.tar.(说那 ...
- Java实现 LeetCode 309 最佳买卖股票时机含冷冻期
309. 最佳买卖股票时机含冷冻期 给定一个整数数组,其中第 i 个元素代表了第 i 天的股票价格 . 设计一个算法计算出最大利润.在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股 ...
- Java实现 蓝桥杯 历届试题 连号区间数
问题描述 小明这些天一直在思考这样一个奇怪而有趣的问题: 在1~N的某个全排列中有多少个连号区间呢?这里所说的连号区间的定义是: 如果区间[L, R] 里的所有元素(即此排列的第L个到第R个元素)递增 ...
- js数据劫持 Object.defineProperty() 作用
原生js Object.defineProperty() 作用 假设我们有一个obj对象,我们要给他设置一个name属性会这么做 Object.defineProperty()也可以设置对象属性 这个 ...
- linux下使用tcpdump抓包分析tcp的三次握手
首先贴上tcp 三次握手的原理图服务器开启ftp服务并执行tcpdump抓包服务器:192.168.3.14 ftp服务客户端:192.168.3.100 服务器执行以下命令,客户端访问服务器ftp: ...
- 美女面试官问我Python如何优雅的创建临时文件,我的回答....
[摘要] 本故事纯属虚构,如有巧合,他们故事里的美女面试官也肯定没有我的美,请自行脑补... 小P像多数Python自学者一样,苦心钻研小半年,一朝出师投简历. 这不,一家招聘初级Python开发工程 ...