python中的数据类型：数字、字符串、元组、序列、字典、集合

1、Number：包含 整数（int）、浮点数（float）、复数（complex）

Python可以同时为多个变量赋值，如a, b = 1, 2；

一个变量可以通过赋值指向不同类型的对象；

数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符；

在混合计算时，Python会把整型转换成为浮点数。

2、字符串

（1）自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并不是换行（显示原字符串内容）

（2）python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"

（3）连接字符串 “+” 

 （4）获取字符串长度 len() --当我们对中文进行编码，采用“UTF-8”编码类型时，一个汉字的字节数量是3

（5）字符串截取  str[start:end:step]  起始：结束：步长

str01= 'abcdefghijk'

str01[2:7:2]    #从下标为2位置开始（包含），到下标为7位置（不包含），步长为2  -- 结果ceg

str01[:]    #全部截取

str01[:7]    #从开始到小标为7的位置  结果abcdefg

str01[7:]    #小标为7的位置到最后  结果hijk

str01[:-2]    #从开始到倒数第二个  结果abcdefghi

str01[::-1]    #全部倒序

str01[7:2:-1] # 结果hgfed

（7）字符串方法

str.upper( ) #转化为大写

str.lower( ) #转化为小写

str.swapcase( ) #字符串大小写互换

str.capitalize( ) #首字母大写

str.title( ) #字符串中全部单词首字母大写

str.replace(old,new,count)  # count 替换次数，此参数可省略；如果省略表示替换所有需要被替换的字符或字符串

strip(chars) ：去除字符串两侧的指定内容，并且，可以同时去除多个相同的指定内容；参数chars为指定的一个或多个字符，不填入该参数则去除字符串两侧所有空格。

lstrip(chars) ：去除字符串左侧的指定内容，并且，可以同时去除多个相同的指定内容；参数chars为指定的一个或多个字符，不填入该参数则去除字符串左侧所有空格。

rstrip(chars) ：去除字符串右侧的指定内容，并且，可以同时去除多个相同的指定内容；参数chars为指定的一个或多个字符，不填入该参数则去除字符串右侧所有空格。

index(sub,start,end)  和 rindex(sub,start,end) ：

index方法是从左至右查询，rindex方法是从右至左查询

参数sub是指被查询的字符或字符串，参数start是查询的起始位置，参数end是查询的终止位置（终止位置不在查询范围内）；

参数start和参数end可以同时省略，这时为查询字符串中全部字符；也可以只省略参数end，表示查询范围为起始位置至末尾。

返回第一次出现的下标位置，没找到抛异常 substring not found

find(sub,start,end)  和  rfind(sub,start,end)  #没有找到的时候 返回 -1

count(x,start,end)，这个函数可以统计字符串中被查询的字符或字符串出现的次数

（8）字符串格式化

使用格式化符号：%s（字符串）  %d（整数）  %f（浮点数）

print("%s----%d----%0.01f "%(arg01,arg02,arg03))

使用format()函数：

format(args,kwargs)：对字符串进行格式化的函数；参数args表示可以输入多个参数（argument），参数间以逗号分隔；参数kwargs表示可以输入多个关键词参数，关键字函数的写法例如：age=’18’，age为关键字，’18’为这个关键字对应的值。

print('您的出生日期为：{}年{}月{}日'.format(id[6:10], id[10:12], id[12:14]))

print('您的出生日期为：{1}年{0}月{2}日'.format(id[10:12], id[6:10], id[12:14]))

print('您的出生日期为：{year}年{month}月{day}日'.format(month=id[10:12], year=id[6:10], day=id[12:14]))

3、元组（tuple）

元组不能更改，只能查询。

tup1= (1,2,3,4,5,6,7,8,9)# 创建元组

len(tup1)    # 获取元组的元素数量

tup1+tup2    # 连接多个元组为一个新元组

tup2*3    # 重复元组元素为一个新元组

tup1[0]    # 获取元组指定位置的元素，索引位置从左至右由0开始

tup1[-1]    # 获取元组指定位置的元素，索引位置从右至左由-1开始

tup1[2:8:2]    # 获取元组中指定片段的元素，并可以设置间隔获取

max(tup1)    # 元组中元素均为同一类型时，获取元组中最大的元素

min(tup1)    # 元组中元素均为同一类型时，获取元组中最小的元素

'a' in tup1    # 判断元组中是否包含某个元素，如果包含，返回值为True，否则为False

tup1.index('a')    # 查询元组中是否包含某个元素，如果包含，返回值为索引位置，否则抛出异常

tup3.count('我')    # 获取元组中某个元素的出现次数

4、序列（list）

lst1= [1,2,3,4,5,6,7,8,9]    # 创建列表

len(lst1)    # 获取列表的元素数量

lst1+lst2    # 连接多个列表为一个新列表

lst2*3    # 重复列表元素为一个新列表

lst1[0]    # 获取列表指定位置的元素，索引位置从左至右由0开始

lst1[-1]    # 获取列表指定位置的元素，索引位置从右至左由-1开始

lst1[2:8:2]    # 获取列表中指定片段的元素，并可以设置间隔获取

max(lst1)    # 数组中元素均为数字类型时，获取列表中数值最大的元素

min(lst1)    # 数组中元素均为数字类型时，获取列表中数值最小的元素

'a' in lst1    # 判断列表中是否包含某个元素，如果包含，返回值为True，否则为False

lst1.index(3)    # 查询元组中是否包含某个元素，如果包含，返回值为索引位置，否则抛出异常

lst3.count('我')    # 获取元组中某个元素的出现次数

新增元素    list.append( object )

合并序列    list.extend( list )

更改指定位置元素     list[ index ] = value

lst1[2:6]= 'a','n','m','x','r','t','u'      #更改指定位置区间的元素为新元素，数量无需对应,后面元素有几个改几个

插入元素 insert(index,object)函数，参数index为索引位置，表示在该位置之前插入新的元素；参数object为对象

删除指定索引元素 pop(index)     #如果不带index索引，那么就默认删除最后一个元素

删除指定元素 remove（object） 删除列表中首次出现的与参数相同的元素，如果列表中不存在与参数相同的元素则抛出异常

删除单个指定索引元素 del 列表[索引位置]

删除多个指定索引元素 del 列表[起始位置:终止位置]  #不包含终止位置

list02= ['a','b','c','d','e']               del list02[2]                del list02[1:3] 

清除所有的元素 clear() 或者 del list[ : ]            list02.clear()

列表排序 list.sort( )

反向排序：使用reverse()函数。

使用sort(cmp,key，reverse)函数，参数cmp为函数，参数key为函数，reverse为布尔值（True和False）。通过设置参数reverse=True，转换为降序排列

升降序排列也可以使用内置函数sorted(iterable,cmp，key，reverse)，参数iterable为可迭代对象；参数cmp为函数，参数key为函数，reverse为布尔值

列表推导式：

list01= [x*x  for x  in range(1,10) ]    # 列表推导式：循环获取范围1~10的整数，计算乘积后添加到新列表。

list02= [x*x  for x  in range(1,10)  if  x%2==0]     # 列表推导式：循环获取范围1~10的整数，符合条件时，计算乘积后添加到新列表。

#lambda表达式 lambda [参数] : 表达式

list03= [1,3,4,5,6,8,11]

list04= list(  filter( lambda x:x%2==0 , list03 ) )#将list03中的元素迭代放入lambda函数中，如果满足条件再执行下一步动作

5、集合 set

集合可以通过可迭代对象（字符串、元组、列表等）进行创建；集合中的元素不可重复；集合中的元素无序排列。

添加单个元素 add(element)函数 ；

添加多个元素：使用update(iterable)函数，参数iterable为可迭代对象

删除元素

使用remove(element)方法删除指定元素，参数element为需要删除的元素；

使用discard(element)方法删除指定元素，参数element为需要删除的元素

当集合中不存在这两个方法参数中填入的元素时，remove()方法会抛出异常，而discard()方法则没有任何影响

s1.pop()    #集合中移除的是集合中第一个元素

s1.clear()    清空集合 

集合的 交集/并集/补集/差集:

s1= set('Python')

s2= set('PyCharm')

# 交集操作：获取两个集合中共有元素。

print (s1& s2)# 显示输出结果为：{'y', 'P', 'h'}

print (s1.intersection(s2))# 显示输出结果为：{'y', 'P', 'h'}

# 并集操作：获取两个集合去除重复元素后的全部元素。

print (s1| s2)# 显示输出结果为：{'y', 'a', 'C', 'o', 'P', 'n', 't', 'm', 'r', 'h'}

print (s1.union(s2))# 显示输出结果为：{'y', 'a', 'C', 'o', 'P', 'n', 't', 'm', 'r', 'h'}

# 补集操作：获取当前集合去除与另一集合交集元素后的全部元素。

print (s1- s2)# 显示输出结果为：{'o', 't', 'n'}

print (s1.difference(s2))# 显示输出结果为：{'o', 't', 'n'}

print (s2- s1)# 显示输出结果为：{'m', 'a', 'r', 'C'}

print (s2.difference(s1))# 显示输出结果为：{'m', 'a', 'r', 'C'}

# 差集操作：获取两个集合去除交集元素后的全部元素。

print (s1^ s2)# 显示输出结果为：{'o', 't', 'm', 'a', 'r', 'n', 'C'}

print (s1.symmetric_difference(s2))# 显示输出结果为：{'o', 't', 'm', 'a', 'r', 'n', 'C'}

成员关系in/ not in

# isdisjoint(set)：可以判断集合是否与指定集合不存在交集，参数set为集合；如果成立返回结果为True，否则为False。

# issubset(set)：可以判断集合是否指定集合的子集，参数set为集合；如果成立返回结果为True，否则为False。

# issuperset(set)：可以判断集合是否指定集合的超集，参数set为集合；如果成立返回结果为True，否则为False。

复制集合 使用copy()方法能够对集合进行复制

5、字典

数据类型字典 dict --- 字典的键必须是不可变的数据类型，可以是数字、字符串或者元组。

d1= {}# 创建空字典

d2= dict()# 创建空字典

#dict(mapping, **kwarg)：参数mapping为映射函数。

d3= dict(测试='测试值',测试02='测试值02')# 通过可变参数创建字典

#dict(iterable, **kwarg)：参数iterable为可迭代对象

d5= dict([('测试','你好'), ('风景','好美')])# 通过可迭代对象（列表）创建字典

#fromkeys(seq,value)  --- value 表示每个键的默认值

l1= ['test01','test02']

d6= dict.fromkeys(l1,'defalutValue')

print(d6)

#遍历字段中的键值对

print(d6.items())#执行结果dict_items([('test01', 'defalutValue'), ('test02', 'defalutValue')])

#获取所有的键

print(d6.keys())

#获取所有的值

print(d6.values())

#获取根据键值指定的值dict['key']  dict.get('key')

d6['test01']= "testVlaue"

print(d6['test01'])#==>没有发现相对应的键值时候，回抛异常

print(d6.get('test04'),'noValue')#===当没有找到相应的键时候，返回第二个参数，默认值

#添加键值对

d6['addKey']= 'addValue'

print(d6)

#添加多个键值对  update(seq)  ==如果存在就更改，不存在新增

d6.update(updateAdd='001',updateAdd02='001',test02='chage')

print(d6)

# setdefault()  --->当字典中有该键值的时候，返回该键对应的值，没有该键的时候，添加，并设置为默认值（第二个参数）,返回 默认值

print(d6.setdefault('newKey','noThisKey,but add it'))

print(d6)

#删除元素del dict['key']

del d6['updateAdd']

print(d6)

# d.popitem()  --- 删除最后一个键值对

# d.pop(key,value)  --- 删除指定键值对，返回对应的值，字典中没有对应键的时候，返回默认值

# clear()：清空字典 copy()：复制字典； len()：获取字典元素数量 max()：获取字典中最大的键  min()：获取字典中最小的键

# 字典也支持通过in和not in进行成员关系的判断

d7= {'test1':'yes01','test002':2,'test03':'hello3'}

print(d7.pop('test007','defaoult'))

# — — — — — — — — — — — — — —

#循环 for in ; while