数据类型的内置方法介绍

可以理解为各个数据类型自带的功能(每个人都有不同的特长)
使用数据类型的内置方法统一采用句点符号
	数据类型.方法()
    eg：
    	name.print()
    可以通过编辑器自动提示来查看某个数据类型的内置方法

整型(int)

1.整型就是数字，没有内置方法
2.类型转换   int(需要转换的数据)
    print(int(123))  # 123  整数，可以转换
    print(int(1.23))  # 1 浮点型，可以取整，取的是小数点前的数字
    print(int('123'))  # 123  字符串，但里面包裹的是纯数字，可以转换
    print(int(11a11))  # 报错 字符串里不是纯数字
    print(int('11.11'))  #报错  字符串里虽是数字，但数字间有小数点
3.进制转换
    十进制转其他进制
    print(bin(100)) # 0b1100100  十进制转二进制  bin()  0b是二进制的标志
    print(oct(100))  #0o144  十进制转八进制  oct()  0o是二进制的标志
    print(hex(100))  #0x64  十进制转十六进制  hex()  0x是二进制的标志
    其他进制转十进制
    print(int(0b1100100))  #100  二进制转十进制  int()  如果数字前没有任何标志，默认是十进制
    人为定制进制
    print(int('0b1100100',2))  # 100
    print(int('100',8))  # 64
    print(int('100',16))  # 256

浮点型(float)

1.类型转换  float(需要转换的数据)
    print(float(111))  # 111.0  整型可以转化成浮点型，在后面加.0即可
    print(type(float('111.6')))  #  <class 'float'>  字符串里是浮点数，所以结果是float
    print(float('11a'))  # 报错  字符串里不是纯浮点数，多了一个a
    print(float('12.34.2')) # 报错  浮点数里只能有一个小数点
2.针对布尔值的特殊情况
    print(float(True))  # 1.0
    print(float(False))  # 0.0
    print(int(True))  # 1
    print(int(False))  # 0  python里通常用1和0来分别表示对错
3.补充说明
    print(12.34 * 1.1)  #  13.574000000000002
    #  python不擅长计算小数 很容易出错  

字符串(str)

1.类型转换  str(需要转换的数据)  所有类型的数据都可以转成字符串
    print(str(11)) # 11 整型
    print(str(11.11))  # 11.11  浮点
    print(str([12,13,14]))  # [12,13,14]  列表
    print(str({'name':'zhangsan','age':18}))  # {'name':'zhangsan','age':18}  # 字典
    print(str((1,2,3,4)))  # (1,2,3,4)  # 元组
    print(str({1,2,3,4}))  # {1,2,3,4}  # 集合
    print(str(True))  # True  # 布尔
2.索引取值与切片取值
     s1 = 'hello world'
	索引取值:只能取单个字符，支持反向取值
        print(s1[1]) # e
        print(s1[-1]) # d  正向从0开始，反向从-1开始
    切片取值:可以一次取多个值，支持反向取值
        print(s1[1:2])  # e
        print(s1[1:8])  # ello wo  从索引0切到索引7  空格也算 左包含右不包含
        print(s1[-1:-3]) # 空  切片取值默认从左往右
        print(s1[-1:-3:-1]) # dl  第三个参数（正负）用来控制切片的方向
        print(s1[-3:-1])  # rl  从左往右切片  从倒数第三个取到倒数第二个  左包含右不包含
3.间隔/方向
    print(s1[:])  #  hello world 取出整个列表的所有值  相当于 print(s1)
    print(s1[::2]) # hlowrd  对于整个列表，隔一个取一个
    print(s1[::3]) #  hlwl  对于整个列表，隔两个取一个
    print(s1[1:4:1])# ell  从第一个开始取到第三个  默认:1可以不写  相当于print(s1[1:4])
    print(s1[1:8:2])# ell  从第一个开始取到第七个  每隔一个取一个
    # 前两个参数决定从哪取到哪，第三个参数决定每隔几个取一次值
4.统计字符串中字符
    print(len('hello'))  # 5
    print(len(s1))  #  11  空格也算字符
5.移除字符串首尾指定的字符  .strip()  可以用于清除用户填写信息结束时不注意多打的的空格
    name = '  jason  '
    print(len(name))  # 9 空格也算字符
    print(name.strip(),len(name.strip()))  #  'jason'  5
    hobby = '%^book^%'
    print(hobby.strip())  #  %%book^^  .strip()括号内不加参数，默认只能清除空格
    print(hobby.strip('%'))  # ^book^ 清除了头尾的%符号
    print(hobby.strip('^'))  #  %^book^%  ^不在头部或尾部，因此不能清除
    print(hobby.lstrip('%'))  #  ^book^%  清除头部的%  left  lstrip()
    print(hobby.rstrip('%'))  #  %^book^  清除尾部的%  right  rstrip()
6.按照指定的字符切割字符串 .split() # 当字符串中出现了特征一样的字符，考虑使用切割
    info = 'zhangsan|19|book'
    print(info.split('|'))  # ['zhangsan', '19', 'book']  被切割字符前后的数据值会被分隔成单独的字符串
    print(type(info.split('|')))  # <class 'list'>   被切割后的字符串会自动转化为列表
    name,age,hobby = info.split('|')  #解压赋值
    print(name,age,hobby)  #  字符串被切割得到的列表可以用来解压赋值
    print(info.split('|',maxsplit=1))  #  ['zhangsan', '19|book']  后面跟的参数maxsplit表示切割字符的个数
    print(info.rsplit('|',maxsplit=1))  # ['zhangsan|19', 'book']  rsplist()  表示切割从右边开始
7.字符串大小写相关  .lower()  .upper() # 可以用来设置验证码中的英文字母，使其更方便人性化
    s2 = 'HeLLo Big BAby 666 你过的还好吗'
    print(s2.lower())  # hello big baby 666 你过的还好吗  将所有的字符串统一转换成小写
    print(s2.upper())  # HELLO BIG BABY 666 你过的还好吗  将所有的字符串统一转换成大写  注意：只能转换英文字母，不能转换数字中文符号
    print(s2.isupper())  #False  判断字符串中的字母是否全为大写
    print(s2.islower())  #False  判断字符串中的字母是否全为小写
    print('he12吉llo1*2'.islower())  #True  注意若英文字母全为小写，即使该字符串中有数字汉字或者符号，islower()依然返回True
    #实例  模拟判断验证码是否正确
    code = 'QwEr'  #事先设置好验证码
    user_input = input('请输入验证码')
    code = code.lower()
    user_input = user_input.lower() # 将待验证的内容和用户输入的内容统一转成小写
    if code == user_input:
        print('验证码正确')
    else:
        print('验证码错误')
8.字符串的格式化输出 .format()
    #方式1: 等价于%s占位 没有什么优势
    redt1 = 'my name is {} my age is {}'
    print(redt1.format('zhangsan',19))
    # 方式2: 支持索引取值 并且支持重复使用
    redt2 = 'my name is {0} my age is {1}{1}{0}'
    print(redt2.format('zhangsan',19))
    # 方式3: 支持关键字取值(按k取值) 并且支持重复使用
    redt3 = 'my name is {name} my age is {age}{age}'
    print(redt3.format(name='zhnagsan',age=19))
    # 方式4:推荐使用(******)  提前定义好变量 随用随取
    name = 'zhangsan'
    age = 19
    print(f'my name is {name}, my age is {age} {name} {age}')
9.统计字符串中指定字符出现的次数  count()
    res = 'sdashdjasdwjjkashdjasdjqwhasjdjahdjwqhdjkasdhwsdaadadadadad'
    print(res.count('h'))
    print(res.count('ad'))
10.判断字符串的开头或者结尾
    res = 'jason say ha ha ha heiheihei'
    print(res.startswith('jason'))  # True
    print(res.startswith('j'))  # True
    print(res.startswith('b'))  # False
    print(res.endswith('heiheihei'))  # True
    print(res.endswith('hei'))  # True
    print(res.endswith('h'))  # False
11.字符串的替换 .replace()
    res = 'zhangsan is 大 sb'
    print(res.replace('n','o'))  # zhaogsao is 大 sb
    print(res.replace('n','o',1))  # zhaogsan is 大 sb  第三个参数决定替换的个数
12.字符串的拼接  join()
    res1 = 'aaa'
    res2 = 'bbb'
    print(res1 + res2)  # aaabbb  字符串之间支持加法
    print(res1 * 3)  # aaaaaaaaa   单个字符串支持乘法
    print('%%'.join([res1,res2,'qqq']))  # aaa%%bbb%%qqq  第一个参数是字符串之间插入的字符  后面跟需要拼接的字符串
    print('%%'.join([res1,res2,19]))  # 报错 拼接字符串只能是str类型，不能是数字
13.判断字符串中是否是纯数字
    print('123'.isdigit())  # True
    print('123a'.isdigit())  # False
    print(''.isdigit())  # False
14.查找某个字符对应的索引值  find() index()
    res = 'hello world '
    print(res.index('e'))
    print(res.index('o'))  #  只能找出一个  若原字符串中有多个该字符，则只返回第一个的索引值
    # print(res.index('k'))  #  index()  若没有找到  直接报错
    print(res.find('k'))  # -1 find() 若没有找到 则返回-1
15.正文相关操作
    res = 'my name is jason'
    print(res.title())  # My Name Is Jason
    print(res.capitalize())  # My name is jason

列表(list)

1.类型转换  # 能够被for循环的数据类型都可以转换成列表
    print(type(list('123243jasdsad')), list('123243jasdsad'))
    print(type(list({'name':"jason",'pwd':123})), list({'name':"jason",'pwd':123}))
2.索引取值
print(l1[0])
print(l1[-1])
3.切片操作
print(l1[0:3])
print(l1[:])
print(l1[-4:-1])
4.间隔/方向
print(l1[::2])
5.统计列表中数据值的个数
print(len(l1)) 

l1 = ['jason','tony','adele','taylor','jerry']
l2 = [11,33,22,55,77,99,44]
1.统计列表中元素的个数
	print(len(l1)) # 5
6.增加
6.1 尾部追加  .append()
	res = l1.append('gaga')
	print(res) # none  列表在调用内置方法后不会产生新值，而是在原有值上做改变
	l1.append('gaga')
	print(l1)   # ['jason', 'tony', 'adele', 'taylor', 'jerry', 'gaga']
	l2.append([1,2,3])   #  括号内无论是什么数据类型，都作为一个整体追加
	print(l2)  #  [11, 33, 22, 55, 77, 99, 44, [1, 2, 3]]
6.2 任意位置插入  .insert()
	l1.insert(2,'gaga')  # .insert()第一个参数是指要插入的位次，第二个参数是要插入的值
	print(l1) #  ['jason', 'tony', 'gaga', 'adele', 'taylor', 'jerry']
	l2.insert(4,[1,2,3])  #同append一样 insert插入的值也作为一个总体插入原列表
		print(l2)  #  [11, 33, 22, 55, [1, 2, 3], 77, 99, 44]
6.3 扩展列表
	new_l1 = ['a','b','c','d']
	new_l2 = [1,2,3]
	方式1   for循环遍历再利用append按部就班得在尾部追加值
		for i in new_l2:
    		new_l1.append(i)
		print(new_l1)  # ['a', 'b', 'c', 'd', 1, 2, 3]
	方式2  +号拼接
		print(new_l1 + new_l2)  #  ['a', 'b', 'c', 'd', 1, 2, 3]
	#方式3  .extend() 推荐
		new_l1.extend(new_l2)  #括号里边必须是支持for循环的数据类型：本质就是方式1，
		print(new_l1)  #  ['a', 'b', 'c', 'd', 1, 2, 3]

7.修改
	l1[4] = 'mary'  #  索引赋值
	print(l1)  # ['jason', 'tony', 'adele', 'taylor', 'mary']
8.删除  del()
	方式1 ： 通过索引删除
		del l1[0]
		print(l1)  # ['tony', 'adele', 'taylor', 'jerry']
	方式2 ；remove() 指名道姓删除
		res = l1.remove('jason')  # 括号内必须跟明确的数据值
		print(l1)  # ['tony', 'adele', 'taylor', 'jerry']
		print(l1.remove('11'))  # 不能删除原列表没有的值，会报错
	方式3 pop() 先取出数据值，可以使用之后再删  默认取出最后面的值
		res = l1.pop()
		print(res)  #  jerry    jerry就是即将被删除的值，我们依然可以使用它
		print(l1)  # ['jason', 'tony', 'adele', 'taylor']   jerry已经被删除
		print(l2.pop(2))  # 22  括号内的参数是删除值得位次（从右往左）
9.查看数据值对应的索引值  index()
	print(l1.index('adele'))  # 2
10.统计某个数据值出现的个数  count()
	print(l1.count('adele'))  # 1
11.排序 sort()
	l2.sort()
	print(l2)  #  [11, 22, 33, 44, 55, 77, 99]  默认升序
	l2.sort(reverse=True)
	print(l2)  #  [99, 77, 55, 44, 33, 22, 11]  设置参数reverse=True可以设置为倒序
12.翻转
	l1.reverse()
	print(l1)  #  ['jerry', 'taylor', 'adele', 'tony', 'jason']
13.比较运算
	list_l1 = [11,22,33,44]
	list_l2 = [33,22,11]
	print(list_l1 > list_l2)  # False  列表比较大小不是比的长度，而是比较相同索引值的数据大小。从索引0开始，一直往右，直到先比较出一个
	print([1,2,3] > ['a','b'])  #  报错  两个列表内不同数据类型的值无法直接做比较
	print(['a','b','c'] > ['A'])  #  True  a对应的数据值大于A对应的值

元组(tumple)

1.类型转换  支持for循环的数据类型都可以转成元组
	print(tuple(['aq',3,4,9]))  #  ('aq', 3, 4, 9)
	print(tuple({'name':'jack','age':19}))  #  ('name', 'age')
# 元组内若只有一个值，那么逗号不能省略，若省略，那么括号内这个值是什么类型，这个‘元组’就是什么类型
# 建议编写元组时时刻记得加逗号('aaa',)
2.索引相关操作
	t1 = (1,2,3,4)
	print(t1[0])  # 1
3.统计元组内数据值的个数
	print(len(t1))  # 4
4.统计元组内特定数据值的个数
	print(t1.count(1))  # 1
5.查与改  '''元组的索引不能更改绑定的地址'''
	t1[0] = 11  # 报错  元组不可以改
	t2 = (1,2,3,[1,2,3])
	t2[-1].append(22)
	print(t2)  # (1, 2, 3, [1, 2, 3, 22])

字典(dict)

字典很少转换类型，通常都是直接定义
dict = {
    'name':'jason',
    'age':19,
    'hobby':'book'
}
1.字典内k:v键值对是无序的 因此不能索引取值
2.取值操作
	print(dict['name'])  # jason  不推荐  若key不存在会报错
	print(dict.get('xxx'))  #  None  推荐  即使原字典没有该key，也不报错，而是返回none
3.统计字典中键值对的个数
	print(len(dict))  #3
4.修改数据   若原字典有该key值，则修改
	dict['name'] = 'jasonnb'
	print(dict)  # {'name': 'jasonnb', 'age': 19, 'hobby': 'book'}
5.新增数据   若原字典没有该key值，则添加
	dict['password'] = '123'
	print(dict)  #{'name': 'jason', 'age': 19, 'hobby': 'book', 'password': '123'}
6.删除数据
方式1
	del dict['name']
	print(dict)  # {'age': 19, 'hobby': 'book'}
方式2
	res = dict.pop('name')  #同列表的pop()一样，字典也可暂时使用将要被删除的值
	print(res,dict)  #jason {'age': 19, 'hobby': 'book'}
7.快速获取键 值 键值对数据
	print(dict.keys())  # dict_keys(['name', 'age', 'hobby'])  获取所有的key值结果当成列表
	print(dict.values())  # dict_values(['jason', 19, 'book'])  获取所有的value值，结果是列表
	print(dict.items())  # dict_items([('name', 'jason'), ('age', 19), ('hobby', 'book')])  获取字典kv键值对，结果是列表套元组
8.修改字典数据   键存在则是修改  键不存在则是新增
	dict.update({'name':'jason01'})
	print(dict)  # {'name': 'jason01', 'age': 19, 'hobby': 'book'}
	dict.update({'password':'123'})
	print(dict)   #{'name': 'jason01', 'age': 19, 'hobby': 'book', 'password': '123'}
9.快速构造字典  给的值默认情况下所有的键都用一个
	res = dict.fromkeys([1, 2, 3], None)
	print(res)
	new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}
	new_dict['name'] = []
	new_dict['name'].append(123)
	new_dict['pwd'].append(123)
	new_dict['hobby'].append('read')
	print(new_dict)

	res = dict.fromkeys([1, 2, 3], 234234234234234234234)
	print(id(res[1]))
	print(id(res[2]))
	print(id(res[3]))
10.键存在则获取键对应的值 键不存在则设置 并返回设置的新值
	res = dict.setdefault('name','jason')
	print(res,dict)  # jason {'name': 'jason', 'age': 19, 'hobby': 'book'}

集合(set)

#集合内的数据必须是不可变类型
'''去重'''
s1 = {1,1,1,12,2,2,2,3,4,4,4,4,5,6,6}
print(s1)  # {1, 2, 3, 4, 5, 6, 12}
l1 = ['jack','jack','tony','tony','mack']
s2 = set(l1)
print(s2)  #{'tony', 'jack', 'mack'}\
print(list(s2))  # ['jack', 'mack', 'tony'] 完美去重

'''关系运算'''
# 模拟两个人的好友合集
f1 = {'jason','tony','adele','lili'}
f2 = {'jason','tony','taylor','kevin'}
# 1.求f1和f2的共同好友  交集
print(f1 & f2)  #{'tony', 'jason'}
# 2.求f1/f2独有好友
print(f1 - f2) # {'adele', 'lili'}
print(f2 - f1) # {'kevin', 'taylor'}
# 3.求f1和f2所有的好友  并集
print(f1 | f2)  # {'taylor', 'kevin', 'jason', 'adele', 'tony', 'lili'}
# 4.求f1和f2各自独有的好友(排除共同好友)
print(f1 ^ f2)  # {'adele', 'kevin', 'lili', 'taylor'}
# 5.父集 子集
s1 = {1,2,3,4,5,6}
s2 = {1,2,3}
print(s1 > s2)  # True  集合中 <> 不在表示两个集合的大小比较而是判断从属关系（父子关系）
print(s1 < s2)  # False

可变与不可变类型

为什么字符串调用内置方法产生一个新的值，二列表则会改变自身
1.可变类型  list dict
# 值改变（内置方法），内存地址可以不变
	l1 = [1,2,3,4]
	print(id(l1))  # 2777520126784
	res = l1.append(5)
	print(l1,id(l1))  # [1, 2, 3, 4, 5]  2777520126784
2.不可变类型  int str float
# 值改变（内置方法），内存地址一定改变  you jump , i jump
	s1 = 'abcdef'
	print(id(s1))  #  1898769696048
	s1 = s1.lower()
	print(s1,id(s1))  #  1898769692656

作业

1.基于字符串充当数据库完成用户登录(基础练习)
	data_source = 'jason|123'  # 一个用户数据
  	获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
'''
    data_source = 'jason|123'  # 一个用户数据
    data_source = data_source.split('|')  #将所给数据的|去掉，方便判断
    username = input('请输入用户名')
    password = input('请输入密码')
    if data_source[0] == username and data_source[1] == password:  #根据索引取值判断输入是否正确
        print('密码正确，欢迎')
    else:
        print('用户名或密码错误')
'''
2.基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
	data_source = ['jason|123', 'kevin|321','oscar|222']
 '''
    data_source = ['jason|123', 'kevin|321', 'oscar|222']
    username = input('请输入用户名')
    password = input('请输入密码')
    user = ('|'.join([username,password]))  #先把用户输入的内容转成数据库中的数据格式再判断
    if user in data_source:
        print('登陆成功')
    else:
        print("用户名或密码错误")
'''

3.利用列表编写一个员工姓名管理系统
    输入1执行添加用户名功能
    输入2执行查看所有用户名功能
    输入3执行删除指定用户名功能
    ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
    提示: 循环结构 + 分支结构
    
'''
staff = ['jason','jack','tony']
while True:
    print('请输入您的操作：1.添加用户 2.查看所有用户 3.删除用户')
    text = input()
    if text == '1': # 添加用户
        staff_name = input('请输入您要添加的员工姓名')
        staff.append(staff_name)
        print(f'{staff_name}已被添加到系统中')
    elif text == '2': # 查看所有用户
        print(staff)
    elif text == '3': # 删除用户
        del_name = input('请输入您要删除的员工姓名')
        staff.remove(del_name)
        print(f'{del_name}已被删除')

'''
2.	去重下列列表并保留数据值原来的顺序
	eg: [1, 2, 3, 2, 1]
	去重之后[1, 2, 3]
        
'''
l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
l2 = []
for i in l1:
    if i not in l2:
        l2.append(i)
print(l2)  # [2, 3, 1, 4, 5, 6]
'''


3.
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
　　linuxs = {'kermit', 'tony', 'gangdan'}
　　1.
求出即报名python又报名linux课程的学员名字集合
　　2.
求出所有报名的学生名字集合
　　3.
求出只报名python课程的学员名字
　　4.
求出没有同时这两门课程的学员名字集合

'''
pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
print(pythons & linuxs)
print(pythons | linuxs)
print(pythons - linuxs)
print(pythons ^ linuxs)

'''