数据类型的内置方法

在日常生活中不同类型的数据具有不同的功能
	eg：表格数据文件具有处理表格的个项功能（透视图 图形化 公式计算过	
		视频数据文件具有快进 加速等各项功能

整型

方式在代码中展示出来的效果就是名字（）
类型装换

res = '123'
print(type(res))
res = int(res)
print(type(res))

使用不是纯数字类型装换会报错

int 可以进行进制数的装换

print(bin(100))  # 将十进制的100转换成二进制  0b1100100
print(oct(100))  # 将十进制的100转换成八进制  0o144
print(hex(100))  # 将十进制的100转换成十六进制  0x64

0b开头为二进制数 0o开头为八进制数 0x开头为十六进制数

浮点型float

类型转换

字符串

类型转换

print(str(123))
print(str(123.21))
print(str([1, 2, 3, 4]))
print(str({'name': 'jason', 'pwd': 123}))
print(str((1, 2, 3, 4)))
print(str(True))
print(str({1, 2, 3, 4}))

基本用法

res = 'hello world!'
1.索引取值
print(res[1]) # e
res = 'hello world!'

res = 'hello world!'
2.切片操作 顾头不顾尾
print(res[1:4]) # ell

3.步长操作
res = 'hello world!'
print(res[1:10]) # ello worl
print(res[1:10:2]) # el ol

4.索引支持负数
res = 'hello world!'
print(res[-1]) # ! 最后一位
print(res[-5:-1]) # orld 顾头不顾尾
print(res[-5👎-1]) # 方向冲突

5.统计字符串内部字符的个数
res = 'hello world!'
print(len(res)) # 12

6.移除字符串首尾指定的字符 strip()
res = 'hello world!'
name = ' jason '
print(name, len(name))
print(len(name.strip())) # 默认移除首尾的空格
name1 = '$$jason$$'
print(name1.strip('$')) # jason
print(name1.lstrip('$')) # jason$$
print(name1.rstrip('$')) # $$jason
username = input('username>>>:')
username = username.strip()
username = input('username>>>:').strip()
if username == 'jason':
print('老板好')
else:
print('去你妹的')

7.按照指定的字符切割字符串 split() 该方法的结果是一个列表
res = 'hello world!'
res2 = 'jason|123|18'
print(res2.split('|')) # ['jason', '123', '18']
print(res2.split('|', maxsplit=1)) # ['jason', '123|18'] maxsplit用于控制切割的次数
print(res2.rsplit('|', maxsplit=1)) # ['jason|123', '18']

字符串的内置方法

1大小写
res = 'Sdjdd sskJDK'
print(res.upper())  #upper: 全部转成大写
print(res.lower())  #lower: 全部转成小写

实际案例:图片验证码忽略大小写
思路:全部转大写或者小写再比对
res = 'Sdjdd sskJDK'
res1 = 'jason123'
old_code = 'jaSon123' #验证码
print('验证码：%s' % old_code) #验证码：jsSon
new_code = input('请输入验证码>>>: ').strip() #请输入验证码>>>: jaSon123
if old_code.upper() == new_code.upper():
print('验证码正确')
else:
print('验证码错误')
print(res.isupper()) #判断是否纯大写
print(res1.isupper()) #判断是否纯大写

print(res.islower()) #判断是否纯x小写
print(res1.islower()) #判断是否纯x小写

2判断字符串是否以指定的字符开头
s1 = 'jason 123 newapeman heiheihei oldgirl'

startswith：从... 开始

print(s1.startswith('tony')) #结果为：False
print(s1.startswith('j')) #结果为：True
print(s1.startswith('jsaon')) #结果为：False

3判断字符是否以指定的字符结尾
s1 = 'jason 123 newapeman heiheihei oldgirl'

endswith:以... 结束

print(s1.endswith('oldnoy')) #结果为：False
print(s1.endswith('l')) #结果为：True
print(s1.endswith('r1')) #结果为：False
print(s1.endswith('oldgirl')) #结果为：True

4.格式化输出
4.1.与用户交互 占位符 %s %d
4.2.字符串内置方法 format()
第一种玩法 相当于%s占位符
s2 = 'my name is {} my age is {}'
print(s2.format('jason', 19)) #结果为：my name is jason my age is 19

第三种玩法 大括号内写变量名
s4 = '{name1} my name is {name1} my age is {age} {name1} {name1}'
print(s4.format(name1 = 'jason', age = 18)) #结果为：jason my name is jason my age is 18 jason jason

第二种玩法 大括号内写索引值可以打破顺序 并且可以反复使用相同位置的数据
s3 = '{1} my name is {1} my age is {0} {0} {0} {1} {1}'
print(s3.format('jason', 18)) #18 my name is 18 my age is jason jason jason 18 18

5.字符串的拼接
方式1 字符串相加
print('hello' + 'world') #结果为：helloworld

方式2 join方法
2.1
l = ['jason', 'tony', 'kevin', 'tom', 'jack']
print(l[0] + '|' + l[1] + '|' + l[2] + '|' + l[3] + '|' + l[4]) #结果为：jason|tony|kevin|tom|jack

2.2
l = ['jason', 'tony', 'kevin', 'tom', 'jack']
print(l[0] + '|' + l[1] + '|' + l[2] + '|' + l[3] + '|' + l[4]) #结果为：jason|tony|kevin|tom|jack
print('|'.join(l)) #结果为：jason|tony|kevin|tom|jack

2.3
l1 = ['jason', 123, 'tony' ]
print('$'.join(l1)) # 报错
"""必须是字符串类型 (在python不同数据类型之间无法直接操作)"""

6.替换字符串中指定的字符
6.1替换字符串中所有的tony>>>jason
s4 = 'my name is tony tony tony mmy age is 18'
print(s4.replace('tony', 'jason')) # 替换字符串中所有的tony>>>jason #结果为：my name is jason jason jason mmy age is 18

6.2替换指定个数的文本
s4 = 'my name is tony tony tony mmy age is 18'
print(s4.replace('tony','jason', 1))# 替换指定个数的文本 #结果为：my name is jason tony tony mmy age is 18
print(s4.replace('tony','jason', 2))# 替换指定个数的文本 #结果为：my name is jason jason tony mmy age is 18
print(s4.replace('tony','jason', 3))# 替换指定个数的文本 #结果为：my name is jason jason jason mmy age is 18

7.判断字符串中是否是纯数字
s5 = 'jason123'
print(s5.isdigit()) #结果为：False

s6 = '123'
print(s6.isdigit())#结果为：True

列表基本方法

列表内一般都会存储相同数据类型的数据
类型转换  数据类型关键字(需要转换的数据)

print(list(123)) # 报错
print(list(123.21)) # 报错
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list({'username': 'jason', 'pwd': 123})) # ['username', 'pwd']
print(list((11, 22, 33))) # [11, 22, 33]
print(list({11, 22, 33})) # [33, 11, 22]
'''list关键字可以将支持for循环的数据类型转换成列表'''

列表修改、添加数据

1.修改值

name_list = ['sjssh', 'wjw','duhiu', 'oieui']
name_list[0] = 666
print(name_list) #结果为：[666, 'wjw', 'duhiu', 'oieui']

2添加值
方式1 尾部追加(将括号内的数据当成一个整体追加到列表末尾)
name_list = ['sjssh', 'wjw','duhiu', 'oieui']
name_list.append(666)
print(name_list)#结果为：['sjssh', 'wjw', 'duhiu', 'oieui', 666]
name_list.append([111, 222, 333, 444])
print(name_list)#结果为：['sjssh', 'wjw', 'duhiu', 'oieui', 666, [111, 222, 333, 444]]

方式2 插入元素（将括号内的数据当成一个整体插入带索引指定位置）
name_list = ['sjssh', 'wjw','duhiu', 'oieui']
name_list.insert(0, 'hehehe')
print(name_list) #结果为：['hehehe', 'sjssh', 'wjw', 'duhiu', 'oieui']
name_list.insert(2, 'hehehe')
print(name_list) #结果为：['hehehe', 'sjssh', 'hehehe', 'wjw', 'duhiu', 'oieui']
name_list.insert(0, [11,22,33,44])
print(name_list) #结果为：[[11, 22, 33, 44], 'hehehe', 'sjssh', 'hehehe', 'wjw', 'duhiu', 'oieui']

方式3 扩展元素(相当于for循环+append操作)
name_list = ['sjssh', 'wjw','duhiu', 'oieui']
name_list.extend([11,22,33,44,55])
print(name_list) #结果为：['sjssh', 'wjw', 'duhiu', 'oieui', 11, 22, 33, 44, 55]

l1 = [111, 222, 333, 444, 555]
l2 = [1, 2, 3, 4, 5]
for i in l2:
l1.append(i) # 将l2中元素追加到l1末尾
print(l1) #结果为：[111, 222, 333, 444, 555, 1, 2, 3, 4, 5]

列表删除数据

列表删除数据

方式1 通用删除方式
name_list = ['sjssh', 'wjw','duhiu', 'oieui']
del name_list[1] # 根据索引直接删除 del是关键字delete缩写
print(name_list) #结果为：['sjssh', 'duhiu', 'oieui']

方式2 remove() 括号内指定需要移除的元素值
name_list = ['sjssh', 'wjw','duhiu', 'oieui']
name_list.remove('duhiu')
print(name_list) #结果为：['sjssh', 'wjw', 'oieui']
print(name_list.remove('wjw'))#结果为：None

方式3 pop() 括号内指定需要弹出的元素索引值 括号内如果不写参数则默认弹出列表尾部元素
name_list = ['sjssh', 'wdfjw','duhiu', 'oieui']
name_list.pop(1)
print(name_list) #结果为：['sjssh', 'duhiu', 'oieui']
name_list.pop()
print(name_list) #结果为：['sjssh', 'duhiu']
print(name_list.pop()) #结果为：duhiu

列表的顺序与比较

顺序

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
l1.sort() # 默认是升序
l1.sort(reverse=True) # 参数指定降序
print(l1) #结果为：[99, 88, 77, 66, 44, 33, 22, 11]
l1.reverse() # 顺序颠倒
print(l1) #结果为：[11, 22, 33, 44, 66, 77, 88, 99]

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
print(l1) #结果为：[44, 22, 11, 33, 99, 77, 88, 66]
print(l1[1:5]) #结果为：[22, 11, 33, 99]
print(l1[::-1]) #冒号左右两边不写数字默认全都要 #结果为：[66, 88, 77, 99, 33, 11, 22, 44]

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
print(l1[:5]) #左边不写默认从头开始 #结果为：[44, 22, 11, 33, 99]
print(l1[1:]) #右边不写默认到尾部 #结果为：[22, 11, 33, 99, 77, 88,

2比较运算
ll1 = [999, 111]
ll2 = [111, 222, 333, 444, 555, 666, 777, 888,999]
print(ll1 > ll2) #列表比较运算采用相同索引元素比较 只要有一个比出了结果就直接得出结论 #结果为:True
s1 = 'hello world'
s2 = 'abc'
print(s1 > s2) #字符串比较大小也是按照索引位置内部转成ASCII对应的数字比较 #结果为：True

字典内置方法

dic = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']

}
1.按k取值 k不存在会直接报错
print(dic['name']) #结果为：jason
print(dic['pwd']) #值不存在 报错
2.按k修改值 新增键值对(使用频率最高)
dic['name'] = 'jasonNB' # 键存在为修改值
print(dic) #结果为：{'name': 'jasonNB', 'age': 18, 'hobbies': ['play game', 'basketball']}
dic['hobbies'].append('read') #append :尾部追加
print(dic) #结果为：{'name': 'jasonNB', 'age': 18, 'hobbies': ['play game', 'basketball', 'read']}
dic['pwd'] = 123 # 键不存在为新增键值对
print(dic) #结果为：{'name': 'jasonNB', 'age': 18, 'hobbies': ['play game', 'basketball', 'read'], 'pwd': 123}

3.统计字典内部键值对的个数
print(len(dic)) # 3

4.成员运算 默认只暴露k
print('jason' in dic) #结果为：False
print('name' in dic) #结果为：True

# 5.删除元素
方式1
del dic['name']
print(dic) #结果为：{'age': 18, 'hobbies': ['play game', 'basketball']}

方式2 指定k弹出键值对 给出v
print(dic.pop('age')) # 18
print(dic) #{'name': 'jason', 'hobbies': ['play game', 'basketball']}

方式3 弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
print(dic.popitem()) #('hobbies', ['play game', 'basketball'])
print(dic) #{'name': 'jason', 'age': 18}

6.获取v值
print(dic['name']) # jason 键不存在直接报错 按k取值不太推荐使用该方式
print(dic['xxx']) #报错 键不存在直接报错 按k取值不太推荐使用该方式
print(dic.get('name')) # jason
print(dic.get('xxx')) # None
print(dic.get('name', '喝喝喝')) # jason

字典需要了解方法

dic = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
1.按k取值 k不存在会直接报错
print(dic['name'])
print(dic['pwd'])
2.按k修改值 新增键值对(使用频率最高)
dic['name'] = 'jasonNB' # 键存在为修改值
print(dic)
dic['hobbies'].append('read')
print(dic)
dic['pwd'] = 123 # 键不存在为新增键值对
print(dic)
3.统计字典内部键值对的个数
print(len(dic)) # 3
4.成员运算 默认只暴露k
print('jason' in dic)
print('name' in dic)
5.删除元素
方式1
del dic['name']
print(dic)
方式2 指定k弹出键值对 给出v
print(dic.pop('age'))
print(dic)
方式3 弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
print(dic.popitem())
print(dic)
6.获取v值
print(dic['name']) # jason 键不存在直接报错 按k取值不太推荐使用该方式
print(dic['xxx']) # 键不存在直接报错 按k取值不太推荐使用该方式
print(dic.get('name')) # jason
print(dic.get('xxx')) # None 键不存在 不会报错返回None
print(dic.get('name', '哈哈哈')) # 第二个参数 可以在k不存在的时候自定义返回信息

print(dic.get('xxx', '哈哈哈')) # 第二个参数 可以在k不存在的时候自定义返回信息

7.keys() values()  items()  在python2中是列表 在python3中是迭代器(老母猪)

print(dic.keys()) # dict_keys(['name', 'age', 'hobbies']) 获取字典所有的键 看成列表即可
print(dic.values()) # dict_values(['jason', 18, ['play game', 'basketball']]) 获取字典所有的值 看成列表即可
print(dic.items()) # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v

1.更新字典  键存在则修改 不存在则创建

dic.update({'name': 'jasonNB', 'pwd': 123})
print(dic)
2.初始化字典
print(dict.fromkeys(['k1', 'k2', 'k3'], []))
'''笔试题'''
res = dict.fromkeys(['k1', 'k2', 'k3'], [])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)
res['k1'] = [111,222,333]
res['k1'].append(444)
print(res)
3.当键存在的情况下 不修改而是获取该键对应的值 print(dic.setdefault('name', 'jasonNB'))
print(dic)
当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))
print(dic)

元组内置方法

"""
小括号括起来 内部存放多个元素 元素与元素逗号隔开
元素可以是任意数据 但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变)
也可以简单的认为它是一个不可变的列表
"""
类型转换 能够支持for循环的数据都可以转换成元组
print(tuple(111))
print(tuple(11.11))
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple([11,22,33])) # (11, 22, 33)
print(tuple({'name':'jason','pwd':123})) # ('name', 'pwd')

元组第一道笔试题
t1 = (111) # 整型
t2 = (11.11) # 浮点型
t3 = ('hello') # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))
'''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
建议:所有的容器类型在存储数据的时候 如果内部只有一个元素
那么也推荐你加上逗号
'''
t = (111, 222, 333, 444, 555)
1.索引取值
print(t[2])
print(t[-1])
2.切片操作
print(t[1:5])
print(t[1:])
print(t[:])
3.步长
print(t[1:5:2])
4.统计元组内元素的个数
print(len(t)) # 5
5.for循环
for i in t:
print(i)
6.count计数
print(t.count(111)) # 1
'''笔试题'''
t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)

集合去重操作

1.定义空集合需要使用关键字set
s1 = set()
2.类型转换 能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
'''集合内元素是无序的'''
去重
s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1) # {1, 2, 3, 4}
name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
1.先将列表转换成集合
s1 = set(name_list)
2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)

"""课堂练习题"""
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
基本要求:去重即可
s1 = set(ll)
ll1 = list(s1)
print(ll1)

拔高要求:去重并保留原来的顺序
1.先定义一个新列表
new_list = []
2.for循环ll列表
for i in ll:
3.判断当前元素是否在新列表中
if i not in new_list:

    new_list.append(i)
  3.2 如果在 则不管

print(new_list)

集合关系运算

关系运算
"""两个群体之间做差异比较 共同好友 共同关注..."""
friends1 = {"zero", "kevin", "jason", "eg"} # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"} # 用户2的好友们
1.求两个用户的共同好友
print(friends1 & friends2) # {'jason', 'eg'}
2.求两个用户所有的好友
print(friends1 | friends2) # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
3.求用户1独有的好友
print(friends1 - friends2) # {'zero', 'kevin'}
4.求用户2独有的好友
print(friends2 - friends1) # {'ricky', 'Jy'}
5.求用户1和用户2各自的好友
print(friends1 ^ friends2) # {'Jy', 'zero', 'kevin', 'ricky'}
6.父集与子集
s1 = {11, 22, 33, 44}
s2 = {11, 33}
print(s1 > s2) # 判断s1是否是s2的父集 True
print(s2 < s1) # 判断s2是否是s1的子集 True

可变类型与不可变类型

可变类型 >>> 列表
值改变 内存地址不变 修改的是原值   
不可变类型 >>> 整型 浮点型 字符串
值改变 内存地址肯定变 其实是产生了新值