• 猜年龄游戏
完成
  • 整型
# python中不同数据类型之间无法直接交互
类型转换
int() # 只有纯数字可以
进制转换
bin() # 转二进制
oct() # 转八进制
hex() # 转十六进制
int('0b11',2) # 二转十
int('0o23',8) #八转十
int('0x52',16) #十六转世
  • 浮点型
float() # 在纯数字基础之上，可以再多一个小数点
  • 字符串
str() # 可以转换任意类型为字符串

1.索引取值
	索引从0开始，还支持负数 只能取不能改
2.切片操作
起始索引：终止索引：步长
3.移除字符串首尾指定的字符
.strip():默认首尾移除空格
    lstrip(): #首
    rstrip(): #尾
4.按照指定的字符串切割字符串
	split() #指定的字符切割字符串，结果是一个列表 还可以控制切割的次数
    rsplit()
5.统计字符串的个数：
	len() # 空格也算
6.格式化输出
	format()
    	{}
        {索引}
        {name}
7.大小写转换
	upper()
    lower()
    isupper()
    islower()
8.字符串的替换
	replace() # 可以设置替换的个数
9.统计字符出现的次数
	count()
10.判断字符串是否是纯数字
	isdigit()
11.首字母全部大写
	title() :每个单词首字母大写
    captalize()
12.判断是否以某个字符开头/结尾
	startswith()
    endswith()
13. 拼接操作
	join() # 一定要是字符串类型
    # 和split一起记忆
  • 列表
# 中括号括起来，内部可以存放多个元素，元素之间用逗号隔开
list() #能够被for循环的类型都能转换成列表，针对字典只有key被转换
1.索引取值
	索引从0开始，还支持负数 只能取不能改
2.切片操作
起始索引：终止索引：步长
3.统计元素的个数：
	len() 
4.增
    尾部追加：
        append() #将单个元素作为列表的一个元素追加
    插入
    	insert() # 根据索引插入元素
    扩展
        extend() #列表的拼接
        ps:也可以用+作为扩展
5.删
	通用删除关键字
    	del	通过索引指定
    remove指名道姓的删除
    	remove(元素)，返回None
    pop弹出元素
    	先提取元素 之后删除，返回元素
6.改：
	列表[索引]='新值'
7.排序
	sort():升序
        reverse = True #降序
8.反转
	reverse()
9.clear() #清空
10.count() #统计列表中某元素出现的次数
11.index()；返回指定元素的索引值
可变类型和不可变类型
不可变类型
	整型，浮点型，字符串，元祖
可变类型
	列表，字典
"""
可变类型
    值改变 内存地址不变
不可变类型
    值改变 内存地址一定变
"""
练习
l1 = []
a = 111
for i in range(1,6):
    l1.append(a*i)
    print(l1)
s = len(l1)
# 先进后出 队列
for i in range(s):
    print(l1.pop())
# 先进先出 堆栈
# for i in range(s):
#     print(l1.pop(0))

今日内容概要

  • 利用列表实现队列与堆栈的特征
  • 字典内置方法
  • 元组及元组内置方法
  • 集合及集合内置方法
  • 数据类型简单总结

字典的内置方法

'''
大括号括起来：内部可以存放多个元素
元素的表现形式是以k:v键值对的形式
    k是不可变类型：一般都是字符串
    v可以是任意类型
'''

# k是字符串
d1 = {'username':'jason',
     'password':'123',
     'hobby':['read','run']
 }
print(d1,type(d1))
# k是整型
d2 = {
    1:'jason',
    2:'egon',
    3:'kevin'
}
print(d2,type(d2))
# k是浮点型
d3 = {
    1.1:'jason',
    2.1:'egon',
    3.1:'kevin'
}
print(d3,type(d3))
# k是多种不可变类型
d4 = {
    '1.1':'jason',
    2:'egon',
    3.1:'kevin'
}
print(d4,type(d4))

# 优先掌握的操作
# 1.通过key取值：可存可取
d1 = {'username':'jason',
    'password':'123',
    'hobby':['read','run']
}
print(d1['username'],id(d1))
d1['username'] = 'tony'
print(d1['username'],id(d1))

v的值改变，但是d1的内置地址不便，所以字典也是可变类型

print(d1['age']) # 键不存在 直接报错

# 2.不存在添加，存在则修改
d1['age'] = 18
print(d1)

# 3.len()统计字典中键值对的个数
print(len(d1))

print('jason' in d1)# 字典默认只暴露k，v不会暴露

# 4.删除
del d1['password'] # 删除整个键值对
print(d1)
'''字典不能使用索引'''
res=d1.pop('password')
print(res) # pop()返回key所对应的值
print(d1)

5.键keys(),值values(),键值对items()

keys()，value()的结果可以直接看成一个列表
res = d1.keys()
print(res,type(res))
for k in d1.keys():
    print(d1.keys(),k)

'''
python2与python3对比：
    python3
        keys() dict_keys(['username', 'password', 'hobby'])
    python2
        keys() ['username', 'password', 'hobby']    
'''
# 将items()的结果可以直接看成列表和嵌套元组
print(d1.items())
dic1 = {}
for k,v in d1.items():
    dic1[k] = v
    print(k,v)
print(dic1)
'''
python3
    dict_items([('username', 'jason'), ('password', '123'), ('hobby', ['read', 'run'])])
python2
    [('username', 'jason'), ('password', '123'), ('hobby', ['read', 'run'])]
'''

dict.get() # 通过字典的key键获取对应的值
d1.get('username')
d1['age'] # key不存在则报错
d1.get('age') # key不存在不会报错，返回None
# 如果键存在，则不使用，键不存在则返回第二个参数，不写默认返回None
print(d1.get('username','hahaha'))

# 创建字典的方式
# 方法1.
d2 = {'name':'egon','age':18,'hobbies':'play'}

# 方法2.
res = dict(name='jason',pwd='123',age=18)
print(res)

# 方法3.
l =[
    ['username','jason'],
    ['password',123],
    ['hobby',['read','run']]
]
d = {}
for i in l:
    d[i[0]] = i[1]
print(d)

for k,v in l:
    d[k] = v
    print(d,v)
print(d)
res = dict(l)
print(res)

dict.clear() #清空字典

dict.fromkeys() 快速通过列表创建一个字典，列表的值作为字典的键，字典的值相同
l = ['username','pwd','hobby']
res = dict.fromkeys(l,None)

# # 弹出一组键值对
dict.popitem()
d1.popitem()
print(d1) #返回元组

dict.setdefault()

dd = {'name': 'jason', 'pwd': 123}
dd.setdefault('age',18)
# 如果键存在，返回键对应的值，键不存在则返回第二个参数，不写默认返回None
res = dd.setdefault('age','egon2222')
print(res)

dict.update()
# 如果键存在则修改
dd.update({'name': 'egon'})
print(dd)
dd.update({'age':18})  # 键不存在 则新建
dd.update({'name':'EGONDSB'})  # 键存在则修改
print(dd)
# # 还不如使用下列方式
dd['age'] = 18
dd['name'] = 'jason'

元组

'''
小括号括起来 括号内可以存放多个元素，元素之间用逗号隔开
元素也可以简单的理解为列表
元组是不可变类型
'''

t1 = (1,2,3,4,5,6)
print(type(t1))

t1 = (1)
t2 = ('a')
print(type(t1))
print(type(t2))
'''
元组当内部只有一个元素的时候，逗号不能省略
以后只要是容器类型 无论内部有几个元素，都必须要加逗号
[1,]
{'username':'jason',}
(1,)
'''

# 1.按索引取值（正向取+反向取）：只能取
t1 = (11,22,33)
t1[0] = 666 # 不能改值

'''
t2 = (11,22,[11,22])
t2[2].append(33)
'''
# 2.切片
# 和字符串，列表一致

# 3.len()长度

# 4. 成员运算in和not in
t1 = (1,2,3,[1,2,3])
print(1 in t1)
# 和列表一样

# 5.循环
for i in (11,22,33):
    print(i)

集合

'''
大括号括起来，内部可以存放多个元素，元素和元素
之间逗号隔开（不是k，v键值对）。元素只能是不可变类型。
集合内部的元素不可以相同
    s = {1, 2, 3}
    只有两种情况才会考虑使用集合
    1.关系运算
        两个群体之间判断 交叉并集
            共同好友 共同关注 共同点赞
    2.去重操作
        去除重复的元素
'''

se = {1,2,3,4,5}
print(type(se)) # set集合

d1 = {}
s1 = {}
print(type(d1),type(s1))

# # 定义空集合使用set()
ss = set()
print(ss,type(ss))

s = {11,2.1,'hello',(1,2,3,)}

# 列表去重
new_l = []
l = [11,22,33,44,33,22,11,44,33,22]
for i in l:
    if i not in new_l:
        new_l.append(i)
print(new_l)

# 将列表转换成列表
sb = set(l)
print(sb)
'''
集合内默认不能出现重复的元素，如果出现了会自动去重
'''

# 关系运算
f1 = ['jason', 'egon', 'tony']
f2 = ['jason', 'rose', 'oscar', 'kecin']
f1 = set(f1)
f2 = set(f2)
print(f1 & f2)  # &:交集
print(f1 - f2)  # 显示f1独有的好友
print(f2 - f1)  # 显示f2独有的好友
print(f1 | f2)  # |:并集
print(f1 ^ f2)  # ^:去除共有好友