Python 数据类型

以下所有代码的首行#/usr/bin/env python都省略，Python版本默认为Python3.5

一、查看数据的类型：

data1 = 123       #数字不能加双引号，加双引号后默认会当做字符类型
data2 = "hello"
data3 = ["tom","joy"]
data4 = ("tom","joy")
data5 = {
    "name":"tom"
    "age":18
}

print(type(data1))
print(type(data2))
print(type(data3))
print(type(data4))
print(type(data5))

打印结果为

[root@bogon data_type]# ./type.py 
<type 'int'>
<type 'str'>
<type 'list'>
<type 'tuple'>
<type 'dict'>

二、数字int(整型)的常用方法

1、数学运算

n1 = 123
n2 = 456
n3 = 789
print(n1+n2+n3)   #就相当于数学上的n1+n2+n3
print(n1.__add__(n2).__add__(n3))  #实际上上一步就是调用的这个方法

2、bit_length() 数字转换为二进制后最少占的位数

n4 = 4
print(n4.bit_length())   #4转换为二进制后为00000111

三、字符str

1、str capitalize 首字母大写

a1 = "hello"
ret1 = a1.capitalize()
print(ret1)

[root@bogon data_type]# ./str.py 
Hello

2、字符串居中，center括号内，第一个字段为长度，第二个字段单引号内指定两边的填充符

a2 = "hello"
ret2 = a2.center(20,'*')  #20表示一个20个字符，*表示两边不够的用*填充
print(ret2)

#打印如下
*******hello********

3、count 子序列的个数,统计count后括号内字符串出现的次数,后面不加参数表示查询全部

#变量内每个字符串称为子序列

#可以指定长度查询，0,表示从第一个开始查询，4表示长度，从第一个开始到第四个，空格也算

a3 = "this is world"
ret3 = a3.count("is",0,4)
print(ret3)

#执行结果为
1

4、endswith 查看是否为指定字符结尾,是返回True，不是返回False，同样可以指定子序列

temp1 = "hello"
print(temp1.endswith("e",0,2)  #查看第二字段是否为e,不加后面的数字默认是查看最后一位

)

5、expandtabs,将tab换成空格，一个tab转换为8个空格,也可以指定转换为多少个空格

content = "hello\t999"   #\t表示tab键
print(content)
print(content.expandtabs())     #默认把tab键转换为8个空格
print(content.expandtabs(20))   #把tab键转转换W为20个空格

#打印结果为
hello   999
hello   999
hello               999

6、find寻找子序列的位置，子序列是自定义的，可以自定一个或多个字符串，空格也算

s = "tom hello"
print(s.find("l"))   #默认只寻找第一个匹配的字符

#打印结果为
6

7、format字符串的格式化

#{0}为占位符

s1 = "hello {0}, age {1}"   #{0}第一个占位符、{1}第二个占位符
print(s1)
new1 = s1.format('tom',19)  #tom赋值给第一个占位符，19赋值给第二个占位符
print(new1)

#打印结果为
hello {0}, age {1}
hello tom, age 19

8、index寻找子序列，没找到报错，类似于find，使用find就可以

9、isalnum 判断字符是否字母和数字, 是返回True，不是返回False

s2 = "tom123hello"
print(s2.isalnum())

10、isalpha 判断字符是否全部是字母

s3 = "hello"
print(s3.isalpha())

11、isdigit 检测是否都为数字，注意：是检测字符串是否都是数字

s4 = "1234"
print(s4.isdigit())

12、islower检查是否全部为小写

s5 = "hello"
print(s5.islower())

13、isspace判断是否是空格

s6 = " "
print(s6.isspace())

14、istitle判断是否是标题,每个单词的首字母为大写

s7 = "The School"
print(s7.istitle())

15、isupper判断是否全部是大写

s8 = "HELLO"
print(s8.isupper())

16、join 连接,指定连接符，将字符串用指定的连接符连接起来,可以不加，不加时为空

li = ["tom","eric"]   #列表
yz = ("joy","hello")  #元组
s9= "_".join(li)      #列表li连接符为_
s10 = "@".join(yz)    #元组yz连接符为@
print(s9)
print(s10)

#打印结果为
tom_eric
joy@hello

17、ljust内容左对齐，右侧填充,也可以指定宽度

s11 = "hello"
print(s11.ljust(20,"*"))   #共20个字符，右侧不够的用*填充

#打印结果为
hello***************

18、lower把字符串变小写

s12 = "HELLO"
print(s12.lower())

19、移除左边的空格lstrip

s13 = " hello "
print(s13.lstrip())

20、rstrip移除右边的空格

s14 = " hello "
print(s14.rstrip())

21、strip 左右两边的空格全部去掉,也可以移除指定的字符，但是只能移除左右两边的，字符串中的无法移除

s15 = " hello "
print(s15.strip())

>>> '**** SPAM * for * everyone!!! ****'.strip(' *!')
'SPAM * for * everyone'

22、partition，指定的分隔符，

s16 = "hello SB hello"
fen = s16.partition("SB") #以SB作为分隔符
print(fen)

#打印结果为
('hello ', 'SB', ' hello')

23、replace替换指定字符，可以指定范围

s17 = "hello SB hello"
temp17 = s17.replace("SB",'BB')
print(temp17)

#打印结果为
hello BB hello

24、rfind 类似find，从右往左找

25、rjust 右对齐

26、rsplit,f分割，指定分割符，将分隔符去除，显示其他部分

s18 = "hellohello"
print(s18.split("e")

#打印结果为
['h', 'lloh', 'llo']

27、split,分片，join的逆方法，把字符串按照指定的分割方式，生成一个序列，即为列表，如果不提供分隔符，默认以空格作为空格符

'1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']

28、startswith判断时候某一个字符或字符串开头，相对于endswith

29、swapcase 大小写互换

30、title变换成标题，即把字符串变为首字母大写

31、upper变大写

32、字符串切片，索引切片[0], 0代表第一个切片字符

#[0:2]

#len（），表示查看字符串的长度

s19 = "hello"
print(s19[0])
print(s19[0:2])   #s19分片字符串，按照顺序，大于0小于2，也就是从第一个字段开始（表示0），长度为2（表示第一个和第二位）
print(len(s19))

#打印结果为
he

33、循环,显示字符串内的每个元素

s20 = "hello tom, you is DSB"
start = 0
while start < len(s20):    #len(s20)，表示s20的长度
    temp = s20[start]      #s20[start]表示每个元素
    print(temp)
    start += 1

34、for循环,break,continu,适用

s20 = "hello tom, you is DSB"
start = 0
for item in s20:
    if item == "l":
        continue
    print(item)

#for循环语法
#for 变量名  in  列表（可以是变量）：
#    print(变量名)

四、列表（list）,中括号[]括起来

name_list = ["erix","egon","tony","tom"]
print(name_list)

1、索引、切片

name_list = ["erix","egon","tony","tom"]
print(name_list[0])   #第一个元素
print(name_list[0:2]) #前两个元素，2表示长度
print(name_list[2:len(name_list)])  #指定范围，从第三个到最后一个

#打印结果为
erix
['erix', 'egon']
['tony', 'tom']

2、for循环，列出所有列表里的元素

name_list = ["erix","egon","tony","tom"]
for i in name_list:
    print(i)


#打印结果
erix
alex
tony
tom

3、append追加，在列表末尾插入指定元素

name_list = ["erix","egon","tony","tom"]
name_list.append("server")
print(name_list)

#打印结果为
['erix', 'alex', 'tony', 'tom', 'server']

4、count统计元素在列表中出现的次数

name_list = ["erix","egon","tony","tom"]
print(name_list.count("tom"))

#打印结果为
1

5、extend扩展插入，把整个列表插入到另外一个列表内

name_list = ["erix","egon","tony","tom"]
age_list = ['14','15','16','17']
name_list.extend(age_list)   #将age_list列表插入到name_list列表中
print(name_list)

#打印结果为
['erix', 'egon', 'tony', 'tom', '4', '15', '16', '17']

6、index获取元素在列表中的索引

name_list = ["erix","egon","tony","tom"]
print(name_list.index("tom"))  

#打印结果为
3   #索引是从0开始

7、insert插入，将元素插入到列表中

name_list = ["erix","egon","tony","tom"]
name_list.insert(20,"SB")
print(name_list)

#打印结果为
['erix', 'egon', 'tony', 'tom', 'SB']

8、pop，删除列表的最后一个元素，同时可以赋值给另外一个变量，也可以删除指定索引的元素

name_list = ["erix","egon","tony","tom"]
a1 = name_list.pop()
print(name_list)
print(a1)

#打印结果为
['erix', 'egon', 'tony']
tom

9、remove,移除列表中的元素，只移除从左边找到的第一个元素

name_list = ["erix","egon","tony","tom"]
name_list.remove("egon")
print(name_list)

#打印结果为
['erix', 'tony', 'tom']

10、reverse,反转，将列表从右往左显示

name_list = ["erix","egon","tony","tom"]
name_list.reverse()
print(name_list)

#打印结果为
['tom', 'tony', 'egon', 'erix']

11、sort排序，是根据元素的首字母排序，字符我整型数字不能直接在一起排序，整型转换成字符后排在前面，是根据在ASCII码表的顺序排列的。

name_list = ["erix","egon","tony","tom"]
name_list.sort()
print(name_list)

#打印结果为
['egon', 'erix', 'tom', 'tony']

12、del 删除指定索引位置的元素

name_list = ["erix","egon","tony","tom"]
del name_list[1]
print(name_list)

#打印结果为
['erix', 'tony', 'tom']

五、tupple元组

元组和列表类似，用小括号括起，用发基本相同，只是，元组是无法修改的，而列表是可以的

name_tupple = ('alex','eric','tom')
print(name_tupple)
#打印结果为
('alex', 'eric', 'tom')

六、dict字典

字典的每一个元素就是一个键值对（key:value）,用大括号‘{}’括起来，使用duct函数可以创建字典

>>> product_list = [['0','quit'],['iphone',5800],['computer',7000],['mouse',99],['keyboard',198],['book',69]]
>>> dic = dict(product_list)
>>> print(dic)
{'0': 'quit', 'computer': 7000, 'iphone': 5800, 'keyboard': 198, 'mouse': 99, 'book': 69}

>>> d = dict(name='tom',age=29)   #也可以直接通过关键字创建字典
>>> d
{'age': 29, 'name': 'tom'}

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
print(name_info)

#打印结果为
{'age': 73, 'name': 'tom', 'gender': 'M'}

1、索引，key即为索引，没有切片

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
print(name_info['name'])
print(name_info['age'])
print(name_info['gender'])

#打印结果为
tom
73
M

2、for循环，默认输出所有key

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
for i in name_info:
    print(i)
    
#打印结果为
age
name
gender



###循环获取key
for i in name_info.keys():
    print(i)
#循环获取value
for i in name_info.values():
    print(i)
#获取所有键值对
for i in name_info.items():
    print(i)

3、获取所有的键，值，键值对

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
print(name_info.keys())  #打印所有的键
print(name_info.values()) #打印所有的值
print(name_info.itmes())  #打印所有的键值对

#打印结果为
dict_keys(['name', 'age', 'gender'])
dict_values(['tom', 73, 'M'])
dict_items([('age', 73), ('name', 'tom'), ('gender', 'M')])

4、for循环，分别获取键和值

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
for k,v in name_info.items():
    print(k)
    print(v)
for i in name_info:
    print(i,name_info[i])

#打印结果为
name
tom
gender
M
age
73

5、clear，清楚所有内容

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
name_info.clear()
print(name_info)

#打印结果为
{}

6、get,根据key获取值，当值没存在时，可以指定一个返回值，根据索引取值时，但不存在时会报错，get不会报错，默认会返回none

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
print(name_info.get('name'))
print(name_info.get('aaa'))

#打印结果为
tom
None

7、has_key，检查字典中的指定key是否存在，存在返回True,不存在返回False，这个方法在Python2中有效，在Python3中已经取消，并用in代替了

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
ret = 'age' in name_info.keys()
print(ret)
ret1 = 'aaa' in name_info.keys()
print(ret1)

#打印结果为
True
False

8、pop，移除，移除指定的key,同时可以把移除的value赋值给变量，如果删除的key不存在，会报错，也可以指定返回值

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
a1 = name_info.pop('name')
print(name_info)
print(a1)

#打印结果为
{'age': 73, 'gender': 'M'}
tom

9、popitem,随机删除字典的key，类似于列表中的pop，同时可以把移除的赋值给一个变量

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
a1 = name_info.popitem()
print(name_info)
print(a1)

#打印结果为
{'name': 'tom', 'age': 73}
('gender', 'M')

10、update,批量更新，把指定的字典更新到另外一个字典内

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
test = {
    "user":"joy",
    "class":"2"
}

name_info.update(test)
print(name_info)

#打印结果为
{'name': 'tom', 'age': 73, 'gender': 'M', 'user': 'joy', 'class': '2'}

11、del 删除字典的元素（键值对）

name_info = {
    "name":"tom",
    "age":73,
    "gender":'M'
}
del name_info['name']
print(name_info)

#打印结果为
{'age': 73, 'gender': 'M'}

12、 fromkeys,

来源：https://www.cnblogs.com/baomanji/p/6591095.html