python的初级数据类型以及高级数据类型方法
python的初级数据类型以及高级数据类型
-
初级数据类型
- str --字符串型
- int --整数型
- long --长整数型
- int --整数型
- float -- 浮点型
- bool --布尔型
- True --真
- False --假
- str --字符串型
-
字符串
- 字符串的索引切片从左到右依次排序索引从0开始从6(-1)结束
s1 = 'python' p y t h o n 对于s1字符串而言，由6个字符串而言 0 1 2 3 -2 -1 print(s1(0)) print(s1(3)) print(s1(5))- 字符串的切片([索引：索引：步长])截取字符串的一段形成新的字符串(默认取头不取尾)
s1 = 'ABCDEFGHIJK' print(s1[:3]) #输出ABC print(s1[2:6]) #输出CDEF print(s1[:]) #默认全部输出 print(s1[:-1])#输出ABCDEFGHIJ无法输出K 默认切片取头不取尾 print(s1[:5:2]) #输出FHJ 隔一个取一个 print(s1[-1:-6:-2]) #输出KIG 反向输出并隔一个取一个-
字符串常用方法
- len #统计字符串的长度
s1 = 'ABCDEFGHIJK' print(len(s1)) ##11- conunt #列出字符串出现的次数
s1 = 'AABBBCCCCDEFGHIJK' print(s1.count('A')) ##计算A数据出现的次数 总共出现两次- index 查看字符串在索引的位置,重复数据默认指出首数据索引的位置
s1 = 'AABBBCCCCDEFGHIJK' print(s1.index('A')) ##A的索引位置0- 字符串判断
1.isspace 判断字符串只包含空格返回True
s1 = ' ' print(s1.isspace()) ##返回True- isalnum 如果变量至少有一个字符并且所有字符都是字母或者数字返回True
s1 = '123abcdefg' print(s1.isalnum()) ##返回True- isalpha 如果变量有一个字符并且所有字符都是字母返回True
s1 = 'abcdefg' print(s1.isalpha()) ##返回Tree- isdecimal 如果变量只包含十进制数字返回True (定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可)
s1 = u'123456' print(s1.isdecimal()) #返回True- isdigit() 如果变量只包含数字
s1 = '123456' print(s1.isdigit()) #返回True- isnumeric() 如果变量只包含数字，汉字数字返回True
s1= '123456' print(f1.isnumeric()) #返回True- istiale() 如果变量是标题话的首字母大写返回True
f1 = 'Ajoon' print(f1.istitle()) #返回True -
字符串的查找和替换
- startswith(str) #检查字符串是否以str开头，则返回Ture
f1 = "ABC" print(f1.startswith(A)) #返回True 2.endswith(str) #检查字符串是否以str结束，则返回Ture
f1 = "ABC" print(f1.endswith(C)) #返回True- replace(1,2) 将变量中1替换成2
f1 = 1 f1.replace(1,2) -
字符串的大小写转换
1. 变量.capitalize(子字符串) #将字符串的第一个字符大写。 2. 变量.title(子字符串) #把字符串的每个单词首字母大写。 3. 变量.lower(子字符串) #转换变量中所有大写字符为小写。 4. 变量.upper(子字符串) #转换变量中的小写字母为大写。 5. 变量.swapcase(子字符串) #翻转变量中的大小写。 -
字符串的文本对齐
1. 变量.ljust(width) #返回一个元字符串左对齐。 2. 变量.rjust(width) #返回一个元字符串右对齐。 3. 变量.center(width) #返回一个元字符串居中。 -
字符串去掉空白字符
1. 变量.lstrip() #去除变量左边(开始)的空白字符。 2. 变量.rstrip() #去除变量右边(开始)的空白字符。 3. 变量.strip() #去除变量左右两边的空白字符。 -
字符串的拆分和连接
1. 变量.split(子字符串)：以分割符拆分变量的数据， 默认以\t\n\r和空格split方法会将拆分结果返回一个列表， 默认以空格为分隔符。 2. 分隔符.join(接收split返回结果的变量)
-
列表list
Why: 我们现在已经学过的数据类型有：数字，布尔值，字符串，大家都知道数字主要用于计算，bool值主要是条件判断，只有字符串可以用于数据的存储，这些数据类型够用么？对于一门语言来说，肯定是不够用的。就说字符串：
1，字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。
2，字符串存储的数据类型太单一，只能是字符串类型。
例如：‘1 True alex’ 像这样的字符串，我如果通过切片或者其他方法将1 True alex 取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True，必须还要转化，是不是很麻烦。
所以python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。
What:这个数据类型就是list列表。
列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
-
列表的创建**
创建一个列表有三种方式： # 方式一：（常用） l1 = [1, 2, 'loser'] # 方式二：（不常用） l1 = list() # 空列表 l1 = list('123') print(l1) # ['1', '2', '3'] # 方式三：列表推导式 l1 = [i for i in range(1,5)] print(l1) # [1, 2, 3, 4]2.列表的索引切片
-
l1 = ['a', 'b', '金星', 3, 666]
print(l1[0]) # 'a'
print(l1[-1]) # 666
print(l1[1:3]) # ['b', '金星']
print(l1[:-1]) # ['a', 'b', '金星', 3]
print(l1[::2]) # ['a', '金星', 666]
print(l1[::-1]) # [666, 3, '金星', 'b', 'a']
-
列表的常用操作
-
增加
1.列表.insert(索引，数据) #在指定位置插入数据 2.列表.append #在末尾追加列表数据 3.列表.extend #再将其他列表迭代追加到列表中 -
修改列表元素的内容
列表[索引]=数据 #修改指定索引的数据
3.删除
1.del关键字同样可以删除列表中的元素。 del关键字的本质上是用来将一个变量从内存中删除 使用del关键字将变量从内存中删除，不能用该变量 2.del 列表[索引] #删除指定索引的数据 3.列表.pop[索引] #删除指定索引的数据 4列表.pop[] #删除索引末尾的数据 5.列表.clear #清除列表的数据4.列表数据统计
1.len(列表) #查看列表数据的总数 2.列表.conunt(数据) #查看列表数据出现的次数5.列表的排序
1.列表.sort() #升序排序列表中的数据 2.列表.sort(reverse=Ture) #降序排序 3.列表.reverse() #逆序 反转6.列表也可以相加与整数相乘
l1 = [1, 2, 3] l2 = [4, 5, 6] # print(l1+l2) # [1, 2, 3, 4, 5, 6] print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3] -
4.元组tuple：元组和列表类似，不同之处在于元组不能修改数据。
1.元组表示多个元素组成的序列。
2.元组再Python开发中有指定的应用场景。
-
python中元组有一个特性，元组中如果只含有一个元素且没有逗号，则该元组不是元组，与改元 素数据类型一致，如果有逗号，那么它是元组 。
tu = (1) print(tu,type(tu)) # 1 <class 'int'> tu1 = ('al') print(tu1,type(tu1)) # 'al' <class 'str'> tu2 = ([1, 2, 3]) print(tu2,type(tu2)) # [1, 2, 3] <class 'list'> tu = (1,) print(tu,type(tu)) # (1,) <class 'tuple'> tu1 = ('al',) print(tu1,type(tu1)) # ('al',) <class 'tuple'> tu2 = ([1, 2, 3],) print(tu2,type(tu2)) # ([1, 2, 3],) <class 'tuple'>
4.元组的操作方法
1.利用for循环遍历取值
tu1 = ('a', 'b', 3, 666)
for i in tu1:
print (i)
2.取值
元组.index #取索引当前的值
3.查看数据的次数
元组.conunt #查看数据出现的次数
4.元组的拆包
a,b = (77,99) #元组的分别赋值 需要一一对应
print (a) #77
print (b) #99
5.index：#通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
tu = (1,2,3,45,6,1,2,1)
print(tu.index(1)) #0
6.count:#获取某元素在列表中出现的次数
tu = (1,2,3,45,6,1,2,1)
print(tu.count(2))#2
-
字典{dictionary}:字典同样可以用来存储多个数据类型
-
Why:咱们目前已经学习到的容器型数据类型只有list，那么list够用？他有什么缺点呢？
-
列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
-
列表只能按照顺序存储，数据与数据之间关联性不强
-
-
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：
Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
Value:任意数据(int，str，bool，tuple，list，dict，set)
-
字典的查询速度非常快，简单解释一下原因：字典的键值对会存在一个散列表（稀疏数组）这样的空间中，每一个单位称作一个表元，表元里面记录着key：value,如果你想要找到这个key对应的值，先要对这个key进行hash获取一串数字咱们简称为门牌号（非内存地址），然后通过门牌号，确定表元，对比查询的key与被锁定的key是否相同，如果相同，将值返回，如果不同，报错。
1.创建字典的几种方式： # 方式1: dic = dict((('one', 1),('two', 2),('three', 3))) # dic = dict([('one', 1),('two', 2),('three', 3)]) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式2: dic = dict(one=1,two=2,three=3) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式3: dic = dict({'one': 1, 'two': 2, 'three': 3}) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式4:利用fromkey。 # dic = dict.fromkeys('abcd','太白') # print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'} fromkeys：#创建一个字典：字典的所有键来自一个可迭代对象，字典的值使用同一个值。 dic = dic.fromkeys('abcd','loser') print(dic) #{"a",loser,"b",loser."c",loser,"d",loser} dic = dict.fromkeys([1, 2, 3],'太') print(dic) # {1: '太', 2: '太', 3: '太'} #如果通过fromkeys得到的字典的值为可变的数据类型，如果改变值，值都会改变 dic = dict.fromkeys([1, 2, 3], []) dic[1].append(666) print(id(dic[1]),id(dic[2]),id(dic[3])) # {1: [666], 2: [666], 3: [666]} print(dic) # {1: [666], 2: [666], 3: [666]}2.字典增加方法 #增加 1.dic = {'name': '李白', 'age': 18} dic['weight'] = 75 print(dic) #没有此键增加 #################################### #修改 dic = {'name': '李白', 'age': 18,'weight':75} dic['weight'] = 65 print(dic) #有此键修改 ### 2.使用serdefault方法增加键 #增加 dic = {'name': '白', 'age': 18} dic.setdefault('height',175) # 没有height此键，则添加 ###################################### #不变 print(dic) # {'name': '白', 'age': 18, 'height': 175} dic.setdefault('name','barry') # 有此键则不变 print(dic) #setdefult有返回值需要一个变量接受 dic = {'name': '白', 'age': 18} ret = dic.setdefault('name') print(ret) # 白 ######################################3.字典删除操作 1.pop 通过key删除字典的键值对，有返回值，可设置返回值。 dic = {'name': '铨', 'age': 18} # ret = dic.pop('name') # print(ret,dic) # 铨 {'age': 18} ret1 = dic.pop('n',None) print(ret1,dic) # None {'name': '太白', 'age': 18} #popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值 dic = {'name': '太白', 'age': 18} ret = dic.popitem() print(ret,dic) # ('age', 18) {'name': '铨'} #clear 清空字典 dic = {'name': '铨', 'age': 18} dic.clear() print(dic) # {} #del通过键值对删除 dic = {'name': '铨', 'age': 18} del dic["name"] print(dic) #{'age': 18} #del从内存中删除字典 del dic4.字典改的方法 # 通过键值对直接改 dic = {'name': '铨', 'age': 18} dic['name'] = 'barry' print(dic) # {'name': 'barry', 'age': 18} #update dic = {'name': '铨', 'age': 18} dic.update(sex='男', height=175) print(dic)#{'name': '铨', 'age': 18,'sex;:'男', 'height':175} dic = {'name': '铨', 'age': 18} dic.update([('sex',男),(‘height，男)]) print(dic){'name': '铨', 'age': 18,'sex;:'男', 'height':175} dic1 = {"name":"jin","age":18,"sex":"male"} dic2 = {"name":"al","weight":75} dic1.update(dic2) print dic1 {"name":"al","age":18,"sex":"male","weight":75}5.字典查的操作： # 通过键查询 dic = {'name': '铨', 'age': 18} print(dic['name']) #铨 #使用get查询 #get() 函数返回指定键的值。 dict.get(key, default=None) #key -- 字典中要查找的键。 #default -- 如果指定键的值不存在时，返回该默认值。 dic = {'name': '铨', 'age': 18} v = dic.get('name') print(v) # '铨' v = dic.get('name1') print(v) # None v = dic.get('name2','没有此键') print(v) # 没有此键 #使用key，values以及itemas #keys() 方法用于返回字典中的所有键； #values() 方法用于返回字典中所有键对应的值； #items() 用于返回字典中所有的键值对。 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。 keys() dic = {'name': '铨', 'age': 18} print(dic.keys()) # dict_keys(['name', 'age']) values() dic = {'name': '铨', 'age': 18} print(dic.values()) # dict_values(['太白', 18]) items() dic = {'name': '铨', 'age': 18} print(dic.items()) # dict_items([('name', '铨'), ('age', 18)])集合：set #集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点： #去重，把一个列表变成集合，就自动去重了。 #关系测试，测试两组数据之前的交集、差集、并集等关系 1.集合去重：列表转换集合有新的列表返回，所以需要一个变量进行接收 lis = [1,2,3,4,6,6,8,9,9,0,1,2,3] a = set(lis) print a 2.集合的创建。 set1 = set({1,2,'barry'}) set2 = {1,2,'barry'} print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'} 3.集合的增。 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) 4.删除集合 set1 = {'alex','wusir','ritian','egon','barry'} set1.remove('alex') # 删除一个元素 print(set1) set1.pop() # 随机删除一个元素 print(set1) set1.clear() # 清空集合 print(set1) del set1 # 删除集合 print(set1) 2.集合的其他操作： 1.交集(&或者intersection) set1 = {1,2,3,4,5} set2 = {3,4,5,6,7} print (set1 & set2) #{3,4,5} 2.并集 （| 或者 union） set1 = {1,2,3,4,5} set2 = {3,4,5,6,7} print(set1 | set2) #{1,2,3,4,5,6,7} 3差集 （- 或者 difference） set1 = {1,2,3,4,5} set2 = {3,4,5,6,7} print(set1 - set2) #{1,2,5,6,7} 4反交集。 set1 = {1,2,3,4,5} set2 = {3,4,5,6,7} print(set1 ^ set2) #{1,2,6,7} -
浙公网安备 33010602011771号