python：从入门到放弃 05 数据类型的内置方法
目录
如何查看数据类型的内置方法
可以借助于编程软件的自动提示 采用句点符快速查看
数字类型内置方法
int整型
1.类型转换
res = int('123') # 将int方法执行之后的结果赋值给变量res
"""int方法只能转换纯数字的字符串"""
2.进制数转换
# 将十进制转换成其他机制
print(bin(100)) # 0b1100100 二进制(0b开头)
print(oct(100)) # 0o144 八进制(0o开头)
print(hex(100)) # 0x64 十六机制(0x开头)
# 将其他机制转换成十进制
print(int('0b1100100', 2))
print(int('0o144', 8))
print(int('0x64', 16))
float浮点型
1.类型转换
res = float('11.11')
print(res, type(res)) # 11.11
res = float('11')
print(res, type(res)) # 11.0
float('abc')
字符串内置方法
常用操作与内置方法
1.类型转换
str可以转换所有基本数据类型
data_test ='hello world'
2.索引取值
print(s1[0])
3.切片操作
print(s1[2:4]) # 顾头不顾尾
4.步长
print(s1[2:9:1]) # 第三个参数是步长 默认是1 依次获取
print(s1[2:9:2]) # 间隔一个取一个
print(s1[-1]) # 获取最后一个字符
print(s1[-1:-5:-1]) # 步长为正从左到右；步长为负从右到左
5.统计字符串中字符的个数
print(len(s1)) # 11
6.成员运算
print('ll' in s1)
7.移除字符串首位指定的字符(使用频率较高)
name = ' jason '
res = name.strip() # res == 'jason' 默认移除字符串首尾的空格
8.按照指定的字符切割字符串
data_test = 'jason|123|DBJ'
print(data.split('|')) # ['jason', '123', 'DBJ']
name, pwd, hobby = data.split('|') # 解压赋值(常用)
print(data.split('|', maxsplit=1))
print(data.rsplit('|', maxsplit=1)) # right 右边
print(data.lsplit('|', maxsplit=1)) # left 左边
#2段代码的区别在于内置方法的不同split方法自左向右，rsplit方法自右向左。
'''需要特别注意的是：split方法切割完字符串之后是一个列表，strip则是字符串'''
8.大小写相关操作
test = 'Rain'
print(test.lower()) # 将所有的英文字母变为小写
print(test.upper()) # 将所有的英文字母变为大写
print(test.islower()) # 判断字符串中所有的英文字母是否是纯小写 结果是布尔值
print(test.isupper()) # 判断字符串中所有的英文字母是否是纯大写 结果是布尔值
9.判断字符串的开头或者结尾是否是指定的字符
test = 'Rain is who'
print(test.startswith('R')) # True
print(s3.startswith('Rain')) # True
print(s3.startswith('tony')) # False →→→→→→→→→→→→向右
print(s3.endswith('o')) # True
print(s3.endswith('who')) # True
print(s3.endswith('jason')) # False ←←←←←←←←←←←←向左
10.格式化输出
方式1 占位符:%s %d
方式2 format方法：
10.1.跟占位符一致 使用的{}占位
print('my name is {} my age is {}'.format('Rain', 18))
10.2.根据索引取值 可以反复使用
print('my name is {0} {0} {0} my age is {0}{1}'.format('Rain', 18))
10.3.根据指名道姓的方式取值
print('my name is {name} {name} my age is {age} {pwd}'.format(name='Rain', age=18, pwd=123))
10.4.直接使用已经出现过的变量
name = 'Rain'
age = 18
print(f'my name is {name} my age is {age} {name} {age}')
11.拼接字符串
print('|'.join(s1)) # 三|月|不|努|力| |四|月|变|垃|圾
'''join方法相当于是将括号内的元素进行for循环'''
12.替换字符串中指定的字符
test = 'Rain is NB NB NB NB Rain'
print(test.replace('Rain', '我')) # 默认一次性替换所有
print(test.replace('Rain', '我')) # 还可以通过数字控制替换的个数 从左往右
13.判断字符串中是否是纯数字
print('rust'.isdigit()) # False
print('123'.isdigit()) # True
print('123'.isdigit()) # False
了解的操作
1.查找指定字符对应的索引值
str.find(str, beg=0, end=len(string))
str.index(str, beg=0, end=len(string)) # 如果包含子字符串返回开始的索引值，否则抛出异常。
'''
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
'''
2.文本位置改变
name = 'tony'
print(name.center(30, '-')) # 原字符在中间
print(name.ljust(30, '*')) # 原字符在左端
print(name.rjust(30, '$')) # 原字符在右端
print(name.zfill(50)) # 返回指定长度的字符串，原字符串右对齐，前面填充0。
3.特殊符号:斜杠与一些英文字母的组合会产生特殊的含义
print('ja\tson\nke\avin') # 表示路径
print(r'ja\tson\nke\avin') # 如果想取消它们的特殊含义 可以在字符串的前面加一个字母r
4.captalize(), swapcase(), title()
captalize：首字母大写
swapcase：大小写翻转
title：每个单词的首字母大写
列表内置方法
1.类型转换
print(list(元素))
"""
list可以转换支持for循环的数据类型
可以被for循环的数据类型
字符串 列表 字典 元组 集合
"""
2.索引取值
print(name_list[0]) # 向右
print(name_list[-1]) # 向左
3.切片操作
print(list[-1:-4:-1]) #第一个为起始，第二个为终结，第三个为差值
4.间隔
即为差值，默认为1，为负改变方向
5.统计列表中元素的个数
len(list)
6.成员运算 最小判断单位是元素不是元素里面的单个字符
print('j' in name_list) # False
print('jason' in name_list) # True
7.列表添加元素的方式
7.1.append()
# 尾部增加元素
7.2.insert()
list.insert(index, obj)
# 指定位置插入'单个'元素 插在index后面
7.3.extend()
list.extend(seq)
#从左向右扩展列表
'''extend其实可以看成是for循环+append'''
8.删除元素
8.1.通用的删除方式
del list[0]
8.2.就地删除
print(list.remove('元素'))
8.3.延迟删除
print(name_list.pop()) # 默认是尾部弹出
print(name_list.pop(2)) # 还可以指定索引值
9.修改列表元素
list[序列] = '元素'
#会改变id
10.排序
list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
11.翻转
reverse() 函数用于反向列表中元素。
list.reverse()
12.比较运算
返回的是bool值
"""列表在做比较的时候 其实比的是对应索引位置上的元素"""
13.统计列表中某个元素出现的次数
list.count(obj) #统计
list.clear() #清空列表
字典的内置方法
常用操作与内置方法
1.类型转换
dict()
2.按key取值
print(test_dict['key']) # value 键存在返回值
print(test_dict['key']) # 键不存在直接报错
'''涉及到字典取值 更加推荐下面的方式'''
print(test_dict.get('key')) # value 键存在返回值
print(test_dict.get('key')) # 键不存在不会报错 而是返回None
print(test_dict.get('key', '设置的默认值'))
返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。
3.修改值
test_dict['key'] = 'value' # 键存在是修改值
4.添加键值对
test_dict['key'] = 'value' # 键不存在则是新增一个键值对
5.统计字典中键值对的个数
print(len(dict)) # 经典len()
6.成员运算
print('value' in test_dict) # True
print('key' in test_dict) # False
# 只能判断key键
7.删除键值对
del test_dict['key'] # 通用的删除方式
print(test_dict.pop('key')) # 默认为尾部弹出，可以指定key，会弹出对应的value。
print(test_dict.popitem()) # 随机弹出一个(使用频率很低 可以忽略)
8.获取所有的键 所有的值 所有的键值对
8.1.keys() # 所有的键 可以看成是列表
8.2.values() # 所有的值 可以看成是列表
8.3.items() # 所有的键值对 可以看成是列表套元组
"""在python2中上述三个方法就是直接返回一个列表 """
了解操作
1.update更新字典
dict.update(dict2) # 键存在则修改 键不存在则新增
2..fromkeys()快速生成字典
dict.fromkeys([list], [value]) # list key键列表 value值列表，默认为 None。
3.setdefault()
setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
dict.setdefault(key, default=None) # default=None为键不存在时，设定的默认值。
'''如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。'''
元组内置方法
1.类型转换
tuple() #支持for循环的数据类型都可以转成元组
2.元组的特性
当元组内只有一个元素的时候 一定要在元素的后面加上逗号,否则元组会改变为元素的数据类型。
"""
一般情况下 我们会习惯性的将所有可以存储多个数据的类型的数据
如果内部只有一个元素 也会加逗号
(1,)
[1,]
{1,}
{'name':'jason',}
"""
3.索引取值
tuple[index] # index为正左至右，为负右至左
4.切片操作
tuple[1:4:-1] #第一个为起始，第二个为终结，第三个为差值
5.间隔
即为差值，默认为1，为负改变方向
6.统计元组内元素的个数
len(tuple) # 经典len()
7.成员运算
test_tuple = (1 , 2)
1 in test_tuple = True
8.统计某个元素出现的次数
tuple.count() # 依旧是经典.count()
9.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改
所以我们一般使用不可变类型作为元组的元素。
集合内置方法
1.类型转换
set()
"""集合内元素只能是不可变类型"""
2.两大功能
2.1.去重
集合内不能出现重复的元素(自带去重特性)
如果出现了 会被集合自动去重
2.2.关系运算
判断两个群体内的差异
& # 交集
A-B # B关于A的相对补集 {x|x∈A，且x∉B}
| # 并集
^ # 交集关于并集的相对补集 {x|x∈A∪B,且x∉A∩B}
垃圾回收机制
"""python底层针对空间的申请和释放都是设计好的 不需要程序员操心"""
1.引用计数
python会将引用计数为0的数据清除
name = 'jason' # jason引用计数为1
a = name # jason引用计数为2
'''内存中数据身上绑定的变量名的个数'''
# ps:还可以了解一下循环引用的情况
2.标记清除
当内存空间即将溢出(满了)的时候 python会自动启动应急机制
停止程序的运行 挨个检查值的引用计数并给计数为0的数据打上标记
然后一次性清理掉
3.分代回收
根据值存在的时间长短 将值划分为三个等级(1,2,3)
等级1 检测机制每隔5s来一次
等级2 检测机制每隔1min来一次
等级3 检测机制每隔5min来一次
可变类型与不可变类型
可变类型与不可变类型
可变类型 列表
值改变 内存地址不变 修改的是本身
不可变类型 字符串
值改变 内存地址肯定遍 修改过程产生了新的值
如何查看变量的'内存地址'
id()
小作业
1.编写一个用户登录程序
要求最多尝试失误三次 过期自动提示并可重置尝试次数
用户登录成功之后进入内部循环 用户输入什么就打印什么 并给用户提供一个结束程序的特殊指令 #一个while循环，if 结束 else
获取用户输入的用户名和密码可以处理首尾空格
用户的用户名和密码使用变量存储 通过程序获取用户名和密码比对
data = 'jason|123'
data = 'jason|123'
is_continue = True
number = 3
username_data, password_data = (data.split('|'))
while is_continue:
username_inp = input('请输入用户名>>>').strip()
password_inp = input('请输入密码>>>').strip()
if username_data == username_inp and password_data == password_inp:
print('欢迎进入打印系统')
while is_continue:
file_input = input('请输入您要打印的文件(输入exit退出打印系统)>>>')
if file_input == 'exit':
is_continue = False
else:
print(file_input)
else:
number -= 1
print('用户名或密码错误 还剩%s次机会' % number)
if number == 0:
yes_inp = input('请输入Y重置次数,输入任意键退出打印系统>>>')
if yes_inp == 'Y' or yes_inp == 'y':
number = 3
else:
is_continue = False
print('已退出')
1.将登录功能编写成多用户模式
2.利用列表编写一个用户注册、登录程序
提示:循环
要求:成功一次即可 无需考虑用户冲突等情况
3.不使用count统计列表中指定元素出现的次数
is_continue = True
number = 3
username_list = ['rain']
password_list = ['123']
while is_continue:
choice_inp = input('用户注册输入Z，用户登录输入D')
if choice_inp == 'Z':
print('欢迎进入注册界面')
username_list.append(input('输入用户名>>>'))
password_list.append(input('输入密码>>>'))
print('注册完成')
elif choice_inp == 'D':
while is_continue:
print('欢迎进入登录界面')
username_inp = input('请输入用户名>>>').strip()
tag = username_list.index(username_inp)
password_inp = input('请输入密码>>>').strip()
if username_inp in username_list and password_inp == password_list[tag]:
print('欢迎进入系统')
file_input = input('输入return返回登录界面>>>')
if file_input == 'return':
continue
else:
number -= 1
print('用户名或密码错误 还剩%s次机会' % number)
if number == 0:
yes_inp = input('请输入Y重置次数,输入任意键系统>>>')
if yes_inp == 'Y' or yes_inp == 'y':
number = 3
else:
is_continue = False
print('已退出')
list_db = [11, 22, 33, 44, 33, 22, 11, 22, 11, 22, 33, 22, 33, 44, 55, 44, 33]
list_inp = int(input('输入查询的元素>>>'))
count = 0
for i in list_db:
if i == list_inp:
count += 1
print(count)
1.去重列表元素并保留原来的顺序
l = ['a', 'b', 1, 'a', 'a']
2.去重下列数据字典并保留原来的顺序
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
3.一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'oscar','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
1.
l = ['a', 'b', 1, 'a', 'a']
l_pr = []
# 利用for循环从l列表中循环，并在l_pr中用成员运算验证是否是存在，不存在就输出到l_pr中
for i in l:
if i not in l_pr:
l_pr.append(i)
print(l_pr)
2.
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
l_pr = []
# 利用for循环从l列表中循环，并在l_pr中用成员运算验证是否是存在，不存在就输出到l_pr中
for i in l:
if i not in l_pr:
l_pr.append(i)
print(l_pr)
3.
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'oscar','tony','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
