数据类型

数字类型内置方法

一丶整型内置方法(int)

1.用途：年龄

2.定义：可以使用int()方法将纯数字的字符串转为十进制的整型

x = int('11.1')  # 报错
print(x)

二丶浮点型内置方法(float)

1.用途：薪资，身高，体重

2.定义：可以使用float()方法将纯数字的字符串转为浮点型数字。

x = float('111')
print(x)
print(type(x))

111.0

<class 'float'>

3.常用操作+内置方法：算数运算+比较运算

4.存一个值or多个值：一个值

5.有序or无序：无有序无序一说

6.可变or不可变：不可变数据类型

字符串类型内置方法

1.用途：

描述性质的东西，如人的名字、单个爱好、地址、国家等

2.定义：

使用'',"",'''''',""""""包裹的一串字符

​ ~u'unicode':uniicode编码的字符串

​ ~b'101':二进制编码的字符串

​ ~r' ':原生字符串，也就是说' '这是普通的两个字符，并没有换行的意思

name = 'nick'	#name = str('nick')
s1 = str(1.1)
s2 = str([1,2,3])
print(f's1:{s1},type:{type(s2)}')
print(f's2:{s2},type:{type(s2)}')

s1:1.1,type:<class 'str'>
s2:[1, 2, 3],type:<class 'str'>

3.常用操作+内置方法：

1.1 优先掌握（*****************）

​ 1.按索引取值（只可取，不可变）

name = 'shiqi zz'
      # 01234567  #索引序号

print(f'索引为3：{name[3]}')
print(f'索引为5：{name[5]}')
print(f'索引为-2：{name[-2]}')

索引为3：q
索引为5：
索引为-2：z

​ 2.切片（顾头不顾尾，步长）

name = 'shiqi zz2019'
#       01234567891011 索引序号
print(f'切片-3到最后：{name[-3:]}')
print(f'切片3-8：{name[3:8]}')
print(f'切片3-8，步长为2：{name[3:8:2]}')
print(f'切片3-最后，步长为2：{name[3::2]}')

print(f'切片所有：{name[:]}')
print(f'反转所有：{name[::-1]}')
print(f'切片-5--2：{name[-5:-2]}')
print(f'切片-2--5：{name[-2-5:-1]}')

切片-3到最后：019
切片3-8：qi zz
切片3-8，步长为2：q z
切片3-最后，步长为2：q z09
切片所有：shiqi zz2019
反转所有：9102zz iqihs
切片-5--2：z20
切片-2--5：102

3.长度len

name = 'shiqi zz 2019'
print(len(name))

10

4.成员运算in和not in

msg = 'my name is shiqi zz,i am handsome'

print(f"'shiqi' in msg:{'shiqi' in msg}")
print(f"'nick' not in msg:{'nick' not in msg}")
print(f"not 'nick' in msg:{not 'nick' in msg} ")

'shiqi' in msg:True
'nick' not in msg:True
not 'nick' in msg:True

5.移除空白strip()

name = '#@  shi qi zz&*^'
print(f"name.strip('@#^&*'):{name.strip('@#^&*')}") # strip()默认为'',并且不修改原值，新创建空间
print(f"name:{name}")

print(f"name.strip('#@ ^&*'):{name.strip('#@ ^&*')}")
name = '  shi qi  '
print(f"name.strip:{name.strip()}")  # strip默认切除两边空白

#strip()应用场景
pwd = input('password: ')# 用户可能会手抖输入空格
if pwd.strip() == '123':
    print('密码输入成功')

name.strip('@#^&'): shi qi zz
name:#@ shi qi zz&^
password: 123
密码输入成功
name.strip('#@ ^&*'):shi qi zz
name.strip:shi qi

6.切分split

info = 'nick:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':',1)

print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')

info_list1:['nick', 'male', '19']
info_list2:['nick', 'male:19']

7.循环

msg = 'hello nick'

for i in msg:
    print(i)

h
e
l
l
o
n
i
c
k

1.2 需要掌握（**）

name = '  #@shiqi* '

name.lstrip('#')  # 左切割
name.rstrip('*')  # 右切割

name.lower()   # 全小写
name.upper()   # 全大写

name.startswith(' ')   # 判断开头为什么，返回布尔值
name.endswith('*')    # 判断结尾为什么，返回布尔值

name.rstrip('*')   # 从右开始切割

lis = {'nick','male','19'}
print(':'.join(lis))   #nick:male:19    拼接,必须为相同类型

name.replace('qi','ba')   # 替换

name.isdigit()  #判断是否为数字

列表类型内置方法

1.定义方式：[]内逗号隔开多个元素（任意数据类型）

2.使用方法

name_list = ['nick','jason','tank','sean']

# 优先掌握
name_list[0]   #正向取值

name_list[-2] #反向取值

name_list[0] = 'nick handsom'  # 修改值


name_list[0:3:2]  # 切片

name_list   # 长度

'tank' in name_list    # 成员运算in 和  not in

name_list.append('shiqi')  # 追加

del name_list[2]    # 删除

for name in name_list:
    print(name)   #循环

#需要掌握

name_list.insert(0,'handsome')
print(name_list)    #插入

name_list.pop(1)  # 删除  默认删除最后一个

name_list.remove('nick')  #删除

name_list.count('nick')   #计数个数 1.2.3...

name_list.index('nick')   #获取索引

name_list.clear()   # 清空

name_list.copy()   # 复制

l1 = [1]
l2 = [2]           #合并列表
l1.extend(l1)

name_list.reverse()   #列表倒序

name_list.sort()    # 使用sort列表元素必须是同类型的    列表内排列

字典类型内置方法

1.定义方式：{}内逗号隔开多个元素（任意数据类型）

2.使用方法

dic = {'a':1,'b':2}

dic['a']    #按k索值
dic['a'] = 3  # 按k更换值

len(dic)    # 字典长度

'a' in dic #True
'1' in dic # False  成员运算

del dic['a']    # 删除

dic.pop('a')   #删除指定元素

dic.keys()   #dict_keys(['a', 'b'])  获取键keys
dic.values()    #dict_values([1, 2])   获取值values
dic.items()  #dict_items([('a', 1), ('b', 2)]) 获取键值对items

for k,v in dic.items():  # items可以换成keys()、values()
    print(k,v)     # 循环

# 需要掌握

dic.get('a')   # 1  获取值的个数

#  dict1.update(dict2)    拼接字典

dic = dict.fromkeys(['name', 'age', 'sex'], None)
print(f"dic: {dic}")
#  dic: {'name': None, 'age': None, 'sex': None}  快速生成一个字典

集合类型内置方法

s = {1,2,'a'}

len(s)  #长度

# 1 in s:  True  成员运算in not in

#并集 s1|s2

# 交集 s1&s2

# 差集 s1-s2

# 对称差集  s1^s2

#  s1==s2   判断是否相等

# s1>=s2  s1>s2  父集

# s1<s2 s1<=s2   子集

s.add(3)  # 增加元素

s.remove(1)   #删除元素

元组类型内置方法

元组为不可变数据类型

在()内可以有多个任意类型的值，逗号分隔元素

使用方法和列表一样，不可更改的列表

数据类型分类

定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

使用方法

s = {1,2,'a'}

len(s)  #长度

# 1 in s:  True  成员运算in not in

#并集 s1|s2

# 交集 s1&s2

# 差集 s1-s2

# 对称差集  s1^s2

#  s1==s2   判断是否相等

# s1>=s2  s1>s2  父集

# s1<s2 s1<=s2   子集

s.add(3)  # 增加元素

s.remove(1)   #删除元素

一丶按存值个数区分

存值个数	数据类型
单个值	数字，字符串
多个值（容器）	列表，元组，字典，集合

二丶按可变不可变区分

可变or不可变	数据类型
可变	列表，字典，集合
不可变	数字，字符串，元组

三丶有序无序区分

有序or无序	数据类型
有序（可按索引取值）	字符串，列表，元组
不可变	字典，集合

四丶按访问类型区分

访问类型	数据类型
直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典