python浮点数小数点前不足补0 python浮点数可以不带小数吗

转载

小鱼儿 2024-08-17 11:30:07

文章标签 python浮点数小数点前不足补0 python 数据结构与算法字符串 Python 文章分类 Python 后端开发

Python 数字

Python数字支持三种不同的数值类型：

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

>>> i = 3
>>> i
3

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）

>>> f = 1.23
>>> f 
1.23

>>> f = 1.29
>>> round(f, 1)    # 精确小数位，四舍五入
1.3

复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

>>> c = 1.23j
>>> c
1.23j

我们可以使用十六进制和八进制来代表整数：

>>> number = 0xA0F    # 十六进制
>>> print(number)
2575

>>> number=0o37    # 八进制
>>> print(number)
31

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3+e18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2-E12	4.53e-7j

Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

>>> f = 1.5
>>> int (f)    # 转换会去掉小数位，并不会四舍五入
1

float(x) 将x转换到一个浮点数。

>>> i = 12
>>> float(i)
12.0

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

>>> i = 11
>>> f = 1.1
>>> complex(i)
(11+0j)
>>> complex(f)
(1.1+0j)

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

>>> i = 11
>>> f = 1.1
>>> complex(i,f)
(11+1.1j)

Python 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

>>> s = 'Hello World!'
>>> s
'Hello World!'

字符串常用方法：

1、下标索引：

所谓“下标”，就是编号。
Python的下标从0开始计数。

s = 'abcd'
print(s[0])
> a
print(s[2])
> c

2、切片：

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。

s = '0123456'
print(s[2:])    # 取下标2~最后的字符
> 23456
print(s[0:3])    # 取下标0~2的字符
> 012
print(s[2:-2])    # 取下标2~倒数第2前的字符
> 234
print(s[::2])    # 跳一个取字符
> 0246
print(s[::-1])    # 倒序
> 6543210

3、find：

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

mystr.find(str, start=0, end=len(mystr))

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.find('World')
6
>>> mystr.find('e')
1
>>> mystr.find('Xorld')
-1

4、index：

跟find()方法一样，只不过如果str不在 mystr中会报一个异常

mystr.index(str, start=0, end=len(mystr))

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.index('World')
6
>>> mystr.index('Xorld')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

5、count：

返回 str在start和end之间在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.count('H')
3
>>> mystr.count('H',2)
2
>>> mystr.count('H',1,-4)
1

6、replace:

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

mystr.replace(str1, str2,  num)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.replace(" ","")
'HelloWorld!OhHeHe!!'
>>> mystr.replace("He","XX")
'XXllo World! Oh XXXX!!'
>>> mystr.replace("He","XX",1)
'XXllo World! Oh HeHe!!'

7、split：

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

mystr.split(str=" ", num)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.split(" ")
['Hello', 'World!', 'Oh', 'HeHe!!']
>>> mystr.split(" ",2)
['Hello', 'World!', 'Oh HeHe!!']

8、capitalize:

把字符串的第一个字符大写

mystr.capitalize()

实例：

>>> mystr = 'hello World! Oh HeHe!!'
>>> mystr.capitalize()
'Hello world! oh hehe!!'

9、title：

把字符串的每个单词首字母大写

mystr.title()

实例：

>>> mystr = 'hello world! oh hehe!!'
>>> mystr.title()
'Hello World! Oh Hehe!!'

10、startswith：

检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

mystr.startswith(obj)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.startswith('Hello')
True
>>> mystr.startswith('hello')
False

11、endswith：

检查字符串是否以obj结束，如果是返回True,否则返回 False

mystr.endswith(obj)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.endswith('HeHe!!')
True
>>> mystr.endswith('hehe!!')
False

12、lower：

转换 mystr 中所有大写字符为小写

mystr.lower()

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.lower()
'hello world! oh hehe!!'

13、upper：

转换 mystr 中的小写字母为大写

mystr.upper()

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.upper()
'HELLO WORLD! OH HEHE!!'

14、ljust：

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

mystr.ljust(width)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.ljust(30)
'Hello World! Oh HeHe!!        '
>>> mystr.ljust(3)
'Hello World! Oh HeHe!!'

15、rjust：

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.rjust(30)
'        Hello World! Oh HeHe!!'
>>> mystr.rjust(3)
'Hello World! Oh HeHe!!'

16、center：

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

mystr.center(width)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.center(30)
'    Hello World! Oh HeHe!!    '
>>> mystr.center(3)
'Hello World! Oh HeHe!!'

17、lstrip：

删除 mystr 左边的空白字符

mystr.lstrip()

实例：

>>> mystr = '     Hello     '
>>> mystr.lstrip()
'Hello     '

18、rstrip：

删除 mystr 字符右边的空白字符

mystr.rstrip()

实例：

>>> mystr = '     Hello     '
>>> mystr.rstrip()
'     Hello'

19、strip：

删除mystr字符串两端的空白字符

mystr.strip()

实例：

>>> mystr = '     Hello     '
>>> mystr.strip()
'Hello'

20、rfind：

类似于 find()函数，不过是从右边开始查找

mystr.rfind(str, start=0,end=len(mystr) )

21、rindex：

类似于 index()，不过是从右边开始

mystr.rindex( str, start=0,end=len(mystr))

22、partition：

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

实例：

>>> mystr = 'Hello World! Oh HeHe!!'
>>> mystr.partition(' ')
('Hello', ' ', 'World! Oh HeHe!!')
>>> mystr.partition('World!')
('Hello ', 'World!', ' Oh HeHe!!')

23、rpartition：

类似于 partition()函数,不过是从右边开始

mystr.rpartition(str)

24、splitlines：

按照行分隔，返回一个包含各行作为元素的列表

mystr.splitlines()

实例：

>>> mystr = 'Hello World!\nOh HeHe!!'
>>> mystr.splitlines()
['Hello World!', 'Oh HeHe!!']

25、isalpha：

如果 mystr 所有字符都是字母则返回 True，否则返回 False

mystr.isalpha()

实例：

>>> mystr = 'abc'
>>> mystr2 = 'a1'
>>> mystr.isalpha()
True
>>> mystr2.isalpha()
False

26、isdigit：

如果 mystr 所有字符都是数字则返回 True，否则返回 False

mystr.isdigit()

实例：

>>> mystr = '123'
>>> mystr2 = 'a1'
>>> mystr.isdigit()
True
>>> mystr2.isdigit()
False

27、isalnum：

如果 mystr 所有字符都是字母或数字则返回 True，否则返回 False

mystr.isalnum()

实例：

>>> mystr = 'ab12'
>>> mystr2 = 'a1*'
>>> mystr.isalnum()
True
>>> mystr2.isalnum()
False

28、isspace：

如果 mystr 中只包含空格，则返回 True，否则返回 False

mystr.isspace()

实例：

>>> mystr = '     '
>>> mystr2 = 'a    1  *'
>>> mystr.isspace()
True
>>> mystr2.isspace()
False

29、join：

mystr 中每个字符后面插入str，构造出一个新的字符串

mystr.join(str)

实例：

>>> mystr = '*'
>>> mylist = ['Hello', 'World', '!']
>>> mystr.join(mylist)
'Hello*World*!'

Python 列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

>>> list1 = ['a','b','c']
>>> list1
['a', 'b', 'c']
>>> list2 = [1, 2, 3]
>>> list2
[1, 2, 3]

访问列表中的值：

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

>>> list1 = ['a','b','c']
>>> list1[0]
'a'
>>> list1[0:2]
['a', 'b']

更新列表：

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

>>> list1 = ['a','b','c']
>>> list1[0] = 1
>>> list1
[1, 'b', 'c']
>>> list1.append('d')    # 添加新列表元素
>>> list1
[1, 'b', 'c', 'd']

删除列表元素：

可以使用 del 语句来删除列表的的元素，如下实例：

>>> list1 = ['a','b','c']
>>> del list1[1]    # 删除下标1的元素
>>> list1
['a', 'c']

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

>>> list1 = ['a','b','c']    
>>> len(list1)    # 长度
3

>>> list2 = [1, 2, 3]
>>> list1 + list2    # 组合
['a', 'b', 'c', 1, 2, 3]

>>> list3 = [1, '*'] * 3    # 重复
>>> list3
[1, '*', 1, '*', 1, '*']

>>> 2 in list3    # 包含元素否
False
>>> '*' in list3
True

>>> for i in list1:print( i )    # 迭代
a
b
c

列表常用方法：

1、len：

len() 方法返回列表元素个数

len(list)

实例：

>>> list1 = ['a','b','c']
>>> len(list1)
3

2、max：

max() 方法返回列表元素中的最大值（按ASCII码对照表），只能对单一类型的列表进行查找。

max(list)

实例：

>>> list1 = ['a','b','c']
>>> max(list1)
'c'

3、min：

min() 方法返回列表元素中的最小值，只能对单一类型的列表进行查找。

min(list)

实例：

>>> list1 = ['a','b','c']
>>> min(list1)
'a'

4、append：

append() 方法用于在列表末尾添加新的对象

list.append(obj)

实例：

>>> list1 = ['a','b','c']
>>> list1.append('d')
>>> list1
['a', 'b', 'c', 'd']

5、count：

count() 方法用于统计某个元素在列表中出现的次数

list.count(obj)

实例：

>>> list1 = ['a','b','c', 'a']
>>> list1.count('a')
2

6、extend：

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.extend(seq)

实例：

>>> list1 = ['a','b','c']
>>> list2 = ['a', 1, '*']
>>> list1.extend(list2)
>>> list1
['a', 'b', 'c', 'a', 1, '*']

7、index：

index() 函数用于从列表中找出某个值第一个匹配项的索引位置

list.index(obj)

实例：

>>> list1 = ['a','b','c', 'a']
>>> list1.index('a')
0

8、insert：

insert() 函数用于将指定对象插入列表的 index 位置前

list.insert(index, obj)

实例：

>>> list1 = ['a','b','c']
>>> list1.insert(1, 'x')
>>> list1
['a', 'x', 'b', 'c']

9、pop：

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.pop(obj=list[-1])

实例：

>>> list1 = ['a','b','c']
>>> list1.pop(1)
'b'
>>> list1
['a', 'c']

10、remove：

remove() 函数用于移除列表中某个值的第一个匹配项

list.remove(obj)

实例：

>>> list1 = ['a','b','c']
>>> list1.remove('c')
>>> list1
['a', 'b']

11、reverse：

reverse() 函数用于反向列表中元素

list.reverse()

实例：

>>> list1 = ['a','b','c']
>>> list1.reverse()
>>> list1
['c', 'b', 'a']

12、sort：

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数

list.sort([func])

实例：

>>> list1 = [1, 5, 9, 7, 0]
>>> list1.sort()
>>> list1
[0, 1, 5, 7, 9]

13、clear：

clear() 函数用于清空列表，类似于 del a[:]

list.clear()

实例：

>>> list1 = ['a','b','c']
>>> list1.clear()
>>> list1
[]

14、copy：

copy() 函数用于复制列表，类似于 a[:]

list.copy()

实例：

>>> list1 = ['a','b','c']
>>> list2 = list1.copy()
>>> list2
['a', 'b', 'c']

Python 元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

>>> tuple1 = (1, 2, 3)
>>> tuple1
(1, 2, 3)

如果元组只有一个元素时，需要在元素后面加个逗号，不然该元组会变成该元素类型。

>>> tuple1 = (1)
>>> type(tuple1)
<class 'int'>

>>> tuple1 = (1, )
>>> type(tuple1)
<class 'tuple'>

访问元组：

元组可以使用下标索引来访问元组中的值，如下实例：

>>> tuple1 = (1, 2, 3)
>>> tuple1[0]
1
>>> tuple1[0:2]
(1, 2)

元组常用方法：

1、len(tuple)

>>> tuple1 = (1, 2, 3)
>>> len(tuple1)
3

2、max(tuple)

>>> tuple1 = (1, 2, 3)
>>> max(tuple1)
3

3、min(tuple)

>>> tuple1 = (1, 2, 3)
>>> min(tuple1)
1

Python 字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：

>>> dict1 = {'a' : 10, 'b': 11, 'a' : '00'}
>>> dict1
{'a': '00', 'b': 11}

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

>>> dict1 = {['a'] : 10, 'b': 11, 'c' : '00'}
Traceback (most recent call last):
  File "<pyshell#126>", line 1, in <module>
    dict1 = {['a'] : 10, 'b': 11, 'c' : '00'}
TypeError: unhashable type: 'list'

>>> dict1 = {('a',) : 10, 'b': 11, 5 : '00'}
>>> dict1
{('a',): 10, 'b': 11, 5: '00'}

访问字典里的值：

把相应的键放入熟悉的方括弧，如下实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1
{'a': 10, 'b': 11, 'c': '00'}
>>> dict1['a']
10

修改字典：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1['a'] = 'xxx'
>>> dict1
{'a': 'xxx', 'b': 11, 'c': '00'}

删除字典元素：

能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> del dict1['a']    # 删除字典元素
>>> dict1
{'b': 11, 'c': '00'}

>>> dict1.clear()    # 清空字典
>>> dict1
{}

>>> del dict1    # 删除字典
>>> dict1
Traceback (most recent call last):
  File "<pyshell#138>", line 1, in <module>
    dict1
NameError: name 'dict1' is not defined

字典常用方法：

1、len：

计算字典元素个数，即键的总数

len(dict)

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> len(dict1)
3

2、str：

输出字典，以可打印的字符串表示

str(dict)

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> str(dict1)
"{'a': 10, 'b': 11, 'c': '00'}"

3、clear：

clear() 函数用于删除字典内所有元素

dict.clear()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.clear()
>>> dict1
{}

4、copy：

copy() 函数返回一个字典的浅复制

dict.copy()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict2 = dict1.copy()
>>> dict2
{'a': 10, 'b': 11, 'c': '00'}

5、fromkeys：

fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

dict.fromkeys(seq[, value]))

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict.fromkeys(dict1)
{'a': None, 'b': None, 'c': None}
>>> dict.fromkeys(dict1, 5)
{'a': 5, 'b': 5, 'c': 5}
>>> dict1
{'a': 10, 'b': 11, 'c': '00'}
>>> dict2 = dict.fromkeys(dict1, 5)
>>> dict2
{'a': 5, 'b': 5, 'c': 5}

6、get：

get() 函数返回指定键的值，如果值不在字典中返回默认值None

dict.get(key, default=None)

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.get('a')
10

7、in：

key in dict

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> 'a' in dict1
True
>>> 'd' in dict1
False

8、items：

items() 方法以列表返回可遍历的(键, 值) 元组数组

dict.items()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.items()
dict_items([('a', 10), ('b', 11), ('c', '00')])
>>> tuple(dict1.items())
(('a', 10), ('b', 11), ('c', '00'))

9、keys：

keys() 方法以列表返回一个字典所有的键

dict.keys()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.keys()
dict_keys(['a', 'b', 'c'])

10、setdefault：

setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值

dict.setdefault(key, default=None)

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.setdefault('a', 999)
10
>>> dict1.setdefault('d', 999)
999
>>> dict1
{'a': 10, 'b': 11, 'c': '00', 'd': 999}

11、update：

update() 函数把字典dict2的键/值对更新到dict里

dict.update(dict2)

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict2 = {'d' : 99, 'e': 88, 'f' : '77'}
>>> dict1.update(dict2)
>>> dict1
{'a': 10, 'b': 11, 'c': '00', 'd': 99, 'e': 88, 'f': '77'}

12、valuse：

values() 方法以列表返回字典中的所有值

dict.values()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.values()
dict_values([10, 11, '00'])
>>> list(dict1.values())
[10, 11, '00']

13、pop：

pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值

pop(key[,default])

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.pop('a')
10
>>> dict1
{'b': 11, 'c': '00'}

14、popitem：

popitem() 方法随机返回并删除字典中的一对键和值（一般删除末尾对）
如果字典已经为空，却调用了此方法，就报出KeyError异常

popitem()

实例：

>>> dict1 = {'a' : 10, 'b': 11, 'c' : '00'}
>>> dict1.popitem()
('c', '00')
>>> dict1
{'a': 10, 'b': 11}

通用方法：

1、type：

类型确认

>>> str1 = '5'
>>> type(str1)
<class 'str'>

2、format：

格式化输出

# 格式限定符
i = 18
print('{0},{1}'.format('long', i))
#> long,18
print('{},{}'.format('long', i))
#> long,18
print('{name},{age}'.format(age=i, name='long'))
#> long,18
#
# 填充与对齐
print('{:A>8}'.format('long'))    # 右对齐，>后面的数字代表长度，A代表填充字符
#> AAAAlong
print('{:B<8}'.format('long'))    # 左对齐
#> longBBBB
print('{:^8}'.format('long'))    # 居中，^前没有字符则默认空格填充
#>   long
#
# 精度，四舍五入
print('{:.2f}'.format(3.156))
#> 3.16
#
# 数字进制转换
print('{:b}'.format(15))    # 二进制转换
#> 1111
print('{:d}'.format(15))    # 十进制转换
#> 15
print('{:o}'.format(15))    # 八进制转换
#> 17
print('{:x}'.format(15))    # 十六进制转换
#> f
#
# 用逗号还能用来做金额的千位分隔符
print('{:,}'.format(1234567))

3、enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

enumerate(sequence, [start=0])

实例：

d = [1, 3, 5, 7]
for i,o in enumerate(d):
    print(i, o)
> 0 1
> 1 3
> 2 5
> 3 7

数据类型转换：

#############################################
s = 'abc'
l = ['a','a','b']
t = ('l','p','q')
d = {'a':1, 'b':2}

## 转字符串
print('元组转字符串.')
print (str(t))
print('列表转字符串.')
print (str(l))
print('字典转字符串.')
print (str(d))

## 转元组
print('####################')
print('字符串转元组')
print (tuple(s))
print('列表转元组')
print (tuple(l))
print('字典转元组')
print (tuple(d.items()))

## 转列表
print('####################')
print('字符串转列表')
print (list(s))
print('元组转列表')
print (list(t))
print('字典转列表')
print (list(d.items()))

## 转字典
print('####################')
tt = (['a',1],['b',2])
ttt = (('a',3),('b',4))
print('元组转字典(元组元素是元组)')
print (dict(tt))
print('元组转字典(元组元素是列表)')
print (dict(ttt))
print('####################')
ll = [['a',5],['b',6]]
lll = [('a',7),('b',8)]
print('列表转字典(列表元素是列表)')
print (dict(ll))
print('列表转字典(列表元素是元组)')
print (dict(lll))
#############################################

Python2 和 Python3 差异处理：

input处理：

# 这个写法用于处理python2和python3中输入函数差异性问题，因为Python3中没有raw_input函数，所以要捕获异常，然后修正为input函数。
try:
    name = raw_input("你叫什么名字？")
except Exception as e:
    name = input("你叫什么名字？")
finally:
    print("{0}真帅！".format(name))

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Java tinyint 映射类型 java如何映射到model

下一篇：java 统计采购数据 java数据采集平台

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯