数据类型内置、可变类型与不可变类型

数据类型内置方法理论

我们之前所学习的每一种数据类型本身都含有一系列的操作方法,内置方法是其中最多的(自带的功能)

在python中数据类型调用内置方法的统一句式为>>>:句点符
	'jason'.字符串内置方法
 	绑定字符串的变量名.字符串内置方法
  	str.字符串内置方法
ps:数据类型的内置方法比较的多 我们如果想要掌握 不要光靠死记硬背 更多时候靠的是熟能生巧

整型内置方法与操作

1.类型转换(将其他数据类型转换成整型)
	int(其他数据类型)
 	ps:浮点型可以直接转（小数点后面的会直接删除）  
        字符串必须满足内部是纯数字才可以
        
2.进制数转换
	十进制转其他进制
    	  print(bin(100))  # 0b1100100
        print(oct(100))  # 0o144
        print(hex(100))  # 0x64
 	'''
 	数字的开头如果是0b则为二进制 0o则为八进制 0x则为十六进制
 	'''
	其他进制转十进制
    	  print(int(0b1100100))
        print(int(0o144))
        print(int(0x64))
    如果这个进制数是字符串，这个字符串是几进制就在后面加几，也可以识别转换	
        print(int("0b1100100", 2))
        print(int("0o144", 8))
        print(int("0x64", 16))
        
3.python自身对数字的敏感度较低(精确度低)
	python这门语言其实真的一点都不厉害 主要是因为它背后有太多大佬
 	如果需要进准的计算需要借助于模块numpy.....

浮点型内置方法与操作

1.类型转换
	float(其他数据类型)
 	字符串里面可以允许出现一个小数点 其他都必须是纯数字
    
2.python自身对数字的敏感度较低(精确度低)
	python这门语言其实真的一点都不厉害 主要是因为它背后有太多大佬
 	如果需要进准的计算需要借助于模块numpy.....

字符串内置方法与操作

1.类型转换
	str(其他数据类型)
	ps:可以转任意数据类型(只需要在前后加引号即可)
2.必须要掌握的方法
	 1.索引取值  (起始位置0开始 超出范围直接报错)
    s1 = 'helloworld'
    # print(s1[0])  # h
    h
    # print(s1[-1])  # d  支持负数 从末尾开始
    d
    
    2.切片操作
    # print(s1[1:5])  # 顾头不顾尾 从索引1一直切取到索引4
    ello
    # print(s1[-1:-5])  # 默认的顺序是从左往右
    查找不到
    -5  -4  -3  -2  -1  0  1  2  3  4  5
    -1在前只能朝着右边0,1,2,3的方向继续找
    # print(s1[-5:-1])  # 默认的顺序是从左往右
    worl
    
    3.修改切片(①:一个功能是控制方向②:一个功能是控制间隔)
    s1 = 'helloworld'
     print(s1[1:5:1])   默认是1，这里改的是间隔
    ello
     print(s1[1:5:2])  # 默认是1，这里改的是间隔
    el
     print(s1[-1:-5:-1]) 改顺序了，从右往左，这里改的是方向
    dlro
     print(s1[:])  # 不写数字就默认都要
    helloword
     print(s1[2:])  # 从索引2开始往后都要
    lloword
     print(s1[:5])  # 从索引0开始往后要到4
    hello
     print(s1[::])  # 不写数字就默认都要，和一个冒号是一样的
    helloword
     print(s1[::2]) #全都要，但是每隔一个要一个
    hlool
    
    s1 = 'hello world'
    4.统计字符串中字符的个数(空格也算长度)
    # print(len(s1))  # 10
    11
    
    5.移除字符串首尾指定的字符
    res = '  jason  '
    # print(len(res))
    9
    # print(len(res.strip()))  # 括号内不写 默认移除首尾的空格
    5
    
    res1 = '$$jason$$'
    # print(res1.strip('$'))  #移除首尾指定字符
    jason
    
    # print(res1.lstrip('$'))  #移除左边指定字符
    jason$$
    # print(res1.rstrip('$'))  #移除右边指定字符
    $$jason
     
    6.切割字符串中指定的字符
    res = 'jason|123|read'
    # print(res.split('|'))  # 在split括号中指定切割的管道符'|'
    ['jason', '123', 'read']  管道符没了，而且有几个就切了几个
              该方法的处理结果是一个列表
        
    name, pwd, hobby = res.split('|')
    这个用到了解压赋值
    
    print(res.split('|', maxsplit=1))  
    ['jason', '123|read']  从左往右切指定个数
    # print(res.rsplit('|',maxsplit=1))  
    ['jason|123', 'read']  从右往左切指定个数
    
    7.字符串格式化输出
    format玩法1:等价于占位符
    res = 'my name is {} my age is {}'.format('jason', 123)
    print(res)
    
    my name is jason my age is 123
    
    format玩法2:索引取值并支持反复使用
    res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
    print(res)
    
    my name is jason my age is 123 jason jason 123
    
    format玩法3:占位符见名知意
  res = 'my name is {name1} my age is{age1}'.format(name1='jason', age1=123)
    print(res) 
    
    my name is jason my age is 123
    
    format玩法4:推荐使用(******)
        f模板字符串
    name = input('username>>>:')  #输入jason
    age = input('age>>>:')    #18
    res = f'my name is {name} my age is {age}'
    print(res)
    在字符串前面加f，里面通过大括号，在大括号里面写一个前面出现过的变量名，这个变量名所绑定的值会被自动放进来
    
    my name is jason my age is 18
    
3.字符串需要了解的方法
	 1.大小写相关
     res = 'hElLO WorlD 666'
  print(res.upper()) #转大写，所有的英语字母转大写，其它的不受影响
        HELLO WORLD 666
        
  print(res.lower()) #转大写，所有的英语字母转小写，其它的不受影响
        hello world 666
    
    
    
    '''图片验证码:生成没有大小写统一的验证码 展示给用户看
    获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
    '''
    res = 'hElLO WorlD 666'
     code = '8Ja6Cc'
     print('展示给用户看的图片验证码', code)
     confirm_code = input('请输入验证码').strip()#移除首位空格
     if confirm_code.upper() == code.upper():#转大小写
         print('验证码正确')
            
            
           
     res = 'hello world'
     print(res.isupper()) # 判断字符串是否是纯大写，判断结果是一个布尔值  
     False
    
     print(res.islower()) # 判断字符串是否是纯小写，判断结果是一个布尔值
     True
        
        
     2.判断字符串中是否是纯数字
     res = ''  
     print(res.isdigit())
    # 判断字符串是否是纯数字，判断结果是一个布尔值
    
    
    例子：猜年龄
     guess_age = input('guess_age>>>:').strip()
     if guess_age.isdigit():
         guess_age = int(guess_age)
     else:
         print('年龄都不知道怎么输吗???')
            
            
            
     3.替换字符串中指定的内容
     res = 'my name is jason jason jason jason jason'
     print(res.replace('jason', 'tonySB'))  
    
    my name is tonySB tonySB tonySB tonySB tonySB
    
    
     print(res.replace('jason', 'tonySB', 1))  
        my name is tonySB jason jason jason jason  
      在括号里面末尾加数字，从左往右替换指定个数的字符
        
        
     4.字符串的拼接  #字符串之间支持加法和乘法
     ss1 = 'hello'
     ss2 = 'world'
     print(ss1 + ss2) #两个字符串进行拼接
        
     helloword
        
     print(ss1 + '$$'+ ss2) #字符串进行拼接的时候，中间也可以添加别的符号
    hello$$word
    
     print(ss1 * 10)  #字符串只能和数字相乘
    
    hellohellohellohellohellohellohellohellohellohello
    
    加入，用一个列表或元组放入多个字符串
     print('|'.join(['jason', '123', 'read', 'JDB']))
      
    jason|123|read|JDB  
    # 将列表当中多个数据值用jojn前面括号里的管道符作为连接符，拼在一起，拼成一个字符串，可以看成是split的反向操作
        
     print('|'.join(['jason', 123]))  
    参与拼接的数据值必须都是字符串
    
    
     5.统计指定字符出现的次数
     res = 'hello world'
     print(res.count('l'))
     3    
        
        
     6.判断字符串的开头或者结尾
     res = 'jason say hello'
     print(res.startswith('jason')) #猜以jason为开头
     Ture
     print(res.startswith('j'))  #猜以j为开头
     Ture   
     print(res.startswith('jas'))  #猜以jas为开头
     Ture
     print(res.startswith('a'))  #猜以a为开头
     False   
     print(res.startswith('son'))  #猜以son为开头
     False
     print(res.startswith('say'))  #猜以say为开头
     False   
        
     print(res.endswith('o'))    #猜以0为结尾
     Ture
     print(res.endswith('llo'))   #猜以llo为结尾
     Ture   
     print(res.endswith('hello'))  #猜以hello为结尾
     Ture
    
    
     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'))  #只能从左往右找到第一个符合的
     4
     print(res.find('O'))  #只能从左往右找到第一个符合的
     4      
     print(res.index('c'))  
    找不到直接报错
     print(res.find('c'))  
     找不到默认返回-1
     print(res.find('LO'))  
     3

列表内置方法及操作

1.类型转换
	list(其他数据类型) 
	ps:能够被for循环的数据类型都可以转成列表
 	print(list('hello')) 
    print(list({'name': 'jason', 'pwd': 123}))
    print(list((1, 2, 3, 4)))
    print(list({1, 2, 3, 4, 5}))
    
2.需要掌握的方法
	11 = [111, 222, 333, 444, 555, 666, 777, 888]
     1.索引取值(正负数)
     print(l1[0])
    111
     print(l1[-1])
    888
    
     2.切片操作    与字符串讲解操作一致
     print(l1[0:5])
    111222333444
     print(l1[:])
    111222333444555666777888 
    
     3.间隔数 方向  与字符串讲解操作一致
     print(l1[::-1])
     888777666555444333222111 
        
     4.统计列表中数据值的个数
     print(len(l1))  
     8
    
     5.数据值修改
     l1[0] = 123
     print(l1)
     [123, 222, 333, 444, 555, 666, 777, 888]
    
     6.列表添加数据值
     方式1:尾部追加数据值
     l1.append('干饭')  
     print(l1)  
        [111, 222, 333, 444, 555, 666, 777, 888, '干饭']
        
     l1.append(['jason', 'kevin', 'jerry'])    
    #不管写多少数据值，都只会当成一个数据值添加进去
     print(l1)  
        [111, 222, 333, 444, 555, 666, 777, 888, ['jason', 'kevin', 'jerry']]
        
        
     方式2:任意位置插入数据值  
        
     l1.insert(0, 'jason')   
    #通过索引的方式添加，第一个写索引位置，第二个写要添加的数据
     print(l1)
     ['jason'，111, 222, 333, 444, 555, 666, 777, 888] 
    
     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 ll2:       #遍历l2的值，依次放到l1的末尾
         ll1.append(i)
     print(ll1)
    [11, 22, 33, 44, 55, 66]
    
     7.删除列表数据
     11 = [111, 222, 333, 444, 555, 666, 777, 888]   
     方式1:通用的删除关键字del
     del l1[0]  #让列表索引的值断开
     print(l1)
     [222, 333, 444, 555, 666, 777, 888]    
    
    
     方式2:remove
     l1.remove(444)  # 括号内填写数据值
     print(l1)
    [111，222, 333, 555, 666, 777, 888]
    
     方式3:pop
     l1.pop(3)  # 括号内填写索引值
     print(l1)
     [111，222, 333, 555, 666, 777, 888]   
        
     l1.pop()  # 默认尾部弹出数据值
     print(l1)
     [111，222, 333, 444，555, 666, 777] 
    
     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)
    [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]
    
     ss.sort(reverse=True)
     print(ss)  # 改为降序
    [100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
    
    
     9.统计列表中某个数据值出现的次数
    print(l1.count(111))    #输入要索引的数据值
    1
    
     10.颠倒列表顺序   
    11 = [111, 222, 333, 444, 555, 666, 777, 888]    
     l1.reverse()
     print(l1)
     [888, 777, 666, 555, 444, 333, 222, 111]
        

可变类型与不可变类型

 s1 = '$$jason$$'
 s1.strip('$')
 print(s1)  
 $$jason$$
    
'''字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果
如何查看调用方法之后有没有新的结果 可以在调用该方法的代码左侧添加变量名和赋值符号
    res = s1.strip('$')
'''

l1 = [11, 22, 33]
 ret = l1.append(44)   #给该代码赋值
 print(l1)  
 [11, 22, 33, 44]
    
 print(ret)  #并没有产生新的东西
 None
'''列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果'''

 可变类型:值改变 内存地址不变
 l1 = [11, 22, 33]  
 print(l1)  #打印
 print(id(l1))   #添加之前查看地址
 l1.append(44)
 print(l1)   #打印
 print(id(l1))   #添加之后查看地址
 [11, 22, 33]   
 3063113831296    #改的自己，内存地值不会变
 [11, 22, 33, 44]   
 3063113831296       
       
 不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'
print(res)     #打印
print(id(res))  #查看id
res.strip('$')  #去掉字符串两边的$符号
print(res)     #打印
print(id(res))  #查看id
'$$hello world$$'    #重新生成了一个，内存地址肯定变
1592242339888
'$$hello world$$'
1592242339567