f是一个python内部变量类型_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

二、数字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个空格

#打印结果为

hello999

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,