数据类型内置方法

数据类型内置方法

数据类型内置方法理论

学习的每一种数据类型本身都含有一系列的操作方法，内置方法是其中最多的（自带的功能）

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

整型内置方法与操作

类型转换(将其他数据类型转换成整型)
	int(其他数据类型)
    ps:浮点型可以直接转 字符串必须满足内部是纯数字才可以
        
整形类型
moon = int(11.11)
moon = int(11.57)
moon = int('11.11') 字符串必须是数字
 print(moon,type(moon))

进制数的转换

1.十进制转其他进制
print(bin(100)) #0b1100100  0b开头是二进制
print(oct(100)) #0o144      0o开头是八进制
print(hex(100)) #0x64       0x开头是十六进制

2.进制转换为数字
print(int(0b1100100))
print(int(0o144))
print(int(0x64))

print(int('0b1100100',2))
print(int('0o144',8))
print(int('0x64',16))

3.python自身对数字的敏感度较低(精确度低)
s1 = 1.1
s2 = 1
print(s1-s2)  #0.10000000000000009 计算的没有那么精准

浮点型内置方法与操作

1.类型转换
	float(其他数据类型)
 	字符串里面可以允许出现一个小数点 其他都必须是纯数字
    
浮点类型
moon = float(66)  #66。0  （整形）在后面加个小数点
moon = float('66') #66.0   （字符串）在后面加个小数点
moon = float('66.66') #66.66
moon = float('6.6.6.6') #不行
moon = float('qwe') # 不行 只能是数字类型
print(moon,type(moon))
    

字符串内置方法与操作

1.类型转换
	str(其他数据类型)
	ps:可以转任意数据类型(只需要在前后加引号即可)
        
字符串类型
moon = str(66)
print(moon,type(moon)) #66
moon1 = str(66.66)
print(moon1,type(moon1)) # 66.66
moon2 = str('baby')
print(moon2,type(moon2)) #baby
moon3 = str([1,2,3,4])
print(moon3,type(moon3)) #[1,2,3,4]
moon4 = str({'name':'tony'})
print(moon4,type(moon4))  #{'name': 'tony'}
moon5 = str((1, 2, 3, 4, 5))
print(moon5,type(moon5)) # (1, 2, 3, 4, 5)
moon6 = str({1, 2, 3, 4, 5})
print(moon6, type(moon6))  # {1, 2, 3, 4, 5}
moon7 = str(True)
print(moon7,type(moon7))  #True
       

必须掌握的方法

1.索引取值（起始位置0开始 超出范围直接报错
s1 = 'helloworld'
print(s1[0]) # h
print(s1[-1]) # d 支持负数 从末尾开始

2.切片操作
s1 = 'helloworld'
print(s1[1:5])  # 顾头不顾尾 从索引1一直切取到索引4  ello
print(s1[-1:-5]) # 默认从左往右
print(s1[-5:-1]) #默认从左往右  worl

3.修改切片方向(间隔)
s1 = 'helloworld'
print(s1[1:5:1]) # ello 默认是1
print(s1[1:5:2])  #el   默认是1
print(s1[-1:-5:-1]) #elro
print(s1[:]) # helloworld 不写数字默认都要
print(s1[2:]) #lloworld 从索引2开始往后的都要
print(s1[:5])  # hello   从索引0开始往后要四位
print(s1[::2])  #hlool 每隔一位要一个

4.统计字符串中字符的个数 
s1 = 'helloworld'
print(len(s1)) # 10

5.移除字符串首位指定的字符
username = input('name:').strip()
username = username.strip()
if username =='moon':
    print("登陆成功")
res = 'moon'
print(len(res))
print(len(res.strip())) #括号内不写 默认移除首位的空格
res1 = '$$moon$$'
print(res1.strip('$'))  # moon
print(res1.lstrip('$'))  # moon$$
print(res1.rstrip('$'))  # $$moon

6.切割字符串中指定的字符
res = 'moon|123|play'
print(res.split('|'))  # ['moon','123','play'] 该方法的处理结果是一个列表
name, pwd, hobby = res.split("|")
print(res.split('|', maxsplit=1))  # ['moon','123|play'] 从左往右切指定个数
print(res.rsplit('|', maxsplit=1))  # ['moon|123', 'play'] 从右往左切指定个数

7.字符串格式化输出
format玩法1:等价于占位符
res = 'my name is {} my age is {}'.format('moon', 18)
print(res)

format玩法2:索引取值并支持反复使用
res = 'my name is {0} my age is {1} {0} {0} {1}'.format('moon',18)
print(res)

format玩法3:占位符见名之意
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1}'.format(name1='moon', age1=123)
print(res)

format玩法4:推荐使用(*******)
name = input('name:')
age = input('age:')
res = f'my name is {name} my age is {age}'
print(res)

需要了解的方法

1.大小写相关
res = 'HeLLo WorLD 666'
print(res.upper()) # HELLO WORLD 666
print(res.lower()) # hello world 666


"""
图片验证码:生成没有大小写统一的验证码 展示给用户看
    获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
"""
code = '3W45kA'
print('展示给用户看的图片验证码',code)
confirm_code = input('请输入验证码').strip()
if confirm_code.upper() == code.upper():
    print('验证码正确')
    
        
res = 'hello world'
print(res.isupper())  # 判断字符串是否是纯大写 False
print(res.islower())  # 判断字符串是否是纯小写 Ture

2.判断字符串中是否是纯数字
例子1
res = ''
print(res.isdigit()) #False 不为纯数字

例子2
age = input('age:').strip()
if age.isdigit():
    age = int(age)
else:
    print('年龄都不知道怎么输入吗？')   

3.替换字符串中指定的内容
res = 'my name is moon moon moon moon moon'
print(res.replace('moon', 'tony'))  # my name is tony tony tony tony tony
print(res.replace('moon', 'tony', 1)) #  my name is tony moon moon moon moon 从左往右替换指定个数内容

4.字符串的拼接
aa1 = 'super'
aa2 = 'man'
print(aa1 + aa2)  # superman
print(aa1 * 10) # supersupersupersupersupersupersupersupersupersuper

print('|'.join(['moon', '123', 'play', 'JDB'])) #  moon|123|play|JDB

print('|'.join(['moon', 123])) # 参与拼接的数据值必须都是字符串

5.统计指定字符出现的次数
res = 'good moring'
print(res.count('o'))

6.判断字符串的开头或者结尾
res = 'super man save world'
print(res.startswith('super man')) # True
print(res.startswith('s')) # True
print(res.startswith('supe')) # True
print(res.startswith('u')) # False
print(res.startswith('per')) # False
print(res.endswith('d')) # True
print(res.endswith('rld')) # True
print(res.endswith('wor')) # Flase

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'))  # 3

列表内置方法与操作

1.类型转换
	list(其他数据类型)
	ps:能够被for循环的数据类型都可以转成列表
print(list('代码拯救世界'))  # ['代', '码', '拯', '救', '世', '界']
print(list({'name': '代码拯救世界', 'password': 123}))  # ['name', 'password']
print(list((11, 22, 33, 44, 55)))  # [11, 22, 33, 44, 55]
print(list({1, 2, 3, 4, 5}))  # [1, 2, 3, 4, 5]
"""
    list可以转换支持for循环的数据类型
        可以被for循环的数据类型
            字符串 列表 字典 元组 集合
"""

常见操作
data = ['代', '码', '拯', '救', '世', '界']
 1.索引取值
 print(data[0])  # 代

2.切片操作
 print(data[1:3])  # ['码', '拯']
 print(data[-1::-1])  # ['界', '世', '救', '拯', '码', '代']

3.间隔
 print(data[1:5:2])  # ['码', '救']
    
4.统计列表中元素的个数
 print(len(data))  # 6
    
5.成员运算 最小判断单位是元素不是元素里面的单个字符
 print('代' in data)  # True
 print('111' in data)  # False 

6.列表添加元素的方式
  1.尾部追加'单个'元素
    data.append('去')
    print(data)  # ['代', '码', '拯', '救', '世', '界', '去']
    data.append(['救世界'])
    print(data)  # ['代', '码', '拯', '救', '世', '界', '去', ['救世界']]
2.指定位置插入'单个'元素
    data.insert(0, '我')
    print(data)  # ['我', '代', '码', '拯', '救', '世', '界']
    data.insert(5, '了')
    print(data)  # ['我', '代', '码', '拯', '救', '了', '世', '界']
 3.合并列表
    data.extend([11, 22, 33, 44, 55])
    print(data)  # ['代', '码', '拯', '救', '世', '界', 11, 22, 33, 44, 55]
    '''extend其实可以看成是for循环+append'''
    data += [11,22,33,44] # 加号的效率不高

7.删除
    1.通用的删除方式
    del data[0]
    print(data)#['码', '拯', '救', '世', '界']
    
    2.指名道姓的直接删除某个元素
    data.remove('拯')
    print(data)  ['代', '码', '救', '世', '界']
    
    3.延迟删除
    data.pop()  # 默认是尾部弹出
    print(data)  # ['代', '码', '拯', '救', '世']
    data.pop(1)
    print(data)  # ['代', '拯', '救', '世']
    data.pop(0)
    print(data)  # ['拯', '救', '世']

  8.修改列表元素
  data[0] = '源'
  print(data)  # ['源', '码', '拯', '救', '世', '界']

  9.排序
  data_number = [1, 5, 3, 6, 8, 0, 66]
  data_number.sort()  # 默认是升序
  print(data_number)  # [0, 1, 3, 5, 6, 8, 66]
  data_number.sort(reverse=True)  #降序
  print(data_number)  # [66, 8, 6, 5, 3, 1, 0]

  10.反转
  data.reverse()  #顺序颠倒,(前面的到后面去)

可变类型和不可变类型

可变数据类型：列表list、字典dict、集合set
不可变数据类型：整型int、浮点型float、字符串型string和元组tuple

 """
     可变类型与不可变类型
    可变类型     列表
        值改变 内存地址不变 修改的是本身
    不可变类型   字符串
        值改变 内存地址肯定遍 修改过程产生了新的值
如何查看变量的'内存地址'
id(变量名)
"""

字典相关操作

1.类型转换
	dict()
	字典的转换一般不使用关键字 而是自己动手转
    1.字典必须要掌握的类型
user_dict = {
    'name': 'moon',
    'pwd': '666',
    'hobby': ['read', 'music', 'run']
}
1. 按k取值(不推荐使用)
print(user_dict['name']) # moon
print(user_dict['play']) # k不存在会直接报错

2.按内置方法get取值(推荐使用)
print(user_dict.get('name')) # moon
print(user_dict.get('age')) # None 不会报错
print(user_dict.get('name','talking to the moon')) # 键存在的情况下获取对应的值
print(user_dict.get('age', 'talking to the moon')) # 键不存在默认返回None 可以通过第二个参数自定义


3.修改数据值
print(id(user_dict))
user_dict['name'] = 'tony'  # 键存在则修改对应的值
print(id(user_dict))
print(user_dict)

4.新增键值对
user_dict['age'] = 18 # 键不存在则新增键值对
print(user_dict)

5.删除数据
del
del user_dict['name']
print(user_dict)

pop
res = user_dict.pop('pwd')
print(user_dict)
print(res)  #666


6.统计字典中键值对的个数
print(len(user_dict)) # 3

7.字典三剑客
print(user_dict.keys()) # 一次性获取字典所有的键  dict_keys(['name', 'pwd', 'hobby'])
print(user_dict.values()) # 一次性获取字典所有的值  dict_values(['moon', '666', ['read', 'music', 'run']])
print(user_dict.items())  # 一次性获取字典的键值对数据 dict_items([('name', 'moon'), ('pwd', '666'), ('hobby', ['read', 'music', 'run'])])
for i in user_dict.items():
        k, v = i
        print(k,v)

8.补充说明
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123))  # 快速生成值相同的字典
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res)  # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('moon')
res['pwd'].append(123)
res['hobby'].append('study')
print(res)
 '''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
res = user_dict.setdefault('username','tony')
print(user_dict, res)  # 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age',123)
print(user_dict, res)  # 存不存在则新增键值对 结果是新增的值
user_dict.popitem()  # 弹出键值对 后进先出

元组相关操作

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

集合相关操作

集合相关操作
1.类型转换
	set()
	集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
 	集合内数据也是无序的 没有索引的概念

2.集合需要掌握的方法
去重
关系运算
ps:只有遇到上述两种需求的时候才应该考虑使用集合

3.去重
s1 = {11,22,33,33,22,44,111,333,444,44,33,77,55,33,11}
l1 = {11,22,33,444,555,55,44,11,22,33,44,55}
s1 = set(l1)
l1 = list(s1)
print(l1)
 '''集合的去重无法保留原先数据的排列顺序'''

4.关系运算
  群体之间做差异化校验
 	eg: 两个微信账户之间 有不同的好友 有相同的好友
f1 = {'moon','tony','mark','tom'}  # 用户1的好友列表
f2 = {'jack','moon','tom','jerry'}  # 用户2的好友列表
1.求两人共同好友
print(f1 & f2)  # {'tom', 'moon'}
2.求用户1独有好友
print(f1 - f2)  # {'tony', 'mark'}
3.求两个人所有的好友
print(f1 | f2)  # {'moon', 'tony', 'mark', 'tom', 'jack', 'jerry'}
4.求两人各自独有的好友
print(f1 ^ f2)  # {'mark', 'tony', 'jack', 'jerry'}
5.父集 子集
print(f1 > f2)
print(f1 < f2)

字符串编码

字符编码理论

该知识点理论特别多 但是结论很少 代码使用也很短
1.字符编码只针对文本数据
2.回忆计算机内部存储数据的本质
3.既然计算机内部只认识01 为什么我们却可以敲出人类各式各样的字符
	肯定存在一个数字跟字符的对应关系 存储该关系的地方称为>>>:字符编码本
4.字符编码发展史
	4.1.一家独大
    	计算机是由美国人发明的 为了能够让计算机识别英文
    	需要发明一个数字跟英文字母的对应关系
		ASCII码:记录了英文字母跟数字的对应关系
        	用8bit(1字节)来表示一个英文字符
            
 	4.2.群雄割据
    	中国人
        GBK码:记录了英文、中文与数字的对应关系
       	 	用至少16bit(2字节)来表示一个中文字符
            	很多生僻字还需要使用更多的字节
           英文还是用8bit(1字节)来表示
       日本人
    	  shift_JIS码:记录了英文、日文与数字的对应关系
    	韩国人
         Euc_kr码:记录了英文、韩文与数字的对应关系
  		"""
  		每个国家的计算机使用的都是自己定制的编码本		
  			不同国家的文本数据无法直接交互 会出现"乱码"
  		"""
  	4.3.天下一统
    	unicode万国码
        	 兼容所有国家语言字符
  			  起步就是两个字节来表示字符 
  		utf系列:utf8 utf16 ...
            专门用于优化unocide存储问题
            英文还是采用一个字节 中文三个字节

字符编码实操

1.针对乱码不要慌 切换编码慢慢试即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        bytes类型数据.decode()
3.python2与python3差异
	python2默认的编码是ASCII
		1.文件头
        	# encoding:utf8
    	2.字符串前面加u
        	u'你好啊'
 	python3默认的编码是utf系列(unicode)