python -----数据类型

python基础-第一篇-（从数据类型出发） 运行环境：

• python3.8.8

• jupyter-lab

数据类型的获取方法

• type(): 返回指定值得数据类型

type("11")
output：str

• isintance()：判断传入的值是否为指定类型

isinstance('Python你好', str)
output:True

基础数据类型（6种）

1 int:数字
2 str:字符串
3 list:列表
4 tuple:元组
5 sets:集合
6 dict:字典

print("1 %s"% type(1))
print("'11' %s"% type("1"))
print("[1] %s"% type([1]))
print("{'1':1} %s"% type({'1':1}))
print("(1,2) %s"% type((1,2)))
print("{1,2} %s"% type({1,2}))
output:
1 
'11' 
[1] 
{'1':1} 
(1,2) 
{1,2} 

不可变数据类型

不可变数据类型包括int(数字)、str(字符串)、tuple(元组),float(浮点型)、boolean(布尔型)

数字(int)类型操作 数据类型转换

int(x) ：将x转换为一个整数。

float(x)： 将x转换到一个浮点数。

complex(x, y) ：将x转换到一个复数，实数部分为 x，不传y时虚数部分为 0。

运算符‘+ - * */ // % * **’

注意的是 “/”总是返回的浮点型

type(8 / 6 )
output:
float

“//”：返回除法向下取整后的结果,

注：返回值还与分母相关，分母为浮点，则返回值也为浮点

17 % 3 
output: 2

“%”：返回余数

17 // 3
output:5

**：幂运算

abs(x)

返回数字的绝对值

abs(-1)
output:1

math.xxx

• math.ceil(x)：返回数字的上入整数

• math.exp(x)：返回e的x次幂

• math.floor(x)：返回数字的下舍整数

• math.fabs(x)：返回数字的绝对值

• math.log(x，y)：返回以y为底x的对数

• math.log10(x)：返回以10为基数的对数

• math.pi：圆周率

• math.e：自然常数

• math.modf(x)：返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

import math
x = 2.22
print(math.ceil(x))#返回数字的上入整数
output:3

x = 2
print(math.exp(x))#返回e的x次幂
output:7.38905609893065

x = 2.22
print(math.floor(x))#返回数字的下舍整数
output:2

x = -1
print(math.fabs(x))#返回数字的绝对值
output:1.0

x,y =100,10
print(math.log(x,y))#返回以y为底x的对数
output:2.0

x = 100
print(math.log10(x))#返回以10为基数的对数
output:2.0

print(math.pi)#圆周率
output:3.141592653589793

print(math.e)#自然常数
output:2.718281828459045
print(math.modf(2.1) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
output:(0.10000000000000009, 2.0)

max(x,y,z),min(x,y,z)

计算x,y,z中最大/最小的数

max(1,2,3)
output:3
min(1,2,3)
output:1

pow(x,y)

计算x**y 运算后的值

pow(10,2)
output:100

sqrt()

sqrt(x)返回数字x的平方根

sqrt(100)
output:10

round(x[,n])

round返回浮点数x的四舍五入

见规范输出专篇

生成随机数

见随机数专篇

字符串(str)操作 数据类型转换

str() 将指定值转为字符串类型。

str(1.222)
output:'1.222'

eval()

将字符串转换成有效的python表达式或者计算结果，也可以做数据类型的转换：

# 转换为表达式,3为int
eval("1+2")
output:3
# 数据类型的转换
res = eval("[1,2]")
type(res)
output:list

返回特定格式（居中，大小写，填充）

• str.capitalize()

返回首字母大写，其余小写的字符串

cap = 'pyThoN'.capitalize()
pirnt(cap) # 'Python'

• str.center(width,fillchar)

返回一个指定长度width的居中字符串，空余部分由fillchar指定的字符填充，fillchar默认为空格

注：fillchar只支持一个字符

center= 'Python_demo'.center(25, "-")
print(center)
output:
'-------Python_demo-------'

• str.lower() &str.upper()

str.lower() &str.upper() 将指定字符串转换为小写/大写

'PytHON'.lower()
output:python

• str.title()

title() 返回字符串中每一个单词首字母大写

'python'.title()
output:'Python'

• str.ljust() & str.rjust()

str.ljust(width,fillchar) & str.rjust(width,fillchar)实现指定宽度的左右对齐字符串

ljust_str = 'Python_demo'.ljust(15, "!")
output：‘Python_demo!!!!’

统计、 查找、定点查找

• str.count()

str.count(sub, start, end) 返回 sub 在 str 中出现的次数，可以通过 [start, end] 指定范围，若不指定，则默认查找整个字符串。

name = 'psddaaa python'
name.count('a'), name.count('p', 1)
output:(3,1)

• str.find() & str.rfind()

find() 从左往右扫描字符串，返回 sub 第一次出现的下标。可以通过 [start, end] 指定范围，若不指定，则默认查找整个字符串。如最后未找到字符串则返回 -1。

rfind则是从右往左开始扫描 ，结果与find一致

name = 'Python'

name.find('Py'), name.find('Py', 1)
output:(0,-1)

• str.index() & str.rindex()

和find类似，但是找不到值会报错ValueError: substring not found

name = 'Python'
name.index('Py', 0)
output：0

判断(字母数字大小写汉字空格首尾）

• str.isalnum()

isalnum() 判断字符串中是否所有字符都是字母/汉字/数字，是 True ，否 False，空字符串返回 False

'Python字符串12'.isalnum()
output：True

• str.isalpha()

isalpha() 判断字符串中是否所有字符都是字母/汉字，是 True ，否 False，空字符串返回 False

'Python字符串'.isalpha()
output：True

• str.isdigit()

isdigit() 判断字符串中是否所有字符都是数字(Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字)，是 True ，否 False，空字符串返回 False

• str.isspace()

字符串中只包含空格(n换行、r回车、f换页、t横向制表符、v纵项制表符)，是 True ，否 False，空字符串返回 False

'nrftv'.isspace()
output:True

• str.startswith() & str.endswith

startswith(prefix[, start[, end]]) 检查字符串是否是以指定子字符串 substr 开头，是 True ，否 False，空字符串会报错。如果指定 start 和 end ，则在指定范围内检查。

startswith_str = 'Python_demo'
startswith_str.startswith('thon', 2) #从第 3 个字符开始检测 
output:True

• str.istitle()

istitle() 判断字符串是否满足每一个单词首字母大写，是 True ，否 False，空字符串返回 False

• str.isupper()& str.islower()

str.isupper()& str.islower() 判断字符串所有区分大小写的字符是否都是大写/小写形式

注： 空字符串或者字符串中午区分大小写的字符返回False

切割，分割，组装

• str.lstrip() & str.rstrip() & str.strip()

str.lstrip() 会在字符串左侧根据指定的字符进行截取，若未指定默认截取左侧空格回车rnt

name = '+++Python+++'
name.lstrip('+')
output：‘Python+++’

str.strip()会截取字符串两边指定的字符

• str.join(iter)

join(iterable) 以指定字符串作为分隔符，将 iterable 中所有的元素(必须是字符串)合并为一个新的字符串。

"---".join(["p","y","t"])
output:'p---y---t'
tip:
"---".join(["p"]) # 只有一个元素时不会添加分隔符
output:'p'

• str.split() & str.splitlines()

str.split(sep=None, maxsplit=-1) 使用sep做分隔符，进行分割，返回列表，maxsplit从左到右分割的最大次数

split_str = 'P y t h o n111'
split_str.split(maxsplit=2)
output:['p','y','t h o n111']

str.splitlines 返回字符串中的行列表，它按照行 ('r'，n'，'rn') 分隔，返回分隔后的列表。它只有一个参数 keepends 表示是否在结果中保留换行符，False (默认)不保留，True 保留

split_str = 'Pnyr t hon'
split_str.splitlines(keepends=True)
output:['Pn’, ‘yr’, ’ t hon']

tuple(元组)操作 tuple()

tuple() 将可迭代对象转换成元组

tuple([0,1,2]) + tuple(range(3)) + tuple({0,1,2}) + tuple('012')
output:(0, 1, 2, 0, 1, 2, 0, 1, 2, ‘0’, ‘1’, ‘2’)

可变数据类型

可变类型有list(列表)、dict(字典)、set(集合)

list(列表)操作 list()

list() 将可迭代对象转成列表。

list((0,1,2)) + list({0,1,2}) + list('012')
output:[0, 1, 2]

增(追加，拓展，插入)

• list.append()：追加写，在末尾添加元素

lst = ['Python', 'Java']
lst.append('C')
lst
output：[‘Python’, ‘Java’, ‘C’]

• list.extand()：扩展列表，在列表末尾添加可迭代对象，字典和集合的追加需要注意

lst = ['Python']
lst.extend('123')
output:['Python','1', '2', '3']
# 追加集合
lst = ['Python']
lst.extend({1,2,3})
lst
output:['Python','1', '2', '3']
# 追加字典，只会将key追加至末尾
lst = ['Python']
lst.extend({1: 'b', 2: 'a'})
lst
['Python', 1, 2]

• list.insert(index,object):将指定对象插入到index位置，当index大于列表长度时，元素会添加至末尾

lst = ['Python', 'Java', 'C']
lst.insert(1, 'C++')
lst
output：[‘Python’, ‘C++’, ‘Java’, ‘C’]

删

• list.pop()：移除指定位置的元素，并返回删除的元素的值，默认移除最后一个，超出长度则会报错。

lst = ['P','y','t','h','o','n']
lst.pop(1), lst
output: ('y',['P','t','h','o','n'])

• list.remove(value)：删除列表中第一次出现的value，无返回值，直接对列表进行修改。值不存在则报错。

• list.clear():移除列表中所有的元素，无返回值，列表为[]

改(赋值排序）

• list.reverse()：将列表本身进行逆序排列

lst = [1, 5, 9, 2]
lst.reverse()
lst
output：[2, 9, 5, 1]

• list.sort(key, reverse):对列表进行特定方式的排序，修改原列表，且元素相等时顺序不会因为排序而改变。

key:指定可迭代对象中的每个元素按照该函数进行排序，通常和lambda一起使用。

reverse: False为升序，True为降序

lst = [{"id":"2"},{"id":"5"},{"id":"3"}]
lst.sort(key=lambda x:x["id"],reverse=False)
output：
[{'id': '2'}, {'id': '3'}, {'id': '5'}]

查

• list.index(value,start,stop)：返回列表中第一个与value匹配的元素下标。

• list.count(value)：返回value在列表中出现的次数，无value则返回0

list.copy() # 深拷贝浅拷贝

浅拷贝通常只复制对象本身，而深拷贝不仅会复制对象，还会递归的复制对象所关联的对象。

深拷贝可能会遇到两个问题：

• 一个对象如果直接或间接的引用了自身，会导致无休止的递归拷贝；

• 深拷贝可能对原本设计为多个对象共享的数据也进行拷贝。

解决方法：deepcopy可以通过memo字典来保存已经拷贝过的对象，从而避免自引用递归问题
注：列表的切片操作[:]相当于实现了列表对象的浅拷贝

• copy:

    - 当最外层对象为可变类型时，copy后得到的对象指向新的内存空间，当最外层的对象为不可变类型时，copy后得到的对象指向原对象的内存空间（注意：浅拷贝的对象的最外层是否是可变类型）

• deepcopy：除拷贝对象本身，还拷贝对象中引用的其他对象

    - 拷贝的内容中只要有一个是个可变类型，那么deepcopy一定是深拷贝

    

>>> a = [1, 2, 3]
>>> b = list(a)
>>> print(id(a), id(b))          
# a和b身份不同
140601785066200 140601784764968
>>> for x, y in zip(a, b):       # 但它们包含的子对象身份相同...     
    print(id(x), id(y))
    ... 
140601911441984 140601911441984
140601911442016 140601911442016
140601911442048 140601911442048

注：深拷贝只有一种方式：copy模块中的deepcopy函数。

1、赋值：简单地拷贝对象的引用，两个对象的id相同。

2、浅拷贝：创建一个新的组合对象，这个新对象与原对象共享内存中的子对象。

3、深拷贝：创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。

dict(字典)操作 dict.clear()

clear() 清除字典的所有内容

dic = {'clear': 'clear',}
dic.clear()
dic
output：{}

dict.fromkeys()

fromkeys() 创建一个新字典，以序列 iterable 中元素做字典的键，value 为字典所有键对应的初始值

• iterable： 可迭代对象，新字典的键

• value： 可选参数, 设置键序列对应的值，默认为 None

dict.fromkeys(['key1', 'key2'],'Python')
output：{‘key1’: ‘Python’, ‘key2’: ‘Python’}

dict.get()

get(key, default=None) 根据指定的 key 值查找，如果 key 在字典中，则返回 key 的值，否则为 None

dic = {'get_value': 'demo01'}
dic.get('get_value')
output:'demo01'

dict.items()

items() 返回视图对象，是一个可遍历的 key/value 对，可以使用 list() 将其转换为列表

dic = {'key01': 'value01',
       'key02': 'value02'}
list(dic.items())
output:[('key01','value01'),('key02','value02')]

dict.keys()

keys() 返回一个视图对象，值为字典的 key ，可将其转换成列表

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.keys()
output:dict_keys(['key01',key02'])

dict.setdefault()

setdefault(key, default=None) 如果键不在字典中，则插入值为 None 的键。如果键在字典中，则返回键的值

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.setdefault('key02','value03)
output:'value02'

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.setdefault('key03','value03)
dic
output:{'key01': 'value01',
       'key02': 'value02'
       'key03':'value03'}
       

dict.update()

dict.update(dict1) 把字典 dict1 的 key/value 对更新到 dict 里，当 dict1 的 key 出现在 dict 中则修改 dict 中的值，如果 key 没有出现在 dict 中，则添加这一对 key/value

dic1 = {'key01': 'value01',
       'key02': 'value02'}
dic2 = {'key01': 'value01',
       'key02': 'value02'} 
dic1.update(dict2)
dic1
output:{'key01': 'value01',
       'key02': 'value02',
       'key01': 'value01',
       'key02': 'value02'}    

dict.values()

values() 返回一个视图对象，值为字典的 value ，可将其转换成列表

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.values()
output:dict_values([‘value01’, ‘value02’])

dict.pop() & dict.popitem()

dict.pop() 删除指定 key 的 key/value ，如果 key 没有找到，则报错

popitem() 删除字典中末尾的元素，并返回一个元组的(键，值)对。字典为空则报错

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.pop('key01')
dic
output:{'key02':'value02'}

dic = {'key01': 'value01',
       'key02': 'value02'}
dic.popitem()
output:{'key02':'value02'}

set（集合） set.add()

向集合中添加一个元素，但如果该元素已经出现在集合中，则不起作用

注：如果add的元素已经在集合中 集合不会发生变化

set1 = {'set01','set02','set03'}
set1.add('python')
set1
output:{'set01','set02','set03','python'}

set.clear()

clear() 移除集合中的所有元素

set1 = {'python'}
set1.clear()
set1
output：set()

set.difference() & set.difference_update()

difference() 返回多个集合的差集，通俗来讲就是返回第一个 set 中哪些元素没有在其他 set 中出现

difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接移除原集合中的元素，无返回值

set1 = {'set01',
        'c++',
        'python'}
set2 = {'python', 'c++'}
set3 = {'Python'}
set1.difference(set2, set3)
output：{'set01'}

set1 = {'set01',
        'c++',
        'python'}
set2 = {'python', 'c++'}
set3 = {'Python'}
set1.difference_update(set2, set3)
set1
output：set()

set.discard()

discard() 删除集合中指定的元素。如果指定移除的元素不在集合中，则不移除

set1 = {'set01','set02','set03'}
set1.discard('set01')
output:{'set02','set03'}

set.intersection() & set.intersection_update()

• intersection() 返回集合的交集。没有交集则返回空集 set()

• intersection_update() 方法与 intersection() 方法的区别在于 intersection() 方法将集合的交集作为新集合返回，而 intersection_update() 方法是直接修改原集合中的元素，只保留交集元素，无返回值。

set1 = {'set01','set02','set03'}
set2 = {'set01', 'c++'}
set03 = {'set01'}
set1.intersection(set2, set3)
output:{'set01'}

set1 = {'set01','set02','set03'}
set2 = {'set01', 'c++'}
set03 = {'set01'}
set1.intersection_update(set2, set3)
set1
output:{'set01'}

set.isdisjoint()

isdisjoint() 判断两个集合是否包含相同的元素，有则返回 False，无则返回 True

set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.isdisjoint(set2)
output:False

set.issubset()&set.issuperset()

• issubset(set1) 判断集合 set2 是否为 set1 集合的子集。是则返回 True，否则返回 False

• issuperset(set2) 判断集合 set2 是否为 set1 集合的子集。是则返回 True，否则返回 False。它与 issubset() 用法相同，只有参数的位置相反而已

set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set2.issubset(set1)
output:True

set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.issuperset(set2)
output:True

set1.pop()&set.remove()

• pop() 移除并返回集合中的任意元素。如果该集合为空集则报错

• remove() 从集合中移除指定的元素，如果该元素不在集合中，则发生报错

set1 = {'set01','set02','set03'}
set1.pop()
output:'set03'
set1.remove('set01')
set1
output:{'set02'}

set.symmetric_difference()&set.symmetric_difference_update()

• symmetric_difference() 返回两个集合中不重复的元素集合，即两个集合的补集，与 ^ 的作用相同

• symmetric_difference_update(set2) 移除 set1 中在 set2 相同的元素，并将 set2 集合中不同的元素插入到 set1 中。简单来说就是把 set1 与 set2 的补集赋值给 set1

set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.symmetric_difference(set2)  ==> set1 ^ set2
output:{'set03'}

set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.symmetric_difference_update(set2) ==>set1 = set1 ^ set2
set1
output:{'set03'}

set.union()

union() 返回多个集合的并集。与 | 的作用相同

set1 = {'set01','set02','set03'}
set2 = {'set01','set02','set04'}
set3 = {'set01','set02','set05'}
set1.union(set2, set3)
output:{'set01','set02','set03','set04','set05'}

set.update()

update() 使用本身和其他的联合来更新集合

set1 = {'set01','set02','set03'}
set1.update([1,2,3])
output:{'set01','set02','set03',1,2,3}