基本数据类型:
一、数字
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值访问(映射类型) 字典