基本数据类型：
一、数字
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
将字符串转化为数字
a = '123'
b = int(a)
print (b)
>>>123
以进制方式进行转换
num = "a"
print(int (num,base = 16)) #转换为16进制
>>>10
bit_length当前是数字的二进制位数
>>>age = 3
>>>age.bit_length()
>>>2
ps 在python3中 不管数字多大 都是int类型
二、 字符串
七个重要的
join split find strip upper lower replace
1、capitalize 将字符串首字母大写
>>>test = 'zhangsan'
>>>test.capitalize()
Zhangsan
2、（重要）casefold , lower 大写变成小写 casefold对于很多未知的大小写对应关系也适用
>>>test = 'ZHANGSAN'
>>>test.casefold()
zhangsan
>>>test.lower(0
zhangsan
3、center 返回一个字符串居中，并使用空格填充至长度width的新字符串，默认填充字符为空格。
>>>test = 'zhangsan'
>>>test.center(20)
' zhangsan '
>>>test.center(20,'*')
******zhangsan******
4、count计算子序列在字符串中出现的次数，可以加数字 代表从第几位开始计算
>>>test = 'zhangsan'
>>>test.count('n')
2
>>>test.count('n',3) 包含第三位的字符
2
>>>test.count('n',4)
1
5、endswith 判断是否以指定的字符串结束 startswith 判断是否以指定的字符串开始
>>>test = 'zhangsan'
>>>test.endswith('an')
Ture
>>>test.startswith('zh')
Ture
6、（重要）find 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
>>>test = 'zhangsanhenshuai'
>>>test.find('n')
3
>>>test.find('n',4)从第四位开始向后遍历 寻找‘n’字符并返回其索引值
7
>>>test.find('n',1,2) 起始搜索索引为1 结束索引为2
-1
7、format 字符串格式化 将字符串中的占位符 替换为指定的值
>>>test = 'I am {name}'
>>>test.format(name='zhangsan')
I am zhangsan
>>> test = 'i am {0},age = {1}'
>>>test.format('zhangsan',17)
i am zhangsan,age = 17
>>>test = 'i am {name}, age is {age}'
>>>test.format(**{'name':zhangsan,'age':17})
i am zhangsan,age is 17
8、format_map以字典方式格式化
>>>test = 'i am {name}, age is {age}'
>>>test.format_map({"name":"zhangsan","age":17})
i am zhangsan, age is 17
9、index 功能与find类似 不同之处是未找到指定字符或指定字符串 会报错
10、isalnum 判断字符串是否只是包含字母和数字
>>>'sduah'.isalnum()
True
>>>'dsad_jhuh'.isalnum()
False
11、expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
test = "username\tmail\tpassword\nlaiying\t[email protected]\t123\nlaiying\t[email protected]\t123\nlaiying\t[email protected]\t123" v = test.expandtabs(20) print(v)
说明 ： 以20个单位分割 username占8个 往后延伸12个单位 再以20为单位分割 以此类推。
12、isalpha 判断是否是否是字母。如果全是字母返回True，如果存在其他字符和数字则返回False
test = "suuehgf"
v1 = test.isalpha()
print(v1)
True
13、isdecimal 和 isdigit 判断是否为数字
test = "123456"
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1,v2)
True True
14、islower 判断是否全是小写
test = “zhangsan”
v1 = test.islower()
print(v1)
True
15、isnumeric 与isdecimal 和 isdigit一样是判断是否是数字 。 不同之处是支持判断中文数字
test = "二"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)
False False True
16、isprintable 判断是否存在不可显示的字符 如果全字符不包含\t \n等 则返回True 否则返回False
17、isidentifier 判断是否是合法的标识符，如果是数字字母下划线但是不能以数字开头的字符串即为True否则为False。
18、isspace 判断是否为空格 如果全是空格或为空 则返回True 否则返回False
19、istitle判断是否为标题 ，全部首字母为大写就认为是标题，不支持中文。
test = “I Love You”
v = test.istitle()
print(v)
True
20、join（重要）将字符串中的每一个元素按照指定分隔符进行拼接，join在内部循环字符串一个个拿到 然后拼接上指定的分隔符
test = "我爱天安门"
t = "*"
v = t.join(test)
print(v)
我*爱*天*安*门
21、ljust 和 rjust使用指定字符填充。
test = "zhangsan"
v1 = test.ljust(20,"*")
print(v1)
zhangsan************ 原字符在符号左边
v2 = test.rjust(20,"*")
print(v2)
************zhangsan 原字符在符号右边
22、（ lstrip rstrip ）strip （重要）移除字符串头尾指定的字符串（默认空格）
test = “*****this is string example....wow!!!*****”
v1 = test.strip("*")
v2 = test.rstrip("*") 移除右边的字符串（默认空格）
v3 = test.lstrip("*")移除左边的字符串（默认空格）
print(v1)
this is string example....wow!!!
print(v2)
this is string example....wow!!!*****
print(v3)
*****this is string example....wow!!!
23、maketrans按照对应关系进行替换
v = "wo ai ni"
m = str.maketrans("aeiou","12345")
new_v = v.translate(m)
print(new_v)
w4 13 n3
24、partition，rpartition使用指定的字符串分割成三份 形成元组（只能分成3份）
test = "testasdesdw"
v1 = test.partition('s')
v2 = test.rpartition('s') 从右往左分
print(v1)
('te', 's', 'tasdesdw')
print(v2)
('testasde', 's', 'dw')
25、（重要）split使用指定字符或者字符串分割字符串形成列表，但是不包括字符本身，可以添加分割次数
test = "testasdesdwsdw"
v1 = test.partition('s')
v2 = test.rpartiton('s')
v3 = test.split('s')
print(v1,v2,v3)
('te', 's', 'tasdesdwsdws')
('testasdesdwsdw', 's', '')
['te', 'ta', 'de', 'dw', 'dw', '']
26、splitlines使用换行符切分割，加参数True转换的结果包含换行符，加False不包含
test = "testasdsddfg\nasjdg\nakjshd"
v = test.splitlines()
print(v)
['testasdsddfg', 'asjdg', 'akjshd']
v1 = test.splitlines(True)
print(v1)
['testasdsddfg\n', 'asjdg\n', 'akjshd']
27、swapcase大小写互换
test = "I Love You"
v = test.swapcase()
print(v)
i lOVE yOU
28、title把一串字符串转换为标题 ，及首字母大写
test = “who are u”
v = test.title()
print(v)
Who Are You
29、(重要)replace把指定字符串替换成指定字符串
test = "abcd"
v = test.replace("a","123")
print(v)
123bcd
30、upper方法将字符串中的小写字母转为大写字母。
test = “dsad”
v = test.upper()
print(v)
DSAD
len读取字符串、列表的长度
range生成一段顺序数字 python3中循环的shi'hou'jian'li
>>>range（100）
range(0,100)
字符串 一旦创建，在内存中就无法修改，如果修改或者拼接则会开辟新的内存空间重新生成字符串。
name="zhangsan"
age = "17"
info = name + age
print(info)
print(id(name),id(age),id(info))
2107320346416 2107320335136 2107320369264
三、 列表
[1,2,3,'sdas','sdad',[1,2,3]]
#中括号括起来以 ，号分割
#列表的元素可以是数字、字符串、列表等
#可以使用索引取值，切片取值为列表
#列表不用于字符串，列表是可以被修改的，在内存里是连续的，属可变类型
1、修改列表
li = [1,2,3,'sdas','sdad',[1,2,3]]
li[0] = 3
print(li)
[3, 2, 3, 'sdas', 'sdad', [1, 2, 3]]
li[1:3]=[120,90] 修改多个 (修改索引 1到3的元素)
print(li)
[3, 120, 90, 'sdas', 'sdad', [1, 2, 3]]
2、删除
del li[1]
print(li)
[1, 3, 'sdas', 'sdad', [1, 2, 3]]
3、list 把字符串转换成列表，迭代字符串 将每一个字符转换成列表的元素
s = 'asdwdfefasd'
new_li = list(s)
print(new_li)
['a', 's', 'd', 'w', 'd', 'f', 'e', 'f', 'a', 's', 'd']
使用for循环将列表转换为字符串
li = [11,22,33,'123','zhangsan']
s=""
for item in li:
s = s + str(item)
print(s)
112233123zhangsan
如果列表中没有数字的话 可以使用join来拼接list元素
li = ['11','22','33','123','zhangsan'] print( ''.join(li)) 112233123zhangsan
4、append 在列表尾部添加一个元素，
li = ['sdas','zhangsan']
li.append('sdawed')
print(li)
sdaszhangsansdawed
5、clear 清空列表
li = ['sdas','zhangsan'] li.clear() print(li) []
6、copy 浅拷贝
li = [1,2,3]
v = li.copy()
print(v)
[1,2,3]
在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。
浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制
深拷贝：外围和内部元素都进行了拷贝对象本身，而不是引用。也就是，把对象复制一遍，并且该对象中引用的其他对象我也复制。
1，深浅拷贝都是对源对象的复制，占用不同的内存空间。
2，不可变类型的对象，对于深浅拷贝毫无影响，最终的地址值和值都是相等的。
3，可变类型：
=浅拷贝： 值相等，地址相等
copy浅拷贝：值相等，地址不相等
deepcopy深拷贝：值相等，地址不相等
7、count计算里面包含元素的个数，2出现了1次
li = [1,2,3]
v = li.count(2)
print(v)
1
8、extend 可叠加追加（对象可以是字符串、列表、元组等所有可迭代的对象）
li = [1,2,3,4]
li.extand([5,6])
print(lii)
[1,2,3,4,5,6]
9、index查找索引位置（从左优先）
li = [11,22,33,44,55]
v = li.index(22)
print(v)
1
10、insert 在指定索引位置插入元素
li = [11,22,33,44,55]
li.insert(0,99)
print(li)
[99,11,22,33,44,55]
11、pop 删除元素，不加参数默认删除最后一个，返回值为删除的值，加参数代表删除某一个索引。
li = [99,11,22,33,44,55]
v = li.pop() 不加参数默认删除最后一个
print（v,li）
55 [99,11,22,33,44]
li = [99,11,22,33,44,55]
v1 = li.pop(1)删除索引为1 的元素
print(v1,li)
11 [99,22,33,44,55]
12 、remove 根据value删除（从左优先） 没有返回值
li = [99,11,22,33,44,55]
v = li.remove(33)
print(li,v)
[99,11,22,44,55] None
13、reverse 反转list
li = [99,11,22,33,44,55]
v = li.reverse()
print(li,v)
[55, 44, 33, 22, 11, 99] None
14、sort排序
li = [11,33,55,22,22,44]
v = li.sort() 括号中加参数True 按从大到小排列
print(li,v)
[11, 22, 22, 33, 44, 55] None
PS 列表是有序的 可以被修改的
四、元组
#对应的类是tuple
#是对列表的加工
#元素不可被修改，增加，删除
#一般在定义元组时 在最后一个元素后面加 ，号
#元组同列表一样可以通过索引及切片取元素，也可以通过for循环迭代元素
1、字符串、列表转换为元组
s = 'asdasd'
li = ['asdf',123]
v = tuple(s)
v1 = tuple(li)
print(v)
print(v1)
('a', 's', 'd', 'a', 's', 'd')
('asdf', 123)
2、元组转换为列表
tu = ("suhduw","duiq",)
li = list(tu)
print(li)
['suhduw', 'duiq']
3、元组里如果没有数字，可以使用join方法转换成字符串，如果有数字 测通过for循环方法转换成字符串
没有数字的时候
tu = ("suhduw","duiq",)
v = "".join(tu) print(v) suhduwduiq
for循环
tu = (1,2,3,"sdasd","sada",)
s=""
for item in tu:
s = s + str(item)
print(s)
123sdasdsada
4、元组元素不能修改，但是元素里面如果包含可修改的元素则可以修改
tu = ("asdf","12",[1,2])
tu[2][0] = 34
print(tu)
('asdf', '12', [34, 2])
5、元组因为不能修改， 方法比列表少，count统计包含元素个数 index获取索引位置
五、字典
#创建一个字典对象
info = {'k1':'v1','k2':'v2'}
#k1 和 v1组成一个键值对，key对应value。字典的value可以是任何值
#key可以是字符串、数字、元组并且通过一个字典中key值是唯一的
#布尔值True和False也可以作为key但是如果有其他key的值为1则会重复
#字典是无序的，获取元素的方法是通过key ，不是像list和tuple那样通过有序的数字索引，因为是无序的所以不能通过切片方式取元素。
1、删除del
dic = {
"p1":"zhangsan",
"p2":"lisi"
}
del dic["p2"]
print(dic)
{'p1': 'zhangsan'}
2、字典是可以for循环的 默认是循环所有的key。
如果需要循环value 则可以通过for item in item.values()
需要循环key和value则是info.items()
dic = {
"p1":"zhangsan",
"p2":"lisi"
}
for item in dic:
print(item)
p1
p2
3、清楚 clear
4、copy复制，浅复制
5、fromkeys格式化生成字典，每一个元素迭代为key，并且指定为同一个value
dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
{'k1': 123, 'k2': 123, 'k3': 123}
6、get取的key，存在则返回对应的value，不存在则返回指定返回值，默认是None
dic = {
"p1":"zhangsan",
"p2":"lisi"
}
print(dic.get('p1'))
zhangsan
7、pop根据key删除， 返回为删除的value ，
dic = {
"k1":"v1"
}
v = dic.pop('k1')
print (v,dic)
v1 {}
8、popitem随机删除一个键值对，返回值为删除的键值对组成的元组
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.popitem()
print(v)
('k2', 'v2')
9、 setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.setdefault('k1',123)
print (dic,v)
{'k2': 'v2', 'k1': 'v1'} v1
10、update 更新，已经存在的更新，不存在的新建键值对
dic = {
"k1":"v1",
"k2":"v2"
}
dic.update({"k1":"123","k3":"v3"})
print(dic)
{'k1': '123', 'k2': 'v2', 'k3': 'v3'}
11、字典里用的最多的是 keys，values，items，update
数据类型总结：
按存储空间的占用分（从低到高）：
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
标量／原子类型 数字，字符串
容器类型 列表，元组，字典
按可变不可变区分
可变 列表，字典
不可变 数字，字符串，元组
按访问顺序区分
直接访问 数字
顺序访问（序列类型） 字符串，列表，元组
key值访问（映射类型） 字典