主题内容：各个数据类型的内置方法
数据类型的内置方法
"""内置：你不用下载等的操作直接可以拿来使用的，Python解释器里面已经有了""" 各个数据类型的方法是可以直接拿来使用的，Pyhton提前定义好的 ### 方法的表现形式：int(res) # 方法名() # 语法格式：数据类型.方法名() str.split() 'helloworld'.split()
整型和浮点型的内置方法
res = '123'
print(type(res)) # str
print(int(res)) # 123 int
'''int方法只能够转纯数字类型的'''
# res2 = '123kevin'
# print(int(res2))
# print(int('')) # invalid literal for int() with base 10: ''
# res = int(input('请输入内容'))
# print(int(res))
### 十进制转其他进制
'''二进制、八进制、十进制、十六进制之间的互相转换'''
# 10---------->00001010
# print(bin(2000)) # 0b1010 # 0b代表的是二进制
# print(oct(2000)) # 0o3720
# print(hex(2000)) # 0x64
"""
ob:二进制
0o:八进制
0x:十六进制
"""
#### 返回来转换
print(int('0b1010', 2)) # 10
print(int('0o3720', 8)) # 2000
print(int('0x7d0', 16)) # 2000
浮点型的内置方法
s = '123.1' print(float(s))
字符串类型的内置方法
1. 数据类型转换
# res = 123
# print(str(res), type(str(res))) # '123'
# print(str(123.1)) # '123'
# print(str('helloworld')) # '123'
# print(str([1, 2, 3, 4]), type(str([1, 2, 3, 4]))) # [1, 2, 3, 4]
# s_list = str([1, 2, 3, 4]) # '[1, 2, 3, 4]'
# print(s_list[0])
print(str({'a':1}), type(str({'a':1}))) # '{'a':1}'
print(str((1, 2, 3)), type(str((1, 2, 3)))) # '{'a':1}'
print(str({1, 2, 3, 4}), type(str({1, 2, 3, 4}))) # '{'a':1}'
# str1 = 'hello python!'
# print(str1[2])
# str1[0] = 'x' # 字符串不允许改变值
# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
# print(str1[0:3]) # hel
# str1 = 'python!pythonpythonpythonpythonpyythonpythonpythonpythonpythonpython'
# str1 = 'hello python!'
# print(len(str1)) # length
# print('hello1' in str1)
# print('hello' not in str1)
# 5.strip 移除字符串首尾指定的字符(默认移除空格)
# str1 = ' hello python! '
# str1 = '@@@hello p@@@ython!@@@@@@'
# print(str1.strip(), len(str1), len(str1.strip()))默认去除两边的
# print(str1.lstrip(), len(str1), len(str1.lstrip()))默认去除左边的
# print(str1.rstrip(), len(str1), len(str1.rstrip()))默认去除右边的
#.strip()去除中间的·
# username = input('username：').strip()
# password = input('password：').strip()
#str1 = 'kevin@18@male@200000' # ['kevin', 18, 'male', 2000]
# res = str1.split('@') # ['kevin', '18', 'male', '200000']
# print(res)
课堂练习
编写⽤户登录程序
温馨提示:
⽤户名与密码来源于字符串source_data = 'kevin|123'
想办法从中拆分出⽤户名和密码⽤于后续账户信息⽐对
普通要求:
1.验证失败情况下可⼀直循环验证 成功则直接退出
拔⾼练习:
1.只允许三次失败机会
2.登录成功后进⼊内层循环，⽤户输⼊任何指令利⽤格式化输出
打印正在执⾏该⽤户指令即可，直到⽤户输⼊字⺟q退出内层循环
# 1. 从字符串中拆分出用户名和密码
source_data = 'kevin|123'
# res = source_data.split('|') # ['kevin', '123']
# real_username = res[0]
# real_password = res[1]
real_username, real_password = source_data.split('|') # ['kevin', '123'] # 解压赋值
### 3. 定义一个用来记录输错密码次数的计数器
count = 0
while True:
## 输错次数3次直接结束程序
if count == 3:
break
username = input('username:').strip()
password = input('password:').strip()
# 2. 比较用户名和密码的正确性
if username == real_username and password == real_password:
print('登录成功')
while True:
cmd = input('请输入你的指令:').strip()
if cmd == 'q':
break
print('正在执行你的指令：%s' % cmd)
else:
print('用户名或者密码错误')
count+=1
列表的内置方法
"""所有可以支持for循环的类型都可以转为列表"""
# 1.1 正向取(从左往右)顾头不顾尾
# my_friends = ['tony', 'jason', 'tom', 4, 5, 'tom', 4, 5]
# print(my_friends[-1])
# print(my_friends[6])
# print(my_friends[0:3]) # ['tony', 'jason', 'tom']从0开始
# print(my_friends[3:]) #[4, 5, 'tom', 4, 5]从第三个开始
# print(my_friends[:3]) # ['tony', 'jason', 'tom']顾头不顾尾
# print(my_friends[0:5:2]) # ['tony', 'tom', 5]支持步长
# print(my_friends[::-1]) #[5, 4, 'tom', 5, 4, 'tom', 'jason', 'tony']反转
# print(len(my_friends)) # 5
# my_friends = ['tony', 'jason', 'tom', 4, 5] # 可变类型与不可变类型
# print(my_friends)
'''列表添加元素'''
#1. append在末尾追加元素
# my_friends.append([1, 2, 3, 4]) # ['tony', 'jason', 'tom', 4, 5, [1, 2, 3, 4]]
# 2. insert
'''insert能够指定你插入数据的位置'''
# my_friends.insert(2, [1, 2, 3, 4]) # ['tony', 'jason', [1, 2, 3, 4], 'tom', 4, 5]
# 3. extend扩展-----------》合并两个列表的元素值
# my_friends.extend([11, 22, 33, 44, 55]) # ['tony', 'jason', 'tom', 4, 5, 11, 22, 33, 44, 55]
# print(my_friends)
# extend: for + append
# new_list = [11, 22, 33, 44, 55]
# for i in new_list:
# my_friends.append(i)
# print(my_friends)
### 修改
# my_friends[0] = 'jerry'
# my_friends[2] = 'jerry111'
# print(my_friends)
# 删除
#my_friends = ['tony', 'jason', 'tom', 4, 5]
# 1. del
# del my_friends[0]
# 2. remove
# my_friends.remove('tony')
#res = my_friends.remove('tom')
#print(res) # None
# 3. pop弹出
# res = my_friends.pop(2) # ['tony', 'jason', 'tom', 4]
# print(my_friends)
# print(res)
可变类型与不可变类型
# 列表
# names_list = ['tony', 'kevin', 'jerry']
#
# print(id(names_list))
# res = names_list.append('oscar')
# print(id(names_list))
# print(names_list) # ['tony', 'kevin', 'jerry', 'oscar']
# print(res) # None
"""
不可变类型：str、int、float
特点：值改变了，内存地址也改变、其实改变的不是原值、而是改变之后又生成一块空间来保存新值
可变类型: list、dict、
特点：值改变了，内存地址没有改变，其实改变的是原值，只要你改变了只，原来的值就会发生变化
"""
a = 10
print(id(a))
a = 11
print(id(a))
### 在Python中，没有值传递还是引用传递一说，都说可变类型与不可变类型
列表的其他方法
1.reverse()颠倒列表内元素顺序
2. sort()给列表内所有元素排序
>>> l=[1,2,3,4,5,6]
>>> l[0:3:1]
[1, 2, 3] # 正向步长
>>> l[2::-1]
[3, 2, 1] # 反向步长
# 通过索引取值实现列表翻转
>>> l[::-1]
[6, 5, 4, 3, 2, 1]
字典的内置方法
# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能
定义方式:
1.info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
2. info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
'''字典的其他用法'''
dic = {
'name': 'xxx',
'age': 18,
'hobby': ['play game', 'basketball']
}
# 1. 取值
# print(dic['name'])
# print(dic['age'])
# print(dic['hobby'][1])
# 2. 赋值操作
'''如果key已经在字典中存在，那么，就是对原来的值进行修改，如果不存在key值，就是新增一个键值对'''
# dic['gender'] = 'male' # {'name': 'xxx', 'age': 18, 'hobby': ['play game', 'basketball'], 'gender': 'male'}
# print(dic)
# print(len(dic))
# 2、长度len
>>> len(dic)
# 3、成员运算in和not in
>>> 'name' in dic # 判断某个值是否是字典的key
True
# 4、删除
# 通过指定字典的key来删除字典的键值对
# dic.pop('age') # pop expected at least 1 argument, got 0
# print(dic)
字典的三剑客
#键keys()，值values()，键值对items()
'''keys获取字典中所有的key值，组织成一个列表'''
# print(dic.keys()) # dict_keys(['name', 'age', 'hobby'])
# for i in dic.keys():
# print(i)
'''values获取字典中所有的value值，组织成一个列表'''
# print(dic.values()) # dict_values(['xxx', 18, ['play game', 'basketball']])
# for i in dic.values():
# print(i)
# .items()获取字典所有的键值对
print(dic.items()) # dict_items([('name', 'xxx'), ('age', 18), ('hobby', ['play game', 'basketball'])])
# for i in dic.items(): #
# print(i[0], i[1]) # ('name', 'xxx')
for i, j in dic.items(): #
print(i , j) # ('name', 'xxx')
### 字典需要需要掌握的操作
## get取值
# key存在，则获取key对应的value值
# print(dic.get('name')) # xxx
# print(dic.get('name1')) # None
'''get方法获取# key不存在，不会报错而是默认返回None。key不存在时，可以设置默认返回的值'''
# print(dic.get('name1', 666)) # 666
"""字典取值推荐使用get方法，中括号取值是可以用的"""
# dic = {
# 'name': 'xxx',
# 'age': 18,
# 'hobby': ['play game', 'basketball']
# }
# print(dic.pop()) # 删除指定的key对应的键值对,并返回值
# print(dic.popitem()) # 随机删除一组键值对,并将删除的键值放到元组内返回
# 4.update()
'''如key值存在，则为修改，如果不存在，则为添加'''
# dic.update({'name': "jerry", 'gender': 'male'}) # 要记忆
# dic = dict.fromkeys(['k1','k2'],[])
# print(dic) # {'k1': [], 'k2': []} # 初始化变量
#
# print(dic['k1'])
# print(dic['k2'])# fromkeys生成的初始化变量占用了同一个内存地址，一个值改变其余的跟着改变
# dic['k1'].append('hello world') # {'k1': [666, 888, 'hello world'], 'k2': [666, 888, 'hello world']}
# print(dic)
dic = {
'name': 'xxx',
'age': 18,
'hobby': ['play game', 'basketball']
}
'''setdefault：key值存在不做修改，则直接获取key的value值，如果不存在，就返回第二个参数的值'''
print(dic.setdefault('name1', 666)) # 666
元组的内置方法
作用：元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，'用于记录多个固定不允许修改的值，单纯用于取'
定义方式： 在()内用逗号分隔开多个任意类型的值
countries = ("中国"，"美国"，"英国") # 常见的
本质:countries = tuple("中国"，"美国"，"英国")# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
本质:countries = tuple(("中国"，"美国"，"英国"))
类型转换：# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
print(tuple(123)) # 'int' object is not iterable
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple((1,2 ,3 ,4))) # (1, 2, 3, 4)
print(tuple([1, 2, 3, 4])) # (1, 2, 3, 4)
print(tuple({'username':'kevin', 'age':18})) # ('username', 'age')
print(tuple({1, 2, 3, 4})) # (1, 2, 3, 4)
"""所有能够支持for循环的数据类型都可以转为元组类型"""
使用：
# 内部可以存放任意的数据类型
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
'''元组就是不可变的列表'''
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！
# print(tuple1[0])
# print(tuple1[-2])
# tuple1[0] = 666 # 报错：TypeError:
# 2、切片(顾头不顾尾，步长
# print(tuple1[0:6:2]) # (1, 15000.0, 22)
# 3、长度
# print(len(tuple1)) # 6
# 4、成员运算 in 和 not in
# print('hhaha' not in tuple1)
# 5、循环
# for i in tuple1:
# print(i)
扩展：
'''面试题：'''
res = (111, ) # <class 'int'>
res1 = (123.1,) # <class 'float'>
res2 = ('hello',) # <class 'str'>
'''元组内部如果只有一个元组也要加逗号，否则就不是元组，只有加了逗号才是元组'''
'''以后只要是容器类型的数据类型，内部只要只有一个元素，末尾都推荐加一个逗号'''
"""
容器类型：只要是内部能够存放多个元素的都可以称为是容器类型
eg：list dict tuple set
不是容器类型的：int float str bool
"""
# print(type(res), type(res1), type(res2)) # <class 'tuple'> <class 'tuple'> <class 'tuple'>
# print(res, res1, res2)
# res3 = [111]
# res4 = ['hello']
# print(type(res3), type(res4)) # <class 'list'> <class 'list'>
# res5 = () # <class 'tuple'>
# res6 = tuple()
# print(type(res5))
"""第二道面试题："""
t = (11, 22, 33, 44, [1, 2, 3, 4])
# t[0] = 666 # 对还是不对？
t[4][0] = 666 # 对还是不对?
print(t)
集合
1. 如何定义集合
s = set() # 空集合
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
"""
2. 集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
3. 类型转换：# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
4. 去重
## 1. 去重
# name_list = ['kevin', 'jerry', 'tony', 'oscar', 'tony', 'oscar', 'jerry', ]
# ## 要求：去除重复元素
# # 思路：列表------------>集合
# s = set(name_list) # {'kevin', 'tony', 'jerry', 'oscar'}
# print(s)
# # 在把集合转为列表
# print(list(s)) # ['tony', 'oscar', 'jerry', 'kevin']
'''集合的另外一个特点：无序'''
ll = [11, 22, 10, 20, 30, 66, 10, 20, 30]
# 1. 去重转为集合
# 2. 去重之后，保留原来的位置
# 思路：循环 遍历
# 1. 先定义一个空列表来存储去重之后的结果
new_list = []
# 2. 循环遍历
for i in ll:
# 判断new_list这个列表中是否已经存在这个值，如果存在了，就不在添加，如果不存在，则追加进去
if i not in new_list:
new_list.append(i)
# 如果在的话，就不用管了
print(new_list)
### 集合运算
friends1 = {"zero", "kevin", "jason", "egon"} # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "egon"} # 用户2的好友们
print(friends1)
# # 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
# 集合不能单个取值可以转换成其他类型单个取值
print(friends1 | friends2)
# 2.交集(&)：求两个用户的共同好友
print(friends1 & friends2) # {'jason', 'egon'}
# # 3.差集(-)：
# friends1 - friends2 # 求用户1独有的好友
print(friends1 - friends2) # {'zero', 'kevin'}
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2) # {'Jy', 'kevin', 'zero', 'ricky'}
# 5.值是否相等(==)
# friends1 == friends2
print(friends1 == friends2) # False
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
# {1,2,3} > {1,2}
print({1, 2, 3} > {1, 2}) # True
# 7.子集
print({1, 2, 3} < {1, 2}) # True
