2018-06-11——pthyon类型整理

二、类型

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能，计算机需要明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的。因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。

type(name)//查看name的类型

int(x)//将x转换为int形

int(x,base=y)//转换为y进制

int.bit_length()     //查看int的二进制长度

str(x)//将x转换为str形x@zuhYJRX

list[str]//将str转换为list，内部使用的是for

列表转换字符串需要自己手动写for循环，但是如果列表里只有字符，可以直接使用str = “”.join(list) 完成转换

*整数(int)

在Python3里不再有long类型了，全都是int

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

定义变量时，如果value是数字且不加引号，就是整数形

*字符串(str)

可索引

在python中所有加了引号的都是字符串

字符串在创建后无法修改(运算)，如果修改(运算)在内存中其实是新建了一个字符串

可以使用加和乘运算，加就是拼接，乘就是复制多少次在拼接在一起。

name + name

name * int //可以乘数字也可以乘变量

 

str.capitalize()   //首字母大写

str.casefold()   // 变小写，对应关系多

str.center(x，“y”)   //设置宽度居中内容。一共x的总长度，str在中间，其 他默认是空格，使用y填充空白位置。。y只能是一个字符

str.count('x')     //x在str里出现了多少次   start|end 从第几个位置开始往后|往前找，也就是寻找范围

-str.decode //欠

str.expandtabs(x) //断句！x为int,以x为单位，将str分组，如果存在tab则填空格补齐x个

 -str.encode //欠

str.find('x')   //x在str中的第一次出现的位置，返回位数，未找到则返回-1，也可以选择查找范围同count，范围是>   <=，前开后闭

str.format(x='y')   //将str中的x(占位符)格式化为y(指定的值，可以是字符和数字)，x、y可以是多个。如果x是数字(从0开始)，则format('y1',y2....)按顺序替换，

str.format_map({"x":'y', ……})  //字典的方式，将str中的x替换为y 

str.index('x')  //同find，但是未找到则报错

str.isprintable() //查看str打印时是否都是真实的值而没有不可现 实的字符(如/t、/n)，返回bool

str.isspace() //查看str是否全部是空格(为空不算，要空格占位)

str.istitle() //查看str中所有单词的首字母是否大写

str.isalnum() //检查str中是否只有字母和数字，返回bool值

##原来是将str变成这个类型的方法，前面带上“is”，则是检查str是否是这个类型，返回bool

str.isalpha()  //查看str是否全部是字母或汉字，返回bool

str.isdigit()   //查看str是否全是数字，包含特殊字符的数字如②，返回bool

str.isnumeric() //查看str是否全是数字，包含中文(字符)的数字如二，返回bool

str.isdecimal()   //查看str是否全是数字，返回bool

str.isidentifier()  //查看str是否符合标识符规则，返回bool

str.islower() //判断str是否全是小写，返回bool

str.join(x) //将str插入到x的每个字符之间，str可以提前赋值，也可以直接打如“_*_”.join(test)

str.l(r)just(x，“y”)  //将str放在x长度的字符串左(右)边，已y填充空格

str.lower() // 将str转换成小写，对应关系少

str0.maketrans("x","y") //给x和y做一个对应关系，这个关系叫str0

str.(r)partition(‘x’) //匹配到str中的x(默认是从左边开始，加上r就是从右边开始)一次，在x的左右分割一次 ，也就是三份

str.replace('x','y',num)//将str中的x替换成y,num是替换次数，默认-1

str.(r)split('x',y)//匹配str中的x，匹配 y次进行分割，匹配到的x会被消除，默认y=-1也就是从右开始第一个，默认从左开始

str.splitlines(‘true’) //只分割str里的换行，默认false，true是保留换行

str.strip(lstrip strip)(‘x’)//去除str的(左右)x【x可以是字符串，会按方向去匹配，可能匹配到整个字符串，也可以是多个的任意个字符】，默认是空白，包括换行、tab 

##eg：test=xalex ；v = test.rstrip('96lexexdsxa') = 空白。都会匹配到

##经测试很乱这个类型，他是循环多次匹配，先最长，在最短，也就是如果你要过滤cat这个单词，可能c、a、t字母都会被过滤，而且还要考虑方向的顺序，不好控制

#eg：test=1+2；v1,v2 = test.split('+')。。。此时v1=1，v2=2

str.starts(ends)with('x') //判断str是否以x开头(结尾) 返回bool值

str.swapcase()// 将str的大小写互换 

 

str.title() //将str变为标题(首字母全部变为大写)你

str.translate(str0)//使用str0的关系，替换str的值

str.upper//将str转换成大写，对应关系少

***************************************

str[x]//x是数字，表示获取str里的第x个字符，从0开始

str[x:y]//获取str中x<=,<y位置的字符，当y为-1时，表示从右开始第一个，也就是只去掉最后一个字符，因为开区间。当x为-1时，会去掉所有的字符？？？？

 

*布尔(bool)

也就是ture和false，主要用于判断

*列表

可索引、循环，可存储不同的数据类型，如数字、字符、布尔、列表等

 

list = [‘x’,’y’]

或

list = list([‘x’,’y’])

列表中可以嵌套列表,可以通过索引、切片取值。可以多次索引取嵌套值

增：

         li = [1,'a','b',2,3,'a']

# li.insert(0,55) #按照索引去增加

# print(li)

#

# li.append('aaa') #增加到最后

# li.append([1,2,3]) #增加到最后

# print(li)

#

# li.extend(['q,a,w']) #迭代的去增

# li.extend(['q,a,w','aaa'])

# li.extend('a')

# li.extend('abc')

# li.extend('a,b,c')

# print(li)

删：

         # l1 = li.pop(1) #按照位置去删除，有返回值

# print(l1)

# del li[1:3] #按照索引位置去删除，也可切片删除没有返回值。

# print(li)

# li.remove('a') #按照指定元素去删除，默认从左开始，删除一次

# print(li)

# li.clear() #清空列表

改；

         # 改

# li = [1,'a','b',2,3,'a']

# li[1] = 'dfasdfas'

# print(li)

# li[1:3] = ['a','b']

# print(li)

查：切片去查，或者循环去查。

其他操作：

test=list.copy() //将list浅拷贝到test

count（数）（方法统计某个元素在列表中出现的次数）。

a = ["q","w","q","r","t","y"]

print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）/默认从左往右寻找一次，可以设定起始值

a = ["q","w","r","t","y"]

print(a.index("r"))

list.sort(key,reverse)//将list默认从小到大排序(reverse=false)

reverse （方法将列表中的元素反向存放）。

a = [2,1,3,4,5]

a.sort()# 他没有返回值，所以只能打印a

print(a)

a.reverse()#他也没有返回值，所以只能打印a

print(a)

*元祖

可索引、循环、切片

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。可以和字符串、列表直接互相转换

元祖中的一级元素不可被修改，不能增加或删除。二级及以下可以被修改、增加和删除

#一般元祖在最后一个元素加个逗号，与方法区分开。元祖长度和元素数量不会变化

tuple = (1,2,3)

tuple = tuple((1,2,3))

tuple.count(x)//查找tuple中x元素的数量

tuple.index(x)// 查找tuple中x的索引位置。默认从左往右寻找一次，可以设定起始值

*字典

无序的，不可切片，可索引、循环

Py中唯一的映射类型存储数据，即key-value形式

dict = {"k1":"v1","k2","v2"}  //k1、k2两个值，分别是v1和v2。

dict = dict({‘x’:’y’,’z’:5})

k不可以是列表、字典

v可以是任意类型

字典的增

# dic['li'] = ["a","b","c"]

# print(dic)

# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。

# dic.setdefault('k','v')

# print(dic)  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}

# dic.setdefault('k','v1')  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}

# print(dic)

字典的删(对于pop如果前面是两个变量，则会返回k和v两个值)

# dic_pop = dic.pop("a",'无key默认返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值

# print(dic_pop)

# del dic["name"]  # 没有返回值。

# print(dic)

# dic_pop1 = dic.popitem()  # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回

# print(dic_pop1)  # ('name','jin')

# dic_clear = dic.clear()  # 清空字典

# print(dic,dic_clear)  # {} None

改：

# dic = {"name":"jin","age":18,"sex":"male"}

# dic2 = {"name":"alex","weight":75}

# dic2.update(dic)  # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中

# print(dic2)

查：

# value1 = dic["name"]  # 索引的方式查找，没有会报错

# print(value1)

#

# value2 = dic.get("djffdsafg","默认返回值")  # 没有可以返回设定的返回值

# print(value2)

#dict.get("key"，vlaue) //根据key获取dict中的对应value，如果把不匹配则返回value，默认返回none

其他操作：

# item = dic.items()

# print(item,type(item))  # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>

# 这个类型就是dict_items类型，可迭代的

# keys = dic.keys()

# print(keys,type(keys))  # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>

# values = dic.values()

# print(values,type(values))  # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上

#dict.fromkeys(["key1",............],value)//根据key序列创建dict并赋予统一的value

字典的循环

# dic = {"name":"jin","age":18,"sex":"male"}

# for key in dic://只输出key

#     print(key)

#for item in dic.values()://只输出value
#   print(item)

# for item in dic.items()://以列表形式输出所有

#     print(item)

# for key,value in dic.items()://以字符形式输出所有

#     print(key,value)

*集合

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

去重，把一个列表变成集合，就自动去重了。

关系测试，测试两组数据之前的交集、差集、并集等关系。

创建集合：set1 = set({1,2,'barry'})或set2 = {1,2,'barry'}

s=frozenset()//定义不可变得集合

set.isdisjoint(x，x1。。。。。)//判断set和x是否有交集，返回bool。x可以是多个

set.issubset(x,x1.....)//判断set是否是x的子集？

set.issuperset(x,x1.....)//判断x是否是set的子集

set.update(x)//将set的值更新为x的值，x为可迭代的值4

         集合的增：set1 = {'alex','wusir','ritian','egon','barry'}

set1.add('景女神')

print(set1)

#update：迭代着增加

set1.update('A')

print(set1)

set1.update('老师')

print(set1)

set1.update([1,2,3])

print(set1)

集合的删：set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 删除一个元素，元素不存在则报错

set.discard()//删除x元素，x不存在时不报错

print(set1)

set1.pop()  # 随机删除一个元素

print(set1)

set1.clear()  # 清空集合

print(set1)

del set1  # 删除集合

print(set1)

集合的其他操作：

(set=set-x==)set.difference_update(x)//取set-x差集并更新set...其他几个计算也有update

交集。（&  或者 intersection）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 & set2)  # {4, 5}

print(set1.intersection(set2))  # {4, 5}

并集。（| 或者 union）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

差集。（- 或者 difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 - set2)  # {1, 2, 3}

print(set1.difference(set2))  # {1, 2, 3}

交叉补集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}

print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

                   子集与超集：set1 = {1,2,3}

set2 = {1,2,3,4,5,6}

print(set1 < set2)

print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)

print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。

frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')

print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

*深浅copy

赋值运算中，其实变量指向的都是相应的内存，也就是说会出现多个变量名指向一个地址的情况。

对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048

l1[1] = 222 //修改1，l2不变

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896

l1[3][0] = 'wusir'//修改3.0，l1和l2都改变

print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

import copy

l1 = [1,2,3,['barry','alex']]

l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'

print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240

print(l2,id(l2[3]))  # [1, 2, 3