python数据整理 高一_Python--数据类型整理

数据类型整理

------------------------------------------------------------------------------------------------

- int 整型

-bit_length 使用方法:用一个int型例如int后的n

n.bit_length()

- to_bytes， 将数字转换成字节类型： 6表示用多少个人字节表示，little/big,用于指定生成字节的顺序

result = val.to_bytes(6,'little')

print(result)

- from_bytes，将字节转换成数字

result = b'\x02\x00\x00\x00\x00\x00'

data = int.from_bytes(result,'little')

print(data)

-------------------------------------------------------------------------------------------------

- bool 布尔类型

-True/False False包括：0 {} [] () None

-------------------------------------------------------------------------------------------------

-str 字符串

-upper 将所有字母大写

使用方法：例如字符串变量

n=abc

n=n.upper()

结果n=ABC

-lower 将所有字母小写

使用方法：例如字符串变量

n=ABC

n=n.upper()

结果n=abc

-strip 去掉数据的所有空格

使用方法：例如字符串变量

n=' ca '

n=n.strip()

结果n='ca'

-split 分割

使用方法： 例如字符串变量

n=‘2+3'

n=n.split('+')

结果[2,3] 加在变量后，括号内字符串形式写分割依据

-replace 替换

使用方法： 例如字符串变量

n='alex'

n = n.replace('x','c')

replace括号内前面字符串形式的被替换内容，后面是替换内容

-join 迭代

使用方法： 例如

li=['a','b','c']

v='+' n=li.split(v)

结果a+b+c，v为要使用的迭代符放在split括号内，前面是迭代列表内容

-capitalize 首字母大写

使用方法： 例如字符串变量

n=alex

n=n.capitalize()

结果n=Alex 首字母大写

-starswith 是否以···为开头

使用方法：例如字符串变量

n=alex

if n.starswith('a'):

print(True)

else: print(False)

结果True ,后面括号内是要确定是否是开头的数值

-endswith 是否以···为结尾

使用方法：上同，不过是结尾

-isdecimal 判断是否是数字

使用方法： 例如字符串变量

n=’9‘

if n.isdecimal():

print(True)

else:

print(False)

结果是True

-encode('utf-8或utf-8') #

使用方法：

n=’name‘

v=n.encode('utf-8')

把字符串转化成字节,括号内是转换的编码型

-find 寻找

使用方法：寻找索引例如

n='alex'

v=n.find('e')

print(v)

结果是2，寻找索引后面括号内要寻找的字符串，寻找不到输出-1

-index 寻找

使用方法同上，不过没寻找到报错

-casefold 将所有字母最小写，同lower()

使用方法，不过包含小语种

lower()只能英语

-count 用于统计某个字符在字符串中出现的次数

使用方法：

n='alel'

v=n.count('l')

print(v)

结果是2出现次数两次 除此外还可以规定范围

规定范围方法

n='alel'

v=n.count('l',0,4)

print(v)

结果是2 如果是n='alel' v=count('l',2,4)print(v) 结果是1

-center 数值在中间向两边填充

name = 'alEalax'

val = name.center(20,'*')

print(val)

结果是******alEalax******* 括号内前面是加上数据的总长度后面是填充内容

-ljust 数值在左向右填充 上同

-rjust 数值在右向左填充 上同

-expandtabs 使\t的数据对其

使用方法：

name = 'IDIDIDID\tName\tPasswword\n1\talex\111\n2\teric\t888'

val = name.expandtabs(50) print(val)括号内是对齐长度，算上数据本身

-format 格式化有四种写法 还有用占位符

name = "我叫{0},年龄{1}-{0}-{0}"

val = name.format('海娇',45)

print(val)

其中{0} format()内第一个数据 可以重复使用 {1}是第二个 依次

name = "我叫{0},年龄{1}-{0}-{0}"

val = name.format(*['海角',45])

print(val)

列表要加*

name = "我叫{name},年龄{age}"

dic = {'name':'海角','age':18}

val = name.format(**dic)

print(val) 给定key 也可以重复使用，要用列表要有*一个不行就两个

-format_map 可以不加*用列表字典

-----------------------------------------------------------------------------------------------------

-list 列表

-append 列表末尾添加新的对象

使用方法：

name = [1,2,3,4]

name.append(5)

print(name)

结果是[1,2,3,4,5] 括号内可以是字符串整数，也可以列表等

-insert 向列表指定位置添加对象

使用方法：

name = [1,2,3,4]

name.insert[2,5]

print(name)

结果是[1,2,5,3,4]

-reverse 列表反转

使用方法 :

name = [1,2,3]

name.reverse()

print(name)

结果：[3,2,1]

-count 列表中某个东西出现多少次

使用方法:

name = [1,2,3]

v = name.count(1)

print(v)

结果是1

-extend 扩展 将可迭代的放进去 相当于批量append

使用方法：name = [1,2] name.extend('礼券') print(name) 结果是[1,2,'礼'，‘券']

name = [1,2] name.extend(5,6,7) print (name) 结果是[1,2,5,6,7]

-index 找某个值索引位置

使用方法:

name = [1,2,3]

v = name.index(1)

print(v) 结果是：0

-pop 默认删除最后一个可以指定索引删除并且获取到值赋值给变量

使用方法：

name = [1,2,3]

v = name.pop(1)

print(v)

结果是：2 name为 [1,3]

-remove 移除

使用方法：同上，不过不获取移除的值，直接移除。可按照值移除，不按照索引移除。与pop不同，pop按索引，remove按值，重复只删第一个

-sort 排序

使用方法：

name = [3,2,1]

name.sort()

print(name)

结果是：[1,2,3]

默认括号内为(reverse=False)，从小到大是(reverse=True)

-copy 深浅拷贝 深拷贝拷贝所有层，浅拷贝只拷贝一层 使用方法：

name = [1,2,3]

name.copy() 浅拷贝

深拷贝：import copy

li = [11,22]

li2 = copy.deepcopy(li)

-clear 清除 使用方法：name.clear() 列表内内容全部清除

-----------------------------------------------------------------------------------------------------

-dict 字典

-clear 上同列表

-copy 上同列表

-fromkeys 通过类就可以"."出来的功能，能生成字典

# val = dict.fromkeys(['k1','k2','k3'],666)

# print(val)

# val['k1'] = 999

结果：{'k1': 666, 'k2': 666, 'k3': 666}

# val = dict.fromkeys(['k1','k2','k3'],[])

# val['k1'].append(678)

# val['k2'].append(999)

# print(val)

结果是：{'k1': [678, 999], 'k2': [678, 999], 'k3': [678, 999]}

# val = dict.fromkeys(['k1','k2','k3'],[])

# val['k1'].append(666)

# val['k1'] = [1,2,3]

# print(val)

结果是：{'k1': [1, 2, 3], 'k2': [666], 'k3': [666]}

-get

获取索引值

使用方法：

name.get()

括号内第一个可以索引值 ，第二个默认值

-pop 同列表

-items 所有键值对

-keys 所有的key

-popitem pop中指定了key popitem出来的值是元素类型 也可以取两个值

-setdefault 添加 列表中有的就不修改，没有就添加

-update 更新

# dic = {'k1':'v1','k2':'v2'} # dict类的一个对象

# dic.update({'k4':'v4','k2':'v5'})

# print(dic)

结果：{'k1': 'v1', 'k2': 'v5', 'k4': 'v4'}

--------------------------------------------------------------------------------------------------

-set(集合)

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# names.add('龙哥')

# print(names)

又加一次'龙哥'也不会出现，集合不可以重复

#2. 差集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = ['小高','海娇','小狗']

# val = names.difference(boys) # names中存在，boys中不存在数据

# print(val)

输出的val是boy中不存在的数据

# val = boys.difference(names) # boys中存在，names中不存在数据

# print(val)

输出的val是names中不存在的数据

# boys.difference_update(names) # boys中存在，names中不存在数据

# print(boys)

输出的boys中的names中不存在的数据

# names.difference_update(boys) # boys中存在，boys中不存在数据

# print(names)

输出的names

# 3. 对称差集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = {'小高','海娇','小狗'}

# {'龙哥','海角','老狗','成绩','小江'}

# {'海娇','小狗'}

# {'海娇','小狗','龙哥','海角','老狗','成绩','小江'}

# val = names.symmetric_difference(boys)

# print(val)

把同样的去掉，输出的是两个互相不相同的

# names.symmetric_difference_update(boys)

# print(names)

同上

# 4. 在集合中删除指定值

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# names.discard('龙哥')

# print(names)

集合中删除指定值的使用

# 5. 求交集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = {'小高','海娇','小狗'}

#

# val = names.intersection(boys)

# print(val)

#求交集，输出两个都有的

# names.intersection_update(boys) 更新了前面的，对name重新赋值了

# print(names)

同上

# 6. 并集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = {'小高','海娇','小狗'}

#

# val = names.union(boys)

# print(val)

两个都有的都输出

# 7.判断是否无交集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = {'海娇','小狗'}

# # 有交集：False

# # 无交集：True

# val = names.isdisjoint(boys)

# print(val)

# 8. 子集父集

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = {'龙哥','老狗'}

# # 是否是子集

# val = boys.issubset(names)

# print(val)

# # 是否是父集

# val = names.issuperset(boys)

# print(val)

# 9. 删除集合元素

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# v = names.pop()

# print(v)

# names.remove('老狗')

# print(names)

# names.discard('老狗1')

# print(names)

# 10. 更新

# names = {'龙哥','海角','老狗','成绩','小江','小高'}

# boys = ['龙哥1','老狗1']

#

# names.update(boys)

# print(names)

# 集合

- 元素，不可变

name = {1,'alex'}

name = {1,'alex',[11,22,33]}

name = {1,'alex',{''}}

name = {1,'alex',()}

name = {1,'alex',{'1','2'}}