基础类型与总结

基础类型总结

type(数据值)/type(变量名)查看数据值的类型

数据类型之整形int

大白话意思就是整数
应用场景：年龄 班级人数 年份
代码实现：
		age = 22
    	stu_num = 66
         year = 2022
整形内置方法与操作
1.类型转换(将其他数据类型钻换成整形)
	int(其他类型数据)
    ps：浮点型可以直接转换 字符串必须满足内部是纯数字才可以
2.进制数转换
	十进制转换其他禁止
    print(bin(100))  #0b1100100
    print(oct(100))  #0o144
    print(hex(100))  #0x64
'''
数字的开头如果是0b则为二进制 0o则为八进制 0x则为十六进制
'''
3.python自身对数字的敏感度较低(精确度低)
	python这门语言其实真的一点都不厉害 主要是因为他背后有太多的大佬
    如果需要精准的计算需要借助与模块numpy....

数据类型之浮点型float

大白话意思就是小数
应用场景：身高 体重 薪资
代码实现：
		height = 1.99
    	 weight = 66.6
         salary = 4.5

数据类型之字符串str

大白话的意思就是文本类型的数据：引号引起来的部分都是字符串
应用场景：姓名 地址 爱好
代码实现;
		name = 'guts'
    	 addr = '上海'
         hobby = '学习'
1.定义字符串有四种方式
name = 'guts'
name1 = "guts"
name2 = '''guts'''
name3 = """guts""" 
2.为什么定义字符串需要有多种方式
	我们在字符串中编写文本也可能会使用到引号 为了避免冲突 有了多种方式
	info = "Jason老师说:'年轻不是用来挥霍的资本'"
3.如何区分三引号是字符串还是注释
	关注左侧是否韩游赋值符号和变量名 如果有则为字符串 没有就为注释

字符串内置方法与操作

1.类型转换
	str(其他数据类型)
    ps:可以转换任意数据类型(只需要再前后加引号即可)
2.必须要掌握的方法
    1.索引取值(起始位置0开始 超出范围直接报错)
    s1 = 'hello word'
    print(s1[0])  # h
    print(s1[-1])  # d 支持负数 从末尾开始
    2.切片操作
    print(s1[1:5])  # ello  顾头不顾尾 从索引1一直切到索引4 
    print(s1[-1:-5])  # 默认顺序是从左往右 不能这么输
    print(s1[-5:-1])  # 顾头不顾尾
    3.修改切片的方向(间隔)
    print(s1[1:5:1])  # 默认是1 第三个数字为间隔数
    print(s1[1:5:2])  # el
    print(s1[-1:-5:-1])  # dlro
    print(s1[:])  # 不写数字就默认都要
    print(s1[2:])  # 从索引2开始往后都要
    print(s1[:5])  # 从索引0开始要到4
    print(s1[::2])  # 每隔两个拿一个
    4.统计字符串中字符的个数
    print(len(s1))
    5.移除字符串首尾指定的字符
    username = input('username:').strip()
    username = username.strip()
    res = '$$guts$$'
    print(res1.strip('$'))   # guts
    print(real.lstrip('$'))  # guts$$
    print(real.rstrip('$'))  # $$guts
    6.切割字符串中指定字符
    res = 'guts|123|study'
    print(res.split('|'))  # ['guts', '123', 'study']  该方法的处理结果是一个列表
    name, pwd, hobby = res.split('|')
    print(res.split('|', maxsplit=1))  #['guts'.'123|study']  # 从左往右切指定个数
    print(res.rsplit('|', maxsplit=1))  #['guts|123', 'study']  # 从右往左切指定个数
    7.字符串格式化输出
    format玩法1：等价于占位符
    res = 'my name is {} my age is {}'.format('guts',123)
    print(res)  # 大括号中的数字为.format()中的索引位置
    format玩法2：索引取值并支持反复使用
    res = 'my name is {0} my age is {1} {0} {1}'.format('guts', 123)
    print(res)
    format玩法3：占位符见名知意
    res = 'my name is {name1} my age is {age1}'.format(name1 = 'gust', age1 = 123)
    print(res)
    format玩法4：推荐使用(*******)
    name = input('name:')
    age = input('age:')
    res = f'my name is {name} my age is {age}'
    print(res)
3.字符串需要了解的用法
	1.大小写相关
    res = 'hELlo WoRld 666'
    print(res.upper())  # HELLO WORLD 666
    print(res.lower())  # hello world 666
    '''图片验证码：生成没有大小写统一的验证码 展示给用户看
    获取用户输入的验证码 讲用户输入的验证码和当初生成的验证码统一转大写或小写再比对
    '''
    code = 'Bja6Cc'
    print('展示给用户看到图片验证码'，code)
    confirm_code = input('请输入验证码').strip()
    if confirm_codde.upper() == code.upper():
        	print('验证码正确')
    res = 'hello world'
    print(res.isupper())  # 判断字符串是否是纯大写 Flase
    print(res.islower())  # 判断字符串是否是纯小写 True
    2.判断字符串是否是纯数字
    res= ''
    print(res.isdigit())  # False
    guess_age = input('guess_age>>>:').strip()
    if guess_age.isdigit():
        guess_age = int(guess_age)
    else:
        print('年龄都不知道怎么输？')
    3.替换字符串中指定的内容
    res = 'my name is guts guts guts guts'
    print(res.replace('guts', 'tonySB'))  # my name is tonySB
    print(res.replace('guts', 'tonySB', 1))  # my name is tonySB guts guts 从左往右替换指定个数的内容
    4.字符串的拼接
    ss1 = 'hello'
    ss2 = 'world'
    print(ss1 + '$$$' + ss2)  # hello$$$world
    print(ss1 * 10)  # hellohellohellohellohellohellohellohellohellohello
    print('|'.join(['guts','123','read','DBJ']))  # guts|123|read|DBJ
    print('|'.join(['guts',123])  # 报错 参与拼接的必须都是字符串
    5.统计指定字符出现的次数      
    res = 'hello world'
    print(res.count('1'))  # 3      
    6.判断字符串开头或者结尾
    res = 'guts say hello'
    print(res.startswith('guts'))  # Ture
    print(res.startswith('g'))  # Ture
    print(res.startswith('s'))  # False
    print(res.endswith('o'))  # Ture
    print(res.endswith('llo'))
    print(res.endswith('hello'))
    print(res.endswith('he'))  # False
    7.其他方法补充
    res = 'hello woRLd HeLLo worLD'
    print(res.title())  # Hello World Hello World
    print(res.capitalize())  # Hello world hello world
    print(res.swapcase())  # HELLO WOrlD hEllo WORld
    print(res.index('o'))  # 所选字符在字符串中的数量
    print(res.find('o'))
    print(res.index('c'))  # 找不到直接报错
    print(res.find('c'))  # 找不到默认返回-1
    print(res.find('lo'))  # 索引字符串在字符串中的位置
    

数据类型之列表list

大白话意思就是可以储存多个数据值的类型 并且可以非常方便的取
应用场景：存储多个数据值 并且将来可能需要单独取其中一些
代码实现：
	name_list = ['guts', 'tony', 'kevin', 'jason', 'jerry']
1.列表的文字描述
	中括号括起来 内部可以存放多个数据值 数据值与数据值之间逗号隔开
    l1 = [11, 11.11, 'guts',[11, 22]]
2.索引取值
	起始数字是从0开始
    l1[索引值]    

列表内置方法及操作

1.类型转换
	list(其他数据类型)
    ps:能够被for循环的数据都可以转成列表
    print(list('hello'))
    print(list{'name':'guts', 'pwd':123})
    print(list((1,2,3,4)))
    print(list({1,2,3,4,5}))
2.需要掌握的方法
	l1 = [111, 222, 333, 444, 555, 666, 777]
    1.索引取值(正负数)
    print(l1[0])  # 111
    print(l1[-1])  # 777
    2.切片操作  与字符串讲解操作一致
    print(l1[0:5])  # [111, 222, 333, 444, 555]
    print(l1[:])  # [111, 222, 333, 444, 555, 666, 777]
    3.间隔数 方向 与字符串讲解操作一致
    print(l1[::-1])
    4.统计列表中数据值的个数
    print(len(l1))  # 7
    5.数据值修改
    l1[0] = 123  # 按照索引位置
    print(l1)
    6.列表添加数据值
    方式1：在尾部追加数据值
    l1.append('干饭')
    print(l1)  # [123, 222, 333, 444, 555, 666, 777, '干饭']
    l1.append(['guts','jason','kevin','jerry'])
    print(l1)  # [123, 222, 333, 444, 555, 666, 777, ['guts', 'jason', 'kevin', 'jerry']]
    方式2:任意位置插入数据值
    l1.insert(0, 'jason')
    print(l1)
    l1.insert(1, [11, 22, 33, 44])
    print(l1)  # [111, [11, 22, 33, 44], 222, 333, 444, 555, 666, 777, 888]
    方式3：扩展列表 合并列表
    ll1 = [11.22.33]
    ll2 = [44,55,66]
    print(ll1+ll2)  # [11, 22, 33, 44, 55, 66]
    ll1.extend(ll2)  # for循环+append
    print(ll1)  # [11, 22, 33, 44, 55, 66]
    for i in 112:
        ll1.append(i)
    print(ll1)  # [11, 22, 33, 44, 55, 66]
    7.删除列表数据
    方式1：通用的删除关键字del
    del l1[0]
    print(l1)
    方式2：remove
    l1.remove[444]  # 括号内填写数据值
    print(l1)
    方式3：pop
    l1.pop(3)  # 括号内填写索引值
    print(l1)
    l1.pop()  # 默认尾部弹出数据值
    print(l1)
    res = l1.pop(3)
    print(res)  # 444
    res1 =l1.remove(444)  # 直接销毁
    print(res1)  # None
    8.排序
    ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
    ss.sort()  # 默认是升序
    print(ss)
    ss.sort(reverse = True)
    print(ss)  # 改为降序
    9.统计列表中某个数据值出现的次数
    print(l1.count(111))
    10.颠倒列表顺序
    l1.reverse()
    print(l1)
    

数据类型之字典dict

能够非常精确的存储和表达数据值的含义
代码实现：
	info_dict = {
        'username': 'guts'
        'age': 22
        'hobby': 'read'
    }
1.字典的文字描述
	大括号括起来 内部可存放多个数据 数据的组织方式是K:V键值对
     键值对与键值对之间用逗号隔开
    K是对V的描述性性质的信息(解释说明) 一般都是字符串类型
    V是真正的数据值 可以是任意数据类型
2.按K取值
	字典只能按K取值 因为字典是无序的 没有索引的概念
    info_dict['username']

字典内置方法相关操作

1.类型转换
	dict()
    字典的转换一般不使用关键字 而是自己手动转
2.字典必须要掌握
	user_dict = {
    'username': 'guts',
    'password': 123,
    'hobby': ['sing', 'jump', 'basketball']    
    }
    1.按k取值(不推荐使用)
    print(user_dicy['username'])  # guts
    print(user_dict['phone'])  # k不存在会直接报错
    2.按内置方法get取值(推荐使用)
    print(user_dict.get('username'))  # guts
    print(user_dict.get('age'))  # None
    print(user_dict.get('username', '没有 给爷爬'))  #  guts 键存在的情况下获取对应的值
    print(user_dict.get('phone', '没有 快爬'))  # 没有 快爬  键不存在的情况下默认返回None 可以通过第二个参数字定义
    3.修改值的数据
    print(id(user_dict))
    user_dict['username'] = 'tony'  # 键存在则修改对应的值
    print(id(user_dict))
    print(user_dict)
    4.新增键值对
    user_dict['age'] = 18  # 键不存在则新增键值对
    print(user_dict)
    5.删除数据
    del user_dict['username']
    print(user_dict)  # {'password': 123, 'hobby': ['sing', 'jump', 'basketball']}
    res = user_dict.pop('password')
    print(res)  # 123
    6.统计字典中键值对的个数
    print(len(user_dict))  # 3
    7.字典中的三剑客
    print(user_dict.keys())  # 一次性获取字典中的所有键  dict_keys(['username', 'password', 'hobby'])
    print(user_dict.values())  # 一次性获取字典中所有的值  dict_values(['jason', 123, ['read', 'music', 'run']])
    print(user_dict.iteam())  # 一次性获取字典的键值对数据 dict_items([('username', 'jason'), ('password', 123), ('hobby', ['read', 'music', 'run'])])
    for i in user_dict.items:
        k, v = i
        print(k,v)
        '''
        username guts
        password 123
        hobby ['sing', 'jump', 'basketball']
        '''      
    8.补充说明
    print(dict.fromkeys(['name','pwd','hobby',123]))  # 快速生成值相同的字典
    res = dict.fromkeys(['name','pwd','hobby'], [])
    print(res)  # {'name': [], 'pwd': [], 'hobby': []}
    res['name'].append('guts')
    res['pwd'].append(123)
    res['hobby'].append('study')
    print(res)  # {'name': ['guts', 123, 'study'], 'pwd': ['guts', 123, 'study'], 'hobby': ['guts', 123, 'study']}
     '''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
    res = user_dict.setdefault('username','tony')
    print(user_dict, res)
    res = user_dict.setdefault('age',123)
    print(user_dict, res)  # 键不存在则新增键值对 结果是新增的值
    user_dict.popitem()  # 弹出键值对 后进先出

基本数据类型之布尔值bool

1.用来判断事物的对错 是否可行 主要用于流程控制中
2.只有两种状态
	Ture	对的 真的 可行的
    False	错的 假的 不可行的
3.python中所有数据值都带有布尔值
	布尔值为Flase的数据有：0 None '' [] {}
    布尔值为Ture的数据值有：出了上面的都是Ture
4.存储布尔值的变量名一般推荐使用is开头
	is_delete = Flase
    is_alive = Ture
"""
很多程序中提供的注销账户功能其实底层没有删除数据 而是修改了数据的中泰
id		username	password    phone    is_delete
1		jason		123		   110     	 1
2		kevin		321		   120		 0
"""    

基本数据类型之元组tuple

1.也成为 '不可变'的列表
	元组内索引绑定的内存地址不能修改
2.小括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值可以是任意数据类型
3.代码实现
		t1 = (11, 22, 'guts')
4.元组与列表的对比
	l1 = [11, 22, 33]
    print(l1[0])  # 获取索引0所对应的数据值
    l1[0] = 666
    print(l1)  # [666, 22, 33]
    
    t1 = (11, 22, [111, 222])
    print(t1[0])  # 11
    t1[0] = 999  # 报错
    t1[2][1] = 666
    print(t1)  # (11, 22, 33, [111, 666])
5.元组内如果只有一个数据值
	t1 = (1)
    t2 = (11, 11)
    t3 = ('jason')
    print(type(t1),type(t2),type(t3))  # <class 'int'> <class 'float'> <class 'str'>
    t1 = (1,)
    t2 = (11.11,)
    t3 = ('jason',)
    print(type(t1), type(t2), type(t3))  # <class 'tuple'> <class 'tuple'> <class 'tuple'>
    """
    建议:以后在使用可以存放多个数据值的数据类型时 如果里面暂时只有一个数据值 那么也建议你加上     逗号
    """

元组相关操作

1.类型转换
	tuple()
    ps:支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
	t1 = (11, 22, 33, 44, 55, 66)
    1.索引取值
    2.切片操作
    3.间隔，方向
    4.统计元组内数据值的个数
    print(len(t1))
    5.统计元组内某个数据值出现的次数
    print(t1.count(l1))
    6.统计元组内指定数据值的索引值
    print(t1.index(22))
    7.元组内如果只有一个数据值那么逗号也不能省略
    8.元组内索引值绑定的内存地址不能修改 (注意区分 可变与不可变)
    9.元组不能新增或者删除数据

基本数据类型之集合set

1.集合只能用于去重和关系运算
2.集合内数据只能是不可变类型
3.大括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值不是K:V键值对
4.代码实现
	a1 ={1, 2, 3, 4, 5, 6}
5.定义空集合与空字典
	{}  默认是字典
    set{}  定义空集合    

集合相关操作

1.类型转变
	set()
    集合内数据必须是不可变类型(整形 浮点型 字符串 元组)
    集合内数据是无序的 没有索引的概念
2.集合需要掌握的方法
	去重
	关系运算
ps：只有遇到上述两种需求的时候才会考虑使用集合
3.去重
	l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
    s1 = set(l1)
    l1 = list(s1)
    print(l1)  # [33, 11, 22]
    '''集合的去重无法保留原先数据的排列顺序'''
4.关系运算
	群体之间做差异化校验
    eg：两个微信账户之间 有不同的好友 有相同的好友
    f1 = {'jason', 'tony', 'jerry', 'oscar'}  # 用户1的好友列表
    f2 = {'jack', 'jason', 'tom', 'tony'}  # 用户2的好友列表
    1.求两个人的共同好友
    print(f1 & f2)
    2.求用户1独有的好友
    print(f1 - f2)
    3.求两个人所有的好友
    print(f1 | f2)
    4.求两个人各自独有的好友
    print(f1 ^ f2)
    5.父级  子集
    print(f1 > f2)
    print(f1 < f2)