python中的基本数据类型

基本数据类型:

(1)数字(int): 整形，浮点

 整数类型定义的时候变量名后面直接跟数字，数字类型是不可变数据类型

>>> age = 20
>>> type(age)
<class 'int'>
>>>

 

数字类型的基本操作

#数字的操作类型主要在程序中起到一个判断作用
num1=b'4' #bytes
num2=u'4' #Unicode  #python3中不用管，可以忽略
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt
#作用就是判断是否是数字，一般就用isdigt就搞定了
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode #bytes类型无isdecimal方法

print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法

print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True
View Code

数字类型操作

(2)字符串（str）:

定义字符串的时候需要用引号引起来,可以用单，双，三引号，三引号多表示多行字符串，这样就可以省掉“\n”换行符换行。

 

>>> name = "alex"
>>> type(name)
<class 'str'>
>>>

 

 

 

 字符串的基本操作主要有：copy，拼接，查找，统计，检测，切片，大小写等。这里需要注意字符串是不可变类型，上述操作并没有改变原来的字符串，只是创建了一个新的字符串，原来的字符串任然在内存中！

1，copy 复制

1 a = "alex"
2 b = a
3 print(a,b)
4 alex alex

2，拼接

1 a = "alex"
2 b = "egon"
3 print(a + b)
4 #alexegon

这里也可以用join来实现字符串的拼接效果，可以指定连接符号如（？， —，*) 之类的，当然也可以是空格!

1 a = "alex"
2 b = "egon"
3 print(a.join(b))
4 #ealexgalexoalexn

3,查找，获取对象的下标

这里的查找是按照下标索引进行的，用到index

 

>>> a = 'alex'
>>> a.index('l')
1
>>> a.index('a')#返回值是0，下标是从0开始的
0
>>> a.index('A')#找不到会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>

 

4，统计 这里用到count

>>> name = 'alex'
>>> name.count('l')#统计name中l的个数
1
>>>

5,切片 这里是按照索引来切的，切片就是取一个范围

>>> word = "keep doing"
>>> word[6:10]#注意使用中括号来做取值范围，顾头不顾尾，不包含10
'oing'
>>> word[5:9]
'doin'
>>>

6，检测 

 1 >>> name = "alex"#检测’l‘有没有在name里面，返回布尔值
 2 >>> "l"in name
 3 True
 4 >>> num = "12345678"
 5 >>> num.isdigit()#检测“num”是不是由整形数字组成，浮点数都不行
 6 True
 7 >>> name.isidentifier()#检测name是否可以被用来做变量名
 8 True
 9 >>> name.find("l")#检测能否从name中找到“l”,找到返回1，找不到返回-1这点和index是 有区别的
10 1
11 >>> name.find('N')
12 -1
13 >>> name.index('N')#找不到报错
14 Traceback (most recent call last):
15   File "<stdin>", line 1, in <module>
16 ValueError: substring not found
17 >>> name.index("l")
18 1
19 >>>

7，大小写

 1 >>> name = "I am alex"
 2 >>> name.swapcase()#大小写互换
 3 'i AM ALEX'
 4 >>> name.capitalize()#首字母大写，其它都小写
 5 'I am alex'
 6 >>> name.upper()#全部大写
 7 'I AM ALEX'
 8 >>> name.lower()#全部小写
 9 'i am alex'
10 >>>

8，移除空格“strip”，替换“replace”，分割“split，format格式化输出的三种玩法

 1 >>> name = "     alex"
 2 >>> print(name.strip())
 3 alex
 4 #replace 替换
 5 >>> name='alex say :i have one tesla,my name is alex'
 6 >>> name.replace("alex","SB",1)#替换第一个就写1
 7 'SB say :i have one tesla,my name is alex'
 8 >>>
 9 #split分割
10 >>> name = "a*b*c*gh*kjk*"
11 >>> name.split('*')#以*为分割符号
12 ['a', 'b', 'c', 'gh', 'kjk', '']
13 >>> name = "h*b*c*gh*gj*hkjhj"
14 >>> name.split('*')
15 ['h', 'b', 'c', 'gh', 'gj', 'hkjhj']
16 >>>
17 
18 #format的三种玩法
19 >>> res = '{},{},{}'.format("egon",18,"male")
20 >>> print(res)
21 egon,18,male
22 >>> res = "{1},{0},{1}".format("egon",18,"male")#中括号里面是索引
23 >>> print(res)
24 18,egon,18
25 >>> res = "{0}{1}{2}".format("egon",18,"male")
26 >>> print(res)
27 egon18male
28 >>> res = "{name} {age} {sex}".format(sex="male",name = "egon",age=18)
29 >>> print(res)
30 egon 18 male

 

字符串还有很多操作方法，不详细举例了，见一下代码。还有更多 的用法可以直接help（str）

1 str.startswith(prefix[,start[,end]]) #是否以prefix开头 
2 str.endswith(suffix[,start[,end]]) #以suffix结尾 
3 str.isalnum()    #是否全是字母和数字，并至少有一个字符 
4 str.isalpha()    #是否全是字母，并至少有一个字符 
5 str.isdigit()    #是否全是数字，并至少有一个字符 
6 str.isspace()    #是否全是空白字符，并至少有一个字符 
7 str.islower()    #S中的字母是否全是小写 
8 str.isupper()    #S中的字母是否便是大写 
9 str.istitle()    #S是否是首字母大写的

#以上返回时布尔值True



str.ljust(width,[fillchar])     #输出width个字符，str左对齐，不足部分用fillchar填充，默认的为空格。
 
str.rjust(width,[fillchar]) #右对齐 

str.center(width, [fillchar]) #中间对齐 

str.zfill(width) #把str变成width长，并在右对齐，不足部分用0补足

str.replace(oldstr, newstr, [count])    #把str中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换 

str.strip([chars])    #把str中前后chars中有的字符全部去掉，可以理解为把str前后chars替换为None 

str.lstrip([chars])    #把str前面的去掉

str.rstrip([chars])    #把str后面的去掉

str.expandtabs([tabsize])    #把str中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个

str.split([sep, [maxsplit]])    #以sep为分隔符，把str分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 


str.splitlines([keepends])   #把str按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
str.maketrans(from, to)    #返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。 

str.translate(table[,deletechars])   # 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果str为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
View Code

（三），列表：

 列表是常见的数据类型，用中括号[]定义，可以存多个任意类似的值，列表和字符串一样都是有序排列的，可以用切片和索引的方式访问数据，并且列表是可变数据类型。

创建一个列表

info= ["name",''age","hobbies","sex",1,2,3,"height"]本质上就是info = list(["name",''age","hobbies","sex",1,2,3,"height"])

字符串可以转换成列表，list在把字符串转换成列表的时候，会把字符串用for循环迭代一下，然后将字符串的每一个值当做list的元素。

>>> name = "alex"
>>> li = list(name)
>>> li
['a', 'l', 'e', 'x']
>>>

列表的基本操作有：索引（访问），切片，扩展，删除，追加，统计，长度，获取下标等。

1，访问，根据索引

 1 >>> info= ["name","age","hobbies","sex",1,2,3,"height"]
 2 >>> info[0]#访问列表中第一个元素
 3 'name'
 4 >>> info[1]#访问列表中第二个元素
 5 'age'
 6 >>> info[-1]#访问列表中最后一个元素
 7 'height'
 8 >>> info[-2]#访问列表中倒数第二个元素
 9 3

2，切片

 

>>> info= ["name","age","hobbies","sex",1,2,3,"height"]
>>> info[1:3]#取1到3之间的值，包括1不包括3，顾头不顾尾
['age', 'hobbies']
>>> info[1:-1]#取1到最后一个之间的值
['age', 'hobbies', 'sex', 1, 2, 3]
>>> info[0:3]#取第一个到第三个之间的值
['name', 'age', 'hobbies']
>>> info[:3]#效果同上，0可以省略掉
['name', 'age', 'hobbies']
>>> info[3:]#取3到最后的值
['sex', 1, 2, 3, 'height']
>>> info[1:8:2]#每隔2步取一个值，取1到8之间的值，这里的2是步长，当然也可以用3做步长，默认步长是1
['age', 'sex', 2, 'height']
>>>

 

3，追加，插入，扩展

>>> info= ["name","age","hobbies","sex",1,2,3,"height"]
>>> info.append("girls")#append添加默认是末尾位置
>>> info
['name', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls']
>>> info.insert(1,"apple")#insert可以根据索引在指定位置添加
>>> info
['name', 'apple', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls']
>>> x =["lenovo","apple","mac"]
>>> info.extend(x)#extend用于在列表末尾一次性追加另一个序列中的多个值
>>> info
['name', 'apple', 'age', 'hobbies', 'sex', 1, 2,3, 'height', 'girls', 'lenovo', 'apple', 'mac']
>>>

4，修改

>>> x =["lenovo","apple","mac"]
>>> x[0]="HUAWEI"#通过下标直接修改
>>> x
['HUAWEI', 'apple', 'mac']
>>>

5，删除

>>> x =["lenovo","apple","mac"]
>>> del x[1]#根据下标删除
>>> x
['lenovo', 'mac']
>>> x.remove("mac")#指定元素删除
>>> x
['lenovo']
>>> x =["lenovo","apple","mac"]
>>> x.pop()#删除最后一个元素
'mac'
>>> x =["lenovo","apple","mac"]
>>> x.pop(0)#根据下标删除，有返回值
'lenovo'
>>> x =["lenovo","apple","mac"]
>>> x.clear()#清除所有
>>> x
[]

6，统计     个数（count），长度（len）

>>> x =["lenovo","apple","mac","lenovo","boys","girls"]
>>> x.count("lenovo")#统计列表中“lenovo”的个数
2
>>> x =["lenovo","apple","mac","lenovo","boys","girls"]
>>> len(x)#统计列表中元素的总长度（总个数）
6

7，排序&翻转

>>> x =["lenovo","apple","mac","lenovo","boys","girls",23,"Alex","HUWEI"]
>>> x[-3]="23"#不是同类型不能排序，转换成str类型
>>> x.sort()#排序顺序数字>大写>小写
>>> x
['23', 'Alex', 'apple', 'boys', 'girls', 'lenovo', 'lenovo', 'mac']
>>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"]
>>> x.reverse()#翻转
>>> x
['Alex', '23', 'girls', 'boys', 'lenovo', 'mac', 'apple', 'lenovo']

8. 获取下标

>>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"]
>>> x.index("lenovo")#只返回第一个元素的下标
0
>>>

还有成员运算in ，not in和字符串是一样的方法

（四）字典

字典是一种映射型的数据类型，每个元素成对出现，即key- value,每对元素key 和  value“：”冒号分开，元素之间用逗号隔开，整个字典包括子在{}中。

字典中的“key”必须是不可变类型，“value”则可以是任意类型，如果出现一个“key”被多个“value”赋值，那么值为最后一个被赋的值，字典是可变数据类型，并且是无序的。所有不可变的数据类型都可以作为字典中的key,例如数字，字符串，元祖。字典的基本操作包括 创建，增加，删除，修改，查找，遍历，更新，in  or  not in 等。

1，创建

#用fromkeys创建一个字典
>>> dic = ["name","age","sex"]
>>> dict = dict.fromkeys(dic)#以序列dic中元素做字典的键，value为字典所有键对应的初始值
>>> dic
['name', 'age', 'sex']#value对应值为None,不显示
>>> dict = dict.fromkeys(dic,"123")#设置默认值value为“123”
>>> dict
{'name': '123', 'age': '123', 'sex': '123'}
>>>

2,增加，删除，修改，查找

 1 >>> info = {"name":"egon","age":18}
 2 >>> info["sex"]="male"#直接添加
 3 >>> info
 4 {'name': 'egon', 'age': 18, 'sex': 'male'}
 5 
 6 
 7 #这里的setdefault 如果key存在，返回已存在的值不修改，如不存在则创建,也可算作一种添加的方法吧
 8 >>> info.setdefault("hobby","girls")
 9 'girls'
10 >>> info
11 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
12 >>>info = {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
13 >>> info.setdefault("age",20)
14 18
15 >>> info
16 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
17 >>>
18 
19 
20 
21 #指定删除pop(),返回对应的值，并把这个值从字典中移除。
22 >>> info={'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
23 >>> info.pop("hobby")
24 'girls'
25 >>> info
26 {'name': 'egon', 'age': 18, 'sex': 'male'}
27 >>>>>> info.popitem()#删除任意键值对，因为字典是无序的。
28 ('sex', 'male')
29 >>> info
30 {'name': 'egon', 'age': 18}
31 >>> info.popitem()
32 ('age', 18)
33 >>> info
34 {'name': 'egon'}
35 >>>
36 
37 
38 
39 #修改，直接修改
40 >>> info = {"name":"egon","age":18}
41 >>> info["age"]=20
42 >>> info
43 {'name': 'egon', 'age': 20}
44 >>>
45 
46 
47 
48 #查找
49 >>> info={'name': 'egon', 'age': 20}
50 >>> "name"in info#成员运算符判断，返回布尔值
51 True
52 >>> info.get("name")#get查找字典中的key,key不存在返回默认值“None”
53 'egon'
54 >>> info["name"]#直接查找，根据“key”
55 'egon'
56 >>>

3,遍历(循环输出）

dic = {"name":"alex","age":18,"sex":"male"}
for key in dic.keys():
    print(key,end=" ")
#  name age sex
for value in dic.values():
    print(value,end=" ")
#  alex 18 male
for item in dic.items():
    print(item,end=" ")
#('name', 'alex') ('age', 18) ('sex', 'male')

 

4，更多

>>> info = {"name":"egon","age":18,"sex":"male"}
>>> info.keys()#循环取key
dict_keys(['name', 'age', 'sex'])
>>> info.values()#循环取value
dict_values(['egon', 18, 'male'])
>>> info.items()#循环取键值对
dict_items([('name', 'egon'), ('age', 18), ('sex', 'male')])
 len(dict)        #计算字典元素个数
 str(dict)        #输出字典可打印的字符串表示，数据类型会发生改变
 dict.clear()     # 清空词典所有条目
>>> info = {"name":"alex"}#将字典info中的键值更新到dic
>>> dic = {"age":18}
>>> info.update(dic)
>>> info
{'name': 'alex', 'age': 18}
>>>

（五），元祖

元祖和字符串一样都是不可修改的，用（）小括号括起来，元素使用逗号隔开。注意当元祖中只有一个元素的时候，要加上逗号，不然就变成字符串了。

元祖的基本操作方法有 统计，查找，嵌套修改，切片，in ，not in，

1，统计

>>> tuple = ("alex","egon","hello","apple","alex","alex")
>>> tuple.count("alex")#统计元素“alex”的个数
3
>>> len(tuple)#统计元素个数
6
>>>

2，查找

>>> tuple = ("alex","egon","hello","apple","alex","alex")
>>> tuple.index("alex")#查找元素在元祖中的位置，多个重复元素只返回第一个的位置
0
>>> tuple[1]#根据索引查找元素
'egon'
>>>

3,嵌套修改

#列表的元素是不可以更改的，但元素的元素就有可能是可以更改的

>>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}])
>>> tuple[4].append(0)
>>> tuple
('alex', 'egon', 'hello', 'apple', ['world', {'name': 'lesheng'}, 0])
>>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}])
>>> tuple[4][1]["name"]="egon"
>>> tuple
('alex', 'egon', 'hello', 'apple', ['world', {'name': 'egon'}])
>>>

（六）集合

集合是一个无序，不重复，每个元素必须是不可变类型的数据组合，主要作用有去重和关系运算。

a = b |  c#求合集 ， union等同|
a = b & c#求交集  ， intersection等同&
a = b - c#求差集   ， difference等同-
a = b^ c#求对称差集 symmetric_difference(求对称差集)

基本操作

s.add('x')            # 添加一项  
s.update([10,37,42])  # 在s中添加多项   
s.remove(1)      #删除一项
len(s)      #set 的长度   
x in s    #测试 x 是否是 s 的成员  
x not in s    #测试 x 是否不是 s 的成员

数据类型总结：

按照存值对象分：

单个：数字，字符串

多个：列表，字典，元祖　

按照可变不可变分：

可变（不可hash）： 列表，字典

不可变（可hash）：数字，字符串，元祖

按访问顺序分：

顺序访问   ： 字符串，列表，元祖（序列类型）

key访问   ： 字典                           （映射类型）

 

 

 

 

 

 

 

 

 

 

 

　　

 

 

 

　　　

 

posted on 2017-07-23 16:20  keepDoing  阅读(9738)  评论(0)  编辑  收藏  举报

导航