Loading

python 数据类型

python 数据类型

一.string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#   * 重复输出字符串
print('hello'*2)
  
# [:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
print('helloworld'[2:])
  
# in  成员运算符 - 如果字符串中包含给定的字符返回 True
print('el' in 'hello')
  
# %   格式字符串
print('alex is a good teacher')
print('%s is a good teacher'%'alex')
  
  
# +   字符串拼接
a='123'
b='abc'
c='789'
d1=a+b+c
print(d1)
 
# +效率低,该用join
d2=''.join([a,b,c])
print(d2)
    123abc789

 字符串方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
string.capitalize()                                  #把字符串的第一个字符大写
# string.center(width)                                 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
# string.count(str, beg=0, end=len(string))            返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
# string.decode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
# string.encode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
# string.endswith(obj, beg=0, end=len(string))         检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
# string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
# string.find(str, beg=0, end=len(string))             检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
# string.index(str, beg=0, end=len(string))            跟find()方法一样，只不过如果str不在 string中会报一个异常.
# string.isalnum()                                     如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
# string.isalpha()                                     如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
# string.isdecimal()                                   如果 string 只包含十进制数字则返回 True 否则返回 False.
# string.isdigit()                                     如果 string 只包含数字则返回 True 否则返回 False.
# string.islower()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
# string.isnumeric()                                   如果 string 中只包含数字字符，则返回 True，否则返回 False
# string.isspace()                                     如果 string 中只包含空格，则返回 True，否则返回 False.
# string.istitle()                                     如果 string 是标题化的(见 title())则返回 True，否则返回 False
# string.isupper()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
# string.join(seq)                                     以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
# string.ljust(width)                                  返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
# string.lower()                                       转换 string 中所有大写字符为小写.
# string.lstrip()                                      截掉 string 左边的空格
# string.maketrans(intab, outtab])                     maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# max(str)                                             返回字符串 str 中最大的字母。
# min(str)                                             返回字符串 str 中最小的字母。
# string.partition(str)                                有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
# string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
# string.rfind(str, beg=0,end=len(string) )            类似于 find()函数，不过是从右边开始查找.
# string.rindex( str, beg=0,end=len(string))           类似于 index()，不过是从右边开始.
# string.rjust(width)                                  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
# string.rpartition(str)                               类似于 partition()函数,不过是从右边开始查找.
# string.rstrip()                                      删除 string 字符串末尾的空格.
# string.split(str="", num=string.count(str))          以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
# string.splitlines(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
# string.startswith(obj, beg=0,end=len(string))        检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
# string.strip([obj])                                  在 string 上执行 lstrip()和 rstrip()
# string.swapcase()                                    翻转 string 中的大小写
# string.title()                                       返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
# string.translate(str, del="")                        根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
# string.upper()                                       转换 string 中的小写字母为大写　　

 字符串格式化

1.   %

%[(name)][flags][width].[precision]typecode

　　

(name)      可选，用于选择指定的key
flags          可选，可供选择的值有:
+       右对齐；正数前加正好，负数前加负号；
-        左对齐；正数前无符号，负数前加负号；
空格    右对齐；正数前加空格，负数前加负号；
0        右对齐；正数前无符号，负数前加负号；用0填充空白处
width         可选，占有宽度
.precision   可选，小数点后保留的位数
typecode    必选
s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
o，将整数转换成 八  进制表示，并将其格式化到指定位置
x，将整数转换成十六进制表示，并将其格式化到指定位置
d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号

　　

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

1
2
3
4
5
6
7
8
9
10
11
tpl = "i am %s" % "alex"
  
tpl = "i am %s age %d" % ("alex", 18)
  
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
  
tpl = "percent %.2f" % 99.97623
  
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
  
tpl = "i am %.2f %%" % {"pp": 123.425556, }

 2、Format方式

[[fill]align][sign][#][0][width][,][.precision][type]

fill           【可选】空白处填充的字符
align        【可选】对齐方式（需配合width使用）
<，内容左对齐
>，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
^，内容居中
sign         【可选】有无符号数字
+，正号加正，负号加负；
 -，正号不变，负号加负；
空格 ，正号空格，负号加负；
#            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
，            【可选】为数字添加分隔符，如：1,000,000
width       【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type         【可选】格式化类型
传入” 字符串类型 “的参数
s，格式化字符串类型数据
空白，未指定类型，则默认是None，同s
传入“ 整数类型 ”的参数
b，将10进制整数自动转换成2进制表示然后格式化
c，将10进制整数自动转换为其对应的unicode字符
d，十进制整数
o，将10进制整数自动转换成8进制表示然后格式化；
x，将10进制整数自动转换成16进制表示然后格式化（小写x）
X，将10进制整数自动转换成16进制表示然后格式化（大写X）
传入“ 浮点型或小数类型 ”的参数
e， 转换为科学计数法（小写e）表示，然后格式化；
E， 转换为科学计数法（大写E）表示，然后格式化;
f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
g， 自动在e和f中切换
G， 自动在E和F中切换
%，显示百分比（默认显示小数点后6位）

　　

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
   
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
   
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
   
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
   
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
   
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
   
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
   
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
   
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
   
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
   
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
  
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

二.列表

1.新增

1
2
3
4
5
6
7
8
9
10
11
name = ["tom","jack","alex","Eric"]
name2 = [1,2,3]
  
name.append("niu")
    ['tom', 'jack', 'alex', 'Eric', 'niu']
  
name.insert(2,"niu")
    ['tom', 'jack', 'niu', 'alex', 'Eric']
  
name.extend(name2)
    ['tom', 'jack', 'alex', 'Eric', 1, 2, 3]

2.删除

1
2
3
4
5
6
7
8
9
10
11
12
name = ["tom","jack","tom","alex","Eric"]
 
name.remove("tom")    #删除元素，若有重复的，删除第一个
    ['jack', 'tom', 'alex', 'Eric']
 
name.pop(2)               #删除制定的元素，默认最后一个,返回删除的值
    ['tom', 'jack', 'alex', 'Eric']
 
del name                    #删除整个元素
 
del name[2]               #删除列表的元素
    ['tom', 'jack', 'alex', 'Eric']

3.排序&反转　

1
2
3
4
5
6
7
a = [2, 4, 6, 7, 3, 1, 5,]
 
a.sort()                #不能将数字和字母放在一起排序
    [1, 2, 3, 4, 5, 6, 7]
 
a.reverse()             #反转
    [5, 1, 3, 7, 6, 4, 2]

4.修改

1
name[2] = "alex"

5.其它

1
2
3
4
5
6
cmp(list1, list2)：比较两个列表的元素 (python3已丢弃)
len(list)：     列表元素个数
max(list)：   返回列表元素最大值
min(list)：   返回列表元素最小值
sorted(["A","a","M"])       排序
list.count(obj)：统计某个元素在列表中出现的次数 list.index(obj)：从列表中找出某个值第一个匹配项的索引位置　

三,字典

1.创建

1
2
3
4
dic1={'name':'alex','age':36,'sex':'male'}
dic2=dict((('name','alex'),))
print(dic1)
print(dic2)

 2.新增

1
2
3
4
5
6
7
8
9
10
dic3={}
  
dic3['name']='alex'
dic3['age']=18
print(dic3)#{'name': 'alex', 'age': 18}
  
a=dic3.setdefault('name','yuan')
b=dic3.setdefault('ages',22)
print(a,b)
print(dic3)

 3.查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dic3={'name': 'alex', 'age': 18}
  
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
  
print(dic3.items())
print(dic3.keys())
print(dic3.values())
  
print('name' in dic3)# py2:  dic3.has_key('name')
print(list(dic3.values()))

 4.改

1
2
3
4
5
6
dic3={'name': 'alex', 'age': 18}
  
dic3['name']='alvin'
dic4={'sex':'male','hobby':'girl','age':36}
dic3.update(dic4)
print(dic3)

 5.删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dic4={'name': 'alex', 'age': 18,'class':1}
  
  
# dic4.clear()
# print(dic4)
del dic4['name']
print(dic4)
  
a=dic4.popitem()
print(a,dic4)
  
# print(dic4.pop('age'))
# print(dic4)
  
# del dic4
# print(dic4)

 6.其它

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#dict.fromkeys
 
d1=dict.fromkeys(['host1','host2','host3'],'Mac')
print(d1)
  
d1['host1']='xiaomi'
print(d1)
#######
d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
print(d2)
d2['host1'][0]='xiaomi'
print(d2)
 
 
 
# sorted(dict) : 返回一个有序的包含字典所有key的列表
dic={5:'555',2:'222',4:'444'}
print(sorted(dic))　
 
 
 
#字典的遍历
dic5={'name': 'alex', 'age': 18}
  
for i in dic5:
    print(i,dic5[i])
  
for items in dic5.items():
    print(items)
for keys,values in dic5.items():
    print(keys,values)

四.元组

　　不可变类型
　　元素不可被修改，不能被增加或删除
 　　有序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
name = ("tom","jim","alex","tom")
 
#索引
name[2]
    alex
 
#切片
name[2][2]
    e
 
#可以被for循环，可迭代对象
for n in name:
    print(n)
 
name.count("tom")       #某个元素出现的次数
name.index("tom")       #返回某个元素的索引，如果重复返回第一个

五.集合

  • 去重，不同元素组成
  • 无序
  • 集合中的元素都是不可变类型

    1.关系 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    a = {1,2,3,4,5}
    b = {3,4,5,6,7}
     
    #交集
    print(a.intersection(b))
        {3, 4, 5}
    print(a & b)
        {3, 4, 5}
     
    # 差集
    print(a.difference(b))
        {1, 2}
    print(a - b)
        {1, 2}
     
    # 并集
    print(a.union(b))
        {1, 2, 3, 4, 5, 6, 7}
    print(a | b)
        {1, 2, 3, 4, 5, 6, 7}
     
    #集合之间是否有联系
    print(a.isdisjoint(b))
        True
     
    #子集 父集
    print(a.issubset(b))
        False
    print(a.issubset(b))
        False
     
    #对称差集  即互相不存在的打印
    print(a.symmetric_difference(b))
        {1, 2, 6, 7}
    print(a ^ b)
        {1, 2, 6, 7}

    2. 创建，新增

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #创建
    linux = {1,2,3,4,5,6}
    s2=set([1,2,3,4,5,6]) 
        
    python = {4,5,6,7,8,9}
     
     
    #增加  #update把传入的值拆分
     
    linux.update(python)
    　　{1, 2, 3, 4, 5, 6, 7, 8, 9}
    linux.update([7,8,9])
    　　{1, 2, 3, 4, 5, 6, 7, 8, 9}
    linux.update("tom")
    　　　　{1, 2, 3, 4, 5, 6, 'o', 'm', 't'}
     
    　　#add增加一个元素
    linux.add(7)
    　　{1, 2, 3, 4, 5, 6, 7}
    linux.add([7,8])　　#报错
    　　TypeError: unhashable type: 'list'

    3.删除　

    1
    2
    linux.remove(4)
        {1, 2, 3, 5, 6}
posted @ 2017-06-27 23:17  Meet~  阅读(343)  评论(0)  编辑  收藏  举报