二、类型
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能，计算机需要明确的告诉它，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\rstrip)(‘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
